functionalscript 0.44.0 → 0.46.0

package/fjs/text/utf16/module.f.mjs

@@ -4,6 +4,10 @@
  * `stateScan` operations.
  *
  * @module
+ *
+ * @import { List, Result, Thunk } from '../../types/list/types.ts'
+ * @import { StateScan } from '../../types/function/operator/types.ts'
+ * @import { CodePoint, U16 } from './types.ts'
  */
 
 import {
@@ -12,17 +16,14 @@ import {
     flatMap,
     empty,
 } from '../../types/list/module.f.mjs'
-/** @import { List, Result, Thunk } from '../../types/list/types.ts' */
 
 import { concat } from '../../types/function/operator/module.f.mjs'
-/** @import { StateScan } from '../../types/function/operator/types.ts' */
-
 import { contains } from '../../types/range/module.f.mjs'
-
 import { fn } from '../../types/function/module.f.mjs'
 
 import {
     decoder,
+    eofFlush,
     errorMask,
     isBmpCodePoint,
     isHighSurrogate,
@@ -37,8 +38,6 @@ import {
  * @typedef {number | null} _Utf16State
  */
 
-/** @import { CodePoint, U16 } from './types.ts' */
-
 /**
  * The BMP / surrogate / supplementary-plane predicates used below live in
  * `code_point`, the shared Unicode contract; see that module for their ranges.
@@ -85,7 +84,6 @@ const codePointToUtf16 = codePoint => {
     return [codePoint & 0xffff]
 }
 
-
 /**
  * Converts a UTF-16 sequence to its corresponding Unicode code points.
  *
@@ -119,6 +117,8 @@ const codePointToUtf16 = codePoint => {
 export const fromCodePointList
     = flatMap(codePointToUtf16)
 
+const isInU16Range = contains(0x0000, 0xFFFF)
+
 /**
  * Validates whether a given 16-bit unsigned integer (U16) falls within the valid range for UTF-16 code units.
  *
@@ -134,10 +134,14 @@ export const fromCodePointList
  * const edgeCaseHigh = u16(0xFFFF)  // true: Maximum valid value for UTF-16
  * ```
  *
+ * `U16` is just `number`, so this also rejects non-integers — `isBmpCodePoint`,
+ * `isHighSurrogate`, and `isLowSurrogate` only partition the *integers* in
+ * `0x0000`–`0xFFFF` with no gap; a fractional value would fall between two of
+ * those ranges and be misclassified downstream if it were let through here.
+ *
  * @type {(i: U16) => boolean}
  */
-const u16 = contains(0x0000, 0xFFFF)
-
+const u16 = i => Number.isInteger(i) && isInU16Range(i)
 
 /**
  * A stateful operation that converts a UTF-16 word (U16) to a list of Unicode code points (CodePoint),
@@ -156,7 +160,9 @@ const u16 = contains(0x0000, 0xFFFF)
  *               This can be either `null` (no state) or the previous high surrogate value.
  * @param word - The current UTF-16 word (U16) to process.
  * @returns A tuple where the first element is a list of decoded Unicode code points (`CodePoint`), and
- *          the second element is the updated state. If the word is invalid, an error code `0xffffffff` is returned.
+ *          the second element is the updated state. A word outside the `U16`
+ *          domain is reported as one bare `errorMask` unit, the same shape the
+ *          UTF-8 decoder's out-of-range guard emits.
  *
  * @example
  *
@@ -178,7 +184,10 @@ const u16 = contains(0x0000, 0xFFFF)
  */
 const utf16ByteToCodePointOp = (word, state) => {
     if (!u16(word)) {
-        return [[0xffffffff], state]
+        // Out of domain, so there is no payload to tag: emit the bare mask,
+        // matching `utf8ByteToCodePointOp`'s guard. Every other error path
+        // below tags a real code unit with `| errorMask`.
+        return [[errorMask], state]
     }
     if (state === null) {
         if (isBmpCodePoint(word)) { return [[word], null] }
@@ -190,39 +199,33 @@ const utf16ByteToCodePointOp = (word, state) => {
         const low = word - 0xdc00
         return [[(high << 10) + low + 0x10000], null]
     }
+    // `isLowSurrogate`, `isBmpCodePoint`, and `isHighSurrogate` partition the
+    // full `u16` range with no gap, and `isLowSurrogate` was already ruled out
+    // above, so a non-BMP `word` here is always a high surrogate.
     if (isBmpCodePoint(word)) { return [[state | errorMask, word], null] }
-    if (isHighSurrogate(word)) { return [[state | errorMask], word] }
-    return [[state | errorMask, word | errorMask], null]
+    return [[state | errorMask], word]
 }
 
+/**
+ * Converts a pending UTF-16 decoding state — an unpaired high surrogate
+ * (0xD800–0xDBFF) left from an earlier input — to an error code.
+ *
+ * @type {(state: number) => CodePoint}
+ */
+const utf16StateToError = state => state | errorMask
 
 /**
  * Handles the EOF (end-of-file) condition during UTF-16 decoding.
  *
- * If there is no pending state (`state === null`), it simply returns an empty list
- * of code points, indicating no further input to process. If there is a pending state,
- * it is treated as an unpaired surrogate, and the `errorMask` is applied to flag
- * the invalid sequence.
- *
- * @param {_Utf16State} state - The current UTF-16 decoding state. This can be:
- *   - `null`: No pending surrogate to process.
- *   - A high surrogate (0xD800–0xDBFF) left from an earlier input, waiting for a low surrogate.
- * @returns {readonly[List<CodePoint>, _Utf16State]} A tuple:
- *   - The first element is a list of code points. If there’s a pending state, it is returned
- *     with the `errorMask` applied.
- *   - The second element is the next state, which will always be `null` because EOF means no
- *     further processing.
- *
- * @example
+ * If there is no pending state (`state === null`), it returns an empty list of
+ * code points, indicating no further input to process. If there is a pending
+ * state, it is treated as an unpaired surrogate and the `errorMask` is applied
+ * to flag the invalid sequence. The flush itself is `eofFlush` from
+ * `code_point`, shared with UTF-8.
  *
- * ```js
- * const eofState = utf16EofToCodePointOp(0xD800) // Unpaired high surrogate
- * const validState = utf16EofToCodePointOp(null) // No pending state
- * ```
+ * @type {(state: _Utf16State) => readonly[List<CodePoint>, _Utf16State]}
  */
-const utf16EofToCodePointOp = state =>
-    [state === null ? empty : [state | errorMask],  null]
-
+const utf16EofToCodePointOp = eofFlush(utf16StateToError)
 
 /**
  * Converts a list of UTF-16 code units to a list of Unicode code points (CodePoint).

package/fjs/text/utf16/proof.f.d.mts

@@ -1,4 +1,6 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ */
 export declare const proof: {
     toCodePointList: (() => void)[];
     fromCodePointList: (() => void)[];

package/fjs/text/utf16/proof.f.mjs

@@ -1,4 +1,6 @@
-/** @import { Unknown } from '../../media/json/types.ts' */
+/**
+ * @import { Unknown } from '../../media/json/types.ts'
+ */
 
 import {
     toCodePointList,
@@ -22,7 +24,7 @@ export const proof = {
     toCodePointList: [
         () => {
             const result = stringify(toArray(toCodePointList([-1, 65536])))
-            assertEq(result, '[4294967295,4294967295]')
+            assertEq(result, '[2147483648,2147483648]')
         },
         () => {
             const result = stringify(toArray(toCodePointList([0, 36, 8364, 55295, 57344, 65535])))
@@ -51,6 +53,21 @@ export const proof = {
         () => {
             const result = stringify(toArray(toCodePointList([56320, 0])))
             assertEq(result, '[-2147427328,0]')
+        },
+        // `U16` is just `number`, so a non-integer in [0x0000, 0xFFFF] is a
+        // possible (if malformed) input. It must be rejected as invalid, not
+        // misclassified by the surrogate/BMP range checks, which only
+        // partition the integers in that range.
+        () => {
+            const result = stringify(toArray(toCodePointList([56319.5])))
+            assertEq(result, '[2147483648]')
+        },
+        // A non-integer word doesn't disturb a pending high surrogate: it is
+        // reported invalid on its own, and the surrogate is still flagged
+        // unpaired at EOF.
+        () => {
+            const result = stringify(toArray(toCodePointList([55296, 56319.5])))
+            assertEq(result, '[2147483648,-2147428352]')
         }
     ],
     fromCodePointList: [

package/fjs/text/utf8/module.f.d.mts

@@ -2,6 +2,11 @@
  * UTF-8 byte-level encoding and decoding utilities for FunctionalScript streams.
  *
  * @module
+ *
+ * @import { List, Thunk } from '../../types/list/types.ts'
+ * @import { StateScan } from '../../types/function/operator/types.ts'
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ * @import { ByteOrEof, I32, U8, Utf8NonEmptyState, Utf8State, } from './types.ts'
  */
 import type { List, Thunk } from '../../types/list/types.ts';
 import type { StateScan } from '../../types/function/operator/types.ts';
@@ -42,12 +47,11 @@ export declare const utf8StateToError: (state: Utf8NonEmptyState) => I32;
  */
 export declare const utf8ByteToCodePointOp: StateScan<number, Utf8State, readonly I32[]>;
 /**
- * Handles the end-of-file (EOF) case for UTF-8 decoding.
+ * Handles the end-of-file (EOF) case for UTF-8 decoding: a leftover incomplete
+ * sequence is flushed as a single error code and the state resets to `null`.
+ * The flush itself is `eofFlush` from `code_point`, shared with UTF-16.
  *
- * @param {Utf8State} state The current UTF-8 decoding state.
- * @returns {readonly [List<I32>, Utf8State]} A tuple containing:
- *   - A list of decoded Unicode code points or error codes.
- *   - The reset UTF-8 state (`null`).
+ * @type {(state: Utf8State) => readonly [List<I32>, Utf8State]}
  */
 export declare const utf8EofToCodePointOp: (state: Utf8State) => readonly [List<I32>, Utf8State];
 /**

package/fjs/text/utf8/module.f.mjs

@@ -2,20 +2,24 @@
  * UTF-8 byte-level encoding and decoding utilities for FunctionalScript streams.
  *
  * @module
+ *
+ * @import { List, Thunk } from '../../types/list/types.ts'
+ * @import { StateScan } from '../../types/function/operator/types.ts'
+ * @import { Vec } from '../../types/bit_vec/types.ts'
+ * @import { ByteOrEof, I32, U8, Utf8NonEmptyState, Utf8State, } from './types.ts'
  */
 
 import { flatMap, toArray } from '../../types/list/module.f.mjs'
-/** @import { List, Thunk } from '../../types/list/types.ts' */
-/** @import { StateScan } from '../../types/function/operator/types.ts' */
-import { decoder, errorMask, isValidCodePoint } from '../code_point/module.f.mjs'
+import {
+    bmpMax,
+    decoder,
+    eofFlush,
+    errorMask,
+    isSupplementaryPlane,
+    isValidCodePoint,
+} from '../code_point/module.f.mjs'
 import { msb, u8List, length } from '../../types/bit_vec/module.f.mjs'
-/** @import { Vec } from '../../types/bit_vec/types.ts' */
 import { codePointListToString } from '../utf16/module.f.mjs'
-/**
- * @import {
- *  ByteOrEof, I32, U8, Utf8NonEmptyState, Utf8State,
- * } from './types.ts'
- */
 
 /**
  * UTF-8 byte-format constants. Each byte kind is defined by a tag — the fixed
@@ -92,14 +96,14 @@ const codePointToUtf8 = input => {
     if (input >= 0x0080 && input <= 0x07ff) {
         return [input >> 6 | lead2Tag, contByte(input)]
     }
-    if (input >= 0x0800 && input <= 0xffff) {
+    if (input >= 0x0800 && input <= bmpMax) {
         return [
             input >> 12 | lead3Tag,
             contByte(input >> 6),
             contByte(input),
         ]
     }
-    if (input >= 0x10000 && input <= 0x10ffff) {
+    if (isSupplementaryPlane(input)) {
         return [
             input >> 18 | lead4Tag,
             contByte(input >> 12),
@@ -240,17 +244,13 @@ export const utf8ByteToCodePointOp = (byte, state) => {
 }
 
 /**
- * Handles the end-of-file (EOF) case for UTF-8 decoding.
+ * Handles the end-of-file (EOF) case for UTF-8 decoding: a leftover incomplete
+ * sequence is flushed as a single error code and the state resets to `null`.
+ * The flush itself is `eofFlush` from `code_point`, shared with UTF-16.
  *
- * @param {Utf8State} state The current UTF-8 decoding state.
- * @returns {readonly [List<I32>, Utf8State]} A tuple containing:
- *   - A list of decoded Unicode code points or error codes.
- *   - The reset UTF-8 state (`null`).
+ * @type {(state: Utf8State) => readonly [List<I32>, Utf8State]}
  */
-export const utf8EofToCodePointOp = state => [
-    state === null ? null : [utf8StateToError(state)],
-    null,
-]
+export const utf8EofToCodePointOp = eofFlush(utf8StateToError)
 
 /**
  * Converts a list of UTF-8 bytes into a list of Unicode code points.

package/fjs/types/array/module.f.d.mts

@@ -2,9 +2,10 @@
  * JavaScript immutable arrays.
  *
  * @module
+ *
+ * @import { Tuple } from './types.ts'
  */
 import type { Tuple } from './types.ts';
-/** @import { Tuple } from './types.ts' */
 /**
  * @type {(value: unknown) => value is readonly unknown[]}
  */

package/fjs/types/array/module.f.mjs

@@ -2,12 +2,12 @@
  * JavaScript immutable arrays.
  *
  * @module
+ *
+ * @import { Tuple } from './types.ts'
  */
 
 import { fromUndefined, map } from '../nullable/module.f.mjs'
 
-/** @import { Tuple } from './types.ts' */
-
 /**
  * @type {(value: unknown) => value is readonly unknown[]}
  */
@@ -53,10 +53,22 @@ export const first = at(0)
  */
 export const last = a => at(a.length - 1)(a)
 
+/**
+ * Applies `f` to a non-empty array, answering `null` for an empty one — the
+ * shared shape of the whole-array accessors below.
+ *
+ * The guard is `a.length === 0` and not `first(a) === null`: `first` goes
+ * through `fromUndefined`, so it reads a *stored* `null` or `undefined`
+ * element as absence. `[null]` is not empty, but `first` says it is.
+ *
+ * @type {<T, R>(f: (a: readonly T[]) => R) => (a: readonly T[]) => R | null}
+ */
+const onNonEmpty = f => a => a.length === 0 ? null : f(a)
+
 /**
  * @type {<T>(a: readonly T[]) => readonly T[] | null}
  */
-export const tail = a => a.length === 0 ? null : uncheckTail(a)
+export const tail = onNonEmpty(uncheckTail)
 
 /**
  * @type {<T>(a: readonly T[]) => readonly [T, readonly T[]] | null}
@@ -69,7 +81,7 @@ export const splitFirst = a => {
 }
 
 /** @type {<T>(a: readonly T[]) => readonly T[] | null} */
-export const head = a => a.length === 0 ? null : uncheckHead(a)
+export const head = onNonEmpty(uncheckHead)
 
 /** @type {<T>(a: readonly T[]) => readonly [readonly T[], T] | null} */
 export const splitLast = a => {

package/fjs/types/bigfloat/module.f.d.mts

@@ -2,12 +2,32 @@
  * Big-float helpers built from bigint mantissa and exponent parts.
  *
  * @module
+ *
+ * @import { BigFloat } from './types.ts'
  */
 import type { BigFloat } from './types.ts';
 export type _BigFloatWithRemainder = readonly [BigFloat, bigint];
 /** @type {(_: BigFloat) => (mul: bigint) => BigFloat} */
 export declare const multiply: (_: BigFloat) => (mul: bigint) => BigFloat;
-/** @type {(dec: BigFloat) => BigFloat} */
+/**
+ * Converts a decimal big-float `m * 10^e` into the nearest binary big-float,
+ * rounding ties to even.
+ *
+ * A zero input returns `[0n, 0]`; every other input returns a mantissa of
+ * exactly 53 significant bits, `2^52 <= abs(m) < 2^53`. The upper bound holds
+ * even when rounding carries out of the top bit.
+ *
+ * The **exponent is unbounded**: this is the correctly-rounded 53-bit value,
+ * not a `number`. Nothing here knows binary64's exponent range, so a result
+ * is neither turned into an infinity when it is too large for a `double` nor
+ * cut down to the fewer-than-53 bits a subnormal actually carries. A consumer
+ * that rounds one of these results onto the subnormal grid therefore rounds
+ * twice and can land an ulp away from the correctly-rounded `double`: reaching
+ * the subnormal range needs a single rounding to a precision chosen from the
+ * target exponent, which this function does not offer yet.
+ *
+ * @type {(dec: BigFloat) => BigFloat}
+ */
 export declare const decToBin: (dec: BigFloat) => BigFloat;
 export declare const proof: {
     normalizeMantissaZero: () => void;

package/fjs/types/bigfloat/module.f.mjs

@@ -2,10 +2,11 @@
  * Big-float helpers built from bigint mantissa and exponent parts.
  *
  * @module
+ *
+ * @import { BigFloat } from './types.ts'
  */
 
 import { abs, sign } from '../bigint/module.f.mjs'
-/** @import { BigFloat } from './types.ts' */
 
 /** @typedef {readonly [BigFloat, bigint]} _BigFloatWithRemainder */
 
@@ -61,6 +62,16 @@ const divide = ([m, e]) => div => [[m / div, e], m % div]
  */
 const withSign = (m, e) => f => multiply(f([abs(m), e]))(BigInt(sign(m)))
 
+/**
+ * Re-normalizes a magnitude that rounding carried out of 53 bits: rounding
+ * `2^53 - 1` up yields exactly `2^53`, one bit wider than `round53` promises.
+ * The bit shifted out is always 0 there, so the value is unchanged and no
+ * second rounding decision is needed.
+ *
+ * @type {(magnitude: BigFloat) => BigFloat}
+ */
+const renormalize53 = ([m, e]) => m === twoPow53 ? [m >> 1n, e + 1] : [m, e]
+
 /** @type {(_: _BigFloatWithRemainder) => BigFloat} */
 const round53 = ([[m, e], r]) =>
     withSign(m, e)(([mAbs]) => {
@@ -68,14 +79,29 @@ const round53 = ([[m, e], r]) =>
         const o54 = m54 & 1n
         const m53 = m54 >> 1n
         const e53 = e54 + 1
-        if (o54 === 1n && r === 0n && mAbs === m54 >> BigInt(e - e54)) {
-            const odd = m53 & 1n
-            return [m53 + odd, e53]
-        }
-        return [m53 + o54, e53]
+        const tie = o54 === 1n && r === 0n && mAbs === m54 >> BigInt(e - e54)
+        return renormalize53([m53 + (tie ? m53 & 1n : o54), e53])
     })
 
-/** @type {(dec: BigFloat) => BigFloat} */
+/**
+ * Converts a decimal big-float `m * 10^e` into the nearest binary big-float,
+ * rounding ties to even.
+ *
+ * A zero input returns `[0n, 0]`; every other input returns a mantissa of
+ * exactly 53 significant bits, `2^52 <= abs(m) < 2^53`. The upper bound holds
+ * even when rounding carries out of the top bit.
+ *
+ * The **exponent is unbounded**: this is the correctly-rounded 53-bit value,
+ * not a `number`. Nothing here knows binary64's exponent range, so a result
+ * is neither turned into an infinity when it is too large for a `double` nor
+ * cut down to the fewer-than-53 bits a subnormal actually carries. A consumer
+ * that rounds one of these results onto the subnormal grid therefore rounds
+ * twice and can land an ulp away from the correctly-rounded `double`: reaching
+ * the subnormal range needs a single rounding to a precision chosen from the
+ * target exponent, which this function does not offer yet.
+ *
+ * @type {(dec: BigFloat) => BigFloat}
+ */
 export const decToBin = dec => {
     if (dec[0] === 0n) {
         return [0n, 0]

package/fjs/types/bigfloat/proof.f.d.mts

@@ -2,4 +2,5 @@ export declare const proof: {
     decToBin: (() => void)[];
     roundingPositive: (() => void)[];
     roundingNegative: (() => void)[];
+    roundingCarry: (() => void)[];
 };

package/fjs/types/bigfloat/proof.f.mjs

@@ -1,5 +1,21 @@
 import { decToBin } from './module.f.mjs'
 import { assertEq } from '../../asserts/module.f.mjs'
+import { bitLength } from '../bigint/module.f.mjs'
+
+/**
+ * Checks `decToBin`'s postcondition on a non-zero result: the mantissa holds
+ * exactly 53 significant bits, and `m * 2^e` is the value it should be.
+ * `bitLength` measures the magnitude, so a negative mantissa is checked as
+ * strictly as a positive one. The value is recovered with a shift, so every
+ * `dec` passed here must round to a whole number (a non-negative `e`).
+ *
+ * @type {(dec: readonly [bigint, number]) => (value: bigint) => void}
+ */
+const assertRounded = dec => value => {
+    const [m, e] = decToBin(dec)
+    assertEq(bitLength(m), 53n, m.toString(2))
+    assertEq(m << BigInt(e), value, m.toString(2))
+}
 
 export const proof = {
     decToBin: [
@@ -214,5 +230,35 @@ export const proof = {
             assertEq(result[0], -0b1_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1001_1100n, result[0].toString(2))
             assertEq(result[1], 2)
         }
+    ],
+    // Rounding up a mantissa of all ones carries into a 54th bit; the result
+    // has to come back as 53 bits without changing the value.
+    roundingCarry: [
+        () => {
+            // 54 ones: an exact tie (nothing below the dropped bit, remainder
+            // 0) whose round-to-even goes up because 2^53 - 1 is odd.
+            assertRounded([0b11_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111n, 0])(
+                0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n) // 2^54
+        },
+        () => {
+            assertRounded([-0b11_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111n, 0])(
+                -0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n) // -2^54
+        },
+        () => {
+            // 55 ones: not a tie — the dropped bits are 11 — so the carry comes
+            // from the plain round-up path instead.
+            assertRounded([0b111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111n, 0])(
+                0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n) // 2^55
+        },
+        () => {
+            assertRounded([-0b111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111n, 0])(
+                -0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000n) // -2^55
+        },
+        () => {
+            // A neighbour that doesn't carry: also a tie, but 2^53 - 2 is even,
+            // so round-to-even goes down and the mantissa stays 53 bits wide.
+            assertRounded([0b11_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1101n, 0])(
+                0b11_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1111_1100n)
+        },
     ]
 }

package/fjs/types/bigint/module.f.d.mts

@@ -15,6 +15,10 @@
  * const bitmask = mask(5n) // 31n
  * const c = combination([3n, 2n, 1n]) // 60n
  * ```
+ *
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { List } from '../list/types.ts'
+ * @import { Reduce, Unary } from './types.ts'
  */
 import type { Sign } from '../function/compare/types.ts';
 import type { List } from '../list/types.ts';

package/fjs/types/bigint/module.f.mjs

@@ -15,12 +15,13 @@
  * const bitmask = mask(5n) // 31n
  * const c = combination([3n, 2n, 1n]) // 60n
  * ```
+ *
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { List } from '../list/types.ts'
+ * @import { Reduce, Unary } from './types.ts'
  */
 
 import { cmp } from '../function/compare/module.f.mjs'
-/** @import { Sign } from '../function/compare/types.ts' */
-/** @import { List } from '../list/types.ts' */
-/** @import { Reduce, Unary } from './types.ts' */
 import { fold } from '../../common/monoid/module.f.mjs'
 
 /**

package/fjs/types/bit_vec/module.f.d.mts

@@ -20,20 +20,21 @@
  * ```
  *
  * @module
+ *
+ * @import { Reduce as BigintReduce } from '../bigint/types.ts'
+ * @import { Fold } from '../function/operator/types.ts'
+ * @import { List, Thunk } from '../list/types.ts'
+ * @import { Absorbing } from '../../common/monoid/types.ts'
+ * @import { Sign } from '../function/compare/types.ts'
+ * @import { Nullable } from '../nullable/types.ts'
+ * @import { BitOrder, PopFront, Reduce, Unpacked, Vec, _NormOp, _UnpackConcat, } from './types.ts'
  */
-import { maxLength } from '../bigint/module.f.mjs';
 import type { Fold } from '../function/operator/types.ts';
-import type { Accumulator, List, Thunk } from '../list/types.ts';
+import type { List, Thunk } from '../list/types.ts';
 import type { Sign } from '../function/compare/types.ts';
 import type { Nullable } from '../nullable/types.ts';
 import type { BitOrder, Unpacked, Vec, _NormOp } from './types.ts';
-/** @import { Nullable } from '../nullable/types.ts' */
-/**
- * @import {
- *  BitOrder, PopFront, Reduce, Unpacked, Vec,
- *  _NormOp, _UnpackConcat,
- * } from './types.ts'
- */
+import { maxLength } from '../bigint/module.f.mjs';
 /**
  * Maximum length of a bit vector in bits (1_048_576 = 0x10_0000).
  * This limit is enforced by Bun's `bigint` size constraint, the minimal limit
@@ -119,18 +120,11 @@ export declare const pack: ({ length, uint }: Unpacked) => Vec;
 /** @type {({ uint }: Unpacked) => bigint} */
 export declare const unpackedUint: ({ uint }: Unpacked) => bigint;
 export type _Base = {
-    readonly front: (len: bigint) => (v: Vec) => bigint;
-    readonly removeFront: (len: bigint) => (v: Vec) => Vec;
     readonly norm: _NormOp;
     readonly uintCmp: (a: bigint) => (b: bigint) => Sign;
     readonly unpackSplit: (len: bigint) => (u: Unpacked) => readonly [bigint, bigint];
     readonly unpackConcatUint: (a: Unpacked) => (b: Unpacked) => bigint;
 };
-export type _ListToVecState = {
-    readonly len: bigint;
-    readonly stack: readonly Unpacked[];
-};
-export type _ListToVecOp = Accumulator<Unpacked, _ListToVecState, Vec>;
 /**
  * Implements operations for handling vectors in a least-significant-bit (LSb) first order.
  *