@cgtk/std 0.0.185 → 0.0.187

package/port.js

@@ -0,0 +1,53 @@
+import { forEach, noop } from "./fn";
+import { isDefined } from "./checks";
+import { on } from "./dom";
+import { promise } from "./async";
+;
+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 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/progress.d.ts

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

package/rect.d.ts

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

@@ -0,0 +1,16 @@
+import { add } from "./number";
+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/resource.d.ts

@@ -0,0 +1,9 @@
+import type { Fn, Dispose, Resource, RecordOf } from "./types";
+export declare const resource: <T>(x: T, d?: Dispose) => Resource<T>;
+export declare const map: <T, S>(r: Resource<T>, g: Fn<T, S>) => Resource<S>;
+type Structure<T> = T | Structure<T>[] | RecordOf<Structure<T>>;
+type Resolved<T extends Structure<Resource<any>>> = {
+    [K in keyof T]: T[K] extends Resource<infer R> ? R : T[K] extends Structure<Resource<any>> ? Resolved<T[K]> : never;
+};
+export declare const combine: <R extends Structure<Resource<any>>>(rs: R) => Resource<Resolved<R>>;
+export {};

package/resource.js

@@ -0,0 +1,20 @@
+import { forEach, noop, comp } from "./fn";
+import { push, empty } from "./array";
+import { assoc } from "./object";
+import { reduceRec } from './iterable';
+import { isFunction } from "./checks";
+export const resource = (x, d = noop) => (f) => forEach(f(x) ?? noop, d);
+export const map = (r, g) => f => r(comp(g, f));
+const isResource = (r) => isFunction(r);
+export const combine = (rs) => f => {
+    const rec = (rs, f) => {
+        if (isResource(rs)) {
+            return rs(x => f(x) ?? noop);
+        }
+        else if (Array.isArray(rs)) {
+            return reduceRec(Iterator.from(rs), (o, r, next) => rec(r, (x) => next(push(o, x))), empty(), o => f(o) ?? noop);
+        }
+        return reduceRec(Iterator.from(Object.entries(rs)), (o, [k, r], next) => rec(r, (x) => next(assoc(o, [k, x]))), {}, r => f(r) ?? noop);
+    };
+    return rec(rs, f);
+};

package/schedule.d.ts

@@ -1,8 +1,10 @@
-import type { Fn, FnV, Reactive } from './types';
+import type { Dispose, 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 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: (sched?: Reactive<any>) => (f: Fn<void>) => () => any;
-export declare const toggler: (f: Fn<void, Fn<void>>) => (x: boolean) => Fn<void>;
+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/schedule.js

@@ -1,17 +1,9 @@
-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));
-};
+import { isUndefined, isDefined, counted } from './checks';
+import { comp, lazy, bind, apply, call, where, disposing, noop } from './fn';
+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))
@@ -23,22 +15,19 @@ export const debounce = (sched = raf) => {
     };
 };
 export const reset = (sched = raf) => {
-    let cancel;
-    const stop = () => { if (isDefined(cancel))
-        cancel(), cancel = undefined; };
+    let cancel = noop;
+    const stop = () => (cancel(), cancel = noop);
     return (f) => {
         stop();
         cancel = sched(f);
         return stop;
     };
 };
-export const repeatedly = (sched = raf) => (f) => {
+export const repeatedly = (f, sched = raf) => {
     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));
-};
+export const delayAfter = (delta, n, f) => where(counted(n), f, schedule(reset(timeout(delta)))(f));
+export const micro = (f) => (...xs) => queueMicrotask(() => f(...xs));

package/set.d.ts

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

package/set.js

@@ -0,0 +1 @@
+export const add = (xs, x) => (xs.add(x), () => xs.delete(x));

package/signal.d.ts

