{"version":3,"file":"SCRAMLELOGO.-RlSs0s0.mjs","names":["React.useRef","React.useState","React.useMemo","React.useCallback"],"sources":["https:/framerusercontent.com/modules/ldkbWzucphIxLS3cNGx5/NwWwqtotl4pjfGMwE7Ua/SCRAMLELOGO.js"],"sourcesContent":["/** @jsxRuntime classic *//** @jsx React.createElement */import*as React from\"react\";import{motion,useMotionValue,useMotionValueEvent,useTransform,animate,useVelocity}from\"framer-motion\";import{addPropertyControls,ControlType,RenderTarget}from\"framer\";const PARALLAX_SLICES=[{id:\"tt\",top:0,bottom:90,lagFactor:.012},{id:\"tm\",top:10,bottom:70,lagFactor:.006},{id:\"cc\",top:30,bottom:30,lagFactor:0},{id:\"bm\",top:70,bottom:10,lagFactor:-.006},{id:\"bb\",top:90,bottom:0,lagFactor:-.012}];function ScrambleLetter({char,delay,hold,appearDelay,appearDuration,hoverDuration,scrambleOnAppear,scrambleString,fontSize,font,color,enableGradient,gradientColor2,useGradientColor3,gradientColor3,useGradientColor4,gradientColor4,useGradientColor5,gradientColor5,gradientAngle,bgPosMV,noiseSVG,charIndex,slotWidthMV,overrideDelta,clippingWidthMV,reelSpacingMV,scrambleKey,returnClip,returnReel,reelBlendMode,scrambleClipWidth,scrambleCharGap,scrambleSlotWidth}){const xValue=useMotionValue(0);const velocity=useVelocity(xValue);const directionRef=React.useRef(charIndex%2===0?1:-1);// Per-letter local MotionValues for scramble overrides\nconst localClipWidthMV=useMotionValue(clippingWidthMV.get());const localReelSpacingMV=useMotionValue(reelSpacingMV.get());const localSlotWidthMV=useMotionValue(slotWidthMV.get());// Track whether this letter is currently scrambling with local overrides\nconst isLocalScramblingRef=React.useRef(false);// Sync local MVs with parent MVs only when NOT locally scrambling\nReact.useEffect(()=>{const unsubClip=clippingWidthMV.on(\"change\",v=>{if(!isLocalScramblingRef.current)localClipWidthMV.set(v);});const unsubReel=reelSpacingMV.on(\"change\",v=>{if(!isLocalScramblingRef.current)localReelSpacingMV.set(v);});const unsubSlot=slotWidthMV.on(\"change\",v=>{if(!isLocalScramblingRef.current)localSlotWidthMV.set(v);});return()=>{unsubClip();unsubReel();unsubSlot();};},[]);// Ref so the ResizeObserver closure always reads the latest value\nconst scrambleOnAppearRef=React.useRef(scrambleOnAppear);scrambleOnAppearRef.current=scrambleOnAppear;// True while a hover keyframe animation is in flight.\n// Suppresses baseline-tracking snaps so the clip/reel MV changes from\n// scramble overrides don't clobber the keyframe's landing position.\nconst isHoverAnimatingRef=React.useRef(false);// True while the initial appear animation (including its delay) is running.\n// The step RAF loop animates clippingWidthMV/reelSpacingMV simultaneously,\n// which would otherwise trigger baseline tracking on every frame and fight\n// the appear animation — preventing the reel from ever scrambling in.\nconst isAppearAnimatingRef=React.useRef(false);// Stable refs for animation state so ResizeObserver/timer closures always\n// read the latest values without needing to be inside a useEffect dep array.\nconst appearTimerRef=React.useRef(null);const appearAnimRef=React.useRef(null);const holdRef=React.useRef(hold);holdRef.current=hold;const appearDelayRef=React.useRef(appearDelay);appearDelayRef.current=appearDelay;const appearDurationRef=React.useRef(appearDuration);appearDurationRef.current=appearDuration;const targetIdx=5;const hasAppeared=React.useRef(false);const containerRef=React.useRef(null);const[measuredWidth,setMeasuredWidth]=React.useState(0);const[showReel,setShowReel]=React.useState(false);// Refs so MotionValue event callbacks always see latest values\nconst measuredWidthRef=React.useRef(measuredWidth);measuredWidthRef.current=measuredWidth;const overrideDeltaRef=React.useRef(overrideDelta);overrideDeltaRef.current=overrideDelta;// ── Per-letter effective slot width: local slotWidth + per-char delta ──\n// Updated via MotionValue subscription (no React render needed for animation)\nconst effectiveSlotWidthMV=useMotionValue(localSlotWidthMV.get()+overrideDelta);useMotionValueEvent(localSlotWidthMV,\"change\",v=>{effectiveSlotWidthMV.set(v+overrideDeltaRef.current);});// Also re-sync when overrideDelta changes (from React state update)\nReact.useEffect(()=>{effectiveSlotWidthMV.set(localSlotWidthMV.get()+overrideDelta);},[overrideDelta]);// ── Reel cell width: measuredWidth + local reelSpacing ──────────────────────────\nconst rsMV=useMotionValue((measuredWidth||fontSize)+localReelSpacingMV.get());useMotionValueEvent(localReelSpacingMV,\"change\",rs=>{rsMV.set((measuredWidthRef.current||fontSize)+rs);});React.useEffect(()=>{rsMV.set((measuredWidth||fontSize)+localReelSpacingMV.get());},[measuredWidth]);const getBaseline=(cw,step)=>cw/2-(targetIdx+.5)*step;const reelChars=React.useMemo(()=>{const base=(scrambleString||\"TOBYS\").split(\"\");const finalChar=char||\" \";const R=()=>base[Math.floor(Math.random()*base.length)];return[R(),finalChar,R(),R(),R(),finalChar,R(),R(),R(),finalChar,R()];},[scrambleString,char]);// Use `any` so the MotionValue backgroundPosition passes through to motion.span\n// without TypeScript complaining (motion elements accept MotionValues in style).\nconst textStyle={fontFamily:font?.fontFamily??\"Inter, sans-serif\",fontWeight:font?.fontWeight??900,fontStyle:font?.fontStyle??\"normal\",fontVariationSettings:font?.fontVariationSettings?typeof font.fontVariationSettings===\"string\"?font.fontVariationSettings:undefined:undefined,letterSpacing:typeof font?.letterSpacing===\"number\"||typeof font?.letterSpacing===\"string\"?font.letterSpacing:undefined,...enableGradient?{// Noise is a second background layer blended via backgroundBlendMode.\n// background-clip: text clips both layers to the letter forms.\n// backgroundPosition is a MotionValue (JS-driven) — no CSS animation\n// runs on this element, so backgroundBlendMode is safe here.\nbackgroundImage:noiseSVG?`${noiseSVG}, linear-gradient(${gradientAngle}deg, ${color}, ${gradientColor2}${useGradientColor3?`, ${gradientColor3}`:\"\"}${useGradientColor4?`, ${gradientColor4}`:\"\"}${useGradientColor5?`, ${gradientColor5}`:\"\"})`:`linear-gradient(${gradientAngle}deg, ${color}, ${gradientColor2}${useGradientColor3?`, ${gradientColor3}`:\"\"}${useGradientColor4?`, ${gradientColor4}`:\"\"}${useGradientColor5?`, ${gradientColor5}`:\"\"})`,backgroundSize:noiseSVG?\"200% 200%, 120% 120%\":\"120% 120%\",backgroundPosition:bgPosMV,backgroundBlendMode:noiseSVG?\"overlay\":undefined,WebkitBackgroundClip:\"text\",backgroundClip:\"text\",WebkitTextFillColor:\"transparent\",color:\"transparent\",lineHeight:.85,paddingBottom:\"0.1em\"}:{color,WebkitTextFillColor:color,lineHeight:.85,paddingBottom:\"0.1em\"}};// ── Measure glyph width ───────────────────────────────────────────────────\nReact.useLayoutEffect(()=>{// Cancel any in-flight appear animation from a prior run (font/char change or\n// React StrictMode's intentional mount → cleanup → remount cycle).\nclearTimeout(appearTimerRef.current);appearAnimRef.current?.stop?.();isAppearAnimatingRef.current=false;hasAppeared.current=false;setShowReel(false);setMeasuredWidth(0);// Detect Framer's canvas editor so we can skip the reel animation there.\n// Animating a scramble every time you edit a property is unusable in the editor;\n// in canvas mode we simply show the settled (final) position instantly instead.\nlet isCanvasRender=false;try{const rt=RenderTarget.current();isCanvasRender=rt===RenderTarget.canvas;}catch(_){}const measure=containerRef.current?.querySelector(\".measure\");if(!measure)return;const observer=new ResizeObserver(entries=>{for(const entry of entries){const w=entry.contentRect.width;if(w>0){setMeasuredWidth(w);if(!hasAppeared.current){hasAppeared.current=true;const step=w+reelSpacingMV.get();const baseline=getBaseline(clippingWidthMV.get(),step);if(scrambleOnAppearRef.current&&!isCanvasRender){// Put reel off-screen then animate to baseline.\n// Triggering directly from the ResizeObserver (rather than from\n// a useEffect) avoids React StrictMode's double-invocation which\n// was silently cancelling the animation before it could complete.\nisAppearAnimatingRef.current=true;clearTimeout(appearTimerRef.current);appearAnimRef.current?.stop?.();const delayMs=((appearDelayRef.current||0)+(holdRef.current||0))*1e3;appearTimerRef.current=setTimeout(()=>{// Re-sample live MV values — the step animation may have\n// moved clippingWidthMV / reelSpacingMV during the delay.\nconst lw=measuredWidthRef.current;const lStep=lw+reelSpacingMV.get();const lBaseline=getBaseline(clippingWidthMV.get(),lStep);// Place reel off-screen then reveal — keeps the letter invisible\n// during the stagger delay so it doesn't flash at an off-screen\n// position while waiting to animate in (now that ancestor overflow\n// is visible, that off-screen position would otherwise be seen).\nxValue.set(lBaseline+3*directionRef.current*lStep);setShowReel(true);appearAnimRef.current=animate(xValue,lBaseline,{duration:appearDurationRef.current||1.5,ease:\"easeInOut\",onComplete:()=>{isAppearAnimatingRef.current=false;if(!isHoverAnimatingRef.current){const fw=measuredWidthRef.current;if(fw>0)xValue.set(getBaseline(clippingWidthMV.get(),fw+reelSpacingMV.get()));}}});},delayMs);}else{// Canvas or scrambleOnAppear=false: snap directly to settled position\nxValue.set(baseline);setShowReel(true);}}}}});observer.observe(measure);return()=>{observer.disconnect();// Cancel pending animation so StrictMode's cleanup → remount cycle\n// doesn't leave two animations running simultaneously.\nclearTimeout(appearTimerRef.current);appearAnimRef.current?.stop?.();isAppearAnimatingRef.current=false;hasAppeared.current=false;};// eslint-disable-next-line react-hooks/exhaustive-deps\n},[fontSize,font?.fontFamily,font?.fontWeight,font?.fontStyle,char]);// ── Baseline tracking via MotionValue subscriptions ───────────────────────\n// clippingWidth changes → re-centre reel\nuseMotionValueEvent(clippingWidthMV,\"change\",cw=>{if(!hasAppeared.current||measuredWidthRef.current===0)return;// Skip while appear or hover animation is running — MV changes during those\n// animations must not overwrite the animated xValue.\nif(isHoverAnimatingRef.current||isAppearAnimatingRef.current)return;xValue.set(getBaseline(cw,measuredWidthRef.current+reelSpacingMV.get()));});// reelSpacing changes → cell size changes, re-centre\nuseMotionValueEvent(reelSpacingMV,\"change\",rs=>{if(!hasAppeared.current||measuredWidthRef.current===0)return;if(isHoverAnimatingRef.current||isAppearAnimatingRef.current)return;xValue.set(getBaseline(clippingWidthMV.get(),measuredWidthRef.current+rs));});// measuredWidth changes (React state) → re-centre\nReact.useEffect(()=>{if(!hasAppeared.current||measuredWidth===0)return;if(isHoverAnimatingRef.current||isAppearAnimatingRef.current)return;xValue.set(getBaseline(clippingWidthMV.get(),measuredWidth+reelSpacingMV.get()));},[measuredWidth]);// ── Hover re-scramble ─────────────────────────────────────────────────────\n// Two-phase chained animation to avoid the \"jump at end\" when scramble overrides\n// (scrambleClipWidth / scrambleCharGap) change the MotionValues during the animation.\n//\n// The problem with a single keyframe [start → far → baseline]:\n//   • baseline is computed ONCE at effect-fire time, using the current MV values\n//   • but scramble overrides quickly animate clippingWidthMV / reelSpacingMV away\n//     from their step values → the true landing baseline shifts\n//   • the reel ends up visually off-centre → visible jump\n//\n// Two-phase fix:\n//   Phase 1  (35% of duration):  current → farPos  — forward spin, easeOut\n//   Phase 2  (65% of duration):  farPos → baseline — settle; baseline uses the\n//                                 step-value snapshot (scrambleBase) so it lands at\n//                                 the correct position even while MV restore is pending\nReact.useEffect(()=>{if(scrambleKey===0||!hasAppeared.current||measuredWidth===0)return;const totalDur=hoverDuration||1.5;const p1Dur=totalDur*.35;const p2Dur=totalDur*.65;let anim1=null,anim2=null;// Check if this letter has local overrides - if so, block parent sync IMMEDIATELY\nconst hasLocalOverrides=scrambleClipWidth!=null||scrambleCharGap!=null||scrambleSlotWidth!=null;if(hasLocalOverrides)isLocalScramblingRef.current=true;const staggerDelayMs=(delay||0)*1e3;const timer=setTimeout(()=>{isHoverAnimatingRef.current=true;if(hasLocalOverrides){// Animate local overrides in over 40% of duration\nconst overrideDur=totalDur*.4;if(scrambleClipWidth!=null){animate(localClipWidthMV,scrambleClipWidth,{duration:overrideDur,ease:\"easeInOut\"});}if(scrambleCharGap!=null){animate(localReelSpacingMV,scrambleCharGap,{duration:overrideDur,ease:\"easeInOut\"});}if(scrambleSlotWidth!=null){animate(localSlotWidthMV,scrambleSlotWidth,{duration:overrideDur,ease:\"easeInOut\"});}// Restore after override duration\nsetTimeout(()=>{if(scrambleClipWidth!=null){animate(localClipWidthMV,clippingWidthMV.get(),{duration:overrideDur,ease:\"easeInOut\",onComplete:()=>{// Re-enable parent sync after restore completes\nisLocalScramblingRef.current=false;// Force sync to current parent values\nlocalClipWidthMV.set(clippingWidthMV.get());}});}if(scrambleCharGap!=null){animate(localReelSpacingMV,reelSpacingMV.get(),{duration:overrideDur,ease:\"easeInOut\",onComplete:()=>{localReelSpacingMV.set(reelSpacingMV.get());}});}if(scrambleSlotWidth!=null){animate(localSlotWidthMV,slotWidthMV.get(),{duration:overrideDur,ease:\"easeInOut\",onComplete:()=>{localSlotWidthMV.set(slotWidthMV.get());}});}// If no overrides were set, re-enable sync after both durations\nif(scrambleClipWidth==null&&scrambleCharGap==null&&scrambleSlotWidth==null){isLocalScramblingRef.current=false;}},overrideDur*1e3);}const step0=measuredWidthRef.current+localReelSpacingMV.get();const base0=getBaseline(localClipWidthMV.get(),step0);const farPos=base0+3*directionRef.current*step0;anim1=animate(xValue,[xValue.get(),farPos],{duration:p1Dur,ease:\"easeOut\",onComplete:()=>{// Phase 2: land on the correct *step* baseline.\n//\n// The naive approach — reading clippingWidthMV/reelSpacingMV live\n// right now — is wrong when scramble overrides are active: phase 1\n// ends before the MV restore timer fires (p1Dur=35% < inDur=40%),\n// so those MVs are still at their scramble-override values and the\n// reel would be aimed at the wrong position, leaving O/B partially\n// off-centre and appearing to overlap their neighbours.\n//\n// Fix: use the last step's clip/reel values directly.\n// Hover is gated until the step animation finishes, so the reel\n// must always return to exactly these values — no MV sampling needed.\nconst liveBaseline=getBaseline(returnClip,measuredWidthRef.current+returnReel);anim2=animate(xValue,liveBaseline,{duration:p2Dur,ease:\"easeInOut\",onComplete:()=>{isHoverAnimatingRef.current=false;// Final snap to the exact last-step baseline — guarantees\n// pixel-perfect landing regardless of any MV restore timing.\nconst fw=measuredWidthRef.current;if(fw>0)xValue.set(getBaseline(returnClip,fw+returnReel));}});}});},staggerDelayMs);return()=>{clearTimeout(timer);anim1?.stop?.();anim2?.stop?.();isHoverAnimatingRef.current=false;// Re-enable parent sync on cleanup\nif(hasLocalOverrides){isLocalScramblingRef.current=false;}};},[scrambleKey]);return /*#__PURE__*/React.createElement(motion.div,{ref:containerRef,style:{position:\"relative\",display:\"inline-flex\",width:effectiveSlotWidthMV,height:\"1em\",alignItems:\"center\",justifyContent:\"center\",overflow:\"visible\"}},/*#__PURE__*/React.createElement(\"span\",{className:\"measure\",style:{visibility:\"hidden\",pointerEvents:\"none\",display:\"inline-block\",whiteSpace:\"pre\",padding:0,...textStyle,// Plain <span> can't use MotionValues — override with a static value\nbackgroundPosition:noiseSVG?\"0% 0%, 0% 50%\":\"0% 50%\"}},char===\" \"?\"\\xa0\":char),/*#__PURE__*/React.createElement(motion.div,{style:{position:\"absolute\",left:\"50%\",top:\"50%\",width:localClipWidthMV,height:\"140%\",transform:\"translate(-50%,-50%)\",overflow:\"hidden\",pointerEvents:\"none\",mixBlendMode:reelBlendMode}},/*#__PURE__*/React.createElement(motion.div,{style:{position:\"absolute\",inset:0,display:\"flex\",flexDirection:\"row\",x:xValue,willChange:\"transform\",opacity:showReel?1:0}},reelChars.map((c,i)=>/*#__PURE__*/React.createElement(motion.span,{key:`b${i}`,style:{width:rsMV,display:\"flex\",justifyContent:\"center\",alignItems:\"center\",height:\"100%\",flexShrink:0,whiteSpace:\"pre\",...textStyle}},c===\" \"?\"\\xa0\":c))),/*#__PURE__*/React.createElement(\"div\",{style:{opacity:showReel?.8:0,position:\"absolute\",inset:0,isolation:\"isolate\"}},PARALLAX_SLICES.map(slice=>/*#__PURE__*/React.createElement(SliceLayer,{key:slice.id,slice:slice,xValue:xValue,velocity:velocity,shearIntensity:2,rsMV:rsMV,textStyle:textStyle,reelChars:reelChars,blendMode:reelBlendMode})))));}// ─── SliceLayer ───────────────────────────────────────────────────────────────\nfunction SliceLayer({slice,xValue,velocity,shearIntensity,rsMV,textStyle,reelChars,blendMode}){const shearOffset=useTransform(velocity,v=>v*slice.lagFactor*(shearIntensity||1));const finalX=useTransform([xValue,shearOffset],([x,s])=>x+s);return /*#__PURE__*/React.createElement(motion.div,{style:{position:\"absolute\",inset:0,willChange:\"transform\",clipPath:`inset(${slice.top}% 0% ${slice.bottom}% 0%)`,x:finalX,mixBlendMode:blendMode}},/*#__PURE__*/React.createElement(\"div\",{style:{display:\"flex\",flexDirection:\"row\",height:\"100%\"}},reelChars.map((c,i)=>/*#__PURE__*/React.createElement(motion.span,{key:`s${i}`,style:{width:rsMV,display:\"flex\",justifyContent:\"center\",alignItems:\"center\",height:\"100%\",flexShrink:0,whiteSpace:\"pre\",...textStyle}},c===\" \"?\"\\xa0\":c))));}// ─── ScrambleTumbler ──────────────────────────────────────────────────────────\nconst DEFAULT_STEP1={fontSize:270,slotWidth:255,spacing:-116,clippingWidth:153,reelSpacing:347,duration:2,pause:.5,widthOverrides:\"\",offsetX:0,offsetY:0,fillViewport:false};const DEFAULT_STEP2={fontSize:735,slotWidth:144,spacing:-308,clippingWidth:576,reelSpacing:174,duration:2,pause:.5,widthOverrides:\"\",offsetX:0,offsetY:0,fillViewport:false};const DEFAULT_STEP3={fontSize:1200,slotWidth:33,spacing:-500,clippingWidth:999,reelSpacing:0,duration:2,pause:.5,widthOverrides:\"\",offsetX:0,offsetY:0,fillViewport:false};// Parse \"Y:-50, W:-30\" → { Y: -50, W: -30 }\nfunction parseOverrides(str){const map={};if(!str)return map;str.split(\",\").forEach(part=>{const m=part.trim().match(/^(.):([+-]?\\d+(?:\\.\\d+)?)$/);if(m)map[m[1]]=parseFloat(m[2]);});return map;}const DEFAULT_STEPS=[DEFAULT_STEP1,DEFAULT_STEP2,DEFAULT_STEP3];export default function ScrambleTumbler({text=\"TOBYS.DESIGN\",color=\"#ABABAB\",font,enableGradient=true,gradientColor2=\"#f9a3da\",useGradientColor3=true,gradientColor3=\"#c840bb\",useGradientColor4=false,gradientColor4=\"#4169E1\",useGradientColor5=false,gradientColor5=\"#9370DB\",gradientAngle=356,gradientSpeed=4,stagger=.12,scrambleHold=.3,appearDelay=0,appearDuration=1.5,scrambleDuration=1.5,scrambleOnAppear=true,hoverDelay=0,stepDelay=.5,// Scramble-specific overrides — applied during hover, restored after\nreelBlendMode=\"difference\",scrambleClipWidth,scrambleCharGap,scrambleSlotWidth,stepsState,fillViewport=false,previewStep=0,// Grainy noise\nenableNoise=false,noiseOpacity=.15,noiseScale=2}){// Merge incoming array with defaults; fall back to built-in 3-step sequence\nconst steps=stepsState&&stepsState.length>0?stepsState:DEFAULT_STEPS;// Refs so the RAF closure always reads the latest values\nconst stepsRef=React.useRef(steps);stepsRef.current=steps;const holdRef=React.useRef(scrambleHold);holdRef.current=scrambleHold;const stepDelayRef=React.useRef(stepDelay);stepDelayRef.current=stepDelay;// fillViewport must be a ref because runAnimation is wrapped in useCallback([])\n// — without this the RAF closure would capture the initial (false) value and\n// never see prop updates from Framer.\nconst fillViewportRef=React.useRef(fillViewport);fillViewportRef.current=fillViewport;// Ref to the root div — used by the DOM-walk effect to escape Framer's own\n// overflow:hidden frames when fillActive is true.\nconst rootRef=React.useRef(null);// Tracks whether the initial appear animation has finished.\n// Used to let canvas prop edits update values without re-running the animation.\nconst animDoneRef=React.useRef(false);// Hover gate — hover scramble is blocked until this is true.\n// Becomes true when the step animation finishes (animDoneRef) OR when the\n// manual hoverDelay timer elapses, whichever comes first.\nconst hoverReadyRef=React.useRef(false);React.useEffect(()=>{hoverReadyRef.current=false;if(hoverDelay>0){const t=setTimeout(()=>{hoverReadyRef.current=true;},hoverDelay*1e3);return()=>clearTimeout(t);}},[]);// ── Shared gradient animation — one animation drives all letters ─────────\nconst gradientPosX=useMotionValue(0);const bgPosMVPlain=useTransform(gradientPosX,v=>`${v}% 50%`);const bgPosMVNoise=useTransform(gradientPosX,v=>`0% 0%, ${v}% 50%`);const bgPosMV=enableNoise?bgPosMVNoise:bgPosMVPlain;React.useEffect(()=>{if(!enableGradient)return;const controls=animate(gradientPosX,100,{duration:gradientSpeed/2,ease:\"easeInOut\",repeat:Infinity,repeatType:\"reverse\"});return()=>controls.stop();},[enableGradient,gradientSpeed]);// ── Shared noise SVG — computed once, passed to every letter ──────────────\nconst noiseSVG=React.useMemo(()=>{if(!enableNoise)return\"\";const slope=1+noiseOpacity*10;const intercept=parseFloat((.5-slope*.5).toFixed(4));const svgString=`<svg viewBox='0 0 200 200' xmlns='http://www.w3.org/2000/svg'><filter id='noiseFilter'><feTurbulence type='fractalNoise' baseFrequency='${noiseScale*.65}' numOctaves='3' stitchTiles='stitch'/><feColorMatrix type='saturate' values='0'/><feComponentTransfer><feFuncR type='linear' slope='${slope}' intercept='${intercept}'/><feFuncG type='linear' slope='${slope}' intercept='${intercept}'/><feFuncB type='linear' slope='${slope}' intercept='${intercept}'/></feComponentTransfer></filter><rect width='100%' height='100%' filter='url(#noiseFilter)'/></svg>`;if(typeof btoa!==\"undefined\")return`url(\"data:image/svg+xml;base64,${btoa(svgString)}\")`;return`url(\"data:image/svg+xml,${encodeURIComponent(svgString)}\")`;},[enableNoise,noiseScale,noiseOpacity]);// Motion values — ALL layout properties drive CSS directly via MotionValues,\n// bypassing React's render scheduler entirely for 60fps animation.\nconst firstStep=steps[0];const fontSizeMV=useMotionValue(firstStep.fontSize);const spacingMV=useMotionValue(firstStep.spacing);const slotWidthMV=useMotionValue(firstStep.slotWidth);const clippingWidthMV=useMotionValue(firstStep.clippingWidth);const reelSpacingMV=useMotionValue(firstStep.reelSpacing);const offsetXMV=useMotionValue(firstStep.offsetX??0);const offsetYMV=useMotionValue(firstStep.offsetY??0);// React state only for per-char width overrides — these are a map of char→delta and\n// can't be a plain MotionValue; they update at step boundaries (infrequent).\n// When both from/to steps have empty widthOverrides (most users), setOverrides\n// is never called inside the RAF tick, so no React renders happen during animation.\nconst[overrides,setOverrides]=React.useState(parseOverrides(firstStep.widthOverrides||\"\"));const overridesRef=React.useRef(parseOverrides(firstStep.widthOverrides||\"\"));// Tracks whether the component should escape its Framer frame and fill the viewport.\n// Activated when the step animation finishes at a step with fillViewport:true.\n// Stays false on the main editor canvas so the canvas remains usable.\nconst[fillActive,setFillActive]=React.useState(false);// Declared early so snapTo and the RAF loop can reference it.\n// isEditorCanvas: fillViewport is blocked on the canvas so editing stays usable.\n// Preview, share links, and published sites all get overflow:visible when fill is active.\nconst rt=RenderTarget.current();const isEditorCanvas=rt===RenderTarget.canvas;// ── Core animation runner ────────────────────────────────────────────────\n// Drives Step[0] → Step[1] → … → Step[n-1].\n//\n// Strategy: setTimeout chain + direct animate() per MotionValue — the same\n// pattern used by ScrambleLetter's appear animation, which is known to work\n// reliably in Framer's preview and published modes.\n//\n// Why not RAF: cancelled before first frame fires in Framer preview (StrictMode\n//   double-invoke / Framer's own mounting sequence).\n// Why not animate(progressMV, total, { onUpdate }): onUpdate reliability across\n//   Framer's different render environments is uncertain.\n// setTimeout + animate(mv, target): each transition is a fresh animate() call on\n//   each MotionValue, identical to how the proven scramble appear animation works.\nconst runAnimation=React.useCallback(()=>{animDoneRef.current=false;// Snapshot steps at call time — avoids race where props arrive after mount\nconst ss=stepsRef.current.length>0?stepsRef.current:DEFAULT_STEPS;const sdl=stepDelayRef.current// global fallback pause (seconds)\n;// Snap all layout MVs to the first step immediately\nconst first=ss[0];fontSizeMV.set(first.fontSize);spacingMV.set(first.spacing);slotWidthMV.set(first.slotWidth);clippingWidthMV.set(first.clippingWidth);reelSpacingMV.set(first.reelSpacing);offsetXMV.set(first.offsetX??0);offsetYMV.set(first.offsetY??0);const firstOvr=parseOverrides(first.widthOverrides||\"\");if(JSON.stringify(firstOvr)!==JSON.stringify(overridesRef.current)){overridesRef.current=firstOvr;setOverrides(firstOvr);}const n=ss.length;if(n<=1){animDoneRef.current=true;if(n===1)setFillActive(!isEditorCanvas&&(fillViewportRef.current||!!ss[0].fillViewport));return()=>{};}const timers=[];const animControls=[];// Step 1's \"Step Pause\" is the initial hold before the first transition.\n// scrambleHold (Initial Hold) is separate — it only delays the letter appear animation.\nlet delayS=ss[0].pause??sdl;for(let i=0;i<n-1;i++){const to=ss[i+1];const dur=ss[i].duration??2// seconds\n;const isLast=i===n-2;const startMs=delayS*1e3;((target,durationS,last)=>{timers.push(setTimeout(()=>{// Apply widthOverrides at the START of the transition (not the end).\n// Only trigger the React state update when the value actually changes —\n// setOverrides causes a re-render which snaps effectiveSlotWidthMV via\n// useEffect([overrideDelta]), creating a visible jump even when both\n// steps have identical override values.  Skipping the update when\n// unchanged eliminates the snap entirely for the common case.\nconst ovr=parseOverrides(target.widthOverrides||\"\");if(JSON.stringify(ovr)!==JSON.stringify(overridesRef.current)){overridesRef.current=ovr;setOverrides(ovr);}animControls.push(animate(fontSizeMV,target.fontSize,{duration:durationS,ease:\"easeInOut\"}));animControls.push(animate(spacingMV,target.spacing,{duration:durationS,ease:\"easeInOut\"}));animControls.push(animate(slotWidthMV,target.slotWidth,{duration:durationS,ease:\"easeInOut\"}));animControls.push(animate(clippingWidthMV,target.clippingWidth,{duration:durationS,ease:\"easeInOut\"}));animControls.push(animate(reelSpacingMV,target.reelSpacing,{duration:durationS,ease:\"easeInOut\"}));animControls.push(animate(offsetXMV,target.offsetX??0,{duration:durationS,ease:\"easeInOut\"}));animControls.push(animate(offsetYMV,target.offsetY??0,{duration:durationS,ease:\"easeInOut\"}));if(last){timers.push(setTimeout(()=>{animDoneRef.current=true;setFillActive(!isEditorCanvas&&(fillViewportRef.current||!!target.fillViewport));},durationS*1e3+50));}},startMs));})(to,dur,isLast);delayS+=dur;// Per-step pause: how long to hold at step i+1 before continuing.\n// Falls back to global stepDelay if the step doesn't have its own pause.\nif(!isLast)delayS+=ss[i+1].pause??sdl;}return()=>{timers.forEach(clearTimeout);animControls.forEach(a=>a.stop());};},[]);// ── Step animation — runs once on mount ──────────────────────────────────\n// We defer via setTimeout(0) instead of calling runAnimation() directly.\n// React StrictMode synchronously runs mount → cleanup → remount; a direct\n// call would have its timers cleared by the cleanup before they ever fire.\n// setTimeout(0) posts to the next event-loop tick — AFTER the StrictMode\n// cycle completes — so only the real (second) mount's animation runs.\n// Identical strategy to ScrambleLetter's ResizeObserver trigger.\nconst stepCleanupRef=React.useRef(null);React.useEffect(()=>{const t=setTimeout(()=>{stepCleanupRef.current=runAnimation()??null;},0);return()=>{clearTimeout(t);stepCleanupRef.current?.();stepCleanupRef.current=null;};},[]);// ── Canvas editing: snap to whichever step was just changed ─────────────\nconst snapTo=s=>{fontSizeMV.set(s.fontSize);spacingMV.set(s.spacing);slotWidthMV.set(s.slotWidth);clippingWidthMV.set(s.clippingWidth);reelSpacingMV.set(s.reelSpacing);offsetXMV.set(s.offsetX??0);offsetYMV.set(s.offsetY??0);const ovr=parseOverrides(s.widthOverrides||\"\");overridesRef.current=ovr;setOverrides(ovr);// fillViewport: global prop overrides per-step; both blocked on editor canvas\nsetFillActive(!isEditorCanvas&&(fillViewport||!!s.fillViewport));};// Increments on each hover to trigger a re-scramble in every ScrambleLetter\nconst[scrambleKey,setScrambleKey]=React.useState(0);const prevStepsJsonRef=React.useRef(\"\");React.useEffect(()=>{// Canvas editor only — this effect must never touch preview/published.\n// In preview the RAF animation owns the MotionValues; any snapTo call\n// here would freeze or skip the animation.\nif(!isEditorCanvas)return;const currJson=JSON.stringify(stepsState);prevStepsJsonRef.current=currJson;if(!animDoneRef.current)return;const ss=stepsRef.current;if(ss.length===0)return;// Snap to whichever step the user is currently previewing.\n// previewStep is 1-indexed; 0 (default) = last step.\nconst idx=previewStep>=1&&previewStep<=ss.length?previewStep-1:ss.length-1;snapTo(ss[idx]);},[JSON.stringify(stepsState),previewStep]);const reelBase=React.useMemo(()=>(text||\"TOBYS\").replace(/\\s/g,\"\")||\"OTYWSLE\",[text]);const handleMouseEnter=()=>{// Block hover while step animation is running, or until hoverDelay elapses.\nconst ready=hoverReadyRef.current||animDoneRef.current;if(!ready)return;hoverReadyRef.current=true// once open, stays open\n;setScrambleKey(k=>k+1);};// The letters —\nconst motionContent=/*#__PURE__*/React.createElement(motion.div,{style:{fontSize:fontSizeMV,display:\"flex\",flexDirection:\"row\",alignItems:\"center\",justifyContent:\"flex-start\",whiteSpace:\"nowrap\",x:offsetXMV,y:offsetYMV}},(text||\"\").split(\"\").map((c,i)=>/*#__PURE__*/React.createElement(motion.div,{key:i,style:{flexShrink:0,marginRight:i<(text||\"\").length-1?spacingMV:0}},/*#__PURE__*/React.createElement(ScrambleLetter,{char:c,fontSize:steps[0]?.fontSize??DEFAULT_STEP1.fontSize,font:font,color:color,enableGradient:enableGradient,gradientColor2:gradientColor2,useGradientColor3:useGradientColor3,gradientColor3:gradientColor3,useGradientColor4:useGradientColor4,gradientColor4:gradientColor4,useGradientColor5:useGradientColor5,gradientColor5:gradientColor5,gradientAngle:gradientAngle,bgPosMV:bgPosMV,noiseSVG:noiseSVG,delay:i*stagger,hold:scrambleHold,appearDelay:appearDelay+i*stagger,appearDuration:appearDuration,hoverDuration:scrambleDuration,scrambleOnAppear:scrambleOnAppear,scrambleString:reelBase,charIndex:i,slotWidthMV:slotWidthMV,overrideDelta:overrides[c]??0,clippingWidthMV:clippingWidthMV,reelSpacingMV:reelSpacingMV,scrambleKey:scrambleKey,returnClip:steps[steps.length-1].clippingWidth,returnReel:steps[steps.length-1].reelSpacing,reelBlendMode:reelBlendMode,scrambleClipWidth:scrambleClipWidth,scrambleCharGap:scrambleCharGap,scrambleSlotWidth:scrambleSlotWidth}))));// DOM ancestor walk — runs once on mount (non-editor only).\n// Framer wraps every code component in its own frame divs that have overflow:hidden.\n// A plain inline style can be beaten by stylesheet rules; using setProperty with\n// \"important\" guarantees nothing overrides it, including Framer's own stylesheets.\n// Covers overflow, overflow-x, and overflow-y separately so nothing slips through.\n// Cleanup restores the original value + priority on unmount.\nReact.useEffect(()=>{if(isEditorCanvas||!rootRef.current)return;const restoreList=[];let el=rootRef.current.parentElement;while(el&&el!==document.body){const computed=window.getComputedStyle(el);if(computed.overflow!==\"visible\"||computed.overflowX!==\"visible\"||computed.overflowY!==\"visible\"){const node=el;// Save current inline value + priority for each axis\nconst prev=node.style.getPropertyValue(\"overflow\");const prevPr=node.style.getPropertyPriority(\"overflow\");const prevX=node.style.getPropertyValue(\"overflow-x\");const prevXPr=node.style.getPropertyPriority(\"overflow-x\");const prevY=node.style.getPropertyValue(\"overflow-y\");const prevYPr=node.style.getPropertyPriority(\"overflow-y\");node.style.setProperty(\"overflow\",\"visible\",\"important\");node.style.setProperty(\"overflow-x\",\"visible\",\"important\");node.style.setProperty(\"overflow-y\",\"visible\",\"important\");restoreList.push(()=>{if(prev)node.style.setProperty(\"overflow\",prev,prevPr);else node.style.removeProperty(\"overflow\");if(prevX)node.style.setProperty(\"overflow-x\",prevX,prevXPr);else node.style.removeProperty(\"overflow-x\");if(prevY)node.style.setProperty(\"overflow-y\",prevY,prevYPr);else node.style.removeProperty(\"overflow-y\");});}el=el.parentElement;}return()=>restoreList.forEach(fn=>fn());},[]);// Editor canvas: keep overflow:hidden so the canvas stays tidy.\n// Preview / published: always visible — each ScrambleLetter's clipper div already\n// handles reel clipping, so there's no need for a second boundary here.\n// The fillViewport DOM-walk handles escaping Framer's own ancestor frames.\nconst overflow=isEditorCanvas?\"hidden\":\"visible\";return /*#__PURE__*/React.createElement(\"div\",{ref:rootRef,style:{width:\"100%\",height:\"100%\",display:\"flex\",alignItems:\"center\",justifyContent:\"flex-start\",overflow,position:\"relative\"},onMouseEnter:handleMouseEnter},motionContent);}// ─── Property controls ────────────────────────────────────────────────────────\nconst layoutControls=defaults=>({duration:{type:ControlType.Number,title:\"Duration\",description:\"Transition time from this step to the next (ignored on the last step)\",defaultValue:defaults.duration,min:.1,max:20,step:.1},pause:{type:ControlType.Number,title:\"Step Pause\",description:\"How long to hold at this step before animating to the next. On Step 1 this is the initial delay before the animation begins. Ignored on the last step.\",defaultValue:defaults.pause??.5,min:0,max:10,step:.1},fontSize:{type:ControlType.Number,title:\"Size\",defaultValue:defaults.fontSize,min:10,max:1200},slotWidth:{type:ControlType.Number,title:\"Letter Width\",description:\"Width of each letter's container box. Letter Gap adds space between box edges. Clip Width can overflow this box on both sides to create the blend overlap effect.\",defaultValue:defaults.slotWidth,min:0,max:800,unit:\"px\"},spacing:{type:ControlType.Number,title:\"Letter Gap\",description:\"Gap between letter containers\",defaultValue:defaults.spacing,min:-500,max:500},clippingWidth:{type:ControlType.Number,title:\"Clip Width\",description:\"Visual window per letter — if wider than Letter Width, the reel overflows into neighbouring slots creating the blend overlap effect\",defaultValue:defaults.clippingWidth,min:0,max:1e3,unit:\"px\"},reelSpacing:{type:ControlType.Number,title:\"Char Gap\",description:\"Distance between characters within each reel\",defaultValue:defaults.reelSpacing,min:0,max:500,unit:\"px\"},widthOverrides:{type:ControlType.String,title:\"Width Overrides\",defaultValue:defaults.widthOverrides??\"\",placeholder:\"Y:-50, W:-30\",description:'Per-character letter width delta for this step. Format: char:delta — e.g. \"Y:-50\" makes Y 50px narrower. Comma-separate multiple entries.'},offsetX:{type:ControlType.Number,title:\"Offset X\",description:\"Horizontal position of the text block within the component (px from left edge). Lerps smoothly between steps.\",defaultValue:0,min:-2e3,max:2e3,step:1},offsetY:{type:ControlType.Number,title:\"Offset Y\",description:\"Vertical offset from the component's vertical centre (px). Negative moves up, positive moves down. Lerps smoothly between steps.\",defaultValue:0,min:-2e3,max:2e3,step:1},fillViewport:{type:ControlType.Boolean,title:\"Fill Viewport\",description:\"When on, the component escapes its Framer frame and fills the full browser viewport once the animation reaches this step. Only the main canvas is excluded — works in preview and on the published site.\",defaultValue:false}});addPropertyControls(ScrambleTumbler,{text:{type:ControlType.String,title:\"Text\",defaultValue:\"TOBYS.DESIGN\"},color:{type:ControlType.Color,title:\"Color\",defaultValue:\"#ABABAB\"},enableGradient:{type:ControlType.Boolean,title:\"Anim Gradient\",defaultValue:true},gradientColor2:{type:ControlType.Color,title:\"Grad Color 2\",defaultValue:\"#f9a3da\",hidden:p=>!p.enableGradient},useGradientColor3:{type:ControlType.Boolean,title:\"3rd Color\",defaultValue:true,hidden:p=>!p.enableGradient},gradientColor3:{type:ControlType.Color,title:\"Grad Color 3\",defaultValue:\"#c840bb\",hidden:p=>!p.enableGradient||!p.useGradientColor3},useGradientColor4:{type:ControlType.Boolean,title:\"4th Color\",defaultValue:false,hidden:p=>!p.enableGradient},gradientColor4:{type:ControlType.Color,title:\"Grad Color 4\",defaultValue:\"#4169E1\",hidden:p=>!p.enableGradient||!p.useGradientColor4},useGradientColor5:{type:ControlType.Boolean,title:\"5th Color\",defaultValue:false,hidden:p=>!p.enableGradient},gradientColor5:{type:ControlType.Color,title:\"Grad Color 5\",defaultValue:\"#9370DB\",hidden:p=>!p.enableGradient||!p.useGradientColor5},gradientAngle:{type:ControlType.Number,title:\"Grad Angle\",defaultValue:356,min:0,max:360,step:1,displayStepper:true,hidden:p=>!p.enableGradient},gradientSpeed:{type:ControlType.Number,title:\"Grad Speed\",defaultValue:4,min:.1,max:20,step:.1,displayStepper:true,hidden:p=>!p.enableGradient},font:{type:ControlType.Font,title:\"Font\",controls:\"extended\",defaultValue:{fontFamily:\"Inter\",fontWeight:900,fontStyle:\"normal\"}},// ── Fill viewport ────────────────────────────────────────────────────\nfillViewport:{type:ControlType.Boolean,title:\"Fill Viewport\",description:\"When on, removes the component's overflow clipping once the animation finishes — text at large step sizes spills beyond the frame boundary and fills the viewport. Requires parent containers to be overflow:visible (Framer's default for sticky sections). Blocked on the editor canvas.\",defaultValue:false},// ── Steps array — add/remove steps freely ────────────────────────────\nstepsState:{type:ControlType.Array,title:\"Steps\",control:{type:ControlType.Object,controls:layoutControls(DEFAULT_STEP1)},defaultValue:DEFAULT_STEPS},// ── Canvas step preview selector ──────────────────────────────────────\npreviewStep:{type:ControlType.Number,title:\"Preview Step\",description:\"Which step to display in the canvas editor so you can design each one. 1 = first step, 0 = last step (default). Has no effect on the published animation — that always plays all steps in order.\",defaultValue:0,min:0,max:20,step:1},// ── Hover scramble overrides ──────────────────────────────────────────\n// When set, these temporarily replace the step values during hover scramble,\n// then smoothly restore to the step values once all letters finish.\nscrambleClipWidth:{type:ControlType.Number,title:\"Scramble Clip Width\",description:\"Clip Width during hover scramble. Leave unset to use the current step value. Widens the visible window while letters spin, then snaps back.\",defaultValue:undefined,min:0,max:4e3,step:1,unit:\"px\",optional:true},scrambleCharGap:{type:ControlType.Number,title:\"Scramble Char Gap\",description:\"Char Gap during hover scramble. Leave unset to use the current step value.\",defaultValue:undefined,min:0,max:500,step:1,unit:\"px\",optional:true},scrambleSlotWidth:{type:ControlType.Number,title:\"Scramble Letter Width\",description:\"Letter Width during hover scramble. Leave unset to use the current step value.\",defaultValue:undefined,min:0,max:800,step:1,unit:\"px\",optional:true},reelBlendMode:{type:ControlType.Enum,title:\"Reel Blend\",defaultValue:\"difference\",options:[\"normal\",\"difference\",\"exclusion\",\"overlay\",\"multiply\",\"screen\",\"hard-light\",\"soft-light\",\"color-dodge\",\"color-burn\",\"darken\",\"lighten\",\"hue\",\"saturation\",\"color\",\"luminosity\"]},// ── Timing ───────────────────────────────────────────────────────────\nscrambleOnAppear:{type:ControlType.Boolean,title:\"Scramble on Appear\",description:\"When off, letters snap directly to their settled position on load — no reel spin. Hover scramble is unaffected.\",defaultValue:true},appearDelay:{type:ControlType.Number,title:\"Appear Delay\",description:\"Seconds to wait before the first letter starts appearing. Per-letter stagger is controlled by the Stagger setting. Has no effect when Scramble on Appear is off.\",defaultValue:0,min:0,max:10,step:.1,hidden:p=>!p.scrambleOnAppear},appearDuration:{type:ControlType.Number,title:\"Appear Duration\",description:\"Speed of the initial reel fly-in animation in seconds. Has no effect when Scramble on Appear is off.\",defaultValue:1.5,min:.1,max:10,step:.1,hidden:p=>!p.scrambleOnAppear},scrambleDuration:{type:ControlType.Number,title:\"Hover Duration\",description:\"Speed of the hover re-scramble reel animation in seconds\",defaultValue:1.5,min:.1,max:10,step:.1},hoverDelay:{type:ControlType.Number,title:\"Hover Lock\",description:\"Lock hover animation for period on appear. Leave at 0 to auto-unlock when the step animation finishes.\",defaultValue:0,min:0,max:30,step:.5},stagger:{type:ControlType.Number,title:\"Stagger\",defaultValue:.12,step:.01},scrambleHold:{type:ControlType.Number,title:\"Letter Hold\",description:\"Delay before the letter reel spin-in animation starts. Separate from the step animation — use Step 1's Step Pause to control when step transitions begin.\",defaultValue:.3,min:0,max:2,step:.1},// ── Grainy Noise ──────────────────────────────────────────────────────\nenableNoise:{type:ControlType.Boolean,title:\"Grain Noise\",description:\"Applies a subtle grainy texture overlay\",defaultValue:false},noiseOpacity:{type:ControlType.Number,title:\"Noise Opacity\",description:\"Intensity of the grain effect\",defaultValue:.15,min:0,max:1,step:.05,hidden:p=>!p.enableNoise},noiseScale:{type:ControlType.Number,title:\"Noise Scale\",description:\"Grain size - higher = finer grain\",defaultValue:2,min:.5,max:5,step:.1,hidden:p=>!p.enableNoise}});\nexport const __FramerMetadata__ = {\"exports\":{\"default\":{\"type\":\"reactComponent\",\"name\":\"ScrambleTumbler\",\"slots\":[],\"annotations\":{\"framerContractVersion\":\"1\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}\n//# sourceMappingURL=./SCRAMLELOGO.map"],"mappings":"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"}