officeparser 6.1.0 → 7.0.0

package/dist/generators/MarkdownGenerator.d.ts

@@ -0,0 +1,59 @@
+import { ConversionResult, GeneratorConfig, OfficeContentNode, OfficeParserAST } from '../types.js';
+import { BaseGenerator } from './BaseGenerator.js';
+/**
+ * Generates Markdown from an AST.
+ *
+ * DESIGN PRINCIPLES:
+ * 1. **Strict Native Preference**: Always utilize native Markdown syntax for features that
+ *    are natively supported (headings, lists, bold/italic, etc.). HTML tags should NEVER
+ *    be used for these features.
+ *
+ * 2. **Fidelity vs. Purity (The `fallbackToHtml` Principle)**:
+ *    - When `fallbackToHtml` is TRUE: The generator prioritizes high-fidelity document
+ *      conversion. It will use HTML tags for features that Markdown cannot natively
+ *      represent (e.g., `<u>` for underline, `<div>` for alignment, `<table>` for
+ *      nested structures or merged cells).
+ *    - When `fallbackToHtml` is FALSE: The generator prioritizes "pure" Markdown.
+ *      Unsupported features are either:
+ *      - **Skipped**: Non-essential formatting like underline, subscript, superscript,
+ *        or text alignment is omitted.
+ *      - **Simplified/Hoisted**: Complex structures like nested tables are hoisted out
+ *        of their parent cells and rendered as separate sequential tables to maintain
+ *        valid Markdown syntax.
+ *
+ * 3. **Consistency**: All similar structural or formatting ideological problems must be
+ *    resolved using these same rules to ensure predictable output.
+ */
+export declare class MarkdownGenerator extends BaseGenerator<'md'> {
+    private isInsideTable;
+    private hoistedContent;
+    constructor(ast: OfficeParserAST, config?: GeneratorConfig<'md'>);
+    /**
+     * Renders anchor tags if HTML fallback is allowed.
+     */
+    private renderAnchors;
+    /**
+     * Generates Markdown string from the provided AST.
+     *
+     * @returns A Markdown string
+     */
+    generate(): Promise<ConversionResult>;
+    /**
+     * Recursively processes nodes and builds output.
+     * Overridden to provide AST optimization (merging adjacent text nodes).
+     */
+    protected processNodeRecursive(node: OfficeContentNode, processor: (node: OfficeContentNode, childrenOutput: string) => string | Promise<string>): Promise<string>;
+    /**
+     * Merges adjacent text nodes with identical formatting and metadata.
+     */
+    private optimizeNodes;
+    private areFormattingEqual;
+    private renderMarkdownTable;
+    private renderMarkdownTableInternal;
+    private hasNestedTable;
+    private hasColspanOrRowspan;
+    /**
+     * Renders a complex table as HTML since Markdown doesn't support nested tables or rowspans.
+     */
+    private renderTableAsHtml;
+}

package/dist/generators/MarkdownGenerator.js

