@baleada/logic 0.22.3 → 0.22.5

package/lib/index.d.ts

@@ -3,22 +3,22 @@ import createDOMPurify, { Config } from 'dompurify';
 import { FullOptions, MatchData, Searcher } from 'fast-fuzzy';
 import { Options } from '@sindresorhus/slugify';
 
-declare type AnimateableKeyframe = {
+type AnimateableKeyframe = {
     progress: number;
     properties: {
         [key: string]: number | string | any[];
     };
     timing?: AnimateableTiming;
 };
-declare type AnimateableOptions = {
+type AnimateableOptions = {
     duration?: number;
     timing?: AnimateableTiming;
     iterations?: number | true;
     alternates?: boolean;
 };
-declare type AnimateableTiming = [number, number, number, number];
-declare type AnimateFrameEffect = (frame?: AnimateFrame) => any;
-declare type AnimateFrame = {
+type AnimateableTiming = [number, number, number, number];
+type AnimateFrameEffect = (frame?: AnimateFrame) => any;
+type AnimateFrame = {
     properties: {
         [key: string]: {
             progress: {
@@ -30,12 +30,12 @@ declare type AnimateFrame = {
     };
     timestamp: number;
 };
-declare type AnimateOptions = {
+type AnimateOptions = {
     interpolate?: {
         colorModel?: 'rgb' | 'hsl' | 'lab' | 'lch' | 'xyz';
     };
 };
-declare type AnimateableStatus = 'ready' | 'playing' | 'played' | 'reversing' | 'reversed' | 'paused' | 'sought' | 'stopped';
+type AnimateableStatus = 'ready' | 'playing' | 'played' | 'reversing' | 'reversed' | 'paused' | 'sought' | 'stopped';
 declare class Animateable {
     private initialDuration;
     private iterationLimit;
@@ -143,7 +143,176 @@ declare const easingsNetInBack: AnimateableKeyframe['timing'];
 declare const easingsNetOutBack: AnimateableKeyframe['timing'];
 declare const easingsNetInOutBack: AnimateableKeyframe['timing'];
 
-declare type CompleteableOptions = {
+type RecognizeableOptions<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
+    maxSequenceLength?: true | number;
+    effects?: {
+        [type in Type]?: RecognizeableEffect<type, Metadata>;
+    };
+};
+type RecognizeableEffect<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = (sequenceItem: ListenEffectParam<Type>, api: RecognizeableEffectApi<Type, Metadata>) => void;
+type RecognizeableEffectApi<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
+    getStatus: () => RecognizeableStatus;
+    getMetadata: () => Metadata;
+    setMetadata: (metadata: Metadata) => void;
+    recognized: () => void;
+    denied: () => void;
+    getSequence: () => ListenEffectParam<Type>[];
+    onRecognized: (sequenceItem: ListenEffectParam<Type>) => any;
+};
+type RecognizeableStatus = 'recognized' | 'recognizing' | 'denied' | 'ready';
+type RecognizeOptions<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
+    onRecognized?: (sequenceItem: ListenEffectParam<Type>) => any;
+};
+declare class Recognizeable<Type extends ListenableSupportedType, Metadata extends Record<any, any>> {
+    private maxSequenceLength;
+    private effects;
+    private effectApi;
+    constructor(sequence: ListenEffectParam<Type>[], options?: RecognizeableOptions<Type, Metadata>);
+    private computedMetadata;
+    private resetComputedMetadata;
+    private recognized;
+    private denied;
+    private computedStatus;
+    private ready;
+    get sequence(): ListenEffectParam<Type>[];
+    set sequence(sequence: ListenEffectParam<Type>[]);
+    get status(): RecognizeableStatus;
+    get metadata(): Metadata;
+    private computedSequence;
+    setSequence(sequence: ListenEffectParam<Type>[]): this;
+    recognize(sequenceItem: ListenEffectParam<Type>, { onRecognized }?: RecognizeOptions<Type, Metadata>): this;
+    private recognizing;
+    private toType;
+}
+
+type ListenableSupportedType = 'recognizeable' | 'intersect' | 'mutate' | 'resize' | 'idle' | 'message' | 'messageerror' | ListenableMediaQuery | keyof Omit<HTMLElementEventMap, 'resize'> | keyof Omit<DocumentEventMap, 'resize'>;
+type ListenableMediaQuery = `(${string})`;
+type ListenableMousecombo = `${string}+${ListenableLeftClick | ListenableRightClick}`;
+type ListenableLeftClick = 'click' | 'dblclick' | `mouse${string}`;
+type ListenableRightClick = 'rightclick' | 'contextmenu';
+type ListenablePointercombo = `${string}+${ListenablePointer}`;
+type ListenablePointer = `pointer${string}`;
+type ListenableKeycombo = string;
+type ListenableSupportedEventType = keyof Omit<HTMLElementEventMap, 'resize'> | keyof Omit<DocumentEventMap, 'resize'>;
+type ListenableOptions<Type extends ListenableSupportedType, RecognizeableMetadata extends Record<any, any> = Record<any, any>> = {
+    recognizeable?: RecognizeableOptions<Type, RecognizeableMetadata>;
+};
+type ListenEffect<Type extends ListenableSupportedType> = Type extends 'intersect' ? (entries: ListenEffectParam<Type>) => any : Type extends 'mutate' ? (records: ListenEffectParam<Type>) => any : Type extends 'resize' ? (entries: ListenEffectParam<Type>) => any : Type extends 'idle' ? (deadline: ListenEffectParam<Type>) => any : Type extends ('message' | 'messageerror') ? (event: MessageEvent) => any : Type extends ListenableMediaQuery ? (event: ListenEffectParam<Type>) => any : Type extends (ListenableLeftClick | ListenableRightClick) ? (event: ListenEffectParam<Type>) => any : Type extends (ListenablePointer) ? (event: ListenEffectParam<Type>) => any : Type extends ('keydown' | 'keyup') ? (event: ListenEffectParam<Type>) => any : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? (event: ListenEffectParam<Type>) => any : Type extends keyof Omit<DocumentEventMap, 'resize'> ? (event: ListenEffectParam<Type>) => any : never;
+type ListenEffectParam<Type extends ListenableSupportedType> = Type extends 'intersect' ? IntersectionObserverEntry[] : Type extends 'mutate' ? MutationRecord[] : Type extends 'resize' ? ResizeObserverEntry[] : Type extends 'idle' ? IdleDeadline : Type extends ListenableMediaQuery ? MediaQueryListEvent : Type extends ListenableRightClick ? MouseEvent : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? HTMLElementEventMap[Type] : Type extends keyof Omit<DocumentEventMap, 'resize'> ? DocumentEventMap[Type] : never;
+type ListenOptions<Type extends ListenableSupportedType> = Type extends 'intersect' ? {
+    observer?: IntersectionObserverInit;
+} & ObservationListenOptions : Type extends 'mutate' ? {
+    observe?: MutationObserverInit;
+} & ObservationListenOptions : Type extends 'resize' ? {
+    observe?: ResizeObserverOptions;
+} & ObservationListenOptions : Type extends 'idle' ? {
+    requestIdleCallback?: IdleRequestOptions;
+} : Type extends ('message' | 'messageerror') ? {
+    target?: BroadcastChannel;
+} : Type extends ListenableMediaQuery ? {
+    instantEffect?: (list: MediaQueryList) => any;
+} : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? EventListenOptions : Type extends keyof Omit<DocumentEventMap, 'resize'> ? EventListenOptions : never;
+type ObservationListenOptions = {
+    target?: Element;
+};
+type EventListenOptions = {
+    target?: Element | Document | (Window & typeof globalThis);
+    addEventListener?: AddEventListenerOptions;
+    useCapture?: boolean;
+    except?: string[];
+    only?: string[];
+};
+type ListenableActive<Type extends ListenableSupportedType, RecognizeableMetadata extends Record<any, any> = Record<any, any>> = Type extends 'intersect' ? {
+    target: Element;
+    id: IntersectionObserver;
+} : Type extends 'mutate' ? {
+    target: Element;
+    id: MutationObserver;
+} : Type extends 'resize' ? {
+    target: Element;
+    id: ResizeObserver;
+} : Type extends 'idle' ? {
+    target: Window & typeof globalThis;
+    id: number;
+} : Type extends ('message' | 'messageerror') ? {
+    target: BroadcastChannel;
+    id: [type: string, effect: (event: MessageEvent) => void];
+} : Type extends ListenableMediaQuery ? {
+    target: MediaQueryList;
+    id: [type: string, effect: (param: ListenEffectParam<Type>) => void];
+} : Type extends ListenableSupportedEventType ? {
+    target: Element | Document;
+    id: ListenableActiveEventId<Type>;
+} : {
+    id: Listenable<Type, RecognizeableMetadata>;
+};
+type ListenableActiveEventId<Type extends ListenableSupportedEventType> = [
+    type: Type,
+    exceptAndOnlyEffect: (param: ListenEffectParam<Type>) => void,
+    optionsOrUseCapture: AddEventListenerOptions | boolean
+];
+type ListenableStatus = 'ready' | 'listening' | 'stopped';
+declare class Listenable<Type extends ListenableSupportedType, RecognizeableMetadata extends Record<any, any> = Record<any, any>> {
+    private computedRecognizeable;
+    private recognizeableEffectsKeys;
+    private computedActive;
+    constructor(type: Type, options?: ListenableOptions<Type, RecognizeableMetadata>);
+    private computedStatus;
+    private ready;
+    get type(): string;
+    set type(type: string);
+    get status(): ListenableStatus;
+    get active(): Set<ListenableActive<Type, RecognizeableMetadata>>;
+    get recognizeable(): Recognizeable<Type, RecognizeableMetadata>;
+    private computedType;
+    private implementation;
+    setType(type: string): this;
+    listen(effect: ListenEffect<Type>, options?: ListenOptions<Type>): this;
+    private intersectionListen;
+    private mutationListen;
+    private resizeListen;
+    private mediaQueryListen;
+    private idleListen;
+    private messageListen;
+    private recognizeableListen;
+    private documentEventListen;
+    private eventListen;
+    private addEventListeners;
+    private listening;
+    stop(options?: {
+        target?: Element | Document | (Window & typeof globalThis);
+    }): this;
+    private stopped;
+}
+
+type BroadcastableOptions = {
+    name?: string;
+};
+type BroadcastableStatus = 'ready' | 'broadcasting' | 'broadcasted' | 'errored' | 'stopped';
+declare class Broadcastable<State> {
+    private name;
+    constructor(state: State, options?: BroadcastableOptions);
+    private computedStatus;
+    private ready;
+    get state(): State;
+    set state(state: State);
+    get status(): BroadcastableStatus;
+    private computedChannel;
+    get channel(): BroadcastChannel;
+    private computedError;
+    get error(): Error;
+    private computedState;
+    setState(state: State): this;
+    broadcast(): this;
+    private broadcasting;
+    private broadcasted;
+    private errored;
+    stop(): this;
+    private stopped;
+}
+declare function toMessageListenParams<State>(instance: Broadcastable<State>, effect: (event: MessageEvent<State>) => void): Parameters<Listenable<'message'>['listen']>;
+
+type CompleteableOptions = {
     segment?: {
         from?: 'start' | 'selection' | 'divider';
         to?: 'end' | 'selection' | 'divider';
@@ -155,8 +324,8 @@ declare type CompleteableOptions = {
         direction: 'forward' | 'backward' | 'none';
     };
 };
-declare type CompleteableStatus = 'constructing' | 'ready' | 'completing' | 'completed';
-declare type CompleteOptions = {
+type CompleteableStatus = 'constructing' | 'ready' | 'completing' | 'completed';
+type CompleteOptions = {
     select?: 'completion' | 'completionEnd' | (({ before, completion, after }: {
         before: string;
         completion: string;
@@ -210,8 +379,8 @@ declare class Completeable {
     private completed;
 }
 
-declare type CopyableOptions = Record<string, never>;
-declare type CopyableStatus = 'ready' | 'copying' | 'copied' | 'errored';
+type CopyableOptions = Record<never, never>;
+type CopyableStatus = 'ready' | 'copying' | 'copied' | 'errored';
 declare class Copyable {
     private computedIsClipboardText;
     private copyListenable;
@@ -236,16 +405,16 @@ declare class Copyable {
     private copying;
     private copied;
     private errored;
-    effectClipboardTextChanges(): void;
+    listenForClipboardEvents(): void;
     stop(): void;
 }
 
-declare type DelayableOptions = {
+type DelayableOptions = {
     delay?: number;
     executions?: number | true;
 };
-declare type DelayableEffect = (timestamp: number) => any;
-declare type DelayableStatus = 'ready' | 'delaying' | 'delayed' | 'paused' | 'sought' | 'stopped';
+type DelayableEffect = (timestamp: number) => any;
+type DelayableStatus = 'ready' | 'delaying' | 'delayed' | 'paused' | 'sought' | 'stopped';
 declare class Delayable {
     private animateable;
     constructor(effect: DelayableEffect, options?: DelayableOptions);
@@ -276,11 +445,11 @@ declare class Delayable {
     private stopped;
 }
 
-declare type DrawableState = ReturnType<typeof getStroke>;
-declare type DrawableOptions = {
+type DrawableState = ReturnType<typeof getStroke>;
+type DrawableOptions = {
     toD?: (stroke: DrawableState) => string;
 };
-declare type DrawableStatus = 'ready' | 'drawing' | 'drawn';
+type DrawableStatus = 'ready' | 'drawing' | 'drawn';
 declare class Drawable {
     private computedD;
     private toD;
@@ -300,9 +469,9 @@ declare class Drawable {
 declare function toD(stroke: number[][]): string;
 declare function toFlattenedD(stroke: number[][]): string;
 
-declare type ResolveableOptions = Record<string, never>;
-declare type ResolveableGetPromise<Value> = (...args: any[]) => (Promise<Value> | Promise<Value>[]);
-declare type ResolveableStatus = 'ready' | 'resolving' | 'resolved' | 'errored';
+type ResolveableOptions = Record<never, never>;
+type ResolveableGetPromise<Value> = (...args: any[]) => (Promise<Value> | Promise<Value>[]);
+type ResolveableStatus = 'ready' | 'resolving' | 'resolved' | 'errored';
 declare class Resolveable<Value> {
     constructor(getPromise: ResolveableGetPromise<Value>, options?: ResolveableOptions);
     private computedStatus;
@@ -320,9 +489,9 @@ declare class Resolveable<Value> {
     private errored;
 }
 
-declare type FetchableOptions = Record<string, never>;
-declare type FetchableStatus = 'ready' | 'fetching' | 'fetched' | 'aborted' | 'errored';
-declare type FetchOptions = RequestInit | ((api: FetchOptionsApi) => RequestInit);
+type FetchableOptions = Record<never, never>;
+type FetchableStatus = 'ready' | 'fetching' | 'fetched' | 'aborted' | 'errored';
+type FetchOptions = RequestInit | ((api: FetchOptionsApi) => RequestInit);
 declare class Fetchable {
     private computedArrayBuffer;
     private computedBlob;
@@ -339,17 +508,20 @@ declare class Fetchable {
     get status(): FetchableStatus;
     get response(): Response;
     get error(): Error;
-    get arrayBuffer(): Resolveable<ArrayBuffer> | Promise<Resolveable<ArrayBuffer>>;
-    get blob(): Resolveable<Blob> | Promise<Resolveable<Blob>>;
-    get formData(): Resolveable<FormData> | Promise<Resolveable<FormData>>;
-    get json(): Resolveable<any> | Promise<Resolveable<any>>;
-    get text(): Resolveable<string> | Promise<Resolveable<string>>;
-    private getUsedBody;
+    get arrayBuffer(): Resolveable<ArrayBuffer>;
+    get blob(): Resolveable<Blob>;
+    get formData(): Resolveable<FormData>;
+    get json(): Resolveable<any>;
+    get text(): Resolveable<string>;
     private computedResource;
     setResource(resource: string): this;
     private computedResponse;
     private computedError;
     fetch(options?: FetchOptions): Promise<this>;
+    private fetching;
+    private fetched;
+    private aborted;
+    private errored;
     get(options?: FetchOptions): Promise<this>;
     patch(options?: FetchOptions): Promise<this>;
     post(options?: FetchOptions): Promise<this>;
@@ -357,7 +529,7 @@ declare class Fetchable {
     delete(options?: FetchOptions): Promise<this>;
     abort(): this;
 }
-declare type FetchOptionsApi = {
+type FetchOptionsApi = {
     withJson: (data: Record<any, any>) => {
         body: string;
         headers: {
@@ -367,9 +539,9 @@ declare type FetchOptionsApi = {
     };
 };
 
-declare type FullscreenableOptions = Record<string, never>;
-declare type FullscreenableGetElement<ElementType> = ((...args: any[]) => ElementType);
-declare type FullscreenableStatus = 'ready' | 'fullscreened' | 'errored' | 'exited';
+type FullscreenableOptions = Record<never, never>;
+type FullscreenableGetElement<ElementType> = ((...args: any[]) => ElementType);
+type FullscreenableStatus = 'ready' | 'fullscreened' | 'errored' | 'exited';
 declare class Fullscreenable<ElementType extends Element> {
     constructor(getElement: FullscreenableGetElement<ElementType>, options?: FullscreenableOptions);
     private computedStatus;
@@ -390,8 +562,8 @@ declare class Fullscreenable<ElementType extends Element> {
     private exited;
 }
 
-declare type GrantableOptions = Record<string, never>;
-declare type GrantableStatus = 'ready' | 'querying' | 'queried' | 'errored';
+type GrantableOptions = Record<never, never>;
+type GrantableStatus = 'ready' | 'querying' | 'queried' | 'errored';
 declare class Grantable<DescriptorType extends PermissionDescriptor> {
     constructor(descriptor: DescriptorType, options?: GrantableOptions);
     private computedStatus;
@@ -409,160 +581,14 @@ declare class Grantable<DescriptorType extends PermissionDescriptor> {
     private errored;
 }
 
-declare type RecognizeableOptions<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
-    maxSequenceLength?: true | number;
-    effects?: {
-        [type in Type]?: RecognizeableEffect<type, Metadata>;
-    };
-};
-declare type RecognizeableEffect<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = (sequenceItem: ListenEffectParam<Type>, api: RecognizeableEffectApi<Type, Metadata>) => void;
-declare type RecognizeableEffectApi<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
-    getStatus: () => RecognizeableStatus;
-    getMetadata: () => Metadata;
-    setMetadata: (metadata: Metadata) => void;
-    recognized: () => void;
-    denied: () => void;
-    getSequence: () => ListenEffectParam<Type>[];
-    onRecognized: (sequenceItem: ListenEffectParam<Type>) => any;
-} & ListenEffectApi<Type>;
-declare type RecognizeableStatus = 'recognized' | 'recognizing' | 'denied' | 'ready';
-declare type RecognizeOptions<Type extends ListenableSupportedType, Metadata extends Record<any, any>> = {
-    onRecognized?: (sequenceItem: ListenEffectParam<Type>) => any;
-};
-declare class Recognizeable<Type extends ListenableSupportedType, Metadata extends Record<any, any>> {
-    private maxSequenceLength;
-    private effects;
-    private effectApi;
-    constructor(sequence: ListenEffectParam<Type>[], options?: RecognizeableOptions<Type, Metadata>);
-    private computedMetadata;
-    private resetComputedMetadata;
-    private recognized;
-    private denied;
-    private computedStatus;
-    private ready;
-    get sequence(): ListenEffectParam<Type>[];
-    set sequence(sequence: ListenEffectParam<Type>[]);
-    get status(): RecognizeableStatus;
-    get metadata(): Metadata;
-    private computedSequence;
-    setSequence(sequence: ListenEffectParam<Type>[]): this;
-    recognize(sequenceItem: ListenEffectParam<Type>, api: ListenEffectApi<Type>, { onRecognized }?: RecognizeOptions<Type, Metadata>): this;
-    private recognizing;
-    private toType;
-}
-
-declare type ListenableSupportedType = 'recognizeable' | 'intersect' | 'mutate' | 'resize' | 'idle' | ListenableMediaQuery | keyof Omit<HTMLElementEventMap, 'resize'> | keyof Omit<DocumentEventMap, 'resize'>;
-declare type ListenableMediaQuery = `(${string})`;
-declare type ListenableClickcombo = `${string}+${ListenableLeftClick | ListenableRightClick}`;
-declare type ListenableLeftClick = 'click' | 'dblclick' | `mouse${string}`;
-declare type ListenableRightClick = 'rightclick' | 'contextmenu';
-declare type ListenablePointercombo = `${string}+${ListenablePointer}`;
-declare type ListenablePointer = `pointer${string}`;
-declare type ListenableKeycombo = string;
-declare type ListenableSupportedEventType = keyof Omit<HTMLElementEventMap, 'resize'> | keyof Omit<DocumentEventMap, 'resize'>;
-declare type ListenableOptions<Type extends ListenableSupportedType, RecognizeableMetadata extends Record<any, any> = Record<any, any>> = {
-    recognizeable?: RecognizeableOptions<Type, RecognizeableMetadata>;
-};
-declare type ListenEffect<Type extends ListenableSupportedType> = Type extends 'intersect' ? (entries: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends 'mutate' ? (records: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends 'resize' ? (entries: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends 'idle' ? (deadline: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends ListenableMediaQuery ? (event: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends (ListenableLeftClick | ListenableRightClick) ? (event: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends (ListenablePointer) ? (event: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends ('keydown' | 'keyup') ? (event: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? (event: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : Type extends keyof Omit<DocumentEventMap, 'resize'> ? (event: ListenEffectParam<Type>, api: ListenEffectApi<Type>) => any : never;
-declare type ListenEffectParam<Type extends ListenableSupportedType> = Type extends 'intersect' ? IntersectionObserverEntry[] : Type extends 'mutate' ? MutationRecord[] : Type extends 'resize' ? ResizeObserverEntry[] : Type extends 'idle' ? IdleDeadline : Type extends ListenableMediaQuery ? MediaQueryListEvent : Type extends ListenableRightClick ? MouseEvent : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? HTMLElementEventMap[Type] : Type extends keyof Omit<DocumentEventMap, 'resize'> ? DocumentEventMap[Type] : never;
-declare type ListenEffectApi<Type extends ListenableSupportedType> = Type extends 'intersect' ? Record<never, never> : Type extends 'mutate' ? Record<never, never> : Type extends 'resize' ? Record<never, never> : Type extends 'idle' ? Record<never, never> : Type extends ListenableMediaQuery ? Record<never, never> : Type extends (ListenableLeftClick | ListenableRightClick) ? MouseEventApi : Type extends (ListenablePointer) ? PointerEventApi : Type extends ('keydown' | 'keyup') ? KeyboardEventApi : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? Record<never, never> : Type extends keyof Omit<DocumentEventMap, 'resize'> ? Record<never, never> : never;
-declare type MouseEventApi = {
-    is: (clickcombo: ListenableClickcombo) => boolean;
-};
-declare type PointerEventApi = {
-    is: (pointercombo: ListenablePointercombo) => boolean;
-};
-declare type KeyboardEventApi = {
-    is: (keycombo: ListenableKeycombo) => boolean;
-};
-declare type ListenOptions<Type extends ListenableSupportedType> = Type extends 'intersect' ? {
-    observer?: IntersectionObserverInit;
-} & ObservationListenOptions : Type extends 'mutate' ? {
-    observe?: MutationObserverInit;
-} & ObservationListenOptions : Type extends 'resize' ? {
-    observe?: ResizeObserverOptions;
-} & ObservationListenOptions : Type extends 'idle' ? {
-    requestIdleCallback?: IdleRequestOptions;
-} : Type extends ListenableMediaQuery ? {
-    instantEffect?: (list: MediaQueryList) => any;
-} : Type extends keyof Omit<HTMLElementEventMap, 'resize'> ? EventListenOptions : Type extends keyof Omit<DocumentEventMap, 'resize'> ? EventListenOptions : never;
-declare type ObservationListenOptions = {
-    target?: Element;
-};
-declare type EventListenOptions = {
-    target?: Element | Document | (Window & typeof globalThis);
-    addEventListener?: AddEventListenerOptions;
-    useCapture?: boolean;
-    except?: string[];
-    only?: string[];
-};
-declare type ListenableActive<Type extends ListenableSupportedType, RecognizeableMetadata extends Record<any, any> = Record<any, any>> = Type extends 'intersect' ? {
-    target: Element;
-    id: IntersectionObserver;
-} : Type extends 'mutate' ? {
-    target: Element;
-    id: MutationObserver;
-} : Type extends 'resize' ? {
-    target: Element;
-    id: ResizeObserver;
-} : Type extends 'idle' ? {
-    target: Window & typeof globalThis;
-    id: number;
-} : Type extends ListenableMediaQuery ? {
-    target: MediaQueryList;
-    id: [type: string, effect: (param: ListenEffectParam<Type>) => void];
-} : Type extends ListenableSupportedEventType ? {
-    target: Element | Document;
-    id: ListenableActiveEventId<Type>;
-} : {
-    id: Listenable<Type, RecognizeableMetadata>;
-};
-declare type ListenableActiveEventId<Type extends ListenableSupportedEventType> = [
-    type: string,
-    exceptAndOnlyEffect: (param: ListenEffectParam<Type>) => void,
-    optionsOrUseCapture: AddEventListenerOptions | boolean
-];
-declare type ListenableStatus = 'ready' | 'listening' | 'stopped';
-declare class Listenable<Type extends ListenableSupportedType, RecognizeableMetadata extends Record<any, any> = Record<any, any>> {
-    private computedRecognizeable;
-    private recognizeableEffectsKeys;
-    private computedActive;
-    constructor(type: Type, options?: ListenableOptions<Type, RecognizeableMetadata>);
-    private computedStatus;
-    private ready;
-    get type(): string;
-    set type(type: string);
-    get status(): ListenableStatus;
-    get active(): Set<ListenableActive<Type, RecognizeableMetadata>>;
-    get recognizeable(): Recognizeable<Type, RecognizeableMetadata>;
-    private computedType;
-    private implementation;
-    setType(type: string): this;
-    listen(effect: ListenEffect<Type>, options?: ListenOptions<Type>): this;
-    private intersectionListen;
-    private mutationListen;
-    private resizeListen;
-    private mediaQueryListen;
-    private idleListen;
-    private recognizeableListen;
-    private documentEventListen;
-    private eventListen;
-    private addEventListeners;
-    private listening;
-    stop(options?: {
-        target?: Element | Document | (Window & typeof globalThis);
-    }): this;
-    private stopped;
-}
-
-declare type NavigateableOptions = {
+type NavigateableOptions = {
     initialLocation?: number;
 };
-declare type NavigateableStatus = 'ready' | 'navigated' | 'navigated to next' | 'navigated to previous' | 'navigated to random' | 'navigated to first' | 'navigated to last';
-declare type NavigateOptions = {
+type NavigateableStatus = 'ready' | 'navigated' | 'navigated to next' | 'navigated to previous' | 'navigated to random' | 'navigated to first' | 'navigated to last';
+type NavigateOptions = {
     allow?: 'possible' | 'any';
 };
-declare type NextAndPreviousOptions = {
+type NextAndPreviousOptions = {
     distance?: number;
     loops?: boolean;
 };
@@ -595,11 +621,11 @@ declare class Navigateable<Item> {
     private lasted;
 }
 
-declare type PickableOptions = {
+type PickableOptions = {
     initialPicks?: number | number[];
 };
-declare type PickableStatus = 'ready' | 'picked' | 'omitted';
-declare type PickOptions = {
+type PickableStatus = 'ready' | 'picked' | 'omitted';
+type PickOptions = {
     replace?: 'none' | 'all' | 'fifo' | 'lifo';
     allowsDuplicates?: boolean;
 };
@@ -635,8 +661,8 @@ declare class Pickable<Item> {
     private omitted;
 }
 
-declare type SanitizeableOptions = Config;
-declare type SanitizeableStatus = 'ready' | 'sanitized';
+type SanitizeableOptions = Config;
+type SanitizeableStatus = 'ready' | 'sanitized';
 declare class Sanitizeable {
     private domPurifyConfig;
     constructor(html: string, options?: Config);
@@ -653,8 +679,8 @@ declare class Sanitizeable {
     private sanitized;
 }
 
-declare type SearchableOptions<Item> = FullOptions<Item>;
-declare type SearchableStatus = 'ready' | 'searched';
+type SearchableOptions<Item> = FullOptions<Item>;
+type SearchableStatus = 'ready' | 'searched';
 declare class Searchable<Item extends string | object> {
     private searcherOptions;
     private computedResults;
@@ -673,12 +699,33 @@ declare class Searchable<Item extends string | object> {
     private searched;
 }
 
-declare type StoreableOptions = {
+type ShareableOptions = Record<never, never>;
+type ShareableStatus = 'ready' | 'sharing' | 'shared' | 'errored';
+declare class Shareable {
+    constructor(state: ShareData, options?: ShareableOptions);
+    private computedStatus;
+    private ready;
+    get state(): ShareData;
+    set state(state: ShareData);
+    get status(): ShareableStatus;
+    private computedCan;
+    get can(): Resolveable<boolean>;
+    private computedError;
+    get error(): Error;
+    private computedState;
+    setState(state: ShareData): this;
+    share(): Promise<this>;
+    private sharing;
+    private shared;
+    private errored;
+}
+
+type StoreableOptions = {
     kind?: 'local' | 'session';
     statusKeySuffix?: string;
 };
-declare type StoreableStatus = 'ready' | 'constructing' | 'stored' | 'errored' | 'removed';
-declare class Storeable {
+type StoreableStatus = 'ready' | 'constructing' | 'stored' | 'errored' | 'removed';
+declare class Storeable<String extends string> {
     private kind;
     private statusKeySuffix;
     constructor(key: string, options?: StoreableOptions);
@@ -689,14 +736,14 @@ declare class Storeable {
     set key(key: string);
     get status(): StoreableStatus;
     get storage(): Storage;
-    get string(): string;
+    get string(): String;
     get error(): Error;
     private computedKey;
     private computedStatusKey;
     setKey(key: string): this;
     private computedString;
     private computedError;
-    store(string: string): this;
+    store(string: String): this;
     private stored;
     private errored;
     private storeStatus;
@@ -705,14 +752,14 @@ declare class Storeable {
     removeStatus(): this;
 }
 
-declare function createReduceAsync<Item, Accumulator>(accumulate: (accumulator?: Accumulator, item?: Item, index?: number) => Promise<Accumulator>, initialValue?: Accumulator): (array: Item[]) => Promise<Accumulator>;
-declare function createReduce<Item, Accumulator>(accumulate: (accumulator?: Accumulator, item?: Item, index?: number) => Accumulator, initialValue?: Accumulator): (array: Item[]) => Accumulator;
-declare 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>(condition: (item?: Item, index?: number) => Promise<boolean>): ArrayFunctionAsync<Item, Item[]>;
-declare type ArrayFunction<Item, Returned> = (array: Item[]) => Returned;
-declare function createDelete<Item>(index: number): ArrayFunction<Item, Item[]>;
+declare function createReduceAsync<Item, Accumulator>(accumulate: (accumulator: Accumulator, item: Item, index: number) => Promise<Accumulator>, initialValue?: Accumulator): (array: Item[]) => Promise<Accumulator>;
+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>(condition: (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 createReorder<Item>(from: {
     start: number;
@@ -722,25 +769,31 @@ declare function createSwap<Item>(indices: [number, number]): ArrayFunction<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>(condition: (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 createFilter<Item>(condition: (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[]>;
-declare type StringFunction<Returned> = (string: string) => Returned;
+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>;
-declare type NumberFunction<Returned> = (number: number) => Returned;
+type NumberFunction<Returned> = (number: number) => Returned;
 declare function createClamp(min: number, max: number): NumberFunction<number>;
-declare type Potentiality<Outcome> = {
+type Potentiality<Outcome> = {
     outcome: Outcome;
     probability: number;
 };
 declare function createDetermine<Outcome>(potentialities: Potentiality<Outcome>[]): NumberFunction<Outcome>;
-declare type MapFunction<Key, Value, Returned> = (transform: Map<Key, Value>) => Returned;
+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>>;
-declare type ObjectFunction<Key extends string | number | symbol, Value, Returned> = (transform: Record<Key, Value>) => Returned;
+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][]>;
+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);
@@ -748,4 +801,4 @@ declare class Pipeable {
     pipeAsync(...fns: ((...args: any[]) => Promise<any>)[]): Promise<any>;
 }
 
-export { AnimateFrame, AnimateFrameEffect, AnimateOptions, Animateable, AnimateableKeyframe, AnimateableOptions, AnimateableStatus, ArrayFunction, ArrayFunctionAsync, CompleteOptions, Completeable, CompleteableOptions, CompleteableStatus, Copyable, CopyableOptions, CopyableStatus, Delayable, DelayableEffect, DelayableOptions, DelayableStatus, Drawable, DrawableOptions, DrawableState, DrawableStatus, FetchOptions, FetchOptionsApi, Fetchable, FetchableOptions, FetchableStatus, Fullscreenable, FullscreenableGetElement, FullscreenableOptions, FullscreenableStatus, Grantable, GrantableOptions, GrantableStatus, ListenEffect, ListenEffectParam, ListenOptions, Listenable, ListenableActive, ListenableClickcombo, ListenableKeycombo, 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, Storeable, StoreableOptions, StoreableStatus, StringFunction, createClamp, createClip, createConcat, createDelete, createDetermine, createFilter, createFilterAsync, createForEachAsync, createInsert, createMap, createMapAsync, createReduce, createReduceAsync, createRename, createReorder, createReplace, createReverse, createSlice, createSlug, createSort, createSwap, createToEntries, 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, verouEase, verouEaseIn, verouEaseInOut, verouEaseOut };
+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, createToFocusable, 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 };