nerdamer 1.1.13 → 2.0.0-rc.2

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadScriptingFunctions = loadScriptingFunctions;
+const dispatch_1 = require("../../../dispatch");
+const controlFlow_1 = require("./controlFlow");
+const deferred_1 = require("./deferred");
+const evaluate_1 = require("./evaluate");
+const scope_1 = require("./scope");
+function loadScriptingFunctions() {
+    Object.assign(dispatch_1.mathFunctionRegistry, {
+        unassign: (0, dispatch_1.systemFunction)({ fn: scope_1.unassign, minArgs: 1, maxArgs: 1, distElWise: false, deferArguments: true }),
+        evaluate: (0, dispatch_1.systemFunction)({
+            fn: evaluate_1.evaluate,
+            minArgs: 1,
+            maxArgs: 3,
+            equationArgs: [0],
+            distElWise: false,
+            deferArguments: true,
+            usage: 'scripting',
+        }),
+        return: (0, dispatch_1.systemFunction)({
+            fn: controlFlow_1.RETURN,
+            minArgs: 1,
+            maxArgs: 1,
+            equationArgs: [0],
+            distElWise: false,
+            bracketlessStatement: true,
+            usage: 'scripting',
+        }),
+        break: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.BREAK, minArgs: 0, maxArgs: 0, distElWise: false, usage: 'scripting' }),
+        continue: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.CONTINUE, minArgs: 0, maxArgs: 0, distElWise: false, usage: 'scripting' }),
+        and: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.AND, minArgs: 2, maxArgs: -1, distElWise: false, deferArguments: true, usage: 'scripting' }),
+        or: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.OR, minArgs: 2, maxArgs: -1, distElWise: false, deferArguments: true, usage: 'scripting' }),
+        not: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.NOT, minArgs: 1, maxArgs: 1, distElWise: false, usage: 'scripting' }),
+        xor: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.XOR, minArgs: 2, maxArgs: -1, distElWise: false, usage: 'scripting' }),
+        iferror: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.IFERROR, minArgs: 2, maxArgs: 2, distElWise: false, deferArguments: true, usage: 'scripting' }),
+        iserror: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.ISERROR, minArgs: 1, maxArgs: 1, distElWise: false, deferArguments: true, usage: 'scripting' }),
+        if: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.IF, minArgs: 2, maxArgs: 3, distElWise: false, deferArguments: true, returnBoundary: true, usage: 'scripting' }),
+        while: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.WHILE, minArgs: 2, maxArgs: 2, distElWise: false, deferArguments: true, returnBoundary: true, usage: 'scripting' }),
+        for: (0, dispatch_1.systemFunction)({ fn: controlFlow_1.FOR, minArgs: 4, maxArgs: 4, distElWise: false, deferArguments: true, returnBoundary: true, usage: 'scripting' }),
+        each: (0, dispatch_1.systemFunction)({ fn: deferred_1.each, minArgs: 3, maxArgs: 4, distElWise: false, deferArguments: true, usage: 'scripting' }),
+        let: (0, dispatch_1.systemFunction)({
+            fn: scope_1.LET,
+            minArgs: 3,
+            maxArgs: -1,
+            distElWise: false,
+            deferArguments: true,
+            normalizeDeferredArguments: scope_1.normalizeLetArguments,
+            returnBoundary: true,
+            usage: 'scripting',
+        }),
+        block: (0, dispatch_1.systemFunction)({
+            fn: controlFlow_1.BLOCK,
+            minArgs: -1,
+            maxArgs: -1,
+            distElWise: false,
+            deferArguments: true,
+            returnBoundary: true,
+            usage: 'scripting',
+        }),
+    });
+}

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

