@develemit/web-hooks 0.0.0-stage → 0.2.0

package/dist/chunk-UZADAINO.js

@@ -0,0 +1,61 @@
+"use client";
+
+// src/media-query/use-media-query.ts
+import { useCallback, useSyncExternalStore } from "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 = useCallback((onChange) => subscribe(query, onChange), [query]);
+  const getSnapshot = useCallback(() => getMatches(query) ?? serverDefault, [query, serverDefault]);
+  const getServerSnapshot = useCallback(() => serverDefault, [serverDefault]);
+  return useSyncExternalStore(subscribeToQuery, getSnapshot, getServerSnapshot);
+}
+function useReducedMotion(options) {
+  return useMediaQuery(REDUCED_MOTION_QUERY, options);
+}
+function useCoarsePointer(options) {
+  return useMediaQuery(COARSE_POINTER_QUERY, options);
+}
+
+export {
+  REDUCED_MOTION_QUERY,
+  COARSE_POINTER_QUERY,
+  useMediaQuery,
+  useReducedMotion,
+  useCoarsePointer
+};

package/dist/clipboard.cjs

@@ -0,0 +1,94 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/clipboard/index.ts
+var clipboard_exports = {};
+__export(clipboard_exports, {
+  copyText: () => copyText,
+  useCopyFeedback: () => useCopyFeedback
+});
+module.exports = __toCommonJS(clipboard_exports);
+
+// src/clipboard/copy-text.ts
+async function copyText(text) {
+  const hasClipboardApi = typeof navigator !== "undefined" && !!navigator.clipboard?.writeText && typeof window !== "undefined" && window.isSecureContext;
+  if (hasClipboardApi) {
+    try {
+      await navigator.clipboard.writeText(text);
+      return { ok: true };
+    } catch {
+    }
+  }
+  if (execCommandCopy(text)) return { ok: true };
+  return { ok: false, reason: hasClipboardApi ? "denied" : "unavailable" };
+}
+function execCommandCopy(text) {
+  if (typeof document === "undefined") return false;
+  const textarea = document.createElement("textarea");
+  textarea.value = text;
+  textarea.readOnly = true;
+  textarea.style.position = "fixed";
+  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");
+  } catch {
+    return false;
+  } finally {
+    document.body.removeChild(textarea);
+    if (previouslyFocused instanceof HTMLElement && previouslyFocused !== document.body) {
+      previouslyFocused.focus({ preventScroll: true });
+    }
+  }
+}
+
+// src/clipboard/use-copy-feedback.ts
+var import_react = require("react");
+function useCopyFeedback({ resetMs = 1500 } = {}) {
+  const [status, setStatus] = (0, import_react.useState)("idle");
+  const timerRef = (0, import_react.useRef)(void 0);
+  const clearTimer = (0, import_react.useCallback)(() => {
+    if (timerRef.current !== void 0) clearTimeout(timerRef.current);
+    timerRef.current = void 0;
+  }, []);
+  (0, import_react.useEffect)(() => clearTimer, [clearTimer]);
+  const copy = (0, import_react.useCallback)(
+    async (text) => {
+      const result = await copyText(text);
+      clearTimer();
+      setStatus(result.ok ? "copied" : "failed");
+      timerRef.current = setTimeout(() => setStatus("idle"), resetMs);
+      return result;
+    },
+    [clearTimer, resetMs]
+  );
+  return { copy, status };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  copyText,
+  useCopyFeedback
+});

package/dist/clipboard.d.cts

@@ -0,0 +1,17 @@
+type CopyResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'unavailable' | 'denied';
+};
+declare function copyText(text: string): Promise<CopyResult>;
+
+type CopyStatus = 'idle' | 'copied' | 'failed';
+declare function useCopyFeedback({ resetMs }?: {
+    resetMs?: number;
+}): {
+    copy: (text: string) => Promise<CopyResult>;
+    status: CopyStatus;
+};
+
+export { type CopyResult, type CopyStatus, copyText, useCopyFeedback };

