functionalscript 0.2.5 → 0.3.0

package/out/crypto/sha2/module.f.mjs

@@ -1,172 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as array from '../../types/array/module.f.mjs';
-/**
- * @typedef {{
- *  readonly f: (i: number) => number
- *  readonly length: number
- * }} HashInput
- */
-/** @typedef {array.Array8<number>} Hash8 */
-/** @typedef {array.Array16<number>} Array16 */
-/** @type {(input: number) => (pos: number) => number} */
-const appendOneWithZeros = input => pos => (input >> pos << pos) | (1 << pos);
-/** @type {(input: number) => (pos: number) => number} */
-const mod = a => b => (a % b + b) % b;
-/** @type  {(input: readonly number[]) => (bits: number) => HashInput} */
-export const padding = input => bitsCount => {
-    const appendBlockIndex = (bitsCount / 32) | 0;
-    const length = (bitsCount + mod(447 - bitsCount)(512) + 65) / 32;
-    /** @type {(i: number) => number} */
-    const f = i => {
-        if (i < appendBlockIndex) {
-            return input[i];
-        }
-        if (i === appendBlockIndex) {
-            return appendBlockIndex >= input.length ? 0x8000_0000 : appendOneWithZeros(input[appendBlockIndex])(31 - bitsCount % 32);
-        }
-        if (i === length - 2) {
-            return (bitsCount / 0x1_0000_0000) | 0;
-        }
-        if (i === length - 1) {
-            return bitsCount % 0x1_0000_0000;
-        }
-        return 0;
-    };
-    return ({ f, length });
-};
-/** @type {(d: number) => (n: number) => number} */
-const rotr = d => {
-    const r = 32 - d;
-    return n => n >>> d | n << r;
-};
-/** @type {(x: number) => (y: number) => (z: number) => number} */
-const ch = x => y => z => x & y ^ ~x & z;
-/** @type {(x: number) => (y: number) => (z: number) => number} */
-const maj = x => y => z => x & y ^ x & z ^ y & z;
-/** @type {(d: number) => (n: number) => number} */
-const shr = d => n => n >>> d;
-/** @type {(a: number) => (b: number) => (c: number) => (x: number) => number} */
-const bigSigma = a => b => c => {
-    const ra = rotr(a);
-    const rb = rotr(b);
-    const rc = rotr(c);
-    return x => ra(x) ^ rb(x) ^ rc(x);
-};
-const bigSigma0 = bigSigma(2)(13)(22);
-const bigSigma1 = bigSigma(6)(11)(25);
-/** @type {(a: number) => (b: number) => (c: number) => (x: number) => number} */
-const smallSigma = a => b => c => {
-    const ra = rotr(a);
-    const rb = rotr(b);
-    const sc = shr(c);
-    return x => ra(x) ^ rb(x) ^ sc(x);
-};
-const smallSigma0 = smallSigma(7)(18)(3);
-const smallSigma1 = smallSigma(17)(19)(10);
-/** @type {(a: array.Array4<number>) => number} */
-const wi = ([a0, a1, a2, a3]) => (smallSigma1(a0) + a1 + smallSigma0(a2) + a3) | 0;
-/** @type {(w: Array16) => Array16} */
-const nextW = ([w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, wA, wB, wC, wD, wE, wF]) => {
-    w0 = wi([wE, w9, w1, w0]);
-    w1 = wi([wF, wA, w2, w1]);
-    w2 = wi([w0, wB, w3, w2]);
-    w3 = wi([w1, wC, w4, w3]);
-    w4 = wi([w2, wD, w5, w4]);
-    w5 = wi([w3, wE, w6, w5]);
-    w6 = wi([w4, wF, w7, w6]);
-    w7 = wi([w5, w0, w8, w7]);
-    w8 = wi([w6, w1, w9, w8]);
-    w9 = wi([w7, w2, wA, w9]);
-    wA = wi([w8, w3, wB, wA]);
-    wB = wi([w9, w4, wC, wB]);
-    wC = wi([wA, w5, wD, wC]);
-    wD = wi([wB, w6, wE, wD]);
-    wE = wi([wC, w7, wF, wE]);
-    wF = wi([wD, w8, w0, wF]);
-    return [w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, wA, wB, wC, wD, wE, wF];
-};
-const k = [
-    [
-        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-    ],
-    [
-        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-    ],
-    [
-        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-    ],
-    [
-        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
-    ],
-];
-/** @type {(init: Hash8) => (data: Array16) => Hash8} */
-const compress = ([a0, b0, c0, d0, e0, f0, g0, h0]) => data => {
-    let w = data;
-    let a = a0;
-    let b = b0;
-    let c = c0;
-    let d = d0;
-    let e = e0;
-    let f = f0;
-    let g = g0;
-    let h = h0;
-    let i = 0;
-    while (true) {
-        const ki = k[i];
-        for (let j = 0; j < 16; ++j) {
-            const t1 = h + bigSigma1(e) + ch(e)(f)(g) + ki[j] + w[j];
-            const t2 = bigSigma0(a) + maj(a)(b)(c);
-            h = g;
-            g = f;
-            f = e;
-            e = (d + t1) | 0;
-            d = c;
-            c = b;
-            b = a;
-            a = (t1 + t2) | 0;
-        }
-        if (i === 3) {
-            break;
-        }
-        ++i;
-        w = nextW(w);
-    }
-    return [
-        (a0 + a) | 0,
-        (b0 + b) | 0,
-        (c0 + c) | 0,
-        (d0 + d) | 0,
-        (e0 + e) | 0,
-        (f0 + f) | 0,
-        (g0 + g) | 0,
-        (h0 + h) | 0,
-    ];
-};
-/** @type {(init: Hash8) => (input: readonly number[]) => (bitsCount: number) => Hash8} */
-const compute = init => input => bitsCount => {
-    const { f, length } = padding(input)(bitsCount);
-    let result = init;
-    const chunkCount = length / 16;
-    for (let i = 0; i < chunkCount; i++) {
-        const s = i * 16;
-        result = compress(result)([
-            f(s + 0), f(s + 1), f(s + 2), f(s + 3), f(s + 4), f(s + 5), f(s + 6), f(s + 7),
-            f(s + 8), f(s + 9), f(s + 10), f(s + 11), f(s + 12), f(s + 13), f(s + 14), f(s + 15)
-        ]);
-    }
-    return result;
-};
-/** @type {Hash8} */
-const init256 = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
-/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-export const computeSha256 = compute(init256);
-/** @type {Hash8} */
-const init224 = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4];
-/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-export const computeSha224 = compute(init224);
-export const compress256 = compress(init256);
-export const compress224 = compress(init224);

