@cgtk/std 0.0.193 → 0.0.194

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

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: {

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

package/fn.d.ts

@@ -1,4 +1,4 @@
-import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Constantly, Maybe, Dispose, Reactive } from "./types";
+import type { Fn, FnV, FnF, Pred, TPred, FirstParam, Last, Constantly, 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;

package/fn.js

@@ -1,4 +1,4 @@
-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);

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

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.194",
   "type": "module",
   "main": "./index.js",
   "exports": {
@@ -41,7 +41,7 @@
     "./utils": "./utils.js"
   },
   "devDependencies": {
-    "typescript": "^5.9.3"
+    "typescript": "^6.0.2"
   },
   "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,4 +1,4 @@
-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;

package/resource.js

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

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/src/array.d.ts

@@ -0,0 +1,14 @@
+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[];
+export declare const get: (i: number) => <T>(xs: T[]) => T;
+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 tuple: <T, N extends number>(...xs: T[] & {
+    length: N;
+}) => Tuple<T, N>;
+export declare const seek: <T>(arr: ArrayLike<T>, vals: Set<T | number>, offset?: number) => number;

package/src/array.js

@@ -0,0 +1,21 @@
+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);
+export const get = (i) => (xs) => xs[i];
+export const pop = (xs) => (xs.pop(), xs);
+export const shift = (xs) => (xs.shift(), xs);
+export const first = (xs) => xs[0];
+export const cap = (n, f) => xs => {
+    while (xs.length > n)
+        f(xs);
+    return xs;
+};
+export const retain = (n, xs = []) => comp(scan((push), xs), cap(n, shift));
+export const tuple = (...xs) => xs;
+export const seek = (arr, vals, offset = 0) => {
+    for (let i = offset, n = arr.length; i < n; i++)
+        if (vals.has(arr[i]))
+            return i;
+    return -1;
+};

package/src/assign.d.ts

@@ -0,0 +1,8 @@
+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);
+};
+type Assign<T extends PO, Ts extends PO[]> = Ts extends [infer A extends PO, ...infer R extends PO[]] ? Assign<Merge<T, A>, R> : T;
+export declare const assign: <T extends PO, Ts extends PO[]>(target: T, ...sources: Ts) => Assign<T, Ts>;
+export {};

package/src/assign.js

