@uifn/core 0.0.1

package/dist/primitives/tooltip.d.ts

@@ -0,0 +1,63 @@
+import { UIFnError } from '../errors.js';
+import { RectLike, PositionResult, Side, Align } from '../utils/position.js';
+import { C as ChangeMeta } from '../shared-Sdeyo6Vu.js';
+
+interface TooltipProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    delayDuration?: number;
+    skipDelayDuration?: number;
+    disableHoverableContent?: boolean;
+    side?: Side;
+    align?: Align;
+    sideOffset?: number;
+    alignOffset?: number;
+    collisionPadding?: number;
+    collisionDetection?: boolean;
+    reducedMotion?: boolean;
+}
+interface TooltipState {
+    open: boolean;
+    delayDuration: number;
+    skipDelayDuration: number;
+    disableHoverableContent: boolean;
+    pendingOpenMs: number | null;
+    side: Side;
+    align: Align;
+    sideOffset: number;
+    alignOffset: number;
+    collisionPadding: number;
+    collisionDetection: boolean;
+    position: PositionResult | null;
+    cleanup: {
+        timers: number;
+        listeners: number;
+        complete: boolean;
+    };
+    lastChangeMeta?: ChangeMeta<boolean>;
+    lastError: UIFnError | null;
+}
+interface TooltipActions {
+    setOpen: (open: boolean) => void;
+    openWithDelay: () => void;
+    close: () => void;
+    advanceTime: (elapsedMs: number) => void;
+    computePosition: (anchorRect: RectLike, contentRect: RectLike, viewport: {
+        width: number;
+        height: number;
+        scrollX?: number;
+        scrollY?: number;
+    }) => PositionResult;
+    registerListener: () => void;
+    clearListener: () => void;
+}
+interface TooltipMachine {
+    readonly state: TooltipState;
+    readonly actions: TooltipActions;
+    getState: () => TooltipState;
+    subscribe: (callback: (state: TooltipState, meta?: ChangeMeta<boolean>) => void) => () => void;
+}
+declare function createTooltip(props: TooltipProps): TooltipMachine;
+
+export { type TooltipActions, type TooltipMachine, type TooltipProps, type TooltipState, createTooltip };

package/dist/primitives/tooltip.js

@@ -0,0 +1,16 @@
+'use strict';
+
+var chunkUYK6N72M_js = require('../chunk-UYK6N72M.js');
+require('../chunk-JBMGXJ55.js');
+require('../chunk-WV2D7BZS.js');
+require('../chunk-K3WYDUIN.js');
+require('../chunk-EKMJ2G7A.js');
+
+
+
+Object.defineProperty(exports, "createTooltip", {
+  enumerable: true,
+  get: function () { return chunkUYK6N72M_js.createTooltip; }
+});
+//# sourceMappingURL=tooltip.js.map
+//# sourceMappingURL=tooltip.js.map

package/dist/primitives/tooltip.js.map

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

package/dist/primitives/tooltip.mjs

@@ -0,0 +1,7 @@
+export { createTooltip } from '../chunk-PMZEYBN3.mjs';
+import '../chunk-UF33V3RN.mjs';
+import '../chunk-CH6WMHOM.mjs';
+import '../chunk-LNJ2UKA3.mjs';
+import '../chunk-HTTKRX7S.mjs';
+//# sourceMappingURL=tooltip.mjs.map
+//# sourceMappingURL=tooltip.mjs.map

package/dist/primitives/tooltip.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"tooltip.mjs"}

package/dist/shared-Sdeyo6Vu.d.mts

@@ -0,0 +1,10 @@
+type ChangeSource = 'user' | 'programmatic' | 'controlled-sync';
+interface ChangeMeta<TValue = unknown> {
+    source: ChangeSource;
+    reason: string;
+    previousValue: TValue;
+    nextValue: TValue;
+    inputModality?: 'keyboard' | 'pointer' | 'touch' | 'virtual';
+}
+
+export type { ChangeMeta as C };

