nerdamer 1.1.13 → 2.0.0-rc.2

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

@@ -0,0 +1,93 @@
+import type { ParserConstants, ParserValuesObject } from '../core/classes/parser/types';
+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];
+/**
+ * Supported high-level parser surface.
+ *
+ * Tokenization, RPN conversion, and parser-stack machinery remain internal
+ * implementation details even though Nerdamer itself uses them across modules.
+ */
+export interface ParserAPI {
+    /** Creates another parser facade backed by the shared parser configuration. */
+    create(): ParserAPI;
+    /**
+     * Parses and evaluates Nerdamer notation with optional substitutions.
+     * @param str - Nerdamer notation or expression-compatible input.
+     * @param values - Values substituted by name while parsing.
+     */
+    evaluate(str: string, values?: ParserValuesObject): ParserEntity;
+    /**
+     * Returns one shared parser setting with the value type associated with that setting.
+     */
+    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;
+    /**
+     * Parses Nerdamer notation with optional substitutions.
+     * @param str - Nerdamer notation or expression-compatible input.
+     * @param values - Values substituted by name while parsing.
+     */
+    parse(str: ExpressionInput, values?: ParserValuesObject): ParserEntity;
+    /**
+     * Temporarily changes one Boolean parser setting while a callback runs.
+     * @param setting - Boolean setting name to change.
+     * @param value - Temporary value for that setting.
+     * @param callback - Work to perform before restoring the previous setting.
+     */
+    scopedBlock<K extends BooleanSettingName>(setting: K, value: SettingsType[K], callback: () => ParserEntity): ParserEntity;
+    /**
+     * Changes one shared parser setting and returns the parser for chaining.
+     * @param setting - Supported parser setting name.
+     * @param value - Value associated with that setting.
+     */
+    set<K extends keyof SettingsType>(setting: K, value: SettingsType[K]): ParserAPI;
+    /**
+     * Changes several supported parser settings and returns the parser for chaining.
+     * @param settings - Partial set of supported parser settings.
+     */
+    set(settings: Partial<SettingsType>): ParserAPI;
+    /**
+     * Registers or removes parser constants.
+     * @param constants - Constant names mapped to values or deletion markers.
+     */
+    setConstants(constants: ParserConstants): void;
+    /**
+     * Changes the symbol used for the imaginary unit.
+     * @param variable - New imaginary-unit symbol.
+     */
+    setI(variable: string): ParserAPI;
+    /**
+     * Alias for {@link ParserAPI.setI}.
+     * @param variable - New imaginary-unit symbol.
+     */
+    setImaginary(variable: string): ParserAPI;
+    /**
+     * Changes the Decimal precision used by numerical calculations.
+     * @param precision - Significant decimal digits to retain.
+     */
+    setPrecision(precision: number): void;
+}
+/**
+ * Shared parser exposed through the supported high-level interface.
+ *
+ * The implementation accepts a broader compatibility settings bag; this facade exposes
+ * only the named settings defined by {@link SettingsType}.
+ */
+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';

package/output/api/parser.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+/**
+ * Supported high-level parser APIs and parser configuration types.
+ *
+ * @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.
+ *
+ * The implementation accepts a broader compatibility settings bag; this facade exposes
+ * only the named settings defined by {@link SettingsType}.
+ */
+exports.Parser = Parser_1.Parser;

package/output/api/solve.d.ts

@@ -0,0 +1,10 @@
+export type { FunctionSolverOptions, Root } from '../solve/classes/FunctionSolver';
+/** Public symbolic and polynomial solver APIs. */
+export { MultivariateSolver } from '../solve/classes/MultivariateSolver';
+export type { MultivariateSolverOptions } from '../solve/classes/MultivariateSolver';
+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 { roots, solve } from '../solve/solve';
+export { solveSystem } from '../solve/solveSystem';

package/output/api/solve.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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; } });
+var PolynomialSolver_1 = require("../solve/classes/PolynomialSolver");
+Object.defineProperty(exports, "PolynomialSolver", { enumerable: true, get: function () { return PolynomialSolver_1.PolynomialSolver; } });
+var SolutionSet_1 = require("../solve/classes/SolutionSet");
+Object.defineProperty(exports, "SolutionSet", { enumerable: true, get: function () { return SolutionSet_1.SolutionSet; } });
+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

@@ -0,0 +1,10 @@
+/** Public structured-value and finite-set APIs. */
+export { Collection } from '../core/classes/collection/Collection';
+export { Dictionary } from '../core/classes/dictionary/Dictionary';
+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';
+export { cross, dot } from '../core/classes/vector/functions';
+export { Vector } from '../core/classes/vector/Vector';
+export type { StructuredEntityType } from '../core/types';

