euredact 0.0.1 → 0.2.0

package/dist/cjs/sdk.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EuRedact = void 0;
+const cache_js_1 = require("./cache.js");
+const normalizer_js_1 = require("./normalizer.js");
+const engine_js_1 = require("./rules/engine.js");
+const types_js_1 = require("./types.js");
+const DATE_TYPES = new Set([types_js_1.EntityType.DOB, types_js_1.EntityType.DATE_OF_DEATH]);
+class ReferentialMapper {
+    counters = new Map();
+    mapping = new Map();
+    getLabel(text, entityType) {
+        if (!this.mapping.has(text)) {
+            const count = (this.counters.get(entityType) ?? 0) + 1;
+            this.counters.set(entityType, count);
+            this.mapping.set(text, `${entityType}_${count}`);
+        }
+        return this.mapping.get(text);
+    }
+}
+class EuRedact {
+    engine = new engine_js_1.RuleEngine();
+    cache = new cache_js_1.ResultCache();
+    referentialMapper = new ReferentialMapper();
+    addCustomPattern(name, pattern) {
+        this.engine.addCustomPattern(name, pattern);
+        this.cache.clear();
+    }
+    redact(text, options = {}) {
+        const { countries = null, mode = "rules", referentialIntegrity = false, detectDates = false, cache = true, } = options;
+        const [normalizedText, offsetMapping] = (0, normalizer_js_1.normalize)(text);
+        const countriesTuple = countries
+            ? countries.map(c => c.toUpperCase()).sort()
+            : ["ALL"];
+        const cacheMode = `${mode}|dates=${detectDates}`;
+        let cacheKey;
+        if (cache) {
+            cacheKey = this.cache.key(normalizedText, countriesTuple, cacheMode);
+            const cached = this.cache.get(cacheKey);
+            if (cached !== null)
+                return cached;
+        }
+        let detections = this.engine.detect(normalizedText, countries);
+        if (offsetMapping !== null) {
+            detections = detections.map(d => ({
+                ...d,
+                start: (0, normalizer_js_1.mapOffsetToOriginal)(d.start, offsetMapping),
+                end: (0, normalizer_js_1.mapOffsetToOriginal)(d.end, offsetMapping),
+            }));
+        }
+        if (!detectDates) {
+            detections = detections.filter(d => !DATE_TYPES.has(d.entityType));
+        }
+        detections.sort((a, b) => a.start - b.start || b.end - a.end);
+        let redacted = text;
+        for (let i = detections.length - 1; i >= 0; i--) {
+            const det = detections[i];
+            const replacement = referentialIntegrity
+                ? this.referentialMapper.getLabel(det.text, det.entityType)
+                : `[${det.entityType}]`;
+            redacted = redacted.slice(0, det.start) + replacement + redacted.slice(det.end);
+        }
+        const result = {
+            redactedText: redacted,
+            detections,
+            source: "rules",
+            degraded: false,
+        };
+        if (cache && cacheKey) {
+            this.cache.put(cacheKey, result);
+        }
+        return result;
+    }
+    redactBatch(texts, options = {}) {
+        const countries = options.countries ?? null;
+        this.engine.loadCountries(countries ? countries.map(c => c.toUpperCase()) : null);
+        return texts.map(text => this.redact(text, options));
+    }
+}
+exports.EuRedact = EuRedact;

