functionalscript 0.36.0 → 0.38.0

package/{fs → fjs}/sul/id/module.f.js

@@ -5,15 +5,15 @@
  *
  * @module
  */
-import { toArray } from "../../types/list/module.f.js";
-import { length, msb, uint, uintChunkList, unpack, vec } from "../../types/bit_vec/module.f.js";
-import { assertEq } from "../../asserts/module.f.js";
-import { utf8 } from "../../text/module.f.js";
-import { secp256r1 } from "../../crypto/secp/module.f.js";
-import { base32 } from "../../crypto/sha2/module.f.js";
-import { literal3ToVec } from "../level/literal/module.f.js";
-import { log2 } from "../../types/bigint/module.f.js";
-import { asBase, asNominal } from "../../types/nominal/module.f.js";
+import { toArray } from '../../types/list/module.f.js';
+import { length, msb, uint, uintChunkList, unpack, vec } from '../../types/bit_vec/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
+import { utf8 } from '../../text/module.f.js';
+import { secp256r1 } from '../../crypto/secp/module.f.js';
+import { base32 } from '../../crypto/sha2/module.f.js';
+import { literal3ToVec } from '../level/literal/module.f.js';
+import { log2 } from '../../types/bigint/module.f.js';
+import { asBase, asNominal } from '../../types/nominal/module.f.js';
 // 32 bytes = 256 bits.
 //
 //              0               1

package/{fs → fjs}/sul/id/proof.f.js

@@ -1,8 +1,8 @@
-import { assert, assertEq } from "../../asserts/module.f.js";
-import { mask } from "../../types/bigint/module.f.js";
-import { vec } from "../../types/bit_vec/module.f.js";
-import { compress, hashId, isHash, isRaw, level3Id, rawId } from "./module.f.js";
-import { asBase } from "../../types/nominal/module.f.js";
+import { assert, assertEq } from '../../asserts/module.f.js';
+import { mask } from '../../types/bigint/module.f.js';
+import { vec } from '../../types/bit_vec/module.f.js';
+import { compress, hashId, isHash, isRaw, level3Id, rawId } from './module.f.js';
+import { asBase } from '../../types/nominal/module.f.js';
 // literal3ToVec bit patterns for symbols used below:
 //   0  → vec(8n)(0n)     4  → vec(8n)(3n)
 //   1  → vec(8n)(1n)     10 → vec(8n)(5n)
