functionalscript 0.3.3 → 0.3.5

package/crypto/secp/module.f.js

@@ -0,0 +1,127 @@
+import * as Operator from "../../types/function/operator/module.f.js";
+import { prime_field, sqrt } from "../prime_field/module.f.js";
+import { scalar_mul } from "../../types/bigint/module.f.js";
+/**
+ * Constructs an elliptic curve with the given initialization parameters.
+ *
+ * @example
+ *
+ * ```js
+ * const curveParams = {
+ *     p: 23n,
+ *     a: [0n, 1n],
+ *     g: [1n, 1n],
+ *     n: 19n
+ * };
+ * const curveInstance = curve(curveParams);
+ *
+ * // Access curve operations
+ * const point = curveInstance.add([1n, 1n])([2n, 5n]); // Add two points
+ * const negPoint = curveInstance.neg([1n, 1n]); // Negate a point
+ * const mulPoint = curveInstance.mul([1n, 1n])(3n); // Multiply a point by 3
+ * ```
+ */
+export const curve = ({ p, a: [a0, a1], n }) => {
+    const pf = prime_field(p);
+    const { pow2, pow3, sub, add, mul, neg, div } = pf;
+    const mul3 = mul(3n);
+    const mul2 = mul(2n);
+    const addA1 = add(a1);
+    const mulA1 = mul(a1);
+    const addA0 = add(a0);
+    /**
+     * y**2 = a1*x**3 + a0
+     */
+    const y2 = x => addA0(add(pow3(x))(mulA1(x)));
+    const addPoint = p => q => {
+        if (p === null) {
+            return q;
+        }
+        if (q === null) {
+            return p;
+        }
+        const [px, py] = p;
+        const [qx, qy] = q;
+        const md = px === qx
+            // (3 * px ** 2 + a1) / (2 * py)
+            ? py !== qy || py === 0n ? null : [addA1(mul3(pow2(px))), mul2(py)]
+            // (py - qy) / (px - qx)
+            : [sub(py)(qy), sub(px)(qx)];
+        if (md === null) {
+            return null;
+        }
+        const [ma, mb] = md;
+        const m = div(ma)(mb);
+        // m ** 2 - px - qx
+        const rx = sub(pow2(m))(add(px)(qx));
+        // [rx, m * (px - rx) - py]
+        return [rx, sub(mul(m)(sub(px)(rx)))(py)];
+    };
+    const sqrt_p = sqrt(pf);
+    return {
+        pf,
+        nf: prime_field(n),
+        y2,
+        y: x => sqrt_p(y2(x)),
+        neg: p => {
+            if (p === null) {
+                return null;
+            }
+            const [x, y] = p;
+            return [x, neg(y)];
+        },
+        add: addPoint,
+        mul: scalar_mul({ 0: null, add: addPoint })
+    };
+};
+export const eq = a => b => {
+    if (a === null || b === null) {
+        return a === b;
+    }
+    const [ax, ay] = a;
+    const [bx, by] = b;
+    return ax === bx && ay === by;
+};
+/**
+ * https://neuromancer.sk/std/secg/secp192r1
+ */
+export const secp192r1 = {
+    p: 0xfffffffffffffffffffffffffffffffeffffffffffffffffn,
+    a: [
+        0x64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1n,
+        0xfffffffffffffffffffffffffffffffefffffffffffffffcn
+    ],
+    g: [
+        0x188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012n,
+        0x07192b95ffc8da78631011ed6b24cdd573f977a11e794811n
+    ],
+    n: 0xffffffffffffffffffffffff99def836146bc9b1b4d22831n,
+};
+/**
+ * https://en.bitcoin.it/wiki/Secp256k1
+ * https://neuromancer.sk/std/secg/secp256k1
+ */
+export const secp256k1 = {
+    p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn,
+    a: [7n, 0n],
+    g: [
+        0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798n,
+        0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8n
+    ],
+    n: 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n,
+};
+/**
+ * https://neuromancer.sk/std/secg/secp256r1
+ */
+export const secp256r1 = {
+    p: 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffffn,
+    a: [
+        0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604bn, //< b
+        0xffffffff00000001000000000000000000000000fffffffffffffffffffffffcn, //< a
+    ],
+    g: [
+        0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296n, //< x
+        0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5n, //< y
+    ],
+    n: 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n,
+};

package/crypto/secp/test.f.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    example: () => void;
+    test: () => void;
+};
+export default _default;

package/crypto/secp/test.f.js

