@cgtk/std 0.0.194 → 0.0.195

package/async.d.ts

@@ -1,7 +1,7 @@
-import type { Fn, Constantly, Maybe, Dispose, MaybePromise } from "./types.js";
+import type { Fn, Lazy, 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 probing: <T>(p: Promise<T>) => Lazy<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>;

package/dom.d.ts

@@ -47,4 +47,5 @@ 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 declare const imageData: (img: HTMLImageElement) => ImageData;
 export {};

package/dom.js

@@ -34,3 +34,8 @@ export const pushState = (path, query, data) => history.pushState(data, EMPTY.ST
 export const qs = (search = location.search) => search.length > 0
     ? Object.fromEntries(new URLSearchParams(search).entries())
     : undefined;
+export const imageData = (img) => {
+    const ctx = new OffscreenCanvas(img.width, img.height).getContext("2d");
+    ctx.drawImage(img, 0, 0);
+    return ctx.getImageData(0, 0, img.width, img.height);
+};

package/fn.d.ts

@@ -1,16 +1,16 @@
-import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Constantly, Maybe, Dispose, Reactive } from "./types.js";
+import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Lazy, Maybe, Dispose, Reactive } from "./types.js";
 export declare const tee: <T>(f: Fn<T, void>) => Fn<T, T>;
 export declare const comp: <Fs extends Fn[]>(...fs: Fs) => (x: FirstParam<Fs[0]>) => Last<Fs> extends Fn<any, infer R> ? R : never;
 export declare const pipe: <T, Fs extends [Fn<T>, ...Fn[]]>(x: T, ...fs: Fs) => Last<Fs> extends Fn<any, infer R> ? R : never;
 export declare const forEach: <T, R = any>(...fs: Fn<T, R>[]) => (x: T) => void;
-export declare const map: <T, R>(...fs: Fn<T, R>[]) => (x: T) => R[];
+export declare const map: <T, S, U>(f: Fn<T, S>, g: Fn<S, U>) => Fn<T, U>;
 export declare const and: <T>(...fs: Pred<T>[]) => (x: T) => boolean;
 export declare const or: <T>(...fs: Pred<T>[]) => (x: T) => boolean;
 export declare const not: <T>(p: Pred<T>) => (x: T) => boolean;
 export declare const comb: <C extends FnV<Fn[]>>(c: C) => (...fs: Fn<FirstParam<FirstParam<C>>, ReturnType<FirstParam<C>>>[]) => (x: FirstParam<FirstParam<C>>) => ReturnType<C>;
 export declare const noop: () => void;
 export declare const identity: <S, T = S>(x: S) => T;
-export declare const constantly: <T>(x: T) => Constantly<T>;
+export declare const constantly: <T>(x: T) => Lazy<T>;
 export declare const apply: <F extends FnV>(f: F) => (x: Parameters<F>) => ReturnType<F>;
 export declare const call: <T extends unknown[]>(f: Fn<T>) => (...xs: T) => ReturnType<typeof f>;
 export declare const bind: <A extends unknown[], B extends unknown[], R>(f: (...args: [...A, ...B]) => R, ...args: A) => (...args: B) => R;
@@ -18,7 +18,6 @@ export declare const lazy: <F extends FnV>(f: F, ...xs: Parameters<F>) => Fn<voi
 export declare const where: <T, U, V>(p: Pred<T>, f: Fn<T, U>, g: Fn<T, V>) => (x: T) => U | V;
 export declare const before: <F extends Fn<void>>(f: F) => FnF;
 export declare const after: <F extends Fn<void>>(f: F) => FnF;
-export declare const mapForEach: <T, R>(...fs: Fn<T, Fn<R>>[]) => (x: T) => (x: R) => void;
 export declare const filter: <T>(p: Pred<T>, f: Fn<T>) => (x: T) => void;
 export declare const filterT: <T>(p: TPred<T>, f: Fn<T>) => <S>(x: S) => void;
 export declare const scan: <T, S>(f: FnV<[S, T], S>, a: S) => Fn<T, S>;

package/fn.js

@@ -3,7 +3,7 @@ export const tee = f => x => (f(x), x);
 export const comp = (...fs) => (x) => fs.reduce((x, f) => f(x), x);
 export const pipe = (x, ...fs) => fs.reduce((x, f) => f(x), x);
 export const forEach = (...fs) => (x) => fs.forEach(f => f(x));
-export const map = (...fs) => (x) => fs.map(f => f(x));
+export const map = (f, g) => comp(f, g);
 export const and = (...fs) => (x) => fs.reduce((a, f) => a && f(x), true);
 export const or = (...fs) => (x) => fs.reduce((a, f) => a || f(x), false);
 export const not = (p) => (x) => !p(x);
