@cgtk/std 0.0.182

package/array.d.ts

@@ -0,0 +1,12 @@
+import type { Fn, Tuple, Numbers } from "./types.js";
+export declare const push: <T>(xs: T[], x: T) => T[];
+export declare const unshift: <T>(xs: T[], x: 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: T[] | Numbers, vals: Set<T | number>, offset?: number) => number;

package/array.js

@@ -0,0 +1,19 @@
+import { comp, scan } from "./fn.js";
+export const push = (xs, x) => (xs.push(x), xs);
+export const unshift = (xs, x) => (xs.unshift(x), xs);
+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/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/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/async.d.ts

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

package/async.js

@@ -0,0 +1,27 @@
+import { filterT } from "./fn.js";
+import { isDefined } from "./checks.js";
+export const timeout = (ms, signal) => new Promise((resolve, reject) => {
+    if (signal?.aborted)
+        reject(signal.reason);
+    else {
+        setTimeout(() => {
+            if (signal?.aborted)
+                reject(signal.reason);
+            else
+                resolve(undefined);
+        }, ms);
+    }
+});
+export const delay = (ms) => async (x) => (await timeout(ms), 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());
+    };
+};

package/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/basen.js

@@ -0,0 +1,31 @@
+import { toFixedMax } from "./number";
+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/buffer.d.ts

@@ -0,0 +1,14 @@
+import type { Fn } from "./types";
+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/buffer.js

@@ -0,0 +1,54 @@
+import { readLine } from './string';
+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/checks.d.ts

@@ -0,0 +1,26 @@
+import type { TypedArray, TypedArrayConstructor, Pred, TPred, FnV, Optional, Numbers } from "./types";
+export declare const isTypedArray: (x: any) => x is TypedArray;
+export declare const isTypedArrayConstructor: (x: any) => x is TypedArrayConstructor;
+export declare const isUndefined: (x: any) => x is undefined;
+export declare const isNull: (x: any) => x is null;
+export declare const isDefined: <T>(x: Optional<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 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: Numbers, b: Numbers, eps?: number) => boolean;
+export declare const ternary: <A, B, C>(f: FnV<[A, B], C>) => (a: Optional<A>, b: Optional<B>) => C;
+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 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;

package/checks.js

@@ -0,0 +1,37 @@
+import { comp, not, apply, and } from "./fn";
+import { retain } from "./array";
+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 Float32Array || x instanceof Float64Array);
+export const isTypedArrayConstructor = (x) => x && (x == Uint8Array || x == Uint8ClampedArray ||
+    x == Uint16Array || x == Uint32Array ||
+    x == Int8Array || x == Int16Array || x == Int32Array ||
+    x == Float32Array || x == Float64Array);
+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 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 ternary = (f) => (a, b) => ((!isUndefined(a) && !isUndefined(b)) ? f(a, b) : isUndefined(a) ? b : a);
+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 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;

package/constants.d.ts

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

package/constants.js

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

package/dom.d.ts

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

package/dom.js

@@ -0,0 +1,31 @@
+import { forEach, noop } from "./fn.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;
+});

package/fn.d.ts

@@ -0,0 +1,29 @@
+import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Constantly, Optional } 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 idempotent: <F extends FnV<any[], Fn<void> | any>>(f: F) => (...xs: Parameters<F>) => void;
+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) => <G extends FnV>(g: G) => (...xs: Parameters<G>) => ReturnType<G>;
+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>) => Fn<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: (f: Fn<AbortSignal>) => <T = any>(reason?: T) => void;
+export declare const disposable: (f: Fn<Fn<Fn<void>, Fn<void>>>, disposes?: Set<Fn<void>>) => () => void;
+export declare const disposing: () => <F extends FnV<any[], Optional<Fn<void>>>>(f: F) => (...xs: Parameters<F>) => Fn<void>;

package/fn.js

@@ -0,0 +1,56 @@
+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 idempotent = (f) => {
+    let clear = noop;
+    return (...xs) => {
+        clear();
+        const y = f(...xs);
+        clear = typeof y === "function" ? y : noop;
+    };
+};
+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(g => (disposes.add(g), () => disposes.delete(g)));
+    return () => (disposes.forEach(g => g()), disposes.clear());
+};
+export const disposing = () => {
+    let dispose = noop;
+    return (f) => (...xs) => (dispose(), dispose = f(...xs) ?? noop);
+};

package/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 toByteArray: (stream: ReadableStream<Uint8Array>) => Promise<Uint8Array<ArrayBufferLike>>;
+export declare const fetchBuffer: (url: string, init?: RequestInit) => Promise<Uint8Array<ArrayBufferLike>>;
+export declare const fetchText: (url: string, init?: RequestInit) => Promise<string>;
+export declare const fetchDOM: (url: string, init?: RequestInit) => Promise<HTMLElement>;
+export declare const fetchImage: (src: string) => Promise<HTMLImageElement>;
+export declare const fetchJSON: (url: string, init?: RequestInit) => Promise<any>;
+export declare const fetchDataUrl: (url: string) => Promise<string>;

package/http.js

