@gmickel/gno 1.45.1 → 2.0.0

package/vendor/converters/officeparser/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<'pdf'>>;
+    /**
+     * 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/vendor/converters/officeparser/dist/generators/PdfGenerator.js

@@ -0,0 +1,194 @@
+"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 errorUtils_js_1 = require("../utils/errorUtils.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,
+            // Force sourceAttributes off: those data-* attributes are wire-format plumbing for
+            // structured consumers and change the mermaid shape's rendered appearance, neither of
+            // which belongs in a printed PDF.
+            htmlConfig: { ...this.config.htmlConfig, standalone: true, sourceAttributes: false },
+        });
+        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) {
+        const signal = this.config.abortSignal;
+        if (signal?.aborted) {
+            throw (0, errorUtils_js_1.getAbortError)();
+        }
+        let browser;
+        const onAbort = async () => {
+            if (browser) {
+                try {
+                    await browser.close();
+                }
+                catch (e) {
+                    // ignore
+                }
+            }
+        };
+        if (signal) {
+            signal.addEventListener('abort', onAbort);
+        }
+        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.
+            browser = await puppeteer.launch(launchOptions);
+            const page = await browser.newPage();
+            // Harden against SSRF: the HTML being rendered is derived from an untrusted
+            // document, and `networkidle0` would otherwise fetch every URL it references
+            // (external images, stylesheets, etc.) from this host — reaching internal
+            // services or a cloud metadata endpoint (169.254.169.254). Intercept requests
+            // and allow only inline data/blob URIs and the configured chart CDN; abort every
+            // other remote fetch.
+            const allowedHosts = new Set();
+            try {
+                const chartSrc = this.config.htmlConfig?.chartJsSrc;
+                if (chartSrc)
+                    allowedHosts.add(new URL(chartSrc).host);
+            }
+            catch { /* no or invalid chart CDN configured */ }
+            let blockedRemoteResource = false;
+            await page.setRequestInterception(true);
+            page.on('request', (req) => {
+                const url = req.url();
+                if (url.startsWith('data:') || url.startsWith('blob:') || url.startsWith('about:')) {
+                    return req.continue().catch(() => { });
+                }
+                try {
+                    if (allowedHosts.has(new URL(url).host)) {
+                        return req.continue().catch(() => { });
+                    }
+                }
+                catch { /* unparseable URL — fall through and block */ }
+                blockedRemoteResource = true;
+                return req.abort().catch(() => { });
+            });
+            const pdfConfig = this.config.pdfConfig;
+            const timeout = pdfConfig.timeout;
+            if (timeout !== undefined && timeout > 0) {
+                page.setDefaultTimeout(timeout);
+                page.setDefaultNavigationTimeout(timeout);
+            }
+            // Set content and wait for network/assets to load
+            await page.setContent(html, { waitUntil: 'networkidle0' });
+            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();
+            browser = null;
+            if (blockedRemoteResource) {
+                this.warn(types_js_1.OfficeWarningType.BROWSER_GENERATION_LIMITATION, 'One or more remote resources referenced by the document were blocked during PDF rendering to prevent server-side request forgery (SSRF). Only inline images and the configured chart CDN are loaded.');
+            }
+            return {
+                value: new Uint8Array(pdfBuffer),
+                messages: this.messages
+            };
+        }
+        catch (err) {
+            if (browser) {
+                try {
+                    await browser.close();
+                }
+                catch (e) {
+                    // ignore
+                }
+                browser = null;
+            }
+            if (signal?.aborted) {
+                throw (0, errorUtils_js_1.getAbortError)();
+            }
+            if (err.message && (err.message.includes('timeout') || err.message.includes('Timeout'))) {
+                this.warn(types_js_1.OfficeWarningType.PAGE_LOAD_FAILED, `PDF generation timed out: ${err.message}`);
+            }
+            else {
+                this.warn(types_js_1.OfficeWarningType.DEPENDENCY_LOAD_FAILED, `puppeteer. Please install it with 'npm install puppeteer'. Error: ${err.message}`);
+            }
+            return {
+                value: new Uint8Array(),
+                messages: this.messages
+            };
+        }
+        finally {
+            if (signal) {
+                signal.removeEventListener('abort', onAbort);
+            }
+        }
+    }
+    /**
+     * 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;

package/vendor/converters/officeparser/dist/generators/RtfGenerator.d.ts

@@ -0,0 +1,29 @@
+import { ConversionResult, GeneratorConfig, OfficeContentNode, OfficeParserAST } from '../types.js';
+import { BaseGenerator } from './BaseGenerator.js';
+/**
+ * Generates high-fidelity RTF (Rich Text Format) from an AST.
+ */
+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>;
+    private renderBody;
+    private getColorIndex;
+    private isLightColor;
+    private escapeRtf;
+}

