@blindfold/sdk 1.0.2

package/dist/index.mjs

@@ -0,0 +1,568 @@
+import { EntityType, PIIScanner, __toCommonJS, init_regex, regex_exports } from "./regex-ByjZg3Zy.mjs";
+import * as fs from "fs";
+import * as path from "path";
+
+//#region src/errors.ts
+/**
+* Base error class for Blindfold SDK
+*/
+var BlindfoldError = class BlindfoldError extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "BlindfoldError";
+		Object.setPrototypeOf(this, BlindfoldError.prototype);
+	}
+};
+/**
+* Error thrown when authentication fails
+*/
+var AuthenticationError = class AuthenticationError extends BlindfoldError {
+	constructor(message = "Authentication failed. Please check your API key.") {
+		super(message);
+		this.name = "AuthenticationError";
+		Object.setPrototypeOf(this, AuthenticationError.prototype);
+	}
+};
+/**
+* Error thrown when API request fails
+*/
+var APIError = class APIError extends BlindfoldError {
+	statusCode;
+	responseBody;
+	constructor(message, statusCode, responseBody) {
+		super(message);
+		this.name = "APIError";
+		this.statusCode = statusCode;
+		this.responseBody = responseBody;
+		Object.setPrototypeOf(this, APIError.prototype);
+	}
+};
+/**
+* Error thrown when network request fails
+*/
+var NetworkError = class NetworkError extends BlindfoldError {
+	constructor(message = "Network request failed. Please check your connection.") {
+		super(message);
+		this.name = "NetworkError";
+		Object.setPrototypeOf(this, NetworkError.prototype);
+	}
+};
+
+//#endregion
+//#region src/client.ts
+const DEFAULT_BASE_URL = "https://api.blindfold.dev/api/public/v1";
+const RETRYABLE_STATUS_CODES = new Set([
+	429,
+	500,
+	502,
+	503,
+	504
+]);
+const REGION_URLS = {
+	eu: "https://eu-api.blindfold.dev/api/public/v1",
+	us: "https://us-api.blindfold.dev/api/public/v1"
+};
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const BUNDLED_POLICIES_PATH = path.join(__dirname, "policies.json");
+function loadPolicies(policiesFile) {
+	const bundled = JSON.parse(fs.readFileSync(BUNDLED_POLICIES_PATH, "utf-8"));
+	if (policiesFile) {
+		const user = JSON.parse(fs.readFileSync(policiesFile, "utf-8"));
+		return {
+			...bundled,
+			...user
+		};
+	}
+	return bundled;
+}
+/**
+* Blindfold client for tokenization and detokenization.
+*
+* When no `apiKey` is provided, all methods run locally using the
+* built-in regex PII scanner.  Set `mode: "local"` to force local
+* mode even when an API key is present.
+*/
+var Blindfold = class {
+	apiKey;
+	baseUrl;
+	userId;
+	maxRetries;
+	retryDelay;
+	mode;
+	locales;
+	policies;
+	_scanner;
+	/**
+	* Create a new Blindfold client
+	* @param config - Configuration options. Can be omitted entirely for local-only mode.
+	*/
+	constructor(config = {}) {
+		this.apiKey = config.apiKey;
+		this.mode = config.mode;
+		this.locales = config.locales;
+		this.policies = loadPolicies(config.policiesFile);
+		if (config.region && !config.baseUrl) {
+			const regionUrl = REGION_URLS[config.region];
+			if (!regionUrl) throw new Error(`Invalid region '${config.region}'. Must be one of: ${Object.keys(REGION_URLS).join(", ")}`);
+			this.baseUrl = regionUrl;
+		} else this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+		this.userId = config.userId;
+		this.maxRetries = config.maxRetries ?? 2;
+		this.retryDelay = config.retryDelay ?? .5;
+		if (this.useLocal && config.region) console.warn(`region='${config.region}' has no effect in local mode. Set an apiKey to use region-based routing.`);
+	}
+	get useLocal() {
+		if (this.mode === "local") return true;
+		return !this.apiKey;
+	}
+	getScanner() {
+		if (!this._scanner) {
+			const { PIIScanner: PIIScanner$1 } = (init_regex(), __toCommonJS(regex_exports));
+			this._scanner = new PIIScanner$1(this.locales ? { locales: this.locales } : void 0);
+		}
+		return this._scanner;
+	}
+	resolvePolicy(policy, entities, scoreThreshold) {
+		if (entities) return {
+			entities,
+			threshold: scoreThreshold
+		};
+		if (policy) {
+			const policyDef = this.policies[policy];
+			if (policyDef) return {
+				entities: policyDef.entities,
+				threshold: scoreThreshold ?? policyDef.threshold
+			};
+			else console.warn(`Unknown policy '${policy}' in local mode, detecting all entities`);
+		}
+		return { threshold: scoreThreshold };
+	}
+	retryWait(attempt, error) {
+		if (error && error.statusCode === 429) {
+			const body = error.responseBody;
+			if (body && typeof body.retry_after === "number") return body.retry_after * 1e3;
+		}
+		const delay = this.retryDelay * 2 ** attempt * 1e3;
+		const jitter = delay * .1 * Math.random();
+		return delay + jitter;
+	}
+	/**
+	* Make an authenticated request to the API
+	*/
+	async request(endpoint, method, body) {
+		const url = `${this.baseUrl}${endpoint}`;
+		const headers = { "Content-Type": "application/json" };
+		if (this.apiKey) headers["X-API-Key"] = this.apiKey;
+		if (this.userId) headers["X-Blindfold-User-Id"] = this.userId;
+		let lastError = new NetworkError("Request failed");
+		for (let attempt = 0; attempt <= this.maxRetries; attempt++) try {
+			const response = await fetch(url, {
+				method,
+				headers,
+				body: body ? JSON.stringify(body) : void 0
+			});
+			if (response.status === 401 || response.status === 403) throw new AuthenticationError("Authentication failed. Please check your API key.");
+			if (!response.ok) {
+				let errorMessage = `API request failed with status ${response.status}`;
+				let responseBody;
+				try {
+					responseBody = await response.json();
+					const errorData = responseBody;
+					errorMessage = errorData.detail || errorData.message || errorMessage;
+				} catch {
+					errorMessage = `${errorMessage}: ${response.statusText}`;
+				}
+				throw new APIError(errorMessage, response.status, responseBody);
+			}
+			return await response.json();
+		} catch (error) {
+			if (error instanceof AuthenticationError) throw error;
+			if (error instanceof APIError) {
+				if (RETRYABLE_STATUS_CODES.has(error.statusCode) && attempt < this.maxRetries) {
+					await sleep(this.retryWait(attempt, error));
+					continue;
+				}
+				throw error;
+			}
+			if (error instanceof NetworkError) {
+				lastError = error;
+				if (attempt < this.maxRetries) {
+					await sleep(this.retryWait(attempt));
+					continue;
+				}
+				throw error;
+			}
+			if (error instanceof TypeError && error.message.includes("fetch")) {
+				lastError = new NetworkError("Network request failed. Please check your connection and the API URL.");
+				if (attempt < this.maxRetries) {
+					await sleep(this.retryWait(attempt));
+					continue;
+				}
+				throw lastError;
+			}
+			throw new NetworkError(error instanceof Error ? error.message : "Unknown error occurred");
+		}
+		throw lastError;
+	}
+	/**
+	* Tokenize text by replacing sensitive information with tokens
+	* @param text - Text to tokenize
+	* @param config - Optional configuration
+	* @returns Promise with tokenized text and mapping
+	*/
+	async tokenize(text, config) {
+		if (this.useLocal) return this.tokenizeLocal(text, config);
+		return this.request("/tokenize", "POST", {
+			text,
+			...config
+		});
+	}
+	tokenizeLocal(text, config) {
+		const { entities: resolved, threshold } = this.resolvePolicy(config?.policy, config?.entities, config?.score_threshold);
+		const scanner = this.getScanner();
+		const result = scanner.tokenize(text, resolved);
+		const detected = result.matches.filter((m) => threshold == null || m.score >= threshold).map((m) => ({
+			type: m.entityType,
+			text: m.text,
+			start: m.start,
+			end: m.end,
+			score: m.score
+		}));
+		return {
+			text: result.text,
+			mapping: result.mapping,
+			detected_entities: detected,
+			entities_count: detected.length
+		};
+	}
+	/**
+	* Detect PII in text without modifying it
+	*
+	* Returns only the detected entities with their types, positions,
+	* and confidence scores. The original text is not transformed.
+	*
+	* When no API key is set (or `mode: "local"`), detection runs locally
+	* using the built-in regex scanner.
+	*
+	* @param text - Text to analyze for PII
+	* @param config - Optional configuration (entities, score_threshold, policy)
+	* @returns Promise with detected entities
+	*/
+	async detect(text, config) {
+		if (this.useLocal) return this.detectLocal(text, config);
+		return this.request("/detect", "POST", {
+			text,
+			...config
+		});
+	}
+	detectLocal(text, config) {
+		const { entities: resolved, threshold } = this.resolvePolicy(config?.policy, config?.entities, config?.score_threshold);
+		const scanner = this.getScanner();
+		const matches = scanner.detect(text, resolved);
+		const detected = [];
+		for (const m of matches) {
+			if (threshold != null && m.score < threshold) continue;
+			detected.push({
+				type: m.entityType,
+				text: m.text,
+				start: m.start,
+				end: m.end,
+				score: m.score
+			});
+		}
+		return {
+			detected_entities: detected,
+			entities_count: detected.length
+		};
+	}
+	/**
+	* Detokenize text by replacing tokens with original values
+	*
+	* This method performs detokenization CLIENT-SIDE for better performance,
+	* security, and to work offline. No API call is made.
+	*
+	* @param text - Tokenized text
+	* @param mapping - Token mapping from tokenize response
+	* @returns DetokenizeResponse with original text
+	*/
+	detokenize(text, mapping) {
+		let result = text;
+		let replacements = 0;
+		const sortedTokens = Object.keys(mapping).sort((a, b) => b.length - a.length);
+		for (const token of sortedTokens) {
+			const originalValue = mapping[token];
+			const regex = new RegExp(token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g");
+			const matches = result.match(regex);
+			if (matches) {
+				result = result.replace(regex, originalValue);
+				replacements += matches.length;
+			}
+		}
+		return {
+			text: result,
+			replacements_made: replacements
+		};
+	}
+	/**
+	* Redact (permanently remove) sensitive information from text
+	*
+	* WARNING: Redaction is irreversible - original data cannot be restored!
+	*
+	* When no API key is set (or `mode: "local"`), redaction runs locally
+	* using the built-in regex scanner, replacing PII with `<Entity Name>` placeholders.
+	*
+	* @param text - Text to redact
+	* @param config - Optional configuration (masking_char, entities)
+	* @returns Promise with redacted text and detected entities
+	*/
+	async redact(text, config) {
+		if (this.useLocal) return this.redactLocal(text, config);
+		return this.request("/redact", "POST", {
+			text,
+			...config
+		});
+	}
+	redactLocal(text, config) {
+		const { entities: resolved, threshold } = this.resolvePolicy(config?.policy, config?.entities, config?.score_threshold);
+		const scanner = this.getScanner();
+		const [redactedText, matches] = scanner.redact(text, resolved);
+		const detected = [];
+		for (const m of matches) {
+			if (threshold != null && m.score < threshold) continue;
+			detected.push({
+				type: m.entityType,
+				text: m.text,
+				start: m.start,
+				end: m.end,
+				score: m.score
+			});
+		}
+		return {
+			text: redactedText,
+			detected_entities: detected,
+			entities_count: detected.length
+		};
+	}
+	/**
+	* Mask (partially hide) sensitive information from text
+	*
+	* @param text - Text to mask
+	* @param config - Optional configuration (chars_to_show, from_end, masking_char, entities)
+	* @returns Promise with masked text and detected entities
+	*/
+	async mask(text, config) {
+		if (this.useLocal) return this.maskLocal(text, config);
+		return this.request("/mask", "POST", {
+			text,
+			...config
+		});
+	}
+	maskLocal(text, config) {
+		const { entities: resolved, threshold } = this.resolvePolicy(config?.policy, config?.entities, config?.score_threshold);
+		const scanner = this.getScanner();
+		const result = scanner.mask(text, config?.chars_to_show ?? 3, config?.from_end ?? false, config?.masking_char ?? "*", resolved);
+		const detected = result.matches.filter((m) => threshold == null || m.score >= threshold).map((m) => ({
+			type: m.entityType,
+			text: m.text,
+			start: m.start,
+			end: m.end,
+			score: m.score
+		}));
+		return {
+			text: result.text,
+			detected_entities: detected,
+			entities_count: detected.length
+		};
+	}
+	/**
+	* Synthesize (replace real data with synthetic fake data)
+	*
+	* When no API key is set (or `mode: "local"`), synthesis runs locally
+	* using format-preserving random generation.
+	*
+	* @param text - Text to synthesize
+	* @param config - Optional configuration (language, entities)
+	* @returns Promise with synthetic text and detected entities
+	*/
+	async synthesize(text, config) {
+		if (this.useLocal) return this.synthesizeLocal(text, config);
+		return this.request("/synthesize", "POST", {
+			text,
+			...config
+		});
+	}
+	synthesizeLocal(text, config) {
+		const { entities: resolved, threshold } = this.resolvePolicy(config?.policy, config?.entities, config?.score_threshold);
+		const scanner = this.getScanner();
+		const result = scanner.synthesize(text, void 0, resolved);
+		const detected = result.matches.filter((m) => threshold == null || m.score >= threshold).map((m) => ({
+			type: m.entityType,
+			text: m.text,
+			start: m.start,
+			end: m.end,
+			score: m.score
+		}));
+		return {
+			text: result.text,
+			detected_entities: detected,
+			entities_count: detected.length
+		};
+	}
+	/**
+	* Hash (replace with deterministic hash values)
+	*
+	* @param text - Text to hash
+	* @param config - Optional configuration (hash_type, hash_prefix, hash_length, entities)
+	* @returns Promise with hashed text and detected entities
+	*/
+	async hash(text, config) {
+		if (this.useLocal) return this.hashLocal(text, config);
+		return this.request("/hash", "POST", {
+			text,
+			...config
+		});
+	}
+	hashLocal(text, config) {
+		const { entities: resolved, threshold } = this.resolvePolicy(config?.policy, config?.entities, config?.score_threshold);
+		const scanner = this.getScanner();
+		const result = scanner.hash(text, config?.hash_type ?? "sha256", config?.hash_prefix ?? "HASH_", config?.hash_length ?? 16, resolved);
+		const detected = result.matches.filter((m) => threshold == null || m.score >= threshold).map((m) => ({
+			type: m.entityType,
+			text: m.text,
+			start: m.start,
+			end: m.end,
+			score: m.score
+		}));
+		return {
+			text: result.text,
+			detected_entities: detected,
+			entities_count: detected.length
+		};
+	}
+	/**
+	* Encrypt (reversibly protect) sensitive data in text using AES encryption
+	*
+	* @param text - Text to encrypt
+	* @param config - Optional configuration (encryption_key, entities)
+	* @returns Promise with encrypted text and detected entities
+	*/
+	async encrypt(text, config) {
+		if (this.useLocal) return this.encryptLocal(text, config);
+		return this.request("/encrypt", "POST", {
+			text,
+			...config
+		});
+	}
+	encryptLocal(text, config) {
+		if (!config?.encryption_key) throw new Error("encryption_key is required for local encryption mode");
+		const { entities: resolved, threshold } = this.resolvePolicy(config?.policy, config?.entities, config?.score_threshold);
+		const scanner = this.getScanner();
+		const result = scanner.encrypt(text, config.encryption_key, resolved);
+		const detected = result.matches.filter((m) => threshold == null || m.score >= threshold).map((m) => ({
+			type: m.entityType,
+			text: m.text,
+			start: m.start,
+			end: m.end,
+			score: m.score
+		}));
+		return {
+			text: result.text,
+			detected_entities: detected,
+			entities_count: detected.length
+		};
+	}
+	/**
+	* Tokenize multiple texts in a single request
+	* @param texts - Array of texts to tokenize (max 100)
+	* @param config - Optional configuration
+	* @returns Promise with batch results
+	*/
+	async tokenizeBatch(texts, config) {
+		return this.request("/tokenize", "POST", {
+			texts,
+			...config
+		});
+	}
+	/**
+	* Detect PII in multiple texts in a single request
+	* @param texts - Array of texts to analyze (max 100)
+	* @param config - Optional configuration
+	* @returns Promise with batch results
+	*/
+	async detectBatch(texts, config) {
+		return this.request("/detect", "POST", {
+			texts,
+			...config
+		});
+	}
+	/**
+	* Redact PII from multiple texts in a single request
+	* @param texts - Array of texts to redact (max 100)
+	* @param config - Optional configuration
+	* @returns Promise with batch results
+	*/
+	async redactBatch(texts, config) {
+		return this.request("/redact", "POST", {
+			texts,
+			...config
+		});
+	}
+	/**
+	* Mask PII in multiple texts in a single request
+	* @param texts - Array of texts to mask (max 100)
+	* @param config - Optional configuration
+	* @returns Promise with batch results
+	*/
+	async maskBatch(texts, config) {
+		return this.request("/mask", "POST", {
+			texts,
+			...config
+		});
+	}
+	/**
+	* Synthesize multiple texts in a single request
+	* @param texts - Array of texts to synthesize (max 100)
+	* @param config - Optional configuration
+	* @returns Promise with batch results
+	*/
+	async synthesizeBatch(texts, config) {
+		return this.request("/synthesize", "POST", {
+			texts,
+			...config
+		});
+	}
+	/**
+	* Hash PII in multiple texts in a single request
+	* @param texts - Array of texts to hash (max 100)
+	* @param config - Optional configuration
+	* @returns Promise with batch results
+	*/
+	async hashBatch(texts, config) {
+		return this.request("/hash", "POST", {
+			texts,
+			...config
+		});
+	}
+	/**
+	* Encrypt PII in multiple texts in a single request
+	* @param texts - Array of texts to encrypt (max 100)
+	* @param config - Optional configuration
+	* @returns Promise with batch results
+	*/
+	async encryptBatch(texts, config) {
+		return this.request("/encrypt", "POST", {
+			texts,
+			...config
+		});
+	}
+};
+
+//#endregion
+//#region src/index.ts
+init_regex();
+
+//#endregion
+export { APIError, AuthenticationError, Blindfold, BlindfoldError, EntityType, NetworkError, PIIScanner };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["message: string","statusCode: number","responseBody?: unknown","REGION_URLS: Record<string, string>","ms: number","policiesFile?: string","bundled: PolicyMap","user: PolicyMap","config: BlindfoldConfig","PIIScanner","policy?: string","entities?: string[]","scoreThreshold?: number","attempt: number","error?: APIError","endpoint: string","method: string","body?: Record<string, unknown>","headers: Record<string, string>","lastError: Error","responseBody: unknown","text: string","config?: TokenizeConfig","detected: DetectedEntity[]","config?: DetectConfig","mapping: Record<string, string>","config?: RedactConfig","config?: MaskConfig","config?: SynthesizeConfig","config?: HashConfig","config?: EncryptConfig","texts: string[]"],"sources":["../src/errors.ts","../src/client.ts","../src/index.ts"],"sourcesContent":["/**\n * Base error class for Blindfold SDK\n */\nexport class BlindfoldError extends Error {\n  constructor(message: string) {\n    super(message)\n    this.name = 'BlindfoldError'\n    Object.setPrototypeOf(this, BlindfoldError.prototype)\n  }\n}\n\n/**\n * Error thrown when authentication fails\n */\nexport class AuthenticationError extends BlindfoldError {\n  constructor(message: string = 'Authentication failed. Please check your API key.') {\n    super(message)\n    this.name = 'AuthenticationError'\n    Object.setPrototypeOf(this, AuthenticationError.prototype)\n  }\n}\n\n/**\n * Error thrown when API request fails\n */\nexport class APIError extends BlindfoldError {\n  statusCode: number\n  responseBody?: unknown\n\n  constructor(message: string, statusCode: number, responseBody?: unknown) {\n    super(message)\n    this.name = 'APIError'\n    this.statusCode = statusCode\n    this.responseBody = responseBody\n    Object.setPrototypeOf(this, APIError.prototype)\n  }\n}\n\n/**\n * Error thrown when network request fails\n */\nexport class NetworkError extends BlindfoldError {\n  constructor(message: string = 'Network request failed. Please check your connection.') {\n    super(message)\n    this.name = 'NetworkError'\n    Object.setPrototypeOf(this, NetworkError.prototype)\n  }\n}\n","import type {\n  BlindfoldConfig,\n  DetectConfig,\n  DetectResponse,\n  DetectedEntity,\n  TokenizeConfig,\n  TokenizeResponse,\n  DetokenizeResponse,\n  RedactConfig,\n  RedactResponse,\n  MaskConfig,\n  MaskResponse,\n  SynthesizeConfig,\n  SynthesizeResponse,\n  HashConfig,\n  HashResponse,\n  EncryptConfig,\n  EncryptResponse,\n  BatchResponse,\n  APIErrorResponse,\n} from './types'\nimport { AuthenticationError, APIError, NetworkError } from './errors'\nimport type { PIIScanner as PIIScannerType } from './regex'\nimport * as fs from 'fs'\nimport * as path from 'path'\n\nconst DEFAULT_BASE_URL = 'https://api.blindfold.dev/api/public/v1'\nconst RETRYABLE_STATUS_CODES = new Set([429, 500, 502, 503, 504])\n\nconst REGION_URLS: Record<string, string> = {\n  eu: 'https://eu-api.blindfold.dev/api/public/v1',\n  us: 'https://us-api.blindfold.dev/api/public/v1',\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms))\n}\n\ninterface PolicyDefinition {\n  entities: string[]\n  threshold?: number\n}\n\ntype PolicyMap = Record<string, PolicyDefinition>\n\nconst BUNDLED_POLICIES_PATH = path.join(__dirname, 'policies.json')\n\nfunction loadPolicies(policiesFile?: string): PolicyMap {\n  const bundled: PolicyMap = JSON.parse(fs.readFileSync(BUNDLED_POLICIES_PATH, 'utf-8'))\n  if (policiesFile) {\n    const user: PolicyMap = JSON.parse(fs.readFileSync(policiesFile, 'utf-8'))\n    return { ...bundled, ...user }\n  }\n  return bundled\n}\n\n/**\n * Blindfold client for tokenization and detokenization.\n *\n * When no `apiKey` is provided, all methods run locally using the\n * built-in regex PII scanner.  Set `mode: \"local\"` to force local\n * mode even when an API key is present.\n */\nexport class Blindfold {\n  private apiKey?: string\n  private baseUrl: string\n  private userId?: string\n  private maxRetries: number\n  private retryDelay: number\n  private mode?: string\n  private locales?: string[]\n  private policies: PolicyMap\n  private _scanner?: PIIScannerType\n\n  /**\n   * Create a new Blindfold client\n   * @param config - Configuration options. Can be omitted entirely for local-only mode.\n   */\n  constructor(config: BlindfoldConfig = {}) {\n    this.apiKey = config.apiKey\n    this.mode = config.mode\n    this.locales = config.locales\n    this.policies = loadPolicies(config.policiesFile)\n    if (config.region && !config.baseUrl) {\n      const regionUrl = REGION_URLS[config.region]\n      if (!regionUrl) {\n        throw new Error(\n          `Invalid region '${config.region}'. Must be one of: ${Object.keys(REGION_URLS).join(', ')}`\n        )\n      }\n      this.baseUrl = regionUrl\n    } else {\n      this.baseUrl = config.baseUrl || DEFAULT_BASE_URL\n    }\n    this.userId = config.userId\n    this.maxRetries = config.maxRetries ?? 2\n    this.retryDelay = config.retryDelay ?? 0.5\n\n    if (this.useLocal && config.region) {\n      console.warn(\n        `region='${config.region}' has no effect in local mode. ` +\n        'Set an apiKey to use region-based routing.'\n      )\n    }\n  }\n\n  private get useLocal(): boolean {\n    if (this.mode === 'local') return true\n    return !this.apiKey\n  }\n\n  private getScanner(): PIIScannerType {\n    if (!this._scanner) {\n      const { PIIScanner } = require('./regex') as typeof import('./regex')\n      this._scanner = new PIIScanner(this.locales ? { locales: this.locales } : undefined)\n    }\n    return this._scanner\n  }\n\n  private resolvePolicy(\n    policy?: string,\n    entities?: string[],\n    scoreThreshold?: number\n  ): { entities?: string[]; threshold?: number } {\n    if (entities) {\n      return { entities, threshold: scoreThreshold }\n    }\n    if (policy) {\n      const policyDef = this.policies[policy]\n      if (policyDef) {\n        return {\n          entities: policyDef.entities,\n          threshold: scoreThreshold ?? policyDef.threshold,\n        }\n      } else {\n        console.warn(`Unknown policy '${policy}' in local mode, detecting all entities`)\n      }\n    }\n    return { threshold: scoreThreshold }\n  }\n\n  private retryWait(attempt: number, error?: APIError): number {\n    if (error && error.statusCode === 429) {\n      const body = error.responseBody as Record<string, unknown> | undefined\n      if (body && typeof body.retry_after === 'number') {\n        return body.retry_after * 1000\n      }\n    }\n    const delay = this.retryDelay * 2 ** attempt * 1000\n    const jitter = delay * 0.1 * Math.random()\n    return delay + jitter\n  }\n\n  /**\n   * Make an authenticated request to the API\n   */\n  private async request<T>(\n    endpoint: string,\n    method: string,\n    body?: Record<string, unknown>\n  ): Promise<T> {\n    const url = `${this.baseUrl}${endpoint}`\n\n    const headers: Record<string, string> = {\n      'Content-Type': 'application/json',\n    }\n\n    if (this.apiKey) {\n      headers['X-API-Key'] = this.apiKey\n    }\n\n    if (this.userId) {\n      headers['X-Blindfold-User-Id'] = this.userId\n    }\n\n    let lastError: Error = new NetworkError('Request failed')\n\n    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {\n      try {\n        const response = await fetch(url, {\n          method,\n          headers,\n          body: body ? JSON.stringify(body) : undefined,\n        })\n\n        // Handle authentication errors\n        if (response.status === 401 || response.status === 403) {\n          throw new AuthenticationError('Authentication failed. Please check your API key.')\n        }\n\n        // Handle other error responses\n        if (!response.ok) {\n          let errorMessage = `API request failed with status ${response.status}`\n          let responseBody: unknown\n\n          try {\n            responseBody = await response.json()\n            const errorData = responseBody as APIErrorResponse\n            errorMessage = errorData.detail || errorData.message || errorMessage\n          } catch {\n            // If we can't parse the error response, use the status text\n            errorMessage = `${errorMessage}: ${response.statusText}`\n          }\n\n          throw new APIError(errorMessage, response.status, responseBody)\n        }\n\n        return (await response.json()) as T\n      } catch (error) {\n        // Never retry auth errors\n        if (error instanceof AuthenticationError) {\n          throw error\n        }\n\n        // Retry retryable API errors\n        if (error instanceof APIError) {\n          if (RETRYABLE_STATUS_CODES.has(error.statusCode) && attempt < this.maxRetries) {\n            await sleep(this.retryWait(attempt, error))\n            continue\n          }\n          throw error\n        }\n\n        // Retry network errors\n        if (error instanceof NetworkError) {\n          lastError = error\n          if (attempt < this.maxRetries) {\n            await sleep(this.retryWait(attempt))\n            continue\n          }\n          throw error\n        }\n\n        // Handle raw fetch errors (network failures)\n        if (error instanceof TypeError && error.message.includes('fetch')) {\n          lastError = new NetworkError(\n            'Network request failed. Please check your connection and the API URL.'\n          )\n          if (attempt < this.maxRetries) {\n            await sleep(this.retryWait(attempt))\n            continue\n          }\n          throw lastError\n        }\n\n        // Non-retryable unknown errors\n        throw new NetworkError(error instanceof Error ? error.message : 'Unknown error occurred')\n      }\n    }\n\n    throw lastError\n  }\n\n  /**\n   * Tokenize text by replacing sensitive information with tokens\n   * @param text - Text to tokenize\n   * @param config - Optional configuration\n   * @returns Promise with tokenized text and mapping\n   */\n  async tokenize(text: string, config?: TokenizeConfig): Promise<TokenizeResponse> {\n    if (this.useLocal) {\n      return this.tokenizeLocal(text, config)\n    }\n    return this.request<TokenizeResponse>('/tokenize', 'POST', {\n      text,\n      ...config,\n    })\n  }\n\n  private tokenizeLocal(text: string, config?: TokenizeConfig): TokenizeResponse {\n    const { entities: resolved, threshold } = this.resolvePolicy(config?.policy, config?.entities, config?.score_threshold)\n    const scanner = this.getScanner()\n    const result = scanner.tokenize(text, resolved)\n\n    const detected: DetectedEntity[] = result.matches\n      .filter((m) => threshold == null || m.score >= threshold)\n      .map((m) => ({\n        type: m.entityType, text: m.text, start: m.start, end: m.end, score: m.score,\n      }))\n\n    return { text: result.text, mapping: result.mapping, detected_entities: detected, entities_count: detected.length }\n  }\n\n  /**\n   * Detect PII in text without modifying it\n   *\n   * Returns only the detected entities with their types, positions,\n   * and confidence scores. The original text is not transformed.\n   *\n   * When no API key is set (or `mode: \"local\"`), detection runs locally\n   * using the built-in regex scanner.\n   *\n   * @param text - Text to analyze for PII\n   * @param config - Optional configuration (entities, score_threshold, policy)\n   * @returns Promise with detected entities\n   */\n  async detect(text: string, config?: DetectConfig): Promise<DetectResponse> {\n    if (this.useLocal) {\n      return this.detectLocal(text, config)\n    }\n    return this.request<DetectResponse>('/detect', 'POST', {\n      text,\n      ...config,\n    })\n  }\n\n  private detectLocal(text: string, config?: DetectConfig): DetectResponse {\n    const { entities: resolved, threshold } = this.resolvePolicy(config?.policy, config?.entities, config?.score_threshold)\n    const scanner = this.getScanner()\n    const matches = scanner.detect(text, resolved)\n\n    const detected: DetectedEntity[] = []\n    for (const m of matches) {\n      if (threshold != null && m.score < threshold) continue\n      detected.push({ type: m.entityType, text: m.text, start: m.start, end: m.end, score: m.score })\n    }\n\n    return { detected_entities: detected, entities_count: detected.length }\n  }\n\n  /**\n   * Detokenize text by replacing tokens with original values\n   *\n   * This method performs detokenization CLIENT-SIDE for better performance,\n   * security, and to work offline. No API call is made.\n   *\n   * @param text - Tokenized text\n   * @param mapping - Token mapping from tokenize response\n   * @returns DetokenizeResponse with original text\n   */\n  detokenize(text: string, mapping: Record<string, string>): DetokenizeResponse {\n    let result = text\n    let replacements = 0\n\n    // Sort tokens by length (longest first) to avoid partial replacements\n    const sortedTokens = Object.keys(mapping).sort((a, b) => b.length - a.length)\n\n    for (const token of sortedTokens) {\n      const originalValue = mapping[token]\n      const regex = new RegExp(token.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&'), 'g')\n      const matches = result.match(regex)\n\n      if (matches) {\n        result = result.replace(regex, originalValue)\n        replacements += matches.length\n      }\n    }\n\n    return {\n      text: result,\n      replacements_made: replacements,\n    }\n  }\n\n  /**\n   * Redact (permanently remove) sensitive information from text\n   *\n   * WARNING: Redaction is irreversible - original data cannot be restored!\n   *\n   * When no API key is set (or `mode: \"local\"`), redaction runs locally\n   * using the built-in regex scanner, replacing PII with `<Entity Name>` placeholders.\n   *\n   * @param text - Text to redact\n   * @param config - Optional configuration (masking_char, entities)\n   * @returns Promise with redacted text and detected entities\n   */\n  async redact(text: string, config?: RedactConfig): Promise<RedactResponse> {\n    if (this.useLocal) {\n      return this.redactLocal(text, config)\n    }\n    return this.request<RedactResponse>('/redact', 'POST', {\n      text,\n      ...config,\n    })\n  }\n\n  private redactLocal(text: string, config?: RedactConfig): RedactResponse {\n    const { entities: resolved, threshold } = this.resolvePolicy(config?.policy, config?.entities, config?.score_threshold)\n    const scanner = this.getScanner()\n    const [redactedText, matches] = scanner.redact(text, resolved)\n\n    const detected: DetectedEntity[] = []\n    for (const m of matches) {\n      if (threshold != null && m.score < threshold) continue\n      detected.push({ type: m.entityType, text: m.text, start: m.start, end: m.end, score: m.score })\n    }\n\n    return { text: redactedText, detected_entities: detected, entities_count: detected.length }\n  }\n\n  /**\n   * Mask (partially hide) sensitive information from text\n   *\n   * @param text - Text to mask\n   * @param config - Optional configuration (chars_to_show, from_end, masking_char, entities)\n   * @returns Promise with masked text and detected entities\n   */\n  async mask(text: string, config?: MaskConfig): Promise<MaskResponse> {\n    if (this.useLocal) {\n      return this.maskLocal(text, config)\n    }\n    return this.request<MaskResponse>('/mask', 'POST', {\n      text,\n      ...config,\n    })\n  }\n\n  private maskLocal(text: string, config?: MaskConfig): MaskResponse {\n    const { entities: resolved, threshold } = this.resolvePolicy(config?.policy, config?.entities, config?.score_threshold)\n    const scanner = this.getScanner()\n    const result = scanner.mask(\n      text,\n      config?.chars_to_show ?? 3,\n      config?.from_end ?? false,\n      config?.masking_char ?? '*',\n      resolved\n    )\n\n    const detected: DetectedEntity[] = result.matches\n      .filter((m) => threshold == null || m.score >= threshold)\n      .map((m) => ({\n        type: m.entityType, text: m.text, start: m.start, end: m.end, score: m.score,\n      }))\n\n    return { text: result.text, detected_entities: detected, entities_count: detected.length }\n  }\n\n  /**\n   * Synthesize (replace real data with synthetic fake data)\n   *\n   * When no API key is set (or `mode: \"local\"`), synthesis runs locally\n   * using format-preserving random generation.\n   *\n   * @param text - Text to synthesize\n   * @param config - Optional configuration (language, entities)\n   * @returns Promise with synthetic text and detected entities\n   */\n  async synthesize(text: string, config?: SynthesizeConfig): Promise<SynthesizeResponse> {\n    if (this.useLocal) {\n      return this.synthesizeLocal(text, config)\n    }\n    return this.request<SynthesizeResponse>('/synthesize', 'POST', {\n      text,\n      ...config,\n    })\n  }\n\n  private synthesizeLocal(text: string, config?: SynthesizeConfig): SynthesizeResponse {\n    const { entities: resolved, threshold } = this.resolvePolicy(config?.policy, config?.entities, config?.score_threshold)\n    const scanner = this.getScanner()\n    const result = scanner.synthesize(text, undefined, resolved)\n\n    const detected: DetectedEntity[] = result.matches\n      .filter((m) => threshold == null || m.score >= threshold)\n      .map((m) => ({\n        type: m.entityType, text: m.text, start: m.start, end: m.end, score: m.score,\n      }))\n\n    return { text: result.text, detected_entities: detected, entities_count: detected.length }\n  }\n\n  /**\n   * Hash (replace with deterministic hash values)\n   *\n   * @param text - Text to hash\n   * @param config - Optional configuration (hash_type, hash_prefix, hash_length, entities)\n   * @returns Promise with hashed text and detected entities\n   */\n  async hash(text: string, config?: HashConfig): Promise<HashResponse> {\n    if (this.useLocal) {\n      return this.hashLocal(text, config)\n    }\n    return this.request<HashResponse>('/hash', 'POST', {\n      text,\n      ...config,\n    })\n  }\n\n  private hashLocal(text: string, config?: HashConfig): HashResponse {\n    const { entities: resolved, threshold } = this.resolvePolicy(config?.policy, config?.entities, config?.score_threshold)\n    const scanner = this.getScanner()\n    const result = scanner.hash(\n      text,\n      config?.hash_type ?? 'sha256',\n      config?.hash_prefix ?? 'HASH_',\n      config?.hash_length ?? 16,\n      resolved\n    )\n\n    const detected: DetectedEntity[] = result.matches\n      .filter((m) => threshold == null || m.score >= threshold)\n      .map((m) => ({\n        type: m.entityType, text: m.text, start: m.start, end: m.end, score: m.score,\n      }))\n\n    return { text: result.text, detected_entities: detected, entities_count: detected.length }\n  }\n\n  /**\n   * Encrypt (reversibly protect) sensitive data in text using AES encryption\n   *\n   * @param text - Text to encrypt\n   * @param config - Optional configuration (encryption_key, entities)\n   * @returns Promise with encrypted text and detected entities\n   */\n  async encrypt(text: string, config?: EncryptConfig): Promise<EncryptResponse> {\n    if (this.useLocal) {\n      return this.encryptLocal(text, config)\n    }\n    return this.request<EncryptResponse>('/encrypt', 'POST', {\n      text,\n      ...config,\n    })\n  }\n\n  private encryptLocal(text: string, config?: EncryptConfig): EncryptResponse {\n    if (!config?.encryption_key) {\n      throw new Error('encryption_key is required for local encryption mode')\n    }\n    const { entities: resolved, threshold } = this.resolvePolicy(config?.policy, config?.entities, config?.score_threshold)\n    const scanner = this.getScanner()\n    const result = scanner.encrypt(text, config.encryption_key, resolved)\n\n    const detected: DetectedEntity[] = result.matches\n      .filter((m) => threshold == null || m.score >= threshold)\n      .map((m) => ({\n        type: m.entityType, text: m.text, start: m.start, end: m.end, score: m.score,\n      }))\n\n    return { text: result.text, detected_entities: detected, entities_count: detected.length }\n  }\n\n  // ===== Batch methods =====\n\n  /**\n   * Tokenize multiple texts in a single request\n   * @param texts - Array of texts to tokenize (max 100)\n   * @param config - Optional configuration\n   * @returns Promise with batch results\n   */\n  async tokenizeBatch(texts: string[], config?: TokenizeConfig): Promise<BatchResponse> {\n    return this.request<BatchResponse>('/tokenize', 'POST', {\n      texts,\n      ...config,\n    })\n  }\n\n  /**\n   * Detect PII in multiple texts in a single request\n   * @param texts - Array of texts to analyze (max 100)\n   * @param config - Optional configuration\n   * @returns Promise with batch results\n   */\n  async detectBatch(texts: string[], config?: DetectConfig): Promise<BatchResponse> {\n    return this.request<BatchResponse>('/detect', 'POST', {\n      texts,\n      ...config,\n    })\n  }\n\n  /**\n   * Redact PII from multiple texts in a single request\n   * @param texts - Array of texts to redact (max 100)\n   * @param config - Optional configuration\n   * @returns Promise with batch results\n   */\n  async redactBatch(texts: string[], config?: RedactConfig): Promise<BatchResponse> {\n    return this.request<BatchResponse>('/redact', 'POST', {\n      texts,\n      ...config,\n    })\n  }\n\n  /**\n   * Mask PII in multiple texts in a single request\n   * @param texts - Array of texts to mask (max 100)\n   * @param config - Optional configuration\n   * @returns Promise with batch results\n   */\n  async maskBatch(texts: string[], config?: MaskConfig): Promise<BatchResponse> {\n    return this.request<BatchResponse>('/mask', 'POST', {\n      texts,\n      ...config,\n    })\n  }\n\n  /**\n   * Synthesize multiple texts in a single request\n   * @param texts - Array of texts to synthesize (max 100)\n   * @param config - Optional configuration\n   * @returns Promise with batch results\n   */\n  async synthesizeBatch(texts: string[], config?: SynthesizeConfig): Promise<BatchResponse> {\n    return this.request<BatchResponse>('/synthesize', 'POST', {\n      texts,\n      ...config,\n    })\n  }\n\n  /**\n   * Hash PII in multiple texts in a single request\n   * @param texts - Array of texts to hash (max 100)\n   * @param config - Optional configuration\n   * @returns Promise with batch results\n   */\n  async hashBatch(texts: string[], config?: HashConfig): Promise<BatchResponse> {\n    return this.request<BatchResponse>('/hash', 'POST', {\n      texts,\n      ...config,\n    })\n  }\n\n  /**\n   * Encrypt PII in multiple texts in a single request\n   * @param texts - Array of texts to encrypt (max 100)\n   * @param config - Optional configuration\n   * @returns Promise with batch results\n   */\n  async encryptBatch(texts: string[], config?: EncryptConfig): Promise<BatchResponse> {\n    return this.request<BatchResponse>('/encrypt', 'POST', {\n      texts,\n      ...config,\n    })\n  }\n}\n","export { Blindfold } from './client'\nexport type {\n  BlindfoldConfig,\n  DetectConfig,\n  DetectResponse,\n  TokenizeConfig,\n  TokenizeResponse,\n  DetokenizeResponse,\n  DetectedEntity,\n  BatchResponse,\n  APIErrorResponse,\n} from './types'\nexport { BlindfoldError, AuthenticationError, APIError, NetworkError } from './errors'\nexport { PIIScanner, EntityType } from './regex'\nexport type { PIIMatch } from './regex'\n"],"mappings":";;;;;;;;AAGA,IAAa,iBAAb,MAAa,uBAAuB,MAAM;CACxC,YAAYA,SAAiB;AAC3B,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,SAAO,eAAe,MAAM,eAAe,UAAU;CACtD;AACF;;;;AAKD,IAAa,sBAAb,MAAa,4BAA4B,eAAe;CACtD,YAAYA,UAAkB,qDAAqD;AACjF,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,SAAO,eAAe,MAAM,oBAAoB,UAAU;CAC3D;AACF;;;;AAKD,IAAa,WAAb,MAAa,iBAAiB,eAAe;CAC3C;CACA;CAEA,YAAYA,SAAiBC,YAAoBC,cAAwB;AACvE,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,OAAK,aAAa;AAClB,OAAK,eAAe;AACpB,SAAO,eAAe,MAAM,SAAS,UAAU;CAChD;AACF;;;;AAKD,IAAa,eAAb,MAAa,qBAAqB,eAAe;CAC/C,YAAYF,UAAkB,yDAAyD;AACrF,QAAM,QAAQ;AACd,OAAK,OAAO;AACZ,SAAO,eAAe,MAAM,aAAa,UAAU;CACpD;AACF;;;;ACrBD,MAAM,mBAAmB;AACzB,MAAM,yBAAyB,IAAI,IAAI;CAAC;CAAK;CAAK;CAAK;CAAK;AAAI;AAEhE,MAAMG,cAAsC;CAC1C,IAAI;CACJ,IAAI;AACL;AAED,SAAS,MAAMC,IAA2B;AACxC,QAAO,IAAI,QAAQ,CAAC,YAAY,WAAW,SAAS,GAAG;AACxD;AASD,MAAM,wBAAwB,KAAK,KAAK,WAAW,gBAAgB;AAEnE,SAAS,aAAaC,cAAkC;CACtD,MAAMC,UAAqB,KAAK,MAAM,GAAG,aAAa,uBAAuB,QAAQ,CAAC;AACtF,KAAI,cAAc;EAChB,MAAMC,OAAkB,KAAK,MAAM,GAAG,aAAa,cAAc,QAAQ,CAAC;AAC1E,SAAO;GAAE,GAAG;GAAS,GAAG;EAAM;CAC/B;AACD,QAAO;AACR;;;;;;;;AASD,IAAa,YAAb,MAAuB;CACrB,AAAQ;CACR,AAAQ;CACR,AAAQ;CACR,AAAQ;CACR,AAAQ;CACR,AAAQ;CACR,AAAQ;CACR,AAAQ;CACR,AAAQ;;;;;CAMR,YAAYC,SAA0B,CAAE,GAAE;AACxC,OAAK,SAAS,OAAO;AACrB,OAAK,OAAO,OAAO;AACnB,OAAK,UAAU,OAAO;AACtB,OAAK,WAAW,aAAa,OAAO,aAAa;AACjD,MAAI,OAAO,WAAW,OAAO,SAAS;GACpC,MAAM,YAAY,YAAY,OAAO;AACrC,QAAK,UACH,OAAM,IAAI,OACP,kBAAkB,OAAO,OAAO,qBAAqB,OAAO,KAAK,YAAY,CAAC,KAAK,KAAK,CAAC;AAG9F,QAAK,UAAU;EAChB,MACC,MAAK,UAAU,OAAO,WAAW;AAEnC,OAAK,SAAS,OAAO;AACrB,OAAK,aAAa,OAAO,cAAc;AACvC,OAAK,aAAa,OAAO,cAAc;AAEvC,MAAI,KAAK,YAAY,OAAO,OAC1B,SAAQ,MACL,UAAU,OAAO,OAAO,2EAE1B;CAEJ;CAED,IAAY,WAAoB;AAC9B,MAAI,KAAK,SAAS,QAAS,QAAO;AAClC,UAAQ,KAAK;CACd;CAED,AAAQ,aAA6B;AACnC,OAAK,KAAK,UAAU;GAClB,MAAM,EAAE,0BAAY;AACpB,QAAK,WAAW,IAAIC,aAAW,KAAK,UAAU,EAAE,SAAS,KAAK,QAAS;EACxE;AACD,SAAO,KAAK;CACb;CAED,AAAQ,cACNC,QACAC,UACAC,gBAC6C;AAC7C,MAAI,SACF,QAAO;GAAE;GAAU,WAAW;EAAgB;AAEhD,MAAI,QAAQ;GACV,MAAM,YAAY,KAAK,SAAS;AAChC,OAAI,UACF,QAAO;IACL,UAAU,UAAU;IACpB,WAAW,kBAAkB,UAAU;GACxC;OAED,SAAQ,MAAM,kBAAkB,OAAO,yCAAyC;EAEnF;AACD,SAAO,EAAE,WAAW,eAAgB;CACrC;CAED,AAAQ,UAAUC,SAAiBC,OAA0B;AAC3D,MAAI,SAAS,MAAM,eAAe,KAAK;GACrC,MAAM,OAAO,MAAM;AACnB,OAAI,eAAe,KAAK,gBAAgB,SACtC,QAAO,KAAK,cAAc;EAE7B;EACD,MAAM,QAAQ,KAAK,aAAa,KAAK,UAAU;EAC/C,MAAM,SAAS,QAAQ,KAAM,KAAK,QAAQ;AAC1C,SAAO,QAAQ;CAChB;;;;CAKD,MAAc,QACZC,UACAC,QACAC,MACY;EACZ,MAAM,OAAO,EAAE,KAAK,QAAQ,EAAE,SAAS;EAEvC,MAAMC,UAAkC,EACtC,gBAAgB,mBACjB;AAED,MAAI,KAAK,OACP,SAAQ,eAAe,KAAK;AAG9B,MAAI,KAAK,OACP,SAAQ,yBAAyB,KAAK;EAGxC,IAAIC,YAAmB,IAAI,aAAa;AAExC,OAAK,IAAI,UAAU,GAAG,WAAW,KAAK,YAAY,UAChD,KAAI;GACF,MAAM,WAAW,MAAM,MAAM,KAAK;IAChC;IACA;IACA,MAAM,OAAO,KAAK,UAAU,KAAK;GAClC,EAAC;AAGF,OAAI,SAAS,WAAW,OAAO,SAAS,WAAW,IACjD,OAAM,IAAI,oBAAoB;AAIhC,QAAK,SAAS,IAAI;IAChB,IAAI,gBAAgB,iCAAiC,SAAS,OAAO;IACrE,IAAIC;AAEJ,QAAI;AACF,oBAAe,MAAM,SAAS,MAAM;KACpC,MAAM,YAAY;AAClB,oBAAe,UAAU,UAAU,UAAU,WAAW;IACzD,QAAO;AAEN,qBAAgB,EAAE,aAAa,IAAI,SAAS,WAAW;IACxD;AAED,UAAM,IAAI,SAAS,cAAc,SAAS,QAAQ;GACnD;AAED,UAAQ,MAAM,SAAS,MAAM;EAC9B,SAAQ,OAAO;AAEd,OAAI,iBAAiB,oBACnB,OAAM;AAIR,OAAI,iBAAiB,UAAU;AAC7B,QAAI,uBAAuB,IAAI,MAAM,WAAW,IAAI,UAAU,KAAK,YAAY;AAC7E,WAAM,MAAM,KAAK,UAAU,SAAS,MAAM,CAAC;AAC3C;IACD;AACD,UAAM;GACP;AAGD,OAAI,iBAAiB,cAAc;AACjC,gBAAY;AACZ,QAAI,UAAU,KAAK,YAAY;AAC7B,WAAM,MAAM,KAAK,UAAU,QAAQ,CAAC;AACpC;IACD;AACD,UAAM;GACP;AAGD,OAAI,iBAAiB,aAAa,MAAM,QAAQ,SAAS,QAAQ,EAAE;AACjE,gBAAY,IAAI,aACd;AAEF,QAAI,UAAU,KAAK,YAAY;AAC7B,WAAM,MAAM,KAAK,UAAU,QAAQ,CAAC;AACpC;IACD;AACD,UAAM;GACP;AAGD,SAAM,IAAI,aAAa,iBAAiB,QAAQ,MAAM,UAAU;EACjE;AAGH,QAAM;CACP;;;;;;;CAQD,MAAM,SAASC,MAAcC,QAAoD;AAC/E,MAAI,KAAK,SACP,QAAO,KAAK,cAAc,MAAM,OAAO;AAEzC,SAAO,KAAK,QAA0B,aAAa,QAAQ;GACzD;GACA,GAAG;EACJ,EAAC;CACH;CAED,AAAQ,cAAcD,MAAcC,QAA2C;EAC7E,MAAM,EAAE,UAAU,UAAU,WAAW,GAAG,KAAK,cAAc,QAAQ,QAAQ,QAAQ,UAAU,QAAQ,gBAAgB;EACvH,MAAM,UAAU,KAAK,YAAY;EACjC,MAAM,SAAS,QAAQ,SAAS,MAAM,SAAS;EAE/C,MAAMC,WAA6B,OAAO,QACvC,OAAO,CAAC,MAAM,aAAa,QAAQ,EAAE,SAAS,UAAU,CACxD,IAAI,CAAC,OAAO;GACX,MAAM,EAAE;GAAY,MAAM,EAAE;GAAM,OAAO,EAAE;GAAO,KAAK,EAAE;GAAK,OAAO,EAAE;EACxE,GAAE;AAEL,SAAO;GAAE,MAAM,OAAO;GAAM,SAAS,OAAO;GAAS,mBAAmB;GAAU,gBAAgB,SAAS;EAAQ;CACpH;;;;;;;;;;;;;;CAeD,MAAM,OAAOF,MAAcG,QAAgD;AACzE,MAAI,KAAK,SACP,QAAO,KAAK,YAAY,MAAM,OAAO;AAEvC,SAAO,KAAK,QAAwB,WAAW,QAAQ;GACrD;GACA,GAAG;EACJ,EAAC;CACH;CAED,AAAQ,YAAYH,MAAcG,QAAuC;EACvE,MAAM,EAAE,UAAU,UAAU,WAAW,GAAG,KAAK,cAAc,QAAQ,QAAQ,QAAQ,UAAU,QAAQ,gBAAgB;EACvH,MAAM,UAAU,KAAK,YAAY;EACjC,MAAM,UAAU,QAAQ,OAAO,MAAM,SAAS;EAE9C,MAAMD,WAA6B,CAAE;AACrC,OAAK,MAAM,KAAK,SAAS;AACvB,OAAI,aAAa,QAAQ,EAAE,QAAQ,UAAW;AAC9C,YAAS,KAAK;IAAE,MAAM,EAAE;IAAY,MAAM,EAAE;IAAM,OAAO,EAAE;IAAO,KAAK,EAAE;IAAK,OAAO,EAAE;GAAO,EAAC;EAChG;AAED,SAAO;GAAE,mBAAmB;GAAU,gBAAgB,SAAS;EAAQ;CACxE;;;;;;;;;;;CAYD,WAAWF,MAAcI,SAAqD;EAC5E,IAAI,SAAS;EACb,IAAI,eAAe;EAGnB,MAAM,eAAe,OAAO,KAAK,QAAQ,CAAC,KAAK,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,OAAO;AAE7E,OAAK,MAAM,SAAS,cAAc;GAChC,MAAM,gBAAgB,QAAQ;GAC9B,MAAM,QAAQ,IAAI,OAAO,MAAM,QAAQ,uBAAuB,OAAO,EAAE;GACvE,MAAM,UAAU,OAAO,MAAM,MAAM;AAEnC,OAAI,SAAS;AACX,aAAS,OAAO,QAAQ,OAAO,cAAc;AAC7C,oBAAgB,QAAQ;GACzB;EACF;AAED,SAAO;GACL,MAAM;GACN,mBAAmB;EACpB;CACF;;;;;;;;;;;;;CAcD,MAAM,OAAOJ,MAAcK,QAAgD;AACzE,MAAI,KAAK,SACP,QAAO,KAAK,YAAY,MAAM,OAAO;AAEvC,SAAO,KAAK,QAAwB,WAAW,QAAQ;GACrD;GACA,GAAG;EACJ,EAAC;CACH;CAED,AAAQ,YAAYL,MAAcK,QAAuC;EACvE,MAAM,EAAE,UAAU,UAAU,WAAW,GAAG,KAAK,cAAc,QAAQ,QAAQ,QAAQ,UAAU,QAAQ,gBAAgB;EACvH,MAAM,UAAU,KAAK,YAAY;EACjC,MAAM,CAAC,cAAc,QAAQ,GAAG,QAAQ,OAAO,MAAM,SAAS;EAE9D,MAAMH,WAA6B,CAAE;AACrC,OAAK,MAAM,KAAK,SAAS;AACvB,OAAI,aAAa,QAAQ,EAAE,QAAQ,UAAW;AAC9C,YAAS,KAAK;IAAE,MAAM,EAAE;IAAY,MAAM,EAAE;IAAM,OAAO,EAAE;IAAO,KAAK,EAAE;IAAK,OAAO,EAAE;GAAO,EAAC;EAChG;AAED,SAAO;GAAE,MAAM;GAAc,mBAAmB;GAAU,gBAAgB,SAAS;EAAQ;CAC5F;;;;;;;;CASD,MAAM,KAAKF,MAAcM,QAA4C;AACnE,MAAI,KAAK,SACP,QAAO,KAAK,UAAU,MAAM,OAAO;AAErC,SAAO,KAAK,QAAsB,SAAS,QAAQ;GACjD;GACA,GAAG;EACJ,EAAC;CACH;CAED,AAAQ,UAAUN,MAAcM,QAAmC;EACjE,MAAM,EAAE,UAAU,UAAU,WAAW,GAAG,KAAK,cAAc,QAAQ,QAAQ,QAAQ,UAAU,QAAQ,gBAAgB;EACvH,MAAM,UAAU,KAAK,YAAY;EACjC,MAAM,SAAS,QAAQ,KACrB,MACA,QAAQ,iBAAiB,GACzB,QAAQ,YAAY,OACpB,QAAQ,gBAAgB,KACxB,SACD;EAED,MAAMJ,WAA6B,OAAO,QACvC,OAAO,CAAC,MAAM,aAAa,QAAQ,EAAE,SAAS,UAAU,CACxD,IAAI,CAAC,OAAO;GACX,MAAM,EAAE;GAAY,MAAM,EAAE;GAAM,OAAO,EAAE;GAAO,KAAK,EAAE;GAAK,OAAO,EAAE;EACxE,GAAE;AAEL,SAAO;GAAE,MAAM,OAAO;GAAM,mBAAmB;GAAU,gBAAgB,SAAS;EAAQ;CAC3F;;;;;;;;;;;CAYD,MAAM,WAAWF,MAAcO,QAAwD;AACrF,MAAI,KAAK,SACP,QAAO,KAAK,gBAAgB,MAAM,OAAO;AAE3C,SAAO,KAAK,QAA4B,eAAe,QAAQ;GAC7D;GACA,GAAG;EACJ,EAAC;CACH;CAED,AAAQ,gBAAgBP,MAAcO,QAA+C;EACnF,MAAM,EAAE,UAAU,UAAU,WAAW,GAAG,KAAK,cAAc,QAAQ,QAAQ,QAAQ,UAAU,QAAQ,gBAAgB;EACvH,MAAM,UAAU,KAAK,YAAY;EACjC,MAAM,SAAS,QAAQ,WAAW,cAAiB,SAAS;EAE5D,MAAML,WAA6B,OAAO,QACvC,OAAO,CAAC,MAAM,aAAa,QAAQ,EAAE,SAAS,UAAU,CACxD,IAAI,CAAC,OAAO;GACX,MAAM,EAAE;GAAY,MAAM,EAAE;GAAM,OAAO,EAAE;GAAO,KAAK,EAAE;GAAK,OAAO,EAAE;EACxE,GAAE;AAEL,SAAO;GAAE,MAAM,OAAO;GAAM,mBAAmB;GAAU,gBAAgB,SAAS;EAAQ;CAC3F;;;;;;;;CASD,MAAM,KAAKF,MAAcQ,QAA4C;AACnE,MAAI,KAAK,SACP,QAAO,KAAK,UAAU,MAAM,OAAO;AAErC,SAAO,KAAK,QAAsB,SAAS,QAAQ;GACjD;GACA,GAAG;EACJ,EAAC;CACH;CAED,AAAQ,UAAUR,MAAcQ,QAAmC;EACjE,MAAM,EAAE,UAAU,UAAU,WAAW,GAAG,KAAK,cAAc,QAAQ,QAAQ,QAAQ,UAAU,QAAQ,gBAAgB;EACvH,MAAM,UAAU,KAAK,YAAY;EACjC,MAAM,SAAS,QAAQ,KACrB,MACA,QAAQ,aAAa,UACrB,QAAQ,eAAe,SACvB,QAAQ,eAAe,IACvB,SACD;EAED,MAAMN,WAA6B,OAAO,QACvC,OAAO,CAAC,MAAM,aAAa,QAAQ,EAAE,SAAS,UAAU,CACxD,IAAI,CAAC,OAAO;GACX,MAAM,EAAE;GAAY,MAAM,EAAE;GAAM,OAAO,EAAE;GAAO,KAAK,EAAE;GAAK,OAAO,EAAE;EACxE,GAAE;AAEL,SAAO;GAAE,MAAM,OAAO;GAAM,mBAAmB;GAAU,gBAAgB,SAAS;EAAQ;CAC3F;;;;;;;;CASD,MAAM,QAAQF,MAAcS,QAAkD;AAC5E,MAAI,KAAK,SACP,QAAO,KAAK,aAAa,MAAM,OAAO;AAExC,SAAO,KAAK,QAAyB,YAAY,QAAQ;GACvD;GACA,GAAG;EACJ,EAAC;CACH;CAED,AAAQ,aAAaT,MAAcS,QAAyC;AAC1E,OAAK,QAAQ,eACX,OAAM,IAAI,MAAM;EAElB,MAAM,EAAE,UAAU,UAAU,WAAW,GAAG,KAAK,cAAc,QAAQ,QAAQ,QAAQ,UAAU,QAAQ,gBAAgB;EACvH,MAAM,UAAU,KAAK,YAAY;EACjC,MAAM,SAAS,QAAQ,QAAQ,MAAM,OAAO,gBAAgB,SAAS;EAErE,MAAMP,WAA6B,OAAO,QACvC,OAAO,CAAC,MAAM,aAAa,QAAQ,EAAE,SAAS,UAAU,CACxD,IAAI,CAAC,OAAO;GACX,MAAM,EAAE;GAAY,MAAM,EAAE;GAAM,OAAO,EAAE;GAAO,KAAK,EAAE;GAAK,OAAO,EAAE;EACxE,GAAE;AAEL,SAAO;GAAE,MAAM,OAAO;GAAM,mBAAmB;GAAU,gBAAgB,SAAS;EAAQ;CAC3F;;;;;;;CAUD,MAAM,cAAcQ,OAAiBT,QAAiD;AACpF,SAAO,KAAK,QAAuB,aAAa,QAAQ;GACtD;GACA,GAAG;EACJ,EAAC;CACH;;;;;;;CAQD,MAAM,YAAYS,OAAiBP,QAA+C;AAChF,SAAO,KAAK,QAAuB,WAAW,QAAQ;GACpD;GACA,GAAG;EACJ,EAAC;CACH;;;;;;;CAQD,MAAM,YAAYO,OAAiBL,QAA+C;AAChF,SAAO,KAAK,QAAuB,WAAW,QAAQ;GACpD;GACA,GAAG;EACJ,EAAC;CACH;;;;;;;CAQD,MAAM,UAAUK,OAAiBJ,QAA6C;AAC5E,SAAO,KAAK,QAAuB,SAAS,QAAQ;GAClD;GACA,GAAG;EACJ,EAAC;CACH;;;;;;;CAQD,MAAM,gBAAgBI,OAAiBH,QAAmD;AACxF,SAAO,KAAK,QAAuB,eAAe,QAAQ;GACxD;GACA,GAAG;EACJ,EAAC;CACH;;;;;;;CAQD,MAAM,UAAUG,OAAiBF,QAA6C;AAC5E,SAAO,KAAK,QAAuB,SAAS,QAAQ;GAClD;GACA,GAAG;EACJ,EAAC;CACH;;;;;;;CAQD,MAAM,aAAaE,OAAiBD,QAAgD;AAClF,SAAO,KAAK,QAAuB,YAAY,QAAQ;GACrD;GACA,GAAG;EACJ,EAAC;CACH;AACF;;;;ACnmBD,YAAgD"}

package/dist/regex/index.d.mts

@@ -0,0 +1,2 @@
+import { EntityType$1 as EntityType, PIIMatch, PIIScanner$1 as PIIScanner, PIIScannerOptions } from "../index-CsE6Vhax.mjs";
+export { EntityType, PIIMatch, PIIScanner, PIIScannerOptions };

package/dist/regex/index.d.ts

@@ -0,0 +1,2 @@
+import { EntityType, PIIMatch, PIIScanner, PIIScannerOptions } from "../index-Dfv8zV_d.js";
+export { EntityType, PIIMatch, PIIScanner, PIIScannerOptions };

package/dist/regex/index.js

@@ -0,0 +1,5 @@
+const require_regex = require('../regex-BEaK0E7Y.js');
+
+require_regex.init_regex();
+exports.EntityType = require_regex.EntityType
+exports.PIIScanner = require_regex.PIIScanner

package/dist/regex/index.mjs

@@ -0,0 +1,4 @@
+import { EntityType, PIIScanner, init_regex } from "../regex-ByjZg3Zy.mjs";
+
+init_regex();
+export { EntityType, PIIScanner };