nerdamer 1.1.13 → 2.0.0-rc.2

package/output/api/calculus.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sum = exports.product = exports.defint = exports.limit = exports.laplace = exports.ilaplace = exports.integrate = exports.C = exports.S = exports.diff = void 0;
+/** Public calculus APIs. */
+var diff_1 = require("../calculus/derivative/diff");
+Object.defineProperty(exports, "diff", { enumerable: true, get: function () { return diff_1.diff; } });
+var fresnel_1 = require("../calculus/fresnel");
+Object.defineProperty(exports, "S", { enumerable: true, get: function () { return fresnel_1.S; } });
+Object.defineProperty(exports, "C", { enumerable: true, get: function () { return fresnel_1.C; } });
+var integrate_1 = require("../calculus/integrate/integrate");
+Object.defineProperty(exports, "integrate", { enumerable: true, get: function () { return integrate_1.integrate; } });
+var ilaplace_1 = require("../calculus/laplace/ilaplace");
+Object.defineProperty(exports, "ilaplace", { enumerable: true, get: function () { return ilaplace_1.ilaplace; } });
+var laplace_1 = require("../calculus/laplace/laplace");
+Object.defineProperty(exports, "laplace", { enumerable: true, get: function () { return laplace_1.laplace; } });
+var limit_1 = require("../calculus/limit/limit");
+Object.defineProperty(exports, "limit", { enumerable: true, get: function () { return limit_1.limit; } });
+var defint_1 = require("../math/defint/defint");
+Object.defineProperty(exports, "defint", { enumerable: true, get: function () { return defint_1.defint; } });
+var math_1 = require("../math/math");
+Object.defineProperty(exports, "product", { enumerable: true, get: function () { return math_1.product; } });
+Object.defineProperty(exports, "sum", { enumerable: true, get: function () { return math_1.sum; } });

package/output/api/core.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Core Nerdamer object model and shared public types.
+ *
+ * Import from `nerdamer/core` when working directly with Nerdamer values rather
+ * than through the callable compatibility root.
+ */
+export { Equation } from '../core/classes/equation/Equation';
+export { CoeffObject } from '../core/classes/expression/CoeffObject';
+export { Expression } from '../core/classes/expression/Expression';
+export type { ElementsSortType } from '../core/classes/expression/Expression';
+export { symbols } from '../core/classes/expression/shortcuts';
+export type { JsFunction, OptionValue, OptionsObject, ParserConstants, ParserValuesObject, TextOptions, } from '../core/classes/parser/types';
+export { Rational } from '../core/classes/rational/Rational';
+export { Converter } from '../core/converters/Converter';
+export { AssignmentError, DimensionError, DivisionByZeroError, MathError, MissingReferenceError, NaNError, NotImplementedError, OperatorError, ParserError, ParserSyntaxError, PolynomialError, UndefinedError, UnexpectedDataType, UnexpectedInputError, UnexpectedTokenError, UnsupportedOperationError, ZeroToZeroPowerError, } from '../core/errors';
+export { build as buildFunction } from '../core/functions/build';
+export type { ExpressionInput, NerdamerInput, ParserEntity, StructuredEntityType, } from '../core/types';