@@ -0,0 +1,72 @@
+import { curve, secp256k1, secp192r1, secp256r1, eq } from "./module.f.js";
+export default {
+    example: () => {
+        const curveParams = {
+            p: 23n,
+            a: [0n, 1n],
+            g: [1n, 1n],
+            n: 19n
+        };
+        const c = curve(curveParams);
+        // Access curve operations
+        const point = c.add([1n, 1n])([2n, 5n]); // Add two points
+        const negPoint = c.neg([1n, 1n]); // Negate a point
+        const mulPoint = c.mul([1n, 1n])(3n); // Multiply a point by 3
+    },
+    test: () => {
+        const test_curve = c => {
+            const { g } = c;
+            const { mul, neg, pf: { abs }, y: yf, nf: { p: n } } = curve(c);
+            const point_check = p => {
+                if (p === null) {
+                    throw 'p === null';
+                }
+                const [x, y] = p;
+                const ye = yf(x);
+                if (ye === null) {
+                    throw 'ye === null';
+                }
+                if (abs(ye) !== abs(y)) {
+                    throw 'ye';
+                }
+            };
+            point_check(g);
+            point_check(neg(g));
+            const test_mul = p => {
+                if (mul(p)(0n) !== null) {
+                    throw 'O';
+                }
+                if (mul(p)(1n) !== p) {
+                    throw 'p';
+                }
+                if (mul(p)(n) !== null) {
+                    throw 'n';
+                }
+                const pn = neg(p);
+                if (!eq(mul(p)(n - 1n))(pn)) {
+                    throw 'n - 1';
+                }
+                const f = s => {
+                    const r = mul(p)(s);
+                    point_check(r);
+                    const rn = mul(pn)(s);
+                    point_check(rn);
+                    if (!eq(r)(neg(rn))) {
+                        throw 'r != -rn';
+                    }
+                };
+                f(2n);
+                f(3n);
+                f(4n << 128n);
+                f((5n << 128n) + 6n);
+                f(7n << 128n);
+                f((8n << 128n) + 9n);
+            };
+            test_mul(g);
+            test_mul(neg(g));
+        };
+        test_curve(secp256k1);
+        test_curve(secp192r1);
+        test_curve(secp256r1);
+    }
+};

package/crypto/sha2/module.f.d.ts

@@ -0,0 +1,13 @@
+import * as array from '../../types/array/module.f.ts';
+type HashInput = {
+    readonly f: (i: number) => number;
+    readonly length: number;
+};
+type Hash8 = array.Array8<number>;
+type Array16 = array.Array16<number>;
+export declare const padding: (input: readonly number[]) => (bits: number) => HashInput;
+export declare const computeSha256: (input: readonly number[]) => (bitsCount: number) => Hash8;
+export declare const computeSha224: (input: readonly number[]) => (bitsCount: number) => Hash8;
+export declare const compress256: (data: Array16) => Hash8;
+export declare const compress224: (data: Array16) => Hash8;
+export {};

package/crypto/sha2/module.f.js

@@ -0,0 +1,145 @@
+import * as array from "../../types/array/module.f.js";
+const appendOneWithZeros = input => pos => (input >> pos << pos) | (1 << pos);
+const mod = a => b => (a % b + b) % b;
+export const padding = input => bitsCount => {
+    const appendBlockIndex = (bitsCount / 32) | 0;
+    const length = (bitsCount + mod(447 - bitsCount)(512) + 65) / 32;
+    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 });
+};
+const rotr = d => {
+    const r = 32 - d;
+    return n => n >>> d | n << r;
+};
+const ch = x => y => z => x & y ^ ~x & z;
+const maj = x => y => z => x & y ^ x & z ^ y & z;
+const shr = d => n => n >>> d;
+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);
+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);
+const wi = ([a0, a1, a2, a3]) => (smallSigma1(a0) + a1 + smallSigma0(a2) + a3) | 0;
+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,
+    ],
+];
+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,
+    ];
+};
+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;
+};
+const init256 = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+export const computeSha256 = compute(init256);
+const init224 = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4];
+export const computeSha224 = compute(init224);
+export const compress256 = compress(init256);
+export const compress224 = compress(init224);

package/crypto/sha2/test.f.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    empty: {
+        sha256: () => void;
+        sha224: () => void;
+    };
+    sha224compress: (() => void)[];
+    sha256: (() => void)[];
+};
+export default _default;

package/crypto/sha2/test.f.js

@@ -0,0 +1,82 @@
+import * as _ from "./module.f.js";
+import * as json from "../../json/module.f.js";
+import { sort } from "../../types/object/module.f.js";
+const toU32 = x => (x + 0x1_0000_0000) % 0x1_0000_0000;
+const toHexString = x => toU32(x).toString(16).padStart(8, '0');
+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/dev/module.f.d.ts

