nerdamer 2.0.0-rc.1 → 2.0.0

package/output/core/errors.d.ts

@@ -16,6 +16,9 @@ export declare class OperatorError extends Error {
 /** General parser error for construction, evaluation, and registered-function failures. */
 export declare class ParserError extends Error {
 }
+/** Thrown when evaluation requires a value but a construct produces no value. */
+export declare class NullError extends Error {
+}
 /** Used when a mathematical operation has no defined value in the handled domain. */
 export declare class UndefinedError extends Error {
 }
@@ -50,482 +53,264 @@ export declare class ZeroToZeroPowerError extends Error {
 export declare class AssignmentError extends Error {
 }
 /** Internal localized message templates used when constructing Nerdamer errors. */
-export declare const ErrorMessages: {
-    readonly eng: {
-        readonly notImplemented: "This method has not yet been implemented.";
-        readonly noInverse: "Unable to calculate inverse!";
-        readonly undefinedValue: "The requested value is undefined!";
-        readonly univariateInputOnly: "The input for this function must be univariate!";
-        readonly differentSignsAtEndPointsRequired: "Function must have opposite signs at endpoints a and b!";
-        readonly integerRequired: "This function requires the coefficient to be an integer!";
-        readonly plainVariableExpected: "Expected plain variable! Received {{input}}.";
-        readonly missingReference: "The reference \"{{ref}}\" does not exist on this pattern!!";
-        readonly undefinedDivision: "Division not defined expression of this type! {{type}}";
-        readonly restrictedVariableName: "Cannot assign the requested value to the reserved name \"{{name}}\"!";
-        readonly noVariableInExpression: "No variable found in expression!";
-        readonly quadraticExpressionExpected: "Expression must be quadratic!";
-        readonly wrongInput: "Wrong input! Expected {{expected}} but received {{received}}.";
-        readonly infinityMinusInfinityUndefined: "Infinity-Infinity is undefined!";
-        readonly inconsistentAssumptions: "Assumptions are inconsistent (empty intersection)!";
-        readonly unsupportedType: "The provided type ({{type}}) is not supported for this function!";
-        readonly unsupportedOperation: "This operation is currently not supported!";
-        readonly buildFunctionUnsupportedFunction: "buildFunction cannot compile the function \"{{function}}\" to JavaScript number arithmetic!";
-        readonly buildFunctionComplexUnsupported: "buildFunction cannot compile expressions containing the imaginary unit to JavaScript number arithmetic!";
-        readonly nonMatchingDimensions: "This operation cannot be completed because the dimensions don't match!";
-        readonly malformedExpression: "Unable to parse malformed expression!";
-        readonly divisionByZero: "Division by zero is not defined!";
-        readonly zeroToZeroPower: "0^0 is undefined!";
-        readonly infinityToPowerZero: "Infinity^0 is not defined!";
-        readonly infinityTimesZero: "0*Infinity is not defined!";
-        readonly infinityToInfinity: "Infinity^Infinity is not defined!";
-        readonly valueToInfinityUndefined: "{{value}}^Infinity is not defined!";
-        readonly atan2Undefined: "atan2 is undefined for 0, 0!";
-        readonly tanUndefined: "tan is undefined for multiples of pi/2!";
-        readonly loopIterationLimitExceeded: "Loop exceeded the maximum of {{max}} iterations.";
-        readonly breakOutsideLoop: "break can only be used inside a loop.";
-        readonly continueOutsideLoop: "continue can only be used inside a loop.";
-        readonly letRequiresBindingsAndBody: "let requires one or more name/value pairs followed by a body expression.";
-        readonly secUndefined: "sec is undefined for odd multiples of pi/2!";
-        readonly cscUndefined: "csc is undefined for multiples of pi!";
-        readonly cotUndefined: "cot is undefined for multiples of pi!";
-        readonly cothUndefined: "coth is undefined for 0!";
-        readonly cschUndefined: "csch is undefined for 0!";
-        readonly atanhUndefined: "atanh is undefined for 0!";
-        readonly cannotCreateArrayFromNaN: "Cannot create array from NaN!";
-        readonly expressionExpected: "Expression expected!. Received {{type}}!";
-        readonly unrecognizedMode: "\"{{mode}}\" is is not a valid mode!";
-        readonly notAPolynomial: "The expression is not a valid polynomial!";
-        readonly multidegreeMismatch: "The number of variables must match the multidegree of the polynomial!";
-        readonly cannotCreateMatrix: "Unable to create Matrix. Row dimensions do not match!";
-        readonly cannotMultiplyMatrix: "Cannot multiply matrix!";
-        readonly squareMatrixRequired: "The matrix must be square!";
-        readonly rowsMustMatch: "The rows of the matrices must match!";
-        readonly columnsMustMatch: "The columns of the matrices must match!";
-        readonly singularMatrix: "The provided matrix is singular!";
-        readonly matrixExpected: "Matrix expected! Received {{type}}.";
-        readonly mismatchedDimensions: "The dimensions must match for the function \"{{function}}\"!";
-        readonly incorrectCrossDimension: "The cross product is only defined for vectors of dimension 3!";
-        readonly vectorExpected: "Expected Vector! Received {{type}}.";
-        readonly univariatePolynomialOnly: "This function is only supported for univariate polynomials!";
-        readonly unknownVariable: "Unknown variable! \"{{variable}}\"";
-        readonly convergenceFailed: "Failed to converge! {{iters}} iterations were tried.";
-        readonly endPointIsRoot: "End point is root.";
-        readonly zeroDerivative: "The derivative is zero at x = {{x}}. Cannot continue.";
-        readonly tooManyUnknowns: "Too many unknowns!";
-        readonly solveSystemInfiniteSolutions: "This system does not have a finite isolated solution set!";
-        readonly solveSystemPolynomialOnly: "solveSystem currently supports only linear or polynomial systems!";
-        readonly solveSystemNonRationalUnsupported: "This nonlinear polynomial system requires non-rational or non-symbolic solving, which is not yet supported!";
-        readonly setJSFunctionExpectsFunction: "The function parameter when setting a JS function must be of type function!";
-        readonly functionRequiresMinAndMaxArgs: "You must provide a min and max arg when setting the function!";
-    };
-    readonly spa: {
-        readonly notImplemented: "Este método aún no se ha implementado.";
-        readonly noInverse: "Incapaz de calcular inversa!";
-        readonly undefinedValue: "¡El valor solicitado no está definido!";
-        readonly univariateInputOnly: "¡La entrada para esta función debe ser univariada!";
-        readonly differentSignsAtEndPointsRequired: "¡La función debe tener signos opuestos en los puntos extremos a y b!";
-        readonly integerRequired: "¡Esta función requiere que el coeficiente sea un número entero!";
-        readonly plainVariableExpected: "¡Se esperaba una variable simple! Se recibió {{input}}.";
-        readonly missingReference: "¡La referencia \"{{ref}}\" no existe en este patrón!";
-        readonly undefinedDivision: "¡División no definida expresión de este tipo! {{type}}";
-        readonly restrictedVariableName: "¡No se puede asignar el valor solicitado al nombre reservado \"{{name}}\"!";
-        readonly noVariableInExpression: "¡No se encontró ninguna variable en la expresión!";
-        readonly quadraticExpressionExpected: "¡La expresión debe ser cuadrática!";
-        readonly wrongInput: "¡Entrada incorrecta! Se esperaba {{expected}}, pero se recibió {{received}}.";
-        readonly infinityMinusInfinityUndefined: "¡Infinito menos infinito es indefinido!";
-        readonly inconsistentAssumptions: "¡Las suposiciones son inconsistentes (intersección vacía)!";
-        readonly unsupportedType: "¡El tipo ({{type}}) proporcionado no es compatible con esta función!";
-        readonly unsupportedOperation: "¡Esta operación no está soportada actualmente!";
-        readonly buildFunctionUnsupportedFunction: "¡buildFunction no puede compilar la función \"{{function}}\" a aritmética numérica de JavaScript!";
-        readonly buildFunctionComplexUnsupported: "¡buildFunction no puede compilar expresiones que contienen la unidad imaginaria a aritmética numérica de JavaScript!";
-        readonly nonMatchingDimensions: "¡Esta operación no se puede completar porque las dimensiones no coinciden!";
-        readonly malformedExpression: "¡No se puede analizar la expresión malformada!";
-        readonly divisionByZero: "¡La división por cero no está definida!";
-        readonly zeroToZeroPower: "¡0^0 no está definido!";
-        readonly infinityToPowerZero: "¡Infinito^0 no está definido!";
-        readonly infinityTimesZero: "¡0*Infinito no está definido!";
-        readonly infinityToInfinity: "¡Infinito^Infinito no está definido!";
-        readonly valueToInfinityUndefined: "{{value}}^Infinito no está definido!";
-        readonly atan2Undefined: "¡atan2 no está definida para 0, 0!";
-        readonly tanUndefined: "¡tan no está definida para múltiplos de pi / 2!";
-        readonly loopIterationLimitExceeded: "El bucle superó el máximo de {{max}} iteraciones.";
-        readonly breakOutsideLoop: "break solo se puede usar dentro de un bucle.";
-        readonly continueOutsideLoop: "continue solo se puede usar dentro de un bucle.";
-        readonly letRequiresBindingsAndBody: "let requiere uno o más pares nombre/valor seguidos de una expresión de cuerpo.";
-        readonly secUndefined: "¡sec no está definida para múltiplos impares de pi/2!";
-        readonly cscUndefined: "¡csc no está definida para múltiplos de pi!";
-        readonly cotUndefined: "¡cot no está definida para múltiplos de pi!";
-        readonly cothUndefined: "¡coth no está definida para 0!";
-        readonly cschUndefined: "¡csch no está definida para 0!";
-        readonly atanhUndefined: "¡Atanh no está definida para 0!";
-        readonly cannotCreateArrayFromNaN: "¡No se puede crear una matriz de NaN!";
-        readonly expressionExpected: "¡Se esperaba Expression! ¡Se recibió {{type}}!";
-        readonly unrecognizedMode: "¡{{mode}} no es un modo válido!";
-        readonly notAPolynomial: "¡La expresión no es un polinomio válido!";
-        readonly multidegreeMismatch: "¡El número de variables debe coincidir con el multigrado del polinomio!";
-        readonly unknownVariable: "¡Variable desconocida! \"{{variable}}\"";
-        readonly cannotCreateMatrix: "No se puede crear la matriz. ¡Las dimensiones de las filas no coinciden!";
-        readonly cannotMultiplyMatrix: "¡No se puede multiplicar la matriz!";
-        readonly squareMatrixRequired: "¡La matriz debe ser cuadrada!";
-        readonly rowsMustMatch: "¡Las filas de las matrices deben coincidir!";
-        readonly columnsMustMatch: "¡Las columnas de las matrices deben coincidir!";
-        readonly singularMatrix: "¡La matriz proporcionada es singular!";
-        readonly matrixExpected: "¡Matriz esperada! Se recibió {{type}}.";
-        readonly mismatchedDimensions: "¡Las dimensiones deben coincidir para la función \"{{function}}\"!";
-        readonly incorrectCrossDimension: "¡El producto vectorial sólo está definido para vectores de dimensión 3!";
-        readonly vectorExpected: "¡Vector esperado! Recibido. {{type}}.";
-        readonly univariatePolynomialOnly: "¡Esta función solo es compatible con polinomios univariados!";
-        readonly convergenceFailed: "¡No se logró la convergencia! Se intentaron {{iters}} iteraciones.";
-        readonly endPointIsRoot: "El punto final es la raíz.";
-        readonly zeroDerivative: "La derivada es cero en x = {{x}}. No se puede continuar.";
-        readonly tooManyUnknowns: "¡Demasiadas incógnitas!";
-        readonly solveSystemInfiniteSolutions: "¡Este sistema no tiene un conjunto finito de soluciones aisladas!";
-        readonly solveSystemPolynomialOnly: "¡solveSystem actualmente solo admite sistemas lineales o polinómicos!";
-        readonly solveSystemNonRationalUnsupported: "¡Este sistema polinómico no lineal requiere resolución no racional o no simbólica, lo cual aún no está soportado!";
-        readonly setJSFunctionExpectsFunction: "¡El parámetro de la función, al configurar una función JS, debe ser de tipo función!";
-        readonly functionRequiresMinAndMaxArgs: "¡Debes proporcionar los argumentos mínimo y máximo al configurar la función!";
-    };
-    readonly fra: {
-        readonly notImplemented: "Cette méthode n'a pas encore été implémentée.";
-        readonly noInverse: "Impossible de calculer l'inverse !";
-        readonly undefinedValue: "La valeur demandée n'est pas définie !";
-        readonly univariateInputOnly: "L'entrée de cette fonction doit être univariée !";
-        readonly differentSignsAtEndPointsRequired: "La fonction doit avoir des signes opposés aux extrémités a et b !";
-        readonly integerRequired: "Cette fonction exige que le coefficient soit un entier !";
-        readonly plainVariableExpected: "Une variable simple était attendue ! Reçu : {{input}}.";
-        readonly missingReference: "La référence « {{ref}} » n'existe pas dans ce modèle !";
-        readonly undefinedDivision: "La division n'est pas définie pour une expression de ce type ! {{type}}";
-        readonly restrictedVariableName: "Impossible d'affecter la valeur demandée au nom réservé « {{name}} » !";
-        readonly noVariableInExpression: "Aucune variable n'a été trouvée dans l'expression !";
-        readonly quadraticExpressionExpected: "L'expression doit être quadratique !";
-        readonly wrongInput: "Entrée incorrecte ! {{expected}} était attendu, mais {{received}} a été reçu.";
-        readonly infinityMinusInfinityUndefined: "Infini moins infini n'est pas défini !";
-        readonly inconsistentAssumptions: "Les hypothèses sont incohérentes (intersection vide) !";
-        readonly unsupportedType: "Le type fourni ({{type}}) n'est pas pris en charge par cette fonction !";
-        readonly unsupportedOperation: "Cette opération n'est actuellement pas prise en charge !";
-        readonly buildFunctionUnsupportedFunction: "buildFunction ne peut pas compiler la fonction « {{function}} » en arithmétique numérique JavaScript !";
-        readonly buildFunctionComplexUnsupported: "buildFunction ne peut pas compiler les expressions contenant l'unité imaginaire en arithmétique numérique JavaScript !";
-        readonly nonMatchingDimensions: "Cette opération ne peut pas être effectuée car les dimensions ne correspondent pas !";
-        readonly malformedExpression: "Impossible d'analyser l'expression mal formée !";
-        readonly divisionByZero: "La division par zéro n'est pas définie !";
-        readonly zeroToZeroPower: "0^0 n'est pas défini !";
-        readonly infinityToPowerZero: "Infini^0 n'est pas défini !";
-        readonly infinityTimesZero: "0*Infini n'est pas défini !";
-        readonly infinityToInfinity: "Infini^Infini n'est pas défini !";
-        readonly valueToInfinityUndefined: "{{value}}^Infini n'est pas défini !";
-        readonly atan2Undefined: "atan2 n'est pas définie pour 0, 0 !";
-        readonly tanUndefined: "tan n'est pas définie pour les multiples de pi/2 !";
-        readonly loopIterationLimitExceeded: "La boucle a dépassé le maximum de {{max}} itérations.";
-        readonly breakOutsideLoop: "break ne peut être utilisé qu'à l'intérieur d'une boucle.";
-        readonly continueOutsideLoop: "continue ne peut être utilisé qu'à l'intérieur d'une boucle.";
-        readonly letRequiresBindingsAndBody: "let exige une ou plusieurs paires nom/valeur suivies d’une expression de corps.";
-        readonly secUndefined: "sec n'est pas définie pour les multiples impairs de pi/2 !";
-        readonly cscUndefined: "csc n'est pas définie pour les multiples de pi !";
-        readonly cotUndefined: "cot n'est pas définie pour les multiples de pi !";
-        readonly cothUndefined: "coth n'est pas définie pour 0 !";
-        readonly cschUndefined: "csch n'est pas définie pour 0 !";
-        readonly atanhUndefined: "atanh n'est pas définie pour 0 !";
-        readonly cannotCreateArrayFromNaN: "Impossible de créer un tableau à partir de NaN !";
-        readonly expressionExpected: "Une expression était attendue ! Reçu : {{type}} !";
-        readonly unrecognizedMode: "« {{mode}} » n’est pas un mode valide !";
-        readonly notAPolynomial: "L'expression n'est pas un polynôme valide !";
-        readonly multidegreeMismatch: "Le nombre de variables doit correspondre au multidegré du polynôme !";
-        readonly unknownVariable: "Variable inconnue ! « {{variable}} »";
-        readonly cannotCreateMatrix: "Impossible de créer la matrice. Les dimensions des lignes ne correspondent pas !";
-        readonly cannotMultiplyMatrix: "Impossible de multiplier la matrice !";
-        readonly squareMatrixRequired: "La matrice doit être carrée !";
-        readonly rowsMustMatch: "Les lignes des matrices doivent correspondre !";
-        readonly columnsMustMatch: "Les colonnes des matrices doivent correspondre !";
-        readonly singularMatrix: "La matrice fournie est singulière !";
-        readonly matrixExpected: "Une matrice était attendue ! Reçu : {{type}}.";
-        readonly mismatchedDimensions: "Les dimensions doivent correspondre pour la fonction « {{function}} » !";
-        readonly incorrectCrossDimension: "Le produit vectoriel est défini uniquement pour les vecteurs de dimension 3 !";
-        readonly vectorExpected: "Un vecteur était attendu ! Reçu : {{type}}.";
-        readonly univariatePolynomialOnly: "Cette fonction est prise en charge uniquement pour les polynômes univariés !";
-        readonly convergenceFailed: "Échec de la convergence ! {{iters}} itérations ont été tentées.";
-        readonly endPointIsRoot: "Le point d'extrémité est une racine.";
-        readonly zeroDerivative: "La dérivée est nulle en x = {{x}}. Impossible de continuer.";
-        readonly tooManyUnknowns: "Trop d'inconnues !";
-        readonly solveSystemInfiniteSolutions: "Ce système ne possède pas un ensemble fini de solutions isolées !";
-        readonly solveSystemPolynomialOnly: "solveSystem prend actuellement en charge uniquement les systèmes linéaires ou polynomiaux !";
-        readonly solveSystemNonRationalUnsupported: "Ce système polynomial non linéaire nécessite une résolution non rationnelle ou non symbolique, qui n’est pas encore prise en charge !";
-        readonly setJSFunctionExpectsFunction: "Le paramètre function lors de la définition d’une fonction JS doit être de type function !";
-        readonly functionRequiresMinAndMaxArgs: "Vous devez fournir un nombre minimal et maximal d’arguments lors de la définition de la fonction !";
-    };
-    readonly deu: {
-        readonly notImplemented: "Diese Methode wurde noch nicht implementiert.";
-        readonly noInverse: "Die Inverse konnte nicht berechnet werden!";
-        readonly undefinedValue: "Der angeforderte Wert ist nicht definiert!";
-        readonly univariateInputOnly: "Die Eingabe für diese Funktion muss univariat sein!";
-        readonly differentSignsAtEndPointsRequired: "Die Funktion muss an den Endpunkten a und b unterschiedliche Vorzeichen haben!";
-        readonly integerRequired: "Für diese Funktion muss der Koeffizient eine ganze Zahl sein!";
-        readonly plainVariableExpected: "Eine einfache Variable wurde erwartet! Erhalten: {{input}}.";
-        readonly missingReference: "Die Referenz „{{ref}}“ existiert in diesem Muster nicht!";
-        readonly undefinedDivision: "Division ist für einen Ausdruck dieses Typs nicht definiert! {{type}}";
-        readonly restrictedVariableName: "Der angeforderte Wert kann dem reservierten Namen „{{name}}“ nicht zugewiesen werden!";
-        readonly noVariableInExpression: "Im Ausdruck wurde keine Variable gefunden!";
-        readonly quadraticExpressionExpected: "Der Ausdruck muss quadratisch sein!";
-        readonly wrongInput: "Falsche Eingabe! Erwartet wurde {{expected}}, erhalten wurde {{received}}.";
-        readonly infinityMinusInfinityUndefined: "Unendlich minus Unendlich ist nicht definiert!";
-        readonly inconsistentAssumptions: "Die Annahmen sind widersprüchlich (leere Schnittmenge)!";
-        readonly unsupportedType: "Der angegebene Typ ({{type}}) wird von dieser Funktion nicht unterstützt!";
-        readonly unsupportedOperation: "Diese Operation wird derzeit nicht unterstützt!";
-        readonly buildFunctionUnsupportedFunction: "buildFunction kann die Funktion „{{function}}“ nicht in JavaScript-Zahlenarithmetik kompilieren!";
-        readonly buildFunctionComplexUnsupported: "buildFunction kann Ausdrücke mit der imaginären Einheit nicht in JavaScript-Zahlenarithmetik kompilieren!";
-        readonly nonMatchingDimensions: "Diese Operation kann nicht ausgeführt werden, weil die Dimensionen nicht übereinstimmen!";
-        readonly malformedExpression: "Der fehlerhafte Ausdruck konnte nicht geparst werden!";
-        readonly divisionByZero: "Division durch null ist nicht definiert!";
-        readonly zeroToZeroPower: "0^0 ist nicht definiert!";
-        readonly infinityToPowerZero: "Unendlich^0 ist nicht definiert!";
-        readonly infinityTimesZero: "0*Unendlich ist nicht definiert!";
-        readonly infinityToInfinity: "Unendlich^Unendlich ist nicht definiert!";
-        readonly valueToInfinityUndefined: "{{value}}^Unendlich ist nicht definiert!";
-        readonly atan2Undefined: "atan2 ist für 0, 0 nicht definiert!";
-        readonly tanUndefined: "tan ist für Vielfache von pi/2 nicht definiert!";
-        readonly loopIterationLimitExceeded: "Die Schleife hat das Maximum von {{max}} Iterationen überschritten.";
-        readonly breakOutsideLoop: "break kann nur innerhalb einer Schleife verwendet werden.";
-        readonly continueOutsideLoop: "continue kann nur innerhalb einer Schleife verwendet werden.";
-        readonly letRequiresBindingsAndBody: "let benötigt ein oder mehrere Name/Wert-Paare, gefolgt von einem Ausdrucksrumpf.";
-        readonly secUndefined: "sec ist für ungerade Vielfache von pi/2 nicht definiert!";
-        readonly cscUndefined: "csc ist für Vielfache von pi nicht definiert!";
-        readonly cotUndefined: "cot ist für Vielfache von pi nicht definiert!";
-        readonly cothUndefined: "coth ist für 0 nicht definiert!";
-        readonly cschUndefined: "csch ist für 0 nicht definiert!";
-        readonly atanhUndefined: "atanh ist für 0 nicht definiert!";
-        readonly cannotCreateArrayFromNaN: "Aus NaN kann kein Array erstellt werden!";
-        readonly expressionExpected: "Ein Ausdruck wurde erwartet! Erhalten: {{type}}!";
-        readonly unrecognizedMode: "„{{mode}}“ ist kein gültiger Modus!";
-        readonly notAPolynomial: "Der Ausdruck ist kein gültiges Polynom!";
-        readonly multidegreeMismatch: "Die Anzahl der Variablen muss mit dem Multigrad des Polynoms übereinstimmen!";
-        readonly unknownVariable: "Unbekannte Variable! „{{variable}}“";
-        readonly cannotCreateMatrix: "Die Matrix kann nicht erstellt werden. Die Zeilendimensionen stimmen nicht überein!";
-        readonly cannotMultiplyMatrix: "Die Matrix kann nicht multipliziert werden!";
-        readonly squareMatrixRequired: "Die Matrix muss quadratisch sein!";
-        readonly rowsMustMatch: "Die Zeilen der Matrizen müssen übereinstimmen!";
-        readonly columnsMustMatch: "Die Spalten der Matrizen müssen übereinstimmen!";
-        readonly singularMatrix: "Die angegebene Matrix ist singulär!";
-        readonly matrixExpected: "Eine Matrix wurde erwartet! Erhalten: {{type}}.";
-        readonly mismatchedDimensions: "Die Dimensionen müssen für die Funktion „{{function}}“ übereinstimmen!";
-        readonly incorrectCrossDimension: "Das Kreuzprodukt ist nur für Vektoren der Dimension 3 definiert!";
-        readonly vectorExpected: "Ein Vektor wurde erwartet! Erhalten: {{type}}.";
-        readonly univariatePolynomialOnly: "Diese Funktion wird nur für univariate Polynome unterstützt!";
-        readonly convergenceFailed: "Keine Konvergenz! {{iters}} Iterationen wurden versucht.";
-        readonly endPointIsRoot: "Der Endpunkt ist eine Nullstelle.";
-        readonly zeroDerivative: "Die Ableitung ist bei x = {{x}} null. Fortsetzung nicht möglich.";
-        readonly tooManyUnknowns: "Zu viele Unbekannte!";
-        readonly solveSystemInfiniteSolutions: "Dieses System besitzt keine endliche Menge isolierter Lösungen!";
-        readonly solveSystemPolynomialOnly: "solveSystem unterstützt derzeit nur lineare oder polynomielle Systeme!";
-        readonly solveSystemNonRationalUnsupported: "Dieses nichtlineare polynomielle System erfordert eine nicht rationale oder nicht symbolische Lösung, die noch nicht unterstützt wird!";
-        readonly setJSFunctionExpectsFunction: "Der Funktionsparameter muss beim Festlegen einer JS-Funktion vom Typ function sein!";
-        readonly functionRequiresMinAndMaxArgs: "Beim Festlegen der Funktion müssen minimale und maximale Argumentanzahl angegeben werden!";
-    };
-    readonly por: {
-        readonly notImplemented: "Este método ainda não foi implementado.";
-        readonly noInverse: "Não foi possível calcular a inversa!";
-        readonly undefinedValue: "O valor solicitado não está definido!";
-        readonly univariateInputOnly: "A entrada desta função deve ser univariada!";
-        readonly differentSignsAtEndPointsRequired: "A função deve ter sinais opostos nos pontos extremos a e b!";
-        readonly integerRequired: "Esta função exige que o coeficiente seja um número inteiro!";
-        readonly plainVariableExpected: "Era esperada uma variável simples! Recebido: {{input}}.";
-        readonly missingReference: "A referência \"{{ref}}\" não existe neste padrão!";
-        readonly undefinedDivision: "A divisão não está definida para uma expressão deste tipo! {{type}}";
-        readonly restrictedVariableName: "Não é possível atribuir o valor solicitado ao nome reservado \"{{name}}\"!";
-        readonly noVariableInExpression: "Nenhuma variável foi encontrada na expressão!";
-        readonly quadraticExpressionExpected: "A expressão deve ser quadrática!";
-        readonly wrongInput: "Entrada incorreta! Esperado {{expected}}, mas recebido {{received}}.";
-        readonly infinityMinusInfinityUndefined: "Infinito menos infinito não está definido!";
-        readonly inconsistentAssumptions: "As suposições são inconsistentes (interseção vazia)!";
-        readonly unsupportedType: "O tipo fornecido ({{type}}) não é compatível com esta função!";
-        readonly unsupportedOperation: "Esta operação não é suportada atualmente!";
-        readonly buildFunctionUnsupportedFunction: "buildFunction não pode compilar a função \"{{function}}\" para aritmética numérica JavaScript!";
-        readonly buildFunctionComplexUnsupported: "buildFunction não pode compilar expressões que contêm a unidade imaginária para aritmética numérica JavaScript!";
-        readonly nonMatchingDimensions: "Esta operação não pode ser concluída porque as dimensões não correspondem!";
-        readonly malformedExpression: "Não foi possível analisar a expressão malformada!";
-        readonly divisionByZero: "A divisão por zero não está definida!";
-        readonly zeroToZeroPower: "0^0 não está definido!";
-        readonly infinityToPowerZero: "Infinito^0 não está definido!";
-        readonly infinityTimesZero: "0*Infinito não está definido!";
-        readonly infinityToInfinity: "Infinito^Infinito não está definido!";
-        readonly valueToInfinityUndefined: "{{value}}^Infinito não está definido!";
-        readonly atan2Undefined: "atan2 não está definida para 0, 0!";
-        readonly tanUndefined: "tan não está definida para múltiplos de pi/2!";
-        readonly loopIterationLimitExceeded: "O laço excedeu o máximo de {{max}} iterações.";
-        readonly breakOutsideLoop: "break só pode ser usado dentro de um laço.";
-        readonly continueOutsideLoop: "continue só pode ser usado dentro de um laço.";
-        readonly letRequiresBindingsAndBody: "let exige um ou mais pares nome/valor seguidos de uma expressão de corpo.";
-        readonly secUndefined: "sec não está definida para múltiplos ímpares de pi/2!";
-        readonly cscUndefined: "csc não está definida para múltiplos de pi!";
-        readonly cotUndefined: "cot não está definida para múltiplos de pi!";
-        readonly cothUndefined: "coth não está definida para 0!";
-        readonly cschUndefined: "csch não está definida para 0!";
-        readonly atanhUndefined: "atanh não está definida para 0!";
-        readonly cannotCreateArrayFromNaN: "Não é possível criar um array a partir de NaN!";
-        readonly expressionExpected: "Era esperada uma expressão! Recebido: {{type}}!";
-        readonly unrecognizedMode: "\"{{mode}}\" não é um modo válido!";
-        readonly notAPolynomial: "A expressão não é um polinômio válido!";
-        readonly multidegreeMismatch: "O número de variáveis deve corresponder ao multigrau do polinômio!";
-        readonly unknownVariable: "Variável desconhecida! \"{{variable}}\"";
-        readonly cannotCreateMatrix: "Não foi possível criar a matriz. As dimensões das linhas não correspondem!";
-        readonly cannotMultiplyMatrix: "Não é possível multiplicar a matriz!";
-        readonly squareMatrixRequired: "A matriz deve ser quadrada!";
-        readonly rowsMustMatch: "As linhas das matrizes devem corresponder!";
-        readonly columnsMustMatch: "As colunas das matrizes devem corresponder!";
-        readonly singularMatrix: "A matriz fornecida é singular!";
-        readonly matrixExpected: "Era esperada uma matriz! Recebido: {{type}}.";
-        readonly mismatchedDimensions: "As dimensões devem corresponder para a função \"{{function}}\"!";
-        readonly incorrectCrossDimension: "O produto vetorial só é definido para vetores de dimensão 3!";
-        readonly vectorExpected: "Era esperado um vetor! Recebido: {{type}}.";
-        readonly univariatePolynomialOnly: "Esta função é suportada apenas para polinômios univariados!";
-        readonly convergenceFailed: "Falha na convergência! Foram tentadas {{iters}} iterações.";
-        readonly endPointIsRoot: "O ponto extremo é uma raiz.";
-        readonly zeroDerivative: "A derivada é zero em x = {{x}}. Não é possível continuar.";
-        readonly tooManyUnknowns: "Muitas incógnitas!";
-        readonly solveSystemInfiniteSolutions: "Este sistema não possui um conjunto finito de soluções isoladas!";
-        readonly solveSystemPolynomialOnly: "solveSystem atualmente suporta apenas sistemas lineares ou polinomiais!";
-        readonly solveSystemNonRationalUnsupported: "Este sistema polinomial não linear exige resolução não racional ou não simbólica, que ainda não é suportada!";
-        readonly setJSFunctionExpectsFunction: "O parâmetro da função, ao definir uma função JS, deve ser do tipo function!";
-        readonly functionRequiresMinAndMaxArgs: "É necessário fornecer os números mínimo e máximo de argumentos ao definir a função!";
-    };
-    readonly ita: {
-        readonly notImplemented: "Questo metodo non è ancora stato implementato.";
-        readonly noInverse: "Impossibile calcolare l’inversa!";
-        readonly undefinedValue: "Il valore richiesto non è definito!";
-        readonly univariateInputOnly: "L’input di questa funzione deve essere univariato!";
-        readonly differentSignsAtEndPointsRequired: "La funzione deve avere segni opposti agli estremi a e b!";
-        readonly integerRequired: "Questa funzione richiede che il coefficiente sia un numero intero!";
-        readonly plainVariableExpected: "Era attesa una variabile semplice! Ricevuto: {{input}}.";
-        readonly missingReference: "Il riferimento \"{{ref}}\" non esiste in questo modello!";
-        readonly undefinedDivision: "La divisione non è definita per un’espressione di questo tipo! {{type}}";
-        readonly restrictedVariableName: "Impossibile assegnare il valore richiesto al nome riservato \"{{name}}\"!";
-        readonly noVariableInExpression: "Nessuna variabile trovata nell’espressione!";
-        readonly quadraticExpressionExpected: "L’espressione deve essere quadratica!";
-        readonly wrongInput: "Input errato! Atteso {{expected}}, ricevuto {{received}}.";
-        readonly infinityMinusInfinityUndefined: "Infinito meno infinito non è definito!";
-        readonly inconsistentAssumptions: "Le ipotesi sono incoerenti (intersezione vuota)!";
-        readonly unsupportedType: "Il tipo fornito ({{type}}) non è supportato da questa funzione!";
-        readonly unsupportedOperation: "Questa operazione non è attualmente supportata!";
-        readonly buildFunctionUnsupportedFunction: "buildFunction non può compilare la funzione \"{{function}}\" nell’aritmetica numerica JavaScript!";
-        readonly buildFunctionComplexUnsupported: "buildFunction non può compilare espressioni contenenti l’unità immaginaria nell’aritmetica numerica JavaScript!";
-        readonly nonMatchingDimensions: "Questa operazione non può essere completata perché le dimensioni non corrispondono!";
-        readonly malformedExpression: "Impossibile analizzare l’espressione non valida!";
-        readonly divisionByZero: "La divisione per zero non è definita!";
-        readonly zeroToZeroPower: "0^0 non è definito!";
-        readonly infinityToPowerZero: "Infinito^0 non è definito!";
-        readonly infinityTimesZero: "0*Infinito non è definito!";
-        readonly infinityToInfinity: "Infinito^Infinito non è definito!";
-        readonly valueToInfinityUndefined: "{{value}}^Infinito non è definito!";
-        readonly atan2Undefined: "atan2 non è definita per 0, 0!";
-        readonly tanUndefined: "tan non è definita per multipli di pi/2!";
-        readonly loopIterationLimitExceeded: "Il ciclo ha superato il massimo di {{max}} iterazioni.";
-        readonly breakOutsideLoop: "break può essere usato solo all’interno di un ciclo.";
-        readonly continueOutsideLoop: "continue può essere usato solo all’interno di un ciclo.";
-        readonly letRequiresBindingsAndBody: "let richiede una o più coppie nome/valore seguite da un’espressione corpo.";
-        readonly secUndefined: "sec non è definita per multipli dispari di pi/2!";
-        readonly cscUndefined: "csc non è definita per multipli di pi!";
-        readonly cotUndefined: "cot non è definita per multipli di pi!";
-        readonly cothUndefined: "coth non è definita per 0!";
-        readonly cschUndefined: "csch non è definita per 0!";
-        readonly atanhUndefined: "atanh non è definita per 0!";
-        readonly cannotCreateArrayFromNaN: "Impossibile creare un array da NaN!";
-        readonly expressionExpected: "Era attesa un’espressione! Ricevuto: {{type}}!";
-        readonly unrecognizedMode: "\"{{mode}}\" non è una modalità valida!";
-        readonly notAPolynomial: "L’espressione non è un polinomio valido!";
-        readonly multidegreeMismatch: "Il numero di variabili deve corrispondere al multigrado del polinomio!";
-        readonly unknownVariable: "Variabile sconosciuta! \"{{variable}}\"";
-        readonly cannotCreateMatrix: "Impossibile creare la matrice. Le dimensioni delle righe non corrispondono!";
-        readonly cannotMultiplyMatrix: "Impossibile moltiplicare la matrice!";
-        readonly squareMatrixRequired: "La matrice deve essere quadrata!";
-        readonly rowsMustMatch: "Le righe delle matrici devono corrispondere!";
-        readonly columnsMustMatch: "Le colonne delle matrici devono corrispondere!";
-        readonly singularMatrix: "La matrice fornita è singolare!";
-        readonly matrixExpected: "Era attesa una matrice! Ricevuto: {{type}}.";
-        readonly mismatchedDimensions: "Le dimensioni devono corrispondere per la funzione \"{{function}}\"!";
-        readonly incorrectCrossDimension: "Il prodotto vettoriale è definito solo per vettori di dimensione 3!";
-        readonly vectorExpected: "Era atteso un vettore! Ricevuto: {{type}}.";
-        readonly univariatePolynomialOnly: "Questa funzione è supportata solo per polinomi univariati!";
-        readonly convergenceFailed: "Convergenza non riuscita! Sono state tentate {{iters}} iterazioni.";
-        readonly endPointIsRoot: "Il punto estremo è una radice.";
-        readonly zeroDerivative: "La derivata è zero in x = {{x}}. Impossibile continuare.";
-        readonly tooManyUnknowns: "Troppe incognite!";
-        readonly solveSystemInfiniteSolutions: "Questo sistema non ha un insieme finito di soluzioni isolate!";
-        readonly solveSystemPolynomialOnly: "solveSystem attualmente supporta solo sistemi lineari o polinomiali!";
-        readonly solveSystemNonRationalUnsupported: "Questo sistema polinomiale non lineare richiede una risoluzione non razionale o non simbolica, che non è ancora supportata!";
-        readonly setJSFunctionExpectsFunction: "Il parametro della funzione, quando si imposta una funzione JS, deve essere di tipo function!";
-        readonly functionRequiresMinAndMaxArgs: "È necessario fornire il numero minimo e massimo di argomenti quando si imposta la funzione!";
-    };
-    readonly nld: {
-        readonly notImplemented: "Deze methode is nog niet geïmplementeerd.";
-        readonly noInverse: "Kan de inverse niet berekenen!";
-        readonly undefinedValue: "De gevraagde waarde is niet gedefinieerd!";
-        readonly univariateInputOnly: "De invoer voor deze functie moet univariaat zijn!";
-        readonly differentSignsAtEndPointsRequired: "De functie moet tegengestelde tekens hebben bij de eindpunten a en b!";
-        readonly integerRequired: "Deze functie vereist dat de coëfficiënt een geheel getal is!";
-        readonly plainVariableExpected: "Er werd een eenvoudige variabele verwacht! Ontvangen: {{input}}.";
-        readonly missingReference: "De verwijzing \"{{ref}}\" bestaat niet in dit patroon!";
-        readonly undefinedDivision: "Deling is niet gedefinieerd voor een uitdrukking van dit type! {{type}}";
-        readonly restrictedVariableName: "Kan de gevraagde waarde niet toewijzen aan de gereserveerde naam \"{{name}}\"!";
-        readonly noVariableInExpression: "Geen variabele gevonden in de uitdrukking!";
-        readonly quadraticExpressionExpected: "De uitdrukking moet kwadratisch zijn!";
-        readonly wrongInput: "Onjuiste invoer! Verwacht: {{expected}}, ontvangen: {{received}}.";
-        readonly infinityMinusInfinityUndefined: "Oneindig min oneindig is niet gedefinieerd!";
-        readonly inconsistentAssumptions: "De aannames zijn inconsistent (lege doorsnede)!";
-        readonly unsupportedType: "Het opgegeven type ({{type}}) wordt niet ondersteund voor deze functie!";
-        readonly unsupportedOperation: "Deze bewerking wordt momenteel niet ondersteund!";
-        readonly buildFunctionUnsupportedFunction: "buildFunction kan de functie \"{{function}}\" niet compileren naar JavaScript-rekenkunde met getallen!";
-        readonly buildFunctionComplexUnsupported: "buildFunction kan uitdrukkingen met de imaginaire eenheid niet compileren naar JavaScript-rekenkunde met getallen!";
-        readonly nonMatchingDimensions: "Deze bewerking kan niet worden voltooid omdat de dimensies niet overeenkomen!";
-        readonly malformedExpression: "Kan de onjuist gevormde uitdrukking niet parseren!";
-        readonly divisionByZero: "Delen door nul is niet gedefinieerd!";
-        readonly zeroToZeroPower: "0^0 is niet gedefinieerd!";
-        readonly infinityToPowerZero: "Oneindig^0 is niet gedefinieerd!";
-        readonly infinityTimesZero: "0*Oneindig is niet gedefinieerd!";
-        readonly infinityToInfinity: "Oneindig^Oneindig is niet gedefinieerd!";
-        readonly valueToInfinityUndefined: "{{value}}^Oneindig is niet gedefinieerd!";
-        readonly atan2Undefined: "atan2 is niet gedefinieerd voor 0, 0!";
-        readonly tanUndefined: "tan is niet gedefinieerd voor veelvouden van pi/2!";
-        readonly loopIterationLimitExceeded: "De lus heeft het maximum van {{max}} iteraties overschreden.";
-        readonly breakOutsideLoop: "break kan alleen binnen een lus worden gebruikt.";
-        readonly continueOutsideLoop: "continue kan alleen binnen een lus worden gebruikt.";
-        readonly letRequiresBindingsAndBody: "let vereist een of meer naam/waarde-paren gevolgd door een hoofdexpressie.";
-        readonly secUndefined: "sec is niet gedefinieerd voor oneven veelvouden van pi/2!";
-        readonly cscUndefined: "csc is niet gedefinieerd voor veelvouden van pi!";
-        readonly cotUndefined: "cot is niet gedefinieerd voor veelvouden van pi!";
-        readonly cothUndefined: "coth is niet gedefinieerd voor 0!";
-        readonly cschUndefined: "csch is niet gedefinieerd voor 0!";
-        readonly atanhUndefined: "atanh is niet gedefinieerd voor 0!";
-        readonly cannotCreateArrayFromNaN: "Kan geen array maken van NaN!";
-        readonly expressionExpected: "Er werd een uitdrukking verwacht! Ontvangen: {{type}}!";
-        readonly unrecognizedMode: "\"{{mode}}\" is geen geldige modus!";
-        readonly notAPolynomial: "De uitdrukking is geen geldig polynoom!";
-        readonly multidegreeMismatch: "Het aantal variabelen moet overeenkomen met de multigraad van het polynoom!";
-        readonly unknownVariable: "Onbekende variabele! \"{{variable}}\"";
-        readonly cannotCreateMatrix: "Kan de matrix niet maken. De rijafmetingen komen niet overeen!";
-        readonly cannotMultiplyMatrix: "Kan de matrix niet vermenigvuldigen!";
-        readonly squareMatrixRequired: "De matrix moet vierkant zijn!";
-        readonly rowsMustMatch: "De rijen van de matrices moeten overeenkomen!";
-        readonly columnsMustMatch: "De kolommen van de matrices moeten overeenkomen!";
-        readonly singularMatrix: "De opgegeven matrix is singulier!";
-        readonly matrixExpected: "Er werd een matrix verwacht! Ontvangen: {{type}}.";
-        readonly mismatchedDimensions: "De dimensies moeten overeenkomen voor de functie \"{{function}}\"!";
-        readonly incorrectCrossDimension: "Het kruisproduct is alleen gedefinieerd voor vectoren met dimensie 3!";
-        readonly vectorExpected: "Er werd een vector verwacht! Ontvangen: {{type}}.";
-        readonly univariatePolynomialOnly: "Deze functie wordt alleen ondersteund voor univariate polynomen!";
-        readonly convergenceFailed: "Convergentie mislukt! Er zijn {{iters}} iteraties geprobeerd.";
-        readonly endPointIsRoot: "Het eindpunt is een wortel.";
-        readonly zeroDerivative: "De afgeleide is nul bij x = {{x}}. Kan niet doorgaan.";
-        readonly tooManyUnknowns: "Te veel onbekenden!";
-        readonly solveSystemInfiniteSolutions: "Dit stelsel heeft geen eindige verzameling geïsoleerde oplossingen!";
-        readonly solveSystemPolynomialOnly: "solveSystem ondersteunt momenteel alleen lineaire of polynomiale stelsels!";
-        readonly solveSystemNonRationalUnsupported: "Dit niet-lineaire polynomiale stelsel vereist een niet-rationele of niet-symbolische oplossing, die nog niet wordt ondersteund!";
-        readonly setJSFunctionExpectsFunction: "De functieparameter moet bij het instellen van een JS-functie van het type function zijn!";
-        readonly functionRequiresMinAndMaxArgs: "U moet het minimale en maximale aantal argumenten opgeven bij het instellen van de functie!";
-    };
+export declare const EnglishErrorMessages: {
+    readonly notImplemented: "This method has not yet been implemented.";
+    readonly noInverse: "Unable to calculate inverse!";
+    readonly undefinedValue: "The requested value is undefined!";
+    readonly nullValue: "Value expected but received null.";
+    readonly univariateInputOnly: "The input for this function must be univariate!";
+    readonly differentSignsAtEndPointsRequired: "Function must have opposite signs at endpoints a and b!";
+    readonly integerRequired: "This function requires the coefficient to be an integer!";
+    readonly plainVariableExpected: "Expected plain variable! Received {{input}}.";
+    readonly missingReference: "The reference \"{{ref}}\" does not exist on this pattern!!";
+    readonly undefinedDivision: "Division not defined expression of this type! {{type}}";
+    readonly restrictedVariableName: "Cannot assign the requested value to the reserved name \"{{name}}\"!";
+    readonly noVariableInExpression: "No variable found in expression!";
+    readonly quadraticExpressionExpected: "Expression must be quadratic!";
+    readonly wrongInput: "Wrong input! Expected {{expected}} but received {{received}}.";
+    readonly unsupportedFunction: "Unsupported function {{function}}";
+    readonly functionMinArgs: "{{function}} requires a minimum of {{min}} arguments but {{actual}} provided!";
+    readonly functionMaxArgs: "{{function}} allows a maximum of {{max}} arguments but {{actual}} provided!";
+    readonly invalidFunctionDeclaration: "Invalid function declaration {{declaration}}.";
+    readonly indexOutOfBounds: "Index {{index}} out of bounds for {{type}} of length {{length}}";
+    readonly matrixRowIndexOutOfBounds: "Row index {{index}} out of bounds for Matrix with {{length}} rows";
+    readonly matrixColumnIndexOutOfBounds: "Column index {{index}} out of bounds for Matrix with {{length}} columns";
+    readonly dictionaryKeyNotFound: "Key \"{{key}}\" not found in Dictionary. Available keys: {{keys}}";
+    readonly rangeValuesFinite: "Range values must be finite.";
+    readonly rangeStepNonzero: "Step cannot be zero";
+    readonly rangeStepNoAdvance: "Step does not advance range at current precision";
+    readonly sparseVariableCountInvalid: "SparsePolynomial variableCount must be a non-negative safe integer.";
+    readonly sparseExponentVectorLengthMismatch: "SparsePolynomial exponent vector length must equal variableCount.";
+    readonly sparseExponentsNonNegativeBigInt: "SparsePolynomial exponents must be non-negative bigints.";
+    readonly sparseVariableIndexOutOfRing: "SparsePolynomial variable index is outside the polynomial ring.";
+    readonly sparseAdditionRingMismatch: "SparsePolynomial addition requires the same polynomial ring.";
+    readonly sparseCoefficientExponentNonNegative: "SparsePolynomial coefficient exponent must be non-negative.";
+    readonly sparseZeroMonomialDivision: "SparsePolynomial cannot divide by a zero monomial.";
+    readonly sparseZeroScalarDivision: "SparsePolynomial cannot divide by zero.";
+    readonly sparseScalarDivisionExact: "SparsePolynomial scalar division must be exact for every coefficient.";
+    readonly sparseDivisionRingMismatch: "SparsePolynomial division requires the same polynomial ring.";
+    readonly sparseZeroPolynomialDivision: "SparsePolynomial cannot divide by the zero polynomial.";
+    readonly sparseMonomialOrderUnsupported: "SparsePolynomial monomial order is not supported.";
+    readonly sparseMultiplicationRingMismatch: "SparsePolynomial multiplication requires the same polynomial ring.";
+    readonly sparseExponentNonNegative: "SparsePolynomial exponent must be non-negative.";
+    readonly sparseSubtractionRingMismatch: "SparsePolynomial subtraction requires the same polynomial ring.";
+    readonly invalidDecimal: "Invalid Decimal: \"{{value}}\"";
+    readonly invalidInterval: "Invalid interval: ({{start}}, {{end}})";
+    readonly invalidAssumption: "Invalid assumption: \"{{input}}\"";
+    readonly assumptionIdentifierExpected: "Expected identifier";
+    readonly assumptionOperatorMissing: "Missing operator";
+    readonly assumptionValueMissing: "Missing value";
+    readonly assumptionOperatorUnsupported: "Unsupported operator \"{{operator}}\"";
+    readonly matrixStringKeyUnsupported: "Matrix does not support string key access";
+    readonly matrixTraceUnavailable: "Unable to calculate trace for the matrix";
+    readonly defintMaxEvals: "defint: maxEvals exceeded ({{max}}).";
+    readonly defintNonFiniteValue: "defint: non-finite f(x) at x={{x}}";
+    readonly defintEndpointSingularity: "defint: endpoint singularity could not be regularized near x={{x}}";
+    readonly defintSingularity: "defint: singular/non-finite encountered near [{{a}}, {{b}}]";
+    readonly defintInfiniteBounds: "defint: infinite bounds require allowInfinite: true";
+    readonly defintUnsupportedInfiniteBounds: "defint: unsupported infinite bound configuration";
+    readonly symbolicAccessNamedTargetRequired: "Symbolic indexed access requires a named Vector or Matrix target.";
+    readonly symbolicVectorIndexCount: "Symbolic Vector access requires exactly one index.";
+    readonly symbolicMatrixRowNonScalar: "Symbolic Matrix row access is not scalar and cannot be deferred as an Expression.";
+    readonly symbolicMatrixCellIndexCount: "Symbolic Matrix cell access requires exactly two indices.";
+    readonly symbolicAccessMaxIndices: "Symbolic indexed access supports at most two unresolved indices.";
+    readonly symbolicAccessIndexScalar: "Symbolic accessor indices must evaluate to scalar expressions.";
+    readonly symbolicAccessTargetType: "Symbolic indexed access target must resolve to a Vector or Matrix.";
+    readonly expectedOperatorOrFunction: "Expected operator or function name but \"{{value}}\" found!";
+    readonly missingOpeningBracket: "Missing opening bracket for \"{{bracket}}\":{{position}}";
+    readonly missingClosingBracket: "Missing closing bracket for \"{{bracket}}\":{{position}}";
+    readonly prefixOperatorExpected: "Prefix operator expected but {{operator}} encountered.";
+    readonly groebnerBasisSizeBudgetExceeded: "Groebner budget exceeded: basis size > {{max}}";
+    readonly groebnerPairsBudgetExceeded: "Groebner budget exceeded: pairsPopped > {{max}}";
+    readonly unsupportedParserEntity: "Unsupported parser entity";
+    readonly factorialNegativeUndefined: "Factorial is undefined for negative integers.";
+    readonly erfConvergenceFailed: "erf not converging. Exiting!";
+    readonly defintInfiniteBoundsDecimal: "defint: infinite bounds require allowInfinite:true";
+    readonly seqStartsAtInteger: "startsAt must be an integer";
+    readonly seqPolynomialOrMaxPower: "Sequence is not a polynomial or exceeds maxPower";
+    readonly seqInsufficientData: "Insufficient data points for detected degree";
+    readonly arithPowNegativeExponent: "pow: negative exponent";
+    readonly arithPowNNonnegativeInteger: "powN: exponent must be a nonnegative integer";
+    readonly arithBigIntSqrtNegative: "bigIntSqrt: negative input";
+    readonly arithNthRootPositiveInteger: "intNthRootExact: n must be a positive integer";
+    readonly arithDivisorsPositive: "getDivisors: n must be positive";
+    readonly arithModNormNonzeroModulus: "modNorm: modulus must be nonzero";
+    readonly arithModSymmetricNonzeroModulus: "modSymmetric: modulus must be nonzero";
+    readonly arithModInvZeroNoninvertible: "modInv: non-invertible (0)";
+    readonly arithModInvNoninvertible: "modInv: non-invertible";
+    readonly integerSqrtNonnegative: "Integer square root requires a non-negative value.";
+    readonly modularExponentiationPositiveModulus: "Modular exponentiation requires a positive modulus.";
+    readonly modularExponentiationNonnegativeExponent: "Modular exponentiation requires a non-negative exponent.";
+    readonly maxBigIntRequiresArgument: "maxBigInt() requires at least one argument";
+    readonly minBigIntEmpty: "Min of empty list is not defined for BigInt.";
+    readonly binomBigIntNonnegativeN: "binomBigInt: n must be non-negative";
+    readonly invalidDecimalValue: "Invalid decimal value: {{value}}";
+    readonly subtractionNotDefined: "Subtraction not defined for {{leftType}}-{{rightType}} | {{left}}-{{right}}";
+    readonly sparseAdapterVariablesUnique: "Sparse polynomial adapter variables must be unique.";
+    readonly sparseAdapterVariablesIncludeEvery: "Sparse polynomial adapter variables must include every polynomial variable.";
+    readonly sparseExpressionConversionNameCount: "Sparse polynomial expression conversion requires one name per ring variable.";
+    readonly converterMissingArgumentScope: "Missing argument scope for function {{function}}";
+    readonly converterMissingPrefixOperand: "Missing operand for prefix operator {{operator}}";
+    readonly converterMissingOperandMetadata: "Missing operand or metadata for operator {{operator}}";
+    readonly converterMissingLeftOperand: "Missing left operand for operator {{operator}}";
+    readonly converterTexConversionFailed: "Unable to convert source expression to TeX";
+    readonly unknownOperator: "Unknown operator {{operator}}";
+    readonly polynomialMaximumIterations: "Maximum iterations reached";
+    readonly polyRequires: "{{operation}} requires {{requirement}}.";
+    readonly polyVariablesUnique: "{{operation}} variables must be unique.";
+    readonly polyVariablesRingOrder: "{{operation}} variables must follow polynomial-ring order.";
+    readonly polyVariablesIncludeActive: "{{operation}} variables must include every active variable.";
+    readonly polyInputsSelectedOnly: "{{operation}} inputs may use only the selected variables.";
+    readonly polyCannotFactorZeroPolynomial: "{{operation}} cannot factor the zero polynomial.";
+    readonly polyCannotFactorZero: "{{operation}} cannot factor zero.";
+    readonly polyModulusGreaterThanOne: "ModularSparsePolynomial modulus must be greater than one.";
+    readonly polyVariableCountMatch: "ModularSparsePolynomial variableCount must match the supplied sparse polynomial.";
+    readonly polyInterpolationCannotDepend: "ModularSparsePolynomial interpolation samples cannot depend on the interpolated variable.";
+    readonly polyInterpolationInvertibleDifferences: "ModularSparsePolynomial interpolation points must have invertible pairwise differences.";
+    readonly polyCoefficientExponentNonnegative: "ModularSparsePolynomial coefficient exponent must be non-negative.";
+    readonly polyCannotDivideZero: "ModularSparsePolynomial cannot divide by the zero polynomial.";
+    readonly polyDivisorLeadingCoefficientInvertible: "ModularSparsePolynomial divisor leading coefficient is not invertible.";
+    readonly polyLeadingCoefficientInvertible: "ModularSparsePolynomial leading coefficient is not invertible.";
+    readonly polyExponentNonnegative: "ModularSparsePolynomial exponent must be non-negative.";
+    readonly polyDegreeMatrixLimit: "Modular factorization degree exceeds the supported matrix dimension.";
+    readonly polyExtendedGcdTwoZeroUndefined: "Modular extended GCD is undefined for two zero polynomials.";
+    readonly polyHenselPrimeExceedsTailDegree: "Multivariate Hensel lifting prime must exceed every tail-variable degree.";
+    readonly polyHenselTargetNotSmaller: "Hensel lifting target modulus cannot be smaller than the base prime.";
+    readonly polyHenselTargetRepeatedSquaring: "Hensel lifting target modulus must be obtained by repeated squaring of the base prime.";
+    readonly polyHenselFactorsReconstructModuloBase: "Hensel lifting factors do not reconstruct the integer polynomial modulo the base prime.";
+    readonly polyZassenhausFactorsReconstructModuloLift: "Zassenhaus recombination factors do not reconstruct the input modulo the lift modulus.";
+    readonly polyWangCannotSpecializeZero: "Wang evaluation search cannot specialize zero.";
+    readonly polyModularContentExactDivision: "Modular polynomial content must divide the polynomial exactly.";
+    readonly factorizationNoFactors: "Nonconstant factorization returned no factors.";
+    readonly polyCrtModuliInvertible: "Polynomial CRT moduli must be invertible.";
+    readonly polyIntegerFactorPrimeZero: "Integer factorization cannot choose a prime for zero.";
+    readonly polySquareFreeNonExactDivision: "Square-free factorization encountered a non-exact polynomial division.";
+    readonly polyZassenhausLostRemaining: "Zassenhaus recombination lost the remaining polynomial.";
+    readonly polyZassenhausReconstructionFailed: "Zassenhaus recombination factors do not reconstruct the integer polynomial.";
+    readonly polyIntegerFactorLostLeading: "Integer factorization lost the leading term.";
+    readonly parserMalformedSymbolicAccessor: "Malformed internal symbolic accessor.";
+    readonly parserMalformedSymbolicAccessorIndex: "Malformed internal symbolic accessor index.";
+    readonly unknownOperatorAction: "Unknown operator action {{action}}";
+    readonly parserBracketTokenMissingCharacter: "Bracket token is missing its character.";
+    readonly polyWangLeadingEvaluationInteger: "Wang leading-coefficient evaluation did not produce an integer.";
+    readonly polyWangSpecializedLeadingInteger: "Wang specialized factor did not have an integer leading coefficient.";
+    readonly polyMultivariateContentDivisionFailed: "Multivariate factorization could not divide a square-free block by its main-variable content.";
+    readonly polyMultivariateContentVariableMissing: "Multivariate main-variable content did not retain an active coefficient variable.";
+    readonly polyMultivariateReconstructionFailed: "Complete multivariate factorization does not reconstruct the input polynomial.";
+    readonly polyBerlekampNoninvertiblePivot: "Berlekamp elimination encountered a noninvertible pivot.";
+    readonly polyHenselZeroFactorGroup: "Hensel lifting cannot lift a zero factor group.";
+    readonly polyHenselCannotLiftZero: "Hensel lifting cannot lift the zero polynomial.";
+    readonly polyHenselModulusExceeded: "Hensel lifting exceeded the requested prime-power modulus.";
+    readonly polyHenselLeadingLost: "Hensel lifting lost the target leading coefficient.";
+    readonly polyHenselReconstructionFailed: "Hensel-lifted factors do not reconstruct the target polynomial.";
+    readonly polyBerlekampNonExactSplit: "Berlekamp splitting produced a non-exact factor division.";
+    readonly polyBerlekampIncompleteSplit: "Berlekamp factorization did not fully split the polynomial.";
+    readonly polyBerlekampReconstructionFailed: "Berlekamp factors do not reconstruct the input polynomial.";
+    readonly expressionKeyValueUnsupported: "The function 'keyValue' is not implemented for type {{type}}.";
+    readonly solveLinearNonlinearDegree: "Nonlinear term detected in equation {{equation}}: degree {{degree}} term found. solveLinearSystem only handles linear systems.";
+    readonly solveLinearNonPolynomialVariable: "Nonlinear term detected in equation {{equation}}: variable \"{{variable}}\" appears in a non-polynomial position. solveLinearSystem only handles linear systems.";
+    readonly polyReqPrimeModulus: "a prime modulus";
+    readonly polyReqUnivariatePolynomial: "a univariate polynomial";
+    readonly polyReqSquareFreeInput: "square-free input";
+    readonly polyReqSamePolynomialRing: "the same polynomial ring";
+    readonly polyReqAtLeastOneVariable: "at least one variable";
+    readonly polyReqAtLeastTwoSelectedVariables: "at least two selected variables";
+    readonly polyReqOneEvaluationPerTailVariable: "one evaluation value per tail variable";
+    readonly polyReqMatchingFactorLeadingLists: "matching factor and leading-coefficient lists";
+    readonly polyReqPairwiseCoprimeModularFactors: "pairwise coprime modular factors";
+    readonly polyReqPrimeBaseModulus: "a prime base modulus";
+    readonly polyReqAtLeastOneModularFactor: "at least one modular factor";
+    readonly polyReqUnivariateIntegerPolynomial: "a univariate integer polynomial";
+    readonly polyReqFactorsSameRingAndPrime: "factors from the same integer polynomial ring and base prime";
+    readonly polyReqUnivariateFactors: "univariate factors";
+    readonly polyReqMonicModularFactors: "monic modular factors";
+    readonly polyReqPrimitiveIntegerPolynomial: "a primitive integer polynomial";
+    readonly polyReqPositiveLeadingCoefficient: "a positive leading coefficient";
+    readonly polyReqLiftedModularFactors: "lifted modular factors";
+    readonly polyReqLiftedFactorsSameRing: "lifted factors from one polynomial ring";
+    readonly polyReqUnivariateLiftedFactors: "univariate lifted factors";
+    readonly polyReqMonicLiftedFactors: "monic lifted factors";
+    readonly polyReqLargerHenselModulus: "a larger Hensel lifting modulus";
+    readonly polyReqPrimitivePolynomial: "a primitive polynomial";
+    readonly polyReqPositiveLexLeadingSign: "positive lexicographic leading sign";
+    readonly polyReqSquareFreeMainVariable: "square-free input in the main variable";
+    readonly polyReqExactlyTwoSelectedVariables: "exactly two selected variables";
+    readonly polyReqExactlyTwoVariables: "exactly two variables";
+    readonly polyReqOneValuePerNonMainVariable: "one value for every non-main selected variable";
+    readonly polyReqOneValuePerTailVariable: "one value for every tail variable";
+    readonly polyReqPositiveDegreeMainVariable: "positive degree in the main variable";
+    readonly polyReqAllOtherVariablesDormant: "all other variables to be dormant";
+    readonly polyReqPositiveModuli: "positive moduli";
+    readonly polyReqCoprimeModuli: "coprime moduli";
+    readonly polyReqAtLeastOneSample: "at least one sample";
+    readonly polyReqInvertibleLeadingCoefficient: "an invertible leading coefficient";
+    readonly polyReqIntegerLeadingCoefficientInvertible: "the integer leading coefficient to be invertible modulo the base prime";
+    readonly infinityMinusInfinityUndefined: "Infinity-Infinity is undefined!";
+    readonly inconsistentAssumptions: "Assumptions are inconsistent (empty intersection)!";
+    readonly unsupportedType: "The provided type ({{type}}) is not supported for this function!";
+    readonly unsupportedOperation: "This operation is currently not supported!";
+    readonly buildFunctionUnsupportedFunction: "buildFunction cannot compile the function \"{{function}}\" to JavaScript number arithmetic!";
+    readonly buildFunctionComplexUnsupported: "buildFunction cannot compile expressions containing the imaginary unit to JavaScript number arithmetic!";
+    readonly nonMatchingDimensions: "This operation cannot be completed because the dimensions don't match!";
+    readonly malformedExpression: "Unable to parse malformed expression!";
+    readonly unsupportedCharacter: "Unsupported character \"{{character}}\" at position {{position}}.";
+    readonly missingCommentDelimiter: "Missing closing comment delimiter \"{{delimiter}}\".";
+    readonly divisionByZero: "Division by zero is not defined!";
+    readonly zeroToZeroPower: "0^0 is undefined!";
+    readonly infinityToPowerZero: "Infinity^0 is not defined!";
+    readonly infinityTimesZero: "0*Infinity is not defined!";
+    readonly infinityToInfinity: "Infinity^Infinity is not defined!";
+    readonly valueToInfinityUndefined: "{{value}}^Infinity is not defined!";
+    readonly atan2Undefined: "atan2 is undefined for 0, 0!";
+    readonly tanUndefined: "tan is undefined for multiples of pi/2!";
+    readonly loopIterationLimitExceeded: "Loop exceeded the maximum of {{max}} iterations.";
+    readonly breakOutsideLoop: "break can only be used inside a loop.";
+    readonly continueOutsideLoop: "continue can only be used inside a loop.";
+    readonly letRequiresBindingsAndBody: "let requires one or more name/value pairs followed by a body expression.";
+    readonly secUndefined: "sec is undefined for odd multiples of pi/2!";
+    readonly cscUndefined: "csc is undefined for multiples of pi!";
+    readonly cotUndefined: "cot is undefined for multiples of pi!";
+    readonly cothUndefined: "coth is undefined for 0!";
+    readonly cschUndefined: "csch is undefined for 0!";
+    readonly atanhUndefined: "atanh is undefined for 0!";
+    readonly cannotCreateArrayFromNaN: "Cannot create array from NaN!";
+    readonly expressionExpected: "Expression expected!. Received {{type}}!";
+    readonly unrecognizedMode: "\"{{mode}}\" is is not a valid mode!";
+    readonly notAPolynomial: "The expression is not a valid polynomial!";
+    readonly multidegreeMismatch: "The number of variables must match the multidegree of the polynomial!";
+    readonly cannotCreateMatrix: "Unable to create Matrix. Row dimensions do not match!";
+    readonly cannotMultiplyMatrix: "Cannot multiply matrix!";
+    readonly squareMatrixRequired: "The matrix must be square!";
+    readonly rowsMustMatch: "The rows of the matrices must match!";
+    readonly columnsMustMatch: "The columns of the matrices must match!";
+    readonly singularMatrix: "The provided matrix is singular!";
+    readonly matrixExpected: "Matrix expected! Received {{type}}.";
+    readonly mismatchedDimensions: "The dimensions must match for the function \"{{function}}\"!";
+    readonly incorrectCrossDimension: "The cross product is only defined for vectors of dimension 3!";
+    readonly vectorExpected: "Expected Vector! Received {{type}}.";
+    readonly univariatePolynomialOnly: "This function is only supported for univariate polynomials!";
+    readonly unknownVariable: "Unknown variable! \"{{variable}}\"";
+    readonly convergenceFailed: "Failed to converge! {{iters}} iterations were tried.";
+    readonly endPointIsRoot: "End point is root.";
+    readonly zeroDerivative: "The derivative is zero at x = {{x}}. Cannot continue.";
+    readonly tooManyUnknowns: "Too many unknowns!";
+    readonly solveSystemInfiniteSolutions: "This system does not have a finite isolated solution set!";
+    readonly solveSystemPolynomialOnly: "solveSystem currently supports only linear or polynomial systems!";
+    readonly solveSystemNonRationalUnsupported: "This nonlinear polynomial system requires non-rational or non-symbolic solving, which is not yet supported!";
+    readonly setJSFunctionExpectsFunction: "The function parameter when setting a JS function must be of type function!";
+    readonly functionRequiresMinAndMaxArgs: "You must provide a min and max arg when setting the function!";
+};
+export type ErrorType = keyof typeof EnglishErrorMessages;
+export type Language = 'eng' | 'spa' | 'fra' | 'deu' | 'por' | 'ita' | 'nld';
+export type MessageCatalog = {
+    [K in ErrorType]: string;
+};
+export declare const ErrorMessages: Partial<Record<Language, MessageCatalog>> & {
+    eng: MessageCatalog;
 };
-/** Internal language keys supported by the message catalog. */
-export type Language = keyof typeof ErrorMessages;
-type ErrorType = keyof (typeof ErrorMessages)['eng'];
+/** Registers one optional localized message catalog. */
+export declare function registerLanguage(language: Exclude<Language, 'eng'>, catalog: MessageCatalog): void;
 /** Formats an internal localized error message with named template values. */
 export declare function message(e: ErrorType, values?: {
     [name: string]: string;
 }): string;
-export {};