{"id":58377,"date":"2026-07-28T21:39:16","date_gmt":"2026-07-28T21:39:16","guid":{"rendered":"https:\/\/senseadelic.com\/?page_id=58377"},"modified":"2026-07-29T00:04:24","modified_gmt":"2026-07-29T00:04:24","slug":"glitterverpakking","status":"publish","type":"page","link":"https:\/\/senseadelic.com\/nl\/glitter-wrap\/","title":{"rendered":"Glitterverpakking"},"content":{"rendered":"\t\t<div data-elementor-type=\"wp-page\" data-elementor-id=\"58377\" class=\"elementor elementor-58377\" data-elementor-post-type=\"page\">\n\t\t\t\t<div class=\"elementor-element elementor-element-3f4f715 e-flex e-con-boxed e-con e-parent\" data-id=\"3f4f715\" data-element_type=\"container\" data-e-type=\"container\">\n\t\t\t\t\t<div class=\"e-con-inner\">\n\t\t\t\t<div class=\"elementor-element elementor-element-1e9c8bb elementor-widget elementor-widget-html\" data-id=\"1e9c8bb\" data-element_type=\"widget\" data-e-type=\"widget\" data-widget_type=\"html.default\">\n\t\t\t\t\t<div id=\"glitter-wrap-container\" style=\"position: absolute; inset: 0; width: 100%; height: 100%; overflow: hidden; pointer-events: none; z-index: 0; background-color: #050505;\">\n  <canvas id=\"glitter-wrap-canvas\" style=\"display: block; width: 100%; height: 100%;\"><\/canvas>\n<\/div>\n\n<script>\n\/\/ Glitter Wrap \u2014 Originkit\n\/\/ Using component defaults.\n\nimport { CSSProperties, useEffect, useRef } from \"react\"\nconst RenderTarget = {\n    current: () => \"preview\",\n    canvas: \"canvas\",\n    export: \"export\",\n    thumbnail: \"thumbnail\",\n    preview: \"preview\",\n}\n\n\/**\n * GlitterWrap \u2014 animated starfield warp tunnel with glittering sparkle flashes.\n *\n * @framerSupportedLayoutWidth any-prefer-fixed\n * @framerSupportedLayoutHeight any-prefer-fixed\n * @framerIntrinsicWidth 600\n * @framerIntrinsicHeight 400\n *\/\n\n\/\/ Pure utility \u2014 hoisted to module scope so it is never re-created on render.\nfunction parseColor(input: string): [number, number, number, number] {\n    if (!input) return [255, 255, 255, 1]\n    const s = input.trim()\n    if (s.startsWith(\"#\")) {\n        let hex = s.slice(1)\n        if (hex.length === 3) {\n            hex = hex\n                .split(\"\")\n                .map((c) => c + c)\n                .join(\"\")\n        }\n        const num = parseInt(hex, 16)\n        return [(num >> 16) & 255, (num >> 8) & 255, num & 255, 1]\n    }\n    const m = s.match(\/rgba?\\(([^)]+)\\)\/i)\n    if (m) {\n        const parts = m[1].split(\",\").map((p) => parseFloat(p.trim()))\n        return [\n            parts[0] || 0,\n            parts[1] || 0,\n            parts[2] || 0,\n            parts[3] == null ? 1 : parts[3],\n        ]\n    }\n    return [255, 255, 255, 1]\n}\n\nexport default function GlitterWrap(props: Props) {\n    props = { ...COMPONENT_DEFAULTS, ...props }\n    \/\/ Only values the wrapper element needs are destructured here; all\n    \/\/ animated params are read live from propsRef inside the draw loop.\n    const { style } = props\n\n    const containerRef = useRef<HTMLDivElement | null>(null)\n    const canvasRef = useRef<HTMLCanvasElement | null>(null)\n    const rafRef = useRef<number | null>(null)\n    const sizeRef = useRef({ w: 0, h: 0, dpr: 1 })\n    \/\/ Freeze ONLY on true static renders (export \/ thumbnail). The Framer\n    \/\/ canvas and Preview run the live rAF loop so the starfield animates while\n    \/\/ editing. Gating on useIsStaticRenderer() (true on canvas) is what\n    \/\/ previously froze the canvas to a few warm-up frames.\n    const renderTarget = RenderTarget.current()\n    const isStatic =\n        renderTarget === RenderTarget.export ||\n        renderTarget === RenderTarget.thumbnail\n\n    \/\/ Latest props, read fresh each frame so control tweaks don't tear down\n    \/\/ and rebuild the whole animation (which would re-init every star + RAF).\n    const propsRef = useRef(props)\n    propsRef.current = props\n\n    \/\/ Cached parsed colors \u2014 only recomputed when the string value changes.\n    \/\/ This avoids 4 string-parse + regex calls per frame (240\/sec at 60fps).\n    const colorCacheRef = useRef({\n        color1: \"\" as string,\n        color2: \"\" as string,\n        color3: \"\" as string,\n        parsed1: [255, 255, 255, 1] as [number, number, number, number],\n        parsed2: [177, 158, 239, 1] as [number, number, number, number],\n        parsed3: [205, 217, 255, 1] as [number, number, number, number],\n    })\n\n    const getCachedColors = () => {\n        const p = propsRef.current\n        const c = colorCacheRef.current\n        if (p.color1 !== c.color1) {\n            c.color1 = p.color1\n            c.parsed1 = parseColor(p.color1)\n        }\n        if (p.color2 !== c.color2) {\n            c.color2 = p.color2\n            c.parsed2 = parseColor(p.color2)\n        }\n        if (p.color3 !== c.color3) {\n            c.color3 = p.color3\n            c.parsed3 = parseColor(p.color3)\n        }\n        return c\n    }\n\n    useEffect(() => {\n        const container = containerRef.current\n        const canvas = canvasRef.current\n        if (!container || !canvas) return\n        const ctx = canvas.getContext(\"2d\")\n        if (!ctx) return\n\n        type Star = {\n            \/\/ Position in normalized space relative to centre\n            x: number\n            y: number\n            z: number \/\/ depth: 1 = far, ~0 = near\n            \/\/ Previous projected screen position (for streaks)\n            px: number\n            py: number\n            seed: number \/\/ unique phase for turbulence + glitter\n            vmul: number \/\/ per-star speed multiplier (breaks up cohorts)\n            colorIdx: number\n            flashUntil: number \/\/ elapsed seconds until which it's flashing\n            nextFlash: number \/\/ elapsed seconds at which it can flash again\n        }\n\n        const stars: Star[] = []\n        \/\/ Elapsed wall-clock seconds. Turbulence + glitter cadence key off this\n        \/\/ instead of a frame counter, so motion stays constant under variable\n        \/\/ frame timing (16\/16\/22\/13ms\u2026) rather than jittering with each hitch.\n        let elapsed = 0\n        let lastT = performance.now()\n\n        \/\/ Map the integer UI controls to their internal working ranges in one\n        \/\/ place, so the physics\/render code stays in convenient units.\n        const cfg = () => {\n            const p = propsRef.current\n            return {\n                reverse: p.reverse,\n                density: p.density, \/\/                1\u2013100, used raw\n                stepZ: p.speed * 0.0008, \/\/           speed 1\u201310\n                focalDepth: p.focalDepth \/ 100, \/\/    1\u201330  -> 0.01\u20130.30\n                starScale: p.starSize * 0.15, \/\/      0\u201320  -> 0\u20133.0\n                turbulence: p.turbulence * 0.2, \/\/    0\u201310  -> 0\u20132\n                glitter: p.glitterIntensity * 0.1, \/\/ 0\u201310  -> 0\u20131\n                brightness: Math.min(1, p.brightness \/ 100), \/\/ 0\u2013100%\n                trail: p.trailAmount \/ 100, \/\/        0\u2013100%\n            }\n        }\n\n        const resetStar = (s: Star, initial = false) => {\n            const { density, reverse, focalDepth, glitter } = cfg()\n            \/\/ Spawn at a random angle around centre, at near-far depth\n            const angle = Math.random() * Math.PI * 2\n            \/\/ density controls how spread out the spawn radius is\n            const radius = (0.2 + Math.random() * 0.8) * (density \/ 15)\n            s.x = Math.cos(angle) * radius\n            s.y = Math.sin(angle) * radius\n            \/\/ Forward: spawn far (z=1), travel toward focal point and outward.\n            \/\/ Reverse: spawn near (z=focalDepth), travel inward toward centre.\n            \/\/ Reverse is the exact time-reverse of forward: identical x\/y\/radius\n            \/\/ spawn, only z runs the other way. Forward spawns far (z=1, near\n            \/\/ centre) and travels to z=focalDepth (off-screen edge); reverse\n            \/\/ spawns at z=focalDepth (edge) and travels back to z=1 (centre).\n            if (reverse) {\n                s.z = initial\n                    ? focalDepth + Math.random() * (1 - focalDepth)\n                    : focalDepth\n            } else {\n                s.z = initial ? Math.random() : 1.0\n            }\n            s.px = NaN\n            s.py = NaN\n            s.seed = Math.random() * 1000\n            \/\/ Varied per-star speed so synchronized respawns disperse instead\n            \/\/ of travelling as one cohort (which reads as a pulsing wave).\n            s.vmul = 0.6 + Math.random() * 0.8\n            s.colorIdx = Math.floor(Math.random() * 3)\n            s.flashUntil = 0\n            \/\/ Seconds-based: ~1s minimum gap + up to ~4s scaled by glitter.\n            s.nextFlash =\n                elapsed +\n                1 +\n                Math.random() * 4 * (1 \/ Math.max(0.0001, glitter))\n        }\n\n        const makeStar = (): Star => ({\n            x: 0,\n            y: 0,\n            z: 0,\n            px: NaN,\n            py: NaN,\n            seed: 0,\n            vmul: 1,\n            colorIdx: 0,\n            flashUntil: 0,\n            nextFlash: 0,\n        })\n\n        \/\/ Grow or shrink the star pool to match the requested count without\n        \/\/ rebuilding the whole array (so changing \"Particles\" stays smooth).\n        const syncCount = () => {\n            const count = Math.max(\n                1,\n                Math.floor(propsRef.current.particleCount)\n            )\n            if (stars.length === count) return\n            if (stars.length > count) {\n                stars.length = count\n            } else {\n                while (stars.length < count) {\n                    const s = makeStar()\n                    resetStar(s, true)\n                    stars.push(s)\n                }\n            }\n        }\n\n        const resize = (entry?: ResizeObserverEntry) => {\n            const dpr = Math.min(window.devicePixelRatio || 1, 2)\n            \/\/ Prefer the observer's contentRect, then layout box (clientWidth),\n            \/\/ then getBoundingClientRect. On the Framer canvas\n            \/\/ getBoundingClientRect can read 0 at setup, which used to pin the\n            \/\/ field to the 600\u00d7400 fallback in the top-left; contentRect \/\n            \/\/ clientWidth report the real laid-out size, so it fills the frame.\n            const cr = entry?.contentRect\n            const rectW =\n                cr?.width ||\n                container.clientWidth ||\n                container.getBoundingClientRect().width\n            const rectH =\n                cr?.height ||\n                container.clientHeight ||\n                container.getBoundingClientRect().height\n            const w = Math.max(1, Math.floor(rectW) || 600)\n            const h = Math.max(1, Math.floor(rectH) || 400)\n\n            \/\/ Bail when nothing changed. ResizeObserver fires spuriously (initial\n            \/\/ observe, sub-pixel jitter, DPR shifts, parent relayout); each call\n            \/\/ here would set canvas.width \u2014 which WIPES the canvas + trail buffer\n            \/\/ \u2014 making the animation visibly break\/restart. Only clear on a real\n            \/\/ size change.\n            const prev = sizeRef.current\n            if (prev.w === w && prev.h === h && prev.dpr === dpr) return\n\n            sizeRef.current = { w, h, dpr }\n            canvas.width = Math.floor(w * dpr)\n            canvas.height = Math.floor(h * dpr)\n            canvas.style.width = `${w}px`\n            canvas.style.height = `${h}px`\n            ctx.setTransform(dpr, 0, 0, dpr, 0, 0)\n\n            \/\/ Canvas stays transparent so the user's frame fill shows through.\n            \/\/ Start from a fully clear slate.\n            ctx.clearRect(0, 0, w, h)\n        }\n\n        syncCount()\n        resize()\n\n        const ro = new ResizeObserver((entries) => resize(entries[0]))\n        ro.observe(container)\n\n        const drawFrame = (deltaSec: number) => {\n            const {\n                reverse,\n                stepZ,\n                focalDepth,\n                starScale,\n                turbulence,\n                glitter,\n                brightness,\n                trail,\n            } = cfg()\n\n            \/\/ Keep the pool sized to the live \"Particles\" value, then read the\n            \/\/ palette\/bg fresh so colour edits apply without an effect rebuild.\n            syncCount()\n            const colors = getCachedColors()\n            const palette: [number, number, number, number][] = [\n                colors.parsed1,\n                colors.parsed2,\n                colors.parsed3,\n            ]\n            \/\/ Solid colour strings, built once per frame (3 of them) instead of\n            \/\/ per-star. Per-star alpha is applied via ctx.globalAlpha below, so\n            \/\/ the hot loop allocates zero strings \u2014 the previous rgba()-per-star\n            \/\/ approach churned ~120k short-lived strings\/sec at 700 particles,\n            \/\/ whose GC pauses were the main cause of the stutter.\n            const rgbStrs = [\n                `rgb(${palette[0][0]}, ${palette[0][1]}, ${palette[0][2]})`,\n                `rgb(${palette[1][0]}, ${palette[1][1]}, ${palette[1][2]})`,\n                `rgb(${palette[2][0]}, ${palette[2][1]}, ${palette[2][2]})`,\n            ]\n\n            const { w, h } = sizeRef.current\n            const cx = w \/ 2\n            const cy = h \/ 2\n            \/\/ Scale used for projection; tied to smaller dimension so it adapts\n            const projScale = Math.min(w, h) * 0.9\n\n            \/\/ Cap deltaSec to avoid large jumps when the tab was backgrounded\n            const dt = Math.max(0.001, Math.min(0.1, deltaSec)) * 60 \/\/ normalize to \"frames at 60fps\"\n\n            \/\/ Soft \"trails\" \u2014 fade prior pixels toward transparent so the\n            \/\/ user's frame fill shows through (the canvas itself has no bg).\n            \/\/ Uses destination-out: filling with alpha=trailAlpha subtracts that\n            \/\/ much from existing pixel alpha each frame, erasing old streaks.\n            \/\/ Decay is framerate-independent: `trail` is the fraction of the\n            \/\/ previous frame kept per 1\/60s, raised to dt so trail length stays\n            \/\/ constant whether the display runs 60Hz, 120Hz, or a stuttering\n            \/\/ variable rate. A fixed per-frame alpha (the old approach) makes the\n            \/\/ glow visibly breathe as fps fluctuates. Floor keeps a little erase\n            \/\/ even at trail=100 so the canvas never smears into a solid field.\n            const keep = Math.pow(Math.min(0.98, Math.max(0, trail)), dt)\n            const trailAlpha = Math.max(0.02, 1 - keep)\n            ctx.globalAlpha = 1\n            ctx.globalCompositeOperation = \"destination-out\"\n            ctx.fillStyle = `rgba(0, 0, 0, ${trailAlpha})`\n            ctx.fillRect(0, 0, w, h)\n\n            \/\/ Switch to additive for the stars\n            ctx.globalCompositeOperation = \"lighter\"\n\n            for (let i = 0; i < stars.length; i++) {\n                const s = stars[i]\n\n                \/\/ Forward: z decreases toward focalDepth (stars fly outward).\n                \/\/ Reverse: z increases toward 1 (stars recede into the centre).\n                const vz = stepZ * s.vmul * dt\n                if (reverse) {\n                    s.z += vz\n                    if (s.z >= 1.0) {\n                        resetStar(s)\n                        continue\n                    }\n                } else {\n                    s.z -= vz\n                    if (s.z <= focalDepth) {\n                        resetStar(s)\n                        continue\n                    }\n                }\n\n                \/\/ Turbulence: gentle sinusoidal wobble that grows as star approaches\n                let tx = s.x\n                let ty = s.y\n                if (turbulence > 0) {\n                    const t = elapsed * 1.2 + s.seed\n                    const amp = turbulence * (1 - s.z) * 0.25\n                    tx += Math.sin(t + s.seed) * amp\n                    ty += Math.cos(t * 1.13 + s.seed * 0.7) * amp\n                }\n\n                \/\/ Project: as z -> 0, the star expands outward from centre\n                const persp = focalDepth \/ Math.max(s.z, 0.0001)\n                const sx = cx + tx * persp * projScale\n                const sy = cy + ty * persp * projScale\n\n                \/\/ Off-screen? respawn \u2014 forward only. A reverse star is born at\n                \/\/ z=focalDepth where persp=1, which can place it past the edge;\n                \/\/ it then travels inward ONTO the screen. Culling on sight would\n                \/\/ kill it before it appears, so reverse stars are retired only by\n                \/\/ the z >= 1 reset (mirror of forward's z <= focalDepth reset).\n                if (\n                    !reverse &&\n                    (sx < -20 || sx > w + 20 || sy < -20 || sy > h + 20)\n                ) {\n                    resetStar(s)\n                    continue\n                }\n\n                \/\/ Glitter flash logic.\n                let flashMult = 1\n                if (glitter > 0) {\n                    if (elapsed >= s.nextFlash && s.flashUntil < elapsed) {\n                        \/\/ Flash for ~40\u2013110ms, then schedule the next one.\n                        s.flashUntil = elapsed + 0.04 + Math.random() * 0.07\n                        s.nextFlash =\n                            elapsed +\n                            1 +\n                            Math.random() * 4 * (1 \/ Math.max(0.0001, glitter))\n                    }\n                    if (elapsed <= s.flashUntil) {\n                        flashMult = 1 + 2.5 * glitter\n                    }\n                }\n\n                \/\/ Size grows as z -> 0. The cap scales with starScale so the\n                \/\/ \"Star Size\" control stays visibly distinct across its whole\n                \/\/ range \u2014 the old flat 1.8px cap clamped every size above ~3\n                \/\/ to the same dot, making the control do nothing past that.\n                const sizePersp = Math.min(\n                    2.5,\n                    (focalDepth \/ Math.max(s.z, 0.0001)) * 0.6\n                )\n                const baseR = Math.max(0.25, starScale * (0.4 + sizePersp))\n                const maxR = 1 + starScale * 2.5\n                const r = Math.min(baseR * flashMult, maxR)\n\n                \/\/ Alpha \u2014 brighter as nearer, modulated by brightness.\n                \/\/ In reverse, stars travel from edge inward. They'd fade out\n                \/\/ too early using the same curve as forward, so keep them\n                \/\/ bright for most of the journey and only fade at the very\n                \/\/ last stretch.\n                const lifeT = reverse ? s.z : 1 - s.z \/\/ 0=spawn, 1=despawn\n                \/\/ Reverse spawns at the screen edge already bright (0.85 curve),\n                \/\/ so each respawn pops. Ramp alpha up over the first ~12% of the\n                \/\/ journey so stars fade in instead. Forward already spawns near\n                \/\/ zero alpha, so it needs no ramp.\n                const fadeIn = reverse\n                    ? Math.min(1, (s.z - focalDepth) \/ (1 - focalDepth) \/ 0.12)\n                    : 1\n                const a =\n                    Math.min(\n                        1,\n                        reverse ? 0.85 - lifeT * 0.6 : lifeT * 0.9 + 0.05\n                    ) *\n                    fadeIn *\n                    brightness *\n                    (flashMult > 1 ? 1 : 0.85)\n\n                \/\/ Solid colour string (1 of 3, cached); per-star opacity rides\n                \/\/ on globalAlpha so nothing is allocated in this hot loop.\n                const colStr = rgbStrs[s.colorIdx]\n\n                \/\/ Streak from previous projected position to current. Kept\n                \/\/ thin so trails read as fine lines, not painted strokes.\n                if (!Number.isNaN(s.px) && !Number.isNaN(s.py)) {\n                    ctx.globalAlpha = a * 0.5\n                    ctx.strokeStyle = colStr\n                    ctx.lineWidth = Math.max(0.4, r * 0.4)\n                    ctx.beginPath()\n                    ctx.moveTo(s.px, s.py)\n                    ctx.lineTo(sx, sy)\n                    ctx.stroke()\n                }\n\n                \/\/ Tiny dot head \u2014 fillRect instead of arc(): at sub-pixel radii\n                \/\/ a square reads identically but skips per-star path tessellation.\n                ctx.globalAlpha = a\n                ctx.fillStyle = colStr\n                ctx.fillRect(sx - r, sy - r, r * 2, r * 2)\n\n                \/\/ Glitter flash adds a subtle extra square at slightly larger\n                \/\/ radius so it reads as a sparkle, not a halo.\n                if (flashMult > 1) {\n                    const rf = Math.min(r * 1.4, maxR * 1.4)\n                    ctx.globalAlpha = a * 0.5\n                    ctx.fillRect(sx - rf, sy - rf, rf * 2, rf * 2)\n                }\n\n                s.px = sx\n                s.py = sy\n            }\n\n            ctx.globalAlpha = 1\n            ctx.globalCompositeOperation = \"source-over\"\n            \/\/ Cap like the motion dt so a backgrounded-tab jump doesn't snap\n            \/\/ turbulence phase or fire every glitter flash at once on resume.\n            elapsed += Math.min(0.1, Math.max(0, deltaSec))\n        }\n\n        if (isStatic) {\n            \/\/ Advance a few warm-up frames so the static export looks populated\n            \/\/ rather than showing only spawning particles near the centre.\n            for (let i = 0; i < 80; i++) drawFrame(1 \/ 60)\n            return () => {\n                ro.disconnect()\n            }\n        }\n\n        const loop = (t: number) => {\n            const deltaSec = (t - lastT) \/ 1000\n            lastT = t\n            drawFrame(deltaSec)\n            rafRef.current = requestAnimationFrame(loop)\n        }\n        rafRef.current = requestAnimationFrame(loop)\n\n        return () => {\n            if (rafRef.current != null) cancelAnimationFrame(rafRef.current)\n            ro.disconnect()\n        }\n        \/\/ Single setup. Every animated value is read from propsRef each frame,\n        \/\/ so control changes apply live without rebuilding stars + RAF.\n        \/\/ eslint-disable-next-line react-hooks\/exhaustive-deps\n    }, [isStatic])\n\n    return (\n        <div\n            ref={containerRef}\n            style={{\n                position: \"relative\",\n                width: \"100%\",\n                height: \"100%\",\n                padding: 0,\n                margin: 0,\n                boxSizing: \"border-box\",\n                overflow: \"hidden\",\n                ...style,\n            }}\n        >\n            <canvas\n                ref={canvasRef}\n                style={{\n                    position: \"absolute\",\n                    inset: 0,\n                    width: \"100%\",\n                    height: \"100%\",\n                    display: \"block\",\n                }}\n            \/>\n        <\/div>\n    )\n}\n\ntype Props = {\n    particleCount: number\n    color1: string\n    color2: string\n    color3: string\n    speed: number\n    density: number\n    starSize: number\n    focalDepth: number\n    turbulence: number\n    brightness: number\n    glitterIntensity: number\n    trailAmount: number\n    reverse: boolean\n    style?: CSSProperties\n}\n\nconst COMPONENT_DEFAULTS = {\n    particleCount: 500,\n    color1: \"#ffffff\",\n    color2: \"#FF0000\",\n    color3: \"#FFE500\",\n    speed: 5,\n    density: 100,\n    starSize: 20,\n    focalDepth: 13,\n    turbulence: 0,\n    brightness: 100,\n    glitterIntensity: 3,\n    trailAmount: 100,\n    reverse: false,\n}\n\n<\/script>\t\t\t\t<\/div>\n\t\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t\t\t<\/div>\n\t\t","protected":false},"excerpt":{"rendered":"","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"_seopress_titles_title":"","_seopress_titles_desc":"","_seopress_robots_index":"","_seopress_robots_follow":"","_seopress_robots_imageindex":"","_seopress_robots_snippet":"","_seopress_robots_primary_cat":"","_seopress_robots_breadcrumbs":"","_seopress_robots_freeze_modified_date":"","_seopress_robots_custom_modified_date":"","_seopress_robots_canonical":"","_seopress_social_fb_title":"","_seopress_social_fb_desc":"","_seopress_social_fb_img":"","_seopress_social_fb_img_attachment_id":0,"_seopress_social_fb_img_width":0,"_seopress_social_fb_img_height":0,"_seopress_social_twitter_title":"","_seopress_social_twitter_desc":"","_seopress_social_twitter_img":"","_seopress_social_twitter_img_attachment_id":0,"_seopress_social_twitter_img_width":0,"_seopress_social_twitter_img_height":0,"_seopress_redirections_value":"","_seopress_redirections_enabled":"","_seopress_redirections_enabled_regex":"","_seopress_redirections_logged_status":"","_seopress_redirections_param":"","_seopress_redirections_type":0,"_seopress_analysis_target_kw":"","_seopress_news_disabled":"","_seopress_video_disabled":"","_seopress_video":[],"_seopress_pro_schemas_manual":[],"_seopress_pro_rich_snippets_disable_all":"","_seopress_pro_rich_snippets_disable":[],"_seopress_pro_schemas":[],"footnotes":""},"class_list":["post-58377","page","type-page","status-publish"],"_links":{"self":[{"href":"https:\/\/senseadelic.com\/nl\/wp-json\/wp\/v2\/pages\/58377","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/senseadelic.com\/nl\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/senseadelic.com\/nl\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/senseadelic.com\/nl\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/senseadelic.com\/nl\/wp-json\/wp\/v2\/comments?post=58377"}],"version-history":[{"count":6,"href":"https:\/\/senseadelic.com\/nl\/wp-json\/wp\/v2\/pages\/58377\/revisions"}],"predecessor-version":[{"id":58384,"href":"https:\/\/senseadelic.com\/nl\/wp-json\/wp\/v2\/pages\/58377\/revisions\/58384"}],"wp:attachment":[{"href":"https:\/\/senseadelic.com\/nl\/wp-json\/wp\/v2\/media?parent=58377"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}