@@ -1,8 +1,8 @@
-import type { Fn, FnV, Reactive, RecordOf } from "./types";
+import type { Fn, FnV, Fns, 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 create: <T>(f: Fn<T>, on: Reactive<T>) => Signal<T>;
 export declare const signal: <T>(fns?: Set<Fn<T>>) => Signal<T>;
 export interface Value<T> {
     value: T;
@@ -10,10 +10,15 @@ export interface Value<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;
+    update(): void;
 }
 export declare const value: <T>(x: T) => Value<T>;
 export type Values<T extends RecordOf<any>> = {
-    [key in keyof T]: Value<T[key]>;
+    [k in keyof T]: Value<T[k]>;
 };
 export declare const values: <T extends RecordOf<any>>(vals: T) => Values<T>;
+export declare const map: <T, S>(source: Reactive<T>, f: Fn<T, S>) => Reactive<S>;
+export declare const merge: <T extends RecordOf<any>>(vals: Values<T>) => Reactive<T>;
+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]>; };
+};

package/signal.js

@@ -1,25 +1,48 @@
-import { after, constantly, noop } from "./fn";
+import { after, constantly, noop, bind, comp, forEach } from "./fn";
 import { mapValues } from "./object";
+import { isDefined } from "./checks";
+import { add } from "./set";
 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 signal = (fns = new Set()) => create((x) => fns.forEach(f => f(x)), bind(add, fns));
 ;
 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)),
+        ops: (f) => mapValues(f(x), notify),
         set: op(constantly((y) => x = y)),
         update: op(constantly(noop))
     };
 };
-export const values = (vals) => mapValues(value)(vals);
+export const values = (vals) => mapValues(vals, value);
+export const map = (source, f) => g => source(comp(f, g));
+export const merge = (vals) => f => {
+    const sub = () => f(mapValues(vals, (v) => v.value));
+    return forEach(...Object.values(vals).map((v) => v.on(sub)));
+};
+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/string.d.ts

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

package/string.js

