functionalscript 0.1.608 → 0.2.0

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';

package/types/btree/module.f.mjs

@@ -1,12 +1,12 @@
 // @ts-self-types="./module.f.d.mts"
 
-import list, * as List from '../list/module.f.mjs'
+import * as list from '../list/module.f.mjs'
 const { flat } = list
-import n from '../nullable/module.f.mjs'
+import * as n from '../nullable/module.f.mjs'
 const { map } = n
 import * as _ from './types/module.f.mjs'
 
-/** @type {<T>(node: _.Node<T>) => List.Thunk<T>} */
+/** @type {<T>(node: _.Node<T>) => list.Thunk<T>} */
 const nodeValues = node => () => {
     switch (node.length) {
         case 1: case 2: { return node }
@@ -29,12 +29,7 @@ const nodeValues = node => () => {
     }
 }
 
-/** @type {<T>(tree: _.Tree<T>) => List.List<T>} */
-const values = map(nodeValues)
+export const empty = null
 
-export default {
-    /** @readonly */
-    empty: null,
-    /** @readonly */
-    values,
-}
+/** @type {<T>(tree: _.Tree<T>) => list.List<T>} */
+export const values = map(nodeValues)

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

@@ -1,19 +1,14 @@
-declare namespace _default {
-    export { nodeRemove };
-    export { remove };
-}
-export default _default;
+/** @type {<T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
+export const nodeRemove: <T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>;
+/** @type {<T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
+export const remove: <T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>;
 export type Leaf01<T> = null | _.Leaf1<T>;
 export type RemovePath<T> = {
     readonly first: Leaf01<T>;
-    readonly tail: Find.Path<T>;
+    readonly tail: find.Path<T>;
 };
 export type Branch<T> = _.Branch1<T> | _.Branch3<T> | _.Branch5<T>;
 export type Merge<A, T> = (a: A) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>;
-/** @type {<T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
-declare const nodeRemove: <T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>;
-/** @type {<T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
-declare const remove: <T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>;
-import * as _ from '../types/module.f.mjs';
-import * as Find from '../find/module.f.mjs';
 import * as Cmp from '../../function/compare/module.f.mjs';
+import * as _ from '../types/module.f.mjs';
+import * as find from '../find/module.f.mjs';

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

@@ -1,11 +1,11 @@
 // @ts-self-types="./module.f.d.mts"
 import * as _ from '../types/module.f.mjs'
 import * as Cmp from '../../function/compare/module.f.mjs'
-import find, * as Find from '../find/module.f.mjs'
-import list from '../../list/module.f.mjs'
+import * as find from '../find/module.f.mjs'
+import * as list from '../../list/module.f.mjs'
 const { fold, concat, next } = list
 import * as Array from '../../array/module.f.mjs'
-import n from '../../nullable/module.f.mjs'
+import * as n from '../../nullable/module.f.mjs'
 const { map } = n
 
 /**
@@ -17,11 +17,11 @@ const { map } = n
  * @template T
  * @typedef {{
  *  readonly first: Leaf01<T>,
- *  readonly tail: Find.Path<T>
+ *  readonly tail: find.Path<T>
  * }} RemovePath
  */
 
-/** @type {<T>(tail: Find.Path<T>) => (n: _.Node<T>) => readonly[T, RemovePath<T>]} */
+/** @type {<T>(tail: find.Path<T>) => (n: _.Node<T>) => readonly[T, RemovePath<T>]} */
 const path = tail => n => {
     switch (n.length) {
         case 1: { return [n[0], { first: null, tail }] }
@@ -95,7 +95,7 @@ const initValue1 = a => n => {
  * @typedef {(a: A) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} Merge
  */
 
-/** @type {<A, T>(ms: Array.Array2<Merge<A, T>>) => (i: Find.PathItem<T>) => (a: A) => Branch<T>} */
+/** @type {<A, T>(ms: Array.Array2<Merge<A, T>>) => (i: find.PathItem<T>) => (a: A) => Branch<T>} */
 const reduceX = ms => ([i, n]) => a => {
     const [m0, m2] = ms
     /** @typedef {typeof ms extends Array.Array2<Merge<infer A, infer T>> ? [A,T] : never} AT */
@@ -118,14 +118,14 @@ const reduce = fold(reduceX([reduceValue0, reduceValue2]))
 const initReduce = reduceX([initValue0, initValue1])
 
 /** @type {<T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
-const nodeRemove = c => node => {
+export const nodeRemove = c => node => {
     /** @typedef {typeof c extends Cmp.Compare<infer T> ? T : never} T */
     /** @type  {() => null | RemovePath<T>} */
     const f = () => {
         const { first, tail } = find.find(c)(node)
-        /** @type {(n: _.Node<T>) => (f: (v: T) => Find.PathItem<T>) => RemovePath<T>} */
+        /** @type {(n: _.Node<T>) => (f: (v: T) => find.PathItem<T>) => RemovePath<T>} */
         const branch = n => f => {
-            const [v, p] = path(/** @type {Find.Path<T>} */(null))(n)
+            const [v, p] = path(/** @type {find.Path<T>} */(null))(n)
             return { first: p.first, tail: concat(p.tail)({ first: f(v), tail }) }
         }
         const [i, n] = first
@@ -158,11 +158,4 @@ const nodeRemove = c => node => {
 }
 
 /** @type {<T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
-const remove =  c => map(nodeRemove(c))
-
-export default {
-    /** @readonly */
-    nodeRemove,
-    /** @readonly */
-    remove,
-}
+export const remove =  c => map(nodeRemove(c))

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

@@ -1,10 +1,10 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 import * as BTree from '../types/module.f.mjs'
-import s from '../set/module.f.mjs'
-import str from '../../string/module.f.mjs'
+import * as s from '../set/module.f.mjs'
+import * as str from '../../string/module.f.mjs'
 const { cmp } = str
-import json from '../../../json/module.f.mjs'
-import o from '../../object/module.f.mjs'
+import * as json from '../../../json/module.f.mjs'
+import * as o from '../../object/module.f.mjs'
 const { sort } = o
 
 /** @type {(node: BTree.Node<string>) => (value: string) => BTree.Node<string>} */

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

@@ -1,9 +1,5 @@
-declare namespace _default {
-    export { set };
-}
-export default _default;
-export type Branch1To3<T> = _.Branch1<T> | _.Branch3<T>;
 /** @type {<T>(c: Cmp.Compare<T>) => (f: (value: T|null) => T) => (tree: _.Tree<T>) => _.Node<T>} */
-declare const set: <T>(c: Cmp.Compare<T>) => (f: (value: T | null) => T) => (tree: _.Tree<T>) => _.Node<T>;
-import * as _ from '../types/module.f.mjs';
+export const set: <T>(c: Cmp.Compare<T>) => (f: (value: T | null) => T) => (tree: _.Tree<T>) => _.Node<T>;
+export type Branch1To3<T> = _.Branch1<T> | _.Branch3<T>;
 import * as Cmp from '../../function/compare/module.f.mjs';
+import * as _ from '../types/module.f.mjs';