@@ -0,0 +1,23 @@
+import type { ParserEntity } from '../../../types';
+import type { DeferredFunctionArgument } from '../types';
+/**
+ * Evaluates a deferred parser value and returns the resolved input if evaluation cannot complete.
+ *
+ * @remarks
+ * A Dictionary supplied as the second argument provides substitutions for this evaluation only.
+ * Those names are passed through the same call-scoped parser-value mechanism used by
+ * `Parser.parse(..., values)`; they are not written to the parser's known-value table.
+ *
+ * This distinction matters for reserved names. The solver index `_n` cannot be assigned
+ * globally with `_n: value`, but it can be supplied locally when evaluating a parametric
+ * `SolutionSet`. For example, `evaluate(solve(sin(x),x),{_n=>0})` returns `{0}`.
+ *
+ * When a solver result is stored first in Nerdamer Scripting, use `:` for assignment:
+ * `sol: solve(sin(x),x); evaluate(sol,{_n=>0})`. The `=` operator denotes an equation;
+ * it does not store a parser value in a variable.
+ */
+export declare function evaluate(value: DeferredFunctionArgument, substitutions?: DeferredFunctionArgument, point?: DeferredFunctionArgument): ParserEntity;
+/**
+ * Evaluates a parser value numerically at a finite significant-digit precision.
+ */
+export declare function numeric(value: DeferredFunctionArgument, precision?: DeferredFunctionArgument): ParserEntity;

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

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluate = evaluate;
+exports.numeric = numeric;
+const math_1 = require("../../../../math/math");
+const errors_1 = require("../../../errors");
+const Collection_1 = require("../../collection/Collection");
+const Dictionary_1 = require("../../dictionary/Dictionary");
+const Equation_1 = require("../../equation/Equation");
+const Expression_1 = require("../../expression/Expression");
+const utils_1 = require("../../expression/utils");
+const Matrix_1 = require("../../matrix/Matrix");
+const ValuesSet_1 = require("../../valuesSet/ValuesSet");
+const Vector_1 = require("../../vector/Vector");
+const constants_1 = require("../constants");
+const EVALUATE_FUNCTION = 'evaluate';
+/**
+ * Evaluates a deferred parser value and returns the resolved input if evaluation cannot complete.
+ *
+ * @remarks
+ * A Dictionary supplied as the second argument provides substitutions for this evaluation only.
+ * Those names are passed through the same call-scoped parser-value mechanism used by
+ * `Parser.parse(..., values)`; they are not written to the parser's known-value table.
+ *
+ * This distinction matters for reserved names. The solver index `_n` cannot be assigned
+ * globally with `_n: value`, but it can be supplied locally when evaluating a parametric
+ * `SolutionSet`. For example, `evaluate(solve(sin(x),x),{_n=>0})` returns `{0}`.
+ *
+ * When a solver result is stored first in Nerdamer Scripting, use `:` for assignment:
+ * `sol: solve(sin(x),x); evaluate(sol,{_n=>0})`. The `=` operator denotes an equation;
+ * it does not store a parser value in a variable.
+ */
+function evaluate(value, substitutions, point) {
+    const input = value();
+    let values;
+    if (substitutions) {
+        const resolved = substitutions();
+        values = {};
+        if (point) {
+            const resolvedPoint = point();
+            if (!Vector_1.Vector.isVector(resolved)) {
+                throw new errors_1.UnexpectedDataType((0, errors_1.message)('vectorExpected', { type: constants_1.dataTypes[resolved.dataType] }));
+            }
+            if (!Vector_1.Vector.isVector(resolvedPoint)) {
+                throw new errors_1.UnexpectedDataType((0, errors_1.message)('vectorExpected', { type: constants_1.dataTypes[resolvedPoint.dataType] }));
+            }
+            if (resolved.count() !== resolvedPoint.count()) {
+                throw new errors_1.DimensionError((0, errors_1.message)('mismatchedDimensions', { function: EVALUATE_FUNCTION }));
+            }
+            for (let i = 0; i < resolved.count(); i++) {
+                const variable = resolved.elements[i];
+                if (!Expression_1.Expression.isExpression(variable)) {
+                    throw new errors_1.UnexpectedDataType((0, errors_1.message)('expressionExpected', { type: constants_1.dataTypes[variable.dataType] }));
+                }
+                values[(0, utils_1.assertPlainVariableAndGetString)(variable)] = resolvedPoint.elements[i];
+            }
+        }
+        else {
+            if (!Dictionary_1.Dictionary.isDictionary(resolved)) {
+                throw new errors_1.UnexpectedDataType((0, errors_1.message)('unsupportedType', { type: constants_1.dataTypes[resolved.dataType] }));
+            }
+            for (const [name, substitution] of resolved) {
+                values[name] = substitution;
+            }
+        }
+    }
+    let retval = input;
+    try {
+        if (values &&
+            (Expression_1.Expression.isExpression(input) ||
+                Vector_1.Vector.isVector(input) ||
+                Matrix_1.Matrix.isMatrix(input) ||
+                ValuesSet_1.ValuesSet.isValuesSet(input))) {
+            retval = input.evaluate(values);
+        }
+        else {
+            retval = input.evaluate();
+        }
+    }
+    catch {
+        retval = input;
+    }
+    return retval;
+}
+function applyNumeric(value, precision) {
+    let retval;
+    if (Expression_1.Expression.isExpression(value)) {
+        retval = (0, math_1.numeric)(value, precision);
+    }
+    else if (Equation_1.Equation.isEquation(value)) {
+        retval = value.copy().each(e => Expression_1.Expression.isExpression(e) ? (0, math_1.numeric)(e, precision) : e);
+    }
+    else if (Vector_1.Vector.isVector(value)) {
+        retval = value.copy().each(e => applyNumeric(e, precision));
+    }
+    else if (Matrix_1.Matrix.isMatrix(value)) {
+        retval = value.copy().each(e => (0, math_1.numeric)(e, precision));
+    }
+    else if (Collection_1.Collection.isCollection(value)) {
+        retval = value.copy().each(e => applyNumeric(e, precision));
+    }
+    else if (Dictionary_1.Dictionary.isDictionary(value)) {
+        retval = value.copy().each(e => applyNumeric(e, precision));
+    }
+    else if (ValuesSet_1.ValuesSet.isValuesSet(value)) {
+        retval = value.copy().each(e => applyNumeric(e, precision));
+    }
+    else {
+        retval = value;
+    }
+    return retval;
+}
+/**
+ * Evaluates a parser value numerically at a finite significant-digit precision.
+ */
+function numeric(value, precision) {
+    const input = value();
+    let digits;
+    if (precision) {
+        const resolved = precision();
+        if (!Expression_1.Expression.isExpression(resolved)) {
+            throw new errors_1.UnexpectedDataType((0, errors_1.message)('expressionExpected', { type: constants_1.dataTypes[resolved.dataType] }));
+        }
+        digits = resolved;
+    }
+    const retval = applyNumeric(input, digits);
+    return retval;
+}

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

