@cgtk/std 0.0.182

package/iterable.js

@@ -0,0 +1,142 @@
+import { pipe, comp, scan, apply, noop, identity, constantly } from "./fn.js";
+import { set } from "./map.js";
+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 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/json.d.ts

@@ -0,0 +1 @@
+export declare const fromBytes: (data: Uint8Array) => any;

package/json.js

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

package/map.d.ts

@@ -0,0 +1,13 @@
+import type { Fn, FnV, Optional } from "./types.js";
+export declare const map: <T, V, K = any>({ create, update, remove }: {
+    create: FnV<[T, K, Map<K, V>], V>;
+    update: FnV<[V, T, K, Map<K, V>], V>;
+    remove?: FnV<[V, K, Map<K, V>]>;
+}) => (dst?: Map<K, V>) => (src: Map<K, T>) => Map<K, V>;
+export declare const mapAlloc: <T, S, K = any>(f: FnV<[T, S]>, alloc: Fn<void, T>, remove?: FnV<[T, K, Map<K, T>]>) => (dst?: Map<K, T>) => (src: Map<K, S>) => Map<K, T>;
+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>) => Optional<V>;
+export declare const shift: <K, V>(m: Map<K, V>) => Optional<[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/map.js

@@ -0,0 +1,36 @@
+import { isDefined } from "./checks.js";
+import * as I from "./iterable.js";
+export const map = ({ 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 mapAlloc = (f, alloc, remove) => map({ create: e => f(alloc(), e), update: f, remove });
+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/math.d.ts

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

package/math.js

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

package/number.d.ts

@@ -0,0 +1,2 @@
+export declare const add: (a: number, x: number) => number;
+export declare const toFixedMax: (x: number, n?: number) => string;

package/number.js

@@ -0,0 +1,5 @@
+export const add = (a, x) => a + x;
+export const toFixedMax = (x, n = 0) => {
+    const y = Number(x.toFixed(n));
+    return `${Math.sign(y) == -1 ? '-' : ''}${Math.abs(y)}`;
+};

package/object.d.ts

@@ -0,0 +1,13 @@
+import type { RecordOf, Elements, Optional, Fn, FnV } from "./types.js";
+export declare const mapEntries: <S, T = S>(f: FnV<[[string, S], number], [string, T]>) => Fn<RecordOf<S>, RecordOf<T>>;
+export declare const mapValues: <S, T = S>(f: FnV<[S, string, number], T>) => Fn<RecordOf<S>, RecordOf<T>>;
+export declare const rename: <S>(keys: RecordOf<string>) => Fn<RecordOf<S>, RecordOf<S>>;
+export declare const renameWith: <S>(f: Fn<string, string>) => Fn<RecordOf<S>, RecordOf<S>>;
+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>(a: RecordOf<T>, [k, v]: [keyof T, T]) => RecordOf<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<[Optional<T>, Optional<S>], V>) => <X extends RecordOf<T>, Y extends RecordOf<T>>(x: X, y: Y) => Merge<X, Y, V>;
+export {};

package/object.js

@@ -0,0 +1,11 @@
+export const mapEntries = (f) => obj => Object.fromEntries(Object.entries(obj).map(f));
+export const mapValues = (f) => mapEntries(([k, v], i) => [k, f(v, k, i)]);
+export const rename = (keys) => mapEntries(([k, v]) => [keys[k] ?? k, v]);
+export const renameWith = (f) => mapEntries(([k, v]) => [f(k), v]);
+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/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@cgtk/std",
+  "version": "0.0.182",
+  "type": "module",
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js",
+    "./types": "./types.js",
+    "./checks": "./checks.js",
+    "./fn": "./fn.js",
+    "./object": "./object.js",
+    "./signal": "./signal.js",
+    "./assign": "./assign.js",
+    "./map": "./map.js",
+    "./array": "./array.js",
+    "./string": "./string.js",
+    "./number": "./number.js",
+    "./typedarray": "./typedarray.js",
+    "./async": "./async.js",
+    "./schedule": "./schedule.js",
+    "./iterable": "./iterable.js",
+    "./gen": "./gen.js",
+    "./tree": "./tree.js",
+    "./treemap": "./treemap.js",
+    "./stream": "./stream.js",
+    "./progress": "./progress.js",
+    "./constants": "./constants.js",
+    "./http": "./http.js",
+    "./json": "./json.js",
+    "./dom": "./dom.js",
+    "./weak": "./weak.js",
+    "./math": "./math.js",
+    "./basen": "./basen.js",
+    "./struct": "./struct.js",
+    "./buffer": "./buffer.js",
+    "./utils": "./utils.js"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

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

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

package/schedule.d.ts

@@ -0,0 +1,8 @@
+import type { Fn, FnV, Reactive } from './types';
+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) => (...xs: Parameters<F>) => ReturnType<Fn<Parameters<F>>>;
+export declare const debounce: <T>(sched?: Reactive<T>) => Reactive<T>;
+export declare const reset: <T>(sched?: Reactive<T>) => Reactive<T>;
+export declare const repeatedly: (sched?: Reactive<any>) => (f: Fn<void>) => () => any;
+export declare const toggler: (f: Fn<void, Fn<void>>) => (x: boolean) => Fn<void>;

package/schedule.js

@@ -0,0 +1,44 @@
+import { isUndefined, isDefined } from './checks';
+import { comp, lazy, noop, bind, apply, call } from './fn';
+export const raf = f => {
+    const id = requestAnimationFrame(f);
+    return () => cancelAnimationFrame(id);
+};
+export const timeout = (ms) => (f) => {
+    const id = setTimeout(f, ms);
+    return () => clearTimeout(id);
+};
+export const schedule = (s) => (f) => {
+    const g = bind(lazy, f);
+    return call(comp(apply(g), s));
+};
+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;
+    const stop = () => { if (isDefined(cancel))
+        cancel(), cancel = undefined; };
+    return (f) => {
+        stop();
+        cancel = sched(f);
+        return stop;
+    };
+};
+export const repeatedly = (sched = raf) => (f) => {
+    let cancel;
+    const g = () => (f(), (cancel = sched(g)));
+    cancel = sched(g);
+    return () => cancel();
+};
+export const toggler = (f) => {
+    let cancel = noop;
+    return (x) => (cancel(), (cancel = x ? f() : noop));
+};

