{"version":3,"file":"static/chunks/9998-d26371d5207d2fc9.js","mappings":"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","sources":["webpack://_N_E/./node_modules/lodash.debounce/index.js","webpack://_N_E/./node_modules/next/dist/api/app-dynamic.js","webpack://_N_E/../../../src/shared/lib/app-dynamic.tsx","webpack://_N_E/../../../../src/shared/lib/lazy-dynamic/dynamic-bailout-to-csr.tsx","webpack://_N_E/../../../../src/shared/lib/lazy-dynamic/loadable.tsx","webpack://_N_E/../../../../src/shared/lib/lazy-dynamic/preload-css.tsx","webpack://_N_E/./node_modules/next/font/local/target.css","webpack://_N_E/./node_modules/@radix-ui/primitive/dist/index.mjs","webpack://_N_E/./node_modules/@radix-ui/react-compose-refs/dist/index.mjs","webpack://_N_E/./node_modules/@radix-ui/react-context/dist/index.mjs","webpack://_N_E/./node_modules/@radix-ui/react-id/dist/index.mjs","webpack://_N_E/../src/Presence.tsx","webpack://_N_E/../src/useStateMachine.tsx","webpack://_N_E/./node_modules/@radix-ui/react-primitive/dist/index.mjs","webpack://_N_E/../src/collection.tsx","webpack://_N_E/./node_modules/@radix-ui/react-direction/dist/index.mjs","webpack://_N_E/../src/roving-focus-group.tsx","webpack://_N_E/./node_modules/@radix-ui/react-use-previous/dist/index.mjs","webpack://_N_E/../src/radio-group.tsx","webpack://_N_E/../src/radio.tsx","webpack://_N_E/./node_modules/@radix-ui/react-slot/dist/index.mjs","webpack://_N_E/./node_modules/@radix-ui/react-use-callback-ref/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-use-layout-effect/dist/index.mjs","webpack://_N_E/./node_modules/@radix-ui/react-use-size/dist/index.mjs"],"sourcesContent":["/**\n * lodash (Custom Build) <https://lodash.com/>\n * Build: `lodash modularize exports=\"npm\" -o ./`\n * Copyright jQuery Foundation and other contributors <https://jquery.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n\n/** Used as the `TypeError` message for \"Functions\" methods. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/** Used to match leading and trailing whitespace. */\nvar reTrim = /^\\s+|\\s+$/g;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar objectToString = objectProto.toString;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        result = wait - timeSinceLastCall;\n\n    return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\n/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n  var type = typeof value;\n  return !!value && (type == 'object' || type == 'function');\n}\n\n/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n  return !!value && typeof value == 'object';\n}\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n  return typeof value == 'symbol' ||\n    (isObjectLike(value) && objectToString.call(value) == symbolTag);\n}\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = value.replace(reTrim, '');\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nmodule.exports = debounce;\n","export * from \"../shared/lib/app-dynamic\";\nexport { default } from \"../shared/lib/app-dynamic\";\n\n//# sourceMappingURL=app-dynamic.js.map",null,null,null,null,"// extracted by mini-css-extract-plugin\nmodule.exports = {\"style\":{\"fontFamily\":\"'__tiemposFont_b85bab', '__tiemposFont_Fallback_b85bab'\"},\"className\":\"__className_b85bab\",\"variable\":\"__variable_b85bab\"};","// 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","// 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/context/src/createContext.tsx\nimport * as React from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nfunction createContext2(rootComponentName, defaultContext) {\n  const Context = React.createContext(defaultContext);\n  const Provider = (props) => {\n    const { children, ...context } = props;\n    const value = React.useMemo(() => context, Object.values(context));\n    return /* @__PURE__ */ jsx(Context.Provider, { value, children });\n  };\n  Provider.displayName = rootComponentName + \"Provider\";\n  function useContext2(consumerName) {\n    const context = React.useContext(Context);\n    if (context) return context;\n    if (defaultContext !== void 0) return defaultContext;\n    throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n  }\n  return [Provider, useContext2];\n}\nfunction createContextScope(scopeName, createContextScopeDeps = []) {\n  let defaultContexts = [];\n  function createContext3(rootComponentName, defaultContext) {\n    const BaseContext = React.createContext(defaultContext);\n    const index = defaultContexts.length;\n    defaultContexts = [...defaultContexts, defaultContext];\n    const Provider = (props) => {\n      const { scope, children, ...context } = props;\n      const Context = scope?.[scopeName]?.[index] || BaseContext;\n      const value = React.useMemo(() => context, Object.values(context));\n      return /* @__PURE__ */ jsx(Context.Provider, { value, children });\n    };\n    Provider.displayName = rootComponentName + \"Provider\";\n    function useContext2(consumerName, scope) {\n      const Context = scope?.[scopeName]?.[index] || BaseContext;\n      const context = React.useContext(Context);\n      if (context) return context;\n      if (defaultContext !== void 0) return defaultContext;\n      throw new Error(`\\`${consumerName}\\` must be used within \\`${rootComponentName}\\``);\n    }\n    return [Provider, useContext2];\n  }\n  const createScope = () => {\n    const scopeContexts = defaultContexts.map((defaultContext) => {\n      return React.createContext(defaultContext);\n    });\n    return function useScope(scope) {\n      const contexts = scope?.[scopeName] || scopeContexts;\n      return React.useMemo(\n        () => ({ [`__scope${scopeName}`]: { ...scope, [scopeName]: contexts } }),\n        [scope, contexts]\n      );\n    };\n  };\n  createScope.scopeName = scopeName;\n  return [createContext3, composeContextScopes(createScope, ...createContextScopeDeps)];\n}\nfunction composeContextScopes(...scopes) {\n  const baseScope = scopes[0];\n  if (scopes.length === 1) return baseScope;\n  const createScope = () => {\n    const scopeHooks = scopes.map((createScope2) => ({\n      useScope: createScope2(),\n      scopeName: createScope2.scopeName\n    }));\n    return function useComposedScopes(overrideScopes) {\n      const nextScopes = scopeHooks.reduce((nextScopes2, { useScope, scopeName }) => {\n        const scopeProps = useScope(overrideScopes);\n        const currentScope = scopeProps[`__scope${scopeName}`];\n        return { ...nextScopes2, ...currentScope };\n      }, {});\n      return React.useMemo(() => ({ [`__scope${baseScope.scopeName}`]: nextScopes }), [nextScopes]);\n    };\n  };\n  createScope.scopeName = baseScope.scopeName;\n  return createScope;\n}\nexport {\n  createContext2 as createContext,\n  createContextScope\n};\n//# sourceMappingURL=index.mjs.map\n","// packages/react/id/src/id.tsx\nimport * as React from \"react\";\nimport { useLayoutEffect } from \"@radix-ui/react-use-layout-effect\";\nvar useReactId = React[\"useId\".toString()] || (() => void 0);\nvar count = 0;\nfunction useId(deterministicId) {\n  const [id, setId] = React.useState(useReactId());\n  useLayoutEffect(() => {\n    if (!deterministicId) setId((reactId) => reactId ?? String(count++));\n  }, [deterministicId]);\n  return deterministicId || (id ? `radix-${id}` : \"\");\n}\nexport {\n  useId\n};\n//# sourceMappingURL=index.mjs.map\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","// 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","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/react/direction/src/Direction.tsx\nimport * as React from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nvar DirectionContext = React.createContext(void 0);\nvar DirectionProvider = (props) => {\n  const { dir, children } = props;\n  return /* @__PURE__ */ jsx(DirectionContext.Provider, { value: dir, children });\n};\nfunction useDirection(localDir) {\n  const globalDir = React.useContext(DirectionContext);\n  return localDir || globalDir || \"ltr\";\n}\nvar Provider = DirectionProvider;\nexport {\n  DirectionProvider,\n  Provider,\n  useDirection\n};\n//# sourceMappingURL=index.mjs.map\n","import * as React from 'react';\nimport { composeEventHandlers } from '@radix-ui/primitive';\nimport { createCollection } from '@radix-ui/react-collection';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { createContextScope } from '@radix-ui/react-context';\nimport { useId } from '@radix-ui/react-id';\nimport { Primitive } from '@radix-ui/react-primitive';\nimport { useCallbackRef } from '@radix-ui/react-use-callback-ref';\nimport { useControllableState } from '@radix-ui/react-use-controllable-state';\nimport { useDirection } from '@radix-ui/react-direction';\n\nimport type { Scope } from '@radix-ui/react-context';\n\nconst ENTRY_FOCUS = 'rovingFocusGroup.onEntryFocus';\nconst EVENT_OPTIONS = { bubbles: false, cancelable: true };\n\n/* -------------------------------------------------------------------------------------------------\n * RovingFocusGroup\n * -----------------------------------------------------------------------------------------------*/\n\nconst GROUP_NAME = 'RovingFocusGroup';\n\ntype ItemData = { id: string; focusable: boolean; active: boolean };\nconst [Collection, useCollection, createCollectionScope] = createCollection<\n  HTMLSpanElement,\n  ItemData\n>(GROUP_NAME);\n\ntype ScopedProps<P> = P & { __scopeRovingFocusGroup?: Scope };\nconst [createRovingFocusGroupContext, createRovingFocusGroupScope] = createContextScope(\n  GROUP_NAME,\n  [createCollectionScope]\n);\n\ntype Orientation = React.AriaAttributes['aria-orientation'];\ntype Direction = 'ltr' | 'rtl';\n\ninterface RovingFocusGroupOptions {\n  /**\n   * The orientation of the group.\n   * Mainly so arrow navigation is done accordingly (left & right vs. up & down)\n   */\n  orientation?: Orientation;\n  /**\n   * The direction of navigation between items.\n   */\n  dir?: Direction;\n  /**\n   * Whether keyboard navigation should loop around\n   * @defaultValue false\n   */\n  loop?: boolean;\n}\n\ntype RovingContextValue = RovingFocusGroupOptions & {\n  currentTabStopId: string | null;\n  onItemFocus(tabStopId: string): void;\n  onItemShiftTab(): void;\n  onFocusableItemAdd(): void;\n  onFocusableItemRemove(): void;\n};\n\nconst [RovingFocusProvider, useRovingFocusContext] =\n  createRovingFocusGroupContext<RovingContextValue>(GROUP_NAME);\n\ntype RovingFocusGroupElement = RovingFocusGroupImplElement;\ninterface RovingFocusGroupProps extends RovingFocusGroupImplProps {}\n\nconst RovingFocusGroup = React.forwardRef<RovingFocusGroupElement, RovingFocusGroupProps>(\n  (props: ScopedProps<RovingFocusGroupProps>, forwardedRef) => {\n    return (\n      <Collection.Provider scope={props.__scopeRovingFocusGroup}>\n        <Collection.Slot scope={props.__scopeRovingFocusGroup}>\n          <RovingFocusGroupImpl {...props} ref={forwardedRef} />\n        </Collection.Slot>\n      </Collection.Provider>\n    );\n  }\n);\n\nRovingFocusGroup.displayName = GROUP_NAME;\n\n/* -----------------------------------------------------------------------------------------------*/\n\ntype RovingFocusGroupImplElement = React.ElementRef<typeof Primitive.div>;\ntype PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface RovingFocusGroupImplProps\n  extends Omit<PrimitiveDivProps, 'dir'>,\n    RovingFocusGroupOptions {\n  currentTabStopId?: string | null;\n  defaultCurrentTabStopId?: string;\n  onCurrentTabStopIdChange?: (tabStopId: string | null) => void;\n  onEntryFocus?: (event: Event) => void;\n  preventScrollOnEntryFocus?: boolean;\n}\n\nconst RovingFocusGroupImpl = React.forwardRef<\n  RovingFocusGroupImplElement,\n  RovingFocusGroupImplProps\n>((props: ScopedProps<RovingFocusGroupImplProps>, forwardedRef) => {\n  const {\n    __scopeRovingFocusGroup,\n    orientation,\n    loop = false,\n    dir,\n    currentTabStopId: currentTabStopIdProp,\n    defaultCurrentTabStopId,\n    onCurrentTabStopIdChange,\n    onEntryFocus,\n    preventScrollOnEntryFocus = false,\n    ...groupProps\n  } = props;\n  const ref = React.useRef<RovingFocusGroupImplElement>(null);\n  const composedRefs = useComposedRefs(forwardedRef, ref);\n  const direction = useDirection(dir);\n  const [currentTabStopId = null, setCurrentTabStopId] = useControllableState({\n    prop: currentTabStopIdProp,\n    defaultProp: defaultCurrentTabStopId,\n    onChange: onCurrentTabStopIdChange,\n  });\n  const [isTabbingBackOut, setIsTabbingBackOut] = React.useState(false);\n  const handleEntryFocus = useCallbackRef(onEntryFocus);\n  const getItems = useCollection(__scopeRovingFocusGroup);\n  const isClickFocusRef = React.useRef(false);\n  const [focusableItemsCount, setFocusableItemsCount] = React.useState(0);\n\n  React.useEffect(() => {\n    const node = ref.current;\n    if (node) {\n      node.addEventListener(ENTRY_FOCUS, handleEntryFocus);\n      return () => node.removeEventListener(ENTRY_FOCUS, handleEntryFocus);\n    }\n  }, [handleEntryFocus]);\n\n  return (\n    <RovingFocusProvider\n      scope={__scopeRovingFocusGroup}\n      orientation={orientation}\n      dir={direction}\n      loop={loop}\n      currentTabStopId={currentTabStopId}\n      onItemFocus={React.useCallback(\n        (tabStopId) => setCurrentTabStopId(tabStopId),\n        [setCurrentTabStopId]\n      )}\n      onItemShiftTab={React.useCallback(() => setIsTabbingBackOut(true), [])}\n      onFocusableItemAdd={React.useCallback(\n        () => setFocusableItemsCount((prevCount) => prevCount + 1),\n        []\n      )}\n      onFocusableItemRemove={React.useCallback(\n        () => setFocusableItemsCount((prevCount) => prevCount - 1),\n        []\n      )}\n    >\n      <Primitive.div\n        tabIndex={isTabbingBackOut || focusableItemsCount === 0 ? -1 : 0}\n        data-orientation={orientation}\n        {...groupProps}\n        ref={composedRefs}\n        style={{ outline: 'none', ...props.style }}\n        onMouseDown={composeEventHandlers(props.onMouseDown, () => {\n          isClickFocusRef.current = true;\n        })}\n        onFocus={composeEventHandlers(props.onFocus, (event) => {\n          // We normally wouldn't need this check, because we already check\n          // that the focus is on the current target and not bubbling to it.\n          // We do this because Safari doesn't focus buttons when clicked, and\n          // instead, the wrapper will get focused and not through a bubbling event.\n          const isKeyboardFocus = !isClickFocusRef.current;\n\n          if (event.target === event.currentTarget && isKeyboardFocus && !isTabbingBackOut) {\n            const entryFocusEvent = new CustomEvent(ENTRY_FOCUS, EVENT_OPTIONS);\n            event.currentTarget.dispatchEvent(entryFocusEvent);\n\n            if (!entryFocusEvent.defaultPrevented) {\n              const items = getItems().filter((item) => item.focusable);\n              const activeItem = items.find((item) => item.active);\n              const currentItem = items.find((item) => item.id === currentTabStopId);\n              const candidateItems = [activeItem, currentItem, ...items].filter(\n                Boolean\n              ) as typeof items;\n              const candidateNodes = candidateItems.map((item) => item.ref.current!);\n              focusFirst(candidateNodes, preventScrollOnEntryFocus);\n            }\n          }\n\n          isClickFocusRef.current = false;\n        })}\n        onBlur={composeEventHandlers(props.onBlur, () => setIsTabbingBackOut(false))}\n      />\n    </RovingFocusProvider>\n  );\n});\n\n/* -------------------------------------------------------------------------------------------------\n * RovingFocusGroupItem\n * -----------------------------------------------------------------------------------------------*/\n\nconst ITEM_NAME = 'RovingFocusGroupItem';\n\ntype RovingFocusItemElement = React.ElementRef<typeof Primitive.span>;\ntype PrimitiveSpanProps = React.ComponentPropsWithoutRef<typeof Primitive.span>;\ninterface RovingFocusItemProps extends PrimitiveSpanProps {\n  tabStopId?: string;\n  focusable?: boolean;\n  active?: boolean;\n}\n\nconst RovingFocusGroupItem = React.forwardRef<RovingFocusItemElement, RovingFocusItemProps>(\n  (props: ScopedProps<RovingFocusItemProps>, forwardedRef) => {\n    const {\n      __scopeRovingFocusGroup,\n      focusable = true,\n      active = false,\n      tabStopId,\n      ...itemProps\n    } = props;\n    const autoId = useId();\n    const id = tabStopId || autoId;\n    const context = useRovingFocusContext(ITEM_NAME, __scopeRovingFocusGroup);\n    const isCurrentTabStop = context.currentTabStopId === id;\n    const getItems = useCollection(__scopeRovingFocusGroup);\n\n    const { onFocusableItemAdd, onFocusableItemRemove } = context;\n\n    React.useEffect(() => {\n      if (focusable) {\n        onFocusableItemAdd();\n        return () => onFocusableItemRemove();\n      }\n    }, [focusable, onFocusableItemAdd, onFocusableItemRemove]);\n\n    return (\n      <Collection.ItemSlot\n        scope={__scopeRovingFocusGroup}\n        id={id}\n        focusable={focusable}\n        active={active}\n      >\n        <Primitive.span\n          tabIndex={isCurrentTabStop ? 0 : -1}\n          data-orientation={context.orientation}\n          {...itemProps}\n          ref={forwardedRef}\n          onMouseDown={composeEventHandlers(props.onMouseDown, (event) => {\n            // We prevent focusing non-focusable items on `mousedown`.\n            // Even though the item has tabIndex={-1}, that only means take it out of the tab order.\n            if (!focusable) event.preventDefault();\n            // Safari doesn't focus a button when clicked so we run our logic on mousedown also\n            else context.onItemFocus(id);\n          })}\n          onFocus={composeEventHandlers(props.onFocus, () => context.onItemFocus(id))}\n          onKeyDown={composeEventHandlers(props.onKeyDown, (event) => {\n            if (event.key === 'Tab' && event.shiftKey) {\n              context.onItemShiftTab();\n              return;\n            }\n\n            if (event.target !== event.currentTarget) return;\n\n            const focusIntent = getFocusIntent(event, context.orientation, context.dir);\n\n            if (focusIntent !== undefined) {\n              if (event.metaKey || event.ctrlKey || event.altKey || event.shiftKey) return;\n              event.preventDefault();\n              const items = getItems().filter((item) => item.focusable);\n              let candidateNodes = items.map((item) => item.ref.current!);\n\n              if (focusIntent === 'last') candidateNodes.reverse();\n              else if (focusIntent === 'prev' || focusIntent === 'next') {\n                if (focusIntent === 'prev') candidateNodes.reverse();\n                const currentIndex = candidateNodes.indexOf(event.currentTarget);\n                candidateNodes = context.loop\n                  ? wrapArray(candidateNodes, currentIndex + 1)\n                  : candidateNodes.slice(currentIndex + 1);\n              }\n\n              /**\n               * Imperative focus during keydown is risky so we prevent React's batching updates\n               * to avoid potential bugs. See: https://github.com/facebook/react/issues/20332\n               */\n              setTimeout(() => focusFirst(candidateNodes));\n            }\n          })}\n        />\n      </Collection.ItemSlot>\n    );\n  }\n);\n\nRovingFocusGroupItem.displayName = ITEM_NAME;\n\n/* -----------------------------------------------------------------------------------------------*/\n\n// prettier-ignore\nconst MAP_KEY_TO_FOCUS_INTENT: Record<string, FocusIntent> = {\n  ArrowLeft: 'prev', ArrowUp: 'prev',\n  ArrowRight: 'next', ArrowDown: 'next',\n  PageUp: 'first', Home: 'first',\n  PageDown: 'last', End: 'last',\n};\n\nfunction getDirectionAwareKey(key: string, dir?: Direction) {\n  if (dir !== 'rtl') return key;\n  return key === 'ArrowLeft' ? 'ArrowRight' : key === 'ArrowRight' ? 'ArrowLeft' : key;\n}\n\ntype FocusIntent = 'first' | 'last' | 'prev' | 'next';\n\nfunction getFocusIntent(event: React.KeyboardEvent, orientation?: Orientation, dir?: Direction) {\n  const key = getDirectionAwareKey(event.key, dir);\n  if (orientation === 'vertical' && ['ArrowLeft', 'ArrowRight'].includes(key)) return undefined;\n  if (orientation === 'horizontal' && ['ArrowUp', 'ArrowDown'].includes(key)) return undefined;\n  return MAP_KEY_TO_FOCUS_INTENT[key];\n}\n\nfunction focusFirst(candidates: HTMLElement[], preventScroll = false) {\n  const PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;\n  for (const candidate of candidates) {\n    // if focus is already where we want to go, we don't want to keep going through the candidates\n    if (candidate === PREVIOUSLY_FOCUSED_ELEMENT) return;\n    candidate.focus({ preventScroll });\n    if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;\n  }\n}\n\n/**\n * Wraps an array around itself at a given start index\n * Example: `wrapArray(['a', 'b', 'c', 'd'], 2) === ['c', 'd', 'a', 'b']`\n */\nfunction wrapArray<T>(array: T[], startIndex: number) {\n  return array.map((_, index) => array[(startIndex + index) % array.length]);\n}\n\nconst Root = RovingFocusGroup;\nconst Item = RovingFocusGroupItem;\n\nexport {\n  createRovingFocusGroupScope,\n  //\n  RovingFocusGroup,\n  RovingFocusGroupItem,\n  //\n  Root,\n  Item,\n};\nexport type { RovingFocusGroupProps, RovingFocusItemProps };\n","// packages/react/use-previous/src/usePrevious.tsx\nimport * as React from \"react\";\nfunction usePrevious(value) {\n  const ref = React.useRef({ value, previous: value });\n  return React.useMemo(() => {\n    if (ref.current.value !== value) {\n      ref.current.previous = ref.current.value;\n      ref.current.value = value;\n    }\n    return ref.current.previous;\n  }, [value]);\n}\nexport {\n  usePrevious\n};\n//# sourceMappingURL=index.mjs.map\n","import * as React from 'react';\nimport { composeEventHandlers } from '@radix-ui/primitive';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { createContextScope } from '@radix-ui/react-context';\nimport { Primitive } from '@radix-ui/react-primitive';\nimport * as RovingFocusGroup from '@radix-ui/react-roving-focus';\nimport { createRovingFocusGroupScope } from '@radix-ui/react-roving-focus';\nimport { useControllableState } from '@radix-ui/react-use-controllable-state';\nimport { useDirection } from '@radix-ui/react-direction';\nimport { Radio, RadioIndicator, createRadioScope } from './radio';\n\nimport type { Scope } from '@radix-ui/react-context';\n\nconst ARROW_KEYS = ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'];\n\n/* -------------------------------------------------------------------------------------------------\n * RadioGroup\n * -----------------------------------------------------------------------------------------------*/\nconst RADIO_GROUP_NAME = 'RadioGroup';\n\ntype ScopedProps<P> = P & { __scopeRadioGroup?: Scope };\nconst [createRadioGroupContext, createRadioGroupScope] = createContextScope(RADIO_GROUP_NAME, [\n  createRovingFocusGroupScope,\n  createRadioScope,\n]);\nconst useRovingFocusGroupScope = createRovingFocusGroupScope();\nconst useRadioScope = createRadioScope();\n\ntype RadioGroupContextValue = {\n  name?: string;\n  required: boolean;\n  disabled: boolean;\n  value?: string;\n  onValueChange(value: string): void;\n};\n\nconst [RadioGroupProvider, useRadioGroupContext] =\n  createRadioGroupContext<RadioGroupContextValue>(RADIO_GROUP_NAME);\n\ntype RadioGroupElement = React.ElementRef<typeof Primitive.div>;\ntype RovingFocusGroupProps = React.ComponentPropsWithoutRef<typeof RovingFocusGroup.Root>;\ntype PrimitiveDivProps = React.ComponentPropsWithoutRef<typeof Primitive.div>;\ninterface RadioGroupProps extends PrimitiveDivProps {\n  name?: RadioGroupContextValue['name'];\n  required?: React.ComponentPropsWithoutRef<typeof Radio>['required'];\n  disabled?: React.ComponentPropsWithoutRef<typeof Radio>['disabled'];\n  dir?: RovingFocusGroupProps['dir'];\n  orientation?: RovingFocusGroupProps['orientation'];\n  loop?: RovingFocusGroupProps['loop'];\n  defaultValue?: string;\n  value?: RadioGroupContextValue['value'];\n  onValueChange?: RadioGroupContextValue['onValueChange'];\n}\n\nconst RadioGroup = React.forwardRef<RadioGroupElement, RadioGroupProps>(\n  (props: ScopedProps<RadioGroupProps>, forwardedRef) => {\n    const {\n      __scopeRadioGroup,\n      name,\n      defaultValue,\n      value: valueProp,\n      required = false,\n      disabled = false,\n      orientation,\n      dir,\n      loop = true,\n      onValueChange,\n      ...groupProps\n    } = props;\n    const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeRadioGroup);\n    const direction = useDirection(dir);\n    const [value, setValue] = useControllableState({\n      prop: valueProp,\n      defaultProp: defaultValue,\n      onChange: onValueChange,\n    });\n\n    return (\n      <RadioGroupProvider\n        scope={__scopeRadioGroup}\n        name={name}\n        required={required}\n        disabled={disabled}\n        value={value}\n        onValueChange={setValue}\n      >\n        <RovingFocusGroup.Root\n          asChild\n          {...rovingFocusGroupScope}\n          orientation={orientation}\n          dir={direction}\n          loop={loop}\n        >\n          <Primitive.div\n            role=\"radiogroup\"\n            aria-required={required}\n            aria-orientation={orientation}\n            data-disabled={disabled ? '' : undefined}\n            dir={direction}\n            {...groupProps}\n            ref={forwardedRef}\n          />\n        </RovingFocusGroup.Root>\n      </RadioGroupProvider>\n    );\n  }\n);\n\nRadioGroup.displayName = RADIO_GROUP_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * RadioGroupItem\n * -----------------------------------------------------------------------------------------------*/\n\nconst ITEM_NAME = 'RadioGroupItem';\n\ntype RadioGroupItemElement = React.ElementRef<typeof Radio>;\ntype RadioProps = React.ComponentPropsWithoutRef<typeof Radio>;\ninterface RadioGroupItemProps extends Omit<RadioProps, 'onCheck' | 'name'> {\n  value: string;\n}\n\nconst RadioGroupItem = React.forwardRef<RadioGroupItemElement, RadioGroupItemProps>(\n  (props: ScopedProps<RadioGroupItemProps>, forwardedRef) => {\n    const { __scopeRadioGroup, disabled, ...itemProps } = props;\n    const context = useRadioGroupContext(ITEM_NAME, __scopeRadioGroup);\n    const isDisabled = context.disabled || disabled;\n    const rovingFocusGroupScope = useRovingFocusGroupScope(__scopeRadioGroup);\n    const radioScope = useRadioScope(__scopeRadioGroup);\n    const ref = React.useRef<React.ElementRef<typeof Radio>>(null);\n    const composedRefs = useComposedRefs(forwardedRef, ref);\n    const checked = context.value === itemProps.value;\n    const isArrowKeyPressedRef = React.useRef(false);\n\n    React.useEffect(() => {\n      const handleKeyDown = (event: KeyboardEvent) => {\n        if (ARROW_KEYS.includes(event.key)) {\n          isArrowKeyPressedRef.current = true;\n        }\n      };\n      const handleKeyUp = () => (isArrowKeyPressedRef.current = false);\n      document.addEventListener('keydown', handleKeyDown);\n      document.addEventListener('keyup', handleKeyUp);\n      return () => {\n        document.removeEventListener('keydown', handleKeyDown);\n        document.removeEventListener('keyup', handleKeyUp);\n      };\n    }, []);\n\n    return (\n      <RovingFocusGroup.Item\n        asChild\n        {...rovingFocusGroupScope}\n        focusable={!isDisabled}\n        active={checked}\n      >\n        <Radio\n          disabled={isDisabled}\n          required={context.required}\n          checked={checked}\n          {...radioScope}\n          {...itemProps}\n          name={context.name}\n          ref={composedRefs}\n          onCheck={() => context.onValueChange(itemProps.value)}\n          onKeyDown={composeEventHandlers((event) => {\n            // According to WAI ARIA, radio groups don't activate items on enter keypress\n            if (event.key === 'Enter') event.preventDefault();\n          })}\n          onFocus={composeEventHandlers(itemProps.onFocus, () => {\n            /**\n             * Our `RovingFocusGroup` will focus the radio when navigating with arrow keys\n             * and we need to \"check\" it in that case. We click it to \"check\" it (instead\n             * of updating `context.value`) so that the radio change event fires.\n             */\n            if (isArrowKeyPressedRef.current) ref.current?.click();\n          })}\n        />\n      </RovingFocusGroup.Item>\n    );\n  }\n);\n\nRadioGroupItem.displayName = ITEM_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * RadioGroupIndicator\n * -----------------------------------------------------------------------------------------------*/\n\nconst INDICATOR_NAME = 'RadioGroupIndicator';\n\ntype RadioGroupIndicatorElement = React.ElementRef<typeof RadioIndicator>;\ntype RadioIndicatorProps = React.ComponentPropsWithoutRef<typeof RadioIndicator>;\ninterface RadioGroupIndicatorProps extends RadioIndicatorProps {}\n\nconst RadioGroupIndicator = React.forwardRef<RadioGroupIndicatorElement, RadioGroupIndicatorProps>(\n  (props: ScopedProps<RadioGroupIndicatorProps>, forwardedRef) => {\n    const { __scopeRadioGroup, ...indicatorProps } = props;\n    const radioScope = useRadioScope(__scopeRadioGroup);\n    return <RadioIndicator {...radioScope} {...indicatorProps} ref={forwardedRef} />;\n  }\n);\n\nRadioGroupIndicator.displayName = INDICATOR_NAME;\n\n/* ---------------------------------------------------------------------------------------------- */\n\nconst Root = RadioGroup;\nconst Item = RadioGroupItem;\nconst Indicator = RadioGroupIndicator;\n\nexport {\n  createRadioGroupScope,\n  //\n  RadioGroup,\n  RadioGroupItem,\n  RadioGroupIndicator,\n  //\n  Root,\n  Item,\n  Indicator,\n};\nexport type { RadioGroupProps, RadioGroupItemProps, RadioGroupIndicatorProps };\n","import * as React from 'react';\nimport { composeEventHandlers } from '@radix-ui/primitive';\nimport { useComposedRefs } from '@radix-ui/react-compose-refs';\nimport { createContextScope } from '@radix-ui/react-context';\nimport { useSize } from '@radix-ui/react-use-size';\nimport { usePrevious } from '@radix-ui/react-use-previous';\nimport { Presence } from '@radix-ui/react-presence';\nimport { Primitive } from '@radix-ui/react-primitive';\n\nimport type { Scope } from '@radix-ui/react-context';\n\n/* -------------------------------------------------------------------------------------------------\n * Radio\n * -----------------------------------------------------------------------------------------------*/\n\nconst RADIO_NAME = 'Radio';\n\ntype ScopedProps<P> = P & { __scopeRadio?: Scope };\nconst [createRadioContext, createRadioScope] = createContextScope(RADIO_NAME);\n\ntype RadioContextValue = { checked: boolean; disabled?: boolean };\nconst [RadioProvider, useRadioContext] = createRadioContext<RadioContextValue>(RADIO_NAME);\n\ntype RadioElement = React.ElementRef<typeof Primitive.button>;\ntype PrimitiveButtonProps = React.ComponentPropsWithoutRef<typeof Primitive.button>;\ninterface RadioProps extends PrimitiveButtonProps {\n  checked?: boolean;\n  required?: boolean;\n  onCheck?(): void;\n}\n\nconst Radio = React.forwardRef<RadioElement, RadioProps>(\n  (props: ScopedProps<RadioProps>, forwardedRef) => {\n    const {\n      __scopeRadio,\n      name,\n      checked = false,\n      required,\n      disabled,\n      value = 'on',\n      onCheck,\n      form,\n      ...radioProps\n    } = props;\n    const [button, setButton] = React.useState<HTMLButtonElement | null>(null);\n    const composedRefs = useComposedRefs(forwardedRef, (node) => setButton(node));\n    const hasConsumerStoppedPropagationRef = React.useRef(false);\n    // We set this to true by default so that events bubble to forms without JS (SSR)\n    const isFormControl = button ? form || !!button.closest('form') : true;\n\n    return (\n      <RadioProvider scope={__scopeRadio} checked={checked} disabled={disabled}>\n        <Primitive.button\n          type=\"button\"\n          role=\"radio\"\n          aria-checked={checked}\n          data-state={getState(checked)}\n          data-disabled={disabled ? '' : undefined}\n          disabled={disabled}\n          value={value}\n          {...radioProps}\n          ref={composedRefs}\n          onClick={composeEventHandlers(props.onClick, (event) => {\n            // radios cannot be unchecked so we only communicate a checked state\n            if (!checked) onCheck?.();\n            if (isFormControl) {\n              hasConsumerStoppedPropagationRef.current = event.isPropagationStopped();\n              // if radio is in a form, stop propagation from the button so that we only propagate\n              // one click event (from the input). We propagate changes from an input so that native\n              // form validation works and form events reflect radio updates.\n              if (!hasConsumerStoppedPropagationRef.current) event.stopPropagation();\n            }\n          })}\n        />\n        {isFormControl && (\n          <BubbleInput\n            control={button}\n            bubbles={!hasConsumerStoppedPropagationRef.current}\n            name={name}\n            value={value}\n            checked={checked}\n            required={required}\n            disabled={disabled}\n            form={form}\n            // We transform because the input is absolutely positioned but we have\n            // rendered it **after** the button. This pulls it back to sit on top\n            // of the button.\n            style={{ transform: 'translateX(-100%)' }}\n          />\n        )}\n      </RadioProvider>\n    );\n  }\n);\n\nRadio.displayName = RADIO_NAME;\n\n/* -------------------------------------------------------------------------------------------------\n * RadioIndicator\n * -----------------------------------------------------------------------------------------------*/\n\nconst INDICATOR_NAME = 'RadioIndicator';\n\ntype RadioIndicatorElement = React.ElementRef<typeof Primitive.span>;\ntype PrimitiveSpanProps = React.ComponentPropsWithoutRef<typeof Primitive.span>;\nexport interface RadioIndicatorProps extends PrimitiveSpanProps {\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 RadioIndicator = React.forwardRef<RadioIndicatorElement, RadioIndicatorProps>(\n  (props: ScopedProps<RadioIndicatorProps>, forwardedRef) => {\n    const { __scopeRadio, forceMount, ...indicatorProps } = props;\n    const context = useRadioContext(INDICATOR_NAME, __scopeRadio);\n    return (\n      <Presence present={forceMount || context.checked}>\n        <Primitive.span\n          data-state={getState(context.checked)}\n          data-disabled={context.disabled ? '' : undefined}\n          {...indicatorProps}\n          ref={forwardedRef}\n        />\n      </Presence>\n    );\n  }\n);\n\nRadioIndicator.displayName = INDICATOR_NAME;\n\n/* ---------------------------------------------------------------------------------------------- */\n\ntype InputProps = React.ComponentPropsWithoutRef<'input'>;\ninterface BubbleInputProps extends Omit<InputProps, 'checked'> {\n  checked: boolean;\n  control: HTMLElement | null;\n  bubbles: boolean;\n}\n\nconst BubbleInput = (props: BubbleInputProps) => {\n  const { control, checked, bubbles = true, ...inputProps } = props;\n  const ref = React.useRef<HTMLInputElement>(null);\n  const prevChecked = usePrevious(checked);\n  const controlSize = useSize(control);\n\n  // Bubble checked change to parents (e.g form change event)\n  React.useEffect(() => {\n    const input = ref.current!;\n    const inputProto = window.HTMLInputElement.prototype;\n    const descriptor = Object.getOwnPropertyDescriptor(inputProto, 'checked') as PropertyDescriptor;\n    const setChecked = descriptor.set;\n    if (prevChecked !== checked && setChecked) {\n      const event = new Event('click', { bubbles });\n      setChecked.call(input, checked);\n      input.dispatchEvent(event);\n    }\n  }, [prevChecked, checked, bubbles]);\n\n  return (\n    <input\n      type=\"radio\"\n      aria-hidden\n      defaultChecked={checked}\n      {...inputProps}\n      tabIndex={-1}\n      ref={ref}\n      style={{\n        ...props.style,\n        ...controlSize,\n        position: 'absolute',\n        pointerEvents: 'none',\n        opacity: 0,\n        margin: 0,\n      }}\n    />\n  );\n};\n\nfunction getState(checked: boolean) {\n  return checked ? 'checked' : 'unchecked';\n}\n\nexport {\n  createRadioScope,\n  //\n  Radio,\n  RadioIndicator,\n};\nexport type { RadioProps };\n","// packages/react/slot/src/slot.tsx\nimport * as React from \"react\";\nimport { composeRefs } from \"@radix-ui/react-compose-refs\";\nimport { Fragment as Fragment2, 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    const props2 = mergeProps(slotProps, children.props);\n    if (children.type !== React.Fragment) {\n      props2.ref = forwardedRef ? composeRefs(forwardedRef, childrenRef) : childrenRef;\n    }\n    return React.cloneElement(children, props2);\n  }\n  return React.Children.count(children) > 1 ? React.Children.only(null) : null;\n});\nSlotClone.displayName = \"SlotClone\";\nvar Slottable = ({ children }) => {\n  return /* @__PURE__ */ jsx(Fragment2, { 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","// 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","// 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/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","// packages/react/use-size/src/useSize.tsx\nimport * as React from \"react\";\nimport { useLayoutEffect } from \"@radix-ui/react-use-layout-effect\";\nfunction useSize(element) {\n  const [size, setSize] = React.useState(void 0);\n  useLayoutEffect(() => {\n    if (element) {\n      setSize({ width: element.offsetWidth, height: element.offsetHeight });\n      const resizeObserver = new ResizeObserver((entries) => {\n        if (!Array.isArray(entries)) {\n          return;\n        }\n        if (!entries.length) {\n          return;\n        }\n        const entry = entries[0];\n        let width;\n        let height;\n        if (\"borderBoxSize\" in entry) {\n          const borderSizeEntry = entry[\"borderBoxSize\"];\n          const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;\n          width = borderSize[\"inlineSize\"];\n          height = borderSize[\"blockSize\"];\n        } else {\n          width = element.offsetWidth;\n          height = element.offsetHeight;\n        }\n        setSize({ width, height });\n      });\n      resizeObserver.observe(element, { box: \"border-box\" });\n      return () => resizeObserver.unobserve(element);\n    } else {\n      setSize(void 0);\n    }\n  }, [element]);\n  return size;\n}\nexport {\n  useSize\n};\n//# sourceMappingURL=index.mjs.map\n"],"names":["NAN","reTrim","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","freeGlobal","__webpack_require__","g","Object","freeSelf","self","root","Function","objectToString","objectProto","prototype","toString","nativeMax","Math","max","nativeMin","min","now","Date","isObject","value","type","toNumber","isObjectLike","call","other","valueOf","replace","isBinary","test","slice","module","exports","func","wait","options","lastArgs","lastThis","maxWait","result","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","invokeFunc","time","args","thisArg","undefined","apply","shouldInvoke","timeSinceLastCall","timeSinceLastInvoke","timerExpired","trailingEdge","setTimeout","debounced","isInvoking","arguments","cancel","clearTimeout","flush","dynamic","dynamicOptions","mergedOptions","loadableOptions","loading","error","isLoading","pastDelay","param","loader","Loadable","modules","loadableGenerated","_bailouttocsr","require","BailoutToCSR","children","reason","window","BailoutToCSRError","_default","convertModule","mod","default","hasDefault","defaultOptions","Promise","resolve","ssr","opts","Lazy","lazy","then","Loading","LoadableComponent","props","fallbackElement","_jsxruntime","jsx","jsxs","Fragment","PreloadCss","moduleIds","Suspense","fallback","displayName","_requestasyncstorageexternal","allFiles","getExpectedRequestStore","requestStore","manifest","reactLoadableManifest","key","cssFiles","push","length","map","file","rel","href","as","assetPrefix","encodeURI","composeEventHandlers","originalEventHandler","ourEventHandler","checkForDefaultPrevented","event","defaultPrevented","setRef","ref","current","composeRefs","refs","hasCleanup","cleanups","cleanup","node","i","useComposedRefs","react__WEBPACK_IMPORTED_MODULE_0__","useCallback","createContext2","rootComponentName","defaultContext","Context","createContext","Provider","context","useMemo","values","react_jsx_runtime__WEBPACK_IMPORTED_MODULE_1__","consumerName","useContext","createContextScope","scopeName","createContextScopeDeps","defaultContexts","createScope","scopeContexts","scope","contexts","BaseContext","index","composeContextScopes","scopes","baseScope","scopeHooks","useScope","createScope2","overrideScopes","nextScopes","reduce","nextScopes2","currentScope","scopeProps","useReactId","react__WEBPACK_IMPORTED_MODULE_0___namespace_cache","t","count","useId","deterministicId","id","setId","useState","_radix_ui_react_use_layout_effect__WEBPACK_IMPORTED_MODULE_1__","b","reactId","String","Presence","getter","mayWarn","present","presence","usePresence","initialState","machine","setNode","React2","stylesRef","prevPresentRef","prevAnimationNameRef","state","send","mounted","UNMOUNT","ANIMATION_OUT","unmountSuspended","MOUNT","ANIMATION_END","unmounted","React","nextState","currentAnimationName","getAnimationName","useLayoutEffect","styles","wasPresent","prevAnimationName","display","timeoutId","ownerWindow","ownerDocument","defaultView","handleAnimationEnd","isCurrentAnimation","includes","animationName","target","currentFillMode","style","animationFillMode","handleAnimationStart","addEventListener","removeEventListener","isPresent","getComputedStyle","child","only","getOwnPropertyDescriptor","element","get","isReactWarning","forceMount","Primitive","NODES","primitive","Node","forwardRef","forwardedRef","asChild","primitiveProps","Comp","_radix_ui_react_slot__WEBPACK_IMPORTED_MODULE_3__","g7","Symbol","for","react_jsx_runtime__WEBPACK_IMPORTED_MODULE_2__","dispatchDiscreteCustomEvent","react_dom__WEBPACK_IMPORTED_MODULE_1__","flushSync","dispatchEvent","DirectionContext","react","useDirection","localDir","globalDir","ENTRY_FOCUS","EVENT_OPTIONS","bubbles","cancelable","GROUP_NAME","Collection","useCollection","createCollectionScope","createCollection","name","PROVIDER_NAME","createCollectionContext","CollectionProviderImpl","useCollectionContext","collectionRef","itemMap","Map","CollectionProvider","COLLECTION_SLOT_NAME","CollectionSlot","composedRefs","Slot","ITEM_SLOT_NAME","ITEM_DATA_ATTR","CollectionItemSlot","itemData","set","delete","ItemSlot","collectionNode","orderedNodes","Array","from","querySelectorAll","concat","items","sort","a","indexOf","createRovingFocusGroupContext","createRovingFocusGroupScope","RovingFocusProvider","useRovingFocusContext","RovingFocusGroup","__scopeRovingFocusGroup","RovingFocusGroupImpl","orientation","loop","dir","currentTabStopId","currentTabStopIdProp","defaultCurrentTabStopId","onCurrentTabStopIdChange","onEntryFocus","preventScrollOnEntryFocus","groupProps","direction","setCurrentTabStopId","useControllableState","prop","defaultProp","onChange","isTabbingBackOut","setIsTabbingBackOut","handleEntryFocus","useCallbackRef","getItems","isClickFocusRef","focusableItemsCount","setFocusableItemsCount","onItemFocus","tabStopId","onItemShiftTab","onFocusableItemAdd","prevCount","onFocusableItemRemove","div","tabIndex","outline","onMouseDown","onFocus","isKeyboardFocus","currentTarget","entryFocusEvent","CustomEvent","filter","item","focusable","focusFirst","candidateItems","find","active","Boolean","onBlur","ITEM_NAME","RovingFocusGroupItem","itemProps","autoId","isCurrentTabStop","span","preventDefault","onKeyDown","shiftKey","focusIntent","getFocusIntent","MAP_KEY_TO_FOCUS_INTENT","metaKey","ctrlKey","altKey","candidateNodes","reverse","array","startIndex","currentIndex","_","ArrowLeft","ArrowUp","ArrowRight","ArrowDown","PageUp","Home","PageDown","End","candidates","preventScroll","PREVIOUSLY_FOCUSED_ELEMENT","document","activeElement","candidate","focus","RADIO_NAME","createRadioContext","createRadioScope","RadioProvider","useRadioContext","Radio","__scopeRadio","checked","required","disabled","onCheck","form","radioProps","button","setButton","hasConsumerStoppedPropagationRef","isFormControl","closest","role","getState","onClick","isPropagationStopped","stopPropagation","BubbleInput","control","transform","INDICATOR_NAME","RadioIndicator","indicatorProps","inputProps","prevChecked","usePrevious","useRef","previous","controlSize","useSize","input","setChecked","descriptor","HTMLInputElement","Event","defaultChecked","position","pointerEvents","opacity","margin","ARROW_KEYS","RADIO_GROUP_NAME","createRadioGroupContext","createRadioGroupScope","useRovingFocusGroupScope","useRadioScope","RadioGroupProvider","useRadioGroupContext","RadioGroup","__scopeRadioGroup","defaultValue","valueProp","onValueChange","rovingFocusGroupScope","setValue","RadioGroupItem","isDisabled","radioScope","isArrowKeyPressedRef","handleKeyDown","handleKeyUp","click","RadioGroupIndicator","Root","Item","Indicator","slotProps","childrenArray","Children","toArray","slottable","isSlottable","newElement","newChildren","isValidElement","SlotClone","cloneElement","childrenRef","props2","mergeProps","childProps","overrideProps","propName","slotPropValue","childPropValue","join","_radix_ui_react_compose_refs__WEBPACK_IMPORTED_MODULE_2__","F","Slottable","callback","callbackRef","useEffect","uncontrolledProp","setUncontrolledProp","useUncontrolledState","uncontrolledState","prevValueRef","handleChange","_radix_ui_react_use_callback_ref__WEBPACK_IMPORTED_MODULE_1__","W","isControlled","value2","nextValue","setter","useLayoutEffect2","size","setSize","width","offsetWidth","height","offsetHeight","resizeObserver","ResizeObserver","isArray","entries","entry","borderSizeEntry","borderSize","observe","box","unobserve"],"sourceRoot":""}