xmlui 0.4.0

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

@@ -0,0 +1,740 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processStatementQueue = processStatementQueue;
+exports.processDeclarations = processDeclarations;
+const eval_tree_sync_1 = require("@components-core/script-runner/eval-tree-sync");
+const process_statement_common_1 = require("./process-statement-common");
+const statement_queue_1 = require("./statement-queue");
+const reportEngineError_1 = require("../reportEngineError");
+const EngineError_1 = require("../EngineError");
+const SYNC_EVAL_TIMEOUT = 1000;
+// --- Helper function to process the entire queue synchronously
+function processStatementQueue(statements, evalContext, thread) {
+    var _a;
+    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);
+    // --- Set start tick to observe timeout
+    evalContext.startTick = new Date().valueOf();
+    // --- 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
+    while (queue.length > 0) {
+        // --- Check sync timeout
+        if (evalContext.startTick !== undefined && new Date().valueOf() - evalContext.startTick > SYNC_EVAL_TIMEOUT) {
+            throw new Error(`Sync evaluation timeout exceeded ${SYNC_EVAL_TIMEOUT} milliseconds`);
+        }
+        // --- Process the first item
+        const queueItem = queue.dequeue();
+        thread.breakLabelValue = queue.length > 0 ? queue.peek().label : -1;
+        let outcome;
+        try {
+            outcome = processStatement(queueItem.statement, evalContext, thread);
+        }
+        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, (_a = queueItem.statement) === null || _a === void 0 ? void 0 : _a.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++;
+            }
+        }
+        // --- 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 synchronously
+ * @param statement Statement to process
+ * @param evalContext Evaluation context used for processing
+ * @param thread Logical thread to use for statement processing
+ * @returns Items to put back into the queue of statements
+ */
+function processStatement(statement, evalContext, thread) {
+    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 = (0, eval_tree_sync_1.evalBinding)(statement.expression, evalContext, thread);
+            if (thread.blocks && thread.blocks.length !== 0) {
+                thread.blocks[thread.blocks.length - 1].returnValue = statementValue;
+            }
+            break;
+        case "ArrowS":
+            // --- Compile the arrow expression
+            const arrowFuncValue = (0, eval_tree_sync_1.executeArrowExpressionSync)(statement.expression, evalContext, 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");
+            }
+            processDeclarations(block, evalContext, thread, 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");
+            }
+            processDeclarations(block, evalContext, thread, statement.declarations, true);
+            break;
+        }
+        case "IfS":
+            // --- Evaluate the condition
+            const condition = !!(0, eval_tree_sync_1.evalBinding)(statement.condition, evalContext, thread);
+            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 ? (0, eval_tree_sync_1.evalBinding)(statement.expression, evalContext, thread) : 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 = !!(0, eval_tree_sync_1.evalBinding)(statement.condition, evalContext, thread);
+            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 = !!(0, eval_tree_sync_1.evalBinding)(statement.condition, evalContext, thread);
+            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 || (0, eval_tree_sync_1.evalBinding)(statement.condition, evalContext, thread)) {
+                    // --- 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 = (0, eval_tree_sync_1.evalBinding)(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,
+                                },
+                            };
+                            (0, eval_tree_sync_1.evalBinding)(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 for..in loop is complete. 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 = (0, eval_tree_sync_1.evalBinding)(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,
+                            },
+                        };
+                        (0, eval_tree_sync_1.evalBinding)(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((0, eval_tree_sync_1.evalBinding)(statement.expression, evalContext, thread));
+        }
+        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 = (0, eval_tree_sync_1.evalBinding)(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 = (0, eval_tree_sync_1.evalBinding)(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 };
+}
+// --- Process a variable declaration
+function processDeclarations(block, evalContext, thread, 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) {
+            //TODO illesg here, functionInvocation for global function (e.g. window.confirm... )
+            value = (0, eval_tree_sync_1.evalBinding)(decl.expression, evalContext, thread);
+        }
+        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);
+            }
+        }
+    }
+}