functionalscript 0.1.608 → 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 {{
@@ -96,6 +96,8 @@ const {
 
 /** @typedef {{readonly kind: 'ws'}} WhitespaceToken */
 
+/** @typedef {{readonly kind: 'nl'}} NewLineToken */
+
 /** @typedef {{readonly kind: 'true'}} TrueToken */
 
 /** @typedef {{readonly kind: 'false'}} FalseToken */
@@ -143,6 +145,7 @@ const {
 * FalseToken |
 * NullToken |
 * WhitespaceToken |
+* NewLineToken |
 * StringToken |
 * NumberToken |
 * ErrorToken |
@@ -154,15 +157,19 @@ const {
 
 const rangeOneNine = range('19')
 
+const rangeSetNewLine = [
+    one(lf),
+    one(cr)
+]
+
 const rangeSetWhiteSpace = [
     one(ht),
-    one(lf),
-    one(cr),
     one(space)
 ]
 
 const rangeSetTerminalForNumber = [
     ...rangeSetWhiteSpace,
+    ...rangeSetNewLine,
     one(exclamationMark),
     one(percentSign),
     one(ampersand),
@@ -235,6 +242,7 @@ const rangeId = [digitRange, ...rangeIdStart]
  * ParseOperatorState |
  * ParseMinusState |
  * ParseWhitespaceState |
+ * ParseNewLineState |
  * EofState
  * } TokenizerState
  */
@@ -257,6 +265,8 @@ const rangeId = [digitRange, ...rangeIdStart]
 
 /** @typedef {{ readonly kind: 'ws'}} ParseWhitespaceState */
 
+/** @typedef {{ readonly kind: 'nl'}} ParseNewLineState */
+
 /** @typedef {{ readonly kind: 'string', readonly value: string}} ParseStringState */
 
 /** @typedef {{ readonly kind: 'escapeChar', readonly value: string}} ParseEscapeCharState */
@@ -299,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
@@ -315,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} */
@@ -328,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)
@@ -392,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'}],
@@ -448,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: '!'}],
@@ -520,24 +530,25 @@ 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) }]),
     rangeSetFunc(rangeSetWhiteSpace)(state => () => [empty, { kind: 'ws' }]),
+    rangeSetFunc(rangeSetNewLine)(state => () => [empty, { kind: 'nl' }]),
     rangeFunc(one(quotationMark))(() => () => [empty, { kind: 'string', value: '' }]),
     rangeFunc(one(digit0))(() => input => [empty, { kind: 'number', value: fromCharCode(input), b: startNumber(input), numberKind: '0' }]),
     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':
@@ -546,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)
@@ -560,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)
@@ -574,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':
@@ -584,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-' }]
@@ -592,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+' }]
@@ -600,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 '.':
@@ -619,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':
@@ -635,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),
@@ -647,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)
@@ -655,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) }]),
@@ -685,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)
@@ -700,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)),
@@ -710,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))
@@ -731,21 +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(rangeSetWhiteSpace)(state => () => [empty, state]),
+    rangeSetFunc(rangeSetNewLine)(state => () => [empty, { kind: 'nl' }])
 ])
 
-/** @type {(state: EofState) => (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]} */
+const parseNewLineStateOp = create(parseNewLineDefault)([
+    rangeSetFunc(rangeSetWhiteSpace)(state => () => [empty, state]),
+    rangeSetFunc(rangeSetNewLine)(state => () => [empty, state])
+])
+
+/** @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)
@@ -758,11 +782,12 @@ const tokenizeCharCodeOp = state => {
         case 'op': return parseOperatorStateOp(state)
         case '-': return parseMinusStateOp(state)
         case 'ws': return parseWhitespaceStateOp(state)
+        case 'nl': return parseNewLineStateOp(state)
         case 'eof': return eofStateOp(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' }]
@@ -782,23 +807,17 @@ const tokenizeEofOp = state => {
         case 'op': return [[getOperatorToken(state.value)], { kind: 'eof' }]
         case '-': return [[{kind: '-'}], { kind: 'eof' }]
         case 'ws': return [[{kind: 'ws'}], { kind: 'eof' }]
+        case 'nl': return [[{kind: 'nl'}], { kind: 'eof' }]
         case 'eof': return [[{ kind: 'error', message: 'eof' }], 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)
@@ -47,9 +47,8 @@ export default {
         },
         () => {
             const result = stringify(tokenizeString('{ \t\n\r}'))
-            if (result !== '[{"kind":"{"},{"kind":"ws"},{"kind":"}"}]') { throw result }
+            if (result !== '[{"kind":"{"},{"kind":"nl"},{"kind":"}"}]') { throw result }
         },
-
         () => {
             const result = stringify(tokenizeString('""'))
             if (result !== '[{"kind":"string","value":""}]') { throw result }
@@ -344,16 +343,20 @@ export default {
             if (result !== '[{"kind":"ws"}]') { throw result }
         },
         () => {
-            const result = stringify(tokenizeString('\n'))
+            const result = stringify(tokenizeString(' \t'))
             if (result !== '[{"kind":"ws"}]') { throw result }
         },
+        () => {
+            const result = stringify(tokenizeString('\n'))
+            if (result !== '[{"kind":"nl"}]') { throw result }
+        },
         () => {
             const result = stringify(tokenizeString('\r'))
-            if (result !== '[{"kind":"ws"}]') { throw result }
+            if (result !== '[{"kind":"nl"}]') { throw result }
         },
         () => {
-            const result = stringify(tokenizeString(' \t\n\r'))
-            if (result !== '[{"kind":"ws"}]') { throw result }
+            const result = stringify(tokenizeString(' \t\n\r '))
+            if (result !== '[{"kind":"nl"}]') { throw result }
         },
     ],
     id: [

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)