@saulwade/swl-ses 1.0.0

package/hooks/lib/performance-marks.js

@@ -0,0 +1,239 @@
+'use strict';
+
+/**
+ * performance-marks.js — Sistema de marks/measures para hooks de swl-ses.
+ *
+ * Patrón adoptado directamente del compilador TypeScript (microsoft/TypeScript,
+ * src/compiler/performance.ts). Abstrae la medición de duración de operaciones
+ * con marks nombrados, acumulando duraciones entre llamadas y permitiendo
+ * reportes al final de la sesión.
+ *
+ * Ventajas sobre Date.now() directo:
+ *   - Acumulación automática: medir la misma operación N veces y obtener total
+ *   - Conteo de invocaciones por mark
+ *   - API simétrica: mark(start) → operación → mark(end) → measure(name, start, end)
+ *   - Zero-overhead cuando está deshabilitado
+ *   - Compatible con Performance API de Node.js si está disponible
+ *
+ * Equivalente JS del patrón:
+ *   mark("beforeParse");
+ *   // ... operación costosa
+ *   mark("afterParse");
+ *   measure("Parse", "beforeParse", "afterParse");
+ *   console.log(getDuration("Parse"));   // ms acumulados
+ *   console.log(getCount("beforeParse")); // veces que se ejecutó
+ *
+ * Zero-dependencies: solo usa process.hrtime.bigint() o Date.now() de Node.js.
+ *
+ * @module hooks/lib/performance-marks
+ */
+
+// ---------------------------------------------------------------------------
+// Internos
+// ---------------------------------------------------------------------------
+
+/** @type {Map<string, bigint>} Timestamps de marks en nanosegundos */
+const marks = new Map();
+
+/** @type {Map<string, number>} Conteo de invocaciones por mark */
+const counts = new Map();
+
+/** @type {Map<string, number>} Duraciones acumuladas en milisegundos */
+const durations = new Map();
+
+/** Soporte nativo de hrtime.bigint para mayor precisión */
+const hasHrtime = typeof process !== 'undefined' && typeof process.hrtime === 'function';
+
+/** Estado: habilitado por defecto para hooks */
+let enabled = true;
+
+/**
+ * Retorna el timestamp actual en nanosegundos.
+ * Usa process.hrtime.bigint() si está disponible, fallback a Date.now().
+ * @returns {bigint}
+ */
+function timestamp() {
+  if (hasHrtime) {
+    return process.hrtime.bigint();
+  }
+  return BigInt(Date.now()) * 1_000_000n;
+}
+
+/**
+ * Convierte nanosegundos a milisegundos como número flotante.
+ * @param {bigint} ns
+ * @returns {number}
+ */
+function nsToMs(ns) {
+  return Number(ns) / 1_000_000;
+}
+
+// ---------------------------------------------------------------------------
+// API pública — compatible con performance.ts del compilador TypeScript
+// ---------------------------------------------------------------------------
+
+/**
+ * Registra una marca de performance.
+ * Si se llama múltiples veces con el mismo nombre, acumula el conteo
+ * y sobreescribe el timestamp (para medir la última ejecución).
+ *
+ * @param {string} markName — Nombre del mark (ej: "beforeCheck", "afterParse")
+ */
+function mark(markName) {
+  if (!enabled) return;
+  const count = counts.get(markName) ?? 0;
+  counts.set(markName, count + 1);
+  marks.set(markName, timestamp());
+}
+
+/**
+ * Calcula y acumula la duración entre dos marks.
+ * Si startMarkName es omitido, usa el origen de tiempo.
+ * Si endMarkName es omitido, usa el momento actual.
+ *
+ * @param {string}  measureName  — Nombre de la medida (ej: "Parse", "TypeCheck")
+ * @param {string}  [startMarkName] — Mark de inicio
+ * @param {string}  [endMarkName]   — Mark de fin
+ */
+function measure(measureName, startMarkName, endMarkName) {
+  if (!enabled) return;
+  const end   = endMarkName   ? marks.get(endMarkName)   : timestamp();
+  const start = startMarkName ? marks.get(startMarkName) : 0n;
+  if (end === undefined || start === undefined) return;
+  const prev = durations.get(measureName) || 0;
+  durations.set(measureName, prev + nsToMs(end - start));
+}
+
+/**
+ * Retorna la duración acumulada en milisegundos de una medida.
+ *
+ * @param {string} measureName
+ * @returns {number}
+ */
+function getDuration(measureName) {
+  return durations.get(measureName) || 0;
+}
+
+/**
+ * Retorna el número de veces que se registró un mark.
+ *
+ * @param {string} markName
+ * @returns {number}
+ */
+function getCount(markName) {
+  return counts.get(markName) || 0;
+}
+
+/**
+ * Itera sobre todas las medidas acumuladas.
+ *
+ * @param {function(string, number): void} cb — (measureName, durationMs)
+ */
+function forEachMeasure(cb) {
+  durations.forEach((dur, name) => cb(name, dur));
+}
+
+/**
+ * Habilita el sistema de marks. Activo por defecto.
+ */
+function enable() {
+  enabled = true;
+}
+
+/**
+ * Deshabilita el sistema. Las llamadas a mark/measure son no-op.
+ */
+function disable() {
+  enabled = false;
+}
+
+/**
+ * Limpia todos los marks, conteos y duraciones acumulados.
+ * Llamar al inicio de cada sesión si se quieren métricas independientes.
+ */
+function clearAll() {
+  marks.clear();
+  counts.clear();
+  durations.clear();
+}
+
+/**
+ * Limpia las marcas y conteos, pero preserva las duraciones acumuladas.
+ * Útil para reutilizar medidas entre fases de la misma sesión.
+ */
+function clearMarks() {
+  marks.clear();
+  counts.clear();
+}
+
+/**
+ * Genera un reporte de texto con todas las medidas acumuladas.
+ * Formateado para incluir en logs de sesión o resumen de métricas.
+ *
+ * @param {object} [opts]
+ * @param {number} [opts.umbralMs=0]   — Solo incluir medidas con duración >= umbralMs
+ * @param {boolean} [opts.ordenarDesc=true] — Ordenar de mayor a menor duración
+ * @returns {string}
+ */
+function formatReporte(opts) {
+  const { umbralMs = 0, ordenarDesc = true } = opts || {};
+
+  const entradas = [];
+  durations.forEach((dur, name) => {
+    if (dur >= umbralMs) {
+      entradas.push({ name, durMs: dur });
+    }
+  });
+
+  if (entradas.length === 0) return '';
+
+  if (ordenarDesc) {
+    entradas.sort((a, b) => b.durMs - a.durMs);
+  }
+
+  const lineas = entradas.map(({ name, durMs }) => {
+    const invocaciones = getCount(name + 'Start') || getCount(name) || 1;
+    return `  ${name.padEnd(30)} ${durMs.toFixed(2).padStart(8)} ms  (${invocaciones}×)`;
+  });
+
+  return [
+    'Performance marks:',
+    ...lineas,
+  ].join('\n');
+}
+
+/**
+ * Helper: ejecuta una función síncrona midiéndola con el patrón mark/measure.
+ *
+ * @template T
+ * @param {string}   measureName — Nombre de la medida
+ * @param {function(): T} fn     — Función a ejecutar
+ * @returns {T}
+ *
+ * @example
+ *   const resultado = timed("ParseArchivo", () => parsear(contenido));
+ *   console.log(getDuration("ParseArchivo")); // ms que tardó
+ */
+function timed(measureName, fn) {
+  const startMark = measureName + '_start';
+  const endMark   = measureName + '_end';
+  mark(startMark);
+  const resultado = fn();
+  mark(endMark);
+  measure(measureName, startMark, endMark);
+  return resultado;
+}
+
+module.exports = {
+  mark,
+  measure,
+  getDuration,
+  getCount,
+  forEachMeasure,
+  enable,
+  disable,
+  clearAll,
+  clearMarks,
+  formatReporte,
+  timed,
+};