@@ -6,6 +6,12 @@ export const dirname = (path) => {
     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

package/struct.d.ts

@@ -1,26 +1,40 @@
-import type { TypedArray } from "./types";
-export interface View<T> {
-    (buf?: ArrayBuffer, offset?: number, length?: number): T;
+import type { TypedArray, Fn } from "./types";
+import type { Constructor } from "./typedarray";
+export interface Type {
     size: number;
     align: number;
 }
-type Inner<T> = T extends View<infer U> ? U : never;
-type Num<T extends TypedArray> = View<T> & {
-    length: 1;
+export type Vec<T extends TypedArray, N extends number> = Type & {
+    length: N;
+    type: Constructor<T>;
 };
-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[]>;
-export type Fields = ReadonlyArray<readonly [string, View<unknown>]>;
-export type Struct<T extends Fields> = {
-    [K in T[number] as K[0]]: K[1] extends Num<any> ? number : Inner<K[1]>;
+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 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 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 struct: <T extends Fields>(fs: T) => View<Struct<T>>;
+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, aligb?: 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 ? number : 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/struct.js

@@ -1,6 +1,43 @@
 import { align as _align } from "./math";
 import { isTypedArray } from "./checks";
-import * as TA from "./typedarray";
+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 i8 = vec(Int8Array);
+export const i16 = vec(Int16Array);
+export const i32 = vec(Int32Array);
+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,
     ...(isTypedArray(value) && value.length == 1 ? {
@@ -8,50 +45,12 @@ const property = (value) => ({
         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;
+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)));
     }
-    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;
+    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/tree.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, FnV, TPred, PredV } from './types.js';
+import type { Fn, FnV, TPred, PredV } from './types';
 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>;
@@ -8,13 +8,4 @@ export declare const value: <S, T = S>(p?: TPred<Tree<S, T>, Node<S, T>>) => (x:
 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 {};

package/tree.js

@@ -1,7 +1,6 @@
-import { identity } from './fn.js';
-import { EMPTY } from './constants.js';
-import { isString } from './checks.js';
-import { zip as zipI } from './iterable.js';
+import { identity } from './fn';
+import { EMPTY } from './constants';
+import { zip as zipI } from './iterable';
 export const tree = (value, children = EMPTY.LIST) => [value, children];
 export const isTree = (x) => Array.isArray(x) && x.length == 2 && Array.isArray(x[1]);
 export const children = (p = isTree) => (x) => p(x) ? x[1] : EMPTY.LIST;
@@ -12,11 +11,6 @@ export const transform = (node, leaf, p = isTree) => {
 };
 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 toggleChildren = (g, update = identity, p = isTree) => transform((x, f, c) => tree(x[0], g(x, c) ? x[1].map(f(update(c, x[0]))) : EMPTY.LIST), identity, p);
-export const asObject = (items, f = identity, update = identity, context = "") => Object.fromEntries(items.map((x) => isString(x) ? [x, f(x, context)] : [x[0], {
-        value: f(x[0], context),
-        children: asObject(x[1], f, update, update(context, x[0]))
-    }]));
 export const zip = (na, nb) => {
     const res = [];
     const va = value(), vb = value();

package/treemap.js

@@ -1,4 +1,4 @@
-import { isUndefined } from "./checks.js";
+import { isUndefined } from "./checks";
 export class Treemap {
     static from(iter) {
         const tree = new Treemap();

package/typedarray.d.ts

@@ -1,6 +1,12 @@
-import type { Fn, FnV, TypedArray, Numbers } from "./types";
-export type Constructor<T extends TypedArray> = T extends Uint8Array ? Uint8ArrayConstructor : T extends Uint8ClampedArray ? Uint8ClampedArrayConstructor : T extends Uint16Array ? Uint16ArrayConstructor : T extends Uint32Array ? Uint32ArrayConstructor : T extends Int8Array ? Int8ArrayConstructor : T extends Int16Array ? Int16ArrayConstructor : T extends Int32Array ? Int32ArrayConstructor : T extends Float32Array ? Float32ArrayConstructor : T extends Float64Array ? Float64ArrayConstructor : never;
-export type View<T extends TypedArray> = FnV<[ArrayBuffer?, number?], T>;
+import type { Fn, FnV, TypedArray, BufferType, Numbers } from "./types";
+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;
+    from(arrayLike: ArrayLike<number>): 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>>;
@@ -8,6 +14,7 @@ export declare const u32: (length: number) => View<Uint32Array<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 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;
@@ -18,6 +25,7 @@ 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 map: <T extends TypedArray>(it: Fn<T, IteratorObject<T>>, f: FnV<[T, T]>) => (data: T, out?: T) => T;
-export declare const unweld: <T extends TypedArray>(data: T, indices: Numbers, size: number, out?: T) => T;
+export declare const unweld: <T extends TypedArray>(data: T, indices: Numbers, size: number, stride?: number, out?: T) => T;
 export declare const toFixed: (n: number, sep?: string) => (xs: TypedArray) => string;

package/typedarray.js

@@ -8,6 +8,7 @@ export const u32 = bind((view), Uint32Array);
 export const i8 = bind((view), Int8Array);
 export const i16 = bind((view), Int16Array);
 export const i32 = bind((view), Int32Array);
+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;
@@ -23,7 +24,6 @@ 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;
-        // https://github.com/microsoft/TypeScript/pull/59417
         yield new C(data.buffer, offset, size);
     }
 };
@@ -33,11 +33,12 @@ export const tile = (n) => (out, x) => {
     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) => out.set(p, i * stride)), out);
 export const map = (it, f) => (data, out = emptyLike(data)) => (zmap(f)(it(out), it(data)), out);
-export const unweld = (data, indices, size, out = new (ctor(data))(indices.length * size)) => {
+export const unweld = (data, indices, size, stride = size, out = new (ctor(data))(indices.length * stride)) => {
     indices.forEach((i, j) => {
         for (let k = 0; k < size; k++)
-            out[j * size + k] = data[i * size + k];
+            out[j * stride + k] = data[i * size + k];
     });
     return out;
 };