functionalscript 0.0.504 → 0.0.506

package/fjson/README.md

@@ -0,0 +1,8 @@
+# FJSON, FJS Object Notation
+
+- additional types: bigint
+
+## Rules
+
+- can serialize/deserialize without reading source code
+  - no function serialization/deserialization

package/fjson/module.f.cjs

@@ -0,0 +1,111 @@
+const list = require('../types/list/module.f.cjs')
+const { next, flat, reduce, map, empty } = list
+const { concat } = require('../types/string/module.f.cjs')
+const object = require('../types/object/module.f.cjs')
+const { at } = object
+const operator = require('../types/function/operator/module.f.cjs')
+const { compose, fn } = require('../types/function/module.f.cjs')
+const { entries } = Object
+const { serialize: bigintSerialize } = require('../types/bigint/module.f.cjs')
+
+/**
+ * @typedef {{
+ *  readonly [k in string]: Unknown
+ * }} Object
+ */
+
+/** @typedef {readonly Unknown[]} Array */
+
+/** @typedef {Object|boolean|string|number|null|Array|bigint} Unknown */
+
+const jsonStringify = JSON.stringify
+
+/** @type {(_: string) => list.List<string>} */
+const stringSerialize = input => [jsonStringify(input)]
+
+/** @type {(_: number) => list.List<string>} */
+const numberSerialize = input => [jsonStringify(input)]
+
+const nullSerialize = ['null']
+
+const trueSerialize = ['true']
+
+const falseSerialize = ['false']
+
+/** @type {(_: boolean) => list.List<string>} */
+const boolSerialize = value => value ? trueSerialize : falseSerialize
+
+const colon = [':']
+const comma = [',']
+
+/** @type {operator.Reduce<list.List<string>>} */
+const joinOp = b => prior => flat([prior, comma, b])
+
+/** @type {(input: list.List<list.List<string>>) => list.List<string>} */
+const join = reduce(joinOp)(empty)
+
+/** @type {(open: string) => (close: string) => (input: list.List<list.List<string>>) => list.List<string>} */
+const wrap = open => close => {
+    const seqOpen = [open]
+    const seqClose = [close]
+    return input => flat([seqOpen, join(input), seqClose])
+}
+
+const objectWrap = wrap('{')('}')
+
+const arrayWrap = wrap('[')(']')
+
+/** @typedef {object.Entry<Unknown>} Entry*/
+
+/** @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>} */
+    const propertySerialize = ([k, v]) => flat([
+        stringSerialize(k),
+        colon,
+        f(v)
+    ])
+    const mapPropertySerialize = map(propertySerialize)
+    /** @type {(object: Object) => list.List<string>} */
+    const objectSerialize = fn(entries)
+        .then(sort)
+        .then(mapPropertySerialize)
+        .then(objectWrap)
+        .result
+    /** @type {(value: Unknown) => list.List<string>} */
+    const f = value => {
+        switch (typeof value) {
+            case 'boolean': { return boolSerialize(value) }
+            case 'number': { return numberSerialize(value) }
+            case 'string': { return stringSerialize(value) }
+            case 'bigint': { return [bigintSerialize(value)] }
+            default: {
+                if (value === null) { return nullSerialize }
+                if (value instanceof Array) { return arraySerialize(value) }
+                return objectSerialize(value)
+            }
+        }
+    }
+    const arraySerialize = compose(map(f))(arrayWrap)
+    return f
+}
+
+/**
+ * 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}
+ */
+const stringify = sort => compose(serialize(sort))(concat)
+
+module.exports = {
+
+    /** @readonly */
+    stringify,
+    /** @readonly */
+    serialize,
+}

package/fjson/test.f.cjs

