@blindfold/sdk 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Blindfold
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,427 @@
+# Blindfold JS SDK
+
+Detect, redact, tokenize, and mask PII in JavaScript/TypeScript. 80+ entity types, 30+ countries, works offline with zero dependencies.
+
+[![npm version](https://img.shields.io/npm/v/@blindfold/sdk)](https://www.npmjs.com/package/@blindfold/sdk)
+[![License](https://img.shields.io/npm/l/@blindfold/sdk)](https://github.com/blindfold-dev/blindfold/blob/main/LICENSE)
+
+## Why Blindfold?
+
+- **Works offline, zero dependencies** — No API key needed for local detection. No network calls. No external packages.
+- **80+ PII entity types** across 30+ countries with checksum validation (Luhn, IBAN mod-97, Verhoeff, etc.)
+- **85x faster than Presidio** — 0.4s vs 34s on 3,000 samples ([benchmark](https://blindfold.dev/blog/pii-detection-benchmark))
+- **Higher accuracy** — F1 58.6% vs Presidio 38.8% on AI4Privacy multilingual benchmark
+- **8 operations**: detect, redact, tokenize, detokenize, mask, hash, encrypt, synthesize
+- **Compliance-ready** — Built-in GDPR, HIPAA, PCI-DSS policies
+- **Optional NLP upgrade** — Add API key to detect names, addresses, organizations (60+ additional entities)
+- **Batch processing**, typed errors, full TypeScript support
+
+## Quick Comparison
+
+| Feature | Blindfold | Presidio | regex-only |
+|---|---|---|---|
+| Entity types (local) | 80+ | ~20 | Custom |
+| Countries | 30+ | ~5 | Custom |
+| Checksum validation | Luhn, mod-97, Verhoeff, ... | Partial | No |
+| Speed (3K samples) | 0.4s | 34s | Varies |
+| Zero dependencies | Yes | No (spaCy) | Yes |
+| NLP upgrade path | Yes (API) | Yes (built-in) | No |
+| Tokenize/detokenize | Yes | No | No |
+
+## Common Use Cases
+
+- **Sanitize LLM prompts** — Strip PII before sending to OpenAI, Anthropic, etc.
+- **PII-safe RAG pipelines** — Redact before embedding, restore after retrieval
+- **Log scrubbing** — Anonymize data in logs and data pipelines
+- **GDPR/HIPAA compliance** — Built-in policies for AI applications
+- **Synthetic test data** — Format-preserving fake data generation
+
+## Install
+
+```bash
+npm install @blindfold/sdk
+# or
+yarn add @blindfold/sdk
+# or
+pnpm add @blindfold/sdk
+```
+
+## Quick Start (no API key needed)
+
+```typescript
+import { Blindfold } from '@blindfold/sdk'
+
+const client = new Blindfold()
+
+// Detect PII locally — no API key, no network call
+const result = await client.detect("Email john@acme.com, SSN 123-45-6789")
+for (const entity of result.detected_entities) {
+  console.log(`${entity.type}: ${entity.text} (score: ${entity.score})`)
+}
+// Email Address: john@acme.com (score: 0.95)
+// Social Security Number: 123-45-6789 (score: 1.0)
+
+// Redact PII locally
+const redacted = await client.redact("Email john@acme.com, SSN 123-45-6789")
+console.log(redacted.text)
+// "Email, SSN"
+```
+
+## Protect AI Prompts
+
+Tokenize PII before sending to any LLM. The AI never sees real data.
+
+### OpenAI
+
+```typescript
+import { Blindfold } from '@blindfold/sdk'
+import OpenAI from 'openai'
+
+const bf = new Blindfold() // Free local mode
+const openai = new OpenAI()
+
+// 1. Tokenize PII
+const safe = await bf.tokenize("My name is John Smith, email john@acme.com")
+// safe.text → "My name is <Person_1>, email <Email Address_1>"
+
+// 2. Send to GPT — PII never reaches OpenAI
+const response = await openai.chat.completions.create({
+  model: 'gpt-4o',
+  messages: [{ role: 'user', content: safe.text }]
+})
+
+// 3. Restore original data
+const result = bf.detokenize(response.choices[0].message.content, safe.mapping)
+console.log(result.text)
+```
+
+### Anthropic Claude
+
+```typescript
+import { Blindfold } from '@blindfold/sdk'
+import Anthropic from '@anthropic-ai/sdk'
+
+const bf = new Blindfold()
+const anthropic = new Anthropic()
+
+const safe = await bf.tokenize("My name is John Smith, email john@acme.com")
+
+const response = await anthropic.messages.create({
+  model: 'claude-sonnet-4-20250514',
+  max_tokens: 1024,
+  messages: [{ role: 'user', content: safe.text }]
+})
+
+const result = bf.detokenize(response.content[0].text, safe.mapping)
+console.log(result.text)
+```
+
+**Works with any AI provider:** OpenAI, Anthropic Claude, Google Gemini, AWS Bedrock, Azure OpenAI, LangChain, LlamaIndex, Vercel AI SDK, CrewAI — [see all integrations](https://docs.blindfold.dev/integrations).
+
+## Upgrade to Blindfold API (optional)
+
+For names, addresses, organizations, and 60+ entity types, add your API key:
+
+1. Sign up at [blindfold.dev](https://www.blindfold.dev/)
+2. Get your API key at [app.blindfold.dev/api-keys](https://app.blindfold.dev/api-keys)
+3. Set environment variable: `BLINDFOLD_API_KEY=sk-***`
+
+```typescript
+// With API key — auto-switches to NLP-powered API
+const client = new Blindfold({ apiKey: 'sk-...' })
+const result = await client.detect("John Smith lives at 123 Oak Street")
+```
+
+## Initialization
+
+```typescript
+import { Blindfold } from '@blindfold/sdk'
+
+// Local mode (no API key) — regex-based detection
+const client = new Blindfold()
+
+// API mode (with API key) — NLP-powered detection
+const client = new Blindfold({ apiKey: 'sk-...' })
+
+// Force local mode even with an API key (useful for latency-critical paths)
+const client = new Blindfold({ apiKey: 'sk-...', mode: 'local' })
+```
+
+## Operations
+
+### Tokenize (Reversible)
+
+Replace sensitive data with reversible tokens (e.g., `<Person_1>`).
+
+```typescript
+const response = await client.tokenize(
+  "Contact John Doe at john@example.com",
+  {
+    policy: 'gdpr_eu',  // Optional: 'hipaa_us', 'basic', 'pci_dss', 'strict'
+    entities: ['person', 'email address'],  // Optional: filter entities
+    score_threshold: 0.4  // Optional: confidence threshold
+  }
+)
+
+console.log(response.text)
+// "Contact <Person_1> at <Email Address_1>"
+
+console.log(response.mapping)
+// { "<Person_1>": "John Doe", "<Email Address_1>": "john@example.com" }
+```
+
+### Detokenize
+
+Restore original values from tokens. Runs **client-side** — no API call.
+
+```typescript
+// No await needed — runs locally!
+const original = client.detokenize(
+  "AI response for <Person_1>",
+  response.mapping
+)
+console.log(original.text)
+// "AI response for John Doe"
+```
+
+### Redact
+
+Permanently remove sensitive data.
+
+```typescript
+const response = await client.redact(
+  "My password is secret123",
+  { entities: ['person', 'email address'] }
+)
+```
+
+### Mask
+
+Partially hide sensitive data (e.g., `****-****-****-1234`).
+
+```typescript
+const response = await client.mask(
+  "Credit card: 4532-7562-9102-3456",
+  { masking_char: '*', chars_to_show: 4, from_end: true }
+)
+console.log(response.text)
+// "Credit card: ***************3456"
+```
+
+### Hash
+
+Replace data with deterministic hashes (useful for analytics/matching).
+
+```typescript
+const response = await client.hash(
+  "User ID: 12345",
+  { hash_type: 'sha256', hash_prefix: 'ID_' }
+)
+```
+
+### Encrypt
+
+Encrypt sensitive data using AES (reversible with key).
+
+```typescript
+const response = await client.encrypt(
+  "Secret message",
+  { encryption_key: 'your-secure-key-min-16-chars' }
+)
+```
+
+### Synthesize
+
+Replace real data with realistic fake data. Works offline with format-preserving generation.
+
+```typescript
+// Works offline — no API key required
+const client = new Blindfold()
+const response = await client.synthesize("Email john@acme.com, SSN 123-45-6789")
+console.log(response.text)
+// "Email user3a9f1b2c@example.com, SSN 847-29-3156"
+
+// With API key — NLP-powered synthesis (names, addresses, etc.)
+const response = await client.synthesize(
+  "John lives in New York",
+  { language: 'en' }
+)
+console.log(response.text)
+// "Michael lives in Boston"
+```
+
+## Batch Processing
+
+Process multiple texts in a single request (max 100 texts):
+
+```typescript
+const result = await client.tokenizeBatch(
+  ["Contact John Doe", "jane@example.com", "No PII here"],
+  { policy: "gdpr_eu" }
+)
+
+console.log(result.total)      // 3
+console.log(result.succeeded)  // 3
+console.log(result.failed)     // 0
+
+result.results.forEach(item => console.log(item.text))
+```
+
+All methods have batch variants: `tokenizeBatch`, `detectBatch`, `redactBatch`, `maskBatch`, `synthesizeBatch`, `hashBatch`, `encryptBatch`.
+
+## Local PII Scanner
+
+The built-in regex scanner works offline with zero dependencies. Use it directly for fine-grained control:
+
+```typescript
+import { PIIScanner, EntityType } from '@blindfold/sdk/regex'
+
+// Default: US locale
+const scanner = new PIIScanner()
+const matches = scanner.detect("Call me at john@acme.com or 555-867-5309")
+
+for (const match of matches) {
+  console.log(`${match.entityType}: ${match.text} (score: ${match.score})`)
+}
+
+// Redact PII
+const { text, matches: redacted } = scanner.redact("SSN 123-45-6789, CC 4532015112830366")
+console.log(text)
+// "SSN, CC"
+```
+
+### Multi-locale support
+
+```typescript
+// US + EU entities
+const scanner = new PIIScanner({ locales: ['us', 'eu'] })
+const matches = scanner.detect("SSN 123-45-6789, IBAN DE89370400440532013000")
+
+// UK entities
+const scanner = new PIIScanner({ locales: ['uk'] })
+const matches = scanner.detect("NI number: AB 12 34 56 A")
+
+// All locales
+const scanner = new PIIScanner({ locales: ['us', 'eu', 'uk'] })
+```
+
+### Filter by entity type
+
+```typescript
+// Only detect emails and credit cards
+const scanner = new PIIScanner({ entities: [EntityType.EMAIL, EntityType.CREDIT_CARD] })
+```
+
+## Error Handling
+
+```typescript
+import { AuthenticationError, APIError, NetworkError } from '@blindfold/sdk'
+
+try {
+  await client.tokenize("...")
+} catch (error) {
+  if (error instanceof AuthenticationError) {
+    // Handle invalid API key
+  } else if (error instanceof APIError) {
+    // Handle API error (e.g. validation)
+  } else if (error instanceof NetworkError) {
+    // Handle network issues
+  }
+}
+```
+
+<details>
+<summary><strong>Supported local entity types (80+)</strong></summary>
+
+| Entity Type | Locale | Validation |
+|---|---|---|
+| Email Address | Universal | RFC 5322 pattern |
+| Credit Card Number | Universal | Luhn checksum |
+| Phone Number | Universal | Format + digit count |
+| IP Address (v4/v6) | Universal | Octet range |
+| URL | Universal | TLD validation |
+| MAC Address | Universal | Pattern |
+| Date of Birth | Universal | Context-required |
+| CVV/CVC | Universal | Context-required |
+| Social Security Number | US | Format rules + context |
+| Driver's License | US | Multi-state formats + context |
+| US Passport | US | Context-required |
+| Tax ID / EIN | US | Prefix validation + context |
+| ZIP Code | US | Context-required + validator |
+| US ITIN | US | Format validation |
+| IBAN | EU | ISO 7064 mod-97 checksum |
+| Postal Code | EU | DE/FR/NL patterns |
+| VAT ID | EU | Country prefix + format |
+| UK NI Number | UK | Format validation |
+| UK NHS Number | UK | Modulus-11 checksum |
+| UK Postcode | UK | Pattern |
+| UK Passport | UK | Context-required |
+| UK UTR | UK | Mod-11 checksum |
+| German Personal ID | DE | Context-required |
+| German Tax ID | DE | Check digit |
+| French National ID (NIR) | FR | Check digit |
+| French SIREN | FR | Luhn checksum |
+| Spanish DNI | ES | Letter validation |
+| Spanish NIE | ES | Letter validation |
+| Spanish NSS | ES | Mod-97 checksum |
+| Spanish CIF | ES | Custom checksum |
+| Italian Codice Fiscale | IT | Check digit |
+| Italian Partita IVA | IT | Luhn-like checksum |
+| Portuguese NIF | PT | Check digit |
+| Dutch BSN | NL | Modulus-11 check |
+| Belgian National Number | BE | Mod-97 checksum |
+| Belgian Enterprise Number | BE | Mod-97 checksum |
+| Austrian SVNR | AT | Mod-11 checksum |
+| Swiss AHV | CH | EAN-13 checksum |
+| Irish PPS Number | IE | Mod-23 checksum |
+| Polish PESEL | PL | Check digit |
+| Polish NIP | PL | Check digit |
+| Polish REGON | PL | Mod-11 checksum |
+| Czech Birth Number | CZ | Modulus validation |
+| Czech ICO (Company ID) | CZ | Mod-11 weighted checksum |
+| Czech DIC (Tax/VAT ID) | CZ | ICO checksum / mod-11 |
+| Czech Bank Account | CZ | Mod-11 weighted checksum |
+| Slovak Birth Number | SK | Modulus validation |
+| Slovak ICO | SK | Mod-11 weighted checksum |
+| Slovak DIC | SK | Mod-11 divisibility |
+| Romanian CNP | RO | Check digit |
+| Romanian CUI | RO | Mod-11 checksum |
+| Danish CPR | DK | Date validation |
+| Danish CVR | DK | Mod-11 checksum |
+| Swedish Personnummer | SE | Luhn algorithm |
+| Swedish Organisationsnummer | SE | Luhn algorithm |
+| Norwegian Birth Number | NO | Check digit |
+| Norwegian Organisasjonsnummer | NO | Mod-11 checksum |
+| Finnish HETU | FI | Mod-31 checksum |
+| Finnish Y-tunnus | FI | Mod-11 checksum |
+| Hungarian Tax ID | HU | Mod-11 checksum |
+| Hungarian TAJ | HU | Mod-10 checksum |
+| Bulgarian EGN | BG | Mod-11 checksum |
+| Croatian OIB | HR | ISO 7064 MOD 11,2 |
+| Slovenian EMSO | SI | Mod-11 checksum |
+| Slovenian Tax Number | SI | Mod-11 checksum |
+| Lithuanian Personal Code | LT | Dual-pass mod-11 |
+| Latvian Personal Code | LV | Weighted checksum |
+| Estonian Personal Code | EE | Dual-pass mod-11 |
+| Russian INN | RU | Check digit |
+| Russian SNILS | RU | Check digit |
+| Canadian SIN | CA | Luhn checksum |
+| Australian TFN | AU | Mod-11 checksum |
+| Australian Medicare | AU | Mod-10 checksum |
+| New Zealand IRD | NZ | Dual-pass mod-11 |
+| Indian Aadhaar | IN | Verhoeff algorithm |
+| Indian PAN | IN | Format validation |
+| Japanese My Number | JP | Mod-11 checksum |
+| Korean RRN | KR | Weighted checksum |
+| South African ID | ZA | Luhn checksum |
+| Turkish Kimlik | TR | Custom dual check |
+| Israeli ID | IL | Luhn checksum |
+| Brazilian CPF | BR | Check digit |
+| Brazilian CNPJ | BR | Check digit |
+| Argentine CUIT | AR | Mod-11 checksum |
+| Chilean RUT | CL | Mod-11 with K |
+| Colombian NIT | CO | Mod-11 prime weights |
+
+> Add your [API key](#upgrade-to-blindfold-api-optional) to unlock names, addresses, organizations, and 60+ additional entity types with NLP-powered detection.
+
+</details>

package/dist/index-CsE6Vhax.d.mts

@@ -0,0 +1,177 @@
+//#region src/regex/entities.d.ts
+/**
+ * PII entity types detected by the regex scanner.
+ * Names match the Blindfold API entity types for transparent switching.
+ */
+declare enum EntityType {
+  EMAIL_ADDRESS = "Email Address",
+  CREDIT_CARD = "Credit Card Number",
+  PHONE_NUMBER = "Phone Number",
+  IP_ADDRESS = "IP Address",
+  URL = "URL",
+  MAC_ADDRESS = "MAC Address",
+  DATE_OF_BIRTH = "Date of Birth",
+  CVV = "CVV",
+  SSN = "Social Security Number",
+  DRIVERS_LICENSE = "Driver's License",
+  US_PASSPORT = "US Passport",
+  TAX_ID = "Tax ID",
+  ZIP_CODE = "ZIP Code",
+  IBAN = "IBAN",
+  EU_POSTAL_CODE = "Postal Code",
+  VAT_ID = "VAT ID",
+  NI_NUMBER = "NI Number",
+  NHS_NUMBER = "NHS Number",
+  UK_POSTCODE = "UK Postcode",
+  UK_PASSPORT = "UK Passport",
+  DE_PERSONAL_ID = "German Personal ID",
+  DE_TAX_ID = "German Tax ID",
+  FR_NATIONAL_ID = "French National ID",
+  ES_DNI = "Spanish DNI",
+  ES_NIE = "Spanish NIE",
+  IT_CODICE_FISCALE = "Italian Codice Fiscale",
+  PT_NIF = "Portuguese NIF",
+  PL_PESEL = "Polish PESEL",
+  PL_NIP = "Polish NIP",
+  CZ_BIRTH_NUMBER = "Czech Birth Number",
+  CZ_ICO = "Czech ICO",
+  CZ_DIC = "Czech DIC",
+  CZ_BANK_ACCOUNT = "Czech Bank Account",
+  RU_INN = "Russian INN",
+  RU_SNILS = "Russian SNILS",
+  NL_BSN = "Dutch BSN",
+  RO_CNP = "Romanian CNP",
+  SK_BIRTH_NUMBER = "Slovak Birth Number",
+  DK_CPR = "Danish CPR",
+  SE_PERSONNUMMER = "Swedish Personnummer",
+  NO_BIRTH_NUMBER = "Norwegian Birth Number",
+  BR_CPF = "Brazilian CPF",
+  BR_CNPJ = "Brazilian CNPJ",
+  US_ITIN = "US ITIN",
+  UK_UTR = "UK UTR",
+  FR_SIREN = "French SIREN",
+  ES_NSS = "Spanish NSS",
+  ES_CIF = "Spanish CIF",
+  IT_PARTITA_IVA = "Italian Partita IVA",
+  PL_REGON = "Polish REGON",
+  SK_ICO = "Slovak ICO",
+  SK_DIC = "Slovak DIC",
+  RO_CUI = "Romanian CUI",
+  DK_CVR = "Danish CVR",
+  SE_ORGNR = "Swedish Organisationsnummer",
+  NO_ORGNR = "Norwegian Organisasjonsnummer",
+  BE_NATIONAL_NUMBER = "Belgian National Number",
+  BE_ENTERPRISE_NUMBER = "Belgian Enterprise Number",
+  AT_SVNR = "Austrian SVNR",
+  IE_PPS = "Irish PPS Number",
+  FI_HETU = "Finnish HETU",
+  FI_YTUNNUS = "Finnish Y-tunnus",
+  HU_TAX_ID = "Hungarian Tax ID",
+  HU_TAJ = "Hungarian TAJ",
+  BG_EGN = "Bulgarian EGN",
+  HR_OIB = "Croatian OIB",
+  SI_EMSO = "Slovenian EMSO",
+  SI_TAX_NUMBER = "Slovenian Tax Number",
+  LT_PERSONAL_CODE = "Lithuanian Personal Code",
+  LV_PERSONAL_CODE = "Latvian Personal Code",
+  EE_PERSONAL_CODE = "Estonian Personal Code",
+  CA_SIN = "Canadian SIN",
+  CH_AHV = "Swiss AHV",
+  AU_TFN = "Australian TFN",
+  AU_MEDICARE = "Australian Medicare",
+  NZ_IRD = "New Zealand IRD",
+  IN_AADHAAR = "Indian Aadhaar",
+  IN_PAN = "Indian PAN",
+  JP_MY_NUMBER = "Japanese My Number",
+  KR_RRN = "Korean RRN",
+  ZA_ID = "South African ID",
+  TR_KIMLIK = "Turkish Kimlik",
+  IL_ID = "Israeli ID",
+  AR_CUIT = "Argentine CUIT",
+  CL_RUT = "Chilean RUT",
+  CO_NIT = "Colombian NIT",
+}
+/** A single PII match found by a detector. */
+interface PIIMatch {
+  entityType: string;
+  text: string;
+  start: number;
+  end: number;
+  score: number;
+} //#endregion
+//#region src/regex/scanner.d.ts
+
+//# sourceMappingURL=entities.d.ts.map
+interface PIIScannerOptions {
+  /** List of locale codes to enable (default: ["us"]). */
+  locales?: string[];
+}
+interface TokenizeResult {
+  text: string;
+  mapping: Record<string, string>;
+  matches: PIIMatch[];
+}
+interface MaskResult {
+  text: string;
+  matches: PIIMatch[];
+}
+interface HashResult {
+  text: string;
+  matches: PIIMatch[];
+}
+interface EncryptResult {
+  text: string;
+  matches: PIIMatch[];
+}
+interface SynthesizeResult {
+  text: string;
+  matches: PIIMatch[];
+}
+/**
+ * Local regex-based PII scanner.
+ *
+ * Usage:
+ *   const scanner = new PIIScanner({ locales: ['us', 'eu'] })
+ *   const matches = scanner.detect('Email john@acme.com, SSN 123-45-6789')
+ *   const [redacted, matches] = scanner.redact('Email john@acme.com')
+ */
+declare class PIIScanner {
+  private registry;
+  constructor(options?: PIIScannerOptions);
+  /** Detect PII entities in text and return deduplicated matches. */
+  detect(text: string, entities?: string[]): PIIMatch[];
+  /**
+   * Detect and remove PII from text.
+   * Returns a tuple of [redactedText, detectedMatches].
+   */
+  redact(text: string, entities?: string[]): [string, PIIMatch[]];
+  /**
+   * 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: string, entities?: string[]): TokenizeResult;
+  /**
+   * Detect PII and partially mask each match.
+   */
+  mask(text: string, charsToShow?: number, fromEnd?: boolean, maskingChar?: string, entities?: string[]): MaskResult;
+  /**
+   * Detect PII and replace each match with a deterministic hash.
+   */
+  hash(text: string, hashType?: string, hashPrefix?: string, hashLength?: number, entities?: string[]): HashResult;
+  /**
+   * Detect PII and encrypt each match with AES-256-CBC.
+   * @param encryptionKey - Required, minimum 16 characters.
+   */
+  encrypt(text: string, encryptionKey: string, entities?: string[]): EncryptResult;
+  /**
+   * Detect PII and replace each match with format-preserving synthetic data.
+   * @param _language - Accepted for API compatibility but ignored locally.
+   */
+  synthesize(text: string, _language?: string, entities?: string[]): SynthesizeResult;
+  /** Remove overlapping matches, preferring higher score then longer span. */
+  private deduplicate;
+} //#endregion
+
+//# sourceMappingURL=scanner.d.ts.map
+export { EntityType as EntityType$1, PIIMatch, PIIScanner as PIIScanner$1, PIIScannerOptions };
+//# sourceMappingURL=index-CsE6Vhax.d.mts.map

package/dist/index-CsE6Vhax.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CsE6Vhax.d.mts","names":[],"sources":["../src/regex/entities.ts","../src/regex/scanner.ts"],"sourcesContent":null,"mappings":";;;;;aAMY,UAAA;EAAA,aAAU,GAAA,eAAA;;EAqML,YAAQ,GAAA,cAAA;;;;ECjMR,aAAA,GAAA,eAAiB;EAKjB,GAAA,GAAA,KAAA;EAAc,GAAA,GAAA,wBAAA;EAAA,eAEpB,GAAA,kBAAA;EAAM,WACN,GAAA,aAAA;EAAQ,MAAA,GAAA,QAAA;EAGF,QAAA,GAAA,UAAU;EAKV,IAAA,GAAA,MAAU;EAKV,cAAA,GAAa,aAEnB;EAGM,MAAA,GAAA,QAAA;;;;;;;;;EAaJ,MAAA,GAAA,aAAU;EAAA,iBAAA,GAAA,wBAAA;EAAA,MAGC,GAAA,gBAAA;EAAiB,QAKI,GAAA,cAAA;EAAQ,MAwBC,GAAA,YAAA;EAAQ,eAsBf,GAAA,oBAAA;EAAc,MAwCxD,GAAA,WAAA;EAAU,MAiCV,GAAA,WAAA;EAAU,eAsBsD,GAAA,oBAAA;EAAa,MA+Bb,GAAA,aAAA;EAAgB,QAAA,GAAA,eAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UD1BpE,QAAA;;;;;;;;;;UCjMA,iBAAA;;;ADJjB;UCSiB,cAAA;ED4LA,IAAA,EAAA,MAAQ;WC1Ld;WACA;;AARM,UAWA,UAAA,CAXiB;EAKjB,IAAA,EAAA,MAAA;EAAc,OAAA,EAQpB,QARoB,EAAA;;AAGpB,UAQM,UAAA,CARN;EAAQ,IAAA,EAAA,MAAA;EAGF,OAAA,EAON,QAPgB,EAAA;AAK3B;AAKiB,UAAA,aAAA,CAEN;EAGM,IAAA,EAAA,MAAA;WAHN;;UAGM,gBAAA;;WAEN;;;;AAWX;;;;;;AA8FK,cA9FQ,UAAA,CA8FR;EAAU,QAiCV,QAAA;EAAU,WAsBsD,CAAA,OAAA,CAAA,EAlJ7C,iBAkJ6C;EAAa;EA+BG,MAAA,CAAA,IAAA,EAAA,MAAA,EAAA,QAAA,CAAA,EAAA,MAAA,EAAA,CAAA,EA5KxC,QA4KwC,EAAA;;;;;sDApJ/B;;;;;+CAsBP;;;;0GAwC1C;;;;wGAiCA;;;;;qEAsBgE;;;;;qEA+BA"}