functionalscript 0.3.7 → 0.3.8

package/dev/test.f.js

@@ -1,7 +1,3 @@
-const assert = () => { throw 'assert'; };
-const assert_if = c => { if (c) {
-    throw 'assert_if';
-} };
 export default {
     ctor: () => {
         const c = (() => { })['constructor'];

package/djs/module.f.d.ts

@@ -1,5 +1,5 @@
 import * as list from '../types/list/module.f.ts';
-import * as O from '../types/object/module.f.ts';
+import type * as O from '../types/object/module.f.ts';
 type Object = {
     readonly [k in string]: Unknown;
 };

package/djs/module.f.js

@@ -2,7 +2,6 @@ import * as list from "../types/list/module.f.js";
 const { flat, map } = list;
 import * as string from "../types/string/module.f.js";
 const { concat } = string;
-import * as O from "../types/object/module.f.js";
 import * as f from "../types/function/module.f.js";
 const { compose, fn } = f;
 const { entries } = Object;

package/djs/parser/module.f.d.ts

@@ -1,6 +1,6 @@
 import * as result from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
-import * as tokenizerT from '../tokenizer/module.f.ts';
+import type * as tokenizerT from '../tokenizer/module.f.ts';
 export type DjsModule = [readonly string[], readonly DjsConst[]];
 export type DjsConst = boolean | string | number | null | bigint | undefined | DjsModuleRef | DjsArray | DjsObject;
 type DjsModuleRef = ['aref' | 'cref', number];

package/djs/parser/module.f.js

@@ -1,7 +1,5 @@
 import * as result from "../../types/result/module.f.js";
 import { fold, first, drop, toArray, length, concat } from "../../types/list/module.f.js";
-import * as Operator from "../../types/function/operator/module.f.js";
-import * as tokenizerT from "../tokenizer/module.f.js";
 import { setReplace, at } from "../../types/map/module.f.js";
 import * as o from "../../types/object/module.f.js";
 const { fromMap } = o;

package/djs/serializer/module.f.d.ts

@@ -1,6 +1,6 @@
 import * as list from '../../types/list/module.f.ts';
-import * as O from '../../types/object/module.f.ts';
-import * as DjsParser from '../parser/module.f.ts';
+import type * as O from '../../types/object/module.f.ts';
+import type * as DjsParser from '../parser/module.f.ts';
 export declare const undefinedSerialize: string[];
 type Entry = O.Entry<DjsParser.DjsConst>;
 type Entries = list.List<Entry>;

package/djs/serializer/module.f.js

@@ -2,7 +2,6 @@ import * as list from "../../types/list/module.f.js";
 const { flat, map, entries: listEntries, concat: listConcat, flatMap } = list;
 import * as string from "../../types/string/module.f.js";
 const { concat } = string;
-import * as O from "../../types/object/module.f.js";
 import * as f from "../../types/function/module.f.js";
 const { compose, fn } = f;
 const { entries } = Object;
@@ -10,7 +9,6 @@ import * as bi from "../../types/bigint/module.f.js";
 const { serialize: bigintSerialize } = bi;
 import * as j from "../../json/serializer/module.f.js";
 const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = j;
-import * as DjsParser from "../parser/module.f.js";
 const colon = [':'];
 export const undefinedSerialize = ['undefined'];
 const djsConstSerialize = sort => {

package/djs/tokenizer/module.f.js

@@ -1,4 +1,3 @@
-import * as Operator from "../../types/function/operator/module.f.js";
 import * as list from "../../types/list/module.f.js";
 const { empty, flat, stateScan } = list;
 import * as bf from "../../types/bigfloat/module.f.js";

package/fsc/test.f.js

@@ -4,7 +4,6 @@ const { one } = ascii;
 import * as j from "../json/module.f.js";
 const { stringify } = j;
 const s = stringify(i => i);
-/** @type {} */
 const f = v => {
     const n = one(v);
     return s(_.init(n)[0]);

package/js/tokenizer/module.f.d.ts

@@ -81,6 +81,6 @@ export type CommentToken = {
 };
 export type JsToken = KeywordToken | TrueToken | FalseToken | NullToken | WhitespaceToken | NewLineToken | StringToken | NumberToken | ErrorToken | IdToken | BigIntToken | UndefinedToken | OperatorToken | CommentToken;
 type ErrorMessage = '" are missing' | 'unescaped character' | 'invalid hex value' | 'unexpected character' | 'invalid number' | 'invalid token' | '*\/ expected' | 'unterminated string literal' | 'eof';
-export declare const isKeywordToken: (token: JsToken) => Boolean;
+export declare const isKeywordToken: (token: JsToken) => boolean;
 export declare const tokenize: (input: list.List<number>) => list.List<JsToken>;
 export {};

package/js/tokenizer/module.f.js

@@ -485,8 +485,8 @@ const tokenizeEofOp = state => {
                 case 'e':
                 case 'e+':
                 case 'e-': return [[{ kind: 'error', message: 'invalid number' }], { kind: 'eof', }];
-                default: return [[bufferToNumberToken(state)], { kind: 'eof' }];
             }
+            return [[bufferToNumberToken(state)], { kind: 'eof' }];
         case 'op': return [[getOperatorToken(state.value)], { kind: 'eof' }];
         case '//': return [[{ kind: '//', value: state.value }], { kind: 'eof' }];
         case '/*':

package/json/parser/module.f.d.ts

@@ -1,5 +1,5 @@
 import * as result from '../../types/result/module.f.ts';
 import * as list from '../../types/list/module.f.ts';
-import * as Tokenizer from '../tokenizer/module.f.ts';
-import * as Json from '../module.f.ts';
+import type * as Tokenizer from '../tokenizer/module.f.ts';
+import type * as Json from '../module.f.ts';
 export declare const parse: (tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>;

package/json/parser/module.f.js

@@ -1,11 +1,8 @@
 import * as result from "../../types/result/module.f.js";
 import * as list from "../../types/list/module.f.js";
 const { fold, first, drop, toArray } = list;
-import * as Operator from "../../types/function/operator/module.f.js";
-import * as Tokenizer from "../tokenizer/module.f.js";
 import * as map from "../../types/map/module.f.js";
 const { setReplace } = map;
-import * as Json from "../module.f.js";
 import * as o from "../../types/object/module.f.js";
 const { fromMap } = o;
 const addKeyToObject = obj => key => ({ kind: 'object', values: obj.values, key: key });

package/json/serializer/module.f.js

@@ -1,7 +1,5 @@
 import * as list from "../../types/list/module.f.js";
 const { flat, reduce, empty } = list;
-import * as O from "../../types/object/module.f.js";
-import * as Operator from "../../types/function/operator/module.f.js";
 const jsonStringify = JSON.stringify;
 export const stringSerialize = input => [jsonStringify(input)];
 export const numberSerialize = input => [jsonStringify(input)];

package/json/tokenizer/module.f.js

@@ -1,4 +1,3 @@
-import * as Operator from "../../types/function/operator/module.f.js";
 import * as list from "../../types/list/module.f.js";
 const { empty, flat, stateScan } = list;
 import * as bf from "../../types/bigfloat/module.f.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.3.7",
+  "version": "0.3.8",
   "type": "module",
   "files": [
     "**/*.f.d.ts",

package/text/ascii/module.f.d.ts

@@ -1,4 +1,4 @@
-import { type Range } from '../../types/range/module.f.ts';
+import type { Range } from '../../types/range/module.f.ts';
 export declare const one: (s: string) => number;
 export declare const range: (s: string) => Range;
 /** 0x08 */

package/text/ascii/module.f.js

@@ -1,5 +1,4 @@
-import {} from "../../types/range/module.f.js";
-const at = s => i => {
+const at = (s) => (i) => {
     const r = s.codePointAt(i);
     if (r === void 0) {
         throw s;
@@ -7,7 +6,7 @@ const at = s => i => {
     return r;
 };
 export const one = (s) => at(s)(0);
-export const range = s => {
+export const range = (s) => {
     const f = at(s);
     const f0 = f(0);
     if (s.length === 1) {

package/text/ascii/test.f.js

@@ -1,8 +1,6 @@
-import * as _ from "./module.f.js";
-const { range } = _;
+import { range } from "./module.f.js";
 import * as json from "../../json/module.f.js";
-import * as o from "../../types/object/module.f.js";
-const { sort } = o;
+import { sort } from "../../types/object/module.f.js";
 const stringify = json.stringify(sort);
 export default {
     range: () => {

package/text/module.f.d.ts

@@ -1,8 +1,23 @@
-import * as list from '../types/list/module.f.ts';
+import { type Vec } from "../types/bit_vec/module.f.ts";
+import { type List } from '../types/list/module.f.ts';
 export type Block = ItemThunk | ItemArray;
 type ItemArray = readonly Item[];
-type ItemThunk = () => list.List<Item>;
+type ItemThunk = () => List<Item>;
 export type Item = string | ItemArray | ItemThunk;
-export declare const flat: (indent: string) => (text: Block) => list.List<string>;
+export declare const flat: (indent: string) => (text: Block) => List<string>;
 export declare const curly: (type: string) => (name: string) => (body: Block) => Block;
+/**
+ * Converts a string to an UTF-8, represented as an MSB first bit vector.
+ *
+ * @param s The input string to be converted.
+ * @returns The resulting UTF-8 bit vector, MSB first.
+ */
+export declare const msbUtf8: (s: string) => Vec;
+/**
+ * Converts a UTF-8 bit vector with MSB first encoding to a string.
+ *
+ * @param msbV - The UTF-8 bit vector with MSB first encoding.
+ * @returns The resulting string.
+ */
+export declare const msbUtf8ToString: (msbV: Vec) => string;
 export {};

package/text/module.f.js

@@ -1,10 +1,26 @@
-import * as list from "../types/list/module.f.js";
-const { flatMap } = list;
-export const flat = indent => {
-    const f = prefix => {
-        const g = item => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item);
+import { msb, u8List, u8ListToVec } from "../types/bit_vec/module.f.js";
+import { flatMap } from "../types/list/module.f.js";
+import * as utf8 from "./utf8/module.f.js";
+import * as utf16 from "./utf16/module.f.js";
+export const flat = (indent) => {
+    const f = (prefix) => {
+        const g = (item) => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item);
         return flatMap(g);
     };
     return f('');
 };
-export const curly = type => name => body => [`${type} ${name}`, '{', body, '}'];
+export const curly = (type) => (name) => (body) => [`${type} ${name}`, '{', body, '}'];
+/**
+ * Converts a string to an UTF-8, represented as an MSB first bit vector.
+ *
+ * @param s The input string to be converted.
+ * @returns The resulting UTF-8 bit vector, MSB first.
+ */
+export const msbUtf8 = (s) => u8ListToVec(msb)(utf8.fromCodePointList(utf16.toCodePointList(utf16.stringToList(s))));
+/**
+ * Converts a UTF-8 bit vector with MSB first encoding to a string.
+ *
+ * @param msbV - The UTF-8 bit vector with MSB first encoding.
+ * @returns The resulting string.
+ */
+export const msbUtf8ToString = (msbV) => utf16.listToString(utf16.fromCodePointList(utf8.toCodePointList(u8List(msb)(msbV))));

package/text/sgr/module.f.js

@@ -1,7 +1,7 @@
 /**
  * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
  */
-export const sgr = c => `\x1b[${c.toString()}m`;
+export const sgr = (c) => `\x1b[${c.toString()}m`;
 export const reset = sgr(0);
 export const bold = sgr(1);
 export const fgRed = sgr(31);

package/text/test.f.d.ts

@@ -1,2 +1,5 @@
-declare const _default: () => void;
+declare const _default: {
+    block: () => void;
+    encoding: () => void;
+};
 export default _default;

package/text/test.f.js

@@ -1,18 +1,26 @@
-import * as _ from "./module.f.js";
-import * as string from "../types/string/module.f.js";
-const { join } = string;
-export default () => {
-    const text = [
-        'a',
-        'b',
-        () => [
-            'c',
-            () => ['d'],
-        ],
-        'e',
-    ];
-    const result = join('\n')(_.flat(':')(text));
-    if (result !== 'a\nb\n:c\n::d\ne') {
-        throw result;
+import { flat, msbUtf8, msbUtf8ToString } from "./module.f.js";
+import { join } from "../types/string/module.f.js";
+export default {
+    block: () => {
+        const text = [
+            'a',
+            'b',
+            () => [
+                'c',
+                () => ['d'],
+            ],
+            'e',
+        ];
+        const result = join('\n')(flat(':')(text));
+        if (result !== 'a\nb\n:c\n::d\ne') {
+            throw result;
+        }
+    },
+    encoding: () => {
+        const v = msbUtf8('Hello world!');
+        const r = msbUtf8ToString(v);
+        if (r !== 'Hello world!') {
+            throw r;
+        }
     }
 };

package/text/utf16/module.f.d.ts

@@ -1,9 +1,8 @@
 import { type List, type Thunk } from '../../types/list/module.f.ts';
-type u16 = number;
-type i32 = number;
+type U16 = number;
+type I32 = number;
 export declare const fromCodePointList: (input: List<number>) => Thunk<number>;
-declare const u16: (i: number) => boolean;
-export declare const toCodePointList: (input: List<u16>) => List<i32>;
-export declare const stringToList: (s: string) => List<u16>;
-export declare const listToString: (input: List<u16>) => string;
+export declare const toCodePointList: (input: List<U16>) => List<I32>;
+export declare const stringToList: (s: string) => List<U16>;
+export declare const listToString: (input: List<U16>) => string;
 export {};

package/text/utf16/module.f.js

@@ -1,16 +1,15 @@
 import { map, flat, stateScan, reduce, flatMap, empty, } from "../../types/list/module.f.js";
-import * as operator from "../../types/function/operator/module.f.js";
+import { concat } from "../../types/function/operator/module.f.js";
 import { contains } from "../../types/range/module.f.js";
-import * as f from "../../types/function/module.f.js";
-const { fn } = f;
+import { fn } from "../../types/function/module.f.js";
 const lowBmp = contains([0x0000, 0xd7ff]);
 const highBmp = contains([0xe000, 0xffff]);
-const isBmpCodePoint = codePoint => lowBmp(codePoint) || highBmp(codePoint);
+const isBmpCodePoint = (codePoint) => lowBmp(codePoint) || highBmp(codePoint);
 const isHighSurrogate = contains([0xd800, 0xdbff]);
 const isLowSurrogate = contains([0xdc00, 0xdfff]);
 const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
 const isSupplementaryPlane = contains([0x01_0000, 0x10_ffff]);
-const codePointToUtf16 = codePoint => {
+const codePointToUtf16 = (codePoint) => {
     if (isBmpCodePoint(codePoint)) {
         return [codePoint];
     }
@@ -50,17 +49,17 @@ const utf16ByteToCodePointOp = state => word => {
     }
     return [[state | errorMask, word | errorMask], null];
 };
-const utf16EofToCodePointOp = state => [state === null ? empty : [state | errorMask], null];
+const utf16EofToCodePointOp = (state) => [state === null ? empty : [state | errorMask], null];
 const utf16ByteOrEofToCodePointOp = state => input => input === null ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input);
 const eofList = [null];
-export const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])));
-export const stringToList = s => {
-    const at = i => {
+export const toCodePointList = (input) => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])));
+export const stringToList = (s) => {
+    const at = (i) => {
         const first = s.charCodeAt(i);
         return isNaN(first) ? empty : { first, tail: () => at(i + 1) };
     };
     return at(0);
 };
 export const listToString = fn(map(String.fromCharCode))
-    .then(reduce(operator.concat)(''))
+    .then(reduce(concat)(''))
     .result;

package/text/utf16/test.f.js

@@ -1,55 +1,54 @@
-import * as encoding from "./module.f.js";
+import { toCodePointList, fromCodePointList, stringToList, listToString } from "./module.f.js";
 import * as json from "../../json/module.f.js";
-import * as o from "../../types/object/module.f.js";
-const { sort } = o;
-import * as list from "../../types/list/module.f.js";
-const stringify = a => json.stringify(sort)(a);
+import { sort } from "../../types/object/module.f.js";
+import { toArray } from "../../types/list/module.f.js";
+const stringify = (a) => json.stringify(sort)(a);
 export default {
     toCodePointList: [
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([-1, 65536])));
+            const result = stringify(toArray(toCodePointList([-1, 65536])));
             if (result !== '[4294967295,4294967295]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([0, 36, 8364, 55295, 57344, 65535])));
+            const result = stringify(toArray(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])));
+            const result = stringify(toArray(toCodePointList([56320, 57343])));
             if (result !== '[-2147427328,-2147426305]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([55296, 56320, 55297, 56375, 55378, 57186, 56319, 57343])));
+            const result = stringify(toArray(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])));
+            const result = stringify(toArray(toCodePointList([55296, 55296])));
             if (result !== '[-2147428352,-2147428352]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([55296, 0])));
+            const result = stringify(toArray(toCodePointList([55296, 0])));
             if (result !== '[-2147428352,0]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([56320])));
+            const result = stringify(toArray(toCodePointList([56320])));
             if (result !== '[-2147427328]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([56320, 0])));
+            const result = stringify(toArray(toCodePointList([56320, 0])));
             if (result !== '[-2147427328,0]') {
                 throw result;
             }
@@ -57,67 +56,67 @@ export default {
     ],
     fromCodePointList: [
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0])));
+            const result = stringify(toArray(fromCodePointList([0])));
             if (result !== '[0]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x24])));
+            const result = stringify(toArray(fromCodePointList([0x24])));
             if (result !== '[36]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x20AC])));
+            const result = stringify(toArray(fromCodePointList([0x20AC])));
             if (result !== '[8364]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0xd7ff])));
+            const result = stringify(toArray(fromCodePointList([0xd7ff])));
             if (result !== '[55295]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0xe000])));
+            const result = stringify(toArray(fromCodePointList([0xe000])));
             if (result !== '[57344]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0xffff])));
+            const result = stringify(toArray(fromCodePointList([0xffff])));
             if (result !== '[65535]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x10000])));
+            const result = stringify(toArray(fromCodePointList([0x10000])));
             if (result !== '[55296,56320]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x10437])));
+            const result = stringify(toArray(fromCodePointList([0x10437])));
             if (result !== '[55297,56375]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x24B62])));
+            const result = stringify(toArray(fromCodePointList([0x24B62])));
             if (result !== '[55378,57186]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x10ffff])));
+            const result = stringify(toArray(fromCodePointList([0x10ffff])));
             if (result !== '[56319,57343]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([-1, 0xd800, 0xdfff, 0x110000])));
+            const result = stringify(toArray(fromCodePointList([-1, 0xd800, 0xdfff, 0x110000])));
             if (result !== '[65535,55296,57343,0]') {
                 throw result;
             }
@@ -125,17 +124,17 @@ export default {
     ],
     string: [
         () => {
-            const utf16List = encoding.stringToList("Hello world!😂🚜🚲");
-            const result = encoding.listToString(utf16List);
+            const utf16List = stringToList("Hello world!😂🚜🚲");
+            const result = 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);
+            const a = stringToList("Hello world!😂🚜🚲");
+            const b = toCodePointList(a);
+            const c = fromCodePointList(b);
+            const result = listToString(c);
             if (result !== "Hello world!😂🚜🚲") {
                 throw result;
             }

package/text/utf8/module.f.d.ts

@@ -1,6 +1,9 @@
 import { type List, type Thunk } from '../../types/list/module.f.ts';
-type u8 = number;
-type i32 = number;
-export declare const fromCodePointList: (input: List<number>) => Thunk<number>;
-export declare const toCodePointList: (input: List<u8>) => List<i32>;
-export {};
+import type { Array1, Array2, Array3 } from '../../types/array/module.f.ts';
+export type ByteOrEof = U8 | null;
+export type Utf8NonEmptyState = Array1<number> | Array2<number> | Array3<number>;
+export type Utf8State = null | Utf8NonEmptyState;
+export type U8 = number;
+export type I32 = number;
+export declare const fromCodePointList: (input: List<number>) => Thunk<U8>;
+export declare const toCodePointList: (input: List<U8>) => List<I32>;

package/text/utf8/module.f.js

@@ -1,8 +1,6 @@
 import { flatMap, flat, stateScan } from "../../types/list/module.f.js";
-import * as operator from "../../types/function/operator/module.f.js";
-import * as Array from "../../types/array/module.f.js";
 const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
-const codePointToUtf8 = input => {
+const codePointToUtf8 = (input) => {
     if (input >= 0x0000 && input <= 0x007f) {
         return [input & 0b01111_1111];
     }
@@ -32,7 +30,7 @@ const codePointToUtf8 = input => {
     return [errorMask];
 };
 export const fromCodePointList = flatMap(codePointToUtf8);
-const utf8StateToError = state => {
+const utf8StateToError = (state) => {
     let x;
     switch (state.length) {
         case 1: {
@@ -106,7 +104,7 @@ const utf8ByteToCodePointOp = state => byte => {
     }
     return [[error, byte | errorMask], null];
 };
-const utf8EofToCodePointOp = state => [state === null ? null : [utf8StateToError(state)], null];
+const utf8EofToCodePointOp = (state) => [state === null ? null : [utf8StateToError(state)], null];
 const utf8ByteOrEofToCodePointOp = state => input => input === null ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input);
 const eofList = [null];
 export const toCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])));