functionalscript 0.37.0 → 0.38.0

package/{fs → fjs}/text/utf16/proof.f.js

@@ -2,149 +2,106 @@ import { toCodePointList, fromCodePointList, stringToList, listToString, stringT
 import { stringify as jsonStringify } from '../../media/json/module.f.js';
 import { sort } from '../../types/object/module.f.js';
 import { toArray } from '../../types/list/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 const stringify = (a) => jsonStringify(sort)(a);
 export const proof = {
     toCodePointList: [
         () => {
             const result = stringify(toArray(toCodePointList([-1, 65536])));
-            if (result !== '[4294967295,4294967295]') {
-                throw result;
-            }
+            assertEq(result, '[4294967295,4294967295]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([0, 36, 8364, 55295, 57344, 65535])));
-            if (result !== '[0,36,8364,55295,57344,65535]') {
-                throw result;
-            }
+            assertEq(result, '[0,36,8364,55295,57344,65535]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([56320, 57343])));
-            if (result !== '[-2147427328,-2147426305]') {
-                throw result;
-            }
+            assertEq(result, '[-2147427328,-2147426305]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([55296, 56320, 55297, 56375, 55378, 57186, 56319, 57343])));
-            if (result !== '[65536,66615,150370,1114111]') {
-                throw result;
-            }
+            assertEq(result, '[65536,66615,150370,1114111]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([55296, 55296])));
-            if (result !== '[-2147428352,-2147428352]') {
-                throw result;
-            }
+            assertEq(result, '[-2147428352,-2147428352]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([55296, 0])));
-            if (result !== '[-2147428352,0]') {
-                throw result;
-            }
+            assertEq(result, '[-2147428352,0]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([56320])));
-            if (result !== '[-2147427328]') {
-                throw result;
-            }
+            assertEq(result, '[-2147427328]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([56320, 0])));
-            if (result !== '[-2147427328,0]') {
-                throw result;
-            }
+            assertEq(result, '[-2147427328,0]');
         }
     ],
     fromCodePointList: [
         () => {
             const result = stringify(toArray(fromCodePointList([0])));
-            if (result !== '[0]') {
-                throw result;
-            }
+            assertEq(result, '[0]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0x24])));
-            if (result !== '[36]') {
-                throw result;
-            }
+            assertEq(result, '[36]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0x20AC])));
-            if (result !== '[8364]') {
-                throw result;
-            }
+            assertEq(result, '[8364]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0xd7ff])));
-            if (result !== '[55295]') {
-                throw result;
-            }
+            assertEq(result, '[55295]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0xe000])));
-            if (result !== '[57344]') {
-                throw result;
-            }
+            assertEq(result, '[57344]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0xffff])));
-            if (result !== '[65535]') {
-                throw result;
-            }
+            assertEq(result, '[65535]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0x10000])));
-            if (result !== '[55296,56320]') {
-                throw result;
-            }
+            assertEq(result, '[55296,56320]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0x10437])));
-            if (result !== '[55297,56375]') {
-                throw result;
-            }
+            assertEq(result, '[55297,56375]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0x24B62])));
-            if (result !== '[55378,57186]') {
-                throw result;
-            }
+            assertEq(result, '[55378,57186]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0x10ffff])));
-            if (result !== '[56319,57343]') {
-                throw result;
-            }
+            assertEq(result, '[56319,57343]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([-1, 0xd800, 0xdfff, 0x110000])));
-            if (result !== '[65535,55296,57343,0]') {
-                throw result;
-            }
+            assertEq(result, '[65535,55296,57343,0]');
         }
     ],
     string: [
         () => {
             const utf16List = stringToList("Hello world!😂🚜🚲");
             const result = listToString(utf16List);
-            if (result !== "Hello world!😂🚜🚲") {
-                throw result;
-            }
+            assertEq(result, "Hello world!😂🚜🚲");
         },
         () => {
             const cpList = stringToCodePointList("Hello world!😂🚜🚲");
             const result = codePointListToString(cpList);
-            if (result !== "Hello world!😂🚜🚲") {
-                throw result;
-            }
+            assertEq(result, "Hello world!😂🚜🚲");
         },
         () => {
             const a = stringToList("Hello world!😂🚜🚲");
             const b = toCodePointList(a);
             const c = fromCodePointList(b);
             const result = listToString(c);
-            if (result !== "Hello world!😂🚜🚲") {
-                throw result;
-            }
+            assertEq(result, "Hello world!😂🚜🚲");
         }
     ],
     stringToList: [

package/{fs → fjs}/text/utf8/proof.f.js

@@ -1,237 +1,175 @@
-import { toCodePointList, fromCodePointList, fromVec } from './module.f.js';
+import { toCodePointList, fromCodePointList, fromVec, utf8ByteToCodePointOp } from './module.f.js';
 import { stringify as jsonStringify } from '../../media/json/module.f.js';
 import { sort } from '../../types/object/module.f.js';
 import { toArray } from '../../types/list/module.f.js';
-import { msb, u8ListToVec } from '../../types/bit_vec/module.f.js';
+import { msb, u8ListToVec, vec } from '../../types/bit_vec/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 const stringify = jsonStringify(sort);
 export const proof = {
     toCodePoint: [
         () => {
             const result = stringify(toArray(toCodePointList([-1, 256])));
-            if (result !== '[2147483648,2147483648]') {
-                throw result;
-            }
+            assertEq(result, '[2147483648,2147483648]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([128, 193, 245, 255])));
-            if (result !== '[-2147483520,-2147483455,-2147483403,-2147483393]') {
-                throw result;
-            }
+            assertEq(result, '[-2147483520,-2147483455,-2147483403,-2147483393]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([0, 1, 127])));
-            if (result !== '[0,1,127]') {
-                throw result;
-            }
+            assertEq(result, '[0,1,127]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([194, 128, 194, 169, 223, 191])));
-            if (result !== '[128,169,2047]') {
-                throw result;
-            }
+            assertEq(result, '[128,169,2047]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([194, 194, 127, 194, 192, 194])));
-            if (result !== '[-2147483454,-2147483454,127,-2147483454,-2147483456,-2147483454]') {
-                throw result;
-            }
+            assertEq(result, '[-2147483454,-2147483454,127,-2147483454,-2147483456,-2147483454]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([224, 160, 128, 224, 160, 129, 239, 191, 191])));
-            if (result !== '[2048,2049,65535]') {
-                throw result;
-            }
+            assertEq(result, '[2048,2049,65535]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([224, 224, 160, 127, 239, 191])));
-            if (result !== '[-2147483424,-2147482592,127,-2147481601]') {
-                throw result;
-            }
+            assertEq(result, '[-2147483424,-2147482592,127,-2147481601]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([240, 144, 128, 128, 240, 144, 128, 129, 244, 143, 191, 191])));
-            if (result !== '[65536,65537,1114111]') {
-                throw result;
-            }
+            assertEq(result, '[65536,65537,1114111]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([240, 240, 160, 127, 244, 191])));
-            if (result !== '[-2147483408,-2147483104,127,-2147482817]') {
-                throw result;
-            }
+            assertEq(result, '[-2147483408,-2147483104,127,-2147482817]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([240, 160, 160, 244, 160, 160])));
-            if (result !== '[-2147448800,-2147432416]') {
-                throw result;
-            }
+            assertEq(result, '[-2147448800,-2147432416]');
         },
         // Overlong 3-byte encodings (E0 80..9F ..) are rejected, not decoded.
         () => {
             const result = stringify(toArray(toCodePointList([224, 128, 128])));
-            if (result !== '[-2147483424,-2147483520,-2147483520]') {
-                throw result;
-            }
+            assertEq(result, '[-2147483424,-2147483520,-2147483520]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([224, 159, 191])));
-            if (result !== '[-2147483424,-2147483489,-2147483457]') {
-                throw result;
-            }
+            assertEq(result, '[-2147483424,-2147483489,-2147483457]');
         },
         // Overlong 4-byte encodings (F0 80..8F .. ..) are rejected, not decoded.
         () => {
             const result = stringify(toArray(toCodePointList([240, 128, 128, 128])));
-            if (result !== '[-2147483408,-2147483520,-2147483520,-2147483520]') {
-                throw result;
-            }
+            assertEq(result, '[-2147483408,-2147483520,-2147483520,-2147483520]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([240, 143, 191, 191])));
-            if (result !== '[-2147483408,-2147483505,-2147483457,-2147483457]') {
-                throw result;
-            }
+            assertEq(result, '[-2147483408,-2147483505,-2147483457,-2147483457]');
         },
         // Valid boundary cases still decode: E0 A0 80 -> U+0800, F0 90 80 80 -> U+10000.
         () => {
             const result = stringify(toArray(toCodePointList([224, 160, 128])));
-            if (result !== '[2048]') {
-                throw result;
-            }
+            assertEq(result, '[2048]');
         },
         () => {
             const result = stringify(toArray(toCodePointList([240, 144, 128, 128])));
-            if (result !== '[65536]') {
-                throw result;
-            }
+            assertEq(result, '[65536]');
+        },
+        // A byte stream never accumulates a 2-byte state whose lead is >= F8
+        // (isLeadByte caps leads at F4), so this defensive fallthrough is
+        // only reachable by calling the scan op directly with such a state.
+        () => {
+            const result = stringify(utf8ByteToCodePointOp(0x80, [0xf8, 0x80]));
+            assertEq(result, '[[-2147483136,-2147483520],null]');
         }
     ],
     fromCodePointList: [
         () => {
             const result = stringify(toArray(fromCodePointList([0, 1, 0x7F])));
-            if (result !== '[0,1,127]') {
-                throw result;
-            }
+            assertEq(result, '[0,1,127]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0x80])));
-            if (result !== '[194,128]') {
-                throw result;
-            }
+            assertEq(result, '[194,128]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0xa9])));
-            if (result !== '[194,169]') {
-                throw result;
-            }
+            assertEq(result, '[194,169]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0x7ff])));
-            if (result !== '[223,191]') {
-                throw result;
-            }
+            assertEq(result, '[223,191]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0x800])));
-            if (result !== '[224,160,128]') {
-                throw result;
-            }
+            assertEq(result, '[224,160,128]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0x801])));
-            if (result !== '[224,160,129]') {
-                throw result;
-            }
+            assertEq(result, '[224,160,129]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0xffff])));
-            if (result !== '[239,191,191]') {
-                throw result;
-            }
+            assertEq(result, '[239,191,191]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0x10000])));
-            if (result !== '[240,144,128,128]') {
-                throw result;
-            }
+            assertEq(result, '[240,144,128,128]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0x10001])));
-            if (result !== '[240,144,128,129]') {
-                throw result;
-            }
+            assertEq(result, '[240,144,128,129]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0x10FFFF])));
-            if (result !== '[244,143,191,191]') {
-                throw result;
-            }
+            assertEq(result, '[244,143,191,191]');
         },
         () => {
             const result = stringify(toArray(fromCodePointList([0x110000, 2147483648])));
-            if (result !== '[2147483648,2147483648]') {
-                throw result;
-            }
+            assertEq(result, '[2147483648,2147483648]');
         }
     ],
     toFrom: [
         () => {
             const codePointList = toCodePointList([128, 193, 245, 255]);
             const result = stringify(toArray(fromCodePointList(codePointList)));
-            if (result !== '[128,193,245,255]') {
-                throw result;
-            }
+            assertEq(result, '[128,193,245,255]');
         },
         () => {
             const codePointList = toCodePointList([194, 194, 127, 194, 192, 194]);
             const result = stringify(toArray(fromCodePointList(codePointList)));
-            if (result !== '[194,194,127,194,192,194]') {
-                throw result;
-            }
+            assertEq(result, '[194,194,127,194,192,194]');
         },
         () => {
             const codePointList = toCodePointList([224, 224, 160, 127, 239, 191]);
             const result = stringify(toArray(fromCodePointList(codePointList)));
-            if (result !== '[224,224,160,127,239,191]') {
-                throw result;
-            }
+            assertEq(result, '[224,224,160,127,239,191]');
         },
         () => {
             const codePointList = toCodePointList([240, 240, 160, 127, 244, 191]);
             const result = stringify(toArray(fromCodePointList(codePointList)));
-            if (result !== '[240,240,160,127,244,191]') {
-                throw result;
-            }
+            assertEq(result, '[240,240,160,127,244,191]');
         },
         () => {
             const codePointList = toCodePointList([240, 160, 160, 244, 160, 160]);
             const result = stringify(toArray(fromCodePointList(codePointList)));
-            if (result !== '[240,160,160,244,160,160]') {
-                throw result;
-            }
+            assertEq(result, '[240,160,160,244,160,160]');
         }
     ],
     fromVec: [
         // Valid ASCII → decoded string
         () => {
             const v = u8ListToVec(msb)([0x68, 0x65, 0x6c, 0x6c, 0x6f]); // "hello"
-            if (fromVec(v) !== 'hello') {
-                throw 'expected "hello"';
-            }
+            assertEq(fromVec(v), 'hello', 'expected "hello"');
         },
         // Valid multi-byte UTF-8 → decoded string (U+00A9 COPYRIGHT SIGN, 2-byte)
         () => {
             const v = u8ListToVec(msb)([0xc2, 0xa9]); // "©"
-            if (fromVec(v) !== '©') {
-                throw 'expected copyright sign';
-            }
+            assertEq(fromVec(v), '©', 'expected copyright sign');
         },
         // Valid 3-byte UTF-8 (U+4E2D CJK)
         () => {
             const v = u8ListToVec(msb)([0xe4, 0xb8, 0xad]); // "中"
-            if (fromVec(v) !== '中') {
-                throw 'expected CJK character';
-            }
+            assertEq(fromVec(v), '中', 'expected CJK character');
         },
         // Valid 4-byte UTF-8 (U+1F600 GRINNING FACE)
         () => {
@@ -243,44 +181,37 @@ export const proof = {
         // Invalid byte sequence → null
         () => {
             const v = u8ListToVec(msb)([0xff, 0xfe]); // not valid UTF-8
-            if (fromVec(v) !== null) {
-                throw 'expected null for invalid UTF-8';
-            }
+            assertEq(fromVec(v), null, 'expected null for invalid UTF-8');
         },
         // Lone continuation byte → null
         () => {
             const v = u8ListToVec(msb)([0x80]);
-            if (fromVec(v) !== null) {
-                throw 'expected null for lone continuation byte';
-            }
+            assertEq(fromVec(v), null, 'expected null for lone continuation byte');
         },
         // Surrogate half (U+D800, encoded as CESU-8 0xED 0xA0 0x80) → null
         () => {
             const v = u8ListToVec(msb)([0xed, 0xa0, 0x80]);
-            if (fromVec(v) !== null) {
-                throw 'expected null for surrogate';
-            }
+            assertEq(fromVec(v), null, 'expected null for surrogate');
         },
         // Empty Vec → empty string
         () => {
             const v = u8ListToVec(msb)([]);
-            if (fromVec(v) !== '') {
-                throw 'expected empty string';
-            }
+            assertEq(fromVec(v), '', 'expected empty string');
         },
         // Overlong 3-byte encoding (E0 80 80, would decode to U+0000) → null
         () => {
             const v = u8ListToVec(msb)([0xe0, 0x80, 0x80]);
-            if (fromVec(v) !== null) {
-                throw 'expected null for overlong 3-byte encoding';
-            }
+            assertEq(fromVec(v), null, 'expected null for overlong 3-byte encoding');
         },
         // Overlong 4-byte encoding (F0 80 80 80, would decode to U+0000) → null
         () => {
             const v = u8ListToVec(msb)([0xf0, 0x80, 0x80, 0x80]);
-            if (fromVec(v) !== null) {
-                throw 'expected null for overlong 4-byte encoding';
-            }
+            assertEq(fromVec(v), null, 'expected null for overlong 4-byte encoding');
+        },
+        // Vec length not a multiple of 8 bits → null
+        () => {
+            const v = vec(4n)(0n);
+            assertEq(fromVec(v), null);
         },
     ]
 };

package/{fs → fjs}/types/array/proof.f.js

@@ -1,117 +1,85 @@
 import { at, first, last, head, tail, splitFirst, splitLast, empty } from './module.f.js';
 import { stringify as jsonStringify } from '../../media/json/module.f.js';
 import { sort } from '../object/module.f.js';
+import { assertEq, assertNotNullish } from '../../asserts/module.f.js';
 const stringify = jsonStringify(sort);
 export const proof = {
     stringify: () => {
         const result = stringify([1, 20, 300]);
-        if (result !== '[1,20,300]') {
-            throw result;
-        }
+        assertEq(result, '[1,20,300]');
     },
     at: [
         () => {
             const result = at(2)([1, 20, 300]);
-            if (result !== 300) {
-                throw result;
-            }
+            assertEq(result, 300);
         },
         () => {
             const result = at(3)([1, 20, 300]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         }
     ],
     first: [
         () => {
             const result = first([1, 20, 300]);
-            if (result !== 1) {
-                throw result;
-            }
+            assertEq(result, 1);
         },
         () => {
             const result = first([]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         }
     ],
     last: [
         () => {
             const result = last([1, 20, 300]);
-            if (result !== 300) {
-                throw result;
-            }
+            assertEq(result, 300);
         },
         () => {
             const result = last([]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         }
     ],
     head: [
         () => {
-            const result = head([1, 20, 300]);
-            if (result === null) {
-                throw result;
-            }
+            const result = assertNotNullish(head([1, 20, 300]));
             const str = stringify(result);
-            if (str !== '[1,20]') {
-                throw str;
-            }
+            assertEq(str, '[1,20]');
         },
         () => {
             const result = head([]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         }
     ],
     tail: [
         () => {
             const result = tail([1, 20, 300]);
             const str = stringify(result);
-            if (str !== '[20,300]') {
-                throw str;
-            }
+            assertEq(str, '[20,300]');
         },
         () => {
             const result = tail([]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         }
     ],
     splitFirst: [
         () => {
             const result = splitFirst([1, 20, 300]);
             const str = stringify(result);
-            if (str !== '[1,[20,300]]') {
-                throw str;
-            }
+            assertEq(str, '[1,[20,300]]');
         },
         () => {
             const result = splitFirst([]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         },
     ],
     splitLast: [
         () => {
             const result = splitLast([1, 20, 300]);
             const str = stringify(result);
-            if (str !== '[[1,20],300]') {
-                throw str;
-            }
+            assertEq(str, '[[1,20],300]');
         },
         () => {
             const result = splitLast([]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         }
     ],
     empty: () => {
@@ -119,8 +87,6 @@ export const proof = {
         const a = x;
         const b = x;
         const c = [...a, ...b, ...x];
-        if (c.length !== 0) {
-            throw c;
-        }
+        assertEq(c.length, 0, c);
     }
 };