functionalscript 0.0.497 → 0.0.499

package/fsc/module.f.cjs

@@ -12,7 +12,7 @@ const { toArray, map } = list
 
 /** @typedef {readonly[readonly string[], ToResult]} Result */
 
-/** @typedef {(a: number) => Result} ToResult */
+/** @typedef {(codePoint: number) => Result} ToResult */
 
 /**
  * @template T
@@ -25,10 +25,10 @@ const { toArray, map } = list
  */
 
 /** @type {ToResult} */
-const unknownSymbol = a => [[`unknown symbol ${a}`], unknownSymbol]
+const unexpectedSymbol = codePoint => [[`unexpected symbol ${codePoint}`], unexpectedSymbol]
 
-/** @type {<T>(a: T) => ToResult} */
-const def = () => unknownSymbol
+/** @type {<T>(state: T) => ToResult} */
+const def = () => unexpectedSymbol
 
 /** @type {<T>(a: CreateToResult<T>) => (b: CreateToResult<T>) => CreateToResult<T>} */
 const union = a => b => {
@@ -77,42 +77,46 @@ const create = a => {
 
 const terminal = -1
 
+/** @type {() => ToResult} */
+const toInit = () => () => [[], init]
+
 const init = create([
-    codePointRange(one(terminal))(() => () => [[], unknownSymbol]),
-    rangeSet(['\t', ' '])(() => () => [[' '], unknownSymbol]),
-    rangeSet(['\n', '\r'])(() => () => [['\n'], unknownSymbol]),
-    range('!')(() => () => [['!'], unknownSymbol]),
-    range('"')(() => () => [['"'], unknownSymbol]),
-    rangeSet(['$', '_', 'AZ', 'az'])(() => c => [[fromCharCode(c)], unknownSymbol]),
-    range('%')(() => () => [['%'], unknownSymbol]),
-    range('&')(() => () => [['&'], unknownSymbol]),
-    range("'")(() => () => [["'"], unknownSymbol]),
-    range('(')(() => () => [['('], unknownSymbol]),
-    range(')')(() => () => [[')'], unknownSymbol]),
-    range('*')(() => () => [['*'], unknownSymbol]),
-    range('+')(() => () => [['+'], unknownSymbol]),
-    range(',')(() => () => [[','], unknownSymbol]),
-    range('-')(() => () => [['-'], unknownSymbol]),
-    range('.')(() => () => [['.'], unknownSymbol]),
-    range('/')(() => () => [['/'], unknownSymbol]),
-    range('09')(() => a => [[fromCharCode(a)], unknownSymbol]),
-    range(':')(() => () => [[':'], unknownSymbol]),
-    range(';')(() => () => [[';'], unknownSymbol]),
-    range('<')(() => () => [['<'], unknownSymbol]),
-    range('=')(() => () => [['='], unknownSymbol]),
-    range('>')(() => () => [['>'], unknownSymbol]),
-    range('?')(() => () => [['?'], unknownSymbol]),
-    range('[')(() => () => [['['], unknownSymbol]),
-    range(']')(() => () => [[']'], unknownSymbol]),
-    range('^')(() => () => [['^'], unknownSymbol]),
-    range('`')(() => () => [['`'], unknownSymbol]),
-    range('{')(() => () => [['{'], unknownSymbol]),
-    range('|')(() => () => [['|'], unknownSymbol]),
-    range('}')(() => () => [['}'], unknownSymbol]),
-    range('~')(() => () => [['~'], unknownSymbol]),
-])
+    codePointRange(one(terminal))(toInit),
+    rangeSet(['\t', ' ', '\n', '\r'])(toInit),
+    range('!')(() => () => [['!'], unexpectedSymbol]),
+    range('"')(() => () => [['"'], unexpectedSymbol]),
+    rangeSet(['$', '_', 'AZ', 'az'])(() => c => [[fromCharCode(c)], unexpectedSymbol]),
+    range('%')(() => () => [['%'], unexpectedSymbol]),
+    range('&')(() => () => [['&'], unexpectedSymbol]),
+    range("'")(() => () => [["'"], unexpectedSymbol]),
+    range('(')(() => () => [['('], unexpectedSymbol]),
+    range(')')(() => () => [[')'], unexpectedSymbol]),
+    range('*')(() => () => [['*'], unexpectedSymbol]),
+    range('+')(() => () => [['+'], unexpectedSymbol]),
+    range(',')(() => () => [[','], unexpectedSymbol]),
+    range('-')(() => () => [['-'], unexpectedSymbol]),
+    range('.')(() => () => [['.'], unexpectedSymbol]),
+    range('/')(() => () => [['/'], unexpectedSymbol]),
+    range('09')(() => a => [[fromCharCode(a)], unexpectedSymbol]),
+    range(':')(() => () => [[':'], unexpectedSymbol]),
+    range(';')(() => () => [[';'], unexpectedSymbol]),
+    range('<')(() => () => [['<'], unexpectedSymbol]),
+    range('=')(() => () => [['='], unexpectedSymbol]),
+    range('>')(() => () => [['>'], unexpectedSymbol]),
+    range('?')(() => () => [['?'], unexpectedSymbol]),
+    range('[')(() => () => [['['], unexpectedSymbol]),
+    range(']')(() => () => [[']'], unexpectedSymbol]),
+    range('^')(() => () => [['^'], unexpectedSymbol]),
+    range('`')(() => () => [['`'], unexpectedSymbol]),
+    range('{')(() => () => [['{'], unexpectedSymbol]),
+    range('|')(() => () => [['|'], unexpectedSymbol]),
+    range('}')(() => () => [['}'], unexpectedSymbol]),
+    range('~')(() => () => [['~'], unexpectedSymbol]),
+])(void 0)
 
 module.exports = {
+    /** @readonly */
+    terminal,
     /** @readonly */
     init,
 }