@@ -22,7 +22,6 @@ export const after = (f) => g => (...xs) => {
     f();
     return r;
 };
-export const mapForEach = (...fs) => comp(map(...fs), apply((forEach)));
 export const filter = (p, f) => (x) => { if (p(x))
     f(x); };
 export const filterT = (p, f) => (x) => { if (p(x))

package/math.d.ts

@@ -32,3 +32,4 @@ export declare const zoom: (x: number, s: number, p: number) => number;
 export declare const align: (x: number, b: number) => number;
 export declare const sign11: (x: number) => 1 | -1;
 export declare const nudge: (x: number, v?: number, eps?: number) => number;
+export declare const divCeil: (a: number, b: number) => number;

package/math.js

@@ -41,3 +41,4 @@ export const zoom = (x, s, p) => (x - p) * s + p;
 export const align = (x, b) => (x + b - 1) & -b;
 export const sign11 = (x) => x >= 0 ? 1 : -1;
 export const nudge = (x, v = 0, eps = EPS) => isclose(x, v, eps) ? sign11(x - v) * eps + v : x;
+export const divCeil = (a, b) => Math.ceil(a / b);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cgtk/std",
-  "version": "0.0.194",
+  "version": "0.0.195",
   "type": "module",
   "main": "./index.js",
   "exports": {
@@ -40,9 +40,6 @@
     "./resource": "./resource.js",
     "./utils": "./utils.js"
   },
-  "devDependencies": {
-    "typescript": "^6.0.2"
-  },
   "publishConfig": {
     "access": "public"
   }

package/resource.d.ts

@@ -3,8 +3,11 @@ export type Resource<T> = Reactive<T, Dispose | void> & {
     value: T;
     dispose: Dispose;
     map<S>(f: Fn<T, S>): Resource<S>;
+    flatMap<S>(f: Fn<T, Resource<S>>): Resource<S>;
+    promise(f: Fn<T, Promise<Dispose | void>>): Promise<Dispose>;
 };
 export declare const resource: <T>(value: T, dispose?: Dispose) => Resource<T>;
+export declare const awaited: <T>({ value, dispose }: Resource<Promise<T>>) => Promise<Resource<Awaited<T>>>;
 type Unwrapped<T> = T extends Resource<infer U> ? U : {
     [K in keyof T]: Unwrapped<T[K]>;
 };

package/resource.js

@@ -5,8 +5,14 @@ export const resource = (value, dispose = noop) => {
     res.value = value;
     res.dispose = dispose;
     res.map = (f) => resource(f(value), dispose);
+    res.flatMap = (f) => {
+        const res = f(value);
+        return resource(res.value, forEach(res.dispose, dispose));
+    };
+    res.promise = async (f) => forEach((await f(value)) ?? noop, dispose);
     return res;
 };
+export const awaited = async ({ value, dispose }) => resource(await value, dispose);
 const isResource = (r) => isFunction(r)
     && Object.hasOwn(r, "value")
     && Object.hasOwn(r, "dispose")

package/types.d.ts

@@ -18,7 +18,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 Lazy<T> = () => T;
 export type FirstParam<F extends FnV> = MaybeFirst<Parameters<F>>;
 export type MaybePromise<T = unknown> = T | PromiseLike<T>;
 export type Last<T extends any[]> = T extends [...any, infer Rest] ? Rest : never;
@@ -39,7 +39,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/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/buffer.d.ts

@@ -1,14 +0,0 @@
-import type { Fn } from "./types.js";
-export interface BufReader {
-    offset: number;
-    line: Fn<void, string>;
-    u8: Fn<void, number>;
-    u16: Fn<boolean, number>;
-    u32: Fn<boolean, number>;
-    i8: Fn<void, number>;
-    i16: Fn<boolean, number>;
-    i32: Fn<boolean, number>;
-    f32: Fn<boolean, number>;
-    f64: Fn<boolean, number>;
-}
-export declare const bufReader: (data: Uint8Array, offset?: number) => BufReader;

package/src/buffer.js

@@ -1,54 +0,0 @@
-import { readLine } from './string.js';
-export const bufReader = (data, offset = 0) => {
-    const rl = readLine();
-    const dv = new DataView(data.buffer, data.byteOffset);
-    return {
-        get offset() { return offset; },
-        set offset(x) { offset = x; },
-        line() {
-            const line = rl(data, offset);
-            offset += line.length;
-            return line;
-        },
-        u8() {
-            const x = dv.getUint8(offset);
-            offset += 1;
-            return x;
-        },
-        u16(littleEndian = true) {
-            const x = dv.getUint16(offset, littleEndian);
-            offset += 2;
-            return x;
-        },
-        u32(littleEndian = true) {
-            const x = dv.getUint16(offset, littleEndian);
-            offset += 4;
-            return x;
-        },
-        i8() {
-            const x = dv.getInt8(offset);
-            offset += 1;
-            return x;
-        },
-        i16(littleEndian = true) {
-            const x = dv.getInt16(offset, littleEndian);
-            offset += 2;
-            return x;
-        },
-        i32(littleEndian = true) {
-            const x = dv.getInt32(offset, littleEndian);
-            offset += 4;
-            return x;
-        },
-        f32(littleEndian = true) {
-            const x = dv.getFloat32(offset, littleEndian);
-            offset += 4;
-            return x;
-        },
-        f64(littleEndian = true) {
-            const x = dv.getFloat64(offset, littleEndian);
-            offset += 8;
-            return x;
-        },
-    };
-};

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;

package/src/fn.d.ts

@@ -1,33 +0,0 @@
-import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Constantly, Maybe, Dispose, Reactive } from "./types.js";
-export declare const tee: <T>(f: Fn<T, void>) => Fn<T, T>;
-export declare const comp: <Fs extends Fn[]>(...fs: Fs) => (x: FirstParam<Fs[0]>) => Last<Fs> extends Fn<any, infer R> ? R : never;
-export declare const pipe: <T, Fs extends [Fn<T>, ...Fn[]]>(x: T, ...fs: Fs) => Last<Fs> extends Fn<any, infer R> ? R : never;
-export declare const forEach: <T, R = any>(...fs: Fn<T, R>[]) => (x: T) => void;
-export declare const map: <T, R>(...fs: Fn<T, R>[]) => (x: T) => R[];
-export declare const and: <T>(...fs: Pred<T>[]) => (x: T) => boolean;
-export declare const or: <T>(...fs: Pred<T>[]) => (x: T) => boolean;
-export declare const not: <T>(p: Pred<T>) => (x: T) => boolean;
-export declare const comb: <C extends FnV<Fn[]>>(c: C) => (...fs: Fn<FirstParam<FirstParam<C>>, ReturnType<FirstParam<C>>>[]) => (x: FirstParam<FirstParam<C>>) => ReturnType<C>;
-export declare const noop: () => void;
-export declare const identity: <S, T = S>(x: S) => T;
-export declare const constantly: <T>(x: T) => Constantly<T>;
-export declare const apply: <F extends FnV>(f: F) => (x: Parameters<F>) => ReturnType<F>;
-export declare const call: <T extends unknown[]>(f: Fn<T>) => (...xs: T) => ReturnType<typeof f>;
-export declare const bind: <A extends unknown[], B extends unknown[], R>(f: (...args: [...A, ...B]) => R, ...args: A) => (...args: B) => R;
-export declare const lazy: <F extends FnV>(f: F, ...xs: Parameters<F>) => Fn<void, ReturnType<F>>;
-export declare const where: <T, U, V>(p: Pred<T>, f: Fn<T, U>, g: Fn<T, V>) => (x: T) => U | V;
-export declare const before: <F extends Fn<void>>(f: F) => FnF;
-export declare const after: <F extends Fn<void>>(f: F) => FnF;
-export declare const mapForEach: <T, R>(...fs: Fn<T, Fn<R>>[]) => (x: T) => (x: R) => void;
-export declare const filter: <T>(p: Pred<T>, f: Fn<T>) => (x: T) => void;
-export declare const filterT: <T>(p: TPred<T>, f: Fn<T>) => <S>(x: S) => void;
-export declare const scan: <T, S>(f: FnV<[S, T], S>, a: S) => Fn<T, S>;
-export declare const memoize: <T extends any[], K, V>(f: FnV<T, V>, key?: FnV<T, K>, cache?: Map<K, V>) => (...xs: T) => NonNullable<V>;
-export declare const abortable: <T = any>(f: Fn<AbortSignal>) => (reason?: T) => void;
-export declare const disposable: (f: Fn<Fn<Dispose, Dispose>>, disposes?: Set<Dispose>) => Dispose;
-export declare const disposing: () => <F extends FnV<any[], Maybe<Dispose>>>(f: F) => FnV<Parameters<F>, Dispose>;
-export declare const disposeWith: <T>(f: Fn<T, Dispose>) => (g: Fn<Fn<T>>) => Dispose;
-export declare const idemp: <F extends FnV<any[], Dispose | void>>(d: Fn<Dispose, Dispose>, f: F) => FnV<Parameters<F>, Dispose>;
-export declare const toggler: (f: Fn<void, Dispose>) => (x: boolean) => Dispose;
-export declare const voidify: <F extends FnV>(f: F) => (...xs: Parameters<F>) => void;
-export declare const effectual: <T>(f: Reactive<T>, g: Fn<T>) => Dispose;