nerdamer 2.0.0-rc.1 → 2.0.0

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;

package/output/api/languages/spa.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 aún no se ha implementado.',
+    noInverse: 'Incapaz de calcular inversa!',
+    undefinedValue: '¡El valor solicitado no está definido!',
+    nullValue: 'Se esperaba un valor, pero se recibió null.',
+    univariateInputOnly: '¡La entrada para esta función debe ser univariada!',
+    differentSignsAtEndPointsRequired: '¡La función debe tener signos opuestos en los puntos extremos a y b!',
+    integerRequired: '¡Esta función requiere que el coeficiente sea un número entero!',
+    plainVariableExpected: '¡Se esperaba una variable simple! Se recibió {{input}}.',
+    missingReference: '¡La referencia "{{ref}}" no existe en este patrón!',
+    undefinedDivision: '¡División no definida expresión de este tipo! {{type}}',
+    restrictedVariableName: '¡No se puede asignar el valor solicitado al nombre reservado "{{name}}"!',
+    noVariableInExpression: '¡No se encontró ninguna variable en la expresión!',
+    quadraticExpressionExpected: '¡La expresión debe ser cuadrática!',
+    wrongInput: '¡Entrada incorrecta! Se esperaba {{expected}}, pero se recibió {{received}}.',
+    unsupportedFunction: 'Función no compatible "{{function}}".',
+    functionMinArgs: '{{function}} requiere al menos {{min}} argumentos, pero se recibieron {{actual}}.',
+    functionMaxArgs: '{{function}} permite como máximo {{max}} argumentos, pero se recibieron {{actual}}.',
+    invalidFunctionDeclaration: 'Declaración de función no válida "{{declaration}}".',
+    indexOutOfBounds: 'El índice {{index}} está fuera de los límites de {{type}} con longitud {{length}}.',
+    matrixRowIndexOutOfBounds: 'El índice de fila {{index}} está fuera de los límites de Matrix con {{length}} filas.',
+    matrixColumnIndexOutOfBounds: 'El índice de columna {{index}} está fuera de los límites de Matrix con {{length}} columnas.',
+    dictionaryKeyNotFound: 'La clave "{{key}}" no se encontró en Dictionary. Claves disponibles: {{keys}}.',
+    rangeValuesFinite: 'Los valores del rango deben ser finitos.',
+    rangeStepNonzero: 'El paso del rango no puede ser cero.',
+    rangeStepNoAdvance: 'El paso del rango no avanza con la precisión actual.',
+    sparseVariableCountInvalid: 'SparsePolynomial variableCount debe ser un entero seguro no negativo.',
+    sparseExponentVectorLengthMismatch: 'La longitud del vector de exponentes de SparsePolynomial debe ser igual a variableCount.',
+    sparseExponentsNonNegativeBigInt: 'Los exponentes de SparsePolynomial deben ser bigint no negativos.',
+    sparseVariableIndexOutOfRing: 'El índice de variable de SparsePolynomial está fuera del anillo polinómico.',
+    sparseAdditionRingMismatch: 'La suma de SparsePolynomial requiere el mismo anillo polinómico.',
+    sparseCoefficientExponentNonNegative: 'El exponente del coeficiente de SparsePolynomial debe ser no negativo.',
+    sparseZeroMonomialDivision: 'SparsePolynomial no puede dividirse por un monomio cero.',
+    sparseZeroScalarDivision: 'SparsePolynomial no puede dividirse por cero.',
+    sparseScalarDivisionExact: 'La división escalar de SparsePolynomial debe ser exacta para cada coeficiente.',
+    sparseDivisionRingMismatch: 'La división de SparsePolynomial requiere el mismo anillo polinómico.',
+    sparseZeroPolynomialDivision: 'SparsePolynomial no puede dividirse por el polinomio cero.',
+    sparseMonomialOrderUnsupported: 'El orden monomial de SparsePolynomial no es compatible.',
+    sparseMultiplicationRingMismatch: 'La multiplicación de SparsePolynomial requiere el mismo anillo polinómico.',
+    sparseExponentNonNegative: 'El exponente de SparsePolynomial debe ser no negativo.',
+    sparseSubtractionRingMismatch: 'La resta de SparsePolynomial requiere el mismo anillo polinómico.',
+    invalidDecimal: 'Decimal no válido: "{{value}}"',
+    invalidInterval: 'Intervalo no válido: ({{start}}, {{end}})',
+    invalidAssumption: 'Suposición no válida: "{{input}}"',
+    assumptionIdentifierExpected: 'Se esperaba un identificador',
+    assumptionOperatorMissing: 'Falta el operador',
+    assumptionValueMissing: 'Falta el valor',
+    assumptionOperatorUnsupported: 'Operador no compatible "{{operator}}"',
+    matrixStringKeyUnsupported: 'Matrix no admite acceso mediante clave de texto',
+    matrixTraceUnavailable: 'No se puede calcular la traza de la matriz',
+    defintMaxEvals: 'defint: se superó maxEvals ({{max}}).',
+    defintNonFiniteValue: 'defint: f(x) no es finita en x={{x}}',
+    defintEndpointSingularity: 'defint: no se pudo regularizar la singularidad del extremo cerca de x={{x}}',
+    defintSingularity: 'defint: se encontró una singularidad o valor no finito cerca de [{{a}}, {{b}}]',
+    defintInfiniteBounds: 'defint: los límites infinitos requieren allowInfinite: true',
+    defintUnsupportedInfiniteBounds: 'defint: configuración de límites infinitos no compatible',
+    symbolicAccessNamedTargetRequired: 'El acceso indexado simbólico requiere un objetivo Vector o Matrix con nombre.',
+    symbolicVectorIndexCount: 'El acceso simbólico a Vector requiere exactamente un índice.',
+    symbolicMatrixRowNonScalar: 'El acceso simbólico a una fila de Matrix no es escalar y no puede diferirse como Expression.',
+    symbolicMatrixCellIndexCount: 'El acceso simbólico a una celda de Matrix requiere exactamente dos índices.',
+    symbolicAccessMaxIndices: 'El acceso indexado simbólico admite como máximo dos índices sin resolver.',
+    symbolicAccessIndexScalar: 'Los índices del acceso simbólico deben evaluarse como expresiones escalares.',
+    symbolicAccessTargetType: 'El objetivo del acceso indexado simbólico debe resolverse como Vector o Matrix.',
+    expectedOperatorOrFunction: 'Se esperaba un operador o nombre de función, pero se encontró "{{value}}"!',
+    missingOpeningBracket: 'Falta el corchete de apertura para "{{bracket}}":{{position}}',
+    missingClosingBracket: 'Falta el corchete de cierre para "{{bracket}}":{{position}}',
+    prefixOperatorExpected: 'Se esperaba un operador prefijo, pero se encontró {{operator}}.',
+    groebnerBasisSizeBudgetExceeded: 'Se excedió el presupuesto de Groebner: tamaño de la base > {{max}}',
+    groebnerPairsBudgetExceeded: 'Se excedió el presupuesto de Groebner: pairsPopped > {{max}}',
+    unsupportedParserEntity: 'Entidad del parser no compatible',
+    factorialNegativeUndefined: 'El factorial no está definido para enteros negativos.',
+    erfConvergenceFailed: 'erf no converge. Saliendo!',
+    defintInfiniteBoundsDecimal: 'defint: los límites infinitos requieren allowInfinite:true',
+    seqStartsAtInteger: "startsAt debe ser un entero",
+    seqPolynomialOrMaxPower: "La secuencia no es un polinomio o supera maxPower",
+    seqInsufficientData: "No hay suficientes puntos de datos para el grado detectado",
+    arithPowNegativeExponent: "pow: exponente negativo",
+    arithPowNNonnegativeInteger: "powN: el exponente debe ser un entero no negativo",
+    arithBigIntSqrtNegative: "bigIntSqrt: entrada negativa",
+    arithNthRootPositiveInteger: "intNthRootExact: n debe ser un entero positivo",
+    arithDivisorsPositive: "getDivisors: n debe ser positivo",
+    arithModNormNonzeroModulus: "modNorm: el módulo debe ser distinto de cero",
+    arithModSymmetricNonzeroModulus: "modSymmetric: el módulo debe ser distinto de cero",
+    arithModInvZeroNoninvertible: "modInv: no invertible (0)",
+    arithModInvNoninvertible: "modInv: no invertible",
+    integerSqrtNonnegative: "La raíz cuadrada entera requiere un valor no negativo.",
+    modularExponentiationPositiveModulus: "La exponenciación modular requiere un módulo positivo.",
+    modularExponentiationNonnegativeExponent: "La exponenciación modular requiere un exponente no negativo.",
+    maxBigIntRequiresArgument: "maxBigInt() requiere al menos un argumento",
+    minBigIntEmpty: "El mínimo de una lista vacía no está definido para BigInt.",
+    binomBigIntNonnegativeN: "binomBigInt: n debe ser no negativo",
+    invalidDecimalValue: "Valor decimal no válido: {{value}}",
+    subtractionNotDefined: "La resta no está definida para {{leftType}}-{{rightType}} | {{left}}-{{right}}",
+    sparseAdapterVariablesUnique: "Las variables del adaptador de polinomios dispersos deben ser únicas.",
+    sparseAdapterVariablesIncludeEvery: "Las variables del adaptador de polinomios dispersos deben incluir todas las variables del polinomio.",
+    sparseExpressionConversionNameCount: "La conversión de expresiones a polinomios dispersos requiere un nombre por variable del anillo.",
+    converterMissingArgumentScope: "Falta el ámbito de argumentos para la función {{function}}",
+    converterMissingPrefixOperand: "Falta el operando para el operador prefijo {{operator}}",
+    converterMissingOperandMetadata: "Falta el operando o los metadatos para el operador {{operator}}",
+    converterMissingLeftOperand: "Falta el operando izquierdo para el operador {{operator}}",
+    converterTexConversionFailed: "No se puede convertir la expresión de origen a TeX",
+    unknownOperator: "Operador desconocido {{operator}}",
+    polynomialMaximumIterations: "Se alcanzó el número máximo de iteraciones",
+    polyRequires: "{{operation}} requiere {{requirement}}.",
+    polyVariablesUnique: "Las variables de {{operation}} deben ser únicas.",
+    polyVariablesRingOrder: "Las variables de {{operation}} deben seguir el orden del anillo de polinomios.",
+    polyVariablesIncludeActive: "Las variables de {{operation}} deben incluir todas las variables activas.",
+    polyInputsSelectedOnly: "Las entradas de {{operation}} solo pueden usar las variables seleccionadas.",
+    polyCannotFactorZeroPolynomial: "{{operation}} no puede factorizar el polinomio cero.",
+    polyCannotFactorZero: "{{operation}} no puede factorizar cero.",
+    polyModulusGreaterThanOne: "El módulo de ModularSparsePolynomial debe ser mayor que uno.",
+    polyVariableCountMatch: "variableCount de ModularSparsePolynomial debe coincidir con el polinomio disperso suministrado.",
+    polyInterpolationCannotDepend: "Las muestras de interpolación de ModularSparsePolynomial no pueden depender de la variable interpolada.",
+    polyInterpolationInvertibleDifferences: "Los puntos de interpolación de ModularSparsePolynomial deben tener diferencias invertibles por pares.",
+    polyCoefficientExponentNonnegative: "El exponente del coeficiente de ModularSparsePolynomial debe ser no negativo.",
+    polyCannotDivideZero: "ModularSparsePolynomial no puede dividir por el polinomio cero.",
+    polyDivisorLeadingCoefficientInvertible: "El coeficiente principal del divisor de ModularSparsePolynomial no es invertible.",
+    polyLeadingCoefficientInvertible: "El coeficiente principal de ModularSparsePolynomial no es invertible.",
+    polyExponentNonnegative: "El exponente de ModularSparsePolynomial debe ser no negativo.",
+    polyDegreeMatrixLimit: "El grado de la factorización modular supera la dimensión de matriz admitida.",
+    polyExtendedGcdTwoZeroUndefined: "El MCD extendido modular no está definido para dos polinomios cero.",
+    polyHenselPrimeExceedsTailDegree: "El primo del levantamiento de Hensel multivariante debe superar el grado de cada variable de cola.",
+    polyHenselTargetNotSmaller: "El módulo objetivo del levantamiento de Hensel no puede ser menor que el primo base.",
+    polyHenselTargetRepeatedSquaring: "El módulo objetivo del levantamiento de Hensel debe obtenerse mediante cuadrados sucesivos del primo base.",
+    polyHenselFactorsReconstructModuloBase: "Los factores del levantamiento de Hensel no reconstruyen el polinomio entero módulo el primo base.",
+    polyZassenhausFactorsReconstructModuloLift: "Los factores de recombinación de Zassenhaus no reconstruyen la entrada módulo el módulo de levantamiento.",
+    polyWangCannotSpecializeZero: "La búsqueda de evaluación de Wang no puede especializar cero.",
+    polyModularContentExactDivision: "El contenido del polinomio modular debe dividir exactamente al polinomio.",
+    factorizationNoFactors: "La factorización no constante no devolvió factores.",
+    polyCrtModuliInvertible: "Los módulos CRT del polinomio deben ser invertibles.",
+    polyIntegerFactorPrimeZero: "La factorización entera no puede elegir un primo para cero.",
+    polySquareFreeNonExactDivision: "La factorización libre de cuadrados encontró una división polinómica no exacta.",
+    polyZassenhausLostRemaining: "La recombinación de Zassenhaus perdió el polinomio restante.",
+    polyZassenhausReconstructionFailed: "Los factores de recombinación de Zassenhaus no reconstruyen el polinomio entero.",
+    polyIntegerFactorLostLeading: "La factorización entera perdió el término principal.",
+    parserMalformedSymbolicAccessor: "Accesor simbólico interno mal formado.",
+    parserMalformedSymbolicAccessorIndex: "Índice de accesor simbólico interno mal formado.",
+    unknownOperatorAction: "Acción de operador desconocida {{action}}",
+    parserBracketTokenMissingCharacter: "Al token de corchete le falta su carácter.",
+    polyWangLeadingEvaluationInteger: "La evaluación del coeficiente principal de Wang no produjo un entero.",
+    polyWangSpecializedLeadingInteger: "El factor especializado de Wang no tenía un coeficiente principal entero.",
+    polyMultivariateContentDivisionFailed: "La factorización multivariante no pudo dividir un bloque libre de cuadrados por su contenido en la variable principal.",
+    polyMultivariateContentVariableMissing: "El contenido de la variable principal multivariante no conservó una variable de coeficiente activa.",
+    polyMultivariateReconstructionFailed: "La factorización multivariante completa no reconstruye el polinomio de entrada.",
+    polyBerlekampNoninvertiblePivot: "La eliminación de Berlekamp encontró un pivote no invertible.",
+    polyHenselZeroFactorGroup: "El levantamiento de Hensel no puede levantar un grupo de factores cero.",
+    polyHenselCannotLiftZero: "El levantamiento de Hensel no puede levantar el polinomio cero.",
+    polyHenselModulusExceeded: "El levantamiento de Hensel superó el módulo de potencia prima solicitado.",
+    polyHenselLeadingLost: "El levantamiento de Hensel perdió el coeficiente principal objetivo.",
+    polyHenselReconstructionFailed: "Los factores levantados por Hensel no reconstruyen el polinomio objetivo.",
+    polyBerlekampNonExactSplit: "La separación de Berlekamp produjo una división de factores no exacta.",
+    polyBerlekampIncompleteSplit: "La factorización de Berlekamp no separó completamente el polinomio.",
+    polyBerlekampReconstructionFailed: "Los factores de Berlekamp no reconstruyen el polinomio de entrada.",
+    expressionKeyValueUnsupported: "La función 'keyValue' no está implementada para el tipo {{type}}.",
+    solveLinearNonlinearDegree: "Se detectó un término no lineal en la ecuación {{equation}}: se encontró un término de grado {{degree}}. solveLinearSystem solo maneja sistemas lineales.",
+    solveLinearNonPolynomialVariable: "Se detectó un término no lineal en la ecuación {{equation}}: la variable \"{{variable}}\" aparece en una posición no polinómica. solveLinearSystem solo maneja sistemas lineales.",
+    polyReqPrimeModulus: "un módulo primo",
+    polyReqUnivariatePolynomial: "un polinomio univariante",
+    polyReqSquareFreeInput: "una entrada libre de cuadrados",
+    polyReqSamePolynomialRing: "el mismo anillo de polinomios",
+    polyReqAtLeastOneVariable: "al menos una variable",
+    polyReqAtLeastTwoSelectedVariables: "al menos dos variables seleccionadas",
+    polyReqOneEvaluationPerTailVariable: "un valor de evaluación por variable de cola",
+    polyReqMatchingFactorLeadingLists: "listas coincidentes de factores y coeficientes principales",
+    polyReqPairwiseCoprimeModularFactors: "factores modulares coprimos por pares",
+    polyReqPrimeBaseModulus: "un módulo base primo",
+    polyReqAtLeastOneModularFactor: "al menos un factor modular",
+    polyReqUnivariateIntegerPolynomial: "un polinomio entero univariante",
+    polyReqFactorsSameRingAndPrime: "factores del mismo anillo de polinomios enteros y primo base",
+    polyReqUnivariateFactors: "factores univariantes",
+    polyReqMonicModularFactors: "factores modulares mónicos",
+    polyReqPrimitiveIntegerPolynomial: "un polinomio entero primitivo",
+    polyReqPositiveLeadingCoefficient: "un coeficiente principal positivo",
+    polyReqLiftedModularFactors: "factores modulares levantados",
+    polyReqLiftedFactorsSameRing: "factores levantados de un mismo anillo de polinomios",
+    polyReqUnivariateLiftedFactors: "factores levantados univariantes",
+    polyReqMonicLiftedFactors: "factores levantados mónicos",
+    polyReqLargerHenselModulus: "un módulo de levantamiento de Hensel mayor",
+    polyReqPrimitivePolynomial: "un polinomio primitivo",
+    polyReqPositiveLexLeadingSign: "un signo principal lexicográfico positivo",
+    polyReqSquareFreeMainVariable: "una entrada libre de cuadrados en la variable principal",
+    polyReqExactlyTwoSelectedVariables: "exactamente dos variables seleccionadas",
+    polyReqExactlyTwoVariables: "exactamente dos variables",
+    polyReqOneValuePerNonMainVariable: "un valor por cada variable seleccionada no principal",
+    polyReqOneValuePerTailVariable: "un valor por cada variable de cola",
+    polyReqPositiveDegreeMainVariable: "grado positivo en la variable principal",
+    polyReqAllOtherVariablesDormant: "que todas las demás variables estén inactivas",
+    polyReqPositiveModuli: "módulos positivos",
+    polyReqCoprimeModuli: "módulos coprimos",
+    polyReqAtLeastOneSample: "al menos una muestra",
+    polyReqInvertibleLeadingCoefficient: "un coeficiente principal invertible",
+    polyReqIntegerLeadingCoefficientInvertible: "que el coeficiente principal entero sea invertible módulo el primo base",
+    infinityMinusInfinityUndefined: '¡Infinito menos infinito es indefinido!',
+    // Assumptions
+    inconsistentAssumptions: '¡Las suposiciones son inconsistentes (intersección vacía)!',
+    // Parser
+    unsupportedType: '¡El tipo ({{type}}) proporcionado no es compatible con esta función!',
+    unsupportedOperation: '¡Esta operación no está soportada actualmente!',
+    buildFunctionUnsupportedFunction: '¡buildFunction no puede compilar la función "{{function}}" a aritmética numérica de JavaScript!',
+    buildFunctionComplexUnsupported: '¡buildFunction no puede compilar expresiones que contienen la unidad imaginaria a aritmética numérica de JavaScript!',
+    nonMatchingDimensions: '¡Esta operación no se puede completar porque las dimensiones no coinciden!',
+    malformedExpression: '¡No se puede analizar la expresión malformada!',
+    unsupportedCharacter: 'Carácter no compatible "{{character}}" en la posición {{position}}.',
+    missingCommentDelimiter: 'Falta el delimitador de cierre de comentario "{{delimiter}}".',
+    divisionByZero: '¡La división por cero no está definida!',
+    zeroToZeroPower: '¡0^0 no está definido!',
+    infinityToPowerZero: '¡Infinito^0 no está definido!',
+    infinityTimesZero: '¡0*Infinito no está definido!',
+    infinityToInfinity: '¡Infinito^Infinito no está definido!',
+    valueToInfinityUndefined: '{{value}}^Infinito no está definido!',
+    atan2Undefined: '¡atan2 no está definida para 0, 0!',
+    tanUndefined: '¡tan no está definida para múltiplos de pi / 2!',
+    loopIterationLimitExceeded: 'El bucle superó el máximo de {{max}} iteraciones.',
+    breakOutsideLoop: 'break solo se puede usar dentro de un bucle.',
+    continueOutsideLoop: 'continue solo se puede usar dentro de un bucle.',
+    letRequiresBindingsAndBody: 'let requiere uno o más pares nombre/valor seguidos de una expresión de cuerpo.',
+    secUndefined: '¡sec no está definida para múltiplos impares de pi/2!',
+    cscUndefined: '¡csc no está definida para múltiplos de pi!',
+    cotUndefined: '¡cot no está definida para múltiplos de pi!',
+    cothUndefined: '¡coth no está definida para 0!',
+    cschUndefined: '¡csch no está definida para 0!',
+    atanhUndefined: '¡Atanh no está definida para 0!',
+    cannotCreateArrayFromNaN: '¡No se puede crear una matriz de NaN!',
+    expressionExpected: '¡Se esperaba Expression! ¡Se recibió {{type}}!',
+    // TeX Converter
+    unrecognizedMode: '¡{{mode}} no es un modo válido!',
+    // Polynomials
+    notAPolynomial: '¡La expresión no es un polinomio válido!',
+    multidegreeMismatch: '¡El número de variables debe coincidir con el multigrado del polinomio!',
+    unknownVariable: '¡Variable desconocida! "{{variable}}"',
+    // Matrix
+    cannotCreateMatrix: 'No se puede crear la matriz. ¡Las dimensiones de las filas no coinciden!',
+    cannotMultiplyMatrix: '¡No se puede multiplicar la matriz!',
+    squareMatrixRequired: '¡La matriz debe ser cuadrada!',
+    rowsMustMatch: '¡Las filas de las matrices deben coincidir!',
+    columnsMustMatch: '¡Las columnas de las matrices deben coincidir!',
+    singularMatrix: '¡La matriz proporcionada es singular!',
+    matrixExpected: '¡Matriz esperada! Se recibió {{type}}.',
+    // Vector
+    mismatchedDimensions: '¡Las dimensiones deben coincidir para la función "{{function}}"!',
+    incorrectCrossDimension: '¡El producto vectorial sólo está definido para vectores de dimensión 3!',
+    vectorExpected: '¡Vector esperado! Recibido. {{type}}.',
+    // Polynomial
+    univariatePolynomialOnly: '¡Esta función solo es compatible con polinomios univariados!',
+    // Solve
+    convergenceFailed: '¡No se logró la convergencia! Se intentaron {{iters}} iteraciones.',
+    endPointIsRoot: 'El punto final es la raíz.',
+    zeroDerivative: 'La derivada es cero en x = {{x}}. No se puede continuar.',
+    tooManyUnknowns: '¡Demasiadas incógnitas!',
+    solveSystemInfiniteSolutions: '¡Este sistema no tiene un conjunto finito de soluciones aisladas!',
+    solveSystemPolynomialOnly: '¡solveSystem actualmente solo admite sistemas lineales o polinómicos!',
+    solveSystemNonRationalUnsupported: '¡Este sistema polinómico no lineal requiere resolución no racional o no simbólica, lo cual aún no está soportado!',
+    // Set Function
+    setJSFunctionExpectsFunction: '¡El parámetro de la función, al configurar una función JS, debe ser de tipo función!',
+    functionRequiresMinAndMaxArgs: '¡Debes proporcionar los argumentos mínimo y máximo al configurar la función!',
+};
+(0, errors_1.registerLanguage)('spa', catalog);
+if (typeof NERDAMER_BUILD_LANGUAGE !== 'undefined' && NERDAMER_BUILD_LANGUAGE === 'spa') {
+    Settings_1.Settings.LANGUAGE = 'spa';
+}
+exports.default = catalog;

