@zeyos/zx 2.1.0 → 2.2.1

package/dist/types/core/i18n.d.ts

@@ -0,0 +1,35 @@
+/** @typedef {(key: string) => string|null|undefined} Translator */
+export type Translator = (key: string) => string | null | undefined;
+/**
+ * Installs the host application's translation function, or clears it with null.
+ * @param {Translator|null} fn Translator function.
+ * @returns {void}
+ */
+export declare function setTranslator(fn: Translator | null): void;
+/**
+ * Sets the active language identifier.
+ * @param {string} lang Language identifier such as "en" or "de-AT".
+ * @returns {void}
+ */
+export declare function setLanguage(lang: string): void;
+/**
+ * Returns the active language identifier.
+ * @returns {string}
+ */
+export declare function getLanguage(): string;
+/**
+ * Translates a key through the injected host translator and interpolates arguments.
+ * @param {string} key Translation key.
+ * @param {unknown[]|Record<string, unknown>|string|number} [args] Interpolation arguments.
+ * @returns {string}
+ */
+export declare function translate(key: string, args?: unknown[] | Record<string, unknown> | string | number): string;
+/**
+ * Replaces one-based numeric placeholders and legacy percent-delimited placeholders.
+ * Arrays replace `%1`, `%2`, and legacy placeholders in encounter order; objects replace
+ * named placeholders such as `%name%`.
+ * @param {string} str Template string.
+ * @param {unknown[]|Record<string, unknown>|string|number} [args] Replacement values.
+ * @returns {string}
+ */
+export declare function printf(str: string, args?: unknown[] | Record<string, unknown> | string | number): string;

package/dist/types/core/icons.d.ts

