@cgtk/std 0.0.195 → 0.0.197

package/array.d.ts

@@ -7,7 +7,8 @@ export declare const pop: <T>(xs: T[]) => T[];
 export declare const shift: <T>(xs: T[]) => T[];
 export declare const first: <T>(xs: T[]) => T;
 export declare const cap: <T>(n: number, f: Fn<T[]>) => Fn<T[], T[]>;
-export declare const retain: <T>(n: number, xs?: T[]) => (x: T) => T[];
+export declare const sliding: <T>(n: number, xs?: T[]) => (x: T) => T[];
+export declare const dropping: <T>(n: number, xs?: T[]) => (x: T) => T[];
 export declare const tuple: <T, N extends number>(...xs: T[] & {
     length: N;
 }) => Tuple<T, N>;

package/array.js

@@ -11,7 +11,8 @@ export const cap = (n, f) => xs => {
         f(xs);
     return xs;
 };
-export const retain = (n, xs = []) => comp(scan((push), xs), cap(n, shift));
+export const sliding = (n, xs = []) => comp(scan((push), xs), cap(n, shift));
+export const dropping = (n, xs = []) => comp(scan((push), xs), cap(n, pop));
 export const tuple = (...xs) => xs;
 export const seek = (arr, vals, offset = 0) => {
     for (let i = offset, n = arr.length; i < n; i++)

package/async.d.ts

@@ -1,8 +1,7 @@
-import type { Fn, Lazy, Maybe, Dispose, MaybePromise } from "./types.js";
-export declare const timeout: (ms: number, signal?: AbortSignal) => Promise<unknown>;
+import type { Lazy, Maybe, Dispose, MaybePromise, Promisified, AsyncDispose } from "./types.js";
+export declare const RESOLVED: Promise<void>;
+export declare const timeout: (ms: number, signal?: AbortSignal) => Promise<void>;
 export declare const delay: (ms: number, signal?: AbortSignal) => <T>(x: T) => Promise<T>;
 export declare const probing: <T>(p: Promise<T>) => Lazy<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>;
-export declare const dispose: (p: Promise<Dispose>) => Dispose;
+export declare const promisify: <T>(x: MaybePromise<T>) => Promisified<T>;
+export declare const dispose: (p: Promise<Dispose>) => AsyncDispose;

package/async.js

@@ -1,5 +1,6 @@
-import { filterT, disposable } from "./fn.js";
-import { isDefined } from "./checks.js";
+import { noop, then } from "./fn.js";
+import { isPromise } from "./checks.js";
+export const RESOLVED = Promise.resolve();
 export const timeout = (ms, signal) => new Promise((resolve, reject) => {
     if (signal?.aborted)
         reject(signal.reason);
@@ -8,7 +9,7 @@ export const timeout = (ms, signal) => new Promise((resolve, reject) => {
             if (signal?.aborted)
                 reject(signal.reason);
             else
-                resolve(undefined);
+                resolve();
         }, ms);
         signal?.addEventListener("abort", () => (clearTimeout(t), reject(signal.reason)), { once: true });
     }
@@ -19,13 +20,10 @@ export const probing = (p) => {
     p.then(x => value = x);
     return () => value;
 };
-export const resolved = (p) => {
-    const val = probing(p);
-    return (f) => {
-        const g = (filterT((isDefined), f));
-        return () => g(val());
-    };
+export const promisify = (x) => (isPromise(x) ? x : Promise.resolve(x));
+export const dispose = (p) => {
+    const { promise, resolve } = Promise.withResolvers();
+    let dispose = noop, disposed = false;
+    p.then(d => (dispose = then(d, resolve), disposed && dispose()));
+    return () => (disposed = true, dispose(), promise);
 };
-export const promise = (x) => (x instanceof Promise) ? x : Promise.resolve(x);
-export const then = (p) => (f) => p.then(f);
-export const dispose = (p) => disposable(async (dispose) => dispose(await p));

package/buffer.d.ts

@@ -1,14 +1,7 @@
-import type { Fn } from "./types.js";
-export interface BufReader {
-    offset: number;
-    line: Fn<void, string>;
-    u8: Fn<void, number>;
-    u16: Fn<boolean, number>;
-    u32: Fn<boolean, number>;
-    i8: Fn<void, number>;
-    i16: Fn<boolean, number>;
-    i32: Fn<boolean, number>;
-    f32: Fn<boolean, number>;
-    f64: Fn<boolean, number>;
-}
-export declare const bufReader: (data: Uint8Array, offset?: number) => BufReader;
+import type { Maybe } from "./types.js";
+export declare const fifo: <T>(n?: number) => {
+    put(x: T): Promise<number>;
+    take(): Promise<T>;
+    readonly size: number;
+    peek(): Maybe<T>;
+};

package/buffer.js

@@ -1,54 +1,28 @@
-import { readLine } from './string.js';
-export const bufReader = (data, offset = 0) => {
-    const rl = readLine();
-    const dv = new DataView(data.buffer, data.byteOffset);
+import { isDefined } from "./checks.js";
+export const fifo = (n = 1) => {
+    const data = [];
+    const pushes = [];
+    const takes = [];
     return {
-        get offset() { return offset; },
-        set offset(x) { offset = x; },
-        line() {
-            const line = rl(data, offset);
-            offset += line.length;
-            return line;
-        },
-        u8() {
-            const x = dv.getUint8(offset);
-            offset += 1;
-            return x;
-        },
-        u16(littleEndian = true) {
-            const x = dv.getUint16(offset, littleEndian);
-            offset += 2;
-            return x;
-        },
-        u32(littleEndian = true) {
-            const x = dv.getUint16(offset, littleEndian);
-            offset += 4;
-            return x;
-        },
-        i8() {
-            const x = dv.getInt8(offset);
-            offset += 1;
-            return x;
-        },
-        i16(littleEndian = true) {
-            const x = dv.getInt16(offset, littleEndian);
-            offset += 2;
-            return x;
-        },
-        i32(littleEndian = true) {
-            const x = dv.getInt32(offset, littleEndian);
-            offset += 4;
-            return x;
-        },
-        f32(littleEndian = true) {
-            const x = dv.getFloat32(offset, littleEndian);
-            offset += 4;
-            return x;
-        },
-        f64(littleEndian = true) {
-            const x = dv.getFloat64(offset, littleEndian);
-            offset += 8;
-            return x;
-        },
+        async put(x) {
+            if (data.length >= n)
+                return new Promise(resolve => pushes.push(() => (data.push(x), resolve(data.length))));
+            const len = data.push(x);
+            const f = takes.shift();
+            if (isDefined(f))
+                f(x);
+            return Promise.resolve(len);
+        },
+        async take() {
+            if (data.length == 0)
+                return new Promise(resolve => takes.push(resolve));
+            const x = data.shift();
+            const f = pushes.shift();
+            if (isDefined(f))
+                f();
+            return Promise.resolve(x);
+        },
+        get size() { return data.length; },
+        peek() { return data[0]; }
     };
 };

package/bytes.d.ts

@@ -0,0 +1,14 @@
+import type { Fn } from "./types.js";
+export interface BufReader {
+    offset: number;
+    line: Fn<void, string>;
+    u8: Fn<void, number>;
+    u16: Fn<boolean, number>;
+    u32: Fn<boolean, number>;
+    i8: Fn<void, number>;
+    i16: Fn<boolean, number>;
+    i32: Fn<boolean, number>;
+    f32: Fn<boolean, number>;
+    f64: Fn<boolean, number>;
+}
+export declare const bufReader: (data: Uint8Array, offset?: number) => BufReader;

package/bytes.js

@@ -0,0 +1,54 @@
+import { readLine } from './string.js';
+export const bufReader = (data, offset = 0) => {
+    const rl = readLine();
+    const dv = new DataView(data.buffer, data.byteOffset);
+    return {
+        get offset() { return offset; },
+        set offset(x) { offset = x; },
+        line() {
+            const line = rl(data, offset);
+            offset += line.length;
+            return line;
+        },
+        u8() {
+            const x = dv.getUint8(offset);
+            offset += 1;
+            return x;
+        },
+        u16(littleEndian = true) {
+            const x = dv.getUint16(offset, littleEndian);
+            offset += 2;
+            return x;
+        },
+        u32(littleEndian = true) {
+            const x = dv.getUint16(offset, littleEndian);
+            offset += 4;
+            return x;
+        },
+        i8() {
+            const x = dv.getInt8(offset);
+            offset += 1;
+            return x;
+        },
+        i16(littleEndian = true) {
+            const x = dv.getInt16(offset, littleEndian);
+            offset += 2;
+            return x;
+        },
+        i32(littleEndian = true) {
+            const x = dv.getInt32(offset, littleEndian);
+            offset += 4;
+            return x;
+        },
+        f32(littleEndian = true) {
+            const x = dv.getFloat32(offset, littleEndian);
+            offset += 4;
+            return x;
+        },
+        f64(littleEndian = true) {
+            const x = dv.getFloat64(offset, littleEndian);
+            offset += 8;
+            return x;
+        },
+    };
+};

package/channel.d.ts

@@ -0,0 +1,37 @@
+import type { Fn, FnV, Dispose, Structure, Pred } from "./types.js";
+export interface Channel<T> {
+    next: Fn<T>;
+    on(next: Fn<T>, done?: Dispose): Dispose;
+    done: Dispose;
+    stateful(f: Fn<T, Dispose>, done?: Dispose): Dispose;
+    to<S>(f: Fn<Channel<T>, Channel<S>>): Channel<S>;
+}
+export declare const create: <T>(subs?: Set<{
+    next: Fn<T>;
+    done: Dispose;
+}>) => Channel<T>;
+export declare const cached: <T>(ch?: Channel<T>) => Channel<T>;
+export interface Value<T> extends Channel<T> {
+    value: T;
+}
+export declare const value: <T>(x: T, ch?: Channel<T>) => Value<T>;
+export declare const pipe: <T, S>(f: Fn<Fn<S>, Fn<T>>, ch?: Channel<S>) => Fn<Channel<T>, Channel<S>>;
+export declare const map: <T, S>(f: Fn<T, S>, ch?: Channel<S>) => Fn<Channel<T>, Channel<S>>;
+export declare const filter: <T>(p: Pred<T>, ch?: Channel<T>) => Fn<Channel<T>, Channel<T>>;
+export declare const then: <T>(ch?: Channel<T>) => Fn<Channel<Promise<T>>, Channel<T>>;
+export declare const dedup: <T, S = T>(key?: Fn<T, S>, ch?: Channel<T>) => Fn<Channel<T>, Channel<T>>;
+export declare const gen: <T>(f: FnV<[Fn<T>, Dispose], Dispose | void>, ch?: Channel<T>) => Channel<T>;
+export declare const reduce: <T, S>(f: FnV<[S, T], S>, a: S, ch?: Channel<S>) => (c: Channel<T>) => Channel<S>;
+export declare const flatten: <T>(ch?: Channel<T>) => (cs: Channel<Channel<T>>) => Channel<T>;
+export declare const latest: <T>(ch?: Channel<T>) => (cs: Channel<Channel<T>>) => Channel<T>;
+export declare const microOn: <T>(ch?: Channel<T>) => Channel<T>;
+type F2C<T> = T extends Fn<infer U> ? Channel<U> : T extends readonly (infer U)[] ? readonly F2C<U>[] : {
+    [K in keyof T]: F2C<T[K]>;
+};
+export declare const derive: <T, F extends Structure<Fn<any>>>(cs: F2C<F>, f: Fn<Fn<T>, F>, ch?: Channel<T>) => Channel<T>;
+export interface Reactive<T> extends Value<T> {
+    set: Fn<T | Fn<T, T>>;
+    update: Fn<Fn<T>>;
+}
+export declare const reactive: <T>(x: T) => Reactive<T>;
+export {};

package/channel.js

@@ -0,0 +1,82 @@
+import * as F from "./fn.js";
+import { isFunction } from "./checks.js";
+import { add } from "./set.js";
+const channel = (next, on, done = F.noop) => ({
+    next, on, done,
+    to(f) { return f(this); },
+    stateful(next, done = F.noop) {
+        const swap = F.swapping();
+        return on(swap(next), swap(done));
+    },
+});
+export const create = (subs = new Set()) => channel((x) => subs.forEach(s => s.next(x)), (next, done = F.noop) => {
+    const del = add(subs, { next, done });
+    return () => del() && done();
+}, () => (subs.forEach(s => s.done()), subs.clear()));
+const None = Symbol('None');
+export const cached = (ch = create()) => {
+    let x = None;
+    return channel(y => ch.next(x = y), (next, done) => {
+        if (x !== None)
+            next(x);
+        return ch.on(next, done);
+    }, ch.done);
+};
+export const value = (x, ch = create()) => Object.defineProperties(channel(y => ch.next(x = y), (next, done) => (next(x), ch.on(next, done)), ch.done), {
+    value: {
+        enumerable: true,
+        get: () => x,
+        set: (y) => x = y
+    }
+});
+export const pipe = (f, ch = create()) => c => channel(ch.next, ch.on, c.on(f(ch.next), ch.done));
+export const map = (f, ch) => pipe(F.bind(F.comp, f), ch);
+export const filter = (p, ch) => pipe(F.bind(F.filter, p), ch);
+export const then = (ch) => pipe(next => p => p.then(next), ch);
+export const dedup = (key = F.identity, ch) => pipe(next => {
+    let x = None;
+    return (y) => {
+        const k = key(y);
+        if (k !== x)
+            next(y);
+        x = k;
+    };
+}, ch);
+export const gen = (f, ch = create()) => {
+    let ended = false;
+    let done = () => { ended = true; };
+    done = F.forEach(f(ch.next, () => done()) ?? F.noop, ch.done);
+    return ended ? channel(F.noop, F.constantly(F.noop)) : channel(ch.next, ch.on, done);
+};
+export const reduce = (f, a, ch = create()) => (c) => channel(F.noop, ch.on, c.on(F.scan(f, a), F.forEach(() => ch.next(a), ch.done)));
+export const flatten = (ch = create()) => (cs) => {
+    const ds = new Set();
+    return channel(ch.next, ch.on, cs.on(c => (ds.add(c.done), c.on(ch.next)), F.forEach(ch.done, () => ds.forEach(d => d()))));
+};
+export const latest = (ch = create()) => (cs) => channel(ch.next, ch.on, cs.stateful(c => c.on(ch.next, c.done), ch.done));
+export const microOn = (ch = create()) => channel(ch.next, (next, done = F.noop) => {
+    const ctrl = new AbortController();
+    let off = () => (ctrl.abort(), done());
+    queueMicrotask(() => off = ctrl.signal.aborted ? F.noop : ch.on(next, done));
+    return () => off();
+}, ch.done);
+const isChannel = (c) => Object.hasOwn(c, "next") && isFunction(c.next) && Object.hasOwn(c, "on") && isFunction(c.on) && Object.hasOwn(c, "next") && isFunction(c.next);
+export const derive = (cs, f, ch = create()) => {
+    let done = F.noop;
+    const rec = (cs, fs) => {
+        if (isFunction(fs) && isChannel(cs))
+            return cs.on(fs, () => done());
+        else if (Array.isArray(cs) && Array.isArray(fs))
+            return F.forEach(...cs.map((c, i) => rec(c, fs[i])));
+        return F.forEach(...Object.entries(cs).map(([k, v]) => rec(v, fs[k])));
+    };
+    done = F.forEach(rec(cs, f(ch.next)), ch.done);
+    return channel(ch.next, ch.on, done);
+};
+export const reactive = (x) => {
+    const ch = value(x);
+    return Object.assign(ch, {
+        set: (y) => ch.next(isFunction(y) ? y(ch.value) : y),
+        update: (f) => (f(ch.value), ch.next(ch.value)),
+    });
+};

package/checks.d.ts

@@ -2,6 +2,7 @@ import type { TypedArray, NumberArray, BigIntArray, Pred, TPred, Maybe } from ".
 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 isBoolean: (x: any) => x is boolean;
 export declare const isUndefined: (x: any) => x is undefined;
 export declare const isNull: (x: any) => x is null;
 export declare const isDefined: <T>(x: Maybe<T>) => x is T;
@@ -27,3 +28,6 @@ export declare const isEmpty: (x: {
     length: number;
 }) => boolean;
 export declare const counted: (n: number) => () => boolean;
+export declare const isBitSet: (x: number, n: number) => boolean;
+export declare const isPromise: <T = any>(x: any) => x is Promise<T>;
+export declare const isPromiseLike: <T = any>(x: any) => x is PromiseLike<T>;

package/checks.js

@@ -1,5 +1,5 @@
 import { comp, not, apply, and } from "./fn.js";
-import { retain } from "./array.js";
+import { sliding } from "./array.js";
 export const isTypedArray = (x) => x && (x instanceof Uint8Array || x instanceof Uint8ClampedArray ||
     x instanceof Uint16Array || x instanceof Uint32Array ||
     x instanceof Int8Array || x instanceof Int16Array || x instanceof Int32Array ||
@@ -10,6 +10,7 @@ export const isNumberArray = (x) => x && (x instanceof Uint8Array || x instanceo
     x instanceof Int8Array || x instanceof Int16Array || x instanceof Int32Array ||
     x instanceof Float16Array || x instanceof Float32Array || x instanceof Float64Array);
 export const isBigIntArray = (x) => x && (x instanceof BigUint64Array || x instanceof BigInt64Array);
+export const isBoolean = (x) => typeof x === "boolean";
 export const isUndefined = (x) => x === undefined;
 export const isNull = (x) => x === null;
 export const isDefined = (x) => !isUndefined(x);
@@ -28,8 +29,8 @@ export const isclose = (a, b, eps = Number.EPSILON) => Math.abs(a - b) < eps;
 export const allclose = (a, b, eps) => a.length == b.length && a.every((x, i) => isclose(x, b[i], eps));
 export const equal = (a, b) => a == b;
 export const strictEqual = (a, b) => a === b;
-export const isDiffPrev = (eq = (strictEqual)) => comp(retain(2), not(apply(eq)));
-export const isLonger = (delta) => comp((x) => [performance.now(), x], retain(2), (xs) => xs.length < 2 || xs[1][0] - xs[0][0] > delta);
+export const isDiffPrev = (eq = (strictEqual)) => comp(sliding(2), not(apply(eq)));
+export const isLonger = (delta) => comp((x) => [performance.now(), x], sliding(2), (xs) => xs.length < 2 || xs[1][0] - xs[0][0] > delta);
 export const isFunction = (x) => typeof x === "function";
 export const isAborted = (signal) => () => signal.aborted;
 export const isArrayBufferLike = (x) => x instanceof ArrayBuffer || x instanceof SharedArrayBuffer;
@@ -42,3 +43,6 @@ export const counted = (n) => {
     let m = 0;
     return () => m++ < n;
 };
+export const isBitSet = (x, n) => (x & (1 << n)) !== 0;
+export const isPromise = (x) => x instanceof Promise;
+export const isPromiseLike = (x) => x instanceof Promise;

package/dom.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, Dispose, RecordOf, Maybe } from "./types.js";
+import type { Fn, FnV, Dispose, RecordOf, Maybe } from "./types.js";
 export declare const customEvent: <T>(type: string, detail: T, { composed, bubbles, cancelable }?: EventInit) => CustomEvent<T>;
 type ListenOpts = boolean | AddEventListenerOptions;
 export declare const on: {
@@ -36,16 +36,34 @@ export declare const onAll: {
 type DragHandlers = Record<'down' | 'move' | 'up', Fn<PointerEvent>>;
 export declare const onDrag: {
     (el: HTMLElement, fns: Partial<DragHandlers>): Dispose;
-    (el: SVGGraphicsElement, fns: Partial<DragHandlers>): Dispose;
+    (el: SVGElement, fns: Partial<DragHandlers>): Dispose;
 };
+export declare const onDragX: (el: HTMLElement, f: Fn<number>) => Dispose;
 export declare const onDragMove: {
     (el: HTMLElement, f: Fn<PointerEvent>): Dispose;
     (el: SVGGraphicsElement, f: Fn<PointerEvent>): Dispose;
 };
 export declare const onResize: (el: Element, f: Fn<ResizeObserverEntry[]>, options?: ResizeObserverOptions) => Dispose;
+export declare const onSelectChange: <T extends string>(el: HTMLSelectElement, f: FnV<[T, number]>, opts?: ListenOpts) => Dispose;
 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) => Maybe<RecordOf<string>>;
 export declare const imageData: (img: HTMLImageElement) => ImageData;
+export type Child = ChildNode | string;
+export declare const append: (el: ParentNode, ...children: Child[]) => () => void;
+export type Attribs = Record<string, string | number | boolean>;
+export declare const setAttrs: (el: Element, attrs: Attribs) => void;
+export declare const css: (styles: Record<string, {
+    toString(): string;
+}>) => string;
+export declare const style: <E extends HTMLElement>(el: E, props: Record<string, {
+    toString(): string;
+}>) => E;
+type Tags<T> = {
+    [K in keyof T]: (attrs?: Attribs | Child, ...rest: Child[]) => T[K];
+};
+export declare const h: Tags<HTMLElementTagNameMap>;
+export declare const s: Tags<SVGElementTagNameMap>;
+export declare const m: Tags<MathMLElementTagNameMap>;
 export {};

package/dom.js

@@ -1,13 +1,13 @@
-import { forEach, noop } from "./fn.js";
-import { isDefined } from "./checks.js";
+import * as F from "./fn.js";
+import { isDefined, isString, isBoolean } from "./checks.js";
 import { EMPTY } from "./constants.js";
 export const customEvent = (type, detail, { composed = false, bubbles = false, cancelable = false } = EMPTY.OBJ) => new CustomEvent(type, { bubbles, cancelable, composed, detail });
 export const on = (el, name, listener, opts = false) => {
     el.addEventListener(name, listener, opts);
     return () => el.removeEventListener(name, listener, opts);
 };
-export const onAll = (el, fs, opts) => forEach(...Object.keys(fs).map(k => on(el, k, fs[k], opts)));
-export const onDrag = (el, { down = noop, move = noop, up = noop }) => on(el, 'pointerdown', e => {
+export const onAll = (el, fs, opts) => F.forEach(...Object.keys(fs).map(k => on(el, k, fs[k], opts)));
+export const onDrag = (el, { down = F.noop, move = F.noop, up = F.noop }) => on(el, 'pointerdown', e => {
     const pointerId = e.pointerId;
     el.setPointerCapture(pointerId);
     down(e);
@@ -19,12 +19,18 @@ export const onDrag = (el, { down = noop, move = noop, up = noop }) => on(el, 'p
         offUp();
     });
 });
+export const onDragX = (el, f) => onDrag(el, {
+    down: e => f(e.offsetX / el.clientWidth),
+    move: e => f(e.offsetX / el.clientWidth),
+    up: e => f(e.offsetX / el.clientWidth),
+});
 export const onDragMove = (el, move) => onDrag(el, { move });
 export const onResize = (el, f, options) => {
     const ro = new ResizeObserver(f);
     ro.observe(el, options);
     return () => ro.disconnect();
 };
+export const onSelectChange = (el, f, opts) => on(el, "change", () => f(el.value, el.selectedIndex), opts);
 export const preventDefault = (e) => e.preventDefault();
 export const loadImage = (img, src) => new Promise((resolve) => {
     const off = on(img, "load", () => (off(), resolve(img)));
@@ -39,3 +45,55 @@ export const imageData = (img) => {
     ctx.drawImage(img, 0, 0);
     return ctx.getImageData(0, 0, img.width, img.height);
 };
+export const append = (el, ...children) => {
+    const els = children.map(x => isString(x) ? document.createTextNode(x) : x);
+    el.append(...els);
+    return () => els.forEach(x => x.remove());
+};
+export const setAttrs = (el, attrs) => Object.entries(attrs).forEach(([k, v]) => {
+    if (isBoolean(v)) {
+        if (el instanceof HTMLInputElement) {
+            if (k === "checked")
+                el.checked = v;
+            if (k === "disabled")
+                el.disabled = v;
+        }
+        else {
+            el.toggleAttribute(k, v);
+        }
+    }
+    else
+        el.setAttribute(k, v.toString());
+});
+export const css = (styles) => Object.entries(styles).map(([prop, value]) => `${prop}: ${value};`).join('');
+export const style = (el, props) => (Object.entries(props).forEach(([k, v]) => el.style.setProperty(k, v.toString())), el);
+const isAttrs = (obj) => (obj !== null &&
+    typeof obj === 'object' &&
+    !(obj instanceof Node) &&
+    !Array.isArray(obj));
+const element = (el, attrs, ...rest) => {
+    if (isDefined(attrs)) {
+        let children = rest;
+        if (isAttrs(attrs))
+            setAttrs(el, attrs);
+        else
+            children = [attrs, ...children];
+        append(el, ...children);
+    }
+    return el;
+};
+const NS = {
+    HTML: "http://www.w3.org/1999/xhtml",
+    SVG: "http://www.w3.org/2000/svg",
+    MathML: "http://www.w3.org/1998/Math/MathML",
+};
+const tag = (ns, name) => document.createElementNS(NS[ns], name);
+export const h = new Proxy({}, ({
+    get: (_, name) => F.bind((element), tag("HTML", name))
+}));
+export const s = new Proxy({}, {
+    get: (_, name) => F.bind((element), tag("SVG", name))
+});
+export const m = new Proxy({}, {
+    get: (_, name) => F.bind((element), tag("MathML", name))
+});

package/fn.d.ts

@@ -1,13 +1,11 @@
-import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Lazy, Maybe, Dispose, Reactive } from "./types.js";
+import type { Fn, FnV, FnF, Pred, Last, Lazy, Dispose, Reactive, Promisified, MaybePromise } from "./types.js";
 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 comp: <Fs extends Fn[]>(...fs: Fs) => (x: Fs[0] extends Fn<infer T> ? T : never) => 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;
 export declare const forEach: <T, R = any>(...fs: Fn<T, R>[]) => (x: T) => void;
-export declare const map: <T, S, U>(f: Fn<T, S>, g: Fn<S, U>) => Fn<T, U>;
 export declare const and: <T>(...fs: Pred<T>[]) => (x: T) => boolean;
 export declare const or: <T>(...fs: Pred<T>[]) => (x: T) => boolean;
 export declare const not: <T>(p: Pred<T>) => (x: T) => boolean;
-export declare const comb: <C extends FnV<Fn[]>>(c: C) => (...fs: Fn<FirstParam<FirstParam<C>>, ReturnType<FirstParam<C>>>[]) => (x: FirstParam<FirstParam<C>>) => ReturnType<C>;
 export declare const noop: () => void;
 export declare const identity: <S, T = S>(x: S) => T;
 export declare const constantly: <T>(x: T) => Lazy<T>;
@@ -19,14 +17,14 @@ export declare const where: <T, U, V>(p: Pred<T>, f: Fn<T, U>, g: Fn<T, V>) => (
 export declare const before: <F extends Fn<void>>(f: F) => FnF;
 export declare const after: <F extends Fn<void>>(f: F) => FnF;
 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 disposable: (f: Fn<Fn<Dispose, Dispose>>, disposes?: Set<Dispose>) => 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 swapping: () => <F extends FnV<any[], Dispose | void>>(f: F) => FnV<Parameters<F>, 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;
+export declare const toggler: (f: Fn<void, Dispose>) => Fn<boolean, Dispose>;
 export declare const voidify: <F extends FnV>(f: F) => (...xs: Parameters<F>) => void;
 export declare const effectual: <T>(f: Reactive<T>, g: Fn<T>) => Dispose;
+export declare const promisify: <F extends FnV>(f: F) => (...xs: Parameters<F>) => Promisified<ReturnType<F>>;
+export declare const then: <T, F extends FnV<any, MaybePromise<any>>>(f: F, g?: Fn<Awaited<ReturnType<F>>, T>) => (...xs: Parameters<F>) => Promise<T>;

package/fn.js

@@ -1,13 +1,13 @@
 import { add } from "./set.js";
+import * as Async from "./async.js";
+import { isPromise } from "./checks.js";
 export const tee = f => x => (f(x), x);
 export const comp = (...fs) => (x) => fs.reduce((x, f) => f(x), x);
 export const pipe = (x, ...fs) => fs.reduce((x, f) => f(x), x);
 export const forEach = (...fs) => (x) => fs.forEach(f => f(x));
-export const map = (f, g) => comp(f, g);
 export const and = (...fs) => (x) => fs.reduce((a, f) => a && f(x), true);
 export const or = (...fs) => (x) => fs.reduce((a, f) => a || f(x), false);
 export const not = (p) => (x) => !p(x);
-export const comb = (c) => (...fs) => (x) => c(...fs.map(f => f(x)));
 export const noop = () => { };
 export const identity = (x) => x;
 export const constantly = (x) => () => x;
@@ -24,8 +24,6 @@ export const after = (f) => g => (...xs) => {
 };
 export const filter = (p, f) => (x) => { if (p(x))
     f(x); };
-export const filterT = (p, f) => (x) => { if (p(x))
-    f(x); };
 export const scan = (f, a) => (x) => a = f(a, x);
 export const memoize = (f, key = (...xs) => xs[0], cache = new Map()) => (...xs) => {
     const k = key(...xs);
@@ -42,19 +40,24 @@ export const disposable = (f, disposes = new Set()) => {
     f(bind(add, disposes));
     return () => (disposes.forEach(g => g()), disposes.clear());
 };
-export const disposing = () => {
+export const swapping = () => {
     let dispose = noop;
     const stop = () => dispose();
     return (f) => (...xs) => (stop(), dispose = f(...xs) ?? noop, stop);
 };
-export const disposeWith = (f) => (g) => disposable((d) => g(comp(f, d)));
-export const idemp = (d, f) => disposing()((...xs) => {
+export const idemp = (d, f) => swapping()((...xs) => {
     const cleanup = f(...xs) ?? noop;
     return forEach(cleanup, d(cleanup));
 });
 export const toggler = (f) => {
     let cancel = noop;
-    return (x) => (cancel(), (cancel = x ? f() : noop));
+    const stop = () => cancel();
+    return (x) => (stop(), (cancel = x ? f() : noop), stop);
 };
 export const voidify = (f) => (...xs) => { f(...xs); };
 export const effectual = (f, g) => disposable(d => d(f(idemp(d, g))));
+export const promisify = (f) => (...xs) => Async.promisify(f(...xs));
+export const then = (f, g = identity) => (...xs) => {
+    const r = f(...xs);
+    return isPromise(r) ? r.then(g) : Promise.resolve(g(r));
+};

package/iterable.d.ts

@@ -5,23 +5,13 @@ export declare const just: <T>(x: T) => IteratorObject<T>;
 export declare const enumerate: (n?: number) => <T>(x: T) => Indexed<T>;
 export declare function empty(): Generator<never, void, unknown>;
 export declare function concat<T>(...xxs: ReadonlyArray<IteratorObject<T>>): Generator<T, void, unknown>;
-export declare const toArray: <T>(xs: IteratorObject<T>) => T[];
 export declare const map: <T, U = T>(f: Fn<T, U>) => (xs: IteratorObject<T>) => IteratorObject<U, undefined, unknown>;
-export declare const filter: <T>(f: Pred<T>) => (xs: IteratorObject<T>) => IteratorObject<T, undefined, unknown>;
-export declare const drop: (n: number) => <T>(xs: IteratorObject<T>) => IteratorObject<T, undefined, unknown>;
-export declare const flatMap: <T, U = Iterable<T>>(f: Fn<T, Iterator<U> | Iterable<U>>) => (xs: IteratorObject<T>) => IteratorObject<U, undefined, unknown>;
-export declare const forEach: <T>(f?: Fn<T>) => (xs: IteratorObject<T>) => void;
-export declare const some: <T>(f: Pred<T>) => (xs: IteratorObject<T>) => boolean;
-export declare const every: <T>(f: Pred<T>) => (xs: IteratorObject<T>) => boolean;
-export declare const find: <T>(f: Pred<T>) => (xs: IteratorObject<T>) => T | undefined;
-export declare const flat: <T>(xs: IteratorObject<IteratorObject<T>>) => IteratorObject<T, undefined, unknown>;
 export declare const prepend: <A>(ys: IteratorObject<A>) => (xs: IteratorObject<A>) => Generator<A, void, unknown>;
 export declare const append: <A>(ys: IteratorObject<A>) => (xs: IteratorObject<A>) => Generator<A, void, unknown>;
 export declare const first: <T>(xs: IteratorObject<T>) => T | undefined;
 export declare const reduce: <T, S>(f: FnV<[S, T, number], S>, a: S) => (xs: IteratorObject<T>) => S;
 export declare const reduceRec: <T, A, R>(xs: IteratorObject<T>, f: FnV<[A, T, Fn<A>], R>, o: A, result: Fn<A, R>) => R;
-export declare const traverse: <T>(children: Fn<T, Iterable<T>>, f: Fn<T>) => Fn<T>;
-export declare const take: (n: number) => <T>(xs: IteratorObject<T>) => Generator<T>;
+export declare const take: <T>(n: number, xs: IteratorObject<T>) => Generator<T, void, unknown>;
 export declare function arange(a: number, b?: number, s?: number): Generator<number, void, unknown>;
 export declare const linspace: (a: number, b: number, n: number) => Generator<number, void, unknown>;
 export declare const steps: (a: number, b: number, s?: number, o?: number, eps?: number) => Generator<number, void, unknown>;

package/iterable.js

@@ -1,5 +1,5 @@
 import { assert, isDefined } from "./checks.js";
-import { pipe, comp, scan, apply, noop, identity, constantly } from "./fn.js";
+import { bind, pipe, comp, scan, apply, noop, constantly } from "./fn.js";
 import { set } from "./map.js";
 export const next = (xs) => {
     const { done, value } = xs.next();
@@ -15,16 +15,7 @@ export function* empty() { }
 export function* concat(...xxs) { for (const xs of xxs)
     yield* xs; }
 ;
-export const toArray = (xs) => xs.toArray();
 export const map = (f) => (xs) => xs.map(f);
-export const filter = (f) => (xs) => xs.filter(f);
-export const drop = (n) => (xs) => xs.drop(n);
-export const flatMap = (f) => (xs) => xs.flatMap(f);
-export const forEach = (f = noop) => (xs) => xs.forEach(f);
-export const some = (f) => (xs) => xs.some(f);
-export const every = (f) => (xs) => xs.every(f);
-export const find = (f) => (xs) => xs.find(f);
-export const flat = (xs) => xs.flatMap(identity);
 export const prepend = (ys) => (xs) => concat(ys, xs);
 export const append = (ys) => (xs) => concat(xs, ys);
 export const first = (xs) => xs.find(constantly(true));
@@ -39,8 +30,7 @@ export const reduceRec = (xs, f, o, result) => {
     };
     return next(o);
 };
-export const traverse = (children, f) => (x) => (f(x), forEach(traverse(children, f))(Iterator.from(children(x))));
-export const take = n => function* (xs) {
+export const take = function* (n, xs) {
     for (let i = 0; i < n; i++) {
         const { done, value } = xs.next();
         if (done)
@@ -146,8 +136,8 @@ export const reduceA = (f, a) => async (xs) => {
 export const race = (n) => async function* (xs) {
     const it = pipe(xs, map(enumerate()), map(([i, x]) => [i, x.then(y => [i, y])]));
     const accum = reduce((set), new Map());
-    const tasks = pipe(it, (take(n)), accum);
-    const next = comp((take(1)), accum);
+    const tasks = pipe(it, bind((take), n), accum);
+    const next = comp(bind((take), 1), accum);
     while (tasks.size > 0) {
         const [i, x] = await Promise.race(tasks.values());
         tasks.delete(i);
@@ -155,4 +145,4 @@ export const race = (n) => async function* (xs) {
         next(it);
     }
 };
-export const zmap = (f) => (...xs) => forEach(apply(f))(zip(...xs));
+export const zmap = (f) => (...xs) => zip(...xs).forEach(apply(f));

package/math.d.ts

@@ -33,3 +33,4 @@ export declare const align: (x: number, b: number) => number;
 export declare const sign11: (x: number) => 1 | -1;
 export declare const nudge: (x: number, v?: number, eps?: number) => number;
 export declare const divCeil: (a: number, b: number) => number;
+export declare const trunc: (num: number, precision: number) => number;

package/math.js

@@ -42,3 +42,7 @@ export const align = (x, b) => (x + b - 1) & -b;
 export const sign11 = (x) => x >= 0 ? 1 : -1;
 export const nudge = (x, v = 0, eps = EPS) => isclose(x, v, eps) ? sign11(x - v) * eps + v : x;
 export const divCeil = (a, b) => Math.ceil(a / b);
+export const trunc = (num, precision) => {
+    const factor = Math.pow(10, precision);
+    return Math.trunc(num * factor) / factor;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cgtk/std",
-  "version": "0.0.195",
+  "version": "0.0.197",
   "type": "module",
   "main": "./index.js",
   "exports": {
@@ -9,7 +9,6 @@
     "./checks": "./checks.js",
     "./fn": "./fn.js",
     "./object": "./object.js",
-    "./signal": "./signal.js",
     "./assign": "./assign.js",
     "./map": "./map.js",
     "./set": "./set.js",
@@ -25,6 +24,7 @@
     "./stream": "./stream.js",
     "./progress": "./progress.js",
     "./constants": "./constants.js",
+    "./channel": "./channel.js",
     "./http": "./http.js",
     "./json": "./json.js",
     "./dom": "./dom.js",
@@ -32,12 +32,12 @@
     "./math": "./math.js",
     "./basen": "./basen.js",
     "./struct": "./struct.js",
-    "./buffer": "./buffer.js",
+    "./bytes": "./bytes.js",
     "./base64": "./base64.js",
     "./npy": "./npy.js",
     "./port": "./port.js",
     "./rect": "./rect.js",
-    "./resource": "./resource.js",
+    "./scope": "./scope.js",
     "./utils": "./utils.js"
   },
   "publishConfig": {

package/port.d.ts

@@ -1,4 +1,4 @@
-import type { Dispose, Fn, Fns, FnV, RecordOf, MaybePromise, Reactive } from "./types.js";
+import type { Dispose, Fn, Fns, FnV, RecordOf, MaybePromise, Reactive, AsyncDispose } from "./types.js";
 export interface Message<K, V> {
     type: K;
     payload: V;
@@ -25,6 +25,6 @@ interface TransferableFnV<T extends any[], R> {
 }
 export declare const client: <S extends RecordOf<any>, T = Worker>(target: Port & MessageEventTarget<T>) => { [k in keyof S]: TransferableFnV<Parameters<S[k]>, Promise<ReturnType<S[k]>>>; };
 export declare const server: <S extends RecordOf<any>, T = Worker>(target: Port & MessageEventTarget<T>) => { [k in keyof S]: Fn<FnV<Parameters<S[k]>, MaybePromise<ReturnType<S[k]>>>, Dispose>; };
-export declare const startClient: (worker: Worker, f: Fn<Worker, Dispose | void>) => Promise<Dispose>;
+export declare const startClient: (worker: Worker, f: Fn<Worker, Dispose | void>) => Promise<AsyncDispose>;
 export declare const startServer: (worker: Worker, f: Fn<Worker, MaybePromise<Dispose>>) => Promise<Dispose>;
 export {};

package/port.js

@@ -1,7 +1,7 @@
-import { forEach, noop, bind } from "./fn.js";
+import { noop, bind, then } from "./fn.js";
 import { isDefined } from "./checks.js";
 import { on } from "./dom.js";
-import { promise } from "./async.js";
+import { promisify } from "./async.js";
 ;
 export const onMessages = (target, fs) => on(target, "message", ({ data: { type, payload } }) => (type in fs) && fs[type](payload));
 export const onMessage = (target, name, f) => on(target, "message", ({ data: { type, payload } }) => type == name && f(payload));
@@ -39,18 +39,18 @@ export const server = (target) => {
     onMessage(target, "rpc", async ({ id, name, args }) => {
         const f = fns.get(name);
         if (isDefined(f))
-            rpc({ id, result: await promise(f(...args)) });
+            rpc({ id, result: await promisify(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()));
+    const { start, stop } = client(worker);
+    await start();
+    return then(stop, f(worker) ?? noop);
 };
 export const startServer = async (worker, f) => {
-    const ser = server(worker);
-    return ser.start(async () => { ser.stop(await promise(f(worker))); });
+    const { start, stop } = server(worker);
+    return start(async () => { stop(await promisify(f(worker))); });
 };

package/schedule.d.ts

@@ -1,10 +1,10 @@
 import type { Dispose, Fn, FnV, Reactive } from './types.js';
 export declare const raf: Reactive<number>;
-export declare const timeout: (ms: number) => Reactive<void>;
+export declare const timeout: (ms?: number) => Reactive<void>;
 export declare const schedule: <T>(s: Reactive<T>) => <F extends FnV>(f: F) => FnV<Parameters<F>, Dispose>;
 export declare const idempotent: <T>(s: Reactive<T>, d: Fn<Dispose, Dispose>) => <F extends FnV>(f: F) => FnV<Parameters<F>, Dispose>;
 export declare const debounce: <T>(sched?: Reactive<T>) => Reactive<T>;
 export declare const reset: <T>(sched?: Reactive<T>) => Reactive<T>;
-export declare const repeatedly: <T>(f: Fn<void>, sched?: Reactive<T>) => () => any;
+export declare const repeatedly: <T = number>(sched?: Reactive<T>) => (f: Fn<T, boolean | void>) => () => 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;
+export declare const micro: <F extends FnV>(f: F) => (...xs: Parameters<F>) => (reason?: any) => void;

package/schedule.js

@@ -1,9 +1,9 @@
 import { isUndefined, isDefined, counted } from './checks.js';
-import { comp, lazy, bind, apply, call, where, disposing, noop } from './fn.js';
+import { comp, lazy, bind, apply, call, where, swapping, noop, abortable } from './fn.js';
 export const raf = f => bind(cancelAnimationFrame, requestAnimationFrame(f));
-export const timeout = (ms) => f => bind(clearTimeout, setTimeout(f, ms));
+export const timeout = (ms = 0) => 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 idempotent = (s, d) => (f) => swapping()((...xs) => d(s(() => f(...xs))));
 export const debounce = (sched = raf) => {
     let cancel;
     const stop = () => { if (isDefined(cancel))
@@ -23,11 +23,13 @@ export const reset = (sched = raf) => {
         return stop;
     };
 };
-export const repeatedly = (f, sched = raf) => {
+export const repeatedly = (sched = raf) => (f) => {
     let cancel;
-    const g = () => (f(), (cancel = sched(g)));
+    const g = (x) => { if (f(x) !== false)
+        cancel = sched(g); };
     cancel = sched(g);
     return () => cancel();
 };
 export const delayAfter = (delta, n, f) => where(counted(n), f, schedule(reset(timeout(delta)))(f));
-export const micro = (f) => (...xs) => queueMicrotask(() => f(...xs));
+export const micro = (f) => (...xs) => abortable(signal => queueMicrotask(() => { if (!signal.aborted)
+    f(...xs); }));

package/scope.d.ts

@@ -0,0 +1,19 @@
+import type { Fn, FnV, Dispose, AsyncDispose, MaybePromise, Structure } from "./types.js";
+type Result = Dispose | AsyncDispose | void;
+export type Scope<T> = Dispose & {
+    value: T;
+    dispose: Dispose;
+    map<S>(f: Fn<T, S>): Scope<S>;
+    use(f: Fn<T, MaybePromise<Result>>): Scope<T>;
+};
+export declare const scope: <T>(value: T, dispose?: Dispose) => Scope<T>;
+type Unwrapped<T> = T extends Scope<infer U> ? U : {
+    [K in keyof T]: Unwrapped<T[K]>;
+};
+export declare const compose: <R extends Structure<Scope<any>>>(rs: R) => Scope<Unwrapped<R>>;
+export declare const of: <T>(x: T, f: Fn<T, Dispose>) => Scope<T>;
+type Use = <T>(r: Scope<T>) => T;
+export declare const gen: <R>(f: FnV<[Use, Fn<Dispose, Dispose>], R>) => Scope<R>;
+export declare const consume: (f: Fn<Use, Dispose | void>) => Dispose;
+export declare const worker: (w: Worker) => Scope<Worker>;
+export {};

package/scope.js

@@ -0,0 +1,41 @@
+import * as F from "./fn.js";
+import * as Async from "./async.js";
+import { isPromise, isFunction } from "./checks.js";
+import { add } from "./set.js";
+export const scope = (value, dispose = F.noop) => {
+    const s = (() => dispose());
+    s.value = value;
+    s.dispose = dispose;
+    s.map = f => scope(f(value), dispose);
+    s.use = f => {
+        const r = f(value);
+        const d = isPromise(r) ?
+            Async.dispose(r.then(d => F.then(d ?? F.noop, dispose))) :
+            F.then(r ?? F.noop, dispose);
+        return scope(value, d);
+    };
+    return s;
+};
+const iLeaf = (r) => Object.hasOwn(r, "value") && Object.hasOwn(r, "dispose") && isFunction(r["dispose"]);
+export const compose = (rs) => {
+    const disposes = [];
+    const rec = (rs) => {
+        if (iLeaf(rs)) {
+            disposes.push(rs.dispose);
+            return rs.value;
+        }
+        else if (Array.isArray(rs)) {
+            return rs.map(rec);
+        }
+        return Object.fromEntries(Object.entries(rs).map(([k, v]) => [k, rec(v)]));
+    };
+    const value = rec(rs);
+    return scope(value, F.forEach(...disposes));
+};
+export const of = (x, f) => scope(x, f(x));
+export const gen = (f) => {
+    const res = new Set();
+    return scope(f(r => (res.add(r.dispose), r.value), F.bind(add, res)), () => res.forEach(f => f()));
+};
+export const consume = (f) => F.disposable(use => use(f(r => (use(r.dispose), r.value)) ?? F.noop));
+export const worker = (w) => of(w, x => x.terminate.bind(x));

package/string.d.ts

@@ -6,3 +6,4 @@ export declare const objectURL: (data: Uint8Array<ArrayBuffer>, type: 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;
+export declare const came2kebab: (s: string) => string;

package/string.js

@@ -27,3 +27,4 @@ export const readLine = (delims = new Set([0x0A])) => {
     };
 };
 export const DATA_URL = /^data:(?<mime>[\w/\-\+]+)?(;(?<params>[\w\-]+\=[^;,\s]+)*)?(;(?<encoding>base64))?,(?<data>.*)$/;
+export const came2kebab = (s) => s.replace(/[A-Z]/g, m => '-' + m.toLowerCase());

package/types.d.ts

@@ -6,9 +6,6 @@ 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>;
@@ -17,10 +14,11 @@ export type Fns<T> = {
 };
 export type FnF = <F extends FnV>(f: F) => (...xs: Parameters<F>) => ReturnType<F>;
 export type Dispose = Fn<void>;
+export type AsyncDispose = Fn<void, Promise<void>>;
 export type Reactive<T = unknown, R = any> = Fn<Fn<T, R>, Dispose>;
 export type Lazy<T> = () => T;
-export type FirstParam<F extends FnV> = MaybeFirst<Parameters<F>>;
-export type MaybePromise<T = unknown> = T | PromiseLike<T>;
+export type MaybePromise<T = unknown> = T | Promise<T>;
+export type Promisified<T> = T extends Promise<any> ? T : Promise<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];

package/resource.d.ts

@@ -1,15 +0,0 @@
-import type { Fn, Dispose, Structure, Reactive } from "./types.js";
-export type Resource<T> = Reactive<T, Dispose | void> & {
-    value: T;
-    dispose: Dispose;
-    map<S>(f: Fn<T, S>): Resource<S>;
-    flatMap<S>(f: Fn<T, Resource<S>>): Resource<S>;
-    promise(f: Fn<T, Promise<Dispose | void>>): Promise<Dispose>;
-};
-export declare const resource: <T>(value: T, dispose?: Dispose) => Resource<T>;
-export declare const awaited: <T>({ value, dispose }: Resource<Promise<T>>) => Promise<Resource<Awaited<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,34 +0,0 @@
-import { forEach, noop } from "./fn.js";
-import { isFunction } from "./checks.js";
-export const resource = (value, dispose = noop) => {
-    const res = ((f) => forEach(f(value) ?? noop, dispose));
-    res.value = value;
-    res.dispose = dispose;
-    res.map = (f) => resource(f(value), dispose);
-    res.flatMap = (f) => {
-        const res = f(value);
-        return resource(res.value, forEach(res.dispose, dispose));
-    };
-    res.promise = async (f) => forEach((await f(value)) ?? noop, dispose);
-    return res;
-};
-export const awaited = async ({ value, dispose }) => resource(await value, dispose);
-const isResource = (r) => isFunction(r)
-    && Object.hasOwn(r, "value")
-    && Object.hasOwn(r, "dispose")
-    && isFunction(r["dispose"]);
-export const compose = (rs) => {
-    const disposes = [];
-    const rec = (rs) => {
-        if (isResource(rs)) {
-            disposes.push(rs.dispose);
-            return rs.value;
-        }
-        else if (Array.isArray(rs)) {
-            return rs.map(rec);
-        }
-        return Object.fromEntries(Object.entries(rs).map(([k, v]) => [k, rec(v)]));
-    };
-    const value = rec(rs);
-    return resource(value, forEach(...disposes));
-};

package/signal.d.ts

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

package/signal.js

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