entangle-ui 0.9.0 → 0.11.0

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

@@ -0,0 +1 @@
+{"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

@@ -1,12 +1,13 @@
 "use client";
 import { useRef, useEffect } from 'react';
+import { useEventCallback } from '../useEventCallback/useEventCallback.js';
 
 /**
  * Observe size changes on an element. SSR-safe; cleans up on unmount.
  *
- * The callback is wrapped in a ref so consumers do not have to memoize it —
- * the underlying observer never re-subscribes when the callback identity
- * changes.
+ * The callback is wrapped with `useEventCallback` so consumers do not have
+ * to memoize it — the underlying observer never re-subscribes when the
+ * callback identity changes.
  *
  * The hook re-checks `ref.current` on every render so it picks up nodes that
  * mount later (e.g. through conditional rendering). When the observed node
@@ -24,12 +25,9 @@ import { useRef, useEffect } from 'react';
  */
 function useResizeObserver(ref, callback, options) {
     const { enabled = true } = options ?? {};
-    const callbackRef = useRef(callback);
+    const handleEntry = useEventCallback(callback);
     const observerRef = useRef(null);
     const observedNodeRef = useRef(null);
-    useEffect(() => {
-        callbackRef.current = callback;
-    }, [callback]);
     // Runs on every render so a node that mounts after the first render
     // (conditional rendering, lazy children, suspense fallback flips, ...) is
     // picked up automatically. Short-circuits on the common case where the
@@ -57,7 +55,7 @@ function useResizeObserver(ref, callback, options) {
             return;
         const observer = new ResizeObserver(entries => {
             for (const entry of entries) {
-                callbackRef.current(entry);
+                handleEntry(entry);
             }
         });
         observer.observe(node);

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":";;;AAaA;;;;;;;;;;;;;;;;;;;;AAoBG;;;AAQD;AACA;AACA;;AAGE;AACF;;;;;;;;;AAUI;AACE;AACA;AACA;;;;AAKJ;AACA;;AAEA;AACE;AACA;;AAEF;AACA;;AAEA;AACE;AACE;;AAEJ;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,11 +3,11 @@ 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 './../../assets/src/theme/darkTheme.css.ts.vanilla-ab1WD4dr.css';
+import '@vanilla-extract/css';
+import './../../assets/src/theme/darkTheme.css.ts.vanilla-BHZ3ecRn.css';
 import 'react/jsx-runtime';
-import './../../assets/src/theme/globalScrollbars.css.ts.vanilla-BAJwnUEJ.css';
 import '../../utils/devWarn.js';
+import './../../assets/src/theme/globalScrollbars.css.ts.vanilla-BAJwnUEJ.css';
 
 const VAR_REF_PATTERN = /^var\((--[^,)]+)/;
 /**
@@ -162,6 +162,9 @@ function useTheme() {
             values: resolveValues(darkThemeValues, root, vars),
         };
         tokenCacheRef.current.clear();
+        // External-system sync: read resolved CSS custom properties from the DOM
+        // into state once mounted (they are unavailable during SSR/first render).
+        // eslint-disable-next-line react-hooks/set-state-in-effect
         setSnapshot(next);
     }, []);
     const getToken = useCallback((path) => {

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":";;;;;;;;;;;AAUA;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;;;AAIF;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

@@ -1,5 +1,6 @@
 "use client";
 import { useRef, useMemo, useEffect } from 'react';
+import { useEventCallback } from '../useEventCallback/useEventCallback.js';
 
 /**
  * Wrap a function so it fires at most once per `delay` ms. With both
@@ -21,8 +22,9 @@ import { useRef, useMemo, useEffect } from 'react';
  */
 function useThrottledCallback(fn, delay, options = {}) {
     const { leading = true, trailing = true } = options;
-    const fnRef = useRef(fn);
-    fnRef.current = fn;
+    // Stable wrapper that always invokes the current callback, refreshed via
+    // useInsertionEffect so the throttled wrapper never goes stale.
+    const stableFn = useEventCallback(fn);
     const lastCallRef = useRef(0);
     const timerRef = useRef(null);
     const lastArgsRef = useRef(null);
@@ -32,9 +34,12 @@ function useThrottledCallback(fn, delay, options = {}) {
             const args = lastArgsRef.current;
             lastArgsRef.current = null;
             if (args)
-                fnRef.current(...args);
+                stableFn(...args);
         };
         const wrapper = (...args) => {
+            // Date.now() runs only when the wrapper is invoked from an event/timer,
+            // never during render, so it is not a render-purity concern here.
+            // eslint-disable-next-line react-hooks/purity
             const now = Date.now();
             if (lastCallRef.current === 0 && !leading) {
                 // Skip the leading fire by anchoring the window to "now".
@@ -66,7 +71,7 @@ function useThrottledCallback(fn, delay, options = {}) {
             lastCallRef.current = 0;
         };
         return wrapper;
-    }, [delay, leading, trailing]);
+    }, [delay, leading, trailing, stableFn]);
     useEffect(() => () => {
         if (timerRef.current !== null)
             clearTimeout(timerRef.current);

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":";;;AAQA;;;;;;;;;;;;;;;;;AAiBG;AACG;;AAOJ;AACA;AAEA;AACA;AACA;AAEA;AACE;AACE;AACA;AACA;AACA;AAAU;AACZ;AAEA;AACE;;;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

@@ -52,6 +52,13 @@ export { Tooltip } from './components/primitives/Tooltip/Tooltip.js';
 export { VisuallyHidden } from './components/primitives/VisuallyHidden/VisuallyHidden.js';
 import 'react';
 import './components/primitives/canvas/CanvasContainer.js';
+export { Viewport } from './components/primitives/viewport/Viewport.js';
+export { ViewportLayer } from './components/primitives/viewport/ViewportLayer.js';
+export { ViewportWorld } from './components/primitives/viewport/ViewportWorld.js';
+export { ViewportOverlay } from './components/primitives/viewport/ViewportOverlay.js';
+export { useViewportContext } from './components/primitives/viewport/ViewportContext.js';
+export { getViewportPointerPosition, screenToWorld, worldToScreen } from './components/primitives/viewport/viewportCoords.js';
+export { computeCenterTransform, computeFitTransform, computeZoomTowardPivot, normalizeRect } from './components/primitives/viewport/viewportMath.js';
 export { ColorPicker } from './components/controls/ColorPicker/ColorPicker.js';
 export { ColorSwatch } from './components/controls/ColorPicker/ColorSwatch.js';
 export { EyeDropper } from './components/controls/ColorPicker/EyeDropper.js';
@@ -60,12 +67,15 @@ export { MATERIAL_PALETTE } from './components/controls/ColorPicker/palettes/mat
 export { TAILWIND_PALETTE } from './components/controls/ColorPicker/palettes/tailwind.js';
 export { EARTH_PALETTE, MONOCHROME_PALETTE, NEON_PALETTE, PASTEL_PALETTE, PROFESSIONAL_PALETTES, SKIN_TONES_PALETTE, VINTAGE_PALETTE } from './components/controls/ColorPicker/palettes/professional.js';
 export { Combobox } from './components/controls/Combobox/Combobox.js';
+export { FileTree } from './components/controls/FileTree/FileTree.js';
+export { classifyExtension, getFileExtension, getFileIconKind } from './components/controls/FileTree/fileTreeIcons.js';
+export { DEFAULT_FILE_TREE_LABELS } from './components/controls/FileTree/fileTreeLabels.js';
 export { FileUploader } from './components/controls/FileUploader/FileUploader.js';
 export { MultiSelect } from './components/controls/MultiSelect/MultiSelect.js';
 export { NumberInput } from './components/controls/NumberInput/NumberInput.js';
 export { KeyboardContextProvider, useEffectsOnKeyboard, useKeyboardContext } from './context/KeyboardContext.js';
-import './utils/mathExpression.js';
 import './utils/devWarn.js';
+import './utils/mathExpression.js';
 export { Select } from './components/controls/Select/Select.js';
 export { Slider } from './components/controls/Slider/Slider.js';
 export { TagInput } from './components/controls/TagInput/TagInput.js';
@@ -80,10 +90,9 @@ export { BreadcrumbItem } from './components/navigation/Breadcrumbs/BreadcrumbIt
 export { BreadcrumbSeparator } from './components/navigation/Breadcrumbs/BreadcrumbSeparator.js';
 export { BreadcrumbEllipsis } from './components/navigation/Breadcrumbs/BreadcrumbEllipsis.js';
 export { ContextMenu } from './components/navigation/ContextMenu/ContextMenu.js';
-export { useContextMenuTarget } from './components/navigation/ContextMenu/useContextMenuTarget.js';
 export { Menu } from './components/navigation/Menu/Menu.js';
-export { useMenu } from './components/navigation/Menu/useMenu.js';
 export { Pagination } from './components/navigation/Pagination/Pagination.js';
+export { PathBar } from './components/navigation/PathBar/PathBar.js';
 export { SegmentedControl } from './components/navigation/SegmentedControl/SegmentedControl.js';
 export { SegmentedControlItem } from './components/navigation/SegmentedControl/SegmentedControlItem.js';
 export { Tabs } from './components/navigation/Tabs/Tabs.js';
@@ -106,6 +115,12 @@ export { DialogClose } from './components/feedback/Dialog/DialogClose.js';
 export { CommandPalette } from './components/feedback/CommandPalette/CommandPalette.js';
 export { Drawer } from './components/feedback/Drawer/Drawer.js';
 export { EmptyState } from './components/feedback/EmptyState/EmptyState.js';
+export { LogView } from './components/feedback/LogView/LogView.js';
+export { LogViewBody } from './components/feedback/LogView/LogViewBody.js';
+export { LogViewClear, LogViewCopy, LogViewFooter, LogViewLevelFilter, LogViewSearch, LogViewToolbar } from './components/feedback/LogView/LogViewParts.js';
+export { useLogViewStats } from './components/feedback/LogView/LogViewContext.js';
+export { DEFAULT_LOG_VIEW_LABELS } from './components/feedback/LogView/logViewLabels.js';
+export { defaultFormatTimestamp, entriesToText, entryToText, getHighlightSegments } from './components/feedback/LogView/logViewUtils.js';
 export { ProgressBar } from './components/feedback/ProgressBar/ProgressBar.js';
 export { CircularProgress } from './components/feedback/ProgressBar/CircularProgress.js';
 export { Skeleton } from './components/feedback/Skeleton/Skeleton.js';
@@ -115,6 +130,8 @@ export { Spinner } from './components/feedback/Spinner/Spinner.js';
 export { Stat } from './components/feedback/Stat/Stat.js';
 export { ToastProvider } from './components/feedback/Toast/ToastProvider.js';
 export { useToast } from './components/feedback/Toast/useToast.js';
+export { AssetBrowser } from './components/editor/AssetBrowser/AssetBrowser.js';
+export { DEFAULT_ASSET_BROWSER_LABELS } from './components/editor/AssetBrowser/assetBrowserLabels.js';
 export { PropertyPanel } from './components/editor/PropertyInspector/PropertyPanel.js';
 export { PropertySection } from './components/editor/PropertyInspector/PropertySection.js';
 export { PropertyRow } from './components/editor/PropertyInspector/PropertyRow.js';
@@ -123,6 +140,23 @@ export { usePropertyUndo } from './components/editor/PropertyInspector/useProper
 export { ViewportGizmo } from './components/editor/ViewportGizmo/ViewportGizmo.js';
 export { axisToPresetView, eulerToRotationMatrix, gizmoHitTest, presetViewToOrientation, projectAxes, projectToCanvas, quaternionToEuler } from './components/editor/ViewportGizmo/gizmoMath.js';
 export { TransformControl } from './components/editor/TransformControl/TransformControl.js';
+export { Minimap } from './components/editor/Minimap/index.js';
+export { NodeGraph } from './components/editor/NodeGraph/NodeGraph.js';
+import 'react/jsx-runtime';
+export { ViewportMinimap } from './components/editor/Minimap/ViewportMinimap.js';
+export { cx as cn, cx } from './utils/cx.js';
+import './components/editor/NodeGraph/NodeGraph.css.js';
+export { useNodeGraphData, useNodeGraphHover, useNodeGraphInteraction, useNodeGraphSelection, useNodeGraphStore } from './components/editor/NodeGraph/NodeGraphContext.js';
+export { NodeGraphBackground, NodeGraphMinimap } from './components/editor/NodeGraph/NodeGraphSlots.js';
+export { NodeGraphPort } from './components/editor/NodeGraph/NodeGraphPort.js';
+export { NodeGraphPortVisual } from './components/editor/NodeGraph/NodeGraphPortVisual.js';
+export { NodeGraphPin } from './components/editor/NodeGraph/NodeGraphPin.js';
+export { NodeGraphNodeSection } from './components/editor/NodeGraph/NodeGraphNodeSection.js';
+export { useNodeGraph } from './components/editor/NodeGraph/useNodeGraph.js';
+export { createTypeMatchValidator } from './components/editor/NodeGraph/createTypeMatchValidator.js';
+export { duplicateNodes, edgesConnectedToPort } from './components/editor/NodeGraph/nodeGraphActions.js';
+export { generateEdgeId, generateNodeId } from './components/editor/NodeGraph/nodeGraphIds.js';
+export { NODE_GRAPH_SLOT } from './components/editor/NodeGraph/NodeGraph.types.js';
 export { ChatPanel } from './components/editor/ChatPanel/ChatPanel.js';
 export { ChatMessageList } from './components/editor/ChatPanel/ChatMessageList.js';
 export { ChatMessage } from './components/editor/ChatPanel/ChatMessage.js';
@@ -140,6 +174,7 @@ export { ChatMarkdownRenderer } from './components/editor/ChatPanel/ChatMarkdown
 export { useChatMessages } from './components/editor/ChatPanel/useChatMessages.js';
 export { useChatInput } from './components/editor/ChatPanel/useChatInput.js';
 export { useChatScroll } from './components/editor/ChatPanel/useChatScroll.js';
+export { Timeline } from './components/editor/Timeline/index.js';
 export { AppShell, useAppShell } from './components/shell/AppShell/AppShell.js';
 export { FloatingManager, FloatingPanel } from './components/shell/FloatingPanel/FloatingPanel.js';
 export { MenuBar } from './components/shell/MenuBar/MenuBar.js';
@@ -176,6 +211,7 @@ export { GridIcon } from './components/Icons/GridIcon.js';
 export { HeartIcon } from './components/Icons/HeartIcon.js';
 export { HelpIcon } from './components/Icons/HelpIcon.js';
 export { HomeIcon } from './components/Icons/HomeIcon.js';
+export { ImageIcon } from './components/Icons/ImageIcon.js';
 export { InfoIcon } from './components/Icons/InfoIcon.js';
 export { LastIcon } from './components/Icons/LastIcon.js';
 export { LinkIcon } from './components/Icons/LinkIcon.js';
@@ -231,10 +267,19 @@ 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';
 export { useMergedRef } from './hooks/useMergedRef/useMergedRef.js';
+export { useLatest } from './hooks/useLatest/useLatest.js';
+export { useEventCallback } from './hooks/useEventCallback/useEventCallback.js';
+export { useIsMounted } from './hooks/useIsMounted/useIsMounted.js';
 export { useResizeObserver } from './hooks/useResizeObserver/useResizeObserver.js';
 export { useDisclosure } from './hooks/useDisclosure/useDisclosure.js';
 export { useClipboard } from './hooks/useClipboard/useClipboard.js';
@@ -248,8 +293,22 @@ export { useThrottledCallback } from './hooks/useThrottledCallback/useThrottledC
 export { useIntersectionObserver } from './hooks/useIntersectionObserver/useIntersectionObserver.js';
 export { useListboxNav } from './hooks/useListboxNav/useListboxNav.js';
 export { useTheme } from './hooks/useTheme/useTheme.js';
-export { cx as cn, cx } from './utils/cx.js';
+import './hooks/useNavigationHistory/useNavigationHistory.js';
 export { getKeyGlyph, getPlatform, parseShortcut } from './utils/platform.js';
 export { animBlink, animFadeIn, animPulse, animSpin, animWave, blinkKeyframe, fadeInKeyframe, pulseKeyframe, spinKeyframe, waveKeyframe } from './utils/animations.css.js';
+export { MINIMAP_SLOT } from './components/editor/Minimap/Minimap.types.js';
+export { MinimapCorner } from './components/editor/Minimap/MinimapCorner.js';
+export { MinimapFooter } from './components/editor/Minimap/MinimapFooter.js';
+export { MinimapTitle } from './components/editor/Minimap/MinimapTitle.js';
+export { TIMELINE_SLOT } from './components/editor/Timeline/Timeline.types.js';
+export { TimelineFooter } from './components/editor/Timeline/TimelineFooter.js';
+export { TimelineMinimap } from './components/editor/Timeline/TimelineMinimap.js';
+export { TimelineToolbar } from './components/editor/Timeline/TimelineToolbar.js';
+export { TimelineTrackScale } from './components/editor/Timeline/TimelineTrackScale.js';
+export { computeBoundsFromItems } from './components/editor/Minimap/computeBoundsFromItems.js';
+export { framesToTimecode } from './components/editor/Timeline/timelineCoords.js';
 export { isKeyPressed, isModifierKey } from './hooks/useKeyboard/utils.js';
+export { selectedTangentMode, setSelectedTangentMode } from './components/editor/Timeline/timelineEdits.js';
+export { useMinimapContext, useMinimapDragState, useMinimapGeometry, useMinimapHover } from './components/editor/Minimap/MinimapContext.js';
+export { useTimelineContext, useTimelineGeometry, useTimelinePlayhead, useTimelineSelectedTangentMode, useTimelineSelection } from './components/editor/Timeline/TimelineContext.js';
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,37 @@
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    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");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    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");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+export { __classPrivateFieldGet, __classPrivateFieldSet };
+//# sourceMappingURL=tslib.es6.js.map

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

@@ -0,0 +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]}

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

@@ -1,15 +1,17 @@
 "use client";
 import { jsx } from 'react/jsx-runtime';
 import { useEffect } from 'react';
-import { GLOBAL_SCROLLBARS_CLASS } from './globalScrollbars.css.js';
 import { KeyboardContextProvider } from '../context/KeyboardContext.js';
+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":";;;;;;AAqBA;;;;;;;;;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/contract.css.js

@@ -1,4 +1,4 @@
-var vars = {colors:{background:{primary:'var(--etui-color-bg-primary)',secondary:'var(--etui-color-bg-secondary)',tertiary:'var(--etui-color-bg-tertiary)',elevated:'var(--etui-color-bg-elevated)',inset:'var(--etui-color-bg-inset)'},surface:{'default':'var(--etui-color-surface-default)',hover:'var(--etui-color-surface-hover)',active:'var(--etui-color-surface-active)',disabled:'var(--etui-color-surface-disabled)',whiteOverlay:'var(--etui-color-surface-white-overlay)',row:'var(--etui-color-surface-row)',rowHover:'var(--etui-color-surface-row-hover)'},border:{'default':'var(--etui-color-border-default)',focus:'var(--etui-color-border-focus)',error:'var(--etui-color-border-error)',success:'var(--etui-color-border-success)'},text:{primary:'var(--etui-color-text-primary)',secondary:'var(--etui-color-text-secondary)',muted:'var(--etui-color-text-muted)',disabled:'var(--etui-color-text-disabled)'},accent:{primary:'var(--etui-color-accent-primary)',secondary:'var(--etui-color-accent-secondary)',success:'var(--etui-color-accent-success)',warning:'var(--etui-color-accent-warning)',error:'var(--etui-color-accent-error)'},backdrop:'var(--etui-color-backdrop)'},spacing:{xs:'var(--etui-spacing-xs)',sm:'var(--etui-spacing-sm)',md:'var(--etui-spacing-md)',lg:'var(--etui-spacing-lg)',xl:'var(--etui-spacing-xl)',xxl:'var(--etui-spacing-xxl)',xxxl:'var(--etui-spacing-xxxl)'},typography:{fontSize:{xxs:'var(--etui-font-size-xxs)',xs:'var(--etui-font-size-xs)',sm:'var(--etui-font-size-sm)',md:'var(--etui-font-size-md)',lg:'var(--etui-font-size-lg)',xl:'var(--etui-font-size-xl)'},fontWeight:{normal:'var(--etui-font-weight-normal)',medium:'var(--etui-font-weight-medium)',semibold:'var(--etui-font-weight-semibold)'},lineHeight:{tight:'var(--etui-line-height-tight)',normal:'var(--etui-line-height-normal)',relaxed:'var(--etui-line-height-relaxed)'},fontFamily:{mono:'var(--etui-font-family-mono)',sans:'var(--etui-font-family-sans)'}},borderRadius:{none:'var(--etui-radius-none)',sm:'var(--etui-radius-sm)',md:'var(--etui-radius-md)',lg:'var(--etui-radius-lg)'},shadows:{sm:'var(--etui-shadow-sm)',md:'var(--etui-shadow-md)',lg:'var(--etui-shadow-lg)',xl:'var(--etui-shadow-xl)',focus:'var(--etui-shadow-focus)',separatorBottom:'var(--etui-shadow-separator-bottom)',separatorRight:'var(--etui-shadow-separator-right)',separatorLeft:'var(--etui-shadow-separator-left)',thumb:'var(--etui-shadow-thumb)'},transitions:{fast:'var(--etui-transition-fast)',normal:'var(--etui-transition-normal)',slow:'var(--etui-transition-slow)'},zIndex:{base:'var(--etui-z-base)',dropdown:'var(--etui-z-dropdown)',popover:'var(--etui-z-popover)',tooltip:'var(--etui-z-tooltip)',modal:'var(--etui-z-modal)'},shell:{menuBar:{height:'var(--etui-shell-menubar-height)',bg:'var(--etui-shell-menubar-bg)',hoverBg:'var(--etui-shell-menubar-hover-bg)',activeBg:'var(--etui-shell-menubar-active-bg)',text:'var(--etui-shell-menubar-text)',shortcutText:'var(--etui-shell-menubar-shortcut-text)'},toolbar:{height:{sm:'var(--etui-shell-toolbar-height-sm)',md:'var(--etui-shell-toolbar-height-md)'},bg:'var(--etui-shell-toolbar-bg)',separator:'var(--etui-shell-toolbar-separator)'},statusBar:{height:'var(--etui-shell-statusbar-height)',heightMd:'var(--etui-shell-statusbar-height-md)',bg:'var(--etui-shell-statusbar-bg)',text:'var(--etui-shell-statusbar-text)'},dock:{tabHeight:'var(--etui-shell-dock-tab-height)',tabBg:'var(--etui-shell-dock-tab-bg)',tabActiveBg:'var(--etui-shell-dock-tab-active-bg)',tabHoverBg:'var(--etui-shell-dock-tab-hover-bg)',tabText:'var(--etui-shell-dock-tab-text)',tabActiveText:'var(--etui-shell-dock-tab-active-text)',splitterSize:'var(--etui-shell-dock-splitter-size)',splitterColor:'var(--etui-shell-dock-splitter-color)',splitterHoverColor:'var(--etui-shell-dock-splitter-hover-color)',borderBarBg:'var(--etui-shell-dock-border-bar-bg)',borderBarSize:'var(--etui-shell-dock-border-bar-size)',dropOverlay:'var(--etui-shell-dock-drop-overlay)'}},storybook:{canvas:{gradientStart:'var(--etui-storybook-gradient-start)',gradientMid:'var(--etui-storybook-gradient-mid)',gradientEnd:'var(--etui-storybook-gradient-end)'}}};
+var vars = {colors:{background:{primary:'var(--etui-color-bg-primary)',secondary:'var(--etui-color-bg-secondary)',tertiary:'var(--etui-color-bg-tertiary)',elevated:'var(--etui-color-bg-elevated)',inset:'var(--etui-color-bg-inset)'},surface:{'default':'var(--etui-color-surface-default)',hover:'var(--etui-color-surface-hover)',active:'var(--etui-color-surface-active)',disabled:'var(--etui-color-surface-disabled)',whiteOverlay:'var(--etui-color-surface-white-overlay)',row:'var(--etui-color-surface-row)',rowHover:'var(--etui-color-surface-row-hover)'},border:{'default':'var(--etui-color-border-default)',focus:'var(--etui-color-border-focus)',error:'var(--etui-color-border-error)',success:'var(--etui-color-border-success)'},text:{primary:'var(--etui-color-text-primary)',secondary:'var(--etui-color-text-secondary)',muted:'var(--etui-color-text-muted)',disabled:'var(--etui-color-text-disabled)'},accent:{primary:'var(--etui-color-accent-primary)',secondary:'var(--etui-color-accent-secondary)',success:'var(--etui-color-accent-success)',warning:'var(--etui-color-accent-warning)',error:'var(--etui-color-accent-error)'},backdrop:'var(--etui-color-backdrop)'},spacing:{xs:'var(--etui-spacing-xs)',sm:'var(--etui-spacing-sm)',md:'var(--etui-spacing-md)',lg:'var(--etui-spacing-lg)',xl:'var(--etui-spacing-xl)',xxl:'var(--etui-spacing-xxl)',xxxl:'var(--etui-spacing-xxxl)'},typography:{fontSize:{xxs:'var(--etui-font-size-xxs)',xs:'var(--etui-font-size-xs)',sm:'var(--etui-font-size-sm)',md:'var(--etui-font-size-md)',lg:'var(--etui-font-size-lg)',xl:'var(--etui-font-size-xl)'},fontWeight:{normal:'var(--etui-font-weight-normal)',medium:'var(--etui-font-weight-medium)',semibold:'var(--etui-font-weight-semibold)'},lineHeight:{tight:'var(--etui-line-height-tight)',normal:'var(--etui-line-height-normal)',relaxed:'var(--etui-line-height-relaxed)'},fontFamily:{mono:'var(--etui-font-family-mono)',sans:'var(--etui-font-family-sans)'}},borderRadius:{none:'var(--etui-radius-none)',sm:'var(--etui-radius-sm)',md:'var(--etui-radius-md)',lg:'var(--etui-radius-lg)'},shadows:{sm:'var(--etui-shadow-sm)',md:'var(--etui-shadow-md)',lg:'var(--etui-shadow-lg)',xl:'var(--etui-shadow-xl)',focus:'var(--etui-shadow-focus)',separatorBottom:'var(--etui-shadow-separator-bottom)',separatorRight:'var(--etui-shadow-separator-right)',separatorLeft:'var(--etui-shadow-separator-left)',thumb:'var(--etui-shadow-thumb)'},transitions:{fast:'var(--etui-transition-fast)',normal:'var(--etui-transition-normal)',slow:'var(--etui-transition-slow)'},zIndex:{base:'var(--etui-z-base)',dropdown:'var(--etui-z-dropdown)',popover:'var(--etui-z-popover)',tooltip:'var(--etui-z-tooltip)',modal:'var(--etui-z-modal)'},shell:{menuBar:{height:'var(--etui-shell-menubar-height)',bg:'var(--etui-shell-menubar-bg)',hoverBg:'var(--etui-shell-menubar-hover-bg)',activeBg:'var(--etui-shell-menubar-active-bg)',text:'var(--etui-shell-menubar-text)',shortcutText:'var(--etui-shell-menubar-shortcut-text)'},toolbar:{height:{sm:'var(--etui-shell-toolbar-height-sm)',md:'var(--etui-shell-toolbar-height-md)'},bg:'var(--etui-shell-toolbar-bg)',separator:'var(--etui-shell-toolbar-separator)'},statusBar:{height:'var(--etui-shell-statusbar-height)',heightMd:'var(--etui-shell-statusbar-height-md)',bg:'var(--etui-shell-statusbar-bg)',text:'var(--etui-shell-statusbar-text)'},dock:{tabHeight:'var(--etui-shell-dock-tab-height)',tabBg:'var(--etui-shell-dock-tab-bg)',tabActiveBg:'var(--etui-shell-dock-tab-active-bg)',tabHoverBg:'var(--etui-shell-dock-tab-hover-bg)',tabText:'var(--etui-shell-dock-tab-text)',tabActiveText:'var(--etui-shell-dock-tab-active-text)',splitterSize:'var(--etui-shell-dock-splitter-size)',splitterColor:'var(--etui-shell-dock-splitter-color)',splitterHoverColor:'var(--etui-shell-dock-splitter-hover-color)',borderBarBg:'var(--etui-shell-dock-border-bar-bg)',borderBarSize:'var(--etui-shell-dock-border-bar-size)',dropOverlay:'var(--etui-shell-dock-drop-overlay)'}},demo:{canvas:{gradientStart:'var(--etui-demo-gradient-start)',gradientMid:'var(--etui-demo-gradient-mid)',gradientEnd:'var(--etui-demo-gradient-end)'}}};
 
 export { vars };
 //# sourceMappingURL=contract.css.js.map

package/dist/esm/theme/createCustomTheme.js

@@ -1,7 +1,7 @@
-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';
-import { mergeDeep } from '../utils/objects.js';
 
 /**
  * Creates a custom theme scoped to a CSS selector by deep-merging

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

@@ -1 +1 @@
-{"version":3,"file":"createCustomTheme.js","sources":["../../../../src/theme/createCustomTheme.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;;AASA;;;;;;;;;;;;;;;;;;;;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;;;;"}

package/dist/esm/theme/darkTheme.css.js

@@ -1,6 +1,6 @@
-import './../assets/src/theme/darkTheme.css.ts.vanilla-ab1WD4dr.css';
+import './../assets/src/theme/darkTheme.css.ts.vanilla-BHZ3ecRn.css';
 
-var darkThemeValues = {colors:{background:{primary:'#1a1a1a',secondary:'#2d2d2d',tertiary:'#3a3a3a',elevated:'#404040',inset:'rgba(0, 0, 0, 0.2)'},surface:{'default':'#2d2d2d',hover:'#363636',active:'#404040',disabled:'#1f1f1f',whiteOverlay:'rgba(255, 255, 255, 0.1)',row:'transparent',rowHover:'rgba(255, 255, 255, 0.03)'},border:{'default':'#4a4a4a',focus:'#007acc',error:'#f44336',success:'#4caf50'},text:{primary:'#ffffff',secondary:'#cccccc',muted:'#888888',disabled:'#555555'},accent:{primary:'#007acc',secondary:'#005a9e',success:'#4caf50',warning:'#ff9800',error:'#f44336'},backdrop:'rgba(0, 0, 0, 0.6)'},spacing:{xs:'2px',sm:'4px',md:'8px',lg:'12px',xl:'16px',xxl:'24px',xxxl:'32px'},typography:{fontSize:{xxs:'9px',xs:'10px',sm:'11px',md:'12px',lg:'14px',xl:'16px'},fontWeight:{normal:'400',medium:'500',semibold:'600'},lineHeight:{tight:'1.2',normal:'1.4',relaxed:'1.6'},fontFamily:{mono:'SF Mono, Monaco, Consolas, "Liberation Mono", "Courier New", monospace',sans:'-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif'}},borderRadius:{none:'0px',sm:'2px',md:'4px',lg:'6px'},shadows:{sm:'0 1px 2px rgba(0, 0, 0, 0.2)',md:'0 2px 4px rgba(0, 0, 0, 0.3)',lg:'0 4px 8px rgba(0, 0, 0, 0.4)',xl:'0 8px 16px rgba(0, 0, 0, 0.5)',focus:'0 0 0 2px rgba(0, 122, 204, 0.4)',separatorBottom:'0 1px 2px rgba(0, 0, 0, 0.18)',separatorRight:'1px 0 2px rgba(0, 0, 0, 0.18)',separatorLeft:'-1px 0 2px rgba(0, 0, 0, 0.18)',thumb:'0 0 2px rgba(0, 0, 0, 0.5)'},transitions:{fast:'100ms ease-out',normal:'200ms ease-out',slow:'300ms ease-out'},zIndex:{base:'1',dropdown:'1000',popover:'1000',tooltip:'1000',modal:'1100'},shell:{menuBar:{height:'28px',bg:'#2d2d2d',hoverBg:'#363636',activeBg:'#005a9e',text:'#ffffff',shortcutText:'#888888'},toolbar:{height:{sm:'32px',md:'40px'},bg:'#2d2d2d',separator:'#4a4a4a'},statusBar:{height:'22px',heightMd:'26px',bg:'#007acc',text:'#ffffff'},dock:{tabHeight:'28px',tabBg:'#2d2d2d',tabActiveBg:'#1a1a1a',tabHoverBg:'#363636',tabText:'#cccccc',tabActiveText:'#ffffff',splitterSize:'4px',splitterColor:'#4a4a4a',splitterHoverColor:'#007acc',borderBarBg:'#2d2d2d',borderBarSize:'28px',dropOverlay:'rgba(0, 122, 204, 0.2)'}},storybook:{canvas:{gradientStart:'#061f21',gradientMid:'#031a1a',gradientEnd:'#091010'}}};
+var darkThemeValues = {colors:{background:{primary:'#1a1a1a',secondary:'#2d2d2d',tertiary:'#3a3a3a',elevated:'#404040',inset:'rgba(0, 0, 0, 0.2)'},surface:{'default':'#2d2d2d',hover:'#363636',active:'#404040',disabled:'#1f1f1f',whiteOverlay:'rgba(255, 255, 255, 0.1)',row:'transparent',rowHover:'rgba(255, 255, 255, 0.03)'},border:{'default':'#4a4a4a',focus:'#007acc',error:'#f44336',success:'#4caf50'},text:{primary:'#ffffff',secondary:'#cccccc',muted:'#888888',disabled:'#555555'},accent:{primary:'#007acc',secondary:'#005a9e',success:'#4caf50',warning:'#ff9800',error:'#f44336'},backdrop:'rgba(0, 0, 0, 0.6)'},spacing:{xs:'2px',sm:'4px',md:'8px',lg:'12px',xl:'16px',xxl:'24px',xxxl:'32px'},typography:{fontSize:{xxs:'9px',xs:'10px',sm:'11px',md:'12px',lg:'14px',xl:'16px'},fontWeight:{normal:'400',medium:'500',semibold:'600'},lineHeight:{tight:'1.2',normal:'1.4',relaxed:'1.6'},fontFamily:{mono:'SF Mono, Monaco, Consolas, "Liberation Mono", "Courier New", monospace',sans:'-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif'}},borderRadius:{none:'0px',sm:'2px',md:'4px',lg:'6px'},shadows:{sm:'0 1px 2px rgba(0, 0, 0, 0.2)',md:'0 2px 4px rgba(0, 0, 0, 0.3)',lg:'0 4px 8px rgba(0, 0, 0, 0.4)',xl:'0 8px 16px rgba(0, 0, 0, 0.5)',focus:'0 0 0 2px rgba(0, 122, 204, 0.4)',separatorBottom:'0 1px 2px rgba(0, 0, 0, 0.18)',separatorRight:'1px 0 2px rgba(0, 0, 0, 0.18)',separatorLeft:'-1px 0 2px rgba(0, 0, 0, 0.18)',thumb:'0 0 2px rgba(0, 0, 0, 0.5)'},transitions:{fast:'100ms ease-out',normal:'200ms ease-out',slow:'300ms ease-out'},zIndex:{base:'1',dropdown:'1000',popover:'1000',tooltip:'1000',modal:'1100'},shell:{menuBar:{height:'28px',bg:'#2d2d2d',hoverBg:'#363636',activeBg:'#005a9e',text:'#ffffff',shortcutText:'#888888'},toolbar:{height:{sm:'32px',md:'40px'},bg:'#2d2d2d',separator:'#4a4a4a'},statusBar:{height:'22px',heightMd:'26px',bg:'#007acc',text:'#ffffff'},dock:{tabHeight:'28px',tabBg:'#2d2d2d',tabActiveBg:'#1a1a1a',tabHoverBg:'#363636',tabText:'#cccccc',tabActiveText:'#ffffff',splitterSize:'4px',splitterColor:'#4a4a4a',splitterHoverColor:'#007acc',borderBarBg:'#2d2d2d',borderBarSize:'28px',dropOverlay:'rgba(0, 122, 204, 0.2)'}},demo:{canvas:{gradientStart:'#061f21',gradientMid:'#031a1a',gradientEnd:'#091010'}}};
 
 export { darkThemeValues };
 //# sourceMappingURL=darkTheme.css.js.map

package/dist/esm/theme/darkThemeValues.js

@@ -142,7 +142,7 @@ const darkThemeValues = {
             dropOverlay: 'rgba(0, 122, 204, 0.2)',
         },
     },
-    storybook: {
+    demo: {
         canvas: {
             gradientStart: '#061f21',
             gradientMid: '#031a1a',