@cgtk/std 0.0.192 → 0.0.194

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 {};

package/src/object.js

@@ -0,0 +1,13 @@
+export const entries = (o) => Object.entries(o);
+export const keys = (o) => Object.keys(o);
+export const entry = (k, v) => [k, v];
+export const fromEntries = (xs) => Object.fromEntries(xs);
+export const mapEntries = (o, f) => fromEntries(entries(o).map(f));
+export const mapValues = (o, f) => mapEntries(o, ([k, v]) => entry(k, f(v, k)));
+export const pick = (obj, keys) => keys.reduce((a, k) => (a[k] = obj[k], a), {});
+export const omit = (obj, keys) => pick(obj, Object.keys(obj).filter(k => !keys.includes(k)));
+export const assoc = (a, [k, v]) => (a[k] = v, a);
+export const merge = (f) => (x, y) => {
+    const keys = [...new Set(Object.keys(x).concat(Object.keys(y))).keys()];
+    return keys.reduce((a, k) => (a[k] = f(x[k], y[k]), a), {});
+};

package/src/port.d.ts

@@ -0,0 +1,30 @@
+import type { Dispose, Fn, Fns, FnV, RecordOf, MaybePromise, Reactive } from "./types.js";
+export interface Message<K, V> {
+    type: K;
+    payload: V;
+}
+export type Port = {
+    postMessage(message: any, options?: StructuredSerializeOptions): void;
+};
+export declare const onMessages: <S extends RecordOf<any>, T = Worker>(target: MessageEventTarget<T>, fs: Fns<S>) => Dispose;
+export declare const onMessage: <K extends string, S, T = Worker>(target: MessageEventTarget<T>, name: K, f: Fn<S>) => Dispose;
+export declare const messageSources: <T extends RecordOf<any>, S = Worker>(worker: MessageEventTarget<S>) => { [K in keyof T]: Reactive<T[K]>; };
+export declare const postMessages: <T extends RecordOf<any>>(port: Port) => { [k in keyof T]: FnV<[T[k], (StructuredSerializeOptions | undefined)?]>; };
+export interface Request {
+    id: number;
+    name: PropertyKey;
+    args: any;
+}
+export interface Response {
+    id: number;
+    result: any;
+}
+interface TransferableFnV<T extends any[], R> {
+    (...args: T): R;
+    transfer(ts?: Transferable[]): FnV<T, R>;
+}
+export declare const client: <S extends RecordOf<any>, T = Worker>(target: Port & MessageEventTarget<T>) => { [k in keyof S]: TransferableFnV<Parameters<S[k]>, Promise<ReturnType<S[k]>>>; };
+export declare const server: <S extends RecordOf<any>, T = Worker>(target: Port & MessageEventTarget<T>) => { [k in keyof S]: Fn<FnV<Parameters<S[k]>, MaybePromise<ReturnType<S[k]>>>, Dispose>; };
+export declare const startClient: (worker: Worker, f: Fn<Worker, Dispose | void>) => Promise<Dispose>;
+export declare const startServer: (worker: Worker, f: Fn<Worker, MaybePromise<Dispose>>) => Promise<Dispose>;
+export {};

package/src/port.js

@@ -0,0 +1,56 @@
+import { forEach, noop, bind } from "./fn.js";
+import { isDefined } from "./checks.js";
+import { on } from "./dom.js";
+import { promise } from "./async.js";
+;
+export const onMessages = (target, fs) => on(target, "message", ({ data: { type, payload } }) => (type in fs) && fs[type](payload));
+export const onMessage = (target, name, f) => on(target, "message", ({ data: { type, payload } }) => type == name && f(payload));
+export const messageSources = (worker) => new Proxy({}, {
+    get: (_, k) => bind((onMessage), worker, k)
+});
+export const postMessages = (port) => new Proxy({}, {
+    get: (_, type) => (payload, options) => port.postMessage({ type, payload }, options)
+});
+export const client = (target) => {
+    const fns = new Map();
+    onMessage(target, "rpc", ({ id, result }) => {
+        const f = fns.get(id);
+        if (isDefined(f))
+            f(result), fns.delete(id);
+    });
+    const { rpc } = postMessages(target);
+    let _id = 0;
+    return new Proxy({}, {
+        get(_, name) {
+            const g = (transfer) => (...args) => {
+                const id = _id++;
+                rpc({ id, name, args }, { transfer });
+                return new Promise(resolve => fns.set(id, resolve));
+            };
+            const f = ((...args) => g()(...args));
+            f.transfer = g;
+            return f;
+        }
+    });
+};
+export const server = (target) => {
+    const fns = new Map();
+    const { rpc } = postMessages(target);
+    onMessage(target, "rpc", async ({ id, name, args }) => {
+        const f = fns.get(name);
+        if (isDefined(f))
+            rpc({ id, result: await promise(f(...args)) });
+    });
+    return new Proxy({}, {
+        get: (_, k) => (f) => (fns.set(k, f), () => fns.delete(k))
+    });
+};
+export const startClient = async (worker, f) => {
+    const cli = client(worker);
+    await cli.start();
+    return forEach(f(worker) ?? noop, () => cli.stop().then(() => worker.terminate()));
+};
+export const startServer = async (worker, f) => {
+    const ser = server(worker);
+    return ser.start(async () => { ser.stop(await promise(f(worker))); });
+};

