functionalscript 0.0.404 → 0.0.407

package/doc/LANGUAGE.md

@@ -1,5 +1,9 @@
 # FunctionalScript Programming Language
 
+Principals:
+- FunctionalScript VM should behaves the same way as a JavaScript VM
+- Any unsupported feature should be reported at compile-time.
+
 ## 1. Module Ecosystem
 
 FunctionalScript uses [CommonJS](https://en.wikipedia.org/wiki/CommonJS) conventions as a module ecosystem. For example,

package/html/module.f.cjs

@@ -3,8 +3,8 @@ const { map, flatMap, flat, concat: listConcat } = list
 const { concat: stringConcat } = require('../types/string/module.f.cjs')
 const object = require('../types/object/module.f.cjs')
 const { compose } = require('../types/function/module.f.cjs')
-const encoding = require('../text/encoding/module.f.cjs');
-const { stringToUtf16List } = encoding
+const encoding = require('../text/utf16/module.f.cjs');
+const { stringToList } = encoding
 
 const { fromCharCode } = String
 const { entries } = Object
@@ -80,7 +80,7 @@ const escapeCharCode = code => {
     }
 }
 
-const escape = compose(stringToUtf16List)(map(escapeCharCode))
+const escape = compose(stringToList)(map(escapeCharCode))
 
 /** @type {(n: Node) => list.List<string>} */
 const node = n => typeof n === 'string' ? escape(n) : element(n)

package/json/tokenizer/test.f.cjs

@@ -2,10 +2,10 @@ const tokenizer = require('./module.f.cjs')
 const list = require('../../types/list/module.f.cjs')
 const json = require('../module.f.cjs')
 const { sort } = require('../../types/object/module.f.cjs')
-const encoding = require('../../text/encoding/module.f.cjs');
+const encoding = require('../../text/utf16/module.f.cjs');
 
 /** @type {(s: string) => readonly tokenizer.JsonToken[]} */
-const tokenizeString = s => list.toArray(tokenizer.tokenize(encoding.stringToUtf16List(s)))
+const tokenizeString = s => list.toArray(tokenizer.tokenize(encoding.stringToList(s)))
 
 const stringify = json.stringify(sort)
 

package/package.json

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

package/sha2/module.f.cjs

@@ -74,41 +74,41 @@ const smallSigma0 = smallSigma(7)(18)(3)
 const smallSigma1 = smallSigma(17)(19)(10)
 
 /** @type {(a: array.Array4<number>) => number} */
