nerdamer 1.1.13 → 2.0.0-rc.2

package/output/core/converters/Converter.d.ts

@@ -0,0 +1,111 @@
+import { Expression } from '../classes/expression/Expression';
+import { BaseConverter } from './BaseConverter';
+import type { OptionsObject } from '../classes/parser/types';
+import type { FracArray } from '../classes/parser/types';
+import type { ParserEntity } from '../types';
+/**
+ * Formats Nerdamer values as TeX or normalized text and imports supported TeX input.
+ *
+ * @remarks
+ * A converter retains its output mode between calls. The default mode is `"TeX"`;
+ * construct a separate `"text"` converter when both representations are needed.
+ * Formatting a string parses it with the process-wide parser, so registered functions,
+ * constants, settings, and known values can affect the result.
+ *
+ * {@link Converter.fromTeX} recognizes the TeX forms emitted by this converter and a
+ * practical subset of common mathematical notation. It is not a general TeX parser:
+ * unsupported macros, ambiguous implicit notation, or nesting outside the recognized
+ * forms can produce parser errors or a different symbolic interpretation.
+ *
+ * @example
+ * ```ts
+ * import nerdamer from 'nerdamer';
+ *
+ * const text = new nerdamer.classes.Converter('text');
+ * const tex = new nerdamer.classes.Converter();
+ *
+ * text.convert('x^2 + 2*x + 1'); // "1+2*x+x^2"
+ * tex.convert('sqrt(x)');        // "\\sqrt{x}"
+ * ```
+ */
+export declare class Converter extends BaseConverter {
+    private static readonly TEX_FUNCTION_MAP;
+    /**
+     * Reverse map for fromTeX: maps TeX command names back to internal function names.
+     */
+    private static readonly TEX_REVERSE_MAP;
+    /**
+     * Creates a converter with persistent output mode.
+     *
+     * @param mode - `"TeX"` (the default) or `"text"`.
+     */
+    constructor(mode?: 'TeX' | 'text');
+    private static clearOnes;
+    private static wrapRoot;
+    protected finalizePowerAndInput(power: Expression, input: Expression, options?: OptionsObject): [Expression, Expression];
+    protected functionString(input: Expression, options?: OptionsObject): string;
+    protected value(input: Expression, isInverted: boolean, isNegative: boolean, options?: OptionsObject): FracArray;
+    private convertSourceRPN;
+    private formatFactorial;
+    private formatSumOrProduct;
+    private formatTeXFunction;
+    private formatVariable;
+    private getFunctionName;
+    private handleExp;
+    private handleProduct;
+    private handleSum;
+    /** Parses a top-level TeX matrix environment into a scalar-valued Matrix. */
+    private parseTeXMatrix;
+    private parseTeXSetOrDictionary;
+    private parseTeXVector;
+    /**
+     * Rewrites the supported TeX subset into parser syntax in an ordered pass.
+     *
+     * Structure-dependent forms such as transforms, derivatives, integrals, limits, and
+     * indexed sums must be recognized before generic braces and commands are removed.
+     * This is a compatibility preprocessor rather than a TeX grammar, so each rewrite is
+     * limited to the forms that can be mapped unambiguously to parser calls.
+     */
+    private preprocessTeXClean;
+    /**
+     * Rewrites one TeX command whose argument is carried in balanced braces.
+     *
+     * The converter emits some commands around expressions that can themselves contain
+     * nested TeX groups. A flat regular expression cannot safely recover those arguments,
+     * so this keeps the brace matching local to the TeX conversion pipeline.
+     */
+    private replaceBracedTeXCommand;
+    private splitTeXTopLevel;
+    /**
+     * Formats supported values while retaining ordinary Converter semantics by default.
+     * Source preservation is an internal compatibility option used by convertToLaTeX.
+     */
+    convert(input: ParserEntity | string | number, options?: OptionsObject): string;
+    /**
+     * Parses a supported TeX subset into a Nerdamer parser entity.
+     *
+     * @remarks
+     * Set notation is recognized before ordinary expression preprocessing and produces a
+     * value set or dictionary when appropriate. Other input is rewritten to Nerdamer
+     * parser syntax, tokenized in pure mode, and evaluated through the process-wide parser.
+     * Consequently, parser settings or registered functions can affect the result.
+     *
+     * The importer supports the converter's common function forms, roots, arbitrary-base
+     * logarithms, transforms, derivatives, integrals, limits, sums, products, floor and
+     * ceiling notation, equations, vectors, matrices, finite sets, and dictionaries. It does
+     * not promise round-tripping arbitrary third-party TeX.
+     *
+     * @param input - TeX text in the supported conversion subset.
+     * @returns The parser entity represented by the supported TeX input.
+     * @throws Error When preprocessing leaves syntax that the parser cannot interpret.
+     *
+     * @example
+     * ```ts
+     * import nerdamer from 'nerdamer';
+     *
+     * const converter = new nerdamer.classes.Converter();
+     * nerdamer.pretty(converter.fromTeX('\\log_{2}{256}'), 'text'); // "8"
+     * ```
+     */
+    fromTeX(input: string): ParserEntity;
+}