nerdamer 2.0.0-rc.1 → 2.0.0

package/output/api/core.js

@@ -7,6 +7,7 @@ exports.buildFunction = exports.ZeroToZeroPowerError = exports.UnsupportedOperat
  * Import from `nerdamer/core` when working directly with Nerdamer values rather
  * than through the callable compatibility root.
  */
+const build_1 = require("../core/functions/build");
 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");
@@ -37,5 +38,30 @@ Object.defineProperty(exports, "UnexpectedInputError", { enumerable: true, get:
 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; } });
+/**
+ * Compiles an expression into a native JavaScript-number function for repeated evaluation.
+ *
+ * @remarks
+ * Function calls are linked to Nerdamer's numerical implementations, including any dependencies
+ * they require. The compiler supports scalar JavaScript-number arithmetic rather than Nerdamer's
+ * full symbolic or structured value model. Symbolic-only operations such as indexed sums,
+ * products, solvers, and matrix operations are rejected if they remain in the expression.
+ *
+ * `buildFunction` uses `new Function`, so it may be unavailable under a Content Security Policy
+ * that forbids dynamic JavaScript evaluation. When `argsArray` is omitted, free variables are
+ * sorted alphabetically.
+ *
+ * @param x - The expression to compile.
+ * @param argsArray - Variable names in the positional order expected by the compiled function.
+ * @returns The compiled JavaScript-number function.
+ * @throws {@link core!UnsupportedOperationError} If the expression contains the imaginary unit or a
+ * function for which no matching JavaScript-number implementation is registered.
+ *
+ * @example
+ * ```ts
+ * buildFunction('x-y')(9, 7);                // 2
+ * buildFunction('x-y', ['y', 'x'])(9, 7);    // -2
+ * buildFunction('erf(x)+2')(9);              // 3
+ * ```
+ */
+exports.buildFunction = build_1.build;

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;

