functionalscript 0.0.592 → 0.1.594

package/text/utf16/{module.f.cjs → module.f.mjs}

@@ -1,7 +1,9 @@
-const list = require('../../types/list/module.f.cjs')
-const operator = require('../../types/function/operator/module.f.cjs')
-const { contains } = require('../../types/range/module.f.cjs')
-const { fn } = require('../../types/function/module.f.cjs')
+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'
+const { contains } = range
+import f from '../../types/function/module.f.mjs'
+const { fn } = f
 const { map, flat, stateScan, reduce, flatMap, empty } = list
 
 /** @typedef {u16|null} WordOrEof */
@@ -29,7 +31,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)) {
@@ -45,7 +47,7 @@ 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]
@@ -65,21 +67,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>} */
+/** @type {(input: List.List<u16>) => List.List<i32>} */
 const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
 
-/** @type {(s: string) => list.List<u16>} */
+/** @type {(s: string) => List.List<u16>} */
 const stringToList = s => {
-    /** @type {(i: number) => list.Result<number>} */
+    /** @type {(i: number) => List.Result<number>} */
     const at = i => {
         const first = s.charCodeAt(i)
         return isNaN(first) ? empty : { first, tail: () => at(i + 1) }
@@ -87,12 +89,12 @@ const stringToList = s => {
     return at(0)
 }
 
-/** @type {(input: list.List<u16>) => string} */
+/** @type {(input: List.List<u16>) => string} */
 const listToString = fn(map(String.fromCharCode))
     .then(reduce(operator.concat)(''))
     .result
 
-module.exports = {
+export default {
     /** @readonly */
     fromCodePointList,
     /** @readonly */

package/text/utf16/{test.f.cjs → test.f.mjs}

@@ -1,12 +1,13 @@
-const encoding = require('./module.f.cjs')
-const json = require('../../json/module.f.cjs')
-const { sort } = require('../../types/object/module.f.cjs')
-const list = require('../../types/list/module.f.cjs')
+import encoding from './module.f.mjs'
+import json, * as jsonT from '../../json/module.f.mjs'
+import o from '../../types/object/module.f.mjs'
+const { sort } = o
+import list from '../../types/list/module.f.mjs'
 
-/** @type {(a: readonly json.Unknown[]) => string} */
+/** @type {(a: readonly jsonT.Unknown[]) => string} */
 const stringify = a => json.stringify(sort)(a)
 
-module.exports = {
+export default {
     toCodePointList: [
         () => {
             const result = stringify(list.toArray(encoding.toCodePointList([-1, 65536])))

package/text/utf8/{module.f.cjs → module.f.mjs}

@@ -1,11 +1,11 @@
-const list = require('../../types/list/module.f.cjs')
-const operator = require('../../types/function/operator/module.f.cjs')
-const array = require('../../types/array/module.f.cjs')
+import list, * as List from '../../types/list/module.f.mjs'
+import * as operator from '../../types/function/operator/module.f.mjs'
+import * as arrayT from '../../types/array/module.f.mjs'
 const { flatMap, flat, stateScan } = list
 
 /** @typedef {u8|null} ByteOrEof */
 
-/** @typedef {array.Array1<number>|array.Array2<number>|array.Array3<number>} Utf8NonEmptyState */
+/** @typedef {arrayT.Array1<number>|arrayT.Array2<number>|arrayT.Array3<number>} Utf8NonEmptyState */
 
 /** @typedef {null|Utf8NonEmptyState} Utf8State */
 
@@ -15,7 +15,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] }
@@ -58,7 +58,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]
@@ -94,20 +94,20 @@ 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>} */
+/** @type {(input: List.List<u8>) => List.List<i32>} */
 const toCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])))
 
