nerdamer 1.1.13 → 2.0.0-rc.2

package/output/core/errors.js

@@ -0,0 +1,349 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ErrorMessages = exports.EnglishErrorMessages = exports.AssignmentError = exports.ZeroToZeroPowerError = exports.MissingReferenceError = exports.NotImplementedError = exports.DimensionError = exports.NaNError = exports.MathError = exports.ParserSyntaxError = exports.UnsupportedOperationError = exports.PolynomialError = exports.UndefinedError = exports.NullError = exports.ParserError = exports.OperatorError = exports.DivisionByZeroError = exports.UnexpectedInputError = exports.UnexpectedDataType = exports.UnexpectedTokenError = void 0;
+exports.registerLanguage = registerLanguage;
+exports.message = message;
+const string_1 = require("./functions/string");
+const Settings_1 = require("./Settings");
+/** Thrown when tokenization encounters invalid adjacency, punctuation, or bracket structure. */
+class UnexpectedTokenError extends Error {
+}
+exports.UnexpectedTokenError = UnexpectedTokenError;
+/** Thrown when an operation receives a Nerdamer entity of the wrong runtime type. */
+class UnexpectedDataType extends Error {
+}
+exports.UnexpectedDataType = UnexpectedDataType;
+/** Used when input parses successfully but does not have the form an operation requires. */
+class UnexpectedInputError extends Error {
+}
+exports.UnexpectedInputError = UnexpectedInputError;
+/** Thrown for exact division by zero. Small nonzero numerical values are not treated as zero. */
+class DivisionByZeroError extends Error {
+}
+exports.DivisionByZeroError = DivisionByZeroError;
+/** Used for invalid parser-operator definitions and operator dispatch failures. */
+class OperatorError extends Error {
+}
+exports.OperatorError = OperatorError;
+/** General parser error for construction, evaluation, and registered-function failures. */
+class ParserError extends Error {
+}
+exports.ParserError = ParserError;
+/** Thrown when evaluation requires a value but a construct produces no value. */
+class NullError extends Error {
+}
+exports.NullError = NullError;
+/** Used when a mathematical operation has no defined value in the handled domain. */
+class UndefinedError extends Error {
+}
+exports.UndefinedError = UndefinedError;
+/** Thrown when input cannot be represented as a polynomial under the requested requirements. */
+class PolynomialError extends Error {
+}
+exports.PolynomialError = PolynomialError;
+/** Thrown when an operation is known but unsupported for the supplied form or domain. */
+class UnsupportedOperationError extends Error {
+}
+exports.UnsupportedOperationError = UnsupportedOperationError;
+/** Parser syntax error kept separate from lower-level tokenization failures. */
+class ParserSyntaxError extends Error {
+}
+exports.ParserSyntaxError = ParserSyntaxError;
+/** General mathematical precondition error for cases without a more specific error type. */
+class MathError extends Error {
+}
+exports.MathError = MathError;
+/** Thrown when a required numeric conversion produces `NaN`. */
+class NaNError extends Error {
+}
+exports.NaNError = NaNError;
+/** Thrown when vector, matrix, or structured-entity dimensions are incompatible. */
+class DimensionError extends Error {
+}
+exports.DimensionError = DimensionError;
+/** Used for recognized operations that have not been implemented yet. */
+class NotImplementedError extends Error {
+}
+exports.NotImplementedError = NotImplementedError;
+/** Thrown when a named converter or pattern reference cannot be resolved. */
+class MissingReferenceError extends Error {
+}
+exports.MissingReferenceError = MissingReferenceError;
+/** Thrown for the indeterminate symbolic form `0^0`. */
+class ZeroToZeroPowerError extends Error {
+}
+exports.ZeroToZeroPowerError = ZeroToZeroPowerError;
+/** Thrown when code attempts to assign to a reserved or otherwise non-assignable parser name. */
+class AssignmentError extends Error {
+}
+exports.AssignmentError = AssignmentError;
+/** Internal localized message templates used when constructing Nerdamer errors. */
+exports.EnglishErrorMessages = {
+    // General
+    notImplemented: 'This method has not yet been implemented.',
+    noInverse: 'Unable to calculate inverse!',
+    undefinedValue: 'The requested value is undefined!',
+    nullValue: 'Value expected but received null.',
+    univariateInputOnly: 'The input for this function must be univariate!',
+    differentSignsAtEndPointsRequired: 'Function must have opposite signs at endpoints a and b!',
+    integerRequired: 'This function requires the coefficient to be an integer!',
+    plainVariableExpected: 'Expected plain variable! Received {{input}}.',
+    missingReference: 'The reference "{{ref}}" does not exist on this pattern!!',
+    undefinedDivision: 'Division not defined expression of this type! {{type}}',
+    restrictedVariableName: 'Cannot assign the requested value to the reserved name "{{name}}"!',
+    noVariableInExpression: 'No variable found in expression!',
+    quadraticExpressionExpected: 'Expression must be quadratic!',
+    wrongInput: 'Wrong input! Expected {{expected}} but received {{received}}.',
+    unsupportedFunction: 'Unsupported function {{function}}',
+    functionMinArgs: '{{function}} requires a minimum of {{min}} arguments but {{actual}} provided!',
+    functionMaxArgs: '{{function}} allows a maximum of {{max}} arguments but {{actual}} provided!',
+    invalidFunctionDeclaration: 'Invalid function declaration {{declaration}}.',
+    indexOutOfBounds: 'Index {{index}} out of bounds for {{type}} of length {{length}}',
+    matrixRowIndexOutOfBounds: 'Row index {{index}} out of bounds for Matrix with {{length}} rows',
+    matrixColumnIndexOutOfBounds: 'Column index {{index}} out of bounds for Matrix with {{length}} columns',
+    dictionaryKeyNotFound: 'Key "{{key}}" not found in Dictionary. Available keys: {{keys}}',
+    rangeValuesFinite: 'Range values must be finite.',
+    rangeStepNonzero: 'Step cannot be zero',
+    rangeStepNoAdvance: 'Step does not advance range at current precision',
+    sparseVariableCountInvalid: 'SparsePolynomial variableCount must be a non-negative safe integer.',
+    sparseExponentVectorLengthMismatch: 'SparsePolynomial exponent vector length must equal variableCount.',
+    sparseExponentsNonNegativeBigInt: 'SparsePolynomial exponents must be non-negative bigints.',
+    sparseVariableIndexOutOfRing: 'SparsePolynomial variable index is outside the polynomial ring.',
+    sparseAdditionRingMismatch: 'SparsePolynomial addition requires the same polynomial ring.',
+    sparseCoefficientExponentNonNegative: 'SparsePolynomial coefficient exponent must be non-negative.',
+    sparseZeroMonomialDivision: 'SparsePolynomial cannot divide by a zero monomial.',
+    sparseZeroScalarDivision: 'SparsePolynomial cannot divide by zero.',
+    sparseScalarDivisionExact: 'SparsePolynomial scalar division must be exact for every coefficient.',
+    sparseDivisionRingMismatch: 'SparsePolynomial division requires the same polynomial ring.',
+    sparseZeroPolynomialDivision: 'SparsePolynomial cannot divide by the zero polynomial.',
+    sparseMonomialOrderUnsupported: 'SparsePolynomial monomial order is not supported.',
+    sparseMultiplicationRingMismatch: 'SparsePolynomial multiplication requires the same polynomial ring.',
+    sparseExponentNonNegative: 'SparsePolynomial exponent must be non-negative.',
+    sparseSubtractionRingMismatch: 'SparsePolynomial subtraction requires the same polynomial ring.',
+    invalidDecimal: 'Invalid Decimal: "{{value}}"',
+    invalidInterval: 'Invalid interval: ({{start}}, {{end}})',
+    invalidAssumption: 'Invalid assumption: "{{input}}"',
+    assumptionIdentifierExpected: 'Expected identifier',
+    assumptionOperatorMissing: 'Missing operator',
+    assumptionValueMissing: 'Missing value',
+    assumptionOperatorUnsupported: 'Unsupported operator "{{operator}}"',
+    matrixStringKeyUnsupported: 'Matrix does not support string key access',
+    matrixTraceUnavailable: 'Unable to calculate trace for the matrix',
+    defintMaxEvals: 'defint: maxEvals exceeded ({{max}}).',
+    defintNonFiniteValue: 'defint: non-finite f(x) at x={{x}}',
+    defintEndpointSingularity: 'defint: endpoint singularity could not be regularized near x={{x}}',
+    defintSingularity: 'defint: singular/non-finite encountered near [{{a}}, {{b}}]',
+    defintInfiniteBounds: 'defint: infinite bounds require allowInfinite: true',
+    defintUnsupportedInfiniteBounds: 'defint: unsupported infinite bound configuration',
+    symbolicAccessNamedTargetRequired: 'Symbolic indexed access requires a named Vector or Matrix target.',
+    symbolicVectorIndexCount: 'Symbolic Vector access requires exactly one index.',
+    symbolicMatrixRowNonScalar: 'Symbolic Matrix row access is not scalar and cannot be deferred as an Expression.',
+    symbolicMatrixCellIndexCount: 'Symbolic Matrix cell access requires exactly two indices.',
+    symbolicAccessMaxIndices: 'Symbolic indexed access supports at most two unresolved indices.',
+    symbolicAccessIndexScalar: 'Symbolic accessor indices must evaluate to scalar expressions.',
+    symbolicAccessTargetType: 'Symbolic indexed access target must resolve to a Vector or Matrix.',
+    expectedOperatorOrFunction: 'Expected operator or function name but "{{value}}" found!',
+    missingOpeningBracket: 'Missing opening bracket for "{{bracket}}":{{position}}',
+    missingClosingBracket: 'Missing closing bracket for "{{bracket}}":{{position}}',
+    prefixOperatorExpected: 'Prefix operator expected but {{operator}} encountered.',
+    groebnerBasisSizeBudgetExceeded: 'Groebner budget exceeded: basis size > {{max}}',
+    groebnerPairsBudgetExceeded: 'Groebner budget exceeded: pairsPopped > {{max}}',
+    unsupportedParserEntity: 'Unsupported parser entity',
+    factorialNegativeUndefined: 'Factorial is undefined for negative integers.',
+    erfConvergenceFailed: 'erf not converging. Exiting!',
+    defintInfiniteBoundsDecimal: 'defint: infinite bounds require allowInfinite:true',
+    seqStartsAtInteger: "startsAt must be an integer",
+    seqPolynomialOrMaxPower: "Sequence is not a polynomial or exceeds maxPower",
+    seqInsufficientData: "Insufficient data points for detected degree",
+    arithPowNegativeExponent: "pow: negative exponent",
+    arithPowNNonnegativeInteger: "powN: exponent must be a nonnegative integer",
+    arithBigIntSqrtNegative: "bigIntSqrt: negative input",
+    arithNthRootPositiveInteger: "intNthRootExact: n must be a positive integer",
+    arithDivisorsPositive: "getDivisors: n must be positive",
+    arithModNormNonzeroModulus: "modNorm: modulus must be nonzero",
+    arithModSymmetricNonzeroModulus: "modSymmetric: modulus must be nonzero",
+    arithModInvZeroNoninvertible: "modInv: non-invertible (0)",
+    arithModInvNoninvertible: "modInv: non-invertible",
+    integerSqrtNonnegative: "Integer square root requires a non-negative value.",
+    modularExponentiationPositiveModulus: "Modular exponentiation requires a positive modulus.",
+    modularExponentiationNonnegativeExponent: "Modular exponentiation requires a non-negative exponent.",
+    maxBigIntRequiresArgument: "maxBigInt() requires at least one argument",
+    minBigIntEmpty: "Min of empty list is not defined for BigInt.",
+    binomBigIntNonnegativeN: "binomBigInt: n must be non-negative",
+    invalidDecimalValue: "Invalid decimal value: {{value}}",
+    subtractionNotDefined: "Subtraction not defined for {{leftType}}-{{rightType}} | {{left}}-{{right}}",
+    sparseAdapterVariablesUnique: "Sparse polynomial adapter variables must be unique.",
+    sparseAdapterVariablesIncludeEvery: "Sparse polynomial adapter variables must include every polynomial variable.",
+    sparseExpressionConversionNameCount: "Sparse polynomial expression conversion requires one name per ring variable.",
+    converterMissingArgumentScope: "Missing argument scope for function {{function}}",
+    converterMissingPrefixOperand: "Missing operand for prefix operator {{operator}}",
+    converterMissingOperandMetadata: "Missing operand or metadata for operator {{operator}}",
+    converterMissingLeftOperand: "Missing left operand for operator {{operator}}",
+    converterTexConversionFailed: "Unable to convert source expression to TeX",
+    unknownOperator: "Unknown operator {{operator}}",
+    polynomialMaximumIterations: "Maximum iterations reached",
+    polyRequires: "{{operation}} requires {{requirement}}.",
+    polyVariablesUnique: "{{operation}} variables must be unique.",
+    polyVariablesRingOrder: "{{operation}} variables must follow polynomial-ring order.",
+    polyVariablesIncludeActive: "{{operation}} variables must include every active variable.",
+    polyInputsSelectedOnly: "{{operation}} inputs may use only the selected variables.",
+    polyCannotFactorZeroPolynomial: "{{operation}} cannot factor the zero polynomial.",
+    polyCannotFactorZero: "{{operation}} cannot factor zero.",
+    polyModulusGreaterThanOne: "ModularSparsePolynomial modulus must be greater than one.",
+    polyVariableCountMatch: "ModularSparsePolynomial variableCount must match the supplied sparse polynomial.",
+    polyInterpolationCannotDepend: "ModularSparsePolynomial interpolation samples cannot depend on the interpolated variable.",
+    polyInterpolationInvertibleDifferences: "ModularSparsePolynomial interpolation points must have invertible pairwise differences.",
+    polyCoefficientExponentNonnegative: "ModularSparsePolynomial coefficient exponent must be non-negative.",
+    polyCannotDivideZero: "ModularSparsePolynomial cannot divide by the zero polynomial.",
+    polyDivisorLeadingCoefficientInvertible: "ModularSparsePolynomial divisor leading coefficient is not invertible.",
+    polyLeadingCoefficientInvertible: "ModularSparsePolynomial leading coefficient is not invertible.",
+    polyExponentNonnegative: "ModularSparsePolynomial exponent must be non-negative.",
+    polyDegreeMatrixLimit: "Modular factorization degree exceeds the supported matrix dimension.",
+    polyExtendedGcdTwoZeroUndefined: "Modular extended GCD is undefined for two zero polynomials.",
+    polyHenselPrimeExceedsTailDegree: "Multivariate Hensel lifting prime must exceed every tail-variable degree.",
+    polyHenselTargetNotSmaller: "Hensel lifting target modulus cannot be smaller than the base prime.",
+    polyHenselTargetRepeatedSquaring: "Hensel lifting target modulus must be obtained by repeated squaring of the base prime.",
+    polyHenselFactorsReconstructModuloBase: "Hensel lifting factors do not reconstruct the integer polynomial modulo the base prime.",
+    polyZassenhausFactorsReconstructModuloLift: "Zassenhaus recombination factors do not reconstruct the input modulo the lift modulus.",
+    polyWangCannotSpecializeZero: "Wang evaluation search cannot specialize zero.",
+    polyModularContentExactDivision: "Modular polynomial content must divide the polynomial exactly.",
+    factorizationNoFactors: "Nonconstant factorization returned no factors.",
+    polyCrtModuliInvertible: "Polynomial CRT moduli must be invertible.",
+    polyIntegerFactorPrimeZero: "Integer factorization cannot choose a prime for zero.",
+    polySquareFreeNonExactDivision: "Square-free factorization encountered a non-exact polynomial division.",
+    polyZassenhausLostRemaining: "Zassenhaus recombination lost the remaining polynomial.",
+    polyZassenhausReconstructionFailed: "Zassenhaus recombination factors do not reconstruct the integer polynomial.",
+    polyIntegerFactorLostLeading: "Integer factorization lost the leading term.",
+    parserMalformedSymbolicAccessor: "Malformed internal symbolic accessor.",
+    parserMalformedSymbolicAccessorIndex: "Malformed internal symbolic accessor index.",
+    unknownOperatorAction: "Unknown operator action {{action}}",
+    parserBracketTokenMissingCharacter: "Bracket token is missing its character.",
+    polyWangLeadingEvaluationInteger: "Wang leading-coefficient evaluation did not produce an integer.",
+    polyWangSpecializedLeadingInteger: "Wang specialized factor did not have an integer leading coefficient.",
+    polyMultivariateContentDivisionFailed: "Multivariate factorization could not divide a square-free block by its main-variable content.",
+    polyMultivariateContentVariableMissing: "Multivariate main-variable content did not retain an active coefficient variable.",
+    polyMultivariateReconstructionFailed: "Complete multivariate factorization does not reconstruct the input polynomial.",
+    polyBerlekampNoninvertiblePivot: "Berlekamp elimination encountered a noninvertible pivot.",
+    polyHenselZeroFactorGroup: "Hensel lifting cannot lift a zero factor group.",
+    polyHenselCannotLiftZero: "Hensel lifting cannot lift the zero polynomial.",
+    polyHenselModulusExceeded: "Hensel lifting exceeded the requested prime-power modulus.",
+    polyHenselLeadingLost: "Hensel lifting lost the target leading coefficient.",
+    polyHenselReconstructionFailed: "Hensel-lifted factors do not reconstruct the target polynomial.",
+    polyBerlekampNonExactSplit: "Berlekamp splitting produced a non-exact factor division.",
+    polyBerlekampIncompleteSplit: "Berlekamp factorization did not fully split the polynomial.",
+    polyBerlekampReconstructionFailed: "Berlekamp factors do not reconstruct the input polynomial.",
+    expressionKeyValueUnsupported: "The function 'keyValue' is not implemented for type {{type}}.",
+    solveLinearNonlinearDegree: "Nonlinear term detected in equation {{equation}}: degree {{degree}} term found. solveLinearSystem only handles linear systems.",
+    solveLinearNonPolynomialVariable: "Nonlinear term detected in equation {{equation}}: variable \"{{variable}}\" appears in a non-polynomial position. solveLinearSystem only handles linear systems.",
+    polyReqPrimeModulus: "a prime modulus",
+    polyReqUnivariatePolynomial: "a univariate polynomial",
+    polyReqSquareFreeInput: "square-free input",
+    polyReqSamePolynomialRing: "the same polynomial ring",
+    polyReqAtLeastOneVariable: "at least one variable",
+    polyReqAtLeastTwoSelectedVariables: "at least two selected variables",
+    polyReqOneEvaluationPerTailVariable: "one evaluation value per tail variable",
+    polyReqMatchingFactorLeadingLists: "matching factor and leading-coefficient lists",
+    polyReqPairwiseCoprimeModularFactors: "pairwise coprime modular factors",
+    polyReqPrimeBaseModulus: "a prime base modulus",
+    polyReqAtLeastOneModularFactor: "at least one modular factor",
+    polyReqUnivariateIntegerPolynomial: "a univariate integer polynomial",
+    polyReqFactorsSameRingAndPrime: "factors from the same integer polynomial ring and base prime",
+    polyReqUnivariateFactors: "univariate factors",
+    polyReqMonicModularFactors: "monic modular factors",
+    polyReqPrimitiveIntegerPolynomial: "a primitive integer polynomial",
+    polyReqPositiveLeadingCoefficient: "a positive leading coefficient",
+    polyReqLiftedModularFactors: "lifted modular factors",
+    polyReqLiftedFactorsSameRing: "lifted factors from one polynomial ring",
+    polyReqUnivariateLiftedFactors: "univariate lifted factors",
+    polyReqMonicLiftedFactors: "monic lifted factors",
+    polyReqLargerHenselModulus: "a larger Hensel lifting modulus",
+    polyReqPrimitivePolynomial: "a primitive polynomial",
+    polyReqPositiveLexLeadingSign: "positive lexicographic leading sign",
+    polyReqSquareFreeMainVariable: "square-free input in the main variable",
+    polyReqExactlyTwoSelectedVariables: "exactly two selected variables",
+    polyReqExactlyTwoVariables: "exactly two variables",
+    polyReqOneValuePerNonMainVariable: "one value for every non-main selected variable",
+    polyReqOneValuePerTailVariable: "one value for every tail variable",
+    polyReqPositiveDegreeMainVariable: "positive degree in the main variable",
+    polyReqAllOtherVariablesDormant: "all other variables to be dormant",
+    polyReqPositiveModuli: "positive moduli",
+    polyReqCoprimeModuli: "coprime moduli",
+    polyReqAtLeastOneSample: "at least one sample",
+    polyReqInvertibleLeadingCoefficient: "an invertible leading coefficient",
+    polyReqIntegerLeadingCoefficientInvertible: "the integer leading coefficient to be invertible modulo the base prime",
+    infinityMinusInfinityUndefined: 'Infinity-Infinity is undefined!',
+    // Assumptions
+    inconsistentAssumptions: 'Assumptions are inconsistent (empty intersection)!',
+    // Parser
+    unsupportedType: 'The provided type ({{type}}) is not supported for this function!',
+    unsupportedOperation: 'This operation is currently not supported!',
+    buildFunctionUnsupportedFunction: 'buildFunction cannot compile the function "{{function}}" to JavaScript number arithmetic!',
+    buildFunctionComplexUnsupported: 'buildFunction cannot compile expressions containing the imaginary unit to JavaScript number arithmetic!',
+    nonMatchingDimensions: "This operation cannot be completed because the dimensions don't match!",
+    malformedExpression: 'Unable to parse malformed expression!',
+    unsupportedCharacter: 'Unsupported character "{{character}}" at position {{position}}.',
+    missingCommentDelimiter: 'Missing closing comment delimiter "{{delimiter}}".',
+    divisionByZero: 'Division by zero is not defined!',
+    zeroToZeroPower: '0^0 is undefined!',
+    infinityToPowerZero: 'Infinity^0 is not defined!',
+    infinityTimesZero: '0*Infinity is not defined!',
+    infinityToInfinity: 'Infinity^Infinity is not defined!',
+    valueToInfinityUndefined: '{{value}}^Infinity is not defined!',
+    atan2Undefined: 'atan2 is undefined for 0, 0!',
+    tanUndefined: 'tan is undefined for multiples of pi/2!',
+    loopIterationLimitExceeded: 'Loop exceeded the maximum of {{max}} iterations.',
+    breakOutsideLoop: 'break can only be used inside a loop.',
+    continueOutsideLoop: 'continue can only be used inside a loop.',
+    letRequiresBindingsAndBody: 'let requires one or more name/value pairs followed by a body expression.',
+    secUndefined: 'sec is undefined for odd multiples of pi/2!',
+    cscUndefined: 'csc is undefined for multiples of pi!',
+    cotUndefined: 'cot is undefined for multiples of pi!',
+    cothUndefined: 'coth is undefined for 0!',
+    cschUndefined: 'csch is undefined for 0!',
+    atanhUndefined: 'atanh is undefined for 0!',
+    cannotCreateArrayFromNaN: 'Cannot create array from NaN!',
+    expressionExpected: 'Expression expected!. Received {{type}}!',
+    // TeX Converter.
+    unrecognizedMode: '"{{mode}}" is is not a valid mode!',
+    // Polynomials
+    notAPolynomial: 'The expression is not a valid polynomial!',
+    multidegreeMismatch: 'The number of variables must match the multidegree of the polynomial!',
+    // Matrix
+    cannotCreateMatrix: 'Unable to create Matrix. Row dimensions do not match!',
+    cannotMultiplyMatrix: 'Cannot multiply matrix!',
+    squareMatrixRequired: 'The matrix must be square!',
+    rowsMustMatch: 'The rows of the matrices must match!',
+    columnsMustMatch: 'The columns of the matrices must match!',
+    singularMatrix: 'The provided matrix is singular!',
+    matrixExpected: 'Matrix expected! Received {{type}}.',
+    // Vector
+    mismatchedDimensions: 'The dimensions must match for the function "{{function}}"!',
+    incorrectCrossDimension: 'The cross product is only defined for vectors of dimension 3!',
+    vectorExpected: 'Expected Vector! Received {{type}}.',
+    // Polynomial
+    univariatePolynomialOnly: 'This function is only supported for univariate polynomials!',
+    unknownVariable: 'Unknown variable! "{{variable}}"',
+    // Solve
+    convergenceFailed: 'Failed to converge! {{iters}} iterations were tried.',
+    endPointIsRoot: 'End point is root.',
+    zeroDerivative: 'The derivative is zero at x = {{x}}. Cannot continue.',
+    tooManyUnknowns: 'Too many unknowns!',
+    solveSystemInfiniteSolutions: 'This system does not have a finite isolated solution set!',
+    solveSystemPolynomialOnly: 'solveSystem currently supports only linear or polynomial systems!',
+    solveSystemNonRationalUnsupported: 'This nonlinear polynomial system requires non-rational or non-symbolic solving, which is not yet supported!',
+    // Set function
+    setJSFunctionExpectsFunction: 'The function parameter when setting a JS function must be of type function!',
+    functionRequiresMinAndMaxArgs: 'You must provide a min and max arg when setting the function!',
+};
+exports.ErrorMessages = {
+    eng: exports.EnglishErrorMessages,
+};
+/** Registers one optional localized message catalog. */
+function registerLanguage(language, catalog) {
+    exports.ErrorMessages[language] = catalog;
+}
+/** Formats an internal localized error message with named template values. */
+function message(e, values) {
+    const catalog = exports.ErrorMessages[Settings_1.Settings.LANGUAGE] ?? exports.ErrorMessages.eng;
+    return (0, string_1.format)(catalog[e], values || {});
+}

