functionalscript 0.1.609 → 0.2.0

package/text/utf16/test.f.mjs

@@ -1,10 +1,10 @@
-import encoding from './module.f.mjs'
-import json, * as Json from '../../json/module.f.mjs'
-import o from '../../types/object/module.f.mjs'
+import * as encoding from './module.f.mjs'
+import * as json from '../../json/module.f.mjs'
+import * as o from '../../types/object/module.f.mjs'
 const { sort } = o
-import list from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 
-/** @type {(a: readonly Json.Unknown[]) => string} */
+/** @type {(a: readonly json.Unknown[]) => string} */
 const stringify = a => json.stringify(sort)(a)
 
 export default {

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

@@ -1,15 +1,10 @@
-declare namespace _default {
-    export { fromCodePointList };
-    export { toCodePointList };
-}
-export default _default;
+export const fromCodePointList: (input: list.List<number>) => list.Thunk<number>;
+/** @type {(input: list.List<u8>) => list.List<i32>} */
+export const toCodePointList: (input: list.List<u8>) => list.List<i32>;
 export type ByteOrEof = u8 | null;
 export type Utf8NonEmptyState = Array.Array1<number> | Array.Array2<number> | Array.Array3<number>;
 export type Utf8State = null | Utf8NonEmptyState;
 export type u8 = number;
 export type i32 = number;
-declare const fromCodePointList: (input: List.List<number>) => List.Thunk<number>;
-/** @type {(input: List.List<u8>) => List.List<i32>} */
-declare const toCodePointList: (input: List.List<u8>) => List.List<i32>;
+import * as list from '../../types/list/module.f.mjs';
 import * as Array from '../../types/array/module.f.mjs';
-import * as List from '../../types/list/module.f.mjs';

package/text/utf8/module.f.mjs

@@ -1,5 +1,5 @@
 // @ts-self-types="./module.f.d.mts"
-import list, * as List from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 import * as operator from '../../types/function/operator/module.f.mjs'
 import * as Array from '../../types/array/module.f.mjs'
 const { flatMap, flat, stateScan } = list
@@ -16,7 +16,7 @@ const { flatMap, flat, stateScan } = list
 
 const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
 
-/** @type {(input:number) => List.List<u8>} */
+/** @type {(input:number) => list.List<u8>} */
 const codePointToUtf8 = input => {
     if (input >= 0x0000 && input <= 0x007f) { return [input & 0b01111_1111] }
     if (input >= 0x0080 && input <= 0x07ff) { return [input >> 6 | 0b1100_0000, input & 0b0011_1111 | 0b1000_0000] }
@@ -31,7 +31,7 @@ const codePointToUtf8 = input => {
     return [errorMask]
 }
 
-const fromCodePointList = flatMap(codePointToUtf8)
+export const fromCodePointList = flatMap(codePointToUtf8)
 
 /** @type {(state: Utf8NonEmptyState) => i32}*/
 const utf8StateToError = state => {
@@ -59,7 +59,7 @@ const utf8StateToError = state => {
     return x | errorMask
 }
 
-/** @type {operator.StateScan<number, Utf8State, List.List<i32>>} */
+/** @type {operator.StateScan<number, Utf8State, list.List<i32>>} */
 const utf8ByteToCodePointOp = state => byte => {
     if (byte < 0x00 || byte > 0xff) {
         return [[errorMask], state]
@@ -95,22 +95,15 @@ const utf8ByteToCodePointOp = state => byte => {
     return [[error, byte | errorMask], null]
 }
 
-/** @type {(state: Utf8State) => readonly[List.List<i32>, Utf8State]} */
+/** @type {(state: Utf8State) => readonly[list.List<i32>, Utf8State]} */
 const utf8EofToCodePointOp = state =>
     [state === null ? null : [utf8StateToError(state)], null]
 
-/** @type {operator.StateScan<ByteOrEof, Utf8State, List.List<i32>>} */
+/** @type {operator.StateScan<ByteOrEof, Utf8State, list.List<i32>>} */
 const utf8ByteOrEofToCodePointOp = state => input => input === null ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
 
-/** @type {List.List<ByteOrEof>} */
+/** @type {list.List<ByteOrEof>} */
 const eofList = [null]
 
-/** @type {(input: List.List<u8>) => List.List<i32>} */
-const toCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
-
-export default {
-    /** @readonly */
-    fromCodePointList,
-    /** @readonly */
-    toCodePointList
-}
+/** @type {(input: list.List<u8>) => list.List<i32>} */
+export const toCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])))

package/text/utf8/test.f.mjs

@@ -1,8 +1,8 @@
-import encoding from './module.f.mjs'
-import json from '../../json/module.f.mjs'
-import o from '../../types/object/module.f.mjs'
+import * as encoding from './module.f.mjs'
+import * as json from '../../json/module.f.mjs'
+import * as o from '../../types/object/module.f.mjs'
 const { sort } = o
-import list from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 
 const stringify = json.stringify(sort)
 

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

@@ -1,13 +1,17 @@
-declare namespace _default {
-    export { at };
-    export { first };
-    export { last };
-    export { head };
-    export { tail };
-    export { splitFirst };
-    export { splitLast };
-}
-export default _default;
+/** @type {(index: number) => <T>(a: readonly T[]) => T|null} */
+export const at: (index: number) => <T>(a: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => T|null} */
+export const first: <T>(_: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => T|null} */
+export const last: <T>(_: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => readonly T[] | null} */
+export const tail: <T>(_: readonly T[]) => readonly T[] | null;
+/** @type {<T>(_: readonly T[]) => readonly[T, readonly T[]]|null} */
+export const splitFirst: <T>(_: readonly T[]) => readonly [T, readonly T[]] | null;
+/** @type {<T>(_: readonly T[]) => readonly T[]|null} */
+export const head: <T>(_: readonly T[]) => readonly T[] | null;
+/** @type {<T>(_: readonly T[]) => readonly[readonly T[], T]|null} */
+export const splitLast: <T>(_: readonly T[]) => readonly [readonly T[], T] | null;
 export type Array1<T> = readonly [T];
 export type Index1 = 0;
 export type Array2<T> = readonly [T, T];
@@ -25,17 +29,3 @@ export type Index16 = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13
 export type Array1_5<T> = Array1<T> | Array2<T> | Array3<T> | Array4<T> | Array5<T>;
 export type Index5 = 0 | 1 | 2 | 3 | 4;
 export type KeyOf<T> = T extends Array1<infer _> ? Index1 : T extends Array2<infer _> ? Index2 : T extends Array3<infer _> ? Index3 : T extends Array4<infer _> ? Index4 : T extends Array5<infer _> ? Index5 : T extends readonly (infer _)[] ? number : never;
-/** @type {(index: number) => <T>(a: readonly T[]) => T|null} */
-declare const at: (index: number) => <T>(a: readonly T[]) => T | null;
-/** @type {<T>(_: readonly T[]) => T|null} */
-declare const first: <T>(_: readonly T[]) => T | null;
-/** @type {<T>(_: readonly T[]) => T|null} */
-declare const last: <T>(_: readonly T[]) => T | null;
-/** @type {<T>(_: readonly T[]) => readonly T[]|null} */
-declare const head: <T>(_: readonly T[]) => readonly T[] | null;
-/** @type {<T>(_: readonly T[]) => readonly T[] | null} */
-declare const tail: <T>(_: readonly T[]) => readonly T[] | null;
-/** @type {<T>(_: readonly T[]) => readonly[T, readonly T[]]|null} */
-declare const splitFirst: <T>(_: readonly T[]) => readonly [T, readonly T[]] | null;
-/** @type {<T>(_: readonly T[]) => readonly[readonly T[], T]|null} */
-declare const splitLast: <T>(_: readonly T[]) => readonly [readonly T[], T] | null;

package/types/array/module.f.mjs

@@ -1,5 +1,5 @@
 // @ts-self-types="./module.f.d.mts"
-import option from '../nullable/module.f.mjs'
+import * as option from '../nullable/module.f.mjs'
 const { map } = option
 
 /**
@@ -86,22 +86,22 @@ const uncheckTail = a => a.slice(1)
 const uncheckHead = a => a.slice(0, -1)
 
 /** @type {(index: number) => <T>(a: readonly T[]) => T|null} */
-const at = i => a => {
+export const at = i => a => {
     const r = a[i]
     return r === void 0 ? null : r
 }
 
 /** @type {<T>(_: readonly T[]) => T|null} */
-const first = at(0)
+export const first = at(0)
 
 /** @type {<T>(_: readonly T[]) => T|null} */
-const last = a => at(a.length - 1)(a)
+export const last = a => at(a.length - 1)(a)
 
 /** @type {<T>(_: readonly T[]) => readonly T[] | null} */
-const tail = a => a.length === 0 ? null : uncheckTail(a)
+export const tail = a => a.length === 0 ? null : uncheckTail(a)
 
 /** @type {<T>(_: readonly T[]) => readonly[T, readonly T[]]|null} */
-const splitFirst = a => {
+export const splitFirst = a => {
     /** @typedef {typeof a[0]} T*/
     /** @type {(_: T) => readonly[T, readonly T[]]} */
     const split = first => [first, uncheckTail(a)]
@@ -109,28 +109,11 @@ const splitFirst = a => {
 }
 
 /** @type {<T>(_: readonly T[]) => readonly T[]|null} */
-const head = a => a.length === 0 ? null : uncheckHead(a)
+export const head = a => a.length === 0 ? null : uncheckHead(a)
 
 /** @type {<T>(_: readonly T[]) => readonly[readonly T[], T]|null} */
-const splitLast = a => {
+export const splitLast = a => {
     const lastA = last(a)
     if (lastA === null) { return null }
     return [uncheckHead(a), lastA]
 }
-
-export default {
-    /** @readonly */
-    at,
-    /** @readnly */
-    first,
-    /** @readonly */
-    last,
-    /** @readonly */
-    head,
-    /** @readonly */
-    tail,
-    /** @readonly */
-    splitFirst,
-    /** @readonly */
-    splitLast,
-}

package/types/array/test.f.mjs

@@ -1,6 +1,6 @@
-import _ from './module.f.mjs'
-import json from '../../json/module.f.mjs'
-import o from '../object/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as json from '../../json/module.f.mjs'
+import * as o from '../object/module.f.mjs'
 const { sort } = o
 
 const stringify = json.stringify(sort)

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

@@ -1,11 +1,6 @@
-declare namespace _default {
-    export { decToBin };
-    export { multiply };
-}
-export default _default;
+/** @type {(b: BigFloat) => (mul: bigint) => BigFloat} */
+export const multiply: (b: BigFloat) => (mul: bigint) => BigFloat;
+/** @type {(dec: BigFloat) => BigFloat} */
+export const decToBin: (dec: BigFloat) => BigFloat;
 export type BigFloat = readonly [bigint, number];
 export type BigFloatWithRemainder = readonly [BigFloat, bigint];
-/** @type {(dec: BigFloat) => BigFloat} */
-declare const decToBin: (dec: BigFloat) => BigFloat;
-/** @type {(b: BigFloat) => (mul: bigint) => BigFloat} */
-declare const multiply: (b: BigFloat) => (mul: bigint) => BigFloat;

package/types/bigfloat/module.f.mjs

@@ -1,5 +1,5 @@
 // @ts-self-types="./module.f.d.mts"
-import bi from '../bigint/module.f.mjs'
+import * as bi from '../bigint/module.f.mjs'
 const { abs, sign } = bi
 
 /** @typedef {readonly[bigint,number]} BigFloat */
@@ -47,7 +47,7 @@ const pow = base => exp => base ** BigInt(exp)
 const pow5 = pow(5n)
 
 /** @type {(b: BigFloat) => (mul: bigint) => BigFloat} */
-const multiply = ([m, e]) => mul => [m * mul, e]
+export const multiply = ([m, e]) => mul => [m * mul, e]
 
 /** @type {(b: BigFloat) => (div: bigint) => BigFloatWithRemainder} */
 const divide = ([m, e]) => div => [[m / div, e], m % div]
@@ -68,7 +68,7 @@ const round53 = ([[m, e], r]) => {
 }
 
 /** @type {(dec: BigFloat) => BigFloat} */
-const decToBin = dec => {
+export const decToBin = dec => {
     if (dec[0] === 0n) {
         return [0n, 0]
     }
@@ -86,10 +86,3 @@ const decToBin = dec => {
     const r53 = round53(qr)
     return multiply(r53)(s)
 }
-
-export default {
-    /** @readonly */
-    decToBin,
-    /** @readonly */
-    multiply
-}

package/types/bigfloat/test.f.mjs

@@ -1,4 +1,4 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 const { decToBin } = _
 
 export default {

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

@@ -1,29 +1,13 @@
-declare namespace _default {
-    export { addition };
-    export { sum };
-    export { abs };
-    export { sign };
-    export { serialize };
-    export { scalar_mul };
-    export { log2 };
-    export { bitLength };
-}
-export default _default;
-export type Unary = Operator.Unary<bigint, bigint>;
-export type Additive<T> = {
-    readonly 0: T;
-    readonly add: Operator.Reduce<T>;
-};
 /** @typedef {Operator.Unary<bigint, bigint>} Unary*/
 /** @type {(a: bigint) => (b: bigint) => bigint} */
-declare const addition: (a: bigint) => (b: bigint) => bigint;
-declare const sum: (input: import("../list/module.f.mjs").List<bigint>) => bigint;
+export const addition: (a: bigint) => (b: bigint) => bigint;
+export const sum: (input: list.List<bigint>) => bigint;
 /** @type {(a: bigint) => bigint} */
-declare const abs: (a: bigint) => bigint;
-/** @type {(a: bigint) => Compare.Sign} */
-declare const sign: (a: bigint) => Compare.Sign;
+export const abs: (a: bigint) => bigint;
+/** @type {(a: bigint) => compare.Sign} */
+export const sign: (a: bigint) => compare.Sign;
 /** @type {(a: bigint) => string} */
-declare const serialize: (a: bigint) => string;
+export const serialize: (a: bigint) => string;
 /**
  * @template T
  * @typedef {{
@@ -32,46 +16,14 @@ declare const serialize: (a: bigint) => string;
  * }} Additive
  */
 /** @type {<T>(a: Additive<T>) => (a: T) => (n: bigint) => T} */
-declare const scalar_mul: <T>(a: Additive<T>) => (a: T) => (n: bigint) => T;
-/**
- * Calculates the base-2 logarithm (floor).
- *
- * This function returns the integer part of the logarithm. For example:
- * - `log2(1n)` returns `0n`,
- * - `log2(2n)` returns `1n`,
- * - `log2(15n)` returns `3n`.
- *
- * @param {bigint} v - The input BigInt.
- * @returns {bigint} The base-2 logarithm (floor) of the input BigInt, or `-1n` if the input is less than or equal to 0.
- *
- * @remarks
- * The function operates in two phases:
- * 1. **Fast Doubling Phase:** Uses exponential steps to quickly narrow down the range
- *    of the most significant bit.
- * 2. **Binary Search Phase:** Refines the result by halving the step size and incrementally
- *    determining the exact value of the logarithm.
- */
-declare function log2(v: bigint): bigint;
-/**
- * Calculates the bit length of a given BigInt.
- *
- * The bit length of a number is the number of bits required to represent its absolute value in binary,
- * excluding leading zeros. For example:
- * - `0n` has a bit length of 0 (it has no bits).
- * - `1n` (binary `1`) has a bit length of 1.
- * - `255n` (binary `11111111`) has a bit length of 8.
- * - `-255n` (absolute value `255`, binary `11111111`) also has a bit length of 8.
- *
- * The function handles both positive and negative numbers. For negative inputs, the bit length is calculated
- * based on the absolute value of the number. Zero has a bit length of 0.
- *
- * @param {bigint} v - The input BigInt.
- * @returns {bigint} The bit length of the input BigInt.
- *
- * @remark
- * The function uses the `log2` function to calculate the position of the most significant bit(MSB)
- * and adds `1n` to account for the MSB itself.For negative numbers, the absolute value is used.
- */
-declare function bitLength(v: bigint): bigint;
+export const scalar_mul: <T>(a: Additive<T>) => (a: T) => (n: bigint) => T;
+export function log2(v: bigint): bigint;
+export function bitLength(v: bigint): bigint;
+export type Unary = Operator.Unary<bigint, bigint>;
+export type Additive<T> = {
+    readonly 0: T;
+    readonly add: Operator.Reduce<T>;
+};
+import * as list from '../list/module.f.mjs';
+import * as compare from '../function/compare/module.f.mjs';
 import * as Operator from '../function/operator/module.f.mjs';
-import * as Compare from '../function/compare/module.f.mjs';

package/types/bigint/module.f.mjs

@@ -1,25 +1,25 @@
 // @ts-self-types="./module.f.d.mts"
-import compare, * as Compare from '../function/compare/module.f.mjs'
+import * as compare from '../function/compare/module.f.mjs'
 import * as Operator from '../function/operator/module.f.mjs'
 const { unsafeCmp } = compare
-import list from '../list/module.f.mjs'
+import * as list from '../list/module.f.mjs'
 const { reduce } = list
 
 /** @typedef {Operator.Unary<bigint, bigint>} Unary*/
 
 /** @type {(a: bigint) => (b: bigint) => bigint} */
-const addition = a => b => a + b
+export const addition = a => b => a + b
 
-const sum = reduce(addition)(0n)
+export const sum = reduce(addition)(0n)
 
 /** @type {(a: bigint) => bigint} */
-const abs = a => a >= 0 ? a : -a
+export const abs = a => a >= 0 ? a : -a
 
-/** @type {(a: bigint) => Compare.Sign} */
-const sign = a => unsafeCmp(a)(0n)
+/** @type {(a: bigint) => compare.Sign} */
+export const sign = a => unsafeCmp(a)(0n)
 
 /** @type {(a: bigint) => string} */
-const serialize = a => `${a}n`
+export const serialize = a => `${a}n`
 
 /**
  * @template T
@@ -30,7 +30,7 @@ const serialize = a => `${a}n`
  */
 
 /** @type {<T>(a: Additive<T>) => (a: T) => (n: bigint) => T} */
-const scalar_mul = ({ 0: _0, add }) => a => n => {
+export const scalar_mul = ({ 0: _0, add }) => a => n => {
     let ai = a
     let ni = n
     let result = _0
@@ -64,7 +64,7 @@ const scalar_mul = ({ 0: _0, add }) => a => n => {
  * 2. **Binary Search Phase:** Refines the result by halving the step size and incrementally
  *    determining the exact value of the logarithm.
  */
-const log2 = v => {
+export const log2 = v => {
     if (v <= 0n) { return -1n }
     let result = 0n
     let i = 1n
@@ -111,29 +111,10 @@ const log2 = v => {
  * The function uses the `log2` function to calculate the position of the most significant bit(MSB)
  * and adds `1n` to account for the MSB itself.For negative numbers, the absolute value is used.
  */
-const bitLength = v => {
+export const bitLength = v => {
     if (v <= 0n) {
         if (v === 0n) { return 0n }
         v = -v
     }
     return log2(v) + 1n
 }
-
-export default {
-    /** @readonly */
-    addition,
-    /** @readonly */
-    sum,
-    /** @readonly */
-    abs,
-    /** @readonly */
-    sign,
-    /** @readonly */
-    serialize,
-    /** @readonly */
-    scalar_mul,
-    /** @readonly */
-    log2,
-    /** @readonly */
-    bitLength,
-}

package/types/bigint/test.f.mjs

@@ -1,4 +1,4 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 const { sum, abs, serialize, log2, bitLength } = _
 
 export default {

package/types/btree/find/module.f.d.mts

@@ -1,12 +1,23 @@
-declare namespace _default {
-    export { find };
-    export { value };
-    export { isFound };
-}
-export default _default;
-export type FirstLeaf1<T> = readonly [cmpT.Index3, _.Leaf1<T>];
+/**
+ * @template T
+ * @typedef {List.List<PathItem<T>>} Path
+ */
+/**
+ * @template T
+ * @typedef {{
+ *  readonly first: First<T>,
+ *  readonly tail: Path<T>
+ * }} Result<T>
+ */
+/** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => Result<T>} */
+export const find: <T>(c: cmp.Compare<T>) => (node: _.Node<T>) => Result<T>;
+/** @type {<T>(first: First<T>) => boolean} */
+export const isFound: <T>(first: First<T>) => boolean;
+/** @type {<T>(first: First<T>) => T | null} */
+export const value: <T>(first: First<T>) => T | null;
+export type FirstLeaf1<T> = readonly [cmp.Index3, _.Leaf1<T>];
 export type FirstBranch3<T> = readonly [1, _.Branch3<T>];
-export type FirstLeaf2<T> = readonly [cmpT.Index5, _.Leaf2<T>];
+export type FirstLeaf2<T> = readonly [cmp.Index5, _.Leaf2<T>];
 export type FirstBranch5<T> = readonly [1 | 3, _.Branch5<T>];
 export type First<T> = FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>;
 export type PathItem3<T> = readonly [0 | 2, _.Branch3<T>];
@@ -20,23 +31,6 @@ export type Result<T> = {
     readonly first: First<T>;
     readonly tail: Path<T>;
 };
-/**
- * @template T
- * @typedef {List.List<PathItem<T>>} Path
- */
-/**
- * @template T
- * @typedef {{
- *  readonly first: First<T>,
- *  readonly tail: Path<T>
- * }} Result<T>
- */
-/** @type {<T>(c: cmpT.Compare<T>) => (node: _.Node<T>) => Result<T>} */
-declare const find: <T>(c: cmpT.Compare<T>) => (node: _.Node<T>) => Result<T>;
-/** @type {<T>(first: First<T>) => T | null} */
-declare const value: <T>(first: First<T>) => T | null;
-/** @type {<T>(first: First<T>) => boolean} */
-declare const isFound: <T>(first: First<T>) => boolean;
-import * as cmpT from '../../function/compare/module.f.mjs';
+import * as cmp from '../../function/compare/module.f.mjs';
 import * as _ from '../types/module.f.mjs';
 import * as List from '../../list/module.f.mjs';

package/types/btree/find/module.f.mjs

@@ -1,13 +1,13 @@
 // @ts-self-types="./module.f.d.mts"
 import * as _ from '../types/module.f.mjs'
 import * as List from '../../list/module.f.mjs'
-import cmp, * as cmpT from '../../function/compare/module.f.mjs'
+import * as cmp from '../../function/compare/module.f.mjs'
 const { index3, index5 } = cmp
 import * as Array from '../../array/module.f.mjs'
 
 /**
  * @template T
- * @typedef {readonly[cmpT.Index3, _.Leaf1<T>]} FirstLeaf1
+ * @typedef {readonly[cmp.Index3, _.Leaf1<T>]} FirstLeaf1
  */
 
 /**
@@ -17,7 +17,7 @@ import * as Array from '../../array/module.f.mjs'
 
 /**
  * @template T
- * @typedef {readonly[cmpT.Index5, _.Leaf2<T>]} FirstLeaf2
+ * @typedef {readonly[cmp.Index5, _.Leaf2<T>]} FirstLeaf2
  */
 
 /**
@@ -62,11 +62,11 @@ const child = item =>
  * }} Result<T>
  */
 
-/** @type {<T>(c: cmpT.Compare<T>) => (node: _.Node<T>) => Result<T>} */
-const find = c => {
+/** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => Result<T>} */
+export const find = c => {
     const i3 = index3(c)
     const i5 = index5(c)
-    /** @typedef {typeof c extends cmpT.Compare<infer T> ? T : never} T */
+    /** @typedef {typeof c extends cmp.Compare<infer T> ? T : never} T */
     /** @type {(prior: Path<T>) => (node: _.Node<T>) => Result<T>} */
     const f = tail => node => {
         /** @type {(index: Array.KeyOf<typeof node>) => Result<T>} */
@@ -99,7 +99,7 @@ const find = c => {
 }
 
 /** @type {<T>(first: First<T>) => boolean} */
-const isFound = ([i]) => {
+export const isFound = ([i]) => {
     switch (i) {
         case 1: case 3: { return true }
         default: { return false }
@@ -107,7 +107,7 @@ const isFound = ([i]) => {
 }
 
 /** @type {<T>(first: First<T>) => T | null} */
-const value = ([i, r]) => {
+export const value = ([i, r]) => {
     switch (i) {
         case 1: {
             switch (r.length) {
@@ -123,12 +123,3 @@ const value = ([i, r]) => {
         }
     }
 }
-
-export default {
-    /** @readonly */
-    find,
-    /** @readonly */
-    value,
-    /** @readonly */
-    isFound,
-}

package/types/btree/find/test.f.mjs

@@ -1,19 +1,19 @@
-import _, * as T from './module.f.mjs'
-import list from '../../list/module.f.mjs'
-import json, * as Json from '../../../json/module.f.mjs'
-import o from '../../object/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as list from '../../list/module.f.mjs'
+import * as json from '../../../json/module.f.mjs'
+import * as o from '../../object/module.f.mjs'
 const { sort } = o
 import * as btree from '../types/module.f.mjs'
-import string from '../../string/module.f.mjs'
+import * as string from '../../string/module.f.mjs'
 const { cmp } = string
-import s from '../set/module.f.mjs'
+import * as s from '../set/module.f.mjs'
 
 const jsonStr = json.stringify(sort)
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
 const set = node => value => s.set(cmp(value))(() => value)(node)
 
-/** @type {(r: T.Result<Json.Unknown>) => string} */
+/** @type {(r: _.Result<json.Unknown>) => string} */
 const str = r => jsonStr(list.toArray(list.map(x => x[0])(r)))
 
 /** @type {(i: string) => (m: btree.Node<string>) => string} */

package/types/btree/module.f.d.mts

@@ -1,9 +1,5 @@
-declare namespace _default {
-    export let empty: null;
-    export { values };
-}
-export default _default;
-/** @type {<T>(tree: _.Tree<T>) => List.List<T>} */
-declare const values: <T>(tree: _.Tree<T>) => List.List<T>;
+export const empty: null;
+/** @type {<T>(tree: _.Tree<T>) => list.List<T>} */
+export const values: <T>(tree: _.Tree<T>) => list.List<T>;
 import * as _ from './types/module.f.mjs';
-import * as List from '../list/module.f.mjs';
+import * as list from '../list/module.f.mjs';