@cgtk/std 0.0.192 → 0.0.194

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

package/src/treemap.js

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

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

package/src/typedarray.js

@@ -0,0 +1,39 @@
+import { bind } from "./fn.js";
+import { zmap, map as mapI, reduce } from "./iterable.js";
+import { push } from "./array.js";
+export const view = (type, length) => (buf = new ArrayBuffer(type.BYTES_PER_ELEMENT * length), offset = 0) => new type(buf, offset, length);
+export const u8 = bind((view), Uint8Array);
+export const u16 = bind((view), Uint16Array);
+export const u32 = bind((view), Uint32Array);
+export const u64 = bind((view), BigUint64Array);
+export const i8 = bind((view), Int8Array);
+export const i16 = bind((view), Int16Array);
+export const i32 = bind((view), Int32Array);
+export const i64 = bind((view), BigInt64Array);
+export const f16 = bind((view), Float16Array);
+export const f32 = bind((view), Float32Array);
+export const f64 = bind((view), Float64Array);
+export const UintArray = (n) => n < 256 ? Uint8Array : n < 65536 ? Uint16Array : Uint32Array;
+export const ctor = (x) => x.constructor;
+export const emptyLike = (x) => new (ctor(x))(x.length);
+export const set = (xs, x, i) => (xs.set(x, i), xs);
+export const concat = (chunks) => {
+    const out = new (ctor(chunks[0]))(chunks.reduce((a, x) => a + x.length, 0));
+    chunks.reduce((offset, chunk) => (out.set(chunk, offset), offset + chunk.length), 0);
+    return out;
+};
+export const iter = (size, stride = size) => function* (data) {
+    const C = ctor(data);
+    for (let i = 0, n = data.length; i < n - size + 1; i += stride) {
+        const offset = data.byteOffset + i * C.BYTES_PER_ELEMENT;
+        yield new C(data.buffer, offset, size);
+    }
+};
+export const tile = (n) => (out, x) => {
+    for (let i = 0; i < n; i++)
+        set(out, x, i * x.length);
+    return out;
+};
+export const tileEvery = (m, n) => (xs, out = new (ctor(xs))(xs.length * n)) => (zmap(tile(n))(iter(m * n)(out), iter(m)(xs)), out);
+export const strided = (data, size, stride = size, out = new (ctor(data))(data.length / size * stride)) => (iter(size)(data).forEach((p, i) => set(out, p, i * stride)), out);
+export const toFixed = (n, sep = ',') => (xs) => reduce((push), [])(mapI(x => x.toFixed(n))(Iterator.from(xs))).join(sep);

package/src/types.d.ts

