nerdamer 2.0.0-rc.1 → 2.0.0

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

@@ -47,9 +47,9 @@ function power(a, b) {
         throw new errors_1.ZeroToZeroPowerError((0, errors_1.message)('zeroToZeroPower'));
     }
     if (Settings_1.Settings.DEFER_SIMPLIFICATION) {
-        retval = new Expression_1.Expression(a);
+        retval = a.copy();
         // Convert it to an EXP
-        retval = Expression_1.Expression.toEXP(retval, new Expression_1.Expression(b));
+        retval = Expression_1.Expression.toEXP(retval, b.copy());
         retval.deferred = true;
     }
     else {
@@ -59,7 +59,7 @@ function power(a, b) {
         }
         // Handle e^(i*pi)
         else if (a.isE() && b.isComplex()) {
-            const p = new Expression_1.Expression(b);
+            const p = b.copy();
             const m = p.getMultiplier();
             delete p.multiplier;
             if ((0, compare_1.equal)(p, `${Expression_1.Expression.imaginary}*${constants_1.PI[0]}`)) {
@@ -163,7 +163,7 @@ function power(a, b) {
                 retval = (0, shortcuts_1.one)();
             }
             else if (b.isOne()) {
-                retval = new Expression_1.Expression(a);
+                retval = a.copy();
             }
             else if (a.isInf() || bIsInf) {
                 const aIsInf = a.isInf();
@@ -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;
                     }
@@ -255,7 +255,7 @@ function power(a, b) {
                         retval = a.getBase().times(a.getMultiplier());
                     }
                     else {
-                        retval = new Expression_1.Expression(a);
+                        retval = a.copy();
                         retval.power = p;
                     }
                 }
@@ -289,7 +289,7 @@ function power(a, b) {
                         // powers. Positive magnitude has already been extracted for symbolic
                         // bases, while numeric bases keep their exact magnitude in c.
                         if (root !== 1n && !a.isNUM() && a.getMultiplier().isNegative()) {
-                            retval = Expression_1.Expression.toEXP(new Expression_1.Expression(a), b);
+                            retval = Expression_1.Expression.toEXP(a.copy(), b);
                             retval = retval.times(c);
                             retval = rationalizeRadical(retval);
                         }
@@ -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());
         }
@@ -542,7 +542,7 @@ function setPower(a, b) {
 function sqrtToPow(x) {
     let retval;
     if (x.isFunction(constants_1.SQRT)) {
-        retval = new Expression_1.Expression(x.getArguments()[0]);
+        retval = x.getArguments()[0].copy();
         // The the power. Pass in true to get it as a Expression
         const pow = x.getPower();
         // set the power
@@ -551,7 +551,7 @@ function sqrtToPow(x) {
         retval.multiplier = x.getMultiplier().copy();
     }
     else {
-        retval = new Expression_1.Expression(x);
+        retval = x.copy();
     }
     return retval;
 }
@@ -573,7 +573,7 @@ function powToSqrt(x) {
         retval.multiplier = x.getMultiplier().copy();
     }
     else {
-        retval = new Expression_1.Expression(x);
+        retval = x.copy();
     }
     return retval;
 }

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.subtract = subtract;
 exports.subtractPrefix = subtractPrefix;
+const errors_1 = require("../../../errors");
 const Settings_1 = require("../../../Settings");
 const Expression_1 = require("../../expression/Expression");
 const add_1 = require("./add");
@@ -23,7 +24,7 @@ function subtract(a, b) {
             retval = (0, add_1.add)(a, b.neg());
         }
         if (!retval) {
-            throw new Error(`Subtraction not defined for ${a.type}-${b.type} | ${a}-${b}`);
+            throw new Error((0, errors_1.message)('subtractionNotDefined', { leftType: String(a.type), rightType: String(b.type), left: String(a), right: String(b) }));
         }
     }
     return retval;

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

@@ -3,12 +3,5 @@ type FunctionMetadata = {
     maxArgs: number;
 };
 type FunctionRegistry = Record<string, FunctionMetadata>;
-/**
- * Converts accepted parser shorthand to the ordinary notation consumed by the tokenizer.
- * Paired-hash comments are removed before root-level semicolon sequences are mapped to the
- * existing block construct and legacy bracketless function calls are normalized. Existing
- * parenthesized calls are untouched; only a registered function followed by whitespace is
- * considered a bracketless call.
- */
 export declare function preprocess(input: string, functions: FunctionRegistry): string;
 export {};

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preprocess = preprocess;
 const errors_1 = require("../../errors");
 const BLOCK_FUNCTION = 'block';
-const COMMENT_DELIMITER = '##';
+const LET_FUNCTION = 'let';
 function isIdentifierStart(character) {
     return /[a-z_]/i.test(character);
 }
@@ -29,29 +29,23 @@ function getNextSignificantCharacter(input, at) {
     }
     return input[index];
 }
