functionalscript 0.3.4 → 0.3.5

package/commonjs/path/module.f.ts

@@ -1,171 +0,0 @@
-import * as list from '../../types/list/module.f.ts'
-const { next, fold, reverse, first, flat, toArray, filterMap, isEmpty, concat } = list
-import * as string from '../../types/string/module.f.ts'
-const { join } = string
-import * as Package from '../package/module.f.ts'
-import * as Module from '../module/module.f.ts'
-
-type Items = readonly string[]
-
-type LocalPath = {
-    readonly external: boolean
-    readonly dir: boolean
-    readonly items: Items
-}
-
-const split
-    : (path: string) => readonly string[]
-    = path => path.split('/')
-
-type OptionList = readonly[list.List<string>] | null
-
-const normItemsOp
-    : (items: string) => (prior: OptionList) => OptionList
-    = first => prior => {
-    if (prior === null) { return null }
-    const tail = prior[0]
-    switch (first) {
-        case '': case '.': { return prior }
-        case '..': {
-            const result = next(tail)
-            if (result === null) { return null }
-            return [result.tail]
-        }
-        default: {
-            return [{ first, tail }]
-        }
-    }
-}
-
-const normItems
-    : (items: list.List<string>) => OptionList
-    = items => {
-    const result = fold(normItemsOp)([list.empty])(items)
-    return result === null ? result : [reverse(result[0])]
-}
-
-const firstNull = first(null)
-
-export const parseLocal
-    : (local: string) => (path: string) => LocalPath|null
-    = local => {
-    const fSeq
-        : (path: string) => readonly[boolean, boolean, list.List<string>]
-        = path => {
-        const pathSeq = split(path)
-        const dir = [null, '', '.', '..'].includes(pathSeq[pathSeq.length - 1])
-        return (['.', '..'] as readonly (string|null)[]).includes(firstNull(pathSeq)) ?
-            [false, dir, flat([split(local), pathSeq])] :
-            [true, dir, pathSeq]
-    }
-    // /** @type {(path: string) => LocalPath|null} */
-    return path => {
-        const [external, dir, items] = fSeq(path)
-        const n = normItems(items)
-        if (n === null) { return null }
-        return {
-            external,
-            dir,
-            items: toArray(n[0])
-        }
-    }
-}
-
-type IdPath = readonly[string, list.List<string>]
-
-/** @type {} */
-const variants
-    : (prior: readonly[string|null, list.List<string>]) => list.Thunk<IdPath>
-    = prior => () => {
-    const [a, b] = prior
-    const r = next(b)
-    if (r === list.empty) { return list.empty }
-    const { first, tail } = r
-    const n
-        : IdPath
-        = [a === null ? first : `${a}/${first}`, tail]
-    return { first: n, tail: variants(n) }
-}
-
-const mapDependency
-    : (d: (local: string) => string|null) => (p: IdPath) => IdPath|null
-    = d => ([external, internal]) => {
-    const id = d(external)
-    return id === null ? null : [id, internal]
-}
-
-type Path = {
-    readonly package: string,
-    readonly items: Items,
-    readonly dir: boolean,
-}
-
-/**
- * @type {}
- */
-export const parseGlobal
-    :   (d: (local: string) => string|null) =>
-        (dir: boolean) =>
-        (items: list.List<string>) =>
-        Path|null
-    = dependencies =>
-{
-    const fMap = filterMap(mapDependency(dependencies))
-    return dir => items => {
-        const v = variants([null, items])
-        const r = firstNull(fMap(v))
-        if (r === null) { return null }
-        return { package: r[0], items: toArray(r[1]), dir }
-    }
-}
-
-/**
- * @type { }
- */
-export const parse
-    :   (packageId: string) =>
-        (dependencies: (local: string) => string|null) =>
-        (local: string) =>
-        (path: string) =>
-        Path|null
-    = packageId => dependencies => {
-    const pg = parseGlobal(dependencies)
-    return local => path => {
-        const parsed = parseLocal(local)(path)
-        if (parsed === null) { return null }
-        const {external, dir, items } = parsed
-        if (!external) { return { package: packageId, items, dir } }
-        return pg(dir)(items)
-    }
-}
-
-type FoundResult = {
-    readonly id: Module.Id
-    readonly source: string
-}
-
-type Result = FoundResult| null
-
-export const parseAndFind
-    :   (packageGet: Package.Get) =>
-        (moduleId: Module.Id) =>
-        (path: string) =>
-        Result
-    = packageGet => moduleId => path => {
-    const currentPack = packageGet(moduleId.package)
-    if (currentPack === null) { return null }
-    const p = parse(moduleId.package)(currentPack.dependency)(moduleId.path.join('/'))(path)
-    if (p === null) { return null }
-    const pack = packageGet(p.package)
-    if (pack === null) { return null }
-    const tryFile
-        : (file: string) => FoundResult | null
-        = file => {
-        const source = pack.file(file)
-        return source === null ? null : { id: { package: p.package, path: file.split('/') }, source }
-    }
-    const file = p.items.join('/')
-    const indexJs = join('/')(concat(p.items)(['index.js']))
-    const fileList = p.dir || isEmpty(p.items) ? [indexJs] : [file, `${file}.js`, indexJs]
-    return firstNull(filterMap(tryFile)(fileList))
-}

package/commonjs/test.ts

@@ -1,64 +0,0 @@
-import * as _ from './module.ts'
-import * as Run from './module/function/module.f.ts'
-
-export default {
-    ok: () => {
-        const source = 'module.exports = "Hello world!"'
-        const m = _.compile(source)
-        if (m[0] !== 'ok') { throw m }
-        const [result] = m[1](() => { throw 0 })(null)
-        if (result[0] !== 'ok') { throw result }
-        if (result[1] !== 'Hello world!') { throw result }
-    },
-    compilationError: () => {
-        const source = '+'
-        const m = _.compile(source)
-        if (m[0] !== 'error') { throw m }
-    },
-    compilationErrorStrict: () => {
-        const source = 'const x = 04'
-        const m = _.compile(source)
-        if (m[0] !== 'error') { throw m }
-    },
-    runtimeError: () => {
-        const source = 'a = 5'
-        const m = _.compile(source)
-        if (m[0] !== 'ok') { throw m }
-        const [result] = m[1](() => { throw 0 })(null)
-        if (result[0] !== 'error') { throw result }
-    },
-    test: () => {
-        const depSource = 'module.exports = 137'
-        const d = _.compile(depSource)
-        if (d[0] !== 'ok') { throw d }
-
-        const req
-            : Run.Require<number>
-            = path => prior => {
-            if (path !== 'm') { throw path }
-            return d[1](req)(prior + 1)
-        }
-
-        let info = 0
-        {
-            const source = 'module.exports = require("m") + 42'
-            const m = _.compile(source)
-            if (m[0] !== 'ok') { throw m }
-
-            const [result, newInfo] = m[1](req)(info)
-            if (result[0] !== 'ok') { throw result }
-            if (result[1] !== 179) { throw result }
-            info = newInfo
-        }
-
-        {
-            const source = 'module.exports = require("x") + 42'
-            const m = _.compile(source)
-            if (m[0] !== 'ok') { throw m }
-
-            const [result, infox] = m[1](req)(info)
-            if (result[0] !== 'error') { throw result }
-            if (infox !== 1) { throw info }
-        }
-    }
-}

package/crypto/README.md

@@ -1,3 +0,0 @@
-# Cryptography
-
-The directory contains algorithms and utilities for various cryptographic methods.

package/crypto/prime_field/module.f.ts

