officeparser 7.4.0 → 7.5.0

package/README.md

@@ -128,7 +128,7 @@ npx officeparser my_document --fileType=docx --to=json
 | `--includeRawContent` | boolean | `false` | Include raw XML/RTF in nodes |
 | `--serializeRawContent` | boolean | `true` | Include stringified XML in metadata |
 | `--preserveXmlWhitespace` | boolean | `false` | Keep raw formatting space |
-| `--includeBreakNodes` | boolean | `false` | Include break nodes (DOCX only) |
+| `--includeBreakNodes` | boolean | `false` | Include break nodes (DOCX and ODF) |
 | `--verbose` | boolean | `false` | Show full error stack traces and warning logs |
 | `--includeFormatting` | boolean | `true` | Include formatting style map matching |
 | `--renderMetadata` | boolean | `false` | Render metadata as visible content in the generated output |
@@ -608,7 +608,14 @@ formatting: {
 }
 ```
 
-### 6. Break Nodes (DOCX only)
+> [!NOTE]
+> On a **content node**, an absent flag and `false` mean the same thing — the flag is simply not
+> applied. On **`ast.metadata.styleMap`**, they differ: an absent flag means the style says nothing
+> about that property (so it inherits), while `false` means the style explicitly turns it off
+> (ODF's `fo:font-weight="normal"`, DOCX's `<w:b w:val="0"/>`). Code resolving inheritance itself
+> must test `=== undefined`, not truthiness, or it will treat "explicitly off" as "unspecified".
+
+### 6. Break Nodes (DOCX and ODF)
 
 When `includeBreakNodes: true`, break elements appear as nodes:
 
@@ -623,6 +630,43 @@ Break Node (type: 'break')
 > [!NOTE]
 > Break nodes have no `text` property, but `ast.toText()` and `ast.to('text')` automatically convert them to the configured newline delimiter.
 
+> [!NOTE]
+> DOCX writes breaks inline (`w:br`/`w:cr`), so they land as children of the paragraph. ODF instead
+> carries page and column breaks on the paragraph *style* (`fo:break-before`/`fo:break-after`), so those
+> are emitted as siblings around the paragraph rather than inside it. `<text:soft-page-break/>` maps onto
+> `lastRenderedPage`, the same type as DOCX's `w:lastRenderedPageBreak`.
+
+### 6b. Equations
+
+Equations are extracted from every format that can carry them and normalized to **LaTeX**, so a
+formula means the same thing whichever format it arrived in:
+
+| Source format | Markup in the file |
+|---|---|
+| DOCX, PPTX | OOXML `<m:oMath>` / `<m:oMathPara>` |
+| ODT, ODP, ODS | MathML inside the embedded formula object |
+| HTML, EPUB | native MathML `<math>` |
+| Markdown | `$inline$` / `$$block$$` |
+
+They all land as the same node:
+
+```text
+Code Node (type: 'code')
+├── text: '\\frac{1}{2}'          // LaTeX, whatever the source markup was
+└── metadata: { math: 'inline' | 'block' }
+```
+
+Fractions, sub/superscripts, radicals, delimiters, n-ary operators (sums, integrals), named
+functions, accents, bars, matrices and math alphabets (`ℝ`, `𝒜`, …) are all preserved. When a
+document supplies its own TeX source in an `<annotation encoding="application/x-tex">`, that is
+used verbatim in preference to anything reconstructed from the presentation markup.
+
+> [!NOTE]
+> Equation text is *structure*, not prose: a fraction whose numerator and denominator are simply
+> concatenated reads as a different number rather than as obviously-missing content. Consumers that
+> index document text should treat `code` nodes carrying `math` as opaque LaTeX rather than
+> splitting them as words.
+
 ### 7. Document Metadata
 
 ```ts
@@ -688,7 +732,7 @@ idempotent and `.md → AST → HTML → AST → .md` survives unchanged.
 | Attribute lists | `![alt](img.png){width=50% .centered}` | `ImageMetadata.width` / `.align`, `TableMetadata.align` |
 | Citations | `[@smith2024]` | `TextMetadata.citationKey` |
 | Wikilinks | `[[Page]]` / `[[Page\|Alias]]` | `TextMetadata.wikilink`, `.link`, `.linkType` |
