nerdamer 1.1.13 → 2.0.0-rc.2

package/output/core/classes/parser/operations/subtract.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subtract = subtract;
+exports.subtractPrefix = subtractPrefix;
+const errors_1 = require("../../../errors");
+const Settings_1 = require("../../../Settings");
+const Expression_1 = require("../../expression/Expression");
+const add_1 = require("./add");
+function subtract(a, b) {
+    let retval;
+    if (Settings_1.Settings.DEFER_SIMPLIFICATION) {
+        retval = (0, add_1.add)(a, b.neg());
+        retval.deferred = true;
+    }
+    else {
+        if (a.isNUM() && b.isNUM()) {
+            retval = Expression_1.Expression.fromRational(a.getMultiplier().minus(b.getMultiplier()));
+        }
+        // Any value minus inf is -inf
+        else if (!a.isInf() && b.isInf()) {
+            retval = Expression_1.Expression.Inf().neg();
+        }
+        else {
+            retval = (0, add_1.add)(a, b.neg());
+        }
+        if (!retval) {
+            throw new Error((0, errors_1.message)('subtractionNotDefined', { leftType: String(a.type), rightType: String(b.type), left: String(a), right: String(b) }));
+        }
+    }
+    return retval;
+}
+function subtractPrefix(a) {
+    // Just negates the multiplier
+    const x = a.neg();
+    return x;
+}

package/output/core/classes/parser/preprocess.d.ts

@@ -0,0 +1,7 @@
+type FunctionMetadata = {
+    bracketlessStatement?: boolean;
+    maxArgs: number;
+};
+type FunctionRegistry = Record<string, FunctionMetadata>;
+export declare function preprocess(input: string, functions: FunctionRegistry): string;
+export {};

package/output/core/classes/parser/preprocess.js

