officeparser 7.4.0 → 7.5.1

package/dist/parsers/EpubParser.js

@@ -37,7 +37,7 @@ const parseEpub = async (buffer, config) => {
     const files = await (0, zipUtils_js_1.extractFiles)(buffer, (path) => /META-INF\/container\.xml$/i.test(path)
         || /\.opf$/i.test(path)
         || /\.(xhtml|html|htm)$/i.test(path)
-        || (!!config.extractAttachments && /\.(png|jpe?g|gif|svg|webp)$/i.test(path)), config.decompressionLimits);
+        || (!!config.extractAttachments && /\.(png|jpe?g|gif|svg|webp)$/i.test(path)), config.decompressionLimits, config);
     // The OPF path is authoritative via META-INF/container.xml; fall back to scanning
     // for any .opf file for malformed archives that skip the container manifest.
     let opfPath;
@@ -49,7 +49,7 @@ const parseEpub = async (buffer, config) => {
     }
     const opfFile = (opfPath && files.find(f => f.path === opfPath)) || files.find(f => /\.opf$/i.test(f.path));
     if (!opfFile) {
-        throw (0, errorUtils_js_1.getOfficeError)(types_js_1.OfficeErrorType.FILE_CORRUPTED, config, 'epub (no OPF manifest found)');
+        throw (0, errorUtils_js_1.getOfficeError)(types_js_1.OfficeErrorType.REQUIRED_PART_MISSING, config, { fileType: 'epub', part: 'OPF package document (.opf)' });
     }
     const opfDir = opfFile.path.includes('/') ? opfFile.path.substring(0, opfFile.path.lastIndexOf('/') + 1) : '';
     const opfXml = (0, xmlUtils_js_1.parseXmlString)(opfFile.content.toString('utf-8'));

package/dist/parsers/ExcelParser.js

@@ -67,7 +67,16 @@ const parseExcel = async (buffer, config) => {
         !!x.match(customPropsFileRegex) ||
         !!x.match(appPropsFileRegex) ||
         (!!config.extractAttachments && (!!x.match(mediaFileRegex) || !!x.match(drawingRelsRegex))) ||
-        ((!!config.extractAttachments || !config.ignoreComments) && !!x.match(relsRegex)), config.decompressionLimits);
+        ((!!config.extractAttachments || !config.ignoreComments) && !!x.match(relsRegex)), config.decompressionLimits, config);
+    // Every workbook has xl/workbook.xml; without it the archive is not a spreadsheet.
+    // Resolved up front so a file that cannot be a workbook fails before any of the parsing
+    // work below, and read again further down for the sheet-name map.
+    const workbookFile = (0, zipUtils_js_1.findRequiredPart)(files, path => path === 'xl/workbook.xml', config, { fileType: 'xlsx', part: 'xl/workbook.xml' });
+    // Worksheets, by contrast, are not guaranteed: a workbook holding only chartsheets is
+    // valid and simply has no cell text to extract. Warn rather than fail, so the caller can
+    // tell "nothing to read here" from "we read nothing".
+    if (!files.some(file => !!file.path.match(sheetsRegex)))
+        (0, errorUtils_js_1.logWarning)(types_js_1.OfficeWarningType.NO_WORKSHEETS_FOUND, config);
     const sharedStringsFile = files.find(f => f.path === stringsFilePath);
     // Updated to store structured content (rich text runs) or simple string
     const sharedStrings = [];
@@ -372,9 +381,8 @@ const parseExcel = async (buffer, config) => {
     }
     // Parse workbook.xml to get sheet names and map them to sheet files
     const sheetNameMap = {};
-    const workbookFile = files.find(f => f.path === 'xl/workbook.xml');
     const workbookRelsFile = files.find(f => f.path === 'xl/_rels/workbook.xml.rels');