package/output/api/core.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFunction = exports.ZeroToZeroPowerError = exports.UnsupportedOperationError = exports.UnexpectedTokenError = exports.UnexpectedInputError = exports.UnexpectedDataType = exports.UndefinedError = exports.PolynomialError = exports.ParserSyntaxError = exports.ParserError = exports.OperatorError = exports.NotImplementedError = exports.NaNError = exports.MissingReferenceError = exports.MathError = exports.DivisionByZeroError = exports.DimensionError = exports.AssignmentError = exports.Converter = exports.Rational = exports.symbols = exports.Expression = exports.CoeffObject = exports.Equation = void 0;
+/**
+ * Core Nerdamer object model and shared public types.
+ *
+ * Import from `nerdamer/core` when working directly with Nerdamer values rather
+ * than through the callable compatibility root.
+ */
+var Equation_1 = require("../core/classes/equation/Equation");
+Object.defineProperty(exports, "Equation", { enumerable: true, get: function () { return Equation_1.Equation; } });
+var CoeffObject_1 = require("../core/classes/expression/CoeffObject");
+Object.defineProperty(exports, "CoeffObject", { enumerable: true, get: function () { return CoeffObject_1.CoeffObject; } });
+var Expression_1 = require("../core/classes/expression/Expression");
+Object.defineProperty(exports, "Expression", { enumerable: true, get: function () { return Expression_1.Expression; } });
+var shortcuts_1 = require("../core/classes/expression/shortcuts");
+Object.defineProperty(exports, "symbols", { enumerable: true, get: function () { return shortcuts_1.symbols; } });
+var Rational_1 = require("../core/classes/rational/Rational");
+Object.defineProperty(exports, "Rational", { enumerable: true, get: function () { return Rational_1.Rational; } });
+var Converter_1 = require("../core/converters/Converter");
+Object.defineProperty(exports, "Converter", { enumerable: true, get: function () { return Converter_1.Converter; } });
+var errors_1 = require("../core/errors");
+Object.defineProperty(exports, "AssignmentError", { enumerable: true, get: function () { return errors_1.AssignmentError; } });
+Object.defineProperty(exports, "DimensionError", { enumerable: true, get: function () { return errors_1.DimensionError; } });
+Object.defineProperty(exports, "DivisionByZeroError", { enumerable: true, get: function () { return errors_1.DivisionByZeroError; } });
+Object.defineProperty(exports, "MathError", { enumerable: true, get: function () { return errors_1.MathError; } });
+Object.defineProperty(exports, "MissingReferenceError", { enumerable: true, get: function () { return errors_1.MissingReferenceError; } });
+Object.defineProperty(exports, "NaNError", { enumerable: true, get: function () { return errors_1.NaNError; } });
+Object.defineProperty(exports, "NotImplementedError", { enumerable: true, get: function () { return errors_1.NotImplementedError; } });
+Object.defineProperty(exports, "OperatorError", { enumerable: true, get: function () { return errors_1.OperatorError; } });
+Object.defineProperty(exports, "ParserError", { enumerable: true, get: function () { return errors_1.ParserError; } });
+Object.defineProperty(exports, "ParserSyntaxError", { enumerable: true, get: function () { return errors_1.ParserSyntaxError; } });
+Object.defineProperty(exports, "PolynomialError", { enumerable: true, get: function () { return errors_1.PolynomialError; } });
+Object.defineProperty(exports, "UndefinedError", { enumerable: true, get: function () { return errors_1.UndefinedError; } });
+Object.defineProperty(exports, "UnexpectedDataType", { enumerable: true, get: function () { return errors_1.UnexpectedDataType; } });
+Object.defineProperty(exports, "UnexpectedInputError", { enumerable: true, get: function () { return errors_1.UnexpectedInputError; } });
+Object.defineProperty(exports, "UnexpectedTokenError", { enumerable: true, get: function () { return errors_1.UnexpectedTokenError; } });
+Object.defineProperty(exports, "UnsupportedOperationError", { enumerable: true, get: function () { return errors_1.UnsupportedOperationError; } });
+Object.defineProperty(exports, "ZeroToZeroPowerError", { enumerable: true, get: function () { return errors_1.ZeroToZeroPowerError; } });
+var build_1 = require("../core/functions/build");
+Object.defineProperty(exports, "buildFunction", { enumerable: true, get: function () { return build_1.build; } });

package/output/api/debug.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Contributor-facing diagnostic inspection helpers.
+ *
+ * @remarks
+ * This module exposes plain-data views of Nerdamer parser and expression internals for
+ * debugging tools, issue reports, and visual inspectors. The shapes reflect Nerdamer's
+ * implementation and may change between releases; they are not part of the mathematical
+ * compatibility surface provided by the ordinary package APIs.
+ *
+ * Import these helpers from `nerdamer/debug`. Loading this subpath does not add them to
+ * the browser UMD bundle or the root `nerdamer` callable.
+ *
+ * @module debug
+ */
+export { inspectEntity, inspectExpressionData as inspectExpression, inspectParse, inspectPolynomialData as inspectPolynomial, inspectTermData as inspectTerm, } from '../utils/debug';
+export type { DebugCollection, DebugDictionary, DebugDictionaryEntry, DebugEntity, DebugEquation, DebugExpression, DebugMatrix, DebugPolynomial, DebugScope, DebugScopeItem, DebugTerm, DebugToken, DebugValuesSet, DebugVector, ParseInspection, } from '../utils/debug';

package/output/api/debug.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectTerm = exports.inspectPolynomial = exports.inspectParse = exports.inspectExpression = exports.inspectEntity = void 0;
+/**
+ * Contributor-facing diagnostic inspection helpers.
+ *
+ * @remarks
+ * This module exposes plain-data views of Nerdamer parser and expression internals for
+ * debugging tools, issue reports, and visual inspectors. The shapes reflect Nerdamer's
+ * implementation and may change between releases; they are not part of the mathematical
+ * compatibility surface provided by the ordinary package APIs.
+ *
+ * Import these helpers from `nerdamer/debug`. Loading this subpath does not add them to
+ * the browser UMD bundle or the root `nerdamer` callable.
+ *
+ * @module debug
+ */
+var debug_1 = require("../utils/debug");
+Object.defineProperty(exports, "inspectEntity", { enumerable: true, get: function () { return debug_1.inspectEntity; } });
+Object.defineProperty(exports, "inspectExpression", { enumerable: true, get: function () { return debug_1.inspectExpressionData; } });
+Object.defineProperty(exports, "inspectParse", { enumerable: true, get: function () { return debug_1.inspectParse; } });
+Object.defineProperty(exports, "inspectPolynomial", { enumerable: true, get: function () { return debug_1.inspectPolynomialData; } });
+Object.defineProperty(exports, "inspectTerm", { enumerable: true, get: function () { return debug_1.inspectTermData; } });

