pompelmi 0.20.0 → 0.20.1

package/README.md

@@ -12,6 +12,10 @@
   <a href="https://www.detectionengineering.net/p/det-eng-weekly-issue-124-the-defcon"><img alt="Featured in Detection Engineering Weekly #124" src="https://img.shields.io/badge/featured-Detection%20Engineering%20Weekly-0A84FF?logo=substack"></a>
   <a href="https://nodeweekly.com/issues/594"><img alt="Featured in Node Weekly #594" src="https://img.shields.io/badge/featured-Node%20Weekly%20%23594-FF6600?logo=node.js"></a>
   <a href="https://bytes.dev/archives/429"><img alt="Featured in Bytes #429" src="https://img.shields.io/badge/featured-Bytes%20%23429-111111"></a>
+  <a href="https://dev.to/sonotommy/secure-nodejs-file-uploads-in-minutes-with-pompelmi-3jfe"><img alt="Featured on DEV.to" src="https://img.shields.io/badge/featured-DEV.to-0A0A0A?logo=devdotto"></a>
+  <br/>
+  <a href="https://github.com/sorrycc/awesome-javascript"><img alt="Mentioned in Awesome JavaScript" src="https://awesome.re/mentioned-badge.svg"></a>
+  <a href="https://github.com/dzharii/awesome-typescript"><img alt="Mentioned in Awesome TypeScript" src="https://awesome.re/mentioned-badge-flat.svg"></a>
   <br/>
   
 </p>
@@ -25,13 +29,17 @@
 <strong>Fast file‑upload malware scanning for Node.js</strong> — optional <strong>YARA</strong> integration, ZIP deep‑inspection, and drop‑in adapters for <em>Express</em>, <em>Koa</em>, and <em>Next.js</em>. Private by design. Typed. Tiny.
 </p>
 
+**Keywords:** file upload security · malware detection · YARA · Node.js middleware · Express · Koa · Next.js · ZIP bomb protection
+
 
 
 <p align="center">
   <a href="https://www.npmjs.com/package/pompelmi"><img alt="npm version" src="https://img.shields.io/npm/v/pompelmi?label=version&color=0a7ea4&logo=npm"></a>
   <a href="https://www.npmjs.com/package/pompelmi"><img alt="npm downloads" src="https://img.shields.io/npm/dm/pompelmi?label=downloads&color=6E9F18&logo=npm"></a>
   <a href="https://www.npmjs.com/package/pompelmi"><img alt="npm weekly downloads" src="https://img.shields.io/npm/dw/pompelmi?label=weekly&color=blue&logo=npm"></a>
+  <a href="https://www.npmjs.com/package/pompelmi"><img alt="npm total downloads" src="https://img.shields.io/npm/dt/pompelmi?label=total%20downloads&color=success&logo=npm"></a>
   <img alt="npm bundle size" src="https://img.shields.io/bundlephobia/minzip/pompelmi?label=size&color=success">
+  <a href="https://snyk.io/test/github/pompelmi/pompelmi"><img alt="Known Vulnerabilities" src="https://snyk.io/test/github/pompelmi/pompelmi/badge.svg"></a>
 </p>
 
 <p align="center">
@@ -51,9 +59,11 @@
 <p align="center">
   <a href="https://github.com/pompelmi/pompelmi/stargazers"><img alt="GitHub stars" src="https://img.shields.io/github/stars/pompelmi/pompelmi?style=social"></a>
   <a href="https://github.com/pompelmi/pompelmi/network/members"><img alt="GitHub forks" src="https://img.shields.io/github/forks/pompelmi/pompelmi?style=social"></a>
+  <a href="https://github.com/pompelmi/pompelmi/watchers"><img alt="GitHub watchers" src="https://img.shields.io/github/watchers/pompelmi/pompelmi?style=social"></a>
   <a href="https://github.com/pompelmi/pompelmi/issues"><img alt="open issues" src="https://img.shields.io/github/issues/pompelmi/pompelmi?color=orange"></a>
   <img alt="PRs welcome" src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg">
   <a href="https://github.com/pompelmi/pompelmi/commits/main"><img alt="last commit" src="https://img.shields.io/github/last-commit/pompelmi/pompelmi?color=blue"></a>