package/dist/shared-Sdeyo6Vu.d.ts

@@ -0,0 +1,10 @@
+type ChangeSource = 'user' | 'programmatic' | 'controlled-sync';
+interface ChangeMeta<TValue = unknown> {
+    source: ChangeSource;
+    reason: string;
+    previousValue: TValue;
+    nextValue: TValue;
+    inputModality?: 'keyboard' | 'pointer' | 'touch' | 'virtual';
+}
+
+export type { ChangeMeta as C };

package/dist/state/index.d.mts

@@ -0,0 +1 @@
+export { ControllableStateController, ControllableStateControllerOptions, ControllableStateRequestResult, EventObject, MachineConfig, StateConfig, StateMachine, Transition, createControllableStateController, createMachine } from './machine.mjs';

package/dist/state/index.d.ts

@@ -0,0 +1 @@
+export { ControllableStateController, ControllableStateControllerOptions, ControllableStateRequestResult, EventObject, MachineConfig, StateConfig, StateMachine, Transition, createControllableStateController, createMachine } from './machine.js';

package/dist/state/index.js

@@ -0,0 +1,21 @@
+'use strict';
+
+require('../chunk-AAUYPAHO.js');
+var chunkL67UQEPI_js = require('../chunk-L67UQEPI.js');
+
+
+
+Object.defineProperty(exports, "StateMachine", {
+  enumerable: true,
+  get: function () { return chunkL67UQEPI_js.StateMachine; }
+});
+Object.defineProperty(exports, "createControllableStateController", {
+  enumerable: true,
+  get: function () { return chunkL67UQEPI_js.createControllableStateController; }
+});
+Object.defineProperty(exports, "createMachine", {
+  enumerable: true,
+  get: function () { return chunkL67UQEPI_js.createMachine; }
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/state/index.js.map

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

package/dist/state/index.mjs

@@ -0,0 +1,4 @@
+import '../chunk-DB2757V5.mjs';
+export { StateMachine, createControllableStateController, createMachine } from '../chunk-RPH4AAZZ.mjs';
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/state/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs"}

package/dist/state/machine.d.mts

@@ -0,0 +1,62 @@
+type EventObject = {
+    type: string;
+    [key: string]: any;
+};
+type StateConfig<TContext, TEvent extends EventObject> = {
+    value: string;
+    context: TContext;
+    event: TEvent;
+};
+type Transition<TContext, TEvent extends EventObject> = string | {
+    target?: string;
+    actions?: Array<(context: TContext, event: TEvent) => void>;
+    cond?: (context: TContext, event: TEvent) => boolean;
+};
+type MachineConfig<TContext, TEvent extends EventObject> = {
+    initial: string;
+    context: TContext;
+    states: {
+        [key: string]: {
+            on?: {
+                [K in TEvent['type']]?: Transition<TContext, TEvent & {
+                    type: K;
+                }>;
+            };
+            entry?: Array<(context: TContext, event: TEvent) => void>;
+            exit?: Array<(context: TContext, event: TEvent) => void>;
+        };
+    };
+};
+declare class StateMachine<TContext, TEvent extends EventObject> {
+    private _state;
+    private _context;
+    private _config;
+    private _listeners;
+    constructor(config: MachineConfig<TContext, TEvent>);
+    get state(): string;
+    get context(): TContext;
+    send(event: TEvent): void;
+    subscribe(listener: (state: string, context: TContext) => void): () => void;
+    private _notify;
+}
+declare function createMachine<TContext, TEvent extends EventObject>(config: MachineConfig<TContext, TEvent>): StateMachine<TContext, TEvent>;
+interface ControllableStateControllerOptions<TValue> {
+    value?: TValue;
+    defaultValue: TValue;
+    onChange?: (value: TValue) => void;
+    isEqual?: (a: TValue, b: TValue) => boolean;
+}
+interface ControllableStateRequestResult<TValue> {
+    value: TValue;
+    changed: boolean;
+    controlled: boolean;
+}
+interface ControllableStateController<TValue> {
+    isControlled: () => boolean;
+    getValue: () => TValue;
+    requestValue: (nextValue: TValue) => ControllableStateRequestResult<TValue>;
+    syncValue: (nextValue: TValue) => ControllableStateRequestResult<TValue>;
+}
+declare function createControllableStateController<TValue>(options: ControllableStateControllerOptions<TValue>): ControllableStateController<TValue>;
+
+export { type ControllableStateController, type ControllableStateControllerOptions, type ControllableStateRequestResult, type EventObject, type MachineConfig, type StateConfig, StateMachine, type Transition, createControllableStateController, createMachine };

package/dist/state/machine.d.ts

@@ -0,0 +1,62 @@
+type EventObject = {
+    type: string;
+    [key: string]: any;
+};
+type StateConfig<TContext, TEvent extends EventObject> = {
+    value: string;
+    context: TContext;
+    event: TEvent;
+};
+type Transition<TContext, TEvent extends EventObject> = string | {
+    target?: string;
+    actions?: Array<(context: TContext, event: TEvent) => void>;
+    cond?: (context: TContext, event: TEvent) => boolean;
+};
+type MachineConfig<TContext, TEvent extends EventObject> = {
+    initial: string;
+    context: TContext;
+    states: {
+        [key: string]: {
+            on?: {
+                [K in TEvent['type']]?: Transition<TContext, TEvent & {
+                    type: K;
+                }>;
+            };
+            entry?: Array<(context: TContext, event: TEvent) => void>;
+            exit?: Array<(context: TContext, event: TEvent) => void>;
+        };
+    };
+};
+declare class StateMachine<TContext, TEvent extends EventObject> {
+    private _state;
+    private _context;
+    private _config;
+    private _listeners;
+    constructor(config: MachineConfig<TContext, TEvent>);
+    get state(): string;
+    get context(): TContext;
+    send(event: TEvent): void;
+    subscribe(listener: (state: string, context: TContext) => void): () => void;
+    private _notify;
+}
+declare function createMachine<TContext, TEvent extends EventObject>(config: MachineConfig<TContext, TEvent>): StateMachine<TContext, TEvent>;
+interface ControllableStateControllerOptions<TValue> {
+    value?: TValue;
+    defaultValue: TValue;
+    onChange?: (value: TValue) => void;
+    isEqual?: (a: TValue, b: TValue) => boolean;
+}
+interface ControllableStateRequestResult<TValue> {
+    value: TValue;
+    changed: boolean;
+    controlled: boolean;
+}
+interface ControllableStateController<TValue> {
+    isControlled: () => boolean;
+    getValue: () => TValue;
+    requestValue: (nextValue: TValue) => ControllableStateRequestResult<TValue>;
+    syncValue: (nextValue: TValue) => ControllableStateRequestResult<TValue>;
+}
+declare function createControllableStateController<TValue>(options: ControllableStateControllerOptions<TValue>): ControllableStateController<TValue>;
+
+export { type ControllableStateController, type ControllableStateControllerOptions, type ControllableStateRequestResult, type EventObject, type MachineConfig, type StateConfig, StateMachine, type Transition, createControllableStateController, createMachine };

package/dist/state/machine.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var chunkL67UQEPI_js = require('../chunk-L67UQEPI.js');
+
+
+
+Object.defineProperty(exports, "StateMachine", {
+  enumerable: true,
+  get: function () { return chunkL67UQEPI_js.StateMachine; }
+});
+Object.defineProperty(exports, "createControllableStateController", {
+  enumerable: true,
+  get: function () { return chunkL67UQEPI_js.createControllableStateController; }
+});
+Object.defineProperty(exports, "createMachine", {
+  enumerable: true,
+  get: function () { return chunkL67UQEPI_js.createMachine; }
+});
+//# sourceMappingURL=machine.js.map
+//# sourceMappingURL=machine.js.map

package/dist/state/machine.js.map

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

package/dist/state/machine.mjs

@@ -0,0 +1,3 @@
+export { StateMachine, createControllableStateController, createMachine } from '../chunk-RPH4AAZZ.mjs';
+//# sourceMappingURL=machine.mjs.map
+//# sourceMappingURL=machine.mjs.map

package/dist/state/machine.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"machine.mjs"}

package/dist/utils/escape-key.d.mts

@@ -0,0 +1,12 @@
+interface EscapeKeyListenerOptions {
+    ownerDocument?: Document;
+    enabled?: boolean;
+    eventName?: 'keydown' | 'keyup';
+}
+interface EscapeKeyListenerController {
+    update: (options: EscapeKeyListenerOptions) => void;
+    destroy: () => void;
+}
+declare function createEscapeKeyListener(onEscape: (event: KeyboardEvent) => void, options?: EscapeKeyListenerOptions): EscapeKeyListenerController;
+
+export { type EscapeKeyListenerController, type EscapeKeyListenerOptions, createEscapeKeyListener };

package/dist/utils/escape-key.d.ts

@@ -0,0 +1,12 @@
+interface EscapeKeyListenerOptions {
+    ownerDocument?: Document;
+    enabled?: boolean;
+    eventName?: 'keydown' | 'keyup';
+}
+interface EscapeKeyListenerController {
+    update: (options: EscapeKeyListenerOptions) => void;
+    destroy: () => void;
+}
+declare function createEscapeKeyListener(onEscape: (event: KeyboardEvent) => void, options?: EscapeKeyListenerOptions): EscapeKeyListenerController;
+
+export { type EscapeKeyListenerController, type EscapeKeyListenerOptions, createEscapeKeyListener };

package/dist/utils/escape-key.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var chunkDJ2J36FP_js = require('../chunk-DJ2J36FP.js');
+require('../chunk-Z4Q2AFMC.js');
+
+
+
+Object.defineProperty(exports, "createEscapeKeyListener", {
+  enumerable: true,
+  get: function () { return chunkDJ2J36FP_js.createEscapeKeyListener; }
+});
+//# sourceMappingURL=escape-key.js.map
+//# sourceMappingURL=escape-key.js.map

package/dist/utils/escape-key.js.map

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

package/dist/utils/escape-key.mjs

@@ -0,0 +1,4 @@
+export { createEscapeKeyListener } from '../chunk-2HLCA7I5.mjs';
+import '../chunk-UJI3VD2G.mjs';
+//# sourceMappingURL=escape-key.mjs.map
+//# sourceMappingURL=escape-key.mjs.map

package/dist/utils/escape-key.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"escape-key.mjs"}

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

