functionalscript 0.33.0 → 0.35.0

package/fs/text/code_point/module.f.d.ts

@@ -1,8 +1,10 @@
 /**
  * Shared Unicode code-point contract for the UTF-8 and UTF-16 decoders: the
- * error-tag mask used to flag invalid sequences, and a streaming `decoder`
+ * error-tag mask used to flag invalid sequences, the streaming `decoder`
  * factory that wraps a per-unit step and an end-of-input step into a single
- * `List`-to-`List` conversion.
+ * `List`-to-`List` conversion, and the code-point classification predicates
+ * (BMP / surrogate / supplementary-plane / overall validity) that both codecs
+ * share.
  *
  * @module
  */
@@ -26,3 +28,38 @@ export declare const errorMask = 2147483648;
  * @returns A function converting a list of code units into a list of code points.
  */
 export declare const decoder: <Unit, S, Cp>(byteOp: StateScan<Unit, S | null, List<Cp>>, eofOp: (state: S | null) => readonly [List<Cp>, S | null]) => (input: List<Unit>) => List<Cp>;
+/**
+ * Checks whether the 16-bit word (U16) is a high surrogate.
+ * Range: 0xD800 - 0xDBFF.
+ */
+export declare const isHighSurrogate: (i: number) => boolean;
+/**
+ * Checks whether the 16-bit word (U16) is a low surrogate.
+ * Range: 0xDC00 - 0xDFFF.
+ */
+export declare const isLowSurrogate: (i: number) => boolean;
+/**
+ * Checks whether the code point is in the BMP range.
+ * BMP is the main Unicode plane that covers code points 0x0000 - 0xFFFF, except
+ * for the range of surrogates.
+ */
+export declare const isBmpCodePoint: (codePoint: number) => boolean;
+/**
+ * Checks whether the code point belongs to a supplementary (additional) Unicode
+ * plane. Supplementary planes cover code points from 0x010000 to 0x10FFFF.
+ */
+export declare const isSupplementaryPlane: (i: number) => boolean;
+/**
+ * Checks whether the code point is a valid scalar value: within the assignable
+ * Unicode range (0x0000 - 0x10FFFF) and not a surrogate.
+ */
+export declare const isValidCodePoint: (c: number) => boolean;
+/**
+ * Checks whether the code point is a *text* code point — distinct from
+ * {@link isValidCodePoint}, which gates well-formedness for decoding. A code
+ * point is text unless it is a control character: the controls are 0x0000 -
+ * 0x001F, 0x007F (DEL), and 0x0080 - 0x009F (C1), minus the whitespace block
+ * 0x0009 - 0x000D (TAB, LF, VT, FF, CR), which is legitimate in text. Every
+ * code point at or above 0x0020 that is not DEL or a C1 control is text.
+ */
+export declare const isTextCodePoint: (c: number) => boolean;

package/fs/text/code_point/module.f.js

@@ -1,12 +1,15 @@
 /**
  * Shared Unicode code-point contract for the UTF-8 and UTF-16 decoders: the
- * error-tag mask used to flag invalid sequences, and a streaming `decoder`
+ * error-tag mask used to flag invalid sequences, the streaming `decoder`
  * factory that wraps a per-unit step and an end-of-input step into a single
- * `List`-to-`List` conversion.
+ * `List`-to-`List` conversion, and the code-point classification predicates
+ * (BMP / surrogate / supplementary-plane / overall validity) that both codecs
+ * share.
  *
  * @module
  */
 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
@@ -29,3 +32,72 @@ export const decoder = (byteOp, eofOp) => {
     const run = stateScan(op)(null);
     return input => flat(run(flat([input, [null]])));
 };