package/hooks/lib/privacy-filter.js

@@ -0,0 +1,128 @@
+'use strict';
+
+/**
+ * Privacy Filter — Filtra contenido marcado como privado antes de almacenar.
+ *
+ * Soporte para tags <private>...</private>, <secreto>...</secreto> y
+ * <privado>...</privado> que excluyen contenido sensible del storage de
+ * aprendizajes y sesiones.
+ *
+ * Inspirado en claude-mem's privacy tag system.
+ *
+ * Seguridad:
+ *   - Limite de tags por texto (MAX_TAGS = 100) para prevenir ReDoS
+ *   - Stripping iterativo, no basado en regex greedy
+ */
+
+const MAX_TAGS = 100;
+
+/**
+ * Remueve bloques <private>...</private>, <secreto>...</secreto> y
+ * <privado>...</privado> del texto.
+ *
+ * @param {string} texto
+ * @returns {{ textoFiltrado: string, tagsRemovidos: number }}
+ */
+function filtrarPrivacidad(texto) {
+  if (!texto || typeof texto !== 'string') return { textoFiltrado: texto, tagsRemovidos: 0 };
+
+  let resultado = texto;
+  let tagsRemovidos = 0;
+
+  // Tags soportados
+  const tags = ['private', 'secreto', 'privado'];
+
+  for (const tag of tags) {
+    let intentos = 0;
+    while (intentos < MAX_TAGS) {
+      const openTag = `<${tag}>`;
+      const closeTag = `</${tag}>`;
+      const start = resultado.indexOf(openTag);
+      if (start === -1) break;
+
+      const end = resultado.indexOf(closeTag, start);
+      if (end === -1) break;
+
+      resultado = resultado.slice(0, start) + resultado.slice(end + closeTag.length);
+      tagsRemovidos++;
+      intentos++;
+    }
+  }
+
+  return { textoFiltrado: resultado.trim(), tagsRemovidos };
+}
+
+/**
+ * Verifica si un texto contiene tags de privacidad sin procesar.
+ *
+ * @param {string} texto
+ * @returns {boolean}
+ */
+function contieneTagsPrivados(texto) {
+  if (!texto) return false;
+  return /<(private|secreto|privado)>/i.test(texto);
+}
+
+/**
+ * Patrones de PII comunes en Mexico y formatos internacionales.
+ * Solo cubre PII estructurada con formato verificable; texto libre con
+ * direcciones o nombres no se detecta (requiere NER con dependencias
+ * pesadas y este hook es zero-deps).
+ *
+ * Cobertura:
+ *   - Tarjeta de credito/debito: 13-19 digitos con espacios o guiones opcionales
+ *     (Visa, MasterCard, Amex, etc.). Validacion formal seria Luhn, pero
+ *     reportamos por formato porque 99% de falsos positivos en texto libre
+ *     no tienen 13+ digitos contiguos.
+ *   - CURP: 18 caracteres, formato oficial mexicano (SAT/RENAPO).
+ *   - RFC personal: 13 caracteres (persona fisica). RFC moral tiene 12 pero
+ *     no es PII (es identificador de empresa).
+ *   - IFE/INE: clave de elector de 18 caracteres alfanumericos.
+ *   - Numero de Seguro Social (NSS IMSS): 11 digitos.
+ *   - Telefono MX: 10 digitos con prefijos comunes.
+ *   - Email: formato RFC5322 simplificado.
+ *   - IPv4 fuera de rangos privados (posible doxxing).
+ */
+const PATTERNS_PII = [
+  { regex: /\b(?:\d[ -]?){13,19}\b/, tipo: 'tarjeta_credito' },
+  { regex: /\b[A-Z]{4}\d{6}[HMX][A-Z]{5}[A-Z0-9]{2}\b/, tipo: 'curp' },
+  { regex: /\b[A-ZÑ&]{4}\d{6}[A-Z0-9]{3}\b/, tipo: 'rfc_persona_fisica' },
+  { regex: /\b[A-Z]{6}\d{8}[HM]\d{3}\b/, tipo: 'ife_ine' },
+  // NSS: 11 digitos aislados, con palabra clave "NSS" cerca para bajar falsos positivos
+  { regex: /\bNSS[:\s]+\d{11}\b/i, tipo: 'nss_imss' },
+  // Telefono MX: requiere separador explicito o prefijo +52 para evitar matchear timestamps/hashes
+  { regex: /\+52[\s-]\d{2,3}[\s-]\d{3,4}[\s-]\d{3,4}\b/, tipo: 'telefono_mx' },
+  { regex: /\(\d{2,3}\)[\s-]?\d{3,4}[\s-]?\d{3,4}\b/, tipo: 'telefono_formato_area' },
+  { regex: /\b\d{2,3}[\s-]\d{3,4}[\s-]\d{3,4}\b/, tipo: 'telefono_con_separadores' },
+  { regex: /\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b/, tipo: 'email' },
+];
+
+/**
+ * Escanea un texto en busca de PII estructurada (tarjeta, CURP, RFC, NSS,
+ * IFE/INE, telefono, email). Devuelve la lista de hallazgos con tipo y
+ * un fragmento parcialmente ofuscado para el reporte.
+ *
+ * No filtra el texto ni lanza excepciones — solo reporta. La decision de
+ * bloquear, redactar o advertir es del caller (tipicamente el hook que
+ * escribe a memoria).
+ *
+ * @param {string} texto
+ * @returns {Array<{ tipo: string, muestra: string }>}
+ */
+function detectarPII(texto) {
+  if (!texto || typeof texto !== 'string') return [];
+  const hallazgos = [];
+  for (const { regex, tipo } of PATTERNS_PII) {
+    const matches = texto.match(new RegExp(regex.source, regex.flags + 'g'));
+    if (!matches) continue;
+    for (const m of matches.slice(0, 3)) {  // max 3 muestras por tipo
+      const muestra = m.length > 8
+        ? m.slice(0, 2) + '***' + m.slice(-2)
+        : '***';
+      hallazgos.push({ tipo, muestra });
+    }
+  }
+  return hallazgos;
+}
+
+module.exports = { filtrarPrivacidad, contieneTagsPrivados, detectarPII, MAX_TAGS, PATTERNS_PII };

