functionalscript 0.3.6 → 0.3.8

package/crypto/sha2/module.f.js

@@ -1,145 +1,252 @@
-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;
+import { mask } from "../../types/bigint/module.f.js";
+import { vec, length, empty, msb } from "../../types/bit_vec/module.f.js";
+const { concat, popFront, front } = msb;
+const lastOne = vec(1n)(1n);
+const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
+    const bitLength = 1n << logBitLen;
+    const rotr = (d) => {
+        const r = bitLength - d;
+        return (n) => n >> d | n << r;
+    };
+    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(bs0);
+    const bigSigma1 = bigSigma(bs1);
+    const smallSigma = ([a, b, c]) => {
+        const ra = rotr(a);
+        const rb = rotr(b);
+        return (x) => ra(x) ^ rb(x) ^ (x >> c);
+    };
+    const smallSigma0 = smallSigma(ss0);
+    const smallSigma1 = smallSigma(ss1);
+    const ch = (x, y, z) => x & y ^ ~x & z;
+    const maj = (x, y, z) => x & y ^ x & z ^ y & z;
+    const m = mask(bitLength);
+    const wi = ([a0, a1, a2, a3]) => (smallSigma1(a0) + a1 + smallSigma0(a2) + a3) & m;
+    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 kLength = k.length;
+    const compressV16 = ([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) & m;
+                d = c;
+                c = b;
+                b = a;
+                a = (t1 + t2) & m;
+            }
+            ++i;
+            if (i === kLength) {
+                break;
+            }
+            w = nextW(w);
         }