@@ -0,0 +1,65 @@
+const json = require('../json/module.f.cjs')
+const { sort } = require('../types/object/module.f.cjs')
+const { identity } = require('../types/function/module.f.cjs')
+const fjson= require('./module.f.cjs')
+
+module.exports = {
+    stringify: [
+        {
+            sort: () => {
+                const r = json.setProperty("Hello")(['a'])({})
+                const x = fjson.stringify(sort)(r)
+                if (x !== '{"a":"Hello"}') { throw x }
+            },
+            identity: () => {
+                const x = fjson.stringify(identity)(json.setProperty("Hello")(['a'])({}))
+                if (x !== '{"a":"Hello"}') { throw x }
+            },
+        },
+        {
+            sort: () => {
+                const x = fjson.stringify(sort)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }))
+                if (x !== '{"a":"Hello","b":12,"c":[]}') { throw x }
+            },
+            identity: () => {
+                const x = fjson.stringify(identity)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }))
+                if (x !== '{"c":[],"b":12,"a":"Hello"}') { throw x }
+            },
+        },
+        {
+            sort: () => {
+                const _0 = { a: { y: [24] }, c: [], b: 12 }
+                const _1 = json.setProperty("Hello")(['a', 'x'])(_0)
+                const _2 = fjson.stringify(sort)(_1)
+                if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') { throw _2 }
+            },
+            identity: () => {
+                const _0 = { a: { y: [24] }, c: [], b: 12 }
+                const _1 = json.setProperty("Hello")(['a', 'x'])(_0)
+                const _2 = fjson.stringify(identity)(_1)
+                if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') { throw _2 }
+            }
+        },
+        {
+            stringify: () => {
+                const bi = 1234567890n
+                const result = fjson.stringify(sort)(bi)
+                if (result !== '1234567890n') { throw result }
+            }
+        },
+        {
+            stringify: () => {
+                const arr = [0n, 1, 2n]
+                const result = fjson.stringify(sort)(arr)
+                if (result !== '[0n,1,2n]') { throw result }
+            }
+        },
+        {
+            stringify: () => {
+                const obj = {"a": 0n, "b": 1, "c": 2n}
+                const result = fjson.stringify(sort)(obj)
+                if (result !== '{"a":0n,"b":1,"c":2n}') { throw result }
+            }
+        }
+    ]
+}

package/json/tokenizer/module.f.cjs

@@ -5,6 +5,7 @@ const list = require('../../types/list/module.f.cjs')
 const _range = require('../../types/range/module.f.cjs')
 const { one } = _range
 const { empty, stateScan, flat, toArray, reduce: listReduce, scan } = list
+const bigfloat = require('../../types/bigfloat/module.f.cjs')
 const { fromCharCode } = String
 const {
     range,
@@ -59,6 +60,7 @@ const {
  * @typedef {{
  * readonly kind: 'number'
  * readonly value: string
+ * readonly bf: bigfloat.BigFloat
  * }} NumberToken
  * */
 
@@ -148,9 +150,20 @@ const rangeCapitalAF = range('AF')
  *  readonly kind: 'number',
  *  readonly numberKind: '0' | '-' | 'int' | '.' | 'fractional' | 'e' | 'e+' | 'e-' | 'expDigits'
  *  readonly value: string
+ *  readonly b: ParseNumberBuffer
  * }} ParseNumberState
  */
 
+/**
+ * @typedef {{
+*  readonly s: -1n | 1n
+*  readonly m: bigint
+*  readonly f: number
+*  readonly es: -1 | 1
+*  readonly e: number
+* }} ParseNumberBuffer
+*/
+
 /** @typedef {{ readonly kind: 'invalidNumber'}} InvalidNumberState */
 
 /** @typedef {{ readonly kind: 'eof'}} EofState */
@@ -222,9 +235,30 @@ const create = def => a => {
     return v => c => x(c)(i)(v)(c)
 }
 
