@loczer/storefront-sdk 0.147.0 → 0.149.0

package/dist/chunks/pkg/ui/dist/node_modules/@base-ui/utils/esm/store/ReactStore-CfPgecP0.js

@@ -0,0 +1,145 @@
+import * as c from "react";
+import { Store as a } from "./Store-CRAQANWM.js";
+import { useStore as l } from "./useStore-BsRFFm2l.js";
+import { useStableCallback as h } from "../useStableCallback-DyHa2qMJ.js";
+import { useIsoLayoutEffect as u } from "../useIsoLayoutEffect-oOMudEAz.js";
+import { NOOP as d } from "../empty-C3-x9M2q.js";
+class v extends a {
+  /**
+   * Creates a new ReactStore instance.
+   *
+   * @param state Initial state of the store.
+   * @param context Non-reactive context values.
+   * @param selectors Optional selectors for use with `useState`.
+   */
+  constructor(e, t = {}, s) {
+    super(e), this.context = t, this.selectors = s;
+  }
+  /**
+   * Non-reactive values such as refs, callbacks, etc.
+   */
+  /**
+   * Synchronizes a single external value into the store.
+   *
+   * Note that the while the value in `state` is updated immediately, the value returned
+   * by `useState` is updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValue(e, t) {
+    c.useDebugValue(e), u(() => {
+      this.state[e] !== t && this.set(e, t);
+    }, [e, t]);
+  }
+  /**
+   * Synchronizes a single external value into the store and
+   * cleans it up (sets to `undefined`) on unmount.
+   *
+   * Note that the while the value in `state` is updated immediately, the value returned
+   * by `useState` is updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValueWithCleanup(e, t) {
+    const s = this;
+    u(() => (s.state[e] !== t && s.set(e, t), () => {
+      s.set(e, void 0);
+    }), [s, e, t]);
+  }
+  /**
+   * Synchronizes multiple external values into the store.
+   *
+   * Note that the while the values in `state` are updated immediately, the values returned
+   * by `useState` are updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValues(e) {
+    const t = this;
+    if (process.env.NODE_ENV !== "production") {
+      c.useDebugValue(e, (n) => Object.keys(n));
+      const o = c.useRef(Object.keys(e)).current, r = Object.keys(e);
+      (o.length !== r.length || o.some((n, i) => n !== r[i])) && console.error("ReactStore.useSyncedValues expects the same prop keys on every render. Keys should be stable.");
+    }
+    const s = Object.values(e);
+    u(() => {
+      t.update(e);
+    }, [t, ...s]);
+  }
+  /**
+   * Registers a controllable prop pair (`controlled`, `defaultValue`) for a specific key. If `controlled`
+   * is non-undefined, the store's state at `key` is updated to match `controlled`.
+   */
+  useControlledProp(e, t) {
+    c.useDebugValue(e);
+    const s = t !== void 0;
+    if (u(() => {
+      s && !Object.is(this.state[e], t) && super.setState({
+        ...this.state,
+        [e]: t
+      });
+    }, [e, t, s]), process.env.NODE_ENV !== "production") {
+      const o = this.controlledValues ??= /* @__PURE__ */ new Map();
+      o.has(e) || o.set(e, s);
+      const r = o.get(e);
+      r !== void 0 && r !== s && console.error(`A component is changing the ${s ? "" : "un"}controlled state of ${e.toString()} to be ${s ? "un" : ""}controlled. Elements should not switch from uncontrolled to controlled (or vice versa).`);
+    }
+  }
+  /** Gets the current value from the store using a selector with the provided key.
+   *
+   * @param key Key of the selector to use.
+   */
+  select(e, t, s, o) {
+    const r = this.selectors[e];
+    return r(this.state, t, s, o);
+  }
+  /**
+   * Returns a value from the store's state using a selector function.
+   * Used to subscribe to specific parts of the state.
+   * This methods causes a rerender whenever the selected state changes.
+   *
+   * @param key Key of the selector to use.
+   */
+  useState(e, t, s, o) {
+    return c.useDebugValue(e), l(this, this.selectors[e], t, s, o);
+  }
+  /**
+   * Wraps a function with `useStableCallback` to ensure it has a stable reference
+   * and assigns it to the context.
+   *
+   * @param key Key of the event callback. Must be a function in the context.
+   * @param fn Function to assign.
+   */
+  useContextCallback(e, t) {
+    c.useDebugValue(e);
+    const s = h(t ?? d);
+    this.context[e] = s;
+  }
+  /**
+   * Returns a stable setter function for a specific key in the store's state.
+   * It's commonly used to pass as a ref callback to React elements.
+   *
+   * @param key Key of the state to set.
+   */
+  useStateSetter(e) {
+    const t = c.useRef(void 0);
+    return t.current === void 0 && (t.current = (s) => {
+      this.set(e, s);
+    }), t.current;
+  }
+  /**
+   * Observes changes derived from the store's selectors and calls the listener when the selected value changes.
+   *
+   * @param key Key of the selector to observe.
+   * @param listener Listener function called when the selector result changes.
+   */
+  observe(e, t) {
+    let s;
+    typeof e == "function" ? s = e : s = this.selectors[e];
+    let o = s(this.state);
+    return t(o, o, this), this.subscribe((r) => {
+      const n = s(r);
+      if (!Object.is(o, n)) {
+        const i = o;
+        o = n, t(n, i, this);
+      }
+    });
+  }
+}
+export {
+  v as ReactStore
+};

