functionalscript 0.7.0 → 0.8.1

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 });
     }
 };