functionalscript 0.7.0 → 0.8.1

package/ci/module.f.js

@@ -0,0 +1,169 @@
+const os = ['ubuntu', 'macos', 'windows'];
+const architecture = ['intel', 'arm'];
+// https://docs.github.com/en/actions/reference/runners/github-hosted-runners#standard-github-hosted-runners-for-public-repositories
+const images = {
+    ubuntu: {
+        intel: 'ubuntu-latest',
+        arm: 'ubuntu-24.04-arm'
+    },
+    macos: {
+        intel: 'macos-15-intel',
+        arm: 'macos-latest'
+    },
+    windows: {
+        intel: 'windows-latest',
+        arm: 'windows-11-arm',
+    }
+};
+const install = (step) => ({ type: 'install', step });
+const test = (step) => ({ type: 'test', step });
+const installOnWindowsArm = ({ def, name, path }) => (v) => (a) => install(v === 'windows' && a === 'arm'
+    ? { run: `irm ${path}/install.ps1 | iex; "$env:USERPROFILE\\.${name}\\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append` }
+    : def);
+const installBun = installOnWindowsArm({
+    def: { uses: 'oven-sh/setup-bun@v1' },
+    name: 'bun',
+    path: 'bun.sh'
+});
+const installDeno = installOnWindowsArm({
+    def: { uses: 'denoland/setup-deno@v2', with: { 'deno-version': '2' } },
+    name: 'deno',
+    path: 'deno.land'
+});
+const cargoTest = (target, config) => {
+    const to = target ? ` --target ${target}` : '';
+    const co = config ? ` --config ${config}` : '';
+    const main = `cargo test${to}${co}`;
+    return [
+        test({ run: main }),
+        test({ run: `${main} --release` })
+    ];
+};
+const customTarget = (target) => [
+    { type: 'rust', target },
+    ...cargoTest(target)
+];
+const wasmTarget = (target) => [
+    ...customTarget(target),
+    ...cargoTest(target, '.cargo/config.wasmer.toml')
+];
+const clean = (steps) => [
+    ...steps,
+    test({ run: 'git reset --hard HEAD && git clean -fdx' })
+];
+const installNode = (version) => ({ uses: 'actions/setup-node@v6', with: { 'node-version': version } });
+const basicNode = (version) => (extra) => clean([
+    install(installNode(version)),
+    test({ run: 'npm ci' }),
+    ...extra,
+]);
+const node = (version) => (extra) => basicNode(version)([
+    test({ run: 'npm test' }),
+    test({ run: 'npm run fst' }),
+    ...extra,
+]);
+const findTgz = (v) => v === 'windows' ? '(Get-ChildItem *.tgz).FullName' : './*.tgz';
+const toSteps = (m) => {
+    const filter = (st) => m.flatMap((mt) => mt.type === st ? [mt.step] : []);
+    const aptGet = m.flatMap(v => v.type === 'apt-get' ? [v.package] : []).join(' ');
+    const rust = m.find(v => v.type === 'rust') !== undefined;
+    const targets = m.flatMap(v => v.type === 'rust' && v.target !== undefined ? [v.target] : []).join(',');
+    return [
+        ...(aptGet !== '' ? [{ run: `sudo apt-get update && sudo apt-get install -y ${aptGet}` }] : []),
+        ...(rust ? [{
+                // wasm32-wasip1-threads doesn't work on Rust 1.91 in the release mode.
+                // See https://github.com/sergey-shandar/wasmtime-crash
+                uses: 'dtolnay/rust-toolchain@1.90.0',
+                with: {
+                    components: 'rustfmt,clippy',
+                    targets
+                }
+            }] : []),
+        ...filter('install'),
+        { uses: 'actions/checkout@v5' },
+        ...filter('test'),
+    ];
+};
+const nodes = ['20', '22', '25'];
+const nodeTest = (v) => v === '20' ? 'run test20' : 'test';
+const nodeSteps = (v) => [
+    install(installNode(v)),
+    test({ run: 'npm ci' }),
+    test({ run: `npm ${nodeTest(v)}` }),
+];
+const ubuntu = (ms) => ({
+    'runs-on': 'ubuntu-latest',
+    steps: toSteps(ms)
+});
+const nodeVersions = Object.fromEntries(nodes.map(v => [`node${v}`, ubuntu(nodeSteps(v))]));
+const steps = (v) => (a) => {
+    const result = [
+        // Rust
+        test({ run: 'cargo fmt -- --check' }),
+        test({ run: 'cargo clippy -- -D warnings' }),
+        ...cargoTest(),
+        install({ uses: 'bytecodealliance/actions/wasmtime/setup@v1' }),
+        install({ uses: 'wasmerio/setup-wasmer@v1' }),
+        ...wasmTarget('wasm32-wasip1'),
+        ...wasmTarget('wasm32-wasip2'),
+        ...wasmTarget('wasm32-unknown-unknown'),
+        ...wasmTarget('wasm32-wasip1-threads'),
+        ...(a !== 'intel' ? [] :
+            v === 'windows' ?
+                customTarget('i686-pc-windows-msvc') :
+                v === 'ubuntu' ? [
+                    { type: 'apt-get', package: 'libc6-dev-i386' },
+                    ...customTarget('i686-unknown-linux-gnu'),
+                ] :
+                    []),
+        // Node.js
+        ...node('24')([
+            // TypeScript Preview
+            install({ run: 'npm install -g @typescript/native-preview' }),
+            test({ run: 'tsgo' }),
+            // Playwright
+            install({ run: 'npm install -g playwright' }),
+            install({ run: 'playwright install --with-deps' }),
+            ...['chromium', 'firefox', 'webkit'].map(browser => (test({ run: `npx playwright test --browser=${browser}` }))),
+            // publishing
+            test({ run: 'npm pack' }),
+            test({ run: `npm install -g ${findTgz(v)}` }),
+            test({ run: 'fsc issues/demo/data/tree.json _tree.f.js' }),
+            test({ run: 'fst' }),
+            test({ run: 'npm uninstall functionalscript -g' }),
+        ]),
+        // Deno
+        ...clean([
+            installDeno(v)(a),
+            test({ run: 'deno install' }),
+            test({ run: 'deno task test' }),
+            test({ run: 'deno task fst' }),
+            test({ run: 'deno publish --dry-run' }),
+        ]),
+        // Bun
+        ...clean([
+            installBun(v)(a),
+            test({ run: 'bun test --timeout 20000' }),
+            test({ run: 'bun ./dev/tf/module.ts' }),
+        ]),
+    ];
+    return toSteps(result);
+};
+const jobs = {
+    ...Object.fromEntries([
+        ...os.flatMap(v => architecture.map(a => [`${v}-${a}`, {
+                'runs-on': images[v][a],
+                steps: steps(v)(a),
+            }]))
+    ]),
+    ...nodeVersions,
+};
+const gha = {
+    name: 'CI',
+    on: { pull_request: {} },
+    jobs,
+};
+export default async (io) => {
+    io.fs.writeFileSync('.github/workflows/ci.yml', JSON.stringify(gha, null, '  '));
+    return 0;
+};