package/src/progress.d.ts

@@ -0,0 +1,6 @@
+import type { Fn } from './types.js';
+export type Progress = {
+    begin: Fn<void>;
+    progress: Fn<number>;
+    end: Fn<void>;
+};

package/src/progress.js

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

package/src/rect.d.ts

@@ -0,0 +1,5 @@
+import type { Tuple } from "./types.js";
+export type Rect = Tuple<number, 4>;
+export declare const rect: (x: number, y: number, w: number, h: number) => Rect;
+export declare const vertical: (ratio: number[]) => (i: number) => ([x, _, w, h]: Rect) => Rect;
+export declare const horizontal: (ratio: number[]) => (i: number) => ([_, y, w, h]: Rect) => Rect;

package/src/rect.js

@@ -0,0 +1,16 @@
+import { add } from "./number.js";
+export const rect = (x, y, w, h) => [x, y, w, h];
+export const vertical = (ratio) => {
+    const tot = ratio.reduce(add, 0);
+    const cum = [0];
+    ratio.forEach(x => cum.push(x / tot + cum[cum.length - 1]));
+    cum.pop();
+    return (i) => ([x, _, w, h]) => [x, cum[i] * h, w, ratio[i] / tot * h];
+};
+export const horizontal = (ratio) => {
+    const tot = ratio.reduce(add, 0);
+    const cum = [0];
+    ratio.forEach(x => cum.push(x / tot + cum[cum.length - 1]));
+    cum.pop();
+    return (i) => ([_, y, w, h]) => [cum[i] * w, y, ratio[i] / tot * w, h];
+};

package/src/resource.d.ts

@@ -0,0 +1,12 @@
+import type { Fn, Dispose, Structure, Reactive } from "./types.js";
+export type Resource<T> = Reactive<T, Dispose | void> & {
+    value: T;
+    dispose: Dispose;
+    map<S>(f: Fn<T, S>): Resource<S>;
+};
+export declare const resource: <T>(value: T, dispose?: Dispose) => Resource<T>;
+type Unwrapped<T> = T extends Resource<infer U> ? U : {
+    [K in keyof T]: Unwrapped<T[K]>;
+};
+export declare const compose: <R extends Structure<Resource<any>>>(rs: R) => Resource<Unwrapped<R>>;
+export {};

package/src/resource.js

@@ -0,0 +1,28 @@
+import { forEach, noop } from "./fn.js";
+import { isFunction } from "./checks.js";
+export const resource = (value, dispose = noop) => {
+    const res = ((f) => forEach(f(value) ?? noop, dispose));
+    res.value = value;
+    res.dispose = dispose;
+    res.map = (f) => resource(f(value), dispose);
+    return res;
+};
+const isResource = (r) => isFunction(r)
+    && Object.hasOwn(r, "value")
+    && Object.hasOwn(r, "dispose")
+    && isFunction(r["dispose"]);
+export const compose = (rs) => {
+    const disposes = [];
+    const rec = (rs) => {
+        if (isResource(rs)) {
+            disposes.push(rs.dispose);
+            return rs.value;
+        }
+        else if (Array.isArray(rs)) {
+            return rs.map(rec);
+        }
+        return Object.fromEntries(Object.entries(rs).map(([k, v]) => [k, rec(v)]));
+    };
+    const value = rec(rs);
+    return resource(value, forEach(...disposes));
+};

package/src/schedule.d.ts

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

package/src/schedule.js

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

package/src/set.d.ts

@@ -0,0 +1,2 @@
+export declare const add: <T>(xs: Set<T>, x: T) => () => boolean;
+export declare const isEqual: <T>(a: Set<T>, b: Set<T>) => boolean;