+  <a href="https://github.com/pompelmi/pompelmi/graphs/contributors"><img alt="contributors" src="https://img.shields.io/github/contributors/pompelmi/pompelmi?color=purple"></a>
 </p>
 
 <p align="center">
@@ -80,41 +90,33 @@
 
 </div>
 
-<table>
-<tr>
-<td width="33%" align="center">
-<h4>🔒 Privacy First</h4>
-All scanning happens in-process. No cloud calls, no data leaks. Your files never leave your infrastructure.
-</td>
-<td width="33%" align="center">
-<h4>⚡ Lightning Fast</h4>
-In-process scanning with zero network latency. Configurable concurrency for high-throughput scenarios.
-</td>
-<td width="33%" align="center">
-<h4>🎨 Developer Friendly</h4>
-TypeScript-first, zero-config defaults, drop-in middleware. Get started in under 5 minutes.
-</td>
-</tr>
-</table>
+| 🔒 Privacy First | ⚡ Lightning Fast | 🎨 Developer Friendly |
+| --- | --- | --- |
+| All scanning happens in-process. No cloud calls, no data leaks. Your files never leave your infrastructure. | In-process scanning with zero network latency. Configurable concurrency for high-throughput scenarios. | TypeScript-first, zero-config defaults, drop-in middleware. Get started in under 5 minutes. |
 
 ---
 
