officeparser 6.1.0 → 7.0.0

package/dist/utils/errorUtils.js

@@ -7,46 +7,62 @@
  * 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]: `Error occured while reading the file buffers. If you are passing text-based formats like md, html, or csv as a Buffer, you must provide the 'fileType' hint in the configuration as they lack magic bytes for auto-detection.`,
+    [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.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 +75,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 +124,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,16 +12,22 @@ 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

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;
 /**