-/**
- * Removes paired-hash comments before any other parser-input normalization occurs.
- *
- * A comment begins at `##` and ends at the next `##`. Comment contents are replaced
- * with whitespace so adjacent tokens do not accidentally merge. A lone `#` is left
- * untouched and retains its ordinary parser meaning.
- */
 function normalizeComments(input) {
     let retval = '';
     let index = 0;
     while (index < input.length) {
-        const opening = input.indexOf(COMMENT_DELIMITER, index);
+        const opening = input.indexOf('#', index);
         if (opening === -1) {
             retval += input.slice(index);
             break;
         }
         retval += input.slice(index, opening);
-        const closing = input.indexOf(COMMENT_DELIMITER, opening + COMMENT_DELIMITER.length);
+        const delimiter = input.startsWith('##', opening) ? '##' : '#';
+        const closing = input.indexOf(delimiter, opening + delimiter.length);
         if (closing === -1) {
-            throw new errors_1.ParserError(`Missing closing comment delimiter "${COMMENT_DELIMITER}".`);
+            throw new errors_1.ParserError((0, errors_1.message)('missingCommentDelimiter', { delimiter }));
         }
         retval += ' ';
-        index = closing + COMMENT_DELIMITER.length;
+        index = closing + delimiter.length;
     }
     return retval;
 }