-        if (i === length - 1) {
-            return bitsCount % 0x1_0000_0000;
+        return [
+            (a0 + a) & m,
+            (b0 + b) & m,
+            (c0 + c) & m,
+            (d0 + d) & m,
+            (e0 + e) & m,
+            (f0 + f) & m,
+            (g0 + g) & m,
+            (h0 + h) & m,
+        ];
+    };
+    const at = (u) => (i) => (u >> (i << logBitLen)) & m;
+    const compress = (i) => (u) => {
+        const a = at(u);
+        return compressV16(i)([
+            a(15n),
+            a(14n),
+            a(13n),
+            a(12n),
+            a(11n),
+            a(10n),
+            a(9n),
+            a(8n),
+            a(7n),
+            a(6n),
+            a(5n),
+            a(4n),
+            a(3n),
+            a(2n),
+            a(1n),
+            a(0n),
+        ]);
+    };
+    const chunkLength = bitLength << 4n; // * 16
+    const fromV8 = (a) => a.reduce((p, v) => (p << bitLength) | v);
+    const lastChunkLength = chunkLength - 65n;
+    return {
+        bitLength,
+        chunkLength,
+        compress,
+        fromV8,
+        append: (state) => (v) => {
+            let { remainder, hash, len } = state;
+            remainder = concat(remainder)(v);
+            let remainderLen = length(remainder);
+            while (remainderLen >= chunkLength) {
+                const [u, nr] = popFront(chunkLength)(remainder);
+                hash = compress(hash)(u);
+                remainder = nr;
+                remainderLen -= chunkLength;
+                len += chunkLength;
+            }
+            return {
+                hash,
+                len,
+                remainder
+            };
+        },
+        end: (hashLength) => {
+            const offset = (bitLength << 3n) - hashLength;
+            return (state) => {
+                const { len, remainder } = state;
+                let { hash } = state;
+                const rLen = length(remainder);
+                let u = front(chunkLength)(concat(remainder)(lastOne));
+                // last chunk overflow
+                if (rLen > lastChunkLength) {
+                    hash = compress(hash)(u);
+                    u = 0n;
+                }
+                return fromV8(compress(hash)(u | (len + rLen))) >> offset;
+            };
         }
-        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,
+const sha2 = ({ append, end }, hash, hashLength) => ({
+    init: {
+        hash,
+        len: 0n,
+        remainder: empty,
+    },
+    append,
+    end: end(hashLength),
+});
+export const base32 = base({
+    logBitLen: 5n,
+    k: [
+        [
+            0x428a2f98n, 0x71374491n, 0xb5c0fbcfn, 0xe9b5dba5n, 0x3956c25bn, 0x59f111f1n, 0x923f82a4n, 0xab1c5ed5n,
+            0xd807aa98n, 0x12835b01n, 0x243185ben, 0x550c7dc3n, 0x72be5d74n, 0x80deb1fen, 0x9bdc06a7n, 0xc19bf174n,
+        ],
+        [
+            0xe49b69c1n, 0xefbe4786n, 0x0fc19dc6n, 0x240ca1ccn, 0x2de92c6fn, 0x4a7484aan, 0x5cb0a9dcn, 0x76f988dan,
+            0x983e5152n, 0xa831c66dn, 0xb00327c8n, 0xbf597fc7n, 0xc6e00bf3n, 0xd5a79147n, 0x06ca6351n, 0x14292967n,
+        ],
+        [
+            0x27b70a85n, 0x2e1b2138n, 0x4d2c6dfcn, 0x53380d13n, 0x650a7354n, 0x766a0abbn, 0x81c2c92en, 0x92722c85n,
+            0xa2bfe8a1n, 0xa81a664bn, 0xc24b8b70n, 0xc76c51a3n, 0xd192e819n, 0xd6990624n, 0xf40e3585n, 0x106aa070n,
+        ],
+        [
+            0x19a4c116n, 0x1e376c08n, 0x2748774cn, 0x34b0bcb5n, 0x391c0cb3n, 0x4ed8aa4an, 0x5b9cca4fn, 0x682e6ff3n,
+            0x748f82een, 0x78a5636fn, 0x84c87814n, 0x8cc70208n, 0x90befffan, 0xa4506cebn, 0xbef9a3f7n, 0xc67178f2n,
+        ],
     ],
-    [
-        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+    bs0: [2n, 13n, 22n],
+    bs1: [6n, 11n, 25n],
+    ss0: [7n, 18n, 3n],
+    ss1: [17n, 19n, 10n],
+});
+export const base64 = base({
+    logBitLen: 6n,
+    k: [
+        [
+            0x428a2f98d728ae22n, 0x7137449123ef65cdn, 0xb5c0fbcfec4d3b2fn, 0xe9b5dba58189dbbcn,
+            0x3956c25bf348b538n, 0x59f111f1b605d019n, 0x923f82a4af194f9bn, 0xab1c5ed5da6d8118n,
+            0xd807aa98a3030242n, 0x12835b0145706fben, 0x243185be4ee4b28cn, 0x550c7dc3d5ffb4e2n,
+            0x72be5d74f27b896fn, 0x80deb1fe3b1696b1n, 0x9bdc06a725c71235n, 0xc19bf174cf692694n,
+        ],
+        [
+            0xe49b69c19ef14ad2n, 0xefbe4786384f25e3n, 0x0fc19dc68b8cd5b5n, 0x240ca1cc77ac9c65n,
+            0x2de92c6f592b0275n, 0x4a7484aa6ea6e483n, 0x5cb0a9dcbd41fbd4n, 0x76f988da831153b5n,
+            0x983e5152ee66dfabn, 0xa831c66d2db43210n, 0xb00327c898fb213fn, 0xbf597fc7beef0ee4n,
+            0xc6e00bf33da88fc2n, 0xd5a79147930aa725n, 0x06ca6351e003826fn, 0x142929670a0e6e70n,
+        ],
+        [
+            0x27b70a8546d22ffcn, 0x2e1b21385c26c926n, 0x4d2c6dfc5ac42aedn, 0x53380d139d95b3dfn,
+            0x650a73548baf63den, 0x766a0abb3c77b2a8n, 0x81c2c92e47edaee6n, 0x92722c851482353bn,
+            0xa2bfe8a14cf10364n, 0xa81a664bbc423001n, 0xc24b8b70d0f89791n, 0xc76c51a30654be30n,
+            0xd192e819d6ef5218n, 0xd69906245565a910n, 0xf40e35855771202an, 0x106aa07032bbd1b8n,
+        ],
+        [
+            0x19a4c116b8d2d0c8n, 0x1e376c085141ab53n, 0x2748774cdf8eeb99n, 0x34b0bcb5e19b48a8n,
+            0x391c0cb3c5c95a63n, 0x4ed8aa4ae3418acbn, 0x5b9cca4f7763e373n, 0x682e6ff3d6b2b8a3n,
+            0x748f82ee5defb2fcn, 0x78a5636f43172f60n, 0x84c87814a1f0ab72n, 0x8cc702081a6439ecn,
+            0x90befffa23631e28n, 0xa4506cebde82bde9n, 0xbef9a3f7b2c67915n, 0xc67178f2e372532bn,
+        ],
+        [
+            0xca273eceea26619cn, 0xd186b8c721c0c207n, 0xeada7dd6cde0eb1en, 0xf57d4f7fee6ed178n,
+            0x06f067aa72176fban, 0x0a637dc5a2c898a6n, 0x113f9804bef90daen, 0x1b710b35131c471bn,
+            0x28db77f523047d84n, 0x32caab7b40c72493n, 0x3c9ebe0a15c9bebcn, 0x431d67c49c100d4cn,
+            0x4cc5d4becb3e42b6n, 0x597f299cfc657e2an, 0x5fcb6fab3ad6faecn, 0x6c44198c4a475817n,
+        ],
     ],
-];
-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);
+    bs0: [28n, 34n, 39n],
+    bs1: [14n, 18n, 41n],
+    ss0: [1n, 8n, 7n],
+    ss1: [19n, 61n, 6n],
+});
+/** SHA-256 */
+export const sha256 = sha2(base32, [0x6a09e667n, 0xbb67ae85n, 0x3c6ef372n, 0xa54ff53an, 0x510e527fn, 0x9b05688cn, 0x1f83d9abn, 0x5be0cd19n], 256n);
+/** SHA-224 */
+export const sha224 = sha2(base32, [0xc1059ed8n, 0x367cd507n, 0x3070dd17n, 0xf70e5939n, 0xffc00b31n, 0x68581511n, 0x64f98fa7n, 0xbefa4fa4n], 224n);
+/** SHA-512 */
+export const sha512 = sha2(base64, [
+    0x6a09e667f3bcc908n, 0xbb67ae8584caa73bn, 0x3c6ef372fe94f82bn, 0xa54ff53a5f1d36f1n,
+    0x510e527fade682d1n, 0x9b05688c2b3e6c1fn, 0x1f83d9abfb41bd6bn, 0x5be0cd19137e2179n,
+], 512n);
+/** SHA-384 */
+export const sha384 = sha2(base64, [
+    0xcbbb9d5dc1059ed8n, 0x629a292a367cd507n, 0x9159015a3070dd17n, 0x152fecd8f70e5939n,
+    0x67332667ffc00b31n, 0x8eb44a8768581511n, 0xdb0c2e0d64f98fa7n, 0x47b5481dbefa4fa4n,
+], 384n);
+/** SHA-512/256 */
+export const sha512x256 = sha2(base64, [
+    0x22312194fc2bf72cn, 0x9f555fa3c84c64c2n, 0x2393b86b6f53b151n, 0x963877195940eabdn,
+    0x96283ee2a88effe3n, 0xbe5e1e2553863992n, 0x2b0199fc2c85b8aan, 0x0eb72ddc81c52ca2n,
+], 256n);
+/** SHA-512/224 */
+export const sha512x224 = sha2(base64, [
+    0x8c3d37c819544da2n, 0x73e1996689dcd4d6n, 0x1dfab7ae32ff9c82n, 0x679dd514582f9fcfn,
+    0x0f6d2b697bd44da8n, 0x77e36f7304c48942n, 0x3f9d85a86a1d36c8n, 0x1112e6ad91d692a1n,
+], 224n);

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