@@ -0,0 +1,63 @@
+export interface RecordOf<T> {
+    [id: PropertyKey]: T;
+}
+export type ValueOf<T> = T[keyof T];
+export type Structure<T> = T | readonly Structure<T>[] | RecordOf<Structure<T>>;
+export type Optional<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>> & Partial<Pick<T, K>>;
+export type Tuple<T, N extends number, R extends T[] = []> = R['length'] extends N ? R : Tuple<T, N, [T, ...R]>;
+export type Elements<A extends readonly unknown[]> = A extends readonly (infer T)[] ? T : never;
+export type MaybeFirst<T extends unknown[], S = void> = T extends {
+    length: 0;
+} ? S : T[0];
+export type FnV<T extends any[] = any[], R = any> = (...x: T) => R;
+export type Fn<T = any, R = any> = FnV<[T], R>;
+export type FnP<T = any, R = any> = (x: T) => Promise<R>;
+export type Fns<T> = {
+    [k in keyof T]: Fn<T[k]>;
+};
+export type FnF = <F extends FnV>(f: F) => (...xs: Parameters<F>) => ReturnType<F>;
+export type Dispose = Fn<void>;
+export type Reactive<T = unknown, R = any> = Fn<Fn<T, R>, Dispose>;
+export type Constantly<T> = () => T;
+export type FirstParam<F extends FnV> = MaybeFirst<Parameters<F>>;
+export type MaybePromise<T = unknown> = T | PromiseLike<T>;
+export type Last<T extends any[]> = T extends [...any, infer Rest] ? Rest : never;
+export type Tail<T extends any[]> = T extends [any, ...(infer Rest)] ? Rest : never;
+export type Push<T extends any[], V> = [...T, V];
+export type Pop<T extends any[]> = T extends [...infer head, any] ? head : never;
+export type MinusOne<T extends number, A extends any[] = []> = A['length'] extends T ? Pop<A>['length'] : MinusOne<T, [...A, 0]>;
+export type Take<N extends number, T extends any[], R extends any[] = []> = R['length'] extends N ? R : Take<N, Tail<T>, [...R, T[0]]>;
+export type Skip<N extends number, T extends any[]> = N extends 0 ? T : Skip<MinusOne<N>, Tail<T>>;
+export type Range<N extends number, Acc extends number[] = []> = Acc['length'] extends N ? Acc[number] : Range<N, [...Acc, Acc['length']]>;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type LastOf<T> = UnionToIntersection<T extends any ? (x: T) => void : never> extends (x: infer L) => void ? L : never;
+export type UnionToTuple<T> = [T] extends [never] ? [] : Push<UnionToTuple<Exclude<T, LastOf<T>>>, LastOf<T>>;
+export type Entry<K extends PropertyKey, V> = [K, V];
+export type Entries<T> = {
+    [K in keyof T]: Entry<K, T[K]>;
+}[keyof T];
+export type EntriesTuple<T, K extends UnionToTuple<keyof T> = UnionToTuple<keyof T>> = {
+    [I in keyof K]: K[I] extends keyof T ? [K[I], T[K[I]]] : never;
+};
+export type UintArray<T extends ArrayBufferLike = ArrayBufferLike> = Uint8Array<T> | Uint16Array<T> | Uint32Array<T>;
+export type IntArray<T extends ArrayBufferLike = ArrayBufferLike> = Int8Array<T> | Int16Array<T> | Int32Array<T>;
+export type FloatArray<T extends ArrayBufferLike = ArrayBufferLike> = Float16Array<T> | Float32Array<T> | Float64Array<T>;
+export type BigIntArray<T extends ArrayBufferLike = ArrayBufferLike> = BigUint64Array<T> | BigInt64Array<T>;
+export type NumberArray<T extends ArrayBufferLike = ArrayBufferLike> = UintArray<T> | IntArray<T> | FloatArray<T>;
+export type TypedArray<T extends ArrayBufferLike = ArrayBufferLike> = NumberArray | BigIntArray<T>;
+export type Number<T extends TypedArray> = T extends NumberArray ? number : bigint;
+export type BufferType<T extends TypedArray> = T extends TypedArray<infer S> ? S : never;
+export type Eq<A, B = A> = FnV<[A, B], boolean>;
+export type Pred<T> = Fn<T, boolean>;
+export type PredV<T extends any[]> = FnV<T, boolean>;
+export type TPred<T extends S, S = any> = (x: S) => x is T;
+export type Maybe<T> = T | undefined;
+export type Indexed<T> = [number, T];
+export type Required<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export type Partials<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type KeyMap<T extends string> = {
+    [K in T]: Extract<K, T>;
+};
+export {};

package/src/types.js

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

package/src/utils.d.ts

@@ -0,0 +1,4 @@
+import type { Tuple } from "./types.js";
+export declare function toposort(nodes: number[]): Generator<number | undefined, void, unknown>;
+export declare const hex2rgb: (hex: string) => number[];
+export declare const rgb2hex: (rgb: Tuple<number, 3>) => string;

package/src/utils.js

@@ -0,0 +1,30 @@
+import { assert } from "./checks.js";
+export function* toposort(nodes) {
+    const n = nodes.length;
+    const queue = [], children = new Map();
+    nodes.forEach((p, i) => {
+        if (p < 0)
+            queue.push(i);
+        else {
+            assert(p < n, `[toposort] Invalid parent: ${p}`);
+            if (!children.has(p))
+                children.set(p, []);
+            children.get(p).push(i);
+        }
+    });
+    while (queue.length > 0) {
+        const p = queue.shift();
+        yield p;
+        if (children.has(p)) {
+            queue.push(...children.get(p));
+            children.delete(p);
+        }
+    }
+}
+export const hex2rgb = (hex) => {
+    const r = parseInt(hex.slice(1, 3), 16);
+    const g = parseInt(hex.slice(3, 5), 16);
+    const b = parseInt(hex.slice(5, 7), 16);
+    return [r, g, b];
+};
+export const rgb2hex = (rgb) => "#" + rgb.map(x => Math.round(x).toString(16).padStart(2, '0')).join("");

package/src/weak.d.ts

@@ -0,0 +1,2 @@
+import type { Fn, Maybe } from "./types.js";
+export declare const deref: <T extends WeakKey, F extends Fn<T>>(r: WeakRef<T>, f: F) => Maybe<ReturnType<F>>;

package/src/weak.js

@@ -0,0 +1,5 @@
+import { isDefined } from "./checks.js";
+export const deref = (r, f) => {
+    const x = r.deref();
+    return isDefined(x) ? f(x) : undefined;
+};

package/stream.d.ts

@@ -1,4 +1,4 @@
-import type { Fn } from "./types";
+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>;

package/stream.js

@@ -1,5 +1,5 @@
-import { push } from "./array";
-import { reduceA } from "./iterable";
+import { push } from "./array.js";
+import { reduceA } from "./iterable.js";
 export const readable = (x) => new ReadableStream({
     start: c => (c.enqueue(x), c.close())
 });

package/string.d.ts

@@ -1,7 +1,8 @@
-import type { Tuple } from "./types";
+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;