+/** @type {(digit: number) => bigint} */
+const digitToBigInt = d => BigInt(d - digit0)
+
+/** @type {(digit: number) => ParseNumberBuffer} */
+const startNumber = digit => ({ s: 1n, m: digitToBigInt(digit), f: 0, es: 1, e: 0 })
+
+/** @type {ParseNumberBuffer} */
+const startNegativeNumber = { s: -1n, m: 0n, f: 0, es: 1, e: 0 }
+
+/** @type {(digit: number) => (b: ParseNumberBuffer) => ParseNumberBuffer} */
+const addIntDigit = digit => b => ({ ... b, m: b.m * 10n + digitToBigInt(digit)})
+
+/** @type {(digit: number) => (b: ParseNumberBuffer) => ParseNumberBuffer} */
+const addFracDigit = digit => b => ({ ... b, m: b.m * 10n + digitToBigInt(digit), f: b.f - 1})
+
+/** @type {(digit: number) => (b: ParseNumberBuffer) => ParseNumberBuffer} */
+const addExpDigit = digit => b =>  ({ ... b, e: b.e * 10 + digit - digit0})
+
+/** @type {(s: ParseNumberState) => NumberToken} */
+const bufferToNumberToken = ({value, b}) => ({ kind: 'number', value: value, bf: [b.s * b.m, b.f + b.es * b.e] })
+
 /** @type {(state: InitialState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
 const initialStateOp = create(state => () => [[{ kind: 'error', message: 'unexpected character' }], state])([
-    rangeFunc(rangeOneNine)(() => input => [empty, { kind: 'number', value: fromCharCode(input), numberKind: 'int' }]),
+    rangeFunc(rangeOneNine)(() => input => [empty, { kind: 'number', value: fromCharCode(input), b: startNumber(input), numberKind: 'int' }]),
     rangeFunc(latinSmallLetterRange)(() => input => [empty, { kind: 'keyword', value: fromCharCode(input) }]),
     rangeSetFunc(rangeSetWhiteSpace)(state => () => [empty, state]),
     rangeFunc(one(leftCurlyBracket))(state => () => [[{ kind: '{' }], state]),
@@ -234,8 +268,8 @@ const initialStateOp = create(state => () => [[{ kind: 'error', message: 'unexpe
     rangeFunc(one(leftSquareBracket))(state => () => [[{ kind: '[' }], state]),
     rangeFunc(one(rightSquareBracket))(state => () => [[{ kind: ']' }], state]),
     rangeFunc(one(quotationMark))(() => () => [empty, { kind: 'string', value: '' }]),
-    rangeFunc(one(digit0))(() => input => [empty, { kind: 'number', value: fromCharCode(input), numberKind: '0' }]),
-    rangeFunc(one(hyphenMinus))(() => input => [empty, { kind: 'number', value: fromCharCode(input), numberKind: '-' }])
+    rangeFunc(one(digit0))(() => input => [empty, { kind: 'number', value: fromCharCode(input), b: startNumber(input), numberKind: '0' }]),
+    rangeFunc(one(hyphenMinus))(() => input => [empty, { kind: 'number', value: fromCharCode(input), b: startNegativeNumber, numberKind: '-' }])
 ])
 
 /** @type {() => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
@@ -245,7 +279,7 @@ const invalidNumberToToken = () => input => tokenizeOp({ kind: 'invalidNumber' }
 const fullStopToToken = state => input => {
     switch (state.numberKind) {
         case '0':
-        case 'int': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: '.' }]
+        case 'int': return [empty, { kind: 'number', value: appendChar(state.value)(input), b: state.b, numberKind: '.' }]
         default: return tokenizeOp({ kind: 'invalidNumber' })(input)
     }
 }
@@ -254,12 +288,14 @@ const fullStopToToken = state => input => {
 const digit0ToToken = state => input => {
     switch (state.numberKind) {
         case '0': return tokenizeOp({ kind: 'invalidNumber' })(input)
-        case '-': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: '0' }]
-        case '.': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'fractional' }]
+        case '-': return [empty, { kind: 'number', value: appendChar(state.value)(input), b: state.b, numberKind: '0' }]
+        case '.':
+        case 'fractional': return [empty, { kind: 'number', value: appendChar(state.value)(input), b: addFracDigit(input)(state.b), numberKind: 'fractional' }]
         case 'e':
         case 'e+':
-        case 'e-': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'expDigits' }]
-        default: return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: state.numberKind }]
+        case 'e-':
+        case 'expDigits': return [empty, { kind: 'number', value: appendChar(state.value)(input), b: addExpDigit(input)(state.b), numberKind: 'expDigits' }]
+        default: return [empty, { kind: 'number', value: appendChar(state.value)(input), b: addIntDigit(input)(state.b), numberKind: state.numberKind }]
     }
 }
 
@@ -267,12 +303,13 @@ const digit0ToToken = state => input => {
 const digit19ToToken = state => input => {
     switch (state.numberKind) {
         case '0': return tokenizeOp({ kind: 'invalidNumber' })(input)
-        case '-': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'int' }]
-        case '.': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'fractional' }]
+        case '.':
+        case 'fractional': return [empty, { kind: 'number', value: appendChar(state.value)(input), b: addFracDigit(input)(state.b), numberKind: 'fractional' }]
         case 'e':
         case 'e+':
-        case 'e-': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'expDigits' }]
-        default: return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: state.numberKind }]
+        case 'e-':
+        case 'expDigits': return [empty, { kind: 'number', value: appendChar(state.value)(input), b: addExpDigit(input)(state.b), numberKind: 'expDigits' }]
+        default: return [empty, { kind: 'number', value: appendChar(state.value)(input), b: addIntDigit(input)(state.b), numberKind: 'int' }]
     }
 }
 
@@ -281,7 +318,7 @@ const expToToken = state => input => {
     switch (state.numberKind) {
         case '0':
         case 'int':
-        case 'fractional': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e' }]
+        case 'fractional': return [empty, { kind: 'number', value: appendChar(state.value)(input), b: state.b, numberKind: 'e' }]
         default: return tokenizeOp({ kind: 'invalidNumber' })(input)
     }
 }
@@ -289,7 +326,7 @@ const expToToken = state => input => {
 /** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
 const hyphenMinusToToken = state => input => {
     switch (state.numberKind) {
-        case 'e': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e-' }]
+        case 'e': return [empty, { kind: 'number', value: appendChar(state.value)(input), b: { ... state.b, es: -1}, numberKind: 'e-' }]
         default: return tokenizeOp({ kind: 'invalidNumber' })(input)
     }
 }
@@ -297,7 +334,7 @@ const hyphenMinusToToken = state => input => {
 /** @type {(state: ParseNumberState) => (input: number) => readonly[list.List<JsonToken>, TokenizerState]} */
 const plusSignToToken = state => input => {
     switch (state.numberKind) {
-        case 'e': return [empty, { kind: 'number', value: appendChar(state.value)(input), numberKind: 'e+' }]
+        case 'e': return [empty, { kind: 'number', value: appendChar(state.value)(input), b: state.b, numberKind: 'e+' }]
         default: return tokenizeOp({ kind: 'invalidNumber' })(input)
     }
 }