package/output/api/parser.d.ts

@@ -1,6 +1,13 @@
 import type { ParserConstants, ParserValuesObject } from '../core/classes/parser/types';
-import type { SettingsType } from '../core/Settings';
+import type { SettingsType as InternalSettingsType } from '../core/Settings';
 import type { ExpressionInput, ParserEntity } from '../core/types';
+/**
+ * Parser settings supported by the public parser facade.
+ *
+ * `DEFER_SIMPLIFICATION` remains an internal compatibility setting and is not part of
+ * the supported 2.0 parser API.
+ */
+export type SettingsType = Omit<InternalSettingsType, 'DEFER_SIMPLIFICATION'>;
 type BooleanSettingName = {
     [K in keyof SettingsType]: SettingsType[K] extends boolean ? K : never;
 }[keyof SettingsType];
@@ -25,6 +32,8 @@ export interface ParserAPI {
     get<K extends keyof SettingsType>(setting: K): SettingsType[K];
     /** Returns the symbol currently used for the imaginary unit. */
     getI(): string;
+    /** Returns whether Nerdamer currently reserves a variable or symbol name. */
+    isReserved(name: string): boolean;
     /** Returns the active Decimal precision. */
     getPrecision(): number;
     /**
@@ -82,4 +91,3 @@ export declare const Parser: ParserAPI;
 export type { JsFunction, Operation, OptionValue, OptionsObject, ParserConstants, ParserValuesObject, PostFixFunction, PreFixFunction, } from '../core/classes/parser/types';
 export type { BinaryArithmeticOperation, ComparisonOperation, Operator, OperatorAction, OperatorDefinition, } from '../core/common/common';
 export type { Language } from '../core/errors';
-export type { SettingsType } from '../core/Settings';

package/output/api/parser.js

@@ -7,6 +7,8 @@ exports.Parser = void 0;
  * @module parser
  */
 const Parser_1 = require("../core/classes/parser/Parser");
+const parserFunctions_1 = require("../core/parserFunctions");
+(0, parserFunctions_1.loadParserFunctions)();
 /**
  * Shared parser exposed through the supported high-level interface.
  *

package/output/api/solve.d.ts

@@ -6,5 +6,5 @@ export { PolynomialSolver } from '../solve/classes/PolynomialSolver';
 export { SolutionSet } from '../solve/classes/SolutionSet';
 export type { SolutionForm, SolutionsType } from '../solve/classes/SolutionSet';
 export { SymbolicSolver } from '../solve/classes/SymbolicSolver';
-export { solve } from '../solve/solve';
+export { roots, solve } from '../solve/solve';
 export { solveSystem } from '../solve/solveSystem';

package/output/api/solve.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.solveSystem = exports.solve = exports.SymbolicSolver = exports.SolutionSet = exports.PolynomialSolver = exports.MultivariateSolver = void 0;
+exports.solveSystem = exports.solve = exports.roots = exports.SymbolicSolver = exports.SolutionSet = exports.PolynomialSolver = exports.MultivariateSolver = void 0;
 /** Public symbolic and polynomial solver APIs. */
 var MultivariateSolver_1 = require("../solve/classes/MultivariateSolver");
 Object.defineProperty(exports, "MultivariateSolver", { enumerable: true, get: function () { return MultivariateSolver_1.MultivariateSolver; } });
@@ -11,6 +11,7 @@ Object.defineProperty(exports, "SolutionSet", { enumerable: true, get: function
 var SymbolicSolver_1 = require("../solve/classes/SymbolicSolver");
 Object.defineProperty(exports, "SymbolicSolver", { enumerable: true, get: function () { return SymbolicSolver_1.SymbolicSolver; } });
 var solve_1 = require("../solve/solve");
+Object.defineProperty(exports, "roots", { enumerable: true, get: function () { return solve_1.roots; } });
 Object.defineProperty(exports, "solve", { enumerable: true, get: function () { return solve_1.solve; } });
 var solveSystem_1 = require("../solve/solveSystem");
 Object.defineProperty(exports, "solveSystem", { enumerable: true, get: function () { return solveSystem_1.solveSystem; } });

package/output/api/structures.d.ts

@@ -1,7 +1,7 @@
 /** Public structured-value and finite-set APIs. */
 export { Collection } from '../core/classes/collection/Collection';
 export { Dictionary } from '../core/classes/dictionary/Dictionary';
-export { determinant, nullspace } from '../core/classes/matrix/functions';
+export { determinant, invert, nullspace } from '../core/classes/matrix/functions';
 export { Matrix } from '../core/classes/matrix/Matrix';
 export { imatrix } from '../core/classes/matrix/utils';
 export { ValuesSet } from '../core/classes/valuesSet/ValuesSet';