package/output/api/languages/fra.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: "Cette méthode n'a pas encore été implémentée.",
+    noInverse: "Impossible de calculer l'inverse !",
+    undefinedValue: "La valeur demandée n'est pas définie !",
+    nullValue: 'Une valeur était attendue, mais null a été reçu.',
+    univariateInputOnly: "L'entrée de cette fonction doit être univariée !",
+    differentSignsAtEndPointsRequired: 'La fonction doit avoir des signes opposés aux extrémités a et b !',
+    integerRequired: 'Cette fonction exige que le coefficient soit un entier !',
+    plainVariableExpected: 'Une variable simple était attendue ! Reçu : {{input}}.',
+    missingReference: "La référence « {{ref}} » n'existe pas dans ce modèle !",
+    undefinedDivision: "La division n'est pas définie pour une expression de ce type ! {{type}}",
+    restrictedVariableName: "Impossible d'affecter la valeur demandée au nom réservé « {{name}} » !",
+    noVariableInExpression: "Aucune variable n'a été trouvée dans l'expression !",
+    quadraticExpressionExpected: "L'expression doit être quadratique !",
+    wrongInput: 'Entrée incorrecte ! {{expected}} était attendu, mais {{received}} a été reçu.',
+    unsupportedFunction: 'Fonction non prise en charge « {{function}} ».',
+    functionMinArgs: '{{function}} exige au moins {{min}} arguments, mais {{actual}} ont été reçus.',
+    functionMaxArgs: '{{function}} accepte au plus {{max}} arguments, mais {{actual}} ont été reçus.',
+    invalidFunctionDeclaration: 'Déclaration de fonction non valide « {{declaration}} ».',
+    indexOutOfBounds: 'L’indice {{index}} est hors limites pour {{type}} de longueur {{length}}.',
+    matrixRowIndexOutOfBounds: 'L’indice de ligne {{index}} est hors limites pour Matrix avec {{length}} lignes.',
+    matrixColumnIndexOutOfBounds: 'L’indice de colonne {{index}} est hors limites pour Matrix avec {{length}} colonnes.',
+    dictionaryKeyNotFound: 'La clé « {{key}} » est introuvable dans Dictionary. Clés disponibles : {{keys}}.',
+    rangeValuesFinite: 'Les valeurs de l’intervalle doivent être finies.',
+    rangeStepNonzero: 'Le pas de l’intervalle ne peut pas être nul.',
+    rangeStepNoAdvance: 'Le pas de l’intervalle n’avance pas avec la précision actuelle.',
+    sparseVariableCountInvalid: 'SparsePolynomial variableCount doit être un entier sûr non négatif.',
+    sparseExponentVectorLengthMismatch: 'La longueur du vecteur des exposants de SparsePolynomial doit être égale à variableCount.',
+    sparseExponentsNonNegativeBigInt: 'Les exposants de SparsePolynomial doivent être des bigint non négatifs.',
+    sparseVariableIndexOutOfRing: 'L’indice de variable de SparsePolynomial est hors de l’anneau polynomial.',
+    sparseAdditionRingMismatch: 'L’addition de SparsePolynomial exige le même anneau polynomial.',
+    sparseCoefficientExponentNonNegative: 'L’exposant du coefficient de SparsePolynomial doit être non négatif.',
+    sparseZeroMonomialDivision: 'SparsePolynomial ne peut pas être divisé par un monôme nul.',
+    sparseZeroScalarDivision: 'SparsePolynomial ne peut pas être divisé par zéro.',
+    sparseScalarDivisionExact: 'La division scalaire de SparsePolynomial doit être exacte pour chaque coefficient.',
+    sparseDivisionRingMismatch: 'La division de SparsePolynomial exige le même anneau polynomial.',
+    sparseZeroPolynomialDivision: 'SparsePolynomial ne peut pas être divisé par le polynôme nul.',
+    sparseMonomialOrderUnsupported: 'L’ordre monomial de SparsePolynomial n’est pas pris en charge.',
+    sparseMultiplicationRingMismatch: 'La multiplication de SparsePolynomial exige le même anneau polynomial.',
+    sparseExponentNonNegative: 'L’exposant de SparsePolynomial doit être non négatif.',
+    sparseSubtractionRingMismatch: 'La soustraction de SparsePolynomial exige le même anneau polynomial.',
+    invalidDecimal: 'Decimal non valide : "{{value}}"',
+    invalidInterval: 'Intervalle non valide : ({{start}}, {{end}})',
+    invalidAssumption: 'Hypothèse non valide : "{{input}}"',
+    assumptionIdentifierExpected: 'Un identificateur était attendu',
+    assumptionOperatorMissing: 'Opérateur manquant',
+    assumptionValueMissing: 'Valeur manquante',
+    assumptionOperatorUnsupported: 'Opérateur non pris en charge "{{operator}}"',
+    matrixStringKeyUnsupported: 'Matrix ne prend pas en charge l’accès par clé textuelle',
+    matrixTraceUnavailable: 'Impossible de calculer la trace de la matrice',
+    defintMaxEvals: 'defint : maxEvals dépassé ({{max}}).',
+    defintNonFiniteValue: 'defint : f(x) non finie à x={{x}}',
+    defintEndpointSingularity: 'defint : la singularité d’extrémité n’a pas pu être régularisée près de x={{x}}',
+    defintSingularity: 'defint : singularité ou valeur non finie rencontrée près de [{{a}}, {{b}}]',
+    defintInfiniteBounds: 'defint : les bornes infinies exigent allowInfinite: true',
+    defintUnsupportedInfiniteBounds: 'defint : configuration de bornes infinies non prise en charge',
+    symbolicAccessNamedTargetRequired: 'L’accès indexé symbolique exige une cible Vector ou Matrix nommée.',
+    symbolicVectorIndexCount: 'L’accès symbolique à Vector exige exactement un indice.',
+    symbolicMatrixRowNonScalar: 'L’accès symbolique à une ligne de Matrix n’est pas scalaire et ne peut pas être différé comme Expression.',
+    symbolicMatrixCellIndexCount: 'L’accès symbolique à une cellule de Matrix exige exactement deux indices.',
+    symbolicAccessMaxIndices: 'L’accès indexé symbolique prend en charge au plus deux indices non résolus.',
+    symbolicAccessIndexScalar: 'Les indices d’accès symbolique doivent s’évaluer en expressions scalaires.',
+    symbolicAccessTargetType: 'La cible de l’accès indexé symbolique doit se résoudre en Vector ou Matrix.',
+    expectedOperatorOrFunction: 'Un opérateur ou un nom de fonction était attendu, mais "{{value}}" a été trouvé !',
+    missingOpeningBracket: 'Crochet ouvrant manquant pour "{{bracket}}" :{{position}}',
+    missingClosingBracket: 'Crochet fermant manquant pour "{{bracket}}" :{{position}}',
+    prefixOperatorExpected: 'Un opérateur préfixe était attendu, mais {{operator}} a été rencontré.',
+    groebnerBasisSizeBudgetExceeded: 'Budget de Groebner dépassé : taille de la base > {{max}}',
+    groebnerPairsBudgetExceeded: 'Budget de Groebner dépassé : pairsPopped > {{max}}',
+    unsupportedParserEntity: 'Entité du parseur non prise en charge',
+    factorialNegativeUndefined: 'La factorielle n’est pas définie pour les entiers négatifs.',
+    erfConvergenceFailed: 'erf ne converge pas. Arrêt !',
+    defintInfiniteBoundsDecimal: 'defint : les bornes infinies exigent allowInfinite:true',
+    seqStartsAtInteger: "startsAt doit être un entier",
+    seqPolynomialOrMaxPower: "La séquence n'est pas un polynôme ou dépasse maxPower",
+    seqInsufficientData: "Nombre de points insuffisant pour le degré détecté",
+    arithPowNegativeExponent: "pow : exposant négatif",
+    arithPowNNonnegativeInteger: "powN : l'exposant doit être un entier non négatif",
+    arithBigIntSqrtNegative: "bigIntSqrt : entrée négative",
+    arithNthRootPositiveInteger: "intNthRootExact : n doit être un entier positif",
+    arithDivisorsPositive: "getDivisors : n doit être positif",
+    arithModNormNonzeroModulus: "modNorm : le module doit être non nul",
+    arithModSymmetricNonzeroModulus: "modSymmetric : le module doit être non nul",
+    arithModInvZeroNoninvertible: "modInv : non inversible (0)",
+    arithModInvNoninvertible: "modInv : non inversible",
+    integerSqrtNonnegative: "La racine carrée entière exige une valeur non négative.",
+    modularExponentiationPositiveModulus: "L'exponentiation modulaire exige un module positif.",
+    modularExponentiationNonnegativeExponent: "L'exponentiation modulaire exige un exposant non négatif.",
+    maxBigIntRequiresArgument: "maxBigInt() exige au moins un argument",
+    minBigIntEmpty: "Le minimum d'une liste vide n'est pas défini pour BigInt.",
+    binomBigIntNonnegativeN: "binomBigInt : n doit être non négatif",
+    invalidDecimalValue: "Valeur décimale non valide : {{value}}",
+    subtractionNotDefined: "La soustraction n'est pas définie pour {{leftType}}-{{rightType}} | {{left}}-{{right}}",
+    sparseAdapterVariablesUnique: "Les variables de l'adaptateur de polynômes creux doivent être uniques.",
+    sparseAdapterVariablesIncludeEvery: "Les variables de l'adaptateur de polynômes creux doivent inclure toutes les variables du polynôme.",
+    sparseExpressionConversionNameCount: "La conversion d'expression en polynôme creux exige un nom par variable de l'anneau.",
+    converterMissingArgumentScope: "Portée d'arguments manquante pour la fonction {{function}}",
+    converterMissingPrefixOperand: "Opérande manquant pour l'opérateur préfixe {{operator}}",
+    converterMissingOperandMetadata: "Opérande ou métadonnées manquants pour l'opérateur {{operator}}",
+    converterMissingLeftOperand: "Opérande gauche manquant pour l'opérateur {{operator}}",
+    converterTexConversionFailed: "Impossible de convertir l'expression source en TeX",
+    unknownOperator: "Opérateur inconnu {{operator}}",
+    polynomialMaximumIterations: "Nombre maximal d'itérations atteint",
+    polyRequires: "{{operation}} exige {{requirement}}.",
+    polyVariablesUnique: "Les variables de {{operation}} doivent être uniques.",
+    polyVariablesRingOrder: "Les variables de {{operation}} doivent suivre l'ordre de l'anneau polynomial.",
+    polyVariablesIncludeActive: "Les variables de {{operation}} doivent inclure toutes les variables actives.",
+    polyInputsSelectedOnly: "Les entrées de {{operation}} ne peuvent utiliser que les variables sélectionnées.",
+    polyCannotFactorZeroPolynomial: "{{operation}} ne peut pas factoriser le polynôme nul.",
+    polyCannotFactorZero: "{{operation}} ne peut pas factoriser zéro.",
+    polyModulusGreaterThanOne: "Le module de ModularSparsePolynomial doit être supérieur à un.",
+    polyVariableCountMatch: "Le variableCount de ModularSparsePolynomial doit correspondre au polynôme creux fourni.",
+    polyInterpolationCannotDepend: "Les échantillons d'interpolation de ModularSparsePolynomial ne peuvent pas dépendre de la variable interpolée.",
+    polyInterpolationInvertibleDifferences: "Les points d'interpolation de ModularSparsePolynomial doivent avoir des différences deux à deux inversibles.",
+    polyCoefficientExponentNonnegative: "L'exposant de coefficient de ModularSparsePolynomial doit être non négatif.",
+    polyCannotDivideZero: "ModularSparsePolynomial ne peut pas diviser par le polynôme nul.",
+    polyDivisorLeadingCoefficientInvertible: "Le coefficient dominant du diviseur de ModularSparsePolynomial n'est pas inversible.",
+    polyLeadingCoefficientInvertible: "Le coefficient dominant de ModularSparsePolynomial n'est pas inversible.",
+    polyExponentNonnegative: "L'exposant de ModularSparsePolynomial doit être non négatif.",
+    polyDegreeMatrixLimit: "Le degré de factorisation modulaire dépasse la dimension de matrice prise en charge.",
+    polyExtendedGcdTwoZeroUndefined: "Le PGCD étendu modulaire n'est pas défini pour deux polynômes nuls.",
+    polyHenselPrimeExceedsTailDegree: "Le nombre premier du relèvement de Hensel multivarié doit dépasser le degré de chaque variable de queue.",
+    polyHenselTargetNotSmaller: "Le module cible du relèvement de Hensel ne peut pas être inférieur au nombre premier de base.",
+    polyHenselTargetRepeatedSquaring: "Le module cible du relèvement de Hensel doit être obtenu par élévations au carré successives du nombre premier de base.",
+    polyHenselFactorsReconstructModuloBase: "Les facteurs du relèvement de Hensel ne reconstruisent pas le polynôme entier modulo le nombre premier de base.",
+    polyZassenhausFactorsReconstructModuloLift: "Les facteurs de recombinaison de Zassenhaus ne reconstruisent pas l'entrée modulo le module de relèvement.",
+    polyWangCannotSpecializeZero: "La recherche d'évaluation de Wang ne peut pas spécialiser zéro.",
+    polyModularContentExactDivision: "Le contenu du polynôme modulaire doit diviser exactement le polynôme.",
+    factorizationNoFactors: "La factorisation non constante n'a renvoyé aucun facteur.",
+    polyCrtModuliInvertible: "Les modules CRT du polynôme doivent être inversibles.",
+    polyIntegerFactorPrimeZero: "La factorisation entière ne peut pas choisir un nombre premier pour zéro.",
+    polySquareFreeNonExactDivision: "La factorisation sans facteur carré a rencontré une division polynomiale non exacte.",
+    polyZassenhausLostRemaining: "La recombinaison de Zassenhaus a perdu le polynôme restant.",
+    polyZassenhausReconstructionFailed: "Les facteurs de recombinaison de Zassenhaus ne reconstruisent pas le polynôme entier.",
+    polyIntegerFactorLostLeading: "La factorisation entière a perdu le terme dominant.",
+    parserMalformedSymbolicAccessor: "Accesseur symbolique interne mal formé.",
+    parserMalformedSymbolicAccessorIndex: "Indice d'accesseur symbolique interne mal formé.",
+    unknownOperatorAction: "Action d'opérateur inconnue {{action}}",
+    parserBracketTokenMissingCharacter: "Le jeton de parenthèse n'a pas de caractère.",
+    polyWangLeadingEvaluationInteger: "L'évaluation du coefficient dominant de Wang n'a pas produit un entier.",
+    polyWangSpecializedLeadingInteger: "Le facteur spécialisé de Wang n'avait pas de coefficient dominant entier.",
+    polyMultivariateContentDivisionFailed: "La factorisation multivariée n'a pas pu diviser un bloc sans facteur carré par son contenu dans la variable principale.",
+    polyMultivariateContentVariableMissing: "Le contenu multivarié de la variable principale n'a pas conservé de variable de coefficient active.",
+    polyMultivariateReconstructionFailed: "La factorisation multivariée complète ne reconstruit pas le polynôme d'entrée.",
+    polyBerlekampNoninvertiblePivot: "L'élimination de Berlekamp a rencontré un pivot non inversible.",
+    polyHenselZeroFactorGroup: "Le relèvement de Hensel ne peut pas relever un groupe de facteurs nul.",
+    polyHenselCannotLiftZero: "Le relèvement de Hensel ne peut pas relever le polynôme nul.",
+    polyHenselModulusExceeded: "Le relèvement de Hensel a dépassé le module de puissance première demandé.",
+    polyHenselLeadingLost: "Le relèvement de Hensel a perdu le coefficient dominant cible.",
+    polyHenselReconstructionFailed: "Les facteurs relevés par Hensel ne reconstruisent pas le polynôme cible.",
+    polyBerlekampNonExactSplit: "La séparation de Berlekamp a produit une division de facteurs non exacte.",
+    polyBerlekampIncompleteSplit: "La factorisation de Berlekamp n'a pas complètement séparé le polynôme.",
+    polyBerlekampReconstructionFailed: "Les facteurs de Berlekamp ne reconstruisent pas le polynôme d'entrée.",
+    expressionKeyValueUnsupported: "La fonction 'keyValue' n'est pas implémentée pour le type {{type}}.",
+    solveLinearNonlinearDegree: "Terme non linéaire détecté dans l'équation {{equation}} : terme de degré {{degree}} trouvé. solveLinearSystem ne traite que les systèmes linéaires.",
+    solveLinearNonPolynomialVariable: "Terme non linéaire détecté dans l'équation {{equation}} : la variable \"{{variable}}\" apparaît dans une position non polynomiale. solveLinearSystem ne traite que les systèmes linéaires.",
+    polyReqPrimeModulus: "un module premier",
+    polyReqUnivariatePolynomial: "un polynôme univarié",
+    polyReqSquareFreeInput: "une entrée sans facteur carré",
+    polyReqSamePolynomialRing: "le même anneau polynomial",
+    polyReqAtLeastOneVariable: "au moins une variable",
+    polyReqAtLeastTwoSelectedVariables: "au moins deux variables sélectionnées",
+    polyReqOneEvaluationPerTailVariable: "une valeur d'évaluation par variable de queue",
+    polyReqMatchingFactorLeadingLists: "des listes correspondantes de facteurs et de coefficients dominants",
+    polyReqPairwiseCoprimeModularFactors: "des facteurs modulaires premiers entre eux deux à deux",
+    polyReqPrimeBaseModulus: "un module de base premier",
+    polyReqAtLeastOneModularFactor: "au moins un facteur modulaire",
+    polyReqUnivariateIntegerPolynomial: "un polynôme entier univarié",
+    polyReqFactorsSameRingAndPrime: "des facteurs du même anneau de polynômes entiers et du même nombre premier de base",
+    polyReqUnivariateFactors: "des facteurs univariés",
+    polyReqMonicModularFactors: "des facteurs modulaires unitaires",
+    polyReqPrimitiveIntegerPolynomial: "un polynôme entier primitif",
+    polyReqPositiveLeadingCoefficient: "un coefficient dominant positif",
+    polyReqLiftedModularFactors: "des facteurs modulaires relevés",
+    polyReqLiftedFactorsSameRing: "des facteurs relevés d'un même anneau polynomial",
+    polyReqUnivariateLiftedFactors: "des facteurs relevés univariés",
+    polyReqMonicLiftedFactors: "des facteurs relevés unitaires",
+    polyReqLargerHenselModulus: "un module de relèvement de Hensel plus grand",
+    polyReqPrimitivePolynomial: "un polynôme primitif",
+    polyReqPositiveLexLeadingSign: "un signe dominant lexicographique positif",
+    polyReqSquareFreeMainVariable: "une entrée sans facteur carré dans la variable principale",
+    polyReqExactlyTwoSelectedVariables: "exactement deux variables sélectionnées",
+    polyReqExactlyTwoVariables: "exactement deux variables",
+    polyReqOneValuePerNonMainVariable: "une valeur pour chaque variable sélectionnée non principale",
+    polyReqOneValuePerTailVariable: "une valeur pour chaque variable de queue",
+    polyReqPositiveDegreeMainVariable: "un degré positif dans la variable principale",
+    polyReqAllOtherVariablesDormant: "que toutes les autres variables soient inactives",
+    polyReqPositiveModuli: "des modules positifs",
+    polyReqCoprimeModuli: "des modules premiers entre eux",
+    polyReqAtLeastOneSample: "au moins un échantillon",
+    polyReqInvertibleLeadingCoefficient: "un coefficient dominant inversible",
+    polyReqIntegerLeadingCoefficientInvertible: "que le coefficient dominant entier soit inversible modulo le nombre premier de base",
+    infinityMinusInfinityUndefined: "Infini moins infini n'est pas défini !",
+    // Assumptions
+    inconsistentAssumptions: 'Les hypothèses sont incohérentes (intersection vide) !',
+    // Parser
+    unsupportedType: "Le type fourni ({{type}}) n'est pas pris en charge par cette fonction !",
+    unsupportedOperation: "Cette opération n'est actuellement pas prise en charge !",
+    buildFunctionUnsupportedFunction: 'buildFunction ne peut pas compiler la fonction « {{function}} » en arithmétique numérique JavaScript !',
+    buildFunctionComplexUnsupported: "buildFunction ne peut pas compiler les expressions contenant l'unité imaginaire en arithmétique numérique JavaScript !",
+    nonMatchingDimensions: 'Cette opération ne peut pas être effectuée car les dimensions ne correspondent pas !',
+    malformedExpression: "Impossible d'analyser l'expression mal formée !",
+    unsupportedCharacter: 'Caractère non pris en charge « {{character}} » à la position {{position}}.',
+    missingCommentDelimiter: 'Le délimiteur de fermeture de commentaire « {{delimiter}} » est manquant.',
+    divisionByZero: "La division par zéro n'est pas définie !",
+    zeroToZeroPower: "0^0 n'est pas défini !",
+    infinityToPowerZero: "Infini^0 n'est pas défini !",
+    infinityTimesZero: "0*Infini n'est pas défini !",
+    infinityToInfinity: "Infini^Infini n'est pas défini !",
+    valueToInfinityUndefined: "{{value}}^Infini n'est pas défini !",
+    atan2Undefined: "atan2 n'est pas définie pour 0, 0 !",
+    tanUndefined: "tan n'est pas définie pour les multiples de pi/2 !",
+    loopIterationLimitExceeded: 'La boucle a dépassé le maximum de {{max}} itérations.',
+    breakOutsideLoop: "break ne peut être utilisé qu'à l'intérieur d'une boucle.",
+    continueOutsideLoop: "continue ne peut être utilisé qu'à l'intérieur d'une boucle.",
+    letRequiresBindingsAndBody: 'let exige une ou plusieurs paires nom/valeur suivies d’une expression de corps.',
+    secUndefined: "sec n'est pas définie pour les multiples impairs de pi/2 !",
+    cscUndefined: "csc n'est pas définie pour les multiples de pi !",
+    cotUndefined: "cot n'est pas définie pour les multiples de pi !",
+    cothUndefined: "coth n'est pas définie pour 0 !",
+    cschUndefined: "csch n'est pas définie pour 0 !",
+    atanhUndefined: "atanh n'est pas définie pour 0 !",
+    cannotCreateArrayFromNaN: 'Impossible de créer un tableau à partir de NaN !',
+    expressionExpected: 'Une expression était attendue ! Reçu : {{type}} !',
+    // TeX Converter
+    unrecognizedMode: '« {{mode}} » n’est pas un mode valide !',
+    // Polynomials
+    notAPolynomial: "L'expression n'est pas un polynôme valide !",
+    multidegreeMismatch: 'Le nombre de variables doit correspondre au multidegré du polynôme !',
+    unknownVariable: 'Variable inconnue ! « {{variable}} »',
+    // Matrix
+    cannotCreateMatrix: 'Impossible de créer la matrice. Les dimensions des lignes ne correspondent pas !',
+    cannotMultiplyMatrix: 'Impossible de multiplier la matrice !',
+    squareMatrixRequired: 'La matrice doit être carrée !',
+    rowsMustMatch: 'Les lignes des matrices doivent correspondre !',
+    columnsMustMatch: 'Les colonnes des matrices doivent correspondre !',
+    singularMatrix: 'La matrice fournie est singulière !',
+    matrixExpected: 'Une matrice était attendue ! Reçu : {{type}}.',
+    // Vector
+    mismatchedDimensions: 'Les dimensions doivent correspondre pour la fonction « {{function}} » !',
+    incorrectCrossDimension: 'Le produit vectoriel est défini uniquement pour les vecteurs de dimension 3 !',
+    vectorExpected: 'Un vecteur était attendu ! Reçu : {{type}}.',
+    // Polynomial
+    univariatePolynomialOnly: 'Cette fonction est prise en charge uniquement pour les polynômes univariés !',
+    // Solve
+    convergenceFailed: 'Échec de la convergence ! {{iters}} itérations ont été tentées.',
+    endPointIsRoot: "Le point d'extrémité est une racine.",
+    zeroDerivative: 'La dérivée est nulle en x = {{x}}. Impossible de continuer.',
+    tooManyUnknowns: "Trop d'inconnues !",
+    solveSystemInfiniteSolutions: "Ce système ne possède pas un ensemble fini de solutions isolées !",
+    solveSystemPolynomialOnly: 'solveSystem prend actuellement en charge uniquement les systèmes linéaires ou polynomiaux !',
+    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 !',
+    // Set Function
+    setJSFunctionExpectsFunction: 'Le paramètre function lors de la définition d’une fonction JS doit être de type function !',
+    functionRequiresMinAndMaxArgs: 'Vous devez fournir un nombre minimal et maximal d’arguments lors de la définition de la fonction !',
+};
+(0, errors_1.registerLanguage)('fra', catalog);
+if (typeof NERDAMER_BUILD_LANGUAGE !== 'undefined' && NERDAMER_BUILD_LANGUAGE === 'fra') {
+    Settings_1.Settings.LANGUAGE = 'fra';
+}
+exports.default = catalog;

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

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