package/signal.d.ts

@@ -0,0 +1,19 @@
+import type { Fn, FnV, Reactive, RecordOf } from "./types";
+export type Signal<T> = Fn<T> & {
+    on: Reactive<T>;
+};
+export declare const create: <A>(f: Fn<A>, on: Reactive<A>) => Signal<A>;
+export declare const signal: <T>(fns?: Set<Fn<T>>) => Signal<T>;
+export interface Value<T> {
+    value: T;
+    on: Reactive<T>;
+    op: <F extends FnV>(f: Fn<T, F>) => F;
+    ops: <F extends RecordOf<FnV>>(f: Fn<T, F>) => F;
+    set: Fn<T>;
+    update: Fn;
+}
+export declare const value: <T>(x: T) => Value<T>;
+export type Values<T extends RecordOf<any>> = {
+    [key in keyof T]: Value<T[key]>;
+};
+export declare const values: <T extends RecordOf<any>>(vals: T) => Values<T>;

package/signal.js

@@ -0,0 +1,25 @@
+import { after, constantly, noop } from "./fn";
+import { mapValues } from "./object";
+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)), (f) => (fns.add(f), () => fns.delete(f)));
+;
+export const value = (x) => {
+    const sig = signal();
+    const notify = after(() => sig(x));
+    const op = (f) => notify(f(x));
+    const mop = mapValues(notify);
+    return {
+        get value() { return x; },
+        set value(y) { sig(x = y); },
+        op,
+        on: (f) => (f(x), sig.on(f)),
+        ops: (f) => mop(f(x)),
+        set: op(constantly((y) => x = y)),
+        update: op(constantly(noop))
+    };
+};
+export const values = (vals) => mapValues(value)(vals);

package/stream.d.ts

@@ -0,0 +1,6 @@
+import type { Fn } from "./types";
+export declare const readable: <T>(x: T) => ReadableStream<any>;
+export declare function iterate<T>(rs: ReadableStream<T>): AsyncGenerator<Awaited<T>, void, unknown>;
+export declare const map: <T, S>(f: Fn<T, S>) => TransformStream<T, S>;
+export declare const tap: <T>(start: TransformerStartCallback<T> | undefined, t: Fn<T>, flush?: TransformerFlushCallback<T>) => TransformStream<T, any>;
+export declare const reduceArray: <T>(stream: ReadableStream<T>, xs?: T[]) => Promise<T[]>;

