functionalscript 0.1.608 → 0.2.0

package/nanvm-lib/tests/test.f.mjs

@@ -0,0 +1,79 @@
+/** @type {(a: unknown) => (b: unknown) => void} */
+const e = a => b => {
+    if (a === b) { } else { throw [a, '===', b] }
+}
+
+/** @type {(a: unknown) => (b: unknown) => void} */
+const n = a => b => {
+    if (a !== b) { } else { throw [a, '!==', b] }
+}
+
+export default {
+    eq: {
+        nullish: () => {
+            e(null)(null)
+            e(undefined)(undefined)
+            n(null)(undefined)
+        },
+        boolean: {
+            boolean: () => {
+                e(true)(true)
+                e(false)(false)
+                n(true)(false)
+            },
+            nullish: () => {
+                n(false)(undefined)
+            }
+        },
+        number: {
+            number: () => {
+                e(2.3)(2.3)
+                n(2.3)(-5.4)
+                n(NaN)(NaN)
+                e(0)(-0)
+                if (!Object.is(-0, -0)) { throw -0 }
+                if (Object.is(0, -0)) { throw -0 }
+                e(Infinity)(Infinity)
+                e(-Infinity)(-Infinity)
+                n(Infinity)(-Infinity)
+            },
+            nullish: () => {
+                n(undefined)(NaN)
+                n(undefined)(0)
+            }
+        },
+        string: {
+            string: () => {
+                e("hello")("hello")
+                n("hello")("world")
+            },
+            number: () => {
+                n(0)("0")
+            }
+        },
+        bigint: {
+            bigint: () => {
+                e(12n)(12n)
+                n(12n)(-12n)
+                n(12n)(13n)
+            }
+        },
+        array: {
+            array: () => {
+                /** @type {any} */
+                const a = []
+                e(a)(a)
+                n([])([])
+                const a0 = ['0']
+                e(a0)(a0)
+            }
+        },
+        object: {
+            object: () => {
+                const o = { '0': '0' }
+                e(o)(o)
+                n(o)({ '0': '0' })
+            }
+        }
+    }
+}

package/nanvm-lib/tests/test.rs

@@ -0,0 +1,108 @@
+use nanvm_lib::{interface::{Complex, Container, Extension, Any, Utf8}, naive, nullish::Nullish, sign::Sign, simple::Simple};
+
+fn eq<A: Any>() {
+    // nullish
+    let null0: A = Simple::Nullish(Nullish::Null).to_unknown();
+    let null1 = Simple::Nullish(Nullish::Null).to_unknown();
+    let undefined0 = Simple::Nullish(Nullish::Undefined).to_unknown();
+    let undefined1 = Simple::Nullish(Nullish::Undefined).to_unknown();
+    {
+        assert_eq!(null0, null1);
+        assert_eq!(undefined0, undefined1);
+        assert_ne!(null1, undefined0);
+    }
+    // boolean
+    let true0: A = Simple::Boolean(true).to_unknown();
+    let true1 = Simple::Boolean(true).to_unknown();
+    let false0 = Simple::Boolean(false).to_unknown();
+    let false1 = Simple::Boolean(false).to_unknown();
+    {
+        // boolean
+        {
+            assert_eq!(true0, true1);
+            assert_eq!(false0, false1);
+            assert_ne!(true0, false0);
+        }
+        // nullish
+        {
+            assert_ne!(false0, undefined0);
+        }
+    }
+    // number
+    let number00: A = Simple::Number(2.3).to_unknown();
+    let number01: A = Simple::Number(2.3).to_unknown();
+    let number1: A = Simple::Number(-5.4).to_unknown();
+    let number_nan: A = Simple::Number(f64::NAN).to_unknown();
+    let number_p0: A = Simple::Number(0.0).to_unknown();
+    let number_n0: A = Simple::Number(-0.0).to_unknown();
+    let number_p_inf0: A = Simple::Number(f64::INFINITY).to_unknown();
+    let number_p_inf1: A = Simple::Number(f64::INFINITY).to_unknown();
+    let number_n_inf0: A = Simple::Number(-f64::INFINITY).to_unknown();
+    let number_n_inf1: A = Simple::Number(-f64::INFINITY).to_unknown();
+    {
+        // number
+        {
+            assert_eq!(number00, number01);
+            assert_ne!(number00, number1);
+            assert_ne!(number_nan, number_nan);
+            assert_eq!(number_p0, number_n0);
+            // Object.is()
+            assert_eq!((-0f64).to_bits(), (-0f64).to_bits());
+            assert_ne!(0f64.to_bits(), (-0f64).to_bits());
+            assert_eq!(number_p_inf0, number_p_inf1);
+            assert_eq!(number_n_inf0, number_n_inf1);
+            assert_ne!(number_p_inf0, number_n_inf0);
+        }
+        // nullish
+        {
+            assert_ne!(number_nan, undefined0);
+            assert_ne!(number00, undefined0);
+        }
+    }
+    // string
+    let string_hello0: A = "Hello!".to_unknown();
+    let string_hello1: A = "Hello!".to_unknown();
+    let string_world0: A = "world!".to_unknown();
+    let string0: A = "0".to_unknown();
+    let s0 = "0".to_string16::<A>();
+    {
+        {
+            assert_eq!(string_hello0, string_hello1);
+            assert_ne!(string_hello0, string_world0);
+        }
+        {
+            assert_ne!(number_p0, string0.clone());
+        }
+    }
+    // bigint
+    let bigint12_0: A = A::BigInt::new(Sign::Positive, [12]).to_unknown();
+    let bigint12_1: A = A::BigInt::new(Sign::Positive, [12]).to_unknown();
+    let bigint12m: A =  A::BigInt::new(Sign::Negative, [12]).to_unknown();
+    let bigint13: A =  A::BigInt::new(Sign::Positive, [13]).to_unknown();
+    {
+        assert_eq!(bigint12_0, bigint12_1);
+        assert_ne!(bigint12_0, bigint12m);
+        assert_ne!(bigint12_0, bigint13);
+    }
+    // array
+    let array0: A = [].to_array_unknown();
+    let array1: A = [].to_array_unknown();
+    let array2: A = [string0.clone()].to_array_unknown();
+    {
+        assert_eq!(array0, array0);
+        assert_ne!(array0, array1);
+        assert_eq!(array2, array2);
+    }
+    // object
+    let object0: A = [(s0.clone(), string0.clone())].to_object_unknown();
+    let object1: A = [(s0, string0)].to_object_unknown();
+    {
+        assert_eq!(object0, object0);
+        assert_ne!(object0, object1);
+    }
+}
+
+#[test]
+fn naive_eq() {
+    eq::<naive::Any>();
+}