@@ -317,7 +354,7 @@ const terminalToToken = state => input => {
         default:
             {
                 const next = tokenizeOp({ kind: 'initial' })(input)
-                return [{ first: { kind: 'number', value: state.value }, tail: next[0] }, next[1]]
+                return [{ first: bufferToNumberToken(state), tail: next[0] }, next[1]]
             }
     }
 }
@@ -441,7 +478,7 @@ const tokenizeEofOp = state => {
                 case 'e':
                 case 'e+':
                 case 'e-': return [[{ kind: 'error', message: 'invalid number' }], { kind: 'invalidNumber', }]
-                default: return [[{ kind: 'number', value: state.value }], { kind: 'eof' }]
+                default: return [[bufferToNumberToken(state)], { kind: 'eof' }]
             }
         case 'eof': return [[{ kind: 'error', message: 'eof' }], state]
     }

package/json/tokenizer/test.f.cjs

@@ -1,13 +1,13 @@
 const tokenizer = require('./module.f.cjs')
 const { toArray, countdown } = require('../../types/list/module.f.cjs')
-const json = require('../module.f.cjs')
+const fjson = require('../../fjson/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)
+const stringify = fjson.stringify(sort)
 
 module.exports = {
     testing: [
@@ -133,11 +133,11 @@ module.exports = {
         },
         () => {
             const result = stringify(tokenizeString('0'))
-            if (result !== '[{"kind":"number","value":"0"}]') { throw result }
+            if (result !== '[{"bf":[0n,0],"kind":"number","value":"0"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('[0]'))
-            if (result !== '[{"kind":"["},{"kind":"number","value":"0"},{"kind":"]"}]') { throw result }
+            if (result !== '[{"kind":"["},{"bf":[0n,0],"kind":"number","value":"0"},{"kind":"]"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('00'))
@@ -148,20 +148,20 @@ module.exports = {
             if (result !== '[{"kind":"error","message":"invalid number"},{"kind":","}]') { throw result }
         },
         () => {
-            const result = stringify(tokenizeString('1234567890'))
-            if (result !== '[{"kind":"number","value":"1234567890"}]') { throw result }
+            const result = stringify(tokenizeString('123456789012345678901234567890'))
+            if (result !== '[{"bf":[123456789012345678901234567890n,0],"kind":"number","value":"123456789012345678901234567890"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('{90}'))
-            if (result !== '[{"kind":"{"},{"kind":"number","value":"90"},{"kind":"}"}]') { throw result }
+            if (result !== '[{"kind":"{"},{"bf":[90n,0],"kind":"number","value":"90"},{"kind":"}"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('1 2'))
-            if (result !== '[{"kind":"number","value":"1"},{"kind":"number","value":"2"}]') { throw result }
+            if (result !== '[{"bf":[1n,0],"kind":"number","value":"1"},{"bf":[2n,0],"kind":"number","value":"2"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('0. 2'))
-            if (result !== '[{"kind":"error","message":"invalid number"},{"kind":"number","value":"2"}]') { throw result }
+            if (result !== '[{"kind":"error","message":"invalid number"},{"bf":[2n,0],"kind":"number","value":"2"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('10-0'))
@@ -173,11 +173,11 @@ module.exports = {
         },
         () => {
             const result = stringify(tokenizeString('-10'))
-            if (result !== '[{"kind":"number","value":"-10"}]') { throw result }
+            if (result !== '[{"bf":[-10n,0],"kind":"number","value":"-10"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-0'))
-            if (result !== '[{"kind":"number","value":"-0"}]') { throw result }
+            if (result !== '[{"bf":[0n,0],"kind":"number","value":"-0"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-00'))
@@ -189,11 +189,11 @@ module.exports = {
         },
         () => {
             const result = stringify(tokenizeString('0.01'))
-            if (result !== '[{"kind":"number","value":"0.01"}]') { throw result }
+            if (result !== '[{"bf":[1n,-2],"kind":"number","value":"0.01"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-0.9'))
-            if (result !== '[{"kind":"number","value":"-0.9"}]') { throw result }
+            if (result !== '[{"bf":[-9n,-1],"kind":"number","value":"-0.9"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-0.'))
@@ -205,11 +205,11 @@ module.exports = {
         },
         () => {
             const result = stringify(tokenizeString('12.34'))
-            if (result !== '[{"kind":"number","value":"12.34"}]') { throw result }
+            if (result !== '[{"bf":[1234n,-2],"kind":"number","value":"12.34"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-12.00'))
-            if (result !== '[{"kind":"number","value":"-12.00"}]') { throw result }
+            if (result !== '[{"bf":[-1200n,-2],"kind":"number","value":"-12.00"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-12.'))
@@ -221,23 +221,27 @@ module.exports = {
         },
         () => {
             const result = stringify(tokenizeString('0e1'))
-            if (result !== '[{"kind":"number","value":"0e1"}]') { throw result }
+            if (result !== '[{"bf":[0n,1],"kind":"number","value":"0e1"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('0e+2'))
-            if (result !== '[{"kind":"number","value":"0e+2"}]') { throw result }
+            if (result !== '[{"bf":[0n,2],"kind":"number","value":"0e+2"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('0e-0'))
-            if (result !== '[{"kind":"number","value":"0e-0"}]') { throw result }
+            if (result !== '[{"bf":[0n,0],"kind":"number","value":"0e-0"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('12e0000'))
-            if (result !== '[{"kind":"number","value":"12e0000"}]') { throw result }
+            if (result !== '[{"bf":[12n,0],"kind":"number","value":"12e0000"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('-12e-0001'))
-            if (result !== '[{"kind":"number","value":"-12e-0001"}]') { throw result }
+            if (result !== '[{"bf":[-12n,-1],"kind":"number","value":"-12e-0001"}]') { throw result }
+        },
+        () => {
+            const result = stringify(tokenizeString('-12.34e1234'))
+            if (result !== '[{"bf":[-1234n,1232],"kind":"number","value":"-12.34e1234"}]') { throw result }
         },
         () => {
             const result = stringify(tokenizeString('0e'))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.504",
+  "version": "0.0.506",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {

package/types/bigint/module.f.cjs

@@ -13,6 +13,9 @@ const abs = a => a >= 0 ? a : -a
 /** @type {(a: bigint) => compare.Sign} */
 const sign = a => unsafeCmp(a)(0n)
 
+/** @type {(a: bigint) => string} */
+const serialize = a => `${a}n`
+
 module.exports = {
     /** @readonly */
     addition,
@@ -22,4 +25,6 @@ module.exports = {
     abs,
     /** @readonly */
     sign,
+    /** @readonly */
+    serialize,
 }

package/types/bigint/test.f.cjs

@@ -1,4 +1,4 @@
-const { sum, abs } = require('./module.f.cjs')
+const { sum, abs, serialize } = require('./module.f.cjs')
 
 module.exports = {
     sum: () => {
@@ -14,5 +14,19 @@ module.exports = {
             const result = abs(-10n)
             if (result !== 10n) { throw result }
         }
+    ],
+    serialize: [
+        () => {
+            const result = serialize(0n)
+            if (result !== '0n') { throw result }
+        },
+        () => {
+            const result = serialize(123456789012345678901234567890n)
+            if (result !== '123456789012345678901234567890n') { throw result }
+        },
+        () => {
+            const result = serialize(-55555n)
+            if (result !== '-55555n') { throw result }
+        },
     ]
 }