@push.rocks/smartproxy 19.5.18 → 19.5.20

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartproxy',
-    version: '19.5.3',
+    version: '19.5.19',
     description: 'A powerful proxy package with unified route-based configuration for high traffic management. Features include SSL/TLS support, flexible routing patterns, WebSocket handling, advanced security options, and automatic ACME certificate management.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLHFQQUFxUDtDQUNuUSxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFNBQVM7SUFDbEIsV0FBVyxFQUFFLHFQQUFxUDtDQUNuUSxDQUFBIn0=

package/dist_ts/core/models/index.d.ts

@@ -4,3 +4,5 @@
 export * from './common-types.js';
 export * from './socket-augmentation.js';
 export * from './route-context.js';
+export * from './wrapped-socket.js';
+export * from './socket-types.js';

package/dist_ts/core/models/index.js

@@ -4,4 +4,6 @@
 export * from './common-types.js';
 export * from './socket-augmentation.js';
 export * from './route-context.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jb3JlL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLG9CQUFvQixDQUFDIn0=
+export * from './wrapped-socket.js';
+export * from './socket-types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jb3JlL21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxtQkFBbUIsQ0FBQyJ9

package/dist_ts/core/models/socket-types.d.ts

@@ -0,0 +1,14 @@
+import * as net from 'net';
+import { WrappedSocket } from './wrapped-socket.js';
+/**
+ * Type guard to check if a socket is a WrappedSocket
+ */
+export declare function isWrappedSocket(socket: net.Socket | WrappedSocket): socket is WrappedSocket;
+/**
+ * Helper to get the underlying socket from either a Socket or WrappedSocket
+ */
+export declare function getUnderlyingSocket(socket: net.Socket | WrappedSocket): net.Socket;
+/**
+ * Type that represents either a regular socket or a wrapped socket
+ */
+export type AnySocket = net.Socket | WrappedSocket;

package/dist_ts/core/models/socket-types.js

