xmlui 0.11.3 → 0.11.6

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

@@ -1,613 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.evalBindingAsync = evalBindingAsync;
-exports.executeArrowExpression = executeArrowExpression;
-exports.completeExprValue = completeExprValue;
-const lodash_es_1 = require("lodash-es");
-const ScriptingSourceTree_1 = require("./ScriptingSourceTree");
-const process_statement_async_1 = require("./process-statement-async");
-const eval_tree_common_1 = require("./eval-tree-common");
-const process_statement_common_1 = require("./process-statement-common");
-const asyncProxy_1 = require("./asyncProxy");
-const bannedFunctions_1 = require("./bannedFunctions");
-/**
- * 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
- * @param onStatementCompleted Execute this function when a statement is completed
- */
-function evalBindingAsync(expr, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // --- Prepare the evaluation context
-        const thisStack = [];
-        (0, process_statement_common_1.ensureMainThread)(evalContext);
-        thread !== null && thread !== void 0 ? thread : (thread = evalContext.mainThread);
-        // --- Evaluate the expression using the context
-        return yield evalBindingExpressionTreeAsync(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 onStatementCompleted Execute this function when a statement is completed
- * @param thread The logical thread to use for evaluation
- * @param args Arguments of the arrow function to execute
- */
-function executeArrowExpression(expr, evalContext, thread, ...args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // --- Just an extra safety check
-        if (expr.type !== ScriptingSourceTree_1.T_ARROW_EXPRESSION) {
-            throw new Error("executeArrowExpression expects an 'ArrowExpression' object.");
-        }
-        // --- This is the evaluator that an arrow expression uses internally
-        const evaluator = evalBindingExpressionTreeAsync;
-        // --- Compiles the Arrow function to a JavaScript function
-        const nativeFunction = yield createArrowFunctionAsync(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 yield 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
- * @param onStatementCompleted Execute this function when a statement is completed
- * 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 evalBindingExpressionTreeAsync(thisStack, expr, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!evalContext.options) {
-            evalContext.options = { defaultToOptionalMemberAccess: true };
-        }
-        // --- Prepare evaluation
-        const evaluator = evalBindingExpressionTreeAsync;
-        // --- Process the expression according to its type
-        try {
-            switch (expr.type) {
-                case ScriptingSourceTree_1.T_TEMPLATE_LITERAL_EXPRESSION:
-                    return evalTemplateLiteralAsync(evaluator, thisStack, expr, evalContext, thread);
-                case ScriptingSourceTree_1.T_LITERAL:
-                    return (0, eval_tree_common_1.evalLiteral)(thisStack, expr, thread);
-                case ScriptingSourceTree_1.T_IDENTIFIER:
-                    return (0, eval_tree_common_1.evalIdentifier)(thisStack, expr, evalContext, thread);
-                case ScriptingSourceTree_1.T_MEMBER_ACCESS_EXPRESSION:
-                    return yield evalMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread);
-                case ScriptingSourceTree_1.T_CALCULATED_MEMBER_ACCESS_EXPRESSION:
-                    return yield evalCalculatedMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread);
-                case ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION:
-                    return yield evalSequenceAsync(evaluator, thisStack, expr, evalContext, thread);
-                case ScriptingSourceTree_1.T_ARRAY_LITERAL:
-                    return yield evalArrayLiteralAsync(evaluator, thisStack, expr, evalContext, thread);
-                case ScriptingSourceTree_1.T_OBJECT_LITERAL:
-                    return yield evalObjectLiteralAsync(evaluator, thisStack, expr, evalContext, thread);
-                case ScriptingSourceTree_1.T_UNARY_EXPRESSION:
-                    return yield evalUnaryAsync(evaluator, thisStack, expr, evalContext, thread);
-                case ScriptingSourceTree_1.T_BINARY_EXPRESSION:
-                    return yield evalBinaryAsync(evaluator, thisStack, expr, evalContext, thread);
-                case ScriptingSourceTree_1.T_CONDITIONAL_EXPRESSION:
-                    return yield evalConditionalAsync(evaluator, thisStack, expr, evalContext, thread);
-                case ScriptingSourceTree_1.T_ASSIGNMENT_EXPRESSION:
-                    return yield evalAssignmentAsync(evaluator, thisStack, expr, evalContext, thread);
-                case ScriptingSourceTree_1.T_PREFIX_OP_EXPRESSION:
-                case ScriptingSourceTree_1.T_POSTFIX_OP_EXPRESSION:
-                    return yield evalPreOrPostAsync(evaluator, thisStack, expr, evalContext, thread);
-                case ScriptingSourceTree_1.T_FUNCTION_INVOCATION_EXPRESSION:
-                    // --- Special async handling
-                    return yield evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, thread);
-                case ScriptingSourceTree_1.T_ARROW_EXPRESSION:
-                    return (0, eval_tree_common_1.evalArrow)(thisStack, expr, thread);
-                case ScriptingSourceTree_1.T_SPREAD_EXPRESSION:
-                    throw new Error("Cannot use spread expression (...) with the current intermediate value.");
-                default:
-                    throw new Error(`Unknown expression tree node: ${expr.type}`);
-            }
-        }
-        catch (e) {
-            //TODO decorate error with expression details (startColumn, startLine, startPosition, etc.)
-            throw e;
-        }
-    });
-}
-function evalMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield evaluator(thisStack, expr.obj, evalContext, thread);
-        yield completeExprValue(expr.obj, 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.
-        return (0, eval_tree_common_1.evalMemberAccessCore)(thisStack, expr, evalContext, thread);
-    });
-}
-function evalCalculatedMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield evaluator(thisStack, expr.obj, evalContext, thread);
-        yield completeExprValue(expr.obj, thread);
-        yield evaluator(thisStack, expr.member, evalContext, thread);
-        thisStack.pop();
-        yield completeExprValue(expr.member, thread);
-        return (0, eval_tree_common_1.evalCalculatedMemberAccessCore)(thisStack, expr, evalContext, thread);
-    });
-}
-function evalSequenceAsync(evaluator, thisStack, expr, evalContext, thread) {
-    if (!expr.exprs || expr.exprs.length === 0) {
-        throw new Error(`Missing expression sequence`);
-    }
-    const result = expr.exprs.map((e) => __awaiter(this, void 0, void 0, function* () {
-        const value = yield evaluator(thisStack, e, evalContext, thread);
-        (0, eval_tree_common_1.setExprValue)(e, { value }, thread);
-        thisStack.pop();
-        return value;
-    }));
-    const lastObj = result[result.length - 1];
-    thisStack.push(lastObj);
-    return lastObj;
-}
-function evalArrayLiteralAsync(evaluator, thisStack, expr, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const value = [];
-        for (const item of expr.items) {
-            if (item.type === ScriptingSourceTree_1.T_SPREAD_EXPRESSION) {
-                const spreadArray = yield evaluator(thisStack, item.expr, evalContext, thread);
-                thisStack.pop();
-                if (!Array.isArray(spreadArray)) {
-                    throw new Error("Spread operator within an array literal expects an array operand.");
-                }
-                value.push(...spreadArray);
-            }
-            else {
-                value.push(yield evaluator(thisStack, item, evalContext, thread));
-                thisStack.pop();
-                thisStack.push(value);
-            }
-        }
-        // --- Done.
-        (0, eval_tree_common_1.setExprValue)(expr, { value }, thread);
-        thisStack.push(value);
-        return value;
-    });
-}
-function evalObjectLiteralAsync(evaluator, thisStack, expr, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const objectHash = {};
-        for (const prop of expr.props) {
-            if (!Array.isArray(prop)) {
-                // --- We're using a spread expression
-                const spreadItems = yield evaluator(thisStack, prop.expr, 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 ScriptingSourceTree_1.T_LITERAL:
-                    key = prop[0].value;
-                    break;
-                case ScriptingSourceTree_1.T_IDENTIFIER:
-                    key = prop[0].name;
-                    break;
-                default:
-                    key = yield evaluator(thisStack, prop[0], evalContext, thread);
-                    thisStack.pop();
-                    break;
-            }
-            objectHash[key] = yield evaluator(thisStack, prop[1], evalContext, thread);
-            thisStack.pop();
-        }
-        // --- Done.
-        (0, eval_tree_common_1.setExprValue)(expr, { value: objectHash }, thread);
-        thisStack.push(objectHash);
-        return objectHash;
-    });
-}
-function evalUnaryAsync(evaluator, thisStack, expr, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield evaluator(thisStack, expr.expr, evalContext, thread);
-        thisStack.pop();
-        yield completeExprValue(expr.expr, thread);
-        return (0, eval_tree_common_1.evalUnaryCore)(expr, thisStack, evalContext, thread);
-    });
-}
-function evalBinaryAsync(evaluator, thisStack, expr, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield evaluator(thisStack, expr.left, evalContext, thread);
-        thisStack.pop();
-        const l = yield completeExprValue(expr.left, thread);
-        if (expr.op === "&&" && !l) {
-            (0, eval_tree_common_1.setExprValue)(expr, { value: l }, thread);
-            thisStack.push(l);
-            return l;
-        }
-        if (expr.op === "||" && l) {
-            (0, eval_tree_common_1.setExprValue)(expr, { value: l }, thread);
-            thisStack.push(l);
-            return l;
-        }
-        yield evaluator(thisStack, expr.right, evalContext, thread);
-        thisStack.pop();
-        yield completeExprValue(expr.right, thread);
-        return (0, eval_tree_common_1.evalBinaryCore)(expr, thisStack, evalContext, thread);
-    });
-}
-function evalConditionalAsync(evaluator, thisStack, expr, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield evaluator(thisStack, expr.cond, evalContext, thread);
-        thisStack.pop();
-        const condition = yield completeExprValue(expr.cond, thread);
-        const value = yield evaluator(thisStack, condition ? expr.thenE : expr.elseE, evalContext, thread);
-        (0, eval_tree_common_1.setExprValue)(expr, { value }, thread);
-        return value;
-    });
-}
-function evalAssignmentAsync(evaluator, thisStack, expr, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const leftValue = expr.leftValue;
-        const rootScope = (0, eval_tree_common_1.getRootIdScope)(leftValue, evalContext, thread);
-        const updatesState = rootScope && rootScope.type !== "block";
-        if (updatesState && evalContext.onWillUpdate) {
-            void evalContext.onWillUpdate(rootScope, rootScope.name, "assignment");
-        }
-        yield evaluator(thisStack, leftValue, evalContext, thread);
-        thisStack.pop();
-        yield completeExprValue(leftValue, thread);
-        yield evaluator(thisStack, expr.expr, evalContext, thread);
-        thisStack.pop();
-        yield completeExprValue(expr.expr, thread);
-        const value = (0, eval_tree_common_1.evalAssignmentCore)(thisStack, expr, evalContext, thread);
-        if (updatesState && evalContext.onDidUpdate) {
-            void evalContext.onDidUpdate(rootScope, rootScope.name, "assignment");
-        }
-        return value;
-    });
-}
-function evalPreOrPostAsync(evaluator, thisStack, expr, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const rootScope = (0, eval_tree_common_1.getRootIdScope)(expr.expr, evalContext, thread);
-        const updatesState = rootScope && rootScope.type !== "block";
-        if (updatesState && evalContext.onWillUpdate) {
-            void evalContext.onWillUpdate(rootScope, rootScope.name, "pre-post");
-        }
-        yield evaluator(thisStack, expr.expr, evalContext, thread);
-        thisStack.pop();
-        yield completeExprValue(expr.expr, thread);
-        const value = (0, eval_tree_common_1.evalPreOrPostCore)(thisStack, expr, evalContext, thread);
-        if (updatesState && evalContext.onDidUpdate) {
-            void evalContext.onDidUpdate(rootScope, rootScope.name, "pre-post");
-        }
-        return value;
-    });
-}
-function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
-        let functionObj;
-        let implicitContextObject = null;
-        // --- Check for contexted object
-        if (expr.obj.type === ScriptingSourceTree_1.T_MEMBER_ACCESS_EXPRESSION) {
-            const hostObject = yield evaluator(thisStack, expr.obj.obj, evalContext, thread);
-            yield completeExprValue(expr.obj.obj, thread);
-            functionObj = (0, eval_tree_common_1.evalMemberAccessCore)(thisStack, expr.obj, evalContext, thread);
-            if (expr.obj.obj.type === ScriptingSourceTree_1.T_IDENTIFIER && (hostObject === null || hostObject === void 0 ? void 0 : hostObject._SUPPORT_IMPLICIT_CONTEXT)) {
-                implicitContextObject = hostObject;
-            }
-        }
-        else {
-            // --- Get the object on which to invoke the function
-            yield evaluator(thisStack, expr.obj, evalContext, thread);
-            functionObj = yield completeExprValue(expr.obj, 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 = yield createArrowFunctionAsync(evaluator, functionObj);
-        }
-        else if (expr.obj.type === ScriptingSourceTree_1.T_ARROW_EXPRESSION) {
-            // --- We delay evaluating expression values. We pass the argument names as the first parameter, and then
-            // --- all parameter expressions
-            functionArgs.push(expr.obj.args.map((a) => a.name), 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 === ScriptingSourceTree_1.T_SPREAD_EXPRESSION) {
-                    yield evaluator([], arg.expr, evalContext, thread);
-                    const funcArg = yield completeExprValue(arg.expr, 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 === ScriptingSourceTree_1.T_ARROW_EXPRESSION) {
-                        const funcArg = createArrowFunctionAsync(evaluator, arg);
-                        const wrappedFunc = (...args) => {
-                            return funcArg(arg.args, evalContext, thread, ...args);
-                        };
-                        functionArgs.push(wrappedFunc);
-                    }
-                    else {
-                        yield evaluator([], arg, evalContext, thread);
-                        const funcArg = yield completeExprValue(arg, thread);
-                        if (funcArg === null || funcArg === void 0 ? void 0 : funcArg._ARROW_EXPR_) {
-                            const wrappedFuncArg = createArrowFunctionAsync(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;
-        // --- We need to use proxies for JavaScript functions (such as Array.prototype.filter) not supporting
-        // --- async arguments
-        functionObj = (0, asyncProxy_1.getAsyncProxy)(functionObj, functionArgs, currentContext);
-        // --- Now, invoke the function
-        const rootScope = (0, eval_tree_common_1.getRootIdScope)(expr.obj, evalContext, thread);
-        const updatesState = rootScope && rootScope.type !== "block";
-        if (updatesState && evalContext.onWillUpdate) {
-            void evalContext.onWillUpdate(rootScope, rootScope.name, "function-call");
-        }
-        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);
-        let returnValue = yield completePromise(value);
-        if (updatesState && evalContext.onDidUpdate) {
-            void evalContext.onDidUpdate(rootScope, rootScope.name, "function-call");
-        }
-        // --- Done.
-        (0, eval_tree_common_1.setExprValue)(expr, { value: returnValue }, thread);
-        thisStack.push(returnValue);
-        return returnValue;
-    });
-}
-function createArrowFunctionAsync(evaluator, expr) {
-    // --- Use this function, it evaluates the arrow function
-    return (...args) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        // --- 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);
-        // --- Create a block for a named arrow function
-        if (expr.name) {
-            const functionBlock = { vars: {} };
-            (_a = workingThread.blocks) !== null && _a !== void 0 ? _a : (workingThread.blocks = []);
-            workingThread.blocks.push(functionBlock);
-            functionBlock.vars[expr.name] = expr;
-            functionBlock.constVars = new Set([expr.name]);
-        }
-        // --- Assign argument values to names
-        const arrowBlock = { vars: {} };
-        (_b = workingThread.blocks) !== null && _b !== void 0 ? _b : (workingThread.blocks = []);
-        workingThread.blocks.push(arrowBlock);
-        const argSpecs = args[0];
-        let restFound = false;
-        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 ScriptingSourceTree_1.T_IDENTIFIER: {
-                    decl = {
-                        type: ScriptingSourceTree_1.T_VAR_DECLARATION,
-                        id: argSpec.name,
-                    };
-                    break;
-                }
-                case ScriptingSourceTree_1.T_DESTRUCTURE: {
-                    decl = {
-                        type: ScriptingSourceTree_1.T_VAR_DECLARATION,
-                        id: argSpec.id,
-                        aDestr: argSpec.aDestr,
-                        oDestr: argSpec.oDestr,
-                    };
-                    break;
-                }
-                case ScriptingSourceTree_1.T_SPREAD_EXPRESSION: {
-                    restFound = true;
-                    decl = {
-                        type: ScriptingSourceTree_1.T_VAR_DECLARATION,
-                        id: argSpec.expr.name,
-                    };
-                    break;
-                }
-                default:
-                    throw new Error("Unexpected arrow argument specification");
-            }
-            if (decl) {
-                if (restFound) {
-                    // --- Get the rest of the arguments
-                    const restArgs = args.slice(i + 3);
-                    let argVals = [];
-                    for (const arg of restArgs) {
-                        if (arg === null || arg === void 0 ? void 0 : arg._EXPRESSION_) {
-                            argVals.push(yield evaluator([], arg, runTimeEvalContext, runtimeThread));
-                        }
-                        else {
-                            argVals.push(arg);
-                        }
-                    }
-                    yield (0, process_statement_async_1.processDeclarationsAsync)(arrowBlock, runTimeEvalContext, runtimeThread, [decl], false, true, argVals);
-                }
-                else {
-                    // --- Get the actual value to work with
-                    let argVal = args[i + 3];
-                    if (argVal === null || argVal === void 0 ? void 0 : argVal._EXPRESSION_) {
-                        argVal = yield evaluator([], argVal, runTimeEvalContext, runtimeThread);
-                    }
-                    yield (0, process_statement_async_1.processDeclarationsAsync)(arrowBlock, runTimeEvalContext, runtimeThread, [decl], false, true, argVal);
-                }
-            }
-        }
-        // --- Evaluate the arrow expression body
-        let returnValue;
-        let statements;
-        switch (expr.statement.type) {
-            case ScriptingSourceTree_1.T_EMPTY_STATEMENT:
-                statements = [];
-                break;
-            case ScriptingSourceTree_1.T_EXPRESSION_STATEMENT:
-                // --- Create a new thread for the call
-                statements = [
-                    {
-                        type: ScriptingSourceTree_1.T_RETURN_STATEMENT,
-                        expr: expr.statement.expr,
-                    },
-                ];
-                break;
-            case ScriptingSourceTree_1.T_BLOCK_STATEMENT:
-                // --- Create a new thread for the call
-                statements = expr.statement.stmts;
-                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
-        yield (0, process_statement_async_1.processStatementQueueAsync)(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;
-    });
-}
-// --- Completes all promises within the input
-function completePromise(input) {
-    const visited = new Map();
-    return completePromiseInternal(input);
-    function completePromiseInternal(input) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // --- No need to resolve undefined or null
-            if (input === undefined || input === null)
-                return input;
-            // --- Already visited?
-            const resolved = visited.get(input);
-            if (resolved)
-                return resolved;
-            // --- Resolve the chain of promises
-            if ((0, eval_tree_common_1.isPromise)(input)) {
-                const awaited = yield input;
-                visited.set(input, awaited);
-                return completePromiseInternal(awaited);
-            }
-            // --- In any other cases, we keep the input reference
-            visited.set(input, input);
-            // --- Resolve promises within an array
-            if (Array.isArray(input)) {
-                for (let i = 0; i < input.length; i++) {
-                    const completedPromise = yield completePromiseInternal(input[i]);
-                    if (input[i] !== completedPromise) {
-                        //prevent write if it's the same reference (can cause problems in frozen objects)
-                        input.splice(i, 1, completedPromise);
-                    }
-                }
-                return input;
-            }
-            // --- Resolve promises in object properties
-            if ((0, lodash_es_1.isPlainObject)(input)) {
-                for (const key of Object.keys(input)) {
-                    let completedPromise = yield completePromiseInternal(input[key]);
-                    if (input[key] !== completedPromise) {
-                        //prevent write if it's the same reference (can cause problems in frozen objects)
-                        input[key] = completedPromise;
-                    }
-                }
-                return input;
-            }
-            // --- Done.
-            return input;
-        });
-    }
-}
-function evalTemplateLiteralAsync(evaluator, thisStack, expr, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const segmentValues = new Array(expr.segments.length);
-        for (let i = 0; i < expr.segments.length; ++i) {
-            yield evaluator(thisStack, expr.segments[i], evalContext, thread);
-            thisStack.pop();
-            const evaledValue = yield completeExprValue(expr.segments[i], thread);
-            segmentValues[i] = evaledValue;
-        }
-        const value = (0, eval_tree_common_1.evalTemplateLiteralCore)(segmentValues);
-        (0, eval_tree_common_1.setExprValue)(expr, { value }, thread);
-        thisStack.push(value);
-        return value;
-    });
-}
-function completeExprValue(expr, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const exprValue = (0, eval_tree_common_1.getExprValue)(expr, thread);
-        const awaited = yield completePromise(exprValue === null || exprValue === void 0 ? void 0 : exprValue.value);
-        (0, eval_tree_common_1.setExprValue)(expr, Object.assign(Object.assign({}, exprValue), { value: awaited }), thread);
-        return awaited;
-    });
-}