-module.exports = {
+export default {
     /** @readonly */
     fromCodePointList,
     /** @readonly */

package/text/utf8/{test.f.cjs → test.f.mjs}

@@ -1,11 +1,12 @@
-const encoding = require('./module.f.cjs')
-const json = require('../../json/module.f.cjs')
-const { sort } = require('../../types/object/module.f.cjs')
-const list = require('../../types/list/module.f.cjs')
+import encoding from './module.f.mjs'
+import json from '../../json/module.f.mjs'
+import o from '../../types/object/module.f.mjs'
+const { sort } = o
+import list from '../../types/list/module.f.mjs'
 
 const stringify = json.stringify(sort)
 
-module.exports = {
+export default {
     toCodePoint: [
         () => {
             const result = stringify(list.toArray(encoding.toCodePointList([-1, 256])))

package/tsconfig.json

@@ -24,7 +24,7 @@
     // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
 
     /* Modules */
-    "module": "commonjs",                                /* Specify what module code is generated. */
+    "module": "ES2022",                                /* Specify what module code is generated. */
     // "rootDir": "./",                                  /* Specify the root folder within your source files. */
     // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
     // "baseUrl": "./",                                  /* Specify the base directory to resolve non-relative module names. */
@@ -33,7 +33,7 @@
     // "typeRoots": [],                                  /* Specify multiple folders that act like `./node_modules/@types`. */
     // "types": [],                                      /* Specify type package names to be included without being referenced in a source file. */
     // "allowUmdGlobalAccess": true,                     /* Allow accessing UMD globals from modules. */
-    "resolveJsonModule": true,                        /* Enable importing .json files */
+    // "resolveJsonModule": true,                        /* Enable importing .json files */
     // "noResolve": true,                                /* Disallow `import`s, `require`s or `<reference>`s from expanding the number of files TypeScript should add to a project. */
 
     /* JavaScript Support */

package/types/array/{module.f.cjs → module.f.mjs}

@@ -1,4 +1,4 @@
-const option = require('../nullable/module.f.cjs')
+import option from '../nullable/module.f.mjs'
 const { map } = option
 
 /**
@@ -117,7 +117,7 @@ const splitLast = a => {
     return [uncheckHead(a), lastA]
 }
 
-module.exports = {
+export default {
     /** @readonly */
     at,
     /** @readnly */

package/types/array/{test.f.cjs → test.f.mjs}

@@ -1,10 +1,11 @@
-const _ = require('./module.f.cjs')
-const json = require('../../json/module.f.cjs')
-const { sort } = require('../object/module.f.cjs')
+import _ from './module.f.mjs'
+import json from '../../json/module.f.mjs'
+import o from '../object/module.f.mjs'
+const { sort } = o
 
 const stringify = json.stringify(sort)
 
-module.exports = {
+export default {
     stringify: () => {
         const result = stringify([1, 20, 300])
         if (result !== '[1,20,300]') { throw result }

package/types/bigfloat/{module.f.cjs → module.f.mjs}

@@ -1,5 +1,5 @@
-const compare = require('../function/compare/module.f.cjs')
-const { abs, sign } = require('../bigint/module.f.cjs')
+import bi from '../bigint/module.f.mjs'
+const { abs, sign } = bi
 
 /** @typedef {readonly[bigint,number]} BigFloat */
 
@@ -86,7 +86,7 @@ const decToBin = dec => {
     return multiply(r53)(s)
 }
 
-module.exports = {
+export default {
     /** @readonly */
     decToBin,
     /** @readonly */

package/types/bigfloat/{test.f.cjs → test.f.mjs}

@@ -1,6 +1,7 @@
-const { decToBin } = require('./module.f.cjs')
+import _ from './module.f.mjs'
+const { decToBin } = _
 
-module.exports = {
+export default {
     decToBin: [
         () => {
             const result = decToBin([0n, 0])

package/types/bigint/{module.f.cjs → module.f.mjs}

@@ -1,9 +1,10 @@
-const compare = require('../function/compare/module.f.cjs')
-const op = require('../function/operator/module.f.cjs')
+import compare, * as compareT from '../function/compare/module.f.mjs'
+import op, * as Op from '../function/operator/module.f.mjs'
 const { unsafeCmp } = compare
-const { reduce } = require('../list/module.f.cjs')
+import list from '../list/module.f.mjs'
+const { reduce } = list
 
-/** @typedef {op.Unary<bigint, bigint>} Unary*/
+/** @typedef {Op.Unary<bigint, bigint>} Unary*/
 
 /** @type {(a: bigint) => (b: bigint) => bigint} */
 const addition = a => b => a + b
@@ -13,7 +14,7 @@ const sum = reduce(addition)(0n)
 /** @type {(a: bigint) => bigint} */
 const abs = a => a >= 0 ? a : -a
 
-/** @type {(a: bigint) => compare.Sign} */
+/** @type {(a: bigint) => compareT.Sign} */
 const sign = a => unsafeCmp(a)(0n)
 
 /** @type {(a: bigint) => string} */
@@ -23,7 +24,7 @@ const serialize = a => `${a}n`
  * @template T
  * @typedef {{
  *  readonly 0: T
- *  readonly add: op.Reduce<T>
+ *  readonly add: Op.Reduce<T>
  * }} Additive
  */
 
@@ -117,7 +118,7 @@ const bitLength = v => {
     return log2(v) + 1n
 }
 
-module.exports = {
+export default {
     /** @readonly */
     addition,
     /** @readonly */

package/types/bigint/{test.f.cjs → test.f.mjs}

@@ -1,6 +1,7 @@
-const { sum, abs, serialize, log2, bitLength } = require('./module.f.cjs')
+import _ from './module.f.mjs'
+const { sum, abs, serialize, log2, bitLength } = _
 
-module.exports = {
+export default {
     sum: () => {
         const result = sum([2n, 3n, 4n, 5n])
         if (result !== 14n) { throw result }

package/types/btree/find/{module.f.cjs → module.f.mjs}

@@ -1,12 +1,12 @@
-const _ = require('../types/module.f.cjs')
-const list = require('../../list/module.f.cjs')
-const cmp = require('../../function/compare/module.f.cjs')
+import * as _ from '../types/module.f.mjs'
+import list, * as List from '../../list/module.f.mjs'
+import cmp, * as cmpT from '../../function/compare/module.f.mjs'
 const { index3, index5 } = cmp
-const array = require('../../array/module.f.cjs')
+import array, * as arrayT from '../../array/module.f.mjs'
 
 /**
  * @template T
- * @typedef {readonly[cmp.Index3, _.Leaf1<T>]} FirstLeaf1
+ * @typedef {readonly[cmpT.Index3, _.Leaf1<T>]} FirstLeaf1
  */
 
 /**
@@ -16,7 +16,7 @@ const array = require('../../array/module.f.cjs')
 
 /**
  * @template T
- * @typedef {readonly[cmp.Index5, _.Leaf2<T>]} FirstLeaf2
+ * @typedef {readonly[cmpT.Index5, _.Leaf2<T>]} FirstLeaf2
  */
 
 /**
@@ -50,7 +50,7 @@ const child = item =>
 
 /**
  * @template T
- * @typedef {list.List<PathItem<T>>} Path
+ * @typedef {List.List<PathItem<T>>} Path
  */
 
 /**
@@ -61,19 +61,19 @@ const child = item =>
  * }} Result<T>
  */
 
-/** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => Result<T>} */
+/** @type {<T>(c: cmpT.Compare<T>) => (node: _.Node<T>) => Result<T>} */
 const find = c => {
     const i3 = index3(c)
     const i5 = index5(c)
-    /** @typedef {typeof c extends cmp.Compare<infer T> ? T : never} T */
+    /** @typedef {typeof c extends cmpT.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>} */
+        /** @type {(index: arrayT.KeyOf<typeof node>) => Result<T>} */
         const append = index => {
             const first = /** @type {PathItem<T>} */([index, node])
             return f({ first, tail })(child(first))
         }
-        /** @type {(index: array.KeyOf<typeof node>) => Result<T>} */
+        /** @type {(index: arrayT.KeyOf<typeof node>) => Result<T>} */
         const done = index => ({ first: /** @type {First<T>} */([index, node]), tail })
         switch (node.length) {
             case 1: { return done(i3(node[0])) }
@@ -123,7 +123,7 @@ const value = ([i, r]) => {
     }
 }
 
-module.exports = {
+export default {
     /** @readonly */
     find,
     /** @readonly */

package/types/btree/find/{test.f.cjs → test.f.mjs}

@@ -1,17 +1,19 @@
-const _ = require('./module.f.cjs')
-const list = require('../../list/module.f.cjs')
-const json = require('../../../json/module.f.cjs')
-const { sort } = require('../../object/module.f.cjs')
-const btree = require('../types/module.f.cjs')
-const { cmp } = require('../../string/module.f.cjs')
-const s = require('../set/module.f.cjs')
+import _, * as T from './module.f.mjs'
+import list from '../../list/module.f.mjs'
+import json, * as jsonT from '../../../json/module.f.mjs'
+import o from '../../object/module.f.mjs'
+const { sort } = o
+import * as btree from '../types/module.f.mjs'
+import string from '../../string/module.f.mjs'
+const { cmp } = string
+import 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: _.Result<json.Unknown>) => string} */
+/** @type {(r: T.Result<jsonT.Unknown>) => string} */
 const str = r => jsonStr(list.toArray(list.map(x => x[0])(r)))
 
 /** @type {(i: string) => (m: btree.Node<string>) => string} */
@@ -113,4 +115,4 @@ const test = () => {
     }
 }
 
-module.exports = test
+export default test

package/types/btree/{module.f.cjs → module.f.mjs}

@@ -1,9 +1,10 @@
-const list = require('../list/module.f.cjs')
+import list, * as List from '../list/module.f.mjs'
 const { flat } = list
-const { map } = require('../nullable/module.f.cjs')
-const _ = require('./types/module.f.cjs')
+import 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 }
@@ -26,18 +27,12 @@ const nodeValues = node => () => {
     }
 }
 
-/** @type {<T>(tree: _.Tree<T>) => list.List<T>} */
+/** @type {<T>(tree: _.Tree<T>) => List.List<T>} */
 const values = map(nodeValues)
 
-module.exports = {
+export default {
     /** @readonly */
     empty: null,
     /** @readonly */
-    find: require('./find/module.f.cjs'),
-    /** @readonly */
-    remove: require('./remove/module.f.cjs'),
-    /** @readonly */
-    set: require('./set/module.f.cjs'),
-    /** @readonly */
     values,
 }

package/types/btree/remove/{module.f.cjs → module.f.mjs}

@@ -1,10 +1,11 @@
-const _ = require('../types/module.f.cjs')
-const cmp = require('../../function/compare/module.f.cjs')
-const find = require('../find/module.f.cjs')
-const list = require('../../list/module.f.cjs')
+import * as _ from '../types/module.f.mjs'
+import cmp, * as cmpT from '../../function/compare/module.f.mjs'
+import find, * as findT from '../find/module.f.mjs'
+import list from '../../list/module.f.mjs'
 const { fold, concat, next } = list
-const array = require('../../array/module.f.cjs')
-const { map } = require('../../nullable/module.f.cjs')
+import array, * as arrayT from '../../array/module.f.mjs'
+import n from '../../nullable/module.f.mjs'
+const { map } = n
 
 /**
  * @template T
@@ -15,11 +16,11 @@ const { map } = require('../../nullable/module.f.cjs')
  * @template T
  * @typedef {{
  *  readonly first: Leaf01<T>,
- *  readonly tail: find.Path<T>
+ *  readonly tail: findT.Path<T>
  * }} RemovePath
  */
 
-/** @type {<T>(tail: find.Path<T>) => (n: _.Node<T>) => readonly[T, RemovePath<T>]} */
+/** @type {<T>(tail: findT.Path<T>) => (n: _.Node<T>) => readonly[T, RemovePath<T>]} */
 const path = tail => n => {
     switch (n.length) {
         case 1: { return [n[0], { first: null, tail }] }
@@ -93,10 +94,10 @@ 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: arrayT.Array2<Merge<A, T>>) => (i: findT.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 */
+    /** @typedef {typeof ms extends arrayT.Array2<Merge<infer A, infer T>> ? [A,T] : never} AT */
     /** @typedef {AT[0]} A */
     /** @typedef {AT[1]} T */
     /** @type {(m: Merge<A, T>) => Branch<T>} */
@@ -115,15 +116,15 @@ const reduce = fold(reduceX([reduceValue0, reduceValue2]))
 
 const initReduce = reduceX([initValue0, initValue1])
 
-/** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
+/** @type {<T>(c: cmpT.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
 const nodeRemove = c => node => {
-    /** @typedef {typeof c extends cmp.Compare<infer T> ? T : never} T */
+    /** @typedef {typeof c extends cmpT.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) => findT.PathItem<T>) => RemovePath<T>} */
         const branch = n => f => {
-            const [v, p] = path(/** @type {find.Path<T>} */(null))(n)
+            const [v, p] = path(/** @type {findT.Path<T>} */(null))(n)
             return { first: p.first, tail: concat(p.tail)({ first: f(v), tail }) }
         }
         const [i, n] = first
@@ -155,10 +156,10 @@ const nodeRemove = c => node => {
     return result.length === 1 ? result[0] : result
 }
 
-/** @type {<T>(c: cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
+/** @type {<T>(c: cmpT.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
 const remove =  c => map(nodeRemove(c))
 
-module.exports = {
+export default {
     /** @readonly */
     nodeRemove,
     /** @readonly */

package/types/btree/remove/{test.f.cjs → test.f.mjs}

@@ -1,9 +1,11 @@
-const _ = require('./module.f.cjs')
-const btree = require('../types/module.f.cjs')
-const s = require('../set/module.f.cjs')
-const { cmp } = require('../../string/module.f.cjs')
-const json = require('../../../json/module.f.cjs')
-const { sort } = require('../../object/module.f.cjs')
+import _ 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'
+const { cmp } = str
+import json from '../../../json/module.f.mjs'
+import o from '../../object/module.f.mjs'
+const { sort } = o
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
 const set = node => value => s.set(cmp(value))(() => value)(node)
@@ -486,7 +488,7 @@ const test2 = () => {
     }
 }
 
-module.exports = {
+export default {
     test,
     test2,
 }

package/types/btree/set/{module.f.cjs → module.f.mjs}

@@ -1,8 +1,8 @@
-const _ = require('../types/module.f.cjs')
-const btreeFind = require('../find/module.f.cjs')
+import * as _ from '../types/module.f.mjs'
+import btreeFind, * as btreeFindT from '../find/module.f.mjs'
 const { find } = btreeFind
-const cmp = require('../../function/compare/module.f.cjs')
-const list = require('../../list/module.f.cjs')
+import cmp, * as cmpT from '../../function/compare/module.f.mjs'
+import list from '../../list/module.f.mjs'
 const { fold } = list
 
 /**
@@ -13,7 +13,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: btreeFindT.PathItem<T>) => (a: Branch1To3<T>) => Branch1To3<T>} */
 const reduceOp = ([i, x]) => a => {
     switch (i) {
         case 0: {
@@ -36,11 +36,11 @@ const reduceOp = ([i, x]) => a => {
 
 const reduceBranch = fold(reduceOp)
 
-/** @type {<T>(c: cmp.Compare<T>) => (g: (value: T | null) => T) => (node: _.Node<T>) => _.Node<T>} */
+/** @type {<T>(c: cmpT.Compare<T>) => (g: (value: T | null) => T) => (node: _.Node<T>) => _.Node<T>} */
 const nodeSet = c => g => node => {
     const { first, tail } = find(c)(node)
     const [i, x] = first;
-    /** @typedef {typeof c extends cmp.Compare<infer T> ? T : never} T */
+    /** @typedef {typeof c extends cmpT.Compare<infer T> ? T : never} T */
     /** @type {() => Branch1To3<T>} */
     const f = () => {
         switch (i) {
@@ -87,10 +87,10 @@ const nodeSet = c => g => node => {
     return r.length === 1 ? r[0] : r
 }
 
-/** @type {<T>(c: cmp.Compare<T>) => (f: (value: T|null) => T) => (tree: _.Tree<T>) => _.Node<T>} */
+/** @type {<T>(c: cmpT.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)
 
-module.exports = {
+export default {
     /** @readonly */
     set,
 }

package/types/btree/set/{test.f.cjs → test.f.mjs}

@@ -1,8 +1,10 @@
-const _ = require('./module.f.cjs')
-const btree = require('../types/module.f.cjs')
-const { cmp } = require('../../string/module.f.cjs')
-const json = require('../../../json/module.f.cjs')
-const { sort } = require('../../object/module.f.cjs')
+import _ from './module.f.mjs'
+import * as btree from '../types/module.f.mjs'
+import s from '../../string/module.f.mjs'
+const { cmp } = s
+import json, * as jsonT from '../../../json/module.f.mjs'
+import o from '../../object/module.f.mjs'
+const { sort } = o
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
 const set = node => value => _.set(cmp(value))(() => value)(node)
@@ -380,4 +382,4 @@ const test = [
     }
 ]
 
-module.exports = test
+export default test