officeparser 7.4.0 → 7.5.0

package/dist/parsers/HtmlParser.js

@@ -4,6 +4,7 @@ exports.parseHtml = void 0;
 const types_js_1 = require("../types.js");
 const astUtils_js_1 = require("../utils/astUtils.js");
 const errorUtils_js_1 = require("../utils/errorUtils.js");
+const mathUtils_js_1 = require("../utils/mathUtils.js");
 const sanitize_js_1 = require("../utils/sanitize.js");
 /**
  * Maximum element nesting depth accepted from an HTML/XHTML source before the parser gives up
@@ -11,6 +12,25 @@ const sanitize_js_1 = require("../utils/sanitize.js");
  * `parseNode` for why this value and not a larger one.
  */
 const MAX_HTML_NESTING_DEPTH = 256;
+/**
+ * Presents an `HtmlNode` as a `MathNode` for the shared MathML converter.
+ *
+ * The shapes already line up field for field; the one thing that must happen here is entity
+ * decoding, since this parser keeps text nodes in their raw escaped form and `<` inside an
+ * `<mo>` is a less-than operator, not markup.
+ */
+const toMathNode = (node) => ({
+    tagName: node.tagName,
+    attributes: node.attributes,
+    text: node.text === undefined ? undefined : node.text
+        .replace(/&nbsp;/g, ' ')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'"),
+    children: (node.children || []).map(toMathNode),
+});
 const parseAttributes = (attrString) => {
     const attrs = {};
     // Attribute names follow the HTML5 rule - any character except whitespace and
@@ -572,6 +592,25 @@ const parseHtml = async (buffer, config) => {
                     metadata: { math: mathMode }
                 };
             }
