functionalscript 0.2.5 → 0.3.0

package/out/crypto/prime_field/module.f.mjs

@@ -1,110 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as Operator from '../../types/function/operator/module.f.mjs';
-import * as bi from '../../types/bigint/module.f.mjs';
-const { scalar_mul } = bi;
-/** @typedef {Operator.Reduce<bigint>} Reduce */
-/** @typedef {Operator.Unary<bigint, bigint>} Unary*/
-/**
- * A type representing a prime field and its associated operations.
- *
- * @typedef {{
- *  readonly p: bigint
- *  readonly middle: bigint
- *  readonly max: bigint
- *  readonly neg: Unary
- *  readonly sub: Reduce
- *  readonly add: Reduce
- *  readonly abs: Unary
- *  readonly mul: Reduce
- *  readonly reciprocal: Unary
- *  readonly div: Reduce
- *  readonly pow: Reduce
- *  readonly pow2: Unary
- *  readonly pow3: Unary
- * }} PrimeField
- */
-/**
- * Creates a prime field with the specified prime modulus and associated operations.
- *
- * @param p - A prime number to define the field.
- * @returns The prime field object.
- *
- * @type {(p: bigint) => PrimeField}
- */
-export const prime_field = p => {
-    /** @type {Reduce} */
-    const sub = a => b => {
-        const r = a - b;
-        return r < 0 ? r + p : r;
-    };
-    /** @type {Reduce} */
-    const mul = a => b => a * b % p;
-    /** @type {Unary} */
-    const reciprocal = a => {
-        if (a === 0n) {
-            throw '1/0';
-        }
-        let a1 = a;
-        let a0 = p;
-        let f0 = 0n;
-        let f1 = 1n;
-        while (a1 !== 1n) {
-            const q = a0 / a1;
-            const a2 = a0 % a1;
-            a0 = a1;
-            a1 = a2;
-            const f2 = sub(f0)(mul(f1)(q));
-            f0 = f1;
-            f1 = f2;
-        }
-        return f1;
-    };
-    const middle = p >> 1n;
-    /** @type {Unary} */
-    const pow2 = a => mul(a)(a);
-    /** @type {Reduce} */
-    const pow = scalar_mul({ 0: 1n, add: mul });
-    return {
-        p,
-        middle,
-        max: p - 1n,
-        neg: a => a === 0n ? 0n : p - a,
-        sub,
-        add: a => b => {
-            const r = a + b;
-            return r < p ? r : r - p;
-        },
-        abs: a => middle < a ? p - a : a,
-        mul,
-        reciprocal,
-        div: a => b => mul(a)(reciprocal(b)),
-        pow,
-        pow2,
-        pow3: a => mul(a)(pow2(a))
-    };
-};
-/**
- * Computes the square root of a number in a prime field.
- *
- * @throws If the prime modulus `p` does not satisfy `p % 4 == 3`.
- *
- * @example
- *
- * ```js
- * const field = prime_field(7n);
- * const root = sqrt(field)(4n);
- * if (root !== 2n) { throw root }
- * ```
- *
- * @type {(f: PrimeField) => (a: bigint) => bigint|null}
- */
-export const sqrt = ({ p, mul, pow }) => {
-    if ((p & 3n) !== 3n) {
-        throw 'sqrt';
-    }
-    const sqrt_k = (p + 1n) >> 2n;
-    return a => {
-        const result = pow(a)(sqrt_k);
-        return mul(result)(result) === a ? result : null;
-    };
-};

package/out/crypto/prime_field/test.f.d.mts

@@ -1,13 +0,0 @@
-declare namespace _default {
-    function prime_field_test(): {
-        neg: () => void;
-        sub: () => void;
-        add: () => void;
-        mul: () => void;
-        reciprocal: () => void;
-        pow: () => void;
-        sqrtExample: () => void;
-        sqrt: () => void;
-    };
-}
-export default _default;

package/out/crypto/prime_field/test.f.mjs