package/fsc/test.f.cjs

@@ -6,7 +6,7 @@ const s = stringify(i => i)
 /** @type {(v: string) => string} */
 const f = v => {
     const n = one(v)
-    return s(_.init(null)(n)[0])
+    return s(_.init(n)[0])
 }
 
 module.exports = {

package/json/parser/module.f.cjs

@@ -0,0 +1,235 @@
+const result = require('../../types/result/module.f.cjs')
+const list = require('../../types/list/module.f.cjs')
+const { fold, isEmpty, 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')
+const { entries, setReplace } = map
+
+
+/**
+ * @typedef {{
+* readonly kind: 'object'
+* readonly values: map.Map<any>
+* readonly key: string
+* }} JsonObject
+* */
+
+/**
+ * @typedef {{
+* readonly kind: 'array'
+* readonly values: list.List<any>
+* }} JsonArray
+* */
+
+/**
+ * @typedef {|
+* JsonObject |
+* JsonArray
+* } JsonStackElement
+*/
+
+/** @typedef {list.List<JsonStackElement>} JsonStack */
+
+/**
+ * @typedef {{
+*  readonly status: '' | '[' | '[v' | '[,' | '{' | '{k' | '{:' | '{v' | '{,'
+*  readonly top: JsonStackElement | null
+*  readonly stack: JsonStack
+* }} StateParse
+*/
+
+/**
+ * @typedef {{
+*  readonly status: 'result'
+*  readonly value: any
+* }} StateResult
+*/
+
+/**
+ * @typedef {{
+*  readonly status: 'error'
+*  readonly message: string
+* }} StateError
+*/
+
+/**
+ * @typedef {|
+* StateParse |
+* StateResult |
+* StateError
+* } JsonState
+*/
+
+/** @type {(obj: JsonObject) => (key: string) => JsonObject} */
+const addKeyToObject = obj => key => ({ kind: 'object', values: obj.values, key: key })
+
+/** @type {(obj: JsonObject) => (value: any) => JsonObject} */
+const addValueToObject = obj => value => ({ kind: 'object', values: setReplace(obj.key)(value)(obj.values), key: '' })
+
+/** @type {(array: JsonArray) => (value: any) => JsonArray} */
+const addToArray = array => value => ({ kind: 'array', values: list.concat(array.values)([value]) })
+
+/** @type {(state: StateParse) => (key: string) => JsonState} */
+const pushKey = state => value => {
+    if (state.top?.kind === 'object') { return { status: '{k', top: addKeyToObject(state.top)(value), stack: state.stack } }
+    return { status: 'error', message: 'error' }
+}
+
+/** @type {(state: StateParse) => (value: any) => 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 } }
+    return { status: '{v', top: addValueToObject(state.top)(value), stack: state.stack }
+}
+
+/** @type {(state: StateParse) => JsonState} */
+const startArray = state => {
+    const newStack = state.top === null ? null : { first: state.top, tail: state.stack }
+    return { status: '[', top: { kind: 'array', values: null }, stack: newStack }
+}
+
+/** @type {(state: StateParse) => JsonState} */
+const endArray = state => {
+    const array = state.top !== null ? toArray(state.top.values) : null
+    /** @type {StateParse} */
+    const newState = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) }
+    return pushValue(newState)(array)
+}
+
+/** @type {(state: StateParse) => JsonState} */
+const startObject = state => {
+    const newStack = state.top === null ? null : { first: state.top, tail: state.stack }
+    return { status: '{', top: { kind: 'object', values: null, key: '' }, stack: newStack }
+}
+
+/** @type {operator.Fold<map.Entry<any>, any>} */
+const foldToObjectOp = ([k, v]) => obj => { return { ...obj, [k] : v } }
+
+/** @type {(m: map.Map<any>) => any} */
+const toObject = m => {
+    const e = entries(m)
+    return fold(foldToObjectOp)({})(e)
+}
+
+/** @type {(state: StateParse) => JsonState} */
+const endObject = state => {
+    const obj = state.top?.kind === 'object' ? toObject(state.top.values) : null
+    /** @type {StateParse} */
+    const newState = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) }
+    return pushValue(newState)(obj)
+}
+
+/** @type {(token: tokenizer.JsonToken) => any} */
+const tokenToValue = token => {
+    switch(token.kind) {
+        case 'null': return null
+        case 'false': return false
+        case 'true': return true
+        case 'number': return Number(token.value)
+        case 'string': return token.value
+        default: return null
+    }
+}
+
+/** @type {(token: tokenizer.JsonToken) => boolean} */
+const isValueToken = token => {
+    switch(token.kind) {
+        case 'null':
+        case 'false':
+        case 'true':
+        case 'number':
+        case 'string': return true
+        default: return false
+    }
+}
+
+/** @type {(token: tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+const parseValueOp = token => state => {
+    if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
+    if (token.kind === '[') { return startArray(state) }
+    if (token.kind === '{') { return startObject(state) }
+    return { status: 'error', message: 'unexpected token' }
+}
+
+/** @type {(token: tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+const parseArrayStartOp = token => state => {
+    if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
+    if (token.kind === '[') { return startArray(state) }
+    if (token.kind === ']') { return endArray(state) }
+    if (token.kind === '{') { return startObject(state) }
+    return { status: 'error', message: 'unexpected token' }
+}
+
+/** @type {(token: tokenizer.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}} */
+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}} */
+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}} */
+const parseObjectColonOp = token => state => {
+    if (isValueToken(token)) { return pushValue(state)(tokenToValue(token)) }
+    if (token.kind === '[') { return startArray(state) }
+    if (token.kind === '{') { return startObject(state) }
+    return { status: 'error', message: 'unexpected token' }
+}
+
+/** @type {(token: tokenizer.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}} */
+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>} */
+const foldOp = token => state => {
+    switch(state.status) {
+        case 'result': return { status: 'error', message: 'unexpected token' }
+        case 'error': return { status: 'error', message: state.message }
+        case '': return parseValueOp(token)(state)
+        case '[': return parseArrayStartOp(token)(state)
+        case '[v': return parseArrayValueOp(token)(state)
+        case '[,': return parseValueOp(token)(state)
+        case '{' : return parseObjectStartOp(token)(state)
+        case '{k' : return parseObjectKeyOp(token)(state)
+        case '{:' : return parseObjectColonOp(token)(state)
+        case '{v' : return parseObjectNextOp(token)(state)
+        case '{,' : return parseObjectCommaOp(token)(state)
+    }
+}
+
+/** @type {(tokenList: list.List<tokenizer.JsonToken>) => result.Result<any, string>} */
+const parse = tokenList => {
+    const state = fold(foldOp)({ status: '', top: null, stack: null })(tokenList)
+    switch(state.status) {
+        case 'result': return result.ok(state.value)
+        case 'error': return result.error(state.message)
+        default: return result.error('unexpected end')
+    }
+}
+
+module.exports = {
+    /** @readonly */
+    parse
+}