+            // Native MathML. This is what a real-world page and every EPUB3 uses (EpubParser
+            // routes each spine item through here), as opposed to the `data-math` round-trip
+            // contract above, which only ever appears in this library's own HTML output. Without
+            // it, a `<math>` element fell through to the generic element handling below, which
+            // concatenates descendant text: `<mfrac><mn>1</mn><mn>2</mn></mfrac>` became "12".
+            if (tagName === 'math' || tagName.endsWith(':math')) {
+                // `display="block"` is MathML's own attribute for a display equation; the legacy
+                // `mode="display"` means the same thing and is still emitted by older producers.
+                const isBlock = node.attributes?.['display'] === 'block'
+                    || node.attributes?.['mode'] === 'display';
+                const latex = (0, mathUtils_js_1.mathmlTreeToLatex)(toMathNode(node));
+                if ((0, mathUtils_js_1.isEmptyMath)(latex))
+                    return null;
+                return {
+                    type: 'code',
+                    text: latex,
+                    metadata: { math: isBlock ? 'block' : 'inline' }
+                };
+            }
             // Admonition: inscript-editor's Admonition node renders
             // <div class="admonition admonition-note" data-type="note">…children…</div>.
             if (tagName === 'div' && (node.attributes?.class || '').split(/\s+/).includes('admonition')) {

package/dist/parsers/OpenOfficeParser.js

@@ -27,6 +27,7 @@ const types_js_1 = require("../types.js");
 const astUtils_js_1 = require("../utils/astUtils.js");
 const chartUtils_js_1 = require("../utils/chartUtils.js");
 const errorUtils_js_1 = require("../utils/errorUtils.js");
+const mathUtils_js_1 = require("../utils/mathUtils.js");
 /**
  * Tracks how many table cells a single document has been allowed to materialize.
  *
@@ -84,10 +85,28 @@ class CellBudget {
 /** Resolves the configured cell budget, falling back to the documented default. */
 const createCellBudget = (config) => new CellBudget(config.decompressionLimits?.maxTableCells ?? 1000000, config);
 /**
- * Coerces a `table:number-*-repeated` attribute to a usable repeat count. A missing, zero,
- * negative or non-numeric value becomes 1 (the element renders once), so a garbage attribute
- * can neither drop a cell nor poison arithmetic downstream (`colIndex += NaN`).
+ * Merges a style's formatting over what it inherits, dropping any flag the style explicitly turns
+ * off rather than carrying a `false` forward.
+ *
+ * Generators all test these flags for truthiness, so a retained `false` would render the same - but
+ * it would not *compare* the same, and `MarkdownGenerator.optimizeNodes` merges adjacent text nodes
+ * only when their formatting objects are equal. Leaving `bold: false` on one node and nothing on
+ * its neighbour would silently stop that merge and fragment the output. Same reasoning, and same
+ * shape, as `WordParser`'s direct-run-property merge.
  */
+const mergeFormatting = (inherited, override) => {
+    if (!override)
+        return { ...inherited };
+    const merged = { ...inherited };
+    for (const key of Object.keys(override)) {
+        const value = override[key];
+        if (value === false)
+            delete merged[key];
+        else if (value !== undefined)
+            merged[key] = value;
+    }
+    return merged;
+};
 const toRepeatCount = (attr) => {
     const n = parseInt(attr || "1");
     return Number.isFinite(n) && n > 0 ? n : 1;
@@ -159,8 +178,8 @@ const parseOpenOffice = async (buffer, config) => {
     let lastWasList = false;
     let traverse;
     // Helper to parse styles
-    const parseStyles = (xml) => {
-        const styles = (0, xmlUtils_js_1.getElementsByTagName)(xml, "style:style");
+    const parseStyles = (scope) => {
+        const styles = (0, xmlUtils_js_1.getElementsByTagName)(scope, "style:style");
         for (const style of styles) {
             const name = style.getAttribute("style:name");
             if (!name)
@@ -188,6 +207,17 @@ const parseOpenOffice = async (buffer, config) => {
                 if (dropCap) {
                     styleInfo.dropCap = true;
                 }
+                // Page/column breaks. ODF attaches these to the paragraph style rather than
+                // writing an inline element the way DOCX's `<w:br w:type="page"/>` does, which is
+                // why `includeBreakNodes` produced nothing at all for ODF: there was no inline
+                // element to find. Only the two break kinds that map onto a BreakMetadata type
+                // are carried; `auto` and `even-page`/`odd-page` have no equivalent.
+                const breakBefore = paraProps.getAttribute("fo:break-before");
+                if (breakBefore === 'page' || breakBefore === 'column')
+                    styleInfo.breakBefore = breakBefore;
+                const breakAfter = paraProps.getAttribute("fo:break-after");
+                if (breakAfter === 'page' || breakAfter === 'column')
+                    styleInfo.breakAfter = breakAfter;
             }
             if (Object.keys(styleInfo).length > 0) {
                 paragraphStyleMap[name] = styleInfo;
@@ -203,14 +233,28 @@ const parseOpenOffice = async (buffer, config) => {
                     formatting.backgroundColor = bgColor;
             }
             if (textProps) {
-                if (textProps.getAttribute("fo:font-weight") === "bold" || textProps.getAttribute("style:font-weight-asian") === "bold")
-                    formatting.bold = true;
-                if (textProps.getAttribute("fo:font-style") === "italic" || textProps.getAttribute("style:font-style-asian") === "italic")
-                    formatting.italic = true;
-                if (textProps.getAttribute("style:text-underline-style") === "solid")
-                    formatting.underline = true;
-                if (textProps.getAttribute("style:text-line-through-style") === "solid")
-                    formatting.strikethrough = true;
+                // Record the *off* states as an explicit `false`, not as an absent key.
+                //
+                // Now that a paragraph style's text properties are inherited by the runs inside it,
+                // a span has to be able to turn one back off: LibreOffice writes
+                // `fo:font-weight="normal"` on the span whenever a user un-bolds part of a
+                // bold-styled paragraph. With only the `true` side recorded, that span had nothing
+                // to override the inherited value with and came out bold - wrong in the opposite
+                // direction from the bug the inheritance fixed. `TextFormatting`'s flags are
+                // `boolean | undefined` precisely so "explicitly off" is expressible.
+                const fontWeight = textProps.getAttribute("fo:font-weight") || textProps.getAttribute("style:font-weight-asian");
+                // Numeric weights are the same axis: 600+ is bold, below that is not.
+                if (fontWeight)
+                    formatting.bold = fontWeight === "bold" || /^[6-9]00$/.test(fontWeight);
+                const fontStyle = textProps.getAttribute("fo:font-style") || textProps.getAttribute("style:font-style-asian");
+                if (fontStyle)
+                    formatting.italic = fontStyle === "italic" || fontStyle === "oblique";
+                const underline = textProps.getAttribute("style:text-underline-style");
+                if (underline)
+                    formatting.underline = underline !== "none";
+                const lineThrough = textProps.getAttribute("style:text-line-through-style");
+                if (lineThrough)
+                    formatting.strikethrough = lineThrough !== "none";
                 const size = textProps.getAttribute("fo:font-size") || textProps.getAttribute("style:font-size-asian");
                 if (size)
                     formatting.size = size;
@@ -247,62 +291,6 @@ const parseOpenOffice = async (buffer, config) => {
      *
      * @param node - The paragraph element to parse
      */
-    const parseMathML = (node) => {
-        if (!node)
-            return '';
-        if (node.nodeType === 3) { // Text node
-            return node.textContent || '';
-        }
-        if (node.nodeType !== 1) { // Not an element
-            return '';
-        }
-        const element = node;
-        const tagName = element.tagName.toLowerCase().replace(/^.*:/, ''); // strip namespace prefix
-        switch (tagName) {
-            case 'math':
-            case 'mrow':
-            case 'semantics':
-                return Array.from(element.childNodes).map(parseMathML).join('');
-            case 'mfrac': {
-                const children = Array.from(element.childNodes).filter((n) => n.nodeType === 1);
-                if (children.length >= 2) {
-                    return `(${parseMathML(children[0])})/(${parseMathML(children[1])})`;
-                }
-                return Array.from(element.childNodes).map(parseMathML).join('');
-            }
-            case 'msub': {
-                const children = Array.from(element.childNodes).filter((n) => n.nodeType === 1);
-                if (children.length >= 2) {
-                    return `${parseMathML(children[0])}_${parseMathML(children[1])}`;
-                }
-                return Array.from(element.childNodes).map(parseMathML).join('');
-            }
-            case 'msup': {
-                const children = Array.from(element.childNodes).filter((n) => n.nodeType === 1);
-                if (children.length >= 2) {
-                    return `${parseMathML(children[0])}^${parseMathML(children[1])}`;
-                }
-                return Array.from(element.childNodes).map(parseMathML).join('');
-            }
-            case 'msubsup': {
-                const children = Array.from(element.childNodes).filter((n) => n.nodeType === 1);
-                if (children.length >= 3) {
-                    return `${parseMathML(children[0])}_${parseMathML(children[1])}^${parseMathML(children[2])}`;
-                }
-                return Array.from(element.childNodes).map(parseMathML).join('');
-            }
-            case 'mi':
-            case 'mn':
-            case 'mo':
-            case 'mtext':
-            case 'ms':
-                return element.textContent || '';
-            case 'annotation':
-                return '';
-            default:
-                return Array.from(element.childNodes).map(parseMathML).join('');
-        }
-    };
     /**
      * Helper to parse inline content (text, spans, links, notes, etc.) recursively.
      *
@@ -365,6 +353,14 @@ const parseOpenOffice = async (buffer, config) => {
                         metadata: linkMetadata ? { ...linkMetadata } : undefined
                     });
                 }
+                else if (tagName === 'text:soft-page-break') {
+                    // The page boundary the editor recorded at its last save. DOCX's equivalent
+                    // is `w:lastRenderedPageBreak`, so it maps onto the same break type rather
+                    // than onto 'page', which is reserved for a break the author asked for.
+                    if (config.includeBreakNodes) {
+                        children.push({ type: 'break', metadata: { breakType: 'lastRenderedPage' } });
+                    }
+                }
                 else if (tagName === 'text:line-break') {
                     // Line break
                     fullText += '\n';
@@ -378,7 +374,7 @@ const parseOpenOffice = async (buffer, config) => {
                 else if (tagName === 'text:span') {
                     // Formatted text span
                     const styleName = element.getAttribute("text:style-name");
-                    const formatting = styleName ? { ...parentFormatting, ...styleMap[styleName] } : parentFormatting;
+                    const formatting = styleName ? mergeFormatting(parentFormatting, styleMap[styleName]) : parentFormatting;
                     const spanContent = parseInlineContent(element, styleMap, config, notes, paragraphStyleMap, formatting, linkMetadata, sourceXml);
                     fullText += spanContent.text;
                     children.push(...spanContent.children);
@@ -483,22 +479,25 @@ const parseOpenOffice = async (buffer, config) => {
                                 const mathNode = (0, xmlUtils_js_1.getFirstElementByTagName)(objXml, "math");
                                 if (mathNode) {
                                     isFormula = true;
-                                    formulaText = parseMathML(mathNode).trim();
+                                    formulaText = (0, mathUtils_js_1.mathmlToLatex)(mathNode).trim();
                                 }
                             }
                         }
                         if (isFormula) {
                             fullText += formulaText;
-                            const textNode = {
-                                type: 'text',
+                            // A `code` node carrying `math`, not a plain `text` node: the formula
+                            // is LaTeX, and marking it as such is what lets generators render it
+                            // as maths rather than emit it as prose that happens to contain
+                            // backslashes. Same node shape DOCX, PPTX, HTML and Markdown produce.
+                            const formulaNode = {
+                                type: 'code',
                                 text: formulaText,
-                                formatting: parentFormatting,
-                                metadata: linkMetadata ? { ...linkMetadata } : undefined
+                                metadata: { math: 'inline', ...(linkMetadata ?? {}) }
                             };
                             if (config.includeRawContent) {
-                                textNode.rawContent = (0, xmlUtils_js_1.getRawContent)(frame, sourceXml, config);
+                                formulaNode.rawContent = (0, xmlUtils_js_1.getRawContent)(frame, sourceXml, config);
                             }
-                            children.push(textNode);
+                            children.push(formulaNode);
                         }
                         else {
                             // Standard inline image extraction fallback if object is not a formula
@@ -588,8 +587,9 @@ const parseOpenOffice = async (buffer, config) => {
         const styleInfo = paraStyle ? paraStyleMap[paraStyle] : undefined;
         const alignment = styleInfo?.alignment;
         const dropCap = styleInfo?.dropCap;
+        const formatting = mergeFormatting({}, paraStyle ? styleMap[paraStyle] : undefined);
         // Parse content recursively using the new helper
-        const content = parseInlineContent(node, styleMap, config, notes, paraStyleMap, {}, undefined, sourceXml);
+        const content = parseInlineContent(node, styleMap, config, notes, paraStyleMap, formatting, undefined, sourceXml);
         // Add style name to metadata of children if they don't have one
         if (paraStyle) {
             content.children.forEach(child => {
@@ -800,7 +800,7 @@ const parseOpenOffice = async (buffer, config) => {
             // whole cell array, so rows x cols is what actually exhausts memory; charge those
             // copies against the same budget.
             const allowedRows = cells.length === 0
-                ? rowsRepeated
+                ? (rowsRepeated > 0 ? 1 + cellBudget.take(rowsRepeated - 1) : 0)
                 : Math.min(rowsRepeated, 1 + Math.floor(cellBudget.take(Math.max(0, (rowsRepeated - 1) * cells.length)) / cells.length));
             for (let k = 0; k < allowedRows; k++) {
                 if ((k & 255) === 0)
@@ -839,82 +839,12 @@ const parseOpenOffice = async (buffer, config) => {
         // splitting a huge repeat expansion across many small tables. `traverse` and the
         // spreadsheet branch below both close over this; `parseTable` receives it explicitly.
         const cellBudget = createCellBudget(config);
-        // Parse automatic styles (local to content.xml)
+        // Automatic styles are local to content.xml, but their definitions have exactly the
+        // shape styles.xml uses, so they go through the same reader rather than a second copy of
+        // it - the copy is how `fo:break-before` came to be read in neither place.
         const automaticStyles = (0, xmlUtils_js_1.getFirstElementByTagName)(xml, "office:automatic-styles");
         if (automaticStyles) {
-            const styles = (0, xmlUtils_js_1.getElementsByTagName)(automaticStyles, "style:style");
-            for (const style of styles) {
-                const name = style.getAttribute("style:name");
-                if (!name)
-                    continue;
-                // Parse paragraph properties for alignment
-                const paraProps = (0, xmlUtils_js_1.getFirstElementByTagName)(style, "style:paragraph-properties");
-                const styleInfo = {};
-                if (paraProps) {
-                    const textAlign = paraProps.getAttribute("fo:text-align");
-                    if (textAlign) {
-                        const alignMap = {
-                            'start': 'left',
-                            'left': 'left',
-                            'center': 'center',
-                            'end': 'right',
-                            'right': 'right',
-                            'justify': 'justify'
-                        };
-                        if (alignMap[textAlign]) {
-                            styleInfo.alignment = alignMap[textAlign];
-                        }
-                    }
-                    const dropCap = (0, xmlUtils_js_1.getFirstElementByTagName)(paraProps, "style:drop-cap");
-                    if (dropCap)
-                        styleInfo.dropCap = true;
-                }
-                if (Object.keys(styleInfo).length > 0) {
-                    paragraphStyleMap[name] = styleInfo;
-                }
-                const cellProps = (0, xmlUtils_js_1.getFirstElementByTagName)(style, "style:table-cell-properties");
-                const formatting = {};
-                if (cellProps) {
-                    const bgColor = cellProps.getAttribute("fo:background-color");
-                    if (bgColor && bgColor !== 'transparent')
-                        formatting.backgroundColor = bgColor;
-                }
-                const textProps = (0, xmlUtils_js_1.getFirstElementByTagName)(style, "style:text-properties");
-                if (textProps) {
-                    if (textProps.getAttribute("fo:font-weight") === "bold" || textProps.getAttribute("style:font-weight-asian") === "bold")
-                        formatting.bold = true;
-                    if (textProps.getAttribute("fo:font-style") === "italic" || textProps.getAttribute("style:font-style-asian") === "italic")
-                        formatting.italic = true;
-                    if (textProps.getAttribute("style:text-underline-style") === "solid")
-                        formatting.underline = true;
-                    if (textProps.getAttribute("style:text-line-through-style") === "solid")
-                        formatting.strikethrough = true;
-                    const size = textProps.getAttribute("fo:font-size") || textProps.getAttribute("style:font-size-asian");
-                    if (size)
-                        formatting.size = size;
-                    const color = textProps.getAttribute("fo:color");
-                    if (color)
-                        formatting.color = color;
-                    // Background color
-                    const bgColor = textProps.getAttribute("fo:background-color");
-                    if (bgColor && bgColor !== 'transparent')
-                        formatting.backgroundColor = bgColor;
-                    // Font family
-                    const fontName = textProps.getAttribute("style:font-name") || textProps.getAttribute("fo:font-family");
-                    if (fontName)
-                        formatting.font = fontName;
-                    // Subscript/Superscript from text-position (e.g., "sub 58%" or "super 58%")
-                    const textPosition = textProps.getAttribute("style:text-position");
-                    if (textPosition) {
-                        if (textPosition.startsWith("sub"))
-                            formatting.subscript = true;
-                        if (textPosition.startsWith("super"))
-                            formatting.superscript = true;
-                    }
-                }
-                if (Object.keys(formatting).length > 0)
-                    styleMap[name] = formatting;
-            }
+            parseStyles(automaticStyles);
         }
         // Start traversal
         const officeBody = (0, xmlUtils_js_1.getFirstElementByTagName)(xml, "office:body");
@@ -940,8 +870,26 @@ const parseOpenOffice = async (buffer, config) => {
          * @param sourceXml - The source XML string for raw content extraction
          * @param asSheet - If true, treats tables as sheets (for ODS)
          */
+        /**
+         * Emits the break a paragraph style asks for, on the given side of that paragraph.
+         *
+         * ODF has no inline break element for these - `fo:break-before="page"` sits on the style,
+         * so the break is a property of the paragraph rather than a run inside it. That makes it a
+         * sibling emitted around the paragraph node, not a child of it, which is the one structural
+         * difference from how DOCX's `<w:br w:type="page"/>` lands.
+         */
+        const pushStyleBreak = (styleName, targetArray, edge) => {
+            if (!config.includeBreakNodes || !styleName)
+                return;
+            const info = paragraphStyleMap[styleName];
+            const breakType = edge === 'before' ? info?.breakBefore : info?.breakAfter;
+            if (!breakType)
+                return;
+            targetArray.push({ type: 'break', metadata: { breakType } });
+        };
         traverse = (node, targetArray, forceHeading = false, sourceXml = '', asSheet = false) => {
             if (node.tagName === "text:p") {
+                pushStyleBreak(node.getAttribute("text:style-name"), targetArray, 'before');
                 const pContent = parseParagraphContent(node, paragraphStyleMap, styleMap, config, sourceXml);
                 const type = (forceHeading || (node.getAttribute("text:style-name") || '').toLowerCase().includes('title')) ? 'heading' : 'paragraph';
                 const metadata = {
@@ -971,9 +919,11 @@ const parseOpenOffice = async (buffer, config) => {
                     pNode.rawContent = (0, xmlUtils_js_1.getRawContent)(node, sourceXml, config);
                 }
                 targetArray.push(pNode);
+                pushStyleBreak(node.getAttribute("text:style-name"), targetArray, 'after');
                 lastWasList = false;
             }
             else if (node.tagName === "text:h") {
+                pushStyleBreak(node.getAttribute("text:style-name"), targetArray, 'before');
                 const level = parseInt(node.getAttribute("text:outline-level") || "1");
                 const hContent = parseParagraphContent(node, paragraphStyleMap, styleMap, config, sourceXml);
                 const metadata = {
@@ -998,6 +948,7 @@ const parseOpenOffice = async (buffer, config) => {
                     hNode.rawContent = (0, xmlUtils_js_1.getRawContent)(node, sourceXml, config);
                 }
                 targetArray.push(hNode);
+                pushStyleBreak(node.getAttribute("text:style-name"), targetArray, 'after');
                 lastWasList = false;
             }
             else if (node.tagName === "table:table") {
@@ -1270,15 +1221,18 @@ const parseOpenOffice = async (buffer, config) => {
                             const objXml = (0, xmlUtils_js_1.parseXmlString)(objectFile.content.toString());
                             const mathNode = (0, xmlUtils_js_1.getFirstElementByTagName)(objXml, "math");
                             if (mathNode) {
-                                // Math formula object at block level
-                                const formulaText = parseMathML(mathNode).trim();
+                                // Math formula object at block level - a display equation, so the
+                                // inner node is `math: 'block'` where the inline site above emits
+                                // `math: 'inline'`.
+                                const formulaText = (0, mathUtils_js_1.mathmlToLatex)(mathNode).trim();
                                 const formulaNode = {
                                     type: 'paragraph',
                                     text: formulaText,
                                     children: [
                                         {
-                                            type: 'text',
-                                            text: formulaText
+                                            type: 'code',
+                                            text: formulaText,
+                                            metadata: { math: 'block' }
                                         }
                                     ]
                                 };
@@ -1358,7 +1312,11 @@ const parseOpenOffice = async (buffer, config) => {
                                 if (spans.length > 0) {
                                     for (const span of spans) {
                                         const styleName = span.getAttribute("text:style-name");
-                                        const formatting = styleName ? styleMap[styleName] : {};
+                                        // Through `mergeFormatting` like every other span site, so
+                                        // an explicit `false` is dropped rather than written onto
+                                        // the node - and so the node gets its own object instead of
+                                        // aliasing the shared style-table entry.
+                                        const formatting = mergeFormatting({}, styleName ? styleMap[styleName] : undefined);
                                         const text = span.textContent || '';
                                         cellText += text;
                                         const textNode = {
@@ -1423,22 +1381,22 @@ const parseOpenOffice = async (buffer, config) => {
                                             const mathNode = (0, xmlUtils_js_1.getFirstElementByTagName)(objXml, "math");
                                             if (mathNode) {
                                                 isFormula = true;
-                                                formulaText = parseMathML(mathNode).trim();
+                                                formulaText = (0, mathUtils_js_1.mathmlToLatex)(mathNode).trim();
                                             }
                                         }
                                     }
                                 }
                                 if (isFormula) {
                                     cellText += formulaText;
-                                    const textNode = {
-                                        type: 'text',
+                                    const formulaNode = {
+                                        type: 'code',
                                         text: formulaText,
-                                        formatting: {}
+                                        metadata: { math: 'inline' }
                                     };
                                     if (config.includeRawContent) {
-                                        textNode.rawContent = (0, xmlUtils_js_1.getRawContent)(frame, xmlString, config);
+                                        formulaNode.rawContent = (0, xmlUtils_js_1.getRawContent)(frame, xmlString, config);
                                     }
-                                    children.push(textNode);
+                                    children.push(formulaNode);
                                 }
                                 else if (drawImages.length > 0) {
                                     // logic for image node

package/dist/parsers/PowerPointParser.js

@@ -29,6 +29,7 @@ const astUtils_js_1 = require("../utils/astUtils.js");
 const chartUtils_js_1 = require("../utils/chartUtils.js");
 const errorUtils_js_1 = require("../utils/errorUtils.js");
 const imageUtils_js_1 = require("../utils/imageUtils.js");
+const mathUtils_js_1 = require("../utils/mathUtils.js");
 const ocrUtils_js_1 = require("../utils/ocrUtils.js");
 const xmlUtils_js_1 = require("../utils/xmlUtils.js");
 const zipUtils_js_1 = require("../utils/zipUtils.js");
@@ -576,6 +577,30 @@ const parsePowerPoint = async (buffer, config) => {
                             activeNode.children?.push({ type: 'text', text: "\n" });
                         }
                     }
+                    else {
+                        // Equations. This loop dispatches on `a:r`/`a:fld`, so an `m:oMath` -
+                        // which is a sibling of the runs, not one of them - was never visited at
+                        // all and the formula vanished from the slide without a warning.
+                        //
+                        // PowerPoint writes the equation either directly in the paragraph or
+                        // wrapped in `mc:AlternateContent`/`a14:m` for pre-2010 readers, so take
+                        // the element itself when it is the equation and search inside it
+                        // otherwise. `getElementsByTagName` returns document order, which is the
+                        // order the equations are read in.
+                        const isMath = tag === "m:oMath" || tag === "m:oMathPara";
+                        const equations = isMath ? [element] : (0, xmlUtils_js_1.getElementsByTagName)(element, "m:oMath");
+                        for (const equation of equations) {
+                            const latex = (0, mathUtils_js_1.ommlToLatex)(equation);
+                            if ((0, mathUtils_js_1.isEmptyMath)(latex))
+                                continue;
+                            activeNode.text += latex;
+                            activeNode.children?.push({
+                                type: 'code',
+                                text: latex,
+                                metadata: { math: tag === "m:oMathPara" ? 'block' : 'inline' }
+                            });
+                        }
+                    }
                 }
             }
         }
@@ -623,12 +648,8 @@ const parsePowerPoint = async (buffer, config) => {
             }
             // Case 4: Grouped shape (recursive!)
             else if (tag === "p:grpSp") {
-                // Extract the nested <p:spTree> inside the group
-                const nestedTree = (0, xmlUtils_js_1.getFirstElementByTagName)(element, "p:spTree");
-                // Recurse into the nested tree
-                if (nestedTree) {
-                    nodes.push(...traverseSpTree(nestedTree, slideNumber, xmlContentString));
-                }
+                // Recurse into the group element itself which holds the child shapes
+                nodes.push(...traverseSpTree(element, slideNumber, xmlContentString));
             }
         }
         return nodes;

package/dist/parsers/WordParser.js

@@ -66,6 +66,7 @@ const types_js_1 = require("../types.js");
 const astUtils_js_1 = require("../utils/astUtils.js");
 const errorUtils_js_1 = require("../utils/errorUtils.js");
 const imageUtils_js_1 = require("../utils/imageUtils.js");
+const mathUtils_js_1 = require("../utils/mathUtils.js");
 const ocrUtils_js_1 = require("../utils/ocrUtils.js");
 const xmlUtils_js_1 = require("../utils/xmlUtils.js");
 const zipUtils_js_1 = require("../utils/zipUtils.js");
@@ -751,6 +752,26 @@ const parseWord = async (buffer, config) => {
                     }
                 }
             }
+            else if ((0, xmlUtils_js_1.isElement)(node) && (node.nodeName === 'm:oMath' || node.nodeName === 'oMath'
+                || node.nodeName === 'm:oMathPara' || node.nodeName === 'oMathPara')) {
+                // Equations. Without this branch they reach the generic fallback below, which
+                // recurses into every child and concatenates the `m:t` runs with no separators -
+                // so `<m:num>1</m:num><m:den>2</m:den>` came out as "12". That is worse than
+                // dropping the formula: the result still reads as a number, so nothing downstream
+                // can tell it is wrong.
+                //
+                // `m:oMathPara` is a display equation on its own line; a bare `m:oMath` is inline.
+                const isBlock = node.nodeName === 'm:oMathPara' || node.nodeName === 'oMathPara';
+                const latex = (0, mathUtils_js_1.ommlToLatex)(node);
+                if (!(0, mathUtils_js_1.isEmptyMath)(latex)) {
+                    text += latex;
+                    children.push({
+                        type: 'code',
+                        text: latex,
+                        metadata: { math: isBlock ? 'block' : 'inline' }
+                    });
+                }
+            }
             else if (node.childNodes.length > 0) {
                 // Generic fallback for unknown elements that might contain content
                 for (const child of Array.from(node.childNodes))