@@ -0,0 +1,32 @@
+import { tee } from "./fn";
+import { assert } from "./checks";
+import { reduceArray } from './stream';
+import { concat } from "./typedarray";
+import { fromBytes } from "./json";
+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 toByteArray = async (stream) => concat(await reduceArray(stream));
+export const fetchBuffer = (url, init) => fetch(url, init)
+    .then(tee(assertStatus(200)))
+    .then(resp => resp.body)
+    .then(toByteArray);
+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 fetchJSON = (url, init) => fetchBuffer(url, init).then(fromBytes);
+export const fetchDataUrl = (url) => fetch(url)
+    .then(resp => resp.blob())
+    .then(blob => new Promise(resolve => {
+    const f = new FileReader();
+    f.addEventListener("load", () => resolve(f.result));
+    f.readAsDataURL(blob);
+}));

package/index.d.ts

@@ -0,0 +1 @@
+export {};

package/index.js

@@ -0,0 +1 @@
+export {};

package/iterable.d.ts

@@ -0,0 +1,41 @@
+import type { Fn, FnV, Indexed, Pred } from "./types.js";
+export declare const repeat: (n: number) => <A>(x: A) => Iterator<A>;
+export declare const just: <T>(x: T) => IteratorObject<T>;
+export declare const enumerate: (n?: number) => <T>(x: T) => Indexed<T>;
+export declare function empty(): Generator<never, void, unknown>;
+export declare function concat<T>(...xxs: ReadonlyArray<IteratorObject<T>>): Generator<T, void, unknown>;
+export declare const toArray: <T>(xs: IteratorObject<T>) => T[];
+export declare const map: <T, U = T>(f: Fn<T, U>) => (xs: IteratorObject<T>) => IteratorObject<U, undefined, unknown>;
+export declare const filter: <T>(f: Pred<T>) => (xs: IteratorObject<T>) => IteratorObject<T, undefined, unknown>;
+export declare const drop: (n: number) => <T>(xs: IteratorObject<T>) => IteratorObject<T, undefined, unknown>;
+export declare const flatMap: <T, U = Iterable<T>>(f: Fn<T, Iterator<U> | Iterable<U>>) => (xs: IteratorObject<T>) => IteratorObject<U, undefined, unknown>;
+export declare const forEach: <T>(f?: Fn<T>) => (xs: IteratorObject<T>) => void;
+export declare const some: <T>(f: Pred<T>) => (xs: IteratorObject<T>) => boolean;
+export declare const every: <T>(f: Pred<T>) => (xs: IteratorObject<T>) => boolean;
+export declare const find: <T>(f: Pred<T>) => (xs: IteratorObject<T>) => T | undefined;
+export declare const flat: <T>(xs: IteratorObject<IteratorObject<T>>) => IteratorObject<T, undefined, unknown>;
+export declare const prepend: <A>(ys: IteratorObject<A>) => (xs: IteratorObject<A>) => Generator<A, void, unknown>;
+export declare const append: <A>(ys: IteratorObject<A>) => (xs: IteratorObject<A>) => Generator<A, void, unknown>;
+export declare const first: <T>(xs: IteratorObject<T>) => T | undefined;
+export declare const reduce: <T, S>(f: FnV<[S, T], S>, a: S) => (xs: IteratorObject<T>) => S;
+export declare const traverse: <T>(children: Fn<T, Iterable<T>>, f: Fn<T>) => Fn<T>;
+export declare const take: (n: number) => <T>(xs: IteratorObject<T>) => Generator<T>;
+export declare function arange(a: number, b?: number, s?: number): Generator<number, void, unknown>;
+export declare const linspace: (a: number, b: number, n: number) => Generator<number, void, unknown>;
+export declare const steps: (a: number, b: number, s?: number, o?: number, eps?: number) => Generator<number, void, unknown>;
+export declare const strided: (n: number, s: number) => <T>(xs: Iterable<T>) => Generator<T[], void, unknown>;
+export declare const stopAt: <T>(p: Pred<T>) => (xs: IteratorObject<T>) => Generator<T, void, unknown>;
+export declare const until: (p: Pred<void>) => <A>(xs: IteratorObject<A>) => Generator<A, void, unknown>;
+export type Iterators<T extends any[]> = {
+    [k in keyof T]: IteratorObject<T[k]>;
+};
+export declare function zip<T extends unknown[]>(...xs: Iterators<T>): Generator<T>;
+export declare const iterA: <T>(xs: Promise<T>[]) => AsyncGenerator<Awaited<T>, void, unknown>;
+export declare const forEachA: <T>(f?: Fn<T>) => (xs: AsyncIterable<T>) => Promise<void>;
+export declare const mapA: <A, B>(f: Fn<A, B>) => Fn<AsyncIterator<A>, AsyncIterableIterator<B>>;
+export declare const flatMapA: <A, B>(f: Fn<A, Iterable<B>>) => (xs: AsyncIterator<A>) => AsyncGenerator<Awaited<B>, void, any>;
+export declare const filterA: <A>(f: Pred<A>) => Fn<AsyncIterator<A>, AsyncIterableIterator<A>>;
+export declare const untilA: (p: Pred<void>) => <A>(xs: AsyncIterator<A>) => AsyncGenerator<Awaited<A>, void, unknown>;
+export declare const reduceA: <T, S>(f: FnV<[S, T], S>, a: S) => (xs: AsyncIterator<T>) => Promise<S>;
+export declare const race: (n: number) => <T>(xs: IteratorObject<Promise<T>>) => AsyncGenerator<Awaited<T>, void, unknown>;
+export declare const zmap: <T extends unknown[]>(f: FnV<T>) => (...xs: Iterators<T>) => void;