{"version":3,"sources":["webpack:///./node_modules/framer-motion/dist/es/render/utils/variants.mjs","webpack:///./node_modules/framer-motion/dist/es/context/PresenceContext.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/transform.mjs","webpack:///./node_modules/framer-motion/dist/es/value/utils/is-motion-value.mjs","webpack:///./node_modules/hey-listen/dist/index.js","webpack:///./node_modules/framer-motion/dist/es/context/LayoutGroupContext.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/process.mjs","webpack:///./node_modules/framer-motion/dist/es/context/MotionConfigContext.mjs","webpack:///./node_modules/style-value-types/dist/valueTypes.cjs.js","webpack:///./node_modules/framer-motion/dist/es/utils/is-browser.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/utils/is-keyframes-target.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/features/definitions.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/is-ref-object.mjs","webpack:///./node_modules/framer-motion/dist/es/projection/node/state.mjs","webpack:///./node_modules/framer-motion/dist/es/projection/styles/scale-correction.mjs","webpack:///./node_modules/framer-motion/dist/es/context/LazyContext.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/resolve-value.mjs","webpack:///./node_modules/framer-motion/dist/es/animation/utils/is-animation-controls.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/transform-origin.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/path.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/build-transform.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/get-as-type.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/build-styles.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/lowercase-elements.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/is-svg-component.mjs","webpack:///./node_modules/framer-motion/dist/es/value/utils/resolve-motion-value.mjs","webpack:///./node_modules/framer-motion/dist/es/context/SwitchLayoutGroupContext.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/utils/is-forced-motion-value.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/is-css-variable.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/render.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/render.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/camel-to-dash.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/utils/valid-prop.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/filter-props.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/type-int.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/value-types/number.mjs","webpack:///./node_modules/@emotion/is-prop-valid/dist/is-prop-valid.browser.cjs.js","webpack:///./node_modules/framer-motion/dist/es/motion/features/use-features.mjs","webpack:///./node_modules/framer-motion/dist/es/context/MotionContext/index.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/use-reduced-motion.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/utils/use-visual-element.mjs","webpack:///./node_modules/framer-motion/dist/es/context/MotionContext/create.mjs","webpack:///./node_modules/framer-motion/dist/es/context/MotionContext/utils.mjs","webpack:///./node_modules/framer-motion/dist/es/projection/node/id.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/utils/VisualElementHandler.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/index.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/features/use-projection.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/utils/use-motion-ref.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/utils/create-render-state.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/use-props.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/utils/create-render-state.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/use-props.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/use-render.mjs","webpack:///./node_modules/framer-motion/dist/es/motion/utils/use-visual-state.mjs","webpack:///./node_modules/framer-motion/dist/es/render/svg/config-motion.mjs","webpack:///./node_modules/framer-motion/dist/es/render/html/config-motion.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/motion-minimal.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/motion-proxy.mjs","webpack:///./node_modules/framer-motion/dist/es/render/dom/utils/create-config.mjs","webpack:///./node_modules/tslib/tslib.js","webpack:///./node_modules/framer-motion/dist/es/utils/use-constant.mjs","webpack:///./node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.mjs"],"names":["isVariantLabels","v","Array","isArray","isVariantLabel","resolveVariantFromProps","props","definition","custom","currentValues","currentVelocity","_a","variants","resolveVariant","visualElement","getProps","current","forEachValue","value","key","get","getCurrent","velocity","getVelocity","checkIfControllingVariants","animate","start","initial","whileHover","whileDrag","whileTap","whileFocus","exit","checkIfVariantNode","Boolean","PresenceContext","createContext","transformAxes","transformProps","sortTransformProps","a","b","indexOf","forEach","operationKey","axesKey","push","transformPropSet","Set","isTransformProp","has","transformOriginProps","isTransformOriginProp","isMotionValue","Object","defineProperty","exports","warning","invariant","LayoutGroupContext","env","process","MotionConfigContext","transformPagePoint","p","isStatic","reducedMotion","clamp","min","max","Math","sanitize","Number","toFixed","floatRegex","colorRegex","singleColorRegex","isString","number","test","parse","parseFloat","transform","alpha","assign","scale","default","createUnitType","unit","endsWith","split","length","degrees","percent","px","vh","vw","progressPercentage","isColorString","type","testProp","startsWith","prototype","hasOwnProperty","call","splitColor","aName","bName","cName","c","match","undefined","hsla","hue","saturation","lightness","alpha$1","round","clampRgbUnit","rgbUnit","rgba","red","green","blue","hex","r","g","substr","parseInt","color","analyse","values","numColors","colors","replace","map","numbers","tokenised","createTransformer","numValues","output","i","convertNumbersToZero","complex","_b","_c","_d","isNaN","getAnimatableNone","parsed","transformer","maxDefaults","applyDefaultFilter","name","slice","defaultValue","functionRegex","filter","functions","join","isBrowser","document","isKeyframesTarget","createDefinition","propNames","isEnabled","some","featureDefinitions","measureLayout","animation","drag","focus","hover","tap","pan","inView","loadFeatures","features","projectionNodeConstructor","Component","isRefObject","ref","globalProjectionState","hasAnimatedSinceResize","hasEverUpdated","scaleCorrectors","addScaleCorrector","correctors","LazyContext","strict","isCustomValue","mix","toValue","resolveFinalValueInKeyframes","isAnimationControls","scrapeMotionValuesFromProps","style","newValues","isForcedMotionValue","calcOrigin","origin","offset","size","dashKeys","array","camelKeys","buildSVGAttrs","state","options","transformTemplate","attrX","attrY","originX","originY","pathLength","pathSpacing","pathOffset","latest","__rest","buildHTMLStyles","attrs","dimensions","transformOrigin","pxOriginX","x","width","pxOriginY","y","height","concat","calcSVGTransformOrigin","spacing","useDashCase","keys","buildSVGPath","translateAlias","z","transformPerspective","getValueAsType","latestValues","vars","transformKeys","hasTransform","hasTransformOrigin","transformIsNone","isCSSVariable","valueType","numberValueTypes","valueAsType","transformIsDefault","enableHardwareAcceleration","allowTransformNone","transformString","sort","transformHasZ","numTransformKeys","trim","buildTransform","originZ","buildTransformOrigin","lowercaseSVGElements","isSVGComponent","includes","resolveMotionValue","unwrappedValue","SwitchLayoutGroupContext","scrapeMotionValuesFromProps$1","toUpperCase","layout","layoutId","renderSVG","element","renderState","_styleProp","projection","renderHTML","setAttribute","camelCaseAttributes","camelToDash","styleProp","getProjectionStyles","setProperty","CAMEL_CASE_PATTERN","str","toLowerCase","validMotionProps","isValidMotionProp","shouldForward","loadExternalIsValidProp","isValidProp","require","filterProps","isDom","forwardMotionProps","filteredProps","int","__assign","borderWidth","borderTopWidth","borderRightWidth","borderBottomWidth","borderLeftWidth","borderRadius","radius","borderTopLeftRadius","borderTopRightRadius","borderBottomRightRadius","borderBottomLeftRadius","maxWidth","maxHeight","top","right","bottom","left","padding","paddingTop","paddingRight","paddingBottom","paddingLeft","margin","marginTop","marginRight","marginBottom","marginLeft","rotate","rotateX","rotateY","rotateZ","scaleX","scaleY","scaleZ","skew","skewX","skewY","distance","translateX","translateY","translateZ","perspective","opacity","zIndex","fillOpacity","strokeOpacity","numOctaves","ex","memoize","reactPropsRegex","index","prop","charCodeAt","featureNames","numFeatures","MotionContext","prefersReducedMotion","hasDetected","useReducedMotion","window","matchMedia","motionMediaQuery_1","setReducedMotionPreferences","matches","addListener","initPrefersReducedMotion","__read","useState","useVisualElement","visualState","createVisualElement","reducedMotionPreference","lazyContext","useContext","parent","presenceContext","shouldReduceMotion","visualElementRef","useRef","renderer","presenceId","id","blockInitialAnimation","useIsomorphicLayoutEffect","syncRender","useEffect","animationState","animateChanges","notifyUnmount","useCreateMotionContext","context","inherit","getCurrentTreeVariants","useMemo","variantLabelsAsDependency","VisualElementHandler","_super","apply","this","arguments","__extends","getSnapshotBeforeUpdate","updateProps","componentDidUpdate","setProps","render","children","React__default","createMotionComponent","preloadedFeatures","useRender","useVisualState","forwardRef","externalRef","layoutGroupId","useLayoutId","config","projectionId","useConstant","ProjectionNodeConstructor","dragConstraints","layoutScroll","initialPromotionConfig","getLatestValues","setOptions","alwaysMeasureLayout","scheduleRender","animationType","useProjection","name_1","React","useFeatures","Provider","useCallback","instance","mount","unmount","useMotionRef","createHtmlRenderState","copyRawValuesOnly","target","source","useStyle","useInitialMotionValues","transformValues","useHTMLProps","htmlProps","dragListener","draggable","userSelect","WebkitUserSelect","WebkitTouchCallout","touchAction","createSvgRenderState","useSVGProps","visualProps","rawStyles","createUseRender","elementProps","createElement","makeState","createRenderState","onMount","makeLatestValues","makeUseVisualState","scrapeMotionValues","motionValues","isControllingVariants","isVariantNode","initialAnimationIsBlocked","variantToSet","resolved","transitionEnd","transition","valueTarget","svgMotionConfig","getBBox","getBoundingClientRect","e","htmlMotionConfig","m","createConfig","customMotionComponentConfig","Proxy","componentCache","Map","_target","set","createMotionProxy","baseConfig","__decorate","__param","__metadata","__awaiter","__generator","__exportStar","__values","__spread","__spreadArrays","__spreadArray","__await","__asyncGenerator","__asyncDelegator","__asyncValues","__makeTemplateObject","__importStar","__importDefault","__classPrivateFieldGet","__classPrivateFieldSet","__createBinding","factory","root","global","self","createExporter","previous","create","__esModule","exporter","extendStatics","setPrototypeOf","__proto__","d","TypeError","String","__","constructor","t","s","n","getOwnPropertySymbols","propertyIsEnumerable","decorators","desc","getOwnPropertyDescriptor","Reflect","decorate","paramIndex","decorator","metadataKey","metadataValue","metadata","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","next","rejected","result","done","then","body","f","_","label","sent","trys","ops","verb","Symbol","iterator","op","pop","o","k","k2","enumerable","ar","error","il","j","jl","to","from","pack","l","asyncIterator","q","resume","fulfill","settle","shift","cooked","raw","__setModuleDefault","mod","receiver","kind","init","useLayoutEffect"],"mappings":"sGAGA,SAASA,EAAgBC,GACrB,OAAOC,MAAMC,QAAQF,GAKzB,SAASG,EAAeH,GACpB,MAAoB,iBAANA,GAAkBD,EAAgBC,GAkBpD,SAASI,EAAwBC,EAAOC,EAAYC,EAAQC,EAAeC,GACvE,IAAIC,EAwBJ,YAvBsB,IAAlBF,IAA4BA,EAAgB,SACxB,IAApBC,IAA8BA,EAAkB,IAI1B,mBAAfH,IACPA,EAAaA,EAAWC,QAAuCA,EAASF,EAAME,OAAQC,EAAeC,IAM/E,iBAAfH,IACPA,EAAuC,QAAzBI,EAAKL,EAAMM,gBAA6B,IAAPD,OAAgB,EAASA,EAAGJ,IAOrD,mBAAfA,IACPA,EAAaA,EAAWC,QAAuCA,EAASF,EAAME,OAAQC,EAAeC,IAElGH,EAEX,SAASM,EAAeC,EAAeP,EAAYC,GAC/C,IAAIF,EAAQQ,EAAcC,WAC1B,OAAOV,EAAwBC,EAAOC,EAAYC,QAAuCA,EAASF,EAAME,OA1C5G,SAAoBM,GAChB,IAAIE,EAAU,GAEd,OADAF,EAAcG,cAAa,SAAUC,EAAOC,GAAO,OAAQH,EAAQG,GAAOD,EAAME,SACzEJ,EAuCyGK,CAAWP,GAlC/H,SAAqBA,GACjB,IAAIQ,EAAW,GAEf,OADAR,EAAcG,cAAa,SAAUC,EAAOC,GAAO,OAAQG,EAASH,GAAOD,EAAMK,iBAC1ED,EA+BoIC,CAAYT,IAE3J,SAASU,EAA2BlB,GAChC,IAAIK,EACJ,MAAwF,mBAA/C,QAAxBA,EAAKL,EAAMmB,eAA4B,IAAPd,OAAgB,EAASA,EAAGe,QACzEtB,EAAeE,EAAMqB,UACrBvB,EAAeE,EAAMmB,UACrBrB,EAAeE,EAAMsB,aACrBxB,EAAeE,EAAMuB,YACrBzB,EAAeE,EAAMwB,WACrB1B,EAAeE,EAAMyB,aACrB3B,EAAeE,EAAM0B,MAE7B,SAASC,EAAmB3B,GACxB,OAAO4B,QAAQV,EAA2BlB,IAAUA,EAAMM,UAvE9D,6M,iCCAA,6CAKIuB,EAAkBC,wBAAc,O,iCCLpC,0KAIA,IAAIC,EAAgB,CAAC,GAAI,IAAK,IAAK,KAS/BC,EAAiB,CAAC,uBAAwB,IAAK,IAAK,KASxD,SAASC,EAAmBC,EAAGC,GAC3B,OAAOH,EAAeI,QAAQF,GAAKF,EAAeI,QAAQD,GAdlD,CAAC,YAAa,QAAS,SAAU,QAKvCE,SAAQ,SAAUC,GACpB,OAAOP,EAAcM,SAAQ,SAAUE,GACnC,OAAOP,EAAeQ,KAAKF,EAAeC,SAYlD,IAAIE,EAAmB,IAAIC,IAAIV,GAC/B,SAASW,EAAgB9B,GACrB,OAAO4B,EAAiBG,IAAI/B,GAKhC,IAAIgC,EAAuB,IAAIH,IAAI,CAAC,UAAW,UAAW,YAC1D,SAASI,EAAsBjC,GAC3B,OAAOgC,EAAqBD,IAAI/B,K,iCCrCpC,sCAAIkC,EAAgB,SAAUnC,GAC1B,OAAOgB,QAAkB,OAAVhB,GAAmC,iBAAVA,GAAsBA,EAAMK,e,iCCCxE+B,OAAOC,eAAeC,EAAS,aAAc,CAAEtC,OAAO,IAEtDsC,EAAQC,QAAU,aAClBD,EAAQE,UAAY,c,iCCLpB,6CAEIC,EAAqBvB,wBAAc,K,kCCFvC,8CAGA,IACIwB,QAAyB,IAAZC,GAA2BA,gCADnB,gB,oDCHzB,6CAKIC,EAAsB1B,wBAAc,CACpC2B,mBAAoB,SAAUC,GAAK,OAAOA,GAC1CC,UAAU,EACVC,cAAe,W,gCCNnBZ,OAAOC,eAAeC,EAAS,aAAc,CAAEtC,OAAO,IAEtD,MAAMiD,EAAQ,CAACC,EAAKC,IAASpE,GAAMqE,KAAKD,IAAIC,KAAKF,IAAInE,EAAGoE,GAAMD,GACxDG,EAAYtE,GAAOA,EAAI,EAAIuE,OAAOvE,EAAEwE,QAAQ,IAAMxE,EAClDyE,EAAa,uBACbC,EAAa,gHACbC,EAAmB,oGACzB,SAASC,EAAS5E,GACd,MAAoB,iBAANA,EAGlB,MAAM6E,EAAS,CACXC,KAAO9E,GAAmB,iBAANA,EACpB+E,MAAOC,WACPC,UAAYjF,GAAMA,GAEhBkF,EAAQ7B,OAAO8B,OAAO9B,OAAO8B,OAAO,GAAIN,GAAS,CAAEI,UAAWf,EAAM,EAAG,KACvEkB,EAAQ/B,OAAO8B,OAAO9B,OAAO8B,OAAO,GAAIN,GAAS,CAAEQ,QAAS,IAE5DC,EAAkBC,IAAS,CAC7BT,KAAO9E,GAAM4E,EAAS5E,IAAMA,EAAEwF,SAASD,IAAiC,IAAxBvF,EAAEyF,MAAM,KAAKC,OAC7DX,MAAOC,WACPC,UAAYjF,GAAM,GAAGA,IAAIuF,MAEvBI,EAAUL,EAAe,OACzBM,EAAUN,EAAe,KACzBO,EAAKP,EAAe,MACpBQ,EAAKR,EAAe,MACpBS,EAAKT,EAAe,MACpBU,EAAqB3C,OAAO8B,OAAO9B,OAAO8B,OAAO,GAAIS,GAAU,CAAEb,MAAQ/E,GAAM4F,EAAQb,MAAM/E,GAAK,IAAKiF,UAAYjF,GAAM4F,EAAQX,UAAc,IAAJjF,KAE3IiG,EAAgB,CAACC,EAAMC,IAAcnG,GAChCiC,QAAS2C,EAAS5E,IAAM2E,EAAiBG,KAAK9E,IAAMA,EAAEoG,WAAWF,IACnEC,GAAY9C,OAAOgD,UAAUC,eAAeC,KAAKvG,EAAGmG,IAEvDK,EAAa,CAACC,EAAOC,EAAOC,IAAW3G,IACzC,IAAK4E,EAAS5E,GACV,OAAOA,EACX,MAAOuC,EAAGC,EAAGoE,EAAG1B,GAASlF,EAAE6G,MAAMpC,GACjC,MAAO,CACH,CAACgC,GAAQzB,WAAWzC,GACpB,CAACmE,GAAQ1B,WAAWxC,GACpB,CAACmE,GAAQ3B,WAAW4B,GACpB1B,WAAiB4B,IAAV5B,EAAsBF,WAAWE,GAAS,IAInD6B,EAAO,CACTjC,KAAMmB,EAAc,MAAO,OAC3BlB,MAAOyB,EAAW,MAAO,aAAc,aACvCvB,UAAW,EAAG+B,MAAKC,aAAYC,YAAWhC,MAAOiC,EAAU,KAC/C,QACJ9C,KAAK+C,MAAMJ,GACX,KACApB,EAAQX,UAAUX,EAAS2C,IAC3B,KACArB,EAAQX,UAAUX,EAAS4C,IAC3B,KACA5C,EAASY,EAAMD,UAAUkC,IACzB,KAINE,EAAenD,EAAM,EAAG,KACxBoD,EAAUjE,OAAO8B,OAAO9B,OAAO8B,OAAO,GAAIN,GAAS,CAAEI,UAAYjF,GAAMqE,KAAK+C,MAAMC,EAAarH,MAC/FuH,EAAO,CACTzC,KAAMmB,EAAc,MAAO,OAC3BlB,MAAOyB,EAAW,MAAO,QAAS,QAClCvB,UAAW,EAAGuC,MAAKC,QAAOC,OAAMxC,MAAOiC,EAAU,KAAQ,QACrDG,EAAQrC,UAAUuC,GAClB,KACAF,EAAQrC,UAAUwC,GAClB,KACAH,EAAQrC,UAAUyC,GAClB,KACApD,EAASY,EAAMD,UAAUkC,IACzB,KA+BR,MAAMQ,EAAM,CACR7C,KAAMmB,EAAc,KACpBlB,MA9BJ,SAAkB/E,GACd,IAAI4H,EAAI,GACJC,EAAI,GACJrF,EAAI,GACJD,EAAI,GAiBR,OAhBIvC,EAAE0F,OAAS,GACXkC,EAAI5H,EAAE8H,OAAO,EAAG,GAChBD,EAAI7H,EAAE8H,OAAO,EAAG,GAChBtF,EAAIxC,EAAE8H,OAAO,EAAG,GAChBvF,EAAIvC,EAAE8H,OAAO,EAAG,KAGhBF,EAAI5H,EAAE8H,OAAO,EAAG,GAChBD,EAAI7H,EAAE8H,OAAO,EAAG,GAChBtF,EAAIxC,EAAE8H,OAAO,EAAG,GAChBvF,EAAIvC,EAAE8H,OAAO,EAAG,GAChBF,GAAKA,EACLC,GAAKA,EACLrF,GAAKA,EACLD,GAAKA,GAEF,CACHiF,IAAKO,SAASH,EAAG,IACjBH,MAAOM,SAASF,EAAG,IACnBH,KAAMK,SAASvF,EAAG,IAClB0C,MAAO3C,EAAIwF,SAASxF,EAAG,IAAM,IAAM,IAMvC0C,UAAWsC,EAAKtC,WAGd+C,EAAQ,CACVlD,KAAO9E,GAAMuH,EAAKzC,KAAK9E,IAAM2H,EAAI7C,KAAK9E,IAAM+G,EAAKjC,KAAK9E,GACtD+E,MAAQ/E,GACAuH,EAAKzC,KAAK9E,GACHuH,EAAKxC,MAAM/E,GAEb+G,EAAKjC,KAAK9E,GACR+G,EAAKhC,MAAM/E,GAGX2H,EAAI5C,MAAM/E,GAGzBiF,UAAYjF,GACD4E,EAAS5E,GACVA,EACAA,EAAEsG,eAAe,OACbiB,EAAKtC,UAAUjF,GACf+G,EAAK9B,UAAUjF,IAYjC,SAASiI,EAAQjI,GACI,iBAANA,IACPA,EAAI,GAAGA,GACX,MAAMkI,EAAS,GACf,IAAIC,EAAY,EAChB,MAAMC,EAASpI,EAAE6G,MAAMnC,GACnB0D,IACAD,EAAYC,EAAO1C,OACnB1F,EAAIA,EAAEqI,QAAQ3D,EAhBH,QAiBXwD,EAAOrF,QAAQuF,EAAOE,IAAIN,EAAMjD,SAEpC,MAAMwD,EAAUvI,EAAE6G,MAAMpC,GAKxB,OAJI8D,IACAvI,EAAIA,EAAEqI,QAAQ5D,EApBF,QAqBZyD,EAAOrF,QAAQ0F,EAAQD,IAAIzD,EAAOE,SAE/B,CAAEmD,SAAQC,YAAWK,UAAWxI,GAE3C,SAAS+E,EAAM/E,GACX,OAAOiI,EAAQjI,GAAGkI,OAEtB,SAASO,EAAkBzI,GACvB,MAAM,OAAEkI,EAAM,UAAEC,EAAS,UAAEK,GAAcP,EAAQjI,GAC3C0I,EAAYR,EAAOxC,OACzB,OAAQ1F,IACJ,IAAI2I,EAASH,EACb,IAAK,IAAII,EAAI,EAAGA,EAAIF,EAAWE,IAC3BD,EAASA,EAAON,QAAQO,EAAIT,EAnCrB,OACC,OAkC0DS,EAAIT,EAAYH,EAAM/C,UAAUjF,EAAE4I,IAAMtE,EAAStE,EAAE4I,KAEzH,OAAOD,GAGf,MAAME,EAAwB7I,GAAmB,iBAANA,EAAiB,EAAIA,EAMhE,MAAM8I,EAAU,CAAEhE,KA5ClB,SAAc9E,GACV,IAAIU,EAAIqI,EAAIC,EAAIC,EAChB,OAAQC,MAAMlJ,IACV4E,EAAS5E,KAC6E,QAApF+I,EAAoC,QAA9BrI,EAAKV,EAAE6G,MAAMpC,UAAgC,IAAP/D,OAAgB,EAASA,EAAGgF,cAA2B,IAAPqD,EAAgBA,EAAK,IAA2F,QAApFE,EAAoC,QAA9BD,EAAKhJ,EAAE6G,MAAMnC,UAAgC,IAAPsE,OAAgB,EAASA,EAAGtD,cAA2B,IAAPuD,EAAgBA,EAAK,GAAK,GAwChOlE,QAAO0D,oBAAmBU,kBALlD,SAA2BnJ,GACvB,MAAMoJ,EAASrE,EAAM/E,GAErB,OADoByI,EAAkBzI,EAC/BqJ,CAAYD,EAAOd,IAAIO,MAI5BS,EAAc,IAAIvG,IAAI,CAAC,aAAc,WAAY,WAAY,YACnE,SAASwG,EAAmBvJ,GACxB,IAAKwJ,EAAMvI,GAASjB,EAAEyJ,MAAM,GAAI,GAAGhE,MAAM,KACzC,GAAa,gBAAT+D,EACA,OAAOxJ,EACX,MAAO6E,GAAU5D,EAAM4F,MAAMpC,IAAe,GAC5C,IAAKI,EACD,OAAO7E,EACX,MAAMuF,EAAOtE,EAAMoH,QAAQxD,EAAQ,IACnC,IAAI6E,EAAeJ,EAAYrG,IAAIuG,GAAQ,EAAI,EAG/C,OAFI3E,IAAW5D,IACXyI,GAAgB,KACbF,EAAO,IAAME,EAAenE,EAAO,IAE9C,MAAMoE,EAAgB,oBAChBC,EAASvG,OAAO8B,OAAO9B,OAAO8B,OAAO,GAAI2D,GAAU,CAAEK,kBAAoBnJ,IACvE,MAAM6J,EAAY7J,EAAE6G,MAAM8C,GAC1B,OAAOE,EAAYA,EAAUvB,IAAIiB,GAAoBO,KAAK,KAAO9J,KAGzEuD,EAAQ2B,MAAQA,EAChB3B,EAAQyE,MAAQA,EAChBzE,EAAQuF,QAAUA,EAClBvF,EAAQoC,QAAUA,EAClBpC,EAAQqG,OAASA,EACjBrG,EAAQoE,IAAMA,EACdpE,EAAQwD,KAAOA,EACfxD,EAAQsB,OAASA,EACjBtB,EAAQqC,QAAUA,EAClBrC,EAAQyC,mBAAqBA,EAC7BzC,EAAQsC,GAAKA,EACbtC,EAAQ+D,QAAUA,EAClB/D,EAAQgE,KAAOA,EACfhE,EAAQ6B,MAAQA,EAChB7B,EAAQuC,GAAKA,EACbvC,EAAQwC,GAAKA,G,iCC5Nb,sCAAIgE,EAAgC,oBAAbC,U,iCCAvB,sCAAIC,EAAoB,SAAUjK,GAC9B,OAAOC,MAAMC,QAAQF,K,iCCDzB,wEAAIkK,EAAmB,SAAUC,GAAa,MAAQ,CAClDC,UAAW,SAAU/J,GAAS,OAAO8J,EAAUE,MAAK,SAAUb,GAAQ,QAASnJ,EAAMmJ,SAErFc,EAAqB,CACrBC,cAAeL,EAAiB,CAAC,SAAU,WAAY,SACvDM,UAAWN,EAAiB,CACxB,UACA,OACA,WACA,aACA,WACA,aACA,YACA,gBAEJnI,KAAMmI,EAAiB,CAAC,SACxBO,KAAMP,EAAiB,CAAC,OAAQ,iBAChCQ,MAAOR,EAAiB,CAAC,eACzBS,MAAOT,EAAiB,CAAC,aAAc,eAAgB,eACvDU,IAAKV,EAAiB,CAAC,WAAY,QAAS,aAAc,gBAC1DW,IAAKX,EAAiB,CAClB,QACA,aACA,oBACA,aAEJY,OAAQZ,EAAiB,CACrB,cACA,kBACA,qBAGR,SAASa,EAAaC,GAClB,IAAK,IAAI9J,KAAO8J,EACU,OAAlBA,EAAS9J,KAED,8BAARA,EACAoJ,EAAmBW,0BAA4BD,EAAS9J,GAGxDoJ,EAAmBpJ,GAAKgK,UAAYF,EAAS9J,M,iCCxCzD,SAASiK,EAAYC,GACjB,MAAuB,iBAARA,GACX/H,OAAOgD,UAAUC,eAAeC,KAAK6E,EAAK,WAFlD,mC,iCCAA,kCAKA,IAAIC,EAAwB,CAKxBC,wBAAwB,EAKxBC,gBAAgB,I,iCCfpB,wEAAIC,EAAkB,GACtB,SAASC,EAAkBC,GACvBrI,OAAO8B,OAAOqG,EAAiBE,K,iCCFnC,6CAEIC,EAAcxJ,wBAAc,CAAEyJ,QAAQ,K,iCCF1C,iFAEIC,EAAgB,SAAU7L,GAC1B,OAAOiC,QAAQjC,GAAkB,iBAANA,GAAkBA,EAAE8L,KAAO9L,EAAE+L,UAExDC,EAA+B,SAAUhM,GAEzC,OAAOiK,YAAkBjK,GAAKA,EAAEA,EAAE0F,OAAS,IAAM,EAAI1F,I,iCCPzD,SAASiM,EAAoBjM,GACzB,MAAoB,iBAANA,GAAqC,mBAAZA,EAAEyB,MAD7C,mC,iCCAA,wDAGA,SAASyK,EAA4B7L,GACjC,IAAI8L,EAAQ9L,EAAM8L,MACdC,EAAY,GAChB,IAAK,IAAIlL,KAAOiL,GACR/I,YAAc+I,EAAMjL,KAASmL,YAAoBnL,EAAKb,MACtD+L,EAAUlL,GAAOiL,EAAMjL,IAG/B,OAAOkL,I,+FCTX,SAASE,EAAWC,EAAQC,EAAQC,GAChC,MAAyB,iBAAXF,EACRA,EACA1G,KAAGZ,UAAUuH,EAASC,EAAOF,GCHvC,IAAIG,EAAW,CACXF,OAAQ,oBACRG,MAAO,oBAEPC,EAAY,CACZJ,OAAQ,mBACRG,MAAO,mBCAX,SAASE,EAAcC,EAAOpM,EAAIqM,EAASC,GACvC,IAAIC,EAAQvM,EAAGuM,MAAOC,EAAQxM,EAAGwM,MAAOC,EAAUzM,EAAGyM,QAASC,EAAU1M,EAAG0M,QAASC,EAAa3M,EAAG2M,WAAYtE,EAAKrI,EAAG4M,YAAaA,OAAqB,IAAPvE,EAAgB,EAAIA,EAAIC,EAAKtI,EAAG6M,WAAYA,OAAoB,IAAPvE,EAAgB,EAAIA,EAEhOwE,EAASC,iBAAO/M,EAAI,CAAC,QAAS,QAAS,UAAW,UAAW,aAAc,cAAe,eAC1FgN,YAAgBZ,EAAOU,EAAQT,EAASC,GACxCF,EAAMa,MAAQb,EAAMX,MACpBW,EAAMX,MAAQ,GACd,IAAIwB,EAAQb,EAAMa,MAAOxB,EAAQW,EAAMX,MAAOyB,EAAad,EAAMc,WAK7DD,EAAM1I,YACF2I,IACAzB,EAAMlH,UAAY0I,EAAM1I,kBACrB0I,EAAM1I,WAGb2I,SACa9G,IAAZqG,QAAqCrG,IAAZsG,GAAyBjB,EAAMlH,aACzDkH,EAAM0B,gBFjBd,SAAgCD,EAAYT,EAASC,GACjD,IAAIU,EAAYxB,EAAWa,EAASS,EAAWG,EAAGH,EAAWI,OACzDC,EAAY3B,EAAWc,EAASQ,EAAWM,EAAGN,EAAWO,QAC7D,MAAO,GAAGC,OAAON,EAAW,KAAKM,OAAOH,GEcZI,CAAuBT,OAAwB9G,IAAZqG,EAAwBA,EAAU,QAAiBrG,IAAZsG,EAAwBA,EAAU,UAG1HtG,IAAVmG,IACAU,EAAMI,EAAId,QACAnG,IAAVoG,IACAS,EAAMO,EAAIhB,QAEKpG,IAAfuG,GDnBR,SAAsBM,EAAOjI,EAAQ4I,EAAS9B,EAAQ+B,QAClC,IAAZD,IAAsBA,EAAU,QACrB,IAAX9B,IAAqBA,EAAS,QACd,IAAhB+B,IAA0BA,GAAc,GAE5CZ,EAAMN,WAAa,EAGnB,IAAImB,EAAOD,EAAc7B,EAAWE,EAEpCe,EAAMa,EAAKhC,QAAU3G,KAAGZ,WAAWuH,GAEnC,IAAIa,EAAaxH,KAAGZ,UAAUS,GAC1B4H,EAAczH,KAAGZ,UAAUqJ,GAC/BX,EAAMa,EAAK7B,OAAS,GAAGyB,OAAOf,EAAY,KAAKe,OAAOd,GCMlDmB,CAAad,EAAON,EAAYC,EAAaC,GAAY,K,gFCnC7DmB,EAAiB,CACjBX,EAAG,aACHG,EAAG,aACHS,EAAG,aACHC,qBAAsB,e,aCHtBC,EAAiB,SAAU5N,EAAOiF,GAClC,OAAOA,GAAyB,iBAAVjF,EAChBiF,EAAKjB,UAAUhE,GACfA,G,SCAV,SAASyM,EAAgBZ,EAAOgC,EAAc/B,EAASC,GACnD,IAAItM,EACAyL,EAAQW,EAAMX,MAAO4C,EAAOjC,EAAMiC,KAAM9J,EAAY6H,EAAM7H,UAAW+J,EAAgBlC,EAAMkC,cAAenB,EAAkBf,EAAMe,gBAItImB,EAActJ,OAAS,EAEvB,IAAIuJ,GAAe,EACfC,GAAqB,EAErBC,GAAkB,EAOtB,IAAK,IAAIjO,KAAO4N,EAAc,CAC1B,IAAI7N,EAAQ6N,EAAa5N,GAIzB,GAAIkO,YAAclO,GACd6N,EAAK7N,GAAOD,MADhB,CAKA,IAAIoO,EAAYC,IAAiBpO,GAC7BqO,EAAcV,EAAe5N,EAAOoO,GACxC,GAAIrM,YAAgB9B,GAAM,CAMtB,GAJA+N,GAAe,EACfhK,EAAU/D,GAAOqO,EACjBP,EAAcnM,KAAK3B,IAEdiO,EACD,SAEAlO,KAAwC,QAA5BP,EAAK2O,EAAUhK,eAA4B,IAAP3E,EAAgBA,EAAK,KACrEyO,GAAkB,QAEjBhM,YAAsBjC,IAC3B2M,EAAgB3M,GAAOqO,EAEvBL,GAAqB,GAGrB/C,EAAMjL,GAAOqO,GAGjBN,EACA9C,EAAMlH,UF5Cd,SAAwBvE,EAAIqI,EAAIyG,EAAoBxC,GAChD,IAAI/H,EAAYvE,EAAGuE,UAAW+J,EAAgBtO,EAAGsO,cAC7ChG,EAAKD,EAAG0G,2BAA4BA,OAAoC,IAAPzG,GAAuBA,EAAIC,EAAKF,EAAG2G,mBAAoBA,OAA4B,IAAPzG,GAAuBA,EAEpK0G,EAAkB,GAEtBX,EAAcY,KAAKtN,KAMnB,IAHA,IAAIuN,GAAgB,EAEhBC,EAAmBd,EAActJ,OAC5BkD,EAAI,EAAGA,EAAIkH,EAAkBlH,IAAK,CACvC,IAAI1H,EAAM8N,EAAcpG,GACxB+G,GAAmB,GAAGvB,OAAOM,EAAexN,IAAQA,EAAK,KAAKkN,OAAOnJ,EAAU/D,GAAM,MACzE,MAARA,IACA2O,GAAgB,GAgBxB,OAdKA,GAAiBJ,EAClBE,GAAmB,gBAGnBA,EAAkBA,EAAgBI,OAIlC/C,EACA2C,EAAkB3C,EAAkB/H,EAAWuK,EAAqB,GAAKG,GAEpED,GAAsBF,IAC3BG,EAAkB,QAEfA,EEYeK,CAAelD,EAAOC,EAASoC,EAAiBnC,GAE7DA,EACLb,EAAMlH,UAAY+H,EAAkB,GAAI,KAElC8B,EAAa7J,WAAakH,EAAMlH,YACtCkH,EAAMlH,UAAY,QAElBiK,IACA/C,EAAM0B,gBFfd,SAA8BnN,GAC1B,IAAIqI,EAAKrI,EAAGyM,QAASA,OAAiB,IAAPpE,EAAgB,MAAQA,EAAIC,EAAKtI,EAAG0M,QAASA,OAAiB,IAAPpE,EAAgB,MAAQA,EAAIC,EAAKvI,EAAGuP,QAASA,OAAiB,IAAPhH,EAAgB,EAAIA,EACjK,MAAO,GAAGmF,OAAOjB,EAAS,KAAKiB,OAAOhB,EAAS,KAAKgB,OAAO6B,GEa/BC,CAAqBrC,M,mEC/DrD,IAAIsC,EAAuB,CACvB,UACA,SACA,OACA,OACA,UACA,IACA,QACA,OACA,SACA,SACA,OACA,WACA,OACA,UACA,UACA,WACA,OACA,OACA,MACA,SACA,SACA,OACA,QACA,MACA,QC3BJ,SAASC,EAAelF,GACpB,MAKqB,iBAAdA,IAIHA,EAAUmF,SAAS,SAOvBF,EAAqB1N,QAAQyI,IAAc,GAIvC,QAAQpG,KAAKoG,M,iCCvBrB,wDAQA,SAASoF,EAAmBrP,GACxB,IAAIsP,EAAiBnN,YAAcnC,GAASA,EAAME,MAAQF,EAC1D,OAAO4K,YAAc0E,GACfA,EAAexE,UACfwE,I,iCCZV,6CAKIC,EAA2BrO,wBAAc,K,iCCL7C,wDAGA,SAAS+J,EAA4B7L,GACjC,IAAI+L,EAAYqE,YAA8BpQ,GAC9C,IAAK,IAAIa,KAAOb,EAAO,CACnB,GAAI+C,YAAc/C,EAAMa,IAEpBkL,EADwB,MAARlL,GAAuB,MAARA,EAAc,OAASA,EAAIwP,cAAgBxP,GACnDb,EAAMa,GAGrC,OAAOkL,I,iCCXX,wDAGA,SAASC,EAAoBnL,EAAKR,GAC9B,IAAIiQ,EAASjQ,EAAGiQ,OAAQC,EAAWlQ,EAAGkQ,SACtC,OAAQ5N,YAAgB9B,IACpBiC,YAAsBjC,KACpByP,QAAuB7J,IAAb8J,OACLpF,IAAgBtK,IAAgB,YAARA,K,iCCLvC,SAASkO,EAAclO,GACnB,OAAOA,EAAIkF,WAAW,MAJ1B,mC,iCCAA,iEAIA,SAASyK,EAAUC,EAASC,EAAaC,EAAYC,GAEjD,IAAK,IAAI/P,KADTgQ,YAAWJ,EAASC,OAAajK,EAAWmK,GAC5BF,EAAYpD,MACxBmD,EAAQK,aAAcC,IAAoBnO,IAAI/B,GAA0BA,EAAnBmQ,YAAYnQ,GAAY6P,EAAYpD,MAAMzM,M,iCCPvG,SAASgQ,EAAWJ,EAASpQ,EAAI4Q,EAAWL,GACxC,IAAI9E,EAAQzL,EAAGyL,MAAO4C,EAAOrO,EAAGqO,KAGhC,IAAK,IAAI7N,KAFTmC,OAAO8B,OAAO2L,EAAQ3E,MAAOA,EAAO8E,GAAcA,EAAWM,oBAAoBD,IAEjEvC,EACZ+B,EAAQ3E,MAAMqF,YAAYtQ,EAAK6N,EAAK7N,IAL5C,mC,iCCAA,kCAGA,IAAIkQ,EAAsB,IAAIrO,IAAI,CAC9B,gBACA,kBACA,eACA,mBACA,aACA,WACA,oBACA,eACA,cACA,aACA,UACA,UACA,eACA,mBACA,mBACA,eACA,cACA,UACA,oBACA,gB,iCCvBJ,sCAAI0O,EAAqB,kBAKrBJ,EAAc,SAAUK,GACxB,OAAOA,EAAIrJ,QAAQoJ,EALA,SAKsCE,gB,qGCA7D,IAAIC,EAAmB,IAAI7O,IAAI,CAC3B,UACA,UACA,OACA,QACA,WACA,aACA,oBACA,kBACA,SACA,UACA,SACA,WACA,mBACA,yBACA,4BACA,kBACA,wBACA,mBACA,sBACA,WACA,cACA,SACA,YACA,2BACA,kBACA,sBACA,OACA,eACA,eACA,kBACA,oBACA,mBACA,SACA,SACA,cACA,eACA,kBACA,iBACA,YACA,QACA,aACA,WACA,oBACA,QACA,aACA,cACA,eACA,aACA,aACA,WACA,aACA,cACA,kBACA,kBACA,WACA,iBAUJ,SAAS8O,EAAkB3Q,GACvB,OAAO0Q,EAAiB3O,IAAI/B,GCvEhC,IAAI4Q,EAAgB,SAAU5Q,GAAO,OAAQ2Q,EAAkB3Q,IAC/D,SAAS6Q,EAAwBC,GACxBA,IAGLF,EAAgB,SAAU5Q,GACtB,OAAOA,EAAIkF,WAAW,OAASyL,EAAkB3Q,GAAO8Q,EAAY9Q,KAgB5E,IAMI6Q,EAAwBE,EAAQ,KAA0B5M,SAE9D,MAAO3E,IAGP,SAASwR,EAAY7R,EAAO8R,EAAOC,GAC/B,IAAIC,EAAgB,GACpB,IAAK,IAAInR,KAAOb,GACRyR,EAAc5Q,KACU,IAAvBkR,GAA+BP,EAAkB3Q,KAChDiR,IAAUN,EAAkB3Q,IAE7Bb,EAAK,WAAiBa,EAAIkF,WAAW,aACtCiM,EAAcnR,GAAOb,EAAMa,IAGnC,OAAOmR,I,sFC3CPC,EAAMC,mBAASA,mBAAS,GAAI1N,UAAS,CAAEI,UAAWZ,KAAK+C,QCAvDkI,EAAmB,CAEnBkD,YAAa3M,KACb4M,eAAgB5M,KAChB6M,iBAAkB7M,KAClB8M,kBAAmB9M,KACnB+M,gBAAiB/M,KACjBgN,aAAchN,KACdiN,OAAQjN,KACRkN,oBAAqBlN,KACrBmN,qBAAsBnN,KACtBoN,wBAAyBpN,KACzBqN,uBAAwBrN,KAExBmI,MAAOnI,KACPsN,SAAUtN,KACVsI,OAAQtI,KACRuN,UAAWvN,KACX4G,KAAM5G,KACNwN,IAAKxN,KACLyN,MAAOzN,KACP0N,OAAQ1N,KACR2N,KAAM3N,KAEN4N,QAAS5N,KACT6N,WAAY7N,KACZ8N,aAAc9N,KACd+N,cAAe/N,KACfgO,YAAahO,KACbiO,OAAQjO,KACRkO,UAAWlO,KACXmO,YAAanO,KACboO,aAAcpO,KACdqO,WAAYrO,KAEZsO,OAAQxO,UACRyO,QAASzO,UACT0O,QAAS1O,UACT2O,QAAS3O,UACTP,MAAOA,QACPmP,OAAQnP,QACRoP,OAAQpP,QACRqP,OAAQrP,QACRsP,KAAM/O,UACNgP,MAAOhP,UACPiP,MAAOjP,UACPkP,SAAUhP,KACViP,WAAYjP,KACZkP,WAAYlP,KACZmP,WAAYnP,KACZkI,EAAGlI,KACHqI,EAAGrI,KACH8I,EAAG9I,KACHoP,YAAapP,KACb+I,qBAAsB/I,KACtBqP,QAAShQ,QACTiI,QAASnH,qBACToH,QAASpH,qBACTiK,QAASpK,KAETsP,OAAQ7C,EAER8C,YAAalQ,QACbmQ,cAAenQ,QACfoQ,WAAYhD,I,iCCjEhBjP,OAAOC,eAAeC,EAAS,aAAc,CAAEtC,OAAO,IAItD,IAF0BsU,EAEtBC,GAFsBD,EAEI,EAAQ,OAFuB,iBAAPA,GAAoB,YAAaA,EAAMA,EAAY,QAAIA,EAIzGE,EAAkB,45HAElBC,EAAQF,GAAQ,SAAUG,GAC5B,OAAOF,EAAgB3Q,KAAK6Q,IAAgC,MAAvBA,EAAKC,WAAW,IAE3B,MAAvBD,EAAKC,WAAW,IAEhBD,EAAKC,WAAW,GAAK,MAK1BrS,EAAQ8B,QAAUqQ,G,kICZdG,EAAexS,OAAOmL,KAAKlE,KAC3BwL,EAAcD,EAAanQ,O,aCP3BqQ,EAAgB5T,wBAAc,I,8BCI9B6T,EAAuB,CAAEjV,QAAS,MAClCkV,GAAc,EA2ClB,SAASC,IASL,OALCD,GA9CL,WAEI,GADAA,GAAc,EACTlM,IAEL,GAAIoM,OAAOC,WAAY,CACnB,IAAIC,EAAqBF,OAAOC,WAAW,4BACvCE,EAA8B,WAC9B,OAAQN,EAAqBjV,QAAUsV,EAAmBE,SAE9DF,EAAmBG,YAAYF,GAC/BA,SAGAN,EAAqBjV,SAAU,EAiCnB0V,GACPC,iBAAOC,mBAASX,EAAqBjV,SAAU,GAA4B,GChDxF,SAAS6V,EAAiB1L,EAAW2L,EAAaxW,EAAOyW,GACrD,IDsDIC,EACA9S,ECvDA+S,EAAcC,qBAAWtL,KACzBuL,EFLGD,qBAAWlB,GAAelV,cEM7BsW,EAAkBF,qBAAW/U,KAC7BkV,GDmDAL,EAA0Bb,IAER,WADlBjS,EAAgBgT,qBAAWpT,KAAqBI,iBAIzB,WAAlBA,GAIE8S,IC3DPM,EAAmBC,sBAAOxQ,GAIzBgQ,IACDA,EAAsBE,EAAYO,WACjCF,EAAiBtW,SAAW+V,IAC7BO,EAAiBtW,QAAU+V,EAAoB5L,EAAW,CACtD2L,YAAaA,EACbK,OAAQA,EACR7W,MAAOA,EACPmX,WAAYL,aAAyD,EAASA,EAAgBM,GAC9FC,uBAAuH,KAA/FP,aAAyD,EAASA,EAAgBzV,SAC1G0V,mBAAoBA,KAG5B,IAAIvW,EAAgBwW,EAAiBtW,QASrC,OARA4W,aAA0B,WACtB9W,SAA8DA,EAAc+W,gBAEhFC,qBAAU,WACN,IAAInX,EACkG,QAArGA,EAAKG,aAAqD,EAASA,EAAciX,sBAAmC,IAAPpX,GAAyBA,EAAGqX,oBAE9IJ,aAA0B,WAAc,OAAO,WAAc,OAAO9W,aAAqD,EAASA,EAAcmX,mBAAuB,IAChKnX,E,0BCjCX,SAASoX,EAAuB5X,GAC5B,IAAIK,ECHR,SAAgCL,EAAO6X,GACnC,GAAI3W,YAA2BlB,GAAQ,CACnC,IAAIqB,EAAUrB,EAAMqB,QAASF,EAAUnB,EAAMmB,QAC7C,MAAO,CACHE,SAAqB,IAAZA,GAAqBvB,YAAeuB,GACvCA,OACAoF,EACNtF,QAASrB,YAAeqB,GAAWA,OAAUsF,GAGrD,OAAyB,IAAlBzG,EAAM8X,QAAoBD,EAAU,GDPlCE,CAAuB/X,EAAO4W,qBAAWlB,IAAiBrU,EAAUhB,EAAGgB,QAASF,EAAUd,EAAGc,QACtG,OAAO6W,mBAAQ,WAAc,MAAQ,CAAE3W,QAASA,EAASF,QAASA,KAAe,CAAC8W,EAA0B5W,GAAU4W,EAA0B9W,KAEpJ,SAAS8W,EAA0B3C,GAC/B,OAAO1V,MAAMC,QAAQyV,GAAQA,EAAK7L,KAAK,KAAO6L,E,qBEN9C8B,EAAK,E,sBCAT,IAAIc,EAAsC,SAAUC,GAEhD,SAASD,IACL,OAAkB,OAAXC,GAAmBA,EAAOC,MAAMC,KAAMC,YAAcD,KAkB/D,OApBAE,oBAAUL,EAAsBC,GAOhCD,EAAqBlS,UAAUwS,wBAA0B,WAErD,OADAH,KAAKI,cACE,MAEXP,EAAqBlS,UAAU0S,mBAAqB,aACpDR,EAAqBlS,UAAUyS,YAAc,WACzC,IAAIpY,EAAKgY,KAAKrY,MAAOQ,EAAgBH,EAAGG,cAAeR,EAAQK,EAAGL,MAC9DQ,GACAA,EAAcmY,SAAS3Y,IAE/BkY,EAAqBlS,UAAU4S,OAAS,WACpC,OAAOP,KAAKrY,MAAM6Y,UAEfX,EArB+B,CAsBxCY,IAAejO,WCAjB,SAASkO,EAAsB1Y,GAC3B,IAAI2Y,EAAoB3Y,EAAG2Y,kBAAmBvC,EAAsBpW,EAAGoW,oBAAqB7L,EAA4BvK,EAAGuK,0BAA2BqO,EAAY5Y,EAAG4Y,UAAWC,EAAiB7Y,EAAG6Y,eAAgBrO,EAAYxK,EAAGwK,UAsDnO,OArDAmO,GAAqBtO,YAAasO,GAqD3BG,sBApDP,SAAyBnZ,EAAOoZ,GAC5B,IAAI7I,EAqDZ,SAAqBlQ,GACjB,IAAIqI,EACA6H,EAAWlQ,EAAGkQ,SACd8I,EAA0D,QAAzC3Q,EAAKkO,qBAAWvT,YAAwC,IAAPqF,OAAgB,EAASA,EAAG0O,GAClG,OAAOiC,QAA8B5S,IAAb8J,EAClB8I,EAAgB,IAAM9I,EACtBA,EA3Da+I,CAAYtZ,GAC3BA,EAAQkS,mBAASA,mBAAS,GAAIlS,GAAQ,CAAEuQ,SAAUA,IAOlD,IAAIgJ,EAAS3C,qBAAWpT,KACpBmH,EAAW,KACXkN,EAAUD,EAAuB5X,GAYjCwZ,EAAeD,EAAO5V,cAAW8C,EF9ClCgT,aAAY,WACf,GAAIzO,IAAsBE,eACtB,OAAOkM,OEgDPZ,EAAc0C,EAAelZ,EAAOuZ,EAAO5V,UAqB/C,OApBK4V,EAAO5V,UAAY+F,MAOpBmO,EAAQrX,cAAgB+V,EAAiB1L,EAAW2L,EAAatE,mBAASA,mBAAS,GAAIqH,GAASvZ,GAAQyW,GC3DpH,SAAuB+C,EAAcnZ,EAAIG,EAAekZ,GACpD,IAAIhR,EACA6H,EAAWlQ,EAAGkQ,SAAUD,EAASjQ,EAAGiQ,OAAQlG,EAAO/J,EAAG+J,KAAMuP,EAAkBtZ,EAAGsZ,gBAAiBC,EAAevZ,EAAGuZ,aACpHC,EAAyBjD,qBAAWzG,KACnCuJ,GACAlZ,KACAA,aAAqD,EAASA,EAAcoQ,cAGjFpQ,EAAcoQ,WAAa,IAAI8I,EAA0BF,EAAchZ,EAAcsZ,kBAAmD,QAA/BpR,EAAKlI,EAAcqW,cAA2B,IAAPnO,OAAgB,EAASA,EAAGkI,YAC5KpQ,EAAcoQ,WAAWmJ,WAAW,CAChCxJ,SAAUA,EACVD,OAAQA,EACR0J,oBAAqBpY,QAAQwI,IAAUuP,GAAmB7O,YAAY6O,GACtEnZ,cAAeA,EACfyZ,eAAgB,WAAc,OAAOzZ,EAAcyZ,kBAQnDC,cAAiC,iBAAX5J,EAAsBA,EAAS,OACrDuJ,uBAAwBA,EACxBD,aAAcA,KDmCVO,CAAcX,EAAcxZ,EAAO6X,EAAQrX,cAAeoK,GACtDX,IAAmBW,2BAKvBD,ERzDZ,SAAqB3K,EAAOQ,EAAewY,GACvC,IAAIrO,EAAW,GACXgM,EAAcC,qBAAWtL,KAC7B,IAAK9K,EACD,OAAO,KAKC,eAAR8C,KAAwB0V,GAAqBrC,EAAYpL,QACzDnI,qBAAU,EAAO,oJAErB,IAAK,IAAImF,EAAI,EAAGA,EAAIkN,EAAalN,IAAK,CAClC,IAAI6R,EAAS5E,EAAajN,GACtBlI,EAAK4J,IAAmBmQ,GAASrQ,EAAY1J,EAAG0J,UAAWc,EAAYxK,EAAGwK,UAM1Ed,EAAU/J,IAAU6K,GACpBF,EAASnI,KAAK6X,gBAAoBxP,EAAWqH,mBAAS,CAAErR,IAAKuZ,GAAUpa,EAAO,CAAEQ,cAAeA,MAGvG,OAAOmK,EQiCY2P,CAAYta,EAAO6X,EAAQrX,cAAewY,IAMjDqB,gBAAoBnC,EAAsB,CAAE1X,cAAeqX,EAAQrX,cAAeR,MAAOkS,mBAASA,mBAAS,GAAIqH,GAASvZ,IAC5H2K,EACA0P,gBAAoB3E,EAAc6E,SAAU,CAAE3Z,MAAOiX,GAAWoB,EAAUpO,EAAW7K,EAAOwZ,EEvExG,SAAsBhD,EAAahW,EAAe4Y,GAC9C,OAAOoB,uBAAY,SAAUC,GACzB,IAAIpa,EACJoa,IAA0C,QAA5Bpa,EAAKmW,EAAYkE,aAA0B,IAAPra,GAAyBA,EAAG6F,KAAKsQ,EAAaiE,IAC5Fja,IACAia,EACMja,EAAcka,MAAMD,GACpBja,EAAcma,WAEpBvB,IAC2B,mBAAhBA,EACPA,EAAYqB,GAEP3P,YAAYsO,KACjBA,EAAY1Y,QAAU+Z,MASlC,CAACja,IFgDiHoa,CAAapE,EAAaqB,EAAQrX,cAAe4Y,GAAc5C,EAAa+C,EAAO5V,SAAUkU,EAAQrX,oB,wCG9EvNqa,EAAwB,WAAc,MAAQ,CAC9C/O,MAAO,GACPlH,UAAW,GACX+J,cAAe,GACfnB,gBAAiB,GACjBkB,KAAM,KCEV,SAASoM,EAAkBC,EAAQC,EAAQhb,GACvC,IAAK,IAAIa,KAAOma,EACPjY,YAAciY,EAAOna,KAAUmL,YAAoBnL,EAAKb,KACzD+a,EAAOla,GAAOma,EAAOna,IAajC,SAASoa,EAASjb,EAAOwW,EAAa7S,GAClC,IACImI,EAAQ,GASZ,OALAgP,EAAkBhP,EALF9L,EAAM8L,OAAS,GAKK9L,GACpCgD,OAAO8B,OAAOgH,EAhBlB,SAAgCzL,EAAImW,EAAa7S,GAC7C,IAAIgJ,EAAoBtM,EAAGsM,kBAC3B,OAAOqL,mBAAQ,WACX,IAAIvL,EDjBsC,CAC9CX,MAAO,GACPlH,UAAW,GACX+J,cAAe,GACfnB,gBAAiB,GACjBkB,KAAM,ICaFrB,YAAgBZ,EAAO+J,EAAa,CAAEpH,4BAA6BzL,GAAYgJ,GAC/E,IAAI+B,EAAOjC,EAAMiC,KAAM5C,EAAQW,EAAMX,MACrC,OAAOoG,mBAASA,mBAAS,GAAIxD,GAAO5C,KACrC,CAAC0K,IASiB0E,CAAuBlb,EAAOwW,EAAa7S,IAC5D3D,EAAMmb,kBACNrP,EAAQ9L,EAAMmb,gBAAgBrP,IAE3BA,EAEX,SAASsP,EAAapb,EAAOwW,EAAa7S,GAEtC,IAAI0X,EAAY,GACZvP,EAAQmP,EAASjb,EAAOwW,EAAa7S,GAgBzC,OAfI/B,QAAQ5B,EAAMoK,QAAgC,IAAvBpK,EAAMsb,eAE7BD,EAAUE,WAAY,EAEtBzP,EAAM0P,WACF1P,EAAM2P,iBACF3P,EAAM4P,mBACF,OAEZ5P,EAAM6P,aACa,IAAf3b,EAAMoK,KACA,OACA,OAAO2D,OAAsB,MAAf/N,EAAMoK,KAAe,IAAM,MAEvDiR,EAAUvP,MAAQA,EACXuP,E,sBCpDPO,EAAuB,WAAc,OAAQ1J,mBAASA,mBAAS,GFHjB,CAC9CpG,MAAO,GACPlH,UAAW,GACX+J,cAAe,GACfnB,gBAAiB,GACjBkB,KAAM,KEFuF,CAAEpB,MAAO,MCG1G,SAASuO,EAAY7b,EAAOwW,GACxB,IAAIsF,EAAc9D,mBAAQ,WACtB,IAAIvL,EAAQmP,IAEZ,OADApP,YAAcC,EAAO+J,EAAa,CAAEpH,4BAA4B,GAASpP,EAAM2M,mBACxEuF,mBAASA,mBAAS,GAAIzF,EAAMa,OAAQ,CAAExB,MAAOoG,mBAAS,GAAIzF,EAAMX,WACxE,CAAC0K,IACJ,GAAIxW,EAAM8L,MAAO,CACb,IAAIiQ,EAAY,GAChBjB,EAAkBiB,EAAW/b,EAAM8L,MAAO9L,GAC1C8b,EAAYhQ,MAAQoG,mBAASA,mBAAS,GAAI6J,GAAYD,EAAYhQ,OAEtE,OAAOgQ,ECVX,SAASE,EAAgBjK,QACM,IAAvBA,IAAiCA,GAAqB,GAc1D,OAbgB,SAAUlH,EAAW7K,EAAOwZ,EAAczO,EAAK1K,EAAIsD,GAC/D,IAAI8K,EAAepO,EAAGoO,aAIlBqN,GAHiB/L,YAAelF,GAC9BgR,EACAT,GAC2Bpb,EAAOyO,EAAc9K,GAClDqO,EAAgBH,YAAY7R,EAA4B,iBAAd6K,EAAwBkH,GAClEkK,EAAe/J,mBAASA,mBAASA,mBAAS,GAAIF,GAAgB8J,GAAc,CAAE/Q,IAAKA,IAIvF,OAHIyO,IACAyC,EAAa,sBAAwBzC,GAElC0C,wBAAcrR,EAAWoR,I,wCCXxC,SAASE,EAAU9b,EAAIL,EAAO6X,EAASf,GACnC,IAAIjL,EAA8BxL,EAAGwL,4BAA6BuQ,EAAoB/b,EAAG+b,kBAAmBC,EAAUhc,EAAGgc,QACrH5P,EAAQ,CACRgC,aAAc6N,EAAiBtc,EAAO6X,EAASf,EAAiBjL,GAChE6E,YAAa0L,KAKjB,OAHIC,IACA5P,EAAMiO,MAAQ,SAAUD,GAAY,OAAO4B,EAAQrc,EAAOya,EAAUhO,KAEjEA,EAEX,IAAI8P,EAAqB,SAAUhD,GAC/B,OAAO,SAAUvZ,EAAO2D,GACpB,IAAIkU,EAAUjB,qBAAWlB,GACrBoB,EAAkBF,qBAAW/U,KACjC,OAAO8B,EACDwY,EAAU5C,EAAQvZ,EAAO6X,EAASf,GAClC2C,aAAY,WACV,OAAO0C,EAAU5C,EAAQvZ,EAAO6X,EAASf,QAIzD,SAASwF,EAAiBtc,EAAO6X,EAASf,EAAiB0F,GACvD,IAAI3U,EAAS,GACTwP,GAAwH,KAA/FP,aAAyD,EAASA,EAAgBzV,SAC3Gob,EAAeD,EAAmBxc,GACtC,IAAK,IAAIa,KAAO4b,EACZ5U,EAAOhH,GAAOoP,YAAmBwM,EAAa5b,IAElD,IAAIQ,EAAUrB,EAAMqB,QAASF,EAAUnB,EAAMmB,QACzCub,EAAwBxb,YAA2BlB,GACnD2c,EAAgBhb,YAAmB3B,GACnC6X,GACA8E,IACCD,IACiB,IAAlB1c,EAAM8X,UACNzW,UAAoDA,EAAUwW,EAAQxW,SACtEF,UAAoDA,EAAU0W,EAAQ1W,UAE1E,IAAIyb,EAA4BvF,IAAqC,IAAZhW,EACrDwb,EAAeD,EAA4Bzb,EAAUE,EACrDwb,GACwB,kBAAjBA,IACNjR,YAAoBiR,KACVjd,MAAMC,QAAQgd,GAAgBA,EAAe,CAACA,IACpDxa,SAAQ,SAAUpC,GACnB,IAAI6c,EAAW/c,YAAwBC,EAAOC,GAC9C,GAAK6c,EAAL,CAEA,IAAIC,EAAgBD,EAASC,cAAeD,EAASE,WAAY,IAAIjC,EAAS3N,iBAAO0P,EAAU,CAAC,gBAAiB,eACjH,IAAK,IAAIjc,KAAOka,EAAQ,CACpB,IAAIkC,EAAclC,EAAOla,GACzB,GAAIjB,MAAMC,QAAQod,GAQdA,EAAcA,EAHFL,EACNK,EAAY5X,OAAS,EACrB,GAGU,OAAhB4X,IACApV,EAAOhH,GAAOoc,GAGtB,IAAK,IAAIpc,KAAOkc,EACZlV,EAAOhH,GAAOkc,EAAclc,OAGxC,OAAOgH,ECzEX,IAAIqV,EAAkB,CAClBhE,eAAgBqD,EAAmB,CAC/B1Q,4BAA6BA,IAC7BuQ,kBAAmBR,EACnBS,QAAS,SAAUrc,EAAOya,EAAUpa,GAChC,IAAIqQ,EAAcrQ,EAAGqQ,YAAajC,EAAepO,EAAGoO,aACpD,IACIiC,EAAYnD,WAEJ,mBADGkN,EAAS0C,QAEV1C,EAAS0C,UACT1C,EAAS2C,wBAEvB,MAAOC,GAEH3M,EAAYnD,WAAa,CACrBG,EAAG,EACHG,EAAG,EACHF,MAAO,EACPG,OAAQ,GAGhBtB,YAAckE,EAAajC,EAAc,CAAEW,4BAA4B,GAASpP,EAAM2M,mBACtF6D,YAAUiK,EAAU/J,OCzB5B4M,EAAmB,CACnBpE,eAAgBqD,EAAmB,CAC/B1Q,4B,OAA6BA,EAC7BuQ,kBAAmBvB,KCD3B,IAAI0C,GCUJ,SAA2BC,GACvB,SAAStd,EAAO2K,EAAW4S,GAEvB,YADoC,IAAhCA,IAA0CA,EAA8B,IACrE1E,EAAsByE,EAAa3S,EAAW4S,IAEzD,GAAqB,oBAAVC,MACP,OAAOxd,EAMX,IAAIyd,EAAiB,IAAIC,IACzB,OAAO,IAAIF,MAAMxd,EAAQ,CAMrBY,IAAK,SAAU+c,EAAShd,GAOpB,OAHK8c,EAAe/a,IAAI/B,IACpB8c,EAAeG,IAAIjd,EAAKX,EAAOW,IAE5B8c,EAAe7c,IAAID,MDpC9Bkd,EEAR,SAA+BlT,EAAWxK,EAAI2Y,EAAmBvC,EAAqB7L,GAClF,IAAIlC,EAAKrI,EAAG0R,mBAAoBA,OAA4B,IAAPrJ,GAAwBA,EACzEsV,EAAajO,YAAelF,GAC1BqS,EACAI,EACN,OAAOpL,mBAASA,mBAAS,GAAI8L,GAAa,CAAEhF,kBAAmBA,EAAmBC,UAAW+C,EAAgBjK,GAAqB0E,oBAAqBA,EAAqB7L,0BAA2BA,EAA2BC,UAAWA,Q,mBCXjP,kBAeI0N,EACArG,EACA9E,EACA6Q,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAlI,EACAmI,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC;;;;;;;;;;;;;;iFACJ,SAAWC,GACP,IAAIC,EAAyB,iBAAXC,EAAsBA,EAAyB,iBAATC,KAAoBA,KAAuB,iBAATnH,KAAoBA,KAAO,GAUrH,SAASoH,EAAevc,EAASwc,GAS7B,OARIxc,IAAYoc,IACiB,mBAAlBtc,OAAO2c,OACd3c,OAAOC,eAAeC,EAAS,aAAc,CAAEtC,OAAO,IAGtDsC,EAAQ0c,YAAa,GAGtB,SAAUxI,EAAIzX,GAAK,OAAOuD,EAAQkU,GAAMsI,EAAWA,EAAStI,EAAIzX,GAAKA,QAjB+B,KAA9E,EAAF,SAAYuD,IAoB9C,SAAU2c,GACP,IAAIC,EAAgB9c,OAAO+c,gBACtB,CAAEC,UAAW,cAAgBpgB,OAAS,SAAUqgB,EAAG9d,GAAK8d,EAAED,UAAY7d,IACvE,SAAU8d,EAAG9d,GAAK,IAAK,IAAIuB,KAAKvB,EAAOa,OAAOgD,UAAUC,eAAeC,KAAK/D,EAAGuB,KAAIuc,EAAEvc,GAAKvB,EAAEuB,KAEhG6U,EAAY,SAAU0H,EAAG9d,GACrB,GAAiB,mBAANA,GAA0B,OAANA,EAC3B,MAAM,IAAI+d,UAAU,uBAAyBC,OAAOhe,GAAK,iCAE7D,SAASie,IAAO/H,KAAKgI,YAAcJ,EADnCH,EAAcG,EAAG9d,GAEjB8d,EAAEja,UAAkB,OAAN7D,EAAaa,OAAO2c,OAAOxd,IAAMie,EAAGpa,UAAY7D,EAAE6D,UAAW,IAAIoa,IAGnFlO,EAAWlP,OAAO8B,QAAU,SAAUwb,GAClC,IAAK,IAAIC,EAAGhY,EAAI,EAAGiY,EAAIlI,UAAUjT,OAAQkD,EAAIiY,EAAGjY,IAE5C,IAAK,IAAI7E,KADT6c,EAAIjI,UAAU/P,GACOvF,OAAOgD,UAAUC,eAAeC,KAAKqa,EAAG7c,KAAI4c,EAAE5c,GAAK6c,EAAE7c,IAE9E,OAAO4c,GAGXlT,EAAS,SAAUmT,EAAGlD,GAClB,IAAIiD,EAAI,GACR,IAAK,IAAI5c,KAAK6c,EAAOvd,OAAOgD,UAAUC,eAAeC,KAAKqa,EAAG7c,IAAM2Z,EAAEjb,QAAQsB,GAAK,IAC9E4c,EAAE5c,GAAK6c,EAAE7c,IACb,GAAS,MAAL6c,GAAqD,mBAAjCvd,OAAOyd,sBACtB,KAAIlY,EAAI,EAAb,IAAgB7E,EAAIV,OAAOyd,sBAAsBF,GAAIhY,EAAI7E,EAAE2B,OAAQkD,IAC3D8U,EAAEjb,QAAQsB,EAAE6E,IAAM,GAAKvF,OAAOgD,UAAU0a,qBAAqBxa,KAAKqa,EAAG7c,EAAE6E,MACvE+X,EAAE5c,EAAE6E,IAAMgY,EAAE7c,EAAE6E,KAE1B,OAAO+X,GAGXrC,EAAa,SAAU0C,EAAY5F,EAAQla,EAAK+f,GAC5C,IAA2HX,EAAvH1Z,EAAI+R,UAAUjT,OAAQkC,EAAIhB,EAAI,EAAIwU,EAAkB,OAAT6F,EAAgBA,EAAO5d,OAAO6d,yBAAyB9F,EAAQla,GAAO+f,EACrH,GAAuB,iBAAZE,SAAoD,mBAArBA,QAAQC,SAAyBxZ,EAAIuZ,QAAQC,SAASJ,EAAY5F,EAAQla,EAAK+f,QACpH,IAAK,IAAIrY,EAAIoY,EAAWtb,OAAS,EAAGkD,GAAK,EAAGA,KAAS0X,EAAIU,EAAWpY,MAAIhB,GAAKhB,EAAI,EAAI0Z,EAAE1Y,GAAKhB,EAAI,EAAI0Z,EAAElF,EAAQla,EAAK0G,GAAK0Y,EAAElF,EAAQla,KAAS0G,GAChJ,OAAOhB,EAAI,GAAKgB,GAAKvE,OAAOC,eAAe8X,EAAQla,EAAK0G,GAAIA,GAGhE2W,EAAU,SAAU8C,EAAYC,GAC5B,OAAO,SAAUlG,EAAQla,GAAOogB,EAAUlG,EAAQla,EAAKmgB,KAG3D7C,EAAa,SAAU+C,EAAaC,GAChC,GAAuB,iBAAZL,SAAoD,mBAArBA,QAAQM,SAAyB,OAAON,QAAQM,SAASF,EAAaC,IAGpH/C,EAAY,SAAUiD,EAASC,EAAYC,EAAGC,GAE1C,OAAO,IAAKD,IAAMA,EAAIE,WAAU,SAAUC,EAASC,GAC/C,SAASC,EAAUhhB,GAAS,IAAMihB,EAAKL,EAAUM,KAAKlhB,IAAW,MAAOyc,GAAKsE,EAAOtE,IACpF,SAAS0E,EAASnhB,GAAS,IAAMihB,EAAKL,EAAiB,MAAE5gB,IAAW,MAAOyc,GAAKsE,EAAOtE,IACvF,SAASwE,EAAKG,GAJlB,IAAephB,EAIaohB,EAAOC,KAAOP,EAAQM,EAAOphB,QAJ1CA,EAIyDohB,EAAOphB,MAJhDA,aAAiB2gB,EAAI3gB,EAAQ,IAAI2gB,GAAE,SAAUG,GAAWA,EAAQ9gB,OAITshB,KAAKN,EAAWG,GAClGF,GAAML,EAAYA,EAAUpJ,MAAMiJ,EAASC,GAAc,KAAKQ,YAItEzD,EAAc,SAAUgD,EAASc,GAC7B,IAAsGC,EAAGvU,EAAGyS,EAAG9Y,EAA3G6a,EAAI,CAAEC,MAAO,EAAGC,KAAM,WAAa,GAAW,EAAPjC,EAAE,GAAQ,MAAMA,EAAE,GAAI,OAAOA,EAAE,IAAOkC,KAAM,GAAIC,IAAK,IAChG,OAAOjb,EAAI,CAAEsa,KAAMY,EAAK,GAAI,MAASA,EAAK,GAAI,OAAUA,EAAK,IAAwB,mBAAXC,SAA0Bnb,EAAEmb,OAAOC,UAAY,WAAa,OAAOvK,OAAU7Q,EACvJ,SAASkb,EAAKlC,GAAK,OAAO,SAAU7gB,GAAK,OACzC,SAAckjB,GACV,GAAIT,EAAG,MAAM,IAAIlC,UAAU,mCAC3B,KAAOmC,GAAG,IACN,GAAID,EAAI,EAAGvU,IAAMyS,EAAY,EAARuC,EAAG,GAAShV,EAAU,OAAIgV,EAAG,GAAKhV,EAAS,SAAOyS,EAAIzS,EAAU,SAAMyS,EAAEpa,KAAK2H,GAAI,GAAKA,EAAEiU,SAAWxB,EAAIA,EAAEpa,KAAK2H,EAAGgV,EAAG,KAAKZ,KAAM,OAAO3B,EAE3J,OADIzS,EAAI,EAAGyS,IAAGuC,EAAK,CAAS,EAARA,EAAG,GAAQvC,EAAE1f,QACzBiiB,EAAG,IACP,KAAK,EAAG,KAAK,EAAGvC,EAAIuC,EAAI,MACxB,KAAK,EAAc,OAAXR,EAAEC,QAAgB,CAAE1hB,MAAOiiB,EAAG,GAAIZ,MAAM,GAChD,KAAK,EAAGI,EAAEC,QAASzU,EAAIgV,EAAG,GAAIA,EAAK,CAAC,GAAI,SACxC,KAAK,EAAGA,EAAKR,EAAEI,IAAIK,MAAOT,EAAEG,KAAKM,MAAO,SACxC,QACI,KAAMxC,EAAI+B,EAAEG,MAAMlC,EAAIA,EAAEjb,OAAS,GAAKib,EAAEA,EAAEjb,OAAS,KAAkB,IAAVwd,EAAG,IAAsB,IAAVA,EAAG,IAAW,CAAER,EAAI,EAAG,SACjG,GAAc,IAAVQ,EAAG,MAAcvC,GAAMuC,EAAG,GAAKvC,EAAE,IAAMuC,EAAG,GAAKvC,EAAE,IAAM,CAAE+B,EAAEC,MAAQO,EAAG,GAAI,MAC9E,GAAc,IAAVA,EAAG,IAAYR,EAAEC,MAAQhC,EAAE,GAAI,CAAE+B,EAAEC,MAAQhC,EAAE,GAAIA,EAAIuC,EAAI,MAC7D,GAAIvC,GAAK+B,EAAEC,MAAQhC,EAAE,GAAI,CAAE+B,EAAEC,MAAQhC,EAAE,GAAI+B,EAAEI,IAAIjgB,KAAKqgB,GAAK,MACvDvC,EAAE,IAAI+B,EAAEI,IAAIK,MAChBT,EAAEG,KAAKM,MAAO,SAEtBD,EAAKV,EAAKjc,KAAKmb,EAASgB,GAC1B,MAAOhF,GAAKwF,EAAK,CAAC,EAAGxF,GAAIxP,EAAI,EAAK,QAAUuU,EAAI9B,EAAI,EACtD,GAAY,EAARuC,EAAG,GAAQ,MAAMA,EAAG,GAAI,MAAO,CAAEjiB,MAAOiiB,EAAG,GAAKA,EAAG,QAAK,EAAQZ,MAAM,GArB9BJ,CAAK,CAACrB,EAAG7gB,OAyB7D2e,EAAe,SAASf,EAAGwF,GACvB,IAAK,IAAIrf,KAAK6Z,EAAa,YAAN7Z,GAAoBV,OAAOgD,UAAUC,eAAeC,KAAK6c,EAAGrf,IAAI0b,EAAgB2D,EAAGxF,EAAG7Z,IAG/G0b,EAAkBpc,OAAO2c,OAAS,SAAUoD,EAAGxF,EAAGyF,EAAGC,QACtCxc,IAAPwc,IAAkBA,EAAKD,GAC3BhgB,OAAOC,eAAe8f,EAAGE,EAAI,CAAEC,YAAY,EAAMpiB,IAAK,WAAa,OAAOyc,EAAEyF,OAC3E,SAAUD,EAAGxF,EAAGyF,EAAGC,QACTxc,IAAPwc,IAAkBA,EAAKD,GAC3BD,EAAEE,GAAM1F,EAAEyF,IAGdzE,EAAW,SAAUwE,GACjB,IAAIxC,EAAsB,mBAAXoC,QAAyBA,OAAOC,SAAUrF,EAAIgD,GAAKwC,EAAExC,GAAIhY,EAAI,EAC5E,GAAIgV,EAAG,OAAOA,EAAErX,KAAK6c,GACrB,GAAIA,GAAyB,iBAAbA,EAAE1d,OAAqB,MAAO,CAC1Cyc,KAAM,WAEF,OADIiB,GAAKxa,GAAKwa,EAAE1d,SAAQ0d,OAAI,GACrB,CAAEniB,MAAOmiB,GAAKA,EAAExa,KAAM0Z,MAAOc,KAG5C,MAAM,IAAI7C,UAAUK,EAAI,0BAA4B,oCAGxDlK,EAAS,SAAU0M,EAAGvC,GAClB,IAAIjD,EAAsB,mBAAXoF,QAAyBI,EAAEJ,OAAOC,UACjD,IAAKrF,EAAG,OAAOwF,EACf,IAAmBxb,EAAY8V,EAA3B9U,EAAIgV,EAAErX,KAAK6c,GAAOI,EAAK,GAC3B,IACI,WAAc,IAAN3C,GAAgBA,KAAM,MAAQjZ,EAAIgB,EAAEuZ,QAAQG,MAAMkB,EAAG3gB,KAAK+E,EAAE3G,OAExE,MAAOwiB,GAAS/F,EAAI,CAAE+F,MAAOA,GAC7B,QACI,IACQ7b,IAAMA,EAAE0a,OAAS1E,EAAIhV,EAAU,SAAIgV,EAAErX,KAAKqC,GAElD,QAAU,GAAI8U,EAAG,MAAMA,EAAE+F,OAE7B,OAAOD,GAIX3E,EAAW,WACP,IAAK,IAAI2E,EAAK,GAAI5a,EAAI,EAAGA,EAAI+P,UAAUjT,OAAQkD,IAC3C4a,EAAKA,EAAGpV,OAAOsI,EAAOiC,UAAU/P,KACpC,OAAO4a,GAIX1E,EAAiB,WACb,IAAK,IAAI8B,EAAI,EAAGhY,EAAI,EAAG8a,EAAK/K,UAAUjT,OAAQkD,EAAI8a,EAAI9a,IAAKgY,GAAKjI,UAAU/P,GAAGlD,OACxE,IAAIkC,EAAI3H,MAAM2gB,GAAIyC,EAAI,EAA3B,IAA8Bza,EAAI,EAAGA,EAAI8a,EAAI9a,IACzC,IAAK,IAAIrG,EAAIoW,UAAU/P,GAAI+a,EAAI,EAAGC,EAAKrhB,EAAEmD,OAAQie,EAAIC,EAAID,IAAKN,IAC1Dzb,EAAEyb,GAAK9gB,EAAEohB,GACjB,OAAO/b,GAGXmX,EAAgB,SAAU8E,EAAIC,EAAMC,GAChC,GAAIA,GAA6B,IAArBpL,UAAUjT,OAAc,IAAK,IAA4B8d,EAAxB5a,EAAI,EAAGob,EAAIF,EAAKpe,OAAYkD,EAAIob,EAAGpb,KACxE4a,GAAQ5a,KAAKkb,IACRN,IAAIA,EAAKvjB,MAAMoG,UAAUoD,MAAMlD,KAAKud,EAAM,EAAGlb,IAClD4a,EAAG5a,GAAKkb,EAAKlb,IAGrB,OAAOib,EAAGzV,OAAOoV,GAAMM,IAG3B9E,EAAU,SAAUhf,GAChB,OAAO0Y,gBAAgBsG,GAAWtG,KAAK1Y,EAAIA,EAAG0Y,MAAQ,IAAIsG,EAAQhf,IAGtEif,EAAmB,SAAUyC,EAASC,EAAYE,GAC9C,IAAKmB,OAAOiB,cAAe,MAAM,IAAI1D,UAAU,wCAC/C,IAAoD3X,EAAhDf,EAAIga,EAAUpJ,MAAMiJ,EAASC,GAAc,IAAQuC,EAAI,GAC3D,OAAOtb,EAAI,GAAIma,EAAK,QAASA,EAAK,SAAUA,EAAK,UAAWna,EAAEoa,OAAOiB,eAAiB,WAAc,OAAOvL,MAAS9P,EACpH,SAASma,EAAKlC,GAAShZ,EAAEgZ,KAAIjY,EAAEiY,GAAK,SAAU7gB,GAAK,OAAO,IAAI8hB,SAAQ,SAAUvf,EAAGC,GAAK0hB,EAAErhB,KAAK,CAACge,EAAG7gB,EAAGuC,EAAGC,IAAM,GAAK2hB,EAAOtD,EAAG7gB,QAC9H,SAASmkB,EAAOtD,EAAG7gB,GAAK,KACV4H,EADqBC,EAAEgZ,GAAG7gB,IACnBiB,iBAAiB+d,EAAU8C,QAAQC,QAAQna,EAAE3G,MAAMjB,GAAGuiB,KAAK6B,EAASpC,GAAUqC,EAAOH,EAAE,GAAG,GAAItc,GADpE,MAAO8V,GAAK2G,EAAOH,EAAE,GAAG,GAAIxG,GAC3E,IAAc9V,EACd,SAASwc,EAAQnjB,GAASkjB,EAAO,OAAQljB,GACzC,SAAS+gB,EAAO/gB,GAASkjB,EAAO,QAASljB,GACzC,SAASojB,EAAO5B,EAAGziB,GAASyiB,EAAEziB,GAAIkkB,EAAEI,QAASJ,EAAExe,QAAQye,EAAOD,EAAE,GAAG,GAAIA,EAAE,GAAG,MAGhFhF,EAAmB,SAAUkE,GACzB,IAAIxa,EAAG7E,EACP,OAAO6E,EAAI,GAAIma,EAAK,QAASA,EAAK,SAAS,SAAUrF,GAAK,MAAMA,KAAOqF,EAAK,UAAWna,EAAEoa,OAAOC,UAAY,WAAc,OAAOvK,MAAS9P,EAC1I,SAASma,EAAKlC,EAAG4B,GAAK7Z,EAAEiY,GAAKuC,EAAEvC,GAAK,SAAU7gB,GAAK,OAAQ+D,GAAKA,GAAK,CAAE9C,MAAO+d,EAAQoE,EAAEvC,GAAG7gB,IAAKsiB,KAAY,WAANzB,GAAmB4B,EAAIA,EAAEziB,GAAKA,GAAOyiB,IAG/ItD,EAAgB,SAAUiE,GACtB,IAAKJ,OAAOiB,cAAe,MAAM,IAAI1D,UAAU,wCAC/C,IAAiC3X,EAA7BgV,EAAIwF,EAAEJ,OAAOiB,eACjB,OAAOrG,EAAIA,EAAErX,KAAK6c,IAAMA,EAAqCxE,EAASwE,GAA2Bxa,EAAI,GAAIma,EAAK,QAASA,EAAK,SAAUA,EAAK,UAAWna,EAAEoa,OAAOiB,eAAiB,WAAc,OAAOvL,MAAS9P,GAC9M,SAASma,EAAKlC,GAAKjY,EAAEiY,GAAKuC,EAAEvC,IAAM,SAAU7gB,GAAK,OAAO,IAAI8hB,SAAQ,SAAUC,EAASC,IACvF,SAAgBD,EAASC,EAAQ1B,EAAGtgB,GAAK8hB,QAAQC,QAAQ/hB,GAAGuiB,MAAK,SAASviB,GAAK+hB,EAAQ,CAAE9gB,MAAOjB,EAAGsiB,KAAMhC,MAAS0B,IADJqC,CAAOtC,EAASC,GAA7BhiB,EAAIojB,EAAEvC,GAAG7gB,IAA8BsiB,KAAMtiB,EAAEiB,aAIpJme,EAAuB,SAAUmF,EAAQC,GAErC,OADInhB,OAAOC,eAAkBD,OAAOC,eAAeihB,EAAQ,MAAO,CAAEtjB,MAAOujB,IAAiBD,EAAOC,IAAMA,EAClGD,GAGX,IAAIE,EAAqBphB,OAAO2c,OAAS,SAAUoD,EAAGpjB,GAClDqD,OAAOC,eAAe8f,EAAG,UAAW,CAAEG,YAAY,EAAMtiB,MAAOjB,KAC9D,SAASojB,EAAGpjB,GACbojB,EAAW,QAAIpjB,GAGnBqf,EAAe,SAAUqF,GACrB,GAAIA,GAAOA,EAAIzE,WAAY,OAAOyE,EAClC,IAAIrC,EAAS,GACb,GAAW,MAAPqC,EAAa,IAAK,IAAIrB,KAAKqB,EAAe,YAANrB,GAAmBhgB,OAAOgD,UAAUC,eAAeC,KAAKme,EAAKrB,IAAI5D,EAAgB4C,EAAQqC,EAAKrB,GAEtI,OADAoB,EAAmBpC,EAAQqC,GACpBrC,GAGX/C,EAAkB,SAAUoF,GACxB,OAAQA,GAAOA,EAAIzE,WAAcyE,EAAM,CAAE,QAAWA,IAGxDnF,EAAyB,SAAUoF,EAAU7X,EAAO8X,EAAMnC,GACtD,GAAa,MAATmC,IAAiBnC,EAAG,MAAM,IAAIlC,UAAU,iDAC5C,GAAqB,mBAAVzT,EAAuB6X,IAAa7X,IAAU2V,GAAK3V,EAAM7J,IAAI0hB,GAAW,MAAM,IAAIpE,UAAU,4EACvG,MAAgB,MAATqE,EAAenC,EAAa,MAATmC,EAAenC,EAAElc,KAAKoe,GAAYlC,EAAIA,EAAExhB,MAAQ6L,EAAM3L,IAAIwjB,IAGxFnF,EAAyB,SAAUmF,EAAU7X,EAAO7L,EAAO2jB,EAAMnC,GAC7D,GAAa,MAATmC,EAAc,MAAM,IAAIrE,UAAU,kCACtC,GAAa,MAATqE,IAAiBnC,EAAG,MAAM,IAAIlC,UAAU,iDAC5C,GAAqB,mBAAVzT,EAAuB6X,IAAa7X,IAAU2V,GAAK3V,EAAM7J,IAAI0hB,GAAW,MAAM,IAAIpE,UAAU,2EACvG,MAAiB,MAATqE,EAAenC,EAAElc,KAAKoe,EAAU1jB,GAASwhB,EAAIA,EAAExhB,MAAQA,EAAQ6L,EAAMqR,IAAIwG,EAAU1jB,GAASA,GAGxGif,EAAS,YAAatH,GACtBsH,EAAS,WAAY3N,GACrB2N,EAAS,SAAUzS,GACnByS,EAAS,aAAc5B,GACvB4B,EAAS,UAAW3B,GACpB2B,EAAS,aAAc1B,GACvB0B,EAAS,YAAazB,GACtByB,EAAS,cAAexB,GACxBwB,EAAS,eAAgBvB,GACzBuB,EAAS,kBAAmBT,GAC5BS,EAAS,WAAYtB,GACrBsB,EAAS,SAAUxJ,GACnBwJ,EAAS,WAAYrB,GACrBqB,EAAS,iBAAkBpB,GAC3BoB,EAAS,gBAAiBnB,GAC1BmB,EAAS,UAAWlB,GACpBkB,EAAS,mBAAoBjB,GAC7BiB,EAAS,mBAAoBhB,GAC7BgB,EAAS,gBAAiBf,GAC1Be,EAAS,uBAAwBd,GACjCc,EAAS,eAAgBb,GACzBa,EAAS,kBAAmBZ,GAC5BY,EAAS,yBAA0BX,GACnCW,EAAS,yBAA0BV,GAtQmBE,CAAQI,EAAeH,EAAMG,EAAevc,MAAa,QAA3F,CAAC,OAA0F,aAHnH,K,kDCvCA,6CASA,SAASuW,EAAY+K,GACjB,IAAIzZ,EAAMkM,iBAAO,MAIjB,OAHoB,OAAhBlM,EAAIrK,UACJqK,EAAIrK,QAAU8jB,KAEXzZ,EAAIrK,U,gCCdf,6CAGI4W,EAHJ,OAGgC5N,EAAY+a,kBAAkBjN","file":"3-70578dc76ff59ffade67.js","sourcesContent":["/**\n * Decides if the supplied variable is an array of variant labels\n */\nfunction isVariantLabels(v) {\n    return Array.isArray(v);\n}\n/**\n * Decides if the supplied variable is variant label\n */\nfunction isVariantLabel(v) {\n    return typeof v === \"string\" || isVariantLabels(v);\n}\n/**\n * Creates an object containing the latest state of every MotionValue on a VisualElement\n */\nfunction getCurrent(visualElement) {\n    var current = {};\n    visualElement.forEachValue(function (value, key) { return (current[key] = value.get()); });\n    return current;\n}\n/**\n * Creates an object containing the latest velocity of every MotionValue on a VisualElement\n */\nfunction getVelocity(visualElement) {\n    var velocity = {};\n    visualElement.forEachValue(function (value, key) { return (velocity[key] = value.getVelocity()); });\n    return velocity;\n}\nfunction resolveVariantFromProps(props, definition, custom, currentValues, currentVelocity) {\n    var _a;\n    if (currentValues === void 0) { currentValues = {}; }\n    if (currentVelocity === void 0) { currentVelocity = {}; }\n    /**\n     * If the variant definition is a function, resolve.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    /**\n     * If the variant definition is a variant label, or\n     * the function returned a variant label, resolve.\n     */\n    if (typeof definition === \"string\") {\n        definition = (_a = props.variants) === null || _a === void 0 ? void 0 : _a[definition];\n    }\n    /**\n     * At this point we've resolved both functions and variant labels,\n     * but the resolved variant label might itself have been a function.\n     * If so, resolve. This can only have returned a valid target object.\n     */\n    if (typeof definition === \"function\") {\n        definition = definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity);\n    }\n    return definition;\n}\nfunction resolveVariant(visualElement, definition, custom) {\n    var props = visualElement.getProps();\n    return resolveVariantFromProps(props, definition, custom !== null && custom !== void 0 ? custom : props.custom, getCurrent(visualElement), getVelocity(visualElement));\n}\nfunction checkIfControllingVariants(props) {\n    var _a;\n    return (typeof ((_a = props.animate) === null || _a === void 0 ? void 0 : _a.start) === \"function\" ||\n        isVariantLabel(props.initial) ||\n        isVariantLabel(props.animate) ||\n        isVariantLabel(props.whileHover) ||\n        isVariantLabel(props.whileDrag) ||\n        isVariantLabel(props.whileTap) ||\n        isVariantLabel(props.whileFocus) ||\n        isVariantLabel(props.exit));\n}\nfunction checkIfVariantNode(props) {\n    return Boolean(checkIfControllingVariants(props) || props.variants);\n}\n\nexport { checkIfControllingVariants, checkIfVariantNode, isVariantLabel, isVariantLabels, resolveVariant, resolveVariantFromProps };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nvar PresenceContext = createContext(null);\n\nexport { PresenceContext };\n","/**\n * A list of all transformable axes. We'll use this list to generated a version\n * of each axes for each transform.\n */\nvar transformAxes = [\"\", \"X\", \"Y\", \"Z\"];\n/**\n * An ordered array of each transformable value. By default, transform values\n * will be sorted to this order.\n */\nvar order = [\"translate\", \"scale\", \"rotate\", \"skew\"];\n/**\n * Generate a list of every possible transform key.\n */\nvar transformProps = [\"transformPerspective\", \"x\", \"y\", \"z\"];\norder.forEach(function (operationKey) {\n    return transformAxes.forEach(function (axesKey) {\n        return transformProps.push(operationKey + axesKey);\n    });\n});\n/**\n * A function to use with Array.sort to sort transform keys by their default order.\n */\nfunction sortTransformProps(a, b) {\n    return transformProps.indexOf(a) - transformProps.indexOf(b);\n}\n/**\n * A quick lookup for transform props.\n */\nvar transformPropSet = new Set(transformProps);\nfunction isTransformProp(key) {\n    return transformPropSet.has(key);\n}\n/**\n * A quick lookup for transform origin props\n */\nvar transformOriginProps = new Set([\"originX\", \"originY\", \"originZ\"]);\nfunction isTransformOriginProp(key) {\n    return transformOriginProps.has(key);\n}\n\nexport { isTransformOriginProp, isTransformProp, sortTransformProps, transformAxes, transformProps };\n","var isMotionValue = function (value) {\n    return Boolean(value !== null && typeof value === \"object\" && value.getVelocity);\n};\n\nexport { isMotionValue };\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nexports.warning = function () { };\r\nexports.invariant = function () { };\r\nif (process.env.NODE_ENV !== 'production') {\r\n    exports.warning = function (check, message) {\r\n        if (!check && typeof console !== 'undefined') {\r\n            console.warn(message);\r\n        }\r\n    };\r\n    exports.invariant = function (check, message) {\r\n        if (!check) {\r\n            throw new Error(message);\r\n        }\r\n    };\r\n}\n","import { createContext } from 'react';\n\nvar LayoutGroupContext = createContext({});\n\nexport { LayoutGroupContext };\n","/**\n * Browser-safe usage of process\n */\nvar defaultEnvironment = \"production\";\nvar env = typeof process === \"undefined\" || process.env === undefined\n    ? defaultEnvironment\n    : process.env.NODE_ENV || defaultEnvironment;\n\nexport { env };\n","import { createContext } from 'react';\n\n/**\n * @public\n */\nvar MotionConfigContext = createContext({\n    transformPagePoint: function (p) { return p; },\n    isStatic: false,\n    reducedMotion: \"never\",\n});\n\nexport { MotionConfigContext };\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nconst clamp = (min, max) => (v) => Math.max(Math.min(v, max), min);\nconst sanitize = (v) => (v % 1 ? Number(v.toFixed(5)) : v);\nconst floatRegex = /(-)?([\\d]*\\.?[\\d])+/g;\nconst colorRegex = /(#[0-9a-f]{6}|#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2,3}\\s*\\/*\\s*[\\d\\.]+%?\\))/gi;\nconst singleColorRegex = /^(#[0-9a-f]{3}|#(?:[0-9a-f]{2}){2,4}|(rgb|hsl)a?\\((-?[\\d\\.]+%?[,\\s]+){2,3}\\s*\\/*\\s*[\\d\\.]+%?\\))$/i;\nfunction isString(v) {\n    return typeof v === 'string';\n}\n\nconst number = {\n    test: (v) => typeof v === 'number',\n    parse: parseFloat,\n    transform: (v) => v,\n};\nconst alpha = Object.assign(Object.assign({}, number), { transform: clamp(0, 1) });\nconst scale = Object.assign(Object.assign({}, number), { default: 1 });\n\nconst createUnitType = (unit) => ({\n    test: (v) => isString(v) && v.endsWith(unit) && v.split(' ').length === 1,\n    parse: parseFloat,\n    transform: (v) => `${v}${unit}`,\n});\nconst degrees = createUnitType('deg');\nconst percent = createUnitType('%');\nconst px = createUnitType('px');\nconst vh = createUnitType('vh');\nconst vw = createUnitType('vw');\nconst progressPercentage = Object.assign(Object.assign({}, percent), { parse: (v) => percent.parse(v) / 100, transform: (v) => percent.transform(v * 100) });\n\nconst isColorString = (type, testProp) => (v) => {\n    return Boolean((isString(v) && singleColorRegex.test(v) && v.startsWith(type)) ||\n        (testProp && Object.prototype.hasOwnProperty.call(v, testProp)));\n};\nconst splitColor = (aName, bName, cName) => (v) => {\n    if (!isString(v))\n        return v;\n    const [a, b, c, alpha] = v.match(floatRegex);\n    return {\n        [aName]: parseFloat(a),\n        [bName]: parseFloat(b),\n        [cName]: parseFloat(c),\n        alpha: alpha !== undefined ? parseFloat(alpha) : 1,\n    };\n};\n\nconst hsla = {\n    test: isColorString('hsl', 'hue'),\n    parse: splitColor('hue', 'saturation', 'lightness'),\n    transform: ({ hue, saturation, lightness, alpha: alpha$1 = 1 }) => {\n        return ('hsla(' +\n            Math.round(hue) +\n            ', ' +\n            percent.transform(sanitize(saturation)) +\n            ', ' +\n            percent.transform(sanitize(lightness)) +\n            ', ' +\n            sanitize(alpha.transform(alpha$1)) +\n            ')');\n    },\n};\n\nconst clampRgbUnit = clamp(0, 255);\nconst rgbUnit = Object.assign(Object.assign({}, number), { transform: (v) => Math.round(clampRgbUnit(v)) });\nconst rgba = {\n    test: isColorString('rgb', 'red'),\n    parse: splitColor('red', 'green', 'blue'),\n    transform: ({ red, green, blue, alpha: alpha$1 = 1 }) => 'rgba(' +\n        rgbUnit.transform(red) +\n        ', ' +\n        rgbUnit.transform(green) +\n        ', ' +\n        rgbUnit.transform(blue) +\n        ', ' +\n        sanitize(alpha.transform(alpha$1)) +\n        ')',\n};\n\nfunction parseHex(v) {\n    let r = '';\n    let g = '';\n    let b = '';\n    let a = '';\n    if (v.length > 5) {\n        r = v.substr(1, 2);\n        g = v.substr(3, 2);\n        b = v.substr(5, 2);\n        a = v.substr(7, 2);\n    }\n    else {\n        r = v.substr(1, 1);\n        g = v.substr(2, 1);\n        b = v.substr(3, 1);\n        a = v.substr(4, 1);\n        r += r;\n        g += g;\n        b += b;\n        a += a;\n    }\n    return {\n        red: parseInt(r, 16),\n        green: parseInt(g, 16),\n        blue: parseInt(b, 16),\n        alpha: a ? parseInt(a, 16) / 255 : 1,\n    };\n}\nconst hex = {\n    test: isColorString('#'),\n    parse: parseHex,\n    transform: rgba.transform,\n};\n\nconst color = {\n    test: (v) => rgba.test(v) || hex.test(v) || hsla.test(v),\n    parse: (v) => {\n        if (rgba.test(v)) {\n            return rgba.parse(v);\n        }\n        else if (hsla.test(v)) {\n            return hsla.parse(v);\n        }\n        else {\n            return hex.parse(v);\n        }\n    },\n    transform: (v) => {\n        return isString(v)\n            ? v\n            : v.hasOwnProperty('red')\n                ? rgba.transform(v)\n                : hsla.transform(v);\n    },\n};\n\nconst colorToken = '${c}';\nconst numberToken = '${n}';\nfunction test(v) {\n    var _a, _b, _c, _d;\n    return (isNaN(v) &&\n        isString(v) &&\n        ((_b = (_a = v.match(floatRegex)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) + ((_d = (_c = v.match(colorRegex)) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0) > 0);\n}\nfunction analyse(v) {\n    if (typeof v === 'number')\n        v = `${v}`;\n    const values = [];\n    let numColors = 0;\n    const colors = v.match(colorRegex);\n    if (colors) {\n        numColors = colors.length;\n        v = v.replace(colorRegex, colorToken);\n        values.push(...colors.map(color.parse));\n    }\n    const numbers = v.match(floatRegex);\n    if (numbers) {\n        v = v.replace(floatRegex, numberToken);\n        values.push(...numbers.map(number.parse));\n    }\n    return { values, numColors, tokenised: v };\n}\nfunction parse(v) {\n    return analyse(v).values;\n}\nfunction createTransformer(v) {\n    const { values, numColors, tokenised } = analyse(v);\n    const numValues = values.length;\n    return (v) => {\n        let output = tokenised;\n        for (let i = 0; i < numValues; i++) {\n            output = output.replace(i < numColors ? colorToken : numberToken, i < numColors ? color.transform(v[i]) : sanitize(v[i]));\n        }\n        return output;\n    };\n}\nconst convertNumbersToZero = (v) => typeof v === 'number' ? 0 : v;\nfunction getAnimatableNone(v) {\n    const parsed = parse(v);\n    const transformer = createTransformer(v);\n    return transformer(parsed.map(convertNumbersToZero));\n}\nconst complex = { test, parse, createTransformer, getAnimatableNone };\n\nconst maxDefaults = new Set(['brightness', 'contrast', 'saturate', 'opacity']);\nfunction applyDefaultFilter(v) {\n    let [name, value] = v.slice(0, -1).split('(');\n    if (name === 'drop-shadow')\n        return v;\n    const [number] = value.match(floatRegex) || [];\n    if (!number)\n        return v;\n    const unit = value.replace(number, '');\n    let defaultValue = maxDefaults.has(name) ? 1 : 0;\n    if (number !== value)\n        defaultValue *= 100;\n    return name + '(' + defaultValue + unit + ')';\n}\nconst functionRegex = /([a-z-]*)\\(.*?\\)/g;\nconst filter = Object.assign(Object.assign({}, complex), { getAnimatableNone: (v) => {\n        const functions = v.match(functionRegex);\n        return functions ? functions.map(applyDefaultFilter).join(' ') : v;\n    } });\n\nexports.alpha = alpha;\nexports.color = color;\nexports.complex = complex;\nexports.degrees = degrees;\nexports.filter = filter;\nexports.hex = hex;\nexports.hsla = hsla;\nexports.number = number;\nexports.percent = percent;\nexports.progressPercentage = progressPercentage;\nexports.px = px;\nexports.rgbUnit = rgbUnit;\nexports.rgba = rgba;\nexports.scale = scale;\nexports.vh = vh;\nexports.vw = vw;\n","var isBrowser = typeof document !== \"undefined\";\n\nexport { isBrowser };\n","var isKeyframesTarget = function (v) {\n    return Array.isArray(v);\n};\n\nexport { isKeyframesTarget };\n","var createDefinition = function (propNames) { return ({\n    isEnabled: function (props) { return propNames.some(function (name) { return !!props[name]; }); },\n}); };\nvar featureDefinitions = {\n    measureLayout: createDefinition([\"layout\", \"layoutId\", \"drag\"]),\n    animation: createDefinition([\n        \"animate\",\n        \"exit\",\n        \"variants\",\n        \"whileHover\",\n        \"whileTap\",\n        \"whileFocus\",\n        \"whileDrag\",\n        \"whileInView\",\n    ]),\n    exit: createDefinition([\"exit\"]),\n    drag: createDefinition([\"drag\", \"dragControls\"]),\n    focus: createDefinition([\"whileFocus\"]),\n    hover: createDefinition([\"whileHover\", \"onHoverStart\", \"onHoverEnd\"]),\n    tap: createDefinition([\"whileTap\", \"onTap\", \"onTapStart\", \"onTapCancel\"]),\n    pan: createDefinition([\n        \"onPan\",\n        \"onPanStart\",\n        \"onPanSessionStart\",\n        \"onPanEnd\",\n    ]),\n    inView: createDefinition([\n        \"whileInView\",\n        \"onViewportEnter\",\n        \"onViewportLeave\",\n    ]),\n};\nfunction loadFeatures(features) {\n    for (var key in features) {\n        if (features[key] === null)\n            continue;\n        if (key === \"projectionNodeConstructor\") {\n            featureDefinitions.projectionNodeConstructor = features[key];\n        }\n        else {\n            featureDefinitions[key].Component = features[key];\n        }\n    }\n}\n\nexport { featureDefinitions, loadFeatures };\n","function isRefObject(ref) {\n    return (typeof ref === \"object\" &&\n        Object.prototype.hasOwnProperty.call(ref, \"current\"));\n}\n\nexport { isRefObject };\n","/**\n * This should only ever be modified on the client otherwise it'll\n * persist through server requests. If we need instanced states we\n * could lazy-init via root.\n */\nvar globalProjectionState = {\n    /**\n     * Global flag as to whether the tree has animated since the last time\n     * we resized the window\n     */\n    hasAnimatedSinceResize: true,\n    /**\n     * We set this to true once, on the first update. Any nodes added to the tree beyond that\n     * update will be given a `data-projection-id` attribute.\n     */\n    hasEverUpdated: false,\n};\n\nexport { globalProjectionState };\n","var scaleCorrectors = {};\nfunction addScaleCorrector(correctors) {\n    Object.assign(scaleCorrectors, correctors);\n}\n\nexport { addScaleCorrector, scaleCorrectors };\n","import { createContext } from 'react';\n\nvar LazyContext = createContext({ strict: false });\n\nexport { LazyContext };\n","import { isKeyframesTarget } from '../animation/utils/is-keyframes-target.mjs';\n\nvar isCustomValue = function (v) {\n    return Boolean(v && typeof v === \"object\" && v.mix && v.toValue);\n};\nvar resolveFinalValueInKeyframes = function (v) {\n    // TODO maybe throw if v.length - 1 is placeholder token?\n    return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;\n};\n\nexport { isCustomValue, resolveFinalValueInKeyframes };\n","function isAnimationControls(v) {\n    return typeof v === \"object\" && typeof v.start === \"function\";\n}\n\nexport { isAnimationControls };\n","import { isForcedMotionValue } from '../../../motion/utils/is-forced-motion-value.mjs';\nimport { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\n\nfunction scrapeMotionValuesFromProps(props) {\n    var style = props.style;\n    var newValues = {};\n    for (var key in style) {\n        if (isMotionValue(style[key]) || isForcedMotionValue(key, props)) {\n            newValues[key] = style[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","import { px } from 'style-value-types';\n\nfunction calcOrigin(origin, offset, size) {\n    return typeof origin === \"string\"\n        ? origin\n        : px.transform(offset + size * origin);\n}\n/**\n * The SVG transform origin defaults are different to CSS and is less intuitive,\n * so we use the measured dimensions of the SVG to reconcile these.\n */\nfunction calcSVGTransformOrigin(dimensions, originX, originY) {\n    var pxOriginX = calcOrigin(originX, dimensions.x, dimensions.width);\n    var pxOriginY = calcOrigin(originY, dimensions.y, dimensions.height);\n    return \"\".concat(pxOriginX, \" \").concat(pxOriginY);\n}\n\nexport { calcSVGTransformOrigin };\n","import { px } from 'style-value-types';\n\nvar dashKeys = {\n    offset: \"stroke-dashoffset\",\n    array: \"stroke-dasharray\",\n};\nvar camelKeys = {\n    offset: \"strokeDashoffset\",\n    array: \"strokeDasharray\",\n};\n/**\n * Build SVG path properties. Uses the path's measured length to convert\n * our custom pathLength, pathSpacing and pathOffset into stroke-dashoffset\n * and stroke-dasharray attributes.\n *\n * This function is mutative to reduce per-frame GC.\n */\nfunction buildSVGPath(attrs, length, spacing, offset, useDashCase) {\n    if (spacing === void 0) { spacing = 1; }\n    if (offset === void 0) { offset = 0; }\n    if (useDashCase === void 0) { useDashCase = true; }\n    // Normalise path length by setting SVG attribute pathLength to 1\n    attrs.pathLength = 1;\n    // We use dash case when setting attributes directly to the DOM node and camel case\n    // when defining props on a React component.\n    var keys = useDashCase ? dashKeys : camelKeys;\n    // Build the dash offset\n    attrs[keys.offset] = px.transform(-offset);\n    // Build the dash array\n    var pathLength = px.transform(length);\n    var pathSpacing = px.transform(spacing);\n    attrs[keys.array] = \"\".concat(pathLength, \" \").concat(pathSpacing);\n}\n\nexport { buildSVGPath };\n","import { __rest } from 'tslib';\nimport { buildHTMLStyles } from '../../html/utils/build-styles.mjs';\nimport { calcSVGTransformOrigin } from './transform-origin.mjs';\nimport { buildSVGPath } from './path.mjs';\n\n/**\n * Build SVG visual attrbutes, like cx and style.transform\n */\nfunction buildSVGAttrs(state, _a, options, transformTemplate) {\n    var attrX = _a.attrX, attrY = _a.attrY, originX = _a.originX, originY = _a.originY, pathLength = _a.pathLength, _b = _a.pathSpacing, pathSpacing = _b === void 0 ? 1 : _b, _c = _a.pathOffset, pathOffset = _c === void 0 ? 0 : _c, \n    // This is object creation, which we try to avoid per-frame.\n    latest = __rest(_a, [\"attrX\", \"attrY\", \"originX\", \"originY\", \"pathLength\", \"pathSpacing\", \"pathOffset\"]);\n    buildHTMLStyles(state, latest, options, transformTemplate);\n    state.attrs = state.style;\n    state.style = {};\n    var attrs = state.attrs, style = state.style, dimensions = state.dimensions;\n    /**\n     * However, we apply transforms as CSS transforms. So if we detect a transform we take it from attrs\n     * and copy it into style.\n     */\n    if (attrs.transform) {\n        if (dimensions)\n            style.transform = attrs.transform;\n        delete attrs.transform;\n    }\n    // Parse transformOrigin\n    if (dimensions &&\n        (originX !== undefined || originY !== undefined || style.transform)) {\n        style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== undefined ? originX : 0.5, originY !== undefined ? originY : 0.5);\n    }\n    // Treat x/y not as shortcuts but as actual attributes\n    if (attrX !== undefined)\n        attrs.x = attrX;\n    if (attrY !== undefined)\n        attrs.y = attrY;\n    // Build SVG path if one has been defined\n    if (pathLength !== undefined) {\n        buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);\n    }\n}\n\nexport { buildSVGAttrs };\n","import { sortTransformProps } from './transform.mjs';\n\nvar translateAlias = {\n    x: \"translateX\",\n    y: \"translateY\",\n    z: \"translateZ\",\n    transformPerspective: \"perspective\",\n};\n/**\n * Build a CSS transform style from individual x/y/scale etc properties.\n *\n * This outputs with a default order of transforms/scales/rotations, this can be customised by\n * providing a transformTemplate function.\n */\nfunction buildTransform(_a, _b, transformIsDefault, transformTemplate) {\n    var transform = _a.transform, transformKeys = _a.transformKeys;\n    var _c = _b.enableHardwareAcceleration, enableHardwareAcceleration = _c === void 0 ? true : _c, _d = _b.allowTransformNone, allowTransformNone = _d === void 0 ? true : _d;\n    // The transform string we're going to build into.\n    var transformString = \"\";\n    // Transform keys into their default order - this will determine the output order.\n    transformKeys.sort(sortTransformProps);\n    // Track whether the defined transform has a defined z so we don't add a\n    // second to enable hardware acceleration\n    var transformHasZ = false;\n    // Loop over each transform and build them into transformString\n    var numTransformKeys = transformKeys.length;\n    for (var i = 0; i < numTransformKeys; i++) {\n        var key = transformKeys[i];\n        transformString += \"\".concat(translateAlias[key] || key, \"(\").concat(transform[key], \") \");\n        if (key === \"z\")\n            transformHasZ = true;\n    }\n    if (!transformHasZ && enableHardwareAcceleration) {\n        transformString += \"translateZ(0)\";\n    }\n    else {\n        transformString = transformString.trim();\n    }\n    // If we have a custom `transform` template, pass our transform values and\n    // generated transformString to that before returning\n    if (transformTemplate) {\n        transformString = transformTemplate(transform, transformIsDefault ? \"\" : transformString);\n    }\n    else if (allowTransformNone && transformIsDefault) {\n        transformString = \"none\";\n    }\n    return transformString;\n}\n/**\n * Build a transformOrigin style. Uses the same defaults as the browser for\n * undefined origins.\n */\nfunction buildTransformOrigin(_a) {\n    var _b = _a.originX, originX = _b === void 0 ? \"50%\" : _b, _c = _a.originY, originY = _c === void 0 ? \"50%\" : _c, _d = _a.originZ, originZ = _d === void 0 ? 0 : _d;\n    return \"\".concat(originX, \" \").concat(originY, \" \").concat(originZ);\n}\n\nexport { buildTransform, buildTransformOrigin };\n","/**\n * Provided a value and a ValueType, returns the value as that value type.\n */\nvar getValueAsType = function (value, type) {\n    return type && typeof value === \"number\"\n        ? type.transform(value)\n        : value;\n};\n\nexport { getValueAsType };\n","import { buildTransform, buildTransformOrigin } from './build-transform.mjs';\nimport { isCSSVariable } from '../../dom/utils/is-css-variable.mjs';\nimport { isTransformProp, isTransformOriginProp } from './transform.mjs';\nimport { getValueAsType } from '../../dom/value-types/get-as-type.mjs';\nimport { numberValueTypes } from '../../dom/value-types/number.mjs';\n\nfunction buildHTMLStyles(state, latestValues, options, transformTemplate) {\n    var _a;\n    var style = state.style, vars = state.vars, transform = state.transform, transformKeys = state.transformKeys, transformOrigin = state.transformOrigin;\n    // Empty the transformKeys array. As we're throwing out refs to its items\n    // this might not be as cheap as suspected. Maybe using the array as a buffer\n    // with a manual incrementation would be better.\n    transformKeys.length = 0;\n    // Track whether we encounter any transform or transformOrigin values.\n    var hasTransform = false;\n    var hasTransformOrigin = false;\n    // Does the calculated transform essentially equal \"none\"?\n    var transformIsNone = true;\n    /**\n     * Loop over all our latest animated values and decide whether to handle them\n     * as a style or CSS variable.\n     *\n     * Transforms and transform origins are kept seperately for further processing.\n     */\n    for (var key in latestValues) {\n        var value = latestValues[key];\n        /**\n         * If this is a CSS variable we don't do any further processing.\n         */\n        if (isCSSVariable(key)) {\n            vars[key] = value;\n            continue;\n        }\n        // Convert the value to its default value type, ie 0 -> \"0px\"\n        var valueType = numberValueTypes[key];\n        var valueAsType = getValueAsType(value, valueType);\n        if (isTransformProp(key)) {\n            // If this is a transform, flag to enable further transform processing\n            hasTransform = true;\n            transform[key] = valueAsType;\n            transformKeys.push(key);\n            // If we already know we have a non-default transform, early return\n            if (!transformIsNone)\n                continue;\n            // Otherwise check to see if this is a default transform\n            if (value !== ((_a = valueType.default) !== null && _a !== void 0 ? _a : 0))\n                transformIsNone = false;\n        }\n        else if (isTransformOriginProp(key)) {\n            transformOrigin[key] = valueAsType;\n            // If this is a transform origin, flag and enable further transform-origin processing\n            hasTransformOrigin = true;\n        }\n        else {\n            style[key] = valueAsType;\n        }\n    }\n    if (hasTransform) {\n        style.transform = buildTransform(state, options, transformIsNone, transformTemplate);\n    }\n    else if (transformTemplate) {\n        style.transform = transformTemplate({}, \"\");\n    }\n    else if (!latestValues.transform && style.transform) {\n        style.transform = \"none\";\n    }\n    if (hasTransformOrigin) {\n        style.transformOrigin = buildTransformOrigin(transformOrigin);\n    }\n}\n\nexport { buildHTMLStyles };\n","/**\n * We keep these listed seperately as we use the lowercase tag names as part\n * of the runtime bundle to detect SVG components\n */\nvar lowercaseSVGElements = [\n    \"animate\",\n    \"circle\",\n    \"defs\",\n    \"desc\",\n    \"ellipse\",\n    \"g\",\n    \"image\",\n    \"line\",\n    \"filter\",\n    \"marker\",\n    \"mask\",\n    \"metadata\",\n    \"path\",\n    \"pattern\",\n    \"polygon\",\n    \"polyline\",\n    \"rect\",\n    \"stop\",\n    \"svg\",\n    \"switch\",\n    \"symbol\",\n    \"text\",\n    \"tspan\",\n    \"use\",\n    \"view\",\n];\n\nexport { lowercaseSVGElements };\n","import { lowercaseSVGElements } from '../../svg/lowercase-elements.mjs';\n\nfunction isSVGComponent(Component) {\n    if (\n    /**\n     * If it's not a string, it's a custom React component. Currently we only support\n     * HTML custom React components.\n     */\n    typeof Component !== \"string\" ||\n        /**\n         * If it contains a dash, the element is a custom HTML webcomponent.\n         */\n        Component.includes(\"-\")) {\n        return false;\n    }\n    else if (\n    /**\n     * If it's in our list of lowercase SVG tags, it's an SVG component\n     */\n    lowercaseSVGElements.indexOf(Component) > -1 ||\n        /**\n         * If it contains a capital letter, it's an SVG component\n         */\n        /[A-Z]/.test(Component)) {\n        return true;\n    }\n    return false;\n}\n\nexport { isSVGComponent };\n","import { isCustomValue } from '../../utils/resolve-value.mjs';\nimport { isMotionValue } from './is-motion-value.mjs';\n\n/**\n * If the provided value is a MotionValue, this returns the actual value, otherwise just the value itself\n *\n * TODO: Remove and move to library\n */\nfunction resolveMotionValue(value) {\n    var unwrappedValue = isMotionValue(value) ? value.get() : value;\n    return isCustomValue(unwrappedValue)\n        ? unwrappedValue.toValue()\n        : unwrappedValue;\n}\n\nexport { resolveMotionValue };\n","import { createContext } from 'react';\n\n/**\n * Internal, exported only for usage in Framer\n */\nvar SwitchLayoutGroupContext = createContext({});\n\nexport { SwitchLayoutGroupContext };\n","import { isMotionValue } from '../../../value/utils/is-motion-value.mjs';\nimport { scrapeMotionValuesFromProps as scrapeMotionValuesFromProps$1 } from '../../html/utils/scrape-motion-values.mjs';\n\nfunction scrapeMotionValuesFromProps(props) {\n    var newValues = scrapeMotionValuesFromProps$1(props);\n    for (var key in props) {\n        if (isMotionValue(props[key])) {\n            var targetKey = key === \"x\" || key === \"y\" ? \"attr\" + key.toUpperCase() : key;\n            newValues[targetKey] = props[key];\n        }\n    }\n    return newValues;\n}\n\nexport { scrapeMotionValuesFromProps };\n","import { scaleCorrectors } from '../../projection/styles/scale-correction.mjs';\nimport { isTransformProp, isTransformOriginProp } from '../../render/html/utils/transform.mjs';\n\nfunction isForcedMotionValue(key, _a) {\n    var layout = _a.layout, layoutId = _a.layoutId;\n    return (isTransformProp(key) ||\n        isTransformOriginProp(key) ||\n        ((layout || layoutId !== undefined) &&\n            (!!scaleCorrectors[key] || key === \"opacity\")));\n}\n\nexport { isForcedMotionValue };\n","/**\n * Returns true if the provided key is a CSS variable\n */\nfunction isCSSVariable(key) {\n    return key.startsWith(\"--\");\n}\n\nexport { isCSSVariable };\n","import { camelToDash } from '../../dom/utils/camel-to-dash.mjs';\nimport { renderHTML } from '../../html/utils/render.mjs';\nimport { camelCaseAttributes } from './camel-case-attrs.mjs';\n\nfunction renderSVG(element, renderState, _styleProp, projection) {\n    renderHTML(element, renderState, undefined, projection);\n    for (var key in renderState.attrs) {\n        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);\n    }\n}\n\nexport { renderSVG };\n","function renderHTML(element, _a, styleProp, projection) {\n    var style = _a.style, vars = _a.vars;\n    Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));\n    // Loop over any CSS variables and assign those.\n    for (var key in vars) {\n        element.style.setProperty(key, vars[key]);\n    }\n}\n\nexport { renderHTML };\n","/**\n * A set of attribute names that are always read/written as camel case.\n */\nvar camelCaseAttributes = new Set([\n    \"baseFrequency\",\n    \"diffuseConstant\",\n    \"kernelMatrix\",\n    \"kernelUnitLength\",\n    \"keySplines\",\n    \"keyTimes\",\n    \"limitingConeAngle\",\n    \"markerHeight\",\n    \"markerWidth\",\n    \"numOctaves\",\n    \"targetX\",\n    \"targetY\",\n    \"surfaceScale\",\n    \"specularConstant\",\n    \"specularExponent\",\n    \"stdDeviation\",\n    \"tableValues\",\n    \"viewBox\",\n    \"gradientTransform\",\n    \"pathLength\",\n]);\n\nexport { camelCaseAttributes };\n","var CAMEL_CASE_PATTERN = /([a-z])([A-Z])/g;\nvar REPLACE_TEMPLATE = \"$1-$2\";\n/**\n * Convert camelCase to dash-case properties.\n */\nvar camelToDash = function (str) {\n    return str.replace(CAMEL_CASE_PATTERN, REPLACE_TEMPLATE).toLowerCase();\n};\n\nexport { camelToDash };\n","/**\n * A list of all valid MotionProps.\n *\n * @privateRemarks\n * This doesn't throw if a `MotionProp` name is missing - it should.\n */\nvar validMotionProps = new Set([\n    \"initial\",\n    \"animate\",\n    \"exit\",\n    \"style\",\n    \"variants\",\n    \"transition\",\n    \"transformTemplate\",\n    \"transformValues\",\n    \"custom\",\n    \"inherit\",\n    \"layout\",\n    \"layoutId\",\n    \"layoutDependency\",\n    \"onLayoutAnimationStart\",\n    \"onLayoutAnimationComplete\",\n    \"onLayoutMeasure\",\n    \"onBeforeLayoutMeasure\",\n    \"onAnimationStart\",\n    \"onAnimationComplete\",\n    \"onUpdate\",\n    \"onDragStart\",\n    \"onDrag\",\n    \"onDragEnd\",\n    \"onMeasureDragConstraints\",\n    \"onDirectionLock\",\n    \"onDragTransitionEnd\",\n    \"drag\",\n    \"dragControls\",\n    \"dragListener\",\n    \"dragConstraints\",\n    \"dragDirectionLock\",\n    \"dragSnapToOrigin\",\n    \"_dragX\",\n    \"_dragY\",\n    \"dragElastic\",\n    \"dragMomentum\",\n    \"dragPropagation\",\n    \"dragTransition\",\n    \"whileDrag\",\n    \"onPan\",\n    \"onPanStart\",\n    \"onPanEnd\",\n    \"onPanSessionStart\",\n    \"onTap\",\n    \"onTapStart\",\n    \"onTapCancel\",\n    \"onHoverStart\",\n    \"onHoverEnd\",\n    \"whileFocus\",\n    \"whileTap\",\n    \"whileHover\",\n    \"whileInView\",\n    \"onViewportEnter\",\n    \"onViewportLeave\",\n    \"viewport\",\n    \"layoutScroll\",\n]);\n/**\n * Check whether a prop name is a valid `MotionProp` key.\n *\n * @param key - Name of the property to check\n * @returns `true` is key is a valid `MotionProp`.\n *\n * @public\n */\nfunction isValidMotionProp(key) {\n    return validMotionProps.has(key);\n}\n\nexport { isValidMotionProp };\n","import { isValidMotionProp } from '../../../motion/utils/valid-prop.mjs';\n\nvar shouldForward = function (key) { return !isValidMotionProp(key); };\nfunction loadExternalIsValidProp(isValidProp) {\n    if (!isValidProp)\n        return;\n    // Explicitly filter our events\n    shouldForward = function (key) {\n        return key.startsWith(\"on\") ? !isValidMotionProp(key) : isValidProp(key);\n    };\n}\n/**\n * Emotion and Styled Components both allow users to pass through arbitrary props to their components\n * to dynamically generate CSS. They both use the `@emotion/is-prop-valid` package to determine which\n * of these should be passed to the underlying DOM node.\n *\n * However, when styling a Motion component `styled(motion.div)`, both packages pass through *all* props\n * as it's seen as an arbitrary component rather than a DOM node. Motion only allows arbitrary props\n * passed through the `custom` prop so it doesn't *need* the payload or computational overhead of\n * `@emotion/is-prop-valid`, however to fix this problem we need to use it.\n *\n * By making it an optionalDependency we can offer this functionality only in the situations where it's\n * actually required.\n */\ntry {\n    /**\n     * We attempt to import this package but require won't be defined in esm environments, in that case\n     * isPropValid will have to be provided via `MotionContext`. In a 6.0.0 this should probably be removed\n     * in favour of explicit injection.\n     */\n    loadExternalIsValidProp(require(\"@emotion/is-prop-valid\").default);\n}\ncatch (_a) {\n    // We don't need to actually do anything here - the fallback is the existing `isPropValid`.\n}\nfunction filterProps(props, isDom, forwardMotionProps) {\n    var filteredProps = {};\n    for (var key in props) {\n        if (shouldForward(key) ||\n            (forwardMotionProps === true && isValidMotionProp(key)) ||\n            (!isDom && !isValidMotionProp(key)) ||\n            // If trying to use native HTML drag events, forward drag listeners\n            (props[\"draggable\"] && key.startsWith(\"onDrag\"))) {\n            filteredProps[key] = props[key];\n        }\n    }\n    return filteredProps;\n}\n\nexport { filterProps, loadExternalIsValidProp };\n","import { __assign } from 'tslib';\nimport { number } from 'style-value-types';\n\nvar int = __assign(__assign({}, number), { transform: Math.round });\n\nexport { int };\n","import { px, degrees, scale, alpha, progressPercentage } from 'style-value-types';\nimport { int } from './type-int.mjs';\n\nvar numberValueTypes = {\n    // Border props\n    borderWidth: px,\n    borderTopWidth: px,\n    borderRightWidth: px,\n    borderBottomWidth: px,\n    borderLeftWidth: px,\n    borderRadius: px,\n    radius: px,\n    borderTopLeftRadius: px,\n    borderTopRightRadius: px,\n    borderBottomRightRadius: px,\n    borderBottomLeftRadius: px,\n    // Positioning props\n    width: px,\n    maxWidth: px,\n    height: px,\n    maxHeight: px,\n    size: px,\n    top: px,\n    right: px,\n    bottom: px,\n    left: px,\n    // Spacing props\n    padding: px,\n    paddingTop: px,\n    paddingRight: px,\n    paddingBottom: px,\n    paddingLeft: px,\n    margin: px,\n    marginTop: px,\n    marginRight: px,\n    marginBottom: px,\n    marginLeft: px,\n    // Transform props\n    rotate: degrees,\n    rotateX: degrees,\n    rotateY: degrees,\n    rotateZ: degrees,\n    scale: scale,\n    scaleX: scale,\n    scaleY: scale,\n    scaleZ: scale,\n    skew: degrees,\n    skewX: degrees,\n    skewY: degrees,\n    distance: px,\n    translateX: px,\n    translateY: px,\n    translateZ: px,\n    x: px,\n    y: px,\n    z: px,\n    perspective: px,\n    transformPerspective: px,\n    opacity: alpha,\n    originX: progressPercentage,\n    originY: progressPercentage,\n    originZ: px,\n    // Misc\n    zIndex: int,\n    // SVG\n    fillOpacity: alpha,\n    strokeOpacity: alpha,\n    numOctaves: int,\n};\n\nexport { numberValueTypes };\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nfunction _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }\n\nvar memoize = _interopDefault(require('@emotion/memoize'));\n\nvar reactPropsRegex = /^((children|dangerouslySetInnerHTML|key|ref|autoFocus|defaultValue|defaultChecked|innerHTML|suppressContentEditableWarning|suppressHydrationWarning|valueLink|accept|acceptCharset|accessKey|action|allow|allowUserMedia|allowPaymentRequest|allowFullScreen|allowTransparency|alt|async|autoComplete|autoPlay|capture|cellPadding|cellSpacing|challenge|charSet|checked|cite|classID|className|cols|colSpan|content|contentEditable|contextMenu|controls|controlsList|coords|crossOrigin|data|dateTime|decoding|default|defer|dir|disabled|disablePictureInPicture|download|draggable|encType|form|formAction|formEncType|formMethod|formNoValidate|formTarget|frameBorder|headers|height|hidden|high|href|hrefLang|htmlFor|httpEquiv|id|inputMode|integrity|is|keyParams|keyType|kind|label|lang|list|loading|loop|low|marginHeight|marginWidth|max|maxLength|media|mediaGroup|method|min|minLength|multiple|muted|name|nonce|noValidate|open|optimum|pattern|placeholder|playsInline|poster|preload|profile|radioGroup|readOnly|referrerPolicy|rel|required|reversed|role|rows|rowSpan|sandbox|scope|scoped|scrolling|seamless|selected|shape|size|sizes|slot|span|spellCheck|src|srcDoc|srcLang|srcSet|start|step|style|summary|tabIndex|target|title|type|useMap|value|width|wmode|wrap|about|datatype|inlist|prefix|property|resource|typeof|vocab|autoCapitalize|autoCorrect|autoSave|color|inert|itemProp|itemScope|itemType|itemID|itemRef|on|results|security|unselectable|accentHeight|accumulate|additive|alignmentBaseline|allowReorder|alphabetic|amplitude|arabicForm|ascent|attributeName|attributeType|autoReverse|azimuth|baseFrequency|baselineShift|baseProfile|bbox|begin|bias|by|calcMode|capHeight|clip|clipPathUnits|clipPath|clipRule|colorInterpolation|colorInterpolationFilters|colorProfile|colorRendering|contentScriptType|contentStyleType|cursor|cx|cy|d|decelerate|descent|diffuseConstant|direction|display|divisor|dominantBaseline|dur|dx|dy|edgeMode|elevation|enableBackground|end|exponent|externalResourcesRequired|fill|fillOpacity|fillRule|filter|filterRes|filterUnits|floodColor|floodOpacity|focusable|fontFamily|fontSize|fontSizeAdjust|fontStretch|fontStyle|fontVariant|fontWeight|format|from|fr|fx|fy|g1|g2|glyphName|glyphOrientationHorizontal|glyphOrientationVertical|glyphRef|gradientTransform|gradientUnits|hanging|horizAdvX|horizOriginX|ideographic|imageRendering|in|in2|intercept|k|k1|k2|k3|k4|kernelMatrix|kernelUnitLength|kerning|keyPoints|keySplines|keyTimes|lengthAdjust|letterSpacing|lightingColor|limitingConeAngle|local|markerEnd|markerMid|markerStart|markerHeight|markerUnits|markerWidth|mask|maskContentUnits|maskUnits|mathematical|mode|numOctaves|offset|opacity|operator|order|orient|orientation|origin|overflow|overlinePosition|overlineThickness|panose1|paintOrder|pathLength|patternContentUnits|patternTransform|patternUnits|pointerEvents|points|pointsAtX|pointsAtY|pointsAtZ|preserveAlpha|preserveAspectRatio|primitiveUnits|r|radius|refX|refY|renderingIntent|repeatCount|repeatDur|requiredExtensions|requiredFeatures|restart|result|rotate|rx|ry|scale|seed|shapeRendering|slope|spacing|specularConstant|specularExponent|speed|spreadMethod|startOffset|stdDeviation|stemh|stemv|stitchTiles|stopColor|stopOpacity|strikethroughPosition|strikethroughThickness|string|stroke|strokeDasharray|strokeDashoffset|strokeLinecap|strokeLinejoin|strokeMiterlimit|strokeOpacity|strokeWidth|surfaceScale|systemLanguage|tableValues|targetX|targetY|textAnchor|textDecoration|textRendering|textLength|to|transform|u1|u2|underlinePosition|underlineThickness|unicode|unicodeBidi|unicodeRange|unitsPerEm|vAlphabetic|vHanging|vIdeographic|vMathematical|values|vectorEffect|version|vertAdvY|vertOriginX|vertOriginY|viewBox|viewTarget|visibility|widths|wordSpacing|writingMode|x|xHeight|x1|x2|xChannelSelector|xlinkActuate|xlinkArcrole|xlinkHref|xlinkRole|xlinkShow|xlinkTitle|xlinkType|xmlBase|xmlns|xmlnsXlink|xmlLang|xmlSpace|y|y1|y2|yChannelSelector|z|zoomAndPan|for|class|autofocus)|(([Dd][Aa][Tt][Aa]|[Aa][Rr][Ii][Aa]|x)-.*))$/; // https://esbench.com/bench/5bfee68a4cd7e6009ef61d23\n\nvar index = memoize(function (prop) {\n  return reactPropsRegex.test(prop) || prop.charCodeAt(0) === 111\n  /* o */\n  && prop.charCodeAt(1) === 110\n  /* n */\n  && prop.charCodeAt(2) < 91;\n}\n/* Z+1 */\n);\n\nexports.default = index;\n","import { __assign } from 'tslib';\nimport * as React from 'react';\nimport { useContext } from 'react';\nimport { env } from '../../utils/process.mjs';\nimport { featureDefinitions } from './definitions.mjs';\nimport { invariant } from 'hey-listen';\nimport { LazyContext } from '../../context/LazyContext.mjs';\n\nvar featureNames = Object.keys(featureDefinitions);\nvar numFeatures = featureNames.length;\n/**\n * Load features via renderless components based on the provided MotionProps.\n */\nfunction useFeatures(props, visualElement, preloadedFeatures) {\n    var features = [];\n    var lazyContext = useContext(LazyContext);\n    if (!visualElement)\n        return null;\n    /**\n     * If we're in development mode, check to make sure we're not rendering a motion component\n     * as a child of LazyMotion, as this will break the file-size benefits of using it.\n     */\n    if (env !== \"production\" && preloadedFeatures && lazyContext.strict) {\n        invariant(false, \"You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.\");\n    }\n    for (var i = 0; i < numFeatures; i++) {\n        var name_1 = featureNames[i];\n        var _a = featureDefinitions[name_1], isEnabled = _a.isEnabled, Component = _a.Component;\n        /**\n         * It might be possible in the future to use this moment to\n         * dynamically request functionality. In initial tests this\n         * was producing a lot of duplication amongst bundles.\n         */\n        if (isEnabled(props) && Component) {\n            features.push(React.createElement(Component, __assign({ key: name_1 }, props, { visualElement: visualElement })));\n        }\n    }\n    return features;\n}\n\nexport { useFeatures };\n","import { createContext, useContext } from 'react';\n\nvar MotionContext = createContext({});\nfunction useVisualElementContext() {\n    return useContext(MotionContext).visualElement;\n}\n\nexport { MotionContext, useVisualElementContext };\n","import { __read } from 'tslib';\nimport { useState, useContext } from 'react';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { isBrowser } from './is-browser.mjs';\n\n// Does this device prefer reduced motion? Returns `null` server-side.\nvar prefersReducedMotion = { current: null };\nvar hasDetected = false;\nfunction initPrefersReducedMotion() {\n    hasDetected = true;\n    if (!isBrowser)\n        return;\n    if (window.matchMedia) {\n        var motionMediaQuery_1 = window.matchMedia(\"(prefers-reduced-motion)\");\n        var setReducedMotionPreferences = function () {\n            return (prefersReducedMotion.current = motionMediaQuery_1.matches);\n        };\n        motionMediaQuery_1.addListener(setReducedMotionPreferences);\n        setReducedMotionPreferences();\n    }\n    else {\n        prefersReducedMotion.current = false;\n    }\n}\n/**\n * A hook that returns `true` if we should be using reduced motion based on the current device's Reduced Motion setting.\n *\n * This can be used to implement changes to your UI based on Reduced Motion. For instance, replacing motion-sickness inducing\n * `x`/`y` animations with `opacity`, disabling the autoplay of background videos, or turning off parallax motion.\n *\n * It will actively respond to changes and re-render your components with the latest setting.\n *\n * ```jsx\n * export function Sidebar({ isOpen }) {\n *   const shouldReduceMotion = useReducedMotion()\n *   const closedX = shouldReduceMotion ? 0 : \"-100%\"\n *\n *   return (\n *     <motion.div animate={{\n *       opacity: isOpen ? 1 : 0,\n *       x: isOpen ? 0 : closedX\n *     }} />\n *   )\n * }\n * ```\n *\n * @return boolean\n *\n * @public\n */\nfunction useReducedMotion() {\n    /**\n     * Lazy initialisation of prefersReducedMotion\n     */\n    !hasDetected && initPrefersReducedMotion();\n    var _a = __read(useState(prefersReducedMotion.current), 1), shouldReduceMotion = _a[0];\n    /**\n     * TODO See if people miss automatically updating shouldReduceMotion setting\n     */\n    return shouldReduceMotion;\n}\nfunction useReducedMotionConfig() {\n    var reducedMotionPreference = useReducedMotion();\n    var reducedMotion = useContext(MotionConfigContext).reducedMotion;\n    if (reducedMotion === \"never\") {\n        return false;\n    }\n    else if (reducedMotion === \"always\") {\n        return true;\n    }\n    else {\n        return reducedMotionPreference;\n    }\n}\n\nexport { useReducedMotion, useReducedMotionConfig };\n","import { useContext, useRef, useEffect } from 'react';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { useVisualElementContext } from '../../context/MotionContext/index.mjs';\nimport { useIsomorphicLayoutEffect } from '../../utils/use-isomorphic-effect.mjs';\nimport { LazyContext } from '../../context/LazyContext.mjs';\nimport { useReducedMotionConfig } from '../../utils/use-reduced-motion.mjs';\n\nfunction useVisualElement(Component, visualState, props, createVisualElement) {\n    var lazyContext = useContext(LazyContext);\n    var parent = useVisualElementContext();\n    var presenceContext = useContext(PresenceContext);\n    var shouldReduceMotion = useReducedMotionConfig();\n    var visualElementRef = useRef(undefined);\n    /**\n     * If we haven't preloaded a renderer, check to see if we have one lazy-loaded\n     */\n    if (!createVisualElement)\n        createVisualElement = lazyContext.renderer;\n    if (!visualElementRef.current && createVisualElement) {\n        visualElementRef.current = createVisualElement(Component, {\n            visualState: visualState,\n            parent: parent,\n            props: props,\n            presenceId: presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.id,\n            blockInitialAnimation: (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false,\n            shouldReduceMotion: shouldReduceMotion,\n        });\n    }\n    var visualElement = visualElementRef.current;\n    useIsomorphicLayoutEffect(function () {\n        visualElement === null || visualElement === void 0 ? void 0 : visualElement.syncRender();\n    });\n    useEffect(function () {\n        var _a;\n        (_a = visualElement === null || visualElement === void 0 ? void 0 : visualElement.animationState) === null || _a === void 0 ? void 0 : _a.animateChanges();\n    });\n    useIsomorphicLayoutEffect(function () { return function () { return visualElement === null || visualElement === void 0 ? void 0 : visualElement.notifyUnmount(); }; }, []);\n    return visualElement;\n}\n\nexport { useVisualElement };\n","import { useMemo, useContext } from 'react';\nimport { MotionContext } from './index.mjs';\nimport { getCurrentTreeVariants } from './utils.mjs';\n\nfunction useCreateMotionContext(props) {\n    var _a = getCurrentTreeVariants(props, useContext(MotionContext)), initial = _a.initial, animate = _a.animate;\n    return useMemo(function () { return ({ initial: initial, animate: animate }); }, [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);\n}\nfunction variantLabelsAsDependency(prop) {\n    return Array.isArray(prop) ? prop.join(\" \") : prop;\n}\n\nexport { useCreateMotionContext };\n","import { checkIfControllingVariants, isVariantLabel } from '../../render/utils/variants.mjs';\n\nfunction getCurrentTreeVariants(props, context) {\n    if (checkIfControllingVariants(props)) {\n        var initial = props.initial, animate = props.animate;\n        return {\n            initial: initial === false || isVariantLabel(initial)\n                ? initial\n                : undefined,\n            animate: isVariantLabel(animate) ? animate : undefined,\n        };\n    }\n    return props.inherit !== false ? context : {};\n}\n\nexport { getCurrentTreeVariants };\n","import { useConstant } from '../../utils/use-constant.mjs';\nimport { globalProjectionState } from './state.mjs';\n\nvar id = 1;\nfunction useProjectionId() {\n    return useConstant(function () {\n        if (globalProjectionState.hasEverUpdated) {\n            return id++;\n        }\n    });\n}\n\nexport { useProjectionId };\n","import { __extends } from 'tslib';\nimport React__default from 'react';\n\nvar VisualElementHandler = /** @class */ (function (_super) {\n    __extends(VisualElementHandler, _super);\n    function VisualElementHandler() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * Update visual element props as soon as we know this update is going to be commited.\n     */\n    VisualElementHandler.prototype.getSnapshotBeforeUpdate = function () {\n        this.updateProps();\n        return null;\n    };\n    VisualElementHandler.prototype.componentDidUpdate = function () { };\n    VisualElementHandler.prototype.updateProps = function () {\n        var _a = this.props, visualElement = _a.visualElement, props = _a.props;\n        if (visualElement)\n            visualElement.setProps(props);\n    };\n    VisualElementHandler.prototype.render = function () {\n        return this.props.children;\n    };\n    return VisualElementHandler;\n}(React__default.Component));\n\nexport { VisualElementHandler };\n","import { __assign } from 'tslib';\nimport * as React from 'react';\nimport { forwardRef, useContext } from 'react';\nimport { useFeatures } from './features/use-features.mjs';\nimport { MotionConfigContext } from '../context/MotionConfigContext.mjs';\nimport { MotionContext } from '../context/MotionContext/index.mjs';\nimport { useVisualElement } from './utils/use-visual-element.mjs';\nimport { useMotionRef } from './utils/use-motion-ref.mjs';\nimport { useCreateMotionContext } from '../context/MotionContext/create.mjs';\nimport { loadFeatures, featureDefinitions } from './features/definitions.mjs';\nimport { isBrowser } from '../utils/is-browser.mjs';\nimport { useProjectionId } from '../projection/node/id.mjs';\nimport { LayoutGroupContext } from '../context/LayoutGroupContext.mjs';\nimport { useProjection } from './features/use-projection.mjs';\nimport { VisualElementHandler } from './utils/VisualElementHandler.mjs';\n\n/**\n * Create a `motion` component.\n *\n * This function accepts a Component argument, which can be either a string (ie \"div\"\n * for `motion.div`), or an actual React component.\n *\n * Alongside this is a config option which provides a way of rendering the provided\n * component \"offline\", or outside the React render cycle.\n */\nfunction createMotionComponent(_a) {\n    var preloadedFeatures = _a.preloadedFeatures, createVisualElement = _a.createVisualElement, projectionNodeConstructor = _a.projectionNodeConstructor, useRender = _a.useRender, useVisualState = _a.useVisualState, Component = _a.Component;\n    preloadedFeatures && loadFeatures(preloadedFeatures);\n    function MotionComponent(props, externalRef) {\n        var layoutId = useLayoutId(props);\n        props = __assign(__assign({}, props), { layoutId: layoutId });\n        /**\n         * If we're rendering in a static environment, we only visually update the component\n         * as a result of a React-rerender rather than interactions or animations. This\n         * means we don't need to load additional memory structures like VisualElement,\n         * or any gesture/animation features.\n         */\n        var config = useContext(MotionConfigContext);\n        var features = null;\n        var context = useCreateMotionContext(props);\n        /**\n         * Create a unique projection ID for this component. If a new component is added\n         * during a layout animation we'll use this to query the DOM and hydrate its ref early, allowing\n         * us to measure it as soon as any layout effect flushes pending layout animations.\n         *\n         * Performance note: It'd be better not to have to search the DOM for these elements.\n         * For newly-entering components it could be enough to only correct treeScale, in which\n         * case we could mount in a scale-correction mode. This wouldn't be enough for\n         * shared element transitions however. Perhaps for those we could revert to a root node\n         * that gets forceRendered and layout animations are triggered on its layout effect.\n         */\n        var projectionId = config.isStatic ? undefined : useProjectionId();\n        /**\n         *\n         */\n        var visualState = useVisualState(props, config.isStatic);\n        if (!config.isStatic && isBrowser) {\n            /**\n             * Create a VisualElement for this component. A VisualElement provides a common\n             * interface to renderer-specific APIs (ie DOM/Three.js etc) as well as\n             * providing a way of rendering to these APIs outside of the React render loop\n             * for more performant animations and interactions\n             */\n            context.visualElement = useVisualElement(Component, visualState, __assign(__assign({}, config), props), createVisualElement);\n            useProjection(projectionId, props, context.visualElement, projectionNodeConstructor ||\n                featureDefinitions.projectionNodeConstructor);\n            /**\n             * Load Motion gesture and animation features. These are rendered as renderless\n             * components so each feature can optionally make use of React lifecycle methods.\n             */\n            features = useFeatures(props, context.visualElement, preloadedFeatures);\n        }\n        /**\n         * The mount order and hierarchy is specific to ensure our element ref\n         * is hydrated by the time features fire their effects.\n         */\n        return (React.createElement(VisualElementHandler, { visualElement: context.visualElement, props: __assign(__assign({}, config), props) },\n            features,\n            React.createElement(MotionContext.Provider, { value: context }, useRender(Component, props, projectionId, useMotionRef(visualState, context.visualElement, externalRef), visualState, config.isStatic, context.visualElement))));\n    }\n    return forwardRef(MotionComponent);\n}\nfunction useLayoutId(_a) {\n    var _b;\n    var layoutId = _a.layoutId;\n    var layoutGroupId = (_b = useContext(LayoutGroupContext)) === null || _b === void 0 ? void 0 : _b.id;\n    return layoutGroupId && layoutId !== undefined\n        ? layoutGroupId + \"-\" + layoutId\n        : layoutId;\n}\n\nexport { createMotionComponent };\n","import { isRefObject } from '../../utils/is-ref-object.mjs';\nimport { useContext } from 'react';\nimport { SwitchLayoutGroupContext } from '../../context/SwitchLayoutGroupContext.mjs';\n\nfunction useProjection(projectionId, _a, visualElement, ProjectionNodeConstructor) {\n    var _b;\n    var layoutId = _a.layoutId, layout = _a.layout, drag = _a.drag, dragConstraints = _a.dragConstraints, layoutScroll = _a.layoutScroll;\n    var initialPromotionConfig = useContext(SwitchLayoutGroupContext);\n    if (!ProjectionNodeConstructor ||\n        !visualElement ||\n        (visualElement === null || visualElement === void 0 ? void 0 : visualElement.projection)) {\n        return;\n    }\n    visualElement.projection = new ProjectionNodeConstructor(projectionId, visualElement.getLatestValues(), (_b = visualElement.parent) === null || _b === void 0 ? void 0 : _b.projection);\n    visualElement.projection.setOptions({\n        layoutId: layoutId,\n        layout: layout,\n        alwaysMeasureLayout: Boolean(drag) || (dragConstraints && isRefObject(dragConstraints)),\n        visualElement: visualElement,\n        scheduleRender: function () { return visualElement.scheduleRender(); },\n        /**\n         * TODO: Update options in an effect. This could be tricky as it'll be too late\n         * to update by the time layout animations run.\n         * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,\n         * ensuring it gets called if there's no potential layout animations.\n         *\n         */\n        animationType: typeof layout === \"string\" ? layout : \"both\",\n        initialPromotionConfig: initialPromotionConfig,\n        layoutScroll: layoutScroll,\n    });\n}\n\nexport { useProjection };\n","import { useCallback } from 'react';\nimport { isRefObject } from '../../utils/is-ref-object.mjs';\n\n/**\n * Creates a ref function that, when called, hydrates the provided\n * external ref and VisualElement.\n */\nfunction useMotionRef(visualState, visualElement, externalRef) {\n    return useCallback(function (instance) {\n        var _a;\n        instance && ((_a = visualState.mount) === null || _a === void 0 ? void 0 : _a.call(visualState, instance));\n        if (visualElement) {\n            instance\n                ? visualElement.mount(instance)\n                : visualElement.unmount();\n        }\n        if (externalRef) {\n            if (typeof externalRef === \"function\") {\n                externalRef(instance);\n            }\n            else if (isRefObject(externalRef)) {\n                externalRef.current = instance;\n            }\n        }\n    }, \n    /**\n     * Only pass a new ref callback to React if we've received a visual element\n     * factory. Otherwise we'll be mounting/remounting every time externalRef\n     * or other dependencies change.\n     */\n    [visualElement]);\n}\n\nexport { useMotionRef };\n","var createHtmlRenderState = function () { return ({\n    style: {},\n    transform: {},\n    transformKeys: [],\n    transformOrigin: {},\n    vars: {},\n}); };\n\nexport { createHtmlRenderState };\n","import { __assign } from 'tslib';\nimport { useMemo } from 'react';\nimport { isForcedMotionValue } from '../../motion/utils/is-forced-motion-value.mjs';\nimport { isMotionValue } from '../../value/utils/is-motion-value.mjs';\nimport { buildHTMLStyles } from './utils/build-styles.mjs';\nimport { createHtmlRenderState } from './utils/create-render-state.mjs';\n\nfunction copyRawValuesOnly(target, source, props) {\n    for (var key in source) {\n        if (!isMotionValue(source[key]) && !isForcedMotionValue(key, props)) {\n            target[key] = source[key];\n        }\n    }\n}\nfunction useInitialMotionValues(_a, visualState, isStatic) {\n    var transformTemplate = _a.transformTemplate;\n    return useMemo(function () {\n        var state = createHtmlRenderState();\n        buildHTMLStyles(state, visualState, { enableHardwareAcceleration: !isStatic }, transformTemplate);\n        var vars = state.vars, style = state.style;\n        return __assign(__assign({}, vars), style);\n    }, [visualState]);\n}\nfunction useStyle(props, visualState, isStatic) {\n    var styleProp = props.style || {};\n    var style = {};\n    /**\n     * Copy non-Motion Values straight into style\n     */\n    copyRawValuesOnly(style, styleProp, props);\n    Object.assign(style, useInitialMotionValues(props, visualState, isStatic));\n    if (props.transformValues) {\n        style = props.transformValues(style);\n    }\n    return style;\n}\nfunction useHTMLProps(props, visualState, isStatic) {\n    // The `any` isn't ideal but it is the type of createElement props argument\n    var htmlProps = {};\n    var style = useStyle(props, visualState, isStatic);\n    if (Boolean(props.drag) && props.dragListener !== false) {\n        // Disable the ghost element when a user drags\n        htmlProps.draggable = false;\n        // Disable text selection\n        style.userSelect =\n            style.WebkitUserSelect =\n                style.WebkitTouchCallout =\n                    \"none\";\n        // Disable scrolling on the draggable direction\n        style.touchAction =\n            props.drag === true\n                ? \"none\"\n                : \"pan-\".concat(props.drag === \"x\" ? \"y\" : \"x\");\n    }\n    htmlProps.style = style;\n    return htmlProps;\n}\n\nexport { copyRawValuesOnly, useHTMLProps, useStyle };\n","import { __assign } from 'tslib';\nimport { createHtmlRenderState } from '../../html/utils/create-render-state.mjs';\n\nvar createSvgRenderState = function () { return (__assign(__assign({}, createHtmlRenderState()), { attrs: {} })); };\n\nexport { createSvgRenderState };\n","import { __assign } from 'tslib';\nimport { useMemo } from 'react';\nimport { copyRawValuesOnly } from '../html/use-props.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\nimport { createSvgRenderState } from './utils/create-render-state.mjs';\n\nfunction useSVGProps(props, visualState) {\n    var visualProps = useMemo(function () {\n        var state = createSvgRenderState();\n        buildSVGAttrs(state, visualState, { enableHardwareAcceleration: false }, props.transformTemplate);\n        return __assign(__assign({}, state.attrs), { style: __assign({}, state.style) });\n    }, [visualState]);\n    if (props.style) {\n        var rawStyles = {};\n        copyRawValuesOnly(rawStyles, props.style, props);\n        visualProps.style = __assign(__assign({}, rawStyles), visualProps.style);\n    }\n    return visualProps;\n}\n\nexport { useSVGProps };\n","import { __assign } from 'tslib';\nimport { createElement } from 'react';\nimport { useHTMLProps } from '../html/use-props.mjs';\nimport { filterProps } from './utils/filter-props.mjs';\nimport { isSVGComponent } from './utils/is-svg-component.mjs';\nimport { useSVGProps } from '../svg/use-props.mjs';\n\nfunction createUseRender(forwardMotionProps) {\n    if (forwardMotionProps === void 0) { forwardMotionProps = false; }\n    var useRender = function (Component, props, projectionId, ref, _a, isStatic) {\n        var latestValues = _a.latestValues;\n        var useVisualProps = isSVGComponent(Component)\n            ? useSVGProps\n            : useHTMLProps;\n        var visualProps = useVisualProps(props, latestValues, isStatic);\n        var filteredProps = filterProps(props, typeof Component === \"string\", forwardMotionProps);\n        var elementProps = __assign(__assign(__assign({}, filteredProps), visualProps), { ref: ref });\n        if (projectionId) {\n            elementProps[\"data-projection-id\"] = projectionId;\n        }\n        return createElement(Component, elementProps);\n    };\n    return useRender;\n}\n\nexport { createUseRender };\n","import { __rest } from 'tslib';\nimport { useContext } from 'react';\nimport { isAnimationControls } from '../../animation/utils/is-animation-controls.mjs';\nimport { PresenceContext } from '../../context/PresenceContext.mjs';\nimport { checkIfControllingVariants, checkIfVariantNode, resolveVariantFromProps } from '../../render/utils/variants.mjs';\nimport { useConstant } from '../../utils/use-constant.mjs';\nimport { resolveMotionValue } from '../../value/utils/resolve-motion-value.mjs';\nimport { MotionContext } from '../../context/MotionContext/index.mjs';\n\nfunction makeState(_a, props, context, presenceContext) {\n    var scrapeMotionValuesFromProps = _a.scrapeMotionValuesFromProps, createRenderState = _a.createRenderState, onMount = _a.onMount;\n    var state = {\n        latestValues: makeLatestValues(props, context, presenceContext, scrapeMotionValuesFromProps),\n        renderState: createRenderState(),\n    };\n    if (onMount) {\n        state.mount = function (instance) { return onMount(props, instance, state); };\n    }\n    return state;\n}\nvar makeUseVisualState = function (config) {\n    return function (props, isStatic) {\n        var context = useContext(MotionContext);\n        var presenceContext = useContext(PresenceContext);\n        return isStatic\n            ? makeState(config, props, context, presenceContext)\n            : useConstant(function () {\n                return makeState(config, props, context, presenceContext);\n            });\n    };\n};\nfunction makeLatestValues(props, context, presenceContext, scrapeMotionValues) {\n    var values = {};\n    var blockInitialAnimation = (presenceContext === null || presenceContext === void 0 ? void 0 : presenceContext.initial) === false;\n    var motionValues = scrapeMotionValues(props);\n    for (var key in motionValues) {\n        values[key] = resolveMotionValue(motionValues[key]);\n    }\n    var initial = props.initial, animate = props.animate;\n    var isControllingVariants = checkIfControllingVariants(props);\n    var isVariantNode = checkIfVariantNode(props);\n    if (context &&\n        isVariantNode &&\n        !isControllingVariants &&\n        props.inherit !== false) {\n        initial !== null && initial !== void 0 ? initial : (initial = context.initial);\n        animate !== null && animate !== void 0 ? animate : (animate = context.animate);\n    }\n    var initialAnimationIsBlocked = blockInitialAnimation || initial === false;\n    var variantToSet = initialAnimationIsBlocked ? animate : initial;\n    if (variantToSet &&\n        typeof variantToSet !== \"boolean\" &&\n        !isAnimationControls(variantToSet)) {\n        var list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];\n        list.forEach(function (definition) {\n            var resolved = resolveVariantFromProps(props, definition);\n            if (!resolved)\n                return;\n            var transitionEnd = resolved.transitionEnd; resolved.transition; var target = __rest(resolved, [\"transitionEnd\", \"transition\"]);\n            for (var key in target) {\n                var valueTarget = target[key];\n                if (Array.isArray(valueTarget)) {\n                    /**\n                     * Take final keyframe if the initial animation is blocked because\n                     * we want to initialise at the end of that blocked animation.\n                     */\n                    var index = initialAnimationIsBlocked\n                        ? valueTarget.length - 1\n                        : 0;\n                    valueTarget = valueTarget[index];\n                }\n                if (valueTarget !== null) {\n                    values[key] = valueTarget;\n                }\n            }\n            for (var key in transitionEnd)\n                values[key] = transitionEnd[key];\n        });\n    }\n    return values;\n}\n\nexport { makeUseVisualState };\n","import { renderSVG } from './utils/render.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { makeUseVisualState } from '../../motion/utils/use-visual-state.mjs';\nimport { createSvgRenderState } from './utils/create-render-state.mjs';\nimport { buildSVGAttrs } from './utils/build-attrs.mjs';\n\nvar svgMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n        createRenderState: createSvgRenderState,\n        onMount: function (props, instance, _a) {\n            var renderState = _a.renderState, latestValues = _a.latestValues;\n            try {\n                renderState.dimensions =\n                    typeof instance.getBBox ===\n                        \"function\"\n                        ? instance.getBBox()\n                        : instance.getBoundingClientRect();\n            }\n            catch (e) {\n                // Most likely trying to measure an unrendered element under Firefox\n                renderState.dimensions = {\n                    x: 0,\n                    y: 0,\n                    width: 0,\n                    height: 0,\n                };\n            }\n            buildSVGAttrs(renderState, latestValues, { enableHardwareAcceleration: false }, props.transformTemplate);\n            renderSVG(instance, renderState);\n        },\n    }),\n};\n\nexport { svgMotionConfig };\n","import { makeUseVisualState } from '../../motion/utils/use-visual-state.mjs';\nimport { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.mjs';\nimport { createHtmlRenderState } from './utils/create-render-state.mjs';\n\nvar htmlMotionConfig = {\n    useVisualState: makeUseVisualState({\n        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,\n        createRenderState: createHtmlRenderState,\n    }),\n};\n\nexport { htmlMotionConfig };\n","import { createMotionProxy } from './motion-proxy.mjs';\nimport { createDomMotionConfig } from './utils/create-config.mjs';\n\n/**\n * @public\n */\nvar m = createMotionProxy(createDomMotionConfig);\n\nexport { m };\n","import { createMotionComponent } from '../../motion/index.mjs';\n\n/**\n * Convert any React component into a `motion` component. The provided component\n * **must** use `React.forwardRef` to the underlying DOM component you want to animate.\n *\n * ```jsx\n * const Component = React.forwardRef((props, ref) => {\n *   return <div ref={ref} />\n * })\n *\n * const MotionComponent = motion(Component)\n * ```\n *\n * @public\n */\nfunction createMotionProxy(createConfig) {\n    function custom(Component, customMotionComponentConfig) {\n        if (customMotionComponentConfig === void 0) { customMotionComponentConfig = {}; }\n        return createMotionComponent(createConfig(Component, customMotionComponentConfig));\n    }\n    if (typeof Proxy === \"undefined\") {\n        return custom;\n    }\n    /**\n     * A cache of generated `motion` components, e.g `motion.div`, `motion.input` etc.\n     * Rather than generating them anew every render.\n     */\n    var componentCache = new Map();\n    return new Proxy(custom, {\n        /**\n         * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.\n         * The prop name is passed through as `key` and we can use that to generate a `motion`\n         * DOM component with that name.\n         */\n        get: function (_target, key) {\n            /**\n             * If this element doesn't exist in the component cache, create it and cache.\n             */\n            if (!componentCache.has(key)) {\n                componentCache.set(key, custom(key));\n            }\n            return componentCache.get(key);\n        },\n    });\n}\n\nexport { createMotionProxy };\n","import { __assign } from 'tslib';\nimport { isSVGComponent } from './is-svg-component.mjs';\nimport { createUseRender } from '../use-render.mjs';\nimport { svgMotionConfig } from '../../svg/config-motion.mjs';\nimport { htmlMotionConfig } from '../../html/config-motion.mjs';\n\nfunction createDomMotionConfig(Component, _a, preloadedFeatures, createVisualElement, projectionNodeConstructor) {\n    var _b = _a.forwardMotionProps, forwardMotionProps = _b === void 0 ? false : _b;\n    var baseConfig = isSVGComponent(Component)\n        ? svgMotionConfig\n        : htmlMotionConfig;\n    return __assign(__assign({}, baseConfig), { preloadedFeatures: preloadedFeatures, useRender: createUseRender(forwardMotionProps), createVisualElement: createVisualElement, projectionNodeConstructor: projectionNodeConstructor, Component: Component });\n}\n\nexport { createDomMotionConfig };\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global global, define, System, Reflect, Promise */\r\nvar __extends;\r\nvar __assign;\r\nvar __rest;\r\nvar __decorate;\r\nvar __param;\r\nvar __metadata;\r\nvar __awaiter;\r\nvar __generator;\r\nvar __exportStar;\r\nvar __values;\r\nvar __read;\r\nvar __spread;\r\nvar __spreadArrays;\r\nvar __spreadArray;\r\nvar __await;\r\nvar __asyncGenerator;\r\nvar __asyncDelegator;\r\nvar __asyncValues;\r\nvar __makeTemplateObject;\r\nvar __importStar;\r\nvar __importDefault;\r\nvar __classPrivateFieldGet;\r\nvar __classPrivateFieldSet;\r\nvar __createBinding;\r\n(function (factory) {\r\n    var root = typeof global === \"object\" ? global : typeof self === \"object\" ? self : typeof this === \"object\" ? this : {};\r\n    if (typeof define === \"function\" && define.amd) {\r\n        define(\"tslib\", [\"exports\"], function (exports) { factory(createExporter(root, createExporter(exports))); });\r\n    }\r\n    else if (typeof module === \"object\" && typeof module.exports === \"object\") {\r\n        factory(createExporter(root, createExporter(module.exports)));\r\n    }\r\n    else {\r\n        factory(createExporter(root));\r\n    }\r\n    function createExporter(exports, previous) {\r\n        if (exports !== root) {\r\n            if (typeof Object.create === \"function\") {\r\n                Object.defineProperty(exports, \"__esModule\", { value: true });\r\n            }\r\n            else {\r\n                exports.__esModule = true;\r\n            }\r\n        }\r\n        return function (id, v) { return exports[id] = previous ? previous(id, v) : v; };\r\n    }\r\n})\r\n(function (exporter) {\r\n    var extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n\r\n    __extends = function (d, b) {\r\n        if (typeof b !== \"function\" && b !== null)\r\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n        extendStatics(d, b);\r\n        function __() { this.constructor = d; }\r\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n    };\r\n\r\n    __assign = Object.assign || function (t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n\r\n    __rest = function (s, e) {\r\n        var t = {};\r\n        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n            t[p] = s[p];\r\n        if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n            for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n                if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                    t[p[i]] = s[p[i]];\r\n            }\r\n        return t;\r\n    };\r\n\r\n    __decorate = function (decorators, target, key, desc) {\r\n        var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n        if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n        else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n        return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n    };\r\n\r\n    __param = function (paramIndex, decorator) {\r\n        return function (target, key) { decorator(target, key, paramIndex); }\r\n    };\r\n\r\n    __metadata = function (metadataKey, metadataValue) {\r\n        if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n    };\r\n\r\n    __awaiter = function (thisArg, _arguments, P, generator) {\r\n        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n        return new (P || (P = Promise))(function (resolve, reject) {\r\n            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n            function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n            step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n        });\r\n    };\r\n\r\n    __generator = function (thisArg, body) {\r\n        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n        return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n        function verb(n) { return function (v) { return step([n, v]); }; }\r\n        function step(op) {\r\n            if (f) throw new TypeError(\"Generator is already executing.\");\r\n            while (_) try {\r\n                if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n                if (y = 0, t) op = [op[0] & 2, t.value];\r\n                switch (op[0]) {\r\n                    case 0: case 1: t = op; break;\r\n                    case 4: _.label++; return { value: op[1], done: false };\r\n                    case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                    case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                    default:\r\n                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                        if (t[2]) _.ops.pop();\r\n                        _.trys.pop(); continue;\r\n                }\r\n                op = body.call(thisArg, _);\r\n            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n        }\r\n    };\r\n\r\n    __exportStar = function(m, o) {\r\n        for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n    };\r\n\r\n    __createBinding = Object.create ? (function(o, m, k, k2) {\r\n        if (k2 === undefined) k2 = k;\r\n        Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n    }) : (function(o, m, k, k2) {\r\n        if (k2 === undefined) k2 = k;\r\n        o[k2] = m[k];\r\n    });\r\n\r\n    __values = function (o) {\r\n        var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n        if (m) return m.call(o);\r\n        if (o && typeof o.length === \"number\") return {\r\n            next: function () {\r\n                if (o && i >= o.length) o = void 0;\r\n                return { value: o && o[i++], done: !o };\r\n            }\r\n        };\r\n        throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n    };\r\n\r\n    __read = function (o, n) {\r\n        var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n        if (!m) return o;\r\n        var i = m.call(o), r, ar = [], e;\r\n        try {\r\n            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n        }\r\n        catch (error) { e = { error: error }; }\r\n        finally {\r\n            try {\r\n                if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n            }\r\n            finally { if (e) throw e.error; }\r\n        }\r\n        return ar;\r\n    };\r\n\r\n    /** @deprecated */\r\n    __spread = function () {\r\n        for (var ar = [], i = 0; i < arguments.length; i++)\r\n            ar = ar.concat(__read(arguments[i]));\r\n        return ar;\r\n    };\r\n\r\n    /** @deprecated */\r\n    __spreadArrays = function () {\r\n        for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n        for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n            for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n                r[k] = a[j];\r\n        return r;\r\n    };\r\n\r\n    __spreadArray = function (to, from, pack) {\r\n        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n            if (ar || !(i in from)) {\r\n                if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n                ar[i] = from[i];\r\n            }\r\n        }\r\n        return to.concat(ar || from);\r\n    };\r\n\r\n    __await = function (v) {\r\n        return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n    };\r\n\r\n    __asyncGenerator = function (thisArg, _arguments, generator) {\r\n        if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n        var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n        return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);  }\r\n        function fulfill(value) { resume(\"next\", value); }\r\n        function reject(value) { resume(\"throw\", value); }\r\n        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n    };\r\n\r\n    __asyncDelegator = function (o) {\r\n        var i, p;\r\n        return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n        function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n    };\r\n\r\n    __asyncValues = function (o) {\r\n        if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n        var m = o[Symbol.asyncIterator], i;\r\n        return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n    };\r\n\r\n    __makeTemplateObject = function (cooked, raw) {\r\n        if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n        return cooked;\r\n    };\r\n\r\n    var __setModuleDefault = Object.create ? (function(o, v) {\r\n        Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n    }) : function(o, v) {\r\n        o[\"default\"] = v;\r\n    };\r\n\r\n    __importStar = function (mod) {\r\n        if (mod && mod.__esModule) return mod;\r\n        var result = {};\r\n        if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n        __setModuleDefault(result, mod);\r\n        return result;\r\n    };\r\n\r\n    __importDefault = function (mod) {\r\n        return (mod && mod.__esModule) ? mod : { \"default\": mod };\r\n    };\r\n\r\n    __classPrivateFieldGet = function (receiver, state, kind, f) {\r\n        if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n        if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n        return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n    };\r\n\r\n    __classPrivateFieldSet = function (receiver, state, value, kind, f) {\r\n        if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n        if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n        if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n        return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n    };\r\n\r\n    exporter(\"__extends\", __extends);\r\n    exporter(\"__assign\", __assign);\r\n    exporter(\"__rest\", __rest);\r\n    exporter(\"__decorate\", __decorate);\r\n    exporter(\"__param\", __param);\r\n    exporter(\"__metadata\", __metadata);\r\n    exporter(\"__awaiter\", __awaiter);\r\n    exporter(\"__generator\", __generator);\r\n    exporter(\"__exportStar\", __exportStar);\r\n    exporter(\"__createBinding\", __createBinding);\r\n    exporter(\"__values\", __values);\r\n    exporter(\"__read\", __read);\r\n    exporter(\"__spread\", __spread);\r\n    exporter(\"__spreadArrays\", __spreadArrays);\r\n    exporter(\"__spreadArray\", __spreadArray);\r\n    exporter(\"__await\", __await);\r\n    exporter(\"__asyncGenerator\", __asyncGenerator);\r\n    exporter(\"__asyncDelegator\", __asyncDelegator);\r\n    exporter(\"__asyncValues\", __asyncValues);\r\n    exporter(\"__makeTemplateObject\", __makeTemplateObject);\r\n    exporter(\"__importStar\", __importStar);\r\n    exporter(\"__importDefault\", __importDefault);\r\n    exporter(\"__classPrivateFieldGet\", __classPrivateFieldGet);\r\n    exporter(\"__classPrivateFieldSet\", __classPrivateFieldSet);\r\n});\r\n","import { useRef } from 'react';\n\n/**\n * Creates a constant value over the lifecycle of a component.\n *\n * Even if `useMemo` is provided an empty array as its final argument, it doesn't offer\n * a guarantee that it won't re-run for performance reasons later on. By using `useConstant`\n * you can ensure that initialisers don't execute twice or more.\n */\nfunction useConstant(init) {\n    var ref = useRef(null);\n    if (ref.current === null) {\n        ref.current = init();\n    }\n    return ref.current;\n}\n\nexport { useConstant };\n","import { useLayoutEffect, useEffect } from 'react';\nimport { isBrowser } from './is-browser.mjs';\n\nvar useIsomorphicLayoutEffect = isBrowser ? useLayoutEffect : useEffect;\n\nexport { useIsomorphicLayoutEffect };\n"],"sourceRoot":""}