@@ -28,9 +28,7 @@ export const proof = {
     inline_is_raw: () => assert(isRaw(compress(level3Id(0x00n), level3Id(0x00n)))),
     // Non-commutativity: argument order is preserved in concatenation
     non_commutative: () => {
-        if (compress(level3Id(0n), level3Id(1n)) === compress(level3Id(1n), level3Id(0n))) {
-            throw compress(level3Id(0n), level3Id(1n));
-        }
+        assert(compress(level3Id(0n), level3Id(1n)) !== compress(level3Id(1n), level3Id(0n)), compress(level3Id(0n), level3Id(1n)));
     },
     // Overflow: two 127-bit raw payloads sum to 254 bits, exceeding the 253-bit inline limit
     overflow_is_hash: () => assert(isHash(overflowHash)),
@@ -38,38 +36,26 @@ export const proof = {
     hash_left_is_hash: () => assert(isHash(compress(overflowHash, level3Id(0n)))),
     hash_right_is_hash: () => assert(isHash(compress(level3Id(0n), overflowHash))),
     hash_non_commutative: () => {
-        if (compress(overflowHash, level3Id(0n)) === compress(level3Id(0n), overflowHash)) {
-            throw compress(overflowHash, level3Id(0n));
-        }
+        assert(compress(overflowHash, level3Id(0n)) !== compress(level3Id(0n), overflowHash), compress(overflowHash, level3Id(0n)));
     },
     // High-bit sensitivity: prefix bit of `a` is included in the SHA2 upper half
     hash_merge_a_high_bits: () => {
-        if (compress(hashId(0n), hashId(0n)) === compress(level3Id(0n), hashId(0n))) {
-            throw compress(hashId(0n), hashId(0n));
-        }
+        assert(compress(hashId(0n), hashId(0n)) !== compress(level3Id(0n), hashId(0n)), compress(hashId(0n), hashId(0n)));
     },
     // High-bit sensitivity: prefix bit of `b` is included in the SHA2 lower half
     hash_merge_b_high_bits: () => {
-        if (compress(hashId(0n), hashId(0n)) === compress(hashId(0n), level3Id(0n))) {
-            throw compress(hashId(0n), hashId(0n));
-        }
+        assert(compress(hashId(0n), hashId(0n)) !== compress(hashId(0n), level3Id(0n)), compress(hashId(0n), hashId(0n)));
     },
     // Shift correctness: changing a bit in `a` (upper 256 bits of SHA2 input) changes result
     hash_merge_a_sensitivity: () => {
-        if (compress(hFF, hFF) === compress(hFE, hFF)) {
-            throw compress(hFF, hFF);
-        }
+        assert(compress(hFF, hFF) !== compress(hFE, hFF), compress(hFF, hFF));
     },
     // Shift correctness: changing a bit in `b` (lower 256 bits of SHA2 input) changes result
     hash_merge_b_sensitivity: () => {
-        if (compress(hFF, hFF) === compress(hFF, hFE)) {
-            throw compress(hFF, hFF);
-        }
+        assert(compress(hFF, hFF) !== compress(hFF, hFE), compress(hFF, hFF));
     },
     // Shift correctness: same bit-flip in `a` vs `b` lands at different SHA2 input positions
     hash_merge_shift: () => {
-        if (compress(hFE, hFF) === compress(hFF, hFE)) {
-            throw compress(hFE, hFF);
-        }
+        assert(compress(hFE, hFF) !== compress(hFF, hFE), compress(hFE, hFF));
     },
 };

package/{fs → fjs}/sul/level/hash/module.f.js

@@ -3,9 +3,9 @@
  *
  * @module
  */
-import { emptyState, patriciaTrie } from "../../../types/patricia_trie/module.f.js";
-import { compress } from "../../id/module.f.js";
-import { asBase } from "../../../types/nominal/module.f.js";
+import { emptyState, patriciaTrie } from '../../../types/patricia_trie/module.f.js';
+import { compress } from '../../id/module.f.js';
+import { asBase } from '../../../types/nominal/module.f.js';
 /**
  * Returns a streaming encoder for hash-level symbols.
  *

package/{fs → fjs}/sul/level/hash/proof.f.js

@@ -1,6 +1,6 @@
-import { assert, assertEq } from "../../../asserts/module.f.js";
-import { compress, level3Id } from "../../id/module.f.js";
-import { emptyEncodeState, encode } from "./module.f.js";
+import { assert, assertEq } from '../../../asserts/module.f.js';
+import { compress, level3Id } from '../../id/module.f.js';
+import { emptyEncodeState, encode } from './module.f.js';
 const add = (l, r, m, isSymbol, s) => [...s, [l, r, m, isSymbol]];
 const enc = encode(add);
 const initial = emptyEncodeState([]);
@@ -42,9 +42,9 @@ export const proof = {
     // All symbols before the terminator return undefined
     intermediate_undefined: () => {
         const [r0, st0] = enc(s1, initial);
-        assert(r0 === undefined);
+        assertEq(r0, undefined);
         const [r1, st1] = enc(s0, st0);
-        assert(r1 === undefined);
+        assertEq(r1, undefined);
         const [r2] = enc(s1, st1);
         assert(r2 !== undefined);
     },
@@ -100,13 +100,13 @@ export const proof = {
     // Trie-internal merges have isSymbol=false; only the terminal merge has isSymbol=true
     isSymbol_terminal_only: () => {
         const [, storage] = runWord([s1, s0, s0]);
-        assert(storage[0][3] === false); // Patricia trie merge
-        assert(storage[1][3] === true); // terminal compress(root, t)
+        assertEq(storage[0][3], false); // Patricia trie merge
+        assertEq(storage[1][3], true); // terminal compress(root, t)
     },
     // Single-step word: no trie merges, exactly one isSymbol=true
     isSymbol_min_word: () => {
         const [, storage] = runWord([s0, s0]);
         assertEq(storage.length, 1);
-        assert(storage[0][3] === true);
+        assertEq(storage[0][3], true);
     },
 };

package/{fs → fjs}/sul/level/literal/module.f.js

@@ -4,11 +4,11 @@
  *
  * @module
  */
-import { log2 } from "../../../types/bigint/module.f.js";
-import { msb, vec } from "../../../types/bit_vec/module.f.js";
-import { strictEqual } from "../../../types/function/operator/module.f.js";
-import { equal, map } from "../../../types/list/module.f.js";
-import { join } from "../../../types/string/module.f.js";
+import { log2 } from '../../../types/bigint/module.f.js';
+import { msb, vec } from '../../../types/bit_vec/module.f.js';
+import { strictEqual } from '../../../types/function/operator/module.f.js';
+import { equal, map } from '../../../types/list/module.f.js';
+import { join } from '../../../types/string/module.f.js';
 export const symbolToString = (s) => s.toString(16);
 export const wordToString = (word) => join(',')(map(symbolToString)(word));
 export const wordEqual = equal(strictEqual);

package/{fs → fjs}/sul/level/literal/proof.f.js

@@ -1,6 +1,7 @@
-import { chunkList, msb, vec } from "../../../types/bit_vec/module.f.js";
-import { map, stateScan, toArray } from "../../../types/list/module.f.js";
-import { emptyEncodeState, emptyPipelineState, level, literal1ToVec, literal2ToVec, literal3ToVec, pipelineStep, symbolToString, wordEqual, wordToString } from "./module.f.js";
+import { chunkList, msb, vec } from '../../../types/bit_vec/module.f.js';
+import { assert, assertEq } from '../../../asserts/module.f.js';
+import { map, stateScan, toArray } from '../../../types/list/module.f.js';
+import { emptyEncodeState, emptyPipelineState, level, literal1ToVec, literal2ToVec, literal3ToVec, pipelineStep, symbolToString, wordEqual, wordToString } from './module.f.js';
 const tests = (n) => {
     const { sum, decode, encode: push } = level(n);
     return {
@@ -18,33 +19,24 @@ const tests = (n) => {
             }
             // encode
             const a = toArray(stateScan(push)(emptyEncodeState)(word));
-            if (!a.slice(0, -1).every(i => i === undefined)) {
-                throw a;
-            }
+            assert(a.slice(0, -1).every(i => i === undefined), a);
             const x = a.at(-1);
-            if (x !== expected) {
-                throw x;
-            }
+            assertEq(x, expected);
         }
     };
 };
 const l = (f) => (l, e) => {
     const result = f(l);
-    if (result !== e) {
-        throw [result, e];
-    }
+    assertEq(result, e, [result, e]);
 };
 const vecToBits = (v) => map((b) => msb.front(1n)(b))(chunkList(msb)(1n)(v));
 const w = (symbol, expected) => {
     const result = literal3ToVec(symbol);
-    if (result !== expected)
-        throw [result, expected];
+    assertEq(result, expected, [result, expected]);
     const a = toArray(stateScan(pipelineStep)(emptyPipelineState)(vecToBits(expected)));
-    if (!a.slice(0, -1).every(o => o === undefined))
-        throw a;
+    assert(a.slice(0, -1).every(o => o === undefined), a);
     const out = a.at(-1);
-    if (out !== symbol)
-        throw out;
+    assertEq(out, symbol);
 };
 export const proof = {
     x2: () => {
@@ -688,9 +680,7 @@ export const proof = {
     },
     wordToString: () => {
         const result = wordToString([0n, 1n, 0xabn]);
-        if (result !== '0,1,ab') {
-            throw result;
-        }
+        assertEq(result, '0,1,ab');
     },
     pipeline: () => {
         // 4 L1 [0,0] words → 2 L2 [0,0] words → L3 [0,0] word → symbol 0
@@ -698,14 +688,12 @@ export const proof = {
         let s = emptyPipelineState;
         for (let i = 0; i < 7; i++) {
             const [out, next] = pipelineStep(0n, s);
-            if (out !== undefined)
-                throw out;
+            assertEq(out, undefined);
             s = next;
         }
         // 8th zero emits L3 symbol 0
         const [out0, s2] = pipelineStep(0n, s);
-        if (out0 !== 0n)
-            throw out0;
+        assertEq(out0, 0n);
         // state resets after emit: second batch of 8 zeros also emits 0
         let s3 = s2;
         for (let i = 0; i < 7; i++) {
@@ -713,8 +701,7 @@ export const proof = {
             s3 = next;
         }
         const [out1] = pipelineStep(0n, s3);
-        if (out1 !== 0n)
-            throw out1;
+        assertEq(out1, 0n);
         // 8 ones emit a different symbol than 8 zeros
         let s4 = emptyPipelineState;
         for (let i = 0; i < 7; i++) {
@@ -722,7 +709,6 @@ export const proof = {
             s4 = next;
         }
         const [out2] = pipelineStep(1n, s4);
-        if (out2 === 0n)
-            throw out2;
+        assert(out2 !== 0n, out2);
     }
 };

package/{fs → fjs}/sul/module.f.js

@@ -4,9 +4,9 @@
  *
  * @module
  */
-import { emptyPipelineState, pipelineStep } from "./level/literal/module.f.js";
-import { encode as hashEncode } from "./level/hash/module.f.js";
-import { level3Id } from "./id/module.f.js";
+import { emptyPipelineState, pipelineStep } from './level/literal/module.f.js';
+import { encode as hashEncode } from './level/hash/module.f.js';
+import { level3Id } from './id/module.f.js';
 export const emptyEncodeState = (storage) => [emptyPipelineState, storage, []];
 export const encode = (add) => {
     const step = hashEncode(add);

package/{fs → fjs}/sul/proof.f.js

@@ -1,6 +1,6 @@
-import { assert, assertEq } from "../asserts/module.f.js";
-import { compress } from "./id/module.f.js";
-import { encode, emptyEncodeState } from "./module.f.js";
+import { assert, assertEq } from '../asserts/module.f.js';
+import { compress } from './id/module.f.js';
+import { encode, emptyEncodeState } from './module.f.js';
 const run = (bits) => {
     const log = [];
     const add = (l, r, m, isSymbol) => { log.push([l, r, m, isSymbol]); return null; };

package/fjs/text/ascii/proof.f.d.ts

@@ -0,0 +1,6 @@
+export declare const proof: {
+    range: () => void;
+    throw: {
+        oneThrowsOnEmpty: () => number;
+    };
+};

package/fjs/text/ascii/proof.f.js

@@ -0,0 +1,14 @@
+import { one, range } from './module.f.js';
+import { stringify as jsonStringify } from '../../media/json/module.f.js';
+import { sort } from '../../types/object/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
+const stringify = jsonStringify(sort);
+export const proof = {
+    range: () => {
+        const r = stringify(range("A"));
+        assertEq(r, '[65,65]');
+    },
+    throw: {
+        oneThrowsOnEmpty: () => one(''),
+    },
+};

package/{fs → fjs}/text/code_point/module.f.js

@@ -8,8 +8,8 @@
  *
  * @module
  */
-import { flat, stateScan } from "../../types/list/module.f.js";
-import { contains } from "../../types/range/module.f.js";
+import { flat, stateScan } from '../../types/list/module.f.js';
+import { contains } from '../../types/range/module.f.js';
 /**
  * Error mask used to tag invalid code points or encoding errors. A decoded
  * value with this bit set represents a malformed unit rather than a valid
@@ -48,18 +48,18 @@ const maxCodePoint = 0x10_ffff;
  * Checks whether the 16-bit word (U16) is a high surrogate.
  * Range: 0xD800 - 0xDBFF.
  */
-export const isHighSurrogate = contains([surrogateMin, lowSurrogateMin - 1]);
+export const isHighSurrogate = contains(surrogateMin, lowSurrogateMin - 1);
 /**
  * Checks whether the 16-bit word (U16) is a low surrogate.
  * Range: 0xDC00 - 0xDFFF.
  */
-export const isLowSurrogate = contains([lowSurrogateMin, surrogateMax]);
+export const isLowSurrogate = contains(lowSurrogateMin, surrogateMax);
 /**
  * Ranges of code points for the lower (Low) and higher (High) parts of the BMP
  * (Basic Multilingual Plane), i.e. the BMP with the surrogate block removed.
  */
-const lowBmp = contains([0x0000, surrogateMin - 1]);
-const highBmp = contains([surrogateMax + 1, bmpMax]);
+const lowBmp = contains(0x0000, surrogateMin - 1);
+const highBmp = contains(surrogateMax + 1, bmpMax);
 /**
  * Checks whether the code point is in the BMP range.
  * BMP is the main Unicode plane that covers code points 0x0000 - 0xFFFF, except
@@ -70,13 +70,13 @@ export const isBmpCodePoint = (codePoint) => lowBmp(codePoint) || highBmp(codePo
  * Checks whether the code point belongs to a supplementary (additional) Unicode
  * plane. Supplementary planes cover code points from 0x010000 to 0x10FFFF.
  */
-export const isSupplementaryPlane = contains([bmpMax + 1, maxCodePoint]);
+export const isSupplementaryPlane = contains(bmpMax + 1, maxCodePoint);
 /**
  * The full assignable code-point range and the surrogate block, used to gate
  * overall validity below.
  */
-const validRange = contains([0, maxCodePoint]);
-const isSurrogate = contains([surrogateMin, surrogateMax]);
+const validRange = contains(0, maxCodePoint);
+const isSurrogate = contains(surrogateMin, surrogateMax);
 /**
  * Checks whether the code point is a valid scalar value: within the assignable
  * Unicode range (0x0000 - 0x10FFFF) and not a surrogate.
@@ -89,9 +89,9 @@ export const isValidCodePoint = (c) => validRange(c) && !isSurrogate(c);
  * contiguous run; the whitespace block 0x0009 - 0x000D (TAB, LF, VT, FF, CR) is
  * the only control range legitimate in text.
  */
-const c0Control = contains([0x00, 0x1f]);
-const delAndC1Control = contains([0x7f, 0x9f]);
-const textWhitespace = contains([0x09, 0x0d]);
+const c0Control = contains(0x00, 0x1f);
+const delAndC1Control = contains(0x7f, 0x9f);
+const textWhitespace = contains(0x09, 0x0d);
 /**
  * Checks whether the code point is a *text* code point — distinct from
  * {@link isValidCodePoint}, which gates well-formedness for decoding. A code

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

@@ -1,4 +1,4 @@
-import { isBmpCodePoint, isHighSurrogate, isLowSurrogate, isSupplementaryPlane, isTextCodePoint, isValidCodePoint, } from "./module.f.js";
+import { isBmpCodePoint, isHighSurrogate, isLowSurrogate, isSupplementaryPlane, isTextCodePoint, isValidCodePoint, } from './module.f.js';
 const check = (actual, expected) => {
     if (actual !== expected) {
         throw `${actual} !== ${expected}`;

package/{fs → fjs}/text/module.f.js

@@ -5,11 +5,11 @@
  *
  * @module
  */
-import { msb, tryU8ListToVec, u8List } from "../types/bit_vec/module.f.js";
-import { flatMap } from "../types/list/module.f.js";
-import { fromCodePointList, toCodePointList } from "./utf8/module.f.js";
-import { stringToCodePointList, codePointListToString } from "./utf16/module.f.js";
-import { mapUnwrap } from "../types/nullable/module.f.js";
+import { msb, tryU8ListToVec, u8List } from '../types/bit_vec/module.f.js';
+import { flatMap } from '../types/list/module.f.js';
+import { fromCodePointList, toCodePointList } from './utf8/module.f.js';
+import { stringToCodePointList, codePointListToString } from './utf16/module.f.js';
+import { mapUnwrap } from '../types/nullable/module.f.js';
 export const flat = (indent) => {
     const f = (prefix) => {
         const g = (item) => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item);

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

@@ -1,7 +1,7 @@
-import { assert, assertEq } from "../asserts/module.f.js";
-import { flat, utf8, utf8ToString, tryUtf8 } from "./module.f.js";
-import { join } from "../types/string/module.f.js";
-import { empty, maxLengthBytes } from "../types/bit_vec/module.f.js";
+import { assertEq, assertNotNullish } from '../asserts/module.f.js';
+import { flat, utf8, utf8ToString, tryUtf8 } from './module.f.js';
+import { join } from '../types/string/module.f.js';
+import { empty, maxLengthBytes } from '../types/bit_vec/module.f.js';
 const overflowStr = 'a'.repeat(Number(maxLengthBytes) + 1);
 export const proof = {
     block: () => {
@@ -15,20 +15,15 @@ export const proof = {
             'e',
         ];
         const result = join('\n')(flat(':')(text));
-        if (result !== 'a\nb\n:c\n::d\ne') {
-            throw result;
-        }
+        assertEq(result, 'a\nb\n:c\n::d\ne');
     },
     encoding: () => {
         const v = utf8('Hello world!');
         const r = utf8ToString(v);
-        if (r !== 'Hello world!') {
-            throw r;
-        }
+        assertEq(r, 'Hello world!');
     },
     tryUtf8RoundTrip: () => {
-        const v = tryUtf8('Hello world!');
-        assert(v !== null);
+        const v = assertNotNullish(tryUtf8('Hello world!'));
         assertEq(v, utf8('Hello world!'));
         assertEq(utf8ToString(v), 'Hello world!');
     },

package/{fs → fjs}/text/sgr/module.f.js

@@ -6,8 +6,8 @@
  */
 // C0 control codes
 // https://en.wikipedia.org/wiki/ANSI_escape_code#C0_control_codes
-import { write } from "../../effects/node/module.f.js";
-import {} from "../../effects/module.f.js";
+import { write } from '../../effects/node/module.f.js';
+import {} from '../../effects/module.f.js';
 import { utf8 } from "../module.f.js";
 export const backspace = '\x08';
 const begin = '\x1b[';

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

@@ -1,42 +1,33 @@
-import { fgRed, reset, createConsoleText, backspace, csiWrite } from "./module.f.js";
-import { virtual, emptyState, defaultNodeProgramOptions } from "../../effects/node/virtual/module.f.js";
+import { fgRed, reset, createConsoleText, backspace, csiWrite } from './module.f.js';
+import { virtual, emptyState, defaultNodeProgramOptions } from '../../effects/node/virtual/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 const makeOptions = (isTTY) => ({ ...defaultNodeProgramOptions, std: { stdout: { isTTY }, stderr: { isTTY } } });
 export const proof = [
     () => {
-        if (fgRed !== '\x1b[31m') {
-            throw new Error('Test failed: sgr(0)');
-        }
+        assertEq(fgRed, '\x1b[31m', new Error('Test failed: sgr(0)'));
     },
     () => {
         const output = [];
         const stdout = { write: (s) => { output.push(s); } };
         const writer1 = createConsoleText(stdout);
         const writer2 = writer1('hello');
-        if (output[0] !== 'hello') {
-            throw output[0];
-        }
+        assert(output[0] === 'hello');
         // replacing 'hello' (len=5) with 'hi' (len=2): suffixLength=3
         writer2('hi');
         const expected = backspace.repeat(5) + 'hi' + ' '.repeat(3) + backspace.repeat(3);
-        if (output[1] !== expected) {
-            throw output[1];
-        }
+        assertEq(output[1], expected);
     },
     () => {
         // csiWrite with isTTY=false strips ANSI SGR sequences
         const writeFn = csiWrite(makeOptions(false))('stdout');
         const [state] = virtual(emptyState)(writeFn(fgRed + 'hello' + reset));
-        if (state.stdout !== 'hello') {
-            throw ['expected ANSI stripped', state.stdout];
-        }
+        assertEq(state.stdout, 'hello', ['expected ANSI stripped', state.stdout]);
     },
     () => {
         // csiWrite with isTTY=true preserves ANSI SGR sequences
         const writeFn = csiWrite(makeOptions(true))('stdout');
         const [state] = virtual(emptyState)(writeFn(fgRed + 'hello' + reset));
         const expected = fgRed + 'hello' + reset;
-        if (state.stdout !== expected) {
-            throw ['expected ANSI preserved', state.stdout];
-        }
+        assertEq(state.stdout, expected, ['expected ANSI preserved', state.stdout]);
     },
 ];

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

@@ -5,11 +5,11 @@
  *
  * @module
  */
-import { map, reduce, flatMap, empty, } from "../../types/list/module.f.js";
-import { concat } from "../../types/function/operator/module.f.js";
-import { contains } from "../../types/range/module.f.js";
-import { fn } from "../../types/function/module.f.js";
-import { decoder, errorMask, isBmpCodePoint, isHighSurrogate, isLowSurrogate, isSupplementaryPlane, } from "../code_point/module.f.js";
+import { map, reduce, flatMap, empty, } from '../../types/list/module.f.js';
+import { concat } from '../../types/function/operator/module.f.js';
+import { contains } from '../../types/range/module.f.js';
+import { fn } from '../../types/function/module.f.js';
+import { decoder, errorMask, isBmpCodePoint, isHighSurrogate, isLowSurrogate, isSupplementaryPlane, } from '../code_point/module.f.js';
 /**
  * The BMP / surrogate / supplementary-plane predicates used below live in
  * `code_point`, the shared Unicode contract; see that module for their ranges.
@@ -107,7 +107,7 @@ export const fromCodePointList = flatMap(codePointToUtf16);
  * const edgeCaseHigh = u16(0xFFFF)  // true: Maximum valid value for UTF-16
  * ```
  */
-const u16 = contains([0x0000, 0xFFFF]);
+const u16 = contains(0x0000, 0xFFFF);
 /**
  * A stateful operation that converts a UTF-16 word (U16) to a list of Unicode code points (CodePoint),
  * while maintaining the state of surrogate pair decoding.