functionalscript 0.0.592 → 0.1.594

package/dev/test/{module.f.cjs → module.f.mjs}

@@ -1,7 +1,8 @@
-const list = require('../../types/list/module.f.cjs')
+import list from '../../types/list/module.f.mjs'
 const { fold } = list
-const { reset, fgGreen, fgRed, bold } = require('../../text/sgr/module.f.cjs')
-const result = require('../../types/result/module.f.cjs')
+import sgr from '../../text/sgr/module.f.mjs'
+const { reset, fgGreen, fgRed, bold } = sgr
+import * as Result from '../../types/result/module.f.mjs'
 
 /**
  * @typedef {{
@@ -39,13 +40,13 @@ const result = require('../../types/result/module.f.cjs')
  *  readonly error: Log<T>,
  *  readonly measure: Measure<T>,
  *  readonly state: T,
- *  readonly tryCatch: <R>(f: () => R) => result.Result<R, unknown>,
+ *  readonly tryCatch: <R>(f: () => R) => Result.Result<R, unknown>,
  *  readonly env: (n: string) => string|undefined
  * }} Input
  */
 
 /** @type {(s: string) => boolean} */
-const isTest = s => s.endsWith('test.f.cjs')
+const isTest = s => s.endsWith('test.f.cjs') || s.endsWith('test.f.mjs')
 
 /**
  * @typedef {{
@@ -66,6 +67,17 @@ const addFail = delta => ts => ({ ...ts, time: ts.time + delta, fail: ts.fail +
  * @typedef {readonly[TestState, T]} FullState
  */
 
+/** @type {(a: number) => string} */
+const timeFormat = a => {
+    const y = Math.round(a * 10_000).toString()
+    const yl = 5 - y.length
+    const x = '0'.repeat(yl > 0 ? yl : 0) + y
+    const s = x.length - 4
+    const b = x.substring(0, s)
+    const e = x.substring(s)
+    return `${b}.${e} ms`
+}
+
 /** @type {<T>(input: Input<T>) => readonly[number, T]} */
 const main = input => {
     let { moduleMap, log, error, measure, tryCatch, env, state } = input
@@ -88,12 +100,12 @@ const main = input => {
                                 // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
                                 state = error(`::error file=${k},line=1,title=[3]['a']()::${r}`)(state)
                             } else {
-                                state = error(`${i}() ${fgRed}error${reset}, ${delta} ms`)(state)
+                                state = error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`)(state)
                                 state = error(`${fgRed}${r}${reset}`)(state)
                             }
                         } else {
                             ts = addPass(delta)(ts)
-                            state = log(`${i}() ${fgGreen}ok${reset}, ${delta} ms`)(state)
+                            state = log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`)(state)
                         }
                         [ts, state] = next(r)([ts, state])
                     }
@@ -130,8 +142,8 @@ const main = input => {
     [ts, state] = fold(f)([ts, state])(Object.entries(moduleMap))
     const fgFail = ts.fail === 0 ? fgGreen : fgRed
     state = log(`${bold}Number of tests: pass: ${fgGreen}${ts.pass}${reset}${bold}, fail: ${fgFail}${ts.fail}${reset}${bold}, total: ${ts.pass + ts.fail}${reset}`)(state)
-    state = log(`${bold}Time: ${ts.time} ms${reset}`)(state);
+    state = log(`${bold}Time: ${timeFormat(ts.time)}${reset}`)(state);
     return [ts.fail !== 0 ? 1 : 0, state]
 }
 
-module.exports = main
+export default main

package/dev/{test.f.cjs → test.f.mjs}

@@ -4,7 +4,7 @@ const assert = () => { throw 'assert' }
 /** @type {(_: boolean) => void} */
 const assert_if = c => { if (c) { throw 'assert_if' } }
 
