{"version":3,"file":"CarouselMotionOverrides.BkagS-sn.mjs","names":["useState","useCallback","useRef"],"sources":["https:/framerusercontent.com/modules/qQ4dBIL3GKa8W960gxtX/7keb0bLuiIaDooBiVbFV/CarouselMotionOverrides.js"],"sourcesContent":["/**\n * Code built by Kamil Leśniak - Designer & Framer Expert PRO\n * Learn more on digitalkamil.com\n */// Horizontal carousel overrides built on Framer Motion, as an alternative to the\n// hand-rolled physics in CarouselOverrides.tsx.\n//\n// The important architectural difference is how a release is resolved. The older\n// file accumulates pointer deltas and lands on the closest snap to that running\n// total, so any platform quirk in event delivery feeds straight into the result\n// and the strip can land nowhere near where it visibly is. Here the strip's\n// position IS a MotionValue, and the landing is the closest snap to that\n// value plus a bounded velocity projection. The landing is therefore always\n// within about one and a half cards of what the user is actually looking at —\n// bounded by the projection clamp and snap rounding — whatever the browser does\n// with the event stream. That bound is the fix: the old file had no bound at\n// all, which is how a swipe could end up at the far end of the track.\n//\n// Other things taken from how Framer Motion drives its own drag:\n//   - move/up/cancel listeners live on `window`, so nothing — an embed, an\n//     iframe, a hit-test change, a failed pointer capture — can lose the gesture\n//     halfway through\n//   - velocity comes from MotionValue.getVelocity(), which is derived from a\n//     timestamped sample history rather than one Date.now() delta that can be 0\n//   - the release is a spring carrying that velocity, so a throw decelerates\n//     instead of easing from a standing start\n//\n// NOTE: this file keeps its own store registry. Pair cards and arrows from the\n// SAME file — mixing these overrides with CarouselOverrides.tsx will not connect.\nimport{jsx as _jsx}from\"react/jsx-runtime\";import{useRef,useEffect,useLayoutEffect,useCallback,useState,useId,startTransition}from\"react\";import{animate,useMotionValue}from\"framer-motion\";const DIRECTION_LOCK_THRESHOLD=8;// Safari commits to a page scroll within a handful of pixels, so lock sooner on\n// touch. On mouse a threshold this small makes ordinary clicks feel draggy.\nconst TOUCH_LOCK_THRESHOLD=5;// How far ahead a throw is projected, in seconds of travel at the release\n// velocity. Framer Motion's inertia does the same thing with a decay curve; a\n// short linear projection is close enough over this distance and stays\n// predictable, which matters more here than physical exactness.\nconst PROJECTION_SECONDS=.18;// The projection is additionally clamped to this multiple of one card step, so a\n// hard flick can never fling the strip across the whole track.\nconst MAX_PROJECTION_STEPS=1;// A release slower than this (px/s) is a drag, not a flick, and simply lands on\n// whatever snap it is nearest.\nconst FLICK_VELOCITY=300;// Optional hard ceiling on cards crossed per gesture. Left uncapped by default:\n// the landing is already tied to the strip's visible position, so crossing three\n// cards only happens when three cards were visibly dragged past, and capping it\n// would spring a long deliberate drag backwards instead. Set to 1 if a strict\n// one-card-per-swipe feel is wanted for its own sake.\nconst MAX_CARDS_PER_GESTURE=Infinity;// Release spring. Stiffness/damping tuned to settle in roughly 400ms without\n// visible overshoot on a card-sized move.\nconst SNAP_SPRING={type:\"spring\",stiffness:320,damping:40,restDelta:.4};const CAROUSEL_VERSION=\"2026-09-11-trackpad-swipe\";// useLayoutEffect warns during SSR — fall back to useEffect on the server.\nconst useIsoLayoutEffect=typeof document!==\"undefined\"?useLayoutEffect:useEffect;const DEFAULT_KEY=\"__default__\";const GROUP_ATTR=\"data-carousel-motion-group\";const registry=new Map;function getEntry(key){let entry=registry.get(key);if(!entry){entry={state:{currentIndex:0,maxIndex:0},listeners:new Set};registry.set(key,entry);}return entry;}function setEntry(key,partial){const entry=getEntry(key);const next={...entry.state,...partial};if(next.currentIndex===entry.state.currentIndex&&next.maxIndex===entry.state.maxIndex){return;// nothing changed — don't wake every subscriber\n}entry.state=next;entry.listeners.forEach(listener=>listener());}function useCarousel(key){const[,force]=useState(0);useEffect(()=>{const entry=getEntry(key);const listener=()=>force(n=>n+1);entry.listeners.add(listener);listener()// sync up in case state changed before we subscribed\n;return()=>{entry.listeners.delete(listener);};},[key]);const set=useCallback(partial=>setEntry(key,partial),[key]);return[getEntry(key).state,set];}// Nearest ancestor decides: an explicit \"-carousel\"/\"-nav\" name beats a group\n// wrapper higher up, and both keep working side by side.\nfunction resolveKey(el,suffix){let node=el;while(node){const candidates=[node.getAttribute(\"data-framer-name\"),node.id];for(const name of candidates){if(name&&name.toLowerCase().endsWith(suffix)){const prefix=name.slice(0,name.length-suffix.length).trim();if(prefix)return prefix;}}const group=node.getAttribute(GROUP_ATTR);if(group)return group;node=node.parentElement;}return DEFAULT_KEY;}function useResolvedKey(ref,suffix){const[key,setKey]=useState(DEFAULT_KEY);useEffect(()=>{if(ref.current)setKey(resolveKey(ref.current,suffix));},[]);return key;}// The carousel only runs as a horizontal flex row. Any other layout — a desktop\n// grid breakpoint, a column stack — disables it so children flow normally.\nfunction isHorizontalLayout(el){const cs=window.getComputedStyle(el);if(cs.display.includes(\"grid\"))return false;if(cs.display.includes(\"flex\")){return cs.flexDirection===\"row\"||cs.flexDirection===\"row-reverse\";}return false;}// A trackpad's two-finger horizontal swipe arrives as wheel events, and macOS\n// keeps sending them — the momentum tail — for a good while after the fingers\n// have lifted. There is no event for \"the gesture ended\", so the end is\n// inferred from a quiet period: long enough that the tail doesn't read as\n// several separate gestures, short enough that the snap doesn't feel delayed.\nconst WHEEL_SETTLE_MS=90;// Travel before a wheel gesture commits to an axis. A trackpad swipe is never\n// perfectly straight, and without a lock the vertical slop in a horizontal\n// swipe pans the page while the strip moves — the same fight the pointer drag\n// locks out. Once locked, the axis holds for the whole gesture including its\n// momentum, so a tail that drifts diagonal can't flip it.\nconst WHEEL_AXIS_LOCK_PX=6;// How far past the first or last card a wheel gesture may push. Without a\n// ceiling a hard flick into the edge banks up hundreds of pixels of overscroll\n// that all have to be undone before the strip moves back at all.\nconst WHEEL_OVERSCROLL_PX=120;// How long after a drag an activation coming out of the strip stays vetoed.\n// A window rather than a bare flag: a flag cleared by the first click is left\n// armed forever by a gesture that never produces one (every touch swipe), and\n// would then swallow an unrelated keyboard-driven click, which arrives with no\n// pointerdown to reset it.\nconst CLICK_SUPPRESS_MS=500;// Framer wraps a card in an extra div when its component instance has\n// per-breakpoint variants: `<div class=\"ssr-variant hidden-…\">` with CSS\n// `.ssr-variant { display: contents }` (and `display: none !important` on the\n// copies belonging to other breakpoints). A display:contents element generates\n// no box — its rect measures 0×0 and a transform written to it is ignored — so\n// treating the container's DIRECT children as the cards silently kills the\n// carousel: every snap point measures identical, maxIndex collapses to 0, both\n// arrows disable, and drags move nothing while the grab cursor still shows.\n// Resolve every direct child down to the element that actually generates the\n// card's box, skipping hidden breakpoint copies entirely. A container without\n// wrappers resolves to the direct child itself, so nothing changes for it.\nfunction boxChildren(container){const boxes=[];for(const raw of Array.from(container.children)){let node=raw;while(node){const display=window.getComputedStyle(node).display;if(display===\"none\"){node=null;break;}if(display!==\"contents\")break;node=node.firstElementChild;}if(node)boxes.push(node);}return boxes;}function measureSnapPoints(container){const children=boxChildren(container);if(children.length===0)return{snapPoints:[0],maxIndex:0};const rect=container.getBoundingClientRect();// Use the fractional box rather than clientWidth: clientWidth is rounded to\n// a whole pixel, and mixing it with fractional child rects skews the final\n// snap by up to a pixel on scaled displays.\nconst containerWidth=rect.width;const containerLeft=rect.left;const offsets=[];let totalRight=0;for(const child of children){const childRect=child.getBoundingClientRect();offsets.push(childRect.left-containerLeft);totalRight=childRect.right-containerLeft;}const snapPoints=offsets.map(offset=>-offset);const maxTranslate=Math.max(0,totalRight-containerWidth);const lastSnap=-maxTranslate;let maxIndex=snapPoints.length-1;for(let i=snapPoints.length-1;i>=0;i--){if(snapPoints[i]<lastSnap)snapPoints[i]=lastSnap;}while(maxIndex>0&&snapPoints[maxIndex]===snapPoints[maxIndex-1]){maxIndex--;}return{snapPoints:snapPoints.slice(0,maxIndex+1),maxIndex};}/**\n * Apply to a wrapper containing BOTH the cards container and the arrows, to\n * scope them together without naming either.\n * @framerDisableUnlink\n */export function withCarouselGroup(Component){return props=>{const ref=useRef(null);const groupId=useId();useIsoLayoutEffect(()=>{if(ref.current)ref.current.setAttribute(GROUP_ATTR,groupId);},[groupId]);return /*#__PURE__*/_jsx(Component,{...props,ref:ref,[GROUP_ATTR]:groupId});};}/**\n * Apply to the Cards container. Supports variable-width children.\n * @framerDisableUnlink\n */export function withScrollableCards(Component){return props=>{const ref=useRef(null);const key=useResolvedKey(ref,\"-carousel\");const[store,setStore]=useCarousel(key);const[isDragging,setIsDragging]=useState(false);const[isHorizontal,setIsHorizontal]=useState(true);// The single source of truth for where the strip is. Everything else —\n// the index in the store, the snap array — is derived or measured.\nconst x=useMotionValue(0);const snapsRef=useRef([0]);const storeRef=useRef(store);storeRef.current=store;// Timestamp until which a click/auxclick out of the strip is vetoed.\nconst suppressUntilRef=useRef(0);// Every element styleChildren has ever touched. Cleanup restores\n// exactly these, even when a breakpoint flip has since changed which\n// ssr-variant copies are the visible ones.\nconst styledRef=useRef(new Set);// One handle for whichever animation is currently running, so a new\n// gesture or a new target always interrupts the previous one. Without a\n// single owner the release spring and the index effect below animate the\n// same MotionValue at once and visibly fight.\nconst animationRef=useRef(null);// Velocity handed from a release to the index effect that performs it.\nconst pendingVelocityRef=useRef(0);const dragRef=useRef({startX:0,startY:0,lockX:0,baseTx:0,active:false,locked:false,direction:null,pointerId:-1});const stopAnimation=useCallback(()=>{animationRef.current?.stop();animationRef.current=null;},[]);const findClosestSnapIndex=useCallback(tx=>{const snaps=snapsRef.current;let closest=0;let minDist=Math.abs(tx-snaps[0]);for(let i=1;i<snaps.length;i++){const dist=Math.abs(tx-snaps[i]);if(dist<minDist){minDist=dist;closest=i;}}return closest;},[]);useEffect(()=>{window.__carouselVersion=CAROUSEL_VERSION;},[]);// Re-evaluate the layout across breakpoints so the carousel turns itself\n// on and off when crossing into a grid or column layout.\nuseEffect(()=>{const el=ref.current;if(!el)return;const check=()=>{const h=isHorizontalLayout(el);setIsHorizontal(prev=>prev===h?prev:h);};check();const ro=new ResizeObserver(check);ro.observe(el);window.addEventListener(\"resize\",check);return()=>{ro.disconnect();window.removeEventListener(\"resize\",check);};},[]);useEffect(()=>{const el=ref.current;if(!el)return;if(!isHorizontal){styledRef.current.forEach(child=>{child.style.pointerEvents=\"\";child.style.transition=\"\";child.style.transform=\"\";child.style.willChange=\"\";child.style.flexShrink=\"\";child.style.webkitUserDrag=\"\";child.style.touchAction=\"\";child.style.webkitTapHighlightColor=\"\";child.style.webkitTouchCallout=\"\";});styledRef.current.clear();return;}el.style.overflow=\"visible\";let parent=el.parentElement;while(parent){const cs=window.getComputedStyle(parent);if(cs.overflow===\"hidden\"||cs.overflowX===\"hidden\"){parent.style.overflow=\"visible\";}if(parent.getAttribute(\"data-framer-name\")===\"Section\")break;parent=parent.parentElement;}// The elements that actually generate the card boxes, resolved\n// through any ssr-variant wrappers. Refreshed by styleChildren so\n// a childList mutation or a breakpoint flip (which swaps the\n// visible copies without any mutation) picks up the new set.\nlet boxes=[];// --- Activation gate ------------------------------------------\n// A drag must never activate anything inside a card. Vetoing the\n// click is not enough on its own: Framer's overlay/modal triggers\n// and Framer Motion's tap gesture both fire on POINTERUP, which no\n// click handler ever sees — so a modal would open mid-swipe while\n// the plain link on the next card was correctly suppressed.\n//\n// Taking the cards out of hit testing for the length of the gesture\n// closes all of those paths at once. The pointerup resolves to the\n// strip instead of the card, so Framer Motion sees a release\n// outside the element it pressed and cancels the press cleanly\n// (no stuck tap state), and a native link never gets its mouseup on\n// the same node as its mousedown, so the browser synthesises no\n// click at all. Safe to do mid-gesture here because every drag\n// listener lives on window, not on the cards.\nlet cardsInteractive=true;let restoreTimer;const applyCardsInteractive=value=>{cardsInteractive=value;for(const child of boxes){styledRef.current.add(child);child.style.pointerEvents=\"none\";}if(!value)return;// Restore across EVERY element the gate has ever touched, not\n// just the current boxes: a breakpoint flip mid-gesture swaps\n// which ssr-variant copies are the live ones, and a copy left\n// behind with pointer-events: none would come back dead.\nstyledRef.current.forEach(child=>{child.style.pointerEvents=\"\";});};const gateCards=()=>{clearTimeout(restoreTimer);if(cardsInteractive)applyCardsInteractive(false);};// Restore on a timer rather than inline at pointerup: the compat\n// mouseup and click of THIS gesture are dispatched synchronously in\n// the same task as the pointerup, so a zero-delay timeout is the\n// first moment the tail is definitely over. Anything later would\n// leave hover and the link cursor dead after every drag.\nconst releaseCards=()=>{clearTimeout(restoreTimer);restoreTimer=setTimeout(()=>{if(!cardsInteractive)applyCardsInteractive(true);},0);};const styleChildren=()=>{boxes=boxChildren(el);boxes.forEach(child=>{styledRef.current.add(child);child.style.flexShrink=\"0\";child.style.webkitUserDrag=\"none\";// No CSS transition anywhere: the spring drives every frame,\n// so a transition would fight it. This is also what removes\n// the whole class of WebKit bugs around a transition whose\n// computed value changes in the same recalc as the transform.\nchild.style.transition=\"none\";child.style.willChange=\"transform\";child.style.touchAction=\"pan-y\";child.style.webkitTapHighlightColor=\"transparent\";child.style.webkitTouchCallout=\"none\";// Cards that arrived (CMS, lazy section, breakpoint flip)\n// while a drag is live must be born non-interactive too.\nchild.style.pointerEvents=cardsInteractive?\"\":\"none\";});};styleChildren();// One write per frame for the whole strip, whatever the pointer\n// event rate. A 1000Hz mouse would otherwise queue a dozen style\n// recalcs per frame and the strip visibly lags the cursor.\nlet writeRaf=0;let pendingTx=x.get();const flushWrite=()=>{writeRaf=0;const transform=`translate3d(${pendingTx}px, 0, 0)`;for(let i=0;i<boxes.length;i++){boxes[i].style.transform=transform;}};const scheduleWrite=value=>{pendingTx=value;if(writeRaf)return;writeRaf=requestAnimationFrame(flushWrite);};const unsubscribe=typeof x.on===\"function\"?x.on(\"change\",scheduleWrite):x.onChange(scheduleWrite);let disposed=false;let metricsRaf=0;// Trackpad gesture state. Declared up here because updateMetrics\n// below reads it, and that runs before the handlers are defined.\nlet wheelActive=false;let wheelAxis=null;let wheelRawTx=0;let wheelAccX=0;let wheelAccY=0;let wheelTimer;const updateMetrics=()=>{// Never re-measure mid-gesture: it would reset the strip and\n// yank it out from under the pointer.\nif(dragRef.current.active||wheelActive)return;// Re-resolve before measuring: a breakpoint flip swaps which\n// ssr-variant copies are visible with no childList mutation, so\n// the fresh copies still need styling, observing, and a clean\n// transform (the x.set(0) below writes to the refreshed set).\nstyleChildren();observeChildren();const previous=x.get();// Measure with the strip at rest — child rects are transformed\n// rects, so anything else biases every offset by the same amount.\nstopAnimation();x.set(0);flushWrite();const{snapPoints,maxIndex}=measureSnapPoints(el);snapsRef.current=snapPoints;// Keep the card that was on screen on screen, rather than the\n// raw pixel offset, which is meaningless once sizes changed.\nconst previousIdx=findClosestSnapIndex(previous);const idx=Math.min(previousIdx,maxIndex);setStore({maxIndex,currentIndex:idx});x.set(snapPoints[idx]??0);flushWrite();};const scheduleMetrics=()=>{if(metricsRaf||disposed)return;metricsRaf=requestAnimationFrame(()=>{metricsRaf=0;updateMetrics();});};// Every snap point comes from the CHILDREN's geometry. A carousel\n// container has a fixed or percentage width, so its own box never\n// changes as the cards resize underneath it — images decoding, fonts\n// swapping, CMS content arriving. Observing only the container means\n// never re-measuring at all. Observe the resolved boxes, not the\n// raw children: a display:contents wrapper has no box, so a\n// ResizeObserver on it never fires.\nconst ro=new ResizeObserver(scheduleMetrics);ro.observe(el);if(el.parentElement)ro.observe(el.parentElement);const observeChildren=()=>{boxes.forEach(child=>ro.observe(child));};updateMetrics();const mo=new MutationObserver(()=>{styleChildren();observeChildren();scheduleMetrics();});mo.observe(el,{childList:true});const fonts=document.fonts;if(fonts?.ready?.then){fonts.ready.then(()=>{if(!disposed)scheduleMetrics();});}// Exactly one of these branches animates. If the index changed the\n// effect below runs and performs the spring, carrying the velocity\n// stashed here; if it did not change, the effect will not fire at\n// all and the release is animated here instead. Never both.\nconst settle=(index,velocity)=>{if(storeRef.current.currentIndex===index){const target=snapsRef.current[index]??0;stopAnimation();animationRef.current=animate(x,target,{...SNAP_SPRING,velocity});return;}pendingVelocityRef.current=velocity;setStore({currentIndex:index});};const endGesture=velocity=>{const d=dragRef.current;const snaps=snapsRef.current;const maxIdx=snaps.length-1;const startIdx=findClosestSnapIndex(d.baseTx);// Landing is resolved from the strip's VISIBLE position plus a\n// bounded projection of the throw — never from a running total\n// of pointer deltas. However strange the event stream gets, the\n// result stays within a card of what the user is looking at.\nconst step=snaps.length>1?Math.abs(snaps[1]-snaps[0]):Math.abs(snaps[0]??1)||1;const maxProjection=step*MAX_PROJECTION_STEPS;const projection=Math.max(-maxProjection,Math.min(maxProjection,velocity*PROJECTION_SECONDS));const visible=x.get();const visibleIdx=findClosestSnapIndex(visible);let index=findClosestSnapIndex(visible+projection);// A deliberate flick that didn't travel far enough to change the\n// nearest card still advances exactly one. Judged against where\n// the strip VISIBLY is, not where the drag began — measuring it\n// from the start lets a long flick add a card on top of the\n// projection and land two away from what the user sees.\nif(index===visibleIdx&&Math.abs(velocity)>FLICK_VELOCITY){index+=velocity<0?1:-1;}index=Math.max(startIdx-MAX_CARDS_PER_GESTURE,Math.min(startIdx+MAX_CARDS_PER_GESTURE,index));index=Math.max(0,Math.min(maxIdx,index));settle(index,velocity);};// --- Trackpad swipe --------------------------------------------\n// A two-finger horizontal swipe tracks the strip 1:1 and settles on\n// the nearest card once the gesture and its momentum have stopped.\n// Deliberately NOT capped to one card per gesture the way a pointer\n// release is: a trackpad moves the strip exactly as far as the\n// fingers say, in real time, so there is no gap between what was\n// thrown and what is seen for a cap to close.\nconst clearWheelGesture=()=>{clearTimeout(wheelTimer);wheelTimer=undefined;wheelActive=false;wheelAxis=null;wheelAccX=0;wheelAccY=0;};const endWheelGesture=()=>{const wasActive=wheelActive;clearWheelGesture();// A pointer drag that began during the momentum tail now owns\n// the strip; settling underneath it would yank it away.\nif(!wasActive||dragRef.current.active)return;const snaps=snapsRef.current;const index=Math.max(0,Math.min(snaps.length-1,findClosestSnapIndex(x.get())));// No velocity: the momentum tail has already carried the strip\n// as far as it was thrown, so the spring only has to close the\n// remaining gap to the card.\nsettle(index,0);};const armWheelEnd=()=>{clearTimeout(wheelTimer);wheelTimer=setTimeout(endWheelGesture,WHEEL_SETTLE_MS);};const onWheel=e=>{// A finger on the strip outranks the trackpad.\nif(dragRef.current.active)return;const snaps=snapsRef.current;// Nothing to scroll: leave the event alone so the page behaves\n// exactly as it would without a carousel here.\nif(snaps.length<2)return;// deltaMode is per-line or per-page on some mice; normalise to\n// pixels or a single notch moves the strip a card and a half.\nconst unit=e.deltaMode===1?16:e.deltaMode===2?el.clientWidth:1;// shift+wheel is the long-standing \"scroll horizontally\"\n// convention, and not every OS/mouse pair synthesises deltaX\n// for it.\nconst shifted=e.shiftKey&&e.deltaX===0;const dx=(shifted?e.deltaY:e.deltaX)*unit;const dy=(shifted?0:e.deltaY)*unit;if(wheelAxis===\"vertical\"){// Hold the lock for the whole momentum tail, so the drift at\n// the end of a page scroll can't grab the strip.\narmWheelEnd();return;}if(!wheelActive){wheelAccX+=dx;wheelAccY+=dy;if(Math.abs(wheelAccX)<WHEEL_AXIS_LOCK_PX&&Math.abs(wheelAccY)<WHEEL_AXIS_LOCK_PX){armWheelEnd();return;}if(Math.abs(wheelAccY)>Math.abs(wheelAccX)){wheelAxis=\"vertical\";armWheelEnd();return;}wheelAxis=\"horizontal\";wheelActive=true;// Anchor on where the strip physically is, so a swipe that\n// interrupts a running spring picks it up where it looks\n// rather than jumping to the target first.\nstopAnimation();wheelRawTx=x.get();}// Claim the gesture. Also what stops the browser turning an\n// unconsumed horizontal wheel into a back/forward navigation.\nif(e.cancelable)e.preventDefault();const minSnap=snaps[snaps.length-1]??0;const maxSnap=snaps[0]??0;// Track the undamped position and damp only what is written:\n// feeding a damped value back in compounds the rubber band on\n// every event of the tail until the strip stops responding.\nwheelRawTx=Math.max(minSnap-WHEEL_OVERSCROLL_PX,Math.min(maxSnap+WHEEL_OVERSCROLL_PX,wheelRawTx-dx));x.set(wheelRawTx>maxSnap?maxSnap+(wheelRawTx-maxSnap)*.3:wheelRawTx<minSnap?minSnap+(wheelRawTx-minSnap)*.3:wheelRawTx);armWheelEnd();};const onPointerMove=e=>{const d=dragRef.current;if(!d.active||d.pointerId!==e.pointerId)return;if(d.direction===\"vertical\")return;const dx=e.clientX-d.startX;const dy=e.clientY-d.startY;if(!d.locked){const adx=Math.abs(dx);const ady=Math.abs(dy);const threshold=e.pointerType===\"touch\"?TOUCH_LOCK_THRESHOLD:DIRECTION_LOCK_THRESHOLD;if(adx<threshold&&ady<threshold)return;if(ady>adx){d.direction=\"vertical\";return;}d.direction=\"horizontal\";d.locked=true;// Anchor on where the strip physically is, so grabbing a\n// still-settling strip picks it up exactly where it looks,\n// and buffered pre-lock travel can't offset the drag.\nstopAnimation();d.baseTx=x.get();d.lockX=e.clientX;suppressUntilRef.current=Date.now()+CLICK_SUPPRESS_MS;// Move the pointer capture onto the strip before the cards\n// leave hit testing. On touch the browser has already given\n// the card IMPLICIT capture at pointerdown, and a captured\n// pointer is delivered to its capture target whatever\n// pointer-events says — so without this the release still\n// lands on the card and a Framer overlay opens mid-swipe.\n// The window listeners below are unaffected: events from\n// the strip still bubble to them.\ntry{el.setPointerCapture(e.pointerId);}catch{}gateCards();startTransition(()=>setIsDragging(true));}const snaps=snapsRef.current;const minSnap=snaps[snaps.length-1]??0;const maxSnap=snaps[0]??0;const raw=d.baseTx+(e.clientX-d.lockX);x.set(raw>maxSnap?maxSnap+(raw-maxSnap)*.3:raw<minSnap?minSnap+(raw-minSnap)*.3:raw);};const finishGesture=(e,cancelled)=>{const d=dragRef.current;if(!d.active||d.pointerId!==e.pointerId)return;const wasLocked=d.locked;d.active=false;d.locked=false;d.direction=null;d.pointerId=-1;detachWindow();if(!wasLocked)return;// Re-arm from the release, not from the lock: a slow drag can\n// outlast a window opened when it started.\nsuppressUntilRef.current=Date.now()+CLICK_SUPPRESS_MS;releaseCards();// Velocity from the MotionValue's own timestamped history, in\n// px/s. Never a hand-computed delta over a dt that can be zero.\nendGesture(cancelled?0:x.getVelocity());setIsDragging(false);};const onPointerUp=e=>finishGesture(e,false);const onPointerCancel=e=>finishGesture(e,true);// Once locked horizontal, stop the browser also panning the page for\n// the rest of this touch. Must be non-passive or preventDefault is a\n// no-op. Before the lock nothing is prevented, so a vertical drag\n// scrolls normally — that is what touch-action: pan-y is for.\nconst onTouchMove=e=>{if(dragRef.current.locked&&e.cancelable)e.preventDefault();};// Listeners live on window, exactly as Framer Motion's own drag\n// does. Nothing inside a card — an embed, an iframe, a hit-test\n// change, a pointer capture that quietly failed — can take the\n// gesture away once it has started.\nconst attachWindow=()=>{window.addEventListener(\"pointermove\",onPointerMove);window.addEventListener(\"pointerup\",onPointerUp);window.addEventListener(\"pointercancel\",onPointerCancel);window.addEventListener(\"touchmove\",onTouchMove,{passive:false});};const detachWindow=()=>{window.removeEventListener(\"pointermove\",onPointerMove);window.removeEventListener(\"pointerup\",onPointerUp);window.removeEventListener(\"pointercancel\",onPointerCancel);window.removeEventListener(\"touchmove\",onTouchMove);};const onPointerDown=e=>{// The first contact owns the gesture; a second finger must not\n// re-anchor it.\nif(dragRef.current.active)return;// Nothing to scroll (every card already fits): leave the\n// pointer alone so cards keep their normal tap/hover/link\n// behaviour, same as the wheel handler does.\nif(snapsRef.current.length<2)return;// A touch landing during the momentum tail settles the trackpad\n// gesture now, rather than leaving one queued to fire\n// underneath the drag that is about to start.\nif(wheelTimer)endWheelGesture();suppressUntilRef.current=0;dragRef.current={startX:e.clientX,startY:e.clientY,lockX:e.clientX,baseTx:x.get(),active:true,locked:false,direction:null,pointerId:e.pointerId};attachWindow();};const onDragStart=event=>event.preventDefault();const onSelectStart=event=>{if(dragRef.current.locked)event.preventDefault();};// Tail veto for anything the hit-test gate above did not already\n// stop — a browser that synthesises the click from the pointerdown\n// target regardless, or a handler bound before the gate applied.\n// Capture phase on the container, so it runs before React's own\n// delegated click listener at the root ever gets the chance to\n// dispatch the card's onClick.\nconst onActivationCapture=event=>{if(Date.now()>=suppressUntilRef.current)return;event.preventDefault();event.stopPropagation();// Also stop listeners on the container ITSELF: Framer puts the\n// handler there when the whole strip is wrapped in a link, and\n// plain stopPropagation never reaches a same-node listener.\nevent.stopImmediatePropagation?.();};el.addEventListener(\"wheel\",onWheel,{passive:false});el.addEventListener(\"pointerdown\",onPointerDown);el.addEventListener(\"click\",onActivationCapture,true);el.addEventListener(\"auxclick\",onActivationCapture,true);el.addEventListener(\"dragstart\",onDragStart);el.addEventListener(\"selectstart\",onSelectStart);return()=>{disposed=true;ro.disconnect();mo.disconnect();clearTimeout(restoreTimer);styledRef.current.forEach(child=>{child.style.pointerEvents=\"\";});if(metricsRaf)cancelAnimationFrame(metricsRaf);if(writeRaf)cancelAnimationFrame(writeRaf);stopAnimation();unsubscribe?.();detachWindow();clearTimeout(wheelTimer);el.removeEventListener(\"wheel\",onWheel);el.removeEventListener(\"pointerdown\",onPointerDown);el.removeEventListener(\"click\",onActivationCapture,true);el.removeEventListener(\"auxclick\",onActivationCapture,true);el.removeEventListener(\"dragstart\",onDragStart);el.removeEventListener(\"selectstart\",onSelectStart);};},[isHorizontal,key]);// Arrow clicks and any other external index change animate to the card.\nuseEffect(()=>{if(!isHorizontal)return;const target=snapsRef.current[store.currentIndex];if(target===undefined)return;if(dragRef.current.active)return;const velocity=pendingVelocityRef.current;pendingVelocityRef.current=0;if(Math.abs(x.get()-target)<.5&&!velocity)return;stopAnimation();animationRef.current=animate(x,target,{...SNAP_SPRING,velocity});return()=>stopAnimation();},[store.currentIndex,isHorizontal,key]);return /*#__PURE__*/_jsx(Component,{...props,ref:ref,style:{...props.style,...isHorizontal?{overflow:\"visible\",cursor:store.maxIndex>0?isDragging?\"grabbing\":\"grab\":undefined,touchAction:\"pan-y\",WebkitTapHighlightColor:\"transparent\",WebkitTouchCallout:\"none\",userSelect:isDragging?\"none\":undefined,WebkitUserSelect:isDragging?\"none\":undefined}:{}}});};}/**\n * Apply to the Prev arrow button.\n * @framerDisableUnlink\n */export function withPrevArrow(Component){return props=>{const ref=useRef(null);const key=useResolvedKey(ref,\"-nav\");const[store,setStore]=useCarousel(key);const atStart=store.currentIndex<=0;const handleClick=useCallback(()=>{setStore({currentIndex:Math.max(0,store.currentIndex-1)});},[store.currentIndex,setStore]);return /*#__PURE__*/_jsx(Component,{...props,ref:ref,onClick:handleClick,style:{...props.style,opacity:atStart?.3:1,pointerEvents:atStart?\"none\":\"auto\",cursor:atStart?\"default\":\"pointer\",transition:\"opacity 0.2s ease\"}});};}/**\n * Apply to the Next arrow button.\n * @framerDisableUnlink\n */export function withNextArrow(Component){return props=>{const ref=useRef(null);const key=useResolvedKey(ref,\"-nav\");const[store,setStore]=useCarousel(key);const atEnd=store.currentIndex>=store.maxIndex;const handleClick=useCallback(()=>{setStore({currentIndex:Math.min(store.maxIndex,store.currentIndex+1)});},[store.currentIndex,store.maxIndex,setStore]);return /*#__PURE__*/_jsx(Component,{...props,ref:ref,onClick:handleClick,style:{...props.style,opacity:atEnd?.3:1,pointerEvents:atEnd?\"none\":\"auto\",cursor:atEnd?\"default\":\"pointer\",transition:\"opacity 0.2s ease\"}});};}/**\n * Apply to a Prev arrow instance with \"Active\" / \"Inactive\" variants.\n * @framerDisableUnlink\n */export function withPrevArrowVariant(Component){return props=>{const ref=useRef(null);const key=useResolvedKey(ref,\"-nav\");const[store,setStore]=useCarousel(key);const atStart=store.currentIndex<=0;const handleClick=useCallback(()=>{if(atStart)return;setStore({currentIndex:Math.max(0,store.currentIndex-1)});},[store.currentIndex,atStart,setStore]);return /*#__PURE__*/_jsx(Component,{...props,ref:ref,variant:atStart?\"Inactive\":\"Active\",onClick:handleClick,style:{...props.style,pointerEvents:atStart?\"none\":\"auto\",cursor:atStart?\"default\":\"pointer\"}});};}/**\n * Apply to a Next arrow instance with \"Active\" / \"Inactive\" variants.\n * @framerDisableUnlink\n */export function withNextArrowVariant(Component){return props=>{const ref=useRef(null);const key=useResolvedKey(ref,\"-nav\");const[store,setStore]=useCarousel(key);const atEnd=store.currentIndex>=store.maxIndex;const handleClick=useCallback(()=>{if(atEnd)return;setStore({currentIndex:Math.min(store.maxIndex,store.currentIndex+1)});},[store.currentIndex,store.maxIndex,atEnd,setStore]);return /*#__PURE__*/_jsx(Component,{...props,ref:ref,variant:atEnd?\"Inactive\":\"Active\",onClick:handleClick,style:{...props.style,pointerEvents:atEnd?\"none\":\"auto\",cursor:atEnd?\"default\":\"pointer\"}});};}\nexport const __FramerMetadata__ = {\"exports\":{\"withPrevArrow\":{\"type\":\"reactHoc\",\"name\":\"withPrevArrow\",\"annotations\":{\"framerContractVersion\":\"1\",\"framerDisableUnlink\":\"\"}},\"withNextArrow\":{\"type\":\"reactHoc\",\"name\":\"withNextArrow\",\"annotations\":{\"framerDisableUnlink\":\"\",\"framerContractVersion\":\"1\"}},\"withPrevArrowVariant\":{\"type\":\"reactHoc\",\"name\":\"withPrevArrowVariant\",\"annotations\":{\"framerContractVersion\":\"1\",\"framerDisableUnlink\":\"\"}},\"withScrollableCards\":{\"type\":\"reactHoc\",\"name\":\"withScrollableCards\",\"annotations\":{\"framerDisableUnlink\":\"\",\"framerContractVersion\":\"1\"}},\"withNextArrowVariant\":{\"type\":\"reactHoc\",\"name\":\"withNextArrowVariant\",\"annotations\":{\"framerContractVersion\":\"1\",\"framerDisableUnlink\":\"\"}},\"withCarouselGroup\":{\"type\":\"reactHoc\",\"name\":\"withCarouselGroup\",\"annotations\":{\"framerDisableUnlink\":\"\",\"framerContractVersion\":\"1\"}},\"__FramerMetadata__\":{\"type\":\"variable\"}}}\n//# sourceMappingURL=./CarouselMotionOverrides.map"],"mappings":"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"}