@cgtk/std 0.0.192 → 0.0.194

package/signal.js

@@ -1,33 +1,74 @@
-import { after, constantly, noop, bind, comp, forEach } from "./fn";
-import { mapValues } from "./object";
-import { isDefined } from "./checks";
-import { add } from "./set";
+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);
+    };
+};
 ;
-export const value = (x) => {
-    const sig = signal();
+;
+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: (f) => (f(x), sig.on(f)),
-        ops: (f) => mapValues(f(x), notify),
+        op, on, ops,
         set: op(constantly((y) => x = y)),
-        update: op(constantly(noop))
+        update: op(constantly(noop)),
+        map: bind(map, on),
+        box: (f) => ({
+            on,
+            get value() { return x; },
+            ops: ops(f),
+        })
     };
 };
-export const values = (vals) => mapValues(vals, value);
-export const map = (source, f) => g => source(comp(f, g));
-export const merge = (vals) => f => {
-    const sub = () => f(mapValues(vals, (v) => v.value));
-    return forEach(...Object.values(vals).map((v) => v.on(sub)));
+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 = {};

package/src/array.d.ts

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,31 @@
+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

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

package/src/base64.js

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,31 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,44 @@
+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

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

package/src/constants.js

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

package/src/dom.d.ts

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,33 @@
+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;

package/src/fn.js

@@ -0,0 +1,61 @@
+import { add } from "./set.js";
+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 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);
+export const comb = (c) => (...fs) => (x) => c(...fs.map(f => f(x)));
+export const noop = () => { };
+export const identity = (x) => x;
+export const constantly = (x) => () => x;
+export const apply = (f) => (x) => f.apply(null, x);
+export const call = (f) => (...xs) => f(xs);
+export const bind = (f, ...args) => f.bind(null, ...args);
+export const lazy = (f, ...xs) => () => f(...xs);
+export const where = (p, f, g) => (x) => p(x) ? f(x) : g(x);
+export const before = (f) => g => (...xs) => (f(), g(...xs));
+export const after = (f) => g => (...xs) => {
+    const r = 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))
+    f(x); };
+export const scan = (f, a) => (x) => a = f(a, x);
+export const memoize = (f, key = (...xs) => xs[0], cache = new Map()) => (...xs) => {
+    const k = key(...xs);
+    if (!cache.has(k))
+        cache.set(k, f(...xs));
+    return cache.get(k);
+};
+export const abortable = (f) => {
+    const ctrl = new AbortController();
+    f(ctrl.signal);
+    return (reason) => ctrl.abort(reason);
+};
+export const disposable = (f, disposes = new Set()) => {
+    f(bind(add, disposes));
+    return () => (disposes.forEach(g => g()), disposes.clear());
+};
+export const disposing = () => {
+    let dispose = noop;
+    const stop = () => dispose();
+    return (f) => (...xs) => (stop(), dispose = f(...xs) ?? noop, stop);
+};
+export const disposeWith = (f) => (g) => disposable((d) => g(comp(f, d)));
+export const idemp = (d, f) => disposing()((...xs) => {
+    const cleanup = f(...xs) ?? noop;
+    return forEach(cleanup, d(cleanup));
+});
+export const toggler = (f) => {
+    let cancel = noop;
+    return (x) => (cancel(), (cancel = x ? f() : noop));
+};
+export const voidify = (f) => (...xs) => { f(...xs); };
+export const effectual = (f, g) => disposable(d => d(f(idemp(d, g))));

package/src/http.d.ts

@@ -0,0 +1,9 @@
+export declare const assertStatus: (status: number) => (resp: Response) => void;
+export declare const contentLength: (response: Response) => number;
+export declare const fetchBuffer: (url: string | URL | Request, init?: RequestInit) => Promise<ArrayBuffer>;
+export declare const fetchText: (url: string | URL | Request, init?: RequestInit) => Promise<string>;
+export declare const fetchDOM: (url: string | URL | Request, init?: RequestInit) => Promise<HTMLElement>;
+export declare const fetchImage: (src: string) => Promise<HTMLImageElement>;
+export declare const fetchImageBitmap: (url: string | URL | Request, init?: RequestInit) => Promise<ImageBitmap>;
+export declare const fetchJSON: (url: string | URL | Request, init?: RequestInit) => Promise<any>;
+export declare const fetchDataUrl: (url: string | URL | Request, init?: RequestInit) => Promise<string>;

package/src/http.js

@@ -0,0 +1,33 @@
+import { tee } from "./fn.js";
+import { assert } from "./checks.js";
+export const assertStatus = (status) => (resp) => assert(resp.status == status, `Invalid HTTP Status ${resp.status}: ${resp.url}`);
+export const contentLength = (response) => {
+    const cl = response.headers.get("content-length");
+    return cl ? parseInt(cl) : -1;
+};
+export const fetchBuffer = (url, init) => fetch(url, init)
+    .then(tee(assertStatus(200)))
+    .then(resp => resp.blob())
+    .then(blob => blob.arrayBuffer());
+export const fetchText = (url, init) => fetchBuffer(url, init).then(buf => new TextDecoder("utf-8").decode(buf));
+export const fetchDOM = (url, init) => fetchText(url, init).then(txt => new DOMParser().parseFromString(txt, "image/svg+xml").documentElement);
+export const fetchImage = (src) => new Promise((resolve, reject) => {
+    const image = new Image();
+    image.crossOrigin = "anonymous";
+    image.src = src;
+    image.onload = () => resolve(image);
+    image.onerror = reject;
+});
+export const fetchImageBitmap = async (url, init) => fetch(url, init)
+    .then(tee(assertStatus(200)))
+    .then(resp => resp.blob())
+    .then(blob => createImageBitmap(blob, { colorSpaceConversion: "none" }));
+export const fetchJSON = (url, init) => fetchText(url, init).then(JSON.parse);
+export const fetchDataUrl = (url, init) => fetch(url, init)
+    .then(tee(assertStatus(200)))
+    .then(resp => resp.blob())
+    .then(blob => new Promise(resolve => {
+    const f = new FileReader();
+    f.addEventListener("load", () => resolve(f.result));
+    f.readAsDataURL(blob);
+}));