@@ -0,0 +1,137 @@
+/**
+ * The icon layer. Two renderers sit behind one `icon()` call:
+ *
+ * - **built-in** (default) — the inline SVG glyphs below, no network, no stylesheet, no font.
+ * - **Font Awesome** — `<i>` elements carrying Font Awesome classes, after an application opts in
+ *   with `useFontAwesome()` or `loadFontAwesome(kit)`. Zx never loads a kit by itself.
+ *
+ * Both renderers put `zx-icon` on the element, so component CSS can style either.
+ * @module zx/core/icons
+ */
+export type IconOptions = {
+    /**
+     * Rendered width and height.
+     */
+    size?: number | string;
+    /**
+     * Accessible label; null marks the icon decorative.
+     */
+    label?: string | null;
+    /**
+     * Extra class names added to the element.
+     */
+    class?: string | string[];
+    /**
+     * Font Awesome style for this icon only (`'solid'`, `'duotone'`, …).
+     */
+    style?: string;
+    /**
+     * Font Awesome family for this icon only (`'classic'`, `'sharp'`, …).
+     */
+    family?: string;
+    /**
+     * Adds Font Awesome's `fa-fw` for column-aligned glyphs.
+     */
+    fixedWidth?: boolean;
+};
+/**
+ * @typedef {Object} IconOptions
+ * @property {number|string} [size=16] Rendered width and height.
+ * @property {string|null} [label=null] Accessible label; null marks the icon decorative.
+ * @property {string|string[]} [class] Extra class names added to the element.
+ * @property {string} [style] Font Awesome style for this icon only (`'solid'`, `'duotone'`, …).
+ * @property {string} [family] Font Awesome family for this icon only (`'classic'`, `'sharp'`, …).
+ * @property {boolean} [fixedWidth] Adds Font Awesome's `fa-fw` for column-aligned glyphs.
+ */
+/**
+ * Icon glyphs from Font Awesome Free 6 (solid, plus `square` from regular), fontawesome.com,
+ * licensed CC BY 4.0 (https://fontawesome.com/license/free). Path data is embedded unmodified so
+ * the library carries no webfont, stylesheet, or package dependency. Each entry is
+ * `[viewBox, path]`; Font Awesome glyphs are filled (not stroked) and use per-glyph 512-unit view
+ * boxes — outlines such as `square` are a filled path with a counter-wound hole.
+ * Extend the set with `registerIcons()`; read every available name with `iconNames()`.
+ * @type {Readonly<Record<string, [string, string]>>}
+ */
+export declare const icons: Readonly<Record<string, [string, string]>>;
+export type IconConfig = {
+    /**
+     * Renderer used for bare icon names.
+     */
+    provider: 'builtin' | 'fontawesome';
+    /**
+     * Default Font Awesome style (`'solid'`, `'regular'`, `'duotone'`, …).
+     */
+    style: string;
+    /**
+     * Default Font Awesome family (`'classic'`, `'sharp'`, …).
+     */
+    family: string;
+    /**
+     * Whether Font Awesome icons get `fa-fw` by default.
+     */
+    fixedWidth: boolean;
+    /**
+     * Kit token or URL passed to the last `loadFontAwesome()` call.
+     */
+    kit: string | null;
+};
+/**
+ * Reads the active icon configuration.
+ * @returns {IconConfig} A copy — mutating it does not change the configuration.
+ */
+export declare function getIconConfig(): IconConfig;
+/**
+ * Sets how bare icon names are rendered. Explicitly prefixed names (`'fa:user'`,
+ * `'builtin:check'`) and literal class lists (`'fa-solid fa-user'`) always ignore this.
+ * @param {Partial<IconConfig>} options Values to change.
+ * @returns {IconConfig} The configuration after the change.
+ */
+export declare function configureIcons(options?: Partial<IconConfig>): IconConfig;
+/**
+ * Switches bare icon names to Font Awesome. Use this when the kit, or a self-hosted Font Awesome
+ * stylesheet, is already on the page; use `loadFontAwesome()` to inject a kit as well.
+ * @param {Partial<Omit<IconConfig, 'provider'>>} [options={}] Default style, family, modifiers.
+ * @returns {IconConfig} The configuration after the change.
+ */
+export declare function useFontAwesome(options?: Partial<Omit<IconConfig, 'provider'>>): IconConfig;
+/**
+ * Switches bare icon names back to the inline SVG glyphs bundled with Zx.
+ * @returns {IconConfig} The configuration after the change.
+ */
+export declare function useBuiltinIcons(): IconConfig;
+/**
+ * Loads a Font Awesome kit and renders bare icon names with it. The script is injected once per
+ * URL; a kit the page already embeds is adopted instead of loaded again.
+ * @param {string|(Partial<Omit<IconConfig, 'provider'>> & {kit: string, activate?: boolean})} options
+ *   Kit token/URL, or an options object naming one.
+ * @returns {Promise<IconConfig>} Resolves with the configuration once the kit has loaded.
+ */
+export declare function loadFontAwesome(options: string | (Partial<Omit<IconConfig, 'provider'>> & {
+    kit: string;
+    activate?: boolean;
+})): Promise<IconConfig>;
+/**
+ * Adds inline SVG glyphs to the built-in set, or replaces existing ones. Entries use the same
+ * `[viewBox, path]` shape as `icons`.
+ * @param {Record<string, [string, string]>} glyphs Glyphs keyed by icon name.
+ * @returns {void}
+ */
+export declare function registerIcons(glyphs: Record<string, [string, string]>): void;
+/**
+ * Lists every inline SVG glyph name available, built-in and registered.
+ * @returns {string[]} Sorted icon names.
+ */
+export declare function iconNames(): string[];
+/**
+ * Creates an icon element.
+ *
+ * Bare names (`'check'`) render through the active provider: the bundled inline SVG set by
+ * default, or Font Awesome after `useFontAwesome()` / `loadFontAwesome()`. A name can also select
+ * its renderer itself — `'fa:user'`, `'duotone:user'`, `'kit:zeyos-notes'`, `'builtin:check'`, or
+ * a literal Font Awesome class list such as `'fa-solid fa-user'`.
+ *
+ * @param {string} name Icon name or spec.
+ * @param {IconOptions} [options={}] Display and accessibility options.
+ * @returns {SVGSVGElement|HTMLElement} An `<svg>` for inline glyphs, an `<i>` for Font Awesome.
+ */
+export declare function icon(name: string, options?: IconOptions): SVGSVGElement | HTMLElement;

package/dist/types/core/keyboard.d.ts

