nerdamer 2.0.0-rc.1 → 2.0.0

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;

package/output/api/languages/nld.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: 'Deze methode is nog niet geïmplementeerd.',
+    noInverse: 'Kan de inverse niet berekenen!',
+    undefinedValue: 'De gevraagde waarde is niet gedefinieerd!',
+    nullValue: 'Er werd een waarde verwacht, maar null werd ontvangen.',
+    univariateInputOnly: 'De invoer voor deze functie moet univariaat zijn!',
+    differentSignsAtEndPointsRequired: 'De functie moet tegengestelde tekens hebben bij de eindpunten a en b!',
+    integerRequired: 'Deze functie vereist dat de coëfficiënt een geheel getal is!',
+    plainVariableExpected: 'Er werd een eenvoudige variabele verwacht! Ontvangen: {{input}}.',
+    missingReference: 'De verwijzing "{{ref}}" bestaat niet in dit patroon!',
+    undefinedDivision: 'Deling is niet gedefinieerd voor een uitdrukking van dit type! {{type}}',
+    restrictedVariableName: 'Kan de gevraagde waarde niet toewijzen aan de gereserveerde naam "{{name}}"!',
+    noVariableInExpression: 'Geen variabele gevonden in de uitdrukking!',
+    quadraticExpressionExpected: 'De uitdrukking moet kwadratisch zijn!',
+    wrongInput: 'Onjuiste invoer! Verwacht: {{expected}}, ontvangen: {{received}}.',
+    unsupportedFunction: 'Niet-ondersteunde functie "{{function}}".',
+    functionMinArgs: '{{function}} vereist ten minste {{min}} argumenten, maar er zijn {{actual}} ontvangen.',
+    functionMaxArgs: '{{function}} staat maximaal {{max}} argumenten toe, maar er zijn {{actual}} ontvangen.',
+    invalidFunctionDeclaration: 'Ongeldige functiedeclaratie "{{declaration}}".',
+    indexOutOfBounds: 'Index {{index}} valt buiten het bereik van {{type}} met lengte {{length}}.',
+    matrixRowIndexOutOfBounds: 'Rij-index {{index}} valt buiten het bereik van Matrix met {{length}} rijen.',
+    matrixColumnIndexOutOfBounds: 'Kolomindex {{index}} valt buiten het bereik van Matrix met {{length}} kolommen.',
+    dictionaryKeyNotFound: 'Sleutel "{{key}}" is niet gevonden in Dictionary. Beschikbare sleutels: {{keys}}.',
+    rangeValuesFinite: 'Bereikwaarden moeten eindig zijn.',
+    rangeStepNonzero: 'De bereikstap mag niet nul zijn.',
+    rangeStepNoAdvance: 'De bereikstap gaat niet vooruit bij de huidige precisie.',
+    sparseVariableCountInvalid: 'SparsePolynomial variableCount moet een niet-negatief veilig geheel getal zijn.',
+    sparseExponentVectorLengthMismatch: 'De lengte van de exponentvector van SparsePolynomial moet gelijk zijn aan variableCount.',
+    sparseExponentsNonNegativeBigInt: 'SparsePolynomial-exponenten moeten niet-negatieve bigints zijn.',
+    sparseVariableIndexOutOfRing: 'De variabele-index van SparsePolynomial ligt buiten de polynoomring.',
+    sparseAdditionRingMismatch: 'Optellen van SparsePolynomial vereist dezelfde polynoomring.',
+    sparseCoefficientExponentNonNegative: 'De coëfficiëntexponent van SparsePolynomial moet niet-negatief zijn.',
+    sparseZeroMonomialDivision: 'SparsePolynomial kan niet door een nulmonoom worden gedeeld.',
+    sparseZeroScalarDivision: 'SparsePolynomial kan niet door nul worden gedeeld.',
+    sparseScalarDivisionExact: 'Scalaire deling van SparsePolynomial moet voor elke coëfficiënt exact zijn.',
+    sparseDivisionRingMismatch: 'Deling van SparsePolynomial vereist dezelfde polynoomring.',
+    sparseZeroPolynomialDivision: 'SparsePolynomial kan niet door de nulpolynoom worden gedeeld.',
+    sparseMonomialOrderUnsupported: 'De monoomvolgorde van SparsePolynomial wordt niet ondersteund.',
+    sparseMultiplicationRingMismatch: 'Vermenigvuldiging van SparsePolynomial vereist dezelfde polynoomring.',
+    sparseExponentNonNegative: 'De exponent van SparsePolynomial moet niet-negatief zijn.',
+    sparseSubtractionRingMismatch: 'Aftrekken van SparsePolynomial vereist dezelfde polynoomring.',
+    invalidDecimal: 'Ongeldige Decimal: "{{value}}"',
+    invalidInterval: 'Ongeldig interval: ({{start}}, {{end}})',
+    invalidAssumption: 'Ongeldige aanname: "{{input}}"',
+    assumptionIdentifierExpected: 'Identificator verwacht',
+    assumptionOperatorMissing: 'Operator ontbreekt',
+    assumptionValueMissing: 'Waarde ontbreekt',
+    assumptionOperatorUnsupported: 'Niet-ondersteunde operator "{{operator}}"',
+    matrixStringKeyUnsupported: 'Matrix ondersteunt geen toegang via tekstsleutels',
+    matrixTraceUnavailable: 'Kan de spoorwaarde van de matrix niet berekenen',
+    defintMaxEvals: 'defint: maxEvals overschreden ({{max}}).',
+    defintNonFiniteValue: 'defint: f(x) is niet eindig bij x={{x}}',
+    defintEndpointSingularity: 'defint: eindpuntsingulariteit kon niet worden geregulariseerd nabij x={{x}}',
+    defintSingularity: 'defint: singulariteit of niet-eindige waarde aangetroffen nabij [{{a}}, {{b}}]',
+    defintInfiniteBounds: 'defint: oneindige grenzen vereisen allowInfinite: true',
+    defintUnsupportedInfiniteBounds: 'defint: niet-ondersteunde configuratie van oneindige grenzen',
+    symbolicAccessNamedTargetRequired: 'Symbolische geïndexeerde toegang vereist een benoemd Vector- of Matrix-doel.',
+    symbolicVectorIndexCount: 'Symbolische Vector-toegang vereist precies één index.',
+    symbolicMatrixRowNonScalar: 'Symbolische toegang tot een Matrix-rij is niet scalair en kan niet als Expression worden uitgesteld.',
+    symbolicMatrixCellIndexCount: 'Symbolische toegang tot een Matrix-cel vereist precies twee indices.',
+    symbolicAccessMaxIndices: 'Symbolische geïndexeerde toegang ondersteunt maximaal twee onopgeloste indices.',
+    symbolicAccessIndexScalar: 'Indices voor symbolische toegang moeten evalueren naar scalaire expressies.',
+    symbolicAccessTargetType: 'Het doel van symbolische geïndexeerde toegang moet oplossen naar Vector of Matrix.',
+    expectedOperatorOrFunction: 'Operator of functienaam verwacht, maar "{{value}}" gevonden!',
+    missingOpeningBracket: 'Openingshaak ontbreekt voor "{{bracket}}":{{position}}',
+    missingClosingBracket: 'Sluitingshaak ontbreekt voor "{{bracket}}":{{position}}',
+    prefixOperatorExpected: 'Prefixoperator verwacht, maar {{operator}} aangetroffen.',
+    groebnerBasisSizeBudgetExceeded: 'Groebner-budget overschreden: basisgrootte > {{max}}',
+    groebnerPairsBudgetExceeded: 'Groebner-budget overschreden: pairsPopped > {{max}}',
+    unsupportedParserEntity: 'Niet-ondersteunde parserentiteit',
+    factorialNegativeUndefined: 'Faculteit is niet gedefinieerd voor negatieve gehele getallen.',
+    erfConvergenceFailed: 'erf convergeert niet. Afbreken!',
+    defintInfiniteBoundsDecimal: 'defint: oneindige grenzen vereisen allowInfinite:true',
+    seqStartsAtInteger: "startsAt moet een geheel getal zijn",
+    seqPolynomialOrMaxPower: "De reeks is geen polynoom of overschrijdt maxPower",
+    seqInsufficientData: "Onvoldoende gegevenspunten voor de gedetecteerde graad",
+    arithPowNegativeExponent: "pow: negatieve exponent",
+    arithPowNNonnegativeInteger: "powN: de exponent moet een niet-negatief geheel getal zijn",
+    arithBigIntSqrtNegative: "bigIntSqrt: negatieve invoer",
+    arithNthRootPositiveInteger: "intNthRootExact: n moet een positief geheel getal zijn",
+    arithDivisorsPositive: "getDivisors: n moet positief zijn",
+    arithModNormNonzeroModulus: "modNorm: de modulus mag niet nul zijn",
+    arithModSymmetricNonzeroModulus: "modSymmetric: de modulus mag niet nul zijn",
+    arithModInvZeroNoninvertible: "modInv: niet-inverteerbaar (0)",
+    arithModInvNoninvertible: "modInv: niet-inverteerbaar",
+    integerSqrtNonnegative: "De gehele vierkantswortel vereist een niet-negatieve waarde.",
+    modularExponentiationPositiveModulus: "Modulaire machtsverheffing vereist een positieve modulus.",
+    modularExponentiationNonnegativeExponent: "Modulaire machtsverheffing vereist een niet-negatieve exponent.",
+    maxBigIntRequiresArgument: "maxBigInt() vereist ten minste één argument",
+    minBigIntEmpty: "Het minimum van een lege lijst is niet gedefinieerd voor BigInt.",
+    binomBigIntNonnegativeN: "binomBigInt: n moet niet-negatief zijn",
+    invalidDecimalValue: "Ongeldige decimale waarde: {{value}}",
+    subtractionNotDefined: "Aftrekking is niet gedefinieerd voor {{leftType}}-{{rightType}} | {{left}}-{{right}}",
+    sparseAdapterVariablesUnique: "De variabelen van de sparse-polynoomadapter moeten uniek zijn.",
+    sparseAdapterVariablesIncludeEvery: "De variabelen van de sparse-polynoomadapter moeten elke polynoomvariabele bevatten.",
+    sparseExpressionConversionNameCount: "Conversie van een expressie naar een sparse polynoom vereist één naam per ringvariabele.",
+    converterMissingArgumentScope: "Argumentbereik ontbreekt voor functie {{function}}",
+    converterMissingPrefixOperand: "Operand ontbreekt voor prefixoperator {{operator}}",
+    converterMissingOperandMetadata: "Operand of metadata ontbreekt voor operator {{operator}}",
+    converterMissingLeftOperand: "Linkeroperand ontbreekt voor operator {{operator}}",
+    converterTexConversionFailed: "Kan de bronexpressie niet naar TeX converteren",
+    unknownOperator: "Onbekende operator {{operator}}",
+    polynomialMaximumIterations: "Maximum aantal iteraties bereikt",
+    polyRequires: "{{operation}} vereist {{requirement}}.",
+    polyVariablesUnique: "De variabelen van {{operation}} moeten uniek zijn.",
+    polyVariablesRingOrder: "De variabelen van {{operation}} moeten de volgorde van de polynoomring volgen.",
+    polyVariablesIncludeActive: "De variabelen van {{operation}} moeten elke actieve variabele bevatten.",
+    polyInputsSelectedOnly: "De invoer van {{operation}} mag alleen de geselecteerde variabelen gebruiken.",
+    polyCannotFactorZeroPolynomial: "{{operation}} kan de nulpolynoom niet ontbinden.",
+    polyCannotFactorZero: "{{operation}} kan nul niet ontbinden.",
+    polyModulusGreaterThanOne: "De modulus van ModularSparsePolynomial moet groter zijn dan één.",
+    polyVariableCountMatch: "variableCount van ModularSparsePolynomial moet overeenkomen met de opgegeven sparse polynoom.",
+    polyInterpolationCannotDepend: "Interpolatiemonsters van ModularSparsePolynomial mogen niet afhangen van de geïnterpoleerde variabele.",
+    polyInterpolationInvertibleDifferences: "Interpolatiepunten van ModularSparsePolynomial moeten paarsgewijs inverteerbare verschillen hebben.",
+    polyCoefficientExponentNonnegative: "De coëfficiëntexponent van ModularSparsePolynomial moet niet-negatief zijn.",
+    polyCannotDivideZero: "ModularSparsePolynomial kan niet delen door de nulpolynoom.",
+    polyDivisorLeadingCoefficientInvertible: "De leidende coëfficiënt van de deler van ModularSparsePolynomial is niet inverteerbaar.",
+    polyLeadingCoefficientInvertible: "De leidende coëfficiënt van ModularSparsePolynomial is niet inverteerbaar.",
+    polyExponentNonnegative: "De exponent van ModularSparsePolynomial moet niet-negatief zijn.",
+    polyDegreeMatrixLimit: "De graad van de modulaire factorisatie overschrijdt de ondersteunde matrixdimensie.",
+    polyExtendedGcdTwoZeroUndefined: "De uitgebreide modulaire GGD is niet gedefinieerd voor twee nulpolynomen.",
+    polyHenselPrimeExceedsTailDegree: "Het priemgetal voor multivariate Hensel-lifting moet groter zijn dan de graad van elke staartvariabele.",
+    polyHenselTargetNotSmaller: "De doelmodulus van Hensel-lifting mag niet kleiner zijn dan het basispriemgetal.",
+    polyHenselTargetRepeatedSquaring: "De doelmodulus van Hensel-lifting moet worden verkregen door herhaald kwadrateren van het basispriemgetal.",
+    polyHenselFactorsReconstructModuloBase: "De Hensel-liftingfactoren reconstrueren de gehele polynoom modulo het basispriemgetal niet.",
+    polyZassenhausFactorsReconstructModuloLift: "De factoren van Zassenhaus-recombinatie reconstrueren de invoer modulo de liftmodulus niet.",
+    polyWangCannotSpecializeZero: "De Wang-evaluatiezoekopdracht kan nul niet specialiseren.",
+    polyModularContentExactDivision: "De inhoud van de modulaire polynoom moet de polynoom exact delen.",
+    factorizationNoFactors: "De niet-constante factorisatie leverde geen factoren op.",
+    polyCrtModuliInvertible: "De CRT-moduli van de polynoom moeten inverteerbaar zijn.",
+    polyIntegerFactorPrimeZero: "Gehele factorisatie kan geen priemgetal voor nul kiezen.",
+    polySquareFreeNonExactDivision: "De kwadraatvrije factorisatie trof een niet-exacte polynoomdeling aan.",
+    polyZassenhausLostRemaining: "De Zassenhaus-recombinatie verloor de resterende polynoom.",
+    polyZassenhausReconstructionFailed: "De factoren van Zassenhaus-recombinatie reconstrueren de gehele polynoom niet.",
+    polyIntegerFactorLostLeading: "Gehele factorisatie verloor de leidende term.",
+    parserMalformedSymbolicAccessor: "Ongeldige interne symbolische accessor.",
+    parserMalformedSymbolicAccessorIndex: "Ongeldige index van een interne symbolische accessor.",
+    unknownOperatorAction: "Onbekende operatoractie {{action}}",
+    parserBracketTokenMissingCharacter: "Het haakjestoken mist zijn teken.",
+    polyWangLeadingEvaluationInteger: "De Wang-evaluatie van de leidende coëfficiënt leverde geen geheel getal op.",
+    polyWangSpecializedLeadingInteger: "De gespecialiseerde Wang-factor had geen gehele leidende coëfficiënt.",
+    polyMultivariateContentDivisionFailed: "De multivariate factorisatie kon een kwadraatvrij blok niet delen door zijn inhoud in de hoofdvariabele.",
+    polyMultivariateContentVariableMissing: "De multivariate inhoud van de hoofdvariabele behield geen actieve coëfficiëntvariabele.",
+    polyMultivariateReconstructionFailed: "De volledige multivariate factorisatie reconstrueert de invoerpolynoom niet.",
+    polyBerlekampNoninvertiblePivot: "Berlekamp-eliminatie trof een niet-inverteerbaar pivot aan.",
+    polyHenselZeroFactorGroup: "Hensel-lifting kan geen nulfactorgroep liften.",
+    polyHenselCannotLiftZero: "Hensel-lifting kan de nulpolynoom niet liften.",
+    polyHenselModulusExceeded: "Hensel-lifting overschreed de gevraagde priemmachtsmodulus.",
+    polyHenselLeadingLost: "Hensel-lifting verloor de leidende doelcoëfficiënt.",
+    polyHenselReconstructionFailed: "De door Hensel gelifte factoren reconstrueren de doelpolynoom niet.",
+    polyBerlekampNonExactSplit: "Berlekamp-splitsing leverde een niet-exacte factordeling op.",
+    polyBerlekampIncompleteSplit: "Berlekamp-factorisatie splitste de polynoom niet volledig.",
+    polyBerlekampReconstructionFailed: "De Berlekamp-factoren reconstrueren de invoerpolynoom niet.",
+    expressionKeyValueUnsupported: "De functie 'keyValue' is niet geïmplementeerd voor type {{type}}.",
+    solveLinearNonlinearDegree: "Niet-lineaire term gedetecteerd in vergelijking {{equation}}: term van graad {{degree}} gevonden. solveLinearSystem verwerkt alleen lineaire systemen.",
+    solveLinearNonPolynomialVariable: "Niet-lineaire term gedetecteerd in vergelijking {{equation}}: variabele \"{{variable}}\" verschijnt op een niet-polynomiale positie. solveLinearSystem verwerkt alleen lineaire systemen.",
+    polyReqPrimeModulus: "een priemmodulus",
+    polyReqUnivariatePolynomial: "een univariate polynoom",
+    polyReqSquareFreeInput: "kwadraatvrije invoer",
+    polyReqSamePolynomialRing: "dezelfde polynoomring",
+    polyReqAtLeastOneVariable: "ten minste één variabele",
+    polyReqAtLeastTwoSelectedVariables: "ten minste twee geselecteerde variabelen",
+    polyReqOneEvaluationPerTailVariable: "één evaluatiewaarde per staartvariabele",
+    polyReqMatchingFactorLeadingLists: "overeenkomende lijsten met factoren en leidende coëfficiënten",
+    polyReqPairwiseCoprimeModularFactors: "paarsgewijs onderling ondeelbare modulaire factoren",
+    polyReqPrimeBaseModulus: "een prieme basismodulus",
+    polyReqAtLeastOneModularFactor: "ten minste één modulaire factor",
+    polyReqUnivariateIntegerPolynomial: "een univariate gehele polynoom",
+    polyReqFactorsSameRingAndPrime: "factoren uit dezelfde gehele polynoomring en hetzelfde basispriemgetal",
+    polyReqUnivariateFactors: "univariate factoren",
+    polyReqMonicModularFactors: "monische modulaire factoren",
+    polyReqPrimitiveIntegerPolynomial: "een primitieve gehele polynoom",
+    polyReqPositiveLeadingCoefficient: "een positieve leidende coëfficiënt",
+    polyReqLiftedModularFactors: "gelifte modulaire factoren",
+    polyReqLiftedFactorsSameRing: "gelifte factoren uit één polynoomring",
+    polyReqUnivariateLiftedFactors: "univariate gelifte factoren",
+    polyReqMonicLiftedFactors: "monische gelifte factoren",
+    polyReqLargerHenselModulus: "een grotere Hensel-liftmodulus",
+    polyReqPrimitivePolynomial: "een primitieve polynoom",
+    polyReqPositiveLexLeadingSign: "een positief lexicografisch leidend teken",
+    polyReqSquareFreeMainVariable: "kwadraatvrije invoer in de hoofdvariabele",
+    polyReqExactlyTwoSelectedVariables: "precies twee geselecteerde variabelen",
+    polyReqExactlyTwoVariables: "precies twee variabelen",
+    polyReqOneValuePerNonMainVariable: "één waarde voor elke geselecteerde niet-hoofdvariabele",
+    polyReqOneValuePerTailVariable: "één waarde voor elke staartvariabele",
+    polyReqPositiveDegreeMainVariable: "een positieve graad in de hoofdvariabele",
+    polyReqAllOtherVariablesDormant: "dat alle andere variabelen inactief zijn",
+    polyReqPositiveModuli: "positieve moduli",
+    polyReqCoprimeModuli: "onderling ondeelbare moduli",
+    polyReqAtLeastOneSample: "ten minste één monster",
+    polyReqInvertibleLeadingCoefficient: "een inverteerbare leidende coëfficiënt",
+    polyReqIntegerLeadingCoefficientInvertible: "dat de gehele leidende coëfficiënt modulo het basispriemgetal inverteerbaar is",
+    infinityMinusInfinityUndefined: 'Oneindig min oneindig is niet gedefinieerd!',
+    // Assumptions
+    inconsistentAssumptions: 'De aannames zijn inconsistent (lege doorsnede)!',
+    // Parser
+    unsupportedType: 'Het opgegeven type ({{type}}) wordt niet ondersteund voor deze functie!',
+    unsupportedOperation: 'Deze bewerking wordt momenteel niet ondersteund!',
+    buildFunctionUnsupportedFunction: 'buildFunction kan de functie "{{function}}" niet compileren naar JavaScript-rekenkunde met getallen!',
+    buildFunctionComplexUnsupported: 'buildFunction kan uitdrukkingen met de imaginaire eenheid niet compileren naar JavaScript-rekenkunde met getallen!',
+    nonMatchingDimensions: 'Deze bewerking kan niet worden voltooid omdat de dimensies niet overeenkomen!',
+    malformedExpression: 'Kan de onjuist gevormde uitdrukking niet parseren!',
+    unsupportedCharacter: 'Niet-ondersteund teken "{{character}}" op positie {{position}}.',
+    missingCommentDelimiter: 'Afsluitende commentaarscheiding "{{delimiter}}" ontbreekt.',
+    divisionByZero: 'Delen door nul is niet gedefinieerd!',
+    zeroToZeroPower: '0^0 is niet gedefinieerd!',
+    infinityToPowerZero: 'Oneindig^0 is niet gedefinieerd!',
+    infinityTimesZero: '0*Oneindig is niet gedefinieerd!',
+    infinityToInfinity: 'Oneindig^Oneindig is niet gedefinieerd!',
+    valueToInfinityUndefined: '{{value}}^Oneindig is niet gedefinieerd!',
+    atan2Undefined: 'atan2 is niet gedefinieerd voor 0, 0!',
+    tanUndefined: 'tan is niet gedefinieerd voor veelvouden van pi/2!',
+    loopIterationLimitExceeded: 'De lus heeft het maximum van {{max}} iteraties overschreden.',
+    breakOutsideLoop: 'break kan alleen binnen een lus worden gebruikt.',
+    continueOutsideLoop: 'continue kan alleen binnen een lus worden gebruikt.',
+    letRequiresBindingsAndBody: 'let vereist een of meer naam/waarde-paren gevolgd door een hoofdexpressie.',
+    secUndefined: 'sec is niet gedefinieerd voor oneven veelvouden van pi/2!',
+    cscUndefined: 'csc is niet gedefinieerd voor veelvouden van pi!',
+    cotUndefined: 'cot is niet gedefinieerd voor veelvouden van pi!',
+    cothUndefined: 'coth is niet gedefinieerd voor 0!',
+    cschUndefined: 'csch is niet gedefinieerd voor 0!',
+    atanhUndefined: 'atanh is niet gedefinieerd voor 0!',
+    cannotCreateArrayFromNaN: 'Kan geen array maken van NaN!',
+    expressionExpected: 'Er werd een uitdrukking verwacht! Ontvangen: {{type}}!',
+    // TeX Converter
+    unrecognizedMode: '"{{mode}}" is geen geldige modus!',
+    // Polynomials
+    notAPolynomial: 'De uitdrukking is geen geldig polynoom!',
+    multidegreeMismatch: 'Het aantal variabelen moet overeenkomen met de multigraad van het polynoom!',
+    unknownVariable: 'Onbekende variabele! "{{variable}}"',
+    // Matrix
+    cannotCreateMatrix: 'Kan de matrix niet maken. De rijafmetingen komen niet overeen!',
+    cannotMultiplyMatrix: 'Kan de matrix niet vermenigvuldigen!',
+    squareMatrixRequired: 'De matrix moet vierkant zijn!',
+    rowsMustMatch: 'De rijen van de matrices moeten overeenkomen!',
+    columnsMustMatch: 'De kolommen van de matrices moeten overeenkomen!',
+    singularMatrix: 'De opgegeven matrix is singulier!',
+    matrixExpected: 'Er werd een matrix verwacht! Ontvangen: {{type}}.',
+    // Vector
+    mismatchedDimensions: 'De dimensies moeten overeenkomen voor de functie "{{function}}"!',
+    incorrectCrossDimension: 'Het kruisproduct is alleen gedefinieerd voor vectoren met dimensie 3!',
+    vectorExpected: 'Er werd een vector verwacht! Ontvangen: {{type}}.',
+    // Polynomial
+    univariatePolynomialOnly: 'Deze functie wordt alleen ondersteund voor univariate polynomen!',
+    // Solve
+    convergenceFailed: 'Convergentie mislukt! Er zijn {{iters}} iteraties geprobeerd.',
+    endPointIsRoot: 'Het eindpunt is een wortel.',
+    zeroDerivative: 'De afgeleide is nul bij x = {{x}}. Kan niet doorgaan.',
+    tooManyUnknowns: 'Te veel onbekenden!',
+    solveSystemInfiniteSolutions: 'Dit stelsel heeft geen eindige verzameling geïsoleerde oplossingen!',
+    solveSystemPolynomialOnly: 'solveSystem ondersteunt momenteel alleen lineaire of polynomiale stelsels!',
+    solveSystemNonRationalUnsupported: 'Dit niet-lineaire polynomiale stelsel vereist een niet-rationele of niet-symbolische oplossing, die nog niet wordt ondersteund!',
+    // Set Function
+    setJSFunctionExpectsFunction: 'De functieparameter moet bij het instellen van een JS-functie van het type function zijn!',
+    functionRequiresMinAndMaxArgs: 'U moet het minimale en maximale aantal argumenten opgeven bij het instellen van de functie!',
+};
+(0, errors_1.registerLanguage)('nld', catalog);
+if (typeof NERDAMER_BUILD_LANGUAGE !== 'undefined' && NERDAMER_BUILD_LANGUAGE === 'nld') {
+    Settings_1.Settings.LANGUAGE = 'nld';
+}
+exports.default = catalog;

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

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