package/dist/cjs/types.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DetectionSource = exports.EntityType = void 0;
+var EntityType;
+(function (EntityType) {
+    EntityType["NAME"] = "NAME";
+    EntityType["ADDRESS"] = "ADDRESS";
+    EntityType["IBAN"] = "IBAN";
+    EntityType["BIC"] = "BIC";
+    EntityType["CREDIT_CARD"] = "CREDIT_CARD";
+    EntityType["PHONE"] = "PHONE";
+    EntityType["EMAIL"] = "EMAIL";
+    EntityType["DOB"] = "DOB";
+    EntityType["DATE_OF_DEATH"] = "DATE_OF_DEATH";
+    EntityType["NATIONAL_ID"] = "NATIONAL_ID";
+    EntityType["SSN"] = "SSN";
+    EntityType["TAX_ID"] = "TAX_ID";
+    EntityType["PASSPORT"] = "PASSPORT";
+    EntityType["DRIVERS_LICENSE"] = "DRIVERS_LICENSE";
+    EntityType["RESIDENCE_PERMIT"] = "RESIDENCE_PERMIT";
+    EntityType["LICENSE_PLATE"] = "LICENSE_PLATE";
+    EntityType["VIN"] = "VIN";
+    EntityType["VAT"] = "VAT";
+    EntityType["POSTAL_CODE"] = "POSTAL_CODE";
+    EntityType["IP_ADDRESS"] = "IP_ADDRESS";
+    EntityType["IPV6_ADDRESS"] = "IPV6_ADDRESS";
+    EntityType["MAC_ADDRESS"] = "MAC_ADDRESS";
+    EntityType["HEALTH_INSURANCE"] = "HEALTH_INSURANCE";
+    EntityType["HEALTHCARE_PROVIDER"] = "HEALTHCARE_PROVIDER";
+    EntityType["CHAMBER_OF_COMMERCE"] = "CHAMBER_OF_COMMERCE";
+    EntityType["IMEI"] = "IMEI";
+    EntityType["GPS_COORDINATES"] = "GPS_COORDINATES";
+    EntityType["UUID"] = "UUID";
+    EntityType["SOCIAL_HANDLE"] = "SOCIAL_HANDLE";
+    EntityType["SECRET"] = "SECRET";
+    EntityType["OTHER"] = "OTHER";
+})(EntityType || (exports.EntityType = EntityType = {}));
+var DetectionSource;
+(function (DetectionSource) {
+    DetectionSource["RULES"] = "rules";
+    DetectionSource["CLOUD"] = "cloud";
+})(DetectionSource || (exports.DetectionSource = DetectionSource = {}));

package/dist/esm/cache.d.ts

@@ -0,0 +1,11 @@
+import type { RedactResult } from "./types.js";
+export declare class ResultCache {
+    private maxsize;
+    private enabled;
+    private store;
+    constructor(maxsize?: number, enabled?: boolean);
+    key(text: string, countries: string[], mode: string): string;
+    get(key: string): RedactResult | null;
+    put(key: string, result: RedactResult): void;
+    clear(): void;
+}

package/dist/esm/cache.js

@@ -0,0 +1,52 @@
+// 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");
+}
+export 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();
+    }
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,10 @@
+export { EntityType, DetectionSource } from "./types.js";
+export type { Detection, RedactResult, PatternDef, CountryConfig } from "./types.js";
+export { EuRedact, type RedactOptions } from "./sdk.js";
+export { COUNTRY_CONFIGS } from "./rules/countries/index.js";
+import { type RedactOptions } from "./sdk.js";
+import type { RedactResult } from "./types.js";
+export declare function availableCountries(): string[];
+export declare function redact(text: string, options?: RedactOptions): RedactResult;
+export declare function addCustomPattern(name: string, pattern: string): void;
+export declare function redactBatch(texts: string[], options?: RedactOptions): RedactResult[];

package/dist/esm/index.js

@@ -0,0 +1,23 @@
+export { EntityType, DetectionSource } from "./types.js";
+export { EuRedact } from "./sdk.js";
+export { COUNTRY_CONFIGS } from "./rules/countries/index.js";
+import { EuRedact } from "./sdk.js";
+import { COUNTRY_CONFIGS } from "./rules/countries/index.js";
+let _instance = null;
+function getInstance() {
+    if (_instance === null)
+        _instance = new EuRedact();
+    return _instance;
+}
+export function availableCountries() {
+    return Object.keys(COUNTRY_CONFIGS).filter(c => c !== "SHARED").sort();
+}
+export function redact(text, options) {
+    return getInstance().redact(text, options);
+}
+export function addCustomPattern(name, pattern) {
+    getInstance().addCustomPattern(name, pattern);
+}
+export function redactBatch(texts, options) {
+    return getInstance().redactBatch(texts, options);
+}

package/dist/esm/normalizer.d.ts

@@ -0,0 +1,2 @@
+export declare function normalize(text: string): [string, number[] | null];
+export declare function mapOffsetToOriginal(offset: number, mapping: number[] | null): number;

package/dist/esm/normalizer.js

@@ -0,0 +1,41 @@
+export 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;
+}
+export 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/esm/rules/countries/index.d.ts

@@ -0,0 +1,2 @@
+import { type CountryConfig } from "../../types.js";
+export declare const COUNTRY_CONFIGS: Record<string, CountryConfig>;