@push.rocks/smartproxy 21.0.0 → 21.1.1

package/dist_ts/detection/protocol-detector.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Protocol Detector
+ *
+ * Simplified protocol detection using the new architecture
+ */
+import type { IDetectionResult, IDetectionOptions } from './models/detection-types.js';
+import type { IConnectionContext } from '../protocols/common/types.js';
+/**
+ * Main protocol detector class
+ */
+export declare class ProtocolDetector {
+    private static instance;
+    private fragmentManager;
+    private tlsDetector;
+    private httpDetector;
+    constructor();
+    private static getInstance;
+    /**
+     * Detect protocol from buffer data
+     */
+    static detect(buffer: Buffer, options?: IDetectionOptions): Promise<IDetectionResult>;
+    private detectInstance;
+    /**
+     * Detect protocol with connection tracking for fragmented data
+     * @deprecated Use detectWithContext instead
+     */
+    static detectWithConnectionTracking(buffer: Buffer, connectionId: string, options?: IDetectionOptions): Promise<IDetectionResult>;
+    /**
+     * Detect protocol with connection context for fragmented data
+     */
+    static detectWithContext(buffer: Buffer, context: IConnectionContext, options?: IDetectionOptions): Promise<IDetectionResult>;
+    private detectWithContextInstance;
+    /**
+     * Clean up resources
+     */
+    static cleanup(): void;
+    private cleanupInstance;
+    /**
+     * Destroy detector instance
+     */
+    static destroy(): void;
+    private destroyInstance;
+    /**
+     * Clean up old connection tracking entries
+     *
+     * @param maxAge Maximum age in milliseconds (default: 30 seconds)
+     */
+    static cleanupConnections(maxAge?: number): void;
+    /**
+     * Extract domain from connection info
+     */
+    static extractDomain(connectionInfo: any): string | undefined;
+    /**
+     * Create a connection ID from connection parameters
+     * @deprecated Use createConnectionContext instead
+     */
+    static createConnectionId(params: {
+        sourceIp?: string;
+        sourcePort?: number;
+        destIp?: string;
+        destPort?: number;
+        socketId?: string;
+    }): string;
+    /**
+     * Create a connection context from parameters
+     */
+    static createConnectionContext(params: {
+        sourceIp?: string;
+        sourcePort?: number;
+        destIp?: string;
+        destPort?: number;
+        socketId?: string;
+    }): IConnectionContext;
+}

package/dist_ts/detection/protocol-detector.js

