nerdamer 2.0.0-rc.1 → 2.0.0

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

@@ -19,6 +19,7 @@ const Rational_1 = require("../rational/Rational");
 const ValuesSet_1 = require("../valuesSet/ValuesSet");
 const Vector_1 = require("../vector/Vector");
 const constants_1 = require("./constants");
+const controlFlowSignals_1 = require("./controlFlowSignals");
 const functions_2 = require("./operations/functions");
 const preprocess_1 = require("./preprocess");
 const Token_1 = require("./Token");
@@ -91,6 +92,47 @@ class ExpressionParser {
      * result, so ordinary substitution does not hand out the stored object itself.
      */
     KNOWN_VALUES = {};
+    /**
+     * Resolves a Dictionary index through the active parser scope.
+     *
+     * A plain variable index is resolved directly instead of reparsing its square
+     * scope. This matters for deferred scripting bodies, where LET installs the
+     * current binding in KNOWN_VALUES while excluding that name from inherited
+     * call-scoped substitutions.
+     *
+     * An unresolved symbolic index remains its own textual key, so d[x] still
+     * addresses the literal key "x". Computed indices continue through the normal
+     * parser path.
+     */
+    extractDictionaryKey(scope, values, assertive) {
+        if (scope.length === 1 &&
+            Token_1.Token.isToken(scope[0]) &&
+            scope[0].type === Token_1.Token.VARIABLE) {
+            const token = scope[0];
+            const scopedValue = values?.[token.value];
+            if (scopedValue !== undefined) {
+                if (Expression_1.Expression.isExpression(scopedValue) ||
+                    Equation_1.Equation.isEquation(scopedValue) ||
+                    (0, structuredEntityUtils_1.isEnumerable)(scopedValue)) {
+                    return scopedValue.text();
+                }
+                return Expression_1.Expression.create(scopedValue, undefined, true).text();
+            }
+            if (Settings_1.Settings.SUBSTITUTE && token.value in this.KNOWN_VALUES) {
+                return this.KNOWN_VALUES[token.value].text();
+            }
+            return token.value;
+        }
+        const parsed = this.parseRPN(scope, values, assertive);
+        let key = parsed;
+        if (Vector_1.Vector.isVector(parsed) && parsed.elements.length === 1) {
+            key = parsed.elements[0];
+        }
+        else if (Collection_1.Collection.isCollection(parsed) && parsed.getElements().length === 1) {
+            key = parsed.getElements()[0];
+        }
+        return key.text();
+    }
     /**
      * Converts an index scope to the zero-based indices used internally.
      *
@@ -155,32 +197,44 @@ class ExpressionParser {
         return retval;
     }
     /**
-     * Extracts string keys from an index scope for Dictionary access.
-     * For d[x], the scope contains a single variable token "x" → returns ["x"].
-     * For d[myKey], returns ["myKey"].
+     * Resolves or preserves symbolic bracket access after the target and indices have
+     * been parsed. Vector and Matrix arity is checked here so direct bracket parsing
+     * and reevaluation of a preserved accessor follow the same rules.
      */
-    extractStringKeys(scope) {
-        const keys = [];
-        for (let k = 0; k < scope.length; k++) {
-            const item = scope[k];
-            if (Scope_1.Scope.isScope(item)) {
-                // Nested scope — not expected for dictionary keys
-                continue;
+    resolveSymbolicAccess(symbolicTarget, resolvedTarget, indices) {
+        if (indices.length > 2) {
+            throw new errors_1.ParserError((0, errors_1.message)('symbolicAccessMaxIndices'));
+        }
+        if (Vector_1.Vector.isVector(resolvedTarget) && indices.length !== 1) {
+            throw new errors_1.ParserError((0, errors_1.message)('symbolicVectorIndexCount'));
+        }
+        if (Matrix_1.Matrix.isMatrix(resolvedTarget) && indices.length !== 2) {
+            if (indices.length === 1) {
+                throw new errors_1.ParserError((0, errors_1.message)('symbolicMatrixRowNonScalar'));
             }
-            if (item.type === Token_1.Token.OPERATOR) {
-                // Skip comma separators
-                continue;
+            throw new errors_1.ParserError((0, errors_1.message)('symbolicMatrixCellIndexCount'));
+        }
+        if (Vector_1.Vector.isVector(resolvedTarget) || Matrix_1.Matrix.isMatrix(resolvedTarget)) {
+            const numericIndices = [];
+            for (const index of indices) {
+                const numericIndex = Number(index.text());
+                if (!Number.isFinite(numericIndex)) {
+                    return Expression_1.Expression.toAccessor(symbolicTarget, indices);
+                }
+                numericIndices.push(numericIndex - Settings_1.Settings.INDEX_BASE);
             }
-            // Use the token value as the string key
-            keys.push(item.value);
+            return resolvedTarget.__get__(numericIndices);
+        }
+        if (Expression_1.Expression.isExpression(resolvedTarget) && resolvedTarget.isPlainVariable()) {
+            return Expression_1.Expression.toAccessor(symbolicTarget, indices);
         }
-        return keys;
+        throw new errors_1.ParserError((0, errors_1.message)('symbolicAccessTargetType'));
     }
     /** Creates another spelling for an existing operator without changing its action. */
     aliasOperator(symbol, alias) {
         const source = this.operators[symbol];
         if (!source) {
-            throw new errors_1.ParserError(`Unknown operator ${symbol}`);
+            throw new errors_1.ParserError((0, errors_1.message)('unknownOperator', { operator: symbol }));
         }
         this.operators[alias] = {
             ...source,
@@ -302,6 +356,21 @@ class ExpressionParser {
     getPrecision() {
         return Rational_1.Rational.getPrecision();
     }
+    /**
+     * Reports whether a name is reserved by Nerdamer's parser or solver conventions.
+     *
+     * @remarks
+     * The result reflects the current process-wide parser state. In particular, changing
+     * the imaginary-unit symbol through {@link setI} removes the previous symbol from the
+     * restricted-name list and reserves the replacement. Solver-specific names such as
+     * `_n` and `all` are also reserved.
+     *
+     * @param name - Variable or symbol name to test.
+     * @returns Whether Nerdamer currently reserves the name.
+     */
+    isReserved(name) {
+        return Settings_1.RESTRICTED.includes(name);
+    }
     /**
      * Parses supported expression input into a Nerdamer parser entity.
      *
@@ -364,7 +433,16 @@ class ExpressionParser {
         const source = (0, preprocess_1.preprocess)(String(str), dispatch_1.mathFunctionRegistry);
         const rpn = this.toRPN(this.tokenize(source));
         // Read it into an expression.
-        const retval = this.parseRPN(rpn, values);
+        let retval;
+        try {
+            retval = this.parseRPN(rpn, values);
+        }
+        catch (error) {
+            if (controlFlowSignals_1.NullSignal.isNullSignal(error)) {
+                throw new errors_1.NullError((0, errors_1.message)('nullValue'));
+            }
+            throw error;
+        }
         return retval;
     }
     /**
@@ -395,15 +473,10 @@ class ExpressionParser {
         // The output stack
         const output = [];
         const operators = this.operators;
-        // TODO: this needs to be applied at the operation level. It's somewhat clunky to apply this here.
-        // const precision = this.getPrecision();
         function addToOutput(expression) {
             if (expression === undefined) {
                 throw new errors_1.ParserError((0, errors_1.message)('malformedExpression'));
             }
-            // Keep track of the precision used to make this calculation
-            // TODO: this needs to be applied at the operation level. It's somewhat clunky to apply this here.
-            // expression.precision = expression.precision || precision;
             output.push(expression);
         }
         function resolveStackValue(value) {
@@ -422,6 +495,16 @@ class ExpressionParser {
             }
             return resolved;
         }
+        const parseScope = (scope, scopeValues, scopeAssertive, substitute) => {
+            const parse = () => this.parseRPN(scope, scopeValues, scopeAssertive);
+            return typeof substitute === 'boolean'
+                ? (0, Settings_1.scopedBlock)('SUBSTITUTE', substitute, parse)
+                : parse();
+        };
+        const parseArguments = (scope, argumentValues, functionAssertive, substitute) => {
+            const parsed = parseScope(scope, argumentValues, functionAssertive, substitute);
+            return Collection_1.Collection.isCollection(parsed) ? parsed.getElements() : [parsed];
+        };
         const createDeferredArgument = (getArgumentRPN, inheritedValues, functionAssertive) => {
             let argumentRPN;
             return (options) => {
@@ -434,455 +517,271 @@ class ExpressionParser {
                         delete argumentValues[name];
                     }
                 }
-                let retval;
-                if (typeof options?.substitute === 'boolean') {
-                    retval = (0, Settings_1.scopedBlock)('SUBSTITUTE', options.substitute, () => {
-                        return this.parseRPN(rpn, argumentValues, functionAssertive);
-                    });
-                }
-                else {
-                    retval = this.parseRPN(rpn, argumentValues, functionAssertive);
-                }
-                return retval;
+                return parseScope(rpn, argumentValues, functionAssertive, options?.substitute);
             };
         };
-        // Begin parsing of tokens
-        for (let i = 0; i < rpn.length; i++) {
-            // Grab the token or Scope
-            const token = rpn[i];
-            if (Scope_1.Scope.isScope(token)) {
-                const lastOutput = output[output.length - 1];
-                if (token.deferRHSResolution) {
-                    addToOutput(createDeferredArgument(() => token, values, assertive));
-                }
-                else if (token.deferLHSResolution) {
-                    // Left-hand targets are parsed without substitution so assignment can update a
-                    // variable that already has a known value.
-                    const parsed = (0, Settings_1.scopedBlock)('SUBSTITUTE', false, () => {
-                        return this.parseRPN(token, undefined, assertive);
-                    });
-                    addToOutput(parsed);
+        const handleFunction = (token, argsScope) => {
+            if (token.value === constants_1.SYMBOLIC_ACCESSOR) {
+                const preservedArgs = parseArguments(argsScope, undefined, assertive, false);
+                const resolvedArgs = parseArguments(argsScope, values, assertive);
+                if (preservedArgs.length < 2 ||
+                    preservedArgs.length !== resolvedArgs.length ||
+                    !Expression_1.Expression.isExpression(preservedArgs[0]) ||
+                    !preservedArgs[0].isPlainVariable()) {
+                    throw new errors_1.ParserError((0, errors_1.message)('parserMalformedSymbolicAccessor'));
                 }
-                // A square scope is a candidate for indexing or implicit multiplication ONLY
-                // when the tokenizer flagged it with implicitMultiply (meaning '[' directly
-                // followed a non-operator/non-function token). Without that flag, the scope
-                // is a standalone vector literal (e.g. in matrix([1,0],[2,3]) where commas
-                // separate the square scopes).
-                else if (token.type === 'square' && token.implicitMultiply && lastOutput) {
-                    if ((0, structuredEntityUtils_1.isEnumerable)(lastOutput) ||
-                        IndexedReference_1.IndexedReference.isIndexedReference(lastOutput)) {
-                        // Indexing: target[indices]
-                        const resolvedTarget = IndexedReference_1.IndexedReference.isIndexedReference(lastOutput)
-                            ? lastOutput.resolve()
-                            : lastOutput;
-                        const previousRPN = rpn[i - 1];
-                        let targetName;
-                        if (Token_1.Token.isToken(previousRPN) &&
-                            previousRPN.type === Token_1.Token.VARIABLE &&
-                            !(values && previousRPN.value in values) &&
-                            previousRPN.value in this.KNOWN_VALUES) {
-                            targetName = previousRPN.value;
-                        }
-                        let indices;
-                        if (Dictionary_1.Dictionary.isDictionary(resolvedTarget)) {
-                            // Dictionary indexing: extract string keys from the index scope.
-                            // d[x] → key "x"
-                            const keys = this.extractStringKeys(token);
-                            indices = keys[0];
-                        }
-                        else {
-                            // Numeric indexing for Vector, Matrix, etc.
-                            indices = this.extractIndices(token, values, assertive);
-                        }
-                        output.pop();
-                        if (Array.isArray(indices) &&
-                            indices.length > 0 &&
-                            Expression_1.Expression.isExpression(indices[0])) {
-                            const symbolicIndices = indices;
-                            let symbolicTarget;
-                            if ((Vector_1.Vector.isVector(resolvedTarget) || Matrix_1.Matrix.isMatrix(resolvedTarget)) &&
-                                resolvedTarget.symbolicTarget) {
-                                symbolicTarget = resolvedTarget.symbolicTarget;
-                            }
-                            else if (Token_1.Token.isToken(previousRPN) &&
-                                previousRPN.type === Token_1.Token.VARIABLE) {
-                                symbolicTarget = Expression_1.Expression.Variable(previousRPN.value);
-                            }
-                            if (!symbolicTarget ||
-                                !(Vector_1.Vector.isVector(resolvedTarget) || Matrix_1.Matrix.isMatrix(resolvedTarget))) {
-                                throw new errors_1.ParserError('Symbolic indexed access requires a named Vector or Matrix target.');
-                            }
-                            if (Vector_1.Vector.isVector(resolvedTarget) && symbolicIndices.length !== 1) {
-                                throw new errors_1.ParserError('Symbolic Vector access requires exactly one index.');
-                            }
-                            if (Matrix_1.Matrix.isMatrix(resolvedTarget) && symbolicIndices.length !== 2) {
-                                if (symbolicIndices.length === 1) {
-                                    throw new errors_1.ParserError('Symbolic Matrix row access is not scalar and cannot be deferred as an Expression.');
-                                }
-                                throw new errors_1.ParserError('Symbolic Matrix cell access requires exactly two indices.');
-                            }
-                            addToOutput(resolvedTarget.withSymbolicAccessor(symbolicTarget, symbolicIndices));
-                        }
-                        else {
-                            addToOutput(new IndexedReference_1.IndexedReference(resolvedTarget, indices, targetName));
-                        }
-                    }
-                    else if (Expression_1.Expression.isExpression(lastOutput) && lastOutput.isPlainVariable()) {
-                        // An unresolved variable followed by symbolic indices cannot yet be
-                        // classified from runtime type information. Preserve the access in a
-                        // structured carrier; concrete bracket adjacency keeps its legacy
-                        // implicit-multiplication behavior.
-                        const indices = this.extractIndices(token, values, assertive);
-                        if (indices.length > 0 &&
-                            Expression_1.Expression.isExpression(indices[0])) {
-                            const symbolicIndices = indices;
-                            if (symbolicIndices.length > 2) {
-                                throw new errors_1.ParserError('Symbolic indexed access supports at most two unresolved indices.');
-                            }
-                            const carrier = symbolicIndices.length === 2 ? new Matrix_1.Matrix([]) : new Vector_1.Vector();
-                            output.pop();
-                            addToOutput(carrier.withSymbolicAccessor(lastOutput, symbolicIndices));
-                        }
-                        else if (Settings_1.Settings.ALLOW_IMPLICIT_MULTIPLICATION) {
-                            const indexExpr = this.parseRPN(token, values, assertive);
-                            const mulFn = functions_2._['multiply'];
-                            const a = resolveStackValue(output.pop());
-                            addToOutput(mulFn(a, indexExpr));
-                        }
-                        else {
-                            const parsed = this.parseRPN(token, values, assertive);
-                            addToOutput(parsed);
-                        }
+                const symbolicTarget = preservedArgs[0];
+                const resolvedTarget = resolvedArgs[0];
+                const symbolicIndices = [];
+                for (let j = 1; j < preservedArgs.length; j++) {
+                    if (!Expression_1.Expression.isExpression(preservedArgs[j])) {
+                        throw new errors_1.ParserError((0, errors_1.message)('parserMalformedSymbolicAccessorIndex'));
                     }
-                    else if (token.implicitMultiply && Settings_1.Settings.ALLOW_IMPLICIT_MULTIPLICATION) {
-                        // Implicit multiplication: x[1,2] where x is not a structured entity.
-                        const indexExpr = this.parseRPN(token, values, assertive);
-                        const mulFn = functions_2._['multiply'];
-                        const a = resolveStackValue(output.pop());
-                        addToOutput(mulFn(a, indexExpr));
-                    }
-                    else {
-                        const parsed = this.parseRPN(token, values, assertive);
-                        addToOutput(parsed);
+                    const resolvedIndex = resolvedArgs[j];
+                    if (!Expression_1.Expression.isExpression(resolvedIndex)) {
+                        throw new errors_1.ParserError((0, errors_1.message)('symbolicAccessIndexScalar'));
                     }
+                    symbolicIndices.push(resolvedIndex);
                 }
-                else {
-                    // Non-square scope or inside parentheses or nothing on output — parse normally
-                    const parsed = this.parseRPN(token, values, assertive);
-                    addToOutput(parsed);
-                }
+                return this.resolveSymbolicAccess(symbolicTarget, resolvedTarget, symbolicIndices);
             }
-            else {
-                if (token.type === Token_1.Token.OPERATOR) {
-                    // Grab the operator. The action will be defined by the operation property
-                    const operator = token.resolvedOperator ?? this.operators[token.value];
-                    // Get the last element on output
-                    let b = output.pop();
-                    let result;
-                    // Comma is the only operation that passes parser stack markers through unchanged.
-                    // This allows KeyValuePair markers to survive until the enclosing curly scope is
-                    // converted to a Dictionary.
-                    if (operator.action === 'comma') {
-                        const a = output.pop();
-                        const fn = functions_2._[operator.action];
-                        result = fn(a, b);
-                    }
-                    // If it's a postfix operator then the operation occurs only on the previous element
-                    else if (operator.isPostfix) {
-                        b = resolveStackValue(b);
-                        b = Expression_1.Expression.fromSymbolicAccess(b) ?? b;
-                        const fn = functions_2._[operator.action];
-                        result = fn(b);
-                    }
-                    else {
-                        let a = output.pop();
-                        const previousRPN = rpn[i - 1];
-                        const possibleFunction = rpn[i - 2];
-                        if (token.position === -1 &&
-                            operator.action === 'times' &&
-                            Scope_1.Scope.isScope(previousRPN) &&
-                            Collection_1.Collection.isCollection(b) &&
-                            Token_1.Token.isToken(possibleFunction) &&
-                            possibleFunction.type === Token_1.Token.VARIABLE &&
-                            Expression_1.Expression.isExpression(a) &&
-                            a.isPlainVariable()) {
-                            throw new errors_1.ParserError(`Unsupported function ${possibleFunction.value}`);
-                        }
-                        // Handle indexed assignment before ordinary left-hand resolution so the
-                        // reference itself remains available to the setter.
-                        if (operator.action === 'assign' &&
-                            IndexedReference_1.IndexedReference.isIndexedReference(a)) {
-                            b = resolveStackValue(b);
-                            if (typeof a.indices === 'string') {
-                                a.target.__set__(a.indices, b);
-                            }
-                            else {
-                                a.target.__set__(a.indices, b);
-                            }
-                            if (a.targetName) {
-                                this.KNOWN_VALUES[a.targetName] = a.target;
-                            }
-                            result = a.target;
-                        }
-                        else if (operator.deferRHSResolution) {
-                            a = resolveStackValue(a);
-                            if (typeof b !== 'function') {
-                                throw new errors_1.ParserError((0, errors_1.message)('malformedExpression'));
-                            }
-                            const fn = functions_2._[operator.action];
-                            result = fn(a, b);
-                        }
-                        else if (operator.deferLHSResolution) {
-                            a = resolveStackValue(a);
-                            b = resolveStackValue(b);
-                            const fn = functions_2._[operator.action];
-                            result = fn(a, b);
-                        }
-                        else if (operator.action === 'mapTo') {
-                            // '=>' operator: create a key-value pair for Dictionary construction
-                            // 'a' is the key (should be a variable name), 'b' is the value
-                            a = resolveStackValue(a);
-                            b = resolveStackValue(b);
-                            const key = Expression_1.Expression.isExpression(a) ? a.text() : String(a.text());
-                            result = new KeyValuePair_1.KeyValuePair(key, b);
+            if (dispatch_1.mathFunctionRegistry[token.value]?.deferArguments) {
+                const argumentScopes = [];
+                if (argsScope.length > 0) {
+                    let argumentScope = new Scope_1.Scope(argsScope.type, argsScope.column);
+                    for (const argumentToken of argsScope) {
+                        if (Token_1.Token.isToken(argumentToken) &&
+                            argumentToken.type === Token_1.Token.OPERATOR &&
+                            argumentToken.value === constants_1.COMMA) {
+                            argumentScopes.push(argumentScope);
+                            argumentScope = new Scope_1.Scope(argsScope.type, argsScope.column);
                         }
                         else {
-                            // Resolve concrete indexed references and normalize symbolic structured
-                            // access before ordinary scalar/aggregate operator routing.
-                            a = resolveStackValue(a);
-                            b = resolveStackValue(b);
-                            a = Expression_1.Expression.fromSymbolicAccess(a) ?? a;
-                            b = Expression_1.Expression.fromSymbolicAccess(b) ?? b;
-                            const action = assertive && operator.assertiveAction
-                                ? operator.assertiveAction
-                                : operator.action;
-                            const fn = functions_2._[action];
-                            if (a.isEnumerable ||
-                                b.isEnumerable ||
-                                Equation_1.Equation.isEquation(a) ||
-                                Equation_1.Equation.isEquation(b)) {
-                                // Delegate this to the router who can handle more
-                                result = (0, functions_2.route)(a, b, operator.action);
-                            }
-                            else {
-                                result = fn(a, b);
-                            }
+                            argumentScope.push(argumentToken);
                         }
                     }
-                    if (Array.isArray(result)) {
-                        addToOutput(result[0]);
-                        addToOutput(result[1]);
+                    argumentScopes.push(argumentScope);
+                }
+                const normalizeArguments = dispatch_1.mathFunctionRegistry[token.value].normalizeDeferredArguments;
+                const normalizedScopes = normalizeArguments
+                    ? normalizeArguments(argumentScopes)
+                    : argumentScopes;
+                const functionAssertive = common_1.ASSERTIVE_FUNCTIONS.includes(token.value);
+                const args = normalizedScopes.map(argumentScope => createDeferredArgument(() => this.toRPN(argumentScope), values, functionAssertive));
+                return (0, functions_2.callFunction)(token.value, args);
+            }
+            if (argsScope.deferLHSResolution) {
+                const args = argsScope.length > 0
+                    ? [...parseArguments(argsScope, undefined, assertive, false)]
+                    : [];
+                args.push(Expression_1.Expression.Variable(token.value));
+                return new Collection_1.Collection(args);
+            }
+            return (0, functions_2.callFunction)(token.value, parseArguments(argsScope, values, common_1.ASSERTIVE_FUNCTIONS.includes(token.value)));
+        };
+        const handleOperator = (token, index) => {
+            const operator = token.resolvedOperator ?? this.operators[token.value];
+            let b = output.pop();
+            if (operator.action === 'comma') {
+                addToOutput(b);
+                return undefined;
+            }
+            if (operator.isPostfix) {
+                b = resolveStackValue(b);
+                const fn = functions_2._[operator.action];
+                return fn(b);
+            }
+            let a = output.pop();
+            const previousRPN = rpn[index - 1];
+            const possibleFunction = rpn[index - 2];
+            if (token.position === -1 &&
+                operator.action === 'times' &&
+                Scope_1.Scope.isScope(previousRPN) &&
+                Collection_1.Collection.isCollection(b) &&
+                Token_1.Token.isToken(possibleFunction) &&
+                possibleFunction.type === Token_1.Token.VARIABLE &&
+                Expression_1.Expression.isExpression(a) &&
+                a.isPlainVariable()) {
+                throw new errors_1.ParserError((0, errors_1.message)('unsupportedFunction', { function: possibleFunction.value }));
+            }
+            if (operator.action === 'assign' && IndexedReference_1.IndexedReference.isIndexedReference(a)) {
+                let assignValue = true;
+                try {
+                    b = typeof b === 'function' ? b() : resolveStackValue(b);
+                }
+                catch (error) {
+                    if (controlFlowSignals_1.NullSignal.isNullSignal(error)) {
+                        assignValue = false;
                     }
                     else {
-                        addToOutput(result);
+                        throw error;
                     }
                 }
-                else if (token.type === Token_1.Token.FUNCTION) {
-                    // Get the next token and move along
-                    const argsScope = rpn[++i];
-                    if (token.value === constants_1.SYMBOLIC_ACCESSOR) {
-                        // Preserve the original target and index expressions while resolving the
-                        // same RPN scope under the active values. This avoids serializing either
-                        // side back through tokenize/toRPN just to apply substitutions.
-                        const preserved = (0, Settings_1.scopedBlock)('SUBSTITUTE', false, () => {
-                            return this.parseRPN(argsScope, undefined, assertive);
-                        });
-                        const preservedArgs = Collection_1.Collection.isCollection(preserved)
-                            ? preserved.getElements()
-                            : [preserved];
-                        const resolved = this.parseRPN(argsScope, values, assertive);
-                        const resolvedArgs = Collection_1.Collection.isCollection(resolved)
-                            ? resolved.getElements()
-                            : [resolved];
-                        if (preservedArgs.length < 2 ||
-                            preservedArgs.length !== resolvedArgs.length ||
-                            !Expression_1.Expression.isExpression(preservedArgs[0]) ||
-                            !preservedArgs[0].isPlainVariable()) {
-                            throw new errors_1.ParserError('Malformed internal symbolic accessor.');
-                        }
-                        const symbolicTarget = preservedArgs[0];
-                        const resolvedTarget = resolvedArgs[0];
-                        const symbolicIndices = [];
-                        const numericIndices = [];
-                        let allResolved = true;
-                        for (let j = 1; j < preservedArgs.length; j++) {
-                            const preservedIndex = preservedArgs[j];
-                            const resolvedIndex = resolvedArgs[j];
-                            if (!Expression_1.Expression.isExpression(preservedIndex)) {
-                                throw new errors_1.ParserError('Malformed internal symbolic accessor index.');
-                            }
-                            if (!Expression_1.Expression.isExpression(resolvedIndex)) {
-                                throw new errors_1.ParserError('Symbolic accessor indices must evaluate to scalar expressions.');
-                            }
-                            symbolicIndices.push(resolvedIndex);
-                            const numericIndex = Number(resolvedIndex.text());
-                            if (Number.isFinite(numericIndex)) {
-                                numericIndices.push(numericIndex - Settings_1.Settings.INDEX_BASE);
-                            }
-                            else {
-                                allResolved = false;
-                            }
-                        }
-                        if (symbolicIndices.length > 2) {
-                            throw new errors_1.ParserError('Symbolic indexed access supports at most two unresolved indices.');
-                        }
-                        if (Vector_1.Vector.isVector(resolvedTarget) && symbolicIndices.length !== 1) {
-                            throw new errors_1.ParserError('Symbolic Vector access requires exactly one index.');
-                        }
-                        if (Matrix_1.Matrix.isMatrix(resolvedTarget) && symbolicIndices.length !== 2) {
-                            if (symbolicIndices.length === 1) {
-                                throw new errors_1.ParserError('Symbolic Matrix row access is not scalar and cannot be deferred as an Expression.');
-                            }
-                            throw new errors_1.ParserError('Symbolic Matrix cell access requires exactly two indices.');
-                        }
-                        let result;
-                        if ((Vector_1.Vector.isVector(resolvedTarget) || Matrix_1.Matrix.isMatrix(resolvedTarget)) && allResolved) {
-                            result = resolvedTarget.__get__(numericIndices);
-                        }
-                        else {
-                            let carrier;
-                            if (Vector_1.Vector.isVector(resolvedTarget) || Matrix_1.Matrix.isMatrix(resolvedTarget)) {
-                                carrier = resolvedTarget;
-                            }
-                            else if (Expression_1.Expression.isExpression(resolvedTarget) &&
-                                resolvedTarget.isPlainVariable()) {
-                                carrier = symbolicIndices.length === 2 ? new Matrix_1.Matrix([]) : new Vector_1.Vector();
-                            }
-                            else {
-                                throw new errors_1.ParserError('Symbolic indexed access target must resolve to a Vector or Matrix.');
-                            }
-                            result = carrier.withSymbolicAccessor(symbolicTarget, symbolicIndices);
-                        }
-                        addToOutput(result);
+                if (assignValue) {
+                    a.set(b);
+                    if (a.targetName) {
+                        this.KNOWN_VALUES[a.targetName] = a.target;
                     }
-                    else if (dispatch_1.mathFunctionRegistry[token.value]?.deferArguments) {
-                        // Deferred functions receive callable arguments and decide when, whether, and how
-                        // often each argument is evaluated.
-                        const argumentScopes = [];
-                        if (argsScope.length > 0) {
-                            let argumentScope = new Scope_1.Scope(argsScope.type, argsScope.column);
-                            for (const argumentToken of argsScope) {
-                                if (Token_1.Token.isToken(argumentToken) &&
-                                    argumentToken.type === Token_1.Token.OPERATOR &&
-                                    argumentToken.value === constants_1.COMMA) {
-                                    argumentScopes.push(argumentScope);
-                                    argumentScope = new Scope_1.Scope(argsScope.type, argsScope.column);
-                                }
-                                else {
-                                    argumentScope.push(argumentToken);
-                                }
-                            }
-                            argumentScopes.push(argumentScope);
-                        }
-                        const normalizeArguments = dispatch_1.mathFunctionRegistry[token.value].normalizeDeferredArguments;
-                        const normalizedScopes = normalizeArguments
-                            ? normalizeArguments(argumentScopes)
-                            : argumentScopes;
-                        const functionAssertive = common_1.ASSERTIVE_FUNCTIONS.includes(token.value);
-                        const args = normalizedScopes.map(argumentScope => {
-                            return createDeferredArgument(() => this.toRPN(argumentScope), values, functionAssertive);
-                        });
-                        const result = (0, functions_2.callFunction)(token.value, args);
-                        addToOutput(result);
+                }
+                return a.target;
+            }
+            if (operator.deferRHSResolution) {
+                a = resolveStackValue(a);
+                if (typeof b !== 'function') {
+                    throw new errors_1.ParserError((0, errors_1.message)('malformedExpression'));
+                }
+                const fn = functions_2._[operator.action];
+                return fn(a, b);
+            }
+            a = resolveStackValue(a);
+            b = resolveStackValue(b);
+            if (operator.action === 'mapTo') {
+                return new KeyValuePair_1.KeyValuePair(a.text(), b);
+            }
+            const action = assertive && operator.assertiveAction
+                ? operator.assertiveAction
+                : operator.action;
+            const fn = functions_2._[action];
+            if (a.isEnumerable ||
+                b.isEnumerable ||
+                Equation_1.Equation.isEquation(a) ||
+                Equation_1.Equation.isEquation(b)) {
+                return (0, functions_2.route)(a, b, operator.action);
+            }
+            return fn(a, b);
+        };
+        const handleScope = (token, index) => {
+            const lastOutput = output[output.length - 1];
+            if (token.deferRHSResolution) {
+                addToOutput(createDeferredArgument(() => token, values, assertive));
+                return;
+            }
+            if (token.type === 'square' && token.implicitMultiply && lastOutput) {
+                if ((0, structuredEntityUtils_1.isEnumerable)(lastOutput) ||
+                    IndexedReference_1.IndexedReference.isIndexedReference(lastOutput)) {
+                    const resolvedTarget = IndexedReference_1.IndexedReference.isIndexedReference(lastOutput)
+                        ? lastOutput.resolve()
+                        : lastOutput;
+                    const previousRPN = rpn[index - 1];
+                    let targetName;
+                    if (Token_1.Token.isToken(previousRPN) &&
+                        previousRPN.type === Token_1.Token.VARIABLE &&
+                        !(values && previousRPN.value in values) &&
+                        previousRPN.value in this.KNOWN_VALUES) {
+                        targetName = previousRPN.value;
                     }
-                    else if (argsScope.deferLHSResolution) {
-                        let args = [];
-                        if (argsScope.length > 0) {
-                            const parsed = (0, Settings_1.scopedBlock)('SUBSTITUTE', false, () => {
-                                return this.parseRPN(argsScope, undefined, assertive);
-                            });
-                            args = Collection_1.Collection.isCollection(parsed) ? [...parsed.getElements()] : [parsed];
+                    const indices = Dictionary_1.Dictionary.isDictionary(resolvedTarget)
+                        ? this.extractDictionaryKey(token, values, assertive)
+                        : this.extractIndices(token, values, assertive);
+                    output.pop();
+                    if (Array.isArray(indices) &&
+                        indices.length > 0 &&
+                        Expression_1.Expression.isExpression(indices[0])) {
+                        const symbolicIndices = indices;
+                        if (!Token_1.Token.isToken(previousRPN) ||
+                            previousRPN.type !== Token_1.Token.VARIABLE ||
+                            !(Vector_1.Vector.isVector(resolvedTarget) || Matrix_1.Matrix.isMatrix(resolvedTarget))) {
+                            throw new errors_1.ParserError((0, errors_1.message)('symbolicAccessNamedTargetRequired'));
                         }
-                        // Preserve the scoped values followed by their left-hand target. The operator
-                        // action is responsible for interpreting that structure.
-                        args.push(Expression_1.Expression.Variable(token.value));
-                        addToOutput(new Collection_1.Collection(args));
+                        addToOutput(this.resolveSymbolicAccess(Expression_1.Expression.Variable(previousRPN.value), resolvedTarget, symbolicIndices));
                     }
                     else {
-                        // Parse it as an argument. If the value is of the token is an assertive function then parseRPN needs to
-                        // know so it can modify it's behavior accordingly. This would be in the case of functions like assume where
-                        // the operators assert a value rather than compare it.
-                        const parsed = this.parseRPN(argsScope, values, common_1.ASSERTIVE_FUNCTIONS.includes(token.value));
-                        const args = Collection_1.Collection.isCollection(parsed) ? parsed.getElements() : [parsed];
-                        const result = (0, functions_2.callFunction)(token.value, args);
-                        addToOutput(result);
+                        addToOutput(new IndexedReference_1.IndexedReference(resolvedTarget, indices, targetName));
                     }
+                    return;
                 }
-                else if (token.type === Token_1.Token.PREFIX) {
-                    const resolved = resolveStackValue(output.pop());
-                    const e = Expression_1.Expression.fromSymbolicAccess(resolved) ?? resolved;
-                    const prefixAction = `${operators[token.value].action}Prefix`;
-                    const fn = functions_2._[prefixAction];
-                    // TODO: Rethink. What happens when a prefix is applied to a vector
-                    addToOutput(fn(e));
+                if (Expression_1.Expression.isExpression(lastOutput) && lastOutput.isPlainVariable()) {
+                    const indices = this.extractIndices(token, values, assertive);
+                    if (indices.length > 0 &&
+                        Expression_1.Expression.isExpression(indices[0])) {
+                        output.pop();
+                        addToOutput(this.resolveSymbolicAccess(lastOutput, lastOutput, indices));
+                        return;
+                    }
+                }
+                const parsed = parseScope(token, values, assertive);
+                if (Settings_1.Settings.ALLOW_IMPLICIT_MULTIPLICATION) {
+                    const mulFn = functions_2._['multiply'];
+                    addToOutput(mulFn(resolveStackValue(output.pop()), parsed));
                 }
                 else {
-                    let expression;
-                    const constant = this.CONSTANTS[token.value];
-                    // User-defined constants are stored as strings and substitute during ordinary parsing.
-                    // They take precedence over scoped values, matching the public setConstant method.
-                    if (typeof constant === 'string') {
-                        expression = this.parse(constant);
-                    }
-                    // Substitute values from the values object. A number is not considered a proper LH value.
-                    else if (values && token.value in values && !token.is(Token_1.Token.NUMBER)) {
-                        // expression = this.parse(String(values[token.value]), values);
-                        const scopedValue = values[token.value];
-                        if (Expression_1.Expression.isExpression(scopedValue) ||
-                            Equation_1.Equation.isEquation(scopedValue) ||
-                            (0, structuredEntityUtils_1.isEnumerable)(scopedValue)) {
-                            expression = scopedValue.copy();
-                        }
-                        else {
-                            expression = Expression_1.Expression.create(scopedValue, undefined, true);
-                        }
-                    }
-                    else if (token.value in this.KNOWN_VALUES && Settings_1.Settings.SUBSTITUTE) {
-                        expression = this.KNOWN_VALUES[token.value].copy();
-                    }
-                    // Built-in constants are factories so they evaluate at the active precision.
-                    else if (Settings_1.Settings.EVALUATE && typeof constant === 'function') {
-                        expression = this.parse(constant(), values);
-                    }
-                    else {
-                        // At this point the expression type is variable or a number
-                        switch (token.type) {
-                            case Token_1.Token.FUNCTION:
-                                expression = Expression_1.Expression.Function(token.value);
-                                break;
-                            case Token_1.Token.VARIABLE:
-                                if (constants_1.INFINITY.includes(token.value)) {
-                                    expression = Expression_1.Expression.Inf();
-                                }
-                                else {
-                                    expression = Expression_1.Expression.Variable(token.value);
-                                }
-                                break;
-                            default:
-                                expression = Expression_1.Expression.Number(token.value);
-                                break;
-                        }
-                    }
-                    // Add it to output
-                    addToOutput(expression);
+                    addToOutput(parsed);
+                }
+                return;
+            }
+            addToOutput(token.deferLHSResolution
+                ? parseScope(token, undefined, assertive, false)
+                : parseScope(token, values, assertive));
+        };
+        const resolveToken = (token) => {
+            const constant = this.CONSTANTS[token.value];
+            // User-defined constants take precedence over scoped values.
+            if (typeof constant === 'string') {
+                return this.parse(constant);
+            }
+            if (values && token.value in values && !token.is(Token_1.Token.NUMBER)) {
+                const scopedValue = values[token.value];
+                if (Expression_1.Expression.isExpression(scopedValue) ||
+                    Equation_1.Equation.isEquation(scopedValue) ||
+                    (0, structuredEntityUtils_1.isEnumerable)(scopedValue)) {
+                    return scopedValue.copy();
                 }
+                return Expression_1.Expression.create(scopedValue, undefined, true);
+            }
+            if (token.value in this.KNOWN_VALUES && Settings_1.Settings.SUBSTITUTE) {
+                return this.KNOWN_VALUES[token.value].copy();
+            }
+            // Built-in constants are factories so they evaluate at the active precision.
+            if (Settings_1.Settings.EVALUATE && typeof constant === 'function') {
+                return this.parse(constant(), values);
+            }
+            if (token.type === Token_1.Token.FUNCTION) {
+                return Expression_1.Expression.Function(token.value);
+            }
+            if (token.type === Token_1.Token.VARIABLE) {
+                return constants_1.INFINITY.includes(token.value)
+                    ? Expression_1.Expression.Inf()
+                    : Expression_1.Expression.Variable(token.value);
+            }
+            return Expression_1.Expression.Number(token.value);
+        };
+        const handlePrefix = (token) => {
+            const value = resolveStackValue(output.pop());
+            const prefixAction = `${operators[token.value].action}Prefix`;
+            const fn = functions_2._[prefixAction];
+            return fn(value);
+        };
+        for (let i = 0; i < rpn.length; i++) {
+            const token = rpn[i];
+            if (Scope_1.Scope.isScope(token)) {
+                handleScope(token, i);
+                continue;
+            }
+            if (token.type === Token_1.Token.OPERATOR) {
+                const result = handleOperator(token, i);
+                if (result !== undefined) {
+                    addToOutput(result);
+                }
+            }
+            else if (token.type === Token_1.Token.FUNCTION) {
+                addToOutput(handleFunction(token, rpn[++i]));
+            }
+            else if (token.type === Token_1.Token.PREFIX) {
+                addToOutput(handlePrefix(token));
+            }
+            else {
+                addToOutput(resolveToken(token));
             }
         }
         let retval;
-        // Since as function args can have multiple arguments in the output
-        // the entire array gets returned. We do the same with
         if (rpn.type === 'square') {
             retval = new Vector_1.Vector(resolveStackValues(output));
         }
         else if (rpn.type === 'curly') {
-            // If the output contains KeyValuePairs (from '=>' operators), build a Dictionary.
-            // Otherwise build a ValuesSet as before.
             if (output.length > 0 && KeyValuePair_1.KeyValuePair.isKeyValuePair(output[0])) {
                 const dict = new Dictionary_1.Dictionary();
                 for (const item of output) {
-                    if (KeyValuePair_1.KeyValuePair.isKeyValuePair(item)) {
-                        dict.set(item.key, item.value);
-                    }
+                    dict.set(item.key, item.value);
                 }
                 retval = dict;
             }
@@ -1234,7 +1133,7 @@ class ExpressionParser {
             functions_2._[operator.action] = action;
         }
         else if (!functions_2._[operator.action]) {
-            throw new errors_1.ParserError(`Unknown operator action ${operator.action}`);
+            throw new errors_1.ParserError((0, errors_1.message)('unknownOperatorAction', { action: operator.action }));
         }
         this.operators[operator.operator] = operator;
         (0, Token_1.refreshOperatorSymbols)();
@@ -1350,13 +1249,19 @@ class ExpressionParser {
             // Get the character type for comparison. Search for changes in the character type to determine
             // the end of a token.
             const charType = Token_1.Token.getCharType(ch, col, tokenBuffer);
+            if (charType === Token_1.Token.CHARACTER && ch !== terminator) {
+                throw new errors_1.UnexpectedTokenError((0, errors_1.message)('unsupportedCharacter', {
+                    character: ch,
+                    position: String(col),
+                }));
+            }
             // Brackets point to a new scope. Once one is encountered, update the target and point to the new scope
             // Subsequent tokens are now pushed to that scope
             if (tokenBuffer.is(Token_1.Token.BRACKET)) {
                 // Get the bracket.
                 const bracketCharacter = tokenBuffer.last();
                 if (bracketCharacter === undefined) {
-                    throw new errors_1.ParserError('Bracket token is missing its character.');
+                    throw new errors_1.ParserError((0, errors_1.message)('parserBracketTokenMissingCharacter'));
                 }
                 const bracket = common_1.brackets[bracketCharacter];
                 if (bracket.isOpen) {
@@ -1391,7 +1296,7 @@ class ExpressionParser {
                             }
                         }
                         else {
-                            throw new errors_1.UnexpectedTokenError(`Expected operator or function name but "${lastToken.value}" found!`);
+                            throw new errors_1.UnexpectedTokenError((0, errors_1.message)('expectedOperatorOrFunction', { value: lastToken.value }));
                         }
                     }
                     // Go down in scope to the new bracket
@@ -1433,7 +1338,10 @@ class ExpressionParser {
                     scope = scope.upperScope();
                     // If there's not scope or the types don't match then we have a mismatched bracket
                     if (scope === undefined || !bracketsMatch) {
-                        throw new errors_1.UnexpectedTokenError(`Missing opening bracket for "${tokenBuffer.last()}":${col}`);
+                        throw new errors_1.UnexpectedTokenError((0, errors_1.message)('missingOpeningBracket', {
+                            bracket: String(tokenBuffer.last()),
+                            position: String(col),
+                        }));
                     }
                 }
                 // Discard the bracket since it's no longer needed
@@ -1507,7 +1415,9 @@ class ExpressionParser {
                             }
                         }
                         else {
-                            throw new errors_1.UnexpectedTokenError(`Expected operator or function name but "${lastToken.value}" found!`);
+                            throw new errors_1.UnexpectedTokenError((0, errors_1.message)('expectedOperatorOrFunction', {
+                                value: lastToken.value,
+                            }));
                         }
                     }
                     // Allows for each single letter in a variable to be treated like an individual variable
@@ -1538,7 +1448,10 @@ class ExpressionParser {
         // If the last item in the tokens array is a scope and it has a parent then it's missing a closing bracket
         const lastItem = tokens[tokens.length - 1];
         if (Scope_1.Scope.isScope(lastItem) && lastItem.isOpen) {
-            throw new errors_1.UnexpectedTokenError(`Missing closing bracket for "${str.charAt(lastItem.column - 1)}":${lastItem.column}`);
+            throw new errors_1.UnexpectedTokenError((0, errors_1.message)('missingClosingBracket', {
+                bracket: str.charAt(lastItem.column - 1),
+                position: String(lastItem.column),
+            }));
         }
         return tokens;
     }
@@ -1670,7 +1583,7 @@ class ExpressionParser {
                             }
                             // If the encountered operator is not a prefix then complain
                             if (!this.operators[prefixOperator.value].isPrefix) {
-                                throw new errors_1.ParserError(`Prefix operator expected but ${prefixOperator.value} encountered.`);
+                                throw new errors_1.ParserError((0, errors_1.message)('prefixOperatorExpected', { operator: prefixOperator.value }));
                             }
                             // We mark it so the next time it's encountered, it's placed to output immediately
                             prefixOperator.type = Token_1.Token.PREFIX;