functionalscript 0.18.0 → 0.20.0

package/fs/sul/level/literal/module.f.js

@@ -5,7 +5,7 @@
  * @module
  */
 import { log2 } from "../../../types/bigint/module.f.js";
-import { listToVec, msb, vec } from "../../../types/bit_vec/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";
@@ -73,12 +73,12 @@ export const pipelineStep = (bit, [l1s, l2s, l3s]) => {
     const [l3Out, newL3s] = l3.encode(l2Out, l3s);
     return [l3Out, [newL1s, newL2s, newL3s]];
 };
-const concat = listToVec(msb);
 const vec1 = vec(1n);
+const { listToVec } = msb;
 const literalToVec = (prior, e) => {
     const m = map(prior);
     const { decode } = level(e);
-    return literal => concat(m(decode(literal)));
+    return literal => listToVec(m(decode(literal)));
 };
 /** Decodes a level-1 symbol to its canonical MSB bit vector. */
 export const literal1ToVec = literalToVec(vec1, 0n);

package/fs/sul/level/literal/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     x2: () => void;
     x5: () => void;
     x81: () => void;
@@ -9,4 +9,3 @@ declare const _default: {
     };
     pipeline: () => void;
 };
-export default _default;

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

@@ -46,7 +46,7 @@ const w = (symbol, expected) => {
     if (out !== symbol)
         throw out;
 };
