@cgtk/std 0.0.193 → 0.0.194

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);
+}));

package/src/index.d.ts

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

package/src/index.js

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

package/src/iterable.d.ts

@@ -0,0 +1,43 @@
+import type { Fn, FnV, Indexed, Pred } from "./types.js";
+export declare const next: <T>(xs: Iterator<T>) => T;
+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, number], S>, a: S) => (xs: IteratorObject<T>) => S;
+export declare const reduceRec: <T, A, R>(xs: IteratorObject<T>, f: FnV<[A, T, Fn<A>], R>, o: A, result: Fn<A, R>) => R;
+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;

package/src/iterable.js

@@ -0,0 +1,158 @@
+import { assert, isDefined } from "./checks.js";
+import { pipe, comp, scan, apply, noop, identity, constantly } from "./fn.js";
+import { set } from "./map.js";
+export const next = (xs) => {
+    const { done, value } = xs.next();
+    assert(isDefined(done) && !done, "iterator done");
+    return value;
+};
+export const repeat = n => function* (x) { for (let i = 0; i < n; i++)
+    yield x; };
+export const just = function* (x) { yield x; };
+export const enumerate = (n = 0) => x => [n++, x];
+export function* empty() { }
+;
+export function* concat(...xxs) { for (const xs of xxs)
+    yield* xs; }
+;
+export const toArray = (xs) => xs.toArray();
+export const map = (f) => (xs) => xs.map(f);
+export const filter = (f) => (xs) => xs.filter(f);
+export const drop = (n) => (xs) => xs.drop(n);
+export const flatMap = (f) => (xs) => xs.flatMap(f);
+export const forEach = (f = noop) => (xs) => xs.forEach(f);
+export const some = (f) => (xs) => xs.some(f);
+export const every = (f) => (xs) => xs.every(f);
+export const find = (f) => (xs) => xs.find(f);
+export const flat = (xs) => xs.flatMap(identity);
+export const prepend = (ys) => (xs) => concat(ys, xs);
+export const append = (ys) => (xs) => concat(xs, ys);
+export const first = (xs) => xs.find(constantly(true));
+export const reduce = (f, a) => (xs) => xs.reduce(f, a);
+export const reduceRec = (xs, f, o, result) => {
+    const next = (o) => {
+        const { done, value } = xs.next();
+        if (done)
+            return result(o);
+        else
+            return f(o, value, next);
+    };
+    return next(o);
+};
+export const traverse = (children, f) => (x) => (f(x), forEach(traverse(children, f))(Iterator.from(children(x))));
+export const take = n => function* (xs) {
+    for (let i = 0; i < n; i++) {
+        const { done, value } = xs.next();
+        if (done)
+            break;
+        yield value;
+    }
+};
+export function* arange(a, b = Number.NaN, s = 1) {
+    if (Number.isNaN(b))
+        b = a, a = 0;
+    for (let i = a; i < b; i += s)
+        yield i;
+}
+export const linspace = (a, b, n) => arange(a, b + 1e-6, (b - a) / (n - 1));
+export const steps = (a, b, s = 1, o = 0, eps = 1e-8) => {
+    const start = Math.floor((a - o + s - eps) / s) * s + o;
+    const end = Math.floor((b - o) / s) * s + o;
+    return arange(start, end + s - eps, s);
+};
+export const strided = (n, s) => function* (xs) {
+    const cur = [];
+    for (const x of xs) {
+        cur.push(x);
+        if (cur.length == n) {
+            yield cur;
+            for (let i = 0; i < s; i++)
+                cur.shift();
+        }
+    }
+};
+export const stopAt = (p) => function* (xs) {
+    let x = xs.next();
+    while (!x.done) {
+        yield x.value;
+        if (p(x.value))
+            return;
+        x = xs.next();
+    }
+};
+export const until = (p) => function* (xs) {
+    if (p())
+        return;
+    let x = xs.next();
+    while (!x.done) {
+        yield x.value;
+        if (p())
+            return;
+        x = xs.next();
+    }
+};
+export function* zip(...xs) {
+    let val = xs.map(x => x.next());
+    while (val.every(x => !x.done)) {
+        yield val.map(x => x.value);
+        val = xs.map(x => x.next());
+    }
+}
+;
+export const iterA = async function* (xs) {
+    for await (const x of xs)
+        yield x;
+};
+export const forEachA = (f = noop) => async (xs) => {
+    for await (const x of xs)
+        f(x);
+};
+export const mapA = f => async function* (xs) {
+    let x = await xs.next();
+    while (!x.done)
+        yield f(x.value), x = await xs.next();
+};
+export const flatMapA = (f) => async function* (xs) {
+    let x = await xs.next();
+    while (!x.done) {
+        yield* f(x.value);
+        x = await xs.next();
+    }
+};
+export const filterA = f => async function* (xs) {
+    let x = await xs.next();
+    while (!x.done) {
+        if (f(x.value))
+            yield x.value;
+        x = await xs.next();
+    }
+};
+export const untilA = (p) => async function* (xs) {
+    if (p())
+        return;
+    let x = await xs.next();
+    while (!x.done) {
+        yield x.value;
+        if (p())
+            return;
+        x = await xs.next();
+    }
+};
+export const reduceA = (f, a) => async (xs) => {
+    const g = scan(f, a);
+    await forEachA()(mapA((x) => a = g(x))(xs));
+    return a;
+};
+export const race = (n) => async function* (xs) {
+    const it = pipe(xs, map(enumerate()), map(([i, x]) => [i, x.then(y => [i, y])]));
+    const accum = reduce((set), new Map());
+    const tasks = pipe(it, (take(n)), accum);
+    const next = comp((take(1)), accum);
+    while (tasks.size > 0) {
+        const [i, x] = await Promise.race(tasks.values());
+        tasks.delete(i);
+        yield x;
+        next(it);
+    }
+};
+export const zmap = (f) => (...xs) => forEach(apply(f))(zip(...xs));