@@ -1,152 +0,0 @@
-import * as _ from './module.f.mjs';
-const { prime_field, sqrt } = _;
-export default {
-    prime_field_test: () => {
-        const p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
-        const f = prime_field(p);
-        const sqrt_f = sqrt(f);
-        return {
-            neg: () => {
-                if (f.neg(0n) !== 0n) {
-                    throw '-0';
-                }
-                if (f.neg(1n) !== p - 1n) {
-                    throw '-1';
-                }
-            },
-            sub: () => {
-                if (f.sub(10n)(4n) !== 6n) {
-                    throw '10 - 4';
-                }
-                if (f.sub(11n)(14n) !== p - 3n) {
-                    throw '11 - 14';
-                }
-            },
-            add: () => {
-                if (f.add(13n)(24n) !== 37n) {
-                    throw '13 + 24';
-                }
-                if (f.add(77n)(f.neg(12n)) !== 65n) {
-                    throw '77 + (-12)';
-                }
-            },
-            mul: () => {
-                if (f.mul(100n)(0n) !== 0n) {
-                    throw '100 * 0';
-                }
-                if (f.mul(101n)(205n) !== 20705n) {
-                    throw '101 * 205';
-                }
-                if (f.mul(304n)(f.neg(1n)) !== f.neg(304n)) {
-                    throw '304 * -1';
-                }
-                if (f.mul(f.neg(507n))(609n) !== f.neg(308763n)) {
-                    throw '-507 * 609';
-                }
-                if (f.mul(f.neg(713n))(f.neg(825n)) !== 588225n) {
-                    throw '-713 * -825';
-                }
-            },
-            reciprocal: () => {
-                let i = 1n;
-                while (i < 10000n) {
-                    const x = f.reciprocal(i);
-                    if (f.mul(x)(i) !== 1n) {
-                        throw i;
-                    }
-                    ++i;
-                }
-            },
-            pow: () => {
-                /** @type {(a: bigint) => void} */
-                const test = a => {
-                    if (f.pow(a)(0n) !== 1n) {
-                        throw '**0';
-                    }
-                    if (f.pow(a)(1n) !== a) {
-                        throw '**1';
-                    }
-                    // https://en.wikipedia.org/wiki/Fermat%27s_little_theorem
-                    // a^(p-1) % p = 1
-                    if (f.abs(f.pow(a)(f.middle)) !== 1n) {
-                        throw '**middle';
-                    }
-                    if (f.pow(a)(f.sub(f.max)(1n)) !== f.reciprocal(a)) {
-                        throw '**(max-1)';
-                    }
-                    if (f.pow(a)(f.max) !== 1n) {
-                        throw '**max';
-                    }
-                };
-                // 0
-                if (f.pow(0n)(0n) !== 1n) {
-                    throw '0**0';
-                }
-                if (f.pow(0n)(f.max) !== 0n) {
-                    throw '0**max';
-                }
-                // 1
-                test(1n);
-                // 2
-                test(2n);
-                if (f.pow(2n)(2n) !== 4n) {
-                    throw '2**2';
-                }
-                if (f.pow(2n)(3n) !== 8n) {
-                    throw '2**3';
-                }
-                if (f.pow(2n)(128n) !== 1n << 128n) {
-                    throw '2**128';
-                }
-                // 3
-                test(3n);
-                if (f.pow(3n)(2n) !== 9n) {
-                    throw '3**2';
-                }
-                if (f.pow(3n)(3n) !== 27n) {
-                    throw '3**3';
-                }
-                if (f.pow(3n)(100n) !== 3n ** 100n) {
-                    throw '3**100';
-                }
-                if (f.pow(3n)(110n) !== 3n ** 110n) {
-                    throw '3**110';
-                }
-                if (f.pow(3n)(120n) !== 3n ** 120n) {
-                    throw '3**120';
-                }
-                if (f.pow(3n)(121n) !== 3n ** 121n) {
-                    throw '3**121';
-                }
-                //
-                test(f.middle);
-                test(f.max - 1n);
-                test(f.max);
-            },
-            sqrtExample: () => {
-                const field = prime_field(7n);
-                const root = sqrt(field)(4n);
-                if (root !== 2n) {
-                    throw root;
-                }
-            },
-            sqrt: () => {
-                /** @type {(a: bigint) => void} */
-                const test = a => {
-                    const a2 = f.mul(a)(a);
-                    const s = sqrt_f(a2);
-                    if (s !== null && f.abs(s) !== f.abs(a)) {
-                        throw 'sqrt';
-                    }
-                };
-                let i = 1n;
-                while (i < 1000n) {
-                    test(i);
-                    ++i;
-                }
-                test(f.middle);
-                test(f.max);
-            }
-        };
-    }
-};

