@cognivo/components 0.8.0

package/dist/styles/premium.css.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Top-edge light simulation on dark surfaces.
+ * Creates a 1px white highlight at the top of the element,
+ * simulating overhead lighting hitting a raised surface.
+ * (Apple/macOS pattern used in premium dark UIs)
+ */
+export declare const insetHighlight: import('lit').CSSResult;
+/**
+ * Subtle top-to-bottom gradient on surfaces for depth.
+ * The 3% lightness difference creates a physical-object feel
+ * without being visually distracting.
+ */
+export declare const surfaceGradient: import('lit').CSSResult;
+/**
+ * Micro-scale on hover for interactive elements.
+ * The 1.02 scale is subtle enough to feel natural but
+ * noticeable enough to communicate interactivity.
+ */
+export declare const hoverScale: import('lit').CSSResult;
+/**
+ * Color-matched hover background using the accent hue
+ * at very low opacity. This feels intentional rather than
+ * a generic gray overlay. (Radix/Shadcn pattern)
+ */
+export declare const colorMatchedHover: import('lit').CSSResult;
+/**
+ * Focus ring that transitions in smoothly rather than
+ * appearing instantly. The ring spreads from 0px to full
+ * size over 150ms with deceleration easing.
+ */
+export declare const focusRingAnimated: import('lit').CSSResult;
+/**
+ * CSS-only ripple effect on click.
+ * Uses ::after pseudo-element with radial gradient that
+ * expands from center on :active. Requires parent to have
+ * position: relative and overflow: hidden.
+ */
+export declare const rippleEffect: import('lit').CSSResult;
+/** Dot/indicator pulse animation for badges and status indicators. */
+export declare const dotPulseKeyframes: import('lit').CSSResult;
+/** Value change pulse for numbers and metrics. */
+export declare const valueChangePulseKeyframes: import('lit').CSSResult;
+/** Entrance animation with stagger support via --stagger-index custom property. */
+export declare const entranceStagger: import('lit').CSSResult;
+/** Exit animation for removed elements (badges, chips, list items). */
+export declare const exitFadeScaleKeyframes: import('lit').CSSResult;
+/**
+ * Dark glassmorphism card — frosted glass with layered shadows.
+ * The saturate(1.1) adds vibrancy behind the blur.
+ * Use sparingly: max 2-3 glass elements per viewport.
+ */
+export declare const glassCard: import('lit').CSSResult;
+/**
+ * Noise texture overlay for premium dark surfaces.
+ * Inline SVG avoids external file dependencies in Shadow DOM.
+ * The mix-blend-mode: overlay enhances surfaces without washing out.
+ */
+export declare const noiseOverlay: import('lit').CSSResult;
+/**
+ * Liquid fill hover — gradient sweeps up from bottom on hover.
+ * More dramatic than colorMatchedHover, for hero/featured elements.
+ */
+export declare const liquidFillHover: import('lit').CSSResult;
+/**
+ * AI processing glow ring — rotating conic gradient border.
+ * Register --cg-border-angle via CSS.registerProperty() in connectedCallback.
+ */
+export declare const aiGlowRing: import('lit').CSSResult;
+/**
+ * Scroll-driven reveal animation.
+ * Elements fade+slide in as they enter the viewport.
+ * Progressive enhancement — works in Chrome 115+, Firefox 110+, Safari 18+.
+ */
+export declare const scrollReveal: import('lit').CSSResult;
+//# sourceMappingURL=premium.css.d.ts.map

