functionalscript 0.1.609 → 0.2.0

package/secp/module.f.mjs

@@ -1,7 +1,7 @@
 // @ts-self-types="./module.f.d.mts"
 import * as Operator from '../types/function/operator/module.f.mjs'
-import pf, * as Pf from '../prime_field/module.f.mjs'
-import bi from '../types/bigint/module.f.mjs'
+import * as pf from '../prime_field/module.f.mjs'
+import * as bi from '../types/bigint/module.f.mjs'
 const { scalar_mul } = bi
 const { prime_field, sqrt } = pf
 
@@ -20,8 +20,8 @@ const { prime_field, sqrt } = pf
 
 /**
  * @typedef {{
- *  readonly pf: Pf.PrimeField
- *  readonly nf: Pf.PrimeField
+ *  readonly pf: pf.PrimeField
+ *  readonly nf: pf.PrimeField
  *  readonly y2: (x: bigint) => bigint
  *  readonly y: (x: bigint) => bigint|null
  *  readonly neg: (a: Point) => Point
@@ -31,7 +31,7 @@ const { prime_field, sqrt } = pf
  */
 
 /** @type {(i: Init) => Curve} */
-const curve = ({ p, a: [a0, a1], n }) => {
+export const curve = ({ p, a: [a0, a1], n }) => {
     const pf = prime_field(p)
     const { pow2, pow3, sub, add, mul, neg, div } = pf
     const mul3 = mul(3n)
@@ -85,38 +85,37 @@ const curve = ({ p, a: [a0, a1], n }) => {
     }
 }
 
-export default {
-    curve,
-    /** @type {(a: Point) => (b: Point) => boolean} */
-    eq: a => b => {
-        if (a === null || b === null) {
-            return a === b
-        }
-        const [ax, ay] = a
-        const [bx, by] = b
-        return ax === bx && ay === by
-    },
-    /** @type {Init} */
-    secp256k1: {
-        p: 0xffffffff_ffffffff_ffffffff_ffffffff_ffffffff_ffffffff_fffffffe_fffffc2fn,
-        a: [7n, 0n],
-        g: [
-            0x79be667e_f9dcbbac_55a06295_ce870b07_029bfcdb_2dce28d9_59f2815b_16f81798n,
-            0x483ada77_26a3c465_5da4fbfc_0e1108a8_fd17b448_a6855419_9c47d08f_fb10d4b8n
-        ],
-        n: 0xffffffff_ffffffff_ffffffff_fffffffe_baaedce6_af48a03b_bfd25e8c_d0364141n,
-    },
-    /** @type {Init} */
-    secp192r1: {
-        p: 0xffffffff_ffffffff_ffffffff_fffffffe_ffffffff_ffffffffn,
-        a: [
-            0x64210519_e59c80e7_0fa7e9ab_72243049_feb8deec_c146b9b1n,
-            0xffffffff_ffffffff_ffffffff_fffffffe_ffffffff_fffffffcn
-        ],
-        g: [
-            0x188da80e_b03090f6_7cbf20eb_43a18800_f4ff0afd_82ff1012n,
-            0x07192b95_ffc8da78_631011ed_6b24cdd5_73f977a1_1e794811n
-        ],
-        n: 0xffffffff_ffffffff_ffffffff_99def836_146bc9b1_b4d22831n,
-    },
+/** @type {(a: Point) => (b: Point) => boolean} */
+export const eq = a => b => {
+    if (a === null || b === null) {
+        return a === b
+    }
+    const [ax, ay] = a
+    const [bx, by] = b
+    return ax === bx && ay === by
+}
+
+/** @type {Init} */
+export const secp256k1 = {
+    p: 0xffffffff_ffffffff_ffffffff_ffffffff_ffffffff_ffffffff_fffffffe_fffffc2fn,
+    a: [7n, 0n],
+    g: [
+        0x79be667e_f9dcbbac_55a06295_ce870b07_029bfcdb_2dce28d9_59f2815b_16f81798n,
+        0x483ada77_26a3c465_5da4fbfc_0e1108a8_fd17b448_a6855419_9c47d08f_fb10d4b8n
+    ],
+    n: 0xffffffff_ffffffff_ffffffff_fffffffe_baaedce6_af48a03b_bfd25e8c_d0364141n,
+}
+
+/** @type {Init} */
+export const secp192r1 = {
+    p: 0xffffffff_ffffffff_ffffffff_fffffffe_ffffffff_ffffffffn,
+    a: [
+        0x64210519_e59c80e7_0fa7e9ab_72243049_feb8deec_c146b9b1n,
+        0xffffffff_ffffffff_ffffffff_fffffffe_ffffffff_fffffffcn
+    ],
+    g: [
+        0x188da80e_b03090f6_7cbf20eb_43a18800_f4ff0afd_82ff1012n,
+        0x07192b95_ffc8da78_631011ed_6b24cdd5_73f977a1_1e794811n
+    ],
+    n: 0xffffffff_ffffffff_ffffffff_99def836_146bc9b1_b4d22831n,
 }

package/secp/test.f.mjs

@@ -1,13 +1,13 @@
-import _, * as T from './module.f.mjs'
+import * as _ from './module.f.mjs'
 const { curve, secp256k1, secp192r1, eq } = _
 
 export default {
     test: () => {
-        /** @type {(c: T.Init) => void} */
+        /** @type {(c: _.Init) => void} */
         const test_curve = c => {
             const { g } = c
             const { mul, neg, pf: { abs }, y: yf, nf: { p: n } } = curve(c)
-            /** @type {(p: T.Point) => void} */
+            /** @type {(p: _.Point) => void} */
             const point_check = p => {
                 if (p === null) { throw 'null' }
                 const [x, y] = p
@@ -17,7 +17,7 @@ export default {
             }
             point_check(g)
             point_check(neg(g))
-            /** @type {(p: T.Point) => void} */
+            /** @type {(p: _.Point) => void} */
             const test_mul = p => {
                 if (mul(p)(0n) !== null) { throw 'O' }
                 if (mul(p)(1n) !== p) { throw 'p' }

package/sha2/module.f.d.mts

@@ -1,23 +1,15 @@
-declare namespace _default {
-    export { padding };
-    export { computeSha256 };
-    export { computeSha224 };
-    export { compress256 };
-    export { compress224 };
-}
-export default _default;
+/** @type  {(input: readonly number[]) => (bits: number) => HashInput} */
+export const padding: (input: readonly number[]) => (bits: number) => HashInput;
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+export const computeSha256: (input: readonly number[]) => (bitsCount: number) => Hash8;
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+export const computeSha224: (input: readonly number[]) => (bitsCount: number) => Hash8;
+export const compress256: (data: Array16) => Hash8;
+export const compress224: (data: Array16) => Hash8;
 export type HashInput = {
     readonly f: (i: number) => number;
     readonly length: number;
 };
 export type Hash8 = arrayT.Array8<number>;
 export type Array16 = arrayT.Array16<number>;
-/** @type  {(input: readonly number[]) => (bits: number) => HashInput} */
-declare const padding: (input: readonly number[]) => (bits: number) => HashInput;
-/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-declare const computeSha256: (input: readonly number[]) => (bitsCount: number) => Hash8;
-/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-declare const computeSha224: (input: readonly number[]) => (bitsCount: number) => Hash8;
-declare const compress256: (data: Array16) => Hash8;
-declare const compress224: (data: Array16) => Hash8;
 import * as arrayT from '../types/array/module.f.mjs';

package/sha2/module.f.mjs

@@ -19,7 +19,7 @@ const appendOneWithZeros = input => pos => (input >> pos << pos) | (1 << pos)
 const mod = a => b => (a % b + b) % b
 
 /** @type  {(input: readonly number[]) => (bits: number) => HashInput} */
-const padding = input => bitsCount => {
+export const padding = input => bitsCount => {
     const appendBlockIndex = (bitsCount / 32) | 0
     const length = (bitsCount + mod(447 - bitsCount)(512) + 65) / 32
     /** @type {(i: number) => number} */
@@ -183,27 +183,14 @@ const compute = init => input => bitsCount => {
 const init256 = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]
 
 /** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-const computeSha256 = compute(init256)
+export const computeSha256 = compute(init256)
 
 /** @type {Hash8} */
 const init224 = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4]
 
 /** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-const computeSha224 = compute(init224)
-
-const compress256 = compress(init256)
-
-const compress224 = compress(init224)
-
-export default {
-    /** @readonly */
-    padding,
-    /** @readonly */
-    computeSha256,
-    /** @readonly */
-    computeSha224,
-     /** @readonly */
-    compress256,
-    /** @readonly */
-    compress224
-}
+export const computeSha224 = compute(init224)
+
+export const compress256 = compress(init256)
+
+export const compress224 = compress(init224)

package/sha2/test.f.mjs

@@ -1,6 +1,6 @@
-import _ from './module.f.mjs'
-import json, * as jsonT from '../json/module.f.mjs'
-import o from '../types/object/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as json from '../json/module.f.mjs'
+import * as o from '../types/object/module.f.mjs'
 const { sort } = o
 
 /** @type {(a: number) => number} */
@@ -9,7 +9,7 @@ const toU32 = x => (x + 0x1_0000_0000) % 0x1_0000_0000
 /** @type {(a: number) => string} */
 const toHexString = x => toU32(x).toString(16).padStart(8, '0')
 
-/** @type {(a: readonly jsonT.Unknown[]) => string} */
+/** @type {(a: readonly json.Unknown[]) => string} */
 const stringify = a => json.stringify(sort)(a)
 
 // {

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

@@ -1,73 +1,70 @@
-declare namespace _default {
-    export { one };
-    export { range };
-    export let backspace: number;
-    export let ht: number;
-    export let lf: number;
-    export let ff: number;
-    export let cr: number;
-    export let space: number;
-    export let exclamationMark: number;
-    export let quotationMark: number;
-    export let numberSign: number;
-    export let dollarSign: number;
-    export let percentSign: number;
-    export let ampersand: number;
-    export let apostrophe: number;
-    export let leftParenthesis: number;
-    export let rightParenthesis: number;
-    export let asterisk: number;
-    export let plusSign: number;
-    export let comma: number;
-    export let hyphenMinus: number;
-    export let fullStop: number;
-    export let solidus: number;
-    export let digitRange: Range.Range;
-    export let digit0: number;
-    export let digit1: number;
-    export let digit2: number;
-    export let digit3: number;
-    export let digit4: number;
-    export let digit5: number;
-    export let digit6: number;
-    export let digit7: number;
-    export let digit8: number;
-    export let digit9: number;
-    export let colon: number;
-    export let semicolon: number;
-    export let lessThanSign: number;
-    export let equalsSign: number;
-    export let greaterThanSign: number;
-    export let questionMark: number;
-    export let commercialAt: number;
-    export let latinCapitalLetterRange: Range.Range;
-    export let latinCapitalLetterA: number;
-    export let latinCapitalLetterE: number;
-    export let latinCapitalLetterF: number;
-    export let leftSquareBracket: number;
-    export let reverseSolidus: number;
-    export let rightSquareBracket: number;
-    export let circumflexAccent: number;
-    export let lowLine: number;
-    export let graveAccent: number;
-    export let latinSmallLetterRange: Range.Range;
-    export let latinSmallLetterA: number;
-    export let latinSmallLetterB: number;
-    export let latinSmallLetterE: number;
-    export let latinSmallLetterF: number;
-    export let latinSmallLetterN: number;
-    export let latinSmallLetterR: number;
-    export let latinSmallLetterT: number;
-    export let latinSmallLetterU: number;
-    export let latinSmallLetterZ: number;
-    export let leftCurlyBracket: number;
-    export let verticalLine: number;
-    export let rightCurlyBracket: number;
-    export let tilde: number;
-}
-export default _default;
 /** @type {(s: string) => number} */
-declare const one: (s: string) => number;
-/** @type {(s: string) => Range.Range} */
-declare const range: (s: string) => Range.Range;
-import * as Range from '../../types/range/module.f.mjs';
+export const one: (s: string) => number;
+/** @type {(s: string) => _range.Range} */
+export const range: (s: string) => _range.Range;
+export namespace ascii {
+    let backspace: number;
+    let ht: number;
+    let lf: number;
+    let ff: number;
+    let cr: number;
+    let space: number;
+    let exclamationMark: number;
+    let quotationMark: number;
+    let numberSign: number;
+    let dollarSign: number;
+    let percentSign: number;
+    let ampersand: number;
+    let apostrophe: number;
+    let leftParenthesis: number;
+    let rightParenthesis: number;
+    let asterisk: number;
+    let plusSign: number;
+    let comma: number;
+    let hyphenMinus: number;
+    let fullStop: number;
+    let solidus: number;
+    let digitRange: _range.Range;
+    let digit0: number;
+    let digit1: number;
+    let digit2: number;
+    let digit3: number;
+    let digit4: number;
+    let digit5: number;
+    let digit6: number;
+    let digit7: number;
+    let digit8: number;
+    let digit9: number;
+    let colon: number;
+    let semicolon: number;
+    let lessThanSign: number;
+    let equalsSign: number;
+    let greaterThanSign: number;
+    let questionMark: number;
+    let commercialAt: number;
+    let latinCapitalLetterRange: _range.Range;
+    let latinCapitalLetterA: number;
+    let latinCapitalLetterE: number;
+    let latinCapitalLetterF: number;
+    let leftSquareBracket: number;
+    let reverseSolidus: number;
+    let rightSquareBracket: number;
+    let circumflexAccent: number;
+    let lowLine: number;
+    let graveAccent: number;
+    let latinSmallLetterRange: _range.Range;
+    let latinSmallLetterA: number;
+    let latinSmallLetterB: number;
+    let latinSmallLetterE: number;
+    let latinSmallLetterF: number;
+    let latinSmallLetterN: number;
+    let latinSmallLetterR: number;
+    let latinSmallLetterT: number;
+    let latinSmallLetterU: number;
+    let latinSmallLetterZ: number;
+    let leftCurlyBracket: number;
+    let verticalLine: number;
+    let rightCurlyBracket: number;
+    let tilde: number;
+}
+import * as _range from '../../types/range/module.f.mjs';

package/text/ascii/module.f.mjs

@@ -1,5 +1,5 @@
 // @ts-self-types="./module.f.d.mts"
-import _range, * as Range from '../../types/range/module.f.mjs'
+import * as _range from '../../types/range/module.f.mjs'
 
 /** @type {(s: string) => (i: number) => number} */
 const at = s => i => {
@@ -9,22 +9,17 @@ const at = s => i => {
 }
 
 /** @type {(s: string) => number} */
-const one = s => at(s)(0)
+export const one = s => at(s)(0)
 
-/** @type {(s: string) => Range.Range} */
-const range = s => {
+/** @type {(s: string) => _range.Range} */
+export const range = s => {
     const f = at(s)
     const f0 = f(0)
     if (s.length === 1) { return [f0, f0] }
     return [f0, f(1)]
 }
 
-export default {
-    /** @readonly */
-    one,
-    /** @readonly */
-    range,
-
+export const ascii = {
     // 0x00..
 
     /** @readonly 0x08 */

package/text/ascii/test.f.mjs

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

package/text/module.f.d.mts

@@ -1,18 +1,13 @@
-declare namespace _default {
-    export { flat };
-    export { curly };
-}
-export default _default;
-export type Block = ItemThunk | ItemArray;
-export type ItemArray = readonly Item[];
-export type ItemThunk = () => List.List<Item>;
-export type Item = string | ItemArray | ItemThunk;
 /** @typedef {ItemThunk|ItemArray} Block */
 /** @typedef {readonly Item[]} ItemArray */
-/** @typedef {() => List.List<Item>} ItemThunk */
+/** @typedef {() => list.List<Item>} ItemThunk */
 /** @typedef {string|ItemArray|ItemThunk} Item */
-/** @type {(indent: string) => (text: Block) => List.List<string>} */
-declare const flat: (indent: string) => (text: Block) => List.List<string>;
+/** @type {(indent: string) => (text: Block) => list.List<string>} */
+export const flat: (indent: string) => (text: Block) => list.List<string>;
 /** @type {(type: string) => (name: string) => (body: Block) => Block} */
-declare const curly: (type: string) => (name: string) => (body: Block) => Block;
-import * as List from '../types/list/module.f.mjs';
+export const curly: (type: string) => (name: string) => (body: Block) => Block;
+export type Block = ItemThunk | ItemArray;
+export type ItemArray = readonly Item[];
+export type ItemThunk = () => list.List<Item>;
+export type Item = string | ItemArray | ItemThunk;
+import * as list from '../types/list/module.f.mjs';

package/text/module.f.mjs

@@ -1,21 +1,21 @@
 // @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'
 const { flatMap } = list
 
 /** @typedef {ItemThunk|ItemArray} Block */
 
 /** @typedef {readonly Item[]} ItemArray */
 
-/** @typedef {() => List.List<Item>} ItemThunk */
+/** @typedef {() => list.List<Item>} ItemThunk */
 
 /** @typedef {string|ItemArray|ItemThunk} Item */
 
-/** @type {(indent: string) => (text: Block) => List.List<string>} */
-const flat = indent => {
+/** @type {(indent: string) => (text: Block) => list.List<string>} */
+export const flat = indent => {
 
-    /** @type {(prefix: string) => (text: Block) => List.List<string>} */
+    /** @type {(prefix: string) => (text: Block) => list.List<string>} */
     const f = prefix => {
-        /** @type {(item: Item) => List.List<string>} */
+        /** @type {(item: Item) => list.List<string>} */
         const g = item => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item)
         return flatMap(g)
     }
@@ -24,11 +24,4 @@ const flat = indent => {
 }
 
 /** @type {(type: string) => (name: string) => (body: Block) => Block} */
-const curly = type => name => body => [`${type} ${name}`, '{', body, '}']
-
-export default {
-    /** @readonly */
-    flat,
-    /** @readonly */
-    curly,
-}
+export const curly = type => name => body => [`${type} ${name}`, '{', body, '}']

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

@@ -1,14 +1,12 @@
-declare namespace _default {
-    export { sgr };
-    export let reset: string;
-    export let bold: string;
-    export let fgRed: string;
-    export let fgGreen: string;
-}
-export default _default;
 /**
  * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
  *
  * @type {(c: number) => string}
  */
-declare const sgr: (c: number) => string;
+export const sgr: (c: number) => string;
+export namespace codes {
+    let reset: string;
+    let bold: string;
+    let fgRed: string;
+    let fgGreen: string;
+}

package/text/sgr/module.f.mjs

@@ -5,11 +5,9 @@
  *
  * @type {(c: number) => string}
  */
-const sgr = c => `\x1b[${c.toString()}m`
+export const sgr = c => `\x1b[${c.toString()}m`
 
-export default {
-    /** @readonly */
-    sgr,
+export const codes = {
     /** @readonly */
     reset: sgr(0),
     /** @readonly */

package/text/test.f.mjs

@@ -1,9 +1,9 @@
-import _, * as T from './module.f.mjs'
-import string from '../types/string/module.f.mjs'
+import * as _ from './module.f.mjs'
+import * as string from '../types/string/module.f.mjs'
 const { join } = string
 
 export default () => {
-    /** @type {T.Block} */
+    /** @type {_.Block} */
     const text = [
         'a',
         'b',

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

@@ -1,19 +1,12 @@
-declare namespace _default {
-    export { fromCodePointList };
-    export { toCodePointList };
-    export { stringToList };
-    export { listToString };
-}
-export default _default;
+export const fromCodePointList: (input: list.List<number>) => list.Thunk<number>;
+/** @type {(input: list.List<u16>) => list.List<i32>} */
+export const toCodePointList: (input: list.List<u16>) => list.List<i32>;
+/** @type {(s: string) => list.List<u16>} */
+export const stringToList: (s: string) => list.List<u16>;
+/** @type {(input: list.List<u16>) => string} */
+export const listToString: (input: list.List<u16>) => string;
 export type WordOrEof = u16 | null;
 export type Utf16State = number | null;
 export type u16 = number;
 export type i32 = number;
-declare const fromCodePointList: (input: List.List<number>) => List.Thunk<number>;
-/** @type {(input: List.List<u16>) => List.List<i32>} */
-declare const toCodePointList: (input: List.List<u16>) => List.List<i32>;
-/** @type {(s: string) => List.List<u16>} */
-declare const stringToList: (s: string) => List.List<u16>;
-/** @type {(input: List.List<u16>) => string} */
-declare const listToString: (input: List.List<u16>) => string;
-import * as List from '../../types/list/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';

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
-}