@@ -0,0 +1,72 @@
+export type RovingOptions = {
+    /**
+     * Arrow-key axis.
+     */
+    orientation?: 'vertical' | 'horizontal';
+    /**
+     * Whether navigation wraps at either end.
+     */
+    wrap?: boolean;
+};
+export type FocusTrapController = {
+    /**
+     * Activate the focus trap.
+     */
+    activate: () => void;
+    /**
+     * Deactivate the focus trap and restore focus.
+     */
+    deactivate: () => void;
+};
+export type RovingController = {
+    /**
+     * Focus the first item.
+     */
+    focusFirst: () => void;
+    /**
+     * Focus the last item.
+     */
+    focusLast: () => void;
+    /**
+     * Remove behavior and restore tabindex values.
+     */
+    destroy: () => void;
+};
+/**
+ * @typedef {Object} RovingOptions
+ * @property {'vertical'|'horizontal'} [orientation='vertical'] Arrow-key axis.
+ * @property {boolean} [wrap=true] Whether navigation wraps at either end.
+ */
+/**
+ * @typedef {Object} FocusTrapController
+ * @property {() => void} activate Activate the focus trap.
+ * @property {() => void} deactivate Deactivate the focus trap and restore focus.
+ */
+/**
+ * @typedef {Object} RovingController
+ * @property {() => void} focusFirst Focus the first item.
+ * @property {() => void} focusLast Focus the last item.
+ * @property {() => void} destroy Remove behavior and restore tabindex values.
+ */
+/**
+ * Creates a focus trap that cycles Tab focus within a container while active.
+ * @param {Element} container Focus boundary.
+ * @returns {FocusTrapController}
+ */
+export declare function focusTrap(container: Element): FocusTrapController;
+/**
+ * Applies the ARIA roving-tabindex keyboard pattern to matching descendants.
+ * @param {Element} container Event and query container.
+ * @param {string} itemSelector Selector for roving items.
+ * @param {RovingOptions} [options={}] Behavior options.
+ * @returns {RovingController}
+ */
+export declare function rovingTabindex(container: Element, itemSelector: string, { orientation, wrap }?: RovingOptions): RovingController;
+/**
+ * Creates a 500 ms buffered, case-insensitive first-letter typeahead handler.
+ * @template T
+ * @param {() => T[]} getItems Returns current candidate items.
+ * @param {(item: T, index: number) => void} onMatch Called for the first prefix match.
+ * @returns {(event: KeyboardEvent|string) => void}
+ */
+export declare function typeahead<T>(getItems: () => T[], onMatch: (item: T, index: number) => void): (event: KeyboardEvent | string) => void;

package/dist/types/core/position.d.ts

@@ -0,0 +1,45 @@
+export type PositionOptions = {
+    placement?: 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end' | 'bottom' | 'top';
+    /**
+     * Gap between anchor and floating element.
+     */
+    offset?: number;
+    /**
+     * Flip vertically when the preferred side overflows.
+     */
+    flip?: boolean;
+    /**
+     * Set the floating element's minimum width to the anchor width.
+     */
+    matchWidth?: boolean;
+};
+export type PositionController = {
+    /**
+     * Recompute coordinates and matched width.
+     */
+    update: () => void;
+    /**
+     * Hide and clean up positioning resources.
+     */
+    destroy: () => void;
+};
+/**
+ * @typedef {Object} PositionOptions
+ * @property {'bottom-start'|'bottom-end'|'top-start'|'top-end'|'bottom'|'top'} [placement='bottom-start']
+ * @property {number} [offset=4] Gap between anchor and floating element.
+ * @property {boolean} [flip=true] Flip vertically when the preferred side overflows.
+ * @property {boolean} [matchWidth=false] Set the floating element's minimum width to the anchor width.
+ */
+/**
+ * @typedef {Object} PositionController
+ * @property {() => void} update Recompute coordinates and matched width.
+ * @property {() => void} destroy Hide and clean up positioning resources.
+ */
+/**
+ * Anchors and opens a manual popover, using CSS anchor positioning when available.
+ * @param {Element} anchor Anchor element.
+ * @param {HTMLElement} floating Floating popover element.
+ * @param {PositionOptions} [options={}] Positioning behavior.
+ * @returns {PositionController}
+ */
+export declare function position(anchor: Element, floating: HTMLElement, options?: PositionOptions): PositionController;

