functionalscript 0.1.609 → 0.2.1

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

@@ -0,0 +1,145 @@
+import * as encoding from './module.f.mjs';
+import * as json from '../../json/module.f.mjs';
+import * as o from '../../types/object/module.f.mjs';
+const { sort } = o;
+import * as list from '../../types/list/module.f.mjs';
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = a => json.stringify(sort)(a);
+export default {
+    toCodePointList: [
+        () => {
+            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;
+            }
+        }
+    ],
+    fromCodePointList: [
+        () => {
+            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;
+            }
+        }
+    ],
+    string: [
+        () => {
+            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;
+            }
+        }
+    ]
+};

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

@@ -0,0 +1,10 @@
+export const fromCodePointList: (input: list.List<number>) => list.Thunk<number>;
+/** @type {(input: list.List<u8>) => list.List<i32>} */
+export const toCodePointList: (input: list.List<u8>) => list.List<i32>;
+export type ByteOrEof = u8 | null;
+export type Utf8NonEmptyState = Array.Array1<number> | Array.Array2<number> | Array.Array3<number>;
+export type Utf8State = null | Utf8NonEmptyState;
+export type u8 = number;
+export type i32 = number;
+import * as list from '../../types/list/module.f.mjs';
+import * as Array from '../../types/array/module.f.mjs';

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

@@ -0,0 +1,126 @@
+// @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 Array from '../../types/array/module.f.mjs';
+const { flatMap, flat, stateScan } = list;
+/** @typedef {u8|null} ByteOrEof */
+/** @typedef {Array.Array1<number>|Array.Array2<number>|Array.Array3<number>} Utf8NonEmptyState */
+/** @typedef {null|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];
+};
+export const fromCodePointList = flatMap(codePointToUtf8);
+/** @type {(state: Utf8NonEmptyState) => i32}*/
+const utf8StateToError = state => {
+    let x;
+    switch (state.length) {
+        case 1: {
+            [x] = state;
+            break;
+        }
+        case 2: {
+            const [s0, s1] = state;
+            x = s0 < 0b1111_0000
+                ? ((s0 & 0b0000_1111) << 6) + (s1 & 0b0011_1111) + 0b0000_0100_0000_0000
+                : ((s0 & 0b0000_0111) << 6) + (s1 & 0b0011_1111) + 0b0000_0010_0000_0000;
+            break;
+        }
+        case 3: {
+            const [s0, s1, s2] = state;
+            x = ((s0 & 0b0000_0111) << 12) + ((s1 & 0b0011_1111) << 6) + (s2 & 0b0011_1111) + 0b1000_0000_0000_0000;
+            break;
+        }
+        default:
+            throw 'invalid state';
+    }
+    return x | errorMask;
+};
+/** @type {operator.StateScan<number, Utf8State, list.List<i32>>} */
+const utf8ByteToCodePointOp = state => byte => {
+    if (byte < 0x00 || byte > 0xff) {
+        return [[errorMask], state];
+    }
+    if (state === null) {
+        if (byte < 0b1000_0000) {
+            return [[byte], null];
+        }
+        if (byte >= 0b1100_0010 && byte <= 0b1111_0100) {
+            return [[], [byte]];
+        }
+        return [[byte | errorMask], null];
+    }
+    if (byte >= 0b1000_0000 && byte < 0b1100_0000) {
+        switch (state.length) {
+            case 1: {
+                const [s0] = state;
+                if (s0 < 0b1110_0000) {
+                    return [[((s0 & 0b0001_1111) << 6) + (byte & 0b0011_1111)], null];
+                }
+                if (s0 < 0b1111_1000) {
+                    return [[], [s0, byte]];
+                }
+                break;
+            }
+            case 2: {
+                const [s0, s1] = state;
+                if (s0 < 0b1111_0000) {
+                    return [[((s0 & 0b0000_1111) << 12) + ((s1 & 0b0011_1111) << 6) + (byte & 0b0011_1111)], null];
+                }
+                if (s0 < 0b1111_1000) {
+                    return [[], [s0, s1, byte]];
+                }
+                break;
+            }
+            case 3: {
+                const [s0, s1, s2] = state;
+                return [[((s0 & 0b0000_0111) << 18) + ((s1 & 0b0011_1111) << 12) + ((s2 & 0b0011_1111) << 6) + (byte & 0b0011_1111)], null];
+            }
+        }
+    }
+    const error = utf8StateToError(state);
+    if (byte < 0b1000_0000) {
+        return [[error, byte], null];
+    }
+    if (byte >= 0b1100_0010 && byte <= 0b1111_0100) {
+        return [[error], [byte]];
+    }
+    return [[error, byte | errorMask], null];
+};
+/** @type {(state: Utf8State) => readonly[list.List<i32>, Utf8State]} */
+const utf8EofToCodePointOp = state => [state === null ? null : [utf8StateToError(state)], null];
+/** @type {operator.StateScan<ByteOrEof, Utf8State, list.List<i32>>} */
+const utf8ByteOrEofToCodePointOp = state => input => input === null ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input);
+/** @type {list.List<ByteOrEof>} */
+const eofList = [null];
+/** @type {(input: list.List<u8>) => list.List<i32>} */
+export const toCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])));

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

