nerdamer 2.0.0-rc.2 → 2.0.0

package/output/core/classes/parser/operations/functions.d.ts

@@ -1,9 +1,8 @@
 import { Equation } from '../../equation/Equation';
 import { Matrix } from '../../matrix/Matrix';
 import { Vector } from '../../vector/Vector';
-import { comma } from './comma';
 import type { ParserEntity } from '../../../types';
-import type { Operation, PreFixFunction, PostFixFunction, EquationConstructorCall, CommaOperation, DeferredFunctionArgument, DeferredOperation } from '../types';
+import type { Operation, PreFixFunction, PostFixFunction, EquationConstructorCall, DeferredFunctionArgument, DeferredOperation } from '../types';
 /**
  * The wrapper used to call functions within the parser.
  *
@@ -16,7 +15,7 @@ export declare function callFunction(functionName: string, args: (ParserEntity |
  * Combines all base operations into one object for parser.
  */
 export declare const _: {
-    [functionName: string]: Operation | DeferredOperation | PreFixFunction | PostFixFunction | EquationConstructorCall | CommaOperation;
+    [functionName: string]: Operation | DeferredOperation | PreFixFunction | PostFixFunction | EquationConstructorCall;
 };
 /**
  * Applies a scalar function over a copied Vector or Matrix while preserving its shape.
@@ -43,4 +42,4 @@ export declare function setEqual(a: ParserEntity, b: ParserEntity): Equation;
  * @returns The registered function signature.
  */
 export declare function functionAssign(a: ParserEntity, body: DeferredFunctionArgument): ParserEntity;
-export declare function route(a: ParserEntity, b: ParserEntity, operation: string): ParserEntity | ReturnType<typeof comma>;
+export declare function route(a: ParserEntity, b: ParserEntity, operation: string): ParserEntity;

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

@@ -7,7 +7,6 @@ exports.setEqual = setEqual;
 exports.functionAssign = functionAssign;
 exports.route = route;
 const math_1 = require("../../../../math/math");
-const structuredEntityUtils_1 = require("../../../common/functions/structuredEntityUtils");
 const dispatch_1 = require("../../../dispatch");
 const errors_1 = require("../../../errors");
 const setFunction_1 = require("../../../functions/setFunction");
@@ -24,7 +23,6 @@ const controlFlow_1 = require("../scripting/controlFlow");
 const functions_1 = require("../scripting/functions");
 const scope_1 = require("../scripting/scope");
 const add_1 = require("./add");
-const comma_1 = require("./comma");
 const divide_1 = require("./divide");
 const multiply_1 = require("./multiply");
 const power_1 = require("./power");
@@ -87,18 +85,15 @@ function callFunction(functionName, args) {
             }
             entityArgs.push(arg);
         }