@@ -0,0 +1,481 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MarkdownGenerator = void 0;
+const BaseGenerator_js_1 = require("./BaseGenerator.js");
+/**
+ * Generates Markdown from an AST.
+ *
+ * DESIGN PRINCIPLES:
+ * 1. **Strict Native Preference**: Always utilize native Markdown syntax for features that
+ *    are natively supported (headings, lists, bold/italic, etc.). HTML tags should NEVER
+ *    be used for these features.
+ *
+ * 2. **Fidelity vs. Purity (The `fallbackToHtml` Principle)**:
+ *    - When `fallbackToHtml` is TRUE: The generator prioritizes high-fidelity document
+ *      conversion. It will use HTML tags for features that Markdown cannot natively
+ *      represent (e.g., `<u>` for underline, `<div>` for alignment, `<table>` for
+ *      nested structures or merged cells).
+ *    - When `fallbackToHtml` is FALSE: The generator prioritizes "pure" Markdown.
+ *      Unsupported features are either:
+ *      - **Skipped**: Non-essential formatting like underline, subscript, superscript,
+ *        or text alignment is omitted.
+ *      - **Simplified/Hoisted**: Complex structures like nested tables are hoisted out
+ *        of their parent cells and rendered as separate sequential tables to maintain
+ *        valid Markdown syntax.
+ *
+ * 3. **Consistency**: All similar structural or formatting ideological problems must be
+ *    resolved using these same rules to ensure predictable output.
+ */
+class MarkdownGenerator extends BaseGenerator_js_1.BaseGenerator {
+    isInsideTable = false;
+    hoistedContent = [];
+    constructor(ast, config) {
+        super('md', ast, config);
+    }
+    /**
+     * Renders anchor tags if HTML fallback is allowed.
+     */
+    renderAnchors(metadata) {
+        if (!this.config.mdConfig.fallbackToHtml || this.config.ignoreInternalLinks)
+            return '';
+        const ids = metadata?.anchorIds || [];
+        return ids.map((aid) => `<a id="${this.slugify(aid)}"></a>`).join('');
+    }
+    /**
+     * Generates Markdown string from the provided AST.
+     *
+     * @returns A Markdown string
+     */
+    async generate() {
+        let output = '';
+        // Add Metadata (YAML Front Matter)
+        if (this.ast.metadata) {
+            output += '---\n';
+            if (this.ast.metadata.title)
+                output += `title: "${this.ast.metadata.title}"\n`;
+            if (this.ast.metadata.author)
+                output += `author: "${this.ast.metadata.author}"\n`;
+            if (this.ast.metadata.created)
+                output += `created: ${new Date(this.ast.metadata.created).toISOString()}\n`;
+            if (this.ast.metadata.modified)
+                output += `modified: ${new Date(this.ast.metadata.modified).toISOString()}\n`;
+            if (this.ast.metadata.description)
+                output += `description: "${this.ast.metadata.description}"\n`;
+            if (this.ast.metadata.customProperties) {
+                for (const [key, val] of Object.entries(this.ast.metadata.customProperties)) {
+                    output += `${key}: ${JSON.stringify(val)}\n`;
+                }
+            }
+            output += '---\n\n';
+        }
+        const processor = async (node, childrenOutput) => {
+            // Handle Style Mapping for Markdown using the semantic mapping helper
+            const mapping = this.getSemanticMapping(node);
+            if (mapping) {
+                // Map common HTML tags to Markdown equivalents
+                if (mapping.tag === 'blockquote')
+                    return `> ${childrenOutput}\n\n`;
+                if (mapping.tag === 'code')
+                    return `\`${childrenOutput}\` `;
+                if (mapping.tag === 'pre')
+                    return `\`\`\`\n${childrenOutput}\n\`\`\`\n\n`;
+                const hMatch = mapping.tag.match(/^h([1-6])$/);
+                if (hMatch) {
+                    const level = parseInt(hMatch[1]);
+                    return `${'#'.repeat(level)} ${childrenOutput}\n\n`;
+                }
+            }
+            switch (node.type) {
+                case 'text': {
+                    let text = node.text || '';
+                    if (this.config.includeFormatting && node.formatting) {
+                        if (node.formatting.bold)
+                            text = `**${text}**`;
+                        if (node.formatting.italic)
+                            text = `*${text}*`;
+                        if (node.formatting.strikethrough)
+                            text = `~~${text}~~`;
+                        // Use HTML tags for formatting not natively supported by standard Markdown
+                        if (this.config.mdConfig.fallbackToHtml) {
+                            if (node.formatting.underline)
+                                text = `<u>${text}</u>`;
+                            if (node.formatting.subscript)
+                                text = `<sub>${text}</sub>`;
+                            if (node.formatting.superscript)
+                                text = `<sup>${text}</sup>`;
+                        }
+                    }
+                    const meta = node.metadata;
+                    if (meta?.link) {
+                        const isInternal = meta.linkType !== 'external';
+                        if (!this.config.ignoreInternalLinks || !isInternal) {
+                            let link = meta.link;
+                            // Slugify internal link targets to match heading IDs if generating IDs
+                            if (isInternal && link.startsWith('#') && (this.config.generateIds || this.config.mdConfig.fallbackToHtml)) {
+                                const target = link.substring(1);
+                                link = '#' + this.slugify(target);
+                            }
+                            text = `[${text}](${link})`;
+                        }
+                    }
+                    return text;
+                }
+                case 'heading': {
+                    const meta = node.metadata;
+                    const level = Math.min(Math.max(meta?.level || 1, 1), 6);
+                    const prefix = '#'.repeat(level) + ' ';
+                    let id = '';
+                    let remainingAnchors = [];
+                    if (!this.config.ignoreInternalLinks && meta?.anchorIds && meta.anchorIds.length > 0) {
+                        const ids = [...meta.anchorIds];
+                        const lastId = ids.pop();
+                        // Slugify the explicit ID to ensure it's a valid Markdown identifier
+                        id = ` {#${this.slugify(lastId)}}`;
+                        remainingAnchors = ids;
+                    }
+                    else if (this.config.generateIds) {
+                        id = ` {#${this.slugify(this.getNodeText(node))}}`;
+                    }
+                    const anchors = remainingAnchors.map(aid => `<a name="${aid}"></a>`).join('');
+                    let content = `${prefix}${childrenOutput}${id}`;
+                    // Alignment fallback via HTML div/p
+                    if (this.config.mdConfig.fallbackToHtml && meta?.alignment && meta.alignment !== 'left') {
+                        // Use extra newlines to ensure Markdown inside the div is parsed
+                        content = `<div style="text-align: ${meta.alignment}">\n\n${content}\n\n</div>`;
+                    }
+                    return `${anchors}${anchors ? '\n' : ''}${content}\n\n`;
+                }
+                case 'paragraph': {
+                    const meta = node.metadata;
+                    const anchors = this.renderAnchors(meta);
+                    let content = childrenOutput;
+                    // Alignment fallback via HTML div/p
+                    if (this.config.mdConfig.fallbackToHtml && meta?.alignment && meta.alignment !== 'left') {
+                        content = `<div style="text-align: ${meta.alignment}">${content}</div>`;
+                    }
+                    return childrenOutput ? `${anchors}${content}\n\n` : '';
+                }
+                case 'list': {
+                    const meta = node.metadata;
+                    const indentSpaces = ' '.repeat(4);
+                    const indent = indentSpaces.repeat(meta?.indentation || 0);
+                    const marker = meta?.listType === 'ordered' ? `${(meta.itemIndex ?? 0) + 1}. ` : '- ';
+                    const anchors = this.renderAnchors(meta);
+                    return `${indent}${marker}${anchors}${childrenOutput}\n`;
+                }
+                case 'image': {
+                    if (!this.config.includeImages)
+                        return '';
+                    const meta = node.metadata;
+                    const alt = meta?.altText || 'image';
+                    let src = meta?.url || meta?.attachmentName || '';
+                    // Resolve attachment to data URI if no external URL is provided
+                    if (!meta?.url && meta?.attachmentName && this.ast) {
+                        const attachment = this.ast.attachments.find(a => a.name === meta.attachmentName);
+                        if (attachment) {
+                            src = `data:${attachment.mimeType || 'image/png'};base64,${attachment.data}`;
+                        }
+                    }
+                    const anchors = this.renderAnchors(meta);
+                    return `${anchors}${anchors ? '\n' : ''}![${alt}](${src})`;
+                }
+                case 'table': {
+                    const anchors = this.renderAnchors(node.metadata);
+                    const tableOutput = await this.renderMarkdownTable(node, processor);
+                    return `${anchors}${anchors ? '\n' : ''}${tableOutput}`;
+                }
+                case 'row':
+                case 'cell': {
+                    // These are handled manually in the 'table' case above
+                    return childrenOutput;
+                }
+                case 'break': {
+                    return '\n';
+                }
+                case 'code': {
+                    const meta = node.metadata;
+                    const lang = meta?.language || '';
+                    // Block code if it contains newlines, else inline
+                    if (node.text && node.text.includes('\n')) {
+                        return `\n\`\`\`${lang}\n${node.text}\n\`\`\`\n\n`;
+                    }
+                    else {
+                        return `\`${node.text || ''}\` `;
+                    }
+                }
+                case 'sheet': {
+                    const anchors = this.renderAnchors(node.metadata);
+                    const tableOutput = await this.renderMarkdownTable(node, processor);
+                    return `\n---\n\n${anchors}${anchors ? '\n' : ''}${tableOutput}\n\n`;
+                }
+                case 'slide': {
+                    const anchors = this.renderAnchors(node.metadata);
+                    return `\n---\n\n${anchors}${anchors ? '\n' : ''}${childrenOutput}\n\n`;
+                }
+                case 'page': {
+                    const anchors = this.renderAnchors(node.metadata);
+                    return `\n---\n\n${anchors}${anchors ? '\n' : ''}${childrenOutput}\n\n`;
+                }
+                default:
+                    return childrenOutput;
+            }
+        };
+        const optimizedContent = this.optimizeNodes(this.ast.content);
+        for (let i = 0; i < optimizedContent.length; i++) {
+            const node = optimizedContent[i];
+            const nextNode = optimizedContent[i + 1];
+            let result = await this.processNodeRecursive(node, processor);
+            // Ensure lists and other block elements are separated from non-similar content by a blank line
+            if (nextNode) {
+                const isBothLists = node.type === 'list' && nextNode.type === 'list';
+                if (!isBothLists) {
+                    if (!result.endsWith('\n\n')) {
+                        if (result.endsWith('\n'))
+                            result += '\n';
+                        else
+                            result += '\n\n';
+                    }
+                }
+            }
+            output += result;
+        }
+        return {
+            value: (output + '\n\n' + this.hoistedContent.join('\n\n')).trim(),
+            messages: this.messages
+        };
+    }
+    /**
+     * Recursively processes nodes and builds output.
+     * Overridden to provide AST optimization (merging adjacent text nodes).
+     */
+    async processNodeRecursive(node, processor) {
+        // Allow user to completely override rendering or skip via onNode
+        const override = await this.handleOnNode(node);
+        if (override === false) {
+            return '';
+        }
+        if (typeof override === 'string') {
+            return override;
+        }
+        let childrenOutput = '';
+        if (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);
+            }
+        }
+        return await processor(node, childrenOutput);
+    }
+    /**
+     * Merges adjacent text nodes with identical formatting and metadata.
+     */
+    optimizeNodes(nodes) {
+        if (nodes.length <= 1)
+            return nodes;
+        const result = [];
+        let current = null;
+        for (const node of nodes) {
+            if (node.type === 'text' && current && current.type === 'text' &&
+                this.areFormattingEqual(node.formatting, current.formatting) &&
+                JSON.stringify(node.metadata) === JSON.stringify(current.metadata)) {
+                current.text = (current.text || '') + (node.text || '');
+                if (current.rawContent && node.rawContent)
+                    current.rawContent += node.rawContent;
+            }
+            else {
+                current = { ...node }; // Clone
+                result.push(current);
+            }
+        }
+        return result;
+    }
+    areFormattingEqual(f1, f2) {
+        if (f1 === f2)
+            return true;
+        if (!f1 || !f2)
+            return false;
+        const keys1 = Object.keys(f1);
+        const keys2 = Object.keys(f2);
+        if (keys1.length !== keys2.length)
+            return false;
+        return keys1.every(key => f1[key] === f2[key]);
+    }
+    async renderMarkdownTable(node, processor) {
+        if (!node.children || node.children.length === 0)
+            return '';
+        // If table is complex, nested, or uses merges, fallback to HTML for high fidelity if allowed
+        const isComplex = this.hasNestedTable(node) || this.hasColspanOrRowspan(node);
+        if (this.config.mdConfig.fallbackToHtml && isComplex) {
+            return '\n' + await this.renderTableAsHtml(node) + '\n';
+        }
+        // Handle nested tables in pure Markdown by hoisting them out
+        if (this.isInsideTable && !this.config.mdConfig.fallbackToHtml) {
+            const wasInside = this.isInsideTable;
+            this.isInsideTable = false; // Reset to allow rendering the hoisted table correctly
+            const hoistedId = this.hoistedContent.length + 1;
+            const tableOutput = await this.renderMarkdownTableInternal(node, processor);
+            this.hoistedContent.push(`**Table ${hoistedId} (Hoisted from cell content):**\n${tableOutput}`);
+            this.isInsideTable = wasInside;
+            return `*(See Table ${hoistedId} below)*`;
+        }
+        this.isInsideTable = true;
+        const result = await this.renderMarkdownTableInternal(node, processor);
+        this.isInsideTable = false;
+        return result;
+    }
+    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.config.mdConfig.fallbackToHtml ? '<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;
+                }
+            }
+            processedRows.push(rowCells);
+            maxCols = Math.max(maxCols, rowCells.length);
+        }
+        // Second pass: Build table string with separator
+        for (let i = 0; i < processedRows.length; i++) {
+            const row = processedRows[i];
+            // Pad row with empty cells if it has fewer than maxCols
+            while (row.length < maxCols)
+                row.push(' ');
+            tableOutput += `| ${row.join(' | ')} |\n`;
+            if (i === 0) {
+                // Header separator
+                tableOutput += `| ${Array(maxCols).fill(' --- ').join(' | ')} |\n`;
+            }
+        }
+        return `\n${tableOutput}\n`;
+    }
+    hasNestedTable(node) {
+        if (!node.children)
+            return false;
+        for (const child of node.children) {
+            if (child.type === 'table')
+                return true;
+            if (this.hasNestedTable(child))
+                return true;
+        }
+        return false;
+    }
+    hasColspanOrRowspan(node) {
+        if (!node.children)
+            return false;
+        for (const row of node.children) {
+            if (row.type === 'row' && row.children) {
+                for (const cell of row.children) {
+                    if (cell.type === 'cell') {
+                        const meta = cell.metadata;
+                        if ((meta?.colSpan && meta.colSpan > 1) || (meta?.rowSpan && meta.rowSpan > 1)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Renders a complex table as HTML since Markdown doesn't support nested tables or rowspans.
+     */
+    async renderTableAsHtml(node, override) {
+        if (override === false)
+            return '';
+        if (typeof override === 'string') {
+            if (node.type === 'row')
+                return `  <tr><td colspan="100%">${override}</td></tr>\n`;
+            if (node.type === 'cell')
+                return `<td>${override}</td>`;
+            return override;
+        }
+        if (node.type === 'table') {
+            let rows = '';
+            if (node.children) {
+                for (const row of node.children) {
+                    rows += await this.renderTableAsHtml(row, await this.handleOnNode(row));
+                }
+            }
+            return `<table>\n${rows}</table>\n`;
+        }
+        else if (node.type === 'row') {
+            let cells = '';
+            if (node.children) {
+                for (const cell of node.children) {
+                    cells += await this.renderTableAsHtml(cell, await this.handleOnNode(cell));
+                }
+            }
+            return `  <tr>\n${cells}  </tr>\n`;
+        }
+        else if (node.type === 'cell') {
+            const meta = node.metadata;
+            const rs = meta?.rowSpan > 1 ? ` rowspan="${meta.rowSpan}"` : '';
+            const cs = meta?.colSpan > 1 ? ` colspan="${meta.colSpan}"` : '';
+            let content = '';
+            if (node.children) {
+                // Use a simplified HTML processor for cell content
+                for (const child of this.optimizeNodes(node.children)) {
+                    content += await this.processNodeRecursive(child, async (n, co) => {
+                        switch (n.type) {
+                            case 'text': {
+                                let text = n.text || '';
+                                if (n.formatting?.bold)
+                                    text = `<b>${text}</b>`;
+                                if (n.formatting?.italic)
+                                    text = `<i>${text}</i>`;
+                                if (n.formatting?.underline)
+                                    text = `<u>${text}</u>`;
+                                if (n.formatting?.subscript)
+                                    text = `<sub>${text}</sub>`;
+                                if (n.formatting?.superscript)
+                                    text = `<sup>${text}</sup>`;
+                                return text;
+                            }
+                            case 'paragraph': return `<p>${co}</p>`;
+                            case 'heading': {
+                                const level = n.metadata?.level || 1;
+                                return `<h${level}>${co}</h${level}>`;
+                            }
+                            case 'table': return await this.renderTableAsHtml(n);
+                            default: return co;
+                        }
+                    });
+                }
+            }
+            return `    <td${rs}${cs}>${content}</td>\n`;
+        }
+        return '';
+    }
+}
+exports.MarkdownGenerator = MarkdownGenerator;

package/dist/generators/PdfGenerator.d.ts

@@ -0,0 +1,22 @@
+import { ConversionResult, GeneratorConfig, OfficeParserAST } from '../types.js';
+import { BaseGenerator } from './BaseGenerator.js';
+/**
+ * Generates high-fidelity PDF documents using a headless browser engine.
+ *
+ * Uses an environment-aware strategy:
+ * - Node.js: Uses Puppeteer (peer dependency) for server-side rendering.
+ * - Browser: Leverages native browser print capabilities.
+ */
+export declare class PdfGenerator extends BaseGenerator<'pdf'> {
+    constructor(ast: OfficeParserAST, config?: GeneratorConfig<'pdf'>);
+    generate(): Promise<ConversionResult>;
+    /**
+     * Node.js implementation using Puppeteer.
+     * Uses dynamic import to avoid bundling puppeteer into the library core.
+     */
+    private generateInNode;
+    /**
+     * Browser implementation using hidden iframe and native print.
+     */
+    private generateInBrowser;
+}

package/dist/generators/PdfGenerator.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PdfGenerator = void 0;
+const types_js_1 = require("../types.js");
+const envUtils_js_1 = require("../utils/envUtils.js");
+const BaseGenerator_js_1 = require("./BaseGenerator.js");
+const HtmlGenerator_js_1 = require("./HtmlGenerator.js");
+/**
+ * Generates high-fidelity PDF documents using a headless browser engine.
+ *
+ * Uses an environment-aware strategy:
+ * - Node.js: Uses Puppeteer (peer dependency) for server-side rendering.
+ * - Browser: Leverages native browser print capabilities.
+ */
+class PdfGenerator extends BaseGenerator_js_1.BaseGenerator {
+    constructor(ast, config) {
+        super('pdf', ast, config);
+    }
+    async generate() {
+        // Step 1: Generate high-fidelity HTML as the source for PDF rendering
+        // We reuse the current configuration but ensure standalone mode is on for HTML
+        const htmlGenerator = new HtmlGenerator_js_1.HtmlGenerator(this.ast, {
+            ...this.config,
+            htmlConfig: { ...this.config.htmlConfig, standalone: true },
+            mdConfig: undefined,
+            chunksConfig: undefined,
+            csvConfig: undefined,
+            textConfig: undefined,
+            pdfConfig: undefined,
+            rtfConfig: undefined,
+        });
+        const htmlResult = await htmlGenerator.generate();
+        const html = typeof htmlResult.value === 'string' ? htmlResult.value : '';
+        // Step 2: Render to PDF based on environment
+        if (envUtils_js_1.isBrowser) {
+            return this.generateInBrowser(html);
+        }
+        else {
+            return this.generateInNode(html);
+        }
+    }
+    /**
+     * Node.js implementation using Puppeteer.
+     * Uses dynamic import to avoid bundling puppeteer into the library core.
+     */
+    async generateInNode(html) {
+        try {
+            // Dynamic import for peer dependency
+            // @ts-ignore
+            const puppeteerModule = await import('puppeteer');
+            const puppeteer = puppeteerModule.default || puppeteerModule;
+            const launchOptions = { ...this.config.pdfConfig.launchOptions };
+            // Handle Apple Silicon / Rosetta performance warning and binary detection
+            const isMac = process.platform === 'darwin';
+            const isX64 = process.arch === 'x64';
+            let isRosetta = false;
+            if (isMac && isX64) {
+                try {
+                    const { execSync } = await import('child_process');
+                    isRosetta = execSync('sysctl -n hw.optional.arm64', { stdio: 'pipe' }).toString().trim() === '1';
+                }
+                catch (e) {
+                    // Ignore errors in detection
+                }
+            }
+            if (isRosetta) {
+                this.warn(types_js_1.OfficeWarningType.PERFORMANCE_TIP, "You are running on Apple Silicon using an x64 Node.js installation. PDF generation will be significantly faster (avoiding Rosetta translation) if you switch to a native arm64 Node.js version.");
+            }
+            // Note: We are no longer suppressing the Puppeteer 'Degraded performance' warning here
+            // to ensure transparency about the environment state. Programmatically fixing this
+            // would require force-downloading a ~300MB arm64 browser binary or switching to 
+            // a system-installed Chrome, both of which are too intrusive for a library.
+            const browser = await puppeteer.launch(launchOptions);
+            const page = await browser.newPage();
+            // Set content and wait for network/assets to load
+            await page.setContent(html, { waitUntil: 'networkidle0' });
+            const pdfConfig = this.config.pdfConfig;
+            const pdfBuffer = await page.pdf({
+                format: pdfConfig.format,
+                width: pdfConfig.width,
+                height: pdfConfig.height,
+                landscape: pdfConfig.landscape,
+                printBackground: pdfConfig.printBackground,
+                scale: pdfConfig.scale,
+                margin: pdfConfig.margin,
+                displayHeaderFooter: pdfConfig.displayHeaderFooter,
+                headerTemplate: pdfConfig.headerTemplate,
+                footerTemplate: pdfConfig.footerTemplate,
+            });
+            await browser.close();
+            return {
+                value: new Uint8Array(pdfBuffer),
+                messages: this.messages
+            };
+        }
+        catch (err) {
+            this.warn(types_js_1.OfficeWarningType.DEPENDENCY_LOAD_FAILED, `puppeteer. Please install it with 'npm install puppeteer'. Error: ${err.message}`);
+            return {
+                value: '',
+                messages: this.messages
+            };
+        }
+    }
+    /**
+     * Browser implementation using hidden iframe and native print.
+     */
+    async generateInBrowser(html) {
+        this.warn(types_js_1.OfficeWarningType.BROWSER_GENERATION_LIMITATION, "Browser-based PDF generation triggered. For automated 'Save as PDF' without user interaction, we recommend using 'html2pdf.js' as a custom generator hook.");
+        // In a browser environment, we return the HTML and suggest using window.print()
+        // Or we could trigger a print dialog immediately if desired, 
+        // but returning the string allows the user to decide where to inject it.
+        return {
+            value: html,
+            messages: this.messages
+        };
+    }
+}
+exports.PdfGenerator = PdfGenerator;