package/dist/clipboard.d.ts

@@ -0,0 +1,17 @@
+type CopyResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: 'unavailable' | 'denied';
+};
+declare function copyText(text: string): Promise<CopyResult>;
+
+type CopyStatus = 'idle' | 'copied' | 'failed';
+declare function useCopyFeedback({ resetMs }?: {
+    resetMs?: number;
+}): {
+    copy: (text: string) => Promise<CopyResult>;
+    status: CopyStatus;
+};
+
+export { type CopyResult, type CopyStatus, copyText, useCopyFeedback };

package/dist/clipboard.js

@@ -0,0 +1,9 @@
+"use client";
+import {
+  copyText,
+  useCopyFeedback
+} from "./chunk-3CACI4OQ.js";
+export {
+  copyText,
+  useCopyFeedback
+};

package/dist/debounce.cjs

@@ -0,0 +1,96 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/debounce/index.ts
+var debounce_exports = {};
+__export(debounce_exports, {
+  createDebouncer: () => createDebouncer,
+  useDebouncedCallback: () => useDebouncedCallback,
+  useDebouncedValue: () => useDebouncedValue
+});
+module.exports = __toCommonJS(debounce_exports);
+
+// 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_react = require("react");
+function useDebouncedValue(value, ms) {
+  const [debounced, setDebounced] = (0, import_react.useState)(value);
+  (0, import_react.useEffect)(() => {
+    const timer = setTimeout(() => setDebounced(value), ms);
+    return () => clearTimeout(timer);
+  }, [value, ms]);
+  return debounced;
+}
+
+// src/debounce/use-debounced-callback.ts
+var import_react2 = require("react");
+function useDebouncedCallback(fn, ms) {
+  const fnRef = (0, import_react2.useRef)(fn);
+  const msRef = (0, import_react2.useRef)(ms);
+  (0, import_react2.useEffect)(() => {
+    fnRef.current = fn;
+    msRef.current = ms;
+  });
+  const [debounced] = (0, import_react2.useState)(() => {
+    const debouncer = createDebouncer(
+      () => fnRef.current,
+      () => msRef.current
+    );
+    return Object.assign((...args) => debouncer.call(...args), {
+      cancel: debouncer.cancel,
+      flush: debouncer.flush
+    });
+  });
+  (0, import_react2.useEffect)(() => () => debounced.cancel(), [debounced]);
+  return debounced;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDebouncer,
+  useDebouncedCallback,
+  useDebouncedValue
+});

package/dist/debounce.d.cts

@@ -0,0 +1,21 @@
+interface Debouncer<Args extends unknown[]> {
+    call(...args: Args): void;
+    cancel(): void;
+    /** Runs the pending call right now; does nothing when none is pending. */
+    flush(): void;
+    isPending(): boolean;
+}
+/** `getFn` and `getMs` are read at call time, so the latest values always win. */
+declare function createDebouncer<Args extends unknown[]>(getFn: () => (...args: Args) => void, getMs: () => number): Debouncer<Args>;
+
+declare function useDebouncedValue<T>(value: T, ms: number): T;
+
+interface DebouncedCallback<Args extends unknown[]> {
+    (...args: Args): void;
+    cancel(): void;
+    flush(): void;
+}
+/** The returned function keeps one identity for the life of the component. */
+declare function useDebouncedCallback<Args extends unknown[]>(fn: (...args: Args) => void, ms: number): DebouncedCallback<Args>;
+
+export { type DebouncedCallback, type Debouncer, createDebouncer, useDebouncedCallback, useDebouncedValue };

package/dist/debounce.d.ts

