@baleada/logic 0.22.7 → 0.23.1

package/lib/index.d.ts

@@ -1,7 +1,10 @@
 import { getStroke, StrokeOptions } from 'perfect-freehand';
-import createDOMPurify, { Config } from 'dompurify';
+import * as ky_distribution_types_ky from 'ky/distribution/types/ky';
+import ky, { Options } from 'ky';
+import { Config, DOMPurifyI } from 'dompurify';
 import { FullOptions, MatchData, Searcher } from 'fast-fuzzy';
-import { Options } from '@sindresorhus/slugify';
+import { Options as Options$1 } from '@sindresorhus/slugify';
+import { ClassValue } from 'clsx';
 
 type AnimateableKeyframe = {
     progress: number;
@@ -156,14 +159,11 @@ type RecognizeableEffectApi<Type extends ListenableSupportedType, Metadata exten
     setMetadata: (metadata: Metadata) => void;
     recognized: () => void;
     denied: () => void;
-    recognizedUntilReady: () => void;
-    deniedUntilReady: () => void;
-    ready: () => void;
     getSequence: () => ListenEffectParam<Type>[];
     onRecognized: (sequenceItem: ListenEffectParam<Type>) => any;
 };
-type RecognizeableStatus = 'recognized' | 'recognizing' | 'denied' | 'ready' | 'recognized until ready' | 'denied until ready';
-type RecognizeOptions<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
+type RecognizeableStatus = 'recognized' | 'recognizing' | 'denied' | 'ready';
+type RecognizeOptions<Type extends ListenableSupportedType> = {
     onRecognized?: (sequenceItem: ListenEffectParam<Type>) => any;
 };
 declare class Recognizeable<Type extends ListenableSupportedType, Metadata extends Record<any, any>> {
@@ -175,8 +175,6 @@ declare class Recognizeable<Type extends ListenableSupportedType, Metadata exten
     private resetComputedMetadata;
     private recognized;
     private denied;
-    private recognizedUntilReady;
-    private deniedUntilReady;
     private computedStatus;
     private ready;
     get sequence(): ListenEffectParam<Type>[];
@@ -185,7 +183,7 @@ declare class Recognizeable<Type extends ListenableSupportedType, Metadata exten
     get metadata(): Metadata;
     private computedSequence;
     setSequence(sequence: ListenEffectParam<Type>[]): this;
-    recognize(sequenceItem: ListenEffectParam<Type>, { onRecognized }?: RecognizeOptions<Type, Metadata>): this;
+    recognize(sequenceItem: ListenEffectParam<Type>, { onRecognized }?: RecognizeOptions<Type>): this;
     private recognizing;
     private toType;
 }
@@ -317,6 +315,29 @@ declare class Broadcastable<State> {
 }
 declare function toMessageListenParams<State>(instance: Broadcastable<State>, effect: (event: MessageEvent<State>) => void): Parameters<Listenable<'message'>['listen']>;
 