+/**
+ * Unicode code-point classification boundaries. The surrogate block
+ * (`0xD800`–`0xDFFF`) splits into a high half (`0xD800`–`0xDBFF`) and a low half
+ * (`0xDC00`–`0xDFFF`); the BMP ends at `0xFFFF` and `maxCodePoint` (`0x10FFFF`)
+ * is the largest assignable code point. Every predicate below is derived from
+ * these constants so the surrogate bounds and the maximum appear exactly once.
+ */
+const surrogateMin = 0xd800;
+const lowSurrogateMin = 0xdc00;
+const surrogateMax = 0xdfff;
+const bmpMax = 0xffff;
+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]);
+/**
+ * Checks whether the 16-bit word (U16) is a low surrogate.
+ * Range: 0xDC00 - 0xDFFF.
+ */
+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]);
+/**
+ * Checks whether the code point is in the BMP range.
+ * BMP is the main Unicode plane that covers code points 0x0000 - 0xFFFF, except
+ * for the range of surrogates.
+ */
+export const isBmpCodePoint = (codePoint) => lowBmp(codePoint) || highBmp(codePoint);
+/**
+ * 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]);
+/**
+ * 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]);
+/**
+ * Checks whether the code point is a valid scalar value: within the assignable
+ * Unicode range (0x0000 - 0x10FFFF) and not a surrogate.
+ */
+export const isValidCodePoint = (c) => validRange(c) && !isSurrogate(c);
+/**
+ * The control-character blocks and the whitespace exception used to separate
+ * *text* code points from binary control bytes. C0 controls span 0x0000 -
+ * 0x001F; 0x007F (DEL) and the C1 controls (0x0080 - 0x009F) form one
+ * 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]);
+/**
+ * Checks whether the code point is a *text* code point — distinct from
+ * {@link isValidCodePoint}, which gates well-formedness for decoding. A code
+ * point is text unless it is a control character: the controls are 0x0000 -
+ * 0x001F, 0x007F (DEL), and 0x0080 - 0x009F (C1), minus the whitespace block
+ * 0x0009 - 0x000D (TAB, LF, VT, FF, CR), which is legitimate in text. Every
+ * code point at or above 0x0020 that is not DEL or a C1 control is text.
+ */
+export const isTextCodePoint = (c) => textWhitespace(c) || !(c0Control(c) || delAndC1Control(c));

package/fs/text/code_point/proof.f.d.ts

@@ -0,0 +1,8 @@
+export declare const proof: {
+    isHighSurrogate: (() => void)[];
+    isLowSurrogate: (() => void)[];
+    isBmpCodePoint: (() => void)[];
+    isSupplementaryPlane: (() => void)[];
+    isValidCodePoint: (() => void)[];
+    isTextCodePoint: (() => void)[];
+};

package/fs/text/code_point/proof.f.js