@@ -0,0 +1,21 @@
+interface Debouncer<Args extends unknown[]> {
+    call(...args: Args): void;
+    cancel(): void;
+    /** Runs the pending call right now; does nothing when none is pending. */
+    flush(): void;
+    isPending(): boolean;
+}
+/** `getFn` and `getMs` are read at call time, so the latest values always win. */
+declare function createDebouncer<Args extends unknown[]>(getFn: () => (...args: Args) => void, getMs: () => number): Debouncer<Args>;
+
+declare function useDebouncedValue<T>(value: T, ms: number): T;
+
+interface DebouncedCallback<Args extends unknown[]> {
+    (...args: Args): void;
+    cancel(): void;
+    flush(): void;
+}
+/** The returned function keeps one identity for the life of the component. */
+declare function useDebouncedCallback<Args extends unknown[]>(fn: (...args: Args) => void, ms: number): DebouncedCallback<Args>;
+
+export { type DebouncedCallback, type Debouncer, createDebouncer, useDebouncedCallback, useDebouncedValue };

package/dist/debounce.js

@@ -0,0 +1,11 @@
+"use client";
+import {
+  createDebouncer,
+  useDebouncedCallback,
+  useDebouncedValue
+} from "./chunk-IWQDAJEP.js";
+export {
+  createDebouncer,
+  useDebouncedCallback,
+  useDebouncedValue
+};

package/dist/drawer-swipe.cjs

@@ -0,0 +1,149 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/drawer-swipe/index.ts
+var drawer_swipe_exports = {};
+__export(drawer_swipe_exports, {
+  BACK_ZONE_PX: () => BACK_ZONE_PX,
+  CLOSE_DISTANCE_PX: () => CLOSE_DISTANCE_PX,
+  FORWARD_ZONE_PX: () => FORWARD_ZONE_PX,
+  MAX_SWIPE_DURATION_MS: () => MAX_SWIPE_DURATION_MS,
+  OPEN_DISTANCE_PX: () => OPEN_DISTANCE_PX,
+  VERTICAL_CANCEL_PX: () => VERTICAL_CANCEL_PX,
+  isInOpenZone: () => isInOpenZone,
+  isInsideHorizontalScroller: () => isInsideHorizontalScroller,
+  resolveSwipeIntent: () => resolveSwipeIntent,
+  useDrawerSwipe: () => useDrawerSwipe
+});
+module.exports = __toCommonJS(drawer_swipe_exports);
+
+// src/drawer-swipe/swipe-intent.ts
+var BACK_ZONE_PX = 60;
+var FORWARD_ZONE_PX = 30;
+var OPEN_DISTANCE_PX = 80;
+var CLOSE_DISTANCE_PX = 60;
+var VERTICAL_CANCEL_PX = 40;
+var MAX_SWIPE_DURATION_MS = 450;
+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) {
+  const dx = end.x - start.x;
+  const dy = end.y - start.y;
+  if (end.time - start.time > MAX_SWIPE_DURATION_MS) return null;
+  if (Math.abs(dx) < Math.abs(dy) * HORIZONTAL_DOMINANCE) return null;
+  if (drawerOpen) {
+    return dx <= -CLOSE_DISTANCE_PX ? "close" : null;
+  }
+  if (dx < OPEN_DISTANCE_PX) return null;
+  return isInOpenZone(start.x, viewportWidth) ? "open" : null;
+}
+function isInsideHorizontalScroller(target) {
+  let node = target instanceof Element ? target : null;
+  while (node && node !== document.body) {
+    const { overflowX } = window.getComputedStyle(node);
+    if ((overflowX === "auto" || overflowX === "scroll") && node.scrollWidth > node.clientWidth) {
+      return true;
+    }
+    node = node.parentElement;
+  }
+  return false;
+}
+
+// src/drawer-swipe/use-drawer-swipe.ts
+var import_react = require("react");
+function isWideViewport(maxViewportWidth) {
+  return window.matchMedia(`(min-width: ${maxViewportWidth}px)`).matches;
+}
+function useDrawerSwipe({
+  drawerOpen,
+  onOpen,
+  onClose,
+  enabled = true,
+  maxViewportWidth = 768
+}) {
+  const start = (0, import_react.useRef)(null);
+  const handlers = (0, import_react.useRef)({ drawerOpen, onOpen, onClose, maxViewportWidth });
+  handlers.current = { drawerOpen, onOpen, onClose, maxViewportWidth };
+  (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 (!handlers.current.drawerOpen && isInsideHorizontalScroller(event.target)) {
+        return;
+      }
+      const touch = event.touches[0];
+      if (!touch) return;
+      start.current = { x: touch.clientX, y: touch.clientY, time: Date.now() };
+    }
+    function handleMove(event) {
+      const origin = start.current;
+      const touch = event.touches[0];
+      if (!origin || !touch) return;
+      if (Math.abs(touch.clientY - origin.y) > VERTICAL_CANCEL_PX) {
+        start.current = null;
+      }
+    }
+    function handleEnd(event) {
+      const origin = start.current;
+      start.current = null;
+      const touch = event.changedTouches[0];
+      if (!origin || !touch) return;
+      const { drawerOpen: drawerOpen2, onOpen: onOpen2, onClose: onClose2 } = handlers.current;
+      const intent = resolveSwipeIntent(
+        origin,
+        { x: touch.clientX, y: touch.clientY, time: Date.now() },
+        drawerOpen2,
+        window.innerWidth
+      );
+      if (intent === "open") onOpen2();
+      if (intent === "close") onClose2();
+    }
+    function handleCancel() {
+      start.current = null;
+    }
+    document.addEventListener("touchstart", handleStart, { passive: true });
+    document.addEventListener("touchmove", handleMove, { passive: true });
+    document.addEventListener("touchend", handleEnd, { passive: true });
+    document.addEventListener("touchcancel", handleCancel, { passive: true });
+    return () => {
+      document.removeEventListener("touchstart", handleStart);
+      document.removeEventListener("touchmove", handleMove);
+      document.removeEventListener("touchend", handleEnd);
+      document.removeEventListener("touchcancel", handleCancel);
+    };
+  }, [enabled]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BACK_ZONE_PX,
+  CLOSE_DISTANCE_PX,
+  FORWARD_ZONE_PX,
+  MAX_SWIPE_DURATION_MS,
+  OPEN_DISTANCE_PX,
+  VERTICAL_CANCEL_PX,
+  isInOpenZone,
+  isInsideHorizontalScroller,
+  resolveSwipeIntent,
+  useDrawerSwipe
+});