@@ -0,0 +1,39 @@
+declare const FOCUSABLE_SELECTOR = "a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex=\"-1\"])";
+interface FocusTrapOptions {
+    active?: boolean;
+    returnFocus?: boolean;
+    ownerDocument?: Document;
+    focusableSelector?: string;
+}
+interface FocusTrapController {
+    activate: () => void;
+    deactivate: () => void;
+    update: (options: FocusTrapOptions) => void;
+    destroy: () => void;
+}
+interface FocusTrapSnapshot {
+    active: boolean;
+    trapped: boolean;
+    entryFocusId: string | null;
+    currentFocusId: string | null;
+    returnFocusId: string | null;
+}
+interface FocusTrapStateOptions {
+    active?: boolean;
+    entryFocusId?: string | null;
+    returnFocusId?: string | null;
+}
+interface FocusTrapStateController {
+    getState: () => FocusTrapSnapshot;
+    activate: (options?: Pick<FocusTrapStateOptions, 'entryFocusId' | 'returnFocusId'>) => FocusTrapSnapshot;
+    deactivate: (options?: {
+        restoreFocus?: boolean;
+    }) => FocusTrapSnapshot;
+    setReturnFocus: (focusId: string | null) => FocusTrapSnapshot;
+    recordFocus: (focusId: string | null) => FocusTrapSnapshot;
+}
+declare function createFocusTrapState(options?: FocusTrapStateOptions): FocusTrapStateController;
+declare function getFocusableElements(container: ParentNode, selector?: string): HTMLElement[];
+declare function createFocusTrap(container: HTMLElement, options?: FocusTrapOptions): FocusTrapController;
+
+export { FOCUSABLE_SELECTOR, type FocusTrapController, type FocusTrapOptions, type FocusTrapSnapshot, type FocusTrapStateController, type FocusTrapStateOptions, createFocusTrap, createFocusTrapState, getFocusableElements };

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

