@gmickel/gno 1.46.0 → 2.1.0

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

@@ -0,0 +1,245 @@
+"use strict";
+/**
+ * Error Handling Utilities
+ *
+ * This module provides centralized error management for the OfficeParser library.
+ * It defines standard error types, messages, and handling logic to ensure
+ * consistent error reporting across all parsers and the main entry point.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkAbortSignal = exports.getAbortError = exports.logWarning = exports.getWrappedError = exports.getOfficeError = exports.getWarningMessage = void 0;
+const types_js_1 = require("../types.js");
+/** Error header prefix for all error messages */
+const ERRORHEADER = "[OfficeParser]: ";
+// `OfficeError` (the public shape callers catch) lives in types.ts alongside `OfficeIssue`.
+// Every error built by getOfficeError is branded with its issue, which serves two purposes:
+// consumers branch on `err.officeIssue.code` instead of matching message text, and
+// getWrappedError recognizes an error it has already reported and prefixed, so it neither
+// reports it twice nor prepends a second header.
+/**
+ * Lookup table for error messages.
+ * Some entries are functions that take parameters to build dynamic messages.
+ */
+const ERROR_MESSAGES = {
+    [types_js_1.OfficeErrorType.EXTENSION_UNSUPPORTED]: (ext) => `Sorry, OfficeParser currently supports docx, pptx, xlsx, odt, odp, ods, pdf, rtf, md, html, csv, epub files only. Create a ticket in Issues on github to add support for ${ext} files. Stay tuned for further updates.`,
+    [types_js_1.OfficeErrorType.FORMAT_UNSUPPORTED]: (format) => `Sorry, OfficeGenerator does not support generating '${format}' files. Supported formats: json, text, md, html, csv, rtf, pdf, chunks, epub.`,
+    [types_js_1.OfficeErrorType.FILE_CORRUPTED]: (filepath) => `Your file ${filepath} seems to be corrupted. If you are sure it is fine, please create a ticket in Issues on github with the file to reproduce error.`,
+    [types_js_1.OfficeErrorType.FILE_DOES_NOT_EXIST]: (filepath) => `File ${filepath} could not be found! Check if the file exists or verify if the relative path to the file is correct from your terminal's location.`,
+    [types_js_1.OfficeErrorType.LOCATION_NOT_FOUND]: (location) => `Entered location ${location} is not reachable! Please make sure that the entered directory location exists. Check relative paths and reenter.`,
+    [types_js_1.OfficeErrorType.IMPROPER_ARGUMENTS]: `Improper arguments`,
+    [types_js_1.OfficeErrorType.IMPROPER_BUFFERS]: `Auto-detection of file type from buffer failed. This can happen if the format lacks magic bytes (like md, html, or csv) or if the detection library is incompatible with your Node.js version. Please provide the 'fileType' hint in your configuration (e.g., { fileType: 'docx' }) to proceed.`,
+    [types_js_1.OfficeErrorType.INVALID_INPUT]: `Invalid input type: Expected a Buffer or a valid file path`,
+    [types_js_1.OfficeErrorType.PDF_WORKER_MISSING]: `Missing PDF worker configuration. PDF parsing in browser environments requires a worker source. Please provide "pdfWorkerSrc" in your configuration.`,
+    [types_js_1.OfficeErrorType.FEATURE_NOT_SUPPORTED_IN_BROWSER]: (feature) => `'${feature}' is not supported in the browser. Browser users must pass file content as Buffer or ArrayBuffer directly.`,
+    [types_js_1.OfficeErrorType.INVALID_STYLE_MAPPING]: (mapping) => `Invalid style mapping string: ${mapping}`,
+    [types_js_1.OfficeErrorType.INVALID_SELECTOR]: (selector) => `Invalid selector: ${selector}`,
+    [types_js_1.OfficeErrorType.INVALID_OUTPUT_MAPPING]: (output) => `Invalid output mapping: ${output}`,
+    [types_js_1.OfficeErrorType.MISSING_EMBEDDING_FUNCTION]: `Semantic chunking requires an "embeddingFunction" to be provided in chunksConfig. This function must accept a string and return a Promise resolving to a number array (vector).`,
+    [types_js_1.OfficeErrorType.OPERATION_ABORTED]: `The operation was aborted.`,
+    [types_js_1.OfficeErrorType.ZIP_ENTRY_COUNT_LIMIT_EXCEEDED]: (limit) => `ZIP entry count exceeds limit (${limit})`,
+    [types_js_1.OfficeErrorType.ZIP_ENTRY_INVALID_SIZE]: `ZIP entry missing a valid declared size`,
+    [types_js_1.OfficeErrorType.ZIP_SIZE_LIMIT_EXCEEDED]: (limit) => `ZIP uncompressed size limit exceeded (${limit} bytes)`,
+    [types_js_1.OfficeErrorType.ZIP_NO_ENTRIES_FOUND]: `No readable entries found in ZIP data. The input is corrupt, truncated, or not a ZIP archive: every ZIP-based document format requires at least one entry.`,
+    [types_js_1.OfficeErrorType.ZIP_TRUNCATED]: `Malformed ZIP data: no End of Central Directory record was found at the end of the input. Either the file was cut off during download or transfer, or extra data follows the archive; in both cases the entries recovered from it cannot be trusted to be the whole document.`,
+    [types_js_1.OfficeErrorType.REQUIRED_PART_MISSING]: (info) => `Your ${info.fileType} file is a readable ZIP archive but is missing its required '${info.part}' part, so it cannot be a valid ${info.fileType} document. The file is corrupt, incomplete, or mislabeled. If you are sure it is fine, please create a ticket in Issues on github with the file to reproduce the error.`,
+    [types_js_1.OfficeErrorType.MAX_NESTING_DEPTH_EXCEEDED]: `Document nesting depth exceeded the safe limit (possible denial-of-service input)`,
+    [types_js_1.OfficeErrorType.EMBEDDING_TIMEOUT]: (timeout) => `Embedding call timed out after ${timeout}ms`
+};
+/**
+ * Lookup table for warning messages.
+ */
+const WARNING_MESSAGES = {
+    [types_js_1.OfficeWarningType.PERFORMANCE_TIP]: (tip) => `⚡️ Performance Tip: ${tip}`,
+    [types_js_1.OfficeWarningType.OCR_FAILED]: (name) => `OCR failed for ${name}:`,
+    [types_js_1.OfficeWarningType.CHART_DATA_EXTRACTION_FAILED]: (path) => `Failed to extract chart data from ${path}:`,
+    [types_js_1.OfficeWarningType.PDF_WORKER_FALLBACK]: `Could not auto-resolve local worker path, falling back to CDN:`,
+    [types_js_1.OfficeWarningType.ATTACHMENT_EXTRACTION_FAILED]: `Error extracting embedded attachments:`,
+    [types_js_1.OfficeWarningType.PAGE_LOAD_FAILED]: (page) => `Error loading page ${page}:`,
+    [types_js_1.OfficeWarningType.DEPENDENCY_LOAD_FAILED]: (dep) => `Failed to load dependency ${dep}:`,
+    [types_js_1.OfficeWarningType.IMAGE_EXTRACTION_FAILED]: (context) => `Error extracting images ${context}:`,
+    [types_js_1.OfficeWarningType.ANNOTATION_EXTRACTION_FAILED]: (page) => `Error extracting annotations from page ${page}:`,
+    [types_js_1.OfficeWarningType.IMAGE_PROCESSING_FAILED]: `Failed to extract from ImageBitmap:`,
+    [types_js_1.OfficeWarningType.BROWSER_GENERATION_LIMITATION]: (msg) => msg,
+    [types_js_1.OfficeWarningType.SHEET_RANGE_NOT_FOUND]: (range) => `No sheets found matching the range: ${range}`,
+    [types_js_1.OfficeWarningType.BUFFER_TYPE_MISMATCH]: (info) => `File content type mismatch: Detected '${info.detected}' but expected/provided '${info.expected}'. Parsing will proceed with '${info.expected}' as requested.`,
+    [types_js_1.OfficeWarningType.FILE_TYPE_DETECTION_FAILED]: `Auto-detection of file type failed. This can happen on older Node.js versions with modern file-type versions. Please provide the 'fileType' hint in the configuration if parsing fails.`,
+    [types_js_1.OfficeWarningType.EMPTY_CHUNK_GENERATED]: (strategy) => `No chunks generated for document. Check if the document content is compatible with the '${strategy}' strategy.`,
+    [types_js_1.OfficeWarningType.WHITESPACE_NODE_SKIPPED]: (nodeType) => `Skipped whitespace-only node of type: ${nodeType}`,
+    [types_js_1.OfficeWarningType.TABLE_CELL_LIMIT_EXCEEDED]: (limit) => `Table cell limit (${limit}) reached while expanding repeated ODF cells/rows; the remaining cells were not materialized. A few hundred bytes of XML can request an unbounded number of cells via table:number-columns-repeated / table:number-rows-repeated, so this is capped. Raise decompressionLimits.maxTableCells if your documents legitimately exceed it.`,
+    [types_js_1.OfficeWarningType.INVALID_CONTAINER_WIDTH]: (val) => `Invalid HTML containerWidth: ${JSON.stringify(val)}. Falling back to "auto". Width must be a positive number, a valid CSS length string (e.g., "900px", "100%", "50vw"), or "auto".`,
+    [types_js_1.OfficeWarningType.METADATA_NOT_REPRESENTABLE]: (info) => `Custom metadata ${info.keys.map(k => `'${k}'`).join(', ')} could not be written to ${info.format} output: the format has a fixed metadata vocabulary with no place for caller-defined keys. The named metadata fields (title, author, etc.) were still applied.`,
+    [types_js_1.OfficeWarningType.NO_WORKSHEETS_FOUND]: `Workbook contains no worksheet parts (xl/worksheets/). If the workbook holds only chartsheets this is expected and there is simply no cell text to extract; otherwise the file may be incomplete.`,
+    [types_js_1.OfficeWarningType.NO_SLIDES_FOUND]: `Presentation contains no slides (ppt/slides/). A legitimately empty presentation produces this too, but if you expected content the file may be incomplete.`,
+    [types_js_1.OfficeWarningType.INVALID_STYLE_MAP_TAG]: (tag) => `styleMap output.tag ${JSON.stringify(tag)} is not an allowed element name and was ignored; the node's default tag was used instead. A tag name is written into both the opening and closing tag, so only a known-safe set of block, heading and inline elements is accepted.`
+};
+/**
+ * Creates a formatted warning message for a specific warning type.
+ *
+ * @param type - The type of warning
+ * @param info - Optional additional information
+ * @returns The formatted warning message string
+ */
+const getWarningMessage = (type, info) => {
+    const msg = WARNING_MESSAGES[type];
+    const message = typeof msg === 'function' ? msg(info) : msg;
+    return message;
+};
+exports.getWarningMessage = getWarningMessage;
+/**
+ * Creates a formatted error message for a specific error type.
+ *
+ * @param type - The type of error
+ * @param info - Optional additional information (e.g., filepath, extension)
+ * @returns The formatted error message string
+ */
+const createOfficeError = (type, info) => {
+    const msg = ERROR_MESSAGES[type];
+    const message = typeof msg === 'function' ? msg(info) : msg;
+    return message;
+};
+/**
+ * Core reporting logic for all issues.
+ * Ensures consistent logging and callback execution.
+ */
+const reportIssue = (issue, config) => {
+    if (config?.onWarning) {
+        config.onWarning(issue);
+    }
+    else if (!config || config.outputErrorToConsole) {
+        const formatted = ERRORHEADER + issue.message;
+        if (issue.type === 'error') {
+            console.error(formatted, issue.details || '');
+        }
+        else {
+            console.warn(formatted, issue.details || '');
+        }
+    }
+};
+/**
+ * Creates, optionally logs to console, and returns a formatted OfficeParser error.
+ *
+ * @param type - The type of error
+ * @param config - Optional parser configuration (checks outputErrorToConsole)
+ * @param info - Optional additional information
+ * @returns The Error object to be thrown
+ */
+const getOfficeError = (type, config, info) => {
+    const message = createOfficeError(type, info);
+    const issue = {
+        type: 'error',
+        code: type,
+        message,
+        details: info
+    };
+    reportIssue(issue, config);
+    const error = new Error(ERRORHEADER + message);
+    // Brand the error with the issue that produced it so getWrappedError can tell an
+    // already-reported, already-prefixed OfficeParser error from a raw third-party one.
+    error.officeIssue = issue;
+    return error;
+};
+exports.getOfficeError = getOfficeError;
+/**
+ * Wraps an existing error with OfficeParser context and performs corruption detection.
+ * Optionally logs the error to console.
+ *
+ * An error already built by {@link getOfficeError} is returned untouched: it carries an
+ * `officeIssue`, meaning it has been reported once and already bears the `[OfficeParser]: `
+ * header. Re-wrapping it would report the same issue a second time, prepend a second header,
+ * and flatten its specific error code to `FILE_CORRUPTED`. This is a marker check on the error
+ * object rather than a test against its message text, so it stays independent of wording.
+ *
+ * **Important**: Do NOT pass AbortErrors to this function. AbortErrors (err.name === 'AbortError')
+ * represent deliberate user cancellation and must be re-thrown as-is from the catch block so that
+ * callers can reliably detect them via `err.name === 'AbortError'` or `err instanceof DOMException`.
+ * This function always returns a plain `new Error(...)`, which would strip the AbortError identity.
+ *
+ * @param error - The original error object
+ * @param config - Parser configuration
+ * @param filePath - Optional file path for context
+ * @returns The wrapped Error object to be thrown
+ */
+const getWrappedError = (error, config, filePath) => {
+    if (error?.officeIssue)
+        return error;
+    let message = error.message || error;
+    let code = types_js_1.OfficeErrorType.FILE_CORRUPTED; // Default for wrapped errors
+    // Detect file corruption from common library error messages
+    if (filePath && (message.includes('end of central directory record') ||
+        message.includes('invalid XML') ||
+        message.includes('Failed to open zip file') ||
+        message.includes('invalid distance too far back'))) {
+        message = createOfficeError(types_js_1.OfficeErrorType.FILE_CORRUPTED, filePath);
+    }
+    const issue = {
+        type: 'error',
+        code: types_js_1.OfficeErrorType.FILE_CORRUPTED,
+        message,
+        details: filePath ? { filePath, originalError: error } : error
+    };
+    reportIssue(issue, config);
+    return new Error(ERRORHEADER + message);
+};
+exports.getWrappedError = getWrappedError;
+/**
+ * Centralized logging utility for non-fatal warnings or issues.
+ * Routes messages to config.onWarning if provided, or console.warn/error
+ * if config.outputErrorToConsole is true.
+ *
+ * @param messageOrType - The warning message or warning type
+ * @param config - Optional parser configuration
+ * @param info - Optional additional information for dynamic messages or context
+ * @param error - Optional original error object
+ */
+const logWarning = (type, config, info, error) => {
+    let message;
+    let details = info;
+    const msg = WARNING_MESSAGES[type];
+    if (typeof msg === 'function') {
+        message = msg(info);
+        details = error || info;
+    }
+    else {
+        message = msg;
+        if (info instanceof Error && !error) {
+            details = info;
+        }
+    }
+    const issue = {
+        type: 'warning',
+        code: type,
+        message,
+        details
+    };
+    reportIssue(issue, config);
+};
+exports.logWarning = logWarning;
+/**
+ * Creates and returns a standard AbortError (DOMException if available).
+ * Used when the user signals cancellation of the parser operation.
+ *
+ * @returns Error object representing the abort action
+ */
+const getAbortError = () => {
+    const message = ERROR_MESSAGES[types_js_1.OfficeErrorType.OPERATION_ABORTED];
+    if (typeof DOMException !== 'undefined') {
+        return new DOMException(message, 'AbortError');
+    }
+    const err = new Error(message);
+    err.name = 'AbortError';
+    return err;
+};
+exports.getAbortError = getAbortError;
+/**
+ * Checks the provided AbortSignal and throws an AbortError if it was aborted.
+ * Helps cleanly interrupt loops and asynchronous phases of parsing.
+ *
+ * @param signal - Optional AbortSignal to inspect
+ * @throws {DOMException} If the signal has been aborted
+ */
+const checkAbortSignal = (signal) => {
+    if (signal?.aborted) {
+        throw (0, exports.getAbortError)();
+    }
+};
+exports.checkAbortSignal = checkAbortSignal;

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