@@ -0,0 +1,14 @@
+import type { ParserEntity } from '../../../types';
+import type { DeferredFunctionArgument } from '../types';
+/**
+ * Evaluates a symbolic user-function body with call-scoped argument bindings.
+ *
+ * Arguments temporarily shadow parser known values so ordinary assignment can update a
+ * function parameter during the call. Previous bindings are restored afterward, including
+ * when RETURN or another error unwinds evaluation. A string body is parsed per invocation;
+ * a deferred parser body reuses its compiled RPN while still resolving current parameter and
+ * known-value state. RETURN is consumed at the function boundary so its parser entity becomes
+ * the function result and cannot escape into the caller. BREAK and CONTINUE are also rejected
+ * at that boundary so loop control cannot cross a function call.
+ */
+export declare function wrappedFunction(expression: string | DeferredFunctionArgument, argList: string[]): (...inputs: ParserEntity[]) => ParserEntity;

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrappedFunction = wrappedFunction;
+const Parser_1 = require("../Parser");
+const controlFlow_1 = require("./controlFlow");
+/**
+ * Evaluates a symbolic user-function body with call-scoped argument bindings.
+ *
+ * Arguments temporarily shadow parser known values so ordinary assignment can update a
+ * function parameter during the call. Previous bindings are restored afterward, including
+ * when RETURN or another error unwinds evaluation. A string body is parsed per invocation;
+ * a deferred parser body reuses its compiled RPN while still resolving current parameter and
+ * known-value state. RETURN is consumed at the function boundary so its parser entity becomes
+ * the function result and cannot escape into the caller. BREAK and CONTINUE are also rejected
+ * at that boundary so loop control cannot cross a function call.
+ */
+function wrappedFunction(expression, argList) {
+    return (...inputs) => {
+        const previousValues = new Map();
+        const previouslyUndefined = new Set();
+        for (let i = 0; i < argList.length; i++) {
+            const name = argList[i];
+            if (!previousValues.has(name) && !previouslyUndefined.has(name)) {
+                if (Object.prototype.hasOwnProperty.call(Parser_1.Parser.KNOWN_VALUES, name)) {
+                    previousValues.set(name, Parser_1.Parser.KNOWN_VALUES[name]);
+                }
+                else {
+                    previouslyUndefined.add(name);
+                }
+            }
+            Parser_1.Parser.KNOWN_VALUES[name] = inputs[i];
+        }
+        let retval;
+        try {
+            retval = (0, controlFlow_1.functionBoundary)(() => {
+                let result;
+                if (typeof expression === 'string') {
+                    result = Parser_1.Parser.parse(expression);
+                }
+                else {
+                    // Function declarations should not capture temporary Parser.parse(..., values)
+                    // substitutions from registration. Parameter and persistent known values are
+                    // resolved from the current call instead.
+                    result = expression({ inheritValues: false });
+                }
+                return result;
+            });
+        }
+        finally {
+            for (const [name, value] of previousValues) {
+                Parser_1.Parser.KNOWN_VALUES[name] = value;
+            }
+            for (const name of previouslyUndefined) {
+                delete Parser_1.Parser.KNOWN_VALUES[name];
+            }
+        }
+        return retval;
+    };
+}

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

