functionalscript 0.37.0 → 0.38.0

package/{fs → fjs}/crypto/vdf/proof.f.js

@@ -1,4 +1,5 @@
 import { sloth, p } from './module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 const { eval: evalVdf, verify, modSqrt, quadRes } = sloth;
 // `eval(steps)(x)` expected values for {@link p}; same Sloth algorithm as
 // https://github.com/hyperhyperspace/pulsar/blob/main/src/model/SlothVDF.ts and
@@ -14,122 +15,80 @@ const y4 = 644011502652234436942449645950841972378141575340402198193426476647825
 export const proof = {
     p: {
         matchesField: () => {
-            if (sloth.p !== p) {
-                throw [sloth.p, p];
-            }
+            assertEq(sloth.p, p, [sloth.p, p]);
         },
     },
     eval: {
         steps100: () => {
             const y = evalVdf(100n)(sampleX);
-            if (y !== sampleY) {
-                throw [y, sampleY];
-            }
+            assertEq(y, sampleY, [y, sampleY]);
         },
         steps10: () => {
             const y = evalVdf(10n)(smallX);
-            if (y !== smallY) {
-                throw [y, smallY];
-            }
+            assertEq(y, smallY, [y, smallY]);
         },
         steps6: () => {
             const y = evalVdf(6n)(largeX);
-            if (y !== y6) {
-                throw [y, y6];
-            }
+            assertEq(y, y6, [y, y6]);
         },
         steps4: () => {
             const y = evalVdf(4n)(smallX);
-            if (y !== y4) {
-                throw [y, y4];
-            }
+            assertEq(y, y4, [y, y4]);
         },
         zeroSteps: () => {
             const y = evalVdf(0n)(sampleX);
-            if (y !== sampleX % p) {
-                throw [y, sampleX % p];
-            }
+            assertEq(y, sampleX % p, [y, sampleX % p]);
         },
         negativeSteps: () => {
             const y = evalVdf(-1n)(sampleX);
-            if (y !== null) {
-                throw y;
-            }
+            assertEq(y, null);
         },
     },
     verify: {
         steps100: () => {
-            if (!verify(100n)(sampleX)(sampleY)) {
-                throw false;
-            }
+            assert(verify(100n)(sampleX)(sampleY), false);
         },
         steps10: () => {
-            if (!verify(10n)(smallX)(smallY)) {
-                throw false;
-            }
+            assert(verify(10n)(smallX)(smallY), false);
         },
         steps6: () => {
-            if (!verify(6n)(largeX)(y6)) {
-                throw false;
-            }
+            assert(verify(6n)(largeX)(y6), false);
         },
         steps4: () => {
-            if (!verify(4n)(smallX)(y4)) {
-                throw false;
-            }
+            assert(verify(4n)(smallX)(y4), false);
         },
         tampered: () => {
-            if (verify(4n)(smallX)((y4 + 1n) % p)) {
-                throw (y4 + 1n) % p;
-            }
+            assert(!(verify(4n)(smallX)((y4 + 1n) % p)), (y4 + 1n) % p);
         },
         wrongY: () => {
-            if (verify(100n)(sampleX)(sampleY + 1n)) {
-                throw sampleY + 1n;
-            }
+            assert(!(verify(100n)(sampleX)(sampleY + 1n)), sampleY + 1n);
         },
         zeroSteps: () => {
-            if (!verify(0n)(sampleX)(sampleX % p)) {
-                throw [sampleX % p];
-            }
+            assert(verify(0n)(sampleX)(sampleX % p), [sampleX % p]);
         },
         negativeSteps: () => {
-            if (verify(-1n)(sampleX)(sampleY)) {
-                throw sampleY;
-            }
+            assert(!(verify(-1n)(sampleX)(sampleY)), sampleY);
         },
         invalidY: () => {
-            if (verify(100n)(sampleX)(0n)) {
-                throw 0n;
-            }
+            assert(!(verify(100n)(sampleX)(0n)), 0n);
         },
     },
     modSqrt: {
         roundTrip: () => {
             const x = 999n;
-            if (!verify(1n)(x)(modSqrt(x))) {
-                throw modSqrt(x);
-            }
+            assert(verify(1n)(x)(modSqrt(x)), modSqrt(x));
         },
         nonResidue: () => {
-            if (quadRes(nonResidue)) {
-                throw nonResidue;
-            }
-            if (!verify(1n)(nonResidue)(modSqrt(nonResidue))) {
-                throw modSqrt(nonResidue);
-            }
+            assert(!(quadRes(nonResidue)), nonResidue);
+            assert(verify(1n)(nonResidue)(modSqrt(nonResidue)), modSqrt(nonResidue));
         },
     },
     quadRes: {
         one: () => {
-            if (!quadRes(1n)) {
-                throw 1n;
-            }
+            assert(quadRes(1n), 1n);
         },
         nonResidue: () => {
-            if (quadRes(nonResidue)) {
-                throw nonResidue;
-            }
+            assert(!(quadRes(nonResidue)), nonResidue);
         },
     },
 };

package/{fs → fjs}/dev/package_json/proof.f.js

