@cgtk/std 0.0.193 → 0.0.194

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;

package/src/set.js

@@ -0,0 +1,2 @@
+export const add = (xs, x) => (xs.add(x), () => xs.delete(x));
+export const isEqual = (a, b) => a.size == b.size && a.isSubsetOf(b) && b.isSubsetOf(a);

package/src/signal.d.ts

@@ -0,0 +1,37 @@
+import type { Fn, FnV, Fns, Pred, Reactive, RecordOf, Structure } from "./types.js";
+export type Signal<T> = Fn<T> & {
+    on: Reactive<T>;
+};
+export declare const create: <T>(f: Fn<T>, on: Reactive<T>) => Signal<T>;
+export declare const signal: <T>(fns?: Set<Fn<T>>) => Signal<T>;
+export declare const map: <T, S>(source: Reactive<T>, f: Fn<T, S>) => Reactive<S>;
+export declare const filter: <T>(source: Reactive<T>, p: Pred<T>) => Reactive<T>;
+export declare const cache: <T>(source: Reactive<T>) => Reactive<T>;
+export interface ValueLike<T> {
+    value: T;
+    on: Reactive<T>;
+}
+export interface Box<T, F extends RecordOf<FnV>> extends ValueLike<T> {
+    ops: F;
+}
+export interface Value<T> extends ValueLike<T> {
+    op: <F extends FnV>(f: Fn<T, F>) => F;
+    ops: <F extends RecordOf<FnV>>(f: Fn<T, F>) => F;
+    set: Fn<T>;
+    update(): void;
+    map<S>(f: Fn<T, S>): Reactive<S>;
+    box: <F extends RecordOf<FnV>>(f: Fn<T, F>) => Box<T, F>;
+}
+export declare const value: <T>(x: T, fs?: Set<Fn<T>>) => Value<T>;
+export type Values<T extends RecordOf<any>> = {
+    [k in keyof T]: Value<T[k]>;
+};
+export declare const values: <T extends RecordOf<any>>(vals: T) => Values<T>;
+type Unwrapped<T> = T extends ValueLike<infer U> ? U : {
+    [K in keyof T]: Unwrapped<T[K]>;
+};
+export declare const compose: <T extends Structure<ValueLike<any>>, S = Unwrapped<T>>(xs: T, transform?: Fn<Unwrapped<T>, S>) => Reactive<S>;
+export declare const mux: <I extends RecordOf<any>, O extends RecordOf<any>>(init: Fn<Fns<O>, Fns<I>>) => Fns<I> & {
+    on: { [k in keyof O]: Reactive<O[k]>; };
+};
+export {};

package/src/signal.js

@@ -0,0 +1,89 @@
+import { after, constantly, noop, bind, comp, forEach, filter as filter_, identity } from "./fn.js";
+import { mapValues } from "./object.js";
+import { isDefined, isFunction } from "./checks.js";
+import { add } from "./set.js";
+export const create = (f, on) => {
+    const g = f;
+    g.on = on;
+    return g;
+};
+export const signal = (fns = new Set()) => create((x) => fns.forEach(f => f(x)), bind(add, fns));
+export const map = (source, f) => g => source(comp(f, g));
+export const filter = (source, p) => f => source(filter_(p, f));
+export const cache = (source) => {
+    let x;
+    source(y => x = y);
+    return f => {
+        if (isDefined(x))
+            f(x);
+        return source(f);
+    };
+};
+;
+;
+const isValueLike = (v) => Object.hasOwn(v, "value") && Object.hasOwn(v, "on") && isFunction(v.on);
+export const value = (x, fs = new Set()) => {
+    const sig = signal(fs);
+    const notify = after(() => sig(x));
+    const op = (f) => notify(f(x));
+    const on = (f) => (f(x), sig.on(f));
+    const ops = (f) => mapValues(f(x), notify);
+    return {
+        get value() { return x; },
+        set value(y) { sig(x = y); },
+        op, on, ops,
+        set: op(constantly((y) => x = y)),
+        update: op(constantly(noop)),
+        map: bind(map, on),
+        box: (f) => ({
+            on,
+            get value() { return x; },
+            ops: ops(f),
+        })
+    };
+};
+export const values = (vals) => mapValues(vals, v => value(v));
+export const compose = (xs, transform = identity) => f => {
+    const collect = (vs) => {
+        if (isValueLike(vs)) {
+            return vs.value;
+        }
+        else if (Array.isArray(vs)) {
+            return vs.map(collect);
+        }
+        return Object.fromEntries(Object.entries(vs).map(([k, v]) => [k, collect(v)]));
+    };
+    const notify = () => f(transform(collect(xs)));
+    let ready = false;
+    const sub = (vs) => {
+        if (isValueLike(vs)) {
+            return vs.on(() => { if (ready)
+                notify(); });
+        }
+        else if (Array.isArray(vs)) {
+            return forEach(...vs.map(sub));
+        }
+        return forEach(...Object.values(vs).map(sub));
+    };
+    const off = sub(xs);
+    ready = true;
+    notify();
+    return off;
+};
+export const mux = (init) => {
+    const sigs = {};
+    const ins = init(new Proxy({}, {
+        get: (_, k) => (x) => {
+            const f = sigs[k];
+            if (isDefined(f))
+                f(x);
+        }
+    }));
+    ins.on = new Proxy({}, {
+        get: (_, k) => f => {
+            const sig = sigs[k] ??= signal();
+            return sig.on(f);
+        }
+    });
+    return ins;
+};