@@ -0,0 +1,246 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocess = preprocess;
+const errors_1 = require("../../errors");
+const BLOCK_FUNCTION = 'block';
+const LET_FUNCTION = 'let';
+function isIdentifierStart(character) {
+    return /[a-z_]/i.test(character);
+}
+function isIdentifierPart(character) {
+    return /[a-z0-9_]/i.test(character);
+}
+function getPreviousIdentifier(input, at) {
+    let end = at;
+    while (end > 0 && /\s/.test(input[end - 1])) {
+        end--;
+    }
+    let start = end;
+    while (start > 0 && isIdentifierPart(input[start - 1])) {
+        start--;
+    }
+    const identifier = input.slice(start, end);
+    return identifier && isIdentifierStart(identifier[0]) ? identifier : undefined;
+}
+function getNextSignificantCharacter(input, at) {
+    let index = at;
+    while (index < input.length && /\s/.test(input[index])) {
+        index++;
+    }
+    return input[index];
+}
+function normalizeComments(input) {
+    let retval = '';
+    let index = 0;
+    while (index < input.length) {
+        const opening = input.indexOf('#', index);
+        if (opening === -1) {
+            retval += input.slice(index);
+            break;
+        }
+        retval += input.slice(index, opening);
+        const delimiter = input.startsWith('##', opening) ? '##' : '#';
+        const closing = input.indexOf(delimiter, opening + delimiter.length);
+        if (closing === -1) {
+            throw new errors_1.ParserError((0, errors_1.message)('missingCommentDelimiter', { delimiter }));
+        }
+        retval += ' ';
+        index = closing + delimiter.length;
+    }
+    return retval;
+}
+/**
+ * Normalizes semicolon statement syntax onto the parser's existing block sequencing.
+ *
+ * Root-level statement sequences become an implicit block. Inside an explicit block,
+ * semicolons separate block arguments just like commas. A statement sequence in LET's body is
+ * wrapped in an implicit block so the sequence remains one LET body argument rather than being
+ * mistaken for additional bindings. A trailing semicolon is discarded.
+ */
+function normalizeStatementSeparators(input) {
+    const scopes = [];
+    let retval = '';
+    let hasRootSequence = false;
+    for (let index = 0; index < input.length; index++) {
+        const character = input[index];
+        if (character === '(' || character === '[' || character === '{') {
+            const closingBracket = character === '(' ? ')' : character === '[' ? ']' : '}';
+            retval += character;
+            scopes.push({
+                argumentStart: retval.length,
+                closingBracket,
+                functionName: character === '(' ? getPreviousIdentifier(input, index) : undefined,
+            });
+            continue;
+        }
+        if (character === ')' || character === ']' || character === '}') {
+            const currentScope = scopes[scopes.length - 1];
+            if (currentScope?.closingBracket === character) {
+                if (currentScope.statementBlockOpened) {
+                    retval += ')';
+                }
+                scopes.pop();
+            }
+            retval += character;
+            continue;
+        }
+        if (character === ',') {
+            retval += character;
+            const currentScope = scopes[scopes.length - 1];
+            if (currentScope && !currentScope.statementBlockOpened) {
+                currentScope.argumentStart = retval.length;
+            }
+            continue;
+        }
+        if (character === ';') {
+            const nextCharacter = getNextSignificantCharacter(input, index + 1);
+            const currentScope = scopes[scopes.length - 1];
+            const isTrailingTerminator = nextCharacter === undefined ||
+                nextCharacter === ',' ||
+                nextCharacter === currentScope?.closingBracket;
+            if (scopes.length === 0) {
+                if (!isTrailingTerminator) {
+                    retval += ',';
+                    hasRootSequence = true;
+                }
+            }
+            else if (isTrailingTerminator) {
+                continue;
+            }
+            else if (currentScope?.functionName === BLOCK_FUNCTION) {
+                retval += ',';
+            }
+            else if (currentScope?.functionName === LET_FUNCTION) {
+                if (!currentScope.statementBlockOpened) {
+                    retval =
+                        retval.slice(0, currentScope.argumentStart) +
+                            `${BLOCK_FUNCTION}(` +
+                            retval.slice(currentScope.argumentStart);
+                    currentScope.statementBlockOpened = true;
+                }
+                retval += ',';
+            }
+            else {
+                retval += character;
+            }
+            continue;
+        }
+        retval += character;
+    }
+    if (hasRootSequence) {
+        retval = `${BLOCK_FUNCTION}(${retval})`;
+    }
+    return retval;
+}
+function findBracketlessFunction(input, functions) {
+    let retval;
+    let index = 0;
+    while (index < input.length) {
+        if (!isIdentifierStart(input[index])) {
+            index++;
+            continue;
+        }
+        const nameStart = index;
+        index++;
+        while (index < input.length && isIdentifierPart(input[index])) {
+            index++;
+        }
+        const nameEnd = index;
+        const name = input.slice(nameStart, nameEnd);
+        if (!(name in functions) || !/\s/.test(input[index] ?? '')) {
+            continue;
+        }
+        while (index < input.length && /\s/.test(input[index])) {
+            index++;
+        }
+        if (index < input.length) {
+            const firstArgumentCharacter = input[index];
+            const nextCharacter = input[index + 1] ?? '';
+            const startsWithOperatorBoundary = /[*/=<>:&|]/.test(firstArgumentCharacter) ||
+                ((firstArgumentCharacter === '+' || firstArgumentCharacter === '-') && /\s/.test(nextCharacter));
+            if (!startsWithOperatorBoundary) {
+                retval = {
+                    argumentStart: index,
+                    consumeStatement: functions[name].bracketlessStatement === true,
+                    maxArgs: functions[name].maxArgs,
+                    nameEnd,
+                    nameStart,
+                };
+            }
+        }
+    }
+    return retval;
+}
+function isOpeningBracket(character) {
+    return character === '(' || character === '[' || character === '{';
+}
+function isClosingBracket(character) {
+    return character === ')' || character === ']' || character === '}';
+}
+function findArgumentEnd(input, start, maxArgs, consumeStatement = false) {
+    let depth = 0;
+    let index = start;
+    let previousSignificant = '';
+    const multipleArguments = maxArgs !== 1;
+    for (; index < input.length; index++) {
+        const character = input[index];
+        if (isOpeningBracket(character)) {
+            depth++;
+            previousSignificant = character;
+            continue;
+        }
+        if (isClosingBracket(character)) {
+            if (depth === 0)
+                break;
+            depth--;
+            previousSignificant = character;
+            continue;
+        }
+        if (depth > 0) {
+            if (!/\s/.test(character))
+                previousSignificant = character;
+            continue;
+        }
+        if (consumeStatement) {
+            if (character === ',')
+                break;
+            if (!/\s/.test(character))
+                previousSignificant = character;
+            continue;
+        }
+        if (/\s/.test(character)) {
+            if (multipleArguments && previousSignificant === ',')
+                continue;
+            break;
+        }
+        if (character === ',') {
+            if (!multipleArguments)
+                break;
+            previousSignificant = character;
+            continue;
+        }
+        const isPrefixSign = (character === '+' || character === '-') &&
+            (index === start || previousSignificant === ',' || previousSignificant === '^');
+        const isBinaryBoundary = /[+\-*/=<>:&|]/.test(character) && !isPrefixSign;
+        if (isBinaryBoundary)
+            break;
+        previousSignificant = character;
+    }
+    return index;
+}
+function preprocess(input, functions) {
+    let retval = normalizeComments(input);
+    retval = normalizeStatementSeparators(retval);
+    let bracketless = findBracketlessFunction(retval, functions);
+    while (bracketless) {
+        const argumentEnd = findArgumentEnd(retval, bracketless.argumentStart, bracketless.maxArgs, bracketless.consumeStatement);
+        const name = retval.slice(bracketless.nameStart, bracketless.nameEnd);
+        const argument = retval.slice(bracketless.argumentStart, argumentEnd);
+        retval =
+            retval.slice(0, bracketless.nameStart) +
+                `${name}(${argument})` +
+                retval.slice(argumentEnd);
+        bracketless = findBracketlessFunction(retval, functions);
+    }
+    return retval;
+}