-        // A structured entity carrying symbolic bracket access represents one unresolved
-        // scalar value. Normalize it before equation checks, distribution, or invocation.
-        const normalizedArgs = entityArgs.map(arg => Expression_1.Expression.fromSymbolicAccess(arg) ?? arg);
         if (attributes.level === 'system') {
-            for (let i = 0; i < normalizedArgs.length; i++) {
-                if (Equation_1.Equation.isEquation(normalizedArgs[i]) && !equationArgs?.includes(i)) {
+            for (let i = 0; i < entityArgs.length; i++) {
+                if (Equation_1.Equation.isEquation(entityArgs[i]) && !equationArgs?.includes(i)) {
                     throw new errors_1.UnexpectedDataType((0, errors_1.message)('expressionExpected', { type: 'Equation' }));
                 }
             }
         }
         const elementWiseArgs = distElWise
-            ? normalizedArgs.filter((arg) => Vector_1.Vector.isVector(arg) || Matrix_1.Matrix.isMatrix(arg))
+            ? entityArgs.filter((arg) => Vector_1.Vector.isVector(arg) || Matrix_1.Matrix.isMatrix(arg))
             : [];
         if (elementWiseArgs.length > 0) {
             const structure = elementWiseArgs[0];
@@ -115,7 +110,7 @@ function callFunction(functionName, args) {
                 }
             }
             result = distribute((_element, i, j) => {
-                const scalarArgs = normalizedArgs.map(arg => {
+                const scalarArgs = entityArgs.map(arg => {
                     let scalarArg = arg;
                     if (Vector_1.Vector.isVector(arg)) {
                         scalarArg = arg.__get__([i]);
@@ -130,15 +125,15 @@ function callFunction(functionName, args) {
         }
         // Call and return
         else if (!fn || Settings_1.Settings.DEFER_SIMPLIFICATION) {
-            result = Expression_1.Expression.toFunction(functionName, normalizedArgs);
+            result = Expression_1.Expression.toFunction(functionName, entityArgs);
         }
         else {
-            result = invokeMathFunction(fn, normalizedArgs);
+            result = invokeMathFunction(fn, entityArgs);
         }
         // Ensure that this function always returns even if it's a symbolic function. This will
         // occur if the function didn't return a value.
         if (!result) {
-            result = Expression_1.Expression.toFunction(functionName, normalizedArgs);
+            result = Expression_1.Expression.toFunction(functionName, entityArgs);
         }
     }
     // Let all future calls know that an inferior precision was used.
@@ -164,7 +159,6 @@ exports._ = {
     assertGTE: assertiveFunctions_1.assertGTE,
     assertLT: assertiveFunctions_1.assertLT,
     assertLTE: assertiveFunctions_1.assertLTE,
-    comma: comma_1.comma,
     assign: scope_1.assign,
     functionAssign: functionAssign,
     setEqual: setEqual,
@@ -297,7 +291,7 @@ function percentage(a) {
     if (!Expression_1.Expression.isExpression(a)) {
         throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
     }
-    const retval = a.div(100);
+    const retval = a.div(Expression_1.Expression.create(100));
     return retval;
 }
 /**
@@ -318,25 +312,8 @@ function gte(a, b) {
 function lte(a, b) {
     return Expression_1.Expression.create(Number(a.lte(b)));
 }
-function isRoutedOperation(operation) {
-    return (operation === 'pow' ||
-        operation === 'times' ||
-        operation === 'div' ||
-        operation === 'minus' ||
-        operation === 'plus' ||
-        operation === 'eq' ||
-        operation === 'lt' ||
-        operation === 'lte' ||
-        operation === 'gt' ||
-        operation === 'gte');
-}
-function routeOperation(target, operand, operation) {
-    const retval = target[operation](operand);
-    return typeof retval === 'boolean' ? Expression_1.Expression.create(Number(retval)) : retval;
-}
 function dispatchDynamicOperation(a, b, operation) {
-    // Preserve the parser's historically loose dispatch for operator actions outside
-    // RoutedOperation. Tightening these actions may change existing runtime behavior.
+    // Preserve the parser's historically loose method dispatch for operator actions.
     const useA = a.isEnumerable || Equation_1.Equation.isEquation(a);
     const target = useA ? a : b;
     const operand = useA ? b : a;
@@ -354,82 +331,43 @@ function route(a, b, operation) {
     if (operation === 'assign') {
         retval = (0, scope_1.assign)(a, b);
     }
-    else if (operation === 'comma') {
-        retval = (0, comma_1.comma)(a, b);
-    }
     else if (operation === 'in') {
         // Membership is the infix form of contains(container, value), so reverse the operands.
         retval = callFunction('contains', [b, a]);
     }
-    else if (isRoutedOperation(operation)) {
-        if (Equation_1.Equation.isEquation(a) || Equation_1.Equation.isEquation(b)) {
-            if (Equation_1.Equation.isEquation(a) && Equation_1.Equation.isEquation(b)) {
-                if (['eq', 'lt', 'lte', 'gt', 'gte'].includes(operation)) {
-                    retval = dispatchDynamicOperation(a, b, operation);
-                }
-                else {
-                    throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+    else if (a.isEnumerable) {
+        retval = dispatchDynamicOperation(a, b, operation);
+    }
+    else if ((Vector_1.Vector.isVector(b) || Matrix_1.Matrix.isMatrix(b)) &&
+        (operation === 'minus' || operation === 'div' || operation === 'pow')) {
+        // Scalar-left operations are not commutative. Preserve operand order while
+        // distributing the operation over the structured right-hand operand.
+        if (!Expression_1.Expression.isExpression(a)) {
+            throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+        }
+        // A scalar base with a Matrix exponent is a matrix-function question. It must
+        // not be reversed into Matrix.pow() or silently treated as element-wise power.
+        if (Matrix_1.Matrix.isMatrix(b) && operation === 'pow') {
+            throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+        }
+        retval = distribute(element => {
+            let elementResult;
+            if (Expression_1.Expression.isExpression(element)) {
+                if (operation === 'minus') {
+                    elementResult = (0, subtract_1.subtract)(a, element);
                 }
-            }
-            else if (Equation_1.Equation.isEquation(a)) {
-                if (['plus', 'minus', 'times', 'div'].includes(operation)) {
-                    retval = dispatchDynamicOperation(a, b, operation);
+                else if (operation === 'div') {
+                    elementResult = (0, divide_1.divide)(a, element);
                 }
                 else {
-                    throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+                    elementResult = (0, power_1.power)(a, element);
                 }
             }
-            else if (operation === 'plus' || operation === 'times') {
-                retval = dispatchDynamicOperation(a, b, operation);
-            }
             else {
-                throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+                elementResult = route(a, element, operation);
             }
-        }
-        else if ((0, structuredEntityUtils_1.isEnumerable)(a)) {
-            retval = routeOperation(a, b, operation);
-        }
-        else if ((Vector_1.Vector.isVector(b) || Matrix_1.Matrix.isMatrix(b)) &&
-            (operation === 'minus' || operation === 'div' || operation === 'pow')) {
-            // Scalar-left operations are not commutative. Preserve operand order while
-            // distributing the operation over the structured right-hand operand.
-            if (!Expression_1.Expression.isExpression(a)) {
-                throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
-            }
-            // A scalar base with a Matrix exponent is a matrix-function question. It must
-            // not be reversed into Matrix.pow() or silently treated as element-wise power.
-            if (Matrix_1.Matrix.isMatrix(b) && operation === 'pow') {
-                throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
-            }
-            retval = distribute(element => {
-                let elementResult;
-                if (Expression_1.Expression.isExpression(element)) {
-                    if (operation === 'minus') {
-                        elementResult = (0, subtract_1.subtract)(a, element);
-                    }
-                    else if (operation === 'div') {
-                        elementResult = (0, divide_1.divide)(a, element);
-                    }
-                    else {
-                        elementResult = (0, power_1.power)(a, element);
-                    }
-                }
-                else {
-                    const nestedResult = route(a, element, operation);
-                    if (Array.isArray(nestedResult)) {
-                        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
-                    }
-                    elementResult = nestedResult;
-                }
-                return elementResult;
-            }, b);
-        }
-        else if ((0, structuredEntityUtils_1.isEnumerable)(b)) {
-            retval = routeOperation(b, a, operation);
-        }
-        else {
-            retval = dispatchDynamicOperation(a, b, operation);
-        }
+            return elementResult;
+        }, b);
     }
     else {
         retval = dispatchDynamicOperation(a, b, operation);

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

@@ -224,7 +224,7 @@ function power(a, b) {
                 let remainder = (0, shortcuts_1.one)();
                 let changed = false;
                 for (const element of a.elementsArray()) {
-                    if (!element.isComplex() && element.gt(0)) {
+                    if (!element.isComplex() && element.gt((0, shortcuts_1.zero)())) {
                         extracted = extracted.times(power(element, b));
                         changed = true;
                     }
@@ -512,7 +512,7 @@ function setPower(a, b) {
         if (p.isNUM() &&
             a.isEXP() &&
             !a.getBase().isComplex() &&
-            a.getBase().gt(0) &&
+            a.getBase().gt((0, shortcuts_1.zero)()) &&
             (0, complex_1.imagPart)(a.getPower()).isZero()) {
             retval = power(a.getBase(), p).times(a.getMultiplier());
         }

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

@@ -190,40 +190,47 @@ function findArgumentEnd(input, start, maxArgs, consumeStatement = false) {
             continue;
         }
         if (isClosingBracket(character)) {
-            if (depth === 0)
+            if (depth === 0) {
                 break;
+            }
             depth--;
             previousSignificant = character;
             continue;
         }
         if (depth > 0) {
-            if (!/\s/.test(character))
+            if (!/\s/.test(character)) {
                 previousSignificant = character;
+            }
             continue;
         }
         if (consumeStatement) {
-            if (character === ',')
+            if (character === ',') {
                 break;
-            if (!/\s/.test(character))
+            }
+            if (!/\s/.test(character)) {
                 previousSignificant = character;
+            }
             continue;
         }
         if (/\s/.test(character)) {
-            if (multipleArguments && previousSignificant === ',')
+            if (multipleArguments && previousSignificant === ',') {
                 continue;
+            }
             break;
         }
         if (character === ',') {
-            if (!multipleArguments)
+            if (!multipleArguments) {
                 break;
+            }
             previousSignificant = character;
             continue;
         }
         const isPrefixSign = (character === '+' || character === '-') &&
             (index === start || previousSignificant === ',' || previousSignificant === '^');
         const isBinaryBoundary = /[+\-*/=<>:&|]/.test(character) && !isPrefixSign;
-        if (isBinaryBoundary)
+        if (isBinaryBoundary) {
             break;
+        }
         previousSignificant = character;
     }
     return index;

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

@@ -73,14 +73,18 @@ function functionBoundary(evaluate) {
         retval = evaluate();
     }
     catch (error) {
-        if (controlFlowSignals_1.ReturnSignal.isReturnSignal(error))
+        if (controlFlowSignals_1.ReturnSignal.isReturnSignal(error)) {
             retval = error.value;
-        else if (controlFlowSignals_1.BreakSignal.isBreakSignal(error))
+        }
+        else if (controlFlowSignals_1.BreakSignal.isBreakSignal(error)) {
             throw new errors_1.ParserError((0, errors_1.message)('breakOutsideLoop'));
-        else if (controlFlowSignals_1.ContinueSignal.isContinueSignal(error))
+        }
+        else if (controlFlowSignals_1.ContinueSignal.isContinueSignal(error)) {
             throw new errors_1.ParserError((0, errors_1.message)('continueOutsideLoop'));
-        else
+        }
+        else {
             throw error;
+        }
     }
     finally {
         symbolicFunctionDepth--;
@@ -91,13 +95,15 @@ function RETURN(x) {
     throw new controlFlowSignals_1.ReturnSignal(x);
 }
 function BREAK() {
-    if (loopBodyDepth === 0)
+    if (loopBodyDepth === 0) {
         throw new errors_1.ParserError((0, errors_1.message)('breakOutsideLoop'));
+    }
     throw BREAK_SIGNAL_INSTANCE;
 }
 function CONTINUE() {
-    if (loopBodyDepth === 0)
+    if (loopBodyDepth === 0) {
         throw new errors_1.ParserError((0, errors_1.message)('continueOutsideLoop'));
+    }
     throw CONTINUE_SIGNAL_INSTANCE;
 }
 function AND(...args) {
@@ -125,9 +131,11 @@ function NOT(value) {
 }
 function XOR(...args) {
     let odd = false;
-    for (const arg of args)
-        if (isTruthy(arg))
+    for (const arg of args) {
+        if (isTruthy(arg)) {
             odd = !odd;
+        }
+    }
     return odd ? (0, shortcuts_1.one)() : (0, shortcuts_1.zero)();
 }
 function IFERROR(expression, fallback) {
@@ -136,8 +144,9 @@ function IFERROR(expression, fallback) {
         retval = expression();
     }
     catch (error) {
-        if (error instanceof controlFlowSignals_1.ControlFlowSignal)
+        if (error instanceof controlFlowSignals_1.ControlFlowSignal) {
             throw error;
+        }
         retval = fallback();
     }
     return retval;
@@ -148,8 +157,9 @@ function ISERROR(expression) {
         expression();
     }
     catch (error) {
-        if (error instanceof controlFlowSignals_1.ControlFlowSignal)
+        if (error instanceof controlFlowSignals_1.ControlFlowSignal) {
             throw error;
+        }
         retval = (0, shortcuts_1.one)();
     }
     return retval;
@@ -161,11 +171,13 @@ function controlFlowReturnBoundary(evaluate) {
     }
     catch (error) {
         if (parserReturnBoundaryDepth > 0 &&
-            symbolicFunctionDepth === 0 &&
-            controlFlowSignals_1.ReturnSignal.isReturnSignal(error))
+            shouldConsumeLocalReturn() &&
+            controlFlowSignals_1.ReturnSignal.isReturnSignal(error)) {
             retval = error.value;
-        else
+        }
+        else {
             throw error;
+        }
     }
     return retval;
 }
@@ -173,12 +185,15 @@ function IF(condition, branch1, branch2) {
     return controlFlowReturnBoundary(() => {
         const evaluatedCondition = condition();
         let retval;
-        if (isTruthy(evaluatedCondition))
+        if (isTruthy(evaluatedCondition)) {
             retval = branch1();
-        else if (branch2)
+        }
+        else if (branch2) {
             retval = branch2();
-        else
+        }
+        else {
             return throwNullSignal();
+        }
         return retval;
     });
 }
@@ -189,8 +204,9 @@ function WHILE(condition, body) {
         let iterations = 0;
         while (continueLoop) {
             const evaluatedCondition = condition();
-            if (!isTruthy(evaluatedCondition))
+            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) }));
@@ -203,10 +219,12 @@ function WHILE(condition, body) {
                     if (controlFlowSignals_1.NullSignal.isNullSignal(error)) {
                         // A loop body may legitimately complete without producing a value.
                     }
-                    else if (controlFlowSignals_1.BreakSignal.isBreakSignal(error))
+                    else if (controlFlowSignals_1.BreakSignal.isBreakSignal(error)) {
                         continueLoop = false;
-                    else if (!controlFlowSignals_1.ContinueSignal.isContinueSignal(error))
+                    }
+                    else if (!controlFlowSignals_1.ContinueSignal.isContinueSignal(error)) {
                         throw error;
+                    }
                 }
                 finally {
                     loopBodyDepth--;
@@ -230,8 +248,9 @@ function FOR(initializer, condition, update, body) {
             }
             catch (error) {
                 if (controlFlowSignals_1.ContinueSignal.isContinueSignal(error) ||
-                    controlFlowSignals_1.NullSignal.isNullSignal(error))
+                    controlFlowSignals_1.NullSignal.isNullSignal(error)) {
                     update();
+                }
                 throw error;
             }
             update();
@@ -240,20 +259,23 @@ function FOR(initializer, condition, update, body) {
     });
 }
 function BLOCK(...args) {
-    if (args.length === 0)
+    if (args.length === 0) {
         return throwNullSignal();
+    }
     let retval;
     for (const arg of args) {
         try {
             retval = arg();
         }
         catch (error) {
-            if (!controlFlowSignals_1.NullSignal.isNullSignal(error))
+            if (!controlFlowSignals_1.NullSignal.isNullSignal(error)) {
                 throw error;
+            }
         }
     }
-    if (retval === undefined)
+    if (retval === undefined) {
         return throwNullSignal();
+    }
     return retval;
 }
 function parserReturnBoundary(evaluate) {
@@ -264,10 +286,12 @@ function parserReturnBoundary(evaluate) {
         retval = evaluate();
     }
     catch (error) {
-        if (consumesReturn && controlFlowSignals_1.ReturnSignal.isReturnSignal(error))
+        if (consumesReturn && controlFlowSignals_1.ReturnSignal.isReturnSignal(error)) {
             retval = error.value;
-        else
+        }
+        else {
             throw error;
+        }
     }
     finally {
         parserReturnBoundaryDepth--;

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

@@ -1,4 +1,4 @@
-import type { DeferredFunctionArgument } from '../types';
 import type { ParserEntity } from '../../../types';
+import type { DeferredFunctionArgument } 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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.each = each;
+const errors_1 = require("../../../errors");
 const Collection_1 = require("../../collection/Collection");
 const Dictionary_1 = require("../../dictionary/Dictionary");
 const Expression_1 = require("../../expression/Expression");
@@ -8,7 +9,6 @@ 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");

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

@@ -19,16 +19,20 @@ function assign(a, b) {
     if (Expression_1.Expression.isExpression(a) && !a.isPlainVariable()) {
         throw new errors_1.UnexpectedInputError((0, errors_1.message)('plainVariableExpected', { input: String(a) }));
     }
-    if (Settings_1.RESTRICTED.includes(a.value))
+    if (Settings_1.RESTRICTED.includes(a.value)) {
         throw new errors_1.AssignmentError((0, errors_1.message)('restrictedVariableName', { name: a.value }));
+    }
     let value;
     try {
-        if (typeof b === 'function')
+        if (typeof b === 'function') {
             value = b();
-        else if (typeof b === 'string')
+        }
+        else if (typeof b === 'string') {
             value = Parser_1.Parser.parse(b);
-        else
+        }
+        else {
             value = b;
+        }
     }
     catch (error) {
         if (controlFlowSignals_1.NullSignal.isNullSignal(error)) {
@@ -58,20 +62,24 @@ function normalizeLetArguments(argumentScopes) {
         if (assignmentIndex > 0 && assignmentIndex < argumentScope.length - 1) {
             const nameScope = new Scope_1.Scope(argumentScope.type, argumentScope.column);
             const valueScope = new Scope_1.Scope(argumentScope.type, argumentScope.column);
-            for (let j = 0; j < assignmentIndex; j++)
+            for (let j = 0; j < assignmentIndex; j++) {
                 nameScope.push(argumentScope[j]);
-            for (let j = assignmentIndex + 1; j < argumentScope.length; j++)
+            }
+            for (let j = assignmentIndex + 1; j < argumentScope.length; j++) {
                 valueScope.push(argumentScope[j]);
+            }
             normalizedScopes.push(nameScope, valueScope);
         }
-        else
+        else {
             normalizedScopes.push(argumentScope);
+        }
     }
     return normalizedScopes;
 }
 function LET(...args) {
-    if (args.length < 3 || args.length % 2 === 0)
+    if (args.length < 3 || args.length % 2 === 0) {
         throw new errors_1.ParserError((0, errors_1.message)('letRequiresBindingsAndBody'));
+    }
     const previousValues = new Map();
     const previouslyUndefined = new Set();
     const localNames = [];
@@ -85,30 +93,37 @@ function LET(...args) {
             const name = (0, utils_1.assertPlainVariableAndGetString)(nameExpression);
             const value = args[i + 1]({ excludeValues: localNames });
             if (!previousValues.has(name) && !previouslyUndefined.has(name)) {
-                if (Object.prototype.hasOwnProperty.call(Parser_1.Parser.KNOWN_VALUES, name))
+                if (Object.prototype.hasOwnProperty.call(Parser_1.Parser.KNOWN_VALUES, name)) {
                     previousValues.set(name, Parser_1.Parser.KNOWN_VALUES[name]);
-                else
+                }
+                else {
                     previouslyUndefined.add(name);
+                }
             }
             assign(nameExpression, value);
-            if (!localNames.includes(name))
+            if (!localNames.includes(name)) {
                 localNames.push(name);
+            }
         }
         try {
             retval = args[args.length - 1]({ excludeValues: localNames });
         }
         catch (error) {
-            if ((0, controlFlow_1.shouldConsumeLocalReturn)() && controlFlow_1.ReturnSignal.isReturnSignal(error))
+            if ((0, controlFlow_1.shouldConsumeLocalReturn)() && controlFlow_1.ReturnSignal.isReturnSignal(error)) {
                 retval = error.value;
-            else
+            }
+            else {
                 throw error;
+            }
         }
     }
     finally {
-        for (const [name, value] of previousValues)
+        for (const [name, value] of previousValues) {
             Parser_1.Parser.KNOWN_VALUES[name] = value;
-        for (const name of previouslyUndefined)
+        }
+        for (const name of previouslyUndefined) {
             delete Parser_1.Parser.KNOWN_VALUES[name];
+        }
     }
     return retval;
 }
@@ -117,16 +132,20 @@ function unassign(x) {
     let name;
     if (typeof x === 'function') {
         const parsed = x({ inheritValues: false, substitute: false });
-        if (!Expression_1.Expression.isExpression(parsed))
+        if (!Expression_1.Expression.isExpression(parsed)) {
             throw new errors_1.UnexpectedInputError((0, errors_1.message)('plainVariableExpected', { input: parsed.text() }));
+        }
         variable = parsed;
     }
-    else
+    else {
         variable = x;
-    if (Expression_1.Expression.isExpression(variable))
+    }
+    if (Expression_1.Expression.isExpression(variable)) {
         name = (0, utils_1.assertPlainVariableAndGetString)(variable);
-    else
+    }
+    else {
         name = variable;
+    }
     delete Parser_1.Parser.KNOWN_VALUES[name];
     return Expression_1.Expression.create(variable);
 }

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

@@ -8,11 +8,6 @@ import type Decimal from 'decimal.js';
  * The type used to defined a operation function for the parser
  */
 export type Operation = (a: ParserEntity, b?: ParserEntity) => ParserEntity;
-/**
- * The comma operation returns both operands so the parser can place them back
- * on the output stack as separate values.
- */
-export type CommaOperation = (a: ParserStackValue, b: ParserStackValue) => ParserStackValue[];
 /**
  * The type used to defined a prefix for the parser
  */