officeparser 6.1.0 → 7.0.0

package/dist/types.js

@@ -1,2 +1,73 @@
 "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";
+    /** 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";
+    /** 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";
+})(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";
+    /** 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";
+})(OfficeWarningType || (exports.OfficeWarningType = OfficeWarningType = {}));

package/dist/utils/astUtils.d.ts

@@ -0,0 +1,16 @@
+import { OfficeParserAST, OfficeContentNode, OfficeMetadata, OfficeAttachment, SupportedFileType, OfficeParserConfig } 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, toTextSync: () => string): OfficeParserAST;

package/dist/utils/astUtils.js

@@ -0,0 +1,32 @@
+"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, toTextSync) {
+    return {
+        config,
+        type,
+        metadata,
+        content,
+        attachments,
+        warnings: [],
+        toText: toTextSync,
+        async to(destination, genConfig) {
+            return OfficeGenerator_js_1.OfficeGenerator.generate(this, destination, genConfig);
+        }
+    };
+}

package/dist/utils/configUtils.d.ts

@@ -0,0 +1,26 @@
+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.
+ *
+ * @param userConfig - Optional configuration provided by the user
+ * @returns A fully populated configuration object
+ */
+export declare function resolveParserConfig(userConfig?: OfficeParserConfig | FullOfficeParserConfig): FullOfficeParserConfig;
+/**
+ * Resolves a full, destination-specific configuration by merging defaults,
+ * AST-level settings, and user-provided overrides.
+ *
+ * @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
+ */
+export declare function resolveGeneratorConfig<D extends string>(destination: D, astConfig?: OfficeParserConfig, userConfig?: GeneratorConfig<D> | FullGeneratorConfig): FullGeneratorConfig;