package/stream.js

@@ -0,0 +1,26 @@
+import { push } from "./array";
+import { reduceA } from "./iterable";
+export const readable = (x) => new ReadableStream({
+    start: c => (c.enqueue(x), c.close())
+});
+export async function* iterate(rs) {
+    const reader = rs.getReader();
+    try {
+        let x = await reader.read();
+        while (!x.done)
+            yield x.value, x = await reader.read();
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+export const map = (f) => new TransformStream({ transform(x, c) { c.enqueue(f(x)); } });
+export const tap = (start, t, flush) => new TransformStream({
+    start,
+    transform(x, c) {
+        t(x);
+        c.enqueue(x);
+    },
+    flush
+});
+export const reduceArray = (stream, xs = []) => reduceA((push), xs)(iterate(stream));

package/string.d.ts

@@ -0,0 +1,5 @@
+export declare const basename: (path: string) => string;
+export declare const dirname: (path: string) => string;
+export declare const objectURL: (data: Uint8Array, type: string) => string;
+export declare const decode: (label?: string, opts?: TextDecoderOptions) => (x: Uint8Array, stream?: boolean) => string;
+export declare const readLine: (delims?: Set<number>) => (data: Uint8Array, offset?: number) => string;

package/string.js

@@ -0,0 +1,22 @@
+import { EMPTY } from "./constants";
+import { seek } from "./array";
+export const basename = (path) => path.split("/").at(-1) ?? "";
+export const dirname = (path) => {
+    const parts = path.split("/");
+    parts.pop();
+    return parts.join("/");
+};
+export const objectURL = (data, type) => URL.createObjectURL(new Blob([data], { type }));
+export const decode = (label = "utf-8", opts = {
+    fatal: false, ignoreBOM: false
+}) => {
+    const decoder = new TextDecoder(label, opts);
+    return (x, stream = false) => decoder.decode(x, { stream });
+};
+export const readLine = (delims = new Set([0x0A])) => {
+    const dec = decode();
+    return (data, offset = 0) => {
+        const n = seek(data, delims, offset);
+        return n > 0 ? dec(data.subarray(offset, n + 1)) : EMPTY.STR;
+    };
+};

package/struct.d.ts

@@ -0,0 +1,25 @@
+import type { TypedArray } from "./types";
+export interface View<T> {
+    (buf?: ArrayBuffer, offset?: number, length?: number): T;
+    size: number;
+    align: number;
+}
+type Inner<T> = T extends View<infer U> ? U : never;
+type Num<T extends TypedArray> = View<T> & {
+    length: 1;
+};
+export declare const u8: Num<Uint8Array<ArrayBufferLike>>;
+export declare const u16: Num<Uint16Array<ArrayBufferLike>>;
+export declare const u32: Num<Uint32Array<ArrayBufferLike>>;
+export declare const i8: Num<Int8Array<ArrayBufferLike>>;
+export declare const i16: Num<Int16Array<ArrayBufferLike>>;
+export declare const i32: Num<Int32Array<ArrayBufferLike>>;
+export declare const f32: Num<Float32Array<ArrayBufferLike>>;
+export declare const f64: Num<Float64Array<ArrayBufferLike>>;
+export declare const vec: <T extends TypedArray, N extends number>(t: Num<T>, length: N, align?: number, size?: number) => View<T>;
+export declare const array: <T>(type: View<T>, length: number, size?: number, align?: number) => View<T[]>;
+type Struct<T extends ReadonlyArray<readonly [string, View<any>]>> = View<{
+    [K in T[number] as K[0]]: K[1] extends Num<any> ? number : Inner<K[1]>;
+}>;
+export declare const struct: <T extends ReadonlyArray<readonly [string, View<any>]>>(fs: T) => Struct<T>;
+export {};

package/struct.js

@@ -0,0 +1,58 @@
+import { align as _align } from "./math";
+import { isTypedArray } from "./checks";
+import * as TA from "./typedarray";
+const property = (value) => ({
+    enumerable: true,
+    ...(isTypedArray(value) && value.length == 1 ? {
+        get: () => value[0],
+        set: (x) => value[0] = x,
+    } : { value })
+});
+const num = (t) => {
+    const f = ((buf, offset, length = 1) => new t(buf, offset, length));
+    f.size = t.BYTES_PER_ELEMENT;
+    f.align = t.BYTES_PER_ELEMENT;
+    return f;
+};
+export const u8 = num(Uint8Array);
+export const u16 = num(Uint16Array);
+export const u32 = num(Uint32Array);
+export const i8 = num(Int8Array);
+export const i16 = num(Int16Array);
+export const i32 = num(Int32Array);
+export const f32 = num(Float32Array);
+export const f64 = num(Float64Array);
+export const vec = (t, length, align = t.align, size = t.size * length) => {
+    const f = ((buf = new ArrayBuffer(size), offset = 0) => t(buf, offset, length));
+    f.size = _align(size, align);
+    f.align = align;
+    return f;
+};
+export const array = (type, length, size = type.size * length, align = type.align) => {
+    const f = ((buf = new ArrayBuffer(size), offset = 0) => Array.from({ length }, (_, i) => type(buf, offset + i * _align(type.size, type.align))));
+    f.size = size;
+    f.align = align;
+    return f;
+};
+export const struct = (fs) => {
+    let align = 0, offset = 0;
+    const fields = {}, offsets = {};
+    for (const [name, type] of fs) {
+        align = Math.max(align, type.align);
+        offset = _align(offset, type.align);
+        fields[name] = type;
+        offsets[name] = offset;
+        offset += type.size;
+    }
+    const size = _align(offset, align);
+    const f = ((buf = new ArrayBuffer(size), offset = 0) => {
+        const res = {};
+        for (const [name, type] of Object.entries(fields)) {
+            Object.defineProperty(res, name, property(type(buf, offset + offsets[name])));
+        }
+        return res;
+    });
+    f.size = size;
+    f.align = align;
+    return f;
+};

package/tree.d.ts

@@ -0,0 +1,20 @@
+import type { Fn, FnV, TPred, PredV } from './types.js';
+export type Node<S, T = S> = T | Tree<S, T>;
+export type Tree<S, T = S> = [S, Node<S, T>[]];
+export declare const tree: <S, T = S>(value: S, children?: Node<S, T>[]) => Tree<S, T>;
+export declare const isTree: <S, T = S>(x: Node<S, T>) => x is Tree<S, T>;
+export declare const children: <S, T = S>(p?: TPred<Tree<S, T>, Node<S, T>>) => (x: Node<S, T>) => Node<S, T>[];
+export declare const value: <S, T = S>(p?: TPred<Tree<S, T>, Node<S, T>>) => (x: Node<S, T>) => S | T;
+export declare const transform: <S, T = S, A = Tree<S, T>, B = Node<S, T>, C = void>(node: FnV<[Tree<S, T>, Fn<C, Fn<Node<S, T>>>, C], A>, leaf: FnV<[T, C], B>, p?: TPred<Tree<S, T>>) => Fn<C, Fn<Node<S, T>, A | B>>;
+export declare const map: <S, T = S, U = S, V = T, C = void>(parent: FnV<[S, C], U>, child: FnV<[T, C], V>, update?: FnV<[C, S], C>, p?: TPred<Tree<S, T>>) => Fn<C, Fn<Node<S, T>, Node<U, V>>>;
+export declare const filter: <S, T = S, C = void>(ps: PredV<[Node<S, T>, C]>, update?: FnV<[C, S], C>, p?: TPred<Tree<S, T>>) => Fn<C, Fn<Node<S, T>, T | Tree<S, T>>>;
+export declare const toggleChildren: <S, T = S, C = void>(g: FnV<[Tree<S, T>, C], boolean>, update?: FnV<[C, S], C>, p?: TPred<Tree<S, T>>) => Fn<C, Fn<Node<S, T>, Node<S, T>>>;
+type TreeObject<T extends Node<string>[]> = {
+    [K in T[number] as K extends string ? K : K[0]]: K extends Tree<string> ? {
+        value: string;
+        children: TreeObject<K[1]>;
+    } : string;
+};
+export declare const asObject: <T extends Node<string>[]>(items: T, f?: FnV<[string, string], string>, update?: FnV<[string, string], string>, context?: string) => TreeObject<T>;
+export declare const zip: <S, T, U, V>(na: Node<S, T>[], nb: Node<U, V>[]) => Node<[S, U], [T, V]>[];
+export {};