od-temp 1.0.4 → 1.0.5

package/dist/document-DBn-i6L4.cjs

@@ -0,0 +1,1470 @@
+#!/usr/bin/env node
+const require_index_cli = require('./index.cli.cjs');
+
+//#region src/document/OCRProcessor.ts
+/**
+* OCR processor with optional Tesseract.js support
+* Requires peer dependency: tesseract.js
+*/
+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;
+		}
+	}
+};
+
+//#endregion
+//#region src/document/JsonProcessor.ts
+/**
+* Processor for JSON documents
+*/
+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
+	*/
+	async detect(data, detector, options) {
+		const opts = {
+			...this.defaultOptions,
+			...options
+		};
+		const pathsDetected = [];
+		const matchesByPath = {};
+		const allDetections = [];
+		const promises = [];
+		this.traverse(data, "", opts, (path, value, key) => {
+			promises.push((async () => {
+				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 = await 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 = await 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);
+				}
+			})());
+		});
+		await Promise.all(promises);
+		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) {
+		if (!{
+			...this.defaultOptions,
+			...options
+		}.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)) result[key] = redactValue(val, currentPath ? `${currentPath}.${key}` : key);
+				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;
+			return new RegExp("^" + skipPath.replace(/\*/g, "[^.]+") + "$").test(path);
+		});
+	}
+	/**
+	* Check if path should always be redacted
+	*/
+	shouldAlwaysRedact(path, alwaysRedact) {
+		return alwaysRedact.some((redactPath) => {
+			if (path === redactPath) return true;
+			return new RegExp("^" + redactPath.replace(/\*/g, "[^.]+") + "$").test(path);
+		});
+	}
+	/**
+	* Boost confidence if key name indicates PII
+	*/
+	boostConfidenceFromKey(detections, key, piiIndicatorKeys) {
+		if (!key) return detections;
+		const keyLower = key.toLowerCase();
+		if (!piiIndicatorKeys.some((indicator) => keyLower.includes(indicator.toLowerCase()))) return detections;
+		return detections.map((detection) => ({
+			...detection,
+			confidence: Math.min(1, (detection.confidence || .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) {
+		return (typeof input === "string" ? input : input.toString("utf-8")).split("\n").filter((line) => line.trim().length > 0).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
+	*/
+	async detectJsonLines(input, detector, options) {
+		const documents = this.parseJsonLines(input);
+		return Promise.all(documents.map((doc) => this.detect(doc, detector, options)));
+	}
+};
+
+//#endregion
+//#region src/document/CsvProcessor.ts
+/**
+* CSV processor for tabular data
+*/
+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
+	*/
+	async detect(input, detector, options) {
+		const opts = {
+			...this.defaultOptions,
+			...options
+		};
+		const rows = this.parse(input, options);
+		if (rows.length === 0) {
+			const original = typeof input === "string" ? input : input.toString("utf-8");
+			return {
+				original,
+				redacted: original,
+				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 = await 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];
+			if (hasHeader && i === 0) 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")) return `${quote}${value.replace(new RegExp(quote, "g"), quote + quote)}${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 score = avg / (counts.reduce((sum, c) => sum + Math.pow(c - avg, 2), 0) / counts.length + 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;
+		if (firstRow.reduce((sum, v) => sum + v.length, 0) / firstRow.length > secondRow.reduce((sum, v) => sum + v.length, 0) / secondRow.length * 1.5) return false;
+		const firstRowNumeric = firstRow.filter((v) => !isNaN(Number(v)) && v.trim() !== "").length;
+		return firstRow.length - firstRowNumeric >= firstRowNumeric;
+	}
+	/**
+	* Boost confidence if column name indicates PII
+	*/
+	boostConfidenceFromColumnName(detections, columnName, piiIndicatorNames) {
+		if (!columnName) return detections;
+		const nameLower = columnName.toLowerCase().trim();
+		if (!piiIndicatorNames.some((indicator) => nameLower.includes(indicator.toLowerCase()))) return detections;
+		return detections.map((detection) => ({
+			...detection,
+			confidence: Math.min(1, (detection.confidence || .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
+		};
+	}
+};
+
+//#endregion
+//#region src/document/XlsxProcessor.ts
+/**
+* XLSX processor for spreadsheet data
+*/
+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
+	*/
+	async 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 = await 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
+	*/
+	async 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,
+					column: colIndex,
+					columnLetter: this.columnToLetter(colIndex),
+					columnName: headers?.[colIndex],
+					value: cellValue,
+					formula: cellFormula,
+					matches: [detection]
+				});
+				columnStats[colIndex].piiCount++;
+				continue;
+			}
+			const result = await 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,
+					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 cell = sheet[cellMatch.cell];
+				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 cell = sheet[this.xlsx.utils.encode_cell({
+				r: row,
+				c: col
+			})];
+			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;
+		if (firstRowValues.reduce((sum, v) => sum + v.length, 0) / firstRowValues.length > secondRowValues.reduce((sum, v) => sum + v.length, 0) / secondRowValues.length * 1.5) return false;
+		const firstRowNumeric = firstRowValues.filter((v) => !isNaN(Number(v)) && v.trim() !== "").length;
+		return firstRowValues.length - firstRowNumeric >= 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();
+		if (!piiIndicatorNames.some((indicator) => nameLower.includes(indicator.toLowerCase()))) return detections;
+		return detections.map((detection) => ({
+			...detection,
+			confidence: Math.min(1, (detection.confidence || .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 cell = sheet[this.xlsx.utils.encode_cell({
+					r: row,
+					c: col
+				})];
+				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
+		};
+	}
+};
+
+//#endregion
+//#region src/document/DocumentProcessor.ts
+/**
+* Document processor with optional PDF, DOCX, OCR, JSON, CSV, and XLSX support
+* Requires peer dependencies:
+* - pdf-parse (for PDF)
+* - mammoth (for DOCX)
+* - tesseract.js (for OCR/images)
+* - xlsx (for Excel/XLSX)
+*/
+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) for (const delimiter of [
+			",",
+			"	",
+			";",
+			"|"
+		]) {
+			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));
+		if (sample.filter((byte) => byte < 32 && byte !== 9 && byte !== 10 && byte !== 13).length < sample.length * .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;
+			case "csv": return true;
+			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 {
+			return (await this.mammoth.extractRawText({ buffer })).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
+		};
+	}
+	/**
+	* 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 {
+			return (await this.ocrProcessor.recognizeText(buffer, options?.ocrOptions)).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 {
+			return {
+				format: "image",
+				pages: void 0,
+				usedOCR: true,
+				ocrConfidence: (await this.ocrProcessor.recognizeText(buffer, options?.ocrOptions)).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;
+	}
+};
+/**
+* Create a document processor instance
+*/
+function createDocumentProcessor() {
+	return new DocumentProcessor();
+}
+
+//#endregion
+exports.createDocumentProcessor = createDocumentProcessor;