@@ -0,0 +1,39 @@
+declare const FOCUSABLE_SELECTOR = "a[href], button:not([disabled]), textarea:not([disabled]), input:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex=\"-1\"])";
+interface FocusTrapOptions {
+    active?: boolean;
+    returnFocus?: boolean;
+    ownerDocument?: Document;
+    focusableSelector?: string;
+}
+interface FocusTrapController {
+    activate: () => void;
+    deactivate: () => void;
+    update: (options: FocusTrapOptions) => void;
+    destroy: () => void;
+}
+interface FocusTrapSnapshot {
+    active: boolean;
+    trapped: boolean;
+    entryFocusId: string | null;
+    currentFocusId: string | null;
+    returnFocusId: string | null;
+}
+interface FocusTrapStateOptions {
+    active?: boolean;
+    entryFocusId?: string | null;
+    returnFocusId?: string | null;
+}
+interface FocusTrapStateController {
+    getState: () => FocusTrapSnapshot;
+    activate: (options?: Pick<FocusTrapStateOptions, 'entryFocusId' | 'returnFocusId'>) => FocusTrapSnapshot;
+    deactivate: (options?: {
+        restoreFocus?: boolean;
+    }) => FocusTrapSnapshot;
+    setReturnFocus: (focusId: string | null) => FocusTrapSnapshot;
+    recordFocus: (focusId: string | null) => FocusTrapSnapshot;
+}
+declare function createFocusTrapState(options?: FocusTrapStateOptions): FocusTrapStateController;
+declare function getFocusableElements(container: ParentNode, selector?: string): HTMLElement[];
+declare function createFocusTrap(container: HTMLElement, options?: FocusTrapOptions): FocusTrapController;
+
+export { FOCUSABLE_SELECTOR, type FocusTrapController, type FocusTrapOptions, type FocusTrapSnapshot, type FocusTrapStateController, type FocusTrapStateOptions, createFocusTrap, createFocusTrapState, getFocusableElements };