package/dist/utils/configUtils.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFullGeneratorConfig = isFullGeneratorConfig;
+exports.isFullParserConfig = isFullParserConfig;
+exports.resolveParserConfig = resolveParserConfig;
+exports.resolveGeneratorConfig = resolveGeneratorConfig;
+const defaults_js_1 = require("../defaults.js");
+/**
+ * Deep clones an object, specifically handling arrays and plain objects.
+ */
+function deepClone(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map((item) => deepClone(item));
+    }
+    const cloned = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            cloned[key] = deepClone(obj[key]);
+        }
+    }
+    return cloned;
+}
+/**
+ * Checks if a configuration object is a FullGeneratorConfig.
+ */
+function isFullGeneratorConfig(config) {
+    return !!(config &&
+        typeof config === 'object' &&
+        'textConfig' in config &&
+        'htmlConfig' in config &&
+        'pdfConfig' in config &&
+        'csvConfig' in config &&
+        'onNode' in config);
+}
+/**
+ * Checks if a configuration object is a FullOfficeParserConfig.
+ */
+function isFullParserConfig(config) {
+    return !!(config &&
+        typeof config === 'object' &&
+        'ocrConfig' in config &&
+        typeof config.ocrConfig === 'object' &&
+        'language' in config.ocrConfig &&
+        'workerPath' in config.ocrConfig);
+}
+/**
+ * Resolves a full parser configuration by merging defaults and user-provided overrides.
+ *
+ * @param userConfig - Optional configuration provided by the user
+ * @returns A fully populated configuration object
+ */
+function resolveParserConfig(userConfig) {
+    if (isFullParserConfig(userConfig)) {
+        return userConfig;
+    }
+    // 1. Start with full defaults (deep cloned)
+    const config = deepClone(defaults_js_1.DEFAULT_OFFICE_PARSER_CONFIG);
+    if (!userConfig) {
+        return config;
+    }
+    // 2. Merge user config
+    // We handle ocrConfig specially to avoid shallow-overwriting the whole object
+    const { ocrConfig, ...rest } = userConfig;
+    Object.assign(config, rest);
+    if (ocrConfig) {
+        config.ocrConfig = { ...config.ocrConfig, ...ocrConfig };
+    }
+    // 3. Handle legacy ocrLanguage mapping if not explicitly set in ocrConfig
+    if (userConfig.ocrLanguage && !userConfig.ocrConfig?.language) {
+        config.ocrConfig.language = userConfig.ocrLanguage;
+    }
+    return config;
+}
+/**
+ * Resolves a full, destination-specific configuration by merging defaults,
+ * AST-level settings, and user-provided overrides.
+ *
+ * @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
+ */
+function resolveGeneratorConfig(destination, astConfig, userConfig) {
+    // If it's already a full config and we don't need to merge AST config, return it as is.
+    // We assume FullGeneratorConfig is already "safe" (references resolved).
+    if (isFullGeneratorConfig(userConfig) && !astConfig) {
+        return userConfig;
+    }
+    // 1. Start with full defaults (deep cloned to avoid reference sharing)
+    const config = deepClone(defaults_js_1.DEFAULT_GENERATOR_CONFIG);
+    // 2. Merge common properties and sub-configs
+    if (userConfig) {
+        // Extract sub-configs to avoid shallow-overwriting the whole sub-config objects
+        const { htmlConfig, mdConfig, pdfConfig, csvConfig, textConfig, chunksConfig, ...commonProps } = userConfig;
+        Object.assign(config, commonProps);
+        // Merge sub-configs individually, ignoring undefined properties to preserve defaults
+        const mergeSubConfig = (target, source) => {
+            if (!source)
+                return;
+            for (const key in source) {
+                if (source[key] !== undefined) {
+                    target[key] = source[key];
+                }
+            }
+        };
+        if (htmlConfig)
+            mergeSubConfig(config.htmlConfig, htmlConfig);
+        if (mdConfig)
+            mergeSubConfig(config.mdConfig, mdConfig);
+        if (pdfConfig)
+            mergeSubConfig(config.pdfConfig, pdfConfig);
+        if (csvConfig)
+            mergeSubConfig(config.csvConfig, csvConfig);
+        if (textConfig)
+            mergeSubConfig(config.textConfig, textConfig);
+        if (chunksConfig)
+            mergeSubConfig(config.chunksConfig, chunksConfig);
+    }
+    // 3. Inherit from AST config if not explicitly provided
+    if (astConfig) {
+        if (userConfig?.onWarning === undefined) {
+            config.onWarning = astConfig.onWarning || config.onWarning;
+        }
+        // Inherit newlineDelimiter for text-based generators
+        const astNewline = astConfig.newlineDelimiter;
+        if (astNewline && ['text', 'md', 'rtf'].includes(destination)) {
+            // If user didn't specify a newline delimiter in their specific config, use AST's
+            if (destination === 'text' && userConfig?.textConfig?.newlineDelimiter === undefined) {
+                config.textConfig.newlineDelimiter = astNewline;
+            }
+            // For MD and RTF, they use common newline settings or internal defaults.
+            // We ensure the resolved config reflects this if possible, or generators can check astConfig directly.
+            // Since FullGeneratorConfig doesn't have an 'mdConfig', we rely on the generator implementation.
+        }
+    }
+    return config;
+}

package/dist/utils/envUtils.js

@@ -10,6 +10,8 @@ exports.ensureDomMatrix = ensureDomMatrix;
  * Detect if we are running in a browser environment.
  */
 exports.isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined';
+const types_js_1 = require("../types.js");
+const errorUtils_js_1 = require("./errorUtils.js");
 /**
  * Human-readable descriptions for Node-only features.
  */
