["<!-- 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 setFBCookie(cname, cvalue, exdays) {\n            const d = new Date();\n            d.setTime(d.getTime() + (exdays * 24 * 60 * 60 * 1000));\n            let expires = \"expires=\" + d.toUTCString();\n            document.cookie = cname + \"=\" + cvalue + \";\" + expires + \";path=/\";\n        }\n\n        function getUrlParameter(param) {\n            const urlParams = new URLSearchParams(window.location.search);\n            return urlParams.get(param);\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\", '723660758207567');\n        let eventTime = Date.now();\n        let fbp = getFBCookie('_fbp');\n        let fbc = getFBCookie('_fbc');\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                let post = {\n              domain: 'start.plugandpay.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://start.plugandpay.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            // Check if this event has already been tracked to prevent duplicate tracking\n            let eventCookieName = 'fb_event_' + eventID;\n            let eventTracked = getFBCookie(eventCookieName);\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                fbq(\"track\", 'PageView', fbData, { eventID: eventID });\n\n                // Set cookie to mark this event as tracked (expires in 30 days)\n                setFBCookie(eventCookieName, '1', 30);\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 setFBCookie(cname, cvalue, exdays) {\n            const d = new Date();\n            d.setTime(d.getTime() + (exdays * 24 * 60 * 60 * 1000));\n            let expires = \"expires=\" + d.toUTCString();\n            document.cookie = cname + \"=\" + cvalue + \";\" + expires + \";path=/\";\n        }\n\n        function getUrlParameter(param) {\n            const urlParams = new URLSearchParams(window.location.search);\n            return urlParams.get(param);\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\", '723660758207567');\n        let eventTime = Date.now();\n        let fbp = getFBCookie('_fbp');\n        let fbc = getFBCookie('_fbc');\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                let post = {\n              domain: 'start.plugandpay.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://start.plugandpay.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            // Check if this event has already been tracked to prevent duplicate tracking\n            let eventCookieName = 'fb_event_' + eventID;\n            let eventTracked = getFBCookie(eventCookieName);\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                fbq(\"track\", 'PageView', fbData, { eventID: eventID });\n\n                // Set cookie to mark this event as tracked (expires in 30 days)\n                setFBCookie(eventCookieName, '1', 30);\n            }\n        }\n\n    </script>\n    <!-- End Facebook Pixel Code -->\n","attributes":null},{"name":"TikTok Data","location":"head","consentType":"statistical","content":"<!-- TikTok Pixel Code Start -->\n<script>\n!function (w, d, t) {\n  w.TiktokAnalyticsObject=t;var ttq=w[t]=w[t]||[];ttq.methods=[\"page\",\"track\",\"identify\",\"instances\",\"debug\",\"on\",\"off\",\"once\",\"ready\",\"alias\",\"group\",\"enableCookie\",\"disableCookie\",\"holdConsent\",\"revokeConsent\",\"grantConsent\"],ttq.setAndDefer=function(t,e){t[e]=function(){t.push([e].concat(Array.prototype.slice.call(arguments,0)))}};for(var i=0;i<ttq.methods.length;i++)ttq.setAndDefer(ttq,ttq.methods[i]);ttq.instance=function(t){for(\nvar e=ttq._i[t]||[],n=0;n<ttq.methods.length;n++)ttq.setAndDefer(e,ttq.methods[n]);return e},ttq.load=function(e,n){var r=\"https://analytics.tiktok.com/i18n/pixel/events.js\",o=n&&n.partner;ttq._i=ttq._i||{},ttq._i[e]=[],ttq._i[e]._u=r,ttq._t=ttq._t||{},ttq._t[e]=+new Date,ttq._o=ttq._o||{},ttq._o[e]=n||{};n=document.createElement(\"script\")\n;n.type=\"text/javascript\",n.async=!0,n.src=r+\"?sdkid=\"+e+\"&lib=\"+t;e=document.getElementsByTagName(\"script\")[0];e.parentNode.insertBefore(n,e)};\n\n\n  ttq.load('CPUN20JC77UA4KP63OF0');\n  ttq.page();\n}(window, document, 'ttq');\n</script>\n<!-- TikTok Pixel Code End -->\n","attributes":[]}]