functionalscript 0.8.0 → 0.8.2

package/bnf/data/module.f.d.ts

@@ -11,6 +11,7 @@ export type Rule = Variant | Sequence | TerminalRange;
 /** The full grammar */
 export type RuleSet = Readonly<Record<string, Rule>>;
 type EmptyTag = string | true | undefined;
+type EmptyTagEntry = string | boolean;
 type DispatchRule = {
     readonly emptyTag: EmptyTag;
     readonly rangeMap: Dispatch;
@@ -25,6 +26,10 @@ type DispatchRuleCollection = {
 type DispatchMap = {
     readonly [id in string]: DispatchRule;
 };
+type EmptyTagMap = {
+    readonly [id in string]: EmptyTagEntry;
+};
+export type DescentMatchRule = (r: Rule, s: readonly CodePoint[], idx: number) => MatchResult;
 /**
  * Represents a parsed Abstract Syntax Tree (AST) sequence.
  */
@@ -52,6 +57,7 @@ export type Match = (name: string, s: readonly CodePoint[]) => MatchResult;
 export type MatchRule = (dr: DispatchRule, s: readonly CodePoint[]) => MatchResult;
 export declare const toData: (fr: FRule) => readonly [RuleSet, string];
 export declare const dispatchMap: (ruleSet: RuleSet) => DispatchMap;
+export declare const createEmptyTagMap: (data: readonly [RuleSet, string]) => EmptyTagMap;
 export declare const parser: (fr: FRule) => Match;
 export declare const parserRuleSet: (ruleSet: RuleSet) => Match;
 export {};

package/bnf/data/module.f.js

@@ -161,6 +161,62 @@ export const dispatchMap = (ruleSet) => {
     }
     return result;
 };
+const emptyTagMapAdd = (ruleSet) => (map) => (name) => {
+    if (name in map) {
+        return [ruleSet, map, map[name]];
+    }
+    const rule = ruleSet[name];
+    if (typeof rule === 'number') {
+        return [ruleSet, { ...map, [name]: false }, false];
+    }
+    else if (rule instanceof Array) {
+        map = { ...map, [name]: true };
+        let emptyTag = rule.length == 0;
+        for (const item of rule) {
+            const [, newMap, itemEmptyTag] = emptyTagMapAdd(ruleSet)(map)(item);
+            map = newMap;
+            if (emptyTag === false) {
+                emptyTag = itemEmptyTag !== false;
+            }
+        }
+        return [ruleSet, { ...map, [name]: emptyTag }, emptyTag];
+    }
+    else {
+        map = { ...map, [name]: true };
+        const entries = Object.entries(rule);
+        let emptyTag = false;
+        for (const [tag, item] of entries) {
+            const [, newMap, itemEmptyTag] = emptyTagMapAdd(ruleSet)(map)(item);
+            map = newMap;
+            if (itemEmptyTag !== false) {
+                emptyTag = tag;
+            }
+        }
+        return [ruleSet, { ...map, [name]: emptyTag }, emptyTag];
+    }
+};
+export const createEmptyTagMap = (data) => {
+    return emptyTagMapAdd(data[0])({})(data[1])[1];
+};
+// export const parserDescent = (fr: FRule): Match => {
+//     const data = toData(fr)
+//     const getEmptyTag = (rule: Rule): EmptyTag => {
+//         return todo()
+//     }
+//     const f: DescentMatchRule = (r, cp, idx): MatchResult => {
+//         const mrSuccess = (tag: AstTag, sequence: AstSequence, r: Remainder): MatchResult => [{tag, sequence}, true, r]
+//         const mrFail = (tag: AstTag, sequence: AstSequence, r: Remainder): MatchResult => [{tag, sequence}, false, r]
+//         if (idx >= cp.length) {
+//             const emptyTag = getEmptyTag(r)
+//             return mrSuccess(emptyTag, [], emptyTag === undefined ? null : cp)
+//         }
+//         return todo()
+//     }
+//     const match: Match = (name, cp): MatchResult => {
+//         return f(data[0][name], cp, 0)
+//     }
+//     return match
+// }
 export const parser = (fr) => {
     const data = toData(fr);
     return parserRuleSet(data[0]);
@@ -202,8 +258,5 @@ export const parserRuleSet = (ruleSet) => {
         }
         return mrSuccess(tag, seq, r);
     };
-    const match = (name, cp) => {
-        return f(map[name], cp);
-    };
-    return match;
+    return (name, cp) => f(map[name], cp);
 };

package/bnf/data/test.f.d.ts

