xmlui 0.4.0

package/dist/scripts/src/components-core/script-runner/process-statement-async.js

@@ -0,0 +1,818 @@
+"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.processStatementQueueAsync = processStatementQueueAsync;
+exports.visitLetConstDeclarations = visitLetConstDeclarations;
+exports.processDeclarationsAsync = processDeclarationsAsync;
+const eval_tree_async_1 = require("./eval-tree-async");
+const process_statement_common_1 = require("./process-statement-common");
+const statement_queue_1 = require("./statement-queue");
+const EngineError_1 = require("../EngineError");
+const reportEngineError_1 = require("../reportEngineError");
+// --- Helper function to process the entire queue asynchronously
+function processStatementQueueAsync(statements, evalContext, thread, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        if (!thread) {
+            // --- Create the main thread for the queue
+            thread = (0, process_statement_common_1.ensureMainThread)(evalContext);
+        }
+        // --- Hoist function declarations to the top scope
+        (0, process_statement_common_1.hoistFunctionDeclarations)(thread, statements);
+        // --- Fill the queue with items
+        const queue = new statement_queue_1.StatementQueue();
+        queue.push((0, statement_queue_1.mapStatementsToQueueItems)(statements));
+        // --- Prepare queue diagnostics information
+        const diagInfo = {
+            processedStatements: 0,
+            maxQueueLength: queue.length,
+            unshiftedItems: 0,
+            clearToLabels: 0,
+            maxBlocks: 0,
+            maxLoops: 0,
+        };
+        // --- Consume the queue
+        let startTime = new Date().getTime();
+        while (queue.length > 0 && !((_a = evalContext.cancellationToken) === null || _a === void 0 ? void 0 : _a.cancelled)) {
+            // --- Allow time to break from infinite loops
+            if (evalContext.timeout && new Date().getTime() - startTime > evalContext.timeout) {
+                throw new Error("Script execution timeout");
+            }
+            // --- Process the first item
+            const queueItem = queue.dequeue();
+            thread.breakLabelValue = queue.length > 0 ? queue.peek().label : -1;
+            let outcome;
+            try {
+                outcome = yield processStatementAsync(queueItem.statement, evalContext, thread, onStatementCompleted);
+            }
+            catch (err) {
+                if (thread.tryBlocks && thread.tryBlocks.length > 0) {
+                    // --- We have a try block to handle this error
+                    const tryScope = thread.tryBlocks[thread.tryBlocks.length - 1];
+                    // --- Sign the error to raise. Next time the guarded try block will execute the catch block, if there is any
+                    tryScope.errorToThrow = err;
+                    tryScope.errorSource = tryScope.processingPhase;
+                    tryScope.processingPhase = "error";
+                    // --- Let's skip the remaining parts of the current block (try/catch/finally)
+                    outcome = {
+                        clearToLabel: tryScope.tryLabel,
+                    };
+                }
+                else {
+                    if (err instanceof EngineError_1.ThrowStatementError) {
+                        (0, reportEngineError_1.reportEngineError)(err);
+                    }
+                    else {
+                        (0, reportEngineError_1.reportEngineError)(new EngineError_1.StatementExecutionError(err, (_b = queueItem.statement) === null || _b === void 0 ? void 0 : _b.source), err);
+                    }
+                }
+            }
+            // --- Modify the queue's content according to the outcome
+            if (outcome) {
+                if (outcome.toUnshift) {
+                    queue.unshift(outcome.toUnshift);
+                    diagInfo.unshiftedItems += outcome.toUnshift.length;
+                }
+                if (outcome.clearToLabel !== undefined) {
+                    queue.clearToLabel(outcome.clearToLabel);
+                    diagInfo.clearToLabels++;
+                }
+            }
+            yield (onStatementCompleted === null || onStatementCompleted === void 0 ? void 0 : onStatementCompleted(evalContext, queueItem.statement));
+            // --- Provide diagnostics
+            if (queue.length > diagInfo.maxQueueLength) {
+                diagInfo.maxQueueLength = queue.length;
+            }
+            if (thread.blocks && thread.blocks.length > diagInfo.maxBlocks) {
+                diagInfo.maxBlocks = thread.blocks.length;
+            }
+            if (thread.loops && thread.loops.length > diagInfo.maxLoops) {
+                diagInfo.maxLoops = thread.loops.length;
+            }
+            diagInfo.processedStatements++;
+        }
+        return diagInfo;
+    });
+}
+/**
+ * Process the specified statement asynchronously
+ * @param statement Statement to process
+ * @param evalContext Evaluation context used for processing
+ * @param thread Logical thread to use for statement processing
+ * @param onStatementCompleted
+ * @returns Items to put back into the queue of statements
+ */
+function processStatementAsync(statement, evalContext, thread, onStatementCompleted) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
+        // --- These items should be put in the statement queue after return
+        let toUnshift = [];
+        let clearToLabel;
+        // --- Process the statement according to its type
+        switch (statement.type) {
+            case "ImportD":
+                // --- Get module information
+                const thisModule = statement.module;
+                if (!thisModule) {
+                    throw new Error("Missing module");
+                }
+                const parentModule = (_a = statement.module) === null || _a === void 0 ? void 0 : _a.parent;
+                if (!parentModule) {
+                    throw new Error("Missing parent module");
+                }
+                // --- At this point the imported module is set
+                // if (!statement.module!.executed) {
+                //   // --- Run the module, it has not been executed yet
+                //   const childEvalContext = createEvalContext({
+                //     cancellationToken: evalContext.cancellationToken,
+                //     timeout: evalContext.timeout ?? 1000
+                //   });
+                //   statement.module!.executed = true;
+                //   executeScriptModule(statement.module!, childEvalContext);
+                // }
+                // --- Import the module's exported variables into the parent module
+                const topVars = evalContext.mainThread.blocks[0].vars;
+                const topConst = evalContext.mainThread.blocks[0].constVars;
+                for (const key of Object.keys(statement.imports)) {
+                    if (key in topVars) {
+                        throw new Error(`Import ${key} already exists`);
+                    }
+                    topVars[key] = statement.module.exports.get(statement.imports[key]);
+                    topConst.add(key);
+                }
+                break;
+            case "FuncD":
+                // --- Function declarations are already hoisted, nothing to do
+                break;
+            case "EmptyS":
+                // --- Nothing to do
+                break;
+            case "BlockS":
+                // --- No statement, nothing to process
+                if (statement.statements.length === 0)
+                    break;
+                // --- Create a new block scope
+                (_b = thread.blocks) !== null && _b !== void 0 ? _b : (thread.blocks = []);
+                thread.blocks.push({ vars: {} });
+                // --- Hoist function declarations to the innermost block scope
+                (0, process_statement_common_1.hoistFunctionDeclarations)(thread, statement.statements);
+                // --- Prepare an empty statement that will only remove the block scope when the entire block is processed
+                const closing = {
+                    type: "EmptyS",
+                    removeBlockScope: true,
+                }; // --- We need the cast as we do not provide required props
+                // --- Queue the block scope's body
+                toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([...statement.statements, closing]);
+                break;
+            case "ExprS":
+                // --- Just evaluate it
+                const statementValue = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expression, evalContext, thread, onStatementCompleted);
+                if (thread.blocks && thread.blocks.length !== 0) {
+                    thread.blocks[thread.blocks.length - 1].returnValue = statementValue;
+                }
+                break;
+            case "ArrowS":
+                // --- Compile the arrow expression
+                const arrowFuncValue = yield (0, eval_tree_async_1.executeArrowExpression)(statement.expression, evalContext, onStatementCompleted, thread, ...((_c = evalContext.eventArgs) !== null && _c !== void 0 ? _c : []));
+                if (thread.blocks && thread.blocks.length !== 0) {
+                    thread.blocks[thread.blocks.length - 1].returnValue = arrowFuncValue;
+                }
+                break;
+            case "LetS": {
+                // --- Create a new variable in the innermost scope
+                const block = (0, process_statement_common_1.innermostBlockScope)(thread);
+                if (!block) {
+                    throw new Error("Missing block scope");
+                }
+                yield processDeclarationsAsync(block, evalContext, thread, onStatementCompleted, statement.declarations);
+                break;
+            }
+            case "ConstS": {
+                // --- Create a new variable in the innermost scope
+                const block = (0, process_statement_common_1.innermostBlockScope)(thread);
+                if (!block) {
+                    throw new Error("Missing block scope");
+                }
+                yield processDeclarationsAsync(block, evalContext, thread, onStatementCompleted, statement.declarations, true);
+                break;
+            }
+            case "IfS":
+                // --- Evaluate the condition
+                const condition = !!(yield (0, eval_tree_async_1.evalBindingAsync)(statement.condition, evalContext, thread, onStatementCompleted));
+                if (condition) {
+                    toUnshift = (0, statement_queue_1.mapToItem)(statement.thenBranch);
+                }
+                else if (statement.elseBranch) {
+                    toUnshift = (0, statement_queue_1.mapToItem)(statement.elseBranch);
+                }
+                break;
+            case "RetS": {
+                // --- Check if return is valid here
+                let blockScope = (0, process_statement_common_1.innermostBlockScope)(thread);
+                if (blockScope === undefined) {
+                    throw new Error("Return requires a block scope");
+                }
+                // --- Store the return value
+                thread.returnValue = statement.expression
+                    ? yield (0, eval_tree_async_1.evalBindingAsync)(statement.expression, evalContext, thread, onStatementCompleted)
+                    : undefined;
+                // --- Check for try blocks
+                if (((_d = thread.tryBlocks) !== null && _d !== void 0 ? _d : []).length > 0) {
+                    // --- Mark the loop's try scope to exit with "return"
+                    const returnTryScope = thread.tryBlocks[0];
+                    returnTryScope.exitType = "return";
+                    // --- Remove the try/catch/finally block's scope
+                    if (returnTryScope.processingPhase !== "postFinally") {
+                        thread.blocks.pop();
+                    }
+                    // --- Clear the last part of the try/catch/finally block
+                    const tryScope = (0, process_statement_common_1.innermostTryScope)(thread);
+                    clearToLabel = tryScope.tryLabel;
+                }
+                else {
+                    // --- Delete the remaining part of the queue
+                    clearToLabel = -1;
+                }
+                break;
+            }
+            case "WhileS": {
+                // --- Create or get the loop's scope (guard is falsy for the first execution)
+                let loopScope = statement.guard ? (0, process_statement_common_1.innermostLoopScope)(thread) : (0, process_statement_common_1.createLoopScope)(thread);
+                // --- Evaluate the loop condition
+                const condition = !!(yield (0, eval_tree_async_1.evalBindingAsync)(statement.condition, evalContext, thread, onStatementCompleted));
+                if (condition) {
+                    toUnshift = (0, process_statement_common_1.provideLoopBody)(loopScope, statement, thread.breakLabelValue);
+                }
+                else {
+                    // --- When the condition is not met, we're done.
+                    (0, process_statement_common_1.releaseLoopScope)(thread);
+                }
+                break;
+            }
+            case "DoWS": {
+                if (!statement.guard) {
+                    // --- First loop execution (do-while is a post-test loop)
+                    toUnshift = (0, process_statement_common_1.provideLoopBody)((0, process_statement_common_1.createLoopScope)(thread), statement, thread.breakLabelValue);
+                    break;
+                }
+                // --- Evaluate the loop condition
+                const condition = !!(yield (0, eval_tree_async_1.evalBindingAsync)(statement.condition, evalContext, thread, onStatementCompleted));
+                if (condition) {
+                    toUnshift = (0, process_statement_common_1.provideLoopBody)((0, process_statement_common_1.innermostLoopScope)(thread), statement, thread.breakLabelValue);
+                }
+                else {
+                    // --- When the condition is not met, we're done.
+                    (0, process_statement_common_1.releaseLoopScope)(thread);
+                }
+                break;
+            }
+            case "ContS": {
+                // --- Search for the innermost non-switch loop scope, release the switch scopes
+                if (!thread.loops || thread.loops.length === 0) {
+                    throw new Error("Missing loop scope");
+                }
+                let loopScope;
+                while (thread.loops.length > 0) {
+                    loopScope = (0, process_statement_common_1.innermostLoopScope)(thread);
+                    if (!loopScope.isSwitch) {
+                        break;
+                    }
+                    thread.loops.pop();
+                }
+                if (!loopScope) {
+                    throw new Error("Missing loop scope");
+                }
+                if (loopScope.tryBlockDepth >= 0 && loopScope.tryBlockDepth < ((_e = thread.tryBlocks) !== null && _e !== void 0 ? _e : []).length) {
+                    // --- Mark the loop's try scope to exit with "continue"
+                    for (let i = loopScope.tryBlockDepth; i < thread.tryBlocks.length; i++) {
+                        thread.tryBlocks[loopScope.tryBlockDepth].exitType = "continue";
+                    }
+                    // --- Clear the last part of the try/catch/finally block
+                    const tryScope = (0, process_statement_common_1.innermostTryScope)(thread);
+                    clearToLabel = tryScope.tryLabel;
+                }
+                else {
+                    clearToLabel = loopScope.continueLabel;
+                    (0, process_statement_common_1.releaseLoopScope)(thread, false);
+                }
+                break;
+            }
+            case "BrkS": {
+                const loopScope = (0, process_statement_common_1.innermostLoopScope)(thread);
+                if (loopScope === undefined) {
+                    throw new Error("Missing loop scope");
+                }
+                if (!!loopScope.isSwitch) {
+                    // --- Break is in a switch case
+                    clearToLabel = loopScope.breakLabel;
+                    break;
+                }
+                // --- Break is in a loop construct
+                if (loopScope.tryBlockDepth >= 0 && loopScope.tryBlockDepth < ((_f = thread.tryBlocks) !== null && _f !== void 0 ? _f : []).length) {
+                    // --- Mark the loop's try scope to exit with "break"
+                    for (let i = loopScope.tryBlockDepth; i < thread.tryBlocks.length; i++) {
+                        thread.tryBlocks[loopScope.tryBlockDepth].exitType = "break";
+                    }
+                    // --- Clear the last part of the try/catch/finally block
+                    const tryScope = (0, process_statement_common_1.innermostTryScope)(thread);
+                    clearToLabel = tryScope.tryLabel;
+                }
+                else {
+                    clearToLabel = loopScope.breakLabel;
+                    (0, process_statement_common_1.releaseLoopScope)(thread);
+                }
+                break;
+            }
+            case "ForS":
+                if (!statement.guard) {
+                    // --- Init the loop with a new scope
+                    (0, process_statement_common_1.createLoopScope)(thread, 1);
+                    // --- Create a new block for the loop variables
+                    (_g = thread.blocks) !== null && _g !== void 0 ? _g : (thread.blocks = []);
+                    thread.blocks.push({
+                        vars: {},
+                    });
+                    const guardStatement = Object.assign(Object.assign({}, statement), { guard: true });
+                    if (statement.init) {
+                        // --- Unshift the initialization part and the guarded for-loop
+                        toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([statement.init, guardStatement]);
+                    }
+                    else {
+                        // --- No init, unshift only the guard statement
+                        toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([guardStatement]);
+                    }
+                }
+                else {
+                    // --- Initialization already done. Evaluate the condition
+                    if (!statement.condition ||
+                        !!(yield (0, eval_tree_async_1.evalBindingAsync)(statement.condition, evalContext, thread, onStatementCompleted))) {
+                        // --- Stay in the loop, inject the body, the update expression, and the loop guard
+                        const loopScope = (0, process_statement_common_1.innermostLoopScope)(thread);
+                        if (statement.update) {
+                            const updateStmt = {
+                                type: "ExprS",
+                                expression: statement.update,
+                            };
+                            toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([statement.body, updateStmt, Object.assign({}, statement)]);
+                        }
+                        else {
+                            toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([statement.body, Object.assign({}, statement)]);
+                        }
+                        // --- The next queue label is for "break"
+                        loopScope.breakLabel = (_h = thread.breakLabelValue) !== null && _h !== void 0 ? _h : -1;
+                        // --- The guard action's label is for "continue"
+                        loopScope.continueLabel = toUnshift[1].label;
+                    }
+                    else {
+                        // --- The condition is not met, we're done. Remove the loop's scope from the evaluation context
+                        (0, process_statement_common_1.releaseLoopScope)(thread);
+                    }
+                }
+                break;
+            case "ForInS":
+                if (!statement.guard) {
+                    // --- Get the object keys
+                    const keyedObject = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expression, evalContext, thread);
+                    if (keyedObject == undefined) {
+                        // --- Nothing to do, no object to traverse
+                        break;
+                    }
+                    // --- Init the loop with a new scope
+                    (0, process_statement_common_1.createLoopScope)(thread, 1);
+                    // --- Create a new block for the loop variables
+                    (_j = thread.blocks) !== null && _j !== void 0 ? _j : (thread.blocks = []);
+                    thread.blocks.push({ vars: {} });
+                    statement.keys = Object.keys(keyedObject);
+                    statement.keyIndex = 0;
+                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([Object.assign(Object.assign({}, statement), { guard: true })]);
+                }
+                else {
+                    // --- Just for the sake of extra safety
+                    if (statement.keyIndex === undefined || statement.keys === undefined) {
+                        throw new Error("Keys information expected in for..in loop");
+                    }
+                    // --- Any key left?
+                    if (statement.keyIndex < statement.keys.length) {
+                        // --- Set the binding variable to the next key
+                        const propValue = statement.keys[statement.keyIndex++];
+                        switch (statement.varBinding) {
+                            case "none": {
+                                const assigmentExpr = {
+                                    type: "AsgnE",
+                                    leftValue: {
+                                        type: "IdE",
+                                        name: statement.id,
+                                    },
+                                    operator: "=",
+                                    operand: {
+                                        type: "LitE",
+                                        value: propValue,
+                                    },
+                                };
+                                yield (0, eval_tree_async_1.evalBindingAsync)(assigmentExpr, evalContext, thread);
+                                break;
+                            }
+                            case "const":
+                            case "let":
+                                {
+                                    // --- Create a new variable in the innermost scope
+                                    const block = (0, process_statement_common_1.innermostBlockScope)(thread);
+                                    if (!block) {
+                                        throw new Error("Missing block scope");
+                                    }
+                                    block.vars[statement.id] = propValue;
+                                    if (statement.varBinding === "const") {
+                                        (_k = block.constVars) !== null && _k !== void 0 ? _k : (block.constVars = new Set());
+                                        block.constVars.add(statement.id);
+                                    }
+                                }
+                                break;
+                        }
+                        // --- Inject the loop body
+                        const loopScope = (0, process_statement_common_1.innermostLoopScope)(thread);
+                        toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([statement.body, Object.assign({}, statement)]);
+                        // --- The next queue label is for "break"
+                        loopScope.breakLabel = (_l = thread.breakLabelValue) !== null && _l !== void 0 ? _l : -1;
+                        // --- The guard action's label is for "continue"
+                        loopScope.continueLabel = toUnshift[1].label;
+                    }
+                    else {
+                        // --- The condition is not met, we're done. Remove the loop's scope from the evaluation context
+                        (0, process_statement_common_1.releaseLoopScope)(thread);
+                    }
+                }
+                break;
+            case "ForOfS":
+                if (!statement.guard) {
+                    // --- Get the object keys
+                    const iteratorObject = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expression, evalContext, thread);
+                    if (iteratorObject == null || typeof iteratorObject[Symbol.iterator] !== "function") {
+                        // --- The object is not an iterator
+                        throw new Error("Object in for..of is not iterable");
+                    }
+                    // --- Init the loop with a new scope
+                    (0, process_statement_common_1.createLoopScope)(thread, 1);
+                    // --- Create a new block for the loop variables
+                    (_m = thread.blocks) !== null && _m !== void 0 ? _m : (thread.blocks = []);
+                    thread.blocks.push({ vars: {} });
+                    statement.iterator = iteratorObject[Symbol.iterator]();
+                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([Object.assign(Object.assign({}, statement), { guard: true })]);
+                }
+                else {
+                    // --- Just for the sake of extra safety
+                    if (statement.iterator === undefined) {
+                        throw new Error("Iterator expected in for..of loop");
+                    }
+                    // --- Any iteration left?
+                    const nextIteration = statement.iterator.next();
+                    if (nextIteration.done) {
+                        // --- The for..of loop is complete. Remove the loop's scope from the evaluation context
+                        (0, process_statement_common_1.releaseLoopScope)(thread);
+                        break;
+                    }
+                    // --- Set the binding variable to the next key
+                    const propValue = nextIteration.value;
+                    switch (statement.varBinding) {
+                        case "none": {
+                            const assigmentExpr = {
+                                type: "AsgnE",
+                                leftValue: {
+                                    type: "IdE",
+                                    name: statement.id,
+                                },
+                                operator: "=",
+                                operand: {
+                                    type: "LitE",
+                                    value: propValue,
+                                },
+                            };
+                            yield (0, eval_tree_async_1.evalBindingAsync)(assigmentExpr, evalContext, thread);
+                            break;
+                        }
+                        case "const":
+                        case "let":
+                            {
+                                // --- Create a new variable in the innermost scope
+                                const block = (0, process_statement_common_1.innermostBlockScope)(thread);
+                                if (!block) {
+                                    throw new Error("Missing block scope");
+                                }
+                                block.vars[statement.id] = propValue;
+                                if (statement.varBinding === "const") {
+                                    (_o = block.constVars) !== null && _o !== void 0 ? _o : (block.constVars = new Set());
+                                    block.constVars.add(statement.id);
+                                }
+                            }
+                            break;
+                    }
+                    // --- Inject the loop body
+                    const loopScope = (0, process_statement_common_1.innermostLoopScope)(thread);
+                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([statement.body, Object.assign({}, statement)]);
+                    // --- The next queue label is for "break"
+                    loopScope.breakLabel = (_p = thread.breakLabelValue) !== null && _p !== void 0 ? _p : -1;
+                    // --- The guard action's label is for "continue"
+                    loopScope.continueLabel = toUnshift[1].label;
+                }
+                break;
+            case "ThrowS": {
+                throw new EngineError_1.ThrowStatementError(yield (0, eval_tree_async_1.evalBindingAsync)(statement.expression, evalContext, thread, onStatementCompleted));
+            }
+            case "TryS": {
+                if (!statement.guard) {
+                    // --- Execute the try block
+                    toUnshift = (0, process_statement_common_1.provideTryBody)(thread, (0, process_statement_common_1.createTryScope)(thread, statement));
+                    break;
+                }
+                // --- Evaluate try
+                const tryScope = (0, process_statement_common_1.innermostTryScope)(thread);
+                switch (tryScope.processingPhase) {
+                    case "error":
+                        // --- There was an error we may handle with catch
+                        switch (tryScope.errorSource) {
+                            case "try":
+                                // --- Remove the "try" block's scope
+                                thread.blocks.pop();
+                                // --- Go on with catch or finally
+                                if (statement.catchBlock) {
+                                    if (tryScope.statement.catchVariable) {
+                                        const block = (0, process_statement_common_1.innermostBlockScope)(thread);
+                                        block.vars[tryScope.statement.catchVariable] =
+                                            tryScope.errorToThrow instanceof EngineError_1.ThrowStatementError
+                                                ? tryScope.errorToThrow.errorObject
+                                                : tryScope.errorToThrow;
+                                    }
+                                    delete tryScope.errorToThrow;
+                                    tryScope.processingPhase = "catch";
+                                    toUnshift = (0, process_statement_common_1.provideCatchBody)(thread, tryScope);
+                                }
+                                else if (tryScope.statement.finallyBlock) {
+                                    // --- No catch, move on finally
+                                    tryScope.processingPhase = "finally";
+                                    toUnshift = (0, process_statement_common_1.provideFinallyBody)(thread, tryScope);
+                                }
+                                break;
+                            case "catch":
+                                // --- Remove the "catch" block's scope
+                                thread.blocks.pop();
+                                // --- Move to the finally block
+                                tryScope.processingPhase = "finally";
+                                toUnshift = (0, process_statement_common_1.provideFinallyBody)(thread, tryScope);
+                                break;
+                            case "finally":
+                                // --- Remove the "finally" block's scope
+                                thread.blocks.pop();
+                                // --- Move to the post finally execution
+                                tryScope.processingPhase = "postFinally";
+                                toUnshift = (0, process_statement_common_1.provideFinallyErrorBody)(tryScope);
+                                break;
+                        }
+                        break;
+                    case "try":
+                        // --- We completed the try block successfully
+                        tryScope.processingPhase = "finally";
+                        if (statement.finallyBlock) {
+                            toUnshift = (0, process_statement_common_1.provideFinallyBody)(thread, tryScope);
+                        }
+                        break;
+                    case "catch":
+                        // --- We completed the catch block successfully, remove the handled error
+                        tryScope.processingPhase = "finally";
+                        if (statement.finallyBlock) {
+                            toUnshift = (0, process_statement_common_1.provideFinallyBody)(thread, tryScope);
+                        }
+                        break;
+                    case "finally":
+                        tryScope.processingPhase = "postFinally";
+                        toUnshift = (0, process_statement_common_1.provideFinallyErrorBody)(tryScope);
+                        break;
+                    case "postFinally":
+                        // --- We completed the finally block successfully
+                        const innermostTry = thread.tryBlocks.pop();
+                        // --- Is there any special exit type?
+                        switch (innermostTry.exitType) {
+                            case "break": {
+                                const loopScope = (0, process_statement_common_1.innermostLoopScope)(thread);
+                                if (loopScope === undefined) {
+                                    throw new Error("Missing loop scope");
+                                }
+                                (0, process_statement_common_1.releaseLoopScope)(thread);
+                                clearToLabel = loopScope.breakLabel;
+                                break;
+                            }
+                            case "continue": {
+                                const loopScope = (0, process_statement_common_1.innermostLoopScope)(thread);
+                                if (loopScope === undefined) {
+                                    throw new Error("Missing loop scope");
+                                }
+                                clearToLabel = loopScope.continueLabel;
+                                (0, process_statement_common_1.releaseLoopScope)(thread, false);
+                                break;
+                            }
+                            case "return":
+                                clearToLabel = -1;
+                                break;
+                        }
+                        // --- Should we raise an error?
+                        if (innermostTry.errorToThrow) {
+                            throw innermostTry.errorToThrow;
+                        }
+                        break;
+                }
+                break;
+            }
+            case "SwitchS": {
+                // --- Create or get the loop's scope (guard is falsy for the first execution)
+                if (statement.guard) {
+                    // --- Complete the switch
+                    (0, process_statement_common_1.releaseLoopScope)(thread);
+                }
+                else {
+                    let loopScope = (0, process_statement_common_1.createLoopScope)(thread);
+                    loopScope.isSwitch = true;
+                    thread.blocks.push({ vars: {} });
+                    // --- Evaluate the switch value
+                    const switchValue = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expression, evalContext, thread);
+                    // --- Find the matching label
+                    let matchingIndex = -1;
+                    for (let i = 0; i < statement.cases.length; i++) {
+                        const currentCase = statement.cases[i];
+                        // --- Check for default case
+                        if (currentCase.caseExpression === undefined) {
+                            matchingIndex = i;
+                            break;
+                        }
+                        // --- Check for matching case
+                        const caseValue = yield (0, eval_tree_async_1.evalBindingAsync)(currentCase.caseExpression, evalContext, thread);
+                        if (caseValue === switchValue) {
+                            matchingIndex = i;
+                            break;
+                        }
+                    }
+                    // --- Merge all statements from the matching label
+                    const statementFlow = [];
+                    if (matchingIndex >= 0) {
+                        for (let i = matchingIndex; i < statement.cases.length; i++) {
+                            statementFlow.push(...statement.cases[i].statements);
+                        }
+                    }
+                    // --- Queue the statement flow and the guard
+                    const guardStatement = Object.assign(Object.assign({}, statement), { guard: true });
+                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([...statementFlow, guardStatement]);
+                    loopScope.breakLabel = toUnshift[toUnshift.length - 1].label;
+                }
+                break;
+            }
+        }
+        // --- The statement may remove the innermost scope
+        if (statement.removeBlockScope) {
+            if (thread.blocks && thread.blocks.length > 0) {
+                thread.blocks.pop();
+            }
+        }
+        // --- Done.
+        return { toUnshift, clearToLabel };
+    });
+}
+/**
+ * Visits all declarations in a let or const statement
+ * @param declaration Declaration to process
+ * @param visitor Function to call on each visited declaration
+ */
+function visitLetConstDeclarations(declaration, visitor) {
+    for (let i = 0; i < declaration.declarations.length; i++) {
+        let value;
+        const decl = declaration.declarations[i];
+        visitDeclaration(decl, visitor);
+    }
+    function visitDeclaration(varDecl, visitor) {
+        // --- Process each declaration
+        if (varDecl.id) {
+            visitor(varDecl.id);
+        }
+        else if (varDecl.arrayDestruct) {
+            visitArrayDestruct(varDecl.arrayDestruct, visitor);
+        }
+        else if (varDecl.objectDestruct) {
+            visitObjectDestruct(varDecl.objectDestruct, visitor);
+        }
+        else {
+            throw new Error("Unknown declaration specifier");
+        }
+    }
+    // --- Visits an array destructure declaration
+    function visitArrayDestruct(arrayD, visitor) {
+        for (let i = 0; i < arrayD.length; i++) {
+            const arrDecl = arrayD[i];
+            if (arrDecl.id) {
+                visitor(arrDecl.id);
+            }
+            else if (arrDecl.arrayDestruct) {
+                visitArrayDestruct(arrDecl.arrayDestruct, visitor);
+            }
+            else if (arrDecl.objectDestruct) {
+                visitObjectDestruct(arrDecl.objectDestruct, visitor);
+            }
+        }
+    }
+    // --- Visits an object destructure declaration
+    function visitObjectDestruct(objectD, visitor) {
+        var _a;
+        for (let i = 0; i < objectD.length; i++) {
+            const objDecl = objectD[i];
+            if (objDecl.arrayDestruct) {
+                visitArrayDestruct(objDecl.arrayDestruct, visitor);
+            }
+            else if (objDecl.objectDestruct) {
+                visitObjectDestruct(objDecl.objectDestruct, visitor);
+            }
+            else {
+                visitor((_a = objDecl.alias) !== null && _a !== void 0 ? _a : objDecl.id);
+            }
+        }
+    }
+}
+// --- Process a variable declaration
+function processDeclarationsAsync(block_1, evalContext_1, thread_1, onStatementCompleted_1, declarations_1) {
+    return __awaiter(this, arguments, void 0, function* (block, evalContext, thread, onStatementCompleted, declarations, addConst = false, useValue = false, baseValue = undefined) {
+        for (let i = 0; i < declarations.length; i++) {
+            let value;
+            const decl = declarations[i];
+            if (useValue) {
+                value = baseValue;
+            }
+            else if (decl.expression) {
+                value = yield (0, eval_tree_async_1.evalBindingAsync)(decl.expression, evalContext, thread, onStatementCompleted);
+            }
+            visitDeclaration(block, decl, value, addConst);
+        }
+        // --- Visit a variable
+        function visitDeclaration(block, decl, baseValue, addConst) {
+            // --- Process each declaration
+            if (decl.id) {
+                visitIdDeclaration(block, decl.id, baseValue, addConst);
+            }
+            else if (decl.arrayDestruct) {
+                visitArrayDestruct(block, decl.arrayDestruct, baseValue, addConst);
+            }
+            else if (decl.objectDestruct) {
+                visitObjectDestruct(block, decl.objectDestruct, baseValue, addConst);
+            }
+            else {
+                throw new Error("Unknown declaration specifier");
+            }
+        }
+        // --- Visits a single ID declaration
+        function visitIdDeclaration(block, id, baseValue, addConst) {
+            var _a;
+            if (block.vars[id]) {
+                throw new Error(`Variable ${id} is already declared in the current scope.`);
+            }
+            block.vars[id] = baseValue;
+            if (addConst) {
+                (_a = block.constVars) !== null && _a !== void 0 ? _a : (block.constVars = new Set());
+                block.constVars.add(id);
+            }
+        }
+        // --- Visits an array destructure declaration
+        function visitArrayDestruct(block, arrayD, baseValue, addConst) {
+            for (let i = 0; i < arrayD.length; i++) {
+                const arrDecl = arrayD[i];
+                const value = baseValue === null || baseValue === void 0 ? void 0 : baseValue[i];
+                if (arrDecl.id) {
+                    visitIdDeclaration(block, arrDecl.id, value, addConst);
+                }
+                else if (arrDecl.arrayDestruct) {
+                    visitArrayDestruct(block, arrDecl.arrayDestruct, value, addConst);
+                }
+                else if (arrDecl.objectDestruct) {
+                    visitObjectDestruct(block, arrDecl.objectDestruct, value, addConst);
+                }
+            }
+        }
+        // --- Visits an object destructure declaration
+        function visitObjectDestruct(block, objectD, baseValue, addConst) {
+            var _a;
+            for (let i = 0; i < objectD.length; i++) {
+                const objDecl = objectD[i];
+                const value = baseValue === null || baseValue === void 0 ? void 0 : baseValue[objDecl.id];
+                if (objDecl.arrayDestruct) {
+                    visitArrayDestruct(block, objDecl.arrayDestruct, value, addConst);
+                }
+                else if (objDecl.objectDestruct) {
+                    visitObjectDestruct(block, objDecl.objectDestruct, value, addConst);
+                }
+                else {
+                    visitIdDeclaration(block, (_a = objDecl.alias) !== null && _a !== void 0 ? _a : objDecl.id, value, addConst);
+                }
+            }
+        }
+    });
+}