-    if (workbookFile && workbookRelsFile) {
+    if (workbookRelsFile) {
         // Parse rels to get rId -> file mapping
         const relsXml = (0, xmlUtils_js_1.parseXmlString)(workbookRelsFile.content.toString());
         const relationships = (0, xmlUtils_js_1.getElementsByTagName)(relsXml, "Relationship");
@@ -401,7 +409,6 @@ const parseExcel = async (buffer, config) => {
         }
     }
     const content = [];
-    const rawContents = [];
     for (const file of files) {
         if (file.path.match(mediaFileRegex))
             continue;
@@ -418,9 +425,6 @@ const parseExcel = async (buffer, config) => {
         if (file.path.match(drawingRelsRegex))
             continue;
         if (file.path.match(sheetsRegex)) {
-            if (config.includeRawContent) {
-                rawContents.push(file.content.toString());
-            }
             const sheetFilename = file.path.split('/').pop() || '';
             const relsFilename = `xl/worksheets/_rels/${sheetFilename}.rels`;
             const relsFile = files.find(f => f.path === relsFilename);

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;
@@ -106,6 +125,8 @@ const cleanAttachmentName = (href) => {
     const cleaned = href.replace(/^\.\//, '').replace(/\/$/, '');
     return cleaned.split('/').pop() || '';
 };
+/** The ODF document types this parser handles, used to validate a caller-supplied file type. */
+const ODF_FILE_TYPES = ['odt', 'odp', 'ods'];
 /**
  * Parses an OpenOffice document (.odt, .odp, .ods) and extracts content.
  *
@@ -129,10 +150,17 @@ const parseOpenOffice = async (buffer, config) => {
         !!x.match(metaFileRegex) ||
         !!x.match(stylesFileRegex) ||
         !!x.match(mimetypeFileRegex) ||
-        (!!config.extractAttachments && !!x.match(mediaFileRegex)), config.decompressionLimits);
+        (!!config.extractAttachments && !!x.match(mediaFileRegex)), config.decompressionLimits, config);
     // 1. Determine File Type
     const mimetypeFile = files.find(f => f.path === 'mimetype');
-    let fileType = 'odt'; // Default
+    // The archive's own mimetype entry is authoritative when present. When it is missing,
+    // fall back to the type the caller asked for (or that was derived from the extension)
+    // rather than assuming text: guessing 'odt' for a spreadsheet sends the parser down the
+    // office:text branch, which finds nothing in an office:spreadsheet body and yields an
+    // empty document for a perfectly valid file.
+    let fileType = ODF_FILE_TYPES.includes(config.fileType)
+        ? config.fileType
+        : 'odt';
     if (mimetypeFile) {
         const mime = mimetypeFile.content.toString().trim();
         if (mime.includes('spreadsheet'))
@@ -142,7 +170,12 @@ const parseOpenOffice = async (buffer, config) => {
         else if (mime.includes('text'))
             fileType = 'odt';
     }
-    const mainContentFile = files.find(f => f.path === 'content.xml') || files.find(f => f.path.match(contentFileRegex));
+    // The document body is the content.xml at the archive root. The fallback stays anchored
+    // and excludes embedded objects: an ODF file can carry Object N/content.xml for a chart
+    // or formula, and an unanchored match would promote one of those to the document body
+    // when the real one is missing, silently parsing a chart as if it were the whole file.
+    const mainContentFile = files.find(f => f.path === 'content.xml')
+        || (0, zipUtils_js_1.findRequiredPart)(files, path => /(^|\/)content\.xml$/.test(path) && !objectContentFileRegex.test(path), config, { fileType, part: 'content.xml' });
     const stylesFile = files.find(f => f.path === 'styles.xml');
     const stylesDom = stylesFile ? (0, xmlUtils_js_1.parseXmlString)(stylesFile.content.toString()) : undefined;
     const content = [];
@@ -159,8 +192,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 +221,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 +247,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 +305,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 +367,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 +388,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 +493,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 +601,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 +814,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 +853,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 +884,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 +933,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 +962,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 +1235,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 +1326,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 +1395,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