@gmickel/gno 1.46.0 → 2.1.0

package/vendor/converters/officeparser/dist/types.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfficeWarningType = exports.OfficeErrorType = void 0;
+/**
+ * Standard error types for OfficeParser.
+ * Use these to identify the kind of error being reported.
+ */
+var OfficeErrorType;
+(function (OfficeErrorType) {
+    /** Unsupported file extension */
+    OfficeErrorType["EXTENSION_UNSUPPORTED"] = "EXTENSION_UNSUPPORTED";
+    /** Unsupported output generator format */
+    OfficeErrorType["FORMAT_UNSUPPORTED"] = "FORMAT_UNSUPPORTED";
+    /** File appears to be corrupted or malformed */
+    OfficeErrorType["FILE_CORRUPTED"] = "FILE_CORRUPTED";
+    /** File could not be found at the specified path */
+    OfficeErrorType["FILE_DOES_NOT_EXIST"] = "FILE_DOES_NOT_EXIST";
+    /** Specified location/directory is not reachable or is a directory */
+    OfficeErrorType["LOCATION_NOT_FOUND"] = "LOCATION_NOT_FOUND";
+    /** Arguments passed to the function are missing or invalid */
+    OfficeErrorType["IMPROPER_ARGUMENTS"] = "IMPROPER_ARGUMENTS";
+    /** Error occurred while reading or processing file buffers */
+    OfficeErrorType["IMPROPER_BUFFERS"] = "IMPROPER_BUFFERS";
+    /** Input type is not a supported type (string, Buffer, ArrayBuffer, Uint8Array) */
+    OfficeErrorType["INVALID_INPUT"] = "INVALID_INPUT";
+    /** PDF worker source is missing (required in browser) */
+    OfficeErrorType["PDF_WORKER_MISSING"] = "PDF_WORKER_MISSING";
+    /** Attempted to use Node.js-only features in a browser environment */
+    OfficeErrorType["FEATURE_NOT_SUPPORTED_IN_BROWSER"] = "FEATURE_NOT_SUPPORTED_IN_BROWSER";
+    /** Style mapping string is malformed */
+    OfficeErrorType["INVALID_STYLE_MAPPING"] = "INVALID_STYLE_MAPPING";
+    /** Selector in style mapping is invalid */
+    OfficeErrorType["INVALID_SELECTOR"] = "INVALID_SELECTOR";
+    /** Output mapping in style mapping is invalid */
+    OfficeErrorType["INVALID_OUTPUT_MAPPING"] = "INVALID_OUTPUT_MAPPING";
+    /** Semantic chunking strategy is selected but no embedding function is provided */
+    OfficeErrorType["MISSING_EMBEDDING_FUNCTION"] = "MISSING_EMBEDDING_FUNCTION";
+    /** The operation was aborted */
+    OfficeErrorType["OPERATION_ABORTED"] = "OPERATION_ABORTED";
+    /** ZIP entry count exceeds limit */
+    OfficeErrorType["ZIP_ENTRY_COUNT_LIMIT_EXCEEDED"] = "ZIP_ENTRY_COUNT_LIMIT_EXCEEDED";
+    /** ZIP entry missing a valid declared size */
+    OfficeErrorType["ZIP_ENTRY_INVALID_SIZE"] = "ZIP_ENTRY_INVALID_SIZE";
+    /** ZIP uncompressed size limit exceeded */
+    OfficeErrorType["ZIP_SIZE_LIMIT_EXCEEDED"] = "ZIP_SIZE_LIMIT_EXCEEDED";
+    /** ZIP data yielded no readable entries (corrupt, truncated, or not a ZIP archive) */
+    OfficeErrorType["ZIP_NO_ENTRIES_FOUND"] = "ZIP_NO_ENTRIES_FOUND";
+    /** ZIP data is truncated: the End of Central Directory record is absent */
+    OfficeErrorType["ZIP_TRUNCATED"] = "ZIP_TRUNCATED";
+    /** A readable ZIP archive is missing the part its document format requires */
+    OfficeErrorType["REQUIRED_PART_MISSING"] = "REQUIRED_PART_MISSING";
+    /** Document element/structure nesting exceeded the safe recursion depth */
+    OfficeErrorType["MAX_NESTING_DEPTH_EXCEEDED"] = "MAX_NESTING_DEPTH_EXCEEDED";
+    /** Embedding call timed out */
+    OfficeErrorType["EMBEDDING_TIMEOUT"] = "EMBEDDING_TIMEOUT";
+})(OfficeErrorType || (exports.OfficeErrorType = OfficeErrorType = {}));
+/**
+ * Standard warning types for OfficeParser.
+ * Use these for reporting non-fatal issues or performance tips.
+ */
+var OfficeWarningType;
+(function (OfficeWarningType) {
+    /** Performance advice (e.g., Rosetta translation on Mac) */
+    OfficeWarningType["PERFORMANCE_TIP"] = "PERFORMANCE_TIP";
+    /** OCR processing failed for an attachment */
+    OfficeWarningType["OCR_FAILED"] = "OCR_FAILED";
+    /** Extraction of structured chart data failed */
+    OfficeWarningType["CHART_DATA_EXTRACTION_FAILED"] = "CHART_DATA_EXTRACTION_FAILED";
+    /** Automatic worker path failed, falling back to CDN */
+    OfficeWarningType["PDF_WORKER_FALLBACK"] = "PDF_WORKER_FALLBACK";
+    /** General attachment extraction failure */
+    OfficeWarningType["ATTACHMENT_EXTRACTION_FAILED"] = "ATTACHMENT_EXTRACTION_FAILED";
+    /** Failed to load a specific page in a multi-page document */
+    OfficeWarningType["PAGE_LOAD_FAILED"] = "PAGE_LOAD_FAILED";
+    /** Failed to load a required dynamic dependency */
+    OfficeWarningType["DEPENDENCY_LOAD_FAILED"] = "DEPENDENCY_LOAD_FAILED";
+    /** Failed to extract images from a source */
+    OfficeWarningType["IMAGE_EXTRACTION_FAILED"] = "IMAGE_EXTRACTION_FAILED";
+    /** Failed to extract annotations from a document */
+    OfficeWarningType["ANNOTATION_EXTRACTION_FAILED"] = "ANNOTATION_EXTRACTION_FAILED";
+    /** Failed to process an extracted image bitmap */
+    OfficeWarningType["IMAGE_PROCESSING_FAILED"] = "IMAGE_PROCESSING_FAILED";
+    /** Warning about limitations of browser-based generation */
+    OfficeWarningType["BROWSER_GENERATION_LIMITATION"] = "BROWSER_GENERATION_LIMITATION";
+    /** Specified sheet range in Excel/ODS export was not found */
+    OfficeWarningType["SHEET_RANGE_NOT_FOUND"] = "SHEET_RANGE_NOT_FOUND";
+    /** Buffer content type does not match the provided or expected file extension */
+    OfficeWarningType["BUFFER_TYPE_MISMATCH"] = "BUFFER_TYPE_MISMATCH";
+    /** Failed to detect file type from buffer due to library error or incompatibility */
+    OfficeWarningType["FILE_TYPE_DETECTION_FAILED"] = "FILE_TYPE_DETECTION_FAILED";
+    /** No chunks were generated for the document given the current strategy */
+    OfficeWarningType["EMPTY_CHUNK_GENERATED"] = "EMPTY_CHUNK_GENERATED";
+    /** A node was skipped because it only contained whitespace */
+    OfficeWarningType["WHITESPACE_NODE_SKIPPED"] = "WHITESPACE_NODE_SKIPPED";
+    /** The HTML generator containerWidth option is invalid */
+    OfficeWarningType["INVALID_CONTAINER_WIDTH"] = "INVALID_CONTAINER_WIDTH";
+    /** A document's repeated-cell expansion hit the configured cell limit and was truncated */
+    OfficeWarningType["TABLE_CELL_LIMIT_EXCEEDED"] = "TABLE_CELL_LIMIT_EXCEEDED";
+    /** A metadata override could not be represented in the destination format's vocabulary */
+    OfficeWarningType["METADATA_NOT_REPRESENTABLE"] = "METADATA_NOT_REPRESENTABLE";
+    /** A styleMap output.tag was not an allowed element name and was ignored */
+    OfficeWarningType["INVALID_STYLE_MAP_TAG"] = "INVALID_STYLE_MAP_TAG";
+    /** A workbook archive contains no worksheet parts (chartsheet-only workbooks are legitimate) */
+    OfficeWarningType["NO_WORKSHEETS_FOUND"] = "NO_WORKSHEETS_FOUND";
+    /** A presentation archive contains no slides (a zero-slide presentation is legitimate) */
+    OfficeWarningType["NO_SLIDES_FOUND"] = "NO_SLIDES_FOUND";
+})(OfficeWarningType || (exports.OfficeWarningType = OfficeWarningType = {}));