@@ -0,0 +1,173 @@
+/**
+ * Protocol Detector
+ *
+ * Simplified protocol detection using the new architecture
+ */
+import { TlsDetector } from './detectors/tls-detector.js';
+import { HttpDetector } from './detectors/http-detector.js';
+import { DetectionFragmentManager } from './utils/fragment-manager.js';
+/**
+ * Main protocol detector class
+ */
+export class ProtocolDetector {
+    constructor() {
+        this.fragmentManager = new DetectionFragmentManager();
+        this.tlsDetector = new TlsDetector();
+        this.httpDetector = new HttpDetector(this.fragmentManager);
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new ProtocolDetector();
+        }
+        return this.instance;
+    }
+    /**
+     * Detect protocol from buffer data
+     */
+    static async detect(buffer, options) {
+        return this.getInstance().detectInstance(buffer, options);
+    }
+    async detectInstance(buffer, options) {
+        // Quick sanity check
+        if (!buffer || buffer.length === 0) {
+            return {
+                protocol: 'unknown',
+                connectionInfo: { protocol: 'unknown' },
+                isComplete: true
+            };
+        }
+        // Try TLS detection first (more specific)
+        if (this.tlsDetector.canHandle(buffer)) {
+            const tlsResult = this.tlsDetector.detect(buffer, options);
+            if (tlsResult) {
+                return tlsResult;
+            }
+        }
+        // Try HTTP detection
+        if (this.httpDetector.canHandle(buffer)) {
+            const httpResult = this.httpDetector.detect(buffer, options);
+            if (httpResult) {
+                return httpResult;
+            }
+        }
+        // Neither TLS nor HTTP
+        return {
+            protocol: 'unknown',
+            connectionInfo: { protocol: 'unknown' },
+            isComplete: true
+        };
+    }
+    /**
+     * Detect protocol with connection tracking for fragmented data
+     * @deprecated Use detectWithContext instead
+     */
+    static async detectWithConnectionTracking(buffer, connectionId, options) {
+        // Convert connection ID to context
+        const context = {
+            id: connectionId,
+            sourceIp: 'unknown',
+            sourcePort: 0,
+            destIp: 'unknown',
+            destPort: 0,
+            timestamp: Date.now()
+        };
+        return this.getInstance().detectWithContextInstance(buffer, context, options);
+    }
+    /**
+     * Detect protocol with connection context for fragmented data
+     */
+    static async detectWithContext(buffer, context, options) {
+        return this.getInstance().detectWithContextInstance(buffer, context, options);
+    }
+    async detectWithContextInstance(buffer, context, options) {
+        // Quick sanity check
+        if (!buffer || buffer.length === 0) {
+            return {
+                protocol: 'unknown',
+                connectionInfo: { protocol: 'unknown' },
+                isComplete: true
+            };
+        }
+        // First peek to determine protocol type
+        if (this.tlsDetector.canHandle(buffer)) {
+            const result = this.tlsDetector.detectWithContext(buffer, context, options);
+            if (result) {
+                return result;
+            }
+        }
+        if (this.httpDetector.canHandle(buffer)) {
+            const result = this.httpDetector.detectWithContext(buffer, context, options);
+            if (result) {
+                return result;
+            }
+        }
+        // Can't determine protocol
+        return {
+            protocol: 'unknown',
+            connectionInfo: { protocol: 'unknown' },
+            isComplete: false,
+            bytesNeeded: Math.max(this.tlsDetector.getMinimumBytes(), this.httpDetector.getMinimumBytes())
+        };
+    }
+    /**
+     * Clean up resources
+     */
+    static cleanup() {
+        this.getInstance().cleanupInstance();
+    }
+    cleanupInstance() {
+        this.fragmentManager.cleanup();
+    }
+    /**
+     * Destroy detector instance
+     */
+    static destroy() {
+        this.getInstance().destroyInstance();
+        this.instance = null;
+    }
+    destroyInstance() {
+        this.fragmentManager.destroy();
+    }
+    /**
+     * Clean up old connection tracking entries
+     *
+     * @param maxAge Maximum age in milliseconds (default: 30 seconds)
+     */
+    static cleanupConnections(maxAge = 30000) {
+        // Cleanup is now handled internally by the fragment manager
+        this.getInstance().fragmentManager.cleanup();
+    }
+    /**
+     * Extract domain from connection info
+     */
+    static extractDomain(connectionInfo) {
+        return connectionInfo.domain || connectionInfo.sni || connectionInfo.host;
+    }
+    /**
+     * Create a connection ID from connection parameters
+     * @deprecated Use createConnectionContext instead
+     */
+    static createConnectionId(params) {
+        // If socketId is provided, use it
+        if (params.socketId) {
+            return params.socketId;
+        }
+        // Otherwise create from connection tuple
+        const { sourceIp = 'unknown', sourcePort = 0, destIp = 'unknown', destPort = 0 } = params;
+        return `${sourceIp}:${sourcePort}-${destIp}:${destPort}`;
+    }
+    /**
+     * Create a connection context from parameters
+     */
+    static createConnectionContext(params) {
+        return {
+            id: params.socketId,
+            sourceIp: params.sourceIp || 'unknown',
+            sourcePort: params.sourcePort || 0,
+            destIp: params.destIp || 'unknown',
+            destPort: params.destPort || 0,
+            timestamp: Date.now()
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/detection/utils/buffer-utils.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Buffer manipulation utilities for protocol detection
+ */
+/**
+ * BufferAccumulator class for handling fragmented data
+ */
+export declare class BufferAccumulator {
+    private chunks;
+    private totalLength;
+    /**
+     * Append data to the accumulator
+     */
+    append(data: Buffer): void;
+    /**
+     * Get the accumulated buffer
+     */
+    getBuffer(): Buffer;
+    /**
+     * Get current buffer length
+     */
+    length(): number;
+    /**
+     * Clear all accumulated data
+     */
+    clear(): void;
+    /**
+     * Check if accumulator has minimum bytes
+     */
+    hasMinimumBytes(minBytes: number): boolean;
+}
+/**
+ * Read a big-endian 16-bit integer from buffer
+ */
+export declare function readUInt16BE(buffer: Buffer, offset: number): number;
+/**
+ * Read a big-endian 24-bit integer from buffer
+ */
+export declare function readUInt24BE(buffer: Buffer, offset: number): number;
+/**
+ * Find a byte sequence in a buffer
+ */
+export declare function findSequence(buffer: Buffer, sequence: Buffer, startOffset?: number): number;
+/**
+ * Extract a line from buffer (up to CRLF or LF)
+ */
+export declare function extractLine(buffer: Buffer, startOffset?: number): {
+    line: string;
+    nextOffset: number;
+} | null;
+/**
+ * Check if buffer starts with a string (case-insensitive)
+ */
+export declare function startsWithString(buffer: Buffer, str: string, offset?: number): boolean;
+/**
+ * Safe buffer slice that doesn't throw on out-of-bounds
+ */
+export declare function safeSlice(buffer: Buffer, start: number, end?: number): Buffer;
+/**
+ * Check if buffer contains printable ASCII
+ */
+export declare function isPrintableAscii(buffer: Buffer, length?: number): boolean;

package/dist_ts/detection/utils/buffer-utils.js

@@ -0,0 +1,127 @@
+/**
+ * Buffer manipulation utilities for protocol detection
+ */
+// Import from protocols
+import { HttpParser } from '../../protocols/http/index.js';
+/**
+ * BufferAccumulator class for handling fragmented data
+ */
+export class BufferAccumulator {
+    constructor() {
+        this.chunks = [];
+        this.totalLength = 0;
+    }
+    /**
+     * Append data to the accumulator
+     */
+    append(data) {
+        this.chunks.push(data);
+        this.totalLength += data.length;
+    }
+    /**
+     * Get the accumulated buffer
+     */
+    getBuffer() {
+        if (this.chunks.length === 0) {
+            return Buffer.alloc(0);
+        }
+        if (this.chunks.length === 1) {
+            return this.chunks[0];
+        }
+        return Buffer.concat(this.chunks, this.totalLength);
+    }
+    /**
+     * Get current buffer length
+     */
+    length() {
+        return this.totalLength;
+    }
+    /**
+     * Clear all accumulated data
+     */
+    clear() {
+        this.chunks = [];
+        this.totalLength = 0;
+    }
+    /**
+     * Check if accumulator has minimum bytes
+     */
+    hasMinimumBytes(minBytes) {
+        return this.totalLength >= minBytes;
+    }
+}
+/**
+ * Read a big-endian 16-bit integer from buffer
+ */
+export function readUInt16BE(buffer, offset) {
+    if (offset + 2 > buffer.length) {
+        throw new Error('Buffer too short for UInt16BE read');
+    }
+    return (buffer[offset] << 8) | buffer[offset + 1];
+}
+/**
+ * Read a big-endian 24-bit integer from buffer
+ */
+export function readUInt24BE(buffer, offset) {
+    if (offset + 3 > buffer.length) {
+        throw new Error('Buffer too short for UInt24BE read');
+    }
+    return (buffer[offset] << 16) | (buffer[offset + 1] << 8) | buffer[offset + 2];
+}
+/**
+ * Find a byte sequence in a buffer
+ */
+export function findSequence(buffer, sequence, startOffset = 0) {
+    if (sequence.length === 0) {
+        return startOffset;
+    }
+    const searchLength = buffer.length - sequence.length + 1;
+    for (let i = startOffset; i < searchLength; i++) {
+        let found = true;
+        for (let j = 0; j < sequence.length; j++) {
+            if (buffer[i + j] !== sequence[j]) {
+                found = false;
+                break;
+            }
+        }
+        if (found) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Extract a line from buffer (up to CRLF or LF)
+ */
+export function extractLine(buffer, startOffset = 0) {
+    // Delegate to protocol parser
+    return HttpParser.extractLine(buffer, startOffset);
+}
+/**
+ * Check if buffer starts with a string (case-insensitive)
+ */
+export function startsWithString(buffer, str, offset = 0) {
+    if (offset + str.length > buffer.length) {
+        return false;
+    }
+    const bufferStr = buffer.slice(offset, offset + str.length).toString('utf8');
+    return bufferStr.toLowerCase() === str.toLowerCase();
+}
+/**
+ * Safe buffer slice that doesn't throw on out-of-bounds
+ */
+export function safeSlice(buffer, start, end) {
+    const safeStart = Math.max(0, Math.min(start, buffer.length));
+    const safeEnd = end === undefined
+        ? buffer.length
+        : Math.max(safeStart, Math.min(end, buffer.length));
+    return buffer.slice(safeStart, safeEnd);
+}
+/**
+ * Check if buffer contains printable ASCII
+ */
+export function isPrintableAscii(buffer, length) {
+    // Delegate to protocol parser
+    return HttpParser.isPrintableAscii(buffer, length);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/detection/utils/fragment-manager.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Fragment Manager for Detection Module
+ *
+ * Manages fragmented protocol data using the shared fragment handler
+ */
+import { FragmentHandler } from '../../protocols/common/fragment-handler.js';
+import type { IConnectionContext } from '../../protocols/common/types.js';
+/**
+ * Detection-specific fragment manager
+ */
+export declare class DetectionFragmentManager {
+    private tlsFragments;
+    private httpFragments;
+    constructor();
+    /**
+     * Get fragment handler for protocol type
+     */
+    getHandler(protocol: 'tls' | 'http'): FragmentHandler;
+    /**
+     * Create connection ID from context
+     */
+    static createConnectionId(context: IConnectionContext): string;
+    /**
+     * Clean up all handlers
+     */
+    cleanup(): void;
+    /**
+     * Destroy all handlers
+     */
+    destroy(): void;
+}

package/dist_ts/detection/utils/fragment-manager.js

@@ -0,0 +1,53 @@
+/**
+ * Fragment Manager for Detection Module
+ *
+ * Manages fragmented protocol data using the shared fragment handler
+ */
+import { FragmentHandler } from '../../protocols/common/fragment-handler.js';
+/**
+ * Detection-specific fragment manager
+ */
+export class DetectionFragmentManager {
+    constructor() {
+        // Configure fragment handlers with appropriate limits
+        const tlsOptions = {
+            maxBufferSize: 16384, // TLS record max size
+            timeout: 5000,
+            cleanupInterval: 30000
+        };
+        const httpOptions = {
+            maxBufferSize: 8192, // HTTP header reasonable limit
+            timeout: 5000,
+            cleanupInterval: 30000
+        };
+        this.tlsFragments = new FragmentHandler(tlsOptions);
+        this.httpFragments = new FragmentHandler(httpOptions);
+    }
+    /**
+     * Get fragment handler for protocol type
+     */
+    getHandler(protocol) {
+        return protocol === 'tls' ? this.tlsFragments : this.httpFragments;
+    }
+    /**
+     * Create connection ID from context
+     */
+    static createConnectionId(context) {
+        return context.id || `${context.sourceIp}:${context.sourcePort}-${context.destIp}:${context.destPort}`;
+    }
+    /**
+     * Clean up all handlers
+     */
+    cleanup() {
+        this.tlsFragments.cleanup();
+        this.httpFragments.cleanup();
+    }
+    /**
+     * Destroy all handlers
+     */
+    destroy() {
+        this.tlsFragments.destroy();
+        this.httpFragments.destroy();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZnJhZ21lbnQtbWFuYWdlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2RldGVjdGlvbi91dGlscy9mcmFnbWVudC1tYW5hZ2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFFSCxPQUFPLEVBQUUsZUFBZSxFQUF5QixNQUFNLDRDQUE0QyxDQUFDO0FBR3BHOztHQUVHO0FBQ0gsTUFBTSxPQUFPLHdCQUF3QjtJQUluQztRQUNFLHNEQUFzRDtRQUN0RCxNQUFNLFVBQVUsR0FBcUI7WUFDbkMsYUFBYSxFQUFFLEtBQUssRUFBRyxzQkFBc0I7WUFDN0MsT0FBTyxFQUFFLElBQUk7WUFDYixlQUFlLEVBQUUsS0FBSztTQUN2QixDQUFDO1FBRUYsTUFBTSxXQUFXLEdBQXFCO1lBQ3BDLGFBQWEsRUFBRSxJQUFJLEVBQUksK0JBQStCO1lBQ3RELE9BQU8sRUFBRSxJQUFJO1lBQ2IsZUFBZSxFQUFFLEtBQUs7U0FDdkIsQ0FBQztRQUVGLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxlQUFlLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDcEQsSUFBSSxDQUFDLGFBQWEsR0FBRyxJQUFJLGVBQWUsQ0FBQyxXQUFXLENBQUMsQ0FBQztJQUN4RCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxVQUFVLENBQUMsUUFBd0I7UUFDakMsT0FBTyxRQUFRLEtBQUssS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDO0lBQ3JFLENBQUM7SUFFRDs7T0FFRztJQUNILE1BQU0sQ0FBQyxrQkFBa0IsQ0FBQyxPQUEyQjtRQUNuRCxPQUFPLE9BQU8sQ0FBQyxFQUFFLElBQUksR0FBRyxPQUFPLENBQUMsUUFBUSxJQUFJLE9BQU8sQ0FBQyxVQUFVLElBQUksT0FBTyxDQUFDLE1BQU0sSUFBSSxPQUFPLENBQUMsUUFBUSxFQUFFLENBQUM7SUFDekcsQ0FBQztJQUVEOztPQUVHO0lBQ0gsT0FBTztRQUNMLElBQUksQ0FBQyxZQUFZLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDNUIsSUFBSSxDQUFDLGFBQWEsQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUMvQixDQUFDO0lBRUQ7O09BRUc7SUFDSCxPQUFPO1FBQ0wsSUFBSSxDQUFDLFlBQVksQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUM1QixJQUFJLENBQUMsYUFBYSxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQy9CLENBQUM7Q0FDRiJ9

package/dist_ts/detection/utils/parser-utils.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Parser utilities for protocol detection
+ * Now delegates to protocol modules for actual parsing
+ */
+import type { THttpMethod, TTlsVersion } from '../models/detection-types.js';
+import { HTTP_METHODS, HTTP_VERSIONS } from '../../protocols/http/index.js';
+export { HTTP_METHODS, HTTP_VERSIONS };
+/**
+ * Parse HTTP request line
+ */
+export declare function parseHttpRequestLine(line: string): {
+    method: THttpMethod;
+    path: string;
+    version: string;
+} | null;
+/**
+ * Parse HTTP header line
+ */
+export declare function parseHttpHeader(line: string): {
+    name: string;
+    value: string;
+} | null;
+/**
+ * Parse HTTP headers from lines
+ */
+export declare function parseHttpHeaders(lines: string[]): Record<string, string>;
+/**
+ * Convert TLS version bytes to version string
+ */
+export declare function tlsVersionToString(major: number, minor: number): TTlsVersion | null;
+/**
+ * Extract domain from Host header value
+ */
+export declare function extractDomainFromHost(hostHeader: string): string;
+/**
+ * Validate domain name
+ */
+export declare function isValidDomain(domain: string): boolean;
+/**
+ * Check if string is a valid HTTP method
+ */
+export declare function isHttpMethod(str: string): str is THttpMethod;

package/dist_ts/detection/utils/parser-utils.js

@@ -0,0 +1,63 @@
+/**
+ * Parser utilities for protocol detection
+ * Now delegates to protocol modules for actual parsing
+ */
+import { HttpParser, HTTP_METHODS, HTTP_VERSIONS } from '../../protocols/http/index.js';
+import { tlsVersionToString as protocolTlsVersionToString } from '../../protocols/tls/index.js';
+// Re-export constants for backward compatibility
+export { HTTP_METHODS, HTTP_VERSIONS };
+/**
+ * Parse HTTP request line
+ */
+export function parseHttpRequestLine(line) {
+    // Delegate to protocol parser
+    const result = HttpParser.parseRequestLine(line);
+    return result ? {
+        method: result.method,
+        path: result.path,
+        version: result.version
+    } : null;
+}
+/**
+ * Parse HTTP header line
+ */
+export function parseHttpHeader(line) {
+    // Delegate to protocol parser
+    return HttpParser.parseHeaderLine(line);
+}
+/**
+ * Parse HTTP headers from lines
+ */
+export function parseHttpHeaders(lines) {
+    // Delegate to protocol parser
+    return HttpParser.parseHeaders(lines);
+}
+/**
+ * Convert TLS version bytes to version string
+ */
+export function tlsVersionToString(major, minor) {
+    // Delegate to protocol parser
+    return protocolTlsVersionToString(major, minor);
+}
+/**
+ * Extract domain from Host header value
+ */
+export function extractDomainFromHost(hostHeader) {
+    // Delegate to protocol parser
+    return HttpParser.extractDomainFromHost(hostHeader);
+}
+/**
+ * Validate domain name
+ */
+export function isValidDomain(domain) {
+    // Delegate to protocol parser
+    return HttpParser.isValidDomain(domain);
+}
+/**
+ * Check if string is a valid HTTP method
+ */
+export function isHttpMethod(str) {
+    // Delegate to protocol parser
+    return HttpParser.isHttpMethod(str) && str !== undefined;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2VyLXV0aWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvZGV0ZWN0aW9uL3V0aWxzL3BhcnNlci11dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7O0dBR0c7QUFHSCxPQUFPLEVBQUUsVUFBVSxFQUFFLFlBQVksRUFBRSxhQUFhLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUN4RixPQUFPLEVBQUUsa0JBQWtCLElBQUksMEJBQTBCLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUVoRyxpREFBaUQ7QUFDakQsT0FBTyxFQUFFLFlBQVksRUFBRSxhQUFhLEVBQUUsQ0FBQztBQUV2Qzs7R0FFRztBQUNILE1BQU0sVUFBVSxvQkFBb0IsQ0FBQyxJQUFZO0lBSy9DLDhCQUE4QjtJQUM5QixNQUFNLE1BQU0sR0FBRyxVQUFVLENBQUMsZ0JBQWdCLENBQUMsSUFBSSxDQUFDLENBQUM7SUFDakQsT0FBTyxNQUFNLENBQUMsQ0FBQyxDQUFDO1FBQ2QsTUFBTSxFQUFFLE1BQU0sQ0FBQyxNQUFxQjtRQUNwQyxJQUFJLEVBQUUsTUFBTSxDQUFDLElBQUk7UUFDakIsT0FBTyxFQUFFLE1BQU0sQ0FBQyxPQUFPO0tBQ3hCLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztBQUNYLENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sVUFBVSxlQUFlLENBQUMsSUFBWTtJQUMxQyw4QkFBOEI7SUFDOUIsT0FBTyxVQUFVLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQzFDLENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sVUFBVSxnQkFBZ0IsQ0FBQyxLQUFlO0lBQzlDLDhCQUE4QjtJQUM5QixPQUFPLFVBQVUsQ0FBQyxZQUFZLENBQUMsS0FBSyxDQUFDLENBQUM7QUFDeEMsQ0FBQztBQUVEOztHQUVHO0FBQ0gsTUFBTSxVQUFVLGtCQUFrQixDQUFDLEtBQWEsRUFBRSxLQUFhO0lBQzdELDhCQUE4QjtJQUM5QixPQUFPLDBCQUEwQixDQUFDLEtBQUssRUFBRSxLQUFLLENBQWdCLENBQUM7QUFDakUsQ0FBQztBQUVEOztHQUVHO0FBQ0gsTUFBTSxVQUFVLHFCQUFxQixDQUFDLFVBQWtCO0lBQ3RELDhCQUE4QjtJQUM5QixPQUFPLFVBQVUsQ0FBQyxxQkFBcUIsQ0FBQyxVQUFVLENBQUMsQ0FBQztBQUN0RCxDQUFDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsYUFBYSxDQUFDLE1BQWM7SUFDMUMsOEJBQThCO0lBQzlCLE9BQU8sVUFBVSxDQUFDLGFBQWEsQ0FBQyxNQUFNLENBQUMsQ0FBQztBQUMxQyxDQUFDO0FBRUQ7O0dBRUc7QUFDSCxNQUFNLFVBQVUsWUFBWSxDQUFDLEdBQVc7SUFDdEMsOEJBQThCO0lBQzlCLE9BQU8sVUFBVSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsSUFBSyxHQUFtQixLQUFLLFNBQVMsQ0FBQztBQUM1RSxDQUFDIn0=

package/dist_ts/index.d.ts

@@ -16,3 +16,5 @@ export * from './core/models/common-types.js';
 export type { IAcmeOptions } from './proxies/smart-proxy/models/interfaces.js';
 export * as tls from './tls/index.js';
 export * as routing from './routing/index.js';
+export * as detection from './detection/index.js';
+export * as protocols from './protocols/index.js';

package/dist_ts/index.js

@@ -21,4 +21,6 @@ export * from './core/models/common-types.js';
 // Certificate module has been removed - use SmartCertManager instead
 export * as tls from './tls/index.js';
 export * as routing from './routing/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILHlCQUF5QjtBQUN6QixjQUFjLG1DQUFtQyxDQUFDO0FBRWxELDRCQUE0QjtBQUM1QixPQUFPLEVBQUUsU0FBUyxFQUFFLGtCQUFrQixFQUFFLGNBQWMsRUFBRSxjQUFjLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUdoSSxPQUFPLEVBQUUsa0JBQWtCLElBQUkscUJBQXFCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUU5Rix5RUFBeUU7QUFDekUsT0FBTyxFQUFFLFVBQVUsRUFBRSxpQkFBaUIsRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUUsc0JBQXNCLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN2TCxPQUFPLEVBQUUsa0JBQWtCLElBQUksWUFBWSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFJckYsY0FBYyxzQ0FBc0MsQ0FBQztBQUVyRCxrRUFBa0U7QUFDbEUsb0NBQW9DO0FBQ3BDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN0RCxrRUFBa0U7QUFDbEUscUVBQXFFO0FBRXJFLDJCQUEyQjtBQUMzQixjQUFjLCtCQUErQixDQUFDO0FBSzlDLHVDQUF1QztBQUN2QyxxRUFBcUU7QUFDckUsT0FBTyxLQUFLLEdBQUcsTUFBTSxnQkFBZ0IsQ0FBQztBQUN0QyxPQUFPLEtBQUssT0FBTyxNQUFNLG9CQUFvQixDQUFDIn0=
+export * as detection from './detection/index.js';
+export * as protocols from './protocols/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILHlCQUF5QjtBQUN6QixjQUFjLG1DQUFtQyxDQUFDO0FBRWxELDRCQUE0QjtBQUM1QixPQUFPLEVBQUUsU0FBUyxFQUFFLGtCQUFrQixFQUFFLGNBQWMsRUFBRSxjQUFjLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUdoSSxPQUFPLEVBQUUsa0JBQWtCLElBQUkscUJBQXFCLEVBQUUsTUFBTSxpQ0FBaUMsQ0FBQztBQUU5Rix5RUFBeUU7QUFDekUsT0FBTyxFQUFFLFVBQVUsRUFBRSxpQkFBaUIsRUFBRSxlQUFlLEVBQUUsY0FBYyxFQUFFLFVBQVUsRUFBRSxlQUFlLEVBQUUsc0JBQXNCLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN2TCxPQUFPLEVBQUUsa0JBQWtCLElBQUksWUFBWSxFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFJckYsY0FBYyxzQ0FBc0MsQ0FBQztBQUVyRCxrRUFBa0U7QUFDbEUsb0NBQW9DO0FBQ3BDLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUN0RCxrRUFBa0U7QUFDbEUscUVBQXFFO0FBRXJFLDJCQUEyQjtBQUMzQixjQUFjLCtCQUErQixDQUFDO0FBSzlDLHVDQUF1QztBQUN2QyxxRUFBcUU7QUFDckUsT0FBTyxLQUFLLEdBQUcsTUFBTSxnQkFBZ0IsQ0FBQztBQUN0QyxPQUFPLEtBQUssT0FBTyxNQUFNLG9CQUFvQixDQUFDO0FBQzlDLE9BQU8sS0FBSyxTQUFTLE1BQU0sc0JBQXNCLENBQUM7QUFDbEQsT0FBTyxLQUFLLFNBQVMsTUFBTSxzQkFBc0IsQ0FBQyJ9