-<details>
-<summary><strong>Table of contents</strong></summary>
-
-- [Install](#installation)
-- [Quick‑start](#quick-start)
-- [Minimal Node usage](#minimal-node-usage)
-- [GitHub Action](#github-action)
-- [Adapters](#adapters)
-- [Diagrams](#diagrams)
-- [Config](#configuration)
-- [Production checklist](#production-checklist)
-- [YARA](#yara-getting-started)
-- [Quick test](#quick-test-no-eicar)
-- [Security](#security-notes)
+## Table of Contents
+
+- [Overview](#overview)
+- [Highlights](#highlights)
+- [Why pompelmi](#why-pompelmi)
+- [How it compares](#how-it-compares)
+- [What Developers Say](#what-developers-say)
+- [What Makes pompelmi Special](#what-makes-pompelmi-special)
+- [Use Cases](#use-cases)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+  - [Minimal Node usage](#minimal-node-usage)
+  - [Express](#express)
+  - [Koa](#koa)
+  - [Next.js (App Router)](#nextjs-app-router)
+- [Configuration](#configuration)
+- [Security Notes](#security-notes)
+- [Testing & Development](#testing--development)
 - [FAQ](#faq)
-</details>
+- [Contributing](#contributing)
+- [License](#license)
 
 ---
 
@@ -155,7 +157,7 @@ TypeScript-first, zero-config defaults, drop-in middleware. Get started in under
 ## 🧠 Why pompelmi?
 
 - **On‑device, private scanning** – no outbound calls, no data sharing.
-- **Blocks early** – runs *before* you write to disk or persist anything.
+- **Blocks early** – runs _before_ you write to disk or persist anything.
 - **Fits your stack** – drop‑in adapters for Express, Koa, Next.js (Fastify plugin in alpha).
 - **Defense‑in‑depth** – ZIP traversal limits, ratio caps, server‑side MIME sniffing, size caps.
 - **Pluggable detection** – bring your own engine (e.g., YARA) via a tiny `{ scan(bytes) }` contract.
@@ -193,7 +195,7 @@ TypeScript-first, zero-config defaults, drop-in middleware. Get started in under
 > "The YARA integration is seamless. We went from prototype to production in less than a week."
 > — DevSecOps Engineer
 
-*Want to share your experience? [Open a discussion](https://github.com/pompelmi/pompelmi/discussions)!*
+_Want to share your experience? [Open a discussion](https://github.com/pompelmi/pompelmi/discussions)!_
 
 ---
 

package/dist/pompelmi.cjs

@@ -1,5 +1,30 @@
 'use strict';
 
+var crypto = require('crypto');
+var os = require('os');
+var path = require('path');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var crypto__namespace = /*#__PURE__*/_interopNamespaceDefault(crypto);
+var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+
 function toScanFn(s) {
     return (typeof s === "function" ? s : s.scan);
 }
@@ -19,12 +44,100 @@ function composeScanners(...scanners) {
         return all;
     };
 }
-function createPresetScanner(_preset, _opts = {}) {
-    // TODO: wire to real preset registry
-    return async (_input, _ctx) => {
-        return [];
-    };
+function createPresetScanner(preset, opts = {}) {
+    const scanners = [];
+    // Add decompilation scanners based on preset
+    if (preset === 'decompilation-basic' || preset === 'decompilation-deep' ||
+        preset === 'malware-analysis' || opts.enableDecompilation) {
+        const depth = preset === 'decompilation-deep' ? 'deep' :
+            preset === 'decompilation-basic' ? 'basic' :
+                opts.decompilationDepth || 'basic';
+        if (!opts.decompilationEngine || opts.decompilationEngine === 'binaryninja-hlil' || opts.decompilationEngine === 'both') {
+            try {
+                // Dynamic import to avoid bundling issues - using Function to bypass TypeScript type checking
+                const importModule = new Function('specifier', 'return import(specifier)');
+                importModule('@pompelmi/engine-binaryninja').then((mod) => {
+                    const binjaScanner = mod.createBinaryNinjaScanner({
+                        timeout: opts.decompilationTimeout || opts.timeout || 30000,
+                        depth,
+                        pythonPath: opts.pythonPath,
+                        binaryNinjaPath: opts.binaryNinjaPath
+                    });
+                    scanners.push(binjaScanner);
+                }).catch(() => {
+                    // Binary Ninja engine not available
+                });
+            }
+            catch {
+                // Engine not installed
+            }
+        }
+        if (!opts.decompilationEngine || opts.decompilationEngine === 'ghidra-pcode' || opts.decompilationEngine === 'both') {
+            try {
+                // Dynamic import for Ghidra engine (when implemented) - using Function to bypass TypeScript type checking
+                const importModule = new Function('specifier', 'return import(specifier)');
+                importModule('@pompelmi/engine-ghidra').then((mod) => {
+                    const ghidraScanner = mod.createGhidraScanner({
+                        timeout: opts.decompilationTimeout || opts.timeout || 30000,
+                        depth,
+                        ghidraPath: opts.ghidraPath,
+                        analyzeHeadless: opts.analyzeHeadless
+                    });
+                    scanners.push(ghidraScanner);
+                }).catch(() => {
+                    // Ghidra engine not available
+                });
+            }
+            catch {
+                // Engine not installed
+            }
+        }
+    }
+    // Add other scanners for advanced presets
+    if (preset === 'advanced' || preset === 'malware-analysis') {
+        // Add heuristics scanner
+        try {
+            const { CommonHeuristicsScanner } = require('./scanners/common-heuristics');
+            scanners.push(new CommonHeuristicsScanner());
+        }
+        catch {
+            // Heuristics not available
+        }
+    }
+    if (scanners.length === 0) {
+        // Fallback scanner that returns no matches
+        return async (_input, _ctx) => {
+            return [];
+        };
+    }
+    return composeScanners(...scanners);
 }
+// Preset configurations
+const PRESET_CONFIGS = {
+    'basic': {
+        timeout: 10000
+    },
+    'advanced': {
+        timeout: 30000,
+        enableDecompilation: false
+    },
+    'malware-analysis': {
+        timeout: 60000,
+        enableDecompilation: true,
+        decompilationEngine: 'both',
+        decompilationDepth: 'deep'
+    },
+    'decompilation-basic': {
+        timeout: 30000,
+        enableDecompilation: true,
+        decompilationDepth: 'basic'
+    },
+    'decompilation-deep': {
+        timeout: 120000,
+        enableDecompilation: true,
+        decompilationDepth: 'deep'
+    }
+};
 
 /** Mappa veloce estensione -> mime (basic) */
 function guessMimeByExt(name) {
@@ -61,13 +174,13 @@ function toYaraMatches(ms) {
 /** Scan di bytes (browser/node) usando preset (default: zip-basic) */
 async function scanBytes(input, opts = {}) {
     const t0 = Date.now();
-    opts.preset ?? 'zip-basic';
+    const preset = opts.preset ?? 'zip-basic';
     const ctx = {
         ...opts.ctx,
         mimeType: opts.ctx?.mimeType ?? guessMimeByExt(opts.ctx?.filename),
         size: opts.ctx?.size ?? input.byteLength,
     };
-    const scanFn = createPresetScanner();
+    const scanFn = createPresetScanner(preset);
     const matchesH = await (typeof scanFn === "function" ? scanFn : scanFn.scan)(input, ctx);
     const matches = toYaraMatches(matchesH);
     const verdict = computeVerdict(matches);
@@ -2110,6 +2223,353 @@ async function scanFilesWithRemoteYara(files, rulesSource, remote) {
     return results;
 }
 
+/** Decompilation-specific types for Pompelmi */
+const SUSPICIOUS_PATTERNS = [
+    {
+        name: 'syscall_direct',
+        description: 'Direct system call without library wrapper',
+        severity: 'medium',
+        pattern: /syscall|sysenter|int\s+0x80/i
+    },
+    {
+        name: 'process_injection',
+        description: 'Process injection techniques',
+        severity: 'high',
+        pattern: /CreateRemoteThread|WriteProcessMemory|VirtualAllocEx/i
+    },
+    {
+        name: 'anti_debug',
+        description: 'Anti-debugging techniques',
+        severity: 'medium',
+        pattern: /IsDebuggerPresent|CheckRemoteDebuggerPresent|OutputDebugString/i
+    },
+    {
+        name: 'obfuscation_xor',
+        description: 'XOR-based obfuscation pattern',
+        severity: 'medium',
+        pattern: /xor.*0x[0-9a-f]+.*xor/i
+    },
+    {
+        name: 'crypto_constants',
+        description: 'Cryptographic constants',
+        severity: 'low',
+        pattern: /0x67452301|0xefcdab89|0x98badcfe|0x10325476/i
+    }
+];
+
+/**
+ * HIPAA Compliance Module for Pompelmi
+ *
+ * This module provides comprehensive HIPAA compliance features for healthcare environments
+ * where Pompelmi is used to analyze potentially compromised systems containing PHI.
+ *
+ * Key protections:
+ * - Data sanitization and redaction
+ * - Secure temporary file handling
+ * - Audit logging
+ * - Memory protection
+ * - Error message sanitization
+ */
+class HipaaComplianceManager {
+    constructor(config) {
+        this.auditEvents = [];
+        this.config = {
+            sanitizeErrors: true,
+            sanitizeFilenames: true,
+            encryptTempFiles: true,
+            memoryProtection: true,
+            requireSecureTransport: true,
+            ...config,
+            enabled: config.enabled !== undefined ? config.enabled : true
+        };
+        this.sessionId = this.generateSessionId();
+    }
+    /**
+     * Sanitize filename to prevent PHI leakage in logs
+     */
+    sanitizeFilename(filename) {
+        if (!this.config.enabled || !this.config.sanitizeFilenames || !filename) {
+            return filename || 'unknown';
+        }
+        // Remove potentially sensitive path information
+        const basename = path__namespace.basename(filename);
+        // Hash the filename to create a consistent but non-revealing identifier
+        const hash = crypto__namespace.createHash('sha256').update(basename).digest('hex').substring(0, 8);
+        // Preserve file extension for analysis purposes
+        const ext = path__namespace.extname(basename);
+        return `file_${hash}${ext}`;
+    }
+    /**
+     * Sanitize error messages to prevent PHI exposure
+     */
+    sanitizeError(error) {
+        if (!this.config.enabled || !this.config.sanitizeErrors) {
+            return typeof error === 'string' ? error : error.message;
+        }
+        const message = typeof error === 'string' ? error : error.message;
+        // Remove common patterns that might contain PHI
+        let sanitized = message
+            // Remove file paths
+            .replace(/[A-Za-z]:\\\\[^\\s]+/g, '[REDACTED_PATH]')
+            .replace(/\/[^\\s]+/g, '[REDACTED_PATH]')
+            // Remove potential patient identifiers (numbers that could be MRNs, SSNs)
+            .replace(/\\b\\d{3}-?\\d{2}-?\\d{4}\\b/g, '[REDACTED_ID]')
+            .replace(/\\b\\d{6,}\\b/g, '[REDACTED_ID]')
+            // Remove email addresses
+            .replace(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}/g, '[REDACTED_EMAIL]')
+            // Remove potential names (capitalize words in error messages)
+            .replace(/\\b[A-Z][a-z]+\\s+[A-Z][a-z]+\\b/g, '[REDACTED_NAME]')
+            // Remove IP addresses
+            .replace(/\\b(?:\\d{1,3}\\.){3}\\d{1,3}\\b/g, '[REDACTED_IP]');
+        return sanitized;
+    }
+    /**
+     * Create secure temporary file path with encryption if enabled
+     */
+    createSecureTempPath(prefix = 'pompelmi') {
+        if (!this.config.enabled) {
+            return path__namespace.join(os__namespace.tmpdir(), `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        }
+        // Use cryptographically secure random names
+        const randomId = crypto__namespace.randomBytes(16).toString('hex');
+        const timestamp = Date.now();
+        // Create path in secure temp directory
+        const secureTempDir = this.getSecureTempDir();
+        const tempPath = path__namespace.join(secureTempDir, `${prefix}-${timestamp}-${randomId}`);
+        this.auditLog('temp_file_created', {
+            action: 'create_temp_file',
+            success: true,
+            metadata: { path: this.sanitizeFilename(tempPath) }
+        });
+        return tempPath;
+    }
+    /**
+     * Get or create secure temporary directory with restricted permissions
+     */
+    getSecureTempDir() {
+        const secureTempPath = path__namespace.join(os__namespace.tmpdir(), 'pompelmi-secure');
+        try {
+            const fs = require('fs');
+            if (!fs.existsSync(secureTempPath)) {
+                fs.mkdirSync(secureTempPath, { mode: 0o700 }); // Owner read/write/execute only
+            }
+        }
+        catch (error) {
+            // Fallback to system temp
+            return os__namespace.tmpdir();
+        }
+        return secureTempPath;
+    }
+    /**
+     * Secure file cleanup with multiple overwrite passes
+     */
+    async secureFileCleanup(filePath) {
+        if (!this.config.enabled) {
+            try {
+                const fs = await import('fs/promises');
+                await fs.unlink(filePath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            return;
+        }
+        try {
+            const fs = await import('fs/promises');
+            const stats = await fs.stat(filePath);
+            if (this.config.memoryProtection) {
+                // Overwrite file with random data multiple times (DoD 5220.22-M standard)
+                const fileSize = stats.size;
+                const buffer = crypto__namespace.randomBytes(Math.min(fileSize, 64 * 1024)); // 64KB chunks
+                for (let pass = 0; pass < 3; pass++) {
+                    const handle = await fs.open(filePath, 'r+');
+                    try {
+                        for (let offset = 0; offset < fileSize; offset += buffer.length) {
+                            const chunk = offset + buffer.length > fileSize
+                                ? buffer.subarray(0, fileSize - offset)
+                                : buffer;
+                            await handle.write(chunk, 0, chunk.length, offset);
+                        }
+                        await handle.sync();
+                    }
+                    finally {
+                        await handle.close();
+                    }
+                }
+            }
+            // Final deletion
+            await fs.unlink(filePath);
+            this.auditLog('temp_file_deleted', {
+                action: 'secure_delete',
+                success: true,
+                metadata: {
+                    path: this.sanitizeFilename(filePath),
+                    overwritePasses: this.config.memoryProtection ? 3 : 0
+                }
+            });
+        }
+        catch (error) {
+            this.auditLog('temp_file_deleted', {
+                action: 'secure_delete',
+                success: false,
+                sanitizedError: this.sanitizeError(error),
+                metadata: { path: this.sanitizeFilename(filePath) }
+            });
+        }
+    }
+    /**
+     * Calculate secure file hash for audit purposes
+     */
+    calculateFileHash(data) {
+        return crypto__namespace.createHash('sha256').update(data).digest('hex');
+    }
+    /**
+     * Log audit event
+     */
+    auditLog(eventType, details) {
+        if (!this.config.enabled)
+            return;
+        const event = {
+            timestamp: new Date().toISOString(),
+            eventType,
+            sessionId: this.sessionId,
+            details: {
+                action: details.action || 'unknown',
+                success: details.success ?? true,
+                ...details
+            }
+        };
+        this.auditEvents.push(event);
+        // Write to audit log file if configured
+        if (this.config.auditLogPath) {
+            this.writeAuditLog(event).catch(() => {
+                // Silent failure to prevent error loops
+            });
+        }
+    }
+    /**
+     * Write audit event to file
+     */
+    async writeAuditLog(event) {
+        if (!this.config.auditLogPath)
+            return;
+        try {
+            const fs = await import('fs/promises');
+            const logLine = JSON.stringify(event) + '\\n';
+            await fs.appendFile(this.config.auditLogPath, logLine, { flag: 'a' });
+        }
+        catch {
+            // Silent failure
+        }
+    }
+    /**
+     * Generate cryptographically secure session ID
+     */
+    generateSessionId() {
+        return crypto__namespace.randomBytes(16).toString('hex');
+    }
+    /**
+     * Get current audit events for this session
+     */
+    getAuditEvents() {
+        return [...this.auditEvents];
+    }
+    /**
+     * Clear sensitive data from memory
+     */
+    clearSensitiveData() {
+        if (!this.config.enabled || !this.config.memoryProtection)
+            return;
+        // Clear audit events
+        this.auditEvents.length = 0;
+        // Force garbage collection if available
+        if (global.gc) {
+            global.gc();
+        }
+    }
+    /**
+     * Validate transport security
+     */
+    validateTransportSecurity(url) {
+        if (!this.config.enabled || !this.config.requireSecureTransport) {
+            return true;
+        }
+        if (!url)
+            return true;
+        try {
+            const urlObj = new URL(url);
+            const isSecure = urlObj.protocol === 'https:' || urlObj.hostname === 'localhost' || urlObj.hostname === '127.0.0.1';
+            if (!isSecure) {
+                this.auditLog('security_violation', {
+                    action: 'insecure_transport',
+                    success: false,
+                    metadata: { protocol: urlObj.protocol, hostname: urlObj.hostname }
+                });
+            }
+            return isSecure;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+// Global HIPAA compliance instance
+let hipaaManager = null;
+/**
+ * Initialize HIPAA compliance
+ */
+function initializeHipaaCompliance(config) {
+    hipaaManager = new HipaaComplianceManager(config);
+    return hipaaManager;
+}
+/**
+ * Get current HIPAA compliance manager
+ */
+function getHipaaManager() {
+    return hipaaManager;
+}
+/**
+ * HIPAA-compliant error wrapper
+ */
+function createHipaaError(error, context) {
+    const manager = getHipaaManager();
+    if (!manager) {
+        return typeof error === 'string' ? new Error(error) : error;
+    }
+    const sanitizedMessage = manager.sanitizeError(error);
+    const hipaaError = new Error(sanitizedMessage);
+    manager.auditLog('error_occurred', {
+        action: context || 'error',
+        success: false,
+        sanitizedError: sanitizedMessage
+    });
+    return hipaaError;
+}
+/**
+ * HIPAA-compliant temporary file utilities
+ */
+const HipaaTemp = {
+    createPath: (prefix) => {
+        const manager = getHipaaManager();
+        return manager ? manager.createSecureTempPath(prefix) : path__namespace.join(os__namespace.tmpdir(), `${prefix || 'pompelmi'}-${Date.now()}`);
+    },
+    cleanup: async (filePath) => {
+        const manager = getHipaaManager();
+        if (manager) {
+            await manager.secureFileCleanup(filePath);
+        }
+        else {
+            try {
+                const fs = await import('fs/promises');
+                await fs.unlink(filePath);
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+    }
+};
+
 function mapMatchesToVerdict(matches = []) {
     if (!matches.length)
         return 'clean';
@@ -2326,10 +2786,17 @@ function definePolicy(input = {}) {
 
 exports.CommonHeuristicsScanner = CommonHeuristicsScanner;
 exports.DEFAULT_POLICY = DEFAULT_POLICY;
+exports.HipaaComplianceManager = HipaaComplianceManager;
+exports.HipaaTemp = HipaaTemp;
+exports.PRESET_CONFIGS = PRESET_CONFIGS;
+exports.SUSPICIOUS_PATTERNS = SUSPICIOUS_PATTERNS;
 exports.composeScanners = composeScanners;
+exports.createHipaaError = createHipaaError;
 exports.createPresetScanner = createPresetScanner;
 exports.createZipBombGuard = createZipBombGuard;
 exports.definePolicy = definePolicy;
+exports.getHipaaManager = getHipaaManager;
+exports.initializeHipaaCompliance = initializeHipaaCompliance;
 exports.mapMatchesToVerdict = mapMatchesToVerdict;
 exports.scanBytes = scanBytes;
 exports.scanFile = scanFile;