package/src/json.d.ts

@@ -0,0 +1 @@
+export declare const fromBytes: (data: AllowSharedBufferSource, options?: TextDecodeOptions) => any;

package/src/json.js

@@ -0,0 +1 @@
+export const fromBytes = (data, options) => JSON.parse(new TextDecoder("utf-8").decode(data, options));

package/src/map.d.ts

@@ -0,0 +1,12 @@
+import type { FnV, Maybe } from "./types.js";
+export declare const transform: <K, S, V>({ create, update, remove }: {
+    create: FnV<[S, K, Map<K, V>], V>;
+    update: FnV<[V, S, K, Map<K, V>], V>;
+    remove?: FnV<[V, K, Map<K, V>]>;
+}, dst?: Map<K, V>) => (src: Map<K, S>) => Map<K, V>;
+export declare const set: <K, V>(m: Map<K, V>, [i, x]: [K, V]) => Map<K, V>;
+export declare const get: <K, V>(m: Map<K, V>, k: K, d: V) => V;
+export declare const update: <K, V>(m: Map<K, V>, k: K, f: FnV<[V | undefined, K, Map<K, V>], V>) => Map<K, V>;
+export declare const first: <K, V>(m: Map<K, V>) => Maybe<V>;
+export declare const shift: <K, V>(m: Map<K, V>) => Maybe<[K, V]>;
+export declare const reduce: <K, V, T>(m: Map<K, V>, f: FnV<[T, V, K, Map<K, V>], T>, a: T) => T;

package/src/map.js

@@ -0,0 +1,35 @@
+import { isDefined } from "./checks.js";
+import * as I from "./iterable.js";
+export const transform = ({ create, update, remove }, dst = new Map()) => (src) => {
+    for (const k of dst.keys())
+        if (!src.has(k)) {
+            remove && remove(dst.get(k), k, dst);
+            dst.delete(k);
+        }
+    src.forEach((v, k) => {
+        if (!dst.has(k))
+            dst.set(k, create(v, k, dst));
+        else
+            dst.set(k, update(dst.get(k), v, k, dst));
+    });
+    return dst;
+};
+export const set = (m, [i, x]) => (m.set(i, x), m);
+export const get = (m, k, d) => m.has(k) ? m.get(k) : d;
+export const update = (m, k, f) => set(m, [k, f(m.get(k), k, m)]);
+export const first = (m) => {
+    const k = I.first(m.keys());
+    if (isDefined(k))
+        return m.get(k);
+    return undefined;
+};
+export const shift = (m) => {
+    const k = I.first(m.keys());
+    if (isDefined(k)) {
+        const v = m.get(k);
+        m.delete(k);
+        return [k, v];
+    }
+    return undefined;
+};
+export const reduce = (m, f, a) => (m.forEach((v, k) => a = f(a, v, k, m)), a);

package/src/math.d.ts