@@ -0,0 +1,175 @@
+import * as encoding from './module.f.mjs';
+import * as json from '../../json/module.f.mjs';
+import * as o from '../../types/object/module.f.mjs';
+const { sort } = o;
+import * as list from '../../types/list/module.f.mjs';
+const stringify = json.stringify(sort);
+export default {
+    toCodePoint: [
+        () => {
+            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;
+            }
+        }
+    ],
+    fromCodePointList: [
+        () => {
+            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;
+            }
+        }
+    ],
+    toFrom: [
+        () => {
+            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;
+            }
+        }
+    ]
+};

package/{types → out/types}/array/module.f.d.mts

@@ -1,13 +1,17 @@
-declare namespace _default {
-    export { at };
-    export { first };
-    export { last };
-    export { head };
-    export { tail };
-    export { splitFirst };
-    export { splitLast };
-}
-export default _default;
+/** @type {(index: number) => <T>(a: readonly T[]) => T|null} */
+export const at: (index: number) => <T>(a: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => T|null} */
+export const first: <T>(_: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => T|null} */
+export const last: <T>(_: readonly T[]) => T | null;
+/** @type {<T>(_: readonly T[]) => readonly T[] | null} */
+export const tail: <T>(_: readonly T[]) => readonly T[] | null;
+/** @type {<T>(_: readonly T[]) => readonly[T, readonly T[]]|null} */
+export const splitFirst: <T>(_: readonly T[]) => readonly [T, readonly T[]] | null;
+/** @type {<T>(_: readonly T[]) => readonly T[]|null} */
+export const head: <T>(_: readonly T[]) => readonly T[] | null;
+/** @type {<T>(_: readonly T[]) => readonly[readonly T[], T]|null} */
+export const splitLast: <T>(_: readonly T[]) => readonly [readonly T[], T] | null;
 export type Array1<T> = readonly [T];
 export type Index1 = 0;
 export type Array2<T> = readonly [T, T];
@@ -25,17 +29,3 @@ export type Index16 = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13
 export type Array1_5<T> = Array1<T> | Array2<T> | Array3<T> | Array4<T> | Array5<T>;
 export type Index5 = 0 | 1 | 2 | 3 | 4;
 export type KeyOf<T> = T extends Array1<infer _> ? Index1 : T extends Array2<infer _> ? Index2 : T extends Array3<infer _> ? Index3 : T extends Array4<infer _> ? Index4 : T extends Array5<infer _> ? Index5 : T extends readonly (infer _)[] ? number : never;
-/** @type {(index: number) => <T>(a: readonly T[]) => T|null} */
-declare const at: (index: number) => <T>(a: readonly T[]) => T | null;
-/** @type {<T>(_: readonly T[]) => T|null} */
-declare const first: <T>(_: readonly T[]) => T | null;
-/** @type {<T>(_: readonly T[]) => T|null} */
-declare const last: <T>(_: readonly T[]) => T | null;
-/** @type {<T>(_: readonly T[]) => readonly T[]|null} */
-declare const head: <T>(_: readonly T[]) => readonly T[] | null;
-/** @type {<T>(_: readonly T[]) => readonly T[] | null} */
-declare const tail: <T>(_: readonly T[]) => readonly T[] | null;
-/** @type {<T>(_: readonly T[]) => readonly[T, readonly T[]]|null} */
-declare const splitFirst: <T>(_: readonly T[]) => readonly [T, readonly T[]] | null;
-/** @type {<T>(_: readonly T[]) => readonly[readonly T[], T]|null} */
-declare const splitLast: <T>(_: readonly T[]) => readonly [readonly T[], T] | null;