@@ -1,9 +1,28 @@
 declare const _default: {
-    empty: {
+    base: {
+        b32: () => {
+            s256: () => void;
+            s224: () => void;
+        };
+        b64: () => {
+            s512: () => void;
+            s385: () => void;
+            s512x256: () => void;
+            s512x224: () => void;
+        };
+    };
+    sha2: {
         sha256: () => void;
         sha224: () => void;
+        sha512: () => void;
+        sha384: () => void;
+        sha512x256: () => void;
+        sha512x224: () => void;
+    };
+    utf8: (() => void)[];
+    fill: () => {
+        8: () => void;
+        16: () => void;
     };
-    sha224compress: (() => void)[];
-    sha256: (() => void)[];
 };
 export default _default;

package/crypto/sha2/test.f.js

@@ -1,82 +1,135 @@
-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))
-// }
+import { msbUtf8 } from "../../text/module.f.js";
+import { empty, msb, vec } from "../../types/bit_vec/module.f.js";
+import { repeat } from "../../types/monoid/module.f.js";
+import { base32, base64, sha224, sha256, sha384, sha512, sha512x224, sha512x256, } from "./module.f.js";
+const { concat: beConcat } = msb;
+const checkEmpty = ({ init, end }) => (x) => {
+    const result = end(init);
+    if (result !== x) {
+        throw [result, x];
+    }
+};
+// https://en.wikipedia.org/wiki/SHA-2#Test_vectors
+//
+// https://csrc.nist.gov/Projects/Cryptographic-Algorithm-Validation-Program/Secure-Hashing
 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;
