@cgtk/std 0.0.193 → 0.0.195

package/array.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, Tuple } from "./types";
+import type { Fn, Tuple } from "./types.js";
 export declare const empty: <T>() => T[];
 export declare const push: <T>(xs: T[], x: T) => T[];
 export declare const unshift: <T>(xs: T[], x: T) => T[];

package/array.js

@@ -1,4 +1,4 @@
-import { comp, scan } from "./fn";
+import { comp, scan } from "./fn.js";
 export const empty = () => [];
 export const push = (xs, x) => (xs.push(x), xs);
 export const unshift = (xs, x) => (xs.unshift(x), xs);

package/assign.d.ts

@@ -1,4 +1,4 @@
-import type { RecordOf } from "./types";
+import type { RecordOf } from "./types.js";
 type PO = RecordOf<unknown>;
 type Merge<T extends PO, S extends PO> = {
     [K in keyof (T & S)]: K extends keyof S ? (K extends keyof T ? (S[K] extends PO ? (T[K] extends PO ? Merge<T[K], S[K]> : S[K]) : S[K]) : S[K]) : (K extends keyof T ? T[K] : never);

package/assign.js

@@ -1,4 +1,4 @@
-import { isUndefined, isNull } from "./checks";
+import { isUndefined, isNull } from "./checks.js";
 const isPrimitive = (x) => {
     const t = typeof x;
     return t === "string" || t === "number" || t === "boolean";

package/async.d.ts

@@ -1,7 +1,7 @@
-import type { Fn, Constantly, Maybe, Dispose, MaybePromise } from "./types";
+import type { Fn, Lazy, Maybe, Dispose, MaybePromise } from "./types.js";
 export declare const timeout: (ms: number, signal?: AbortSignal) => Promise<unknown>;
 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 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>;

package/async.js

@@ -1,5 +1,5 @@
-import { filterT, disposable } from "./fn";
-import { isDefined } from "./checks";
+import { filterT, disposable } from "./fn.js";
+import { isDefined } from "./checks.js";
 export const timeout = (ms, signal) => new Promise((resolve, reject) => {
     if (signal?.aborted)
         reject(signal.reason);

package/basen.js

@@ -1,4 +1,4 @@
-import { toFixedMax } from "./number";
+import { toFixedMax } from "./number.js";
 export const basen = (b) => (m = 0, n = 0) => [b, m, n];
 export const base10 = basen(10);
 export const normalize = (x) => {

package/buffer.d.ts

@@ -1,4 +1,4 @@
-import type { Fn } from "./types";
+import type { Fn } from "./types.js";
 export interface BufReader {
     offset: number;
     line: Fn<void, string>;

package/buffer.js

@@ -1,4 +1,4 @@
-import { readLine } from './string';
+import { readLine } from './string.js';
 export const bufReader = (data, offset = 0) => {
     const rl = readLine();
     const dv = new DataView(data.buffer, data.byteOffset);

package/checks.d.ts

@@ -1,4 +1,4 @@
-import type { TypedArray, NumberArray, BigIntArray, Pred, TPred, Maybe } from "./types";
+import type { TypedArray, NumberArray, BigIntArray, Pred, TPred, Maybe } from "./types.js";
 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;

package/checks.js

@@ -1,5 +1,5 @@
-import { comp, not, apply, and } from "./fn";
-import { retain } from "./array";
+import { comp, not, apply, and } from "./fn.js";
+import { retain } 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 ||

package/dom.d.ts

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

package/dom.js

@@ -1,6 +1,6 @@
-import { forEach, noop } from "./fn";
-import { isDefined } from "./checks";
-import { EMPTY } from "./constants";
+import { forEach, noop } from "./fn.js";
+import { isDefined } 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);
@@ -34,3 +34,8 @@ export const pushState = (path, query, data) => history.pushState(data, EMPTY.ST
 export const qs = (search = location.search) => search.length > 0
     ? Object.fromEntries(new URLSearchParams(search).entries())
     : undefined;
+export const imageData = (img) => {
+    const ctx = new OffscreenCanvas(img.width, img.height).getContext("2d");
+    ctx.drawImage(img, 0, 0);
+    return ctx.getImageData(0, 0, img.width, img.height);
+};

package/fn.d.ts

@@ -1,16 +1,16 @@
-import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Constantly, Maybe, Dispose, Reactive } from "./types";
+import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Lazy, Maybe, Dispose, Reactive } 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 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, R>(...fs: Fn<T, R>[]) => (x: T) => R[];
+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) => Constantly<T>;
+export declare const constantly: <T>(x: T) => Lazy<T>;
 export declare const apply: <F extends FnV>(f: F) => (x: Parameters<F>) => ReturnType<F>;
 export declare const call: <T extends unknown[]>(f: Fn<T>) => (...xs: T) => ReturnType<typeof f>;
 export declare const bind: <A extends unknown[], B extends unknown[], R>(f: (...args: [...A, ...B]) => R, ...args: A) => (...args: B) => R;
@@ -18,7 +18,6 @@ export declare const lazy: <F extends FnV>(f: F, ...xs: Parameters<F>) => Fn<voi
 export declare const where: <T, U, V>(p: Pred<T>, f: Fn<T, U>, g: Fn<T, V>) => (x: T) => U | 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 mapForEach: <T, R>(...fs: Fn<T, Fn<R>>[]) => (x: T) => (x: R) => void;
 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>;

package/fn.js

@@ -1,9 +1,9 @@
-import { add } from "./set";
+import { add } from "./set.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 = (...fs) => (x) => fs.map(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);
@@ -22,7 +22,6 @@ export const after = (f) => g => (...xs) => {
     f();
     return r;
 };
-export const mapForEach = (...fs) => comp(map(...fs), apply((forEach)));
 export const filter = (p, f) => (x) => { if (p(x))
     f(x); };
 export const filterT = (p, f) => (x) => { if (p(x))

package/http.js

@@ -1,5 +1,5 @@
-import { tee } from "./fn";
-import { assert } from "./checks";
+import { tee } from "./fn.js";
+import { assert } from "./checks.js";
 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");

package/iterable.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, FnV, Indexed, Pred } from "./types";
+import type { Fn, FnV, Indexed, Pred } from "./types.js";
 export declare const next: <T>(xs: Iterator<T>) => T;
 export declare const repeat: (n: number) => <A>(x: A) => Iterator<A>;
 export declare const just: <T>(x: T) => IteratorObject<T>;

package/iterable.js

@@ -1,6 +1,6 @@
-import { assert, isDefined } from "./checks";
-import { pipe, comp, scan, apply, noop, identity, constantly } from "./fn";
-import { set } from "./map";
+import { assert, isDefined } from "./checks.js";
+import { pipe, comp, scan, apply, noop, identity, constantly } from "./fn.js";
+import { set } from "./map.js";
 export const next = (xs) => {
     const { done, value } = xs.next();
     assert(isDefined(done) && !done, "iterator done");

package/map.d.ts

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

package/map.js

@@ -1,5 +1,5 @@
-import { isDefined } from "./checks";
-import * as I from "./iterable";
+import { isDefined } from "./checks.js";
+import * as I from "./iterable.js";
 export const transform = ({ create, update, remove }, dst = new Map()) => (src) => {
     for (const k of dst.keys())
         if (!src.has(k)) {

package/math.d.ts

@@ -32,3 +32,4 @@ export declare const zoom: (x: number, s: number, p: number) => number;
 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;

package/math.js

@@ -1,4 +1,4 @@
-import { isclose } from "./checks";
+import { isclose } from "./checks.js";
 export const PI = Math.PI;
 export const TAU = PI * 2;
 export const HALF_PI = PI / 2;
@@ -41,3 +41,4 @@ export const zoom = (x, s, p) => (x - p) * s + p;
 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);

package/npy.d.ts

@@ -1,4 +1,4 @@
-import type { TypedArray, Elements } from "./types";
+import type { TypedArray, Elements } from "./types.js";
 declare const DTYPES: readonly ["|u1", "<u2", "<u4", "|i1", "<i2", "<i4", "<f4", "<f8"];
 type DType = Elements<typeof DTYPES>;
 export interface NDArray {

package/number.js

@@ -1,4 +1,4 @@
-import { isBigInt } from "./checks";
+import { isBigInt } from "./checks.js";
 export const add = (a, x) => a + x;
 export const toFixed = (x, n = 0) => isBigInt(x) ? x : x.toFixed(n);
 export const toFixedMax = (x, n = 0) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cgtk/std",
-  "version": "0.0.193",
+  "version": "0.0.195",
   "type": "module",
   "main": "./index.js",
   "exports": {
@@ -40,9 +40,6 @@
     "./resource": "./resource.js",
     "./utils": "./utils.js"
   },
-  "devDependencies": {
-    "typescript": "^5.9.3"
-  },
   "publishConfig": {
     "access": "public"
   }

package/port.d.ts

@@ -1,4 +1,4 @@
-import type { Dispose, Fn, Fns, FnV, RecordOf, MaybePromise, Reactive } from "./types";
+import type { Dispose, Fn, Fns, FnV, RecordOf, MaybePromise, Reactive } from "./types.js";
 export interface Message<K, V> {
     type: K;
     payload: V;

package/port.js

@@ -1,7 +1,7 @@
-import { forEach, noop, bind } from "./fn";
-import { isDefined } from "./checks";
-import { on } from "./dom";
-import { promise } from "./async";
+import { forEach, noop, bind } from "./fn.js";
+import { isDefined } from "./checks.js";
+import { on } from "./dom.js";
+import { promise } from "./async.js";
 ;
 export const onMessages = (target, fs) => on(target, "message", ({ data: { type, payload } }) => (type in fs) && fs[type](payload));
 export const onMessage = (target, name, f) => on(target, "message", ({ data: { type, payload } }) => type == name && f(payload));

package/progress.d.ts

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

package/rect.d.ts

@@ -1,4 +1,4 @@
-import type { Tuple } from "./types";
+import type { Tuple } from "./types.js";
 export type Rect = Tuple<number, 4>;
 export declare const rect: (x: number, y: number, w: number, h: number) => Rect;
 export declare const vertical: (ratio: number[]) => (i: number) => ([x, _, w, h]: Rect) => Rect;

package/rect.js

@@ -1,4 +1,4 @@
-import { add } from "./number";
+import { add } from "./number.js";
 export const rect = (x, y, w, h) => [x, y, w, h];
 export const vertical = (ratio) => {
     const tot = ratio.reduce(add, 0);

package/resource.d.ts

@@ -1,10 +1,13 @@
-import type { Fn, Dispose, Structure, Reactive } from "./types";
+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]>;
 };

package/resource.js

@@ -1,12 +1,18 @@
-import { forEach, noop } from "./fn";
-import { isFunction } from "./checks";
+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")

package/schedule.d.ts

@@ -1,4 +1,4 @@
-import type { Dispose, Fn, FnV, Reactive } from './types';
+import type { Dispose, Fn, FnV, Reactive } from './types.js';
 export declare const raf: Reactive<number>;
 export declare const timeout: (ms: number) => Reactive<void>;
 export declare const schedule: <T>(s: Reactive<T>) => <F extends FnV>(f: F) => FnV<Parameters<F>, Dispose>;

package/schedule.js

@@ -1,5 +1,5 @@
-import { isUndefined, isDefined, counted } from './checks';
-import { comp, lazy, bind, apply, call, where, disposing, noop } from './fn';
+import { isUndefined, isDefined, counted } from './checks.js';
+import { comp, lazy, bind, apply, call, where, disposing, noop } from './fn.js';
 export const raf = f => bind(cancelAnimationFrame, requestAnimationFrame(f));
 export const timeout = (ms) => f => bind(clearTimeout, setTimeout(f, ms));
 export const schedule = (s) => (f) => call(comp(apply(bind((lazy), f)), s));

package/signal.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, FnV, Fns, Pred, Reactive, RecordOf, Structure } from "./types";
+import type { Fn, FnV, Fns, Pred, Reactive, RecordOf, Structure } from "./types.js";
 export type Signal<T> = Fn<T> & {
     on: Reactive<T>;
 };

package/signal.js

@@ -1,7 +1,7 @@
-import { after, constantly, noop, bind, comp, forEach, filter as filter_, identity } from "./fn";
-import { mapValues } from "./object";
-import { isDefined, isFunction } from "./checks";
-import { add } from "./set";
+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;

package/stream.d.ts

@@ -1,4 +1,4 @@
-import type { Fn } from "./types";
+import type { Fn } from "./types.js";
 export declare const readable: <T>(x: T) => ReadableStream<any>;
 export declare function iterate<T>(rs: ReadableStream<T>): AsyncGenerator<Awaited<T>, void, unknown>;
 export declare const map: <T, S>(f: Fn<T, S>) => TransformStream<T, S>;

package/stream.js

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

package/string.d.ts

@@ -1,4 +1,4 @@
-import type { Tuple } from "./types";
+import type { Tuple } from "./types.js";
 export declare const basename: (path: string) => string;
 export declare const dirname: (path: string) => string;
 export declare const splitext: (path: string) => Tuple<string, 2>;

package/string.js

@@ -1,5 +1,5 @@
-import { EMPTY } from "./constants";
-import { seek } from "./array";
+import { EMPTY } from "./constants.js";
+import { seek } from "./array.js";
 export const basename = (path) => path.split("/").at(-1) ?? "";
 export const dirname = (path) => {
     const parts = path.split("/");

package/struct.d.ts

@@ -1,5 +1,5 @@
-import type { TypedArray, Fn, NumberArray } from "./types";
-import type { Constructor } from "./typedarray";
+import type { TypedArray, Fn, NumberArray } from "./types.js";
+import type { Constructor } from "./typedarray.js";
 export interface Type {
     size: number;
     align: number;

package/struct.js

@@ -1,5 +1,5 @@
-import { align as _align } from "./math";
-import { isBigIntArray, isNumberArray } from "./checks";
+import { align as _align } from "./math.js";
+import { isBigIntArray, isNumberArray } from "./checks.js";
 const vec = (type) => (length = 1, align = type.BYTES_PER_ELEMENT) => ({
     type, align, length, size: type.BYTES_PER_ELEMENT * length,
 });

package/tree.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, FnV, TPred, PredV } from './types';
+import type { Fn, FnV, TPred, PredV } from './types.js';
 export type Node<S, T = S> = T | Tree<S, T>;
 export type Tree<S, T = S> = [S, Node<S, T>[]];
 export declare const tree: <S, T = S>(value: S, children?: Node<S, T>[]) => Tree<S, T>;

package/tree.js

@@ -1,6 +1,6 @@
-import { identity } from './fn';
-import { EMPTY } from './constants';
-import { zip as zipI } from './iterable';
+import { identity } from './fn.js';
+import { EMPTY } from './constants.js';
+import { zip as zipI } from './iterable.js';
 export const tree = (value, children = []) => [value, children];
 export const isTree = (x) => Array.isArray(x) && x.length == 2 && Array.isArray(x[1]);
 export const children = (x, p = isTree) => p(x) ? x[1] : EMPTY.LIST;

package/treemap.d.ts

@@ -1,4 +1,4 @@
-import type { Maybe } from "./types";
+import type { Maybe } from "./types.js";
 export interface Treemap<T = number> {
     set(node: T, parent?: T): Treemap<T>;
     delete(key: T): void;

package/treemap.js

@@ -1,6 +1,6 @@
-import { before } from "./fn";
-import { isDefined } from "./checks";
-import { EMPTY } from "./constants";
+import { before } from "./fn.js";
+import { isDefined } from "./checks.js";
+import { EMPTY } from "./constants.js";
 export const treemap = () => {
     const nodes = new Set();
     const parents = new Map();

package/typedarray.d.ts

@@ -1,4 +1,4 @@
-import type { FnV, TypedArray, NumberArray, BufferType, Number } from "./types";
+import type { FnV, TypedArray, NumberArray, BufferType, Number } from "./types.js";
 export interface Constructor<T extends TypedArray> {
     new (length: number): T;
     new (buffer: BufferType<T> | ArrayBufferLike, byteOffset?: number, length?: number): T;

package/typedarray.js

@@ -1,6 +1,6 @@
-import { bind } from "./fn";
-import { zmap, map as mapI, reduce } from "./iterable";
-import { push } from "./array";
+import { bind } from "./fn.js";
+import { zmap, map as mapI, reduce } from "./iterable.js";
+import { push } from "./array.js";
 export const view = (type, length) => (buf = new ArrayBuffer(type.BYTES_PER_ELEMENT * length), offset = 0) => new type(buf, offset, length);
 export const u8 = bind((view), Uint8Array);
 export const u16 = bind((view), Uint16Array);

package/types.d.ts

@@ -18,7 +18,7 @@ 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 Constantly<T> = () => T;
+export type Lazy<T> = () => T;
 export type FirstParam<F extends FnV> = MaybeFirst<Parameters<F>>;
 export type MaybePromise<T = unknown> = T | PromiseLike<T>;
 export type Last<T extends any[]> = T extends [...any, infer Rest] ? Rest : never;
@@ -39,7 +39,7 @@ export type Entries<T> = {
 export type EntriesTuple<T, K extends UnionToTuple<keyof T> = UnionToTuple<keyof T>> = {
     [I in keyof K]: K[I] extends keyof T ? [K[I], T[K[I]]] : never;
 };
-export type UintArray<T extends ArrayBufferLike = ArrayBufferLike> = Uint8Array<T> | Uint16Array<T> | Uint32Array<T>;
+export type UintArray<T extends ArrayBufferLike = ArrayBufferLike> = Uint8Array<T> | Uint8ClampedArray<T> | Uint16Array<T> | Uint32Array<T>;
 export type IntArray<T extends ArrayBufferLike = ArrayBufferLike> = Int8Array<T> | Int16Array<T> | Int32Array<T>;
 export type FloatArray<T extends ArrayBufferLike = ArrayBufferLike> = Float16Array<T> | Float32Array<T> | Float64Array<T>;
 export type BigIntArray<T extends ArrayBufferLike = ArrayBufferLike> = BigUint64Array<T> | BigInt64Array<T>;

package/utils.d.ts

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

package/utils.js

@@ -1,4 +1,4 @@
-import { assert } from "./checks";
+import { assert } from "./checks.js";
 export function* toposort(nodes) {
     const n = nodes.length;
     const queue = [], children = new Map();

package/weak.d.ts

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

package/weak.js

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