euredact 0.0.1 → 0.2.0

package/LICENSE

@@ -0,0 +1,189 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work.
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by the Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding any notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2024 JNJS
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,20 +1,349 @@
-# EUREdact
+# euredact
 
-**European PII redaction SDK — rule engine + cloud tier.**
+**European PII detection and redaction for Node.js / TypeScript**
 
-> ⚠️ The Node.js/TypeScript SDK is in development. The Python SDK is available now.
+---
+
+Fast, zero-dependency European PII detection and redaction SDK. Detects and
+redacts personal data across **31 European countries** using rule-based pattern
+matching with checksum validation, context-aware false-positive suppression,
+and priority-based deduplication.
+
+## Install
 
 ```bash
-pip install euredact
+npm install euredact
+```
+
+## Quick Start
+
+```ts
+import { redact } from "euredact";
+
+const result = redact("Mijn BSN is 123456782 en email jan@example.com", {
+  countries: ["NL"],
+});
+
+console.log(result.redactedText);
+// "Mijn BSN is [NATIONAL_ID] en email [EMAIL]"
+
+console.log(result.detections);
+// [{ entityType: "NATIONAL_ID", text: "123456782", start: 12, end: 21, ... }, ...]
+```
+
+## Features
+
+- **31 European countries** with country-specific patterns
+- **25+ PII entity types:** national IDs, IBANs, phone numbers, email, VAT
+  numbers, license plates, credit cards, BIC/SWIFT, VIN, IMEI, GPS coordinates,
+  UUIDs, social handles, IP/IPv6, MAC addresses, secrets/API keys, and more
+- **Secret/API key detection:** known-prefix patterns for AWS, GitHub, Stripe,
+  OpenAI, Slack, JWT, SendGrid, plus Shannon entropy-based detection for generic
+  high-entropy tokens near context keywords
+- **Custom patterns:** register your own regex patterns for domain-specific PII
+- **Checksum validation:** IBAN mod-97, Luhn (credit cards/IMEI), and 30+
+  country-specific validators
+- **Priority-aware deduplication:** validated (checksum) > custom > regex-only
+- **Context-aware:** keyword proximity checks and structural detection (JSON field
+  names, CSV headers) for ambiguous patterns
+- **Zero runtime dependencies**
+- **ESM and CommonJS** dual-published
+
+### Supported Countries
+
+| Region | Countries |
+|---|---|
+| Western Europe | AT, BE, CH, DE, FR, LU, NL |
+| Southern Europe | CY, EL, ES, IT, MT, PT |
+| Northern Europe | DK, EE, FI, IS, LT, LV, NO, SE |
+| Eastern Europe | BG, CZ, HR, HU, PL, RO, SI, SK |
+| British Isles | IE, UK |
+
+## API Reference
+
+### Module-Level Functions
+
+#### `redact(text, options?)`
+
+```ts
+function redact(text: string, options?: RedactOptions): RedactResult;
+```
+
+Main entry point. Detects and redacts PII in the given text.
+
+```ts
+interface RedactOptions {
+  countries?: string[] | null; // Country codes (e.g. ["NL", "BE"]) — null loads all
+  referentialIntegrity?: boolean;      // Replace with consistent labels (default: false)
+  detectDates?: boolean;       // Include DOB/date-of-death detections (default: false)
+  cache?: boolean;             // Enable result caching (default: true)
+}
+```
+
+| Parameter | Default | Description |
+|---|---|---|
+| `countries` | `null` | ISO 3166-1 alpha-2 codes to restrict detection. `null` loads all 31 countries. |
+| `referentialIntegrity` | `false` | Replace PII with consistent labels instead of entity-type labels. |
+| `detectDates` | `false` | Include date-of-birth and date-of-death detections. Off by default. |
+| `cache` | `true` | Cache results for identical inputs. |
+
+#### `redactBatch(texts, options?)`
+
+```ts
+function redactBatch(texts: string[], options?: RedactOptions): RedactResult[];
+```
+
+Process multiple texts efficiently. Loads country configs once. Returns results
+in the same order as the input.
+
+#### `addCustomPattern(name, pattern)`
+
+```ts
+function addCustomPattern(name: string, pattern: string): void;
+```
+
+Register a custom regex pattern. Matches are reported with `name` as the entity
+type. See [Custom Patterns](#custom-patterns) below.
+
+#### `availableCountries()`
+
+```ts
+function availableCountries(): string[];
+```
+
+Returns a sorted list of supported ISO country codes.
+
+### Instance-Based API (`EuRedact` Class)
+
+For applications that need isolated instances with separate caches and custom
+pattern registrations:
+
+```ts
+import { EuRedact } from "euredact";
+
+const instance = new EuRedact();
+instance.addCustomPattern("CASE_REF", "CASE-\\d{8}");
+
+const result = instance.redact("See CASE-20260401 for details", {
+  countries: ["NL", "BE"],
+});
+console.log(result.redactedText);
+// "See [CASE_REF] for details"
+```
+
+The `EuRedact` class exposes: `redact()`, `redactBatch()`, and
+`addCustomPattern()`.
+
+### Return Types
+
+#### `RedactResult`
+
+```ts
+interface RedactResult {
+  redactedText: string;       // The input text with PII replaced
+  detections: Detection[];    // All PII spans found
+  source: string;             // Detection backend ("rules")
+  degraded: boolean;          // True if the engine fell back to a simpler mode
+}
+```
+
+#### `Detection`
+
+```ts
+interface Detection {
+  entityType: EntityType | string; // PII category (enum or custom name)
+  start: number;                   // Start offset in the original text
+  end: number;                     // End offset (exclusive)
+  text: string;                    // The matched substring
+  source: DetectionSource;         // "rules" or "cloud"
+  country: string | null;          // ISO code or null for shared/custom patterns
+  confidence: string;              // Confidence level
+}
+```
+
+#### `EntityType`
+
+String enum with all supported PII categories:
+
+```
+NAME              ADDRESS           IBAN              BIC
+CREDIT_CARD       PHONE             EMAIL             DOB
+DATE_OF_DEATH     NATIONAL_ID       SSN               TAX_ID
+PASSPORT          DRIVERS_LICENSE   RESIDENCE_PERMIT  LICENSE_PLATE
+VIN               VAT               POSTAL_CODE       IP_ADDRESS
+IPV6_ADDRESS      MAC_ADDRESS       HEALTH_INSURANCE  HEALTHCARE_PROVIDER
+CHAMBER_OF_COMMERCE  IMEI          GPS_COORDINATES   UUID
+SOCIAL_HANDLE     SECRET            OTHER
+```
+
+For custom patterns, `entityType` is a plain string (e.g. `"EMPLOYEE_ID"`).
+
+## Custom Patterns
+
+Register domain-specific PII patterns at runtime:
+
+```ts
+import { addCustomPattern, redact } from "euredact";
+
+// Register patterns
+addCustomPattern("EMPLOYEE_ID", "EMP-\\d{6}");
+addCustomPattern("CASE_REF", "CASE-\\d{8}");
+
+// They are detected alongside built-in PII
+const result = redact(
+  "Employee EMP-123456, email jan@example.com, ref CASE-20260401"
+);
+console.log(result.redactedText);
+// "Employee [EMPLOYEE_ID], email [EMAIL], ref [CASE_REF]"
+```
+
+### How Custom Patterns Work
+
+- `name` becomes the entity type in detections and replacement tags
+- `pattern` is a JavaScript regular expression (same syntax as `RegExp`)
+- Custom patterns are always active regardless of the `countries` option
+- In overlap resolution, custom patterns have higher priority than built-in
+  regex-only patterns but lower priority than built-in patterns with a passing
+  checksum validator
+
+### Instance Isolation
+
+Custom patterns registered on the module-level function apply to the shared
+singleton. For isolated registrations, use separate `EuRedact` instances:
+
+```ts
+import { EuRedact } from "euredact";
+
+const a = new EuRedact();
+a.addCustomPattern("EMPLOYEE_ID", "EMP-\\d{6}");
+
+const b = new EuRedact();
+b.addCustomPattern("CASE_REF", "CASE-\\d{8}");
+```
+
+## Secret and API Key Detection
+
+Built-in detection for API keys, tokens, and passwords. Always active -- no
+configuration required.
+
+### Known-Prefix Patterns
+
+| Pattern | Description |
+|---|---|
+| `AKIA...` | AWS Access Key ID |
+| `ghp_`, `gho_`, `ghs_`, `github_pat_` | GitHub tokens (PAT, OAuth, app, server) |
+| `sk_live_`, `pk_live_`, `sk_test_`, `pk_test_` | Stripe secret and publishable keys |
+| `sk-`, `sk-ant-` | OpenAI and Anthropic API keys |
+| `xoxb-`, `xoxp-`, `xoxa-`, `xoxs-` | Slack tokens |
+| `eyJ...` (3-part base64url) | JWT tokens |
+| `SG.` | SendGrid API keys |
+
+```ts
+const result = redact("My API key is sk-proj-abc123def456ghi789jkl0");
+console.log(result.redactedText);
+// "My API key is [SECRET]"
+```
+
+### Entropy-Based Detection
+
+High-entropy strings (32+ alphanumeric characters) near context keywords like
+`key`, `token`, `secret`, `password`, `credential`, `auth`, or `bearer`
+(including 12 European language translations) are flagged via Shannon entropy
+analysis:
+
+```ts
+redact("The api_key is xK9mPqR7vLnW2bFjY8cGhT4sDfAeU6iO").redactedText;
+// "The api_key is [SECRET]"
+
+// Without a context keyword -- not flagged:
+redact("identifier: xK9mPqR7vLnW2bFjY8cGhT4sDfAeU6iO").redactedText;
+// "identifier: xK9mPqR7vLnW2bFjY8cGhT4sDfAeU6iO"
+```
+
+## Country Hints
+
+When you know which countries appear in your data, pass them explicitly:
+
+```ts
+const result = redact(text, { countries: ["NL", "BE"] });
+```
+
+This restricts pattern matching to Dutch and Belgian rules (plus shared patterns
+and custom patterns). Benefits:
+
+- **Fewer false positives.** A 9-digit number that passes the Dutch BSN checksum
+  won't also be tested against unrelated country patterns.
+- **Faster.** Fewer patterns to compile and scan.
+
+## Referential Integrity
+
+When `referentialIntegrity: true`, each unique PII value is mapped to a consistent
+label:
+
+```ts
+const result = redact(
+  "BSN 123456782 en later weer 123456782",
+  { countries: ["NL"], referentialIntegrity: true }
+);
+console.log(result.redactedText);
+// "BSN NATIONAL_ID_1 en later weer NATIONAL_ID_1"
+```
+
+## Architecture
+
+```
+Input text
+    |
+    v
+[Normalizer] -- Unicode normalization, whitespace cleanup
+    |
+    v
+[Pass 1: Pattern Matching] -- All country + shared + custom regexes
+    |
+    v
+[Pass 2a: Validation] -- Checksum validators (mod-97, Luhn, entropy, ...)
+    |                     Failed-validation spans become suppression zones
+    v
+[Pass 2b: Suppression] -- Remove false positives (currency amounts, units,
+    |                      references, overlapping matches in suppression zones)
+    v
+[Deduplication] -- Priority-aware: validated > custom > regex-only
+    |               Within same tier, longer span wins
+    v
+[Replacement] -- Right-to-left substitution with [ENTITY_TYPE] labels
+    |              or labels
+    v
+RedactResult
+```
+
+### Suppression Zones
+
+When a regex matches a pattern that has a checksum validator but the checksum
+fails, the matched span becomes a "suppression zone." Any purely regex-based
+detection fully contained within that zone is suppressed as a false positive.
+
+### Deduplication Priority
+
+1. **Validated patterns** (checksum passes) -- highest priority
+2. **Custom patterns** (registered via `addCustomPattern()`)
+3. **Regex-only patterns** (no validator) -- lowest priority
+
+Within the same tier, the longer span wins.
+
+## CommonJS
+
+```js
+const { redact } = require("euredact");
 ```
 
-## Links
+## Performance
 
-- **Website:** [euredact.eu](https://euredact.eu)
-- **Docs:** [docs.euredact.dev](https://docs.euredact.dev)
-- **GitHub:** [github.com/euredact/euredact](https://github.com/euredact/euredact)
-- **PyPI:** [pypi.org/project/euredact](https://pypi.org/project/euredact)
+| Metric | Value |
+|---|---|
+| Latency per redaction | ~0.02 ms |
+| Package size | ~86 KB |
+| Runtime dependencies | 0 |
 
 ## License
 
-Apache 2.0
+Apache-2.0

package/dist/cjs/cache.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResultCache = void 0;
+// Simple hash function (FNV-1a) - no crypto dependency needed for cache keys
+function fnv1aHash(str) {
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        hash = (hash * 0x01000193) >>> 0;
+    }
+    return hash.toString(16).padStart(8, "0");
+}
+class ResultCache {
+    maxsize;
+    enabled;
+    store = new Map();
+    constructor(maxsize = 1024, enabled = true) {
+        this.maxsize = maxsize;
+        this.enabled = enabled;
+    }
+    key(text, countries, mode) {
+        const sorted = [...countries].sort();
+        const raw = `${text}|${sorted.join("|")}|${mode}`;
+        // Use multiple FNV-1a hashes on different slices for reduced collisions
+        const h1 = fnv1aHash(raw);
+        const h2 = fnv1aHash(raw.slice(Math.floor(raw.length / 2)) + raw.slice(0, Math.floor(raw.length / 2)));
+        return h1 + h2;
+    }
+    get(key) {
+        if (!this.enabled)
+            return null;
+        const result = this.store.get(key);
+        if (result !== undefined) {
+            // Move to end (LRU)
+            this.store.delete(key);
+            this.store.set(key, result);
+            return result;
+        }
+        return null;
+    }
+    put(key, result) {
+        if (!this.enabled)
+            return;
+        this.store.delete(key);
+        this.store.set(key, result);
+        while (this.store.size > this.maxsize) {
+            const first = this.store.keys().next().value;
+            if (first !== undefined)
+                this.store.delete(first);
+        }
+    }
+    clear() {
+        this.store.clear();
+    }
+}
+exports.ResultCache = ResultCache;

package/dist/cjs/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COUNTRY_CONFIGS = exports.EuRedact = exports.DetectionSource = exports.EntityType = void 0;
+exports.availableCountries = availableCountries;
+exports.redact = redact;
+exports.addCustomPattern = addCustomPattern;
+exports.redactBatch = redactBatch;
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "EntityType", { enumerable: true, get: function () { return types_js_1.EntityType; } });
+Object.defineProperty(exports, "DetectionSource", { enumerable: true, get: function () { return types_js_1.DetectionSource; } });
+var sdk_js_1 = require("./sdk.js");
+Object.defineProperty(exports, "EuRedact", { enumerable: true, get: function () { return sdk_js_1.EuRedact; } });
+var index_js_1 = require("./rules/countries/index.js");
+Object.defineProperty(exports, "COUNTRY_CONFIGS", { enumerable: true, get: function () { return index_js_1.COUNTRY_CONFIGS; } });
+const sdk_js_2 = require("./sdk.js");
+const index_js_2 = require("./rules/countries/index.js");
+let _instance = null;
+function getInstance() {
+    if (_instance === null)
+        _instance = new sdk_js_2.EuRedact();
+    return _instance;
+}
+function availableCountries() {
+    return Object.keys(index_js_2.COUNTRY_CONFIGS).filter(c => c !== "SHARED").sort();
+}
+function redact(text, options) {
+    return getInstance().redact(text, options);
+}
+function addCustomPattern(name, pattern) {
+    getInstance().addCustomPattern(name, pattern);
+}
+function redactBatch(texts, options) {
+    return getInstance().redactBatch(texts, options);
+}

package/dist/cjs/normalizer.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize = normalize;
+exports.mapOffsetToOriginal = mapOffsetToOriginal;
+function normalize(text) {
+    const normalized = text.normalize("NFC");
+    if (normalized.length === text.length)
+        return [normalized, null];
+    return [normalized, buildOffsetMapping(text, normalized)];
+}
+function buildOffsetMapping(original, normalized) {
+    const nfdOriginal = original.normalize("NFD");
+    const nfdNormalized = normalized.normalize("NFD");
+    // Build: normalized index -> original index via NFD as intermediate
+    const normToOrig = [];
+    for (let normIdx = 0; normIdx < normalized.length; normIdx++) {
+        const nfdOfNormChar = normalized[normIdx].normalize("NFD");
+        let nfdStart = 0;
+        for (let i = 0; i < normIdx; i++) {
+            nfdStart += normalized[i].normalize("NFD").length;
+        }
+        let targetOrig = 0;
+        let running = 0;
+        for (let oi = 0; oi < original.length; oi++) {
+            const nfdOc = original[oi].normalize("NFD");
+            if (running + nfdOc.length > nfdStart) {
+                targetOrig = oi;
+                break;
+            }
+            running += nfdOc.length;
+        }
+        normToOrig.push(targetOrig);
+    }
+    return normToOrig;
+}
+function mapOffsetToOriginal(offset, mapping) {
+    if (mapping === null)
+        return offset;
+    if (offset >= mapping.length) {
+        if (mapping.length > 0)
+            return mapping[mapping.length - 1] + (offset - mapping.length + 1);
+        return offset;
+    }
+    return mapping[offset];
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}