officeparser 6.1.1 → 7.0.1

package/dist/utils/errorUtils.js

@@ -7,46 +7,63 @@
  * consistent error reporting across all parsers and the main entry point.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logWarning = exports.getWrappedError = exports.getOfficeError = exports.OfficeErrorType = void 0;
+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]: ";
-/**
- * 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";
-    /** 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) */
-    OfficeErrorType["INVALID_INPUT"] = "INVALID_INPUT";
-    /** PDF worker source is missing (required in browser) */
-    OfficeErrorType["PDF_WORKER_MISSING"] = "PDF_WORKER_MISSING";
-})(OfficeErrorType || (exports.OfficeErrorType = OfficeErrorType = {}));
 /**
  * Lookup table for error messages.
  * Some entries are functions that take parameters to build dynamic messages.
  */
 const ERROR_MESSAGES = {
-    [OfficeErrorType.EXTENSION_UNSUPPORTED]: (ext) => `Sorry, OfficeParser currently supports docx, pptx, xlsx, odt, odp, ods, pdf, rtf files only. Create a ticket in Issues on github to add support for ${ext} files. Stay tuned for further updates.`,
-    [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.`,
-    [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.`,
-    [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.`,
-    [OfficeErrorType.IMPROPER_ARGUMENTS]: `Improper arguments`,
-    [OfficeErrorType.IMPROPER_BUFFERS]: `Error occured while reading the file buffers`,
-    [OfficeErrorType.INVALID_INPUT]: `Invalid input type: Expected a Buffer or a valid file path`,
-    [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.EXTENSION_UNSUPPORTED]: (ext) => `Sorry, OfficeParser currently supports docx, pptx, xlsx, odt, odp, ods, pdf, rtf, md, html, csv files only. Create a ticket in Issues on github to add support for ${ext} files. Stay tuned for further updates.`,
+    [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).`
 };
+/**
+ * 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}`
+};
+/**
+ * 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.
  *
@@ -59,19 +76,41 @@ const createOfficeError = (type, info) => {
     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 - Parser configuration (checks outputErrorToConsole)
+ * @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);
-    if (config.outputErrorToConsole) {
-        console.error(ERRORHEADER + message);
-    }
+    const issue = {
+        type: 'error',
+        code: type,
+        message,
+        details: info
+    };
+    reportIssue(issue, config);
     return new Error(ERRORHEADER + message);
 };
 exports.getOfficeError = getOfficeError;
@@ -86,35 +125,54 @@ exports.getOfficeError = getOfficeError;
  */
 const getWrappedError = (error, config, filePath) => {
     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(OfficeErrorType.FILE_CORRUPTED, filePath);
-    }
-    if (config.outputErrorToConsole) {
-        console.error(ERRORHEADER + message);
+        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;
 /**
- * Conditionally logs a warning message to the console.
- * Used for non-fatal errors that shouldn't stop the parsing process.
+ * 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 message - The warning message
- * @param config - Parser configuration
- * @param error - Optional original error object for more context
+ * @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 = (message, config, error) => {
-    if (config.outputErrorToConsole) {
-        if (error) {
-            console.warn(ERRORHEADER + message, error);
-        }
-        else {
-            console.warn(ERRORHEADER + message);
+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;

package/dist/utils/moduleLoader.js

@@ -12,22 +12,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.loadFileType = loadFileType;
 exports.loadPdfJs = loadPdfJs;
 const envUtils_js_1 = require("./envUtils.js");
-/**
- * Dynamically loads an ESM module in a Node.js CJS context.
- *
- * @param specifier - The module specifier to load
- * @returns The loaded module
- */
 async function loadNodeEsmModule(specifier) {
-    // We use 'new Function' to bypass static analysis of tsc and some bundlers.
-    // This ensures that Node.js sees a real 'import()' at runtime, even in a CJS file.
-    return new Function('s', 'return import(s)')(specifier);
+    // In Node.js, we resolve the specifier to an absolute file URL.
+    // This ensures that the dynamic import() call (executed via new Function)
+    // always finds the correct module regardless of the caller's context.
+    // This is especially important in Node 18 for sub-paths of packages.
+    try {
+        const { pathToFileURL } = await import('url');
+        // @ts-ignore - require.resolve is available in Node.js
+        const absolutePath = require.resolve(specifier);
+        const fileUrl = pathToFileURL(absolutePath).href;
+        return new Function('s', 'return import(s)')(fileUrl);
+    }
+    catch (e) {
+        // Fallback for cases where require.resolve might fail (e.g. non-file specifiers)
+        return new Function('s', 'return import(s)')(specifier);
+    }
 }
 /**
  * Specialized loader for file-type
  */
 async function loadFileType() {
     if (!envUtils_js_1.isBrowser) {
+        // Ensure environment polyfills for Node.js 18 support
+        (0, envUtils_js_1.ensureEnvPolyfills)();
         // Node.js path: Use dynamic import wrapper for CJS compatibility
         return loadNodeEsmModule('file-type');
     }
@@ -39,8 +47,8 @@ async function loadFileType() {
  */
 async function loadPdfJs() {
     if (!envUtils_js_1.isBrowser) {
-        // Ensure DOMMatrix polyfill for Node.js 18 support
-        (0, envUtils_js_1.ensureDomMatrix)();
+        // Ensure environment polyfills for Node.js 18 support
+        (0, envUtils_js_1.ensureEnvPolyfills)();
         // Node.js environment: require legacy build for stability with ESM-only main
         try {
             return await loadNodeEsmModule('pdfjs-dist/legacy/build/pdf.mjs');

package/dist/utils/ocrUtils.js

@@ -12,6 +12,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.terminateOcr = exports.performOcr = void 0;
+const envUtils_js_1 = require("./envUtils.js");
 /**
  * Manages a pool of Tesseract workers with "Smart Affinity".
  *
@@ -202,7 +203,7 @@ const performOcr = async (image, config) => {
     let inputImage = image;
     // In browser environment, convert Buffer to Blob for better compatibility
     // @ts-ignore
-    if (typeof window !== 'undefined' && typeof Blob !== 'undefined' && Buffer.isBuffer(image)) {
+    if (envUtils_js_1.isBrowser && typeof Blob !== 'undefined' && Buffer.isBuffer(image)) {
         inputImage = new Blob([image], { type: 'image/bmp' });
     }
     return await OcrSchedulerManager.getInstance().recognize(inputImage, config);

package/dist/utils/sheetUtils.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Parses a range string (e.g., "1", "1-3", "1,2", "1,3-5, 7") into an array of numbers.
+ *
+ * @param rangeStr - The range string to parse
+ * @returns An array of unique, sorted numbers (1-based indices)
+ */
+export declare function parseRangeString(rangeStr: string): number[];

package/dist/utils/sheetUtils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRangeString = parseRangeString;
+/**
+ * Parses a range string (e.g., "1", "1-3", "1,2", "1,3-5, 7") into an array of numbers.
+ *
+ * @param rangeStr - The range string to parse
+ * @returns An array of unique, sorted numbers (1-based indices)
+ */
+function parseRangeString(rangeStr) {
+    const result = new Set();
+    const segments = rangeStr.split(',');
+    for (const segment of segments) {
+        const trimmed = segment.trim();
+        if (trimmed.includes('-')) {
+            const [startStr, endStr] = trimmed.split('-');
+            const start = parseInt(startStr, 10);
+            const end = parseInt(endStr, 10);
+            if (!isNaN(start) && !isNaN(end)) {
+                const actualStart = Math.min(start, end);
+                const actualEnd = Math.max(start, end);
+                for (let i = actualStart; i <= actualEnd; i++) {
+                    result.add(i);
+                }
+            }
+        }
+        else {
+            const val = parseInt(trimmed, 10);
+            if (!isNaN(val)) {
+                result.add(val);
+            }
+        }
+    }
+    return Array.from(result).sort((a, b) => a - b);
+}

package/dist/utils/styleMapper.d.ts

@@ -0,0 +1,36 @@
+import { OfficeContentNode, StructuredStyleMapping } from '../types.js';
+export interface StyleMapping {
+    selector: {
+        nodeType?: string;
+        attributes: Record<string, {
+            value: string | number | boolean;
+            operator: '=' | '~=';
+            compiled?: RegExp;
+        }>;
+    };
+    output: {
+        tag: string;
+        classes: string[];
+        attributes: Record<string, string>;
+        fresh: boolean;
+    };
+}
+/**
+ * Parser and matcher for the style mapping DSL.
+ * Supports a structured JSON format and a legacy string DSL.
+ */
+export declare class StyleMapper {
+    private mappings;
+    constructor(mappings?: string[] | StructuredStyleMapping[] | Record<string, any>, ignoreDefaults?: boolean);
+    /**
+     * Finds the best matching mapping for a node.
+     */
+    getMapping(node: OfficeContentNode): StyleMapping['output'] | undefined;
+    private matches;
+    private getNodeAttribute;
+    private convertStructuredMapping;
+    /**
+     * Parses a mapping string like "p[style-name='Heading 1'] => h1.title:fresh"
+     */
+    private parseMappingString;
+}

package/dist/utils/styleMapper.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StyleMapper = void 0;
+const types_js_1 = require("../types.js");
+const errorUtils_js_1 = require("./errorUtils.js");
+const DEFAULT_MAPPINGS = [
+    { selector: { nodeType: 'paragraph', attributes: { 'style-name': 'Heading 1' } }, output: { tag: 'h1' } },
+    { selector: { nodeType: 'paragraph', attributes: { 'style-name': 'Heading 2' } }, output: { tag: 'h2' } },
+    { selector: { nodeType: 'paragraph', attributes: { 'style-name': 'Heading 3' } }, output: { tag: 'h3' } },
+    { selector: { nodeType: 'paragraph', attributes: { 'style-name': 'Heading 4' } }, output: { tag: 'h4' } },
+    { selector: { nodeType: 'paragraph', attributes: { 'style-name': 'Heading 5' } }, output: { tag: 'h5' } },
+    { selector: { nodeType: 'paragraph', attributes: { 'style-name': 'Heading 6' } }, output: { tag: 'h6' } },
+    { selector: { nodeType: 'paragraph', attributes: { 'style-name': 'Title' } }, output: { tag: 'h1', classes: ['title'] } },
+    { selector: { nodeType: 'paragraph', attributes: { 'style-name': 'Subtitle' } }, output: { tag: 'p', classes: ['subtitle'] } },
+    { selector: { nodeType: 'paragraph', attributes: { 'style-name': 'Quote' } }, output: { tag: 'blockquote' } },
+    { selector: { nodeType: 'paragraph', attributes: { 'style-name': 'Intense Quote' } }, output: { tag: 'blockquote', classes: ['intense'] } },
+];
+/**
+ * Parser and matcher for the style mapping DSL.
+ * Supports a structured JSON format and a legacy string DSL.
+ */
+class StyleMapper {
+    mappings = [];
+    constructor(mappings, ignoreDefaults = false) {
+        // 1. Add user mappings (they take precedence)
+        if (mappings) {
+            if (Array.isArray(mappings)) {
+                for (const m of mappings) {
+                    if (typeof m === 'string') {
+                        this.mappings.push(this.parseMappingString(m));
+                    }
+                    else {
+                        this.mappings.push(this.convertStructuredMapping(m));
+                    }
+                }
+            }
+            else {
+                // Support legacy object format: { 'Heading 1': { tag: 'h1', class: 'title' } }
+                for (const [styleName, target] of Object.entries(mappings)) {
+                    this.mappings.push({
+                        selector: {
+                            attributes: { style: { value: styleName, operator: '=' } }
+                        },
+                        output: {
+                            tag: target.tag || 'div',
+                            classes: target.class ? target.class.split(' ') : [],
+                            attributes: {},
+                            fresh: false
+                        }
+                    });
+                }
+            }
+        }
+        // 2. Add default mappings if not ignored
+        if (!ignoreDefaults) {
+            this.mappings.push(...DEFAULT_MAPPINGS.map(m => this.convertStructuredMapping(m)));
+        }
+    }
+    /**
+     * Finds the best matching mapping for a node.
+     */
+    getMapping(node) {
+        for (const mapping of this.mappings) {
+            if (this.matches(node, mapping.selector)) {
+                return mapping.output;
+            }
+        }
+        return undefined;
+    }
+    matches(node, selector) {
+        // Match node type if specified
+        if (selector.nodeType && node.type !== selector.nodeType) {
+            return false;
+        }
+        // Match attributes (style, level, etc.)
+        for (const [attr, { value, operator, compiled }] of Object.entries(selector.attributes)) {
+            const actualValue = this.getNodeAttribute(node, attr);
+            if (actualValue === undefined)
+                return false;
+            if (operator === '=') {
+                if (String(actualValue) !== String(value))
+                    return false;
+            }
+            else if (operator === '~=') {
+                const regex = compiled || new RegExp(String(value));
+                if (!regex.test(String(actualValue)))
+                    return false;
+            }
+        }
+        return true;
+    }
+    getNodeAttribute(node, attr) {
+        // Special case for style (alias style-name for mammoth.js compatibility)
+        if (attr === 'style' || attr === 'style-name') {
+            return node.metadata?.style || node.formatting?.font;
+        }
+        // Metadata attributes
+        if (node.metadata && attr in node.metadata) {
+            return node.metadata[attr];
+        }
+        // Formatting attributes
+        if (node.formatting && attr in node.formatting) {
+            return node.formatting[attr];
+        }
+        return undefined;
+    }
+    convertStructuredMapping(m) {
+        const attributes = {};
+        if (m.selector.attributes) {
+            for (const [key, val] of Object.entries(m.selector.attributes)) {
+                if (typeof val === 'object' && val !== null && 'value' in val) {
+                    const operator = val.operator || '=';
+                    attributes[key] = {
+                        value: val.value,
+                        operator,
+                        compiled: operator === '~=' ? new RegExp(String(val.value)) : undefined
+                    };
+                }
+                else {
+                    attributes[key] = {
+                        value: val,
+                        operator: '='
+                    };
+                }
+            }
+        }
+        return {
+            selector: {
+                nodeType: m.selector.nodeType,
+                attributes
+            },
+            output: {
+                tag: m.output.tag,
+                classes: m.output.classes || [],
+                attributes: m.output.attributes || {},
+                fresh: m.output.fresh || false
+            }
+        };
+    }
+    /**
+     * Parses a mapping string like "p[style-name='Heading 1'] => h1.title:fresh"
+     */
+    parseMappingString(mapping) {
+        const lastIndex = mapping.lastIndexOf('=>');
+        if (lastIndex === -1) {
+            throw (0, errorUtils_js_1.getOfficeError)(types_js_1.OfficeErrorType.INVALID_STYLE_MAPPING, undefined, mapping);
+        }
+        const selectorStr = mapping.substring(0, lastIndex).trim();
+        const outputStr = mapping.substring(lastIndex + 2).trim();
+        // Parse Selector
+        const selectorMatch = selectorStr.match(/^([a-z]+)?(?:\[(.+?)\])?$/);
+        if (!selectorMatch) {
+            throw (0, errorUtils_js_1.getOfficeError)(types_js_1.OfficeErrorType.INVALID_SELECTOR, undefined, selectorStr);
+        }
+        const typeMap = {
+            'p': 'paragraph',
+            'h': 'heading',
+            't': 'table',
+            'tr': 'row',
+            'td': 'cell',
+            'li': 'list',
+            'img': 'image'
+        };
+        const nodeType = selectorMatch[1] ? (typeMap[selectorMatch[1]] || selectorMatch[1]) : undefined;
+        const attrStr = selectorMatch[2];
+        const attributes = {};
+        if (attrStr) {
+            // Improved attribute parsing to handle commas inside quotes
+            const attrParts = [];
+            let currentPart = '';
+            let inQuotes = false;
+            for (let i = 0; i < attrStr.length; i++) {
+                const char = attrStr[i];
+                if (char === "'" || char === '"')
+                    inQuotes = !inQuotes;
+                if (char === ',' && !inQuotes) {
+                    attrParts.push(currentPart.trim());
+                    currentPart = '';
+                }
+                else {
+                    currentPart += char;
+                }
+            }
+            if (currentPart)
+                attrParts.push(currentPart.trim());
+            for (const part of attrParts) {
+                const m = part.match(/^([\w-]+)\s*(=|~=)\s*(?:(["'])(.*?)\3|(.+))$/);
+                if (m) {
+                    const operator = m[2];
+                    const value = m[4] !== undefined ? m[4] : m[5];
+                    attributes[m[1]] = {
+                        operator,
+                        value,
+                        compiled: operator === '~=' ? new RegExp(value) : undefined
+                    };
+                }
+            }
+        }
+        // Parse Output
+        const outputParts = outputStr.split(':');
+        const fresh = outputParts.includes('fresh');
+        const mainOutput = outputParts[0];
+        const outputMatch = mainOutput.match(/^([a-z0-9]+)?((?:\.[\w-]+)*)(?:\[(.+?)\])?$/);
+        if (!outputMatch) {
+            throw (0, errorUtils_js_1.getOfficeError)(types_js_1.OfficeErrorType.INVALID_OUTPUT_MAPPING, undefined, mainOutput);
+        }
+        const tag = outputMatch[1] || 'div';
+        const classes = outputMatch[2] ? outputMatch[2].split('.').filter(Boolean) : [];
+        const outAttrs = {};
+        if (outputMatch[3]) {
+            const outAttrParts = outputMatch[3].split(',').map(a => a.trim());
+            for (const part of outAttrParts) {
+                const m = part.match(/^([\w-]+)\s*=\s*(?:(["'])(.*?)\2|(.+))$/);
+                if (m)
+                    outAttrs[m[1]] = m[3] !== undefined ? m[3] : m[4];
+            }
+        }
+        return {
+            selector: { nodeType, attributes },
+            output: { tag, classes, attributes: outAttrs, fresh }
+        };
+    }
+}
+exports.StyleMapper = StyleMapper;

package/dist/utils/xmlUtils.d.ts

@@ -42,14 +42,6 @@ export declare const parseXmlString: (xml: string, options?: {
  * ```
  */
 export declare const getElementsByTagName: (element: Element | Document, tagName: string) => Element[];
-/**
- * Serializes a DOM Node (Document, Element, etc.) back into an XML string.
- * This is cross-platform and works in both Node.js and Browser environments.
- *
- * @param node - The DOM node to serialize
- * @param options - Serialization options
- * @returns The XML string representation
- */
 export declare const serializeXml: (node: Node, options?: {
     preserveWhitespace?: boolean;
 }) => string;

package/dist/utils/xmlUtils.js

@@ -72,13 +72,14 @@ exports.getElementsByTagName = getElementsByTagName;
  * @param options - Serialization options
  * @returns The XML string representation
  */
+const serializer = new xmldom_1.XMLSerializer();
 const serializeXml = (node, options = {}) => {
     // Note: xmldom's XMLSerializer doesn't natively support a 'pretty' or 'preserve' 
     // flag in a way that matches all user expectations, but it defaults to 
     // preserving structure. Formatting (indentation) is usually handled by the 
     // parser's initial whitespace handling.
     // @ts-ignore - xmldom's Node is compatible with the global Node interface
-    return new xmldom_1.XMLSerializer().serializeToString(node);
+    return serializer.serializeToString(node);
 };
 exports.serializeXml = serializeXml;
 /**