functionalscript 0.36.0 → 0.38.0

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

@@ -1,6 +1,7 @@
-import { compile } from "./module.f.js";
-import { virtual, emptyState } from "../effects/node/virtual/module.f.js";
-import { utf8, utf8ToString } from "../text/module.f.js";
+import { compile } from './module.f.js';
+import { virtual, emptyState } from '../effects/node/virtual/module.f.js';
+import { utf8, utf8ToString } from '../text/module.f.js';
+import { assert, assertEq } from '../asserts/module.f.js';
 const readOutput = (root, path) => {
     const file = root[path];
     if (!Array.isArray(file) || file.length === 0) {
@@ -12,62 +13,38 @@ export const proof = {
     tooFewArgs: {
         noArgs: () => {
             const [state, code] = virtual(emptyState)(compile([]));
-            if (code !== 1) {
-                throw code;
-            }
-            if (!state.stderr.includes('Requires 2 or more arguments')) {
-                throw state.stderr;
-            }
+            assertEq(code, 1);
+            assert(state.stderr.includes('Requires 2 or more arguments'), state.stderr);
         },
         oneArg: () => {
             const [state, code] = virtual(emptyState)(compile(['input.f.js']));
-            if (code !== 1) {
-                throw code;
-            }
-            if (!state.stderr.includes('Requires 2 or more arguments')) {
-                throw state.stderr;
-            }
+            assertEq(code, 1);
+            assert(state.stderr.includes('Requires 2 or more arguments'), state.stderr);
         },
     },
     success: () => {
         const root = { 'input.f.js': [utf8('export default 42')] };
         const [state, code] = virtual({ ...emptyState, root })(compile(['input.f.js', 'output.f.js']));
-        if (code !== 0) {
-            throw code;
-        }
+        assertEq(code, 0);
         const content = readOutput(state.root, 'output.f.js');
-        if (content !== 'export default 42') {
-            throw content;
-        }
+        assertEq(content, 'export default 42');
     },
     jsonOutput: () => {
         const root = { 'input.f.js': [utf8('export default 42')] };
         const [state, code] = virtual({ ...emptyState, root })(compile(['input.f.js', 'output.json']));
-        if (code !== 0) {
-            throw code;
-        }
+        assertEq(code, 0);
         const content = readOutput(state.root, 'output.json');
-        if (content !== '42') {
-            throw content;
-        }
+        assertEq(content, '42');
     },
     fileNotFound: () => {
         const [state, code] = virtual(emptyState)(compile(['missing.f.js', 'output.f.js']));
-        if (code !== 0) {
-            throw code;
-        }
-        if (!state.stderr.includes('file not found')) {
-            throw state.stderr;
-        }
+        assertEq(code, 0);
+        assert(state.stderr.includes('file not found'), state.stderr);
     },
     parseError: () => {
         const root = { 'bad.f.js': [utf8('export default @')] };
         const [state, code] = virtual({ ...emptyState, root })(compile(['bad.f.js', 'output.f.js']));
-        if (code !== 0) {
-            throw code;
-        }
-        if (state.stderr === '') {
-            throw 'expected error output';
-        }
+        assertEq(code, 0);
+        assert(state.stderr !== '', 'expected error output');
     },
 };

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

@@ -1,10 +1,10 @@
-import { fold } from "../../types/list/module.f.js";
-import { concat } from "../../types/string/module.f.js";
-import { flat, flatMap, map, concat as listConcat } from "../../types/list/module.f.js";
+import { fold } from '../../types/list/module.f.js';
+import { concat } from '../../types/string/module.f.js';
+import { flat, flatMap, map, concat as listConcat } from '../../types/list/module.f.js';
 const { entries } = Object;
-import { compose, fn } from "../../types/function/module.f.js";
-import { serialize as bigintSerialize } from "../../types/bigint/module.f.js";
-import { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } from "../../json/serializer/module.f.js";
+import { compose, fn } from '../../types/function/module.f.js';
+import { serialize as bigintSerialize } from '../../types/bigint/module.f.js';
+import { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } from '../../media/json/serializer/module.f.js';
 const colon = [':'];
 export const undefinedSerialize = ['undefined'];
 /**

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

@@ -1,63 +1,42 @@
-import { countRefs, stringify, stringifyAsTree } from "./module.f.js";
-import { sort } from "../../types/object/module.f.js";
-import { identity } from "../../types/function/module.f.js";
-import { setProperty } from "../../json/module.f.js";
+import { countRefs, stringify, stringifyAsTree } from './module.f.js';
+import { sort } from '../../types/object/module.f.js';
+import { identity } from '../../types/function/module.f.js';
+import { setProperty } from '../../media/json/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
     stringify: [
         {
             testPrimitives: () => {
                 const djs = [1, 2, 2, 2, true, false, undefined, null, 3n, "str"];
                 const refs = countRefs(djs);
-                if (refs.size !== 3) {
-                    throw refs.size;
-                }
+                assertEq(refs.size, 3);
                 const refsBigInt = stringifyAsTree(sort)(refs.get(3n));
-                if (refsBigInt !== '[0,1]') {
-                    throw refsBigInt;
-                }
+                assertEq(refsBigInt, '[0,1]');
                 const refsString = stringifyAsTree(sort)(refs.get("str"));
-                if (refsString !== '[1,1]') {
-                    throw refsString;
-                }
+                assertEq(refsString, '[1,1]');
                 const refsRoot = stringifyAsTree(sort)(refs.get(djs));
-                if (refsRoot !== '[2,1]') {
-                    throw refsRoot;
-                }
-                if (refs.get(null) !== undefined) {
-                    throw refs.get(null);
-                }
+                assertEq(refsRoot, '[2,1]');
+                assertEq(refs.get(null), undefined);
             },
             testArray: () => {
                 const array = [null];
                 const djs = [array, array, array];
                 const refs = countRefs(djs);
-                if (refs.size !== 2) {
-                    throw refs.size;
-                }
+                assertEq(refs.size, 2);
                 const refsArray = stringifyAsTree(sort)(refs.get(array));
-                if (refsArray !== '[0,3]') {
-                    throw refsArray;
-                }
+                assertEq(refsArray, '[0,3]');
                 const refsRoot = stringifyAsTree(sort)(refs.get(djs));
-                if (refsRoot !== '[1,1]') {
-                    throw refsRoot;
-                }
+                assertEq(refsRoot, '[1,1]');
             },
             testObj: () => {
                 const obj = { "a": 1, "b": 2 };
                 const djs = [obj, obj, 1];
                 const refs = countRefs(djs);
-                if (refs.size !== 2) {
-                    throw refs.size;
-                }
+                assertEq(refs.size, 2);
                 const refsObj = stringifyAsTree(sort)(refs.get(obj));
-                if (refsObj !== '[0,2]') {
-                    throw refsObj;
-                }
+                assertEq(refsObj, '[0,2]');
                 const refsRoot = stringifyAsTree(sort)(refs.get(djs));
-                if (refsRoot !== '[1,1]') {
-                    throw refsRoot;
-                }
+                assertEq(refsRoot, '[1,1]');
             },
         },
         {
@@ -131,18 +110,14 @@ export const proof = {
             stringify: () => {
                 const bi = 1234567890n;
                 const result = stringifyAsTree(sort)(bi);
-                if (result !== '1234567890n') {
-                    throw result;
-                }
+                assertEq(result, '1234567890n');
             }
         },
         {
             stringify: () => {
                 const arr = [0n, 1, 2n];
                 const result = stringifyAsTree(sort)(arr);
-                if (result !== '[0n,1,2n]') {
-                    throw result;
-                }
+                assertEq(result, '[0n,1,2n]');
             }
         },
         {

package/fjs/djs/tokenizer/module.f.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Experimental DJS parser implementation.
+ *
+ * @module
+ */
+import { type DescentMatch, type DescentMatchResult } from "../../bnf/descent/module.f.ts";
+import { type Rule } from "../../bnf/module.f.ts";
+import { type BigIntToken, type CommentToken, type EofToken, type ErrorToken, type IdToken, type JsTokenWithMetadata, type NewLineToken, type NumberToken, type StringToken, type TokenMetadata, type WhitespaceToken } from "../../js/tokenizer/module.f.ts";
+import { type CodePoint } from "../../text/utf16/module.f.ts";
+import { type List } from "../../types/list/module.f.ts";
+export declare const jsGrammar: () => Rule;
+export declare const descentParserCpOnly: (m: DescentMatch<unknown>, name: string, cp: readonly CodePoint[]) => DescentMatchResult<unknown>;
+export declare const tokenizeString: (s: string) => string;
+export declare const tokenizeJs: (input: List<number>) => (path: string) => List<JsTokenWithMetadata>;
+export type DjsToken = {
+    readonly kind: 'true' | 'false' | 'null' | 'undefined';
+} | {
+    readonly kind: '{' | '}' | ':' | ',' | '[' | ']' | '.' | '=';
+} | StringToken | NumberToken | ErrorToken | IdToken | BigIntToken | WhitespaceToken | NewLineToken | CommentToken | EofToken;
+export type DjsTokenWithMetadata = {
+    readonly token: DjsToken;
+    readonly metadata: TokenMetadata;
+};
+export declare const tokenize: (input: List<number>) => (path: string) => List<DjsTokenWithMetadata>;