xmlui 0.4.0

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

@@ -0,0 +1,551 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evalBindingAsync = evalBindingAsync;
+exports.executeArrowExpression = executeArrowExpression;
+exports.isConstVar = isConstVar;
+const isPlainObject_1 = __importDefault(require("lodash/isPlainObject")); //doesn't work when we import it through lodash-es (build.ts uses it...)
+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, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const thisStack = [];
+        (0, process_statement_common_1.ensureMainThread)(evalContext);
+        thread !== null && thread !== void 0 ? thread : (thread = evalContext.mainThread);
+        return yield evalBindingExpressionTreeAsync(thisStack, expr, evalContext, thread !== null && thread !== void 0 ? thread : evalContext.mainThread, onStatementCompleted);
+    });
+}
+/**
+ * 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, onStatementCompleted, thread, ...args) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // --- 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 = 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, onStatementCompleted, ...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, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!evalContext.options) {
+            evalContext.options = { defaultToOptionalMemberAccess: true };
+        }
+        // --- Prepare evaluation
+        let customOp = null;
+        const evaluator = evalBindingExpressionTreeAsync;
+        // --- Reset the expression scope
+        expr.valueScope = expr.valueIndex = undefined;
+        // --- Process the expression according to its type
+        try {
+            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 yield evalMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
+                case "CMembE":
+                    return yield evalCalculatedMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
+                case "SeqE":
+                    return yield evalSequenceAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
+                case "ALitE":
+                    return yield evalArrayLiteralAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
+                case "OLitE":
+                    return yield evalObjectLiteralAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
+                case "UnaryE":
+                    return yield evalUnaryAsync(evaluator, thisStack, customOp, expr, evalContext, thread, onStatementCompleted);
+                case "BinaryE":
+                    return yield evalBinaryAsync(evaluator, thisStack, customOp, expr, evalContext, thread, onStatementCompleted);
+                case "CondE":
+                    return yield evalConditionalAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
+                case "AsgnE":
+                    return yield evalAssignmentAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
+                case "PrefE":
+                case "PostfE":
+                    return yield evalPreOrPostAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
+                case "InvokeE":
+                    // --- Special async handling
+                    return yield evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted);
+                case "ArrowE":
+                    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}`);
+            }
+        }
+        catch (e) {
+            //TODO decorate error with expression details (startColumn, startLine, startPosition, etc.)
+            throw e;
+        }
+    });
+}
+function evalMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const parentObj = yield evaluator(thisStack, expr.object, evalContext, thread, onStatementCompleted);
+        return (0, eval_tree_common_1.evalMemberAccessCore)(parentObj, thisStack, expr, evalContext);
+    });
+}
+function evalCalculatedMemberAccessAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const parentObj = yield evaluator(thisStack, expr.object, evalContext, thread, onStatementCompleted);
+        // --- 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 = yield evaluator(thisStack, expr.member, evalContext, thread, onStatementCompleted);
+        thisStack.pop();
+        return (0, eval_tree_common_1.evalCalculatedMemberAccessCore)(parentObj, memberObj, thisStack, expr, evalContext);
+    });
+}
+function evalSequenceAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!expr.expressions || expr.expressions.length === 0) {
+            throw new Error(`Missing expression sequence`);
+        }
+        const result = expr.expressions.map((e) => __awaiter(this, void 0, void 0, function* () {
+            const exprValue = yield evaluator(thisStack, e, evalContext, thread, onStatementCompleted);
+            thisStack.pop();
+            return exprValue;
+        }));
+        const lastObj = result[result.length - 1];
+        thisStack.push(lastObj);
+        return lastObj;
+    });
+}
+function evalArrayLiteralAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const arrayValue = [];
+        for (const item of expr.items) {
+            if (item.type === "SpreadE") {
+                const spreadArray = yield evaluator(thisStack, item.operand, evalContext, thread, onStatementCompleted);
+                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(yield evaluator(thisStack, item, evalContext, thread, onStatementCompleted));
+                thisStack.pop();
+                thisStack.push(arrayValue);
+            }
+        }
+        return arrayValue;
+    });
+}
+function evalObjectLiteralAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+    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.operand, evalContext, thread, onStatementCompleted);
+                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 = yield evaluator(thisStack, prop[0], evalContext, thread, onStatementCompleted);
+                    thisStack.pop();
+                    break;
+            }
+            objectHash[key] = yield evaluator(thisStack, prop[1], evalContext, thread, onStatementCompleted);
+            thisStack.pop();
+        }
+        thisStack.push(objectHash);
+        return objectHash;
+    });
+}
+function evalUnaryAsync(evaluator, thisStack, customOp, expr, evalContext, thread, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const operand = yield evaluator(thisStack, expr.operand, evalContext, thread, onStatementCompleted);
+        thisStack.pop();
+        return (0, eval_tree_common_1.evalUnaryCore)(expr, operand, thisStack, customOp);
+    });
+}
+function evalBinaryAsync(evaluator, thisStack, customOp, expr, evalContext, thread, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const l = yield evaluator(thisStack, expr.left, evalContext, thread, onStatementCompleted);
+        thisStack.pop();
+        if (expr.operator === "&&" && !l) {
+            thisStack.push(l);
+            return l;
+        }
+        if (expr.operator === "||" && l) {
+            thisStack.push(l);
+            return l;
+        }
+        const r = yield evaluator(thisStack, expr.right, evalContext, thread, onStatementCompleted);
+        thisStack.pop();
+        return (0, eval_tree_common_1.evalBinaryCore)(l, r, thisStack, customOp, expr.operator);
+    });
+}
+function evalConditionalAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const condition = yield evaluator(thisStack, expr.condition, evalContext, thread, onStatementCompleted);
+        thisStack.pop();
+        return yield evaluator(thisStack, condition ? expr.consequent : expr.alternate, evalContext, thread, onStatementCompleted);
+    });
+}
+function runAssignment(evalContext, doAssignment) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const updateHook = evalContext.onUpdateHook || ((updateFn) => __awaiter(this, void 0, void 0, function* () { return yield updateFn(); }));
+        return yield updateHook(() => __awaiter(this, void 0, void 0, function* () {
+            return yield doAssignment();
+        }));
+    });
+}
+function evalAssignmentAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return runAssignment(evalContext, () => __awaiter(this, void 0, void 0, function* () {
+            const leftValue = expr.leftValue;
+            yield evaluator(thisStack, leftValue, evalContext, thread, onStatementCompleted);
+            thisStack.pop();
+            const newValue = yield evaluator(thisStack, expr.operand, evalContext, thread, onStatementCompleted);
+            thisStack.pop();
+            return (0, eval_tree_common_1.evalAssignmentCore)(leftValue, newValue, thisStack, expr, thread);
+        }));
+    });
+}
+function evalPreOrPostAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return runAssignment(evalContext, () => __awaiter(this, void 0, void 0, function* () {
+            const operand = expr.operand;
+            yield evaluator(thisStack, operand, evalContext, thread, onStatementCompleted);
+            thisStack.pop();
+            return (0, eval_tree_common_1.evalPreOrPostCore)(operand, thisStack, expr, evalContext, thread);
+        }));
+    });
+}
+function evalFunctionInvocationAsync(evaluator, thisStack, expr, evalContext, thread, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        let functionObj;
+        let implicitContextObject = null;
+        let hostObject;
+        // --- Check for contexted object
+        if (expr.object.type === "MembE") {
+            hostObject = yield evaluator(thisStack, expr.object.object, evalContext, thread, onStatementCompleted);
+            functionObj = (0, eval_tree_common_1.evalMemberAccessCore)(hostObject, thisStack, expr.object, evalContext);
+            if (expr.object.object.type === "IdE" && (hostObject === null || hostObject === void 0 ? void 0 : hostObject._SUPPORT_IMPLICIT_CONTEXT)) {
+                implicitContextObject = hostObject;
+            }
+        }
+        else {
+            // --- Get the object on which to invoke the function
+            functionObj = yield evaluator(thisStack, expr.object, evalContext, thread, onStatementCompleted);
+        }
+        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, onStatementCompleted, ...expr.arguments.map((a) => (Object.assign(Object.assign({}, a), { _EXPRESSION_: true }))));
+            functionObj = yield createArrowFunctionAsync(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.map((a) => a.name), evalContext, thread, onStatementCompleted, ...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 = yield evaluator([], arg.operand, evalContext, thread, onStatementCompleted);
+                    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 = yield createArrowFunctionAsync(evaluator, arg);
+                        const wrappedFunc = (...args) => __awaiter(this, void 0, void 0, function* () {
+                            return funcArg(arg.args, evalContext, thread, onStatementCompleted, ...args);
+                        });
+                        functionArgs.push(wrappedFunc);
+                    }
+                    else {
+                        const funcArg = yield evaluator([], arg, evalContext, thread, onStatementCompleted);
+                        if (funcArg === null || funcArg === void 0 ? void 0 : funcArg._ARROW_EXPR_) {
+                            const wrappedFuncArg = yield createArrowFunctionAsync(evaluator, funcArg);
+                            const wrappedFunc = (...args) => wrappedFuncArg(funcArg.args, evalContext, thread, onStatementCompleted, ...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
+        try {
+            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);
+            thisStack.push(returnValue);
+            return returnValue;
+        }
+        catch (err) {
+            console.log(typeof functionObj, functionObj);
+            throw err;
+        }
+    });
+}
+function createArrowFunctionAsync(evaluator, expr) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // --- Use this function, it evaluates the arrow function
+        return (...args) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // --- Prepare the variables to pass
+            const runTimeEvalContext = args[1];
+            const runtimeThread = args[2];
+            const runTimeOnStatementCompleted = args[3];
+            // --- 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 + 4];
+                    if (argVal === null || argVal === void 0 ? void 0 : argVal._EXPRESSION_) {
+                        argVal = yield evaluator([], argVal, runTimeEvalContext, runtimeThread, runTimeOnStatementCompleted);
+                    }
+                    yield (0, process_statement_async_1.processDeclarationsAsync)(arrowBlock, runTimeEvalContext, runtimeThread, runTimeOnStatementCompleted, [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
+            yield (0, process_statement_async_1.processStatementQueueAsync)(statements, runTimeEvalContext, workingThread, runTimeOnStatementCompleted);
+            // --- 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) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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, isPlainObject_1.default)(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;
+            });
+        }
+    });
+}
+/**
+ * Gets the context of the variable
+ * @param id Identifier to test
+ * @param thread Thread to use for evaluation
+ */
+function isConstVar(id, thread) {
+    var _a;
+    // --- Start search the block context
+    if (thread.blocks) {
+        for (let idx = thread.blocks.length; idx >= 0; idx--) {
+            const constContext = (_a = thread.blocks[idx]) === null || _a === void 0 ? void 0 : _a.constVars;
+            if (constContext && constContext.has(id))
+                return true;
+        }
+    }
+    // --- Not in block context
+    return false;
+}