@@ -1,12 +1,12 @@
-import { assert } from '../../asserts/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 import { unwrap } from '../../types/result/module.f.js';
 import { validatePackageJson, validatePackageJsonText, } from './module.f.js';
 export const proof = {
     parseMetadata: () => {
         const result = unwrap(validatePackageJsonText('{"name":"x","version":"1.0.0","scripts":{"test":"node test.js"}}'));
-        assert(result.name === 'x', result);
-        assert(result.version === '1.0.0', result);
-        assert(result.scripts?.test === 'node test.js', result);
+        assertEq(result.name, 'x', result);
+        assertEq(result.version, '1.0.0', result);
+        assertEq(result.scripts?.test, 'node test.js', result);
     },
     malformedJson: () => {
         const result = validatePackageJsonText('{');
@@ -20,9 +20,9 @@ export const proof = {
     validatePreservesOriginalObject: () => {
         const object = { name: 'x', version: '1.0.0', private: true };
         const metadata = unwrap(validatePackageJson(object));
-        assert(metadata.name === 'x', metadata);
-        assert(metadata.version === '1.0.0', metadata);
+        assertEq(metadata.name, 'x', metadata);
+        assertEq(metadata.version, '1.0.0', metadata);
         assert(Object.is(metadata, object), metadata);
-        assert(object.private === true, object);
+        assertEq(object.private, true, object);
     },
 };

package/{fs → fjs}/dev/proof.f.js

@@ -1,4 +1,4 @@
-import { assert, todo } from '../asserts/module.f.js';
+import { assert, assertEq, todo } from '../asserts/module.f.js';
 import { shouldLoad } from './module.f.js';
 export const proof = {
     shouldLoad: () => {
@@ -18,9 +18,7 @@ export const proof = {
         const c = (() => { })['constructor'];
         const f = c('return 5');
         const result = f();
-        if (result !== 5) {
-            throw 'function';
-        }
+        assertEq(result, 5, 'function');
     },
     ctorEmpty: () => {
         /** @type {any} */

package/{fs → fjs}/djs/ast/proof.f.js

@@ -6,30 +6,22 @@ export const proof = {
     test: () => {
         const djs = run([1])([]);
         const result = stringifyAsTree(sort)(djs);
-        if (result !== '1') {
-            throw result;
-        }
+        assertEq(result, '1');
     },
     testCref: () => {
         const djs = run([1, 2, 3, 4, 5, ['cref', 3]])([11, 12, 13, 14, 15]);
         const result = stringifyAsTree(sort)(djs);
-        if (result !== '4') {
-            throw result;
-        }
+        assertEq(result, '4');
     },
     testAref: () => {
         const djs = run([1, 2, 3, 4, 5, ['aref', 3]])([11, 12, 13, 14, 15]);
         const result = stringifyAsTree(sort)(djs);
-        if (result !== '14') {
-            throw result;
-        }
+        assertEq(result, '14');
     },
     testArray: () => {
         const djs = run([1, 2, 3, 4, 5, ['array', [['aref', 3], ['cref', 3]]]])([11, 12, 13, 14, 15]);
         const result = stringifyAsTree(sort)(djs);
-        if (result !== '[14,4]') {
-            throw result;
-        }
+        assertEq(result, '[14,4]');
     },
     testObj: () => {
         const djs = run([1, 2, 3, 4, 5, { "key": { "key2": ['array', [['aref', 3], ['cref', 3]]] } }])([11, 12, 13, 14, 15]);

package/{fs → fjs}/djs/parser/module.f.d.ts

@@ -13,3 +13,8 @@ export type ParseError = {
     readonly metadata: TokenMetadata | null;
 };
 export declare const parseFromTokens: (tokenList: List<DjsTokenWithMetadata>) => Result<AstModule, ParseError>;
+export declare const proof: {
+    pushKey: {
+        nonObjectTop: () => void;
+    };
+};

package/{fs → fjs}/djs/parser/module.f.js

@@ -7,6 +7,7 @@ import { error, ok } from '../../types/result/module.f.js';
 import { fold, first, drop, toArray, length, concat } from '../../types/list/module.f.js';
 import { setReplace, at } from '../../types/ordered_map/module.f.js';
 import { fromMap } from '../../types/object/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 const parseInitialOp = ({ token, metadata }) => state => {
     switch (token.kind) {
         case 'ws':
@@ -361,3 +362,22 @@ export const parseFromTokens = (tokenList) => {
         default: return error({ message: 'unexpected end', metadata: null });
     }
 };
+export const proof = {
+    pushKey: {
+        // `pushKey` is only ever invoked while `state.top` is an object (the
+        // `'{'`/`'{,'` value-states guarantee it), so its non-object guard is
+        // a defensive branch unreachable through `parseFromTokens`. Call it
+        // directly to cover that branch.
+        nonObjectTop: () => {
+            const state = {
+                state: 'exportValue',
+                module: { refs: null, modules: null, consts: null },
+                valueState: '[',
+                top: null,
+                stack: null,
+            };
+            const result = pushKey(state)('key')({ path: 'test', line: 0, column: 0 });
+            assertEq(result.state, 'error');
+        },
+    },
+};