@ariakit/react 0.4.25 → 0.4.27

package/cjs/__chunks/D4HCGWOU.cjs

@@ -0,0 +1,464 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _QAUJZR6Ycjs = require('./QAUJZR6Y.cjs');
+
+// ../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@18.3.1/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.js
+var require_use_sync_external_store_shim_production = _QAUJZR6Ycjs.__commonJS.call(void 0, {
+  "../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@18.3.1/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.js"(exports) {
+    "use strict";
+    var React2 = _QAUJZR6Ycjs.__require.call(void 0, "react");
+    function is(x, y) {
+      return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+    }
+    var objectIs = "function" === typeof Object.is ? Object.is : is;
+    var useState2 = React2.useState;
+    var useEffect = React2.useEffect;
+    var useLayoutEffect = React2.useLayoutEffect;
+    var useDebugValue = React2.useDebugValue;
+    function useSyncExternalStore$2(subscribe2, getSnapshot) {
+      var value = getSnapshot(), _useState = useState2({ inst: { value, getSnapshot } }), inst = _useState[0].inst, forceUpdate = _useState[1];
+      useLayoutEffect(
+        function() {
+          inst.value = value;
+          inst.getSnapshot = getSnapshot;
+          checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+        },
+        [subscribe2, value, getSnapshot]
+      );
+      useEffect(
+        function() {
+          checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+          return subscribe2(function() {
+            checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+          });
+        },
+        [subscribe2]
+      );
+      useDebugValue(value);
+      return value;
+    }
+    function checkIfSnapshotChanged(inst) {
+      var latestGetSnapshot = inst.getSnapshot;
+      inst = inst.value;
+      try {
+        var nextValue = latestGetSnapshot();
+        return !objectIs(inst, nextValue);
+      } catch (error) {
+        return true;
+      }
+    }
+    function useSyncExternalStore$1(subscribe2, getSnapshot) {
+      return getSnapshot();
+    }
+    var shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+    exports.useSyncExternalStore = void 0 !== React2.useSyncExternalStore ? React2.useSyncExternalStore : shim;
+  }
+});
+
+// ../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@18.3.1/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js
+var require_use_sync_external_store_shim_development = _QAUJZR6Ycjs.__commonJS.call(void 0, {
+  "../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@18.3.1/node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js"(exports) {
+    "use strict";
+    "production" !== process.env.NODE_ENV && (function() {
+      function is(x, y) {
+        return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+      }
+      function useSyncExternalStore$2(subscribe2, getSnapshot) {
+        didWarnOld18Alpha || void 0 === React2.startTransition || (didWarnOld18Alpha = true, console.error(
+          "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+        ));
+        var value = getSnapshot();
+        if (!didWarnUncachedGetSnapshot) {
+          var cachedValue = getSnapshot();
+          objectIs(value, cachedValue) || (console.error(
+            "The result of getSnapshot should be cached to avoid an infinite loop"
+          ), didWarnUncachedGetSnapshot = true);
+        }
+        cachedValue = useState2({
+          inst: { value, getSnapshot }
+        });
+        var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
+        useLayoutEffect(
+          function() {
+            inst.value = value;
+            inst.getSnapshot = getSnapshot;
+            checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+          },
+          [subscribe2, value, getSnapshot]
+        );
+        useEffect(
+          function() {
+            checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+            return subscribe2(function() {
+              checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+            });
+          },
+          [subscribe2]
+        );
+        useDebugValue(value);
+        return value;
+      }
+      function checkIfSnapshotChanged(inst) {
+        var latestGetSnapshot = inst.getSnapshot;
+        inst = inst.value;
+        try {
+          var nextValue = latestGetSnapshot();
+          return !objectIs(inst, nextValue);
+        } catch (error) {
+          return true;
+        }
+      }
+      function useSyncExternalStore$1(subscribe2, getSnapshot) {
+        return getSnapshot();
+      }
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var React2 = _QAUJZR6Ycjs.__require.call(void 0, "react"), objectIs = "function" === typeof Object.is ? Object.is : is, useState2 = React2.useState, useEffect = React2.useEffect, useLayoutEffect = React2.useLayoutEffect, useDebugValue = React2.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+      exports.useSyncExternalStore = void 0 !== React2.useSyncExternalStore ? React2.useSyncExternalStore : shim;
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    })();
+  }
+});
+
+// ../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@18.3.1/node_modules/use-sync-external-store/shim/index.js
+var require_shim = _QAUJZR6Ycjs.__commonJS.call(void 0, {
+  "../../node_modules/.pnpm/use-sync-external-store@1.6.0_react@18.3.1/node_modules/use-sync-external-store/shim/index.js"(exports, module) {
+    "use strict";
+    if (process.env.NODE_ENV === "production") {
+      module.exports = require_use_sync_external_store_shim_production();
+    } else {
+      module.exports = require_use_sync_external_store_shim_development();
+    }
+  }
+});
+
+// ../ariakit-store/dist/index.js
+function getInternal(store, key) {
+  const internals = store.__unstableInternals;
+  _QAUJZR6Ycjs.invariant.call(void 0, internals, "Invalid store");
+  return internals[key];
+}
+function createStore(initialState, ...stores) {
+  let state = initialState;
+  let prevStateBatch = state;
+  let lastUpdate = /* @__PURE__ */ Symbol();
+  let destroy = _QAUJZR6Ycjs.noop;
+  const instances = /* @__PURE__ */ new Set();
+  const updatedKeys = /* @__PURE__ */ new Set();
+  const setups = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set();
+  const batchListeners = /* @__PURE__ */ new Set();
+  const disposables = /* @__PURE__ */ new WeakMap();
+  const listenerKeys = /* @__PURE__ */ new WeakMap();
+  const storeSetup = (callback) => {
+    setups.add(callback);
+    return () => setups.delete(callback);
+  };
+  const storeInit = () => {
+    const initialized = instances.size;
+    const instance = /* @__PURE__ */ Symbol();
+    instances.add(instance);
+    const maybeDestroy = () => {
+      instances.delete(instance);
+      if (instances.size) return;
+      destroy();
+    };
+    if (initialized) return maybeDestroy;
+    const desyncs = _QAUJZR6Ycjs.getKeys.call(void 0, state).map((key) => _QAUJZR6Ycjs.chain.call(void 0, ...stores.map((store) => {
+      var _a;
+      const storeState = (_a = store == null ? void 0 : store.getState) == null ? void 0 : _a.call(store);
+      if (!storeState) return;
+      if (!_QAUJZR6Ycjs.hasOwnProperty.call(void 0, storeState, key)) return;
+      return sync(store, [key], (state2) => {
+        setState(key, state2[key], true);
+      });
+    })));
+    const teardowns = [];
+    for (const setup2 of setups) teardowns.push(setup2());
+    const cleanups = stores.map(init);
+    destroy = _QAUJZR6Ycjs.chain.call(void 0, ...desyncs, ...teardowns, ...cleanups);
+    return maybeDestroy;
+  };
+  const sub = (keys, listener, set = listeners) => {
+    set.add(listener);
+    listenerKeys.set(listener, keys);
+    return () => {
+      var _a;
+      (_a = disposables.get(listener)) == null ? void 0 : _a();
+      disposables.delete(listener);
+      listenerKeys.delete(listener);
+      set.delete(listener);
+    };
+  };
+  const storeSubscribe = (keys, listener) => sub(keys, listener);
+  const storeSync = (keys, listener) => {
+    disposables.set(listener, listener(state, state));
+    return sub(keys, listener);
+  };
+  const storeBatch = (keys, listener) => {
+    disposables.set(listener, listener(state, prevStateBatch));
+    return sub(keys, listener, batchListeners);
+  };
+  const storePick = (keys) => createStore(_QAUJZR6Ycjs.pick.call(void 0, state, keys), finalStore);
+  const storeOmit = (keys) => createStore(_QAUJZR6Ycjs.omit.call(void 0, state, keys), finalStore);
+  const getState = () => state;
+  const setState = (key, value, fromStores = false) => {
+    var _a;
+    if (!_QAUJZR6Ycjs.hasOwnProperty.call(void 0, state, key)) return;
+    const nextValue = _QAUJZR6Ycjs.applyState.call(void 0, value, state[key]);
+    if (nextValue === state[key]) return;
+    if (!fromStores) for (const store of stores) (_a = store == null ? void 0 : store.setState) == null ? void 0 : _a.call(store, key, nextValue);
+    const prevState = state;
+    state = {
+      ...state,
+      [key]: nextValue
+    };
+    const thisUpdate = /* @__PURE__ */ Symbol();
+    lastUpdate = thisUpdate;
+    updatedKeys.add(key);
+    const run = (listener, prev, uKeys) => {
+      var _a2;
+      const keys = listenerKeys.get(listener);
+      const updated = (k) => uKeys ? uKeys.has(k) : k === key;
+      if (!keys || keys.some(updated)) {
+        (_a2 = disposables.get(listener)) == null ? void 0 : _a2();
+        disposables.set(listener, listener(state, prev));
+      }
+    };
+    for (const listener of listeners) run(listener, prevState);
+    queueMicrotask(() => {
+      if (lastUpdate !== thisUpdate) return;
+      const snapshot = state;
+      for (const listener of batchListeners) run(listener, prevStateBatch, updatedKeys);
+      prevStateBatch = snapshot;
+      updatedKeys.clear();
+    });
+  };
+  const finalStore = {
+    getState,
+    setState,
+    __unstableInternals: {
+      setup: storeSetup,
+      init: storeInit,
+      subscribe: storeSubscribe,
+      sync: storeSync,
+      batch: storeBatch,
+      pick: storePick,
+      omit: storeOmit
+    }
+  };
+  return finalStore;
+}
+function setup(store, ...args) {
+  if (!store) return;
+  return getInternal(store, "setup")(...args);
+}
+function init(store, ...args) {
+  if (!store) return;
+  return getInternal(store, "init")(...args);
+}
+function subscribe(store, ...args) {
+  if (!store) return;
+  return getInternal(store, "subscribe")(...args);
+}
+function sync(store, ...args) {
+  if (!store) return;
+  return getInternal(store, "sync")(...args);
+}
+function batch(store, ...args) {
+  if (!store) return;
+  return getInternal(store, "batch")(...args);
+}
+function omit2(store, ...args) {
+  if (!store) return;
+  return getInternal(store, "omit")(...args);
+}
+function pick2(store, ...args) {
+  if (!store) return;
+  return getInternal(store, "pick")(...args);
+}
+function mergeStore(...stores) {
+  var _a;
+  const initialState = {};
+  for (const store2 of stores) {
+    const nextState = (_a = store2 == null ? void 0 : store2.getState) == null ? void 0 : _a.call(store2);
+    if (nextState) Object.assign(initialState, nextState);
+  }
+  const store = createStore(initialState, ...stores);
+  return Object.assign({}, ...stores, store);
+}
+function throwOnConflictingProps(props, store) {
+  if (!store) return;
+  const defaultKeys = Object.entries(props).filter(([key, value]) => key.startsWith("default") && value !== void 0).map(([key]) => {
+    var _a;
+    const stateKey = key.replace("default", "");
+    return `${((_a = stateKey[0]) == null ? void 0 : _a.toLowerCase()) || ""}${stateKey.slice(1)}`;
+  });
+  if (!defaultKeys.length) return;
+  const storeState = store.getState();
+  if (!defaultKeys.filter((key) => _QAUJZR6Ycjs.hasOwnProperty.call(void 0, storeState, key)).length) return;
+  throw new Error(`Passing a store prop in conjunction with a default state is not supported.
+
+const store = useSelectStore();
+<SelectProvider store={store} defaultValue="Apple" />
+                ^             ^
+
+Instead, pass the default state to the topmost store:
+
+const store = useSelectStore({ defaultValue: "Apple" });
+<SelectProvider store={store} />
+
+See https://github.com/ariakit/ariakit/pull/2745 for more details.
+
+If there's a particular need for this, please submit a feature request at https://github.com/ariakit/ariakit
+`);
+}
+
+// ../ariakit-react-store/dist/index.js
+var import_shim = _QAUJZR6Ycjs.__toESM.call(void 0, require_shim(), 1);
+var _react = require('react'); var React = _interopRequireWildcard(_react);
+var noopSubscribe = () => () => {
+};
+function useStoreState(store, keyOrSelector = _QAUJZR6Ycjs.identity) {
+  const storeSubscribe = React.useCallback((callback) => {
+    if (!store) return noopSubscribe();
+    return subscribe(store, null, callback);
+  }, [store]);
+  const getSnapshot = () => {
+    const key = typeof keyOrSelector === "string" ? keyOrSelector : null;
+    const selector = typeof keyOrSelector === "function" ? keyOrSelector : null;
+    const state = store == null ? void 0 : store.getState();
+    if (selector) return selector(state);
+    if (!state) return;
+    if (!key) return;
+    if (!_QAUJZR6Ycjs.hasOwnProperty.call(void 0, state, key)) return;
+    return state[key];
+  };
+  return (0, import_shim.useSyncExternalStore)(storeSubscribe, getSnapshot, getSnapshot);
+}
+function useStoreStateObject(store, object) {
+  const objRef = React.useRef({});
+  const storeSubscribe = React.useCallback((callback) => {
+    if (!store) return noopSubscribe();
+    return subscribe(store, null, callback);
+  }, [store]);
+  const getSnapshot = () => {
+    const state = store == null ? void 0 : store.getState();
+    let updated = false;
+    const obj = objRef.current;
+    for (const prop in object) {
+      const keyOrSelector = object[prop];
+      if (typeof keyOrSelector === "function") {
+        const value = keyOrSelector(state);
+        if (value !== obj[prop]) {
+          obj[prop] = value;
+          updated = true;
+        }
+      }
+      if (typeof keyOrSelector === "string") {
+        if (!state) continue;
+        if (!_QAUJZR6Ycjs.hasOwnProperty.call(void 0, state, keyOrSelector)) continue;
+        const value = state[keyOrSelector];
+        if (value !== obj[prop]) {
+          obj[prop] = value;
+          updated = true;
+        }
+      }
+    }
+    if (updated) objRef.current = { ...obj };
+    return objRef.current;
+  };
+  return (0, import_shim.useSyncExternalStore)(storeSubscribe, getSnapshot, getSnapshot);
+}
+function useStoreProps(store, props, key, setKey) {
+  const value = _QAUJZR6Ycjs.hasOwnProperty.call(void 0, props, key) ? props[key] : void 0;
+  const propsRef = _QAUJZR6Ycjs.useLiveRef.call(void 0, {
+    value,
+    setValue: setKey ? props[setKey] : void 0
+  });
+  _QAUJZR6Ycjs.useSafeLayoutEffect.call(void 0, () => {
+    return sync(store, [key], (state, prev) => {
+      const { value: value2, setValue } = propsRef.current;
+      if (!setValue) return;
+      if (state[key] === prev[key]) return;
+      if (state[key] === value2) return;
+      setValue(state[key]);
+    });
+  }, [store, key]);
+  _QAUJZR6Ycjs.useSafeLayoutEffect.call(void 0, () => {
+    if (value === void 0) return;
+    store.setState(key, value);
+    return batch(store, [key], () => {
+      if (value === void 0) return;
+      store.setState(key, value);
+    });
+  });
+}
+function useStore(createStore2, props) {
+  const [store, setStore] = React.useState(() => createStore2(props));
+  _QAUJZR6Ycjs.useSafeLayoutEffect.call(void 0, () => init(store), [store]);
+  const useState2 = React.useCallback((keyOrSelector) => useStoreState(store, keyOrSelector), [store]);
+  return [React.useMemo(() => ({
+    ...store,
+    useState: useState2
+  }), [store, useState2]), _QAUJZR6Ycjs.useEvent.call(void 0, () => {
+    setStore((store2) => createStore2({
+      ...props,
+      ...store2.getState()
+    }));
+  })];
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.createStore = createStore; exports.setup = setup; exports.init = init; exports.subscribe = subscribe; exports.sync = sync; exports.batch = batch; exports.omit = omit2; exports.pick = pick2; exports.mergeStore = mergeStore; exports.throwOnConflictingProps = throwOnConflictingProps; exports.useStoreState = useStoreState; exports.useStoreStateObject = useStoreStateObject; exports.useStoreProps = useStoreProps; exports.useStore = useStore;
+/*! Bundled license information:
+
+use-sync-external-store/cjs/use-sync-external-store-shim.production.js:
+  (**
+   * @license React
+   * use-sync-external-store-shim.production.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
+use-sync-external-store/cjs/use-sync-external-store-shim.development.js:
+  (**
+   * @license React
+   * use-sync-external-store-shim.development.js
+   *
+   * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+*/

package/cjs/__chunks/DVWS2XPY.cjs

@@ -0,0 +1,107 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _XH4GE3VEcjs = require('./XH4GE3VE.cjs');
+
+
+
+
+var _FIPBE5IXcjs = require('./FIPBE5IX.cjs');
+
+
+var _FVIS5BFZcjs = require('./FVIS5BFZ.cjs');
+
+
+var _D4HCGWOUcjs = require('./D4HCGWOU.cjs');
+
+
+
+
+
+
+
+
+var _QAUJZR6Ycjs = require('./QAUJZR6Y.cjs');
+
+// ../ariakit-react-components/dist/popover/popover-disclosure.js
+var _jsxruntime = require('react/jsx-runtime');
+var TagName = "button";
+var usePopoverDisclosure = _QAUJZR6Ycjs.createHook.call(void 0, function usePopoverDisclosure2({ store, ...props }) {
+  const context = _FIPBE5IXcjs.usePopoverProviderContext.call(void 0, );
+  store = store || context;
+  _QAUJZR6Ycjs.invariant.call(void 0, store, "PopoverDisclosure must receive a `store` prop or be wrapped in a PopoverProvider component.");
+  const onClickProp = props.onClick;
+  const onClick = _QAUJZR6Ycjs.useEvent.call(void 0, (event) => {
+    store == null ? void 0 : store.setAnchorElement(event.currentTarget);
+    onClickProp == null ? void 0 : onClickProp(event);
+  });
+  props = _QAUJZR6Ycjs.useWrapElement.call(void 0, props, (element) => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, _FIPBE5IXcjs.PopoverScopedContextProvider, {
+    value: store,
+    children: element
+  }), [store]);
+  props = {
+    ...props,
+    onClick
+  };
+  props = _XH4GE3VEcjs.usePopoverAnchor.call(void 0, {
+    store,
+    ...props
+  });
+  props = _FVIS5BFZcjs.useDialogDisclosure.call(void 0, {
+    store,
+    ...props
+  });
+  return props;
+});
+var PopoverDisclosure = _QAUJZR6Ycjs.forwardRef.call(void 0, function PopoverDisclosure2(props) {
+  return _QAUJZR6Ycjs.createElement.call(void 0, TagName, usePopoverDisclosure(props));
+});
+
+// ../ariakit-react-components/dist/popover/popover-disclosure-arrow.js
+var _react = require('react');
+
+var TagName2 = "span";
+var pointsMap = {
+  top: "4,10 8,6 12,10",
+  right: "6,4 10,8 6,12",
+  bottom: "4,6 8,10 12,6",
+  left: "10,4 6,8 10,12"
+};
+var usePopoverDisclosureArrow = _QAUJZR6Ycjs.createHook.call(void 0, function usePopoverDisclosureArrow2({ store, placement, ...props }) {
+  const context = _FIPBE5IXcjs.usePopoverContext.call(void 0, );
+  store = store || context;
+  _QAUJZR6Ycjs.invariant.call(void 0, store, "PopoverDisclosureArrow must be wrapped in a PopoverDisclosure component.");
+  const points = pointsMap[_D4HCGWOUcjs.useStoreState.call(void 0, store, (state) => placement || state.placement).split("-")[0]];
+  props = {
+    children: _react.useMemo.call(void 0, () => /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "svg", {
+      display: "block",
+      fill: "none",
+      stroke: "currentColor",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      strokeWidth: 1.5,
+      viewBox: "0 0 16 16",
+      height: "1em",
+      width: "1em",
+      children: /* @__PURE__ */ _jsxruntime.jsx.call(void 0, "polyline", { points })
+    }), [points]),
+    "aria-hidden": true,
+    ...props,
+    style: {
+      width: "1em",
+      height: "1em",
+      pointerEvents: "none",
+      ...props.style
+    }
+  };
+  return _QAUJZR6Ycjs.removeUndefinedValues.call(void 0, props);
+});
+var PopoverDisclosureArrow = _QAUJZR6Ycjs.forwardRef.call(void 0, function PopoverDisclosureArrow2(props) {
+  return _QAUJZR6Ycjs.createElement.call(void 0, TagName2, usePopoverDisclosureArrow(props));
+});
+
+
+
+
+
+
+exports.usePopoverDisclosure = usePopoverDisclosure; exports.PopoverDisclosure = PopoverDisclosure; exports.usePopoverDisclosureArrow = usePopoverDisclosureArrow; exports.PopoverDisclosureArrow = PopoverDisclosureArrow;

package/cjs/__chunks/DWSXHZYM.cjs

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// ../ariakit-react-components/dist/heading/heading-context.js
+var _react = require('react');
+var HeadingContext = _react.createContext.call(void 0, 0);
+
+// ../ariakit-react-components/dist/heading/heading-level.js
+
+var _jsxruntime = require('react/jsx-runtime');
+function HeadingLevel({ level, children }) {
+  const contextLevel = _react.useContext.call(void 0, HeadingContext);
+  const nextLevel = Math.max(Math.min(level || contextLevel + 1, 6), 1);
+  return /* @__PURE__ */ _jsxruntime.jsx.call(void 0, HeadingContext.Provider, {
+    value: nextLevel,
+    children
+  });
+}
+
+
+
+
+exports.HeadingContext = HeadingContext; exports.HeadingLevel = HeadingLevel;

package/cjs/__chunks/E6EV2Q5P.cjs

@@ -0,0 +1 @@
+"use strict";