package/vendor/converters/officeparser/dist/utils/astUtils.d.ts

@@ -0,0 +1,16 @@
+import { OfficeAttachment, OfficeAuxiliaryContent, OfficeContentNode, OfficeMetadata, OfficeParserAST, OfficeParserConfig, SupportedFileType } from '../types.js';
+/**
+ * Creates a fully-featured OfficeParserAST object with conversion methods.
+ *
+ * This helper ensures that all ASTs returned by officeParser have the latest
+ * conversion methods (.to()) and maintain backward compatibility (.toText()).
+ *
+ * @param type - The detected file type
+ * @param metadata - Document metadata
+ * @param content - Parsed content nodes
+ * @param attachments - Extracted attachments
+ * @param config - Original parser configuration
+ * @param toTextSync - Synchronous text extraction logic (for backward compatibility)
+ * @returns An object conforming to OfficeParserAST
+ */
+export declare function createAST(type: SupportedFileType, metadata: OfficeMetadata, content: OfficeContentNode[], attachments: OfficeAttachment[], config: OfficeParserConfig, auxiliary: OfficeAuxiliaryContent | undefined, toTextSync: () => string): OfficeParserAST;

package/vendor/converters/officeparser/dist/utils/astUtils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAST = createAST;
+const OfficeGenerator_js_1 = require("../OfficeGenerator.js");
+/**
+ * Creates a fully-featured OfficeParserAST object with conversion methods.
+ *
+ * This helper ensures that all ASTs returned by officeParser have the latest
+ * conversion methods (.to()) and maintain backward compatibility (.toText()).
+ *
+ * @param type - The detected file type
+ * @param metadata - Document metadata
+ * @param content - Parsed content nodes
+ * @param attachments - Extracted attachments
+ * @param config - Original parser configuration
+ * @param toTextSync - Synchronous text extraction logic (for backward compatibility)
+ * @returns An object conforming to OfficeParserAST
+ */
+function createAST(type, metadata, content, attachments, config, auxiliary, toTextSync) {
+    return {
+        config,
+        type,
+        metadata,
+        content,
+        attachments,
+        auxiliary,
+        warnings: [],
+        toText: toTextSync,
+        async to(destination, genConfig) {
+            return OfficeGenerator_js_1.OfficeGenerator.generate(this, destination, genConfig);
+        }
+    };
+}