@@ -0,0 +1,66 @@
+/**
+ * Image Processing Utilities
+ *
+ * Provides helper functions for working with image attachments extracted from office documents.
+ * Handles MIME type conversions, file extension mapping, and attachment object creation.
+ *
+ * @module imageUtils
+ */
+import { OfficeAttachment } from '../types';
+/**
+ * Converts a file extension to its corresponding MIME type.
+ *
+ * Used when creating attachments to determine the MIME type from a filename.
+ * The extension check is case-insensitive.
+ *
+ * @param ext - The file extension (with or without a dot, e.g., 'png', '.png')
+ * @returns The corresponding MIME type string
+ * @example
+ * ```typescript
+ * getMimeFromExtension('png'); // Returns 'image/png'
+ * getMimeFromExtension('JPG'); // Returns 'image/jpeg' (case-insensitive)
+ * getMimeFromExtension('unknown'); // Returns 'application/octet-stream'
+ * ```
+ */
+export declare const getMimeFromExtension: (ext: string) => string;
+/**
+ * Detects the MIME type from file magic bytes (file signature).
+ *
+ * This is useful for files with incorrect or missing extensions (like .tmp files).
+ * Inspects the first few bytes of the file to determine the actual format.
+ *
+ * @param buffer - The file content as a Buffer
+ * @returns The detected MIME type, or undefined if not recognized
+ * @example
+ * ```typescript
+ * const pngBuffer = fs.readFileSync('image.tmp');
+ * getMimeFromBytes(pngBuffer); // Returns 'image/png' if it's a PNG file
+ * ```
+ */
+export declare const getMimeFromBytes: (buffer: Buffer) => string | undefined;
+/**
+ * Creates an OfficeAttachment object from image data.
+ *
+ * This is a convenience function that:
+ * 1. Extracts the file extension from the filename
+ * 2. Determines the MIME type from the extension
+ * 3. Encodes the image buffer as Base64
+ * 4. Constructs a properly formatted OfficeAttachment object
+ *
+ * @param name - The filename of the image (e.g., 'image1.png', 'chart.jpg')
+ * @param content - The image data as a Node.js Buffer
+ * @returns An OfficeAttachment object ready to be added to the attachments array
+ *
+ * @example
+ * ```typescript
+ * const imageBuffer = fs.readFileSync('photo.png');
+ * const attachment = createAttachment('photo.png', imageBuffer);
+ *
+ * console.log(attachment.type); // 'image'
+ * console.log(attachment.mimeType); // 'image/png'
+ * console.log(attachment.name); // 'photo.png'
+ * console.log(attachment.extension); // 'png'
+ * console.log(attachment.data); // 'iVBORw0KGgoAAAANSUhEUgAA...' (Base64)
+ * ```
+ */
+export declare const createAttachment: (name: string, content: Buffer) => OfficeAttachment;

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

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * Image Processing Utilities
+ *
+ * Provides helper functions for working with image attachments extracted from office documents.
+ * Handles MIME type conversions, file extension mapping, and attachment object creation.
+ *
+ * @module imageUtils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAttachment = exports.getMimeFromBytes = exports.getMimeFromExtension = void 0;
+/**
+ * Converts a file extension to its corresponding MIME type.
+ *
+ * Used when creating attachments to determine the MIME type from a filename.
+ * The extension check is case-insensitive.
+ *
+ * @param ext - The file extension (with or without a dot, e.g., 'png', '.png')
+ * @returns The corresponding MIME type string
+ * @example
+ * ```typescript
+ * getMimeFromExtension('png'); // Returns 'image/png'
+ * getMimeFromExtension('JPG'); // Returns 'image/jpeg' (case-insensitive)
+ * getMimeFromExtension('unknown'); // Returns 'application/octet-stream'
+ * ```
+ */
+const getMimeFromExtension = (ext) => {
+    switch (ext.toLowerCase()) {
+        case 'jpg':
+        case 'jpeg': return 'image/jpeg';
+        case 'png': return 'image/png';
+        case 'gif': return 'image/gif';
+        case 'bmp': return 'image/bmp';
+        case 'tiff': return 'image/tiff';
+        case 'webp': return 'image/webp';
+        default: return 'application/octet-stream'; // Generic binary MIME type
+    }
+};
+exports.getMimeFromExtension = getMimeFromExtension;
+/**
+ * Detects the MIME type from file magic bytes (file signature).
+ *
+ * This is useful for files with incorrect or missing extensions (like .tmp files).
+ * Inspects the first few bytes of the file to determine the actual format.
+ *
+ * @param buffer - The file content as a Buffer
+ * @returns The detected MIME type, or undefined if not recognized
+ * @example
+ * ```typescript
+ * const pngBuffer = fs.readFileSync('image.tmp');
+ * getMimeFromBytes(pngBuffer); // Returns 'image/png' if it's a PNG file
+ * ```
+ */
+const getMimeFromBytes = (buffer) => {
+    if (buffer.length < 4)
+        return undefined;
+    // PNG: 89 50 4E 47 (0x89 "PNG")
+    if (buffer[0] === 0x89 && buffer[1] === 0x50 && buffer[2] === 0x4E && buffer[3] === 0x47) {
+        return 'image/png';
+    }
+    // JPEG: FF D8 FF
+    if (buffer[0] === 0xFF && buffer[1] === 0xD8 && buffer[2] === 0xFF) {
+        return 'image/jpeg';
+    }
+    // GIF: 47 49 46 38 ("GIF8")
+    if (buffer[0] === 0x47 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x38) {
+        return 'image/gif';
+    }
+    // BMP: 42 4D ("BM")
+    if (buffer[0] === 0x42 && buffer[1] === 0x4D) {
+        return 'image/bmp';
+    }
+    // TIFF: 49 49 2A 00 (little endian) or 4D 4D 00 2A (big endian)
+    if ((buffer[0] === 0x49 && buffer[1] === 0x49 && buffer[2] === 0x2A && buffer[3] === 0x00) ||
+        (buffer[0] === 0x4D && buffer[1] === 0x4D && buffer[2] === 0x00 && buffer[3] === 0x2A)) {
+        return 'image/tiff';
+    }
+    // WebP: 52 49 46 46 ... 57 45 42 50 ("RIFF" ... "WEBP")
+    if (buffer.length >= 12 &&
+        buffer[0] === 0x52 && buffer[1] === 0x49 && buffer[2] === 0x46 && buffer[3] === 0x46 &&
+        buffer[8] === 0x57 && buffer[9] === 0x45 && buffer[10] === 0x42 && buffer[11] === 0x50) {
+        return 'image/webp';
+    }
+    return undefined;
+};
+exports.getMimeFromBytes = getMimeFromBytes;
+/**
+ * Creates an OfficeAttachment object from image data.
+ *
+ * This is a convenience function that:
+ * 1. Extracts the file extension from the filename
+ * 2. Determines the MIME type from the extension
+ * 3. Encodes the image buffer as Base64
+ * 4. Constructs a properly formatted OfficeAttachment object
+ *
+ * @param name - The filename of the image (e.g., 'image1.png', 'chart.jpg')
+ * @param content - The image data as a Node.js Buffer
+ * @returns An OfficeAttachment object ready to be added to the attachments array
+ *
+ * @example
+ * ```typescript
+ * const imageBuffer = fs.readFileSync('photo.png');
+ * const attachment = createAttachment('photo.png', imageBuffer);
+ *
+ * console.log(attachment.type); // 'image'
+ * console.log(attachment.mimeType); // 'image/png'
+ * console.log(attachment.name); // 'photo.png'
+ * console.log(attachment.extension); // 'png'
+ * console.log(attachment.data); // 'iVBORw0KGgoAAAANSUhEUgAA...' (Base64)
+ * ```
+ */
+const createAttachment = (name, content) => {
+    // Step 1: Extract file extension from the filename
+    // Example: 'image1.png' -> 'png'
+    const ext = name.split('.').pop() || '';
+    // Step 2: Try to detect MIME type from magic bytes first (more reliable)
+    // This handles cases like .tmp files or mismatched extensions
+    let mime = (0, exports.getMimeFromBytes)(content);
+    // Step 3: Fallback to extension if magic bytes couldn't detect it
+    // Useful for SVG or formats not covered by getMimeFromBytes
+    if (!mime) {
+        mime = (0, exports.getMimeFromExtension)(ext);
+    }
+    // Step 4: Create and return the attachment object
+    return {
+        type: 'image', // All attachments created here are images
+        mimeType: mime, // Cast to our supported MIME types
+        data: content.toString('base64'), // Convert buffer to Base64 string
+        name: name, // Original filename
+        extension: ext // File extension for reference
+    };
+};
+exports.createAttachment = createAttachment;

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