package/src/stream.d.ts

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

@@ -0,0 +1,26 @@
+import { push } from "./array.js";
+import { reduceA } from "./iterable.js";
+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/src/string.d.ts

@@ -0,0 +1,8 @@
+import type { Tuple } from "./types.js";
+export declare const basename: (path: string) => string;
+export declare const dirname: (path: string) => string;
+export declare const splitext: (path: string) => Tuple<string, 2>;
+export declare const objectURL: (data: Uint8Array<ArrayBuffer>, 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;
+export declare const DATA_URL: RegExp;

package/src/string.js

@@ -0,0 +1,29 @@
+import { EMPTY } from "./constants.js";
+import { seek } from "./array.js";
+export const basename = (path) => path.split("/").at(-1) ?? "";
+export const dirname = (path) => {
+    const parts = path.split("/");
+    parts.pop();
+    return parts.join("/");
+};
+export const splitext = (path) => {
+    const idx = path.lastIndexOf(".");
+    if (idx == -1)
+        return [path, ""];
+    return [path.slice(0, idx), path.slice(idx + 1)];
+};
+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;
+    };
+};
+export const DATA_URL = /^data:(?<mime>[\w/\-\+]+)?(;(?<params>[\w\-]+\=[^;,\s]+)*)?(;(?<encoding>base64))?,(?<data>.*)$/;

package/src/struct.d.ts

@@ -0,0 +1,42 @@
+import type { TypedArray, Fn, NumberArray } from "./types.js";
+import type { Constructor } from "./typedarray.js";
+export interface Type {
+    size: number;
+    align: number;
+}
+export type Vec<T extends TypedArray, N extends number> = Type & {
+    length: N;
+    type: Constructor<T>;
+};
+export declare const u8: <N extends number = 1>(length?: N, align?: number) => Vec<Uint8Array<ArrayBufferLike>, N>;
+export declare const u16: <N extends number = 1>(length?: N, align?: number) => Vec<Uint16Array<ArrayBufferLike>, N>;
+export declare const u32: <N extends number = 1>(length?: N, align?: number) => Vec<Uint32Array<ArrayBufferLike>, N>;
+export declare const u64: <N extends number = 1>(length?: N, align?: number) => Vec<BigUint64Array<ArrayBufferLike>, N>;
+export declare const i8: <N extends number = 1>(length?: N, align?: number) => Vec<Int8Array<ArrayBufferLike>, N>;
+export declare const i16: <N extends number = 1>(length?: N, align?: number) => Vec<Int16Array<ArrayBufferLike>, N>;
+export declare const i32: <N extends number = 1>(length?: N, align?: number) => Vec<Int32Array<ArrayBufferLike>, N>;
+export declare const i64: <N extends number = 1>(length?: N, align?: number) => Vec<BigInt64Array<ArrayBufferLike>, N>;
+export declare const f16: <N extends number = 1>(length?: N, align?: number) => Vec<Float16Array<ArrayBufferLike>, N>;
+export declare const f32: <N extends number = 1>(length?: N, align?: number) => Vec<Float32Array<ArrayBufferLike>, N>;
+export declare const f64: <N extends number = 1>(length?: N, align?: number) => Vec<Float64Array<ArrayBufferLike>, N>;
+export type Array<T extends Type> = Type & {
+    type: T;
+    length: number;
+    offset: Fn<number, number>;
+};
+export declare const isArray: (t: any) => t is Array<any>;
+export declare const array: <T extends Type>(type: T, length: number, align?: number) => Array<T>;
+type Field<T extends Type> = readonly [name: string, type: T, align?: number];
+export type Struct<T extends ReadonlyArray<Field<any>>> = Type & {
+    fields: {
+        [K in T[number] as K[0]]: K[1];
+    };
+    offset(key: T[number][0]): number;
+};
+export declare const isStruct: (t: any) => t is Struct<any>;
+export declare const struct: <T extends ReadonlyArray<Field<any>>>(fs: T, align?: number, offset?: number) => Struct<T>;
+export type View<T extends Type> = T extends Vec<infer C, any> ? C : T extends Array<infer S> ? View<S>[] : T extends Struct<infer F> ? {
+    [K in F[number] as K[0]]: K[1] extends Vec<infer C, infer N> ? (N extends 1 ? (C extends NumberArray ? number : bigint) : C) : View<K[1]>;
+} : never;
+export declare const view: <T extends Vec<any, any> | Array<any> | Struct<any>>(t: T, buf?: ArrayBufferLike, offset?: number) => View<T>;
+export {};

