nerdamer 1.1.13 → 2.0.0-rc.2

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;

package/output/api/languages/por.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: 'Este método ainda não foi implementado.',
+    noInverse: 'Não foi possível calcular a inversa!',
+    undefinedValue: 'O valor solicitado não está definido!',
+    nullValue: 'Era esperado um valor, mas foi recebido null.',
+    univariateInputOnly: 'A entrada desta função deve ser univariada!',
+    differentSignsAtEndPointsRequired: 'A função deve ter sinais opostos nos pontos extremos a e b!',
+    integerRequired: 'Esta função exige que o coeficiente seja um número inteiro!',
+    plainVariableExpected: 'Era esperada uma variável simples! Recebido: {{input}}.',
+    missingReference: 'A referência "{{ref}}" não existe neste padrão!',
+    undefinedDivision: 'A divisão não está definida para uma expressão deste tipo! {{type}}',
+    restrictedVariableName: 'Não é possível atribuir o valor solicitado ao nome reservado "{{name}}"!',
+    noVariableInExpression: 'Nenhuma variável foi encontrada na expressão!',
+    quadraticExpressionExpected: 'A expressão deve ser quadrática!',
+    wrongInput: 'Entrada incorreta! Esperado {{expected}}, mas recebido {{received}}.',
+    unsupportedFunction: 'Função não suportada "{{function}}".',
+    functionMinArgs: '{{function}} exige pelo menos {{min}} argumentos, mas {{actual}} foram recebidos.',
+    functionMaxArgs: '{{function}} permite no máximo {{max}} argumentos, mas {{actual}} foram recebidos.',
+    invalidFunctionDeclaration: 'Declaração de função inválida "{{declaration}}".',
+    indexOutOfBounds: 'O índice {{index}} está fora dos limites de {{type}} com comprimento {{length}}.',
+    matrixRowIndexOutOfBounds: 'O índice de linha {{index}} está fora dos limites de Matrix com {{length}} linhas.',
+    matrixColumnIndexOutOfBounds: 'O índice de coluna {{index}} está fora dos limites de Matrix com {{length}} colunas.',
+    dictionaryKeyNotFound: 'A chave "{{key}}" não foi encontrada em Dictionary. Chaves disponíveis: {{keys}}.',
+    rangeValuesFinite: 'Os valores do intervalo devem ser finitos.',
+    rangeStepNonzero: 'O passo do intervalo não pode ser zero.',
+    rangeStepNoAdvance: 'O passo do intervalo não avança com a precisão atual.',
+    sparseVariableCountInvalid: 'SparsePolynomial variableCount deve ser um inteiro seguro não negativo.',
+    sparseExponentVectorLengthMismatch: 'O comprimento do vetor de expoentes de SparsePolynomial deve ser igual a variableCount.',
+    sparseExponentsNonNegativeBigInt: 'Os expoentes de SparsePolynomial devem ser bigints não negativos.',
+    sparseVariableIndexOutOfRing: 'O índice de variável de SparsePolynomial está fora do anel polinomial.',
+    sparseAdditionRingMismatch: 'A adição de SparsePolynomial requer o mesmo anel polinomial.',
+    sparseCoefficientExponentNonNegative: 'O expoente do coeficiente de SparsePolynomial deve ser não negativo.',
+    sparseZeroMonomialDivision: 'SparsePolynomial não pode ser dividido por um monômio zero.',
+    sparseZeroScalarDivision: 'SparsePolynomial não pode ser dividido por zero.',
+    sparseScalarDivisionExact: 'A divisão escalar de SparsePolynomial deve ser exata para cada coeficiente.',
+    sparseDivisionRingMismatch: 'A divisão de SparsePolynomial requer o mesmo anel polinomial.',
+    sparseZeroPolynomialDivision: 'SparsePolynomial não pode ser dividido pelo polinômio zero.',
+    sparseMonomialOrderUnsupported: 'A ordem monomial de SparsePolynomial não é suportada.',
+    sparseMultiplicationRingMismatch: 'A multiplicação de SparsePolynomial requer o mesmo anel polinomial.',
+    sparseExponentNonNegative: 'O expoente de SparsePolynomial deve ser não negativo.',
+    sparseSubtractionRingMismatch: 'A subtração de SparsePolynomial requer o mesmo anel polinomial.',
+    invalidDecimal: 'Decimal inválido: "{{value}}"',
+    invalidInterval: 'Intervalo inválido: ({{start}}, {{end}})',
+    invalidAssumption: 'Suposição inválida: "{{input}}"',
+    assumptionIdentifierExpected: 'Identificador esperado',
+    assumptionOperatorMissing: 'Operador ausente',
+    assumptionValueMissing: 'Valor ausente',
+    assumptionOperatorUnsupported: 'Operador não suportado "{{operator}}"',
+    matrixStringKeyUnsupported: 'Matrix não suporta acesso por chave textual',
+    matrixTraceUnavailable: 'Não foi possível calcular o traço da matriz',
+    defintMaxEvals: 'defint: maxEvals excedido ({{max}}).',
+    defintNonFiniteValue: 'defint: f(x) não finita em x={{x}}',
+    defintEndpointSingularity: 'defint: não foi possível regularizar a singularidade do extremo perto de x={{x}}',
+    defintSingularity: 'defint: singularidade ou valor não finito encontrado perto de [{{a}}, {{b}}]',
+    defintInfiniteBounds: 'defint: limites infinitos exigem allowInfinite: true',
+    defintUnsupportedInfiniteBounds: 'defint: configuração de limites infinitos não suportada',
+    symbolicAccessNamedTargetRequired: 'O acesso indexado simbólico requer um alvo Vector ou Matrix nomeado.',
+    symbolicVectorIndexCount: 'O acesso simbólico a Vector requer exatamente um índice.',
+    symbolicMatrixRowNonScalar: 'O acesso simbólico a uma linha de Matrix não é escalar e não pode ser adiado como Expression.',
+    symbolicMatrixCellIndexCount: 'O acesso simbólico a uma célula de Matrix requer exatamente dois índices.',
+    symbolicAccessMaxIndices: 'O acesso indexado simbólico suporta no máximo dois índices não resolvidos.',
+    symbolicAccessIndexScalar: 'Os índices do acesso simbólico devem ser avaliados como expressões escalares.',
+    symbolicAccessTargetType: 'O alvo do acesso indexado simbólico deve ser resolvido como Vector ou Matrix.',
+    expectedOperatorOrFunction: 'Era esperado um operador ou nome de função, mas "{{value}}" foi encontrado!',
+    missingOpeningBracket: 'Falta o colchete de abertura para "{{bracket}}":{{position}}',
+    missingClosingBracket: 'Falta o colchete de fechamento para "{{bracket}}":{{position}}',
+    prefixOperatorExpected: 'Era esperado um operador prefixo, mas {{operator}} foi encontrado.',
+    groebnerBasisSizeBudgetExceeded: 'Orçamento de Groebner excedido: tamanho da base > {{max}}',
+    groebnerPairsBudgetExceeded: 'Orçamento de Groebner excedido: pairsPopped > {{max}}',
+    unsupportedParserEntity: 'Entidade do parser não suportada',
+    factorialNegativeUndefined: 'O fatorial não é definido para inteiros negativos.',
+    erfConvergenceFailed: 'erf não converge. Saindo!',
+    defintInfiniteBoundsDecimal: 'defint: limites infinitos exigem allowInfinite:true',
+    seqStartsAtInteger: "startsAt deve ser um inteiro",
+    seqPolynomialOrMaxPower: "A sequência não é um polinômio ou excede maxPower",
+    seqInsufficientData: "Pontos de dados insuficientes para o grau detectado",
+    arithPowNegativeExponent: "pow: expoente negativo",
+    arithPowNNonnegativeInteger: "powN: o expoente deve ser um inteiro não negativo",
+    arithBigIntSqrtNegative: "bigIntSqrt: entrada negativa",
+    arithNthRootPositiveInteger: "intNthRootExact: n deve ser um inteiro positivo",
+    arithDivisorsPositive: "getDivisors: n deve ser positivo",
+    arithModNormNonzeroModulus: "modNorm: o módulo deve ser diferente de zero",
+    arithModSymmetricNonzeroModulus: "modSymmetric: o módulo deve ser diferente de zero",
+    arithModInvZeroNoninvertible: "modInv: não invertível (0)",
+    arithModInvNoninvertible: "modInv: não invertível",
+    integerSqrtNonnegative: "A raiz quadrada inteira requer um valor não negativo.",
+    modularExponentiationPositiveModulus: "A exponenciação modular requer um módulo positivo.",
+    modularExponentiationNonnegativeExponent: "A exponenciação modular requer um expoente não negativo.",
+    maxBigIntRequiresArgument: "maxBigInt() requer pelo menos um argumento",
+    minBigIntEmpty: "O mínimo de uma lista vazia não é definido para BigInt.",
+    binomBigIntNonnegativeN: "binomBigInt: n deve ser não negativo",
+    invalidDecimalValue: "Valor decimal inválido: {{value}}",
+    subtractionNotDefined: "A subtração não está definida para {{leftType}}-{{rightType}} | {{left}}-{{right}}",
+    sparseAdapterVariablesUnique: "As variáveis do adaptador de polinômios esparsos devem ser únicas.",
+    sparseAdapterVariablesIncludeEvery: "As variáveis do adaptador de polinômios esparsos devem incluir todas as variáveis do polinômio.",
+    sparseExpressionConversionNameCount: "A conversão de expressão para polinômio esparso requer um nome por variável do anel.",
+    converterMissingArgumentScope: "Falta o escopo de argumentos para a função {{function}}",
+    converterMissingPrefixOperand: "Falta o operando para o operador prefixo {{operator}}",
+    converterMissingOperandMetadata: "Falta o operando ou os metadados para o operador {{operator}}",
+    converterMissingLeftOperand: "Falta o operando esquerdo para o operador {{operator}}",
+    converterTexConversionFailed: "Não foi possível converter a expressão de origem para TeX",
+    unknownOperator: "Operador desconhecido {{operator}}",
+    polynomialMaximumIterations: "Número máximo de iterações atingido",
+    polyRequires: "{{operation}} requer {{requirement}}.",
+    polyVariablesUnique: "As variáveis de {{operation}} devem ser únicas.",
+    polyVariablesRingOrder: "As variáveis de {{operation}} devem seguir a ordem do anel polinomial.",
+    polyVariablesIncludeActive: "As variáveis de {{operation}} devem incluir todas as variáveis ativas.",
+    polyInputsSelectedOnly: "As entradas de {{operation}} podem usar apenas as variáveis selecionadas.",
+    polyCannotFactorZeroPolynomial: "{{operation}} não pode fatorar o polinômio zero.",
+    polyCannotFactorZero: "{{operation}} não pode fatorar zero.",
+    polyModulusGreaterThanOne: "O módulo de ModularSparsePolynomial deve ser maior que um.",
+    polyVariableCountMatch: "variableCount de ModularSparsePolynomial deve corresponder ao polinômio esparso fornecido.",
+    polyInterpolationCannotDepend: "As amostras de interpolação de ModularSparsePolynomial não podem depender da variável interpolada.",
+    polyInterpolationInvertibleDifferences: "Os pontos de interpolação de ModularSparsePolynomial devem ter diferenças invertíveis aos pares.",
+    polyCoefficientExponentNonnegative: "O expoente do coeficiente de ModularSparsePolynomial deve ser não negativo.",
+    polyCannotDivideZero: "ModularSparsePolynomial não pode dividir pelo polinômio zero.",
+    polyDivisorLeadingCoefficientInvertible: "O coeficiente líder do divisor de ModularSparsePolynomial não é invertível.",
+    polyLeadingCoefficientInvertible: "O coeficiente líder de ModularSparsePolynomial não é invertível.",
+    polyExponentNonnegative: "O expoente de ModularSparsePolynomial deve ser não negativo.",
+    polyDegreeMatrixLimit: "O grau da fatoração modular excede a dimensão de matriz suportada.",
+    polyExtendedGcdTwoZeroUndefined: "O MDC estendido modular não é definido para dois polinômios zero.",
+    polyHenselPrimeExceedsTailDegree: "O primo do levantamento de Hensel multivariado deve exceder o grau de cada variável de cauda.",
+    polyHenselTargetNotSmaller: "O módulo alvo do levantamento de Hensel não pode ser menor que o primo base.",
+    polyHenselTargetRepeatedSquaring: "O módulo alvo do levantamento de Hensel deve ser obtido por quadraturas repetidas do primo base.",
+    polyHenselFactorsReconstructModuloBase: "Os fatores do levantamento de Hensel não reconstroem o polinômio inteiro módulo o primo base.",
+    polyZassenhausFactorsReconstructModuloLift: "Os fatores da recombinação de Zassenhaus não reconstroem a entrada módulo o módulo de levantamento.",
+    polyWangCannotSpecializeZero: "A busca de avaliação de Wang não pode especializar zero.",
+    polyModularContentExactDivision: "O conteúdo do polinômio modular deve dividir o polinômio exatamente.",
+    factorizationNoFactors: "A fatoração não constante não retornou fatores.",
+    polyCrtModuliInvertible: "Os módulos CRT do polinômio devem ser invertíveis.",
+    polyIntegerFactorPrimeZero: "A fatoração inteira não pode escolher um primo para zero.",
+    polySquareFreeNonExactDivision: "A fatoração livre de quadrados encontrou uma divisão polinomial não exata.",
+    polyZassenhausLostRemaining: "A recombinação de Zassenhaus perdeu o polinômio restante.",
+    polyZassenhausReconstructionFailed: "Os fatores da recombinação de Zassenhaus não reconstroem o polinômio inteiro.",
+    polyIntegerFactorLostLeading: "A fatoração inteira perdeu o termo líder.",
+    parserMalformedSymbolicAccessor: "Acessor simbólico interno malformado.",
+    parserMalformedSymbolicAccessorIndex: "Índice de acessor simbólico interno malformado.",
+    unknownOperatorAction: "Ação de operador desconhecida {{action}}",
+    parserBracketTokenMissingCharacter: "O token de colchete está sem seu caractere.",
+    polyWangLeadingEvaluationInteger: "A avaliação do coeficiente líder de Wang não produziu um inteiro.",
+    polyWangSpecializedLeadingInteger: "O fator especializado de Wang não tinha coeficiente líder inteiro.",
+    polyMultivariateContentDivisionFailed: "A fatoração multivariada não pôde dividir um bloco livre de quadrados por seu conteúdo na variável principal.",
+    polyMultivariateContentVariableMissing: "O conteúdo multivariado da variável principal não reteve uma variável de coeficiente ativa.",
+    polyMultivariateReconstructionFailed: "A fatoração multivariada completa não reconstrói o polinômio de entrada.",
+    polyBerlekampNoninvertiblePivot: "A eliminação de Berlekamp encontrou um pivô não invertível.",
+    polyHenselZeroFactorGroup: "O levantamento de Hensel não pode levantar um grupo de fatores zero.",
+    polyHenselCannotLiftZero: "O levantamento de Hensel não pode levantar o polinômio zero.",
+    polyHenselModulusExceeded: "O levantamento de Hensel excedeu o módulo de potência prima solicitado.",
+    polyHenselLeadingLost: "O levantamento de Hensel perdeu o coeficiente líder alvo.",
+    polyHenselReconstructionFailed: "Os fatores levantados por Hensel não reconstroem o polinômio alvo.",
+    polyBerlekampNonExactSplit: "A separação de Berlekamp produziu uma divisão de fatores não exata.",
+    polyBerlekampIncompleteSplit: "A fatoração de Berlekamp não separou completamente o polinômio.",
+    polyBerlekampReconstructionFailed: "Os fatores de Berlekamp não reconstroem o polinômio de entrada.",
+    expressionKeyValueUnsupported: "A função 'keyValue' não está implementada para o tipo {{type}}.",
+    solveLinearNonlinearDegree: "Termo não linear detectado na equação {{equation}}: termo de grau {{degree}} encontrado. solveLinearSystem trata apenas sistemas lineares.",
+    solveLinearNonPolynomialVariable: "Termo não linear detectado na equação {{equation}}: a variável \"{{variable}}\" aparece em uma posição não polinomial. solveLinearSystem trata apenas sistemas lineares.",
+    polyReqPrimeModulus: "um módulo primo",
+    polyReqUnivariatePolynomial: "um polinômio univariado",
+    polyReqSquareFreeInput: "uma entrada livre de quadrados",
+    polyReqSamePolynomialRing: "o mesmo anel polinomial",
+    polyReqAtLeastOneVariable: "pelo menos uma variável",
+    polyReqAtLeastTwoSelectedVariables: "pelo menos duas variáveis selecionadas",
+    polyReqOneEvaluationPerTailVariable: "um valor de avaliação por variável de cauda",
+    polyReqMatchingFactorLeadingLists: "listas correspondentes de fatores e coeficientes líderes",
+    polyReqPairwiseCoprimeModularFactors: "fatores modulares coprimos aos pares",
+    polyReqPrimeBaseModulus: "um módulo base primo",
+    polyReqAtLeastOneModularFactor: "pelo menos um fator modular",
+    polyReqUnivariateIntegerPolynomial: "um polinômio inteiro univariado",
+    polyReqFactorsSameRingAndPrime: "fatores do mesmo anel de polinômios inteiros e primo base",
+    polyReqUnivariateFactors: "fatores univariados",
+    polyReqMonicModularFactors: "fatores modulares mônicos",
+    polyReqPrimitiveIntegerPolynomial: "um polinômio inteiro primitivo",
+    polyReqPositiveLeadingCoefficient: "um coeficiente líder positivo",
+    polyReqLiftedModularFactors: "fatores modulares levantados",
+    polyReqLiftedFactorsSameRing: "fatores levantados de um mesmo anel polinomial",
+    polyReqUnivariateLiftedFactors: "fatores levantados univariados",
+    polyReqMonicLiftedFactors: "fatores levantados mônicos",
+    polyReqLargerHenselModulus: "um módulo de levantamento de Hensel maior",
+    polyReqPrimitivePolynomial: "um polinômio primitivo",
+    polyReqPositiveLexLeadingSign: "um sinal líder lexicográfico positivo",
+    polyReqSquareFreeMainVariable: "uma entrada livre de quadrados na variável principal",
+    polyReqExactlyTwoSelectedVariables: "exatamente duas variáveis selecionadas",
+    polyReqExactlyTwoVariables: "exatamente duas variáveis",
+    polyReqOneValuePerNonMainVariable: "um valor para cada variável selecionada não principal",
+    polyReqOneValuePerTailVariable: "um valor para cada variável de cauda",
+    polyReqPositiveDegreeMainVariable: "grau positivo na variável principal",
+    polyReqAllOtherVariablesDormant: "que todas as outras variáveis estejam inativas",
+    polyReqPositiveModuli: "módulos positivos",
+    polyReqCoprimeModuli: "módulos coprimos",
+    polyReqAtLeastOneSample: "pelo menos uma amostra",
+    polyReqInvertibleLeadingCoefficient: "um coeficiente líder invertível",
+    polyReqIntegerLeadingCoefficientInvertible: "que o coeficiente líder inteiro seja invertível módulo o primo base",
+    infinityMinusInfinityUndefined: 'Infinito menos infinito não está definido!',
+    // Assumptions
+    inconsistentAssumptions: 'As suposições são inconsistentes (interseção vazia)!',
+    // Parser
+    unsupportedType: 'O tipo fornecido ({{type}}) não é compatível com esta função!',
+    unsupportedOperation: 'Esta operação não é suportada atualmente!',
+    buildFunctionUnsupportedFunction: 'buildFunction não pode compilar a função "{{function}}" para aritmética numérica JavaScript!',
+    buildFunctionComplexUnsupported: 'buildFunction não pode compilar expressões que contêm a unidade imaginária para aritmética numérica JavaScript!',
+    nonMatchingDimensions: 'Esta operação não pode ser concluída porque as dimensões não correspondem!',
+    malformedExpression: 'Não foi possível analisar a expressão malformada!',
+    unsupportedCharacter: 'Caractere não suportado "{{character}}" na posição {{position}}.',
+    missingCommentDelimiter: 'Falta o delimitador de fechamento de comentário "{{delimiter}}".',
+    divisionByZero: 'A divisão por zero não está definida!',
+    zeroToZeroPower: '0^0 não está definido!',
+    infinityToPowerZero: 'Infinito^0 não está definido!',
+    infinityTimesZero: '0*Infinito não está definido!',
+    infinityToInfinity: 'Infinito^Infinito não está definido!',
+    valueToInfinityUndefined: '{{value}}^Infinito não está definido!',
+    atan2Undefined: 'atan2 não está definida para 0, 0!',
+    tanUndefined: 'tan não está definida para múltiplos de pi/2!',
+    loopIterationLimitExceeded: 'O laço excedeu o máximo de {{max}} iterações.',
+    breakOutsideLoop: 'break só pode ser usado dentro de um laço.',
+    continueOutsideLoop: 'continue só pode ser usado dentro de um laço.',
+    letRequiresBindingsAndBody: 'let exige um ou mais pares nome/valor seguidos de uma expressão de corpo.',
+    secUndefined: 'sec não está definida para múltiplos ímpares de pi/2!',
+    cscUndefined: 'csc não está definida para múltiplos de pi!',
+    cotUndefined: 'cot não está definida para múltiplos de pi!',
+    cothUndefined: 'coth não está definida para 0!',
+    cschUndefined: 'csch não está definida para 0!',
+    atanhUndefined: 'atanh não está definida para 0!',
+    cannotCreateArrayFromNaN: 'Não é possível criar um array a partir de NaN!',
+    expressionExpected: 'Era esperada uma expressão! Recebido: {{type}}!',
+    // TeX Converter
+    unrecognizedMode: '"{{mode}}" não é um modo válido!',
+    // Polynomials
+    notAPolynomial: 'A expressão não é um polinômio válido!',
+    multidegreeMismatch: 'O número de variáveis deve corresponder ao multigrau do polinômio!',
+    unknownVariable: 'Variável desconhecida! "{{variable}}"',
+    // Matrix
+    cannotCreateMatrix: 'Não foi possível criar a matriz. As dimensões das linhas não correspondem!',
+    cannotMultiplyMatrix: 'Não é possível multiplicar a matriz!',
+    squareMatrixRequired: 'A matriz deve ser quadrada!',
+    rowsMustMatch: 'As linhas das matrizes devem corresponder!',
+    columnsMustMatch: 'As colunas das matrizes devem corresponder!',
+    singularMatrix: 'A matriz fornecida é singular!',
+    matrixExpected: 'Era esperada uma matriz! Recebido: {{type}}.',
+    // Vector
+    mismatchedDimensions: 'As dimensões devem corresponder para a função "{{function}}"!',
+    incorrectCrossDimension: 'O produto vetorial só é definido para vetores de dimensão 3!',
+    vectorExpected: 'Era esperado um vetor! Recebido: {{type}}.',
+    // Polynomial
+    univariatePolynomialOnly: 'Esta função é suportada apenas para polinômios univariados!',
+    // Solve
+    convergenceFailed: 'Falha na convergência! Foram tentadas {{iters}} iterações.',
+    endPointIsRoot: 'O ponto extremo é uma raiz.',
+    zeroDerivative: 'A derivada é zero em x = {{x}}. Não é possível continuar.',
+    tooManyUnknowns: 'Muitas incógnitas!',
+    solveSystemInfiniteSolutions: 'Este sistema não possui um conjunto finito de soluções isoladas!',
+    solveSystemPolynomialOnly: 'solveSystem atualmente suporta apenas sistemas lineares ou polinomiais!',
+    solveSystemNonRationalUnsupported: 'Este sistema polinomial não linear exige resolução não racional ou não simbólica, que ainda não é suportada!',
+    // Set Function
+    setJSFunctionExpectsFunction: 'O parâmetro da função, ao definir uma função JS, deve ser do tipo function!',
+    functionRequiresMinAndMaxArgs: 'É necessário fornecer os números mínimo e máximo de argumentos ao definir a função!',
+};
+(0, errors_1.registerLanguage)('por', catalog);
+if (typeof NERDAMER_BUILD_LANGUAGE !== 'undefined' && NERDAMER_BUILD_LANGUAGE === 'por') {
+    Settings_1.Settings.LANGUAGE = 'por';
+}
+exports.default = catalog;

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

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