package/dist/chunks/pkg/ui/dist/node_modules/@base-ui/utils/esm/store/Store-CRAQANWM.js

@@ -0,0 +1,86 @@
+import { useStore as a } from "./useStore-BsRFFm2l.js";
+class n {
+  /**
+   * The current state of the store.
+   * This property is updated immediately when the state changes as a result of calling {@link setState}, {@link update}, or {@link set}.
+   * To subscribe to state changes, use the {@link useState} method. The value returned by {@link useState} is updated after the component renders (similarly to React's useState).
+   * The values can be used directly (to avoid subscribing to the store) in effects or event handlers.
+   *
+   * Do not modify properties in state directly. Instead, use the provided methods to ensure proper state management and listener notification.
+   */
+  // Internal state to handle recursive `setState()` calls
+  constructor(t) {
+    this.state = t, this.listeners = /* @__PURE__ */ new Set(), this.updateTick = 0;
+  }
+  /**
+   * Registers a listener that will be called whenever the store's state changes.
+   *
+   * @param fn The listener function to be called on state changes.
+   * @returns A function to unsubscribe the listener.
+   */
+  subscribe = (t) => (this.listeners.add(t), () => {
+    this.listeners.delete(t);
+  });
+  /**
+   * Returns the current state of the store.
+   */
+  getSnapshot = () => this.state;
+  /**
+   * Updates the entire store's state and notifies all registered listeners.
+   *
+   * @param newState The new state to set for the store.
+   */
+  setState(t) {
+    if (this.state === t)
+      return;
+    this.state = t, this.updateTick += 1;
+    const s = this.updateTick;
+    for (const e of this.listeners) {
+      if (s !== this.updateTick)
+        return;
+      e(t);
+    }
+  }
+  /**
+   * Merges the provided changes into the current state and notifies listeners if there are changes.
+   *
+   * @param changes An object containing the changes to apply to the current state.
+   */
+  update(t) {
+    for (const s in t)
+      if (!Object.is(this.state[s], t[s])) {
+        this.setState({
+          ...this.state,
+          ...t
+        });
+        return;
+      }
+  }
+  /**
+   * Sets a specific key in the store's state to a new value and notifies listeners if the value has changed.
+   *
+   * @param key The key in the store's state to update.
+   * @param value The new value to set for the specified key.
+   */
+  set(t, s) {
+    Object.is(this.state[t], s) || this.setState({
+      ...this.state,
+      [t]: s
+    });
+  }
+  /**
+   * Gives the state a new reference and updates all registered listeners.
+   */
+  notifyAll() {
+    const t = {
+      ...this.state
+    };
+    this.setState(t);
+  }
+  use(t, s, e, i) {
+    return a(this, t, s, e, i);
+  }
+}
+export {
+  n as Store
+};

package/dist/chunks/pkg/ui/dist/node_modules/@base-ui/utils/esm/store/createSelector-SDRl3LYE.js

