functionalscript 0.1.609 → 0.2.1

package/out/sha2/module.f.mjs

@@ -0,0 +1,172 @@
+// @ts-self-types="./module.f.d.mts"
+import * as arrayT from '../types/array/module.f.mjs';
+/**
+ * @typedef {{
+ *  readonly f: (i: number) => number
+ *  readonly length: number
+ * }} HashInput
+ */
+/** @typedef {arrayT.Array8<number>} Hash8 */
+/** @typedef {arrayT.Array16<number>} Array16 */
+/** @type {(input: number) => (pos: number) => number} */
+const appendOneWithZeros = input => pos => (input >> pos << pos) | (1 << pos);
+/** @type {(input: number) => (pos: number) => number} */
+const mod = a => b => (a % b + b) % b;
+/** @type  {(input: readonly number[]) => (bits: number) => HashInput} */
+export const padding = input => bitsCount => {
+    const appendBlockIndex = (bitsCount / 32) | 0;
+    const length = (bitsCount + mod(447 - bitsCount)(512) + 65) / 32;
+    /** @type {(i: number) => number} */
+    const f = i => {
+        if (i < appendBlockIndex) {
+            return input[i];
+        }
+        if (i === appendBlockIndex) {
+            return appendBlockIndex >= input.length ? 0x8000_0000 : appendOneWithZeros(input[appendBlockIndex])(31 - bitsCount % 32);
+        }
+        if (i === length - 2) {
+            return (bitsCount / 0x1_0000_0000) | 0;
+        }
+        if (i === length - 1) {
+            return bitsCount % 0x1_0000_0000;
+        }
+        return 0;
+    };
+    return ({ f, length });
+};
+/** @type {(d: number) => (n: number) => number} */
+const rotr = d => {
+    const r = 32 - d;
+    return n => n >>> d | n << r;
+};
+/** @type {(x: number) => (y: number) => (z: number) => number} */
+const ch = x => y => z => x & y ^ ~x & z;
+/** @type {(x: number) => (y: number) => (z: number) => number} */
+const maj = x => y => z => x & y ^ x & z ^ y & z;
+/** @type {(d: number) => (n: number) => number} */
+const shr = d => n => n >>> d;
+/** @type {(a: number) => (b: number) => (c: number) => (x: number) => number} */
+const bigSigma = a => b => c => {
+    const ra = rotr(a);
+    const rb = rotr(b);
+    const rc = rotr(c);
+    return x => ra(x) ^ rb(x) ^ rc(x);
+};
+const bigSigma0 = bigSigma(2)(13)(22);
+const bigSigma1 = bigSigma(6)(11)(25);
+/** @type {(a: number) => (b: number) => (c: number) => (x: number) => number} */
+const smallSigma = a => b => c => {
+    const ra = rotr(a);
+    const rb = rotr(b);
+    const sc = shr(c);
+    return x => ra(x) ^ rb(x) ^ sc(x);
+};
+const smallSigma0 = smallSigma(7)(18)(3);
+const smallSigma1 = smallSigma(17)(19)(10);
+/** @type {(a: arrayT.Array4<number>) => number} */
+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];
+};
+const k = [
+    [
+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    ],
+    [
+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    ],
+    [
+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    ],
+    [
+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+    ],
+];
+/** @type {(init: Hash8) => (data: Array16) => Hash8} */
+const compress = ([a0, b0, c0, d0, e0, f0, g0, h0]) => data => {
+    let w = data;
+    let a = a0;
+    let b = b0;
+    let c = c0;
+    let d = d0;
+    let e = e0;
+    let f = f0;
+    let g = g0;
+    let h = h0;
+    let i = 0;
+    while (true) {
+        const ki = k[i];
+        for (let j = 0; j < 16; ++j) {
+            const t1 = h + bigSigma1(e) + ch(e)(f)(g) + ki[j] + w[j];
+            const t2 = bigSigma0(a) + maj(a)(b)(c);
+            h = g;
+            g = f;
+            f = e;
+            e = (d + t1) | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) | 0;
+        }
+        if (i === 3) {
+            break;
+        }
+        ++i;
+        w = nextW(w);
+    }
+    return [
+        (a0 + a) | 0,
+        (b0 + b) | 0,
+        (c0 + c) | 0,
+        (d0 + d) | 0,
+        (e0 + e) | 0,
+        (f0 + f) | 0,
+        (g0 + g) | 0,
+        (h0 + h) | 0,
+    ];
+};
+/** @type {(init: Hash8) => (input: readonly number[]) => (bitsCount: number) => Hash8} */
+const compute = init => input => bitsCount => {
+    const { f, length } = padding(input)(bitsCount);
+    let result = init;
+    const chunkCount = length / 16;
+    for (let i = 0; i < chunkCount; i++) {
+        const s = i * 16;
+        result = compress(result)([
+            f(s + 0), f(s + 1), f(s + 2), f(s + 3), f(s + 4), f(s + 5), f(s + 6), f(s + 7),
+            f(s + 8), f(s + 9), f(s + 10), f(s + 11), f(s + 12), f(s + 13), f(s + 14), f(s + 15)
+        ]);
+    }
+    return result;
+};
+/** @type {Hash8} */
+const init256 = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19];
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+export const computeSha256 = compute(init256);
+/** @type {Hash8} */
+const init224 = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4];
+/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
+export const computeSha224 = compute(init224);
+export const compress256 = compress(init256);
+export const compress224 = compress(init224);