package/dist/utils/focus-trap.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var chunkZBIA3D6U_js = require('../chunk-ZBIA3D6U.js');
+require('../chunk-Z4Q2AFMC.js');
+
+
+
+Object.defineProperty(exports, "FOCUSABLE_SELECTOR", {
+  enumerable: true,
+  get: function () { return chunkZBIA3D6U_js.FOCUSABLE_SELECTOR; }
+});
+Object.defineProperty(exports, "createFocusTrap", {
+  enumerable: true,
+  get: function () { return chunkZBIA3D6U_js.createFocusTrap; }
+});
+Object.defineProperty(exports, "createFocusTrapState", {
+  enumerable: true,
+  get: function () { return chunkZBIA3D6U_js.createFocusTrapState; }
+});
+Object.defineProperty(exports, "getFocusableElements", {
+  enumerable: true,
+  get: function () { return chunkZBIA3D6U_js.getFocusableElements; }
+});
+//# sourceMappingURL=focus-trap.js.map
+//# sourceMappingURL=focus-trap.js.map

package/dist/utils/focus-trap.js.map

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

package/dist/utils/focus-trap.mjs

@@ -0,0 +1,4 @@
+export { FOCUSABLE_SELECTOR, createFocusTrap, createFocusTrapState, getFocusableElements } from '../chunk-W3EUJ2EQ.mjs';
+import '../chunk-UJI3VD2G.mjs';
+//# sourceMappingURL=focus-trap.mjs.map
+//# sourceMappingURL=focus-trap.mjs.map

package/dist/utils/focus-trap.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"focus-trap.mjs"}

