officeparser 7.4.0 → 7.5.1

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)) {

package/dist/index.d.ts

@@ -51,10 +51,10 @@
 import { OfficeParser } from './OfficeParser.js';
 import { OfficeGenerator } from './OfficeGenerator.js';
 import { OfficeConverter } from './OfficeConverter.js';
-import { OfficeParserConfig, OfficeParserAST, OfficeContentNode, OfficeAttachment, OfficeMetadata, TextFormatting, SupportedFileType, OfficeContentNodeType, OfficeMimeType, SlideMetadata, SheetMetadata, HeadingMetadata, ListMetadata, CellMetadata, ImageMetadata, PageMetadata, ContentMetadata, BreakMetadata, GeneratorConfig, SupportedDestination, UniversalGeneratorFormat, ChunkingConfig, ChunkingStrategy, FixedSizeChunkingConfig, DocumentStructureChunkingConfig, SemanticChunkingConfig, OfficeChunk, OfficeConverterConfig, OfficeErrorType, OfficeWarningType, ConversionResult } from './types.js';
+import { OfficeParserConfig, OfficeParserAST, OfficeContentNode, OfficeAttachment, OfficeMetadata, TextFormatting, SupportedFileType, OfficeContentNodeType, OfficeMimeType, SlideMetadata, SheetMetadata, HeadingMetadata, ListMetadata, CellMetadata, ImageMetadata, PageMetadata, ContentMetadata, BreakMetadata, GeneratorConfig, SupportedDestination, UniversalGeneratorFormat, ChunkingConfig, ChunkingStrategy, FixedSizeChunkingConfig, DocumentStructureChunkingConfig, SemanticChunkingConfig, OfficeChunk, OfficeConverterConfig, OfficeErrorType, OfficeWarningType, OfficeError, ConversionResult } from './types.js';
 declare const parseOffice: typeof OfficeParser.parseOffice;
 declare const terminateOcr: typeof OfficeParser.terminateOcr;
 declare const convert: typeof OfficeConverter.convert;
 declare const generate: typeof OfficeGenerator.generate;
-export { OfficeParser, parseOffice, terminateOcr, OfficeParserConfig, OfficeParserAST, OfficeContentNode, OfficeAttachment, OfficeMetadata, TextFormatting, SupportedFileType, OfficeContentNodeType, OfficeMimeType, SlideMetadata, SheetMetadata, HeadingMetadata, ListMetadata, CellMetadata, ImageMetadata, PageMetadata, ContentMetadata, BreakMetadata, OfficeGenerator, GeneratorConfig, SupportedDestination, UniversalGeneratorFormat, ChunkingConfig, ChunkingStrategy, FixedSizeChunkingConfig, DocumentStructureChunkingConfig, SemanticChunkingConfig, OfficeChunk, OfficeConverter, OfficeConverterConfig, convert, generate, OfficeErrorType, OfficeWarningType, ConversionResult, };
+export { OfficeParser, parseOffice, terminateOcr, OfficeParserConfig, OfficeParserAST, OfficeContentNode, OfficeAttachment, OfficeMetadata, TextFormatting, SupportedFileType, OfficeContentNodeType, OfficeMimeType, SlideMetadata, SheetMetadata, HeadingMetadata, ListMetadata, CellMetadata, ImageMetadata, PageMetadata, ContentMetadata, BreakMetadata, OfficeGenerator, GeneratorConfig, SupportedDestination, UniversalGeneratorFormat, ChunkingConfig, ChunkingStrategy, FixedSizeChunkingConfig, DocumentStructureChunkingConfig, SemanticChunkingConfig, OfficeChunk, OfficeConverter, OfficeConverterConfig, convert, generate, OfficeErrorType, OfficeWarningType, OfficeError, ConversionResult, };
 export default OfficeParser;

package/dist/officeparser.browser.d.ts

@@ -41,6 +41,12 @@ export declare enum OfficeErrorType {
 	ZIP_ENTRY_INVALID_SIZE = "ZIP_ENTRY_INVALID_SIZE",
 	/** ZIP uncompressed size limit exceeded */
 	ZIP_SIZE_LIMIT_EXCEEDED = "ZIP_SIZE_LIMIT_EXCEEDED",
+	/** ZIP data yielded no readable entries (corrupt, truncated, or not a ZIP archive) */
+	ZIP_NO_ENTRIES_FOUND = "ZIP_NO_ENTRIES_FOUND",
+	/** ZIP data is truncated: the End of Central Directory record is absent */
+	ZIP_TRUNCATED = "ZIP_TRUNCATED",
+	/** A readable ZIP archive is missing the part its document format requires */
+	REQUIRED_PART_MISSING = "REQUIRED_PART_MISSING",
 	/** Document element/structure nesting exceeded the safe recursion depth */
 	MAX_NESTING_DEPTH_EXCEEDED = "MAX_NESTING_DEPTH_EXCEEDED",
 	/** Embedding call timed out */
@@ -90,7 +96,11 @@ export declare enum OfficeWarningType {
 	/** A metadata override could not be represented in the destination format's vocabulary */
 	METADATA_NOT_REPRESENTABLE = "METADATA_NOT_REPRESENTABLE",
 	/** A styleMap output.tag was not an allowed element name and was ignored */
-	INVALID_STYLE_MAP_TAG = "INVALID_STYLE_MAP_TAG"
+	INVALID_STYLE_MAP_TAG = "INVALID_STYLE_MAP_TAG",
+	/** A workbook archive contains no worksheet parts (chartsheet-only workbooks are legitimate) */
+	NO_WORKSHEETS_FOUND = "NO_WORKSHEETS_FOUND",
+	/** A presentation archive contains no slides (a zero-slide presentation is legitimate) */
+	NO_SLIDES_FOUND = "NO_SLIDES_FOUND"
 }
 /**
  * Consolidated timeout settings for OCR operations.
@@ -463,6 +473,29 @@ export interface OfficeIssue {
 	/** Optional additional context or original error object. */
 	details?: any;
 }
+/**
+ * An Error thrown by OfficeParser, carrying the structured issue that produced it.
+ *
+ * Catching code can branch on `error.officeIssue.code`, the same stable enum used for warnings,
+ * instead of matching against message text. Errors that originate outside the library (and
+ * `AbortError`, which is deliberately re-thrown untouched so cancellation stays detectable via
+ * `error.name`) do not carry this property, hence the optional marker.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *     await parseOffice(buffer, { fileType: 'docx' });
+ * } catch (err) {
+ *     if ((err as OfficeError).officeIssue?.code === OfficeErrorType.REQUIRED_PART_MISSING) {
+ *         // the archive is readable, but it is not a docx
+ *     }
+ * }
+ * ```
+ */
+export interface OfficeError extends Error {
+	/** The structured issue this error was created from. */
+	officeIssue?: OfficeIssue;
+}
 /**
  * The result of a document conversion operation.
  */