functionalscript 0.35.2 → 0.37.0

package/fs/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([]);

package/fs/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/sul/level/literal/proof.f.js

@@ -1,6 +1,6 @@
-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 { 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 {

package/fs/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/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/fs/text/ascii/proof.f.js

@@ -1,6 +1,6 @@
-import { one, range } from "./module.f.js";
-import { stringify as jsonStringify } from "../../json/module.f.js";
-import { sort } from "../../types/object/module.f.js";
+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';
 const stringify = jsonStringify(sort);
 export const proof = {
     range: () => {

package/fs/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

package/fs/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/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/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 { 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: () => {

package/fs/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/text/sgr/proof.f.js

@@ -1,5 +1,5 @@
-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';
 const makeOptions = (isTTY) => ({ ...defaultNodeProgramOptions, std: { stdout: { isTTY }, stderr: { isTTY } } });
 export const proof = [
     () => {

package/fs/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.

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

@@ -1,7 +1,7 @@
-import { toCodePointList, fromCodePointList, stringToList, listToString, stringToCodePointList, codePointListToString } from "./module.f.js";
-import { stringify as jsonStringify } from "../../json/module.f.js";
-import { sort } from "../../types/object/module.f.js";
-import { toArray } from "../../types/list/module.f.js";
+import { toCodePointList, fromCodePointList, stringToList, listToString, stringToCodePointList, codePointListToString } from './module.f.js';
+import { stringify as jsonStringify } from '../../media/json/module.f.js';
+import { sort } from '../../types/object/module.f.js';
+import { toArray } from '../../types/list/module.f.js';
 const stringify = (a) => jsonStringify(sort)(a);
 export const proof = {
     toCodePointList: [

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

@@ -46,6 +46,12 @@ export declare const utf8StateToError: (state: Utf8NonEmptyState) => I32;
 /**
  * Decodes a byte into a Unicode code point, using a given UTF-8 state.
  *
+ * Rejects overlong 3-/4-byte encodings (Unicode Table 3-7): a lead `E0` must
+ * be followed by a continuation `>= 0xA0`, and a lead `F0` by a continuation
+ * `>= 0x90`. It does not itself reject surrogates (`ED A0..BF`) or code
+ * points above `U+10FFFF` (`F4 90..BF`); {@link fromVec}'s
+ * `isValidCodePoint` pass filters those out of the raw code-point stream.
+ *
  * @param state - The current UTF-8 decoding state.
  * @param byte - A single byte to decode.
  * @returns A tuple containing:

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

@@ -3,10 +3,10 @@
  *
  * @module
  */
-import { flatMap, toArray } from "../../types/list/module.f.js";
-import { decoder, errorMask, isValidCodePoint } from "../code_point/module.f.js";
-import { msb, u8List, length } from "../../types/bit_vec/module.f.js";
-import { codePointListToString } from "../utf16/module.f.js";
+import { flatMap, toArray } from '../../types/list/module.f.js';
+import { decoder, errorMask, isValidCodePoint } from '../code_point/module.f.js';
+import { msb, u8List, length } from '../../types/bit_vec/module.f.js';
+import { codePointListToString } from '../utf16/module.f.js';
 /**
  * UTF-8 byte-format constants. Each byte kind is defined by a tag — the fixed
  * high bits identifying the kind — and a payload mask selecting the code-point
@@ -36,6 +36,21 @@ const contByte = (x) => x & contMask | contTag;
  * Reads the six payload bits of a continuation byte.
  */
 const contPayload = (b) => b & contMask;
+/**
+ * The valid lead-byte range for 2-, 3-, and 4-byte sequences (RFC 3629);
+ * excludes overlong 2-byte leads (`C0`, `C1`) and leads above `U+10FFFF` (`F5`-`F7`).
+ */
+const leadMin = 0b1100_0010;
+const leadMax = 0b1111_0100;
+const isLeadByte = (b) => b >= leadMin && b <= leadMax;
+/**
+ * Dispatches a fresh-state byte, emitting `prefix` ahead of whatever the byte
+ * itself produces. Shared by the `state === null` arm and by error recovery
+ * after {@link utf8StateToError}, which differ only in `prefix`.
+ */
+const restart = (prefix) => (byte) => byte < contTag ? [[...prefix, byte], null]
+    : isLeadByte(byte) ? [[...prefix], [byte]]
+        : [[...prefix, byte | errorMask], null];
 /**
  * Converts a Unicode code point to a sequence of UTF-8 bytes.
  * @param input The Unicode code point to be converted. Valid range:
@@ -135,6 +150,12 @@ export const utf8StateToError = (state) => {
 /**
  * Decodes a byte into a Unicode code point, using a given UTF-8 state.
  *
+ * Rejects overlong 3-/4-byte encodings (Unicode Table 3-7): a lead `E0` must
+ * be followed by a continuation `>= 0xA0`, and a lead `F0` by a continuation
+ * `>= 0x90`. It does not itself reject surrogates (`ED A0..BF`) or code
+ * points above `U+10FFFF` (`F4 90..BF`); {@link fromVec}'s
+ * `isValidCodePoint` pass filters those out of the raw code-point stream.
+ *
  * @param state - The current UTF-8 decoding state.
  * @param byte - A single byte to decode.
  * @returns A tuple containing:
@@ -145,13 +166,8 @@ export const utf8ByteToCodePointOp = (byte, state) => {
     if (byte < 0x00 || byte > 0xff) {
         return [[errorMask], state];
     }
-    if (state === null) {
-        if (byte < contTag)
-            return [[byte], null];
-        if (byte >= 0b1100_0010 && byte <= 0b1111_0100)
-            return [[], [byte]];
-        return [[byte | errorMask], null];
-    }
+    if (state === null)
+        return restart([])(byte);
     if (byte >= contTag && byte < lead2Tag) {
         switch (state.length) {
             case 1: {
@@ -159,8 +175,15 @@ export const utf8ByteToCodePointOp = (byte, state) => {
                 if (s0 < lead3Tag) {
                     return [[((s0 & lead2Mask) << 6) + contPayload(byte)], null];
                 }
-                if (s0 < 0b1111_1000)
-                    return [[], [s0, byte]];
+                if (s0 < 0b1111_1000) {
+                    // Reject overlong 3-/4-byte encodings: after lead `E0` the
+                    // first continuation must be >= 0xA0, after lead `F0` it
+                    // must be >= 0x90 (Unicode Table 3-7).
+                    const overlong = s0 === lead3Tag && byte < 0b1010_0000 ||
+                        s0 === lead4Tag && byte < 0b1001_0000;
+                    if (!overlong)
+                        return [[], [s0, byte]];
+                }
                 break;
             }
             case 2: {
@@ -184,12 +207,7 @@ export const utf8ByteToCodePointOp = (byte, state) => {
             }
         }
     }
-    const error = utf8StateToError(state);
-    if (byte < contTag)
-        return [[error, byte], null];
-    if (byte >= 0b1100_0010 && byte <= 0b1111_0100)
-        return [[error], [byte]];
-    return [[error, byte | errorMask], null];
+    return restart([utf8StateToError(state)])(byte);
 };
 /**
  * Handles the end-of-file (EOF) case for UTF-8 decoding.

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

@@ -1,8 +1,8 @@
-import { toCodePointList, fromCodePointList, fromVec } from "./module.f.js";
-import { stringify as jsonStringify } from "../../json/module.f.js";
-import { sort } from "../../types/object/module.f.js";
-import { toArray } from "../../types/list/module.f.js";
-import { msb, u8ListToVec } from "../../types/bit_vec/module.f.js";
+import { toCodePointList, fromCodePointList, fromVec } from './module.f.js';
+import { stringify as jsonStringify } from '../../media/json/module.f.js';
+import { sort } from '../../types/object/module.f.js';
+import { toArray } from '../../types/list/module.f.js';
+import { msb, u8ListToVec } from '../../types/bit_vec/module.f.js';
 const stringify = jsonStringify(sort);
 export const proof = {
     toCodePoint: [
@@ -65,6 +65,45 @@ export const proof = {
             if (result !== '[-2147448800,-2147432416]') {
                 throw result;
             }
+        },
+        // Overlong 3-byte encodings (E0 80..9F ..) are rejected, not decoded.
+        () => {
+            const result = stringify(toArray(toCodePointList([224, 128, 128])));
+            if (result !== '[-2147483424,-2147483520,-2147483520]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(toArray(toCodePointList([224, 159, 191])));
+            if (result !== '[-2147483424,-2147483489,-2147483457]') {
+                throw result;
+            }
+        },
+        // Overlong 4-byte encodings (F0 80..8F .. ..) are rejected, not decoded.
+        () => {
+            const result = stringify(toArray(toCodePointList([240, 128, 128, 128])));
+            if (result !== '[-2147483408,-2147483520,-2147483520,-2147483520]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(toArray(toCodePointList([240, 143, 191, 191])));
+            if (result !== '[-2147483408,-2147483505,-2147483457,-2147483457]') {
+                throw result;
+            }
+        },
+        // Valid boundary cases still decode: E0 A0 80 -> U+0800, F0 90 80 80 -> U+10000.
+        () => {
+            const result = stringify(toArray(toCodePointList([224, 160, 128])));
+            if (result !== '[2048]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(toArray(toCodePointList([240, 144, 128, 128])));
+            if (result !== '[65536]') {
+                throw result;
+            }
         }
     ],
     fromCodePointList: [
@@ -229,5 +268,19 @@ export const proof = {
                 throw 'expected empty string';
             }
         },
+        // Overlong 3-byte encoding (E0 80 80, would decode to U+0000) → null
+        () => {
+            const v = u8ListToVec(msb)([0xe0, 0x80, 0x80]);
+            if (fromVec(v) !== null) {
+                throw 'expected null for overlong 3-byte encoding';
+            }
+        },
+        // Overlong 4-byte encoding (F0 80 80 80, would decode to U+0000) → null
+        () => {
+            const v = u8ListToVec(msb)([0xf0, 0x80, 0x80, 0x80]);
+            if (fromVec(v) !== null) {
+                throw 'expected null for overlong 4-byte encoding';
+            }
+        },
     ]
 };

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

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

package/fs/types/array/proof.f.js

@@ -1,6 +1,6 @@
-import { at, first, last, head, tail, splitFirst, splitLast, empty } from "./module.f.js";
-import { stringify as jsonStringify } from "../../json/module.f.js";
-import { sort } from "../object/module.f.js";
+import { at, first, last, head, tail, splitFirst, splitLast, empty } from './module.f.js';
+import { stringify as jsonStringify } from '../../media/json/module.f.js';
+import { sort } from '../object/module.f.js';
 const stringify = jsonStringify(sort);
 export const proof = {
     stringify: () => {

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

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { abs, sign } from "../bigint/module.f.js";
+import { abs, sign } from '../bigint/module.f.js';
 const twoPow53 = 9007199254740992n;
 const twoPow54 = 18014398509481984n;
 /**

package/fs/types/bigfloat/proof.f.js

@@ -1,4 +1,4 @@
-import { decToBin } from "./module.f.js";
+import { decToBin } from './module.f.js';
 export const proof = {
     decToBin: [
         () => {

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

@@ -16,8 +16,8 @@
  * const c = combination([3n, 2n, 1n]) // 60n
  * ```
  */
-import { cmp } from "../function/compare/module.f.js";
-import { reduce } from "../list/module.f.js";
+import { cmp } from '../function/compare/module.f.js';
+import { reduce } from '../list/module.f.js';
 /**
  * Adds two `bigint` values.
  *

package/fs/types/bigint/proof.f.js

@@ -1,6 +1,6 @@
-import { sum, abs, serialize, log2, bitLength, mask, combination, factorial, xor, multiple, product, divUp, roundUp, divUp8, roundUp8 } from "./module.f.js";
-import { assertEq } from "../../asserts/module.f.js";
-import { min } from "../function/compare/module.f.js";
+import { sum, abs, serialize, log2, bitLength, mask, combination, factorial, xor, multiple, product, divUp, roundUp, divUp8, roundUp8 } from './module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
+import { min } from '../function/compare/module.f.js';
 const oldLog2 = (v) => {
     if (v <= 0n) {
         return -1n;

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

@@ -21,13 +21,13 @@
  *
  * @module
  */
-import { bitLength, divUp, mask, maxLength, xor } from "../bigint/module.f.js";
-import { flip, identity } from "../function/module.f.js";
-import { iterable, map } from "../list/module.f.js";
-import { asBase, asNominal } from "../nominal/module.f.js";
-import { repeat as mRepeat } from "../monoid/module.f.js";
-import { cmp, max, min } from "../function/compare/module.f.js";
-import { mapUnwrap } from "../nullable/module.f.js";
+import { bitLength, divUp, mask, maxLength, xor } from '../bigint/module.f.js';
+import { flip, identity } from '../function/module.f.js';
+import { iterable, map } from '../list/module.f.js';
+import { asBase, asNominal } from '../nominal/module.f.js';
+import { repeat as mRepeat } from '../../common/monoid/module.f.js';
+import { cmp, max, min } from '../function/compare/module.f.js';
+import { mapUnwrap } from '../nullable/module.f.js';
 /**
  * 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
@@ -352,7 +352,7 @@ const mappedChunkList = (g) => (f) => (bo) => (n) => {
  * @param u The unpacked vector to be chunked.
  * @returns A thunk that produces a list of unsigned integers, each representing one chunk.
  */
-export const uintChunkList = mappedChunkList((identity))(unpackedUint);
+export const uintChunkList = mappedChunkList(identity)(unpackedUint);
 /**
  * Chunks a bit vector into fixed-size pieces of `n` bits using the provided bit order.
  * The last chunk may be smaller than `n` bits if the vector length is not a multiple of `n`.

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

@@ -1,8 +1,8 @@
-import { assertEq } from "../../asserts/module.f.js";
-import { mask } from "../bigint/module.f.js";
-import { asBase, asNominal } from "../nominal/module.f.js";
-import { length, empty, uint, vec, lsb, msb, repeat, vec8, maxLength, u8ListToVec, tryU8ListToVec, u8List, chunkList, fromSentinel } from "./module.f.js";
-import { repeat as listRepeat, toArray } from "../list/module.f.js";
+import { assertEq } from '../../asserts/module.f.js';
+import { mask } from '../bigint/module.f.js';
+import { asBase, asNominal } from '../nominal/module.f.js';
+import { length, empty, uint, vec, lsb, msb, repeat, vec8, maxLength, u8ListToVec, tryU8ListToVec, u8List, chunkList, fromSentinel } from './module.f.js';
+import { repeat as listRepeat, toArray } from '../list/module.f.js';
 const unsafeVec = (a) => asNominal(a);
 // 0x8 = 0b1000 = 0 + 8
 // 0x9 = 0b1001 = 1 + 8

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

@@ -1,4 +1,4 @@
-import { index3, index5 } from "../../function/compare/module.f.js";
+import { index3, index5 } from '../../function/compare/module.f.js';
 const child = (item) => item[1][item[0]];
 export const find = (c) => {
     const i3 = index3(c);

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

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

package/fs/types/btree/find/proof.f.js

@@ -1,10 +1,10 @@
-import { find as btreeFind } from "./module.f.js";
-import { map, toArray } from "../../list/module.f.js";
-import { stringify } from "../../../json/module.f.js";
-import { sort } from "../../object/module.f.js";
-import {} from "../types/module.f.js";
-import { cmp } from "../../string/module.f.js";
-import { set as setSet } from "../set/module.f.js";
+import { find as btreeFind } from './module.f.js';
+import { map, toArray } from '../../list/module.f.js';
+import { stringify } from '../../../media/json/module.f.js';
+import { sort } from '../../object/module.f.js';
+import {} from '../types/module.f.js';
+import { cmp } from '../../string/module.f.js';
+import { set as setSet } from '../set/module.f.js';
 const jsonStr = stringify(sort);
 const set = node => value => setSet(cmp(value))(() => value)(node);
 const str = r => jsonStr(toArray(map((x) => x[0])(r)));

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

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { flat } from "../list/module.f.js";
-import { map } from "../nullable/module.f.js";
+import { flat } from '../list/module.f.js';
+import { map } from '../nullable/module.f.js';
 const nodeValues = node => () => {
     switch (node.length) {
         case 1:

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

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

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

@@ -1,10 +1,10 @@
-import { values } from "./module.f.js";
-import { stringify as jsonStringify } from "../../json/module.f.js";
-import { sort } from "../object/module.f.js";
-import { cmp } from "../string/module.f.js";
-import { next, toArray } from "../list/module.f.js";
-import { set as setSet } from "./set/module.f.js";
-import { value, find as findFind } from "./find/module.f.js";
+import { values } from './module.f.js';
+import { stringify as jsonStringify } from '../../media/json/module.f.js';
+import { sort } from '../object/module.f.js';
+import { cmp } from '../string/module.f.js';
+import { next, toArray } from '../list/module.f.js';
+import { set as setSet } from './set/module.f.js';
+import { value, find as findFind } from './find/module.f.js';
 const jsonStr = jsonStringify(sort);
 const stringify = sequence => jsonStr(toArray(sequence));
 const set = node => value => setSet(cmp(value))(() => value)(node);

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

@@ -3,10 +3,10 @@
  *
  * @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";
+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';
 const path = (tail) => (n) => {
     switch (n.length) {
         case 1: {

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

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

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

@@ -1,8 +1,8 @@
-import { nodeRemove } from "./module.f.js";
-import { set as setSet } from "../set/module.f.js";
-import { cmp } from "../../string/module.f.js";
-import { stringify } from "../../../json/module.f.js";
-import { sort } from "../../object/module.f.js";
+import { nodeRemove } from './module.f.js';
+import { set as setSet } from '../set/module.f.js';
+import { cmp } from '../../string/module.f.js';
+import { stringify } from '../../../media/json/module.f.js';
+import { sort } from '../../object/module.f.js';
 const set = (node) => (value) => setSet(cmp(value))(() => value)(node);
 const remove = (node) => (value) => nodeRemove(cmp(value))(node);
 const jsonStr = stringify(sort);

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

@@ -3,9 +3,9 @@
  *
  * @module
  */
-import { collapseRoot } from "../types/module.f.js";
-import { find } from "../find/module.f.js";
-import { fold } from "../../list/module.f.js";
+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]]];
 const reduceOp = ([i, x]) => a => {
     switch (i) {