package/dist/drawer-swipe.d.cts

@@ -0,0 +1,26 @@
+type SwipePoint = {
+    x: number;
+    y: number;
+    time: number;
+};
+declare const BACK_ZONE_PX = 60;
+declare const FORWARD_ZONE_PX = 30;
+declare const OPEN_DISTANCE_PX = 80;
+declare const CLOSE_DISTANCE_PX = 60;
+declare const VERTICAL_CANCEL_PX = 40;
+declare const MAX_SWIPE_DURATION_MS = 450;
+type SwipeIntent = 'open' | 'close' | null;
+declare function isInOpenZone(x: number, viewportWidth: number): boolean;
+declare function resolveSwipeIntent(start: SwipePoint, end: SwipePoint, drawerOpen: boolean, viewportWidth: number): SwipeIntent;
+declare function isInsideHorizontalScroller(target: EventTarget | null): boolean;
+
+type UseDrawerSwipeOptions = {
+    drawerOpen: boolean;
+    onOpen: () => void;
+    onClose: () => void;
+    enabled?: boolean;
+    maxViewportWidth?: number;
+};
+declare function useDrawerSwipe({ drawerOpen, onOpen, onClose, enabled, maxViewportWidth, }: UseDrawerSwipeOptions): void;
+
+export { BACK_ZONE_PX, CLOSE_DISTANCE_PX, FORWARD_ZONE_PX, MAX_SWIPE_DURATION_MS, OPEN_DISTANCE_PX, type SwipeIntent, type SwipePoint, type UseDrawerSwipeOptions, VERTICAL_CANCEL_PX, isInOpenZone, isInsideHorizontalScroller, resolveSwipeIntent, useDrawerSwipe };

package/dist/drawer-swipe.d.ts