@@ -0,0 +1,72 @@
+import { isBmpCodePoint, isHighSurrogate, isLowSurrogate, isSupplementaryPlane, isTextCodePoint, isValidCodePoint, } from "./module.f.js";
+const check = (actual, expected) => {
+    if (actual !== expected) {
+        throw `${actual} !== ${expected}`;
+    }
+};
+export const proof = {
+    isHighSurrogate: [
+        () => check(isHighSurrogate(0xd800), true),
+        () => check(isHighSurrogate(0xdbff), true),
+        () => check(isHighSurrogate(0xd7ff), false),
+        () => check(isHighSurrogate(0xdc00), false),
+    ],
+    isLowSurrogate: [
+        () => check(isLowSurrogate(0xdc00), true),
+        () => check(isLowSurrogate(0xdfff), true),
+        () => check(isLowSurrogate(0xdbff), false),
+        () => check(isLowSurrogate(0xe000), false),
+    ],
+    isBmpCodePoint: [
+        // lowBmp branch true
+        () => check(isBmpCodePoint(0x0000), true),
+        () => check(isBmpCodePoint(0xd7ff), true),
+        // lowBmp false, highBmp true
+        () => check(isBmpCodePoint(0xe000), true),
+        () => check(isBmpCodePoint(0xffff), true),
+        // both false: surrogate and supplementary
+        () => check(isBmpCodePoint(0xd800), false),
+        () => check(isBmpCodePoint(0x10000), false),
+    ],
+    isSupplementaryPlane: [
+        () => check(isSupplementaryPlane(0x10000), true),
+        () => check(isSupplementaryPlane(0x10ffff), true),
+        () => check(isSupplementaryPlane(0xffff), false),
+        () => check(isSupplementaryPlane(0x110000), false),
+    ],
+    isValidCodePoint: [
+        // in range, not surrogate
+        () => check(isValidCodePoint(0x0000), true),
+        () => check(isValidCodePoint(0x10ffff), true),
+        // in range, surrogate -> invalid
+        () => check(isValidCodePoint(0xd800), false),
+        () => check(isValidCodePoint(0xdfff), false),
+        // out of range -> validRange short-circuits false
+        () => check(isValidCodePoint(-1), false),
+        () => check(isValidCodePoint(0x110000), false),
+    ],
+    isTextCodePoint: [
+        // C0 controls are binary...
+        () => check(isTextCodePoint(0x00), false), // NUL
+        () => check(isTextCodePoint(0x08), false), // BS
+        () => check(isTextCodePoint(0x1b), false), // ESC
+        () => check(isTextCodePoint(0x1f), false), // US
+        // ...except the whitespace block 0x09 - 0x0D
+        () => check(isTextCodePoint(0x09), true), // TAB
+        () => check(isTextCodePoint(0x0a), true), // LF
+        () => check(isTextCodePoint(0x0b), true), // VT
+        () => check(isTextCodePoint(0x0c), true), // FF
+        () => check(isTextCodePoint(0x0d), true), // CR
+        // printable ASCII is text
+        () => check(isTextCodePoint(0x20), true), // space
+        () => check(isTextCodePoint(0x41), true), // 'A'
+        () => check(isTextCodePoint(0x7e), true), // '~'
+        // DEL and the C1 controls are binary
+        () => check(isTextCodePoint(0x7f), false), // DEL
+        () => check(isTextCodePoint(0x80), false), // C1 start
+        () => check(isTextCodePoint(0x9f), false), // C1 end
+        // above C1 is text again
+        () => check(isTextCodePoint(0xa0), true), // NBSP
+        () => check(isTextCodePoint(0x10ffff), true),
+    ],
+};

package/fs/text/module.f.d.ts

@@ -7,19 +7,29 @@
  */
 import { type Vec } from '../types/bit_vec/module.f.ts';
 import { type List } from '../types/list/module.f.ts';
+import { type Nullable } from '../types/nullable/module.f.ts';
 export type Block = ItemThunk | ItemArray;
 type ItemArray = readonly Item[];
 type ItemThunk = () => List<Item>;
 export type Item = string | ItemArray | ItemThunk;
 export declare const flat: (indent: string) => (text: Block) => List<string>;
 export type Utf8 = Vec;
+/**
+ * Converts a string to an UTF-8, represented as an MSB first bit vector,
+ * returning `null` instead of throwing if the result would exceed
+ * `maxLength`.
+ *
+ * @param s The input string to be converted.
+ * @returns The resulting UTF-8 bit vector, MSB first, or `null` on overflow.
+ */
+export declare const tryUtf8: (s: string) => Nullable<Utf8>;
 /**
  * Converts a string to an UTF-8, represented as an MSB first bit vector.
  *
  * @param s The input string to be converted.
  * @returns The resulting UTF-8 bit vector, MSB first.
  */
-export declare const utf8: (s: string) => Utf8;
+export declare const utf8: import("../types/function/module.f.ts").Func<string, Vec>;
 /**
  * Converts a UTF-8 bit vector with MSB first encoding to a string.
  *

package/fs/text/module.f.js

@@ -5,10 +5,11 @@
  *
  * @module
  */