-            }
+    base: {
+        b32: () => {
+            const { fromV8, compress, chunkLength } = base32;
+            const e = 1n << (chunkLength - 1n);
+            return {
+                s256: () => {
+                    const result = fromV8(compress(sha256.init.hash)(e));
+                    const x = 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n;
+                    if (result !== x) {
+                        throw [result, x];
+                    }
+                },
+                s224: () => {
+                    const result = fromV8(compress(sha224.init.hash)(e)) >> 32n;
+                    const x = 0xd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42fn;
+                    if (result !== x) {
+                        throw [result, x];
+                    }
+                },
+            };
         },
-        sha224: () => {
-            const hash = _.computeSha224([])(0);
-            const result = stringify(hash.map(toHexString));
-            if (result !== '["d14a028c","2a3a2bc9","476102bb","288234c4","15a2b01f","828ea62a","c5b3e42f","bdd387cb"]') {
-                throw result;
-            }
+        b64: () => {
+            const { fromV8, compress, chunkLength } = base64;
+            const e = 1n << (chunkLength - 1n);
+            return {
+                s512: () => {
+                    const result = fromV8(compress(sha512.init.hash)(e));
+                    const x = 0xcf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3en;
+                    if (result !== x) {
+                        throw [result, x];
+                    }
+                },
+                s385: () => {
+                    const result = fromV8(compress(sha384.init.hash)(e)) >> 128n;
+                    const x = 0x38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95bn;
+                    if (result !== x) {
+                        throw [result, x];
+                    }
+                },
+                s512x256: () => {
+                    const result = fromV8(base64.compress(sha512x256.init.hash)(e)) >> 256n;
+                    const x = 0xc672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967an;
+                    if (result !== x) {
+                        throw [result, x];
+                    }
+                },
+                s512x224: () => {
+                    const result = fromV8(compress(sha512x224.init.hash)(e)) >> 288n;
+                    const x = 0x6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4n;
+                    if (result !== x) {
+                        throw [result, x];
+                    }
+                },
+            };
         }
     },
-    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: [
+    sha2: {
+        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: [
         () => {
-            //[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;
+            const s = msbUtf8("The quick brown fox jumps over the lazy dog");
+            let state = sha224.init;
+            state = sha224.append(state)(s);
+            const h = sha224.end(state);
+            if (h !== 0x730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525n) {
+                throw h;
             }
         },
         () => {
-            //[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 s = msbUtf8("The quick brown fox jumps over the lazy dog.");
+            let state = sha224.init;
+            state = sha224.append(state)(s);
+            const h = sha224.end(state);
+            if (h !== 0x619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn) {
+                throw h;
             }
         },
         () => {
-            const input = Array(8).fill(0x31313131);
-            const result = _.computeSha256(input)(256);
-            if (toU32(result[0]) !== 0x8a83665f) {
-                throw result[0];
+            const s = msbUtf8("hello world");
+            if (s !== 0x168656c6c6f20776f726c64n) {
+                throw s;
             }
-        },
-        () => {
-            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;
+            let state = sha256.init;
+            state = sha256.append(state)(s);
+            const h = sha256.end(state);
+            if (h !== 0xb94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9n) {
+                throw h;
             }
         }
-    ]
+    ],
+    fill: () => {
+        const times = repeat({ identity: empty, operation: beConcat })(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 !== 0x8a83665fn) {
+                    throw h;
+                }
+            },
+            16: () => {
+                const r = times(16n);
+                let state = sha256.init;
+                state = sha256.append(state)(r);
+                const h = sha256.end(state);
+                if (h !== 0x3138bb9bc78df27c473ecfd1410f7bd45ebac1f59cf3ff9cfe4db77aab7aedd3n) {
+                    throw h;
+                }
+            }
+        };
+    }
 };

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

@@ -1,4 +1,4 @@
-import * as Result from '../../types/result/module.f.ts';
+import type * as Result from '../../types/result/module.f.ts';
 type Module = {
     readonly default?: unknown;
 };

package/dev/test/module.f.js

@@ -1,10 +1,9 @@
 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 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;