{"version":3,"file":"static/chunks/3796-f2ef6d55f65e9d50.js","mappings":"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A,GAAkC,KAAd,QAAc,yBAElC,CACA,oBACA,2BACA,iBAEA,uBAAoC,IAAS,4DAC7C,CACA,gBACA,6BAGA,2BACA,oBACA,iCAGA,yBACA,CACA,mBACA,4DAAsE,QAAc,4BACpF,CACA,UACA,2DACA,YAAwB,iBAAsB,EAC9C,mBACA,CACA,WACA,yDACA,YAAwB,iBAAsB,EAC9C,mBACA,CACA,eACA,6BACA,uBACA,sBACA,gBAA2B,2CAA8C,EAEzE,CACA,kBACA,6BACA,+CACA,wBACA,UACA,QACA,gBAAmC,UAAc,EAEjD,uBAGA,mBAEA,gBAA2B,6CAAgD,EAE3E,CACA,oBACA,6BAEA,aACA,0BACA,SAAuB,kBAAoB,CAE3C,CACA,WACA,oCACA,8CACA,aAAsB,UAAc,OAC5B,WAER,OADA,wBACA,gBAMA,GAHA,GACA,mBAEA,uBACA,gDACA,GACA,0BAEA,CAQA,0BACA,MACA,kCACA,cACA,SACA,WACA,SAEA,CAAO,CACP,EAkBA,GACA,eACA,qBACA,uBACA,iBACA,QAtBA,KACA,MAAsB,QAAa,iBACnC,GACA,uBACA,sBAIA,CAFA,KACA,WACA,wBACA,uBACA,EACA,EACA,MAGA,IACA,CAOA,EACA,KACA,+BACA,EACA,MAEA,mBACA,gFACA,SAAuB,uCAAiD,EAExE,UACY,QAAgB,eAC5B,SACA,aACA,OACA,CAAS,EAEE,QAAgB,MAC3B,yBACA,EACA,MAEA,2BACA,gBACA,EACA,OAGA,iBACA,EA4CA,OA3CA,QAAoB,QAAa,EACjC,iCACA,aACA,sBACA,cACA,eAMA,WAA+B,gBAAgB,qBAC/C,MACA,CACA,IACA,eACA,CAAU,SACV,KACA,MACA,CACA,mCACA,2BACA,EACA,iBACA,MAEA,iBACA,CAAO,CACP,UACA,eACA,SAAyB,qCAAqC,CAC9D,CAAO,CACP,aACA,SAAyB,aAAe,CACxC,CAAO,CACP,gBACA,SAAyB,gBAAkB,CAC3C,CAAO,CACP,sBACA,gCACA,kCACA,aACA,CAAK,EACL,eACA,CACA,MAmEA,YAlEA,IACA,eACA,aACA,OACA,KACA,iCACA,2BAEA,aACA,OACA,KACA,oBACA,CACA,gBACA,OACA,KACA,sBACA,CACA,aACA,OACA,KACA,0BACA,sBACA,CACA,eACA,OACA,KACA,YACA,oCACA,0CACA,WACA,iBACA,iBACA,eACA,mBACA,oBACA,uBACA,EAEA,aACA,cACA,GAAc,QAAgB,uBAC9B,OAAqB,+BAErB,OACA,KACA,QACA,sCACA,0BACA,wCACA,qBACA,mBACA,cACA,CACA,kBACA,OACA,KACA,gBACA,CACA,gBACA,OACA,KACA,WAEA,CACA,GACA,YACI,GAAa,YACjB,2BACA,iBACA,CAAO,EACP,gBAA2B,mCAAsC,CACjE,CAAK,CACL,CACA,EACA,gBACA,OACA,oBACA,wBACA,YAAiB,QAAQ,oCACzB,gBACA,WACA,gBACA,EAEA,gECpWA,uBAAuD,iBAAqB,MAC5E,iDCUM,MAAI,cAAgB,CAAC,GAAK,EAC9B,CAAC,MAAQ,EAAE,EAAG,CAAc,gBAAK,SAAU,EAC3C,CAAC,MAAQ,EAAE,EAAG,CAAc,gBAAK,SAAU,EAC5C,2GCOD,EAlBA,CACA,IACA,SACA,MACA,OACA,KACA,KACA,MACA,QACA,QACA,KACA,MACA,KACA,IACA,OACA,MACA,KACA,CACA,eACA,MAAe,YAAgB,SAC/B,YAAY,QAA6B,EACzC,IAA2B,IAAI,GAI/B,MAHA,4BACA,oCAE2B,SAAG,IAAS,WAAsC,CAC7E,CAAG,EAEH,OADA,2BAAkC,EAAK,EACvC,CAAW,WACX,CAAC,GAAI,EACL,gBACA,GAAc,WAAkB,wBAChC,gECtBA,gCAA+D,EAAM,cAC9D,EAAW,GAAI,CACf,aACP,MACA,mGACA,aAAgB,qBAA4B,EAC5C,yBACA,0BACA,sBACA,wBACA,iBACA,eACS,EACT,sCACA,kBACA,YAGA,SAFA,CAIA,CAAS,GAAI,EAkBb,aAjBA,iFACA,IAAkB,0BAAoE,EACtF,mCACA,WACA,oCACA,KACA,KACiB,OACjB,KACA,KACA,CAAiB,OACjB,CAAa,MACb,EACA,EACA,EACA,EACA,CAAS,KACT,kDACA,aCrDA,WAAkB,OAAS,0DAA8D,uKCezF,SAAS,EAAiE,GAAc,IAKhF,EAAgB,EAAO,qBACvB,CAAC,EAAyB,EAAqB,CAAI,OAAkB,CAAC,GAUtE,CAAC,EAAwB,EAAoB,CAAI,CAVF,CAWnD,EAXuF,CAYrF,YAF+C,EAEhC,CAAE,QAAS,IAAK,EAAG,QAAS,IAAI,GAAM,CAAF,EAGjD,EAA4E,IAChF,GAAM,OAAE,WAAO,EAAS,CAAI,EACtB,EAAM,QAAM,CAA0B,IAAI,EAC1C,EAAU,QAAM,CAAgC,IAAI,IAAI,CAAC,OAAE,CACjE,MACE,UAAC,SAAuB,UAAc,EAAkB,cAAe,WACpE,EACH,CAEJ,EAEA,EAAmB,YAAc,EAMjC,IAAM,EAAuB,EAAO,iBAE9B,EAAiB,YAAM,CAC3B,CAAC,EAAO,KACN,GAAM,OAAE,WAAO,EAAS,CAAI,EACtB,EAAU,EAAqB,EAAsB,GACrD,EAD0D,CAC3C,MAAe,CAAC,EAAc,EAAQ,aAAa,EACxE,MAAO,UAAC,IAAI,CAAJ,CAAK,IAAK,WAAe,EAAS,CAC5C,GAGF,EAAe,YAAc,EAM7B,IAAM,EAAiB,EAAO,qBACxB,EAAiB,6BAOjB,EAAqB,YAAM,CAC/B,CAAC,EAAO,KACN,GAAM,OAAE,WAAO,EAAU,GAAG,EAAS,CAAI,EACnC,EAAM,EADyB,MACnB,CAAoB,IAAI,EACpC,EAAe,OAAe,CAAC,EAAc,GAC7C,EAAU,EAAqB,EAAgB,GAOrD,EAP0D,KAE1D,WAAM,CAAU,KACd,EAAQ,QAAQ,IAAI,EAAK,CAAE,MAAK,GAAI,EAAkC,EAC/D,IAAM,KAAK,EAAQ,QAAQ,OAAO,GAAG,EAI5C,UAAC,IAAI,CAAJ,CAAW,CAAC,EAAc,CAAG,GAAM,IAAK,IAAd,OACxB,EACH,CAEJ,UAGF,EAAmB,YAAc,EAuB1B,CACL,CAAE,SAAU,EAAoB,KAAM,EAAgB,SAAU,CAAmB,EAlBrF,SAAS,CAAc,EAAY,IAC3B,EAAU,EAAqB,EAAO,qBAAsB,GAalE,EAbuE,KAahE,EAXU,WAAM,CAAY,KACjC,IAAM,EAAiB,EAAQ,cAAc,QAC7C,GAAI,CAAC,EAAgB,MAAO,CAAC,EAC7B,IAAM,EAAe,MAAM,KAAK,EAAe,iBAAiB,IAAkB,EAAG,CAAC,IAAlB,EAAc,OAKlF,KALkF,EAE7D,MADD,KAAK,EAAQ,QAAQ,OAAO,CAAC,EACtB,KACzB,CAAC,EAAG,IAAM,EAAa,QAAQ,EAAE,IAAI,OAAQ,EAAI,EAAa,QAAQ,EAAE,IAAI,OAAQ,EAGxF,EAAG,CAAC,EAAQ,cAAe,EAAQ,OAAO,CAAC,CAG7C,EAKE,EACF,gCC7HF,yCAAuE,MAAkC,EAAI,EAC7G,mBAEA,GADA,OACA,4BACA,aAEA,CACA,gHCHA,gBAA+B,GAAY,CAC3C,gBAAyB,EACzB,QACA,cACA,eACA,CACA,GACA,aACA,iBACA,eAA2C,QAAqB,MAChE,cAYA,OAXA,IACA,MAAkB,GAAK,EACvB,WACA,WACA,YACA,iCACA,QACA,oCACA,CAAO,EACP,aAEA,CACA,CACA,OACA,2BACA,2BACA,aACA,aACA,OACA,CAAO,EAEP,CACA,UACA,+BACA,IACA,YACA,OACA,4BAEA,aAAoB,uBAAwB,EAE5C,CACA,QACI,GAAa,YACjB,0BACA,cACA,CAAO,CACP,CAAK,CACL,CACA,OACA,qBACA,CACA,SACA,4BAEA,QACA,OAA+B,eAC/B,0BACA,GAAiB,QAAU,MAE3B,CACA,YAAsB,EACtB,oBACA,2CAAuE,QAAU,QACjF,CACA,UACI,GAAa,YACjB,2BACA,IACA,CAAO,CACP,CAAK,CACL,CACA,UACI,GAAa,YACjB,0BACA,WACA,CAAO,CACP,CAAK,CACL,CACA,WACI,GAAa,YACjB,0BACA,YACA,CAAO,CACP,CAAK,CACL,CACA,aCvFA,gBAAkC,GAAY,CAC9C,gBAAyB,EACzB,QACA,cACA,gBACA,gBACA,SACA,CACA,IACA,GACA,EACA,aACA,UAAyB,GAAQ,EACjC,mBACA,qBACA,oCACA,OACA,CAAK,EAEL,OADA,YACA,CACA,CACA,OACA,eACA,WACA,uBACA,qBACA,EACA,UAEA,kBAEA,CACA,aAAkB,wBAAyB,CAC3C,CACA,UACA,sBACA,WACA,uBACA,qBACA,MACA,eACA,kBACA,SACA,aAEA,EAAY,cACZ,kBAGA,CACA,CACA,aAAkB,0BAA2B,CAC7C,CACA,UACA,WACA,sBAOA,QAPA,EACA,qBACA,UACA,+BAEA,eACA,CAGA,CAHM,QAIN,GACA,WACA,sBAIA,wBAJA,EACA,uDACA,uCACA,CAGA,CAHM,OAIN,CACI,GAAa,YACjB,oBACA,aAAsB,0BAA2B,CACjD,CAAO,EACP,gBACA,eACA,CAAK,CACL,CACA,SACA,0BACA,CACA,QACA,OAA+B,eAC/B,0BACA,GAAoB,QAAa,MAEjC,CACA,YAAsB,EACtB,+BAA8C,QAAa,MAC3D,CACA,UACI,GAAa,YACjB,2BACA,IACA,CAAO,CACP,CAAK,CACL,CACA,wBACA,gDACA,OAAW,GAAa,OACxB,gBACA,4BAAoE,IAAI,IAGxE,CACA,EACA,cACA,0BACA,2BCpHA,cACA,OACA,gBACA,gBACA,6CACA,0BACA,+BACA,GAAqB,wBACrB,IACA,YACA,SACA,MACA,kCACA,cACA,SACA,iBACA,KAEA,uCACA,IACA,CAAiB,EAEjB,SAEA,CAAW,CACX,EACA,EAAwB,QAAa,2BACrC,iBACA,KACA,wBAEA,2BACA,0BAEA,OACA,oBACA,YACA,iCACA,qBAEA,KACA,cACA,GAEA,UAAkB,GAAW,UAC7B,IAAmC,IAAU,CAAG,IAAQ,CACxD,OACA,qBACA,8BACA,CACA,EACA,gBACA,qBAEA,GACA,QACA,YACA,EACA,EALA,GA+CA,YAAyC,qBAAmB,EAC5D,gEACA,EAjDA,GAKA,KACA,gBACA,EAAU,IACV,kBACA,GACA,4CACA,gBACA,MAEA,eACA,GACA,EAAY,UAEZ,QACA,CACA,qBACA,cACA,sBACA,EACA,CACA,oBACA,oBACA,eACA,CAAa,CACb,GAIA,WAEA,CACA,CACA,CACA,oBAAqC,eAAmB,EACxD,iBACA,qCACA,KACA,EACA,KACA,GACA,MACA,CCrFA,YACA,IACA,GACA,GACA,GACA,GACA,GACA,GACA,cACA,IAAyB,EACzB,0BAAgD,EAChD,6BAAsD,EACtD,WADmE,aACnE,KACA,gBACA,gBACA,SACA,CACA,QACA,UACA,cAEA,QAA6B,GAAY,qBACzC,IACA,mCACA,kBAEA,CAAK,EACL,QAA8B,GAAa,qBAC3C,IACA,mCACA,mBAEA,CAAK,EACL,CACA,UACA,UACA,cAEA,YACA,eACA,YACA,eACA,CACA,cACA,wBAAsC,4BAAqC,SAE3E,cACA,wBAAyC,sBAA+B,SAExE,gBACA,yCAA+C,EAAU,EACzD,2CACA,CACA,mBACA,kCACA,wBACA,sBACA,WACA,oBAEA,qCAAyD,QAAgB,kBACzE,sBAEA,mBACA,CACA,kBACA,yCAAoD,UAAiB,GAErE,GADA,OACA,CAEA,CACA,oBACA,yCAAwD,EAAU,EAClE,cACA,aAEA,gBACA,EAAiB,QAAgB,MACjC,cAGA,wCAA0E,eAA0B,CACpG,CACA,sBACA,OAAW,GAAa,OACxB,6BAAqD,WAAU,IAC/D,EACA,yBACA,EAEA,CACA,iBACA,yCAA+C,EAAU,EACzD,mBACA,cACA,KACA,CACA,iBACA,cACI,GAAa,YACjB,yBACA,WACA,CAAO,CACP,CAAK,CACL,CACA,kBACA,cACA,GACA,cACA,MAEA,OAAW,GAAa,YACxB,yBACA,SACA,CAAO,EACP,0BAEA,CACA,oBAA2C,EAC3C,OAAqC,gBAIrC,mBAHqB,GAAa,OAClC,6CAEA,KAAsC,IAAI,QAAQ,IAAI,CACtD,CACA,wBAAyC,EACzC,OAAW,GAAa,YAIxB,GAHA,+BACA,cACA,CAAO,EACP,wBACA,yBAEA,OACA,KACA,sCACA,EACA,+BACA,CAAK,CACL,CACA,qBAAsC,EACtC,OACA,KACA,iCACA,EAUA,mBATqB,GAAa,OAClC,0DACA,wBAIA,OAHA,gBACA,WAAkC,KAAI,EAEtC,kDACA,CAAO,IAEP,KAAsC,IAAI,CAC1C,CACA,cACA,iCACA,mBACA,aAEA,4BACA,uBACM,QAAgB,iBACtB,wCACA,CACA,iBACA,+BAAyC,IAAI,QAAQ,IAAI,CACzD,CACA,sBAEA,OADA,WAAuB,EAAqB,SAC5C,UAD4C,KAC5C,GACA,CACA,yBACA,uCAAiD,IAAI,QAAQ,IAAI,CACjE,CACA,2BAEA,OADA,WAAuB,EAAqB,SAC5C,UAD4C,UAC5C,GACA,CACA,+BACA,EAAQ,CAAa,YACrB,gCAEA,iBACA,CACA,gBACA,eAEA,mBACA,eAEA,oBACA,eAEA,qBACA,SACA,CACA,sBACA,YAA4B,QAAO,KACnC,WACA,gBACA,CAAK,CACL,CACA,oBACA,4BACA,KAMA,OALA,cACU,QAAe,gBACzB,iCAEA,CAAK,EACL,CACA,CACA,yBACA,YAA+B,QAAO,KACtC,cACA,gBACA,CAAK,CACL,CACA,uBACA,4BACA,KAMA,OALA,cACU,QAAe,mBACzB,IAAmB,0BAEnB,CAAK,EACL,CACA,CACA,uBACA,gBACA,SAEA,OACA,mBACA,qCACA,KACA,aACA,EAmBA,OAlBA,aACA,aAAmC,QAAqB,CACxD,WACA,EACA,EAEA,+BACA,gDAEA,yBACA,8BAEA,6BACA,+BAEA,YAAqC,IAAS,EAC9C,eAEA,CACA,CACA,iCACA,cACA,EAEA,CACA,qBACA,2DACA,KACA,aACA,CACA,CACA,QACA,gBACA,eACA,CACA,sFC/RA,EAAW,YAAgB,SAC3B,IAAU,iBAAyB,EACnC,EAAwB,UAAc,YACtC,YACA,MACA,uBACA,WACA,MAIA,EAHA,EAAY,QAAc,YAA+B,UAAc,YACxD,gBAAoB,2BAKnC,MAA2B,SAAG,IAAc,oBAA2C,gBAAoB,IAAe,cAAkB,kBAA0C,CACtL,CACA,MAAyB,SAAG,IAAc,sBAA2C,CACrF,CAAC,CACD,sBACA,MAAgB,YAAgB,SAChC,aAAU,QAAyB,EACnC,GAAM,gBAAoB,KAC1B,eAuCA,GACA,0DACA,mDACA,EACA,MAGA,GADA,mDACA,wCAEA,YAEA,kBACA,EAnDA,GACA,OAAW,cAAkB,IAC7B,YAcA,KACA,OAA0B,MAC1B,gBACA,WACA,OACA,mBAEA,KACA,cACA,QACA,OACA,EACQ,GACR,SAEM,YACN,MAAkC,WAC5B,iBACN,sCAEA,CACA,OAAW,UACX,EApCA,WAEA,MAA0B,OAAW,OACrC,CAAK,CACL,CACA,OAAS,UAAc,YAAuB,UAAc,gBAC5D,CAAC,EACD,0BACA,iBAAmB,EAAU,GACJ,SAAG,CAAC,UAAQ,WAAI,EAAU,EAEnD,cACA,OAAS,gBAAoB,eAC7B","sources":["webpack://_N_E/./node_modules/@radix-ui/react-visually-hidden/dist/index.mjs","webpack://_N_E/./node_modules/@radix-ui/react-use-controllable-state/dist/index.mjs","webpack://_N_E/./node_modules/@radix-ui/react-compose-refs/dist/index.mjs","webpack://_N_E/./node_modules/@radix-ui/react-use-escape-keydown/dist/index.mjs","webpack://_N_E/../src/DismissableLayer.tsx","webpack://_N_E/../../../../../shared/src/utils.ts","webpack://_N_E/../defaultAttributes.ts","webpack://_N_E/../Icon.ts","webpack://_N_E/../createLucideIcon.ts","webpack://_N_E/../src/Toast.tsx","webpack://_N_E/../src/Presence.tsx","webpack://_N_E/../src/useStateMachine.tsx","webpack://_N_E/../src/Portal.tsx","webpack://_N_E/./node_modules/@radix-ui/react-use-callback-ref/dist/index.mjs","webpack://_N_E/./node_modules/@tanstack/query-core/build/modern/query.js","webpack://_N_E/./node_modules/@radix-ui/react-use-layout-effect/dist/index.mjs","webpack://_N_E/../../../src/icons/x.ts","webpack://_N_E/./node_modules/@radix-ui/react-primitive/dist/index.mjs","webpack://_N_E/./node_modules/class-variance-authority/dist/index.mjs","webpack://_N_E/./node_modules/next/font/google/target.css","webpack://_N_E/../src/Collection.tsx","webpack://_N_E/./node_modules/@radix-ui/primitive/dist/index.mjs","webpack://_N_E/./node_modules/@tanstack/query-core/build/modern/queryCache.js","webpack://_N_E/./node_modules/@tanstack/query-core/build/modern/mutationCache.js","webpack://_N_E/./node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js","webpack://_N_E/./node_modules/@tanstack/query-core/build/modern/queryClient.js","webpack://_N_E/./node_modules/@radix-ui/react-slot/dist/index.mjs"],"sourcesContent":["// packages/react/visually-hidden/src/VisuallyHidden.tsx\nimport * as React from \"react\";\nimport { Primitive } from \"@radix-ui/react-primitive\";\nimport { jsx } from \"react/jsx-runtime\";\nvar NAME = \"VisuallyHidden\";\nvar VisuallyHidden = React.forwardRef(\n  (props, forwardedRef) => {\n    return /* @__PURE__ */ jsx(\n      Primitive.span,\n      {\n        ...props,\n        ref: forwardedRef,\n        style: {\n          // See: https://github.com/twbs/bootstrap/blob/main/scss/mixins/_visually-hidden.scss\n          position: \"absolute\",\n          border: 0,\n          width: 1,\n          height: 1,\n          padding: 0,\n          margin: -1,\n          overflow: \"hidden\",\n          clip: \"rect(0, 0, 0, 0)\",\n          whiteSpace: \"nowrap\",\n          wordWrap: \"normal\",\n          ...props.style\n        }\n      }\n    );\n  }\n);\nVisuallyHidden.displayName = NAME;\nvar Root = VisuallyHidden;\nexport {\n  Root,\n  VisuallyHidden\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/use-controllable-state/src/useControllableState.tsx\nimport * as React from \"react\";\nimport { useCallbackRef } from \"@radix-ui/react-use-callback-ref\";\nfunction useControllableState({\n  prop,\n  defaultProp,\n  onChange = () => {\n  }\n}) {\n  const [uncontrolledProp, setUncontrolledProp] = useUncontrolledState({ defaultProp, onChange });\n  const isControlled = prop !== void 0;\n  const value = isControlled ? prop : uncontrolledProp;\n  const handleChange = useCallbackRef(onChange);\n  const setValue = React.useCallback(\n    (nextValue) => {\n      if (isControlled) {\n        const setter = nextValue;\n        const value2 = typeof nextValue === \"function\" ? setter(prop) : nextValue;\n        if (value2 !== prop) handleChange(value2);\n      } else {\n        setUncontrolledProp(nextValue);\n      }\n    },\n    [isControlled, prop, setUncontrolledProp, handleChange]\n  );\n  return [value, setValue];\n}\nfunction useUncontrolledState({\n  defaultProp,\n  onChange\n}) {\n  const uncontrolledState = React.useState(defaultProp);\n  const [value] = uncontrolledState;\n  const prevValueRef = React.useRef(value);\n  const handleChange = useCallbackRef(onChange);\n  React.useEffect(() => {\n    if (prevValueRef.current !== value) {\n      handleChange(value);\n      prevValueRef.current = value;\n    }\n  }, [value, prevValueRef, handleChange]);\n  return uncontrolledState;\n}\nexport {\n  useControllableState\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/compose-refs/src/composeRefs.tsx\nimport * as React from \"react\";\nfunction setRef(ref, value) {\n  if (typeof ref === \"function\") {\n    return ref(value);\n  } else if (ref !== null && ref !== void 0) {\n    ref.current = value;\n  }\n}\nfunction composeRefs(...refs) {\n  return (node) => {\n    let hasCleanup = false;\n    const cleanups = refs.map((ref) => {\n      const cleanup = setRef(ref, node);\n      if (!hasCleanup && typeof cleanup == \"function\") {\n        hasCleanup = true;\n      }\n      return cleanup;\n    });\n    if (hasCleanup) {\n      return () => {\n        for (let i = 0; i < cleanups.length; i++) {\n          const cleanup = cleanups[i];\n          if (typeof cleanup == \"function\") {\n            cleanup();\n          } else {\n            setRef(refs[i], null);\n          }\n        }\n      };\n    }\n  };\n}\nfunction useComposedRefs(...refs) {\n  return React.useCallback(composeRefs(...refs), refs);\n}\nexport {\n  composeRefs,\n  useComposedRefs\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/use-escape-keydown/src/useEscapeKeydown.tsx\nimport * as React from \"react\";\nimport { useCallbackRef } from \"@radix-ui/react-use-callback-ref\";\nfunction useEscapeKeydown(onEscapeKeyDownProp, ownerDocument = globalThis?.document) {\n  const onEscapeKeyDown = useCallbackRef(onEscapeKeyDownProp);\n  React.useEffect(() => {\n    const handleKeyDown = (event) => {\n      if (event.key === \"Escape\") {\n        onEscapeKeyDown(event);\n      }\n    };\n    ownerDocument.addEventListener(\"keydown\", handleKeyDown, { capture: true });\n    return () => ownerDocument.removeEventListener(\"keydown\", handleKeyDown, { capture: true });\n  }, [onEscapeKeyDown, ownerDocument]);\n}\nexport {\n  useEscapeKeydown\n};\n//# sourceMappingURL=index.mjs.map\n","import * as React from 'react';\nimport { composeEventHandlers } from '@radix-ui/primitive';\nimport { Primitive, dispatchDiscreteCustomEvent } from '@radix-ui/react-primitive';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { useCallbackRef } from '@radix-ui/react-use-callback-ref';\nimport { useEscapeKeydown } from '@radix-ui/react-use-escape-keydown';\n\n/* -------------------------------------------------------------------------------------------------\n * DismissableLayer\n * -----------------------------------------------------------------------------------------------*/\n\nconst DISMISSABLE_LAYER_NAME = 'DismissableLayer';\nconst CONTEXT_UPDATE = 'dismissableLayer.update';\nconst POINTER_DOWN_OUTSIDE = 'dismissableLayer.pointerDownOutside';\nconst FOCUS_OUTSIDE = 'dismissableLayer.focusOutside';\n\nlet originalBodyPointerEvents: string;\n\nconst DismissableLayerContext = React.createContext({\n  layers: new Set<DismissableLayerElement>(),\n  layersWithOutsidePointerEventsDisabled: new Set<DismissableLayerElement>(),\n  branches: new Set<DismissableLayerBranchElement>(),\n});\n\ntype DismissableLayerElement = React.ElementRef<typeof Primitive.div>;\ntype PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface DismissableLayerProps extends PrimitiveDivProps {\n  /**\n   * When `true`, hover/focus/click interactions will be disabled on elements outside\n   * the `DismissableLayer`. Users will need to click twice on outside elements to\n   * interact with them: once to close the `DismissableLayer`, and again to trigger the element.\n   */\n  disableOutsidePointerEvents?: boolean;\n  /**\n   * Event handler called when the escape key is down.\n   * Can be prevented.\n   */\n  onEscapeKeyDown?: (event: KeyboardEvent) => void;\n  /**\n   * Event handler called when the a `pointerdown` event happens outside of the `DismissableLayer`.\n   * Can be prevented.\n   */\n  onPointerDownOutside?: (event: PointerDownOutsideEvent) => void;\n  /**\n   * Event handler called when the focus moves outside of the `DismissableLayer`.\n   * Can be prevented.\n   */\n  onFocusOutside?: (event: FocusOutsideEvent) => void;\n  /**\n   * Event handler called when an interaction happens outside the `DismissableLayer`.\n   * Specifically, when a `pointerdown` event happens outside or focus moves outside of it.\n   * Can be prevented.\n   */\n  onInteractOutside?: (event: PointerDownOutsideEvent | FocusOutsideEvent) => void;\n  /**\n   * Handler called when the `DismissableLayer` should be dismissed\n   */\n  onDismiss?: () => void;\n}\n\nconst DismissableLayer = React.forwardRef<DismissableLayerElement, DismissableLayerProps>(\n  (props, forwardedRef) => {\n    const {\n      disableOutsidePointerEvents = false,\n      onEscapeKeyDown,\n      onPointerDownOutside,\n      onFocusOutside,\n      onInteractOutside,\n      onDismiss,\n      ...layerProps\n    } = props;\n    const context = React.useContext(DismissableLayerContext);\n    const [node, setNode] = React.useState<DismissableLayerElement | null>(null);\n    const ownerDocument = node?.ownerDocument ?? globalThis?.document;\n    const [, force] = React.useState({});\n    const composedRefs = useComposedRefs(forwardedRef, (node) => setNode(node));\n    const layers = Array.from(context.layers);\n    const [highestLayerWithOutsidePointerEventsDisabled] = [...context.layersWithOutsidePointerEventsDisabled].slice(-1); // prettier-ignore\n    const highestLayerWithOutsidePointerEventsDisabledIndex = layers.indexOf(highestLayerWithOutsidePointerEventsDisabled); // prettier-ignore\n    const index = node ? layers.indexOf(node) : -1;\n    const isBodyPointerEventsDisabled = context.layersWithOutsidePointerEventsDisabled.size > 0;\n    const isPointerEventsEnabled = index >= highestLayerWithOutsidePointerEventsDisabledIndex;\n\n    const pointerDownOutside = usePointerDownOutside((event) => {\n      const target = event.target as HTMLElement;\n      const isPointerDownOnBranch = [...context.branches].some((branch) => branch.contains(target));\n      if (!isPointerEventsEnabled || isPointerDownOnBranch) return;\n      onPointerDownOutside?.(event);\n      onInteractOutside?.(event);\n      if (!event.defaultPrevented) onDismiss?.();\n    }, ownerDocument);\n\n    const focusOutside = useFocusOutside((event) => {\n      const target = event.target as HTMLElement;\n      const isFocusInBranch = [...context.branches].some((branch) => branch.contains(target));\n      if (isFocusInBranch) return;\n      onFocusOutside?.(event);\n      onInteractOutside?.(event);\n      if (!event.defaultPrevented) onDismiss?.();\n    }, ownerDocument);\n\n    useEscapeKeydown((event) => {\n      const isHighestLayer = index === context.layers.size - 1;\n      if (!isHighestLayer) return;\n      onEscapeKeyDown?.(event);\n      if (!event.defaultPrevented && onDismiss) {\n        event.preventDefault();\n        onDismiss();\n      }\n    }, ownerDocument);\n\n    React.useEffect(() => {\n      if (!node) return;\n      if (disableOutsidePointerEvents) {\n        if (context.layersWithOutsidePointerEventsDisabled.size === 0) {\n          originalBodyPointerEvents = ownerDocument.body.style.pointerEvents;\n          ownerDocument.body.style.pointerEvents = 'none';\n        }\n        context.layersWithOutsidePointerEventsDisabled.add(node);\n      }\n      context.layers.add(node);\n      dispatchUpdate();\n      return () => {\n        if (\n          disableOutsidePointerEvents &&\n          context.layersWithOutsidePointerEventsDisabled.size === 1\n        ) {\n          ownerDocument.body.style.pointerEvents = originalBodyPointerEvents;\n        }\n      };\n    }, [node, ownerDocument, disableOutsidePointerEvents, context]);\n\n    /**\n     * We purposefully prevent combining this effect with the `disableOutsidePointerEvents` effect\n     * because a change to `disableOutsidePointerEvents` would remove this layer from the stack\n     * and add it to the end again so the layering order wouldn't be _creation order_.\n     * We only want them to be removed from context stacks when unmounted.\n     */\n    React.useEffect(() => {\n      return () => {\n        if (!node) return;\n        context.layers.delete(node);\n        context.layersWithOutsidePointerEventsDisabled.delete(node);\n        dispatchUpdate();\n      };\n    }, [node, context]);\n\n    React.useEffect(() => {\n      const handleUpdate = () => force({});\n      document.addEventListener(CONTEXT_UPDATE, handleUpdate);\n      return () => document.removeEventListener(CONTEXT_UPDATE, handleUpdate);\n    }, []);\n\n    return (\n      <Primitive.div\n        {...layerProps}\n        ref={composedRefs}\n        style={{\n          pointerEvents: isBodyPointerEventsDisabled\n            ? isPointerEventsEnabled\n              ? 'auto'\n              : 'none'\n            : undefined,\n          ...props.style,\n        }}\n        onFocusCapture={composeEventHandlers(props.onFocusCapture, focusOutside.onFocusCapture)}\n        onBlurCapture={composeEventHandlers(props.onBlurCapture, focusOutside.onBlurCapture)}\n        onPointerDownCapture={composeEventHandlers(\n          props.onPointerDownCapture,\n          pointerDownOutside.onPointerDownCapture\n        )}\n      />\n    );\n  }\n);\n\nDismissableLayer.displayName = DISMISSABLE_LAYER_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * DismissableLayerBranch\n * -----------------------------------------------------------------------------------------------*/\n\nconst BRANCH_NAME = 'DismissableLayerBranch';\n\ntype DismissableLayerBranchElement = React.ElementRef<typeof Primitive.div>;\ninterface DismissableLayerBranchProps extends PrimitiveDivProps {}\n\nconst DismissableLayerBranch = React.forwardRef<\n  DismissableLayerBranchElement,\n  DismissableLayerBranchProps\n>((props, forwardedRef) => {\n  const context = React.useContext(DismissableLayerContext);\n  const ref = React.useRef<DismissableLayerBranchElement>(null);\n  const composedRefs = useComposedRefs(forwardedRef, ref);\n\n  React.useEffect(() => {\n    const node = ref.current;\n    if (node) {\n      context.branches.add(node);\n      return () => {\n        context.branches.delete(node);\n      };\n    }\n  }, [context.branches]);\n\n  return <Primitive.div {...props} ref={composedRefs} />;\n});\n\nDismissableLayerBranch.displayName = BRANCH_NAME;\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype PointerDownOutsideEvent = CustomEvent<{ originalEvent: PointerEvent }>;\ntype FocusOutsideEvent = CustomEvent<{ originalEvent: FocusEvent }>;\n\n/**\n * Listens for `pointerdown` outside a react subtree. We use `pointerdown` rather than `pointerup`\n * to mimic layer dismissing behaviour present in OS.\n * Returns props to pass to the node we want to check for outside events.\n */\nfunction usePointerDownOutside(\n  onPointerDownOutside?: (event: PointerDownOutsideEvent) => void,\n  ownerDocument: Document = globalThis?.document\n) {\n  const handlePointerDownOutside = useCallbackRef(onPointerDownOutside) as EventListener;\n  const isPointerInsideReactTreeRef = React.useRef(false);\n  const handleClickRef = React.useRef(() => {});\n\n  React.useEffect(() => {\n    const handlePointerDown = (event: PointerEvent) => {\n      if (event.target && !isPointerInsideReactTreeRef.current) {\n        const eventDetail = { originalEvent: event };\n\n        function handleAndDispatchPointerDownOutsideEvent() {\n          handleAndDispatchCustomEvent(\n            POINTER_DOWN_OUTSIDE,\n            handlePointerDownOutside,\n            eventDetail,\n            { discrete: true }\n          );\n        }\n\n        /**\n         * On touch devices, we need to wait for a click event because browsers implement\n         * a ~350ms delay between the time the user stops touching the display and when the\n         * browser executres events. We need to ensure we don't reactivate pointer-events within\n         * this timeframe otherwise the browser may execute events that should have been prevented.\n         *\n         * Additionally, this also lets us deal automatically with cancellations when a click event\n         * isn't raised because the page was considered scrolled/drag-scrolled, long-pressed, etc.\n         *\n         * This is why we also continuously remove the previous listener, because we cannot be\n         * certain that it was raised, and therefore cleaned-up.\n         */\n        if (event.pointerType === 'touch') {\n          ownerDocument.removeEventListener('click', handleClickRef.current);\n          handleClickRef.current = handleAndDispatchPointerDownOutsideEvent;\n          ownerDocument.addEventListener('click', handleClickRef.current, { once: true });\n        } else {\n          handleAndDispatchPointerDownOutsideEvent();\n        }\n      } else {\n        // We need to remove the event listener in case the outside click has been canceled.\n        // See: https://github.com/radix-ui/primitives/issues/2171\n        ownerDocument.removeEventListener('click', handleClickRef.current);\n      }\n      isPointerInsideReactTreeRef.current = false;\n    };\n    /**\n     * if this hook executes in a component that mounts via a `pointerdown` event, the event\n     * would bubble up to the document and trigger a `pointerDownOutside` event. We avoid\n     * this by delaying the event listener registration on the document.\n     * This is not React specific, but rather how the DOM works, ie:\n     * ```\n     * button.addEventListener('pointerdown', () => {\n     *   console.log('I will log');\n     *   document.addEventListener('pointerdown', () => {\n     *     console.log('I will also log');\n     *   })\n     * });\n     */\n    const timerId = window.setTimeout(() => {\n      ownerDocument.addEventListener('pointerdown', handlePointerDown);\n    }, 0);\n    return () => {\n      window.clearTimeout(timerId);\n      ownerDocument.removeEventListener('pointerdown', handlePointerDown);\n      ownerDocument.removeEventListener('click', handleClickRef.current);\n    };\n  }, [ownerDocument, handlePointerDownOutside]);\n\n  return {\n    // ensures we check React component tree (not just DOM tree)\n    onPointerDownCapture: () => (isPointerInsideReactTreeRef.current = true),\n  };\n}\n\n/**\n * Listens for when focus happens outside a react subtree.\n * Returns props to pass to the root (node) of the subtree we want to check.\n */\nfunction useFocusOutside(\n  onFocusOutside?: (event: FocusOutsideEvent) => void,\n  ownerDocument: Document = globalThis?.document\n) {\n  const handleFocusOutside = useCallbackRef(onFocusOutside) as EventListener;\n  const isFocusInsideReactTreeRef = React.useRef(false);\n\n  React.useEffect(() => {\n    const handleFocus = (event: FocusEvent) => {\n      if (event.target && !isFocusInsideReactTreeRef.current) {\n        const eventDetail = { originalEvent: event };\n        handleAndDispatchCustomEvent(FOCUS_OUTSIDE, handleFocusOutside, eventDetail, {\n          discrete: false,\n        });\n      }\n    };\n    ownerDocument.addEventListener('focusin', handleFocus);\n    return () => ownerDocument.removeEventListener('focusin', handleFocus);\n  }, [ownerDocument, handleFocusOutside]);\n\n  return {\n    onFocusCapture: () => (isFocusInsideReactTreeRef.current = true),\n    onBlurCapture: () => (isFocusInsideReactTreeRef.current = false),\n  };\n}\n\nfunction dispatchUpdate() {\n  const event = new CustomEvent(CONTEXT_UPDATE);\n  document.dispatchEvent(event);\n}\n\nfunction handleAndDispatchCustomEvent<E extends CustomEvent, OriginalEvent extends Event>(\n  name: string,\n  handler: ((event: E) => void) | undefined,\n  detail: { originalEvent: OriginalEvent } & (E extends CustomEvent<infer D> ? D : never),\n  { discrete }: { discrete: boolean }\n) {\n  const target = detail.originalEvent.target;\n  const event = new CustomEvent(name, { bubbles: false, cancelable: true, detail });\n  if (handler) target.addEventListener(name, handler as EventListener, { once: true });\n\n  if (discrete) {\n    dispatchDiscreteCustomEvent(target, event);\n  } else {\n    target.dispatchEvent(event);\n  }\n}\n\nconst Root = DismissableLayer;\nconst Branch = DismissableLayerBranch;\n\nexport {\n  DismissableLayer,\n  DismissableLayerBranch,\n  //\n  Root,\n  Branch,\n};\nexport type { DismissableLayerProps };\n","import { CamelToPascal } from './utility-types';\n\n/**\n * Converts string to kebab case\n *\n * @param {string} string\n * @returns {string} A kebabized string\n */\nexport const toKebabCase = (string: string) =>\n  string.replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase();\n\n/**\n * Converts string to camel case\n *\n * @param {string} string\n * @returns {string} A camelized string\n */\nexport const toCamelCase = <T extends string>(string: T) =>\n  string.replace(/^([A-Z])|[\\s-_]+(\\w)/g, (match, p1, p2) =>\n    p2 ? p2.toUpperCase() : p1.toLowerCase(),\n  );\n\n/**\n * Converts string to pascal case\n *\n * @param {string} string\n * @returns {string} A pascalized string\n */\nexport const toPascalCase = <T extends string>(string: T): CamelToPascal<T> => {\n  const camelCase = toCamelCase(string);\n\n  return (camelCase.charAt(0).toUpperCase() + camelCase.slice(1)) as CamelToPascal<T>;\n};\n\n/**\n * Merges classes into a single string\n *\n * @param {array} classes\n * @returns {string} A string of classes\n */\nexport const mergeClasses = <ClassType = string | undefined | null>(...classes: ClassType[]) =>\n  classes\n    .filter((className, index, array) => {\n      return (\n        Boolean(className) &&\n        (className as string).trim() !== '' &&\n        array.indexOf(className) === index\n      );\n    })\n    .join(' ')\n    .trim();\n","export default {\n  xmlns: 'http://www.w3.org/2000/svg',\n  width: 24,\n  height: 24,\n  viewBox: '0 0 24 24',\n  fill: 'none',\n  stroke: 'currentColor',\n  strokeWidth: 2,\n  strokeLinecap: 'round',\n  strokeLinejoin: 'round',\n};\n","import { createElement, forwardRef } from 'react';\nimport defaultAttributes from './defaultAttributes';\nimport { IconNode, LucideProps } from './types';\nimport { mergeClasses } from '@lucide/shared';\n\ninterface IconComponentProps extends LucideProps {\n  iconNode: IconNode;\n}\n\n/**\n * Lucide icon component\n *\n * @component Icon\n * @param {object} props\n * @param {string} props.color - The color of the icon\n * @param {number} props.size - The size of the icon\n * @param {number} props.strokeWidth - The stroke width of the icon\n * @param {boolean} props.absoluteStrokeWidth - Whether to use absolute stroke width\n * @param {string} props.className - The class name of the icon\n * @param {IconNode} props.children - The children of the icon\n * @param {IconNode} props.iconNode - The icon node of the icon\n *\n * @returns {ForwardRefExoticComponent} LucideIcon\n */\nconst Icon = forwardRef<SVGSVGElement, IconComponentProps>(\n  (\n    {\n      color = 'currentColor',\n      size = 24,\n      strokeWidth = 2,\n      absoluteStrokeWidth,\n      className = '',\n      children,\n      iconNode,\n      ...rest\n    },\n    ref,\n  ) => {\n    return createElement(\n      'svg',\n      {\n        ref,\n        ...defaultAttributes,\n        width: size,\n        height: size,\n        stroke: color,\n        strokeWidth: absoluteStrokeWidth ? (Number(strokeWidth) * 24) / Number(size) : strokeWidth,\n        className: mergeClasses('lucide', className),\n        ...rest,\n      },\n      [\n        ...iconNode.map(([tag, attrs]) => createElement(tag, attrs)),\n        ...(Array.isArray(children) ? children : [children]),\n      ],\n    );\n  },\n);\n\nexport default Icon;\n","import { createElement, forwardRef } from 'react';\nimport { mergeClasses, toKebabCase } from '@lucide/shared';\nimport { IconNode, LucideProps } from './types';\nimport Icon from './Icon';\n\n/**\n * Create a Lucide icon component\n * @param {string} iconName\n * @param {array} iconNode\n * @returns {ForwardRefExoticComponent} LucideIcon\n */\nconst createLucideIcon = (iconName: string, iconNode: IconNode) => {\n  const Component = forwardRef<SVGSVGElement, LucideProps>(({ className, ...props }, ref) =>\n    createElement(Icon, {\n      ref,\n      iconNode,\n      className: mergeClasses(`lucide-${toKebabCase(iconName)}`, className),\n      ...props,\n    }),\n  );\n\n  Component.displayName = `${iconName}`;\n\n  return Component;\n};\n\nexport default createLucideIcon;\n","import * as React from 'react';\nimport * as ReactDOM from 'react-dom';\nimport { composeEventHandlers } from '@radix-ui/primitive';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { createCollection } from '@radix-ui/react-collection';\nimport { createContextScope } from '@radix-ui/react-context';\nimport * as DismissableLayer from '@radix-ui/react-dismissable-layer';\nimport { Portal } from '@radix-ui/react-portal';\nimport { Presence } from '@radix-ui/react-presence';\nimport { Primitive, dispatchDiscreteCustomEvent } from '@radix-ui/react-primitive';\nimport { useCallbackRef } from '@radix-ui/react-use-callback-ref';\nimport { useControllableState } from '@radix-ui/react-use-controllable-state';\nimport { useLayoutEffect } from '@radix-ui/react-use-layout-effect';\nimport { VisuallyHidden } from '@radix-ui/react-visually-hidden';\n\nimport type { Scope } from '@radix-ui/react-context';\n\n/* -------------------------------------------------------------------------------------------------\n * ToastProvider\n * -----------------------------------------------------------------------------------------------*/\n\nconst PROVIDER_NAME = 'ToastProvider';\n\nconst [Collection, useCollection, createCollectionScope] = createCollection<ToastElement>('Toast');\n\ntype SwipeDirection = 'up' | 'down' | 'left' | 'right';\ntype ToastProviderContextValue = {\n  label: string;\n  duration: number;\n  swipeDirection: SwipeDirection;\n  swipeThreshold: number;\n  toastCount: number;\n  viewport: ToastViewportElement | null;\n  onViewportChange(viewport: ToastViewportElement): void;\n  onToastAdd(): void;\n  onToastRemove(): void;\n  isFocusedToastEscapeKeyDownRef: React.MutableRefObject<boolean>;\n  isClosePausedRef: React.MutableRefObject<boolean>;\n};\n\ntype ScopedProps<P> = P & { __scopeToast?: Scope };\nconst [createToastContext, createToastScope] = createContextScope('Toast', [createCollectionScope]);\nconst [ToastProviderProvider, useToastProviderContext] =\n  createToastContext<ToastProviderContextValue>(PROVIDER_NAME);\n\ninterface ToastProviderProps {\n  children?: React.ReactNode;\n  /**\n   * An author-localized label for each toast. Used to help screen reader users\n   * associate the interruption with a toast.\n   * @defaultValue 'Notification'\n   */\n  label?: string;\n  /**\n   * Time in milliseconds that each toast should remain visible for.\n   * @defaultValue 5000\n   */\n  duration?: number;\n  /**\n   * Direction of pointer swipe that should close the toast.\n   * @defaultValue 'right'\n   */\n  swipeDirection?: SwipeDirection;\n  /**\n   * Distance in pixels that the swipe must pass before a close is triggered.\n   * @defaultValue 50\n   */\n  swipeThreshold?: number;\n}\n\nconst ToastProvider: React.FC<ToastProviderProps> = (props: ScopedProps<ToastProviderProps>) => {\n  const {\n    __scopeToast,\n    label = 'Notification',\n    duration = 5000,\n    swipeDirection = 'right',\n    swipeThreshold = 50,\n    children,\n  } = props;\n  const [viewport, setViewport] = React.useState<ToastViewportElement | null>(null);\n  const [toastCount, setToastCount] = React.useState(0);\n  const isFocusedToastEscapeKeyDownRef = React.useRef(false);\n  const isClosePausedRef = React.useRef(false);\n\n  if (!label.trim()) {\n    console.error(\n      `Invalid prop \\`label\\` supplied to \\`${PROVIDER_NAME}\\`. Expected non-empty \\`string\\`.`\n    );\n  }\n\n  return (\n    <Collection.Provider scope={__scopeToast}>\n      <ToastProviderProvider\n        scope={__scopeToast}\n        label={label}\n        duration={duration}\n        swipeDirection={swipeDirection}\n        swipeThreshold={swipeThreshold}\n        toastCount={toastCount}\n        viewport={viewport}\n        onViewportChange={setViewport}\n        onToastAdd={React.useCallback(() => setToastCount((prevCount) => prevCount + 1), [])}\n        onToastRemove={React.useCallback(() => setToastCount((prevCount) => prevCount - 1), [])}\n        isFocusedToastEscapeKeyDownRef={isFocusedToastEscapeKeyDownRef}\n        isClosePausedRef={isClosePausedRef}\n      >\n        {children}\n      </ToastProviderProvider>\n    </Collection.Provider>\n  );\n};\n\nToastProvider.displayName = PROVIDER_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * ToastViewport\n * -----------------------------------------------------------------------------------------------*/\n\nconst VIEWPORT_NAME = 'ToastViewport';\nconst VIEWPORT_DEFAULT_HOTKEY = ['F8'];\nconst VIEWPORT_PAUSE = 'toast.viewportPause';\nconst VIEWPORT_RESUME = 'toast.viewportResume';\n\ntype ToastViewportElement = React.ElementRef<typeof Primitive.ol>;\ntype PrimitiveOrderedListProps = React.ComponentPropsWithoutRef<typeof Primitive.ol>;\ninterface ToastViewportProps extends PrimitiveOrderedListProps {\n  /**\n   * The keys to use as the keyboard shortcut that will move focus to the toast viewport.\n   * @defaultValue ['F8']\n   */\n  hotkey?: string[];\n  /**\n   * An author-localized label for the toast viewport to provide context for screen reader users\n   * when navigating page landmarks. The available `{hotkey}` placeholder will be replaced for you.\n   * @defaultValue 'Notifications ({hotkey})'\n   */\n  label?: string;\n}\n\nconst ToastViewport = React.forwardRef<ToastViewportElement, ToastViewportProps>(\n  (props: ScopedProps<ToastViewportProps>, forwardedRef) => {\n    const {\n      __scopeToast,\n      hotkey = VIEWPORT_DEFAULT_HOTKEY,\n      label = 'Notifications ({hotkey})',\n      ...viewportProps\n    } = props;\n    const context = useToastProviderContext(VIEWPORT_NAME, __scopeToast);\n    const getItems = useCollection(__scopeToast);\n    const wrapperRef = React.useRef<HTMLDivElement>(null);\n    const headFocusProxyRef = React.useRef<FocusProxyElement>(null);\n    const tailFocusProxyRef = React.useRef<FocusProxyElement>(null);\n    const ref = React.useRef<ToastViewportElement>(null);\n    const composedRefs = useComposedRefs(forwardedRef, ref, context.onViewportChange);\n    const hotkeyLabel = hotkey.join('+').replace(/Key/g, '').replace(/Digit/g, '');\n    const hasToasts = context.toastCount > 0;\n\n    React.useEffect(() => {\n      const handleKeyDown = (event: KeyboardEvent) => {\n        // we use `event.code` as it is consistent regardless of meta keys that were pressed.\n        // for example, `event.key` for `Control+Alt+t` is `†` and `t !== †`\n        const isHotkeyPressed =\n          hotkey.length !== 0 && hotkey.every((key) => (event as any)[key] || event.code === key);\n        if (isHotkeyPressed) ref.current?.focus();\n      };\n      document.addEventListener('keydown', handleKeyDown);\n      return () => document.removeEventListener('keydown', handleKeyDown);\n    }, [hotkey]);\n\n    React.useEffect(() => {\n      const wrapper = wrapperRef.current;\n      const viewport = ref.current;\n      if (hasToasts && wrapper && viewport) {\n        const handlePause = () => {\n          if (!context.isClosePausedRef.current) {\n            const pauseEvent = new CustomEvent(VIEWPORT_PAUSE);\n            viewport.dispatchEvent(pauseEvent);\n            context.isClosePausedRef.current = true;\n          }\n        };\n\n        const handleResume = () => {\n          if (context.isClosePausedRef.current) {\n            const resumeEvent = new CustomEvent(VIEWPORT_RESUME);\n            viewport.dispatchEvent(resumeEvent);\n            context.isClosePausedRef.current = false;\n          }\n        };\n\n        const handleFocusOutResume = (event: FocusEvent) => {\n          const isFocusMovingOutside = !wrapper.contains(event.relatedTarget as HTMLElement);\n          if (isFocusMovingOutside) handleResume();\n        };\n\n        const handlePointerLeaveResume = () => {\n          const isFocusInside = wrapper.contains(document.activeElement);\n          if (!isFocusInside) handleResume();\n        };\n\n        // Toasts are not in the viewport React tree so we need to bind DOM events\n        wrapper.addEventListener('focusin', handlePause);\n        wrapper.addEventListener('focusout', handleFocusOutResume);\n        wrapper.addEventListener('pointermove', handlePause);\n        wrapper.addEventListener('pointerleave', handlePointerLeaveResume);\n        window.addEventListener('blur', handlePause);\n        window.addEventListener('focus', handleResume);\n        return () => {\n          wrapper.removeEventListener('focusin', handlePause);\n          wrapper.removeEventListener('focusout', handleFocusOutResume);\n          wrapper.removeEventListener('pointermove', handlePause);\n          wrapper.removeEventListener('pointerleave', handlePointerLeaveResume);\n          window.removeEventListener('blur', handlePause);\n          window.removeEventListener('focus', handleResume);\n        };\n      }\n    }, [hasToasts, context.isClosePausedRef]);\n\n    const getSortedTabbableCandidates = React.useCallback(\n      ({ tabbingDirection }: { tabbingDirection: 'forwards' | 'backwards' }) => {\n        const toastItems = getItems();\n        const tabbableCandidates = toastItems.map((toastItem) => {\n          const toastNode = toastItem.ref.current!;\n          const toastTabbableCandidates = [toastNode, ...getTabbableCandidates(toastNode)];\n          return tabbingDirection === 'forwards'\n            ? toastTabbableCandidates\n            : toastTabbableCandidates.reverse();\n        });\n        return (\n          tabbingDirection === 'forwards' ? tabbableCandidates.reverse() : tabbableCandidates\n        ).flat();\n      },\n      [getItems]\n    );\n\n    React.useEffect(() => {\n      const viewport = ref.current;\n      // We programmatically manage tabbing as we are unable to influence\n      // the source order with portals, this allows us to reverse the\n      // tab order so that it runs from most recent toast to least\n      if (viewport) {\n        const handleKeyDown = (event: KeyboardEvent) => {\n          const isMetaKey = event.altKey || event.ctrlKey || event.metaKey;\n          const isTabKey = event.key === 'Tab' && !isMetaKey;\n\n          if (isTabKey) {\n            const focusedElement = document.activeElement;\n            const isTabbingBackwards = event.shiftKey;\n            const targetIsViewport = event.target === viewport;\n\n            // If we're back tabbing after jumping to the viewport then we simply\n            // proxy focus out to the preceding document\n            if (targetIsViewport && isTabbingBackwards) {\n              headFocusProxyRef.current?.focus();\n              return;\n            }\n\n            const tabbingDirection = isTabbingBackwards ? 'backwards' : 'forwards';\n            const sortedCandidates = getSortedTabbableCandidates({ tabbingDirection });\n            const index = sortedCandidates.findIndex((candidate) => candidate === focusedElement);\n            if (focusFirst(sortedCandidates.slice(index + 1))) {\n              event.preventDefault();\n            } else {\n              // If we can't focus that means we're at the edges so we\n              // proxy to the corresponding exit point and let the browser handle\n              // tab/shift+tab keypress and implicitly pass focus to the next valid element in the document\n              isTabbingBackwards\n                ? headFocusProxyRef.current?.focus()\n                : tailFocusProxyRef.current?.focus();\n            }\n          }\n        };\n\n        // Toasts are not in the viewport React tree so we need to bind DOM events\n        viewport.addEventListener('keydown', handleKeyDown);\n        return () => viewport.removeEventListener('keydown', handleKeyDown);\n      }\n    }, [getItems, getSortedTabbableCandidates]);\n\n    return (\n      <DismissableLayer.Branch\n        ref={wrapperRef}\n        role=\"region\"\n        aria-label={label.replace('{hotkey}', hotkeyLabel)}\n        // Ensure virtual cursor from landmarks menus triggers focus/blur for pause/resume\n        tabIndex={-1}\n        // incase list has size when empty (e.g. padding), we remove pointer events so\n        // it doesn't prevent interactions with page elements that it overlays\n        style={{ pointerEvents: hasToasts ? undefined : 'none' }}\n      >\n        {hasToasts && (\n          <FocusProxy\n            ref={headFocusProxyRef}\n            onFocusFromOutsideViewport={() => {\n              const tabbableCandidates = getSortedTabbableCandidates({\n                tabbingDirection: 'forwards',\n              });\n              focusFirst(tabbableCandidates);\n            }}\n          />\n        )}\n        {/**\n         * tabindex on the the list so that it can be focused when items are removed. we focus\n         * the list instead of the viewport so it announces number of items remaining.\n         */}\n        <Collection.Slot scope={__scopeToast}>\n          <Primitive.ol tabIndex={-1} {...viewportProps} ref={composedRefs} />\n        </Collection.Slot>\n        {hasToasts && (\n          <FocusProxy\n            ref={tailFocusProxyRef}\n            onFocusFromOutsideViewport={() => {\n              const tabbableCandidates = getSortedTabbableCandidates({\n                tabbingDirection: 'backwards',\n              });\n              focusFirst(tabbableCandidates);\n            }}\n          />\n        )}\n      </DismissableLayer.Branch>\n    );\n  }\n);\n\nToastViewport.displayName = VIEWPORT_NAME;\n\n/* -----------------------------------------------------------------------------------------------*/\n\nconst FOCUS_PROXY_NAME = 'ToastFocusProxy';\n\ntype FocusProxyElement = React.ElementRef<typeof VisuallyHidden>;\ntype VisuallyHiddenProps = React.ComponentPropsWithoutRef<typeof VisuallyHidden>;\ninterface FocusProxyProps extends VisuallyHiddenProps {\n  onFocusFromOutsideViewport(): void;\n}\n\nconst FocusProxy = React.forwardRef<FocusProxyElement, ScopedProps<FocusProxyProps>>(\n  (props, forwardedRef) => {\n    const { __scopeToast, onFocusFromOutsideViewport, ...proxyProps } = props;\n    const context = useToastProviderContext(FOCUS_PROXY_NAME, __scopeToast);\n\n    return (\n      <VisuallyHidden\n        aria-hidden\n        tabIndex={0}\n        {...proxyProps}\n        ref={forwardedRef}\n        // Avoid page scrolling when focus is on the focus proxy\n        style={{ position: 'fixed' }}\n        onFocus={(event) => {\n          const prevFocusedElement = event.relatedTarget as HTMLElement | null;\n          const isFocusFromOutsideViewport = !context.viewport?.contains(prevFocusedElement);\n          if (isFocusFromOutsideViewport) onFocusFromOutsideViewport();\n        }}\n      />\n    );\n  }\n);\n\nFocusProxy.displayName = FOCUS_PROXY_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * Toast\n * -----------------------------------------------------------------------------------------------*/\n\nconst TOAST_NAME = 'Toast';\nconst TOAST_SWIPE_START = 'toast.swipeStart';\nconst TOAST_SWIPE_MOVE = 'toast.swipeMove';\nconst TOAST_SWIPE_CANCEL = 'toast.swipeCancel';\nconst TOAST_SWIPE_END = 'toast.swipeEnd';\n\ntype ToastElement = ToastImplElement;\ninterface ToastProps extends Omit<ToastImplProps, keyof ToastImplPrivateProps> {\n  open?: boolean;\n  defaultOpen?: boolean;\n  onOpenChange?(open: boolean): void;\n  /**\n   * Used to force mounting when more control is needed. Useful when\n   * controlling animation with React animation libraries.\n   */\n  forceMount?: true;\n}\n\nconst Toast = React.forwardRef<ToastElement, ToastProps>(\n  (props: ScopedProps<ToastProps>, forwardedRef) => {\n    const { forceMount, open: openProp, defaultOpen, onOpenChange, ...toastProps } = props;\n    const [open = true, setOpen] = useControllableState({\n      prop: openProp,\n      defaultProp: defaultOpen,\n      onChange: onOpenChange,\n    });\n    return (\n      <Presence present={forceMount || open}>\n        <ToastImpl\n          open={open}\n          {...toastProps}\n          ref={forwardedRef}\n          onClose={() => setOpen(false)}\n          onPause={useCallbackRef(props.onPause)}\n          onResume={useCallbackRef(props.onResume)}\n          onSwipeStart={composeEventHandlers(props.onSwipeStart, (event) => {\n            event.currentTarget.setAttribute('data-swipe', 'start');\n          })}\n          onSwipeMove={composeEventHandlers(props.onSwipeMove, (event) => {\n            const { x, y } = event.detail.delta;\n            event.currentTarget.setAttribute('data-swipe', 'move');\n            event.currentTarget.style.setProperty('--radix-toast-swipe-move-x', `${x}px`);\n            event.currentTarget.style.setProperty('--radix-toast-swipe-move-y', `${y}px`);\n          })}\n          onSwipeCancel={composeEventHandlers(props.onSwipeCancel, (event) => {\n            event.currentTarget.setAttribute('data-swipe', 'cancel');\n            event.currentTarget.style.removeProperty('--radix-toast-swipe-move-x');\n            event.currentTarget.style.removeProperty('--radix-toast-swipe-move-y');\n            event.currentTarget.style.removeProperty('--radix-toast-swipe-end-x');\n            event.currentTarget.style.removeProperty('--radix-toast-swipe-end-y');\n          })}\n          onSwipeEnd={composeEventHandlers(props.onSwipeEnd, (event) => {\n            const { x, y } = event.detail.delta;\n            event.currentTarget.setAttribute('data-swipe', 'end');\n            event.currentTarget.style.removeProperty('--radix-toast-swipe-move-x');\n            event.currentTarget.style.removeProperty('--radix-toast-swipe-move-y');\n            event.currentTarget.style.setProperty('--radix-toast-swipe-end-x', `${x}px`);\n            event.currentTarget.style.setProperty('--radix-toast-swipe-end-y', `${y}px`);\n            setOpen(false);\n          })}\n        />\n      </Presence>\n    );\n  }\n);\n\nToast.displayName = TOAST_NAME;\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype SwipeEvent = { currentTarget: EventTarget & ToastElement } & Omit<\n  CustomEvent<{ originalEvent: React.PointerEvent; delta: { x: number; y: number } }>,\n  'currentTarget'\n>;\n\nconst [ToastInteractiveProvider, useToastInteractiveContext] = createToastContext(TOAST_NAME, {\n  onClose() {},\n});\n\ntype ToastImplElement = React.ElementRef<typeof Primitive.li>;\ntype DismissableLayerProps = React.ComponentPropsWithoutRef<typeof DismissableLayer.Root>;\ntype ToastImplPrivateProps = { open: boolean; onClose(): void };\ntype PrimitiveListItemProps = React.ComponentPropsWithoutRef<typeof Primitive.li>;\ninterface ToastImplProps extends ToastImplPrivateProps, PrimitiveListItemProps {\n  type?: 'foreground' | 'background';\n  /**\n   * Time in milliseconds that toast should remain visible for. Overrides value\n   * given to `ToastProvider`.\n   */\n  duration?: number;\n  onEscapeKeyDown?: DismissableLayerProps['onEscapeKeyDown'];\n  onPause?(): void;\n  onResume?(): void;\n  onSwipeStart?(event: SwipeEvent): void;\n  onSwipeMove?(event: SwipeEvent): void;\n  onSwipeCancel?(event: SwipeEvent): void;\n  onSwipeEnd?(event: SwipeEvent): void;\n}\n\nconst ToastImpl = React.forwardRef<ToastImplElement, ToastImplProps>(\n  (props: ScopedProps<ToastImplProps>, forwardedRef) => {\n    const {\n      __scopeToast,\n      type = 'foreground',\n      duration: durationProp,\n      open,\n      onClose,\n      onEscapeKeyDown,\n      onPause,\n      onResume,\n      onSwipeStart,\n      onSwipeMove,\n      onSwipeCancel,\n      onSwipeEnd,\n      ...toastProps\n    } = props;\n    const context = useToastProviderContext(TOAST_NAME, __scopeToast);\n    const [node, setNode] = React.useState<ToastImplElement | null>(null);\n    const composedRefs = useComposedRefs(forwardedRef, (node) => setNode(node));\n    const pointerStartRef = React.useRef<{ x: number; y: number } | null>(null);\n    const swipeDeltaRef = React.useRef<{ x: number; y: number } | null>(null);\n    const duration = durationProp || context.duration;\n    const closeTimerStartTimeRef = React.useRef(0);\n    const closeTimerRemainingTimeRef = React.useRef(duration);\n    const closeTimerRef = React.useRef(0);\n    const { onToastAdd, onToastRemove } = context;\n    const handleClose = useCallbackRef(() => {\n      // focus viewport if focus is within toast to read the remaining toast\n      // count to SR users and ensure focus isn't lost\n      const isFocusInToast = node?.contains(document.activeElement);\n      if (isFocusInToast) context.viewport?.focus();\n      onClose();\n    });\n\n    const startTimer = React.useCallback(\n      (duration: number) => {\n        if (!duration || duration === Infinity) return;\n        window.clearTimeout(closeTimerRef.current);\n        closeTimerStartTimeRef.current = new Date().getTime();\n        closeTimerRef.current = window.setTimeout(handleClose, duration);\n      },\n      [handleClose]\n    );\n\n    React.useEffect(() => {\n      const viewport = context.viewport;\n      if (viewport) {\n        const handleResume = () => {\n          startTimer(closeTimerRemainingTimeRef.current);\n          onResume?.();\n        };\n        const handlePause = () => {\n          const elapsedTime = new Date().getTime() - closeTimerStartTimeRef.current;\n          closeTimerRemainingTimeRef.current = closeTimerRemainingTimeRef.current - elapsedTime;\n          window.clearTimeout(closeTimerRef.current);\n          onPause?.();\n        };\n        viewport.addEventListener(VIEWPORT_PAUSE, handlePause);\n        viewport.addEventListener(VIEWPORT_RESUME, handleResume);\n        return () => {\n          viewport.removeEventListener(VIEWPORT_PAUSE, handlePause);\n          viewport.removeEventListener(VIEWPORT_RESUME, handleResume);\n        };\n      }\n    }, [context.viewport, duration, onPause, onResume, startTimer]);\n\n    // start timer when toast opens or duration changes.\n    // we include `open` in deps because closed !== unmounted when animating\n    // so it could reopen before being completely unmounted\n    React.useEffect(() => {\n      if (open && !context.isClosePausedRef.current) startTimer(duration);\n    }, [open, duration, context.isClosePausedRef, startTimer]);\n\n    React.useEffect(() => {\n      onToastAdd();\n      return () => onToastRemove();\n    }, [onToastAdd, onToastRemove]);\n\n    const announceTextContent = React.useMemo(() => {\n      return node ? getAnnounceTextContent(node) : null;\n    }, [node]);\n\n    if (!context.viewport) return null;\n\n    return (\n      <>\n        {announceTextContent && (\n          <ToastAnnounce\n            __scopeToast={__scopeToast}\n            // Toasts are always role=status to avoid stuttering issues with role=alert in SRs.\n            role=\"status\"\n            aria-live={type === 'foreground' ? 'assertive' : 'polite'}\n            aria-atomic\n          >\n            {announceTextContent}\n          </ToastAnnounce>\n        )}\n\n        <ToastInteractiveProvider scope={__scopeToast} onClose={handleClose}>\n          {ReactDOM.createPortal(\n            <Collection.ItemSlot scope={__scopeToast}>\n              <DismissableLayer.Root\n                asChild\n                onEscapeKeyDown={composeEventHandlers(onEscapeKeyDown, () => {\n                  if (!context.isFocusedToastEscapeKeyDownRef.current) handleClose();\n                  context.isFocusedToastEscapeKeyDownRef.current = false;\n                })}\n              >\n                <Primitive.li\n                  // Ensure toasts are announced as status list or status when focused\n                  role=\"status\"\n                  aria-live=\"off\"\n                  aria-atomic\n                  tabIndex={0}\n                  data-state={open ? 'open' : 'closed'}\n                  data-swipe-direction={context.swipeDirection}\n                  {...toastProps}\n                  ref={composedRefs}\n                  style={{ userSelect: 'none', touchAction: 'none', ...props.style }}\n                  onKeyDown={composeEventHandlers(props.onKeyDown, (event) => {\n                    if (event.key !== 'Escape') return;\n                    onEscapeKeyDown?.(event.nativeEvent);\n                    if (!event.nativeEvent.defaultPrevented) {\n                      context.isFocusedToastEscapeKeyDownRef.current = true;\n                      handleClose();\n                    }\n                  })}\n                  onPointerDown={composeEventHandlers(props.onPointerDown, (event) => {\n                    if (event.button !== 0) return;\n                    pointerStartRef.current = { x: event.clientX, y: event.clientY };\n                  })}\n                  onPointerMove={composeEventHandlers(props.onPointerMove, (event) => {\n                    if (!pointerStartRef.current) return;\n                    const x = event.clientX - pointerStartRef.current.x;\n                    const y = event.clientY - pointerStartRef.current.y;\n                    const hasSwipeMoveStarted = Boolean(swipeDeltaRef.current);\n                    const isHorizontalSwipe = ['left', 'right'].includes(context.swipeDirection);\n                    const clamp = ['left', 'up'].includes(context.swipeDirection)\n                      ? Math.min\n                      : Math.max;\n                    const clampedX = isHorizontalSwipe ? clamp(0, x) : 0;\n                    const clampedY = !isHorizontalSwipe ? clamp(0, y) : 0;\n                    const moveStartBuffer = event.pointerType === 'touch' ? 10 : 2;\n                    const delta = { x: clampedX, y: clampedY };\n                    const eventDetail = { originalEvent: event, delta };\n                    if (hasSwipeMoveStarted) {\n                      swipeDeltaRef.current = delta;\n                      handleAndDispatchCustomEvent(TOAST_SWIPE_MOVE, onSwipeMove, eventDetail, {\n                        discrete: false,\n                      });\n                    } else if (isDeltaInDirection(delta, context.swipeDirection, moveStartBuffer)) {\n                      swipeDeltaRef.current = delta;\n                      handleAndDispatchCustomEvent(TOAST_SWIPE_START, onSwipeStart, eventDetail, {\n                        discrete: false,\n                      });\n                      (event.target as HTMLElement).setPointerCapture(event.pointerId);\n                    } else if (Math.abs(x) > moveStartBuffer || Math.abs(y) > moveStartBuffer) {\n                      // User is swiping in wrong direction so we disable swipe gesture\n                      // for the current pointer down interaction\n                      pointerStartRef.current = null;\n                    }\n                  })}\n                  onPointerUp={composeEventHandlers(props.onPointerUp, (event) => {\n                    const delta = swipeDeltaRef.current;\n                    const target = event.target as HTMLElement;\n                    if (target.hasPointerCapture(event.pointerId)) {\n                      target.releasePointerCapture(event.pointerId);\n                    }\n                    swipeDeltaRef.current = null;\n                    pointerStartRef.current = null;\n                    if (delta) {\n                      const toast = event.currentTarget;\n                      const eventDetail = { originalEvent: event, delta };\n                      if (\n                        isDeltaInDirection(delta, context.swipeDirection, context.swipeThreshold)\n                      ) {\n                        handleAndDispatchCustomEvent(TOAST_SWIPE_END, onSwipeEnd, eventDetail, {\n                          discrete: true,\n                        });\n                      } else {\n                        handleAndDispatchCustomEvent(\n                          TOAST_SWIPE_CANCEL,\n                          onSwipeCancel,\n                          eventDetail,\n                          {\n                            discrete: true,\n                          }\n                        );\n                      }\n                      // Prevent click event from triggering on items within the toast when\n                      // pointer up is part of a swipe gesture\n                      toast.addEventListener('click', (event) => event.preventDefault(), {\n                        once: true,\n                      });\n                    }\n                  })}\n                />\n              </DismissableLayer.Root>\n            </Collection.ItemSlot>,\n            context.viewport\n          )}\n        </ToastInteractiveProvider>\n      </>\n    );\n  }\n);\n\n/* -----------------------------------------------------------------------------------------------*/\n\ninterface ToastAnnounceProps\n  extends Omit<React.ComponentPropsWithoutRef<'div'>, 'children'>,\n    ScopedProps<{ children: string[] }> {}\n\nconst ToastAnnounce: React.FC<ToastAnnounceProps> = (props: ScopedProps<ToastAnnounceProps>) => {\n  const { __scopeToast, children, ...announceProps } = props;\n  const context = useToastProviderContext(TOAST_NAME, __scopeToast);\n  const [renderAnnounceText, setRenderAnnounceText] = React.useState(false);\n  const [isAnnounced, setIsAnnounced] = React.useState(false);\n\n  // render text content in the next frame to ensure toast is announced in NVDA\n  useNextFrame(() => setRenderAnnounceText(true));\n\n  // cleanup after announcing\n  React.useEffect(() => {\n    const timer = window.setTimeout(() => setIsAnnounced(true), 1000);\n    return () => window.clearTimeout(timer);\n  }, []);\n\n  return isAnnounced ? null : (\n    <Portal asChild>\n      <VisuallyHidden {...announceProps}>\n        {renderAnnounceText && (\n          <>\n            {context.label} {children}\n          </>\n        )}\n      </VisuallyHidden>\n    </Portal>\n  );\n};\n\n/* -------------------------------------------------------------------------------------------------\n * ToastTitle\n * -----------------------------------------------------------------------------------------------*/\n\nconst TITLE_NAME = 'ToastTitle';\n\ntype ToastTitleElement = React.ElementRef<typeof Primitive.div>;\ntype PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface ToastTitleProps extends PrimitiveDivProps {}\n\nconst ToastTitle = React.forwardRef<ToastTitleElement, ToastTitleProps>(\n  (props: ScopedProps<ToastTitleProps>, forwardedRef) => {\n    const { __scopeToast, ...titleProps } = props;\n    return <Primitive.div {...titleProps} ref={forwardedRef} />;\n  }\n);\n\nToastTitle.displayName = TITLE_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * ToastDescription\n * -----------------------------------------------------------------------------------------------*/\n\nconst DESCRIPTION_NAME = 'ToastDescription';\n\ntype ToastDescriptionElement = React.ElementRef<typeof Primitive.div>;\ninterface ToastDescriptionProps extends PrimitiveDivProps {}\n\nconst ToastDescription = React.forwardRef<ToastDescriptionElement, ToastDescriptionProps>(\n  (props: ScopedProps<ToastDescriptionProps>, forwardedRef) => {\n    const { __scopeToast, ...descriptionProps } = props;\n    return <Primitive.div {...descriptionProps} ref={forwardedRef} />;\n  }\n);\n\nToastDescription.displayName = DESCRIPTION_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * ToastAction\n * -----------------------------------------------------------------------------------------------*/\n\nconst ACTION_NAME = 'ToastAction';\n\ntype ToastActionElement = ToastCloseElement;\ninterface ToastActionProps extends ToastCloseProps {\n  /**\n   * A short description for an alternate way to carry out the action. For screen reader users\n   * who will not be able to navigate to the button easily/quickly.\n   * @example <ToastAction altText=\"Goto account settings to upgrade\">Upgrade</ToastAction>\n   * @example <ToastAction altText=\"Undo (Alt+U)\">Undo</ToastAction>\n   */\n  altText: string;\n}\n\nconst ToastAction = React.forwardRef<ToastActionElement, ToastActionProps>(\n  (props: ScopedProps<ToastActionProps>, forwardedRef) => {\n    const { altText, ...actionProps } = props;\n\n    if (!altText.trim()) {\n      console.error(\n        `Invalid prop \\`altText\\` supplied to \\`${ACTION_NAME}\\`. Expected non-empty \\`string\\`.`\n      );\n      return null;\n    }\n\n    return (\n      <ToastAnnounceExclude altText={altText} asChild>\n        <ToastClose {...actionProps} ref={forwardedRef} />\n      </ToastAnnounceExclude>\n    );\n  }\n);\n\nToastAction.displayName = ACTION_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * ToastClose\n * -----------------------------------------------------------------------------------------------*/\n\nconst CLOSE_NAME = 'ToastClose';\n\ntype ToastCloseElement = React.ElementRef<typeof Primitive.button>;\ntype PrimitiveButtonProps = React.ComponentPropsWithoutRef<typeof Primitive.button>;\ninterface ToastCloseProps extends PrimitiveButtonProps {}\n\nconst ToastClose = React.forwardRef<ToastCloseElement, ToastCloseProps>(\n  (props: ScopedProps<ToastCloseProps>, forwardedRef) => {\n    const { __scopeToast, ...closeProps } = props;\n    const interactiveContext = useToastInteractiveContext(CLOSE_NAME, __scopeToast);\n\n    return (\n      <ToastAnnounceExclude asChild>\n        <Primitive.button\n          type=\"button\"\n          {...closeProps}\n          ref={forwardedRef}\n          onClick={composeEventHandlers(props.onClick, interactiveContext.onClose)}\n        />\n      </ToastAnnounceExclude>\n    );\n  }\n);\n\nToastClose.displayName = CLOSE_NAME;\n\n/* ---------------------------------------------------------------------------------------------- */\n\ntype ToastAnnounceExcludeElement = React.ElementRef<typeof Primitive.div>;\ninterface ToastAnnounceExcludeProps extends PrimitiveDivProps {\n  altText?: string;\n}\n\nconst ToastAnnounceExclude = React.forwardRef<\n  ToastAnnounceExcludeElement,\n  ToastAnnounceExcludeProps\n>((props: ScopedProps<ToastAnnounceExcludeProps>, forwardedRef) => {\n  const { __scopeToast, altText, ...announceExcludeProps } = props;\n\n  return (\n    <Primitive.div\n      data-radix-toast-announce-exclude=\"\"\n      data-radix-toast-announce-alt={altText || undefined}\n      {...announceExcludeProps}\n      ref={forwardedRef}\n    />\n  );\n});\n\nfunction getAnnounceTextContent(container: HTMLElement) {\n  const textContent: string[] = [];\n  const childNodes = Array.from(container.childNodes);\n\n  childNodes.forEach((node) => {\n    if (node.nodeType === node.TEXT_NODE && node.textContent) textContent.push(node.textContent);\n    if (isHTMLElement(node)) {\n      const isHidden = node.ariaHidden || node.hidden || node.style.display === 'none';\n      const isExcluded = node.dataset.radixToastAnnounceExclude === '';\n\n      if (!isHidden) {\n        if (isExcluded) {\n          const altText = node.dataset.radixToastAnnounceAlt;\n          if (altText) textContent.push(altText);\n        } else {\n          textContent.push(...getAnnounceTextContent(node));\n        }\n      }\n    }\n  });\n\n  // We return a collection of text rather than a single concatenated string.\n  // This allows SR VO to naturally pause break between nodes while announcing.\n  return textContent;\n}\n\n/* ---------------------------------------------------------------------------------------------- */\n\nfunction handleAndDispatchCustomEvent<\n  E extends CustomEvent,\n  ReactEvent extends React.SyntheticEvent\n>(\n  name: string,\n  handler: ((event: E) => void) | undefined,\n  detail: { originalEvent: ReactEvent } & (E extends CustomEvent<infer D> ? D : never),\n  { discrete }: { discrete: boolean }\n) {\n  const currentTarget = detail.originalEvent.currentTarget as HTMLElement;\n  const event = new CustomEvent(name, { bubbles: true, cancelable: true, detail });\n  if (handler) currentTarget.addEventListener(name, handler as EventListener, { once: true });\n\n  if (discrete) {\n    dispatchDiscreteCustomEvent(currentTarget, event);\n  } else {\n    currentTarget.dispatchEvent(event);\n  }\n}\n\nconst isDeltaInDirection = (\n  delta: { x: number; y: number },\n  direction: SwipeDirection,\n  threshold = 0\n) => {\n  const deltaX = Math.abs(delta.x);\n  const deltaY = Math.abs(delta.y);\n  const isDeltaX = deltaX > deltaY;\n  if (direction === 'left' || direction === 'right') {\n    return isDeltaX && deltaX > threshold;\n  } else {\n    return !isDeltaX && deltaY > threshold;\n  }\n};\n\nfunction useNextFrame(callback = () => {}) {\n  const fn = useCallbackRef(callback);\n  useLayoutEffect(() => {\n    let raf1 = 0;\n    let raf2 = 0;\n    raf1 = window.requestAnimationFrame(() => (raf2 = window.requestAnimationFrame(fn)));\n    return () => {\n      window.cancelAnimationFrame(raf1);\n      window.cancelAnimationFrame(raf2);\n    };\n  }, [fn]);\n}\n\nfunction isHTMLElement(node: any): node is HTMLElement {\n  return node.nodeType === node.ELEMENT_NODE;\n}\n\n/**\n * Returns a list of potential tabbable candidates.\n *\n * NOTE: This is only a close approximation. For example it doesn't take into account cases like when\n * elements are not visible. This cannot be worked out easily by just reading a property, but rather\n * necessitate runtime knowledge (computed styles, etc). We deal with these cases separately.\n *\n * See: https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker\n * Credit: https://github.com/discord/focus-layers/blob/master/src/util/wrapFocus.tsx#L1\n */\nfunction getTabbableCandidates(container: HTMLElement) {\n  const nodes: HTMLElement[] = [];\n  const walker = document.createTreeWalker(container, NodeFilter.SHOW_ELEMENT, {\n    acceptNode: (node: any) => {\n      const isHiddenInput = node.tagName === 'INPUT' && node.type === 'hidden';\n      if (node.disabled || node.hidden || isHiddenInput) return NodeFilter.FILTER_SKIP;\n      // `.tabIndex` is not the same as the `tabindex` attribute. It works on the\n      // runtime's understanding of tabbability, so this automatically accounts\n      // for any kind of element that could be tabbed to.\n      return node.tabIndex >= 0 ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n    },\n  });\n  while (walker.nextNode()) nodes.push(walker.currentNode as HTMLElement);\n  // we do not take into account the order of nodes with positive `tabIndex` as it\n  // hinders accessibility to have tab order different from visual order.\n  return nodes;\n}\n\nfunction focusFirst(candidates: HTMLElement[]) {\n  const previouslyFocusedElement = document.activeElement;\n  return candidates.some((candidate) => {\n    // if focus is already where we want to go, we don't want to keep going through the candidates\n    if (candidate === previouslyFocusedElement) return true;\n    candidate.focus();\n    return document.activeElement !== previouslyFocusedElement;\n  });\n}\n\nconst Provider = ToastProvider;\nconst Viewport = ToastViewport;\nconst Root = Toast;\nconst Title = ToastTitle;\nconst Description = ToastDescription;\nconst Action = ToastAction;\nconst Close = ToastClose;\n\nexport {\n  createToastScope,\n  //\n  ToastProvider,\n  ToastViewport,\n  Toast,\n  ToastTitle,\n  ToastDescription,\n  ToastAction,\n  ToastClose,\n  //\n  Provider,\n  Viewport,\n  Root,\n  Title,\n  Description,\n  Action,\n  Close,\n};\nexport type {\n  ToastProviderProps,\n  ToastViewportProps,\n  ToastProps,\n  ToastTitleProps,\n  ToastDescriptionProps,\n  ToastActionProps,\n  ToastCloseProps,\n};\n","import * as React from 'react';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { useLayoutEffect } from '@radix-ui/react-use-layout-effect';\nimport { useStateMachine } from './useStateMachine';\n\ninterface PresenceProps {\n  children: React.ReactElement | ((props: { present: boolean }) => React.ReactElement);\n  present: boolean;\n}\n\nconst Presence: React.FC<PresenceProps> = (props) => {\n  const { present, children } = props;\n  const presence = usePresence(present);\n\n  const child = (\n    typeof children === 'function'\n      ? children({ present: presence.isPresent })\n      : React.Children.only(children)\n  ) as React.ReactElement<{ ref?: React.Ref<HTMLElement> }>;\n\n  const ref = useComposedRefs(presence.ref, getElementRef(child));\n  const forceMount = typeof children === 'function';\n  return forceMount || presence.isPresent ? React.cloneElement(child, { ref }) : null;\n};\n\nPresence.displayName = 'Presence';\n\n/* -------------------------------------------------------------------------------------------------\n * usePresence\n * -----------------------------------------------------------------------------------------------*/\n\nfunction usePresence(present: boolean) {\n  const [node, setNode] = React.useState<HTMLElement>();\n  const stylesRef = React.useRef<CSSStyleDeclaration>({} as any);\n  const prevPresentRef = React.useRef(present);\n  const prevAnimationNameRef = React.useRef<string>('none');\n  const initialState = present ? 'mounted' : 'unmounted';\n  const [state, send] = useStateMachine(initialState, {\n    mounted: {\n      UNMOUNT: 'unmounted',\n      ANIMATION_OUT: 'unmountSuspended',\n    },\n    unmountSuspended: {\n      MOUNT: 'mounted',\n      ANIMATION_END: 'unmounted',\n    },\n    unmounted: {\n      MOUNT: 'mounted',\n    },\n  });\n\n  React.useEffect(() => {\n    const currentAnimationName = getAnimationName(stylesRef.current);\n    prevAnimationNameRef.current = state === 'mounted' ? currentAnimationName : 'none';\n  }, [state]);\n\n  useLayoutEffect(() => {\n    const styles = stylesRef.current;\n    const wasPresent = prevPresentRef.current;\n    const hasPresentChanged = wasPresent !== present;\n\n    if (hasPresentChanged) {\n      const prevAnimationName = prevAnimationNameRef.current;\n      const currentAnimationName = getAnimationName(styles);\n\n      if (present) {\n        send('MOUNT');\n      } else if (currentAnimationName === 'none' || styles?.display === 'none') {\n        // If there is no exit animation or the element is hidden, animations won't run\n        // so we unmount instantly\n        send('UNMOUNT');\n      } else {\n        /**\n         * When `present` changes to `false`, we check changes to animation-name to\n         * determine whether an animation has started. We chose this approach (reading\n         * computed styles) because there is no `animationrun` event and `animationstart`\n         * fires after `animation-delay` has expired which would be too late.\n         */\n        const isAnimating = prevAnimationName !== currentAnimationName;\n\n        if (wasPresent && isAnimating) {\n          send('ANIMATION_OUT');\n        } else {\n          send('UNMOUNT');\n        }\n      }\n\n      prevPresentRef.current = present;\n    }\n  }, [present, send]);\n\n  useLayoutEffect(() => {\n    if (node) {\n      let timeoutId: number;\n      const ownerWindow = node.ownerDocument.defaultView ?? window;\n      /**\n       * Triggering an ANIMATION_OUT during an ANIMATION_IN will fire an `animationcancel`\n       * event for ANIMATION_IN after we have entered `unmountSuspended` state. So, we\n       * make sure we only trigger ANIMATION_END for the currently active animation.\n       */\n      const handleAnimationEnd = (event: AnimationEvent) => {\n        const currentAnimationName = getAnimationName(stylesRef.current);\n        const isCurrentAnimation = currentAnimationName.includes(event.animationName);\n        if (event.target === node && isCurrentAnimation) {\n          // With React 18 concurrency this update is applied a frame after the\n          // animation ends, creating a flash of visible content. By setting the\n          // animation fill mode to \"forwards\", we force the node to keep the\n          // styles of the last keyframe, removing the flash.\n          //\n          // Previously we flushed the update via ReactDom.flushSync, but with\n          // exit animations this resulted in the node being removed from the\n          // DOM before the synthetic animationEnd event was dispatched, meaning\n          // user-provided event handlers would not be called.\n          // https://github.com/radix-ui/primitives/pull/1849\n          send('ANIMATION_END');\n          if (!prevPresentRef.current) {\n            const currentFillMode = node.style.animationFillMode;\n            node.style.animationFillMode = 'forwards';\n            // Reset the style after the node had time to unmount (for cases\n            // where the component chooses not to unmount). Doing this any\n            // sooner than `setTimeout` (e.g. with `requestAnimationFrame`)\n            // still causes a flash.\n            timeoutId = ownerWindow.setTimeout(() => {\n              if (node.style.animationFillMode === 'forwards') {\n                node.style.animationFillMode = currentFillMode;\n              }\n            });\n          }\n        }\n      };\n      const handleAnimationStart = (event: AnimationEvent) => {\n        if (event.target === node) {\n          // if animation occurred, store its name as the previous animation.\n          prevAnimationNameRef.current = getAnimationName(stylesRef.current);\n        }\n      };\n      node.addEventListener('animationstart', handleAnimationStart);\n      node.addEventListener('animationcancel', handleAnimationEnd);\n      node.addEventListener('animationend', handleAnimationEnd);\n      return () => {\n        ownerWindow.clearTimeout(timeoutId);\n        node.removeEventListener('animationstart', handleAnimationStart);\n        node.removeEventListener('animationcancel', handleAnimationEnd);\n        node.removeEventListener('animationend', handleAnimationEnd);\n      };\n    } else {\n      // Transition to the unmounted state if the node is removed prematurely.\n      // We avoid doing so during cleanup as the node may change but still exist.\n      send('ANIMATION_END');\n    }\n  }, [node, send]);\n\n  return {\n    isPresent: ['mounted', 'unmountSuspended'].includes(state),\n    ref: React.useCallback((node: HTMLElement) => {\n      if (node) stylesRef.current = getComputedStyle(node);\n      setNode(node);\n    }, []),\n  };\n}\n\n/* -----------------------------------------------------------------------------------------------*/\n\nfunction getAnimationName(styles?: CSSStyleDeclaration) {\n  return styles?.animationName || 'none';\n}\n\n// Before React 19 accessing `element.props.ref` will throw a warning and suggest using `element.ref`\n// After React 19 accessing `element.ref` does the opposite.\n// https://github.com/facebook/react/pull/28348\n//\n// Access the ref using the method that doesn't yield a warning.\nfunction getElementRef(element: React.ReactElement<{ ref?: React.Ref<unknown> }>) {\n  // React <=18 in DEV\n  let getter = Object.getOwnPropertyDescriptor(element.props, 'ref')?.get;\n  let mayWarn = getter && 'isReactWarning' in getter && getter.isReactWarning;\n  if (mayWarn) {\n    return (element as any).ref;\n  }\n\n  // React 19 in DEV\n  getter = Object.getOwnPropertyDescriptor(element, 'ref')?.get;\n  mayWarn = getter && 'isReactWarning' in getter && getter.isReactWarning;\n  if (mayWarn) {\n    return element.props.ref;\n  }\n\n  // Not DEV\n  return element.props.ref || (element as any).ref;\n}\n\nexport { Presence };\nexport type { PresenceProps };\n","import * as React from 'react';\n\ntype Machine<S> = { [k: string]: { [k: string]: S } };\ntype MachineState<T> = keyof T;\ntype MachineEvent<T> = keyof UnionToIntersection<T[keyof T]>;\n\n// 🤯 https://fettblog.eu/typescript-union-to-intersection/\ntype UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any\n  ? R\n  : never;\n\nexport function useStateMachine<M>(\n  initialState: MachineState<M>,\n  machine: M & Machine<MachineState<M>>\n) {\n  return React.useReducer((state: MachineState<M>, event: MachineEvent<M>): MachineState<M> => {\n    const nextState = (machine[state] as any)[event];\n    return nextState ?? state;\n  }, initialState);\n}\n","import * as React from 'react';\nimport ReactDOM from 'react-dom';\nimport { Primitive } from '@radix-ui/react-primitive';\nimport { useLayoutEffect } from '@radix-ui/react-use-layout-effect';\n\n/* -------------------------------------------------------------------------------------------------\n * Portal\n * -----------------------------------------------------------------------------------------------*/\n\nconst PORTAL_NAME = 'Portal';\n\ntype PortalElement = React.ElementRef<typeof Primitive.div>;\ntype PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface PortalProps extends PrimitiveDivProps {\n  /**\n   * An optional container where the portaled content should be appended.\n   */\n  container?: Element | DocumentFragment | null;\n}\n\nconst Portal = React.forwardRef<PortalElement, PortalProps>((props, forwardedRef) => {\n  const { container: containerProp, ...portalProps } = props;\n  const [mounted, setMounted] = React.useState(false);\n  useLayoutEffect(() => setMounted(true), []);\n  const container = containerProp || (mounted && globalThis?.document?.body);\n  return container\n    ? ReactDOM.createPortal(<Primitive.div {...portalProps} ref={forwardedRef} />, container)\n    : null;\n});\n\nPortal.displayName = PORTAL_NAME;\n\n/* -----------------------------------------------------------------------------------------------*/\n\nconst Root = Portal;\n\nexport {\n  Portal,\n  //\n  Root,\n};\nexport type { PortalProps };\n","// packages/react/use-callback-ref/src/useCallbackRef.tsx\nimport * as React from \"react\";\nfunction useCallbackRef(callback) {\n  const callbackRef = React.useRef(callback);\n  React.useEffect(() => {\n    callbackRef.current = callback;\n  });\n  return React.useMemo(() => (...args) => callbackRef.current?.(...args), []);\n}\nexport {\n  useCallbackRef\n};\n//# sourceMappingURL=index.mjs.map\n","// src/query.ts\nimport {\n  ensureQueryFn,\n  noop,\n  replaceData,\n  resolveEnabled,\n  skipToken,\n  timeUntilStale\n} from \"./utils.js\";\nimport { notifyManager } from \"./notifyManager.js\";\nimport { canFetch, createRetryer, isCancelledError } from \"./retryer.js\";\nimport { Removable } from \"./removable.js\";\nvar Query = class extends Removable {\n  #initialState;\n  #revertState;\n  #cache;\n  #retryer;\n  #defaultOptions;\n  #abortSignalConsumed;\n  constructor(config) {\n    super();\n    this.#abortSignalConsumed = false;\n    this.#defaultOptions = config.defaultOptions;\n    this.setOptions(config.options);\n    this.observers = [];\n    this.#cache = config.cache;\n    this.queryKey = config.queryKey;\n    this.queryHash = config.queryHash;\n    this.#initialState = getDefaultState(this.options);\n    this.state = config.state ?? this.#initialState;\n    this.scheduleGc();\n  }\n  get meta() {\n    return this.options.meta;\n  }\n  get promise() {\n    return this.#retryer?.promise;\n  }\n  setOptions(options) {\n    this.options = { ...this.#defaultOptions, ...options };\n    this.updateGcTime(this.options.gcTime);\n  }\n  optionalRemove() {\n    if (!this.observers.length && this.state.fetchStatus === \"idle\") {\n      this.#cache.remove(this);\n    }\n  }\n  setData(newData, options) {\n    const data = replaceData(this.state.data, newData, this.options);\n    this.#dispatch({\n      data,\n      type: \"success\",\n      dataUpdatedAt: options?.updatedAt,\n      manual: options?.manual\n    });\n    return data;\n  }\n  setState(state, setStateOptions) {\n    this.#dispatch({ type: \"setState\", state, setStateOptions });\n  }\n  cancel(options) {\n    const promise = this.#retryer?.promise;\n    this.#retryer?.cancel(options);\n    return promise ? promise.then(noop).catch(noop) : Promise.resolve();\n  }\n  destroy() {\n    super.destroy();\n    this.cancel({ silent: true });\n  }\n  reset() {\n    this.destroy();\n    this.setState(this.#initialState);\n  }\n  isActive() {\n    return this.observers.some(\n      (observer) => resolveEnabled(observer.options.enabled, this) !== false\n    );\n  }\n  isDisabled() {\n    if (this.getObserversCount() > 0) {\n      return !this.isActive();\n    }\n    return this.options.queryFn === skipToken || this.state.dataUpdateCount + this.state.errorUpdateCount === 0;\n  }\n  isStale() {\n    if (this.state.isInvalidated) {\n      return true;\n    }\n    if (this.getObserversCount() > 0) {\n      return this.observers.some(\n        (observer) => observer.getCurrentResult().isStale\n      );\n    }\n    return this.state.data === void 0;\n  }\n  isStaleByTime(staleTime = 0) {\n    return this.state.isInvalidated || this.state.data === void 0 || !timeUntilStale(this.state.dataUpdatedAt, staleTime);\n  }\n  onFocus() {\n    const observer = this.observers.find((x) => x.shouldFetchOnWindowFocus());\n    observer?.refetch({ cancelRefetch: false });\n    this.#retryer?.continue();\n  }\n  onOnline() {\n    const observer = this.observers.find((x) => x.shouldFetchOnReconnect());\n    observer?.refetch({ cancelRefetch: false });\n    this.#retryer?.continue();\n  }\n  addObserver(observer) {\n    if (!this.observers.includes(observer)) {\n      this.observers.push(observer);\n      this.clearGcTimeout();\n      this.#cache.notify({ type: \"observerAdded\", query: this, observer });\n    }\n  }\n  removeObserver(observer) {\n    if (this.observers.includes(observer)) {\n      this.observers = this.observers.filter((x) => x !== observer);\n      if (!this.observers.length) {\n        if (this.#retryer) {\n          if (this.#abortSignalConsumed) {\n            this.#retryer.cancel({ revert: true });\n          } else {\n            this.#retryer.cancelRetry();\n          }\n        }\n        this.scheduleGc();\n      }\n      this.#cache.notify({ type: \"observerRemoved\", query: this, observer });\n    }\n  }\n  getObserversCount() {\n    return this.observers.length;\n  }\n  invalidate() {\n    if (!this.state.isInvalidated) {\n      this.#dispatch({ type: \"invalidate\" });\n    }\n  }\n  fetch(options, fetchOptions) {\n    if (this.state.fetchStatus !== \"idle\") {\n      if (this.state.data !== void 0 && fetchOptions?.cancelRefetch) {\n        this.cancel({ silent: true });\n      } else if (this.#retryer) {\n        this.#retryer.continueRetry();\n        return this.#retryer.promise;\n      }\n    }\n    if (options) {\n      this.setOptions(options);\n    }\n    if (!this.options.queryFn) {\n      const observer = this.observers.find((x) => x.options.queryFn);\n      if (observer) {\n        this.setOptions(observer.options);\n      }\n    }\n    if (process.env.NODE_ENV !== \"production\") {\n      if (!Array.isArray(this.options.queryKey)) {\n        console.error(\n          `As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']`\n        );\n      }\n    }\n    const abortController = new AbortController();\n    const addSignalProperty = (object) => {\n      Object.defineProperty(object, \"signal\", {\n        enumerable: true,\n        get: () => {\n          this.#abortSignalConsumed = true;\n          return abortController.signal;\n        }\n      });\n    };\n    const fetchFn = () => {\n      const queryFn = ensureQueryFn(this.options, fetchOptions);\n      const queryFnContext = {\n        queryKey: this.queryKey,\n        meta: this.meta\n      };\n      addSignalProperty(queryFnContext);\n      this.#abortSignalConsumed = false;\n      if (this.options.persister) {\n        return this.options.persister(\n          queryFn,\n          queryFnContext,\n          this\n        );\n      }\n      return queryFn(queryFnContext);\n    };\n    const context = {\n      fetchOptions,\n      options: this.options,\n      queryKey: this.queryKey,\n      state: this.state,\n      fetchFn\n    };\n    addSignalProperty(context);\n    this.options.behavior?.onFetch(\n      context,\n      this\n    );\n    this.#revertState = this.state;\n    if (this.state.fetchStatus === \"idle\" || this.state.fetchMeta !== context.fetchOptions?.meta) {\n      this.#dispatch({ type: \"fetch\", meta: context.fetchOptions?.meta });\n    }\n    const onError = (error) => {\n      if (!(isCancelledError(error) && error.silent)) {\n        this.#dispatch({\n          type: \"error\",\n          error\n        });\n      }\n      if (!isCancelledError(error)) {\n        this.#cache.config.onError?.(\n          error,\n          this\n        );\n        this.#cache.config.onSettled?.(\n          this.state.data,\n          error,\n          this\n        );\n      }\n      this.scheduleGc();\n    };\n    this.#retryer = createRetryer({\n      initialPromise: fetchOptions?.initialPromise,\n      fn: context.fetchFn,\n      abort: abortController.abort.bind(abortController),\n      onSuccess: (data) => {\n        if (data === void 0) {\n          if (process.env.NODE_ENV !== \"production\") {\n            console.error(\n              `Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`\n            );\n          }\n          onError(new Error(`${this.queryHash} data is undefined`));\n          return;\n        }\n        try {\n          this.setData(data);\n        } catch (error) {\n          onError(error);\n          return;\n        }\n        this.#cache.config.onSuccess?.(data, this);\n        this.#cache.config.onSettled?.(\n          data,\n          this.state.error,\n          this\n        );\n        this.scheduleGc();\n      },\n      onError,\n      onFail: (failureCount, error) => {\n        this.#dispatch({ type: \"failed\", failureCount, error });\n      },\n      onPause: () => {\n        this.#dispatch({ type: \"pause\" });\n      },\n      onContinue: () => {\n        this.#dispatch({ type: \"continue\" });\n      },\n      retry: context.options.retry,\n      retryDelay: context.options.retryDelay,\n      networkMode: context.options.networkMode,\n      canRun: () => true\n    });\n    return this.#retryer.start();\n  }\n  #dispatch(action) {\n    const reducer = (state) => {\n      switch (action.type) {\n        case \"failed\":\n          return {\n            ...state,\n            fetchFailureCount: action.failureCount,\n            fetchFailureReason: action.error\n          };\n        case \"pause\":\n          return {\n            ...state,\n            fetchStatus: \"paused\"\n          };\n        case \"continue\":\n          return {\n            ...state,\n            fetchStatus: \"fetching\"\n          };\n        case \"fetch\":\n          return {\n            ...state,\n            ...fetchState(state.data, this.options),\n            fetchMeta: action.meta ?? null\n          };\n        case \"success\":\n          return {\n            ...state,\n            data: action.data,\n            dataUpdateCount: state.dataUpdateCount + 1,\n            dataUpdatedAt: action.dataUpdatedAt ?? Date.now(),\n            error: null,\n            isInvalidated: false,\n            status: \"success\",\n            ...!action.manual && {\n              fetchStatus: \"idle\",\n              fetchFailureCount: 0,\n              fetchFailureReason: null\n            }\n          };\n        case \"error\":\n          const error = action.error;\n          if (isCancelledError(error) && error.revert && this.#revertState) {\n            return { ...this.#revertState, fetchStatus: \"idle\" };\n          }\n          return {\n            ...state,\n            error,\n            errorUpdateCount: state.errorUpdateCount + 1,\n            errorUpdatedAt: Date.now(),\n            fetchFailureCount: state.fetchFailureCount + 1,\n            fetchFailureReason: error,\n            fetchStatus: \"idle\",\n            status: \"error\"\n          };\n        case \"invalidate\":\n          return {\n            ...state,\n            isInvalidated: true\n          };\n        case \"setState\":\n          return {\n            ...state,\n            ...action.state\n          };\n      }\n    };\n    this.state = reducer(this.state);\n    notifyManager.batch(() => {\n      this.observers.forEach((observer) => {\n        observer.onQueryUpdate();\n      });\n      this.#cache.notify({ query: this, type: \"updated\", action });\n    });\n  }\n};\nfunction fetchState(data, options) {\n  return {\n    fetchFailureCount: 0,\n    fetchFailureReason: null,\n    fetchStatus: canFetch(options.networkMode) ? \"fetching\" : \"paused\",\n    ...data === void 0 && {\n      error: null,\n      status: \"pending\"\n    }\n  };\n}\nfunction getDefaultState(options) {\n  const data = typeof options.initialData === \"function\" ? options.initialData() : options.initialData;\n  const hasData = data !== void 0;\n  const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === \"function\" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;\n  return {\n    data,\n    dataUpdateCount: 0,\n    dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0,\n    error: null,\n    errorUpdateCount: 0,\n    errorUpdatedAt: 0,\n    fetchFailureCount: 0,\n    fetchFailureReason: null,\n    fetchMeta: null,\n    isInvalidated: false,\n    status: hasData ? \"success\" : \"pending\",\n    fetchStatus: \"idle\"\n  };\n}\nexport {\n  Query,\n  fetchState\n};\n//# sourceMappingURL=query.js.map","// packages/react/use-layout-effect/src/useLayoutEffect.tsx\nimport * as React from \"react\";\nvar useLayoutEffect2 = Boolean(globalThis?.document) ? React.useLayoutEffect : () => {\n};\nexport {\n  useLayoutEffect2 as useLayoutEffect\n};\n//# sourceMappingURL=index.mjs.map\n","import createLucideIcon from '../createLucideIcon';\n\n/**\n * @component @name X\n * @description Lucide SVG icon component, renders SVG Element with children.\n *\n * @preview ![img](data:image/svg+xml;base64,PHN2ZyAgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIgogIHdpZHRoPSIyNCIKICBoZWlnaHQ9IjI0IgogIHZpZXdCb3g9IjAgMCAyNCAyNCIKICBmaWxsPSJub25lIgogIHN0cm9rZT0iIzAwMCIgc3R5bGU9ImJhY2tncm91bmQtY29sb3I6ICNmZmY7IGJvcmRlci1yYWRpdXM6IDJweCIKICBzdHJva2Utd2lkdGg9IjIiCiAgc3Ryb2tlLWxpbmVjYXA9InJvdW5kIgogIHN0cm9rZS1saW5lam9pbj0icm91bmQiCj4KICA8cGF0aCBkPSJNMTggNiA2IDE4IiAvPgogIDxwYXRoIGQ9Im02IDYgMTIgMTIiIC8+Cjwvc3ZnPgo=) - https://lucide.dev/icons/x\n * @see https://lucide.dev/guide/packages/lucide-react - Documentation\n *\n * @param {Object} props - Lucide icons props and any valid SVG attribute\n * @returns {JSX.Element} JSX Element\n *\n */\nconst X = createLucideIcon('X', [\n  ['path', { d: 'M18 6 6 18', key: '1bl5f8' }],\n  ['path', { d: 'm6 6 12 12', key: 'd8bk6v' }],\n]);\n\nexport default X;\n","// packages/react/primitive/src/Primitive.tsx\nimport * as React from \"react\";\nimport * as ReactDOM from \"react-dom\";\nimport { Slot } from \"@radix-ui/react-slot\";\nimport { jsx } from \"react/jsx-runtime\";\nvar NODES = [\n  \"a\",\n  \"button\",\n  \"div\",\n  \"form\",\n  \"h2\",\n  \"h3\",\n  \"img\",\n  \"input\",\n  \"label\",\n  \"li\",\n  \"nav\",\n  \"ol\",\n  \"p\",\n  \"span\",\n  \"svg\",\n  \"ul\"\n];\nvar Primitive = NODES.reduce((primitive, node) => {\n  const Node = React.forwardRef((props, forwardedRef) => {\n    const { asChild, ...primitiveProps } = props;\n    const Comp = asChild ? Slot : node;\n    if (typeof window !== \"undefined\") {\n      window[Symbol.for(\"radix-ui\")] = true;\n    }\n    return /* @__PURE__ */ jsx(Comp, { ...primitiveProps, ref: forwardedRef });\n  });\n  Node.displayName = `Primitive.${node}`;\n  return { ...primitive, [node]: Node };\n}, {});\nfunction dispatchDiscreteCustomEvent(target, event) {\n  if (target) ReactDOM.flushSync(() => target.dispatchEvent(event));\n}\nvar Root = Primitive;\nexport {\n  Primitive,\n  Root,\n  dispatchDiscreteCustomEvent\n};\n//# sourceMappingURL=index.mjs.map\n","/**\n * Copyright 2022 Joe Bell. All rights reserved.\n *\n * This file is licensed to you under the Apache License, Version 2.0\n * (the \"License\"); you may not use this file except in compliance with the\n * License. You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR REPRESENTATIONS OF ANY KIND, either express or implied. See the\n * License for the specific language governing permissions and limitations under\n * the License.\n */ import { clsx } from \"clsx\";\nconst falsyToString = (value)=>typeof value === \"boolean\" ? `${value}` : value === 0 ? \"0\" : value;\nexport const cx = clsx;\nexport const cva = (base, config)=>(props)=>{\n        var _config_compoundVariants;\n        if ((config === null || config === void 0 ? void 0 : config.variants) == null) return cx(base, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);\n        const { variants, defaultVariants } = config;\n        const getVariantClassNames = Object.keys(variants).map((variant)=>{\n            const variantProp = props === null || props === void 0 ? void 0 : props[variant];\n            const defaultVariantProp = defaultVariants === null || defaultVariants === void 0 ? void 0 : defaultVariants[variant];\n            if (variantProp === null) return null;\n            const variantKey = falsyToString(variantProp) || falsyToString(defaultVariantProp);\n            return variants[variant][variantKey];\n        });\n        const propsWithoutUndefined = props && Object.entries(props).reduce((acc, param)=>{\n            let [key, value] = param;\n            if (value === undefined) {\n                return acc;\n            }\n            acc[key] = value;\n            return acc;\n        }, {});\n        const getCompoundVariantClassNames = config === null || config === void 0 ? void 0 : (_config_compoundVariants = config.compoundVariants) === null || _config_compoundVariants === void 0 ? void 0 : _config_compoundVariants.reduce((acc, param)=>{\n            let { class: cvClass, className: cvClassName, ...compoundVariantOptions } = param;\n            return Object.entries(compoundVariantOptions).every((param)=>{\n                let [key, value] = param;\n                return Array.isArray(value) ? value.includes({\n                    ...defaultVariants,\n                    ...propsWithoutUndefined\n                }[key]) : ({\n                    ...defaultVariants,\n                    ...propsWithoutUndefined\n                })[key] === value;\n            }) ? [\n                ...acc,\n                cvClass,\n                cvClassName\n            ] : acc;\n        }, []);\n        return cx(base, getVariantClassNames, getCompoundVariantClassNames, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);\n    };\n\n","// extracted by mini-css-extract-plugin\nmodule.exports = {\"style\":{\"fontFamily\":\"'Inter', 'Inter Fallback'\",\"fontStyle\":\"normal\"},\"className\":\"__className_d65c78\",\"variable\":\"__variable_d65c78\"};","import React from 'react';\nimport { createContextScope } from '@radix-ui/react-context';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { Slot } from '@radix-ui/react-slot';\n\ntype SlotProps = React.ComponentPropsWithoutRef<typeof Slot>;\ntype CollectionElement = HTMLElement;\ninterface CollectionProps extends SlotProps {\n  scope: any;\n}\n\n// We have resorted to returning slots directly rather than exposing primitives that can then\n// be slotted like `<CollectionItem as={Slot}>…</CollectionItem>`.\n// This is because we encountered issues with generic types that cannot be statically analysed\n// due to creating them dynamically via createCollection.\n\nfunction createCollection<ItemElement extends HTMLElement, ItemData = {}>(name: string) {\n  /* -----------------------------------------------------------------------------------------------\n   * CollectionProvider\n   * ---------------------------------------------------------------------------------------------*/\n\n  const PROVIDER_NAME = name + 'CollectionProvider';\n  const [createCollectionContext, createCollectionScope] = createContextScope(PROVIDER_NAME);\n\n  type ContextValue = {\n    collectionRef: React.RefObject<CollectionElement | null>;\n    itemMap: Map<\n      React.RefObject<ItemElement | null>,\n      { ref: React.RefObject<ItemElement | null> } & ItemData\n    >;\n  };\n\n  const [CollectionProviderImpl, useCollectionContext] = createCollectionContext<ContextValue>(\n    PROVIDER_NAME,\n    { collectionRef: { current: null }, itemMap: new Map() }\n  );\n\n  const CollectionProvider: React.FC<{ children?: React.ReactNode; scope: any }> = (props) => {\n    const { scope, children } = props;\n    const ref = React.useRef<CollectionElement>(null);\n    const itemMap = React.useRef<ContextValue['itemMap']>(new Map()).current;\n    return (\n      <CollectionProviderImpl scope={scope} itemMap={itemMap} collectionRef={ref}>\n        {children}\n      </CollectionProviderImpl>\n    );\n  };\n\n  CollectionProvider.displayName = PROVIDER_NAME;\n\n  /* -----------------------------------------------------------------------------------------------\n   * CollectionSlot\n   * ---------------------------------------------------------------------------------------------*/\n\n  const COLLECTION_SLOT_NAME = name + 'CollectionSlot';\n\n  const CollectionSlot = React.forwardRef<CollectionElement, CollectionProps>(\n    (props, forwardedRef) => {\n      const { scope, children } = props;\n      const context = useCollectionContext(COLLECTION_SLOT_NAME, scope);\n      const composedRefs = useComposedRefs(forwardedRef, context.collectionRef);\n      return <Slot ref={composedRefs}>{children}</Slot>;\n    }\n  );\n\n  CollectionSlot.displayName = COLLECTION_SLOT_NAME;\n\n  /* -----------------------------------------------------------------------------------------------\n   * CollectionItem\n   * ---------------------------------------------------------------------------------------------*/\n\n  const ITEM_SLOT_NAME = name + 'CollectionItemSlot';\n  const ITEM_DATA_ATTR = 'data-radix-collection-item';\n\n  type CollectionItemSlotProps = ItemData & {\n    children: React.ReactNode;\n    scope: any;\n  };\n\n  const CollectionItemSlot = React.forwardRef<ItemElement, CollectionItemSlotProps>(\n    (props, forwardedRef) => {\n      const { scope, children, ...itemData } = props;\n      const ref = React.useRef<ItemElement>(null);\n      const composedRefs = useComposedRefs(forwardedRef, ref);\n      const context = useCollectionContext(ITEM_SLOT_NAME, scope);\n\n      React.useEffect(() => {\n        context.itemMap.set(ref, { ref, ...(itemData as unknown as ItemData) });\n        return () => void context.itemMap.delete(ref);\n      });\n\n      return (\n        <Slot {...{ [ITEM_DATA_ATTR]: '' }} ref={composedRefs}>\n          {children}\n        </Slot>\n      );\n    }\n  );\n\n  CollectionItemSlot.displayName = ITEM_SLOT_NAME;\n\n  /* -----------------------------------------------------------------------------------------------\n   * useCollection\n   * ---------------------------------------------------------------------------------------------*/\n\n  function useCollection(scope: any) {\n    const context = useCollectionContext(name + 'CollectionConsumer', scope);\n\n    const getItems = React.useCallback(() => {\n      const collectionNode = context.collectionRef.current;\n      if (!collectionNode) return [];\n      const orderedNodes = Array.from(collectionNode.querySelectorAll(`[${ITEM_DATA_ATTR}]`));\n      const items = Array.from(context.itemMap.values());\n      const orderedItems = items.sort(\n        (a, b) => orderedNodes.indexOf(a.ref.current!) - orderedNodes.indexOf(b.ref.current!)\n      );\n      return orderedItems;\n    }, [context.collectionRef, context.itemMap]);\n\n    return getItems;\n  }\n\n  return [\n    { Provider: CollectionProvider, Slot: CollectionSlot, ItemSlot: CollectionItemSlot },\n    useCollection,\n    createCollectionScope,\n  ] as const;\n}\n\nexport { createCollection };\nexport type { CollectionProps };\n","// packages/core/primitive/src/primitive.tsx\nfunction composeEventHandlers(originalEventHandler, ourEventHandler, { checkForDefaultPrevented = true } = {}) {\n  return function handleEvent(event) {\n    originalEventHandler?.(event);\n    if (checkForDefaultPrevented === false || !event.defaultPrevented) {\n      return ourEventHandler?.(event);\n    }\n  };\n}\nexport {\n  composeEventHandlers\n};\n//# sourceMappingURL=index.mjs.map\n","// src/queryCache.ts\nimport { hashQueryKeyByOptions, matchQuery } from \"./utils.js\";\nimport { Query } from \"./query.js\";\nimport { notifyManager } from \"./notifyManager.js\";\nimport { Subscribable } from \"./subscribable.js\";\nvar QueryCache = class extends Subscribable {\n  constructor(config = {}) {\n    super();\n    this.config = config;\n    this.#queries = /* @__PURE__ */ new Map();\n  }\n  #queries;\n  build(client, options, state) {\n    const queryKey = options.queryKey;\n    const queryHash = options.queryHash ?? hashQueryKeyByOptions(queryKey, options);\n    let query = this.get(queryHash);\n    if (!query) {\n      query = new Query({\n        cache: this,\n        queryKey,\n        queryHash,\n        options: client.defaultQueryOptions(options),\n        state,\n        defaultOptions: client.getQueryDefaults(queryKey)\n      });\n      this.add(query);\n    }\n    return query;\n  }\n  add(query) {\n    if (!this.#queries.has(query.queryHash)) {\n      this.#queries.set(query.queryHash, query);\n      this.notify({\n        type: \"added\",\n        query\n      });\n    }\n  }\n  remove(query) {\n    const queryInMap = this.#queries.get(query.queryHash);\n    if (queryInMap) {\n      query.destroy();\n      if (queryInMap === query) {\n        this.#queries.delete(query.queryHash);\n      }\n      this.notify({ type: \"removed\", query });\n    }\n  }\n  clear() {\n    notifyManager.batch(() => {\n      this.getAll().forEach((query) => {\n        this.remove(query);\n      });\n    });\n  }\n  get(queryHash) {\n    return this.#queries.get(queryHash);\n  }\n  getAll() {\n    return [...this.#queries.values()];\n  }\n  find(filters) {\n    const defaultedFilters = { exact: true, ...filters };\n    return this.getAll().find(\n      (query) => matchQuery(defaultedFilters, query)\n    );\n  }\n  findAll(filters = {}) {\n    const queries = this.getAll();\n    return Object.keys(filters).length > 0 ? queries.filter((query) => matchQuery(filters, query)) : queries;\n  }\n  notify(event) {\n    notifyManager.batch(() => {\n      this.listeners.forEach((listener) => {\n        listener(event);\n      });\n    });\n  }\n  onFocus() {\n    notifyManager.batch(() => {\n      this.getAll().forEach((query) => {\n        query.onFocus();\n      });\n    });\n  }\n  onOnline() {\n    notifyManager.batch(() => {\n      this.getAll().forEach((query) => {\n        query.onOnline();\n      });\n    });\n  }\n};\nexport {\n  QueryCache\n};\n//# sourceMappingURL=queryCache.js.map","// src/mutationCache.ts\nimport { notifyManager } from \"./notifyManager.js\";\nimport { Mutation } from \"./mutation.js\";\nimport { matchMutation, noop } from \"./utils.js\";\nimport { Subscribable } from \"./subscribable.js\";\nvar MutationCache = class extends Subscribable {\n  constructor(config = {}) {\n    super();\n    this.config = config;\n    this.#mutations = /* @__PURE__ */ new Set();\n    this.#scopes = /* @__PURE__ */ new Map();\n    this.#mutationId = 0;\n  }\n  #mutations;\n  #scopes;\n  #mutationId;\n  build(client, options, state) {\n    const mutation = new Mutation({\n      mutationCache: this,\n      mutationId: ++this.#mutationId,\n      options: client.defaultMutationOptions(options),\n      state\n    });\n    this.add(mutation);\n    return mutation;\n  }\n  add(mutation) {\n    this.#mutations.add(mutation);\n    const scope = scopeFor(mutation);\n    if (typeof scope === \"string\") {\n      const scopedMutations = this.#scopes.get(scope);\n      if (scopedMutations) {\n        scopedMutations.push(mutation);\n      } else {\n        this.#scopes.set(scope, [mutation]);\n      }\n    }\n    this.notify({ type: \"added\", mutation });\n  }\n  remove(mutation) {\n    if (this.#mutations.delete(mutation)) {\n      const scope = scopeFor(mutation);\n      if (typeof scope === \"string\") {\n        const scopedMutations = this.#scopes.get(scope);\n        if (scopedMutations) {\n          if (scopedMutations.length > 1) {\n            const index = scopedMutations.indexOf(mutation);\n            if (index !== -1) {\n              scopedMutations.splice(index, 1);\n            }\n          } else if (scopedMutations[0] === mutation) {\n            this.#scopes.delete(scope);\n          }\n        }\n      }\n    }\n    this.notify({ type: \"removed\", mutation });\n  }\n  canRun(mutation) {\n    const scope = scopeFor(mutation);\n    if (typeof scope === \"string\") {\n      const mutationsWithSameScope = this.#scopes.get(scope);\n      const firstPendingMutation = mutationsWithSameScope?.find(\n        (m) => m.state.status === \"pending\"\n      );\n      return !firstPendingMutation || firstPendingMutation === mutation;\n    } else {\n      return true;\n    }\n  }\n  runNext(mutation) {\n    const scope = scopeFor(mutation);\n    if (typeof scope === \"string\") {\n      const foundMutation = this.#scopes.get(scope)?.find((m) => m !== mutation && m.state.isPaused);\n      return foundMutation?.continue() ?? Promise.resolve();\n    } else {\n      return Promise.resolve();\n    }\n  }\n  clear() {\n    notifyManager.batch(() => {\n      this.#mutations.forEach((mutation) => {\n        this.notify({ type: \"removed\", mutation });\n      });\n      this.#mutations.clear();\n      this.#scopes.clear();\n    });\n  }\n  getAll() {\n    return Array.from(this.#mutations);\n  }\n  find(filters) {\n    const defaultedFilters = { exact: true, ...filters };\n    return this.getAll().find(\n      (mutation) => matchMutation(defaultedFilters, mutation)\n    );\n  }\n  findAll(filters = {}) {\n    return this.getAll().filter((mutation) => matchMutation(filters, mutation));\n  }\n  notify(event) {\n    notifyManager.batch(() => {\n      this.listeners.forEach((listener) => {\n        listener(event);\n      });\n    });\n  }\n  resumePausedMutations() {\n    const pausedMutations = this.getAll().filter((x) => x.state.isPaused);\n    return notifyManager.batch(\n      () => Promise.all(\n        pausedMutations.map((mutation) => mutation.continue().catch(noop))\n      )\n    );\n  }\n};\nfunction scopeFor(mutation) {\n  return mutation.options.scope?.id;\n}\nexport {\n  MutationCache\n};\n//# sourceMappingURL=mutationCache.js.map","// src/infiniteQueryBehavior.ts\nimport { addToEnd, addToStart, ensureQueryFn } from \"./utils.js\";\nfunction infiniteQueryBehavior(pages) {\n  return {\n    onFetch: (context, query) => {\n      const options = context.options;\n      const direction = context.fetchOptions?.meta?.fetchMore?.direction;\n      const oldPages = context.state.data?.pages || [];\n      const oldPageParams = context.state.data?.pageParams || [];\n      let result = { pages: [], pageParams: [] };\n      let currentPage = 0;\n      const fetchFn = async () => {\n        let cancelled = false;\n        const addSignalProperty = (object) => {\n          Object.defineProperty(object, \"signal\", {\n            enumerable: true,\n            get: () => {\n              if (context.signal.aborted) {\n                cancelled = true;\n              } else {\n                context.signal.addEventListener(\"abort\", () => {\n                  cancelled = true;\n                });\n              }\n              return context.signal;\n            }\n          });\n        };\n        const queryFn = ensureQueryFn(context.options, context.fetchOptions);\n        const fetchPage = async (data, param, previous) => {\n          if (cancelled) {\n            return Promise.reject();\n          }\n          if (param == null && data.pages.length) {\n            return Promise.resolve(data);\n          }\n          const queryFnContext = {\n            queryKey: context.queryKey,\n            pageParam: param,\n            direction: previous ? \"backward\" : \"forward\",\n            meta: context.options.meta\n          };\n          addSignalProperty(queryFnContext);\n          const page = await queryFn(\n            queryFnContext\n          );\n          const { maxPages } = context.options;\n          const addTo = previous ? addToStart : addToEnd;\n          return {\n            pages: addTo(data.pages, page, maxPages),\n            pageParams: addTo(data.pageParams, param, maxPages)\n          };\n        };\n        if (direction && oldPages.length) {\n          const previous = direction === \"backward\";\n          const pageParamFn = previous ? getPreviousPageParam : getNextPageParam;\n          const oldData = {\n            pages: oldPages,\n            pageParams: oldPageParams\n          };\n          const param = pageParamFn(options, oldData);\n          result = await fetchPage(oldData, param, previous);\n        } else {\n          const remainingPages = pages ?? oldPages.length;\n          do {\n            const param = currentPage === 0 ? oldPageParams[0] ?? options.initialPageParam : getNextPageParam(options, result);\n            if (currentPage > 0 && param == null) {\n              break;\n            }\n            result = await fetchPage(result, param);\n            currentPage++;\n          } while (currentPage < remainingPages);\n        }\n        return result;\n      };\n      if (context.options.persister) {\n        context.fetchFn = () => {\n          return context.options.persister?.(\n            fetchFn,\n            {\n              queryKey: context.queryKey,\n              meta: context.options.meta,\n              signal: context.signal\n            },\n            query\n          );\n        };\n      } else {\n        context.fetchFn = fetchFn;\n      }\n    }\n  };\n}\nfunction getNextPageParam(options, { pages, pageParams }) {\n  const lastIndex = pages.length - 1;\n  return pages.length > 0 ? options.getNextPageParam(\n    pages[lastIndex],\n    pages,\n    pageParams[lastIndex],\n    pageParams\n  ) : void 0;\n}\nfunction getPreviousPageParam(options, { pages, pageParams }) {\n  return pages.length > 0 ? options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams) : void 0;\n}\nfunction hasNextPage(options, data) {\n  if (!data)\n    return false;\n  return getNextPageParam(options, data) != null;\n}\nfunction hasPreviousPage(options, data) {\n  if (!data || !options.getPreviousPageParam)\n    return false;\n  return getPreviousPageParam(options, data) != null;\n}\nexport {\n  hasNextPage,\n  hasPreviousPage,\n  infiniteQueryBehavior\n};\n//# sourceMappingURL=infiniteQueryBehavior.js.map","// src/queryClient.ts\nimport {\n  functionalUpdate,\n  hashKey,\n  hashQueryKeyByOptions,\n  noop,\n  partialMatchKey,\n  resolveStaleTime,\n  skipToken\n} from \"./utils.js\";\nimport { QueryCache } from \"./queryCache.js\";\nimport { MutationCache } from \"./mutationCache.js\";\nimport { focusManager } from \"./focusManager.js\";\nimport { onlineManager } from \"./onlineManager.js\";\nimport { notifyManager } from \"./notifyManager.js\";\nimport { infiniteQueryBehavior } from \"./infiniteQueryBehavior.js\";\nvar QueryClient = class {\n  #queryCache;\n  #mutationCache;\n  #defaultOptions;\n  #queryDefaults;\n  #mutationDefaults;\n  #mountCount;\n  #unsubscribeFocus;\n  #unsubscribeOnline;\n  constructor(config = {}) {\n    this.#queryCache = config.queryCache || new QueryCache();\n    this.#mutationCache = config.mutationCache || new MutationCache();\n    this.#defaultOptions = config.defaultOptions || {};\n    this.#queryDefaults = /* @__PURE__ */ new Map();\n    this.#mutationDefaults = /* @__PURE__ */ new Map();\n    this.#mountCount = 0;\n  }\n  mount() {\n    this.#mountCount++;\n    if (this.#mountCount !== 1)\n      return;\n    this.#unsubscribeFocus = focusManager.subscribe(async (focused) => {\n      if (focused) {\n        await this.resumePausedMutations();\n        this.#queryCache.onFocus();\n      }\n    });\n    this.#unsubscribeOnline = onlineManager.subscribe(async (online) => {\n      if (online) {\n        await this.resumePausedMutations();\n        this.#queryCache.onOnline();\n      }\n    });\n  }\n  unmount() {\n    this.#mountCount--;\n    if (this.#mountCount !== 0)\n      return;\n    this.#unsubscribeFocus?.();\n    this.#unsubscribeFocus = void 0;\n    this.#unsubscribeOnline?.();\n    this.#unsubscribeOnline = void 0;\n  }\n  isFetching(filters) {\n    return this.#queryCache.findAll({ ...filters, fetchStatus: \"fetching\" }).length;\n  }\n  isMutating(filters) {\n    return this.#mutationCache.findAll({ ...filters, status: \"pending\" }).length;\n  }\n  getQueryData(queryKey) {\n    const options = this.defaultQueryOptions({ queryKey });\n    return this.#queryCache.get(options.queryHash)?.state.data;\n  }\n  ensureQueryData(options) {\n    const defaultedOptions = this.defaultQueryOptions(options);\n    const query = this.#queryCache.build(this, defaultedOptions);\n    const cachedData = query.state.data;\n    if (cachedData === void 0) {\n      return this.fetchQuery(options);\n    }\n    if (options.revalidateIfStale && query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query))) {\n      void this.prefetchQuery(defaultedOptions);\n    }\n    return Promise.resolve(cachedData);\n  }\n  getQueriesData(filters) {\n    return this.#queryCache.findAll(filters).map(({ queryKey, state }) => {\n      const data = state.data;\n      return [queryKey, data];\n    });\n  }\n  setQueryData(queryKey, updater, options) {\n    const defaultedOptions = this.defaultQueryOptions({ queryKey });\n    const query = this.#queryCache.get(\n      defaultedOptions.queryHash\n    );\n    const prevData = query?.state.data;\n    const data = functionalUpdate(updater, prevData);\n    if (data === void 0) {\n      return void 0;\n    }\n    return this.#queryCache.build(this, defaultedOptions).setData(data, { ...options, manual: true });\n  }\n  setQueriesData(filters, updater, options) {\n    return notifyManager.batch(\n      () => this.#queryCache.findAll(filters).map(({ queryKey }) => [\n        queryKey,\n        this.setQueryData(queryKey, updater, options)\n      ])\n    );\n  }\n  getQueryState(queryKey) {\n    const options = this.defaultQueryOptions({ queryKey });\n    return this.#queryCache.get(\n      options.queryHash\n    )?.state;\n  }\n  removeQueries(filters) {\n    const queryCache = this.#queryCache;\n    notifyManager.batch(() => {\n      queryCache.findAll(filters).forEach((query) => {\n        queryCache.remove(query);\n      });\n    });\n  }\n  resetQueries(filters, options) {\n    const queryCache = this.#queryCache;\n    const refetchFilters = {\n      type: \"active\",\n      ...filters\n    };\n    return notifyManager.batch(() => {\n      queryCache.findAll(filters).forEach((query) => {\n        query.reset();\n      });\n      return this.refetchQueries(refetchFilters, options);\n    });\n  }\n  cancelQueries(filters, cancelOptions = {}) {\n    const defaultedCancelOptions = { revert: true, ...cancelOptions };\n    const promises = notifyManager.batch(\n      () => this.#queryCache.findAll(filters).map((query) => query.cancel(defaultedCancelOptions))\n    );\n    return Promise.all(promises).then(noop).catch(noop);\n  }\n  invalidateQueries(filters, options = {}) {\n    return notifyManager.batch(() => {\n      this.#queryCache.findAll(filters).forEach((query) => {\n        query.invalidate();\n      });\n      if (filters?.refetchType === \"none\") {\n        return Promise.resolve();\n      }\n      const refetchFilters = {\n        ...filters,\n        type: filters?.refetchType ?? filters?.type ?? \"active\"\n      };\n      return this.refetchQueries(refetchFilters, options);\n    });\n  }\n  refetchQueries(filters, options = {}) {\n    const fetchOptions = {\n      ...options,\n      cancelRefetch: options.cancelRefetch ?? true\n    };\n    const promises = notifyManager.batch(\n      () => this.#queryCache.findAll(filters).filter((query) => !query.isDisabled()).map((query) => {\n        let promise = query.fetch(void 0, fetchOptions);\n        if (!fetchOptions.throwOnError) {\n          promise = promise.catch(noop);\n        }\n        return query.state.fetchStatus === \"paused\" ? Promise.resolve() : promise;\n      })\n    );\n    return Promise.all(promises).then(noop);\n  }\n  fetchQuery(options) {\n    const defaultedOptions = this.defaultQueryOptions(options);\n    if (defaultedOptions.retry === void 0) {\n      defaultedOptions.retry = false;\n    }\n    const query = this.#queryCache.build(this, defaultedOptions);\n    return query.isStaleByTime(\n      resolveStaleTime(defaultedOptions.staleTime, query)\n    ) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);\n  }\n  prefetchQuery(options) {\n    return this.fetchQuery(options).then(noop).catch(noop);\n  }\n  fetchInfiniteQuery(options) {\n    options.behavior = infiniteQueryBehavior(options.pages);\n    return this.fetchQuery(options);\n  }\n  prefetchInfiniteQuery(options) {\n    return this.fetchInfiniteQuery(options).then(noop).catch(noop);\n  }\n  ensureInfiniteQueryData(options) {\n    options.behavior = infiniteQueryBehavior(options.pages);\n    return this.ensureQueryData(options);\n  }\n  resumePausedMutations() {\n    if (onlineManager.isOnline()) {\n      return this.#mutationCache.resumePausedMutations();\n    }\n    return Promise.resolve();\n  }\n  getQueryCache() {\n    return this.#queryCache;\n  }\n  getMutationCache() {\n    return this.#mutationCache;\n  }\n  getDefaultOptions() {\n    return this.#defaultOptions;\n  }\n  setDefaultOptions(options) {\n    this.#defaultOptions = options;\n  }\n  setQueryDefaults(queryKey, options) {\n    this.#queryDefaults.set(hashKey(queryKey), {\n      queryKey,\n      defaultOptions: options\n    });\n  }\n  getQueryDefaults(queryKey) {\n    const defaults = [...this.#queryDefaults.values()];\n    const result = {};\n    defaults.forEach((queryDefault) => {\n      if (partialMatchKey(queryKey, queryDefault.queryKey)) {\n        Object.assign(result, queryDefault.defaultOptions);\n      }\n    });\n    return result;\n  }\n  setMutationDefaults(mutationKey, options) {\n    this.#mutationDefaults.set(hashKey(mutationKey), {\n      mutationKey,\n      defaultOptions: options\n    });\n  }\n  getMutationDefaults(mutationKey) {\n    const defaults = [...this.#mutationDefaults.values()];\n    let result = {};\n    defaults.forEach((queryDefault) => {\n      if (partialMatchKey(mutationKey, queryDefault.mutationKey)) {\n        result = { ...result, ...queryDefault.defaultOptions };\n      }\n    });\n    return result;\n  }\n  defaultQueryOptions(options) {\n    if (options._defaulted) {\n      return options;\n    }\n    const defaultedOptions = {\n      ...this.#defaultOptions.queries,\n      ...this.getQueryDefaults(options.queryKey),\n      ...options,\n      _defaulted: true\n    };\n    if (!defaultedOptions.queryHash) {\n      defaultedOptions.queryHash = hashQueryKeyByOptions(\n        defaultedOptions.queryKey,\n        defaultedOptions\n      );\n    }\n    if (defaultedOptions.refetchOnReconnect === void 0) {\n      defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== \"always\";\n    }\n    if (defaultedOptions.throwOnError === void 0) {\n      defaultedOptions.throwOnError = !!defaultedOptions.suspense;\n    }\n    if (!defaultedOptions.networkMode && defaultedOptions.persister) {\n      defaultedOptions.networkMode = \"offlineFirst\";\n    }\n    if (defaultedOptions.queryFn === skipToken) {\n      defaultedOptions.enabled = false;\n    }\n    return defaultedOptions;\n  }\n  defaultMutationOptions(options) {\n    if (options?._defaulted) {\n      return options;\n    }\n    return {\n      ...this.#defaultOptions.mutations,\n      ...options?.mutationKey && this.getMutationDefaults(options.mutationKey),\n      ...options,\n      _defaulted: true\n    };\n  }\n  clear() {\n    this.#queryCache.clear();\n    this.#mutationCache.clear();\n  }\n};\nexport {\n  QueryClient\n};\n//# sourceMappingURL=queryClient.js.map","// packages/react/slot/src/Slot.tsx\nimport * as React from \"react\";\nimport { composeRefs } from \"@radix-ui/react-compose-refs\";\nimport { Fragment, jsx } from \"react/jsx-runtime\";\nvar Slot = React.forwardRef((props, forwardedRef) => {\n  const { children, ...slotProps } = props;\n  const childrenArray = React.Children.toArray(children);\n  const slottable = childrenArray.find(isSlottable);\n  if (slottable) {\n    const newElement = slottable.props.children;\n    const newChildren = childrenArray.map((child) => {\n      if (child === slottable) {\n        if (React.Children.count(newElement) > 1) return React.Children.only(null);\n        return React.isValidElement(newElement) ? newElement.props.children : null;\n      } else {\n        return child;\n      }\n    });\n    return /* @__PURE__ */ jsx(SlotClone, { ...slotProps, ref: forwardedRef, children: React.isValidElement(newElement) ? React.cloneElement(newElement, void 0, newChildren) : null });\n  }\n  return /* @__PURE__ */ jsx(SlotClone, { ...slotProps, ref: forwardedRef, children });\n});\nSlot.displayName = \"Slot\";\nvar SlotClone = React.forwardRef((props, forwardedRef) => {\n  const { children, ...slotProps } = props;\n  if (React.isValidElement(children)) {\n    const childrenRef = getElementRef(children);\n    return React.cloneElement(children, {\n      ...mergeProps(slotProps, children.props),\n      // @ts-ignore\n      ref: forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef\n    });\n  }\n  return React.Children.count(children) > 1 ? React.Children.only(null) : null;\n});\nSlotClone.displayName = \"SlotClone\";\nvar Slottable = ({ children }) => {\n  return /* @__PURE__ */ jsx(Fragment, { children });\n};\nfunction isSlottable(child) {\n  return React.isValidElement(child) && child.type === Slottable;\n}\nfunction mergeProps(slotProps, childProps) {\n  const overrideProps = { ...childProps };\n  for (const propName in childProps) {\n    const slotPropValue = slotProps[propName];\n    const childPropValue = childProps[propName];\n    const isHandler = /^on[A-Z]/.test(propName);\n    if (isHandler) {\n      if (slotPropValue && childPropValue) {\n        overrideProps[propName] = (...args) => {\n          childPropValue(...args);\n          slotPropValue(...args);\n        };\n      } else if (slotPropValue) {\n        overrideProps[propName] = slotPropValue;\n      }\n    } else if (propName === \"style\") {\n      overrideProps[propName] = { ...slotPropValue, ...childPropValue };\n    } else if (propName === \"className\") {\n      overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(\" \");\n    }\n  }\n  return { ...slotProps, ...overrideProps };\n}\nfunction getElementRef(element) {\n  let getter = Object.getOwnPropertyDescriptor(element.props, \"ref\")?.get;\n  let mayWarn = getter && \"isReactWarning\" in getter && getter.isReactWarning;\n  if (mayWarn) {\n    return element.ref;\n  }\n  getter = Object.getOwnPropertyDescriptor(element, \"ref\")?.get;\n  mayWarn = getter && \"isReactWarning\" in getter && getter.isReactWarning;\n  if (mayWarn) {\n    return element.props.ref;\n  }\n  return element.props.ref || element.ref;\n}\nvar Root = Slot;\nexport {\n  Root,\n  Slot,\n  Slottable\n};\n//# sourceMappingURL=index.mjs.map\n"],"names":["node","handleAndDispatchPointerDownOutsideEvent","duration","event","Root"],"sourceRoot":"","ignoreList":[0,1,2,3,13,14,15,17,18,19,21,22,23,24,25,26]}