package/vendor/converters/officeparser/dist/utils/chartUtils.d.ts

@@ -0,0 +1,6 @@
+import { ChartData } from "../types";
+/**
+ * Universal chart data extractor that selects logic based on XML content.
+ * @param xmlBuffer Chart XML buffer
+ */
+export declare const extractChartData: (xmlBuffer: Buffer) => ChartData;

package/vendor/converters/officeparser/dist/utils/chartUtils.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractChartData = void 0;
+const xmlUtils_1 = require("./xmlUtils");
+/**
+ * Extracts a single text element located at:
+ * c:title -> c:tx -> c:rich -> a:p -> a:r -> a:t
+ * OR c:tx -> c:strRef -> c:strCache -> c:pt -> c:v
+ * @param el Chart element
+ * @param tagName The tag to search for (e.g., "c:title", "c:tx")
+ */
+const extractOpenXmlRichText = (el, tagName) => {
+    const target = (el.localName === tagName || el.tagName === tagName) ? el : el.getElementsByTagName(tagName)[0];
+    if (!target)
+        return undefined;
+    // 1. Try c:rich or a:p (standard rich text)
+    const richNodes = target.getElementsByTagName("c:rich");
+    const pNodes = target.getElementsByTagName("a:p");
+    const textContainers = richNodes.length > 0 ? Array.from(richNodes) : Array.from(pNodes);
+    if (textContainers.length > 0) {
+        let acc = "";
+        for (const container of textContainers) {
+            const tNodes = container.getElementsByTagName("a:t");
+            for (let i = 0; i < tNodes.length; i++) {
+                acc += (tNodes[i].textContent || "") + " ";
+            }
+        }
+        if (acc.trim())
+            return acc.trim();
+    }
+    // 2. Try c:v (cached values/strings)
+    const vNode = target.getElementsByTagName("c:v")[0];
+    if (vNode && vNode.textContent) {
+        return vNode.textContent.trim() || undefined;
+    }
+    return undefined;
+};
+/**
+ * Extracts fully structured chart data from OpenXML (PPTX, XLSX) chart XML.
+ * @param xmlBuffer Chart XML buffer
+ */
+const extractOpenXmlChartData = (xmlBuffer) => {
+    const xml = xmlBuffer.toString("utf8");
+    const dom = (0, xmlUtils_1.parseXmlString)(xml);
+    const root = dom.documentElement;
+    if (!root)
+        return { title: undefined, xAxisTitle: undefined, yAxisTitle: undefined, dataSets: [], labels: [], rawTexts: [] };
+    const title = extractOpenXmlRichText(root, "c:title");
+    // Axis titles
+    let xAxisTitle = undefined;
+    let yAxisTitle = undefined;
+    const catAxes = root.getElementsByTagName("c:catAx");
+    if (catAxes.length > 0)
+        xAxisTitle = extractOpenXmlRichText(catAxes[0], "c:title");
+    const valAxes = root.getElementsByTagName("c:valAx");
+    if (valAxes.length > 0)
+        yAxisTitle = extractOpenXmlRichText(valAxes[0], "c:title");
+    // Extract Series (dataSets)
+    const seriesNodes = root.getElementsByTagName("c:ser");
+    const dataSets = [];
+    const sharedLabels = [];
+    for (let i = 0; i < seriesNodes.length; i++) {
+        const ser = seriesNodes[i];
+        // DataSet Name (c:tx)
+        const name = extractOpenXmlRichText(ser, "c:tx");
+        // Values (c:val)
+        const values = [];
+        const valNode = ser.getElementsByTagName("c:val")[0] || ser.getElementsByTagName("c:yVal")[0];
+        if (valNode) {
+            const vNodes = valNode.getElementsByTagName("c:v");
+            for (let j = 0; j < vNodes.length; j++) {
+                const v = vNodes[j].textContent?.trim();
+                if (v)
+                    values.push(v);
+            }
+        }
+        // Point Labels (data labels)
+        const pointLabels = [];
+        const dLbls = ser.getElementsByTagName("c:dLbl");
+        for (let j = 0; j < dLbls.length; j++) {
+            const lbl = extractOpenXmlRichText(dLbls[j], "c:tx");
+            if (lbl)
+                pointLabels.push(lbl);
+        }
+        // Categories (labels) - c:cat or c:xVal
+        const catNode = ser.getElementsByTagName("c:cat")[0] || ser.getElementsByTagName("c:xVal")[0];
+        if (catNode) {
+            const vNodes = catNode.getElementsByTagName("c:v");
+            const localLabels = [];
+            for (let j = 0; j < vNodes.length; j++) {
+                const v = vNodes[j].textContent?.trim();
+                if (v)
+                    localLabels.push(v);
+            }
+            if (localLabels.length > 0 && sharedLabels.length === 0) {
+                sharedLabels.push(...localLabels);
+            }
+        }
+        dataSets.push({ name, values, pointLabels });
+    }
+    // Structured rawTexts: for each dataset: Name -> Labels -> Values
+    const rawTexts = [];
+    for (const ds of dataSets) {
+        if (ds.name)
+            rawTexts.push(ds.name);
+        rawTexts.push(...sharedLabels);
+        rawTexts.push(...ds.values);
+    }
+    return {
+        title,
+        xAxisTitle,
+        yAxisTitle,
+        dataSets,
+        labels: sharedLabels,
+        rawTexts
+    };
+};
+/**
+ * Extracts structured chart data from ODF (ODP, ODS) chart content.xml.
+ * @param xmlBuffer Chart XML buffer
+ */
+const extractOdfChartData = (xmlBuffer) => {
+    const xml = xmlBuffer.toString("utf8");
+    const dom = (0, xmlUtils_1.parseXmlString)(xml);
+    const chart = (0, xmlUtils_1.getElementsByTagName)(dom, "chart:chart")[0] || dom.documentElement;
+    const titleNode = (0, xmlUtils_1.getElementsByTagName)(chart, "chart:title")[0];
+    const title = titleNode ? (0, xmlUtils_1.getElementsByTagName)(titleNode, "text:p")[0]?.textContent || undefined : undefined;
+    const table = (0, xmlUtils_1.getElementsByTagName)(chart, "table:table")[0];
+    const dataSets = [];
+    const labels = [];
+    const rawTexts = [];
+    if (table) {
+        // Chart with embedded data table (common in ODP presentations)
+        let rows = [];
+        const headerRowsNode = (0, xmlUtils_1.getDirectChildren)(table, "table:table-header-rows")[0];
+        if (headerRowsNode) {
+            rows.push(...(0, xmlUtils_1.getDirectChildren)(headerRowsNode, "table:table-row"));
+        }
+        rows.push(...(0, xmlUtils_1.getDirectChildren)(table, "table:table-row"));
+        if (rows.length > 0) {
+            // Header row for series names
+            const headerCells = (0, xmlUtils_1.getDirectChildren)(rows[0], "table:table-cell");
+            for (let j = 1; j < headerCells.length; j++) {
+                const colsRepeated = parseInt(headerCells[j].getAttribute("table:number-columns-repeated") || "1");
+                const name = (0, xmlUtils_1.getDirectChildren)(headerCells[j], "text:p")[0]?.textContent || undefined;
+                for (let k = 0; k < colsRepeated; k++) {
+                    dataSets.push({ name, values: [], pointLabels: [] });
+                }
+            }
+            // Data rows
+            for (let i = 1; i < rows.length; i++) {
+                const dataCells = (0, xmlUtils_1.getDirectChildren)(rows[i], "table:table-cell");
+                if (dataCells.length > 0) {
+                    const label = (0, xmlUtils_1.getDirectChildren)(dataCells[0], "text:p")[0]?.textContent || undefined;
+                    if (label)
+                        labels.push(label);
+                    let dsIdx = 0;
+                    for (let j = 1; j < dataCells.length; j++) {
+                        const colsRepeated = parseInt(dataCells[j].getAttribute("table:number-columns-repeated") || "1");
+                        const val = dataCells[j].getAttribute("office:value") || (0, xmlUtils_1.getDirectChildren)(dataCells[j], "text:p")[0]?.textContent || "";
+                        for (let k = 0; k < colsRepeated; k++) {
+                            if (dataSets[dsIdx]) {
+                                dataSets[dsIdx].values.push(val);
+                            }
+                            dsIdx++;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    else {
+        // Chart with cell references (common in ODS spreadsheets)
+        // Extract series info from chart:series elements
+        const seriesNodes = (0, xmlUtils_1.getElementsByTagName)(chart, "chart:series");
+        for (const series of seriesNodes) {
+            // Series label is in chart:label-cell-address attribute
+            const labelAddr = series.getAttribute("chart:label-cell-address");
+            const valuesAddr = series.getAttribute("chart:values-cell-range-address");
+            // Try to get series name from any text:p in a title
+            let name = undefined;
+            const seriesLabels = (0, xmlUtils_1.getElementsByTagName)(series, "text:p");
+            if (seriesLabels.length > 0) {
+                name = seriesLabels[0].textContent || undefined;
+            }
+            // If no embedded name, use cell address as identifier
+            if (!name && labelAddr) {
+                // Extract just the cell reference part, e.g., "Sheet1.$D$2" -> "D2"
+                const cellRef = labelAddr.split('.').pop()?.replace(/\$/g, '') || labelAddr;
+                name = `Series ${cellRef}`;
+            }
+            // Values cell range can give us some info
+            const dataSet = {
+                name,
+                values: [],
+                pointLabels: []
+            };
+            // Add values address as a hint in rawTexts
+            if (valuesAddr) {
+                dataSet.values.push(`[${valuesAddr}]`);
+            }
+            dataSets.push(dataSet);
+        }
+        // Extract category labels from chart:categories
+        const categories = (0, xmlUtils_1.getElementsByTagName)(chart, "chart:categories")[0];
+        if (categories) {
+            const catRange = categories.getAttribute("table:cell-range-address");
+            if (catRange) {
+                labels.push(`[${catRange}]`);
+            }
+        }
+    }
+    // Axis titles
+    const axes = (0, xmlUtils_1.getElementsByTagName)(dom, "chart:axis");
+    let xAxisTitle = undefined;
+    let yAxisTitle = undefined;
+    for (const axis of axes) {
+        const dimension = axis.getAttribute("chart:dimension");
+        const axisTitleNode = (0, xmlUtils_1.getElementsByTagName)(axis, "chart:title")[0];
+        const axisTitle = axisTitleNode ? (0, xmlUtils_1.getElementsByTagName)(axisTitleNode, "text:p")[0]?.textContent || undefined : undefined;
+        if (dimension === 'x')
+            xAxisTitle = axisTitle;
+        else if (dimension === 'y')
+            yAxisTitle = axisTitle;
+    }
+    // Structured rawTexts: title + series info
+    if (title)
+        rawTexts.push(title);
+    for (const ds of dataSets) {
+        if (ds.name)
+            rawTexts.push(ds.name);
+        rawTexts.push(...labels);
+        rawTexts.push(...ds.values);
+    }
+    return {
+        title,
+        xAxisTitle,
+        yAxisTitle,
+        dataSets,
+        labels,
+        rawTexts
+    };
+};
+/**
+ * Universal chart data extractor that selects logic based on XML content.
+ * @param xmlBuffer Chart XML buffer
+ */
+const extractChartData = (xmlBuffer) => {
+    const head = xmlBuffer.toString("utf8", 0, 500);
+    if (head.includes("urn:oasis:names:tc:opendocument:xmlns:chart:1.0")) {
+        return extractOdfChartData(xmlBuffer);
+    }
+    else {
+        return extractOpenXmlChartData(xmlBuffer);
+    }
+};
+exports.extractChartData = extractChartData;

package/vendor/converters/officeparser/dist/utils/configUtils.d.ts

@@ -0,0 +1,44 @@
+import { FullGeneratorConfig, FullOfficeParserConfig, GeneratorConfig, OfficeParserConfig } from '../types.js';
+/**
+ * Checks if a configuration object is a FullGeneratorConfig.
+ */
+export declare function isFullGeneratorConfig(config: any): config is FullGeneratorConfig;
+/**
+ * Checks if a configuration object is a FullOfficeParserConfig.
+ */
+export declare function isFullParserConfig(config: any): config is FullOfficeParserConfig;
+/**
+ * Resolves a full parser configuration by merging defaults and user-provided overrides.
+ *
+ * The returned object always belongs solely to the caller of this function. That matters
+ * because a parse installs per-call state on the config it is handed, such as the collector
+ * that gathers warnings for one document's `ast.warnings`. Returning the caller's own object
+ * would attach that state to an object they may reuse, so a second parse would append its
+ * warnings to the first document's already-returned AST, and each parse would retain the
+ * previous one's state for as long as the config lived.
+ *
+ * Only the configuration containers are copied. Callbacks and `abortSignal` keep their
+ * identity, since a copy of an `AbortSignal` would no longer be tied to its controller.
+ *
+ * @param userConfig - Optional configuration provided by the user
+ * @returns A fully populated configuration object, owned by the caller
+ */
+export declare function resolveParserConfig(userConfig?: OfficeParserConfig | FullOfficeParserConfig): FullOfficeParserConfig;
+/**
+ * Resolves a full, destination-specific configuration by merging defaults,
+ * AST-level settings, and user-provided overrides.
+ *
+ * As with {@link resolveParserConfig}, the returned object belongs solely to the caller of this
+ * function, so that per-run normalization cannot edit a config the caller still holds.
+ *
+ * @param destination - The target format
+ * @param userConfig - Optional configuration provided by the user
+ * @param astConfig - Optional configuration from the source AST (for inheritance)
+ * @returns A fully populated configuration object, owned by the caller
+ */
+export declare function resolveGeneratorConfig<D extends string>(destination: D, astConfig?: OfficeParserConfig, userConfig?: GeneratorConfig<D> | FullGeneratorConfig): FullGeneratorConfig;
+/**
+ * Validates the containerWidth option for HTML generation.
+ * Can be 'auto', a positive number, or a positive CSS length/percentage string.
+ */
+export declare function isValidContainerWidth(width: any): boolean;