package/output/core/classes/parser/scripting/controlFlow.d.ts

@@ -0,0 +1,23 @@
+import { Expression } from '../../expression/Expression';
+import type { ParserEntity } from '../../../types';
+import type { DeferredFunctionArgument } from '../types';
+export { BREAK_SIGNAL, CONTINUE_SIGNAL, NULL_SIGNAL, RETURN_SIGNAL, BreakSignal, ContinueSignal, ControlFlowSignal, NullSignal, ReturnSignal, } from '../controlFlowSignals';
+export declare function isInsideSymbolicFunction(): boolean;
+export declare function shouldConsumeLocalReturn(): boolean;
+export declare function withReturnPropagation(evaluate: () => ParserEntity): ParserEntity;
+export declare function functionBoundary(evaluate: () => ParserEntity): ParserEntity;
+export declare function RETURN(x: ParserEntity): never;
+export declare function BREAK(): never;
+export declare function CONTINUE(): never;
+export declare function AND(...args: DeferredFunctionArgument[]): Expression;
+export declare function OR(...args: DeferredFunctionArgument[]): Expression;
+export declare function NOT(value: ParserEntity): Expression;
+export declare function XOR(...args: ParserEntity[]): Expression;
+export declare function IFERROR(expression: DeferredFunctionArgument, fallback: DeferredFunctionArgument): ParserEntity;
+export declare function ISERROR(expression: DeferredFunctionArgument): Expression;
+export declare function IF(condition: DeferredFunctionArgument, branch1: DeferredFunctionArgument, branch2?: DeferredFunctionArgument): ParserEntity;
+export declare function WHILE(condition: DeferredFunctionArgument, body: DeferredFunctionArgument): ParserEntity;
+export declare function FOR(initializer: DeferredFunctionArgument, condition: DeferredFunctionArgument, update: DeferredFunctionArgument, body: DeferredFunctionArgument): ParserEntity;
+export declare function BLOCK(...args: DeferredFunctionArgument[]): ParserEntity;
+export declare function parserReturnBoundary(evaluate: () => ParserEntity): ParserEntity;
+export declare function parserBlock(...args: DeferredFunctionArgument[]): ParserEntity;

