functionalscript 0.36.0 → 0.38.0

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

@@ -1,150 +1,107 @@
-import { toCodePointList, fromCodePointList, stringToList, listToString, stringToCodePointList, codePointListToString } from "./module.f.js";
-import { stringify as jsonStringify } from "../../json/module.f.js";
-import { sort } from "../../types/object/module.f.js";
-import { toArray } from "../../types/list/module.f.js";
+import { toCodePointList, fromCodePointList, stringToList, listToString, stringToCodePointList, codePointListToString } 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 { 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/module.f.js

@@ -3,10 +3,10 @@
  *
  * @module
  */
-import { flatMap, toArray } from "../../types/list/module.f.js";
-import { decoder, errorMask, isValidCodePoint } from "../code_point/module.f.js";
-import { msb, u8List, length } from "../../types/bit_vec/module.f.js";
-import { codePointListToString } from "../utf16/module.f.js";
+import { flatMap, toArray } from '../../types/list/module.f.js';
+import { decoder, errorMask, isValidCodePoint } from '../code_point/module.f.js';
+import { msb, u8List, length } from '../../types/bit_vec/module.f.js';
+import { codePointListToString } from '../utf16/module.f.js';
 /**
  * UTF-8 byte-format constants. Each byte kind is defined by a tag — the fixed
  * high bits identifying the kind — and a payload mask selecting the code-point
@@ -36,6 +36,21 @@ const contByte = (x) => x & contMask | contTag;
  * Reads the six payload bits of a continuation byte.
  */
 const contPayload = (b) => b & contMask;
+/**
+ * The valid lead-byte range for 2-, 3-, and 4-byte sequences (RFC 3629);
+ * excludes overlong 2-byte leads (`C0`, `C1`) and leads above `U+10FFFF` (`F5`-`F7`).
+ */
+const leadMin = 0b1100_0010;
+const leadMax = 0b1111_0100;
+const isLeadByte = (b) => b >= leadMin && b <= leadMax;
+/**
+ * Dispatches a fresh-state byte, emitting `prefix` ahead of whatever the byte
+ * itself produces. Shared by the `state === null` arm and by error recovery
+ * after {@link utf8StateToError}, which differ only in `prefix`.
+ */
+const restart = (prefix) => (byte) => byte < contTag ? [[...prefix, byte], null]
+    : isLeadByte(byte) ? [[...prefix], [byte]]
+        : [[...prefix, byte | errorMask], null];
 /**
  * Converts a Unicode code point to a sequence of UTF-8 bytes.
  * @param input The Unicode code point to be converted. Valid range:
@@ -151,13 +166,8 @@ export const utf8ByteToCodePointOp = (byte, state) => {
     if (byte < 0x00 || byte > 0xff) {
         return [[errorMask], state];
     }
-    if (state === null) {
-        if (byte < contTag)
-            return [[byte], null];
-        if (byte >= 0b1100_0010 && byte <= 0b1111_0100)
-            return [[], [byte]];
-        return [[byte | errorMask], null];
-    }
+    if (state === null)
+        return restart([])(byte);
     if (byte >= contTag && byte < lead2Tag) {
         switch (state.length) {
             case 1: {
@@ -197,12 +207,7 @@ export const utf8ByteToCodePointOp = (byte, state) => {
             }
         }
     }
-    const error = utf8StateToError(state);
-    if (byte < contTag)
-        return [[error, byte], null];
-    if (byte >= 0b1100_0010 && byte <= 0b1111_0100)
-        return [[error], [byte]];
-    return [[error, byte | errorMask], null];
+    return restart([utf8StateToError(state)])(byte);
 };
 /**
  * Handles the end-of-file (EOF) case for UTF-8 decoding.

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

@@ -1,237 +1,175 @@
-import { toCodePointList, fromCodePointList, fromVec } from "./module.f.js";
-import { stringify as jsonStringify } from "../../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 { 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, 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/module.f.js

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { fromUndefined, map } from "../nullable/module.f.js";
+import { fromUndefined, map } from '../nullable/module.f.js';
 export const isArray = (value) => value instanceof Array;
 /**
  * Currently, TypeScript can't narrow the type of `readonly T[]` to `Array2<T>`