xmlui 0.4.0

package/dist/scripts/src/components-core/script-runner/eval-tree-sync.js

@@ -0,0 +1,434 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evalBindingExpression = evalBindingExpression;
+exports.evalBinding = evalBinding;
+exports.executeArrowExpressionSync = executeArrowExpressionSync;
+const eval_tree_common_1 = require("./eval-tree-common");
+const Parser_1 = require("../../parsers/scripting/Parser");
+const process_statement_common_1 = require("./process-statement-common");
+const process_statement_sync_1 = require("./process-statement-sync");
+const bannedFunctions_1 = require("./bannedFunctions");
+/**
+ * Evaluates the specified binding expression tree and retrieves the evaluated value
+ * @param source Binding tree expression
+ * @param evalContext Evaluation context
+ * @param thread The logical thread to use for evaluation
+ * This code uses the JavaScript semantics and errors when evaluating the code.
+ */
+function evalBindingExpression(source, evalContext, thread) {
+    // --- Use the main thread by default
+    thread !== null && thread !== void 0 ? thread : (thread = evalContext.mainThread);
+    // --- Parse the source code
+    const wParser = new Parser_1.Parser(source);
+    const tree = wParser.parseExpr();
+    if (tree === null) {
+        // --- This should happen only when an expression is empty
+        return undefined;
+    }
+    // --- Check for expression termination
+    if (!wParser.isEof) {
+        throw new Error("Expression is not terminated properly");
+    }
+    // --- Ok, valid source, evaluate
+    return evalBinding(tree, evalContext, thread);
+}
+/**
+ * Evaluates a binding represented by the specified expression
+ * @param expr Expression to evaluate
+ * @param evalContext Evaluation context to use
+ * @param thread The logical thread to use for evaluation
+ */
+function evalBinding(expr, evalContext, thread) {
+    const thisStack = [];
+    (0, process_statement_common_1.ensureMainThread)(evalContext);
+    thread !== null && thread !== void 0 ? thread : (thread = evalContext.mainThread);
+    return evalBindingExpressionTree(thisStack, expr, evalContext, thread !== null && thread !== void 0 ? thread : evalContext.mainThread);
+}
+/**
+ * Executes the specified arrow function
+ * @param expr Arrow function expression to run
+ * @param evalContext Evaluation context to use
+ * @param thread The logical thread to use for evaluation
+ * @param args Arguments of the arrow function to execute
+ */
+function executeArrowExpressionSync(expr, evalContext, thread, ...args) {
+    // --- Just an extra safety check
+    if (expr.type !== "ArrowE") {
+        throw new Error("executeArrowExpression expects an 'ArrowExpression' object.");
+    }
+    // --- This is the evaluator that an arrow expression uses internally
+    const evaluator = evalBindingExpressionTree;
+    // --- Compiles the Arrow function to a JavaScript function
+    const nativeFunction = createArrowFunction(evaluator, expr);
+    // --- Run the compiled arrow function. Note, we have two prefix arguments:
+    // --- #1: The names of arrow function arguments
+    // --- #2: The evaluation context the arrow function runs in
+    // --- #others: The real arguments of the arrow function
+    return nativeFunction(expr.args, evalContext, thread !== null && thread !== void 0 ? thread : evalContext.mainThread, ...args);
+}
+/**
+ * Evaluates the specified binding expression tree and retrieves the evaluated value
+ * @param expr Binding tree expression
+ * @param thisStack Stack of "this" object to use with function calls
+ * @param evalContext Evaluation context
+ * @param thread The logical thread to use for evaluation
+ * This code uses the JavaScript semantics and errors when evaluating the code.
+ * We use `thisStack` to keep track of the partial results of the evaluation tree so that we can set
+ * the real `this` context when invoking a function.
+ */
+function evalBindingExpressionTree(thisStack, expr, evalContext, thread) {
+    if (!evalContext.options) {
+        evalContext.options = { defaultToOptionalMemberAccess: true };
+    }
+    // --- Prepare evaluation
+    let customOp = null;
+    const evaluator = evalBindingExpressionTree;
+    // --- Reset the expression scope
+    expr.valueScope = expr.valueIndex = undefined;
+    // --- Process the expression according to its type
+    switch (expr.type) {
+        case "LitE":
+            return (0, eval_tree_common_1.evalLiteral)(thisStack, expr);
+        case "IdE":
+            return (0, eval_tree_common_1.evalIdentifier)(thisStack, expr, evalContext, thread);
+        case "MembE":
+            return evalMemberAccess(evaluator, thisStack, expr, evalContext, thread);
+        case "CMembE":
+            return evalCalculatedMemberAccess(evaluator, thisStack, expr, evalContext, thread);
+        case "SeqE":
+            return evalSequence(evaluator, thisStack, expr, evalContext, thread);
+        case "ALitE":
+            return evalArrayLiteral(evaluator, thisStack, expr, evalContext, thread);
+        case "OLitE":
+            return evalObjectLiteral(evaluator, thisStack, expr, evalContext, thread);
+        case "UnaryE":
+            return evalUnary(evaluator, thisStack, customOp, expr, evalContext, thread);
+        case "BinaryE":
+            return evalBinary(evaluator, thisStack, customOp, expr, evalContext, thread);
+        case "CondE":
+            return evalConditional(evaluator, thisStack, expr, evalContext, thread);
+        case "AsgnE":
+            return evalAssignment(evaluator, thisStack, expr, evalContext, thread);
+        case "PrefE":
+        case "PostfE":
+            return evalPreOrPost(evaluator, thisStack, expr, evalContext, thread);
+        case "InvokeE":
+            // --- Special sync handling
+            const funcResult = evalFunctionInvocation(evaluator, thisStack, expr, evalContext, thread);
+            if ((0, eval_tree_common_1.isPromise)(funcResult)) {
+                throw new Error("Promises (async function calls) are not allowed in binding expressions.");
+            }
+            return funcResult;
+        case "ArrowE":
+            // --- Special sync handling
+            return (0, eval_tree_common_1.evalArrow)(thisStack, expr, thread);
+        case "SpreadE":
+            throw new Error("Cannot use spread expression (...) with the current intermediate value.");
+        default:
+            throw new Error(`Unknown expression tree node: ${expr.type}`);
+    }
+}
+function evalMemberAccess(evaluator, thisStack, expr, evalContext, thread) {
+    const parentObj = evaluator(thisStack, expr.object, evalContext, thread);
+    return (0, eval_tree_common_1.evalMemberAccessCore)(parentObj, thisStack, expr, evalContext);
+}
+function evalCalculatedMemberAccess(evaluator, thisStack, expr, evalContext, thread) {
+    const parentObj = evaluator(thisStack, expr.object, evalContext, thread);
+    // --- At this point we definitely keep the parent object on `thisStack`, as it will be the context object
+    // --- of a FunctionInvocationExpression, if that follows the MemberAccess. Other operations would call
+    // --- `thisStack.pop()` to remove the result from the previous `evalBindingExpressionTree` call.
+    const memberObj = evaluator(thisStack, expr.member, evalContext, thread);
+    thisStack.pop();
+    return (0, eval_tree_common_1.evalCalculatedMemberAccessCore)(parentObj, memberObj, thisStack, expr, evalContext);
+}
+function evalSequence(evaluator, thisStack, expr, evalContext, thread) {
+    if (!expr.expressions || expr.expressions.length === 0) {
+        throw new Error(`Missing expression sequence`);
+    }
+    const result = expr.expressions.map((e) => {
+        const exprValue = evaluator(thisStack, e, evalContext, thread);
+        thisStack.pop();
+        return exprValue;
+    });
+    const lastObj = result[result.length - 1];
+    thisStack.push(lastObj);
+    return lastObj;
+}
+function evalArrayLiteral(evaluator, thisStack, expr, evalContext, thread) {
+    const arrayValue = [];
+    for (const item of expr.items) {
+        if (item.type === "SpreadE") {
+            const spreadArray = evaluator(thisStack, item.operand, evalContext, thread);
+            thisStack.pop();
+            if (!Array.isArray(spreadArray)) {
+                throw new Error("Spread operator within an array literal expects an array operand.");
+            }
+            arrayValue.push(...spreadArray);
+        }
+        else {
+            arrayValue.push(evaluator(thisStack, item, evalContext, thread));
+            thisStack.pop();
+            thisStack.push(arrayValue);
+        }
+    }
+    return arrayValue;
+}
+function evalObjectLiteral(evaluator, thisStack, expr, evalContext, thread) {
+    const objectHash = {};
+    for (const prop of expr.props) {
+        if (!Array.isArray(prop)) {
+            // --- We're using a spread expression
+            const spreadItems = evaluator(thisStack, prop.operand, evalContext, thread);
+            thisStack.pop();
+            if (Array.isArray(spreadItems)) {
+                // --- Spread of an array
+                for (let i = 0; i < spreadItems.length; i++) {
+                    objectHash[i] = spreadItems[i];
+                }
+            }
+            else if (typeof spreadItems === "object") {
+                // --- Spread of a hash object
+                for (const [key, value] of Object.entries(spreadItems)) {
+                    objectHash[key] = value;
+                }
+            }
+            continue;
+        }
+        // --- We're using key/[value] pairs
+        let key;
+        switch (prop[0].type) {
+            case "LitE":
+                key = prop[0].value;
+                break;
+            case "IdE":
+                key = prop[0].name;
+                break;
+            default:
+                key = evaluator(thisStack, prop[0], evalContext, thread);
+                thisStack.pop();
+                break;
+        }
+        objectHash[key] = evaluator(thisStack, prop[1], evalContext, thread);
+        thisStack.pop();
+    }
+    thisStack.push(objectHash);
+    return objectHash;
+}
+function evalUnary(evaluator, thisStack, customOp, expr, evalContext, thread) {
+    const operand = evaluator(thisStack, expr.operand, evalContext, thread);
+    thisStack.pop();
+    return (0, eval_tree_common_1.evalUnaryCore)(expr, operand, thisStack, customOp);
+}
+function evalBinary(evaluator, thisStack, customOp, expr, evalContext, thread) {
+    const l = evaluator(thisStack, expr.left, evalContext, thread);
+    thisStack.pop();
+    if (expr.operator === "&&" && !l) {
+        thisStack.push(l);
+        return l;
+    }
+    if (expr.operator === "||" && l) {
+        thisStack.push(l);
+        return l;
+    }
+    const r = evaluator(thisStack, expr.right, evalContext, thread);
+    thisStack.pop();
+    return (0, eval_tree_common_1.evalBinaryCore)(l, r, thisStack, customOp, expr.operator);
+}
+function evalConditional(evaluator, thisStack, expr, evalContext, thread) {
+    const condition = evaluator(thisStack, expr.condition, evalContext, thread);
+    thisStack.pop();
+    return evaluator(thisStack, condition ? expr.consequent : expr.alternate, evalContext, thread);
+}
+function evalAssignment(evaluator, thisStack, expr, evalContext, thread) {
+    const leftValue = expr.leftValue;
+    evaluator(thisStack, leftValue, evalContext, thread);
+    thisStack.pop();
+    const newValue = evaluator(thisStack, expr.operand, evalContext, thread);
+    thisStack.pop();
+    return (0, eval_tree_common_1.evalAssignmentCore)(leftValue, newValue, thisStack, expr, thread);
+}
+function evalPreOrPost(evaluator, thisStack, expr, evalContext, thread) {
+    const operand = expr.operand;
+    evaluator(thisStack, operand, evalContext, thread);
+    thisStack.pop();
+    return (0, eval_tree_common_1.evalPreOrPostCore)(operand, thisStack, expr, evalContext, thread);
+}
+function evalFunctionInvocation(evaluator, thisStack, expr, evalContext, thread) {
+    var _a, _b, _c, _d;
+    let functionObj;
+    let implicitContextObject = null;
+    // --- Check for contexted object
+    if (expr.object.type === "MembE" && expr.object.object.type === "IdE") {
+        const hostObject = evaluator(thisStack, expr.object.object, evalContext, thread);
+        functionObj = (0, eval_tree_common_1.evalMemberAccessCore)(hostObject, thisStack, expr.object, evalContext);
+        if (hostObject === null || hostObject === void 0 ? void 0 : hostObject._SUPPORT_IMPLICIT_CONTEXT) {
+            implicitContextObject = hostObject;
+        }
+    }
+    else {
+        // --- Get the object on which to invoke the function
+        functionObj = evaluator(thisStack, expr.object, evalContext, thread);
+    }
+    thisStack.pop();
+    // --- Keep function arguments here, we pass it to the function later
+    const functionArgs = [];
+    // --- The functionObj may be an ArrowExpression. In this care we need to create the invokable arrow function
+    if (functionObj === null || functionObj === void 0 ? void 0 : functionObj._ARROW_EXPR_) {
+        functionArgs.push(functionObj.args, evalContext, thread, ...expr.arguments.map((a) => (Object.assign(Object.assign({}, a), { _EXPRESSION_: true }))));
+        functionObj = createArrowFunction(evaluator, functionObj);
+    }
+    else if (expr.object.type === "ArrowE") {
+        // --- We delay evaluating expression values. We pass the argument names as the first parameter, and then
+        // --- all parameter expressions
+        functionArgs.push(expr.object.args, evalContext, thread, ...expr.arguments.map((a) => (Object.assign(Object.assign({}, a), { _EXPRESSION_: true }))));
+    }
+    else {
+        // --- We evaluate the argument values to pass to a JavaScript function
+        for (let i = 0; i < expr.arguments.length; i++) {
+            const arg = expr.arguments[i];
+            if (arg.type === "SpreadE") {
+                const funcArg = evaluator([], arg.operand, evalContext, thread);
+                if (!Array.isArray(funcArg)) {
+                    throw new Error("Spread operator within a function invocation expects an array operand.");
+                }
+                functionArgs.push(...funcArg);
+            }
+            else {
+                if (arg.type === "ArrowE") {
+                    const funcArg = createArrowFunction(evaluator, arg);
+                    const wrappedFunc = (...args) => funcArg(arg.args, evalContext, thread, ...args);
+                    functionArgs.push(wrappedFunc);
+                }
+                else {
+                    const funcArg = evaluator([], arg, evalContext, thread);
+                    if (funcArg === null || funcArg === void 0 ? void 0 : funcArg._ARROW_EXPR_) {
+                        const wrappedFuncArg = createArrowFunction(evaluator, funcArg);
+                        const wrappedFunc = (...args) => wrappedFuncArg(funcArg.args, evalContext, thread, ...args);
+                        functionArgs.push(wrappedFunc);
+                    }
+                    else {
+                        functionArgs.push(funcArg);
+                    }
+                }
+            }
+        }
+        // --- We can pass implicit arguments to JavaScript function
+        if (implicitContextObject) {
+            // --- Let's obtain the implicit context
+            if (evalContext.implicitContextGetter) {
+                const implicitContext = evalContext.implicitContextGetter(implicitContextObject);
+                functionArgs.unshift(implicitContext);
+            }
+            else {
+                throw new Error("Cannot use implicitContextGetter, it is undefined");
+            }
+        }
+    }
+    // --- Check if the function is banned from running
+    const bannedInfo = (0, bannedFunctions_1.isBannedFunction)(functionObj);
+    if (bannedInfo.banned) {
+        throw new Error(`Function ${(_b = (_a = bannedInfo.func) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : "unknown"} is not allowed to call. ${(_c = bannedInfo === null || bannedInfo === void 0 ? void 0 : bannedInfo.help) !== null && _c !== void 0 ? _c : ""}`);
+    }
+    // --- We use context for "this"
+    const currentContext = thisStack.length > 0 ? thisStack.pop() : evalContext.localContext;
+    // --- Now, invoke the function
+    const value = ((_d = evalContext.options) === null || _d === void 0 ? void 0 : _d.defaultToOptionalMemberAccess)
+        ? functionObj === null || functionObj === void 0 ? void 0 : functionObj.call(currentContext, ...functionArgs)
+        : functionObj.call(currentContext, ...functionArgs);
+    thisStack.push(value);
+    return value;
+}
+function createArrowFunction(evaluator, expr) {
+    // --- Use this function, it evaluates the arrow function
+    return (...args) => {
+        var _a;
+        // --- Prepare the variables to pass
+        const runTimeEvalContext = args[1];
+        const runtimeThread = args[2];
+        // --- Create the thread that runs the arrow function
+        const workingThread = {
+            parent: runtimeThread,
+            childThreads: [],
+            blocks: [{ vars: {} }],
+            loops: [],
+            breakLabelValue: -1,
+            closures: expr.closureContext,
+        };
+        runtimeThread.childThreads.push(workingThread);
+        // --- Assign argument values to names
+        const arrowBlock = { vars: {} };
+        (_a = workingThread.blocks) !== null && _a !== void 0 ? _a : (workingThread.blocks = []);
+        workingThread.blocks.push(arrowBlock);
+        const argSpecs = args[0];
+        for (let i = 0; i < argSpecs.length; i++) {
+            // --- Turn argument specification into processable variable declarations
+            const argSpec = argSpecs[i];
+            let decl;
+            switch (argSpec.type) {
+                case "IdE": {
+                    decl = {
+                        type: "VarD",
+                        id: argSpec.name,
+                    };
+                    break;
+                }
+                case "Destr": {
+                    decl = {
+                        type: "VarD",
+                        id: argSpec.id,
+                        arrayDestruct: argSpec.arrayDestruct,
+                        objectDestruct: argSpec.objectDestruct,
+                    };
+                    break;
+                }
+                default:
+                    throw new Error("Unexpected arrow argument specification");
+            }
+            if (decl) {
+                // --- Get the actual value to work with
+                let argVal = args[i + 3];
+                if (argVal === null || argVal === void 0 ? void 0 : argVal._EXPRESSION_) {
+                    argVal = evaluator([], argVal, runTimeEvalContext, runtimeThread);
+                }
+                (0, process_statement_sync_1.processDeclarations)(arrowBlock, runTimeEvalContext, runtimeThread, [decl], false, true, argVal);
+            }
+        }
+        // --- Evaluate the arrow expression body
+        let returnValue;
+        let statements;
+        switch (expr.statement.type) {
+            case "EmptyS":
+                statements = [];
+                break;
+            case "ExprS":
+                // --- Create a new thread for the call
+                statements = [
+                    {
+                        type: "RetS",
+                        expression: expr.statement.expression,
+                    },
+                ];
+                break;
+            case "BlockS":
+                // --- Create a new thread for the call
+                statements = expr.statement.statements;
+                break;
+            default:
+                throw new Error(`Arrow expression with a body of '${expr.statement.type}' is not supported yet.`);
+        }
+        // --- Process the statement with a new processor
+        (0, process_statement_sync_1.processStatementQueue)(statements, runTimeEvalContext, workingThread);
+        // --- Return value is in a return value slot
+        returnValue = workingThread.returnValue;
+        // --- Remove the current working thread
+        const workingIndex = runtimeThread.childThreads.indexOf(workingThread);
+        if (workingIndex < 0) {
+            throw new Error("Cannot find thread to remove.");
+        }
+        runtimeThread.childThreads.splice(workingIndex, 1);
+        // --- Remove the function level block
+        workingThread.blocks.pop();
+        // --- Return the function value
+        return returnValue;
+    };
+}

