@syncfusion/ej2-office-common 35.1.37 → 35.1.43

package/src/office-common/features/mathml/latex/latex-parser.js

@@ -0,0 +1,1206 @@
+/**
+ * LaTeX → Office Math model parser.
+ *
+ * Port of compression `LaTeXConverter.ParseMathPara` (Syncfusion.Office MathML).
+ * The scanning rules intentionally mirror the .NET implementation (including
+ * Microsoft Word's tolerant handling of malformed input, which degrades to plain
+ * text runs).
+ *
+ * @packageDocumentation
+ */
+import { MathFontType, MathFractionType, MathFunctionType, MathHorizontalAlignment, MathLimitType, MathScriptType, MathStyleType } from '../office-math/enums';
+import { OfficeMathParagraph } from '../office-math/math-paragraph';
+import { getLatexSymbol } from './latex-symbols';
+// Built at runtime: Unicode property escapes need the `u` flag, which ES5 compile targets reject in literals.
+var LETTER = new RegExp('^\\p{L}$', 'u');
+var LETTER_OR_DIGIT = new RegExp('^[\\p{L}\\p{Nd}]$', 'u');
+var GROUP_START = '{';
+var GROUP_END = '}';
+var SQUARE_START = '[';
+var SQUARE_END = ']';
+var CONTROL_START = '\\';
+var SPACE = ' ';
+var MATRIX_ROW_END = '\\\\';
+var MATRIX_COL_END = '&';
+var SUPER = '^';
+var SUB = '_';
+var LOW_LIMIT = '\\below';
+var ACCENTS = {
+    '\\dot': 775, '\\ddot': 776, '\\dddot': 8411, '\\hat': 770, '\\widehat': 770, '\\check': 780, '\\acute': 769,
+    '\\grave': 768, '\\breve': 774, '\\widetilde': 771, '\\bar': 773, '\\vec': 8407, '\\hvec': 8401,
+};
+var FUNCTIONS = ['\\sin', '\\cos', '\\tan', '\\cot', '\\sec', '\\csc', '\\sinh', '\\cosh', '\\tanh', '\\coth', '\\sech', '\\csch',
+    '\\arcsin', '\\arccos', '\\arctan', '\\log', '\\lim', '\\min', '\\max', '\\ln'];
+var NARY = {
+    '\\sum': 8721, '\\int': 8747, '\\iint': 8748, '\\iiint': 8749, '\\oint': 8750, '\\oiint': 8751, '\\oiiint': 8752,
+    '\\cwint': 8753, '\\coint': 8754, '\\aoint': 8755, '\\prod': 8719, '\\amalg': 8720, '\\bigcap': 8898, '\\bigcup': 8899,
+    '\\bigwedge': 8896, '\\bigvee': 8897, '\\bigodot': 10752, '\\bigotimes': 10754, '\\bigoplus': 10753,
+    '\\biguplus': 10756, '\\bigudot': 10755,
+};
+var DELIMITERS = {
+    '\\lfloor': '\u230A', '\\rfloor': '\u230B', '\\lceil': '\u2308', '\\rceil': '\u2309', '\\langle': '\u2329', '\\rangle': '\u232A',
+    '.': '', '|': '|', '(': '(', ')': ')', '[': '[', ']': ']', '{': '{', '}': '}',
+};
+var FONT_COMMANDS = {
+    '\\mathbb': MathFontType.DoubleStruck, '\\mathfrak': MathFontType.Fraktur, '\\mathtt': MathFontType.Monospace,
+    '\\mathsf': MathFontType.SansSerif, '\\mathcal': MathFontType.Script, '\\mathscr': MathFontType.Script,
+};
+var STYLE_COMMANDS = {
+    '\\mathbit': MathStyleType.BoldItalic, '\\mathbf': MathStyleType.Bold,
+};
+/** Mutable run accumulated while scanning; merged while formatting is unchanged. */
+var RunBuf = /** @class */ (function () {
+    function RunBuf(text, sty, scr, nor) {
+        this.text = text;
+        this.sty = sty;
+        this.scr = scr;
+        this.nor = nor;
+    }
+    return RunBuf;
+}());
+function finalize(seq, target) {
+    seq.forEach(function (i) { return (i instanceof RunBuf ? addRun(i, target) : i.make(target)); });
+}
+function addRun(r, target) {
+    var run = target.functions.add(MathFunctionType.RunElement);
+    run.text = r.text;
+    if (r.sty !== undefined) {
+        run.mathFormat.style = r.sty;
+    }
+    if (r.scr !== undefined) {
+        run.mathFormat.font = r.scr;
+    }
+    if (r.nor) {
+        run.mathFormat.hasNormalText = true;
+    }
+}
+function add(target, type) {
+    return target.functions.add(type);
+}
+function chr(code) {
+    return String.fromCharCode(code);
+}
+function nz(value) {
+    return value === null ? '' : value;
+}
+function hasScriptPair(s) {
+    return (s.startsWith(SUB) && s.includes(SUPER)) || (s.startsWith(SUPER) && s.includes(SUB));
+}
+function trimBackslash(s) {
+    return s.replace(/^\\+|\\+$/g, '');
+}
+/**
+ * Stateful LaTeX scanner/parser. One instance per conversion.
+ *
+ * @private
+ */
+var LatexParser = /** @class */ (function () {
+    function LatexParser() {
+        this.latex = '';
+        this.pos = 0;
+        this.cur = null;
+        this.useExisting = false;
+        this.current = null;
+        this.roots = [];
+        this.nor = false;
+    }
+    /** Appends one `m:oMath` per top-level equation of `latex` to `target`, through its collections and adapter. */
+    LatexParser.prototype.populate = function (latex, target) {
+        var _this = this;
+        this.latex = latex;
+        this.parseEquation();
+        target.suspendMutations(function () { return _this.roots.forEach(function (r) { return finalize(r, target.maths.add()); }); });
+    };
+    // ─── Scanner ──────────────────────────────────────────────────────────────
+    LatexParser.prototype.next = function () {
+        if (this.pos > this.latex.length - 1) {
+            return null;
+        }
+        var el = this.latex[this.pos];
+        this.pos++;
+        this.cur = el;
+        if (el === CONTROL_START) {
+            while (this.pos < this.latex.length && (LETTER.test(this.latex[this.pos]) || this.latex[this.pos] === ';')) {
+                el += this.latex[this.pos];
+                this.pos++;
+            }
+            this.cur = el;
+        }
+        return this.cur;
+    };
+    LatexParser.prototype.ensure = function () {
+        if (this.current === null) {
+            this.current = [];
+            this.roots.push(this.current);
+        }
+        return this.current;
+    };
+    LatexParser.prototype.sub = function (text, target) {
+        if (text === null) {
+            return;
+        }
+        var saved = { latex: this.latex, current: this.current, pos: this.pos, cur: this.cur, use: this.useExisting };
+        this.latex = text;
+        this.current = target;
+        this.pos = 0;
+        this.cur = null;
+        this.useExisting = false;
+        this.parseEquation();
+        this.latex = saved.latex;
+        this.current = saved.current;
+        this.pos = saved.pos;
+        this.cur = saved.cur;
+        this.useExisting = saved.use;
+    };
+    LatexParser.prototype.fill = function (text) {
+        var seq = [];
+        this.sub(text, seq);
+        return seq;
+    };
+    LatexParser.prototype.add = function (make) {
+        this.ensure().push({ make: make });
+    };
+    LatexParser.prototype.setRun = function (text) {
+        if (text.length === 0) {
+            return;
+        }
+        var seq = this.ensure();
+        var t = text.startsWith('\\') ? getLatexSymbol(text) : text;
+        var last = seq[seq.length - 1];
+        if (last instanceof RunBuf && last.sty === this.sty && last.scr === this.scr && last.nor === this.nor) {
+            last.text += t;
+        }
+        else {
+            seq.push(new RunBuf(t, this.sty, this.scr, this.nor));
+        }
+    };
+    LatexParser.prototype.fallbackRun = function (startPos) {
+        this.setRun(this.latex.substring(startPos, this.pos));
+    };
+    // ─── Group helpers ────────────────────────────────────────────────────────
+    LatexParser.prototype.equationString = function () {
+        this.cur = this.next();
+        var result = null;
+        var valid = false;
+        var notInGroup = false;
+        if (this.cur === GROUP_START) {
+            var g = this.group();
+            valid = g.ok;
+            result = g.text;
+        }
+        else {
+            notInGroup = true;
+        }
+        if (notInGroup && this.cur !== null && this.cur.length === 1 && (LETTER_OR_DIGIT.test(this.cur) || this.cur === SPACE)) {
+            result = this.cur;
+        }
+        else if (!valid) {
+            result = null;
+        }
+        return result;
+    };
+    LatexParser.prototype.group = function () {
+        if (this.cur !== GROUP_START) {
+            return { ok: false, text: '' };
+        }
+        var text = '';
+        var depth = 1;
+        while (depth > 0 && this.pos < this.latex.length) {
+            this.cur = this.next();
+            if (this.cur === GROUP_START) {
+                depth++;
+                text += this.cur;
+            }
+            else if (this.cur === GROUP_END) {
+                if (depth !== 1) {
+                    text += this.cur;
+                }
+                depth--;
+            }
+            else if (this.cur === '\\left') {
+                var d = this.delimiter();
+                text += d.text;
+                if (!d.ok) {
+                    return { ok: false, text: text };
+                }
+            }
+            else {
+                text += nz(this.cur);
+            }
+        }
+        return { ok: depth === 0, text: text };
+    };
+    LatexParser.prototype.squareGroup = function () {
+        if (this.cur !== SQUARE_START) {
+            return null;
+        }
+        var text = '';
+        var depth = 1;
+        while (depth > 0 && this.pos < this.latex.length) {
+            this.cur = this.next();
+            if (this.cur === SQUARE_START) {
+                depth++;
+                text += this.cur;
+            }
+            else if (this.cur === SQUARE_END) {
+                if (depth !== 1) {
+                    text += this.cur;
+                }
+                depth--;
+            }
+            else {
+                text += nz(this.cur);
+            }
+        }
+        return text;
+    };
+    // ─── Main loop ────────────────────────────────────────────────────────────
+    LatexParser.prototype.parseEquation = function () {
+        while (this.pos < this.latex.length || this.useExisting) {
+            if (this.useExisting) {
+                this.useExisting = false;
+            }
+            else {
+                this.cur = this.next();
+            }
+            this.dispatch(nz(this.cur), this.cur);
+        }
+    };
+    LatexParser.prototype.dispatch = function (c, raw) {
+        if (raw === null) {
+            this.parseDefault();
+        }
+        else if (ACCENTS[c] !== undefined) {
+            this.parseAccent();
+        }
+        else if (c === '\\overline' || c === '\\underline') {
+            this.parseBar();
+        }
+        else if (c === '\\box') {
+            this.parseBox();
+        }
+        else if (c === '\\fbox' || c === '\\boxed') {
+            this.parseBorderBox();
+        }
+        else if (c === '\\left') {
+            this.parseDelimiter();
+        }
+        else if (c === '\\eqarray') {
+            this.parseEqArray();
+        }
+        else if (c === '\\frac' || c === '\\sfrac' || c === '\\binom') {
+            this.parseFraction();
+        }
+        else if (FUNCTIONS.indexOf(c) !== -1) {
+            this.parseFunction();
+        }
+        else if (c === '\\overbrace' || c === '\\underbrace') {
+            this.parseGroupChar();
+        }
+        else if (c === '\\begin') {
+            this.parseMatrix();
+        }
+        else if (NARY[c] !== undefined) {
+            this.parseNary();
+        }
+        else if (c === '\\sqrt') {
+            this.parseRadical();
+        }
+        else if (c === GROUP_START) {
+            this.parseGroupStart();
+        }
+        else if (STYLE_COMMANDS[c] !== undefined) {
+            this.parseFormat(c, 'sty', STYLE_COMMANDS[c]);
+        }
+        else if (FONT_COMMANDS[c] !== undefined) {
+            this.parseFormat(c, 'scr', FONT_COMMANDS[c]);
+        }
+        else if (c === '\\mathrm') {
+            this.parseFormat(c, 'nor', true);
+        }
+        else {
+            this.parseDefault();
+        }
+    };
+    LatexParser.prototype.parseDefault = function () {
+        var startPos = this.pos;
+        var previous = nz(this.cur);
+        this.cur = this.next();
+        if (this.cur === SUPER || this.cur === SUB) {
+            this.parseScript(previous, startPos - previous.length);
+            return;
+        }
+        if (this.cur !== null) {
+            this.useExisting = true;
+        }
+        if (this.cur === SPACE) {
+            if (previous === '\\') {
+                return;
+            }
+            if (previous.startsWith('\\') && getLatexSymbol(previous) !== previous) {
+                this.useExisting = false;
+            }
+        }
+        this.setRun(previous);
+    };
+    LatexParser.prototype.parseFormat = function (start, kind, value) {
+        var laTexPos = this.pos;
+        this.cur = this.next();
+        if (this.cur !== GROUP_START) {
+            this.setRun(start);
+            this.useExisting = true;
+            return;
+        }
+        var g = this.group();
+        if (!g.ok) {
+            this.fallbackRun(laTexPos - start.length);
+            return;
+        }
+        var old = { sty: this.sty, scr: this.scr, nor: this.nor };
+        if (kind === 'sty' && this.sty === undefined) {
+            this.sty = value;
+        }
+        else if (kind === 'scr' && this.scr === undefined) {
+            this.scr = value;
+        }
+        else if (kind === 'nor') {
+            this.nor = true;
+        }
+        this.sub(g.text, this.current);
+        this.sty = old.sty;
+        this.scr = old.scr;
+        this.nor = old.nor;
+    };
+    /** `\cmd{...}` / `\cmd x` argument shared by accent, bar, box, border box, group char. */
+    LatexParser.prototype.oneArg = function () {
+        var at = this.pos;
+        var start = nz(this.cur);
+        var text = this.equationString();
+        if (text === SPACE && this.cur === SPACE) {
+            text = this.equationString();
+        }
+        return { start: start, at: at, text: text };
+    };
+    LatexParser.prototype.parseAccent = function () {
+        var _a = this.oneArg(), start = _a.start, at = _a.at, text = _a.text;
+        if (text === null && this.cur !== null) {
+            this.fallbackRun(at - start.length);
+            return;
+        }
+        var chrCode = chr(ACCENTS[start]);
+        var body = text;
+        if (body && body.startsWith('\\bar{') && body.endsWith(GROUP_END) && chrCode === chr(773)) {
+            chrCode = chr(831);
+            body = body.substring(5, body.length - 1);
+        }
+        var inner = body ? this.fill(body) : [];
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.Accent);
+            f.accentCharacter = chrCode;
+            finalize(inner, f.equation);
+        });
+    };
+    LatexParser.prototype.parseBar = function () {
+        var _a = this.oneArg(), start = _a.start, at = _a.at, text = _a.text;
+        if (text === null && this.cur !== null) {
+            this.fallbackRun(at - start.length);
+            return;
+        }
+        this.cur = this.next();
+        if (this.cur === SUPER || this.cur === SUB) {
+            this.parseScript("" + start + GROUP_START + nz(text) + GROUP_END, at);
+            return;
+        }
+        if (this.cur !== null) {
+            this.useExisting = true;
+        }
+        var inner = text ? this.fill(text) : [];
+        var pos = start === '\\overline' ? 'top' : 'bot';
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.Bar);
+            f.barTop = pos === 'top';
+            finalize(inner, f.equation);
+        });
+    };
+    LatexParser.prototype.parseBox = function () {
+        var _a = this.oneArg(), start = _a.start, at = _a.at, text = _a.text;
+        if (text === null && this.cur !== null) {
+            this.fallbackRun(at - start.length);
+            return;
+        }
+        var inner = text ? this.fill(text) : [];
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.Box);
+            f.noBreak = false;
+            finalize(inner, f.equation);
+        });
+    };
+    LatexParser.prototype.parseBorderBox = function () {
+        var _a = this.oneArg(), start = _a.start, at = _a.at, text = _a.text;
+        if (text === null && this.cur !== null) {
+            this.fallbackRun(at - start.length);
+            return;
+        }
+        this.cur = this.next();
+        if (this.cur === SUPER || this.cur === SUB) {
+            this.parseScript("" + start + GROUP_START + nz(text) + GROUP_END, at);
+            return;
+        }
+        if (this.cur !== null) {
+            this.useExisting = true;
+        }
+        var inner = text ? this.fill(text) : [];
+        this.add(function (t) { return finalize(inner, add(t, MathFunctionType.BorderBox).equation); });
+    };
+    // ─── Delimiter / eqArray ──────────────────────────────────────────────────
+    LatexParser.prototype.delimiterChar = function (eq) {
+        this.cur = this.next();
+        eq.s += nz(this.cur);
+        if (this.cur === CONTROL_START) {
+            this.cur = this.next();
+            eq.s += nz(this.cur);
+        }
+        var key = nz(this.cur);
+        return Object.prototype.hasOwnProperty.call(DELIMITERS, key) ? DELIMITERS[key] : null;
+    };
+    LatexParser.prototype.delimiter = function () {
+        var r = { ok: false, begin: null, end: null, sep: null, list: [], text: '' };
+        var eq = { s: nz(this.cur) };
+        var depth = 1;
+        r.begin = this.delimiterChar(eq);
+        if (r.begin === null) {
+            r.text = eq.s;
+            return r;
+        }
+        var between = '';
+        while (depth > 0 && this.pos < this.latex.length) {
+            var el = nz(this.next());
+            eq.s += el;
+            if (el === '\\left') {
+                between += el;
+                depth++;
+            }
+            else if (el === '\\right') {
+                if (depth === 1) {
+                    r.list.push(between.trim());
+                    r.end = this.delimiterChar(eq);
+                    if (r.end === null) {
+                        r.text = eq.s;
+                        return r;
+                    }
+                }
+                else {
+                    between += el;
+                }
+                depth--;
+            }
+            else if (el === '\\middle') {
+                if (depth === 1) {
+                    var mid = this.delimiterChar(eq);
+                    if (mid === null) {
+                        r.text = eq.s;
+                        return r;
+                    }
+                    if (r.sep === null) {
+                        r.sep = mid;
+                    }
+                    r.list.push(between.trim());
+                    between = '';
+                }
+                else {
+                    between += el;
+                }
+            }
+            else {
+                between += el;
+            }
+        }
+        r.ok = depth === 0;
+        r.text = eq.s;
+        return r;
+    };
+    LatexParser.prototype.parseDelimiter = function () {
+        var _this = this;
+        var at = this.pos;
+        var start = nz(this.cur);
+        var d = this.delimiter();
+        if (!d.ok) {
+            this.setRun(this.latex.substring(at - start.length, this.pos).replace(/\\ /g, ' '));
+            return;
+        }
+        this.cur = this.next();
+        if (this.cur === SUPER || this.cur === SUB) {
+            this.parseScript(d.text, at);
+            return;
+        }
+        if (this.cur !== null) {
+            this.useExisting = true;
+        }
+        var args = d.list.map(function (e) { return _this.fill(e); });
+        var props = { begChr: nz(d.begin), endChr: nz(d.end) };
+        if (d.sep !== null) {
+            props.sepChr = d.sep;
+        }
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.Delimiter);
+            f.beginCharacter = props.begChr;
+            f.endCharacter = props.endChr;
+            if (props.sepChr !== undefined) {
+                f.separator = props.sepChr;
+            }
+            args.forEach(function (a) { return finalize(a, f.equations.add()); });
+        });
+    };
+    LatexParser.prototype.splitEqArray = function (text) {
+        var list = [];
+        var between = '';
+        if (text !== null) {
+            for (var p = 0; p < text.length; p++) {
+                if (text[p] === '@') {
+                    if (text.substring(p).includes('&') || text.substring(p + 1).includes('@')) {
+                        list.push(between.trim());
+                        between = '';
+                    }
+                }
+                else {
+                    between += text[p];
+                }
+            }
+            list.push(between.trim());
+        }
+        return list;
+    };
+    LatexParser.prototype.parseEqArray = function () {
+        var _this = this;
+        var at = this.pos;
+        var start = nz(this.cur);
+        var text = this.equationString();
+        if (text === null && this.cur !== null) {
+            this.fallbackRun(at - start.length);
+            return;
+        }
+        var parts = this.splitEqArray(text).map(function (e) { return _this.fill(e); });
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.EquationArray);
+            if (parts.length === 0) {
+                f.equations.add();
+            }
+            parts.forEach(function (p) { return finalize(p, f.equations.add()); });
+        });
+    };
+    // ─── Fraction / function / group char / limit ─────────────────────────────
+    LatexParser.prototype.parseFraction = function () {
+        var at = this.pos;
+        var start = nz(this.cur);
+        var num = this.equationString();
+        if (this.cur === SPACE && num === SPACE) {
+            num = this.equationString();
+        }
+        var den = '';
+        if ((this.cur === SPACE && num === SPACE) || (this.cur === null && num === null)) {
+            num = '';
+        }
+        else {
+            den = this.equationString();
+        }
+        if (num === null || den === null) {
+            this.fallbackRun(at - start.length);
+            return;
+        }
+        this.cur = this.next();
+        if (this.cur === SUPER || this.cur === SUB) {
+            this.parseScript("" + start + GROUP_START + num + GROUP_END + GROUP_START + den + GROUP_END, at);
+            return;
+        }
+        if (this.cur !== null) {
+            this.useExisting = true;
+        }
+        if (start === '\\binom') {
+            this.binomial(num, den);
+            return;
+        }
+        var type = start === '\\sfrac' ? MathFractionType.SkewedFractionBar : MathFractionType.NormalFractionBar;
+        this.fraction(type, num, den);
+    };
+    LatexParser.prototype.fraction = function (type, num, den) {
+        var n = num !== '' ? this.fill(num) : [];
+        var d = den !== '' ? this.fill(den) : [];
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.Fraction);
+            f.fractionType = type;
+            finalize(n, f.numerator);
+            finalize(d, f.denominator);
+        });
+    };
+    /** `\binom{n}{k}`: a parenthesis delimiter around a no-bar fraction (Word's binomial coefficient). */
+    LatexParser.prototype.binomial = function (num, den) {
+        var n = num !== '' ? this.fill(num) : [];
+        var d = den !== '' ? this.fill(den) : [];
+        this.add(function (t) {
+            var delimiter = add(t, MathFunctionType.Delimiter);
+            delimiter.beginCharacter = '(';
+            delimiter.endCharacter = ')';
+            var f = add(delimiter.equations.add(), MathFunctionType.Fraction);
+            f.fractionType = MathFractionType.NoFractionBar;
+            finalize(n, f.numerator);
+            finalize(d, f.denominator);
+        });
+    };
+    LatexParser.prototype.parseNoFractionBar = function (numerator, startPos) {
+        if (this.cur !== '\\atop') {
+            return;
+        }
+        var den = this.equationString();
+        if (this.cur === den) {
+            den = null;
+        }
+        if (den === null) {
+            this.fallbackRun(startPos);
+            return;
+        }
+        this.fraction(MathFractionType.NoFractionBar, numerator, den);
+    };
+    LatexParser.prototype.parseFunction = function () {
+        var at = this.pos;
+        var start = nz(this.cur);
+        var body = this.equationString();
+        var scriptKind = null;
+        var scriptText = null;
+        if (this.cur === SUPER || this.cur === SUB || this.cur === LOW_LIMIT) {
+            scriptKind = this.cur === SUPER ? 'sup' : this.cur === SUB ? 'sub' : 'limit';
+            scriptText = this.equationString();
+            if (scriptText === this.cur) {
+                body = this.equationString();
+                if (body !== null && body === this.cur) {
+                    body = '';
+                    this.useExisting = true;
+                }
+            }
+            else {
+                body = this.equationString();
+            }
+        }
+        if (body === null) {
+            this.fallbackRun(at - start.length);
+            return;
+        }
+        var name = trimBackslash(start);
+        var nameSeq = [];
+        var make;
+        if (scriptKind === 'sup' || scriptKind === 'sub') {
+            var base_1 = this.fill(name);
+            this.regular(base_1);
+            var script_1 = scriptText !== null ? this.fill(scriptText) : [];
+            make = function (f) {
+                var sc = add(f.functionName, MathFunctionType.SubSuperscript);
+                sc.scriptType = scriptKind === 'sup' ? MathScriptType.Superscript : MathScriptType.Subscript;
+                finalize(base_1, sc.equation);
+                finalize(script_1, sc.script);
+            };
+        }
+        else if (scriptKind === 'limit') {
+            var base_2 = this.fill(name);
+            this.regular(base_2);
+            var lim_1 = scriptText !== null ? this.fill(scriptText) : [];
+            make = function (f) {
+                var l = add(f.functionName, MathFunctionType.Limit);
+                l.limitType = MathLimitType.LowerLimit;
+                finalize(base_2, l.equation);
+                finalize(lim_1, l.limit);
+            };
+        }
+        else {
+            var saved = this.current;
+            this.current = nameSeq;
+            this.setRun(name);
+            this.current = saved;
+            this.regular(nameSeq);
+            make = function (f) { return finalize(nameSeq, f.functionName); };
+        }
+        this.ensure();
+        var inner = body !== '' ? this.fill(body) : [];
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.Function);
+            make(f);
+            finalize(inner, f.equation);
+        });
+    };
+    LatexParser.prototype.regular = function (seq) {
+        var first = seq[0];
+        if (first instanceof RunBuf) {
+            first.sty = MathStyleType.Regular;
+        }
+    };
+    LatexParser.prototype.parseGroupChar = function () {
+        var _a = this.oneArg(), start = _a.start, at = _a.at, text = _a.text;
+        if (text === null && this.cur !== null) {
+            this.fallbackRun(at - start.length);
+            return;
+        }
+        var inner = text ? this.fill(text) : [];
+        var over = start === '\\overbrace';
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.GroupCharacter);
+            if (over) {
+                f.groupCharacter = chr(9182);
+                f.hasAlignTop = false;
+                f.hasCharacterTop = true;
+            }
+            finalize(inner, f.equation);
+        });
+    };
+    /** Compares the current element without TypeScript narrowing across mutating calls. */
+    LatexParser.prototype.isCurrent = function (value) {
+        return this.cur === value;
+    };
+    LatexParser.prototype.parseLimit = function (equation, startPos) {
+        if (!this.isCurrent(LOW_LIMIT)) {
+            return;
+        }
+        var lim = this.equationString();
+        if (lim === SPACE && this.isCurrent(SPACE)) {
+            lim = this.equationString();
+        }
+        if (lim === null) {
+            this.fallbackRun(startPos);
+            return;
+        }
+        var base = this.fill(equation);
+        var limit = lim !== SPACE ? this.fill(lim) : [];
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.Limit);
+            f.limitType = MathLimitType.LowerLimit;
+            finalize(base, f.equation);
+            finalize(limit, f.limit);
+        });
+    };
+    // ─── Matrix ───────────────────────────────────────────────────────────────
+    LatexParser.prototype.parseMatrix = function () {
+        var _this = this;
+        var at = this.pos;
+        var start = nz(this.cur);
+        this.cur = this.next();
+        if (this.cur !== GROUP_START) {
+            this.setRun(start);
+            this.useExisting = true;
+            return;
+        }
+        var g = this.group();
+        var m = g.ok && g.text === 'matrix' ? this.matrixRows() : null;
+        if (m === null) {
+            this.fallbackRun(at - start.length);
+            return;
+        }
+        this.cur = this.next();
+        if (this.cur === SUPER || this.cur === SUB) {
+            this.parseScript(this.latex.substring(at - start.length, this.pos - 1), at);
+            return;
+        }
+        if (this.cur !== null) {
+            this.useExisting = true;
+        }
+        var rows = m.rows.map(function (cols) {
+            var cells = [];
+            for (var i = 0; i < m.maxCols; i++) {
+                cells.push(i < cols.length ? _this.fill(cols[i]) : []);
+            }
+            return cells;
+        });
+        var columnCount = m.maxCols;
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.Matrix);
+            for (var i = 0; i < columnCount; i++) {
+                f.columns.add().horizontalAlignment = MathHorizontalAlignment.Center;
+            }
+            rows.forEach(function (r) {
+                var row = f.rows.add();
+                r.forEach(function (c, i) { return finalize(c, row.arguments.getItem(i)); });
+            });
+        });
+    };
+    LatexParser.prototype.matrixRows = function () {
+        var rows = [];
+        var maxCols = 0;
+        var depth = 1;
+        var between = '';
+        var cols = [];
+        var endRow = function () {
+            cols.push(between);
+            between = '';
+            maxCols = Math.max(maxCols, cols.length);
+            rows.push(cols);
+            cols = [];
+        };
+        while (depth > 0 && this.pos < this.latex.length) {
+            this.cur = this.next();
+            while (this.cur === SPACE) {
+                this.cur = this.next();
+            }
+            if (this.cur === CONTROL_START) {
+                this.cur = this.next();
+                if (this.cur === CONTROL_START) {
+                    this.cur += CONTROL_START;
+                }
+            }
+            var c = this.cur;
+            if (c === '\\begin') {
+                between += c;
+                var startEl = nz((this.cur = this.next()));
+                var g = this.group();
+                if (g.ok && g.text === 'matrix') {
+                    depth++;
+                }
+                between += startEl + g.text + nz(this.cur);
+            }
+            else if (c === '\\end') {
+                var startEl = c + nz((this.cur = this.next()));
+                var g = this.group();
+                if (g.ok && g.text === 'matrix' && depth === 1) {
+                    if (cols.length !== 0 || between !== '') {
+                        endRow();
+                    }
+                    depth--;
+                }
+                else if (depth === 1) {
+                    return null;
+                }
+                else {
+                    between += startEl + g.text + nz(this.cur);
+                }
+            }
+            else if (c === MATRIX_COL_END) {
+                if (depth === 1) {
+                    cols.push(between);
+                    between = '';
+                }
+                else {
+                    between += c;
+                }
+            }
+            else if (c === MATRIX_ROW_END) {
+                if (depth === 1) {
+                    endRow();
+                }
+                else {
+                    between += c;
+                }
+            }
+            else {
+                between += nz(c);
+            }
+        }
+        return depth === 0 ? { rows: rows, maxCols: maxCols } : null;
+    };
+    // ─── N-ary ────────────────────────────────────────────────────────────────
+    LatexParser.prototype.parseNary = function () {
+        var at = this.pos;
+        var start = nz(this.cur);
+        var eq = this.equationString();
+        var subText = null;
+        var supText = null;
+        for (var i = 0; i < 2; i++) {
+            if (eq === SPACE && this.cur === SPACE) {
+                eq = this.equationString();
+            }
+            else {
+                break;
+            }
+        }
+        if (this.cur === SUB) {
+            subText = this.equationString();
+        }
+        else if (this.cur === SUPER) {
+            supText = this.equationString();
+        }
+        if (subText !== null) {
+            eq = this.equationString();
+            if (this.cur === SUPER) {
+                supText = this.equationString();
+            }
+        }
+        else if (supText !== null) {
+            eq = this.equationString();
+            if (this.cur === SUB) {
+                subText = this.equationString();
+            }
+        }
+        if (subText !== null && supText !== null) {
+            eq = this.equationString();
+        }
+        if (eq !== null) {
+            eq = this.naryTail(eq);
+        }
+        if (eq === null && this.cur !== null) {
+            this.fallbackRun(at - start.length);
+            return;
+        }
+        var sub = subText !== null ? this.fill(subText) : [];
+        var sup = supText !== null ? this.fill(supText) : [];
+        var base = eq !== SPACE ? this.fill(eq) : [];
+        var character = chr(NARY[start]);
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.NArray);
+            f.nArrayCharacter = character;
+            if (subText === null) {
+                f.hideLowerLimit = true;
+            }
+            if (supText === null) {
+                f.hideUpperLimit = true;
+            }
+            if (subText === null && supText === null) {
+                f.subSuperscriptLimit = false;
+            }
+            finalize(sub, f.subscript);
+            finalize(sup, f.superscript);
+            finalize(base, f.equation);
+        });
+    };
+    /** Greedily absorbs trailing script groups into the N-ary operand (mirrors compression). */
+    LatexParser.prototype.naryTail = function (first) {
+        var eq = first;
+        var isLeft = false;
+        if (this.cur === GROUP_END && hasScriptPair(eq)) {
+            eq = GROUP_START + eq + GROUP_END;
+            isLeft = true;
+        }
+        var part = this.equationString();
+        var check = true;
+        if (part !== null && isLeft) {
+            eq += GROUP_START + part + GROUP_END;
+        }
+        else if (part === null && (this.cur === SUPER || this.cur === SUB)) {
+            eq += this.cur + GROUP_START + nz(this.equationString()) + GROUP_END;
+        }
+        else if (part !== null && hasScriptPair(part)) {
+            eq += GROUP_START + part + GROUP_END;
+        }
+        else {
+            this.useExisting = true;
+            check = false;
+            if (part !== null && this.cur !== part) {
+                this.cur = part;
+            }
+        }
+        while (check) {
+            part = this.equationString();
+            if (part === null && (this.cur === SUPER || this.cur === SUB)) {
+                eq += this.cur + GROUP_START + nz(this.equationString()) + GROUP_END;
+            }
+            else if (part !== null && hasScriptPair(part)) {
+                eq += GROUP_START + part + GROUP_END;
+            }
+            else {
+                this.useExisting = true;
+                check = false;
+            }
+        }
+        return eq;
+    };
+    // ─── Radical ──────────────────────────────────────────────────────────────
+    LatexParser.prototype.parseRadical = function () {
+        var at = this.pos;
+        var start = nz(this.cur);
+        this.cur = this.next();
+        if (this.cur === SPACE) {
+            this.cur = this.next();
+        }
+        var degree = this.squareGroup();
+        if (degree !== null) {
+            this.cur = this.next();
+        }
+        var equation = null;
+        var valid = false;
+        var notInGroup = false;
+        if (this.cur === GROUP_START) {
+            var g = this.group();
+            valid = g.ok;
+            equation = g.text;
+        }
+        else {
+            notInGroup = true;
+        }
+        if (notInGroup && this.cur !== null && this.cur.length === 1 && (LETTER_OR_DIGIT.test(this.cur) || this.cur === SPACE)) {
+            equation = this.cur;
+        }
+        if (!(notInGroup || valid)) {
+            this.fallbackRun(at - start.length);
+            return;
+        }
+        this.cur = this.next();
+        if (this.cur === SUPER || this.cur === SUB) {
+            this.parseScript(this.latex.substring(at - start.length, this.pos - 1), at);
+            return;
+        }
+        if (this.cur !== null) {
+            this.useExisting = true;
+        }
+        var hide = !(degree !== null && equation !== null);
+        var deg = !hide ? this.fill(degree) : [];
+        var body = [];
+        if (equation !== null && equation !== SPACE) {
+            body = this.fill(equation);
+        }
+        else if (equation === null) {
+            this.useExisting = true;
+            if (degree !== null) {
+                this.setRun("[" + degree + "]");
+            }
+        }
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.Radical);
+            if (hide) {
+                f.hideDegree = true;
+            }
+            finalize(deg, f.degree);
+            finalize(body, f.equation);
+        });
+    };
+    // ─── Groups and scripts ───────────────────────────────────────────────────
+    LatexParser.prototype.parseGroupStart = function () {
+        var startPos = this.pos - GROUP_START.length;
+        var g = this.group();
+        if (!g.ok) {
+            this.setRun(GROUP_START);
+            this.sub(g.text, this.current);
+            return;
+        }
+        if (hasScriptPair(g.text)) {
+            this.parseLeftScript(g.text, startPos);
+            return;
+        }
+        this.cur = this.next();
+        if (this.cur === SUPER || this.cur === SUB) {
+            this.parseScript(g.text, startPos);
+        }
+        else if (this.cur === LOW_LIMIT) {
+            this.parseLimit(g.text, startPos);
+        }
+        else if (this.cur === '\\atop') {
+            this.parseNoFractionBar(g.text, startPos);
+        }
+        else {
+            this.sub(g.text, this.current);
+            this.useExisting = true;
+        }
+    };
+    LatexParser.prototype.parseScript = function (equation, startPos) {
+        if (!(this.cur === SUPER || this.cur === SUB)) {
+            return;
+        }
+        var isSup = this.cur === SUPER;
+        var script = this.equationString();
+        if (script === null && this.cur !== null) {
+            this.fallbackRun(startPos);
+            return;
+        }
+        if (this.cur !== null) {
+            this.cur = this.next();
+            if ((isSup && this.cur === SUB) || (!isSup && this.cur === SUPER)) {
+                this.parseRightScript(equation, script, isSup, startPos);
+                return;
+            }
+            this.useExisting = true;
+        }
+        this.ensure();
+        var base = this.fill(equation);
+        var scriptSeq = script ? this.fill(script) : [];
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.SubSuperscript);
+            f.scriptType = isSup ? MathScriptType.Superscript : MathScriptType.Subscript;
+            finalize(base, f.equation);
+            finalize(scriptSeq, f.script);
+        });
+    };
+    LatexParser.prototype.parseRightScript = function (equation, first, isSup, startPos) {
+        var second = this.equationString();
+        if (second === null && this.cur !== null) {
+            this.fallbackRun(startPos);
+            return;
+        }
+        var keep = function (s) { return (s !== null && s !== SPACE ? s : null); };
+        var base = this.fill(keep(equation));
+        var sup = this.fill(keep(isSup ? first : second));
+        var sub = this.fill(keep(isSup ? second : first));
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.RightSubSuperscript);
+            finalize(base, f.equation);
+            finalize(sub, f.subscript);
+            finalize(sup, f.superscript);
+        });
+    };
+    LatexParser.prototype.parseLeftScript = function (group, startPos) {
+        var sub = null;
+        var sup = null;
+        var saved = { latex: this.latex, pos: this.pos, cur: this.cur };
+        this.latex = group;
+        this.pos = 1;
+        if (group.startsWith(SUB)) {
+            sub = this.equationString();
+        }
+        else {
+            sup = this.equationString();
+        }
+        if (sub !== null) {
+            this.cur = this.next();
+            if (this.cur === SUPER) {
+                sup = this.equationString();
+            }
+        }
+        else if (sup !== null) {
+            this.cur = this.next();
+            if (this.cur === SUB) {
+                sub = this.equationString();
+            }
+        }
+        this.latex = saved.latex;
+        this.pos = saved.pos;
+        this.cur = saved.cur;
+        var eq = null;
+        if (sub !== null && sup !== null) {
+            eq = this.equationString();
+        }
+        if (eq === null && this.cur !== null) {
+            this.fallbackRun(startPos);
+            return;
+        }
+        var keep = function (s) { return (s !== SPACE ? s : null); };
+        var subSeq = this.fill(keep(sub));
+        var supSeq = this.fill(keep(sup));
+        var base = eq !== null && eq !== SPACE ? this.fill(eq) : [];
+        this.add(function (t) {
+            var f = add(t, MathFunctionType.LeftSubSuperscript);
+            finalize(subSeq, f.subscript);
+            finalize(supSeq, f.superscript);
+            finalize(base, f.equation);
+        });
+    };
+    return LatexParser;
+}());
+export { LatexParser };
+/**
+ * Convert a LaTeX equation string to an Office Math paragraph.
+ *
+ * Mirrors Microsoft Word's "linear LaTeX" behavior as implemented by Syncfusion
+ * `LaTeXConverter.ParseMathPara`: unsupported or malformed constructs degrade to
+ * plain text runs instead of throwing.
+ *
+ * @param latex - LaTeX source (for example `\frac{a}{b}` or `\sqrt[3]{x}`).
+ * @returns An {@link OfficeMathParagraph} holding one {@link OfficeMath} per top-level equation.
+ * @public
+ */
+export function parseLatexToMath(latex, adapter) {
+    var paragraph = new OfficeMathParagraph(adapter);
+    parseLatexIntoMathParagraph(latex, paragraph);
+    return paragraph;
+}
+/**
+ * Appends the equations parsed from a LaTeX string to an existing Math paragraph.
+ * Runs are created through the target's document adapter when it has one.
+ *
+ * @param latex - LaTeX source.
+ * @param target - The paragraph to populate; it keeps its identity, owner, adapter and listener.
+ * @public
+ */
+export function parseLatexIntoMathParagraph(latex, target) {
+    new LatexParser().populate(latex, target);
+}