@@ -0,0 +1,17 @@
+import t from "../formatErrorMessage-BJfWDcMI.js";
+const f = (e, n, s, c, i, p, ...o) => {
+  if (o.length > 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Unsupported number of selectors" : t(1));
+  let r;
+  if (e)
+    r = e;
+  else
+    throw (
+      /* minify-error-disabled */
+      new Error("Missing arguments")
+    );
+  return r;
+};
+export {
+  f as createSelector
+};

package/dist/chunks/pkg/ui/dist/node_modules/@base-ui/utils/esm/store/useStore-BsRFFm2l.js

@@ -0,0 +1,21 @@
+import * as a from "react";
+import { s as c } from "../../../../../_virtual/index-C9tmbAjU.js";
+import { w as i } from "../../../../../_virtual/with-selector-BTwk-iW5.js";
+import { isReactVersionAtLeast as u } from "../reactVersion-oVIlFc4q.js";
+const f = u(19), m = f ? S : l;
+function x(t, r, e, o, s) {
+  return m(t, r, e, o, s);
+}
+function p(t, r, e, o, s) {
+  const n = a.useCallback(() => r(t.getSnapshot(), e, o, s), [t, r, e, o, s]);
+  return c.useSyncExternalStore(t.subscribe, n, n);
+}
+function S(t, r, e, o, s) {
+  return p(t, r, e, o, s);
+}
+function l(t, r, e, o, s) {
+  return i.useSyncExternalStoreWithSelector(t.subscribe, t.getSnapshot, t.getSnapshot, (n) => r(n, e, o, s));
+}
+export {
+  x as useStore
+};

package/dist/chunks/pkg/ui/dist/node_modules/@base-ui/utils/esm/useAnimationFrame-C0av1dS7.js

@@ -0,0 +1,68 @@
+import { useRefWithInit as u } from "./useRefWithInit-BObJZm23.js";
+import { useOnMount as h } from "./useOnMount-DjNCK2YI.js";
+const e = null;
+let l = globalThis.requestAnimationFrame;
+class o {
+  /* 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 = !1;
+  tick = (t) => {
+    this.isScheduled = !1;
+    const s = this.callbacks, a = this.callbacksCount;
+    if (this.callbacks = [], this.callbacksCount = 0, this.startId = this.nextId, a > 0)
+      for (let i = 0; i < s.length; i += 1)
+        s[i]?.(t);
+  };
+  request(t) {
+    const s = this.nextId;
+    this.nextId += 1, this.callbacks.push(t), this.callbacksCount += 1;
+    const a = process.env.NODE_ENV !== "production" && l !== requestAnimationFrame && (l = requestAnimationFrame, !0);
+    return (!this.isScheduled || a) && (requestAnimationFrame(this.tick), this.isScheduled = !0), s;
+  }
+  cancel(t) {
+    const s = t - this.startId;
+    s < 0 || s >= this.callbacks.length || (this.callbacks[s] = null, this.callbacksCount -= 1);
+  }
+}
+const c = new o();
+class r {
+  static create() {
+    return new r();
+  }
+  static request(t) {
+    return c.request(t);
+  }
+  static cancel(t) {
+    return c.cancel(t);
+  }
+  currentId = e;
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  request(t) {
+    this.cancel(), this.currentId = c.request(() => {
+      this.currentId = e, t();
+    });
+  }
+  cancel = () => {
+    this.currentId !== e && (c.cancel(this.currentId), this.currentId = e);
+  };
+  disposeEffect = () => this.cancel;
+}
+function k() {
+  const n = u(r.create).current;
+  return h(n.disposeEffect), n;
+}
+export {
+  r as AnimationFrame,
+  k as useAnimationFrame
+};

package/dist/chunks/pkg/ui/dist/node_modules/@base-ui/utils/esm/useControlled-BYl9LGEz.js

@@ -0,0 +1,53 @@
+import * as r from "react";
+import { error as l } from "./error-KZbzusBH.js";
+function _({
+  controlled: o,
+  default: n,
+  name: t,
+  state: i = "value"
+}) {
+  const {
+    current: e
+  } = r.useRef(o !== void 0), [c, f] = r.useState(n), a = e ? o : c;
+  if (process.env.NODE_ENV !== "production") {
+    r.useEffect(() => {
+      e !== (o !== void 0) && l([`A component is changing the ${e ? "" : "un"}controlled ${i} state of ${t} to be ${e ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${t} 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(`
+`));
+    }, [i, t, o]);
+    const {
+      current: s
+    } = r.useRef(n);
+    r.useEffect(() => {
+      !e && u(s) !== u(n) && l([`A component is changing the default ${i} state of an uncontrolled ${t} after being initialized. To suppress this warning opt to use a controlled ${t}.`].join(`
+`));
+    }, [n]);
+  }
+  const d = r.useCallback((s) => {
+    e || f(s);
+  }, []);
+  return [a, d];
+}
+function u(o) {
+  let n = 0;
+  const t = /* @__PURE__ */ new WeakMap();
+  try {
+    return JSON.stringify(o, function(i, e) {
+      if (!(i === "_owner" && this != null && typeof this == "object" && "$$typeof" in this)) {
+        if (typeof e == "bigint")
+          return `__bigint__:${e}`;
+        if (e !== null && typeof e == "object") {
+          const c = t.get(e);
+          if (c !== void 0)
+            return `__object__:${c}`;
+          t.set(e, n), n += 1;
+        }
+        return e;
+      }
+    }) ?? `__top__:${typeof o}`;
+  } catch {
+    return "__unserializable__";
+  }
+}
+export {
+  _ as useControlled
+};

package/dist/chunks/pkg/ui/dist/node_modules/@base-ui/utils/esm/useEnhancedClickHandler-Cu2E1baO.js

@@ -0,0 +1,19 @@
+import * as o from "react";
+function a(n) {
+  const t = o.useRef(""), r = o.useCallback((e) => {
+    e.defaultPrevented || (t.current = e.pointerType, n(e, e.pointerType));
+  }, [n]);
+  return {
+    onClick: o.useCallback((e) => {
+      if (e.detail === 0) {
+        n(e, "keyboard");
+        return;
+      }
+      "pointerType" in e ? n(e, e.pointerType) : n(e, t.current), t.current = "";
+    }, [n]),
+    onPointerDown: r
+  };
+}
+export {
+  a as useEnhancedClickHandler
+};

package/dist/chunks/pkg/ui/dist/node_modules/@base-ui/utils/esm/useId-D8NyJjt3.js

@@ -0,0 +1,20 @@
+import * as n from "react";
+import { SafeReact as u } from "./safeReact-C4X27Y1Z.js";
+let r = 0;
+function f(o, e = "mui") {
+  const [t, a] = n.useState(o), c = o || t;
+  return n.useEffect(() => {
+    t == null && (r += 1, a(`${e}-${r}`));
+  }, [t, e]), c;
+}
+const s = u.useId;
+function m(o, e) {
+  if (s !== void 0) {
+    const t = s();
+    return o ?? (e ? `${e}-${t}` : t);
+  }
+  return f(o, e);
+}
+export {
+  m as useId
+};

package/dist/chunks/pkg/ui/dist/node_modules/@base-ui/utils/esm/useIsoLayoutEffect-oOMudEAz.js

@@ -0,0 +1,6 @@
+import * as t from "react";
+const e = () => {
+}, o = typeof document < "u" ? t.useLayoutEffect : e;
+export {
+  o as useIsoLayoutEffect
+};

package/dist/chunks/pkg/ui/dist/node_modules/@base-ui/utils/esm/useMergedRefs-p9UujHQn.js

@@ -0,0 +1,69 @@
+import { useRefWithInit as f } from "./useRefWithInit-BObJZm23.js";
+function p(e, l, t, r) {
+  const n = f(s).current;
+  return a(n, e, l, t, r) && o(n, [e, l, t, r]), n.callback;
+}
+function h(e) {
+  const l = f(s).current;
+  return i(l, e) && o(l, e), l.callback;
+}
+function s() {
+  return {
+    callback: null,
+    cleanup: null,
+    refs: []
+  };
+}
+function a(e, l, t, r, n) {
+  return e.refs[0] !== l || e.refs[1] !== t || e.refs[2] !== r || e.refs[3] !== n;
+}
+function i(e, l) {
+  return e.refs.length !== l.length || e.refs.some((t, r) => t !== l[r]);
+}
+function o(e, l) {
+  if (e.refs = l, l.every((t) => t == null)) {
+    e.callback = null;
+    return;
+  }
+  e.callback = (t) => {
+    if (e.cleanup && (e.cleanup(), e.cleanup = null), t != null) {
+      const r = Array(l.length).fill(null);
+      for (let n = 0; n < l.length; n += 1) {
+        const c = l[n];
+        if (c != null)
+          switch (typeof c) {
+            case "function": {
+              const u = c(t);
+              typeof u == "function" && (r[n] = u);
+              break;
+            }
+            case "object": {
+              c.current = t;
+              break;
+            }
+          }
+      }
+      e.cleanup = () => {
+        for (let n = 0; n < l.length; n += 1) {
+          const c = l[n];
+          if (c != null)
+            switch (typeof c) {
+              case "function": {
+                const u = r[n];
+                typeof u == "function" ? u() : c(null);
+                break;
+              }
+              case "object": {
+                c.current = null;
+                break;
+              }
+            }
+        }
+      };
+    }
+  };
+}
+export {
+  p as useMergedRefs,
+  h as useMergedRefsN
+};

package/dist/chunks/pkg/ui/dist/node_modules/@base-ui/utils/esm/useOnFirstRender-IB3XPZ7h.js

@@ -0,0 +1,8 @@
+import * as t from "react";
+function n(r) {
+  const e = t.useRef(!0);
+  e.current && (e.current = !1, r());
+}
+export {
+  n as useOnFirstRender
+};

package/dist/chunks/pkg/ui/dist/node_modules/@base-ui/utils/esm/useOnMount-DjNCK2YI.js

@@ -0,0 +1,8 @@
+import * as e from "react";
+const n = [];
+function o(t) {
+  e.useEffect(t, n);
+}
+export {
+  o as useOnMount
+};

package/dist/chunks/pkg/ui/dist/node_modules/@base-ui/utils/esm/useRefWithInit-BObJZm23.js

@@ -0,0 +1,9 @@
+import * as c from "react";
+const e = {};
+function o(r, n) {
+  const t = c.useRef(e);
+  return t.current === e && (t.current = r(n)), t;
+}
+export {
+  o as useRefWithInit
+};

package/dist/chunks/pkg/ui/dist/node_modules/@base-ui/utils/esm/useScrollLock-kV6bksFe.js

@@ -0,0 +1,125 @@
+import { getWindow as h, isOverflowElement as d } from "../../../@floating-ui/utils/dist/floating-ui.utils.dom-BULZuLW5.js";
+import { addEventListener as B } from "./addEventListener-DnnRp2CB.js";
+import { isIOS as $, isWebKit as j } from "./detectBrowser-CntSiJrj.js";
+import { ownerDocument as a } from "./owner-CfKP3-Rk.js";
+import { useIsoLayoutEffect as F } from "./useIsoLayoutEffect-oOMudEAz.js";
+import { Timeout as Y } from "./useTimeout-BPZmm8PE.js";
+import { AnimationFrame as T } from "./useAnimationFrame-C0av1dS7.js";
+import { NOOP as q } from "./empty-C3-x9M2q.js";
+let S = {}, C = {}, X = "";
+function z(r) {
+  if (typeof document > "u")
+    return !1;
+  const o = a(r);
+  return h(o).innerWidth - o.documentElement.clientWidth > 0;
+}
+function A(r) {
+  if (!(typeof CSS < "u" && CSS.supports && CSS.supports("scrollbar-gutter", "stable")) || typeof document > "u")
+    return !1;
+  const o = a(r), t = o.documentElement, e = o.body, l = d(t) ? t : e, s = l.style.overflowY, n = t.style.scrollbarGutter;
+  t.style.scrollbarGutter = "stable", l.style.overflowY = "scroll";
+  const c = l.offsetWidth;
+  l.style.overflowY = "hidden";
+  const u = l.offsetWidth;
+  return l.style.overflowY = s, t.style.scrollbarGutter = n, c === u;
+}
+function H(r) {
+  const o = a(r), t = o.documentElement, e = o.body, l = d(t) ? t : e, s = {
+    overflowY: l.style.overflowY,
+    overflowX: l.style.overflowX
+  };
+  return Object.assign(l.style, {
+    overflowY: "hidden",
+    overflowX: "hidden"
+  }), () => {
+    Object.assign(l.style, s);
+  };
+}
+function I(r) {
+  const o = a(r), t = o.documentElement, e = o.body, l = h(t);
+  let s = 0, n = 0, c = !1;
+  const u = T.create();
+  if (j && (l.visualViewport?.scale ?? 1) !== 1)
+    return () => {
+    };
+  function m() {
+    const f = l.getComputedStyle(t), i = l.getComputedStyle(e), y = (f.scrollbarGutter || "").includes("both-edges") ? "stable both-edges" : "stable";
+    s = t.scrollTop, n = t.scrollLeft, S = {
+      scrollbarGutter: t.style.scrollbarGutter,
+      overflowY: t.style.overflowY,
+      overflowX: t.style.overflowX
+    }, X = t.style.scrollBehavior, C = {
+      position: e.style.position,
+      height: e.style.height,
+      width: e.style.width,
+      boxSizing: e.style.boxSizing,
+      overflowY: e.style.overflowY,
+      overflowX: e.style.overflowX,
+      scrollBehavior: e.style.scrollBehavior
+    };
+    const W = t.scrollHeight > t.clientHeight, x = t.scrollWidth > t.clientWidth, E = f.overflowY === "scroll" || i.overflowY === "scroll", G = f.overflowX === "scroll" || i.overflowX === "scroll", w = Math.max(0, l.innerWidth - e.clientWidth), p = Math.max(0, l.innerHeight - e.clientHeight), b = parseFloat(i.marginTop) + parseFloat(i.marginBottom), g = parseFloat(i.marginLeft) + parseFloat(i.marginRight), k = d(t) ? t : e;
+    if (c = A(r), c) {
+      t.style.scrollbarGutter = y, k.style.overflowY = "hidden", k.style.overflowX = "hidden";
+      return;
+    }
+    Object.assign(t.style, {
+      scrollbarGutter: y,
+      overflowY: "hidden",
+      overflowX: "hidden"
+    }), (W || E) && (t.style.overflowY = "scroll"), (x || G) && (t.style.overflowX = "scroll"), Object.assign(e.style, {
+      position: "relative",
+      height: b || p ? `calc(100dvh - ${b + p}px)` : "100dvh",
+      width: g || w ? `calc(100vw - ${g + w}px)` : "100vw",
+      boxSizing: "border-box",
+      overflow: "hidden",
+      scrollBehavior: "unset"
+    }), e.scrollTop = s, e.scrollLeft = n, t.setAttribute("data-base-ui-scroll-locked", ""), t.style.scrollBehavior = "unset";
+  }
+  function v() {
+    Object.assign(t.style, S), Object.assign(e.style, C), c || (t.scrollTop = s, t.scrollLeft = n, t.removeAttribute("data-base-ui-scroll-locked"), t.style.scrollBehavior = X);
+  }
+  function L() {
+    v(), u.request(m);
+  }
+  m();
+  const O = B(l, "resize", L);
+  return () => {
+    u.cancel(), v(), typeof l.removeEventListener == "function" && O();
+  };
+}
+class K {
+  lockCount = 0;
+  restore = null;
+  timeoutLock = Y.create();
+  timeoutUnlock = Y.create();
+  acquire(o) {
+    return this.lockCount += 1, this.lockCount === 1 && this.restore === null && this.timeoutLock.start(0, () => this.lock(o)), this.release;
+  }
+  release = () => {
+    this.lockCount -= 1, this.lockCount === 0 && this.restore && this.timeoutUnlock.start(0, this.unlock);
+  };
+  unlock = () => {
+    this.lockCount === 0 && this.restore && (this.restore?.(), this.restore = null);
+  };
+  lock(o) {
+    if (this.lockCount === 0 || this.restore !== null)
+      return;
+    const t = a(o).documentElement, e = h(t).getComputedStyle(t).overflowY;
+    if (e === "hidden" || e === "clip") {
+      this.restore = q;
+      return;
+    }
+    const l = $ || !z(o);
+    this.restore = l ? H(o) : I(o);
+  }
+}
+const M = new K();
+function Z(r = !0, o = null) {
+  F(() => {
+    if (r)
+      return M.acquire(o);
+  }, [r, o]);
+}
+export {
+  Z as useScrollLock
+};