package/out/crypto/secp/module.f.d.mts

@@ -1,110 +0,0 @@
-/**
- * A 2D point represented as a pair of `bigint` values `[x, y]`.
- *
- * @typedef {readonly[bigint, bigint]} Point2D
- */
-/**
- * A 2D point on an elliptic curve, represented as a pair of `bigint` values.
- * `null` represents the point at infinity (`O`).
- *
- * @typedef {Point2D|null} Point
- */
-/**
- * Initialization parameters for an elliptic curve.
- *
- * @typedef {{
- *  readonly p: bigint
- *  readonly a: readonly[bigint, bigint]
- *  readonly g: readonly[bigint, bigint]
- *  readonly n: bigint
- * }} Init
- */
-/**
- * Represents an elliptic curve and its associated operations.
- *
- * @typedef {{
- *  readonly pf: pf.PrimeField
- *  readonly nf: pf.PrimeField
- *  readonly y2: (x: bigint) => bigint
- *  readonly y: (x: bigint) => bigint|null
- *  readonly neg: (a: Point) => Point
- *  readonly add: Operator.Reduce<Point>
- *  readonly mul: (a: Point) => (n: bigint) => Point
- * }} Curve
- */
-/**
- * Constructs an elliptic curve with the given initialization parameters.
- *
- * @example
- *
- * ```js
- * const curveParams = {
- *     p: 23n,
- *     a: [0n, 1n],
- *     g: [1n, 1n],
- *     n: 19n
- * };
- * const curveInstance = curve(curveParams);
- *
- * // Access curve operations
- * const point = curveInstance.add([1n, 1n])([2n, 5n]); // Add two points
- * const negPoint = curveInstance.neg([1n, 1n]); // Negate a point
- * const mulPoint = curveInstance.mul([1n, 1n])(3n); // Multiply a point by 3
- * ```
- *
- * @type {(i: Init) => Curve}
- */
-export const curve: (i: Init) => Curve;
-/** @type {(a: Point) => (b: Point) => boolean} */
-export const eq: (a: Point) => (b: Point) => boolean;
-/**
- * https://neuromancer.sk/std/secg/secp192r1
- *
- * @type {Init}
- */
-export const secp192r1: Init;
-/**
- * https://en.bitcoin.it/wiki/Secp256k1
- * https://neuromancer.sk/std/secg/secp256k1
- *
- * @type {Init}
- */
-export const secp256k1: Init;
-/**
- * https://neuromancer.sk/std/secg/secp256r1
- *
- * @type { Init }
- */
-export const secp256r1: Init;
-/**
- * A 2D point represented as a pair of `bigint` values `[x, y]`.
- */
-export type Point2D = readonly [bigint, bigint];
-/**
- * A 2D point on an elliptic curve, represented as a pair of `bigint` values.
- * `null` represents the point at infinity (`O`).
- */
-export type Point = Point2D | null;
-/**
- * Initialization parameters for an elliptic curve.
- */
-export type Init = {
-    readonly p: bigint;
-    readonly a: readonly [bigint, bigint];
-    readonly g: readonly [bigint, bigint];
-    readonly n: bigint;
-};
-/**
- * Represents an elliptic curve and its associated operations.
- */
-export type Curve = {
-    readonly pf: pf.PrimeField;
-    readonly nf: pf.PrimeField;
-    readonly y2: (x: bigint) => bigint;
-    readonly y: (x: bigint) => bigint | null;
-    readonly neg: (a: Point) => Point;
-    readonly add: Operator.Reduce<Point>;
-    readonly mul: (a: Point) => (n: bigint) => Point;
-};
-import * as pf from '../prime_field/module.f.mjs';
-import * as Operator from '../../types/function/operator/module.f.mjs';

package/out/crypto/secp/module.f.mjs