package/output/api/languages/deu.d.ts

@@ -0,0 +1,3 @@
+import type { MessageCatalog } from '../../core/errors';
+declare const catalog: MessageCatalog;
+export default catalog;

package/output/api/languages/deu.js

@@ -0,0 +1,266 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../core/errors");
+const Settings_1 = require("../../core/Settings");
+const catalog = {
+    // General
+    notImplemented: 'Diese Methode wurde noch nicht implementiert.',
+    noInverse: 'Die Inverse konnte nicht berechnet werden!',
+    undefinedValue: 'Der angeforderte Wert ist nicht definiert!',
+    nullValue: 'Ein Wert wurde erwartet, aber null wurde empfangen.',
+    univariateInputOnly: 'Die Eingabe für diese Funktion muss univariat sein!',
+    differentSignsAtEndPointsRequired: 'Die Funktion muss an den Endpunkten a und b unterschiedliche Vorzeichen haben!',
+    integerRequired: 'Für diese Funktion muss der Koeffizient eine ganze Zahl sein!',
+    plainVariableExpected: 'Eine einfache Variable wurde erwartet! Erhalten: {{input}}.',
+    missingReference: 'Die Referenz „{{ref}}“ existiert in diesem Muster nicht!',
+    undefinedDivision: 'Division ist für einen Ausdruck dieses Typs nicht definiert! {{type}}',
+    restrictedVariableName: 'Der angeforderte Wert kann dem reservierten Namen „{{name}}“ nicht zugewiesen werden!',
+    noVariableInExpression: 'Im Ausdruck wurde keine Variable gefunden!',
+    quadraticExpressionExpected: 'Der Ausdruck muss quadratisch sein!',
+    wrongInput: 'Falsche Eingabe! Erwartet wurde {{expected}}, erhalten wurde {{received}}.',
+    unsupportedFunction: 'Nicht unterstützte Funktion „{{function}}“.',
+    functionMinArgs: '{{function}} benötigt mindestens {{min}} Argumente, aber {{actual}} wurden übergeben.',
+    functionMaxArgs: '{{function}} erlaubt höchstens {{max}} Argumente, aber {{actual}} wurden übergeben.',
+    invalidFunctionDeclaration: 'Ungültige Funktionsdeklaration „{{declaration}}“.',
+    indexOutOfBounds: 'Index {{index}} liegt außerhalb des gültigen Bereichs für {{type}} mit Länge {{length}}.',
+    matrixRowIndexOutOfBounds: 'Zeilenindex {{index}} liegt außerhalb des gültigen Bereichs für Matrix mit {{length}} Zeilen.',
+    matrixColumnIndexOutOfBounds: 'Spaltenindex {{index}} liegt außerhalb des gültigen Bereichs für Matrix mit {{length}} Spalten.',
+    dictionaryKeyNotFound: 'Schlüssel „{{key}}“ wurde in Dictionary nicht gefunden. Verfügbare Schlüssel: {{keys}}.',
+    rangeValuesFinite: 'Bereichswerte müssen endlich sein.',
+    rangeStepNonzero: 'Die Bereichsschrittweite darf nicht null sein.',
+    rangeStepNoAdvance: 'Die Bereichsschrittweite bewirkt bei der aktuellen Genauigkeit keinen Fortschritt.',
+    sparseVariableCountInvalid: 'SparsePolynomial variableCount muss eine nichtnegative sichere Ganzzahl sein.',
+    sparseExponentVectorLengthMismatch: 'Die Länge des Exponentenvektors von SparsePolynomial muss variableCount entsprechen.',
+    sparseExponentsNonNegativeBigInt: 'SparsePolynomial-Exponenten müssen nichtnegative bigints sein.',
+    sparseVariableIndexOutOfRing: 'Der Variablenindex von SparsePolynomial liegt außerhalb des Polynomrings.',
+    sparseAdditionRingMismatch: 'Die Addition von SparsePolynomial erfordert denselben Polynomring.',
+    sparseCoefficientExponentNonNegative: 'Der Koeffizientenexponent von SparsePolynomial muss nichtnegativ sein.',
+    sparseZeroMonomialDivision: 'SparsePolynomial kann nicht durch ein Nullmonom dividiert werden.',
+    sparseZeroScalarDivision: 'SparsePolynomial kann nicht durch null dividiert werden.',
+    sparseScalarDivisionExact: 'Die skalare Division von SparsePolynomial muss für jeden Koeffizienten exakt sein.',
+    sparseDivisionRingMismatch: 'Die Division von SparsePolynomial erfordert denselben Polynomring.',
+    sparseZeroPolynomialDivision: 'SparsePolynomial kann nicht durch das Nullpolynom dividiert werden.',
+    sparseMonomialOrderUnsupported: 'Die Monomordnung von SparsePolynomial wird nicht unterstützt.',
+    sparseMultiplicationRingMismatch: 'Die Multiplikation von SparsePolynomial erfordert denselben Polynomring.',
+    sparseExponentNonNegative: 'Der Exponent von SparsePolynomial muss nichtnegativ sein.',
+    sparseSubtractionRingMismatch: 'Die Subtraktion von SparsePolynomial erfordert denselben Polynomring.',
+    invalidDecimal: 'Ungültiger Decimal-Wert: "{{value}}"',
+    invalidInterval: 'Ungültiges Intervall: ({{start}}, {{end}})',
+    invalidAssumption: 'Ungültige Annahme: "{{input}}"',
+    assumptionIdentifierExpected: 'Bezeichner erwartet',
+    assumptionOperatorMissing: 'Operator fehlt',
+    assumptionValueMissing: 'Wert fehlt',
+    assumptionOperatorUnsupported: 'Nicht unterstützter Operator "{{operator}}"',
+    matrixStringKeyUnsupported: 'Matrix unterstützt keinen Zugriff über Textschlüssel',
+    matrixTraceUnavailable: 'Die Spur der Matrix kann nicht berechnet werden',
+    defintMaxEvals: 'defint: maxEvals überschritten ({{max}}).',
+    defintNonFiniteValue: 'defint: f(x) ist bei x={{x}} nicht endlich',
+    defintEndpointSingularity: 'defint: Endpunktsingularität konnte nahe x={{x}} nicht regularisiert werden',
+    defintSingularity: 'defint: Singularität oder nicht endlicher Wert nahe [{{a}}, {{b}}]',
+    defintInfiniteBounds: 'defint: unendliche Grenzen erfordern allowInfinite: true',
+    defintUnsupportedInfiniteBounds: 'defint: nicht unterstützte Konfiguration unendlicher Grenzen',
+    symbolicAccessNamedTargetRequired: 'Symbolischer indizierter Zugriff erfordert ein benanntes Vector- oder Matrix-Ziel.',
+    symbolicVectorIndexCount: 'Symbolischer Vector-Zugriff erfordert genau einen Index.',
+    symbolicMatrixRowNonScalar: 'Symbolischer Zugriff auf eine Matrix-Zeile ist nicht skalar und kann nicht als Expression verzögert werden.',
+    symbolicMatrixCellIndexCount: 'Symbolischer Zugriff auf eine Matrix-Zelle erfordert genau zwei Indizes.',
+    symbolicAccessMaxIndices: 'Symbolischer indizierter Zugriff unterstützt höchstens zwei nicht aufgelöste Indizes.',
+    symbolicAccessIndexScalar: 'Indizes des symbolischen Zugriffs müssen zu skalaren Ausdrücken ausgewertet werden.',
+    symbolicAccessTargetType: 'Das Ziel des symbolischen indizierten Zugriffs muss zu Vector oder Matrix aufgelöst werden.',
+    expectedOperatorOrFunction: 'Operator oder Funktionsname erwartet, aber "{{value}}" gefunden!',
+    missingOpeningBracket: 'Öffnende Klammer fehlt für "{{bracket}}":{{position}}',
+    missingClosingBracket: 'Schließende Klammer fehlt für "{{bracket}}":{{position}}',
+    prefixOperatorExpected: 'Präfixoperator erwartet, aber {{operator}} gefunden.',
+    groebnerBasisSizeBudgetExceeded: 'Groebner-Budget überschritten: Basisgröße > {{max}}',
+    groebnerPairsBudgetExceeded: 'Groebner-Budget überschritten: pairsPopped > {{max}}',
+    unsupportedParserEntity: 'Nicht unterstützte Parser-Entität',
+    factorialNegativeUndefined: 'Die Fakultät ist für negative ganze Zahlen nicht definiert.',
+    erfConvergenceFailed: 'erf konvergiert nicht. Abbruch!',
+    defintInfiniteBoundsDecimal: 'defint: unendliche Grenzen erfordern allowInfinite:true',
+    seqStartsAtInteger: "startsAt muss eine Ganzzahl sein",
+    seqPolynomialOrMaxPower: "Die Folge ist kein Polynom oder überschreitet maxPower",
+    seqInsufficientData: "Nicht genügend Datenpunkte für den erkannten Grad",
+    arithPowNegativeExponent: "pow: negativer Exponent",
+    arithPowNNonnegativeInteger: "powN: Der Exponent muss eine nichtnegative Ganzzahl sein",
+    arithBigIntSqrtNegative: "bigIntSqrt: negative Eingabe",
+    arithNthRootPositiveInteger: "intNthRootExact: n muss eine positive Ganzzahl sein",
+    arithDivisorsPositive: "getDivisors: n muss positiv sein",
+    arithModNormNonzeroModulus: "modNorm: Der Modulus darf nicht null sein",
+    arithModSymmetricNonzeroModulus: "modSymmetric: Der Modulus darf nicht null sein",
+    arithModInvZeroNoninvertible: "modInv: nicht invertierbar (0)",
+    arithModInvNoninvertible: "modInv: nicht invertierbar",
+    integerSqrtNonnegative: "Die ganzzahlige Quadratwurzel erfordert einen nichtnegativen Wert.",
+    modularExponentiationPositiveModulus: "Die modulare Exponentiation erfordert einen positiven Modulus.",
+    modularExponentiationNonnegativeExponent: "Die modulare Exponentiation erfordert einen nichtnegativen Exponenten.",
+    maxBigIntRequiresArgument: "maxBigInt() erfordert mindestens ein Argument",
+    minBigIntEmpty: "Das Minimum einer leeren Liste ist für BigInt nicht definiert.",
+    binomBigIntNonnegativeN: "binomBigInt: n muss nichtnegativ sein",
+    invalidDecimalValue: "Ungültiger Dezimalwert: {{value}}",
+    subtractionNotDefined: "Subtraktion ist für {{leftType}}-{{rightType}} | {{left}}-{{right}} nicht definiert",
+    sparseAdapterVariablesUnique: "Die Variablen des Sparse-Polynom-Adapters müssen eindeutig sein.",
+    sparseAdapterVariablesIncludeEvery: "Die Variablen des Sparse-Polynom-Adapters müssen jede Polynomvariable enthalten.",
+    sparseExpressionConversionNameCount: "Die Konvertierung eines Ausdrucks in ein Sparse-Polynom erfordert einen Namen pro Ringvariable.",
+    converterMissingArgumentScope: "Argumentbereich für Funktion {{function}} fehlt",
+    converterMissingPrefixOperand: "Operand für Präfixoperator {{operator}} fehlt",
+    converterMissingOperandMetadata: "Operand oder Metadaten für Operator {{operator}} fehlen",
+    converterMissingLeftOperand: "Linker Operand für Operator {{operator}} fehlt",
+    converterTexConversionFailed: "Quellausdruck kann nicht in TeX konvertiert werden",
+    unknownOperator: "Unbekannter Operator {{operator}}",
+    polynomialMaximumIterations: "Maximale Anzahl von Iterationen erreicht",
+    polyRequires: "{{operation}} erfordert {{requirement}}.",
+    polyVariablesUnique: "Die Variablen von {{operation}} müssen eindeutig sein.",
+    polyVariablesRingOrder: "Die Variablen von {{operation}} müssen der Reihenfolge des Polynomrings folgen.",
+    polyVariablesIncludeActive: "Die Variablen von {{operation}} müssen jede aktive Variable enthalten.",
+    polyInputsSelectedOnly: "Die Eingaben von {{operation}} dürfen nur die ausgewählten Variablen verwenden.",
+    polyCannotFactorZeroPolynomial: "{{operation}} kann das Nullpolynom nicht faktorisieren.",
+    polyCannotFactorZero: "{{operation}} kann Null nicht faktorisieren.",
+    polyModulusGreaterThanOne: "Der Modulus von ModularSparsePolynomial muss größer als eins sein.",
+    polyVariableCountMatch: "variableCount von ModularSparsePolynomial muss mit dem angegebenen Sparse-Polynom übereinstimmen.",
+    polyInterpolationCannotDepend: "Interpolationsstichproben von ModularSparsePolynomial dürfen nicht von der interpolierten Variablen abhängen.",
+    polyInterpolationInvertibleDifferences: "Interpolationspunkte von ModularSparsePolynomial müssen paarweise invertierbare Differenzen haben.",
+    polyCoefficientExponentNonnegative: "Der Koeffizientenexponent von ModularSparsePolynomial muss nichtnegativ sein.",
+    polyCannotDivideZero: "ModularSparsePolynomial kann nicht durch das Nullpolynom dividieren.",
+    polyDivisorLeadingCoefficientInvertible: "Der führende Koeffizient des Divisors von ModularSparsePolynomial ist nicht invertierbar.",
+    polyLeadingCoefficientInvertible: "Der führende Koeffizient von ModularSparsePolynomial ist nicht invertierbar.",
+    polyExponentNonnegative: "Der Exponent von ModularSparsePolynomial muss nichtnegativ sein.",
+    polyDegreeMatrixLimit: "Der Grad der modularen Faktorisierung überschreitet die unterstützte Matrixdimension.",
+    polyExtendedGcdTwoZeroUndefined: "Der erweiterte modulare GGT ist für zwei Nullpolynome nicht definiert.",
+    polyHenselPrimeExceedsTailDegree: "Die Primzahl beim multivariaten Hensel-Lifting muss den Grad jeder Restvariablen überschreiten.",
+    polyHenselTargetNotSmaller: "Der Zielmodulus des Hensel-Liftings darf nicht kleiner als die Basisprimzahl sein.",
+    polyHenselTargetRepeatedSquaring: "Der Zielmodulus des Hensel-Liftings muss durch wiederholtes Quadrieren der Basisprimzahl erhalten werden.",
+    polyHenselFactorsReconstructModuloBase: "Die Hensel-Lifting-Faktoren rekonstruieren das ganzzahlige Polynom modulo der Basisprimzahl nicht.",
+    polyZassenhausFactorsReconstructModuloLift: "Die Faktoren der Zassenhaus-Rekombination rekonstruieren die Eingabe modulo des Lift-Modulus nicht.",
+    polyWangCannotSpecializeZero: "Die Wang-Auswertungssuche kann Null nicht spezialisieren.",
+    polyModularContentExactDivision: "Der Inhalt des modularen Polynoms muss das Polynom exakt teilen.",
+    factorizationNoFactors: "Die nichtkonstante Faktorisierung lieferte keine Faktoren.",
+    polyCrtModuliInvertible: "Die CRT-Moduli des Polynoms müssen invertierbar sein.",
+    polyIntegerFactorPrimeZero: "Die ganzzahlige Faktorisierung kann für Null keine Primzahl wählen.",
+    polySquareFreeNonExactDivision: "Bei der quadratfreien Faktorisierung trat eine nicht exakte Polynomdivision auf.",
+    polyZassenhausLostRemaining: "Die Zassenhaus-Rekombination verlor das verbleibende Polynom.",
+    polyZassenhausReconstructionFailed: "Die Faktoren der Zassenhaus-Rekombination rekonstruieren das ganzzahlige Polynom nicht.",
+    polyIntegerFactorLostLeading: "Die ganzzahlige Faktorisierung verlor den Leitterm.",
+    parserMalformedSymbolicAccessor: "Fehlerhafter interner symbolischer Zugriff.",
+    parserMalformedSymbolicAccessorIndex: "Fehlerhafter Index eines internen symbolischen Zugriffs.",
+    unknownOperatorAction: "Unbekannte Operatoraktion {{action}}",
+    parserBracketTokenMissingCharacter: "Dem Klammer-Token fehlt das Zeichen.",
+    polyWangLeadingEvaluationInteger: "Die Wang-Auswertung des führenden Koeffizienten ergab keine Ganzzahl.",
+    polyWangSpecializedLeadingInteger: "Der spezialisierte Wang-Faktor hatte keinen ganzzahligen führenden Koeffizienten.",
+    polyMultivariateContentDivisionFailed: "Die multivariate Faktorisierung konnte einen quadratfreien Block nicht durch seinen Inhalt in der Hauptvariablen teilen.",
+    polyMultivariateContentVariableMissing: "Der multivariate Inhalt der Hauptvariablen behielt keine aktive Koeffizientenvariable.",
+    polyMultivariateReconstructionFailed: "Die vollständige multivariate Faktorisierung rekonstruiert das Eingabepolynom nicht.",
+    polyBerlekampNoninvertiblePivot: "Die Berlekamp-Elimination traf auf ein nicht invertierbares Pivotelement.",
+    polyHenselZeroFactorGroup: "Hensel-Lifting kann keine Nullfaktorgruppe anheben.",
+    polyHenselCannotLiftZero: "Hensel-Lifting kann das Nullpolynom nicht anheben.",
+    polyHenselModulusExceeded: "Hensel-Lifting überschritt den angeforderten Primzahlpotenz-Modulus.",
+    polyHenselLeadingLost: "Hensel-Lifting verlor den führenden Zielkoeffizienten.",
+    polyHenselReconstructionFailed: "Die durch Hensel angehobenen Faktoren rekonstruieren das Zielpolynom nicht.",
+    polyBerlekampNonExactSplit: "Die Berlekamp-Aufspaltung erzeugte eine nicht exakte Faktordivision.",
+    polyBerlekampIncompleteSplit: "Die Berlekamp-Faktorisierung spaltete das Polynom nicht vollständig auf.",
+    polyBerlekampReconstructionFailed: "Die Berlekamp-Faktoren rekonstruieren das Eingabepolynom nicht.",
+    expressionKeyValueUnsupported: "Die Funktion 'keyValue' ist für den Typ {{type}} nicht implementiert.",
+    solveLinearNonlinearDegree: "Nichtlinearer Term in Gleichung {{equation}} erkannt: Term vom Grad {{degree}} gefunden. solveLinearSystem verarbeitet nur lineare Systeme.",
+    solveLinearNonPolynomialVariable: "Nichtlinearer Term in Gleichung {{equation}} erkannt: Variable \"{{variable}}\" erscheint an einer nichtpolynomialen Position. solveLinearSystem verarbeitet nur lineare Systeme.",
+    polyReqPrimeModulus: "einen Primmodulus",
+    polyReqUnivariatePolynomial: "ein univariates Polynom",
+    polyReqSquareFreeInput: "quadratfreien Input",
+    polyReqSamePolynomialRing: "denselben Polynomring",
+    polyReqAtLeastOneVariable: "mindestens eine Variable",
+    polyReqAtLeastTwoSelectedVariables: "mindestens zwei ausgewählte Variablen",
+    polyReqOneEvaluationPerTailVariable: "einen Auswertungswert pro Restvariable",
+    polyReqMatchingFactorLeadingLists: "übereinstimmende Listen von Faktoren und führenden Koeffizienten",
+    polyReqPairwiseCoprimeModularFactors: "paarweise teilerfremde modulare Faktoren",
+    polyReqPrimeBaseModulus: "einen primen Basismodulus",
+    polyReqAtLeastOneModularFactor: "mindestens einen modularen Faktor",
+    polyReqUnivariateIntegerPolynomial: "ein univariates ganzzahliges Polynom",
+    polyReqFactorsSameRingAndPrime: "Faktoren aus demselben ganzzahligen Polynomring und derselben Basisprimzahl",
+    polyReqUnivariateFactors: "univariate Faktoren",
+    polyReqMonicModularFactors: "monische modulare Faktoren",
+    polyReqPrimitiveIntegerPolynomial: "ein primitives ganzzahliges Polynom",
+    polyReqPositiveLeadingCoefficient: "einen positiven führenden Koeffizienten",
+    polyReqLiftedModularFactors: "angehobene modulare Faktoren",
+    polyReqLiftedFactorsSameRing: "angehobene Faktoren aus einem Polynomring",
+    polyReqUnivariateLiftedFactors: "univariate angehobene Faktoren",
+    polyReqMonicLiftedFactors: "monische angehobene Faktoren",
+    polyReqLargerHenselModulus: "einen größeren Hensel-Lifting-Modulus",
+    polyReqPrimitivePolynomial: "ein primitives Polynom",
+    polyReqPositiveLexLeadingSign: "ein positives lexikografisches Vorzeichen des Leitterms",
+    polyReqSquareFreeMainVariable: "quadratfreien Input in der Hauptvariablen",
+    polyReqExactlyTwoSelectedVariables: "genau zwei ausgewählte Variablen",
+    polyReqExactlyTwoVariables: "genau zwei Variablen",
+    polyReqOneValuePerNonMainVariable: "einen Wert für jede ausgewählte Nicht-Hauptvariable",
+    polyReqOneValuePerTailVariable: "einen Wert für jede Restvariable",
+    polyReqPositiveDegreeMainVariable: "einen positiven Grad in der Hauptvariablen",
+    polyReqAllOtherVariablesDormant: "dass alle anderen Variablen inaktiv sind",
+    polyReqPositiveModuli: "positive Moduli",
+    polyReqCoprimeModuli: "teilerfremde Moduli",
+    polyReqAtLeastOneSample: "mindestens eine Stichprobe",
+    polyReqInvertibleLeadingCoefficient: "einen invertierbaren führenden Koeffizienten",
+    polyReqIntegerLeadingCoefficientInvertible: "dass der ganzzahlige führende Koeffizient modulo der Basisprimzahl invertierbar ist",
+    infinityMinusInfinityUndefined: 'Unendlich minus Unendlich ist nicht definiert!',
+    // Assumptions
+    inconsistentAssumptions: 'Die Annahmen sind widersprüchlich (leere Schnittmenge)!',
+    // Parser
+    unsupportedType: 'Der angegebene Typ ({{type}}) wird von dieser Funktion nicht unterstützt!',
+    unsupportedOperation: 'Diese Operation wird derzeit nicht unterstützt!',
+    buildFunctionUnsupportedFunction: 'buildFunction kann die Funktion „{{function}}“ nicht in JavaScript-Zahlenarithmetik kompilieren!',
+    buildFunctionComplexUnsupported: 'buildFunction kann Ausdrücke mit der imaginären Einheit nicht in JavaScript-Zahlenarithmetik kompilieren!',
+    nonMatchingDimensions: 'Diese Operation kann nicht ausgeführt werden, weil die Dimensionen nicht übereinstimmen!',
+    malformedExpression: 'Der fehlerhafte Ausdruck konnte nicht geparst werden!',
+    unsupportedCharacter: 'Nicht unterstütztes Zeichen „{{character}}“ an Position {{position}}.',
+    missingCommentDelimiter: 'Schließender Kommentartrenner „{{delimiter}}“ fehlt.',
+    divisionByZero: 'Division durch null ist nicht definiert!',
+    zeroToZeroPower: '0^0 ist nicht definiert!',
+    infinityToPowerZero: 'Unendlich^0 ist nicht definiert!',
+    infinityTimesZero: '0*Unendlich ist nicht definiert!',
+    infinityToInfinity: 'Unendlich^Unendlich ist nicht definiert!',
+    valueToInfinityUndefined: '{{value}}^Unendlich ist nicht definiert!',
+    atan2Undefined: 'atan2 ist für 0, 0 nicht definiert!',
+    tanUndefined: 'tan ist für Vielfache von pi/2 nicht definiert!',
+    loopIterationLimitExceeded: 'Die Schleife hat das Maximum von {{max}} Iterationen überschritten.',
+    breakOutsideLoop: 'break kann nur innerhalb einer Schleife verwendet werden.',
+    continueOutsideLoop: 'continue kann nur innerhalb einer Schleife verwendet werden.',
+    letRequiresBindingsAndBody: 'let benötigt ein oder mehrere Name/Wert-Paare, gefolgt von einem Ausdrucksrumpf.',
+    secUndefined: 'sec ist für ungerade Vielfache von pi/2 nicht definiert!',
+    cscUndefined: 'csc ist für Vielfache von pi nicht definiert!',
+    cotUndefined: 'cot ist für Vielfache von pi nicht definiert!',
+    cothUndefined: 'coth ist für 0 nicht definiert!',
+    cschUndefined: 'csch ist für 0 nicht definiert!',
+    atanhUndefined: 'atanh ist für 0 nicht definiert!',
+    cannotCreateArrayFromNaN: 'Aus NaN kann kein Array erstellt werden!',
+    expressionExpected: 'Ein Ausdruck wurde erwartet! Erhalten: {{type}}!',
+    // TeX Converter
+    unrecognizedMode: '„{{mode}}“ ist kein gültiger Modus!',
+    // Polynomials
+    notAPolynomial: 'Der Ausdruck ist kein gültiges Polynom!',
+    multidegreeMismatch: 'Die Anzahl der Variablen muss mit dem Multigrad des Polynoms übereinstimmen!',
+    unknownVariable: 'Unbekannte Variable! „{{variable}}“',
+    // Matrix
+    cannotCreateMatrix: 'Die Matrix kann nicht erstellt werden. Die Zeilendimensionen stimmen nicht überein!',
+    cannotMultiplyMatrix: 'Die Matrix kann nicht multipliziert werden!',
+    squareMatrixRequired: 'Die Matrix muss quadratisch sein!',
+    rowsMustMatch: 'Die Zeilen der Matrizen müssen übereinstimmen!',
+    columnsMustMatch: 'Die Spalten der Matrizen müssen übereinstimmen!',
+    singularMatrix: 'Die angegebene Matrix ist singulär!',
+    matrixExpected: 'Eine Matrix wurde erwartet! Erhalten: {{type}}.',
+    // Vector
+    mismatchedDimensions: 'Die Dimensionen müssen für die Funktion „{{function}}“ übereinstimmen!',
+    incorrectCrossDimension: 'Das Kreuzprodukt ist nur für Vektoren der Dimension 3 definiert!',
+    vectorExpected: 'Ein Vektor wurde erwartet! Erhalten: {{type}}.',
+    // Polynomial
+    univariatePolynomialOnly: 'Diese Funktion wird nur für univariate Polynome unterstützt!',
+    // Solve
+    convergenceFailed: 'Keine Konvergenz! {{iters}} Iterationen wurden versucht.',
+    endPointIsRoot: 'Der Endpunkt ist eine Nullstelle.',
+    zeroDerivative: 'Die Ableitung ist bei x = {{x}} null. Fortsetzung nicht möglich.',
+    tooManyUnknowns: 'Zu viele Unbekannte!',
+    solveSystemInfiniteSolutions: 'Dieses System besitzt keine endliche Menge isolierter Lösungen!',
+    solveSystemPolynomialOnly: 'solveSystem unterstützt derzeit nur lineare oder polynomielle Systeme!',
+    solveSystemNonRationalUnsupported: 'Dieses nichtlineare polynomielle System erfordert eine nicht rationale oder nicht symbolische Lösung, die noch nicht unterstützt wird!',
+    // Set Function
+    setJSFunctionExpectsFunction: 'Der Funktionsparameter muss beim Festlegen einer JS-Funktion vom Typ function sein!',
+    functionRequiresMinAndMaxArgs: 'Beim Festlegen der Funktion müssen minimale und maximale Argumentanzahl angegeben werden!',
+};
+(0, errors_1.registerLanguage)('deu', catalog);
+if (typeof NERDAMER_BUILD_LANGUAGE !== 'undefined' && NERDAMER_BUILD_LANGUAGE === 'deu') {
+    Settings_1.Settings.LANGUAGE = 'deu';
+}
+exports.default = catalog;

package/output/api/languages/fra.d.ts

@@ -0,0 +1,3 @@
+import type { MessageCatalog } from '../../core/errors';
+declare const catalog: MessageCatalog;
+export default catalog;