@syncfusion/ej2-office-common 35.1.37 → 35.1.42

package/dist/global/index.d.ts

@@ -1,6 +1,6 @@
 /*!
 *  filename: index.d.ts
-*  version : 35.1.37
+*  version : 35.1.42
 *  Copyright Syncfusion Inc. 2001 - 2025. All rights reserved.
 *  Use of this code is subject to the terms of our license.
 *  A copy of the current license can be obtained at any time by e-mailing

package/office-common.js

@@ -0,0 +1,4 @@
+/**
+ * office-common
+ */
+export * from './src/office-common/index';

package/package.json

@@ -1,18 +1,22 @@
 {
   "name": "@syncfusion/ej2-office-common",
-  "version": "35.1.37",
-  "description": "Shared OOXML codecs and domain models for EJ2 Office JavaScript libraries (ink, diagrams, mathml, smart-art, encryption).",
+  "version": "35.1.42",
+  "description": "The EJ2 Office Common library provides shared OOXML codecs and domain models used across EJ2 Office JavaScript libraries.",
   "author": "Syncfusion Inc.",
   "license": "SEE LICENSE IN license",
-  "devDependencies": {},
-  "main": "./dist/ej2-office-common.umd.min.js",
+  "main": "./src/index.js",
   "module": "./index.js",
-  "es2015": "./dist/es6/ej2-office-common.es5.js",
-  "typings": "index.d.ts",
+  "es2015": "./src/index.js",
+  "typings": "src/index.d.ts",
+  "devDependencies": {},
   "keywords": [
     "ej2",
     "syncfusion",
-    "office-common"
+    "ej2-office-common",
+    "javascript",
+    "typescript",
+    "ooxml",
+    "document-processing"
   ],
   "repository": {
     "type": "git",

package/src/index.d.ts

@@ -1,21 +1,7 @@
 /**
- * Shared OOXML codecs and domain models for EJ2 Office JavaScript libraries.
- * Consume from git / local workspace; not published to npm.
- *
- * Feature modules are added incrementally (ink, mathml, encryption, …). Root
- * entry re-exports the public surface as features land, including the OFFCRYPTO
- * Agile decrypt surface from ./encryption.
- *
  * @packageDocumentation
- */
-/**
- * Package identity string for consumers proving resolution (TASK-9001).
+ * @syncfusion/ej2-office-common - shared OOXML codecs and domain models.
  *
- * @public
+ * Package root beside `src/office-common/`, mirroring `@syncfusion/ej2-docx`.
  */
-export declare const OFFICE_COMMON_PACKAGE_NAME = "@syncfusion/ej2-office-common";
-export { INKML_NAMESPACE, INK_CONTENT_TYPE, INK_SOURCE_RELATIONSHIP_TYPE, WORDML_2010_NAMESPACE, WORDPROCESSING_INK_URI, INK_EFFECT_COLORS, inkEffectColor, computeInkBounds, decodeTrace, encodeTrace, scalePointsStretch, scalePointsUniform, addInkTrace, cloneInk, createInk, inkPathPoints, isOfficeInk, DIAG_INVALID_INK_TRACE, getLastInkParseDiagnostics, parseInkXml, serializeInkXml, EMUS_PER_POINT, formatUnitValue, pointsToUnit, unitValueToPoints, } from './features/ink/index';
-export { InkBounds, InkExtent, InkPoint, TraceDecodeResult, TraceDecodeStats, InkBrush, InkChannel, InkContext, InkEffectType, InkTrace, OfficeInk, InkParseDiagnostic, InkParseDiagnostics, } from './features/ink/index';
-export { MATH_NAMESPACE, MATH_PREFIX_FALLBACKS, WML_TRANSITIONAL_NAMESPACE, XML_NAMESPACE, MATH_BREAKBIN_VALUES, MATH_BREAKBINSUB_VALUES, MATH_FTYPE_VALUES, MATH_JC_VALUES, MATH_LIMLOC_VALUES, MATH_SCRIPT_VALUES, MATH_SHP_VALUES, MATH_SPACING_RULE_VALUES, MATH_STYLE_VALUES, MATH_TOPBOT_VALUES, emitOnOff, isInteger2, isInteger255, isSpacingRule, isUnSignedInteger, parseMathBreakBin, parseMathBreakBinSub, parseMathFractionType, parseMathJc, parseMathLimLoc, parseMathScript, parseMathShape, parseMathStyle, parseMathTopBot, parseOnOff, MathArgument, MathElement, MathText, UnknownMathElement, mathArg, MathOMath, MathParagraph, MathAccent, MathBar, MathBorderBox, MathBox, MathDelimiter, MathEquationArray, MathFraction, MathFunction, MathGroupCharacter, MathLimitLower, MathLimitUpper, MathMatrix, MathMatrixRow, MathNaryOperator, MathPhantom, MathPreSubSuperscript, MathRadical, MathRun, MathSubscript, MathSubSuperscript, MathSuperscript, parseMathElement, parseMathElements, mathElementToOpenXml, cloneMathElement, mathEqual, attrValue, attrValueNs, childElements, createElement, createText, textContent, } from './features/mathml/index';
-export { MathBreakBin, MathBreakBinSub, MathFractionType, MathJc, MathLimLoc, MathScript, MathShape, MathSpacingRule, MathStyle, MathTopBot, MathArgProperties, MathElementType, MathParaProperties, MathAccentProperties, MathBarProperties, MathBorderBoxProperties, MathBoxProperties, MathCtrlPr, MathDelimiterProperties, MathEquationArrayProperties, MathFractionProperties, MathFunctionProperties, MathGroupCharacterProperties, MathLimitProperties, MathMatrixProperties, MathNaryProperties, MathPhantomProperties, MathRadicalProperties, MathRunProperties, MathScriptControlProperties, MathParseDiagnostic, ParseMathOptions, SerializeMathOptions, NamespaceDeclaration, OpenXmlAttribute, OpenXmlChild, OpenXmlElement, OpenXmlText, } from './features/mathml/index';
-export { decryptOffCryptoPackage, isOffCryptoPackage, DEFAULT_DECRYPT_SECURITY_LIMITS, EncryptedPackageError, InvalidPasswordError, PackageLimitError, resolveDecryptLimits, UnsupportedEncryptionError, DecryptSecurityLimits, SecurityErrorOptions, AGILE_ENCRYPTION_NS, AGILE_RESERVED, AGILE_VERSION_MAJOR, AGILE_VERSION_MINOR, BLOCK_KEY_ENCRYPTOR_KEY, BLOCK_KEY_HMAC_KEY, BLOCK_KEY_HMAC_VALUE, BLOCK_KEY_VERIFIER_HASH, BLOCK_KEY_VERIFIER_INPUT, ENCRYPTED_PACKAGE_SEGMENT_SIZE, PASSWORD_KEY_ENCRYPTOR_NS, PASSWORD_KEY_ENCRYPTOR_URI, STREAM_ENCRYPTED_PACKAGE, STREAM_ENCRYPTION_INFO, aesCbcDecrypt, aesCbcEncrypt, concatBytes, deriveAgileIv, deriveAgileKey, encodePasswordUtf16Le, hashBytes, hashDigestLength, hmacBytes, timingSafeEqual, AgileHashName, } from './encryption/index';
+export * from './office-common/index';

package/src/index.js

@@ -1,22 +1,7 @@
 /**
- * Shared OOXML codecs and domain models for EJ2 Office JavaScript libraries.
- * Consume from git / local workspace; not published to npm.
- *
- * Feature modules are added incrementally (ink, mathml, encryption, …). Root
- * entry re-exports the public surface as features land, including the OFFCRYPTO
- * Agile decrypt surface from ./encryption.
- *
  * @packageDocumentation
- */
-/**
- * Package identity string for consumers proving resolution (TASK-9001).
+ * @syncfusion/ej2-office-common - shared OOXML codecs and domain models.
  *
- * @public
+ * Package root beside `src/office-common/`, mirroring `@syncfusion/ej2-docx`.
  */
-export var OFFICE_COMMON_PACKAGE_NAME = '@syncfusion/ej2-office-common';
-export { INKML_NAMESPACE, INK_CONTENT_TYPE, INK_SOURCE_RELATIONSHIP_TYPE, WORDML_2010_NAMESPACE, WORDPROCESSING_INK_URI, INK_EFFECT_COLORS, inkEffectColor, computeInkBounds, decodeTrace, encodeTrace, scalePointsStretch, scalePointsUniform, addInkTrace, cloneInk, createInk, inkPathPoints, isOfficeInk, DIAG_INVALID_INK_TRACE, getLastInkParseDiagnostics, parseInkXml, serializeInkXml, EMUS_PER_POINT, formatUnitValue, pointsToUnit, unitValueToPoints, } from './features/ink/index';
-// ─── mathml (OMML) public surface — @syncfusion/ej2-office-common/mathml ──────────────────
-export { MATH_NAMESPACE, MATH_PREFIX_FALLBACKS, WML_TRANSITIONAL_NAMESPACE, XML_NAMESPACE, MATH_BREAKBIN_VALUES, MATH_BREAKBINSUB_VALUES, MATH_FTYPE_VALUES, MATH_JC_VALUES, MATH_LIMLOC_VALUES, MATH_SCRIPT_VALUES, MATH_SHP_VALUES, MATH_SPACING_RULE_VALUES, MATH_STYLE_VALUES, MATH_TOPBOT_VALUES, emitOnOff, isInteger2, isInteger255, isSpacingRule, isUnSignedInteger, parseMathBreakBin, parseMathBreakBinSub, parseMathFractionType, parseMathJc, parseMathLimLoc, parseMathScript, parseMathShape, parseMathStyle, parseMathTopBot, parseOnOff, MathArgument, MathElement, MathText, UnknownMathElement, mathArg, MathOMath, MathParagraph, MathAccent, MathBar, MathBorderBox, MathBox, MathDelimiter, MathEquationArray, MathFraction, MathFunction, MathGroupCharacter, MathLimitLower, MathLimitUpper, MathMatrix, MathMatrixRow, MathNaryOperator, MathPhantom, MathPreSubSuperscript, MathRadical, MathRun, MathSubscript, MathSubSuperscript, MathSuperscript, parseMathElement, parseMathElements, mathElementToOpenXml, cloneMathElement, mathEqual, attrValue, attrValueNs, childElements, createElement, createText, textContent, } from './features/mathml/index';
-export { decryptOffCryptoPackage, isOffCryptoPackage, DEFAULT_DECRYPT_SECURITY_LIMITS, EncryptedPackageError, InvalidPasswordError, PackageLimitError, resolveDecryptLimits, UnsupportedEncryptionError, 
-// fixture / advanced crypto surface
-AGILE_ENCRYPTION_NS, AGILE_RESERVED, AGILE_VERSION_MAJOR, AGILE_VERSION_MINOR, BLOCK_KEY_ENCRYPTOR_KEY, BLOCK_KEY_HMAC_KEY, BLOCK_KEY_HMAC_VALUE, BLOCK_KEY_VERIFIER_HASH, BLOCK_KEY_VERIFIER_INPUT, ENCRYPTED_PACKAGE_SEGMENT_SIZE, PASSWORD_KEY_ENCRYPTOR_NS, PASSWORD_KEY_ENCRYPTOR_URI, STREAM_ENCRYPTED_PACKAGE, STREAM_ENCRYPTION_INFO, aesCbcDecrypt, aesCbcEncrypt, concatBytes, deriveAgileIv, deriveAgileKey, encodePasswordUtf16Le, hashBytes, hashDigestLength, hmacBytes, timingSafeEqual, } from './encryption/index';
+export * from './office-common/index';

package/src/office-common/features/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Public feature modules for EJ2 Office common codecs (MathML only for now).
+ *
+ * @packageDocumentation
+ */
+export * from './mathml/index';

package/src/office-common/features/index.js

@@ -0,0 +1,6 @@
+/**
+ * Public feature modules for EJ2 Office common codecs (MathML only for now).
+ *
+ * @packageDocumentation
+ */
+export * from './mathml/index';

package/src/office-common/features/mathml/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Optional Office Math Markup Language (OMML) feature module
+ * (`@syncfusion/ej2-office-common/mathml`).
+ *
+ * Provides the canonical Office Math authoring model (`OfficeMathParagraph`, `OfficeMath`,
+ * `OfficeMath*` functions), the tolerant OMML parser, clone/equality helpers, and cited constants. "MathML" here
+ * means OMML (`m:*` per ECMA-376-1 §22.1 / Part 4 Annex A.8.1) — not W3C MathML.
+ *
+ * Docx integration (`MathInline`, paragraph accessors, save hook) is TASK-9011.
+ *
+ * @packageDocumentation
+ */
+export { MATH_NAMESPACE, MATH_PREFIX_FALLBACKS, WML_TRANSITIONAL_NAMESPACE, XML_NAMESPACE } from './constants';
+export * from './office-math/index';
+export { MathParseDiagnostic, ParseMathOptions } from './parse/parse-options';
+export { parseOfficeMathParagraph } from './parse/office-math-parser';
+export { parseLatexToMath, parseLatexIntoMathParagraph } from './latex/latex-parser';
+export { mathToLatex } from './latex/latex-generator';
+export { getLatexSymbol, getSymbolLatex } from './latex/latex-symbols';
+export { serializeOfficeMathParagraph, SerializeOfficeMathOptions } from './serialize/office-math-serializer';
+export { MathmlConstraintKind } from './errors';
+export { MathmlReadOnlyError, MathmlValidationError } from './errors';
+export { NamespaceDeclaration, OpenXmlAttribute, OpenXmlChild, OpenXmlElement, OpenXmlText } from './openxml';
+export { attrValue, attrValueNs, childElements, createElement, createText, textContent } from './openxml';
+export { MathSettings, parseMathSettings, mathSettingsToOpenXml } from './math-settings';

package/src/office-common/features/mathml/index.js

@@ -0,0 +1,22 @@
+/**
+ * Optional Office Math Markup Language (OMML) feature module
+ * (`@syncfusion/ej2-office-common/mathml`).
+ *
+ * Provides the canonical Office Math authoring model (`OfficeMathParagraph`, `OfficeMath`,
+ * `OfficeMath*` functions), the tolerant OMML parser, clone/equality helpers, and cited constants. "MathML" here
+ * means OMML (`m:*` per ECMA-376-1 §22.1 / Part 4 Annex A.8.1) — not W3C MathML.
+ *
+ * Docx integration (`MathInline`, paragraph accessors, save hook) is TASK-9011.
+ *
+ * @packageDocumentation
+ */
+export { MATH_NAMESPACE, MATH_PREFIX_FALLBACKS, WML_TRANSITIONAL_NAMESPACE, XML_NAMESPACE } from './constants';
+export * from './office-math/index';
+export { parseOfficeMathParagraph } from './parse/office-math-parser';
+export { parseLatexToMath, parseLatexIntoMathParagraph } from './latex/latex-parser';
+export { mathToLatex } from './latex/latex-generator';
+export { getLatexSymbol, getSymbolLatex } from './latex/latex-symbols';
+export { serializeOfficeMathParagraph } from './serialize/office-math-serializer';
+export { MathmlReadOnlyError, MathmlValidationError } from './errors';
+export { attrValue, attrValueNs, childElements, createElement, createText, textContent } from './openxml';
+export { parseMathSettings, mathSettingsToOpenXml } from './math-settings';

package/src/office-common/features/mathml/latex/latex-generator.d.ts

@@ -0,0 +1,8 @@
+import { OfficeMath } from '../office-math/office-math';
+import { OfficeMathParagraph } from '../office-math/math-paragraph';
+/**
+ * Converts a math paragraph (or a single `m:oMath`) to a LaTeX string.
+ *
+ * @public
+ */
+export declare function mathToLatex(math: OfficeMathParagraph | OfficeMath): string;

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

@@ -0,0 +1,357 @@
+var __values = (this && this.__values) || function (o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+};
+var _a;
+/**
+ * Office Math model → LaTeX generator.
+ *
+ * Port of compression `LaTeXConverter.GetLaTeX` (Math to LaTeX region). Output
+ * syntax matches what `parseLatexToMath` accepts. Unsupported element kinds are
+ * skipped, as in the .NET implementation.
+ *
+ * @packageDocumentation
+ */
+import { MathFontType, MathFractionType, MathFunctionType, MathScriptType, MathStyleType } from '../office-math/enums';
+import { K } from '../office-math/keys';
+import { OfficeMathParagraph } from '../office-math/math-paragraph';
+import { getSymbolLatex } from './latex-symbols';
+// Built at runtime: `u`-flag literals are rejected by ES5 compile targets.
+var LETTER = new RegExp('^\\p{L}$', 'u');
+function orDefault(value, fallback) {
+    return value !== undefined && value !== null ? value : fallback;
+}
+var ACCENT_COMMANDS = {
+    775: '\\dot', 776: '\\ddot', 8411: '\\dddot', 770: '\\widehat', 780: '\\check', 768: '\\grave', 774: '\\breve',
+    771: '\\widetilde', 769: '\\acute', 773: '\\bar', 831: '\\bar{\\bar', 8407: '\\vec', 8401: '\\hvec',
+};
+var NARY_COMMANDS = {
+    8721: '\\sum', 8747: '\\int', 8748: '\\iint', 8749: '\\iiint', 8750: '\\oint', 8751: '\\oiint', 8752: '\\oiiint',
+    8753: '\\cwint', 8754: '\\coint', 8755: '\\aoint', 8719: '\\prod', 8720: '\\amalg', 8898: '\\bigcap', 8899: '\\bigcup',
+    8896: '\\bigwedge', 8897: '\\bigvee', 10752: '\\bigodot', 10754: '\\bigotimes', 10753: '\\bigoplus', 10756: '\\biguplus',
+    10755: '\\bigudot',
+};
+var DELIMITER_COMMANDS = {
+    40: '(', 91: '[', 123: '{', 41: ')', 93: ']', 125: '}', 124: '|', 9001: '\\langle', 8968: '\\lceil', 8970: '\\lfloor',
+    9002: '\\rangle', 8969: '\\rceil', 8971: '\\rfloor',
+};
+var FONT_COMMANDS = (_a = {},
+    _a[MathFontType.DoubleStruck] = '\\mathbb',
+    _a[MathFontType.Fraktur] = '\\mathfrak',
+    _a[MathFontType.Monospace] = '\\mathtt',
+    _a[MathFontType.SansSerif] = '\\mathsf',
+    _a[MathFontType.Script] = '\\mathscr',
+    _a);
+var LatexGenerator = /** @class */ (function () {
+    function LatexGenerator() {
+        this.out = '';
+        this.inFunctionName = false;
+    }
+    LatexGenerator.prototype.generate = function (equations) {
+        var e_1, _a;
+        try {
+            for (var equations_1 = __values(equations), equations_1_1 = equations_1.next(); !equations_1_1.done; equations_1_1 = equations_1.next()) {
+                var eq = equations_1_1.value;
+                this.arg(eq);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (equations_1_1 && !equations_1_1.done && (_a = equations_1.return)) _a.call(equations_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return this.out;
+    };
+    LatexGenerator.prototype.group = function (arg) {
+        this.out += '{';
+        this.arg(arg);
+        this.out += '}';
+    };
+    LatexGenerator.prototype.arg = function (arg) {
+        if (arg) {
+            for (var i = 0; i < arg.functions.count; i++) {
+                this.element(arg.functions.getItem(i));
+            }
+        }
+    };
+    LatexGenerator.prototype.element = function (el) {
+        switch (el.type) {
+            case MathFunctionType.RunElement:
+                this.run(el);
+                break;
+            case MathFunctionType.Accent:
+                this.accent(el);
+                break;
+            case MathFunctionType.Bar:
+                this.out += el.barTop ? '\\overline' : '\\underline';
+                this.group(el.equation);
+                break;
+            case MathFunctionType.Box:
+                this.out += '\\box';
+                this.group(el.equation);
+                break;
+            case MathFunctionType.BorderBox:
+                this.out += '\\fbox';
+                this.group(el.equation);
+                break;
+            case MathFunctionType.Fraction:
+                this.fraction(el);
+                break;
+            case MathFunctionType.Function:
+                this.func(el);
+                break;
+            case MathFunctionType.Delimiter:
+                this.delimiter(el);
+                break;
+            case MathFunctionType.GroupCharacter:
+                this.groupChar(el);
+                break;
+            case MathFunctionType.Limit:
+                this.limit(el);
+                break;
+            case MathFunctionType.Matrix:
+                this.matrix(el);
+                break;
+            case MathFunctionType.NArray:
+                this.nary(el);
+                break;
+            case MathFunctionType.Radical:
+                this.radical(el);
+                break;
+            case MathFunctionType.SubSuperscript: {
+                var s = el;
+                this.script(s.equation, s.scriptType === MathScriptType.Subscript ? '_' : '^', s.script);
+                break;
+            }
+            case MathFunctionType.LeftSubSuperscript: {
+                var s = el;
+                this.out += '{_';
+                this.group(s.subscript);
+                this.out += '^';
+                this.group(s.superscript);
+                this.out += '}';
+                this.group(s.equation);
+                break;
+            }
+            case MathFunctionType.RightSubSuperscript: {
+                var s = el;
+                this.group(s.equation);
+                this.out += '_';
+                this.group(s.subscript);
+                this.out += '^';
+                this.group(s.superscript);
+                break;
+            }
+            case MathFunctionType.EquationArray: {
+                var e = el;
+                this.out += '\\eqarray{';
+                for (var i = 0; i < e.equations.count; i++) {
+                    if (i > 0) {
+                        this.out += '@';
+                    }
+                    this.arg(e.equations.getItem(i));
+                }
+                this.out += '}';
+                break;
+            }
+            default: break;
+        }
+    };
+    LatexGenerator.prototype.accent = function (el) {
+        var code = el.accentCharacter.charCodeAt(0);
+        this.out += orDefault(ACCENT_COMMANDS[code], '');
+        this.group(el.equation);
+        if (code === 831) {
+            this.out += '}';
+        }
+    };
+    LatexGenerator.prototype.fraction = function (el) {
+        var type = el.fractionType;
+        if (type === MathFractionType.NormalFractionBar) {
+            this.out += '\\frac';
+        }
+        else if (type === MathFractionType.SkewedFractionBar || type === MathFractionType.FractionInline) {
+            this.out += '\\sfrac';
+        }
+        this.group(el.numerator);
+        if (type === MathFractionType.NoFractionBar) {
+            this.out += '\\atop';
+        }
+        this.group(el.denominator);
+    };
+    LatexGenerator.prototype.func = function (el) {
+        this.inFunctionName = true;
+        this.out += '\\';
+        this.arg(el.functionName);
+        this.inFunctionName = false;
+        this.group(el.equation);
+    };
+    LatexGenerator.prototype.delimiterChar = function (chr) {
+        this.out += chr.length > 0 ? orDefault(DELIMITER_COMMANDS[chr.charCodeAt(0)], '') : '.';
+    };
+    LatexGenerator.prototype.delimiter = function (el) {
+        this.out += '\\left';
+        this.delimiterChar(el.beginCharacter);
+        this.out += ' ';
+        for (var i = 0; i < el.equations.count; i++) {
+            this.arg(el.equations.getItem(i));
+            if (i < el.equations.count - 1) {
+                this.out += '\\middle';
+                this.delimiterChar(el.separator);
+                this.out += ' ';
+            }
+        }
+        this.out += '\\right';
+        this.delimiterChar(el.endCharacter);
+    };
+    LatexGenerator.prototype.groupChar = function (el) {
+        var code = el.groupCharacter.charCodeAt(0);
+        if (code === 9182) {
+            this.out += '\\overbrace';
+        }
+        else if (code === 9183) {
+            this.out += '\\underbrace';
+        }
+        this.group(el.equation);
+    };
+    LatexGenerator.prototype.limit = function (el) {
+        if (!this.inFunctionName) {
+            this.out += '{';
+        }
+        this.arg(el.equation);
+        if (!this.inFunctionName) {
+            this.out += '}';
+        }
+        this.out += '\\below';
+        this.group(el.limit);
+    };
+    LatexGenerator.prototype.matrix = function (el) {
+        var e_2, _a;
+        this.out += '\\begin{matrix}';
+        try {
+            for (var _b = __values(el.rowItems), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var row = _c.value;
+                var count = row.arguments.count;
+                for (var i = 0; i < count; i++) {
+                    this.arg(row.arguments.getItem(i));
+                    if (i !== count - 1) {
+                        this.out += '&';
+                    }
+                }
+                this.out += '\\\\';
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        this.out += '\\end{matrix}';
+    };
+    LatexGenerator.prototype.nary = function (el) {
+        this.out += orDefault(NARY_COMMANDS[el.nArrayCharacter.charCodeAt(0)], '');
+        if (el.subscript.functions.count > 0) {
+            this.out += '_';
+            this.group(el.subscript);
+        }
+        if (el.superscript.functions.count > 0) {
+            this.out += '^';
+            this.group(el.superscript);
+        }
+        this.group(el.equation);
+    };
+    LatexGenerator.prototype.radical = function (el) {
+        this.out += '\\sqrt';
+        if (el.degree.functions.count > 0) {
+            this.out += '[';
+            this.arg(el.degree);
+            this.out += ']';
+        }
+        this.group(el.equation);
+    };
+    LatexGenerator.prototype.script = function (base, op, script) {
+        if (!this.inFunctionName) {
+            this.out += '{';
+        }
+        this.arg(base);
+        if (!this.inFunctionName) {
+            this.out += '}';
+        }
+        this.out += op;
+        this.group(script);
+    };
+    LatexGenerator.prototype.run = function (el) {
+        var e_3, _a;
+        var text = el.text;
+        var format = el.mathFormat;
+        var sty = format.isExplicit(K.Style) ? format.style : undefined;
+        var scr = format.isExplicit(K.Script) ? format.font : undefined;
+        var openers = [];
+        if (sty === MathStyleType.BoldItalic) {
+            openers.push('\\mathbit{');
+        }
+        else if (sty === MathStyleType.Bold) {
+            openers.push('\\mathbf{');
+        }
+        if (scr !== undefined && FONT_COMMANDS[scr] !== undefined) {
+            openers.push(FONT_COMMANDS[scr] + "{");
+        }
+        if (format.hasNormalText) {
+            openers.push('\\mathrm{');
+        }
+        var applied = 0;
+        var applyFormats = true;
+        var lastSymbol = false;
+        try {
+            for (var text_1 = __values(text), text_1_1 = text_1.next(); !text_1_1.done; text_1_1 = text_1.next()) {
+                var ch = text_1_1.value;
+                var symbol = getSymbolLatex(ch, scr === MathFontType.Script);
+                if (symbol !== undefined) {
+                    this.out += '}'.repeat(applied);
+                    applied = 0;
+                    applyFormats = true;
+                    this.out += symbol;
+                    lastSymbol = true;
+                    continue;
+                }
+                if (lastSymbol && LETTER.test(ch)) {
+                    this.out += ' ';
+                }
+                lastSymbol = false;
+                if (applyFormats) {
+                    this.out += openers.join('');
+                    applied = openers.length;
+                    applyFormats = false;
+                }
+                this.out += ch;
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (text_1_1 && !text_1_1.done && (_a = text_1.return)) _a.call(text_1);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        this.out += '}'.repeat(applied);
+    };
+    return LatexGenerator;
+}());
+/**
+ * Converts a math paragraph (or a single `m:oMath`) to a LaTeX string.
+ *
+ * @public
+ */
+export function mathToLatex(math) {
+    return new LatexGenerator().generate(math instanceof OfficeMathParagraph ? math.maths.toArray() : [math]);
+}

package/src/office-common/features/mathml/latex/latex-parser.d.ts

@@ -0,0 +1,87 @@
+import { OfficeMathParagraph } from '../office-math/math-paragraph';
+import { MathDocumentAdapter } from '../office-math/adapter';
+/**
+ * Stateful LaTeX scanner/parser. One instance per conversion.
+ *
+ * @private
+ */
+export declare class LatexParser {
+    private latex;
+    private pos;
+    private cur;
+    private useExisting;
+    private current;
+    private readonly roots;
+    private sty;
+    private scr;
+    private nor;
+    /** Appends one `m:oMath` per top-level equation of `latex` to `target`, through its collections and adapter. */
+    populate(latex: string, target: OfficeMathParagraph): void;
+    private next;
+    private ensure;
+    private sub;
+    private fill;
+    private add;
+    private setRun;
+    private fallbackRun;
+    private equationString;
+    private group;
+    private squareGroup;
+    private parseEquation;
+    private dispatch;
+    private parseDefault;
+    private parseFormat;
+    /** `\cmd{...}` / `\cmd x` argument shared by accent, bar, box, border box, group char. */
+    private oneArg;
+    private parseAccent;
+    private parseBar;
+    private parseBox;
+    private parseBorderBox;
+    private delimiterChar;
+    private delimiter;
+    private parseDelimiter;
+    private splitEqArray;
+    private parseEqArray;
+    private parseFraction;
+    private fraction;
+    /** `\binom{n}{k}`: a parenthesis delimiter around a no-bar fraction (Word's binomial coefficient). */
+    private binomial;
+    private parseNoFractionBar;
+    private parseFunction;
+    private regular;
+    private parseGroupChar;
+    /** Compares the current element without TypeScript narrowing across mutating calls. */
+    private isCurrent;
+    private parseLimit;
+    private parseMatrix;
+    private matrixRows;
+    private parseNary;
+    /** Greedily absorbs trailing script groups into the N-ary operand (mirrors compression). */
+    private naryTail;
+    private parseRadical;
+    private parseGroupStart;
+    private parseScript;
+    private parseRightScript;
+    private parseLeftScript;
+}
+/**
+ * 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 declare function parseLatexToMath(latex: string, adapter?: MathDocumentAdapter): OfficeMathParagraph;
+/**
+ * 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 declare function parseLatexIntoMathParagraph(latex: string, target: OfficeMathParagraph): void;