package/dist/utils/id.d.mts

@@ -0,0 +1,54 @@
+import { UIFnPackageName } from '../errors.mjs';
+
+interface IdFactoryOptions {
+    namespace?: string;
+}
+interface IdFactory {
+    next: (token?: string) => string;
+    reset: (token?: string) => void;
+    snapshot: () => Record<string, number>;
+}
+interface PublicIdInput {
+    prefix?: string;
+    slot?: string;
+}
+interface PublicIdAssertionOptions {
+    package?: UIFnPackageName;
+    component?: string;
+    details?: Record<string, unknown>;
+    recoverable?: boolean;
+}
+interface PublicIdSnapshot {
+    counters: Record<string, number>;
+    issued: string[];
+}
+interface PublicIdRegistry {
+    has: (id: string) => boolean;
+    register: (id: string) => string;
+    reset: (prefix?: string) => void;
+    snapshot: () => string[];
+}
+interface DeterministicIdFactory {
+    compose: (input?: string | PublicIdInput) => string;
+    create: (input?: string | PublicIdInput) => string;
+    reuse: (existingId: string | null | undefined, input?: string | PublicIdInput) => string;
+    register: (id: string, options?: PublicIdAssertionOptions) => string;
+    reset: (input?: string | PublicIdInput) => void;
+    snapshot: () => PublicIdSnapshot;
+}
+declare function createPublicIdRegistry(): PublicIdRegistry;
+declare function assertUniquePublicId(id: string, registry?: PublicIdRegistry, options?: PublicIdAssertionOptions): string;
+declare function createDeterministicIdFactory(options?: IdFactoryOptions & {
+    registry?: PublicIdRegistry;
+}): DeterministicIdFactory;
+declare function composePublicId(input?: string | PublicIdInput, options?: IdFactoryOptions): string;
+declare function createIdFactory(options?: IdFactoryOptions): IdFactory;
+declare const createIdScope: typeof createIdFactory;
+declare function generateId(token?: string): string;
+declare function reusePublicId(existingId: string | null | undefined, input?: string | PublicIdInput): string;
+declare function registerPublicId(id: string, options?: PublicIdAssertionOptions): string;
+declare function resetIdCounters(token?: string): void;
+declare function getIdCounterSnapshot(): Record<string, number>;
+declare function getPublicIdSnapshot(): PublicIdSnapshot;
+
+export { type DeterministicIdFactory, type IdFactory, type IdFactoryOptions, type PublicIdAssertionOptions, type PublicIdInput, type PublicIdRegistry, type PublicIdSnapshot, assertUniquePublicId, composePublicId, createDeterministicIdFactory, createIdFactory, createIdScope, createPublicIdRegistry, generateId, getIdCounterSnapshot, getPublicIdSnapshot, registerPublicId, resetIdCounters, reusePublicId };

package/dist/utils/id.d.ts