package/dist/types/core/storage.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @typedef {Object} StorageOptions
+ * @property {'local'|'session'} [area='local'] Backing Web Storage area.
+ */
+export type StorageOptions = {
+    /**
+     * Backing Web Storage area.
+     */
+    area?: 'local' | 'session';
+};
+export type NamespacedStorage = {
+    /**
+     * Reads and decodes a value.
+     */
+    get: (key: string, fallback?: any) => any;
+    /**
+     * Encodes and writes a value.
+     */
+    set: (key: string, value: unknown) => void;
+    /**
+     * Deletes a single key.
+     */
+    remove: (key: string) => void;
+    /**
+     * Lists the namespace's keys without their prefix.
+     */
+    keys: () => string[];
+    /**
+     * Deletes every key in the namespace, leaving other namespaces alone.
+     */
+    clear: () => void;
+};
+/**
+ * Creates a namespaced, JSON-encoded view of `localStorage` or `sessionStorage`.
+ *
+ * Every key is stored as `zx:<namespace>:<key>`, so several features can share one origin without
+ * colliding, and `clear()` only touches the namespace it belongs to. When the storage area is
+ * unavailable or refuses a write — private browsing, a full quota, cookies disabled — the view
+ * transparently falls back to an in-memory map that lives as long as the page, so callers never
+ * need a try/catch and never see an exception.
+ *
+ * @param {string} namespace Namespace segment, typically an application or feature name.
+ * @param {StorageOptions} [options={}] Area selection.
+ * @returns {NamespacedStorage}
+ */
+export declare function storage(namespace: string, options?: StorageOptions): NamespacedStorage;