@@ -26,7 +28,7 @@ const readableFeatures = {
  */
 function assertNode(feature) {
     if (exports.isBrowser) {
-        throw new Error(`officeparser: '${readableFeatures[feature]}' is not supported in the browser. Browser users must pass file content as Buffer or ArrayBuffer directly.`);
+        throw (0, errorUtils_js_1.getOfficeError)(types_js_1.OfficeErrorType.FEATURE_NOT_SUPPORTED_IN_BROWSER, undefined, readableFeatures[feature]);
     }
 }
 /**
@@ -36,6 +38,7 @@ function assertNode(feature) {
  */
 function ensureDomMatrix() {
     if (typeof global !== 'undefined' && !global.DOMMatrix) {
+        // Node.js < 20 needs a polyfill for DOMMatrix used by pdf.js 5.x
         global.DOMMatrix = class DOMMatrix {
             a;
             b;
@@ -52,18 +55,69 @@ function ensureDomMatrix() {
                     this.e = init[4];
                     this.f = init[5];
                 }
+                else if (typeof init === 'object' && init !== null) {
+                    this.a = init.a;
+                    this.b = init.b;
+                    this.c = init.c;
+                    this.d = init.d;
+                    this.e = init.e;
+                    this.f = init.f;
+                }
                 else {
                     this.a = this.d = 1;
                     this.b = this.c = this.e = this.f = 0;
                 }
             }
-            // Map standard matrix properties for compatibility
+            // Standard matrix property aliases for compatibility
             get m11() { return this.a; }
             get m12() { return this.b; }
             get m21() { return this.c; }
             get m22() { return this.d; }
             get m41() { return this.e; }
             get m42() { return this.f; }
+            multiply(other) {
+                return new DOMMatrix([
+                    this.a * other.a + this.c * other.b,
+                    this.b * other.a + this.d * other.b,
+                    this.a * other.c + this.c * other.d,
+                    this.b * other.c + this.d * other.d,
+                    this.a * other.e + this.c * other.f + this.e,
+                    this.b * other.e + this.d * other.f + this.f
+                ]);
+            }
+            inverse() {
+                const det = this.a * this.d - this.b * this.c;
+                if (det === 0)
+                    return new DOMMatrix();
+                return new DOMMatrix([
+                    this.d / det,
+                    -this.b / det,
+                    -this.c / det,
+                    this.a / det,
+                    (this.c * this.f - this.d * this.e) / det,
+                    (this.b * this.e - this.a * this.f) / det
+                ]);
+            }
+            transformPoint(point) {
+                const x = point?.x ?? 0;
+                const y = point?.y ?? 0;
+                return {
+                    x: x * this.a + y * this.c + this.e,
+                    y: x * this.b + y * this.d + this.f
+                };
+            }
+        };
+    }
+    if (typeof global !== 'undefined' && !global.ImageData) {
+        global.ImageData = class ImageData {
+            width;
+            height;
+            data;
+            constructor(data, width, height) {
+                this.data = data;
+                this.width = width;
+                this.height = height;
+            }
         };
     }
 }

package/dist/utils/errorUtils.d.ts

@@ -5,38 +5,24 @@
  * It defines standard error types, messages, and handling logic to ensure
  * consistent error reporting across all parsers and the main entry point.
  */
-import { OfficeParserConfig } from '../types';
+import { OfficeErrorType, OfficeParserConfig, OfficeWarningType } from '../types.js';
 /**
- * Standard error types for OfficeParser.
- * Use these to identify the kind of error being reported.
+ * 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
  */
-export declare enum OfficeErrorType {
-    /** Unsupported file extension */
-    EXTENSION_UNSUPPORTED = "EXTENSION_UNSUPPORTED",
-    /** File appears to be corrupted or malformed */
-    FILE_CORRUPTED = "FILE_CORRUPTED",
-    /** File could not be found at the specified path */
-    FILE_DOES_NOT_EXIST = "FILE_DOES_NOT_EXIST",
-    /** Specified location/directory is not reachable or is a directory */
-    LOCATION_NOT_FOUND = "LOCATION_NOT_FOUND",
-    /** Arguments passed to the function are missing or invalid */
-    IMPROPER_ARGUMENTS = "IMPROPER_ARGUMENTS",
-    /** Error occurred while reading or processing file buffers */
-    IMPROPER_BUFFERS = "IMPROPER_BUFFERS",
-    /** Input type is not a supported type (string, Buffer, ArrayBuffer) */
-    INVALID_INPUT = "INVALID_INPUT",
-    /** PDF worker source is missing (required in browser) */
-    PDF_WORKER_MISSING = "PDF_WORKER_MISSING"
-}
+export declare const getWarningMessage: (type: OfficeWarningType, info?: any) => string;
 /**
  * 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
  */
-export declare const getOfficeError: (type: OfficeErrorType, config: OfficeParserConfig, info?: any) => Error;
+export declare const getOfficeError: (type: OfficeErrorType, config?: OfficeParserConfig, info?: any) => Error;
 /**
  * Wraps an existing error with OfficeParser context and performs corruption detection.
  * Optionally logs the error to console.
@@ -48,11 +34,13 @@ export declare const getOfficeError: (type: OfficeErrorType, config: OfficeParse
  */
 export declare const getWrappedError: (error: any, config: OfficeParserConfig, filePath?: string) => Error;
 /**
- * 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
  */
-export declare const logWarning: (message: string, config: OfficeParserConfig, error?: any) => void;
+export declare const logWarning: (type: OfficeWarningType, config?: OfficeParserConfig, info?: any, error?: any) => void;