package/json/parser/test.f.cjs

@@ -0,0 +1,240 @@
+const parser = require('./module.f.cjs')
+const tokenizer = require('../tokenizer/module.f.cjs')
+const { toArray } = require('../../types/list/module.f.cjs')
+const json = require('../module.f.cjs')
+const { sort } = require('../../types/object/module.f.cjs')
+const encoding = require('../../text/utf16/module.f.cjs');
+
+/** @type {(s: string) => readonly tokenizer.JsonToken[]} */
+const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)))
+
+const stringify = json.stringify(sort)
+
+module.exports = {
+    valud: [
+        () => {
+            const tokenList = tokenizeString('null')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",null]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('true')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",true]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('false')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",false]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('0.1')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",0.1]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('1.1e+2')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",110]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('"abc"')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok","abc"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('[]')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",[]]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('[1]')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",[1]]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('[[]]')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",[[]]]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('[0,[1,[2,[]]],3]')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",[0,[1,[2,[]]],3]]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{}')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",{}]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('[{}]')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",[{}]]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{"a":true,"b":false,"c":null}')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",{"a":true,"b":false,"c":null}]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{"a":{"b":{"c":["d"]}}}')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["ok",{"a":{"b":{"c":["d"]}}}]') { throw result }
+        },
+    ],
+    invalid: [
+        () => {
+            const tokenList = tokenizeString('')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected end"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('"123')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('[,]')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('[1 2]')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('[1,,2]')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('[]]')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('["a"')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected end"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('[1,]')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('[,1]')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('[:]')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString(']')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{,}')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{1:2}')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{"1"2}')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{"1"::2}')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{"1":2,,"3":4')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{}}')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{"1":2')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected end"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{"1":2,}')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{,"1":2}')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('}')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('[{]}')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+        () => {
+            const tokenList = tokenizeString('{[}]')
+            const obj = parser.parse(tokenList)
+            const result = stringify(obj)
+            if (result !== '["error","unexpected token"]') { throw result }
+        },
+    ]
+}

