@push.rocks/smartproxy 12.0.0 → 13.1.2

package/dist_ts/http/router/proxy-router.d.ts

@@ -0,0 +1,115 @@
+import * as plugins from '../../plugins.js';
+import type { IReverseProxyConfig } from '../../proxies/network-proxy/models/types.js';
+/**
+ * Optional path pattern configuration that can be added to proxy configs
+ */
+export interface PathPatternConfig {
+    pathPattern?: string;
+}
+export type IPathPatternConfig = PathPatternConfig;
+/**
+ * Interface for router result with additional metadata
+ */
+export interface RouterResult {
+    config: IReverseProxyConfig;
+    pathMatch?: string;
+    pathParams?: Record<string, string>;
+    pathRemainder?: string;
+}
+export type IRouterResult = RouterResult;
+/**
+ * Router for HTTP reverse proxy requests
+ *
+ * Supports the following domain matching patterns:
+ * - Exact matches: "example.com"
+ * - Wildcard subdomains: "*.example.com" (matches any subdomain of example.com)
+ * - TLD wildcards: "example.*" (matches example.com, example.org, etc.)
+ * - Complex wildcards: "*.lossless*" (matches any subdomain of any lossless domain)
+ * - Default fallback: "*" (matches any unmatched domain)
+ *
+ * Also supports path pattern matching for each domain:
+ * - Exact path: "/api/users"
+ * - Wildcard paths: "/api/*"
+ * - Path parameters: "/users/:id/profile"
+ */
+export declare class ProxyRouter {
+    private reverseProxyConfigs;
+    private defaultConfig?;
+    private pathPatterns;
+    private logger;
+    constructor(configs?: IReverseProxyConfig[], logger?: {
+        error: (message: string, data?: any) => void;
+        warn: (message: string, data?: any) => void;
+        info: (message: string, data?: any) => void;
+        debug: (message: string, data?: any) => void;
+    });
+    /**
+     * Sets a new set of reverse configs to be routed to
+     * @param reverseCandidatesArg Array of reverse proxy configurations
+     */
+    setNewProxyConfigs(reverseCandidatesArg: IReverseProxyConfig[]): void;
+    /**
+     * Routes a request based on hostname and path
+     * @param req The incoming HTTP request
+     * @returns The matching proxy config or undefined if no match found
+     */
+    routeReq(req: plugins.http.IncomingMessage): IReverseProxyConfig;
+    /**
+     * Routes a request with detailed matching information
+     * @param req The incoming HTTP request
+     * @returns Detailed routing result including matched config and path information
+     */
+    routeReqWithDetails(req: plugins.http.IncomingMessage): RouterResult | undefined;
+    /**
+     * Find potential wildcard patterns that could match a given hostname
+     * Handles complex patterns like "*.lossless*" or other partial matches
+     * @param hostname The hostname to find wildcard matches for
+     * @returns Array of potential wildcard patterns that could match
+     */
+    private findWildcardMatches;
+    /**
+     * Find a config for a specific host and path
+     */
+    private findConfigForHost;
+    /**
+     * Matches a URL path against a pattern
+     * Supports:
+     * - Exact matches: /users/profile
+     * - Wildcards: /api/* (matches any path starting with /api/)
+     * - Path parameters: /users/:id (captures id as a parameter)
+     *
+     * @param path The URL path to match
+     * @param pattern The pattern to match against
+     * @returns Match result with params and remainder, or null if no match
+     */
+    private matchPath;
+    /**
+     * Gets all currently active proxy configurations
+     * @returns Array of all active configurations
+     */
+    getProxyConfigs(): IReverseProxyConfig[];
+    /**
+     * Gets all hostnames that this router is configured to handle
+     * @returns Array of hostnames
+     */
+    getHostnames(): string[];
+    /**
+     * Adds a single new proxy configuration
+     * @param config The configuration to add
+     * @param pathPattern Optional path pattern for route matching
+     */
+    addProxyConfig(config: IReverseProxyConfig, pathPattern?: string): void;
+    /**
+     * Sets a path pattern for an existing config
+     * @param config The existing configuration
+     * @param pathPattern The path pattern to set
+     * @returns Boolean indicating if the config was found and updated
+     */
+    setPathPattern(config: IReverseProxyConfig, pathPattern: string): boolean;
+    /**
+     * Removes a proxy configuration by hostname
+     * @param hostname The hostname to remove
+     * @returns Boolean indicating whether any configs were removed
+     */
+    removeProxyConfig(hostname: string): boolean;
+}

package/dist_ts/http/router/proxy-router.js