package/vendor/converters/officeparser/dist/generators/RtfGenerator.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RtfGenerator = void 0;
+const sanitize_js_1 = require("../utils/sanitize.js");
+const BaseGenerator_js_1 = require("./BaseGenerator.js");
+const errorUtils_js_1 = require("../utils/errorUtils.js");
+/**
+ * Generates high-fidelity RTF (Rich Text Format) from an AST.
+ */
+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);
+    }
+    async generate() {
+        this.colorTable = [];
+        // We first process all nodes to collect colors and analyze structure
+        const bodyContent = await this.renderBody(this.ast);
+        let output = '{\\rtf1\\ansi\\uc1\\deff0\n';
+        // 1. Info Group (Metadata)
+        const meta = this.effectiveMetadata;
+        if (this.config.renderMetadata && meta) {
+            // RTF's \info group is a fixed set of control words with no slot for caller-defined keys.
+            this.warnUnrepresentableCustomMetadata('RTF');
+            output += '{\\info';
+            if (meta.title)
+                output += `{\\title ${this.escapeRtf(meta.title)}}`;
+            if (meta.author)
+                output += `{\\author ${this.escapeRtf(meta.author)}}`;
+            if (meta.description)
+                output += `{\\comm ${this.escapeRtf(meta.description)}}`;
+            // \subject and \keywords are standard \info destinations, so unlike a caller's
+            // arbitrary custom keys these DO have a home in RTF.
+            if (meta.subject)
+                output += `{\\subject ${this.escapeRtf(meta.subject)}}`;
+            if (meta.keywords)
+                output += `{\\keywords ${this.escapeRtf(meta.keywords)}}`;
+            output += '}\n';
+        }
+        // 2. Font Table
+        output += '{\\fonttbl{\\f0\\fnil\\fcharset0 Arial;}{\\f1\\fnil\\fcharset0 Times New Roman;}}\n';
+        // 3. Color Table
+        if (this.colorTable.length > 0) {
+            output += '{\\colortbl;';
+            for (const hex of this.colorTable) {
+                const r = parseInt(hex.substring(1, 3), 16);
+                const g = parseInt(hex.substring(3, 5), 16);
+                const b = parseInt(hex.substring(5, 7), 16);
+                output += `\\red${r}\\green${g}\\blue${b};`;
+            }
+            output += '}\n';
+        }
+        // 4. Body
+        output += '\\f0\\fs24\n';
+        output += bodyContent;
+        output += '}';
+        return {
+            value: output,
+            messages: this.messages
+        };
+    }
+    async processNodeRecursive(node, processor) {
+        // Mirrors the check in BaseGenerator.processNodeRecursive. This override replaces that
+        // 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 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) {
+        let body = '';
+        this.inTable = false;
+        const processor = async (node, childrenOutput) => {
+            const mapping = this.getSemanticMapping(node);
+            if (mapping) {
+                if (mapping.tag === 'blockquote') {
+                    const pPr = this.inTable ? '\\pard\\intbl' : '\\pard';
+                    return `${pPr}\\li720\\ri720\\sa120 ${childrenOutput}\\par\n`;
+                }
+                const hMatch = mapping.tag.match(/^h([1-6])$/);
+                if (hMatch) {
+                    const level = parseInt(hMatch[1]);
+                    const fontSize = 24 + (6 - level) * 4;
+                    const pPr = this.inTable ? '\\pard\\intbl' : '\\pard';
+                    return `${pPr}\\s${level}\\sb240\\sa120{\\b\\fs${fontSize} ${childrenOutput}}\\par\n`;
+                }
+            }
+            switch (node.type) {
+                case 'text': {
+                    let text = this.escapeRtf(node.text || '');
+                    const f = node.formatting;
+                    const meta = node.metadata;
+                    if (this.config.includeFormatting && f) {
+                        let prefix = '';
+                        let suffix = '';
+                        if (f.bold && !this.inHeading) {
+                            prefix += '\\b ';
+                            suffix = '\\b0 ' + suffix;
+                        }
+                        if (f.italic) {
+                            prefix += '\\i ';
+                            suffix = '\\i0 ' + suffix;
+                        }
+                        if (f.underline) {
+                            prefix += '\\ul ';
+                            suffix = '\\ul0 ' + suffix;
+                        }
+                        if (f.strikethrough) {
+                            prefix += '\\strike ';
+                            suffix = '\\strike0 ' + suffix;
+                        }
+                        if (f.color) {
+                            // RTF default background is white. Ensure light text without a dark background remains readable.
+                            const isTextLight = this.isLightColor(f.color);
+                            const isBgLight = !f.backgroundColor || this.isLightColor(f.backgroundColor);
+                            if (!(isTextLight && isBgLight)) {
+                                const idx = this.getColorIndex(f.color);
+                                prefix += `\\cf${idx + 1} `;
+                            }
+                        }
+                        if (f.backgroundColor) {
+                            const idx = this.getColorIndex(f.backgroundColor);
+                            prefix += `\\highlight${idx + 1} `;
+                        }
+                        if (f.size && !this.headingUniformSize) {
+                            let pt = 12; // default
+                            const val = parseFloat(f.size);
+                            if (!isNaN(val)) {
+                                if (f.size.includes('in'))
+                                    pt = val * 72;
+                                else if (f.size.includes('cm'))
+                                    pt = val * 28.3465;
+                                else if (f.size.includes('mm'))
+                                    pt = val * 2.83465;
+                                else if (f.size.includes('px'))
+                                    pt = val * 0.75;
+                                else
+                                    pt = val;
+                            }
+                            prefix += `\\fs${Math.round(pt * 2)} `;
+                        }
+                        text = `{\\f0 ${prefix}${text}${suffix}}`;
+                    }
+                    if (meta?.link) {
+                        const isInternal = meta.linkType !== 'external';
+                        if (!this.config.ignoreInternalLinks || !isInternal) {
+                            // Scheme-checked, not merely escaped. escapeRtf neutralizes the field
+                            // metacharacters but says nothing about where the link points, so RTF
+                            // was the one generator that would emit `javascript:` or a `file://`
+                            // /UNC target that HTML and Markdown both reject. On rejection, fall
+                            // through to the bare link text - the same degradation as HTML's
+                            // href="" and Markdown's [text]().
+                            const safeLink = (0, sanitize_js_1.sanitizeRtfUrl)(meta.link);
+                            if (safeLink) {
+                                return `{\\field{\\*\\fldinst{HYPERLINK "${safeLink}"}}{\\fldrslt ${text}}}`;
+                            }
+                        }
+                    }
+                    return text;
+                }
+                case 'heading': {
+                    const meta = node.metadata;
+                    const level = meta?.level || 1;
+                    const fontSize = 24 + (6 - level) * 4;
+                    const pPr = this.inTable ? '\\pard\\intbl' : '\\pard';
+                    return `${pPr}\\s${level}\\sb240\\sa120{\\b\\fs${fontSize} ${childrenOutput}}\\par\n`;
+                }
+                case 'paragraph': {
+                    let pPr = this.inTable ? '\\pard\\intbl' : '\\pard';
+                    pPr += '\\sa120';
+                    if (this.config.includeFormatting && node.metadata) {
+                        const meta = node.metadata;
+                        if (meta.alignment) {
+                            if (meta.alignment === 'center')
+                                pPr += '\\qc';
+                            else if (meta.alignment === 'right')
+                                pPr += '\\qr';
+                            else if (meta.alignment === 'justify')
+                                pPr += '\\qj';
+                        }
+                    }
+                    return `${pPr} ${childrenOutput}\\par\n`;
+                }
+                case 'list': {
+                    const meta = node.metadata;
+                    const level = meta?.indentation || 0;
+                    const indent = (level + 1) * 360;
+                    const isOrdered = meta?.listType === 'ordered';
+                    const marker = isOrdered ? `${(meta.itemIndex ?? 0) + 1}. ` : '\\bullet ';
+                    const listControl = isOrdered ? '\\pndec' : '\\pnbullet';
+                    const pPr = this.inTable ? '\\pard\\intbl' : '\\pard';
+                    return `${pPr}\\li${indent}\\fi-360\\ilvl${level}${listControl} ${marker}${childrenOutput}\\par\n`;
+                }
+                case 'table': {
+                    return `\\pard\\sa0\n${childrenOutput}`;
+                }
+                case 'row': {
+                    const cells = node.children || [];
+                    const pageWidth = 9000; // Standard twips width
+                    const cellWidth = Math.floor(pageWidth / (cells.length || 1));
+                    let cellDefs = '';
+                    for (let i = 0; i < cells.length; i++) {
+                        // Add basic cell borders and calculate width
+                        cellDefs += `\\clbrdrt\\brdrs\\brdrw10\\clbrdrl\\brdrs\\brdrw10\\clbrdrb\\brdrs\\brdrw10\\clbrdrr\\brdrs\\brdrw10\\cellx${(i + 1) * cellWidth}`;
+                    }
+                    return `\\trowd\\trgaph108\\trleft-108${cellDefs}\n${childrenOutput}\\row\n`;
+                }
+                case 'cell': {
+                    return `\\pard\\intbl\\sb60\\sa60 ${childrenOutput}\\cell\n`;
+                }
+                case 'image': {
+                    if (!this.config.includeImages)
+                        return '';
+                    const meta = node.metadata;
+                    const attachmentName = meta?.attachmentName;
+                    const attachment = this.ast.attachments.find(a => a.name === attachmentName);
+                    if (attachment && attachment.data) {
+                        const type = attachment.extension === 'png' ? 'pngblip' : 'jpegblip';
+                        // Convert base64 to hex
+                        const binary = atob(attachment.data);
+                        let hex = '';
+                        for (let i = 0; i < binary.length; i++) {
+                            const h = binary.charCodeAt(i).toString(16);
+                            hex += h.length === 1 ? '0' + h : h;
+                            if (i % 64 === 63)
+                                hex += '\n'; // Add newlines for better RTF readability
+                        }
+                        // Default goals (approx 3 inches wide at 1440 twips per inch)
+                        return `{\\pict\\${type}\\picwgoal4320\\pichgoal3240\n${hex}\n}\n`;
+                    }
+                    return '';
+                }
+                case 'break': {
+                    return node.metadata?.breakType === 'page' ? '\\page\n' : '\\line\n';
+                }
+                case 'embed': {
+                    // RTF has no embed concept - degrade to the URL as plain text rather than
+                    // silently dropping the node (it has no children to fall back to).
+                    const meta = node.metadata;
+                    if (!meta?.url)
+                        return '';
+                    // Rendered as visible text rather than a field, but still a URL a reader may
+                    // copy, so it gets the same scheme policy.
+                    const safeUrl = (0, sanitize_js_1.sanitizeRtfUrl)(meta.url);
+                    if (!safeUrl)
+                        return '';
+                    const pPr = this.inTable ? '\\pard\\intbl' : '\\pard';
+                    return `${pPr}\\sa120 ${safeUrl}\\par\n`;
+                }
+                default:
+                    return childrenOutput;
+            }
+        };
+        for (const node of ast.content) {
+            body += await this.processNodeRecursive(node, processor);
+        }
+        if (this.collectedNotes.length > 0) {
+            body += '\\pard\\sb120\\sa120\\keepn{\\b Notes:}\\par\n';
+            for (const note of this.collectedNotes) {
+                body += await this.processNodeRecursive(note, processor);
+            }
+        }
+        return body;
+    }
+    getColorIndex(hex) {
+        const h = hex.toUpperCase();
+        let idx = this.colorTable.indexOf(h);
+        if (idx === -1) {
+            idx = this.colorTable.length;
+            this.colorTable.push(h);
+        }
+        return idx;
+    }
+    isLightColor(hex) {
+        if (!hex || hex.length !== 7 || !hex.startsWith('#'))
+            return false;
+        const r = parseInt(hex.substring(1, 3), 16);
+        const g = parseInt(hex.substring(3, 5), 16);
+        const b = parseInt(hex.substring(5, 7), 16);
+        if (isNaN(r) || isNaN(g) || isNaN(b))
+            return false;
+        // Simple luminance calculation
+        const luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255;
+        return luminance > 0.8;
+    }
+    escapeRtf(text) {
+        return (0, sanitize_js_1.escapeRtf)(text);
+    }
+}
+exports.RtfGenerator = RtfGenerator;

package/vendor/converters/officeparser/dist/generators/TextGenerator.d.ts

@@ -0,0 +1,13 @@
+import { ConversionResult, GeneratorConfig, OfficeParserAST } from '../types.js';
+import { BaseGenerator } from './BaseGenerator.js';
+/**
+ * Generates plain text from an AST.
+ */
+export declare class TextGenerator extends BaseGenerator<'text'> {
+    constructor(ast: OfficeParserAST, config?: GeneratorConfig<'text'>);
+    /**
+     * Generates plain text by concatenating text content from nodes.
+     */
+    generate(): Promise<ConversionResult<'text'>>;
+    private renderTable;
+}