functionalscript 0.4.2 → 0.4.4

package/README.md

@@ -19,7 +19,7 @@ Learn more about
 - [Purely Functional Programming in JavaScript](https://blog.bitsrc.io/purely-functional-programming-in-javascript-91114b1b2dff?sk=5f7132e56902f38fcf4c6164bfa681ed),
 - [FunctionalScript and I/O](https://medium.com/@sergeyshandar/functionalscript-5cf817345376?sk=30b32189a81d1a2dad16c2244f32328d).
 
-This repository is a [monorepo](https://en.wikipedia.org/wiki/Monorepo) and distributted under under [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.en.html#license-text). Let us know if you need another license by sending an [email](mailto:sergey.oss@proton.me).
+This repository is a [monorepo](https://en.wikipedia.org/wiki/Monorepo) and distributted under [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.en.html#license-text). Let us know if you need another license by sending an [email](mailto:sergey.oss@proton.me).
 
 ## Vision
 

package/bnf/data/module.f.d.ts

@@ -0,0 +1,12 @@
+import type { Rule as FRule } from '../module.f.ts';
+export type TerminalRange = number;
+export type Sequence = readonly string[];
+export type Variant = {
+    readonly [k in string]: string;
+};
+export type Rule = Variant | Sequence | TerminalRange;
+export type RuleSet = Readonly<Record<string, Rule>>;
+export declare const toData: (fr: FRule) => readonly [RuleSet, string];
+/**
+ * Either `{ variantItem: id }` or `id`.
+ */

package/bnf/data/module.f.js

@@ -0,0 +1,85 @@
+import { stringToCodePointList } from "../../text/utf16/module.f.js";
+import { toArray } from "../../types/list/module.f.js";
+const { entries } = Object;
+const find = (map) => (fr) => {
+    for (const [k, v] of entries(map)) {
+        if (v === fr) {
+            return k;
+        }
+    }
+    return undefined;
+};
+const newName = (map, name) => {
+    let i = 0;
+    let result = name;
+    while (result in map) {
+        result = name + i;
+        ++i;
+    }
+    return result;
+};
+const sequence = (list) => map => {
+    let result = [];
+    let set = {};
+    for (const fr of list) {
+        const [map1, set1, id] = toDataAdd(map)(fr);
+        map = map1;
+        set = { ...set, ...set1 };
+        result = [...result, id];
+    }
+    return [map, set, result];
+};
+const variant = (fr) => map => {
+    let set = {};
+    let rule = {};
+    for (const [k, v] of entries(fr)) {
+        const [m1, s, id] = toDataAdd(map)(v);
+        map = m1;
+        set = { ...set, ...s };
+        rule = { ...rule, [k]: id };
+    }
+    return [map, set, rule];
+};
+const data = (dr) => {
+    switch (typeof dr) {
+        case 'string': {
+            return sequence(toArray(stringToCodePointList(dr)));
+        }
+        case 'number':
+            return m => [m, {}, dr];
+        default:
+            if (dr instanceof Array) {
+                return sequence(dr);
+            }
+            return variant(dr);
+    }
+};
+const toDataAdd = (map) => (fr) => {
+    {
+        const id = find(map)(fr);
+        if (id !== undefined) {
+            return [map, {}, id];
+        }
+    }
+    const [dr, tmpId] = typeof fr === 'function' ? [fr(), fr.name] : [fr, ''];
+    const newRule = data(dr);
+    const id = newName(map, tmpId);
+    const map1 = { ...map, [id]: fr };
+    const [map2, set, rule] = newRule(map1);
+    return [map2, { ...set, [id]: rule }, id];
+};
+export const toData = (fr) => {
+    const [, ruleSet, id] = toDataAdd({})(fr);
+    return [ruleSet, id];
+};
+// type Dispatch = RangeMapArray<string>;
+/**
+ * Either `{ variantItem: id }` or `id`.
+ */
+/*
+type DispatchRule = SingleProperty<> | string
+
+type Dispatch = RangeMapArray<DispatchRule>
+
+type DispatchMap = { readonly[id in string]: Dispatch }
+*/

package/bnf/data/test.f.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    toData: () => void;
+};
+export default _default;

package/bnf/data/test.f.js

@@ -0,0 +1,8 @@
+import { classic, deterministic } from "../testlib.f.js";
+import { toData } from "./module.f.js";
+export default {
+    toData: () => {
+        const c = toData(classic());
+        const d = toData(deterministic());
+    }
+};

package/bnf/module.f.d.ts

@@ -0,0 +1,55 @@
+import { type Array2 } from '../types/array/module.f.ts';
+export type TerminalRange = number;
+export type Sequence = readonly Rule[];
+export type Variant = {
+    readonly [k in string]: Rule;
+};
+export type DataRule = Variant | Sequence | TerminalRange | string;
+export type LazyRule = () => DataRule;
+export type Rule = DataRule | LazyRule;
+export declare const max: string;
+export declare const rangeEncode: (a: number, b: number) => TerminalRange;
+export declare const oneEncode: (a: number) => TerminalRange;
+export declare const rangeDecode: (r: number) => Array2<number>;
+export declare const toSequence: (s: string) => readonly TerminalRange[];
+export declare const str: (s: string) => readonly TerminalRange[] | TerminalRange;
+export declare const set: (s: string) => RangeVariant;
+export declare const range: (ab: string) => TerminalRange;
+/**
+ * A set of terminal ranges compatible with the `Variant` rule.
+ */
+export type RangeVariant = {
+    readonly [k in string]: TerminalRange;
+};
+export declare const rangeToId: (r: TerminalRange) => string;
+export declare const remove: (range: TerminalRange, removeSet: RangeVariant) => RangeVariant;
+export type None = readonly [];
+export declare const none: None;
+export type Option<S> = {
+    none: None;
+    some: S;
+};
+export declare const option: <S extends Rule>(some: S) => Option<S>;
+export type Repeat0Plus<T> = () => Option<readonly [T, Repeat0Plus<T>]>;
+/**
+ * Repeat zero or more times.
+ *
+ * https://english.stackexchange.com/questions/506480/single-word-quantifiers-for-zero-or-more-like-cardinalities
+ * - zero or more - any, 0Plus
+ * - one or more - several, 1Plus
+ *
+ * Also see: https://arbs.nzcer.org.nz/types-numbers
+ */
+export declare const repeat0Plus: <T extends Rule>(some: T) => Repeat0Plus<T>;
+export type Repeat1Plus<T> = readonly [T, Repeat0Plus<T>];
+/**
+ * Repeat one or more times.
+ */
+export declare const repeat1Plus: <T extends Rule>(some: T) => Repeat1Plus<T>;
+export type Join1Plus<T, S> = readonly [T, Repeat0Plus<readonly [S, T]>];
+export declare const join1Plus: <T extends Rule, S extends Rule>(some: T, separator: S) => Join1Plus<T, S>;
+export type Join0Plus<T, S> = Option<readonly [T, Repeat0Plus<readonly [S, T]>]>;
+export declare const join0Plus: <T extends Rule, S extends Rule>(some: T, separator: S) => Rule;
+export type Repeat<T> = readonly T[];
+export declare const repeat: (n: number) => <T extends Rule>(some: T) => Repeat<T>;
+export declare const isEmpty: (rule: Rule) => boolean;

package/bnf/module.f.js

@@ -0,0 +1,98 @@
+import { codePointListToString, stringToCodePointList } from "../text/utf16/module.f.js";
+import { isArray2 } from "../types/array/module.f.js";
+import { map, toArray, repeat as listRepeat } from "../types/list/module.f.js";
+//
+const { fromEntries, values } = Object;
+const { fromCodePoint } = String;
+/**
+ * Two 24 bit numbers can be fit into one JS number (53 bit).
+ */
+const offset = 24;
+const mask = (1 << offset) - 1;
+const isValid = (r) => r >= 0 && r <= mask;
+export const max = codePointListToString([0x10FFFF]);
+export const rangeEncode = (a, b) => {
+    if (!isValid(a) || !isValid(b) || a > b) {
+        throw `Invalid range ${a} ${b}.`;
+    }
+    return (a << offset) | b;
+};
+export const oneEncode = (a) => rangeEncode(a, a);
+export const rangeDecode = (r) => [r >> offset, r & mask];
+const mapOneEncode = map(oneEncode);
+export const toSequence = (s) => toArray(mapOneEncode(stringToCodePointList(s)));
+export const str = (s) => {
+    const x = toSequence(s);
+    return x.length === 1 ? x[0] : x;
+};
+const mapEntry = map((v) => [fromCodePoint(v), oneEncode(v)]);
+export const set = (s) => fromEntries(toArray(mapEntry(stringToCodePointList(s))));
+export const range = (ab) => {
+    const a = toArray(stringToCodePointList(ab));
+    if (!isArray2(a)) {
+        throw `Invalid range ${ab}.`;
+    }
+    return rangeEncode(...a);
+};
+export const rangeToId = (r) => {
+    const ab = rangeDecode(r);
+    const [a, b] = ab;
+    const cp = a === b ? [a] : ab;
+    return fromCodePoint(...cp);
+};
+const rangeToEntry = (r) => [rangeToId(r), r];
+const toVariantRangeSet = (r) => fromEntries(r.map(rangeToEntry));
+const removeOne = (list, ab) => {
+    const [a, b] = rangeDecode(ab);
+    let result = [];
+    for (const ab0 of list) {
+        const [a0, b0] = rangeDecode(ab0);
+        if (a0 < a) {
+            // [a0
+            //     ]a
+            result = [...result, rangeEncode(a0, Math.min(b0, a - 1))];
+        }
+        if (b < b0) {
+            //    b0]
+            // b[
+            result = [...result, rangeEncode(Math.max(b + 1, a0), b0)];
+        }
+    }
+    return result;
+};
+export const remove = (range, removeSet) => {
+    let result = [range];
+    for (const r of values(removeSet)) {
+        result = removeOne(result, r);
+    }
+    return toVariantRangeSet(result);
+};
+export const none = [];
+export const option = (some) => ({
+    none,
+    some,
+});
+/**
+ * Repeat zero or more times.
+ *
+ * https://english.stackexchange.com/questions/506480/single-word-quantifiers-for-zero-or-more-like-cardinalities
+ * - zero or more - any, 0Plus
+ * - one or more - several, 1Plus
+ *
+ * Also see: https://arbs.nzcer.org.nz/types-numbers
+ */
+export const repeat0Plus = (some) => {
+    const r = () => option([some, r]);
+    return r;
+};
+/**
+ * Repeat one or more times.
+ */
+export const repeat1Plus = (some) => [some, repeat0Plus(some)];
+export const join1Plus = (some, separator) => [some, repeat0Plus([separator, some])];
+export const join0Plus = (some, separator) => option(join1Plus(some, separator));
+export const repeat = (n) => (some) => toArray(listRepeat(some)(n));
+export const isEmpty = (rule) => {
+    const d = typeof rule === 'function' ? rule() : rule;
+    return d === '' || (d instanceof Array && d.length === 0);
+};

package/bnf/test.f.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    test: () => void;
+};
+export default _default;

package/bnf/test.f.js

@@ -0,0 +1,7 @@
+import { classic, deterministic } from "./testlib.f.js";
+export default {
+    test: () => {
+        classic();
+        deterministic();
+    }
+};

package/bnf/testlib.f.d.ts

@@ -0,0 +1,3 @@
+import { type Rule } from './module.f.ts';
+export declare const classic: () => Rule;
+export declare const deterministic: () => Rule;

package/bnf/{tag/test.f.js → testlib.f.js}

@@ -1,5 +1,5 @@
-import { join0, none, option, range, repeat0, set } from "./module.f.js";
-const _classic = () => {
+import { join0Plus, max, none, option, range, remove, repeat, repeat0Plus, set } from "./module.f.js";
+export const classic = () => {
     const json = () => [element];
     const value = () => ({
         object,
@@ -34,9 +34,9 @@ const _classic = () => {
         characters: [character, characters],
     });
     const character = () => ({
-        0: 0x20000021n,
-        1: 0x2300005bn,
-        2: 0x5d10ffffn,
+        0: 0x20_000021,
+        1: 0x23_00005B,
+        2: 0x5D_10FFFF,
         escape: ['\\', escape],
     });
     const escape = () => ({
@@ -63,7 +63,7 @@ const _classic = () => {
         '0': '0',
         onenine,
     });
-    const onenine = range('12');
+    const onenine = range('19');
     const fraction = () => ({
         none,
         digits: ['.', digits],
@@ -86,53 +86,57 @@ const _classic = () => {
     });
     return json;
 };
-const _deterministic = () => {
-    const onenine = range('12');
-    const digit = {
-        '0': '0',
-        onenine,
-    };
-    const hex = {
-        digit,
-        AF: range('AF'),
-        af: range('af'),
-    };
-    const escape = {
-        ...set('"\\/bfnrt'),
-        u: ['u', hex, hex, hex, hex],
-    };
-    const character = {
-        0: 0x20000021n,
-        1: 0x2300005bn,
-        2: 0x5d10ffffn,
-        escape: ['\\', escape],
-    };
-    const characters = repeat0(character);
-    const string = ['"', characters, '"'];
-    const digits0 = repeat0(digit);
+export const deterministic = () => {
+    const onenine = range('19');
+    const digit = range('09');
+    const string = [
+        '"',
+        repeat0Plus({
+            ...remove(range(` ${max}`), set('"\\')),
+            escape: [
+                '\\',
+                {
+                    ...set('"\\/bfnrt'),
+                    u: [
+                        'u',
+                        ...repeat(4)({
+                            digit,
+                            AF: range('AF'),
+                            af: range('af'),
+                        })
+                    ],
+                }
+            ],
+        }),
+        '"'
+    ];
+    const digits0 = repeat0Plus(digit);
     const digits = [digit, digits0];
-    const integer = [option('-'), {
-            '0': '0',
+    const number = [
+        option('-'),
+        {
+            0: '0',
             onenine: [onenine, digits0],
-        }];
-    const fraction = option(['.', digits]);
-    const sign = option(set('+-'));
-    const exponent = option([set('Ee'), sign, digits]);
-    const number = [integer, fraction, exponent];
-    const ws = repeat0(set(' \n\r\t'));
+        },
+        option(['.', digits]),
+        option([set('Ee'), option(set('+-')), digits])
+    ];
+    const ws = repeat0Plus(set(' \n\r\t'));
+    const commaJoin0Plus = ([open, close], a) => [
+        open,
+        ws,
+        join0Plus([a, ws], [',', ws]),
+        close,
+    ];
     const value = () => ({
-        object,
-        array,
+        object: commaJoin0Plus('{}', [string, ws, ':', ws, value]),
+        array: commaJoin0Plus('[]', value),
         string,
         number,
         true: 'true',
         false: 'false',
         null: 'null'
     });
-    const commaJoin0 = ([open, close], a) => [open, ws, join0([a, ws], [',', ws]), close];
-    const array = commaJoin0('[]', value);
-    const member = [string, ws, ':', ws, value];
-    const object = commaJoin0('{}', member);
     const json = [ws, value, ws];
     return json;
 };

package/crypto/hmac/module.f.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Provides an implementation of HMAC (Hash-based Message Authentication Code).
+ *
+ * https://en.wikipedia.org/wiki/HMAC
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```ts
+ * import { vec } from '../../types/bit_vec/module.f.ts'
+ * import { msbUtf8 } from '../../text/module.f.ts'
+ * import { sha256 } from '../sha2/module.f.ts'
+ *
+ * const r = hmac(sha256)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'))
+ * if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) { throw r }
+ * ```
+ */
+import { type Vec } from '../../types/bit_vec/module.f.ts';
+import { type Sha2 } from '../sha2/module.f.ts';
+/**
+ * Generates an HMAC (Hash-based Message Authentication Code) using the specified SHA-2 hash function.
+ *
+ * @param sha2 - The SHA-2 hash function implementation to use.
+ * @returns - A function that takes a key and returns another function
+ * that takes a message and computes the HMAC.
+ */
+export declare const hmac: (sha2: Sha2) => (k: Vec) => (m: Vec) => Vec;

package/crypto/hmac/module.f.js

@@ -0,0 +1,60 @@
+/**
+ * Provides an implementation of HMAC (Hash-based Message Authentication Code).
+ *
+ * https://en.wikipedia.org/wiki/HMAC
+ *
+ * @module
+ *
+ * @example
+ *
+ * ```ts
+ * import { vec } from '../../types/bit_vec/module.f.ts'
+ * import { msbUtf8 } from '../../text/module.f.ts'
+ * import { sha256 } from '../sha2/module.f.ts'
+ *
+ * const r = hmac(sha256)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'))
+ * if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) { throw r }
+ * ```
+ */
+import { length } from "../../types/bit_vec/module.f.js";
+import { empty, msb, vec, vec8 } from "../../types/bit_vec/module.f.js";
+import { flip } from "../../types/function/module.f.js";
+import { repeat } from "../../types/monoid/module.f.js";
+import { computeSync } from "../sha2/module.f.js";
+const { concat } = msb;
+/**
+ * Outer padding.
+ */
+const oPad = vec8(0x5cn);
+/**
+ * Inner padding.
+ */
+const iPad = vec8(0x36n);
+/**
+ * Repeats a vector to create a padded block of the desired length.
+ */
+const padRepeat = repeat({ identity: empty, operation: concat });
+/**
+ * Generates an HMAC (Hash-based Message Authentication Code) using the specified SHA-2 hash function.
+ *
+ * @param sha2 - The SHA-2 hash function implementation to use.
+ * @returns - A function that takes a key and returns another function
+ * that takes a message and computes the HMAC.
+ */
+export const hmac = (sha2) => {
+    const { blockLength } = sha2;
+    const p = flip(padRepeat)(blockLength >> 3n);
+    const ip = p(iPad);
+    const op = p(oPad);
+    const c = computeSync(sha2);
+    const vbl = vec(blockLength);
+    const xor = (a) => (b) => vbl(a ^ b);
+    return k => m => {
+        const k1 = length(k) > blockLength ? c([k]) : k;
+        const k2 = concat(k1)(vec(blockLength - length(k1))(0n));
+        const xk2 = xor(k2);
+        const f = (p, msg) => c([xk2(p), msg]);
+        const m1 = f(ip, m);
+        return f(op, m1);
+    };
+};

package/crypto/hmac/test.f.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    example: () => void;
+    sha256: () => void;
+    sha512: () => void;
+};
+export default _default;

package/crypto/hmac/test.f.js

@@ -0,0 +1,24 @@
+import { msbUtf8 } from "../../text/module.f.js";
+import { vec } from "../../types/bit_vec/module.f.js";
+import { sha256, sha512 } from "../sha2/module.f.js";
+import { hmac } from "./module.f.js";
+export default {
+    example: () => {
+        const r = hmac(sha256)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'));
+        if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) {
+            throw r;
+        }
+    },
+    sha256: () => {
+        const r = hmac(sha256)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'));
+        if (r !== 0x1f7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n) {
+            throw r;
+        }
+    },
+    sha512: () => {
+        const r = hmac(sha512)(msbUtf8('key'))(msbUtf8('The quick brown fox jumps over the lazy dog'));
+        if (r !== 0x1b42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3an) {
+            throw r;
+        }
+    }
+};

package/crypto/secp/module.f.d.ts

@@ -65,4 +65,12 @@ export declare const secp256k1: Init;
  * https://neuromancer.sk/std/secg/secp256r1
  */
 export declare const secp256r1: Init;
+/**
+ * https://neuromancer.sk/std/secg/secp384r1
+ */
+export declare const secp384r1: Init;
+/**
+ * https://neuromancer.sk/std/secg/secp521r1
+ */
+export declare const secp521r1: Init;
 export {};

package/crypto/secp/module.f.js

@@ -124,3 +124,33 @@ export const secp256r1 = {
     ],
     n: 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n,
 };
+/**
+ * https://neuromancer.sk/std/secg/secp384r1
+ */
+export const secp384r1 = {
+    p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000ffffffffn,
+    a: [
+        0xb3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875ac656398d8a2ed19d2a85c8edd3ec2aefn, //< b
+        0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000fffffffcn, //< a
+    ],
+    g: [
+        0xaa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a385502f25dbf55296c3a545e3872760ab7n, //< x
+        0x3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5fn, //< y
+    ],
+    n: 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973n,
+};
+/**
+ * https://neuromancer.sk/std/secg/secp521r1
+ */
+export const secp521r1 = {
+    p: 0x01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,
+    a: [
+        0x0051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00n, //< b
+        0x01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffcn, //< a
+    ],
+    g: [
+        0x00c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66n,
+        0x011839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650n,
+    ],
+    n: 0x01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409n
+};

package/crypto/secp/test.f.d.ts

@@ -1,5 +1,8 @@
 declare const _default: {
     example: () => void;
     test: () => void;
+    poker: () => {
+        [k: string]: () => void;
+    };
 };
 export default _default;