functionalscript 0.0.592 → 0.1.594

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

@@ -1,14 +1,15 @@
-const operator = require('../../types/function/operator/module.f.cjs')
-const range_map = require('../../types/range_map/module.f.cjs')
+import operator, * as Operator from '../../types/function/operator/module.f.mjs'
+import range_map, * as RangeMap from '../../types/range_map/module.f.mjs'
 const { merge, fromRange, get } = range_map
-const list = require('../../types/list/module.f.cjs')
-const map = require('../../types/map/module.f.cjs')
+import list, * as List from '../../types/list/module.f.mjs'
+import map, * as Map from '../../types/map/module.f.mjs'
 const { at } = map
-const _range = require('../../types/range/module.f.cjs')
+import _range, * as Range from '../../types/range/module.f.mjs'
 const { one } = _range
 const { empty, stateScan, flat, toArray, reduce: listReduce, scan } = list
-const bigfloat = require('../../types/bigfloat/module.f.cjs')
+import * as bigfloatT from '../../types/bigfloat/module.f.mjs'
 const { fromCharCode } = String
+import ascii from '../../text/ascii/module.f.mjs'
 const {
     range,
     //
@@ -66,7 +67,7 @@ const {
     leftCurlyBracket,
     rightCurlyBracket,
     dollarSign
-} = require('../../text/ascii/module.f.cjs')
+} = ascii
 
 /**
  * @typedef {{
@@ -79,7 +80,7 @@ const {
 * @typedef {{
 * readonly kind: 'number'
 * readonly value: string
-* readonly bf: bigfloat.BigFloat
+* readonly bf: bigfloatT.BigFloat
 * }} NumberToken
 * */
 
@@ -297,14 +298,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
@@ -313,7 +314,7 @@ const rangeId = [digitRange, ...rangeIdStart]
 
 /**
  * @template T
- * @typedef {range_map.RangeMapArray<CreateToToken<T>>} RangeMapToToken<T>
+ * @typedef {RangeMap.RangeMapArray<CreateToToken<T>>} RangeMapToToken<T>
  */
 
 /** @type {(old: string) => (input: number) => string} */
@@ -326,34 +327,34 @@ const union = def => a => b => {
     throw [a, b]
 }
 
-/** @type {<T>(def:  CreateToToken<T>) => range_map.RangeMerge<CreateToToken<T>>} */
+/** @type {<T>(def:  CreateToToken<T>) => RangeMap.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)
@@ -390,7 +391,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'}],
@@ -450,7 +451,7 @@ 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: '!'}],
@@ -518,7 +519,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) }]),
@@ -528,14 +529,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':
@@ -544,7 +545,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)
@@ -558,7 +559,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)
@@ -572,7 +573,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':
@@ -582,7 +583,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-' }]
@@ -590,7 +591,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+' }]
@@ -598,7 +599,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 '.':
@@ -617,7 +618,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':
@@ -633,7 +634,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),
@@ -645,7 +646,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)
@@ -653,26 +654,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) }]),
@@ -683,13 +684,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)
@@ -698,7 +699,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)),
@@ -708,19 +709,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))
@@ -729,21 +730,21 @@ 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])
 ])
 
-/** @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)
@@ -760,7 +761,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' }]
@@ -784,17 +785,17 @@ 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]])))
+/** @type {(input: List.List<number>) => List.List<JsToken>} */
+const tokenize = input => flat(initial(flat([/** @type {List.List<CharCodeOrEof>} */(input), [null]])))
 