@@ -1,173 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as Operator from '../../types/function/operator/module.f.mjs';
-import * as pf from '../prime_field/module.f.mjs';
-import * as bi from '../../types/bigint/module.f.mjs';
-const { scalar_mul } = bi;
-const { prime_field, sqrt } = pf;
-/**
- * A 2D point represented as a pair of `bigint` values `[x, y]`.
- *
- * @typedef {readonly[bigint, bigint]} Point2D
- */
-/**
- * A 2D point on an elliptic curve, represented as a pair of `bigint` values.
- * `null` represents the point at infinity (`O`).
- *
- * @typedef {Point2D|null} Point
- */
-/**
- * Initialization parameters for an elliptic curve.
- *
- * @typedef {{
- *  readonly p: bigint
- *  readonly a: readonly[bigint, bigint]
- *  readonly g: readonly[bigint, bigint]
- *  readonly n: bigint
- * }} Init
- */
-/**
- * Represents an elliptic curve and its associated operations.
- *
- * @typedef {{
- *  readonly pf: pf.PrimeField
- *  readonly nf: pf.PrimeField
- *  readonly y2: (x: bigint) => bigint
- *  readonly y: (x: bigint) => bigint|null
- *  readonly neg: (a: Point) => Point
- *  readonly add: Operator.Reduce<Point>
- *  readonly mul: (a: Point) => (n: bigint) => Point
- * }} Curve
- */
-/**
- * Constructs an elliptic curve with the given initialization parameters.
- *
- * @example
- *
- * ```js
- * const curveParams = {
- *     p: 23n,
- *     a: [0n, 1n],
- *     g: [1n, 1n],
- *     n: 19n
- * };
- * const curveInstance = curve(curveParams);
- *
- * // Access curve operations
- * const point = curveInstance.add([1n, 1n])([2n, 5n]); // Add two points
- * const negPoint = curveInstance.neg([1n, 1n]); // Negate a point
- * const mulPoint = curveInstance.mul([1n, 1n])(3n); // Multiply a point by 3
- * ```
- *
- * @type {(i: Init) => Curve}
- */
-export const curve = ({ p, a: [a0, a1], n }) => {
-    const pf = prime_field(p);
-    const { pow2, pow3, sub, add, mul, neg, div } = pf;
-    const mul3 = mul(3n);
-    const mul2 = mul(2n);
-    const addA1 = add(a1);
-    const mulA1 = mul(a1);
-    const addA0 = add(a0);
-    // y**2 = a1*x**3 + a0
-    /** @type {(x: bigint) => bigint} */
-    const y2 = x => addA0(add(pow3(x))(mulA1(x)));
-    /** @type {Operator.Reduce<Point>} */
-    const addPoint = p => q => {
-        if (p === null) {
-            return q;
-        }
-        if (q === null) {
-            return p;
-        }
-        const [px, py] = p;
-        const [qx, qy] = q;
-        const md = px === qx
-            // (3 * px ** 2 + a1) / (2 * py)
-            ? py !== qy || py === 0n ? null : [addA1(mul3(pow2(px))), mul2(py)]
-            // (py - qy) / (px - qx)
-            : [sub(py)(qy), sub(px)(qx)];
-        if (md === null) {
-            return null;
-        }
-        const [ma, mb] = md;
-        const m = div(ma)(mb);
-        // m ** 2 - px - qx
-        const rx = sub(pow2(m))(add(px)(qx));
-        // [rx, m * (px - rx) - py]
-        return [rx, sub(mul(m)(sub(px)(rx)))(py)];
-    };
-    const sqrt_p = sqrt(pf);
-    return {
-        pf,
-        nf: prime_field(n),
-        y2,
-        y: x => sqrt_p(y2(x)),
-        neg: p => {
-            if (p === null) {
-                return null;
-            }
-            const [x, y] = p;
-            return [x, neg(y)];
-        },
-        add: addPoint,
-        mul: scalar_mul({ 0: null, add: addPoint })
-    };
-};
-/** @type {(a: Point) => (b: Point) => boolean} */
-export const eq = a => b => {
-    if (a === null || b === null) {
-        return a === b;
-    }
-    const [ax, ay] = a;
-    const [bx, by] = b;
-    return ax === bx && ay === by;
-};
-/**
- * https://neuromancer.sk/std/secg/secp192r1
- *
- * @type {Init}
- */
-export const secp192r1 = {
-    p: 0xfffffffffffffffffffffffffffffffeffffffffffffffffn,
-    a: [
-        0x64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1n,
-        0xfffffffffffffffffffffffffffffffefffffffffffffffcn
-    ],
-    g: [
-        0x188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012n,
-        0x07192b95ffc8da78631011ed6b24cdd573f977a11e794811n
-    ],
-    n: 0xffffffffffffffffffffffff99def836146bc9b1b4d22831n,
-};
-/**
- * https://en.bitcoin.it/wiki/Secp256k1
- * https://neuromancer.sk/std/secg/secp256k1
- *
- * @type {Init}
- */
-export const secp256k1 = {
-    p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn,
-    a: [7n, 0n],
-    g: [
-        0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798n,
-        0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8n
-    ],
-    n: 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n,
-};
-/**
- * https://neuromancer.sk/std/secg/secp256r1
- *
- * @type { Init }
- */
-export const secp256r1 = {
-    p: 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffffn,
-    a: [
-        0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604bn, //< b
-        0xffffffff00000001000000000000000000000000fffffffffffffffffffffffcn, //< a
-    ],
-    g: [
-        0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296n, //< x
-        0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5n, //< y
-    ],
-    n: 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n,
-};

