functionalscript 0.1.609 → 0.2.1

package/text/utf16/module.f.mjs

@@ -1,9 +1,9 @@
 // @ts-self-types="./module.f.d.mts"
-import list, * as List from '../../types/list/module.f.mjs'
-import operator, * as Operator from '../../types/function/operator/module.f.mjs'
-import range from '../../types/range/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
+import * as operator from '../../types/function/operator/module.f.mjs'
+import * as range from '../../types/range/module.f.mjs'
 const { contains } = range
-import f from '../../types/function/module.f.mjs'
+import * as f from '../../types/function/module.f.mjs'
 const { fn } = f
 const { map, flat, stateScan, reduce, flatMap, empty } = list
 
@@ -32,7 +32,7 @@ const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
 /** @type {(a: i32) => boolean} */
 const isSupplementaryPlane = contains([0x01_0000, 0x10_ffff])
 
-/** @type {(input: i32) => List.List<u16>} */
+/** @type {(input: i32) => list.List<u16>} */
 const codePointToUtf16 = codePoint => {
     if (isBmpCodePoint(codePoint)) { return [codePoint] }
     if (isSupplementaryPlane(codePoint)) {
@@ -44,11 +44,11 @@ const codePointToUtf16 = codePoint => {
     return [codePoint & 0xffff]
 }
 
-const fromCodePointList = flatMap(codePointToUtf16)
+export const fromCodePointList = flatMap(codePointToUtf16)
 
 const u16 = contains([0x0000, 0xFFFF])
 
-/** @type {Operator.StateScan<u16, Utf16State, List.List<i32>>} */
+/** @type {operator.StateScan<u16, Utf16State, list.List<i32>>} */
 const utf16ByteToCodePointOp = state => word => {
     if (!u16(word)) {
         return [[0xffffffff], state]
@@ -68,21 +68,21 @@ const utf16ByteToCodePointOp = state => word => {
     return [[state | errorMask, word | errorMask], null]
 }
 
-/** @type {(state: Utf16State) => readonly[List.List<i32>, Utf16State]} */
+/** @type {(state: Utf16State) => readonly[list.List<i32>, Utf16State]} */
 const utf16EofToCodePointOp = state => [state === null ? empty : [state | errorMask],  null]
 
-/** @type {Operator.StateScan<WordOrEof, Utf16State, List.List<i32>>} */
+/** @type {operator.StateScan<WordOrEof, Utf16State, list.List<i32>>} */
 const utf16ByteOrEofToCodePointOp = state => input => input === null ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input)
 
-/** @type {List.List<WordOrEof>} */
+/** @type {list.List<WordOrEof>} */
 const eofList = [null]
 
-/** @type {(input: List.List<u16>) => List.List<i32>} */
-const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
+/** @type {(input: list.List<u16>) => list.List<i32>} */
+export const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
 
-/** @type {(s: string) => List.List<u16>} */
-const stringToList = s => {
-    /** @type {(i: number) => List.Result<number>} */
+/** @type {(s: string) => list.List<u16>} */
+export const stringToList = s => {
+    /** @type {(i: number) => list.Result<number>} */
     const at = i => {
         const first = s.charCodeAt(i)
         return isNaN(first) ? empty : { first, tail: () => at(i + 1) }
@@ -90,18 +90,7 @@ const stringToList = s => {
     return at(0)
 }
 
-/** @type {(input: List.List<u16>) => string} */
-const listToString = fn(map(String.fromCharCode))
+/** @type {(input: list.List<u16>) => string} */
+export const listToString = fn(map(String.fromCharCode))
     .then(reduce(operator.concat)(''))
     .result
-
-export default {
-    /** @readonly */
-    fromCodePointList,
-    /** @readonly */
-    toCodePointList,
-    /** @readonly */
-    stringToList,
-    /** @readonly */
-    listToString
-}

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.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/tsconfig.json

@@ -42,12 +42,12 @@
     // "maxNodeModuleJsDepth": 1,                        /* Specify the maximum folder depth used for checking JavaScript files from `node_modules`. Only applicable with `allowJs`. */
 
     /* Emit */
-    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
     // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
     // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
     // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
     // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */
-    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
+    "outDir": "./out",                                   /* Specify an output folder for all emitted files. */
     // "removeComments": true,                           /* Disable emitting comments. */
     "noEmit": true,                                   /* Disable emitting files from a compilation. */
     // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */

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.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.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.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.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.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.mjs

@@ -1,9 +1,9 @@
 // @ts-self-types="./module.f.d.mts"
 import * as _ from '../types/module.f.mjs'
-import btreeFind, * as BtreeFind from '../find/module.f.mjs'
+import * as btreeFind from '../find/module.f.mjs'
 const { find } = btreeFind
 import * as Cmp from '../../function/compare/module.f.mjs'
-import list from '../../list/module.f.mjs'
+import * as list from '../../list/module.f.mjs'
 const { fold } = list
 
 /**
@@ -14,7 +14,7 @@ const { fold } = list
 /** @type {<T>(b: _.Branch5<T> | _.Branch7<T>) => Branch1To3<T>} */
 const b57 = b => b.length === 5 ? [b] : [[b[0], b[1], b[2]], b[3], [b[4], b[5], b[6]]]
 
-/** @type {<T>(i: BtreeFind.PathItem<T>) => (a: Branch1To3<T>) => Branch1To3<T>} */
+/** @type {<T>(i: btreeFind.PathItem<T>) => (a: Branch1To3<T>) => Branch1To3<T>} */
 const reduceOp = ([i, x]) => a => {
     switch (i) {
         case 0: {
@@ -89,9 +89,4 @@ const nodeSet = c => g => node => {
 }
 
 /** @type {<T>(c: Cmp.Compare<T>) => (f: (value: T|null) => T) => (tree: _.Tree<T>) => _.Node<T>} */
-const set = c => f => tree => tree === null ? [f(null)] : nodeSet(c)(f)(tree)
-
-export default {
-    /** @readonly */
-    set,
-}
+export const set = c => f => tree => tree === null ? [f(null)] : nodeSet(c)(f)(tree)