@@ -1,5 +1,6 @@
 declare const _default: {
     toData: (() => void)[];
+    emptyTags: (() => void)[];
     variantTest: () => void;
     dispatch: (() => void)[];
     parser: (() => void)[];

package/bnf/data/test.f.js

@@ -5,7 +5,7 @@ import { toArray } from "../../types/list/module.f.js";
 import { sort } from "../../types/object/module.f.js";
 import { join0Plus, max, option, range, remove, repeat, repeat0Plus, set } from "../module.f.js";
 import { classic, deterministic } from "../testlib.f.js";
-import { dispatchMap, parser, parserRuleSet, toData } from "./module.f.js";
+import { dispatchMap, parser, parserRuleSet, toData, createEmptyTagMap } from "./module.f.js";
 export default {
     toData: [
         () => {
@@ -87,6 +87,72 @@ export default {
             }
         }
     ],
+    emptyTags: [
+        () => {
+            const stringRule = 'true';
+            const data = toData(stringRule);
+            const emptyTags = createEmptyTagMap(data);
+            const result = JSON.stringify(emptyTags);
+            if (result !== '{"0":false,"1":false,"2":false,"3":false,"":false}') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = range('AF');
+            const data = toData(terminalRangeRule);
+            const emptyTags = createEmptyTagMap(data);
+            const result = JSON.stringify(emptyTags);
+            if (result !== '{"":false}') {
+                throw result;
+            }
+        },
+        () => {
+            const varintRule = { true: 'true', false: 'false' };
+            const data = toData(varintRule);
+            const emptyTags = createEmptyTagMap(data);
+            const result = JSON.stringify(emptyTags);
+            if (result !== '{"0":false,"1":false,"2":false,"3":false,"4":false,"5":false,"6":false,"7":false,"8":false,"9":false,"":false}') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const data = toData(emptyRule);
+            const emptyTags = createEmptyTagMap(data);
+            const result = JSON.stringify(emptyTags);
+            if (result !== '{"":true}') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const varintRule = { true: 'true', e: emptyRule };
+            const data = toData(varintRule);
+            const emptyTags = createEmptyTagMap(data);
+            const result = JSON.stringify(emptyTags);
+            if (result !== '{"0":false,"1":false,"2":false,"3":false,"4":false,"5":true,"":"e"}') {
+                throw result;
+            }
+        },
+        () => {
+            const repeatRule = repeat0Plus(option('a'));
+            const data = toData(repeatRule);
+            const emptyTags = createEmptyTagMap(data);
+            const result = JSON.stringify(emptyTags);
+            if (result !== '{"0":"none","1":false,"2":false,"3":true,"r":"none","":true}') {
+                throw result;
+            }
+        },
+        () => {
+            const repeatRule = repeat0Plus(set(' \n\r\t'));
+            const data = toData(repeatRule);
+            const emptyTags = createEmptyTagMap(data);
+            const result = JSON.stringify(emptyTags);
+            if (result !== '{"0":false,"1":false,"2":false,"3":false,"4":false,"5":true,"r":"none","":true}') {
+                throw result;
+            }
+        }
+    ],
     variantTest: () => {
         const varintRule = { a: 'a', b: 'b' };
         const result = stringify(sort)(toData(varintRule));

package/ci/module.f.d.ts

@@ -0,0 +1,3 @@
+import type { Io } from '../io/module.f.ts';
+declare const _default: (io: Io) => Promise<number>;
+export default _default;

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/secp/module.f.d.ts

@@ -1,5 +1,5 @@
-import type { Reduce } from '../../types/function/operator/module.f.ts';
-import { type PrimeField } from '../prime_field/module.f.ts';
+import type { Equal, Fold, Reduce } from '../../types/function/operator/module.f.ts';
+import { type PrimeField } from '../../types/prime_field/module.f.ts';
 /**
  * A 2D point represented as a pair of `bigint` values `[x, y]`.
  */
@@ -21,14 +21,15 @@ export type Init = {
 /**
  * Represents an elliptic curve and its associated operations.
  */
-type Curve = {
+export type Curve = {
     readonly pf: PrimeField;
     readonly nf: PrimeField;
+    readonly g: Point;
     readonly y2: (x: bigint) => bigint;
     readonly y: (x: bigint) => bigint | null;
     readonly neg: (a: Point) => Point;
     readonly add: Reduce<Point>;
-    readonly mul: (a: Point) => (n: bigint) => Point;
+    readonly mul: Fold<bigint, Point>;
 };
 /**
  * Constructs an elliptic curve with the given initialization parameters.
@@ -50,27 +51,29 @@ type Curve = {
  * const mulPoint = curveInstance.mul([1n, 1n])(3n); // Multiply a point by 3
  * ```
  */
-export declare const curve: ({ p, a: [a0, a1], n }: Init) => Curve;
-export declare const eq: (a: Point) => (b: Point) => boolean;
+export declare const curve: ({ p, a: [a0, a1], n, g }: Init) => Curve;
+export declare const eq: Equal<Point>;
 /**
  * https://neuromancer.sk/std/secg/secp192r1
+ * NIST P-192
  */
-export declare const secp192r1: Init;
+export declare const secp192r1: Curve;
 /**
  * https://en.bitcoin.it/wiki/Secp256k1
  * https://neuromancer.sk/std/secg/secp256k1
  */
-export declare const secp256k1: Init;
+export declare const secp256k1: Curve;
 /**
  * https://neuromancer.sk/std/secg/secp256r1
+ * NIST P-256
  */
-export declare const secp256r1: Init;
+export declare const secp256r1: Curve;
 /**
  * https://neuromancer.sk/std/secg/secp384r1
  */
-export declare const secp384r1: Init;
+export declare const secp384r1: Curve;
 /**
  * https://neuromancer.sk/std/secg/secp521r1
  */
-export declare const secp521r1: Init;
+export declare const secp521r1: Curve;
 export {};