-| Inline/block math | `$E=mc^2$` / `` $$...$$ `` | `TextMetadata.math` (`'inline' \| 'block'`) |
+| Inline/block math | `$E=mc^2$` / `` $$...$$ `` | `type: 'code'`, `CodeMetadata.math` (`'inline' \| 'block'`) |
 | Frontmatter arrays | `tags: [a, b]` or `tags: ["a","b"]` | Real array in `metadata.customProperties`/`nativeProperties` |
 | MDX components (import-only) | `<Component prop="x">...</Component>` | Stripped; inner Markdown is kept. Never generated back. |
 
@@ -888,7 +932,7 @@ Pass as the second argument to `parseOffice(file, config)`.
 | `includeRawContent` | `boolean` | `false` | Attach raw XML/RTF source to each node |
 | `serializeRawContent` | `boolean` | `true` | Re-serialize XML to clean strings (only if `includeRawContent: true`) |
 | `preserveXmlWhitespace` | `boolean` | `false` | Preserve original XML whitespace during serialization |
-| `includeBreakNodes` | `boolean` | `false` | Include `w:br` / `w:cr` as typed break nodes (DOCX only) |
+| `includeBreakNodes` | `boolean` | `false` | Include typed break nodes: DOCX `w:br`/`w:cr`, ODF `fo:break-before`/`fo:break-after` and `text:soft-page-break` |
 | `ignoreInternalLinks` | `boolean` | `false` | Strip bookmarks and internal cross-references from AST |
 | `fileType` | `SupportedFileType \| null` | `null` | **Required for text-based binary data** (`'md'`, `'html'`, `'csv'`) as these lack magic bytes. |
 | `csvDelimiter` | `string` | `','` | Input delimiter when parsing CSV files |

package/dist/generators/BaseGenerator.d.ts

@@ -81,6 +81,21 @@ export declare abstract class BaseGenerator<D extends UniversalGeneratorFormat =
      * hasn't already been claimed; otherwise a sequential counter guarantees uniqueness.
      */
     protected getFootnoteKey(note: OfficeContentNode): string;
+    /**
+     * True when every content-bearing text descendant satisfies `test` - i.e. the property is
+     * uniform across the whole node and therefore says nothing the node type does not already say.
+     *
+     * Used to decide whether a heading's or header row's inherited formatting can be dropped. The
+     * distinction matters: an ODF heading whose paragraph style is bold and 14pt yields a heading
+     * where *every* run is bold and 14pt, and re-emitting that gives `# **Heading**` in Markdown
+     * and, worse in RTF/HTML, an inner font-size that overrides the heading's own and visibly
+     * shrinks it. But `# Normal **Bold** Normal` is an author contrasting one word against the
+     * rest, and dropping that would discard real meaning. Only the uniform case is safe.
+     *
+     * Returns false when there is no text to judge, so an empty or image-only node never triggers
+     * suppression.
+     */
+    protected hasUniformFormatting(node: OfficeContentNode, test: (formatting: OfficeContentNode['formatting']) => boolean): boolean;
     /**
      * Recursively extracts plain text from a node and its children.
      */

package/dist/generators/BaseGenerator.js

@@ -187,6 +187,37 @@ class BaseGenerator {
         this.noteFootnoteKeys.set(note, key);
         return key;
     }
+    /**
+     * True when every content-bearing text descendant satisfies `test` - i.e. the property is
+     * uniform across the whole node and therefore says nothing the node type does not already say.
+     *
+     * Used to decide whether a heading's or header row's inherited formatting can be dropped. The
+     * distinction matters: an ODF heading whose paragraph style is bold and 14pt yields a heading
+     * where *every* run is bold and 14pt, and re-emitting that gives `# **Heading**` in Markdown
+     * and, worse in RTF/HTML, an inner font-size that overrides the heading's own and visibly
+     * shrinks it. But `# Normal **Bold** Normal` is an author contrasting one word against the
+     * rest, and dropping that would discard real meaning. Only the uniform case is safe.
+     *
+     * Returns false when there is no text to judge, so an empty or image-only node never triggers
+     * suppression.
+     */
+    hasUniformFormatting(node, test) {
+        let sawText = false;
+        const walk = (n) => {
+            if (n.type === 'text') {
+                // Whitespace-only runs carry no visible formatting either way, so they neither
+                // count as evidence nor veto - otherwise a stray unformatted space between two
+                // bold runs would defeat the check on almost every real heading.
+                if (!(n.text || '').trim())
+                    return true;
+                sawText = true;
+                return test(n.formatting);
+            }
+            return (n.children ?? []).every(walk);
+        };
+        const uniform = (node.children ?? []).every(walk);
+        return sawText && uniform;
+    }
     /**
      * Recursively extracts plain text from a node and its children.
      */