-import { msb, u8List, u8ListToVec } from "../types/bit_vec/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);
@@ -16,14 +17,23 @@ export const flat = (indent) => {
     };
     return f('');
 };
-const u8ListToVecMsb = u8ListToVec(msb);
+const tryU8ListToVecMsb = tryU8ListToVec(msb);
+/**
+ * Converts a string to an UTF-8, represented as an MSB first bit vector,
+ * returning `null` instead of throwing if the result would exceed
+ * `maxLength`.
+ *
+ * @param s The input string to be converted.
+ * @returns The resulting UTF-8 bit vector, MSB first, or `null` on overflow.
+ */
+export const tryUtf8 = (s) => tryU8ListToVecMsb(fromCodePointList(stringToCodePointList(s)));
 /**
  * Converts a string to an UTF-8, represented as an MSB first bit vector.
  *
  * @param s The input string to be converted.
  * @returns The resulting UTF-8 bit vector, MSB first.
  */
-export const utf8 = (s) => u8ListToVecMsb(fromCodePointList(stringToCodePointList(s)));
+export const utf8 = mapUnwrap(tryUtf8);
 /**
  * Converts a UTF-8 bit vector with MSB first encoding to a string.
  *

package/fs/text/proof.f.d.ts

@@ -1,4 +1,10 @@
 export declare const proof: {
     block: () => void;
     encoding: () => void;
+    tryUtf8RoundTrip: () => void;
+    tryUtf8Empty: () => void;
+    tryUtf8Overflow: {
+        try: () => void;
+        throw: () => void;
+    };
 };

package/fs/text/proof.f.js

@@ -1,5 +1,8 @@
-import { flat, utf8, utf8ToString } from "./module.f.js";
+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";
+const overflowStr = 'a'.repeat(Number(maxLengthBytes) + 1);
 export const proof = {
     block: () => {
         const text = [
@@ -22,5 +25,25 @@ export const proof = {
         if (r !== 'Hello world!') {
             throw r;
         }
-    }
+    },
+    tryUtf8RoundTrip: () => {
+        const v = tryUtf8('Hello world!');
+        assert(v !== null);
+        assertEq(v, utf8('Hello world!'));
+        assertEq(utf8ToString(v), 'Hello world!');
+    },
+    tryUtf8Empty: () => {
+        assertEq(tryUtf8(''), empty);
+    },
+    tryUtf8Overflow: {
+        // One byte past `maxLengthBytes`; `tryUtf8` should report `null`
+        // instead of building an oversized `bigint`, and the throwing `utf8`
+        // wrapper should raise on the same input.
+        try: () => {
+            assertEq(tryUtf8(overflowStr), null);
+        },
+        throw: () => {
+            utf8(overflowStr);
+        },
+    },
 };

package/fs/text/utf16/module.f.js

@@ -9,33 +9,11 @@ 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 } from "../code_point/module.f.js";
-/**
- * Ranges of code points for the lower (Low) and higher (High) parts of the BMP (Basic Multilingual Plane) plane.
- */
-const lowBmp = contains([0x0000, 0xd7ff]);
-const highBmp = contains([0xe000, 0xffff]);
-/**
- * Checks whether the code point is in the BMP range.
- * BMP is the main multi-plane Unicode plane that covers code points 0x0000 - 0xFFFF, except for the range of surrogates.
- */
-const isBmpCodePoint = (codePoint) => lowBmp(codePoint) || highBmp(codePoint);
-/**
- * Checks whether the 16-bit word (U16) is a surrogate of the high part.
- * Range: 0xD800 - 0xDBFF.
- */
-const isHighSurrogate = contains([0xd800, 0xdbff]);
-/**
- * Checks whether the 16-bit word (U16) is a substitute for the low part.
- * Range: 0xDC00 – 0xDFFF.
- */
-const isLowSurrogate = contains([0xdc00, 0xdfff]);
-/**
- * Checks whether the code point belongs to the additional (Supplementary) plane of Unicode.
- * Additional planes include code points from 0x010000 to 0x10FFFF.
- */
-const isSupplementaryPlane = contains([0x01_0000, 0x10_ffff]);
+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.
+ *
  * Converts a Unicode code point to its corresponding UTF-16 representation.
  *
  * This function handles:

package/fs/text/utf8/module.f.d.ts

@@ -4,6 +4,7 @@
  * @module
  */
 import { type List, type Thunk } from '../../types/list/module.f.ts';
+import type { StateScan } from '../../types/function/operator/module.f.ts';
 import type { Array1, Array2, Array3 } from '../../types/array/module.f.ts';
 import { type Vec } from '../../types/bit_vec/module.f.ts';
 /**
@@ -35,6 +36,32 @@ export type Utf8State = null | Utf8NonEmptyState;
  * @returns A thunk that lazily produces a sequence of UTF-8 bytes.
  */
 export declare const fromCodePointList: (input: List<number>) => Thunk<U8>;
+/**
+ * Converts a non-empty UTF-8 decoding state to an error code.
+ *
+ * @param state - A non-empty UTF-8 decoding state.
+ * @returns An I32 error code derived from the invalid UTF-8 state.
+ */
+export declare const utf8StateToError: (state: Utf8NonEmptyState) => I32;
+/**
+ * Decodes a byte into a Unicode code point, using a given UTF-8 state.
+ *
+ * @param state - The current UTF-8 decoding state.
+ * @param byte - A single byte to decode.
+ * @returns A tuple containing:
+ *   - A list of decoded Unicode code points or error codes.
+ *   - The updated UTF-8 state.
+ */
+export declare const utf8ByteToCodePointOp: StateScan<number, Utf8State, readonly I32[]>;
+/**
+ * Handles the end-of-file (EOF) case for UTF-8 decoding.
+ *
+ * @param state - The current UTF-8 decoding state.
+ * @returns A tuple containing:
+ *   - A list of decoded Unicode code points or error codes.
+ *   - The reset UTF-8 state (`null`).
+ */
+export declare const utf8EofToCodePointOp: (state: Utf8State) => readonly [List<I32>, Utf8State];
 /**
  * Converts a list of UTF-8 bytes into a list of Unicode code points.
  *

package/fs/text/utf8/module.f.js

@@ -4,7 +4,7 @@
  * @module
  */
 import { flatMap, toArray } from "../../types/list/module.f.js";
-import { decoder, errorMask } from "../code_point/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";
 /**
@@ -106,7 +106,7 @@ export const fromCodePointList = flatMap(codePointToUtf8);
  * @param state - A non-empty UTF-8 decoding state.
  * @returns An I32 error code derived from the invalid UTF-8 state.
  */