+type CompareableOptions = {
+    locales?: Parameters<typeof Intl.Collator>[0];
+    collator?: Intl.CollatorOptions;
+};
+type CompareableStatus = 'ready' | 'comparing' | 'compared';
+declare class Compareable {
+    constructor(string: string, options?: CompareableOptions);
+    private computedStatus;
+    private ready;
+    get string(): string;
+    set string(string: string);
+    get status(): CompareableStatus;
+    private computedCollator;
+    get collator(): Intl.Collator;
+    private computedComparison;
+    get comparison(): 0 | 1 | -1;
+    private computedString;
+    setString(string: string): this;
+    compare(compared: string): this;
+    private comparing;
+    private compared;
+}
+
 type CompleteableOptions = {
     segment?: {
         from?: 'start' | 'selection' | 'divider';
@@ -494,9 +515,13 @@ declare class Resolveable<Value> {
     private errored;
 }
 
-type FetchableOptions = Record<never, never>;
-type FetchableStatus = 'ready' | 'fetching' | 'fetched' | 'aborted' | 'errored';
-type FetchOptions = RequestInit | ((api: FetchOptionsApi) => RequestInit);
+type FetchableOptions = {
+    ky?: Options | ((api: ToKyOptionsApi) => Options);
+};
+type ToKyOptionsApi = {
+    stop: typeof ky['stop'];
+};
+type FetchableStatus = 'ready' | 'fetching' | 'fetched' | 'retrying' | 'aborted' | 'errored';
 declare class Fetchable {
     private computedArrayBuffer;
     private computedBlob;
@@ -508,10 +533,14 @@ declare class Fetchable {
     private ready;
     get resource(): string;
     set resource(resource: string);
+    private computedKy;
+    get ky(): ky_distribution_types_ky.KyInstance;
     private computedAbortController;
     get abortController(): AbortController;
     get status(): FetchableStatus;
     get response(): Response;
+    private computedRetryCount;
+    get retryCount(): number;
     get error(): Error;
     get arrayBuffer(): Resolveable<ArrayBuffer>;
     get blob(): Resolveable<Blob>;
@@ -522,27 +551,20 @@ declare class Fetchable {
     setResource(resource: string): this;
     private computedResponse;
     private computedError;
-    fetch(options?: FetchOptions): Promise<this>;
+    fetch(options?: Options): Promise<this>;
     private fetching;
+    private retrying;
     private fetched;
     private aborted;
     private errored;
-    get(options?: FetchOptions): Promise<this>;
-    patch(options?: FetchOptions): Promise<this>;
-    post(options?: FetchOptions): Promise<this>;
-    put(options?: FetchOptions): Promise<this>;
-    delete(options?: FetchOptions): Promise<this>;
+    get(options?: Options): Promise<this>;
+    patch(options?: Options): Promise<this>;
+    post(options?: Options): Promise<this>;
+    put(options?: Options): Promise<this>;
+    delete(options?: Options): Promise<this>;
+    head(options?: Options): Promise<this>;
     abort(): this;
 }
-type FetchOptionsApi = {
-    withJson: (data: Record<any, any>) => {
-        body: string;
-        headers: {
-            'Accept': 'application/json';
-            'Content-Type': 'application/json';
-        };
-    };
-};
 
 type FullscreenableOptions = Record<never, never>;
 type FullscreenableGetElement<ElementType> = ((...args: any[]) => ElementType);
@@ -676,7 +698,7 @@ declare class Sanitizeable {
     private ready;
     get html(): string;
     set html(html: string);
-    get dompurify(): createDOMPurify.DOMPurifyI;
+    get dompurify(): DOMPurifyI;
     get status(): SanitizeableStatus;
     private computedHtml;
     setHtml(html: string): this;
@@ -757,56 +779,472 @@ declare class Storeable<String extends string> {
     removeStatus(): this;
 }
 
-declare function createReduceAsync<Item, Accumulator>(accumulate: (accumulator: Accumulator, item: Item, index: number) => Promise<Accumulator>, initialValue?: Accumulator): (array: Item[]) => Promise<Accumulator>;
+type AnyFn<Returned> = (param: any) => Returned;
+declare function createClone<Any>(): AnyFn<Any>;
+declare function createEqual(compared: any): AnyFn<boolean>;
+
+type ArrayFn<Item, Returned> = (array: Item[]) => Returned;
+declare function createConcat<Item>(...arrays: Item[][]): ArrayFn<Item, Item[]>;
+declare function createFilter<Item>(predicate: (item: Item, index: number) => boolean): ArrayFn<Item, Item[]>;
+declare function createInsert<Item>(item: Item, index: number): ArrayFn<Item, Item[]>;
+declare function createMap<Item, Transformed = Item>(transform: (item: Item, index: number) => Transformed): ArrayFn<Item, Transformed[]>;
 declare function createReduce<Item, Accumulator>(accumulate: (accumulator: Accumulator, item: Item, index: number) => Accumulator, initialValue?: Accumulator): (array: Item[]) => Accumulator;
-type ArrayFunctionAsync<Item, Returned> = (array: Item[]) => Promise<Returned>;
-declare function createForEachAsync<Item>(forEach: (item: Item, index: number) => any): ArrayFunctionAsync<Item, any>;
-declare function createMapAsync<Item, Mapped>(transform: (item: Item, index: number) => Promise<Mapped>): ArrayFunctionAsync<Item, Mapped[]>;
-declare function createFilterAsync<Item>(predicate: (item: Item, index: number) => Promise<boolean>): ArrayFunctionAsync<Item, Item[]>;
-type ArrayFunction<Item, Returned> = (array: Item[]) => Returned;
-declare function createRemove<Item>(index: number): ArrayFunction<Item, Item[]>;
-declare function createInsert<Item>(item: Item, index: number): ArrayFunction<Item, Item[]>;
+declare function createRemove<Item>(index: number): ArrayFn<Item, Item[]>;
 declare function createReorder<Item>(from: {
     start: number;
     itemCount: number;
-} | number, to: number): ArrayFunction<Item, Item[]>;
-declare function createSwap<Item>(indices: [number, number]): ArrayFunction<Item, Item[]>;
-declare function createReplace<Item>(index: number, item: Item): ArrayFunction<Item, Item[]>;
-declare function createUnique<Item>(): ArrayFunction<Item, Item[]>;
-declare function createSlice<Item>(from: number, to?: number): ArrayFunction<Item, Item[]>;
-declare function createFilter<Item>(predicate: (item: Item, index: number) => boolean): ArrayFunction<Item, Item[]>;
-declare function createMap<Item, Transformed = Item>(transform: (item: Item, index: number) => Transformed): ArrayFunction<Item, Transformed[]>;
-declare function createConcat<Item>(...arrays: Item[][]): ArrayFunction<Item, Item[]>;
-declare function createReverse<Item>(): ArrayFunction<Item, Item[]>;
-declare function createSort<Item>(compare?: (itemA: Item, itemB: Item) => number): ArrayFunction<Item, Item[]>;
-type StringFunction<Returned> = (string: string) => Returned;
-declare function createSlug(options?: Options): StringFunction<string>;
-declare function createClip(required: string | RegExp): StringFunction<string>;
-type NumberFunction<Returned> = (number: number) => Returned;
-declare function createClamp(min: number, max: number): NumberFunction<number>;
+} | number, to: number): ArrayFn<Item, Item[]>;
+declare function createReplace<Item>(index: number, replacement: Item): ArrayFn<Item, Item[]>;
+declare function createReverse<Item>(): ArrayFn<Item, Item[]>;
+declare function createSlice<Item>(from: number, to?: number): ArrayFn<Item, Item[]>;
+declare function createSort<Item>(compare?: (itemA: Item, itemB: Item) => number): ArrayFn<Item, Item[]>;
+declare function createSwap<Item>(indices: [number, number]): ArrayFn<Item, Item[]>;
+declare function createUnique<Item>(): ArrayFn<Item, Item[]>;
+
+type ArrayAsyncFn<Item, Returned> = (array: Item[]) => Promise<Returned>;
+declare function createFilterAsync<Item>(predicate: (item: Item, index: number) => Promise<boolean>): ArrayAsyncFn<Item, Item[]>;
+declare function createFindAsync<Item>(predicate: (item: Item, index: number) => Promise<boolean>): ArrayAsyncFn<Item, Item | undefined>;
+declare function createFindIndexAsync<Item>(predicate: (item: Item, index: number) => Promise<boolean>): ArrayAsyncFn<Item, number>;
+declare function createForEachAsync<Item>(forEach: (item: Item, index: number) => any): ArrayAsyncFn<Item, any>;
+declare function createMapAsync<Item, Mapped>(transform: (item: Item, index: number) => Promise<Mapped>): ArrayAsyncFn<Item, Mapped[]>;
+declare function createReduceAsync<Item, Accumulator>(accumulate: (accumulator: Accumulator, item: Item, index: number) => Promise<Accumulator>, initialValue?: Accumulator): (array: Item[]) => Promise<Accumulator>;
+
+type StringFn<Returned> = (string: string) => Returned;
+declare function createClip(required: string | RegExp): StringFn<string>;
+declare function createSlug(options?: Options$1): StringFn<string>;
+
+type NumberFn<Returned> = (number: number) => Returned;
+declare function createClamp(min: number, max: number): NumberFn<number>;
 type Potentiality<Outcome> = {
     outcome: Outcome;
     probability: number;
 };
-declare function createDetermine<Outcome>(potentialities: Potentiality<Outcome>[]): NumberFunction<Outcome>;
-type MapFunction<Key, Value, Returned> = (transform: Map<Key, Value>) => Returned;
-declare function createRename<Key, Value>(from: Key, to: Key): MapFunction<Key, Value, Map<Key, Value>>;
-type ObjectFunction<Key extends string | number | symbol, Value, Returned> = (transform: Record<Key, Value>) => Returned;
-declare function createToEntries<Key extends string | number | symbol, Value>(): ObjectFunction<Key, Value, [Key, Value][]>;
-declare function createToKeys<Key extends string | number | symbol>(): ObjectFunction<Key, any, [Key, any][]>;
-declare function createToSome<Key extends string | number | symbol, Value>(predicate: (key: Key, value: Value) => unknown): ObjectFunction<Key, Value, boolean>;
-declare function createToEvery<Key extends string | number | symbol, Value>(predicate: (key: Key, value: Value) => unknown): ObjectFunction<Key, Value, boolean>;
-type EventFunction<Evt extends Event, Returned> = (event: Evt) => Returned;
-declare function createMatchesKeycombo(keycombo: string): EventFunction<KeyboardEvent, boolean>;
-declare function createMatchesMousecombo(mousecombo: string): EventFunction<MouseEvent, boolean>;
-declare function createMatchesPointercombo(pointercombo: string): EventFunction<PointerEvent, boolean>;
-type ElementFunction<El extends HTMLElement, Returned> = (element: El) => Returned;
-declare function createToFocusable(order: 'first' | 'last', elementIsCandidate?: boolean): ElementFunction<HTMLElement, HTMLElement | undefined>;
-declare class Pipeable {
-    private state;
-    constructor(state: any);
-    pipe(...fns: ((...args: any[]) => any)[]): any;
-    pipeAsync(...fns: ((...args: any[]) => Promise<any>)[]): Promise<any>;
-}
+declare function createDetermine<Outcome>(potentialities: Potentiality<Outcome>[]): NumberFn<Outcome>;
+
+type ObjectFn<Key extends string | number | symbol, Value, Returned> = (transform: Record<Key, Value>) => Returned;
+declare function createEntries<Key extends string | number | symbol, Value>(): ObjectFn<Key, Value, [Key, Value][]>;
+declare function createKeys<Key extends string | number | symbol>(): ObjectFn<Key, any, Key[]>;
+declare function createEvery<Key extends string | number | symbol, Value>(predicate: (key: Key, value: Value) => unknown): ObjectFn<Key, Value, boolean>;
+declare function createSome<Key extends string | number | symbol, Value>(predicate: (key: Key, value: Value) => unknown): ObjectFn<Key, Value, boolean>;
+
+type MapFn<Key, Value, Returned> = (transform: Map<Key, Value>) => Returned;
+declare function createRename<Key, Value>(from: Key, to: Key): MapFn<Key, Value, Map<Key, Value>>;
+
+type ElementFn<El extends HTMLElement, Returned> = (element: El) => Returned;
+type CreateFocusableOptions = {
+    elementIsCandidate?: boolean;
+    tabbableSelector?: string;
+};
+declare function createFocusable(order: 'first' | 'last', options?: CreateFocusableOptions): ElementFn<HTMLElement, HTMLElement | undefined>;
+
+type AssociativeArrayEntries<Key, Value> = [Key, Value][];
+declare function defineAssociativeArrayEntries<Key, Value>(entries: AssociativeArrayEntries<Key, Value>): AssociativeArrayEntries<Key, Value>;
+
+type AssociativeArray<Key extends any, Value extends any> = {
+    toValue: (key: Key) => Value | undefined;
+    set: (key: Key, value: Value) => void;
+    predicateHas: (key: Key) => boolean;
+    clear: () => void;
+    delete: (key: Key) => boolean;
+    toKeys: () => Key[];
+    toValues: () => Value[];
+    toEntries: () => AssociativeArrayEntries<Key, Value>;
+};
+type AssociativeArrayOptions<Key extends any> = {
+    initial?: AssociativeArrayEntries<Key, any>;
+    createPredicateKey?: (query: Key) => (candidate: Key) => boolean;
+};
+declare function createAssociativeArray<Key extends any, Value extends any>(options?: AssociativeArrayOptions<Key>): {
+    toValue: (key: Key) => Value;
+    set: (key: Key, value: Value) => void;
+    predicateHas: (key: Key) => boolean;
+    clear: () => void;
+    delete: (key: Key) => boolean;
+    toKeys: () => Key[];
+    toValues: () => Value[];
+    toEntries: () => AssociativeArrayEntries<Key, Value>;
+};
+
+type KeypressType = 'keydown' | 'keyup' | 'visibilitychange';
+type KeypressMetadata = {
+    pressed: string;
+} & KeyboardTimeMetadata;
+type KeypressOptions = {
+    minDuration?: number;
+    preventsDefaultUnlessDenied?: boolean;
+    toKey?: CreatePredicateKeycomboDownOptions['toKey'];
+    toAliases?: CreatePredicateKeycomboMatchOptions$1['toAliases'];
+    onDown?: KeypressHook;
+    onUp?: KeypressHook;
+    onVisibilitychange?: KeypressHook;
+};
+type KeypressHook = (api: KeypressHookApi) => any;
+type KeypressHookApi = HookApi<KeypressType, KeypressMetadata>;
+declare function createKeypress(keycomboOrKeycombos: string | string[], options?: KeypressOptions): {
+    keydown: RecognizeableEffect<"keydown", KeypressMetadata>;
+    keyup: RecognizeableEffect<"keyup", KeypressMetadata>;
+    visibilitychange: RecognizeableEffect<"visibilitychange", KeypressMetadata>;
+};
+
+type KeyreleaseType = 'keydown' | 'keyup' | 'visibilitychange';
+type KeyreleaseMetadata = {
+    released: string;
+} & KeyboardTimeMetadata;
+type KeyreleaseOptions = {
+    minDuration?: number;
+    preventsDefaultUnlessDenied?: boolean;
+    toKey?: CreatePredicateKeycomboDownOptions['toKey'];
+    toAliases?: CreatePredicateKeycomboMatchOptions$1['toAliases'];
+    onDown?: KeyreleaseHook;
+    onUp?: KeyreleaseHook;
+    onVisibilitychange?: KeyreleaseHook;
+};
+type KeyreleaseHook = (api: KeyreleaseHookApi) => any;
+type KeyreleaseHookApi = HookApi<KeyreleaseType, KeyreleaseMetadata>;
+declare function createKeyrelease(keycomboOrKeycombos: string | string[], options?: KeyreleaseOptions): {
+    keydown: RecognizeableEffect<"keydown", KeyreleaseMetadata>;
+    keyup: RecognizeableEffect<"keyup", KeyreleaseMetadata>;
+    visibilitychange: RecognizeableEffect<"visibilitychange", KeyreleaseMetadata>;
+};
+
+type KeychordType = 'keydown' | 'keyup' | 'visibilitychange';
+type KeychordMetadata = {
+    played: ({
+        released: string;
+    } & KeyboardTimeMetadata)[];
+};
+type KeychordOptions = {
+    minDuration?: number;
+    maxInterval?: number;
+    preventsDefaultUnlessDenied?: boolean;
+    toKey?: CreatePredicateKeycomboDownOptions['toKey'];
+    toAliases?: CreatePredicateKeycomboMatchOptions$1['toAliases'];
+    onDown?: KeychordHook;
+    onUp?: KeychordHook;
+    onVisibilitychange?: KeychordHook;
+};
+type KeychordHook = (api: KeychordHookApi) => any;
+type KeychordHookApi = HookApi<KeychordType, KeychordMetadata>;
+declare function createKeychord(keychord: string, options?: KeychordOptions): {
+    keydown: RecognizeableEffect<"keydown", KeychordMetadata>;
+    keyup: RecognizeableEffect<"keyup", KeychordMetadata>;
+    visibilitychange: RecognizeableEffect<"visibilitychange", KeychordMetadata>;
+};
+
+type KonamiType = KeychordType;
+type KonamiMetadata = KeychordMetadata;
+type KonamiOptions = KeychordOptions;
+type KonamiHook = KeychordHook;
+type KonamiHookApi = KeychordHookApi;
+declare function createKonami(options?: KonamiOptions): RecognizeableOptions<KonamiType, KonamiMetadata>['effects'];
+
+type MousepressType = 'mousedown' | 'mouseleave' | 'mouseup';
+type MousepressMetadata = PointerStartMetadata & PointerMoveMetadata & PointerTimeMetadata;
+type MousepressOptions = {
+    minDuration?: number;
+    minDistance?: number;
+    getMousemoveTarget?: (event: MouseEvent) => HTMLElement;
+    onDown?: MousepressHook;
+    onMove?: MousepressHook;
+    onLeave?: MousepressHook;
+    onUp?: MousepressHook;
+};
+type MousepressHook = (api: MousepressHookApi) => any;
+type MousepressHookApi = HookApi<MousepressType, MousepressMetadata>;
+declare function createMousepress(options?: MousepressOptions): RecognizeableOptions<MousepressType, MousepressMetadata>['effects'];
+
+type MousereleaseType = 'mousedown' | 'mouseleave' | 'mouseup';
+type MousereleaseMetadata = PointerStartMetadata & PointerMoveMetadata & PointerTimeMetadata;
+type MousereleaseOptions = {
+    minDuration?: number;
+    minDistance?: number;
+    minVelocity?: number;
+    getMousemoveTarget?: (event: MouseEvent) => HTMLElement;
+    onDown?: MousereleaseHook;
+    onMove?: MousereleaseHook;
+    onLeave?: MousereleaseHook;
+    onUp?: MousereleaseHook;
+};
+type MousereleaseHook = (api: MousereleaseHookApi) => any;
+type MousereleaseHookApi = HookApi<MousereleaseType, MousereleaseMetadata>;
+declare function createMouserelease(options?: MousereleaseOptions): RecognizeableOptions<MousereleaseType, MousereleaseMetadata>['effects'];
+
+type TouchpressType = 'touchstart' | 'touchmove' | 'touchcancel' | 'touchend';
+type TouchpressMetadata = PointerStartMetadata & PointerMoveMetadata & PointerTimeMetadata;
+type TouchpressOptions = {
+    minDuration?: number;
+    minDistance?: number;
+    onStart?: TouchpressHook;
+    onMove?: TouchpressHook;
+    onCancel?: TouchpressHook;
+    onEnd?: TouchpressHook;
+};
+type TouchpressHook = (api: TouchpressHookApi) => any;
+type TouchpressHookApi = HookApi<TouchpressType, TouchpressMetadata>;
+declare function createTouchpress(options?: TouchpressOptions): RecognizeableOptions<TouchpressType, TouchpressMetadata>['effects'];
+
+type TouchreleaseType = 'touchstart' | 'touchmove' | 'touchcancel' | 'touchend';
+type TouchreleaseMetadata = PointerStartMetadata & PointerMoveMetadata & PointerTimeMetadata;
+type TouchreleaseOptions = {
+    minDuration?: number;
+    minDistance?: number;
+    minVelocity?: number;
+    onStart?: TouchreleaseHook;
+    onMove?: TouchreleaseHook;
+    onCancel?: TouchreleaseHook;
+    onEnd?: TouchreleaseHook;
+};
+type TouchreleaseHook = (api: TouchreleaseHookApi) => any;
+type TouchreleaseHookApi = HookApi<TouchreleaseType, TouchreleaseMetadata>;
+declare function createTouchrelease(options?: TouchreleaseOptions): RecognizeableOptions<TouchreleaseType, TouchreleaseMetadata>['effects'];
+
+type KeyStatusKey = {
+    key?: string;
+    code?: string;
+};
+
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+
+type CreatePredicateKeycomboDownOptions = {
+    toKey?: (alias: string) => KeyStatusKey;
+};
+
+type CreatePredicateKeycomboMatchOptions$1 = CreatePredicateKeycomboDownOptions & {
+    toAliases?: (key: KeyStatusKey) => string[];
+};
+
+type Direction = 'up' | 'upRight' | 'right' | 'downRight' | 'down' | 'downLeft' | 'left' | 'upLeft';
+
+type HookApi<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
+    status: RecognizeableStatus;
+    metadata: Metadata;
+    sequence: ListenEffectParam<Type>[];
+};
+
+type PolarCoordinates = {
+    distance: number;
+    angle: {
+        radians: number;
+        degrees: number;
+    };
+};
+
+type KeyboardTimeMetadata = {
+    times: {
+        start: number;
+        end: number;
+    };
+    duration: number;
+};
+
+type PointerStartMetadata = {
+    points: {
+        start: {
+            x: number;
+            y: number;
+        };
+        end: {
+            x: number;
+            y: number;
+        };
+    };
+};
+
+type PointerTimeMetadata = {
+    times: {
+        start: number;
+        end: number;
+    };
+    duration: number;
+    velocity: number;
+};
+
+type PointerMoveMetadata = {
+    distance: {
+        straight: {
+            fromStart: PolarCoordinates['distance'];
+            fromPrevious: PolarCoordinates['distance'];
+        };
+        horizontal: {
+            fromStart: PolarCoordinates['distance'];
+            fromPrevious: PolarCoordinates['distance'];
+        };
+        vertical: {
+            fromStart: PolarCoordinates['distance'];
+            fromPrevious: PolarCoordinates['distance'];
+        };
+    };
+    angle: {
+        fromPrevious: PolarCoordinates['angle'];
+        fromStart: PolarCoordinates['angle'];
+    };
+    direction: {
+        fromPrevious: Direction;
+        fromStart: Direction;
+    };
+};
+
+type Graph<Id extends string, Metadata> = {
+    nodes: GraphNode<Id>[];
+    edges: GraphEdge<Id, Metadata>[];
+};
+type GraphNode<Id extends string> = Id;
+type GraphEdge<Id extends string, Metadata> = {
+    from: Id;
+    to: Id;
+    predicateTraversable: (state: GraphState<Id, Metadata>) => boolean;
+};
+type GraphState<Id extends string, Metadata> = Record<Id, {
+    status: 'set' | 'unset';
+    metadata: Metadata;
+}>;
+type GraphStep<Id extends string, Metadata> = {
+    path: GraphNode<Id>[];
+    state: GraphState<Id, Metadata>;
+};
+type GraphCommonAncestor<Id extends string> = {
+    node: GraphNode<Id>;
+    distances: Record<GraphNode<Id>, number>;
+};
+type GraphTreeNode<Id extends string> = {
+    node: GraphNode<Id>;
+    children: GraphTreeNode<Id>[];
+};
+declare function defineGraph<Id extends string, Metadata>(nodes: GraphNode<Id>[], edges: GraphEdge<Id, Metadata>[]): {
+    nodes: Id[];
+    edges: GraphEdge<Id, Metadata>[];
+};
+declare function defineGraphNodes<Id extends string>(nodes: GraphNode<Id>[]): Id[];
+declare function defineGraphEdges<Id extends string, Metadata>(edges: GraphEdge<Id, Metadata>[]): GraphEdge<Id, Metadata>[];
+declare function defineGraphNode<Id extends string>(node: GraphNode<Id>): Id;
+declare function defineGraphEdge<Id extends string, Metadata>(from: GraphNode<Id>, to: GraphNode<Id>, predicateTraversable: (state: GraphState<Id, Metadata>) => boolean): {
+    from: Id;
+    to: Id;
+    predicateTraversable: (state: GraphState<Id, Metadata>) => boolean;
+};
+type AsyncGraph<Id extends string, Metadata> = {
+    nodes: GraphNode<Id>[];
+    edges: AsyncGraphEdge<Id, Metadata>[];
+};
+type AsyncGraphEdge<Id extends string, Metadata> = {
+    from: Id;
+    to: Id;
+    predicateTraversable: (metadata: GraphState<Id, Metadata>) => Promise<boolean>;
+};
+declare function defineAsyncGraph<Id extends string, Metadata>(nodes: GraphNode<Id>[], edges: AsyncGraphEdge<Id, Metadata>[]): {
+    nodes: Id[];
+    edges: AsyncGraphEdge<Id, Metadata>[];
+};
+declare function defineAsyncGraphEdges<Id extends string, Metadata>(edges: AsyncGraphEdge<Id, Metadata>[]): AsyncGraphEdge<Id, Metadata>[];
+declare function defineAsyncGraphEdge<Id extends string, Metadata>(from: GraphNode<Id>, to: GraphNode<Id>, predicateTraversable: (metadata: GraphState<Id, Metadata>) => Promise<boolean>): {
+    from: Id;
+    to: Id;
+    predicateTraversable: (metadata: GraphState<Id, Metadata>) => Promise<boolean>;
+};
+
+type GeneratorFn<Parameter, Yielded> = (param: Parameter) => Generator<Yielded>;
+
+type GraphFn<Id extends string, Metadata, Returned> = (graph: Graph<Id, Metadata>) => Returned;
+type GraphGeneratorFn<Id extends string, Metadata, Yielded> = GeneratorFn<Graph<Id, Metadata>, Yielded>;
+type GraphNodeFn<Id extends string, Returned> = (node: GraphNode<Id>) => Returned;
+type GraphNodeGeneratorFn<Id extends string, Yielded> = GeneratorFn<GraphNode<Id>, Yielded>;
+type GraphNodeTupleFn<Id extends string, Returned> = (...nodes: [GraphNode<Id>, GraphNode<Id>]) => Returned;
+type GraphNodeTupleGeneratorFn<Id extends string, Yielded> = (...nodes: [GraphNode<Id>, GraphNode<Id>]) => Generator<Yielded>;
+type GraphStateFn<Id extends string, Metadata, Returned> = (state: GraphState<Id, Metadata>) => Returned;
+declare function createToIndegree<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | AsyncGraph<Id, Metadata>>(graph: GraphType): GraphNodeFn<Id, number>;
+declare function createToOutdegree<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | AsyncGraph<Id, Metadata>>(graph: GraphType): GraphNodeFn<Id, number>;
+declare function createToIncoming<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | AsyncGraph<Id, Metadata>>(graph: GraphType): GraphNodeGeneratorFn<Id, GraphType extends AsyncGraph<Id, Metadata> ? AsyncGraphEdge<Id, Metadata> : GraphEdge<Id, Metadata>>;
+declare function createToOutgoing<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | AsyncGraph<Id, Metadata>>(graph: GraphType): GraphNodeGeneratorFn<Id, GraphType extends AsyncGraph<Id, Metadata> ? AsyncGraphEdge<Id, Metadata> : GraphEdge<Id, Metadata>>;
+declare function createPredicateRoot<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | AsyncGraph<Id, Metadata>>(graph: GraphType): GraphNodeFn<Id, boolean>;
+
+type AsyncGeneratorFn<Parameter, Yielded> = (param: Parameter) => AsyncGenerator<Yielded>;
+
+type AsyncGraphFn<Id extends string, Metadata, Returned> = (graph: AsyncGraph<Id, Metadata>) => Promise<Returned>;
+type AsyncGraphGeneratorFn<Id extends string, Metadata, Yielded> = GeneratorFn<AsyncGraph<Id, Metadata>, Yielded>;
+type AsyncGraphAsyncGeneratorFn<Id extends string, Metadata, Yielded> = AsyncGeneratorFn<AsyncGraph<Id, Metadata>, Yielded>;
+type GraphNodeAsyncGeneratorFn<Id extends string, Yielded> = AsyncGeneratorFn<GraphNode<Id>, Yielded>;
+type GraphNodeTupleAsyncFn<Id extends string, Returned> = (...nodes: [GraphNode<Id>, GraphNode<Id>]) => Promise<Returned>;
+type GraphNodeTupleAsyncGeneratorFn<Id extends string, Yielded> = (...nodes: [GraphNode<Id>, GraphNode<Id>]) => AsyncGenerator<Yielded>;
+type GraphStateAsyncFn<Id extends string, Metadata, Returned> = (state: GraphState<Id, Metadata>) => Promise<Returned>;
+
+declare function createToLayers$1<Id extends string, Metadata>(options?: {
+    createToSteps?: CreateToStepsOptions$2<Id, Metadata>;
+}): GraphFn<Id, Metadata, GraphNode<Id>[][]>;
+declare function createToTree$2<Id extends string, Metadata>(options?: {
+    createToSteps?: CreateToStepsOptions$2<Id, Metadata>;
+}): GraphFn<Id, Metadata, GraphTreeNode<Id>[]>;
+declare function createToCommonAncestors$2<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata>): GraphNodeTupleGeneratorFn<Id, GraphCommonAncestor<Id>>;
+declare function createPredicateAncestor$2<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata>): GraphNodeTupleFn<Id, boolean>;
+declare function createToNodeSteps$2<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata>, options?: {
+    createToSteps?: CreateToStepsOptions$2<Id, Metadata>;
+}): GraphNodeGeneratorFn<Id, GraphStep<Id, Metadata>>;
+type CreateToStepsOptions$2<Id extends string, Metadata> = {
+    root?: GraphNode<Id>;
+    toMockMetadata?: (node: GraphNode<Id>, totalConnectionsFollowed: number) => Metadata;
+    toUnsetMetadata?: (node: GraphNode<Id>) => Metadata;
+    kind?: 'directed acyclic' | 'arborescence';
+};
+declare function createToSteps$2<Id extends string, Metadata>(options?: CreateToStepsOptions$2<Id, Metadata>): GraphGeneratorFn<Id, Metadata, GraphStep<Id, Metadata>>;
+declare function createToPath$2<Id extends string, Metadata>(directedAcyclic: Graph<Id, Metadata>): GraphStateFn<Id, Metadata, GraphNode<Id>[]>;
+declare function createToRoots<Id extends string, Metadata, GraphType extends Graph<Id, Metadata> | AsyncGraph<Id, Metadata> = Graph<Id, Metadata>>(options?: {
+    kind?: 'directed acyclic' | 'arborescence';
+}): (GraphType extends AsyncGraph<Id, Metadata> ? AsyncGraphGeneratorFn<Id, Metadata, GraphNode<Id>> : GraphGeneratorFn<Id, Metadata, GraphNode<Id>>);
+
+declare function createToLayers<Id extends string, Metadata>(options?: {
+    createToSteps?: CreateToStepsOptions$2<Id, Metadata>;
+}): AsyncGraphFn<Id, Metadata, GraphNode<Id>[][]>;
+declare function createToTree$1<Id extends string, Metadata>(options?: {
+    createToSteps?: CreateToStepsOptions$1<Id, Metadata>;
+}): AsyncGraphFn<Id, Metadata, GraphTreeNode<Id>[]>;
+declare function createToCommonAncestors$1<Id extends string, Metadata>(directedAcyclic: AsyncGraph<Id, Metadata>): GraphNodeTupleAsyncGeneratorFn<Id, GraphCommonAncestor<Id>>;
+declare function createPredicateAncestor$1<Id extends string, Metadata>(directedAcyclic: AsyncGraph<Id, Metadata>): GraphNodeTupleAsyncFn<Id, boolean>;
+declare function createToNodeSteps$1<Id extends string, Metadata>(directedAcyclic: AsyncGraph<Id, Metadata>, options?: {
+    createToSteps?: CreateToStepsOptions$1<Id, Metadata>;
+}): GraphNodeAsyncGeneratorFn<Id, GraphStep<Id, Metadata>>;
+type CreateToStepsOptions$1<Id extends string, Metadata> = CreateToStepsOptions$2<Id, Metadata>;
+declare function createToSteps$1<Id extends string, Metadata>(options?: CreateToStepsOptions$1<Id, Metadata>): AsyncGraphAsyncGeneratorFn<Id, Metadata, GraphStep<Id, Metadata>>;
+declare function createToPath$1<Id extends string, Metadata>(directedAcyclic: AsyncGraph<Id, Metadata>): GraphStateAsyncFn<Id, Metadata, GraphNode<Id>[]>;
+
+type CreateToStepsOptions<Id extends string> = Expand<Pick<CreateToStepsOptions$2<Id, DecisionTreeMetadata>, 'kind'> & {
+    priorityBranch?: boolean;
+}>;
+type DecisionTree<Id extends string> = Graph<Id, DecisionTreeMetadata>;
+type DecisionTreeMetadata = boolean;
+declare function createToTree<Id extends string>(options?: {
+    createToSteps?: CreateToStepsOptions<Id>;
+}): GraphFn<Id, boolean, GraphTreeNode<Id>[]>;
+declare function createToCommonAncestors<Id extends string>(...params: Parameters<typeof createToCommonAncestors$2<Id, DecisionTreeMetadata>>): GraphNodeTupleGeneratorFn<Id, GraphCommonAncestor<Id>>;
+declare function createPredicateAncestor<Id extends string>(...params: Parameters<typeof createPredicateAncestor$2<Id, DecisionTreeMetadata>>): GraphNodeTupleFn<Id, boolean>;
+declare function createToNodeSteps<Id extends string>(decisionTree: DecisionTree<Id>, options?: {
+    createToSteps?: CreateToStepsOptions<Id>;
+}): GraphNodeGeneratorFn<Id, GraphStep<Id, boolean>>;
+declare function createToSteps<Id extends string>(options?: CreateToStepsOptions<Id>): GraphGeneratorFn<Id, boolean, GraphStep<Id, boolean>>;
+declare function createToPath<Id extends string>(...params: Parameters<typeof createToPath$2<Id, DecisionTreeMetadata>>): GraphStateFn<Id, boolean, Id[]>;
+
+type GraphTreeFn<Id extends string, Returned> = (tree: GraphTreeNode<Id>[]) => Returned;
+declare function createFind<Id extends string>(node: GraphNode<Id>): GraphTreeFn<Id, GraphTreeNode<Id>>;
+
+type ManyFn<Parameter, Returned> = (...params: Parameter[]) => Returned;
+
+declare function createList(): ManyFn<ClassValue, string>;
+
+type ToGraphYielded = {
+    node: GraphNode<string>;
+    edge: PartialGraphEdge | undefined;
+};
+type PartialGraphEdge = Omit<GraphEdge<string, unknown>, 'predicateTraversable'>;
+type CreateToGraphOptions<TreeNode> = {
+    toId?: (node: TreeNode) => string;
+    toChildren?: (node: TreeNode) => TreeNode[];
+};
+declare function createToGraph<TreeNode>(options?: CreateToGraphOptions<TreeNode>): GeneratorFn<TreeNode[], ToGraphYielded>;
+
+type KeyboardEventFn<Returned> = (keyboardEvent: KeyboardEvent) => Returned;
+type CreatePredicateKeycomboMatchOptions = {
+    toKey?: (alias: string) => KeyStatusKey;
+};
+declare const createPredicateKeycomboMatch: (keycombo: string, options?: CreatePredicateKeycomboMatchOptions) => KeyboardEventFn<boolean>;
 