@@ -0,0 +1,8 @@
+import { Scope } from '../../../common/classes/Scope';
+import { Expression } from '../../expression/Expression';
+import type { ExpressionInput, ParserEntity } from '../../../types';
+import type { DeferredFunctionArgument } from '../types';
+export declare function assign(a: ExpressionInput, b: ParserEntity | string | DeferredFunctionArgument): ParserEntity;
+export declare function normalizeLetArguments(argumentScopes: Scope[]): Scope[];
+export declare function LET(...args: DeferredFunctionArgument[]): ParserEntity;
+export declare function unassign(x: Expression | string | DeferredFunctionArgument): Expression;

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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assign = assign;
+exports.normalizeLetArguments = normalizeLetArguments;
+exports.LET = LET;
+exports.unassign = unassign;
+const Scope_1 = require("../../../common/classes/Scope");
+const errors_1 = require("../../../errors");
+const Settings_1 = require("../../../Settings");
+const Expression_1 = require("../../expression/Expression");
+const utils_1 = require("../../expression/utils");
+const constants_1 = require("../constants");
+const controlFlowSignals_1 = require("../controlFlowSignals");
+const Parser_1 = require("../Parser");
+const Token_1 = require("../Token");
+const controlFlow_1 = require("./controlFlow");
+function assign(a, b) {
+    a = Expression_1.Expression.create(a);
+    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))
+        throw new errors_1.AssignmentError((0, errors_1.message)('restrictedVariableName', { name: a.value }));
+    let value;
+    try {
+        if (typeof b === 'function')
+            value = b();
+        else if (typeof b === 'string')
+            value = Parser_1.Parser.parse(b);
+        else
+            value = b;
+    }
+    catch (error) {
+        if (controlFlowSignals_1.NullSignal.isNullSignal(error)) {
+            // A no-result RHS is assignment's one special case. It is equivalent to x:x:
+            // preserve an existing binding, or leave an unbound name unresolved.
+            return Parser_1.Parser.KNOWN_VALUES[a.value]?.copy() ?? a;
+        }
+        throw error;
+    }
+    Parser_1.Parser.KNOWN_VALUES[a.value] = value;
+    return value;
+}
+function normalizeLetArguments(argumentScopes) {
+    const normalizedScopes = [];
+    for (let i = 0; i < argumentScopes.length; i++) {
+        const argumentScope = argumentScopes[i];
+        let assignmentIndex = -1;
+        if (i < argumentScopes.length - 1) {
+            for (let j = 0; j < argumentScope.length; j++) {
+                const argumentToken = argumentScope[j];
+                if (Token_1.Token.isToken(argumentToken) && argumentToken.type === Token_1.Token.OPERATOR && argumentToken.value === constants_1.ASSIGN) {
+                    assignmentIndex = j;
+                    break;
+                }
+            }
+        }
+        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++)
+                nameScope.push(argumentScope[j]);
+            for (let j = assignmentIndex + 1; j < argumentScope.length; j++)
+                valueScope.push(argumentScope[j]);
+            normalizedScopes.push(nameScope, valueScope);
+        }
+        else
+            normalizedScopes.push(argumentScope);
+    }
+    return normalizedScopes;
+}
+function LET(...args) {
+    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 = [];
+    let retval;
+    try {
+        for (let i = 0; i < args.length - 1; i += 2) {
+            const nameExpression = args[i]({ inheritValues: false, substitute: false });
+            if (!Expression_1.Expression.isExpression(nameExpression)) {
+                throw new errors_1.UnexpectedInputError((0, errors_1.message)('plainVariableExpected', { input: nameExpression.text() }));
+            }
+            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))
+                    previousValues.set(name, Parser_1.Parser.KNOWN_VALUES[name]);
+                else
+                    previouslyUndefined.add(name);
+            }
+            assign(nameExpression, value);
+            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))
+                retval = error.value;
+            else
+                throw error;
+        }
+    }
+    finally {
+        for (const [name, value] of previousValues)
+            Parser_1.Parser.KNOWN_VALUES[name] = value;
+        for (const name of previouslyUndefined)
+            delete Parser_1.Parser.KNOWN_VALUES[name];
+    }
+    return retval;
+}
+function unassign(x) {
+    let variable;
+    let name;
+    if (typeof x === 'function') {
+        const parsed = x({ inheritValues: false, substitute: false });
+        if (!Expression_1.Expression.isExpression(parsed))
+            throw new errors_1.UnexpectedInputError((0, errors_1.message)('plainVariableExpected', { input: parsed.text() }));
+        variable = parsed;
+    }
+    else
+        variable = x;
+    if (Expression_1.Expression.isExpression(variable))
+        name = (0, utils_1.assertPlainVariableAndGetString)(variable);
+    else
+        name = variable;
+    delete Parser_1.Parser.KNOWN_VALUES[name];
+    return Expression_1.Expression.create(variable);
+}

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