@@ -0,0 +1,15 @@
+import * as net from 'net';
+import { WrappedSocket } from './wrapped-socket.js';
+/**
+ * Type guard to check if a socket is a WrappedSocket
+ */
+export function isWrappedSocket(socket) {
+    return socket instanceof WrappedSocket || 'socket' in socket;
+}
+/**
+ * Helper to get the underlying socket from either a Socket or WrappedSocket
+ */
+export function getUnderlyingSocket(socket) {
+    return isWrappedSocket(socket) ? socket.socket : socket;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ja2V0LXR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvY29yZS9tb2RlbHMvc29ja2V0LXR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxHQUFHLE1BQU0sS0FBSyxDQUFDO0FBQzNCLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUVwRDs7R0FFRztBQUNILE1BQU0sVUFBVSxlQUFlLENBQUMsTUFBa0M7SUFDaEUsT0FBTyxNQUFNLFlBQVksYUFBYSxJQUFJLFFBQVEsSUFBSSxNQUFNLENBQUM7QUFDL0QsQ0FBQztBQUVEOztHQUVHO0FBQ0gsTUFBTSxVQUFVLG1CQUFtQixDQUFDLE1BQWtDO0lBQ3BFLE9BQU8sZUFBZSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUM7QUFDMUQsQ0FBQyJ9

package/dist_ts/core/models/wrapped-socket.d.ts

@@ -0,0 +1,34 @@
+import * as plugins from '../../plugins.js';
+/**
+ * WrappedSocket wraps a regular net.Socket to provide transparent access
+ * to the real client IP and port when behind a proxy using PROXY protocol.
+ *
+ * This is the FOUNDATION for all PROXY protocol support and must be implemented
+ * before any protocol parsing can occur.
+ *
+ * This implementation uses a Proxy to delegate all properties and methods
+ * to the underlying socket while allowing override of specific properties.
+ */
+export declare class WrappedSocket {
+    readonly socket: plugins.net.Socket;
+    private realClientIP?;
+    private realClientPort?;
+    [key: string]: any;
+    constructor(socket: plugins.net.Socket, realClientIP?: string, realClientPort?: number);
+    /**
+     * Returns the real client IP if available, otherwise the socket's remote address
+     */
+    get remoteAddress(): string | undefined;
+    /**
+     * Returns the real client port if available, otherwise the socket's remote port
+     */
+    get remotePort(): number | undefined;
+    /**
+     * Indicates if this connection came through a trusted proxy
+     */
+    get isFromTrustedProxy(): boolean;
+    /**
+     * Updates the real client information (called after parsing PROXY protocol)
+     */
+    setProxyInfo(ip: string, port: number): void;
+}

package/dist_ts/core/models/wrapped-socket.js

@@ -0,0 +1,82 @@
+import * as plugins from '../../plugins.js';
+/**
+ * WrappedSocket wraps a regular net.Socket to provide transparent access
+ * to the real client IP and port when behind a proxy using PROXY protocol.
+ *
+ * This is the FOUNDATION for all PROXY protocol support and must be implemented
+ * before any protocol parsing can occur.
+ *
+ * This implementation uses a Proxy to delegate all properties and methods
+ * to the underlying socket while allowing override of specific properties.
+ */
+export class WrappedSocket {
+    constructor(socket, realClientIP, realClientPort) {
+        this.socket = socket;
+        this.realClientIP = realClientIP;
+        this.realClientPort = realClientPort;
+        // Create a proxy that delegates everything to the underlying socket
+        return new Proxy(this, {
+            get(target, prop, receiver) {
+                // Override specific properties
+                if (prop === 'remoteAddress') {
+                    return target.remoteAddress;
+                }
+                if (prop === 'remotePort') {
+                    return target.remotePort;
+                }
+                if (prop === 'socket') {
+                    return target.socket;
+                }
+                if (prop === 'realClientIP') {
+                    return target.realClientIP;
+                }
+                if (prop === 'realClientPort') {
+                    return target.realClientPort;
+                }
+                if (prop === 'isFromTrustedProxy') {
+                    return target.isFromTrustedProxy;
+                }
+                if (prop === 'setProxyInfo') {
+                    return target.setProxyInfo.bind(target);
+                }
+                // For all other properties/methods, delegate to the underlying socket
+                const value = target.socket[prop];
+                if (typeof value === 'function') {
+                    return value.bind(target.socket);
+                }
+                return value;
+            },
+            set(target, prop, value) {
+                // Set on the underlying socket
+                target.socket[prop] = value;
+                return true;
+            }
+        });
+    }
+    /**
+     * Returns the real client IP if available, otherwise the socket's remote address
+     */
+    get remoteAddress() {
+        return this.realClientIP || this.socket.remoteAddress;
+    }
+    /**
+     * Returns the real client port if available, otherwise the socket's remote port
+     */
+    get remotePort() {
+        return this.realClientPort || this.socket.remotePort;
+    }
+    /**
+     * Indicates if this connection came through a trusted proxy
+     */
+    get isFromTrustedProxy() {
+        return !!this.realClientIP;
+    }
+    /**
+     * Updates the real client information (called after parsing PROXY protocol)
+     */
+    setProxyInfo(ip, port) {
+        this.realClientIP = ip;
+        this.realClientPort = port;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/core/routing/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Unified routing module
+ * Provides all routing functionality in a centralized location
+ */
+export * from './types.js';
+export * from './matchers/index.js';
+export * from './specificity.js';
+export * from './route-manager.js';
+export * from './route-utils.js';
+export { matchers } from './matchers/index.js';
+export { RouteSpecificity } from './specificity.js';

package/dist_ts/core/routing/index.js

@@ -0,0 +1,17 @@
+/**
+ * Unified routing module
+ * Provides all routing functionality in a centralized location
+ */
+// Export all types
+export * from './types.js';
+// Export all matchers
+export * from './matchers/index.js';
+// Export specificity calculator
+export * from './specificity.js';
+// Export route management
+export * from './route-manager.js';
+export * from './route-utils.js';
+// Convenience re-exports
+export { matchers } from './matchers/index.js';
+export { RouteSpecificity } from './specificity.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9jb3JlL3JvdXRpbmcvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBRUgsbUJBQW1CO0FBQ25CLGNBQWMsWUFBWSxDQUFDO0FBRTNCLHNCQUFzQjtBQUN0QixjQUFjLHFCQUFxQixDQUFDO0FBRXBDLGdDQUFnQztBQUNoQyxjQUFjLGtCQUFrQixDQUFDO0FBRWpDLDBCQUEwQjtBQUMxQixjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsa0JBQWtCLENBQUM7QUFFakMseUJBQXlCO0FBQ3pCLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQyJ9

package/dist_ts/core/routing/matchers/domain.d.ts

@@ -0,0 +1,34 @@
+import type { IMatcher, IDomainMatchOptions } from '../types.js';
+/**
+ * DomainMatcher provides comprehensive domain matching functionality
+ * Supporting exact matches, wildcards, and case-insensitive matching
+ */
+export declare class DomainMatcher implements IMatcher<boolean, IDomainMatchOptions> {
+    private static wildcardToRegex;
+    /**
+     * Match a domain pattern against a hostname
+     * @param pattern The pattern to match (supports wildcards like *.example.com)
+     * @param hostname The hostname to test
+     * @param options Matching options
+     * @returns true if the hostname matches the pattern
+     */
+    static match(pattern: string, hostname: string, options?: IDomainMatchOptions): boolean;
+    /**
+     * Check if a pattern contains wildcards
+     */
+    static isWildcardPattern(pattern: string): boolean;
+    /**
+     * Calculate the specificity of a domain pattern
+     * Higher values mean more specific patterns
+     */
+    static calculateSpecificity(pattern: string): number;
+    /**
+     * Find all matching patterns from a list
+     * Returns patterns sorted by specificity (most specific first)
+     */
+    static findAllMatches(patterns: string[], hostname: string, options?: IDomainMatchOptions): string[];
+    /**
+     * Instance method for interface compliance
+     */
+    match(pattern: string, hostname: string, options?: IDomainMatchOptions): boolean;
+}

package/dist_ts/core/routing/matchers/domain.js

@@ -0,0 +1,91 @@
+/**
+ * DomainMatcher provides comprehensive domain matching functionality
+ * Supporting exact matches, wildcards, and case-insensitive matching
+ */
+export class DomainMatcher {
+    static wildcardToRegex(pattern) {
+        // Escape special regex characters except *
+        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+        // Replace * with regex equivalent
+        const regexPattern = escaped.replace(/\*/g, '.*');
+        return new RegExp(`^${regexPattern}$`, 'i');
+    }
+    /**
+     * Match a domain pattern against a hostname
+     * @param pattern The pattern to match (supports wildcards like *.example.com)
+     * @param hostname The hostname to test
+     * @param options Matching options
+     * @returns true if the hostname matches the pattern
+     */
+    static match(pattern, hostname, options = {}) {
+        // Handle null/undefined cases
+        if (!pattern || !hostname) {
+            return false;
+        }
+        // Normalize inputs
+        const normalizedPattern = pattern.toLowerCase().trim();
+        const normalizedHostname = hostname.toLowerCase().trim();
+        // Remove trailing dots (FQDN normalization)
+        const cleanPattern = normalizedPattern.replace(/\.$/, '');
+        const cleanHostname = normalizedHostname.replace(/\.$/, '');
+        // Exact match (most common case)
+        if (cleanPattern === cleanHostname) {
+            return true;
+        }
+        // Wildcard matching
+        if (options.allowWildcards !== false && cleanPattern.includes('*')) {
+            const regex = this.wildcardToRegex(cleanPattern);
+            return regex.test(cleanHostname);
+        }
+        // No match
+        return false;
+    }
+    /**
+     * Check if a pattern contains wildcards
+     */
+    static isWildcardPattern(pattern) {
+        return pattern.includes('*');
+    }
+    /**
+     * Calculate the specificity of a domain pattern
+     * Higher values mean more specific patterns
+     */
+    static calculateSpecificity(pattern) {
+        if (!pattern)
+            return 0;
+        let score = 0;
+        // Exact domains are most specific
+        if (!pattern.includes('*')) {
+            score += 100;
+        }
+        // Count domain segments
+        const segments = pattern.split('.');
+        score += segments.length * 10;
+        // Penalize wildcards based on position
+        if (pattern.startsWith('*')) {
+            score -= 50; // Leading wildcard is very generic
+        }
+        else if (pattern.includes('*')) {
+            score -= 20; // Wildcard elsewhere is less generic
+        }
+        // Bonus for longer patterns
+        score += pattern.length;
+        return score;
+    }
+    /**
+     * Find all matching patterns from a list
+     * Returns patterns sorted by specificity (most specific first)
+     */
+    static findAllMatches(patterns, hostname, options = {}) {
+        const matches = patterns.filter(pattern => this.match(pattern, hostname, options));
+        // Sort by specificity (highest first)
+        return matches.sort((a, b) => this.calculateSpecificity(b) - this.calculateSpecificity(a));
+    }
+    /**
+     * Instance method for interface compliance
+     */
+    match(pattern, hostname, options) {
+        return DomainMatcher.match(pattern, hostname, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/core/routing/matchers/header.d.ts

@@ -0,0 +1,32 @@
+import type { IMatcher, IHeaderMatchOptions } from '../types.js';
+/**
+ * HeaderMatcher provides HTTP header matching functionality
+ * Supporting exact matches, patterns, and case-insensitive matching
+ */
+export declare class HeaderMatcher implements IMatcher<boolean, IHeaderMatchOptions> {
+    /**
+     * Match a header value against a pattern
+     * @param pattern The pattern to match
+     * @param value The header value to test
+     * @param options Matching options
+     * @returns true if the value matches the pattern
+     */
+    static match(pattern: string, value: string | undefined, options?: IHeaderMatchOptions): boolean;
+    /**
+     * Match multiple headers against a set of required headers
+     * @param requiredHeaders Headers that must match
+     * @param actualHeaders Actual request headers
+     * @param options Matching options
+     * @returns true if all required headers match
+     */
+    static matchAll(requiredHeaders: Record<string, string>, actualHeaders: Record<string, string | string[] | undefined>, options?: IHeaderMatchOptions): boolean;
+    /**
+     * Calculate the specificity of header requirements
+     * More headers = more specific
+     */
+    static calculateSpecificity(headers: Record<string, string>): number;
+    /**
+     * Instance method for interface compliance
+     */
+    match(pattern: string, value: string, options?: IHeaderMatchOptions): boolean;
+}

package/dist_ts/core/routing/matchers/header.js

@@ -0,0 +1,94 @@
+/**
+ * HeaderMatcher provides HTTP header matching functionality
+ * Supporting exact matches, patterns, and case-insensitive matching
+ */
+export class HeaderMatcher {
+    /**
+     * Match a header value against a pattern
+     * @param pattern The pattern to match
+     * @param value The header value to test
+     * @param options Matching options
+     * @returns true if the value matches the pattern
+     */
+    static match(pattern, value, options = {}) {
+        // Handle missing header
+        if (value === undefined || value === null) {
+            return pattern === '' || pattern === null || pattern === undefined;
+        }
+        // Convert to string and normalize
+        const normalizedPattern = String(pattern);
+        const normalizedValue = String(value);
+        // Apply case sensitivity
+        const comparePattern = options.caseInsensitive !== false
+            ? normalizedPattern.toLowerCase()
+            : normalizedPattern;
+        const compareValue = options.caseInsensitive !== false
+            ? normalizedValue.toLowerCase()
+            : normalizedValue;
+        // Exact match
+        if (options.exactMatch !== false) {
+            return comparePattern === compareValue;
+        }
+        // Pattern matching (simple wildcard support)
+        if (comparePattern.includes('*')) {
+            const regex = new RegExp('^' + comparePattern.replace(/\*/g, '.*') + '$', options.caseInsensitive !== false ? 'i' : '');
+            return regex.test(normalizedValue);
+        }
+        // Contains match (if not exact match mode)
+        return compareValue.includes(comparePattern);
+    }
+    /**
+     * Match multiple headers against a set of required headers
+     * @param requiredHeaders Headers that must match
+     * @param actualHeaders Actual request headers
+     * @param options Matching options
+     * @returns true if all required headers match
+     */
+    static matchAll(requiredHeaders, actualHeaders, options = {}) {
+        for (const [name, pattern] of Object.entries(requiredHeaders)) {
+            const headerName = options.caseInsensitive !== false
+                ? name.toLowerCase()
+                : name;
+            // Find the actual header (case-insensitive search if needed)
+            let actualValue;
+            if (options.caseInsensitive !== false) {
+                const actualKey = Object.keys(actualHeaders).find(key => key.toLowerCase() === headerName);
+                const rawValue = actualKey ? actualHeaders[actualKey] : undefined;
+                // Handle array values (multiple headers with same name)
+                actualValue = Array.isArray(rawValue) ? rawValue.join(', ') : rawValue;
+            }
+            else {
+                const rawValue = actualHeaders[name];
+                // Handle array values (multiple headers with same name)
+                actualValue = Array.isArray(rawValue) ? rawValue.join(', ') : rawValue;
+            }
+            // Check if this header matches
+            if (!this.match(pattern, actualValue, options)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Calculate the specificity of header requirements
+     * More headers = more specific
+     */
+    static calculateSpecificity(headers) {
+        const count = Object.keys(headers).length;
+        let score = count * 10;
+        // Bonus for headers without wildcards (more specific)
+        for (const value of Object.values(headers)) {
+            if (!value.includes('*')) {
+                score += 5;
+            }
+        }
+        return score;
+    }
+    /**
+     * Instance method for interface compliance
+     */
+    match(pattern, value, options) {
+        return HeaderMatcher.match(pattern, value, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/core/routing/matchers/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Unified matching utilities for the routing system
+ * All route matching logic should use these matchers for consistency
+ */
+export * from './domain.js';
+export * from './path.js';
+export * from './ip.js';
+export * from './header.js';
+import { DomainMatcher } from './domain.js';
+import { PathMatcher } from './path.js';
+import { IpMatcher } from './ip.js';
+import { HeaderMatcher } from './header.js';
+export declare const matchers: {
+    readonly domain: typeof DomainMatcher;
+    readonly path: typeof PathMatcher;
+    readonly ip: typeof IpMatcher;
+    readonly header: typeof HeaderMatcher;
+};

package/dist_ts/core/routing/matchers/index.js

@@ -0,0 +1,20 @@
+/**
+ * Unified matching utilities for the routing system
+ * All route matching logic should use these matchers for consistency
+ */
+export * from './domain.js';
+export * from './path.js';
+export * from './ip.js';
+export * from './header.js';
+// Re-export for convenience
+import { DomainMatcher } from './domain.js';
+import { PathMatcher } from './path.js';
+import { IpMatcher } from './ip.js';
+import { HeaderMatcher } from './header.js';
+export const matchers = {
+    domain: DomainMatcher,
+    path: PathMatcher,
+    ip: IpMatcher,
+    header: HeaderMatcher
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi90cy9jb3JlL3JvdXRpbmcvbWF0Y2hlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBRUgsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxhQUFhLENBQUM7QUFFNUIsNEJBQTRCO0FBQzVCLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDNUMsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLFdBQVcsQ0FBQztBQUN4QyxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQ3BDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFFNUMsTUFBTSxDQUFDLE1BQU0sUUFBUSxHQUFHO0lBQ3RCLE1BQU0sRUFBRSxhQUFhO0lBQ3JCLElBQUksRUFBRSxXQUFXO0lBQ2pCLEVBQUUsRUFBRSxTQUFTO0lBQ2IsTUFBTSxFQUFFLGFBQWE7Q0FDYixDQUFDIn0=

package/dist_ts/core/routing/matchers/ip.d.ts

@@ -0,0 +1,53 @@
+import type { IMatcher, IIpMatchOptions } from '../types.js';
+/**
+ * IpMatcher provides comprehensive IP address matching functionality
+ * Supporting exact matches, CIDR notation, ranges, and wildcards
+ */
+export declare class IpMatcher implements IMatcher<boolean, IIpMatchOptions> {
+    /**
+     * Check if a value is a valid IPv4 address
+     */
+    static isValidIpv4(ip: string): boolean;
+    /**
+     * Check if a value is a valid IPv6 address (simplified check)
+     */
+    static isValidIpv6(ip: string): boolean;
+    /**
+     * Convert IP address to numeric value for comparison
+     */
+    private static ipToNumber;
+    /**
+     * Match an IP against a CIDR notation pattern
+     */
+    static matchCidr(cidr: string, ip: string): boolean;
+    /**
+     * Match an IP against a wildcard pattern
+     */
+    static matchWildcard(pattern: string, ip: string): boolean;
+    /**
+     * Match an IP against a range (e.g., "192.168.1.1-192.168.1.100")
+     */
+    static matchRange(range: string, ip: string): boolean;
+    /**
+     * Match an IP pattern against an IP address
+     * Supports multiple formats:
+     * - Exact match: "192.168.1.1"
+     * - CIDR: "192.168.1.0/24"
+     * - Wildcard: "192.168.1.*"
+     * - Range: "192.168.1.1-192.168.1.100"
+     */
+    static match(pattern: string, ip: string, options?: IIpMatchOptions): boolean;
+    /**
+     * Check if an IP is authorized based on allow and block lists
+     */
+    static isAuthorized(ip: string, allowList?: string[], blockList?: string[]): boolean;
+    /**
+     * Calculate the specificity of an IP pattern
+     * Higher values mean more specific patterns
+     */
+    static calculateSpecificity(pattern: string): number;
+    /**
+     * Instance method for interface compliance
+     */
+    match(pattern: string, ip: string, options?: IIpMatchOptions): boolean;
+}