@@ -0,0 +1,26 @@
+import { isUndefined, isNull } from "./checks.js";
+const isPrimitive = (x) => {
+    const t = typeof x;
+    return t === "string" || t === "number" || t === "boolean";
+};
+function isPlainObject(x) {
+    if (typeof x !== 'object')
+        return false;
+    const prototype = Object.getPrototypeOf(x);
+    return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+const canClone = (x) => isPrimitive(x) || isPlainObject(x) &&
+    Object.values(x).every(x => isUndefined(x) || isNull(x) || isPrimitive(x) || canClone(x));
+const merge = (target, source) => {
+    Object.keys(source).forEach(key => {
+        const s = source[key], t = target[key];
+        if (isPlainObject(t) && isPlainObject(s))
+            target[key] = merge(t, s);
+        else if (canClone(s))
+            target[key] = structuredClone(s);
+        else
+            target[key] = s;
+    });
+    return target;
+};
+export const assign = (target, ...sources) => sources.reduce(merge, target);

package/src/async.d.ts

@@ -0,0 +1,8 @@
+import type { Fn, Constantly, 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 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;

package/src/async.js

@@ -0,0 +1,31 @@
+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);
+    else {
+        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, signal) => async (x) => (await timeout(ms, signal), x);
+export const probing = (p) => {
+    let value = undefined;
+    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 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/src/base64.d.ts

@@ -0,0 +1 @@
+export declare const decodeBytes: (str: string) => Uint8Array<ArrayBuffer>;

package/src/base64.js

@@ -0,0 +1,7 @@
+export const decodeBytes = (str) => {
+    const raw = atob(str), size = raw.length;
+    const res = new Uint8Array(size);
+    for (let i = 0; i < size; i++)
+        res[i] = raw.charCodeAt(i);
+    return res;
+};

package/src/basen.d.ts

@@ -0,0 +1,12 @@
+export type Base<N extends number> = [n: N, m: number, d: number];
+export declare const basen: <B extends number>(b: B) => (m?: number, n?: number) => Base<B>;
+export declare const base10: (m?: number, n?: number) => Base<10>;
+export declare const normalize: <B extends number>(x: Base<B>) => Base<B>;
+export declare const add: <B extends number>([b, m0, n0]: Base<B>, [_, m1, n1]: Base<B>) => Base<B>;
+export declare const mul: <B extends number>([b, m0, n0]: Base<B>, [_, m1, n1]: Base<B>) => Base<B>;
+export declare const addN: <B extends number>(x: Base<B>, a: number) => Base<B>;
+export declare const mulN: <B extends number>(x: Base<B>, a: number) => Base<B>;
+export declare const change: <B extends number, D extends number>([b, m, n]: Base<B>, d: D) => Base<D>;
+export declare const toNumber: <B extends number>([b, m, n]: Base<B>) => number;
+export declare const toString: <B extends number>([b, m, n]: Base<B>, d?: number) => string;
+export declare const toExponential: ([_, m, n]: Base<10>, digits?: number, dMax?: number) => string;

package/src/basen.js

@@ -0,0 +1,31 @@
+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) => {
+    if (!Number.isInteger(x[2])) {
+        const n = Math.floor(x[2]);
+        x[1] *= x[0] ** (x[2] - n);
+        x[2] = n;
+    }
+    const d = x[1] != 0 ? Math.floor(Math.log(Math.abs(x[1])) / Math.log(x[0])) : 0;
+    x[1] /= x[0] ** d;
+    x[2] += d;
+    return x;
+};
+export const add = ([b, m0, n0], [_, m1, n1]) => {
+    const n = Math.max(n0, n1);
+    const m = m0 * b ** (n0 - n) + m1 * b ** (n1 - n);
+    return [b, m, n];
+};
+export const mul = ([b, m0, n0], [_, m1, n1]) => [b, m0 * m1, n0 + n1];
+export const addN = (x, a) => (x[1] += a, normalize(x));
+export const mulN = (x, a) => (x[1] *= a, normalize(x));
+export const change = ([b, m, n], d) => {
+    const k = n * Math.log(b) / Math.log(d);
+    return basen(d)(m, k);
+};
+export const toNumber = ([b, m, n]) => m * b ** n;
+export const toString = ([b, m, n], d = 2) => `${m.toFixed(d)}x${b}^${n}`;
+export const toExponential = ([_, m, n], digits = 2, dMax = 2) => Math.abs(n) <= dMax
+    ? toFixedMax(m * 10 ** n, digits)
+    : `${toFixedMax(m, digits)}e${n.toFixed(0)}`;

package/src/buffer.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/src/buffer.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/src/checks.d.ts

@@ -0,0 +1,29 @@
+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;
+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;
+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>;
+export declare const isString: TPred<string>;
+export declare const isNumber: TPred<number>;
+export declare const isBigInt: TPred<bigint>;
+export declare const isPositive: Pred<number>;
+export declare const isTs: <T>(p: TPred<T>) => TPred<T[]>;
+export declare const isclose: (a: number, b: number, eps?: number) => boolean;
+export declare const allclose: (a: Array<number> | NumberArray, b: Array<number> | NumberArray, eps?: number) => boolean;
+export declare const equal: <T>(a: T, b?: T) => boolean;
+export declare const strictEqual: <T>(a: T, b?: T) => boolean;
+export declare const isDiffPrev: <T>(eq?: (a: T, b?: T | undefined) => boolean) => Pred<T>;
+export declare const isLonger: <T>(delta: number) => Pred<T>;
+export declare const isFunction: <T extends Function>(x: any) => x is T;
+export declare const isAborted: (signal: AbortSignal) => () => boolean;
+export declare const isArrayBufferLike: (x: any) => x is ArrayBufferLike;
+export declare const isArrayBufferView: (x: any) => x is ArrayBufferView;
+export declare const isEmpty: (x: {
+    length: number;
+}) => boolean;
+export declare const counted: (n: number) => () => boolean;

package/src/checks.js

@@ -0,0 +1,44 @@
+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 ||
+    x instanceof Float16Array || x instanceof Float32Array || x instanceof Float64Array ||
+    x instanceof BigUint64Array || x instanceof BigInt64Array);
+export const isNumberArray = (x) => x && (x instanceof Uint8Array || x instanceof Uint8ClampedArray ||
+    x instanceof Uint16Array || x instanceof Uint32Array ||
+    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 isUndefined = (x) => x === undefined;
+export const isNull = (x) => x === null;
+export const isDefined = (x) => !isUndefined(x);
+export function assert(condition, msg) {
+    if (!condition)
+        throw new Error(msg);
+}
+export function assertType(x, pred, msg) { assert(pred(x), msg); }
+export const isObject = (x) => x !== null && typeof x === "object";
+export const isString = (x) => typeof x === "string";
+export const isNumber = (x) => typeof x === 'number';
+export const isBigInt = (x) => typeof x === "bigint";
+export const isPositive = (x) => x > 0;
+export const isTs = (p) => and(Array.isArray, (xs) => xs.every(p));
+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 isFunction = (x) => typeof x === "function";
+export const isAborted = (signal) => () => signal.aborted;
+export const isArrayBufferLike = (x) => x instanceof ArrayBuffer || x instanceof SharedArrayBuffer;
+export const isArrayBufferView = (x) => x != null &&
+    isArrayBufferLike(x.buffer) &&
+    isNumber(x.byteOffset) &&
+    isNumber(x.byteLength);
+export const isEmpty = (x) => x.length == 0;
+export const counted = (n) => {
+    let m = 0;
+    return () => m++ < n;
+};

package/src/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const EMPTY: Readonly<{
+    OBJ: {};
+    STR: "";
+    LIST: never[];
+}>;

package/src/constants.js

@@ -0,0 +1 @@
+export const EMPTY = Object.freeze({ OBJ: {}, STR: "", LIST: [] });