package/nodejs/version/main.mjs

@@ -1,4 +1,4 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 import fs from 'node:fs'
 
 _.updateVersion({ fs })

package/nodejs/version/module.f.d.mts

@@ -1,8 +1,7 @@
-declare namespace _default {
-    export { getVersion };
-    export { updateVersion };
-}
-export default _default;
+/** @type {<T>(fs: Fs<T>) => string} */
+export const getVersion: <T>(fs: Fs<T>) => string;
+/** @type {<T>(node: Node<T>) => readonly[T, T]} */
+export const updateVersion: <T>(node: Node<T>) => readonly [T, T];
 export type Buffer = {};
 export type Fs<T> = {
     readonly readFileSync: (name: string) => Buffer;
@@ -11,7 +10,3 @@ export type Fs<T> = {
 export type Node<T> = {
     readonly fs: Fs<T>;
 };
-/** @type {<T>(fs: Fs<T>) => string} */
-declare const getVersion: <T>(fs: Fs<T>) => string;
-/** @type {<T>(node: Node<T>) => readonly[T, T]} */
-declare const updateVersion: <T>(node: Node<T>) => readonly [T, T];

package/nodejs/version/module.f.mjs

@@ -20,7 +20,7 @@
 const { stringify, parse } = JSON
 
 /** @type {<T>(fs: Fs<T>) => string} */
-const getVersion = fs => readJson(fs)('package').version
+export const getVersion = fs => readJson(fs)('package').version
 
 const jsonFile = (/** @type {string} */jsonFile) => `${jsonFile}.json`
 
@@ -28,7 +28,7 @@ const jsonFile = (/** @type {string} */jsonFile) => `${jsonFile}.json`
 const readJson = fs => name => parse(fs.readFileSync(jsonFile(name)).toString())
 
 /** @type {<T>(node: Node<T>) => readonly[T, T]} */
-const updateVersion = ({ fs }) => {
+export const updateVersion = ({ fs }) => {
     const f = (/** @type {string} */name) => {
         return fs.writeFileSync(
             jsonFile(name),
@@ -45,8 +45,3 @@ const updateVersion = ({ fs }) => {
         f('jsr')
     ]
 }
-
-export default {
-    getVersion,
-    updateVersion,
-}

package/nodejs/version/test.f.mjs

@@ -1,4 +1,4 @@
-import _, * as T from './module.f.mjs'
+import * as _ from './module.f.mjs'
 
 const version = '0.3.0'
 
@@ -82,13 +82,13 @@ const e = '{\n' +
     '  }\n' +
     '}'
 
-/** @type {(s: string) => T.Buffer} */
+/** @type {(s: string) => _.Buffer} */
 const buffer = s => ({
     toString: () => s
 })
 
 export default () => {
-    /** @type {T.Node<string>} */
+    /** @type {_.Node<string>} */
     const node = {
         fs: {
             readFileSync: n => buffer(JSON.stringify(x[n])),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.1.608",
+  "version": "0.2.0",
   "type": "module",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "scripts": {

package/prime_field/module.f.d.mts

@@ -1,25 +1,3 @@
-declare namespace _default {
-    export { prime_field };
-    export let sqrt: (f: PrimeField) => (a: bigint) => bigint | null;
-}
-export default _default;
-export type Reduce = Operator.Reduce<bigint>;
-export type Unary = Operator.Unary<bigint, bigint>;
-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;
-};
 /** @typedef {Operator.Reduce<bigint>} Reduce */
 /** @typedef {Operator.Unary<bigint, bigint>} Unary*/
 /**
@@ -40,5 +18,24 @@ export type PrimeField = {
  * }} PrimeField
  */
 /** @type {(p: bigint) => PrimeField} */
-declare const prime_field: (p: bigint) => PrimeField;
+export const prime_field: (p: bigint) => PrimeField;
+/** @type {(f: PrimeField) => (a: bigint) => bigint|null} */
+export const sqrt: (f: PrimeField) => (a: bigint) => bigint | null;
+export type Reduce = Operator.Reduce<bigint>;
+export type Unary = Operator.Unary<bigint, bigint>;
+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;
+};
 import * as Operator from '../types/function/operator/module.f.mjs';

package/prime_field/module.f.mjs

@@ -1,6 +1,6 @@
 // @ts-self-types="./module.f.d.mts"
 import * as Operator from '../types/function/operator/module.f.mjs'
-import bi from '../types/bigint/module.f.mjs'
+import * as bi from '../types/bigint/module.f.mjs'
 const { scalar_mul } = bi
 
 /** @typedef {Operator.Reduce<bigint>} Reduce */
@@ -26,7 +26,7 @@ const { scalar_mul } = bi
  */
 
 /** @type {(p: bigint) => PrimeField} */
-const prime_field = p => {
+export const prime_field = p => {
     /** @type {Reduce} */
     const sub = a => b => {
         const r = a - b
@@ -77,15 +77,12 @@ const prime_field = p => {
     }
 }
 
-export default {
-    prime_field,
-    /** @type {(f: PrimeField) => (a: bigint) => bigint|null} */
-    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
-        }
+/** @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/prime_field/test.f.mjs

@@ -1,4 +1,4 @@
-import _ from './module.f.mjs'
+import * as _ from './module.f.mjs'
 const { prime_field, sqrt } = _
 
 export default {

package/secp/module.f.d.mts

@@ -1,27 +1,3 @@
-declare namespace _default {
-    export { curve };
-    export let eq: (a: Point) => (b: Point) => boolean;
-    export let secp256k1: Init;
-    export let secp192r1: Init;
-}
-export default _default;
-export type Point2D = readonly [bigint, bigint];
-export type Point = Point2D | null;
-export type Init = {
-    readonly p: bigint;
-    readonly a: readonly [bigint, bigint];
-    readonly g: readonly [bigint, bigint];
-    readonly n: bigint;
-};
-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;
-};
 /** @typedef {readonly[bigint, bigint]} Point2D */
 /** @typedef {Point2D|null} Point */
 /**
@@ -34,8 +10,8 @@ export type Curve = {
  */
 /**
  * @typedef {{
- *  readonly pf: Pf.PrimeField
- *  readonly nf: Pf.PrimeField
+ *  readonly pf: pf.PrimeField
+ *  readonly nf: pf.PrimeField
  *  readonly y2: (x: bigint) => bigint
  *  readonly y: (x: bigint) => bigint|null
  *  readonly neg: (a: Point) => Point
@@ -44,6 +20,29 @@ export type Curve = {
  * }} Curve
  */
 /** @type {(i: Init) => Curve} */
-declare const curve: (i: Init) => Curve;
-import * as Pf from '../prime_field/module.f.mjs';
+export const curve: (i: Init) => Curve;
+/** @type {(a: Point) => (b: Point) => boolean} */
+export const eq: (a: Point) => (b: Point) => boolean;
+/** @type {Init} */
+export const secp256k1: Init;
+/** @type {Init} */
+export const secp192r1: Init;
+export type Point2D = readonly [bigint, bigint];
+export type Point = Point2D | null;
+export type Init = {
+    readonly p: bigint;
+    readonly a: readonly [bigint, bigint];
+    readonly g: readonly [bigint, bigint];
+    readonly n: bigint;
+};
+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/secp/module.f.mjs

@@ -1,7 +1,7 @@
 // @ts-self-types="./module.f.d.mts"
 import * as Operator from '../types/function/operator/module.f.mjs'
-import pf, * as Pf from '../prime_field/module.f.mjs'
-import bi from '../types/bigint/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
 
@@ -20,8 +20,8 @@ const { prime_field, sqrt } = pf
 
 /**
  * @typedef {{
- *  readonly pf: Pf.PrimeField
- *  readonly nf: Pf.PrimeField
+ *  readonly pf: pf.PrimeField
+ *  readonly nf: pf.PrimeField
  *  readonly y2: (x: bigint) => bigint
  *  readonly y: (x: bigint) => bigint|null
  *  readonly neg: (a: Point) => Point
@@ -31,7 +31,7 @@ const { prime_field, sqrt } = pf
  */
 
 /** @type {(i: Init) => Curve} */
-const curve = ({ p, a: [a0, a1], n }) => {
+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)
@@ -85,38 +85,37 @@ const curve = ({ p, a: [a0, a1], n }) => {
     }
 }
 
-export default {
-    curve,
-    /** @type {(a: Point) => (b: Point) => boolean} */
-    eq: a => b => {
-        if (a === null || b === null) {
-            return a === b
-        }
-        const [ax, ay] = a
-        const [bx, by] = b
-        return ax === bx && ay === by
-    },
-    /** @type {Init} */
-    secp256k1: {
-        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,
-    },
-    /** @type {Init} */
-    secp192r1: {
-        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,
-    },
+/** @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
+}
+
+/** @type {Init} */
+export const secp256k1 = {
+    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,
+}
+
+/** @type {Init} */
+export const secp192r1 = {
+    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,
 }

package/secp/test.f.mjs

@@ -1,13 +1,13 @@
-import _, * as T from './module.f.mjs'
+import * as _ from './module.f.mjs'
 const { curve, secp256k1, secp192r1, eq } = _
 
 export default {
     test: () => {
-        /** @type {(c: T.Init) => void} */
+        /** @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: T.Point) => void} */
+            /** @type {(p: _.Point) => void} */
             const point_check = p => {
                 if (p === null) { throw 'null' }
                 const [x, y] = p
@@ -17,7 +17,7 @@ export default {
             }
             point_check(g)
             point_check(neg(g))
-            /** @type {(p: T.Point) => void} */
+            /** @type {(p: _.Point) => void} */
             const test_mul = p => {
                 if (mul(p)(0n) !== null) { throw 'O' }
                 if (mul(p)(1n) !== p) { throw 'p' }

package/sha2/module.f.d.mts

@@ -1,23 +1,15 @@
-declare namespace _default {
-    export { padding };
-    export { computeSha256 };
-    export { computeSha224 };
-    export { compress256 };
-    export { compress224 };
-}
-export default _default;
+/** @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 = arrayT.Array8<number>;
 export type Array16 = arrayT.Array16<number>;
-/** @type  {(input: readonly number[]) => (bits: number) => HashInput} */
-declare const padding: (input: readonly number[]) => (bits: number) => HashInput;
-/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-declare const computeSha256: (input: readonly number[]) => (bitsCount: number) => Hash8;
-/** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-declare const computeSha224: (input: readonly number[]) => (bitsCount: number) => Hash8;
-declare const compress256: (data: Array16) => Hash8;
-declare const compress224: (data: Array16) => Hash8;
 import * as arrayT from '../types/array/module.f.mjs';

package/sha2/module.f.mjs

@@ -19,7 +19,7 @@ const appendOneWithZeros = input => pos => (input >> pos << pos) | (1 << pos)
 const mod = a => b => (a % b + b) % b
 
 /** @type  {(input: readonly number[]) => (bits: number) => HashInput} */
-const padding = input => bitsCount => {
+export const padding = input => bitsCount => {
     const appendBlockIndex = (bitsCount / 32) | 0
     const length = (bitsCount + mod(447 - bitsCount)(512) + 65) / 32
     /** @type {(i: number) => number} */
@@ -183,27 +183,14 @@ const compute = init => input => bitsCount => {
 const init256 = [0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]
 
 /** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-const computeSha256 = compute(init256)
+export const computeSha256 = compute(init256)
 
 /** @type {Hash8} */
 const init224 = [0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939, 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4]
 
 /** @type {(input: readonly number[]) => (bitsCount: number) => Hash8} */
-const computeSha224 = compute(init224)
-
-const compress256 = compress(init256)
-
-const compress224 = compress(init224)
-
-export default {
-    /** @readonly */
-    padding,
-    /** @readonly */
-    computeSha256,
-    /** @readonly */
-    computeSha224,
-     /** @readonly */
-    compress256,
-    /** @readonly */
-    compress224
-}
+export const computeSha224 = compute(init224)
+
+export const compress256 = compress(init256)
+
+export const compress224 = compress(init224)

package/sha2/test.f.mjs

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