nerdamer 1.1.13 → 2.0.0-rc.2

package/output/core/converters/Converter.js

@@ -0,0 +1,806 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Converter = void 0;
+const Dictionary_1 = require("../classes/dictionary/Dictionary");
+const Expression_1 = require("../classes/expression/Expression");
+const shortcuts_1 = require("../classes/expression/shortcuts");
+const Matrix_1 = require("../classes/matrix/Matrix");
+const constants_1 = require("../classes/parser/constants");
+const Parser_1 = require("../classes/parser/Parser");
+const Token_1 = require("../classes/parser/Token");
+const ValuesSet_1 = require("../classes/valuesSet/ValuesSet");
+const Vector_1 = require("../classes/vector/Vector");
+const Scope_1 = require("../common/classes/Scope");
+const dispatch_1 = require("../dispatch");
+const errors_1 = require("../errors");
+const BaseConverter_1 = require("./BaseConverter");
+const { TeX, TEXT } = BaseConverter_1.BaseConverter.modes;
+/**
+ * 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}"
+ * ```
+ */
+class Converter extends BaseConverter_1.BaseConverter {
+    static TEX_FUNCTION_MAP = {
+        // Inverse trig
+        acos: 'arccos',
+        asin: 'arcsin',
+        atan: 'arctan',
+        asec: 'operatorname{arcsec}',
+        acsc: 'operatorname{arccsc}',
+        acot: 'operatorname{arccot}',
+        // Inverse hyperbolic
+        acosh: 'operatorname{arcosh}',
+        asinh: 'operatorname{arsinh}',
+        atanh: 'operatorname{artanh}',
+        asech: 'operatorname{arsech}',
+        acsch: 'operatorname{arcsch}',
+        acoth: 'operatorname{arcoth}',
+        // Hyperbolic (not built-in in LaTeX)
+        sech: 'operatorname{sech}',
+        csch: 'operatorname{csch}',
+        coth: 'operatorname{coth}',
+        // Special
+        realpart: 'Re',
+        imagpart: 'Im',
+        sign: 'operatorname{sgn}',
+        sinc: 'operatorname{sinc}',
+        erf: 'operatorname{erf}',
+        erfc: 'operatorname{erfc}',
+        determinant: 'det',
+    };
+    /**
+     * Reverse map for fromTeX: maps TeX command names back to internal function names.
+     */
+    static TEX_REVERSE_MAP = {
+        arccos: 'acos',
+        arcsin: 'asin',
+        arctan: 'atan',
+        arcsec: 'asec',
+        arccsc: 'acsc',
+        arccot: 'acot',
+        arcosh: 'acosh',
+        arsinh: 'asinh',
+        artanh: 'atanh',
+        arsech: 'asech',
+        arcsch: 'acsch',
+        arcoth: 'acoth',
+        det: 'determinant',
+        deg: constants_1.DEG,
+        sgn: 'sign',
+        operatorname: '',
+        Gamma: 'gamma',
+        delta: constants_1.DIRAC,
+        Re: 'realpart',
+        Im: 'imagpart',
+    };
+    /**
+     * Creates a converter with persistent output mode.
+     *
+     * @param mode - `"TeX"` (the default) or `"text"`.
+     */
+    constructor(mode) {
+        super();
+        if (mode) {
+            this.setMode(mode);
+        }
+    }
+    static clearOnes(m, v) {
+        for (let i = 0; i < 2; i++) {
+            if (v[i] && Number(m[i]) === 1) {
+                m[i] = '';
+            }
+        }
+        return [m, v];
+    }
+    static wrapRoot(value, root) {
+        return root === '2' ? `\\sqrt{${value}}` : `\\sqrt[${root}]{${value}}`;
+    }
+    finalizePowerAndInput(power, input, options) {
+        if (!options?.convertRoots) {
+            return [power, input];
+        }
+        const num = power.getNumerator();
+        const den = power.getDenominator();
+        if (num.isOne() && !power.isOne()) {
+            if (this.mode === BaseConverter_1.BaseConverter.modes.TEXT && den.eq((0, shortcuts_1.two)())) {
+                return [(0, shortcuts_1.one)(), BaseConverter_1.BaseConverter.convertSQRT(input)];
+            }
+            if (this.mode === BaseConverter_1.BaseConverter.modes.TeX) {
+                return [(0, shortcuts_1.one)(), BaseConverter_1.BaseConverter.convertNtRoot(input, den)];
+            }
+        }
+        return [power, input];
+    }
+    functionString(input, options) {
+        const name = this.getFunctionName(input.name || '');
+        const args = input.getArguments();
+        const output = args.map(arg => this.convert(arg, options));
+        if (this.mode === TEXT) {
+            return `${name}(${output.join(',')})`;
+        }
+        return this.formatTeXFunction(input.name || '', name, output, args);
+    }
+    value(input, isInverted, isNegative, options) {
+        const v = ['', ''];
+        const index = isInverted ? 1 : 0;
+        if (input.isNUM()) {
+            return v;
+        }
+        if (input.isEXP()) {
+            v[index] = this.handleExp(input, options);
+        }
+        else if (input.isInf()) {
+            v[index] = this.mode === 'text' ? constants_1.INFINITY[0] : '\\infty';
+        }
+        else if (!(input.elements || input.args)) {
+            v[index] = this.formatVariable(input.value);
+        }
+        else if (input.isFunction()) {
+            v[index] = this.functionString(input, options);
+        }
+        else if (input.isSum()) {
+            v[index] = this.handleSum(input, isNegative, options);
+        }
+        else if (input.isProduct()) {
+            return this.handleProduct(input, isInverted, options);
+        }
+        return v;
+    }
+    convertSourceRPN(rpn, options) {
+        const stack = [];
+        for (let i = 0; i < rpn.length; i++) {
+            const item = rpn[i];
+            if (Scope_1.Scope.isScope(item)) {
+                const converted = this.convertSourceRPN(item, options);
+                const innerText = converted.args
+                    ? converted.args.map(arg => arg.text).join(',')
+                    : converted.text;
+                const innerSource = converted.args
+                    ? converted.args.map(arg => arg.source).join(',')
+                    : converted.source;
+                let text = innerText;
+                let source = innerSource;
+                switch (item.type) {
+                    case 'parenthesis':
+                        text = this.inBrackets(innerText);
+                        source = `(${innerSource})`;
+                        break;
+                    case 'square':
+                        text = this.inBrackets(innerText, 'square');
+                        source = `[${innerSource}]`;
+                        break;
+                    case 'curly':
+                        text = this.inBrackets(innerText, 'brace');
+                        source = `{${innerSource}}`;
+                        break;
+                    case 'pipe':
+                        text = this.inBrackets(innerText, 'abs');
+                        source = `|${innerSource}|`;
+                        break;
+                }
+                stack.push({ text, source });
+            }
+            else if (item.type === Token_1.Token.FUNCTION) {
+                const argsScope = rpn[++i];
+                if (!Scope_1.Scope.isScope(argsScope)) {
+                    throw new Error((0, errors_1.message)('converterMissingArgumentScope', { function: item.value }));
+                }
+                let args = [];
+                if (argsScope.length > 0) {
+                    const argumentRPN = dispatch_1.mathFunctionRegistry[item.value]?.deferArguments
+                        ? Parser_1.Parser.toRPN(argsScope)
+                        : argsScope;
+                    const converted = this.convertSourceRPN(argumentRPN, options);
+                    args = converted.args ?? [converted];
+                }
+                const output = args.map(arg => arg.text);
+                const placeholders = args.map((_, index) => Expression_1.Expression.create(`zzsourcearg${index}`));
+                const name = this.getFunctionName(item.value);
+                let text;
+                if (item.value === Expression_1.Expression.LOG && args.length === 2) {
+                    const numerator = this.formatTeXFunction(Expression_1.Expression.LOG, name, [output[0]], [placeholders[0]]);
+                    const denominator = this.formatTeXFunction(Expression_1.Expression.LOG, name, [output[1]], [placeholders[1]]);
+                    text = this.toFraction(numerator, denominator);
+                }
+                else if (item.value === 'sqrt' && args.length === 1) {
+                    text = Converter.wrapRoot(output[0], '2');
+                }
+                else if (args.length === 1 &&
+                    (item.value === constants_1.FACTORIAL ||
+                        item.value === 'factorial' ||
+                        item.value === constants_1.DOUBLE_FACTORIAL)) {
+                    text = this.formatTeXFunction(item.value, name, output, [
+                        Expression_1.Expression.create(args[0].source),
+                    ]);
+                }
+                else {
+                    text = this.formatTeXFunction(item.value, name, output, placeholders);
+                }
+                stack.push({
+                    text,
+                    source: `${item.value}(${args.map(arg => arg.source).join(',')})`,
+                });
+            }
+            else if (item.type === Token_1.Token.PREFIX) {
+                const operand = stack.pop();
+                if (!operand) {
+                    throw new Error((0, errors_1.message)('converterMissingPrefixOperand', { operator: item.value }));
+                }
+                stack.push({
+                    text: item.value + operand.text,
+                    source: item.value + operand.source,
+                });
+            }
+            else if (item.type === Token_1.Token.OPERATOR) {
+                const operator = item.resolvedOperator ?? Parser_1.Parser.getOperator(item.value);
+                const right = stack.pop();
+                if (!operator || !right) {
+                    throw new Error((0, errors_1.message)('converterMissingOperandMetadata', { operator: item.value }));
+                }
+                if (operator.isPostfix) {
+                    const symbol = item.value === '%' ? '\\%' : item.value;
+                    stack.push({
+                        text: right.text + symbol,
+                        source: right.source + item.value,
+                    });
+                    continue;
+                }
+                const left = stack.pop();
+                if (!left) {
+                    throw new Error((0, errors_1.message)('converterMissingLeftOperand', { operator: item.value }));
+                }
+                if (operator.action === 'comma') {
+                    const args = [...(left.args ?? [left]), ...(right.args ?? [right])];
+                    stack.push({
+                        text: args.map(arg => arg.text).join(','),
+                        source: args.map(arg => arg.source).join(','),
+                        args,
+                    });
+                    continue;
+                }
+                let text;
+                if (operator.action === 'times') {
+                    text =
+                        left.text +
+                            (item.position === -1 ? '' : this.getMultiplicationSymbol()) +
+                            right.text;
+                }
+                else if (operator.action === 'div') {
+                    text = this.toFraction(left.text, right.text);
+                }
+                else if (operator.action === 'pow') {
+                    const power = Expression_1.Expression.create(right.source);
+                    if (power.sign() === -1) {
+                        const positivePower = power.signFree();
+                        const denominator = positivePower.isOne()
+                            ? left.text
+                            : left.text + '^' + this.inBraces(super.convert(positivePower, options));
+                        text = this.toFraction('1', denominator);
+                    }
+                    else {
+                        text = left.text + '^' + this.inBraces(right.text);
+                    }
+                }
+                else if (operator.action === 'mod') {
+                    text = this.formatTeXFunction('mod', this.getFunctionName('mod'), [left.text, right.text], [Expression_1.Expression.create('zzsourcearg0'), Expression_1.Expression.create('zzsourcearg1')]);
+                }
+                else if (operator.action === 'mapTo') {
+                    text = `${left.text} \\mapsto ${right.text}`;
+                }
+                else {
+                    text = left.text + item.value + right.text;
+                }
+                stack.push({
+                    text,
+                    source: `(${left.source})${item.value}(${right.source})`,
+                });
+            }
+            else {
+                let text = item.value;
+                if (item.type === Token_1.Token.VARIABLE) {
+                    text = constants_1.INFINITY.includes(item.value) ? '\\infty' : this.formatVariable(item.value);
+                }
+                stack.push({ text, source: item.value });
+            }
+        }
+        if (stack.length !== 1) {
+            throw new Error((0, errors_1.message)('converterTexConversionFailed'));
+        }
+        const retval = stack[0];
+        return retval;
+    }
+    formatFactorial(arg, output, symbol) {
+        if (arg.isLinear() && (arg.isSum() || arg.isProduct())) {
+            output = this.inBrackets(output);
+        }
+        return output + symbol;
+    }
+    formatSumOrProduct(symbol, output) {
+        const [a, b, c, d] = output;
+        return `${symbol}_{${this.inBraces(b)}=${this.inBraces(c)}}^${this.inBraces(d)} ${this.inBraces(a)}`;
+    }
+    formatTeXFunction(originalName, name, output, args) {
+        // Standard function: \name\left(arg\right)
+        const std = () => name + this.inBrackets(output[0]);
+        const generic = () => {
+            const formattedName = '\\operatorname' + this.inBraces(originalName.replace(/_/g, '\\_'));
+            return formattedName + this.inBrackets(output.join(','), 'parens');
+        };
+        const handlers = {
+            // Basic math
+            sqrt: std,
+            abs: () => this.inBrackets(output[0], 'abs'),
+            cbrt: () => `\\sqrt[3]${this.inBraces(output[0])}`,
+            max: () => `\\max${this.inBrackets(output.join(','), 'parens')}`,
+            min: () => `\\min${this.inBrackets(output.join(','), 'parens')}`,
+            round: () => output.length === 1
+                ? `\\left\\lfloor ${output[0]} \\right\\rceil`
+                : generic(),
+            mod: () => `${output[0]} \\bmod ${output[1]}`,
+            [constants_1.FACTORIAL]: () => this.formatFactorial(args[0], output[0], '!'),
+            factorial: () => this.formatFactorial(args[0], output[0], '!'),
+            [constants_1.DOUBLE_FACTORIAL]: () => this.formatFactorial(args[0], output[0], '!!'),
+            parens: () => this.inBrackets(output[0], 'parens'),
+            // Trig
+            cos: std,
+            sin: std,
+            tan: std,
+            sec: std,
+            csc: std,
+            cot: std,
+            // Inverse trig
+            acos: std,
+            asin: std,
+            atan: std,
+            asec: std,
+            acsc: std,
+            acot: std,
+            atan2: () => name + this.inBrackets(output.join(','), 'parens'),
+            // Hyperbolic
+            sinh: std,
+            cosh: std,
+            tanh: std,
+            sech: std,
+            csch: std,
+            coth: std,
+            // Inverse hyperbolic
+            acosh: std,
+            asinh: std,
+            atanh: std,
+            asech: std,
+            acsch: std,
+            acoth: std,
+            // Floor / ceiling
+            floor: () => `\\left\\lfloor ${output[0]} \\right\\rfloor`,
+            ceil: () => `\\left\\lceil ${output[0]} \\right\\rceil`,
+            ceiling: () => `\\left\\lceil ${output[0]} \\right\\rceil`,
+            // Logarithms
+            [Expression_1.Expression.LOG]: () => {
+                const base = output[1];
+                const subscript = base === undefined ? '' : `_${this.inBraces(base)}`;
+                return `\\mathrm${this.inBraces(Expression_1.Expression.LOG)}${subscript}${this.inBrackets(output[0])}`;
+            },
+            [Expression_1.Expression.LOG10]: () => `\\mathrm${this.inBraces(Expression_1.Expression.LOG)}_${this.inBraces('10')}${this.inBrackets(output[0])}`,
+            log10: () => `\\mathrm${this.inBraces(Expression_1.Expression.LOG)}_${this.inBraces('10')}${this.inBrackets(output[0])}`,
+            // Special functions
+            exp: std,
+            gamma: () => `\\Gamma${this.inBrackets(output[0])}`,
+            gamma_incomplete: () => `\\Gamma${this.inBrackets(output.join(','), 'parens')}`,
+            gamma_incomplete_lower: () => `\\gamma${this.inBrackets(output.join(','), 'parens')}`,
+            erf: std,
+            erfc: std,
+            sinc: std,
+            Si: () => `\\operatorname{Si}${this.inBrackets(output[0])}`,
+            Shi: () => `\\operatorname{Shi}${this.inBrackets(output[0])}`,
+            Ci: () => `\\operatorname{Ci}${this.inBrackets(output[0])}`,
+            Chi: () => `\\operatorname{Chi}${this.inBrackets(output[0])}`,
+            Ei: () => `\\operatorname{Ei}${this.inBrackets(output[0])}`,
+            [constants_1.LI]: () => `\\operatorname{Li}${this.inBrackets(output[0])}`,
+            // Step / impulse
+            [constants_1.HEAVISIDE]: () => `H${this.inBrackets(output[0])}`,
+            [constants_1.DIRAC]: () => `\\delta${this.inBrackets(output[0])}`,
+            dirac: () => `\\delta${this.inBrackets(output[0])}`,
+            sign: std,
+            // Complex
+            realpart: () => `\\Re${this.inBrackets(output[0])}`,
+            imagpart: () => `\\Im${this.inBrackets(output[0])}`,
+            arg: std,
+            [constants_1.CONJUGATE]: () => `\\overline${this.inBraces(output[0])}`,
+            // Linear algebra
+            determinant: std,
+            // Polynomials
+            [constants_1.DEG]: std,
+            // Calculus
+            limit: () => `\\lim_${this.inBraces(output[1] + ' \\to ' + output[2])} ${output[0]}`,
+            integrate: () => output.length === 2 ? `\\int ${output[0]}\\, d${output[1]}` : generic(),
+            defint: () => `\\int_${this.inBraces(output[1])}^${this.inBraces(output[2])} ${output[0]}\\, d${output[3]}`,
+            diff: () => {
+                let retval;
+                if (output.length === 1) {
+                    retval = generic();
+                }
+                else if (output.length === 3) {
+                    retval = `\\frac${this.inBraces('d^' + output[2])}${this.inBraces('d' + output[1] + '^' + output[2])} ${output[0]}`;
+                }
+                else {
+                    retval = `\\frac${this.inBraces('d')}${this.inBraces('d' + output[1])} ${output[0]}`;
+                }
+                return retval;
+            },
+            laplace: () => `\\mathcal{L}_${this.inBraces(output[1] + ' \\to ' + output[2])}\\left\\{${output[0]}\\right\\}`,
+            ilaplace: () => `\\mathcal{L}^{-1}_${this.inBraces(output[1] + ' \\to ' + output[2])}\\left\\{${output[0]}\\right\\}`,
+            partfrac: () => `\\operatorname{partfrac}${this.inBrackets(output.join(','), 'parens')}`,
+            // Summation / product
+            sum: () => this.formatSumOrProduct('\\sum', output),
+            product: () => this.formatSumOrProduct('\\prod', output),
+            // Roots
+            nthroot: () => output[1] === '2'
+                ? `\\sqrt${this.inBraces(output[0])}`
+                : `\\sqrt[${output[1]}]${this.inBraces(output[0])}`,
+            // Number theory
+            gcd: () => name + this.inBrackets(output.join(','), 'parens'),
+            lcm: () => `\\operatorname{lcm}${this.inBrackets(output.join(','), 'parens')}`,
+            // Wrapper
+            [constants_1.WRAP]: () => output[0],
+        };
+        const handler = handlers[originalName];
+        if (handler) {
+            return handler();
+        }
+        return generic();
+    }
+    formatVariable(value) {
+        return this.formatSubscripts(value)
+            .split('_')
+            .map((v, i) => {
+            if (this.mode === BaseConverter_1.BaseConverter.modes.TeX && this.greek.includes(v)) {
+                v = `\\${v}`;
+            }
+            return i > 0 ? this.inBraces(v) : v;
+        })
+            .join('_');
+    }
+    getFunctionName(name) {
+        if (this.mode !== TeX) {
+            return name;
+        }
+        const mappedName = Converter.TEX_FUNCTION_MAP[name] || name;
+        return `\\${mappedName}`;
+    }
+    handleExp(input, options) {
+        const arg = input.getBase();
+        let value = this.convert(arg, options);
+        if (!(arg.isInteger() || arg.isVAR())) {
+            value = this.inBrackets(value);
+        }
+        return value;
+    }
+    handleProduct(input, isInverted, options) {
+        const mul = this.getMultiplicationSymbol();
+        const numOutput = [];
+        const denOutput = [];
+        for (let element of input.elementsArray()) {
+            if (element.isFunction(constants_1.WRAP)) {
+                element = element.getArguments()[0];
+            }
+            const elementIsInverted = element.getPower().sign() === -1;
+            const isInDenominator = isInverted ? !elementIsInverted : elementIsInverted;
+            const target = isInDenominator ? denOutput : numOutput;
+            if (elementIsInverted) {
+                element = element.invert();
+            }
+            let output = this.convert(element, options);
+            if (element.isSum() && element.isLinear()) {
+                output = this.inBrackets(output);
+            }
+            target.push(output);
+        }
+        return [numOutput.join(mul), denOutput.join(mul)];
+    }
+    handleSum(input, isNegative, options) {
+        const elements = input.elementsArray().map(e => this.convert(e, options));
+        const value = elements.join('+');
+        const needsBrackets = !(input.isLinear() && input.getMultiplier().isOne()) || isNegative;
+        return needsBrackets ? this.inBrackets(value, 'parens') : value;
+    }
+    /** Parses a top-level TeX matrix environment into a scalar-valued Matrix. */
+    parseTeXMatrix(input) {
+        const match = input.match(/^\\begin\{([pbBvV]?matrix)\}\s*([\s\S]*?)\s*\\end\{\1\}$/);
+        let retval;
+        if (match) {
+            const rows = match[2]
+                .split(/\\\\/)
+                .map(row => row.trim())
+                .filter(row => row.length > 0)
+                .map(row => row.split('&').map(cell => Expression_1.Expression.create(this.fromTeX(cell.trim()))));
+            retval = new Matrix_1.Matrix(...rows);
+        }
+        return retval;
+    }
+    parseTeXSetOrDictionary(inner) {
+        const items = this.splitTeXTopLevel(inner, ',');
+        const entries = items.map(item => this.splitTeXTopLevel(item, '\\mapsto'));
+        const isDictionary = entries.some(parts => parts.length === 2);
+        if (isDictionary) {
+            const dictionaryEntries = new Map();
+            for (const parts of entries) {
+                if (parts.length === 2) {
+                    const key = parts[0].trim();
+                    const value = this.fromTeX(parts[1].trim());
+                    dictionaryEntries.set(key, value);
+                }
+            }
+            return new Dictionary_1.Dictionary(dictionaryEntries);
+        }
+        const set = new ValuesSet_1.ValuesSet();
+        for (const item of items) {
+            if (item.trim()) {
+                set.add(this.fromTeX(item.trim()));
+            }
+        }
+        return set;
+    }
+    parseTeXVector(input) {
+        const match = input.match(/^\\left\s*\[([\s\S]*)\\right\s*\]$/) || input.match(/^\[([\s\S]*)\]$/);
+        let retval;
+        if (match) {
+            const elements = this.splitTeXTopLevel(match[1], ',')
+                .map(item => item.trim())
+                .filter(item => item.length > 0)
+                .map(item => this.fromTeX(item));
+            retval = new Vector_1.Vector(elements);
+        }
+        return retval;
+    }
+    /**
+     * 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.
+     */
+    preprocessTeXClean(input) {
+        let s = input;
+        // Normalize valid short-form fractions before the existing brace-based TeX path runs.
+        s = s.replace(/\\frac\s*\{([^{}]+)\}\s*([a-zA-Z0-9.])/g, '\\frac{$1}{$2}');
+        s = s.replace(/\\frac\s*([a-zA-Z0-9.])\s*\{([^{}]+)\}/g, '\\frac{$1}{$2}');
+        s = s.replace(/\\frac\s*([a-zA-Z0-9.])\s*([a-zA-Z0-9.])/g, '\\frac{$1}{$2}');
+        // A whole number immediately followed by a numeric fraction is conventional mixed-number notation.
+        s = s.replace(/(\d+)\s*\\frac\s*\{(\d+)\}\s*\{(\d+)\}/g, '($1+\\frac{$2}{$3})');
+        // --- Laplace transforms (before brace stripping) ---
+        s = s.replace(/\\mathcal\s*\{L\}\s*\^\s*\{-1\}\s*_\s*\{([^{}]+?)\s*\\to\s*([^{}]+?)\}\s*(?:\\left\s*)?\\{(.+?)\\}\s*(?:\\right\s*)?/g, (_m, source, target, expr) => `ilaplace(${expr},${String(source).trim()},${String(target).trim()})`);
+        s = s.replace(/\\mathcal\s*\{L\}\s*_\s*\{([^{}]+?)\s*\\to\s*([^{}]+?)\}\s*(?:\\left\s*)?\\{(.+?)\\}\s*(?:\\right\s*)?/g, (_m, source, target, expr) => `laplace(${expr},${String(source).trim()},${String(target).trim()})`);
+        s = s.replace(/\\mathcal\s*\{L\}\s*\^\s*\{-1\}\s*(?:\\left\s*)?\\{(.+?)\\}\s*(?:\\right\s*)?/g, 'ilaplace($1)');
+        s = s.replace(/\\mathcal\s*\{L\}\s*(?:\\left\s*)?\\{(.+?)\\}\s*(?:\\right\s*)?/g, 'laplace($1)');
+        // --- Derivatives: \frac{d^n}{dx^n} f → diff(f, x, n) ---
+        // Higher order
+        s = s.replace(/\\frac\s*\{d\^(\w+)\}\s*\{d(\w+)\^\1\}\s*(.+)/g, (_m, n, v, f) => `diff(${f},${v},${n})`);
+        // First order
+        s = s.replace(/\\frac\s*\{d\}\s*\{d(\w+)\}\s*(.+)/g, (_m, v, f) => `diff(${f},${v})`);
+        // --- Definite integrals ---
+        s = s.replace(/\\int\s*_\s*\{([^}]+)\}\s*\^\s*\{([^}]+)\}\s*(.+?)\\?,?\s*d(\w+)/g, (_m, a, b, f, v) => `defint(${f},${a},${b},${v})`);
+        // --- Indefinite integrals ---
+        s = s.replace(/\\int\s+(.+?)\\?,?\s*d(\w+)/g, (_m, f, v) => `integrate(${f},${v})`);
+        // --- Limits: \lim_{x \to a} f → limit(f, x, a) ---
+        s = s.replace(/\\lim\s*_\s*\{(\w+)\s*\\to\s*([^}]+)\}\s*(.+)/g, (_m, v, a, f) => `limit(${f},${v},${a})`);
+        // --- Sum / Product: \sum_{i=a}^{b} f → sum(f, i, a, b) ---
+        s = s.replace(/\\sum\s*_\s*\{(\w+)=([^}]+)\}\s*\^\s*\{([^}]+)\}\s*(.+)/g, (_m, i, a, b, f) => `sum(${f},${i},${a},${b})`);
+        s = s.replace(/\\prod\s*_\s*\{(\w+)=([^}]+)\}\s*\^\s*\{([^}]+)\}\s*(.+)/g, (_m, i, a, b, f) => `product(${f},${i},${a},${b})`);
+        // --- Floor / Ceiling ---
+        s = s.replace(/(?:\\left\s*)?\\lfloor\s*(.+?)\s*(?:\\right\s*)?\\rceil/g, 'round($1)');
+        s = s.replace(/(?:\\left\s*)?\\lfloor\s*/g, 'floor(');
+        s = s.replace(/\\rfloor\s*(?:\\right\s*)?/g, ')');
+        s = s.replace(/(?:\\left\s*)?\\lceil\s*/g, 'ceil(');
+        s = s.replace(/\\rceil\s*(?:\\right\s*)?/g, ')');
+        // --- Arbitrary-base logarithms ---
+        s = s.replace(/\\log\s*_\s*\{([^}]+)\}\s*\{([^}]+)\}/g, 'log($2,$1)');
+        s = s.replace(/\\log\s*_\s*\{([^}]+)\}\s*([a-zA-Z0-9_.]+)/g, 'log($2,$1)');
+        // --- Special functions ---
+        s = this.replaceBracedTeXCommand(s, 'overline', constants_1.CONJUGATE);
+        s = s.replace(/\\Gamma\s*/g, 'gamma');
+        s = s.replace(/\\delta\s*/g, constants_1.DIRAC);
+        s = s.replace(/(?<![a-zA-Z])H\s*(?=(?:\\left\s*)?\()/g, constants_1.HEAVISIDE);
+        s = s.replace(/\\Re\s*/g, 'realpart');
+        s = s.replace(/\\Im\s*/g, 'imagpart');
+        // --- \operatorname{name} → name ---
+        s = s.replace(/\\operatorname\s*\{([^}]+)\}/g, '$1');
+        // --- Inverse trig/hyperbolic TeX names → internal names ---
+        for (const [texName, internalName] of Object.entries(Converter.TEX_REVERSE_MAP)) {
+            if (texName === 'operatorname' ||
+                texName === 'Gamma' ||
+                texName === 'delta' ||
+                texName === 'Re' ||
+                texName === 'Im') {
+                continue; // already handled above
+            }
+            s = s.replace(new RegExp(`\\\\${texName}\\b`, 'g'), internalName);
+        }
+        // --- \bmod ---
+        s = s.replace(/(.+?)\s*\\bmod\s*(.+)/g, 'mod($1,$2)');
+        // --- nth root: \sqrt[n]{x} → nthroot(x,n), \sqrt{x} → sqrt(x) ---
+        s = s.replace(/\\sqrt\s*\[([^\]]+)\]\s*\{([^}]+)\}/g, 'nthroot($2,$1)');
+        s = s.replace(/\\sqrt\s*\{([^}]+)\}/g, 'sqrt($1)');
+        // --- Standard cleanup (same as original fromTeX) ---
+        s = s.replace(/\\,/g, '');
+        s = s.replace(/\s*\\cdot\s*/g, '*');
+        s = s.replace(/\s*(?:\\left|\\right)\s*/g, '');
+        s = s.replace(/\\infty/g, 'Infinity');
+        s = s.replace(/\s*[{(]/g, '(');
+        s = s.replace(/}/g, ')');
+        s = s.replace(/\s+|\\/g, ' ');
+        return s;
+    }
+    /**
+     * 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.
+     */
+    replaceBracedTeXCommand(input, command, functionName) {
+        const marker = `\\${command}`;
+        let retval = '';
+        let cursor = 0;
+        while (cursor < input.length) {
+            const commandIndex = input.indexOf(marker, cursor);
+            if (commandIndex === -1) {
+                retval += input.slice(cursor);
+                cursor = input.length;
+            }
+            else {
+                retval += input.slice(cursor, commandIndex);
+                let openIndex = commandIndex + marker.length;
+                while (openIndex < input.length && /\s/.test(input[openIndex])) {
+                    openIndex++;
+                }
+                if (input[openIndex] !== '{') {
+                    retval += marker;
+                    cursor = commandIndex + marker.length;
+                }
+                else {
+                    let depth = 1;
+                    let closeIndex = openIndex + 1;
+                    while (closeIndex < input.length && depth > 0) {
+                        if (input[closeIndex] === '{') {
+                            depth++;
+                        }
+                        else if (input[closeIndex] === '}') {
+                            depth--;
+                        }
+                        closeIndex++;
+                    }
+                    if (depth !== 0) {
+                        retval += input.slice(commandIndex);
+                        cursor = input.length;
+                    }
+                    else {
+                        const inner = input.slice(openIndex + 1, closeIndex - 1);
+                        const convertedInner = this.replaceBracedTeXCommand(inner, command, functionName);
+                        retval += `${functionName}(${convertedInner})`;
+                        cursor = closeIndex;
+                    }
+                }
+            }
+        }
+        return retval;
+    }
+    splitTeXTopLevel(input, delimiter) {
+        const items = [];
+        let depth = 0;
+        let current = '';
+        for (let i = 0; i < input.length; i++) {
+            const ch = input[i];
+            if (delimiter === ',' && ch === '\\' && input[i + 1] === ',') {
+                i++;
+                continue;
+            }
+            if (ch === '{' || ch === '[' || ch === '(') {
+                depth++;
+            }
+            else if (ch === '}' || ch === ']' || ch === ')') {
+                depth--;
+            }
+            if (depth === 0 && input.startsWith(delimiter, i)) {
+                items.push(current);
+                current = '';
+                i += delimiter.length - 1;
+            }
+            else {
+                current += ch;
+            }
+        }
+        if (current.trim()) {
+            items.push(current);
+        }
+        return items;
+    }
+    /**
+     * Formats supported values while retaining ordinary Converter semantics by default.
+     * Source preservation is an internal compatibility option used by convertToLaTeX.
+     */
+    convert(input, options) {
+        let retval;
+        if (typeof input === 'string' &&
+            this.mode === TeX &&
+            options?.preserveSource === true &&
+            options.decimal !== true) {
+            const rpn = Parser_1.Parser.toRPN(Parser_1.Parser.tokenize(input));
+            const converted = this.convertSourceRPN(rpn, options);
+            retval = converted.args
+                ? converted.args.map(arg => arg.text).join(',')
+                : converted.text;
+        }
+        else {
+            retval = super.convert(input, options);
+        }
+        return retval;
+    }
+    /**
+     * 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) {
+        const trimmed = input.trim();
+        const matrix = this.parseTeXMatrix(trimmed);
+        if (matrix) {
+            return matrix;
+        }
+        const vector = this.parseTeXVector(trimmed);
+        if (vector) {
+            return vector;
+        }
+        // Detect set/dictionary notation: \{...\} or \left\{...\right\}
+        const setMatch = trimmed.match(/^\\left\s*\\{(.*)\\right\s*\\}$/) || trimmed.match(/^\\{(.*)\\}$/);
+        if (setMatch) {
+            return this.parseTeXSetOrDictionary(setMatch[1]);
+        }
+        const str = this.preprocessTeXClean(input);
+        const TeXRPN = Parser_1.Parser.tokenize(str, { pure: true });
+        return Parser_1.Parser.parse(Parser_1.Parser.parseTeXRPN(TeXRPN));
+    }
+}
+exports.Converter = Converter;