["<!-- Facebook Pixel Code -->\n    <script>\n        function getFBCookie(cname) {\n            let name = cname + \"=\";\n            let decodedCookie = decodeURIComponent(document.cookie);\n            let ca = decodedCookie.split(';');\n            for (let i = 0; i < ca.length; i++) {\n                let c = ca[i];\n                while (c.charAt(0) == ' ') {\n                    c = c.substring(1);\n                }\n                if (c.indexOf(name) == 0) {\n                    return c.substring(name.length, c.length);\n                }\n            }\n            return \"\";\n        }\n\n        function getUrlParameter(param) {\n            const urlParams = new URLSearchParams(window.location.search);\n            return urlParams.get(param);\n        }\n\n        \n                \n        !function (f, b, e, v, n, t, s) {\n            if (f.fbq) return;\n            n = f.fbq = function () {\n                n.callMethod ?\n                    n.callMethod.apply(n, arguments) : n.queue.push(arguments);\n            };\n            if (!f._fbq) f._fbq = n;\n            n.push = n;\n            n.loaded = !0;\n            n.version = \"2.0\";\n            n.queue = [];\n            t = b.createElement(e);\n            t.async = !0;\n            t.src = v;\n            s = b.getElementsByTagName(e)[0];\n            s.parentNode.insertBefore(t, s);\n        }(window, document, \"script\",\n            \"https://connect.facebook.net/en_US/fbevents.js\");\n\n        fbq(\"init\", '1611211853997946');\n                let eventTime = Date.now();\n        let fbp = getFBCookie('_fbp');\n        let fbc = getFBCookie('_fbc');\n        let fbclid = getUrlParameter('fbclid');\n\n        \n        if (fbc === \"\" && fbclid) {\n            fbc = `fb.1.${eventTime}.${fbclid}`;\n        }\n\n                        let txId = getUrlParameter('form_submission_id') ?? eventTime;\n\n                    let event = getUrlParameter('form_submission_id') ? 'Lead' : 'PageView';\n        \n                    eventID = `page.${event}.tx_${txId}`;\n        \n        \n                let deduplicationKey = null;\n\n                        let post = {\n              domain: 'scheffenbergh.nl',\n              conversion_type: 'PageView',\n              url: window.location.href,\n              event_id: eventID,\n              event_time: eventTime,\n            };\n\n            if (getUrlParameter(\"pagese\")) {\n              post.email = getUrlParameter(\"pagese\");\n            }\n\n            if (getUrlParameter(\"pagesf\")) {\n              post.first_name = getUrlParameter(\"pagesf\");\n            }\n\n            if (getUrlParameter(\"pagesl\")) {\n              post.last_name = getUrlParameter(\"pagesl\");\n            }\n\n            if (fbp !== \"\") {\n              post.fbp = fbp;\n            }\n\n            if (fbc !== \"\") {\n              post.fbc = fbc;\n            }\n\n            const url = 'https://scheffenbergh.nl/client/facebook-conversion/events';\n            let xhr = new XMLHttpRequest();\n            xhr.open(\"POST\", url, true);\n            xhr.setRequestHeader(\"Content-type\", \"application/json; charset=UTF-8\");\n            xhr.setRequestHeader(\"X-Requested-With\", \"XMLHttpRequest\");\n            xhr.send(JSON.stringify(post));\n        \n        if (event) {\n            let eventStorageKey = deduplicationKey ? 'fb_event_' + deduplicationKey : null;\n            let eventTracked = false;\n            if (eventStorageKey) {\n                try {\n                    eventTracked = localStorage.getItem(eventStorageKey) !== null;\n                } catch (e) {\n                    // localStorage may be unavailable (private mode / disabled storage); fire anyway.\n                }\n            }\n\n            if (!eventTracked) {\n                let fbData = {};\n\n                if (fbp !== \"\") {\n                    fbData.fbp = fbp;\n                }\n\n                if (fbc !== \"\") {\n                    fbData.fbc = fbc;\n                }\n\n                \n                \n                \n                fbq(\"track\", 'PageView', fbData, { eventID: eventID });\n\n                if (eventStorageKey) {\n                    try {\n                        localStorage.setItem(eventStorageKey, eventTime.toString());\n                    } catch (e) {\n                        // Ignore storage failures (quota / private mode).\n                    }\n                }\n            }\n        }\n\n    </script>\n    <!-- End Facebook Pixel Code -->\n",{"name":"fb","location":"head","consentType":"statistical","content":"<!-- Facebook Pixel Code -->\n    <script>\n        function getFBCookie(cname) {\n            let name = cname + \"=\";\n            let decodedCookie = decodeURIComponent(document.cookie);\n            let ca = decodedCookie.split(';');\n            for (let i = 0; i < ca.length; i++) {\n                let c = ca[i];\n                while (c.charAt(0) == ' ') {\n                    c = c.substring(1);\n                }\n                if (c.indexOf(name) == 0) {\n                    return c.substring(name.length, c.length);\n                }\n            }\n            return \"\";\n        }\n\n        function getUrlParameter(param) {\n            const urlParams = new URLSearchParams(window.location.search);\n            return urlParams.get(param);\n        }\n\n        \n                \n        !function (f, b, e, v, n, t, s) {\n            if (f.fbq) return;\n            n = f.fbq = function () {\n                n.callMethod ?\n                    n.callMethod.apply(n, arguments) : n.queue.push(arguments);\n            };\n            if (!f._fbq) f._fbq = n;\n            n.push = n;\n            n.loaded = !0;\n            n.version = \"2.0\";\n            n.queue = [];\n            t = b.createElement(e);\n            t.async = !0;\n            t.src = v;\n            s = b.getElementsByTagName(e)[0];\n            s.parentNode.insertBefore(t, s);\n        }(window, document, \"script\",\n            \"https://connect.facebook.net/en_US/fbevents.js\");\n\n        fbq(\"init\", '1611211853997946');\n                let eventTime = Date.now();\n        let fbp = getFBCookie('_fbp');\n        let fbc = getFBCookie('_fbc');\n        let fbclid = getUrlParameter('fbclid');\n\n        \n        if (fbc === \"\" && fbclid) {\n            fbc = `fb.1.${eventTime}.${fbclid}`;\n        }\n\n                        let txId = getUrlParameter('form_submission_id') ?? eventTime;\n\n                    let event = getUrlParameter('form_submission_id') ? 'Lead' : 'PageView';\n        \n                    eventID = `page.${event}.tx_${txId}`;\n        \n        \n                let deduplicationKey = null;\n\n                        let post = {\n              domain: 'scheffenbergh.nl',\n              conversion_type: 'PageView',\n              url: window.location.href,\n              event_id: eventID,\n              event_time: eventTime,\n            };\n\n            if (getUrlParameter(\"pagese\")) {\n              post.email = getUrlParameter(\"pagese\");\n            }\n\n            if (getUrlParameter(\"pagesf\")) {\n              post.first_name = getUrlParameter(\"pagesf\");\n            }\n\n            if (getUrlParameter(\"pagesl\")) {\n              post.last_name = getUrlParameter(\"pagesl\");\n            }\n\n            if (fbp !== \"\") {\n              post.fbp = fbp;\n            }\n\n            if (fbc !== \"\") {\n              post.fbc = fbc;\n            }\n\n            const url = 'https://scheffenbergh.nl/client/facebook-conversion/events';\n            let xhr = new XMLHttpRequest();\n            xhr.open(\"POST\", url, true);\n            xhr.setRequestHeader(\"Content-type\", \"application/json; charset=UTF-8\");\n            xhr.setRequestHeader(\"X-Requested-With\", \"XMLHttpRequest\");\n            xhr.send(JSON.stringify(post));\n        \n        if (event) {\n            let eventStorageKey = deduplicationKey ? 'fb_event_' + deduplicationKey : null;\n            let eventTracked = false;\n            if (eventStorageKey) {\n                try {\n                    eventTracked = localStorage.getItem(eventStorageKey) !== null;\n                } catch (e) {\n                    // localStorage may be unavailable (private mode / disabled storage); fire anyway.\n                }\n            }\n\n            if (!eventTracked) {\n                let fbData = {};\n\n                if (fbp !== \"\") {\n                    fbData.fbp = fbp;\n                }\n\n                if (fbc !== \"\") {\n                    fbData.fbc = fbc;\n                }\n\n                \n                \n                \n                fbq(\"track\", 'PageView', fbData, { eventID: eventID });\n\n                if (eventStorageKey) {\n                    try {\n                        localStorage.setItem(eventStorageKey, eventTime.toString());\n                    } catch (e) {\n                        // Ignore storage failures (quota / private mode).\n                    }\n                }\n            }\n        }\n\n    </script>\n    <!-- End Facebook Pixel Code -->\n","attributes":null},{"name":"Google Tag Manager","location":"head","consentType":"marketing","content":"<!-- Google Tag Manager -->\n<script>(function(w,d,s,l,i){w[l]=w[l]||[];w[l].push({'gtm.start':\nnew Date().getTime(),event:'gtm.js'});var f=d.getElementsByTagName(s)[0],\nj=d.createElement(s),dl=l!='dataLayer'?'&l='+l:'';j.async=true;j.src=\n'https://www.googletagmanager.com/gtm.js?id='+i+dl;f.parentNode.insertBefore(j,f);\n})(window,document,'script','dataLayer','GTM-WNDLNRCS');</script>\n<!-- End Google Tag Manager -->\n","attributes":[]}]
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