-const wi = a => (smallSigma1(a[0]) + a[1] + smallSigma0(a[2]) + a[3]) | 0
-
-/** @type {(input: Array16) => Array16} */
-const nextW = w => {
-    const _0 = wi([w[14], w[ 9], w[ 1], w[ 0]])
-    const _1 = wi([w[15], w[10], w[ 2], w[ 1]])
-    const _2 = wi([   _0, w[11], w[ 3], w[ 2]])
-    const _3 = wi([   _1, w[12], w[ 4], w[ 3]])
-    const _4 = wi([   _2, w[13], w[ 5], w[ 4]])
-    const _5 = wi([   _3, w[14], w[ 6], w[ 5]])
-    const _6 = wi([   _4, w[15], w[ 7], w[ 6]])
-    const _7 = wi([   _5,    _0, w[ 8], w[ 7]])
-    const _8 = wi([   _6,    _1, w[ 9], w[ 8]])
-    const _9 = wi([   _7,    _2, w[10], w[ 9]])
-    const _A = wi([   _8,    _3, w[11], w[10]])
-    const _B = wi([   _9,    _4, w[12], w[11]])
-    const _C = wi([   _A,    _5, w[13], w[12]])
-    const _D = wi([   _B,    _6, w[14], w[13]])
-    const _E = wi([   _C,    _7, w[15], w[14]])
-    const _F = wi([   _D,    _8,    _0, w[15]])
-    return [_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _A, _B, _C, _D, _E, _F]
+const wi = ([a0, a1, a2, a3]) => (smallSigma1(a0) + a1 + smallSigma0(a2) + a3) | 0
+
+/** @type {(w: Array16) => Array16} */
+const nextW = ([w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, wA, wB, wC, wD, wE, wF]) => {
+    w0 = wi([wE, w9, w1, w0])
+    w1 = wi([wF, wA, w2, w1])
+    w2 = wi([w0, wB, w3, w2])
+    w3 = wi([w1, wC, w4, w3])
+    w4 = wi([w2, wD, w5, w4])
+    w5 = wi([w3, wE, w6, w5])
+    w6 = wi([w4, wF, w7, w6])
+    w7 = wi([w5, w0, w8, w7])
+    w8 = wi([w6, w1, w9, w8])
+    w9 = wi([w7, w2, wA, w9])
+    wA = wi([w8, w3, wB, wA])
+    wB = wi([w9, w4, wC, wB])
+    wC = wi([wA, w5, wD, wC])
+    wD = wi([wB, w6, wE, wD])
+    wE = wi([wC, w7, wF, wE])
+    wF = wi([wD, w8, w0, wF])
+    return [w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, wA, wB, wC, wD, wE, wF]
 }
 
 /** @type {(init: Hash8) => (data: Array16) => Hash8} */
-const compress = init => data => {
+const compress = ([a0, b0, c0, d0, e0, f0, g0, h0]) => data => {
     let w = data
 
-    let a = init[0]
-    let b = init[1]
-    let c = init[2]
-    let d = init[3]
-    let e = init[4]
-    let f = init[5]
-    let g = init[6]
-    let h = init[7]
+    let a = a0
+    let b = b0
+    let c = c0
+    let d = d0
+    let e = e0
+    let f = f0
+    let g = g0
+    let h = h0
 
     for (let i = 0; i < 4; ++i) {
         const ki = k[i]
@@ -128,14 +128,14 @@ const compress = init => data => {
     }
 
     return [
-        (init[0] + a) | 0,
-        (init[1] + b) | 0,
-        (init[2] + c) | 0,
-        (init[3] + d) | 0,
-        (init[4] + e) | 0,
-        (init[5] + f) | 0,
-        (init[6] + g) | 0,
-        (init[7] + h) | 0,
+        (a0 + a) | 0,
+        (b0 + b) | 0,
+        (c0 + c) | 0,
+        (d0 + d) | 0,
+        (e0 + e) | 0,
+        (f0 + f) | 0,
+        (g0 + g) | 0,
+        (h0 + h) | 0,
     ]
 }
 

package/test.f.cjs

@@ -22,7 +22,8 @@ require('./commonjs/build/test.f.cjs')
 require('./types/range/test.f.cjs')
 require('./html/test.f.cjs')
 require('./text/test.f.cjs')
-require('./text/encoding/test.f.cjs')
+require('./text/utf8/test.f.cjs')
+require('./text/utf16/test.f.cjs')
 require('./com/cs/test.f.cjs')
 require('./com/cpp/test.f.cjs')
 require('./nodejs/version/test.f.cjs')

package/text/{encoding/README.md → README.md}

@@ -34,12 +34,14 @@ Total error states:
 - 34_432
 - < 2^16
 
+### utf8/module.f.cjs
+
 ```js
 /** @type {(input: List<u8|undefined>) => List<i32>} */
-const utf8ToCodePoint
+const toCodePointList
 
 /** @type {(input: List<i32>) => List<u8>} */
-const codePointToUtf8
+const fromCodePointList
 ```
 
 ## UTF-16
@@ -67,18 +69,20 @@ Requirement: no loss for UTF16 => codepoint => UTF16
 
 Total error states: 11 bit
 
+### utf16/module.f.cjs
+
 ```js
 /** @type {(input: List<u16|undefined>) => List<i32>} */
-const utf16ListToCodePointList
+const toCodePointList
 
 /** @type {(input: List<i32>) => List<u16>} */
-const codePointListToUtf16List
+const fromCodePointList
 
 /** @type {(input: string) => List<u16>} */
-const stringToUtf16List
+const stringToList
 
 /** @type {(input: List<u16>) => string} */
-const utf16ListToString
+const listToString
 ```
 
 UTF-16 => CP => UTF-8 => CP = UTF-16

package/text/utf16/module.f.cjs

@@ -0,0 +1,90 @@
+const list = require('../../types/list/module.f.cjs')
+const operator = require('../../types/function/operator/module.f.cjs')
+const array = require('../../types/array/module.f.cjs')
+const { contains } = require('../../types/range/module.f.cjs')
+const { compose } = require('../../types/function/module.f.cjs')
+const { map, flat, stateScan, concat, reduce, flatMap } = list
+
+/** @typedef {u16|undefined} WordOrEof */
+
+/** @typedef {undefined|number} Utf16State */
+
+/** @typedef {number} u16 */
+
+/** @typedef {number} i32 */
+
+/** @type {(a:number) => boolean} */
+const isBmpCodePoint = a => a >= 0x0000 && a <= 0xd7ff || a >= 0xe000 && a <= 0xffff
+
+const isHighSurrogate = contains([0xd800, 0xdbff])
+
+/** @type {(a:number) => boolean} */
+const isLowSurrogate = contains([0xdc00, 0xdfff])
+
+const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
+
+/** @type {(input:i32) => list.List<u16>} */
+const codePointToUtf16 = input =>
+{
+    if (isBmpCodePoint(input)) { return [input] }
+    if (input >= 0x010000 && input <= 0x10ffff) {
+        const high = ((input - 0x10000) >> 10) + 0xd800
+        const low = ((input - 0x10000) & 0b0011_1111_1111) + 0xdc00
+        return [high, low]
+    }
+    return [input & 0xffff]
+}
+
+const fromCodePointList = flatMap(codePointToUtf16)
+
+/** @type {operator.StateScan<u16, Utf16State, list.List<i32>>} */
+const utf16ByteToCodePointOp = state => byte => {
+    if (byte < 0x00 || byte > 0xffff) {
+        return [[0xffffffff], state]
+    }
+    if (state === undefined) {
+        if (isBmpCodePoint(byte)) { return [[byte], undefined] }
+        if (isHighSurrogate(byte)) { return [[], byte] }
+        return [[byte | errorMask], undefined]
+    }
+    if (isLowSurrogate(byte)) {
+        const high = state - 0xd800
+        const low = byte - 0xdc00
+        return [[(high << 10) + low + 0x10000], undefined]
+    }
+    if (isBmpCodePoint(byte)) { return [[state | errorMask, byte], undefined] }
+    if (isHighSurrogate(byte)) { return [[state | errorMask], byte] }
+    return [[state | errorMask, byte | errorMask], undefined]
+}
+
+/** @type {(state: Utf16State) => readonly[list.List<i32>, Utf16State]} */
+const utf16EofToCodePointOp = state => [state === undefined ? undefined : [state | errorMask],  undefined]
+
+/** @type {operator.StateScan<WordOrEof, Utf16State, list.List<i32>>} */
+const utf16ByteOrEofToCodePointOp = state => input => input === undefined ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input)
+
+/** @type {(input: list.List<u16>) => list.List<i32>} */
+const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(undefined)(concat(/** @type {list.List<WordOrEof>} */(input))([undefined])))
+
+/** @type {(s: string) => list.List<u16>} */
+const stringToList = s => {
+    /** @type {(i: number) => list.Result<number>} */
+    const at = i => {
+        const first = s.charCodeAt(i)
+        return isNaN(first) ? undefined : { first, tail: () => at(i + 1) }
+    }
+    return at(0)
+}
+
+const listToString = compose(map(String.fromCharCode))(reduce(operator.concat)(''))
+
+module.exports = {
+    /** @readonly */
+    fromCodePointList,
+    /** @readonly */
+    toCodePointList,
+    /** @readonly */
+    stringToList,
+    /** @readonly */
+    listToString
+}

package/text/utf16/test.f.cjs

@@ -0,0 +1,118 @@
+const encoding = require('./module.f.cjs')
+const json = require('../../json/module.f.cjs')
+const { sort } = require('../../types/object/module.f.cjs')
+const { list } = require('../../types/module.f.cjs')
+
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = a => json.stringify(sort)(a)
+
+{
+    const result = stringify(list.toArray(encoding.toCodePointList([-1, 65536])))
+    if (result !== '[4294967295,4294967295]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.toCodePointList([0, 36, 8364, 55295, 57344, 65535])))
+    if (result !== '[0,36,8364,55295,57344,65535]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.toCodePointList([56320, 57343])))
+    if (result !== '[-2147427328,-2147426305]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.toCodePointList([55296, 56320, 55297, 56375, 55378, 57186, 56319, 57343])))
+    if (result !== '[65536,66615,150370,1114111]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.toCodePointList([55296, 55296])))
+    if (result !== '[-2147428352,-2147428352]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.toCodePointList([55296, 0])))
+    if (result !== '[-2147428352,0]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.toCodePointList([56320])))
+    if (result !== '[-2147427328]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.toCodePointList([56320, 0])))
+    if (result !== '[-2147427328,0]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0])))
+    if (result !== '[0]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0x24])))
+    if (result !== '[36]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0x20AC])))
+    if (result !== '[8364]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0xd7ff])))
+    if (result !== '[55295]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0xe000])))
+    if (result !== '[57344]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0xffff])))
+    if (result !== '[65535]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0x10000])))
+    if (result !== '[55296,56320]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0x10437])))
+    if (result !== '[55297,56375]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0x24B62])))
+    if (result !== '[55378,57186]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0x10ffff])))
+    if (result !== '[56319,57343]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([-1, 0xd800, 0xdfff, 0x110000])))
+    if (result !== '[65535,55296,57343,0]') { throw result }
+}
+
+{
+    const utf16List = encoding.stringToList("Hello world!😂🚜🚲")
+    const result = encoding.listToString(utf16List)
+    if (result !== "Hello world!😂🚜🚲") { throw result }
+}
+
+{
+    const a = encoding.stringToList("Hello world!😂🚜🚲")
+    const b = encoding.toCodePointList(a)
+    const c = encoding.fromCodePointList(b)
+    const result = encoding.listToString(c)
+    if (result !== "Hello world!😂🚜🚲") { throw result }
+}
+
+module.exports = {}

package/text/utf8/module.f.cjs

@@ -0,0 +1,96 @@
+const list = require('../../types/list/module.f.cjs')
+const operator = require('../../types/function/operator/module.f.cjs')
+const array = require('../../types/array/module.f.cjs')
+const { flatMap } = list
+
+/** @typedef {u8|undefined} ByteOrEof */
+
+/** @typedef {array.Array1<number>|array.Array2<number>|array.Array3<number>} Utf8NonEmptyState */
+
+/** @typedef {undefined|Utf8NonEmptyState} Utf8State */
+
+/** @typedef {number} u8 */
+
+/** @typedef {number} i32 */
+
+const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
+
+/** @type {(input:number) => list.List<u8>} */
+const codePointToUtf8 = input =>
+{
+    if (input >= 0x0000 && input <= 0x007f) { return [input & 0b01111_1111] }
+    if (input >= 0x0080 && input <= 0x07ff) { return [input >> 6 | 0b1100_0000, input & 0b0011_1111 | 0b1000_0000] }
+    if (input >= 0x0800 && input <= 0xffff) { return [input >> 12 | 0b1110_0000, input >> 6 & 0b0011_1111 | 0b1000_0000, input & 0b0011_1111 | 0b1000_0000] }
+    if (input >= 0x10000 && input <= 0x10ffff) { return [input >> 18 | 0b1111_0000, input >> 12 & 0b0011_1111 | 0b1000_0000, input >> 6 & 0b0011_1111 | 0b1000_0000, input & 0b0011_1111 | 0b1000_0000] }
+    if ((input & errorMask) !== 0) {
+        if ((input & 0b1000_0000_0000_0000) !== 0) { return [input >> 12 & 0b0000_0111 | 0b1111_0000, input >> 6 & 0b0011_1111 | 0b1000_0000, input & 0b0011_1111 | 0b1000_0000] }
+        if ((input & 0b0000_0100_0000_0000) !== 0) { return [input >> 6 & 0b0000_1111 | 0b1110_0000, input & 0b0011_1111 | 0b1000_0000] }
+        if ((input & 0b0000_0010_0000_0000) !== 0) { return [input >> 6 & 0b0000_0111 | 0b1111_0000, input & 0b0011_1111 | 0b1000_0000] }
+        if ((input & 0b0000_0000_1000_0000) !== 0) { return [input & 0b1111_1111] }
+    }
+    return [errorMask]
+}
+
+const fromCodePointList = flatMap(codePointToUtf8)
+
+/** @type {(state: Utf8NonEmptyState) => i32}*/
+const utf8StateToError = state => {
+    switch(state.length) {
+        case 1:
+             return state[0] | errorMask
+        case 2:
+            if (state[0] < 0b1111_0000) return (((state[0] & 0b0000_1111) << 6) + (state[1] & 0b0011_1111) + 0b0000_0100_0000_0000) | errorMask
+            return (((state[0] & 0b0000_0111) << 6) + (state[1] & 0b0011_1111) + 0b0000_0010_0000_0000) | errorMask
+        case 3:
+            return (((state[0] & 0b0000_0111) << 12) + ((state[1] & 0b0011_1111) << 6) + (state[2] & 0b0011_1111) + 0b1000_0000_0000_0000) | errorMask
+    }
+}
+
+/** @type {operator.StateScan<number, Utf8State, list.List<i32>>} */
+const utf8ByteToCodePointOp = state => byte => {
+    if (byte < 0x00 || byte > 0xff) {
+        return [[errorMask], state]
+    }
+    if (state == undefined) {
+        if (byte < 0b1000_0000) { return [[byte], undefined] }
+        if (byte >= 0b1100_0010 && byte <= 0b1111_0100) { return [[], [byte]] }
+        return [[byte | errorMask], undefined]
+    }
+    if (byte >= 0b1000_0000 && byte < 0b1100_0000) {
+        switch(state.length) {
+            case 1:
+                if (state[0] < 0b1110_0000) { return [[((state[0] & 0b0001_1111) << 6) + (byte & 0b0011_1111)], undefined] }
+                if (state[0] < 0b1111_1000) { return [[], [state[0], byte]] }
+                break
+            case 2:
+                if (state[0] < 0b1111_0000) { return [[((state[0] & 0b0000_1111) << 12) + ((state[1] & 0b0011_1111) << 6) + (byte & 0b0011_1111)], undefined] }
+                if (state[0] < 0b1111_1000) { return [[], [state[0], state[1], byte]] }
+                break
+            case 3:
+                return [[((state[0] & 0b0000_0111) << 18) + ((state[1] & 0b0011_1111) << 12) + ((state[2] & 0b0011_1111) << 6) + (byte & 0b0011_1111)], undefined]
+        }
+    }
+    const error = utf8StateToError(state)
+    if (byte < 0b1000_0000) { return [[error, byte], undefined] }
+    if (byte >= 0b1100_0010 && byte <= 0b1111_0100) { return [[error], [byte]] }
+    return [[error, byte | errorMask], undefined]
+}
+
+/** @type {(state: Utf8State) => readonly[list.List<i32>, Utf8State]} */
+const utf8EofToCodePointOp = state => {
+    if (state === undefined) { return [undefined, undefined] }
+    return [[utf8StateToError(state)], undefined]
+}
+
+/** @type {operator.StateScan<ByteOrEof, Utf8State, list.List<i32>>} */
+const utf8ByteOrEofToCodePointOp = state => input => input === undefined ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
+
+/** @type {(input: list.List<u8>) => list.List<i32>} */
+const toCodePointList = input => list.flat(list.stateScan(utf8ByteOrEofToCodePointOp)(undefined)(list.concat(/** @type {list.List<ByteOrEof>} */(input))([undefined])))
+
+module.exports = {
+    /** @readonly */
+    fromCodePointList,
+    /** @readonly */
+    toCodePointList
+}

package/text/utf8/test.f.cjs

@@ -0,0 +1,144 @@
+const encoding = require('./module.f.cjs')
+const json = require('../../json/module.f.cjs')
+const { sort } = require('../../types/object/module.f.cjs')
+const { list } = require('../../types/module.f.cjs')
+
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = a => json.stringify(sort)(a)
+
+{
+    const result = stringify(list.toArray(encoding.toCodePointList([-1, 256])))
+    if (result !== '[2147483648,2147483648]') { throw result }
+}
+
+{
+   const result = stringify(list.toArray(encoding.toCodePointList([128, 193, 245, 255])))
+   if (result !== '[-2147483520,-2147483455,-2147483403,-2147483393]') { throw result }
+}
+
+{
+   const result = stringify(list.toArray(encoding.toCodePointList([0, 1, 127])))
+   if (result !== '[0,1,127]') { throw result }
+}
+
+{
+   const result = stringify(list.toArray(encoding.toCodePointList([194, 128, 194, 169, 223, 191])))
+   if (result !== '[128,169,2047]') { throw result }
+}
+
+{
+   const result = stringify(list.toArray(encoding.toCodePointList([194, 194, 127, 194, 192, 194])))
+   if (result !== '[-2147483454,-2147483454,127,-2147483454,-2147483456,-2147483454]') { throw result }
+}
+
+{
+   const result = stringify(list.toArray(encoding.toCodePointList([224, 160, 128, 224, 160, 129, 239, 191, 191])))
+   if (result !== '[2048,2049,65535]') { throw result }
+}
+
+{
+   const result = stringify(list.toArray(encoding.toCodePointList([224, 224, 160, 127, 239, 191])))
+   if (result !== '[-2147483424,-2147482592,127,-2147481601]') { throw result }
+}
+
+{
+   const result = stringify(list.toArray(encoding.toCodePointList([240, 144, 128, 128, 240, 144, 128, 129, 244, 143, 191, 191])))
+   if (result !== '[65536,65537,1114111]') { throw result }
+}
+
+{
+   const result = stringify(list.toArray(encoding.toCodePointList([240, 240, 160, 127, 244, 191])))
+   if (result !== '[-2147483408,-2147483104,127,-2147482817]') { throw result }
+}
+
+{
+   const result = stringify(list.toArray(encoding.toCodePointList([240, 160, 160, 244, 160, 160])))
+   if (result !== '[-2147448800,-2147432416]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0,1,0x7F])))
+    if (result !== '[0,1,127]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0x80])))
+    if (result !== '[194,128]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0xa9])))
+    if (result !== '[194,169]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0x7ff])))
+    if (result !== '[223,191]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0x800])))
+    if (result !== '[224,160,128]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0x801])))
+    if (result !== '[224,160,129]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0xffff])))
+    if (result !== '[239,191,191]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0x10000])))
+    if (result !== '[240,144,128,128]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0x10001])))
+    if (result !== '[240,144,128,129]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0x10FFFF])))
+    if (result !== '[244,143,191,191]') { throw result }
+}
+
+{
+    const result = stringify(list.toArray(encoding.fromCodePointList([0x110000,2147483648])))
+    if (result !== '[2147483648,2147483648]') { throw result }
+}
+
+{
+    const codePointList = encoding.toCodePointList([128, 193, 245, 255])
+    const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)))
+    if (result !== '[128,193,245,255]') { throw result }
+}
+
+{
+    const codePointList = encoding.toCodePointList([194, 194, 127, 194, 192, 194])
+    const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)))
+    if (result !== '[194,194,127,194,192,194]') { throw result }
+}
+
+{
+    const codePointList = encoding.toCodePointList([224, 224, 160, 127, 239, 191])
+    const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)))
+    if (result !== '[224,224,160,127,239,191]') { throw result }
+}
+
+{
+    const codePointList = encoding.toCodePointList([240, 240, 160, 127, 244, 191])
+    const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)))
+    if (result !== '[240,240,160,127,244,191]') { throw result }
+}
+
+{
+    const codePointList = encoding.toCodePointList([240, 160, 160, 244, 160, 160])
+    const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)))
+    if (result !== '[240,160,160,244,160,160]') { throw result }
+}
+
+module.exports = {}

package/text/encoding/module.f.cjs

@@ -1,154 +0,0 @@
-const result = require('../../types/result/module.f.cjs')
-const list = require('../../types/list/module.f.cjs')
-const operator = require('../../types/function/operator/module.f.cjs')
-const array = require('../../types/array/module.f.cjs')
-const { contains } = require('../../types/range/module.f.cjs')
-const { compose } = require('../../types/function/module.f.cjs')
-const { map, flat, stateScan, concat, reduce, toArray, flatMap } = list
-const { ok, error } = result
-
-/** @typedef {result.Result<number,number>} ByteResult */
-
-/** @typedef {result.Result<number,readonly number[]>} CodePointResult */
-
-/** @typedef {number|undefined} ByteOrEof */
-
-/** @typedef {u16|undefined} WordOrEof */
-
-/** @typedef {undefined|array.Array1<number>|array.Array2<number>|array.Array3<number>} Utf8State */
-
-/** @typedef {undefined|number} Utf16State */
-
-/** @typedef {number} u16 */
-
-/** @typedef {number} i32 */
-
-/** @type {(a:number) => boolean} */
-const isBmpCodePoint = a => a >= 0x0000 && a <= 0xd7ff || a >= 0xe000 && a <= 0xffff
-
-const isHighSurrogate = contains([0xd800, 0xdbff])
-
-/** @type {(a:number) => boolean} */
-const isLowSurrogate = contains([0xdc00, 0xdfff])
-
-const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000
-
-/** @type {(input:number) => list.List<ByteResult>} */
-const codePointToUtf8 = input =>
-{
-    if (input >= 0x0000 && input <= 0x007f) { return [ok(input & 0x7f)] }
-    if (input >= 0x0080 && input <= 0x07ff) { return [ok(input >> 6 | 0xc0), ok(input & 0x3f | 0x80)] }
-    if (input >= 0x0800 && input <= 0xffff) { return [ok(input >> 12 | 0xe0), ok(input >> 6 & 0x3f | 0x80), ok(input & 0x3f | 0x80)] }
-    if (input >= 0x10000 && input <= 0x10ffff) { return [ok(input >> 18 | 0xf0), ok(input >> 12 & 0x3f | 0x80), ok(input >> 6 & 0x3f | 0x80), ok(input & 0x3f | 0x80)] }
-    return [error(input)]
-}
-
-/** @type {(input:i32) => list.List<u16>} */
-const codePointToUtf16 = input =>
-{
-    if (isBmpCodePoint(input)) { return [input] }
-    if (input >= 0x010000 && input <= 0x10ffff) {
-        const high = ((input - 0x10000) >> 10) + 0xd800
-        const low = ((input - 0x10000) & 0b0011_1111_1111) + 0xdc00
-        return [high, low]
-    }
-    return [input & 0xffff]
-}
-
-const codePointListToUtf8List = flatMap(codePointToUtf8)
-
-const codePointListToUtf16List = flatMap(codePointToUtf16)
-
-/** @type {operator.StateScan<number, Utf8State, list.List<CodePointResult>>} */
-const utf8ByteToCodePointOp = state => byte => {
-    if (byte < 0x00 || byte > 0xff) {
-        return [[error([byte])], state]
-    }
-    if (state == undefined) {
-        if (byte < 0x80) { return [[ok(byte)], undefined] }
-        if (byte >= 0xc2 && byte <= 0xf4) { return [[], [byte]] }
-        return [[error([byte])], undefined]
-    }
-    if (byte >= 0x80 && byte < 0xc0)
-    {
-        switch(state.length)
-        {
-            case 1:
-                if (state[0] < 0xe0) { return [[ok(((state[0] & 0x1f) << 6) + (byte & 0x3f))], undefined] }
-                if (state[0] < 0xf8) { return [[], [state[0], byte]] }
-                break
-            case 2:
-                if (state[0] < 0xf0) { return [[ok(((state[0] & 0x0f) << 12) + ((state[1] & 0x3f) << 6) + (byte & 0x3f))], undefined] }
-                if (state[0] < 0xf8) { return [[], [state[0], state[1], byte]] }
-                break
-            case 3:
-                return [[ok(((state[0] & 0x07) << 18) + ((state[1] & 0x3f) << 12) + ((state[2] & 0x3f) << 6) + (byte & 0x3f))], undefined]
-        }
-    }
-    return [[error(toArray(concat(state)([byte])))], undefined]
-}
-
-/** @type {(state: Utf8State) => readonly[list.List<CodePointResult>, Utf8State]} */
-const utf8EofToCodePointOp = state => [state === undefined ? undefined : [error(state)],  undefined]
-
-/** @type {operator.StateScan<ByteOrEof, Utf8State, list.List<CodePointResult>>} */
-const utf8ByteOrEofToCodePointOp = state => input => input === undefined ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input)
-
-/** @type {(input: list.List<number>) => list.List<CodePointResult>} */
-const utf8ListToCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(undefined)(concat(/** @type {list.List<ByteOrEof>} */(input))([undefined])))
-
-/** @type {operator.StateScan<u16, Utf16State, list.List<i32>>} */
-const utf16ByteToCodePointOp = state => byte => {
-    if (byte < 0x00 || byte > 0xffff) {
-        return [[0xffffffff], state]
-    }
-    if (state === undefined) {
-        if (isBmpCodePoint(byte)) { return [[byte], undefined] }
-        if (isHighSurrogate(byte)) { return [[], byte] }
-        return [[byte | errorMask], undefined]
-    }
-    if (isLowSurrogate(byte)) {
-        const high = state - 0xd800
-        const low = byte - 0xdc00
-        return [[(high << 10) + low + 0x10000], undefined]
-    }
-    if (isBmpCodePoint(byte)) { return [[state | errorMask, byte], undefined] }
-    if (isHighSurrogate(byte)) { return [[state | errorMask], byte] }
-    return [[state | errorMask, byte | errorMask], undefined]
-}
-
-/** @type {(state: Utf16State) => readonly[list.List<i32>, Utf16State]} */
-const utf16EofToCodePointOp = state => [state === undefined ? undefined : [state | errorMask],  undefined]
-
-/** @type {operator.StateScan<WordOrEof, Utf16State, list.List<i32>>} */
-const utf16ByteOrEofToCodePointOp = state => input => input === undefined ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input)
-
-/** @type {(input: list.List<u16>) => list.List<i32>} */
-const utf16ListToCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(undefined)(concat(/** @type {list.List<WordOrEof>} */(input))([undefined])))
-
-/** @type {(s: string) => list.List<u16>} */
-const stringToUtf16List = s => {
-    /** @type {(i: number) => list.Result<number>} */
-    const at = i => {
-        const first = s.charCodeAt(i)
-        return isNaN(first) ? undefined : { first, tail: () => at(i + 1) }
-    }
-    return at(0)
-}
-
-const utf16ListToString = compose(map(String.fromCharCode))(reduce(operator.concat)(''))
-
-module.exports = {
-    /** @readonly */
-    codePointListToUtf8List,
-    /** @readonly */
-    codePointListToUtf16List,
-    /** @readonly */
-    utf8ListToCodePointList,
-    /** @readonly */
-    utf16ListToCodePointList,
-    /** @readonly */
-    stringToUtf16List,
-    /** @readonly */
-    utf16ListToString
-}

package/text/encoding/test.f.cjs

@@ -1,223 +0,0 @@
-const encoding = require('./module.f.cjs')
-const json = require('../../json/module.f.cjs')
-const { sort } = require('../../types/object/module.f.cjs')
-const { list } = require('../../types/module.f.cjs')
-
-/** @type {(a: readonly json.Unknown[]) => string} */
-const stringify = a => json.stringify(sort)(a)
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0,1,0x7F])))
-    if (result !== '[["ok",0],["ok",1],["ok",127]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0x80])))
-    if (result !== '[["ok",194],["ok",128]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0xa9])))
-    if (result !== '[["ok",194],["ok",169]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0x7ff])))
-    if (result !== '[["ok",223],["ok",191]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0x800])))
-    if (result !== '[["ok",224],["ok",160],["ok",128]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0x801])))
-    if (result !== '[["ok",224],["ok",160],["ok",129]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0xffff])))
-    if (result !== '[["ok",239],["ok",191],["ok",191]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0x10000])))
-    if (result !== '[["ok",240],["ok",144],["ok",128],["ok",128]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0x10001])))
-    if (result !== '[["ok",240],["ok",144],["ok",128],["ok",129]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf8List([0x10FFFF])))
-    if (result !== '[["ok",244],["ok",143],["ok",191],["ok",191]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf8List([-1,0x110000])))
-    if (result !== '[["error",-1],["error",1114112]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0])))
-    if (result !== '[0]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0x24])))
-    if (result !== '[36]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0x20AC])))
-    if (result !== '[8364]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0xd7ff])))
-    if (result !== '[55295]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0xe000])))
-    if (result !== '[57344]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0xffff])))
-    if (result !== '[65535]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0x10000])))
-    if (result !== '[55296,56320]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0x10437])))
-    if (result !== '[55297,56375]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0x24B62])))
-    if (result !== '[55378,57186]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf16List([0x10ffff])))
-    if (result !== '[56319,57343]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.codePointListToUtf16List([-1, 0xd800, 0xdfff, 0x110000])))
-    if (result !== '[65535,55296,57343,0]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([-1, 256])))
-    if (result !== '[["error",[-1]],["error",[256]]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([128, 193, 245, 255])))
-    if (result !== '[["error",[128]],["error",[193]],["error",[245]],["error",[255]]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([0, 1, 127])))
-    if (result !== '[["ok",0],["ok",1],["ok",127]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([194, 128, 194, 169, 223, 191])))
-    if (result !== '[["ok",128],["ok",169],["ok",2047]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([194, 127, 194, 192, 194])))
-    if (result !== '[["error",[194,127]],["error",[194,192]],["error",[194]]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([224, 160, 128, 224, 160, 129, 239, 191, 191])))
-    if (result !== '[["ok",2048],["ok",2049],["ok",65535]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([224, 160, 127, 224, 160, 192, 224, 160])))
-    if (result !== '[["error",[224,160,127]],["error",[224,160,192]],["error",[224,160]]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([240, 144, 128, 128, 240, 144, 128, 129, 244, 143, 191, 191])))
-    if (result !== '[["ok",65536],["ok",65537],["ok",1114111]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([240, 144, 128, 127, 240, 144, 128, 192, 240, 144, 128])))
-    if (result !== '[["error",[240,144,128,127]],["error",[240,144,128,192]],["error",[240,144,128]]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf8ListToCodePointList([194, -1, 128])))
-    if (result !== '[["error",[-1]],["ok",128]]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([-1, 65536])))
-    if (result !== '[4294967295,4294967295]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([0, 36, 8364, 55295, 57344, 65535])))
-    if (result !== '[0,36,8364,55295,57344,65535]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([56320, 57343])))
-    if (result !== '[-2147427328,-2147426305]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([55296, 56320, 55297, 56375, 55378, 57186, 56319, 57343])))
-    if (result !== '[65536,66615,150370,1114111]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([55296, 55296])))
-    if (result !== '[-2147428352,-2147428352]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([55296, 0])))
-    if (result !== '[-2147428352,0]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([56320])))
-    if (result !== '[-2147427328]') { throw result }
-}
-
-{
-    const result = stringify(list.toArray(encoding.utf16ListToCodePointList([56320, 0])))
-    if (result !== '[-2147427328,0]') { throw result }
-}
-
-{
-    const utf16List = encoding.stringToUtf16List("Hello world!😂🚜🚲")
-    const result = encoding.utf16ListToString(utf16List)
-    if (result !== "Hello world!😂🚜🚲") { throw result }
-}
-
-{
-    const a = encoding.stringToUtf16List("Hello world!😂🚜🚲")
-    const b = encoding.utf16ListToCodePointList(a)
-    const c = encoding.codePointListToUtf16List(b)
-    const result = encoding.utf16ListToString(c)
-    if (result !== "Hello world!😂🚜🚲") { throw result }
-}
-
-module.exports = {}