@@ -0,0 +1,34 @@
+export declare const PI: number;
+export declare const TAU: number;
+export declare const HALF_PI: number;
+export declare const THIRD_PI: number;
+export declare const QUARTER_PI: number;
+export declare const SIXTH_PI: number;
+export declare const SQRT2: number;
+export declare const GOLDEN: number;
+export declare const FOUR_OVER_PI: number;
+export declare const INV_PI: number;
+export declare const INV_TAU: number;
+export declare const INV_HALF_PI: number;
+export declare const U32_MAX = 4294967295;
+export declare const EPS: number;
+export declare const radians: (x: number) => number;
+export declare const degrees: (x: number) => number;
+export declare const safeSqrt: (x: number) => number;
+export declare const lerp: (a: number, b: number, t: number) => number;
+export declare const clamp: (a: number, b: number, x: number) => number;
+export declare const saturate: (x: number) => number;
+export declare const norm: (a: number, b: number, x: number) => number;
+export declare const fit: (a: number, b: number, c: number, d: number, x: number) => number;
+export declare const efit: (a: number, b: number, c: number, d: number, x: number) => number;
+export declare const fit01: (a: number, b: number, x: number) => number;
+export declare const ewmabc: (beta?: number, t?: number) => (x: number) => number;
+export declare const sinc: (x: number) => number;
+export declare const nextpow2: (x: number) => number;
+export declare const mod: (x: number, m: number) => number;
+export declare const logn: (n: number, x: number) => number;
+export declare const floordiv: (x: number, b: number) => number;
+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;

package/src/math.js

@@ -0,0 +1,43 @@
+import { isclose } from "./checks.js";
+export const PI = Math.PI;
+export const TAU = PI * 2;
+export const HALF_PI = PI / 2;
+export const THIRD_PI = PI / 3;
+export const QUARTER_PI = PI / 4;
+export const SIXTH_PI = PI / 6;
+export const SQRT2 = Math.sqrt(2);
+export const GOLDEN = (1 + 5 ** .5) * .5;
+export const FOUR_OVER_PI = 4 / Math.PI;
+export const INV_PI = 1 / PI;
+export const INV_TAU = 1 / TAU;
+export const INV_HALF_PI = 1 / HALF_PI;
+export const U32_MAX = 0xFFFFFFFF;
+export const EPS = Number.EPSILON;
+const DEG2RAD = PI / 180, RAD2DEG = 180 / PI;
+export const radians = (x) => x * DEG2RAD;
+export const degrees = (x) => x * RAD2DEG;
+export const safeSqrt = (x) => Math.sqrt(Math.max(x, 0));
+export const lerp = (a, b, t) => a * (1 - t) + b * t;
+export const clamp = (a, b, x) => Math.max(a, Math.min(b, x));
+export const saturate = (x) => clamp(0, 1, x);
+export const norm = (a, b, x) => (x - a) / ((b - a));
+// https://www.sidefx.com/docs/houdini/expressions/fit.html
+export const fit = (a, b, c, d, x) => lerp(c, d, saturate(norm(a, b, x)));
+// https://www.sidefx.com/docs/houdini/expressions/efit.html
+export const efit = (a, b, c, d, x) => lerp(c, d, norm(a, b, x));
+// https://www.sidefx.com/docs/houdini/expressions/fit01.html
+export const fit01 = (a, b, x) => lerp(a, b, saturate(x));
+export const ewmabc = (beta = .8, t = 1) => {
+    let z = 0, bc = beta ** (t - 1);
+    return (x) => (z = lerp(x, z, beta)) / (1 - (bc *= beta));
+};
+export const sinc = (x) => x < Number.EPSILON ? 1.0 : Math.sin(x) / x;
+export const nextpow2 = (x) => Math.ceil(Math.log2(Math.abs(x)));
+export const mod = (x, m) => ((x % m) + m) % m;
+export const logn = (n, x) => Math.log(x) / Math.log(n);
+// https://www.desmos.com/calculator/ybbuznxbcc
+export const floordiv = (x, b) => Math.floor(x / b + (x < 0 ? 1 : 0));
+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;

package/src/npy.d.ts

@@ -0,0 +1,10 @@
+import type { TypedArray, Elements } from "./types.js";
+declare const DTYPES: readonly ["|u1", "<u2", "<u4", "|i1", "<i2", "<i4", "<f4", "<f8"];
+type DType = Elements<typeof DTYPES>;
+export interface NDArray {
+    data: TypedArray;
+    dtype: DType;
+    shape: number[];
+}
+export declare const read: (buf: ArrayBuffer) => NDArray;
+export {};