package/output/core/fullFunctions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Registers the complete Nerdamer parser function surface.
+ *
+ * Core parser modules do not import higher-level mathematical domains. Entry points
+ * and consumers that require the complete Nerdamer notation surface call this registration function.
+ */
+export declare function registerNerdamerFunctions(): void;

package/output/core/fullFunctions.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerNerdamerFunctions = registerNerdamerFunctions;
+const dispatch_1 = require("../algebra/dispatch");
+const dispatch_2 = require("../calculus/dispatch");
+const dispatch_3 = require("./classes/assumption/dispatch");
+const dispatch_4 = require("./classes/matrix/dispatch");
+const dispatch_5 = require("./classes/polynomial/dispatch");
+const dispatch_6 = require("./classes/parser/scripting/dispatch");
+const dispatch_7 = require("./classes/vector/dispatch");
+const complex_dispatch_1 = require("./functions/complex.dispatch");
+const dispatch_8 = require("../math/dispatch");
+const dispatch_9 = require("../solve/dispatch");
+/**
+ * Registers the complete Nerdamer parser function surface.
+ *
+ * Core parser modules do not import higher-level mathematical domains. Entry points
+ * and consumers that require the complete Nerdamer notation surface call this registration function.
+ */
+function registerNerdamerFunctions() {
+    (0, dispatch_6.loadScriptingFunctions)();
+    (0, dispatch_3.loadAssumptionFunctions)();
+    (0, dispatch_4.loadMatrixFunctions)();
+    (0, dispatch_7.loadVectorFunctions)();
+    (0, complex_dispatch_1.loadComplexFunctions)();
+    (0, dispatch_5.loadPolynomialFunctions)();
+    (0, dispatch_8.loadMathFunctions)();
+    (0, dispatch_1.loadAlgebraFunctions)();
+    (0, dispatch_2.loadCalculusFunctions)();
+    (0, dispatch_9.loadSolveFunctions)();
+}