@@ -0,0 +1,26 @@
+type SwipePoint = {
+    x: number;
+    y: number;
+    time: number;
+};
+declare const BACK_ZONE_PX = 60;
+declare const FORWARD_ZONE_PX = 30;
+declare const OPEN_DISTANCE_PX = 80;
+declare const CLOSE_DISTANCE_PX = 60;
+declare const VERTICAL_CANCEL_PX = 40;
+declare const MAX_SWIPE_DURATION_MS = 450;
+type SwipeIntent = 'open' | 'close' | null;
+declare function isInOpenZone(x: number, viewportWidth: number): boolean;
+declare function resolveSwipeIntent(start: SwipePoint, end: SwipePoint, drawerOpen: boolean, viewportWidth: number): SwipeIntent;
+declare function isInsideHorizontalScroller(target: EventTarget | null): boolean;
+
+type UseDrawerSwipeOptions = {
+    drawerOpen: boolean;
+    onOpen: () => void;
+    onClose: () => void;
+    enabled?: boolean;
+    maxViewportWidth?: number;
+};
+declare function useDrawerSwipe({ drawerOpen, onOpen, onClose, enabled, maxViewportWidth, }: UseDrawerSwipeOptions): void;
+
+export { BACK_ZONE_PX, CLOSE_DISTANCE_PX, FORWARD_ZONE_PX, MAX_SWIPE_DURATION_MS, OPEN_DISTANCE_PX, type SwipeIntent, type SwipePoint, type UseDrawerSwipeOptions, VERTICAL_CANCEL_PX, isInOpenZone, isInsideHorizontalScroller, resolveSwipeIntent, useDrawerSwipe };

package/dist/drawer-swipe.js

@@ -0,0 +1,25 @@
+"use client";
+import {
+  BACK_ZONE_PX,
+  CLOSE_DISTANCE_PX,
+  FORWARD_ZONE_PX,
+  MAX_SWIPE_DURATION_MS,
+  OPEN_DISTANCE_PX,
+  VERTICAL_CANCEL_PX,
+  isInOpenZone,
+  isInsideHorizontalScroller,
+  resolveSwipeIntent,
+  useDrawerSwipe
+} from "./chunk-OZ4PU4E3.js";
+export {
+  BACK_ZONE_PX,
+  CLOSE_DISTANCE_PX,
+  FORWARD_ZONE_PX,
+  MAX_SWIPE_DURATION_MS,
+  OPEN_DISTANCE_PX,
+  VERTICAL_CANCEL_PX,
+  isInOpenZone,
+  isInsideHorizontalScroller,
+  resolveSwipeIntent,
+  useDrawerSwipe
+};

package/dist/escape.cjs

@@ -0,0 +1,48 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/escape/index.ts
+var escape_exports = {};
+__export(escape_exports, {
+  useEscape: () => useEscape
+});
+module.exports = __toCommonJS(escape_exports);
+
+// src/escape/use-escape.ts
+var import_react = require("react");
+function useEscape(onEscape, active = true) {
+  const handlerRef = (0, import_react.useRef)(onEscape);
+  (0, import_react.useEffect)(() => {
+    handlerRef.current = onEscape;
+  });
+  (0, import_react.useEffect)(() => {
+    if (!active) return;
+    function onKeyDown(event) {
+      if (event.isComposing || event.keyCode === 229) return;
+      if (event.key === "Escape") handlerRef.current();
+    }
+    document.addEventListener("keydown", onKeyDown);
+    return () => document.removeEventListener("keydown", onKeyDown);
+  }, [active]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  useEscape
+});

package/dist/escape.d.cts

@@ -0,0 +1,3 @@
+declare function useEscape(onEscape: () => void, active?: boolean): void;
+
+export { useEscape };

package/dist/escape.d.ts

@@ -0,0 +1,3 @@
+declare function useEscape(onEscape: () => void, active?: boolean): void;
+
+export { useEscape };

package/dist/escape.js

@@ -0,0 +1,7 @@
+"use client";
+import {
+  useEscape
+} from "./chunk-S4YKMGQE.js";
+export {
+  useEscape
+};