{"version":3,"file":"SCRAMLELOGO.U5eNnHRQ.mjs","names":["React.useRef","React.useState","React.useMemo","React.useCallback"],"sources":["https:/framerusercontent.com/modules/ldkbWzucphIxLS3cNGx5/sF1hlRyN5FW0SHWwNfJt/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,isOutline,outlineColor,strokeWidth,charIndex,slotWidthMV,overrideDelta,clippingWidthMV,reelSpacingMV,scrambleKey}){const xValue=useMotionValue(0);const velocity=useVelocity(xValue);const directionRef=React.useRef(charIndex%2===0?1:-1);// 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);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: shared slotWidthMV + per-char delta ──\n// Updated via MotionValue subscription (no React render needed for animation)\nconst effectiveSlotWidthMV=useMotionValue(slotWidthMV.get()+overrideDelta);useMotionValueEvent(slotWidthMV,\"change\",v=>{effectiveSlotWidthMV.set(v+overrideDeltaRef.current);});// Also re-sync when overrideDelta changes (from React state update)\nReact.useEffect(()=>{effectiveSlotWidthMV.set(slotWidthMV.get()+overrideDelta);},[overrideDelta]);// ── Reel cell width: measuredWidth + reelSpacing ──────────────────────────\nconst rsMV=useMotionValue((measuredWidth||fontSize)+reelSpacingMV.get());useMotionValueEvent(reelSpacingMV,\"change\",rs=>{rsMV.set((measuredWidthRef.current||fontSize)+rs);});React.useEffect(()=>{rsMV.set((measuredWidth||fontSize)+reelSpacingMV.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]);const textStyle={color,fontFamily:font?.fontFamily??\"Inter, sans-serif\",fontWeight:font?.fontWeight??900,fontStyle:font?.fontStyle??\"normal\",fontVariationSettings:font?.fontVariationSettings??undefined,letterSpacing:font?.letterSpacing??undefined,WebkitTextStroke:isOutline?`${strokeWidth}px ${outlineColor}`:\"none\",WebkitTextFillColor:isOutline?\"transparent\":color};// ── Measure glyph width ───────────────────────────────────────────────────\nReact.useLayoutEffect(()=>{// Reset appear state so the animation replays whenever this effect re-runs.\n// In Framer's canvas the component re-renders (without unmounting) when props\n// change, leaving hasAppeared=true and preventing the scramble from re-firing.\n// Resetting here ensures a fresh animation each time font/char/fontSize changes.\nhasAppeared.current=false;setShowReel(false);setMeasuredWidth(0);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){const step=w+reelSpacingMV.get();const baseline=getBaseline(clippingWidthMV.get(),step);// When scrambleOnAppear is off, start already at baseline\n// so letters never flash at the off-screen reel position.\nxValue.set(scrambleOnAppearRef.current?baseline+3*directionRef.current*step:baseline);}setShowReel(true);}}});observer.observe(measure);return()=>observer.disconnect();},[fontSize,JSON.stringify(font),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]);// ── Initial scramble ──────────────────────────────────────────────────────\nReact.useEffect(()=>{if(!showReel||measuredWidth===0||hasAppeared.current)return;const step=measuredWidth+reelSpacingMV.get();const baseline=getBaseline(clippingWidthMV.get(),step);hasAppeared.current=true;// When scrambleOnAppear is disabled, skip the reel animation entirely —\n// the ResizeObserver already positioned xValue at baseline, so just mark done.\nif(!scrambleOnAppear){return()=>{hasAppeared.current=false;};}// Raise the flag BEFORE starting so baseline-tracking listeners (driven by the\n// concurrent step RAF loop) don't fight the animation on every frame.\n// Also: use setTimeout+onComplete instead of async/await — framer-motion's\n// animate() thenable is not reliable in all Framer versions.\nisAppearAnimatingRef.current=true;let cancelled=false;let anim=null;const delayMs=((appearDelay||0)+(hold||.2))*1e3;const timer=setTimeout(()=>{if(cancelled)return;anim=animate(xValue,baseline,{duration:appearDuration||1.5,ease:\"easeInOut\",onComplete:()=>{if(cancelled)return;isAppearAnimatingRef.current=false;// Snap once to current baseline — the step animation may have moved\n// clippingWidthMV/reelSpacingMV while appear was playing, so re-centre.\nif(!isHoverAnimatingRef.current){const w=measuredWidthRef.current;if(w>0)xValue.set(getBaseline(clippingWidthMV.get(),w+reelSpacingMV.get()));}}});},delayMs);return()=>{// Reset hasAppeared so this effect can replay after cleanup.\n// Critical for React StrictMode: effects intentionally run twice\n// (mount → cleanup → remount). Without this reset, the second mount\n// sees hasAppeared=true and skips the animation entirely.\ncancelled=true;clearTimeout(timer);anim?.stop?.();isAppearAnimatingRef.current=false;hasAppeared.current=false;};},[measuredWidth,showReel,delay,hold,appearDuration,scrambleOnAppear]);// ── 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 is re-sampled\n//                                 from LIVE MV values at the moment phase 2 starts,\n//                                 so it always lands correctly whatever the MVs are doing\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;// Use setTimeout for the stagger delay rather than Framer's delay option.\n// This keeps isHoverAnimatingRef=false during the wait so baseline tracking\n// stays active — letters remain correctly positioned as scramble overrides\n// change the MVs, preventing the \"blank letters staggering on\" glitch.\nconst timer=setTimeout(()=>{// Snapshot current xValue and MV state now that we're actually starting.\n// Baseline tracking has been running up to this point, so values are correct.\nisHoverAnimatingRef.current=true;const step0=measuredWidthRef.current+reelSpacingMV.get();const base0=getBaseline(clippingWidthMV.get(),step0);const farPos=base0+3*directionRef.current*step0;anim1=animate(xValue,[xValue.get(),farPos],{duration:p1Dur,ease:\"easeOut\",onComplete:()=>{// Phase 2: re-sample live MV values for the correct landing baseline.\nconst liveStep=measuredWidthRef.current+reelSpacingMV.get();const liveBaseline=getBaseline(clippingWidthMV.get(),liveStep);anim2=animate(xValue,liveBaseline,{duration:p2Dur,ease:\"easeOut\",onComplete:()=>{isHoverAnimatingRef.current=false;}});}});},delay*1e3);return()=>{clearTimeout(timer);anim1?.stop?.();anim2?.stop?.();isHoverAnimatingRef.current=false;};},[scrambleKey]);return /*#__PURE__*/React.createElement(motion.div,{ref:containerRef,style:{position:\"relative\",display:\"inline-flex\",width:effectiveSlotWidthMV,height:\"1.2em\",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}},char===\" \"?\"\\xa0\":char),/*#__PURE__*/React.createElement(motion.div,{style:{position:\"absolute\",left:\"50%\",top:\"50%\",width:clippingWidthMV,height:\"140%\",transform:\"translate(-50%,-50%)\",overflow:\"hidden\",pointerEvents:\"none\",mixBlendMode:\"difference\"}},/*#__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})))));}// ─── SliceLayer ───────────────────────────────────────────────────────────────\nfunction SliceLayer({slice,xValue,velocity,shearIntensity,rsMV,textStyle,reelChars}){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:\"difference\"}},/*#__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,widthOverrides:\"\",offsetX:0,offsetY:0};const DEFAULT_STEP2={fontSize:735,slotWidth:144,spacing:-308,clippingWidth:576,reelSpacing:174,duration:2,widthOverrides:\"\",offsetX:0,offsetY:0};const DEFAULT_STEP3={fontSize:1200,slotWidth:33,spacing:-500,clippingWidth:999,reelSpacing:0,duration:2,widthOverrides:\"\",offsetX:0,offsetY:0};// Shared easing curve — cubic ease-in-out\nconst cubicEaseInOut=x=>{const t=Math.max(0,Math.min(1,x));return t<.5?4*t*t*t:1-Math.pow(-2*t+2,3)/2;};// 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;}// Lerp two parsed override maps — missing key treated as 0\nfunction lerpOverrides(fromStr,toStr,e){const from=parseOverrides(fromStr||\"\");const to=parseOverrides(toStr||\"\");const keys=new Set([...Object.keys(from),...Object.keys(to)]);const result={};keys.forEach(k=>{result[k]=(from[k]??0)+((to[k]??0)-(from[k]??0))*e;});return result;}const DEFAULT_STEPS=[DEFAULT_STEP1,DEFAULT_STEP2,DEFAULT_STEP3];export default function ScrambleTumbler({text=\"TOBYS.DESIGN\",color=\"#ABABAB\",font,isOutline=false,outlineColor=\"#000\",strokeWidth=1,stagger=.12,scrambleHold=.3,appearDelay=0,appearDuration=1.5,scrambleDuration=1.5,scrambleOnAppear=true,hoverDelay=0,fillViewport=false,stepDelay=.5,// Scramble-specific overrides — applied during hover, restored after\nscrambleClipWidth,scrambleCharGap,scrambleSlotWidth,scrollProgress,stepsState}){// Merge incoming array with defaults; fall back to built-in 3-step sequence\nconst steps=stepsState&&stepsState.length>0?stepsState:DEFAULT_STEPS;// Scroll mode: when scrollProgress is wired, scrub replaces RAF transitions.\nconst scrollMode=scrollProgress!==null&&scrollProgress!==undefined;const scrollProgressRef=React.useRef(scrollProgress);scrollProgressRef.current=scrollProgress;// 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;const scrollModeRef=React.useRef(scrollMode);scrollModeRef.current=scrollMode;// 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);}},[]);// Timer that restores step MV values after a hover scramble completes\nconst scrambleReturnTimerRef=React.useRef(null);// Snapshot of MV values before scramble — so rapid re-hovers return to the\n// correct step values, not to mid-scramble values\nconst scrambleBaseRef=React.useRef(null);const isScramblingRef=React.useRef(false);// 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||\"\"));// ── Core animation runner ────────────────────────────────────────────────\n// Drives Step[0] → Step[1] → … → Step[n-1] in a single RAF loop.\n// Each transition takes that step's own Duration; stepDelay pauses between them.\nconst runAnimation=React.useCallback(()=>{const del=holdRef.current*1e3;animDoneRef.current=false;const first=stepsRef.current[0]||DEFAULT_STEP1;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||\"\");overridesRef.current=firstOvr;setOverrides(firstOvr);// Scroll mode: letters still scramble on mount, but layout stays at\n// step 0 — scroll scrubs the transitions instead of time.\nif(scrollModeRef.current){animDoneRef.current=true;return()=>{};}let startTime=null;let rafId;let cancelled=false;const tick=now=>{if(cancelled)return;if(startTime===null)startTime=now+del;const elapsed=Math.max(0,now-startTime);const ss=stepsRef.current;const n=ss.length;const sdl=stepDelayRef.current*1e3;if(n<=1){animDoneRef.current=true;return;}// Each segment uses its own step's duration.\n// Compute totalDur and find current segment in one pass.\nlet from=ss[n-1],to=ss[n-1],e=1;let cursor=0,totalDur=0;for(let i=0;i<n-1;i++){const segDur=(ss[i].duration??2)*1e3;const isLast=i===n-2;const transEnd=cursor+segDur;const segEnd=isLast?transEnd:transEnd+sdl;totalDur=segEnd;if(elapsed<transEnd){from=ss[i];to=ss[i+1];e=cubicEaseInOut((elapsed-cursor)/segDur);break;}else if(!isLast&&elapsed<segEnd){from=to=ss[i+1];e=0;break;}cursor=segEnd;}const lerp=(a,b)=>a+(b-a)*e;fontSizeMV.set(lerp(from.fontSize,to.fontSize));spacingMV.set(lerp(from.spacing,to.spacing));slotWidthMV.set(lerp(from.slotWidth,to.slotWidth));clippingWidthMV.set(lerp(from.clippingWidth,to.clippingWidth));reelSpacingMV.set(lerp(from.reelSpacing,to.reelSpacing));offsetXMV.set(lerp(from.offsetX??0,to.offsetX??0));offsetYMV.set(lerp(from.offsetY??0,to.offsetY??0));// Overrides only cause React re-renders when non-empty strings are defined\nconst fromOvr=from.widthOverrides||\"\";const toOvr=to.widthOverrides||\"\";if(fromOvr||toOvr){const newOvr=lerpOverrides(fromOvr,toOvr,e);overridesRef.current=newOvr;setOverrides(newOvr);}else if(Object.keys(overridesRef.current).length>0){overridesRef.current={};setOverrides({});}if(elapsed<totalDur){rafId=requestAnimationFrame(tick);}else{animDoneRef.current=true;}};rafId=requestAnimationFrame(tick);return()=>{cancelled=true;cancelAnimationFrame(rafId);};},[]);// ── Appear animation — runs once on mount ────────────────────────────────\nReact.useEffect(()=>runAnimation(),[]);// ── 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);};// ── Scroll scrub ─────────────────────────────────────────────────────────\n// Maps a 0–1 progress value across the step transitions, weighted by each\n// step's duration so a longer duration = more scroll range for that segment.\nconst scrubToProgress=React.useCallback(p=>{const ss=stepsRef.current;const n=ss.length;if(n<=1)return;// Each of the n-1 transitions gets a weight proportional to the FROM step's duration.\nconst weights=ss.slice(0,n-1).map(s=>Math.max(.01,s.duration??2));const totalW=weights.reduce((a,b)=>a+b,0);const clamped=Math.max(0,Math.min(1,p));let cursor=0;let from=ss[0],to=ss[Math.min(1,n-1)],e=0;for(let i=0;i<n-1;i++){const segEnd=cursor+weights[i]/totalW;if(clamped<=segEnd||i===n-2){from=ss[i];to=ss[i+1];const localT=(clamped-cursor)/(weights[i]/totalW);// Scroll-driven: use linear mapping — the user's hand already controls\n// pacing. Applying easing here makes the ends of each segment feel\n// unresponsive, especially when scrolling back (scale-down direction).\ne=Math.max(0,Math.min(1,localT));break;}cursor=segEnd;}const lerp=(a,b)=>a+(b-a)*e;fontSizeMV.set(lerp(from.fontSize,to.fontSize));spacingMV.set(lerp(from.spacing,to.spacing));slotWidthMV.set(lerp(from.slotWidth,to.slotWidth));clippingWidthMV.set(lerp(from.clippingWidth,to.clippingWidth));reelSpacingMV.set(lerp(from.reelSpacing,to.reelSpacing));offsetXMV.set(lerp(from.offsetX??0,to.offsetX??0));offsetYMV.set(lerp(from.offsetY??0,to.offsetY??0));const fromOvr=from.widthOverrides||\"\";const toOvr=to.widthOverrides||\"\";if(fromOvr||toOvr){const newOvr=lerpOverrides(fromOvr,toOvr,e);overridesRef.current=newOvr;setOverrides(newOvr);}else if(Object.keys(overridesRef.current).length>0){overridesRef.current={};setOverrides({});}},[]);// Drive scrub whenever scrollProgress prop changes\nReact.useEffect(()=>{if(!scrollMode)return;scrubToProgress(scrollProgress);},[scrollProgress,scrollMode]);// Increments on each hover to trigger a re-scramble in every ScrambleLetter\nconst[scrambleKey,setScrambleKey]=React.useState(0);const prevStepsJsonRef=React.useRef(\"\");React.useEffect(()=>{if(!animDoneRef.current)return;const ss=stepsRef.current;if(ss.length===0)return;const currJson=JSON.stringify(stepsState);const prevJson=prevStepsJsonRef.current;prevStepsJsonRef.current=currJson;try{const prev=prevJson?JSON.parse(prevJson):[];let idx=ss.length-1// default: last step\n;if(ss.length===prev.length){// Same length — find the first step that differs\nfor(let i=0;i<ss.length;i++){if(JSON.stringify(ss[i])!==JSON.stringify(prev[i])){idx=i;break;}}}// If length changed (add/remove), snap to last (idx already = ss.length - 1)\nsnapTo(ss[idx]);}catch{snapTo(ss[ss.length-1]);}},[JSON.stringify(stepsState)]);const reelBase=React.useMemo(()=>(text||\"TOBYS\").replace(/\\s/g,\"\")||\"OTYWSLE\",[text]);// fillViewport: apply position:fixed on the published/preview site so the component\n// escapes its Framer container and covers the full viewport.\n// In the canvas editor we render normally so the canvas stays usable.\n// RenderTarget.canvas is true only inside the Framer canvas editor —\n// it returns false in preview and on published sites.\n// No portal needed: published Framer sites don't have the canvas transform\n// hierarchy that traps position:fixed, so it works natively.\nconst isCanvas=RenderTarget.current()===RenderTarget.canvas;const wrapperStyle=fillViewport&&!isCanvas?{position:\"fixed\",inset:0,zIndex:9999,display:\"flex\",alignItems:\"center\",justifyContent:\"flex-start\",overflow:\"hidden\"}:{width:\"100%\",height:\"100%\",display:\"flex\",alignItems:\"center\",justifyContent:\"flex-start\",overflow:\"hidden\"};const inner=/*#__PURE__*/React.createElement(\"div\",{style:wrapperStyle,onMouseEnter:()=>{// 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);const hasOverrides=scrambleClipWidth!=null||scrambleCharGap!=null||scrambleSlotWidth!=null;if(!hasOverrides)return;// Only snapshot step values on first hover (not on rapid re-hover)\nif(!isScramblingRef.current){scrambleBaseRef.current={clip:clippingWidthMV.get(),reel:reelSpacingMV.get(),slot:slotWidthMV.get()};}isScramblingRef.current=true;clearTimeout(scrambleReturnTimerRef.current);// Clip/reel/slot animate IN over 40% of the hover duration,\n// then sweep back out over another 40% — symmetric ease-in-out arc.\nconst totalDur=scrambleDuration||1.5;const inDur=totalDur*.4;const outDur=totalDur*.4;if(scrambleClipWidth!=null)animate(clippingWidthMV,scrambleClipWidth,{duration:inDur,ease:\"easeInOut\"});if(scrambleCharGap!=null)animate(reelSpacingMV,scrambleCharGap,{duration:inDur,ease:\"easeInOut\"});if(scrambleSlotWidth!=null)animate(slotWidthMV,scrambleSlotWidth,{duration:inDur,ease:\"easeInOut\"});// Return fires exactly when the in-animation completes\nscrambleReturnTimerRef.current=setTimeout(()=>{const base=scrambleBaseRef.current;if(!base)return;isScramblingRef.current=false;if(scrambleClipWidth!=null)animate(clippingWidthMV,base.clip,{duration:outDur,ease:\"easeInOut\"});if(scrambleCharGap!=null)animate(reelSpacingMV,base.reel,{duration:outDur,ease:\"easeInOut\"});if(scrambleSlotWidth!=null)animate(slotWidthMV,base.slot,{duration:outDur,ease:\"easeInOut\"});},inDur*1e3);}},/*#__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)=>// Each letter sits in a slotWidth-wide flex item.\n    // spacingMV drives marginRight — supports negative values\n    // (overlap) unlike CSS gap, and enables hover animation.\n    /*#__PURE__*/React.createElement(motion.div,{key:i,style:{flexShrink:0,marginRight:spacingMV}},/*#__PURE__*/React.createElement(ScrambleLetter,{char:c,fontSize:steps[0]?.fontSize??DEFAULT_STEP1.fontSize,font:font,color:color,outlineColor:outlineColor,delay:i*stagger,hold:scrambleHold,appearDelay:appearDelay+i*stagger,appearDuration:appearDuration,hoverDuration:scrambleDuration,scrambleOnAppear:scrambleOnAppear,scrambleString:reelBase,isOutline:isOutline,strokeWidth:strokeWidth,charIndex:i,slotWidthMV:slotWidthMV,overrideDelta:overrides[c]??0,clippingWidthMV:clippingWidthMV,reelSpacingMV:reelSpacingMV,scrambleKey:scrambleKey})))));return inner;}// ─── 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},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}});addPropertyControls(ScrambleTumbler,{text:{type:ControlType.String,title:\"Text\",defaultValue:\"TOBYS.DESIGN\"},color:{type:ControlType.Color,title:\"Color\",defaultValue:\"#ABABAB\"},font:{type:ControlType.Font,title:\"Font\",controls:\"extended\",defaultValue:{fontFamily:\"Inter\",fontWeight:900,fontStyle:\"normal\"}},// ── Scroll scrub ─────────────────────────────────────────────────────\nscrollProgress:{type:ControlType.Number,title:\"Scroll Progress\",description:\"Connect to a Framer Scroll component's scrollYProgress (0–1). When wired, scroll scrubs the step transitions instead of time. Each step's Duration controls how much scroll range its transition occupies.\",defaultValue:undefined,min:0,max:1,step:.001,optional:true},// ── Steps array — add/remove steps freely ────────────────────────────\nstepsState:{type:ControlType.Array,title:\"Steps\",control:{type:ControlType.Object,controls:layoutControls(DEFAULT_STEP1)},defaultValue:DEFAULT_STEPS},// ── 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},// ── Layout ───────────────────────────────────────────────────────────\nfillViewport:{type:ControlType.Boolean,title:\"Fill Viewport\",description:\"When on, the component ignores its Framer frame size and fills the full browser viewport. Useful when the component is inside scaled or nested frames.\",defaultValue:false},// ── 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:\"Seconds after load before hover scramble is enabled. Set this to match your total step animation time to prevent hover triggering mid-animation. Leave at 0 to auto-unlock when the step animation finishes.\",defaultValue:0,min:0,max:30,step:.5},stepDelay:{type:ControlType.Number,title:\"Step Pause\",description:\"Pause at Step 2 before continuing to Step 3\",defaultValue:.5,min:0,max:5,step:.1},stagger:{type:ControlType.Number,title:\"Stagger\",defaultValue:.12,step:.01},scrambleHold:{type:ControlType.Number,title:\"Initial Hold\",defaultValue:.3,min:0,max:2,step:.1},// ── Outline ───────────────────────────────────────────────────────────\nisOutline:{type:ControlType.Boolean,title:\"Outline\",defaultValue:false},outlineColor:{type:ControlType.Color,title:\"Stroke Color\",defaultValue:\"#000\",hidden:p=>!p.isOutline},strokeWidth:{type:ControlType.Number,title:\"Stroke Width\",defaultValue:1,min:1,max:10,step:.5,hidden:p=>!p.isOutline}});\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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"}