package/dist/styles/premium.css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"premium.css.d.ts","sourceRoot":"","sources":["../../src/styles/premium.css.ts"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,eAAO,MAAM,cAAc,yBAE1B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,yBAM3B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,UAAU,yBAQtB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,yBAI7B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,yBAS7B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,yBAuBxB,CAAC;AAEF,sEAAsE;AACtE,eAAO,MAAM,iBAAiB,yBAK7B,CAAC;AAEF,kDAAkD;AAClD,eAAO,MAAM,yBAAyB,yBAMrC,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,eAAe,yBAW3B,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,sBAAsB,yBAKlC,CAAC;AAMF;;;;GAIG;AACH,eAAO,MAAM,SAAS,yBAQrB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,yBAYxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,yBAsB3B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,UAAU,yBAItB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,yBAWxB,CAAC"}

package/dist/utils/drag-manager.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Module-scope drag coordinator shared between cg-draggable and cg-droppable.
+ *
+ * Pointer-event-based drag/drop works uniformly across mouse, touch, and
+ * stylus and survives modern bundling. Each active drag broadcasts on the
+ * document so any cg-droppable in any subtree can opt in.
+ */
+export type DragType = string;
+export interface DragSession {
+    /** Application-defined payload. cg-droppable receives this on cg-drop. */
+    payload: unknown;
+    /** Type tag — cg-droppable.accepts is matched against this. */
+    type: DragType;
+    /** Source element that initiated the drag. */
+    source: HTMLElement;
+}
+export interface DragMoveDetail extends DragSession {
+    clientX: number;
+    clientY: number;
+}
+export interface DragEndDetail extends DragMoveDetail {
+    /** If true, the drop landed on a registered droppable. */
+    dropped: boolean;
+}
+/** True while a drag is in progress. */
+export declare function isDragging(): boolean;
+/** Start a drag session. Idempotent: a second start while active is ignored. */
+export declare function startDrag(session: DragSession, x: number, y: number): void;
+/** Broadcast a move during the current drag. */
+export declare function moveDrag(x: number, y: number): void;
+/**
+ * End the current drag session. Returns the session that was active so
+ * cg-draggable can fire its own end event with the same payload.
+ */
+export declare function endDrag(x: number, y: number, dropped: boolean): DragSession | null;
+/** Cancel any in-progress drag without firing a drop. Useful for Escape key handling. */
+export declare function cancelDrag(): void;
+/** Inspect the current session without ending it. Returns null when no drag is active. */
+export declare function currentSession(): DragSession | null;
+//# sourceMappingURL=drag-manager.d.ts.map

package/dist/utils/drag-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drag-manager.d.ts","sourceRoot":"","sources":["../../src/utils/drag-manager.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAE9B,MAAM,WAAW,WAAW;IAC1B,0EAA0E;IAC1E,OAAO,EAAE,OAAO,CAAC;IACjB,+DAA+D;IAC/D,IAAI,EAAE,QAAQ,CAAC;IACf,8CAA8C;IAC9C,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,cAAe,SAAQ,WAAW;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAc,SAAQ,cAAc;IACnD,0DAA0D;IAC1D,OAAO,EAAE,OAAO,CAAC;CAClB;AAID,wCAAwC;AACxC,wBAAgB,UAAU,IAAI,OAAO,CAEpC;AAED,gFAAgF;AAChF,wBAAgB,SAAS,CAAC,OAAO,EAAE,WAAW,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAM1E;AAED,gDAAgD;AAChD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAKnD;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,CAQlF;AAED,yFAAyF;AACzF,wBAAgB,UAAU,IAAI,IAAI,CAMjC;AAED,0FAA0F;AAC1F,wBAAgB,cAAc,IAAI,WAAW,GAAG,IAAI,CAEnD"}

package/dist/utils/floating.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Floating positioning utility — used by cg-popover, cg-hover-card, cg-context-menu.
+ * Pure function, no dependencies. Provides collision detection, auto-flip, and shift.
+ */
+export type Placement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
+export type Side = 'top' | 'bottom' | 'left' | 'right';
+export interface Rect {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+export interface ComputePositionOptions {
+    /** Preferred placement. Default: 'bottom' */
+    placement?: Placement;
+    /** Distance between reference and floating element in px. Default: 8 */
+    offset?: number;
+    /** Padding from viewport edges in px. Default: 8 */
+    padding?: number;
+    /** Auto-flip to opposite side if no room. Default: true */
+    flip?: boolean;
+    /** Shift along main axis to keep in viewport. Default: true */
+    shift?: boolean;
+    /** Viewport bounds. Defaults to window innerWidth/innerHeight. */
+    viewport?: Rect;
+}
+export interface ComputePositionResult {
+    x: number;
+    y: number;
+    placement: Placement;
+    arrowX?: number;
+    arrowY?: number;
+}
+/**
+ * Compute the absolute position of a floating element relative to a reference element.
+ */
+export declare function computePosition(reference: Rect, floating: {
+    width: number;
+    height: number;
+}, options?: ComputePositionOptions): ComputePositionResult;
+/**
+ * Convenience wrapper: compute the position of `floating` relative to `reference`,
+ * then apply `top`/`left` styles to the floating element. Returns the raw result
+ * so callers can still read back the final placement (e.g. for arrow alignment).
+ *
+ * Call from within a `requestAnimationFrame` if the floating element was just
+ * shown, so `getBoundingClientRect()` sees its rendered size.
+ */
+export declare function applyFloatingPosition(reference: Element, floating: HTMLElement, options?: ComputePositionOptions): ComputePositionResult;
+/**
+ * Automatically update the position of a floating element when the reference or viewport changes.
+ * Returns a cleanup function.
+ */
+export declare function autoUpdate(reference: HTMLElement, _floating: HTMLElement, update: () => void): () => void;
+//# sourceMappingURL=floating.d.ts.map

package/dist/utils/floating.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floating.d.ts","sourceRoot":"","sources":["../../src/utils/floating.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,SAAS,GACjB,KAAK,GAAG,WAAW,GAAG,SAAS,GAC/B,QAAQ,GAAG,cAAc,GAAG,YAAY,GACxC,MAAM,GAAG,YAAY,GAAG,UAAU,GAClC,OAAO,GAAG,aAAa,GAAG,WAAW,CAAC;AAE1C,MAAM,MAAM,IAAI,GAAG,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;AAEvD,MAAM,WAAW,IAAI;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,sBAAsB;IACrC,6CAA6C;IAC7C,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,wEAAwE;IACxE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,+DAA+D;IAC/D,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,qBAAqB;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,SAAS,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAuBD;;GAEG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,IAAI,EACf,QAAQ,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAC3C,OAAO,GAAE,sBAA2B,GACnC,qBAAqB,CA4CvB;AAyED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,OAAO,EAClB,QAAQ,EAAE,WAAW,EACrB,OAAO,GAAE,sBAA2B,GACnC,qBAAqB,CAWvB;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,SAAS,EAAE,WAAW,EACtB,SAAS,EAAE,WAAW,EACtB,MAAM,EAAE,MAAM,IAAI,GACjB,MAAM,IAAI,CAcZ"}

package/dist/utils/focus-trap.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Focus trap utility — shared by cg-modal, cg-popover, cg-alert-dialog, cg-command, cg-context-menu.
+ * Extracted from the focus trap logic in cg-modal._handleKeydown.
+ */
+/**
+ * Returns all visible, non-disabled, focusable elements within a root.
+ * Walks both shadow DOM and light DOM.
+ */
+export declare function getFocusableElements(root: HTMLElement | ShadowRoot): HTMLElement[];
+export interface FocusTrapOptions {
+    /** Element to focus first when activated. Defaults to first focusable element. */
+    initialFocus?: HTMLElement | null | undefined;
+    /** Return focus to the previously active element on deactivate. Default: true */
+    returnFocus?: boolean | undefined;
+    /** Called when Escape key is pressed. */
+    onEscape?: (() => void) | undefined;
+    /** Whether to handle Escape key. Default: true */
+    handleEscape?: boolean | undefined;
+}
+/**
+ * Manages focus trapping within a root element.
+ * - Activates: captures prior focus, focuses initial element, binds keydown.
+ * - Deactivates: unbinds keydown, optionally returns focus to prior element.
+ * - Handles Tab/Shift+Tab cycling within the trap.
+ * - Optionally handles Escape.
+ */
+export declare class FocusTrap {
+    private _root;
+    private _previousFocus;
+    private _options;
+    private _active;
+    activate(root: HTMLElement, options?: FocusTrapOptions): void;
+    deactivate(): void;
+    isActive(): boolean;
+    private _handleKeydown;
+}
+//# sourceMappingURL=focus-trap.d.ts.map

package/dist/utils/focus-trap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"focus-trap.d.ts","sourceRoot":"","sources":["../../src/utils/focus-trap.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAOH;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,GAAG,WAAW,EAAE,CAgBlF;AAED,MAAM,WAAW,gBAAgB;IAC/B,kFAAkF;IAClF,YAAY,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,CAAC;IAC9C,iFAAiF;IACjF,WAAW,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAClC,yCAAyC;IACzC,QAAQ,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;IACpC,kDAAkD;IAClD,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACpC;AAED;;;;;;GAMG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAA4B;IACzC,OAAO,CAAC,cAAc,CAA4B;IAClD,OAAO,CAAC,QAAQ,CAAwB;IACxC,OAAO,CAAC,OAAO,CAAS;IAExB,QAAQ,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,GAAE,gBAAqB,GAAG,IAAI;IAuBjE,UAAU,IAAI,IAAI;IAclB,QAAQ,IAAI,OAAO;IAInB,OAAO,CAAC,cAAc,CAgCpB;CACH"}

package/dist/utils/lazy.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Lazy custom-element registration.
+ *
+ * Apps often ship every component up front, even when most pages only render
+ * a handful. `lazy(tag, loader)` defers the network cost of a component until
+ * the first time its tag appears in the DOM, using a `MutationObserver` to
+ * watch for insertions. The loader is a dynamic `import()` whose module's
+ * `@customElement` side effect registers the element — the observer
+ * disconnects as soon as the loader starts, so there's no ongoing cost.
+ *
+ * This module is browser-only. It must not be imported from SSR code paths
+ * without a `document`/`MutationObserver` guard.
+ */
+/**
+ * Register a custom element on demand — when the tag first appears in the DOM.
+ * Uses `MutationObserver` to detect insertions and triggers the loader promise.
+ *
+ * @example
+ * ```ts
+ * import { lazy } from '@cognivo/components/lazy';
+ *
+ * // Called once at app init. Component only downloads when used.
+ * lazy('cg-chart', () => import('@cognivo/components/cg-chart'));
+ * ```
+ *
+ * @param tag - The custom element tag name (e.g. `'cg-chart'`).
+ * @param loader - A function that returns a promise resolving to the module.
+ *                 The module's side effect (`customElements.define`) runs on
+ *                 import; the resolved value itself is ignored.
+ */
+export declare function lazy(tag: string, loader: () => Promise<unknown>): void;
+/**
+ * Batch-register multiple components lazily. Thin wrapper around {@link lazy}.
+ *
+ * @example
+ * ```ts
+ * lazyAll({
+ *   'cg-chart': () => import('@cognivo/components/cg-chart'),
+ *   'cg-calendar': () => import('@cognivo/components/cg-calendar'),
+ *   'ai-workflow-builder': () => import('@cognivo/components/ai-workflow-builder'),
+ * });
+ * ```
+ *
+ * @param registry - Map of tag name to loader function.
+ */
+export declare function lazyAll(registry: Record<string, () => Promise<unknown>>): void;
+//# sourceMappingURL=lazy.d.ts.map

package/dist/utils/lazy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazy.d.ts","sourceRoot":"","sources":["../../src/utils/lazy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAyCtE;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC,GAAG,IAAI,CAI9E"}

package/dist/utils/outside-click.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Outside-click helper.
+ *
+ * Used by any component that opens a floating surface (menu, popover, dropdown,
+ * autocomplete, color picker, etc.) and needs to close when the user clicks
+ * outside. Uses `composedPath()` so it works correctly across Shadow DOM
+ * boundaries.
+ *
+ * The listener is attached on the next macrotask (`setTimeout 0`) to make sure
+ * the click that opened the surface does not immediately bubble up and close
+ * it again.
+ *
+ * Dependency-free — no Lit or framework imports allowed.
+ */
+/**
+ * Call `onOutside` when the user clicks outside `host`.
+ *
+ * @param host        The element whose interior should be considered "inside".
+ * @param onOutside   Invoked with the triggering `MouseEvent` on outside click.
+ * @returns           Disposer — cancels the pending attach if not yet attached,
+ *                    otherwise removes the listener.
+ */
+export declare function bindOutsideClick(host: Element, onOutside: (e: MouseEvent) => void): () => void;
+//# sourceMappingURL=outside-click.d.ts.map

package/dist/utils/outside-click.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outside-click.d.ts","sourceRoot":"","sources":["../../src/utils/outside-click.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,OAAO,EACb,SAAS,EAAE,CAAC,CAAC,EAAE,UAAU,KAAK,IAAI,GACjC,MAAM,IAAI,CAgBZ"}

package/dist/utils/roving-index.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Keyboard navigation helper for the roving-tabindex list pattern.
+ *
+ * Used by menu-like components (cg-context-menu, cg-dropdown, cg-split-button,
+ * cg-command, …) that track an "active" item index internally and advance it
+ * with ArrowUp / ArrowDown / Home / End, select with Enter or Space, and
+ * dismiss with Escape.
+ *
+ * Dependency-free — no Lit or framework imports allowed.
+ */
+export interface RovingKeyOptions<T> {
+    /** The full source list of items (including separators / disabled). */
+    items: T[];
+    /**
+     * Current active index.
+     *
+     * IMPORTANT: this index refers to the *selectable* sub-list (items remaining
+     * after `isSkippable` filtering), not the raw `items` array. Every caller in
+     * the Cognivo codebase tracks `_activeIndex` this way, so the return value
+     * is also a selectable-list index.
+     */
+    activeIndex: number;
+    /** Return true if an item should be skipped during navigation. */
+    isSkippable?: (item: T) => boolean;
+    /** Invoked when the user activates the current item (Enter or Space). */
+    onSelect?: (item: T, selectableIndex: number) => void;
+    /** Invoked on Escape. */
+    onEscape?: () => void;
+}
+export interface RovingKeyResult {
+    /** New selectable-list index. Unchanged if the key was not handled. */
+    index: number;
+    /** True if the key was handled (caller should `e.preventDefault()`). */
+    handled: boolean;
+}
+/**
+ * Handle a keyboard event for a roving-tabindex list pattern.
+ *
+ * The caller is responsible for:
+ *  - Updating `_activeIndex` with `result.index`.
+ *  - Calling `e.preventDefault()` when `result.handled === true`.
+ *
+ * Handled keys:
+ *  - `ArrowDown` — advance by 1 (wraps).
+ *  - `ArrowUp`   — recede by 1 (wraps).
+ *  - `Home`      — jump to first selectable item.
+ *  - `End`       — jump to last selectable item.
+ *  - `Enter` / `Space` — invoke `onSelect` with the active selectable item.
+ *  - `Escape`    — invoke `onEscape`.
+ *
+ * Any other key returns `{ index: activeIndex, handled: false }`.
+ */
+export declare function handleRovingKey<T>(e: KeyboardEvent, opts: RovingKeyOptions<T>): RovingKeyResult;
+//# sourceMappingURL=roving-index.d.ts.map

package/dist/utils/roving-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roving-index.d.ts","sourceRoot":"","sources":["../../src/utils/roving-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,uEAAuE;IACvE,KAAK,EAAE,CAAC,EAAE,CAAC;IACX;;;;;;;OAOG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,kEAAkE;IAClE,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;IACnC,yEAAyE;IACzE,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,eAAe,EAAE,MAAM,KAAK,IAAI,CAAC;IACtD,yBAAyB;IACzB,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,CAAC,EAAE,aAAa,EAChB,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,GACxB,eAAe,CAsCjB"}

package/dist/utils/sanitize.d.ts

@@ -0,0 +1,7 @@
+/**
+ * HTML sanitizer for XSS prevention.
+ * Strips dangerous tags, event handler attributes, and dangerous URL protocols
+ * from HTML strings before innerHTML assignment.
+ */
+export declare function sanitizeHTML(html: string): string;
+//# sourceMappingURL=sanitize.d.ts.map

package/dist/utils/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/utils/sanitize.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAKjD"}

package/dist/utils/text-scramble.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Premium text scramble/decode animation engine.
+ *
+ * Inspired by Linear app, GSAP ScrambleText, and award-winning Awwwards
+ * implementations. Uses a sweep-front approach where characters resolve
+ * left-to-right with a configurable wave width, scramble refresh rate,
+ * and reveal delay.
+ *
+ * Design decisions:
+ * - Resolved characters SNAP (no fade/scale) -- the binary state change
+ *   is what makes it feel like a real decode, not a generic animation.
+ * - Scrambled characters render at reduced opacity so resolved text pops.
+ * - The reveal front eases in (starts slow, accelerates) for polish.
+ * - Character refresh happens every ~2-3 frames, not every frame --
+ *   too fast looks glitchy, too slow looks laggy.
+ *
+ * @example
+ * ```ts
+ * import { createTextScramble } from '../utils/text-scramble.js';
+ *
+ * const scramble = createTextScramble({
+ *   text: 'Hello World',
+ *   onUpdate: (html) => { this.displayHtml = html; this.requestUpdate(); },
+ *   onComplete: () => { console.log('done'); },
+ * });
+ *
+ * scramble.start();
+ * // scramble.cancel(); // to abort
+ * ```
+ */
+export declare const CHAR_SETS: {
+    /** Clean alphanumeric -- general purpose, Linear-style */
+    readonly alphanumeric: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    /** Hacker/terminal aesthetic (underscores add breathing room) */
+    readonly terminal: "!<>-_\\/[]{}=+*^?#________";
+    /** Binary / matrix / AI theme */
+    readonly binary: "01";
+    /** Minimal geometric symbols */
+    readonly minimal: ".-+*=~<>/";
+    /** Unicode block elements (density-based) */
+    readonly blocks: "░▒▓█";
+    /** Uppercase only -- bold, headline feel */
+    readonly uppercase: "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    /** Katakana -- cyberpunk / matrix rain */
+    readonly katakana: "アイウエオカキクケコサシスセソタチツテトナニヌネノハヒフヘホマミムメモヤユヨラリルレロワヲン";
+};
+export type CharSetPreset = keyof typeof CHAR_SETS;
+export interface TextScrambleOptions {
+    /** The target text to decode/reveal. */
+    text: string;
+    /**
+     * Called on each animation frame with the current display string.
+     * The string contains `<span>` wrappers:
+     * - resolved chars: `<span class="resolved">X</span>`
+     * - scrambled chars: `<span class="scrambled">X</span>`
+     *
+     * This lets the consumer style resolved vs scrambled differently
+     * (e.g. opacity, color) via CSS.
+     */
+    onUpdate: (html: string) => void;
+    /** Called when the full text is resolved. */
+    onComplete?: () => void;
+    /**
+     * Character set for scrambled characters.
+     * Pass a preset name or a custom string.
+     * @default 'alphanumeric'
+     */
+    chars?: CharSetPreset | string;
+    /**
+     * Total animation duration in ms.
+     * @default 800
+     */
+    duration?: number;
+    /**
+     * Fraction of total duration (0-1) to keep the entire text scrambled
+     * before the resolve sweep begins. Creates the "deliberate pause"
+     * that makes premium scrambles feel intentional.
+     * @default 0.2
+     */
+    revealDelay?: number;
+    /**
+     * Number of characters in the "wave front" that are actively
+     * transitioning. Higher = softer sweep, lower = sharper edge.
+     * @default 3
+     */
+    waveFrontWidth?: number;
+    /**
+     * How often (in frames) scrambled characters refresh.
+     * 1 = every frame (60 changes/sec, glitchy).
+     * 2 = every other frame (30 changes/sec, smooth).
+     * 3 = every 3rd frame (20 changes/sec, deliberate).
+     * @default 2
+     */
+    scrambleFrameInterval?: number;
+    /**
+     * Easing function for the reveal front position.
+     * Maps progress (0-1) to position (0-1).
+     * Default is ease-in (starts slow, accelerates).
+     * @default easeInQuad
+     */
+    easing?: (t: number) => number;
+    /**
+     * Whether to preserve spaces (don't scramble them).
+     * @default true
+     */
+    preserveSpaces?: boolean;
+    /**
+     * Direction of the reveal sweep.
+     * @default 'ltr'
+     */
+    direction?: 'ltr' | 'rtl' | 'center';
+}
+/** Quadratic ease-in: starts slow, accelerates. */
+export declare function easeInQuad(t: number): number;
+/** Quadratic ease-out: starts fast, decelerates. */
+export declare function easeOutQuad(t: number): number;
+/** Cubic ease-in-out: smooth start and end. */
+export declare function easeInOutCubic(t: number): number;
+export interface TextScrambleController {
+    /** Start the animation. */
+    start: () => void;
+    /** Cancel the animation immediately. */
+    cancel: () => void;
+    /** Resolve all characters instantly and fire onComplete. */
+    finish: () => void;
+}
+/**
+ * Create a text scramble animation controller.
+ *
+ * Returns an object with `start()`, `cancel()`, and `finish()` methods.
+ * The animation uses `requestAnimationFrame` for 60fps updates and calls
+ * `onUpdate` with an HTML string on each visual frame.
+ */
+export declare function createTextScramble(options: TextScrambleOptions): TextScrambleController;
+export interface TextScramblePlainOptions extends Omit<TextScrambleOptions, 'onUpdate'> {
+    /** Called with plain text (no HTML) on each frame. */
+    onUpdate: (text: string) => void;
+}
+/**
+ * Same as `createTextScramble` but emits plain text instead of HTML.
+ * Useful when you don't need per-character styling.
+ */
+export declare function createTextScramblePlain(options: TextScramblePlainOptions): TextScrambleController;
+//# sourceMappingURL=text-scramble.d.ts.map

package/dist/utils/text-scramble.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-scramble.d.ts","sourceRoot":"","sources":["../../src/utils/text-scramble.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAMH,eAAO,MAAM,SAAS;IACpB,0DAA0D;;IAI1D,iEAAiE;;IAGjE,iCAAiC;;IAGjC,gCAAgC;;IAGhC,6CAA6C;;IAG7C,4CAA4C;;IAG5C,0CAA0C;;CAElC,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,MAAM,OAAO,SAAS,CAAC;AAMnD,MAAM,WAAW,mBAAmB;IAClC,wCAAwC;IACxC,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;;;OAQG;IACH,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAEjC,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;IAExB;;;;OAIG;IACH,KAAK,CAAC,EAAE,aAAa,GAAG,MAAM,CAAC;IAE/B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;;;OAMG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAE/B;;;;;OAKG;IACH,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAE/B;;;OAGG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IAEzB;;;OAGG;IACH,SAAS,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,QAAQ,CAAC;CACtC;AAMD,mDAAmD;AACnD,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED,oDAAoD;AACpD,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED,+CAA+C;AAC/C,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEhD;AA4CD,MAAM,WAAW,sBAAsB;IACrC,2BAA2B;IAC3B,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,wCAAwC;IACxC,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,4DAA4D;IAC5D,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,mBAAmB,GAC3B,sBAAsB,CA0LxB;AAMD,MAAM,WAAW,wBACf,SAAQ,IAAI,CAAC,mBAAmB,EAAE,UAAU,CAAC;IAC7C,sDAAsD;IACtD,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,wBAAwB,GAChC,sBAAsB,CAmIxB"}