@gmickel/gno 1.46.0 → 2.0.0

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

@@ -0,0 +1,315 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFullGeneratorConfig = isFullGeneratorConfig;
+exports.isFullParserConfig = isFullParserConfig;
+exports.resolveParserConfig = resolveParserConfig;
+exports.resolveGeneratorConfig = resolveGeneratorConfig;
+exports.isValidContainerWidth = isValidContainerWidth;
+const defaults_js_1 = require("../defaults.js");
+const types_js_1 = require("../types.js");
+const errorUtils_js_1 = require("./errorUtils.js");
+/**
+ * Keys that must never be copied from a caller-supplied config onto one of our objects.
+ *
+ * A config that arrived via `JSON.parse` can carry `__proto__` as a genuine **own enumerable**
+ * property (an object *literal* cannot - there `__proto__` invokes the setter at parse time),
+ * which is exactly the shape of a host application accepting a JSON config blob. Copying that
+ * key reaches `Object.prototype` and corrupts every object in the process.
+ *
+ * `constructor` and `prototype` are included because they are the other two names that reach a
+ * prototype through an ordinary property write.
+ */
+const PROTOTYPE_POLLUTION_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+/**
+ * Returns a copy of `source` with prototype-reaching keys removed.
+ *
+ * Needed before `Object.assign`, which does **not** pollute `Object.prototype` (it writes via
+ * `[[Set]]`, so `__proto__` invokes the inherited setter rather than creating an own property) -
+ * but that setter is not inert: it **replaces the target's prototype**, so the returned config
+ * silently inherits attacker-chosen properties for every field the defaults don't set as an own
+ * property. Narrower than global pollution, still wrong. Do not "simplify" this away on the
+ * grounds that `Object.assign` is safe; it is safe only against the *global* variant.
+ */
+function withoutPrototypeKeys(source) {
+    const safe = {};
+    for (const key of Object.keys(source)) {
+        if (PROTOTYPE_POLLUTION_KEYS.has(key))
+            continue;
+        safe[key] = source[key];
+    }
+    return safe;
+}
+/**
+ * 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.
+ *
+ * The returned object always belongs solely to the caller of this function. That matters
+ * because a parse installs per-call state on the config it is handed, such as the collector
+ * that gathers warnings for one document's `ast.warnings`. Returning the caller's own object
+ * would attach that state to an object they may reuse, so a second parse would append its
+ * warnings to the first document's already-returned AST, and each parse would retain the
+ * previous one's state for as long as the config lived.
+ *
+ * Only the configuration containers are copied. Callbacks and `abortSignal` keep their
+ * identity, since a copy of an `AbortSignal` would no longer be tied to its controller.
+ *
+ * @param userConfig - Optional configuration provided by the user
+ * @returns A fully populated configuration object, owned by the caller
+ */
+function resolveParserConfig(userConfig) {
+    if (isFullParserConfig(userConfig)) {
+        const resolved = { ...userConfig };
+        resolved.ocrConfig = { ...userConfig.ocrConfig };
+        if (userConfig.ocrConfig?.timeout) {
+            resolved.ocrConfig.timeout = { ...userConfig.ocrConfig.timeout };
+        }
+        resolved.decompressionLimits = {
+            ...(userConfig.decompressionLimits ?? defaults_js_1.DEFAULT_OFFICE_PARSER_CONFIG.decompressionLimits)
+        };
+        if (userConfig.htmlParserConfig) {
+            resolved.htmlParserConfig = { ...userConfig.htmlParserConfig };
+        }
+        return resolved;
+    }
+    // 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, decompressionLimits, and htmlParserConfig specially to avoid
+    // shallow-overwriting the whole nested objects
+    const { ocrConfig, decompressionLimits, htmlParserConfig, ...rest } = userConfig;
+    Object.assign(config, withoutPrototypeKeys(rest));
+    if (decompressionLimits) {
+        config.decompressionLimits = {
+            ...config.decompressionLimits,
+            ...decompressionLimits,
+        };
+    }
+    if (htmlParserConfig) {
+        config.htmlParserConfig = {
+            ...config.htmlParserConfig,
+            ...htmlParserConfig,
+        };
+    }
+    if (ocrConfig) {
+        const { timeout, ...ocrRest } = ocrConfig;
+        config.ocrConfig = {
+            ...config.ocrConfig,
+            ...ocrRest,
+            timeout: {
+                autoTerminate: timeout?.autoTerminate !== undefined ? timeout.autoTerminate : config.ocrConfig.timeout.autoTerminate,
+                workerLoad: timeout?.workerLoad !== undefined ? timeout.workerLoad : config.ocrConfig.timeout.workerLoad,
+                recognition: timeout?.recognition !== undefined ? timeout.recognition : config.ocrConfig.timeout.recognition,
+            }
+        };
+    }
+    // 3. Handle legacy ocrLanguage mapping if not explicitly set in ocrConfig
+    if (userConfig.ocrLanguage && !userConfig.ocrConfig?.language) {
+        config.ocrConfig.language = userConfig.ocrLanguage;
+    }
+    // 4. Propagate the top-level abortSignal to ocrConfig so the OCR subsystem is aware of it
+    if (config.abortSignal) {
+        config.ocrConfig.abortSignal = config.abortSignal;
+    }
+    return config;
+}
+/** The per-destination and metadata sub-objects a generator config groups its settings into. */
+const GENERATOR_CONFIG_CONTAINERS = [
+    'metadataOverrides', 'htmlConfig', 'mdConfig', 'pdfConfig',
+    'csvConfig', 'textConfig', 'rtfConfig', 'chunksConfig',
+];
+/**
+ * Copies a generator config's containers so writes during generation cannot reach the caller.
+ *
+ * One level is enough: the containers are what generation writes to. Everything else is copied
+ * by reference on purpose, since callbacks, `styleMap` and `abortSignal` are values whose
+ * identity matters, and a duplicated `AbortSignal` would no longer be tied to its controller.
+ *
+ * @param source - The caller's configuration
+ * @returns An equivalent configuration owned by us
+ */
+function copyGeneratorConfigContainers(source) {
+    const copy = { ...source };
+    for (const key of GENERATOR_CONFIG_CONTAINERS) {
+        const container = source[key];
+        if (container && typeof container === 'object')
+            copy[key] = { ...container };
+    }
+    return copy;
+}
+/**
+ * Resolves a full, destination-specific configuration by merging defaults,
+ * AST-level settings, and user-provided overrides.
+ *
+ * As with {@link resolveParserConfig}, the returned object belongs solely to the caller of this
+ * function, so that per-run normalization cannot edit a config the caller still holds.
+ *
+ * @param destination - The target format
+ * @param userConfig - Optional configuration provided by the user
+ * @param astConfig - Optional configuration from the source AST (for inheritance)
+ * @returns A fully populated configuration object, owned by the caller
+ */
+function resolveGeneratorConfig(destination, astConfig, userConfig) {
+    // Already complete, so nothing to merge. Still copied rather than handed straight back, for
+    // the same reason as resolveParserConfig: generation writes to the config it is given. The
+    // width check below normalizes an invalid `containerWidth` to 'auto', and doing that to the
+    // caller's own object both edits a value they still hold and silences the warning on every
+    // later run, so the same config would report a problem once and then appear clean.
+    if (isFullGeneratorConfig(userConfig) && !astConfig) {
+        const resolved = copyGeneratorConfigContainers(userConfig);
+        validateHtmlConfigWidth(resolved.htmlConfig, resolved);
+        return resolved;
+    }
+    // 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, rtfConfig, chunksConfig, ...commonProps } = userConfig;
+        Object.assign(config, withoutPrototypeKeys(commonProps));
+        // Merge sub-configs individually, ignoring undefined properties to preserve defaults
+        const mergeSubConfig = (target, source) => {
+            if (!source)
+                return;
+            for (const key in source) {
+                // Both guards are load-bearing and neither subsumes the other. The own-property
+                // check (matching deepClone above) stops inherited enumerable properties, which
+                // matters once anything else in the process has already polluted a prototype. It
+                // does NOT stop this attack on its own: `JSON.parse('{"__proto__":{...}}')` yields
+                // `__proto__` as an own enumerable key, so it passes hasOwnProperty and would be
+                // written straight through to Object.prototype by the recursion below.
+                if (!Object.prototype.hasOwnProperty.call(source, key))
+                    continue;
+                if (PROTOTYPE_POLLUTION_KEYS.has(key))
+                    continue;
+                if (source[key] !== undefined) {
+                    // Deep merge plain objects (like injections or margin)
+                    if (typeof source[key] === 'object' &&
+                        source[key] !== null &&
+                        !Array.isArray(source[key]) &&
+                        !(source[key] instanceof Function) &&
+                        !(source[key] instanceof Date) &&
+                        !(source[key] instanceof RegExp) &&
+                        !(source[key] instanceof Buffer)) {
+                        if (!target[key] || typeof target[key] !== 'object') {
+                            target[key] = {};
+                        }
+                        mergeSubConfig(target[key], source[key]);
+                    }
+                    else {
+                        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 (rtfConfig)
+            mergeSubConfig(config.rtfConfig, rtfConfig);
+        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.
+        }
+    }
+    validateHtmlConfigWidth(config.htmlConfig, config);
+    return config;
+}
+/**
+ * Validates the containerWidth option for HTML generation.
+ * Can be 'auto', a positive number, or a positive CSS length/percentage string.
+ */
+function isValidContainerWidth(width) {
+    if (width === 'auto')
+        return true;
+    if (typeof width === 'number') {
+        return Number.isFinite(width) && width > 0;
+    }
+    if (typeof width === 'string') {
+        const val = width.trim().toLowerCase();
+        if (val === 'auto')
+            return true;
+        const match = val.match(/^((?:\d*\.)?\d+)(px|%|em|rem|vw|vh|vmin|vmax|ch|in|cm|mm|pt|pc)?$/);
+        if (!match)
+            return false;
+        const numericValue = parseFloat(match[1]);
+        return numericValue > 0;
+    }
+    return false;
+}
+/**
+ * Emits a warning and falls back to 'auto' if the HTML containerWidth is invalid.
+ */
+function validateHtmlConfigWidth(htmlConfig, config) {
+    if (htmlConfig?.containerWidth !== undefined) {
+        const width = htmlConfig.containerWidth;
+        if (!isValidContainerWidth(width)) {
+            (0, errorUtils_js_1.logWarning)(types_js_1.OfficeWarningType.INVALID_CONTAINER_WIDTH, config, width);
+            htmlConfig.containerWidth = 'auto';
+        }
+    }
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Date Parsing Utilities
+ *
+ * Provides robust functions for parsing date strings from various office formats.
+ * Handles standard ISO dates, PDF-specific date formats, and malformed strings.
+ *
+ * @module dateUtils
+ */
+/**
+ * Parses a date string into a Date object.
+ * Handles standard ISO formats and falls back to native parsing.
+ * Returns undefined instead of "Invalid Date" if parsing fails.
+ *
+ * @param dateString - The date string to parse
+ * @returns Parsed Date object or undefined if parsing fails
+ */
+export declare function parseOfficeDate(dateString: string | undefined): Date | undefined;

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

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Date Parsing Utilities
+ *
+ * Provides robust functions for parsing date strings from various office formats.
+ * Handles standard ISO dates, PDF-specific date formats, and malformed strings.
+ *
+ * @module dateUtils
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseOfficeDate = parseOfficeDate;
+/**
+ * Parses a date string into a Date object.
+ * Handles standard ISO formats and falls back to native parsing.
+ * Returns undefined instead of "Invalid Date" if parsing fails.
+ *
+ * @param dateString - The date string to parse
+ * @returns Parsed Date object or undefined if parsing fails
+ */
+function parseOfficeDate(dateString) {
+    if (!dateString)
+        return undefined;
+    try {
+        // PDF-specific format detection: D:YYYYMMDDHHmmSSOHH'mm'
+        if (dateString.startsWith('D:')) {
+            return parsePdfDate(dateString);
+        }
+        const date = new Date(dateString);
+        return isNaN(date.getTime()) ? undefined : date;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Internal helper for PDF-specific date format: D:YYYYMMDDHHmmSSOHH'mm'
+ * @param dateString - The PDF date string
+ */
+function parsePdfDate(dateString) {
+    try {
+        // Remove "D:" prefix
+        let str = dateString.slice(2);
+        // Extract components: YYYYMMDDHHmmSS
+        const year = parseInt(str.slice(0, 4), 10);
+        const month = parseInt(str.slice(4, 6), 10) - 1; // 0-indexed
+        const day = parseInt(str.slice(6, 8), 10) || 1;
+        const hour = parseInt(str.slice(8, 10), 10) || 0;
+        const minute = parseInt(str.slice(10, 12), 10) || 0;
+        const second = parseInt(str.slice(12, 14), 10) || 0;
+        // Handle timezone if present
+        const tzMatch = str.slice(14).match(/([+-Z])(\d{2})'?(\d{2})?'?/);
+        if (tzMatch) {
+            if (tzMatch[1] === 'Z') {
+                return new Date(Date.UTC(year, month, day, hour, minute, second));
+            }
+            const tzSign = tzMatch[1] === '-' ? -1 : 1;
+            const tzHours = parseInt(tzMatch[2], 10) || 0;
+            const tzMinutes = parseInt(tzMatch[3], 10) || 0;
+            const offset = tzSign * (tzHours * 60 + tzMinutes);
+            // Create date in UTC and adjust for timezone
+            const utc = Date.UTC(year, month, day, hour, minute, second);
+            return new Date(utc - offset * 60000);
+        }
+        return new Date(year, month, day, hour, minute, second);
+    }
+    catch {
+        return undefined;
+    }
+}

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

@@ -0,0 +1,29 @@
+/**
+ * Environment detection and safe utility wrappers.
+ */
+/**
+ * Detect if we are running in a browser environment.
+ */
+export declare const isBrowser: boolean;
+/**
+ * Supported Node.js-only features that require explicit guarding for browser compatibility.
+ */
+export type NodeFeature = 'fs' | 'path-parsing' | 'pdf-worker-auto-resolution';
+/**
+ * Throws an error if attempted to use Node.js-specific features in the browser.
+ *
+ * @param feature - The Node.js feature being accessed
+ * @throws {Error} Clear error message directing browser users to use Buffers
+ */
+export declare function assertNode(feature: NodeFeature): void;
+/**
+ * Polyfills environment features not available globally (required for Node.js < 20).
+ * This shim provides enough properties for pdfjs-dist 5.x to calculate
+ * text coordinates and transformations, and guards against modern RegExp flags.
+ */
+export declare function ensureEnvPolyfills(): void;
+/**
+ * Backward-compatible alias for ensureEnvPolyfills.
+ * @deprecated Use ensureEnvPolyfills instead.
+ */
+export declare const ensureDomMatrix: typeof ensureEnvPolyfills;

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

@@ -0,0 +1,152 @@
+"use strict";
+/**
+ * Environment detection and safe utility wrappers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDomMatrix = exports.isBrowser = void 0;
+exports.assertNode = assertNode;
+exports.ensureEnvPolyfills = ensureEnvPolyfills;
+/**
+ * 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.
+ */
+const readableFeatures = {
+    'fs': 'direct file system access',
+    'path-parsing': 'parsing from file path string',
+    'pdf-worker-auto-resolution': 'automatic PDF worker resolution from node_modules'
+};
+/**
+ * Throws an error if attempted to use Node.js-specific features in the browser.
+ *
+ * @param feature - The Node.js feature being accessed
+ * @throws {Error} Clear error message directing browser users to use Buffers
+ */
+function assertNode(feature) {
+    if (exports.isBrowser) {
+        throw (0, errorUtils_js_1.getOfficeError)(types_js_1.OfficeErrorType.FEATURE_NOT_SUPPORTED_IN_BROWSER, undefined, readableFeatures[feature]);
+    }
+}
+/**
+ * Polyfills environment features not available globally (required for Node.js < 20).
+ * This shim provides enough properties for pdfjs-dist 5.x to calculate
+ * text coordinates and transformations, and guards against modern RegExp flags.
+ */
+function ensureEnvPolyfills() {
+    if (typeof global !== 'undefined') {
+        // 1. DOMMatrix Polyfill (Node.js < 20)
+        if (!global.DOMMatrix) {
+            global.DOMMatrix = class DOMMatrix {
+                a;
+                b;
+                c;
+                d;
+                e;
+                f;
+                constructor(init) {
+                    if (Array.isArray(init) && init.length >= 6) {
+                        this.a = init[0];
+                        this.b = init[1];
+                        this.c = init[2];
+                        this.d = init[3];
+                        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;
+                    }
+                }
+                // 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
+                    };
+                }
+            };
+        }
+        // 2. ImageData Polyfill (Node.js < 20)
+        if (!global.ImageData) {
+            global.ImageData = class ImageData {
+                width;
+                height;
+                data;
+                constructor(data, width, height) {
+                    this.data = data;
+                    this.width = width;
+                    this.height = height;
+                }
+            };
+        }
+        // 3. RegExp 'v' flag Polyfill (Node.js < 20)
+        // Modern dependencies (file-type 22+, pdfjs-dist 5+) might use the 'v' flag.
+        // We wrap the constructor to downgrade 'v' to 'u' in Node 18.
+        const OriginalRegExp = global.RegExp;
+        try {
+            new OriginalRegExp('', 'v');
+        }
+        catch (e) {
+            // 'v' flag is not supported (Node 18), apply fallback wrapper
+            const RegExpWrapper = function (pattern, flags) {
+                if (typeof flags === 'string' && flags.includes('v')) {
+                    // Fallback 'v' to 'u' (Unicode sets to Unicode)
+                    return new OriginalRegExp(pattern, flags.replace('v', 'u'));
+                }
+                return new OriginalRegExp(pattern, flags);
+            };
+            // Maintain prototype chain and static methods
+            RegExpWrapper.prototype = OriginalRegExp.prototype;
+            Object.setPrototypeOf(RegExpWrapper, OriginalRegExp);
+            global.RegExp = RegExpWrapper;
+        }
+    }
+}
+/**
+ * Backward-compatible alias for ensureEnvPolyfills.
+ * @deprecated Use ensureEnvPolyfills instead.
+ */
+exports.ensureDomMatrix = ensureEnvPolyfills;

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

@@ -0,0 +1,72 @@
+/**
+ * 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.
+ */
+import { OfficeError, OfficeErrorType, OfficeParserConfig, OfficeWarningType } from '../types.js';
+/**
+ * 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 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 - 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) => OfficeError;
+/**
+ * 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
+ */
+export declare const getWrappedError: (error: any, config: OfficeParserConfig, filePath?: string) => Error;
+/**
+ * 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
+ */
+export declare const logWarning: (type: OfficeWarningType, config?: OfficeParserConfig, info?: any, error?: any) => void;
+/**
+ * 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
+ */
+export declare const getAbortError: () => Error;
+/**
+ * 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
+ */
+export declare const checkAbortSignal: (signal?: AbortSignal | null) => void;