@@ -0,0 +1,325 @@
+import * as plugins from '../../plugins.js';
+/**
+ * Router for HTTP reverse proxy requests
+ *
+ * Supports the following domain matching patterns:
+ * - Exact matches: "example.com"
+ * - Wildcard subdomains: "*.example.com" (matches any subdomain of example.com)
+ * - TLD wildcards: "example.*" (matches example.com, example.org, etc.)
+ * - Complex wildcards: "*.lossless*" (matches any subdomain of any lossless domain)
+ * - Default fallback: "*" (matches any unmatched domain)
+ *
+ * Also supports path pattern matching for each domain:
+ * - Exact path: "/api/users"
+ * - Wildcard paths: "/api/*"
+ * - Path parameters: "/users/:id/profile"
+ */
+export class ProxyRouter {
+    constructor(configs, logger) {
+        // Store original configs for reference
+        this.reverseProxyConfigs = [];
+        // Store path patterns separately since they're not in the original interface
+        this.pathPatterns = new Map();
+        this.logger = logger || console;
+        if (configs) {
+            this.setNewProxyConfigs(configs);
+        }
+    }
+    /**
+     * Sets a new set of reverse configs to be routed to
+     * @param reverseCandidatesArg Array of reverse proxy configurations
+     */
+    setNewProxyConfigs(reverseCandidatesArg) {
+        this.reverseProxyConfigs = [...reverseCandidatesArg];
+        // Find default config if any (config with "*" as hostname)
+        this.defaultConfig = this.reverseProxyConfigs.find(config => config.hostName === '*');
+        this.logger.info(`Router initialized with ${this.reverseProxyConfigs.length} configs (${this.getHostnames().length} unique hosts)`);
+    }
+    /**
+     * Routes a request based on hostname and path
+     * @param req The incoming HTTP request
+     * @returns The matching proxy config or undefined if no match found
+     */
+    routeReq(req) {
+        const result = this.routeReqWithDetails(req);
+        return result ? result.config : undefined;
+    }
+    /**
+     * Routes a request with detailed matching information
+     * @param req The incoming HTTP request
+     * @returns Detailed routing result including matched config and path information
+     */
+    routeReqWithDetails(req) {
+        // Extract and validate host header
+        const originalHost = req.headers.host;
+        if (!originalHost) {
+            this.logger.error('No host header found in request');
+            return this.defaultConfig ? { config: this.defaultConfig } : undefined;
+        }
+        // Parse URL for path matching
+        const parsedUrl = plugins.url.parse(req.url || '/');
+        const urlPath = parsedUrl.pathname || '/';
+        // Extract hostname without port
+        const hostWithoutPort = originalHost.split(':')[0].toLowerCase();
+        // First try exact hostname match
+        const exactConfig = this.findConfigForHost(hostWithoutPort, urlPath);
+        if (exactConfig) {
+            return exactConfig;
+        }
+        // Try various wildcard patterns
+        if (hostWithoutPort.includes('.')) {
+            const domainParts = hostWithoutPort.split('.');
+            // Try wildcard subdomain (*.example.com)
+            if (domainParts.length > 2) {
+                const wildcardDomain = `*.${domainParts.slice(1).join('.')}`;
+                const wildcardConfig = this.findConfigForHost(wildcardDomain, urlPath);
+                if (wildcardConfig) {
+                    return wildcardConfig;
+                }
+            }
+            // Try TLD wildcard (example.*)
+            const baseDomain = domainParts.slice(0, -1).join('.');
+            const tldWildcardDomain = `${baseDomain}.*`;
+            const tldWildcardConfig = this.findConfigForHost(tldWildcardDomain, urlPath);
+            if (tldWildcardConfig) {
+                return tldWildcardConfig;
+            }
+            // Try complex wildcard patterns
+            const wildcardPatterns = this.findWildcardMatches(hostWithoutPort);
+            for (const pattern of wildcardPatterns) {
+                const wildcardConfig = this.findConfigForHost(pattern, urlPath);
+                if (wildcardConfig) {
+                    return wildcardConfig;
+                }
+            }
+        }
+        // Fall back to default config if available
+        if (this.defaultConfig) {
+            this.logger.warn(`No specific config found for host: ${hostWithoutPort}, using default`);
+            return { config: this.defaultConfig };
+        }
+        this.logger.error(`No config found for host: ${hostWithoutPort}`);
+        return undefined;
+    }
+    /**
+     * Find potential wildcard patterns that could match a given hostname
+     * Handles complex patterns like "*.lossless*" or other partial matches
+     * @param hostname The hostname to find wildcard matches for
+     * @returns Array of potential wildcard patterns that could match
+     */
+    findWildcardMatches(hostname) {
+        const patterns = [];
+        const hostnameParts = hostname.split('.');
+        // Find all configured hostnames that contain wildcards
+        const wildcardConfigs = this.reverseProxyConfigs.filter(config => config.hostName.includes('*'));
+        // Extract unique wildcard patterns
+        const wildcardPatterns = [...new Set(wildcardConfigs.map(config => config.hostName.toLowerCase()))];
+        // For each wildcard pattern, check if it could match the hostname
+        // using simplified regex pattern matching
+        for (const pattern of wildcardPatterns) {
+            // Skip the default wildcard '*'
+            if (pattern === '*')
+                continue;
+            // Skip already checked patterns (*.domain.com and domain.*)
+            if (pattern.startsWith('*.') && pattern.indexOf('*', 2) === -1)
+                continue;
+            if (pattern.endsWith('.*') && pattern.indexOf('*') === pattern.length - 1)
+                continue;
+            // Convert wildcard pattern to regex
+            const regexPattern = pattern
+                .replace(/\./g, '\\.') // Escape dots
+                .replace(/\*/g, '.*'); // Convert * to .* for regex
+            // Create regex object with case insensitive flag
+            const regex = new RegExp(`^${regexPattern}$`, 'i');
+            // If hostname matches this complex pattern, add it to the list
+            if (regex.test(hostname)) {
+                patterns.push(pattern);
+            }
+        }
+        return patterns;
+    }
+    /**
+     * Find a config for a specific host and path
+     */
+    findConfigForHost(hostname, path) {
+        // Find all configs for this hostname
+        const configs = this.reverseProxyConfigs.filter(config => config.hostName.toLowerCase() === hostname.toLowerCase());
+        if (configs.length === 0) {
+            return undefined;
+        }
+        // First try configs with path patterns
+        const configsWithPaths = configs.filter(config => this.pathPatterns.has(config));
+        // Sort by path pattern specificity - more specific first
+        configsWithPaths.sort((a, b) => {
+            const aPattern = this.pathPatterns.get(a) || '';
+            const bPattern = this.pathPatterns.get(b) || '';
+            // Exact patterns come before wildcard patterns
+            const aHasWildcard = aPattern.includes('*');
+            const bHasWildcard = bPattern.includes('*');
+            if (aHasWildcard && !bHasWildcard)
+                return 1;
+            if (!aHasWildcard && bHasWildcard)
+                return -1;
+            // Longer patterns are considered more specific
+            return bPattern.length - aPattern.length;
+        });
+        // Check each config with path pattern
+        for (const config of configsWithPaths) {
+            const pathPattern = this.pathPatterns.get(config);
+            if (pathPattern) {
+                const pathMatch = this.matchPath(path, pathPattern);
+                if (pathMatch) {
+                    return {
+                        config,
+                        pathMatch: pathMatch.matched,
+                        pathParams: pathMatch.params,
+                        pathRemainder: pathMatch.remainder
+                    };
+                }
+            }
+        }
+        // If no path pattern matched, use the first config without a path pattern
+        const configWithoutPath = configs.find(config => !this.pathPatterns.has(config));
+        if (configWithoutPath) {
+            return { config: configWithoutPath };
+        }
+        return undefined;
+    }
+    /**
+     * Matches a URL path against a pattern
+     * Supports:
+     * - Exact matches: /users/profile
+     * - Wildcards: /api/* (matches any path starting with /api/)
+     * - Path parameters: /users/:id (captures id as a parameter)
+     *
+     * @param path The URL path to match
+     * @param pattern The pattern to match against
+     * @returns Match result with params and remainder, or null if no match
+     */
+    matchPath(path, pattern) {
+        // Handle exact match
+        if (path === pattern) {
+            return {
+                matched: pattern,
+                params: {},
+                remainder: ''
+            };
+        }
+        // Handle wildcard match
+        if (pattern.endsWith('/*')) {
+            const prefix = pattern.slice(0, -2);
+            if (path === prefix || path.startsWith(`${prefix}/`)) {
+                return {
+                    matched: prefix,
+                    params: {},
+                    remainder: path.slice(prefix.length)
+                };
+            }
+            return null;
+        }
+        // Handle path parameters
+        const patternParts = pattern.split('/').filter(p => p);
+        const pathParts = path.split('/').filter(p => p);
+        // Too few path parts to match
+        if (pathParts.length < patternParts.length) {
+            return null;
+        }
+        const params = {};
+        // Compare each part
+        for (let i = 0; i < patternParts.length; i++) {
+            const patternPart = patternParts[i];
+            const pathPart = pathParts[i];
+            // Handle parameter
+            if (patternPart.startsWith(':')) {
+                const paramName = patternPart.slice(1);
+                params[paramName] = pathPart;
+                continue;
+            }
+            // Handle wildcard at the end
+            if (patternPart === '*' && i === patternParts.length - 1) {
+                break;
+            }
+            // Handle exact match for this part
+            if (patternPart !== pathPart) {
+                return null;
+            }
+        }
+        // Calculate the remainder - the unmatched path parts
+        const remainderParts = pathParts.slice(patternParts.length);
+        const remainder = remainderParts.length ? '/' + remainderParts.join('/') : '';
+        // Calculate the matched path
+        const matchedParts = patternParts.map((part, i) => {
+            return part.startsWith(':') ? pathParts[i] : part;
+        });
+        const matched = '/' + matchedParts.join('/');
+        return {
+            matched,
+            params,
+            remainder
+        };
+    }
+    /**
+     * Gets all currently active proxy configurations
+     * @returns Array of all active configurations
+     */
+    getProxyConfigs() {
+        return [...this.reverseProxyConfigs];
+    }
+    /**
+     * Gets all hostnames that this router is configured to handle
+     * @returns Array of hostnames
+     */
+    getHostnames() {
+        const hostnames = new Set();
+        for (const config of this.reverseProxyConfigs) {
+            if (config.hostName !== '*') {
+                hostnames.add(config.hostName.toLowerCase());
+            }
+        }
+        return Array.from(hostnames);
+    }
+    /**
+     * Adds a single new proxy configuration
+     * @param config The configuration to add
+     * @param pathPattern Optional path pattern for route matching
+     */
+    addProxyConfig(config, pathPattern) {
+        this.reverseProxyConfigs.push(config);
+        // Store path pattern if provided
+        if (pathPattern) {
+            this.pathPatterns.set(config, pathPattern);
+        }
+    }
+    /**
+     * Sets a path pattern for an existing config
+     * @param config The existing configuration
+     * @param pathPattern The path pattern to set
+     * @returns Boolean indicating if the config was found and updated
+     */
+    setPathPattern(config, pathPattern) {
+        const exists = this.reverseProxyConfigs.includes(config);
+        if (exists) {
+            this.pathPatterns.set(config, pathPattern);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Removes a proxy configuration by hostname
+     * @param hostname The hostname to remove
+     * @returns Boolean indicating whether any configs were removed
+     */
+    removeProxyConfig(hostname) {
+        const initialCount = this.reverseProxyConfigs.length;
+        // Find configs to remove
+        const configsToRemove = this.reverseProxyConfigs.filter(config => config.hostName === hostname);
+        // Remove them from the patterns map
+        for (const config of configsToRemove) {
+            this.pathPatterns.delete(config);
+        }
+        // Filter them out of the configs array
+        this.reverseProxyConfigs = this.reverseProxyConfigs.filter(config => config.hostName !== hostname);
+        return this.reverseProxyConfigs.length !== initialCount;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"proxy-router.js","sourceRoot":"","sources":["../../../ts/http/router/proxy-router.ts"],"names":[],"mappings":"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"}

package/dist_ts/index.d.ts

@@ -1,9 +1,16 @@
-export * from './nfttablesproxy/classes.nftablesproxy.js';
-export * from './networkproxy/index.js';
-export * from './port80handler/classes.port80handler.js';
+/**
+ * SmartProxy main module exports
+ */
+export * from './proxies/nftables-proxy/index.js';
+export * from './proxies/network-proxy/index.js';
+export { Port80Handler, Port80HandlerError as HttpError, ServerError, CertificateError } from './http/port80/port80-handler.js';
+export { Port80HandlerEvents } from './certificate/events/certificate-events.js';
 export * from './redirect/classes.redirect.js';
-export * from './smartproxy/classes.smartproxy.js';
-export * from './smartproxy/classes.pp.snihandler.js';
-export * from './smartproxy/classes.pp.interfaces.js';
-export * from './common/types.js';
-export * as forwarding from './smartproxy/forwarding/index.js';
+export * from './proxies/smart-proxy/index.js';
+export { SniHandler } from './tls/sni/sni-handler.js';
+export * from './proxies/smart-proxy/models/interfaces.js';
+export * from './core/models/common-types.js';
+export * as forwarding from './forwarding/index.js';
+export * as certificate from './certificate/index.js';
+export * as tls from './tls/index.js';
+export * as http from './http/index.js';

package/dist_ts/index.js

@@ -1,11 +1,27 @@
-export * from './nfttablesproxy/classes.nftablesproxy.js';
-export * from './networkproxy/index.js';
-export * from './port80handler/classes.port80handler.js';
+/**
+ * SmartProxy main module exports
+ */
+// Legacy exports (to maintain backward compatibility)
+// Migrated to the new proxies structure
+export * from './proxies/nftables-proxy/index.js';
+export * from './proxies/network-proxy/index.js';
+// Export port80handler elements selectively to avoid conflicts
+export { Port80Handler, Port80HandlerError as HttpError, ServerError, CertificateError } from './http/port80/port80-handler.js';
+// Use re-export to control the names
+export { Port80HandlerEvents } from './certificate/events/certificate-events.js';
 export * from './redirect/classes.redirect.js';
-export * from './smartproxy/classes.smartproxy.js';
-export * from './smartproxy/classes.pp.snihandler.js';
-export * from './smartproxy/classes.pp.interfaces.js';
-export * from './common/types.js';
-// Export forwarding system
-export * as forwarding from './smartproxy/forwarding/index.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDJDQUEyQyxDQUFDO0FBQzFELGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywwQ0FBMEMsQ0FBQztBQUN6RCxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLHVDQUF1QyxDQUFDO0FBRXRELGNBQWMsbUJBQW1CLENBQUM7QUFFbEMsMkJBQTJCO0FBQzNCLE9BQU8sS0FBSyxVQUFVLE1BQU0sa0NBQWtDLENBQUMifQ==
+export * from './proxies/smart-proxy/index.js';
+// Original: export * from './smartproxy/classes.pp.snihandler.js'
+// Now we export from the new module
+export { SniHandler } from './tls/sni/sni-handler.js';
+// Original: export * from './smartproxy/classes.pp.interfaces.js'
+// Now we export from the new module
+export * from './proxies/smart-proxy/models/interfaces.js';
+// Core types and utilities
+export * from './core/models/common-types.js';
+// Modular exports for new architecture
+export * as forwarding from './forwarding/index.js';
+export * as certificate from './certificate/index.js';
+export * as tls from './tls/index.js';
+export * as http from './http/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILHNEQUFzRDtBQUN0RCx3Q0FBd0M7QUFDeEMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELCtEQUErRDtBQUMvRCxPQUFPLEVBQ0wsYUFBYSxFQUNiLGtCQUFrQixJQUFJLFNBQVMsRUFDL0IsV0FBVyxFQUNYLGdCQUFnQixFQUNqQixNQUFNLGlDQUFpQyxDQUFDO0FBQ3pDLHFDQUFxQztBQUNyQyxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw0Q0FBNEMsQ0FBQztBQUVqRixjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0Msa0VBQWtFO0FBQ2xFLG9DQUFvQztBQUNwQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDdEQsa0VBQWtFO0FBQ2xFLG9DQUFvQztBQUNwQyxjQUFjLDRDQUE0QyxDQUFDO0FBRTNELDJCQUEyQjtBQUMzQixjQUFjLCtCQUErQixDQUFDO0FBRTlDLHVDQUF1QztBQUN2QyxPQUFPLEtBQUssVUFBVSxNQUFNLHVCQUF1QixDQUFDO0FBQ3BELE9BQU8sS0FBSyxXQUFXLE1BQU0sd0JBQXdCLENBQUM7QUFDdEQsT0FBTyxLQUFLLEdBQUcsTUFBTSxnQkFBZ0IsQ0FBQztBQUN0QyxPQUFPLEtBQUssSUFBSSxNQUFNLGlCQUFpQixDQUFDIn0=

package/dist_ts/networkproxy/classes.np.certificatemanager.js

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'url';
 import { createLogger } from './classes.np.types.js';
 import { Port80Handler } from '../port80handler/classes.port80handler.js';
 import { Port80HandlerEvents } from '../common/types.js';
-import { buildPort80Handler } from '../common/acmeFactory.js';
+import { buildPort80Handler } from '../certificate/acme/acme-factory.js';
 import { subscribeToPort80Handler } from '../common/eventUtils.js';
 /**
  * Manages SSL certificates for NetworkProxy including ACME integration
@@ -369,4 +369,4 @@ export class CertificateManager {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.np.certificatemanager.js","sourceRoot":"","sources":["../../ts/networkproxy/classes.np.certificatemanager.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AACzB,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AACpC,OAAO,EAAmE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACtH,OAAO,EAAE,aAAa,EAAE,MAAM,2CAA2C,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAGnE;;GAEG;AACH,MAAM,OAAO,kBAAkB;IAS7B,YAAoB,OAA6B;QAA7B,YAAO,GAAP,OAAO,CAAsB;QAPzC,qBAAgB,GAAmC,IAAI,GAAG,EAAE,CAAC;QAC7D,kBAAa,GAAyB,IAAI,CAAC;QAC3C,0BAAqB,GAAY,KAAK,CAAC;QAGvC,gBAAW,GAAgC,IAAI,CAAC;QAGtD,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,EAAE,gBAAgB,IAAI,SAAS,CAAC,CAAC;QACrF,IAAI,CAAC,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,QAAQ,IAAI,MAAM,CAAC,CAAC;QAEvD,4CAA4C;QAC5C,IAAI,CAAC;YACH,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,mBAAmB,CAAC,EAAE,CAAC;gBAC7C,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,mBAAmB,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;gBAC5D,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,wCAAwC,IAAI,CAAC,mBAAmB,EAAE,CAAC,CAAC;YACvF,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,iDAAiD,KAAK,EAAE,CAAC,CAAC;QAC7E,CAAC;QAED,IAAI,CAAC,uBAAuB,EAAE,CAAC;IACjC,CAAC;IAED;;OAEG;IACI,uBAAuB;QAC5B,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QAC/D,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QAErE,IAAI,CAAC;YACH,IAAI,CAAC,mBAAmB,GAAG;gBACzB,GAAG,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE,MAAM,CAAC;gBAC5D,IAAI,EAAE,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC;aAC/D,CAAC;YACF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,0CAA0C,CAAC,CAAC;QAC/D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,oCAAoC,EAAE,KAAK,CAAC,CAAC;YAE/D,6CAA6C;YAC7C,IAAI,CAAC;gBACH,+DAA+D;gBAC/D,sFAAsF;gBACtF,IAAI,CAAC,mBAAmB,GAAG;oBACzB,GAAG,EAAE,sBAAsB;oBAC3B,IAAI,EAAE,uBAAuB;iBAC9B,CAAC;gBACF,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yCAAyC,CAAC,CAAC;YAC9D,CAAC;YAAC,OAAO,aAAa,EAAE,CAAC;gBACvB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,0CAA0C,EAAE,aAAa,CAAC,CAAC;gBAC7E,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;YACjE,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACI,cAAc,CAAC,MAA4B;QAChD,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;IAC5B,CAAC;IAED;;OAEG;IACI,sBAAsB;QAC3B,OAAO,EAAE,GAAG,IAAI,CAAC,mBAAmB,EAAE,CAAC;IACzC,CAAC;IAED;;OAEG;IACI,wBAAwB,CAAC,OAAsB;QACpD,IAAI,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC;YACtD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,iEAAiE,CAAC,CAAC;YAEpF,sCAAsC;YACtC,IAAI,IAAI,CAAC,aAAa,KAAK,OAAO,EAAE,CAAC;gBACnC,kDAAkD;gBAClD,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,kBAAkB,CAAC,CAAC;gBAC9E,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,mBAAmB,CAAC,CAAC;gBAC/E,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,kBAAkB,CAAC,CAAC;gBAC9E,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,mBAAmB,CAAC,oBAAoB,CAAC,CAAC;YAClF,CAAC;QACH,CAAC;QAED,2BAA2B;QAC3B,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC;QAC7B,IAAI,CAAC,qBAAqB,GAAG,IAAI,CAAC;QAElC,oCAAoC;QACpC,wBAAwB,CAAC,IAAI,CAAC,aAAa,EAAE;YAC3C,mBAAmB,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC5D,oBAAoB,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC7D,mBAAmB,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC5D,qBAAqB,EAAE,CAAC,IAAI,EAAE,EAAE;gBAC9B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,IAAI,CAAC,MAAM,eAAe,IAAI,CAAC,aAAa,OAAO,CAAC,CAAC;YAC3F,CAAC;SACF,CAAC,CAAC;QAEH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,wDAAwD,CAAC,CAAC;QAE3E,yEAAyE;QACzE,IAAI,IAAI,CAAC,gBAAgB,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;YACnC,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,CAAC;iBACrD,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,wBAAwB;YAEpE,IAAI,CAAC,gCAAgC,CAAC,OAAO,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;IAED;;OAEG;IACK,uBAAuB,CAAC,IAAmF;QACjH,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;QAE7D,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,eAAe,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,QAAQ,MAAM,iBAAiB,UAAU,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;QAEnJ,qCAAqC;QACrC,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,CAAC,CAAC;QAEzE,uEAAuE;QACvE,IAAI,CAAC,IAAI,CAAC,qBAAqB,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,gBAAgB,EAAE,CAAC;YACvE,IAAI,CAAC,sBAAsB,CAAC,MAAM,EAAE,WAAW,EAAE,UAAU,CAAC,CAAC;QAC/D,CAAC;IACH,CAAC;IAED;;OAEG;IACK,uBAAuB,CAAC,IAAuC;QACrE,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mCAAmC,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC;IACrF,CAAC;IAED;;OAEG;IACK,sBAAsB,CAAC,MAAc,EAAE,WAAmB,EAAE,UAAkB;QACpF,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,GAAG,MAAM,WAAW,CAAC,CAAC;YAC3E,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,mBAAmB,EAAE,GAAG,MAAM,UAAU,CAAC,CAAC;YAEzE,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;YACxC,EAAE,CAAC,aAAa,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;YAEtC,gDAAgD;YAChD,IAAI,CAAC;gBACH,EAAE,CAAC,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;YAC/B,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,gDAAgD,MAAM,KAAK,KAAK,EAAE,CAAC,CAAC;YACvF,CAAC;YAED,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,yBAAyB,MAAM,OAAO,QAAQ,EAAE,CAAC,CAAC;QACrE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,kCAAkC,MAAM,KAAK,KAAK,EAAE,CAAC,CAAC;QAC1E,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,SAAS,CAAC,MAAc,EAAE,EAA+D;QAC9F,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,2BAA2B,MAAM,EAAE,CAAC,CAAC;QAEvD,iDAAiD;QACjD,MAAM,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAChD,IAAI,KAAK,EAAE,CAAC;YACV,IAAI,CAAC;gBACH,iDAAiD;gBACjD,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC;oBAC9C,GAAG,EAAE,KAAK,CAAC,GAAG;oBACd,IAAI,EAAE,KAAK,CAAC,IAAI;iBACjB,CAAC,CAAC;gBACH,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,gCAAgC,MAAM,EAAE,CAAC,CAAC;gBAC5D,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;gBAClB,OAAO;YACT,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qCAAqC,MAAM,GAAG,EAAE,GAAG,CAAC,CAAC;YACzE,CAAC;QACH,CAAC;QACD,0EAA0E;QAC1E,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,IAAI,CAAC;gBACH,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,kDAAkD,MAAM,EAAE,CAAC,CAAC;gBAC7E,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;oBAC3B,UAAU,EAAE,MAAM;oBAClB,WAAW,EAAE,KAAK;oBAClB,eAAe,EAAE,IAAI;iBACtB,CAAC,CAAC;YACL,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,uDAAuD,MAAM,EAAE,EAAE,GAAG,CAAC,CAAC;YAC1F,CAAC;QACH,CAAC;QAED,kDAAkD;QAClD,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,IAAI,IAAI,CAAC,aAAa,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC9E,6CAA6C;YAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;YAE3D,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,4BAA4B,MAAM,4BAA4B,CAAC,CAAC;gBAEjF,0CAA0C;gBAC1C,MAAM,aAAa,GAAmB;oBACpC,UAAU,EAAE,MAAM;oBAClB,WAAW,EAAE,IAAI;oBACjB,eAAe,EAAE,IAAI;iBACtB,CAAC;gBAEF,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC;QAED,mCAAmC;QACnC,IAAI,CAAC;YACH,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,mBAAmB,CAAC;gBAC9C,GAAG,EAAE,IAAI,CAAC,mBAAmB,CAAC,GAAG;gBACjC,IAAI,EAAE,IAAI,CAAC,mBAAmB,CAAC,IAAI;aACpC,CAAC,CAAC;YAEH,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,iCAAiC,MAAM,EAAE,CAAC,CAAC;YAC7D,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QACpB,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,wCAAwC,EAAE,GAAG,CAAC,CAAC;YACjE,EAAE,CAAC,IAAI,KAAK,CAAC,8BAA8B,CAAC,EAAE,IAAI,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;IAED;;OAEG;IACI,sBAAsB,CAAC,MAAc,EAAE,WAAmB,EAAE,UAAkB,EAAE,UAAiB;QACtG,6DAA6D;QAC7D,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;YACrB,IAAI,CAAC;gBACH,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,MAAM,EAAE;oBAClC,GAAG,EAAE,UAAU;oBACf,IAAI,EAAE,WAAW;iBAClB,CAAC,CAAC;gBACH,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mCAAmC,MAAM,EAAE,CAAC,CAAC;YACjE,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,yCAAyC,MAAM,GAAG,EAAE,KAAK,CAAC,CAAC;YAC/E,CAAC;QACH,CAAC;QAED,8BAA8B;QAC9B,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE;YAChC,GAAG,EAAE,UAAU;YACf,IAAI,EAAE,WAAW;YACjB,OAAO,EAAE,UAAU;SACpB,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACI,cAAc,CAAC,MAAc;QAClC,OAAO,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,kBAAkB,CAAC,MAAc;QAC5C,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/D,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,4CAA4C,CAAC,CAAC;YAC/D,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,kCAAkC,CAAC,CAAC;YACtD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,4EAA4E;QAC5E,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,mDAAmD,MAAM,EAAE,CAAC,CAAC;YAC/E,OAAO,KAAK,CAAC;QACf,CAAC;QAED,IAAI,CAAC;YACH,oCAAoC;YACpC,MAAM,aAAa,GAAmB;gBACpC,UAAU,EAAE,MAAM;gBAClB,WAAW,EAAE,IAAI;gBACjB,eAAe,EAAE,IAAI;aACtB,CAAC;YAEF,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YAC5C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,6CAA6C,MAAM,EAAE,CAAC,CAAC;YACxE,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,2CAA2C,MAAM,GAAG,EAAE,KAAK,CAAC,CAAC;YAC/E,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;OAEG;IACI,gCAAgC,CAAC,OAAiB;QACvD,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,kCAAkC,CAAC,CAAC;YACrD,OAAO;QACT,CAAC;QAED,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,4EAA4E;YAC5E,IAAI,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBACzB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,sCAAsC,MAAM,EAAE,CAAC,CAAC;gBACjE,SAAS;YACX,CAAC;YAED,gEAAgE;YAChE,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,mBAAmB,EAAE,CAAC;gBAC3C,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;gBACrD,IAAI,UAAU,EAAE,CAAC;oBACf,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,8CAA8C,MAAM,EAAE,CAAC,CAAC;oBACzE,SAAS;gBACX,CAAC;YACH,CAAC;YAED,8EAA8E;YAC9E,MAAM,aAAa,GAAmB;gBACpC,UAAU,EAAE,MAAM;gBAClB,WAAW,EAAE,IAAI;gBACjB,eAAe,EAAE,IAAI;aACtB,CAAC;YAEF,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;YAC5C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,oDAAoD,MAAM,EAAE,CAAC,CAAC;QACjF,CAAC;IACH,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,uBAAuB;QAClC,iCAAiC;QACjC,IAAI,IAAI,CAAC,qBAAqB,EAAE,CAAC;YAC/B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,uDAAuD,CAAC,CAAC;YAC1E,OAAO,IAAI,CAAC,aAAa,CAAC;QAC5B,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC;YAChC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,oCAAoC;QACpC,IAAI,CAAC,aAAa,GAAG,kBAAkB,CAAC;YACtC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI;YAC5B,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,YAAY;YAC5C,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa;YAC9C,iBAAiB,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,6BAA6B;YACnE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO;YAClC,gBAAgB,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,gBAAgB;YACpD,mBAAmB,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,mBAAmB;SAC3D,CAAC,CAAC;QACH,oCAAoC;QACpC,wBAAwB,CAAC,IAAI,CAAC,aAAa,EAAE;YAC3C,mBAAmB,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC5D,oBAAoB,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC7D,mBAAmB,EAAE,IAAI,CAAC,uBAAuB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC5D,qBAAqB,EAAE,CAAC,IAAI,EAAE,EAAE;gBAC9B,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,mBAAmB,IAAI,CAAC,MAAM,eAAe,IAAI,CAAC,aAAa,OAAO,CAAC,CAAC;YAC3F,CAAC;SACF,CAAC,CAAC;QAEH,oBAAoB;QACpB,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;YACjC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,iCAAiC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;YAC5E,OAAO,IAAI,CAAC,aAAa,CAAC;QAC5B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,kCAAkC,KAAK,EAAE,CAAC,CAAC;YAC7D,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;YAC1B,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,iBAAiB;QAC5B,IAAI,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,qBAAqB,EAAE,CAAC;YACtD,IAAI,CAAC;gBACH,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;gBAChC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,uBAAuB,CAAC,CAAC;YAC5C,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,8BAA8B,EAAE,KAAK,CAAC,CAAC;YAC3D,CAAC;QACH,CAAC;IACH,CAAC;CACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.np.certificatemanager.js","sourceRoot":"","sources":["../../ts/networkproxy/classes.np.certificatemanager.ts"],"names":[],"mappings":"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"}

package/dist_ts/networkproxy/index.d.ts

@@ -1,6 +1 @@
-export * from './classes.np.types.js';
-export * from './classes.np.certificatemanager.js';
-export * from './classes.np.connectionpool.js';
-export * from './classes.np.requesthandler.js';
-export * from './classes.np.websockethandler.js';
-export * from './classes.np.networkproxy.js';
+export * from '../proxies/network-proxy/index.js';

package/dist_ts/networkproxy/index.js

@@ -1,8 +1,4 @@
-// Re-export all components for easier imports
-export * from './classes.np.types.js';
-export * from './classes.np.certificatemanager.js';
-export * from './classes.np.connectionpool.js';
-export * from './classes.np.requesthandler.js';
-export * from './classes.np.websockethandler.js';
-export * from './classes.np.networkproxy.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9uZXR3b3JrcHJveHkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsOENBQThDO0FBQzlDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLDhCQUE4QixDQUFDIn0=
+// Re-export all components from the new location
+// This file is for backward compatibility only
+export * from '../proxies/network-proxy/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9uZXR3b3JrcHJveHkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsaURBQWlEO0FBQ2pELCtDQUErQztBQUMvQyxjQUFjLG1DQUFtQyxDQUFDIn0=

package/dist_ts/plugins.d.ts

@@ -1,11 +1,12 @@
 import { EventEmitter } from 'events';
+import * as fs from 'fs';
 import * as http from 'http';
 import * as https from 'https';
 import * as net from 'net';
 import * as tls from 'tls';
 import * as url from 'url';
 import * as http2 from 'http2';
-export { EventEmitter, http, https, net, tls, url, http2 };
+export { EventEmitter, fs, http, https, net, tls, url, http2 };
 import * as tsclass from '@tsclass/tsclass';
 export { tsclass };
 import * as lik from '@push.rocks/lik';