package/out/crypto/secp/test.f.d.mts

@@ -1,5 +0,0 @@
-declare namespace _default {
-    function example(): void;
-    function test(): void;
-}
-export default _default;

package/out/crypto/secp/test.f.mjs

@@ -1,78 +0,0 @@
-import * as _ from './module.f.mjs';
-const { curve, secp256k1, secp192r1, secp256r1, eq } = _;
-export default {
-    example: () => {
-        /** @type {_.Init} */
-        const curveParams = {
-            p: 23n,
-            a: [0n, 1n],
-            g: [1n, 1n],
-            n: 19n
-        };
-        const c = curve(curveParams);
-        // Access curve operations
-        const point = c.add([1n, 1n])([2n, 5n]); // Add two points
-        const negPoint = c.neg([1n, 1n]); // Negate a point
-        const mulPoint = c.mul([1n, 1n])(3n); // Multiply a point by 3
-    },
-    test: () => {
-        /** @type {(c: _.Init) => void} */
-        const test_curve = c => {
-            const { g } = c;
-            const { mul, neg, pf: { abs }, y: yf, nf: { p: n } } = curve(c);
-            /** @type {(p: _.Point) => void} */
-            const point_check = p => {
-                if (p === null) {
-                    throw 'p === null';
-                }
-                const [x, y] = p;
-                const ye = yf(x);
-                if (ye === null) {
-                    throw 'ye === null';
-                }
-                if (abs(ye) !== abs(y)) {
-                    throw 'ye';
-                }
-            };
-            point_check(g);
-            point_check(neg(g));
-            /** @type {(p: _.Point) => void} */
-            const test_mul = p => {
-                if (mul(p)(0n) !== null) {
-                    throw 'O';
-                }
-                if (mul(p)(1n) !== p) {
-                    throw 'p';
-                }
-                if (mul(p)(n) !== null) {
-                    throw 'n';
-                }
-                const pn = neg(p);
-                if (!eq(mul(p)(n - 1n))(pn)) {
-                    throw 'n - 1';
-                }
-                /** @type {(s: bigint) => void} */
-                const f = s => {
-                    const r = mul(p)(s);
-                    point_check(r);
-                    const rn = mul(pn)(s);
-                    point_check(rn);
-                    if (!eq(r)(neg(rn))) {
-                        throw 'r != -rn';
-                    }
-                };
-                f(2n);
-                f(3n);
-                f(4n << 128n);
-                f((5n << 128n) + 6n);
-                f(7n << 128n);
-                f((8n << 128n) + 9n);
-            };
-            test_mul(g);
-            test_mul(neg(g));
-        };
-        test_curve(secp256k1);
-        test_curve(secp192r1);
-        test_curve(secp256r1);
-    }
-};

package/out/crypto/sha2/module.f.d.mts

@@ -1,15 +0,0 @@
-/** @type  {(input: readonly number[]) => (bits: number) => HashInput} */
-export const padding: (input: readonly number[]) => (bits: number) => HashInput;
-/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-export const computeSha256: (input: readonly number[]) => (bitsCount: number) => Hash8;
-/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-export const computeSha224: (input: readonly number[]) => (bitsCount: number) => Hash8;
-export const compress256: (data: Array16) => Hash8;
-export const compress224: (data: Array16) => Hash8;
-export type HashInput = {
-    readonly f: (i: number) => number;
-    readonly length: number;
-};
-export type Hash8 = array.Array8<number>;
-export type Array16 = array.Array16<number>;
-import * as array from '../../types/array/module.f.mjs';