package/dist/scripts/src/components-core/script-runner/modules.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isModuleErrors = isModuleErrors;
+exports.parseScriptModule = parseScriptModule;
+const Parser_1 = require("../../parsers/scripting/Parser");
+const Token_1 = require("../../abstractions/scripting/Token");
+const process_statement_async_1 = require("./process-statement-async");
+const tree_visitor_1 = require("../../parsers/scripting/tree-visitor");
+const ParserError_1 = require("../../parsers/scripting/ParserError");
+/**
+ * Checks if the result is a module error
+ * @param result Result to check
+ * @returns True if the result is a module error
+ */
+function isModuleErrors(result) {
+    return result.type !== "ScriptModule";
+}
+/**
+ * Parses a script module
+ * @param moduleName Name of the module
+ * @param source Source code to parse
+ * @param moduleResolver A function that resolves a module path to the text of the module
+ * @returns The parsed and resolved module
+ */
+function parseScriptModule(moduleName, source, moduleResolver, restrictiveMode = false) {
+    // --- Keep track of parsed modules to avoid circular references
+    const parsedModules = new Map();
+    const moduleErrors = {};
+    const parsedModule = doParseModule(moduleName, source, moduleResolver, true);
+    return !parsedModule || Object.keys(moduleErrors).length > 0 ? moduleErrors : parsedModule;
+    // --- Do the parsing, allow recursion
+    function doParseModule(moduleName, source, moduleResolver, topLevel = false) {
+        var _a;
+        // --- Do not parse the same module twice
+        if (parsedModules.has(moduleName)) {
+            return parsedModules.get(moduleName);
+        }
+        // --- Parse the source code
+        const parser = new Parser_1.Parser(source);
+        let statements = [];
+        try {
+            statements = parser.parseStatements();
+        }
+        catch (error) {
+            moduleErrors[moduleName] = parser.errors;
+            return null;
+        }
+        // --- Check for unparsed tail
+        const lastToken = parser.current;
+        if (lastToken.type !== Token_1.TokenType.Eof) {
+            (_a = moduleErrors[moduleName]) !== null && _a !== void 0 ? _a : (moduleErrors[moduleName] = []);
+            moduleErrors[moduleName].push({
+                code: "W002",
+                text: ParserError_1.errorMessages["W002"].replace(/\{(\d+)}/g, () => lastToken.text),
+                position: lastToken.location.startLine,
+                line: lastToken.location.startLine,
+                column: lastToken.location.startColumn,
+            });
+            return null;
+        }
+        const errors = [];
+        // --- Visit all statements in the module
+        const emptyState = {
+            data: null,
+            cancel: false,
+            skipChildren: false,
+        };
+        (0, tree_visitor_1.visitNode)(statements, emptyState, (before, stmt, state, parent, tag) => {
+            if (!before)
+                return state;
+            if (topLevel) {
+                // --- Restrict top-level statements
+                switch (stmt.type) {
+                    case "VarS":
+                        // --- Allow on top-level var declarations in a top-level module
+                        if (parent) {
+                            addErrorMessage("W027", stmt);
+                        }
+                        break;
+                    case "FuncD":
+                    case "ImportD":
+                        break;
+                    default:
+                        if (restrictiveMode && !parent) {
+                            addErrorMessage("W028", stmt, stmt.type);
+                        }
+                        break;
+                }
+            }
+            else {
+                switch (stmt.type) {
+                    case "VarS":
+                        addErrorMessage("W027", stmt);
+                        break;
+                    case "FuncD":
+                        if (restrictiveMode && !stmt.isExported) {
+                            addErrorMessage("W029", stmt);
+                        }
+                        break;
+                    case "ImportD":
+                        break;
+                    default:
+                        if (restrictiveMode && !parent) {
+                            addErrorMessage("W028", stmt, stmt.type);
+                        }
+                        break;
+                }
+            }
+            return state;
+        });
+        // // --- Check for forbidden "var" declarations
+        // statements.forEach((stmt) => {
+        //   if (topLevel) {
+        //     // --- Restrict top-level statements
+        //     switch (stmt.type) {
+        //       case "VarS":
+        //       case "FuncD":
+        //       case "ImportD":
+        //         break;
+        //       default:
+        //         if (restrictiveMode) {
+        //           addErrorMessage("W028", stmt, stmt.type);
+        //         }
+        //         break;
+        //     }
+        //   } else {
+        //     switch (stmt.type) {
+        //       case "VarS":
+        //         addErrorMessage("W027", stmt);
+        //         break;
+        //       case "FuncD":
+        //         if (restrictiveMode && !stmt.isExported) {
+        //           addErrorMessage("W029", stmt);
+        //         }
+        //         break;
+        //       case "ImportD":
+        //         break;
+        //       default:
+        //         if (restrictiveMode) {
+        //           addErrorMessage("W028", stmt, stmt.type);
+        //         }
+        //         break;
+        //     }
+        //   }
+        // });
+        // --- Hoist functions
+        const functions = {};
+        statements
+            .filter((stmt) => stmt.type === "FuncD")
+            .forEach((stmt) => {
+            const func = stmt;
+            if (functions[func.name]) {
+                addErrorMessage("W020", stmt, func.name);
+                return;
+            }
+            functions[func.name] = func;
+        });
+        // --- Collect exports
+        const exports = new Map();
+        statements.forEach((stmt) => {
+            if (stmt.type === "ConstS" && stmt.isExported) {
+                (0, process_statement_async_1.visitLetConstDeclarations)(stmt, (id) => {
+                    if (exports.has(id)) {
+                        addErrorMessage("W021", stmt, id);
+                    }
+                    else {
+                        exports.set(id, stmt);
+                    }
+                });
+            }
+            else if (stmt.type === "FuncD" && stmt.isExported) {
+                if (exports.has(stmt.name)) {
+                    addErrorMessage("W021", stmt, stmt.name);
+                }
+                else {
+                    exports.set(stmt.name, stmt);
+                }
+            }
+        });
+        // --- Successful module parsing
+        const parsedModule = {
+            type: "ScriptModule",
+            name: moduleName,
+            exports,
+            importedModules: [],
+            imports: [],
+            functions,
+            statements,
+            executed: false,
+        };
+        // --- Sign this module as parsed
+        parsedModules.set(moduleName, parsedModule);
+        // --- Load imported modules and resolve imports
+        const importedModules = [];
+        const imports = {};
+        for (let i = 0; i < statements.length; i++) {
+            const stmt = statements[i];
+            if (stmt.type !== "ImportD") {
+                continue;
+            }
+            // --- Find the imported module
+            const source = moduleResolver(moduleName, stmt.moduleFile);
+            if (source === null) {
+                addErrorMessage("W022", stmt, stmt.moduleFile);
+                continue;
+            }
+            // --- Parse the imported module
+            const imported = doParseModule(stmt.moduleFile, source, moduleResolver);
+            if (!imported) {
+                // --- Error in the imported module
+                return;
+            }
+            // --- Successful import
+            importedModules.push(imported);
+            // --- Extract imported names
+            for (const key in stmt.imports) {
+                if (imported.exports.has(stmt.imports[key])) {
+                    imports[key] = imported.exports.get(stmt.imports[key]);
+                }
+                else {
+                    addErrorMessage("W023", stmt, stmt.moduleFile, key);
+                }
+            }
+        }
+        // --- Catch errors
+        if (errors.length > 0) {
+            moduleErrors[moduleName] = errors;
+            return null;
+        }
+        // --- All imported modules use this module as a parent
+        importedModules.forEach((m) => (m.parent = parsedModule));
+        // --- Done.
+        parsedModule.importedModules = importedModules;
+        parsedModule.imports = imports;
+        return parsedModule;
+        function addErrorMessage(code, stmt, ...args) {
+            let errorText = ParserError_1.errorMessages[code];
+            if (args) {
+                args.forEach((o, idx) => (errorText = errorText.replaceAll(`{${idx}}`, args[idx].toString())));
+            }
+            errors.push({
+                code,
+                text: ParserError_1.errorMessages[code].replace(/\{(\d+)}/g, (_, index) => args[index]),
+                position: stmt.startPosition,
+                line: stmt.startLine,
+                column: stmt.startColumn,
+            });
+        }
+    }
+}