package/ci/module.js

@@ -0,0 +1,3 @@
+import node from "../io/module.js";
+import x from "./module.f.js";
+await node(x);

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

@@ -2,6 +2,7 @@
  * Provides an implementation of HMAC (Hash-based Message Authentication Code).
  *
  * https://en.wikipedia.org/wiki/HMAC
+ * https://www.rfc-editor.org/rfc/rfc2104
  *
  * @module
  *
@@ -16,13 +17,13 @@
  * if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) { throw r }
  * ```
  */
-import { type Vec } from '../../types/bit_vec/module.f.ts';
+import { type Reduce } from '../../types/bit_vec/module.f.ts';
 import { type Sha2 } from '../sha2/module.f.ts';
 /**
- * Generates an HMAC (Hash-based Message Authentication Code) using the specified SHA-2 hash function.
+ * Generates an HMAC (Hash-based Message Authentication Code) using the specified hash function.
  *
- * @param sha2 - The SHA-2 hash function implementation to use.
+ * @param hashFunc - The hash function implementation to use.
  * @returns - A function that takes a key and returns another function
  * that takes a message and computes the HMAC.
  */
-export declare const hmac: (sha2: Sha2) => (k: Vec) => (m: Vec) => Vec;
+export declare const hmac: (hashFunc: Sha2) => Reduce;

package/crypto/hmac/module.f.js

@@ -2,6 +2,7 @@
  * Provides an implementation of HMAC (Hash-based Message Authentication Code).
  *
  * https://en.wikipedia.org/wiki/HMAC
+ * https://www.rfc-editor.org/rfc/rfc2104
  *
  * @module
  *
@@ -16,12 +17,9 @@
  * if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) { throw r }
  * ```
  */
-import { length } from "../../types/bit_vec/module.f.js";
-import { empty, msb, vec, vec8 } from "../../types/bit_vec/module.f.js";
-import { flip } from "../../types/function/module.f.js";
-import { repeat } from "../../types/monoid/module.f.js";
+import { length, msb, vec, vec8, repeat } from "../../types/bit_vec/module.f.js";
 import { computeSync } from "../sha2/module.f.js";