package/dist/generators/HtmlGenerator.d.ts

@@ -6,6 +6,14 @@ import { BaseGenerator } from './BaseGenerator.js';
 export declare class HtmlGenerator extends BaseGenerator<'html'> {
     private chartCounter;
     private isSpreadsheetMode;
+    /**
+     * Set while rendering a heading's children, so `formatText` can drop the run-level bold and
+     * font-size the `<hN>` already establishes. See the note there, and the identical flag in
+     * `RtfGenerator`, where the same inherited size actively shrinks the heading.
+     */
+    private inHeading;
+    /** As `inHeading`, but for the inherited font size - see `hasUniformFormatting`. */
+    private headingUniformSize;
     constructor(ast: OfficeParserAST, config?: GeneratorConfig<'html'>);
     /**
      * Generates HTML string from the provided AST.
@@ -24,6 +32,7 @@ export declare class HtmlGenerator extends BaseGenerator<'html'> {
      */
     private tableNestingLevel;
     protected processNodeRecursive(node: OfficeContentNode, processor: (node: OfficeContentNode, childrenOutput: string) => string | Promise<string>, override?: string | boolean | void): Promise<string>;
+    private processNodeRecursiveInner;
     /**
      * Internal processor for individual nodes.
      */

package/dist/generators/HtmlGenerator.js

@@ -88,6 +88,14 @@ function resolveStandalone(standalone) {
 class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
     chartCounter = 0;
     isSpreadsheetMode = false;
+    /**
+     * Set while rendering a heading's children, so `formatText` can drop the run-level bold and
+     * font-size the `<hN>` already establishes. See the note there, and the identical flag in
+     * `RtfGenerator`, where the same inherited size actively shrinks the heading.
+     */
+    inHeading = false;
+    /** As `inHeading`, but for the inherited font size - see `hasUniformFormatting`. */
+    headingUniformSize = false;
     constructor(ast, config) {
         super('html', ast, config);
     }
@@ -502,6 +510,21 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
         // method entirely, so without repeating the check here the signal would be silently
         // inert for this generator - which is exactly how it was missed.
         (0, errorUtils_js_1.checkAbortSignal)(this.config.abortSignal);
+        const wasInHeading = this.inHeading;
+        const wasHeadingSize = this.headingUniformSize;
+        if (node.type === 'heading') {
+            this.inHeading = this.hasUniformFormatting(node, f => f?.bold === true);
+            this.headingUniformSize = this.hasUniformFormatting(node, f => !!f?.size);
+        }
+        try {
+            return await this.processNodeRecursiveInner(node, processor, override);
+        }
+        finally {
+            this.inHeading = wasInHeading;
+            this.headingUniformSize = wasHeadingSize;
+        }
+    }
+    async processNodeRecursiveInner(node, processor, override) {
         // Use pre-evaluated override if provided, otherwise call handleOnNode
         const actualOverride = override !== undefined ? override : await this.handleOnNode(node);
         // Returning false skips the node and its children
@@ -1076,7 +1099,12 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
         let result = this.escape(text);
         const f = node.formatting;
         if (this.config.includeFormatting && f) {
-            if (f.bold)
+            // Inside an `<hN>`, the heading's own styling is authoritative. A run that also carries
+            // bold and a font size - the normal case for ODF, where a heading's paragraph style is
+            // inherited by its runs - would wrap the text in `<b>` the heading already implies and,
+            // worse, in a `<span style="font-size: 14pt">` that *shrinks* the heading to the size
+            // its paragraph style happened to name. See the same suppression in RtfGenerator.
+            if (f.bold && !this.inHeading)
                 result = `<b>${result}</b>`;
             if (f.italic)
                 result = `<i>${result}</i>`;
@@ -1088,7 +1116,9 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
                 result = `<sub>${result}</sub>`;
             if (f.superscript)
                 result = `<sup>${result}</sup>`;
-            const styles = this.getInlineStyles(node);
+            const styles = this.headingUniformSize
+                ? this.getInlineStyles(node, { skipFontSize: true })
+                : this.getInlineStyles(node);
             if (styles) {
                 result = `<span style="${styles}">${result}</span>`;
             }
@@ -1120,7 +1150,7 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
         }
         return result;
     }
-    getInlineStyles(node) {
+    getInlineStyles(node, options = {}) {
         const styles = [];
         // Colors/sizes/fonts/alignments are free strings from an untrusted document;
         // run each through sanitizeCssValue so it can't break out of the style="" attribute
@@ -1154,7 +1184,7 @@ class HtmlGenerator extends BaseGenerator_js_1.BaseGenerator {
                 pushSafe('color', f.color);
             if (f.backgroundColor)
                 pushSafe('background-color', f.backgroundColor);
-            if (f.size)
+            if (f.size && !options.skipFontSize)
                 pushSafe('font-size', f.size);
             if (f.font) {
                 const safeFont = (0, sanitize_js_1.sanitizeCssValue)(f.font);

package/dist/generators/MarkdownGenerator.d.ts

@@ -31,6 +31,18 @@ import { BaseGenerator } from './BaseGenerator.js';
  */
 export declare class MarkdownGenerator extends BaseGenerator<'md'> {
     private isInsideTable;
+    /**
+     * Set while rendering the children of a heading, or the cells of a table's header row.
+     *
+     * Markdown already conveys "this is a heading" with `#` and "this is a header row" with the
+     * separator line, so a run inside one that also carries bold - the normal case for ODF, whose
+     * heading and header-row paragraph styles are bold and are now inherited by their runs - would
+     * render as `# **Heading**` and `| **ITEM** |`. That is redundant rather than wrong, but it
+     * also round-trips back into bold text nodes nested inside a heading, so the noise compounds
+     * on every parse/generate cycle. Emphasis the node type already implies is dropped; every
+     * other formatting flag still comes through.
+     */
+    private inImplicitBold;
     private hoistedContent;
     private collectedAbbreviations;
     private resolvedDialect;
@@ -72,6 +84,7 @@ export declare class MarkdownGenerator extends BaseGenerator<'md'> {
     private optimizeNodes;
     private areFormattingEqual;
     private renderMarkdownTable;
+    private collectNotesFrom;
     private renderMarkdownTableInternal;
     private hasNestedTable;
     private hasColspanOrRowspan;

package/dist/generators/MarkdownGenerator.js

@@ -113,6 +113,18 @@ function resolveFallbackToHtml(fallbackToHtml) {
  */
 class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
     isInsideTable = false;
+    /**
+     * Set while rendering the children of a heading, or the cells of a table's header row.
+     *
+     * Markdown already conveys "this is a heading" with `#` and "this is a header row" with the
+     * separator line, so a run inside one that also carries bold - the normal case for ODF, whose
+     * heading and header-row paragraph styles are bold and are now inherited by their runs - would
+     * render as `# **Heading**` and `| **ITEM** |`. That is redundant rather than wrong, but it
+     * also round-trips back into bold text nodes nested inside a heading, so the noise compounds
+     * on every parse/generate cycle. Emphasis the node type already implies is dropped; every
+     * other formatting flag still comes through.
+     */
+    inImplicitBold = false;
     hoistedContent = [];
     collectedAbbreviations = new Map();
     resolvedDialect;
@@ -245,7 +257,7 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                     let text = (0, sanitize_js_1.markdownEscapeText)(node.text || '');
                     if (this.config.includeFormatting && node.formatting) {
                         const emphasisAsterisk = this.resolvedDialect.emphasisMarker === 'asterisk';
-                        if (node.formatting.bold)
+                        if (node.formatting.bold && !this.inImplicitBold)
                             text = emphasisAsterisk ? `**${text}**` : `__${text}__`;
                         if (node.formatting.italic)
                             text = emphasisAsterisk ? `*${text}*` : `_${text}_`;
@@ -544,7 +556,12 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                     if (!this.resolvedDialect.definitionLists)
                         return `${childrenOutput}\n\n`;
                     return `: ${childrenOutput}\n`;
-                default:
+                case 'chart':
+                case 'drawing':
+                case 'comment':
+                case 'header':
+                case 'footer':
+                case 'slideMaster':
                     return childrenOutput;
             }
         };
@@ -612,14 +629,19 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
         if (typeof override === 'string') {
             return override;
         }
+        const walkedByProcessor = node.type === 'table' || node.type === 'sheet';
+        const wasInImplicitBold = this.inImplicitBold;
+        if (node.type === 'heading' && this.hasUniformFormatting(node, f => f?.bold === true))
+            this.inImplicitBold = true;
         let childrenOutput = '';
-        if (node.children && node.children.length > 0) {
+        if (!walkedByProcessor && node.children && node.children.length > 0) {
             // Optimization: Merge adjacent text nodes with identical formatting
             const optimizedChildren = this.optimizeNodes(node.children);
             for (const child of optimizedChildren) {
                 childrenOutput += await this.processNodeRecursive(child, processor);
             }
         }
+        this.inImplicitBold = wasInImplicitBold;
         // When the dialect has no footnote syntax, a footnote/endnote is inlined right at its
         // reference point instead (see below) - so it must not also be collected into the
         // end-of-document "### Notes" section, or its content would be duplicated.
@@ -627,11 +649,7 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
             const meta = note.metadata;
             return (meta?.noteType === 'footnote' || meta?.noteType === 'endnote') && !this.resolvedDialect.footnotes;
         };
-        if (node.notes && node.notes.length > 0) {
-            if (node.type !== 'slide') {
-                this.collectedNotes.push(...node.notes.filter(note => !isInlinedFootnote(note)));
-            }
-        }
+        this.collectNotesFrom(node);
         let result = await processor(node, childrenOutput);
         if (node.type === 'slide' && node.notes && node.notes.length > 0) {
             for (const note of node.notes) {
@@ -732,46 +750,73 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
         this.isInsideTable = false;
         return result;
     }
+    collectNotesFrom(node) {
+        if (!node.notes || node.notes.length === 0)
+            return;
+        if (node.type === 'slide')
+            return;
+        const isInlinedFootnote = (note) => {
+            const meta = note.metadata;
+            return (meta?.noteType === 'footnote' || meta?.noteType === 'endnote') && !this.resolvedDialect.footnotes;
+        };
+        this.collectedNotes.push(...node.notes.filter(note => !isInlinedFootnote(note)));
+    }
     async renderMarkdownTableInternal(node, processor) {
         let tableOutput = '';
         let maxCols = 0;
         // First pass: Process rows and determine max columns (accounting for colspans)
         const processedRows = [];
         for (const rowNode of (node.children ?? [])) {
-            const override = await this.handleOnNode(rowNode);
-            if (override === false)
-                continue;
-            if (typeof override === 'string') {
-                processedRows.push([override]);
-                continue;
-            }
-            const rowCells = [];
-            let lastCol = -1;
-            if (rowNode.children) {
-                const cellNodes = rowNode.children.filter(c => c.type === 'cell');
-                for (const cellNode of cellNodes) {
-                    const currentCol = cellNode.metadata?.col ?? (lastCol + 1);
-                    // Fill gaps with empty cells
-                    while (lastCol < currentCol - 1) {
-                        rowCells.push(' ');
-                        lastCol++;
-                    }
-                    // Process cell content
-                    let cellContent = await this.processNodeRecursive(cellNode, processor);
-                    // Use <br> fallback only if allowed, otherwise space
-                    const br = this.resolvedFallbackToHtml.cellLineBreaks ? '<br>' : ' ';
-                    cellContent = cellContent.trim().replace(/\n+/g, br).replace(/\|/g, '\\|');
-                    rowCells.push(cellContent);
-                    // Handle colspan by adding empty cells
-                    const colSpan = cellNode.metadata?.colSpan || 1;
-                    for (let i = 1; i < colSpan; i++) {
-                        rowCells.push(' ');
+            // The first row becomes the header row - the `| --- |` separator emitted below marks
+            // it as such - so bold inside it is already implied.
+            const wasInImplicitBold = this.inImplicitBold;
+            if (processedRows.length === 0 && this.hasUniformFormatting(rowNode, f => f?.bold === true))
+                this.inImplicitBold = true;
+            try {
+                const override = await this.handleOnNode(rowNode);
+                if (override === false)
+                    continue;
+                if (typeof override === 'string') {
+                    processedRows.push([override]);
+                    continue;
+                }
+                // After the override checks, not before: a row the caller skipped via `onNode` must not
+                // still contribute its footnote to the end-of-document Notes section, where it would
+                // appear with no `[^id]` marker anywhere in the document pointing at it.
+                // `renderTableAsHtml` gets this right by returning early, so collecting here keeps the
+                // pipe and HTML paths agreeing on what a skipped row means.
+                this.collectNotesFrom(rowNode);
+                const rowCells = [];
+                let lastCol = -1;
+                if (rowNode.children) {
+                    const cellNodes = rowNode.children.filter(c => c.type === 'cell');
+                    for (const cellNode of cellNodes) {
+                        const currentCol = cellNode.metadata?.col ?? (lastCol + 1);
+                        // Fill gaps with empty cells
+                        while (lastCol < currentCol - 1) {
+                            rowCells.push(' ');
+                            lastCol++;
+                        }
+                        // Process cell content
+                        let cellContent = await this.processNodeRecursive(cellNode, processor);
+                        // Use <br> fallback only if allowed, otherwise space
+                        const br = this.resolvedFallbackToHtml.cellLineBreaks ? '<br>' : ' ';
+                        cellContent = cellContent.trim().replace(/\n+/g, br).replace(/\|/g, '\\|');
+                        rowCells.push(cellContent);
+                        // Handle colspan by adding empty cells
+                        const colSpan = cellNode.metadata?.colSpan || 1;
+                        for (let i = 1; i < colSpan; i++) {
+                            rowCells.push(' ');
+                        }
+                        lastCol = currentCol + colSpan - 1;
                     }
-                    lastCol = currentCol + colSpan - 1;
                 }
+                processedRows.push(rowCells);
+                maxCols = Math.max(maxCols, rowCells.length);
+            }
+            finally {
+                this.inImplicitBold = wasInImplicitBold;
             }
-            processedRows.push(rowCells);
-            maxCols = Math.max(maxCols, rowCells.length);
         }
         // Second pass: Build table string with separator
         for (let i = 0; i < processedRows.length; i++) {
@@ -842,6 +887,7 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
             return `<table${alignAttr}>\n${rows}</table>\n`;
         }
         else if (node.type === 'row') {
+            this.collectNotesFrom(node);
             let cells = '';
             if (node.children) {
                 for (const cell of node.children) {
@@ -851,6 +897,7 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
             return `  <tr>\n${cells}  </tr>\n`;
         }
         else if (node.type === 'cell') {
+            this.collectNotesFrom(node);
             const meta = node.metadata;
             const rs = meta?.rowSpan > 1 ? ` rowspan="${meta.rowSpan}"` : '';
             const cs = meta?.colSpan > 1 ? ` colspan="${meta.colSpan}"` : '';
@@ -861,10 +908,16 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                     content += await this.processNodeRecursive(child, async (n, co) => {
                         switch (n.type) {
                             case 'text': {
+                                if (n.metadata) {
+                                    const m = n.metadata;
+                                    if (m.abbreviationTitle) {
+                                        this.collectedAbbreviations.set(n.text || '', m.abbreviationTitle);
+                                    }
+                                }
                                 // Inside HTML table cells, entity-encode angle brackets so cell
                                 // text can't inject a raw tag (e.g. </td><script>).
                                 let text = (0, sanitize_js_1.markdownEscapeText)(n.text || '');
-                                if (n.formatting?.bold)
+                                if (n.formatting?.bold && !this.inImplicitBold)
                                     text = `<b>${text}</b>`;
                                 if (n.formatting?.italic)
                                     text = `<i>${text}</i>`;
@@ -882,7 +935,28 @@ class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
                                 return `<h${level}>${co}</h${level}>`;
                             }
                             case 'table': return await this.renderTableAsHtml(n);
-                            default: return co;
+                            case 'list':
+                            case 'image':
+                            case 'chart':
+                            case 'drawing':
+                            case 'slide':
+                            case 'note':
+                            case 'sheet':
+                            case 'row':
+                            case 'cell':
+                            case 'page':
+                            case 'break':
+                            case 'code':
+                            case 'comment':
+                            case 'header':
+                            case 'footer':
+                            case 'slideMaster':
+                            case 'embed':
+                            case 'admonition':
+                            case 'definitionList':
+                            case 'definitionTerm':
+                            case 'definitionDescription':
+                                return co;
                         }
                     });
                 }

package/dist/generators/RtfGenerator.d.ts

@@ -6,6 +6,19 @@ import { BaseGenerator } from './BaseGenerator.js';
 export declare class RtfGenerator extends BaseGenerator<'rtf'> {
     private colorTable;
     private inTable;
+    /**
+     * Set while rendering a heading's children.
+     *
+     * A heading emits its own `{\\b\\fs44 ...}` wrapper, so a run inside it that also carries bold
+     * and a size - which is now the normal case for ODF, where the heading's paragraph style is
+     * inherited by its runs - would emit a nested `\\fs28` that *overrides* the outer `\\fs44`.
+     * The heading then renders at the body-text size it was styled with rather than at heading
+     * size. Suppressing the inherited weight and size inside a heading keeps the heading's own
+     * wrapper authoritative; every other property (colour, font) still comes through.
+     */
+    private inHeading;
+    /** As `inHeading`, but for the inherited font size - see `hasUniformFormatting`. */
+    private headingUniformSize;
     constructor(ast: OfficeParserAST, config?: GeneratorConfig<'rtf'>);
     generate(): Promise<ConversionResult<'rtf'>>;
     protected processNodeRecursive(node: OfficeContentNode, processor: (node: OfficeContentNode, childrenOutput: string) => Promise<string>): Promise<string>;

package/dist/generators/RtfGenerator.js

@@ -10,6 +10,19 @@ const errorUtils_js_1 = require("../utils/errorUtils.js");
 class RtfGenerator extends BaseGenerator_js_1.BaseGenerator {
     colorTable = [];
     inTable = false;
+    /**
+     * Set while rendering a heading's children.
+     *
+     * A heading emits its own `{\\b\\fs44 ...}` wrapper, so a run inside it that also carries bold
+     * and a size - which is now the normal case for ODF, where the heading's paragraph style is
+     * inherited by its runs - would emit a nested `\\fs28` that *overrides* the outer `\\fs44`.
+     * The heading then renders at the body-text size it was styled with rather than at heading
+     * size. Suppressing the inherited weight and size inside a heading keeps the heading's own
+     * wrapper authoritative; every other property (colour, font) still comes through.
+     */
+    inHeading = false;
+    /** As `inHeading`, but for the inherited font size - see `hasUniformFormatting`. */
+    headingUniformSize = false;
     constructor(ast, config) {
         super('rtf', ast, config);
     }
@@ -68,8 +81,16 @@ class RtfGenerator extends BaseGenerator_js_1.BaseGenerator {
         const wasInTable = this.inTable;
         if (node.type === 'table')
             this.inTable = true;
+        const wasInHeading = this.inHeading;
+        const wasHeadingSize = this.headingUniformSize;
+        if (node.type === 'heading') {
+            this.inHeading = this.hasUniformFormatting(node, f => f?.bold === true);
+            this.headingUniformSize = this.hasUniformFormatting(node, f => !!f?.size);
+        }
         const result = await super.processNodeRecursive(node, processor);
         this.inTable = wasInTable;
+        this.inHeading = wasInHeading;
+        this.headingUniformSize = wasHeadingSize;
         return result;
     }
     async renderBody(ast) {
@@ -98,7 +119,7 @@ class RtfGenerator extends BaseGenerator_js_1.BaseGenerator {
                     if (this.config.includeFormatting && f) {
                         let prefix = '';
                         let suffix = '';
-                        if (f.bold) {
+                        if (f.bold && !this.inHeading) {
                             prefix += '\\b ';
                             suffix = '\\b0 ' + suffix;
                         }
@@ -127,7 +148,7 @@ class RtfGenerator extends BaseGenerator_js_1.BaseGenerator {
                             const idx = this.getColorIndex(f.backgroundColor);
                             prefix += `\\highlight${idx + 1} `;
                         }
-                        if (f.size) {
+                        if (f.size && !this.headingUniformSize) {
                             let pt = 12; // default
                             const val = parseFloat(f.size);
                             if (!isNaN(val)) {