@@ -0,0 +1,54 @@
+import { UIFnPackageName } from '../errors.js';
+
+interface IdFactoryOptions {
+    namespace?: string;
+}
+interface IdFactory {
+    next: (token?: string) => string;
+    reset: (token?: string) => void;
+    snapshot: () => Record<string, number>;
+}
+interface PublicIdInput {
+    prefix?: string;
+    slot?: string;
+}
+interface PublicIdAssertionOptions {
+    package?: UIFnPackageName;
+    component?: string;
+    details?: Record<string, unknown>;
+    recoverable?: boolean;
+}
+interface PublicIdSnapshot {
+    counters: Record<string, number>;
+    issued: string[];
+}
+interface PublicIdRegistry {
+    has: (id: string) => boolean;
+    register: (id: string) => string;
+    reset: (prefix?: string) => void;
+    snapshot: () => string[];
+}
+interface DeterministicIdFactory {
+    compose: (input?: string | PublicIdInput) => string;
+    create: (input?: string | PublicIdInput) => string;
+    reuse: (existingId: string | null | undefined, input?: string | PublicIdInput) => string;
+    register: (id: string, options?: PublicIdAssertionOptions) => string;
+    reset: (input?: string | PublicIdInput) => void;
+    snapshot: () => PublicIdSnapshot;
+}
+declare function createPublicIdRegistry(): PublicIdRegistry;
+declare function assertUniquePublicId(id: string, registry?: PublicIdRegistry, options?: PublicIdAssertionOptions): string;
+declare function createDeterministicIdFactory(options?: IdFactoryOptions & {
+    registry?: PublicIdRegistry;
+}): DeterministicIdFactory;
+declare function composePublicId(input?: string | PublicIdInput, options?: IdFactoryOptions): string;
+declare function createIdFactory(options?: IdFactoryOptions): IdFactory;
+declare const createIdScope: typeof createIdFactory;
+declare function generateId(token?: string): string;
+declare function reusePublicId(existingId: string | null | undefined, input?: string | PublicIdInput): string;
+declare function registerPublicId(id: string, options?: PublicIdAssertionOptions): string;
+declare function resetIdCounters(token?: string): void;
+declare function getIdCounterSnapshot(): Record<string, number>;
+declare function getPublicIdSnapshot(): PublicIdSnapshot;
+
+export { type DeterministicIdFactory, type IdFactory, type IdFactoryOptions, type PublicIdAssertionOptions, type PublicIdInput, type PublicIdRegistry, type PublicIdSnapshot, assertUniquePublicId, composePublicId, createDeterministicIdFactory, createIdFactory, createIdScope, createPublicIdRegistry, generateId, getIdCounterSnapshot, getPublicIdSnapshot, registerPublicId, resetIdCounters, reusePublicId };

package/dist/utils/id.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var chunk75SPLZPF_js = require('../chunk-75SPLZPF.js');
+require('../chunk-EKMJ2G7A.js');
+
+
+
+Object.defineProperty(exports, "assertUniquePublicId", {
+  enumerable: true,
+  get: function () { return chunk75SPLZPF_js.assertUniquePublicId; }
+});
+Object.defineProperty(exports, "composePublicId", {
+  enumerable: true,
+  get: function () { return chunk75SPLZPF_js.composePublicId; }
+});
+Object.defineProperty(exports, "createDeterministicIdFactory", {
+  enumerable: true,
+  get: function () { return chunk75SPLZPF_js.createDeterministicIdFactory; }
+});
+Object.defineProperty(exports, "createIdFactory", {
+  enumerable: true,
+  get: function () { return chunk75SPLZPF_js.createIdFactory; }
+});
+Object.defineProperty(exports, "createIdScope", {
+  enumerable: true,
+  get: function () { return chunk75SPLZPF_js.createIdScope; }
+});
+Object.defineProperty(exports, "createPublicIdRegistry", {
+  enumerable: true,
+  get: function () { return chunk75SPLZPF_js.createPublicIdRegistry; }
+});
+Object.defineProperty(exports, "generateId", {
+  enumerable: true,
+  get: function () { return chunk75SPLZPF_js.generateId; }
+});
+Object.defineProperty(exports, "getIdCounterSnapshot", {
+  enumerable: true,
+  get: function () { return chunk75SPLZPF_js.getIdCounterSnapshot; }
+});
+Object.defineProperty(exports, "getPublicIdSnapshot", {
+  enumerable: true,
+  get: function () { return chunk75SPLZPF_js.getPublicIdSnapshot; }
+});
+Object.defineProperty(exports, "registerPublicId", {
+  enumerable: true,
+  get: function () { return chunk75SPLZPF_js.registerPublicId; }
+});
+Object.defineProperty(exports, "resetIdCounters", {
+  enumerable: true,
+  get: function () { return chunk75SPLZPF_js.resetIdCounters; }
+});
+Object.defineProperty(exports, "reusePublicId", {
+  enumerable: true,
+  get: function () { return chunk75SPLZPF_js.reusePublicId; }
+});
+//# sourceMappingURL=id.js.map
+//# sourceMappingURL=id.js.map