-module.exports = {
+export default {
     /** @readonly */
     tokenize,
     /** @readonly */

package/js/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 '../../djs/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.JsToken[]} */
+/** @type {(s: string) => readonly tokenizerT.JsToken[]} */
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = djs.stringify(sort)
 
-module.exports = {
+export default {
     djs: [
         () => {
             const result = tokenizeString('')

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

@@ -1,11 +1,14 @@
-const list = require('../types/list/module.f.cjs')
-const { next, flat, map, empty } = list
-const { concat } = require('../types/string/module.f.cjs')
-const object = require('../types/object/module.f.cjs')
+import list, * as List from '../types/list/module.f.mjs'
+const { next, flat, map } = list
+import string  from '../types/string/module.f.mjs'
+const { concat } = string
+import object, * as O from '../types/object/module.f.mjs'
 const { at } = object
-const { compose, fn } = require('../types/function/module.f.cjs')
+import f from '../types/function/module.f.mjs'
+const { compose, fn } = f
 const { entries } = Object
-const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = require('./serializer/module.f.cjs')
+import s from './serializer/module.f.mjs'
+const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = s
 
 /**
  * @typedef {{
@@ -17,9 +20,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} */
+/** @type {(value: Unknown) => (path: List.List<string>) => (src: Unknown) => Unknown} */
 const setProperty = value => {
-    /** @type {(path: list.List<string>) => (src: Unknown) => Unknown} */
+    /** @type {(path: List.List<string>) => (src: Unknown) => Unknown} */
     const f = path => src => {
         const result = next(path)
         if (result === null) { return value }
@@ -32,28 +35,28 @@ const setProperty = value => {
 
 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) }
@@ -84,9 +87,7 @@ const parse = JSON.parse
 /** @type {(value: Unknown) => value is Object} */
 const isObject = value => typeof value === 'object' && value !== null && !(value instanceof Array)
 
-module.exports = {
-    /** @readonly */
-    tokenizer: require('./tokenizer/module.f.cjs'),
+export default {
     /** @readonly */
     setProperty,
     /** @readonly */

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

@@ -1,18 +1,19 @@
-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 json = require('../module.f.cjs')
-const { fromMap } = require('../../types/object/module.f.cjs')
+import * as Json from '../module.f.mjs'
+import 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
 * */
@@ -20,7 +21,7 @@ const { fromMap } = require('../../types/object/module.f.cjs')
 /**
  * @typedef {{
 * readonly kind: 'array'
-* readonly values: list.List<json.Unknown>
+* readonly values: List.List<Json.Unknown>
 * }} JsonArray
 * */
 
@@ -31,7 +32,7 @@ const { fromMap } = require('../../types/object/module.f.cjs')
 * } JsonStackElement
 */
 
-/** @typedef {list.List<JsonStackElement>} JsonStack */
+/** @typedef {List.List<JsonStackElement>} JsonStack */
 
 /**
  * @typedef {{
@@ -44,7 +45,7 @@ const { fromMap } = require('../../types/object/module.f.cjs')
 /**
  * @typedef {{
 *  readonly status: 'result'
-*  readonly value: json.Unknown
+*  readonly value: Json.Unknown
 * }} StateResult
 */
 
@@ -66,10 +67,10 @@ const { fromMap } = require('../../types/object/module.f.cjs')
 /** @type {(obj: JsonObject) => (key: string) => JsonObject} */
 const addKeyToObject = obj => key => ({ kind: 'object', values: obj.values, key: key })
 
-/** @type {(obj: JsonObject) => (value: json.Unknown) => JsonObject} */
+/** @type {(obj: JsonObject) => (value: Json.Unknown) => JsonObject} */
 const addValueToObject = obj => value => ({ kind: 'object', values: setReplace(obj.key)(value)(obj.values), key: '' })
 
-/** @type {(array: JsonArray) => (value: json.Unknown) => JsonArray} */
+/** @type {(array: JsonArray) => (value: Json.Unknown) => JsonArray} */
 const addToArray = array => value => ({ kind: 'array', values: list.concat(array.values)([value]) })
 
 /** @type {(state: StateParse) => (key: string) => JsonState} */
@@ -78,7 +79,7 @@ const pushKey = state => value => {
     return { status: 'error', message: 'error' }
 }
 
-/** @type {(state: StateParse) => (value: json.Unknown) => JsonState} */
+/** @type {(state: StateParse) => (value: Json.Unknown) => JsonState} */
 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 } }
@@ -113,7 +114,7 @@ const endObject = state => {
     return pushValue(newState)(obj)
 }
 
-/** @type {(token: tokenizer.JsonToken) => json.Unknown} */
+/** @type {(token: tokenizerT.JsonToken) => Json.Unknown} */
 const tokenToValue = token => {
     switch (token.kind) {
         case 'null': return null
@@ -125,7 +126,7 @@ const tokenToValue = token => {
     }
 }
 
-/** @type {(token: tokenizer.JsonToken) => boolean} */
+/** @type {(token: tokenizerT.JsonToken) => boolean} */
 const isValueToken = token => {
     switch (token.kind) {
         case 'null':
@@ -137,7 +138,7 @@ const isValueToken = token => {
     }
 }
 
-/** @type {(token: tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
 const parseValueOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
     if (token.kind === '[') { return startArray(state) }
@@ -145,7 +146,7 @@ const parseValueOp = token => state => {
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
 const parseArrayStartOp = token => state => {
     if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
     if (token.kind === '[') { return startArray(state) }
@@ -154,40 +155,40 @@ const parseArrayStartOp = token => state => {
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
 const parseArrayValueOp = token => state => {
     if (token.kind === ']') { return endArray(state) }
     if (token.kind === ',') { return { status: '[,', top: state.top, stack: state.stack } }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
 const parseObjectStartOp = token => state => {
     if (token.kind === 'string') { return pushKey(state)(token.value) }
     if (token.kind === '}') { return endObject(state) }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
 const parseObjectKeyOp = token => state => {
     if (token.kind === ':') { return { status: '{:', top: state.top, stack: state.stack } }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
 const parseObjectNextOp = token => state => {
     if (token.kind === '}') { return endObject(state) }
     if (token.kind === ',') { return { status: '{,', top: state.top, stack: state.stack } }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {(token: tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+/** @type {(token: tokenizerT.JsonToken) => (state: StateParse) => JsonState}} */
 const parseObjectCommaOp = token => state => {
     if (token.kind === 'string') { return pushKey(state)(token.value) }
     return { status: 'error', message: 'unexpected token' }
 }
 
-/** @type {operator.Fold<tokenizer.JsonToken, JsonState>} */
+/** @type {Operator.Fold<tokenizerT.JsonToken, JsonState>} */
 const foldOp = token => state => {
     switch (state.status) {
         case 'result': return { status: 'error', message: 'unexpected token' }
@@ -204,7 +205,7 @@ const foldOp = token => state => {
     }
 }
 
-/** @type {(tokenList: list.List<tokenizer.JsonToken>) => result.Result<json.Unknown, string>} */
+/** @type {(tokenList: List.List<tokenizerT.JsonToken>) => Result.Result<Json.Unknown, string>} */
 const parse = tokenList => {
     const state = fold(foldOp)({ status: '', top: null, stack: null })(tokenList)
     switch (state.status) {
@@ -214,7 +215,7 @@ const parse = tokenList => {
     }
 }
 
-module.exports = {
+export default {
     /** @readonly */
     parse
 }