functionalscript 0.1.609 → 0.2.0

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.d.mts

@@ -1,17 +1,3 @@
-declare namespace _default {
-    export { setProperty };
-    export { stringify };
-    export { serialize };
-    export { parse };
-    export { isObject };
-}
-export default _default;
-export type Object = { readonly [k in string]: Unknown; };
-export type Array = readonly Unknown[];
-export type Unknown = Object | boolean | string | number | null | Array;
-export type Entry = O.Entry<Unknown>;
-export type Entries = (List.List<Entry>);
-export type MapEntries = (entries: Entries) => Entries;
 /**
  * @typedef {{
  *  readonly [k in string]: Unknown
@@ -19,23 +5,29 @@ export type MapEntries = (entries: Entries) => Entries;
  */
 /** @typedef {readonly Unknown[]} Array */
 /** @typedef {Object|boolean|string|number|null|Array} Unknown */
-/** @type {(value: Unknown) => (path: List.List<string>) => (src: Unknown) => Unknown} */
-declare const setProperty: (value: Unknown) => (path: List.List<string>) => (src: Unknown) => Unknown;
+/** @type {(value: Unknown) => (path: list.List<string>) => (src: Unknown) => Unknown} */
+export const setProperty: (value: Unknown) => (path: list.List<string>) => (src: Unknown) => Unknown;
+/** @typedef {object.Entry<Unknown>} Entry*/
+/** @typedef {(list.List<Entry>)} Entries */
+/** @typedef {(entries: Entries) => Entries} MapEntries */
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => list.List<string>} */
+export const serialize: (mapEntries: MapEntries) => (value: Unknown) => list.List<string>;
 /**
  * The standard `JSON.stringify` rules determined by
  * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
  *
  * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
  */
-declare const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
-/** @typedef {O.Entry<Unknown>} Entry*/
-/** @typedef {(List.List<Entry>)} Entries */
-/** @typedef {(entries: Entries) => Entries} MapEntries */
-/** @type {(mapEntries: MapEntries) => (value: Unknown) => List.List<string>} */
-declare const serialize: (mapEntries: MapEntries) => (value: Unknown) => List.List<string>;
+export const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
 /** @type {(value: string) => Unknown} */
-declare const parse: (value: string) => Unknown;
+export const parse: (value: string) => Unknown;
 /** @type {(value: Unknown) => value is Object} */
-declare const isObject: (value: Unknown) => value is Object;
-import * as O from '../types/object/module.f.mjs';
-import * as List from '../types/list/module.f.mjs';
+export const isObject: (value: Unknown) => value is Object;
+export type Object = { readonly [k in string]: Unknown; };
+export type Array = readonly Unknown[];
+export type Unknown = Object | boolean | string | number | null | Array;
+export type Entry = object.Entry<Unknown>;
+export type Entries = (list.List<Entry>);
+export type MapEntries = (entries: Entries) => Entries;
+import * as list from '../types/list/module.f.mjs';
+import * as object from '../types/object/module.f.mjs';

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.d.mts

@@ -1,18 +1,16 @@
-declare namespace _default {
-    export { parse };
-}
-export default _default;
+/** @type {(tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>} */
+export const parse: (tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>;
 export type JsonObject = {
     readonly kind: "object";
-    readonly values: Map.Map<Json.Unknown>;
+    readonly values: map.Map<Json.Unknown>;
     readonly key: string;
 };
 export type JsonArray = {
     readonly kind: "array";
-    readonly values: List.List<Json.Unknown>;
+    readonly values: list.List<Json.Unknown>;
 };
 export type JsonStackElement = JsonObject | JsonArray;
-export type JsonStack = List.List<JsonStackElement>;
+export type JsonStack = list.List<JsonStackElement>;
 export type StateParse = {
     readonly status: "" | "[" | "[v" | "[," | "{" | "{k" | "{:" | "{v" | "{,";
     readonly top: JsonStackElement | null;
@@ -27,10 +25,8 @@ export type StateError = {
     readonly message: string;
 };
 export type JsonState = StateParse | StateResult | StateError;
-/** @type {(tokenList: List.List<Tokenizer.JsonToken>) => Result.Result<Json.Unknown, string>} */
-declare const parse: (tokenList: List.List<Tokenizer.JsonToken>) => Result.Result<Json.Unknown, string>;
-import * as Map from '../../types/map/module.f.mjs';
-import * as Json from '../module.f.mjs';
-import * as List from '../../types/list/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';
 import * as Tokenizer from '../tokenizer/module.f.mjs';
-import * as Result from '../../types/result/module.f.mjs';
+import * as result from '../../types/result/module.f.mjs';
+import * as Json from '../module.f.mjs';
+import * as map from '../../types/map/module.f.mjs';