@cgtk/std 0.0.191 → 0.0.193

package/async.d.ts

@@ -1,7 +1,7 @@
-import type { Fn, Constantly, Optional, Dispose, MaybePromise } from "./types";
+import type { Fn, Constantly, Maybe, Dispose, MaybePromise } from "./types";
 export declare const timeout: (ms: number, signal?: AbortSignal) => Promise<unknown>;
-export declare const delay: (ms: number) => <T>(x: T) => Promise<T>;
-export declare const probing: <T>(p: Promise<T>) => Constantly<Optional<T>>;
+export declare const delay: (ms: number, signal?: AbortSignal) => <T>(x: T) => Promise<T>;
+export declare const probing: <T>(p: Promise<T>) => Constantly<Maybe<T>>;
 export declare const resolved: <T>(p: Promise<T>) => (f: Fn<T>) => () => void;
 export declare const promise: <T>(x: MaybePromise<T>) => Promise<any>;
 export declare const then: <T>(p: Promise<T>) => <R>(f: Fn<T, R>) => Promise<R>;

package/async.js

@@ -4,15 +4,16 @@ export const timeout = (ms, signal) => new Promise((resolve, reject) => {
     if (signal?.aborted)
         reject(signal.reason);
     else {
-        setTimeout(() => {
+        const t = setTimeout(() => {
             if (signal?.aborted)
                 reject(signal.reason);
             else
                 resolve(undefined);
         }, ms);
+        signal?.addEventListener("abort", () => (clearTimeout(t), reject(signal.reason)), { once: true });
     }
 });
-export const delay = (ms) => async (x) => (await timeout(ms), x);
+export const delay = (ms, signal) => async (x) => (await timeout(ms, signal), x);
 export const probing = (p) => {
     let value = undefined;
     p.then(x => value = x);

package/checks.d.ts

@@ -1,10 +1,10 @@
-import type { TypedArray, NumberArray, BigIntArray, Pred, TPred, Optional } from "./types";
+import type { TypedArray, NumberArray, BigIntArray, Pred, TPred, Maybe } from "./types";
 export declare const isTypedArray: (x: any) => x is TypedArray;
 export declare const isNumberArray: (x: any) => x is NumberArray;
 export declare const isBigIntArray: (x: any) => x is BigIntArray;
 export declare const isUndefined: (x: any) => x is undefined;
 export declare const isNull: (x: any) => x is null;
-export declare const isDefined: <T>(x: Optional<T>) => x is T;
+export declare const isDefined: <T>(x: Maybe<T>) => x is T;
 export declare function assert(condition: boolean, msg: string): asserts condition;
 export declare function assertType<T>(x: any, pred: TPred<T>, msg: string): asserts x is T;
 export declare const isObject: TPred<Object>;

package/dom.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, Dispose, RecordOf, Optional } from "./types";
+import type { Fn, Dispose, RecordOf, Maybe } from "./types";
 export declare const customEvent: <T>(type: string, detail: T, { composed, bubbles, cancelable }?: EventInit) => CustomEvent<T>;
 type ListenOpts = boolean | AddEventListenerOptions;
 export declare const on: {
@@ -46,5 +46,5 @@ export declare const onResize: (el: Element, f: Fn<ResizeObserverEntry[]>, optio
 export declare const preventDefault: <T extends Event>(e: T) => void;
 export declare const loadImage: (img: HTMLImageElement, src: string) => Promise<HTMLImageElement>;
 export declare const pushState: (path: string, query?: RecordOf<string>, data?: any) => void;
-export declare const qs: (search?: string) => Optional<RecordOf<string>>;
+export declare const qs: (search?: string) => Maybe<RecordOf<string>>;
 export {};

package/fn.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Constantly, Optional, Dispose, Reactive } from "./types";
+import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Constantly, Maybe, Dispose, Reactive } from "./types";
 export declare const tee: <T>(f: Fn<T, void>) => Fn<T, T>;
 export declare const comp: <Fs extends Fn[]>(...fs: Fs) => (x: FirstParam<Fs[0]>) => Last<Fs> extends Fn<any, infer R> ? R : never;
 export declare const pipe: <T, Fs extends [Fn<T>, ...Fn[]]>(x: T, ...fs: Fs) => Last<Fs> extends Fn<any, infer R> ? R : never;
@@ -23,9 +23,9 @@ export declare const filter: <T>(p: Pred<T>, f: Fn<T>) => (x: T) => void;
 export declare const filterT: <T>(p: TPred<T>, f: Fn<T>) => <S>(x: S) => void;
 export declare const scan: <T, S>(f: FnV<[S, T], S>, a: S) => Fn<T, S>;
 export declare const memoize: <T extends any[], K, V>(f: FnV<T, V>, key?: FnV<T, K>, cache?: Map<K, V>) => (...xs: T) => NonNullable<V>;
-export declare const abortable: <T = any>(f: Fn<AbortSignal>, reason?: T) => () => void;
+export declare const abortable: <T = any>(f: Fn<AbortSignal>) => (reason?: T) => void;
 export declare const disposable: (f: Fn<Fn<Dispose, Dispose>>, disposes?: Set<Dispose>) => Dispose;
-export declare const disposing: () => <F extends FnV<any[], Optional<Dispose>>>(f: F) => FnV<Parameters<F>, Dispose>;
+export declare const disposing: () => <F extends FnV<any[], Maybe<Dispose>>>(f: F) => FnV<Parameters<F>, Dispose>;
 export declare const disposeWith: <T>(f: Fn<T, Dispose>) => (g: Fn<Fn<T>>) => Dispose;
 export declare const idemp: <F extends FnV<any[], Dispose | void>>(d: Fn<Dispose, Dispose>, f: F) => FnV<Parameters<F>, Dispose>;
 export declare const toggler: (f: Fn<void, Dispose>) => (x: boolean) => Dispose;

package/fn.js

@@ -34,10 +34,10 @@ export const memoize = (f, key = (...xs) => xs[0], cache = new Map()) => (...xs)
         cache.set(k, f(...xs));
     return cache.get(k);
 };
-export const abortable = (f, reason) => {
+export const abortable = (f) => {
     const ctrl = new AbortController();
     f(ctrl.signal);
-    return () => ctrl.abort(reason);
+    return (reason) => ctrl.abort(reason);
 };
 export const disposable = (f, disposes = new Set()) => {
     f(bind(add, disposes));

package/http.d.ts

@@ -1,10 +1,9 @@
 export declare const assertStatus: (status: number) => (resp: Response) => void;
 export declare const contentLength: (response: Response) => number;
-export declare const toByteArray: (stream: ReadableStream<Uint8Array>) => Promise<Uint8Array<ArrayBufferLike>>;
-export declare const fetchBuffer: (url: string | URL | Request, init?: RequestInit) => Promise<Uint8Array<ArrayBufferLike>>;
-export declare const fetchText: (url: string, init?: RequestInit) => Promise<string>;
-export declare const fetchDOM: (url: string, init?: RequestInit) => Promise<HTMLElement>;
+export declare const fetchBuffer: (url: string | URL | Request, init?: RequestInit) => Promise<ArrayBuffer>;
+export declare const fetchText: (url: string | URL | Request, init?: RequestInit) => Promise<string>;
+export declare const fetchDOM: (url: string | URL | Request, init?: RequestInit) => Promise<HTMLElement>;
 export declare const fetchImage: (src: string) => Promise<HTMLImageElement>;
-export declare const fetchImageBitmap: (url: string, init?: RequestInit) => Promise<ImageBitmap>;
-export declare const fetchJSON: (url: string, init?: RequestInit) => Promise<any>;
-export declare const fetchDataUrl: (url: string) => Promise<string>;
+export declare const fetchImageBitmap: (url: string | URL | Request, init?: RequestInit) => Promise<ImageBitmap>;
+export declare const fetchJSON: (url: string | URL | Request, init?: RequestInit) => Promise<any>;
+export declare const fetchDataUrl: (url: string | URL | Request, init?: RequestInit) => Promise<string>;

package/http.js

@@ -1,18 +1,14 @@
 import { tee } from "./fn";
 import { assert } from "./checks";
-import { reduceArray } from './stream';
-import { concat } from "./typedarray";
-import { fromBytes } from "./json";
 export const assertStatus = (status) => (resp) => assert(resp.status == status, `Invalid HTTP Status ${resp.status}: ${resp.url}`);
 export const contentLength = (response) => {
     const cl = response.headers.get("content-length");
     return cl ? parseInt(cl) : -1;
 };
-export const toByteArray = async (stream) => concat(await reduceArray(stream));
 export const fetchBuffer = (url, init) => fetch(url, init)
     .then(tee(assertStatus(200)))
-    .then(resp => resp.body)
-    .then(toByteArray);
+    .then(resp => resp.blob())
+    .then(blob => blob.arrayBuffer());
 export const fetchText = (url, init) => fetchBuffer(url, init).then(buf => new TextDecoder("utf-8").decode(buf));
 export const fetchDOM = (url, init) => fetchText(url, init).then(txt => new DOMParser().parseFromString(txt, "image/svg+xml").documentElement);
 export const fetchImage = (src) => new Promise((resolve, reject) => {
@@ -22,13 +18,13 @@ export const fetchImage = (src) => new Promise((resolve, reject) => {
     image.onload = () => resolve(image);
     image.onerror = reject;
 });
-export const fetchImageBitmap = async (url, init) => {
-    const res = await fetch(url, init);
-    const blob = await res.blob();
-    return await createImageBitmap(blob, { colorSpaceConversion: "none" });
-};
-export const fetchJSON = (url, init) => fetchBuffer(url, init).then(fromBytes);
-export const fetchDataUrl = (url) => fetch(url)
+export const fetchImageBitmap = async (url, init) => fetch(url, init)
+    .then(tee(assertStatus(200)))
+    .then(resp => resp.blob())
+    .then(blob => createImageBitmap(blob, { colorSpaceConversion: "none" }));
+export const fetchJSON = (url, init) => fetchText(url, init).then(JSON.parse);
+export const fetchDataUrl = (url, init) => fetch(url, init)
+    .then(tee(assertStatus(200)))
     .then(resp => resp.blob())
     .then(blob => new Promise(resolve => {
     const f = new FileReader();

package/json.d.ts

@@ -1 +1 @@
-export declare const fromBytes: (data: Uint8Array) => any;
+export declare const fromBytes: (data: AllowSharedBufferSource, options?: TextDecodeOptions) => any;

package/json.js

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

package/map.d.ts

@@ -1,4 +1,4 @@
-import type { FnV, Optional } from "./types";
+import type { FnV, Maybe } from "./types";
 export declare const transform: <K, S, V>({ create, update, remove }: {
     create: FnV<[S, K, Map<K, V>], V>;
     update: FnV<[V, S, K, Map<K, V>], V>;
@@ -7,6 +7,6 @@ export declare const transform: <K, S, V>({ create, update, remove }: {
 export declare const set: <K, V>(m: Map<K, V>, [i, x]: [K, V]) => Map<K, V>;
 export declare const get: <K, V>(m: Map<K, V>, k: K, d: V) => V;
 export declare const update: <K, V>(m: Map<K, V>, k: K, f: FnV<[V | undefined, K, Map<K, V>], V>) => Map<K, V>;
-export declare const first: <K, V>(m: Map<K, V>) => Optional<V>;
-export declare const shift: <K, V>(m: Map<K, V>) => Optional<[K, V]>;
+export declare const first: <K, V>(m: Map<K, V>) => Maybe<V>;
+export declare const shift: <K, V>(m: Map<K, V>) => Maybe<[K, V]>;
 export declare const reduce: <K, V, T>(m: Map<K, V>, f: FnV<[T, V, K, Map<K, V>], T>, a: T) => T;

package/object.d.ts

@@ -1,4 +1,4 @@
-import type { RecordOf, Elements, Optional, FnV, ValueOf, EntriesTuple, UnionToTuple, Entry } from "./types.js";
+import type { RecordOf, Elements, Maybe, FnV, ValueOf, EntriesTuple, UnionToTuple, Entry } from "./types.js";
 export declare const entries: <T extends RecordOf<any>>(o: T) => EntriesTuple<T>;
 export declare const keys: <T extends RecordOf<any>>(o: T) => UnionToTuple<keyof T>;
 export declare const entry: <K extends PropertyKey, V>(k: K, v: V) => Entry<K, V>;
@@ -11,5 +11,5 @@ export declare const assoc: <T extends RecordOf<any>>(a: T, [k, v]: [keyof T, Va
 type Merge<T extends RecordOf<unknown>, S extends RecordOf<unknown>, V> = {
     [K in keyof (T & S)]: V;
 };
-export declare const merge: <T, S = T, V = T>(f: FnV<[Optional<T>, Optional<S>], V>) => <X extends RecordOf<T>, Y extends RecordOf<T>>(x: X, y: Y) => Merge<X, Y, V>;
+export declare const merge: <T, S = T, V = T>(f: FnV<[Maybe<T>, Maybe<S>], V>) => <X extends RecordOf<T>, Y extends RecordOf<T>>(x: X, y: Y) => Merge<X, Y, V>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cgtk/std",
-  "version": "0.0.191",
+  "version": "0.0.193",
   "type": "module",
   "main": "./index.js",
   "exports": {
@@ -41,7 +41,7 @@
     "./utils": "./utils.js"
   },
   "devDependencies": {
-    "typescript": "^5.9.2"
+    "typescript": "^5.9.3"
   },
   "publishConfig": {
     "access": "public"

package/port.d.ts

@@ -1,4 +1,4 @@
-import type { Dispose, Fn, Fns, FnV, RecordOf, MaybePromise } from "./types";
+import type { Dispose, Fn, Fns, FnV, RecordOf, MaybePromise, Reactive } from "./types";
 export interface Message<K, V> {
     type: K;
     payload: V;
@@ -8,6 +8,7 @@ export type Port = {
 };
 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;

package/port.js

@@ -1,10 +1,13 @@
-import { forEach, noop } from "./fn";
+import { forEach, noop, bind } 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 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)
 });

package/resource.d.ts

@@ -1,10 +1,12 @@
-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>;
-export declare const flatMap: <T, S>(r: Resource<T>, g: Fn<T, Resource<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;
+import type { Fn, Dispose, Structure, Reactive } from "./types";
+export type Resource<T> = Reactive<T, Dispose | void> & {
+    value: T;
+    dispose: Dispose;
+    map<S>(f: Fn<T, S>): Resource<S>;
 };
-export declare const combine: <R extends Structure<Resource<any>>>(rs: R) => Resource<Resolved<R>>;
+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/resource.js

@@ -1,21 +1,28 @@
-import { forEach, noop, comp } from "./fn";
-import { push, empty } from "./array";
-import { assoc } from "./object";
-import { reduceRec } from './iterable';
+import { forEach, noop } from "./fn";
 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));
-export const flatMap = (r, g) => f => r(x => g(x)(f));
-const isResource = (r) => isFunction(r);
-export const combine = (rs) => f => {
-    const rec = (rs, f) => {
+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)) {
-            return rs(x => f(x) ?? noop);
+            disposes.push(rs.dispose);
+            return rs.value;
         }
         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 rs.map(rec);
         }
-        return reduceRec(Iterator.from(Object.entries(rs)), (o, [k, r], next) => rec(r, (x) => next(assoc(o, [k, x]))), {}, r => f(r) ?? noop);
+        return Object.fromEntries(Object.entries(rs).map(([k, v]) => [k, rec(v)]));
     };
-    return rec(rs, f);
+    const value = rec(rs);
+    return resource(value, forEach(...disposes));
 };

package/set.d.ts

@@ -1 +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/set.js

@@ -1 +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/signal.d.ts

@@ -1,24 +1,37 @@
-import type { Fn, FnV, Fns, Reactive, RecordOf } from "./types";
+import type { Fn, FnV, Fns, Pred, Reactive, RecordOf, Structure } from "./types";
 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 interface Value<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) => Value<T>;
+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>;
-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>;
+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/signal.js

@@ -1,6 +1,6 @@
-import { after, constantly, noop, bind, comp, forEach } from "./fn";
+import { after, constantly, noop, bind, comp, forEach, filter as filter_, identity } from "./fn";
 import { mapValues } from "./object";
-import { isDefined } from "./checks";
+import { isDefined, isFunction } from "./checks";
 import { add } from "./set";
 export const create = (f, on) => {
     const g = f;
@@ -8,26 +8,67 @@ export const create = (f, 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);
+    };
+};
 ;
-export const value = (x) => {
-    const sig = signal();
+;
+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: (f) => (f(x), sig.on(f)),
-        ops: (f) => mapValues(f(x), notify),
+        op, on, ops,
         set: op(constantly((y) => x = y)),
-        update: op(constantly(noop))
+        update: op(constantly(noop)),
+        map: bind(map, on),
+        box: (f) => ({
+            on,
+            get value() { return x; },
+            ops: ops(f),
+        })
     };
 };
-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 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 = {};

package/string.d.ts

@@ -5,3 +5,4 @@ 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/string.js

@@ -26,3 +26,4 @@ export const readLine = (delims = new Set([0x0A])) => {
         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/struct.d.ts

@@ -1,4 +1,4 @@
-import type { TypedArray, Fn } from "./types";
+import type { TypedArray, Fn, NumberArray } from "./types";
 import type { Constructor } from "./typedarray";
 export interface Type {
     size: number;
@@ -36,7 +36,7 @@ export type Struct<T extends ReadonlyArray<Field<any>>> = Type & {
 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 TypedArray ? number : bigint) : C) : View<K[1]>;
+    [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/struct.js

@@ -1,5 +1,5 @@
 import { align as _align } from "./math";
-import { isTypedArray, isBigIntArray } from "./checks";
+import { isBigIntArray, isNumberArray } from "./checks";
 const vec = (type) => (length = 1, align = type.BYTES_PER_ELEMENT) => ({
     type, align, length, size: type.BYTES_PER_ELEMENT * length,
 });
@@ -42,7 +42,7 @@ export const struct = (fs, align = 0, offset = 0) => {
 };
 const property = (value) => ({
     enumerable: true,
-    ...((isTypedArray(value) || isBigIntArray(value)) && value.length == 1 ? {
+    ...((isNumberArray(value) || isBigIntArray(value)) && value.length == 1 ? {
         get: () => value[0],
         set: (x) => value[0] = x,
     } : { value })

package/tree.d.ts

@@ -3,8 +3,8 @@ export type Node<S, T = S> = T | Tree<S, T>;
 export type Tree<S, T = S> = [S, Node<S, T>[]];
 export declare const tree: <S, T = S>(value: S, children?: Node<S, T>[]) => Tree<S, T>;
 export declare const isTree: <S, T = S>(x: Node<S, T>) => x is Tree<S, T>;
-export declare const children: <S, T = S>(p?: TPred<Tree<S, T>, Node<S, T>>) => (x: Node<S, T>) => Node<S, T>[];
-export declare const value: <S, T = S>(p?: TPred<Tree<S, T>, Node<S, T>>) => (x: Node<S, T>) => S | T;
+export declare const 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>>>;

package/tree.js

@@ -1,10 +1,10 @@
 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 tree = (value, children = []) => [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;
-export const value = (p = isTree) => (x) => p(x) ? x[0] : x;
+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;
@@ -13,13 +13,11 @@ export const map = (parent, child, update = identity, p = isTree) => transform((
 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 = [];
-    const va = value(), vb = value();
-    const ca = children(), cb = children();
     for (const [a, b] of zipI(Iterator.from(na), Iterator.from(nb))) {
         if (!isTree(a) && !isTree(a))
-            res.push([va(a), vb(b)]);
+            res.push([value(a), value(b)]);
         else if ((isTree(a) && isTree(a)))
-            res.push([[va(a), vb(b)], zip(ca(a), cb(b))]);
+            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");
     }

package/treemap.d.ts

@@ -1,13 +1,13 @@
-export declare class Treemap<T = number> {
-    #private;
-    static from<T>(iter: Iterable<[T, T?]>): Treemap<T>;
-    nodes: Set<T>;
-    parents: Map<T, T>;
-    changed: boolean;
-    add(node: T, parent?: T): T;
-    remove(key: T): void;
-    parent(key: T): T | undefined;
-    get size(): number;
-    children(key: T): T[] | undefined;
-    [Symbol.iterator](): Generator<NonNullable<T>, void, unknown>;
+import type { Maybe } from "./types";
+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/treemap.js

@@ -1,68 +1,71 @@
-import { isUndefined } from "./checks";
-export class Treemap {
-    static from(iter) {
-        const tree = new Treemap();
-        for (const [n, p] of iter)
-            tree.add(n, p);
-        return tree;
-    }
-    nodes = new Set();
-    parents = new Map();
-    #children = new Map();
-    changed = false;
-    add(node, parent) {
-        const { nodes, parents } = this;
-        nodes.add(node);
-        if (!isUndefined(parent))
-            parents.set(node, parent);
-        this.changed = true;
-        return node;
-    }
-    remove(key) {
-        const { nodes, parents } = this;
-        nodes.delete(key);
-        parents.delete(key);
-        this.changed = true;
-    }
-    #update() {
-        const changed = this.changed;
-        if (changed) {
-            const { nodes, parents } = this;
-            const children = this.#children;
+import { before } from "./fn";
+import { isDefined } from "./checks";
+import { EMPTY } from "./constants";
+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 (!isUndefined(p)) {
+                if (isDefined(p)) {
                     if (!children.has(p))
                         children.set(p, []);
                     children.get(p).push(k);
                 }
             }
-            this.changed = false;
+            changed = false;
         }
-        return changed;
-    }
-    parent(key) {
-        this.#update();
-        return this.parents.get(key);
-    }
-    get size() {
-        this.#update();
-        return this.nodes.size;
-    }
-    children(key) {
-        this.#update();
-        return this.#children.get(key);
-    }
-    *[Symbol.iterator]() {
-        this.#update();
-        const { nodes, parents } = this;
-        const queue = [], children = this.#children;
-        nodes.forEach(k => !parents.has(k) && queue.push(k));
-        for (let node; queue.length > 0;) {
-            yield node = queue.shift();
-            if (children.has(node))
-                queue.push(...children.get(node));
-        }
-    }
-}
+        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/types.d.ts

@@ -2,6 +2,8 @@ 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 {
@@ -16,7 +18,6 @@ export type Fns<T> = {
 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 Resource<T> = Reactive<T, Dispose | void>;
 export type Constantly<T> = () => T;
 export type FirstParam<F extends FnV> = MaybeFirst<Parameters<F>>;
 export type MaybePromise<T = unknown> = T | PromiseLike<T>;
@@ -50,7 +51,7 @@ 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 Optional<T> = T | undefined;
+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];
@@ -59,9 +60,4 @@ 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 interface BufferView<T extends ArrayBufferLike = ArrayBufferLike> {
-    readonly buffer: T;
-    readonly byteLength: number;
-    readonly byteOffset: number;
-}
 export {};

package/weak.d.ts

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