-export default {
+export const proof = {
     x2: () => {
         const { c, n } = tests(0n);
         c(-1n, 0n);

package/fs/sul/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     deterministic: () => void;
     distinct: () => void;
     order_matters: () => void;
@@ -7,4 +7,3 @@ declare const _default: {
     compress_correct: () => void;
     isSymbol_terminal_only: () => void;
 };
-export default _default;

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

@@ -13,7 +13,7 @@ const run = (bits) => {
 };
 const id = (bits) => run(bits)[0];
 const zeros = (n) => new Array(n).fill(0n);
-export default {
+export const proof = {
     deterministic: () => {
         assertEq(id(zeros(16)), id(zeros(16)));
     },

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

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

package/fs/text/ascii/{test.f.js → proof.f.js}

@@ -2,7 +2,7 @@ import { range } from "./module.f.js";
 import { stringify as jsonStringify } from "../../json/module.f.js";
 import { sort } from "../../types/object/module.f.js";
 const stringify = jsonStringify(sort);
-export default {
+export const proof = {
     range: () => {
         const r = stringify(range("A"));
         if (r !== '[65,65]') {

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

@@ -0,0 +1,28 @@
+/**
+ * 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`
+ * factory that wraps a per-unit step and an end-of-input step into a single
+ * `List`-to-`List` conversion.
+ *
+ * @module
+ */
+import { type List } from '../../types/list/module.f.ts';
+import type { StateScan } from '../../types/function/operator/module.f.ts';
+/**
+ * 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
+ * code point.
+ */
+export declare const errorMask = 2147483648;
+/**
+ * Builds a streaming decoder from the two direction-specific steps.
+ *
+ * Decoding starts from the empty (`null`) state. The input is processed unit by
+ * unit through `byteOp`, then a trailing end-of-input marker drives `eofOp` to
+ * flush any leftover decoding state.
+ *
+ * @param byteOp - The per-unit decoding step.
+ * @param eofOp - The end-of-input step that flushes the remaining state.
+ * @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>;

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

@@ -0,0 +1,31 @@
+/**
+ * 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`
+ * factory that wraps a per-unit step and an end-of-input step into a single
+ * `List`-to-`List` conversion.
+ *
+ * @module
+ */
+import { flat, stateScan } from "../../types/list/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
+ * code point.
+ */
+export const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
+/**
+ * Builds a streaming decoder from the two direction-specific steps.
+ *
+ * Decoding starts from the empty (`null`) state. The input is processed unit by
+ * unit through `byteOp`, then a trailing end-of-input marker drives `eofOp` to
+ * flush any leftover decoding state.
+ *
+ * @param byteOp - The per-unit decoding step.
+ * @param eofOp - The end-of-input step that flushes the remaining state.
+ * @returns A function converting a list of code units into a list of code points.
+ */
+export const decoder = (byteOp, eofOp) => {
+    const op = (input, state) => input === null ? eofOp(state) : byteOp(input, state);
+    const run = stateScan(op)(null);
+    return input => flat(run(flat([input, [null]])));
+};

package/fs/text/{test.f.d.ts → proof.f.d.ts}

@@ -1,5 +1,4 @@
-declare const _default: {
+export declare const proof: {
     block: () => void;
     encoding: () => void;
 };
-export default _default;

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

@@ -1,6 +1,6 @@
 import { flat, utf8, utf8ToString } from "./module.f.js";
 import { join } from "../types/string/module.f.js";
-export default {
+export const proof = {
     block: () => {
         const text = [
             'a',

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

@@ -0,0 +1 @@
+export declare const proof: (() => void)[];

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

@@ -0,0 +1,23 @@
+import { fgRed, createConsoleText, backspace } from "./module.f.js";
+export const proof = [
+    () => {
+        if (fgRed !== '\x1b[31m') {
+            throw 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];
+        }
+        // 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];
+        }
+    }
+];

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

@@ -5,10 +5,11 @@
  *
  * @module
  */
-import { map, flat, stateScan, reduce, flatMap, empty, } from "../../types/list/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 } 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.
  */
@@ -29,10 +30,6 @@ const isHighSurrogate = contains([0xd800, 0xdbff]);
  * Range: 0xDC00 – 0xDFFF.
  */
 const isLowSurrogate = contains([0xdc00, 0xdfff]);
-/**
- * Mask of mistakes. Used to indicate invalid code points or coding errors
- */
-const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
 /**
  * Checks whether the code point belongs to the additional (Supplementary) plane of Unicode.
  * Additional planes include code points from 0x010000 to 0x10FFFF.
@@ -219,53 +216,6 @@ const utf16ByteToCodePointOp = (word, state) => {
  * ```
  */
 const utf16EofToCodePointOp = (state) => [state === null ? empty : [state | errorMask], null];
-/**
- * A stateful scan operation that processes UTF-16 input (word or EOF).
- * This function determines whether to handle a UTF-16 word or an end-of-file (EOF)
- * signal during decoding:
- * 1. If the input is `null` (EOF), it calls `utf16EofToCodePointOp` to process
- *    any remaining state.
- * 2. If the input is a valid UTF-16 word, it calls `utf16ByteToCodePointOp` to
- *    process the word and update the state accordingly.
- * @param state - The current state in the UTF-16 decoding process:
- *   - `null`: No pending surrogate.
- *   - A high surrogate waiting for a low surrogate.
- * @param input - The current UTF-16 word to process, or `null` to signal EOF.
- * @returns A tuple:
- *   - A list of decoded code points (if any).
- *   - The updated decoding state.
- *
- * @example
- *
- * ```ts
- * // Example 1: Process a valid UTF-16 word
- * const input1 = 0x0041 // 'A' (BMP code point)
- * const result1 = utf16ByteOrEofToCodePointOp(input1, null)
- * console.log(result1) // [[0x0041], null]
- * // Example 2: Process a high surrogate, followed by EOF
- * const input2 = 0xD83D // High surrogate
- * const result2 = utf16ByteOrEofToCodePointOp(input2, null)
- * console.log(result2) // [[], 0xD83D] (waiting for a low surrogate)
- * const eofResult = utf16ByteOrEofToCodePointOp(null, 0xD83D)
- * console.log(eofResult) // [[0xD83D | errorMask], null] (unpaired high surrogate)
- * // Example 3: Handle EOF with no pending state
- * const eofResult2 = utf16ByteOrEofToCodePointOp(null, null)
- * ```
- */
-const utf16ByteOrEofToCodePointOp = (input, state) => input === null ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(input, state);
-/**
- * Represents an end-of-file (EOF) indicator in a list of UTF-16 code units.
- *
- * This list contains a single element, `null`, which is used to signal the end
- * of input during UTF-16 decoding operations.
- * @example
- *
- * ```ts
- * const input = [...utf16Data, ...eofList]
- * // Ensures the EOF is handled during processing.
- * ```
- */
-const eofList = [null];
 /**
  * Converts a list of UTF-16 code units to a list of Unicode code points (CodePoint).
  * This function processes each UTF-16 code unit, decoding them into their corresponding Unicode code points.
@@ -281,7 +231,7 @@ const eofList = [null];
  * const codePoints = toCodePointList(utf16List)
  * ```
  */
-export const toCodePointList = (input) => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])));
+export const toCodePointList = decoder(utf16ByteToCodePointOp, utf16EofToCodePointOp);
 /**
  * Converts a string to a list of UTF-16 code units (U16).
  *

package/fs/text/utf16/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     toCodePointList: (() => void)[];
     fromCodePointList: (() => void)[];
     string: (() => void)[];
@@ -7,4 +7,3 @@ declare const _default: {
     stringToCodePointList: (() => void)[];
     codePointListToString: (() => void)[];
 };
-export default _default;

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

@@ -3,7 +3,7 @@ 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";
 const stringify = (a) => jsonStringify(sort)(a);
-export default {
+export const proof = {
     toCodePointList: [
         () => {
             const result = stringify(toArray(toCodePointList([-1, 65536])));

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

@@ -3,11 +3,8 @@
  *
  * @module
  */
-import { flat, flatMap, stateScan } from "../../types/list/module.f.js";
-/**
- * Error mask constant used to represent invalid code points or encoding errors in UTF-8.
- */
-const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
+import { flatMap } from "../../types/list/module.f.js";
+import { decoder, errorMask } from "../code_point/module.f.js";
 /**
  * Converts a Unicode code point to a sequence of UTF-8 bytes.
  * @param input The Unicode code point to be converted. Valid range:
@@ -175,29 +172,10 @@ const utf8EofToCodePointOp = (state) => [
     state === null ? null : [utf8StateToError(state)],
     null,
 ];
-/**
- * Combines UTF-8 byte and EOF handling into a single decoding operation.
- *
- * @param state - The current UTF-8 decoding state.
- * @param input - The next byte or EOF indicator.
- * @returns A tuple containing:
- *   - A list of decoded Unicode code points or error codes.
- *   - The updated UTF-8 state.
- */
-const utf8ByteOrEofToCodePointOp = (input, state) => input === null ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(input, state);
-/**
- * A constant representing the end-of-file (EOF) marker for UTF-8 decoding.
- *
- * @remarks
- * This is used as a sentinel value in decoding operations to signify the
- * termination of input. The list contains a single `null` value, which
- * represents the EOF condition.
- */
-const eofList = [null];
 /**
  * Converts a list of UTF-8 bytes into a list of Unicode code points.
  *
  * @param input - A list of UTF-8 bytes.
  * @returns A list of Unicode code points or error codes.
  */
-export const toCodePointList = (input) => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])));
+export const toCodePointList = decoder(utf8ByteToCodePointOp, utf8EofToCodePointOp);

package/fs/text/utf8/{test.f.d.ts → proof.f.d.ts}

@@ -1,6 +1,5 @@
-declare const _default: {
+export declare const proof: {
     toCodePoint: (() => void)[];
     fromCodePointList: (() => void)[];
     toFrom: (() => void)[];
 };
-export default _default;

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

@@ -3,7 +3,7 @@ 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";
 const stringify = jsonStringify(sort);
-export default {
+export const proof = {
     toCodePoint: [
         () => {
             const result = stringify(toArray(toCodePointList([-1, 256])));

package/fs/types/array/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     stringify: () => void;
     at: (() => void)[];
     first: (() => void)[];
@@ -9,4 +9,3 @@ declare const _default: {
     splitLast: (() => void)[];
     empty: () => void;
 };
-export default _default;

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

@@ -2,7 +2,7 @@ import { at, first, last, head, tail, splitFirst, splitLast, empty } from "./mod
 import { stringify as jsonStringify } from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
 const stringify = jsonStringify(sort);
-export default {
+export const proof = {
     stringify: () => {
         const result = stringify([1, 20, 300]);
         if (result !== '[1,20,300]') {

package/fs/types/bigfloat/{test.f.d.ts → proof.f.d.ts}

@@ -1,6 +1,5 @@
-declare const _default: {
+export declare const proof: {
     decToBin: (() => void)[];
     roundingPositive: (() => void)[];
     roundingNegative: (() => void)[];
 };
-export default _default;

package/fs/types/bigfloat/{test.f.js → proof.f.js}

@@ -1,5 +1,5 @@
 import { decToBin } from "./module.f.js";
-export default {
+export const proof = {
     decToBin: [
         () => {
             const result = decToBin([0n, 0]);

package/fs/types/bigint/{test.f.d.ts → proof.f.d.ts}

@@ -1,5 +1,5 @@
 export declare const clz32Log2: (v: bigint) => bigint;
-declare const _default: {
+export declare const proof: {
     example: () => void;
     benchmark: () => {
         big: {
@@ -30,4 +30,3 @@ declare const _default: {
     divUp: () => void;
     roundUp: () => void;
 };
-export default _default;

package/fs/types/bigint/{test.f.js → proof.f.js}

@@ -148,7 +148,7 @@ const benchmarkSmall = f => () => {
         --e;
     } while (c !== 0n);
 };
-export default {
+export const proof = {
     example: () => {
         const total = sum([1n, 2n, 3n]); // 6n
         if (total !== 6n) {

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

@@ -146,6 +146,15 @@ export type BitOrder = {
      * ```
      */
     readonly concat: Reduce;
+    /**
+     * Folds a list of vectors into a single vector in this bit order.
+     *
+     * Unlike `concat`, which joins exactly two vectors, this joins a whole list.
+     *
+     * @returns The concatenation of every vector in the list, or `empty` when the
+     * list is empty.
+     */
+    readonly listToVec: (list: List<Vec>) => Vec;
     /**
      * Computes the bitwise exclusive OR of two vectors after normalizing their lengths.
      *
@@ -219,10 +228,6 @@ export declare const chunkList: (bo: BitOrder) => (n: bigint) => (v: Vec) => Thu
  * @returns A thunk that produces a list of unsigned 8-bit integers.
  */
 export declare const u8List: (bo: BitOrder) => (v: Vec) => Thunk<number>;
-/**
- * Concatenates a list of vectors using the provided bit order.
- */
-export declare const listToVec: ({ concat }: BitOrder) => (list: List<Vec>) => Vec;
 /**
  * Repeats a vector to create a padded block of the desired length.
  */

package/fs/types/bit_vec/module.f.js

@@ -127,14 +127,16 @@ const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }
             return [uint, pack(u)];
         };
     };
+    const concat = a => b => {
+        const au = unpack(a);
+        const bu = unpack(b);
+        return pack(unpackConcat(au)(bu));
+    };
     return {
         front,
         removeFront,
-        concat: a => b => {
-            const au = unpack(a);
-            const bu = unpack(b);
-            return pack(unpackConcat(au)(bu));
-        },
+        concat,
+        listToVec: fold(flip(concat))(empty),
         xor: op(norm)(xor),
         unpackPopFront,
         popFront,
@@ -301,10 +303,6 @@ const vecToU8 = ({ unpackSplit }) => {
  * @returns A thunk that produces a list of unsigned 8-bit integers.
  */
 export const u8List = (bo) => (v) => map(vecToU8(bo))(chunkList(bo)(8n)(v));
-/**
- * Concatenates a list of vectors using the provided bit order.
- */
-export const listToVec = ({ concat }) => fold(flip(concat))(empty);
 /**
  * Repeats a vector to create a padded block of the desired length.
  */

package/fs/types/bit_vec/{test.f.d.ts → proof.f.d.ts}

@@ -1,4 +1,4 @@
-declare const _default: {
+export declare const proof: {
     examples: {
         vec: () => void;
         uint: () => void;
@@ -54,4 +54,3 @@ declare const _default: {
         msb_unaligned: () => void;
     };
 };
-export default _default;

package/fs/types/bit_vec/{test.f.js → proof.f.js}

@@ -80,7 +80,7 @@ const concat = (e) => (r) => () => {
         throw ab;
     }
 };
-export default {
+export const proof = {
     examples: {
         vec: () => {
             const vec4 = vec(4n);

package/fs/types/btree/find/proof.f.d.ts

@@ -0,0 +1 @@
+export declare const proof: () => void;

package/fs/types/btree/find/{test.f.js → proof.f.js}

@@ -148,4 +148,4 @@ const test = () => {
         }
     }
 };
-export default test;
+export const proof = test;

package/fs/types/btree/{test.f.d.ts → proof.f.d.ts}

@@ -1,8 +1,7 @@
-declare const _default: {
+export declare const proof: {
     valueTest1: () => void;
     valuesTest2: () => void;
     findTrue: () => void;
     find: () => void;
     test: () => void;
 };
-export default _default;

package/fs/types/btree/{test.f.js → proof.f.js}

@@ -62,7 +62,7 @@ const test = () => {
         }
     }
 };
-export default {
+export const proof = {
     valueTest1,
     valuesTest2,
     findTrue,

package/fs/types/btree/remove/module.f.d.ts

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import type { TNode, Tree } from '../types/module.f.ts';
+import { type TNode, type Tree } from '../types/module.f.ts';
 import type { Compare } from '../../function/compare/module.f.ts';
 export declare const nodeRemove: <T>(c: Compare<T>) => (node: TNode<T>) => Tree<T>;
 export declare const remove: <T>(c: Compare<T>) => (tree: Tree<T>) => Tree<T>;

package/fs/types/btree/remove/module.f.js

@@ -1,3 +1,9 @@
+/**
+ * Removal operations for persistent B-tree structures.
+ *
+ * @module
+ */
+import { collapseRoot } from "../types/module.f.js";
 import { find } from "../find/module.f.js";
 import { fold, concat, next } from "../../list/module.f.js";
 import { map } from "../../nullable/module.f.js";
@@ -163,7 +169,6 @@ export const nodeRemove = (c) => (node) => {
         return first;
     }
     const { first: tf, tail: tt } = tailR;
-    const result = reduce(initReduce(tf)(first))(tt);
-    return result.length === 1 ? result[0] : result;
+    return collapseRoot(reduce(initReduce(tf)(first))(tt));
 };
 export const remove = c => map(nodeRemove(c));

package/fs/types/btree/remove/proof.f.d.ts

@@ -0,0 +1,4 @@
+export declare const proof: {
+    test: () => void;
+    test2: () => void;
+};

package/fs/types/btree/remove/{test.f.js → proof.f.js}

@@ -625,7 +625,7 @@ const test2 = () => {
         }
     }
 };
-export default {
+export const proof = {
     test,
     test2,
 };

package/fs/types/btree/set/module.f.d.ts

@@ -3,6 +3,6 @@
  *
  * @module
  */
-import type { TNode, Tree } from '../types/module.f.ts';
+import { type TNode, type Tree } from '../types/module.f.ts';
 import type { Compare } from '../../function/compare/module.f.ts';
 export declare const set: <T>(c: Compare<T>) => (f: (value: T | null) => T) => (tree: Tree<T>) => TNode<T>;

package/fs/types/btree/set/module.f.js

@@ -1,3 +1,9 @@
+/**
+ * Insertion and update operations for persistent B-tree structures.
+ *
+ * @module
+ */
+import { collapseRoot } from "../types/module.f.js";
 import { find } from "../find/module.f.js";
 import { fold } from "../../list/module.f.js";
 const b57 = b => b.length === 5 ? [b] : [[b[0], b[1], b[2]], b[3], [b[4], b[5], b[6]]];
@@ -114,7 +120,6 @@ const nodeSet = (c) => (g) => (node) => {
             }
         }
     };
-    const r = reduceBranch(f())(tail);
-    return r.length === 1 ? r[0] : r;
+    return collapseRoot(reduceBranch(f())(tail));
 };
 export const set = c => f => tree => tree === null ? [f(null)] : nodeSet(c)(f)(tree);

package/fs/types/btree/set/proof.f.d.ts

@@ -0,0 +1 @@
+export declare const proof: (() => void)[];

package/fs/types/btree/set/{test.f.js → proof.f.js}

@@ -354,4 +354,4 @@ const test = [
         }
     }
 ];
-export default test;
+export const proof = test;

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

@@ -12,3 +12,12 @@ export type TNode<T> = Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>;
 export type Tree<T> = TNode<T> | null;
 export type Branch1<T> = readonly [TNode<T>];
 export type Branch7<T> = readonly [...Branch5<T>, T, TNode<T>];
+/**
+ * Demotes a single-child branch root to its only child.
+ *
+ * After an insert or remove the root may temporarily hold exactly one child
+ * (a `Branch1`). In that case the tree is one level taller than necessary;
+ * returning the child directly restores the correct height. If the root has
+ * more than one child it is returned unchanged.
+ */
+export declare const collapseRoot: <T>(b: Branch1<T> | Branch3<T> | Branch5<T>) => TNode<T>;

package/fs/types/btree/types/module.f.js

@@ -1 +1,9 @@
-export {};
+/**
+ * Demotes a single-child branch root to its only child.
+ *
+ * After an insert or remove the root may temporarily hold exactly one child
+ * (a `Branch1`). In that case the tree is one level taller than necessary;
+ * returning the child directly restores the correct height. If the root has
+ * more than one child it is returned unchanged.
+ */
+export const collapseRoot = b => b.length === 1 ? b[0] : b;