package/dist/types/core/util.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Returns a debounced wrapper that runs after calls have stopped for the delay.
+ * @template {(...args: any[]) => any} T
+ * @param {T} fn Function to debounce.
+ * @param {number} ms Delay in milliseconds.
+ * @returns {(...args: Parameters<T>) => void}
+ */
+export declare function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): (...args: Parameters<T>) => void;
+export type ThrottleOptions = {
+    /**
+     * Whether the first call in a window runs immediately.
+     */
+    leading?: boolean;
+    /**
+     * Whether a call made during a window runs when it closes.
+     */
+    trailing?: boolean;
+};
+/**
+ * @typedef {Object} ThrottleOptions
+ * @property {boolean} [leading=true] Whether the first call in a window runs immediately.
+ * @property {boolean} [trailing=true] Whether a call made during a window runs when it closes.
+ */
+/**
+ * Returns a throttled wrapper that runs at most once per interval, on the leading edge, the
+ * trailing edge, or both. The trailing call replays the most recent arguments and context.
+ * @template {(...args: any[]) => any} T
+ * @param {T} fn Function to throttle.
+ * @param {number} ms Interval in milliseconds.
+ * @param {ThrottleOptions} [options={}] Edge behaviour.
+ * @returns {(...args: Parameters<T>) => void}
+ */
+export declare function throttle<T extends (...args: any[]) => any>(fn: T, ms: number, { leading, trailing }?: ThrottleOptions): (...args: Parameters<T>) => void;
+/**
+ * Creates a process-unique identifier suitable for DOM IDs and CSS names.
+ * @param {string} [prefix='zx'] Identifier prefix.
+ * @returns {string}
+ */
+export declare function uid(prefix?: string): string;
+/**
+ * Recursively merges plain objects without mutating either input.
+ * Arrays and other values are replaced rather than merged.
+ * @template T
+ * @template U
+ * @param {T} a Base value.
+ * @param {U} b Overriding value.
+ * @returns {T & U}
+ */
+export declare function deepMerge<T, U>(a: T, b: U): T & U;
+/**
+ * Reports whether a value is a DOM Element, including elements from another realm.
+ * @param {unknown} value Value to inspect.
+ * @returns {value is Element}
+ */
+export declare function isElement(value: unknown): value is Element;
+/**
+ * Restricts a number to an inclusive range.
+ * @param {number} n Value to restrict.
+ * @param {number} min Minimum value.
+ * @param {number} max Maximum value.
+ * @returns {number}
+ */
+export declare function clamp(n: number, min: number, max: number): number;
+/**
+ * Normalizes a nullable, scalar, iterable, or array value to a new array.
+ * @template T
+ * @param {T|Iterable<T>|ArrayLike<T>|null|undefined} value Value to normalize.
+ * @returns {T[]}
+ */
+export declare function toArray<T>(value: T | Iterable<T> | ArrayLike<T> | null | undefined): T[];
+export type KeySelector<T> = string | ((item: T) => unknown);
+export type SortKey<T> = KeySelector<T> | {
+    key: KeySelector<T>;
+    dir?: 'asc' | 'desc';
+};
+/**
+ * @template T
+ * @typedef {string|((item: T) => unknown)} KeySelector A property name or an accessor function.
+ */
+/**
+ * @template T
+ * @typedef {KeySelector<T>|{key: KeySelector<T>, dir?: 'asc'|'desc'}} SortKey
+ * A property name (prefix with `-` to sort descending), an accessor, or an explicit direction.
+ */
+/**
+ * Groups items into a plain object of arrays, keyed by a property or accessor and ordered by first
+ * appearance.
+ * @template T
+ * @param {Iterable<T>|ArrayLike<T>|null|undefined} items Items to group.
+ * @param {KeySelector<T>} key Property name or accessor returning the group key.
+ * @returns {Record<string, T[]>}
+ */
+export declare function groupBy<T>(items: Iterable<T> | ArrayLike<T> | null | undefined, key: KeySelector<T>): Record<string, T[]>;
+/**
+ * Sorts items by one or more keys into a NEW array, leaving the input untouched. Strings compare
+ * with `localeCompare` (digit runs compare numerically), numbers, booleans, and dates compare by
+ * value, and null, undefined, and NaN always sort last regardless of direction.
+ * @template T
+ * @param {Iterable<T>|ArrayLike<T>|null|undefined} items Items to sort.
+ * @param {...SortKey<T>} keys Sort keys applied in order.
+ * @returns {T[]}
+ */
+export declare function sortBy<T>(items: Iterable<T> | ArrayLike<T> | null | undefined, ...keys: SortKey<T>[]): T[];
+/**
+ * Removes duplicates, keeping the first occurrence, and returns a new array.
+ * @template T
+ * @param {Iterable<T>|ArrayLike<T>|null|undefined} items Items to filter.
+ * @param {KeySelector<T>} [key] Property name or accessor; the item itself when omitted.
+ * @returns {T[]}
+ */
+export declare function uniqueBy<T>(items: Iterable<T> | ArrayLike<T> | null | undefined, key?: KeySelector<T>): T[];
+/**
+ * Escapes regular-expression metacharacters so a value can be used as a literal pattern.
+ * @param {unknown} value Value to escape.
+ * @returns {string}
+ */
+export declare function escapeRegExp(value: unknown): string;

package/dist/types/elements/define.d.ts

