nerdamer 1.1.13 → 2.0.0-rc.2

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;

package/output/api/languages/ita.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: 'Questo metodo non è ancora stato implementato.',
+    noInverse: 'Impossibile calcolare l’inversa!',
+    undefinedValue: 'Il valore richiesto non è definito!',
+    nullValue: 'Era previsto un valore, ma è stato ricevuto null.',
+    univariateInputOnly: 'L’input di questa funzione deve essere univariato!',
+    differentSignsAtEndPointsRequired: 'La funzione deve avere segni opposti agli estremi a e b!',
+    integerRequired: 'Questa funzione richiede che il coefficiente sia un numero intero!',
+    plainVariableExpected: 'Era attesa una variabile semplice! Ricevuto: {{input}}.',
+    missingReference: 'Il riferimento "{{ref}}" non esiste in questo modello!',
+    undefinedDivision: 'La divisione non è definita per un’espressione di questo tipo! {{type}}',
+    restrictedVariableName: 'Impossibile assegnare il valore richiesto al nome riservato "{{name}}"!',
+    noVariableInExpression: 'Nessuna variabile trovata nell’espressione!',
+    quadraticExpressionExpected: 'L’espressione deve essere quadratica!',
+    wrongInput: 'Input errato! Atteso {{expected}}, ricevuto {{received}}.',
+    unsupportedFunction: 'Funzione non supportata "{{function}}".',
+    functionMinArgs: '{{function}} richiede almeno {{min}} argomenti, ma ne sono stati ricevuti {{actual}}.',
+    functionMaxArgs: '{{function}} consente al massimo {{max}} argomenti, ma ne sono stati ricevuti {{actual}}.',
+    invalidFunctionDeclaration: 'Dichiarazione di funzione non valida "{{declaration}}".',
+    indexOutOfBounds: 'L’indice {{index}} è fuori dai limiti per {{type}} di lunghezza {{length}}.',
+    matrixRowIndexOutOfBounds: 'L’indice di riga {{index}} è fuori dai limiti per Matrix con {{length}} righe.',
+    matrixColumnIndexOutOfBounds: 'L’indice di colonna {{index}} è fuori dai limiti per Matrix con {{length}} colonne.',
+    dictionaryKeyNotFound: 'La chiave "{{key}}" non è stata trovata in Dictionary. Chiavi disponibili: {{keys}}.',
+    rangeValuesFinite: 'I valori dell’intervallo devono essere finiti.',
+    rangeStepNonzero: 'Il passo dell’intervallo non può essere zero.',
+    rangeStepNoAdvance: 'Il passo dell’intervallo non avanza con la precisione corrente.',
+    sparseVariableCountInvalid: 'SparsePolynomial variableCount deve essere un intero sicuro non negativo.',
+    sparseExponentVectorLengthMismatch: 'La lunghezza del vettore degli esponenti di SparsePolynomial deve essere uguale a variableCount.',
+    sparseExponentsNonNegativeBigInt: 'Gli esponenti di SparsePolynomial devono essere bigint non negativi.',
+    sparseVariableIndexOutOfRing: 'L’indice della variabile di SparsePolynomial è fuori dall’anello polinomiale.',
+    sparseAdditionRingMismatch: 'L’addizione di SparsePolynomial richiede lo stesso anello polinomiale.',
+    sparseCoefficientExponentNonNegative: 'L’esponente del coefficiente di SparsePolynomial deve essere non negativo.',
+    sparseZeroMonomialDivision: 'SparsePolynomial non può essere diviso per un monomio nullo.',
+    sparseZeroScalarDivision: 'SparsePolynomial non può essere diviso per zero.',
+    sparseScalarDivisionExact: 'La divisione scalare di SparsePolynomial deve essere esatta per ogni coefficiente.',
+    sparseDivisionRingMismatch: 'La divisione di SparsePolynomial richiede lo stesso anello polinomiale.',
+    sparseZeroPolynomialDivision: 'SparsePolynomial non può essere diviso per il polinomio nullo.',
+    sparseMonomialOrderUnsupported: 'L’ordine monomiale di SparsePolynomial non è supportato.',
+    sparseMultiplicationRingMismatch: 'La moltiplicazione di SparsePolynomial richiede lo stesso anello polinomiale.',
+    sparseExponentNonNegative: 'L’esponente di SparsePolynomial deve essere non negativo.',
+    sparseSubtractionRingMismatch: 'La sottrazione di SparsePolynomial richiede lo stesso anello polinomiale.',
+    invalidDecimal: 'Decimal non valido: "{{value}}"',
+    invalidInterval: 'Intervallo non valido: ({{start}}, {{end}})',
+    invalidAssumption: 'Ipotesi non valida: "{{input}}"',
+    assumptionIdentifierExpected: 'Identificatore atteso',
+    assumptionOperatorMissing: 'Operatore mancante',
+    assumptionValueMissing: 'Valore mancante',
+    assumptionOperatorUnsupported: 'Operatore non supportato "{{operator}}"',
+    matrixStringKeyUnsupported: 'Matrix non supporta l’accesso tramite chiave testuale',
+    matrixTraceUnavailable: 'Impossibile calcolare la traccia della matrice',
+    defintMaxEvals: 'defint: maxEvals superato ({{max}}).',
+    defintNonFiniteValue: 'defint: f(x) non finita in x={{x}}',
+    defintEndpointSingularity: 'defint: impossibile regolarizzare la singolarità dell’estremo vicino a x={{x}}',
+    defintSingularity: 'defint: singularità o valore non finito incontrato vicino a [{{a}}, {{b}}]',
+    defintInfiniteBounds: 'defint: i limiti infiniti richiedono allowInfinite: true',
+    defintUnsupportedInfiniteBounds: 'defint: configurazione di limiti infiniti non supportata',
+    symbolicAccessNamedTargetRequired: 'L’accesso indicizzato simbolico richiede un obiettivo Vector o Matrix con nome.',
+    symbolicVectorIndexCount: 'L’accesso simbolico a Vector richiede esattamente un indice.',
+    symbolicMatrixRowNonScalar: 'L’accesso simbolico a una riga di Matrix non è scalare e non può essere differito come Expression.',
+    symbolicMatrixCellIndexCount: 'L’accesso simbolico a una cella di Matrix richiede esattamente due indici.',
+    symbolicAccessMaxIndices: 'L’accesso indicizzato simbolico supporta al massimo due indici non risolti.',
+    symbolicAccessIndexScalar: 'Gli indici dell’accesso simbolico devono valutarsi come espressioni scalari.',
+    symbolicAccessTargetType: 'L’obiettivo dell’accesso indicizzato simbolico deve risolversi in Vector o Matrix.',
+    expectedOperatorOrFunction: 'Era atteso un operatore o un nome di funzione, ma è stato trovato "{{value}}"!',
+    missingOpeningBracket: 'Manca la parentesi di apertura per "{{bracket}}":{{position}}',
+    missingClosingBracket: 'Manca la parentesi di chiusura per "{{bracket}}":{{position}}',
+    prefixOperatorExpected: 'Era atteso un operatore prefisso, ma è stato incontrato {{operator}}.',
+    groebnerBasisSizeBudgetExceeded: 'Budget di Groebner superato: dimensione della base > {{max}}',
+    groebnerPairsBudgetExceeded: 'Budget di Groebner superato: pairsPopped > {{max}}',
+    unsupportedParserEntity: 'Entità del parser non supportata',
+    factorialNegativeUndefined: 'Il fattoriale non è definito per interi negativi.',
+    erfConvergenceFailed: 'erf non converge. Uscita!',
+    defintInfiniteBoundsDecimal: 'defint: i limiti infiniti richiedono allowInfinite:true',
+    seqStartsAtInteger: "startsAt deve essere un intero",
+    seqPolynomialOrMaxPower: "La sequenza non è un polinomio o supera maxPower",
+    seqInsufficientData: "Punti dati insufficienti per il grado rilevato",
+    arithPowNegativeExponent: "pow: esponente negativo",
+    arithPowNNonnegativeInteger: "powN: l'esponente deve essere un intero non negativo",
+    arithBigIntSqrtNegative: "bigIntSqrt: input negativo",
+    arithNthRootPositiveInteger: "intNthRootExact: n deve essere un intero positivo",
+    arithDivisorsPositive: "getDivisors: n deve essere positivo",
+    arithModNormNonzeroModulus: "modNorm: il modulo deve essere diverso da zero",
+    arithModSymmetricNonzeroModulus: "modSymmetric: il modulo deve essere diverso da zero",
+    arithModInvZeroNoninvertible: "modInv: non invertibile (0)",
+    arithModInvNoninvertible: "modInv: non invertibile",
+    integerSqrtNonnegative: "La radice quadrata intera richiede un valore non negativo.",
+    modularExponentiationPositiveModulus: "L'esponenziazione modulare richiede un modulo positivo.",
+    modularExponentiationNonnegativeExponent: "L'esponenziazione modulare richiede un esponente non negativo.",
+    maxBigIntRequiresArgument: "maxBigInt() richiede almeno un argomento",
+    minBigIntEmpty: "Il minimo di una lista vuota non è definito per BigInt.",
+    binomBigIntNonnegativeN: "binomBigInt: n deve essere non negativo",
+    invalidDecimalValue: "Valore decimale non valido: {{value}}",
+    subtractionNotDefined: "La sottrazione non è definita per {{leftType}}-{{rightType}} | {{left}}-{{right}}",
+    sparseAdapterVariablesUnique: "Le variabili dell'adattatore per polinomi sparsi devono essere univoche.",
+    sparseAdapterVariablesIncludeEvery: "Le variabili dell'adattatore per polinomi sparsi devono includere ogni variabile del polinomio.",
+    sparseExpressionConversionNameCount: "La conversione di un'espressione in polinomio sparso richiede un nome per ogni variabile dell'anello.",
+    converterMissingArgumentScope: "Manca l'ambito degli argomenti per la funzione {{function}}",
+    converterMissingPrefixOperand: "Manca l'operando per l'operatore prefisso {{operator}}",
+    converterMissingOperandMetadata: "Manca l'operando o i metadati per l'operatore {{operator}}",
+    converterMissingLeftOperand: "Manca l'operando sinistro per l'operatore {{operator}}",
+    converterTexConversionFailed: "Impossibile convertire l'espressione di origine in TeX",
+    unknownOperator: "Operatore sconosciuto {{operator}}",
+    polynomialMaximumIterations: "Raggiunto il numero massimo di iterazioni",
+    polyRequires: "{{operation}} richiede {{requirement}}.",
+    polyVariablesUnique: "Le variabili di {{operation}} devono essere univoche.",
+    polyVariablesRingOrder: "Le variabili di {{operation}} devono seguire l'ordine dell'anello polinomiale.",
+    polyVariablesIncludeActive: "Le variabili di {{operation}} devono includere ogni variabile attiva.",
+    polyInputsSelectedOnly: "Gli input di {{operation}} possono usare solo le variabili selezionate.",
+    polyCannotFactorZeroPolynomial: "{{operation}} non può fattorizzare il polinomio zero.",
+    polyCannotFactorZero: "{{operation}} non può fattorizzare zero.",
+    polyModulusGreaterThanOne: "Il modulo di ModularSparsePolynomial deve essere maggiore di uno.",
+    polyVariableCountMatch: "variableCount di ModularSparsePolynomial deve corrispondere al polinomio sparso fornito.",
+    polyInterpolationCannotDepend: "I campioni di interpolazione di ModularSparsePolynomial non possono dipendere dalla variabile interpolata.",
+    polyInterpolationInvertibleDifferences: "I punti di interpolazione di ModularSparsePolynomial devono avere differenze a coppie invertibili.",
+    polyCoefficientExponentNonnegative: "L'esponente del coefficiente di ModularSparsePolynomial deve essere non negativo.",
+    polyCannotDivideZero: "ModularSparsePolynomial non può dividere per il polinomio zero.",
+    polyDivisorLeadingCoefficientInvertible: "Il coefficiente principale del divisore di ModularSparsePolynomial non è invertibile.",
+    polyLeadingCoefficientInvertible: "Il coefficiente principale di ModularSparsePolynomial non è invertibile.",
+    polyExponentNonnegative: "L'esponente di ModularSparsePolynomial deve essere non negativo.",
+    polyDegreeMatrixLimit: "Il grado della fattorizzazione modulare supera la dimensione di matrice supportata.",
+    polyExtendedGcdTwoZeroUndefined: "Il MCD esteso modulare non è definito per due polinomi zero.",
+    polyHenselPrimeExceedsTailDegree: "Il primo del sollevamento di Hensel multivariato deve superare il grado di ogni variabile di coda.",
+    polyHenselTargetNotSmaller: "Il modulo obiettivo del sollevamento di Hensel non può essere minore del primo di base.",
+    polyHenselTargetRepeatedSquaring: "Il modulo obiettivo del sollevamento di Hensel deve essere ottenuto mediante quadrature ripetute del primo di base.",
+    polyHenselFactorsReconstructModuloBase: "I fattori del sollevamento di Hensel non ricostruiscono il polinomio intero modulo il primo di base.",
+    polyZassenhausFactorsReconstructModuloLift: "I fattori della ricombinazione di Zassenhaus non ricostruiscono l'input modulo il modulo di sollevamento.",
+    polyWangCannotSpecializeZero: "La ricerca di valutazione di Wang non può specializzare zero.",
+    polyModularContentExactDivision: "Il contenuto del polinomio modulare deve dividere esattamente il polinomio.",
+    factorizationNoFactors: "La fattorizzazione non costante non ha restituito fattori.",
+    polyCrtModuliInvertible: "I moduli CRT del polinomio devono essere invertibili.",
+    polyIntegerFactorPrimeZero: "La fattorizzazione intera non può scegliere un primo per zero.",
+    polySquareFreeNonExactDivision: "La fattorizzazione priva di fattori quadrati ha incontrato una divisione polinomiale non esatta.",
+    polyZassenhausLostRemaining: "La ricombinazione di Zassenhaus ha perso il polinomio rimanente.",
+    polyZassenhausReconstructionFailed: "I fattori della ricombinazione di Zassenhaus non ricostruiscono il polinomio intero.",
+    polyIntegerFactorLostLeading: "La fattorizzazione intera ha perso il termine principale.",
+    parserMalformedSymbolicAccessor: "Accessor simbolico interno non valido.",
+    parserMalformedSymbolicAccessorIndex: "Indice dell'accessor simbolico interno non valido.",
+    unknownOperatorAction: "Azione dell'operatore sconosciuta {{action}}",
+    parserBracketTokenMissingCharacter: "Al token di parentesi manca il carattere.",
+    polyWangLeadingEvaluationInteger: "La valutazione del coefficiente principale di Wang non ha prodotto un intero.",
+    polyWangSpecializedLeadingInteger: "Il fattore specializzato di Wang non aveva un coefficiente principale intero.",
+    polyMultivariateContentDivisionFailed: "La fattorizzazione multivariata non ha potuto dividere un blocco privo di fattori quadrati per il suo contenuto nella variabile principale.",
+    polyMultivariateContentVariableMissing: "Il contenuto multivariato della variabile principale non ha mantenuto una variabile di coefficiente attiva.",
+    polyMultivariateReconstructionFailed: "La fattorizzazione multivariata completa non ricostruisce il polinomio di input.",
+    polyBerlekampNoninvertiblePivot: "L'eliminazione di Berlekamp ha incontrato un pivot non invertibile.",
+    polyHenselZeroFactorGroup: "Il sollevamento di Hensel non può sollevare un gruppo di fattori zero.",
+    polyHenselCannotLiftZero: "Il sollevamento di Hensel non può sollevare il polinomio zero.",
+    polyHenselModulusExceeded: "Il sollevamento di Hensel ha superato il modulo di potenza prima richiesto.",
+    polyHenselLeadingLost: "Il sollevamento di Hensel ha perso il coefficiente principale obiettivo.",
+    polyHenselReconstructionFailed: "I fattori sollevati da Hensel non ricostruiscono il polinomio obiettivo.",
+    polyBerlekampNonExactSplit: "La separazione di Berlekamp ha prodotto una divisione di fattori non esatta.",
+    polyBerlekampIncompleteSplit: "La fattorizzazione di Berlekamp non ha separato completamente il polinomio.",
+    polyBerlekampReconstructionFailed: "I fattori di Berlekamp non ricostruiscono il polinomio di input.",
+    expressionKeyValueUnsupported: "La funzione 'keyValue' non è implementata per il tipo {{type}}.",
+    solveLinearNonlinearDegree: "Termine non lineare rilevato nell'equazione {{equation}}: trovato un termine di grado {{degree}}. solveLinearSystem gestisce solo sistemi lineari.",
+    solveLinearNonPolynomialVariable: "Termine non lineare rilevato nell'equazione {{equation}}: la variabile \"{{variable}}\" appare in una posizione non polinomiale. solveLinearSystem gestisce solo sistemi lineari.",
+    polyReqPrimeModulus: "un modulo primo",
+    polyReqUnivariatePolynomial: "un polinomio univariato",
+    polyReqSquareFreeInput: "un input privo di fattori quadrati",
+    polyReqSamePolynomialRing: "lo stesso anello polinomiale",
+    polyReqAtLeastOneVariable: "almeno una variabile",
+    polyReqAtLeastTwoSelectedVariables: "almeno due variabili selezionate",
+    polyReqOneEvaluationPerTailVariable: "un valore di valutazione per variabile di coda",
+    polyReqMatchingFactorLeadingLists: "elenchi corrispondenti di fattori e coefficienti principali",
+    polyReqPairwiseCoprimeModularFactors: "fattori modulari coprimi a coppie",
+    polyReqPrimeBaseModulus: "un modulo di base primo",
+    polyReqAtLeastOneModularFactor: "almeno un fattore modulare",
+    polyReqUnivariateIntegerPolynomial: "un polinomio intero univariato",
+    polyReqFactorsSameRingAndPrime: "fattori dello stesso anello di polinomi interi e dello stesso primo di base",
+    polyReqUnivariateFactors: "fattori univariati",
+    polyReqMonicModularFactors: "fattori modulari monici",
+    polyReqPrimitiveIntegerPolynomial: "un polinomio intero primitivo",
+    polyReqPositiveLeadingCoefficient: "un coefficiente principale positivo",
+    polyReqLiftedModularFactors: "fattori modulari sollevati",
+    polyReqLiftedFactorsSameRing: "fattori sollevati da un unico anello polinomiale",
+    polyReqUnivariateLiftedFactors: "fattori sollevati univariati",
+    polyReqMonicLiftedFactors: "fattori sollevati monici",
+    polyReqLargerHenselModulus: "un modulo di sollevamento di Hensel maggiore",
+    polyReqPrimitivePolynomial: "un polinomio primitivo",
+    polyReqPositiveLexLeadingSign: "un segno principale lessicografico positivo",
+    polyReqSquareFreeMainVariable: "un input privo di fattori quadrati nella variabile principale",
+    polyReqExactlyTwoSelectedVariables: "esattamente due variabili selezionate",
+    polyReqExactlyTwoVariables: "esattamente due variabili",
+    polyReqOneValuePerNonMainVariable: "un valore per ogni variabile selezionata non principale",
+    polyReqOneValuePerTailVariable: "un valore per ogni variabile di coda",
+    polyReqPositiveDegreeMainVariable: "grado positivo nella variabile principale",
+    polyReqAllOtherVariablesDormant: "che tutte le altre variabili siano inattive",
+    polyReqPositiveModuli: "moduli positivi",
+    polyReqCoprimeModuli: "moduli coprimi",
+    polyReqAtLeastOneSample: "almeno un campione",
+    polyReqInvertibleLeadingCoefficient: "un coefficiente principale invertibile",
+    polyReqIntegerLeadingCoefficientInvertible: "che il coefficiente principale intero sia invertibile modulo il primo di base",
+    infinityMinusInfinityUndefined: 'Infinito meno infinito non è definito!',
+    // Assumptions
+    inconsistentAssumptions: 'Le ipotesi sono incoerenti (intersezione vuota)!',
+    // Parser
+    unsupportedType: 'Il tipo fornito ({{type}}) non è supportato da questa funzione!',
+    unsupportedOperation: 'Questa operazione non è attualmente supportata!',
+    buildFunctionUnsupportedFunction: 'buildFunction non può compilare la funzione "{{function}}" nell’aritmetica numerica JavaScript!',
+    buildFunctionComplexUnsupported: 'buildFunction non può compilare espressioni contenenti l’unità immaginaria nell’aritmetica numerica JavaScript!',
+    nonMatchingDimensions: 'Questa operazione non può essere completata perché le dimensioni non corrispondono!',
+    malformedExpression: 'Impossibile analizzare l’espressione non valida!',
+    unsupportedCharacter: 'Carattere non supportato "{{character}}" alla posizione {{position}}.',
+    missingCommentDelimiter: 'Manca il delimitatore di chiusura del commento "{{delimiter}}".',
+    divisionByZero: 'La divisione per zero non è definita!',
+    zeroToZeroPower: '0^0 non è definito!',
+    infinityToPowerZero: 'Infinito^0 non è definito!',
+    infinityTimesZero: '0*Infinito non è definito!',
+    infinityToInfinity: 'Infinito^Infinito non è definito!',
+    valueToInfinityUndefined: '{{value}}^Infinito non è definito!',
+    atan2Undefined: 'atan2 non è definita per 0, 0!',
+    tanUndefined: 'tan non è definita per multipli di pi/2!',
+    loopIterationLimitExceeded: 'Il ciclo ha superato il massimo di {{max}} iterazioni.',
+    breakOutsideLoop: 'break può essere usato solo all’interno di un ciclo.',
+    continueOutsideLoop: 'continue può essere usato solo all’interno di un ciclo.',
+    letRequiresBindingsAndBody: 'let richiede una o più coppie nome/valore seguite da un’espressione corpo.',
+    secUndefined: 'sec non è definita per multipli dispari di pi/2!',
+    cscUndefined: 'csc non è definita per multipli di pi!',
+    cotUndefined: 'cot non è definita per multipli di pi!',
+    cothUndefined: 'coth non è definita per 0!',
+    cschUndefined: 'csch non è definita per 0!',
+    atanhUndefined: 'atanh non è definita per 0!',
+    cannotCreateArrayFromNaN: 'Impossibile creare un array da NaN!',
+    expressionExpected: 'Era attesa un’espressione! Ricevuto: {{type}}!',
+    // TeX Converter
+    unrecognizedMode: '"{{mode}}" non è una modalità valida!',
+    // Polynomials
+    notAPolynomial: 'L’espressione non è un polinomio valido!',
+    multidegreeMismatch: 'Il numero di variabili deve corrispondere al multigrado del polinomio!',
+    unknownVariable: 'Variabile sconosciuta! "{{variable}}"',
+    // Matrix
+    cannotCreateMatrix: 'Impossibile creare la matrice. Le dimensioni delle righe non corrispondono!',
+    cannotMultiplyMatrix: 'Impossibile moltiplicare la matrice!',
+    squareMatrixRequired: 'La matrice deve essere quadrata!',
+    rowsMustMatch: 'Le righe delle matrici devono corrispondere!',
+    columnsMustMatch: 'Le colonne delle matrici devono corrispondere!',
+    singularMatrix: 'La matrice fornita è singolare!',
+    matrixExpected: 'Era attesa una matrice! Ricevuto: {{type}}.',
+    // Vector
+    mismatchedDimensions: 'Le dimensioni devono corrispondere per la funzione "{{function}}"!',
+    incorrectCrossDimension: 'Il prodotto vettoriale è definito solo per vettori di dimensione 3!',
+    vectorExpected: 'Era atteso un vettore! Ricevuto: {{type}}.',
+    // Polynomial
+    univariatePolynomialOnly: 'Questa funzione è supportata solo per polinomi univariati!',
+    // Solve
+    convergenceFailed: 'Convergenza non riuscita! Sono state tentate {{iters}} iterazioni.',
+    endPointIsRoot: 'Il punto estremo è una radice.',
+    zeroDerivative: 'La derivata è zero in x = {{x}}. Impossibile continuare.',
+    tooManyUnknowns: 'Troppe incognite!',
+    solveSystemInfiniteSolutions: 'Questo sistema non ha un insieme finito di soluzioni isolate!',
+    solveSystemPolynomialOnly: 'solveSystem attualmente supporta solo sistemi lineari o polinomiali!',
+    solveSystemNonRationalUnsupported: 'Questo sistema polinomiale non lineare richiede una risoluzione non razionale o non simbolica, che non è ancora supportata!',
+    // Set Function
+    setJSFunctionExpectsFunction: 'Il parametro della funzione, quando si imposta una funzione JS, deve essere di tipo function!',
+    functionRequiresMinAndMaxArgs: 'È necessario fornire il numero minimo e massimo di argomenti quando si imposta la funzione!',
+};
+(0, errors_1.registerLanguage)('ita', catalog);
+if (typeof NERDAMER_BUILD_LANGUAGE !== 'undefined' && NERDAMER_BUILD_LANGUAGE === 'ita') {
+    Settings_1.Settings.LANGUAGE = 'ita';
+}
+exports.default = catalog;

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

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