functionalscript 0.1.609 → 0.2.1

package/js/tokenizer/module.f.mjs

@@ -1,18 +1,18 @@
 // @ts-self-types="./module.f.d.mts"
-import operator, * as Operator from '../../types/function/operator/module.f.mjs'
-import range_map, * as RangeMap from '../../types/range_map/module.f.mjs'
+import * as operator from '../../types/function/operator/module.f.mjs'
+import * as range_map from '../../types/range_map/module.f.mjs'
 const { merge, fromRange, get } = range_map
-import list, * as List from '../../types/list/module.f.mjs'
-import map, * as Map from '../../types/map/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
+import * as map from '../../types/map/module.f.mjs'
 const { at } = map
-import _range, * as Range from '../../types/range/module.f.mjs'
+import * as _range from '../../types/range/module.f.mjs'
 const { one } = _range
 const { empty, stateScan, flat, toArray, reduce: listReduce, scan } = list
 import * as bigfloatT from '../../types/bigfloat/module.f.mjs'
 const { fromCharCode } = String
-import ascii from '../../text/ascii/module.f.mjs'
+import * as ascii from '../../text/ascii/module.f.mjs'
+const { range } = ascii
 const {
-    range,
     //
     backspace,
     ht,
@@ -68,7 +68,7 @@ const {
     leftCurlyBracket,
     rightCurlyBracket,
     dollarSign
-} = ascii
+} = ascii.ascii
 
 /**
  * @typedef {{
@@ -157,9 +157,9 @@ const {
 
 const rangeOneNine = range('19')
 
-const rangeSetNewLine = [    
+const rangeSetNewLine = [
     one(lf),
-    one(cr)    
+    one(cr)
 ]
 
 const rangeSetWhiteSpace = [
@@ -309,14 +309,14 @@ const rangeId = [digitRange, ...rangeIdStart]
 
 /** @typedef {number|null} CharCodeOrEof */
 
-/** @typedef {(input: number) => readonly[List.List<JsToken>, TokenizerState]} ToToken */
+/** @typedef {(input: number) => readonly[list.List<JsToken>, TokenizerState]} ToToken */
 
 /**
  * @template T
  * @typedef {(state: T) => ToToken} CreateToToken<T>
  */
 
-/** @typedef {List.List<Range.Range>} RangeSet */
+/** @typedef {list.List<_range.Range>} RangeSet */
 
 /**
  * @template T
@@ -325,7 +325,7 @@ const rangeId = [digitRange, ...rangeIdStart]
 
 /**
  * @template T
- * @typedef {RangeMap.RangeMapArray<CreateToToken<T>>} RangeMapToToken<T>
+ * @typedef {range_map.RangeMapArray<CreateToToken<T>>} RangeMapToToken<T>
  */
 
 /** @type {(old: string) => (input: number) => string} */
@@ -338,34 +338,34 @@ const union = def => a => b => {
     throw [a, b]
 }
 
-/** @type {<T>(def:  CreateToToken<T>) => RangeMap.RangeMerge<CreateToToken<T>>} */
+/** @type {<T>(def:  CreateToToken<T>) => range_map.RangeMerge<CreateToToken<T>>} */
 const rangeMapMerge = def => merge({
     union: union(def),
     equal: operator.strictEqual,
 })
 
-/** @type {<T>(r: Range.Range) => (f: CreateToToken<T>) => RangeFunc<T>} */
+/** @type {<T>(r: _range.Range) => (f: CreateToToken<T>) => RangeFunc<T>} */
 const rangeFunc = r => f => def => fromRange(def)(r)(f)
 
-/** @type {<T>(def:  CreateToToken<T>) => (Operator.Scan<RangeFunc<T>, RangeMapToToken<T>>)} */
+/** @type {<T>(def:  CreateToToken<T>) => (operator.Scan<RangeFunc<T>, RangeMapToToken<T>>)} */
 const scanRangeOp = def => f => [f(def), scanRangeOp(def)]
 
-/** @type {<T>(def: CreateToToken<T>) => (a: List.List<RangeFunc<T>>) => RangeMapToToken<T>} */
+/** @type {<T>(def: CreateToToken<T>) => (a: list.List<RangeFunc<T>>) => RangeMapToToken<T>} */
 const reduceRangeMap = def => a => {
     const rm = scan(scanRangeOp(def))(a)
     return toArray(listReduce(rangeMapMerge(def))(empty)(rm))
 }
 