package/output/core/classes/parser/scripting/controlFlow.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReturnSignal = exports.NullSignal = exports.ControlFlowSignal = exports.ContinueSignal = exports.BreakSignal = exports.RETURN_SIGNAL = exports.NULL_SIGNAL = exports.CONTINUE_SIGNAL = exports.BREAK_SIGNAL = void 0;
+exports.isInsideSymbolicFunction = isInsideSymbolicFunction;
+exports.shouldConsumeLocalReturn = shouldConsumeLocalReturn;
+exports.withReturnPropagation = withReturnPropagation;
+exports.functionBoundary = functionBoundary;
+exports.RETURN = RETURN;
+exports.BREAK = BREAK;
+exports.CONTINUE = CONTINUE;
+exports.AND = AND;
+exports.OR = OR;
+exports.NOT = NOT;
+exports.XOR = XOR;
+exports.IFERROR = IFERROR;
+exports.ISERROR = ISERROR;
+exports.IF = IF;
+exports.WHILE = WHILE;
+exports.FOR = FOR;
+exports.BLOCK = BLOCK;
+exports.parserReturnBoundary = parserReturnBoundary;
+exports.parserBlock = parserBlock;
+const errors_1 = require("../../../errors");
+const Settings_1 = require("../../../Settings");
+const Expression_1 = require("../../expression/Expression");
+const shortcuts_1 = require("../../expression/shortcuts");
+const constants_1 = require("../constants");
+const controlFlowSignals_1 = require("../controlFlowSignals");
+var controlFlowSignals_2 = require("../controlFlowSignals");
+Object.defineProperty(exports, "BREAK_SIGNAL", { enumerable: true, get: function () { return controlFlowSignals_2.BREAK_SIGNAL; } });
+Object.defineProperty(exports, "CONTINUE_SIGNAL", { enumerable: true, get: function () { return controlFlowSignals_2.CONTINUE_SIGNAL; } });
+Object.defineProperty(exports, "NULL_SIGNAL", { enumerable: true, get: function () { return controlFlowSignals_2.NULL_SIGNAL; } });
+Object.defineProperty(exports, "RETURN_SIGNAL", { enumerable: true, get: function () { return controlFlowSignals_2.RETURN_SIGNAL; } });
+Object.defineProperty(exports, "BreakSignal", { enumerable: true, get: function () { return controlFlowSignals_2.BreakSignal; } });
+Object.defineProperty(exports, "ContinueSignal", { enumerable: true, get: function () { return controlFlowSignals_2.ContinueSignal; } });
+Object.defineProperty(exports, "ControlFlowSignal", { enumerable: true, get: function () { return controlFlowSignals_2.ControlFlowSignal; } });
+Object.defineProperty(exports, "NullSignal", { enumerable: true, get: function () { return controlFlowSignals_2.NullSignal; } });
+Object.defineProperty(exports, "ReturnSignal", { enumerable: true, get: function () { return controlFlowSignals_2.ReturnSignal; } });
+const BREAK_SIGNAL_INSTANCE = new controlFlowSignals_1.BreakSignal();
+const CONTINUE_SIGNAL_INSTANCE = new controlFlowSignals_1.ContinueSignal();
+let loopBodyDepth = 0;
+let parserReturnBoundaryDepth = 0;
+let returnPropagationDepth = 0;
+let symbolicFunctionDepth = 0;
+function throwNullSignal() {
+    throw new controlFlowSignals_1.NullSignal();
+}
+function isInsideSymbolicFunction() {
+    return symbolicFunctionDepth > 0;
+}
+function shouldConsumeLocalReturn() {
+    return symbolicFunctionDepth === 0 && returnPropagationDepth === 0;
+}
+function withReturnPropagation(evaluate) {
+    returnPropagationDepth++;
+    try {
+        return evaluate();
+    }
+    finally {
+        returnPropagationDepth--;
+    }
+}
+function isTruthy(value) {
+    if (!Expression_1.Expression.isExpression(value)) {
+        throw new errors_1.UnexpectedDataType((0, errors_1.message)('expressionExpected', { type: constants_1.dataTypes[value.dataType] }));
+    }
+    return !value.isZero();
+}
+function functionBoundary(evaluate) {
+    let retval;
+    symbolicFunctionDepth++;
+    try {
+        retval = evaluate();
+    }
+    catch (error) {
+        if (controlFlowSignals_1.ReturnSignal.isReturnSignal(error))
+            retval = error.value;
+        else if (controlFlowSignals_1.BreakSignal.isBreakSignal(error))
+            throw new errors_1.ParserError((0, errors_1.message)('breakOutsideLoop'));
+        else if (controlFlowSignals_1.ContinueSignal.isContinueSignal(error))
+            throw new errors_1.ParserError((0, errors_1.message)('continueOutsideLoop'));
+        else
+            throw error;
+    }
+    finally {
+        symbolicFunctionDepth--;
+    }
+    return retval;
+}
+function RETURN(x) {
+    throw new controlFlowSignals_1.ReturnSignal(x);
+}
+function BREAK() {
+    if (loopBodyDepth === 0)
+        throw new errors_1.ParserError((0, errors_1.message)('breakOutsideLoop'));
+    throw BREAK_SIGNAL_INSTANCE;
+}
+function CONTINUE() {
+    if (loopBodyDepth === 0)
+        throw new errors_1.ParserError((0, errors_1.message)('continueOutsideLoop'));
+    throw CONTINUE_SIGNAL_INSTANCE;
+}
+function AND(...args) {
+    let retval = (0, shortcuts_1.one)();
+    for (const arg of args) {
+        if (!isTruthy(arg())) {
+            retval = (0, shortcuts_1.zero)();
+            break;
+        }
+    }
+    return retval;
+}
+function OR(...args) {
+    let retval = (0, shortcuts_1.zero)();
+    for (const arg of args) {
+        if (isTruthy(arg())) {
+            retval = (0, shortcuts_1.one)();
+            break;
+        }
+    }
+    return retval;
+}
+function NOT(value) {
+    return isTruthy(value) ? (0, shortcuts_1.zero)() : (0, shortcuts_1.one)();
+}
+function XOR(...args) {
+    let odd = false;
+    for (const arg of args)
+        if (isTruthy(arg))
+            odd = !odd;
+    return odd ? (0, shortcuts_1.one)() : (0, shortcuts_1.zero)();
+}
+function IFERROR(expression, fallback) {
+    let retval;
+    try {
+        retval = expression();
+    }
+    catch (error) {
+        if (error instanceof controlFlowSignals_1.ControlFlowSignal)
+            throw error;
+        retval = fallback();
+    }
+    return retval;
+}
+function ISERROR(expression) {
+    let retval = (0, shortcuts_1.zero)();
+    try {
+        expression();
+    }
+    catch (error) {
+        if (error instanceof controlFlowSignals_1.ControlFlowSignal)
+            throw error;
+        retval = (0, shortcuts_1.one)();
+    }
+    return retval;
+}
+function controlFlowReturnBoundary(evaluate) {
+    let retval;
+    try {
+        retval = evaluate();
+    }
+    catch (error) {
+        if (parserReturnBoundaryDepth > 0 &&
+            symbolicFunctionDepth === 0 &&
+            controlFlowSignals_1.ReturnSignal.isReturnSignal(error))
+            retval = error.value;
+        else
+            throw error;
+    }
+    return retval;
+}
+function IF(condition, branch1, branch2) {
+    return controlFlowReturnBoundary(() => {
+        const evaluatedCondition = condition();
+        let retval;
+        if (isTruthy(evaluatedCondition))
+            retval = branch1();
+        else if (branch2)
+            retval = branch2();
+        else
+            return throwNullSignal();
+        return retval;
+    });
+}
+function WHILE(condition, body) {
+    return controlFlowReturnBoundary(() => {
+        let retval;
+        let continueLoop = true;
+        let iterations = 0;
+        while (continueLoop) {
+            const evaluatedCondition = condition();
+            if (!isTruthy(evaluatedCondition))
+                continueLoop = false;
+            else {
+                if (iterations >= Settings_1.Settings.MAX_LOOP_ITERATIONS) {
+                    throw new errors_1.ParserError((0, errors_1.message)('loopIterationLimitExceeded', { max: String(Settings_1.Settings.MAX_LOOP_ITERATIONS) }));
+                }
+                loopBodyDepth++;
+                try {
+                    retval = body();
+                }
+                catch (error) {
+                    if (controlFlowSignals_1.NullSignal.isNullSignal(error)) {
+                        // A loop body may legitimately complete without producing a value.
+                    }
+                    else if (controlFlowSignals_1.BreakSignal.isBreakSignal(error))
+                        continueLoop = false;
+                    else if (!controlFlowSignals_1.ContinueSignal.isContinueSignal(error))
+                        throw error;
+                }
+                finally {
+                    loopBodyDepth--;
+                }
+                iterations++;
+            }
+        }
+        if (retval === undefined) {
+            return throwNullSignal();
+        }
+        return retval;
+    });
+}
+function FOR(initializer, condition, update, body) {
+    return controlFlowReturnBoundary(() => {
+        initializer();
+        return WHILE(condition, () => {
+            let bodyResult;
+            try {
+                bodyResult = body();
+            }
+            catch (error) {
+                if (controlFlowSignals_1.ContinueSignal.isContinueSignal(error) ||
+                    controlFlowSignals_1.NullSignal.isNullSignal(error))
+                    update();
+                throw error;
+            }
+            update();
+            return bodyResult;
+        });
+    });
+}
+function BLOCK(...args) {
+    if (args.length === 0)
+        return throwNullSignal();
+    let retval;
+    for (const arg of args) {
+        try {
+            retval = arg();
+        }
+        catch (error) {
+            if (!controlFlowSignals_1.NullSignal.isNullSignal(error))
+                throw error;
+        }
+    }
+    if (retval === undefined)
+        return throwNullSignal();
+    return retval;
+}
+function parserReturnBoundary(evaluate) {
+    const consumesReturn = symbolicFunctionDepth === 0 && parserReturnBoundaryDepth === 0;
+    let retval;
+    parserReturnBoundaryDepth++;
+    try {
+        retval = evaluate();
+    }
+    catch (error) {
+        if (consumesReturn && controlFlowSignals_1.ReturnSignal.isReturnSignal(error))
+            retval = error.value;
+        else
+            throw error;
+    }
+    finally {
+        parserReturnBoundaryDepth--;
+    }
+    return retval;
+}
+function parserBlock(...args) {
+    return parserReturnBoundary(() => BLOCK(...args));
+}