@@ -59,10 +53,9 @@ function normalizeComments(input) {
  * Normalizes semicolon statement syntax onto the parser's existing block sequencing.
  *
  * Root-level statement sequences become an implicit block. Inside an explicit block,
- * semicolons separate block arguments just like the commas that already drive BLOCK's
- * deferred evaluation. A trailing semicolon before a closing bracket or comma is simply
- * discarded. Semicolons in other nested expression contexts are left untouched so the
- * ordinary parser can reject syntax whose sequencing semantics have not been defined.
+ * semicolons separate block arguments just like commas. A statement sequence in LET's body is
+ * wrapped in an implicit block so the sequence remains one LET body argument rather than being
+ * mistaken for additional bindings. A trailing semicolon is discarded.
  */
 function normalizeStatementSeparators(input) {
     const scopes = [];
@@ -72,21 +65,33 @@ function normalizeStatementSeparators(input) {
         const character = input[index];
         if (character === '(' || character === '[' || character === '{') {
             const closingBracket = character === '(' ? ')' : character === '[' ? ']' : '}';
+            retval += character;
             scopes.push({
+                argumentStart: retval.length,
                 closingBracket,
                 functionName: character === '(' ? getPreviousIdentifier(input, index) : undefined,
             });
-            retval += character;
             continue;
         }
         if (character === ')' || character === ']' || character === '}') {
             const currentScope = scopes[scopes.length - 1];
             if (currentScope?.closingBracket === character) {
+                if (currentScope.statementBlockOpened) {
+                    retval += ')';
+                }
                 scopes.pop();
             }
             retval += character;
             continue;
         }
+        if (character === ',') {
+            retval += character;
+            const currentScope = scopes[scopes.length - 1];
+            if (currentScope && !currentScope.statementBlockOpened) {
+                currentScope.argumentStart = retval.length;
+            }
+            continue;
+        }
         if (character === ';') {
             const nextCharacter = getNextSignificantCharacter(input, index + 1);
             const currentScope = scopes[scopes.length - 1];
@@ -105,6 +110,16 @@ function normalizeStatementSeparators(input) {
             else if (currentScope?.functionName === BLOCK_FUNCTION) {
                 retval += ',';
             }
+            else if (currentScope?.functionName === LET_FUNCTION) {
+                if (!currentScope.statementBlockOpened) {
+                    retval =
+                        retval.slice(0, currentScope.argumentStart) +
+                            `${BLOCK_FUNCTION}(` +
+                            retval.slice(currentScope.argumentStart);
+                    currentScope.statementBlockOpened = true;
+                }
+                retval += ',';
+            }
             else {
                 retval += character;
             }
@@ -117,11 +132,6 @@ function normalizeStatementSeparators(input) {
     }
     return retval;
 }
-/**
- * Finds the right-most registered function that is separated from its argument by whitespace.
- * Processing from the inside out lets nested input such as `sin sin x` normalize without
- * introducing a separate parser mode.
- */
 function findBracketlessFunction(input, functions) {
     let retval;
     let index = 0;
@@ -146,12 +156,8 @@ function findBracketlessFunction(input, functions) {
         if (index < input.length) {
             const firstArgumentCharacter = input[index];
             const nextCharacter = input[index + 1] ?? '';
-            // Whitespace around an ordinary binary operator must not turn a registered
-            // function name used as a variable into a bracketless call. A sign glued to
-            // its operand remains valid prefix syntax, as in `sin -x`.
             const startsWithOperatorBoundary = /[*/=<>:&|]/.test(firstArgumentCharacter) ||
-                ((firstArgumentCharacter === '+' || firstArgumentCharacter === '-') &&
-                    /\s/.test(nextCharacter));
+                ((firstArgumentCharacter === '+' || firstArgumentCharacter === '-') && /\s/.test(nextCharacter));
             if (!startsWithOperatorBoundary) {
                 retval = {
                     argumentStart: index,
@@ -171,11 +177,6 @@ function isOpeningBracket(character) {
 function isClosingBracket(character) {
     return character === ')' || character === ']' || character === '}';
 }
-/**
- * Finds the end of one bracketless function application. Function application binds more
- * tightly than ordinary binary arithmetic but less tightly than powers and postfix operators.
- * Multi-argument functions keep comma-separated arguments in the same application.
- */
 function findArgumentEnd(input, start, maxArgs, consumeStatement = false) {
     let depth = 0;
     let index = start;
@@ -234,13 +235,6 @@ function findArgumentEnd(input, start, maxArgs, consumeStatement = false) {
     }
     return index;
 }
-/**
- * Converts accepted parser shorthand to the ordinary notation consumed by the tokenizer.
- * Paired-hash comments are removed before root-level semicolon sequences are mapped to the
- * existing block construct and legacy bracketless function calls are normalized. Existing
- * parenthesized calls are untouched; only a registered function followed by whitespace is
- * considered a bracketless call.
- */
 function preprocess(input, functions) {
     let retval = normalizeComments(input);
     retval = normalizeStatementSeparators(retval);

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

@@ -1,121 +1,23 @@
 import { Expression } from '../../expression/Expression';
 import type { ParserEntity } from '../../../types';
 import type { DeferredFunctionArgument } from '../types';
-export declare const RETURN_SIGNAL = "RETURN_SIGNAL";
-export declare const BREAK_SIGNAL = "BREAK_SIGNAL";
-export declare const CONTINUE_SIGNAL = "CONTINUE_SIGNAL";
-/** Base class for internal parser control transfers. These signals are not parser errors. */
-export declare abstract class ControlFlowSignal extends Error {
-    constructor();
-}
-/**
- * Internal control-flow signal used to carry a symbolic function's return value to its
- * function boundary. It is not a mathematical parser result.
- */
-export declare class ReturnSignal extends ControlFlowSignal {
-    readonly value: ParserEntity;
-    readonly dataType: typeof RETURN_SIGNAL;
-    constructor(value: ParserEntity);
-    static isReturnSignal(obj: unknown): obj is ReturnSignal;
-}
-/** Internal control-flow signal consumed by the nearest parser loop. */
-export declare class BreakSignal extends ControlFlowSignal {
-    readonly dataType: typeof BREAK_SIGNAL;
-    static isBreakSignal(obj: unknown): obj is BreakSignal;
-}
-/** Internal control-flow signal consumed by the nearest parser loop. */
-export declare class ContinueSignal extends ControlFlowSignal {
-    readonly dataType: typeof CONTINUE_SIGNAL;
-    static isContinueSignal(obj: unknown): obj is ContinueSignal;
-}
-/**
- * Evaluates one symbolic-function body and consumes control flow at the function boundary.
- * RETURN becomes the function result, while BREAK and CONTINUE cannot escape a function call.
- */
+export { BREAK_SIGNAL, CONTINUE_SIGNAL, NULL_SIGNAL, RETURN_SIGNAL, BreakSignal, ContinueSignal, ControlFlowSignal, NullSignal, ReturnSignal, } from '../controlFlowSignals';
+export declare function isInsideSymbolicFunction(): boolean;
+export declare function shouldConsumeLocalReturn(): boolean;
+export declare function withReturnPropagation(evaluate: () => ParserEntity): ParserEntity;
 export declare function functionBoundary(evaluate: () => ParserEntity): ParserEntity;
-/**
- * Returns a value from the current symbolic function.
- * @param x
- * @returns
- */
 export declare function RETURN(x: ParserEntity): never;
-/** Exits the nearest parser control-flow loop. */
 export declare function BREAK(): never;
-/** Skips to the next iteration of the nearest parser control-flow loop. */
 export declare function CONTINUE(): never;
-/**
- * Returns 1 when every deferred argument is nonzero, otherwise 0.
- * Evaluation stops as soon as a false argument is found.
- */
 export declare function AND(...args: DeferredFunctionArgument[]): Expression;
-/**
- * Returns 1 when at least one deferred argument is nonzero, otherwise 0.
- * Evaluation stops as soon as a true argument is found.
- */
 export declare function OR(...args: DeferredFunctionArgument[]): Expression;
-/** Returns 1 when the argument is zero and 0 otherwise. */
 export declare function NOT(value: ParserEntity): Expression;
-/** Returns 1 when an odd number of arguments are nonzero, otherwise 0. */
 export declare function XOR(...args: ParserEntity[]): Expression;
-/**
- * Evaluates an expression and returns its result unless evaluation throws an ordinary error.
- * The fallback is evaluated only after an error. Internal parser control-flow signals continue
- * unwinding to their enclosing function or loop boundary.
- */
 export declare function IFERROR(expression: DeferredFunctionArgument, fallback: DeferredFunctionArgument): ParserEntity;
-/**
- * Returns 1 when deferred evaluation throws an ordinary error and 0 otherwise.
- * Internal parser control-flow signals are not errors and continue unwinding normally.
- */
 export declare function ISERROR(expression: DeferredFunctionArgument): Expression;
-/**
- * A branching function. Its arguments are deferred so only the selected branch is evaluated.
- * When the false branch is omitted, a false condition produces the parser's empty result.
- * @param condition
- * @param branch1
- * @param branch2
- * @returns
- */
 export declare function IF(condition: DeferredFunctionArgument, branch1: DeferredFunctionArgument, branch2?: DeferredFunctionArgument): ParserEntity;
-/**
- * Repeatedly evaluates a deferred body while a deferred condition is nonzero.
- * The condition is reevaluated before every iteration. BREAK and CONTINUE are consumed here so
- * they apply only to the nearest loop; other control-flow signals continue to unwind outward.
- * The final completed body result is returned; if the body never completes, an empty Vector is
- * returned.
- * @param condition
- * @param body
- * @returns
- */
 export declare function WHILE(condition: DeferredFunctionArgument, body: DeferredFunctionArgument): ParserEntity;
-/**
- * Evaluates a deferred initializer once, then delegates repeated condition and body evaluation
- * to WHILE. The update runs after each completed body evaluation and also before a CONTINUE
- * advances to the next condition check. BREAK and RETURN skip the pending update. The final
- * completed body result is returned; if the body never completes, WHILE's empty-Vector result
- * is preserved.
- * @param initializer
- * @param condition
- * @param update
- * @param body
- * @returns
- */
 export declare function FOR(initializer: DeferredFunctionArgument, condition: DeferredFunctionArgument, update: DeferredFunctionArgument, body: DeferredFunctionArgument): ParserEntity;
-/**
- * Evaluates a sequence of deferred parser commands in order.
- * The final command's result is returned. Control-flow signals are not consumed here, allowing
- * RETURN, BREAK, and CONTINUE to unwind to their enclosing function or loop boundary. An empty
- * block retains the historical empty-vector result.
- * @param args
- * @returns
- */
 export declare function BLOCK(...args: DeferredFunctionArgument[]): ParserEntity;
-/**
- * Evaluates one parser-dispatched function through the outer return boundary.
- *
- * Nested parser calls keep propagating RETURN. The outermost parser call consumes it when
- * execution is not already inside a symbolic function.
- */
 export declare function parserReturnBoundary(evaluate: () => ParserEntity): ParserEntity;
-/** Evaluates BLOCK through the parser return boundary. */
 export declare function parserBlock(...args: DeferredFunctionArgument[]): ParserEntity;