package/json/tokenizer/module.f.cjs

@@ -84,7 +84,7 @@ const rangeSetWhiteSpace = [
     one(space)
 ]
 
-const rangeSetTerminalForNumer = [
+const rangeSetTerminalForNumber = [
     one(ht),
     one(lf),
     one(cr),
@@ -134,15 +134,22 @@ const rangeCapitalAF = range('AF')
 
 /** @typedef {{ readonly kind: 'escapeChar', readonly value: string}} ParseEscapeCharState */
 
-/** @typedef {{ readonly kind: 'unicodeChar', readonly value: string, readonly unicode: number, readonly hexIndex: number}} ParseUnicodeCharState */
+/**
+ * @typedef {{
+ *  readonly kind: 'unicodeChar'
+ *  readonly value: string
+ *  readonly unicode: number
+ *  readonly hexIndex: number
+ * }} ParseUnicodeCharState
+ */
 
 /**
- *  @typedef {{
- * readonly kind: 'number',
- * readonly numberKind: '0' | '-' | 'int' | '.' | 'fractional' | 'e' | 'e+' | 'e-' | 'expDigits'
- * readonly value: string
+ * @typedef {{
+ *  readonly kind: 'number',
+ *  readonly numberKind: '0' | '-' | 'int' | '.' | 'fractional' | 'e' | 'e+' | 'e-' | 'expDigits'
+ *  readonly value: string
  * }} ParseNumberState
- *  */
+ */
 
 /** @typedef {{ readonly kind: 'invalidNumber'}} InvalidNumberState */
 
@@ -323,12 +330,12 @@ const parseNumberStateOp = create(invalidNumberToToken)([
     rangeSetFunc([one(latinSmallLetterE), one(latinCapitalLetterE)])(expToToken),
     rangeFunc(one(hyphenMinus))(hyphenMinusToToken),
     rangeFunc(one(plusSign))(plusSignToToken),
-    rangeSetFunc(rangeSetTerminalForNumer)(terminalToToken)
+    rangeSetFunc(rangeSetTerminalForNumber)(terminalToToken)
 ])
 
 /** @type {(state: InvalidNumberState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
 const invalidNumberStateOp = create(() => () => [empty, { kind: 'invalidNumber' }])([
-    rangeSetFunc(rangeSetTerminalForNumer)(() => input => {
+    rangeSetFunc(rangeSetTerminalForNumber)(() => input => {
         const next = tokenizeOp({ kind: 'initial' })(input)
         return [{ first: { kind: 'error', message: 'invalid number' }, tail: next[0] }, next[1]]
     })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.497",
+  "version": "0.0.499",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {
@@ -30,7 +30,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^18.11.15",
+    "@types/node": "^18.11.18",
     "typescript": "^4.9.4"
   }
 }