-const utf8StateToError = (state) => {
+export const utf8StateToError = (state) => {
     let x;
     switch (state.length) {
         case 1: {
@@ -127,8 +127,8 @@ const utf8StateToError = (state) => {
                 contPayload(s2) + 0b1000_0000_0000_0000;
             break;
         }
-        default:
-            throw 'invalid state';
+        //default:
+        //    throw 'invalid state'
     }
     return x | errorMask;
 };
@@ -141,7 +141,7 @@ const utf8StateToError = (state) => {
  *   - A list of decoded Unicode code points or error codes.
  *   - The updated UTF-8 state.
  */
-const utf8ByteToCodePointOp = (byte, state) => {
+export const utf8ByteToCodePointOp = (byte, state) => {
     if (byte < 0x00 || byte > 0xff) {
         return [[errorMask], state];
     }
@@ -199,7 +199,7 @@ const utf8ByteToCodePointOp = (byte, state) => {
  *   - A list of decoded Unicode code points or error codes.
  *   - The reset UTF-8 state (`null`).
  */
-const utf8EofToCodePointOp = (state) => [
+export const utf8EofToCodePointOp = (state) => [
     state === null ? null : [utf8StateToError(state)],
     null,
 ];
@@ -216,18 +216,12 @@ export const toCodePointList = decoder(utf8ByteToCodePointOp, utf8EofToCodePoint
  * code points.
  */
 export const fromVec = (v) => {
-    if (length(v) % 8n !== 0n) {
+    if ((length(v) & 7n) !== 0n) {
         return null;
     }
     const arr = toArray(toCodePointList(u8List(msb)(v)));
     for (const cp of arr) {
-        if (cp < 0) {
-            return null;
-        }
-        if (cp > 0x10FFFF) {
-            return null;
-        }
-        if (cp >= 0xD800 && cp <= 0xDFFF) {
+        if (!isValidCodePoint(cp)) {
             return null;
         }
     }

package/fs/types/bit_vec/module.f.d.ts

@@ -26,6 +26,7 @@ import type { Binary, Fold, Reduce as OpReduce } from '../function/operator/modu
 import { type List, type Thunk } from '../list/module.f.ts';
 import { type Nominal } from '../nominal/module.f.ts';
 import { type Sign } from '../function/compare/module.f.ts';
+import { type Nullable } from '../nullable/module.f.ts';
 /**
  * A vector of bits represented as a signed `bigint`.
  */
@@ -195,6 +196,12 @@ export type BitOrder = {
      * ```
      */
     readonly concat: Reduce;
+    /**
+     * Folds a list of vectors into a single vector in this bit order, like
+     * `listToVec`, but returns `null` instead of throwing when the combined
+     * length would exceed `maxLength`.
+     */
+    readonly tryListToVec: (list: List<Vec>) => Nullable<Vec>;
     /**
      * Folds a list of vectors into a single vector in this bit order.
      *
@@ -221,9 +228,10 @@ export type BitOrder = {
      */
     readonly cmp: (a: Vec) => (b: Vec) => Sign;
     readonly unpackSplit: (len: bigint) => (u: Unpacked) => readonly [bigint, bigint];
-    readonly unpackConcat: (a: Unpacked) => (b: Unpacked) => Unpacked;
+    readonly unpackConcat: UnpackConcat;
     readonly startsWith: (prefix: Vec) => (v: Vec) => boolean;
 };
+type UnpackConcat = (a: Unpacked) => (b: Unpacked) => Unpacked;
 /**
  * Implements operations for handling vectors in a least-significant-bit (LSb) first order.
  *
@@ -240,6 +248,16 @@ export declare const lsb: BitOrder;
  * Usually associated with Big-Endian (BE) byte order.
  */
 export declare const msb: BitOrder;
+/**
+ * Converts a list of unsigned 8-bit integers to a bit vector using the provided
+ * bit order, like `u8ListToVec`, but returns `null` instead of throwing when the
+ * result would exceed `maxLength`.
+ *
+ * @param bo The bit order for the conversion
+ * @param list The list of unsigned 8-bit integers to be converted.
+ * @returns The resulting vector, or `null` if it would exceed `maxLength`.
+ */
+export declare const tryU8ListToVec: ({ unpackConcat }: BitOrder) => (list: List<number>) => Nullable<Vec>;
 /**
  * Converts a list of unsigned 8-bit integers to a bit vector using the provided bit order.
  *
@@ -247,7 +265,7 @@ export declare const msb: BitOrder;
  * @param list The list of unsigned 8-bit integers to be converted.
  * @returns The resulting vector based on the provided bit order.
  */
-export declare const u8ListToVec: ({ unpackConcat }: BitOrder) => (list: List<number>) => Vec;
+export declare const u8ListToVec: (bo: BitOrder) => import("../function/module.f.ts").Func<List<number>, Vec>;
 /**
  * Chunks an unpacked vector into fixed-size pieces of `n` bits using the provided bit order,
  * returning each chunk as an unsigned integer.