-export { AnimateFrame, AnimateFrameEffect, AnimateOptions, Animateable, AnimateableKeyframe, AnimateableOptions, AnimateableStatus, ArrayFunction, ArrayFunctionAsync, Broadcastable, BroadcastableOptions, BroadcastableStatus, CompleteOptions, Completeable, CompleteableOptions, CompleteableStatus, Copyable, CopyableOptions, CopyableStatus, Delayable, DelayableEffect, DelayableOptions, DelayableStatus, Drawable, DrawableOptions, DrawableState, DrawableStatus, ElementFunction, EventFunction, FetchOptions, FetchOptionsApi, Fetchable, FetchableOptions, FetchableStatus, Fullscreenable, FullscreenableGetElement, FullscreenableOptions, FullscreenableStatus, Grantable, GrantableOptions, GrantableStatus, ListenEffect, ListenEffectParam, ListenOptions, Listenable, ListenableActive, ListenableKeycombo, ListenableMousecombo, ListenableOptions, ListenablePointercombo, ListenableStatus, ListenableSupportedEventType, ListenableSupportedType, MapFunction, Navigateable, NavigateableOptions, NavigateableStatus, NumberFunction, ObjectFunction, Pickable, PickableOptions, PickableStatus, Pipeable, RecognizeOptions, Recognizeable, RecognizeableEffect, RecognizeableOptions, RecognizeableStatus, Resolveable, ResolveableGetPromise, ResolveableOptions, ResolveableStatus, Sanitizeable, SanitizeableOptions, SanitizeableStatus, Searchable, SearchableOptions, SearchableStatus, Shareable, ShareableOptions, ShareableStatus, Storeable, StoreableOptions, StoreableStatus, StringFunction, createClamp, createClip, createConcat, createDetermine, createFilter, createFilterAsync, createForEachAsync, createInsert, createMap, createMapAsync, createMatchesKeycombo, createMatchesMousecombo, createMatchesPointercombo, createReduce, createReduceAsync, createRemove, createRename, createReorder, createReplace, createReverse, createSlice, createSlug, createSort, createSwap, createToEntries, createToEvery, createToFocusable, createToKeys, createToSome, createUnique, easingsNetInBack, easingsNetInCirc, easingsNetInCubic, easingsNetInExpo, easingsNetInOutBack, easingsNetInOutCirc, easingsNetInOutCubic, easingsNetInOutExpo, easingsNetInOutQuad, easingsNetInOutQuint, easingsNetInOutSine, easingsNetInQuad, easingsNetInQuart, easingsNetInQuint, easingsNetInSine, easingsNetOutBack, easingsNetOutCirc, easingsNetOutCubic, easingsNetOutExpo, easingsNetOutQuad, easingsNetOutQuint, easingsNetOutSine, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, toMessageListenParams, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };
+export { AnimateFrame, AnimateFrameEffect, AnimateOptions, Animateable, AnimateableKeyframe, AnimateableOptions, AnimateableStatus, AssociativeArray, AssociativeArrayEntries, AssociativeArrayOptions, AsyncGraph, AsyncGraphEdge, Broadcastable, BroadcastableOptions, BroadcastableStatus, Compareable, CompareableOptions, CompareableStatus, CompleteOptions, Completeable, CompleteableOptions, CompleteableStatus, Copyable, CopyableOptions, CopyableStatus, CreateToStepsOptions$1 as CreateAsyncDirectedAcyclicToStepsOptions, CreateToStepsOptions as CreateDecisionTreeToStepsOptions, CreateToStepsOptions$2 as CreateDirectedAcyclicToStepsOptions, CreatePredicateKeycomboMatchOptions, CreateFocusableOptions as CreateToFocusableOptions, CreateToGraphOptions, Delayable, DelayableEffect, DelayableOptions, DelayableStatus, Drawable, DrawableOptions, DrawableState, DrawableStatus, Fetchable, FetchableOptions, FetchableStatus, Fullscreenable, FullscreenableGetElement, FullscreenableOptions, FullscreenableStatus, Grantable, GrantableOptions, GrantableStatus, Graph, GraphCommonAncestor, GraphEdge, GraphNode, GraphState, GraphStep, GraphTreeNode, KeychordHook, KeychordHookApi, KeychordMetadata, KeychordOptions, KeychordType, KeypressHook, KeypressHookApi, KeypressMetadata, KeypressOptions, KeypressType, KeyreleaseHook, KeyreleaseHookApi, KeyreleaseMetadata, KeyreleaseOptions, KeyreleaseType, KonamiHook, KonamiHookApi, KonamiMetadata, KonamiOptions, KonamiType, ListenEffect, ListenEffectParam, ListenOptions, Listenable, ListenableActive, ListenableKeycombo, ListenableMousecombo, ListenableOptions, ListenablePointercombo, ListenableStatus, ListenableSupportedEventType, ListenableSupportedType, MousepressHook, MousepressHookApi, MousepressMetadata, MousepressOptions, MousepressType, MousereleaseHook, MousereleaseHookApi, MousereleaseMetadata, MousereleaseOptions, MousereleaseType, Navigateable, NavigateableOptions, NavigateableStatus, Pickable, PickableOptions, PickableStatus, Potentiality, RecognizeOptions, Recognizeable, RecognizeableEffect, RecognizeableOptions, RecognizeableStatus, Resolveable, ResolveableGetPromise, ResolveableOptions, ResolveableStatus, Sanitizeable, SanitizeableOptions, SanitizeableStatus, Searchable, SearchableOptions, SearchableStatus, Shareable, ShareableOptions, ShareableStatus, Storeable, StoreableOptions, StoreableStatus, ToGraphYielded, TouchpressHook, TouchpressHookApi, TouchpressMetadata, TouchpressOptions, TouchpressType, TouchreleaseHook, TouchreleaseHookApi, TouchreleaseMetadata, TouchreleaseOptions, TouchreleaseType, createAssociativeArray, createPredicateAncestor$1 as createAsyncDirectedAcyclicPredicateAncestor, createToCommonAncestors$1 as createAsyncDirectedAcyclicToCommonAncestors, createToLayers as createAsyncDirectedAcyclicToLayers, createToNodeSteps$1 as createAsyncDirectedAcyclicToNodeSteps, createToPath$1 as createAsyncDirectedAcyclicToPath, createToSteps$1 as createAsyncDirectedAcyclicToSteps, createToTree$1 as createAsyncDirectedAcyclicToTree, createClamp, createClip, createClone, createConcat, createPredicateAncestor as createDecisionTreePredicateAncestor, createToCommonAncestors as createDecisionTreeToCommonAncestors, createToNodeSteps as createDecisionTreeToNodeSteps, createToPath as createDecisionTreeToPath, createToSteps as createDecisionTreeToSteps, createToTree as createDecisionTreeToTree, createDetermine, createPredicateAncestor$2 as createDirectedAcyclicPredicateAncestor, createToCommonAncestors$2 as createDirectedAcyclicToCommonAncestors, createToLayers$1 as createDirectedAcyclicToLayers, createToNodeSteps$2 as createDirectedAcyclicToNodeSteps, createToPath$2 as createDirectedAcyclicToPath, createToRoots as createDirectedAcyclicToRoots, createToSteps$2 as createDirectedAcyclicToSteps, createToTree$2 as createDirectedAcyclicToTree, createEntries, createEqual, createEvery, createFilter, createFilterAsync, createFindAsync, createFindIndexAsync, createFocusable, createForEachAsync, createInsert, createKeychord, createKeypress, createKeyrelease, createKeys, createKonami, createList, createMap, createMapAsync, createMousepress, createMouserelease, createPredicateKeycomboMatch, createPredicateRoot, createReduce, createReduceAsync, createRemove, createRename, createReorder, createReplace, createReverse, createSlice, createSlug, createSome, createSort, createSwap, createToGraph, createToIncoming, createToIndegree, createToOutdegree, createToOutgoing, createTouchpress, createTouchrelease, createFind as createTreeFind, createUnique, defineAssociativeArrayEntries, defineAsyncGraph, defineAsyncGraphEdge, defineAsyncGraphEdges, defineGraph, defineGraphEdge, defineGraphEdges, defineGraphNode, defineGraphNodes, easingsNetInBack, easingsNetInCirc, easingsNetInCubic, easingsNetInExpo, easingsNetInOutBack, easingsNetInOutCirc, easingsNetInOutCubic, easingsNetInOutExpo, easingsNetInOutQuad, easingsNetInOutQuint, easingsNetInOutSine, easingsNetInQuad, easingsNetInQuart, easingsNetInQuint, easingsNetInSine, easingsNetOutBack, easingsNetOutCirc, easingsNetOutCubic, easingsNetOutExpo, easingsNetOutQuad, easingsNetOutQuint, easingsNetOutSine, linear, materialAccelerated, materialDecelerated, materialStandard, toD, toFlattenedD, toMessageListenParams, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };