functionalscript 0.2.6 → 0.3.1

package/crypto/prime_field/{test.f.mjs → test.f.ts}

@@ -1,4 +1,4 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 const { prime_field, sqrt } = _
 
 export default {
@@ -35,8 +35,9 @@ export default {
                 }
             },
             pow: () => {
-                /** @type {(a: bigint) => void} */
-                const test = a => {
+                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
@@ -74,8 +75,9 @@ export default {
                 if (root !== 2n) { throw root }
             },
             sqrt: () => {
-                /** @type {(a: bigint) => void} */
-                const test = a => {
+                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' }

package/crypto/secp/{module.f.mjs → module.f.ts}

@@ -1,47 +1,42 @@
-// @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'
+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]`.
- *
- * @typedef {readonly[bigint, bigint]} Point2D
  */
+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`).
- *
- * @typedef {Point2D|null} Point
  */
+export type Point = Point2D|null
 
 /**
  * Initialization parameters for an elliptic curve.
- *
- * @typedef {{
- *  readonly p: bigint
- *  readonly a: readonly[bigint, bigint]
- *  readonly g: readonly[bigint, bigint]
- *  readonly n: bigint
- * }} Init
  */
+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.
- *
- * @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
  */
+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.
@@ -62,10 +57,10 @@ const { prime_field, sqrt } = pf
  * 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 }) => {
+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)
@@ -73,11 +68,15 @@ export const curve = ({ p, a: [a0, a1], n }) => {
     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 => {
+    /**
+     * 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
         }
@@ -119,8 +118,9 @@ export const curve = ({ p, a: [a0, a1], n }) => {
     }
 }
 
-/** @type {(a: Point) => (b: Point) => boolean} */
-export const eq = a => b => {
+export const eq
+    : (a: Point) => (b: Point) => boolean
+    = a => b => {
     if (a === null || b === null) {
         return a === b
     }
@@ -131,10 +131,10 @@ export const eq = a => b => {
 
 /**
  * https://neuromancer.sk/std/secg/secp192r1
- *
- * @type {Init}
  */
-export const secp192r1 = {
+export const secp192r1
+    : Init
+    = {
     p: 0xffffffff_ffffffff_ffffffff_fffffffe_ffffffff_ffffffffn,
     a: [
         0x64210519_e59c80e7_0fa7e9ab_72243049_feb8deec_c146b9b1n,
@@ -150,10 +150,10 @@ export const secp192r1 = {
 /**
  * https://en.bitcoin.it/wiki/Secp256k1
  * https://neuromancer.sk/std/secg/secp256k1
- *
- * @type {Init}
  */
-export const secp256k1 = {
+export const secp256k1
+    : Init
+    = {
     p: 0xffffffff_ffffffff_ffffffff_ffffffff_ffffffff_ffffffff_fffffffe_fffffc2fn,
     a: [7n, 0n],
     g: [
@@ -165,10 +165,10 @@ export const secp256k1 = {
 
 /**
  * https://neuromancer.sk/std/secg/secp256r1
- *
- * @type { Init }
  */
-export const secp256r1 ={
+export const secp256r1
+    : Init
+    = {
     p: 0xffffffff_00000001_00000000_00000000_00000000_ffffffff_ffffffff_ffffffffn,
     a: [
         0x5ac635d8_aa3a93e7_b3ebbd55_769886bc_651d06b0_cc53b0f6_3bce3c3e_27d2604bn, //< b

package/crypto/secp/{test.f.mjs → test.f.ts}

@@ -1,10 +1,11 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 const { curve, secp256k1, secp192r1, secp256r1, eq } = _
 
 export default {
     example: () => {
-        /** @type {_.Init} */
-        const curveParams = {
+        const curveParams
+            : _.Init
+            = {
             p: 23n,
             a: [0n, 1n],
             g: [1n, 1n],
@@ -17,12 +18,14 @@ export default {
         const mulPoint = c.mul([1n, 1n])(3n); // Multiply a point by 3
     },
     test: () => {
-        /** @type {(c: _.Init) => void} */
-        const test_curve = c => {
+        const test_curve
+            : (c: _.Init) => void
+            = c => {
             const { g } = c
             const { mul, neg, pf: { abs }, y: yf, nf: { p: n } } = curve(c)
-            /** @type {(p: _.Point) => void} */
-            const point_check = p => {
+            const point_check
+                : (p: _.Point) => void
+                = p => {
                 if (p === null) { throw 'p === null' }
                 const [x, y] = p
                 const ye = yf(x)
@@ -31,15 +34,17 @@ export default {
             }
             point_check(g)
             point_check(neg(g))
-            /** @type {(p: _.Point) => void} */
-            const test_mul = p => {
+            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' }
-                /** @type {(s: bigint) => void} */
-                const f = s => {
+                const f
+                    : (s: bigint) => void
+                    = s => {
                     const r = mul(p)(s)
                     point_check(r)
                     const rn = mul(pn)(s)

package/crypto/sha2/{module.f.mjs → module.f.ts}

@@ -1,29 +1,30 @@
-// @ts-self-types="./module.f.d.mts"
-import * as array from '../../types/array/module.f.mjs'
+import * as array from '../../types/array/module.f.ts'
 
-/**
- * @typedef {{
- *  readonly f: (i: number) => number
- *  readonly length: number
- * }} HashInput
- */
+type HashInput = {
+    readonly f: (i: number) => number
+    readonly length: number
+}
 
-/** @typedef {array.Array8<number>} Hash8 */
+type Hash8 = array.Array8<number>
 
-/** @typedef {array.Array16<number>} Array16 */
+type Array16 = array.Array16<number>
 
-/** @type {(input: number) => (pos: number) => number} */
-const appendOneWithZeros = input => pos => (input >> pos << pos) | (1 << pos)
+const appendOneWithZeros
+    : (input: number) => (pos: number) => number
+    = input => pos => (input >> pos << pos) | (1 << pos)
 
-/** @type {(input: number) => (pos: number) => number} */
-const mod = a => b => (a % b + b) % b
+const mod
+    : (input: number) => (pos: number) => number
+    = a => b => (a % b + b) % b
 
-/** @type  {(input: readonly number[]) => (bits: number) => HashInput} */
-export const padding = input => bitsCount => {
+export const padding
+    : (input: readonly number[]) => (bits: number) => HashInput
+    = input => bitsCount => {
     const appendBlockIndex = (bitsCount / 32) | 0
     const length = (bitsCount + mod(447 - bitsCount)(512) + 65) / 32
-    /** @type {(i: number) => number} */
-    const f = i => {
+    const f
+        : (i: number) => number
+        = i => {
         if (i < appendBlockIndex) { return input[i] }
         if (i === appendBlockIndex) {
             return appendBlockIndex >= input.length ? 0x8000_0000 : appendOneWithZeros(input[appendBlockIndex])(31 - bitsCount % 32)
@@ -35,23 +36,28 @@ export const padding = input => bitsCount => {
     return ({ f, length })
 }
 
-/** @type {(d: number) => (n: number) => number} */
-const rotr = d => {
+const rotr
+    : (d: number) => (n: number) => number
+    = 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
+const ch
+    : (x: number) => (y: number) => (z: number) => number
+    = 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
+const maj
+    : (x: number) => (y: number) => (z: number) => number
+    = x => y => z => x & y ^ x & z ^ y & z
 
-/** @type {(d: number) => (n: number) => number} */
-const shr = d => n => n >>> d
+const shr
+    : (d: number) => (n: number) => number
+    = d => n => n >>> d
 
-/** @type {(a: number) => (b: number) => (c: number) => (x: number) => number} */
-const bigSigma = a => b => c => {
+const bigSigma
+    : (a: number) => (b: number) => (c: number) => (x: number) => number
+    = a => b => c => {
     const ra = rotr(a)
     const rb = rotr(b)
     const rc = rotr(c)
@@ -62,8 +68,9 @@ 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 smallSigma
+    : (a: number) => (b: number) => (c: number) => (x: number) => number
+    = a => b => c => {
     const ra = rotr(a)
     const rb = rotr(b)
     const sc = shr(c)
@@ -74,11 +81,13 @@ const smallSigma0 = smallSigma(7)(18)(3)
 
 const smallSigma1 = smallSigma(17)(19)(10)
 
-/** @type {(a: array.Array4<number>) => number} */
-const wi = ([a0, a1, a2, a3]) => (smallSigma1(a0) + a1 + smallSigma0(a2) + a3) | 0
+const wi
+    : (a: array.Array4<number>) => number
+    = ([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]) => {
+const nextW
+    : (w: Array16) => Array16
+    = ([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])
@@ -117,8 +126,9 @@ const k = [
     ],
 ];
 
-/** @type {(init: Hash8) => (data: Array16) => Hash8} */
-const compress = ([a0, b0, c0, d0, e0, f0, g0, h0]) => data => {
+const compress
+    : (init: Hash8) => (data: Array16) => Hash8
+    = ([a0, b0, c0, d0, e0, f0, g0, h0]) => data => {
     let w = data
 
     let a = a0
@@ -162,8 +172,9 @@ const compress = ([a0, b0, c0, d0, e0, f0, g0, h0]) => data => {
     ]
 }
 
-/** @type {(init: Hash8) => (input: readonly number[]) => (bitsCount: number) => Hash8} */
-const compute = init => input => bitsCount => {
+const compute
+    : (init: Hash8) => (input: readonly number[]) => (bitsCount: number) => Hash8
+    = init => input => bitsCount => {
     const { f, length } = padding(input)(bitsCount)
 
     let result = init
@@ -179,17 +190,21 @@ const compute = init => input => bitsCount => {
     return result
 }
 
-/** @type {Hash8} */
-const init256 = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]
+const init256
+    : Hash8
+    = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]
 
-/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-export const computeSha256 = compute(init256)
+export const computeSha256
+    : (input: readonly number[]) => (bitsCount: number) => Hash8
+    = compute(init256)
 
-/** @type {Hash8} */
-const init224 = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4]
+const init224
+    : Hash8
+    = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4]
 
-/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-export const computeSha224 = compute(init224)
+export const computeSha224
+    : (input: readonly number[]) => (bitsCount: number) => Hash8
+    = compute(init224)
 
 export const compress256 = compress(init256)
 

package/crypto/sha2/{test.f.mjs → test.f.ts}

@@ -1,16 +1,19 @@
-import * as _ from './module.f.mjs'
-import * as json from '../../json/module.f.mjs'
-import * as o from '../../types/object/module.f.mjs'
+import * as _ from './module.f.ts'
+import * as json from '../../json/module.f.ts'
+import * as o from '../../types/object/module.f.ts'
 const { sort } = o
 
-/** @type {(a: number) => number} */
-const toU32 = x => (x + 0x1_0000_0000) % 0x1_0000_0000
+const toU32
+    : (a: number) => number
+    = x => (x + 0x1_0000_0000) % 0x1_0000_0000
 
-/** @type {(a: number) => string} */
-const toHexString = x => toU32(x).toString(16).padStart(8, '0')
+const toHexString
+    : (a: number) => string
+    = x => toU32(x).toString(16).padStart(8, '0')
 
-/** @type {(a: readonly json.Unknown[]) => string} */
-const stringify = a => json.stringify(sort)(a)
+const stringify
+    : (a: readonly json.Unknown[]) => string
+    = a => json.stringify(sort)(a)
 
 // {
 //     const result = _.padding([])(0)

package/deno.json

@@ -0,0 +1,71 @@
+{
+  "name": "@functionalscript/functionalscript",
+  "version": "0.3.1",
+  "license": "AGPL-3.0-only",
+  "exports": {
+    "./com/cpp": "./com/cpp/module.f.ts",
+    "./com/cs": "./com/cs/module.f.ts",
+    "./com/rust": "./com/rust/module.f.ts",
+    "./com/types": "./com/types/module.f.ts",
+    "./commonjs/build": "./commonjs/build/module.f.ts",
+    "./commonjs": "./commonjs/module.f.ts",
+    "./commonjs/module/function": "./commonjs/module/function/module.f.ts",
+    "./commonjs/module": "./commonjs/module/module.f.ts",
+    "./commonjs/package/dependencies": "./commonjs/package/dependencies/module.f.ts",
+    "./commonjs/package": "./commonjs/package/module.f.ts",
+    "./commonjs/path": "./commonjs/path/module.f.ts",
+    "./crypto/prime_field": "./crypto/prime_field/module.f.ts",
+    "./crypto/secp": "./crypto/secp/module.f.ts",
+    "./crypto/sha2": "./crypto/sha2/module.f.ts",
+    "./dev": "./dev/module.f.ts",
+    "./dev/test": "./dev/test/module.f.ts",
+    "./djs": "./djs/module.f.ts",
+    "./djs/parser": "./djs/parser/module.f.ts",
+    "./djs/serializer": "./djs/serializer/module.f.ts",
+    "./djs/tokenizer": "./djs/tokenizer/module.f.ts",
+    "./fsc": "./fsc/module.f.ts",
+    "./fsm": "./fsm/module.f.ts",
+    "./html": "./html/module.f.ts",
+    "./js/tokenizer": "./js/tokenizer/module.f.ts",
+    "./json": "./json/module.f.ts",
+    "./json/parser": "./json/parser/module.f.ts",
+    "./json/serializer": "./json/serializer/module.f.ts",
+    "./json/tokenizer": "./json/tokenizer/module.f.ts",
+    "./nodejs/version": "./nodejs/version/module.f.ts",
+    "./text/ascii": "./text/ascii/module.f.ts",
+    "./text": "./text/module.f.ts",
+    "./text/sgr": "./text/sgr/module.f.ts",
+    "./text/utf16": "./text/utf16/module.f.ts",
+    "./text/utf8": "./text/utf8/module.f.ts",
+    "./types/array": "./types/array/module.f.ts",
+    "./types/bigfloat": "./types/bigfloat/module.f.ts",
+    "./types/bigint": "./types/bigint/module.f.ts",
+    "./types/bit_vec": "./types/bit_vec/module.f.ts",
+    "./types/btree/find": "./types/btree/find/module.f.ts",
+    "./types/btree": "./types/btree/module.f.ts",
+    "./types/btree/remove": "./types/btree/remove/module.f.ts",
+    "./types/btree/set": "./types/btree/set/module.f.ts",
+    "./types/btree/types": "./types/btree/types/module.f.ts",
+    "./types/byte_set": "./types/byte_set/module.f.ts",
+    "./types/function/compare": "./types/function/compare/module.f.ts",
+    "./types/function": "./types/function/module.f.ts",
+    "./types/function/operator": "./types/function/operator/module.f.ts",
+    "./types/list": "./types/list/module.f.ts",
+    "./types/map": "./types/map/module.f.ts",
+    "./types/nibble_set": "./types/nibble_set/module.f.ts",
+    "./types/nullable": "./types/nullable/module.f.ts",
+    "./types/number": "./types/number/module.f.ts",
+    "./types/object": "./types/object/module.f.ts",
+    "./types/range": "./types/range/module.f.ts",
+    "./types/range_map": "./types/range_map/module.f.ts",
+    "./types/result": "./types/result/module.f.ts",
+    "./types/sorted_list": "./types/sorted_list/module.f.ts",
+    "./types/sorted_set": "./types/sorted_set/module.f.ts",
+    "./types/string": "./types/string/module.f.ts",
+    "./types/string_set": "./types/string_set/module.f.ts"
+  },
+  "tasks": {
+    "doc": "deno doc --html **/module.f.ts",
+    "test": "deno run --quiet --allow-read --allow-env --allow-net ./dev/test.ts"
+  }
+}

package/dev/README.md

@@ -0,0 +1,8 @@
+# Test Framework
+
+The main principle is that tests don't depend on test framework. We use conventions instead.
+
+## Conventions
+
+- file name 'test.f.*',
+- parsing default exports.

package/dev/index.ts

@@ -0,0 +1,3 @@
+import { index } from "./module.ts"
+
+index()

package/dev/{module.f.mjs → module.f.ts}

@@ -1,3 +1 @@
-// @ts-self-types="./module.f.d.mts"
-
 export const todo = () => { throw 'not implemented' }