@@ -0,0 +1,42 @@
+/**
+ * Converts an OMML subtree (`<m:oMath>` or any node within one) to LaTeX.
+ *
+ * Covers the constructs that actually appear in office documents: fractions, sub/superscripts,
+ * delimiters, radicals, n-ary operators, functions, accents, bars, boxes and matrices. Anything
+ * unrecognized falls through to concatenating its children, which is the old behaviour and the
+ * right degradation for a construct that carries no grouping of its own.
+ */
+export declare const ommlToLatex: (node: Node, depth?: number) => string;
+/**
+ * The subset of a parsed element every MathML source here can present.
+ *
+ * MathML reaches this module from two different tree types - the XML DOM (ODF embedded objects)
+ * and `HtmlParser`'s own lightweight node (HTML, and EPUB via its spine items) - so the converter
+ * is written against this shape and each caller adapts into it. That keeps one implementation of
+ * the conversion rather than one per tree type, which is how HTML came to have no MathML support
+ * at all while ODF did.
+ */
+export interface MathNode {
+    /** Tag name, namespace prefix included or not; `undefined` marks a text node. */
+    tagName?: string;
+    attributes?: Record<string, string>;
+    /** Literal text, for text nodes and for leaf tokens. */
+    text?: string;
+    children: MathNode[];
+}
+/**
+ * Converts a MathML subtree to LaTeX.
+ *
+ * When the document carries a TeX annotation (`<annotation encoding="application/x-tex">`), that
+ * is the author's own source and is used verbatim in preference to anything reconstructed here.
+ * ODF's `<annotation encoding="StarMath 5.0">` is deliberately not used - StarMath is not LaTeX,
+ * and emitting it would put a second notation back into the output this module exists to unify.
+ */
+export declare const mathmlTreeToLatex: (node: MathNode, depth?: number) => string;
+/** Converts a MathML subtree held in an XML DOM (ODF embedded objects) to LaTeX. */
+export declare const mathmlToLatex: (node: Node, depth?: number) => string;
+/**
+ * True when a converted equation carries nothing worth emitting, so callers can drop the node
+ * instead of pushing an empty `$$` into the output.
+ */
+export declare const isEmptyMath: (latex: string) => boolean;