package/output/core/functions/bigint/bigint.d.ts

@@ -0,0 +1,133 @@
+/**
+ * Returns the absolute value of a bigint
+ *
+ * @param x
+ * @returns
+ */
+export declare function abs(x: bigint): bigint;
+/**
+ * Returns an array with unique values, sorted, and in reverse order.
+ *
+ * @param array
+ * @returns
+ */
+export declare function uniqueSortedArray(array: bigint[]): bigint[];
+/**
+ * Calculates the gcd of a set of bigints
+ *
+ * @returns
+ */
+export declare function GCD(...args: bigint[]): bigint;
+/**
+ * Calculates the LCM of a set of bigints
+ *
+ * @param args
+ */
+export declare function LCM(...args: bigint[]): bigint;
+/**
+ * Simplifies a ratio of two bigints
+ *
+ * @param numerator
+ * @param denominator
+ * @returns
+ */
+export declare function simplifyRatio(numerator: bigint, denominator: bigint): [bigint, bigint];
+/**
+ * Converts a decimal number to a rational
+ *
+ * @param numStr
+ * @returns
+ */
+export declare function convert(numStr: string): [bigint, bigint];
+/**
+ * Returns the sign of a bigint
+ *
+ * @param n
+ * @returns -1 if negative and 1 for positive and 0 for zero
+ */
+export declare function sign(n: bigint): 0 | 1 | -1;
+/**
+ * Checks if a bigint is an even number
+ *
+ * @param n
+ * @returns
+ */
+export declare function isEven(n: bigint): boolean;
+/**
+ * Returns the floor of the exact square root of a non-negative bigint.
+ */
+export declare function integerSquareRoot(value: bigint): bigint;
+/** Returns the least bigint whose square is at least value. */
+export declare function ceilIntegerSquareRoot(value: bigint): bigint;
+/**
+ * Computes the nth Fibonacci number exactly using fast doubling.
+ *
+ * Negative indices use the negafibonacci identity F(-n) = (-1)^(n+1)F(n).
+ *
+ * @param n - Integer index.
+ * @returns The exact Fibonacci number.
+ */
+export declare function fibonacci(n: bigint): bigint;
+/**
+ * The big number version
+ */
+export declare const factorial: (n: number | bigint) => bigint;
+/**
+ * Calculates the modulo of two numbers
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare function mod(a: bigint, b: bigint): bigint;
+/**
+ * Raises a bigint base to a non-negative bigint exponent modulo a positive modulus.
+ *
+ * Binary exponentiation keeps every intermediate value in bigint modular arithmetic.
+ */
+export declare function powMod(base: bigint, exponent: bigint, modulus: bigint): bigint;
+/**
+ * Finds the multiplicative inverse of a modulo m.
+ *
+ * Returns -1 when the inverse does not exist. The extended Euclidean algorithm keeps
+ * the operation exact for bigint inputs without scanning every possible residue.
+ *
+ * @param a
+ * @param m
+ * @returns
+ */
+export declare function invMod(a: bigint, m: bigint): bigint;
+/**
+ * Gets the product given a number range start and finish
+ *
+ * @param start The start of the range
+ * @param end The end of the range
+ * @param step The increment step
+ */
+export declare function productInRange(start: number, end: number, step?: number): bigint;
+/**
+ * Returns the largest of a set of bigints
+ * @param args
+ * @returns
+ */
+export declare function max(...args: bigint[]): bigint;
+/**
+ * Returns the smallest of a set of bigints
+ * @param args
+ * @returns
+ */
+export declare function min(...args: bigint[]): bigint;
+export declare function recoverCoeffsZ(num: bigint, primes: {
+    [variable: string]: bigint;
+}): Record<string, number | bigint>;
+/**
+ * The binomial function using bigint
+ * @param n
+ * @param k
+ * @returns
+ */
+export declare function binom(n: bigint, k: bigint): bigint;
+/**
+ * Computes the LCM of an array of positive bigints.
+ */
+export declare function bigintLCM(values: bigint[]): bigint;