package/src/npy.js

@@ -0,0 +1,29 @@
+const DTYPES = [
+    "|u1", "<u2", "<u4",
+    "|i1", "<i2", "<i4",
+    "<f4", "<f8",
+    // "<u8", "<i8", 
+];
+const TYPED_ARRAY = {
+    "|u1": Uint8Array,
+    "<u2": Uint16Array,
+    "<u4": Uint32Array,
+    "|i1": Int8Array,
+    "<i2": Int16Array,
+    "<i4": Int32Array,
+    "<f4": Float32Array,
+    "<f8": Float64Array,
+    // "<u8": BigUint64Array,
+    // "<i8": BigInt64Array,
+};
+export const read = (buf) => {
+    const headerLength = new DataView(buf.slice(8, 10)).getUint8(0);
+    const hcontents = new TextDecoder("utf-8").decode(buf.slice(10, 10 + headerLength));
+    const { descr, shape } = JSON.parse(hcontents
+        .replace(/'/g, '"')
+        .replace("False", "false")
+        .replace("(", "[")
+        .replace(/,*\),*/g, "]"));
+    const data = new TYPED_ARRAY[descr](buf, headerLength + 10);
+    return { data, shape, dtype: descr };
+};

package/src/number.d.ts

@@ -0,0 +1,4 @@
+export declare const add: (a: number, x: number) => number;
+export declare const toFixed: (x: number | bigint, n?: number) => string | bigint;
+export declare const toFixedMax: (x: number, n?: number) => string;
+export declare const roundTo: (x: number, n: number) => number;

package/src/number.js

@@ -0,0 +1,13 @@
+import { isBigInt } from "./checks.js";
+export const add = (a, x) => a + x;
+export const toFixed = (x, n = 0) => isBigInt(x) ? x : x.toFixed(n);
+export const toFixedMax = (x, n = 0) => {
+    const y = Number(x.toFixed(n));
+    return `${Math.sign(y) == -1 ? '-' : ''}${Math.abs(y)}`;
+};
+export const roundTo = (x, n) => {
+    const inv = 1. / n;
+    const result = Math.round(x * inv) / inv;
+    const decimals = n.toString().split(".")[1]?.length || 0;
+    return parseFloat(result.toFixed(decimals));
+};

package/src/object.d.ts

@@ -0,0 +1,15 @@
+import type { RecordOf, Elements, Maybe, FnV, ValueOf, EntriesTuple, UnionToTuple, Entry } from "./types.js";
+export declare const entries: <T extends RecordOf<any>>(o: T) => EntriesTuple<T>;
+export declare const keys: <T extends RecordOf<any>>(o: T) => UnionToTuple<keyof T>;
+export declare const entry: <K extends PropertyKey, V>(k: K, v: V) => Entry<K, V>;
+export declare const fromEntries: <T extends Entry<PropertyKey, any>[]>(xs: T) => { [K in T[number] as K[0]]: K[1]; };
+export declare const mapEntries: <T extends RecordOf<any>, S>(o: T, f: FnV<[Entry<keyof T, ValueOf<T>>, number], Entry<keyof T, S>>) => { [K in Entry<keyof T, S> as K[0]]: K[1]; };
+export declare const mapValues: <T extends RecordOf<any>, S>(o: T, f: FnV<[ValueOf<T>, keyof T], S>) => { [K in Entry<keyof T, S> as K[0]]: K[1]; };
+export declare const pick: <T extends RecordOf<any>, R extends Array<keyof T>>(obj: T, keys: R) => Pick<T, Elements<R>>;
+export declare const omit: <T extends RecordOf<any>, R extends Array<keyof T>>(obj: T, keys: R) => Omit<T, Elements<R>>;
+export declare const assoc: <T extends RecordOf<any>>(a: T, [k, v]: [keyof T, ValueOf<T>]) => T;
+type Merge<T extends RecordOf<unknown>, S extends RecordOf<unknown>, V> = {
+    [K in keyof (T & S)]: V;
+};
+export declare const merge: <T, S = T, V = T>(f: FnV<[Maybe<T>, Maybe<S>], V>) => <X extends RecordOf<T>, Y extends RecordOf<T>>(x: X, y: Y) => Merge<X, Y, V>;
+export {};