@blindfold/sdk 1.0.2

package/dist/regex-BEaK0E7Y.js

@@ -0,0 +1,4881 @@
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function() {
+	return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+//#endregion
+const crypto = __toESM(require("crypto"));
+
+//#region src/regex/registry.ts
+/** Register a universal (locale-independent) detector class. */
+function registerUniversal(cls) {
+	UNIVERSAL_DETECTORS.push(cls);
+}
+/** Register a region-specific detector class. */
+function registerRegion(locale, cls) {
+	if (!REGION_DETECTORS[locale]) REGION_DETECTORS[locale] = [];
+	REGION_DETECTORS[locale].push(cls);
+}
+var UNIVERSAL_DETECTORS, REGION_DETECTORS, DetectorRegistry;
+var init_registry = __esm({ "src/regex/registry.ts"() {
+	UNIVERSAL_DETECTORS = [];
+	REGION_DETECTORS = {
+		us: [],
+		eu: [],
+		uk: []
+	};
+	DetectorRegistry = class {
+		_detectors = [];
+		constructor(locales) {
+			const resolvedLocales = (locales ?? ["us"]).map((loc) => loc.toLowerCase());
+			this._build(resolvedLocales);
+		}
+		_build(locales) {
+			for (const Cls of UNIVERSAL_DETECTORS) this._detectors.push(new Cls());
+			for (const locale of locales) {
+				const regionClasses = REGION_DETECTORS[locale] ?? [];
+				for (const Cls of regionClasses) this._detectors.push(new Cls());
+			}
+		}
+		get detectors() {
+			return this._detectors;
+		}
+	};
+} });
+
+//#endregion
+//#region src/regex/synthesizers.ts
+function randInt(min, max) {
+	return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randChar(chars) {
+	return chars[Math.floor(Math.random() * chars.length)];
+}
+function randHex(len) {
+	let result = "";
+	for (let i = 0; i < len; i++) result += randChar("0123456789abcdef");
+	return result;
+}
+/**
+* Format-preserving default: replace digits with random digits,
+* uppercase with random uppercase, lowercase with random lowercase,
+* keep everything else (separators, symbols) intact.
+*/
+function formatPreserving(original) {
+	const chars = [];
+	for (const ch of original) if (ch >= "0" && ch <= "9") chars.push(randChar(DIGITS));
+	else if (ch >= "A" && ch <= "Z") chars.push(randChar(UPPER));
+	else if (ch >= "a" && ch <= "z") chars.push(randChar(LOWER));
+	else chars.push(ch);
+	const result = chars.join("");
+	if (result === original) return formatPreserving(original);
+	return result;
+}
+function synthesizeEmail() {
+	const id = randHex(8);
+	return `user${id}@example.com`;
+}
+function synthesizeUrl() {
+	const path = randHex(10);
+	return `https://example.com/${path}`;
+}
+function synthesizeIp() {
+	const a = randInt(1, 254);
+	const b = randInt(0, 255);
+	const c = randInt(0, 255);
+	const d = randInt(1, 254);
+	return `${a}.${b}.${c}.${d}`;
+}
+/**
+* Generate a credit card number with valid Luhn checksum,
+* preserving the separator pattern of the original.
+*/
+function synthesizeCreditCard(original) {
+	const digitsOnly = original.replace(/\D/g, "");
+	const numDigits = digitsOnly.length;
+	const payload = [];
+	for (let i = 0; i < numDigits - 1; i++) payload.push(randInt(0, 9));
+	let sum = 0;
+	for (let i = payload.length - 1; i >= 0; i--) {
+		let d = payload[i];
+		if ((payload.length - 1 - i) % 2 === 0) {
+			d *= 2;
+			if (d > 9) d -= 9;
+		}
+		sum += d;
+	}
+	const checkDigit = (10 - sum % 10) % 10;
+	payload.push(checkDigit);
+	let digitIdx = 0;
+	let result = "";
+	for (const ch of original) if (ch >= "0" && ch <= "9") result += payload[digitIdx++];
+	else result += ch;
+	return result;
+}
+/**
+* Generate an IBAN-like value preserving length with a valid mod-97 check.
+*/
+function synthesizeIban(original) {
+	const stripped = original.replace(/\s/g, "");
+	const len = stripped.length;
+	if (len < 5) return formatPreserving(original);
+	const bbanLen = len - 4;
+	let bban = "";
+	for (let i = 0; i < bbanLen; i++) bban += randChar(DIGITS);
+	const numericStr = bban + "333300";
+	let remainder = 0;
+	for (const ch of numericStr) remainder = (remainder * 10 + parseInt(ch, 10)) % 97;
+	const checkDigits = (98 - remainder).toString().padStart(2, "0");
+	const iban = "XX" + checkDigits + bban;
+	if (original.includes(" ")) {
+		let spaceIdx = 0;
+		let result = "";
+		for (const ch of original) if (ch === " ") result += " ";
+		else result += iban[spaceIdx++] || "0";
+		return result;
+	}
+	return iban;
+}
+/**
+* Generate a synthetic replacement for a detected PII value.
+* Uses format-preserving random by default, with specific generators
+* for types where structural validity matters.
+*/
+function synthesizeValue(entityType, originalText) {
+	switch (entityType) {
+		case "Email Address": return synthesizeEmail();
+		case "URL": return synthesizeUrl();
+		case "IP Address": return synthesizeIp();
+		case "Credit Card Number": return synthesizeCreditCard(originalText);
+		case "IBAN": return synthesizeIban(originalText);
+		default: return formatPreserving(originalText);
+	}
+}
+var UPPER, LOWER, DIGITS;
+var init_synthesizers = __esm({ "src/regex/synthesizers.ts"() {
+	UPPER = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+	LOWER = "abcdefghijklmnopqrstuvwxyz";
+	DIGITS = "0123456789";
+} });
+
+//#endregion
+//#region src/regex/base.ts
+var Detector, RegexDetector;
+var init_base = __esm({ "src/regex/base.ts"() {
+	Detector = class {
+		score = .85;
+		baseScore = null;
+		contextKeywords = [];
+		contextRequired = false;
+		contextWindow = 50;
+		locale = "";
+		needsDigit = true;
+		/** Check if any context keyword appears near the match position. */
+		hasContext(text, start, end = 0) {
+			if (this.contextKeywords.length === 0) return true;
+			const lower = this._textLower || text.toLowerCase();
+			const windowStart = Math.max(0, start - this.contextWindow);
+			const before = lower.slice(windowStart, start);
+			const after = end ? lower.slice(end, end + this.contextWindow) : "";
+			const window = before + " " + after;
+			return this.contextKeywords.some((kw) => window.includes(kw));
+		}
+	};
+	RegexDetector = class extends Detector {
+		validator;
+		/** Optional fast pre-check before running regex. Override in subclasses. */
+		preCheck(_text) {
+			return true;
+		}
+		iterMatches(text) {
+			if (!this.preCheck(text)) return [];
+			const results = [];
+			this.pattern.lastIndex = 0;
+			let match;
+			while ((match = this.pattern.exec(text)) !== null) {
+				const matchedText = match[0];
+				const start = match.index;
+				const end = start + matchedText.length;
+				const hasCtx = this.hasContext(text, start, end);
+				if (this.contextRequired && !hasCtx) continue;
+				let score;
+				if (this.validator) {
+					if (!this.validator(matchedText)) continue;
+					score = hasCtx ? 1 : this.score;
+				} else if (hasCtx) score = this.score;
+				else score = this.baseScore !== null ? this.baseScore : this.score;
+				results.push({
+					entityType: this.entityType,
+					text: matchedText,
+					start,
+					end,
+					score
+				});
+			}
+			return results;
+		}
+	};
+} });
+
+//#endregion
+//#region src/regex/entities.ts
+var EntityType;
+var init_entities = __esm({ "src/regex/entities.ts"() {
+	EntityType = /* @__PURE__ */ function(EntityType$1) {
+		EntityType$1["EMAIL_ADDRESS"] = "Email Address";
+		EntityType$1["CREDIT_CARD"] = "Credit Card Number";
+		EntityType$1["PHONE_NUMBER"] = "Phone Number";
+		EntityType$1["IP_ADDRESS"] = "IP Address";
+		EntityType$1["URL"] = "URL";
+		EntityType$1["MAC_ADDRESS"] = "MAC Address";
+		EntityType$1["DATE_OF_BIRTH"] = "Date of Birth";
+		EntityType$1["CVV"] = "CVV";
+		EntityType$1["SSN"] = "Social Security Number";
+		EntityType$1["DRIVERS_LICENSE"] = "Driver's License";
+		EntityType$1["US_PASSPORT"] = "US Passport";
+		EntityType$1["TAX_ID"] = "Tax ID";
+		EntityType$1["ZIP_CODE"] = "ZIP Code";
+		EntityType$1["IBAN"] = "IBAN";
+		EntityType$1["EU_POSTAL_CODE"] = "Postal Code";
+		EntityType$1["VAT_ID"] = "VAT ID";
+		EntityType$1["NI_NUMBER"] = "NI Number";
+		EntityType$1["NHS_NUMBER"] = "NHS Number";
+		EntityType$1["UK_POSTCODE"] = "UK Postcode";
+		EntityType$1["UK_PASSPORT"] = "UK Passport";
+		EntityType$1["DE_PERSONAL_ID"] = "German Personal ID";
+		EntityType$1["DE_TAX_ID"] = "German Tax ID";
+		EntityType$1["FR_NATIONAL_ID"] = "French National ID";
+		EntityType$1["ES_DNI"] = "Spanish DNI";
+		EntityType$1["ES_NIE"] = "Spanish NIE";
+		EntityType$1["IT_CODICE_FISCALE"] = "Italian Codice Fiscale";
+		EntityType$1["PT_NIF"] = "Portuguese NIF";
+		EntityType$1["PL_PESEL"] = "Polish PESEL";
+		EntityType$1["PL_NIP"] = "Polish NIP";
+		EntityType$1["CZ_BIRTH_NUMBER"] = "Czech Birth Number";
+		EntityType$1["CZ_ICO"] = "Czech ICO";
+		EntityType$1["CZ_DIC"] = "Czech DIC";
+		EntityType$1["CZ_BANK_ACCOUNT"] = "Czech Bank Account";
+		EntityType$1["RU_INN"] = "Russian INN";
+		EntityType$1["RU_SNILS"] = "Russian SNILS";
+		EntityType$1["NL_BSN"] = "Dutch BSN";
+		EntityType$1["RO_CNP"] = "Romanian CNP";
+		EntityType$1["SK_BIRTH_NUMBER"] = "Slovak Birth Number";
+		EntityType$1["DK_CPR"] = "Danish CPR";
+		EntityType$1["SE_PERSONNUMMER"] = "Swedish Personnummer";
+		EntityType$1["NO_BIRTH_NUMBER"] = "Norwegian Birth Number";
+		EntityType$1["BR_CPF"] = "Brazilian CPF";
+		EntityType$1["BR_CNPJ"] = "Brazilian CNPJ";
+		EntityType$1["US_ITIN"] = "US ITIN";
+		EntityType$1["UK_UTR"] = "UK UTR";
+		EntityType$1["FR_SIREN"] = "French SIREN";
+		EntityType$1["ES_NSS"] = "Spanish NSS";
+		EntityType$1["ES_CIF"] = "Spanish CIF";
+		EntityType$1["IT_PARTITA_IVA"] = "Italian Partita IVA";
+		EntityType$1["PL_REGON"] = "Polish REGON";
+		EntityType$1["SK_ICO"] = "Slovak ICO";
+		EntityType$1["SK_DIC"] = "Slovak DIC";
+		EntityType$1["RO_CUI"] = "Romanian CUI";
+		EntityType$1["DK_CVR"] = "Danish CVR";
+		EntityType$1["SE_ORGNR"] = "Swedish Organisationsnummer";
+		EntityType$1["NO_ORGNR"] = "Norwegian Organisasjonsnummer";
+		EntityType$1["BE_NATIONAL_NUMBER"] = "Belgian National Number";
+		EntityType$1["BE_ENTERPRISE_NUMBER"] = "Belgian Enterprise Number";
+		EntityType$1["AT_SVNR"] = "Austrian SVNR";
+		EntityType$1["IE_PPS"] = "Irish PPS Number";
+		EntityType$1["FI_HETU"] = "Finnish HETU";
+		EntityType$1["FI_YTUNNUS"] = "Finnish Y-tunnus";
+		EntityType$1["HU_TAX_ID"] = "Hungarian Tax ID";
+		EntityType$1["HU_TAJ"] = "Hungarian TAJ";
+		EntityType$1["BG_EGN"] = "Bulgarian EGN";
+		EntityType$1["HR_OIB"] = "Croatian OIB";
+		EntityType$1["SI_EMSO"] = "Slovenian EMSO";
+		EntityType$1["SI_TAX_NUMBER"] = "Slovenian Tax Number";
+		EntityType$1["LT_PERSONAL_CODE"] = "Lithuanian Personal Code";
+		EntityType$1["LV_PERSONAL_CODE"] = "Latvian Personal Code";
+		EntityType$1["EE_PERSONAL_CODE"] = "Estonian Personal Code";
+		EntityType$1["CA_SIN"] = "Canadian SIN";
+		EntityType$1["CH_AHV"] = "Swiss AHV";
+		EntityType$1["AU_TFN"] = "Australian TFN";
+		EntityType$1["AU_MEDICARE"] = "Australian Medicare";
+		EntityType$1["NZ_IRD"] = "New Zealand IRD";
+		EntityType$1["IN_AADHAAR"] = "Indian Aadhaar";
+		EntityType$1["IN_PAN"] = "Indian PAN";
+		EntityType$1["JP_MY_NUMBER"] = "Japanese My Number";
+		EntityType$1["KR_RRN"] = "Korean RRN";
+		EntityType$1["ZA_ID"] = "South African ID";
+		EntityType$1["TR_KIMLIK"] = "Turkish Kimlik";
+		EntityType$1["IL_ID"] = "Israeli ID";
+		EntityType$1["AR_CUIT"] = "Argentine CUIT";
+		EntityType$1["CL_RUT"] = "Chilean RUT";
+		EntityType$1["CO_NIT"] = "Colombian NIT";
+		return EntityType$1;
+	}({});
+} });
+
+//#endregion
+//#region src/regex/detectors/email.ts
+var EmailDetector;
+var init_email = __esm({ "src/regex/detectors/email.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	EmailDetector = class extends RegexDetector {
+		entityType = EntityType.EMAIL_ADDRESS;
+		score = .95;
+		needsDigit = false;
+		pattern = /\b[a-zA-Z0-9._%+\-]+@[a-zA-Z0-9.\-]+\.[a-zA-Z]{2,}\b/g;
+		preCheck(text) {
+			return text.includes("@");
+		}
+	};
+	registerUniversal(EmailDetector);
+} });
+
+//#endregion
+//#region src/regex/validators.ts
+/** Validate a number string using the Luhn algorithm (ISO/IEC 7812). */
+function luhnChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length < 2) return false;
+	let total = 0;
+	const reversed = digits.slice().reverse();
+	for (let i = 0; i < reversed.length; i++) {
+		let d = reversed[i];
+		if (i % 2 === 1) {
+			d *= 2;
+			if (d > 9) d -= 9;
+		}
+		total += d;
+	}
+	return total % 10 === 0;
+}
+/** Validate IBAN using ISO 7064 mod-97 checksum. */
+function ibanMod97(iban) {
+	const cleaned = iban.replace(/[\s-]/g, "").toUpperCase();
+	if (cleaned.length < 5) return false;
+	if (!/^[A-Z]{2}/.test(cleaned) || !/^\d{2}/.test(cleaned.slice(2, 4))) return false;
+	const rearranged = cleaned.slice(4) + cleaned.slice(0, 4);
+	let numeric = "";
+	for (const c of rearranged) if (c >= "0" && c <= "9") numeric += c;
+	else if (c >= "A" && c <= "Z") numeric += String(c.charCodeAt(0) - 55);
+	else return false;
+	let remainder = 0;
+	for (let i = 0; i < numeric.length; i++) remainder = (remainder * 10 + parseInt(numeric[i], 10)) % 97;
+	return remainder === 1;
+}
+/** Check SSN format rules: no 000/666/9xx area, no 00 group, no 0000 serial. */
+function ssnValidFormat(ssn) {
+	let digits = "";
+	for (const c of ssn) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length !== 9) return false;
+	const area = parseInt(digits.slice(0, 3), 10);
+	const group = parseInt(digits.slice(3, 5), 10);
+	const serial = parseInt(digits.slice(5), 10);
+	if (area === 0 || area === 666 || area >= 900) return false;
+	if (group === 0) return false;
+	if (serial === 0) return false;
+	return true;
+}
+/** Validate German Tax ID using ISO 7064 Mod 11,10. */
+function deTaxIdChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 11) return false;
+	let product = 10;
+	for (let i = 0; i < 10; i++) {
+		let total = (digits[i] + product) % 10;
+		if (total === 0) total = 10;
+		product = total * 2 % 11;
+	}
+	let check = 11 - product;
+	if (check === 10) check = 0;
+	return digits[10] === check;
+}
+/** Validate French NIR using mod 97 checksum. */
+function frNirChecksum(number) {
+	const cleaned = number.toUpperCase().replace(/2A/g, "19").replace(/2B/g, "18");
+	let digitsStr = "";
+	for (const c of cleaned) if (c >= "0" && c <= "9") digitsStr += c;
+	if (digitsStr.length !== 15) return false;
+	const base = parseInt(digitsStr.slice(0, 13), 10);
+	const key = parseInt(digitsStr.slice(13, 15), 10);
+	return key === 97 - base % 97;
+}
+/** Validate Spanish DNI check letter using mod-23 table. */
+function esDniLetter(number) {
+	let cleaned = "";
+	for (const c of number) if (c >= "0" && c <= "9" || c >= "A" && c <= "Z" || c >= "a" && c <= "z") cleaned += c;
+	if (cleaned.length !== 9) return false;
+	const digitsStr = cleaned.slice(0, 8);
+	const letter = cleaned[8].toUpperCase();
+	for (const c of digitsStr) if (c < "0" || c > "9") return false;
+	const expected = ES_DNI_LETTERS[parseInt(digitsStr, 10) % 23];
+	return letter === expected;
+}
+/** Validate Spanish NIE check letter (X/Y/Z prefix, then same as DNI). */
+function esNieLetter(number) {
+	let cleaned = "";
+	for (const c of number) if (c >= "0" && c <= "9" || c >= "A" && c <= "Z" || c >= "a" && c <= "z") cleaned += c;
+	if (cleaned.length !== 9) return false;
+	const prefix = cleaned[0].toUpperCase();
+	const mapping = {
+		X: "0",
+		Y: "1",
+		Z: "2"
+	};
+	if (!(prefix in mapping)) return false;
+	const digitsStr = mapping[prefix] + cleaned.slice(1, 8);
+	const letter = cleaned[8].toUpperCase();
+	for (const c of digitsStr) if (c < "0" || c > "9") return false;
+	const expected = ES_DNI_LETTERS[parseInt(digitsStr, 10) % 23];
+	return letter === expected;
+}
+/** Validate Italian Codice Fiscale using odd/even position lookup tables. */
+function itCodiceFiscaleCheck(code) {
+	let cleaned = "";
+	for (const c of code) if (c >= "0" && c <= "9" || c >= "A" && c <= "Z" || c >= "a" && c <= "z") cleaned += c;
+	cleaned = cleaned.toUpperCase();
+	if (cleaned.length !== 16) return false;
+	let total = 0;
+	for (let i = 0; i < 15; i++) {
+		const c = cleaned[i];
+		const val = (i + 1) % 2 === 1 ? IT_ODD_TABLE[c] : IT_EVEN_TABLE[c];
+		if (val === void 0) return false;
+		total += val;
+	}
+	const expected = String.fromCharCode(total % 26 + "A".charCodeAt(0));
+	return cleaned[15] === expected;
+}
+/** Validate Portuguese NIF using weighted checksum. */
+function ptNifChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 9) return false;
+	if (![
+		1,
+		2,
+		3,
+		5,
+		6,
+		8,
+		9
+	].includes(digits[0])) return false;
+	let total = 0;
+	for (let i = 0; i < 8; i++) total += digits[i] * (9 - i);
+	const remainder = total % 11;
+	const check = remainder < 2 ? 0 : 11 - remainder;
+	return digits[8] === check;
+}
+/** Validate Polish PESEL using weighted mod-10 checksum. */
+function plPeselChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 11) return false;
+	const weights = [
+		1,
+		3,
+		7,
+		9,
+		1,
+		3,
+		7,
+		9,
+		1,
+		3
+	];
+	let total = 0;
+	for (let i = 0; i < 10; i++) total += digits[i] * weights[i];
+	const check = (10 - total % 10) % 10;
+	return digits[10] === check;
+}
+/** Validate Polish NIP using weighted mod-11 checksum. */
+function plNipChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 10) return false;
+	const weights = [
+		6,
+		5,
+		7,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7
+	];
+	let total = 0;
+	for (let i = 0; i < 9; i++) total += digits[i] * weights[i];
+	const check = total % 11;
+	if (check === 10) return false;
+	return digits[9] === check;
+}
+/** Validate Czech Birth Number: divisible by 11 + month check. */
+function czBirthNumberValid(number) {
+	const cleaned = number.replace(/[/ ]/g, "");
+	for (const c of cleaned) if (c < "0" || c > "9") return false;
+	if (cleaned.length !== 9 && cleaned.length !== 10) return false;
+	if (cleaned.length === 10) {
+		let remainder = 0;
+		for (const c of cleaned) remainder = (remainder * 10 + parseInt(c, 10)) % 11;
+		if (remainder !== 0) return false;
+	}
+	const month = parseInt(cleaned.slice(2, 4), 10);
+	let baseMonth = month % 50;
+	if (baseMonth > 20) baseMonth -= 20;
+	if (baseMonth < 1 || baseMonth > 12) return false;
+	return true;
+}
+/** Validate Czech ICO (Company ID) using mod-11 weighted checksum. */
+function czIcoChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 8) return false;
+	const weights = [
+		8,
+		7,
+		6,
+		5,
+		4,
+		3,
+		2
+	];
+	let total = 0;
+	for (let i = 0; i < 7; i++) total += digits[i] * weights[i];
+	const remainder = total % 11;
+	let check;
+	if (remainder === 0) check = 1;
+	else if (remainder === 1) check = 0;
+	else check = 11 - remainder;
+	return digits[7] === check;
+}
+/** Validate Czech DIC (Tax/VAT ID): CZ prefix + ICO or birth number checksum. */
+function czDicValid(number) {
+	let cleaned = number.trim();
+	if (cleaned.toUpperCase().startsWith("CZ")) cleaned = cleaned.slice(2);
+	if (!/^\d+$/.test(cleaned)) return false;
+	if (cleaned.length === 8) return czIcoChecksum(cleaned);
+	if (cleaned.length === 10) {
+		let remainder = 0;
+		for (const c of cleaned) remainder = (remainder * 10 + parseInt(c, 10)) % 11;
+		return remainder === 0;
+	}
+	if (cleaned.length === 9) {
+		const month = parseInt(cleaned.slice(2, 4), 10);
+		let baseMonth = month % 50;
+		if (baseMonth > 20) baseMonth -= 20;
+		return baseMonth >= 1 && baseMonth <= 12;
+	}
+	return false;
+}
+/** Validate Czech bank account number using mod-11 weighted checksum. */
+function czBankAccountValid(number) {
+	const parts = number.split("/");
+	if (parts.length !== 2) return false;
+	const bankCode = parts[1];
+	if (!/^\d{4}$/.test(bankCode)) return false;
+	const accountPart = parts[0];
+	let prefix = "";
+	let account = accountPart;
+	if (accountPart.includes("-")) {
+		const split = accountPart.split("-");
+		if (split.length !== 2) return false;
+		prefix = split[0];
+		account = split[1];
+	}
+	if (!/^\d{1,6}$/.test(prefix) && prefix !== "") return false;
+	if (!/^\d{2,10}$/.test(account)) return false;
+	const weights = [
+		6,
+		3,
+		7,
+		9,
+		10,
+		5,
+		8,
+		4,
+		2,
+		1
+	];
+	const accDigits = account.padStart(10, "0").split("").map(Number);
+	let total = 0;
+	for (let i = 0; i < 10; i++) total += accDigits[i] * weights[i];
+	if (total % 11 !== 0) return false;
+	if (prefix !== "") {
+		const prefDigits = prefix.padStart(6, "0").split("").map(Number);
+		const prefWeights = weights.slice(4);
+		let prefTotal = 0;
+		for (let i = 0; i < 6; i++) prefTotal += prefDigits[i] * prefWeights[i];
+		if (prefTotal % 11 !== 0) return false;
+	}
+	if (prefix === "" && account.length === 6 && czBirthNumberValid(number)) return false;
+	return true;
+}
+/** Validate Slovak Birth Number (same logic as Czech). */
+function skBirthNumberValid(number) {
+	return czBirthNumberValid(number);
+}
+/** Validate Russian INN using weighted checksum (10 or 12 digits). */
+function ruInnChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length === 10) {
+		const weights = [
+			2,
+			4,
+			10,
+			3,
+			5,
+			9,
+			4,
+			6,
+			8
+		];
+		let total = 0;
+		for (let i = 0; i < 9; i++) total += digits[i] * weights[i];
+		return digits[9] === total % 11 % 10;
+	} else if (digits.length === 12) {
+		const weights1 = [
+			7,
+			2,
+			4,
+			10,
+			3,
+			5,
+			9,
+			4,
+			6,
+			8
+		];
+		let total1 = 0;
+		for (let i = 0; i < 10; i++) total1 += digits[i] * weights1[i];
+		const check1 = total1 % 11 % 10;
+		if (digits[10] !== check1) return false;
+		const weights2 = [
+			3,
+			7,
+			2,
+			4,
+			10,
+			3,
+			5,
+			9,
+			4,
+			6,
+			8
+		];
+		let total2 = 0;
+		for (let i = 0; i < 11; i++) total2 += digits[i] * weights2[i];
+		const check2 = total2 % 11 % 10;
+		return digits[11] === check2;
+	}
+	return false;
+}
+/** Validate Russian SNILS using mod-101 checksum. */
+function ruSnilsChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 11) return false;
+	let base = 0;
+	for (let i = 0; i < 9; i++) base = base * 10 + digits[i];
+	if (base <= 1001998) return true;
+	let total = 0;
+	for (let i = 0; i < 9; i++) total += digits[i] * (9 - i);
+	let check = total % 101;
+	if (check === 100) check = 0;
+	const checkValue = digits[9] * 10 + digits[10];
+	return checkValue === check;
+}
+/** Validate Dutch BSN using the 11-test. */
+function nlBsn11test(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 9) return false;
+	let total = 0;
+	for (let i = 0; i < 8; i++) total += digits[i] * (9 - i);
+	total -= digits[8];
+	return total % 11 === 0 && total !== 0;
+}
+/** Validate Romanian CNP using weighted checksum. */
+function roCnpChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 13) return false;
+	if (digits[0] < 1 || digits[0] > 8) return false;
+	const weights = [
+		2,
+		7,
+		9,
+		1,
+		4,
+		6,
+		3,
+		5,
+		8,
+		2,
+		7,
+		9
+	];
+	let total = 0;
+	for (let i = 0; i < 12; i++) total += digits[i] * weights[i];
+	let check = total % 11;
+	if (check === 10) check = 1;
+	return digits[12] === check;
+}
+/** Validate Danish CPR number by checking the date portion. */
+function dkCprValidDate(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length !== 10) return false;
+	const day = parseInt(digits.slice(0, 2), 10);
+	const month = parseInt(digits.slice(2, 4), 10);
+	if (day < 1 || day > 31) return false;
+	if (month < 1 || month > 12) return false;
+	return true;
+}
+/** Validate Swedish Personnummer using Luhn on last 10 digits. */
+function sePersonnummerLuhn(number) {
+	let digitsStr = "";
+	for (const c of number) if (c >= "0" && c <= "9") digitsStr += c;
+	if (digitsStr.length === 12) digitsStr = digitsStr.slice(2);
+	if (digitsStr.length !== 10) return false;
+	const month = parseInt(digitsStr.slice(2, 4), 10);
+	const day = parseInt(digitsStr.slice(4, 6), 10);
+	if (month < 1 || month > 12) return false;
+	if (day < 1 || day > 31) return false;
+	return luhnChecksum(digitsStr);
+}
+/** Validate Norwegian Birth Number using dual weighted checksums. */
+function noBirthNumberChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 11) return false;
+	const weights1 = [
+		3,
+		7,
+		6,
+		1,
+		8,
+		9,
+		4,
+		5,
+		2
+	];
+	let total1 = 0;
+	for (let i = 0; i < 9; i++) total1 += digits[i] * weights1[i];
+	let check1 = 11 - total1 % 11;
+	if (check1 === 11) check1 = 0;
+	if (check1 === 10) return false;
+	if (digits[9] !== check1) return false;
+	const weights2 = [
+		5,
+		4,
+		3,
+		2,
+		7,
+		6,
+		5,
+		4,
+		3,
+		2
+	];
+	let total2 = 0;
+	for (let i = 0; i < 10; i++) total2 += digits[i] * weights2[i];
+	let check2 = 11 - total2 % 11;
+	if (check2 === 11) check2 = 0;
+	if (check2 === 10) return false;
+	return digits[10] === check2;
+}
+/** Validate Brazilian CPF using weighted mod-11 checksum. */
+function brCpfChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 11) return false;
+	if (new Set(digits).size === 1) return false;
+	let total1 = 0;
+	for (let i = 0; i < 9; i++) total1 += digits[i] * (10 - i);
+	let check1 = total1 * 10 % 11;
+	if (check1 === 10) check1 = 0;
+	if (digits[9] !== check1) return false;
+	let total2 = 0;
+	for (let i = 0; i < 10; i++) total2 += digits[i] * (11 - i);
+	let check2 = total2 * 10 % 11;
+	if (check2 === 10) check2 = 0;
+	return digits[10] === check2;
+}
+/** Validate Brazilian CNPJ using weighted mod-11 checksum. */
+function brCnpjChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 14) return false;
+	const weights1 = [
+		5,
+		4,
+		3,
+		2,
+		9,
+		8,
+		7,
+		6,
+		5,
+		4,
+		3,
+		2
+	];
+	let total1 = 0;
+	for (let i = 0; i < 12; i++) total1 += digits[i] * weights1[i];
+	let check1 = total1 % 11;
+	check1 = check1 < 2 ? 0 : 11 - check1;
+	if (digits[12] !== check1) return false;
+	const weights2 = [
+		6,
+		5,
+		4,
+		3,
+		2,
+		9,
+		8,
+		7,
+		6,
+		5,
+		4,
+		3,
+		2
+	];
+	let total2 = 0;
+	for (let i = 0; i < 13; i++) total2 += digits[i] * weights2[i];
+	let check2 = total2 % 11;
+	check2 = check2 < 2 ? 0 : 11 - check2;
+	return digits[13] === check2;
+}
+/** Validate US ITIN format: 9XX-[7X|8X|9X|70-88]-XXXX. */
+function usItinValid(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length !== 9) return false;
+	if (digits[0] !== "9") return false;
+	const d4 = parseInt(digits[3], 10);
+	if (d4 < 7) return false;
+	return true;
+}
+/** Validate UK UTR using mod-11 weighted checksum. */
+function ukUtrChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 10) return false;
+	const weights = [
+		6,
+		7,
+		8,
+		9,
+		10,
+		5,
+		4,
+		3,
+		2
+	];
+	let total = 0;
+	for (let i = 0; i < 9; i++) total += digits[i + 1] * weights[i];
+	const remainder = total % 11;
+	const check = 11 - remainder === 10 ? 0 : 11 - remainder;
+	return digits[0] === check || 11 - remainder === 11 && digits[0] === 0;
+}
+/** Validate Spanish NSS using mod-97 checksum. */
+function esNssChecksum(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length !== 12) return false;
+	const province = parseInt(digits.slice(0, 2), 10);
+	if (province < 1 || province > 53) return false;
+	const baseNum = parseInt(digits.slice(0, 10), 10);
+	const check = parseInt(digits.slice(10, 12), 10);
+	return baseNum % 97 === check;
+}
+/** Validate Spanish CIF using custom checksum. */
+function esCifChecksum(number) {
+	let cleaned = "";
+	for (const c of number) if (c >= "0" && c <= "9" || c >= "A" && c <= "Z" || c >= "a" && c <= "z") cleaned += c;
+	cleaned = cleaned.toUpperCase();
+	if (cleaned.length !== 9) return false;
+	const letter = cleaned[0];
+	if (!"ABCDEFGHJNPQRSUVW".includes(letter)) return false;
+	let totalEven = 0;
+	let totalOdd = 0;
+	for (let i = 1; i <= 7; i++) {
+		const d = parseInt(cleaned[i], 10);
+		if (isNaN(d)) return false;
+		if (i % 2 === 0) totalEven += d;
+		else {
+			const doubled = d * 2;
+			totalOdd += Math.floor(doubled / 10) + doubled % 10;
+		}
+	}
+	const total = totalEven + totalOdd;
+	const checkDigit = (10 - total % 10) % 10;
+	const control = cleaned[8];
+	if ("KPQS".includes(letter)) return control === String.fromCharCode("A".charCodeAt(0) + checkDigit);
+	if ("ABEH".includes(letter)) return control === String(checkDigit);
+	return control === String(checkDigit) || control === String.fromCharCode("A".charCodeAt(0) + checkDigit);
+}
+/** Validate Italian Partita IVA using Luhn-like algorithm. */
+function itPartitaIvaChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 11) return false;
+	if (digits.every((d) => d === 0)) return false;
+	let total = 0;
+	for (let i = 0; i < 10; i++) if (i % 2 === 0) total += digits[i];
+	else {
+		const doubled = digits[i] * 2;
+		total += doubled > 9 ? doubled - 9 : doubled;
+	}
+	const check = (10 - total % 10) % 10;
+	return digits[10] === check;
+}
+/** Validate Polish REGON using mod-11 weighted checksum (9 or 14 digits). */
+function plRegonChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length === 9) {
+		const weights = [
+			8,
+			9,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7
+		];
+		let total = 0;
+		for (let i = 0; i < 8; i++) total += digits[i] * weights[i];
+		const check = total % 11 === 10 ? 0 : total % 11;
+		return digits[8] === check;
+	}
+	if (digits.length === 14) {
+		const weights9 = [
+			8,
+			9,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7
+		];
+		let total9 = 0;
+		for (let i = 0; i < 8; i++) total9 += digits[i] * weights9[i];
+		const check9 = total9 % 11 === 10 ? 0 : total9 % 11;
+		if (digits[8] !== check9) return false;
+		const weights14 = [
+			2,
+			4,
+			8,
+			5,
+			0,
+			9,
+			7,
+			3,
+			6,
+			1,
+			2,
+			4,
+			8
+		];
+		let total14 = 0;
+		for (let i = 0; i < 13; i++) total14 += digits[i] * weights14[i];
+		const check14 = total14 % 11 === 10 ? 0 : total14 % 11;
+		return digits[13] === check14;
+	}
+	return false;
+}
+/** Validate Slovak ICO using same algorithm as Czech ICO. */
+function skIcoChecksum(number) {
+	return czIcoChecksum(number);
+}
+/** Validate Slovak DIC: SK prefix + digits divisible by 11. */
+function skDicValid(number) {
+	let cleaned = number.trim();
+	if (cleaned.toUpperCase().startsWith("SK")) cleaned = cleaned.slice(2);
+	if (!/^\d{10}$/.test(cleaned)) return false;
+	let remainder = 0;
+	for (const c of cleaned) remainder = (remainder * 10 + parseInt(c, 10)) % 11;
+	return remainder === 0;
+}
+/** Validate Romanian CUI using mod-11 weighted checksum. */
+function roCuiChecksum(number) {
+	let cleaned = number.trim().toUpperCase();
+	if (cleaned.startsWith("RO")) cleaned = cleaned.slice(2);
+	const digits = [];
+	for (const c of cleaned) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length < 2 || digits.length > 10) return false;
+	const weights = [
+		7,
+		5,
+		3,
+		2,
+		1,
+		7,
+		5,
+		3,
+		2
+	];
+	const padded = Array(10 - digits.length).fill(0).concat(digits);
+	const check = padded.pop();
+	let total = 0;
+	for (let i = 0; i < 9; i++) total += padded[i] * weights[i];
+	const expected = total * 10 % 11 === 10 ? 0 : total * 10 % 11;
+	return check === expected;
+}
+/** Validate Danish CVR using mod-11 weighted checksum. */
+function dkCvrChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 8) return false;
+	const weights = [
+		2,
+		7,
+		6,
+		5,
+		4,
+		3,
+		2,
+		1
+	];
+	let total = 0;
+	for (let i = 0; i < 8; i++) total += digits[i] * weights[i];
+	return total % 11 === 0;
+}
+/** Validate Swedish Organisationsnummer using Luhn on 10 digits. */
+function seOrgnrChecksum(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length !== 10) return false;
+	const d3 = parseInt(digits[2], 10);
+	if (d3 < 2) return false;
+	return luhnChecksum(digits);
+}
+/** Validate Norwegian Organisasjonsnummer using mod-11 weighted checksum. */
+function noOrgnrChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 9) return false;
+	const weights = [
+		3,
+		2,
+		7,
+		6,
+		5,
+		4,
+		3,
+		2
+	];
+	let total = 0;
+	for (let i = 0; i < 8; i++) total += digits[i] * weights[i];
+	const remainder = total % 11;
+	if (remainder === 1) return false;
+	const check = remainder === 0 ? 0 : 11 - remainder;
+	return digits[8] === check;
+}
+/** Validate Belgian National Number using mod-97 checksum. */
+function beNationalNumberChecksum(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length !== 11) return false;
+	const base = parseInt(digits.slice(0, 9), 10);
+	const check = parseInt(digits.slice(9, 11), 10);
+	if (97 - base % 97 === check) return true;
+	const base2000 = parseInt("2" + digits.slice(0, 9), 10);
+	return 97 - base2000 % 97 === check;
+}
+/** Validate Belgian Enterprise Number using mod-97 checksum. */
+function beEnterpriseChecksum(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length !== 10) return false;
+	if (digits[0] !== "0" && digits[0] !== "1") return false;
+	const base = parseInt(digits.slice(0, 8), 10);
+	const check = parseInt(digits.slice(8, 10), 10);
+	return 97 - base % 97 === check;
+}
+/** Validate Austrian SVNR (Social Insurance Number). */
+function atSvnrChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 10) return false;
+	const weights = [
+		3,
+		7,
+		9,
+		0,
+		5,
+		8,
+		4,
+		2,
+		1,
+		6
+	];
+	let total = 0;
+	for (let i = 0; i < 10; i++) total += digits[i] * weights[i];
+	return total % 11 === digits[3];
+}
+/** Validate Irish PPS Number using mod-23 checksum. */
+function iePpsChecksum(number) {
+	let cleaned = "";
+	for (const c of number) if (c >= "0" && c <= "9" || c >= "A" && c <= "Z" || c >= "a" && c <= "z") cleaned += c;
+	cleaned = cleaned.toUpperCase();
+	if (cleaned.length < 8 || cleaned.length > 9) return false;
+	let total = 0;
+	for (let i = 0; i < 7; i++) {
+		const d = parseInt(cleaned[i], 10);
+		if (isNaN(d)) return false;
+		total += d * (8 - i);
+	}
+	if (cleaned.length === 9 && cleaned[8] >= "A" && cleaned[8] <= "Z") total += (cleaned[8].charCodeAt(0) - 64) * 9;
+	const remainder = total % 23;
+	const expected = remainder === 0 ? "W" : String.fromCharCode("A".charCodeAt(0) + remainder - 1);
+	return cleaned[7] === expected;
+}
+/** Validate Finnish HETU (Personal Identity Code) using mod-31 checksum. */
+function fiHetuChecksum(number) {
+	let cleaned = number.replace(/[\s-]/g, "");
+	if (cleaned.length !== 11) cleaned = number.trim();
+	if (cleaned.length !== 11) return false;
+	const datePart = cleaned.slice(0, 6);
+	for (const c of datePart) if (c < "0" || c > "9") return false;
+	const sep = cleaned[6];
+	if (!"-+ABCDEFYXWVU".includes(sep)) return false;
+	const numPart = cleaned.slice(7, 10);
+	for (const c of numPart) if (c < "0" || c > "9") return false;
+	const checkChars = "0123456789ABCDEFHJKLMNPRSTUVWXY";
+	const combined = parseInt(datePart + numPart, 10);
+	const expected = checkChars[combined % 31];
+	return cleaned[10].toUpperCase() === expected;
+}
+/** Validate Finnish Y-tunnus (Business ID) using mod-11 weighted checksum. */
+function fiYtunnusChecksum(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length !== 8) return false;
+	const weights = [
+		7,
+		9,
+		10,
+		5,
+		8,
+		4,
+		2
+	];
+	let total = 0;
+	for (let i = 0; i < 7; i++) total += parseInt(digits[i], 10) * weights[i];
+	const remainder = total % 11;
+	if (remainder === 1) return false;
+	const check = remainder === 0 ? 0 : 11 - remainder;
+	return parseInt(digits[7], 10) === check;
+}
+/** Validate Hungarian Tax ID using mod-11 weighted checksum. */
+function huTaxIdChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 10) return false;
+	if (digits[0] !== 8) return false;
+	const weights = [
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		9
+	];
+	let total = 0;
+	for (let i = 0; i < 9; i++) total += digits[i] * weights[i];
+	return digits[9] === total % 11;
+}
+/** Validate Hungarian TAJ (Social Security) using mod-10 with 3/7 weights. */
+function huTajChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 9) return false;
+	let total = 0;
+	for (let i = 0; i < 8; i++) total += digits[i] * (i % 2 === 0 ? 3 : 7);
+	return digits[8] === total % 10;
+}
+/** Validate Bulgarian EGN using weighted mod-11 checksum. */
+function bgEgnChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 10) return false;
+	const month = parseInt(number.slice(2, 4), 10);
+	const baseMonth = month > 40 ? month - 40 : month > 20 ? month - 20 : month;
+	if (baseMonth < 1 || baseMonth > 12) return false;
+	const weights = [
+		2,
+		4,
+		8,
+		5,
+		10,
+		9,
+		7,
+		3,
+		6
+	];
+	let total = 0;
+	for (let i = 0; i < 9; i++) total += digits[i] * weights[i];
+	let check = total % 11;
+	if (check === 10) check = 0;
+	return digits[9] === check;
+}
+/** Validate Croatian OIB using ISO 7064 MOD 11,2. */
+function hrOibChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 11) return false;
+	let remainder = 10;
+	for (let i = 0; i < 10; i++) {
+		remainder = (remainder + digits[i]) % 10;
+		if (remainder === 0) remainder = 10;
+		remainder = remainder * 2 % 11;
+	}
+	let check = 11 - remainder;
+	if (check === 10) check = 0;
+	return digits[10] === check;
+}
+/** Validate Slovenian EMSO using mod-11 weighted checksum. */
+function siEmsoChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 13) return false;
+	const weights = [
+		7,
+		6,
+		5,
+		4,
+		3,
+		2,
+		7,
+		6,
+		5,
+		4,
+		3,
+		2
+	];
+	let total = 0;
+	for (let i = 0; i < 12; i++) total += digits[i] * weights[i];
+	const remainder = total % 11;
+	const check = remainder === 0 ? 0 : 11 - remainder;
+	if (check === 10) return false;
+	return digits[12] === check;
+}
+/** Validate Slovenian Tax Number using mod-11. */
+function siTaxNumberChecksum(number) {
+	let cleaned = number.trim().toUpperCase();
+	if (cleaned.startsWith("SI")) cleaned = cleaned.slice(2);
+	const digits = [];
+	for (const c of cleaned) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 8) return false;
+	const weights = [
+		8,
+		7,
+		6,
+		5,
+		4,
+		3,
+		2
+	];
+	let total = 0;
+	for (let i = 0; i < 7; i++) total += digits[i] * weights[i];
+	const remainder = total % 11;
+	if (remainder === 0 || remainder === 1) return digits[7] === 0;
+	return digits[7] === 11 - remainder;
+}
+/** Validate Lithuanian Personal Code using dual-pass mod-11 checksum. */
+function ltPersonalCodeChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 11) return false;
+	if (digits[0] < 1 || digits[0] > 6) return false;
+	const weights1 = [
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		9,
+		1
+	];
+	let total = 0;
+	for (let i = 0; i < 10; i++) total += digits[i] * weights1[i];
+	let check = total % 11;
+	if (check === 10) {
+		const weights2 = [
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9,
+			1,
+			2,
+			3
+		];
+		total = 0;
+		for (let i = 0; i < 10; i++) total += digits[i] * weights2[i];
+		check = total % 11;
+		if (check === 10) check = 0;
+	}
+	return digits[10] === check;
+}
+/** Validate Latvian Personal Code (old format with checksum). */
+function lvPersonalCodeChecksum(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length !== 11) return false;
+	const day = parseInt(digits.slice(0, 2), 10);
+	const month = parseInt(digits.slice(2, 4), 10);
+	if (digits[0] === "3" && digits[1] === "2") return true;
+	if (day < 1 || day > 31) return false;
+	if (month < 1 || month > 12) return false;
+	const weights = [
+		1,
+		6,
+		3,
+		7,
+		9,
+		10,
+		5,
+		8,
+		4,
+		2
+	];
+	let total = 0;
+	for (let i = 0; i < 10; i++) total += parseInt(digits[i], 10) * weights[i];
+	const check = (1101 - total) % 11 % 10;
+	return parseInt(digits[10], 10) === check;
+}
+/** Validate Estonian Personal Code using dual-pass mod-11 checksum. */
+function eePersonalCodeChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 11) return false;
+	if (digits[0] < 1 || digits[0] > 6) return false;
+	const weights1 = [
+		1,
+		2,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		9,
+		1
+	];
+	let total = 0;
+	for (let i = 0; i < 10; i++) total += digits[i] * weights1[i];
+	let check = total % 11;
+	if (check === 10) {
+		const weights2 = [
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9,
+			1,
+			2,
+			3
+		];
+		total = 0;
+		for (let i = 0; i < 10; i++) total += digits[i] * weights2[i];
+		check = total % 11;
+		if (check === 10) check = 0;
+	}
+	return digits[10] === check;
+}
+/** Validate Swiss AHV using EAN-13 checksum. */
+function chAhvChecksum(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length !== 13) return false;
+	if (!digits.startsWith("756")) return false;
+	let total = 0;
+	for (let i = 0; i < 12; i++) total += parseInt(digits[i], 10) * (i % 2 === 0 ? 1 : 3);
+	const check = (10 - total % 10) % 10;
+	return parseInt(digits[12], 10) === check;
+}
+/** Validate Australian TFN using mod-11 weighted checksum. */
+function auTfnChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 9 && digits.length !== 8) return false;
+	if (digits.length === 8) {
+		const weights$1 = [
+			10,
+			7,
+			8,
+			4,
+			6,
+			3,
+			5,
+			1
+		];
+		let total$1 = 0;
+		for (let i = 0; i < 8; i++) total$1 += digits[i] * weights$1[i];
+		return total$1 % 11 === 0;
+	}
+	const weights = [
+		1,
+		4,
+		3,
+		7,
+		5,
+		8,
+		6,
+		9,
+		10
+	];
+	let total = 0;
+	for (let i = 0; i < 9; i++) total += digits[i] * weights[i];
+	return total % 11 === 0;
+}
+/** Validate Australian Medicare number using mod-10 weighted checksum. */
+function auMedicareChecksum(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length < 10 || digits.length > 11) return false;
+	const weights = [
+		1,
+		3,
+		7,
+		9,
+		1,
+		3,
+		7,
+		9
+	];
+	let total = 0;
+	for (let i = 0; i < 8; i++) total += parseInt(digits[i], 10) * weights[i];
+	return parseInt(digits[8], 10) === total % 10;
+}
+/** Validate New Zealand IRD using dual-pass mod-11 checksum. */
+function nzIrdChecksum(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length !== 8 && digits.length !== 9) return false;
+	if (digits.length === 8) digits = "0" + digits;
+	const d = digits.split("").map(Number);
+	const weights1 = [
+		3,
+		2,
+		7,
+		6,
+		5,
+		4,
+		3,
+		2
+	];
+	let total = 0;
+	for (let i = 0; i < 8; i++) total += d[i] * weights1[i];
+	const remainder = total % 11;
+	if (remainder === 0) return d[8] === 0;
+	if (11 - remainder !== 10) return d[8] === 11 - remainder;
+	const weights2 = [
+		7,
+		4,
+		3,
+		2,
+		5,
+		2,
+		7,
+		6
+	];
+	total = 0;
+	for (let i = 0; i < 8; i++) total += d[i] * weights2[i];
+	const r2 = total % 11;
+	if (r2 === 0) return d[8] === 0;
+	return d[8] === 11 - r2;
+}
+/** Validate Indian Aadhaar using Verhoeff algorithm. */
+function inAadhaarChecksum(number) {
+	let digits = "";
+	for (const c$1 of number) if (c$1 >= "0" && c$1 <= "9") digits += c$1;
+	if (digits.length !== 12) return false;
+	if (digits[0] === "0" || digits[0] === "1") return false;
+	let c = 0;
+	for (let i = digits.length - 1; i >= 0; i--) c = VERHOEFF_D[c][VERHOEFF_P[(digits.length - 1 - i) % 8][parseInt(digits[i], 10)]];
+	return c === 0;
+}
+/** Validate Indian PAN format: AAAAA0000A. */
+function inPanValid(number) {
+	const cleaned = number.trim().toUpperCase();
+	if (cleaned.length !== 10) return false;
+	return /^[A-Z]{3}[ABCFGHLJPT][A-Z]\d{4}[A-Z]$/.test(cleaned);
+}
+/** Validate Japanese My Number using mod-11 checksum. */
+function jpMyNumberChecksum(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length !== 12) return false;
+	let total = 0;
+	for (let i = 0; i < 11; i++) {
+		const p = 11 - i;
+		const q = p <= 6 ? p + 1 : p - 5;
+		total += parseInt(digits[i], 10) * q;
+	}
+	const remainder = total % 11;
+	const check = remainder <= 1 ? 0 : 11 - remainder;
+	return parseInt(digits[11], 10) === check;
+}
+/** Validate Korean RRN using weighted mod checksum. */
+function krRrnChecksum(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length !== 13) return false;
+	const weights = [
+		2,
+		3,
+		4,
+		5,
+		6,
+		7,
+		8,
+		9,
+		2,
+		3,
+		4,
+		5
+	];
+	let total = 0;
+	for (let i = 0; i < 12; i++) total += parseInt(digits[i], 10) * weights[i];
+	const check = (11 - total % 11) % 10;
+	return parseInt(digits[12], 10) === check;
+}
+/** Validate Turkish Kimlik using custom dual check digit algorithm. */
+function trKimlikChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 11) return false;
+	if (digits[0] === 0) return false;
+	const oddSum = digits[0] + digits[2] + digits[4] + digits[6] + digits[8];
+	const evenSum = digits[1] + digits[3] + digits[5] + digits[7];
+	const check1 = (oddSum * 7 - evenSum) % 10;
+	if (check1 < 0 ? check1 + 10 : check1 !== digits[9]) return false;
+	let total = 0;
+	for (let i = 0; i < 10; i++) total += digits[i];
+	return total % 10 === digits[10];
+}
+/** Validate Argentine CUIT using mod-11 weighted checksum. */
+function arCuitChecksum(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length !== 11) return false;
+	const weights = [
+		5,
+		4,
+		3,
+		2,
+		7,
+		6,
+		5,
+		4,
+		3,
+		2
+	];
+	let total = 0;
+	for (let i = 0; i < 10; i++) total += parseInt(digits[i], 10) * weights[i];
+	const remainder = total % 11;
+	const check = remainder === 0 ? 0 : remainder === 1 ? 9 : 11 - remainder;
+	return parseInt(digits[10], 10) === check;
+}
+/** Validate Chilean RUT using mod-11 checksum with K. */
+function clRutChecksum(number) {
+	let cleaned = number.replace(/[.\s]/g, "").toUpperCase();
+	if (cleaned.includes("-")) {
+		const parts = cleaned.split("-");
+		if (parts.length !== 2) return false;
+		cleaned = parts[0] + parts[1];
+	}
+	if (cleaned.length < 2) return false;
+	const body = cleaned.slice(0, -1);
+	const check = cleaned.slice(-1);
+	if (!/^\d+$/.test(body)) return false;
+	let total = 0;
+	let mul = 2;
+	for (let i = body.length - 1; i >= 0; i--) {
+		total += parseInt(body[i], 10) * mul;
+		mul = mul === 7 ? 2 : mul + 1;
+	}
+	const remainder = 11 - total % 11;
+	let expected;
+	if (remainder === 11) expected = "0";
+	else if (remainder === 10) expected = "K";
+	else expected = String(remainder);
+	return check === expected;
+}
+/** Validate Colombian NIT using mod-11 with prime-based weights. */
+function coNitChecksum(number) {
+	let digits = "";
+	for (const c of number) if (c >= "0" && c <= "9") digits += c;
+	if (digits.length < 8 || digits.length > 10) return false;
+	const body = digits.slice(0, -1);
+	const check = parseInt(digits.slice(-1), 10);
+	const weights = [
+		3,
+		7,
+		13,
+		17,
+		19,
+		23,
+		29,
+		37,
+		41,
+		43,
+		47,
+		53,
+		59,
+		67,
+		71
+	];
+	let total = 0;
+	for (let i = 0; i < body.length; i++) total += parseInt(body[body.length - 1 - i], 10) * weights[i];
+	const remainder = total % 11;
+	const expected = remainder === 0 ? 0 : remainder === 1 ? 1 : 11 - remainder;
+	return check === expected;
+}
+/** Validate NHS number using modulus 11 checksum. */
+function nhsChecksum(number) {
+	const digits = [];
+	for (const c of number) if (c >= "0" && c <= "9") digits.push(parseInt(c, 10));
+	if (digits.length !== 10) return false;
+	const weights = [
+		10,
+		9,
+		8,
+		7,
+		6,
+		5,
+		4,
+		3,
+		2
+	];
+	let total = 0;
+	for (let i = 0; i < 9; i++) total += digits[i] * weights[i];
+	const remainder = total % 11;
+	let checkDigit = 11 - remainder;
+	if (checkDigit === 11) checkDigit = 0;
+	if (checkDigit === 10) return false;
+	return digits[9] === checkDigit;
+}
+var ES_DNI_LETTERS, IT_ODD_TABLE, IT_EVEN_TABLE, VERHOEFF_D, VERHOEFF_P;
+var init_validators = __esm({ "src/regex/validators.ts"() {
+	ES_DNI_LETTERS = "TRWAGMYFPDXBNJZSQVHLCKE";
+	IT_ODD_TABLE = {
+		"0": 1,
+		"1": 0,
+		"2": 5,
+		"3": 7,
+		"4": 9,
+		"5": 13,
+		"6": 15,
+		"7": 17,
+		"8": 19,
+		"9": 21,
+		A: 1,
+		B: 0,
+		C: 5,
+		D: 7,
+		E: 9,
+		F: 13,
+		G: 15,
+		H: 17,
+		I: 19,
+		J: 21,
+		K: 2,
+		L: 4,
+		M: 18,
+		N: 20,
+		O: 11,
+		P: 3,
+		Q: 6,
+		R: 8,
+		S: 12,
+		T: 14,
+		U: 16,
+		V: 10,
+		W: 22,
+		X: 25,
+		Y: 24,
+		Z: 23
+	};
+	IT_EVEN_TABLE = {
+		"0": 0,
+		"1": 1,
+		"2": 2,
+		"3": 3,
+		"4": 4,
+		"5": 5,
+		"6": 6,
+		"7": 7,
+		"8": 8,
+		"9": 9,
+		A: 0,
+		B: 1,
+		C: 2,
+		D: 3,
+		E: 4,
+		F: 5,
+		G: 6,
+		H: 7,
+		I: 8,
+		J: 9,
+		K: 10,
+		L: 11,
+		M: 12,
+		N: 13,
+		O: 14,
+		P: 15,
+		Q: 16,
+		R: 17,
+		S: 18,
+		T: 19,
+		U: 20,
+		V: 21,
+		W: 22,
+		X: 23,
+		Y: 24,
+		Z: 25
+	};
+	VERHOEFF_D = [
+		[
+			0,
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9
+		],
+		[
+			1,
+			2,
+			3,
+			4,
+			0,
+			6,
+			7,
+			8,
+			9,
+			5
+		],
+		[
+			2,
+			3,
+			4,
+			0,
+			1,
+			7,
+			8,
+			9,
+			5,
+			6
+		],
+		[
+			3,
+			4,
+			0,
+			1,
+			2,
+			8,
+			9,
+			5,
+			6,
+			7
+		],
+		[
+			4,
+			0,
+			1,
+			2,
+			3,
+			9,
+			5,
+			6,
+			7,
+			8
+		],
+		[
+			5,
+			9,
+			8,
+			7,
+			6,
+			0,
+			4,
+			3,
+			2,
+			1
+		],
+		[
+			6,
+			5,
+			9,
+			8,
+			7,
+			1,
+			0,
+			4,
+			3,
+			2
+		],
+		[
+			7,
+			6,
+			5,
+			9,
+			8,
+			2,
+			1,
+			0,
+			4,
+			3
+		],
+		[
+			8,
+			7,
+			6,
+			5,
+			9,
+			3,
+			2,
+			1,
+			0,
+			4
+		],
+		[
+			9,
+			8,
+			7,
+			6,
+			5,
+			4,
+			3,
+			2,
+			1,
+			0
+		]
+	];
+	VERHOEFF_P = [
+		[
+			0,
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9
+		],
+		[
+			1,
+			5,
+			7,
+			6,
+			2,
+			8,
+			3,
+			0,
+			9,
+			4
+		],
+		[
+			5,
+			8,
+			0,
+			3,
+			7,
+			9,
+			6,
+			1,
+			4,
+			2
+		],
+		[
+			8,
+			9,
+			1,
+			6,
+			0,
+			4,
+			3,
+			5,
+			2,
+			7
+		],
+		[
+			9,
+			4,
+			5,
+			3,
+			1,
+			2,
+			6,
+			8,
+			7,
+			0
+		],
+		[
+			4,
+			2,
+			8,
+			6,
+			5,
+			7,
+			3,
+			9,
+			0,
+			1
+		],
+		[
+			2,
+			7,
+			9,
+			3,
+			8,
+			0,
+			6,
+			4,
+			1,
+			5
+		],
+		[
+			7,
+			0,
+			4,
+			6,
+			9,
+			1,
+			3,
+			2,
+			5,
+			8
+		]
+	];
+} });
+
+//#endregion
+//#region src/regex/detectors/credit-card.ts
+var CC_KNOWN, CC_GENERIC, CC_CONTEXT, CreditCardDetector;
+var init_credit_card = __esm({ "src/regex/detectors/credit-card.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	CC_KNOWN = new RegExp("\\b(?:4\\d{3}[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}(?:[-\\s]?\\d{3})?|4\\d{12}|5[1-5]\\d{2}[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}|2[2-7]\\d{2}[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}|3[47]\\d{2}[-\\s]?\\d{6}[-\\s]?\\d{5}|6(?:011|5\\d{2})[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}|3(?:0[0-5]|[68]\\d)\\d{11,13}|35(?:2[89]|[3-8]\\d)\\d{12}|62\\d{14,17}|50(?:18|20|38)\\d{8,15}|6(?:304|7(?:59|6[1-3]))\\d{8,15})\\b", "g");
+	CC_GENERIC = /\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{1,7}\b/g;
+	CC_CONTEXT = [
+		"credit card",
+		"card number",
+		"card no",
+		"card #",
+		"cc:",
+		"cc #",
+		"payment card",
+		"debit card",
+		"billing",
+		"card:",
+		"credit",
+		"payment"
+	];
+	CreditCardDetector = class extends Detector {
+		entityType = EntityType.CREDIT_CARD;
+		score = .9;
+		iterMatches(text) {
+			if (!text.match(/\d/)) return [];
+			const results = [];
+			CC_KNOWN.lastIndex = 0;
+			let match;
+			while ((match = CC_KNOWN.exec(text)) !== null) {
+				const matchedText = match[0];
+				if (!luhnChecksum(matchedText)) continue;
+				results.push({
+					entityType: this.entityType,
+					text: matchedText,
+					start: match.index,
+					end: match.index + matchedText.length,
+					score: 1
+				});
+			}
+			CC_GENERIC.lastIndex = 0;
+			while ((match = CC_GENERIC.exec(text)) !== null) {
+				const matchedText = match[0];
+				const start = match.index;
+				if (results.some((r) => r.start <= start && start < r.end)) continue;
+				if (!luhnChecksum(matchedText)) continue;
+				const windowStart = Math.max(0, start - 100);
+				const lower = this._textLower || text.toLowerCase();
+				const window = lower.slice(windowStart, start);
+				if (!CC_CONTEXT.some((kw) => window.includes(kw))) continue;
+				results.push({
+					entityType: this.entityType,
+					text: matchedText,
+					start,
+					end: start + matchedText.length,
+					score: 1
+				});
+			}
+			return results;
+		}
+	};
+	registerUniversal(CreditCardDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/phone.ts
+function phoneLengthCheck(text) {
+	let digits = 0;
+	for (const c of text) if (c >= "0" && c <= "9") digits++;
+	if (digits < 7 || digits > 15) return false;
+	if (DATE_LIKE.test(text)) return false;
+	if (SSN_LIKE.test(text)) return false;
+	return true;
+}
+var DATE_LIKE, SSN_LIKE, PhoneDetector;
+var init_phone = __esm({ "src/regex/detectors/phone.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	DATE_LIKE = /^\d{1,2}[-./]\d{1,2}[-./]\d{2,4}$/;
+	SSN_LIKE = /^\d{3}[-.\s]\d{2}[-.\s]\d{4}$/;
+	PhoneDetector = class extends RegexDetector {
+		entityType = EntityType.PHONE_NUMBER;
+		score = .85;
+		contextKeywords = [
+			"phone",
+			"tel",
+			"telephone",
+			"call",
+			"mobile",
+			"cell",
+			"fax",
+			"contact",
+			"dial",
+			"reach",
+			"ring",
+			"text",
+			"sms",
+			"whatsapp",
+			"number",
+			"ph#",
+			"ph #",
+			"cell#",
+			"cell #"
+		];
+		contextWindow = 80;
+		pattern = new RegExp("(?<!\\d)(?:(?:\\+?1[-.\\s]?)?\\([2-9]\\d{2}\\)[-.\\s]?[2-9]\\d{2}[-.\\s]?\\d{4}|(?:\\+?1[-.\\s]?)?[2-9]\\d{2}[-.\\s][2-9]\\d{2}[-.\\s]?\\d{4}|\\+[1-9]\\d{0,2}[-.\\s]?\\(?\\d{1,4}\\)?[-.\\s]?\\d{1,4}[-.\\s]?\\d{1,9}|0\\d{1,3}[-.\\s]\\d{2,4}[-.\\s]?\\d{2,4}[-.\\s]?\\d{0,4})(?:\\s?(?:x|ext\\.?)\\s?\\d{1,5})?(?!\\d)", "g");
+		validator = phoneLengthCheck;
+	};
+	registerUniversal(PhoneDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/ip-address.ts
+var IPV4, IPV6, IpAddressDetector;
+var init_ip_address = __esm({ "src/regex/detectors/ip-address.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	IPV4 = /\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b/g;
+	IPV6 = new RegExp("\\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\\b|\\b(?:[0-9a-fA-F]{1,4}:){1,7}:\\b|\\b::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}\\b", "g");
+	IpAddressDetector = class IpAddressDetector extends Detector {
+		entityType = EntityType.IP_ADDRESS;
+		score = .95;
+		iterMatches(text) {
+			const results = [];
+			for (const pattern of [IPV4, IPV6]) {
+				pattern.lastIndex = 0;
+				let match;
+				while ((match = pattern.exec(text)) !== null) {
+					const matchedText = match[0];
+					const start = match.index;
+					if (pattern === IPV4 && IpAddressDetector.isVersionNumber(text, start)) continue;
+					results.push({
+						entityType: this.entityType,
+						text: matchedText,
+						start,
+						end: start + matchedText.length,
+						score: this.score
+					});
+				}
+			}
+			return results;
+		}
+		/** Skip patterns preceded by 'v' or 'version' that look like version numbers. */
+		static isVersionNumber(text, start) {
+			if (start > 0 && text[start - 1].toLowerCase() === "v") return true;
+			const prefix = text.slice(Math.max(0, start - 10), start).toLowerCase().trim();
+			return prefix.endsWith("version");
+		}
+	};
+	registerUniversal(IpAddressDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/url.ts
+function urlValidTld(text) {
+	try {
+		const afterScheme = text.split("://", 2)[1];
+		if (!afterScheme) return false;
+		const domain = afterScheme.split("/")[0].split("?")[0].split("#")[0];
+		const parts = domain.replace(/\.$/, "").split(".");
+		if (parts.length < 2) return false;
+		const tld = parts[parts.length - 1].toLowerCase();
+		return VALID_TLDS.has(tld);
+	} catch {
+		return false;
+	}
+}
+var VALID_TLDS, UrlDetector;
+var init_url = __esm({ "src/regex/detectors/url.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	VALID_TLDS = new Set([
+		"com",
+		"org",
+		"net",
+		"edu",
+		"gov",
+		"mil",
+		"int",
+		"io",
+		"co",
+		"dev",
+		"app",
+		"ai",
+		"me",
+		"us",
+		"uk",
+		"de",
+		"fr",
+		"it",
+		"es",
+		"nl",
+		"be",
+		"at",
+		"ch",
+		"se",
+		"no",
+		"dk",
+		"fi",
+		"pl",
+		"cz",
+		"sk",
+		"pt",
+		"ru",
+		"br",
+		"jp",
+		"kr",
+		"cn",
+		"in",
+		"au",
+		"nz",
+		"za",
+		"ca",
+		"mx",
+		"ar",
+		"cl",
+		"il",
+		"tr",
+		"ie",
+		"hu",
+		"ro",
+		"bg",
+		"hr",
+		"si",
+		"lt",
+		"lv",
+		"ee",
+		"info",
+		"biz",
+		"name",
+		"pro",
+		"xyz",
+		"online",
+		"site",
+		"tech",
+		"store",
+		"shop",
+		"cloud",
+		"page",
+		"link",
+		"top",
+		"icu",
+		"live",
+		"world",
+		"blog",
+		"news",
+		"tv",
+		"cc",
+		"ly",
+		"gg",
+		"to",
+		"eu",
+		"asia"
+	]);
+	UrlDetector = class extends RegexDetector {
+		entityType = EntityType.URL;
+		score = .85;
+		needsDigit = false;
+		pattern = /https?:\/\/(?:[\w\-]+\.)+[a-zA-Z]{2,}(?:\/[^\s<>"')\]]*)?/gi;
+		validator = urlValidTld;
+		preCheck(text) {
+			return text.includes("://");
+		}
+	};
+	registerUniversal(UrlDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/mac-address.ts
+var MacAddressDetector;
+var init_mac_address = __esm({ "src/regex/detectors/mac-address.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	MacAddressDetector = class extends RegexDetector {
+		entityType = EntityType.MAC_ADDRESS;
+		score = .95;
+		pattern = /\b(?:[0-9A-Fa-f]{2}[:\-]){5}[0-9A-Fa-f]{2}\b/g;
+	};
+	registerUniversal(MacAddressDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/date-of-birth.ts
+function validDate(text) {
+	if (/[a-zA-Z]/i.test(text.replace(/T/g, ""))) return true;
+	const groups = text.match(/\d+/g);
+	return groups !== null && groups.length >= 3;
+}
+var MONTHS, DateOfBirthDetector;
+var init_date_of_birth = __esm({ "src/regex/detectors/date-of-birth.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	MONTHS = "(?:january|february|march|april|may|june|july|august|september|october|november|december|jan|feb|mar|apr|jun|jul|aug|sep|oct|nov|dec)";
+	DateOfBirthDetector = class extends RegexDetector {
+		entityType = EntityType.DATE_OF_BIRTH;
+		score = .75;
+		contextKeywords = [
+			"born",
+			"dob",
+			"date of birth",
+			"birthday",
+			"birthdate",
+			"d.o.b",
+			"birth date",
+			"birth",
+			"b-day",
+			"bday",
+			"age",
+			"d/o/b",
+			"born on",
+			"date de naissance",
+			"geburtsdatum",
+			"fecha de nacimiento",
+			"geboortedatum",
+			"data di nascita"
+		];
+		contextRequired = true;
+		contextWindow = 100;
+		validator = validDate;
+		pattern = new RegExp(
+			// MM/DD/YYYY (4-digit year, month 1-12)
+			"\\b(?:0?[1-9]|1[0-2])[/\\-.](?:0?[1-9]|[12]\\d|3[01])[/\\-.](?:19|20)\\d{2}\\b|\\b(?:1[3-9]|2\\d|3[01])[/\\-.](?:0?[1-9]|1[0-2])[/\\-.](?:19|20)\\d{2}\\b|\\b(?:0?[1-9]|1[0-2])[/\\-.](?:0?[1-9]|[12]\\d|3[01])[/\\-.]\\d{2}\\b|\\b(?:1[3-9]|2\\d|3[01])[/\\-.](?:0?[1-9]|1[0-2])[/\\-.]\\d{2}\\b|\\b(?:19|20)\\d{2}[/\\-.](?:0?[1-9]|1[0-2])[/\\-.](?:0?[1-9]|[12]\\d|3[01])(?:T\\d{2}:\\d{2}:\\d{2})?\\b|\\b" + MONTHS + "\\s+\\d{1,2}(?:st|nd|rd|th)?,?\\s+(?:19|20)\\d{2}\\b|\\b\\d{1,2}(?:st|nd|rd|th)?\\s+" + MONTHS + ",?\\s+(?:19|20)\\d{2}\\b|\\b" + MONTHS + "[/\\-.]\\d{2}\\b",
+			"gi"
+);
+	};
+	registerUniversal(DateOfBirthDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/cvv.ts
+var CvvDetector;
+var init_cvv = __esm({ "src/regex/detectors/cvv.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	CvvDetector = class extends RegexDetector {
+		entityType = EntityType.CVV;
+		score = .8;
+		contextKeywords = [
+			"cvv",
+			"cvc",
+			"security code",
+			"card verification",
+			"cvv2",
+			"cvc2",
+			"csv"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b\d{3,4}\b/g;
+	};
+	registerUniversal(CvvDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/us/ssn.ts
+var SSN_WITH_SEP, SSN_NO_SEP, SsnDetector;
+var init_ssn = __esm({ "src/regex/detectors/us/ssn.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	SSN_WITH_SEP = new RegExp("\\b(?!000|666|9\\d{2})\\d{3}[-.\\s](?!00)\\d{2}[-.\\s](?!0000)\\d{4}\\b", "g");
+	SSN_NO_SEP = new RegExp("\\b(?!000|666|9\\d{2})\\d{3}(?!00)\\d{2}(?!0000)\\d{4}\\b", "g");
+	SsnDetector = class extends Detector {
+		entityType = EntityType.SSN;
+		score = .85;
+		contextKeywords = [
+			"ssn",
+			"social security",
+			"social sec",
+			"ss#",
+			"ss #",
+			"social",
+			"tax id",
+			"taxpayer",
+			"tin",
+			"social number",
+			"soc number",
+			"socialnum"
+		];
+		contextRequired = false;
+		contextWindow = 100;
+		iterMatches(text) {
+			const results = [];
+			SSN_WITH_SEP.lastIndex = 0;
+			let match;
+			while ((match = SSN_WITH_SEP.exec(text)) !== null) {
+				const matchedText = match[0];
+				if (!ssnValidFormat(matchedText)) continue;
+				const start = match.index;
+				const end = start + matchedText.length;
+				const hasCtx = this.hasContext(text, start, end);
+				results.push({
+					entityType: this.entityType,
+					text: matchedText,
+					start,
+					end,
+					score: hasCtx ? 1 : this.score
+				});
+			}
+			SSN_NO_SEP.lastIndex = 0;
+			while ((match = SSN_NO_SEP.exec(text)) !== null) {
+				const matchedText = match[0];
+				const start = match.index;
+				const end = start + matchedText.length;
+				if (results.some((r) => r.start <= start && start < r.end)) continue;
+				if (!ssnValidFormat(matchedText)) continue;
+				if (!this.hasContext(text, start, end)) continue;
+				results.push({
+					entityType: this.entityType,
+					text: matchedText,
+					start,
+					end,
+					score: 1
+				});
+			}
+			return results;
+		}
+	};
+	registerRegion("us", SsnDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/us/drivers-license.ts
+var DriversLicenseDetector;
+var init_drivers_license = __esm({ "src/regex/detectors/us/drivers-license.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	DriversLicenseDetector = class extends RegexDetector {
+		entityType = EntityType.DRIVERS_LICENSE;
+		score = .75;
+		contextKeywords = [
+			"driver",
+			"license",
+			"licence",
+			"dl",
+			"driver's license",
+			"driving license",
+			"dl#",
+			"dl #",
+			"dmv",
+			"permit"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = new RegExp("\\b(?:[A-Z]\\d{14}|[A-Z]\\d{13}|[A-Z]\\d{12}|[A-Z]\\d{11}|[A-Z]\\d{10}|[A-Z]\\d{8}|[A-Z]{2}\\d{6}|[A-Z]\\d{7}|\\d{9}|\\d{8})\\b", "g");
+	};
+	registerRegion("us", DriversLicenseDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/us/passport.ts
+var UsPassportDetector;
+var init_passport$1 = __esm({ "src/regex/detectors/us/passport.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	UsPassportDetector = class extends RegexDetector {
+		entityType = EntityType.US_PASSPORT;
+		score = .75;
+		contextKeywords = [
+			"passport",
+			"passport#",
+			"passport #",
+			"passport number",
+			"passport no"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b\d{9}\b/g;
+	};
+	registerRegion("us", UsPassportDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/us/tax-id.ts
+var TaxIdDetector;
+var init_tax_id$2 = __esm({ "src/regex/detectors/us/tax-id.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	TaxIdDetector = class extends RegexDetector {
+		entityType = EntityType.TAX_ID;
+		score = .8;
+		contextKeywords = [
+			"ein",
+			"tax id",
+			"tax identification",
+			"employer identification",
+			"tin",
+			"tax #",
+			"ein#"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b\d{2}-\d{7}\b/g;
+	};
+	registerRegion("us", TaxIdDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/us/zip-code.ts
+function zipValid(text) {
+	let digits = "";
+	for (const c of text) if (c >= "0" && c <= "9") digits += c;
+	return !digits.startsWith("000");
+}
+var ZipCodeDetector;
+var init_zip_code = __esm({ "src/regex/detectors/us/zip-code.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	ZipCodeDetector = class extends RegexDetector {
+		entityType = EntityType.ZIP_CODE;
+		score = .7;
+		contextKeywords = [
+			"zip",
+			"postal",
+			"zip code",
+			"zipcode",
+			"postal code",
+			"address",
+			"city",
+			"state",
+			"mailing",
+			"shipping",
+			"billing",
+			"delivery",
+			"location",
+			"resident",
+			"zip+4",
+			"usa",
+			"united states"
+		];
+		contextRequired = true;
+		contextWindow = 150;
+		pattern = /\b\d{5}(?:-\d{4})?\b/g;
+		validator = zipValid;
+	};
+	registerRegion("us", ZipCodeDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/us/itin.ts
+var UsItinDetector;
+var init_itin = __esm({ "src/regex/detectors/us/itin.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	UsItinDetector = class extends RegexDetector {
+		entityType = EntityType.US_ITIN;
+		score = .85;
+		contextKeywords = [
+			"itin",
+			"individual taxpayer",
+			"tax identification"
+		];
+		contextRequired = true;
+		pattern = /\b9\d{2}[- ]?\d{2}[- ]?\d{4}\b/g;
+		validator = usItinValid;
+	};
+	registerRegion("us", UsItinDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/us/index.ts
+var init_us = __esm({ "src/regex/detectors/us/index.ts"() {
+	init_ssn();
+	init_drivers_license();
+	init_passport$1();
+	init_tax_id$2();
+	init_zip_code();
+	init_itin();
+} });
+
+//#endregion
+//#region src/regex/detectors/eu/iban.ts
+var IbanDetector;
+var init_iban = __esm({ "src/regex/detectors/eu/iban.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	IbanDetector = class extends RegexDetector {
+		entityType = EntityType.IBAN;
+		score = .9;
+		pattern = /\b[A-Z]{2}\d{2}\s?[\dA-Z]{4}(?:\s?[\dA-Z]{4}){1,7}(?:\s?[\dA-Z]{1,4})?\b/g;
+		validator = ibanMod97;
+	};
+	registerRegion("eu", IbanDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/eu/postal-code.ts
+var EuPostalCodeDetector;
+var init_postal_code = __esm({ "src/regex/detectors/eu/postal-code.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	EuPostalCodeDetector = class extends RegexDetector {
+		entityType = EntityType.EU_POSTAL_CODE;
+		score = .7;
+		contextKeywords = [
+			"postal",
+			"postcode",
+			"post code",
+			"zip",
+			"plz",
+			"postleitzahl",
+			"code postal"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = new RegExp("\\b(?:\\d{5}|\\d{4}\\s?[A-Z]{2})\\b", "g");
+	};
+	registerRegion("eu", EuPostalCodeDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/eu/vat-id.ts
+var VatIdDetector;
+var init_vat_id = __esm({ "src/regex/detectors/eu/vat-id.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	VatIdDetector = class extends RegexDetector {
+		entityType = EntityType.VAT_ID;
+		score = .9;
+		pattern = new RegExp("\\b(?:ATU\\d{8}|BE[01]\\d{9}|DE\\d{9}|DK\\d{8}|ES[A-Z0-9]\\d{7}[A-Z0-9]|FI\\d{8}|FR[A-Z0-9]{2}\\d{9}|IT\\d{11}|LU\\d{8}|NL\\d{9}B\\d{2}|PL\\d{10}|PT\\d{9}|SE\\d{12})\\b", "g");
+	};
+	registerRegion("eu", VatIdDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/eu/index.ts
+var init_eu = __esm({ "src/regex/detectors/eu/index.ts"() {
+	init_iban();
+	init_postal_code();
+	init_vat_id();
+} });
+
+//#endregion
+//#region src/regex/detectors/uk/ni-number.ts
+var NiNumberDetector;
+var init_ni_number = __esm({ "src/regex/detectors/uk/ni-number.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	NiNumberDetector = class extends RegexDetector {
+		entityType = EntityType.NI_NUMBER;
+		score = .9;
+		pattern = new RegExp("\\b(?!BG)(?!GB)(?!NK)(?!KN)(?!TN)(?!NT)(?!ZZ)[A-CEGHJ-PR-TW-Z][A-CEGHJ-NPR-TW-Z]\\s?\\d{2}\\s?\\d{2}\\s?\\d{2}\\s?[A-D]\\b", "gi");
+	};
+	registerRegion("uk", NiNumberDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/uk/nhs-number.ts
+var NhsNumberDetector;
+var init_nhs_number = __esm({ "src/regex/detectors/uk/nhs-number.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	NhsNumberDetector = class extends RegexDetector {
+		entityType = EntityType.NHS_NUMBER;
+		score = .85;
+		contextKeywords = [
+			"nhs",
+			"national health",
+			"nhs number",
+			"nhs#"
+		];
+		contextRequired = false;
+		contextWindow = 50;
+		pattern = /\b\d{3}\s?\d{3}\s?\d{4}\b/g;
+		validator = nhsChecksum;
+	};
+	registerRegion("uk", NhsNumberDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/uk/postcode.ts
+var UkPostcodeDetector;
+var init_postcode = __esm({ "src/regex/detectors/uk/postcode.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	UkPostcodeDetector = class extends RegexDetector {
+		entityType = EntityType.UK_POSTCODE;
+		score = .85;
+		pattern = new RegExp("\\b(?:[A-Z]{1,2}\\d[A-Z\\d]?\\s?\\d[A-Z]{2})\\b", "gi");
+	};
+	registerRegion("uk", UkPostcodeDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/uk/passport.ts
+var UkPassportDetector;
+var init_passport = __esm({ "src/regex/detectors/uk/passport.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	UkPassportDetector = class extends RegexDetector {
+		entityType = EntityType.UK_PASSPORT;
+		score = .75;
+		contextKeywords = [
+			"passport",
+			"passport#",
+			"passport #",
+			"passport number",
+			"passport no"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b\d{9}\b/g;
+	};
+	registerRegion("uk", UkPassportDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/uk/utr.ts
+var UkUtrDetector;
+var init_utr = __esm({ "src/regex/detectors/uk/utr.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	UkUtrDetector = class extends RegexDetector {
+		entityType = EntityType.UK_UTR;
+		score = .85;
+		contextKeywords = [
+			"utr",
+			"unique taxpayer",
+			"tax reference",
+			"self assessment",
+			"hmrc"
+		];
+		contextRequired = true;
+		pattern = /\b\d{10}\b/g;
+		validator = ukUtrChecksum;
+	};
+	registerRegion("uk", UkUtrDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/uk/index.ts
+var init_uk = __esm({ "src/regex/detectors/uk/index.ts"() {
+	init_ni_number();
+	init_nhs_number();
+	init_postcode();
+	init_passport();
+	init_utr();
+} });
+
+//#endregion
+//#region src/regex/detectors/de/personal-id.ts
+var DePersonalIdDetector;
+var init_personal_id = __esm({ "src/regex/detectors/de/personal-id.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	DePersonalIdDetector = class extends RegexDetector {
+		entityType = EntityType.DE_PERSONAL_ID;
+		score = .75;
+		contextKeywords = [
+			"personalausweis",
+			"personal id",
+			"ausweis",
+			"identifikation",
+			"id-nummer",
+			"ausweisnummer"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b[CFGHJKLMNPRTVWXYZ][0-9A-Z][0-9]{7}[0-9]\b/gi;
+	};
+	registerRegion("de", DePersonalIdDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/de/tax-id.ts
+var DeTaxIdDetector;
+var init_tax_id$1 = __esm({ "src/regex/detectors/de/tax-id.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	DeTaxIdDetector = class extends RegexDetector {
+		entityType = EntityType.DE_TAX_ID;
+		score = .85;
+		contextKeywords = [
+			"steuer",
+			"tax id",
+			"steueridentifikationsnummer",
+			"tin",
+			"identifikationsnummer",
+			"steuernummer"
+		];
+		contextRequired = false;
+		pattern = /\b\d{2}\s?\d{3}\s?\d{3}\s?\d{3}\b/g;
+		validator = deTaxIdChecksum;
+	};
+	registerRegion("de", DeTaxIdDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/de/index.ts
+var init_de = __esm({ "src/regex/detectors/de/index.ts"() {
+	init_personal_id();
+	init_tax_id$1();
+} });
+
+//#endregion
+//#region src/regex/detectors/fr/national-id.ts
+var FrNationalIdDetector;
+var init_national_id = __esm({ "src/regex/detectors/fr/national-id.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	FrNationalIdDetector = class extends RegexDetector {
+		entityType = EntityType.FR_NATIONAL_ID;
+		score = .9;
+		contextKeywords = [
+			"nir",
+			"securite sociale",
+			"social security",
+			"numero national",
+			"insee"
+		];
+		contextRequired = false;
+		pattern = /\b[12]\s?\d{2}\s?(?:0[1-9]|1[0-2]|[2-9]\d)\s?\d{2,3}\s?\d{3}\s?\d{3}\s?\d{2}\b/g;
+		validator = frNirChecksum;
+	};
+	registerRegion("fr", FrNationalIdDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/fr/siren.ts
+var FrSirenDetector;
+var init_siren = __esm({ "src/regex/detectors/fr/siren.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	FrSirenDetector = class extends RegexDetector {
+		entityType = EntityType.FR_SIREN;
+		score = .85;
+		contextKeywords = [
+			"siren",
+			"siret",
+			"registre du commerce",
+			"rcs",
+			"company number"
+		];
+		contextRequired = true;
+		pattern = /\b\d{3}[- ]?\d{3}[- ]?\d{3}\b/g;
+		validator = luhnChecksum;
+	};
+	registerRegion("fr", FrSirenDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/fr/index.ts
+var init_fr = __esm({ "src/regex/detectors/fr/index.ts"() {
+	init_national_id();
+	init_siren();
+} });
+
+//#endregion
+//#region src/regex/detectors/es/dni.ts
+var EsDniDetector;
+var init_dni = __esm({ "src/regex/detectors/es/dni.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	EsDniDetector = class extends RegexDetector {
+		entityType = EntityType.ES_DNI;
+		score = .9;
+		contextKeywords = [
+			"dni",
+			"documento nacional",
+			"identidad"
+		];
+		contextRequired = false;
+		pattern = /\b\d{8}[-\s]?[A-Z]\b/gi;
+		validator = esDniLetter;
+	};
+	registerRegion("es", EsDniDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/es/nie.ts
+var EsNieDetector;
+var init_nie = __esm({ "src/regex/detectors/es/nie.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	EsNieDetector = class extends RegexDetector {
+		entityType = EntityType.ES_NIE;
+		score = .9;
+		contextKeywords = [
+			"nie",
+			"extranjero",
+			"numero de identidad"
+		];
+		contextRequired = false;
+		pattern = /\b[XYZ]\d{7}[-\s]?[A-Z]\b/gi;
+		validator = esNieLetter;
+	};
+	registerRegion("es", EsNieDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/es/nss.ts
+var EsNssDetector;
+var init_nss = __esm({ "src/regex/detectors/es/nss.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	EsNssDetector = class extends RegexDetector {
+		entityType = EntityType.ES_NSS;
+		score = .85;
+		contextKeywords = [
+			"nss",
+			"numero seguridad social",
+			"seguridad social",
+			"social security"
+		];
+		contextRequired = true;
+		pattern = /\b\d{2}[- ]?\d{8}[- ]?\d{2}\b/g;
+		validator = esNssChecksum;
+	};
+	registerRegion("es", EsNssDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/es/cif.ts
+var EsCifDetector;
+var init_cif = __esm({ "src/regex/detectors/es/cif.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	EsCifDetector = class extends RegexDetector {
+		entityType = EntityType.ES_CIF;
+		score = .85;
+		contextKeywords = [
+			"cif",
+			"codigo de identificacion fiscal",
+			"tax id",
+			"nif empresa"
+		];
+		contextRequired = false;
+		pattern = /\b[A-HJ-NP-SUVW]\d{7}[0-9A-J]\b/gi;
+		validator = esCifChecksum;
+	};
+	registerRegion("es", EsCifDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/es/index.ts
+var init_es = __esm({ "src/regex/detectors/es/index.ts"() {
+	init_dni();
+	init_nie();
+	init_nss();
+	init_cif();
+} });
+
+//#endregion
+//#region src/regex/detectors/it/codice-fiscale.ts
+var ItCodiceFiscaleDetector;
+var init_codice_fiscale = __esm({ "src/regex/detectors/it/codice-fiscale.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	ItCodiceFiscaleDetector = class extends RegexDetector {
+		entityType = EntityType.IT_CODICE_FISCALE;
+		score = .9;
+		contextKeywords = [
+			"codice fiscale",
+			"cf",
+			"fiscal code"
+		];
+		contextRequired = false;
+		pattern = /\b[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]\b/gi;
+		validator = itCodiceFiscaleCheck;
+	};
+	registerRegion("it", ItCodiceFiscaleDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/it/partita-iva.ts
+var ItPartitaIvaDetector;
+var init_partita_iva = __esm({ "src/regex/detectors/it/partita-iva.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	ItPartitaIvaDetector = class extends RegexDetector {
+		entityType = EntityType.IT_PARTITA_IVA;
+		score = .85;
+		contextKeywords = [
+			"partita iva",
+			"p.iva",
+			"p. iva",
+			"vat",
+			"iva"
+		];
+		contextRequired = true;
+		pattern = /\b(?:IT)?\d{11}\b/gi;
+		validator = itPartitaIvaChecksum;
+	};
+	registerRegion("it", ItPartitaIvaDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/it/index.ts
+var init_it = __esm({ "src/regex/detectors/it/index.ts"() {
+	init_codice_fiscale();
+	init_partita_iva();
+} });
+
+//#endregion
+//#region src/regex/detectors/pt/nif.ts
+var PtNifDetector;
+var init_nif = __esm({ "src/regex/detectors/pt/nif.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	PtNifDetector = class extends RegexDetector {
+		entityType = EntityType.PT_NIF;
+		score = .85;
+		contextKeywords = [
+			"nif",
+			"contribuinte",
+			"fiscal",
+			"tax"
+		];
+		contextRequired = true;
+		pattern = /\b[1-3589]\d{8}\b/g;
+		validator = ptNifChecksum;
+	};
+	registerRegion("pt", PtNifDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/pt/index.ts
+var init_pt = __esm({ "src/regex/detectors/pt/index.ts"() {
+	init_nif();
+} });
+
+//#endregion
+//#region src/regex/detectors/pl/pesel.ts
+var PlPeselDetector;
+var init_pesel = __esm({ "src/regex/detectors/pl/pesel.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	PlPeselDetector = class extends RegexDetector {
+		entityType = EntityType.PL_PESEL;
+		score = .85;
+		contextKeywords = ["pesel"];
+		contextRequired = false;
+		pattern = /\b\d{11}\b/g;
+		validator = plPeselChecksum;
+	};
+	registerRegion("pl", PlPeselDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/pl/nip.ts
+var PlNipDetector;
+var init_nip = __esm({ "src/regex/detectors/pl/nip.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	PlNipDetector = class extends RegexDetector {
+		entityType = EntityType.PL_NIP;
+		score = .85;
+		contextKeywords = [
+			"nip",
+			"tax",
+			"podatkowy"
+		];
+		contextRequired = true;
+		pattern = /\b\d{3}[-\s]?\d{3}[-\s]?\d{2}[-\s]?\d{2}\b/g;
+		validator = plNipChecksum;
+	};
+	registerRegion("pl", PlNipDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/pl/regon.ts
+var PlRegonDetector;
+var init_regon = __esm({ "src/regex/detectors/pl/regon.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	PlRegonDetector = class extends RegexDetector {
+		entityType = EntityType.PL_REGON;
+		score = .85;
+		contextKeywords = [
+			"regon",
+			"statistical number",
+			"numer statystyczny"
+		];
+		contextRequired = true;
+		pattern = /\b\d{9}(?:\d{5})?\b/g;
+		validator = plRegonChecksum;
+	};
+	registerRegion("pl", PlRegonDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/pl/index.ts
+var init_pl = __esm({ "src/regex/detectors/pl/index.ts"() {
+	init_pesel();
+	init_nip();
+	init_regon();
+} });
+
+//#endregion
+//#region src/regex/detectors/cz/birth-number.ts
+var CzBirthNumberDetector;
+var init_birth_number$2 = __esm({ "src/regex/detectors/cz/birth-number.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	CzBirthNumberDetector = class extends RegexDetector {
+		entityType = EntityType.CZ_BIRTH_NUMBER;
+		score = .85;
+		contextKeywords = [
+			"rodne cislo",
+			"birth number",
+			"rc",
+			"rodné číslo"
+		];
+		contextRequired = false;
+		pattern = /\b\d{6}\/?\d{3,4}\b/g;
+		validator = czBirthNumberValid;
+	};
+	registerRegion("cz", CzBirthNumberDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/cz/ico.ts
+var CzIcoDetector;
+var init_ico$1 = __esm({ "src/regex/detectors/cz/ico.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	CzIcoDetector = class extends RegexDetector {
+		entityType = EntityType.CZ_ICO;
+		score = .85;
+		contextKeywords = [
+			"ico",
+			"ičo",
+			"identifikacni cislo",
+			"identifikační číslo",
+			"company id",
+			"business id"
+		];
+		contextRequired = true;
+		pattern = /\b\d{8}\b/g;
+		validator = czIcoChecksum;
+	};
+	registerRegion("cz", CzIcoDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/cz/dic.ts
+var CzDicDetector;
+var init_dic$1 = __esm({ "src/regex/detectors/cz/dic.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	CzDicDetector = class extends RegexDetector {
+		entityType = EntityType.CZ_DIC;
+		score = .85;
+		contextKeywords = [
+			"dic",
+			"dič",
+			"danove identifikacni cislo",
+			"daňové identifikační číslo",
+			"vat",
+			"tax id"
+		];
+		contextRequired = false;
+		pattern = /\bCZ\d{8,10}\b/gi;
+		validator = czDicValid;
+	};
+	registerRegion("cz", CzDicDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/cz/bank-account.ts
+var CzBankAccountDetector;
+var init_bank_account = __esm({ "src/regex/detectors/cz/bank-account.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	CzBankAccountDetector = class extends RegexDetector {
+		entityType = EntityType.CZ_BANK_ACCOUNT;
+		score = .85;
+		contextKeywords = [
+			"ucet",
+			"účet",
+			"cislo uctu",
+			"číslo účtu",
+			"bank account",
+			"bankovni",
+			"bankovní"
+		];
+		contextRequired = false;
+		pattern = /\b(?:\d{1,6}-)?\d{2,10}\/\d{4}\b/g;
+		validator = czBankAccountValid;
+	};
+	registerRegion("cz", CzBankAccountDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/cz/index.ts
+var init_cz = __esm({ "src/regex/detectors/cz/index.ts"() {
+	init_birth_number$2();
+	init_ico$1();
+	init_dic$1();
+	init_bank_account();
+} });
+
+//#endregion
+//#region src/regex/detectors/ru/inn.ts
+var RuInnDetector;
+var init_inn = __esm({ "src/regex/detectors/ru/inn.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	RuInnDetector = class extends RegexDetector {
+		entityType = EntityType.RU_INN;
+		score = .85;
+		contextKeywords = [
+			"inn",
+			"инн",
+			"taxpayer",
+			"налог"
+		];
+		contextRequired = true;
+		pattern = /\b\d{10}\b|\b\d{12}\b/g;
+		validator = ruInnChecksum;
+	};
+	registerRegion("ru", RuInnDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/ru/snils.ts
+var RuSnilsDetector;
+var init_snils = __esm({ "src/regex/detectors/ru/snils.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	RuSnilsDetector = class extends RegexDetector {
+		entityType = EntityType.RU_SNILS;
+		score = .85;
+		contextKeywords = [
+			"snils",
+			"снилс",
+			"pension",
+			"пенсион",
+			"страховое свидетельство"
+		];
+		contextRequired = true;
+		pattern = /\b\d{3}[-\s]?\d{3}[-\s]?\d{3}[-\s]?\d{2}\b/g;
+		validator = ruSnilsChecksum;
+	};
+	registerRegion("ru", RuSnilsDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/ru/index.ts
+var init_ru = __esm({ "src/regex/detectors/ru/index.ts"() {
+	init_inn();
+	init_snils();
+} });
+
+//#endregion
+//#region src/regex/detectors/nl/bsn.ts
+var NlBsnDetector;
+var init_bsn = __esm({ "src/regex/detectors/nl/bsn.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	NlBsnDetector = class extends RegexDetector {
+		entityType = EntityType.NL_BSN;
+		score = .85;
+		contextKeywords = [
+			"bsn",
+			"burgerservicenummer",
+			"sofi",
+			"citizen service"
+		];
+		contextRequired = true;
+		pattern = /\b\d{9}\b/g;
+		validator = nlBsn11test;
+	};
+	registerRegion("nl", NlBsnDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/nl/index.ts
+var init_nl = __esm({ "src/regex/detectors/nl/index.ts"() {
+	init_bsn();
+} });
+
+//#endregion
+//#region src/regex/detectors/ro/cnp.ts
+var RoCnpDetector;
+var init_cnp = __esm({ "src/regex/detectors/ro/cnp.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	RoCnpDetector = class extends RegexDetector {
+		entityType = EntityType.RO_CNP;
+		score = .9;
+		contextKeywords = [
+			"cnp",
+			"cod numeric personal",
+			"personal numeric code"
+		];
+		contextRequired = false;
+		pattern = /\b[1-8]\d{12}\b/g;
+		validator = roCnpChecksum;
+	};
+	registerRegion("ro", RoCnpDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/ro/cui.ts
+var RoCuiDetector;
+var init_cui = __esm({ "src/regex/detectors/ro/cui.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	RoCuiDetector = class extends RegexDetector {
+		entityType = EntityType.RO_CUI;
+		score = .85;
+		contextKeywords = [
+			"cui",
+			"cod unic",
+			"cod de inregistrare",
+			"fiscal code",
+			"cif"
+		];
+		contextRequired = true;
+		pattern = /\b(?:RO)?\d{2,10}\b/gi;
+		validator = roCuiChecksum;
+	};
+	registerRegion("ro", RoCuiDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/ro/index.ts
+var init_ro = __esm({ "src/regex/detectors/ro/index.ts"() {
+	init_cnp();
+	init_cui();
+} });
+
+//#endregion
+//#region src/regex/detectors/sk/birth-number.ts
+var SkBirthNumberDetector;
+var init_birth_number$1 = __esm({ "src/regex/detectors/sk/birth-number.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	SkBirthNumberDetector = class extends RegexDetector {
+		entityType = EntityType.SK_BIRTH_NUMBER;
+		score = .85;
+		contextKeywords = [
+			"rodne cislo",
+			"birth number",
+			"rc",
+			"rodné číslo"
+		];
+		contextRequired = false;
+		pattern = /\b\d{6}\/?\d{3,4}\b/g;
+		validator = skBirthNumberValid;
+	};
+	registerRegion("sk", SkBirthNumberDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/sk/ico.ts
+var SkIcoDetector;
+var init_ico = __esm({ "src/regex/detectors/sk/ico.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	SkIcoDetector = class extends RegexDetector {
+		entityType = EntityType.SK_ICO;
+		score = .85;
+		contextKeywords = [
+			"ico",
+			"ičo",
+			"identifikacne cislo",
+			"identifikačné číslo",
+			"company id",
+			"business id"
+		];
+		contextRequired = true;
+		pattern = /\b\d{8}\b/g;
+		validator = skIcoChecksum;
+	};
+	registerRegion("sk", SkIcoDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/sk/dic.ts
+var SkDicDetector;
+var init_dic = __esm({ "src/regex/detectors/sk/dic.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	SkDicDetector = class extends RegexDetector {
+		entityType = EntityType.SK_DIC;
+		score = .85;
+		contextKeywords = [
+			"dic",
+			"dič",
+			"danove identifikacne cislo",
+			"daňové identifikačné číslo",
+			"vat",
+			"tax id"
+		];
+		contextRequired = false;
+		pattern = /\bSK\d{10}\b/gi;
+		validator = skDicValid;
+	};
+	registerRegion("sk", SkDicDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/sk/index.ts
+var init_sk = __esm({ "src/regex/detectors/sk/index.ts"() {
+	init_birth_number$1();
+	init_ico();
+	init_dic();
+} });
+
+//#endregion
+//#region src/regex/detectors/dk/cpr.ts
+var DkCprDetector;
+var init_cpr = __esm({ "src/regex/detectors/dk/cpr.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	DkCprDetector = class extends RegexDetector {
+		entityType = EntityType.DK_CPR;
+		score = .85;
+		contextKeywords = [
+			"cpr",
+			"personnummer",
+			"cpr-nummer",
+			"central person"
+		];
+		contextRequired = true;
+		pattern = /\b(?:0[1-9]|[12]\d|3[01])(?:0[1-9]|1[0-2])\d{2}[-\s]?\d{4}\b/g;
+		validator = dkCprValidDate;
+	};
+	registerRegion("dk", DkCprDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/dk/cvr.ts
+var DkCvrDetector;
+var init_cvr = __esm({ "src/regex/detectors/dk/cvr.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	DkCvrDetector = class extends RegexDetector {
+		entityType = EntityType.DK_CVR;
+		score = .85;
+		contextKeywords = [
+			"cvr",
+			"virksomhed",
+			"erhvervsstyrelsen",
+			"company number",
+			"business id"
+		];
+		contextRequired = true;
+		pattern = /\b(?:DK)?\d{8}\b/gi;
+		validator = dkCvrChecksum;
+	};
+	registerRegion("dk", DkCvrDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/dk/index.ts
+var init_dk = __esm({ "src/regex/detectors/dk/index.ts"() {
+	init_cpr();
+	init_cvr();
+} });
+
+//#endregion
+//#region src/regex/detectors/se/personnummer.ts
+var SePersonnummerDetector;
+var init_personnummer = __esm({ "src/regex/detectors/se/personnummer.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	SePersonnummerDetector = class extends RegexDetector {
+		entityType = EntityType.SE_PERSONNUMMER;
+		score = .9;
+		contextKeywords = [
+			"personnummer",
+			"personal number",
+			"pnr"
+		];
+		contextRequired = false;
+		pattern = /\b(?:\d{8}|\d{6})[-+]?\d{4}\b/g;
+		validator = sePersonnummerLuhn;
+	};
+	registerRegion("se", SePersonnummerDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/se/orgnr.ts
+var SeOrgnrDetector;
+var init_orgnr$1 = __esm({ "src/regex/detectors/se/orgnr.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	SeOrgnrDetector = class extends RegexDetector {
+		entityType = EntityType.SE_ORGNR;
+		score = .85;
+		contextKeywords = [
+			"organisationsnummer",
+			"orgnr",
+			"org nr",
+			"organization number",
+			"foretag"
+		];
+		contextRequired = true;
+		pattern = /\b\d{6}-?\d{4}\b/g;
+		validator = seOrgnrChecksum;
+	};
+	registerRegion("se", SeOrgnrDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/se/index.ts
+var init_se = __esm({ "src/regex/detectors/se/index.ts"() {
+	init_personnummer();
+	init_orgnr$1();
+} });
+
+//#endregion
+//#region src/regex/detectors/no/birth-number.ts
+var NoBirthNumberDetector;
+var init_birth_number = __esm({ "src/regex/detectors/no/birth-number.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	NoBirthNumberDetector = class extends RegexDetector {
+		entityType = EntityType.NO_BIRTH_NUMBER;
+		score = .9;
+		contextKeywords = [
+			"fodselsnummer",
+			"birth number",
+			"personnummer",
+			"fødselsnummer"
+		];
+		contextRequired = false;
+		pattern = /\b(?:0[1-9]|[12]\d|3[01])(?:0[1-9]|1[0-2])\d{7}\b/g;
+		validator = noBirthNumberChecksum;
+	};
+	registerRegion("no", NoBirthNumberDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/no/orgnr.ts
+var NoOrgnrDetector;
+var init_orgnr = __esm({ "src/regex/detectors/no/orgnr.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	NoOrgnrDetector = class extends RegexDetector {
+		entityType = EntityType.NO_ORGNR;
+		score = .85;
+		contextKeywords = [
+			"organisasjonsnummer",
+			"orgnr",
+			"org nr",
+			"organization number",
+			"foretaksnummer"
+		];
+		contextRequired = true;
+		pattern = /\b\d{9}\b/g;
+		validator = noOrgnrChecksum;
+	};
+	registerRegion("no", NoOrgnrDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/no/index.ts
+var init_no = __esm({ "src/regex/detectors/no/index.ts"() {
+	init_birth_number();
+	init_orgnr();
+} });
+
+//#endregion
+//#region src/regex/detectors/br/cpf.ts
+var BrCpfDetector;
+var init_cpf = __esm({ "src/regex/detectors/br/cpf.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	BrCpfDetector = class extends RegexDetector {
+		entityType = EntityType.BR_CPF;
+		score = .9;
+		contextKeywords = ["cpf", "cadastro de pessoa"];
+		contextRequired = false;
+		pattern = /\b\d{3}\.?\d{3}\.?\d{3}[-.]?\d{2}\b/g;
+		validator = brCpfChecksum;
+	};
+	registerRegion("br", BrCpfDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/br/cnpj.ts
+var BrCnpjDetector;
+var init_cnpj = __esm({ "src/regex/detectors/br/cnpj.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	BrCnpjDetector = class extends RegexDetector {
+		entityType = EntityType.BR_CNPJ;
+		score = .9;
+		contextKeywords = ["cnpj", "cadastro nacional"];
+		contextRequired = false;
+		pattern = /\b\d{2}\.?\d{3}\.?\d{3}\/?\d{4}[-.]?\d{2}\b/g;
+		validator = brCnpjChecksum;
+	};
+	registerRegion("br", BrCnpjDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/br/index.ts
+var init_br = __esm({ "src/regex/detectors/br/index.ts"() {
+	init_cpf();
+	init_cnpj();
+} });
+
+//#endregion
+//#region src/regex/detectors/be/national-number.ts
+var BeNationalNumberDetector;
+var init_national_number = __esm({ "src/regex/detectors/be/national-number.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	BeNationalNumberDetector = class extends RegexDetector {
+		entityType = EntityType.BE_NATIONAL_NUMBER;
+		score = .85;
+		contextKeywords = [
+			"rijksregisternummer",
+			"national number",
+			"numero national",
+			"registre national",
+			"nn"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b\d{2}[. ]?\d{2}[. ]?\d{2}[- ]?\d{3}[. ]?\d{2}\b/g;
+		validator = beNationalNumberChecksum;
+	};
+	registerRegion("be", BeNationalNumberDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/be/enterprise-number.ts
+var BeEnterpriseNumberDetector;
+var init_enterprise_number = __esm({ "src/regex/detectors/be/enterprise-number.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	BeEnterpriseNumberDetector = class extends RegexDetector {
+		entityType = EntityType.BE_ENTERPRISE_NUMBER;
+		score = .85;
+		contextKeywords = [
+			"bce",
+			"kbo",
+			"enterprise number",
+			"ondernemingsnummer",
+			"numero entreprise"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b[01]\d{3}[. ]?\d{3}[. ]?\d{3}\b/g;
+		validator = beEnterpriseChecksum;
+	};
+	registerRegion("be", BeEnterpriseNumberDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/be/index.ts
+var init_be = __esm({ "src/regex/detectors/be/index.ts"() {
+	init_national_number();
+	init_enterprise_number();
+} });
+
+//#endregion
+//#region src/regex/detectors/at/svnr.ts
+var AtSvnrDetector;
+var init_svnr = __esm({ "src/regex/detectors/at/svnr.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	AtSvnrDetector = class extends RegexDetector {
+		entityType = EntityType.AT_SVNR;
+		score = .85;
+		contextKeywords = [
+			"svnr",
+			"sozialversicherungsnummer",
+			"versicherungsnummer",
+			"social insurance"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b\d{4}[- ]?\d{6}\b/g;
+		validator = atSvnrChecksum;
+	};
+	registerRegion("at", AtSvnrDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/at/index.ts
+var init_at = __esm({ "src/regex/detectors/at/index.ts"() {
+	init_svnr();
+} });
+
+//#endregion
+//#region src/regex/detectors/ie/pps.ts
+var IePpsDetector;
+var init_pps = __esm({ "src/regex/detectors/ie/pps.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	IePpsDetector = class extends RegexDetector {
+		entityType = EntityType.IE_PPS;
+		score = .85;
+		contextKeywords = [
+			"pps",
+			"ppsn",
+			"personal public service",
+			"revenue"
+		];
+		contextRequired = false;
+		contextWindow = 50;
+		pattern = /\b\d{7}[A-Z]{1,2}\b/gi;
+		validator = iePpsChecksum;
+	};
+	registerRegion("ie", IePpsDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/ie/index.ts
+var init_ie = __esm({ "src/regex/detectors/ie/index.ts"() {
+	init_pps();
+} });
+
+//#endregion
+//#region src/regex/detectors/fi/hetu.ts
+var FiHetuDetector;
+var init_hetu = __esm({ "src/regex/detectors/fi/hetu.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	FiHetuDetector = class extends RegexDetector {
+		entityType = EntityType.FI_HETU;
+		score = .85;
+		contextKeywords = [
+			"henkilotunnus",
+			"hetu",
+			"personal identity code",
+			"sosiaaliturvatunnus"
+		];
+		contextRequired = false;
+		pattern = /\b\d{6}[-+ABCDEFYXWVUabcdefyxwvu]\d{3}[0-9A-Za-z]\b/g;
+		validator = fiHetuChecksum;
+	};
+	registerRegion("fi", FiHetuDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/fi/ytunnus.ts
+var FiYtunnusDetector;
+var init_ytunnus = __esm({ "src/regex/detectors/fi/ytunnus.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	FiYtunnusDetector = class extends RegexDetector {
+		entityType = EntityType.FI_YTUNNUS;
+		score = .85;
+		contextKeywords = [
+			"y-tunnus",
+			"ytunnus",
+			"business id",
+			"yritystunnus",
+			"fo-nummer"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b\d{7}-\d\b/g;
+		validator = fiYtunnusChecksum;
+	};
+	registerRegion("fi", FiYtunnusDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/fi/index.ts
+var init_fi = __esm({ "src/regex/detectors/fi/index.ts"() {
+	init_hetu();
+	init_ytunnus();
+} });
+
+//#endregion
+//#region src/regex/detectors/hu/tax-id.ts
+var HuTaxIdDetector;
+var init_tax_id = __esm({ "src/regex/detectors/hu/tax-id.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	HuTaxIdDetector = class extends RegexDetector {
+		entityType = EntityType.HU_TAX_ID;
+		score = .85;
+		contextKeywords = [
+			"adoazonosito",
+			"adószám",
+			"tax id",
+			"tax number",
+			"adoazonosito jel"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b8\d{9}\b/g;
+		validator = huTaxIdChecksum;
+	};
+	registerRegion("hu", HuTaxIdDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/hu/taj.ts
+var HuTajDetector;
+var init_taj = __esm({ "src/regex/detectors/hu/taj.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	HuTajDetector = class extends RegexDetector {
+		entityType = EntityType.HU_TAJ;
+		score = .85;
+		contextKeywords = [
+			"taj",
+			"tarsadalombiztositasi",
+			"social security",
+			"társadalombiztosítási"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b\d{3}[- ]?\d{3}[- ]?\d{3}\b/g;
+		validator = huTajChecksum;
+	};
+	registerRegion("hu", HuTajDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/hu/index.ts
+var init_hu = __esm({ "src/regex/detectors/hu/index.ts"() {
+	init_tax_id();
+	init_taj();
+} });
+
+//#endregion
+//#region src/regex/detectors/bg/egn.ts
+var BgEgnDetector;
+var init_egn = __esm({ "src/regex/detectors/bg/egn.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	BgEgnDetector = class extends RegexDetector {
+		entityType = EntityType.BG_EGN;
+		score = .85;
+		contextKeywords = [
+			"egn",
+			"егн",
+			"edinen grazhdanski nomer",
+			"personal number",
+			"civil number"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b\d{10}\b/g;
+		validator = bgEgnChecksum;
+	};
+	registerRegion("bg", BgEgnDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/bg/index.ts
+var init_bg = __esm({ "src/regex/detectors/bg/index.ts"() {
+	init_egn();
+} });
+
+//#endregion
+//#region src/regex/detectors/hr/oib.ts
+var HrOibDetector;
+var init_oib = __esm({ "src/regex/detectors/hr/oib.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	HrOibDetector = class extends RegexDetector {
+		entityType = EntityType.HR_OIB;
+		score = .85;
+		contextKeywords = [
+			"oib",
+			"osobni identifikacijski broj",
+			"personal identification",
+			"identifikacijski"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b\d{11}\b/g;
+		validator = hrOibChecksum;
+	};
+	registerRegion("hr", HrOibDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/hr/index.ts
+var init_hr = __esm({ "src/regex/detectors/hr/index.ts"() {
+	init_oib();
+} });
+
+//#endregion
+//#region src/regex/detectors/si/emso.ts
+var SiEmsoDetector;
+var init_emso = __esm({ "src/regex/detectors/si/emso.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	SiEmsoDetector = class extends RegexDetector {
+		entityType = EntityType.SI_EMSO;
+		score = .85;
+		contextKeywords = [
+			"emso",
+			"enotna maticna stevilka",
+			"maticna stevilka",
+			"personal number"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b\d{13}\b/g;
+		validator = siEmsoChecksum;
+	};
+	registerRegion("si", SiEmsoDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/si/tax-number.ts
+var SiTaxNumberDetector;
+var init_tax_number = __esm({ "src/regex/detectors/si/tax-number.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	SiTaxNumberDetector = class extends RegexDetector {
+		entityType = EntityType.SI_TAX_NUMBER;
+		score = .85;
+		contextKeywords = [
+			"davcna stevilka",
+			"davcna",
+			"tax number",
+			"davčna številka"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b(?:SI)?\d{8}\b/gi;
+		validator = siTaxNumberChecksum;
+	};
+	registerRegion("si", SiTaxNumberDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/si/index.ts
+var init_si = __esm({ "src/regex/detectors/si/index.ts"() {
+	init_emso();
+	init_tax_number();
+} });
+
+//#endregion
+//#region src/regex/detectors/lt/personal-code.ts
+var LtPersonalCodeDetector;
+var init_personal_code$2 = __esm({ "src/regex/detectors/lt/personal-code.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	LtPersonalCodeDetector = class extends RegexDetector {
+		entityType = EntityType.LT_PERSONAL_CODE;
+		score = .85;
+		contextKeywords = [
+			"asmens kodas",
+			"personal code",
+			"asmens"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b[1-6]\d{10}\b/g;
+		validator = ltPersonalCodeChecksum;
+	};
+	registerRegion("lt", LtPersonalCodeDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/lt/index.ts
+var init_lt = __esm({ "src/regex/detectors/lt/index.ts"() {
+	init_personal_code$2();
+} });
+
+//#endregion
+//#region src/regex/detectors/lv/personal-code.ts
+var LvPersonalCodeDetector;
+var init_personal_code$1 = __esm({ "src/regex/detectors/lv/personal-code.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	LvPersonalCodeDetector = class extends RegexDetector {
+		entityType = EntityType.LV_PERSONAL_CODE;
+		score = .85;
+		contextKeywords = [
+			"personas kods",
+			"personal code",
+			"personas"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b\d{6}-?\d{5}\b/g;
+		validator = lvPersonalCodeChecksum;
+	};
+	registerRegion("lv", LvPersonalCodeDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/lv/index.ts
+var init_lv = __esm({ "src/regex/detectors/lv/index.ts"() {
+	init_personal_code$1();
+} });
+
+//#endregion
+//#region src/regex/detectors/ee/personal-code.ts
+var EePersonalCodeDetector;
+var init_personal_code = __esm({ "src/regex/detectors/ee/personal-code.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	EePersonalCodeDetector = class extends RegexDetector {
+		entityType = EntityType.EE_PERSONAL_CODE;
+		score = .85;
+		contextKeywords = [
+			"isikukood",
+			"personal code",
+			"identity code"
+		];
+		contextRequired = true;
+		contextWindow = 50;
+		pattern = /\b[1-6]\d{10}\b/g;
+		validator = eePersonalCodeChecksum;
+	};
+	registerRegion("ee", EePersonalCodeDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/ee/index.ts
+var init_ee = __esm({ "src/regex/detectors/ee/index.ts"() {
+	init_personal_code();
+} });
+
+//#endregion
+//#region src/regex/detectors/ca/sin.ts
+var CaSinDetector;
+var init_sin = __esm({ "src/regex/detectors/ca/sin.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	CaSinDetector = class extends RegexDetector {
+		entityType = EntityType.CA_SIN;
+		score = .85;
+		contextKeywords = [
+			"sin",
+			"social insurance number",
+			"numero assurance sociale",
+			"nas"
+		];
+		contextRequired = true;
+		pattern = /\b\d{3}[- ]?\d{3}[- ]?\d{3}\b/g;
+		validator = luhnChecksum;
+	};
+	registerRegion("ca", CaSinDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/ca/index.ts
+var init_ca = __esm({ "src/regex/detectors/ca/index.ts"() {
+	init_sin();
+} });
+
+//#endregion
+//#region src/regex/detectors/ch/ahv.ts
+var ChAhvDetector;
+var init_ahv = __esm({ "src/regex/detectors/ch/ahv.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	ChAhvDetector = class extends RegexDetector {
+		entityType = EntityType.CH_AHV;
+		score = .85;
+		contextKeywords = [
+			"ahv",
+			"avs",
+			"oasi",
+			"sozialversicherungsnummer",
+			"ahv-nr"
+		];
+		contextRequired = false;
+		pattern = /\b756[. ]?\d{4}[. ]?\d{4}[. ]?\d{2}\b/g;
+		validator = chAhvChecksum;
+	};
+	registerRegion("ch", ChAhvDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/ch/index.ts
+var init_ch = __esm({ "src/regex/detectors/ch/index.ts"() {
+	init_ahv();
+} });
+
+//#endregion
+//#region src/regex/detectors/au/tfn.ts
+var AuTfnDetector;
+var init_tfn = __esm({ "src/regex/detectors/au/tfn.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	AuTfnDetector = class extends RegexDetector {
+		entityType = EntityType.AU_TFN;
+		score = .85;
+		contextKeywords = [
+			"tfn",
+			"tax file number",
+			"tax file no"
+		];
+		contextRequired = true;
+		pattern = /\b\d{3}[- ]?\d{3}[- ]?\d{2,3}\b/g;
+		validator = auTfnChecksum;
+	};
+	registerRegion("au", AuTfnDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/au/medicare.ts
+var AuMedicareDetector;
+var init_medicare = __esm({ "src/regex/detectors/au/medicare.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	AuMedicareDetector = class extends RegexDetector {
+		entityType = EntityType.AU_MEDICARE;
+		score = .85;
+		contextKeywords = [
+			"medicare",
+			"medicare card",
+			"medicare number"
+		];
+		contextRequired = true;
+		pattern = /\b\d{4}[- ]?\d{5}[- ]?\d[- ]?\d?\b/g;
+		validator = auMedicareChecksum;
+	};
+	registerRegion("au", AuMedicareDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/au/index.ts
+var init_au = __esm({ "src/regex/detectors/au/index.ts"() {
+	init_tfn();
+	init_medicare();
+} });
+
+//#endregion
+//#region src/regex/detectors/nz/ird.ts
+var NzIrdDetector;
+var init_ird = __esm({ "src/regex/detectors/nz/ird.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	NzIrdDetector = class extends RegexDetector {
+		entityType = EntityType.NZ_IRD;
+		score = .85;
+		contextKeywords = [
+			"ird",
+			"inland revenue",
+			"tax number",
+			"ird number"
+		];
+		contextRequired = true;
+		pattern = /\b\d{2,3}[- ]?\d{3}[- ]?\d{3}\b/g;
+		validator = nzIrdChecksum;
+	};
+	registerRegion("nz", NzIrdDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/nz/index.ts
+var init_nz = __esm({ "src/regex/detectors/nz/index.ts"() {
+	init_ird();
+} });
+
+//#endregion
+//#region src/regex/detectors/in/aadhaar.ts
+var InAadhaarDetector;
+var init_aadhaar = __esm({ "src/regex/detectors/in/aadhaar.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	InAadhaarDetector = class extends RegexDetector {
+		entityType = EntityType.IN_AADHAAR;
+		score = .85;
+		contextKeywords = [
+			"aadhaar",
+			"aadhar",
+			"uidai",
+			"unique identification"
+		];
+		contextRequired = true;
+		pattern = /\b[2-9]\d{3}[- ]?\d{4}[- ]?\d{4}\b/g;
+		validator = inAadhaarChecksum;
+	};
+	registerRegion("in", InAadhaarDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/in/pan.ts
+var InPanDetector;
+var init_pan = __esm({ "src/regex/detectors/in/pan.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	InPanDetector = class extends RegexDetector {
+		entityType = EntityType.IN_PAN;
+		score = .85;
+		contextKeywords = [
+			"pan",
+			"permanent account number",
+			"income tax",
+			"pan card"
+		];
+		contextRequired = false;
+		pattern = /\b[A-Z]{3}[ABCFGHLJPT][A-Z]\d{4}[A-Z]\b/gi;
+		validator = inPanValid;
+	};
+	registerRegion("in", InPanDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/in/index.ts
+var init_in = __esm({ "src/regex/detectors/in/index.ts"() {
+	init_aadhaar();
+	init_pan();
+} });
+
+//#endregion
+//#region src/regex/detectors/jp/my-number.ts
+var JpMyNumberDetector;
+var init_my_number = __esm({ "src/regex/detectors/jp/my-number.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	JpMyNumberDetector = class extends RegexDetector {
+		entityType = EntityType.JP_MY_NUMBER;
+		score = .85;
+		contextKeywords = [
+			"my number",
+			"マイナンバー",
+			"kojin bango",
+			"individual number"
+		];
+		contextRequired = true;
+		pattern = /\b\d{4}[- ]?\d{4}[- ]?\d{4}\b/g;
+		validator = jpMyNumberChecksum;
+	};
+	registerRegion("jp", JpMyNumberDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/jp/index.ts
+var init_jp = __esm({ "src/regex/detectors/jp/index.ts"() {
+	init_my_number();
+} });
+
+//#endregion
+//#region src/regex/detectors/kr/rrn.ts
+var KrRrnDetector;
+var init_rrn = __esm({ "src/regex/detectors/kr/rrn.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	KrRrnDetector = class extends RegexDetector {
+		entityType = EntityType.KR_RRN;
+		score = .85;
+		contextKeywords = [
+			"주민등록번호",
+			"resident registration",
+			"jumin",
+			"rrn"
+		];
+		contextRequired = true;
+		pattern = /\b\d{6}[- ]?\d{7}\b/g;
+		validator = krRrnChecksum;
+	};
+	registerRegion("kr", KrRrnDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/kr/index.ts
+var init_kr = __esm({ "src/regex/detectors/kr/index.ts"() {
+	init_rrn();
+} });
+
+//#endregion
+//#region src/regex/detectors/za/id.ts
+var ZaIdDetector;
+var init_id$1 = __esm({ "src/regex/detectors/za/id.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	ZaIdDetector = class extends RegexDetector {
+		entityType = EntityType.ZA_ID;
+		score = .85;
+		contextKeywords = [
+			"id number",
+			"identity number",
+			"south african id",
+			"sa id"
+		];
+		contextRequired = true;
+		pattern = /\b\d{13}\b/g;
+		validator = luhnChecksum;
+	};
+	registerRegion("za", ZaIdDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/za/index.ts
+var init_za = __esm({ "src/regex/detectors/za/index.ts"() {
+	init_id$1();
+} });
+
+//#endregion
+//#region src/regex/detectors/tr/kimlik.ts
+var TrKimlikDetector;
+var init_kimlik = __esm({ "src/regex/detectors/tr/kimlik.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	TrKimlikDetector = class extends RegexDetector {
+		entityType = EntityType.TR_KIMLIK;
+		score = .85;
+		contextKeywords = [
+			"tc kimlik",
+			"kimlik no",
+			"tckn",
+			"vatandas",
+			"nufus"
+		];
+		contextRequired = true;
+		pattern = /\b[1-9]\d{10}\b/g;
+		validator = trKimlikChecksum;
+	};
+	registerRegion("tr", TrKimlikDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/tr/index.ts
+var init_tr = __esm({ "src/regex/detectors/tr/index.ts"() {
+	init_kimlik();
+} });
+
+//#endregion
+//#region src/regex/detectors/il/id.ts
+var IlIdDetector;
+var init_id = __esm({ "src/regex/detectors/il/id.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	IlIdDetector = class extends RegexDetector {
+		entityType = EntityType.IL_ID;
+		score = .85;
+		contextKeywords = [
+			"teudat zehut",
+			"mispar zehut",
+			"identity number",
+			"ת.ז",
+			"tz"
+		];
+		contextRequired = true;
+		pattern = /\b\d{9}\b/g;
+		validator = luhnChecksum;
+	};
+	registerRegion("il", IlIdDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/il/index.ts
+var init_il = __esm({ "src/regex/detectors/il/index.ts"() {
+	init_id();
+} });
+
+//#endregion
+//#region src/regex/detectors/ar/cuit.ts
+var ArCuitDetector;
+var init_cuit = __esm({ "src/regex/detectors/ar/cuit.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	ArCuitDetector = class extends RegexDetector {
+		entityType = EntityType.AR_CUIT;
+		score = .85;
+		contextKeywords = [
+			"cuit",
+			"cuil",
+			"clave unica",
+			"identificacion tributaria"
+		];
+		contextRequired = true;
+		pattern = /\b\d{2}-?\d{8}-?\d\b/g;
+		validator = arCuitChecksum;
+	};
+	registerRegion("ar", ArCuitDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/ar/index.ts
+var init_ar = __esm({ "src/regex/detectors/ar/index.ts"() {
+	init_cuit();
+} });
+
+//#endregion
+//#region src/regex/detectors/cl/rut.ts
+var ClRutDetector;
+var init_rut = __esm({ "src/regex/detectors/cl/rut.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	ClRutDetector = class extends RegexDetector {
+		entityType = EntityType.CL_RUT;
+		score = .85;
+		contextKeywords = [
+			"rut",
+			"run",
+			"rol unico tributario",
+			"rol unico nacional"
+		];
+		contextRequired = true;
+		pattern = /\b\d{1,2}\.?\d{3}\.?\d{3}-?[\dkK]\b/g;
+		validator = clRutChecksum;
+	};
+	registerRegion("cl", ClRutDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/cl/index.ts
+var init_cl = __esm({ "src/regex/detectors/cl/index.ts"() {
+	init_rut();
+} });
+
+//#endregion
+//#region src/regex/detectors/co/nit.ts
+var CoNitDetector;
+var init_nit = __esm({ "src/regex/detectors/co/nit.ts"() {
+	init_base();
+	init_entities();
+	init_registry();
+	init_validators();
+	CoNitDetector = class extends RegexDetector {
+		entityType = EntityType.CO_NIT;
+		score = .85;
+		contextKeywords = [
+			"nit",
+			"numero de identificacion tributaria",
+			"identificacion tributaria"
+		];
+		contextRequired = true;
+		pattern = /\b\d{3}\.?\d{3}\.?\d{3}-?\d\b/g;
+		validator = coNitChecksum;
+	};
+	registerRegion("co", CoNitDetector);
+} });
+
+//#endregion
+//#region src/regex/detectors/co/index.ts
+var init_co = __esm({ "src/regex/detectors/co/index.ts"() {
+	init_nit();
+} });
+
+//#endregion
+//#region src/regex/detectors/index.ts
+var init_detectors = __esm({ "src/regex/detectors/index.ts"() {
+	init_email();
+	init_credit_card();
+	init_phone();
+	init_ip_address();
+	init_url();
+	init_mac_address();
+	init_date_of_birth();
+	init_cvv();
+	init_us();
+	init_eu();
+	init_uk();
+	init_de();
+	init_fr();
+	init_es();
+	init_it();
+	init_pt();
+	init_pl();
+	init_cz();
+	init_ru();
+	init_nl();
+	init_ro();
+	init_sk();
+	init_dk();
+	init_se();
+	init_no();
+	init_br();
+	init_be();
+	init_at();
+	init_ie();
+	init_fi();
+	init_hu();
+	init_bg();
+	init_hr();
+	init_si();
+	init_lt();
+	init_lv();
+	init_ee();
+	init_ca();
+	init_ch();
+	init_au();
+	init_nz();
+	init_in();
+	init_jp();
+	init_kr();
+	init_za();
+	init_tr();
+	init_il();
+	init_ar();
+	init_cl();
+	init_co();
+} });
+
+//#endregion
+//#region src/regex/scanner.ts
+var PIIScanner;
+var init_scanner = __esm({ "src/regex/scanner.ts"() {
+	init_registry();
+	init_synthesizers();
+	init_detectors();
+	PIIScanner = class {
+		registry;
+		constructor(options) {
+			this.registry = new DetectorRegistry(options?.locales);
+		}
+		/** Detect PII entities in text and return deduplicated matches. */
+		detect(text, entities) {
+			let detectors = this.registry.detectors;
+			if (entities) {
+				const entitySet = new Set(entities);
+				detectors = detectors.filter((d) => entitySet.has(d.entityType));
+			}
+			const hasDigit = /\d/.test(text);
+			const textLower = text.toLowerCase();
+			const allMatches = [];
+			for (const detector of detectors) {
+				if (detector.needsDigit && !hasDigit) continue;
+				detector._textLower = textLower;
+				allMatches.push(...detector.iterMatches(text));
+				detector._textLower = null;
+			}
+			return this.deduplicate(allMatches);
+		}
+		/**
+		* Detect and remove PII from text.
+		* Returns a tuple of [redactedText, detectedMatches].
+		*/
+		redact(text, entities) {
+			const matches = this.detect(text, entities);
+			if (matches.length === 0) return [text, []];
+			const sortedMatches = [...matches].sort((a, b) => b.start - a.start);
+			let result = text;
+			for (const m of sortedMatches) {
+				const start = m.start > 0 && result[m.start - 1] === " " ? m.start - 1 : m.start;
+				result = result.slice(0, start) + result.slice(m.end);
+			}
+			return [result, matches];
+		}
+		/**
+		* Detect PII and replace with numbered tokens like `<Email Address_1>`.
+		* Returns tokenized text, a mapping from tokens to original values, and matches.
+		*/
+		tokenize(text, entities) {
+			const matches = this.detect(text, entities);
+			if (matches.length === 0) return {
+				text,
+				mapping: {},
+				matches: []
+			};
+			const sortedAsc = [...matches].sort((a, b) => a.start - b.start);
+			const counters = {};
+			const tokenMap = new Map();
+			const mapping = {};
+			for (const m of sortedAsc) {
+				const count = (counters[m.entityType] ?? 0) + 1;
+				counters[m.entityType] = count;
+				const token = `<${m.entityType}_${count}>`;
+				tokenMap.set(m, token);
+				mapping[token] = m.text;
+			}
+			const sortedDesc = [...matches].sort((a, b) => b.start - a.start);
+			let result = text;
+			for (const m of sortedDesc) {
+				const token = tokenMap.get(m);
+				result = result.slice(0, m.start) + token + result.slice(m.end);
+			}
+			return {
+				text: result,
+				mapping,
+				matches
+			};
+		}
+		/**
+		* Detect PII and partially mask each match.
+		*/
+		mask(text, charsToShow = 3, fromEnd = false, maskingChar = "*", entities) {
+			const matches = this.detect(text, entities);
+			if (matches.length === 0) return {
+				text,
+				matches: []
+			};
+			const sortedMatches = [...matches].sort((a, b) => b.start - a.start);
+			let result = text;
+			for (const m of sortedMatches) {
+				const original = m.text;
+				const show = Math.min(charsToShow, original.length);
+				const maskLen = original.length - show;
+				let masked;
+				if (fromEnd) masked = maskingChar.repeat(maskLen) + original.slice(maskLen);
+				else masked = original.slice(0, show) + maskingChar.repeat(maskLen);
+				result = result.slice(0, m.start) + masked + result.slice(m.end);
+			}
+			return {
+				text: result,
+				matches
+			};
+		}
+		/**
+		* Detect PII and replace each match with a deterministic hash.
+		*/
+		hash(text, hashType = "sha256", hashPrefix = "HASH_", hashLength = 16, entities) {
+			const matches = this.detect(text, entities);
+			if (matches.length === 0) return {
+				text,
+				matches: []
+			};
+			const sortedMatches = [...matches].sort((a, b) => b.start - a.start);
+			let result = text;
+			for (const m of sortedMatches) {
+				const digest = crypto.createHash(hashType).update(m.text).digest("hex");
+				const truncated = digest.slice(0, hashLength);
+				const replacement = hashPrefix + truncated;
+				result = result.slice(0, m.start) + replacement + result.slice(m.end);
+			}
+			return {
+				text: result,
+				matches
+			};
+		}
+		/**
+		* Detect PII and encrypt each match with AES-256-CBC.
+		* @param encryptionKey - Required, minimum 16 characters.
+		*/
+		encrypt(text, encryptionKey, entities) {
+			if (!encryptionKey || encryptionKey.length < 16) throw new Error("encryptionKey is required and must be at least 16 characters for local encryption");
+			const matches = this.detect(text, entities);
+			if (matches.length === 0) return {
+				text,
+				matches: []
+			};
+			const derivedKey = crypto.createHash("sha256").update(encryptionKey).digest();
+			const sortedMatches = [...matches].sort((a, b) => b.start - a.start);
+			let result = text;
+			for (const m of sortedMatches) {
+				const iv = crypto.randomBytes(16);
+				const cipher = crypto.createCipheriv("aes-256-cbc", derivedKey, iv);
+				const encrypted = Buffer.concat([cipher.update(m.text, "utf8"), cipher.final()]);
+				const combined = Buffer.concat([iv, encrypted]);
+				const replacement = combined.toString("base64");
+				result = result.slice(0, m.start) + replacement + result.slice(m.end);
+			}
+			return {
+				text: result,
+				matches
+			};
+		}
+		/**
+		* Detect PII and replace each match with format-preserving synthetic data.
+		* @param _language - Accepted for API compatibility but ignored locally.
+		*/
+		synthesize(text, _language, entities) {
+			const matches = this.detect(text, entities);
+			if (matches.length === 0) return {
+				text,
+				matches: []
+			};
+			const sortedMatches = [...matches].sort((a, b) => b.start - a.start);
+			let result = text;
+			for (const m of sortedMatches) {
+				const replacement = synthesizeValue(m.entityType, m.text);
+				result = result.slice(0, m.start) + replacement + result.slice(m.end);
+			}
+			return {
+				text: result,
+				matches
+			};
+		}
+		/** Remove overlapping matches, preferring higher score then longer span. */
+		deduplicate(matches) {
+			if (matches.length === 0) return [];
+			matches.sort((a, b) => {
+				if (a.start !== b.start) return a.start - b.start;
+				if (a.score !== b.score) return b.score - a.score;
+				return b.end - b.start - (a.end - a.start);
+			});
+			const result = [];
+			let lastEnd = -1;
+			for (const m of matches) if (m.start >= lastEnd) {
+				result.push(m);
+				lastEnd = m.end;
+			}
+			return result;
+		}
+	};
+} });
+
+//#endregion
+//#region src/regex/index.ts
+var regex_exports = {};
+__export(regex_exports, {
+	EntityType: () => EntityType,
+	PIIScanner: () => PIIScanner
+});
+var init_regex = __esm({ "src/regex/index.ts"() {
+	init_scanner();
+	init_entities();
+} });
+
+//#endregion
+Object.defineProperty(exports, 'EntityType', {
+  enumerable: true,
+  get: function () {
+    return EntityType;
+  }
+});
+Object.defineProperty(exports, 'PIIScanner', {
+  enumerable: true,
+  get: function () {
+    return PIIScanner;
+  }
+});
+Object.defineProperty(exports, '__toCommonJS', {
+  enumerable: true,
+  get: function () {
+    return __toCommonJS;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'init_regex', {
+  enumerable: true,
+  get: function () {
+    return init_regex;
+  }
+});
+Object.defineProperty(exports, 'regex_exports', {
+  enumerable: true,
+  get: function () {
+    return regex_exports;
+  }
+});
+//# sourceMappingURL=regex-BEaK0E7Y.js.map