package/out/types/array/module.f.mjs

@@ -0,0 +1,95 @@
+// @ts-self-types="./module.f.d.mts"
+import * as option from '../nullable/module.f.mjs';
+const { map } = option;
+/**
+ * @template T
+ * @typedef {readonly[T]} Array1
+ */
+/** @typedef {0} Index1 */
+/**
+ * @template T
+ * @typedef {readonly[T, T]} Array2
+ */
+/**
+ * @template T0
+ * @template T1
+ * @typedef {readonly[T0, T1]} Tuple2
+ */
+/** @typedef {0|1} Index2 */
+/**
+ * @template T
+ * @typedef {readonly[T, T, T]} Array3
+ */
+/**
+ * @template T0
+ * @template T1
+ * @template T2
+ * @typedef {readonly[T0, T1, T2]} Tuple3
+ */
+/** @typedef {0|1|2} Index3 */
+/**
+ * @template T
+ * @typedef {readonly[T, T, T, T]} Array4
+ */
+/** @typedef {0|1|2|3} Index4 */
+/**
+ * @template T
+ * @typedef {readonly[T, T, T, T, T]} Array5
+ */
+/**
+ * @template T
+ * @typedef {readonly[T, T, T, T, T, T, T, T]} Array8
+ */
+/**
+ * @template T
+ * @typedef {readonly[T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T]} Array16
+ */
+/** @typedef {0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15} Index16 */
+/**
+ * @template T
+ * @typedef {Array1<T>| Array2<T> | Array3<T> | Array4<T> | Array5<T>} Array1_5
+ */
+/** @typedef {0|1|2|3|4} Index5 */
+/**
+ * @template T
+ * @typedef {T extends Array1<infer _> ? Index1 :
+ *  T extends Array2<infer _> ? Index2 :
+ *  T extends Array3<infer _> ? Index3 :
+ *  T extends Array4<infer _> ? Index4 :
+ *  T extends Array5<infer _> ? Index5 :
+ *  T extends readonly (infer _)[] ? number :
+ *  never
+ * } KeyOf
+ */
+/** @type {<T>(_: readonly T[]) => readonly T[]} */
+const uncheckTail = a => a.slice(1);
+/** @type {<T>(_: readonly T[]) => readonly T[]} */
+const uncheckHead = a => a.slice(0, -1);
+/** @type {(index: number) => <T>(a: readonly T[]) => T|null} */
+export const at = i => a => {
+    const r = a[i];
+    return r === void 0 ? null : r;
+};
+/** @type {<T>(_: readonly T[]) => T|null} */
+export const first = at(0);
+/** @type {<T>(_: readonly T[]) => T|null} */
+export const last = a => at(a.length - 1)(a);
+/** @type {<T>(_: readonly T[]) => readonly T[] | null} */
+export const tail = a => a.length === 0 ? null : uncheckTail(a);
+/** @type {<T>(_: readonly T[]) => readonly[T, readonly T[]]|null} */
+export const splitFirst = a => {
+    /** @typedef {typeof a[0]} T*/
+    /** @type {(_: T) => readonly[T, readonly T[]]} */
+    const split = first => [first, uncheckTail(a)];
+    return map(split)(first(a));
+};
+/** @type {<T>(_: readonly T[]) => readonly T[]|null} */
+export const head = a => a.length === 0 ? null : uncheckHead(a);
+/** @type {<T>(_: readonly T[]) => readonly[readonly T[], T]|null} */
+export const splitLast = a => {
+    const lastA = last(a);
+    if (lastA === null) {
+        return null;
+    }
+    return [uncheckHead(a), lastA];
+};