@@ -0,0 +1,130 @@
+import { type Equation } from '../equation/Equation';
+import { type Expression } from '../expression/Expression';
+import type { NerdamerInput, ParserEntity } from '../../types';
+import type { IndexedReference } from './wrappers/IndexedReference';
+import type { KeyValuePair } from './wrappers/KeyValuePair';
+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
+ */
+export type PreFixFunction = (a: ParserEntity) => ParserEntity;
+/**
+ * The type used to defined a prefix for the parser
+ */
+export type PostFixFunction = (b: ParserEntity) => ParserEntity;
+/**
+ * The call used to construct an equation
+ */
+export type EquationConstructorCall = (a: ParserEntity, b: ParserEntity) => Equation;
+/** Controls the parser context used when a deferred function evaluates one argument. */
+export interface DeferredArgumentOptions {
+    /** Call-scoped substitution names to omit while evaluating this argument. */
+    excludeValues?: readonly string[];
+    /** Whether this argument should inherit the enclosing call-scoped substitutions. */
+    inheritValues?: boolean;
+    /** Optional temporary override for known-value substitution. */
+    substitute?: boolean;
+}
+/**
+ * A parser argument whose evaluation is delayed until the receiving function decides to
+ * execute it. The callback may be invoked once or repeatedly, and may narrow the inherited
+ * substitution context for lexical control functions.
+ */
+export type DeferredFunctionArgument = (options?: DeferredArgumentOptions) => ParserEntity;
+/** An operator action whose right-hand operand is deferred. */
+export type DeferredOperation = (a: ParserEntity, b: DeferredFunctionArgument) => ParserEntity;
+/**
+ * Named values substituted while parsing or evaluating an input expression.
+ *
+ * Keys are parser variable names. This compatibility type accepts the same broad value
+ * union as the root API, but not every substitution path can consume every structured
+ * entity. The receiving operation's documentation defines the narrower requirements when
+ * one applies.
+ */
+export type ParserValuesObject = Record<string, NerdamerInput>;
+/**
+ * Constant definitions accepted by the parser's constant registry.
+ *
+ * String definitions are parsed when the constant is encountered. Function
+ * definitions are deferred factories that return parser text, allowing constants such
+ * as `pi` and `e` to reflect the active numerical precision. The registry itself is
+ * process-wide; this type does not imply isolated parser state.
+ */
+export type ParserConstants = Record<string, (() => string) | string>;
+/**
+ * Values currently accepted by Nerdamer's broad settings objects.
+ *
+ * @remarks
+ * Parser and formatting settings share this recursive value type. Each API still decides
+ * which setting names and value shapes it understands.
+ */
+export type OptionValue = string | boolean | number | string[] | OptionsObject;
+/**
+ * Compatibility settings bag used by several parser and formatter entry points.
+ *
+ * The index signature reflects the values that settings APIs currently pass around. It
+ * does not make arbitrary setting names part of the supported public method.
+ */
+export interface OptionsObject {
+    [key: string]: OptionValue;
+}
+/**
+ * Formatting options accepted by {@link Expression.text}.
+ *
+ * These options affect only the returned string. They do not change the expression or
+ * Nerdamer's process-wide settings.
+ */
+export type TextOptions = {
+    /** Render rational values as decimals instead of exact fractions. */
+    decimal?: boolean;
+    /** Significant-digit precision used when decimal output is requested. */
+    precision?: number;
+    /**
+     * Render numeric values in scientific notation with exactly this many significant digits (1–1e9).
+     * Numeric powers use scientific notation only when the formatted exponent remains exact.
+     */
+    scientific?: number;
+    /** Sort sum and product elements with {@link Expression.sortFunction} before rendering. */
+    sort?: boolean;
+    /** Parenthesize powers for output that will be embedded in JavaScript-style expressions. */
+    wrapPow?: boolean;
+};
+/**
+ * The type used when passing settings
+ */
+export type SimpleOptionsObject = Record<string, string | number | Expression>;
+/**
+ * The type supported by Decimal implementations of algorithms
+ */
+export type DecimalType = Decimal | number | string;
+/**
+ * Native JavaScript function produced or consumed by numerical compilation APIs.
+ *
+ * Arguments and numeric results use JavaScript `number` arithmetic rather than
+ * Nerdamer's exact rational or arbitrary-precision symbolic representation. Boolean
+ * results support compiled comparison expressions.
+ */
+export type JsFunction = (...args: number[]) => number | boolean;
+/**
+ * A simple expression function call
+ */
+export type ExpressionFunction = (...args: Expression[]) => Expression;
+/**
+ * Internal values that may temporarily exist on the parser output stack.
+ * IndexedReference and KeyValuePair are resolved or consumed before parseRPN returns.
+ * Deferred callbacks are consumed only by operators that explicitly request them.
+ */
+export type ParserStackValue = ParserEntity | IndexedReference | KeyValuePair | DeferredFunctionArgument;
+/**
+ * An array containing numerator and denominator
+ */
+export type FracArray = [string, string];

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/output/core/classes/parser/wrappers/IndexedReference.d.ts