@@ -1,114 +0,0 @@
-import * as Operator from '../../types/function/operator/module.f.ts'
-import * as bi from '../../types/bigint/module.f.ts'
-const { scalar_mul } = bi
-
-type Reduce = Operator.Reduce<bigint>
-
-type Unary = Operator.Unary<bigint, bigint>
-
-/**
- * A type representing a prime field and its associated operations.
- */
-export type PrimeField = {
-    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
-}
-
-/**
- * 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.
- */
-export const prime_field
-    : (p: bigint) => PrimeField
-    = p => {
-    const sub
-        : Reduce
-        = a => b => {
-        const r = a - b
-        return r < 0 ? r + p : r
-    }
-    const mul
-        : Reduce
-        = a => b => a * b % p
-    const reciprocal
-        : Unary
-        = 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
-    const pow2
-        : Unary
-        = a => mul(a)(a)
-    const pow
-        : Reduce
-        = 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 }
- * ```
- */
-export const sqrt
-    : (f: PrimeField) => (a: bigint) => bigint|null
-    = ({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/crypto/prime_field/test.f.ts

@@ -1,95 +0,0 @@
-import * as _ from './module.f.ts'
-const { prime_field, sqrt } = _
-
-export default {
-    prime_field_test: () => {
-        const p = 0xffffffff_ffffffff_ffffffff_ffffffff_ffffffff_ffffffff_fffffffe_fffffc2fn;
-        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) !== 20_705n) { 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(308_763n)) { throw '-507 * 609' }
-                if (f.mul(f.neg(713n))(f.neg(825n)) !== 588_225n) { throw '-713 * -825' }
-            },
-            reciprocal: () => {
-                let i = 1n
-                while (i < 10_000n) {
-                    const x = f.reciprocal(i)
-                    if (f.mul(x)(i) !== 1n) { throw i }
-                    ++i
-                }
-            },
-            pow: () => {
-                const test
-                    : (a: bigint) => void
-                    = 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: () => {
-                const test
-                    : (a: bigint) => void
-                    = 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/crypto/secp/module.f.ts

@@ -1,182 +0,0 @@
-import * as Operator from '../../types/function/operator/module.f.ts'
-import * as pf from '../prime_field/module.f.ts'
-import * as bi from '../../types/bigint/module.f.ts'
-const { scalar_mul } = bi
-const { prime_field, sqrt } = pf
-
-/**
- * A 2D point represented as a pair of `bigint` values `[x, y]`.
- */
-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.
- */
-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
-}
-
-/**
- * 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
- * ```
- */
-export const curve
-    : (i: Init) => 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
-     */
-    const y2
-        : (x: bigint) => bigint
-        = x => addA0(add(pow3(x))(mulA1(x)))
-    const addPoint
-        : Operator.Reduce<Point>
-        = 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 })
-    }
-}
-
-export const eq
-    : (a: Point) => (b: Point) => boolean
-    = 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
- */
-export const secp192r1
-    : Init
-    = {
-    p: 0xffffffff_ffffffff_ffffffff_fffffffe_ffffffff_ffffffffn,
-    a: [
-        0x64210519_e59c80e7_0fa7e9ab_72243049_feb8deec_c146b9b1n,
-        0xffffffff_ffffffff_ffffffff_fffffffe_ffffffff_fffffffcn
-    ],
-    g: [
-        0x188da80e_b03090f6_7cbf20eb_43a18800_f4ff0afd_82ff1012n,
-        0x07192b95_ffc8da78_631011ed_6b24cdd5_73f977a1_1e794811n
-    ],
-    n: 0xffffffff_ffffffff_ffffffff_99def836_146bc9b1_b4d22831n,
-}
-
-/**
- * https://en.bitcoin.it/wiki/Secp256k1
- * https://neuromancer.sk/std/secg/secp256k1
- */
-export const secp256k1
-    : Init
-    = {
-    p: 0xffffffff_ffffffff_ffffffff_ffffffff_ffffffff_ffffffff_fffffffe_fffffc2fn,
-    a: [7n, 0n],
-    g: [
-        0x79be667e_f9dcbbac_55a06295_ce870b07_029bfcdb_2dce28d9_59f2815b_16f81798n,
-        0x483ada77_26a3c465_5da4fbfc_0e1108a8_fd17b448_a6855419_9c47d08f_fb10d4b8n
-    ],
-    n: 0xffffffff_ffffffff_ffffffff_fffffffe_baaedce6_af48a03b_bfd25e8c_d0364141n,
-}
-
-/**
- * https://neuromancer.sk/std/secg/secp256r1
- */
-export const secp256r1
-    : Init
-    = {
-    p: 0xffffffff_00000001_00000000_00000000_00000000_ffffffff_ffffffff_ffffffffn,
-    a: [
-        0x5ac635d8_aa3a93e7_b3ebbd55_769886bc_651d06b0_cc53b0f6_3bce3c3e_27d2604bn, //< b
-        0xffffffff_00000001_00000000_00000000_00000000_ffffffff_ffffffff_fffffffcn, //< a
-    ],
-    g: [
-        0x6b17d1f2_e12c4247_f8bce6e5_63a440f2_77037d81_2deb33a0_f4a13945_d898c296n, //< x
-        0x4fe342e2_fe1a7f9b_8ee7eb4a_7c0f9e16_2bce3357_6b315ece_cbb64068_37bf51f5n, //< y
-    ],
-    n: 0xffffffff_00000000_ffffffff_ffffffff_bce6faad_a7179e84_f3b9cac2_fc632551n,
-}

package/crypto/secp/test.f.ts

@@ -1,68 +0,0 @@
-import * as _ from './module.f.ts'
-const { curve, secp256k1, secp192r1, secp256r1, eq } = _
-
-export default {
-    example: () => {
-        const curveParams
-            : _.Init
-            = {
-            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: () => {
-        const test_curve
-            : (c: _.Init) => void
-            = c => {
-            const { g } = c
-            const { mul, neg, pf: { abs }, y: yf, nf: { p: n } } = curve(c)
-            const point_check
-                : (p: _.Point) => void
-                = 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))
-            const test_mul
-                : (p: _.Point) => void
-                = 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' }
-                const f
-                    : (s: bigint) => void
-                    = 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)
-    }
-}