entangle-ui 0.10.0 → 0.11.0

package/dist/esm/components/shell/Toolbar/Toolbar.js.map

@@ -1 +1 @@
-{"version":3,"file":"Toolbar.js","sources":["../../../../../../src/components/shell/Toolbar/Toolbar.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AA+BA;AACE;AACA;AACD;AAED;AAEA;AAEA;AAGA;;AAIA;AAEA;AAEA;AAeI;AAEA;AAoBF;AAGF;AAEA;AAeI;AAEA;AAGM;AACF;AAmBN;AAGF;AAEA;AAEI;AAEA;AAYF;AAGF;AAEA;AAEI;;AAcF;AAGF;AAEA;;AAWE;AAGF;AAEA;AAEA;AAWE;;AAII;AACA;;;AAEO;AACL;;AAEJ;AAIF;AAEI;AACA;;AAEA;AACA;;AAEA;;AAGA;AACA;AAEA;;AAEE;AACA;;AACK;;;AAIL;;AACK;;AAEL;;AACK;;;;AAIT;AAIF;AACE;AACA;;;AAGA;AACE;AACA;;;;;AA2BN;AAEA;AAEA;AAEO;AACL;AACA;AACA;AACA;AACA;AACD;;"}
+{"version":3,"file":"Toolbar.js","sources":["src/components/shell/Toolbar/Toolbar.tsx"],"sourcesContent":["'use client';\n\nimport React, {\n  createContext,\n  useContext,\n  useRef,\n  useCallback,\n  useMemo,\n  KeyboardEvent,\n} from 'react';\n\nimport { cx } from '@/utils/cx';\n\nimport {\n  toolbarRoot,\n  toolbarButton,\n  toolbarGroup,\n  toolbarSeparator,\n  toolbarSpacer,\n} from './Toolbar.css';\n\nimport type {\n  ToolbarProps,\n  ToolbarButtonProps,\n  ToolbarToggleProps,\n  ToolbarGroupProps,\n  ToolbarSeparatorProps,\n  ToolbarSpacerProps,\n  ToolbarContextValue,\n} from './Toolbar.types';\n\nconst ToolbarContext = /*#__PURE__*/ createContext<ToolbarContextValue>({\n  orientation: 'horizontal',\n  size: 'md',\n});\n\nconst useToolbar = () => useContext(ToolbarContext);\n\n// --- Roving tabindex helper ---\n\nconst FOCUSABLE_ITEM_SELECTOR =\n  'button:not(:disabled), [role=\"button\"]:not([aria-disabled=\"true\"])';\n\nfunction focusableItems(container: HTMLElement): HTMLElement[] {\n  return Array.from(\n    container.querySelectorAll<HTMLElement>(FOCUSABLE_ITEM_SELECTOR)\n  );\n}\n\n// --- Sub-components ---\n\nconst ToolbarButton = /*#__PURE__*/ React.memo<ToolbarButtonProps>(\n  ({\n    onClick,\n    icon,\n    children,\n    tooltip,\n    variant = 'default',\n    disabled = false,\n\n    className,\n    style,\n    testId,\n    ref,\n    ...rest\n  }) => {\n    const { size } = useToolbar();\n\n    return (\n      <button\n        onClick={onClick}\n        disabled={disabled}\n        className={cx(\n          toolbarButton({ size, variant, active: false }),\n          className\n        )}\n        style={style}\n        data-testid={testId}\n        ref={ref}\n        title={tooltip}\n        type=\"button\"\n        tabIndex={-1}\n        {...rest}\n      >\n        {icon}\n        {!icon && children}\n      </button>\n    );\n  }\n);\n\nToolbarButton.displayName = 'Toolbar.Button';\n\nconst ToolbarToggle = /*#__PURE__*/ React.memo<ToolbarToggleProps>(\n  ({\n    pressed,\n    onPressedChange,\n    icon,\n    children,\n    tooltip,\n    disabled = false,\n\n    className,\n    style,\n    testId,\n    ref,\n    ...rest\n  }) => {\n    const { size } = useToolbar();\n\n    return (\n      <button\n        onClick={() => {\n          onPressedChange(!pressed);\n        }}\n        disabled={disabled}\n        className={cx(\n          toolbarButton({ size, variant: 'default', active: pressed }),\n          className\n        )}\n        style={style}\n        data-testid={testId}\n        ref={ref}\n        title={tooltip}\n        type=\"button\"\n        tabIndex={-1}\n        aria-pressed={pressed}\n        {...rest}\n      >\n        {icon}\n        {!icon && children}\n      </button>\n    );\n  }\n);\n\nToolbarToggle.displayName = 'Toolbar.Toggle';\n\nconst ToolbarGroupComp = /*#__PURE__*/ React.memo<ToolbarGroupProps>(\n  ({ children, className, style, testId, ref, ...rest }) => {\n    const { orientation } = useToolbar();\n\n    return (\n      <div\n        className={cx(toolbarGroup({ orientation }), className)}\n        style={style}\n        data-testid={testId}\n        ref={ref}\n        role=\"group\"\n        {...rest}\n      >\n        {children}\n      </div>\n    );\n  }\n);\n\nToolbarGroupComp.displayName = 'Toolbar.Group';\n\nconst ToolbarSeparatorComp = /*#__PURE__*/ React.memo<ToolbarSeparatorProps>(\n  ({ className, style, testId, ref, ...rest }) => {\n    const { orientation } = useToolbar();\n    return (\n      <div\n        className={cx(toolbarSeparator({ orientation }), className)}\n        style={style}\n        data-testid={testId}\n        ref={ref}\n        role=\"separator\"\n        aria-orientation={\n          orientation === 'horizontal' ? 'vertical' : 'horizontal'\n        }\n        {...rest}\n      />\n    );\n  }\n);\n\nToolbarSeparatorComp.displayName = 'Toolbar.Separator';\n\nconst ToolbarSpacerComp = /*#__PURE__*/ React.memo<ToolbarSpacerProps>(\n  ({ className, style, testId, ref, ...rest }) => {\n    return (\n      <div\n        className={cx(toolbarSpacer, className)}\n        style={style}\n        data-testid={testId}\n        ref={ref}\n        {...rest}\n      />\n    );\n  }\n);\n\nToolbarSpacerComp.displayName = 'Toolbar.Spacer';\n\n// --- Root Component ---\n\nconst ToolbarRoot: React.FC<ToolbarProps> = ({\n  orientation = 'horizontal',\n  size = 'md',\n  children,\n\n  className,\n  style,\n  testId,\n  ref: externalRef,\n  ...rest\n}) => {\n  const internalRef = useRef<HTMLDivElement>(null);\n\n  const setToolbarRef = useMemo(\n    () => (node: HTMLDivElement | null) => {\n      internalRef.current = node;\n      if (typeof externalRef === 'function') {\n        externalRef(node);\n      } else if (externalRef && typeof externalRef === 'object') {\n        externalRef.current = node;\n      }\n    },\n    [externalRef]\n  );\n\n  const handleKeyDown = useCallback(\n    (e: KeyboardEvent<HTMLDivElement>) => {\n      const container = internalRef.current;\n      if (!container) return;\n\n      const items = focusableItems(container);\n      if (items.length === 0) return;\n\n      const current = document.activeElement as HTMLElement;\n      const currentIndex = items.indexOf(current);\n\n      const nextKey = orientation === 'horizontal' ? 'ArrowRight' : 'ArrowDown';\n      const prevKey = orientation === 'horizontal' ? 'ArrowLeft' : 'ArrowUp';\n\n      if (e.key === nextKey) {\n        e.preventDefault();\n        const next = currentIndex + 1 < items.length ? currentIndex + 1 : 0;\n        items[next]?.focus();\n      } else if (e.key === prevKey) {\n        e.preventDefault();\n        const prev =\n          currentIndex - 1 >= 0 ? currentIndex - 1 : items.length - 1;\n        items[prev]?.focus();\n      } else if (e.key === 'Home') {\n        e.preventDefault();\n        items[0]?.focus();\n      } else if (e.key === 'End') {\n        e.preventDefault();\n        items[items.length - 1]?.focus();\n      }\n    },\n    [orientation]\n  );\n\n  const handleFocus = useCallback(() => {\n    const container = internalRef.current;\n    if (!container) return;\n\n    // If focus lands on the toolbar container itself, move to first button\n    if (document.activeElement === container) {\n      const items = focusableItems(container);\n      items[0]?.focus();\n    }\n  }, []);\n\n  const toolbarContextValue = useMemo(\n    () => ({ orientation, size }),\n    [orientation, size]\n  );\n\n  return (\n    <ToolbarContext.Provider value={toolbarContextValue}>\n      <div\n        ref={setToolbarRef}\n        className={cx(toolbarRoot({ orientation }), className)}\n        style={style}\n        data-testid={testId}\n        role=\"toolbar\"\n        aria-orientation={orientation}\n        tabIndex={0}\n        onKeyDown={handleKeyDown}\n        onFocus={handleFocus}\n        {...rest}\n      >\n        {children}\n      </div>\n    </ToolbarContext.Provider>\n  );\n};\n\nToolbarRoot.displayName = 'Toolbar';\n\n// --- Compound Component ---\n\nexport const Toolbar = /*#__PURE__*/ Object.assign(ToolbarRoot, {\n  Button: ToolbarButton,\n  Toggle: ToolbarToggle,\n  Group: ToolbarGroupComp,\n  Separator: ToolbarSeparatorComp,\n  Spacer: ToolbarSpacerComp,\n});\n"],"names":[],"mappings":";;;;;;AA+BA;AACE;AACA;AACD;AAED;AAEA;AAEA;AAGA;;AAIA;AAEA;AAEA;AAeI;AAEA;AAoBF;AAGF;AAEA;AAeI;AAEA;AAGM;AACF;AAmBN;AAGF;AAEA;AAEI;AAEA;AAYF;AAGF;AAEA;AAEI;;AAcF;AAGF;AAEA;;AAWE;AAGF;AAEA;AAEA;AAWE;;AAII;AACA;;;AAEO;AACL;;AAEJ;AAIF;AAEI;AACA;;AAEA;AACA;;AAEA;;AAGA;AACA;AAEA;;AAEE;AACA;;AACK;;;AAIL;;AACK;;AAEL;;AACK;;;;AAIT;AAIF;AACE;AACA;;;AAGA;AACE;AACA;;;;;AA2BN;AAEA;AAEA;AAEO;AACL;AACA;AACA;AACA;AACA;AACD;;"}

package/dist/esm/context/KeyboardContext.js.map

@@ -1 +1 @@
-{"version":3,"file":"KeyboardContext.js","sources":["../../../../src/context/KeyboardContext.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAcA;AACE;AACA;;AAGF;AAQO;AAEH;AACA;AAKF;AAGK;AAYD;AACJ;AAEA;AACE;AACE;AACE;;AAEJ;AACF;AAEA;AACE;AACE;AACE;;AAEJ;AACF;;AAGE;AACA;AACF;AACF;;"}
+{"version":3,"file":"KeyboardContext.js","sources":["src/context/KeyboardContext.tsx"],"sourcesContent":["'use client';\n\nimport React, {\n  createContext,\n  useContext,\n  memo,\n  useEffect,\n  useCallback,\n} from 'react';\n\nimport { useKeyboard, isKeyPressed } from '@/hooks/useKeyboard';\n\nimport type { KeyboardState, AllKeys } from '@/hooks/useKeyboard';\n\nconst NEUTRAL_KEYBOARD_STATE: KeyboardState = {\n  pressedKeys: [],\n  modifiers: { control: false, shift: false, alt: false, meta: false },\n};\n\nconst KeyboardContext = /*#__PURE__*/ createContext<KeyboardState>(\n  NEUTRAL_KEYBOARD_STATE\n);\n\nexport interface KeyboardContextProviderProps {\n  children: React.ReactNode;\n}\n\nexport const KeyboardContextProvider = /*#__PURE__*/ memo(\n  ({ children }: KeyboardContextProviderProps) => {\n    const keyboardState = useKeyboard();\n    return (\n      <KeyboardContext.Provider value={keyboardState}>\n        {children}\n      </KeyboardContext.Provider>\n    );\n  }\n);\n\nexport const useKeyboardContext = (): KeyboardState =>\n  useContext(KeyboardContext);\n\ntype KeyboardEffectMode = 'keydown' | 'keyup';\n\ntype KeyboardEffect = {\n  key: AllKeys;\n  actions: {\n    [mode in KeyboardEffectMode]?: () => void;\n  };\n};\n\nexport function useEffectsOnKeyboard(actions: KeyboardEffect[]): void {\n  const keyboard = useKeyboardContext();\n\n  const handleKeyDown = useCallback(() => {\n    actions.forEach(action => {\n      if (isKeyPressed(keyboard, action.key) && action.actions.keydown) {\n        action.actions.keydown();\n      }\n    });\n  }, [keyboard, actions]);\n\n  const handleKeyUp = useCallback(() => {\n    actions.forEach(action => {\n      if (isKeyPressed(keyboard, action.key) && action.actions.keyup) {\n        action.actions.keyup();\n      }\n    });\n  }, [keyboard, actions]);\n\n  useEffect(() => {\n    handleKeyDown();\n    handleKeyUp();\n  }, [handleKeyDown, handleKeyUp]);\n}\n"],"names":[],"mappings":";;;;;;AAcA;AACE;AACA;;AAGF;AAQO;AAEH;AACA;AAKF;AAGK;AAYD;AACJ;AAEA;AACE;AACE;AACE;;AAEJ;AACF;AAEA;AACE;AACE;AACE;;AAEJ;AACF;;AAGE;AACA;AACF;AACF;;"}

package/dist/esm/hooks/useBreakpoint/useBreakpoint.js.map

@@ -1 +1 @@
-{"version":3,"file":"useBreakpoint.js","sources":["../../../../../src/hooks/useBreakpoint/useBreakpoint.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;AACA;AACA;AACA;AAEA;AACE;AACE;AACA;AAAuB;;AAEzB;AACF;AAEA;;;;;;;;;;;;;AAaG;;AAED;AACA;AACA;AACA;;AAGE;;;AAGJ;;"}
+{"version":3,"file":"useBreakpoint.js","sources":["src/hooks/useBreakpoint/useBreakpoint.ts"],"sourcesContent":["'use client';\n\nimport { useMemo } from 'react';\n\nimport { useMediaQuery } from '@/hooks/useMediaQuery';\nimport { BREAKPOINT_ORDER, breakpoints } from '@/theme/breakpoints';\n\nimport type { UseBreakpointReturn } from './useBreakpoint.types';\nimport type { Breakpoint } from '@/theme/breakpoints';\n\nconst SM_QUERY = `(min-width: ${breakpoints.sm}px)`;\nconst MD_QUERY = `(min-width: ${breakpoints.md}px)`;\nconst LG_QUERY = `(min-width: ${breakpoints.lg}px)`;\nconst XL_QUERY = `(min-width: ${breakpoints.xl}px)`;\n\nfunction resolveCurrent(map: Omit<UseBreakpointReturn, 'current'>): Breakpoint {\n  for (let i = BREAKPOINT_ORDER.length - 1; i >= 0; i -= 1) {\n    const name = BREAKPOINT_ORDER[i];\n    if (name && map[name]) return name;\n  }\n  return 'xs';\n}\n\n/**\n * Reactive named-breakpoint matcher.\n *\n * Returns booleans for each named breakpoint plus the largest matching\n * `current`. Built on top of `useMediaQuery`. Breakpoint values come from\n * `@/theme/breakpoints` and match the values used by `Stack` and other\n * responsive layout components.\n *\n * @example\n * ```tsx\n * const { md, current } = useBreakpoint();\n * return md ? <Sidebar /> : <BottomSheet />;\n * ```\n */\nexport function useBreakpoint(): UseBreakpointReturn {\n  const sm = useMediaQuery(SM_QUERY);\n  const md = useMediaQuery(MD_QUERY);\n  const lg = useMediaQuery(LG_QUERY);\n  const xl = useMediaQuery(XL_QUERY);\n\n  return useMemo(() => {\n    const map = { xs: true, sm, md, lg, xl };\n    return { ...map, current: resolveCurrent(map) };\n  }, [sm, md, lg, xl]);\n}\n"],"names":[],"mappings":";;;;;AAUA;AACA;AACA;AACA;AAEA;AACE;AACE;AACA;AAAuB;;AAEzB;AACF;AAEA;;;;;;;;;;;;;AAaG;;AAED;AACA;AACA;AACA;;AAGE;;;AAGJ;;"}

package/dist/esm/hooks/useClickOutside/useClickOutside.js.map

@@ -1 +1 @@
-{"version":3,"file":"useClickOutside.js","sources":["../../../../../src/hooks/useClickOutside/useClickOutside.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAwBA;AACE;AAA+B;AAE/B;AACE;AACA;AACE;;;AAGJ;AACF;AAEA;;;;;;;;;;;;;;;;;AAiBG;AACG;;;;;AAUJ;;;AAIE;;;;AAGA;;AAEI;;AAEJ;AAEA;AACA;AACE;AACF;;;AAGJ;;"}
+{"version":3,"file":"useClickOutside.js","sources":["src/hooks/useClickOutside/useClickOutside.ts"],"sourcesContent":["'use client';\n\nimport { useEffect } from 'react';\n\nimport { useLatest } from '@/hooks/useLatest';\n\nimport type { RefObject } from 'react';\n\nexport interface UseClickOutsideOptions {\n  /**\n   * When false, the listener is not attached. Useful for toggling without\n   * unmount.\n   * @default true\n   */\n  enabled?: boolean;\n  /**\n   * Mouse / pointer event to listen for.\n   * @default 'mousedown'\n   */\n  event?: 'mousedown' | 'click' | 'pointerdown';\n}\n\ntype AnyHTMLRef = RefObject<HTMLElement | null>;\n\nfunction isOutside(target: EventTarget | null, refs: AnyHTMLRef[]): boolean {\n  if (!(target instanceof Node)) return true;\n\n  for (const ref of refs) {\n    const node = ref.current;\n    if (node && (node === target || node.contains(target))) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Fire a callback when a click occurs outside the referenced element(s).\n *\n * Accepts either a single ref or an array of refs. The handler fires only\n * when the click lands outside ALL provided refs — useful for popover +\n * trigger pairs where clicking either should be considered \"inside\".\n *\n * Defaults to `mousedown` so the handler runs before `click`. SSR-safe;\n * cleans up on unmount and when `enabled` flips to `false`.\n *\n * @example\n * ```tsx\n * const ref = useRef<HTMLDivElement>(null);\n * useClickOutside(ref, () => setOpen(false), { enabled: isOpen });\n *\n * return <div ref={ref}>...</div>;\n * ```\n */\nexport function useClickOutside<T extends HTMLElement = HTMLElement>(\n  ref: RefObject<T | null> | Array<RefObject<HTMLElement | null>>,\n  handler: (event: MouseEvent) => void,\n  options: UseClickOutsideOptions = {}\n): void {\n  const { enabled = true, event = 'mousedown' } = options;\n\n  // Latest handler / ref(s), refreshed after each commit so the document\n  // listener reads live values without re-subscribing and consumers may pass\n  // inline arrays.\n  const handlerRef = useLatest(handler);\n  const refsRef = useLatest<AnyHTMLRef[]>(Array.isArray(ref) ? ref : [ref]);\n\n  useEffect(() => {\n    if (!enabled) return;\n    if (typeof document === 'undefined') return;\n\n    const listener = (e: MouseEvent) => {\n      if (isOutside(e.target, refsRef.current)) {\n        handlerRef.current(e);\n      }\n    };\n\n    document.addEventListener(event, listener);\n    return () => {\n      document.removeEventListener(event, listener);\n    };\n    // handlerRef/refsRef are stable useLatest refs; listed to satisfy the rule.\n  }, [enabled, event, handlerRef, refsRef]);\n}\n"],"names":[],"mappings":";;;;AAwBA;AACE;AAA+B;AAE/B;AACE;AACA;AACE;;;AAGJ;AACF;AAEA;;;;;;;;;;;;;;;;;AAiBG;AACG;;;;;AAUJ;;;AAIE;;;;AAGA;;AAEI;;AAEJ;AAEA;AACA;AACE;AACF;;;AAGJ;;"}

package/dist/esm/hooks/useClipboard/useClipboard.js.map

@@ -1 +1 @@
-{"version":3,"file":"useClipboard.js","sources":["../../../../../src/hooks/useClipboard/useClipboard.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;AAEA;;AAGI;;AAGA;;;AAGF;AACF;AAEA;;AACuC;;AAGrC;AACA;AACA;AACA;AACA;AACA;;;AAIA;;;;;AAKE;;AACA;;;AAGF;AACA;AACF;AAEA;;;;;;;;;;;;;;;;;;AAkBG;AACG;AAGJ;;;AAKA;AACA;;;;;AAKA;;AAGE;AACF;AAEA;AACE;AACE;AACA;;;AAIJ;AACE;;;AAGA;;;AAGF;;AAII;AAEA;AACA;;;AAKA;AACE;;;AAEA;;AAGF;AACE;AACE;;AAEE;;;;AAGF;;;;;AAMJ;AACE;;;;;AAMA;AACE;;;;;AAKA;;;AAGF;AACA;;;;AAKF;AACF;;AAKA;AACE;AACE;AACA;;AAEJ;;;;;;;;;AAUJ;;"}
+{"version":3,"file":"useClipboard.js","sources":["src/hooks/useClipboard/useClipboard.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useEffect, useRef, useState } from 'react';\n\nimport type {\n  ClipboardStatus,\n  UseClipboardOptions,\n  UseClipboardReturn,\n} from './useClipboard.types';\n\nconst DEFAULT_TIMEOUT = 2000;\n\nasync function writeViaClipboardApi(text: string): Promise<boolean> {\n  if (\n    typeof navigator === 'undefined' ||\n    typeof navigator.clipboard === 'undefined' ||\n    typeof navigator.clipboard.writeText !== 'function'\n  ) {\n    return false;\n  }\n  await navigator.clipboard.writeText(text);\n  return true;\n}\n\nfunction writeViaExecCommand(text: string): boolean {\n  if (typeof document === 'undefined') return false;\n\n  const textarea = document.createElement('textarea');\n  textarea.value = text;\n  textarea.setAttribute('readonly', '');\n  textarea.style.position = 'absolute';\n  textarea.style.left = '-9999px';\n  textarea.style.top = '0';\n  document.body.appendChild(textarea);\n  textarea.select();\n\n  let succeeded = false;\n  try {\n    // Legacy fallback used only when navigator.clipboard.writeText is\n    // unavailable (the modern primary path). execCommand has no modern\n    // synchronous equivalent for this fallback scenario.\n    // eslint-disable-next-line @typescript-eslint/no-deprecated\n    succeeded = document.execCommand('copy');\n  } catch {\n    succeeded = false;\n  }\n  document.body.removeChild(textarea);\n  return succeeded;\n}\n\n/**\n * Copy text to the clipboard with a built-in timeout-driven feedback state.\n *\n * Uses `navigator.clipboard.writeText` when available; falls back to\n * `document.execCommand('copy')` only when the modern API is missing.\n * In SSR or restricted contexts where neither path is available, `copy`\n * resolves to `false` and `status` flips to `'error'` without throwing.\n *\n * @example\n * ```tsx\n * const { copy, copied } = useClipboard({ timeout: 1500 });\n *\n * return (\n *   <Button onClick={() => copy('Hello!')}>\n *     {copied ? 'Copied!' : 'Copy'}\n *   </Button>\n * );\n * ```\n */\nexport function useClipboard(\n  options: UseClipboardOptions = {}\n): UseClipboardReturn {\n  const { timeout = DEFAULT_TIMEOUT } = options;\n\n  const [status, setStatus] = useState<ClipboardStatus>('idle');\n  const [error, setError] = useState<Error | null>(null);\n\n  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const timeoutRef = useRef(timeout);\n  // Bumped on every `copy()` call. The async path captures its own value\n  // and short-circuits on resolution if a newer call has started — that\n  // prevents an older, slower `writeText` from overwriting the state of a\n  // newer copy or from arming a stale timer.\n  const requestSeqRef = useRef(0);\n\n  useEffect(() => {\n    timeoutRef.current = timeout;\n  }, [timeout]);\n\n  const clearTimer = useCallback(() => {\n    if (timerRef.current !== null) {\n      clearTimeout(timerRef.current);\n      timerRef.current = null;\n    }\n  }, []);\n\n  const reset = useCallback(() => {\n    clearTimer();\n    // Invalidate any in-flight copy so a late resolution does not flip\n    // the status back from idle/error.\n    requestSeqRef.current += 1;\n    setStatus('idle');\n    setError(null);\n  }, [clearTimer]);\n\n  const copy = useCallback(\n    async (text: string): Promise<boolean> => {\n      clearTimer();\n\n      requestSeqRef.current += 1;\n      const requestId = requestSeqRef.current;\n\n      let succeeded = false;\n      let copyError: Error | null = null;\n\n      try {\n        succeeded = await writeViaClipboardApi(text);\n      } catch (err) {\n        copyError = err instanceof Error ? err : new Error(String(err));\n      }\n\n      if (!succeeded && copyError === null) {\n        try {\n          succeeded = writeViaExecCommand(text);\n          if (!succeeded) {\n            copyError = new Error('Copy command was rejected by the browser.');\n          }\n        } catch (err) {\n          copyError = err instanceof Error ? err : new Error(String(err));\n        }\n      }\n\n      // A newer call (or `reset`) has started — drop this result on the\n      // floor so it does not race the active state.\n      if (requestId !== requestSeqRef.current) {\n        return succeeded;\n      }\n\n      if (succeeded) {\n        setError(null);\n        setStatus('copied');\n        timerRef.current = setTimeout(() => {\n          timerRef.current = null;\n          // Guard the timer too: another copy may have started during the\n          // window and bumped the sequence. We still clear the timer ref,\n          // but only flip back to idle if the timer belonged to the\n          // current request.\n          if (requestId === requestSeqRef.current) {\n            setStatus('idle');\n          }\n        }, timeoutRef.current);\n        return true;\n      }\n\n      setError(copyError ?? new Error('Clipboard API is not available.'));\n      setStatus('error');\n      return false;\n    },\n    [clearTimer]\n  );\n\n  useEffect(() => {\n    return () => {\n      if (timerRef.current !== null) {\n        clearTimeout(timerRef.current);\n        timerRef.current = null;\n      }\n    };\n  }, []);\n\n  return {\n    status,\n    copied: status === 'copied',\n    error,\n    copy,\n    reset,\n  };\n}\n"],"names":[],"mappings":";;;AAUA;AAEA;;AAGI;;AAGA;;;AAGF;AACF;AAEA;;AACuC;;AAGrC;AACA;AACA;AACA;AACA;AACA;;;AAIA;;;;;AAKE;;AACA;;;AAGF;AACA;AACF;AAEA;;;;;;;;;;;;;;;;;;AAkBG;AACG;AAGJ;;;AAKA;AACA;;;;;AAKA;;AAGE;AACF;AAEA;AACE;AACE;AACA;;;AAIJ;AACE;;;AAGA;;;AAGF;;AAII;AAEA;AACA;;;AAKA;AACE;;;AAEA;;AAGF;AACE;AACE;;AAEE;;;;AAGF;;;;;AAMJ;AACE;;;;;AAMA;AACE;;;;;AAKA;;;AAGF;AACA;;;;AAKF;AACF;;AAKA;AACE;AACE;AACA;;AAEJ;;;;;;;;;AAUJ;;"}

package/dist/esm/hooks/useControlledState/useControlledState.js.map

@@ -1 +1 @@
-{"version":3,"file":"useControlledState.js","sources":["../../../../../src/hooks/useControlledState/useControlledState.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAiBA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG;;AAKJ;;;AAIA;;;;AAMA;AACA;AACA;;AAGE;AACF;;AAGE;AACF;;;;AAKE;AACA;;;;AAOM;AAEJ;;AAEJ;AAEA;AAEI;AACE;AACA;AACF;AAGA;;AAEE;;AAEF;AACF;;AAKF;AACF;;"}
+{"version":3,"file":"useControlledState.js","sources":["src/hooks/useControlledState/useControlledState.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useEffect, useRef, useState } from 'react';\n\nimport { devWarn } from '@/utils/devWarn';\n\nexport interface UseControlledStateOptions<T> {\n  /** Controlled value — when defined, drives the returned value. */\n  value?: T;\n  /** Default value used when the hook is uncontrolled. */\n  defaultValue?: T;\n  /** Called when the consumer requests a change in either mode. */\n  onChange?: (value: T) => void;\n  /** Fallback used when both `value` and `defaultValue` are undefined. */\n  fallback: T;\n}\n\n/**\n * Manage a value that may be either controlled (via prop) or uncontrolled\n * (managed internally with a default).\n *\n * Returns a `[value, setValue]` tuple just like `useState`. When\n * `options.value` is defined the state is read from there and `setValue`\n * becomes a pure side-effect callback that calls `onChange` only — internal\n * state is never mutated. When `options.value` is undefined the hook owns the\n * state and `setValue` updates it as well as calls `onChange`.\n *\n * Switching between controlled and uncontrolled within a component's lifetime\n * is a known pitfall (matches React's own warning for `<input value/defaultValue>`).\n * The hook emits a development-only warning when this happens.\n *\n * @example\n * ```ts\n * const [value, setValue] = useControlledState({\n *   value: props.value,\n *   defaultValue: props.defaultValue,\n *   onChange: props.onChange,\n *   fallback: '',\n * });\n * ```\n */\nexport function useControlledState<T>(\n  options: UseControlledStateOptions<T>\n): [T, (next: T | ((prev: T) => T)) => void] {\n  const { value, defaultValue, onChange, fallback } = options;\n\n  const isControlled = value !== undefined;\n\n  // Only `undefined` means \"no defaultValue given\" — `null` is a legal value\n  // for generic T (e.g. `string | null`) and must not be replaced by fallback.\n  const [internalValue, setInternalValue] = useState<T>(\n    // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing\n    defaultValue !== undefined ? defaultValue : fallback\n  );\n\n  // Stable refs to avoid stale closures and unnecessary identity changes.\n  const onChangeRef = useRef(onChange);\n  const internalValueRef = useRef(internalValue);\n  const isControlledRef = useRef(isControlled);\n\n  useEffect(() => {\n    onChangeRef.current = onChange;\n  }, [onChange]);\n\n  useEffect(() => {\n    internalValueRef.current = internalValue;\n  }, [internalValue]);\n\n  // Dev-only warning when controlled <-> uncontrolled flips after mount.\n  // Mirrors React's behavior for <input value/defaultValue>.\n  useEffect(() => {\n    const wasControlled = isControlledRef.current;\n    if (wasControlled !== isControlled) {\n      devWarn(\n        `[useControlledState] Component is changing from ${\n          wasControlled ? 'controlled' : 'uncontrolled'\n        } to ${isControlled ? 'controlled' : 'uncontrolled'}. ` +\n          'Components should not switch between controlled and uncontrolled ' +\n          '(or vice versa) during their lifetime. Decide between using a ' +\n          'controlled or uncontrolled mode for the lifetime of the component.'\n      );\n      isControlledRef.current = isControlled;\n    }\n  }, [isControlled]);\n\n  const setValue = useCallback(\n    (next: T | ((prev: T) => T)) => {\n      const prev = isControlledRef.current\n        ? (value as T)\n        : internalValueRef.current;\n      const resolved =\n        typeof next === 'function' ? (next as (p: T) => T)(prev) : next;\n\n      if (!isControlledRef.current) {\n        setInternalValue(resolved);\n        internalValueRef.current = resolved;\n      }\n      onChangeRef.current?.(resolved);\n    },\n    [value]\n  );\n\n  const currentValue = isControlled ? (value as T) : internalValue;\n  return [currentValue, setValue];\n}\n"],"names":[],"mappings":";;;;AAiBA;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG;;AAKJ;;;AAIA;;;;AAMA;AACA;AACA;;AAGE;AACF;;AAGE;AACF;;;;AAKE;AACA;;;;AAOM;AAEJ;;AAEJ;AAEA;AAEI;AACE;AACA;AACF;AAGA;;AAEE;;AAEF;AACF;;AAKF;AACF;;"}

package/dist/esm/hooks/useDebounced/useDebouncedCallback.js.map

@@ -1 +1 @@
-{"version":3,"file":"useDebouncedCallback.js","sources":["../../../../../src/hooks/useDebounced/useDebouncedCallback.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAWA;;;;;;;;;;;;;;;;AAgBG;AACG;;;;AASJ;AAEA;AACA;AACA;AACA;AAEA;AACE;AACE;AACA;;AAEF;AACE;AACA;;;AAIJ;AACE;AACA;AACA;AACA;AACA;AAAU;AACZ;AAEA;AACE;AACE;;;;AAIA;AACA;;;;;AAOE;AACA;AACA;;AAGF;AAA+B;AAC/B;AACE;AACA;AAAkC;AAC7B;AACH;AACA;;;;AAKF;AACE;AACA;AAAkC;;;AAGxC;AAEA;AACE;AACA;AACF;AACA;AACE;AAAkC;;AAC7B;AACP;AAEA;AACF;;;AAKA;AACF;;"}
+{"version":3,"file":"useDebouncedCallback.js","sources":["src/hooks/useDebounced/useDebouncedCallback.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useEffect, useMemo, useRef } from 'react';\n\nimport { useEventCallback } from '@/hooks/useEventCallback';\n\nimport type {\n  DebouncedCallback,\n  UseDebouncedCallbackOptions,\n} from './useDebounced.types';\n\n/**\n * Wrap a function so rapid calls collapse into one. By default the call\n * fires on the trailing edge — pass `leading: true` to also fire\n * immediately. `maxWait` forces a call even when calls keep coming.\n *\n * The wrapper identity is stable; passing fresh inline functions across\n * renders is safe and does not reset pending timers.\n *\n * @example\n * ```tsx\n * const onResize = useDebouncedCallback(measure, 150);\n * useEffect(() => {\n *   window.addEventListener('resize', onResize);\n *   return () => window.removeEventListener('resize', onResize);\n * }, [onResize]);\n * ```\n */\nexport function useDebouncedCallback<Args extends unknown[]>(\n  fn: (...args: Args) => void,\n  delay: number,\n  options: UseDebouncedCallbackOptions = {}\n): DebouncedCallback<Args> {\n  const { leading = false, maxWait } = options;\n\n  // Stable wrapper that always invokes the current callback, refreshed via\n  // useInsertionEffect so the debounced wrapper never goes stale.\n  const stableFn = useEventCallback(fn);\n\n  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const maxTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const lastArgsRef = useRef<Args | null>(null);\n  const lastInvokeRef = useRef<number>(0);\n\n  const clearTimers = useCallback(() => {\n    if (timerRef.current !== null) {\n      clearTimeout(timerRef.current);\n      timerRef.current = null;\n    }\n    if (maxTimerRef.current !== null) {\n      clearTimeout(maxTimerRef.current);\n      maxTimerRef.current = null;\n    }\n  }, []);\n\n  const invoke = useCallback(() => {\n    const args = lastArgsRef.current;\n    lastArgsRef.current = null;\n    lastInvokeRef.current = Date.now();\n    clearTimers();\n    if (args) stableFn(...args);\n  }, [clearTimers, stableFn]);\n\n  const debounced = useMemo<DebouncedCallback<Args>>(() => {\n    const wrapper = (...args: Args): void => {\n      lastArgsRef.current = args;\n      // Date.now() runs only when the wrapper is invoked from an event/timer,\n      // never during render, so it is not a render-purity concern here.\n      // eslint-disable-next-line react-hooks/purity\n      const now = Date.now();\n      const isLeadingCall =\n        leading && timerRef.current === null && maxTimerRef.current === null;\n\n      if (isLeadingCall) {\n        // Fire immediately, then suppress trailing for `delay` ms unless\n        // additional calls happen — in that case the trailing handler will\n        // pick them up.\n        lastArgsRef.current = null;\n        lastInvokeRef.current = now;\n        stableFn(...args);\n      }\n\n      if (timerRef.current !== null) clearTimeout(timerRef.current);\n      timerRef.current = setTimeout(() => {\n        timerRef.current = null;\n        if (lastArgsRef.current !== null) invoke();\n        else if (maxTimerRef.current !== null) {\n          clearTimeout(maxTimerRef.current);\n          maxTimerRef.current = null;\n        }\n      }, delay);\n\n      if (maxWait !== undefined && maxTimerRef.current === null) {\n        maxTimerRef.current = setTimeout(() => {\n          maxTimerRef.current = null;\n          if (lastArgsRef.current !== null) invoke();\n        }, maxWait);\n      }\n    };\n\n    wrapper.cancel = () => {\n      lastArgsRef.current = null;\n      clearTimers();\n    };\n    wrapper.flush = () => {\n      if (lastArgsRef.current !== null) invoke();\n      else clearTimers();\n    };\n\n    return wrapper;\n  }, [delay, leading, maxWait, invoke, clearTimers, stableFn]);\n\n  // Cleanup on unmount.\n  useEffect(() => clearTimers, [clearTimers]);\n\n  return debounced;\n}\n"],"names":[],"mappings":";;;;AAWA;;;;;;;;;;;;;;;;AAgBG;AACG;;;;AASJ;AAEA;AACA;AACA;AACA;AAEA;AACE;AACE;AACA;;AAEF;AACE;AACA;;;AAIJ;AACE;AACA;AACA;AACA;AACA;AAAU;AACZ;AAEA;AACE;AACE;;;;AAIA;AACA;;;;;AAOE;AACA;AACA;;AAGF;AAA+B;AAC/B;AACE;AACA;AAAkC;AAC7B;AACH;AACA;;;;AAKF;AACE;AACA;AAAkC;;;AAGxC;AAEA;AACE;AACA;AACF;AACA;AACE;AAAkC;;AAC7B;AACP;AAEA;AACF;;;AAKA;AACF;;"}

package/dist/esm/hooks/useDebounced/useDebouncedValue.js.map

@@ -1 +1 @@
-{"version":3,"file":"useDebouncedValue.js","sources":["../../../../../src/hooks/useDebounced/useDebouncedValue.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACG;;;AAIF;;;;;;;AAOA;;;AAGA;;AAEA;AACF;AAEA;AACF;;"}
+{"version":3,"file":"useDebouncedValue.js","sources":["src/hooks/useDebounced/useDebouncedValue.ts"],"sourcesContent":["'use client';\n\nimport { useEffect, useState } from 'react';\n\n/**\n * Returns a copy of `value` that updates only after `delay` ms have elapsed\n * without further changes (trailing-edge debounce).\n *\n * @deprecated Prefer React's `useDeferredValue` for the common case — keeping\n * an input responsive while an expensive derivation (filtering, search) lags\n * behind it. It needs no fixed delay, integrates with concurrent rendering,\n * and gives better interactivity on large lists. Reach for `useDebouncedCallback`\n * when you need to debounce a *side effect* (a network request, an analytics\n * ping) rather than a rendered value. This hook stays exported for now but\n * will not see further work.\n *\n * @example\n * ```tsx\n * // Preferred: defer the value that drives the expensive derivation.\n * const deferredQuery = useDeferredValue(query);\n * const results = useMemo(\n *   () => filter(items, deferredQuery),\n *   [items, deferredQuery]\n * );\n * ```\n */\nexport function useDebouncedValue<T>(value: T, delay: number): T {\n  const [debounced, setDebounced] = useState<T>(value);\n\n  useEffect(() => {\n    if (delay <= 0) {\n      // Synchronous passthrough when debouncing is disabled; this hook's whole\n      // purpose is to mirror an external value into state.\n      // eslint-disable-next-line react-hooks/set-state-in-effect\n      setDebounced(value);\n      return;\n    }\n    const id = setTimeout(() => {\n      setDebounced(value);\n    }, delay);\n    return () => {\n      clearTimeout(id);\n    };\n  }, [value, delay]);\n\n  return debounced;\n}\n"],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;AAqBG;AACG;;;AAIF;;;;;;;AAOA;;;AAGA;;AAEA;AACF;AAEA;AACF;;"}

package/dist/esm/hooks/useDisclosure/useDisclosure.js.map

@@ -1 +1 @@
-{"version":3,"file":"useDisclosure.js","sources":["../../../../../src/hooks/useDisclosure/useDisclosure.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAWA;;;;;;;;;;;;;;;;;;;AAmBG;AACG;;AAKJ;AACE;AACA;AACA;AACA;AACD;AAED;;AAGE;AAIF;;AAEA;AAEA;;AAEA;AAEA;;AAEA;AAEA;AAIF;;"}
+{"version":3,"file":"useDisclosure.js","sources":["src/hooks/useDisclosure/useDisclosure.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useMemo } from 'react';\n\nimport { useControlledState } from '@/hooks/useControlledState';\n\nimport type {\n  UseDisclosureOptions,\n  UseDisclosureReturn,\n} from './useDisclosure.types';\n\n/**\n * Manage an open/closed state with stable `open`, `close`, `toggle` callbacks.\n *\n * Supports both controlled (driven by an `open` prop) and uncontrolled\n * (managed internally with `defaultOpen`) modes. Built on top of\n * `useControlledState` so the same controlled / uncontrolled rules apply —\n * including the development warning when switching modes mid-life.\n *\n * @example\n * ```tsx\n * const { isOpen, open, close, toggle } = useDisclosure();\n *\n * return (\n *   <>\n *     <Button onClick={open}>Open</Button>\n *     <Dialog open={isOpen} onClose={close}>...</Dialog>\n *   </>\n * );\n * ```\n */\nexport function useDisclosure(\n  options: UseDisclosureOptions = {}\n): UseDisclosureReturn {\n  const { defaultOpen, open: controlledOpen, onOpenChange } = options;\n\n  const [isOpen, setOpenState] = useControlledState<boolean>({\n    value: controlledOpen,\n    defaultValue: defaultOpen,\n    onChange: onOpenChange,\n    fallback: false,\n  });\n\n  const setOpen = useCallback(\n    (next: boolean) => {\n      setOpenState(next);\n    },\n    [setOpenState]\n  );\n\n  const open = useCallback(() => {\n    setOpenState(true);\n  }, [setOpenState]);\n\n  const close = useCallback(() => {\n    setOpenState(false);\n  }, [setOpenState]);\n\n  const toggle = useCallback(() => {\n    setOpenState(prev => !prev);\n  }, [setOpenState]);\n\n  return useMemo(\n    () => ({ isOpen, open, close, toggle, setOpen }),\n    [isOpen, open, close, toggle, setOpen]\n  );\n}\n"],"names":[],"mappings":";;;;AAWA;;;;;;;;;;;;;;;;;;;AAmBG;AACG;;AAKJ;AACE;AACA;AACA;AACA;AACD;AAED;;AAGE;AAIF;;AAEA;AAEA;;AAEA;AAEA;;AAEA;AAEA;AAIF;;"}

package/dist/esm/hooks/useEventCallback/useEventCallback.js.map

@@ -1 +1 @@
-{"version":3,"file":"useEventCallback.js","sources":["../../../../../src/hooks/useEventCallback/useEventCallback.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACG;AAGJ;;;;;;AAOE;AACF;;;;AAKA;AACF;;"}
+{"version":3,"file":"useEventCallback.js","sources":["src/hooks/useEventCallback/useEventCallback.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useInsertionEffect, useRef } from 'react';\n\n/**\n * Wrap a callback so its identity stays stable for the component lifetime\n * while it always invokes the most recently rendered version — the\n * `useEffectEvent` pattern, backed by `useInsertionEffect`.\n *\n * The stored callback is refreshed in `useInsertionEffect`, which commits\n * before any layout effect. So the freshness guarantee holds even for\n * consumers that read it during the same commit: a child's\n * `useLayoutEffect`, a synchronous external-store subscription, an\n * imperative handle. A passively updated ref (e.g. `useLatest`, which writes\n * in `useEffect`) would still be one render stale in those cases.\n *\n * Pass the result to memoized children, dependency arrays, or external\n * subscriptions without re-subscribing — the reference never changes, yet it\n * still closes over the latest props and state.\n *\n * The one rule: do not call it during render. Like an event handler it reads\n * through a ref, so a render-phase call has no meaningful \"latest\" value to\n * read. Use it in event handlers, effects, layout effects, timers, and\n * subscriptions only.\n *\n * @example\n * ```tsx\n * const handleChange = useEventCallback((value: string) => {\n *   onChange?.(value, internalState);\n * });\n * useEffect(() => store.subscribe(handleChange), [handleChange]);\n * ```\n */\nexport function useEventCallback<Args extends unknown[], Return>(\n  fn: (...args: Args) => Return\n): (...args: Args) => Return {\n  const ref = useRef(fn);\n\n  // Refresh the stored callback before layout effects run. useInsertionEffect\n  // commits earlier than useEffect / useLayoutEffect, so children's layout\n  // effects and synchronous subscriptions firing in the same commit already\n  // observe the latest callback.\n  useInsertionEffect(() => {\n    ref.current = fn;\n  }, [fn]);\n\n  // Stable wrapper for the component lifetime. Reading `ref.current` happens\n  // only when the wrapper is invoked from an event, effect, or timer — never\n  // during render.\n  return useCallback((...args: Args): Return => ref.current(...args), []);\n}\n"],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACG;AAGJ;;;;;;AAOE;AACF;;;;AAKA;AACF;;"}

package/dist/esm/hooks/useFocusTrap/useFocusTrap.js.map

@@ -1 +1 @@
-{"version":3,"file":"useFocusTrap.js","sources":["../../../../../src/hooks/useFocusTrap/useFocusTrap.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAMA;;;;;;;AAOC;AAaD;;;;;;;;;;;;;AAaG;AACG;AAIJ;AAEI;;AAEA;AACA;;AAEA;AAIA;;;;AAKA;;AAKA;AACE;;;;;;AAKA;;;;;AAKJ;AAGJ;;"}
+{"version":3,"file":"useFocusTrap.js","sources":["src/hooks/useFocusTrap/useFocusTrap.ts"],"sourcesContent":["'use client';\n\nimport { useCallback } from 'react';\n\nimport type { KeyboardEvent, RefObject } from 'react';\n\nconst FOCUSABLE_SELECTOR = [\n  'a[href]',\n  'button:not([disabled])',\n  'input:not([disabled])',\n  'textarea:not([disabled])',\n  'select:not([disabled])',\n  '[tabindex]:not([tabindex=\"-1\"])',\n].join(', ');\n\nexport interface UseFocusTrapOptions {\n  /** Ref to the container element whose focusable descendants are trapped. */\n  containerRef: RefObject<HTMLElement | null>;\n  /**\n   * When false, the trap is bypassed (Tab works normally). Useful for toggling\n   * trap state without unmounting.\n   * @default true\n   */\n  enabled?: boolean;\n}\n\n/**\n * Trap focus within a container element. Tab and Shift+Tab cycle through the\n * focusable descendants without escaping the container.\n *\n * Returns a keyboard event handler to attach to the container's `onKeyDown`.\n *\n * @example\n * ```tsx\n * const ref = useRef<HTMLDivElement>(null);\n * const handleKeyDown = useFocusTrap({ containerRef: ref, enabled: isOpen });\n *\n * return <div ref={ref} onKeyDown={handleKeyDown}>...</div>;\n * ```\n */\nexport function useFocusTrap({\n  containerRef,\n  enabled = true,\n}: UseFocusTrapOptions): (event: KeyboardEvent) => void {\n  return useCallback(\n    (e: KeyboardEvent) => {\n      if (!enabled || e.key !== 'Tab') return;\n\n      const container = containerRef.current;\n      if (!container) return;\n\n      const focusableElements = Array.from(\n        container.querySelectorAll<HTMLElement>(FOCUSABLE_SELECTOR)\n      );\n\n      if (focusableElements.length === 0) {\n        e.preventDefault();\n        return;\n      }\n\n      const firstElement = focusableElements[0] as HTMLElement;\n      const lastElement = focusableElements[\n        focusableElements.length - 1\n      ] as HTMLElement;\n\n      if (e.shiftKey) {\n        if (document.activeElement === firstElement) {\n          e.preventDefault();\n          lastElement.focus();\n        }\n      } else {\n        if (document.activeElement === lastElement) {\n          e.preventDefault();\n          firstElement.focus();\n        }\n      }\n    },\n    [enabled, containerRef]\n  );\n}\n\nexport { FOCUSABLE_SELECTOR };\n"],"names":[],"mappings":";;;AAMA;;;;;;;AAOC;AAaD;;;;;;;;;;;;;AAaG;AACG;AAIJ;AAEI;;AAEA;AACA;;AAEA;AAIA;;;;AAKA;;AAKA;AACE;;;;;;AAKA;;;;;AAKJ;AAGJ;;"}

package/dist/esm/hooks/useHotkey/useHotkey.js.map

@@ -1 +1 @@
-{"version":3,"file":"useHotkey.js","sources":["../../../../../src/hooks/useHotkey/useHotkey.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAUA;AACE;AAEE;;AAGJ;AAEA;AACE;AACE;;;AAEmB;;;AAErB;AACF;AAWA;AAEA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGF;AACE;AACA;AACF;AAEA;AACE;AACA;AAAwB;AAExB;AACA;;;;;;AAQA;AACE;AACA;;AAEI;;;AAGA;;;;;;;;;AAQA;;;AAGA;AACA;;;AAGA;;;;;;AAKF;;;;AAIc;;AAEpB;AAEA;AACE;AAAsC;;AACR;AAC9B;AACA;;;AAGE;;;;;;;;;;AAUC;AACD;;AAEF;AACF;AAEA;AACE;AAAmC;AACnC;AAAmC;AACnC;AAAiC;AACjC;AAAqC;;AAGrC;AACF;AAEA;;;;;;;;;;;;;;;;;AAiBG;AACG;;;;AAeJ;;;;;;AAMC;AAED;AACA;AAEA;AACA;;;;;;AAOE;AACA;;;;;AAQA;AACA;AACE;;;AAIF;;AAEE;AACA;AACA;;AACA;;;;;;AAIA;;;AAEF;AACA;AACA;AACF;AAEA;;;;AAQI;AACA;;AAIN;;"}
+{"version":3,"file":"useHotkey.js","sources":["src/hooks/useHotkey/useHotkey.ts"],"sourcesContent":["'use client';\n\nimport { useEffect, useMemo, useRef } from 'react';\n\nimport { useLatest } from '@/hooks/useLatest';\nimport { getPlatform, parseShortcut } from '@/utils/platform';\n\nimport type { HotkeyTarget, UseHotkeyOptions } from './useHotkey.types';\nimport type { RefObject } from 'react';\n\nfunction isRefObject(value: unknown): value is RefObject<EventTarget | null> {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    'current' in (value as Record<string, unknown>)\n  );\n}\n\nfunction resolveTarget(target: HotkeyTarget | undefined): EventTarget | null {\n  if (target === undefined) {\n    return typeof window === 'undefined' ? null : window;\n  }\n  if (target === null) return null;\n  if (isRefObject(target)) return target.current;\n  return target;\n}\n\ninterface ParsedCombo {\n  ctrl: boolean;\n  meta: boolean;\n  alt: boolean;\n  shift: boolean;\n  /** Lower-cased non-modifier key, e.g. \"s\", \"k\", \"escape\", \"arrowup\". */\n  key: string;\n}\n\nconst MODIFIERS = new Set(['ctrl', 'cmd', 'meta', 'alt', 'option', 'shift']);\n\nconst KEY_ALIASES: Record<string, string> = {\n  esc: 'escape',\n  return: 'enter',\n  space: ' ',\n  spacebar: ' ',\n  up: 'arrowup',\n  down: 'arrowdown',\n  left: 'arrowleft',\n  right: 'arrowright',\n  plus: '+',\n};\n\nfunction normalizeKey(key: string): string {\n  const lower = key.toLowerCase();\n  return KEY_ALIASES[lower] ?? lower;\n}\n\nfunction parseCombo(combo: string): ParsedCombo | null {\n  const parts = parseShortcut(combo);\n  if (parts.length === 0) return null;\n\n  const platform = getPlatform();\n  const isMac = platform === 'mac';\n\n  let ctrl = false;\n  let meta = false;\n  let alt = false;\n  let shift = false;\n  let key: string | null = null;\n\n  for (const raw of parts) {\n    const lower = raw.toLowerCase();\n    if (MODIFIERS.has(lower)) {\n      switch (lower) {\n        case 'ctrl':\n          ctrl = true;\n          break;\n        case 'cmd':\n          // Cmd auto-maps to Ctrl on non-Mac.\n          if (isMac) {\n            meta = true;\n          } else {\n            ctrl = true;\n          }\n          break;\n        case 'meta':\n          meta = true;\n          break;\n        case 'alt':\n        case 'option':\n          alt = true;\n          break;\n        case 'shift':\n          shift = true;\n          break;\n      }\n    } else {\n      key = normalizeKey(raw);\n    }\n  }\n\n  if (key === null) return null;\n  return { ctrl, meta, alt, shift, key };\n}\n\nfunction isEditableTarget(target: EventTarget | null): boolean {\n  if (!(target instanceof HTMLElement)) return false;\n  if (target.isContentEditable) return true;\n  const tag = target.tagName;\n  if (tag === 'INPUT') {\n    const type = (target as HTMLInputElement).type.toLowerCase();\n    // Buttons and similar non-text inputs should not block hotkeys.\n    const nonEditable = new Set([\n      'button',\n      'submit',\n      'reset',\n      'checkbox',\n      'radio',\n      'file',\n      'image',\n      'range',\n      'color',\n    ]);\n    return !nonEditable.has(type);\n  }\n  return tag === 'TEXTAREA' || tag === 'SELECT';\n}\n\nfunction matches(parsed: ParsedCombo, event: KeyboardEvent): boolean {\n  if (event.ctrlKey !== parsed.ctrl) return false;\n  if (event.metaKey !== parsed.meta) return false;\n  if (event.altKey !== parsed.alt) return false;\n  if (event.shiftKey !== parsed.shift) return false;\n\n  const eventKey = event.key.toLowerCase();\n  return eventKey === parsed.key;\n}\n\n/**\n * Bind a single keyboard combo to a callback.\n *\n * Combos use the same `+`-separated string format as `MenuBar`'s `shortcut`\n * prop: `\"Ctrl+S\"`, `\"Cmd+Shift+P\"`, `\"Escape\"`. Modifiers: `Ctrl`, `Cmd`\n * (= Meta), `Alt` / `Option`, `Shift`. `Cmd` automatically maps to `Ctrl` on\n * non-Mac platforms via `getPlatform()`.\n *\n * The handler reference is stable — passing a fresh inline function on every\n * render is safe and does not re-subscribe the underlying listener.\n *\n * @example\n * ```tsx\n * useHotkey('Ctrl+S', e => save(), { preventDefault: true });\n * useHotkey('Escape', () => setOpen(false));\n * useHotkey('Cmd+K', () => openCommandPalette()); // Cmd on Mac, Ctrl elsewhere\n * ```\n */\nexport function useHotkey(\n  combo: string,\n  handler: (event: KeyboardEvent) => void,\n  options: UseHotkeyOptions = {}\n): void {\n  const {\n    enabled = true,\n    enableInInputs = false,\n    preventDefault = true,\n    stopPropagation = false,\n    target,\n  } = options;\n\n  // Latest handler / options / parsed combo, refreshed after each commit so\n  // the document listener reads live values without re-subscribing.\n  const handlerRef = useLatest(handler);\n  const optionsRef = useLatest({\n    enabled,\n    enableInInputs,\n    preventDefault,\n    stopPropagation,\n  });\n\n  const parsed = useMemo(() => parseCombo(combo), [combo]);\n  const parsedRef = useLatest(parsed);\n\n  const attachedTargetRef = useRef<EventTarget | null>(null);\n  const listenerRef = useRef<((event: Event) => void) | null>(null);\n\n  // Runs every render so a ref whose `.current` becomes available after the\n  // first render (conditional rendering, lazy children) is picked up. The\n  // identity check on the resolved target keeps re-attaches limited to the\n  // moments the underlying element actually changes.\n  useEffect(() => {\n    const desired = enabled && parsed !== null ? resolveTarget(target) : null;\n    if (desired === attachedTargetRef.current) return;\n\n    if (attachedTargetRef.current && listenerRef.current) {\n      attachedTargetRef.current.removeEventListener(\n        'keydown',\n        listenerRef.current\n      );\n    }\n    attachedTargetRef.current = desired;\n    if (desired === null) {\n      listenerRef.current = null;\n      return;\n    }\n\n    const listener = (event: Event) => {\n      const ke = event as KeyboardEvent;\n      const opts = optionsRef.current;\n      const p = parsedRef.current;\n      if (p === null || !opts.enabled) return;\n      if (!matches(p, ke)) return;\n      if (!opts.enableInInputs && isEditableTarget(ke.target)) return;\n\n      if (opts.preventDefault) ke.preventDefault();\n      handlerRef.current(ke);\n      if (opts.stopPropagation) ke.stopPropagation();\n    };\n    listenerRef.current = listener;\n    desired.addEventListener('keydown', listener);\n  });\n\n  useEffect(\n    () => () => {\n      if (attachedTargetRef.current && listenerRef.current) {\n        attachedTargetRef.current.removeEventListener(\n          'keydown',\n          listenerRef.current\n        );\n      }\n      attachedTargetRef.current = null;\n      listenerRef.current = null;\n    },\n    []\n  );\n}\n"],"names":[],"mappings":";;;;;AAUA;AACE;AAEE;;AAGJ;AAEA;AACE;AACE;;;AAEmB;;;AAErB;AACF;AAWA;AAEA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAGF;AACE;AACA;AACF;AAEA;AACE;AACA;AAAwB;AAExB;AACA;;;;;;AAQA;AACE;AACA;;AAEI;;;AAGA;;;;;;;;;AAQA;;;AAGA;AACA;;;AAGA;;;;;;AAKF;;;;AAIc;;AAEpB;AAEA;AACE;AAAsC;;AACR;AAC9B;AACA;;;AAGE;;;;;;;;;;AAUC;AACD;;AAEF;AACF;AAEA;AACE;AAAmC;AACnC;AAAmC;AACnC;AAAiC;AACjC;AAAqC;;AAGrC;AACF;AAEA;;;;;;;;;;;;;;;;;AAiBG;AACG;;;;AAeJ;;;;;;AAMC;AAED;AACA;AAEA;AACA;;;;;;AAOE;AACA;;;;;AAQA;AACA;AACE;;;AAIF;;AAEE;AACA;AACA;;AACA;;;;;;AAIA;;;AAEF;AACA;AACA;AACF;AAEA;;;;AAQI;AACA;;AAIN;;"}

package/dist/esm/hooks/useIntersectionObserver/useIntersectionObserver.js.map

@@ -1 +1 @@
-{"version":3,"file":"useIntersectionObserver.js","sources":["../../../../../src/hooks/useIntersectionObserver/useIntersectionObserver.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;AAgBG;AACG;AAGJ;;AAGA;AACA;AAEA;AAEI;AACE;;;AAIF;AACE;AACA;;AAGF;AACA;;;;AAKA;AAEI;AACA;;AACF;AAGF;AACA;;;;;AAQF;;AACA;AACE;AACA;;;;;AAKJ;;AAGA;AAEI;AACA;AACA;;;;;AAQF;;AAEJ;;"}
+{"version":3,"file":"useIntersectionObserver.js","sources":["src/hooks/useIntersectionObserver/useIntersectionObserver.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useEffect, useRef, useState } from 'react';\n\nimport type {\n  UseIntersectionObserverOptions,\n  UseIntersectionObserverReturn,\n} from './useIntersectionObserver.types';\nimport type React from 'react';\n\n/**\n * Observe whether an element intersects a root (defaults to the viewport).\n * Returns a ref callback to attach to the observed element plus the latest\n * `IntersectionObserverEntry`. SSR-safe: returns a no-op ref and `null`\n * entry when `IntersectionObserver` is unavailable.\n *\n * @example\n * ```tsx\n * const { ref, isIntersecting } = useIntersectionObserver<HTMLDivElement>({\n *   rootMargin: '200px',\n * });\n * useEffect(() => {\n *   if (isIntersecting) loadMore();\n * }, [isIntersecting]);\n * return <div ref={ref} />;\n * ```\n */\nexport function useIntersectionObserver<T extends Element = Element>(\n  options: UseIntersectionObserverOptions = {}\n): UseIntersectionObserverReturn<T> {\n  const { root, rootMargin, threshold, enabled = true } = options;\n\n  const [entry, setEntry] = useState<IntersectionObserverEntry | null>(null);\n  const observerRef = useRef<IntersectionObserver | null>(null);\n  const nodeRef = useRef<T | null>(null);\n\n  const ref = useCallback<React.RefCallback<T>>(\n    node => {\n      if (typeof IntersectionObserver === 'undefined') {\n        nodeRef.current = node;\n        return;\n      }\n\n      if (observerRef.current) {\n        observerRef.current.disconnect();\n        observerRef.current = null;\n      }\n\n      nodeRef.current = node;\n      if (!enabled || !node) {\n        setEntry(null);\n        return;\n      }\n\n      const observer = new IntersectionObserver(\n        entries => {\n          const next = entries[0];\n          if (next) setEntry(next);\n        },\n        { root: root ?? null, rootMargin, threshold }\n      );\n      observer.observe(node);\n      observerRef.current = observer;\n    },\n    [root, rootMargin, threshold, enabled]\n  );\n\n  // When toggled off via `enabled`, disconnect proactively so consumers don't\n  // have to detach the ref to stop observing.\n  useEffect(() => {\n    if (enabled) return;\n    if (observerRef.current) {\n      observerRef.current.disconnect();\n      observerRef.current = null;\n    }\n    // Sync state to the external observer being torn down when disabled.\n    // eslint-disable-next-line react-hooks/set-state-in-effect\n    setEntry(null);\n  }, [enabled]);\n\n  // Final cleanup on unmount.\n  useEffect(\n    () => () => {\n      observerRef.current?.disconnect();\n      observerRef.current = null;\n      nodeRef.current = null;\n    },\n    []\n  );\n\n  return {\n    ref,\n    entry,\n    isIntersecting: entry?.isIntersecting ?? false,\n  };\n}\n"],"names":[],"mappings":";;;AAUA;;;;;;;;;;;;;;;;AAgBG;AACG;AAGJ;;AAGA;AACA;AAEA;AAEI;AACE;;;AAIF;AACE;AACA;;AAGF;AACA;;;;AAKA;AAEI;AACA;;AACF;AAGF;AACA;;;;;AAQF;;AACA;AACE;AACA;;;;;AAKJ;;AAGA;AAEI;AACA;AACA;;;;;AAQF;;AAEJ;;"}

package/dist/esm/hooks/useIsMounted/useIsMounted.js.map

@@ -1 +1 @@
-{"version":3,"file":"useIsMounted.js","sources":["../../../../../src/hooks/useIsMounted/useIsMounted.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;;AAED;;AAGE;AACA;AACE;AACF;;;;;AAMJ;;"}
+{"version":3,"file":"useIsMounted.js","sources":["src/hooks/useIsMounted/useIsMounted.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useEffect, useRef } from 'react';\n\n/**\n * Returns a stable getter that reports whether the component is still\n * mounted. Call it inside async continuations (promises, timers, fetches)\n * before committing state, so a resolution that lands after unmount becomes\n * a no-op instead of a \"set state on an unmounted component\" warning.\n *\n * The getter identity is stable for the component lifetime, so it is safe to\n * include in — or omit from — dependency arrays without churn. It reports\n * `false` until the mount effect commits and `false` again after unmount,\n * which also covers the double mount/unmount of React StrictMode.\n *\n * Prefer real cancellation (`AbortController`, effect cleanup) where the\n * async source supports it; reach for this only when the source cannot be\n * cancelled.\n *\n * @example\n * ```tsx\n * const isMounted = useIsMounted();\n * useEffect(() => {\n *   void load().then(data => {\n *     if (isMounted()) setData(data);\n *   });\n * }, [isMounted]);\n * ```\n */\nexport function useIsMounted(): () => boolean {\n  const mountedRef = useRef(false);\n\n  useEffect(() => {\n    mountedRef.current = true;\n    return () => {\n      mountedRef.current = false;\n    };\n  }, []);\n\n  // Reading `mountedRef.current` happens only when the getter is invoked from\n  // an async continuation or effect — never during render.\n  return useCallback(() => mountedRef.current, []);\n}\n"],"names":[],"mappings":";;;AAIA;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;;AAED;;AAGE;AACA;AACE;AACF;;;;;AAMJ;;"}

package/dist/esm/hooks/useKeyboard/useKeyboard.js.map

@@ -1 +1 @@
-{"version":3,"file":"useKeyboard.js","sources":["../../../../../src/hooks/useKeyboard/useKeyboard.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;AACI;AACL;AAIA;AACE;;AAGF;AACE;;;AAIA;AACA;AAEA;AACE;AACA;AACF;AACF;AAEA;AACF;;"}
+{"version":3,"file":"useKeyboard.js","sources":["src/hooks/useKeyboard/useKeyboard.tsx"],"sourcesContent":["'use client';\n\n// src/hooks/useKeyboard.ts\nimport { useEffect, useState, useCallback, useMemo } from 'react';\n\nimport { updateState, mapInnerStateToState } from './utils';\n\nimport type { KeyboardState, KeyboardInnerState, AllKeys } from './types';\n\nexport type { ModifierKeys, KeyboardState, AllKeys } from './types';\nexport { isKeyPressed, isModifierKey } from './utils';\n\n/**\n * Hook for tracking keyboard state including modifier keys and pressed keys.\n *\n * Useful for components that need to respond to keyboard modifiers like\n * Ctrl+drag for snapping, Shift+drag for precision, etc.\n * @returns Current keyboard state\n *\n * @example\n * ```tsx\n * // Track all keys and modifiers\n * const keyboard = useKeyboard();\n *\n * const handleMouseMove = (e: MouseEvent) => {\n *   if (keyboard.ctrl) {\n *     // Snap to grid\n *   } else if (keyboard.shift) {\n *     // Precision mode\n *   }\n * };\n *\n * // Track only specific keys\n * const keyboard = useKeyboard({\n *   trackAllKeys: false,\n *   trackedKeys: ['Space', 'Enter', 'Escape']\n * });\n *\n * // Check if specific key is pressed\n * const isSpacePressed = keyboard.pressedKeys.includes('Space');\n * ```\n */\nexport const useKeyboard = (): KeyboardState => {\n  const [keyboardState, setKeyboardState] = useState<KeyboardInnerState>(\n    new Set<AllKeys>()\n  );\n\n  const handleKeyDown = useCallback((event: KeyboardEvent) => {\n    setKeyboardState(prevState => updateState(prevState, event));\n  }, []);\n\n  const handleKeyUp = useCallback((event: KeyboardEvent) => {\n    setKeyboardState(prevState => updateState(prevState, event));\n  }, []);\n\n  useEffect(() => {\n    window.addEventListener('keydown', handleKeyDown);\n    window.addEventListener('keyup', handleKeyUp);\n\n    return () => {\n      window.removeEventListener('keydown', handleKeyDown);\n      window.removeEventListener('keyup', handleKeyUp);\n    };\n  }, [handleKeyDown, handleKeyUp]);\n\n  return useMemo(() => mapInnerStateToState(keyboardState), [keyboardState]);\n};\n"],"names":[],"mappings":";;;;;AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BG;AACI;AACL;AAIA;AACE;;AAGF;AACE;;;AAIA;AACA;AAEA;AACE;AACA;AACF;AACF;AAEA;AACF;;"}

package/dist/esm/hooks/useKeyboard/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sources":["../../../../../src/hooks/useKeyboard/utils.ts"],"sourcesContent":[null],"names":[],"mappings":";;AASO,MAAM,aAAa,GAAG,CAAC,GAAW,KAAyB;AAChE,IAAA,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC;AAClE;AAEA,MAAM,cAAc,GAAG,CACrB,SAA6B,EAC7B,GAAY,KACU;AACtB,IAAA,IAAI,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;AACtB,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC;AACnC,IAAA,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC;AACjB,IAAA,OAAO,QAAQ;AACjB,CAAC;AAED,MAAM,gBAAgB,GAAG,CACvB,SAA6B,EAC7B,GAAY,KACU;IACtB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;AACvB,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC;AACnC,IAAA,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC;AACpB,IAAA,OAAO,QAAQ;AACjB,CAAC;MAEY,WAAW,GAAG,CACzB,SAA6B,EAC7B,KAAoB,KACE;IACtB,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,WAAW,EAAE;AACnC,IAAA,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI;IAC5B,QAAQ,SAAS;AACf,QAAA,KAAK,SAAS;AACZ,YAAA,OAAO,cAAc,CAAC,SAAS,EAAE,GAAG,CAAC;AACvC,QAAA,KAAK,OAAO;AACV,YAAA,OAAO,gBAAgB,CAAC,SAAS,EAAE,GAAG,CAAC;AACzC,QAAA;AACE,YAAA,OAAO,CAAC,CAAA,sBAAA,EAAyB,SAAS,CAAA,CAAE,CAAC;AAC7C,YAAA,OAAO,SAAS;;AAEtB;AAEO,MAAM,oBAAoB,GAAG,CAClC,UAA8B,KACb;AACjB,IAAA,MAAM,SAAS,GAA+B;AAC5C,QAAA,OAAO,EAAE,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;AAC5D,QAAA,KAAK,EAAE,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC;AAC9B,QAAA,GAAG,EAAE,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC;AAC1B,QAAA,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;KAC7B;IACD,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;IAC7E,OAAO;QACL,WAAW;QACX,SAAS;KACV;AACH;MAEa,YAAY,GAAG,CAC1B,aAA4B,EAC5B,GAAY,KACD;AACX,IAAA,IAAI,aAAa,CAAC,GAAG,CAAC,EAAE;AACtB,QAAA,OAAO,aAAa,CAAC,SAAS,CAAC,GAAG,CAAC;IACrC;IACA,OAAO,aAAa,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC;AAChD;;;;"}
+{"version":3,"file":"utils.js","sources":["src/hooks/useKeyboard/utils.ts"],"sourcesContent":["import { devWarn } from '@/utils/devWarn';\n\nimport {\n  KeyboardState,\n  KeyboardInnerState,\n  AllKeys,\n  ModifierKeys,\n} from './types';\n\nexport const isModifierKey = (key: string): key is ModifierKeys => {\n  return ['ctrl', 'shift', 'alt', 'meta', 'control'].includes(key);\n};\n\nconst KeypressUpdate = (\n  prevState: KeyboardInnerState,\n  key: AllKeys\n): KeyboardInnerState => {\n  if (prevState.has(key)) {\n    return prevState;\n  }\n  const newState = new Set(prevState);\n  newState.add(key);\n  return newState;\n};\n\nconst KeyReleaseUpdate = (\n  prevState: KeyboardInnerState,\n  key: AllKeys\n): KeyboardInnerState => {\n  if (!prevState.has(key)) {\n    return prevState;\n  }\n  const newState = new Set(prevState);\n  newState.delete(key);\n  return newState;\n};\n\nexport const updateState = (\n  prevState: KeyboardInnerState,\n  event: KeyboardEvent\n): KeyboardInnerState => {\n  const key = event.key.toLowerCase();\n  const eventType = event.type;\n  switch (eventType) {\n    case 'keydown':\n      return KeypressUpdate(prevState, key);\n    case 'keyup':\n      return KeyReleaseUpdate(prevState, key);\n    default:\n      devWarn(`Unhandled event type: ${eventType}`);\n      return prevState;\n  }\n};\n\nexport const mapInnerStateToState = (\n  innerState: KeyboardInnerState\n): KeyboardState => {\n  const modifiers: KeyboardState['modifiers'] = {\n    control: innerState.has('control') || innerState.has('ctrl'),\n    shift: innerState.has('shift'),\n    alt: innerState.has('alt'),\n    meta: innerState.has('meta'),\n  };\n  const pressedKeys = Array.from(innerState).filter(key => !isModifierKey(key));\n  return {\n    pressedKeys,\n    modifiers,\n  };\n};\n\nexport const isKeyPressed = (\n  keyboardState: KeyboardState,\n  key: AllKeys\n): boolean => {\n  if (isModifierKey(key)) {\n    return keyboardState.modifiers[key];\n  }\n  return keyboardState.pressedKeys.includes(key);\n};\n"],"names":[],"mappings":";;AASO,MAAM,aAAa,GAAG,CAAC,GAAW,KAAyB;AAChE,IAAA,OAAO,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC;AAClE;AAEA,MAAM,cAAc,GAAG,CACrB,SAA6B,EAC7B,GAAY,KACU;AACtB,IAAA,IAAI,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;AACtB,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC;AACnC,IAAA,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC;AACjB,IAAA,OAAO,QAAQ;AACjB,CAAC;AAED,MAAM,gBAAgB,GAAG,CACvB,SAA6B,EAC7B,GAAY,KACU;IACtB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE;AACvB,QAAA,OAAO,SAAS;IAClB;AACA,IAAA,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC;AACnC,IAAA,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC;AACpB,IAAA,OAAO,QAAQ;AACjB,CAAC;MAEY,WAAW,GAAG,CACzB,SAA6B,EAC7B,KAAoB,KACE;IACtB,MAAM,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC,WAAW,EAAE;AACnC,IAAA,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI;IAC5B,QAAQ,SAAS;AACf,QAAA,KAAK,SAAS;AACZ,YAAA,OAAO,cAAc,CAAC,SAAS,EAAE,GAAG,CAAC;AACvC,QAAA,KAAK,OAAO;AACV,YAAA,OAAO,gBAAgB,CAAC,SAAS,EAAE,GAAG,CAAC;AACzC,QAAA;AACE,YAAA,OAAO,CAAC,CAAA,sBAAA,EAAyB,SAAS,CAAA,CAAE,CAAC;AAC7C,YAAA,OAAO,SAAS;;AAEtB;AAEO,MAAM,oBAAoB,GAAG,CAClC,UAA8B,KACb;AACjB,IAAA,MAAM,SAAS,GAA+B;AAC5C,QAAA,OAAO,EAAE,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;AAC5D,QAAA,KAAK,EAAE,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC;AAC9B,QAAA,GAAG,EAAE,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC;AAC1B,QAAA,IAAI,EAAE,UAAU,CAAC,GAAG,CAAC,MAAM,CAAC;KAC7B;IACD,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;IAC7E,OAAO;QACL,WAAW;QACX,SAAS;KACV;AACH;MAEa,YAAY,GAAG,CAC1B,aAA4B,EAC5B,GAAY,KACD;AACX,IAAA,IAAI,aAAa,CAAC,GAAG,CAAC,EAAE;AACtB,QAAA,OAAO,aAAa,CAAC,SAAS,CAAC,GAAG,CAAC;IACrC;IACA,OAAO,aAAa,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC;AAChD;;;;"}

package/dist/esm/hooks/useLatest/useLatest.js.map

@@ -1 +1 @@
-{"version":3,"file":"useLatest.js","sources":["../../../../../src/hooks/useLatest/useLatest.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAMA;;;;;;;;;;;;;;;;;AAiBG;AACG;AACJ;;AAEE;AACF;AACA;AACF;;"}
+{"version":3,"file":"useLatest.js","sources":["src/hooks/useLatest/useLatest.ts"],"sourcesContent":["'use client';\n\nimport { useEffect, useRef } from 'react';\n\nimport type { RefObject } from 'react';\n\n/**\n * Keep a ref synced to the latest value of `value` after each render.\n *\n * Useful for reading \"live\" props/state inside event handlers, timers,\n * or external store subscriptions without re-attaching the listener on\n * every render. The ref is updated in `useEffect` so its value reflects\n * the most recently committed render.\n *\n * @example\n * ```ts\n * const latestOnChange = useLatest(onChange);\n * useEffect(() => {\n *   const handler = (e: Event) => latestOnChange.current(e);\n *   target.addEventListener('change', handler);\n *   return () => target.removeEventListener('change', handler);\n * }, [target]);\n * ```\n */\nexport function useLatest<T>(value: T): RefObject<T> {\n  const ref = useRef(value);\n  useEffect(() => {\n    ref.current = value;\n  });\n  return ref;\n}\n"],"names":[],"mappings":";;;AAMA;;;;;;;;;;;;;;;;;AAiBG;AACG;AACJ;;AAEE;AACF;AACA;AACF;;"}

package/dist/esm/hooks/useListboxNav/useListboxNav.js.map

@@ -1 +1 @@
-{"version":3,"file":"useListboxNav.js","sources":["../../../../../src/hooks/useListboxNav/useListboxNav.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAiEA;;;;;;;;;;;;;;;;;;;AAmBG;AACG;;;;AAgBJ;AACA;AACA;AACA;;AAGE;AACF;;AAEE;AACF;;AAEE;AACF;;AAEE;AACF;;AAGA;;AAEE;;AACA;;AAEE;;;AAIJ;AACE;AACA;AACA;AAAe;;AAEf;AACE;AACA;AAAwB;;AAE1B;;;;;AAMF;AACE;AAAqB;;AAErB;AACE;AACA;AAA8B;;AAEhC;AACF;AAEA;AAEI;AACA;AACE;;;;;;AAOE;AACE;AACF;;;;AAG4B;AAC1B;AACA;;;AAGI;;AAEJ;;;;;AAKA;AACA;;AAEI;;;AAGJ;;;AAGN;AACF;AAIF;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AAEA;AACE;AACA;;;AAE6C;AAC3C;AACA;AAA+B;;AAE/B;AACF;;;;;AAMF;AAEI;AAAe;;AAEf;AACA;AACF;AAGF;AAEI;AACE;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;AACE;AACF;AACE;;AAEN;;;;;;;;;;;;AAeJ;;"}
+{"version":3,"file":"useListboxNav.js","sources":["src/hooks/useListboxNav/useListboxNav.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useEffect, useMemo, useRef, useState } from 'react';\n\nimport { useEventCallback } from '@/hooks/useEventCallback';\n\nimport type React from 'react';\n\nexport interface UseListboxNavOptions<T> {\n  /** Items rendered in the listbox. The hook tracks navigation by index. */\n  items: T[];\n\n  /**\n   * Whether a given item should be skipped during navigation and rejected by\n   * `selectActive()`.\n   */\n  isItemDisabled?: (item: T, index: number) => boolean;\n\n  /** Initial active index. Defaults to `-1` (no active item). */\n  defaultActiveIndex?: number;\n\n  /**\n   * Wrap from last → first (and vice versa) on `next`/`prev`.\n   * @default true\n   */\n  loop?: boolean;\n\n  /**\n   * Reset the active index when the items array changes by reference.\n   * Useful for filtered listboxes where the previous index would be stale.\n   * @default true\n   */\n  resetOnItemsChange?: boolean;\n\n  /** Called when the active item is committed via `selectActive()`. */\n  onSelect?: (item: T, index: number) => void;\n\n  /** Called on `Escape`. */\n  onEscape?: () => void;\n}\n\nexport interface UseListboxNavReturn {\n  /** Currently active index, or `-1` when none. */\n  activeIndex: number;\n  /** Direct setter; the value is not validated. */\n  setActiveIndex: (index: number) => void;\n  /** Move to the next non-disabled item. */\n  next: () => void;\n  /** Move to the previous non-disabled item. */\n  prev: () => void;\n  /** Activate the first non-disabled item. */\n  first: () => void;\n  /** Activate the last non-disabled item. */\n  last: () => void;\n  /** Commit the active item via `onSelect`. */\n  selectActive: () => void;\n  /**\n   * Single keyboard handler for ArrowUp/Down/Home/End/Enter/Escape. Returns\n   * `true` when the event was handled (and `preventDefault` was called).\n   */\n  handleKeyDown: (event: KeyboardEvent | React.KeyboardEvent) => boolean;\n  /** Snapshot of the navigable indices (non-disabled, in order). */\n  navigableIndices: number[];\n}\n\n/**\n * Shared keyboard navigation for listbox-like surfaces (Select, MultiSelect,\n * Combobox, CommandPalette). Tracks an `activeIndex`, skips disabled items,\n * and exposes a single `handleKeyDown` covering Arrow / Home / End / Enter /\n * Escape semantics.\n *\n * The hook is purely logical — consumers render the list and bind the handler\n * to an input or the listbox container. Scroll-into-view is the consumer's\n * concern.\n *\n * @example\n * ```tsx\n * const { activeIndex, handleKeyDown } = useListboxNav({\n *   items: filtered,\n *   isItemDisabled: o => o.disabled ?? false,\n *   onSelect: (item) => commit(item),\n *   onEscape: () => close(),\n * });\n * ```\n */\nexport function useListboxNav<T>(\n  options: UseListboxNavOptions<T>\n): UseListboxNavReturn {\n  const {\n    items,\n    isItemDisabled,\n    defaultActiveIndex = -1,\n    loop = true,\n    resetOnItemsChange = true,\n    onSelect,\n    onEscape,\n  } = options;\n\n  const [activeIndex, setActiveIndex] = useState(defaultActiveIndex);\n\n  // Stable refs so handlers don't churn when callers pass inline closures.\n  const itemsRef = useRef(items);\n  const isItemDisabledRef = useRef(isItemDisabled);\n  const onSelectRef = useRef(onSelect);\n  const loopRef = useRef(loop);\n\n  useEffect(() => {\n    itemsRef.current = items;\n  }, [items]);\n  useEffect(() => {\n    isItemDisabledRef.current = isItemDisabled;\n  }, [isItemDisabled]);\n  useEffect(() => {\n    onSelectRef.current = onSelect;\n  }, [onSelect]);\n  useEffect(() => {\n    loopRef.current = loop;\n  }, [loop]);\n\n  // Reset active index when items reference changes (e.g. filter).\n  const prevItemsRef = useRef(items);\n  useEffect(() => {\n    if (!resetOnItemsChange) return;\n    if (prevItemsRef.current !== items) {\n      setActiveIndex(defaultActiveIndex);\n      prevItemsRef.current = items;\n    }\n  }, [items, resetOnItemsChange, defaultActiveIndex]);\n\n  const getNavigableIndices = useCallback((): number[] => {\n    const list = itemsRef.current;\n    const disabled = isItemDisabledRef.current;\n    if (!disabled) return list.map((_, i) => i);\n    const out: number[] = [];\n    for (let i = 0; i < list.length; i += 1) {\n      const item = list[i] as T;\n      if (!disabled(item, i)) out.push(i);\n    }\n    return out;\n  }, []);\n\n  // Reactive navigable-index list for the returned value. Derived from the\n  // live props rather than the latest-refs above, which exist only for reads\n  // inside the event-time keyboard handlers.\n  const navigableIndices = useMemo(() => {\n    if (!isItemDisabled) return items.map((_, i) => i);\n    const out: number[] = [];\n    for (let i = 0; i < items.length; i += 1) {\n      const item = items[i] as T;\n      if (!isItemDisabled(item, i)) out.push(i);\n    }\n    return out;\n  }, [items, isItemDisabled]);\n\n  const move = useCallback(\n    (direction: 'next' | 'prev' | 'first' | 'last') => {\n      const navigable = getNavigableIndices();\n      if (navigable.length === 0) {\n        setActiveIndex(-1);\n        return;\n      }\n\n      setActiveIndex(current => {\n        const currentNavIdx = navigable.indexOf(current);\n        switch (direction) {\n          case 'first':\n            return navigable[0] ?? -1;\n          case 'last':\n            return navigable[navigable.length - 1] ?? -1;\n          case 'next': {\n            if (currentNavIdx === -1) return navigable[0] ?? -1;\n            const nextIdx = currentNavIdx + 1;\n            if (nextIdx >= navigable.length) {\n              return loopRef.current\n                ? (navigable[0] ?? -1)\n                : (navigable[navigable.length - 1] ?? -1);\n            }\n            return navigable[nextIdx] ?? -1;\n          }\n          case 'prev': {\n            if (currentNavIdx === -1)\n              return navigable[navigable.length - 1] ?? -1;\n            const prevIdx = currentNavIdx - 1;\n            if (prevIdx < 0) {\n              return loopRef.current\n                ? (navigable[navigable.length - 1] ?? -1)\n                : (navigable[0] ?? -1);\n            }\n            return navigable[prevIdx] ?? -1;\n          }\n        }\n      });\n    },\n    [getNavigableIndices]\n  );\n\n  const next = useCallback(() => {\n    move('next');\n  }, [move]);\n  const prev = useCallback(() => {\n    move('prev');\n  }, [move]);\n  const first = useCallback(() => {\n    move('first');\n  }, [move]);\n  const last = useCallback(() => {\n    move('last');\n  }, [move]);\n\n  const selectActive = useCallback(() => {\n    const list = itemsRef.current;\n    const disabled = isItemDisabledRef.current;\n    setActiveIndex(current => {\n      if (current < 0 || current >= list.length) return current;\n      const item = list[current] as T;\n      if (disabled?.(item, current)) return current;\n      onSelectRef.current?.(item, current);\n      return current;\n    });\n  }, []);\n\n  // Escape handling via useEventCallback: stable identity (so handleKeyDown\n  // does not churn when callers pass an inline onEscape) while always seeing\n  // the latest onEscape and reporting whether it actually handled the key.\n  const handleEscape = useEventCallback(\n    (event: KeyboardEvent | React.KeyboardEvent): boolean => {\n      if (!onEscape) return false;\n      event.preventDefault();\n      onEscape();\n      return true;\n    }\n  );\n\n  const handleKeyDown = useCallback(\n    (event: KeyboardEvent | React.KeyboardEvent): boolean => {\n      switch (event.key) {\n        case 'ArrowDown':\n          event.preventDefault();\n          next();\n          return true;\n        case 'ArrowUp':\n          event.preventDefault();\n          prev();\n          return true;\n        case 'Home':\n          event.preventDefault();\n          first();\n          return true;\n        case 'End':\n          event.preventDefault();\n          last();\n          return true;\n        case 'Enter':\n          event.preventDefault();\n          selectActive();\n          return true;\n        case 'Escape':\n          return handleEscape(event);\n        default:\n          return false;\n      }\n    },\n    [next, prev, first, last, selectActive, handleEscape]\n  );\n\n  return {\n    activeIndex,\n    setActiveIndex,\n    next,\n    prev,\n    first,\n    last,\n    selectActive,\n    handleKeyDown,\n    navigableIndices,\n  };\n}\n"],"names":[],"mappings":";;;;AAiEA;;;;;;;;;;;;;;;;;;;AAmBG;AACG;;;;AAgBJ;AACA;AACA;AACA;;AAGE;AACF;;AAEE;AACF;;AAEE;AACF;;AAEE;AACF;;AAGA;;AAEE;;AACA;;AAEE;;;AAIJ;AACE;AACA;AACA;AAAe;;AAEf;AACE;AACA;AAAwB;;AAE1B;;;;;AAMF;AACE;AAAqB;;AAErB;AACE;AACA;AAA8B;;AAEhC;AACF;AAEA;AAEI;AACA;AACE;;;;;;AAOE;AACE;AACF;;;;AAG4B;AAC1B;AACA;;;AAGI;;AAEJ;;;;;AAKA;AACA;;AAEI;;;AAGJ;;;AAGN;AACF;AAIF;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AAEA;AACE;AACA;;;AAE6C;AAC3C;AACA;AAA+B;;AAE/B;AACF;;;;;AAMF;AAEI;AAAe;;AAEf;AACA;AACF;AAGF;AAEI;AACE;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;;AAEE;AACA;AACF;AACE;AACF;AACE;;AAEN;;;;;;;;;;;;AAeJ;;"}

package/dist/esm/hooks/useMediaQuery/useMediaQuery.js.map

@@ -1 +1 @@
-{"version":3,"file":"useMediaQuery.js","sources":["../../../../../src/hooks/useMediaQuery/useMediaQuery.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAMA;;AAGI;AAEA;;;AAGJ;AAEA;;;;;;;;;;;;;AAaG;;AAKD;AAEA;;;AAOI;;;;;;AAQF;AAEA;AACE;AACF;AAEA;AACE;AACA;AACE;AACF;;;;;;AAOF;AACA;;AAEE;AACF;AACF;AAEA;AACF;;"}
+{"version":3,"file":"useMediaQuery.js","sources":["src/hooks/useMediaQuery/useMediaQuery.ts"],"sourcesContent":["'use client';\n\nimport { useEffect, useState } from 'react';\n\nimport type { UseMediaQueryOptions } from './useMediaQuery.types';\n\nfunction getInitialMatch(query: string, fallback: boolean): boolean {\n  if (\n    typeof window === 'undefined' ||\n    typeof window.matchMedia !== 'function'\n  ) {\n    return fallback;\n  }\n  return window.matchMedia(query).matches;\n}\n\n/**\n * Reactive media query matching.\n *\n * Returns `true` when the current viewport matches the query and updates as\n * the viewport changes. SSR-safe — returns `defaultMatches` when `matchMedia`\n * is unavailable. Uses the modern `addEventListener('change')` API with a\n * fallback to the legacy `addListener` for older browsers.\n *\n * @example\n * ```tsx\n * const isWide = useMediaQuery('(min-width: 768px)');\n * return isWide ? <DesktopLayout /> : <MobileLayout />;\n * ```\n */\nexport function useMediaQuery(\n  query: string,\n  options: UseMediaQueryOptions = {}\n): boolean {\n  const { defaultMatches = false } = options;\n\n  const [matches, setMatches] = useState<boolean>(() =>\n    getInitialMatch(query, defaultMatches)\n  );\n\n  useEffect(() => {\n    if (\n      typeof window === 'undefined' ||\n      typeof window.matchMedia !== 'function'\n    ) {\n      return;\n    }\n\n    const mql = window.matchMedia(query);\n    // External-system sync: seed state from matchMedia on mount/query change.\n    // eslint-disable-next-line react-hooks/set-state-in-effect\n    setMatches(mql.matches);\n\n    const handler = (event: MediaQueryListEvent): void => {\n      setMatches(event.matches);\n    };\n\n    if (typeof mql.addEventListener === 'function') {\n      mql.addEventListener('change', handler);\n      return () => {\n        mql.removeEventListener('change', handler);\n      };\n    }\n\n    // Legacy Safari fallback, reached only when the modern addEventListener\n    // API above is unavailable. addListener/removeListener are deprecated but\n    // remain the only option on those older engines.\n    // eslint-disable-next-line @typescript-eslint/no-deprecated\n    mql.addListener(handler);\n    return () => {\n      // eslint-disable-next-line @typescript-eslint/no-deprecated\n      mql.removeListener(handler);\n    };\n  }, [query]);\n\n  return matches;\n}\n"],"names":[],"mappings":";;;AAMA;;AAGI;AAEA;;;AAGJ;AAEA;;;;;;;;;;;;;AAaG;;AAKD;AAEA;;;AAOI;;;;;;AAQF;AAEA;AACE;AACF;AAEA;AACE;AACA;AACE;AACF;;;;;;AAOF;AACA;;AAEE;AACF;AACF;AAEA;AACF;;"}

package/dist/esm/hooks/useMergedRef/useMergedRef.js.map

@@ -1 +1 @@
-{"version":3,"file":"useMergedRef.js","sources":["../../../../../src/hooks/useMergedRef/useMergedRef.ts"],"sourcesContent":[null],"names":[],"mappings":";;;AAMA;;;;;;;;;;;;;;;;AAgBG;AACG;;;;AAMJ;AACE;AACE;;AACA;;;;;;;AAMG;;;;;AAKT;;"}
+{"version":3,"file":"useMergedRef.js","sources":["src/hooks/useMergedRef/useMergedRef.ts"],"sourcesContent":["'use client';\n\nimport { useCallback } from 'react';\n\nimport type { Ref, RefCallback } from 'react';\n\n/**\n * Merge multiple refs into a single callback ref. Each provided ref (object\n * ref, callback ref, or `null`/`undefined`) receives the node when the merged\n * ref fires.\n *\n * Useful when a component needs to keep an internal ref to a DOM node while\n * also forwarding the same node through an externally supplied `ref` prop\n * (ref-as-prop in React 19).\n *\n * @example\n * ```tsx\n * const internalRef = useRef<HTMLDivElement>(null);\n * const mergedRef = useMergedRef(internalRef, props.ref);\n *\n * return <div ref={mergedRef} />;\n * ```\n */\nexport function useMergedRef<T>(\n  ...refs: Array<Ref<T> | undefined | null>\n): RefCallback<T> {\n  // The spread of refs is intentional — the merged callback must pick up the\n  // latest set of refs the consumer is passing in, so the dependency list is\n  // dynamic by design (use-memo / exhaustive-deps cannot model that).\n  return useCallback((node: T | null) => {\n    for (const ref of refs) {\n      if (!ref) continue;\n      if (typeof ref === 'function') {\n        ref(node);\n      } else {\n        // Assigning a node into an object ref's `.current` is the entire point\n        // of a callback ref; it is not a forbidden mutation of hook arguments.\n        // eslint-disable-next-line react-hooks/immutability\n        (ref as { current: T | null }).current = node;\n      }\n    }\n    // eslint-disable-next-line react-hooks/exhaustive-deps, react-hooks/use-memo\n  }, refs);\n}\n"],"names":[],"mappings":";;;AAMA;;;;;;;;;;;;;;;;AAgBG;AACG;;;;AAMJ;AACE;AACE;;AACA;;;;;;;AAMG;;;;;AAKT;;"}

package/dist/esm/hooks/useNavigationHistory/useNavigationHistory.js.map

@@ -1 +1 @@
-{"version":3,"file":"useNavigationHistory.js","sources":["../../../../../src/hooks/useNavigationHistory/useNavigationHistory.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AASA;;;;AAIG;AACH;AAKE;;;;;AAUA;AACE;AACA;AACE;AACF;AACF;AAEA;;AAEA;AAlBE;AACE;AACA;;;AAEA;AACA;;;AAqBJ;;;AAEE;AACA;AACA;;AAEA;;;AAIA;AAAsB;;AAEtB;;;;;AAK2C;;AAE3C;;;AAIF;AACE;AACE;;;;;AAOA;AACA;;;AAEA;;AACA;AACA;;AAEF;;AAEH;;AA9CG;AACE;AACF;AACF;AA6CF;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG;;;;AAOJ;AAEA;AACA;AAIA;AAKA;AACA;AAEA;AAEI;;AACA;AACF;AAIF;AACE;AAAc;AACd;AACF;AAEA;AACE;AAAc;AACd;AACF;AAEA;AAEI;AACF;AAIF;;;;;;;;AASG;AAGL;;"}
+{"version":3,"file":"useNavigationHistory.js","sources":["src/hooks/useNavigationHistory/useNavigationHistory.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useMemo, useState, useSyncExternalStore } from 'react';\n\nimport type {\n  NavigationHistoryApi,\n  UseNavigationHistoryOptions,\n} from './useNavigationHistory.types';\n\n/**\n * Per-instance back/forward stack. Lives outside React so reads are stable\n * across concurrent renders and so non-React handlers can mutate without\n * scheduling extra renders for unrelated consumers.\n */\nclass NavigationHistoryStore<T> {\n  #stack: T[];\n  #index: number;\n  #listeners = new Set<() => void>();\n\n  constructor(initial: T | undefined) {\n    if (initial !== undefined) {\n      this.#stack = [initial];\n      this.#index = 0;\n    } else {\n      this.#stack = [];\n      this.#index = -1;\n    }\n  }\n\n  subscribe = (listener: () => void): (() => void) => {\n    this.#listeners.add(listener);\n    return () => {\n      this.#listeners.delete(listener);\n    };\n  };\n\n  getCurrent = (): T | undefined => this.#stack[this.#index];\n  getCanGoBack = (): boolean => this.#index > 0;\n  getCanGoForward = (): boolean => this.#index < this.#stack.length - 1;\n\n  #notify(): void {\n    this.#listeners.forEach(l => {\n      l();\n    });\n  }\n\n  push(entry: T): void {\n    if (this.#stack[this.#index] === entry) return;\n    const next = this.#stack.slice(0, this.#index + 1);\n    next.push(entry);\n    this.#stack = next;\n    this.#index = next.length - 1;\n    this.#notify();\n  }\n\n  goBack(): T | undefined {\n    if (this.#index <= 0) return undefined;\n    this.#index -= 1;\n    this.#notify();\n    return this.#stack[this.#index];\n  }\n\n  goForward(): T | undefined {\n    if (this.#index >= this.#stack.length - 1) return undefined;\n    this.#index += 1;\n    this.#notify();\n    return this.#stack[this.#index];\n  }\n\n  reset(entry: T | undefined): void {\n    if (entry !== undefined) {\n      if (\n        this.#stack.length === 1 &&\n        this.#index === 0 &&\n        this.#stack[0] === entry\n      ) {\n        return;\n      }\n      this.#stack = [entry];\n      this.#index = 0;\n    } else {\n      if (this.#stack.length === 0) return;\n      this.#stack = [];\n      this.#index = -1;\n    }\n    this.#notify();\n  }\n}\n\n/**\n * Back/forward history primitive. Tracks a stack of entries (`T`) with a\n * cursor, mirrors browser semantics (pushing truncates the forward branch),\n * and exposes the current entry plus `canGoBack` / `canGoForward` flags via\n * `useSyncExternalStore`.\n *\n * Useful any time a UI needs Back/Forward controls over a finite navigation\n * — folder browsers, wizard steps, drill-down inspectors. Generic over the\n * entry type, so it works with ids, paths, route objects, anything stable.\n *\n * @example\n * ```tsx\n * const nav = useNavigationHistory<string>({ initial: 'root' });\n *\n * <Toolbar>\n *   <IconButton aria-label=\"Back\" disabled={!nav.canGoBack} onClick={nav.goBack}>\n *     <ChevronLeftIcon />\n *   </IconButton>\n *   <IconButton aria-label=\"Forward\" disabled={!nav.canGoForward} onClick={nav.goForward}>\n *     <ChevronRightIcon />\n *   </IconButton>\n * </Toolbar>\n * ```\n */\nexport function useNavigationHistory<T = string>(\n  options: UseNavigationHistoryOptions<T> = {}\n): NavigationHistoryApi<T> {\n  const { initial, enabled = true } = options;\n\n  // Lazy init via useState — the initial value is captured once on mount.\n  // Subsequent changes to `initial` are ignored (use `reset()` to re-seed).\n  const [store] = useState(() => new NavigationHistoryStore<T>(initial));\n\n  const current = useSyncExternalStore(store.subscribe, store.getCurrent);\n  const canGoBackRaw = useSyncExternalStore(\n    store.subscribe,\n    store.getCanGoBack\n  );\n  const canGoForwardRaw = useSyncExternalStore(\n    store.subscribe,\n    store.getCanGoForward\n  );\n\n  const canGoBack = enabled && canGoBackRaw;\n  const canGoForward = enabled && canGoForwardRaw;\n\n  const push = useCallback(\n    (entry: T): void => {\n      if (!enabled) return;\n      store.push(entry);\n    },\n    [store, enabled]\n  );\n\n  const goBack = useCallback((): T | undefined => {\n    if (!enabled) return undefined;\n    return store.goBack();\n  }, [store, enabled]);\n\n  const goForward = useCallback((): T | undefined => {\n    if (!enabled) return undefined;\n    return store.goForward();\n  }, [store, enabled]);\n\n  const reset = useCallback(\n    (entry?: T): void => {\n      store.reset(entry);\n    },\n    [store]\n  );\n\n  return useMemo(\n    () => ({\n      current,\n      canGoBack,\n      canGoForward,\n      push,\n      goBack,\n      goForward,\n      reset,\n    }),\n    [current, canGoBack, canGoForward, push, goBack, goForward, reset]\n  );\n}\n"],"names":[],"mappings":";;;;;AASA;;;;AAIG;AACH;AAKE;;;;;AAUA;AACE;AACA;AACE;AACF;AACF;AAEA;;AAEA;AAlBE;AACE;AACA;;;AAEA;AACA;;;AAqBJ;;;AAEE;AACA;AACA;;AAEA;;;AAIA;AAAsB;;AAEtB;;;;;AAK2C;;AAE3C;;;AAIF;AACE;AACE;;;;;AAOA;AACA;;;AAEA;;AACA;AACA;;AAEF;;AAEH;;AA9CG;AACE;AACF;AACF;AA6CF;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACG;;;;AAOJ;AAEA;AACA;AAIA;AAKA;AACA;AAEA;AAEI;;AACA;AACF;AAIF;AACE;AAAc;AACd;AACF;AAEA;AACE;AAAc;AACd;AACF;AAEA;AAEI;AACF;AAIF;;;;;;;;AASG;AAGL;;"}

package/dist/esm/hooks/useResizeObserver/useResizeObserver.js.map

@@ -1 +1 @@
-{"version":3,"file":"useResizeObserver.js","sources":["../../../../../src/hooks/useResizeObserver/useResizeObserver.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAiBA;;;;;;;;;;;;;;;;;;;;AAoBG;;;AAQD;AACA;AACA;;;;;;;;;AAUI;AACE;AACA;AACA;;;;AAKJ;AACA;;AAEA;AACE;AACA;;AAEF;AACA;;AAEA;AACE;;;AAGF;AACA;AACA;AACF;;AAGA;AAEI;AACA;AACA;;AAIN;;"}
+{"version":3,"file":"useResizeObserver.js","sources":["src/hooks/useResizeObserver/useResizeObserver.ts"],"sourcesContent":["'use client';\n\nimport { useEffect, useRef } from 'react';\n\nimport { useEventCallback } from '@/hooks/useEventCallback';\n\nimport type { RefObject } from 'react';\n\nexport interface UseResizeObserverOptions {\n  /**\n   * When false, the observer is not attached. Toggling this from `false` to\n   * `true` (re-)attaches the observer; toggling back disconnects it.\n   * @default true\n   */\n  enabled?: boolean;\n}\n\n/**\n * Observe size changes on an element. SSR-safe; cleans up on unmount.\n *\n * The callback is wrapped with `useEventCallback` so consumers do not have\n * to memoize it — the underlying observer never re-subscribes when the\n * callback identity changes.\n *\n * The hook re-checks `ref.current` on every render so it picks up nodes that\n * mount later (e.g. through conditional rendering). When the observed node\n * has not changed the only cost is a single identity comparison.\n *\n * @example\n * ```tsx\n * const ref = useRef<HTMLDivElement>(null);\n * useResizeObserver(ref, entry => {\n *   console.log(entry.contentRect.width);\n * });\n *\n * return <div ref={ref} />;\n * ```\n */\nexport function useResizeObserver<T extends HTMLElement>(\n  ref: RefObject<T | null>,\n  callback: (entry: ResizeObserverEntry) => void,\n  options?: UseResizeObserverOptions\n): void {\n  const { enabled = true } = options ?? {};\n\n  const handleEntry = useEventCallback(callback);\n  const observerRef = useRef<ResizeObserver | null>(null);\n  const observedNodeRef = useRef<T | null>(null);\n\n  // Runs on every render so a node that mounts after the first render\n  // (conditional rendering, lazy children, suspense fallback flips, ...) is\n  // picked up automatically. Short-circuits on the common case where the\n  // observed node has not changed.\n  useEffect(() => {\n    if (typeof ResizeObserver === 'undefined') return;\n\n    if (!enabled) {\n      if (observerRef.current) {\n        observerRef.current.disconnect();\n        observerRef.current = null;\n        observedNodeRef.current = null;\n      }\n      return;\n    }\n\n    const node = ref.current;\n    if (node === observedNodeRef.current) return;\n\n    if (observerRef.current) {\n      observerRef.current.disconnect();\n      observerRef.current = null;\n    }\n    observedNodeRef.current = node;\n    if (!node) return;\n\n    const observer = new ResizeObserver(entries => {\n      for (const entry of entries) {\n        handleEntry(entry);\n      }\n    });\n    observer.observe(node);\n    observerRef.current = observer;\n  });\n\n  // Final cleanup on unmount.\n  useEffect(\n    () => () => {\n      observerRef.current?.disconnect();\n      observerRef.current = null;\n      observedNodeRef.current = null;\n    },\n    []\n  );\n}\n"],"names":[],"mappings":";;;;AAiBA;;;;;;;;;;;;;;;;;;;;AAoBG;;;AAQD;AACA;AACA;;;;;;;;;AAUI;AACE;AACA;AACA;;;;AAKJ;AACA;;AAEA;AACE;AACA;;AAEF;AACA;;AAEA;AACE;;;AAGF;AACA;AACA;AACF;;AAGA;AAEI;AACA;AACA;;AAIN;;"}

package/dist/esm/hooks/useTheme/useTheme.js

@@ -3,7 +3,7 @@ import { useRef, useState, useLayoutEffect, useCallback, useMemo } from 'react';
 import { vars } from '../../theme/contract.css.js';
 import { darkThemeValues } from '../../theme/darkThemeValues.js';
 import { lightThemeClass } from '../../theme/lightTheme.css.js';
-import '../../node_modules/@vanilla-extract/css/dist/vanilla-extract-css.esm.js';
+import '@vanilla-extract/css';
 import './../../assets/src/theme/darkTheme.css.ts.vanilla-BHZ3ecRn.css';
 import 'react/jsx-runtime';
 import '../../utils/devWarn.js';

package/dist/esm/hooks/useTheme/useTheme.js.map

@@ -1 +1 @@
-{"version":3,"file":"useTheme.js","sources":["../../../../../src/hooks/useTheme/useTheme.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;;;;;;AAYA;AAEA;;;;;;;;;;AAUG;AACH;;;AAGE;;;;AAMI;;;AAEA;;;;AAG0B;;AAE9B;AACF;AAEA;AACE;;AAEF;AAEA;;;;;AAKG;AACH;AACE;AACE;;AAEE;;AAEE;AACA;;;AAGJ;;;;;AAKE;AACA;AAGA;;AAEF;;AAEF;AACF;AAEA;;;AAGE;;;;AAMI;;;AAEA;;;AAGJ;AACF;AAEA;;;;;;;AAOG;AACH;;AACuC;;AAGnC;;AAEF;AACF;AAOA;AACE;AACA;;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CG;;;;;;;AAOC;AACA;;;;AAIA;;;;;;AAOF;AACE;;;AAE0B;AAE1B;;AAEE;AACA;;AAGF;;AAEE;AACA;;AAGF;;AAEG;;AAEH;AACA;;AAGF;AAEA;;;;;;AASF;;"}
+{"version":3,"file":"useTheme.js","sources":["src/hooks/useTheme/useTheme.ts"],"sourcesContent":["'use client';\n\nimport { useCallback, useLayoutEffect, useMemo, useRef, useState } from 'react';\n\nimport { darkThemeValues, lightThemeClass, vars } from '@/theme';\n\nimport type {\n  ResolvedThemeValues,\n  ThemeVariant,\n  UseThemeReturn,\n} from './useTheme.types';\n\nconst VAR_REF_PATTERN = /^var\\((--[^,)]+)/;\n\n/**\n * Walk a dot-path on the theme contract and return the underlying CSS\n * custom property name (without the leading `var(`/trailing `)`).\n *\n * The contract emits hand-tuned, non-derivable names — `colors.accent.primary`\n * resolves to `--etui-color-accent-primary`, not `--etui-colors-accent-primary`.\n * Walking the existing `vars` object (whose leaves are already\n * `var(--etui-...)` references) is the only correct way to get the var name.\n *\n * Returns `''` for paths that don't resolve to a leaf reference.\n */\nfunction pathToCssVar(path: string): string {\n  const segments = path.split('.');\n  let node: unknown = vars;\n  for (const segment of segments) {\n    if (\n      node !== null &&\n      typeof node === 'object' &&\n      segment in (node as Record<string, unknown>)\n    ) {\n      node = (node as Record<string, unknown>)[segment];\n    } else {\n      return '';\n    }\n  }\n  if (typeof node !== 'string') return '';\n  const match = VAR_REF_PATTERN.exec(node);\n  return match?.[1] ?? '';\n}\n\nfunction pathToVarRef(path: string): string {\n  const cssVar = pathToCssVar(path);\n  return cssVar ? `var(${cssVar})` : '';\n}\n\n/**\n * Walk the dark-theme template alongside the contract, replacing each\n * leaf with the resolved CSS variable value read from `root`. Falls back\n * to the template value when a property is empty (e.g. before stylesheets\n * have applied during testing).\n */\nfunction resolveValues<T>(template: T, root: Element, contract: unknown): T {\n  if (typeof template === 'string') {\n    if (typeof contract === 'string') {\n      const match = VAR_REF_PATTERN.exec(contract);\n      const cssVar = match?.[1];\n      if (cssVar) {\n        const value = getComputedStyle(root).getPropertyValue(cssVar).trim();\n        return (value || template) as T;\n      }\n    }\n    return template;\n  }\n  if (template !== null && typeof template === 'object') {\n    const out: Record<string, unknown> = {};\n    for (const key of Object.keys(template)) {\n      const childTemplate = (template as Record<string, unknown>)[key];\n      const childContract = (contract as Record<string, unknown> | undefined)?.[\n        key\n      ];\n      out[key] = resolveValues(childTemplate, root, childContract);\n    }\n    return out as T;\n  }\n  return template;\n}\n\nfunction readTemplateValue(template: unknown, path: string): string {\n  const segments = path.split('.');\n  let node: unknown = template;\n  for (const segment of segments) {\n    if (\n      node !== null &&\n      typeof node === 'object' &&\n      segment in (node as Record<string, unknown>)\n    ) {\n      node = (node as Record<string, unknown>)[segment];\n    } else {\n      return '';\n    }\n  }\n  return typeof node === 'string' ? node : '';\n}\n\n/**\n * Root-only detection: the variant is determined by whether the\n * light-theme class is applied to `document.documentElement` — the same\n * element from which `values` are resolved. Anything more permissive\n * (descendant scan, `<body>` check) would let the variant disagree with\n * the resolved values for a dark app that contains a single light\n * subtree.\n */\nfunction detectVariant(): ThemeVariant {\n  if (typeof document === 'undefined') return 'dark';\n  if (!lightThemeClass) return 'dark';\n  if (document.documentElement.classList.contains(lightThemeClass)) {\n    return 'light';\n  }\n  return 'dark';\n}\n\ninterface ThemeSnapshot {\n  variant: ThemeVariant;\n  values: ResolvedThemeValues;\n}\n\nconst FALLBACK_SNAPSHOT: ThemeSnapshot = {\n  variant: 'dark',\n  values: darkThemeValues,\n};\n\n/**\n * Read the current theme at runtime.\n *\n * Returns the resolved CSS variable snapshot from `:root`, the detected\n * theme variant, and helpers for reading individual tokens by path.\n * Components should prefer compile-time tokens via Vanilla Extract\n * (`vars.*` from `@/theme`) — reach for `useTheme` only when a runtime\n * read is genuinely required (canvas drawing, third-party libraries that\n * take colors as plain strings).\n *\n * **Scope:** the hook always reads from `:root` — both the variant and\n * the resolved values come from `document.documentElement`. A light- or\n * custom-themed subtree wrapped in `VanillaThemeProvider` will **not** be\n * reflected here; for that, components inside the subtree should style\n * via Vanilla Extract `vars.*` (which the browser resolves correctly per\n * scope) rather than runtime reads.\n *\n * **SSR:** returns the dark-theme defaults as a fallback. The hook\n * re-evaluates against the live DOM on mount via `useLayoutEffect`, so\n * the second render contains the real values before the browser paints.\n *\n * **Reactivity:** v0.8 reads once on mount. Toggling the root theme at\n * runtime is not reflected — remount the consuming subtree to pick up\n * the new theme. A `MutationObserver`-based subscription may be added\n * in a later release if consumer demand emerges.\n *\n * @example\n * ```tsx\n * const { values, variant, getVar, getToken } = useTheme();\n *\n * // Canvas drawing with theme-aware colors\n * ctx.strokeStyle = values.colors.accent.primary;\n *\n * // Conditional logic\n * if (variant === 'dark') loadDarkAssets();\n *\n * // Inline styles that follow theme changes automatically\n * <div style={{ color: getVar('colors.text.primary') }} />\n *\n * // One-off token resolution\n * const accent = getToken('colors.accent.primary');\n * ```\n */\nexport function useTheme(): UseThemeReturn {\n  const tokenCacheRef = useRef<Map<string, string>>(new Map());\n  const [snapshot, setSnapshot] = useState<ThemeSnapshot>(FALLBACK_SNAPSHOT);\n\n  useLayoutEffect(() => {\n    if (typeof document === 'undefined') return;\n    const root = document.documentElement;\n    const next: ThemeSnapshot = {\n      variant: detectVariant(),\n      values: resolveValues(darkThemeValues, root, vars),\n    };\n    tokenCacheRef.current.clear();\n    // External-system sync: read resolved CSS custom properties from the DOM\n    // into state once mounted (they are unavailable during SSR/first render).\n    // eslint-disable-next-line react-hooks/set-state-in-effect\n    setSnapshot(next);\n  }, []);\n\n  const getToken = useCallback((path: string): string => {\n    const cache = tokenCacheRef.current;\n    const cached = cache.get(path);\n    if (cached !== undefined) return cached;\n\n    if (typeof document === 'undefined') {\n      const fallback = readTemplateValue(darkThemeValues, path);\n      cache.set(path, fallback);\n      return fallback;\n    }\n\n    const cssVar = pathToCssVar(path);\n    if (!cssVar) {\n      cache.set(path, '');\n      return '';\n    }\n\n    const value = getComputedStyle(document.documentElement)\n      .getPropertyValue(cssVar)\n      .trim();\n    const resolved = value || readTemplateValue(darkThemeValues, path);\n    cache.set(path, resolved);\n    return resolved;\n  }, []);\n\n  const getVar = useCallback((path: string): string => pathToVarRef(path), []);\n\n  return useMemo(\n    () => ({\n      variant: snapshot.variant,\n      values: snapshot.values,\n      getToken,\n      getVar,\n    }),\n    [snapshot, getToken, getVar]\n  );\n}\n"],"names":[],"mappings":";;;;;;;;;;;AAYA;AAEA;;;;;;;;;;AAUG;AACH;;;AAGE;;;;AAMI;;;AAEA;;;;AAG0B;;AAE9B;AACF;AAEA;AACE;;AAEF;AAEA;;;;;AAKG;AACH;AACE;AACE;;AAEE;;AAEE;AACA;;;AAGJ;;;;;AAKE;AACA;AAGA;;AAEF;;AAEF;AACF;AAEA;;;AAGE;;;;AAMI;;;AAEA;;;AAGJ;AACF;AAEA;;;;;;;AAOG;AACH;;AACuC;;AAGnC;;AAEF;AACF;AAOA;AACE;AACA;;AAGF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CG;;;;;;;AAOC;AACA;;;;AAIA;;;;;;AAOF;AACE;;;AAE0B;AAE1B;;AAEE;AACA;;AAGF;;AAEE;AACA;;AAGF;;AAEG;;AAEH;AACA;;AAGF;AAEA;;;;;;AASF;;"}

package/dist/esm/hooks/useThrottledCallback/useThrottledCallback.js.map

@@ -1 +1 @@
-{"version":3,"file":"useThrottledCallback.js","sources":["../../../../../src/hooks/useThrottledCallback/useThrottledCallback.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAWA;;;;;;;;;;;;;;;;;AAiBG;AACG;;;;AASJ;AAEA;AACA;AACA;AAEA;AACE;AACE;AACA;AACA;AACA;AAAU;AACZ;AAEA;;;;AAIE;;;AAGE;;AAGF;AACA;AAEA;AACE;AACE;AACA;;;;;;AAOF;AACE;AACA;AACF;;AAEJ;AAEA;AACE;AACE;AACA;;AAEF;AACA;AACF;AAEA;;AAGF;AAEI;AAA+B;;AAKnC;AACF;;"}
+{"version":3,"file":"useThrottledCallback.js","sources":["src/hooks/useThrottledCallback/useThrottledCallback.ts"],"sourcesContent":["'use client';\n\nimport { useEffect, useMemo, useRef } from 'react';\n\nimport { useEventCallback } from '@/hooks/useEventCallback';\n\nimport type {\n  ThrottledCallback,\n  UseThrottledCallbackOptions,\n} from './useThrottledCallback.types';\n\n/**\n * Wrap a function so it fires at most once per `delay` ms. With both\n * `leading` and `trailing` enabled (the default), the first call fires\n * immediately and the most recent call inside the window fires at its\n * end. Set `leading: false` to defer the first call; set\n * `trailing: false` to drop calls inside the window.\n *\n * Typical use: drag handlers, scroll listeners, resize observers — places\n * where the input rate exceeds the work rate and you want to bound the\n * latter.\n *\n * The wrapper identity is stable across renders.\n *\n * @example\n * ```tsx\n * const onPointerMove = useThrottledCallback(updateGuide, 16);\n * ```\n */\nexport function useThrottledCallback<Args extends unknown[]>(\n  fn: (...args: Args) => void,\n  delay: number,\n  options: UseThrottledCallbackOptions = {}\n): ThrottledCallback<Args> {\n  const { leading = true, trailing = true } = options;\n\n  // Stable wrapper that always invokes the current callback, refreshed via\n  // useInsertionEffect so the throttled wrapper never goes stale.\n  const stableFn = useEventCallback(fn);\n\n  const lastCallRef = useRef<number>(0);\n  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const lastArgsRef = useRef<Args | null>(null);\n\n  const throttled = useMemo<ThrottledCallback<Args>>(() => {\n    const invoke = (now: number): void => {\n      lastCallRef.current = now;\n      const args = lastArgsRef.current;\n      lastArgsRef.current = null;\n      if (args) stableFn(...args);\n    };\n\n    const wrapper = (...args: Args): void => {\n      // Date.now() runs only when the wrapper is invoked from an event/timer,\n      // never during render, so it is not a render-purity concern here.\n      // eslint-disable-next-line react-hooks/purity\n      const now = Date.now();\n      if (lastCallRef.current === 0 && !leading) {\n        // Skip the leading fire by anchoring the window to \"now\".\n        lastCallRef.current = now;\n      }\n\n      const elapsed = now - lastCallRef.current;\n      lastArgsRef.current = args;\n\n      if (elapsed >= delay) {\n        if (timerRef.current !== null) {\n          clearTimeout(timerRef.current);\n          timerRef.current = null;\n        }\n        invoke(now);\n        return;\n      }\n\n      if (trailing && timerRef.current === null) {\n        timerRef.current = setTimeout(() => {\n          timerRef.current = null;\n          invoke(Date.now());\n        }, delay - elapsed);\n      }\n    };\n\n    wrapper.cancel = () => {\n      if (timerRef.current !== null) {\n        clearTimeout(timerRef.current);\n        timerRef.current = null;\n      }\n      lastArgsRef.current = null;\n      lastCallRef.current = 0;\n    };\n\n    return wrapper;\n  }, [delay, leading, trailing, stableFn]);\n\n  useEffect(\n    () => () => {\n      if (timerRef.current !== null) clearTimeout(timerRef.current);\n    },\n    []\n  );\n\n  return throttled;\n}\n"],"names":[],"mappings":";;;;AAWA;;;;;;;;;;;;;;;;;AAiBG;AACG;;;;AASJ;AAEA;AACA;AACA;AAEA;AACE;AACE;AACA;AACA;AACA;AAAU;AACZ;AAEA;;;;AAIE;;;AAGE;;AAGF;AACA;AAEA;AACE;AACE;AACA;;;;;;AAOF;AACE;AACA;AACF;;AAEJ;AAEA;AACE;AACE;AACA;;AAEF;AACA;AACF;AAEA;;AAGF;AAEI;AAA+B;;AAKnC;AACF;;"}

package/dist/esm/index.js

@@ -267,6 +267,12 @@ export { GitBranchIcon } from './components/Icons/GitBranchIcon.js';
 export { BugIcon } from './components/Icons/BugIcon.js';
 export { MinusIcon } from './components/Icons/MinusIcon.js';
 export { PinIcon } from './components/Icons/PinIcon.js';
+export { OrbitIcon } from './components/Icons/OrbitIcon.js';
+export { RotateIcon } from './components/Icons/RotateIcon.js';
+export { SpinIcon } from './components/Icons/SpinIcon.js';
+export { CameraIcon } from './components/Icons/CameraIcon.js';
+export { CubeIcon } from './components/Icons/CubeIcon.js';
+export { ZoomFitIcon } from './components/Icons/ZoomFitIcon.js';
 export { useKeyboard } from './hooks/useKeyboard/useKeyboard.js';
 export { useControlledState } from './hooks/useControlledState/useControlledState.js';
 export { useFocusTrap } from './hooks/useFocusTrap/useFocusTrap.js';

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/node_modules/tslib/tslib.es6.js.map

@@ -1 +1 @@
-{"version":3,"file":"tslib.es6.js","sources":["../../../../node_modules/tslib/tslib.es6.js"],"sourcesContent":["/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.unshift(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.unshift(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\r\n    return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\r\n    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nvar ownKeys = function(o) {\r\n    ownKeys = Object.getOwnPropertyNames || function (o) {\r\n        var ar = [];\r\n        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\r\n        return ar;\r\n    };\r\n    return ownKeys(o);\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport function __addDisposableResource(env, value, async) {\r\n    if (value !== null && value !== void 0) {\r\n        if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\r\n        var dispose, inner;\r\n        if (async) {\r\n            if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\r\n            dispose = value[Symbol.asyncDispose];\r\n        }\r\n        if (dispose === void 0) {\r\n            if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\r\n            dispose = value[Symbol.dispose];\r\n            if (async) inner = dispose;\r\n        }\r\n        if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\r\n        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\r\n        env.stack.push({ value: value, dispose: dispose, async: async });\r\n    }\r\n    else if (async) {\r\n        env.stack.push({ async: true });\r\n    }\r\n    return value;\r\n\r\n}\r\n\r\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\r\n\r\nexport function __disposeResources(env) {\r\n    function fail(e) {\r\n        env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\r\n        env.hasError = true;\r\n    }\r\n    var r, s = 0;\r\n    function next() {\r\n        while (r = env.stack.pop()) {\r\n            try {\r\n                if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\r\n                if (r.dispose) {\r\n                    var result = r.dispose.call(r.value);\r\n                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\r\n                }\r\n                else s |= 1;\r\n            }\r\n            catch (e) {\r\n                fail(e);\r\n            }\r\n        }\r\n        if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\r\n        if (env.hasError) throw env.error;\r\n    }\r\n    return next();\r\n}\r\n\r\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\r\n    if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\r\n        return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\r\n            return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\r\n        });\r\n    }\r\n    return path;\r\n}\r\n\r\nexport default {\r\n    __extends: __extends,\r\n    __assign: __assign,\r\n    __rest: __rest,\r\n    __decorate: __decorate,\r\n    __param: __param,\r\n    __esDecorate: __esDecorate,\r\n    __runInitializers: __runInitializers,\r\n    __propKey: __propKey,\r\n    __setFunctionName: __setFunctionName,\r\n    __metadata: __metadata,\r\n    __awaiter: __awaiter,\r\n    __generator: __generator,\r\n    __createBinding: __createBinding,\r\n    __exportStar: __exportStar,\r\n    __values: __values,\r\n    __read: __read,\r\n    __spread: __spread,\r\n    __spreadArrays: __spreadArrays,\r\n    __spreadArray: __spreadArray,\r\n    __await: __await,\r\n    __asyncGenerator: __asyncGenerator,\r\n    __asyncDelegator: __asyncDelegator,\r\n    __asyncValues: __asyncValues,\r\n    __makeTemplateObject: __makeTemplateObject,\r\n    __importStar: __importStar,\r\n    __importDefault: __importDefault,\r\n    __classPrivateFieldGet: __classPrivateFieldGet,\r\n    __classPrivateFieldSet: __classPrivateFieldSet,\r\n    __classPrivateFieldIn: __classPrivateFieldIn,\r\n    __addDisposableResource: __addDisposableResource,\r\n    __disposeResources: __disposeResources,\r\n    __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,\r\n};\r\n"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AA8QA;AACO,SAAS,sBAAsB,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE;AACjE,IAAI,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,CAAC,EAAE,MAAM,IAAI,SAAS,CAAC,+CAA+C,CAAC,CAAC;AACjG,IAAI,IAAI,OAAO,KAAK,KAAK,UAAU,GAAG,QAAQ,KAAK,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,SAAS,CAAC,0EAA0E,CAAC,CAAC;AACvL,IAAI,OAAO,IAAI,KAAK,GAAG,GAAG,CAAC,GAAG,IAAI,KAAK,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAClG,CAAC;AACD;AACO,SAAS,sBAAsB,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE;AACxE,IAAI,IAAI,IAAI,KAAK,GAAG,EAAE,MAAM,IAAI,SAAS,CAAC,gCAAgC,CAAC,CAAC;AAC5E,IAAI,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,CAAC,EAAE,MAAM,IAAI,SAAS,CAAC,+CAA+C,CAAC,CAAC;AACjG,IAAI,IAAI,OAAO,KAAK,KAAK,UAAU,GAAG,QAAQ,KAAK,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,SAAS,CAAC,yEAAyE,CAAC,CAAC;AACtL,IAAI,OAAO,CAAC,IAAI,KAAK,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,KAAK,CAAC;AAC9G,CAAC;AA8BD;AACuB,OAAO,eAAe,KAAK,UAAU,GAAG,eAAe,GAAG,UAAU,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE;AACvH,IAAI,IAAI,CAAC,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;AAC/B,IAAI,OAAO,CAAC,CAAC,IAAI,GAAG,iBAAiB,EAAE,CAAC,CAAC,KAAK,GAAG,KAAK,EAAE,CAAC,CAAC,UAAU,GAAG,UAAU,EAAE,CAAC,CAAC;AACrF;;;;","x_google_ignoreList":[0]}
+{"version":3,"file":"tslib.es6.js","sources":["node_modules/tslib/tslib.es6.js"],"sourcesContent":["/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise, SuppressedError, Symbol, Iterator */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n    function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n    var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n    var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n    var _, done = false;\r\n    for (var i = decorators.length - 1; i >= 0; i--) {\r\n        var context = {};\r\n        for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n        for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n        context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n        var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n        if (kind === \"accessor\") {\r\n            if (result === void 0) continue;\r\n            if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n            if (_ = accept(result.get)) descriptor.get = _;\r\n            if (_ = accept(result.set)) descriptor.set = _;\r\n            if (_ = accept(result.init)) initializers.unshift(_);\r\n        }\r\n        else if (_ = accept(result)) {\r\n            if (kind === \"field\") initializers.unshift(_);\r\n            else descriptor[key] = _;\r\n        }\r\n    }\r\n    if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n    done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n    var useValue = arguments.length > 2;\r\n    for (var i = 0; i < initializers.length; i++) {\r\n        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n    }\r\n    return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n    return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n    if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n    return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\r\n    return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = Object.create((typeof AsyncIterator === \"function\" ? AsyncIterator : Object).prototype), verb(\"next\"), verb(\"throw\"), verb(\"return\", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }\r\n    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nvar ownKeys = function(o) {\r\n    ownKeys = Object.getOwnPropertyNames || function (o) {\r\n        var ar = [];\r\n        for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;\r\n        return ar;\r\n    };\r\n    return ownKeys(o);\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== \"default\") __createBinding(result, mod, k[i]);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport function __addDisposableResource(env, value, async) {\r\n    if (value !== null && value !== void 0) {\r\n        if (typeof value !== \"object\" && typeof value !== \"function\") throw new TypeError(\"Object expected.\");\r\n        var dispose, inner;\r\n        if (async) {\r\n            if (!Symbol.asyncDispose) throw new TypeError(\"Symbol.asyncDispose is not defined.\");\r\n            dispose = value[Symbol.asyncDispose];\r\n        }\r\n        if (dispose === void 0) {\r\n            if (!Symbol.dispose) throw new TypeError(\"Symbol.dispose is not defined.\");\r\n            dispose = value[Symbol.dispose];\r\n            if (async) inner = dispose;\r\n        }\r\n        if (typeof dispose !== \"function\") throw new TypeError(\"Object not disposable.\");\r\n        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };\r\n        env.stack.push({ value: value, dispose: dispose, async: async });\r\n    }\r\n    else if (async) {\r\n        env.stack.push({ async: true });\r\n    }\r\n    return value;\r\n\r\n}\r\n\r\nvar _SuppressedError = typeof SuppressedError === \"function\" ? SuppressedError : function (error, suppressed, message) {\r\n    var e = new Error(message);\r\n    return e.name = \"SuppressedError\", e.error = error, e.suppressed = suppressed, e;\r\n};\r\n\r\nexport function __disposeResources(env) {\r\n    function fail(e) {\r\n        env.error = env.hasError ? new _SuppressedError(e, env.error, \"An error was suppressed during disposal.\") : e;\r\n        env.hasError = true;\r\n    }\r\n    var r, s = 0;\r\n    function next() {\r\n        while (r = env.stack.pop()) {\r\n            try {\r\n                if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);\r\n                if (r.dispose) {\r\n                    var result = r.dispose.call(r.value);\r\n                    if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });\r\n                }\r\n                else s |= 1;\r\n            }\r\n            catch (e) {\r\n                fail(e);\r\n            }\r\n        }\r\n        if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();\r\n        if (env.hasError) throw env.error;\r\n    }\r\n    return next();\r\n}\r\n\r\nexport function __rewriteRelativeImportExtension(path, preserveJsx) {\r\n    if (typeof path === \"string\" && /^\\.\\.?\\//.test(path)) {\r\n        return path.replace(/\\.(tsx)$|((?:\\.d)?)((?:\\.[^./]+?)?)\\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {\r\n            return tsx ? preserveJsx ? \".jsx\" : \".js\" : d && (!ext || !cm) ? m : (d + ext + \".\" + cm.toLowerCase() + \"js\");\r\n        });\r\n    }\r\n    return path;\r\n}\r\n\r\nexport default {\r\n    __extends: __extends,\r\n    __assign: __assign,\r\n    __rest: __rest,\r\n    __decorate: __decorate,\r\n    __param: __param,\r\n    __esDecorate: __esDecorate,\r\n    __runInitializers: __runInitializers,\r\n    __propKey: __propKey,\r\n    __setFunctionName: __setFunctionName,\r\n    __metadata: __metadata,\r\n    __awaiter: __awaiter,\r\n    __generator: __generator,\r\n    __createBinding: __createBinding,\r\n    __exportStar: __exportStar,\r\n    __values: __values,\r\n    __read: __read,\r\n    __spread: __spread,\r\n    __spreadArrays: __spreadArrays,\r\n    __spreadArray: __spreadArray,\r\n    __await: __await,\r\n    __asyncGenerator: __asyncGenerator,\r\n    __asyncDelegator: __asyncDelegator,\r\n    __asyncValues: __asyncValues,\r\n    __makeTemplateObject: __makeTemplateObject,\r\n    __importStar: __importStar,\r\n    __importDefault: __importDefault,\r\n    __classPrivateFieldGet: __classPrivateFieldGet,\r\n    __classPrivateFieldSet: __classPrivateFieldSet,\r\n    __classPrivateFieldIn: __classPrivateFieldIn,\r\n    __addDisposableResource: __addDisposableResource,\r\n    __disposeResources: __disposeResources,\r\n    __rewriteRelativeImportExtension: __rewriteRelativeImportExtension,\r\n};\r\n"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AA8QA;AACO,SAAS,sBAAsB,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE;AACjE,IAAI,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,CAAC,EAAE,MAAM,IAAI,SAAS,CAAC,+CAA+C,CAAC,CAAC;AACjG,IAAI,IAAI,OAAO,KAAK,KAAK,UAAU,GAAG,QAAQ,KAAK,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,SAAS,CAAC,0EAA0E,CAAC,CAAC;AACvL,IAAI,OAAO,IAAI,KAAK,GAAG,GAAG,CAAC,GAAG,IAAI,KAAK,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAClG,CAAC;AACD;AACO,SAAS,sBAAsB,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,EAAE;AACxE,IAAI,IAAI,IAAI,KAAK,GAAG,EAAE,MAAM,IAAI,SAAS,CAAC,gCAAgC,CAAC,CAAC;AAC5E,IAAI,IAAI,IAAI,KAAK,GAAG,IAAI,CAAC,CAAC,EAAE,MAAM,IAAI,SAAS,CAAC,+CAA+C,CAAC,CAAC;AACjG,IAAI,IAAI,OAAO,KAAK,KAAK,UAAU,GAAG,QAAQ,KAAK,KAAK,IAAI,CAAC,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,SAAS,CAAC,yEAAyE,CAAC,CAAC;AACtL,IAAI,OAAO,CAAC,IAAI,KAAK,GAAG,GAAG,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC,GAAG,KAAK,CAAC;AAC9G,CAAC;AA8BD;AACuB,OAAO,eAAe,KAAK,UAAU,GAAG,eAAe,GAAG,UAAU,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE;AACvH,IAAI,IAAI,CAAC,GAAG,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC;AAC/B,IAAI,OAAO,CAAC,CAAC,IAAI,GAAG,iBAAiB,EAAE,CAAC,CAAC,KAAK,GAAG,KAAK,EAAE,CAAC,CAAC,UAAU,GAAG,UAAU,EAAE,CAAC,CAAC;AACrF;;;;","x_google_ignoreList":[0]}

package/dist/esm/styles.js

@@ -0,0 +1,3 @@
+import './assets/src/theme/darkTheme.css.ts.vanilla-BHZ3ecRn.css';
+import './assets/src/theme/globalScrollbars.css.ts.vanilla-BAJwnUEJ.css';
+//# sourceMappingURL=styles.js.map

package/dist/esm/styles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/esm/theme/ThemeProvider.js

@@ -7,9 +7,11 @@ import { GLOBAL_SCROLLBARS_CLASS } from './globalScrollbars.css.js';
 /**
  * Theme provider for Entangle UI components.
  *
- * The dark theme is applied globally via CSS custom properties on `:root`,
- * so this provider is a pass-through for most apps. Use it to opt into
- * additional global behaviors such as native-scrollbar theming.
+ * The dark theme's `--etui-*` custom properties are registered on `:root`
+ * by the canonical stylesheet — `import 'entangle-ui/styles.css'` once at your
+ * app root. With that loaded this provider is optional and acts as a
+ * pass-through for most apps; use it to opt into additional global behaviors
+ * such as native-scrollbar theming (`globalScrollbars`) and keyboard context.
  *
  * For scoped theme overrides, use `VanillaThemeProvider` with a custom
  * class generated by `createCustomTheme()`.

package/dist/esm/theme/ThemeProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"ThemeProvider.js","sources":["../../../../src/theme/ThemeProvider.tsx"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAuBA;;;;;;;;;AASG;AACI;;AAKH;;;;AAGA;AACA;AACA;AACE;AACF;AACF;AAEA;AACF;;"}
+{"version":3,"file":"ThemeProvider.js","sources":["src/theme/ThemeProvider.tsx"],"sourcesContent":["'use client';\n\nimport React, { useEffect } from 'react';\n\nimport { KeyboardContextProvider } from '@/context/KeyboardContext';\n\nimport { GLOBAL_SCROLLBARS_CLASS } from './globalScrollbars.css';\n\nexport interface ThemeProviderProps {\n  children: React.ReactNode;\n  /**\n   * When true, apply Entangle's dark-theme scrollbar styling globally\n   * (thin 8px track, muted thumb). The class is added to\n   * `document.body` and removed on unmount.\n   *\n   * Opt-in by design: many app shells run alongside other UI\n   * frameworks where forcing scrollbar styles would be invasive.\n   *\n   * @default false\n   */\n  globalScrollbars?: boolean;\n}\n\n/**\n * Theme provider for Entangle UI components.\n *\n * The dark theme's `--etui-*` custom properties are registered on `:root`\n * by the canonical stylesheet — `import 'entangle-ui/styles.css'` once at your\n * app root. With that loaded this provider is optional and acts as a\n * pass-through for most apps; use it to opt into additional global behaviors\n * such as native-scrollbar theming (`globalScrollbars`) and keyboard context.\n *\n * For scoped theme overrides, use `VanillaThemeProvider` with a custom\n * class generated by `createCustomTheme()`.\n */\nexport const ThemeProvider: React.FC<ThemeProviderProps> = ({\n  children,\n  globalScrollbars = false,\n}) => {\n  useEffect(() => {\n    if (!globalScrollbars) return;\n    if (typeof document === 'undefined') return;\n\n    const body = document.body;\n    body.classList.add(GLOBAL_SCROLLBARS_CLASS);\n    return () => {\n      body.classList.remove(GLOBAL_SCROLLBARS_CLASS);\n    };\n  }, [globalScrollbars]);\n\n  return <KeyboardContextProvider>{children}</KeyboardContextProvider>;\n};\n"],"names":[],"mappings":";;;;;;AAuBA;;;;;;;;;;;AAWG;AACI;;AAKH;;;;AAGA;AACA;AACA;AACE;AACF;AACF;AAEA;AACF;;"}

package/dist/esm/theme/VanillaThemeProvider.js.map

@@ -1 +1 @@
-{"version":3,"file":"VanillaThemeProvider.js","sources":["../../../../src/theme/VanillaThemeProvider.tsx"],"sourcesContent":[null],"names":["_jsx"],"mappings":";;AAaA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,oBAAoB,GAAwC,CAAC,EACxE,QAAQ,EACR,SAAS,GACV,KAAI;AACH,IAAA,OAAOA,aAAK,SAAS,EAAE,SAAS,EAAA,QAAA,EAAG,QAAQ,GAAO;AACpD;;;;"}
+{"version":3,"file":"VanillaThemeProvider.js","sources":["src/theme/VanillaThemeProvider.tsx"],"sourcesContent":["import React from 'react';\n\nexport interface VanillaThemeProviderProps {\n  children: React.ReactNode;\n  /**\n   * CSS class name that sets theme CSS custom properties.\n   * Can be a class from createTheme() or a custom class.\n   *\n   * When omitted, components inherit tokens from :root (dark theme).\n   */\n  className?: string;\n}\n\n/**\n * Optional wrapper for scoped theme overrides.\n *\n * The dark theme is applied globally on :root — most apps don't need\n * VanillaThemeProvider at all. Use it only when you need a different theme\n * for a subtree (e.g. a light-themed dialog inside a dark app).\n *\n * @example\n * ```tsx\n * // No provider needed for default dark theme:\n * <App />\n *\n * // Scoped override for a subtree:\n * <VanillaThemeProvider className=\"my-light-section\">\n *   <SettingsPanel />\n * </VanillaThemeProvider>\n * ```\n */\nexport const VanillaThemeProvider: React.FC<VanillaThemeProviderProps> = ({\n  children,\n  className,\n}) => {\n  return <div className={className}>{children}</div>;\n};\n"],"names":["_jsx"],"mappings":";;AAaA;;;;;;;;;;;;;;;;;AAiBG;AACI,MAAM,oBAAoB,GAAwC,CAAC,EACxE,QAAQ,EACR,SAAS,GACV,KAAI;AACH,IAAA,OAAOA,aAAK,SAAS,EAAE,SAAS,EAAA,QAAA,EAAG,QAAQ,GAAO;AACpD;;;;"}

package/dist/esm/theme/breakpoints.js.map

@@ -1 +1 @@
-{"version":3,"file":"breakpoints.js","sources":["../../../../src/theme/breakpoints.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;;;;;;;;;AASG;AACI,MAAM,WAAW,GAAG;AACzB,IAAA,EAAE,EAAE,CAAC;AACL,IAAA,EAAE,EAAE,GAAG;AACP,IAAA,EAAE,EAAE,GAAG;AACP,IAAA,EAAE,EAAE,GAAG;AACP,IAAA,EAAE,EAAE,IAAI;;AAKH,MAAM,gBAAgB,GAA8B;IACzD,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;;;;;"}
+{"version":3,"file":"breakpoints.js","sources":["src/theme/breakpoints.ts"],"sourcesContent":["/**\n * Library breakpoint values (px) — used by responsive components like\n * `Stack` and exposed via `useBreakpoint`.\n *\n * Values follow the same scale Stack already uses (576/768/992/1200) and\n * are part of the public API.\n *\n * `xs` is always `0` and effectively means \"no minimum\"; every viewport\n * matches `xs`.\n */\nexport const breakpoints = {\n  xs: 0,\n  sm: 576,\n  md: 768,\n  lg: 992,\n  xl: 1200,\n} as const;\n\nexport type Breakpoint = keyof typeof breakpoints;\n\nexport const BREAKPOINT_ORDER: ReadonlyArray<Breakpoint> = [\n  'xs',\n  'sm',\n  'md',\n  'lg',\n  'xl',\n];\n"],"names":[],"mappings":"AAAA;;;;;;;;;AASG;AACI,MAAM,WAAW,GAAG;AACzB,IAAA,EAAE,EAAE,CAAC;AACL,IAAA,EAAE,EAAE,GAAG;AACP,IAAA,EAAE,EAAE,GAAG;AACP,IAAA,EAAE,EAAE,GAAG;AACP,IAAA,EAAE,EAAE,IAAI;;AAKH,MAAM,gBAAgB,GAA8B;IACzD,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;IACJ,IAAI;;;;;"}

package/dist/esm/theme/createCustomTheme.js

@@ -1,4 +1,4 @@
-import { createGlobalTheme } from '../node_modules/@vanilla-extract/css/dist/vanilla-extract-css.esm.js';
+import { createGlobalTheme } from '@vanilla-extract/css';
 import { mergeDeep } from '../utils/objects.js';
 import { vars } from './contract.css.js';
 import { darkThemeValues } from './darkTheme.css.js';

package/dist/esm/theme/createCustomTheme.js.map

@@ -1 +1 @@
-{"version":3,"file":"createCustomTheme.js","sources":["../../../../src/theme/createCustomTheme.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AAYA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,iBAAiB,CAC/B,QAAgB,EAChB,SAAmC,EAAA;IAEnC,MAAM,MAAM,GAAG,SAAS,CACtB,eAAqD,EACrD,SAA4D,CAC9C;AAChB,IAAA,iBAAiB,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC;AAC3C;;;;"}
+{"version":3,"file":"createCustomTheme.js","sources":["src/theme/createCustomTheme.ts"],"sourcesContent":["import { createGlobalTheme } from '@vanilla-extract/css';\n\nimport { mergeDeep } from '@/utils/objects';\n\nimport { vars } from './contract.css';\nimport { darkThemeValues } from './darkTheme.css';\n\nimport type { DarkThemeValues } from './darkTheme.css';\nimport type { DeepPartial } from '@/types/utilities';\n\nexport type ThemeValues = DarkThemeValues;\n\n/**\n * Creates a custom theme scoped to a CSS selector by deep-merging\n * overrides onto the dark theme defaults.\n *\n * MUST be called in a .css.ts file (build-time only).\n *\n * @param selector - CSS selector to scope the theme to (e.g. '.my-brand', '[data-theme=\"light\"]')\n * @param overrides - Partial theme values to override\n *\n * @example\n * ```typescript\n * // my-theme.css.ts\n * import { createCustomTheme } from 'entangle-ui/theme';\n *\n * createCustomTheme('.my-brand', {\n *   colors: {\n *     accent: { primary: '#ff6600' },\n *   },\n * });\n * ```\n */\nexport function createCustomTheme(\n  selector: string,\n  overrides: DeepPartial<ThemeValues>\n) {\n  const merged = mergeDeep(\n    darkThemeValues as unknown as Record<string, unknown>,\n    overrides as unknown as DeepPartial<Record<string, unknown>>\n  ) as ThemeValues;\n  createGlobalTheme(selector, vars, merged);\n}\n"],"names":[],"mappings":";;;;;AAYA;;;;;;;;;;;;;;;;;;;;AAoBG;AACG,SAAU,iBAAiB,CAC/B,QAAgB,EAChB,SAAmC,EAAA;IAEnC,MAAM,MAAM,GAAG,SAAS,CACtB,eAAqD,EACrD,SAA4D,CAC9C;AAChB,IAAA,iBAAiB,CAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,CAAC;AAC3C;;;;"}

package/dist/esm/theme/createLightTheme.js.map

@@ -1 +1 @@
-{"version":3,"file":"createLightTheme.js","sources":["../../../../src/theme/createLightTheme.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;AAoBG;SACa,gBAAgB,GAAA;AAC9B,IAAA,OAAO,eAAe;AACxB;;;;"}
+{"version":3,"file":"createLightTheme.js","sources":["src/theme/createLightTheme.ts"],"sourcesContent":["import { lightThemeClass } from './lightTheme.css';\n\n/**\n * Returns the light-theme CSS class. Apply the returned class to any\n * subtree (typically via `VanillaThemeProvider`) to flip its tokens\n * from the dark default to the light preset.\n *\n * The class is generated at build time inside `lightTheme.css.ts` (where\n * Vanilla Extract's file scope is set), so this helper is safe to call\n * from any `.ts`/`.tsx` file — no `.css.ts` wrapper required. Consumers\n * who prefer can also import `lightThemeClass` directly from the package.\n *\n * @example\n * ```tsx\n * import { createLightTheme, VanillaThemeProvider } from 'entangle-ui';\n *\n * const lightThemeClass = createLightTheme();\n *\n * <VanillaThemeProvider className={lightThemeClass}>\n *   <SettingsPanel />\n * </VanillaThemeProvider>\n * ```\n */\nexport function createLightTheme(): string {\n  return lightThemeClass;\n}\n"],"names":[],"mappings":";;AAEA;;;;;;;;;;;;;;;;;;;;AAoBG;SACa,gBAAgB,GAAA;AAC9B,IAAA,OAAO,eAAe;AACxB;;;;"}