@badnpm/ui 0.0.0-stage → 0.0.0

package/dist/umd/index.js

@@ -0,0 +1,3541 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.BadUI = {}, global.React));
+})(this, (function (exports, React) { 'use strict';
+
+  function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+      Object.keys(e).forEach(function (k) {
+        if (k !== 'default') {
+          var d = Object.getOwnPropertyDescriptor(e, k);
+          Object.defineProperty(n, k, d.get ? d : {
+            enumerable: true,
+            get: function () { return e[k]; }
+          });
+        }
+      });
+    }
+    n.default = e;
+    return Object.freeze(n);
+  }
+
+  var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+  var jsxRuntime = {exports: {}};
+
+  var reactJsxRuntime_production = {};
+
+  /**
+   * @license React
+   * react-jsx-runtime.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   */
+
+  var hasRequiredReactJsxRuntime_production;
+
+  function requireReactJsxRuntime_production () {
+  	if (hasRequiredReactJsxRuntime_production) return reactJsxRuntime_production;
+  	hasRequiredReactJsxRuntime_production = 1;
+  	var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+  	  REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+  	function jsxProd(type, config, maybeKey) {
+  	  var key = null;
+  	  void 0 !== maybeKey && (key = "" + maybeKey);
+  	  void 0 !== config.key && (key = "" + config.key);
+  	  if ("key" in config) {
+  	    maybeKey = {};
+  	    for (var propName in config)
+  	      "key" !== propName && (maybeKey[propName] = config[propName]);
+  	  } else maybeKey = config;
+  	  config = maybeKey.ref;
+  	  return {
+  	    $$typeof: REACT_ELEMENT_TYPE,
+  	    type: type,
+  	    key: key,
+  	    ref: void 0 !== config ? config : null,
+  	    props: maybeKey
+  	  };
+  	}
+  	reactJsxRuntime_production.Fragment = REACT_FRAGMENT_TYPE;
+  	reactJsxRuntime_production.jsx = jsxProd;
+  	reactJsxRuntime_production.jsxs = jsxProd;
+  	return reactJsxRuntime_production;
+  }
+
+  var hasRequiredJsxRuntime;
+
+  function requireJsxRuntime () {
+  	if (hasRequiredJsxRuntime) return jsxRuntime.exports;
+  	hasRequiredJsxRuntime = 1;
+
+  	{
+  	  jsxRuntime.exports = requireReactJsxRuntime_production();
+  	}
+  	return jsxRuntime.exports;
+  }
+
+  var jsxRuntimeExports = requireJsxRuntime();
+
+  function hasWindow() {
+    return typeof window !== 'undefined';
+  }
+  function getWindow(node) {
+    var _node$ownerDocument;
+    return (node == null || (_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;
+  }
+  function isHTMLElement(value) {
+    if (!hasWindow()) {
+      return false;
+    }
+    return value instanceof HTMLElement || value instanceof getWindow(value).HTMLElement;
+  }
+
+  /**
+   * A clone of the React namespace for reading APIs that may be missing in older
+   * supported React versions. Bundlers can rewrite direct `React.someNewApi`
+   * reads into named imports, which breaks React 17. Reading from this cloned
+   * object keeps those lookups optional.
+   *
+   * @see https://github.com/mui/material-ui/issues/41190#issuecomment-2040873379
+   */
+  const SafeReact = {
+    ...React__namespace
+  };
+
+  const UNINITIALIZED = {};
+
+  /**
+   * A React.useRef() that is initialized with a function. Note that it accepts an optional
+   * initialization argument, so the initialization function doesn't need to be an inline closure.
+   *
+   * @usage
+   *   const ref = useRefWithInit(sortColumns, columns)
+   */
+
+  function useRefWithInit(init, initArg) {
+    const ref = React__namespace.useRef(UNINITIALIZED);
+    if (ref.current === UNINITIALIZED) {
+      ref.current = init(initArg);
+    }
+    return ref;
+  }
+
+  const useInsertionEffect = SafeReact.useInsertionEffect;
+  const useSafeInsertionEffect =
+  // React 17 doesn't have useInsertionEffect.
+  useInsertionEffect &&
+  // Preact replaces useInsertionEffect with useLayoutEffect and fires too late.
+  useInsertionEffect !== SafeReact.useLayoutEffect ? useInsertionEffect : fn => fn();
+  /**
+   * Stabilizes the function passed so it's always the same between renders.
+   *
+   * The function becomes non-reactive to any values it captures.
+   * It can safely be passed as a dependency of `React.useMemo` and `React.useEffect` without re-triggering them if its captured values change.
+   *
+   * The function must only be called inside effects and event handlers, never during render (which throws an error).
+   *
+   * This hook is a more permissive version of React 19.2's `React.useEffectEvent` in that it can be passed through contexts and called in event handler props, not just effects.
+   */
+  function useStableCallback(callback) {
+    const stable = useRefWithInit(createStableCallback).current;
+    stable.next = callback;
+    useSafeInsertionEffect(stable.effect);
+    return stable.trampoline;
+  }
+  function createStableCallback() {
+    const stable = {
+      next: undefined,
+      callback: assertNotCalled,
+      trampoline: (...args) => stable.callback?.(...args),
+      effect: () => {
+        stable.callback = stable.next;
+      }
+    };
+    return stable;
+  }
+  function assertNotCalled() {
+  }
+
+  const noop = () => {};
+  const useIsoLayoutEffect = typeof document !== 'undefined' ? React__namespace.useLayoutEffect : noop;
+
+  function mergeObjects(a, b) {
+    if (a && !b) {
+      return a;
+    }
+    if (!a && b) {
+      return b;
+    }
+    if (a || b) {
+      return {
+        ...a,
+        ...b
+      };
+    }
+    return undefined;
+  }
+
+  const EMPTY_PROPS = {};
+
+  /* eslint-disable id-denylist */
+  /**
+   * Merges multiple sets of React props. It follows the Object.assign pattern where the rightmost object's fields overwrite
+   * the conflicting ones from others. This doesn't apply to event handlers, `className` and `style` props.
+   *
+   * Event handlers are merged and called in right-to-left order (rightmost handler executes first, leftmost last).
+   * For React synthetic events, the rightmost handler can prevent prior (left-positioned) handlers from executing
+   * by calling `event.preventBaseUIHandler()`. For non-synthetic events (custom events with primitive/object values),
+   * all handlers always execute without prevention capability.
+   *
+   * The `className` prop is merged by concatenating classes in right-to-left order (rightmost class appears first in the string).
+   * The `style` prop is merged with rightmost styles overwriting the prior ones.
+   *
+   * Props can either be provided as objects or as functions that take the previous props as an argument.
+   * The function will receive the merged props up to that point (going from left to right):
+   * so in the case of `(obj1, obj2, fn, obj3)`, `fn` will receive the merged props of `obj1` and `obj2`.
+   * The function is responsible for chaining event handlers if needed (that is, we don't run the merge logic).
+   *
+   * Event handlers returned by the functions are not automatically prevented when `preventBaseUIHandler` is called.
+   * They must check `event.baseUIHandlerPrevented` themselves and bail out if it's true.
+   *
+   * @important **`ref` is not merged.**
+   * @param a Props object to merge.
+   * @param b Props object to merge. The function will overwrite conflicting props from `a`.
+   * @param c Props object to merge. The function will overwrite conflicting props from previous parameters.
+   * @param d Props object to merge. The function will overwrite conflicting props from previous parameters.
+   * @param e Props object to merge. The function will overwrite conflicting props from previous parameters.
+   * @returns The merged props.
+   * @public
+   */
+
+  function mergeProps(a, b, c, d, e) {
+    if (!c && !d && true && !a) {
+      return createInitialMergedProps(b);
+    }
+
+    // We need to mutably own `merged`.
+    let merged = createInitialMergedProps(a);
+    if (b) {
+      merged = mergeInto(merged, b);
+    }
+    if (c) {
+      merged = mergeInto(merged, c);
+    }
+    if (d) {
+      merged = mergeInto(merged, d);
+    }
+    return merged;
+  }
+  /* eslint-enable id-denylist */
+
+  /**
+   * Merges an arbitrary number of React props using the same logic as {@link mergeProps}.
+   * This function accepts an array of props instead of individual arguments.
+   *
+   * This has slightly lower performance than {@link mergeProps} due to accepting an array
+   * instead of a fixed number of arguments. Prefer {@link mergeProps} when merging 5 or
+   * fewer prop sets for better performance.
+   *
+   * @param props Array of props to merge.
+   * @returns The merged props.
+   * @see mergeProps
+   * @public
+   */
+  function mergePropsN(props) {
+    if (props.length === 0) {
+      return EMPTY_PROPS;
+    }
+    if (props.length === 1) {
+      return createInitialMergedProps(props[0]);
+    }
+
+    // We need to mutably own `merged`.
+    let merged = createInitialMergedProps(props[0]);
+    for (let i = 1; i < props.length; i += 1) {
+      merged = mergeInto(merged, props[i]);
+    }
+    return merged;
+  }
+  function createInitialMergedProps(inputProps) {
+    if (isPropsGetter(inputProps)) {
+      // Getter-returned handlers intentionally keep their existing semantics.
+      return {
+        ...inputProps(EMPTY_PROPS)
+      };
+    }
+    return copyInitialProps(inputProps);
+  }
+  function mergeInto(merged, inputProps) {
+    if (isPropsGetter(inputProps)) {
+      return inputProps(merged);
+    }
+    return mutablyMergeInto(merged, inputProps);
+  }
+  function copyInitialProps(inputProps) {
+    const copiedProps = {
+      ...inputProps
+    };
+
+    // `copiedProps` is our fresh own-object copy, so iterating with `for...in` is safe here.
+    // eslint-disable-next-line guard-for-in
+    for (const propName in copiedProps) {
+      const propValue = copiedProps[propName];
+      if (isEventHandler(propName, propValue)) {
+        copiedProps[propName] = wrapEventHandler(propValue);
+      }
+    }
+    return copiedProps;
+  }
+
+  /**
+   * Merges two sets of props. In case of conflicts, the external props take precedence.
+   */
+  function mutablyMergeInto(mergedProps, externalProps) {
+    if (!externalProps) {
+      return mergedProps;
+    }
+
+    // eslint-disable-next-line guard-for-in
+    for (const propName in externalProps) {
+      const externalPropValue = externalProps[propName];
+      switch (propName) {
+        case 'style':
+          {
+            mergedProps[propName] = mergeObjects(mergedProps.style, externalPropValue);
+            break;
+          }
+        case 'className':
+          {
+            mergedProps[propName] = mergeClassNames(mergedProps.className, externalPropValue);
+            break;
+          }
+        default:
+          {
+            if (isEventHandler(propName, externalPropValue)) {
+              mergedProps[propName] = mergeEventHandlers(mergedProps[propName], externalPropValue);
+            } else {
+              mergedProps[propName] = externalPropValue;
+            }
+          }
+      }
+    }
+    return mergedProps;
+  }
+  function isEventHandler(key, value) {
+    // This approach is more efficient than using a regex.
+    const code0 = key.charCodeAt(0);
+    const code1 = key.charCodeAt(1);
+    const code2 = key.charCodeAt(2);
+    return code0 === 111 /* o */ && code1 === 110 /* n */ && code2 >= 65 /* A */ && code2 <= 90 /* Z */ && (typeof value === 'function' || typeof value === 'undefined');
+  }
+  function isPropsGetter(inputProps) {
+    return typeof inputProps === 'function';
+  }
+  function mergeEventHandlers(ourHandler, theirHandler) {
+    if (!theirHandler) {
+      return ourHandler;
+    }
+    if (!ourHandler) {
+      return wrapEventHandler(theirHandler);
+    }
+    return (...args) => {
+      const event = args[0];
+      if (isSyntheticEvent(event)) {
+        const baseUIEvent = event;
+        makeEventPreventable(baseUIEvent);
+        const result = theirHandler(...args);
+        if (!baseUIEvent.baseUIHandlerPrevented) {
+          ourHandler?.(...args);
+        }
+        return result;
+      }
+      const result = theirHandler(...args);
+      ourHandler?.(...args);
+      return result;
+    };
+  }
+  function wrapEventHandler(handler) {
+    if (!handler) {
+      return handler;
+    }
+    return (...args) => {
+      const event = args[0];
+      if (isSyntheticEvent(event)) {
+        makeEventPreventable(event);
+      }
+      return handler(...args);
+    };
+  }
+  function makeEventPreventable(event) {
+    event.preventBaseUIHandler = () => {
+      event.baseUIHandlerPrevented = true;
+    };
+    return event;
+  }
+  function mergeClassNames(ourClassName, theirClassName) {
+    if (theirClassName) {
+      if (ourClassName) {
+        // eslint-disable-next-line prefer-template
+        return theirClassName + ' ' + ourClassName;
+      }
+      return theirClassName;
+    }
+    return ourClassName;
+  }
+  function isSyntheticEvent(event) {
+    return event != null && typeof event === 'object' && 'nativeEvent' in event;
+  }
+
+  /**
+   * Creates a formatErrorMessage function with a custom URL and prefix.
+   * @param baseUrl - The base URL for the error page (e.g., 'https://base-ui.com/production-error')
+   * @param prefix - The prefix for the error message (e.g., 'Base UI')
+   * @returns A function that formats error messages with the given URL and prefix
+   */
+  function createFormatErrorMessage(baseUrl, prefix) {
+    return function formatErrorMessage(code, ...args) {
+      const url = new URL(baseUrl);
+      url.searchParams.set('code', code.toString());
+      args.forEach(arg => url.searchParams.append('args[]', arg));
+      return `${prefix} error #${code}; visit ${url} for the full message.`;
+    };
+  }
+
+  /**
+   * WARNING: Don't import this directly. It's imported by the code generated by
+   * `@mui/internal-babel-plugin-minify-errors`. Make sure to always use string literals in `Error`
+   * constructors to ensure the plugin works as expected. Supported patterns include:
+   *   throw new Error('My message');
+   *   throw new Error(`My message: ${foo}`);
+   *   throw new Error(`My message: ${foo}` + 'another string');
+   *   ...
+   */
+  const formatErrorMessage = createFormatErrorMessage('https://base-ui.com/production-error', 'Base UI');
+
+  const CompositeRootContext = /*#__PURE__*/React__namespace.createContext(undefined);
+  function useCompositeRootContext(optional = false) {
+    const context = React__namespace.useContext(CompositeRootContext);
+    if (context === undefined && !optional) {
+      throw new Error(formatErrorMessage(16));
+    }
+    return context;
+  }
+
+  function useFocusableWhenDisabled(parameters) {
+    const {
+      focusableWhenDisabled,
+      disabled,
+      composite = false,
+      tabIndex: tabIndexProp = 0,
+      isNativeButton
+    } = parameters;
+    const isFocusableComposite = composite && focusableWhenDisabled !== false;
+    const isNonFocusableComposite = composite && focusableWhenDisabled === false;
+
+    // we can't explicitly assign `undefined` to any of these props because it
+    // would otherwise prevent subsequently merged props from setting them
+    const props = React__namespace.useMemo(() => {
+      const additionalProps = {
+        // allow Tabbing away from focusableWhenDisabled elements
+        onKeyDown(event) {
+          if (disabled && focusableWhenDisabled && event.key !== 'Tab') {
+            event.preventDefault();
+          }
+        }
+      };
+      if (!composite) {
+        additionalProps.tabIndex = tabIndexProp;
+        if (!isNativeButton && disabled) {
+          additionalProps.tabIndex = focusableWhenDisabled ? tabIndexProp : -1;
+        }
+      }
+      if (isNativeButton && (focusableWhenDisabled || isFocusableComposite) || !isNativeButton && disabled) {
+        additionalProps['aria-disabled'] = disabled;
+      }
+      if (isNativeButton && (!focusableWhenDisabled || isNonFocusableComposite)) {
+        additionalProps.disabled = disabled;
+      }
+      return additionalProps;
+    }, [composite, disabled, focusableWhenDisabled, isFocusableComposite, isNonFocusableComposite, isNativeButton, tabIndexProp]);
+    return {
+      props
+    };
+  }
+
+  /**
+   * Dispatches a constructed click on the target so it carries the source event's
+   * modifier state, which `click()` always reports as unpressed. Like `click()`,
+   * the untrusted click still runs native activation behavior (form submission,
+   * link navigation).
+   * `detail` defaults to 0 and `pointerType` to `''` (the native convention for
+   * keyboard-generated clicks). When the click represents a mouse gesture, pass
+   * `detail: 1` and `pointerType: 'mouse'` so consumers don't classify it as a
+   * keyboard activation.
+   */
+  function dispatchClickWithModifiers(target, sourceEvent, {
+    detail = 0,
+    pointerType = ''
+  } = {}) {
+    target.dispatchEvent(new (getWindow(target).PointerEvent)('click', {
+      bubbles: true,
+      cancelable: true,
+      composed: true,
+      detail,
+      pointerType,
+      shiftKey: sourceEvent.shiftKey,
+      ctrlKey: sourceEvent.ctrlKey,
+      altKey: sourceEvent.altKey,
+      metaKey: sourceEvent.metaKey
+    }));
+  }
+
+  function useButton(parameters = {}) {
+    const {
+      disabled = false,
+      focusableWhenDisabled,
+      tabIndex = 0,
+      native: isNativeButton = true,
+      composite: compositeProp
+    } = parameters;
+    const elementRef = React__namespace.useRef(null);
+    const compositeRootContext = useCompositeRootContext(true);
+    const isCompositeItem = compositeProp ?? compositeRootContext !== undefined;
+    const {
+      props: focusableWhenDisabledProps
+    } = useFocusableWhenDisabled({
+      focusableWhenDisabled,
+      disabled,
+      composite: isCompositeItem,
+      tabIndex,
+      isNativeButton
+    });
+
+    // handles a disabled composite button rendering another button, e.g.
+    // <Toolbar.Button disabled render={<Menu.Trigger />} />
+    // the `disabled` prop needs to pass through 2 `useButton`s then finally
+    // delete the `disabled` attribute from DOM
+    const updateDisabled = React__namespace.useCallback(() => {
+      const element = elementRef.current;
+      if (!isButtonElement(element)) {
+        return;
+      }
+      if (isCompositeItem && disabled && focusableWhenDisabledProps.disabled === undefined && element.disabled) {
+        element.disabled = false;
+      }
+    }, [disabled, focusableWhenDisabledProps.disabled, isCompositeItem]);
+    useIsoLayoutEffect(updateDisabled, [updateDisabled]);
+    const getButtonProps = React__namespace.useCallback((externalProps = {}) => {
+      const {
+        onClick: externalOnClick,
+        onMouseDown: externalOnMouseDown,
+        onKeyUp: externalOnKeyUp,
+        onKeyDown: externalOnKeyDown,
+        onPointerDown: externalOnPointerDown,
+        ...otherExternalProps
+      } = externalProps;
+      return mergeProps({
+        onClick(event) {
+          if (disabled) {
+            event.preventDefault();
+            return;
+          }
+          externalOnClick?.(event);
+        },
+        onMouseDown(event) {
+          if (!disabled) {
+            externalOnMouseDown?.(event);
+          }
+        },
+        onKeyDown(event) {
+          if (disabled) {
+            return;
+          }
+          makeEventPreventable(event);
+          externalOnKeyDown?.(event);
+          if (event.baseUIHandlerPrevented) {
+            return;
+          }
+          const isCurrentTarget = event.target === event.currentTarget;
+          const currentTarget = event.currentTarget;
+          const isButton = isButtonElement(currentTarget);
+          const isLink = !isNativeButton && isValidLinkElement(currentTarget);
+          const shouldClick = isCurrentTarget && (isNativeButton ? isButton : !isLink);
+          const isEnterKey = event.key === 'Enter';
+          const isSpaceKey = event.key === ' ';
+          const role = currentTarget.getAttribute('role');
+          const isTextNavigationRole = role?.startsWith('menuitem') || role === 'option' || role === 'gridcell';
+          if (isCurrentTarget && isCompositeItem && isSpaceKey) {
+            if (event.defaultPrevented && isTextNavigationRole) {
+              return;
+            }
+            event.preventDefault();
+
+            // Only a native-mode item that isn't a real <button> is excluded.
+            if (!isNativeButton || isButton) {
+              event.preventBaseUIHandler();
+              dispatchClickWithModifiers(currentTarget, event);
+            }
+            return;
+          }
+
+          // Keyboard accessibility for native and non-native elements.
+          if (!shouldClick || isNativeButton || !isSpaceKey && !isEnterKey) {
+            // Space activates links on keyup (`role="button"` semantics, matching the
+            // composite path); prevent the page scroll Space would otherwise trigger.
+            // Enter is left to the browser's native link activation.
+            if (isCurrentTarget && isLink && isSpaceKey) {
+              event.preventDefault();
+            }
+            return;
+          }
+
+          // Match native buttons: preventing the keydown's default cancels activation.
+          if (event.defaultPrevented) {
+            return;
+          }
+          event.preventDefault();
+          if (isEnterKey) {
+            event.preventBaseUIHandler();
+            dispatchClickWithModifiers(currentTarget, event);
+          }
+        },
+        onKeyUp(event) {
+          if (disabled) {
+            return;
+          }
+
+          // calling preventDefault in keyUp on a <button> will not dispatch a click event if Space is pressed
+          // https://codesandbox.io/p/sandbox/button-keyup-preventdefault-dn7f0
+          makeEventPreventable(event);
+          externalOnKeyUp?.(event);
+          if (event.target === event.currentTarget && isNativeButton && isCompositeItem && isButtonElement(event.currentTarget) && event.key === ' ') {
+            event.preventDefault();
+            return;
+          }
+          if (event.baseUIHandlerPrevented) {
+            return;
+          }
+
+          // Keyboard accessibility for non interactive elements.
+          // Match native buttons: preventing the keyup's default cancels Space activation.
+          // Limitation: unlike a native <button>, a prevented *keydown* cannot cancel the
+          // activation — no state is kept between keydown and keyup, so we can't tell
+          // whether the keydown was prevented or even happened on this element.
+          if (event.target === event.currentTarget && !isNativeButton && !isCompositeItem && !event.defaultPrevented && event.key === ' ') {
+            event.preventBaseUIHandler();
+            dispatchClickWithModifiers(event.currentTarget, event);
+          }
+        },
+        onPointerDown(event) {
+          if (disabled) {
+            event.preventDefault();
+            return;
+          }
+          externalOnPointerDown?.(event);
+        }
+      }, isNativeButton ? {
+        type: 'button'
+      } : {
+        role: 'button'
+      }, focusableWhenDisabledProps, otherExternalProps);
+    }, [disabled, focusableWhenDisabledProps, isCompositeItem, isNativeButton]);
+    const buttonRef = useStableCallback(element => {
+      elementRef.current = element;
+      updateDisabled();
+    });
+    return {
+      getButtonProps,
+      buttonRef
+    };
+  }
+  function isButtonElement(elem) {
+    return isHTMLElement(elem) && elem.tagName === 'BUTTON';
+  }
+  function isValidLinkElement(elem) {
+    return isHTMLElement(elem) && elem.tagName === 'A' && Boolean(elem.href);
+  }
+
+  /**
+   * Merges refs into a single memoized callback ref or `null`.
+   * This makes sure multiple refs are updated together and have the same value.
+   *
+   * This function accepts up to four refs. If you need to merge more, or have an unspecified number of refs to merge,
+   * use `useMergedRefsN` instead.
+   */
+
+  function useMergedRefs(a, b, c, d) {
+    const forkRef = useRefWithInit(createForkRef).current;
+    if (didChange(forkRef, a, b, c, d)) {
+      update(forkRef, [a, b, c, d]);
+    }
+    return forkRef.callback;
+  }
+
+  /**
+   * Merges an array of refs into a single memoized callback ref or `null`.
+   *
+   * If you need to merge a fixed number (up to four) of refs, use `useMergedRefs` instead for better performance.
+   */
+  function useMergedRefsN(refs) {
+    const forkRef = useRefWithInit(createForkRef).current;
+    if (didChangeN(forkRef, refs)) {
+      update(forkRef, refs);
+    }
+    return forkRef.callback;
+  }
+  function createForkRef() {
+    return {
+      callback: null,
+      cleanup: null,
+      refs: []
+    };
+  }
+  function didChange(forkRef, a, b, c, d) {
+    // prettier-ignore
+    return forkRef.refs[0] !== a || forkRef.refs[1] !== b || forkRef.refs[2] !== c || forkRef.refs[3] !== d;
+  }
+  function didChangeN(forkRef, newRefs) {
+    return forkRef.refs.length !== newRefs.length || forkRef.refs.some((ref, index) => ref !== newRefs[index]);
+  }
+  function update(forkRef, refs) {
+    forkRef.refs = refs;
+    if (refs.every(ref => ref == null)) {
+      forkRef.callback = null;
+      return;
+    }
+    forkRef.callback = instance => {
+      if (forkRef.cleanup) {
+        forkRef.cleanup();
+        forkRef.cleanup = null;
+      }
+      if (instance != null) {
+        const cleanupCallbacks = Array(refs.length).fill(null);
+        for (let i = 0; i < refs.length; i += 1) {
+          const ref = refs[i];
+          if (ref == null) {
+            continue;
+          }
+          switch (typeof ref) {
+            case 'function':
+              {
+                const refCleanup = ref(instance);
+                if (typeof refCleanup === 'function') {
+                  cleanupCallbacks[i] = refCleanup;
+                }
+                break;
+              }
+            case 'object':
+              {
+                ref.current = instance;
+                break;
+              }
+          }
+        }
+        forkRef.cleanup = () => {
+          for (let i = 0; i < refs.length; i += 1) {
+            const ref = refs[i];
+            if (ref == null) {
+              continue;
+            }
+            switch (typeof ref) {
+              case 'function':
+                {
+                  const cleanupCallback = cleanupCallbacks[i];
+                  if (typeof cleanupCallback === 'function') {
+                    cleanupCallback();
+                  } else {
+                    // Legacy ref with no attach-time cleanup: detach by calling it with `null`.
+                    // It returns nothing; React 19 cleanups are handled in the branch above.
+                    void ref(null);
+                  }
+                  break;
+                }
+              case 'object':
+                {
+                  ref.current = null;
+                  break;
+                }
+            }
+          }
+        };
+      }
+    };
+  }
+
+  const majorVersion = parseInt(React__namespace.version, 10);
+  function isReactVersionAtLeast(reactVersionToCheck) {
+    return majorVersion >= reactVersionToCheck;
+  }
+
+  /**
+   * Extracts the `ref` from a React element, handling different React versions.
+   */
+  function getReactElementRef(element) {
+    if (! /*#__PURE__*/React__namespace.isValidElement(element)) {
+      return null;
+    }
+    const reactElement = element;
+    const propsWithRef = reactElement.props;
+    return (isReactVersionAtLeast(19) ? propsWithRef?.ref : reactElement.ref) ?? null;
+  }
+
+  function NOOP() {}
+
+  // Typed as mutable `never[]` so it is assignable to any `T[]` fallback (for example
+  // `defaultValue ?? EMPTY_ARRAY` in `useControlled` callers) without widening `T`.
+  // Frozen so a write through a widened alias throws instead of mutating the shared singleton.
+  const EMPTY_ARRAY = Object.freeze([]);
+  const EMPTY_OBJECT = Object.freeze({});
+
+  function getStateAttributesProps(state, customMapping) {
+    const props = {};
+
+    /* eslint-disable-next-line guard-for-in */
+    for (const key in state) {
+      const value = state[key];
+      if (customMapping?.hasOwnProperty(key)) {
+        const customProps = customMapping[key](value);
+        if (customProps != null) {
+          Object.assign(props, customProps);
+        }
+        continue;
+      }
+      if (value === true) {
+        props[`data-${key.toLowerCase()}`] = '';
+      } else if (value) {
+        props[`data-${key.toLowerCase()}`] = value.toString();
+      }
+    }
+    return props;
+  }
+
+  /**
+   * If the provided className is a string, it will be returned as is.
+   * Otherwise, the function will call the className function with the state as the first argument.
+   *
+   * @param className
+   * @param state
+   */
+  function resolveClassName(className, state) {
+    return typeof className === 'function' ? className(state) : className;
+  }
+
+  /**
+   * If the provided style is an object, it will be returned as is.
+   * Otherwise, the function will call the style function with the state as the first argument.
+   *
+   * @param style
+   * @param state
+   */
+  function resolveStyle(style, state) {
+    return typeof style === 'function' ? style(state) : style;
+  }
+
+  /**
+   * Renders a Base UI element.
+   *
+   * @param element The default HTML element to render. Can be overridden by the `render` prop.
+   * @param componentProps An object containing the `render` and `className` props to be used for element customization. Other props are ignored.
+   * @param params Additional parameters for rendering the element.
+   */
+  function useRenderElement(element, componentProps, params = {}) {
+    let renderProp = componentProps.render;
+    if (params.enabled !== false) {
+      // A pending lazy element suspends when unwrapped, so leave it wrapped while disabled.
+      renderProp = unwrapLazyRenderProp(renderProp);
+    }
+    const outProps = useRenderElementProps(componentProps, params, renderProp);
+    if (params.enabled === false) {
+      return null;
+    }
+    const state = params.state ?? EMPTY_OBJECT;
+    return evaluateRenderProp(element, renderProp, outProps, state);
+  }
+
+  /**
+   * Computes render element final props.
+   */
+  function useRenderElementProps(componentProps, params, renderProp) {
+    const {
+      className: classNameProp,
+      style: styleProp
+    } = componentProps;
+    const {
+      state = EMPTY_OBJECT,
+      ref,
+      props,
+      stateAttributesMapping,
+      enabled = true
+    } = params;
+    const className = enabled ? resolveClassName(classNameProp, state) : undefined;
+    const style = enabled ? resolveStyle(styleProp, state) : undefined;
+    const stateProps = enabled ? getStateAttributesProps(state, stateAttributesMapping) : EMPTY_OBJECT;
+    const resolvedProps = enabled && props ? resolveRenderFunctionProps(props) : undefined;
+
+    // Ensure outProps is always a new mutable object when enabled, never EMPTY_OBJECT.
+    // This prevents potential TypeError when setting ref, className, or style properties,
+    // since EMPTY_OBJECT is frozen and mutations would fail in strict mode.
+    const outProps = enabled ? mergeObjects(stateProps, resolvedProps) ?? {} : EMPTY_OBJECT;
+
+    // SAFETY: The `useMergedRefs` functions use a single hook to store the same value,
+    // switching between them at runtime is safe. If this assertion fails, React will
+    // throw at runtime anyway.
+    // This also skips the `useMergedRefs` call on the server, which is fine because
+    // refs are not used on the server side.
+    /* eslint-disable react-hooks/rules-of-hooks */
+    if (typeof document !== 'undefined') {
+      if (!enabled) {
+        // Called only to keep the hook order stable when disabled; the merged ref is unused.
+        void useMergedRefs(null, null);
+      } else if (Array.isArray(ref)) {
+        outProps.ref = useMergedRefsN([outProps.ref, getReactElementRef(renderProp), ...ref]);
+      } else {
+        outProps.ref = useMergedRefs(outProps.ref, getReactElementRef(renderProp), ref);
+      }
+    }
+    if (!enabled) {
+      return EMPTY_OBJECT;
+    }
+    if (className !== undefined) {
+      outProps.className = mergeClassNames(outProps.className, className);
+    }
+    if (style !== undefined) {
+      outProps.style = mergeObjects(outProps.style, style);
+    }
+    return outProps;
+  }
+  function resolveRenderFunctionProps(props) {
+    if (Array.isArray(props)) {
+      return mergePropsN(props);
+    }
+    return mergeProps(undefined, props);
+  }
+
+  // The symbol React uses internally for lazy components
+  // https://github.com/react/react/blob/a0566250b210499b4c5677f5ac2eedbd71d51a1b/packages/shared/ReactSymbols.js#L31
+  //
+  // TODO delete once https://github.com/react/react/issues/32392 is fixed
+  const REACT_LAZY_TYPE = Symbol.for('react.lazy');
+
+  // Workaround for https://github.com/react/react/issues/32392
+  // The Flight client hands over a lazy wrapper in place of a render element created in a
+  // Server Component. The wrapper exposes no `.props` or `.ref`, so it must be unwrapped
+  // before those are read. This works because the toArray() logic unwraps the lazy
+  // element type in
+  // https://github.com/react/react/blob/a0566250b210499b4c5677f5ac2eedbd71d51a1b/packages/react/src/ReactChildren.js#L186
+  function unwrapLazyRenderProp(render) {
+    // `$$typeof` is a React internal, absent from the public element types.
+    if (render?.$$typeof !== REACT_LAZY_TYPE) {
+      return render;
+    }
+    // Keep the wrapper unless it unwraps to an element, so an invalid render prop is still
+    // reported as one instead of silently falling back to the default element.
+    const unwrapped = React__namespace.Children.toArray(render)[0];
+    return /*#__PURE__*/React__namespace.isValidElement(unwrapped) ? unwrapped : render;
+  }
+  function evaluateRenderProp(element, render, props, state) {
+    if (render) {
+      if (typeof render === 'function') {
+        return render(props, state);
+      }
+      const mergedProps = mergeProps(props, render.props);
+      mergedProps.ref = props.ref;
+      return /*#__PURE__*/React__namespace.cloneElement(render, mergedProps);
+    }
+    // `element` is always provided when there is no `render` prop.
+    return renderTag(element, props);
+  }
+  function renderTag(Tag, props) {
+    if (Tag === 'button') {
+      return /*#__PURE__*/React.createElement("button", {
+        type: "button",
+        ...props,
+        key: props.key
+      });
+    }
+    if (Tag === 'img') {
+      return /*#__PURE__*/React.createElement("img", {
+        alt: "",
+        ...props,
+        key: props.key
+      });
+    }
+    return /*#__PURE__*/React__namespace.createElement(Tag, props);
+  }
+
+  /**
+   * A button component that can be used to trigger actions.
+   * Renders a `<button>` element.
+   *
+   * Documentation: [Base UI Button](https://base-ui.com/react/components/button)
+   */
+  const Button$1 = /*#__PURE__*/React__namespace.forwardRef(function Button(componentProps, forwardedRef) {
+    const {
+      render,
+      className,
+      disabled = false,
+      focusableWhenDisabled = false,
+      nativeButton = true,
+      style,
+      ...elementProps
+    } = componentProps;
+    const {
+      getButtonProps,
+      buttonRef
+    } = useButton({
+      disabled,
+      focusableWhenDisabled,
+      native: nativeButton
+    });
+    const state = {
+      disabled
+    };
+    return useRenderElement('button', componentProps, {
+      state,
+      ref: [forwardedRef, buttonRef],
+      props: [elementProps, getButtonProps]
+    });
+  });
+
+  function r(e){var t,f,n="";if("string"==typeof e||"number"==typeof e)n+=e;else if("object"==typeof e)if(Array.isArray(e)){var o=e.length;for(t=0;t<o;t++)e[t]&&(f=r(e[t]))&&(n&&(n+=" "),n+=f);}else for(f in e)e[f]&&(n&&(n+=" "),n+=f);return n}function clsx(){for(var e,t,f=0,n="",o=arguments.length;f<o;f++)(e=arguments[f])&&(t=r(e))&&(n&&(n+=" "),n+=t);return n}
+
+  const falsyToString = (value)=>typeof value === "boolean" ? `${value}` : value === 0 ? "0" : value;
+  const cx = clsx;
+  const cva = (base, config)=>(props)=>{
+          var _config_compoundVariants;
+          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);
+          const { variants, defaultVariants } = config;
+          const getVariantClassNames = Object.keys(variants).map((variant)=>{
+              const variantProp = props === null || props === void 0 ? void 0 : props[variant];
+              const defaultVariantProp = defaultVariants === null || defaultVariants === void 0 ? void 0 : defaultVariants[variant];
+              if (variantProp === null) return null;
+              const variantKey = falsyToString(variantProp) || falsyToString(defaultVariantProp);
+              return variants[variant][variantKey];
+          });
+          const propsWithoutUndefined = props && Object.entries(props).reduce((acc, param)=>{
+              let [key, value] = param;
+              if (value === undefined) {
+                  return acc;
+              }
+              acc[key] = value;
+              return acc;
+          }, {});
+          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)=>{
+              let { class: cvClass, className: cvClassName, ...compoundVariantOptions } = param;
+              return Object.entries(compoundVariantOptions).every((param)=>{
+                  let [key, value] = param;
+                  return Array.isArray(value) ? value.includes({
+                      ...defaultVariants,
+                      ...propsWithoutUndefined
+                  }[key]) : ({
+                      ...defaultVariants,
+                      ...propsWithoutUndefined
+                  })[key] === value;
+              }) ? [
+                  ...acc,
+                  cvClass,
+                  cvClassName
+              ] : acc;
+          }, []);
+          return cx(base, getVariantClassNames, getCompoundVariantClassNames, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
+      };
+
+  //#region src/tables.generated.ts
+  const P = 48;
+  const U = (s, o = 0) => {
+  	const out = new Int32Array(s.length);
+  	for (let i = 0; i < s.length; i++) out[i] = s.charCodeAt(i) - P - o;
+  	return out;
+  };
+  const PS = (counts) => {
+  	const out = new Int32Array(counts.length + 1);
+  	for (let i = 0; i < counts.length; i++) out[i + 1] = out[i] + counts[i];
+  	return out;
+  };
+  const DZ = (s) => {
+  	const out = new Int32Array(s.length);
+  	let a = 0;
+  	for (let i = 0; i < s.length; i++) {
+  		const z = s.charCodeAt(i) - P;
+  		a += z >>> 1 ^ -(z & 1);
+  		out[i] = a;
+  	}
+  	return out;
+  };
+  const GROUP_COUNT = 384;
+  const customValidatorNames = [];
+  const edgeStart = PS(U("E0500002005282000000002000150000020021820000011200000003022202000300004200120000200420001200021200301200010400162000010000220021010:2192001200220012000220012000200200200400010200040000000000400200108200110100000022010313000162002000020020012020080213000228200000000082000000000120002000120020020040101020300130001001010"));
+  const labelStart = PS(U(":11111111211111119311546544411119731869:671397415686432441111111111161114151214313433415:78311132233313187211117221449443411141111151152226611131111112212518142224214215421421542142424242516171151615616347111111111197911327451111111111111111111113134714133513411111311111111111111111111112444411111342312715245411117:3"));
+  const labelText = "@containerabcdefghinlmoprstunderlineviawzccentlignnimatespectuto-colsrowsaglorightnessckdrop-sisbcontrastfiltergrayscalehue-rotateinvertopacityslurrightnessaturateepia-coniclinearpositionradialsizeockurrderttom-belrstxyespacing-xyaretoursorlnt-umnsendspantartainentrasteividerop-shadowurationcorationlay-xyasendillexontromlter-featuresstretchapr-xyayscaleidow-colsrowsue-rotatedentlinesetvert-beringsxyeshadoweiadingftnest-clamp-imageabein-lrstxyskx--b-coniclpositionrsizet-x-y-fromto-fromto-inearfromto-fromto-adialfromto-fromtofromtofromtofromtoblockhinlinew-screenesblockhinlinewbjectpacityrutlinederigin-offsetbelrstxyesrspective-originaceholderioghtng-offsettateundedw-xyz-belrstlreseslr-endspantartaturatecepiahizekewpace-taleroll-xyz-barmpbelrstxyesbelrstxyes-thumbrackadowrink-xyxyartrokeabextora-shadowpckingnsformitionlate-xyz-offsetill-changeoom";
+  const edgeTarget = (() => {
+  	const N = edgeStart.length - 1;
+  	const sizes = new Int32Array(N);
+  	for (let i = N - 1; i >= 0; i--) {
+  		let s = 1;
+  		let c = i + 1;
+  		for (let k = edgeStart[i]; k < edgeStart[i + 1]; k++) {
+  			s += sizes[c];
+  			c += sizes[c];
+  		}
+  		sizes[i] = s;
+  	}
+  	const out = new Int32Array(edgeStart[N]);
+  	let e = 0;
+  	for (let i = 0; i < N; i++) {
+  		let c = i + 1;
+  		for (let k = edgeStart[i]; k < edgeStart[i + 1]; k++) {
+  			out[e++] = c;
+  			c += sizes[c];
+  		}
+  	}
+  	return out;
+  })();
+  const nodeGroup = U("02000000000000900<=0?000B000F00F00ŏI0J0LNPRTVX0000]_a00000000000000000000000rst0000000zŏ00000000000…ŏ000ˆ0000ŏ0000000000—0000000000000000000000000000000000000000000000000000Ë000000000000000000000Þ000000000000000000ð0000000ø0ùúûüýþÿĀāĂ㥹Ć000000000000000000000000000000000000000000ħ0ĨĪ00000000000000000000ļĽ00000Ŭ000000", 1);
+  const vlistPat = PS(U("123333359346463635126536711576"));
+  const vlistOps = U("93203242332583253248325D>E?F@03263243255B:032523853:0325B:8GA032542H<C=12727B:0328432553;D>E?3257D>032585:0325B:;0328B:032");
+  const vlistRef = U("012113445661666666789111:5;;;;;;;;444;;;:62999<1161=62>>?61:21@ABCD4446996:64E:::;:?::64:F114GHHIHHHHIHH1HH1HH1HHHHHH::EEJ4444::EE4444441691;644444114244444:;K6666555555555555555999666664444444444444444444444226?6:66644L9M?D:111::::6DE199");
+  const vlistGroup = DZ("020200202020020020020020020020200200200200200200200002020202001003040106000200200200200200200200200200200200200200200200200200200200200200200200200200200200020020020020020020002020200202002002002002002002002002002020002002020020200220200200200200200200200200200200020020020000200020002000200200200020020020002000200200200020020202002020202000200200020022000200200020020002002000200220002002000200W0Z00020020002002020002002000200g0j0002002000200200020020002002000200200020020002000200002000002002002002002000200020000200002002002002002002002020020020200200200200200200200200202020020020020020020020020002002002020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020020002002002002002002000200200200200200200200200200020202020002000200020002002002002000020200200");
+  const nodeVlist = (() => {
+  	const out = (/* @__PURE__ */ new Int32Array(319)).fill(-1);
+  	const A = DZ("02422242:222222242224222242442222222422222244442242226224222426222422442462222422622222222626222462242622422622422424242422222222422222222242422222222222222222622442224222222222222224424442262222222222222222222226224222424242422224422422422222");
+  	const V = DZ("02222222222222222222202222222222222222222222221422222222222222222222222222222222222Y\\222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222221422222222222222222222222222222222222222Ŀł222222222222222222");
+  	for (let i = 0; i < A.length; i++) out[A[i]] = V[i];
+  	return out;
+  })();
+  const SETS = "container |break-after- all auto avoid avoid-page column left page right|break-before- all auto avoid avoid-page column left page right|break-inside-a uto void void-column void-page|box-decoration- clone slice|box- border content| contents flow-root hidden table table-caption table-cell table-column table-column-group table-footer-group table-header-group table-row table-row-group| not-sr-only sr-only|float- end left none right start|clear- both end left none right start|isolat e ion-auto|overflow- auto clip hidden scroll visible|overflow-x- auto clip hidden scroll visible|overflow-y- auto clip hidden scroll visible|overscroll- auto contain none|overscroll-x- auto contain none|overscroll-y- auto contain none| absolute fixed relative static sticky| collapse invisible visible|justify- around baseline between center center-safe end end-safe evenly normal start stretch|justify-items- center center-safe end end-safe normal start stretch|justify-self- auto center center-safe end end-safe start stretch|items- baseline baseline-last center center-safe end end-safe start stretch|self- auto baseline baseline-last center center-safe end end-safe start stretch|place-content- around baseline between center center-safe end end-safe evenly start stretch|place-items- baseline center center-safe end end-safe start stretch|place-self- auto center center-safe end end-safe start stretch| antialiased subpixel-antialiased| italic not-italic|normal-nums |ordinal |slashed-zero | lining-nums oldstyle-nums| proportional-nums tabular-nums| diagonal-fractions stacked-fractions| no-underline overline| capitalize lowercase normal-case uppercase|truncate |whitespace- break-spaces normal nowrap pre pre-line pre-wrap|break- all keep normal words|wrap- anywhere break-word normal|hyphens- auto manual none|mix-blend- color color-burn color-dodge darken difference exclusion hard-light hue lighten luminosity multiply normal overlay plus-darker plus-lighter saturation screen soft-light|table- auto fixed|caption- bottom top|backface- hidden visible|appearance- auto none|scheme- dark light light-dark normal only-dark only-light|field-sizing- content fixed|pointer-events- auto none|resize  -none -x -y|snap- align-none center end start|snap- always normal|snap- both none x y|snap- mandatory proximity|touch- auto manipulation none|touch-pan- left right x|touch-pan- down up y|touch-pinch-zoom |select- all auto none text|forced-color-adjust- auto none| normal size| baseline bottom middle sub super text-bottom text-top top| bounce none ping pulse spin| auto square video| auto fr max min px|none | auto full px| fixed local scroll|clip- border content padding text|origin- border content padding| bottom bottom-left bottom-right center left left-bottom left-top right right-bottom right-top top top-left top-right| no-repeat repeat repeat-round repeat-space repeat-x repeat-y| auto contain cover|blend- color color-burn color-dodge darken difference exclusion hard-light hue lighten luminosity multiply normal overlay saturation screen soft-light|to- b bl br l r t tl tr| auto dvh fit full lh lvh max min px screen svh| dashed dotted double hidden none solid| collapse separate|px |auto |full | content none strict| inline-size size|layout |paint |style | around baseline between center center-safe end end-safe evenly normal start stretch| alias all-scroll auto cell col-resize context-menu copy crosshair default e-resize ew-resize grab grabbing help move n-resize ne-resize nesw-resize no-drop none not-allowed ns-resize nw-resize nwse-resize pointer progress row-resize s-resize se-resize sw-resize text vertical-text w-resize wait zoom-in zoom-out| dashed dotted double solid wavy| auto from-font|reverse |initial | in in-out initial linear out| col col-reverse row row-reverse| nowrap wrap wrap-reverse| auto initial none| black bold extrabold extralight light medium normal semibold thin| condensed expanded extra-condensed extra-expanded normal semi-condensed semi-expanded ultra-condensed ultra-expanded|flow- col col-dense dense row row-dense| none subgrid| auto dvh dvw fit full lh lvh lvw max min px screen svh svw| block flex grid table| auto dvw fit full lvw max min px screen svw| loose none normal px relaxed snug tight|through |item | inside outside| decimal disc none| auto px| clip-border clip-content clip-fill clip-padding clip-stroke clip-view no-clip| add exclude intersect subtract| alpha luminance match|origin- border content fill padding stroke view|type- alpha luminance| circle ellipse| closest-corner closest-side farthest-corner farthest-side|at- bottom bottom-left bottom-right center left left-bottom left-top right right-bottom right-top top top-left top-right| dvh fit full lh lvh max min none px screen svh| auto dvh dvw fit full lh lvh lvw max min none px screen svh svw| dvw fit full lvw max min none px screen svw| auto dvh dvw fit full lvh lvw max min none prose px svh svw| auto dvh dvw fit full lvh lvw max min none px screen svh svw| contain cover fill none scale-down| first last none| distant dramatic midrange near none normal|inset | full none|3d | auto smooth|gutter- auto both stable| auto none thin| inner none| auto dvh dvw fit full lvh lvw max min px svh svw|base | center end justify left right start| clip ellipsis| balance nowrap pretty wrap| normal tight tighter wide wider widest| cpu gpu none| 3d flat| all colors none opacity shadow transform| discrete normal| full px| auto dvh dvw fit full lvh lvw max min px screen svh svw| auto contents scroll transform".split("|").map((s) => {
+  	const tails = s.split(" ");
+  	const prefix = tails.shift();
+  	for (let i = 0; i < tails.length; i++) tails[i] = prefix + tails[i];
+  	return tails;
+  });
+  const AA = DZ("0000000000000000000000000000000000000000000000000000000000000262242:6@200000006:240B428:4422400002046044222426220026642642462026224222824220022400000000\\00N222422242222222224062242222222422226264222422222222222222442804222422222222222222222222220<4<0204260002444020204224422");
+  const AG = DZ("ɠ222222222222222222222222222222222222222222222222222222222222˕4222226>6ʰ22ʷʺʷʺʷ42ʴ2ʓ22>621422ɶ222ɹɼɷɺɷɺ22ɱ42222ɨ2ɧ26622ɘɓ244ƸƵ222]d24242ǖǓƚÄȫ2263ȨȥȨ2222222ǣ222222222222222222ǂƽ2ƾƵ2222222422222ƜƑ22222222222222222222144Ŧţ22Ţş222222222222222222222ĸ2ı68ĦģĦɡŰ4Ġ«®ĝ822ĔđĔ2ē2222622");
+  const AS = DZ("02222222222222222222222222222222222222222222222222222222222222222202021422222222CF2200GJ021042222WZ222IL0ad2c10h2222U00X202[^2w0000120zy|}€22ƒ†…:22z22222222222G000q†OVI00000{˜2™<40000Œ›@00000G¦§000ª00000000000000021K¬«00®“000000000000000000000–222›HGH_1¸222½2¾2222ÇÊ000­°2±");
+  const litAnchor = /* @__PURE__ */ new Int32Array(987);
+  const litGroup = /* @__PURE__ */ new Int32Array(987);
+  const litPool = /* @__PURE__ */ new Int32Array(987);
+  let poolText = "";
+  const poolOffsets = /* @__PURE__ */ new Int32Array(1022);
+  {
+  	const tailRef = /* @__PURE__ */ new Map();
+  	let nextRef = 0;
+  	let e = 0;
+  	for (let i = 0; i < AA.length; i++) for (const tail of SETS[AS[i]]) {
+  		let r = tailRef.get(tail);
+  		if (r === void 0) {
+  			r = nextRef++;
+  			tailRef.set(tail, r);
+  			poolOffsets[r * 2] = poolText.length;
+  			poolOffsets[r * 2 + 1] = tail.length;
+  			poolText += tail;
+  		}
+  		litAnchor[e] = AA[i];
+  		litGroup[e] = AG[i];
+  		litPool[e] = r;
+  		e++;
+  	}
+  }
+  const adjGid = DZ("0b2N:222@R>F@286¦2@H2D266226FB22B2>BD\\6N22222Z222D222p");
+  const adjStart = PS(U("1::24444432:442:44:44>222222:44:4421322511111311111114"));
+  const adjTgt = DZ("2Š4A;33N=C@H4A;33N=C@<27;83:;8393NQ:3NQʰ222ˉºŴŽ2R2=18cƴÅҜ=cĞÛC1ƈǝȈ:ħ25=11D3A@4=<1;1DEr25;11B3?<6;:371BCn9@7=<8192>2E121@9@EHE@9>2T25511<398454131<=V25511<398454131<=„ƧNž2Đå242L222290000f22500ɛ000ǘ222");
+  const patGid = U("ij");
+  const patTgt = U("—");
+  const postfixLookupGroups = U("1");
+  const orderSensitiveModifiers = "* ** after backdrop before details-content file first-letter first-line marker placeholder selection";
+  var tables_generated_default = {
+  	GROUP_COUNT,
+  	customValidatorNames,
+  	edgeStart,
+  	labelStart,
+  	labelText,
+  	edgeTarget,
+  	nodeGroup,
+  	nodeVlist,
+  	vlistPat,
+  	vlistOps,
+  	vlistRef,
+  	vlistGroup,
+  	litAnchor,
+  	litGroup,
+  	litPool,
+  	poolOffsets,
+  	poolText,
+  	adjGid,
+  	adjStart,
+  	adjTgt,
+  	patGid,
+  	patTgt,
+  	postfixLookupGroups,
+  	orderSensitiveModifiers
+  };
+
+  //#region src/engine.ts
+  const IS_JSC = "line" in /* @__PURE__ */ new Error();
+  const EXTERNAL = -1;
+  const DEAD = -1;
+  const fnv = (str, s, e) => {
+  	let h = 2166136261;
+  	for (let p = s; p < e; p++) h = Math.imul(h ^ str.charCodeAt(p), 16777619);
+  	return h;
+  };
+  const spanHash = (str, s, e) => {
+  	const len = e - s;
+  	let h = Math.imul(len, 2654435761) ^ str.charCodeAt(s);
+  	if (len > 3) {
+  		const q = len >> 2;
+  		const m = len >> 1;
+  		h = Math.imul(h ^ str.charCodeAt(s + 1) << 8 ^ str.charCodeAt(s + 2) << 16 ^ str.charCodeAt(s + q), 2246822507);
+  		h = Math.imul(h ^ str.charCodeAt(s + m) << 8 ^ str.charCodeAt(s + m + q) << 16 ^ str.charCodeAt(e - 3), 3266489909);
+  		h ^= str.charCodeAt(e - 2) << 8 ^ str.charCodeAt(e - 1) << 16;
+  		for (let p = s + 3, q = e - 4; p < s + 8 && p < q; p++, q--) h = Math.imul(h ^ str.charCodeAt(p) ^ str.charCodeAt(q) << 8, 16777619);
+  	}
+  	return h ^ h >>> 15 | 0;
+  };
+  const createEngine = (T, validatorImpls, options = {}) => {
+  	const { GROUP_COUNT, edgeStart, labelStart, labelText, edgeTarget, nodeGroup, nodeVlist, vlistPat, vlistOps, vlistRef, vlistGroup, litAnchor, litGroup, litPool, poolOffsets, poolText, adjGid, adjStart, adjTgt, patGid, patTgt, postfixLookupGroups, customValidatorNames, orderSensitiveModifiers } = T;
+  	const adjRow = new Int32Array(GROUP_COUNT).fill(-1);
+  	for (let i = 0; i < adjGid.length; i++) adjRow[adjGid[i]] = i;
+  	let maxAdj = 0;
+  	for (let r = 0; r + 1 < adjStart.length; r++) {
+  		const n = adjStart[r + 1] - adjStart[r];
+  		if (n > maxAdj) maxAdj = n;
+  	}
+  	let CLAIM_PER_TOKEN = 32;
+  	while (CLAIM_PER_TOKEN < 2 * (1 + maxAdj + patGid.length)) CLAIM_PER_TOKEN <<= 1;
+  	const vgStart = new Int32Array(vlistRef.length + 1);
+  	for (let l = 0; l < vlistRef.length; l++) vgStart[l + 1] = vgStart[l] + vlistPat[vlistRef[l] + 1] - vlistPat[vlistRef[l]];
+  	const postfixLookupSet = new Uint8Array(GROUP_COUNT);
+  	for (let i = 0; i < postfixLookupGroups.length; i++) postfixLookupSet[postfixLookupGroups[i]] = 1;
+  	const nodeCount = edgeStart.length - 1;
+  	const nodeHasLit = new Uint8Array(nodeCount);
+  	let litMaxLen = 0;
+  	let litNoArb = true;
+  	for (let i = 0; i < litAnchor.length; i++) {
+  		nodeHasLit[litAnchor[i]] = 1;
+  		const len = poolOffsets[litPool[i] * 2 + 1];
+  		if (len > litMaxLen) litMaxLen = len;
+  		const c0 = poolText.charCodeAt(poolOffsets[litPool[i] * 2]);
+  		if (c0 === 91 || c0 === 40) litNoArb = false;
+  	}
+  	let LIT_SIZE = 1;
+  	while (LIT_SIZE < litAnchor.length * 2) LIT_SIZE <<= 1;
+  	const litTable = new Int32Array(LIT_SIZE).fill(-1);
+  	for (let i = 0; i < litAnchor.length; i++) {
+  		const off = poolOffsets[litPool[i] * 2];
+  		let idx = (fnv(poolText, off, off + poolOffsets[litPool[i] * 2 + 1]) ^ Math.imul(litAnchor[i], 2654435761) | 0) & LIT_SIZE - 1;
+  		while (litTable[idx] !== -1) idx = idx + 1 & LIT_SIZE - 1;
+  		litTable[idx] = i;
+  	}
+  	const litProbe = (anchor, input, s, e) => {
+  		let idx = (fnv(input, s, e) ^ Math.imul(anchor, 2654435761) | 0) & LIT_SIZE - 1;
+  		const len = e - s;
+  		for (;;) {
+  			const entry = litTable[idx];
+  			if (entry === -1) return -1;
+  			if (litAnchor[entry] === anchor && poolOffsets[litPool[entry] * 2 + 1] === len) {
+  				const off = poolOffsets[litPool[entry] * 2];
+  				let ok = true;
+  				for (let k = 0; k < len; k++) if (poolText.charCodeAt(off + k) !== input.charCodeAt(s + k)) {
+  					ok = false;
+  					break;
+  				}
+  				if (ok) return litGroup[entry];
+  			}
+  			idx = idx + 1 & LIT_SIZE - 1;
+  		}
+  	};
+  	const cacheSize = options.cacheSize ?? 8192;
+  	const RAW_PREFIX = options.prefix ?? T.prefix ?? "";
+  	const FULL_PREFIX = RAW_PREFIX === "" ? "" : RAW_PREFIX + ":";
+  	const FPL = FULL_PREFIX.length;
+  	const vCustom = (customValidatorNames ?? []).map((name) => {
+  		throw new Error("cn: missing validator " + name);
+  	});
+  	const lengthUnitRegex = /\d+(%|px|r?em|[sdl]?v([hwib]|min|max)|pt|pc|in|cm|mm|cap|ch|ex|r?lh|cq(w|h|i|b|min|max))|\b(calc|min|max|clamp)\(.+\)|^0$/;
+  	const colorFunctionRegex = /^(rgba?|hsla?|hwb|(ok)?(lab|lch)|color-mix)\(.+\)$/;
+  	const shadowRegex = /^(inset_)?-?((\d+)?\.?(\d+)[a-z]+|0)_-?((\d+)?\.?(\d+)[a-z]+|0)/;
+  	const imageRegex = /^(url|image|image-set|cross-fade|element|(repeating-)?(linear|radial|conic)-gradient)\(.+\)$/;
+  	let aKind = 0;
+  	let aLabelS = -1;
+  	let aLabelE = -1;
+  	let aValS = -1;
+  	let aValE = -1;
+  	const isWordCode = (c) => c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 95;
+  	const isUniWS = (c) => /\s/.test(String.fromCharCode(c));
+  	const analyzeArb = (input, s, e) => {
+  		aKind = 0;
+  		aLabelS = -1;
+  		if (e - s < 3) return;
+  		const c0 = input.charCodeAt(s);
+  		const cl = input.charCodeAt(e - 1);
+  		if (c0 === 91 && cl === 93) aKind = 1;
+  		else if (c0 === 40 && cl === 41) aKind = 2;
+  		else return;
+  		aValS = s + 1;
+  		aValE = e - 1;
+  		let p = s + 1;
+  		if (isWordCode(input.charCodeAt(p))) {
+  			p++;
+  			while (p < e - 1) {
+  				const c = input.charCodeAt(p);
+  				if (!isWordCode(c) && c !== 45) break;
+  				p++;
+  			}
+  			if (p < e - 2 && input.charCodeAt(p) === 58) {
+  				aLabelS = s + 1;
+  				aLabelE = p;
+  				aValS = p + 1;
+  			}
+  		}
+  	};
+  	const spanEq = (input, s, e, str) => {
+  		if (e - s !== str.length) return false;
+  		for (let i = 0; i < str.length; i++) if (input.charCodeAt(s + i) !== str.charCodeAt(i)) return false;
+  		return true;
+  	};
+  	const fractionRegex = /^\d+(?:\.\d+)?\/\d+(?:\.\d+)?$/;
+  	const tshirtRegex = /^(\d+(\.\d+)?)?(xs|sm|md|lg|xl)$/;
+  	const isNumStr = (v) => !!v && !Number.isNaN(Number(v));
+  	const spanIsNamedContainerQuery = (input, s, e) => {
+  		if (e - s < 11 || !spanEq(input, s, s + 10, "@container")) return false;
+  		if (input.charCodeAt(s + 10) === 47) return e - s >= 12;
+  		const c11 = input.charCodeAt(s + 11);
+  		return c11 === 115 && e - s >= 17 && spanEq(input, s + 10, s + 16, "-size/") || c11 === 110 && e - s >= 19 && spanEq(input, s + 10, s + 18, "-normal/");
+  	};
+  	const VKIND = [
+  		1,
+  		1,
+  		1,
+  		1,
+  		1,
+  		1,
+  		1,
+  		1,
+  		2,
+  		2,
+  		2,
+  		2,
+  		2,
+  		2,
+  		2
+  	];
+  	const VLABELS = "length|number|number weight|family-name|position percentage|length size bg-size|image url|shadow|length|family-name|position percentage|length size bg-size|image url|shadow|number weight".split("|").map((s) => s.split(" "));
+  	const VFALL = [
+  		2,
+  		3,
+  		1,
+  		0,
+  		0,
+  		0,
+  		4,
+  		5,
+  		0,
+  		0,
+  		0,
+  		0,
+  		0,
+  		1,
+  		1
+  	];
+  	const runValidator = (op, input, s, e) => {
+  		if (op >= 10) {
+  			if (op >= 25) return vCustom[op - 25](input.slice(s, e));
+  			const i = op - 10;
+  			if (aKind !== VKIND[i]) return false;
+  			if (aLabelS >= 0) {
+  				for (const L of VLABELS[i]) if (spanEq(input, aLabelS, aLabelE, L)) return true;
+  				return false;
+  			}
+  			switch (VFALL[i]) {
+  				case 0: return false;
+  				case 1: return true;
+  				case 2: {
+  					const v = input.slice(aValS, aValE);
+  					return lengthUnitRegex.test(v) && !colorFunctionRegex.test(v);
+  				}
+  				case 3: return isNumStr(input.slice(aValS, aValE));
+  				case 4: return imageRegex.test(input.slice(aValS, aValE));
+  				default: return shadowRegex.test(input.slice(aValS, aValE));
+  			}
+  		}
+  		switch (op) {
+  			case 0: return true;
+  			case 1: return aKind === 0;
+  			case 2: return aKind === 1;
+  			case 3: return aKind === 2;
+  			case 4: return fractionRegex.test(input.slice(s, e));
+  			case 5: return isNumStr(input.slice(s, e));
+  			case 6: {
+  				const v = input.slice(s, e);
+  				return !!v && Number.isInteger(Number(v));
+  			}
+  			case 7: return e > s && input.charCodeAt(e - 1) === 37 && isNumStr(input.slice(s, e - 1));
+  			case 8: return tshirtRegex.test(input.slice(s, e));
+  			default: return spanIsNamedContainerQuery(input, s, e);
+  		}
+  	};
+  	const orderSensitive = new Set(typeof orderSensitiveModifiers === "string" ? orderSensitiveModifiers.split(" ") : orderSensitiveModifiers);
+  	const internSpan = (map, input, s, e, imp, make) => {
+  		const h = fnv(input, s, e) ^ (imp ? 2654435769 : 0) | 0;
+  		let bucket = map.get(h);
+  		if (bucket !== void 0) outer: for (let b = 0; b < bucket.length; b++) {
+  			const en = bucket[b];
+  			if (en.imp !== imp || en.k.length !== e - s) continue;
+  			for (let i = 0; i < en.k.length; i++) if (en.k.charCodeAt(i) !== input.charCodeAt(s + i)) continue outer;
+  			return en.id;
+  		}
+  		else map.set(h, bucket = []);
+  		const k = input.slice(s, e);
+  		const id = make(k);
+  		bucket.push({
+  			k,
+  			imp,
+  			id
+  		});
+  		return id;
+  	};
+  	let ctxByHash = /* @__PURE__ */ new Map();
+  	let ctxByCanon = /* @__PURE__ */ new Map();
+  	let nextCtxId = 2;
+  	const MAX_CTX = 4096;
+  	const canonicalizeContext = (raw, important) => {
+  		const mods = [];
+  		let dB = 0, dP = 0, start = 0;
+  		for (let i = 0; i < raw.length; i++) {
+  			const c = raw.charCodeAt(i);
+  			if (dB === 0 && dP === 0 && c === 58) {
+  				mods.push(raw.slice(start, i));
+  				start = i + 1;
+  			} else if (c === 91) dB++;
+  			else if (c === 93) dB--;
+  			else if (c === 40) dP++;
+  			else if (c === 41) dP--;
+  		}
+  		mods.push(raw.slice(start));
+  		let canonical = mods[0];
+  		if (mods.length > 1) {
+  			const result = [];
+  			let segment = [];
+  			for (const mod of mods) if (mod.charCodeAt(0) === 91 || orderSensitive.has(mod)) {
+  				if (segment.length) {
+  					result.push(...segment.sort());
+  					segment = [];
+  				}
+  				result.push(mod);
+  			} else segment.push(mod);
+  			if (segment.length) result.push(...segment.sort());
+  			canonical = result.join(":");
+  		}
+  		const key = important ? canonical + " !" : canonical;
+  		let id = ctxByCanon.get(key);
+  		if (id === void 0) ctxByCanon.set(key, id = nextCtxId++);
+  		return id;
+  	};
+  	let dynByHash = /* @__PURE__ */ new Map();
+  	let nextDynId = GROUP_COUNT;
+  	const MAX_DYN = GROUP_COUNT + 4096;
+  	const newDynId = () => nextDynId++;
+  	const ID_LIMIT = 2097152;
+  	const TOKEN_TABLE = 8192;
+  	const memoHash = new Int32Array(TOKEN_TABLE);
+  	const memoStr = new Array(TOKEN_TABLE).fill(null);
+  	const memoGid = new Int32Array(TOKEN_TABLE);
+  	const memoCtx = new Int32Array(TOKEN_TABLE);
+  	const memoFlags = new Uint8Array(TOKEN_TABLE);
+  	let memoTick = 0;
+  	const memoPut = (way0, input, ts, te, h, gid, ctxId, flags) => {
+  		let slot = way0;
+  		if (memoStr[way0] !== null) {
+  			if (memoStr[way0 | 1] === null) slot = way0 | 1;
+  			else if ((memoTick++ & 3) === 0) slot = way0 | memoTick >> 2 & 1;
+  			else return;
+  		}
+  		memoStr[slot] = input.slice(ts, te);
+  		memoHash[slot] = h;
+  		memoGid[slot] = gid;
+  		memoCtx[slot] = ctxId;
+  		memoFlags[slot] = flags;
+  	};
+  	const memoReset = () => memoStr.fill(null);
+  	let cap = 256;
+  	let tokI32 = [
+  		new Int32Array(cap),
+  		new Int32Array(cap),
+  		new Int32Array(cap),
+  		new Int32Array(cap)
+  	];
+  	let [tokStart, tokEnd, tokGid, tokCtx] = tokI32;
+  	let tokFlags = new Uint8Array(cap);
+  	let keep = new Uint8Array(cap);
+  	const growTokens = () => {
+  		cap *= 2;
+  		tokI32 = tokI32.map((a) => {
+  			const n = new Int32Array(cap);
+  			n.set(a);
+  			return n;
+  		});
+  		[tokStart, tokEnd, tokGid, tokCtx] = tokI32;
+  		const nf = new Uint8Array(cap);
+  		nf.set(tokFlags);
+  		tokFlags = nf;
+  		keep = new Uint8Array(cap);
+  	};
+  	let ckptCap = 64;
+  	let ckptNode = new Int32Array(ckptCap);
+  	let ckptTail = new Int32Array(ckptCap);
+  	const claim0 = new Int32Array(GROUP_COUNT);
+  	let CLAIM_TABLE = 2048;
+  	let claimShift = 21;
+  	let claimKeys = new Float64Array(CLAIM_TABLE);
+  	let claimEpochs = new Int32Array(CLAIM_TABLE);
+  	let epoch = 0;
+  	const claimTest = (ctx, gid) => {
+  		if (ctx === 0 && gid < GROUP_COUNT) {
+  			if (claim0[gid] === epoch) return 1;
+  			claim0[gid] = epoch;
+  			return 0;
+  		}
+  		const key = ctx * 2097152 + gid + 1;
+  		let idx = Math.imul(key, 2654435761) >>> claimShift;
+  		for (;;) {
+  			if (claimEpochs[idx] !== epoch) break;
+  			if (claimKeys[idx] === key) return 1;
+  			idx = idx + 1 & CLAIM_TABLE - 1;
+  		}
+  		claimKeys[idx] = key;
+  		claimEpochs[idx] = epoch;
+  		return 0;
+  	};
+  	const resolveAt = (input, bs, endPos, nodeAt, ckptAt) => {
+  		if (endPos - bs >= 2 && input.charCodeAt(bs) === 91 && input.charCodeAt(endPos - 1) === 93) {
+  			let colon = -1;
+  			for (let p = bs + 1; p < endPos - 1; p++) if (input.charCodeAt(p) === 58) {
+  				colon = p;
+  				break;
+  			}
+  			if (colon === -1 || colon === bs + 1) return EXTERNAL;
+  			return internSpan(dynByHash, input, bs + 1, colon, 0, newDynId);
+  		}
+  		if (nodeAt >= 0 && nodeGroup[nodeAt] >= 0) return nodeGroup[nodeAt];
+  		for (let k = ckptAt - 1; k >= 0; k--) {
+  			const tailStart = ckptTail[k];
+  			if (tailStart > endPos) continue;
+  			const nodeId = ckptNode[k];
+  			const tlen = endPos - tailStart;
+  			if (nodeHasLit[nodeId] === 1 && tlen > 0 && tlen <= litMaxLen) {
+  				const c0 = input.charCodeAt(tailStart);
+  				if (litNoArb === false || c0 !== 91 && c0 !== 40) {
+  					const g = litProbe(nodeId, input, tailStart, endPos);
+  					if (g >= 0) return g;
+  				}
+  			}
+  			const vl = nodeVlist[nodeId];
+  			if (vl < 0) continue;
+  			const pat = vlistRef[vl];
+  			const vs = vlistPat[pat];
+  			const ve = vlistPat[pat + 1];
+  			if (vs === ve) continue;
+  			analyzeArb(input, tailStart, endPos);
+  			const g0 = vgStart[vl] - vs;
+  			for (let v = vs; v < ve; v++) if (runValidator(vlistOps[v], input, tailStart, endPos)) return vlistGroup[g0 + v];
+  		}
+  		return EXTERNAL;
+  	};
+  	const mergeClassList = (input) => {
+  		const n = input.length;
+  		let tokenCount = 0;
+  		let totalTokenChars = 0;
+  		let sawNonSpaceWS = false;
+  		if (nextCtxId > MAX_CTX || ctxByHash.size > MAX_CTX) {
+  			ctxByHash = /* @__PURE__ */ new Map();
+  			ctxByCanon = /* @__PURE__ */ new Map();
+  			nextCtxId = 2;
+  			memoReset();
+  		}
+  		if (nextDynId > MAX_DYN) {
+  			dynByHash = /* @__PURE__ */ new Map();
+  			nextDynId = GROUP_COUNT;
+  			memoReset();
+  		}
+  		let i = 0;
+  		while (i < n) {
+  			let c = input.charCodeAt(i);
+  			if (c === 32 || c >= 9 && c <= 13 || c >= 160 && isUniWS(c)) {
+  				if (c !== 32) sawNonSpaceWS = true;
+  				i++;
+  				continue;
+  			}
+  			const ts = i;
+  			let th = 0;
+  			while (i < n) {
+  				c = input.charCodeAt(i);
+  				if (c <= 32) {
+  					if (c === 32) break;
+  					if (c >= 9 && c <= 13) {
+  						sawNonSpaceWS = true;
+  						break;
+  					}
+  				} else if (c >= 160 && isUniWS(c)) {
+  					sawNonSpaceWS = true;
+  					break;
+  				}
+  				th = Math.imul(th ^ c, 16777619);
+  				i++;
+  			}
+  			const te = i;
+  			const len = te - ts;
+  			if (tokenCount === cap) growTokens();
+  			const t = tokenCount++;
+  			tokStart[t] = ts;
+  			tokEnd[t] = te;
+  			totalTokenChars += len;
+  			th ^= Math.imul(len, 2654435761);
+  			const h = th ^ th >>> 15 | 0;
+  			const way0 = h & 8190;
+  			{
+  				let hitAt = -1;
+  				if (memoHash[way0] === h && memoStr[way0] !== null && memoStr[way0].length === len) hitAt = way0;
+  				else if (memoHash[way0 | 1] === h && memoStr[way0 | 1] !== null && memoStr[way0 | 1].length === len) hitAt = way0 | 1;
+  				if (hitAt >= 0) {
+  					const s = memoStr[hitAt];
+  					let ok = true;
+  					for (let k = 0; k < len; k++) if (s.charCodeAt(k) !== input.charCodeAt(ts + k)) {
+  						ok = false;
+  						break;
+  					}
+  					if (ok) {
+  						tokGid[t] = memoGid[hitAt];
+  						tokCtx[t] = memoCtx[hitAt];
+  						tokFlags[t] = memoFlags[hitAt];
+  						continue;
+  					}
+  				}
+  			}
+  			let pts = ts;
+  			if (FPL !== 0) {
+  				if (te - ts <= FPL || !input.startsWith(FULL_PREFIX, ts)) {
+  					tokGid[t] = EXTERNAL;
+  					memoPut(way0, input, ts, te, h, EXTERNAL, 0, 0);
+  					continue;
+  				}
+  				pts = ts + FPL;
+  			}
+  			let depthB = 0, depthP = 0;
+  			let lastColon = -1, lastSlash = -1;
+  			for (let p = pts; p < te; p++) {
+  				const pc = input.charCodeAt(p);
+  				if (depthB === 0 && depthP === 0) {
+  					if (pc === 58) {
+  						lastColon = p;
+  						continue;
+  					}
+  					if (pc === 47) {
+  						lastSlash = p;
+  						continue;
+  					}
+  				}
+  				if (pc === 91) depthB++;
+  				else if (pc === 93) depthB--;
+  				else if (pc === 40) depthP++;
+  				else if (pc === 41) depthP--;
+  			}
+  			const modStart = lastColon >= pts ? lastColon + 1 : pts;
+  			let bs = modStart;
+  			let be = te;
+  			let important = false;
+  			let prefixShift = 0;
+  			if (be > bs && input.charCodeAt(be - 1) === 33) {
+  				important = true;
+  				be--;
+  			} else if (be > bs && input.charCodeAt(bs) === 33) {
+  				important = true;
+  				bs++;
+  				prefixShift = 1;
+  			}
+  			let postfixEnd = -1;
+  			if (lastSlash > modStart) {
+  				postfixEnd = lastSlash + prefixShift;
+  				if (postfixEnd >= be) postfixEnd = -1;
+  			}
+  			let feedStart = bs;
+  			if (be - bs > 1 && input.charCodeAt(bs) === 45) feedStart = bs + 1;
+  			let node = 0;
+  			let lp = 0;
+  			let le = 0;
+  			let pending = -1;
+  			let ckptTop = 0;
+  			if (nodeVlist[0] >= 0 || nodeHasLit[0] === 1) {
+  				ckptNode[0] = 0;
+  				ckptTail[0] = feedStart;
+  				ckptTop = 1;
+  			}
+  			let slashNode = DEAD;
+  			let slashCkpt = 0;
+  			for (let p = feedStart; p < be; p++) {
+  				if (p === postfixEnd) {
+  					slashNode = lp < le ? DEAD : node;
+  					slashCkpt = ckptTop;
+  				}
+  				if (node !== DEAD) {
+  					const cc = input.charCodeAt(p);
+  					let arrived = -1;
+  					if (lp < le) {
+  						if (labelText.charCodeAt(lp) === cc) {
+  							lp++;
+  							if (lp === le) arrived = node = pending;
+  						} else node = DEAD;
+  					} else {
+  						const es = edgeStart[node];
+  						const ee = edgeStart[node + 1];
+  						let next = DEAD;
+  						for (let e = es; e < ee; e++) {
+  							const ls = labelStart[e];
+  							if (labelText.charCodeAt(ls) === cc) {
+  								if (labelStart[e + 1] - ls === 1) arrived = next = edgeTarget[e];
+  								else {
+  									lp = ls + 1;
+  									le = labelStart[e + 1];
+  									pending = edgeTarget[e];
+  									next = node;
+  								}
+  								break;
+  							}
+  						}
+  						node = next;
+  					}
+  					if (arrived >= 0 && (nodeVlist[arrived] >= 0 || nodeHasLit[arrived] === 1) && p + 1 < be && input.charCodeAt(p + 1) === 45) {
+  						if (ckptTop === ckptCap) {
+  							ckptCap *= 2;
+  							const nv = new Int32Array(ckptCap);
+  							nv.set(ckptNode);
+  							ckptNode = nv;
+  							const nt = new Int32Array(ckptCap);
+  							nt.set(ckptTail);
+  							ckptTail = nt;
+  						}
+  						ckptNode[ckptTop] = arrived;
+  						ckptTail[ckptTop] = p + 2;
+  						ckptTop++;
+  					}
+  				}
+  			}
+  			if (postfixEnd === be) {
+  				slashNode = lp < le ? DEAD : node;
+  				slashCkpt = ckptTop;
+  			}
+  			const endNode = lp < le ? DEAD : node;
+  			let gid;
+  			let hasPostfix = false;
+  			if (postfixEnd >= 0) {
+  				hasPostfix = true;
+  				gid = resolveAt(input, bs, postfixEnd, slashNode, slashCkpt);
+  				if (gid !== EXTERNAL && gid < GROUP_COUNT && postfixLookupSet[gid]) {
+  					const gidFull = resolveAt(input, bs, be, endNode, ckptTop);
+  					if (gidFull !== EXTERNAL && gidFull !== gid) {
+  						gid = gidFull;
+  						hasPostfix = false;
+  					}
+  				} else if (gid === EXTERNAL) {
+  					gid = resolveAt(input, bs, be, endNode, ckptTop);
+  					hasPostfix = false;
+  				}
+  			} else gid = resolveAt(input, bs, be, endNode, ckptTop);
+  			let ctxId = 0;
+  			let flags = 0;
+  			if (gid === EXTERNAL) tokGid[t] = EXTERNAL;
+  			else {
+  				flags = hasPostfix ? 1 : 0;
+  				ctxId = pts >= lastColon ? important ? 1 : 0 : internSpan(ctxByHash, input, pts, lastColon, important ? 1 : 0, (k) => canonicalizeContext(k, important));
+  				tokGid[t] = gid;
+  				tokFlags[t] = flags;
+  				tokCtx[t] = ctxId;
+  			}
+  			memoPut(way0, input, ts, te, h, gid, ctxId, flags);
+  		}
+  		if (tokenCount === 0) return "";
+  		if (tokenCount === 1) return tokStart[0] === 0 && tokEnd[0] === n ? input : input.slice(tokStart[0], tokEnd[0]);
+  		if (tokenCount * CLAIM_PER_TOKEN > CLAIM_TABLE) {
+  			while (tokenCount * CLAIM_PER_TOKEN > CLAIM_TABLE) {
+  				CLAIM_TABLE <<= 1;
+  				claimShift--;
+  			}
+  			claimKeys = new Float64Array(CLAIM_TABLE);
+  			claimEpochs = new Int32Array(CLAIM_TABLE);
+  		}
+  		if (nextCtxId >= ID_LIMIT || nextDynId >= ID_LIMIT) throw new Error("cn: too many distinct classes in one merge");
+  		epoch = epoch + 1 | 0;
+  		if (epoch === 0) {
+  			claim0.fill(0);
+  			claimEpochs.fill(0);
+  			epoch = 1;
+  		}
+  		let didDrop = false;
+  		for (let t = tokenCount - 1; t >= 0; t--) {
+  			const gid = tokGid[t];
+  			if (gid === EXTERNAL) {
+  				keep[t] = 1;
+  				continue;
+  			}
+  			const ctxId = tokCtx[t];
+  			if (claimTest(ctxId, gid) === 1) {
+  				keep[t] = 0;
+  				didDrop = true;
+  				continue;
+  			}
+  			keep[t] = 1;
+  			if (gid < GROUP_COUNT) {
+  				const r = adjRow[gid];
+  				if (r >= 0) for (let k = adjStart[r]; k < adjStart[r + 1]; k++) claimTest(ctxId, adjTgt[k]);
+  				if (tokFlags[t] & 1) {
+  					for (let k = 0; k < patGid.length; k++) if (patGid[k] === gid) claimTest(ctxId, patTgt[k]);
+  				}
+  			}
+  		}
+  		if (!didDrop && !sawNonSpaceWS && n === totalTokenChars + tokenCount - 1) return input;
+  		let out = "";
+  		let t = 0;
+  		while (t < tokenCount) {
+  			if (!keep[t]) {
+  				t++;
+  				continue;
+  			}
+  			const runStart = tokStart[t];
+  			let runEnd = tokEnd[t];
+  			let u = t + 1;
+  			while (u < tokenCount && keep[u] && tokStart[u] === runEnd + 1 && input.charCodeAt(runEnd) === 32) {
+  				runEnd = tokEnd[u];
+  				u++;
+  			}
+  			if (out.length > 0) out += " ";
+  			out += input.slice(runStart, runEnd);
+  			t = u;
+  		}
+  		return out;
+  	};
+  	const DOOR_SIZE = 16384;
+  	const door = new Int32Array(DOOR_SIZE * 2);
+  	let doorBase = 0;
+  	let doorEpoch = 1;
+  	let cache = Object.create(null);
+  	let prevCache = Object.create(null);
+  	let cacheMap = /* @__PURE__ */ new Map();
+  	let prevCacheMap = /* @__PURE__ */ new Map();
+  	let cacheCount = 0;
+  	let doorMarks = 0;
+  	const rotateDoor = () => {
+  		doorBase ^= DOOR_SIZE;
+  		doorEpoch = doorEpoch + 1 | 0;
+  		doorMarks = 0;
+  	};
+  	const mergeCached = (input) => {
+  		let merged = cache[input];
+  		if (merged !== void 0) return merged;
+  		const hash = spanHash(input, 0, input.length);
+  		const slot = (hash & 16383) + doorBase;
+  		const wasSeen = door[slot] === (hash ^ doorEpoch) || door[slot ^ DOOR_SIZE] === (hash ^ doorEpoch - 1);
+  		if (wasSeen) {
+  			merged = prevCache[input];
+  			if (merged !== void 0) {
+  				cache[input] = merged;
+  				return merged;
+  			}
+  		}
+  		merged = mergeClassList(input);
+  		if (wasSeen) {
+  			cache[input] = merged;
+  			if (++cacheCount > cacheSize) {
+  				cacheCount = 0;
+  				prevCache = cache;
+  				cache = Object.create(null);
+  				rotateDoor();
+  			}
+  		} else {
+  			door[slot] = hash ^ doorEpoch;
+  			if (++doorMarks > DOOR_SIZE) rotateDoor();
+  		}
+  		return merged;
+  	};
+  	const mergeCachedMap = (input) => {
+  		let merged = cacheMap.get(input);
+  		if (merged !== void 0) return merged;
+  		const hash = spanHash(input, 0, input.length);
+  		const slot = (hash & 16383) + doorBase;
+  		const wasSeen = door[slot] === (hash ^ doorEpoch) || door[slot ^ DOOR_SIZE] === (hash ^ doorEpoch - 1);
+  		if (wasSeen) {
+  			merged = prevCacheMap.get(input);
+  			if (merged !== void 0) {
+  				cacheMap.set(input, merged);
+  				return merged;
+  			}
+  		}
+  		merged = mergeClassList(input);
+  		if (wasSeen) {
+  			cacheMap.set(input, merged);
+  			if (++cacheCount > cacheSize) {
+  				cacheCount = 0;
+  				prevCacheMap = cacheMap;
+  				cacheMap = /* @__PURE__ */ new Map();
+  				rotateDoor();
+  			}
+  		} else {
+  			door[slot] = hash ^ doorEpoch;
+  			if (++doorMarks > DOOR_SIZE) rotateDoor();
+  		}
+  		return merged;
+  	};
+  	const seenBefore = (input) => {
+  		const hash = spanHash(input, 0, input.length);
+  		const slot = (hash & 16383) + doorBase;
+  		if (door[slot] === (hash ^ doorEpoch) || door[slot ^ DOOR_SIZE] === (hash ^ doorEpoch - 1)) return true;
+  		door[slot] = hash ^ doorEpoch;
+  		if (++doorMarks > DOOR_SIZE) rotateDoor();
+  		return false;
+  	};
+  	const mergeString = cacheSize === 0 ? mergeClassList : IS_JSC ? (input) => {
+  		const merged = cacheMap.get(input);
+  		return merged !== void 0 ? merged : mergeCachedMap(input);
+  	} : mergeCached;
+  	const merge = function() {
+  		return arguments.length === 1 && typeof arguments[0] === "string" ? mergeString(arguments[0]) : mergeString(twJoin.apply(null, arguments));
+  	};
+  	return {
+  		merge,
+  		mergeString,
+  		seenBefore: cacheSize === 0 ? () => false : seenBefore,
+  		mergeUncached: mergeClassList
+  	};
+  };
+  const resolveValue = (v, clsxMode) => {
+  	if (!v) return "";
+  	if (typeof v === "string") return v;
+  	let out = "";
+  	if (typeof v.length === "number" && (clsxMode ? Array.isArray(v) : true)) {
+  		const arr = v;
+  		for (let i = 0; i < arr.length; i++) {
+  			const item = arr[i];
+  			if (!item) continue;
+  			const r = typeof item === "string" ? item : resolveValue(item, clsxMode);
+  			if (r) {
+  				if (out) out += " ";
+  				out += r;
+  			}
+  		}
+  		return out;
+  	}
+  	if (clsxMode) {
+  		if (typeof v === "number") return "" + v;
+  		if (typeof v === "object") {
+  			for (const k in v) if (v[k]) {
+  				if (out) out += " ";
+  				out += k;
+  			}
+  		}
+  	}
+  	return out;
+  };
+  const joinArgs = (args, clsxMode) => {
+  	let s = "";
+  	for (let i = 0; i < args.length; i++) {
+  		const a = args[i];
+  		if (!a) continue;
+  		const r = typeof a === "string" ? a : resolveValue(a, clsxMode);
+  		if (r) {
+  			if (s) s += " ";
+  			s += r;
+  		}
+  	}
+  	return s;
+  };
+  /** join-only, `twJoin`-compatible (strings + nested arrays, falsy skipped) */
+  const twJoin = function() {
+  	return joinArgs(arguments, false);
+  };
+  const BUCKET_CAP = 256;
+  const BUCKET_MISS_CAP = 16;
+  const BUCKET_SKIP = 1024;
+  const CHURN_SIZE = 4096;
+  const wrapClsx = (mergeString, fresh) => {
+  	const seenBefore = fresh === void 0 ? () => true : fresh.seenBefore;
+  	const mergeUncached = fresh === void 0 ? mergeString : fresh.mergeUncached;
+  	let argCache = /* @__PURE__ */ new Map();
+  	let prevArgCache = /* @__PURE__ */ new Map();
+  	let argCount = 0;
+  	let lastHit = null;
+  	let churnKey = null;
+  	let churnOwn = [];
+  	let churnVal = [];
+  	let churnTick = 0;
+  	const churnLookup = (key, own, join) => {
+  		if (churnKey === null) {
+  			churnKey = new Array(CHURN_SIZE).fill("");
+  			churnOwn = new Array(CHURN_SIZE).fill("");
+  			churnVal = new Array(CHURN_SIZE).fill("");
+  		}
+  		const way0 = spanHash(key, 0, key.length) & 4094;
+  		if (churnKey[way0] === key && churnOwn[way0] === own) return churnVal[way0];
+  		if (churnKey[way0 | 1] === key && churnOwn[way0 | 1] === own) return churnVal[way0 | 1];
+  		const merged = mergeString(join ? own + " " + key : key);
+  		const slot = churnKey[way0] === "" ? way0 : way0 | (churnKey[way0 | 1] === "" ? 1 : churnTick++ & 1);
+  		churnKey[slot] = key;
+  		churnOwn[slot] = own;
+  		churnVal[slot] = merged;
+  		return merged;
+  	};
+  	const match3 = (e, v0, v1, v2) => {
+  		let k = 0;
+  		if (v0) {
+  			if (v0 !== e.a0) return false;
+  			k = 1;
+  		}
+  		if (v1) {
+  			if (v1 !== (k === 0 ? e.a0 : e.a1)) return false;
+  			k++;
+  		}
+  		if (v2) {
+  			if (v2 !== (k === 0 ? e.a0 : k === 1 ? e.a1 : e.a2)) return false;
+  			k++;
+  		}
+  		return k === e.t;
+  	};
+  	const matchN = (e, vals) => {
+  		const ea = e.a;
+  		let k = 0;
+  		for (let i = 0; i < vals.length; i++) {
+  			const v = vals[i];
+  			if (!v) continue;
+  			if (v !== ea[k]) return false;
+  			k++;
+  		}
+  		return k === e.t;
+  	};
+  	const resolveArgs = (vals, probed) => {
+  		const nArgs = vals.length;
+  		const pred = lastHit === null ? null : lastHit.n;
+  		if (!probed) {
+  			if (pred !== null && matchN(pred, vals)) {
+  				lastHit = pred;
+  				return pred.r;
+  			}
+  			if (lastHit !== null && lastHit !== pred && matchN(lastHit, vals)) return lastHit.r;
+  		}
+  		let first = "";
+  		let firstIdx = -1;
+  		let truthy = 0;
+  		let hasResolvedValue = false;
+  		for (let i = 0; i < nArgs; i++) {
+  			let v = vals[i];
+  			if (!v) continue;
+  			if (typeof v !== "string") {
+  				v = vals[i] = resolveValue(v, true);
+  				if (!v) continue;
+  				hasResolvedValue = true;
+  			}
+  			if (firstIdx < 0) {
+  				first = v;
+  				firstIdx = i;
+  			}
+  			truthy++;
+  		}
+  		if (truthy === 0) return "";
+  		if (truthy === 1) return mergeString(first);
+  		if (hasResolvedValue) {
+  			if (pred !== null && matchN(pred, vals)) {
+  				lastHit = pred;
+  				return pred.r;
+  			}
+  			if (lastHit !== null && lastHit !== pred && matchN(lastHit, vals)) return lastHit.r;
+  		}
+  		let bucket = argCache.get(first);
+  		if (bucket === void 0) {
+  			bucket = prevArgCache.get(first);
+  			if (bucket !== void 0) argCache.set(first, bucket);
+  		}
+  		let hit = null;
+  		if (bucket !== void 0) {
+  			if (bucket.skip > 0) {
+  				bucket.skip--;
+  				lastHit = null;
+  				let joined = first;
+  				for (let i = firstIdx + 1; i < nArgs; i++) {
+  					const v = vals[i];
+  					if (v) joined += " " + v;
+  				}
+  				return churnLookup(joined, "", false);
+  			}
+  			const entries = bucket.e;
+  			outer: for (let b = 0; b < entries.length; b++) {
+  				const e = entries[b];
+  				if (e.t !== truthy) continue;
+  				const ea = e.a;
+  				let k = 1;
+  				for (let i = firstIdx + 1; i < nArgs; i++) {
+  					const v = vals[i];
+  					if (v && v !== ea[k++]) continue outer;
+  				}
+  				hit = e;
+  				break;
+  			}
+  			if (hit !== null) bucket.miss = 0;
+  		}
+  		if (hit === null) {
+  			let joined = first;
+  			const a = [first];
+  			for (let i = firstIdx + 1; i < nArgs; i++) {
+  				const v = vals[i];
+  				if (!v) continue;
+  				joined += " " + v;
+  				a.push(v);
+  			}
+  			if (!seenBefore(joined)) return mergeUncached(joined);
+  			hit = {
+  				r: mergeString(joined),
+  				t: a.length,
+  				a0: a[0],
+  				a1: a[1],
+  				a2: a[2] ?? "",
+  				a,
+  				n: null
+  			};
+  			if (bucket === void 0) argCache.set(first, bucket = {
+  				e: [],
+  				miss: 0,
+  				skip: 0,
+  				at: 0
+  			});
+  			else if (++bucket.miss > BUCKET_MISS_CAP) {
+  				bucket.miss = BUCKET_MISS_CAP;
+  				bucket.skip = BUCKET_SKIP;
+  				bucket.e.length = 0;
+  				bucket.at = 0;
+  			}
+  			const entries = bucket.e;
+  			if (entries.length < BUCKET_CAP) entries.push(hit);
+  			else {
+  				entries[bucket.at] = hit;
+  				bucket.at = bucket.at + 1 & 255;
+  			}
+  			if (++argCount > 1e3) {
+  				argCount = 0;
+  				prevArgCache = argCache;
+  				argCache = /* @__PURE__ */ new Map();
+  			}
+  		}
+  		if (lastHit !== null && lastHit !== hit) lastHit.n = hit;
+  		lastHit = hit;
+  		return hit.r;
+  	};
+  	const mergeSingleValue = (value) => Array.isArray(value) ? resolveArgs(value.slice(), false) : mergeString(resolveValue(value, true));
+  	return function(v0, v1, v2) {
+  		const nArgs = arguments.length;
+  		if ((nArgs | 1) === 3) {
+  			const lh = lastHit;
+  			if (lh !== null) {
+  				const pred = lh.n;
+  				if (pred !== null && match3(pred, v0, v1, v2)) {
+  					lastHit = pred;
+  					return pred.r;
+  				}
+  				if (lh !== pred && match3(lh, v0, v1, v2)) return lh.r;
+  			}
+  			if (nArgs === 2 && typeof v1 === "string" && v1 !== "") {
+  				const bucket = argCache.get(v0);
+  				if (bucket !== void 0 && bucket.skip > 0) {
+  					bucket.skip--;
+  					lastHit = null;
+  					return churnLookup(v1, v0, true);
+  				}
+  			}
+  			return resolveArgs([
+  				v0,
+  				v1,
+  				v2
+  			], true);
+  		}
+  		if (nArgs === 1) return typeof v0 === "string" ? mergeString(v0) : mergeSingleValue(v0);
+  		const lh = lastHit;
+  		if (lh !== null) {
+  			const pred = lh.n;
+  			if (pred !== null) {
+  				const pa = pred.a;
+  				let k = 0;
+  				let ok = true;
+  				for (let i = 0; i < nArgs; i++) {
+  					const v = arguments[i];
+  					if (!v) continue;
+  					if (v !== pa[k]) {
+  						ok = false;
+  						break;
+  					}
+  					k++;
+  				}
+  				if (ok && k === pred.t) {
+  					lastHit = pred;
+  					return pred.r;
+  				}
+  			}
+  			if (lh !== pred) {
+  				const la = lh.a;
+  				let k = 0;
+  				let ok = true;
+  				for (let i = 0; i < nArgs; i++) {
+  					const v = arguments[i];
+  					if (!v) continue;
+  					if (v !== la[k]) {
+  						ok = false;
+  						break;
+  					}
+  					k++;
+  				}
+  				if (ok && k === lh.t) return lh.r;
+  			}
+  		}
+  		const vals = [];
+  		for (let i = 0; i < nArgs; i++) vals.push(arguments[i]);
+  		return resolveArgs(vals, true);
+  	};
+  };
+
+  //#region src/index.ts
+  const instance = /* @__PURE__ */ createEngine(tables_generated_default);
+  /**
+  * Merge Tailwind CSS classes with clsx-style arguments (strings, arrays,
+  * objects, conditionals). Drop-in replacement for `twMerge(clsx(...))`.
+  */
+  const cn = /* @__PURE__ */ wrapClsx(instance.mergeString, instance);
+
+  const buttonVariants = cva("group/button inline-flex shrink-0 items-center justify-center rounded-lg border border-transparent bg-clip-padding text-sm font-medium whitespace-nowrap transition-all outline-none select-none focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 active:not-aria-[haspopup]:translate-y-px disabled:pointer-events-none disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40 [&_svg]:pointer-events-none [&_svg]:shrink-0 [&_svg:not([class*='size-'])]:size-4", {
+      variants: {
+          variant: {
+              default: 'bg-primary text-primary-foreground hover:bg-primary/80',
+              outline: 'border-border bg-background hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:border-input dark:bg-input/30 dark:hover:bg-input/50',
+              secondary: 'bg-secondary text-secondary-foreground hover:bg-[color-mix(in_oklch,var(--secondary),var(--foreground)_5%)] aria-expanded:bg-secondary aria-expanded:text-secondary-foreground',
+              ghost: 'hover:bg-muted hover:text-foreground aria-expanded:bg-muted aria-expanded:text-foreground dark:hover:bg-muted/50',
+              destructive: 'bg-destructive/10 text-destructive hover:bg-destructive/20 focus-visible:border-destructive/40 focus-visible:ring-destructive/20 dark:bg-destructive/20 dark:hover:bg-destructive/30 dark:focus-visible:ring-destructive/40',
+              link: 'text-primary underline-offset-4 hover:underline',
+          },
+          size: {
+              default: 'h-8 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2',
+              xs: "h-6 gap-1 rounded-[min(var(--radius-md),10px)] px-2 text-xs in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3",
+              sm: "h-7 gap-1 rounded-[min(var(--radius-md),12px)] px-2.5 text-[0.8rem] in-data-[slot=button-group]:rounded-lg has-data-[icon=inline-end]:pr-1.5 has-data-[icon=inline-start]:pl-1.5 [&_svg:not([class*='size-'])]:size-3.5",
+              lg: 'h-9 gap-1.5 px-2.5 has-data-[icon=inline-end]:pr-2 has-data-[icon=inline-start]:pl-2',
+              icon: 'size-8',
+              'icon-xs': "size-6 rounded-[min(var(--radius-md),10px)] in-data-[slot=button-group]:rounded-lg [&_svg:not([class*='size-'])]:size-3",
+              'icon-sm': 'size-7 rounded-[min(var(--radius-md),12px)] in-data-[slot=button-group]:rounded-lg',
+              'icon-lg': 'size-9',
+          },
+      },
+      defaultVariants: {
+          variant: 'default',
+          size: 'default',
+      },
+  });
+  function Button({ className, variant = 'default', size = 'default', ...props }) {
+      return (jsxRuntimeExports.jsx(Button$1, { "data-slot": "button", className: typeof className === 'function'
+              ? (state) => cn(buttonVariants({ variant, size }), className(state))
+              : cn(buttonVariants({ variant, size }), className), ...props }));
+  }
+
+  /**
+   * Present when the field is disabled.
+   */
+  /**
+   * Present when the field is in a valid state.
+   */
+  const valid = 'data-valid';
+  /**
+   * Present when the field is in an invalid state.
+   */
+  const invalid = 'data-invalid';
+
+  const DEFAULT_VALIDITY_STATE = {
+    badInput: false,
+    customError: false,
+    patternMismatch: false,
+    rangeOverflow: false,
+    rangeUnderflow: false,
+    stepMismatch: false,
+    tooLong: false,
+    tooShort: false,
+    typeMismatch: false,
+    valid: null,
+    valueMissing: false
+  };
+  const DEFAULT_FIELD_STATE_ATTRIBUTES = {
+    valid: null,
+    touched: false,
+    dirty: false,
+    filled: false,
+    focused: false
+  };
+  const DEFAULT_FIELD_ROOT_STATE = {
+    disabled: false,
+    ...DEFAULT_FIELD_STATE_ATTRIBUTES
+  };
+  const fieldValidityMapping = {
+    valid(value) {
+      if (value === null) {
+        return null;
+      }
+      if (value) {
+        return {
+          [valid]: ''
+        };
+      }
+      return {
+        [invalid]: ''
+      };
+    }
+  };
+
+  const DEFAULT_FIELD_ROOT_CONTEXT = {
+    invalid: undefined,
+    name: undefined,
+    validityData: {
+      state: DEFAULT_VALIDITY_STATE,
+      errors: [],
+      error: '',
+      value: '',
+      initialValue: null
+    },
+    setValidityData: NOOP,
+    disabled: undefined,
+    setTouched: NOOP,
+    setDirty: NOOP,
+    setFilled: NOOP,
+    setFocused: NOOP,
+    focusOwnerRef: {
+      current: undefined
+    },
+    validationMode: 'onSubmit',
+    shouldValidateOnChange: () => false,
+    state: DEFAULT_FIELD_ROOT_STATE,
+    registerFieldControl: NOOP,
+    validation: {
+      getValidationProps: (_disabled, props = EMPTY_OBJECT) => props,
+      inputRef: {
+        current: null
+      },
+      registeredInputs: new Map(),
+      registerInput: NOOP,
+      getInputControl: () => null,
+      commit: async () => {},
+      change: NOOP
+    }
+  };
+  const FieldRootContext = /*#__PURE__*/React__namespace.createContext(DEFAULT_FIELD_ROOT_CONTEXT);
+  function useFieldRootContext(optional = true) {
+    const context = React__namespace.useContext(FieldRootContext);
+    if (context.setValidityData === NOOP && !optional) {
+      throw new Error(formatErrorMessage(28));
+    }
+    return context;
+  }
+
+  const FormContext = /*#__PURE__*/React__namespace.createContext({
+    elementRef: {
+      current: null
+    },
+    formRef: {
+      current: {
+        fields: new Map()
+      }
+    },
+    errors: {},
+    clearErrors: NOOP,
+    validationMode: 'onSubmit',
+    submitCountRef: {
+      current: 0
+    }
+  });
+  function useFormContext() {
+    return React__namespace.useContext(FormContext);
+  }
+
+  /**
+   * Returns a function that forces a rerender.
+   */
+  function useForcedRerendering() {
+    const [, setState] = React__namespace.useState({});
+    return React__namespace.useCallback(() => {
+      setState({});
+    }, []);
+  }
+
+  let globalId = 0;
+
+  // TODO React 17: Remove `useGlobalId` once React 17 support is removed
+  function useGlobalId(idOverride, prefix = 'mui') {
+    const defaultId = React__namespace.useRef(undefined);
+    const forceRerender = useForcedRerendering();
+    const id = idOverride ?? defaultId.current;
+    React__namespace.useEffect(() => {
+      if (defaultId.current == null) {
+        // Fallback to this default id when possible.
+        // Use the incrementing value for client-side rendering only.
+        // We can't use it server-side.
+        // If you want to use random values please consider the Birthday Problem: https://en.wikipedia.org/wiki/Birthday_problem
+        globalId += 1;
+        defaultId.current = `${prefix}-${globalId}`;
+        // Generate the fallback even while `idOverride` is set.
+        // Removing the override then swaps in the existing id within the same commit.
+        // Deferring generation would leave one commit with no id, breaking `htmlFor` and `aria-labelledby` links.
+        // Only rerender when the fallback is the value being rendered.
+        {
+          forceRerender();
+        }
+      }
+    }, [idOverride, prefix, forceRerender]);
+    return id;
+  }
+  const maybeReactUseId = SafeReact.useId;
+
+  /**
+   *
+   * @example <div id={useId()} />
+   * @param {string | undefined} idOverride overrides the generated id when provided
+   * @param {string | undefined} prefix prefixes the generated id when provided
+   * @returns {string | undefined}
+   */
+  function useId(idOverride, prefix) {
+    // React.useId() is only available from React 18.0.0.
+    if (maybeReactUseId !== undefined) {
+      const reactId = maybeReactUseId();
+      return idOverride ?? (prefix ? `${prefix}-${reactId}` : reactId);
+    }
+
+    // TODO: uncomment once we enable eslint-plugin-react-compiler // eslint-disable-next-line react-compiler/react-compiler
+    // eslint-disable-next-line react-hooks/rules-of-hooks -- `React.useId` is invariant at runtime.
+    return useGlobalId(idOverride, prefix);
+  }
+
+  /**
+   * Wraps `useId` and prefixes generated `id`s with `base-ui-`
+   * @param {string | undefined} idOverride overrides the generated id when provided
+   * @returns {string | undefined}
+   */
+  function useBaseUiId(idOverride) {
+    return useId(idOverride, 'base-ui');
+  }
+
+  /**
+   * A context for providing [labelable elements](https://html.spec.whatwg.org/multipage/forms.html#category-label)\
+   * with an accessible name (label) and description.
+   */
+  const LabelableContext = /*#__PURE__*/React__namespace.createContext({
+    controlId: undefined,
+    registerControlId: NOOP,
+    resetControlId: NOOP,
+    labelId: undefined,
+    setLabelId: NOOP,
+    messageIds: [],
+    setMessageIds: NOOP,
+    getDescriptionProps: externalProps => externalProps
+  });
+  function useLabelableContext() {
+    return React__namespace.useContext(LabelableContext);
+  }
+
+  function useLabelableId(params = {}) {
+    const {
+      id,
+      enabled = true
+    } = params;
+    const {
+      controlId,
+      registerControlId,
+      resetControlId
+    } = useLabelableContext();
+
+    // Deliberately not seeded with `id`: on React 17 the seed would stick around after the
+    // `id` prop is removed, leaving the control on a stale id forever.
+    const defaultId = useBaseUiId();
+    const controlSourceRef = useRefWithInit(() => Symbol());
+    const hasRegisteredRef = React__namespace.useRef(false);
+    const hadExplicitIdRef = React__namespace.useRef(false);
+    const unregisterControlId = useStableCallback(() => {
+      if (!hasRegisteredRef.current || registerControlId === NOOP) {
+        return;
+      }
+      hasRegisteredRef.current = false;
+      registerControlId(controlSourceRef.current, undefined);
+    });
+    useIsoLayoutEffect(() => {
+      if (!enabled || registerControlId === NOOP) {
+        unregisterControlId();
+        return undefined;
+      }
+      let nextId;
+      if (id !== undefined) {
+        hadExplicitIdRef.current = true;
+        nextId = id;
+      } else if (hadExplicitIdRef.current) {
+        nextId = defaultId;
+      } else {
+        // An id-less replacement must claim the provider's fallback so a previously registered
+        // explicit id is not retained after its control unmounts.
+        resetControlId();
+        return undefined;
+      }
+
+      // Either the control never had an explicit `id`, or React 17 has not assigned the
+      // fallback id yet. Neither is worth registering.
+      if (nextId === undefined) {
+        unregisterControlId();
+        return undefined;
+      }
+      hasRegisteredRef.current = true;
+      registerControlId(controlSourceRef.current, nextId);
+      return undefined;
+    }, [id, enabled, registerControlId, resetControlId, defaultId, controlSourceRef, unregisterControlId]);
+
+    // Unregistering in the layout phase, not a passive effect: a replacement control's layout
+    // effect would otherwise run first and still see the outgoing control's registration.
+    useIsoLayoutEffect(() => {
+      return unregisterControlId;
+    }, [unregisterControlId]);
+
+    // The provider's id wins until registration runs: the label renders `htmlFor` from the
+    // provider's pre-registration state, so preempting it with an explicit `id` here would
+    // leave the pair unassociated in server-rendered markup.
+    return (enabled ? controlId : undefined) ?? id ?? defaultId;
+  }
+
+  /**
+   * A React.useEffect equivalent that runs once, when the component is mounted.
+   */
+  function useOnMount(fn) {
+    // TODO: uncomment once we enable eslint-plugin-react-compiler // eslint-disable-next-line react-compiler/react-compiler -- no need to put `fn` in the dependency array
+    /* eslint-disable react-hooks/exhaustive-deps */
+    React__namespace.useEffect(fn, EMPTY_ARRAY);
+    /* eslint-enable react-hooks/exhaustive-deps */
+  }
+
+  const EMPTY = 0;
+  class Timeout {
+    static create() {
+      return new Timeout();
+    }
+    currentId = EMPTY;
+
+    /**
+     * Executes `fn` after `delay`, clearing any previously scheduled call.
+     */
+    start(delay, fn) {
+      this.clear();
+      this.currentId = setTimeout(() => {
+        this.currentId = EMPTY;
+        fn();
+      }, delay); /* Node.js types are enabled in development */
+    }
+    isStarted() {
+      return this.currentId !== EMPTY;
+    }
+    clear = () => {
+      if (this.currentId !== EMPTY) {
+        clearTimeout(this.currentId);
+        this.currentId = EMPTY;
+      }
+    };
+    disposeEffect = () => {
+      return this.clear;
+    };
+  }
+
+  /**
+   * A `setTimeout` with automatic cleanup and guard.
+   */
+  function useTimeout() {
+    const timeout = useRefWithInit(Timeout.create).current;
+    useOnMount(timeout.disposeEffect);
+    return timeout;
+  }
+
+  /**
+   * Returns the field's `setFocused`, recording which control the focused state belongs to.
+   *
+   * Disabling or unmounting a focused control moves focus away without firing `blur`, so the focused
+   * state would otherwise stay latched. A field can have several focus targets, so a control only
+   * clears the shared state when focus last landed on itself. The stable callback doubles as that
+   * identity.
+   */
+  function useSetFieldFocused(disabled, focusTargetRef, onFocusedChange) {
+    const {
+      setFocused,
+      focusOwnerRef
+    } = useFieldRootContext();
+    const setFieldFocused = useStableCallback(focused => {
+      // A disabled target can still be focused (`aria-disabled` elements stay programmatically
+      // focusable), but must not publish the field's focused styling.
+      if (focused ? !disabled : focusOwnerRef.current === setFieldFocused) {
+        focusOwnerRef.current = focused && setFieldFocused;
+        setFocused(focused);
+      }
+    });
+
+    // Re-run when `disabled` changes so a focused control releases the field even when the browser
+    // does not fire `blur`. The setup reclaims focus that no focus event reported: StrictMode
+    // re-running effects after a mount-time focus, a control focused before hydration, or an
+    // `aria-disabled` control re-enabled while it kept focus.
+    useIsoLayoutEffect(() => {
+      const el = focusTargetRef.current;
+      const root = el?.getRootNode();
+      if (root?.activeElement === el) {
+        setFieldFocused(true);
+      }
+      return () => setFieldFocused(false);
+    }, [disabled, focusTargetRef, setFieldFocused]);
+    return setFieldFocused;
+  }
+
+  function useRegisterFieldControl(controlRef, id, value, getFormValueOverride, enabled = true, name) {
+    const {
+      registerFieldControl
+    } = useFieldRootContext();
+    const sourceRef = useRefWithInit(() => Symbol());
+
+    // Re-register without unregistering first: re-registration with the same id updates the
+    // form's fields Map entry in place, while a delete + re-add would move the field to the
+    // end of the Map every time its value changes.
+    useIsoLayoutEffect(() => {
+      const source = sourceRef.current;
+      if (!enabled) {
+        registerFieldControl(source, undefined);
+        return;
+      }
+      const registration = {
+        controlRef,
+        getValue: getFormValueOverride,
+        id,
+        name,
+        value
+      };
+      registerFieldControl(source, registration);
+    }, [controlRef, enabled, getFormValueOverride, id, name, registerFieldControl, sourceRef, value]);
+    useIsoLayoutEffect(() => {
+      const source = sourceRef.current;
+      return () => {
+        registerFieldControl(source, undefined);
+      };
+    }, [registerFieldControl, sourceRef]);
+  }
+
+  function useValueChanged(value, onChange) {
+    const valueRef = React__namespace.useRef(value);
+    const onChangeCallback = useStableCallback(onChange);
+    useIsoLayoutEffect(() => {
+      if (valueRef.current !== value) {
+        onChangeCallback(valueRef.current);
+      }
+      valueRef.current = value;
+    }, [value, onChangeCallback]);
+  }
+
+  /**
+   * Maps a change `reason` string to the corresponding native event type.
+   */
+
+  /**
+   * Details of custom change events emitted by Base UI components.
+   */
+
+  /**
+   * Details of custom generic events emitted by Base UI components.
+   */
+
+  /** Highlight navigation uses mouse events for hover and pointer events for leaving an item. */
+
+  /**
+   * Creates a Base UI event details object with the given reason and utilities
+   * for preventing Base UI's internal event handling.
+   */
+  function createChangeEventDetails(reason, event, trigger, customProperties) {
+    let canceled = false;
+    let allowPropagation = false;
+    const custom = EMPTY_OBJECT;
+    const details = {
+      reason,
+      event: event ?? new Event('base-ui'),
+      cancel() {
+        canceled = true;
+      },
+      allowPropagation() {
+        allowPropagation = true;
+      },
+      get isCanceled() {
+        return canceled;
+      },
+      get isPropagationAllowed() {
+        return allowPropagation;
+      },
+      trigger,
+      ...custom
+    };
+    return details;
+  }
+
+  const none = 'none';
+
+  /**
+   * The form control to label and validate.
+   * Renders an `<input>` element.
+   *
+   * You can omit this part and use any Base UI input component instead. For example,
+   * [Input](https://base-ui.com/react/components/input), [Checkbox](https://base-ui.com/react/components/checkbox),
+   * or [Select](https://base-ui.com/react/components/select), among others, will work with Field out of the box.
+   *
+   * Documentation: [Base UI Field](https://base-ui.com/react/components/field)
+   */
+  const FieldControl = /*#__PURE__*/React__namespace.forwardRef(function FieldControl(componentProps, forwardedRef) {
+    const {
+      render,
+      className,
+      id: idProp,
+      name: nameProp,
+      value,
+      disabled: disabledProp = false,
+      onValueChange,
+      defaultValue,
+      autoFocus = false,
+      style,
+      ...elementProps
+    } = componentProps;
+    const {
+      state: fieldState,
+      name: fieldName,
+      disabled: fieldDisabled,
+      setTouched,
+      setDirty,
+      validityData,
+      setFilled,
+      validationMode,
+      validation
+    } = useFieldRootContext();
+    const {
+      clearErrors,
+      elementRef: formElementRef,
+      submitCountRef
+    } = useFormContext();
+    const disabled = fieldDisabled || disabledProp;
+    const name = fieldName ?? nameProp;
+    const state = {
+      ...fieldState,
+      disabled
+    };
+    const {
+      labelId
+    } = useLabelableContext();
+    const id = useLabelableId({
+      id: idProp
+    });
+    const isControlled = value !== undefined;
+    // The DOM value is always a string, so dirty comparisons must serialize the controlled value.
+    const serializedValue = value == null ? undefined : String(value);
+    const getValueFromInput = useStableCallback(() => validation.inputRef.current?.value);
+    useRegisterFieldControl(validation.inputRef, id, serializedValue, getValueFromInput, !disabled, nameProp);
+    useIsoLayoutEffect(() => {
+      const currentValue = serializedValue ?? validation.inputRef.current?.value;
+      if (currentValue !== undefined) {
+        setFilled(currentValue !== '');
+      }
+    }, [serializedValue, defaultValue, validation.inputRef, setFilled]);
+    useValueChanged(serializedValue, () => {
+      if (serializedValue === undefined) {
+        return;
+      }
+      clearErrors(name);
+      setDirty(serializedValue !== (validityData.initialValue ?? ''));
+      validation.change(serializedValue);
+    });
+    const inputRef = React__namespace.useRef(null);
+    const setFocused = useSetFieldFocused(disabled, inputRef);
+    const enterValidationTimeout = useTimeout();
+    const element = useRenderElement('input', componentProps, {
+      ref: [forwardedRef, inputRef],
+      state,
+      props: [{
+        id,
+        disabled,
+        name,
+        ref: validation.inputRef,
+        'aria-labelledby': labelId,
+        autoFocus,
+        ...(isControlled ? {
+          value
+        } : {
+          defaultValue
+        }),
+        onChange(event) {
+          const inputValue = event.currentTarget.value;
+          const details = createChangeEventDetails(none, event.nativeEvent);
+          onValueChange?.(inputValue, details);
+
+          // Controlled values sync from the `value` prop instead, so that a value the consumer
+          // rejects or rewrites never reaches the field state.
+          if (isControlled) {
+            return;
+          }
+
+          // `validation.change` reads `markedDirtyRef`, so update dirty before validating.
+          setDirty(inputValue !== (validityData.initialValue ?? ''));
+          setFilled(inputValue !== '');
+
+          // Workaround for https://github.com/react/react/issues/9023
+          if (!event.nativeEvent.defaultPrevented && !details.isCanceled) {
+            clearErrors(name);
+            validation.change(inputValue);
+          }
+        },
+        onFocus() {
+          setFocused(true);
+        },
+        onBlur(event) {
+          setTouched(true);
+          setFocused(false);
+          if (validationMode === 'onBlur') {
+            const inputValue = event.currentTarget.value;
+            validation.commit(inputValue);
+            if (isControlled) {
+              // Controlled blur handlers can normalize the value before this microtask runs.
+              // A rewrite back to the initial value is a programmatic reset: the field looks
+              // pristine, so committing it would only surface `valueMissing` noise.
+              queueMicrotask(() => {
+                const nextValue = validation.inputRef.current?.value;
+                if (nextValue !== undefined && nextValue !== inputValue && nextValue !== (validityData.initialValue ?? '')) {
+                  validation.commit(nextValue);
+                }
+              });
+            }
+          }
+        },
+        onKeyDown(event) {
+          if (event.currentTarget.tagName === 'INPUT' && event.key === 'Enter') {
+            setTouched(true);
+            const value = event.currentTarget.value;
+            const form = event.currentTarget.form;
+            if (form && form === formElementRef.current && !event.defaultPrevented) {
+              const input = event.currentTarget;
+              const submitCount = submitCountRef.current;
+
+              // Implicit submission runs after keydown. Fall back unless Form handles it first.
+              enterValidationTimeout.start(0, () => {
+                if (submitCountRef.current === submitCount) {
+                  validation.commit(input.value);
+                }
+              });
+            } else {
+              validation.commit(value);
+            }
+          }
+        }
+      }, elementProps, props => validation.getValidationProps(disabled, props)],
+      stateAttributesMapping: fieldValidityMapping
+    });
+    return element;
+  });
+
+  /**
+   * A native input element that automatically works with [Field](https://base-ui.com/react/components/field).
+   * Renders an `<input>` element.
+   *
+   * Documentation: [Base UI Input](https://base-ui.com/react/components/input)
+   */
+  const Input$1 = /*#__PURE__*/React__namespace.forwardRef(function Input(props, forwardedRef) {
+    return /*#__PURE__*/jsxRuntimeExports.jsx(FieldControl, {
+      ref: forwardedRef,
+      ...props
+    });
+  });
+
+  function Input({ className, type, ...props }) {
+      return (jsxRuntimeExports.jsx(Input$1, { type: type, "data-slot": "input", className: cn("h-8 w-full min-w-0 rounded-lg border border-input bg-transparent px-2.5 py-1 text-base transition-colors outline-none file:inline-flex file:h-6 file:border-0 file:bg-transparent file:text-sm file:font-medium file:text-foreground placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-3 focus-visible:ring-ring/50 disabled:pointer-events-none disabled:cursor-not-allowed disabled:bg-input/50 disabled:opacity-50 aria-invalid:border-destructive aria-invalid:ring-3 aria-invalid:ring-destructive/20 md:text-sm dark:bg-input/30 dark:disabled:bg-input/80 dark:aria-invalid:border-destructive/50 dark:aria-invalid:ring-destructive/40", className), ...props }));
+  }
+
+  /**
+   * @license lucide-react v1.70.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+
+  const toKebabCase = (string) => string?.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+
+  /**
+   * @license lucide-react v1.70.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+
+
+  function toLucideIconData(iconName, iconNode, aliases = []) {
+    if (iconNode == null) {
+      throw new Error("[lucide]: iconNode is required when icon name is used");
+    }
+    return {
+      name: toKebabCase(iconName),
+      size: 24,
+      node: iconNode,
+      ...aliases.length > 0 ? { aliases } : {}
+    };
+  }
+
+  /**
+   * @license lucide-react v1.70.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+
+  const toCamelCase = (string) => {
+    let out = "";
+    let upperNext = false;
+    for (const ch of string) {
+      if (ch === "-" || ch === "_" || ch <= " ") {
+        upperNext = out.length > 0;
+        continue;
+      }
+      if (out.length === 0) {
+        out += ch.toLowerCase();
+      } else {
+        out += upperNext ? ch.toUpperCase() : ch;
+      }
+      upperNext = false;
+    }
+    return out;
+  };
+
+  /**
+   * @license lucide-react v1.70.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+
+
+  const toPascalCase = (string) => {
+    const camelCase = toCamelCase(string);
+    return camelCase.charAt(0).toUpperCase() + camelCase.slice(1);
+  };
+
+  /**
+   * @license lucide-react v1.70.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+
+  const mergeClasses = (...classes) => classes.filter((className, index, array) => {
+    return Boolean(className) && className.trim() !== "" && array.indexOf(className) === index;
+  }).join(" ").trim();
+
+  /**
+   * @license lucide-react v1.70.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+
+  const defaultAttributes = {
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 24,
+    height: 24,
+    viewBox: "0 0 24 24",
+    fill: "none",
+    stroke: "currentColor",
+    "stroke-width": 2,
+    "stroke-linecap": "round",
+    "stroke-linejoin": "round"
+  };
+
+  /**
+   * @license lucide-react v1.70.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+
+
+  function isDefined(value) {
+    return value !== null && value !== void 0;
+  }
+  function buildLucideIconNode(icon, params = {}) {
+    const attributeNames = params.attributeNames ?? {};
+    const getAttributeName = (attributeName) => attributeNames[attributeName] ?? attributeName;
+    const viewBoxWidth = icon.size ?? icon.width ?? defaultAttributes["width"];
+    const viewBoxHeight = icon.size ?? icon.height ?? defaultAttributes["height"];
+    const aliasClassNames = icon.aliases?.filter((alias) => typeof alias === "string" && alias.trim() !== "").map((alias) => `lucide-${alias}`) ?? [];
+    const iconClassNames = [...icon.name ? [`lucide-${icon.name}`] : [], ...aliasClassNames];
+    const classNamesFromClassName = params.className?.split(" ").filter(Boolean) ?? [];
+    const className = params.includeDefaultClasses === false ? mergeClasses(...classNamesFromClassName) : mergeClasses("lucide", ...iconClassNames, ...classNamesFromClassName);
+    const calculatedStrokeWidth = params.absoluteStrokeWidth ? Number(params.strokeWidth ?? defaultAttributes["stroke-width"]) * Number(icon.size ?? icon.width ?? defaultAttributes["width"]) / Number(params.size ?? params.width ?? defaultAttributes["width"]) : params.strokeWidth ?? defaultAttributes["stroke-width"];
+    const attributes = {
+      ...Object.entries(defaultAttributes).reduce((attrs, [attrName, value]) => {
+        attrs[getAttributeName(attrName)] = value;
+        return attrs;
+      }, {}),
+      ..."color" in params && params.color && {
+        [getAttributeName("stroke")]: params.color
+      },
+      ..."size" in params && isDefined(params.size) && {
+        [getAttributeName("width")]: params.size,
+        [getAttributeName("height")]: params.size
+      },
+      ..."width" in params && isDefined(params.width) && {
+        [getAttributeName("width")]: params.width
+      },
+      ..."height" in params && isDefined(params.height) && {
+        [getAttributeName("height")]: params.height
+      },
+      [getAttributeName("stroke-width")]: calculatedStrokeWidth,
+      ...className && {
+        [getAttributeName("class")]: className
+      },
+      [getAttributeName("viewBox")]: `0 0 ${viewBoxWidth} ${viewBoxHeight}`,
+      ...params.hasA11yProp === false ? {
+        [getAttributeName("aria-hidden")]: "true"
+      } : {},
+      ..."attributes" in params && params.attributes
+    };
+    return [
+      "svg",
+      attributes,
+      icon.node.map((child) => {
+        const [name, attrs, children] = child;
+        const nextAttrs = params.nonScalingStroke ? { [getAttributeName("vector-effect")]: "non-scaling-stroke", ...attrs } : attrs;
+        return children ? [name, nextAttrs, children] : [name, nextAttrs];
+      })
+    ];
+  }
+
+  /**
+   * @license lucide-react v1.70.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+
+
+  function buildLucideIconForReact(icon, params = {}) {
+    return buildLucideIconNode(icon, {
+      ...params,
+      attributeNames: {
+        ...params.attributeNames,
+        class: "className",
+        "stroke-width": "strokeWidth",
+        "stroke-linecap": "strokeLinecap",
+        "stroke-linejoin": "strokeLinejoin",
+        "vector-effect": "vectorEffect"
+      }
+    });
+  }
+
+  /**
+   * @license lucide-react v1.70.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+
+  const hasA11yProp = (props) => {
+    for (const prop in props) {
+      if (prop.startsWith("aria-") || prop === "role" || prop === "title") {
+        return true;
+      }
+    }
+    return false;
+  };
+
+  const LucideContext = React.createContext({});
+  const useLucideContext = () => React.useContext(LucideContext);
+
+  const Icon = React.forwardRef(
+    ({
+      color,
+      size,
+      width,
+      height,
+      strokeWidth,
+      absoluteStrokeWidth,
+      nonScalingStroke,
+      className = "",
+      children,
+      iconNode = [],
+      icon = {
+        node: iconNode,
+        aliases: [],
+        size: 24
+      },
+      ...rest
+    }, ref) => {
+      const {
+        size: contextSize = 24,
+        strokeWidth: contextStrokeWidth = 2,
+        absoluteStrokeWidth: contextAbsoluteStrokeWidth = false,
+        nonScalingStroke: contextNonScalingStroke = false,
+        color: contextColor = "currentColor",
+        className: contextClass = ""
+      } = useLucideContext() ?? {};
+      const hasAccessibleProp = Boolean(children) || hasA11yProp(rest);
+      const [name, svgAttributes, builtIconNode = []] = buildLucideIconForReact(icon, {
+        color: color ?? contextColor,
+        width: width ?? size ?? contextSize,
+        height: height ?? size ?? contextSize,
+        strokeWidth: strokeWidth ?? contextStrokeWidth,
+        absoluteStrokeWidth: absoluteStrokeWidth ?? contextAbsoluteStrokeWidth,
+        nonScalingStroke: nonScalingStroke ?? contextNonScalingStroke,
+        className: mergeClasses(contextClass, className),
+        hasA11yProp: hasAccessibleProp,
+        attributes: rest
+      });
+      return React.createElement(
+        name,
+        {
+          ref,
+          ...svgAttributes
+        },
+        [
+          ...builtIconNode.map(([tag, attrs]) => React.createElement(tag, attrs)),
+          ...Array.isArray(children) ? children : [children]
+        ]
+      );
+    }
+  );
+
+  /**
+   * @license lucide-react v1.70.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+
+
+  function createLucideIcon(iconDataOrName, iconNode = [], aliases = []) {
+    const iconData = typeof iconDataOrName === "string" ? toLucideIconData(iconDataOrName, iconNode, aliases) : iconDataOrName;
+    const Component = React.forwardRef(
+      ({ className, ...props }, ref) => React.createElement(Icon, {
+        ref,
+        icon: iconData,
+        className,
+        ...props
+      })
+    );
+    if (iconData.name) {
+      Component.displayName = toPascalCase(iconData.name);
+    }
+    return Component;
+  }
+
+  /**
+   * @license lucide-react v1.70.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+
+
+  const __iconData$1 = {
+    name: "moon",
+    size: 24,
+    node: [
+      [
+        "path",
+        {
+          d: "M20.985 12.486a9 9 0 1 1-9.473-9.472c.405-.022.617.46.402.803a6 6 0 0 0 8.268 8.268c.344-.215.825-.004.803.401",
+          key: "kfwtm"
+        }
+      ]
+    ]
+  };
+  __iconData$1.node;
+  const Moon = createLucideIcon(__iconData$1);
+
+  /**
+   * @license lucide-react v1.70.0 - ISC
+   *
+   * This source code is licensed under the ISC license.
+   * See the LICENSE file in the root directory of this source tree.
+   */
+
+
+  const __iconData = {
+    name: "sun",
+    size: 24,
+    node: [
+      ["circle", { cx: "12", cy: "12", r: "4", key: "4exip2" }],
+      ["path", { d: "M12 2v2", key: "tus03m" }],
+      ["path", { d: "M12 20v2", key: "1lh1kg" }],
+      ["path", { d: "m4.93 4.93 1.41 1.41", key: "149t6j" }],
+      ["path", { d: "m17.66 17.66 1.41 1.41", key: "ptbguv" }],
+      ["path", { d: "M2 12h2", key: "1t8f8n" }],
+      ["path", { d: "M20 12h2", key: "1q8mjw" }],
+      ["path", { d: "m6.34 17.66-1.41 1.41", key: "1m8zz5" }],
+      ["path", { d: "m19.07 4.93-1.41 1.41", key: "1shlcs" }]
+    ]
+  };
+  __iconData.node;
+  const Sun = createLucideIcon(__iconData);
+
+  // 水合完成与否由 React 的服务端快照机制区分，无需 effect 中同步设置状态。
+  const subscribe = () => () => { };
+  const getSnapshot = () => true;
+  const getServerSnapshot = () => false;
+  /** 服务端及客户端水合首帧返回 false，之后返回 true；纯客户端渲染直接返回 true。 */
+  function useHydrated() {
+      return React.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+  }
+
+  const COLOR_SCHEME_QUERY = '(prefers-color-scheme: dark)';
+  const ThemeProviderContext = React.createContext(undefined);
+  // 校验存储值，同时将类型收窄为合法的主题选项。
+  function isTheme(value) {
+      return value === 'dark' || value === 'light' || value === 'system';
+  }
+  // 优先读取已保存的主题；值无效或存储不可用时使用默认主题。
+  function readTheme(storageKey, fallback) {
+      try {
+          const value = localStorage.getItem(storageKey);
+          return isTheme(value) ? value : fallback;
+      }
+      catch {
+          // 存储不可用时回退到默认主题，不影响组件初始化。
+          return fallback;
+      }
+  }
+  // 持久化用户选择，存储失败时仍允许更新页面主题。
+  function persistTheme(storageKey, theme) {
+      try {
+          localStorage.setItem(storageKey, theme);
+      }
+      catch {
+          // 忽略存储异常，主题仍可在当前页面内切换。
+      }
+  }
+  // 将用户选择解析为实际配色；system 每次读取当前系统偏好。
+  function resolveTheme(theme) {
+      if (theme !== 'system') {
+          return theme;
+      }
+      return window.matchMedia(COLOR_SCHEME_QUERY).matches ? 'dark' : 'light';
+  }
+  // 更新根元素的主题类名，并返回清理临时样式及动画帧的函数。
+  function applyTheme(theme, disableTransitionOnChange) {
+      const root = document.documentElement;
+      const resolvedTheme = resolveTheme(theme);
+      // 主题已生效且没有冲突类名时，跳过重复的 DOM 操作。
+      if (root.classList.contains(resolvedTheme) && !root.classList.contains(resolvedTheme === 'dark' ? 'light' : 'dark')) {
+          return () => { };
+      }
+      const style = disableTransitionOnChange ? document.createElement('style') : null;
+      if (style) {
+          style.textContent = '*,*::before,*::after{transition:none!important}';
+          document.head.appendChild(style);
+          // 强制浏览器计算样式，确保禁用过渡的规则先于主题切换生效。
+          window.getComputedStyle(root).getPropertyValue('transition-property');
+      }
+      root.classList.remove('light', 'dark');
+      root.classList.add(resolvedTheme);
+      if (!style) {
+          return () => { };
+      }
+      // 在禁用过渡期间计算新主题样式，再通过两次动画帧延迟移除规则。
+      window.getComputedStyle(root).getPropertyValue('color');
+      let frame = requestAnimationFrame(() => {
+          frame = requestAnimationFrame(() => style.remove());
+      });
+      // 重新应用主题或卸载时，取消待执行的帧并移除临时样式。
+      return () => {
+          cancelAnimationFrame(frame);
+          style.remove();
+      };
+  }
+  // 判断事件是否来自可编辑区域，避免主题快捷键干扰输入。
+  function isEditableTarget(target) {
+      if (!(target instanceof HTMLElement)) {
+          return false;
+      }
+      if (target.isContentEditable) {
+          return true;
+      }
+      return target.closest('input, textarea, select') !== null;
+  }
+  // 统一管理主题状态、页面样式及系统和跨标签页同步。
+  function ThemeProvider({ children, defaultTheme = 'system', storageKey = 'bad-ui:theme', disableTransitionOnChange = true, keyboardShortcut, }) {
+      const hydrated = useHydrated();
+      const [storedTheme, setThemeState] = React.useState(() => readTheme(storageKey, defaultTheme));
+      // 水合首帧与服务端一致，完成后才使用浏览器保存的主题。
+      const theme = hydrated ? storedTheme : defaultTheme;
+      // 所有主动切换共用此入口，统一更新存储和 React 状态。
+      const setTheme = React.useCallback((nextTheme) => {
+          persistTheme(storageKey, nextTheme);
+          setThemeState(nextTheme);
+      }, [storageKey]);
+      // 按需解析系统配色，按钮和快捷键共用同一切换逻辑。
+      const toggleTheme = React.useCallback(() => {
+          setTheme(resolveTheme(theme) === 'dark' ? 'light' : 'dark');
+      }, [theme, setTheme]);
+      // 水合完成后应用主题；服务端与水合首帧不访问系统配色或修改根元素。
+      React.useLayoutEffect(() => {
+          if (!hydrated)
+              return;
+          let cleanup = applyTheme(theme, disableTransitionOnChange);
+          const mediaQuery = window.matchMedia(COLOR_SCHEME_QUERY);
+          const handleChange = () => {
+              cleanup();
+              cleanup = applyTheme(theme, disableTransitionOnChange);
+          };
+          // 仅跟随系统时订阅配色变化；显式选择深浅色后不再跟随。
+          if (theme === 'system') {
+              mediaQuery.addEventListener('change', handleChange);
+          }
+          return () => {
+              mediaQuery.removeEventListener('change', handleChange);
+              cleanup();
+          };
+      }, [theme, disableTransitionOnChange, hydrated]);
+      React.useEffect(() => {
+          if (!hydrated || !keyboardShortcut)
+              return;
+          const shortcutKey = keyboardShortcut.toLowerCase();
+          // 忽略已处理事件、输入法组合和长按重复。
+          const handleKeyDown = (event) => {
+              if (event.defaultPrevented || event.isComposing || event.repeat) {
+                  return;
+              }
+              if (event.metaKey || event.ctrlKey || event.altKey) {
+                  return;
+              }
+              if (isEditableTarget(event.target)) {
+                  return;
+              }
+              if (event.key.toLowerCase() !== shortcutKey) {
+                  return;
+              }
+              toggleTheme();
+          };
+          window.addEventListener('keydown', handleKeyDown);
+          return () => {
+              window.removeEventListener('keydown', handleKeyDown);
+          };
+      }, [toggleTheme, hydrated, keyboardShortcut]);
+      React.useEffect(() => {
+          // storage 事件用于接收同源其他标签页的主题变更。
+          const handleStorageChange = (event) => {
+              if (event.storageArea !== localStorage) {
+                  return;
+              }
+              // clear() 触发的事件 key 为 null，也需要回退到默认主题。
+              if (event.key !== null && event.key !== storageKey) {
+                  return;
+              }
+              if (isTheme(event.newValue)) {
+                  setThemeState(event.newValue);
+                  return;
+              }
+              // 存储项被移除、清空或写入无效值时，恢复默认主题。
+              setThemeState(defaultTheme);
+          };
+          window.addEventListener('storage', handleStorageChange);
+          return () => {
+              window.removeEventListener('storage', handleStorageChange);
+          };
+      }, [defaultTheme, storageKey]);
+      // 保持上下文值的引用稳定，避免父组件重渲染引起无关更新。
+      const value = React.useMemo(() => ({
+          theme,
+          setTheme,
+          toggleTheme,
+      }), [theme, setTheme, toggleTheme]);
+      return jsxRuntimeExports.jsx(ThemeProviderContext.Provider, { value: value, children: children });
+  }
+  // 获取主题上下文，并在缺少 Provider 时给出明确错误。
+  const useTheme = () => {
+      const context = React.useContext(ThemeProviderContext);
+      if (context === undefined) {
+          throw new Error('useTheme must be used within a ThemeProvider');
+      }
+      return context;
+  };
+
+  function ThemeToggle({ darkLabel = '切换到深色主题', lightLabel = '切换到浅色主题', variant = 'outline', size = 'icon', title = '切换主题', onClick, ...props }) {
+      const { toggleTheme } = useTheme();
+      return (jsxRuntimeExports.jsxs(Button, { type: "button", variant: variant, size: size, title: title, ...props, onClick: (event) => {
+              // 先执行使用方回调，允许通过 preventDefault() 取消主题切换。
+              onClick?.(event);
+              if (!event.defaultPrevented)
+                  toggleTheme();
+          }, children: [jsxRuntimeExports.jsx(Moon, { "data-icon": "inline-start", "aria-hidden": "true", className: "animate-in duration-200 ease-out zoom-in-75 fade-in spin-in-90 motion-reduce:animate-none dark:hidden" }), jsxRuntimeExports.jsx(Sun, { "data-icon": "inline-start", "aria-hidden": "true", className: "hidden animate-in duration-200 ease-out zoom-in-75 fade-in spin-in-90 motion-reduce:animate-none dark:block" }), jsxRuntimeExports.jsx("span", { className: "sr-only dark:hidden", children: darkLabel }), jsxRuntimeExports.jsx("span", { className: "sr-only hidden dark:block", children: lightLabel })] }));
+  }
+
+  // color 用于选项色块预览：基础色取浅色模式的 muted-foreground，主题色取 primary。
+  const BASE_COLORS = [
+      { value: 'neutral', label: 'Neutral', color: 'oklch(0.556 0 0)' },
+      { value: 'mist', label: 'Mist', color: 'oklch(0.56 0.021 213.5)' },
+      { value: 'zinc', label: 'Zinc', color: 'oklch(0.552 0.016 285.938)' },
+  ];
+  // value 对应 CSS 的 data-theme 属性，label 用于展示，color 是固定的预览色。
+  const COLOR_THEMES = [
+      { value: 'neutral', label: 'Neutral', color: 'oklch(0.205 0 0)' },
+      { value: 'blue', label: 'Blue', color: 'oklch(0.488 0.243 264.376)' },
+      { value: 'green', label: 'Green', color: 'oklch(0.527 0.154 150.069)' },
+      { value: 'orange', label: 'Orange', color: 'oklch(0.553 0.195 38.402)' },
+      { value: 'pink', label: 'Pink', color: 'oklch(0.525 0.223 3.958)' },
+      { value: 'purple', label: 'Purple', color: 'oklch(0.496 0.265 301.924)' },
+      { value: 'red', label: 'Red', color: 'oklch(0.505 0.213 27.518)' },
+      { value: 'rose', label: 'Rose', color: 'oklch(0.514 0.222 16.935)' },
+      { value: 'sky', label: 'Sky', color: 'oklch(0.5 0.134 242.749)' },
+      { value: 'yellow', label: 'Yellow', color: 'oklch(0.852 0.199 91.936)' },
+  ];
+  // 圆角预设的 value 单位为 rem，可直接传给 setRadius，也可用于 borderRadius 预览。
+  const RADIUS_OPTIONS = [
+      { value: 0, label: '0' },
+      { value: 0.25, label: '0.25' },
+      { value: 0.5, label: '0.5' },
+      { value: 0.625, label: 'Default' },
+      { value: 0.75, label: '0.75' },
+      { value: 1, label: '1' },
+  ];
+  const DEFAULT_PREFERENCE = {
+      baseColor: 'neutral',
+      theme: 'neutral',
+      radius: 0.625,
+  };
+
+  const PreferenceContext = React.createContext(undefined);
+  // 校验选项标识，并将 unknown 收窄为对应的字符串联合类型。
+  function isOption(options, value) {
+      return options.some((option) => option.value === value);
+  }
+  // 存储内容不可信：逐项校验，单个字段无效时不影响其他有效偏好。
+  function normalizePreference(value, fallback) {
+      const candidate = typeof value === 'object' && value !== null ? value : {};
+      return {
+          baseColor: isOption(BASE_COLORS, candidate.baseColor) ? candidate.baseColor : fallback.baseColor,
+          theme: isOption(COLOR_THEMES, candidate.theme) ? candidate.theme : fallback.theme,
+          // 预设用于展示，不限制自定义圆角；只接受有限的非负数。
+          radius: typeof candidate.radius === 'number' && Number.isFinite(candidate.radius) && candidate.radius >= 0
+              ? candidate.radius
+              : fallback.radius,
+      };
+  }
+  // 解析并校验存储字符串；没有记录或 JSON 损坏时回退到默认值。
+  function parsePreference(value, fallback) {
+      try {
+          return normalizePreference(value === null ? null : JSON.parse(value), fallback);
+      }
+      catch {
+          return fallback;
+      }
+  }
+  // 将存储访问与 JSON 解析分开处理，兼容浏览器禁止存储的情况。
+  function readPreference(storageKey, fallback) {
+      try {
+          return parsePreference(localStorage.getItem(storageKey), fallback);
+      }
+      catch {
+          // 存储不可用时，偏好仍可在当前页面内使用。
+          return fallback;
+      }
+  }
+  // 比较字段值，避免相同偏好触发重复渲染。
+  function isSamePreference(current, next) {
+      return current.baseColor === next.baseColor && current.theme === next.theme && current.radius === next.radius;
+  }
+  // 管理基础色、主题配色和圆角；深浅模式继续由 ThemeProvider 管理。
+  function PreferenceProvider({ children, defaultPreference, storageKey = 'bad-ui:preference', }) {
+      // 先补齐并校验调用方传入的默认值，再作为存储读取和重置时的回退值。
+      const { baseColor, theme, radius } = normalizePreference(defaultPreference, DEFAULT_PREFERENCE);
+      const defaults = React.useMemo(() => ({ baseColor, theme, radius }), [baseColor, theme, radius]);
+      const hydrated = useHydrated();
+      const [storedPreference, setPreference] = React.useState(() => readPreference(storageKey, defaults));
+      // 保存最新偏好，保证同一批次连续修改不同字段时保留先前修改。
+      const preferenceRef = React.useRef(storedPreference);
+      // 服务端及客户端水合首帧使用相同默认值，水合后才向子组件公开本地偏好。
+      const preference = hydrated ? storedPreference : defaults;
+      // 主动修改时才写入存储；跨标签页同步仅更新内存，避免删除后又写回默认值。
+      const updatePreference = React.useCallback((patch) => {
+          const current = preferenceRef.current;
+          const next = normalizePreference({ ...current, ...patch }, current);
+          if (isSamePreference(current, next))
+              return;
+          preferenceRef.current = next;
+          setPreference(next);
+          try {
+              localStorage.setItem(storageKey, JSON.stringify(next));
+          }
+          catch {
+              // 写入失败不阻断页面偏好更新。
+          }
+      }, [storageKey]);
+      const setBaseColor = React.useCallback((nextBaseColor) => {
+          updatePreference({ baseColor: nextBaseColor });
+      }, [updatePreference]);
+      // 此处 theme 是配色方案（如 blue），并非 light / dark / system。
+      const setTheme = React.useCallback((nextTheme) => {
+          updatePreference({ theme: nextTheme });
+      }, [updatePreference]);
+      // 圆角以 rem 保存，转换为 CSS 长度的工作由下方 effect 统一完成。
+      const setRadius = React.useCallback((nextRadius) => {
+          updatePreference({ radius: nextRadius });
+      }, [updatePreference]);
+      // 配色通过独立属性组合；圆角以内联变量覆盖主题默认值，不改动深浅模式类名。
+      React.useLayoutEffect(() => {
+          if (!hydrated)
+              return;
+          const root = document.documentElement;
+          // 在浏览器绘制前更新属性，分别匹配 base-color 和 themes 中的选择器。
+          root.dataset.baseColor = preference.baseColor;
+          root.dataset.theme = preference.theme;
+          root.style.setProperty('--radius', `${preference.radius}rem`);
+      }, [preference, hydrated]);
+      React.useEffect(() => {
+          // 接收其他标签页的变更；删除或清空存储时恢复默认偏好。
+          function handleStorageChange(event) {
+              // 只处理 localStorage 中当前键的变化；clear() 的事件 key 为 null。
+              if (event.storageArea !== localStorage || (event.key !== null && event.key !== storageKey)) {
+                  return;
+              }
+              const next = parsePreference(event.newValue, defaults);
+              if (isSamePreference(preferenceRef.current, next))
+                  return;
+              preferenceRef.current = next;
+              setPreference(next);
+          }
+          window.addEventListener('storage', handleStorageChange);
+          // 卸载或依赖变化时注销监听，避免重复订阅。
+          return () => window.removeEventListener('storage', handleStorageChange);
+      }, [defaults, storageKey]);
+      // 保持 Context 值的引用稳定，避免父组件重渲染引起无关的订阅更新。
+      const value = React.useMemo(() => ({ ...preference, setBaseColor, setTheme, setRadius }), [preference, setBaseColor, setTheme, setRadius]);
+      return jsxRuntimeExports.jsx(PreferenceContext.Provider, { value: value, children: children });
+  }
+  // 统一读取偏好上下文，在缺少 Provider 时给出明确的使用错误。
+  function usePreference() {
+      const context = React.useContext(PreferenceContext);
+      if (context === undefined) {
+          throw new Error('usePreference must be used within a PreferenceProvider');
+      }
+      return context;
+  }
+
+  exports.BASE_COLORS = BASE_COLORS;
+  exports.Button = Button;
+  exports.COLOR_THEMES = COLOR_THEMES;
+  exports.DEFAULT_PREFERENCE = DEFAULT_PREFERENCE;
+  exports.Input = Input;
+  exports.PreferenceProvider = PreferenceProvider;
+  exports.RADIUS_OPTIONS = RADIUS_OPTIONS;
+  exports.ThemeProvider = ThemeProvider;
+  exports.ThemeToggle = ThemeToggle;
+  exports.buttonVariants = buttonVariants;
+  exports.cn = cn;
+  exports.useHydrated = useHydrated;
+  exports.usePreference = usePreference;
+  exports.useTheme = useTheme;
+
+}));