package/out/sha2/test.f.mjs

@@ -0,0 +1,86 @@
+import * as _ from './module.f.mjs';
+import * as json from '../json/module.f.mjs';
+import * as o from '../types/object/module.f.mjs';
+const { sort } = o;
+/** @type {(a: number) => number} */
+const toU32 = x => (x + 0x1_0000_0000) % 0x1_0000_0000;
+/** @type {(a: number) => string} */
+const toHexString = x => toU32(x).toString(16).padStart(8, '0');
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = a => json.stringify(sort)(a);
+// {
+//     const result = _.padding([])(0)
+//     console.log(result.map(toHexString))
+// }
+// {
+//     const result = _.padding([0x61626364, 0x65000000])(40)
+//     console.log(result.map(toHexString))
+// }
+// {
+//     const result = _.padding([0x11111110])(31)
+//     console.log(result.map(toHexString))
+// }
+// {
+//     const result = _.padding([0x11111110])(32)
+//     console.log(result.map(toHexString))
+// }
+export default {
+    empty: {
+        sha256: () => {
+            const hash = _.computeSha256([])(0);
+            const result = stringify(hash.map(toHexString));
+            if (result !== '["e3b0c442","98fc1c14","9afbf4c8","996fb924","27ae41e4","649b934c","a495991b","7852b855"]') {
+                throw result;
+            }
+        },
+        sha224: () => {
+            const hash = _.computeSha224([])(0);
+            const result = stringify(hash.map(toHexString));
+            if (result !== '["d14a028c","2a3a2bc9","476102bb","288234c4","15a2b01f","828ea62a","c5b3e42f","bdd387cb"]') {
+                throw result;
+            }
+        }
+    },
+    sha224compress: [
+        () => {
+            const hash = _.compress224([0x8000_0000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+            const result = stringify(hash.map(toHexString));
+            if (result !== '["d14a028c","2a3a2bc9","476102bb","288234c4","15a2b01f","828ea62a","c5b3e42f","bdd387cb"]') {
+                throw result;
+            }
+        }
+    ],
+    sha256: [
+        () => {
+            //[0x68656C6C, 0x6F20776F, 0x726C6400] represents phrase 'hello world'
+            const hash = _.computeSha256([0x68656C6C, 0x6F20776F, 0x726C6400])(88);
+            const result = stringify(hash.map(toHexString));
+            if (result !== '["b94d27b9","934d3e08","a52e52d7","da7dabfa","c484efe3","7a5380ee","9088f7ac","e2efcde9"]') {
+                throw result;
+            }
+        },
+        () => {
+            //[0x68656C6C, 0x6F20776F, 0x726C6488] represents phrase 'hello world' with 1's at the end
+            const hash = _.computeSha256([0x68656C6C, 0x6F20776F, 0x726C64FF])(88);
+            const result = stringify(hash.map(toHexString));
+            if (result !== '["b94d27b9","934d3e08","a52e52d7","da7dabfa","c484efe3","7a5380ee","9088f7ac","e2efcde9"]') {
+                throw result;
+            }
+        },
+        () => {
+            const input = Array(8).fill(0x31313131);
+            const result = _.computeSha256(input)(256);
+            if (toU32(result[0]) !== 0x8a83665f) {
+                throw result[0];
+            }
+        },
+        () => {
+            const input = Array(16).fill(0x31313131);
+            const hash = _.computeSha256(input)(512);
+            const result = stringify(hash.map(toHexString));
+            if (result !== '["3138bb9b","c78df27c","473ecfd1","410f7bd4","5ebac1f5","9cf3ff9c","fe4db77a","ab7aedd3"]') {
+                throw result;
+            }
+        }
+    ]
+};

package/out/text/ascii/module.f.d.mts

@@ -0,0 +1,70 @@
+/** @type {(s: string) => number} */
+export const one: (s: string) => number;
+/** @type {(s: string) => _range.Range} */
+export const range: (s: string) => _range.Range;
+export namespace ascii {
+    let backspace: number;
+    let ht: number;
+    let lf: number;
+    let ff: number;
+    let cr: number;
+    let space: number;
+    let exclamationMark: number;
+    let quotationMark: number;
+    let numberSign: number;
+    let dollarSign: number;
+    let percentSign: number;
+    let ampersand: number;
+    let apostrophe: number;
+    let leftParenthesis: number;
+    let rightParenthesis: number;
+    let asterisk: number;
+    let plusSign: number;
+    let comma: number;
+    let hyphenMinus: number;
+    let fullStop: number;
+    let solidus: number;
+    let digitRange: _range.Range;
+    let digit0: number;
+    let digit1: number;
+    let digit2: number;
+    let digit3: number;
+    let digit4: number;
+    let digit5: number;
+    let digit6: number;
+    let digit7: number;
+    let digit8: number;
+    let digit9: number;
+    let colon: number;
+    let semicolon: number;
+    let lessThanSign: number;
+    let equalsSign: number;
+    let greaterThanSign: number;
+    let questionMark: number;
+    let commercialAt: number;
+    let latinCapitalLetterRange: _range.Range;
+    let latinCapitalLetterA: number;
+    let latinCapitalLetterE: number;
+    let latinCapitalLetterF: number;
+    let leftSquareBracket: number;
+    let reverseSolidus: number;
+    let rightSquareBracket: number;
+    let circumflexAccent: number;
+    let lowLine: number;
+    let graveAccent: number;
+    let latinSmallLetterRange: _range.Range;
+    let latinSmallLetterA: number;
+    let latinSmallLetterB: number;
+    let latinSmallLetterE: number;
+    let latinSmallLetterF: number;
+    let latinSmallLetterN: number;
+    let latinSmallLetterR: number;
+    let latinSmallLetterT: number;
+    let latinSmallLetterU: number;
+    let latinSmallLetterZ: number;
+    let leftCurlyBracket: number;
+    let verticalLine: number;
+    let rightCurlyBracket: number;
+    let tilde: number;
+}
+import * as _range from '../../types/range/module.f.mjs';

package/out/text/ascii/module.f.mjs

@@ -0,0 +1,154 @@
+// @ts-self-types="./module.f.d.mts"
+import * as _range from '../../types/range/module.f.mjs';
+/** @type {(s: string) => (i: number) => number} */
+const at = s => i => {
+    const r = s.codePointAt(i);
+    if (r === void 0) {
+        throw s;
+    }
+    return r;
+};
+/** @type {(s: string) => number} */
+export const one = s => at(s)(0);
+/** @type {(s: string) => _range.Range} */
+export const range = s => {
+    const f = at(s);
+    const f0 = f(0);
+    if (s.length === 1) {
+        return [f0, f0];
+    }
+    return [f0, f(1)];
+};
+export const ascii = {
+    // 0x00..
+    /** @readonly 0x08 */
+    backspace: one('\b'),
+    /** @readonly 0x09 */
+    ht: one('\t'),
+    /** @readonly 0x0A */
+    lf: one('\n'),
+    /** @readonly 0x0C */
+    ff: one('\f'),
+    /** @readonly 0x0D */
+    cr: one('\r'),
+    // 0x20..
+    /** @readonly 0x20 */
+    space: one(' '),
+    /** @readonly 0x21 */
+    exclamationMark: one('!'),
+    /** @readonly 0x22 */
+    quotationMark: one('"'),
+    /** @readonly 0x23 */
+    numberSign: one('#'),
+    /** @readonly 0x24 */
+    dollarSign: one('$'),
+    /** @readonly 0x25 */
+    percentSign: one('%'),
+    /** @readonly 0x26 */
+    ampersand: one('&'),
+    /** @readonly 0x27 */
+    apostrophe: one("'"),
+    /** @readonly 0x28 */
+    leftParenthesis: one('('),
+    /** @readonly 0x29 */
+    rightParenthesis: one(')'),
+    /** @readonly 0x2A */
+    asterisk: one('*'),
+    /** @readonly 0x2B */
+    plusSign: one('+'),
+    /** @readonly 0x2C */
+    comma: one(','),
+    /** @readonly 0x2D */
+    hyphenMinus: one('-'),
+    /** @readonly 0x2E */
+    fullStop: one('.'),
+    /** @readonly 0x2F */
+    solidus: one('/'),
+    // 0x30..
+    /** @readonly 0x30..0x39 */
+    digitRange: range('09'),
+    /** @readonly 0x30 */
+    digit0: one('0'),
+    /** @readonly 0x31 */
+    digit1: one('1'),
+    /** @readonly 0x32 */
+    digit2: one('2'),
+    /** @readonly 0x33 */
+    digit3: one('3'),
+    /** @readonly 0x34 */
+    digit4: one('4'),
+    /** @readonly 0x35 */
+    digit5: one('5'),
+    /** @readonly 0x36 */
+    digit6: one('6'),
+    /** @readonly 0x37 */
+    digit7: one('7'),
+    /** @readonly 0x38 */
+    digit8: one('8'),
+    /** @readonly 0x39 */
+    digit9: one('9'),
+    /** @readonly 0x3A */
+    colon: one(':'),
+    /** @readonly 0x3B */
+    semicolon: one(';'),
+    /** @readonly 0x3C */
+    lessThanSign: one('<'),
+    /** @readonly 0x3D */
+    equalsSign: one('='),
+    /** @readonly 0x3E */
+    greaterThanSign: one('>'),
+    /** @readonly 0x3F */
+    questionMark: one('?'),
+    // 0x40..
+    /** @readonly 0x40 */
+    commercialAt: one('@'),
+    /** @readonly 0x41..0x5A */
+    latinCapitalLetterRange: range('AZ'),
+    /** @readonly 0x41 */
+    latinCapitalLetterA: one('A'),
+    /** @readonly 0x45 */
+    latinCapitalLetterE: one('E'),
+    /** @readonly 0x46 */
+    latinCapitalLetterF: one('F'),
+    /** @readonly 0x5B */
+    leftSquareBracket: one('['),
+    /** @readonly 0x5C */
+    reverseSolidus: one('\\'),
+    /** @readonly 0x5D */
+    rightSquareBracket: one(']'),
+    /** @readonly 0x5E */
+    circumflexAccent: one('^'),
+    /** @readonly 0x5F */
+    lowLine: one('_'),
+    // 0x60..
+    /** @readonly 0x60 */
+    graveAccent: one('`'),
+    /** @readonly 0x61..0x7A */
+    latinSmallLetterRange: range('az'),
+    /** @readonly 0x61 */
+    latinSmallLetterA: one('a'),
+    /** @readonly 0x62 */
+    latinSmallLetterB: one('b'),
+    /** @readonly 0x65 */
+    latinSmallLetterE: one('e'),
+    /** @readonly 0x66 */
+    latinSmallLetterF: one('f'),
+    /** @readonly 0x6E */
+    latinSmallLetterN: one('n'),
+    /** @readonly 0x72 */
+    latinSmallLetterR: one('r'),
+    /** @readonly 0x74 */
+    latinSmallLetterT: one('t'),
+    /** @readonly 0x75 */
+    latinSmallLetterU: one('u'),
+    /** @readonly 0x7A */
+    latinSmallLetterZ: one('z'),
+    /** @readonly 0x7B */
+    leftCurlyBracket: one('{'),
+    /** @readonly 0x7C */
+    verticalLine: one('|'),
+    /** @readonly 0x7D */
+    rightCurlyBracket: one('}'),
+    /** @readonly 0x7E */
+    tilde: one('~'),
+};

package/out/text/ascii/test.f.mjs

@@ -0,0 +1,14 @@
+import * as _ from './module.f.mjs';
+const { range } = _;
+import * as json from '../../json/module.f.mjs';
+import * as o from '../../types/object/module.f.mjs';
+const { sort } = o;
+const stringify = json.stringify(sort);
+export default {
+    range: () => {
+        const r = stringify(range("A"));
+        if (r !== '[65,65]') {
+            throw r;
+        }
+    }
+};

package/out/text/module.f.d.mts

@@ -0,0 +1,13 @@
+/** @typedef {ItemThunk|ItemArray} Block */
+/** @typedef {readonly Item[]} ItemArray */
+/** @typedef {() => list.List<Item>} ItemThunk */
+/** @typedef {string|ItemArray|ItemThunk} Item */
+/** @type {(indent: string) => (text: Block) => list.List<string>} */
+export const flat: (indent: string) => (text: Block) => list.List<string>;
+/** @type {(type: string) => (name: string) => (body: Block) => Block} */
+export const curly: (type: string) => (name: string) => (body: Block) => Block;
+export type Block = ItemThunk | ItemArray;
+export type ItemArray = readonly Item[];
+export type ItemThunk = () => list.List<Item>;
+export type Item = string | ItemArray | ItemThunk;
+import * as list from '../types/list/module.f.mjs';

package/out/text/module.f.mjs

@@ -0,0 +1,19 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../types/list/module.f.mjs';
+const { flatMap } = list;
+/** @typedef {ItemThunk|ItemArray} Block */
+/** @typedef {readonly Item[]} ItemArray */
+/** @typedef {() => list.List<Item>} ItemThunk */
+/** @typedef {string|ItemArray|ItemThunk} Item */
+/** @type {(indent: string) => (text: Block) => list.List<string>} */
+export const flat = indent => {
+    /** @type {(prefix: string) => (text: Block) => list.List<string>} */
+    const f = prefix => {
+        /** @type {(item: Item) => list.List<string>} */
+        const g = item => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item);
+        return flatMap(g);
+    };
+    return f('');
+};
+/** @type {(type: string) => (name: string) => (body: Block) => Block} */
+export const curly = type => name => body => [`${type} ${name}`, '{', body, '}'];

package/out/text/sgr/module.f.d.mts

@@ -0,0 +1,12 @@
+/**
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
+ *
+ * @type {(c: number) => string}
+ */
+export const sgr: (c: number) => string;
+export namespace codes {
+    let reset: string;
+    let bold: string;
+    let fgRed: string;
+    let fgGreen: string;
+}

package/out/text/sgr/module.f.mjs

@@ -0,0 +1,17 @@
+// @ts-self-types="./module.f.d.mts"
+/**
+ * https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
+ *
+ * @type {(c: number) => string}
+ */
+export const sgr = c => `\x1b[${c.toString()}m`;
+export const codes = {
+    /** @readonly */
+    reset: sgr(0),
+    /** @readonly */
+    bold: sgr(1),
+    /** @readonly */
+    fgRed: sgr(31),
+    /** @readonly */
+    fgGreen: sgr(32),
+};

package/out/text/test.f.mjs

@@ -0,0 +1,19 @@
+import * as _ from './module.f.mjs';
+import * as string from '../types/string/module.f.mjs';
+const { join } = string;
+export default () => {
+    /** @type {_.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;
+    }
+};

package/out/text/utf16/module.f.d.mts

@@ -0,0 +1,12 @@
+export const fromCodePointList: (input: list.List<number>) => list.Thunk<number>;
+/** @type {(input: list.List<u16>) => list.List<i32>} */
+export const toCodePointList: (input: list.List<u16>) => list.List<i32>;
+/** @type {(s: string) => list.List<u16>} */
+export const stringToList: (s: string) => list.List<u16>;
+/** @type {(input: list.List<u16>) => string} */
+export const listToString: (input: list.List<u16>) => string;
+export type WordOrEof = u16 | null;
+export type Utf16State = number | null;
+export type u16 = number;
+export type i32 = number;
+import * as list from '../../types/list/module.f.mjs';

package/out/text/utf16/module.f.mjs

@@ -0,0 +1,86 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../../types/list/module.f.mjs';
+import * as operator from '../../types/function/operator/module.f.mjs';
+import * as range from '../../types/range/module.f.mjs';
+const { contains } = range;
+import * as f from '../../types/function/module.f.mjs';
+const { fn } = f;
+const { map, flat, stateScan, reduce, flatMap, empty } = list;
+/** @typedef {u16|null} WordOrEof */
+/** @typedef {number|null} Utf16State */
+/** @typedef {number} u16 */
+/** @typedef {number} i32 */
+const lowBmp = contains([0x0000, 0xd7ff]);
+const highBmp = contains([0xe000, 0xffff]);
+/** @type {(codePoint: i32) => boolean} */
+const isBmpCodePoint = codePoint => lowBmp(codePoint) || highBmp(codePoint);
+/** @type {(codePoint: i32) => boolean} */
+const isHighSurrogate = contains([0xd800, 0xdbff]);
+/** @type {(codePoint: i32) => boolean} */
+const isLowSurrogate = contains([0xdc00, 0xdfff]);
+const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
+/** @type {(a: i32) => boolean} */
+const isSupplementaryPlane = contains([0x01_0000, 0x10_ffff]);
+/** @type {(input: i32) => list.List<u16>} */
+const codePointToUtf16 = codePoint => {
+    if (isBmpCodePoint(codePoint)) {
+        return [codePoint];
+    }
+    if (isSupplementaryPlane(codePoint)) {
+        const n = codePoint - 0x1_0000;
+        const high = (n >> 10) + 0xd800;
+        const low = (n & 0b0011_1111_1111) + 0xdc00;
+        return [high, low];
+    }
+    return [codePoint & 0xffff];
+};
+export const fromCodePointList = flatMap(codePointToUtf16);
+const u16 = contains([0x0000, 0xFFFF]);
+/** @type {operator.StateScan<u16, Utf16State, list.List<i32>>} */
+const utf16ByteToCodePointOp = state => word => {
+    if (!u16(word)) {
+        return [[0xffffffff], state];
+    }
+    if (state === null) {
+        if (isBmpCodePoint(word)) {
+            return [[word], null];
+        }
+        if (isHighSurrogate(word)) {
+            return [[], word];
+        }
+        return [[word | errorMask], null];
+    }
+    if (isLowSurrogate(word)) {
+        const high = state - 0xd800;
+        const low = word - 0xdc00;
+        return [[(high << 10) + low + 0x10000], null];
+    }
+    if (isBmpCodePoint(word)) {
+        return [[state | errorMask, word], null];
+    }
+    if (isHighSurrogate(word)) {
+        return [[state | errorMask], word];
+    }
+    return [[state | errorMask, word | errorMask], null];
+};
+/** @type {(state: Utf16State) => readonly[list.List<i32>, Utf16State]} */
+const utf16EofToCodePointOp = state => [state === null ? empty : [state | errorMask], null];
+/** @type {operator.StateScan<WordOrEof, Utf16State, list.List<i32>>} */
+const utf16ByteOrEofToCodePointOp = state => input => input === null ? utf16EofToCodePointOp(state) : utf16ByteToCodePointOp(state)(input);
+/** @type {list.List<WordOrEof>} */
+const eofList = [null];
+/** @type {(input: list.List<u16>) => list.List<i32>} */
+export const toCodePointList = input => flat(stateScan(utf16ByteOrEofToCodePointOp)(null)(flat([input, eofList])));
+/** @type {(s: string) => list.List<u16>} */
+export const stringToList = s => {
+    /** @type {(i: number) => list.Result<number>} */
+    const at = i => {
+        const first = s.charCodeAt(i);
+        return isNaN(first) ? empty : { first, tail: () => at(i + 1) };
+    };
+    return at(0);
+};
+/** @type {(input: list.List<u16>) => string} */
+export const listToString = fn(map(String.fromCharCode))
+    .then(reduce(operator.concat)(''))
+    .result;