@@ -0,0 +1 @@
+export declare const todo: () => never;

package/dev/module.f.js

@@ -0,0 +1 @@
+export const todo = () => { throw 'not implemented'; };

package/dev/test/module.f.d.ts

@@ -0,0 +1,20 @@
+import * as Result from '../../types/result/module.f.ts';
+type Module = {
+    readonly default?: unknown;
+};
+type ModuleMap = {
+    readonly [k in string]: Module;
+};
+type Log<T> = (v: string) => (state: T) => T;
+type Measure<T> = <R>(f: () => R) => (state: T) => readonly [R, number, T];
+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;
+};
+declare const _default: <T>(input: Input<T>) => readonly [number, T];
+export default _default;

package/dev/test/module.f.js

@@ -0,0 +1,75 @@
+import { entries, fold } from "../../types/list/module.f.js";
+import { reset, fgGreen, fgRed, bold } from "../../text/sgr/module.f.js";
+import * as Result from "../../types/result/module.f.js";
+const isTest = s => s.endsWith('test.f.mjs') || s.endsWith('test.f.js') || s.endsWith('test.f.ts');
+const addPass = delta => ts => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });
+const addFail = delta => ts => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 });
+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`;
+};
+export default (input) => {
+    let { moduleMap, log, error, measure, tryCatch, env, state } = input;
+    const isGitHub = env('GITHUB_ACTION') !== void 0;
+    const f = ([k, v]) => {
+        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(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) {
+                        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 ? 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];
+        };
+    };
+    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/dev/test.f.d.ts

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

package/dev/{test.f.ts → test.f.js}

@@ -1,22 +1,20 @@
-const assert
-    : () => never
-    = () => { throw 'assert' }
-
-const assert_if
-    : (_: boolean) => void
-    = c => { if (c) { throw 'assert_if' } }
-
+const assert = () => { throw 'assert'; };
+const assert_if = c => { if (c) {
+    throw 'assert_if';
+} };
 export default {
     ctor: () => {
-        const c = (() => { })['constructor']
-        const f = c('return 5')
-        const result = f()
-        if (result !== 5) { throw 'function' }
+        const c = (() => { })['constructor'];
+        const f = c('return 5');
+        const result = f();
+        if (result !== 5) {
+            throw 'function';
+        }
     },
     ctorEmpty: () => {
         /** @type {any} */
-        const o = {}
-        const c = o['constructor']
+        const o = {};
+        const c = o['constructor'];
         // console.log(c)
         // console.log(c(()=>{}))
     },
@@ -24,19 +22,19 @@ export default {
         /** @type {any} */
         const o = {
             constructor: void 0
-        }
-        const c = o['constructor']
+        };
+        const c = o['constructor'];
         //console.log(c)
     },
     number: () => {
         /** @type {any} */
-        const b = '42'
-        const r = Number(b)
+        const b = '42';
+        const r = Number(b);
         //console.log(r)
     },
     properties: () => {
         /** @type {any} */
-        const o = {}
+        const o = {};
         //const c = o['constructor']
         //const c = o['__proto__']
         //const c = o['__defineGetter__']
@@ -47,12 +45,12 @@ export default {
         //const c = o['isPrototypeOf']
         //const c = o['propertyIsEnumerable']
         //const c = o['toString']
-        const c = o['valueOf']
+        const c = o['valueOf'];
         //console.log(c)
     },
     getOwnPropertyDescriptor: () => {
-        const x = { 'a': 12 }
-        const c = Object.getOwnPropertyDescriptor(x, 'constructor')
-        const a = Object.getOwnPropertyDescriptor(x, 'a')
+        const x = { 'a': 12 };
+        const c = Object.getOwnPropertyDescriptor(x, 'constructor');
+        const a = Object.getOwnPropertyDescriptor(x, 'a');
     }
-}
+};

package/djs/module.f.d.ts

@@ -0,0 +1,17 @@
+import * as list from '../types/list/module.f.ts';
+import * as O from '../types/object/module.f.ts';
+type Object = {
+    readonly [k in string]: Unknown;
+};
+type Array = readonly Unknown[];
+type Unknown = Object | boolean | string | number | null | Array | bigint | undefined;
+type Entry = O.Entry<Unknown>;
+type Entries = list.List<Entry>;
+type MapEntries = (entries: Entries) => Entries;
+export declare const serialize: (mapEntries: MapEntries) => (value: Unknown) => list.List<string>;
+/**
+ * The standard `JSON.stringify` rules determined by
+ * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
+ */
+export declare const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
+export {};