package/src/struct.js

@@ -0,0 +1,58 @@
+import { align as _align } from "./math.js";
+import { isBigIntArray, isNumberArray } from "./checks.js";
+const vec = (type) => (length = 1, align = type.BYTES_PER_ELEMENT) => ({
+    type, align, length, size: type.BYTES_PER_ELEMENT * length,
+});
+export const u8 = vec(Uint8Array);
+export const u16 = vec(Uint16Array);
+export const u32 = vec(Uint32Array);
+export const u64 = vec(BigUint64Array);
+export const i8 = vec(Int8Array);
+export const i16 = vec(Int16Array);
+export const i32 = vec(Int32Array);
+export const i64 = vec(BigInt64Array);
+export const f16 = vec(Float16Array);
+export const f32 = vec(Float32Array);
+export const f64 = vec(Float64Array);
+export const isArray = (t) => Object.hasOwn(t, "length") && Object.hasOwn(t, "offset");
+export const array = (type, length, align = type.align) => {
+    const step = _align(type.size, align);
+    return ({
+        type, align, length,
+        size: step * length,
+        offset: i => i * step
+    });
+};
+export const isStruct = (t) => Object.hasOwn(t, "offset") && Object.hasOwn(t, "fields");
+export const struct = (fs, align = 0, offset = 0) => {
+    const fields = {}, offsets = {};
+    for (const [name, type, align_ = type.align] of fs) {
+        align = Math.max(align, align_);
+        offset = _align(offset, align_);
+        fields[name] = type;
+        offsets[name] = offset;
+        offset += type.size;
+    }
+    return {
+        size: _align(offset, align),
+        align,
+        fields: fields,
+        offset: k => offsets[k]
+    };
+};
+const property = (value) => ({
+    enumerable: true,
+    ...((isNumberArray(value) || isBigIntArray(value)) && value.length == 1 ? {
+        get: () => value[0],
+        set: (x) => value[0] = x,
+    } : { value })
+});
+export const view = (t, buf = new ArrayBuffer(t.size), offset = 0) => {
+    if (isArray(t)) {
+        return Array.from({ length: t.length }, (_, i) => view(t.type, buf, offset + t.offset(i)));
+    }
+    else if (isStruct(t)) {
+        return Object.entries(t.fields).reduce((o, [name, type]) => Object.defineProperty(o, name, property(view(type, buf, offset + t.offset(name)))), {});
+    }
+    return new t.type(buf, offset, t.length);
+};

package/src/tree.d.ts

@@ -0,0 +1,11 @@
+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>(x: Node<S, T>, p?: TPred<Tree<S, T>, Node<S, T>>) => Node<S, T>[];
+export declare const value: <S, T = S>(x: Node<S, T>, p?: TPred<Tree<S, T>, 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 zip: <S, T, U, V>(na: Node<S, T>[], nb: Node<U, V>[]) => Node<[S, U], [T, V]>[];

package/src/tree.js

@@ -0,0 +1,25 @@
+import { identity } from './fn.js';
+import { EMPTY } from './constants.js';
+import { zip as zipI } from './iterable.js';
+export const tree = (value, children = []) => [value, children];
+export const isTree = (x) => Array.isArray(x) && x.length == 2 && Array.isArray(x[1]);
+export const children = (x, p = isTree) => p(x) ? x[1] : EMPTY.LIST;
+export const value = (x, p = isTree) => p(x) ? x[0] : x;
+export const transform = (node, leaf, p = isTree) => {
+    const f = (c) => (x) => p(x) ? node(x, f, c) : leaf(x, c);
+    return f;
+};
+export const map = (parent, child, update = identity, p = isTree) => transform((x, f, c) => tree(parent(x[0], c), x[1].map(f(update(c, x[0])))), child, p);
+export const filter = (ps, update = identity, p = isTree) => transform((x, f, c) => tree(x[0], x[1].filter(x => ps(x, c)).map(f(update(c, x[0])))), identity, p);
+export const zip = (na, nb) => {
+    const res = [];
+    for (const [a, b] of zipI(Iterator.from(na), Iterator.from(nb))) {
+        if (!isTree(a) && !isTree(a))
+            res.push([value(a), value(b)]);
+        else if ((isTree(a) && isTree(a)))
+            res.push([[value(a), value(b)], zip(children(a), children(b))]);
+        else
+            throw new Error("[tree] a and b should be both tree or node");
+    }
+    return res;
+};

package/src/treemap.d.ts

@@ -0,0 +1,13 @@
+import type { Maybe } from "./types.js";
+export interface Treemap<T = number> {
+    set(node: T, parent?: T): Treemap<T>;
+    delete(key: T): void;
+    parent(key: T): Maybe<T>;
+    size: number;
+    children(key: T): T[];
+    roots(): IteratorObject<T>;
+    ancestors(node: T): IteratorObject<T>;
+    dfs(root: T): IteratorObject<T>;
+    bfs(): IteratorObject<T>;
+}
+export declare const treemap: <T = number>() => Treemap<T>;