@push.rocks/smartproxy 15.0.2 → 16.0.2

package/dist_ts/proxies/smart-proxy/utils/route-utils.js

@@ -0,0 +1,266 @@
+/**
+ * Route Utilities
+ *
+ * This file provides utility functions for working with route configurations,
+ * including merging, finding, and managing route collections.
+ */
+import { validateRouteConfig } from './route-validators.js';
+/**
+ * Merge two route configurations
+ * The second route's properties will override the first route's properties where they exist
+ * @param baseRoute The base route configuration
+ * @param overrideRoute The route configuration with overriding properties
+ * @returns A new merged route configuration
+ */
+export function mergeRouteConfigs(baseRoute, overrideRoute) {
+    // Create deep copies to avoid modifying original objects
+    const mergedRoute = JSON.parse(JSON.stringify(baseRoute));
+    // Apply overrides at the top level
+    if (overrideRoute.id)
+        mergedRoute.id = overrideRoute.id;
+    if (overrideRoute.name)
+        mergedRoute.name = overrideRoute.name;
+    if (overrideRoute.enabled !== undefined)
+        mergedRoute.enabled = overrideRoute.enabled;
+    if (overrideRoute.priority !== undefined)
+        mergedRoute.priority = overrideRoute.priority;
+    // Merge match configuration
+    if (overrideRoute.match) {
+        mergedRoute.match = { ...mergedRoute.match };
+        if (overrideRoute.match.ports !== undefined) {
+            mergedRoute.match.ports = overrideRoute.match.ports;
+        }
+        if (overrideRoute.match.domains !== undefined) {
+            mergedRoute.match.domains = overrideRoute.match.domains;
+        }
+        if (overrideRoute.match.path !== undefined) {
+            mergedRoute.match.path = overrideRoute.match.path;
+        }
+        if (overrideRoute.match.headers !== undefined) {
+            mergedRoute.match.headers = overrideRoute.match.headers;
+        }
+    }
+    // Merge action configuration
+    if (overrideRoute.action) {
+        // If action types are different, replace the entire action
+        if (overrideRoute.action.type && overrideRoute.action.type !== mergedRoute.action.type) {
+            mergedRoute.action = JSON.parse(JSON.stringify(overrideRoute.action));
+        }
+        else {
+            // Otherwise merge the action properties
+            mergedRoute.action = { ...mergedRoute.action };
+            // Merge target
+            if (overrideRoute.action.target) {
+                mergedRoute.action.target = {
+                    ...mergedRoute.action.target,
+                    ...overrideRoute.action.target
+                };
+            }
+            // Merge TLS options
+            if (overrideRoute.action.tls) {
+                mergedRoute.action.tls = {
+                    ...mergedRoute.action.tls,
+                    ...overrideRoute.action.tls
+                };
+            }
+            // Merge redirect options
+            if (overrideRoute.action.redirect) {
+                mergedRoute.action.redirect = {
+                    ...mergedRoute.action.redirect,
+                    ...overrideRoute.action.redirect
+                };
+            }
+            // Merge static options
+            if (overrideRoute.action.static) {
+                mergedRoute.action.static = {
+                    ...mergedRoute.action.static,
+                    ...overrideRoute.action.static
+                };
+            }
+        }
+    }
+    return mergedRoute;
+}
+/**
+ * Check if a route matches a domain
+ * @param route The route to check
+ * @param domain The domain to match against
+ * @returns True if the route matches the domain, false otherwise
+ */
+export function routeMatchesDomain(route, domain) {
+    if (!route.match?.domains) {
+        return false;
+    }
+    const domains = Array.isArray(route.match.domains)
+        ? route.match.domains
+        : [route.match.domains];
+    return domains.some(d => {
+        // Handle wildcard domains
+        if (d.startsWith('*.')) {
+            const suffix = d.substring(2);
+            return domain.endsWith(suffix) && domain.split('.').length > suffix.split('.').length;
+        }
+        return d.toLowerCase() === domain.toLowerCase();
+    });
+}
+/**
+ * Check if a route matches a port
+ * @param route The route to check
+ * @param port The port to match against
+ * @returns True if the route matches the port, false otherwise
+ */
+export function routeMatchesPort(route, port) {
+    if (!route.match?.ports) {
+        return false;
+    }
+    if (typeof route.match.ports === 'number') {
+        return route.match.ports === port;
+    }
+    if (Array.isArray(route.match.ports)) {
+        // Simple case - array of numbers
+        if (typeof route.match.ports[0] === 'number') {
+            return route.match.ports.includes(port);
+        }
+        // Complex case - array of port ranges
+        if (typeof route.match.ports[0] === 'object') {
+            return route.match.ports.some(range => port >= range.from && port <= range.to);
+        }
+    }
+    return false;
+}
+/**
+ * Check if a route matches a path
+ * @param route The route to check
+ * @param path The path to match against
+ * @returns True if the route matches the path, false otherwise
+ */
+export function routeMatchesPath(route, path) {
+    if (!route.match?.path) {
+        return true; // No path specified means it matches any path
+    }
+    // Handle exact path
+    if (route.match.path === path) {
+        return true;
+    }
+    // Handle path prefix with trailing slash (e.g., /api/)
+    if (route.match.path.endsWith('/') && path.startsWith(route.match.path)) {
+        return true;
+    }
+    // Handle exact path match without trailing slash
+    if (!route.match.path.endsWith('/') && path === route.match.path) {
+        return true;
+    }
+    // Handle wildcard paths (e.g., /api/*)
+    if (route.match.path.endsWith('*')) {
+        const prefix = route.match.path.slice(0, -1);
+        return path.startsWith(prefix);
+    }
+    return false;
+}
+/**
+ * Check if a route matches headers
+ * @param route The route to check
+ * @param headers The headers to match against
+ * @returns True if the route matches the headers, false otherwise
+ */
+export function routeMatchesHeaders(route, headers) {
+    if (!route.match?.headers || Object.keys(route.match.headers).length === 0) {
+        return true; // No headers specified means it matches any headers
+    }
+    // Check each header in the route's match criteria
+    return Object.entries(route.match.headers).every(([key, value]) => {
+        // If the header isn't present in the request, it doesn't match
+        if (!headers[key]) {
+            return false;
+        }
+        // Handle exact match
+        if (typeof value === 'string') {
+            return headers[key] === value;
+        }
+        // Handle regex match
+        if (value instanceof RegExp) {
+            return value.test(headers[key]);
+        }
+        return false;
+    });
+}
+/**
+ * Find all routes that match the given criteria
+ * @param routes Array of routes to search
+ * @param criteria Matching criteria
+ * @returns Array of matching routes sorted by priority
+ */
+export function findMatchingRoutes(routes, criteria) {
+    // Filter routes that are enabled and match all provided criteria
+    const matchingRoutes = routes.filter(route => {
+        // Skip disabled routes
+        if (route.enabled === false) {
+            return false;
+        }
+        // Check domain match if specified
+        if (criteria.domain && !routeMatchesDomain(route, criteria.domain)) {
+            return false;
+        }
+        // Check port match if specified
+        if (criteria.port !== undefined && !routeMatchesPort(route, criteria.port)) {
+            return false;
+        }
+        // Check path match if specified
+        if (criteria.path && !routeMatchesPath(route, criteria.path)) {
+            return false;
+        }
+        // Check headers match if specified
+        if (criteria.headers && !routeMatchesHeaders(route, criteria.headers)) {
+            return false;
+        }
+        return true;
+    });
+    // Sort matching routes by priority (higher priority first)
+    return matchingRoutes.sort((a, b) => {
+        const priorityA = a.priority || 0;
+        const priorityB = b.priority || 0;
+        return priorityB - priorityA; // Higher priority first
+    });
+}
+/**
+ * Find the best matching route for the given criteria
+ * @param routes Array of routes to search
+ * @param criteria Matching criteria
+ * @returns The best matching route or undefined if no match
+ */
+export function findBestMatchingRoute(routes, criteria) {
+    const matchingRoutes = findMatchingRoutes(routes, criteria);
+    return matchingRoutes.length > 0 ? matchingRoutes[0] : undefined;
+}
+/**
+ * Create a route ID based on route properties
+ * @param route Route configuration
+ * @returns Generated route ID
+ */
+export function generateRouteId(route) {
+    // Create a deterministic ID based on route properties
+    const domains = Array.isArray(route.match?.domains)
+        ? route.match.domains.join('-')
+        : route.match?.domains || 'any';
+    let portsStr = 'any';
+    if (route.match?.ports) {
+        if (Array.isArray(route.match.ports)) {
+            portsStr = route.match.ports.join('-');
+        }
+        else if (typeof route.match.ports === 'number') {
+            portsStr = route.match.ports.toString();
+        }
+    }
+    const path = route.match?.path || 'any';
+    const action = route.action?.type || 'unknown';
+    return `route-${domains}-${portsStr}-${path}-${action}`.replace(/[^a-zA-Z0-9-]/g, '-');
+}
+/**
+ * Clone a route configuration
+ * @param route Route to clone
+ * @returns Deep copy of the route
+ */
+export function cloneRoute(route) {
+    return JSON.parse(JSON.stringify(route));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-utils.js","sourceRoot":"","sources":["../../../../ts/proxies/smart-proxy/utils/route-utils.ts"],"names":[],"mappings":"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"}

package/dist_ts/proxies/smart-proxy/utils/route-validators.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Route Validators
+ *
+ * This file provides utility functions for validating route configurations.
+ * These validators help ensure that route configurations are valid and correctly structured.
+ */
+import type { IRouteConfig, IRouteMatch, IRouteAction, TPortRange } from '../models/route-types.js';
+/**
+ * Validates a port range or port number
+ * @param port Port number or port range
+ * @returns True if valid, false otherwise
+ */
+export declare function isValidPort(port: TPortRange): boolean;
+/**
+ * Validates a domain string
+ * @param domain Domain string to validate
+ * @returns True if valid, false otherwise
+ */
+export declare function isValidDomain(domain: string): boolean;
+/**
+ * Validates a route match configuration
+ * @param match Route match configuration to validate
+ * @returns { valid: boolean, errors: string[] } Validation result
+ */
+export declare function validateRouteMatch(match: IRouteMatch): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Validates a route action configuration
+ * @param action Route action configuration to validate
+ * @returns { valid: boolean, errors: string[] } Validation result
+ */
+export declare function validateRouteAction(action: IRouteAction): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Validates a complete route configuration
+ * @param route Route configuration to validate
+ * @returns { valid: boolean, errors: string[] } Validation result
+ */
+export declare function validateRouteConfig(route: IRouteConfig): {
+    valid: boolean;
+    errors: string[];
+};
+/**
+ * Validate an array of route configurations
+ * @param routes Array of route configurations to validate
+ * @returns { valid: boolean, errors: { index: number, errors: string[] }[] } Validation result
+ */
+export declare function validateRoutes(routes: IRouteConfig[]): {
+    valid: boolean;
+    errors: {
+        index: number;
+        errors: string[];
+    }[];
+};
+/**
+ * Check if a route configuration has the required properties for a specific action type
+ * @param route Route configuration to check
+ * @param actionType Expected action type
+ * @returns True if the route has the necessary properties, false otherwise
+ */
+export declare function hasRequiredPropertiesForAction(route: IRouteConfig, actionType: string): boolean;
+/**
+ * Throws an error if the route config is invalid, returns the config if valid
+ * Useful for immediate validation when creating routes
+ * @param route Route configuration to validate
+ * @returns The validated route configuration
+ * @throws Error if the route configuration is invalid
+ */
+export declare function assertValidRoute(route: IRouteConfig): IRouteConfig;

package/dist_ts/proxies/smart-proxy/utils/route-validators.js

@@ -0,0 +1,242 @@
+/**
+ * Route Validators
+ *
+ * This file provides utility functions for validating route configurations.
+ * These validators help ensure that route configurations are valid and correctly structured.
+ */
+/**
+ * Validates a port range or port number
+ * @param port Port number or port range
+ * @returns True if valid, false otherwise
+ */
+export function isValidPort(port) {
+    if (typeof port === 'number') {
+        return port > 0 && port < 65536; // Valid port range is 1-65535
+    }
+    else if (Array.isArray(port)) {
+        return port.every(p => typeof p === 'number' && p > 0 && p < 65536);
+    }
+    return false;
+}
+/**
+ * Validates a domain string
+ * @param domain Domain string to validate
+ * @returns True if valid, false otherwise
+ */
+export function isValidDomain(domain) {
+    // Basic domain validation regex - allows wildcards (*.example.com)
+    const domainRegex = /^(\*\.)?([a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
+    return domainRegex.test(domain);
+}
+/**
+ * Validates a route match configuration
+ * @param match Route match configuration to validate
+ * @returns { valid: boolean, errors: string[] } Validation result
+ */
+export function validateRouteMatch(match) {
+    const errors = [];
+    // Validate ports
+    if (match.ports !== undefined) {
+        if (!isValidPort(match.ports)) {
+            errors.push('Invalid port number or port range in match.ports');
+        }
+    }
+    // Validate domains
+    if (match.domains !== undefined) {
+        if (typeof match.domains === 'string') {
+            if (!isValidDomain(match.domains)) {
+                errors.push(`Invalid domain format: ${match.domains}`);
+            }
+        }
+        else if (Array.isArray(match.domains)) {
+            for (const domain of match.domains) {
+                if (!isValidDomain(domain)) {
+                    errors.push(`Invalid domain format: ${domain}`);
+                }
+            }
+        }
+        else {
+            errors.push('Domains must be a string or an array of strings');
+        }
+    }
+    // Validate path
+    if (match.path !== undefined) {
+        if (typeof match.path !== 'string' || !match.path.startsWith('/')) {
+            errors.push('Path must be a string starting with /');
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Validates a route action configuration
+ * @param action Route action configuration to validate
+ * @returns { valid: boolean, errors: string[] } Validation result
+ */
+export function validateRouteAction(action) {
+    const errors = [];
+    // Validate action type
+    if (!action.type) {
+        errors.push('Action type is required');
+    }
+    else if (!['forward', 'redirect', 'static', 'block'].includes(action.type)) {
+        errors.push(`Invalid action type: ${action.type}`);
+    }
+    // Validate target for 'forward' action
+    if (action.type === 'forward') {
+        if (!action.target) {
+            errors.push('Target is required for forward action');
+        }
+        else {
+            // Validate target host
+            if (!action.target.host) {
+                errors.push('Target host is required');
+            }
+            // Validate target port
+            if (!action.target.port || !isValidPort(action.target.port)) {
+                errors.push('Valid target port is required');
+            }
+        }
+        // Validate TLS options for forward actions
+        if (action.tls) {
+            if (!['passthrough', 'terminate', 'terminate-and-reencrypt'].includes(action.tls.mode)) {
+                errors.push(`Invalid TLS mode: ${action.tls.mode}`);
+            }
+            // For termination modes, validate certificate
+            if (['terminate', 'terminate-and-reencrypt'].includes(action.tls.mode)) {
+                if (action.tls.certificate !== 'auto' &&
+                    (!action.tls.certificate || !action.tls.certificate.key || !action.tls.certificate.cert)) {
+                    errors.push('Certificate must be "auto" or an object with key and cert properties');
+                }
+            }
+        }
+    }
+    // Validate redirect for 'redirect' action
+    if (action.type === 'redirect') {
+        if (!action.redirect) {
+            errors.push('Redirect configuration is required for redirect action');
+        }
+        else {
+            if (!action.redirect.to) {
+                errors.push('Redirect target (to) is required');
+            }
+            if (action.redirect.status &&
+                ![301, 302, 303, 307, 308].includes(action.redirect.status)) {
+                errors.push('Invalid redirect status code');
+            }
+        }
+    }
+    // Validate static file config for 'static' action
+    if (action.type === 'static') {
+        if (!action.static) {
+            errors.push('Static file configuration is required for static action');
+        }
+        else {
+            if (!action.static.root) {
+                errors.push('Static file root directory is required');
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Validates a complete route configuration
+ * @param route Route configuration to validate
+ * @returns { valid: boolean, errors: string[] } Validation result
+ */
+export function validateRouteConfig(route) {
+    const errors = [];
+    // Check for required properties
+    if (!route.match) {
+        errors.push('Route match configuration is required');
+    }
+    if (!route.action) {
+        errors.push('Route action configuration is required');
+    }
+    // Validate match configuration
+    if (route.match) {
+        const matchValidation = validateRouteMatch(route.match);
+        if (!matchValidation.valid) {
+            errors.push(...matchValidation.errors.map(err => `Match: ${err}`));
+        }
+    }
+    // Validate action configuration
+    if (route.action) {
+        const actionValidation = validateRouteAction(route.action);
+        if (!actionValidation.valid) {
+            errors.push(...actionValidation.errors.map(err => `Action: ${err}`));
+        }
+    }
+    // Ensure the route has a unique identifier
+    if (!route.id && !route.name) {
+        errors.push('Route should have either an id or a name for identification');
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Validate an array of route configurations
+ * @param routes Array of route configurations to validate
+ * @returns { valid: boolean, errors: { index: number, errors: string[] }[] } Validation result
+ */
+export function validateRoutes(routes) {
+    const results = [];
+    routes.forEach((route, index) => {
+        const validation = validateRouteConfig(route);
+        if (!validation.valid) {
+            results.push({
+                index,
+                errors: validation.errors
+            });
+        }
+    });
+    return {
+        valid: results.length === 0,
+        errors: results
+    };
+}
+/**
+ * Check if a route configuration has the required properties for a specific action type
+ * @param route Route configuration to check
+ * @param actionType Expected action type
+ * @returns True if the route has the necessary properties, false otherwise
+ */
+export function hasRequiredPropertiesForAction(route, actionType) {
+    if (!route.action || route.action.type !== actionType) {
+        return false;
+    }
+    switch (actionType) {
+        case 'forward':
+            return !!route.action.target && !!route.action.target.host && !!route.action.target.port;
+        case 'redirect':
+            return !!route.action.redirect && !!route.action.redirect.to;
+        case 'static':
+            return !!route.action.static && !!route.action.static.root;
+        case 'block':
+            return true; // Block action doesn't require additional properties
+        default:
+            return false;
+    }
+}
+/**
+ * Throws an error if the route config is invalid, returns the config if valid
+ * Useful for immediate validation when creating routes
+ * @param route Route configuration to validate
+ * @returns The validated route configuration
+ * @throws Error if the route configuration is invalid
+ */
+export function assertValidRoute(route) {
+    const validation = validateRouteConfig(route);
+    if (!validation.valid) {
+        throw new Error(`Invalid route configuration: ${validation.errors.join(', ')}`);
+    }
+    return route;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"route-validators.js","sourceRoot":"","sources":["../../../../ts/proxies/smart-proxy/utils/route-validators.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,IAAgB;IAC1C,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC7B,OAAO,IAAI,GAAG,CAAC,IAAI,IAAI,GAAG,KAAK,CAAC,CAAC,8BAA8B;IACjE,CAAC;SAAM,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC;IACtE,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,aAAa,CAAC,MAAc;IAC1C,mEAAmE;IACnE,MAAM,WAAW,GAAG,wEAAwE,CAAC;IAC7F,OAAO,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;AAClC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,kBAAkB,CAAC,KAAkB;IACnD,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,iBAAiB;IACjB,IAAI,KAAK,CAAC,KAAK,KAAK,SAAS,EAAE,CAAC;QAC9B,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YAC9B,MAAM,CAAC,IAAI,CAAC,kDAAkD,CAAC,CAAC;QAClE,CAAC;IACH,CAAC;IAED,mBAAmB;IACnB,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;QAChC,IAAI,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;YACtC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;gBAClC,MAAM,CAAC,IAAI,CAAC,0BAA0B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;YACzD,CAAC;QACH,CAAC;aAAM,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;YACxC,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;gBACnC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;oBAC3B,MAAM,CAAC,IAAI,CAAC,0BAA0B,MAAM,EAAE,CAAC,CAAC;gBAClD,CAAC;YACH,CAAC;QACH,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,IAAI,CAAC,iDAAiD,CAAC,CAAC;QACjE,CAAC;IACH,CAAC;IAED,gBAAgB;IAChB,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC7B,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAClE,MAAM,CAAC,IAAI,CAAC,uCAAuC,CAAC,CAAC;QACvD,CAAC;IACH,CAAC;IAED,OAAO;QACL,KAAK,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC;QAC1B,MAAM;KACP,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAoB;IACtD,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,uBAAuB;IACvB,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACjB,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC;IACzC,CAAC;SAAM,IAAI,CAAC,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;QAC7E,MAAM,CAAC,IAAI,CAAC,wBAAwB,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;IACrD,CAAC;IAED,uCAAuC;IACvC,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC9B,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACnB,MAAM,CAAC,IAAI,CAAC,uCAAuC,CAAC,CAAC;QACvD,CAAC;aAAM,CAAC;YACN,uBAAuB;YACvB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;gBACxB,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC;YACzC,CAAC;YAED,uBAAuB;YACvB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;gBAC5D,MAAM,CAAC,IAAI,CAAC,+BAA+B,CAAC,CAAC;YAC/C,CAAC;QACH,CAAC;QAED,2CAA2C;QAC3C,IAAI,MAAM,CAAC,GAAG,EAAE,CAAC;YACf,IAAI,CAAC,CAAC,aAAa,EAAE,WAAW,EAAE,yBAAyB,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACvF,MAAM,CAAC,IAAI,CAAC,qBAAqB,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC;YACtD,CAAC;YAED,8CAA8C;YAC9C,IAAI,CAAC,WAAW,EAAE,yBAAyB,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;gBACvE,IAAI,MAAM,CAAC,GAAG,CAAC,WAAW,KAAK,MAAM;oBACjC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;oBAC7F,MAAM,CAAC,IAAI,CAAC,sEAAsE,CAAC,CAAC;gBACtF,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED,0CAA0C;IAC1C,IAAI,MAAM,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QAC/B,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACrB,MAAM,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;QACxE,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;gBACxB,MAAM,CAAC,IAAI,CAAC,kCAAkC,CAAC,CAAC;YAClD,CAAC;YAED,IAAI,MAAM,CAAC,QAAQ,CAAC,MAAM;gBACtB,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBAChE,MAAM,CAAC,IAAI,CAAC,8BAA8B,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC;IACH,CAAC;IAED,kDAAkD;IAClD,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC7B,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;YACnB,MAAM,CAAC,IAAI,CAAC,yDAAyD,CAAC,CAAC;QACzE,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;gBACxB,MAAM,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;YACxD,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO;QACL,KAAK,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC;QAC1B,MAAM;KACP,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAmB;IACrD,MAAM,MAAM,GAAa,EAAE,CAAC;IAE5B,gCAAgC;IAChC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACjB,MAAM,CAAC,IAAI,CAAC,uCAAuC,CAAC,CAAC;IACvD,CAAC;IAED,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;QAClB,MAAM,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;IACxD,CAAC;IAED,+BAA+B;IAC/B,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC;QAChB,MAAM,eAAe,GAAG,kBAAkB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACxD,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,CAAC;YAC3B,MAAM,CAAC,IAAI,CAAC,GAAG,eAAe,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IAED,gCAAgC;IAChC,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QACjB,MAAM,gBAAgB,GAAG,mBAAmB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC3D,IAAI,CAAC,gBAAgB,CAAC,KAAK,EAAE,CAAC;YAC5B,MAAM,CAAC,IAAI,CAAC,GAAG,gBAAgB,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,WAAW,GAAG,EAAE,CAAC,CAAC,CAAC;QACvE,CAAC;IACH,CAAC;IAED,2CAA2C;IAC3C,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;QAC7B,MAAM,CAAC,IAAI,CAAC,6DAA6D,CAAC,CAAC;IAC7E,CAAC;IAED,OAAO;QACL,KAAK,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC;QAC1B,MAAM;KACP,CAAC;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,MAAsB;IAInD,MAAM,OAAO,GAA0C,EAAE,CAAC;IAE1D,MAAM,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;QAC9B,MAAM,UAAU,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;QAC9C,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;YACtB,OAAO,CAAC,IAAI,CAAC;gBACX,KAAK;gBACL,MAAM,EAAE,UAAU,CAAC,MAAM;aAC1B,CAAC,CAAC;QACL,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO;QACL,KAAK,EAAE,OAAO,CAAC,MAAM,KAAK,CAAC;QAC3B,MAAM,EAAE,OAAO;KAChB,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,8BAA8B,CAAC,KAAmB,EAAE,UAAkB;IACpF,IAAI,CAAC,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;QACtD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,QAAQ,UAAU,EAAE,CAAC;QACnB,KAAK,SAAS;YACZ,OAAO,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;QAC3F,KAAK,UAAU;YACb,OAAO,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC/D,KAAK,QAAQ;YACX,OAAO,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;QAC7D,KAAK,OAAO;YACV,OAAO,IAAI,CAAC,CAAC,qDAAqD;QACpE;YACE,OAAO,KAAK,CAAC;IACjB,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAmB;IAClD,MAAM,UAAU,GAAG,mBAAmB,CAAC,KAAK,CAAC,CAAC;IAC9C,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;QACtB,MAAM,IAAI,KAAK,CAAC,gCAAgC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAClF,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartproxy",
-  "version": "15.0.2",
+  "version": "16.0.2",
   "private": false,
   "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.",
   "main": "dist_ts/index.js",