package/output/core/classes/parser/scripting/deferred.d.ts

@@ -0,0 +1,4 @@
+import type { DeferredFunctionArgument } from '../types';
+import type { ParserEntity } from '../../../types';
+/** Iterates parser containers while keeping iteration variables local to each body call. */
+export declare function each(collection: DeferredFunctionArgument, variable: DeferredFunctionArgument, bodyOrValueVariable: DeferredFunctionArgument, dictionaryBody?: DeferredFunctionArgument): ParserEntity;

package/output/core/classes/parser/scripting/deferred.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.each = each;
+const Collection_1 = require("../../collection/Collection");
+const Dictionary_1 = require("../../dictionary/Dictionary");
+const Expression_1 = require("../../expression/Expression");
+const shortcuts_1 = require("../../expression/shortcuts");
+const Matrix_1 = require("../../matrix/Matrix");
+const ValuesSet_1 = require("../../valuesSet/ValuesSet");
+const Vector_1 = require("../../vector/Vector");
+const errors_1 = require("../../../errors");
+const constants_1 = require("../constants");
+const controlFlow_1 = require("./controlFlow");
+const scope_1 = require("./scope");
+/** Iterates parser containers while keeping iteration variables local to each body call. */
+function each(collection, variable, bodyOrValueVariable, dictionaryBody) {
+    const target = collection();
+    const values = [];
+    const keys = [];
+    if (dictionaryBody) {
+        if (!Dictionary_1.Dictionary.isDictionary(target)) {
+            throw new errors_1.UnexpectedDataType((0, errors_1.message)('unsupportedType', { type: constants_1.dataTypes[target.dataType] }));
+        }
+        for (const [key, value] of target.entries()) {
+            keys.push(Expression_1.Expression.create(key));
+            values.push(value.copy());
+        }
+    }
+    else if (Vector_1.Vector.isVector(target) ||
+        Collection_1.Collection.isCollection(target) ||
+        ValuesSet_1.ValuesSet.isValuesSet(target)) {
+        target.forEach(value => values.push(value.copy()));
+    }
+    else if (Matrix_1.Matrix.isMatrix(target)) {
+        target.forEach(value => values.push(value.copy()));
+    }
+    else if (Dictionary_1.Dictionary.isDictionary(target)) {
+        target.forEach(value => values.push(value.copy()));
+    }
+    else {
+        throw new errors_1.UnexpectedDataType((0, errors_1.message)('unsupportedType', { type: constants_1.dataTypes[target.dataType] }));
+    }
+    let index = 0;
+    let retval;
+    try {
+        retval = (0, controlFlow_1.withReturnPropagation)(() => (0, controlFlow_1.FOR)(() => (0, shortcuts_1.zero)(), () => (index < values.length ? (0, shortcuts_1.one)() : (0, shortcuts_1.zero)()), () => {
+            index++;
+            return (0, shortcuts_1.zero)();
+        }, () => {
+            if (dictionaryBody) {
+                return (0, scope_1.LET)(variable, () => keys[index], () => (0, scope_1.LET)(bodyOrValueVariable, () => values[index], dictionaryBody));
+            }
+            return (0, scope_1.LET)(variable, () => values[index], bodyOrValueVariable);
+        }));
+    }
+    catch (error) {
+        if (!(0, controlFlow_1.isInsideSymbolicFunction)() && controlFlow_1.ReturnSignal.isReturnSignal(error)) {
+            retval = error.value;
+        }
+        else {
+            throw error;
+        }
+    }
+    return retval;
+}

package/output/core/classes/parser/scripting/dispatch.d.ts

@@ -0,0 +1 @@
+export declare function loadScriptingFunctions(): void;