@@ -0,0 +1,73 @@
+import { INVALID_ATTRIBUTE } from './reflect.js';
+export type AttributeType = 'string' | 'number' | 'boolean' | 'json';
+export type ElementAttribute = {
+    /**
+     * Attribute representation.
+     */
+    type?: AttributeType;
+    /**
+     * Component option name; null keeps the value on the host only.
+     */
+    option?: string | null;
+    /**
+     * Host property name; defaults to camel-cased attribute name.
+     */
+    property?: string;
+    /**
+     * Property value used while the attribute is absent.
+     */
+    default?: unknown;
+    /**
+     * Pass the default to the component during initial creation.
+     */
+    always?: boolean;
+    /**
+     * Recreate the component when this value changes.
+     */
+    rebuild?: boolean;
+    /**
+     * Value adapter.
+     */
+    normalize?: (value: unknown, host: HTMLElement) => unknown;
+    /**
+     * Property serializer override.
+     */
+    serialize?: (value: unknown, host: HTMLElement) => string | null | typeof INVALID_ATTRIBUTE;
+    /**
+     * Live component setter.
+     */
+    set?: (component: InstanceType<typeof import('../core/component.js').Component>, value: any, host: HTMLElement) => void;
+    /**
+     * Live component getter.
+     */
+    get?: (component: InstanceType<typeof import('../core/component.js').Component>, host: HTMLElement) => unknown;
+};
+export type ElementAttributeMap = Record<string, AttributeType | ElementAttribute>;
+export type ElementWrapperOptions = {
+    /**
+     * Whether the element participates in native forms.
+     */
+    formAssociated?: boolean;
+    /**
+     * Reflected attribute definitions.
+     */
+    attrs?: ElementAttributeMap;
+};
+/**
+ * Creates a light-DOM custom-element class backed by a Zx component.
+ * Groupbox and Dialog wrappers adopt their host's initial children as component content;
+ * other wrappers leave unrelated host children untouched and append their component root.
+ *
+ * @param {typeof import('../core/component.js').Component} ComponentClass Component constructor.
+ * @param {ElementWrapperOptions} [wrapperOptions={}] Wrapper behavior.
+ * @returns {typeof HTMLElement} Custom-element constructor.
+ */
+export declare function elementFor(ComponentClass: typeof import('../core/component.js').Component, { formAssociated, attrs }?: ElementWrapperOptions): typeof HTMLElement;
+/**
+ * Registers the supported Zx custom elements. Repeated calls and pre-registered names are safe.
+ * This function is deliberately not called by the module.
+ *
+ * @param {string} [prefix='zx'] Custom-element name prefix.
+ * @returns {void}
+ */
+export declare function defineElements(prefix?: string): void;

package/dist/types/elements/reflect.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Attribute value types supported by the custom-element wrappers.
+ * @typedef {'string'|'number'|'boolean'|'json'} AttributeType
+ */
+export type AttributeType = 'string' | 'number' | 'boolean' | 'json';
+/** Sentinel returned when an attribute value cannot be safely applied. */
+export declare const INVALID_ATTRIBUTE: unique symbol;
+/**
+ * Coerces a serialized attribute into a component option value.
+ * Missing boolean attributes are false; other missing attributes are undefined.
+ *
+ * @param {string|null} value Attribute text, or null when the attribute is absent.
+ * @param {AttributeType} [type='string'] Requested option type.
+ * @param {(message: string) => void} [warn=console.warn] Invalid-value reporter.
+ * @returns {string|number|boolean|unknown|undefined|typeof INVALID_ATTRIBUTE}
+ */
+export declare function coerceAttribute(value: string | null, type?: AttributeType, warn?: (message: string) => void): string | number | boolean | unknown | undefined | typeof INVALID_ATTRIBUTE;
+/**
+ * Serializes a property value for attribute reflection.
+ * A null return value means the corresponding attribute should be removed.
+ *
+ * @param {unknown} value Property value.
+ * @param {AttributeType} [type='string'] Attribute representation.
+ * @param {(message: string) => void} [warn=console.warn] Invalid-value reporter.
+ * @returns {string|null|typeof INVALID_ATTRIBUTE}
+ */
+export declare function serializeAttribute(value: unknown, type?: AttributeType, warn?: (message: string) => void): string | null | typeof INVALID_ATTRIBUTE;

