xmlui 0.11.3 → 0.11.6

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

@@ -1,761 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processStatementQueueAsync = processStatementQueueAsync;
-exports.processDeclarationsAsync = processDeclarationsAsync;
-const ScriptingSourceTree_1 = require("./ScriptingSourceTree");
-const EngineError_1 = require("../EngineError");
-const reportEngineError_1 = require("../reportEngineError");
-const statement_queue_1 = require("./statement-queue");
-const eval_tree_async_1 = require("./eval-tree-async");
-const process_statement_common_1 = require("./process-statement-common");
-const Parser_1 = require("../../parsers/scripting/Parser");
-// --- Helper function to process the entire queue asynchronously
-function processStatementQueueAsync(statements, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d;
-        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)((0, process_statement_common_1.toStatementItems)(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 {
-                // --- Sign that the statement is about to start
-                yield ((_b = evalContext === null || evalContext === void 0 ? void 0 : evalContext.onStatementStarted) === null || _b === void 0 ? void 0 : _b.call(evalContext, evalContext, queueItem.statement));
-                // --- Execute the statement
-                outcome = yield processStatementAsync(queueItem.statement, (_c = queueItem === null || queueItem === void 0 ? void 0 : queueItem.execInfo) !== null && _c !== void 0 ? _c : {}, 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 {
-                        // TODO: Provide source code information
-                        (0, reportEngineError_1.reportEngineError)(new EngineError_1.StatementExecutionError(err /* queueItem!.statement?.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++;
-                }
-            }
-            // --- Sign that the statement has been completed
-            yield ((_d = evalContext === null || evalContext === void 0 ? void 0 : evalContext.onStatementCompleted) === null || _d === void 0 ? void 0 : _d.call(evalContext, 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++;
-        }
-        // --- Done.
-        return diagInfo;
-    });
-}
-/**
- * Process the specified statement asynchronously
- * @param statement Statement to process
- * @param execInfo Execution information
- * @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, execInfo, evalContext, thread) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
-        // --- 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 ScriptingSourceTree_1.T_FUNCTION_DECLARATION:
-                // --- Function declarations are already hoisted, nothing to do
-                break;
-            case ScriptingSourceTree_1.T_VAR_STATEMENT:
-                if (thread !== evalContext.mainThread) {
-                    throw new Error("'var' declarations are not allowed within functions");
-                }
-                break;
-            case ScriptingSourceTree_1.T_EMPTY_STATEMENT:
-                // --- Nothing to do
-                break;
-            case ScriptingSourceTree_1.T_BLOCK_STATEMENT:
-                // --- No statement, nothing to process
-                if (statement.stmts.length === 0)
-                    break;
-                // --- Create a new block scope
-                (_a = thread.blocks) !== null && _a !== void 0 ? _a : (thread.blocks = []);
-                thread.blocks.push({ vars: {} });
-                // --- Hoist function declarations to the innermost block scope
-                (0, process_statement_common_1.hoistFunctionDeclarations)(thread, statement.stmts);
-                // --- Queue the block scope's body...
-                toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
-                    ...(0, process_statement_common_1.toStatementItems)(statement.stmts),
-                    // --- ...and an empty statement to remove the block scope
-                    (0, process_statement_common_1.closing)(),
-                ]);
-                break;
-            case ScriptingSourceTree_1.T_EXPRESSION_STATEMENT:
-                // --- Just evaluate it
-                const statementValue = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expr, evalContext, thread);
-                if (thread.blocks && thread.blocks.length !== 0) {
-                    thread.blocks[thread.blocks.length - 1].returnValue = statementValue;
-                }
-                break;
-            case ScriptingSourceTree_1.T_ARROW_EXPRESSION_STATEMENT:
-                // --- Compile the arrow expression
-                const arrowFuncValue = yield (0, eval_tree_async_1.executeArrowExpression)(statement.expr, evalContext, thread, ...((_b = evalContext.eventArgs) !== null && _b !== void 0 ? _b : []));
-                if (thread.blocks && thread.blocks.length !== 0) {
-                    thread.blocks[thread.blocks.length - 1].returnValue = arrowFuncValue;
-                }
-                break;
-            case ScriptingSourceTree_1.T_LET_STATEMENT: {
-                // --- 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, statement.decls);
-                break;
-            }
-            case ScriptingSourceTree_1.T_CONST_STATEMENT: {
-                // --- 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, statement.decls, true);
-                break;
-            }
-            case ScriptingSourceTree_1.T_IF_STATEMENT:
-                // --- Evaluate the condition
-                const condition = !!(yield (0, eval_tree_async_1.evalBindingAsync)(statement.cond, evalContext, thread));
-                if (condition) {
-                    toUnshift = (0, statement_queue_1.mapToItem)(statement.thenB);
-                }
-                else if (statement.elseB) {
-                    toUnshift = (0, statement_queue_1.mapToItem)(statement.elseB);
-                }
-                break;
-            case ScriptingSourceTree_1.T_RETURN_STATEMENT: {
-                // --- 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.expr
-                    ? yield (0, eval_tree_async_1.evalBindingAsync)(statement.expr, evalContext, thread)
-                    : undefined;
-                // --- Check for try blocks
-                if (((_c = thread.tryBlocks) !== null && _c !== void 0 ? _c : []).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 ScriptingSourceTree_1.T_WHILE_STATEMENT: {
-                // --- Create or get the loop's scope (guard is falsy for the first execution)
-                let loopScope = execInfo.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.cond, 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 ScriptingSourceTree_1.T_DO_WHILE_STATEMENT: {
-                if (!execInfo.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.cond, 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 ScriptingSourceTree_1.T_CONTINUE_STATEMENT: {
-                // --- 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 < ((_d = thread.tryBlocks) !== null && _d !== void 0 ? _d : []).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 ScriptingSourceTree_1.T_BREAK_STATEMENT: {
-                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 < ((_e = thread.tryBlocks) !== null && _e !== void 0 ? _e : []).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 ScriptingSourceTree_1.T_FOR_STATEMENT:
-                if (!execInfo.guard) {
-                    // --- Init the loop with a new scope
-                    (0, process_statement_common_1.createLoopScope)(thread, 1);
-                    // --- Create a new block for the loop variables
-                    (_f = thread.blocks) !== null && _f !== void 0 ? _f : (thread.blocks = []);
-                    thread.blocks.push({
-                        vars: {},
-                    });
-                    const guardStatement = (0, process_statement_common_1.guard)(statement);
-                    if (statement.init) {
-                        // --- Unshift the initialization part and the guarded for-loop
-                        toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([{ statement: 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.cond || !!(yield (0, eval_tree_async_1.evalBindingAsync)(statement.cond, 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.upd) {
-                            const updateStmt = {
-                                statement: {
-                                    type: ScriptingSourceTree_1.T_EXPRESSION_STATEMENT,
-                                    nodeId: (0, Parser_1.createXmlUiTreeNodeId)(),
-                                    expr: statement.upd,
-                                },
-                            };
-                            toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
-                                { statement: statement.body },
-                                updateStmt,
-                                { statement, execInfo },
-                            ]);
-                        }
-                        else {
-                            toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
-                                { statement: statement.body },
-                                { statement, execInfo },
-                            ]);
-                        }
-                        // --- The next queue label is for "break"
-                        loopScope.breakLabel = (_g = thread.breakLabelValue) !== null && _g !== void 0 ? _g : -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 ScriptingSourceTree_1.T_FOR_IN_STATEMENT:
-                if (!execInfo.guard) {
-                    // --- Get the object keys
-                    const keyedObject = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expr, 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
-                    (_h = thread.blocks) !== null && _h !== void 0 ? _h : (thread.blocks = []);
-                    thread.blocks.push({ vars: {} });
-                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
-                        { statement, execInfo: { guard: true, keys: Object.keys(keyedObject), keyIndex: 0 } },
-                    ]);
-                }
-                else {
-                    // --- Just for the sake of extra safety
-                    if (execInfo.keyIndex === undefined || execInfo.keys === undefined) {
-                        throw new Error("Keys information expected in for..in loop");
-                    }
-                    // --- Any key left?
-                    if (execInfo.keyIndex < execInfo.keys.length) {
-                        // --- Set the binding variable to the next key
-                        const propValue = execInfo.keys[execInfo.keyIndex++];
-                        switch (statement.varB) {
-                            case "none": {
-                                const assigmentExpr = {
-                                    type: ScriptingSourceTree_1.T_ASSIGNMENT_EXPRESSION,
-                                    leftValue: {
-                                        type: ScriptingSourceTree_1.T_IDENTIFIER,
-                                        name: statement.id.name,
-                                    },
-                                    op: "=",
-                                    expr: {
-                                        type: ScriptingSourceTree_1.T_LITERAL,
-                                        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.name] = propValue;
-                                    if (statement.varB === "const") {
-                                        (_j = block.constVars) !== null && _j !== void 0 ? _j : (block.constVars = new Set());
-                                        block.constVars.add(statement.id.name);
-                                    }
-                                }
-                                break;
-                        }
-                        // --- Inject the loop body
-                        const loopScope = (0, process_statement_common_1.innermostLoopScope)(thread);
-                        toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
-                            { statement: statement.body },
-                            { statement, execInfo },
-                        ]);
-                        // --- The next queue label is for "break"
-                        loopScope.breakLabel = (_k = thread.breakLabelValue) !== null && _k !== void 0 ? _k : -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 ScriptingSourceTree_1.T_FOR_OF_STATEMENT:
-                if (!execInfo.guard) {
-                    // --- Get the object keys
-                    const iteratorObject = yield (0, eval_tree_async_1.evalBindingAsync)(statement.expr, 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
-                    (_l = thread.blocks) !== null && _l !== void 0 ? _l : (thread.blocks = []);
-                    thread.blocks.push({ vars: {} });
-                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
-                        { statement, execInfo: { guard: true, iterator: iteratorObject[Symbol.iterator]() } },
-                    ]);
-                }
-                else {
-                    // --- Just for the sake of extra safety
-                    if (execInfo.iterator === undefined) {
-                        throw new Error("Iterator expected in for..of loop");
-                    }
-                    // --- Any iteration left?
-                    const nextIteration = execInfo.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.varB) {
-                        case "none": {
-                            const assigmentExpr = {
-                                type: ScriptingSourceTree_1.T_ASSIGNMENT_EXPRESSION,
-                                leftValue: {
-                                    type: ScriptingSourceTree_1.T_IDENTIFIER,
-                                    name: statement.id.name,
-                                },
-                                op: "=",
-                                expr: {
-                                    type: ScriptingSourceTree_1.T_LITERAL,
-                                    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.name] = propValue;
-                                if (statement.varB === "const") {
-                                    (_m = block.constVars) !== null && _m !== void 0 ? _m : (block.constVars = new Set());
-                                    block.constVars.add(statement.id.name);
-                                }
-                            }
-                            break;
-                    }
-                    // --- Inject the loop body
-                    const loopScope = (0, process_statement_common_1.innermostLoopScope)(thread);
-                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
-                        { statement: statement.body },
-                        { statement, execInfo },
-                    ]);
-                    // --- The next queue label is for "break"
-                    loopScope.breakLabel = (_o = thread.breakLabelValue) !== null && _o !== void 0 ? _o : -1;
-                    // --- The guard action's label is for "continue"
-                    loopScope.continueLabel = toUnshift[1].label;
-                }
-                break;
-            case ScriptingSourceTree_1.T_THROW_STATEMENT: {
-                throw new EngineError_1.ThrowStatementError(yield (0, eval_tree_async_1.evalBindingAsync)(statement.expr, evalContext, thread));
-            }
-            case ScriptingSourceTree_1.T_TRY_STATEMENT: {
-                if (!execInfo.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.catchB) {
-                                    if (tryScope.statement.catchV) {
-                                        const block = (0, process_statement_common_1.innermostBlockScope)(thread);
-                                        block.vars[tryScope.statement.catchV.name] =
-                                            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.finallyB) {
-                                    // --- 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.finallyB) {
-                            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.finallyB) {
-                            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 ScriptingSourceTree_1.T_SWITCH_STATEMENT: {
-                // --- Create or get the loop's scope (guard is falsy for the first execution)
-                if (execInfo.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.expr, 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.caseE === undefined) {
-                            matchingIndex = i;
-                            break;
-                        }
-                        // --- Check for matching case
-                        const caseValue = yield (0, eval_tree_async_1.evalBindingAsync)(currentCase.caseE, 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].stmts);
-                        }
-                    }
-                    // --- Queue the statement flow and the guard
-                    toUnshift = (0, statement_queue_1.mapStatementsToQueueItems)([
-                        ...(0, process_statement_common_1.toStatementItems)(statementFlow),
-                        (0, process_statement_common_1.guard)(statement),
-                    ]);
-                    loopScope.breakLabel = toUnshift[toUnshift.length - 1].label;
-                }
-                break;
-            }
-        }
-        // --- The statement may remove the innermost scope
-        if (execInfo.removeBlockScope) {
-            if (thread.blocks && thread.blocks.length > 0) {
-                thread.blocks.pop();
-            }
-        }
-        // --- Done.
-        return { toUnshift, clearToLabel };
-    });
-}
-// --- Process a variable declaration
-function processDeclarationsAsync(block_1, evalContext_1, thread_1, declarations_1) {
-    return __awaiter(this, arguments, void 0, function* (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.expr) {
-                value = yield (0, eval_tree_async_1.evalBindingAsync)(decl.expr, 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.aDestr) {
-                visitArrayDestruct(block, decl.aDestr, baseValue, addConst);
-            }
-            else if (decl.oDestr) {
-                visitObjectDestruct(block, decl.oDestr, 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.aDestr) {
-                    visitArrayDestruct(block, arrDecl.aDestr, value, addConst);
-                }
-                else if (arrDecl.oDestr) {
-                    visitObjectDestruct(block, arrDecl.oDestr, 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.aDestr) {
-                    visitArrayDestruct(block, objDecl.aDestr, value, addConst);
-                }
-                else if (objDecl.oDestr) {
-                    visitObjectDestruct(block, objDecl.oDestr, value, addConst);
-                }
-                else {
-                    visitIdDeclaration(block, (_a = objDecl.alias) !== null && _a !== void 0 ? _a : objDecl.id, value, addConst);
-                }
-            }
-        }
-    });
-}