openredaction 1.0.0

package/dist/chunk-7OGNW2MU.mjs

@@ -0,0 +1,1701 @@
+import {
+  __require
+} from "./chunk-WMJKH4XE.mjs";
+
+// src/document/OCRProcessor.ts
+var OCRProcessor = class {
+  constructor() {
+    try {
+      this.tesseract = __require("tesseract.js");
+    } catch {
+    }
+  }
+  /**
+   * Extract text from image buffer using OCR
+   */
+  async recognizeText(buffer, options) {
+    if (!this.tesseract) {
+      throw new Error(
+        "[OCRProcessor] OCR support requires tesseract.js. Install with: npm install tesseract.js"
+      );
+    }
+    const startTime = performance.now();
+    try {
+      const language = Array.isArray(options?.language) ? options.language.join("+") : options?.language || "eng";
+      const worker = await this.tesseract.createWorker(language, options?.oem || 3);
+      if (options?.psm !== void 0) {
+        await worker.setParameters({
+          tessedit_pageseg_mode: options.psm
+        });
+      }
+      const result = await worker.recognize(buffer);
+      await worker.terminate();
+      const endTime = performance.now();
+      const processingTime = Math.round((endTime - startTime) * 100) / 100;
+      return {
+        text: result.data.text || "",
+        confidence: result.data.confidence || 0,
+        processingTime
+      };
+    } catch (error) {
+      throw new Error(`[OCRProcessor] OCR recognition failed: ${error.message}`);
+    }
+  }
+  /**
+   * Check if OCR is available (tesseract.js installed)
+   */
+  isAvailable() {
+    return !!this.tesseract;
+  }
+  /**
+   * Create a scheduler for batch OCR processing
+   * More efficient for processing multiple images
+   */
+  async createScheduler(workerCount = 4) {
+    if (!this.tesseract) {
+      throw new Error(
+        "[OCRProcessor] OCR support requires tesseract.js. Install with: npm install tesseract.js"
+      );
+    }
+    if (this.scheduler) {
+      await this.scheduler.terminate();
+    }
+    this.scheduler = this.tesseract.createScheduler();
+    const workers = [];
+    for (let i = 0; i < workerCount; i++) {
+      const worker = await this.tesseract.createWorker("eng");
+      this.scheduler.addWorker(worker);
+      workers.push(worker);
+    }
+    return this.scheduler;
+  }
+  /**
+   * Batch process multiple images
+   */
+  async recognizeBatch(buffers, _options) {
+    if (!this.tesseract) {
+      throw new Error(
+        "[OCRProcessor] OCR support requires tesseract.js. Install with: npm install tesseract.js"
+      );
+    }
+    const scheduler = await this.createScheduler();
+    try {
+      const results = await Promise.all(
+        buffers.map(async (buffer) => {
+          const startTime = performance.now();
+          const result = await scheduler.addJob("recognize", buffer);
+          const endTime = performance.now();
+          return {
+            text: result.data.text || "",
+            confidence: result.data.confidence || 0,
+            processingTime: Math.round((endTime - startTime) * 100) / 100
+          };
+        })
+      );
+      await scheduler.terminate();
+      this.scheduler = void 0;
+      return results;
+    } catch (error) {
+      if (scheduler) {
+        await scheduler.terminate();
+        this.scheduler = void 0;
+      }
+      throw new Error(`[OCRProcessor] Batch OCR failed: ${error.message}`);
+    }
+  }
+  /**
+   * Terminate any running scheduler
+   */
+  async cleanup() {
+    if (this.scheduler) {
+      await this.scheduler.terminate();
+      this.scheduler = void 0;
+    }
+  }
+};
+function createOCRProcessor() {
+  return new OCRProcessor();
+}
+
+// src/document/JsonProcessor.ts
+var JsonProcessor = class {
+  constructor() {
+    this.defaultOptions = {
+      maxDepth: 100,
+      scanKeys: false,
+      alwaysRedact: [],
+      skipPaths: [],
+      piiIndicatorKeys: [
+        "email",
+        "e-mail",
+        "mail",
+        "phone",
+        "tel",
+        "telephone",
+        "mobile",
+        "ssn",
+        "social_security",
+        "address",
+        "street",
+        "city",
+        "zip",
+        "postal",
+        "name",
+        "firstname",
+        "lastname",
+        "fullname",
+        "password",
+        "pwd",
+        "secret",
+        "token",
+        "key",
+        "card",
+        "credit_card",
+        "creditcard",
+        "account",
+        "iban",
+        "swift",
+        "passport",
+        "license",
+        "licence"
+      ],
+      preserveStructure: true
+    };
+  }
+  /**
+   * Parse JSON from buffer or string
+   */
+  parse(input) {
+    try {
+      const text = typeof input === "string" ? input : input.toString("utf-8");
+      return JSON.parse(text);
+    } catch (error) {
+      throw new Error(`[JsonProcessor] Invalid JSON: ${error.message}`);
+    }
+  }
+  /**
+   * Detect PII in JSON data
+   */
+  detect(data, detector, options) {
+    const opts = { ...this.defaultOptions, ...options };
+    const pathsDetected = [];
+    const matchesByPath = {};
+    const allDetections = [];
+    this.traverse(data, "", opts, (path, value, key) => {
+      if (this.shouldSkip(path, opts.skipPaths)) {
+        return;
+      }
+      if (this.shouldAlwaysRedact(path, opts.alwaysRedact)) {
+        const detection = {
+          type: "SENSITIVE_FIELD",
+          value: String(value),
+          placeholder: `[SENSITIVE_FIELD]`,
+          position: [0, String(value).length],
+          severity: "high",
+          confidence: 1
+        };
+        matchesByPath[path] = [detection];
+        pathsDetected.push(path);
+        allDetections.push(detection);
+        return;
+      }
+      if (opts.scanKeys && key) {
+        const keyResult = detector.detect(key);
+        if (keyResult.detections.length > 0) {
+          const keyPath = `${path}.__key__`;
+          matchesByPath[keyPath] = keyResult.detections;
+          pathsDetected.push(keyPath);
+          allDetections.push(...keyResult.detections);
+        }
+      }
+      const valueStr = String(value);
+      const result = detector.detect(valueStr);
+      if (result.detections.length > 0) {
+        const boostedDetections = this.boostConfidenceFromKey(
+          result.detections,
+          key,
+          opts.piiIndicatorKeys
+        );
+        matchesByPath[path] = boostedDetections;
+        pathsDetected.push(path);
+        allDetections.push(...boostedDetections);
+      }
+    });
+    const original = JSON.stringify(data);
+    const redacted = this.redact(data, {
+      original,
+      redacted: original,
+      detections: allDetections,
+      redactionMap: {},
+      stats: { piiCount: allDetections.length },
+      pathsDetected,
+      matchesByPath
+    }, opts);
+    const redactionMap = {};
+    allDetections.forEach((det) => {
+      redactionMap[det.placeholder] = det.value;
+    });
+    return {
+      original,
+      redacted: typeof redacted === "string" ? redacted : JSON.stringify(redacted),
+      detections: allDetections,
+      redactionMap,
+      stats: {
+        piiCount: allDetections.length
+      },
+      pathsDetected,
+      matchesByPath
+    };
+  }
+  /**
+   * Redact PII in JSON data
+   */
+  redact(data, detectionResult, options) {
+    const opts = { ...this.defaultOptions, ...options };
+    if (!opts.preserveStructure) {
+      return this.parse(this.redactText(JSON.stringify(data, null, 2), detectionResult));
+    }
+    return this.redactPreservingStructure(data, detectionResult.pathsDetected);
+  }
+  /**
+   * Redact specific paths in JSON while preserving structure
+   */
+  redactPreservingStructure(data, pathsToRedact) {
+    const pathSet = new Set(pathsToRedact);
+    const redactValue = (value, currentPath) => {
+      if (pathSet.has(currentPath)) {
+        if (typeof value === "string") {
+          return "[REDACTED]";
+        } else if (typeof value === "number") {
+          return 0;
+        } else if (typeof value === "boolean") {
+          return false;
+        } else if (value === null) {
+          return null;
+        } else if (Array.isArray(value)) {
+          return [];
+        } else if (typeof value === "object") {
+          return {};
+        }
+        return "[REDACTED]";
+      }
+      if (Array.isArray(value)) {
+        return value.map(
+          (item, index) => redactValue(item, `${currentPath}[${index}]`)
+        );
+      }
+      if (value !== null && typeof value === "object") {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+          const newPath = currentPath ? `${currentPath}.${key}` : key;
+          result[key] = redactValue(val, newPath);
+        }
+        return result;
+      }
+      return value;
+    };
+    return redactValue(data, "");
+  }
+  /**
+   * Simple text-based redaction (fallback)
+   */
+  redactText(text, detectionResult) {
+    let redacted = text;
+    const sortedDetections = [...detectionResult.detections].sort((a, b) => b.position[0] - a.position[0]);
+    for (const detection of sortedDetections) {
+      const [start, end] = detection.position;
+      redacted = redacted.slice(0, start) + detection.placeholder + redacted.slice(end);
+    }
+    return redacted;
+  }
+  /**
+   * Traverse JSON structure and call callback for each value
+   */
+  traverse(obj, path, options, callback, depth = 0) {
+    if (depth > options.maxDepth) {
+      throw new Error(`[JsonProcessor] Maximum depth (${options.maxDepth}) exceeded`);
+    }
+    if (obj === null || obj === void 0) {
+      return;
+    }
+    if (Array.isArray(obj)) {
+      obj.forEach((item, index) => {
+        const itemPath = path ? `${path}[${index}]` : `[${index}]`;
+        if (this.isPrimitive(item)) {
+          callback(itemPath, item);
+        }
+        this.traverse(item, itemPath, options, callback, depth + 1);
+      });
+      return;
+    }
+    if (typeof obj === "object") {
+      for (const [key, value] of Object.entries(obj)) {
+        const valuePath = path ? `${path}.${key}` : key;
+        if (this.isPrimitive(value)) {
+          callback(valuePath, value, key);
+        }
+        this.traverse(value, valuePath, options, callback, depth + 1);
+      }
+      return;
+    }
+    if (this.isPrimitive(obj)) {
+      callback(path, obj);
+    }
+  }
+  /**
+   * Check if value is primitive (string, number, boolean)
+   */
+  isPrimitive(value) {
+    return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  }
+  /**
+   * Check if path should be skipped
+   */
+  shouldSkip(path, skipPaths) {
+    return skipPaths.some((skipPath) => {
+      if (path === skipPath) return true;
+      const skipRegex = new RegExp("^" + skipPath.replace(/\*/g, "[^.]+") + "$");
+      return skipRegex.test(path);
+    });
+  }
+  /**
+   * Check if path should always be redacted
+   */
+  shouldAlwaysRedact(path, alwaysRedact) {
+    return alwaysRedact.some((redactPath) => {
+      if (path === redactPath) return true;
+      const redactRegex = new RegExp("^" + redactPath.replace(/\*/g, "[^.]+") + "$");
+      return redactRegex.test(path);
+    });
+  }
+  /**
+   * Boost confidence if key name indicates PII
+   */
+  boostConfidenceFromKey(detections, key, piiIndicatorKeys) {
+    if (!key) return detections;
+    const keyLower = key.toLowerCase();
+    const isPiiKey = piiIndicatorKeys.some(
+      (indicator) => keyLower.includes(indicator.toLowerCase())
+    );
+    if (!isPiiKey) return detections;
+    return detections.map((detection) => ({
+      ...detection,
+      confidence: Math.min(1, (detection.confidence || 0.5) * 1.2)
+    }));
+  }
+  /**
+   * Extract all text values from JSON for simple text-based detection
+   */
+  extractText(data, options) {
+    const opts = { ...this.defaultOptions, ...options };
+    const textParts = [];
+    this.traverse(data, "", opts, (_path, value, key) => {
+      if (opts.scanKeys && key) {
+        textParts.push(key);
+      }
+      if (typeof value === "string") {
+        textParts.push(value);
+      }
+    });
+    return textParts.join(" ");
+  }
+  /**
+   * Validate JSON buffer/string
+   */
+  isValid(input) {
+    try {
+      this.parse(input);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get JSON Lines (JSONL) support - split by newlines and parse each line
+   */
+  parseJsonLines(input) {
+    const text = typeof input === "string" ? input : input.toString("utf-8");
+    const lines = text.split("\n").filter((line) => line.trim().length > 0);
+    return lines.map((line, index) => {
+      try {
+        return JSON.parse(line);
+      } catch (error) {
+        throw new Error(`[JsonProcessor] Invalid JSON at line ${index + 1}: ${error.message}`);
+      }
+    });
+  }
+  /**
+   * Detect PII in JSON Lines format
+   */
+  detectJsonLines(input, detector, options) {
+    const documents = this.parseJsonLines(input);
+    return documents.map((doc) => this.detect(doc, detector, options));
+  }
+};
+function createJsonProcessor() {
+  return new JsonProcessor();
+}
+
+// src/document/CsvProcessor.ts
+var CsvProcessor = class {
+  constructor() {
+    this.defaultOptions = {
+      quote: '"',
+      escape: '"',
+      skipEmptyLines: true,
+      piiIndicatorNames: [
+        "email",
+        "e-mail",
+        "mail",
+        "email_address",
+        "phone",
+        "tel",
+        "telephone",
+        "mobile",
+        "phone_number",
+        "ssn",
+        "social_security",
+        "social_security_number",
+        "address",
+        "street",
+        "street_address",
+        "city",
+        "zip",
+        "zipcode",
+        "postal",
+        "postcode",
+        "name",
+        "firstname",
+        "first_name",
+        "lastname",
+        "last_name",
+        "fullname",
+        "full_name",
+        "password",
+        "pwd",
+        "secret",
+        "token",
+        "api_key",
+        "card",
+        "credit_card",
+        "creditcard",
+        "card_number",
+        "account",
+        "account_number",
+        "iban",
+        "swift",
+        "passport",
+        "passport_number",
+        "license",
+        "licence",
+        "driver_license",
+        "dob",
+        "date_of_birth",
+        "birth_date",
+        "birthdate"
+      ],
+      treatFirstRowAsHeader: true
+    };
+  }
+  /**
+   * Parse CSV from buffer or string
+   */
+  parse(input, options) {
+    const opts = { ...this.defaultOptions, ...options };
+    const text = typeof input === "string" ? input : input.toString("utf-8");
+    const delimiter = opts.delimiter || this.detectDelimiter(text);
+    const lines = text.split(/\r?\n/);
+    const rows = [];
+    let rowIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (opts.skipEmptyLines && line.trim().length === 0) {
+        continue;
+      }
+      if (opts.maxRows !== void 0 && rowIndex >= opts.maxRows) {
+        break;
+      }
+      const values = this.parseRow(line, delimiter, opts.quote, opts.escape);
+      rows.push({
+        index: rowIndex,
+        values
+      });
+      rowIndex++;
+    }
+    return rows;
+  }
+  /**
+   * Detect PII in CSV data
+   */
+  detect(input, detector, options) {
+    const opts = { ...this.defaultOptions, ...options };
+    const rows = this.parse(input, options);
+    if (rows.length === 0) {
+      const original2 = typeof input === "string" ? input : input.toString("utf-8");
+      return {
+        original: original2,
+        redacted: original2,
+        detections: [],
+        redactionMap: {},
+        stats: {
+          piiCount: 0
+        },
+        rowCount: 0,
+        columnCount: 0,
+        columnStats: {},
+        matchesByCell: []
+      };
+    }
+    const hasHeader = opts.hasHeader !== void 0 ? opts.hasHeader : this.detectHeader(rows);
+    const headers = hasHeader && rows.length > 0 ? rows[0].values : void 0;
+    const dataRows = hasHeader ? rows.slice(1) : rows;
+    const columnCount = rows[0].values.length;
+    const columnNameToIndex = /* @__PURE__ */ new Map();
+    if (headers) {
+      headers.forEach((header, index) => {
+        columnNameToIndex.set(header.toLowerCase().trim(), index);
+      });
+    }
+    const alwaysRedactCols = new Set(opts.alwaysRedactColumns || []);
+    if (opts.alwaysRedactColumnNames && headers) {
+      opts.alwaysRedactColumnNames.forEach((name) => {
+        const index = columnNameToIndex.get(name.toLowerCase().trim());
+        if (index !== void 0) {
+          alwaysRedactCols.add(index);
+        }
+      });
+    }
+    const skipCols = new Set(opts.skipColumns || []);
+    const columnStats = {};
+    const matchesByCell = [];
+    const allDetections = [];
+    for (let col = 0; col < columnCount; col++) {
+      columnStats[col] = {
+        columnIndex: col,
+        columnName: headers?.[col],
+        piiCount: 0,
+        piiPercentage: 0,
+        piiTypes: []
+      };
+    }
+    for (const row of dataRows) {
+      for (let col = 0; col < row.values.length; col++) {
+        if (skipCols.has(col)) {
+          continue;
+        }
+        const cellValue = row.values[col];
+        if (alwaysRedactCols.has(col)) {
+          const detection = {
+            type: "SENSITIVE_COLUMN",
+            value: cellValue,
+            placeholder: `[SENSITIVE_COLUMN_${col}]`,
+            position: [0, cellValue.length],
+            severity: "high",
+            confidence: 1
+          };
+          matchesByCell.push({
+            row: row.index,
+            column: col,
+            columnName: headers?.[col],
+            value: cellValue,
+            matches: [detection]
+          });
+          allDetections.push(detection);
+          columnStats[col].piiCount++;
+          continue;
+        }
+        const result = detector.detect(cellValue);
+        if (result.detections.length > 0) {
+          const boostedDetections = this.boostConfidenceFromColumnName(
+            result.detections,
+            headers?.[col],
+            opts.piiIndicatorNames || []
+          );
+          matchesByCell.push({
+            row: row.index,
+            column: col,
+            columnName: headers?.[col],
+            value: cellValue,
+            matches: boostedDetections
+          });
+          allDetections.push(...boostedDetections);
+          columnStats[col].piiCount += boostedDetections.length;
+          const columnTypes = new Set(columnStats[col].piiTypes);
+          boostedDetections.forEach((d) => columnTypes.add(d.type));
+          columnStats[col].piiTypes = Array.from(columnTypes);
+        }
+      }
+    }
+    for (let col = 0; col < columnCount; col++) {
+      const rowsWithPii = matchesByCell.filter((m) => m.column === col).length;
+      columnStats[col].piiPercentage = dataRows.length > 0 ? rowsWithPii / dataRows.length * 100 : 0;
+    }
+    const original = typeof input === "string" ? input : input.toString("utf-8");
+    const redacted = this.redact(original, {
+      original,
+      redacted: original,
+      detections: allDetections,
+      redactionMap: {},
+      stats: { piiCount: allDetections.length },
+      rowCount: dataRows.length,
+      columnCount,
+      headers,
+      columnStats,
+      matchesByCell
+    }, opts);
+    const redactionMap = {};
+    allDetections.forEach((det) => {
+      redactionMap[det.placeholder] = det.value;
+    });
+    return {
+      original,
+      redacted,
+      detections: allDetections,
+      redactionMap,
+      stats: {
+        piiCount: allDetections.length
+      },
+      rowCount: dataRows.length,
+      columnCount,
+      headers: headers?.filter((h) => h !== void 0),
+      columnStats,
+      matchesByCell
+    };
+  }
+  /**
+   * Redact PII in CSV data
+   */
+  redact(input, detectionResult, options) {
+    const opts = { ...this.defaultOptions, ...options };
+    const rows = this.parse(input, options);
+    if (rows.length === 0) {
+      return "";
+    }
+    const delimiter = opts.delimiter || this.detectDelimiter(
+      typeof input === "string" ? input : input.toString("utf-8")
+    );
+    const hasHeader = detectionResult.headers !== void 0;
+    const redactionMap = /* @__PURE__ */ new Map();
+    for (const cellMatch of detectionResult.matchesByCell) {
+      if (!redactionMap.has(cellMatch.row)) {
+        redactionMap.set(cellMatch.row, /* @__PURE__ */ new Map());
+      }
+      redactionMap.get(cellMatch.row).set(
+        cellMatch.column,
+        "[REDACTED]"
+      );
+    }
+    const outputRows = [];
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      const isHeaderRow = hasHeader && i === 0;
+      if (isHeaderRow) {
+        outputRows.push(this.formatRow(row.values, delimiter, opts.quote));
+      } else {
+        const rowIndex = hasHeader ? i - 1 : i;
+        const redactedValues = row.values.map((value, colIndex) => {
+          return redactionMap.get(rowIndex)?.get(colIndex) || value;
+        });
+        outputRows.push(this.formatRow(redactedValues, delimiter, opts.quote));
+      }
+    }
+    return outputRows.join("\n");
+  }
+  /**
+   * Parse a single CSV row
+   */
+  parseRow(line, delimiter, quote, _escape) {
+    const values = [];
+    let current = "";
+    let inQuotes = false;
+    let i = 0;
+    while (i < line.length) {
+      const char = line[i];
+      const nextChar = line[i + 1];
+      if (char === quote) {
+        if (inQuotes && nextChar === quote) {
+          current += quote;
+          i += 2;
+        } else {
+          inQuotes = !inQuotes;
+          i++;
+        }
+      } else if (char === delimiter && !inQuotes) {
+        values.push(current);
+        current = "";
+        i++;
+      } else {
+        current += char;
+        i++;
+      }
+    }
+    values.push(current);
+    return values;
+  }
+  /**
+   * Format a row as CSV
+   */
+  formatRow(values, delimiter, quote) {
+    return values.map((value) => {
+      if (value.includes(delimiter) || value.includes(quote) || value.includes("\n")) {
+        const escaped = value.replace(new RegExp(quote, "g"), quote + quote);
+        return `${quote}${escaped}${quote}`;
+      }
+      return value;
+    }).join(delimiter);
+  }
+  /**
+   * Auto-detect CSV delimiter
+   */
+  detectDelimiter(text) {
+    const delimiters = [",", "	", ";", "|"];
+    const lines = text.split(/\r?\n/).slice(0, 5);
+    let bestDelimiter = ",";
+    let bestScore = 0;
+    for (const delimiter of delimiters) {
+      const counts = lines.map((line) => {
+        let count = 0;
+        let inQuotes = false;
+        for (const char of line) {
+          if (char === '"') inQuotes = !inQuotes;
+          if (char === delimiter && !inQuotes) count++;
+        }
+        return count;
+      });
+      if (counts.length > 0 && counts[0] > 0) {
+        const avg = counts.reduce((a, b) => a + b, 0) / counts.length;
+        const variance = counts.reduce((sum, c) => sum + Math.pow(c - avg, 2), 0) / counts.length;
+        const score = avg / (variance + 1);
+        if (score > bestScore) {
+          bestScore = score;
+          bestDelimiter = delimiter;
+        }
+      }
+    }
+    return bestDelimiter;
+  }
+  /**
+   * Detect if first row is likely a header
+   */
+  detectHeader(rows) {
+    if (rows.length < 2) {
+      return false;
+    }
+    const firstRow = rows[0].values;
+    const secondRow = rows[1].values;
+    const firstRowAvgLen = firstRow.reduce((sum, v) => sum + v.length, 0) / firstRow.length;
+    const secondRowAvgLen = secondRow.reduce((sum, v) => sum + v.length, 0) / secondRow.length;
+    if (firstRowAvgLen > secondRowAvgLen * 1.5) {
+      return false;
+    }
+    const firstRowNumeric = firstRow.filter((v) => !isNaN(Number(v)) && v.trim() !== "").length;
+    const firstRowNonNumeric = firstRow.length - firstRowNumeric;
+    return firstRowNonNumeric >= firstRowNumeric;
+  }
+  /**
+   * Boost confidence if column name indicates PII
+   */
+  boostConfidenceFromColumnName(detections, columnName, piiIndicatorNames) {
+    if (!columnName) return detections;
+    const nameLower = columnName.toLowerCase().trim();
+    const isPiiColumn = piiIndicatorNames.some(
+      (indicator) => nameLower.includes(indicator.toLowerCase())
+    );
+    if (!isPiiColumn) return detections;
+    return detections.map((detection) => ({
+      ...detection,
+      confidence: Math.min(1, (detection.confidence || 0.5) * 1.2)
+    }));
+  }
+  /**
+   * Extract all cell values as text
+   */
+  extractText(input, options) {
+    const rows = this.parse(input, options);
+    const textParts = [];
+    for (const row of rows) {
+      for (const value of row.values) {
+        if (value.trim().length > 0) {
+          textParts.push(value);
+        }
+      }
+    }
+    return textParts.join(" ");
+  }
+  /**
+   * Get column statistics without full PII detection
+   */
+  getColumnInfo(input, options) {
+    const rows = this.parse(input, options);
+    if (rows.length === 0) {
+      return {
+        columnCount: 0,
+        rowCount: 0,
+        sampleRows: []
+      };
+    }
+    const opts = { ...this.defaultOptions, ...options };
+    const hasHeader = opts.hasHeader !== void 0 ? opts.hasHeader : this.detectHeader(rows);
+    const headers = hasHeader && rows.length > 0 ? rows[0].values : void 0;
+    const dataRows = hasHeader ? rows.slice(1) : rows;
+    const sampleRows = dataRows.slice(0, 5).map((r) => r.values);
+    return {
+      columnCount: rows[0].values.length,
+      rowCount: dataRows.length,
+      headers,
+      sampleRows
+    };
+  }
+};
+function createCsvProcessor() {
+  return new CsvProcessor();
+}
+
+// src/document/XlsxProcessor.ts
+var XlsxProcessor = class {
+  constructor() {
+    this.defaultOptions = {
+      piiIndicatorNames: [
+        "email",
+        "e-mail",
+        "mail",
+        "email_address",
+        "phone",
+        "tel",
+        "telephone",
+        "mobile",
+        "phone_number",
+        "ssn",
+        "social_security",
+        "social_security_number",
+        "address",
+        "street",
+        "street_address",
+        "city",
+        "zip",
+        "zipcode",
+        "postal",
+        "postcode",
+        "name",
+        "firstname",
+        "first_name",
+        "lastname",
+        "last_name",
+        "fullname",
+        "full_name",
+        "password",
+        "pwd",
+        "secret",
+        "token",
+        "api_key",
+        "card",
+        "credit_card",
+        "creditcard",
+        "card_number",
+        "account",
+        "account_number",
+        "iban",
+        "swift",
+        "passport",
+        "passport_number",
+        "license",
+        "licence",
+        "driver_license",
+        "dob",
+        "date_of_birth",
+        "birth_date",
+        "birthdate"
+      ],
+      preserveFormatting: true,
+      preserveFormulas: true
+    };
+    try {
+      this.xlsx = __require("xlsx");
+    } catch {
+    }
+  }
+  /**
+   * Check if XLSX support is available
+   */
+  isAvailable() {
+    return !!this.xlsx;
+  }
+  /**
+   * Parse XLSX from buffer
+   */
+  parse(buffer) {
+    if (!this.xlsx) {
+      throw new Error(
+        "[XlsxProcessor] XLSX support requires xlsx package. Install with: npm install xlsx"
+      );
+    }
+    try {
+      return this.xlsx.read(buffer, { type: "buffer", cellFormula: true, cellStyles: true });
+    } catch (error) {
+      throw new Error(`[XlsxProcessor] Failed to parse XLSX: ${error.message}`);
+    }
+  }
+  /**
+   * Detect PII in XLSX data
+   */
+  detect(buffer, detector, options) {
+    if (!this.xlsx) {
+      throw new Error(
+        "[XlsxProcessor] XLSX support requires xlsx package. Install with: npm install xlsx"
+      );
+    }
+    const opts = { ...this.defaultOptions, ...options };
+    const workbook = this.parse(buffer);
+    const sheetNames = this.getSheetNamesToProcess(workbook, opts);
+    const sheetResults = [];
+    const allDetections = [];
+    const allTypes = /* @__PURE__ */ new Set();
+    for (let sheetIndex = 0; sheetIndex < sheetNames.length; sheetIndex++) {
+      const sheetName = sheetNames[sheetIndex];
+      const sheet = workbook.Sheets[sheetName];
+      const sheetResult = this.detectSheet(
+        sheet,
+        sheetName,
+        sheetIndex,
+        detector,
+        opts
+      );
+      sheetResults.push(sheetResult);
+      allDetections.push(...sheetResult.matchesByCell.flatMap((c) => c.matches));
+      sheetResult.matchesByCell.forEach((cell) => {
+        cell.matches.forEach((det) => allTypes.add(det.type));
+      });
+    }
+    const original = this.extractText(buffer, options);
+    const redactedBuffer = this.redact(buffer, {
+      original,
+      redacted: original,
+      detections: allDetections,
+      redactionMap: {},
+      stats: { piiCount: allDetections.length },
+      sheetResults,
+      sheetCount: sheetResults.length
+    }, options);
+    const redacted = this.extractText(redactedBuffer, options);
+    const redactionMap = {};
+    allDetections.forEach((det) => {
+      redactionMap[det.placeholder] = det.value;
+    });
+    return {
+      original,
+      redacted,
+      detections: allDetections,
+      redactionMap,
+      stats: {
+        piiCount: allDetections.length
+      },
+      sheetResults,
+      sheetCount: sheetResults.length
+    };
+  }
+  /**
+   * Detect PII in a single sheet
+   */
+  detectSheet(sheet, sheetName, sheetIndex, detector, options) {
+    const range = this.xlsx.utils.decode_range(sheet["!ref"] || "A1");
+    const startRow = range.s.r;
+    const endRow = options.maxRows !== void 0 ? Math.min(range.e.r, startRow + options.maxRows - 1) : range.e.r;
+    const startCol = range.s.c;
+    const endCol = range.e.c;
+    const columnCount = endCol - startCol + 1;
+    const hasHeader = options.hasHeader !== void 0 ? options.hasHeader : this.detectHeader(sheet, range);
+    const headers = hasHeader ? this.getRowValues(sheet, startRow, startCol, endCol) : void 0;
+    const dataStartRow = hasHeader ? startRow + 1 : startRow;
+    const columnNameToIndex = /* @__PURE__ */ new Map();
+    if (headers) {
+      headers.forEach((header, index) => {
+        if (header) {
+          columnNameToIndex.set(header.toLowerCase().trim(), index);
+        }
+      });
+    }
+    const alwaysRedactCols = new Set(options.alwaysRedactColumns || []);
+    if (options.alwaysRedactColumnNames && headers) {
+      options.alwaysRedactColumnNames.forEach((name) => {
+        const index = columnNameToIndex.get(name.toLowerCase().trim());
+        if (index !== void 0) {
+          alwaysRedactCols.add(index);
+        }
+      });
+    }
+    const skipCols = new Set(options.skipColumns || []);
+    const columnStats = {};
+    for (let col = 0; col <= endCol - startCol; col++) {
+      columnStats[col] = {
+        columnIndex: col,
+        columnLetter: this.columnToLetter(col),
+        columnName: headers?.[col],
+        piiCount: 0,
+        piiPercentage: 0,
+        piiTypes: []
+      };
+    }
+    const matchesByCell = [];
+    for (let row = dataStartRow; row <= endRow; row++) {
+      for (let col = startCol; col <= endCol; col++) {
+        const colIndex = col - startCol;
+        if (skipCols.has(colIndex)) {
+          continue;
+        }
+        const cellRef = this.xlsx.utils.encode_cell({ r: row, c: col });
+        const cell = sheet[cellRef];
+        if (!cell) continue;
+        const cellValue = this.getCellValue(cell);
+        if (!cellValue) continue;
+        const cellFormula = cell.f;
+        if (alwaysRedactCols.has(colIndex)) {
+          const detection = {
+            type: "SENSITIVE_COLUMN",
+            value: cellValue,
+            placeholder: `[SENSITIVE_COLUMN_${colIndex}]`,
+            position: [0, cellValue.length],
+            severity: "high",
+            confidence: 1
+          };
+          matchesByCell.push({
+            cell: cellRef,
+            row: row + 1,
+            // 1-indexed for Excel
+            column: colIndex,
+            columnLetter: this.columnToLetter(colIndex),
+            columnName: headers?.[colIndex],
+            value: cellValue,
+            formula: cellFormula,
+            matches: [detection]
+          });
+          columnStats[colIndex].piiCount++;
+          continue;
+        }
+        const result = detector.detect(cellValue);
+        if (result.detections.length > 0) {
+          const boostedDetections = this.boostConfidenceFromColumnName(
+            result.detections,
+            headers?.[colIndex],
+            options.piiIndicatorNames || []
+          );
+          matchesByCell.push({
+            cell: cellRef,
+            row: row + 1,
+            // 1-indexed for Excel
+            column: colIndex,
+            columnLetter: this.columnToLetter(colIndex),
+            columnName: headers?.[colIndex],
+            value: cellValue,
+            formula: cellFormula,
+            matches: boostedDetections
+          });
+          columnStats[colIndex].piiCount += boostedDetections.length;
+          const columnTypes = new Set(columnStats[colIndex].piiTypes);
+          boostedDetections.forEach((d) => columnTypes.add(d.type));
+          columnStats[colIndex].piiTypes = Array.from(columnTypes);
+        }
+      }
+    }
+    const dataRowCount = endRow - dataStartRow + 1;
+    for (let col = 0; col <= endCol - startCol; col++) {
+      const rowsWithPii = matchesByCell.filter((m) => m.column === col).length;
+      columnStats[col].piiPercentage = dataRowCount > 0 ? rowsWithPii / dataRowCount * 100 : 0;
+    }
+    return {
+      sheetName,
+      sheetIndex,
+      rowCount: dataRowCount,
+      columnCount,
+      headers: headers?.filter((h) => h !== void 0),
+      columnStats,
+      matchesByCell
+    };
+  }
+  /**
+   * Redact PII in XLSX data
+   */
+  redact(buffer, detectionResult, options) {
+    if (!this.xlsx) {
+      throw new Error(
+        "[XlsxProcessor] XLSX support requires xlsx package. Install with: npm install xlsx"
+      );
+    }
+    const opts = { ...this.defaultOptions, ...options };
+    const workbook = this.parse(buffer);
+    for (const sheetResult of detectionResult.sheetResults) {
+      const sheet = workbook.Sheets[sheetResult.sheetName];
+      for (const cellMatch of sheetResult.matchesByCell) {
+        const cellRef = cellMatch.cell;
+        const cell = sheet[cellRef];
+        if (!cell) continue;
+        cell.v = "[REDACTED]";
+        cell.w = "[REDACTED]";
+        if (!opts.preserveFormulas) {
+          delete cell.f;
+        }
+        cell.t = "s";
+      }
+    }
+    return this.xlsx.write(workbook, { type: "buffer", bookType: "xlsx" });
+  }
+  /**
+   * Get cell value as string
+   */
+  getCellValue(cell) {
+    if (!cell) return "";
+    if (cell.w !== void 0) {
+      return String(cell.w);
+    }
+    if (cell.v !== void 0) {
+      return String(cell.v);
+    }
+    return "";
+  }
+  /**
+   * Get row values
+   */
+  getRowValues(sheet, row, startCol, endCol) {
+    const values = [];
+    for (let col = startCol; col <= endCol; col++) {
+      const cellRef = this.xlsx.utils.encode_cell({ r: row, c: col });
+      const cell = sheet[cellRef];
+      values.push(cell ? this.getCellValue(cell) : void 0);
+    }
+    return values;
+  }
+  /**
+   * Detect if first row is likely a header
+   */
+  detectHeader(sheet, range) {
+    const firstRow = this.getRowValues(sheet, range.s.r, range.s.c, range.e.c);
+    const secondRow = range.s.r + 1 <= range.e.r ? this.getRowValues(sheet, range.s.r + 1, range.s.c, range.e.c) : null;
+    if (!secondRow) return false;
+    const firstRowValues = firstRow.filter((v) => v !== void 0);
+    const secondRowValues = secondRow.filter((v) => v !== void 0);
+    if (firstRowValues.length === 0 || secondRowValues.length === 0) {
+      return false;
+    }
+    const firstRowAvgLen = firstRowValues.reduce((sum, v) => sum + v.length, 0) / firstRowValues.length;
+    const secondRowAvgLen = secondRowValues.reduce((sum, v) => sum + v.length, 0) / secondRowValues.length;
+    if (firstRowAvgLen > secondRowAvgLen * 1.5) {
+      return false;
+    }
+    const firstRowNumeric = firstRowValues.filter((v) => !isNaN(Number(v)) && v.trim() !== "").length;
+    const firstRowNonNumeric = firstRowValues.length - firstRowNumeric;
+    return firstRowNonNumeric >= firstRowNumeric;
+  }
+  /**
+   * Convert column index to letter (0 = A, 25 = Z, 26 = AA)
+   */
+  columnToLetter(col) {
+    let letter = "";
+    while (col >= 0) {
+      letter = String.fromCharCode(col % 26 + 65) + letter;
+      col = Math.floor(col / 26) - 1;
+    }
+    return letter;
+  }
+  /**
+   * Get sheet names to process based on options
+   */
+  getSheetNamesToProcess(workbook, options) {
+    const allSheetNames = workbook.SheetNames;
+    if (options.sheets && options.sheets.length > 0) {
+      return options.sheets.filter((name) => allSheetNames.includes(name));
+    }
+    if (options.sheetIndices && options.sheetIndices.length > 0) {
+      return options.sheetIndices.filter((index) => index >= 0 && index < allSheetNames.length).map((index) => allSheetNames[index]);
+    }
+    return allSheetNames;
+  }
+  /**
+   * Boost confidence if column name indicates PII
+   */
+  boostConfidenceFromColumnName(detections, columnName, piiIndicatorNames) {
+    if (!columnName) return detections;
+    const nameLower = columnName.toLowerCase().trim();
+    const isPiiColumn = piiIndicatorNames.some(
+      (indicator) => nameLower.includes(indicator.toLowerCase())
+    );
+    if (!isPiiColumn) return detections;
+    return detections.map((detection) => ({
+      ...detection,
+      confidence: Math.min(1, (detection.confidence || 0.5) * 1.2)
+    }));
+  }
+  /**
+   * Extract all cell values as text
+   */
+  extractText(buffer, options) {
+    if (!this.xlsx) {
+      throw new Error(
+        "[XlsxProcessor] XLSX support requires xlsx package. Install with: npm install xlsx"
+      );
+    }
+    const workbook = this.parse(buffer);
+    const opts = { ...this.defaultOptions, ...options };
+    const sheetNames = this.getSheetNamesToProcess(workbook, opts);
+    const textParts = [];
+    for (const sheetName of sheetNames) {
+      const sheet = workbook.Sheets[sheetName];
+      const range = this.xlsx.utils.decode_range(sheet["!ref"] || "A1");
+      for (let row = range.s.r; row <= range.e.r; row++) {
+        for (let col = range.s.c; col <= range.e.c; col++) {
+          const cellRef = this.xlsx.utils.encode_cell({ r: row, c: col });
+          const cell = sheet[cellRef];
+          if (cell) {
+            const value = this.getCellValue(cell);
+            if (value.trim().length > 0) {
+              textParts.push(value);
+            }
+          }
+        }
+      }
+    }
+    return textParts.join(" ");
+  }
+  /**
+   * Get workbook metadata
+   */
+  getMetadata(buffer) {
+    if (!this.xlsx) {
+      throw new Error(
+        "[XlsxProcessor] XLSX support requires xlsx package. Install with: npm install xlsx"
+      );
+    }
+    const workbook = this.parse(buffer);
+    return {
+      sheetNames: workbook.SheetNames,
+      sheetCount: workbook.SheetNames.length
+    };
+  }
+};
+function createXlsxProcessor() {
+  return new XlsxProcessor();
+}
+
+// src/document/DocumentProcessor.ts
+var DocumentProcessor = class {
+  constructor() {
+    try {
+      this.pdfParse = __require("pdf-parse");
+    } catch {
+    }
+    try {
+      this.mammoth = __require("mammoth");
+    } catch {
+    }
+    this.ocrProcessor = new OCRProcessor();
+    this.jsonProcessor = new JsonProcessor();
+    this.csvProcessor = new CsvProcessor();
+    this.xlsxProcessor = new XlsxProcessor();
+  }
+  /**
+   * Extract text from document buffer
+   */
+  async extractText(buffer, options) {
+    const format = options?.format || this.detectFormat(buffer);
+    if (!format) {
+      throw new Error("[DocumentProcessor] Unable to detect document format. Supported: PDF, DOCX, TXT, images (with OCR)");
+    }
+    const maxSize = options?.maxSize || 50 * 1024 * 1024;
+    if (buffer.length > maxSize) {
+      throw new Error(`[DocumentProcessor] Document size (${buffer.length} bytes) exceeds maximum (${maxSize} bytes)`);
+    }
+    switch (format) {
+      case "pdf":
+        return this.extractPdfText(buffer, options);
+      case "docx":
+        return this.extractDocxText(buffer, options);
+      case "txt":
+        return buffer.toString("utf-8");
+      case "image":
+        return this.extractImageText(buffer, options);
+      case "json":
+        return this.extractJsonText(buffer, options);
+      case "csv":
+        return this.extractCsvText(buffer, options);
+      case "xlsx":
+        return this.extractXlsxText(buffer, options);
+      default:
+        throw new Error(`[DocumentProcessor] Unsupported format: ${format}`);
+    }
+  }
+  /**
+   * Get document metadata
+   */
+  async getMetadata(buffer, options) {
+    const format = options?.format || this.detectFormat(buffer);
+    if (!format) {
+      throw new Error("[DocumentProcessor] Unable to detect document format");
+    }
+    switch (format) {
+      case "pdf":
+        return this.getPdfMetadata(buffer, options);
+      case "docx":
+        return this.getDocxMetadata(buffer, options);
+      case "txt":
+        return {
+          format: "txt",
+          pages: void 0
+        };
+      case "image":
+        return this.getImageMetadata(buffer, options);
+      case "json":
+        return this.getJsonMetadata(buffer, options);
+      case "csv":
+        return this.getCsvMetadata(buffer, options);
+      case "xlsx":
+        return this.getXlsxMetadata(buffer, options);
+      default:
+        throw new Error(`[DocumentProcessor] Unsupported format: ${format}`);
+    }
+  }
+  /**
+   * Detect document format from buffer
+   */
+  detectFormat(buffer) {
+    if (buffer.length < 4) {
+      return null;
+    }
+    if (buffer.toString("utf-8", 0, 4) === "%PDF") {
+      return "pdf";
+    }
+    if (buffer.length >= 8 && buffer[0] === 137 && buffer[1] === 80 && buffer[2] === 78 && buffer[3] === 71) {
+      return "image";
+    }
+    if (buffer[0] === 255 && buffer[1] === 216 && buffer[2] === 255) {
+      return "image";
+    }
+    if (buffer[0] === 73 && buffer[1] === 73 && buffer[2] === 42 && buffer[3] === 0 || buffer[0] === 77 && buffer[1] === 77 && buffer[2] === 0 && buffer[3] === 42) {
+      return "image";
+    }
+    if (buffer[0] === 66 && buffer[1] === 77) {
+      return "image";
+    }
+    if (buffer.length >= 12 && buffer[0] === 82 && buffer[1] === 73 && buffer[2] === 70 && buffer[3] === 70 && buffer[8] === 87 && buffer[9] === 69 && buffer[10] === 66 && buffer[11] === 80) {
+      return "image";
+    }
+    if (buffer[0] === 80 && buffer[1] === 75) {
+      const zipHeader = buffer.toString("utf-8", 0, Math.min(500, buffer.length));
+      if (zipHeader.includes("word/") || zipHeader.includes("[Content_Types].xml")) {
+        return "docx";
+      }
+      if (zipHeader.includes("xl/")) {
+        return "xlsx";
+      }
+    }
+    const text = buffer.toString("utf-8");
+    const trimmed = text.trim();
+    if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      if (this.jsonProcessor.isValid(buffer)) {
+        return "json";
+      }
+    }
+    const lines = text.split(/\r?\n/).slice(0, 5);
+    if (lines.length >= 2) {
+      const delimiters = [",", "	", ";", "|"];
+      for (const delimiter of delimiters) {
+        const counts = lines.map((line) => (line.match(new RegExp(delimiter, "g")) || []).length);
+        if (counts[0] > 0 && counts.every((c) => c === counts[0])) {
+          return "csv";
+        }
+      }
+    }
+    const sample = buffer.slice(0, Math.min(1e3, buffer.length));
+    const nonPrintable = sample.filter((byte) => byte < 32 && byte !== 9 && byte !== 10 && byte !== 13).length;
+    if (nonPrintable < sample.length * 0.1) {
+      return "txt";
+    }
+    return null;
+  }
+  /**
+   * Check if format is supported
+   */
+  isFormatSupported(format) {
+    switch (format) {
+      case "pdf":
+        return !!this.pdfParse;
+      case "docx":
+        return !!this.mammoth;
+      case "txt":
+        return true;
+      case "image":
+        return this.ocrProcessor.isAvailable();
+      case "json":
+        return true;
+      // Always supported (native)
+      case "csv":
+        return true;
+      // Always supported (native)
+      case "xlsx":
+        return this.xlsxProcessor.isAvailable();
+      default:
+        return false;
+    }
+  }
+  /**
+   * Extract text from PDF
+   */
+  async extractPdfText(buffer, options) {
+    if (!this.pdfParse) {
+      throw new Error(
+        "[DocumentProcessor] PDF support requires pdf-parse. Install with: npm install pdf-parse"
+      );
+    }
+    try {
+      const data = await this.pdfParse(buffer, {
+        password: options?.password,
+        max: options?.pages ? Math.max(...options.pages) : void 0
+      });
+      if (options?.pages) {
+        return data.text;
+      }
+      return data.text || "";
+    } catch (error) {
+      throw new Error(`[DocumentProcessor] PDF extraction failed: ${error.message}`);
+    }
+  }
+  /**
+   * Extract text from DOCX
+   */
+  async extractDocxText(buffer, _options) {
+    if (!this.mammoth) {
+      throw new Error(
+        "[DocumentProcessor] DOCX support requires mammoth. Install with: npm install mammoth"
+      );
+    }
+    try {
+      const result = await this.mammoth.extractRawText({ buffer });
+      return result.value || "";
+    } catch (error) {
+      throw new Error(`[DocumentProcessor] DOCX extraction failed: ${error.message}`);
+    }
+  }
+  /**
+   * Get PDF metadata
+   */
+  async getPdfMetadata(buffer, _options) {
+    if (!this.pdfParse) {
+      throw new Error(
+        "[DocumentProcessor] PDF support requires pdf-parse. Install with: npm install pdf-parse"
+      );
+    }
+    try {
+      const data = await this.pdfParse(buffer, {
+        password: _options?.password
+      });
+      return {
+        format: "pdf",
+        pages: data.numpages,
+        title: data.info?.Title,
+        author: data.info?.Author,
+        creationDate: data.info?.CreationDate ? new Date(data.info.CreationDate) : void 0,
+        modifiedDate: data.info?.ModDate ? new Date(data.info.ModDate) : void 0,
+        custom: data.info
+      };
+    } catch (error) {
+      throw new Error(`[DocumentProcessor] PDF metadata extraction failed: ${error.message}`);
+    }
+  }
+  /**
+   * Get DOCX metadata
+   */
+  async getDocxMetadata(_buffer, _options) {
+    return {
+      format: "docx",
+      pages: void 0
+      // Word doesn't have fixed pages
+    };
+  }
+  /**
+   * Extract text from image using OCR
+   */
+  async extractImageText(buffer, options) {
+    if (!this.ocrProcessor.isAvailable()) {
+      throw new Error(
+        "[DocumentProcessor] Image/OCR support requires tesseract.js. Install with: npm install tesseract.js"
+      );
+    }
+    try {
+      const result = await this.ocrProcessor.recognizeText(buffer, options?.ocrOptions);
+      return result.text;
+    } catch (error) {
+      throw new Error(`[DocumentProcessor] Image text extraction failed: ${error.message}`);
+    }
+  }
+  /**
+   * Get image metadata
+   */
+  async getImageMetadata(buffer, options) {
+    if (!this.ocrProcessor.isAvailable()) {
+      return {
+        format: "image",
+        pages: void 0,
+        usedOCR: false
+      };
+    }
+    try {
+      const result = await this.ocrProcessor.recognizeText(buffer, options?.ocrOptions);
+      return {
+        format: "image",
+        pages: void 0,
+        usedOCR: true,
+        ocrConfidence: result.confidence
+      };
+    } catch {
+      return {
+        format: "image",
+        pages: void 0,
+        usedOCR: false
+      };
+    }
+  }
+  /**
+   * Extract text from JSON
+   */
+  async extractJsonText(buffer, _options) {
+    try {
+      return this.jsonProcessor.extractText(buffer);
+    } catch (error) {
+      throw new Error(`[DocumentProcessor] JSON extraction failed: ${error.message}`);
+    }
+  }
+  /**
+   * Extract text from CSV
+   */
+  async extractCsvText(buffer, _options) {
+    try {
+      return this.csvProcessor.extractText(buffer);
+    } catch (error) {
+      throw new Error(`[DocumentProcessor] CSV extraction failed: ${error.message}`);
+    }
+  }
+  /**
+   * Extract text from XLSX
+   */
+  async extractXlsxText(buffer, _options) {
+    if (!this.xlsxProcessor.isAvailable()) {
+      throw new Error(
+        "[DocumentProcessor] XLSX support requires xlsx package. Install with: npm install xlsx"
+      );
+    }
+    try {
+      return this.xlsxProcessor.extractText(buffer);
+    } catch (error) {
+      throw new Error(`[DocumentProcessor] XLSX extraction failed: ${error.message}`);
+    }
+  }
+  /**
+   * Get JSON metadata
+   */
+  async getJsonMetadata(buffer, _options) {
+    try {
+      const data = this.jsonProcessor.parse(buffer);
+      const isArray = Array.isArray(data);
+      return {
+        format: "json",
+        pages: void 0,
+        custom: {
+          isArray,
+          itemCount: isArray ? data.length : Object.keys(data).length
+        }
+      };
+    } catch {
+      return {
+        format: "json",
+        pages: void 0
+      };
+    }
+  }
+  /**
+   * Get CSV metadata
+   */
+  async getCsvMetadata(buffer, _options) {
+    try {
+      const info = this.csvProcessor.getColumnInfo(buffer);
+      return {
+        format: "csv",
+        pages: void 0,
+        custom: {
+          rowCount: info.rowCount,
+          columnCount: info.columnCount,
+          headers: info.headers
+        }
+      };
+    } catch {
+      return {
+        format: "csv",
+        pages: void 0
+      };
+    }
+  }
+  /**
+   * Get XLSX metadata
+   */
+  async getXlsxMetadata(buffer, _options) {
+    if (!this.xlsxProcessor.isAvailable()) {
+      return {
+        format: "xlsx",
+        pages: void 0
+      };
+    }
+    try {
+      const metadata = this.xlsxProcessor.getMetadata(buffer);
+      return {
+        format: "xlsx",
+        pages: void 0,
+        custom: {
+          sheetNames: metadata.sheetNames,
+          sheetCount: metadata.sheetCount
+        }
+      };
+    } catch {
+      return {
+        format: "xlsx",
+        pages: void 0
+      };
+    }
+  }
+  /**
+   * Get OCR processor instance
+   */
+  getOCRProcessor() {
+    return this.ocrProcessor;
+  }
+  /**
+   * Get JSON processor instance
+   */
+  getJsonProcessor() {
+    return this.jsonProcessor;
+  }
+  /**
+   * Get CSV processor instance
+   */
+  getCsvProcessor() {
+    return this.csvProcessor;
+  }
+  /**
+   * Get XLSX processor instance
+   */
+  getXlsxProcessor() {
+    return this.xlsxProcessor;
+  }
+};
+function createDocumentProcessor() {
+  return new DocumentProcessor();
+}
+
+export {
+  OCRProcessor,
+  createOCRProcessor,
+  JsonProcessor,
+  createJsonProcessor,
+  CsvProcessor,
+  createCsvProcessor,
+  XlsxProcessor,
+  createXlsxProcessor,
+  DocumentProcessor,
+  createDocumentProcessor
+};
+//# sourceMappingURL=chunk-7OGNW2MU.mjs.map