@@ -0,0 +1,31 @@
+import { INDEXED_REFERENCE } from '../constants';
+import type { ParserEntity } from '../../../types';
+import type { Dictionary } from '../../dictionary/Dictionary';
+/**
+ * A lightweight wrapper that holds a reference to a structured entity and the indices
+ * used to access it. This is pushed onto the output stack during indexing so that
+ * the assign operator can detect it and call setter instead of getter.
+ *
+ * For any non-assign operator, the IndexedReference is resolved to its value via resolve().
+ * The resolved value is cached so that repeated calls don't re-invoke the getter.
+ */
+export declare class IndexedReference {
+    target: ParserEntity;
+    indices: number[] | string;
+    targetName?: string | undefined;
+    private _resolved;
+    dataType: typeof INDEXED_REFERENCE;
+    isEnumerable: boolean;
+    constructor(target: ParserEntity, indices: number[] | string, targetName?: string | undefined);
+    static isIndexedReference(obj: unknown): obj is IndexedReference;
+    copy(): import("../../expression/Expression").Expression | import("../../vector/Vector").Vector | import("../../valuesSet/ValuesSet").ValuesSet | import("../../collection/Collection").Collection | import("../../matrix/Matrix").Matrix | Dictionary | import("../../equation/Equation").Equation;
+    eq(other: ParserEntity): boolean;
+    evaluate(): import("../../expression/Expression").Expression | import("../../vector/Vector").Vector | import("../../valuesSet/ValuesSet").ValuesSet | import("../../collection/Collection").Collection | import("../../matrix/Matrix").Matrix | Dictionary | import("../../equation/Equation").Equation;
+    expand(): import("../../expression/Expression").Expression | import("../../vector/Vector").Vector | import("../../valuesSet/ValuesSet").ValuesSet | import("../../collection/Collection").Collection | import("../../matrix/Matrix").Matrix | Dictionary | import("../../equation/Equation").Equation;
+    gt(other: ParserEntity): boolean;
+    gte(other: ParserEntity): boolean;
+    lt(other: ParserEntity): boolean;
+    lte(other: ParserEntity): boolean;
+    resolve(): ParserEntity;
+    text(): string;
+}