-module.exports = {
+export default {
     ctor: () => {
         const c = (() => { })['constructor']
         const f = c('return 5')

package/dev/test.mjs

@@ -45,7 +45,7 @@ const main = async() => {
     const moduleMap = await loadModuleMap()
 
     /** @type {any} */
-    const f = moduleMap['./dev/test/module.f.cjs'].default
+    const f = moduleMap['./dev/test/module.f.mjs'].default
     const r = f({
         moduleMap,
         log: anyLog(console.log),

package/djs/{module.f.cjs → module.f.mjs}

@@ -1,11 +1,15 @@
-const list = require('../types/list/module.f.cjs')
-const { flat, map, empty } = list
-const { concat } = require('../types/string/module.f.cjs')
-const object = require('../types/object/module.f.cjs')
-const { compose, fn } = require('../types/function/module.f.cjs')
+import list, * as List from '../types/list/module.f.mjs'
+const { flat, map } = list
+import string from '../types/string/module.f.mjs'
+const { concat } = string
+import object, * as O from '../types/object/module.f.mjs'
+import f from '../types/function/module.f.mjs'
+const { compose, fn } = f
 const { entries } = Object
-const { serialize: bigintSerialize } = require('../types/bigint/module.f.cjs')
-const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = require('../json/serializer/module.f.cjs')
+import bi from '../types/bigint/module.f.mjs'
+const { serialize: bigintSerialize } = bi
+import j from '../json/serializer/module.f.mjs'
+const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = j
 
 /**
  * @typedef {{
@@ -19,28 +23,28 @@ const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize,
 
 const colon = [':']
 
-/** @typedef {object.Entry<Unknown>} Entry*/
+/** @typedef {O.Entry<Unknown>} Entry*/
 
-/** @typedef {(list.List<Entry>)} Entries */
+/** @typedef {(List.List<Entry>)} Entries */
 
 /** @typedef {(entries: Entries) => Entries} MapEntries */
 
-/** @type {(mapEntries: MapEntries) => (value: Unknown) => list.List<string>} */
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => List.List<string>} */
 const serialize = sort => {
-    /** @type {(kv: readonly[string, Unknown]) => list.List<string>} */
+    /** @type {(kv: readonly[string, Unknown]) => List.List<string>} */
     const propertySerialize = ([k, v]) => flat([
         stringSerialize(k),
         colon,
         f(v)
     ])
     const mapPropertySerialize = map(propertySerialize)
-    /** @type {(object: Object) => list.List<string>} */
+    /** @type {(object: Object) => List.List<string>} */
     const objectSerialize = fn(entries)
         .then(sort)
         .then(mapPropertySerialize)
         .then(objectWrap)
         .result
-    /** @type {(value: Unknown) => list.List<string>} */
+    /** @type {(value: Unknown) => List.List<string>} */
     const f = value => {
         switch (typeof value) {
             case 'boolean': { return boolSerialize(value) }
@@ -66,8 +70,7 @@ const serialize = sort => {
  */
 const stringify = sort => compose(serialize(sort))(concat)
 
-module.exports = {
-
+export default {
     /** @readonly */
     stringify,
     /** @readonly */

package/djs/parser/{module.f.cjs → module.f.mjs}

@@ -1,17 +1,18 @@
-const result = require('../../types/result/module.f.cjs')
-const list = require('../../types/list/module.f.cjs')
+import result, * as Result from '../../types/result/module.f.mjs'
+import list, * as List from '../../types/list/module.f.mjs'
 const { fold, first, drop, toArray } = list
-const operator = require('../../types/function/operator/module.f.cjs')
-const tokenizer = require('../tokenizer/module.f.cjs')
-const map = require('../../types/map/module.f.cjs')
+import * as Operator from '../../types/function/operator/module.f.mjs'
+import * as tokenizerT from '../tokenizer/module.f.mjs'
+import map, * as Map from '../../types/map/module.f.mjs'
 const { setReplace } = map
-const djs = require('../module.f.cjs')
-const { fromMap } = require('../../types/object/module.f.cjs')
+import * as Djs from '../module.f.mjs'
+import o from '../../types/object/module.f.mjs'
+const { fromMap } = o
 
 /**
  * @typedef {{
 * readonly kind: 'object'
-* readonly values: map.Map<djs.Unknown>
+* readonly values: Map.Map<Djs.Unknown>
 * readonly key: string
 * }} JsonObject
 * */
@@ -19,7 +20,7 @@ const { fromMap } = require('../../types/object/module.f.cjs')
 /**
  * @typedef {{
 * readonly kind: 'array'
-* readonly values: list.List<djs.Unknown>
+* readonly values: List.List<Djs.Unknown>
 * }} JsonArray
 * */
 
@@ -30,7 +31,7 @@ const { fromMap } = require('../../types/object/module.f.cjs')
 * } JsonStackElement
 */
 
-/** @typedef {list.List<JsonStackElement>} JsonStack */
+/** @typedef {List.List<JsonStackElement>} JsonStack */
 
 /**
  * @typedef {{
@@ -50,7 +51,7 @@ const { fromMap } = require('../../types/object/module.f.cjs')
 /**
  * @typedef {{
 *  readonly status: 'result'
-*  readonly value: djs.Unknown
+*  readonly value: Djs.Unknown
 * }} StateResult
 */
 
@@ -70,7 +71,7 @@ const { fromMap } = require('../../types/object/module.f.cjs')
 * } DjsState
 */
 
-/** @type {(token: tokenizer.DjsToken) => (state: StateModule) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: StateModule) => DjsState}} */
 const parseModuleOp = token => state => {
     switch(state.stage)
     {
@@ -101,10 +102,10 @@ const parseModuleOp = token => state => {
 /** @type {(obj: JsonObject) => (key: string) => JsonObject} */
 const addKeyToObject = obj => key => ({ kind: 'object', values: obj.values, key: key })
 
-/** @type {(obj: JsonObject) => (value: djs.Unknown) => JsonObject} */
+/** @type {(obj: JsonObject) => (value: Djs.Unknown) => JsonObject} */
 const addValueToObject = obj => value => ({ kind: 'object', values: setReplace(obj.key)(value)(obj.values), key: '' })
 
-/** @type {(array: JsonArray) => (value: djs.Unknown) => JsonArray} */
+/** @type {(array: JsonArray) => (value: Djs.Unknown) => JsonArray} */
 const addToArray = array => value => ({ kind: 'array', values: list.concat(array.values)([value]) })
 
 /** @type {(state: StateParse) => (key: string) => DjsState} */
@@ -113,7 +114,7 @@ const pushKey = state => value => {
     return { status: 'error', message: 'error' }
 }
 
-/** @type {(state: StateParse) => (value: djs.Unknown) => DjsState} */
+/** @type {(state: StateParse) => (value: Djs.Unknown) => DjsState} */
 const pushValue = state => value => {
     if (state.top === null) { return { status: 'result', value: value } }
     if (state.top.kind === 'array') { return { status: '[v', top: addToArray(state.top)(value), stack: state.stack } }
@@ -148,7 +149,7 @@ const endObject = state => {
     return pushValue(newState)(obj)
 }
 
-/** @type {(token: tokenizer.DjsToken) => djs.Unknown} */
+/** @type {(token: tokenizerT.DjsToken) => Djs.Unknown} */
 const tokenToValue = token => {
     switch (token.kind) {
         case 'null': return null
@@ -161,7 +162,7 @@ const tokenToValue = token => {
     }
 }
 
-/** @type {(token: tokenizer.DjsToken) => boolean} */
+/** @type {(token: tokenizerT.DjsToken) => boolean} */
 const isValueToken = token => {
     switch (token.kind) {
         case 'null':
@@ -174,7 +175,7 @@ const isValueToken = token => {
     }
 }
 
-/** @type {(token: tokenizer.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
 const parseValueOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
     if (token.kind === '[') { return startArray(state) }
@@ -183,7 +184,7 @@ const parseValueOp = token => state => {
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizer.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
 const parseArrayStartOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
     if (token.kind === '[') { return startArray(state) }
@@ -193,7 +194,7 @@ const parseArrayStartOp = token => state => {
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizer.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
 const parseArrayValueOp = token => state => {
     if (token.kind === ']') { return endArray(state) }
     if (token.kind === ',') { return { status: '[,', top: state.top, stack: state.stack } }
@@ -201,7 +202,7 @@ const parseArrayValueOp = token => state => {
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizer.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
 const parseObjectStartOp = token => state => {
     if (token.kind === 'string') { return pushKey(state)(token.value) }
     if (token.kind === '}') { return endObject(state) }
@@ -209,14 +210,14 @@ const parseObjectStartOp = token => state => {
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizer.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
 const parseObjectKeyOp = token => state => {
     if (token.kind === ':') { return { status: '{:', top: state.top, stack: state.stack } }
     if (token.kind === 'ws') { return state }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizer.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
 const parseObjectColonOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
     if (token.kind === '[') { return startArray(state) }
@@ -225,7 +226,7 @@ const parseObjectColonOp = token => state => {
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizer.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
 const parseObjectNextOp = token => state => {
     if (token.kind === '}') { return endObject(state) }
     if (token.kind === ',') { return { status: '{,', top: state.top, stack: state.stack } }
@@ -233,14 +234,14 @@ const parseObjectNextOp = token => state => {
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizer.DjsToken) => (state: StateParse) => DjsState}} */
+/** @type {(token: tokenizerT.DjsToken) => (state: StateParse) => DjsState}} */
 const parseObjectCommaOp = token => state => {
     if (token.kind === 'string') { return pushKey(state)(token.value) }
     if (token.kind === 'ws') { return state }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {operator.Fold<tokenizer.DjsToken, DjsState>} */
+/** @type {Operator.Fold<tokenizerT.DjsToken, DjsState>} */
 const foldOp = token => state => {
     switch (state.status) {
         case 'module': return parseModuleOp(token)(state)
@@ -258,7 +259,7 @@ const foldOp = token => state => {
     }
 }
 
-/** @type {(tokenList: list.List<tokenizer.DjsToken>) => result.Result<djs.Unknown, string>} */
+/** @type {(tokenList: List.List<tokenizerT.DjsToken>) => Result.Result<Djs.Unknown, string>} */
 const parse = tokenList => {
     const state = fold(foldOp)({ status: 'module', stage: 'module' })(tokenList)
     switch (state.status) {
@@ -268,7 +269,7 @@ const parse = tokenList => {
     }
 }
 
-module.exports = {
+export default {
     /** @readonly */
     parse
 }

package/djs/parser/{test.f.cjs → test.f.mjs}

@@ -1,16 +1,18 @@
-const parser = require('./module.f.cjs')
-const tokenizer = require('../tokenizer/module.f.cjs')
-const { toArray } = require('../../types/list/module.f.cjs')
-const djs = require('../module.f.cjs')
-const { sort } = require('../../types/object/module.f.cjs')
-const encoding = require('../../text/utf16/module.f.cjs');
+import parser from './module.f.mjs'
+import tokenizer, * as tokenizerT from '../tokenizer/module.f.mjs'
+import list from '../../types/list/module.f.mjs'
+const { toArray } = list
+import djs from '../module.f.mjs'
+import o from '../../types/object/module.f.mjs'
+const { sort } = o
+import encoding from '../../text/utf16/module.f.mjs'
 
-/** @type {(s: string) => readonly tokenizer.DjsToken[]} */
+/** @type {(s: string) => readonly tokenizerT.DjsToken[]} */
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = djs.stringify(sort)
 
-module.exports = {
+export default {
     valid: [
         () => {
             const tokenList = tokenizeString('module.exports=null')

package/djs/{test.f.cjs → test.f.mjs}

@@ -1,9 +1,11 @@
-const json = require('../json/module.f.cjs')
-const { sort } = require('../types/object/module.f.cjs')
-const { identity } = require('../types/function/module.f.cjs')
-const djs= require('./module.f.cjs')
+import json from '../json/module.f.mjs'
+import list from '../types/object/module.f.mjs'
+const { sort } = list
+import f from '../types/function/module.f.mjs'
+const { identity } = f
+import djs from './module.f.mjs'
 
-module.exports = {
+export default {
     stringify: [
         {
             sort: () => {

package/djs/tokenizer/{module.f.cjs → module.f.mjs}

@@ -1,19 +1,20 @@
-const operator = require('../../types/function/operator/module.f.cjs')
-const list = require('../../types/list/module.f.cjs')
+import operator, * as Operator from '../../types/function/operator/module.f.mjs'
+import list, * as List from '../../types/list/module.f.mjs'
 const { empty, flat, stateScan } = list
-const { multiply } = require('../../types/bigfloat/module.f.cjs')
-const jsTokenizer = require('../../js/tokenizer/module.f.cjs')
+import bf from '../../types/bigfloat/module.f.mjs'
+const { multiply } = bf
+import jsTokenizer, * as jsTokenizerT from '../../js/tokenizer/module.f.mjs'
 
 /**
  * @typedef {|
 * {readonly kind: 'true' | 'false' | 'null'} |
 * {readonly kind: '{' | '}' | ':' | ',' | '[' | ']' | '.' | '=' } |
-* jsTokenizer.StringToken |
-* jsTokenizer.NumberToken |
-* jsTokenizer.ErrorToken |
-* jsTokenizer.IdToken |
-* jsTokenizer.BigIntToken |
-* jsTokenizer.WhitespaceToken
+* jsTokenizerT.StringToken |
+* jsTokenizerT.NumberToken |
+* jsTokenizerT.ErrorToken |
+* jsTokenizerT.IdToken |
+* jsTokenizerT.BigIntToken |
+* jsTokenizerT.WhitespaceToken
 * } DjsToken
 */
 
@@ -25,11 +26,11 @@ const jsTokenizer = require('../../js/tokenizer/module.f.cjs')
 
 /**
  * @typedef {|
-* jsTokenizer.JsToken | null
+* jsTokenizerT.JsToken | null
 * } ScanInput
 */
 
-/** @type {(input: jsTokenizer.JsToken) => list.List<DjsToken>} */
+/** @type {(input: jsTokenizerT.JsToken) => List.List<DjsToken>} */
 const mapToken = input =>
 {
     switch(input.kind)
@@ -55,7 +56,7 @@ const mapToken = input =>
     }
 }
 
-/** @type {(input: ScanInput) => readonly [list.List<DjsToken>, ScanState]} */
+/** @type {(input: ScanInput) => readonly [List.List<DjsToken>, ScanState]} */
 const parseDefaultState = input =>
 {
     if (input === null) return [empty, { kind: 'def'}]
@@ -66,7 +67,7 @@ const parseDefaultState = input =>
     }
 }
 
-/** @type {(input: ScanInput) => readonly [list.List<DjsToken>, ScanState]} */
+/** @type {(input: ScanInput) => readonly [List.List<DjsToken>, ScanState]} */
 const parseMinusState = input =>
 {
     if (input === null) return [[{ kind: 'error', message: 'invalid token' }], { kind: 'def'}]
@@ -79,7 +80,7 @@ const parseMinusState = input =>
     }
 }
 
-/** @type {operator.StateScan<ScanInput, ScanState, list.List<DjsToken>>} */
+/** @type {Operator.StateScan<ScanInput, ScanState, List.List<DjsToken>>} */
 const scanToken = state => input => {
     switch(state.kind)
     {
@@ -88,15 +89,15 @@ const scanToken = state => input => {
     }
 }
 
-/** @type {(input: list.List<number>) => list.List<DjsToken>} */
+/** @type {(input: List.List<number>) => List.List<DjsToken>} */
 const tokenize = input =>
 {
-    /** @type {list.List<ScanInput>} */
+    /** @type {List.List<ScanInput>} */
     const jsTokens = jsTokenizer.tokenize(input)
     return flat(stateScan(scanToken)({ kind: 'def' })(list.concat(jsTokens)([null])))
 }
 
-module.exports = {
+export default {
     /** @readonly */
     tokenize
 }

package/djs/tokenizer/{test.f.cjs → test.f.mjs}

@@ -1,15 +1,17 @@
-const tokenizer = require('./module.f.cjs')
-const { toArray, countdown } = require('../../types/list/module.f.cjs')
-const djs = require('../../djs/module.f.cjs')
-const { sort } = require('../../types/object/module.f.cjs')
-const encoding = require('../../text/utf16/module.f.cjs');
+import tokenizer, * as tokenizerT from './module.f.mjs'
+import list from '../../types/list/module.f.mjs'
+const { toArray, countdown } = list
+import djs from '../module.f.mjs'
+import o from '../../types/object/module.f.mjs'
+const { sort } = o
+import encoding from '../../text/utf16/module.f.mjs'
 
-/** @type {(s: string) => readonly tokenizer.DjsToken[]} */
+/** @type {(s: string) => readonly tokenizerT.DjsToken[]} */
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = djs.stringify(sort)
 
-module.exports = {
+export default {
     djs: [
         () => {
             const result = tokenizeString('')

package/fsc/{module.f.cjs → module.f.mjs}

@@ -1,12 +1,14 @@
-const operator = require('../types/function/operator/module.f.cjs')
-const range_map = require('../types/range_map/module.f.cjs')
+import operator from '../types/function/operator/module.f.mjs'
+import range_map, * as RM from '../types/range_map/module.f.mjs'
 const { merge: rangeMapMerge, fromRange, get } = range_map
-const { reduce: listReduce } = require('../types/list/module.f.cjs')
-const { range: asciiRange } = require('../text/ascii/module.f.cjs')
+import list, * as List from '../types/list/module.f.mjs'
+const { reduce: listReduce } = list
+import ascii from '../text/ascii/module.f.mjs'
+const { range: asciiRange } = ascii
 const { fromCharCode } = String
-const { fn } = require('../types/function/module.f.cjs')
-const list = require('../types/list/module.f.cjs')
-const _range = require('../types/range/module.f.cjs')
+import f from '../types/function/module.f.mjs'
+const { fn } = f
+import _range, * as Range from '../types/range/module.f.mjs'
 const { one } = _range
 const { toArray, map } = list
 
@@ -21,7 +23,7 @@ const { toArray, map } = list
 
 /**
  * @template T
- * @typedef {range_map.RangeMapArray<CreateToResult<T>>} State
+ * @typedef {RM.RangeMapArray<CreateToResult<T>>} State
  */
 
 /** @type {ToResult} */
@@ -40,10 +42,10 @@ const union = a => b => {
 /** @type {readonly never[]} */
 const empty = []
 
-/** @type {<T>(a: list.List<State<T>>) => State<T>} */
+/** @type {<T>(a: List.List<State<T>>) => State<T>} */
 const reduce = a => {
-    /** @typedef {typeof a extends list.List<State<infer T>> ? T : never} T */
-    /** @type {range_map.RangeMerge<CreateToResult<T>>} */
+    /** @typedef {typeof a extends List.List<State<infer T>> ? T : never} T */
+    /** @type {RM.RangeMerge<CreateToResult<T>>} */
     const merge = rangeMapMerge({
         union,
         equal: operator.strictEqual,
@@ -51,7 +53,6 @@ const reduce = a => {
     return toArray(listReduce(merge)(empty)(a))
 }
 
-
 const codePointRange = fromRange(def)
 
 const range = fn(asciiRange).then(codePointRange).result
@@ -59,16 +60,16 @@ const range = fn(asciiRange).then(codePointRange).result
 /** @type {(l: readonly string[]) => <T>(f: CreateToResult<T>) => State<T>} */
 const rangeSet = l => f => {
     /** @typedef {typeof f extends CreateToResult<infer T> ? T : never} T */
-    /** @type {(a: _range.Range) => (f: CreateToResult<T>) => State<T>} */
+    /** @type {(a: Range.Range) => (f: CreateToResult<T>) => State<T>} */
     const codePointRange = fromRange(def)
     /** @type {(r: string) => State<T>} */
     const g = r => codePointRange(asciiRange(r))(f)
     return reduce(map(g)(l))
 }
 
-/** @type {<T>(a: list.List<State<T>>) => CreateToResult<T>} */
+/** @type {<T>(a: List.List<State<T>>) => CreateToResult<T>} */
 const create = a => {
-    /** @typedef {typeof a extends list.List<State<infer T>> ? T : never} T */
+    /** @typedef {typeof a extends List.List<State<infer T>> ? T : never} T */
     const i = reduce(a)
     /** @type {(v: number) => (i: State<T>) => (v: T) => ToResult} */
     const x = get(def)
@@ -114,7 +115,7 @@ const init = create([
     range('~')(() => () => [['~'], unexpectedSymbol]),
 ])(void 0)
 
-module.exports = {
+export default {
     /** @readonly */
     terminal,
     /** @readonly */

package/fsc/{test.f.cjs → test.f.mjs}

@@ -1,6 +1,8 @@
-const _ = require('./module.f.cjs')
-const { one } = require('../text/ascii/module.f.cjs')
-const { stringify } = require('../json/module.f.cjs')
+import _ from './module.f.mjs'
+import ascii from '../text/ascii/module.f.mjs'
+const { one } = ascii
+import j from '../json/module.f.mjs'
+const { stringify } = j
 const s = stringify(i => i)
 
 /** @type {(v: string) => string} */
@@ -9,7 +11,7 @@ const f = v => {
     return s(_.init(n)[0])
 }
 
-module.exports = {
+export default {
     a: () => {
         const x = f('1')
         if (x != '["1"]') { throw x }