package/output/api/structures.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector = exports.dot = exports.cross = exports.ValuesSet = exports.imatrix = exports.Matrix = exports.nullspace = exports.invert = exports.determinant = exports.Dictionary = exports.Collection = void 0;
+/** Public structured-value and finite-set APIs. */
+var Collection_1 = require("../core/classes/collection/Collection");
+Object.defineProperty(exports, "Collection", { enumerable: true, get: function () { return Collection_1.Collection; } });
+var Dictionary_1 = require("../core/classes/dictionary/Dictionary");
+Object.defineProperty(exports, "Dictionary", { enumerable: true, get: function () { return Dictionary_1.Dictionary; } });
+var functions_1 = require("../core/classes/matrix/functions");
+Object.defineProperty(exports, "determinant", { enumerable: true, get: function () { return functions_1.determinant; } });
+Object.defineProperty(exports, "invert", { enumerable: true, get: function () { return functions_1.invert; } });
+Object.defineProperty(exports, "nullspace", { enumerable: true, get: function () { return functions_1.nullspace; } });
+var Matrix_1 = require("../core/classes/matrix/Matrix");
+Object.defineProperty(exports, "Matrix", { enumerable: true, get: function () { return Matrix_1.Matrix; } });
+var utils_1 = require("../core/classes/matrix/utils");
+Object.defineProperty(exports, "imatrix", { enumerable: true, get: function () { return utils_1.imatrix; } });
+var ValuesSet_1 = require("../core/classes/valuesSet/ValuesSet");
+Object.defineProperty(exports, "ValuesSet", { enumerable: true, get: function () { return ValuesSet_1.ValuesSet; } });
+var functions_2 = require("../core/classes/vector/functions");
+Object.defineProperty(exports, "cross", { enumerable: true, get: function () { return functions_2.cross; } });
+Object.defineProperty(exports, "dot", { enumerable: true, get: function () { return functions_2.dot; } });
+var Vector_1 = require("../core/classes/vector/Vector");
+Object.defineProperty(exports, "Vector", { enumerable: true, get: function () { return Vector_1.Vector; } });

package/output/calculus/adapters.d.ts

@@ -0,0 +1,8 @@
+import type { Expression } from '../core/classes/expression/Expression';
+import type { ParserEntity } from '../core/types';
+/** Applies differentiation to both sides when the parser supplies an Equation. */
+export declare function differentiate(expr: ParserEntity, variable?: ParserEntity, n?: ParserEntity): ParserEntity;
+/** Applies integration to both sides when the parser supplies an Equation. */
+export declare function integrateEquation(expr: ParserEntity, variable?: ParserEntity): ParserEntity;
+/** Maps a symbolic direction token to the direction accepted by limit. */
+export declare function directionalLimit(expr: Expression, x: Expression, val: Expression, dir?: Expression): Expression;

package/output/calculus/adapters.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.differentiate = differentiate;
+exports.integrateEquation = integrateEquation;
+exports.directionalLimit = directionalLimit;
+const Equation_1 = require("../core/classes/equation/Equation");
+const utils_1 = require("../core/classes/expression/utils");
+const diff_1 = require("./derivative/diff");
+const integrate_1 = require("./integrate/integrate");
+const limit_1 = require("./limit/limit");
+/** Applies differentiation to both sides when the parser supplies an Equation. */
+function differentiate(expr, variable, n) {
+    let retval;
+    if (Equation_1.Equation.isEquation(expr)) {
+        retval = expr.each(e => differentiate(e, variable, n));
+    }
+    else {
+        retval = (0, diff_1.diff)(expr, variable, n);
+    }
+    return retval;
+}
+/** Applies integration to both sides when the parser supplies an Equation. */
+function integrateEquation(expr, variable) {
+    let retval;
+    if (Equation_1.Equation.isEquation(expr)) {
+        retval = expr.each(e => integrateEquation(e, variable));
+    }
+    else {
+        retval = (0, integrate_1.integrate)(expr, variable);
+    }
+    return retval;
+}
+/** Maps a symbolic direction token to the direction accepted by limit. */
+function directionalLimit(expr, x, val, dir) {
+    let direction = 'both';
+    if (dir) {
+        direction = (0, utils_1.assertPlainVariableAndGetString)(dir);
+    }
+    const retval = (0, limit_1.limit)(expr, x, val, direction);
+    return retval;
+}

package/output/calculus/derivative/diff.d.ts

@@ -0,0 +1,30 @@
+import { Expression } from '../../core/classes/expression/Expression';
+import type { ExpressionInput } from '../../core/types';
+/**
+ * Differentiates an expression symbolically.
+ *
+ * The chain, product, sum, and power rules are applied recursively, together
+ * with the built-in derivative table for recognized functions. An omitted
+ * variable is inferred as the first variable in the expression. Existing
+ * Expression input is reused during normalization.
+ *
+ * @remarks
+ * `n` requests a repeated derivative. A non-integer order, a non-variable
+ * differentiation target, or an unsupported derivative is preserved as an
+ * unevaluated `diff(...)` expression. Constants and expressions independent of
+ * the selected variable differentiate to zero.
+ *
+ * @param x - Expression to differentiate.
+ * @param variable - Variable with respect to which the derivative is taken.
+ * @param n - Positive integer derivative order. Defaults to the first derivative.
+ * @returns The symbolic derivative, or an unevaluated `diff(...)` call when the
+ * requested operation cannot be resolved.
+ * @throws {@link core!UnsupportedOperationError} If `variable` is numeric.
+ *
+ * @example
+ * ```ts
+ * diff('sin(x^2)', 'x').text();
+ * diff('x^4', 'x', 2).text();
+ * ```
+ */
+export declare function diff(x: ExpressionInput, variable?: ExpressionInput, n?: Expression | number): Expression;