package/output/core/classes/parser/wrappers/IndexedReference.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedReference = void 0;
+const common_1 = require("../../../common/common");
+const constants_1 = require("../constants");
+/**
+ * A lightweight wrapper that holds a reference to a structured entity and the indices
+ * used to access it. This is pushed onto the output stack during indexing so that
+ * the assign operator can detect it and call setter instead of getter.
+ *
+ * For any non-assign operator, the IndexedReference is resolved to its value via resolve().
+ * The resolved value is cached so that repeated calls don't re-invoke the getter.
+ */
+class IndexedReference {
+    target;
+    indices;
+    targetName;
+    _resolved = null;
+    dataType = constants_1.INDEXED_REFERENCE;
+    isEnumerable = false;
+    constructor(target, indices, targetName) {
+        this.target = target;
+        this.indices = indices;
+        this.targetName = targetName;
+    }
+    static isIndexedReference(obj) {
+        return (0, common_1.isNerdamerNativeType)(obj, constants_1.INDEXED_REFERENCE);
+    }
+    copy() {
+        return this.resolve().copy();
+    }
+    eq(other) {
+        return this.resolve().eq(other);
+    }
+    evaluate() {
+        return this.resolve().evaluate();
+    }
+    expand() {
+        return this.resolve().expand();
+    }
+    gt(other) {
+        return this.resolve().gt(other);
+    }
+    gte(other) {
+        return this.resolve().gte(other);
+    }
+    lt(other) {
+        return this.resolve().lt(other);
+    }
+    lte(other) {
+        return this.resolve().lte(other);
+    }
+    resolve() {
+        if (this._resolved === null) {
+            if (typeof this.indices === 'string') {
+                this._resolved = this.target.__get__(this.indices);
+            }
+            else {
+                this._resolved = this.target.__get__(this.indices);
+            }
+        }
+        return this._resolved;
+    }
+    text() {
+        return this.resolve().text();
+    }
+}
+exports.IndexedReference = IndexedReference;