openred 0.2.0

package/dist/chunk-65T2K4W6.js

@@ -0,0 +1,629 @@
+import { createHash } from 'crypto';
+
+// src/aggregator.ts
+var DEFAULT_CONFIG = {
+  overlapResolution: "highest-confidence",
+  minConfidence: 0,
+  mergeAdjacent: false
+};
+function aggregate(matches, config = {}) {
+  const { overlapResolution, minConfidence, mergeAdjacent } = {
+    ...DEFAULT_CONFIG,
+    ...config
+  };
+  let filtered = minConfidence > 0 ? matches.filter((m) => m.confidence >= minConfidence) : [...matches];
+  filtered.sort((a, b) => a.start - b.start || b.confidence - a.confidence);
+  const resolved = [];
+  for (const match of filtered) {
+    const prev = resolved[resolved.length - 1];
+    if (prev && match.start < prev.end) {
+      const winner = pickWinner(prev, match, overlapResolution);
+      resolved[resolved.length - 1] = winner;
+      continue;
+    }
+    resolved.push(match);
+  }
+  if (mergeAdjacent) {
+    return mergeAdjacentMatches(resolved);
+  }
+  return resolved;
+}
+function pickWinner(a, b, strategy) {
+  switch (strategy) {
+    case "longest": {
+      const lenA = a.end - a.start;
+      const lenB = b.end - b.start;
+      return lenB > lenA ? b : a;
+    }
+    case "highest-confidence":
+      return b.confidence > a.confidence ? b : a;
+    case "first":
+      return a;
+  }
+}
+function mergeAdjacentMatches(matches) {
+  if (matches.length <= 1) return matches;
+  const merged = [matches[0]];
+  for (let i = 1; i < matches.length; i++) {
+    const prev = merged[merged.length - 1];
+    const curr = matches[i];
+    if (prev.type === curr.type && curr.start - prev.end <= 2) {
+      merged[merged.length - 1] = {
+        ...prev,
+        end: curr.end,
+        value: prev.value + " " + curr.value,
+        // approximate
+        confidence: Math.min(prev.confidence, curr.confidence)
+      };
+    } else {
+      merged.push(curr);
+    }
+  }
+  return merged;
+}
+
+// src/detectors/email.ts
+var EMAIL_RE = /[a-zA-Z][a-zA-Z0-9._%+-]*@[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?)*\.[a-zA-Z]{2,}/g;
+var FILE_EXT_RE = /\.(png|jpg|jpeg|gif|svg|webp|ico|bmp|tiff|pdf|zip|tar|gz|js|ts|css|html|xml|json|yaml|yml|md|txt|csv|log|sh|py|rb|exe|dll|so|wasm)$/i;
+var EmailDetector = {
+  name: "email",
+  type: "EMAIL",
+  confidence: "high",
+  detect(text) {
+    const matches = [];
+    EMAIL_RE.lastIndex = 0;
+    let match;
+    while ((match = EMAIL_RE.exec(text)) !== null) {
+      const value = match[0];
+      if (FILE_EXT_RE.test(value)) continue;
+      matches.push({
+        type: "EMAIL",
+        value,
+        start: match.index,
+        end: match.index + value.length,
+        confidence: 0.95,
+        detector: "email"
+      });
+    }
+    return matches;
+  }
+};
+
+// src/utils/validation.ts
+function luhnCheck(digits) {
+  let sum = 0;
+  let alternate = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let n = parseInt(digits[i], 10);
+    if (alternate) {
+      n *= 2;
+      if (n > 9) n -= 9;
+    }
+    sum += n;
+    alternate = !alternate;
+  }
+  return sum % 10 === 0;
+}
+function countDigits(s) {
+  return (s.match(/\d/g) || []).length;
+}
+function stripNonDigits(s) {
+  return s.replace(/\D/g, "");
+}
+
+// src/detectors/phone.ts
+var PHONE_RE = /(?:\+\d{1,3}[\s.-]?)\(?\d{2,4}\)?[\s.-]?\d{3,4}[\s.-]?\d{3,4}|(?:\(?\d{2,4}\)?[\s.-])\d{3,4}[\s.-]?\d{3,4}|\(?\d{2,4}\)?[\s.-]?\d{3,4}[\s.-]\d{3,4}/g;
+function hasSeparator(s) {
+  return /[.\s()-]/.test(s);
+}
+var PhoneDetector = {
+  name: "phone",
+  type: "PHONE",
+  confidence: "high",
+  detect(text) {
+    const matches = [];
+    PHONE_RE.lastIndex = 0;
+    let match;
+    while ((match = PHONE_RE.exec(text)) !== null) {
+      const value = match[0];
+      const digits = countDigits(value);
+      if (digits < 7 || digits > 15) continue;
+      if (!hasSeparator(value) && !value.startsWith("+")) continue;
+      if (match.index > 0 && text[match.index - 1] === "#") continue;
+      const conf = value.startsWith("+") ? 0.95 : hasSeparator(value) ? 0.85 : 0.6;
+      matches.push({
+        type: "PHONE",
+        value,
+        start: match.index,
+        end: match.index + value.length,
+        confidence: conf,
+        detector: "phone"
+      });
+    }
+    return matches;
+  }
+};
+
+// src/detectors/ssn.ts
+var SSN_RE = /\b(\d{3})[-\s](\d{2})[-\s](\d{4})\b/g;
+function isValidSSN(area, group, serial) {
+  const areaNum = parseInt(area, 10);
+  if (areaNum === 0 || areaNum === 666 || areaNum >= 900) return false;
+  if (parseInt(group, 10) === 0) return false;
+  if (parseInt(serial, 10) === 0) return false;
+  return true;
+}
+var SSNDetector = {
+  name: "ssn",
+  type: "SSN",
+  confidence: "high",
+  detect(text) {
+    const matches = [];
+    SSN_RE.lastIndex = 0;
+    let match;
+    while ((match = SSN_RE.exec(text)) !== null) {
+      if (!isValidSSN(match[1], match[2], match[3])) continue;
+      matches.push({
+        type: "SSN",
+        value: match[0],
+        start: match.index,
+        end: match.index + match[0].length,
+        confidence: 0.9,
+        detector: "ssn"
+      });
+    }
+    return matches;
+  }
+};
+
+// src/detectors/credit-card.ts
+var CC_SEPARATED_RE = /\d{4}[ -]\d{4}[ -]\d{4}[ -]\d{1,7}|\d{4}[ -]\d{6}[ -]\d{5}/g;
+var CC_BARE_RE = /\b\d{13,19}\b/g;
+function isKnownPrefix(digits) {
+  const first = parseInt(digits[0], 10);
+  return first >= 3 && first <= 6;
+}
+function isPrecededByIdMarker(text, index) {
+  const before = text.slice(Math.max(0, index - 10), index).trimEnd();
+  return /[#]$/.test(before) || /\bID\s*:?\s*$/.test(before) || /\bNo\.?\s*$/.test(before);
+}
+function validateMatch(text, match, isSeparated) {
+  const value = match[0].trim();
+  const digits = stripNonDigits(value);
+  if (digits.length < 13 || digits.length > 19) return null;
+  if (!isKnownPrefix(digits)) return null;
+  if (!luhnCheck(digits)) return null;
+  return {
+    type: "CREDIT_CARD",
+    value,
+    start: match.index,
+    end: match.index + value.length,
+    confidence: isSeparated ? 0.95 : 0.8,
+    detector: "credit-card"
+  };
+}
+var CreditCardDetector = {
+  name: "credit-card",
+  type: "CREDIT_CARD",
+  confidence: "high",
+  detect(text) {
+    const matches = [];
+    let match;
+    CC_SEPARATED_RE.lastIndex = 0;
+    while ((match = CC_SEPARATED_RE.exec(text)) !== null) {
+      const m = validateMatch(text, match, true);
+      if (m) matches.push(m);
+    }
+    CC_BARE_RE.lastIndex = 0;
+    while ((match = CC_BARE_RE.exec(text)) !== null) {
+      if (isPrecededByIdMarker(text, match.index)) continue;
+      const m = validateMatch(text, match, false);
+      if (m) matches.push(m);
+    }
+    return matches;
+  }
+};
+
+// src/detectors/ip-address.ts
+var IPV4_RE = /\b(?:(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d\d?)\b/g;
+var IPV6_RE = /\b(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\b|(?:[0-9a-fA-F]{1,4}:){1,7}:|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}/g;
+function isPrivateIPv4(ip) {
+  const parts = ip.split(".").map(Number);
+  if (parts[0] === 127) return true;
+  if (parts[0] === 10) return true;
+  if (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) return true;
+  if (parts[0] === 192 && parts[1] === 168) return true;
+  return false;
+}
+var IPAddressDetector = {
+  name: "ip-address",
+  type: "IP_ADDRESS",
+  confidence: "high",
+  detect(text) {
+    const matches = [];
+    let match;
+    IPV4_RE.lastIndex = 0;
+    while ((match = IPV4_RE.exec(text)) !== null) {
+      if (isPrivateIPv4(match[0])) continue;
+      matches.push({
+        type: "IP_ADDRESS",
+        value: match[0],
+        start: match.index,
+        end: match.index + match[0].length,
+        confidence: 0.9,
+        detector: "ip-address"
+      });
+    }
+    IPV6_RE.lastIndex = 0;
+    while ((match = IPV6_RE.exec(text)) !== null) {
+      if (match[0] === "::1") continue;
+      matches.push({
+        type: "IP_ADDRESS",
+        value: match[0],
+        start: match.index,
+        end: match.index + match[0].length,
+        confidence: 0.9,
+        detector: "ip-address"
+      });
+    }
+    return matches;
+  }
+};
+
+// src/detectors/url.ts
+var URL_RE = /https?:\/\/[^\s<>"{}|\\^`\[\]]+/g;
+var URLDetector = {
+  name: "url",
+  type: "URL",
+  confidence: "high",
+  detect(text) {
+    const matches = [];
+    URL_RE.lastIndex = 0;
+    let match;
+    while ((match = URL_RE.exec(text)) !== null) {
+      let value = match[0].replace(/[.,;:!?)]+$/, "");
+      matches.push({
+        type: "URL",
+        value,
+        start: match.index,
+        end: match.index + value.length,
+        confidence: 0.95,
+        detector: "url"
+      });
+    }
+    return matches;
+  }
+};
+
+// src/detectors/date-of-birth.ts
+var DATE_NUMERIC_RE = /\b(?:0?[1-9]|1[0-2])[\/\-.](?:0?[1-9]|[12]\d|3[01])[\/\-.](?:19|20)\d{2}\b|\b(?:19|20)\d{2}[\/\-.](?:0?[1-9]|1[0-2])[\/\-.](?:0?[1-9]|[12]\d|3[01])\b/g;
+var MONTHS = "(?:Jan(?:uary)?|Feb(?:ruary)?|Mar(?:ch)?|Apr(?:il)?|May|Jun(?:e)?|Jul(?:y)?|Aug(?:ust)?|Sep(?:tember)?|Oct(?:ober)?|Nov(?:ember)?|Dec(?:ember)?)";
+var DATE_WRITTEN_RE = new RegExp(
+  `\\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`,
+  "gi"
+);
+var DOB_CONTEXT_RE = /\b(?:born|birth|birthday|dob|date\s+of\s+birth|d\.o\.b)\b/i;
+var DateOfBirthDetector = {
+  name: "date-of-birth",
+  type: "DATE_OF_BIRTH",
+  confidence: "medium",
+  detect(text) {
+    const matches = [];
+    const hasContext = DOB_CONTEXT_RE.test(text);
+    for (const regex of [DATE_NUMERIC_RE, DATE_WRITTEN_RE]) {
+      regex.lastIndex = 0;
+      let match;
+      while ((match = regex.exec(text)) !== null) {
+        const start = Math.max(0, match.index - 50);
+        const end = Math.min(text.length, match.index + match[0].length + 50);
+        const localContext = text.slice(start, end);
+        const localHasContext = DOB_CONTEXT_RE.test(localContext);
+        if (!hasContext && !localHasContext) continue;
+        matches.push({
+          type: "DATE_OF_BIRTH",
+          value: match[0],
+          start: match.index,
+          end: match.index + match[0].length,
+          confidence: localHasContext ? 0.85 : 0.5,
+          detector: "date-of-birth"
+        });
+      }
+    }
+    return matches;
+  }
+};
+
+// src/detectors/address.ts
+var STREET_RE = /\b\d{1,6}\s+(?:[NSEW]\.?\s+)?[A-Z][a-zA-Z]+(?:\s+[A-Z][a-zA-Z]+)*\s+(?:St(?:reet)?|Ave(?:nue)?|Blvd|Boulevard|Dr(?:ive)?|Ln|Lane|Rd|Road|Ct|Court|Pl(?:ace)?|Way|Cir(?:cle)?|Pkwy|Parkway|Ter(?:race)?|Hwy|Highway)\.?\b/g;
+var ZIP_RE = /\b\d{5}(?:-\d{4})?\b/g;
+var ADDRESS_CONTEXT_RE = /\b(?:address|live[sd]?\s+(?:at|on)|located\s+at|ship(?:ping)?\s+to|deliver\s+to|reside[sd]?\s+at|mailing)\b/i;
+var AddressDetector = {
+  name: "address",
+  type: "ADDRESS",
+  confidence: "medium",
+  detect(text) {
+    const matches = [];
+    STREET_RE.lastIndex = 0;
+    let match;
+    while ((match = STREET_RE.exec(text)) !== null) {
+      matches.push({
+        type: "ADDRESS",
+        value: match[0],
+        start: match.index,
+        end: match.index + match[0].length,
+        confidence: 0.8,
+        detector: "address"
+      });
+    }
+    const hasContext = ADDRESS_CONTEXT_RE.test(text);
+    if (hasContext) {
+      ZIP_RE.lastIndex = 0;
+      while ((match = ZIP_RE.exec(text)) !== null) {
+        const isPartOfStreet = matches.some(
+          (m) => match.index >= m.start && match.index < m.end
+        );
+        if (isPartOfStreet) continue;
+        matches.push({
+          type: "ADDRESS",
+          value: match[0],
+          start: match.index,
+          end: match.index + match[0].length,
+          confidence: 0.6,
+          detector: "address"
+        });
+      }
+    }
+    return matches;
+  }
+};
+
+// src/detectors/index.ts
+var allDetectors = [
+  EmailDetector,
+  PhoneDetector,
+  SSNDetector,
+  CreditCardDetector,
+  IPAddressDetector,
+  URLDetector,
+  DateOfBirthDetector,
+  AddressDetector
+];
+
+// src/strategies/placeholder.ts
+function createPlaceholderStrategy() {
+  const counters = /* @__PURE__ */ new Map();
+  const valueToToken = /* @__PURE__ */ new Map();
+  return (match) => {
+    const existing = valueToToken.get(match.value);
+    if (existing) return existing;
+    const count = (counters.get(match.type) ?? 0) + 1;
+    counters.set(match.type, count);
+    const token = `[${match.type}_${count}]`;
+    valueToToken.set(match.value, token);
+    return token;
+  };
+}
+function shortHash(value) {
+  return createHash("sha256").update(value).digest("hex").slice(0, 8);
+}
+var hashStrategy = (match) => {
+  return shortHash(match.value);
+};
+
+// src/strategies/mask.ts
+function maskEmail(value) {
+  const [local, domain] = value.split("@");
+  if (!domain) return "\u2588\u2588\u2588\u2588";
+  const maskedLocal = local[0] + "\u2588\u2588\u2588";
+  const domainParts = domain.split(".");
+  const maskedDomain = domainParts[0][0] + "\u2588\u2588\u2588." + domainParts.slice(1).join(".");
+  return maskedLocal + "@" + maskedDomain;
+}
+function maskPhone(value) {
+  const digits = value.replace(/\D/g, "");
+  const last4 = digits.slice(-4);
+  return "\u2588".repeat(digits.length - 4) + last4;
+}
+function maskSSN(value) {
+  return "\u2588\u2588\u2588-\u2588\u2588-" + value.slice(-4);
+}
+function maskCreditCard(value) {
+  const digits = value.replace(/\D/g, "");
+  const last4 = digits.slice(-4);
+  return "\u2588\u2588\u2588\u2588-\u2588\u2588\u2588\u2588-\u2588\u2588\u2588\u2588-" + last4;
+}
+function maskGeneric(value) {
+  if (value.length <= 4) return "\u2588\u2588\u2588\u2588";
+  return value[0] + "\u2588".repeat(value.length - 2) + value[value.length - 1];
+}
+var MASKERS = {
+  EMAIL: maskEmail,
+  PHONE: maskPhone,
+  SSN: maskSSN,
+  CREDIT_CARD: maskCreditCard
+};
+var maskStrategy = (match) => {
+  const masker = MASKERS[match.type] ?? maskGeneric;
+  return masker(match.value);
+};
+
+// src/strategies/category.ts
+var categoryStrategy = (match) => {
+  return `[${match.type}]`;
+};
+
+// src/strategies/index.ts
+function resolveStrategy(strategy) {
+  if (typeof strategy === "function") return strategy;
+  switch (strategy ?? "placeholder") {
+    case "placeholder":
+      return createPlaceholderStrategy();
+    case "hash":
+      return hashStrategy;
+    case "mask":
+      return maskStrategy;
+    case "category":
+      return categoryStrategy;
+    default:
+      throw new Error(`Unknown strategy: ${strategy}`);
+  }
+}
+
+// src/vault.ts
+var Vault = class {
+  replacementToOriginal = /* @__PURE__ */ new Map();
+  originalToReplacement = /* @__PURE__ */ new Map();
+  ttl;
+  timers = [];
+  constructor(options) {
+    this.ttl = options?.ttl;
+  }
+  store(original, replacement, type) {
+    this.replacementToOriginal.set(replacement, { original, replacement, type });
+    this.originalToReplacement.set(original, replacement);
+    if (this.ttl && this.ttl > 0) {
+      const timer = setTimeout(() => {
+        this.replacementToOriginal.delete(replacement);
+        this.originalToReplacement.delete(original);
+      }, this.ttl);
+      this.timers.push(timer);
+    }
+  }
+  getReplacementFor(original) {
+    return this.originalToReplacement.get(original);
+  }
+  restore(text) {
+    let result = text;
+    const entries = [...this.replacementToOriginal.values()].sort(
+      (a, b) => b.replacement.length - a.replacement.length
+    );
+    for (const entry of entries) {
+      while (result.includes(entry.replacement)) {
+        result = result.replace(entry.replacement, entry.original);
+      }
+    }
+    return result;
+  }
+  getMapping() {
+    return new Map(this.replacementToOriginal);
+  }
+  getEntries() {
+    return [...this.replacementToOriginal.values()];
+  }
+  clear() {
+    this.replacementToOriginal.clear();
+    this.originalToReplacement.clear();
+    for (const timer of this.timers) clearTimeout(timer);
+    this.timers = [];
+  }
+  export() {
+    return JSON.stringify([...this.replacementToOriginal.entries()]);
+  }
+  import(data) {
+    const entries = JSON.parse(data);
+    for (const [key, entry] of entries) {
+      this.replacementToOriginal.set(key, entry);
+      this.originalToReplacement.set(entry.original, entry.replacement);
+    }
+  }
+};
+
+// src/pipeline.ts
+var RedactionPipeline = class {
+  detectors;
+  strategyFn;
+  vault;
+  config;
+  constructor(config = {}) {
+    this.config = {
+      detectors: config.detectors ?? allDetectors,
+      ...config
+    };
+    this.detectors = this.config.detectors;
+    this.strategyFn = resolveStrategy(this.config.strategy);
+    this.vault = this.config.vault ? new Vault({ ttl: this.config.vaultTTL }) : null;
+  }
+  addDetector(detector) {
+    this.detectors.push(detector);
+  }
+  redact(text) {
+    const startTime = performance.now();
+    const context = { locale: this.config.locale };
+    let rawMatches = [];
+    for (const detector of this.detectors) {
+      rawMatches.push(...detector.detect(text, context));
+    }
+    if (this.config.onDetection) {
+      for (const match of rawMatches) {
+        this.config.onDetection(match);
+      }
+    }
+    const matches = aggregate(rawMatches, {
+      overlapResolution: this.config.overlapResolution ?? "highest-confidence",
+      minConfidence: this.config.minConfidence ?? 0,
+      mergeAdjacent: false
+    });
+    const finalMatches = this.applyLists(matches);
+    const tokens = [];
+    let result = "";
+    let cursor = 0;
+    for (const match of finalMatches) {
+      result += text.slice(cursor, match.start);
+      let replacement;
+      if (this.vault) {
+        const existing = this.vault.getReplacementFor(match.value);
+        if (existing) {
+          replacement = existing;
+        } else {
+          replacement = this.strategyFn(match);
+          this.vault.store(match.value, replacement, match.type);
+        }
+      } else {
+        replacement = this.strategyFn(match);
+      }
+      result += replacement;
+      tokens.push({
+        original: match.value,
+        replacement,
+        type: match.type,
+        confidence: match.confidence
+      });
+      cursor = match.end;
+    }
+    result += text.slice(cursor);
+    const byType = {};
+    for (const match of finalMatches) {
+      byType[match.type] = (byType[match.type] ?? 0) + 1;
+    }
+    const redactionResult = {
+      text: result,
+      matches: finalMatches,
+      tokens,
+      stats: {
+        totalDetected: finalMatches.length,
+        byType,
+        processingTimeMs: performance.now() - startTime
+      }
+    };
+    if (this.config.onRedaction) {
+      this.config.onRedaction(redactionResult);
+    }
+    return redactionResult;
+  }
+  /** Get the vault instance (only available if vault: true). */
+  getVault() {
+    return this.vault;
+  }
+  applyLists(matches) {
+    const allowList = this.config.allowList;
+    this.config.denyList;
+    let result = matches;
+    if (allowList && allowList.length > 0) {
+      const allowSet = new Set(allowList.map((s) => s.toLowerCase()));
+      result = result.filter((m) => !allowSet.has(m.value.toLowerCase()));
+    }
+    return result;
+  }
+};
+
+export { AddressDetector, CreditCardDetector, DateOfBirthDetector, EmailDetector, IPAddressDetector, PhoneDetector, RedactionPipeline, SSNDetector, URLDetector, Vault, aggregate, allDetectors, categoryStrategy, countDigits, createPlaceholderStrategy, hashStrategy, maskStrategy, resolveStrategy };

package/dist/chunk-ABSJVCYK.js

@@ -0,0 +1,44 @@
+// src/utils/text.ts
+function transformStrings(obj, fn) {
+  if (obj === null || obj === void 0 || typeof obj !== "object") return;
+  if (Array.isArray(obj)) {
+    for (let i = 0; i < obj.length; i++) {
+      if (typeof obj[i] === "string") {
+        obj[i] = fn(obj[i]);
+      } else {
+        transformStrings(obj[i], fn);
+      }
+    }
+    return;
+  }
+  const record = obj;
+  for (const key of Object.keys(record)) {
+    if (typeof record[key] === "string") {
+      record[key] = fn(record[key]);
+    } else {
+      transformStrings(record[key], fn);
+    }
+  }
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function setNestedValue(obj, path, value) {
+  const parts = path.split(".");
+  let current = obj;
+  for (let i = 0; i < parts.length - 1; i++) {
+    if (current === null || current === void 0 || typeof current !== "object") return;
+    current = current[parts[i]];
+  }
+  if (current !== null && current !== void 0 && typeof current === "object") {
+    current[parts[parts.length - 1]] = value;
+  }
+}
+
+export { getNestedValue, setNestedValue, transformStrings };