nerdamer 1.1.13 → 2.0.0-rc.1

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subtract = subtract;
+exports.subtractPrefix = subtractPrefix;
+const Settings_1 = require("../../../Settings");
+const Expression_1 = require("../../expression/Expression");
+const add_1 = require("./add");
+function subtract(a, b) {
+    let retval;
+    if (Settings_1.Settings.DEFER_SIMPLIFICATION) {
+        retval = (0, add_1.add)(a, b.neg());
+        retval.deferred = true;
+    }
+    else {
+        if (a.isNUM() && b.isNUM()) {
+            retval = Expression_1.Expression.fromRational(a.getMultiplier().minus(b.getMultiplier()));
+        }
+        // Any value minus inf is -inf
+        else if (!a.isInf() && b.isInf()) {
+            retval = Expression_1.Expression.Inf().neg();
+        }
+        else {
+            retval = (0, add_1.add)(a, b.neg());
+        }
+        if (!retval) {
+            throw new Error(`Subtraction not defined for ${a.type}-${b.type} | ${a}-${b}`);
+        }
+    }
+    return retval;
+}
+function subtractPrefix(a) {
+    // Just negates the multiplier
+    const x = a.neg();
+    return x;
+}

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

@@ -0,0 +1,14 @@
+type FunctionMetadata = {
+    bracketlessStatement?: boolean;
+    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

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

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

@@ -0,0 +1,121 @@
+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 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;