@develemit/web-hooks 0.1.0 → 0.3.0

package/dist/index.cjs

@@ -1,3 +1,4 @@
+"use client";
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -22,21 +23,73 @@ var src_exports = {};
 __export(src_exports, {
   BACK_ZONE_PX: () => BACK_ZONE_PX,
   CLOSE_DISTANCE_PX: () => CLOSE_DISTANCE_PX,
+  COARSE_POINTER_QUERY: () => COARSE_POINTER_QUERY,
+  DEFAULT_IGNORE_SELECTOR: () => DEFAULT_IGNORE_SELECTOR,
   FOCUSABLE_SELECTOR: () => FOCUSABLE_SELECTOR,
   FORWARD_ZONE_PX: () => FORWARD_ZONE_PX,
   MAX_SWIPE_DURATION_MS: () => MAX_SWIPE_DURATION_MS,
   OPEN_DISTANCE_PX: () => OPEN_DISTANCE_PX,
+  REDUCED_MOTION_QUERY: () => REDUCED_MOTION_QUERY,
   VERTICAL_CANCEL_PX: () => VERTICAL_CANCEL_PX,
+  canShareFiles: () => canShareFiles,
+  computeKeyboardInset: () => computeKeyboardInset,
   copyText: () => copyText,
+  createDebouncer: () => createDebouncer,
+  deriveUpdateState: () => deriveUpdateState,
+  detectApple: () => detectApple,
+  detectPlatform: () => detectPlatform,
   focusableWithin: () => focusableWithin,
+  getPushSupport: () => getPushSupport,
+  handleBeforeUnload: () => handleBeforeUnload,
+  isEditableElement: () => isEditableElement,
+  isEditableTarget: () => isEditableTarget,
+  isInIgnoredRegion: () => isInIgnoredRegion,
   isInOpenZone: () => isInOpenZone,
   isInsideHorizontalScroller: () => isInsideHorizontalScroller,
+  isIos: () => isIos,
+  isIosSafari: () => isIosSafari,
+  isOutside: () => isOutside,
+  isPrimaryPress: () => isPrimaryPress,
+  isShareCancel: () => isShareCancel,
+  isStandalone: () => isStandalone,
+  lockScroll: () => lockScroll,
+  matchHotkey: () => matchHotkey,
+  nextDelay: () => nextDelay,
   nextFocusTarget: () => nextFocusTarget,
+  nextHeight: () => nextHeight,
+  parseHotkey: () => parseHotkey,
+  readText: () => readText,
   resolveSwipeIntent: () => resolveSwipeIntent,
+  shareOrCopy: () => shareOrCopy,
+  shareTextFor: () => shareTextFor,
+  shouldResubscribe: () => shouldResubscribe,
+  startInstallPromptCapture: () => startInstallPromptCapture,
+  unlockScroll: () => unlockScroll,
+  unregisterAll: () => unregisterAll,
+  urlBase64ToUint8Array: () => urlBase64ToUint8Array,
+  useAutoGrowTextarea: () => useAutoGrowTextarea,
+  useCoarsePointer: () => useCoarsePointer,
   useCopyFeedback: () => useCopyFeedback,
+  useDebouncedCallback: () => useDebouncedCallback,
+  useDebouncedValue: () => useDebouncedValue,
   useDrawerSwipe: () => useDrawerSwipe,
   useEscape: () => useEscape,
-  useFocusTrap: () => useFocusTrap
+  useFocusTrap: () => useFocusTrap,
+  useHotkey: () => useHotkey,
+  useInstallPrompt: () => useInstallPrompt,
+  useIsStandalone: () => useIsStandalone,
+  useKeyboardInset: () => useKeyboardInset,
+  useMediaQuery: () => useMediaQuery,
+  useOnlineStatus: () => useOnlineStatus,
+  useOutsidePress: () => useOutsidePress,
+  usePushSubscription: () => usePushSubscription,
+  useReducedMotion: () => useReducedMotion,
+  useScrollLock: () => useScrollLock,
+  useServiceWorker: () => useServiceWorker,
+  useShareFeedback: () => useShareFeedback,
+  useStorageState: () => useStorageState,
+  useUnsavedChangesGuard: () => useUnsavedChangesGuard,
+  useVisibilityPolling: () => useVisibilityPolling
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -51,7 +104,8 @@ var HORIZONTAL_DOMINANCE = 1.5;
 function isInOpenZone(x, viewportWidth) {
   return x > BACK_ZONE_PX && x < viewportWidth - FORWARD_ZONE_PX;
 }
-function resolveSwipeIntent(start, end, drawerOpen, viewportWidth) {
+function resolveSwipeIntent(start, end, drawerOpen, viewportWidth, startedInIgnoredRegion = false) {
+  if (startedInIgnoredRegion) return null;
   const dx = end.x - start.x;
   const dy = end.y - start.y;
   if (end.time - start.time > MAX_SWIPE_DURATION_MS) return null;
@@ -73,6 +127,11 @@ function isInsideHorizontalScroller(target) {
   }
   return false;
 }
+var DEFAULT_IGNORE_SELECTOR = "[data-no-swipe]";
+function isInIgnoredRegion(target, selector) {
+  if (!selector || !(target instanceof Element)) return false;
+  return target.closest(selector) !== null;
+}
 
 // src/drawer-swipe/use-drawer-swipe.ts
 var import_react = require("react");
@@ -84,17 +143,19 @@ function useDrawerSwipe({
   onOpen,
   onClose,
   enabled = true,
-  maxViewportWidth = 768
+  maxViewportWidth = 768,
+  ignoreSelector = DEFAULT_IGNORE_SELECTOR
 }) {
   const start = (0, import_react.useRef)(null);
-  const handlers = (0, import_react.useRef)({ drawerOpen, onOpen, onClose, maxViewportWidth });
-  handlers.current = { drawerOpen, onOpen, onClose, maxViewportWidth };
+  const handlers = (0, import_react.useRef)({ drawerOpen, onOpen, onClose, maxViewportWidth, ignoreSelector });
+  handlers.current = { drawerOpen, onOpen, onClose, maxViewportWidth, ignoreSelector };
   (0, import_react.useEffect)(() => {
     if (!enabled) return;
     function handleStart(event) {
       start.current = null;
       if (event.touches.length !== 1) return;
       if (isWideViewport(handlers.current.maxViewportWidth)) return;
+      if (isInIgnoredRegion(event.target, handlers.current.ignoreSelector)) return;
       if (!handlers.current.drawerOpen && isInsideHorizontalScroller(event.target)) {
         return;
       }
@@ -171,6 +232,9 @@ function useFocusTrap(containerRef, {
   if (active && !openerRef.current && typeof document !== "undefined") {
     openerRef.current = document.activeElement;
   }
+  (0, import_react2.useEffect)(() => {
+    if (!active) openerRef.current = null;
+  }, [active]);
   (0, import_react2.useEffect)(() => {
     const container = containerRef.current;
     if (!active || !container) return;
@@ -207,7 +271,6 @@ function useFocusTrap(containerRef, {
       document.removeEventListener("keydown", onKeyDown);
       activeTraps.splice(activeTraps.indexOf(token), 1);
       const opener = returnFocusRef?.current ?? openerRef.current;
-      openerRef.current = null;
       if (restoreFocus && opener?.isConnected) opener.focus();
     };
   }, [active, containerRef, initialFocusRef, returnFocusRef, restoreFocus]);
@@ -223,6 +286,7 @@ function useEscape(onEscape, active = true) {
   (0, import_react3.useEffect)(() => {
     if (!active) return;
     function onKeyDown(event) {
+      if (event.isComposing || event.keyCode === 229) return;
       if (event.key === "Escape") handlerRef.current();
     }
     document.addEventListener("keydown", onKeyDown);
@@ -252,8 +316,10 @@ function execCommandCopy(text) {
   textarea.style.top = "-1000px";
   textarea.style.left = "-1000px";
   textarea.style.fontSize = "16px";
+  const previouslyFocused = document.activeElement;
   document.body.appendChild(textarea);
   try {
+    textarea.focus({ preventScroll: true });
     textarea.select();
     textarea.setSelectionRange(0, text.length);
     return document.execCommand("copy");
@@ -261,6 +327,9 @@ function execCommandCopy(text) {
     return false;
   } finally {
     document.body.removeChild(textarea);
+    if (previouslyFocused instanceof HTMLElement && previouslyFocused !== document.body) {
+      previouslyFocused.focus({ preventScroll: true });
+    }
   }
 }
 
@@ -286,23 +355,1154 @@ function useCopyFeedback({ resetMs = 1500 } = {}) {
   );
   return { copy, status };
 }
+
+// src/clipboard/read-text.ts
+async function readText() {
+  const hasClipboardApi = typeof navigator !== "undefined" && !!navigator.clipboard?.readText && typeof window !== "undefined" && window.isSecureContext;
+  if (!hasClipboardApi) return { ok: false, reason: "unavailable" };
+  try {
+    return { ok: true, text: await navigator.clipboard.readText() };
+  } catch {
+    return { ok: false, reason: "denied" };
+  }
+}
+
+// src/scroll-lock/use-scroll-lock.ts
+var import_react5 = require("react");
+
+// src/scroll-lock/lock-styles.ts
+var LOCKED_PROPERTIES = [
+  "position",
+  "top",
+  "left",
+  "right",
+  "width",
+  "overflow",
+  "paddingRight"
+];
+function computeLockStyles({ scrollY, scrollbarWidth, existingPaddingRight }) {
+  const styles = {
+    position: "fixed",
+    top: `-${scrollY}px`,
+    left: "0",
+    right: "0",
+    width: "100%",
+    overflow: "hidden"
+  };
+  if (scrollbarWidth > 0) styles.paddingRight = `${existingPaddingRight + scrollbarWidth}px`;
+  return styles;
+}
+
+// src/scroll-lock/scroll-lock.ts
+var count = 0;
+var saved = null;
+function applyFirstLock() {
+  const { body, documentElement } = document;
+  const inline = {};
+  for (const property of LOCKED_PROPERTIES) inline[property] = body.style[property];
+  saved = { scrollY: window.scrollY, inline };
+  const styles = computeLockStyles({
+    scrollY: saved.scrollY,
+    scrollbarWidth: Math.max(0, window.innerWidth - documentElement.clientWidth),
+    existingPaddingRight: parseFloat(getComputedStyle(body).paddingRight) || 0
+  });
+  Object.assign(body.style, styles);
+}
+function restoreLastLock() {
+  if (!saved) return;
+  const { scrollY, inline } = saved;
+  saved = null;
+  Object.assign(document.body.style, inline);
+  window.scrollTo(0, scrollY);
+}
+function lockScroll() {
+  if (count === 0) applyFirstLock();
+  count += 1;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    count -= 1;
+    if (count === 0) restoreLastLock();
+  };
+}
+function unlockScroll() {
+  if (count === 0) return;
+  count -= 1;
+  if (count === 0) restoreLastLock();
+}
+
+// src/scroll-lock/use-scroll-lock.ts
+function useScrollLock(active = true) {
+  (0, import_react5.useEffect)(() => {
+    if (!active) return;
+    return lockScroll();
+  }, [active]);
+}
+
+// src/media-query/use-media-query.ts
+var import_react6 = require("react");
+
+// src/media-query/media-query.ts
+var REDUCED_MOTION_QUERY = "(prefers-reduced-motion: reduce)";
+var COARSE_POINTER_QUERY = "(pointer: coarse)";
+var lists = /* @__PURE__ */ new WeakMap();
+function getList(query) {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") return null;
+  const owner = window.matchMedia;
+  let byQuery = lists.get(owner);
+  if (!byQuery) {
+    byQuery = /* @__PURE__ */ new Map();
+    lists.set(owner, byQuery);
+  }
+  let list = byQuery.get(query);
+  if (!list) {
+    list = owner.call(window, query);
+    byQuery.set(query, list);
+  }
+  return list;
+}
+function getMatches(query) {
+  return getList(query)?.matches ?? null;
+}
+function subscribe(query, onChange) {
+  const list = getList(query);
+  if (!list) return () => {
+  };
+  if (typeof list.addEventListener === "function") {
+    list.addEventListener("change", onChange);
+    return () => list.removeEventListener("change", onChange);
+  }
+  list.addListener(onChange);
+  return () => list.removeListener(onChange);
+}
+
+// src/media-query/use-media-query.ts
+function useMediaQuery(query, options = {}) {
+  const serverDefault = options.serverDefault ?? false;
+  const subscribeToQuery = (0, import_react6.useCallback)((onChange) => subscribe(query, onChange), [query]);
+  const getSnapshot2 = (0, import_react6.useCallback)(() => getMatches(query) ?? serverDefault, [query, serverDefault]);
+  const getServerSnapshot2 = (0, import_react6.useCallback)(() => serverDefault, [serverDefault]);
+  return (0, import_react6.useSyncExternalStore)(subscribeToQuery, getSnapshot2, getServerSnapshot2);
+}
+function useReducedMotion(options) {
+  return useMediaQuery(REDUCED_MOTION_QUERY, options);
+}
+function useCoarsePointer(options) {
+  return useMediaQuery(COARSE_POINTER_QUERY, options);
+}
+
+// src/outside-press/outside-press.ts
+function isOutside(target, elements, ignoreSelector) {
+  if (!target) return false;
+  if (!target.isConnected) return false;
+  if (ignoreSelector && isInIgnoredRegion2(target, ignoreSelector)) return false;
+  return !elements.some((el) => el?.contains(target));
+}
+function isPrimaryPress(event) {
+  return !(event.pointerType === "mouse" && event.button !== 0);
+}
+function isInIgnoredRegion2(target, selector) {
+  const element = target instanceof Element ? target : target.parentElement;
+  return element?.closest(selector) != null;
+}
+
+// src/outside-press/use-outside-press.ts
+var import_react7 = require("react");
+function useOutsidePress(refs, onOutsidePress, { enabled = true, ignore } = {}) {
+  const refsRef = (0, import_react7.useRef)(refs);
+  const handlerRef = (0, import_react7.useRef)(onOutsidePress);
+  const ignoreRef = (0, import_react7.useRef)(ignore);
+  (0, import_react7.useEffect)(() => {
+    ignoreRef.current = ignore;
+    refsRef.current = refs;
+    handlerRef.current = onOutsidePress;
+  });
+  (0, import_react7.useEffect)(() => {
+    if (!enabled) return;
+    function onPointerDown(event) {
+      if (!isPrimaryPress(event)) return;
+      const list = Array.isArray(refsRef.current) ? refsRef.current : [refsRef.current];
+      const elements = list.map((ref) => ref.current);
+      if (isOutside(event.target, elements, ignoreRef.current)) handlerRef.current(event);
+    }
+    document.addEventListener("pointerdown", onPointerDown, true);
+    return () => document.removeEventListener("pointerdown", onPointerDown, true);
+  }, [enabled]);
+}
+
+// src/visibility-polling/schedule.ts
+function nextDelay(intervalMs, jitter, random) {
+  const fraction = Math.min(1, Math.max(0, jitter));
+  return intervalMs + random() * fraction * intervalMs;
+}
+
+// src/visibility-polling/use-visibility-polling.ts
+var import_react8 = require("react");
+var isHidden = () => document.visibilityState === "hidden";
+function useVisibilityPolling(fn, intervalMs, { enabled = true, immediate = true, jitter = 0, runOnVisible = true } = {}) {
+  const fnRef = (0, import_react8.useRef)(fn);
+  const optionsRef = (0, import_react8.useRef)({ immediate, jitter, runOnVisible });
+  (0, import_react8.useEffect)(() => {
+    fnRef.current = fn;
+    optionsRef.current = { immediate, jitter, runOnVisible };
+  });
+  const runningRef = (0, import_react8.useRef)(false);
+  const scheduleRef = (0, import_react8.useRef)(null);
+  (0, import_react8.useEffect)(() => {
+    if (!enabled) return;
+    let active = true;
+    let timer = null;
+    function clearTimer() {
+      if (timer !== null) clearTimeout(timer);
+      timer = null;
+    }
+    function schedule() {
+      clearTimer();
+      if (!active || isHidden()) return;
+      timer = setTimeout(run, nextDelay(intervalMs, optionsRef.current.jitter, Math.random));
+    }
+    async function run() {
+      timer = null;
+      if (!active || runningRef.current || isHidden()) return;
+      runningRef.current = true;
+      try {
+        await fnRef.current();
+      } catch {
+      } finally {
+        runningRef.current = false;
+      }
+      scheduleRef.current?.();
+    }
+    function onVisibilityChange() {
+      if (isHidden()) {
+        clearTimer();
+      } else if (optionsRef.current.runOnVisible) {
+        clearTimer();
+        void run();
+      } else if (!runningRef.current) {
+        schedule();
+      }
+    }
+    scheduleRef.current = schedule;
+    if (optionsRef.current.immediate && !isHidden()) void run();
+    else schedule();
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    return () => {
+      active = false;
+      scheduleRef.current = null;
+      clearTimer();
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+    };
+  }, [enabled, intervalMs]);
+}
+
+// src/debounce/debouncer.ts
+function createDebouncer(getFn, getMs) {
+  let timer;
+  let pending;
+  function clear() {
+    if (timer !== void 0) clearTimeout(timer);
+    timer = void 0;
+    pending = void 0;
+  }
+  function run() {
+    const args = pending;
+    clear();
+    if (args) getFn()(...args);
+  }
+  return {
+    call(...args) {
+      if (timer !== void 0) clearTimeout(timer);
+      pending = args;
+      timer = setTimeout(run, getMs());
+    },
+    cancel: clear,
+    flush() {
+      if (pending) run();
+    },
+    isPending: () => pending !== void 0
+  };
+}
+
+// src/debounce/use-debounced-value.ts
+var import_react9 = require("react");
+function useDebouncedValue(value, ms) {
+  const [debounced, setDebounced] = (0, import_react9.useState)(value);
+  (0, import_react9.useEffect)(() => {
+    const timer = setTimeout(() => setDebounced(value), ms);
+    return () => clearTimeout(timer);
+  }, [value, ms]);
+  return debounced;
+}
+
+// src/debounce/use-debounced-callback.ts
+var import_react10 = require("react");
+function useDebouncedCallback(fn, ms) {
+  const fnRef = (0, import_react10.useRef)(fn);
+  const msRef = (0, import_react10.useRef)(ms);
+  (0, import_react10.useEffect)(() => {
+    fnRef.current = fn;
+    msRef.current = ms;
+  });
+  const [debounced] = (0, import_react10.useState)(() => {
+    const debouncer = createDebouncer(
+      () => fnRef.current,
+      () => msRef.current
+    );
+    return Object.assign((...args) => debouncer.call(...args), {
+      cancel: debouncer.cancel,
+      flush: debouncer.flush
+    });
+  });
+  (0, import_react10.useEffect)(() => () => debounced.cancel(), [debounced]);
+  return debounced;
+}
+
+// src/storage-state/use-storage-state.ts
+var import_react11 = require("react");
+
+// src/storage-state/storage-store.ts
+function getStorage(kind) {
+  try {
+    if (typeof window === "undefined") return null;
+    return kind === "session" ? window.sessionStorage : window.localStorage;
+  } catch {
+    return null;
+  }
+}
+function readRaw(storage, key) {
+  try {
+    return storage ? storage.getItem(key) : null;
+  } catch {
+    return null;
+  }
+}
+function writeRaw(storage, key, value) {
+  try {
+    if (!storage) return false;
+    storage.setItem(key, value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function removeRaw(storage, key) {
+  try {
+    if (!storage) return false;
+    storage.removeItem(key);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseOr(raw, parse, fallback) {
+  if (raw === null) return fallback;
+  try {
+    return parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+var slot = (kind, key) => `${kind}\0${key}`;
+var memory = /* @__PURE__ */ new Map();
+var listeners = /* @__PURE__ */ new Map();
+function readCurrent(kind, key) {
+  const held = memory.get(slot(kind, key));
+  if (held !== void 0) return held;
+  return readRaw(getStorage(kind), key);
+}
+function notify(id) {
+  for (const listener of [...listeners.get(id) ?? []]) listener();
+}
+function writeCurrent(kind, key, raw) {
+  const id = slot(kind, key);
+  if (writeRaw(getStorage(kind), key, raw)) memory.delete(id);
+  else memory.set(id, raw);
+  notify(id);
+}
+function removeCurrent(kind, key) {
+  const id = slot(kind, key);
+  if (removeRaw(getStorage(kind), key)) memory.delete(id);
+  else memory.set(id, null);
+  notify(id);
+}
+function onStorageEvent(event) {
+  const kinds = [];
+  if (!event.storageArea || event.storageArea === getStorage("local")) kinds.push("local");
+  if (!event.storageArea || event.storageArea === getStorage("session")) kinds.push("session");
+  for (const id of [...listeners.keys()]) {
+    const [kind, key] = id.split("\0");
+    if (!kinds.includes(kind)) continue;
+    if (event.key !== null && event.key !== key) continue;
+    memory.delete(id);
+    notify(id);
+  }
+}
+function subscribeToKey(kind, key, listener) {
+  const id = slot(kind, key);
+  const wasEmpty = listeners.size === 0;
+  let set2 = listeners.get(id);
+  if (!set2) listeners.set(id, set2 = /* @__PURE__ */ new Set());
+  set2.add(listener);
+  if (wasEmpty) window.addEventListener("storage", onStorageEvent);
+  return () => {
+    const current = listeners.get(id);
+    current?.delete(listener);
+    if (current?.size === 0) listeners.delete(id);
+    if (listeners.size === 0) window.removeEventListener("storage", onStorageEvent);
+  };
+}
+
+// src/storage-state/use-storage-state.ts
+function useStorageState(key, defaultValue, options = {}) {
+  const kind = options.storage ?? "local";
+  const serialize = options.serialize ?? JSON.stringify;
+  const parse = options.parse ?? JSON.parse;
+  const latest = (0, import_react11.useRef)({ serialize, parse, defaultValue });
+  (0, import_react11.useEffect)(() => {
+    latest.current = { serialize, parse, defaultValue };
+  });
+  const cache = (0, import_react11.useRef)(null);
+  const subscribe3 = (0, import_react11.useCallback)((onChange) => subscribeToKey(kind, key, onChange), [kind, key]);
+  const getSnapshot2 = (0, import_react11.useCallback)(() => {
+    const raw = readCurrent(kind, key);
+    const hit = cache.current;
+    if (hit && hit.kind === kind && hit.key === key && hit.raw === raw && hit.parse === parse) return hit.value;
+    const value2 = parseOr(raw, parse, defaultValue);
+    cache.current = { kind, key, raw, parse, value: value2 };
+    return value2;
+  }, [kind, key, parse, defaultValue]);
+  const getServerSnapshot2 = (0, import_react11.useCallback)(() => defaultValue, [defaultValue]);
+  const value = (0, import_react11.useSyncExternalStore)(subscribe3, getSnapshot2, getServerSnapshot2);
+  const set2 = (0, import_react11.useCallback)(
+    (next) => {
+      const { serialize: encode, parse: decode, defaultValue: fallback } = latest.current;
+      try {
+        const resolved = typeof next === "function" ? next(parseOr(readCurrent(kind, key), decode, fallback)) : next;
+        writeCurrent(kind, key, encode(resolved));
+      } catch {
+      }
+    },
+    [kind, key]
+  );
+  const remove = (0, import_react11.useCallback)(() => removeCurrent(kind, key), [kind, key]);
+  return [value, set2, remove];
+}
+
+// src/unsaved-guard/handle-before-unload.ts
+function handleBeforeUnload(event) {
+  event.preventDefault();
+  event.returnValue = "";
+}
+
+// src/unsaved-guard/use-unsaved-changes-guard.ts
+var import_react12 = require("react");
+function useUnsavedChangesGuard(dirty) {
+  (0, import_react12.useEffect)(() => {
+    if (!dirty) return;
+    window.addEventListener("beforeunload", handleBeforeUnload);
+    return () => window.removeEventListener("beforeunload", handleBeforeUnload);
+  }, [dirty]);
+}
+
+// src/hotkey/parse-hotkey.ts
+var KEY_ALIASES = {
+  esc: "escape",
+  space: " ",
+  plus: "+",
+  up: "arrowup",
+  down: "arrowdown",
+  left: "arrowleft",
+  right: "arrowright"
+};
+function parseHotkey(combo) {
+  const parsed = { key: "", mod: false, ctrl: false, meta: false, alt: false, shift: false };
+  const parts = combo.trim().toLowerCase().split(/\+(?=.)/);
+  for (const part of parts) {
+    const token = part.trim();
+    if (token === "mod" || token === "ctrl" || token === "meta" || token === "alt" || token === "shift") {
+      parsed[token] = true;
+    } else {
+      parsed.key = KEY_ALIASES[token] ?? token;
+    }
+  }
+  if (!parsed.key) throw new Error(`Invalid hotkey "${combo}": no key`);
+  return parsed;
+}
+
+// src/hotkey/match-hotkey.ts
+var CODE_FOR_SYMBOL = {
+  "/": "Slash",
+  ".": "Period",
+  ",": "Comma",
+  ";": "Semicolon",
+  "'": "Quote",
+  "[": "BracketLeft",
+  "]": "BracketRight",
+  "\\": "Backslash",
+  "-": "Minus",
+  "=": "Equal",
+  "`": "Backquote"
+};
+function physicalCode(key) {
+  if (/^[a-z]$/.test(key)) return `Key${key.toUpperCase()}`;
+  if (/^[0-9]$/.test(key)) return `Digit${key}`;
+  return CODE_FOR_SYMBOL[key] ?? null;
+}
+function keyMatches(event, parsed) {
+  if (event.key.toLowerCase() === parsed.key) return true;
+  return parsed.shift && physicalCode(parsed.key) === event.code;
+}
+function matchHotkey(event, combo, isApple) {
+  const parsed = typeof combo === "string" ? parseHotkey(combo) : combo;
+  const wantMeta = parsed.meta || parsed.mod && isApple;
+  const wantCtrl = parsed.ctrl || parsed.mod && !isApple;
+  return event.metaKey === wantMeta && event.ctrlKey === wantCtrl && event.altKey === parsed.alt && event.shiftKey === parsed.shift && keyMatches(event, parsed);
+}
+function detectApple(nav) {
+  if (!nav) return false;
+  const platform = nav.userAgentData?.platform || nav.platform || "";
+  return /mac|iphone|ipad|ipod/i.test(platform);
+}
+function isEditableTarget(target) {
+  const el = target;
+  if (!el || typeof el.tagName !== "string") return false;
+  const tag = el.tagName.toLowerCase();
+  return tag === "input" || tag === "textarea" || tag === "select" || el.isContentEditable === true;
+}
+
+// src/hotkey/use-hotkey.ts
+var import_react13 = require("react");
+function useHotkey(combo, onHotkey, options = {}) {
+  const { enabled = true, allowInInputs = false, preventDefault = true } = options;
+  const handlerRef = (0, import_react13.useRef)(onHotkey);
+  (0, import_react13.useEffect)(() => {
+    handlerRef.current = onHotkey;
+  });
+  (0, import_react13.useEffect)(() => {
+    if (!enabled) return;
+    const parsed = parseHotkey(combo);
+    function onKeyDown(event) {
+      if (event.isComposing || event.keyCode === 229) return;
+      if (!allowInInputs && isEditableTarget(event.target)) return;
+      if (!matchHotkey(event, parsed, detectApple(navigator))) return;
+      if (preventDefault) event.preventDefault();
+      handlerRef.current(event);
+    }
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [combo, enabled, allowInInputs, preventDefault]);
+}
+
+// src/auto-grow/next-height.ts
+function nextHeight(scrollHeight, maxHeight) {
+  const content = Math.ceil(scrollHeight);
+  if (maxHeight !== void 0 && content > maxHeight) return { height: maxHeight, capped: true };
+  return { height: content, capped: false };
+}
+
+// src/auto-grow/use-auto-grow-textarea.ts
+var import_react14 = require("react");
+var useIsomorphicLayoutEffect = typeof window === "undefined" ? import_react14.useEffect : import_react14.useLayoutEffect;
+function useAutoGrowTextarea(ref, value, { maxHeight } = {}) {
+  const resize = (0, import_react14.useCallback)(() => {
+    const el = ref.current;
+    if (!el) return;
+    el.style.height = "auto";
+    const { height, capped } = nextHeight(el.scrollHeight, maxHeight);
+    el.style.height = `${height}px`;
+    el.style.overflowY = capped ? "auto" : "hidden";
+  }, [ref, maxHeight]);
+  useIsomorphicLayoutEffect(resize, [resize, value]);
+  (0, import_react14.useEffect)(() => {
+    const viewport = window.visualViewport;
+    const target = viewport ?? window;
+    target.addEventListener("resize", resize);
+    return () => target.removeEventListener("resize", resize);
+  }, [resize]);
+}
+
+// src/pwa/use-is-standalone.ts
+var import_react15 = require("react");
+
+// src/pwa/detect.ts
+var IOS_UA = /iPhone|iPad|iPod/;
+var IOS_OTHER_BROWSER = /CriOS|FxiOS|EdgiOS|OPiOS/;
+var IN_APP_WEBVIEW = /FBAN|FBAV|Instagram/;
+var STANDALONE_QUERY = "(display-mode: standalone)";
+function detectPlatform(env) {
+  const isIos2 = IOS_UA.test(env.userAgent) || env.platform === "MacIntel" && env.maxTouchPoints > 1;
+  const isIosSafari2 = isIos2 && !IOS_OTHER_BROWSER.test(env.userAgent) && !IN_APP_WEBVIEW.test(env.userAgent);
+  return { isIos: isIos2, isIosSafari: isIosSafari2, isStandalone: env.standaloneMedia || env.navigatorStandalone };
+}
+function readStandaloneMedia() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") return false;
+  return window.matchMedia(STANDALONE_QUERY).matches;
+}
+function readNavigatorStandalone() {
+  if (typeof navigator === "undefined") return false;
+  return navigator.standalone === true;
+}
+function readPlatform() {
+  if (typeof navigator === "undefined") return { isIos: false, isIosSafari: false, isStandalone: false };
+  return detectPlatform({
+    userAgent: navigator.userAgent ?? "",
+    platform: navigator.platform ?? "",
+    maxTouchPoints: navigator.maxTouchPoints ?? 0,
+    standaloneMedia: readStandaloneMedia(),
+    navigatorStandalone: readNavigatorStandalone()
+  });
+}
+var isStandalone = () => readPlatform().isStandalone;
+var isIos = () => readPlatform().isIos;
+var isIosSafari = () => readPlatform().isIosSafari;
+
+// src/pwa/use-is-standalone.ts
+function useIsStandalone() {
+  const subscribeToMode = (0, import_react15.useCallback)((onChange) => subscribe(STANDALONE_QUERY, onChange), []);
+  return (0, import_react15.useSyncExternalStore)(subscribeToMode, isStandalone, () => false);
+}
+
+// src/pwa/use-install-prompt.ts
+var import_react16 = require("react");
+
+// src/pwa/install-store.ts
+var state = { event: null, installed: false };
+var subscribers = /* @__PURE__ */ new Set();
+var permanent = false;
+var holders = 0;
+var attached = false;
+function set(next) {
+  state = next;
+  subscribers.forEach((fn) => fn());
+}
+function onBeforeInstallPrompt(e) {
+  e.preventDefault();
+  set({ ...state, event: e });
+}
+function onAppInstalled() {
+  set({ event: null, installed: true });
+}
+function sync() {
+  const wanted = permanent || holders > 0;
+  if (wanted === attached || typeof window === "undefined") return;
+  attached = wanted;
+  const toggle = wanted ? window.addEventListener : window.removeEventListener;
+  toggle.call(window, "beforeinstallprompt", onBeforeInstallPrompt);
+  toggle.call(window, "appinstalled", onAppInstalled);
+}
+function startInstallPromptCapture() {
+  permanent = true;
+  sync();
+}
+function acquireCapture() {
+  holders += 1;
+  sync();
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    holders -= 1;
+    sync();
+  };
+}
+function getInstallState() {
+  return state;
+}
+function subscribeInstallState(onChange) {
+  subscribers.add(onChange);
+  return () => {
+    subscribers.delete(onChange);
+  };
+}
+async function promptInstall() {
+  const event = state.event;
+  if (!event) return "unavailable";
+  set({ ...state, event: null });
+  try {
+    await event.prompt();
+    const { outcome } = await event.userChoice;
+    return outcome;
+  } catch {
+    return "dismissed";
+  }
+}
+
+// src/pwa/use-install-prompt.ts
+var serverState = { event: null, installed: false };
+function useInstallPrompt() {
+  const state2 = (0, import_react16.useSyncExternalStore)(subscribeInstallState, getInstallState, () => serverState);
+  const standalone = useIsStandalone();
+  const iosSafari = (0, import_react16.useSyncExternalStore)(
+    () => () => {
+    },
+    isIosSafari,
+    () => false
+  );
+  (0, import_react16.useEffect)(() => acquireCapture(), []);
+  const installed = state2.installed || standalone;
+  return {
+    canPrompt: state2.event !== null && !installed,
+    prompt: promptInstall,
+    installed,
+    needsIosInstructions: iosSafari && !installed
+  };
+}
+
+// src/online-status/use-online-status.ts
+var import_react17 = require("react");
+function subscribe2(callback) {
+  window.addEventListener("online", callback);
+  window.addEventListener("offline", callback);
+  return () => {
+    window.removeEventListener("online", callback);
+    window.removeEventListener("offline", callback);
+  };
+}
+var getSnapshot = () => navigator.onLine;
+var getServerSnapshot = () => true;
+function useOnlineStatus() {
+  return (0, import_react17.useSyncExternalStore)(subscribe2, getSnapshot, getServerSnapshot);
+}
+
+// src/service-worker/use-service-worker.ts
+var import_react18 = require("react");
+
+// src/service-worker/update-state.ts
+function deriveUpdateState({ hasController: hasController2, waiting, installingState }) {
+  if (!hasController2) return false;
+  return waiting || installingState === "installed";
+}
+
+// src/service-worker/register.ts
+var reloaded = false;
+function isServiceWorkerSupported() {
+  return typeof navigator !== "undefined" && "serviceWorker" in navigator;
+}
+var hasController = () => Boolean(navigator.serviceWorker.controller);
+async function unregisterAll() {
+  if (!isServiceWorkerSupported()) return;
+  try {
+    const registrations = await navigator.serviceWorker.getRegistrations();
+    await Promise.all(registrations.map((r) => r.unregister()));
+  } catch {
+  }
+}
+function registerServiceWorker({ url, scope, onUpdateAvailable }, { reload = () => window.location.reload() } = {}) {
+  let registration;
+  let disposed = false;
+  let applying = false;
+  const cleanups = [];
+  const controlledAtStart = hasController();
+  const onControllerChange = () => {
+    if (!(applying || controlledAtStart) || reloaded) return;
+    reloaded = true;
+    reload();
+  };
+  navigator.serviceWorker.addEventListener("controllerchange", onControllerChange);
+  cleanups.push(() => navigator.serviceWorker.removeEventListener("controllerchange", onControllerChange));
+  const watchInstalling = (reg) => {
+    const worker = reg.installing;
+    if (!worker) return;
+    const onState = () => {
+      if (deriveUpdateState({ hasController: hasController(), waiting: false, installingState: worker.state })) {
+        onUpdateAvailable();
+      }
+    };
+    worker.addEventListener("statechange", onState);
+    cleanups.push(() => worker.removeEventListener("statechange", onState));
+  };
+  navigator.serviceWorker.register(url, scope === void 0 ? void 0 : { scope }).then((reg) => {
+    if (disposed) return;
+    registration = reg;
+    if (deriveUpdateState({ hasController: hasController(), waiting: Boolean(reg.waiting) })) {
+      onUpdateAvailable();
+    }
+    const onUpdateFound = () => watchInstalling(reg);
+    reg.addEventListener("updatefound", onUpdateFound);
+    cleanups.push(() => reg.removeEventListener("updatefound", onUpdateFound));
+  }).catch(() => {
+  });
+  return {
+    applyUpdate() {
+      const waiting = registration?.waiting;
+      if (!waiting) return;
+      applying = true;
+      waiting.postMessage({ type: "SKIP_WAITING" });
+    },
+    dispose() {
+      disposed = true;
+      cleanups.splice(0).forEach((fn) => fn());
+    }
+  };
+}
+
+// src/service-worker/use-service-worker.ts
+function useServiceWorker({ url, scope, enabled = true }) {
+  const [supported, setSupported] = (0, import_react18.useState)(true);
+  const [updateAvailable, setUpdateAvailable] = (0, import_react18.useState)(false);
+  const handle = (0, import_react18.useRef)(void 0);
+  (0, import_react18.useEffect)(() => {
+    if (!enabled) return;
+    if (!isServiceWorkerSupported()) {
+      setSupported(false);
+      return;
+    }
+    const registered = registerServiceWorker({ url, scope, onUpdateAvailable: () => setUpdateAvailable(true) });
+    handle.current = registered;
+    return () => {
+      registered.dispose();
+      handle.current = void 0;
+    };
+  }, [url, scope, enabled]);
+  const applyUpdate = (0, import_react18.useCallback)(() => handle.current?.applyUpdate(), []);
+  return { supported, updateAvailable, applyUpdate };
+}
+
+// src/share/share-text.ts
+function shareTextFor({ text, url }) {
+  return [text, url].filter((part) => !!part).join("\n");
+}
+function isShareCancel(error) {
+  return typeof error === "object" && error !== null && error.name === "AbortError";
+}
+
+// src/share/share-or-copy.ts
+async function shareOrCopy(data) {
+  if (canShareNatively(data)) {
+    try {
+      await navigator.share(data);
+      return { status: "shared" };
+    } catch (error) {
+      if (isShareCancel(error)) return { status: "cancelled" };
+    }
+  }
+  const result = await copyText(shareTextFor(data));
+  return { status: result.ok ? "copied" : "failed" };
+}
+function canShareFiles(files) {
+  if (typeof navigator === "undefined" || typeof navigator.canShare !== "function") return false;
+  try {
+    return navigator.canShare({ files });
+  } catch {
+    return false;
+  }
+}
+function canShareNatively(data) {
+  if (typeof navigator === "undefined" || typeof navigator.share !== "function") return false;
+  if (typeof navigator.canShare !== "function") return true;
+  try {
+    return navigator.canShare(data);
+  } catch {
+    return false;
+  }
+}
+
+// src/share/use-share-feedback.ts
+var import_react19 = require("react");
+function useShareFeedback({ resetMs = 1500 } = {}) {
+  const [status, setStatus] = (0, import_react19.useState)("idle");
+  const timerRef = (0, import_react19.useRef)(void 0);
+  const clearTimer = (0, import_react19.useCallback)(() => {
+    if (timerRef.current !== void 0) clearTimeout(timerRef.current);
+    timerRef.current = void 0;
+  }, []);
+  (0, import_react19.useEffect)(() => clearTimer, [clearTimer]);
+  const share = (0, import_react19.useCallback)(
+    async (data) => {
+      const result = await shareOrCopy(data);
+      clearTimer();
+      setStatus(result.status);
+      timerRef.current = setTimeout(() => setStatus("idle"), resetMs);
+      return result;
+    },
+    [clearTimer, resetMs]
+  );
+  return { share, status };
+}
+
+// src/keyboard-inset/use-keyboard-inset.ts
+var import_react20 = require("react");
+
+// src/keyboard-inset/compute-inset.ts
+var DEFAULT_MIN_INSET = 150;
+function computeKeyboardInset(r) {
+  if (!r.editableFocused) return 0;
+  const occluded = r.layoutHeight - r.visualHeight - r.visualOffsetTop;
+  return occluded >= (r.minInset ?? DEFAULT_MIN_INSET) ? Math.round(occluded) : 0;
+}
+var NON_TEXT_INPUT_TYPES = /* @__PURE__ */ new Set([
+  "button",
+  "checkbox",
+  "radio",
+  "range",
+  "submit",
+  "reset",
+  "file",
+  "color",
+  "image",
+  "hidden"
+]);
+function isEditableElement(el) {
+  if (!el) return false;
+  const tag = el.tagName.toLowerCase();
+  if (tag === "select") return !el.disabled;
+  if (tag === "textarea" || tag === "input") {
+    const field = el;
+    if (field.readOnly || field.disabled) return false;
+    return tag === "textarea" || !NON_TEXT_INPUT_TYPES.has(field.type);
+  }
+  if (el.isContentEditable === true) return true;
+  const attr = el.getAttribute("contenteditable");
+  return attr !== null && attr !== "false";
+}
+
+// src/keyboard-inset/use-keyboard-inset.ts
+function useKeyboardInset({ minInset = DEFAULT_MIN_INSET, enabled = true } = {}) {
+  const [inset, setInset] = (0, import_react20.useState)(0);
+  (0, import_react20.useEffect)(() => {
+    const vv = typeof window === "undefined" ? null : window.visualViewport;
+    if (!enabled || !vv) {
+      setInset(0);
+      return;
+    }
+    const update = () => setInset(
+      computeKeyboardInset({
+        layoutHeight: window.innerHeight,
+        visualHeight: vv.height,
+        visualOffsetTop: vv.offsetTop,
+        editableFocused: isEditableElement(document.activeElement),
+        minInset
+      })
+    );
+    let frame = 0;
+    const onFocusOut = () => {
+      cancelAnimationFrame(frame);
+      frame = requestAnimationFrame(update);
+    };
+    const onFocusIn = () => {
+      cancelAnimationFrame(frame);
+      update();
+    };
+    vv.addEventListener("resize", update);
+    vv.addEventListener("scroll", update);
+    document.addEventListener("focusin", onFocusIn);
+    document.addEventListener("focusout", onFocusOut);
+    update();
+    return () => {
+      cancelAnimationFrame(frame);
+      vv.removeEventListener("resize", update);
+      vv.removeEventListener("scroll", update);
+      document.removeEventListener("focusin", onFocusIn);
+      document.removeEventListener("focusout", onFocusOut);
+    };
+  }, [enabled, minInset]);
+  return inset;
+}
+
+// src/push/use-push-subscription.ts
+var import_react21 = require("react");
+
+// src/push/support.ts
+function getPushSupport(env = readPushEnv()) {
+  if (env.isIos && !env.isStandalone) return "ios-needs-install";
+  if (!env.hasPushManager || !env.hasServiceWorker || !env.hasNotification) return "unsupported";
+  return "supported";
+}
+function readPushEnv() {
+  const browser = typeof window !== "undefined" && typeof navigator !== "undefined";
+  return {
+    hasPushManager: browser && "PushManager" in window,
+    hasServiceWorker: browser && "serviceWorker" in navigator,
+    hasNotification: browser && "Notification" in window,
+    isIos: browser && isIos(),
+    isStandalone: browser && isStandalone()
+  };
+}
+function readPermission() {
+  if (typeof window === "undefined" || !("Notification" in window)) return "unsupported";
+  return Notification.permission;
+}
+function shouldResubscribe({ permission, hasSubscription, resubscribeOnLoad }) {
+  return resubscribeOnLoad && permission === "granted" && !hasSubscription;
+}
+function isGone(error) {
+  return typeof error === "object" && error !== null && error.status === 410;
+}
+
+// src/push/vapid.ts
+function urlBase64ToUint8Array(key) {
+  const padding = "=".repeat((4 - key.length % 4) % 4);
+  const base64 = (key + padding).replace(/-/g, "+").replace(/_/g, "/");
+  const raw = atob(base64);
+  const out = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i++) out[i] = raw.charCodeAt(i);
+  return out;
+}
+
+// src/push/register.ts
+function subscribeFresh(reg, vapidPublicKey) {
+  return reg.pushManager.subscribe({
+    userVisibleOnly: true,
+    // lib.dom wants ArrayBufferView<ArrayBuffer>; a Uint8Array satisfies the runtime contract.
+    applicationServerKey: urlBase64ToUint8Array(vapidPublicKey)
+  });
+}
+async function ensureSubscribed(reg, { vapidPublicKey, onSubscribe }, existing) {
+  let sub = existing ?? await reg.pushManager.getSubscription() ?? await subscribeFresh(reg, vapidPublicKey);
+  try {
+    await onSubscribe(sub.toJSON());
+  } catch (error) {
+    if (!isGone(error)) throw error;
+    await sub.unsubscribe();
+    sub = await subscribeFresh(reg, vapidPublicKey);
+    await onSubscribe(sub.toJSON());
+  }
+  return sub;
+}
+
+// src/push/use-push-subscription.ts
+var messageOf = (error, fallback) => error instanceof Error ? error.message : fallback;
+function usePushSubscription(options) {
+  const { resubscribeOnLoad = true } = options;
+  const [support, setSupport] = (0, import_react21.useState)("unsupported");
+  const [permission, setPermission] = (0, import_react21.useState)("unsupported");
+  const [subscribed, setSubscribed] = (0, import_react21.useState)(false);
+  const [busy, setBusy] = (0, import_react21.useState)(false);
+  const [error, setError] = (0, import_react21.useState)(null);
+  const latest = (0, import_react21.useRef)(options);
+  latest.current = options;
+  (0, import_react21.useEffect)(() => {
+    const current = getPushSupport();
+    setSupport(current);
+    setPermission(readPermission());
+    if (current !== "supported") return;
+    let cancelled = false;
+    (async () => {
+      try {
+        const reg = await navigator.serviceWorker.ready;
+        const existing = await reg.pushManager.getSubscription();
+        if (cancelled) return;
+        const permissionNow = readPermission();
+        setPermission(permissionNow);
+        if (existing) return setSubscribed(true);
+        if (!shouldResubscribe({ permission: permissionNow, hasSubscription: false, resubscribeOnLoad })) return;
+        await ensureSubscribed(reg, latest.current);
+        if (!cancelled) setSubscribed(true);
+      } catch {
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [resubscribeOnLoad]);
+  const subscribe3 = (0, import_react21.useCallback)(async () => {
+    if (getPushSupport() !== "supported") return;
+    setError(null);
+    setBusy(true);
+    try {
+      const result = await Notification.requestPermission();
+      setPermission(result);
+      if (result !== "granted") return;
+      const reg = await navigator.serviceWorker.ready;
+      await ensureSubscribed(reg, latest.current);
+      setSubscribed(true);
+    } catch (e) {
+      setError(messageOf(e, "subscribe failed"));
+    } finally {
+      setBusy(false);
+    }
+  }, []);
+  const unsubscribe = (0, import_react21.useCallback)(async () => {
+    if (getPushSupport() !== "supported") return;
+    setError(null);
+    setBusy(true);
+    try {
+      const reg = await navigator.serviceWorker.ready;
+      const sub = await reg.pushManager.getSubscription();
+      if (sub) {
+        await latest.current.onUnsubscribe(sub.endpoint);
+        await sub.unsubscribe();
+      }
+      setSubscribed(false);
+    } catch (e) {
+      setError(messageOf(e, "unsubscribe failed"));
+    } finally {
+      setBusy(false);
+    }
+  }, []);
+  return { support, permission, subscribed, busy, error, subscribe: subscribe3, unsubscribe };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BACK_ZONE_PX,
   CLOSE_DISTANCE_PX,
+  COARSE_POINTER_QUERY,
+  DEFAULT_IGNORE_SELECTOR,
   FOCUSABLE_SELECTOR,
   FORWARD_ZONE_PX,
   MAX_SWIPE_DURATION_MS,
   OPEN_DISTANCE_PX,
+  REDUCED_MOTION_QUERY,
   VERTICAL_CANCEL_PX,
+  canShareFiles,
+  computeKeyboardInset,
   copyText,
+  createDebouncer,
+  deriveUpdateState,
+  detectApple,
+  detectPlatform,
   focusableWithin,
+  getPushSupport,
+  handleBeforeUnload,
+  isEditableElement,
+  isEditableTarget,
+  isInIgnoredRegion,
   isInOpenZone,
   isInsideHorizontalScroller,
+  isIos,
+  isIosSafari,
+  isOutside,
+  isPrimaryPress,
+  isShareCancel,
+  isStandalone,
+  lockScroll,
+  matchHotkey,
+  nextDelay,
   nextFocusTarget,
+  nextHeight,
+  parseHotkey,
+  readText,
   resolveSwipeIntent,
+  shareOrCopy,
+  shareTextFor,
+  shouldResubscribe,
+  startInstallPromptCapture,
+  unlockScroll,
+  unregisterAll,
+  urlBase64ToUint8Array,
+  useAutoGrowTextarea,
+  useCoarsePointer,
   useCopyFeedback,
+  useDebouncedCallback,
+  useDebouncedValue,
   useDrawerSwipe,
   useEscape,
-  useFocusTrap
+  useFocusTrap,
+  useHotkey,
+  useInstallPrompt,
+  useIsStandalone,
+  useKeyboardInset,
+  useMediaQuery,
+  useOnlineStatus,
+  useOutsidePress,
+  usePushSubscription,
+  useReducedMotion,
+  useScrollLock,
+  useServiceWorker,
+  useShareFeedback,
+  useStorageState,
+  useUnsavedChangesGuard,
+  useVisibilityPolling
 });