package/out/crypto/sha2/test.f.d.mts

@@ -1,10 +0,0 @@
-declare namespace _default {
-    export namespace empty {
-        function sha256(): void;
-        function sha224(): void;
-    }
-    export let sha224compress: (() => void)[];
-    let sha256_1: (() => void)[];
-    export { sha256_1 as sha256 };
-}
-export default _default;

package/out/crypto/sha2/test.f.mjs

@@ -1,86 +0,0 @@
-import * as _ from './module.f.mjs';
-import * as json from '../../json/module.f.mjs';
-import * as o from '../../types/object/module.f.mjs';
-const { sort } = o;
-/** @type {(a: number) => number} */
-const toU32 = x => (x + 0x1_0000_0000) % 0x1_0000_0000;
-/** @type {(a: number) => string} */
-const toHexString = x => toU32(x).toString(16).padStart(8, '0');
-/** @type {(a: readonly json.Unknown[]) => string} */
-const stringify = a => json.stringify(sort)(a);
-// {
-//     const result = _.padding([])(0)
-//     console.log(result.map(toHexString))
-// }
-// {
-//     const result = _.padding([0x61626364, 0x65000000])(40)
-//     console.log(result.map(toHexString))
-// }
-// {
-//     const result = _.padding([0x11111110])(31)
-//     console.log(result.map(toHexString))
-// }
-// {
-//     const result = _.padding([0x11111110])(32)
-//     console.log(result.map(toHexString))
-// }
-export default {
-    empty: {
-        sha256: () => {
-            const hash = _.computeSha256([])(0);
-            const result = stringify(hash.map(toHexString));
-            if (result !== '["e3b0c442","98fc1c14","9afbf4c8","996fb924","27ae41e4","649b934c","a495991b","7852b855"]') {
-                throw result;
-            }
-        },
-        sha224: () => {
-            const hash = _.computeSha224([])(0);
-            const result = stringify(hash.map(toHexString));
-            if (result !== '["d14a028c","2a3a2bc9","476102bb","288234c4","15a2b01f","828ea62a","c5b3e42f","bdd387cb"]') {
-                throw result;
-            }
-        }
-    },
-    sha224compress: [
-        () => {
-            const hash = _.compress224([0x8000_0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
-            const result = stringify(hash.map(toHexString));
-            if (result !== '["d14a028c","2a3a2bc9","476102bb","288234c4","15a2b01f","828ea62a","c5b3e42f","bdd387cb"]') {
-                throw result;
-            }
-        }
-    ],
-    sha256: [
-        () => {
-            //[0x68656C6C, 0x6F20776F, 0x726C6400] represents phrase 'hello world'
-            const hash = _.computeSha256([0x68656C6C, 0x6F20776F, 0x726C6400])(88);
-            const result = stringify(hash.map(toHexString));
-            if (result !== '["b94d27b9","934d3e08","a52e52d7","da7dabfa","c484efe3","7a5380ee","9088f7ac","e2efcde9"]') {
-                throw result;
-            }
-        },
-        () => {
-            //[0x68656C6C, 0x6F20776F, 0x726C6488] represents phrase 'hello world' with 1's at the end
-            const hash = _.computeSha256([0x68656C6C, 0x6F20776F, 0x726C64FF])(88);
-            const result = stringify(hash.map(toHexString));
-            if (result !== '["b94d27b9","934d3e08","a52e52d7","da7dabfa","c484efe3","7a5380ee","9088f7ac","e2efcde9"]') {
-                throw result;
-            }
-        },
-        () => {
-            const input = Array(8).fill(0x31313131);
-            const result = _.computeSha256(input)(256);
-            if (toU32(result[0]) !== 0x8a83665f) {
-                throw result[0];
-            }
-        },
-        () => {
-            const input = Array(16).fill(0x31313131);
-            const hash = _.computeSha256(input)(512);
-            const result = stringify(hash.map(toHexString));
-            if (result !== '["3138bb9b","c78df27c","473ecfd1","410f7bd4","5ebac1f5","9cf3ff9c","fe4db77a","ab7aedd3"]') {
-                throw result;
-            }
-        }
-    ]
-};

package/out/dev/index.d.mts

@@ -1 +0,0 @@
-export {};

package/out/dev/index.mjs

@@ -1,2 +0,0 @@
-import { index } from "./module.mjs";
-index();

package/out/dev/module.d.mts

@@ -1,26 +0,0 @@
-/** @type {(code: number) => never} */
-export const exit: (code: number) => never;
-/** @type {(v: string) => string|undefined} */
-export const env: (v: string) => string | undefined;
-export function loadModuleMap(): Promise<ModuleMap>;
-export function index(): Promise<void>;
-export type Options = {
-    readonly withFileTypes: true;
-};
-export type Dirent = {
-    readonly name: string;
-    readonly isDirectory: () => boolean;
-};
-export type FsPromises = {
-    readonly readdir: (path: string, options: Options) => Promise<readonly Dirent[]>;
-    readonly readFile: (path: string, options: "utf8") => Promise<string>;
-};
-export type Module = {
-    readonly default?: unknown;
-};
-export type Require = (name: string) => unknown;
-export type UnknownMap = { readonly [k in string]: unknown; };
-export type Entry<T> = readonly [string, T];
-export type MutableModuleMap = { [k in string]: Module; };
-export type ModuleMap = { readonly [k in string]: Module; };
-export type FolderMap = { readonly [k in string]: string | FolderMap; };

package/out/dev/module.f.d.mts

@@ -1 +0,0 @@
-export function todo(): never;

package/out/dev/module.f.mjs

@@ -1,2 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-export const todo = () => { throw 'not implemented'; };

package/out/dev/module.mjs

@@ -1,167 +0,0 @@
-import { readdir, writeFile, readFile } from 'node:fs/promises';
-/**
- * @typedef {{
- *  readonly withFileTypes: true
- * }} Options
- */
-/**
- * @typedef {{
- *  readonly name: string
- *  readonly isDirectory: () => boolean
- * }} Dirent
- */
-/**
- * @typedef {{
- *  readonly readdir: (path: string, options: Options) => Promise<readonly Dirent[]>
- *  readonly readFile: (path: string, options: 'utf8') => Promise<string>
- * }} FsPromises
- */
-/**
- * @typedef {{
- *  readonly default?: unknown
- * }} Module
- */
-/** @typedef {(name: string) => unknown} Require */
-/**
- * @typedef {{
- *  readonly[k in string]: unknown
- * }} UnknownMap
- */
-/**
- * @template T
- * @typedef {readonly[string, T]} Entry
- */
-/** @type {(a: Entry<unknown>, b: Entry<unknown>) => number} */
-const cmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0;
-/**
- * @typedef {{
- *  [k in string]: Module
- * }} MutableModuleMap
- */
-/**
- * @typedef {{
- *  readonly[k in string]: Module
- * }} ModuleMap
- */
-/** @type {(v: readonly string[]) => (dif: number) => readonly string[]} */
-const remove_tail = v => dif => v.slice(0, v.length - dif);
-/** @type {any} */
-const self = globalThis;
-/** @type {(code: number) => never} */
-export const exit = self.Deno ? self.Deno.exit : process.exit;
-/** @type {(v: string) => string|undefined} */
-export const env = self.Deno ? self.Deno.env.get :
-    a => {
-        const r = Object.getOwnPropertyDescriptor(process.env, a);
-        return r === void 0 ? void 0 :
-            typeof r.get === 'function' ? r.get() :
-                r.value;
-    };
-export const loadModuleMap = async () => {
-    /** @type {() => Promise<UnknownMap>} */
-    const load = async () => {
-        /** @type {(readonly[string, unknown])[]} */
-        const map = [];
-        /** @type {(path: string) => Promise<void>} */
-        const f = async (p) => {
-            for (const i of await readdir(p, { withFileTypes: true })) {
-                const { name } = i;
-                if (!name.startsWith('.')) {
-                    const file = `${p}/${name}`;
-                    if (i.isDirectory()) {
-                        await f(file);
-                    }
-                    else if (name.endsWith('.f.mjs') || name.endsWith('.f.js')) {
-                        const source = await import(`../${file}`);
-                        map.push([file, source.default]);
-                    }
-                }
-            }
-        };
-        await f('.');
-        map.sort(cmp);
-        return Object.fromEntries(map);
-    };
-    const map = await load();
-    /** @type {() => ModuleMap} */
-    const build = () => {
-        /** @type {MutableModuleMap} */
-        const d = {};
-        /** @type {(base: readonly string[]) => (k: string) => readonly[string, Module]} */
-        const getModule = base => k => {
-            const relativePath = k.split('/');
-            const dif = relativePath.filter(v => v === '..').length;
-            const path = [remove_tail(base)(dif), relativePath.filter(v => !['..', '.'].includes(v))]
-                .flat();
-            const pathStr = path.join('/');
-            {
-                const module = d[pathStr];
-                if (module !== void 0) {
-                    return [pathStr, module];
-                }
-            }
-            {
-                /** @type {Module} */
-                const module = { default: map[pathStr] };
-                d[pathStr] = module;
-                return [pathStr, module];
-            }
-        };
-        {
-            const get = getModule(['.']);
-            for (const k of Object.keys(map)) {
-                get(k);
-            }
-        }
-        return d;
-    };
-    return build();
-};
-/**
- * @typedef {{
- *  readonly[k in string]: string | FolderMap
- * }} FolderMap
- */
-/** @type {(m: FolderMap) => (s: readonly string[]) => FolderMap } */
-const folderMapAdd = m => s => {
-    const [first, ...rest] = s;
-    const firstResult = m[first];
-    return typeof firstResult === 'string'
-        ? m
-        : {
-            ...m,
-            [first]: rest.length === 1
-                ? rest[0]
-                : folderMapAdd(firstResult === undefined ? {} : firstResult)(rest)
-        };
-};
-const indent = '  ';
-/** @type {(i: string) => (p: string) => (m: FolderMap) => readonly[string,string]} */
-const codeAdd = i => p => m => {
-    let result = '';
-    let im = '';
-    for (const [k, v] of Object.entries(m)) {
-        const np = `${p}${k}`;
-        if (typeof v === 'string') {
-            result += `${i}${k}: ${np},\n`;
-            im += `import ${np} from './${np.replaceAll('$', '/')}/${v}'\n`;
-        }
-        else {
-            const [r, x] = codeAdd(i + indent)(`${np}\$`)(v);
-            result += `${i}${k}: \{\n`;
-            result += r;
-            result += `${i}\},\n`;
-            im += x;
-        }
-    }
-    return [result, im];
-};
-export const index = async () => {
-    const jj = './jsr.json';
-    const n = '/module.f.mjs';
-    const jsr_json = JSON.parse(await readFile(jj, { encoding: 'utf8' }));
-    const list = Object.keys(await loadModuleMap()).filter(v => v.endsWith(n));
-    const exportsA = list.filter(v => !v.startsWith('./out')).map(v => [v.replace(n, ''), `./out/${v.substring(2)}`]);
-    const exports = Object.fromEntries(exportsA);
-    await writeFile(jj, JSON.stringify({ ...jsr_json, exports }, null, 2));
-};

package/out/dev/test/module.f.d.mts

@@ -1,25 +0,0 @@
-declare const _default: <T>(input: Input<T>) => readonly [number, T];
-export default _default;
-export type DependencyMap = { readonly [k in string]?: Module; };
-export type Module = {
-    readonly default?: unknown;
-};
-export type ModuleMap = { readonly [k in string]: Module; };
-export type Log<T> = (v: string) => (state: T) => T;
-export type Measure<T> = <R>(f: () => R) => (state: T) => readonly [R, number, T];
-export type Input<T> = {
-    readonly moduleMap: ModuleMap;
-    readonly log: Log<T>;
-    readonly error: Log<T>;
-    readonly measure: Measure<T>;
-    readonly state: T;
-    readonly tryCatch: <R>(f: () => R) => Result.Result<R, unknown>;
-    readonly env: (n: string) => string | undefined;
-};
-export type TestState = {
-    readonly time: number;
-    readonly pass: number;
-    readonly fail: number;
-};
-export type FullState<T> = readonly [TestState, T];
-import * as Result from '../../types/result/module.f.mjs';

package/out/dev/test/module.f.mjs

@@ -1,134 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as list from '../../types/list/module.f.mjs';
-const { fold } = list;
-import * as sgr from '../../text/sgr/module.f.mjs';
-const { reset, fgGreen, fgRed, bold } = sgr.codes;
-import * as Result from '../../types/result/module.f.mjs';
-/**
- * @typedef {{
- *  readonly[k in string]?: Module
- * }} DependencyMap
- */
-/**
- * @typedef {{
- *  readonly default?: unknown
- * }} Module
- */
-/**
- * @typedef {{
- *  readonly[k in string]: Module
- * }} ModuleMap
- */
-/**
- * @template T
- * @typedef {(v: string) => (state: T) => T} Log
- */
-/**
- * @template T
- * @typedef {<R>(f: () => R) => (state: T) => readonly[R, number, T]} Measure
- */
-/**
- * @template T
- * @typedef {{
- *  readonly moduleMap: ModuleMap,
- *  readonly log: Log<T>,
- *  readonly error: Log<T>,
- *  readonly measure: Measure<T>,
- *  readonly state: T,
- *  readonly tryCatch: <R>(f: () => R) => Result.Result<R, unknown>,
- *  readonly env: (n: string) => string|undefined
- * }} Input
- */
-/** @type {(s: string) => boolean} */
-const isTest = s => s.endsWith('test.f.mjs') || s.endsWith('test.f.js');
-/**
- * @typedef {{
- *  readonly time: number,
- *  readonly pass: number,
- *  readonly fail: number,
- * }} TestState
- */
-/** @type {(time: number) => (testState: TestState) => TestState} */
-const addPass = delta => ts => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });
-/** @type {(time: number) => (testState: TestState) => TestState} */
-const addFail = delta => ts => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 });
-/**
- * @template T
- * @typedef {readonly[TestState, T]} FullState
- */
-/** @type {(a: number) => string} */
-const timeFormat = a => {
-    const y = Math.round(a * 10_000).toString();
-    const yl = 5 - y.length;
-    const x = '0'.repeat(yl > 0 ? yl : 0) + y;
-    const s = x.length - 4;
-    const b = x.substring(0, s);
-    const e = x.substring(s);
-    return `${b}.${e} ms`;
-};
-/** @type {<T>(input: Input<T>) => readonly[number, T]} */
-export default input => {
-    let { moduleMap, log, error, measure, tryCatch, env, state } = input;
-    const isGitHub = env('GITHUB_ACTION') !== void 0;
-    /** @typedef {input extends Input<infer T> ? T : never} T */
-    /** @type {(k: readonly[string, Module]) => (fs: FullState<T>) => FullState<T>} */
-    const f = ([k, v]) => {
-        /** @type {(i: string) => (v: unknown) => (fs: FullState<T>) => FullState<T>} */
-        const test = i => v => ([ts, state]) => {
-            const next = test(`${i}| `);
-            switch (typeof v) {
-                case 'function': {
-                    if (v.length === 0) {
-                        const [[s, r], delta, state0] = measure(() => tryCatch(/** @type {() => unknown} */ (v)))(state);
-                        state = state0;
-                        if (s === 'error') {
-                            ts = addFail(delta)(ts);
-                            if (isGitHub) {
-                                // https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
-                                // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
-                                state = error(`::error file=${k},line=1,title=[3]['a']()::${r}`)(state);
-                            }
-                            else {
-                                state = error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`)(state);
-                                state = error(`${fgRed}${r}${reset}`)(state);
-                            }
-                        }
-                        else {
-                            ts = addPass(delta)(ts);
-                            state = log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`)(state);
-                        }
-                        [ts, state] = next(r)([ts, state]);
-                    }
-                    break;
-                }
-                case 'object': {
-                    if (v !== null) {
-                        /** @type {(k: readonly[string|number, unknown]) => (fs: FullState<T>) => FullState<T>} */
-                        const f = ([k, v]) => ([time, state]) => {
-                            state = log(`${i}${k}:`)(state);
-                            [time, state] = next(v)([time, state]);
-                            return [time, state];
-                        };
-                        [ts, state] = fold(f)([ts, state])(v instanceof Array ? list.entries(v) : Object.entries(v));
-                    }
-                    break;
-                }
-            }
-            return [ts, state];
-        };
-        return ([ts, state]) => {
-            if (isTest(k)) {
-                state = log(`testing ${k}`)(state);
-                [ts, state] = test('| ')(v.default)([ts, state]);
-            }
-            return [ts, state];
-        };
-    };
-    /** @type {TestState} */
-    let ts = { time: 0, pass: 0, fail: 0 };
-    [ts, state] = fold(f)([ts, state])(Object.entries(moduleMap));
-    const fgFail = ts.fail === 0 ? fgGreen : fgRed;
-    state = log(`${bold}Number of tests: pass: ${fgGreen}${ts.pass}${reset}${bold}, fail: ${fgFail}${ts.fail}${reset}${bold}, total: ${ts.pass + ts.fail}${reset}`)(state);
-    state = log(`${bold}Time: ${timeFormat(ts.time)}${reset}`)(state);
-    return [ts.fail !== 0 ? 1 : 0, state];
-};

package/out/dev/test.d.mts

@@ -1,3 +0,0 @@
-export type Ok<T> = readonly ["ok", T];
-export type Error<E> = readonly ["error", E];
-export type Result<T, E> = Ok<T> | Error<E>;

package/out/dev/test.f.d.mts

@@ -1,9 +0,0 @@
-declare namespace _default {
-    function ctor(): void;
-    function ctorEmpty(): void;
-    function ctorUndefined(): void;
-    function number(): void;
-    function properties(): void;
-    function getOwnPropertyDescriptor(): void;
-}
-export default _default;