-/** @type {<T>(def:  CreateToToken<T>) => (f:  CreateToToken<T>) => (Operator.Scan<Range.Range, RangeMapToToken<T>>)} */
+/** @type {<T>(def:  CreateToToken<T>) => (f:  CreateToToken<T>) => (operator.Scan<_range.Range, RangeMapToToken<T>>)} */
 const scanRangeSetOp = def => f => r => [fromRange(def)(r)(f), scanRangeSetOp(def)(f)]
 
-/** @type {<T>(rs: List.List<Range.Range>) => (f: CreateToToken<T>) => RangeFunc<T>} */
+/** @type {<T>(rs: list.List<_range.Range>) => (f: CreateToToken<T>) => RangeFunc<T>} */
 const rangeSetFunc = rs => f => def => {
     const rm = scan(scanRangeSetOp(def)(f))(rs)
     return toArray(listReduce(rangeMapMerge(def))(empty)(rm))
 }
 
-/** @type {<T>(def: CreateToToken<T>) => (a: List.List<RangeFunc<T>>) => CreateToToken<T>} */
+/** @type {<T>(def: CreateToToken<T>) => (a: list.List<RangeFunc<T>>) => CreateToToken<T>} */
 const create = def => a => {
     /** @typedef {typeof def extends CreateToToken<infer T> ? T : never} T */
     const i = reduceRangeMap(def)(a)
@@ -402,7 +402,7 @@ const bufferToNumberToken = ({numberKind, value, b}) =>
 
 /**
  * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#keywords
- * @type {List.List<Map.Entry<JsToken>>}
+ * @type {list.List<map.Entry<JsToken>>}
  */
 const keywordEntries = [
     ['arguments', { kind: 'arguments'}],
@@ -458,11 +458,11 @@ const keywordEntries = [
 const keywordMap = map.fromEntries(keywordEntries)
 
 /** @type {(token: JsToken) => Boolean} */
-const isKeywordToken = token => at(token.kind)(keywordMap) !== null
+export const isKeywordToken = token => at(token.kind)(keywordMap) !== null
 
 /**
  * @link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators
- * @type {List.List<Map.Entry<JsToken>>}
+ * @type {list.List<map.Entry<JsToken>>}
  */
 const operatorEntries = [
     ['!', { kind: '!'}],
@@ -530,7 +530,7 @@ const getOperatorToken = op => at(op)(operatorMap) ?? { kind: 'error', message:
 /** @type {(op: string) => Boolean} */
 const hasOperatorToken = op => at(op)(operatorMap) !== null
 
-/** @type {(state: InitialState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: InitialState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const initialStateOp = create(state => () => [[{ kind: 'error', message: 'unexpected character' }], state])([
     rangeFunc(rangeOneNine)(() => input => [empty, { kind: 'number', value: fromCharCode(input), b: startNumber(input), numberKind: 'int' }]),
     rangeSetFunc(rangeIdStart)(() => input => [empty, { kind: 'id', value: fromCharCode(input) }]),
@@ -541,14 +541,14 @@ const initialStateOp = create(state => () => [[{ kind: 'error', message: 'unexpe
     rangeSetFunc(rangeOpStart)(() => input => [empty, { kind: 'op', value: fromCharCode(input) }])
 ])
 
-/** @type {(state: ParseNumberState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const invalidNumberToToken = () => input =>
 {
     const next = tokenizeOp({ kind: 'initial' })(input)
     return [{ first: { kind: 'error', message: 'invalid number' }, tail: next[0] }, next[1]]
 }
 
-/** @type {(state: ParseNumberState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const fullStopToToken = state => input => {
     switch (state.numberKind) {
         case '0':
@@ -557,7 +557,7 @@ const fullStopToToken = state => input => {
     }
 }
 
-/** @type {(state: ParseNumberState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const digit0ToToken = state => input => {
     switch (state.numberKind) {
         case '0': return tokenizeOp({ kind: 'invalidNumber' })(input)
@@ -571,7 +571,7 @@ const digit0ToToken = state => input => {
     }
 }
 
-/** @type {(state: ParseNumberState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const digit19ToToken = state => input => {
     switch (state.numberKind) {
         case '0': return tokenizeOp({ kind: 'invalidNumber' })(input)
@@ -585,7 +585,7 @@ const digit19ToToken = state => input => {
     }
 }
 
-/** @type {(state: ParseNumberState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const expToToken = state => input => {
     switch (state.numberKind) {
         case '0':
@@ -595,7 +595,7 @@ const expToToken = state => input => {
     }
 }
 
-/** @type {(state: ParseNumberState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const hyphenMinusToToken = state => input => {
     switch (state.numberKind) {
         case 'e': return [empty, { kind: 'number', value: appendChar(state.value)(input), b: { ... state.b, es: -1}, numberKind: 'e-' }]
@@ -603,7 +603,7 @@ const hyphenMinusToToken = state => input => {
     }
 }
 
-/** @type {(state: ParseNumberState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const plusSignToToken = state => input => {
     switch (state.numberKind) {
         case 'e': return [empty, { kind: 'number', value: appendChar(state.value)(input), b: state.b, numberKind: 'e+' }]
@@ -611,7 +611,7 @@ const plusSignToToken = state => input => {
     }
 }
 
-/** @type {(state: ParseNumberState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const terminalToToken = state => input => {
     switch (state.numberKind) {
         case '.':
@@ -630,7 +630,7 @@ const terminalToToken = state => input => {
     }
 }
 
-/** @type {(state: ParseNumberState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const bigintToToken = state => input => {
     switch (state.numberKind) {
         case '0':
@@ -646,7 +646,7 @@ const bigintToToken = state => input => {
     }
 }
 
-/** @type {(state: ParseNumberState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseNumberStateOp = create(invalidNumberToToken)([
     rangeFunc(one(fullStop))(fullStopToToken),
     rangeFunc(one(digit0))(digit0ToToken),
@@ -658,7 +658,7 @@ const parseNumberStateOp = create(invalidNumberToToken)([
     rangeFunc(one(latinSmallLetterN))(bigintToToken),
 ])
 
-/** @type {(state: InvalidNumberState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: InvalidNumberState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const invalidNumberStateOp = create(() => () => [empty, { kind: 'invalidNumber' }])([
     rangeSetFunc(rangeSetTerminalForNumber)(() => input => {
         const next = tokenizeOp({ kind: 'initial' })(input)
@@ -666,26 +666,26 @@ const invalidNumberStateOp = create(() => () => [empty, { kind: 'invalidNumber'
     })
 ])
 
-/** @type {(state: ParseMinusState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseMinusState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseMinusStateOp = create(() => input => tokenizeOp({ kind: 'op', value: '-' })(input))([
     rangeFunc(one(fullStop))(() => input => tokenizeOp({ kind: 'invalidNumber' })(input)),
     rangeFunc(one(digit0))(() => () => [empty, { kind: 'number', value: '-0', b: startNegativeNumber, numberKind: '0' }]),
     rangeFunc(rangeOneNine)(() => input => [empty, { kind: 'number', value: appendChar('-')(input), b: addIntDigit(input)(startNegativeNumber), numberKind: 'int' }]),
 ])
 
-/** @type {(state: ParseStringState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseStringState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseStringStateOp = create(state => input => [empty, { kind: 'string', value: appendChar(state.value)(input) }])([
     rangeFunc(one(quotationMark))(state => () => [[{ kind: 'string', value: state.value }], { kind: 'initial' }]),
     rangeFunc(one(reverseSolidus))(state => () => [empty, { kind: 'escapeChar', value: state.value }])
 ])
 
-/** @type {(state: ParseEscapeCharState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseEscapeCharState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseEscapeDefault = state => input => {
     const next = tokenizeOp({ kind: 'string', value: state.value })(input)
     return [{ first: { kind: 'error', message: 'unescaped character' }, tail: next[0] }, next[1]]
 }
 
-/** @type {(state: ParseEscapeCharState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseEscapeCharState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseEscapeCharStateOp = create(parseEscapeDefault)([
     rangeSetFunc([one(quotationMark), one(reverseSolidus), one(solidus)])(state => input => [empty, { kind: 'string', value: appendChar(state.value)(input) }]),
     rangeFunc(one(latinSmallLetterB))(state => () => [empty, { kind: 'string', value: appendChar(state.value)(backspace) }]),
@@ -696,13 +696,13 @@ const parseEscapeCharStateOp = create(parseEscapeDefault)([
     rangeFunc(one(latinSmallLetterU))(state => () => [empty, { kind: 'unicodeChar', value: state.value, unicode: 0, hexIndex: 0 }]),
 ])
 
-/** @type {(state: ParseUnicodeCharState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseUnicodeCharState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseUnicodeCharDefault = state => input => {
     const next = tokenizeOp({ kind: 'string', value: state.value })(input)
     return [{ first: { kind: 'error', message: 'invalid hex value' }, tail: next[0] }, next[1]]
 }
 
-/** @type {(offser: number) => (state: ParseUnicodeCharState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(offser: number) => (state: ParseUnicodeCharState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseUnicodeCharHex = offset => state => input => {
     const hexValue = input - offset
     const newUnicode = state.unicode | (hexValue << (3 - state.hexIndex) * 4)
@@ -711,7 +711,7 @@ const parseUnicodeCharHex = offset => state => input => {
         { kind: 'unicodeChar', value: state.value, unicode: newUnicode, hexIndex: state.hexIndex + 1 }]
 }
 
-/** @type {(state: ParseUnicodeCharState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseUnicodeCharState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseUnicodeCharStateOp = create(parseUnicodeCharDefault)([
     rangeFunc(digitRange)(parseUnicodeCharHex(digit0)),
     rangeFunc(rangeSmallAF)(parseUnicodeCharHex(latinSmallLetterA - 10)),
@@ -721,19 +721,19 @@ const parseUnicodeCharStateOp = create(parseUnicodeCharDefault)([
 /** @type {(s: string) => JsToken} */
 const idToToken = s => at(s)(keywordMap) ?? { kind: 'id', value: s }
 
-/** @type {(state: ParseIdState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseIdState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseIdDefault = state => input => {
     const keyWordToken = idToToken(state.value)
     const next = tokenizeOp({ kind: 'initial' })(input)
     return [{ first: keyWordToken, tail: next[0] }, next[1]]
 }
 
-/** @type {(state: ParseIdState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseIdState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseIdStateOp = create(parseIdDefault)([
     rangeSetFunc(rangeId)(state => input => [empty, { kind: 'id', value: appendChar(state.value)(input) }])
 ])
 
-/** @type {(state: ParseOperatorState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseOperatorState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseOperatorStateOp = state => input => {
     const nextStateValue = appendChar(state.value)(input)
     if (hasOperatorToken(nextStateValue))
@@ -742,34 +742,34 @@ const parseOperatorStateOp = state => input => {
     return [{ first: getOperatorToken(state.value), tail: next[0] }, next[1]]
 }
 
-/** @type {(state: ParseWhitespaceState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseWhitespaceState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseWhitespaceDefault = state => input => {
     const next = tokenizeOp({ kind: 'initial' })(input)
     return [{ first: { kind: 'ws' }, tail: next[0] }, next[1]]
 }
 
-/** @type {(state: ParseWhitespaceState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseWhitespaceState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseWhitespaceStateOp = create(parseWhitespaceDefault)([
     rangeSetFunc(rangeSetWhiteSpace)(state => () => [empty, state]),
     rangeSetFunc(rangeSetNewLine)(state => () => [empty, { kind: 'nl' }])
 ])
 
-/** @type {(state: ParseNewLineState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseNewLineState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseNewLineDefault = state => input => {
     const next = tokenizeOp({ kind: 'initial' })(input)
     return [{ first: { kind: 'nl' }, tail: next[0] }, next[1]]
 }
 
-/** @type {(state: ParseNewLineState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: ParseNewLineState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const parseNewLineStateOp = create(parseNewLineDefault)([
     rangeSetFunc(rangeSetWhiteSpace)(state => () => [empty, state]),
     rangeSetFunc(rangeSetNewLine)(state => () => [empty, state])
 ])
 
-/** @type {(state: EofState) => (input: number) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: EofState) => (input: number) => readonly[list.List<JsToken>, TokenizerState]} */
 const eofStateOp = create(state => () => [[{ kind: 'error', message: 'eof' }], state])([])
 
-/** @type {Operator.StateScan<number, TokenizerState, List.List<JsToken>>} */
+/** @type {operator.StateScan<number, TokenizerState, list.List<JsToken>>} */
 const tokenizeCharCodeOp = state => {
     switch (state.kind) {
         case 'initial': return initialStateOp(state)
@@ -787,7 +787,7 @@ const tokenizeCharCodeOp = state => {
     }
 }
 
-/** @type {(state: TokenizerState) => readonly[List.List<JsToken>, TokenizerState]} */
+/** @type {(state: TokenizerState) => readonly[list.List<JsToken>, TokenizerState]} */
 const tokenizeEofOp = state => {
     switch (state.kind) {
         case 'initial': return [empty, { kind: 'eof' }]
@@ -812,19 +812,12 @@ const tokenizeEofOp = state => {
     }
 }
 
-/** @type {Operator.StateScan<CharCodeOrEof, TokenizerState, List.List<JsToken>>} */
+/** @type {operator.StateScan<CharCodeOrEof, TokenizerState, list.List<JsToken>>} */
 const tokenizeOp = state => input => input === null ? tokenizeEofOp(state) : tokenizeCharCodeOp(state)(input)
 
 const scanTokenize = stateScan(tokenizeOp)
 
 const initial = scanTokenize({ kind: 'initial' })
 
-/** @type {(input: List.List<number>) => List.List<JsToken>} */
-const tokenize = input => flat(initial(flat([/** @type {List.List<CharCodeOrEof>} */(input), [null]])))
-
-export default {
-    /** @readonly */
-    tokenize,
-    /** @readonly */
-    isKeywordToken
-}
+/** @type {(input: list.List<number>) => list.List<JsToken>} */
+export const tokenize = input => flat(initial(flat([/** @type {list.List<CharCodeOrEof>} */(input), [null]])))

package/js/tokenizer/test.f.mjs

@@ -1,12 +1,12 @@
-import tokenizer, * as Tokenizer from './module.f.mjs'
-import list from '../../types/list/module.f.mjs'
+import * as tokenizer from './module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { toArray } = list
-import djs from '../../djs/module.f.mjs'
-import o from '../../types/object/module.f.mjs'
+import * as djs from '../../djs/module.f.mjs'
+import * as o from '../../types/object/module.f.mjs'
 const { sort } = o
-import encoding from '../../text/utf16/module.f.mjs'
+import * as encoding from '../../text/utf16/module.f.mjs'
 
-/** @type {(s: string) => readonly Tokenizer.JsToken[]} */
+/** @type {(s: string) => readonly tokenizer.JsToken[]} */
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = djs.stringify(sort)

package/json/module.f.mjs

@@ -1,14 +1,14 @@
 // @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 { next, flat, map } = list
-import string  from '../types/string/module.f.mjs'
+import * as string  from '../types/string/module.f.mjs'
 const { concat } = string
-import object, * as O from '../types/object/module.f.mjs'
+import * as object from '../types/object/module.f.mjs'
 const { at } = object
-import f from '../types/function/module.f.mjs'
+import * as f from '../types/function/module.f.mjs'
 const { compose, fn } = f
 const { entries } = Object
-import s from './serializer/module.f.mjs'
+import * as s from './serializer/module.f.mjs'
 const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = s
 
 /**
@@ -21,9 +21,9 @@ const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize,
 
 /** @typedef {Object|boolean|string|number|null|Array} Unknown */
 
-/** @type {(value: Unknown) => (path: List.List<string>) => (src: Unknown) => Unknown} */
-const setProperty = value => {
-    /** @type {(path: List.List<string>) => (src: Unknown) => Unknown} */
+/** @type {(value: Unknown) => (path: list.List<string>) => (src: Unknown) => Unknown} */
+export const setProperty = value => {
+    /** @type {(path: list.List<string>) => (src: Unknown) => Unknown} */
     const f = path => src => {
         const result = next(path)
         if (result === null) { return value }
@@ -36,28 +36,28 @@ const setProperty = value => {
 
 const colon = [':']
 
-/** @typedef {O.Entry<Unknown>} Entry*/
+/** @typedef {object.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>} */
-const serialize = sort => {
-    /** @type {(kv: readonly[string, Unknown]) => List.List<string>} */
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => list.List<string>} */
+export const serialize = sort => {
+    /** @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) }
@@ -80,23 +80,10 @@ const serialize = sort => {
  *
  * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
  */
-const stringify = sort => compose(serialize(sort))(concat)
+export const stringify = sort => compose(serialize(sort))(concat)
 
 /** @type {(value: string) => Unknown} */
-const parse = JSON.parse
+export const parse = JSON.parse
 
 /** @type {(value: Unknown) => value is Object} */
-const isObject = value => typeof value === 'object' && value !== null && !(value instanceof Array)
-
-export default {
-    /** @readonly */
-    setProperty,
-    /** @readonly */
-    stringify,
-    /** @readonly */
-    serialize,
-    /** @readonly */
-    parse,
-    /** @readonly */
-    isObject,
-}
+export const isObject = value => typeof value === 'object' && value !== null && !(value instanceof Array)

package/json/parser/module.f.mjs

@@ -1,20 +1,20 @@
 // @ts-self-types="./module.f.d.mts"
-import result, * as Result from '../../types/result/module.f.mjs'
-import list, * as List from '../../types/list/module.f.mjs'
+import * as result from '../../types/result/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { fold, first, drop, toArray } = list
 import * as Operator from '../../types/function/operator/module.f.mjs'
 import * as Tokenizer from '../tokenizer/module.f.mjs'
-import map, * as Map from '../../types/map/module.f.mjs'
+import * as map from '../../types/map/module.f.mjs'
 const { setReplace } = map
 import * as Json from '../module.f.mjs'
-import o from '../../types/object/module.f.mjs'
+import * as o from '../../types/object/module.f.mjs'
 const { fromMap } = o
 
 
 /**
  * @typedef {{
 * readonly kind: 'object'
-* readonly values: Map.Map<Json.Unknown>
+* readonly values: map.Map<Json.Unknown>
 * readonly key: string
 * }} JsonObject
 * */
@@ -22,7 +22,7 @@ const { fromMap } = o
 /**
  * @typedef {{
 * readonly kind: 'array'
-* readonly values: List.List<Json.Unknown>
+* readonly values: list.List<Json.Unknown>
 * }} JsonArray
 * */
 
@@ -33,7 +33,7 @@ const { fromMap } = o
 * } JsonStackElement
 */
 
-/** @typedef {List.List<JsonStackElement>} JsonStack */
+/** @typedef {list.List<JsonStackElement>} JsonStack */
 
 /**
  * @typedef {{
@@ -206,8 +206,8 @@ const foldOp = token => state => {
     }
 }
 
-/** @type {(tokenList: List.List<Tokenizer.JsonToken>) => Result.Result<Json.Unknown, string>} */
-const parse = tokenList => {
+/** @type {(tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>} */
+export const parse = tokenList => {
     const state = fold(foldOp)({ status: '', top: null, stack: null })(tokenList)
     switch (state.status) {
         case 'result': return result.ok(state.value)
@@ -215,8 +215,3 @@ const parse = tokenList => {
         default: return result.error('unexpected end')
     }
 }
-
-export default {
-    /** @readonly */
-    parse
-}

package/json/parser/test.f.mjs

@@ -1,13 +1,13 @@
-import parser from './module.f.mjs'
-import tokenizer, * as Tokenizer from '../tokenizer/module.f.mjs'
-import list from '../../types/list/module.f.mjs'
+import * as parser from './module.f.mjs'
+import * as tokenizer from '../tokenizer/module.f.mjs'
+import * as list from '../../types/list/module.f.mjs'
 const { toArray } = list
-import json from '../module.f.mjs'
-import o from '../../types/object/module.f.mjs'
+import * as json from '../module.f.mjs'
+import * as o from '../../types/object/module.f.mjs'
 const { sort } = o
-import encoding from '../../text/utf16/module.f.mjs'
+import * as encoding from '../../text/utf16/module.f.mjs'
 
-/** @type {(s: string) => readonly Tokenizer.JsonToken[]} */
+/** @type {(s: string) => readonly tokenizer.JsonToken[]} */
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = json.stringify(sort)