-const { concat } = msb;
+const { concat, xor } = msb;
 /**
  * Outer padding.
  */
@@ -31,25 +29,18 @@ const oPad = vec8(0x5cn);
  */
 const iPad = vec8(0x36n);
 /**
- * Repeats a vector to create a padded block of the desired length.
- */
-const padRepeat = repeat({ identity: empty, operation: concat });
-/**
- * Generates an HMAC (Hash-based Message Authentication Code) using the specified SHA-2 hash function.
+ * Generates an HMAC (Hash-based Message Authentication Code) using the specified hash function.
  *
- * @param sha2 - The SHA-2 hash function implementation to use.
+ * @param hashFunc - The hash function implementation to use.
  * @returns - A function that takes a key and returns another function
  * that takes a message and computes the HMAC.
  */
-export const hmac = (sha2) => {
-    const { blockLength } = sha2;
-    const p = flip(padRepeat)(blockLength >> 3n);
+export const hmac = (hashFunc) => {
+    const { blockLength } = hashFunc;
+    const p = repeat(blockLength >> 3n);
     const ip = p(iPad);
     const op = p(oPad);
-    const c = computeSync(sha2);
-    const vbl = vec(blockLength);
-    // a and b should have the same size
-    const xor = (a) => (b) => vbl(a ^ b);
+    const c = computeSync(hashFunc);
     return k => {
         const k1 = length(k) > blockLength ? c([k]) : k;
         const k2 = concat(k1)(vec(blockLength - length(k1))(0n));

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

@@ -1,6 +1,7 @@
 declare const _default: {
     example: () => void;
     sha256: () => void;
+    sha384: () => void;
     sha512: () => void;
 };
 export default _default;

package/crypto/hmac/test.f.js

@@ -1,23 +1,31 @@
-import { msbUtf8 } from "../../text/module.f.js";
-import { vec } from "../../types/bit_vec/module.f.js";
-import { sha256, sha512 } from "../sha2/module.f.js";
+import { utf8 } from "../../text/module.f.js";
+import { length, uint, vec } from "../../types/bit_vec/module.f.js";
+import { sha256, sha384, sha512 } from "../sha2/module.f.js";
 import { hmac } from "./module.f.js";
 export default {
     example: () => {
-        const r = hmac(sha256)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'));
+        const r = hmac(sha256)(utf8('key'))(utf8('The quick brown fox jumps over the lazy dog'));
         if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) {
             throw r;
         }
     },
     sha256: () => {
-        const r = hmac(sha256)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'));
-        if (r !== 0x1f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n) {
+        const r = hmac(sha256)(utf8('key'))(utf8('The quick brown fox jumps over the lazy dog'));
+        if (uint(r) !== 0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n) {
             throw r;
         }
     },
+    sha384: () => {
+        const k = vec(384n)(0n);
+        const m = vec(904n)(0x0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010069c7548c21d0dfea6b9a51c9ead4e27c33d3b3f180316e5bcab92c933f0e4dbc9a9083505bc92276aec4be312696ef7bf3bf603f4bbd381196a029f340585312n);
+        const r = hmac(sha384)(k)(m);
+        if (r !== vec(384n)(0x8f858157ce005cd52fd8e8f1a46b55e6cfae21c8c183d9c2f7504bedf450609edd7d3c6171dc0bdd2d2444faa28f18ban)) {
+            throw uint(r).toString(16);
+        }
+    },
     sha512: () => {
-        const r = hmac(sha512)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'));
-        if (r !== 0x1b42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3an) {
+        const r = hmac(sha512)(utf8('key'))(utf8('The quick brown fox jumps over the lazy dog'));
+        if (r !== vec(512n)(0xb42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3an)) {
             throw r;
         }
     }

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

@@ -37,4 +37,4 @@ export declare const prime_field: (p: bigint) => PrimeField;
  * if (root !== 2n) { throw root }
  * ```
  */
-export declare const sqrt: ({ p, mul, pow }: PrimeField) => (a: bigint) => bigint | null;
+export declare const sqrt: ({ p, pow, pow2 }: PrimeField) => (a: bigint) => bigint | null;

package/crypto/prime_field/module.f.js

@@ -65,13 +65,14 @@ export const prime_field = (p) => {
  * if (root !== 2n) { throw root }
  * ```
  */
-export const sqrt = ({ p, mul, pow }) => {
+export const sqrt = ({ p, pow, pow2 }) => {
     if ((p & 3n) !== 3n) {
         throw 'sqrt';
     }
     const sqrt_k = (p + 1n) >> 2n;
+    const psk = pow(sqrt_k);
     return a => {
-        const result = pow(a)(sqrt_k);
-        return mul(result)(result) === a ? result : null;
+        const result = psk(a);
+        return pow2(result) === a ? result : null;
     };
 };

package/crypto/prime_field/test.f.js

@@ -58,21 +58,21 @@ export default {
             },
             pow: () => {
                 const test = a => {
-                    if (f.pow(a)(0n) !== 1n) {
+                    if (f.pow(0n)(a) !== 1n) {
                         throw '**0';
                     }
-                    if (f.pow(a)(1n) !== a) {
+                    if (f.pow(1n)(a) !== a) {
                         throw '**1';
                     }
                     // https://en.wikipedia.org/wiki/Fermat%27s_little_theorem
                     // a^(p-1) % p = 1
-                    if (f.abs(f.pow(a)(f.middle)) !== 1n) {
+                    if (f.abs(f.pow(f.middle)(a)) !== 1n) {
                         throw '**middle';
                     }
-                    if (f.pow(a)(f.sub(f.max)(1n)) !== f.reciprocal(a)) {
+                    if (f.pow(f.sub(f.max)(1n))(a) !== f.reciprocal(a)) {
                         throw '**(max-1)';
                     }
-                    if (f.pow(a)(f.max) !== 1n) {
+                    if (f.pow(f.max)(a) !== 1n) {
                         throw '**max';
                     }
                 };
@@ -80,7 +80,7 @@ export default {
                 if (f.pow(0n)(0n) !== 1n) {
                     throw '0**0';
                 }
-                if (f.pow(0n)(f.max) !== 0n) {
+                if (f.pow(f.max)(0n) !== 0n) {
                     throw '0**max';
                 }
                 // 1
@@ -90,30 +90,30 @@ export default {
                 if (f.pow(2n)(2n) !== 4n) {
                     throw '2**2';
                 }
-                if (f.pow(2n)(3n) !== 8n) {
+                if (f.pow(3n)(2n) !== 8n) {
                     throw '2**3';
                 }
-                if (f.pow(2n)(128n) !== 1n << 128n) {
+                if (f.pow(128n)(2n) !== 1n << 128n) {
                     throw '2**128';
                 }
                 // 3
                 test(3n);
-                if (f.pow(3n)(2n) !== 9n) {
+                if (f.pow(2n)(3n) !== 9n) {
                     throw '3**2';
                 }
                 if (f.pow(3n)(3n) !== 27n) {
                     throw '3**3';
                 }
-                if (f.pow(3n)(100n) !== 3n ** 100n) {
+                if (f.pow(100n)(3n) !== 3n ** 100n) {
                     throw '3**100';
                 }
-                if (f.pow(3n)(110n) !== 3n ** 110n) {
+                if (f.pow(110n)(3n) !== 3n ** 110n) {
                     throw '3**110';
                 }
-                if (f.pow(3n)(120n) !== 3n ** 120n) {
+                if (f.pow(120n)(3n) !== 3n ** 120n) {
                     throw '3**120';
                 }
-                if (f.pow(3n)(121n) !== 3n ** 121n) {
+                if (f.pow(121n)(3n) !== 3n ** 121n) {
                     throw '3**121';
                 }
                 //

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

@@ -0,0 +1,15 @@
+import { type Vec } from '../../types/bit_vec/module.f.ts';
+import type { Curve } from '../secp/module.f.ts';
+import { type Sha2 } from '../sha2/module.f.ts';
+export type All = {
+    readonly q: bigint;
+    readonly qlen: bigint;
+    readonly bits2int: (b: Vec) => bigint;
+    readonly int2octets: (x: bigint) => Vec;
+    readonly bits2octets: (b: Vec) => Vec;
+};
+export declare const all: (q: bigint) => All;
+export declare const fromCurve: (c: Curve) => All;
+export declare const concat: (...x: readonly Vec[]) => Vec;
+export declare const computeK: ({ q, bits2int, qlen, int2octets, bits2octets }: All) => (hf: Sha2) => (x: bigint) => (m: Vec) => bigint;
+export declare const sign: (a: All) => (hf: Sha2) => (x: bigint) => (m: Vec) => bigint;

package/crypto/rfc6979/module.f.js

@@ -0,0 +1,98 @@
+import { todo } from "../../dev/module.f.js";
+import { bitLength, divUp, roundUp } from "../../types/bigint/module.f.js";
+import { empty, length, listToVec, msb, repeat, unpack, vec, vec8 } from "../../types/bit_vec/module.f.js";
+import { hmac } from "../hmac/module.f.js";
+import { computeSync } from "../sha2/module.f.js";
+// qlen to rlen
+const roundUp8 = roundUp(8n);
+const divUp8 = divUp(8n);
+export const all = (q) => {
+    const qlen = bitLength(q);
+    const bits2int = (b) => {
+        const { length, uint } = unpack(b);
+        const diff = length - qlen;
+        return diff > 0n ? uint >> diff : uint;
+    };
+    const int2octets = vec(roundUp8(qlen));
+    return {
+        q,
+        qlen,
+        bits2int,
+        int2octets,
+        // since z2 < 2*q, we can use simple mod with `z1 < q ? z1 : z1 - q`
+        bits2octets: b => int2octets(bits2int(b) % q),
+    };
+};
+export const fromCurve = (c) => all(c.nf.p);
+const v0 = vec8(0x01n);
+const k0 = vec8(0x00n);
+const ltov = listToVec(msb);
+export const concat = (...x) => ltov(x);
+export const computeK = ({ q, bits2int, qlen, int2octets, bits2octets }) => (hf) => (x) => (m) => {
+    const hmacf = hmac(hf);
+    // a. Process m through the hash function H, yielding:
+    //      h1 = H(m)
+    //   (h1 is a sequence of hlen bits).
+    const h1 = computeSync(hf)([m]);
+    // b. Set:
+    //      V = 0x01 0x01 0x01 ... 0x01
+    //    such that the length of V, in bits, is equal to 8*ceil(hlen/8).
+    //    For instance, on an octet-based system, if H is SHA-256, then V
+    //    is set to a sequence of 32 octets of value 1.  Note that in this
+    //    step and all subsequent steps, we use the same H function as the
+    //    one used in step 'a' to process the input message; this choice
+    //    will be discussed in more detail in Section 3.6.
+    const rep = repeat(divUp8(hf.hashLength));
+    let v = rep(v0);
+    // c. Set:
+    //      K = 0x00 0x00 0x00 ... 0x00
+    //    such that the length of K, in bits, is equal to 8*ceil(hlen/8).
+    let k = rep(k0);
+    // d. Set:
+    //      K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1))
+    //    where '||' denotes concatenation.
+    const xh1 = concat(int2octets(x), bits2octets(h1));
+    k = hmacf(k)(concat(v, k0, xh1));
+    // e. Set:
+    //      V = HMAC_K(V)
+    v = hmacf(k)(v);
+    // f. Set:
+    //      K = HMAC_K(V || 0x01 || int2octets(x) || bits2octets(h1))
+    k = hmacf(k)(concat(v, v0, xh1));
+    // g. Set:
+    //      V = HMAC_K(V)
+    v = hmacf(k)(v);
+    // h. Apply the following algorithm until a proper value is for `k`:
+    while (true) {
+        // h. Apply the following algorithm until a proper value is for `k`:
+        //    1. Set `T` to the empty sequence, so `tlen = 0`.
+        let t = empty;
+        //    2. while `tlen < qlen` do:
+        //       - `V = HMAC_K(V)`
+        //       - `T = T || V`
+        // Possible optimizations:
+        // - precompute number of iterations
+        // - `qlen` can't be 0, so we can avoid the first check and
+        //   first concatenation.
+        while (length(t) < qlen) {
+            v = hmacf(k)(v);
+            t = concat(t, v);
+        }
+        //    3. Compute `k = bits2int(T)`. If `k` is not in `[1, q-1]` or `kG = 0` then
+        //       - `K = HMAC_K(V || 0x00)`
+        //       - `V = HMAC_K(V)`
+        //       and loop (try to generate a new `T`, and so on). Return to step `1`.
+        const result = bits2int(t);
+        if (0n < result && result < q) {
+            return result;
+        }
+        k = hmacf(k)(concat(v, k0));
+        v = hmacf(k)(v);
+    }
+};
+export const sign = (a) => (hf) => (x) => (m) => {
+    const hm = computeSync(hf)([m]);
+    const h = a.bits2int(hm) % a.q;
+    ///
+    return todo();
+};

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

@@ -0,0 +1,10 @@
+declare const _default: {
+    bits2int: () => void;
+    int2octets: () => void;
+    bit2octets: () => void;
+    k: () => void;
+    computeK: () => void;
+    investigate: () => void;
+    a2: () => void;
+};
+export default _default;