@cgtk/std 0.0.194 → 0.0.196

package/resource.js

@@ -1,16 +1,24 @@
-import { forEach, noop } from "./fn.js";
+import * as F from "./fn.js";
 import { isFunction } from "./checks.js";
-export const resource = (value, dispose = noop) => {
-    const res = ((f) => forEach(f(value) ?? noop, dispose));
+import { add } from "./set.js";
+import { mapValues } from "./object.js";
+export const resource = (value, dispose = F.noop) => {
+    const res = ((f) => F.forEach(f(value) ?? F.noop, dispose));
     res.value = value;
     res.dispose = dispose;
     res.map = (f) => resource(f(value), dispose);
+    res.flatMap = (f) => {
+        const res = f(value);
+        return resource(res.value, F.forEach(res.dispose, dispose));
+    };
+    res.promise = async (f) => F.forEach((await f(value)) ?? F.noop, dispose);
     return res;
 };
-const isResource = (r) => isFunction(r)
-    && Object.hasOwn(r, "value")
-    && Object.hasOwn(r, "dispose")
-    && isFunction(r["dispose"]);
+export const awaited = async ({ value, dispose }) => resource(await value, dispose);
+const isResource = (r) => isFunction(r) &&
+    Object.hasOwn(r, "value") &&
+    Object.hasOwn(r, "dispose") &&
+    isFunction(r["dispose"]);
 export const compose = (rs) => {
     const disposes = [];
     const rec = (rs) => {
@@ -24,5 +32,15 @@ export const compose = (rs) => {
         return Object.fromEntries(Object.entries(rs).map(([k, v]) => [k, rec(v)]));
     };
     const value = rec(rs);
-    return resource(value, forEach(...disposes));
+    return resource(value, F.forEach(...disposes));
+};
+export const of = (x, f) => resource(x, f(x));
+export const gen = (f) => {
+    const res = new Set();
+    return resource(f((r) => (res.add(r.dispose), r.value), F.bind(add, res)), () => res.forEach((f) => f()));
+};
+export const consume = (f) => F.disposable((use) => use(f((r) => (use(r.dispose), r.value)) ?? F.noop));
+export const swapping = (fs) => {
+    const swap = F.swapping();
+    return resource(mapValues(fs, swap), swap(F.noop));
 };

package/schedule.d.ts

@@ -1,10 +1,10 @@
 import type { Dispose, Fn, FnV, Reactive } from './types.js';
 export declare const raf: Reactive<number>;
-export declare const timeout: (ms: number) => Reactive<void>;
+export declare const timeout: (ms?: number) => Reactive<void>;
 export declare const schedule: <T>(s: Reactive<T>) => <F extends FnV>(f: F) => FnV<Parameters<F>, Dispose>;
 export declare const idempotent: <T>(s: Reactive<T>, d: Fn<Dispose, Dispose>) => <F extends FnV>(f: F) => FnV<Parameters<F>, Dispose>;
 export declare const debounce: <T>(sched?: Reactive<T>) => Reactive<T>;
 export declare const reset: <T>(sched?: Reactive<T>) => Reactive<T>;
-export declare const repeatedly: <T>(f: Fn<void>, sched?: Reactive<T>) => () => any;
+export declare const repeatedly: <T = number>(sched?: Reactive<T>) => (f: Fn<T, boolean | void>) => () => any;
 export declare const delayAfter: <F extends FnV<any>>(delta: number, n: number, f: F) => (x: any) => any;
-export declare const micro: <F extends FnV>(f: F) => (...xs: Parameters<F>) => void;
+export declare const micro: <F extends FnV>(f: F) => (...xs: Parameters<F>) => (reason?: any) => void;

package/schedule.js

@@ -1,9 +1,9 @@
 import { isUndefined, isDefined, counted } from './checks.js';
-import { comp, lazy, bind, apply, call, where, disposing, noop } from './fn.js';
+import { comp, lazy, bind, apply, call, where, swapping, noop, abortable } from './fn.js';
 export const raf = f => bind(cancelAnimationFrame, requestAnimationFrame(f));
-export const timeout = (ms) => f => bind(clearTimeout, setTimeout(f, ms));
+export const timeout = (ms = 0) => f => bind(clearTimeout, setTimeout(f, ms));
 export const schedule = (s) => (f) => call(comp(apply(bind((lazy), f)), s));
-export const idempotent = (s, d) => (f) => disposing()((...xs) => d(s(() => f(...xs))));
+export const idempotent = (s, d) => (f) => swapping()((...xs) => d(s(() => f(...xs))));
 export const debounce = (sched = raf) => {
     let cancel;
     const stop = () => { if (isDefined(cancel))
@@ -23,11 +23,13 @@ export const reset = (sched = raf) => {
         return stop;
     };
 };
-export const repeatedly = (f, sched = raf) => {
+export const repeatedly = (sched = raf) => (f) => {
     let cancel;
-    const g = () => (f(), (cancel = sched(g)));
+    const g = (x) => { if (f(x) !== false)
+        cancel = sched(g); };
     cancel = sched(g);
     return () => cancel();
 };
 export const delayAfter = (delta, n, f) => where(counted(n), f, schedule(reset(timeout(delta)))(f));
-export const micro = (f) => (...xs) => queueMicrotask(() => f(...xs));
+export const micro = (f) => (...xs) => abortable(signal => queueMicrotask(() => { if (!signal.aborted)
+    f(...xs); }));

package/string.d.ts

@@ -6,3 +6,4 @@ export declare const objectURL: (data: Uint8Array<ArrayBuffer>, type: string) =>
 export declare const decode: (label?: string, opts?: TextDecoderOptions) => (x: Uint8Array, stream?: boolean) => string;
 export declare const readLine: (delims?: Set<number>) => (data: Uint8Array, offset?: number) => string;
 export declare const DATA_URL: RegExp;
+export declare const came2kebab: (s: string) => string;

package/string.js

@@ -27,3 +27,4 @@ export const readLine = (delims = new Set([0x0A])) => {
     };
 };
 export const DATA_URL = /^data:(?<mime>[\w/\-\+]+)?(;(?<params>[\w\-]+\=[^;,\s]+)*)?(;(?<encoding>base64))?,(?<data>.*)$/;
+export const came2kebab = (s) => s.replace(/[A-Z]/g, m => '-' + m.toLowerCase());

package/types.d.ts

@@ -6,9 +6,6 @@ export type Structure<T> = T | readonly Structure<T>[] | RecordOf<Structure<T>>;
 export type Optional<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>> & Partial<Pick<T, K>>;
 export type Tuple<T, N extends number, R extends T[] = []> = R['length'] extends N ? R : Tuple<T, N, [T, ...R]>;
 export type Elements<A extends readonly unknown[]> = A extends readonly (infer T)[] ? T : never;
-export type MaybeFirst<T extends unknown[], S = void> = T extends {
-    length: 0;
-} ? S : T[0];
 export type FnV<T extends any[] = any[], R = any> = (...x: T) => R;
 export type Fn<T = any, R = any> = FnV<[T], R>;
 export type FnP<T = any, R = any> = (x: T) => Promise<R>;
@@ -18,8 +15,7 @@ export type Fns<T> = {
 export type FnF = <F extends FnV>(f: F) => (...xs: Parameters<F>) => ReturnType<F>;
 export type Dispose = Fn<void>;
 export type Reactive<T = unknown, R = any> = Fn<Fn<T, R>, Dispose>;
-export type Constantly<T> = () => T;
-export type FirstParam<F extends FnV> = MaybeFirst<Parameters<F>>;
+export type Lazy<T> = () => T;
 export type MaybePromise<T = unknown> = T | PromiseLike<T>;
 export type Last<T extends any[]> = T extends [...any, infer Rest] ? Rest : never;
 export type Tail<T extends any[]> = T extends [any, ...(infer Rest)] ? Rest : never;
@@ -39,7 +35,7 @@ export type Entries<T> = {
 export type EntriesTuple<T, K extends UnionToTuple<keyof T> = UnionToTuple<keyof T>> = {
     [I in keyof K]: K[I] extends keyof T ? [K[I], T[K[I]]] : never;
 };
-export type UintArray<T extends ArrayBufferLike = ArrayBufferLike> = Uint8Array<T> | Uint16Array<T> | Uint32Array<T>;
+export type UintArray<T extends ArrayBufferLike = ArrayBufferLike> = Uint8Array<T> | Uint8ClampedArray<T> | Uint16Array<T> | Uint32Array<T>;
 export type IntArray<T extends ArrayBufferLike = ArrayBufferLike> = Int8Array<T> | Int16Array<T> | Int32Array<T>;
 export type FloatArray<T extends ArrayBufferLike = ArrayBufferLike> = Float16Array<T> | Float32Array<T> | Float64Array<T>;
 export type BigIntArray<T extends ArrayBufferLike = ArrayBufferLike> = BigUint64Array<T> | BigInt64Array<T>;

package/signal.d.ts

@@ -1,37 +0,0 @@
-import type { Fn, FnV, Fns, Pred, Reactive, RecordOf, Structure } from "./types.js";
-export type Signal<T> = Fn<T> & {
-    on: Reactive<T>;
-};
-export declare const create: <T>(f: Fn<T>, on: Reactive<T>) => Signal<T>;
-export declare const signal: <T>(fns?: Set<Fn<T>>) => Signal<T>;
-export declare const map: <T, S>(source: Reactive<T>, f: Fn<T, S>) => Reactive<S>;
-export declare const filter: <T>(source: Reactive<T>, p: Pred<T>) => Reactive<T>;
-export declare const cache: <T>(source: Reactive<T>) => Reactive<T>;
-export interface ValueLike<T> {
-    value: T;
-    on: Reactive<T>;
-}
-export interface Box<T, F extends RecordOf<FnV>> extends ValueLike<T> {
-    ops: F;
-}
-export interface Value<T> extends ValueLike<T> {
-    op: <F extends FnV>(f: Fn<T, F>) => F;
-    ops: <F extends RecordOf<FnV>>(f: Fn<T, F>) => F;
-    set: Fn<T>;
-    update(): void;
-    map<S>(f: Fn<T, S>): Reactive<S>;
-    box: <F extends RecordOf<FnV>>(f: Fn<T, F>) => Box<T, F>;
-}
-export declare const value: <T>(x: T, fs?: Set<Fn<T>>) => Value<T>;
-export type Values<T extends RecordOf<any>> = {
-    [k in keyof T]: Value<T[k]>;
-};
-export declare const values: <T extends RecordOf<any>>(vals: T) => Values<T>;
-type Unwrapped<T> = T extends ValueLike<infer U> ? U : {
-    [K in keyof T]: Unwrapped<T[K]>;
-};
-export declare const compose: <T extends Structure<ValueLike<any>>, S = Unwrapped<T>>(xs: T, transform?: Fn<Unwrapped<T>, S>) => Reactive<S>;
-export declare const mux: <I extends RecordOf<any>, O extends RecordOf<any>>(init: Fn<Fns<O>, Fns<I>>) => Fns<I> & {
-    on: { [k in keyof O]: Reactive<O[k]>; };
-};
-export {};

package/signal.js

@@ -1,89 +0,0 @@
-import { after, constantly, noop, bind, comp, forEach, filter as filter_, identity } from "./fn.js";
-import { mapValues } from "./object.js";
-import { isDefined, isFunction } from "./checks.js";
-import { add } from "./set.js";
-export const create = (f, on) => {
-    const g = f;
-    g.on = on;
-    return g;
-};
-export const signal = (fns = new Set()) => create((x) => fns.forEach(f => f(x)), bind(add, fns));
-export const map = (source, f) => g => source(comp(f, g));
-export const filter = (source, p) => f => source(filter_(p, f));
-export const cache = (source) => {
-    let x;
-    source(y => x = y);
-    return f => {
-        if (isDefined(x))
-            f(x);
-        return source(f);
-    };
-};
-;
-;
-const isValueLike = (v) => Object.hasOwn(v, "value") && Object.hasOwn(v, "on") && isFunction(v.on);
-export const value = (x, fs = new Set()) => {
-    const sig = signal(fs);
-    const notify = after(() => sig(x));
-    const op = (f) => notify(f(x));
-    const on = (f) => (f(x), sig.on(f));
-    const ops = (f) => mapValues(f(x), notify);
-    return {
-        get value() { return x; },
-        set value(y) { sig(x = y); },
-        op, on, ops,
-        set: op(constantly((y) => x = y)),
-        update: op(constantly(noop)),
-        map: bind(map, on),
-        box: (f) => ({
-            on,
-            get value() { return x; },
-            ops: ops(f),
-        })
-    };
-};
-export const values = (vals) => mapValues(vals, v => value(v));
-export const compose = (xs, transform = identity) => f => {
-    const collect = (vs) => {
-        if (isValueLike(vs)) {
-            return vs.value;
-        }
-        else if (Array.isArray(vs)) {
-            return vs.map(collect);
-        }
-        return Object.fromEntries(Object.entries(vs).map(([k, v]) => [k, collect(v)]));
-    };
-    const notify = () => f(transform(collect(xs)));
-    let ready = false;
-    const sub = (vs) => {
-        if (isValueLike(vs)) {
-            return vs.on(() => { if (ready)
-                notify(); });
-        }
-        else if (Array.isArray(vs)) {
-            return forEach(...vs.map(sub));
-        }
-        return forEach(...Object.values(vs).map(sub));
-    };
-    const off = sub(xs);
-    ready = true;
-    notify();
-    return off;
-};
-export const mux = (init) => {
-    const sigs = {};
-    const ins = init(new Proxy({}, {
-        get: (_, k) => (x) => {
-            const f = sigs[k];
-            if (isDefined(f))
-                f(x);
-        }
-    }));
-    ins.on = new Proxy({}, {
-        get: (_, k) => f => {
-            const sig = sigs[k] ??= signal();
-            return sig.on(f);
-        }
-    });
-    return ins;
-};

package/src/array.d.ts

@@ -1,14 +0,0 @@
-import type { Fn, Tuple } from "./types.js";
-export declare const empty: <T>() => T[];
-export declare const push: <T>(xs: T[], x: T) => T[];
-export declare const unshift: <T>(xs: T[], x: T) => T[];
-export declare const get: (i: number) => <T>(xs: T[]) => T;
-export declare const pop: <T>(xs: T[]) => T[];
-export declare const shift: <T>(xs: T[]) => T[];
-export declare const first: <T>(xs: T[]) => T;
-export declare const cap: <T>(n: number, f: Fn<T[]>) => Fn<T[], T[]>;
-export declare const retain: <T>(n: number, xs?: T[]) => (x: T) => T[];
-export declare const tuple: <T, N extends number>(...xs: T[] & {
-    length: N;
-}) => Tuple<T, N>;
-export declare const seek: <T>(arr: ArrayLike<T>, vals: Set<T | number>, offset?: number) => number;

package/src/array.js

@@ -1,21 +0,0 @@
-import { comp, scan } from "./fn.js";
-export const empty = () => [];
-export const push = (xs, x) => (xs.push(x), xs);
-export const unshift = (xs, x) => (xs.unshift(x), xs);
-export const get = (i) => (xs) => xs[i];
-export const pop = (xs) => (xs.pop(), xs);
-export const shift = (xs) => (xs.shift(), xs);
-export const first = (xs) => xs[0];
-export const cap = (n, f) => xs => {
-    while (xs.length > n)
-        f(xs);
-    return xs;
-};
-export const retain = (n, xs = []) => comp(scan((push), xs), cap(n, shift));
-export const tuple = (...xs) => xs;
-export const seek = (arr, vals, offset = 0) => {
-    for (let i = offset, n = arr.length; i < n; i++)
-        if (vals.has(arr[i]))
-            return i;
-    return -1;
-};

package/src/assign.d.ts

@@ -1,8 +0,0 @@
-import type { RecordOf } from "./types.js";
-type PO = RecordOf<unknown>;
-type Merge<T extends PO, S extends PO> = {
-    [K in keyof (T & S)]: K extends keyof S ? (K extends keyof T ? (S[K] extends PO ? (T[K] extends PO ? Merge<T[K], S[K]> : S[K]) : S[K]) : S[K]) : (K extends keyof T ? T[K] : never);
-};
-type Assign<T extends PO, Ts extends PO[]> = Ts extends [infer A extends PO, ...infer R extends PO[]] ? Assign<Merge<T, A>, R> : T;
-export declare const assign: <T extends PO, Ts extends PO[]>(target: T, ...sources: Ts) => Assign<T, Ts>;
-export {};

package/src/assign.js

@@ -1,26 +0,0 @@
-import { isUndefined, isNull } from "./checks.js";
-const isPrimitive = (x) => {
-    const t = typeof x;
-    return t === "string" || t === "number" || t === "boolean";
-};
-function isPlainObject(x) {
-    if (typeof x !== 'object')
-        return false;
-    const prototype = Object.getPrototypeOf(x);
-    return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
-}
-const canClone = (x) => isPrimitive(x) || isPlainObject(x) &&
-    Object.values(x).every(x => isUndefined(x) || isNull(x) || isPrimitive(x) || canClone(x));
-const merge = (target, source) => {
-    Object.keys(source).forEach(key => {
-        const s = source[key], t = target[key];
-        if (isPlainObject(t) && isPlainObject(s))
-            target[key] = merge(t, s);
-        else if (canClone(s))
-            target[key] = structuredClone(s);
-        else
-            target[key] = s;
-    });
-    return target;
-};
-export const assign = (target, ...sources) => sources.reduce(merge, target);

package/src/async.d.ts

@@ -1,8 +0,0 @@
-import type { Fn, Constantly, Maybe, Dispose, MaybePromise } from "./types.js";
-export declare const timeout: (ms: number, signal?: AbortSignal) => Promise<unknown>;
-export declare const delay: (ms: number, signal?: AbortSignal) => <T>(x: T) => Promise<T>;
-export declare const probing: <T>(p: Promise<T>) => Constantly<Maybe<T>>;
-export declare const resolved: <T>(p: Promise<T>) => (f: Fn<T>) => () => void;
-export declare const promise: <T>(x: MaybePromise<T>) => Promise<any>;
-export declare const then: <T>(p: Promise<T>) => <R>(f: Fn<T, R>) => Promise<R>;
-export declare const dispose: (p: Promise<Dispose>) => Dispose;

package/src/async.js

@@ -1,31 +0,0 @@
-import { filterT, disposable } from "./fn.js";
-import { isDefined } from "./checks.js";
-export const timeout = (ms, signal) => new Promise((resolve, reject) => {
-    if (signal?.aborted)
-        reject(signal.reason);
-    else {
-        const t = setTimeout(() => {
-            if (signal?.aborted)
-                reject(signal.reason);
-            else
-                resolve(undefined);
-        }, ms);
-        signal?.addEventListener("abort", () => (clearTimeout(t), reject(signal.reason)), { once: true });
-    }
-});
-export const delay = (ms, signal) => async (x) => (await timeout(ms, signal), x);
-export const probing = (p) => {
-    let value = undefined;
-    p.then(x => value = x);
-    return () => value;
-};
-export const resolved = (p) => {
-    const val = probing(p);
-    return (f) => {
-        const g = (filterT((isDefined), f));
-        return () => g(val());
-    };
-};
-export const promise = (x) => (x instanceof Promise) ? x : Promise.resolve(x);
-export const then = (p) => (f) => p.then(f);
-export const dispose = (p) => disposable(async (dispose) => dispose(await p));

package/src/base64.d.ts

@@ -1 +0,0 @@
-export declare const decodeBytes: (str: string) => Uint8Array<ArrayBuffer>;

package/src/base64.js

@@ -1,7 +0,0 @@
-export const decodeBytes = (str) => {
-    const raw = atob(str), size = raw.length;
-    const res = new Uint8Array(size);
-    for (let i = 0; i < size; i++)
-        res[i] = raw.charCodeAt(i);
-    return res;
-};

package/src/basen.d.ts

@@ -1,12 +0,0 @@
-export type Base<N extends number> = [n: N, m: number, d: number];
-export declare const basen: <B extends number>(b: B) => (m?: number, n?: number) => Base<B>;
-export declare const base10: (m?: number, n?: number) => Base<10>;
-export declare const normalize: <B extends number>(x: Base<B>) => Base<B>;
-export declare const add: <B extends number>([b, m0, n0]: Base<B>, [_, m1, n1]: Base<B>) => Base<B>;
-export declare const mul: <B extends number>([b, m0, n0]: Base<B>, [_, m1, n1]: Base<B>) => Base<B>;
-export declare const addN: <B extends number>(x: Base<B>, a: number) => Base<B>;
-export declare const mulN: <B extends number>(x: Base<B>, a: number) => Base<B>;
-export declare const change: <B extends number, D extends number>([b, m, n]: Base<B>, d: D) => Base<D>;
-export declare const toNumber: <B extends number>([b, m, n]: Base<B>) => number;
-export declare const toString: <B extends number>([b, m, n]: Base<B>, d?: number) => string;
-export declare const toExponential: ([_, m, n]: Base<10>, digits?: number, dMax?: number) => string;

package/src/basen.js

@@ -1,31 +0,0 @@
-import { toFixedMax } from "./number.js";
-export const basen = (b) => (m = 0, n = 0) => [b, m, n];
-export const base10 = basen(10);
-export const normalize = (x) => {
-    if (!Number.isInteger(x[2])) {
-        const n = Math.floor(x[2]);
-        x[1] *= x[0] ** (x[2] - n);
-        x[2] = n;
-    }
-    const d = x[1] != 0 ? Math.floor(Math.log(Math.abs(x[1])) / Math.log(x[0])) : 0;
-    x[1] /= x[0] ** d;
-    x[2] += d;
-    return x;
-};
-export const add = ([b, m0, n0], [_, m1, n1]) => {
-    const n = Math.max(n0, n1);
-    const m = m0 * b ** (n0 - n) + m1 * b ** (n1 - n);
-    return [b, m, n];
-};
-export const mul = ([b, m0, n0], [_, m1, n1]) => [b, m0 * m1, n0 + n1];
-export const addN = (x, a) => (x[1] += a, normalize(x));
-export const mulN = (x, a) => (x[1] *= a, normalize(x));
-export const change = ([b, m, n], d) => {
-    const k = n * Math.log(b) / Math.log(d);
-    return basen(d)(m, k);
-};
-export const toNumber = ([b, m, n]) => m * b ** n;
-export const toString = ([b, m, n], d = 2) => `${m.toFixed(d)}x${b}^${n}`;
-export const toExponential = ([_, m, n], digits = 2, dMax = 2) => Math.abs(n) <= dMax
-    ? toFixedMax(m * 10 ** n, digits)
-    : `${toFixedMax(m, digits)}e${n.toFixed(0)}`;

package/src/checks.d.ts

@@ -1,29 +0,0 @@
-import type { TypedArray, NumberArray, BigIntArray, Pred, TPred, Maybe } from "./types.js";
-export declare const isTypedArray: (x: any) => x is TypedArray;
-export declare const isNumberArray: (x: any) => x is NumberArray;
-export declare const isBigIntArray: (x: any) => x is BigIntArray;
-export declare const isUndefined: (x: any) => x is undefined;
-export declare const isNull: (x: any) => x is null;
-export declare const isDefined: <T>(x: Maybe<T>) => x is T;
-export declare function assert(condition: boolean, msg: string): asserts condition;
-export declare function assertType<T>(x: any, pred: TPred<T>, msg: string): asserts x is T;
-export declare const isObject: TPred<Object>;
-export declare const isString: TPred<string>;
-export declare const isNumber: TPred<number>;
-export declare const isBigInt: TPred<bigint>;
-export declare const isPositive: Pred<number>;
-export declare const isTs: <T>(p: TPred<T>) => TPred<T[]>;
-export declare const isclose: (a: number, b: number, eps?: number) => boolean;
-export declare const allclose: (a: Array<number> | NumberArray, b: Array<number> | NumberArray, eps?: number) => boolean;
-export declare const equal: <T>(a: T, b?: T) => boolean;
-export declare const strictEqual: <T>(a: T, b?: T) => boolean;
-export declare const isDiffPrev: <T>(eq?: (a: T, b?: T | undefined) => boolean) => Pred<T>;
-export declare const isLonger: <T>(delta: number) => Pred<T>;
-export declare const isFunction: <T extends Function>(x: any) => x is T;
-export declare const isAborted: (signal: AbortSignal) => () => boolean;
-export declare const isArrayBufferLike: (x: any) => x is ArrayBufferLike;
-export declare const isArrayBufferView: (x: any) => x is ArrayBufferView;
-export declare const isEmpty: (x: {
-    length: number;
-}) => boolean;
-export declare const counted: (n: number) => () => boolean;

package/src/checks.js

@@ -1,44 +0,0 @@
-import { comp, not, apply, and } from "./fn.js";
-import { retain } from "./array.js";
-export const isTypedArray = (x) => x && (x instanceof Uint8Array || x instanceof Uint8ClampedArray ||
-    x instanceof Uint16Array || x instanceof Uint32Array ||
-    x instanceof Int8Array || x instanceof Int16Array || x instanceof Int32Array ||
-    x instanceof Float16Array || x instanceof Float32Array || x instanceof Float64Array ||
-    x instanceof BigUint64Array || x instanceof BigInt64Array);
-export const isNumberArray = (x) => x && (x instanceof Uint8Array || x instanceof Uint8ClampedArray ||
-    x instanceof Uint16Array || x instanceof Uint32Array ||
-    x instanceof Int8Array || x instanceof Int16Array || x instanceof Int32Array ||
-    x instanceof Float16Array || x instanceof Float32Array || x instanceof Float64Array);
-export const isBigIntArray = (x) => x && (x instanceof BigUint64Array || x instanceof BigInt64Array);
-export const isUndefined = (x) => x === undefined;
-export const isNull = (x) => x === null;
-export const isDefined = (x) => !isUndefined(x);
-export function assert(condition, msg) {
-    if (!condition)
-        throw new Error(msg);
-}
-export function assertType(x, pred, msg) { assert(pred(x), msg); }
-export const isObject = (x) => x !== null && typeof x === "object";
-export const isString = (x) => typeof x === "string";
-export const isNumber = (x) => typeof x === 'number';
-export const isBigInt = (x) => typeof x === "bigint";
-export const isPositive = (x) => x > 0;
-export const isTs = (p) => and(Array.isArray, (xs) => xs.every(p));
-export const isclose = (a, b, eps = Number.EPSILON) => Math.abs(a - b) < eps;
-export const allclose = (a, b, eps) => a.length == b.length && a.every((x, i) => isclose(x, b[i], eps));
-export const equal = (a, b) => a == b;
-export const strictEqual = (a, b) => a === b;
-export const isDiffPrev = (eq = (strictEqual)) => comp(retain(2), not(apply(eq)));
-export const isLonger = (delta) => comp((x) => [performance.now(), x], retain(2), (xs) => xs.length < 2 || xs[1][0] - xs[0][0] > delta);
-export const isFunction = (x) => typeof x === "function";
-export const isAborted = (signal) => () => signal.aborted;
-export const isArrayBufferLike = (x) => x instanceof ArrayBuffer || x instanceof SharedArrayBuffer;
-export const isArrayBufferView = (x) => x != null &&
-    isArrayBufferLike(x.buffer) &&
-    isNumber(x.byteOffset) &&
-    isNumber(x.byteLength);
-export const isEmpty = (x) => x.length == 0;
-export const counted = (n) => {
-    let m = 0;
-    return () => m++ < n;
-};

package/src/constants.d.ts

@@ -1,5 +0,0 @@
-export declare const EMPTY: Readonly<{
-    OBJ: {};
-    STR: "";
-    LIST: never[];
-}>;

package/src/constants.js

@@ -1 +0,0 @@
-export const EMPTY = Object.freeze({ OBJ: {}, STR: "", LIST: [] });

package/src/dom.d.ts

@@ -1,50 +0,0 @@
-import type { Fn, Dispose, RecordOf, Maybe } from "./types.js";
-export declare const customEvent: <T>(type: string, detail: T, { composed, bubbles, cancelable }?: EventInit) => CustomEvent<T>;
-type ListenOpts = boolean | AddEventListenerOptions;
-export declare const on: {
-    <T extends HTMLElement, K extends keyof HTMLElementEventMap>(el: T, name: K, listener: Fn<HTMLElementEventMap[K]>, opts?: ListenOpts): Dispose;
-    <T extends SVGGraphicsElement, K extends keyof SVGElementEventMap>(el: T, name: K, listener: Fn<SVGElementEventMap[K]>, opts?: ListenOpts): Dispose;
-    <T, K extends keyof MessageEventTargetEventMap>(el: MessageEventTarget<T>, name: K, listener: Fn<MessageEventTargetEventMap[K]>, opts?: ListenOpts): Dispose;
-    <K extends keyof DocumentEventMap>(el: Document, name: K, listener: Fn<DocumentEventMap[K]>, opts?: ListenOpts): Dispose;
-    <K extends keyof WindowEventMap>(el: Window, name: K, listener: Fn<WindowEventMap[K]>, opts?: ListenOpts): Dispose;
-    <K extends keyof WorkerEventMap>(el: Worker, name: K, listener: Fn<WorkerEventMap[K]>, opts?: ListenOpts): Dispose;
-    <K extends keyof AbortSignalEventMap>(el: AbortSignal, name: K, listener: Fn<AbortSignalEventMap[K]>, opts?: ListenOpts): Dispose;
-};
-export declare const onAll: {
-    <T extends keyof HTMLElementEventMap>(el: HTMLElement, listeners: {
-        [k in T]: Fn<HTMLElementEventMap[k]>;
-    }, opts?: ListenOpts): Dispose;
-    <T extends keyof SVGElementEventMap>(el: SVGGraphicsElement, listeners: {
-        [k in T]: Fn<SVGElementEventMap[k]>;
-    }, opts?: ListenOpts): Dispose;
-    <T, K extends keyof MessageEventTargetEventMap>(el: MessageEventTarget<T>, listeners: {
-        [k in K]: Fn<MessageEventTargetEventMap[k]>;
-    }, opts?: ListenOpts): Dispose;
-    <T extends keyof DocumentEventMap>(el: Document, listeners: {
-        [k in T]: Fn<DocumentEventMap[k]>;
-    }, opts?: ListenOpts): Dispose;
-    <T extends keyof WindowEventMap>(el: Window, listeners: {
-        [k in T]: Fn<WindowEventMap[k]>;
-    }, opts?: ListenOpts): Dispose;
-    <T extends keyof WorkerEventMap>(el: Worker, listeners: {
-        [k in T]: Fn<WorkerEventMap[k]>;
-    }, opts?: ListenOpts): Dispose;
-    <T extends keyof AbortSignalEventMap>(el: AbortSignal, listeners: {
-        [k in T]: Fn<AbortSignalEventMap[k]>;
-    }, opts?: ListenOpts): Dispose;
-};
-type DragHandlers = Record<'down' | 'move' | 'up', Fn<PointerEvent>>;
-export declare const onDrag: {
-    (el: HTMLElement, fns: Partial<DragHandlers>): Dispose;
-    (el: SVGGraphicsElement, fns: Partial<DragHandlers>): Dispose;
-};
-export declare const onDragMove: {
-    (el: HTMLElement, f: Fn<PointerEvent>): Dispose;
-    (el: SVGGraphicsElement, f: Fn<PointerEvent>): Dispose;
-};
-export declare const onResize: (el: Element, f: Fn<ResizeObserverEntry[]>, options?: ResizeObserverOptions) => Dispose;
-export declare const preventDefault: <T extends Event>(e: T) => void;
-export declare const loadImage: (img: HTMLImageElement, src: string) => Promise<HTMLImageElement>;
-export declare const pushState: (path: string, query?: RecordOf<string>, data?: any) => void;
-export declare const qs: (search?: string) => Maybe<RecordOf<string>>;
-export {};

package/src/dom.js

@@ -1,36 +0,0 @@
-import { forEach, noop } from "./fn.js";
-import { isDefined } from "./checks.js";
-import { EMPTY } from "./constants.js";
-export const customEvent = (type, detail, { composed = false, bubbles = false, cancelable = false } = EMPTY.OBJ) => new CustomEvent(type, { bubbles, cancelable, composed, detail });
-export const on = (el, name, listener, opts = false) => {
-    el.addEventListener(name, listener, opts);
-    return () => el.removeEventListener(name, listener, opts);
-};
-export const onAll = (el, fs, opts) => forEach(...Object.keys(fs).map(k => on(el, k, fs[k], opts)));
-export const onDrag = (el, { down = noop, move = noop, up = noop }) => on(el, 'pointerdown', e => {
-    const pointerId = e.pointerId;
-    el.setPointerCapture(pointerId);
-    down(e);
-    const offMove = on(el, 'pointermove', move);
-    const offUp = on(el, 'pointerup', e => {
-        up(e);
-        el.releasePointerCapture(pointerId);
-        offMove();
-        offUp();
-    });
-});
-export const onDragMove = (el, move) => onDrag(el, { move });
-export const onResize = (el, f, options) => {
-    const ro = new ResizeObserver(f);
-    ro.observe(el, options);
-    return () => ro.disconnect();
-};
-export const preventDefault = (e) => e.preventDefault();
-export const loadImage = (img, src) => new Promise((resolve) => {
-    const off = on(img, "load", () => (off(), resolve(img)));
-    img.src = src;
-});
-export const pushState = (path, query, data) => history.pushState(data, EMPTY.STR, isDefined(query) ? `${path}?${new URLSearchParams(query).toString()}` : path);
-export const qs = (search = location.search) => search.length > 0
-    ? Object.fromEntries(new URLSearchParams(search).entries())
-    : undefined;