@cgtk/std 0.0.194 → 0.0.196

package/src/port.js

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

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

package/src/progress.js

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

package/src/rect.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/src/treemap.js

@@ -1,71 +0,0 @@
-import { before } from "./fn.js";
-import { isDefined } from "./checks.js";
-import { EMPTY } from "./constants.js";
-export const treemap = () => {
-    const nodes = new Set();
-    const parents = new Map();
-    const children = new Map();
-    let changed = false;
-    const update = () => {
-        const hasChanged = changed;
-        if (hasChanged) {
-            children.clear();
-            for (const k of nodes) {
-                const p = parents.get(k);
-                if (isDefined(p)) {
-                    if (!children.has(p))
-                        children.set(p, []);
-                    children.get(p).push(k);
-                }
-            }
-            changed = false;
-        }
-        return hasChanged;
-    };
-    const updated = before(update);
-    const getChildren = updated((key) => children.get(key) ?? EMPTY.LIST);
-    const parent = updated((key) => parents.get(key));
-    const roots = () => nodes.values().filter(k => !parents.has(k));
-    return {
-        set(node, parent) {
-            nodes.add(node);
-            if (isDefined(parent)) {
-                nodes.add(parent);
-                parents.set(node, parent);
-            }
-            changed = true;
-            return this;
-        },
-        delete(key) {
-            nodes.delete(key);
-            parents.delete(key);
-            changed = true;
-        },
-        get size() {
-            update();
-            return nodes.size;
-        },
-        parent,
-        children: getChildren,
-        roots,
-        ancestors: updated(function* (node) {
-            for (let cur = node; isDefined(cur); cur = parent(cur))
-                yield cur;
-        }),
-        dfs: updated(function* (root) {
-            const stack = [root];
-            for (let node; stack.length > 0;) {
-                yield node = stack.pop();
-                const items = getChildren(node);
-                for (let i = items.length - 1; i >= 0; i--)
-                    stack.push(items[i]);
-            }
-        }),
-        bfs: updated(function* (queue = [...roots()]) {
-            for (let node; queue.length > 0;) {
-                yield node = queue.shift();
-                queue.push(...getChildren(node));
-            }
-        })
-    };
-};

package/src/typedarray.d.ts

@@ -1,31 +0,0 @@
-import type { FnV, TypedArray, NumberArray, BufferType, Number } from "./types.js";
-export interface Constructor<T extends TypedArray> {
-    new (length: number): T;
-    new (buffer: BufferType<T> | ArrayBufferLike, byteOffset?: number, length?: number): T;
-    readonly BYTES_PER_ELEMENT: number;
-    of(...items: Number<T>[]): T;
-    from(arrayLike: ArrayLike<Number<T>>): T;
-}
-export type View<T extends TypedArray> = FnV<[BufferType<T>?, number?], T>;
-export declare const view: <T extends TypedArray>(type: Constructor<T>, length: number) => View<T>;
-export declare const u8: (length: number) => View<Uint8Array<ArrayBufferLike>>;
-export declare const u16: (length: number) => View<Uint16Array<ArrayBufferLike>>;
-export declare const u32: (length: number) => View<Uint32Array<ArrayBufferLike>>;
-export declare const u64: (length: number) => View<BigUint64Array<ArrayBufferLike>>;
-export declare const i8: (length: number) => View<Int8Array<ArrayBufferLike>>;
-export declare const i16: (length: number) => View<Int16Array<ArrayBufferLike>>;
-export declare const i32: (length: number) => View<Int32Array<ArrayBufferLike>>;
-export declare const i64: (length: number) => View<BigInt64Array<ArrayBufferLike>>;
-export declare const f16: (length: number) => View<Float16Array<ArrayBufferLike>>;
-export declare const f32: (length: number) => View<Float32Array<ArrayBufferLike>>;
-export declare const f64: (length: number) => View<Float64Array<ArrayBufferLike>>;
-export declare const UintArray: (n: number) => Uint8ArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor;
-export declare const ctor: <T extends TypedArray>(x: T) => Constructor<T>;
-export declare const emptyLike: <T extends TypedArray>(x: T) => T;
-export declare const set: <T extends TypedArray>(xs: T, x: ArrayLike<Number<T>> | T, i: number) => T;
-export declare const concat: <T extends TypedArray>(chunks: T[]) => T;
-export declare const iter: (size: number, stride?: number) => <T extends TypedArray>(data: T) => Generator<T>;
-export declare const tile: (n: number) => (out: TypedArray, x: TypedArray) => TypedArray;
-export declare const tileEvery: (m: number, n: number) => <T extends TypedArray>(xs: T, out?: T) => T;
-export declare const strided: <T extends TypedArray>(data: T, size: number, stride?: number, out?: T) => T;
-export declare const toFixed: (n: number, sep?: string) => (xs: NumberArray) => string;