supadeck 0.0.6 → 0.0.7

package/dist/index.js

@@ -1,11 +1,2808 @@
-export { createDefaultComponents, mergeComponents } from './runtime/default-components.js';
-export { useCurrentSlide } from './runtime/hooks/slides.js';
-export { SlideFrame } from './runtime/layout/SlideFrame.js';
-export { DeckSlide } from './runtime/layout/DeckSlide.js';
-export { DeckChrome } from './runtime/primitives/DeckChrome.js';
-export { DeckNavigation } from './runtime/primitives/DeckNavigation.js';
-export { DeckProgress } from './runtime/primitives/DeckProgress.js';
-export { DeckTitle } from './runtime/primitives/DeckTitle.js';
-export { DefaultDeck } from './runtime/themes/base/DefaultDeck.js';
-export { clamp, getHashIndex, parseAspectRatio } from './runtime/utils/use-current-slide.js';
-export { Callout, Columns, Disclosure, Frame } from './runtime/components/index.js';
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/runtime/components/Callout.tsx
+import { jsx } from "react/jsx-runtime";
+function toneClasses(tone) {
+  if (tone === "accent") {
+    return "border-[color:var(--color-accent)] bg-[color:var(--color-accent)]/10";
+  }
+  if (tone === "danger") {
+    return "border-red-500/50 bg-red-500/10";
+  }
+  return "border-[color:var(--color-border)] bg-white/60 dark:bg-white/5";
+}
+function Callout({ children, tone = "default" }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: `rounded-[var(--radius-lg)] border px-6 py-5 text-xl shadow-lg shadow-black/5 backdrop-blur ${toneClasses(
+        tone
+      )}`,
+      children
+    }
+  );
+}
+
+// src/runtime/components/Columns.tsx
+import { jsxs } from "react/jsx-runtime";
+function Columns({ left, right }) {
+  return /* @__PURE__ */ jsxs("div", { className: "grid gap-6 md:grid-cols-2", children: [
+    left,
+    right
+  ] });
+}
+
+// node_modules/@base-ui/react/esm/accordion/index.parts.js
+var index_parts_exports = {};
+__export(index_parts_exports, {
+  Header: () => AccordionHeader,
+  Item: () => AccordionItem,
+  Panel: () => AccordionPanel,
+  Root: () => AccordionRoot,
+  Trigger: () => AccordionTrigger
+});
+
+// node_modules/@base-ui/react/esm/accordion/root/AccordionRoot.js
+import * as React12 from "react";
+
+// node_modules/@base-ui/utils/esm/useControlled.js
+import * as React from "react";
+function useControlled({
+  controlled,
+  default: defaultProp,
+  name,
+  state = "value"
+}) {
+  const {
+    current: isControlled
+  } = React.useRef(controlled !== void 0);
+  const [valueState, setValue] = React.useState(defaultProp);
+  const value = isControlled ? controlled : valueState;
+  if (true) {
+    React.useEffect(() => {
+      if (isControlled !== (controlled !== void 0)) {
+        console.error([`Base UI: A component is changing the ${isControlled ? "" : "un"}controlled ${state} state of ${name} to be ${isControlled ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${name} element for the lifetime of the component.`, "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join("\n"));
+      }
+    }, [state, name, controlled]);
+    const {
+      current: defaultValue
+    } = React.useRef(defaultProp);
+    React.useEffect(() => {
+      if (!isControlled && JSON.stringify(defaultValue) !== JSON.stringify(defaultProp)) {
+        console.error([`Base UI: A component is changing the default ${state} state of an uncontrolled ${name} after being initialized. To suppress this warning opt to use a controlled ${name}.`].join("\n"));
+      }
+    }, [JSON.stringify(defaultProp)]);
+  }
+  const setValueIfUncontrolled = React.useCallback((newValue) => {
+    if (!isControlled) {
+      setValue(newValue);
+    }
+  }, []);
+  return [value, setValueIfUncontrolled];
+}
+
+// node_modules/@base-ui/utils/esm/useStableCallback.js
+import * as React3 from "react";
+
+// node_modules/@base-ui/utils/esm/useRefWithInit.js
+import * as React2 from "react";
+var UNINITIALIZED = {};
+function useRefWithInit(init, initArg) {
+  const ref = React2.useRef(UNINITIALIZED);
+  if (ref.current === UNINITIALIZED) {
+    ref.current = init(initArg);
+  }
+  return ref;
+}
+
+// node_modules/@base-ui/utils/esm/useStableCallback.js
+var useInsertionEffect = React3[`useInsertionEffect${Math.random().toFixed(1)}`.slice(0, -3)];
+var useSafeInsertionEffect = (
+  // React 17 doesn't have useInsertionEffect.
+  useInsertionEffect && // Preact replaces useInsertionEffect with useLayoutEffect and fires too late.
+  useInsertionEffect !== React3.useLayoutEffect ? useInsertionEffect : (fn) => fn()
+);
+function useStableCallback(callback) {
+  const stable = useRefWithInit(createStableCallback).current;
+  stable.next = callback;
+  useSafeInsertionEffect(stable.effect);
+  return stable.trampoline;
+}
+function createStableCallback() {
+  const stable = {
+    next: void 0,
+    callback: assertNotCalled,
+    trampoline: (...args) => stable.callback?.(...args),
+    effect: () => {
+      stable.callback = stable.next;
+    }
+  };
+  return stable;
+}
+function assertNotCalled() {
+  if (true) {
+    throw (
+      /* minify-error-disabled */
+      new Error("Base UI: Cannot call an event handler while rendering.")
+    );
+  }
+}
+
+// node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js
+import * as React4 from "react";
+var noop = () => {
+};
+var useIsoLayoutEffect = typeof document !== "undefined" ? React4.useLayoutEffect : noop;
+
+// node_modules/@base-ui/utils/esm/warn.js
+var set;
+if (true) {
+  set = /* @__PURE__ */ new Set();
+}
+function warn(...messages) {
+  if (true) {
+    const messageKey = messages.join(" ");
+    if (!set.has(messageKey)) {
+      set.add(messageKey);
+      console.warn(`Base UI: ${messageKey}`);
+    }
+  }
+}
+
+// node_modules/@base-ui/react/esm/composite/list/CompositeList.js
+import * as React6 from "react";
+
+// node_modules/@base-ui/react/esm/composite/list/CompositeListContext.js
+import * as React5 from "react";
+var CompositeListContext = /* @__PURE__ */ React5.createContext({
+  register: () => {
+  },
+  unregister: () => {
+  },
+  subscribeMapChange: () => {
+    return () => {
+    };
+  },
+  elementsRef: {
+    current: []
+  },
+  nextIndexRef: {
+    current: 0
+  }
+});
+if (true) CompositeListContext.displayName = "CompositeListContext";
+function useCompositeListContext() {
+  return React5.useContext(CompositeListContext);
+}
+
+// node_modules/@base-ui/react/esm/composite/list/CompositeList.js
+import { jsx as _jsx } from "react/jsx-runtime";
+function CompositeList(props) {
+  const {
+    children,
+    elementsRef,
+    labelsRef,
+    onMapChange: onMapChangeProp
+  } = props;
+  const onMapChange = useStableCallback(onMapChangeProp);
+  const nextIndexRef = React6.useRef(0);
+  const listeners = useRefWithInit(createListeners).current;
+  const map = useRefWithInit(createMap).current;
+  const [mapTick, setMapTick] = React6.useState(0);
+  const lastTickRef = React6.useRef(mapTick);
+  const register = useStableCallback((node, metadata) => {
+    map.set(node, metadata ?? null);
+    lastTickRef.current += 1;
+    setMapTick(lastTickRef.current);
+  });
+  const unregister = useStableCallback((node) => {
+    map.delete(node);
+    lastTickRef.current += 1;
+    setMapTick(lastTickRef.current);
+  });
+  const sortedMap = React6.useMemo(() => {
+    disableEslintWarning(mapTick);
+    const newMap = /* @__PURE__ */ new Map();
+    const sortedNodes = Array.from(map.keys()).filter((node) => node.isConnected).sort(sortByDocumentPosition);
+    sortedNodes.forEach((node, index) => {
+      const metadata = map.get(node) ?? {};
+      newMap.set(node, {
+        ...metadata,
+        index
+      });
+    });
+    return newMap;
+  }, [map, mapTick]);
+  useIsoLayoutEffect(() => {
+    if (typeof MutationObserver !== "function" || sortedMap.size === 0) {
+      return void 0;
+    }
+    const mutationObserver = new MutationObserver((entries) => {
+      const diff = /* @__PURE__ */ new Set();
+      const updateDiff = (node) => diff.has(node) ? diff.delete(node) : diff.add(node);
+      entries.forEach((entry) => {
+        entry.removedNodes.forEach(updateDiff);
+        entry.addedNodes.forEach(updateDiff);
+      });
+      if (diff.size === 0) {
+        lastTickRef.current += 1;
+        setMapTick(lastTickRef.current);
+      }
+    });
+    sortedMap.forEach((_, node) => {
+      if (node.parentElement) {
+        mutationObserver.observe(node.parentElement, {
+          childList: true
+        });
+      }
+    });
+    return () => {
+      mutationObserver.disconnect();
+    };
+  }, [sortedMap]);
+  useIsoLayoutEffect(() => {
+    const shouldUpdateLengths = lastTickRef.current === mapTick;
+    if (shouldUpdateLengths) {
+      if (elementsRef.current.length !== sortedMap.size) {
+        elementsRef.current.length = sortedMap.size;
+      }
+      if (labelsRef && labelsRef.current.length !== sortedMap.size) {
+        labelsRef.current.length = sortedMap.size;
+      }
+      nextIndexRef.current = sortedMap.size;
+    }
+    onMapChange(sortedMap);
+  }, [onMapChange, sortedMap, elementsRef, labelsRef, mapTick]);
+  useIsoLayoutEffect(() => {
+    return () => {
+      elementsRef.current = [];
+    };
+  }, [elementsRef]);
+  useIsoLayoutEffect(() => {
+    return () => {
+      if (labelsRef) {
+        labelsRef.current = [];
+      }
+    };
+  }, [labelsRef]);
+  const subscribeMapChange = useStableCallback((fn) => {
+    listeners.add(fn);
+    return () => {
+      listeners.delete(fn);
+    };
+  });
+  useIsoLayoutEffect(() => {
+    listeners.forEach((l) => l(sortedMap));
+  }, [listeners, sortedMap]);
+  const contextValue = React6.useMemo(() => ({
+    register,
+    unregister,
+    subscribeMapChange,
+    elementsRef,
+    labelsRef,
+    nextIndexRef
+  }), [register, unregister, subscribeMapChange, elementsRef, labelsRef, nextIndexRef]);
+  return /* @__PURE__ */ _jsx(CompositeListContext.Provider, {
+    value: contextValue,
+    children
+  });
+}
+function createMap() {
+  return /* @__PURE__ */ new Map();
+}
+function createListeners() {
+  return /* @__PURE__ */ new Set();
+}
+function sortByDocumentPosition(a, b) {
+  const position = a.compareDocumentPosition(b);
+  if (position & Node.DOCUMENT_POSITION_FOLLOWING || position & Node.DOCUMENT_POSITION_CONTAINED_BY) {
+    return -1;
+  }
+  if (position & Node.DOCUMENT_POSITION_PRECEDING || position & Node.DOCUMENT_POSITION_CONTAINS) {
+    return 1;
+  }
+  return 0;
+}
+function disableEslintWarning(_) {
+}
+
+// node_modules/@base-ui/react/esm/direction-provider/DirectionContext.js
+import * as React7 from "react";
+var DirectionContext = /* @__PURE__ */ React7.createContext(void 0);
+if (true) DirectionContext.displayName = "DirectionContext";
+function useDirection() {
+  const context = React7.useContext(DirectionContext);
+  return context?.direction ?? "ltr";
+}
+
+// node_modules/@base-ui/react/esm/accordion/root/AccordionRootContext.js
+import * as React8 from "react";
+var AccordionRootContext = /* @__PURE__ */ React8.createContext(void 0);
+if (true) AccordionRootContext.displayName = "AccordionRootContext";
+function useAccordionRootContext() {
+  const context = React8.useContext(AccordionRootContext);
+  if (context === void 0) {
+    throw new Error(true ? "Base UI: AccordionRootContext is missing. Accordion parts must be placed within <Accordion.Root>." : formatErrorMessage_default(10));
+  }
+  return context;
+}
+
+// node_modules/@base-ui/react/esm/utils/useRenderElement.js
+import * as React11 from "react";
+
+// node_modules/@base-ui/utils/esm/useMergedRefs.js
+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;
+}
+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) {
+  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;
+          }
+          default:
+        }
+      }
+      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 {
+                ref(null);
+              }
+              break;
+            }
+            case "object": {
+              ref.current = null;
+              break;
+            }
+            default:
+          }
+        }
+      };
+    }
+  };
+}
+
+// node_modules/@base-ui/utils/esm/getReactElementRef.js
+import * as React10 from "react";
+
+// node_modules/@base-ui/utils/esm/reactVersion.js
+import * as React9 from "react";
+var majorVersion = parseInt(React9.version, 10);
+function isReactVersionAtLeast(reactVersionToCheck) {
+  return majorVersion >= reactVersionToCheck;
+}
+
+// node_modules/@base-ui/utils/esm/getReactElementRef.js
+function getReactElementRef(element) {
+  if (!/* @__PURE__ */ React10.isValidElement(element)) {
+    return null;
+  }
+  const reactElement = element;
+  const propsWithRef = reactElement.props;
+  return (isReactVersionAtLeast(19) ? propsWithRef?.ref : reactElement.ref) ?? null;
+}
+
+// node_modules/@base-ui/utils/esm/mergeObjects.js
+function mergeObjects(a, b) {
+  if (a && !b) {
+    return a;
+  }
+  if (!a && b) {
+    return b;
+  }
+  if (a || b) {
+    return {
+      ...a,
+      ...b
+    };
+  }
+  return void 0;
+}
+
+// node_modules/@base-ui/react/esm/utils/getStateAttributesProps.js
+function getStateAttributesProps(state, customMapping) {
+  const props = {};
+  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;
+}
+
+// node_modules/@base-ui/react/esm/utils/resolveClassName.js
+function resolveClassName(className, state) {
+  return typeof className === "function" ? className(state) : className;
+}
+
+// node_modules/@base-ui/react/esm/utils/resolveStyle.js
+function resolveStyle(style, state) {
+  return typeof style === "function" ? style(state) : style;
+}
+
+// node_modules/@base-ui/react/esm/merge-props/mergeProps.js
+var EMPTY_PROPS = {};
+function mergeProps(a, b, c, d, e) {
+  let merged = {
+    ...resolvePropsGetter(a, EMPTY_PROPS)
+  };
+  if (b) {
+    merged = mergeOne(merged, b);
+  }
+  if (c) {
+    merged = mergeOne(merged, c);
+  }
+  if (d) {
+    merged = mergeOne(merged, d);
+  }
+  if (e) {
+    merged = mergeOne(merged, e);
+  }
+  return merged;
+}
+function mergePropsN(props) {
+  if (props.length === 0) {
+    return EMPTY_PROPS;
+  }
+  if (props.length === 1) {
+    return resolvePropsGetter(props[0], EMPTY_PROPS);
+  }
+  let merged = {
+    ...resolvePropsGetter(props[0], EMPTY_PROPS)
+  };
+  for (let i = 1; i < props.length; i += 1) {
+    merged = mergeOne(merged, props[i]);
+  }
+  return merged;
+}
+function mergeOne(merged, inputProps) {
+  if (isPropsGetter(inputProps)) {
+    return inputProps(merged);
+  }
+  return mutablyMergeInto(merged, inputProps);
+}
+function mutablyMergeInto(mergedProps, externalProps) {
+  if (!externalProps) {
+    return mergedProps;
+  }
+  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) {
+  const code0 = key.charCodeAt(0);
+  const code1 = key.charCodeAt(1);
+  const code2 = key.charCodeAt(2);
+  return code0 === 111 && code1 === 110 && code2 >= 65 && code2 <= 90 && (typeof value === "function" || typeof value === "undefined");
+}
+function isPropsGetter(inputProps) {
+  return typeof inputProps === "function";
+}
+function resolvePropsGetter(inputProps, previousProps) {
+  if (isPropsGetter(inputProps)) {
+    return inputProps(previousProps);
+  }
+  return inputProps ?? EMPTY_PROPS;
+}
+function mergeEventHandlers(ourHandler, theirHandler) {
+  if (!theirHandler) {
+    return ourHandler;
+  }
+  if (!ourHandler) {
+    return theirHandler;
+  }
+  return (event) => {
+    if (isSyntheticEvent(event)) {
+      const baseUIEvent = event;
+      makeEventPreventable(baseUIEvent);
+      const result2 = theirHandler(baseUIEvent);
+      if (!baseUIEvent.baseUIHandlerPrevented) {
+        ourHandler?.(baseUIEvent);
+      }
+      return result2;
+    }
+    const result = theirHandler(event);
+    ourHandler?.(event);
+    return result;
+  };
+}
+function makeEventPreventable(event) {
+  event.preventBaseUIHandler = () => {
+    event.baseUIHandlerPrevented = true;
+  };
+  return event;
+}
+function mergeClassNames(ourClassName, theirClassName) {
+  if (theirClassName) {
+    if (ourClassName) {
+      return theirClassName + " " + ourClassName;
+    }
+    return theirClassName;
+  }
+  return ourClassName;
+}
+function isSyntheticEvent(event) {
+  return event != null && typeof event === "object" && "nativeEvent" in event;
+}
+
+// node_modules/@base-ui/utils/esm/empty.js
+var EMPTY_ARRAY = Object.freeze([]);
+var EMPTY_OBJECT = Object.freeze({});
+
+// node_modules/@base-ui/react/esm/utils/constants.js
+var BASE_UI_SWIPE_IGNORE_ATTRIBUTE = "data-base-ui-swipe-ignore";
+var LEGACY_SWIPE_IGNORE_ATTRIBUTE = "data-swipe-ignore";
+var BASE_UI_SWIPE_IGNORE_SELECTOR = `[${BASE_UI_SWIPE_IGNORE_ATTRIBUTE}]`;
+var LEGACY_SWIPE_IGNORE_SELECTOR = `[${LEGACY_SWIPE_IGNORE_ATTRIBUTE}]`;
+
+// node_modules/@base-ui/react/esm/utils/useRenderElement.js
+import { createElement as _createElement } from "react";
+function useRenderElement(element, componentProps, params = {}) {
+  const renderProp = componentProps.render;
+  const outProps = useRenderElementProps(componentProps, params);
+  if (params.enabled === false) {
+    return null;
+  }
+  const state = params.state ?? EMPTY_OBJECT;
+  return evaluateRenderProp(element, renderProp, outProps, state);
+}
+function useRenderElementProps(componentProps, params = {}) {
+  const {
+    className: classNameProp,
+    style: styleProp,
+    render: renderProp
+  } = componentProps;
+  const {
+    state = EMPTY_OBJECT,
+    ref,
+    props,
+    stateAttributesMapping,
+    enabled = true
+  } = params;
+  const className = enabled ? resolveClassName(classNameProp, state) : void 0;
+  const style = enabled ? resolveStyle(styleProp, state) : void 0;
+  const stateProps = enabled ? getStateAttributesProps(state, stateAttributesMapping) : EMPTY_OBJECT;
+  const outProps = enabled ? mergeObjects(stateProps, Array.isArray(props) ? mergePropsN(props) : props) ?? EMPTY_OBJECT : EMPTY_OBJECT;
+  if (typeof document !== "undefined") {
+    if (!enabled) {
+      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 !== void 0) {
+    outProps.className = mergeClassNames(outProps.className, className);
+  }
+  if (style !== void 0) {
+    outProps.style = mergeObjects(outProps.style, style);
+  }
+  return outProps;
+}
+var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
+function evaluateRenderProp(element, render, props, state) {
+  if (render) {
+    if (typeof render === "function") {
+      if (true) {
+        warnIfRenderPropLooksLikeComponent(render);
+      }
+      return render(props, state);
+    }
+    const mergedProps = mergeProps(props, render.props);
+    mergedProps.ref = props.ref;
+    let newElement = render;
+    if (newElement?.$$typeof === REACT_LAZY_TYPE) {
+      const children = React11.Children.toArray(render);
+      newElement = children[0];
+    }
+    if (true) {
+      if (!/* @__PURE__ */ React11.isValidElement(newElement)) {
+        throw new Error(["Base UI: The `render` prop was provided an invalid React element as `React.isValidElement(render)` is `false`.", "A valid React element must be provided to the `render` prop because it is cloned with props to replace the default element.", "https://base-ui.com/r/invalid-render-prop"].join("\n"));
+      }
+    }
+    return /* @__PURE__ */ React11.cloneElement(newElement, mergedProps);
+  }
+  if (element) {
+    if (typeof element === "string") {
+      return renderTag(element, props);
+    }
+  }
+  throw new Error(true ? "Base UI: Render element or function are not defined." : formatErrorMessage_default(8));
+}
+function warnIfRenderPropLooksLikeComponent(renderFn) {
+  const functionName = renderFn.name;
+  if (functionName.length === 0) {
+    return;
+  }
+  const firstCharacterCode = functionName.charCodeAt(0);
+  if (firstCharacterCode < 65 || firstCharacterCode > 90) {
+    return;
+  }
+  warn(`The \`render\` prop received a function named \`${functionName}\` that starts with an uppercase letter.`, "This usually means a React component was passed directly as `render={Component}`.", "Base UI calls `render` as a plain function, which can break the Rules of Hooks during reconciliation.", "If this is an intentional render callback, rename it to start with a lowercase letter.", "Use `render={<Component />}` or `render={(props) => <Component {...props} />}` instead.", "https://base-ui.com/r/invalid-render-prop");
+}
+function renderTag(Tag, props) {
+  if (Tag === "button") {
+    return /* @__PURE__ */ _createElement("button", {
+      type: "button",
+      ...props,
+      key: props.key
+    });
+  }
+  if (Tag === "img") {
+    return /* @__PURE__ */ _createElement("img", {
+      alt: "",
+      ...props,
+      key: props.key
+    });
+  }
+  return /* @__PURE__ */ React11.createElement(Tag, props);
+}
+
+// node_modules/@base-ui/react/esm/utils/reason-parts.js
+var reason_parts_exports = {};
+__export(reason_parts_exports, {
+  cancelOpen: () => cancelOpen,
+  chipRemovePress: () => chipRemovePress,
+  clearPress: () => clearPress,
+  closePress: () => closePress,
+  closeWatcher: () => closeWatcher,
+  decrementPress: () => decrementPress,
+  disabled: () => disabled,
+  drag: () => drag,
+  escapeKey: () => escapeKey,
+  focusOut: () => focusOut,
+  imperativeAction: () => imperativeAction,
+  incrementPress: () => incrementPress,
+  inputBlur: () => inputBlur,
+  inputChange: () => inputChange,
+  inputClear: () => inputClear,
+  inputPaste: () => inputPaste,
+  inputPress: () => inputPress,
+  itemPress: () => itemPress,
+  keyboard: () => keyboard,
+  linkPress: () => linkPress,
+  listNavigation: () => listNavigation,
+  none: () => none,
+  outsidePress: () => outsidePress,
+  pointer: () => pointer,
+  scrub: () => scrub,
+  siblingOpen: () => siblingOpen,
+  swipe: () => swipe,
+  trackPress: () => trackPress,
+  triggerFocus: () => triggerFocus,
+  triggerHover: () => triggerHover,
+  triggerPress: () => triggerPress,
+  wheel: () => wheel,
+  windowResize: () => windowResize
+});
+var none = "none";
+var triggerPress = "trigger-press";
+var triggerHover = "trigger-hover";
+var triggerFocus = "trigger-focus";
+var outsidePress = "outside-press";
+var itemPress = "item-press";
+var closePress = "close-press";
+var linkPress = "link-press";
+var clearPress = "clear-press";
+var chipRemovePress = "chip-remove-press";
+var trackPress = "track-press";
+var incrementPress = "increment-press";
+var decrementPress = "decrement-press";
+var inputChange = "input-change";
+var inputClear = "input-clear";
+var inputBlur = "input-blur";
+var inputPaste = "input-paste";
+var inputPress = "input-press";
+var focusOut = "focus-out";
+var escapeKey = "escape-key";
+var closeWatcher = "close-watcher";
+var listNavigation = "list-navigation";
+var keyboard = "keyboard";
+var pointer = "pointer";
+var drag = "drag";
+var wheel = "wheel";
+var scrub = "scrub";
+var cancelOpen = "cancel-open";
+var siblingOpen = "sibling-open";
+var disabled = "disabled";
+var imperativeAction = "imperative-action";
+var swipe = "swipe";
+var windowResize = "window-resize";
+
+// node_modules/@base-ui/react/esm/utils/createBaseUIEventDetails.js
+function createChangeEventDetails(reason, event, trigger, customProperties) {
+  let canceled = false;
+  let allowPropagation = false;
+  const custom = customProperties ?? 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;
+}
+
+// node_modules/@base-ui/react/esm/accordion/root/AccordionRoot.js
+import { jsx as _jsx2 } from "react/jsx-runtime";
+var rootStateAttributesMapping = {
+  value: () => null
+};
+var AccordionRoot = /* @__PURE__ */ React12.forwardRef(function AccordionRoot2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    disabled: disabled2 = false,
+    hiddenUntilFound: hiddenUntilFoundProp,
+    keepMounted: keepMountedProp,
+    loopFocus = true,
+    onValueChange: onValueChangeProp,
+    multiple = false,
+    orientation = "vertical",
+    value: valueProp,
+    defaultValue: defaultValueProp,
+    ...elementProps
+  } = componentProps;
+  const direction = useDirection();
+  if (true) {
+    useIsoLayoutEffect(() => {
+      if (hiddenUntilFoundProp && keepMountedProp === false) {
+        warn("The `keepMounted={false}` prop on a Accordion.Root will be ignored when using `hiddenUntilFound` since it requires Panels to remain mounted when closed.");
+      }
+    }, [hiddenUntilFoundProp, keepMountedProp]);
+  }
+  const defaultValue = React12.useMemo(() => {
+    if (valueProp === void 0) {
+      return defaultValueProp ?? [];
+    }
+    return void 0;
+  }, [valueProp, defaultValueProp]);
+  const onValueChange = useStableCallback(onValueChangeProp);
+  const accordionItemRefs = React12.useRef([]);
+  const [value, setValue] = useControlled({
+    controlled: valueProp,
+    default: defaultValue,
+    name: "Accordion",
+    state: "value"
+  });
+  const handleValueChange = useStableCallback((newValue, nextOpen) => {
+    const details = createChangeEventDetails(reason_parts_exports.none);
+    if (!multiple) {
+      const nextValue = value[0] === newValue ? [] : [newValue];
+      onValueChange(nextValue, details);
+      if (details.isCanceled) {
+        return;
+      }
+      setValue(nextValue);
+    } else if (nextOpen) {
+      const nextOpenValues = value.slice();
+      nextOpenValues.push(newValue);
+      onValueChange(nextOpenValues, details);
+      if (details.isCanceled) {
+        return;
+      }
+      setValue(nextOpenValues);
+    } else {
+      const nextOpenValues = value.filter((v) => v !== newValue);
+      onValueChange(nextOpenValues, details);
+      if (details.isCanceled) {
+        return;
+      }
+      setValue(nextOpenValues);
+    }
+  });
+  const state = React12.useMemo(() => ({
+    value,
+    disabled: disabled2,
+    orientation
+  }), [value, disabled2, orientation]);
+  const contextValue = React12.useMemo(() => ({
+    accordionItemRefs,
+    direction,
+    disabled: disabled2,
+    handleValueChange,
+    hiddenUntilFound: hiddenUntilFoundProp ?? false,
+    keepMounted: keepMountedProp ?? false,
+    loopFocus,
+    orientation,
+    state,
+    value
+  }), [direction, disabled2, handleValueChange, hiddenUntilFoundProp, keepMountedProp, loopFocus, orientation, state, value]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: [{
+      dir: direction,
+      role: "region"
+    }, elementProps],
+    stateAttributesMapping: rootStateAttributesMapping
+  });
+  return /* @__PURE__ */ _jsx2(AccordionRootContext.Provider, {
+    value: contextValue,
+    children: /* @__PURE__ */ _jsx2(CompositeList, {
+      elementsRef: accordionItemRefs,
+      children: element
+    })
+  });
+});
+if (true) AccordionRoot.displayName = "AccordionRoot";
+
+// node_modules/@base-ui/react/esm/accordion/item/AccordionItem.js
+import * as React21 from "react";
+
+// node_modules/@base-ui/utils/esm/useId.js
+import * as React14 from "react";
+
+// node_modules/@base-ui/utils/esm/safeReact.js
+import * as React13 from "react";
+var SafeReact = {
+  ...React13
+};
+
+// node_modules/@base-ui/utils/esm/useId.js
+var globalId = 0;
+function useGlobalId(idOverride, prefix = "mui") {
+  const [defaultId, setDefaultId] = React14.useState(idOverride);
+  const id = idOverride || defaultId;
+  React14.useEffect(() => {
+    if (defaultId == null) {
+      globalId += 1;
+      setDefaultId(`${prefix}-${globalId}`);
+    }
+  }, [defaultId, prefix]);
+  return id;
+}
+var maybeReactUseId = SafeReact.useId;
+function useId(idOverride, prefix) {
+  if (maybeReactUseId !== void 0) {
+    const reactId = maybeReactUseId();
+    return idOverride ?? (prefix ? `${prefix}-${reactId}` : reactId);
+  }
+  return useGlobalId(idOverride, prefix);
+}
+
+// node_modules/@base-ui/react/esm/utils/useBaseUiId.js
+function useBaseUiId(idOverride) {
+  return useId(idOverride, "base-ui");
+}
+
+// node_modules/@base-ui/react/esm/collapsible/root/useCollapsibleRoot.js
+import * as React17 from "react";
+
+// node_modules/@base-ui/react/esm/utils/useAnimationsFinished.js
+import * as ReactDOM from "react-dom";
+
+// node_modules/@base-ui/utils/esm/useOnMount.js
+import * as React15 from "react";
+var EMPTY = [];
+function useOnMount(fn) {
+  React15.useEffect(fn, EMPTY);
+}
+
+// node_modules/@base-ui/utils/esm/useAnimationFrame.js
+var EMPTY2 = null;
+var LAST_RAF = globalThis.requestAnimationFrame;
+var Scheduler = class {
+  /* This implementation uses an array as a backing data-structure for frame callbacks.
+   * It allows `O(1)` callback cancelling by inserting a `null` in the array, though it
+   * never calls the native `cancelAnimationFrame` if there are no frames left. This can
+   * be much more efficient if there is a call pattern that alterns as
+   * "request-cancel-request-cancel-…".
+   * But in the case of "request-request-…-cancel-cancel-…", it leaves the final animation
+   * frame to run anyway. We turn that frame into a `O(1)` no-op via `callbacksCount`. */
+  callbacks = [];
+  callbacksCount = 0;
+  nextId = 1;
+  startId = 1;
+  isScheduled = false;
+  tick = (timestamp) => {
+    this.isScheduled = false;
+    const currentCallbacks = this.callbacks;
+    const currentCallbacksCount = this.callbacksCount;
+    this.callbacks = [];
+    this.callbacksCount = 0;
+    this.startId = this.nextId;
+    if (currentCallbacksCount > 0) {
+      for (let i = 0; i < currentCallbacks.length; i += 1) {
+        currentCallbacks[i]?.(timestamp);
+      }
+    }
+  };
+  request(fn) {
+    const id = this.nextId;
+    this.nextId += 1;
+    this.callbacks.push(fn);
+    this.callbacksCount += 1;
+    const didRAFChange = LAST_RAF !== requestAnimationFrame && (LAST_RAF = requestAnimationFrame, true);
+    if (!this.isScheduled || didRAFChange) {
+      requestAnimationFrame(this.tick);
+      this.isScheduled = true;
+    }
+    return id;
+  }
+  cancel(id) {
+    const index = id - this.startId;
+    if (index < 0 || index >= this.callbacks.length) {
+      return;
+    }
+    this.callbacks[index] = null;
+    this.callbacksCount -= 1;
+  }
+};
+var scheduler = new Scheduler();
+var AnimationFrame = class _AnimationFrame {
+  static create() {
+    return new _AnimationFrame();
+  }
+  static request(fn) {
+    return scheduler.request(fn);
+  }
+  static cancel(id) {
+    return scheduler.cancel(id);
+  }
+  currentId = EMPTY2;
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  request(fn) {
+    this.cancel();
+    this.currentId = scheduler.request(() => {
+      this.currentId = EMPTY2;
+      fn();
+    });
+  }
+  cancel = () => {
+    if (this.currentId !== EMPTY2) {
+      scheduler.cancel(this.currentId);
+      this.currentId = EMPTY2;
+    }
+  };
+  disposeEffect = () => {
+    return this.cancel;
+  };
+};
+function useAnimationFrame() {
+  const timeout = useRefWithInit(AnimationFrame.create).current;
+  useOnMount(timeout.disposeEffect);
+  return timeout;
+}
+
+// node_modules/@base-ui/react/esm/utils/resolveRef.js
+function resolveRef(maybeRef) {
+  if (maybeRef == null) {
+    return maybeRef;
+  }
+  return "current" in maybeRef ? maybeRef.current : maybeRef;
+}
+
+// node_modules/@base-ui/react/esm/utils/stateAttributesMapping.js
+var TransitionStatusDataAttributes = /* @__PURE__ */ (function(TransitionStatusDataAttributes2) {
+  TransitionStatusDataAttributes2["startingStyle"] = "data-starting-style";
+  TransitionStatusDataAttributes2["endingStyle"] = "data-ending-style";
+  return TransitionStatusDataAttributes2;
+})({});
+var STARTING_HOOK = {
+  [TransitionStatusDataAttributes.startingStyle]: ""
+};
+var ENDING_HOOK = {
+  [TransitionStatusDataAttributes.endingStyle]: ""
+};
+var transitionStatusMapping = {
+  transitionStatus(value) {
+    if (value === "starting") {
+      return STARTING_HOOK;
+    }
+    if (value === "ending") {
+      return ENDING_HOOK;
+    }
+    return null;
+  }
+};
+
+// node_modules/@base-ui/react/esm/utils/useAnimationsFinished.js
+function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = false, treatAbortedAsFinished = true) {
+  const frame = useAnimationFrame();
+  return useStableCallback((fnToExecute, signal = null) => {
+    frame.cancel();
+    function done() {
+      ReactDOM.flushSync(fnToExecute);
+    }
+    const element = resolveRef(elementOrRef);
+    if (element == null) {
+      return;
+    }
+    const resolvedElement = element;
+    if (typeof resolvedElement.getAnimations !== "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED) {
+      fnToExecute();
+    } else {
+      let execWaitForStartingStyleRemoved2 = function() {
+        const startingStyleAttribute = TransitionStatusDataAttributes.startingStyle;
+        if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
+          frame.request(exec2);
+          return;
+        }
+        const attributeObserver = new MutationObserver(() => {
+          if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
+            attributeObserver.disconnect();
+            exec2();
+          }
+        });
+        attributeObserver.observe(resolvedElement, {
+          attributes: true,
+          attributeFilter: [startingStyleAttribute]
+        });
+        signal?.addEventListener("abort", () => attributeObserver.disconnect(), {
+          once: true
+        });
+      }, exec2 = function() {
+        Promise.all(resolvedElement.getAnimations().map((anim) => anim.finished)).then(() => {
+          if (signal?.aborted) {
+            return;
+          }
+          done();
+        }).catch(() => {
+          const currentAnimations = resolvedElement.getAnimations();
+          if (treatAbortedAsFinished) {
+            if (signal?.aborted) {
+              return;
+            }
+            done();
+          } else if (currentAnimations.length > 0 && currentAnimations.some((anim) => anim.pending || anim.playState !== "finished")) {
+            exec2();
+          }
+        });
+      };
+      var execWaitForStartingStyleRemoved = execWaitForStartingStyleRemoved2, exec = exec2;
+      if (waitForStartingStyleRemoved) {
+        execWaitForStartingStyleRemoved2();
+        return;
+      }
+      frame.request(exec2);
+    }
+  });
+}
+
+// node_modules/@base-ui/react/esm/utils/useTransitionStatus.js
+import * as React16 from "react";
+function useTransitionStatus(open, enableIdleState = false, deferEndingState = false) {
+  const [transitionStatus, setTransitionStatus] = React16.useState(open && enableIdleState ? "idle" : void 0);
+  const [mounted, setMounted] = React16.useState(open);
+  if (open && !mounted) {
+    setMounted(true);
+    setTransitionStatus("starting");
+  }
+  if (!open && mounted && transitionStatus !== "ending" && !deferEndingState) {
+    setTransitionStatus("ending");
+  }
+  if (!open && !mounted && transitionStatus === "ending") {
+    setTransitionStatus(void 0);
+  }
+  useIsoLayoutEffect(() => {
+    if (!open && mounted && transitionStatus !== "ending" && deferEndingState) {
+      const frame = AnimationFrame.request(() => {
+        setTransitionStatus("ending");
+      });
+      return () => {
+        AnimationFrame.cancel(frame);
+      };
+    }
+    return void 0;
+  }, [open, mounted, transitionStatus, deferEndingState]);
+  useIsoLayoutEffect(() => {
+    if (!open || enableIdleState) {
+      return void 0;
+    }
+    const frame = AnimationFrame.request(() => {
+      setTransitionStatus(void 0);
+    });
+    return () => {
+      AnimationFrame.cancel(frame);
+    };
+  }, [enableIdleState, open]);
+  useIsoLayoutEffect(() => {
+    if (!open || !enableIdleState) {
+      return void 0;
+    }
+    if (open && mounted && transitionStatus !== "idle") {
+      setTransitionStatus("starting");
+    }
+    const frame = AnimationFrame.request(() => {
+      setTransitionStatus("idle");
+    });
+    return () => {
+      AnimationFrame.cancel(frame);
+    };
+  }, [enableIdleState, open, mounted, setTransitionStatus, transitionStatus]);
+  return React16.useMemo(() => ({
+    mounted,
+    setMounted,
+    transitionStatus
+  }), [mounted, transitionStatus]);
+}
+
+// node_modules/@base-ui/react/esm/collapsible/root/useCollapsibleRoot.js
+function useCollapsibleRoot(parameters) {
+  const {
+    open: openParam,
+    defaultOpen,
+    onOpenChange,
+    disabled: disabled2
+  } = parameters;
+  const isControlled = openParam !== void 0;
+  const [open, setOpen] = useControlled({
+    controlled: openParam,
+    default: defaultOpen,
+    name: "Collapsible",
+    state: "open"
+  });
+  const {
+    mounted,
+    setMounted,
+    transitionStatus
+  } = useTransitionStatus(open, true, true);
+  const [visible, setVisible] = React17.useState(open);
+  const [{
+    height,
+    width
+  }, setDimensions] = React17.useState({
+    height: void 0,
+    width: void 0
+  });
+  const defaultPanelId = useBaseUiId();
+  const [panelIdState, setPanelIdState] = React17.useState();
+  const panelId = panelIdState ?? defaultPanelId;
+  const [hiddenUntilFound, setHiddenUntilFound] = React17.useState(false);
+  const [keepMounted, setKeepMounted] = React17.useState(false);
+  const abortControllerRef = React17.useRef(null);
+  const animationTypeRef = React17.useRef(null);
+  const transitionDimensionRef = React17.useRef(null);
+  const panelRef = React17.useRef(null);
+  const runOnceAnimationsFinish = useAnimationsFinished(panelRef, false);
+  const handleTrigger = useStableCallback((event) => {
+    const nextOpen = !open;
+    const eventDetails = createChangeEventDetails(reason_parts_exports.triggerPress, event.nativeEvent);
+    onOpenChange(nextOpen, eventDetails);
+    if (eventDetails.isCanceled) {
+      return;
+    }
+    const panel = panelRef.current;
+    if (animationTypeRef.current === "css-animation" && panel != null) {
+      panel.style.removeProperty("animation-name");
+    }
+    if (!hiddenUntilFound && !keepMounted) {
+      if (animationTypeRef.current != null && animationTypeRef.current !== "css-animation") {
+        if (!mounted && nextOpen) {
+          setMounted(true);
+        }
+      }
+      if (animationTypeRef.current === "css-animation") {
+        if (!visible && nextOpen) {
+          setVisible(true);
+        }
+        if (!mounted && nextOpen) {
+          setMounted(true);
+        }
+      }
+    }
+    setOpen(nextOpen);
+    if (animationTypeRef.current === "none" && mounted && !nextOpen) {
+      setMounted(false);
+    }
+  });
+  useIsoLayoutEffect(() => {
+    if (isControlled && animationTypeRef.current === "none" && !keepMounted && !open) {
+      setMounted(false);
+    }
+  }, [isControlled, keepMounted, open, openParam, setMounted]);
+  return React17.useMemo(() => ({
+    abortControllerRef,
+    animationTypeRef,
+    disabled: disabled2,
+    handleTrigger,
+    height,
+    mounted,
+    open,
+    panelId,
+    panelRef,
+    runOnceAnimationsFinish,
+    setDimensions,
+    setHiddenUntilFound,
+    setKeepMounted,
+    setMounted,
+    setOpen,
+    setPanelIdState,
+    setVisible,
+    transitionDimensionRef,
+    transitionStatus,
+    visible,
+    width
+  }), [abortControllerRef, animationTypeRef, disabled2, handleTrigger, height, mounted, open, panelId, panelRef, runOnceAnimationsFinish, setDimensions, setHiddenUntilFound, setKeepMounted, setMounted, setOpen, setVisible, transitionDimensionRef, transitionStatus, visible, width]);
+}
+
+// node_modules/@base-ui/react/esm/collapsible/root/CollapsibleRootContext.js
+import * as React18 from "react";
+var CollapsibleRootContext = /* @__PURE__ */ React18.createContext(void 0);
+if (true) CollapsibleRootContext.displayName = "CollapsibleRootContext";
+function useCollapsibleRootContext() {
+  const context = React18.useContext(CollapsibleRootContext);
+  if (context === void 0) {
+    throw new Error(true ? "Base UI: CollapsibleRootContext is missing. Collapsible parts must be placed within <Collapsible.Root>." : formatErrorMessage_default(15));
+  }
+  return context;
+}
+
+// node_modules/@base-ui/react/esm/composite/list/useCompositeListItem.js
+import * as React19 from "react";
+var IndexGuessBehavior = /* @__PURE__ */ (function(IndexGuessBehavior2) {
+  IndexGuessBehavior2[IndexGuessBehavior2["None"] = 0] = "None";
+  IndexGuessBehavior2[IndexGuessBehavior2["GuessFromOrder"] = 1] = "GuessFromOrder";
+  return IndexGuessBehavior2;
+})({});
+function useCompositeListItem(params = {}) {
+  const {
+    label,
+    metadata,
+    textRef,
+    indexGuessBehavior,
+    index: externalIndex
+  } = params;
+  const {
+    register,
+    unregister,
+    subscribeMapChange,
+    elementsRef,
+    labelsRef,
+    nextIndexRef
+  } = useCompositeListContext();
+  const indexRef = React19.useRef(-1);
+  const [index, setIndex] = React19.useState(externalIndex ?? (indexGuessBehavior === IndexGuessBehavior.GuessFromOrder ? () => {
+    if (indexRef.current === -1) {
+      const newIndex = nextIndexRef.current;
+      nextIndexRef.current += 1;
+      indexRef.current = newIndex;
+    }
+    return indexRef.current;
+  } : -1));
+  const componentRef = React19.useRef(null);
+  const ref = React19.useCallback((node) => {
+    componentRef.current = node;
+    if (index !== -1 && node !== null) {
+      elementsRef.current[index] = node;
+      if (labelsRef) {
+        const isLabelDefined = label !== void 0;
+        labelsRef.current[index] = isLabelDefined ? label : textRef?.current?.textContent ?? node.textContent;
+      }
+    }
+  }, [index, elementsRef, labelsRef, label, textRef]);
+  useIsoLayoutEffect(() => {
+    if (externalIndex != null) {
+      return void 0;
+    }
+    const node = componentRef.current;
+    if (node) {
+      register(node, metadata);
+      return () => {
+        unregister(node);
+      };
+    }
+    return void 0;
+  }, [externalIndex, register, unregister, metadata]);
+  useIsoLayoutEffect(() => {
+    if (externalIndex != null) {
+      return void 0;
+    }
+    return subscribeMapChange((map) => {
+      const i = componentRef.current ? map.get(componentRef.current)?.index : null;
+      if (i != null) {
+        setIndex(i);
+      }
+    });
+  }, [externalIndex, subscribeMapChange, setIndex]);
+  return React19.useMemo(() => ({
+    ref,
+    index
+  }), [index, ref]);
+}
+
+// node_modules/@base-ui/react/esm/accordion/item/AccordionItemContext.js
+import * as React20 from "react";
+var AccordionItemContext = /* @__PURE__ */ React20.createContext(void 0);
+if (true) AccordionItemContext.displayName = "AccordionItemContext";
+function useAccordionItemContext() {
+  const context = React20.useContext(AccordionItemContext);
+  if (context === void 0) {
+    throw new Error(true ? "Base UI: AccordionItemContext is missing. Accordion parts must be placed within <Accordion.Item>." : formatErrorMessage_default(9));
+  }
+  return context;
+}
+
+// node_modules/@base-ui/react/esm/collapsible/panel/CollapsiblePanelDataAttributes.js
+var CollapsiblePanelDataAttributes = (function(CollapsiblePanelDataAttributes2) {
+  CollapsiblePanelDataAttributes2["open"] = "data-open";
+  CollapsiblePanelDataAttributes2["closed"] = "data-closed";
+  CollapsiblePanelDataAttributes2[CollapsiblePanelDataAttributes2["startingStyle"] = TransitionStatusDataAttributes.startingStyle] = "startingStyle";
+  CollapsiblePanelDataAttributes2[CollapsiblePanelDataAttributes2["endingStyle"] = TransitionStatusDataAttributes.endingStyle] = "endingStyle";
+  return CollapsiblePanelDataAttributes2;
+})({});
+
+// node_modules/@base-ui/react/esm/collapsible/trigger/CollapsibleTriggerDataAttributes.js
+var CollapsibleTriggerDataAttributes = /* @__PURE__ */ (function(CollapsibleTriggerDataAttributes2) {
+  CollapsibleTriggerDataAttributes2["panelOpen"] = "data-panel-open";
+  return CollapsibleTriggerDataAttributes2;
+})({});
+
+// node_modules/@base-ui/react/esm/utils/collapsibleOpenStateMapping.js
+var PANEL_OPEN_HOOK = {
+  [CollapsiblePanelDataAttributes.open]: ""
+};
+var PANEL_CLOSED_HOOK = {
+  [CollapsiblePanelDataAttributes.closed]: ""
+};
+var triggerOpenStateMapping = {
+  open(value) {
+    if (value) {
+      return {
+        [CollapsibleTriggerDataAttributes.panelOpen]: ""
+      };
+    }
+    return null;
+  }
+};
+var collapsibleOpenStateMapping = {
+  open(value) {
+    if (value) {
+      return PANEL_OPEN_HOOK;
+    }
+    return PANEL_CLOSED_HOOK;
+  }
+};
+
+// node_modules/@base-ui/react/esm/accordion/item/AccordionItemDataAttributes.js
+var AccordionItemDataAttributes = /* @__PURE__ */ (function(AccordionItemDataAttributes2) {
+  AccordionItemDataAttributes2["index"] = "data-index";
+  AccordionItemDataAttributes2["disabled"] = "data-disabled";
+  AccordionItemDataAttributes2["open"] = "data-open";
+  return AccordionItemDataAttributes2;
+})({});
+
+// node_modules/@base-ui/react/esm/accordion/item/stateAttributesMapping.js
+var accordionStateAttributesMapping = {
+  ...collapsibleOpenStateMapping,
+  index: (value) => {
+    return Number.isInteger(value) ? {
+      [AccordionItemDataAttributes.index]: String(value)
+    } : null;
+  },
+  ...transitionStatusMapping,
+  value: () => null
+};
+
+// node_modules/@base-ui/react/esm/accordion/item/AccordionItem.js
+import { jsx as _jsx3 } from "react/jsx-runtime";
+var AccordionItem = /* @__PURE__ */ React21.forwardRef(function AccordionItem2(componentProps, forwardedRef) {
+  const {
+    className,
+    disabled: disabledProp = false,
+    onOpenChange: onOpenChangeProp,
+    render,
+    value: valueProp,
+    ...elementProps
+  } = componentProps;
+  const {
+    ref: listItemRef,
+    index
+  } = useCompositeListItem();
+  const mergedRef = useMergedRefs(forwardedRef, listItemRef);
+  const {
+    disabled: contextDisabled,
+    handleValueChange,
+    state: rootState,
+    value: openValues
+  } = useAccordionRootContext();
+  const fallbackValue = useBaseUiId();
+  const value = valueProp ?? fallbackValue;
+  const disabled2 = disabledProp || contextDisabled;
+  const isOpen = React21.useMemo(() => {
+    if (!openValues) {
+      return false;
+    }
+    for (let i = 0; i < openValues.length; i += 1) {
+      if (openValues[i] === value) {
+        return true;
+      }
+    }
+    return false;
+  }, [openValues, value]);
+  const onOpenChange = useStableCallback((nextOpen, eventDetails) => {
+    onOpenChangeProp?.(nextOpen, eventDetails);
+    if (eventDetails.isCanceled) {
+      return;
+    }
+    handleValueChange(value, nextOpen);
+  });
+  const collapsible = useCollapsibleRoot({
+    open: isOpen,
+    onOpenChange,
+    disabled: disabled2
+  });
+  const collapsibleState = React21.useMemo(() => ({
+    open: collapsible.open,
+    disabled: collapsible.disabled,
+    hidden: !collapsible.mounted,
+    transitionStatus: collapsible.transitionStatus
+  }), [collapsible.open, collapsible.disabled, collapsible.mounted, collapsible.transitionStatus]);
+  const collapsibleContext = React21.useMemo(() => ({
+    ...collapsible,
+    onOpenChange,
+    state: collapsibleState
+  }), [collapsible, collapsibleState, onOpenChange]);
+  const state = React21.useMemo(() => ({
+    ...rootState,
+    index,
+    disabled: disabled2,
+    open: isOpen
+  }), [disabled2, index, isOpen, rootState]);
+  const [triggerId, setTriggerId] = React21.useState(useBaseUiId());
+  const accordionItemContext = React21.useMemo(() => ({
+    open: isOpen,
+    state,
+    setTriggerId,
+    triggerId
+  }), [isOpen, state, setTriggerId, triggerId]);
+  const element = useRenderElement("div", componentProps, {
+    state,
+    ref: mergedRef,
+    props: elementProps,
+    stateAttributesMapping: accordionStateAttributesMapping
+  });
+  return /* @__PURE__ */ _jsx3(CollapsibleRootContext.Provider, {
+    value: collapsibleContext,
+    children: /* @__PURE__ */ _jsx3(AccordionItemContext.Provider, {
+      value: accordionItemContext,
+      children: element
+    })
+  });
+});
+if (true) AccordionItem.displayName = "AccordionItem";
+
+// node_modules/@base-ui/react/esm/accordion/header/AccordionHeader.js
+import * as React22 from "react";
+var AccordionHeader = /* @__PURE__ */ React22.forwardRef(function AccordionHeader2(componentProps, forwardedRef) {
+  const {
+    render,
+    className,
+    ...elementProps
+  } = componentProps;
+  const {
+    state
+  } = useAccordionItemContext();
+  const element = useRenderElement("h3", componentProps, {
+    state,
+    ref: forwardedRef,
+    props: elementProps,
+    stateAttributesMapping: accordionStateAttributesMapping
+  });
+  return element;
+});
+if (true) AccordionHeader.displayName = "AccordionHeader";
+
+// node_modules/@base-ui/react/esm/accordion/trigger/AccordionTrigger.js
+import * as React26 from "react";
+
+// node_modules/@base-ui/utils/esm/isElementDisabled.js
+function isElementDisabled(element) {
+  return element == null || element.hasAttribute("disabled") || element.getAttribute("aria-disabled") === "true";
+}
+
+// node_modules/@base-ui/react/esm/use-button/useButton.js
+import * as React25 from "react";
+
+// node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.mjs
+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;
+}
+
+// node_modules/@base-ui/utils/esm/error.js
+var set2;
+if (true) {
+  set2 = /* @__PURE__ */ new Set();
+}
+function error(...messages) {
+  if (true) {
+    const messageKey = messages.join(" ");
+    if (!set2.has(messageKey)) {
+      set2.add(messageKey);
+      console.error(`Base UI: ${messageKey}`);
+    }
+  }
+}
+
+// node_modules/@base-ui/react/esm/composite/root/CompositeRootContext.js
+import * as React23 from "react";
+var CompositeRootContext = /* @__PURE__ */ React23.createContext(void 0);
+if (true) CompositeRootContext.displayName = "CompositeRootContext";
+function useCompositeRootContext(optional = false) {
+  const context = React23.useContext(CompositeRootContext);
+  if (context === void 0 && !optional) {
+    throw new Error(true ? "Base UI: CompositeRootContext is missing. Composite parts must be placed within <Composite.Root>." : formatErrorMessage_default(16));
+  }
+  return context;
+}
+
+// node_modules/@base-ui/react/esm/utils/useFocusableWhenDisabled.js
+import * as React24 from "react";
+function useFocusableWhenDisabled(parameters) {
+  const {
+    focusableWhenDisabled,
+    disabled: disabled2,
+    composite = false,
+    tabIndex: tabIndexProp = 0,
+    isNativeButton
+  } = parameters;
+  const isFocusableComposite = composite && focusableWhenDisabled !== false;
+  const isNonFocusableComposite = composite && focusableWhenDisabled === false;
+  const props = React24.useMemo(() => {
+    const additionalProps = {
+      // allow Tabbing away from focusableWhenDisabled elements
+      onKeyDown(event) {
+        if (disabled2 && focusableWhenDisabled && event.key !== "Tab") {
+          event.preventDefault();
+        }
+      }
+    };
+    if (!composite) {
+      additionalProps.tabIndex = tabIndexProp;
+      if (!isNativeButton && disabled2) {
+        additionalProps.tabIndex = focusableWhenDisabled ? tabIndexProp : -1;
+      }
+    }
+    if (isNativeButton && (focusableWhenDisabled || isFocusableComposite) || !isNativeButton && disabled2) {
+      additionalProps["aria-disabled"] = disabled2;
+    }
+    if (isNativeButton && (!focusableWhenDisabled || isNonFocusableComposite)) {
+      additionalProps.disabled = disabled2;
+    }
+    return additionalProps;
+  }, [composite, disabled2, focusableWhenDisabled, isFocusableComposite, isNonFocusableComposite, isNativeButton, tabIndexProp]);
+  return {
+    props
+  };
+}
+
+// node_modules/@base-ui/react/esm/use-button/useButton.js
+function useButton(parameters = {}) {
+  const {
+    disabled: disabled2 = false,
+    focusableWhenDisabled,
+    tabIndex = 0,
+    native: isNativeButton = true,
+    composite: compositeProp
+  } = parameters;
+  const elementRef = React25.useRef(null);
+  const compositeRootContext = useCompositeRootContext(true);
+  const isCompositeItem = compositeProp ?? compositeRootContext !== void 0;
+  const {
+    props: focusableWhenDisabledProps
+  } = useFocusableWhenDisabled({
+    focusableWhenDisabled,
+    disabled: disabled2,
+    composite: isCompositeItem,
+    tabIndex,
+    isNativeButton
+  });
+  if (true) {
+    React25.useEffect(() => {
+      if (!elementRef.current) {
+        return;
+      }
+      const isButtonTag = isButtonElement(elementRef.current);
+      if (isNativeButton) {
+        if (!isButtonTag) {
+          const ownerStackMessage = SafeReact.captureOwnerStack?.() || "";
+          const message = "A component that acts as a button expected a native <button> because the `nativeButton` prop is true. Rendering a non-<button> removes native button semantics, which can impact forms and accessibility. Use a real <button> in the `render` prop, or set `nativeButton` to `false`.";
+          error(`${message}${ownerStackMessage}`);
+        }
+      } else if (isButtonTag) {
+        const ownerStackMessage = SafeReact.captureOwnerStack?.() || "";
+        const message = "A component that acts as a button expected a non-<button> because the `nativeButton` prop is false. Rendering a <button> keeps native behavior while Base UI applies non-native attributes and handlers, which can add unintended extra attributes (such as `role` or `aria-disabled`). Use a non-<button> in the `render` prop, or set `nativeButton` to `true`.";
+        error(`${message}${ownerStackMessage}`);
+      }
+    }, [isNativeButton]);
+  }
+  const updateDisabled = React25.useCallback(() => {
+    const element = elementRef.current;
+    if (!isButtonElement(element)) {
+      return;
+    }
+    if (isCompositeItem && disabled2 && focusableWhenDisabledProps.disabled === void 0 && element.disabled) {
+      element.disabled = false;
+    }
+  }, [disabled2, focusableWhenDisabledProps.disabled, isCompositeItem]);
+  useIsoLayoutEffect(updateDisabled, [updateDisabled]);
+  const getButtonProps = React25.useCallback((externalProps = {}) => {
+    const {
+      onClick: externalOnClick,
+      onMouseDown: externalOnMouseDown,
+      onKeyUp: externalOnKeyUp,
+      onKeyDown: externalOnKeyDown,
+      onPointerDown: externalOnPointerDown,
+      ...otherExternalProps
+    } = externalProps;
+    const type = isNativeButton ? "button" : void 0;
+    return mergeProps({
+      type,
+      onClick(event) {
+        if (disabled2) {
+          event.preventDefault();
+          return;
+        }
+        externalOnClick?.(event);
+      },
+      onMouseDown(event) {
+        if (!disabled2) {
+          externalOnMouseDown?.(event);
+        }
+      },
+      onKeyDown(event) {
+        if (disabled2) {
+          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();
+          if (isLink || isNativeButton && isButton) {
+            currentTarget.click();
+            event.preventBaseUIHandler();
+          } else if (shouldClick) {
+            externalOnClick?.(event);
+            event.preventBaseUIHandler();
+          }
+          return;
+        }
+        if (shouldClick) {
+          if (!isNativeButton && (isSpaceKey || isEnterKey)) {
+            event.preventDefault();
+          }
+          if (!isNativeButton && isEnterKey) {
+            externalOnClick?.(event);
+          }
+        }
+      },
+      onKeyUp(event) {
+        if (disabled2) {
+          return;
+        }
+        makeEventPreventable(event);
+        externalOnKeyUp?.(event);
+        if (event.target === event.currentTarget && isNativeButton && isCompositeItem && isButtonElement(event.currentTarget) && event.key === " ") {
+          event.preventDefault();
+          return;
+        }
+        if (event.baseUIHandlerPrevented) {
+          return;
+        }
+        if (event.target === event.currentTarget && !isNativeButton && !isCompositeItem && event.key === " ") {
+          externalOnClick?.(event);
+        }
+      },
+      onPointerDown(event) {
+        if (disabled2) {
+          event.preventDefault();
+          return;
+        }
+        externalOnPointerDown?.(event);
+      }
+    }, !isNativeButton ? {
+      role: "button"
+    } : void 0, focusableWhenDisabledProps, otherExternalProps);
+  }, [disabled2, 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 Boolean(elem?.tagName === "A" && elem?.href);
+}
+
+// node_modules/@base-ui/react/esm/floating-ui-react/utils/event.js
+function stopEvent(event) {
+  event.preventDefault();
+  event.stopPropagation();
+}
+
+// node_modules/@base-ui/react/esm/composite/composite.js
+var ARROW_UP = "ArrowUp";
+var ARROW_DOWN = "ArrowDown";
+var ARROW_LEFT = "ArrowLeft";
+var ARROW_RIGHT = "ArrowRight";
+var HOME = "Home";
+var END = "End";
+var HORIZONTAL_KEYS = /* @__PURE__ */ new Set([ARROW_LEFT, ARROW_RIGHT]);
+var VERTICAL_KEYS = /* @__PURE__ */ new Set([ARROW_UP, ARROW_DOWN]);
+var ARROW_KEYS = /* @__PURE__ */ new Set([...HORIZONTAL_KEYS, ...VERTICAL_KEYS]);
+var ALL_KEYS = /* @__PURE__ */ new Set([...ARROW_KEYS, HOME, END]);
+
+// node_modules/@base-ui/react/esm/accordion/trigger/AccordionTrigger.js
+var SUPPORTED_KEYS = /* @__PURE__ */ new Set([ARROW_DOWN, ARROW_UP, ARROW_RIGHT, ARROW_LEFT, HOME, END]);
+function getActiveTriggers(accordionItemRefs) {
+  const {
+    current: accordionItemElements
+  } = accordionItemRefs;
+  const output = [];
+  for (let i = 0; i < accordionItemElements.length; i += 1) {
+    const section = accordionItemElements[i];
+    if (!isElementDisabled(section)) {
+      const trigger = section?.querySelector('[type="button"], [role="button"]');
+      if (trigger && !isElementDisabled(trigger)) {
+        output.push(trigger);
+      }
+    }
+  }
+  return output;
+}
+var AccordionTrigger = /* @__PURE__ */ React26.forwardRef(function AccordionTrigger2(componentProps, forwardedRef) {
+  const {
+    disabled: disabledProp,
+    className,
+    id: idProp,
+    render,
+    nativeButton = true,
+    ...elementProps
+  } = componentProps;
+  const {
+    panelId,
+    open,
+    handleTrigger,
+    disabled: contextDisabled
+  } = useCollapsibleRootContext();
+  const disabled2 = disabledProp ?? contextDisabled;
+  const {
+    getButtonProps,
+    buttonRef
+  } = useButton({
+    disabled: disabled2,
+    focusableWhenDisabled: true,
+    native: nativeButton,
+    composite: true
+  });
+  const {
+    accordionItemRefs,
+    direction,
+    loopFocus,
+    orientation
+  } = useAccordionRootContext();
+  const isRtl = direction === "rtl";
+  const isHorizontal = orientation === "horizontal";
+  const {
+    state,
+    setTriggerId,
+    triggerId: id
+  } = useAccordionItemContext();
+  useIsoLayoutEffect(() => {
+    if (idProp) {
+      setTriggerId(idProp);
+    }
+    return () => {
+      setTriggerId(void 0);
+    };
+  }, [idProp, setTriggerId]);
+  const props = React26.useMemo(() => ({
+    "aria-controls": open ? panelId : void 0,
+    "aria-expanded": open,
+    id,
+    tabIndex: 0,
+    onClick: handleTrigger,
+    onKeyDown(event) {
+      if (!SUPPORTED_KEYS.has(event.key)) {
+        return;
+      }
+      stopEvent(event);
+      const triggers = getActiveTriggers(accordionItemRefs);
+      const numOfEnabledTriggers = triggers.length;
+      const lastIndex = numOfEnabledTriggers - 1;
+      let nextIndex = -1;
+      const thisIndex = triggers.indexOf(event.target);
+      function toNext() {
+        if (loopFocus) {
+          nextIndex = thisIndex + 1 > lastIndex ? 0 : thisIndex + 1;
+        } else {
+          nextIndex = Math.min(thisIndex + 1, lastIndex);
+        }
+      }
+      function toPrev() {
+        if (loopFocus) {
+          nextIndex = thisIndex === 0 ? lastIndex : thisIndex - 1;
+        } else {
+          nextIndex = thisIndex - 1;
+        }
+      }
+      switch (event.key) {
+        case ARROW_DOWN:
+          if (!isHorizontal) {
+            toNext();
+          }
+          break;
+        case ARROW_UP:
+          if (!isHorizontal) {
+            toPrev();
+          }
+          break;
+        case ARROW_RIGHT:
+          if (isHorizontal) {
+            if (isRtl) {
+              toPrev();
+            } else {
+              toNext();
+            }
+          }
+          break;
+        case ARROW_LEFT:
+          if (isHorizontal) {
+            if (isRtl) {
+              toNext();
+            } else {
+              toPrev();
+            }
+          }
+          break;
+        case "Home":
+          nextIndex = 0;
+          break;
+        case "End":
+          nextIndex = lastIndex;
+          break;
+        default:
+          break;
+      }
+      if (nextIndex > -1) {
+        triggers[nextIndex].focus();
+      }
+    }
+  }), [accordionItemRefs, handleTrigger, id, isHorizontal, isRtl, loopFocus, open, panelId]);
+  const element = useRenderElement("button", componentProps, {
+    state,
+    ref: [forwardedRef, buttonRef],
+    props: [props, elementProps, getButtonProps],
+    stateAttributesMapping: triggerOpenStateMapping
+  });
+  return element;
+});
+if (true) AccordionTrigger.displayName = "AccordionTrigger";
+
+// node_modules/@base-ui/react/esm/accordion/panel/AccordionPanel.js
+import * as React29 from "react";
+
+// node_modules/@base-ui/react/esm/collapsible/panel/useCollapsiblePanel.js
+import * as React27 from "react";
+
+// node_modules/@base-ui/react/esm/accordion/root/AccordionRootDataAttributes.js
+var AccordionRootDataAttributes = /* @__PURE__ */ (function(AccordionRootDataAttributes2) {
+  AccordionRootDataAttributes2["disabled"] = "data-disabled";
+  AccordionRootDataAttributes2["orientation"] = "data-orientation";
+  return AccordionRootDataAttributes2;
+})({});
+
+// node_modules/@base-ui/react/esm/collapsible/panel/useCollapsiblePanel.js
+function useCollapsiblePanel(parameters) {
+  const {
+    abortControllerRef,
+    animationTypeRef,
+    externalRef,
+    height,
+    hiddenUntilFound,
+    keepMounted,
+    id: idParam,
+    mounted,
+    onOpenChange,
+    open,
+    panelRef,
+    runOnceAnimationsFinish,
+    setDimensions,
+    setMounted,
+    setOpen,
+    setVisible,
+    transitionDimensionRef,
+    visible,
+    width
+  } = parameters;
+  const isBeforeMatchRef = React27.useRef(false);
+  const latestAnimationNameRef = React27.useRef(null);
+  const shouldCancelInitialOpenAnimationRef = React27.useRef(open);
+  const shouldCancelInitialOpenTransitionRef = React27.useRef(open);
+  const endingStyleFrame = useAnimationFrame();
+  const hidden = React27.useMemo(() => {
+    if (animationTypeRef.current === "css-animation") {
+      return !visible;
+    }
+    return !open && !mounted;
+  }, [open, mounted, visible, animationTypeRef]);
+  const handlePanelRef = useStableCallback((element) => {
+    if (!element) {
+      return void 0;
+    }
+    if (animationTypeRef.current == null || transitionDimensionRef.current == null) {
+      const panelStyles = getComputedStyle(element);
+      const hasAnimation = panelStyles.animationName !== "none" && panelStyles.animationName !== "";
+      const hasTransition = panelStyles.transitionDuration !== "0s" && panelStyles.transitionDuration !== "";
+      if (hasAnimation && hasTransition) {
+        if (true) {
+          warn("CSS transitions and CSS animations both detected on Collapsible or Accordion panel.", "Only one of either animation type should be used.");
+        }
+      } else if (panelStyles.animationName === "none" && panelStyles.transitionDuration !== "0s") {
+        animationTypeRef.current = "css-transition";
+      } else if (panelStyles.animationName !== "none" && panelStyles.transitionDuration === "0s") {
+        animationTypeRef.current = "css-animation";
+      } else {
+        animationTypeRef.current = "none";
+      }
+      if (element.getAttribute(AccordionRootDataAttributes.orientation) === "horizontal" || panelStyles.transitionProperty.indexOf("width") > -1) {
+        transitionDimensionRef.current = "width";
+      } else {
+        transitionDimensionRef.current = "height";
+      }
+    }
+    if (animationTypeRef.current !== "css-transition") {
+      return void 0;
+    }
+    if (height === void 0 || width === void 0) {
+      setDimensions({
+        height: element.scrollHeight,
+        width: element.scrollWidth
+      });
+      if (shouldCancelInitialOpenTransitionRef.current) {
+        element.style.setProperty("transition-duration", "0s");
+      }
+    }
+    let frame = -1;
+    let nextFrame = -1;
+    frame = AnimationFrame.request(() => {
+      shouldCancelInitialOpenTransitionRef.current = false;
+      nextFrame = AnimationFrame.request(() => {
+        setTimeout(() => {
+          element.style.removeProperty("transition-duration");
+        });
+      });
+    });
+    return () => {
+      AnimationFrame.cancel(frame);
+      AnimationFrame.cancel(nextFrame);
+    };
+  });
+  const mergedPanelRef = useMergedRefs(externalRef, panelRef, handlePanelRef);
+  useIsoLayoutEffect(() => {
+    if (animationTypeRef.current !== "css-transition") {
+      return void 0;
+    }
+    const panel = panelRef.current;
+    if (!panel) {
+      return void 0;
+    }
+    let resizeFrame = -1;
+    if (abortControllerRef.current != null) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    if (open) {
+      const originalLayoutStyles = {
+        "justify-content": panel.style.justifyContent,
+        "align-items": panel.style.alignItems,
+        "align-content": panel.style.alignContent,
+        "justify-items": panel.style.justifyItems
+      };
+      Object.keys(originalLayoutStyles).forEach((key) => {
+        panel.style.setProperty(key, "initial", "important");
+      });
+      if (!shouldCancelInitialOpenTransitionRef.current && !keepMounted) {
+        panel.setAttribute(CollapsiblePanelDataAttributes.startingStyle, "");
+      }
+      setDimensions({
+        height: panel.scrollHeight,
+        width: panel.scrollWidth
+      });
+      resizeFrame = AnimationFrame.request(() => {
+        Object.entries(originalLayoutStyles).forEach(([key, value]) => {
+          if (value === "") {
+            panel.style.removeProperty(key);
+          } else {
+            panel.style.setProperty(key, value);
+          }
+        });
+      });
+    } else {
+      if (panel.scrollHeight === 0 && panel.scrollWidth === 0) {
+        return void 0;
+      }
+      setDimensions({
+        height: panel.scrollHeight,
+        width: panel.scrollWidth
+      });
+      const abortController = new AbortController();
+      abortControllerRef.current = abortController;
+      const signal = abortController.signal;
+      let attributeObserver = null;
+      const endingStyleAttribute = CollapsiblePanelDataAttributes.endingStyle;
+      attributeObserver = new MutationObserver((mutationList) => {
+        const hasEndingStyle = mutationList.some((mutation) => mutation.type === "attributes" && mutation.attributeName === endingStyleAttribute);
+        if (hasEndingStyle) {
+          attributeObserver?.disconnect();
+          attributeObserver = null;
+          runOnceAnimationsFinish(() => {
+            setDimensions({
+              height: 0,
+              width: 0
+            });
+            panel.style.removeProperty("content-visibility");
+            setMounted(false);
+            if (abortControllerRef.current === abortController) {
+              abortControllerRef.current = null;
+            }
+          }, signal);
+        }
+      });
+      attributeObserver.observe(panel, {
+        attributes: true,
+        attributeFilter: [endingStyleAttribute]
+      });
+      return () => {
+        attributeObserver?.disconnect();
+        endingStyleFrame.cancel();
+        if (abortControllerRef.current === abortController) {
+          abortController.abort();
+          abortControllerRef.current = null;
+        }
+      };
+    }
+    return () => {
+      AnimationFrame.cancel(resizeFrame);
+    };
+  }, [abortControllerRef, animationTypeRef, endingStyleFrame, hiddenUntilFound, keepMounted, mounted, open, panelRef, runOnceAnimationsFinish, setDimensions, setMounted]);
+  useIsoLayoutEffect(() => {
+    if (animationTypeRef.current !== "css-animation") {
+      return;
+    }
+    const panel = panelRef.current;
+    if (!panel) {
+      return;
+    }
+    latestAnimationNameRef.current = panel.style.animationName || latestAnimationNameRef.current;
+    panel.style.setProperty("animation-name", "none");
+    setDimensions({
+      height: panel.scrollHeight,
+      width: panel.scrollWidth
+    });
+    if (!shouldCancelInitialOpenAnimationRef.current && !isBeforeMatchRef.current) {
+      panel.style.removeProperty("animation-name");
+    }
+    if (open) {
+      if (abortControllerRef.current != null) {
+        abortControllerRef.current.abort();
+        abortControllerRef.current = null;
+      }
+      setMounted(true);
+      setVisible(true);
+    } else {
+      abortControllerRef.current = new AbortController();
+      runOnceAnimationsFinish(() => {
+        setMounted(false);
+        setVisible(false);
+        abortControllerRef.current = null;
+      }, abortControllerRef.current.signal);
+    }
+  }, [abortControllerRef, animationTypeRef, open, panelRef, runOnceAnimationsFinish, setDimensions, setMounted, setVisible, visible]);
+  useOnMount(() => {
+    const frame = AnimationFrame.request(() => {
+      shouldCancelInitialOpenAnimationRef.current = false;
+    });
+    return () => AnimationFrame.cancel(frame);
+  });
+  useIsoLayoutEffect(() => {
+    if (!hiddenUntilFound) {
+      return void 0;
+    }
+    const panel = panelRef.current;
+    if (!panel) {
+      return void 0;
+    }
+    let frame = -1;
+    let nextFrame = -1;
+    if (open && isBeforeMatchRef.current) {
+      panel.style.transitionDuration = "0s";
+      setDimensions({
+        height: panel.scrollHeight,
+        width: panel.scrollWidth
+      });
+      frame = AnimationFrame.request(() => {
+        isBeforeMatchRef.current = false;
+        nextFrame = AnimationFrame.request(() => {
+          setTimeout(() => {
+            panel.style.removeProperty("transition-duration");
+          });
+        });
+      });
+    }
+    return () => {
+      AnimationFrame.cancel(frame);
+      AnimationFrame.cancel(nextFrame);
+    };
+  }, [hiddenUntilFound, open, panelRef, setDimensions]);
+  useIsoLayoutEffect(() => {
+    const panel = panelRef.current;
+    if (panel && hiddenUntilFound && hidden) {
+      panel.setAttribute("hidden", "until-found");
+      if (animationTypeRef.current === "css-transition") {
+        panel.setAttribute(CollapsiblePanelDataAttributes.startingStyle, "");
+      }
+    }
+  }, [hiddenUntilFound, hidden, animationTypeRef, panelRef]);
+  React27.useEffect(function registerBeforeMatchListener() {
+    const panel = panelRef.current;
+    if (!panel) {
+      return void 0;
+    }
+    function handleBeforeMatch(event) {
+      isBeforeMatchRef.current = true;
+      setOpen(true);
+      onOpenChange(true, createChangeEventDetails(reason_parts_exports.none, event));
+    }
+    panel.addEventListener("beforematch", handleBeforeMatch);
+    return () => {
+      panel.removeEventListener("beforematch", handleBeforeMatch);
+    };
+  }, [onOpenChange, panelRef, setOpen]);
+  return React27.useMemo(() => ({
+    props: {
+      hidden,
+      id: idParam,
+      ref: mergedPanelRef
+    }
+  }), [hidden, idParam, mergedPanelRef]);
+}
+
+// node_modules/@base-ui/react/esm/accordion/panel/AccordionPanelCssVars.js
+var AccordionPanelCssVars = /* @__PURE__ */ (function(AccordionPanelCssVars2) {
+  AccordionPanelCssVars2["accordionPanelHeight"] = "--accordion-panel-height";
+  AccordionPanelCssVars2["accordionPanelWidth"] = "--accordion-panel-width";
+  return AccordionPanelCssVars2;
+})({});
+
+// node_modules/@base-ui/react/esm/utils/useOpenChangeComplete.js
+import * as React28 from "react";
+function useOpenChangeComplete(parameters) {
+  const {
+    enabled = true,
+    open,
+    ref,
+    onComplete: onCompleteParam
+  } = parameters;
+  const onComplete = useStableCallback(onCompleteParam);
+  const runOnceAnimationsFinish = useAnimationsFinished(ref, open, false);
+  React28.useEffect(() => {
+    if (!enabled) {
+      return void 0;
+    }
+    const abortController = new AbortController();
+    runOnceAnimationsFinish(onComplete, abortController.signal);
+    return () => {
+      abortController.abort();
+    };
+  }, [enabled, open, onComplete, runOnceAnimationsFinish]);
+}
+
+// node_modules/@base-ui/react/esm/accordion/panel/AccordionPanel.js
+var AccordionPanel = /* @__PURE__ */ React29.forwardRef(function AccordionPanel2(componentProps, forwardedRef) {
+  const {
+    className,
+    hiddenUntilFound: hiddenUntilFoundProp,
+    keepMounted: keepMountedProp,
+    id: idProp,
+    render,
+    ...elementProps
+  } = componentProps;
+  const {
+    hiddenUntilFound: contextHiddenUntilFound,
+    keepMounted: contextKeepMounted
+  } = useAccordionRootContext();
+  const {
+    abortControllerRef,
+    animationTypeRef,
+    height,
+    mounted,
+    onOpenChange,
+    open,
+    panelId,
+    panelRef,
+    runOnceAnimationsFinish,
+    setDimensions,
+    setHiddenUntilFound,
+    setKeepMounted,
+    setMounted,
+    setOpen,
+    setVisible,
+    transitionDimensionRef,
+    visible,
+    width,
+    setPanelIdState,
+    transitionStatus
+  } = useCollapsibleRootContext();
+  const hiddenUntilFound = hiddenUntilFoundProp ?? contextHiddenUntilFound;
+  const keepMounted = keepMountedProp ?? contextKeepMounted;
+  if (true) {
+    useIsoLayoutEffect(() => {
+      if (keepMountedProp === false && hiddenUntilFound) {
+        warn("The `keepMounted={false}` prop on a Accordion.Panel will be ignored when using `contextHiddenUntilFound` on the Panel or the Root since it requires the panel to remain mounted when closed.");
+      }
+    }, [hiddenUntilFound, keepMountedProp]);
+  }
+  useIsoLayoutEffect(() => {
+    if (idProp) {
+      setPanelIdState(idProp);
+      return () => {
+        setPanelIdState(void 0);
+      };
+    }
+    return void 0;
+  }, [idProp, setPanelIdState]);
+  useIsoLayoutEffect(() => {
+    setHiddenUntilFound(hiddenUntilFound);
+  }, [setHiddenUntilFound, hiddenUntilFound]);
+  useIsoLayoutEffect(() => {
+    setKeepMounted(keepMounted);
+  }, [setKeepMounted, keepMounted]);
+  useOpenChangeComplete({
+    open: open && transitionStatus === "idle",
+    ref: panelRef,
+    onComplete() {
+      if (!open) {
+        return;
+      }
+      setDimensions({
+        width: void 0,
+        height: void 0
+      });
+    }
+  });
+  const {
+    props
+  } = useCollapsiblePanel({
+    abortControllerRef,
+    animationTypeRef,
+    externalRef: forwardedRef,
+    height,
+    hiddenUntilFound,
+    id: idProp ?? panelId,
+    keepMounted,
+    mounted,
+    onOpenChange,
+    open,
+    panelRef,
+    runOnceAnimationsFinish,
+    setDimensions,
+    setMounted,
+    setOpen,
+    setVisible,
+    transitionDimensionRef,
+    visible,
+    width
+  });
+  const {
+    state,
+    triggerId
+  } = useAccordionItemContext();
+  const panelState = React29.useMemo(() => ({
+    ...state,
+    transitionStatus
+  }), [state, transitionStatus]);
+  const element = useRenderElement("div", componentProps, {
+    state: panelState,
+    ref: [forwardedRef, panelRef],
+    props: [props, {
+      "aria-labelledby": triggerId,
+      role: "region",
+      style: {
+        [AccordionPanelCssVars.accordionPanelHeight]: height === void 0 ? "auto" : `${height}px`,
+        [AccordionPanelCssVars.accordionPanelWidth]: width === void 0 ? "auto" : `${width}px`
+      }
+    }, elementProps],
+    stateAttributesMapping: accordionStateAttributesMapping
+  });
+  const shouldRender = keepMounted || hiddenUntilFound || !keepMounted && mounted;
+  if (!shouldRender) {
+    return null;
+  }
+  return element;
+});
+if (true) AccordionPanel.displayName = "AccordionPanel";
+
+// src/runtime/components/Disclosure.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function Disclosure({ title, children }) {
+  return /* @__PURE__ */ jsx2(index_parts_exports.Root, { className: "rounded-[var(--radius-lg)] border border-[color:var(--color-border)] bg-white/70 dark:bg-white/5", children: /* @__PURE__ */ jsxs2(index_parts_exports.Item, { value: "item-1", children: [
+    /* @__PURE__ */ jsx2(index_parts_exports.Header, { children: /* @__PURE__ */ jsxs2(index_parts_exports.Trigger, { className: "flex w-full items-center justify-between px-5 py-4 text-left text-xl font-semibold", children: [
+      /* @__PURE__ */ jsx2("span", { children: title }),
+      /* @__PURE__ */ jsx2("span", { "aria-hidden": "true", children: "+" })
+    ] }) }),
+    /* @__PURE__ */ jsx2(index_parts_exports.Panel, { className: "px-5 pb-5 text-lg text-[color:var(--color-foreground)]/80", children })
+  ] }) });
+}
+
+// src/runtime/components/Frame.tsx
+import { jsx as jsx3 } from "react/jsx-runtime";
+function Frame({ children }) {
+  return /* @__PURE__ */ jsx3("div", { className: "rounded-[var(--radius-xl)] border border-[color:var(--color-border)] bg-white/70 p-8 shadow-xl shadow-black/10 dark:bg-white/5", children });
+}
+
+// src/runtime/components/Center.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function Center({
+  children,
+  className
+}) {
+  return /* @__PURE__ */ jsx4(
+    "div",
+    {
+      className: `flex gap-4 flex-col items-center justify-center *:text-center ${className}`,
+      children
+    }
+  );
+}
+
+// src/runtime/default-components.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+function cx(...values) {
+  return values.filter(Boolean).join(" ");
+}
+function toClassName(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    const className = value.flatMap(
+      (entry) => typeof entry === "string" ? entry.split(/\s+/) : []
+    ).filter(Boolean).join(" ");
+    return className || void 0;
+  }
+  return void 0;
+}
+function isBlockCode(className, props) {
+  const normalizedClassName = toClassName(className) ?? "";
+  return "data-code-block" in props || normalizedClassName.includes("language-") || normalizedClassName.includes("deck-code-content");
+}
+function createDefaultComponents() {
+  return {
+    h1: (props) => /* @__PURE__ */ jsx5(
+      "h1",
+      {
+        className: "text-6xl font-semibold tracking-tight text-balance",
+        ...props
+      }
+    ),
+    h2: (props) => /* @__PURE__ */ jsx5(
+      "h2",
+      {
+        className: "text-4xl font-semibold tracking-tight text-balance",
+        ...props
+      }
+    ),
+    h3: (props) => /* @__PURE__ */ jsx5("h3", { className: "text-2xl font-semibold tracking-tight", ...props }),
+    p: (props) => /* @__PURE__ */ jsx5(
+      "p",
+      {
+        className: "text-2xl leading-relaxed text-[color:var(--color-foreground)]/90",
+        ...props
+      }
+    ),
+    a: (props) => /* @__PURE__ */ jsx5(
+      "a",
+      {
+        className: "text-[color:var(--color-accent)] underline decoration-2 underline-offset-4",
+        ...props
+      }
+    ),
+    ul: (props) => /* @__PURE__ */ jsx5("ul", { className: "list-disc space-y-3 pl-8 text-2xl", ...props }),
+    ol: (props) => /* @__PURE__ */ jsx5("ol", { className: "list-decimal space-y-3 pl-8 text-2xl", ...props }),
+    li: (props) => /* @__PURE__ */ jsx5("li", { className: "pl-2", ...props }),
+    code: ({ className, ...props }) => /* @__PURE__ */ jsx5(
+      "code",
+      {
+        className: isBlockCode(className, props) ? toClassName(className) : cx(
+          "rounded-md bg-black/10 px-2 py-1 font-mono text-[0.9em] dark:bg-white/10",
+          toClassName(className)
+        ),
+        ...props
+      }
+    ),
+    pre: ({ className, ...props }) => /* @__PURE__ */ jsx5(
+      "pre",
+      {
+        className: cx(
+          "overflow-x-auto rounded-[var(--radius-lg)] border border-[color:var(--color-border)] bg-[color:var(--color-code-bg)] p-6 text-lg",
+          toClassName(className)
+        ),
+        ...props
+      }
+    ),
+    table: ({ className, ...props }) => /* @__PURE__ */ jsx5("div", { className: "deck-table-wrap", children: /* @__PURE__ */ jsx5("table", { className: cx("deck-table", className), ...props }) }),
+    thead: ({ className, ...props }) => /* @__PURE__ */ jsx5("thead", { className: cx("deck-thead", className), ...props }),
+    tbody: ({ className, ...props }) => /* @__PURE__ */ jsx5("tbody", { className: cx("deck-tbody", className), ...props }),
+    tr: ({ className, ...props }) => /* @__PURE__ */ jsx5("tr", { className: cx("deck-tr", className), ...props }),
+    th: ({ className, ...props }) => /* @__PURE__ */ jsx5("th", { className: cx("deck-th", className), ...props }),
+    td: ({ className, ...props }) => /* @__PURE__ */ jsx5("td", { className: cx("deck-td", className), ...props }),
+    blockquote: (props) => /* @__PURE__ */ jsx5(
+      "blockquote",
+      {
+        className: "border-l-4 border-[color:var(--color-accent)] pl-6 text-2xl italic",
+        ...props
+      }
+    ),
+    Callout,
+    Columns,
+    Disclosure,
+    Frame,
+    Center
+  };
+}
+function mergeComponents(theme) {
+  return {
+    ...createDefaultComponents(),
+    ...theme?.components ?? {}
+  };
+}
+
+// src/runtime/hooks/slides.ts
+import { useEffect as useEffect7, useState as useState8 } from "react";
+
+// src/runtime/utils/use-current-slide.ts
+function parseAspectRatio(input) {
+  const value = String(input ?? "16:9");
+  const parts = value.split(":").map((part) => Number(part.trim()));
+  if (parts.length !== 2 || parts.some((part) => !Number.isFinite(part) || part <= 0)) {
+    return "16 / 9";
+  }
+  return `${parts[0]} / ${parts[1]}`;
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function getHashIndex(total) {
+  const raw = Number(window.location.hash.replace("#", ""));
+  if (!Number.isFinite(raw) || raw < 1) {
+    return 0;
+  }
+  return clamp(raw - 1, 0, Math.max(total - 1, 0));
+}
+
+// src/runtime/hooks/slides.ts
+function useCurrentSlide(total) {
+  const [index, setIndex] = useState8(() => getHashIndex(total));
+  useEffect7(() => {
+    const onHashChange = () => setIndex(getHashIndex(total));
+    window.addEventListener("hashchange", onHashChange);
+    return () => window.removeEventListener("hashchange", onHashChange);
+  }, [total]);
+  useEffect7(() => {
+    const nextHash = `#${index + 1}`;
+    if (window.location.hash !== nextHash) {
+      history.replaceState(
+        null,
+        "",
+        `${window.location.pathname}${window.location.search}${nextHash}`
+      );
+    }
+  }, [index]);
+  useEffect7(() => {
+    const onKeyDown = (event) => {
+      if (event.metaKey || event.ctrlKey || event.altKey) {
+        return;
+      }
+      if (["ArrowRight", "ArrowDown", "PageDown", " "].includes(event.key)) {
+        event.preventDefault();
+        setIndex((current) => clamp(current + 1, 0, total - 1));
+      }
+      if (["ArrowLeft", "ArrowUp", "PageUp"].includes(event.key)) {
+        event.preventDefault();
+        setIndex((current) => clamp(current - 1, 0, total - 1));
+      }
+      if (event.key === "Home") {
+        event.preventDefault();
+        setIndex(0);
+      }
+      if (event.key === "End") {
+        event.preventDefault();
+        setIndex(total - 1);
+      }
+    };
+    window.addEventListener("keydown", onKeyDown);
+    return () => window.removeEventListener("keydown", onKeyDown);
+  }, [total]);
+  useEffect7(() => {
+    setIndex((current) => clamp(current, 0, Math.max(total - 1, 0)));
+  }, [total]);
+  return [index, setIndex];
+}
+
+// src/runtime/layout/SlideFrame.tsx
+import { jsx as jsx6, jsxs as jsxs3 } from "react/jsx-runtime";
+function SlideFrame({
+  children,
+  config,
+  index,
+  total,
+  printMode
+}) {
+  const ratio = parseAspectRatio(config.aspectRatio);
+  return /* @__PURE__ */ jsx6(
+    "section",
+    {
+      className: `slide-frame ${printMode ? "slide-frame-print" : ""}`,
+      style: { "--slide-aspect-ratio": ratio },
+      "data-transition": config.transition,
+      children: /* @__PURE__ */ jsxs3("div", { className: "slide-surface", children: [
+        /* @__PURE__ */ jsx6("div", { className: "slide-content", children }),
+        config.showSlideNumbers ? /* @__PURE__ */ jsx6("div", { className: "slide-footer", children: /* @__PURE__ */ jsxs3("span", { children: [
+          index + 1,
+          " / ",
+          total
+        ] }) }) : null
+      ] })
+    }
+  );
+}
+
+// src/runtime/layout/DeckSlide.tsx
+import { jsx as jsx7 } from "react/jsx-runtime";
+function DeckSlide({
+  slide,
+  config,
+  total,
+  index,
+  printMode,
+  components
+}) {
+  const Slide = slide.Component;
+  return /* @__PURE__ */ jsx7(
+    SlideFrame,
+    {
+      config,
+      index,
+      total,
+      printMode,
+      children: /* @__PURE__ */ jsx7(Slide, { components })
+    }
+  );
+}
+
+// src/runtime/primitives/DeckProgress.tsx
+import { jsx as jsx8 } from "react/jsx-runtime";
+function DeckProgress({ currentIndex, total }) {
+  const width = total > 0 ? `${(currentIndex + 1) / total * 100}%` : "0%";
+  return /* @__PURE__ */ jsx8("div", { className: "deck-progress", children: /* @__PURE__ */ jsx8("div", { className: "deck-progress-bar", style: { width } }) });
+}
+
+// src/runtime/primitives/DeckTitle.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+function DeckTitle({ title }) {
+  return /* @__PURE__ */ jsx9("div", { className: "deck-title", children: title });
+}
+
+// src/runtime/primitives/DeckChrome.tsx
+import { jsx as jsx10, jsxs as jsxs4 } from "react/jsx-runtime";
+function DeckChrome({ title, currentIndex, total }) {
+  return /* @__PURE__ */ jsxs4("div", { className: "deck-chrome", children: [
+    /* @__PURE__ */ jsx10(DeckTitle, { title }),
+    /* @__PURE__ */ jsx10(DeckProgress, { currentIndex, total })
+  ] });
+}
+
+// src/runtime/primitives/DeckNavigation.tsx
+import { jsx as jsx11, jsxs as jsxs5 } from "react/jsx-runtime";
+function DeckNavigation({ onPrevious, onNext }) {
+  return /* @__PURE__ */ jsxs5("div", { className: "deck-nav", children: [
+    /* @__PURE__ */ jsx11("button", { className: "deck-button", type: "button", onClick: onPrevious, children: "Prev" }),
+    /* @__PURE__ */ jsx11("button", { className: "deck-button", type: "button", onClick: onNext, children: "Next" })
+  ] });
+}
+
+// src/runtime/themes/base/DefaultDeck.tsx
+import { jsx as jsx12, jsxs as jsxs6 } from "react/jsx-runtime";
+function DefaultDeck({
+  config,
+  slides,
+  currentIndex,
+  setCurrentIndex,
+  printMode,
+  components,
+  helpers
+}) {
+  if (printMode) {
+    return /* @__PURE__ */ jsx12("main", { className: "print-deck", children: slides.map((slide, slideIndex) => /* @__PURE__ */ jsx12(
+      DeckSlide,
+      {
+        slide,
+        config,
+        total: slides.length,
+        index: slideIndex,
+        printMode: true,
+        components
+      },
+      slideIndex
+    )) });
+  }
+  return /* @__PURE__ */ jsxs6("main", { className: "app-shell", children: [
+    /* @__PURE__ */ jsx12(DeckChrome, { title: config.title, currentIndex, total: slides.length }),
+    /* @__PURE__ */ jsx12("div", { className: "deck-stage", children: /* @__PURE__ */ jsx12(
+      DeckSlide,
+      {
+        slide: slides[currentIndex],
+        config,
+        total: slides.length,
+        index: currentIndex,
+        components
+      }
+    ) }),
+    /* @__PURE__ */ jsx12(
+      DeckNavigation,
+      {
+        onPrevious: () => setCurrentIndex((value) => helpers.clamp(value - 1, 0, slides.length - 1)),
+        onNext: () => setCurrentIndex((value) => helpers.clamp(value + 1, 0, slides.length - 1))
+      }
+    )
+  ] });
+}
+export {
+  Callout,
+  Columns,
+  DeckChrome,
+  DeckNavigation,
+  DeckProgress,
+  DeckSlide,
+  DeckTitle,
+  DefaultDeck,
+  Disclosure,
+  Frame,
+  SlideFrame,
+  clamp,
+  createDefaultComponents,
+  getHashIndex,
+  mergeComponents,
+  parseAspectRatio,
+  useCurrentSlide
+};