xmlui 0.11.3 → 0.11.6

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

@@ -1,522 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.evalBindingExpression = evalBindingExpression;
-exports.evalBinding = evalBinding;
-exports.executeArrowExpressionSync = executeArrowExpressionSync;
-const ScriptingSourceTree_1 = require("./ScriptingSourceTree");
-const Parser_1 = require("../../parsers/scripting/Parser");
-const bannedFunctions_1 = require("./bannedFunctions");
-const eval_tree_common_1 = require("./eval-tree-common");
-const process_statement_common_1 = require("./process-statement-common");
-const process_statement_sync_1 = require("./process-statement-sync");
-/**
- * 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 !== 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 = evalBindingExpressionTree;
-    // --- Compiles the Arrow function to a JavaScript function
-    const nativeFunction = createArrowFunction(evaluator, expr, evalContext);
-    // --- 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
-    const evaluator = evalBindingExpressionTree;
-    // --- Process the expression according to its type
-    switch (expr.type) {
-        case ScriptingSourceTree_1.T_TEMPLATE_LITERAL_EXPRESSION:
-            return evalTemplateLiteral(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 evalMemberAccess(evaluator, thisStack, expr, evalContext, thread);
-        case ScriptingSourceTree_1.T_CALCULATED_MEMBER_ACCESS_EXPRESSION:
-            return evalCalculatedMemberAccess(evaluator, thisStack, expr, evalContext, thread);
-        case ScriptingSourceTree_1.T_SEQUENCE_EXPRESSION:
-            return evalSequence(evaluator, thisStack, expr, evalContext, thread);
-        case ScriptingSourceTree_1.T_ARRAY_LITERAL:
-            return evalArrayLiteral(evaluator, thisStack, expr, evalContext, thread);
-        case ScriptingSourceTree_1.T_OBJECT_LITERAL:
-            return evalObjectLiteral(evaluator, thisStack, expr, evalContext, thread);
-        case ScriptingSourceTree_1.T_UNARY_EXPRESSION:
-            return evalUnary(evaluator, thisStack, expr, evalContext, thread);
-        case ScriptingSourceTree_1.T_BINARY_EXPRESSION:
-            return evalBinary(evaluator, thisStack, expr, evalContext, thread);
-        case ScriptingSourceTree_1.T_CONDITIONAL_EXPRESSION:
-            return evalConditional(evaluator, thisStack, expr, evalContext, thread);
-        case ScriptingSourceTree_1.T_ASSIGNMENT_EXPRESSION:
-            return evalAssignment(evaluator, thisStack, expr, evalContext, thread);
-        case ScriptingSourceTree_1.T_PREFIX_OP_EXPRESSION:
-        case ScriptingSourceTree_1.T_POSTFIX_OP_EXPRESSION:
-            return evalPreOrPost(evaluator, thisStack, expr, evalContext, thread);
-        case ScriptingSourceTree_1.T_FUNCTION_INVOCATION_EXPRESSION:
-            // --- 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 ScriptingSourceTree_1.T_ARROW_EXPRESSION:
-            // --- Special sync handling
-            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}`);
-    }
-}
-function evalTemplateLiteral(evaluator, thisStack, expr, evalContext, thread) {
-    const segmentValues = expr.segments.map((s) => {
-        const evaledValue = evaluator(thisStack, s, evalContext, thread);
-        thisStack.pop();
-        return 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 evalMemberAccess(evaluator, thisStack, expr, evalContext, thread) {
-    evaluator(thisStack, expr.obj, 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.
-    return (0, eval_tree_common_1.evalMemberAccessCore)(thisStack, expr, evalContext, thread);
-}
-function evalCalculatedMemberAccess(evaluator, thisStack, expr, evalContext, thread) {
-    evaluator(thisStack, expr.obj, evalContext, thread);
-    evaluator(thisStack, expr.member, evalContext, thread);
-    thisStack.pop();
-    return (0, eval_tree_common_1.evalCalculatedMemberAccessCore)(thisStack, expr, evalContext, thread);
-}
-function evalSequence(evaluator, thisStack, expr, evalContext, thread) {
-    if (!expr.exprs || expr.exprs.length === 0) {
-        throw new Error(`Missing expression sequence`);
-    }
-    const result = expr.exprs.map((e) => {
-        const value = 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 evalArrayLiteral(evaluator, thisStack, expr, evalContext, thread) {
-    const value = [];
-    for (const item of expr.items) {
-        if (item.type === ScriptingSourceTree_1.T_SPREAD_EXPRESSION) {
-            const spreadArray = 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(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 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.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 = evaluator(thisStack, prop[0], evalContext, thread);
-                thisStack.pop();
-                break;
-        }
-        objectHash[key] = 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 evalUnary(evaluator, thisStack, expr, evalContext, thread) {
-    evaluator(thisStack, expr.expr, evalContext, thread);
-    thisStack.pop();
-    return (0, eval_tree_common_1.evalUnaryCore)(expr, thisStack, evalContext, thread);
-}
-function evalBinary(evaluator, thisStack, expr, evalContext, thread) {
-    var _a;
-    evaluator(thisStack, expr.left, evalContext, thread);
-    thisStack.pop();
-    const l = (_a = (0, eval_tree_common_1.getExprValue)(expr.left, thread)) === null || _a === void 0 ? void 0 : _a.value;
-    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;
-    }
-    if (expr.op === "??" && l !== null && l !== undefined) {
-        (0, eval_tree_common_1.setExprValue)(expr, { value: l }, thread);
-        thisStack.push(l);
-        return l;
-    }
-    evaluator(thisStack, expr.right, evalContext, thread);
-    thisStack.pop();
-    return (0, eval_tree_common_1.evalBinaryCore)(expr, thisStack, evalContext, thread);
-}
-function evalConditional(evaluator, thisStack, expr, evalContext, thread) {
-    const condition = evaluator(thisStack, expr.cond, evalContext, thread);
-    thisStack.pop();
-    const value = evaluator(thisStack, condition ? expr.thenE : expr.elseE, evalContext, thread);
-    (0, eval_tree_common_1.setExprValue)(expr, { value }, thread);
-    return value;
-}
-function evalAssignment(evaluator, thisStack, expr, evalContext, thread) {
-    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");
-    }
-    evaluator(thisStack, leftValue, evalContext, thread);
-    thisStack.pop();
-    evaluator(thisStack, expr.expr, evalContext, thread);
-    thisStack.pop();
-    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 evalPreOrPost(evaluator, thisStack, expr, evalContext, thread) {
-    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");
-    }
-    evaluator(thisStack, expr.expr, evalContext, thread);
-    thisStack.pop();
-    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 evalFunctionInvocation(evaluator, thisStack, expr, evalContext, thread) {
-    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 = evaluator(thisStack, expr.obj.obj, evalContext, 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
-        functionObj = evaluator(thisStack, expr.obj, 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, evalContext);
-    }
-    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, 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) {
-                const funcArg = evaluator([], arg.expr, 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 === ScriptingSourceTree_1.T_ARROW_EXPRESSION) {
-                    const funcArg = createArrowFunction(evaluator, arg, evalContext);
-                    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, evalContext);
-                        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 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);
-    if (updatesState && evalContext.onDidUpdate) {
-        void evalContext.onDidUpdate(rootScope, rootScope.name, "function-call");
-    }
-    (0, eval_tree_common_1.setExprValue)(expr, { value }, thread);
-    thisStack.push(value);
-    return value;
-}
-function createArrowFunction(evaluator, expr, evalContext) {
-    // --- Use this function, it evaluates the arrow function
-    return (...args) => {
-        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(evaluator([], arg, runTimeEvalContext, runtimeThread));
-                        }
-                        else {
-                            argVals.push(arg);
-                        }
-                    }
-                    (0, process_statement_sync_1.processDeclarations)(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 = 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 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,
-                        nodeId: (0, Parser_1.createXmlUiTreeNodeId)(),
-                        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
-        (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;
-    };
-}