package/hooks/lib/prompt-injection-scanner.js

@@ -0,0 +1,209 @@
+'use strict';
+
+/**
+ * Prompt Injection Scanner — Detección de inyecciones de prompt y amenazas.
+ *
+ * Escanea contenido buscando patrones de amenaza conocidos:
+ *   - Prompt injection (ignore previous instructions, new instructions)
+ *   - Role hijack (you are now, act as, pretend to be)
+ *   - Deception (do not tell the user, hide this)
+ *   - Exfiltración (curl/wget/fetch con secretos)
+ *   - SSH backdoor (authorized_keys)
+ *   - Caracteres Unicode invisibles (zero-width, RTL marks)
+ *
+ * Patrón adoptado de Hermes Agent (memory_tool.py → _MEMORY_THREAT_PATTERNS
+ * y prompt_builder.py → _CONTEXT_THREAT_PATTERNS).
+ *
+ * @module hooks/lib/prompt-injection-scanner
+ */
+
+// ---------------------------------------------------------------------------
+// Patrones de amenaza
+// ---------------------------------------------------------------------------
+
+/**
+ * Taxonomía de categorías de amenaza.
+ *
+ * Clasificación formal inspirada en Google Model Armor y OWASP LLM Top 10.
+ * Cada patrón pertenece a una categoría para reportes y métricas agregadas.
+ *
+ * Categorías:
+ *   PI  — Prompt Injection: manipulación de instrucciones del sistema
+ *   RAI — Responsible AI: contenido dañino, engaño, manipulación
+ *   SDP — Sensitive Data Protection: exfiltración de datos, PII, secretos
+ *   MAL — Malicious Actions: backdoors, destrucción, código malicioso
+ */
+const THREAT_CATEGORIES = {
+  PI:  { name: 'Prompt Injection',          description: 'Manipulación de instrucciones del sistema o jailbreak' },
+  RAI: { name: 'Responsible AI',            description: 'Engaño, manipulación de comportamiento, ocultamiento' },
+  SDP: { name: 'Sensitive Data Protection', description: 'Exfiltración de secretos, PII, credenciales' },
+  MAL: { name: 'Malicious Actions',         description: 'Backdoors, destrucción de datos, código malicioso' },
+};
+
+const THREAT_PATTERNS = [
+  // --- PI: Prompt Injection ---
+  { regex: /ignore\s+(?:\w+\s+)*(?:previous|all|above|prior)\s+instructions/i, type: 'prompt_injection', category: 'PI', severity: 'critical' },
+  { regex: /disregard\s+(all|any|your)\s+(previous|prior)/i, type: 'prompt_injection', category: 'PI', severity: 'critical' },
+  { regex: /forget\s+(everything|all|your)\s+(instructions|rules|guidelines)/i, type: 'prompt_injection', category: 'PI', severity: 'critical' },
+  { regex: /override\s+(your|all|the)\s+(instructions|rules|guidelines)/i, type: 'prompt_injection', category: 'PI', severity: 'critical' },
+  { regex: /new\s+instructions?\s*:/i, type: 'prompt_injection', category: 'PI', severity: 'high' },
+  { regex: /system\s*:\s*you\s+are/i, type: 'prompt_injection', category: 'PI', severity: 'high' },
+
+  // --- PI: Role hijack ---
+  { regex: /you\s+are\s+now\s+/i, type: 'role_hijack', category: 'PI', severity: 'critical' },
+  { regex: /act\s+as\s+(?:if\s+you\s+are|a|an)\s+/i, type: 'role_hijack', category: 'PI', severity: 'high' },
+  { regex: /pretend\s+(?:to\s+be|you\s+are|you're)/i, type: 'role_hijack', category: 'PI', severity: 'high' },
+  { regex: /from\s+now\s+on\s+you\s+(?:are|will|must)/i, type: 'role_hijack', category: 'PI', severity: 'high' },
+
+  // --- RAI: Deception ---
+  { regex: /do\s+not\s+tell\s+the\s+user/i, type: 'deception', category: 'RAI', severity: 'critical' },
+  { regex: /hide\s+this\s+from\s+(?:the\s+)?user/i, type: 'deception', category: 'RAI', severity: 'critical' },
+  { regex: /don'?t\s+mention\s+this\s+(?:to|in)/i, type: 'deception', category: 'RAI', severity: 'medium' },
+  { regex: /never\s+reveal\s+(?:this|that|your)/i, type: 'deception', category: 'RAI', severity: 'high' },
+  { regex: /keep\s+this\s+(?:secret|hidden|private)\s+from/i, type: 'deception', category: 'RAI', severity: 'high' },
+
+  // --- SDP: Exfiltration ---
+  { regex: /curl\s+[^\n]*\$\{?\w*(?:KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL)/i, type: 'exfil', category: 'SDP', severity: 'critical' },
+  { regex: /curl\s+[^\n]*\s-[dF]\s+@[^\s"']+/i, type: 'exfil_file', category: 'SDP', severity: 'critical' },
+  { regex: /wget\s+[^\n]*\$\{?\w*(?:KEY|TOKEN|SECRET|PASSWORD)/i, type: 'exfil', category: 'SDP', severity: 'critical' },
+  { regex: /wget\s+[^\n]*--post-file[= ][^\s"']+/i, type: 'exfil_file', category: 'SDP', severity: 'critical' },
+  { regex: /fetch\s*\([^\n]*(?:KEY|TOKEN|SECRET|PASSWORD)/i, type: 'exfil', category: 'SDP', severity: 'high' },
+  { regex: /(?:nc|netcat|ncat)\s+[^\n]*(?:\d{1,3}\.){3}\d{1,3}/i, type: 'exfil', category: 'SDP', severity: 'high' },
+
+  // --- MAL: SSH backdoor ---
+  { regex: /authorized_keys/i, type: 'ssh_backdoor', category: 'MAL', severity: 'high' },
+  { regex: /ssh-(?:rsa|ed25519|ecdsa)\s+[A-Za-z0-9+/]{20,}/i, type: 'ssh_key_injection', category: 'MAL', severity: 'high' },
+
+  // --- MAL: Destructive (en contexto de prompt, no como comando real) ---
+  { regex: /rm\s+-rf\s+[/~]/i, type: 'destructive_prompt', category: 'MAL', severity: 'high' },
+  { regex: /DROP\s+(?:TABLE|DATABASE|SCHEMA)/i, type: 'destructive_prompt', category: 'MAL', severity: 'high' },
+];
+
+// ---------------------------------------------------------------------------
+// Caracteres Unicode invisibles
+// ---------------------------------------------------------------------------
+
+/**
+ * Caracteres Unicode que son invisibles pero pueden alterar el comportamiento
+ * de parseo de texto. Técnica documentada de inyección de prompts.
+ */
+const INVISIBLE_CHARS = new Set([
+  '\u200B', // zero-width space
+  '\u200C', // zero-width non-joiner
+  '\u200D', // zero-width joiner
+  '\u2060', // word joiner
+  '\uFEFF', // BOM / zero-width no-break space
+  '\u00AD', // soft hyphen
+  '\u200E', // left-to-right mark
+  '\u200F', // right-to-left mark
+  '\u202A', // left-to-right embedding
+  '\u202B', // right-to-left embedding
+  '\u202C', // pop directional formatting
+  '\u202D', // left-to-right override
+  '\u202E', // right-to-left override
+  '\u2066', // left-to-right isolate
+  '\u2067', // right-to-left isolate
+  '\u2068', // first strong isolate
+  '\u2069', // pop directional isolate
+]);
+
+// ---------------------------------------------------------------------------
+// API pública
+// ---------------------------------------------------------------------------
+
+/**
+ * Escanea contenido buscando amenazas de inyección de prompt.
+ *
+ * @param {string} content - Contenido a escanear.
+ * @param {string} [source='unknown'] - Nombre del origen (para mensajes).
+ * @returns {{ safe: boolean, threats: object[], criticalCount: number, highCount: number }}
+ */
+function scan(content, source = 'unknown') {
+  if (!content || typeof content !== 'string') {
+    return { safe: true, threats: [], criticalCount: 0, highCount: 0 };
+  }
+
+  const threats = [];
+
+  // 1. Detectar caracteres Unicode invisibles
+  let invisibleCount = 0;
+  for (const ch of content) {
+    if (INVISIBLE_CHARS.has(ch)) invisibleCount++;
+  }
+  if (invisibleCount > 0) {
+    threats.push({
+      type: 'invisible_chars',
+      category: 'PI',
+      severity: invisibleCount > 5 ? 'critical' : 'high',
+      count: invisibleCount,
+      message: `${invisibleCount} carácter(es) Unicode invisible(s) en ${source}`,
+    });
+  }
+
+  // 2. Detectar patrones de amenaza
+  for (const pattern of THREAT_PATTERNS) {
+    const match = content.match(pattern.regex);
+    if (match) {
+      threats.push({
+        type: pattern.type,
+        category: pattern.category,
+        severity: pattern.severity,
+        match: match[0].substring(0, 80),
+        message: `Patrón ${pattern.type} en ${source}: "${match[0].substring(0, 50)}"`,
+      });
+    }
+  }
+
+  // 3. Agrupar por categoría de amenaza
+  const porCategoria = {};
+  for (const t of threats) {
+    const cat = t.category || 'UNKNOWN';
+    porCategoria[cat] = (porCategoria[cat] || 0) + 1;
+  }
+
+  return {
+    safe: threats.length === 0,
+    threats,
+    criticalCount: threats.filter(t => t.severity === 'critical').length,
+    highCount: threats.filter(t => t.severity === 'high').length,
+    categorias: porCategoria,
+  };
+}
+
+/**
+ * Escanea y produce contenido sanitizado.
+ *
+ * - Si hay amenazas críticas: bloquea completamente (reemplaza con placeholder).
+ * - Si hay amenazas no-críticas: inyecta con advertencia.
+ * - Si no hay amenazas: retorna tal cual.
+ *
+ * @param {string} content - Contenido a sanitizar.
+ * @param {string} [source='unknown'] - Nombre del origen.
+ * @returns {{ content: string, blocked: boolean, threats: object[] }}
+ */
+function sanitize(content, source = 'unknown') {
+  const result = scan(content, source);
+
+  if (result.safe) {
+    return { content, blocked: false, threats: [] };
+  }
+
+  if (result.criticalCount > 0) {
+    const tipos = [...new Set(result.threats.filter(t => t.severity === 'critical').map(t => t.type))];
+    return {
+      content: `[BLOQUEADO: ${source} contiene ${result.criticalCount} amenaza(s) crítica(s) (${tipos.join(', ')}). Contenido no inyectado.]`,
+      blocked: true,
+      threats: result.threats,
+    };
+  }
+
+  // Amenazas no-críticas: inyectar con advertencia
+  const tipos = [...new Set(result.threats.map(t => t.type))];
+  return {
+    content: `[ADVERTENCIA: ${result.threats.length} patrón(es) sospechoso(s) en ${source} (${tipos.join(', ')})]\n${content}`,
+    blocked: false,
+    threats: result.threats,
+  };
+}
+
+module.exports = { scan, sanitize, THREAT_PATTERNS, THREAT_CATEGORIES, INVISIBLE_CHARS };