functionalscript 0.8.0 → 0.8.1

package/crypto/secp/test.f.js

@@ -5,7 +5,7 @@ const poker = (param) => () => {
     // c ^ ((x * y) * (1/x * 1/y)) = c
     const { g, n } = param;
     const { mul, y } = curve(param);
-    const f = (m) => (pList) => pList.map(i => mul(i)(m));
+    const f = (m) => (pList) => pList.map(mul(m));
     //
     const pf = prime_field(n);
     //           0        1        2        3        4        5        6        7
@@ -65,7 +65,7 @@ export default {
         // 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
+        const mulPoint = c.mul(3n)([1n, 1n]); // Multiply a point by 3
     },
     test: () => {
         const test_curve = c => {
@@ -87,23 +87,23 @@ export default {
             point_check(g);
             point_check(neg(g));
             const test_mul = (p) => {
-                if (mul(p)(0n) !== null) {
+                if (mul(0n)(p) !== null) {
                     throw 'O';
                 }
-                if (mul(p)(1n) !== p) {
+                if (mul(1n)(p) !== p) {
                     throw 'p';
                 }
-                if (mul(p)(n) !== null) {
+                if (mul(n)(p) !== null) {
                     throw 'n';
                 }
                 const pn = neg(p);
-                if (!eq(mul(p)(n - 1n))(pn)) {
+                if (!eq(mul(n - 1n)(p))(pn)) {
                     throw 'n - 1';
                 }
                 const f = s => {
-                    const r = mul(p)(s);
+                    const r = mul(s)(p);
                     point_check(r);
-                    const rn = mul(pn)(s);
+                    const rn = mul(s)(pn);
                     point_check(rn);
                     if (!eq(r)(neg(rn))) {
                         throw 'r != -rn';

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

@@ -1,5 +1,11 @@
+/**
+ * See https://www.rfc-editor.org/rfc/rfc6234
+ *
+ * @module
+ */
 import type { Array16, Array8 } from '../../types/array/module.f.ts';
 import { type Vec } from '../../types/bit_vec/module.f.ts';
+import type { Fold } from '../../types/function/operator/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 export type V8 = Array8<bigint>;
 export type V16 = Array16<bigint>;
@@ -25,8 +31,8 @@ export type Base = {
     readonly chunkLength: bigint;
     readonly compress: (i: V8) => (u: bigint) => V8;
     readonly fromV8: (a: V8) => bigint;
-    readonly append: (state: State) => (v: Vec) => State;
-    readonly end: (hashLength: bigint) => (state: State) => bigint;
+    readonly append: Fold<Vec, State>;
+    readonly end: (hashLength: bigint) => (state: State) => Vec;
 };
 /**
  * SHA2. See https://en.wikipedia.org/wiki/SHA-2
@@ -56,18 +62,18 @@ export type Sha2 = {
     /**
      * Appends data to the state and returns the new state.
      *
-     * @param state The current state.
      * @param v The data to append.
+     * @param state The current state.
      * @returns The new state after appending data.
      */
-    readonly append: (state: State) => (v: Vec) => State;
+    readonly append: Fold<Vec, State>;
     /**
      * Finalizes the hash and returns the result as a bigint.
      *
      * @param state The final state.
      * @returns The resulting hash.
      */
-    readonly end: (state: State) => bigint;
+    readonly end: (state: State) => Vec;
 };
 export declare const computeSync: ({ append, init, end }: Sha2) => (list: List<Vec>) => Vec;
 export declare const base32: Base;

package/crypto/sha2/module.f.js

@@ -115,13 +115,14 @@ const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
     };
     const chunkLength = bitLength << 4n; // * 16
     const fromV8 = (a) => a.reduce((p, v) => (p << bitLength) | v);
-    const lastChunkLength = chunkLength - 65n;
+    // See https://www.rfc-editor.org/rfc/rfc6234#section-4
+    const lastChunkLength = chunkLength - 1n - (bitLength << 1n);
     return {
         bitLength,
         chunkLength,
         compress,
         fromV8,
-        append: (state) => (v) => {
+        append: (v) => (state) => {
             let { remainder, hash, len } = state;
             remainder = concat(remainder)(v);
             let remainderLen = length(remainder);
@@ -168,7 +169,7 @@ const sha2 = ({ append, end, chunkLength }, hash, hashLength) => ({
     end: end(hashLength),
 });
 export const computeSync = ({ append, init, end }) => {
-    const f = fold(flip(append))(init);
+    const f = fold(append)(init);
     return (list) => end(f(list));
 };
 export const base32 = base({

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

@@ -6,7 +6,7 @@ declare const _default: {
         };
         b64: () => {
             s512: () => void;
-            s385: () => void;
+            s384: () => void;
             s512x256: () => void;
             s512x224: () => void;
         };
@@ -24,5 +24,8 @@ declare const _default: {
         8: () => void;
         16: () => void;
     };
+    padding: {
+        overflow: () => void;
+    };
 };
 export default _default;

package/crypto/sha2/test.f.js

@@ -1,12 +1,11 @@
-import { msbUtf8 } from "../../text/module.f.js";
-import { empty, msb, vec } from "../../types/bit_vec/module.f.js";
+import { utf8 } from "../../text/module.f.js";
+import { repeat, uint, vec } from "../../types/bit_vec/module.f.js";
+import { flip } from "../../types/function/module.f.js";
 import { map } from "../../types/list/module.f.js";
-import { repeat } from "../../types/monoid/module.f.js";
 import { base32, base64, computeSync, sha224, sha256, sha384, sha512, sha512x224, sha512x256, } from "./module.f.js";
-const { concat: beConcat } = msb;
-const checkEmpty = ({ init, end }) => (x) => {
+const checkEmpty = ({ init, end, hashLength }) => (x) => {
     const result = end(init);
-    if (result !== x) {
+    if (result !== vec(hashLength)(x)) {
         throw [result, x];
     }
 };
@@ -46,7 +45,7 @@ export default {
                         throw [result, x];
                     }
                 },
-                s385: () => {
+                s384: () => {
                     const result = fromV8(compress(sha384.init.hash)(e)) >> 128n;
                     const x = 0x38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95bn;
                     if (result !== x) {
@@ -71,72 +70,83 @@ export default {
         }
     },
     sha2: {
-        sha256: () => checkEmpty(sha256)(0x1e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n),
-        sha224: () => checkEmpty(sha224)(0x1d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42fn),
-        sha512: () => checkEmpty(sha512)(0x1cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3en),
-        sha384: () => checkEmpty(sha384)(0x138b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95bn),
-        sha512x256: () => checkEmpty(sha512x256)(0x1c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967an),
-        sha512x224: () => checkEmpty(sha512x224)(0x16ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4n),
+        sha256: () => checkEmpty(sha256)(0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n),
+        sha224: () => checkEmpty(sha224)(0xd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42fn),
+        sha512: () => checkEmpty(sha512)(0xcf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3en),
+        sha384: () => checkEmpty(sha384)(0x38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95bn),
+        sha512x256: () => checkEmpty(sha512x256)(0xc672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967an),
+        sha512x224: () => checkEmpty(sha512x224)(0x6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4n),
     },
     utf8: [
         () => {
-            const e = 0x1730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525n;
+            const e = 0x730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525n;
             {
-                const s = msbUtf8("The quick brown fox jumps over the lazy dog");
+                const s = utf8("The quick brown fox jumps over the lazy dog");
                 const h = computeSync(sha224)([s]);
-                if (h !== e) {
+                if (uint(h) !== e) {
                     throw h;
                 }
             }
             {
                 const s = ['The', ' quick', ' brown', ' fox', ' jumps', ' over', ' the', ' lazy', ' dog'];
-                const h = computeSync(sha224)(map(msbUtf8)(s));
-                if (h !== e) {
+                const h = computeSync(sha224)(map(utf8)(s));
+                if (uint(h) !== e) {
                     throw h;
                 }
             }
         },
         () => {
-            const s = msbUtf8("The quick brown fox jumps over the lazy dog.");
+            const s = utf8("The quick brown fox jumps over the lazy dog.");
             const h = computeSync(sha224)([s]);
-            if (h !== 0x1619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn) {
+            if (uint(h) !== 0x619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn) {
                 throw h;
             }
         },
         () => {
-            const s = msbUtf8("hello world");
-            if (s !== 0x168656c6c6f20776f726c64n) {
+            const s = utf8("hello world");
+            if (uint(s) !== 0x68656c6c6f20776f726c64n) {
                 throw s;
             }
             let state = sha256.init;
-            state = sha256.append(state)(s);
+            state = sha256.append(s)(state);
             const h = sha256.end(state);
-            if (h !== 0x1b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9n) {
+            if (uint(h) !== 0xb94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9n) {
                 throw h;
             }
         }
     ],
     fill: () => {
-        const times = repeat({ identity: empty, operation: beConcat })(vec(32n)(0x31313131n));
+        const times = flip(repeat)(vec(32n)(0x31313131n));
         return {
             8: () => {
                 const r = times(8n);
                 let state = sha256.init;
-                state = sha256.append(state)(r);
-                const h = sha256.end(state);
-                if (h >> 224n !== 0x18a83665fn) {
+                state = sha256.append(r)(state);
+                const h = uint(sha256.end(state));
+                if (h >> 224n !== 0x8a83665fn) {
                     throw h;
                 }
             },
             16: () => {
                 const r = times(16n);
                 let state = sha256.init;
-                state = sha256.append(state)(r);
+                state = sha256.append(r)(state);
                 const h = sha256.end(state);
-                if (h !== 0x13138bb9bc78df27c473ecfd1410f7bd45ebac1f59cf3ff9cfe4db77aab7aedd3n) {
+                if (uint(h) !== 0x3138bb9bc78df27c473ecfd1410f7bd45ebac1f59cf3ff9cfe4db77aab7aedd3n) {
                     throw h;
                 }
             }
         };
-    }
+    },
+    padding: {
+        overflow: () => {
+            const zero = vec(8n)(0n);
+            const msg = flip(repeat)(zero)(113n);
+            const h = computeSync(sha384)([msg]);
+            const x = 0x6be9af2cf3cd5dd12c8d9399ec2b34e66034fbd699d4e0221d39074172a380656089caafe8f39963f94cc7c0a07e3d21n;
+            if (uint(h) !== x) {
+                throw h;
+            }
+        },
+    },
 };

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

@@ -1,5 +1,5 @@
 import { type Vec } from '../../types/bit_vec/module.f.ts';
 import { type Init } from '../secp/module.f.ts';
 import type { Sha2 } from '../sha2/module.f.ts';
-export declare const newPrivateKey: (i: Init) => (random: Vec) => Vec;
+export declare const newPrivateKey: (i: Init) => (random: Vec) => bigint;
 export declare const sign: (sha2: Sha2) => (curveInit: Init) => (privateKey: Vec) => (messageHash: Vec) => readonly [bigint, bigint];

package/crypto/sign/module.f.js

@@ -1,3 +1,4 @@
+import { bitLength } from "../../types/bigint/module.f.js";
 import { listToVec, msb, uint, vec, vec8, length } from "../../types/bit_vec/module.f.js";
 import { hmac } from "../hmac/module.f.js";
 import { curve } from "../secp/module.f.js";
@@ -28,7 +29,7 @@ const createK = (sha2) => {
 };
 export const newPrivateKey = (i) => (random) => {
     const { nf } = curve(i);
-    if (length(nf.max) < length(random)) {
+    if (bitLength(nf.max) < length(random)) {
         throw "need more random bits";
     }
     return uint(random) % nf.p;
@@ -39,7 +40,7 @@ export const sign = (sha2) => (curveInit) => (privateKey) => (messageHash) => {
     //`k` is a unique for each `z` and secret.
     const k = createK(sha2)(privateKey)(messageHash) % pf.p;
     // `R = G * k`.
-    const rp = mul(curveInit.g)(k);
+    const rp = mul(k)(curveInit.g);
     // `r = R.x`
     const r = rp === null ? 0n : rp[0];
     // `s = ((z + r * d) / k)`.

package/dev/tf/all.test.js

@@ -3,9 +3,17 @@ import { loadModuleMap } from "../module.f.js";
 import { isTest, parseTestSet } from "./module.f.js";
 import * as nodeTest from 'node:test';
 const isBun = typeof Bun !== 'undefined';
+const isPlaywright = typeof process !== 'undefined' && process?.env?.PLAYWRIGHT_TEST !== undefined;
 const createFramework = (fw) => (prefix, f) => fw.test(prefix, t => f((name, v) => t.test(name, v)));
+// Bun doesn't support nested tests yet.
 const createBunFramework = (fw) => (prefix, f) => f((name, v) => fw.test(`${prefix}: ${name}`, v));
-const framework = isBun ? createBunFramework(nodeTest) : createFramework(nodeTest);
+const createPlaywrihtFramework = async () => {
+    const pwTest = (await import('@playwright/test')).test;
+    return (prefix, f) => f((name, v) => pwTest(`${prefix}: ${name}`, v));
+};
+const framework = isPlaywright ? await createPlaywrihtFramework() :
+    isBun ? createBunFramework(nodeTest) :
+        createFramework(nodeTest);
 const parse = parseTestSet(io.tryCatch);
 const scanModule = (x) => async (subTestRunner) => {
     let subTests = [x];

package/djs/ast/module.f.d.ts

@@ -1,10 +1,10 @@
-import type * as djs from '../module.f.ts';
+import type { Primitive, Array, Unknown } from '../module.f.ts';
 export type AstModule = [readonly string[], AstBody];
-export type AstConst = djs.Primitive | AstModuleRef | AstArray | AstObject;
+export type AstConst = Primitive | AstModuleRef | AstArray | AstObject;
 export type AstModuleRef = ['aref' | 'cref', number];
 export type AstArray = ['array', readonly AstConst[]];
 export type AstObject = {
     readonly [k in string]: AstConst;
 };
 export type AstBody = readonly AstConst[];
-export declare const run: (body: AstBody) => (args: djs.Array) => djs.Unknown;
+export declare const run: (body: AstBody) => (args: Array) => Unknown;

package/djs/ast/test.f.js

@@ -1,38 +1,37 @@
-import * as list from "../../types/object/module.f.js";
-const { sort } = list;
-import * as shared from "./module.f.js";
+import { sort } from "../../types/object/module.f.js";
+import { run } from "./module.f.js";
 import { stringifyAsTree } from "../serializer/module.f.js";
 export default {
     test: () => {
-        const djs = shared.run([1])([]);
+        const djs = run([1])([]);
         const result = stringifyAsTree(sort)(djs);
         if (result !== '1') {
             throw result;
         }
     },
     testCref: () => {
-        const djs = shared.run([1, 2, 3, 4, 5, ['cref', 3]])([11, 12, 13, 14, 15]);
+        const djs = run([1, 2, 3, 4, 5, ['cref', 3]])([11, 12, 13, 14, 15]);
         const result = stringifyAsTree(sort)(djs);
         if (result !== '4') {
             throw result;
         }
     },
     testAref: () => {
-        const djs = shared.run([1, 2, 3, 4, 5, ['aref', 3]])([11, 12, 13, 14, 15]);
+        const djs = run([1, 2, 3, 4, 5, ['aref', 3]])([11, 12, 13, 14, 15]);
         const result = stringifyAsTree(sort)(djs);
         if (result !== '14') {
             throw result;
         }
     },
     testArray: () => {
-        const djs = shared.run([1, 2, 3, 4, 5, ['array', [['aref', 3], ['cref', 3]]]])([11, 12, 13, 14, 15]);
+        const djs = run([1, 2, 3, 4, 5, ['array', [['aref', 3], ['cref', 3]]]])([11, 12, 13, 14, 15]);
         const result = stringifyAsTree(sort)(djs);
         if (result !== '[14,4]') {
             throw result;
         }
     },
     testObj: () => {
-        const djs = shared.run([1, 2, 3, 4, 5, { "key": { "key2": ['array', [['aref', 3], ['cref', 3]]] } }])([11, 12, 13, 14, 15]);
+        const djs = run([1, 2, 3, 4, 5, { "key": { "key2": ['array', [['aref', 3], ['cref', 3]]] } }])([11, 12, 13, 14, 15]);
         const result = stringifyAsTree(sort)(djs);
         if (result !== '{"key":{"key2":[14,4]}}') {
             throw result;

package/djs/parser/module.f.d.ts

@@ -1,4 +1,4 @@
-import * as result from '../../types/result/module.f.ts';
+import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import type { DjsTokenWithMetadata } from '../tokenizer/module.f.ts';
 import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
@@ -7,11 +7,11 @@ import type { AstModule } from '../ast/module.f.ts';
 import type { TokenMetadata } from '../../js/tokenizer/module.f.ts';
 export type ParseContext = {
     readonly fs: Fs;
-    readonly complete: OrderedMap<result.Result<AstModule, string>>;
+    readonly complete: OrderedMap<Result<AstModule, string>>;
     readonly stack: List<string>;
 };
 export type ParseError = {
     readonly message: string;
     readonly metadata: TokenMetadata | null;
 };
-export declare const parseFromTokens: (tokenList: List<DjsTokenWithMetadata>) => result.Result<AstModule, ParseError>;
+export declare const parseFromTokens: (tokenList: List<DjsTokenWithMetadata>) => Result<AstModule, ParseError>;

package/djs/parser/module.f.js

@@ -1,4 +1,4 @@
-import * as result from "../../types/result/module.f.js";
+import { error, ok } from "../../types/result/module.f.js";
 import { fold, first, drop, toArray, length, concat } from "../../types/list/module.f.js";
 import { setReplace, at } from "../../types/ordered_map/module.f.js";
 import { fromMap } from "../../types/object/module.f.js";
@@ -351,8 +351,8 @@ const foldOp = token => state => {
 export const parseFromTokens = (tokenList) => {
     const state = fold(foldOp)({ state: '', module: { refs: null, modules: null, consts: null } })(tokenList);
     switch (state.state) {
-        case 'result': return result.ok([toArray(state.module.modules), toArray(state.module.consts)]);
-        case 'error': return result.error(state.error);
-        default: return result.error({ message: 'unexpected end', metadata: null });
+        case 'result': return ok([toArray(state.module.modules), toArray(state.module.consts)]);
+        case 'error': return error(state.error);
+        default: return error({ message: 'unexpected end', metadata: null });
     }
 };