package/dist/types/index.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Zx public API.
+ * @module zx
+ */
+/**
+ * Registers every component-backed Field adapter. Calling this function repeatedly is safe.
+ * @returns {void}
+ */
+export declare function registerFieldAdapters(): void;
+export { Component } from './core/component.js';
+export { h, htmlEscape, resolveElement, highlightMatch } from './core/dom.js';
+export { position } from './core/position.js';
+export { breakpoints, breakpointOf, matchBreakpoint, onBreakpoint } from './core/breakpoint.js';
+export { Http, zeyosService, parseResult } from './core/http.js';
+export { setTranslator, setLanguage, getLanguage, translate, printf } from './core/i18n.js';
+export { focusTrap, rovingTabindex, typeahead } from './core/keyboard.js';
+export { formatDate, parseDate, clampDate, isSameDay, addDays, addMonths, getWeekStart } from './core/date.js';
+export { icon, icons, iconNames, registerIcons, configureIcons, getIconConfig, useFontAwesome, useBuiltinIcons, loadFontAwesome } from './core/icons.js';
+export { faStyles, faFamilies, faNames, faIconClasses, parseIconSpec, kitUrl, loadFontAwesomeKit } from './core/fontawesome.js';
+export { debounce, throttle, uid, deepMerge, isElement, clamp, toArray, groupBy, sortBy, uniqueBy, escapeRegExp } from './core/util.js';
+export { formatNumber, formatCurrency, formatPercent, formatFileSize, formatRelativeTime } from './core/format.js';
+export { storage } from './core/storage.js';
+export { toCsv, downloadBlob, copyToClipboard } from './core/export.js';
+export { defineElements } from './elements/define.js';
+export { button, buttonGroup } from './components/button/button.js';
+export { badge, badgeGroup } from './components/badge/badge.js';
+export { CheckButton } from './components/check-button/check-button.js';
+export { emptyState } from './components/empty-state/empty-state.js';
+export { spinner } from './components/loading/spinner.js';
+export { ProgressBar } from './components/loading/progress-bar.js';
+export { InlineLoading } from './components/loading/inline-loading.js';
+export { skeleton, skeletonText, skeletonTable } from './components/skeleton/skeleton.js';
+export { stack, grid, aspect } from './components/layout/layout.js';
+export { truncate, isTruncated } from './components/truncate/truncate.js';
+export { copyButton } from './components/copy/copy-button.js';
+export { CopyInput } from './components/copy/copy-input.js';
+export { Toolbar } from './components/toolbar/toolbar.js';
+export { Toggle } from './components/toggle/toggle.js';
+export { Groupbox } from './components/groupbox/groupbox.js';
+export { Panel } from './components/panel/panel.js';
+export { MasterPanel } from './components/master-panel/master-panel.js';
+export { SplitView, clampSize, resolveSize, snapSize } from './components/split-view/split-view.js';
+export { Tabbox } from './components/tabbox/tabbox.js';
+export { NavigationBar } from './components/navigation-bar/navigation-bar.js';
+export { Stepper } from './components/stepper/stepper.js';
+export { Breadcrumb } from './components/breadcrumb/breadcrumb.js';
+export { Pagination, paginationRange } from './components/pagination/pagination.js';
+export { Search } from './components/search/search.js';
+export { Message } from './components/message/message.js';
+export { Modal } from './components/modal/modal.js';
+export { Dialog } from './components/dialog/dialog.js';
+export { Dropdown } from './components/dropdown/dropdown.js';
+export { Tooltip, tooltip, describe } from './components/tooltip/tooltip.js';
+export { MenuButton } from './components/menu-button/menu-button.js';
+export { ContextMenu } from './components/context-menu/context-menu.js';
+export { Select } from './components/select/select.js';
+export { Checklist } from './components/checklist/checklist.js';
+export { TagPicker } from './components/tag-picker/tag-picker.js';
+export { NumberField, parseNumber, snapNumber } from './components/number-field/number-field.js';
+export { Rating } from './components/rating/rating.js';
+export { Slider, stepPrecision } from './components/slider/slider.js';
+export { Permission } from './components/permission/permission.js';
+export { DatePicker } from './components/date-picker/date-picker.js';
+export { MonthPicker } from './components/date-picker/month-picker.js';
+export { TimePicker } from './components/date-picker/time-picker.js';
+export { Datebox, DateTimeBox } from './components/datebox/datebox.js';
+export { DateRangePicker, clampRange, defaultDateRangePresets, normalizeRange, rangeNights, rangeStateOf } from './components/date-picker/date-range-picker.js';
+export { DateRangeBox, formatRangeText, parseRangeText } from './components/datebox/date-range-box.js';
+export { Timebox, splitTime, joinTime } from './components/timebox/timebox.js';
+export { Table } from './components/table/table.js';
+export { TreeView } from './components/tree/tree.js';
+export { Finder } from './components/finder/finder.js';
+export { DataFilter } from './components/data-filter/data-filter.js';
+export { Field } from './components/field/field.js';
+export { Fieldset } from './components/fieldset/fieldset.js';
+export { Form } from './components/form/form.js';
+export { ValueList } from './components/value-list/value-list.js';
+export { MultiValueEditor } from './components/multi-value-editor/multi-value-editor.js';
+export { FieldUpload } from './components/field-upload/field-upload.js';