@esportsplus/ui 0.56.3 → 0.57.0

package/build/css-utilities/skeleton/scss/index.scss

@@ -1,2 +1,2 @@
-@layer css-utilities {.--skeleton{--animation-duration:4.8s;animation:var(--animation-duration) linear infinite skeleton;background-image:linear-gradient(270deg, var(--from), var(--to), var(--to), var(--from));color:#0000;pointer-events:none;background-size:400% 100%}.--skeleton *{opacity:0}@keyframes skeleton{0%{background-position:200% 0}to{background-position:-200% 0}}}
+@layer css-utilities{.--skeleton{--animation-duration:4.8s;animation:var(--animation-duration) linear infinite skeleton;background-image:linear-gradient(270deg, var(--from), var(--to), var(--to), var(--from));color:#0000;pointer-events:none;background-size:400% 100%}.--skeleton *{opacity:0}@keyframes skeleton{0%{background-position:200% 0}to{background-position:-200% 0}}}
 /*$vite$:1*/

package/build/css-utilities/text/scss/index.scss

@@ -1,2 +1,2 @@
-@layer css-utilities {@supports (text-box:trim-both cap alphabetic){.--text-crop{text-box:trim-both cap alphabetic}.--text-crop-top,.--text-crop-first-child:first-child{text-box:trim-start cap alphabetic}.--text-crop-bottom,.--text-crop-last-child:last-child{text-box:trim-end cap alphabetic}}@supports not (text-box:trim-both cap alphabetic){.--text-crop:after,.--text-crop:before,.--text-crop-bottom:after,.--text-crop-last-child:last-child:after,.--text-crop-top:before,.--text-crop-first-child:first-child:before{content:"";width:100%;height:0;display:block}.--text-crop:after,.--text-crop-bottom:after,.--text-crop-last-child:last-child:after{margin-bottom:calc(.618em - .618lh)}.--text-crop:before,.--text-crop-top:before,.--text-crop-first-child:first-child:before{margin-top:calc(.618em - .618lh)}}.--text-truncate{text-overflow:ellipsis;white-space:nowrap;max-width:100%;overflow:hidden}}
+@layer css-utilities{.--text-truncate{text-overflow:ellipsis;white-space:nowrap;max-width:100%;overflow:hidden}.--text-gradient{--color-from:#ffaa40;--color-to:#9c40ff;--duration:8s;--speed:1}.--text-line-shadow{--duration:15s;--line-size:.06em;--offset:.04em;--shadow-color:var(--color-text-500)}.--text-shiny{--shine-color:oklch(from var(--color-black-300) l c h / .8);--shine-duration:8s;--shine-text-color:oklch(from var(--color-text-300) l c h / .7);--shine-width:100px}@supports (text-box:trim-both cap alphabetic){.--text-crop{text-box:trim-both cap alphabetic}.--text-crop-top,.--text-crop-first-child:first-child{text-box:trim-start cap alphabetic}.--text-crop-bottom,.--text-crop-last-child:last-child{text-box:trim-end cap alphabetic}}@supports not (text-box:trim-both cap alphabetic){.--text-crop:after,.--text-crop:before,.--text-crop-bottom:after,.--text-crop-last-child:last-child:after,.--text-crop-top:before,.--text-crop-first-child:first-child:before{content:"";width:100%;height:0;display:block}.--text-crop:after,.--text-crop-bottom:after,.--text-crop-last-child:last-child:after{margin-bottom:calc(.618em - .618lh)}.--text-crop:before,.--text-crop-top:before,.--text-crop-first-child:first-child:before{margin-top:calc(.618em - .618lh)}}.--text-gradient{--background-size:calc(var(--speed) * 300%);animation:text-gradient var(--duration) linear infinite;-webkit-background-clip:text;background-clip:text;background-image:linear-gradient(to right, var(--color-from), var(--color-to), var(--color-from));background-size:var(--background-size) 100%;color:#0000}@media (prefers-reduced-motion:reduce){.--text-gradient{animation:none}}.--text-line-shadow{z-index:0;display:inline-flex;position:relative}.--text-line-shadow:after{animation:text-line-shadow var(--duration) linear infinite;-webkit-background-clip:text;background-clip:text;background-image:linear-gradient(45deg, transparent 45%, var(--shadow-color) 45%, var(--shadow-color) 55%, transparent 0);background-size:var(--line-size) var(--line-size);color:#0000;content:attr(data-text);left:var(--offset);pointer-events:none;top:var(--offset);z-index:-1;position:absolute}@media (prefers-reduced-motion:reduce){.--text-line-shadow:after{animation:none}}.--text-shiny{animation:text-shiny var(--shine-duration) infinite;-webkit-background-clip:text;background-clip:text;background-image:linear-gradient(to right, transparent, var(--shine-color) 50%, transparent);background-position:0 0;background-repeat:no-repeat;background-size:var(--shine-width) 100%;color:var(--shine-text-color)}@media (prefers-reduced-motion:reduce){.--text-shiny{background-image:none;animation:none}}@keyframes text-gradient{to{background-position:var(--background-size) 0}}@keyframes text-line-shadow{0%{background-position:0 0}to{background-position:100% -100%}}@keyframes text-shiny{0%,90%,to{background-position:calc(-100% - var(--shine-width)) 0}30%,60%{background-position:calc(100% + var(--shine-width)) 0}}}
 /*$vite$:1*/

package/build/css-utilities/theme/index.d.ts

@@ -0,0 +1,16 @@
+type Mode = 'dark' | 'light';
+type Preference = Mode | 'system';
+type Store = {
+    delete(...keys: (typeof KEY)[]): Promise<void>;
+    get(key: typeof KEY): Promise<unknown>;
+    set(key: typeof KEY, value: Preference): Promise<boolean>;
+};
+declare const KEY = "theme";
+export default _default;
+declare function _default(store?: Store): {
+    readonly class: string;
+    readonly mode: Mode;
+    readonly preference: Preference;
+    set(preference: Preference): void;
+};
+export type { Mode, Preference, Store };

package/build/css-utilities/theme/index.js

@@ -0,0 +1,60 @@
+import * as reactivity_u0 from '@esportsplus/reactivity';
+class ReactiveObject_1grmkcs0 extends reactivity_u0.ReactiveObject {
+    #preference;
+    #system;
+    constructor(_p0, _p1) {
+        super(null);
+        this.#preference = this[reactivity_u0.SIGNAL](_p0);
+        this.#system = this[reactivity_u0.SIGNAL](_p1);
+    }
+    get preference() {
+        return reactivity_u0.read(this.#preference);
+    }
+    set preference(_v0) {
+        reactivity_u0.write(this.#preference, _v0);
+    }
+    get system() {
+        return reactivity_u0.read(this.#system);
+    }
+    set system(_v1) {
+        reactivity_u0.write(this.#system, _v1);
+    }
+}
+const KEY = 'theme';
+const PREFERENCES = ['dark', 'light', 'system'];
+const QUERY = '(prefers-color-scheme: dark)';
+function system(dark) {
+    return dark ? 'dark' : 'light';
+}
+export default (store) => {
+    let media = matchMedia(QUERY), state = new ReactiveObject_1grmkcs0('system', system(media.matches)), touched = false;
+    media.addEventListener('change', (event) => {
+        state.system = system(event.matches);
+    });
+    store?.get(KEY).then((value) => {
+        if (!touched && PREFERENCES.includes(value)) {
+            state.preference = value;
+        }
+    }, () => { });
+    return {
+        get class() {
+            return `--theme-${this.mode}`;
+        },
+        get mode() {
+            return state.preference === 'system' ? state.system : state.preference;
+        },
+        get preference() {
+            return state.preference;
+        },
+        set(preference) {
+            touched = true;
+            state.preference = preference;
+            if (preference === 'system') {
+                void store?.delete(KEY);
+            }
+            else {
+                void store?.set(KEY, preference);
+            }
+        }
+    };
+};

package/build/normalize/scss/index.scss

@@ -0,0 +1,3 @@
+/*! modern-normalize v3.0.1 | MIT License | https://github.com/sindresorhus/modern-normalize */
+@layer normalize{*,:before,:after{box-sizing:border-box}html{-webkit-text-size-adjust:100%;tab-size:4;font-family:system-ui,Segoe UI,Roboto,Helvetica,Arial,sans-serif,Apple Color Emoji,Segoe UI Emoji;line-height:1.15}body{margin:0}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:ui-monospace,SFMono-Regular,Consolas,Liberation Mono,Menlo,monospace;font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{border-color:currentColor}button,input,optgroup,select,textarea{margin:0;font-family:inherit;font-size:100%;line-height:1.15}button,[type=button],[type=reset],[type=submit]{-webkit-appearance:button}legend{padding:0}progress{vertical-align:baseline}::-webkit-inner-spin-button{height:auto}::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}summary{display:list-item}button,input,select,textarea{font-family:inherit;font-size:inherit;background:0 0;border:0;border-radius:0;margin:0;padding:0}button,button:active,button:focus,button:hover,input,input:active,input:focus,input:hover,select,select:active,select:focus,select:hover,textarea,textarea:active,textarea:focus,textarea:hover{outline:none}button:invalid,input:invalid,select:invalid,textarea:invalid{box-shadow:none}code,kbd,pre,samp{font-family:var(--font-family-mono)}form{width:100%;margin:0;padding:0}label{cursor:pointer}}
+/*$vite$:1*/

package/build/shared/anchor.d.ts

@@ -0,0 +1,7 @@
+type Edge = {
+    x: -1 | 0 | 1;
+    y: -1 | 0 | 1;
+};
+declare const edge: (element: Element, block: string) => Edge | undefined;
+export { edge };
+export type { Edge };

package/build/shared/anchor.js

@@ -0,0 +1,18 @@
+const EDGES = {
+    e: { x: 1, y: 0 },
+    n: { x: 0, y: -1 },
+    ne: { x: 1, y: -1 },
+    nw: { x: -1, y: -1 },
+    s: { x: 0, y: 1 },
+    se: { x: 1, y: 1 },
+    sw: { x: -1, y: 1 },
+    w: { x: -1, y: 0 }
+};
+const edge = (element, block) => {
+    for (let key in EDGES) {
+        if (element.classList.contains(`${block}--${key}`)) {
+            return EDGES[key];
+        }
+    }
+};
+export { edge };

package/build/shared/animation.d.ts

@@ -0,0 +1,6 @@
+declare const finished: (element: HTMLElement, options?: GetAnimationsOptions) => Promise<PromiseSettledResult<Animation>[]>;
+declare const measure: (elements: Iterable<Element>) => void;
+declare const ms: (value: string) => number;
+declare const slides: <T extends Element>(elements: ArrayLike<T>, timing: KeyframeAnimationOptions | null, enter?: (element: T) => void) => DOMRect[];
+declare const timing: (computed: CSSStyleDeclaration, name: string) => KeyframeAnimationOptions | null;
+export { finished, measure, ms, slides, timing };

package/build/shared/animation.js

@@ -0,0 +1,57 @@
+const FROM = Symbol();
+const SLIDE = Symbol();
+const finished = (element, options) => {
+    let animations = element.getAnimations(options), pending = [];
+    for (let i = 0, n = animations.length; i < n; i++) {
+        if (animations[i].effect?.getComputedTiming().endTime !== Infinity) {
+            pending.push(animations[i].finished);
+        }
+    }
+    return Promise.allSettled(pending);
+};
+const measure = (elements) => {
+    for (let element of elements) {
+        element[FROM] = element.getBoundingClientRect();
+    }
+};
+const ms = (value) => {
+    let n = parseFloat(value);
+    return isNaN(n) ? 0 : value.trim().endsWith('ms') ? n : n * 1000;
+};
+const slides = (elements, timing, enter) => {
+    let froms = [], n = elements.length, options = timing && { ...timing, composite: 'add' }, tos = [];
+    for (let i = 0; i < n; i++) {
+        let element = elements[i], from = element[FROM];
+        element[FROM] = undefined;
+        froms.push(from);
+        if (from) {
+            element[SLIDE]?.cancel();
+        }
+    }
+    for (let i = 0; i < n; i++) {
+        tos.push(elements[i].getBoundingClientRect());
+    }
+    for (let i = 0; i < n; i++) {
+        let from = froms[i], to = tos[i];
+        if (!from || !options) {
+            continue;
+        }
+        let x = from.left - to.left, y = from.top - to.top;
+        if (Math.abs(x) >= 0.5 || Math.abs(y) >= 0.5) {
+            elements[i][SLIDE] = elements[i].animate([{ translate: `${x}px ${y}px` }, { translate: '0px 0px' }], options);
+        }
+    }
+    if (enter) {
+        for (let i = 0; i < n; i++) {
+            if (!froms[i]) {
+                enter(elements[i]);
+            }
+        }
+    }
+    return tos;
+};
+const timing = (computed, name) => {
+    let duration = ms(computed.getPropertyValue(`--${name}-duration`));
+    return duration ? { duration, easing: computed.getPropertyValue(`--${name}-easing`).trim() || 'ease' } : null;
+};
+export { finished, measure, ms, slides, timing };

package/build/shared/clamp.d.ts

@@ -0,0 +1,2 @@
+declare const clamp: (value: number, min: number, max: number) => number;
+export { clamp };

package/build/shared/clamp.js

@@ -0,0 +1,4 @@
+const clamp = (value, min, max) => {
+    return Math.min(Math.max(value, min), max);
+};
+export { clamp };

package/build/shared/deadline.d.ts

@@ -0,0 +1,2 @@
+declare const deadline: (at: number, callback: VoidFunction) => () => void;
+export { deadline };

package/build/shared/deadline.js

@@ -0,0 +1,94 @@
+const MAX_TIMEOUT = 2 ** 31 - 1;
+let armed = Infinity, flushing = false, heap = [], timer;
+function arm() {
+    let next = heap[0]?.at ?? Infinity;
+    if (flushing || next === armed) {
+        return;
+    }
+    clearTimeout(timer);
+    armed = next;
+    timer = next === Infinity ? undefined : setTimeout(flush, Math.min(Math.max(next - Date.now(), 0), MAX_TIMEOUT));
+}
+function flush() {
+    let due = [], now = Date.now();
+    armed = Infinity;
+    flushing = true;
+    timer = undefined;
+    while (heap.length && heap[0].at <= now) {
+        due.push(remove(heap[0]));
+    }
+    for (let i = 0, n = due.length; i < n; i++) {
+        let entry = due[i];
+        if (!entry.pending) {
+            continue;
+        }
+        entry.pending = false;
+        try {
+            entry.callback();
+        }
+        catch (error) {
+            reportError(error);
+        }
+    }
+    flushing = false;
+    arm();
+}
+function remove(entry) {
+    let last = heap.pop();
+    if (last !== entry) {
+        heap[entry.index] = last;
+        last.index = entry.index;
+        sift(last);
+    }
+    entry.index = -1;
+    return entry;
+}
+function sift(entry) {
+    let i = entry.index;
+    while (i > 0) {
+        let parent = (i - 1) >> 1;
+        if (heap[parent].at <= entry.at) {
+            break;
+        }
+        swap(i, parent);
+        i = parent;
+    }
+    for (let n = heap.length;;) {
+        let left = 2 * i + 1, right = left + 1, least = i;
+        if (left < n && heap[left].at < heap[least].at) {
+            least = left;
+        }
+        if (right < n && heap[right].at < heap[least].at) {
+            least = right;
+        }
+        if (least === i) {
+            break;
+        }
+        swap(i, least);
+        i = least;
+    }
+}
+function swap(a, b) {
+    let entry = heap[a];
+    heap[a] = heap[b];
+    heap[b] = entry;
+    heap[a].index = a;
+    heap[b].index = b;
+}
+const deadline = (at, callback) => {
+    let entry = { at, callback, index: heap.length, pending: true };
+    heap.push(entry);
+    sift(entry);
+    arm();
+    return () => {
+        if (!entry.pending) {
+            return;
+        }
+        entry.pending = false;
+        if (entry.index !== -1) {
+            remove(entry);
+            arm();
+        }
+    };
+};
+export { deadline };

package/build/shared/dismiss.d.ts

@@ -0,0 +1,2 @@
+export default _default;
+declare function _default(open: () => boolean, close: VoidFunction): (this: HTMLElement, e: MouseEvent) => void;

package/build/shared/dismiss.js

@@ -0,0 +1,5 @@
+export default (open, close) => function (e) {
+    if (open() && !this.contains(e.target)) {
+        close();
+    }
+};

package/build/shared/drag.d.ts

@@ -0,0 +1,47 @@
+type Direction = {
+    axis: 'x' | 'y';
+    sign: -1 | 1;
+};
+type Drag = {
+    captured: boolean;
+    directions: Direction[];
+    distance: number;
+    height: number;
+    originX: number;
+    originY: number;
+    pointer: number;
+    sampleX: number;
+    sampleY: number;
+    time: number;
+    vx: number;
+    vy: number;
+    width: number;
+    x: number;
+    y: number;
+};
+type Fling = {
+    duration: number;
+    easing: string;
+    x: number;
+    y: number;
+};
+type Options = {
+    begin: (e: PointerEvent, element: HTMLElement) => Direction[] | null;
+    capture?: (element: HTMLElement) => void;
+    move: (element: HTMLElement, drag: Drag, progress: number) => void;
+    release: (element: HTMLElement, drag: Drag, dismiss: boolean) => void;
+};
+declare const INTERACTIVE = "a, button, input, label, select, summary, textarea, [contenteditable], [role=\"button\"], [role=\"option\"]";
+declare const drag: ({ begin, capture, move, release }: Options) => {
+    onpointercancel: (e: PointerEvent) => void;
+    onpointerdown: (e: PointerEvent) => void;
+    onpointermove: (e: PointerEvent) => void;
+    onpointerup: (e: PointerEvent) => void;
+};
+declare const fling: (element: HTMLElement, { directions, time, vx, vy, x, y }: Drag) => Fling | null;
+declare const toward: ({ x, y }: {
+    x: -1 | 0 | 1;
+    y: -1 | 0 | 1;
+}) => Direction[];
+export { drag, fling, INTERACTIVE, toward };
+export type { Direction, Drag, Fling };

package/build/shared/drag.js

@@ -0,0 +1,189 @@
+import { timing } from './animation.js';
+import { swallow } from './press.js';
+import { viewport } from './viewport.js';
+const DISMISS_DISTANCE = 0.25;
+const FLICK_DISTANCE = 12;
+const FLICK_VELOCITY = 0.11;
+const FLING_EASING = 'cubic-bezier(0.33, 1, 0.68, 1)';
+const FLING_MIN = 150;
+const INTERACTIVE = 'a, button, input, label, select, summary, textarea, [contenteditable], [role="button"], [role="option"]';
+const REST = 100;
+const SAMPLE = 16;
+const THRESHOLD = 4;
+function dismissed(drag) {
+    let { directions, distance, time, vx, vy, x, y } = drag, ox = outward(directions, 'x', x), oy = outward(directions, 'y', y);
+    if (distance === 0) {
+        return false;
+    }
+    if (performance.now() - time > REST) {
+        return distance > extent(drag, ox, oy) * DISMISS_DISTANCE;
+    }
+    let fx = outward(directions, 'x', vx), fy = outward(directions, 'y', vy), speed = Math.hypot(fx, fy);
+    if (distance > FLICK_DISTANCE && speed > FLICK_VELOCITY && speed > Math.hypot(vx - fx, vy - fy)) {
+        return true;
+    }
+    return distance > extent(drag, ox, oy) * DISMISS_DISTANCE && (vx * ox + vy * oy) / distance > -FLICK_VELOCITY;
+}
+function extent({ height, width }, x, y) {
+    let length = Math.hypot(x, y);
+    if (length === 0) {
+        return Math.max(width, height);
+    }
+    return (Math.abs(x) * width + Math.abs(y) * height) / length;
+}
+function follow(directions, axis, delta) {
+    let free = false;
+    for (let i = 0, n = directions.length; i < n; i++) {
+        if (directions[i].axis !== axis) {
+            continue;
+        }
+        if (delta === 0 || Math.sign(delta) === directions[i].sign) {
+            return delta;
+        }
+        free = true;
+    }
+    return free ? Math.sign(delta) * Math.pow(Math.abs(delta), 0.7) : 0;
+}
+function free(directions, axis) {
+    for (let i = 0, n = directions.length; i < n; i++) {
+        if (directions[i].axis === axis) {
+            return true;
+        }
+    }
+    return false;
+}
+function outward(directions, axis, value) {
+    for (let i = 0, n = directions.length; i < n; i++) {
+        if (directions[i].axis === axis && Math.sign(value) === directions[i].sign) {
+            return value;
+        }
+    }
+    return 0;
+}
+const drag = ({ begin, capture, move, release }) => {
+    let current = null;
+    return {
+        onpointercancel: (e) => {
+            if (!current || e.pointerId !== current.pointer) {
+                return;
+            }
+            let state = current;
+            current = null;
+            if (state.captured) {
+                release(e.currentTarget, state, false);
+            }
+        },
+        onpointerdown: (e) => {
+            let directions = begin(e, e.currentTarget), now = performance.now();
+            if (!directions || directions.length === 0) {
+                return;
+            }
+            current = {
+                captured: false,
+                directions,
+                distance: 0,
+                height: 0,
+                originX: e.clientX,
+                originY: e.clientY,
+                pointer: e.pointerId,
+                sampleX: 0,
+                sampleY: 0,
+                time: now,
+                vx: 0,
+                vy: 0,
+                width: 0,
+                x: 0,
+                y: 0
+            };
+        },
+        onpointermove: (e) => {
+            if (!current || e.pointerId !== current.pointer) {
+                return;
+            }
+            let { directions } = current, element = e.currentTarget, dx = e.clientX - current.originX, dy = e.clientY - current.originY;
+            if (!current.captured) {
+                if (Math.hypot(free(directions, 'x') ? dx : 0, free(directions, 'y') ? dy : 0) <= THRESHOLD) {
+                    return;
+                }
+                current.captured = true;
+                element.setPointerCapture(e.pointerId);
+                getSelection()?.removeAllRanges();
+                capture?.(element);
+                current.height = element.offsetHeight;
+                current.width = element.offsetWidth;
+            }
+            let now = performance.now(), x = follow(directions, 'x', dx), y = follow(directions, 'y', dy), ox = outward(directions, 'x', x), oy = outward(directions, 'y', y);
+            if (now - current.time >= SAMPLE) {
+                current.vx = (dx - current.sampleX) / (now - current.time);
+                current.vy = (dy - current.sampleY) / (now - current.time);
+                current.sampleX = dx;
+                current.sampleY = dy;
+                current.time = now;
+            }
+            current.distance = Math.hypot(ox, oy);
+            current.x = x;
+            current.y = y;
+            move(element, current, Math.min(current.distance / extent(current, ox, oy), 1));
+        },
+        onpointerup: (e) => {
+            if (!current || e.pointerId !== current.pointer) {
+                return;
+            }
+            let element = e.currentTarget, state = current;
+            current = null;
+            if (!state.captured) {
+                return;
+            }
+            swallow();
+            release(element, state, dismissed(state));
+        }
+    };
+};
+const fling = (element, { directions, time, vx, vy, x, y }) => {
+    let longest = timing(getComputedStyle(element), 'fling')?.duration;
+    if (!longest) {
+        return null;
+    }
+    let moving = performance.now() - time <= REST, ux = moving ? outward(directions, 'x', vx) : 0, uy = moving ? outward(directions, 'y', vy) : 0;
+    if (ux === 0 && uy === 0) {
+        ux = outward(directions, 'x', x);
+        uy = outward(directions, 'y', y);
+    }
+    let length = Math.hypot(ux, uy);
+    if (length === 0) {
+        return null;
+    }
+    ux /= length;
+    uy /= length;
+    let rect = element.getBoundingClientRect(), speed = moving ? Math.max(vx * ux + vy * uy, 0) : 0, travel = Infinity, { height, width } = viewport();
+    if (ux > 0) {
+        travel = Math.min(travel, (width - rect.left) / ux);
+    }
+    else if (ux < 0) {
+        travel = Math.min(travel, rect.right / -ux);
+    }
+    if (uy > 0) {
+        travel = Math.min(travel, (height - rect.top) / uy);
+    }
+    else if (uy < 0) {
+        travel = Math.min(travel, rect.bottom / -uy);
+    }
+    travel = Math.max(travel, 0);
+    return {
+        duration: speed > 0 ? Math.min(Math.max((3 * travel) / speed, FLING_MIN), longest) : longest,
+        easing: FLING_EASING,
+        x: ux * travel,
+        y: uy * travel
+    };
+};
+const toward = ({ x, y }) => {
+    let ways = [];
+    if (x !== 0) {
+        ways.push({ axis: 'x', sign: x });
+    }
+    if (y !== 0) {
+        ways.push({ axis: 'y', sign: y });
+    }
+    return ways;
+};
+export { drag, fling, INTERACTIVE, toward };

package/build/shared/fuzzy.d.ts

@@ -0,0 +1,6 @@
+type Match = {
+    indices: number[];
+    score: number;
+};
+export default _default;
+declare function _default(query: string, text: string): Match | null;