@push.rocks/smartproxy 5.0.0 → 6.0.0

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

@@ -0,0 +1,210 @@
+import * as plugins from '../plugins.js';
+import { createLogger } from './classes.np.types.js';
+import { ConnectionPool } from './classes.np.connectionpool.js';
+import { ProxyRouter } from '../classes.router.js';
+/**
+ * Handles HTTP request processing and proxying
+ */
+export class RequestHandler {
+    constructor(options, connectionPool, router) {
+        this.options = options;
+        this.connectionPool = connectionPool;
+        this.router = router;
+        this.defaultHeaders = {};
+        this.metricsTracker = null;
+        this.logger = createLogger(options.logLevel || 'info');
+    }
+    /**
+     * Set the metrics tracker instance
+     */
+    setMetricsTracker(tracker) {
+        this.metricsTracker = tracker;
+    }
+    /**
+     * Set default headers to be included in all responses
+     */
+    setDefaultHeaders(headers) {
+        this.defaultHeaders = {
+            ...this.defaultHeaders,
+            ...headers
+        };
+        this.logger.info('Updated default response headers');
+    }
+    /**
+     * Get all default headers
+     */
+    getDefaultHeaders() {
+        return { ...this.defaultHeaders };
+    }
+    /**
+     * Apply CORS headers to response if configured
+     */
+    applyCorsHeaders(res, req) {
+        if (!this.options.cors) {
+            return;
+        }
+        // Apply CORS headers
+        if (this.options.cors.allowOrigin) {
+            res.setHeader('Access-Control-Allow-Origin', this.options.cors.allowOrigin);
+        }
+        if (this.options.cors.allowMethods) {
+            res.setHeader('Access-Control-Allow-Methods', this.options.cors.allowMethods);
+        }
+        if (this.options.cors.allowHeaders) {
+            res.setHeader('Access-Control-Allow-Headers', this.options.cors.allowHeaders);
+        }
+        if (this.options.cors.maxAge) {
+            res.setHeader('Access-Control-Max-Age', this.options.cors.maxAge.toString());
+        }
+        // Handle CORS preflight requests
+        if (req.method === 'OPTIONS') {
+            res.statusCode = 204; // No content
+            res.end();
+            return;
+        }
+    }
+    /**
+     * Apply default headers to response
+     */
+    applyDefaultHeaders(res) {
+        // Apply default headers
+        for (const [key, value] of Object.entries(this.defaultHeaders)) {
+            if (!res.hasHeader(key)) {
+                res.setHeader(key, value);
+            }
+        }
+        // Add server identifier if not already set
+        if (!res.hasHeader('Server')) {
+            res.setHeader('Server', 'NetworkProxy');
+        }
+    }
+    /**
+     * Handle an HTTP request
+     */
+    async handleRequest(req, res) {
+        // Record start time for logging
+        const startTime = Date.now();
+        // Apply CORS headers if configured
+        this.applyCorsHeaders(res, req);
+        // If this is an OPTIONS request, the response has already been ended in applyCorsHeaders
+        // so we should return early to avoid trying to set more headers
+        if (req.method === 'OPTIONS') {
+            // Increment metrics for OPTIONS requests too
+            if (this.metricsTracker) {
+                this.metricsTracker.incrementRequestsServed();
+            }
+            return;
+        }
+        // Apply default headers
+        this.applyDefaultHeaders(res);
+        try {
+            // Find target based on hostname
+            const proxyConfig = this.router.routeReq(req);
+            if (!proxyConfig) {
+                // No matching proxy configuration
+                this.logger.warn(`No proxy configuration for host: ${req.headers.host}`);
+                res.statusCode = 404;
+                res.end('Not Found: No proxy configuration for this host');
+                // Increment failed requests counter
+                if (this.metricsTracker) {
+                    this.metricsTracker.incrementFailedRequests();
+                }
+                return;
+            }
+            // Get destination IP using round-robin if multiple IPs configured
+            const destination = this.connectionPool.getNextTarget(proxyConfig.destinationIps, proxyConfig.destinationPorts[0]);
+            // Create options for the proxy request
+            const options = {
+                hostname: destination.host,
+                port: destination.port,
+                path: req.url,
+                method: req.method,
+                headers: { ...req.headers }
+            };
+            // Remove host header to avoid issues with virtual hosts on target server
+            // The host header should match the target server's expected hostname
+            if (options.headers && options.headers.host) {
+                if (proxyConfig.rewriteHostHeader) {
+                    options.headers.host = `${destination.host}:${destination.port}`;
+                }
+            }
+            this.logger.debug(`Proxying request to ${destination.host}:${destination.port}${req.url}`, { method: req.method });
+            // Create proxy request
+            const proxyReq = plugins.http.request(options, (proxyRes) => {
+                // Copy status code
+                res.statusCode = proxyRes.statusCode || 500;
+                // Copy headers from proxy response to client response
+                for (const [key, value] of Object.entries(proxyRes.headers)) {
+                    if (value !== undefined) {
+                        res.setHeader(key, value);
+                    }
+                }
+                // Pipe proxy response to client response
+                proxyRes.pipe(res);
+                // Increment served requests counter when the response finishes
+                res.on('finish', () => {
+                    if (this.metricsTracker) {
+                        this.metricsTracker.incrementRequestsServed();
+                    }
+                    // Log the completed request
+                    const duration = Date.now() - startTime;
+                    this.logger.debug(`Request completed in ${duration}ms: ${req.method} ${req.url} ${res.statusCode}`, { duration, statusCode: res.statusCode });
+                });
+            });
+            // Handle proxy request errors
+            proxyReq.on('error', (error) => {
+                const duration = Date.now() - startTime;
+                this.logger.error(`Proxy error for ${req.method} ${req.url}: ${error.message}`, { duration, error: error.message });
+                // Increment failed requests counter
+                if (this.metricsTracker) {
+                    this.metricsTracker.incrementFailedRequests();
+                }
+                // Check if headers have already been sent
+                if (!res.headersSent) {
+                    res.statusCode = 502;
+                    res.end(`Bad Gateway: ${error.message}`);
+                }
+                else {
+                    // If headers already sent, just close the connection
+                    res.end();
+                }
+            });
+            // Pipe request body to proxy request and handle client-side errors
+            req.pipe(proxyReq);
+            // Handle client disconnection
+            req.on('error', (error) => {
+                this.logger.debug(`Client connection error: ${error.message}`);
+                proxyReq.destroy();
+                // Increment failed requests counter on client errors
+                if (this.metricsTracker) {
+                    this.metricsTracker.incrementFailedRequests();
+                }
+            });
+            // Handle response errors
+            res.on('error', (error) => {
+                this.logger.debug(`Response error: ${error.message}`);
+                proxyReq.destroy();
+                // Increment failed requests counter on response errors
+                if (this.metricsTracker) {
+                    this.metricsTracker.incrementFailedRequests();
+                }
+            });
+        }
+        catch (error) {
+            // Handle any unexpected errors
+            this.logger.error(`Unexpected error handling request: ${error.message}`, { error: error.stack });
+            // Increment failed requests counter
+            if (this.metricsTracker) {
+                this.metricsTracker.incrementFailedRequests();
+            }
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.end('Internal Server Error');
+            }
+            else {
+                res.end();
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.np.requesthandler.js","sourceRoot":"","sources":["../../ts/networkproxy/classes.np.requesthandler.ts"],"names":[],"mappings":"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"}

package/dist_ts/networkproxy/classes.np.types.d.ts

@@ -0,0 +1,82 @@
+import * as plugins from '../plugins.js';
+/**
+ * Configuration options for NetworkProxy
+ */
+export interface INetworkProxyOptions {
+    port: number;
+    maxConnections?: number;
+    keepAliveTimeout?: number;
+    headersTimeout?: number;
+    logLevel?: 'error' | 'warn' | 'info' | 'debug';
+    cors?: {
+        allowOrigin?: string;
+        allowMethods?: string;
+        allowHeaders?: string;
+        maxAge?: number;
+    };
+    connectionPoolSize?: number;
+    portProxyIntegration?: boolean;
+    useExternalPort80Handler?: boolean;
+    acme?: {
+        enabled?: boolean;
+        port?: number;
+        contactEmail?: string;
+        useProduction?: boolean;
+        renewThresholdDays?: number;
+        autoRenew?: boolean;
+        certificateStore?: string;
+        skipConfiguredCerts?: boolean;
+    };
+}
+/**
+ * Interface for a certificate entry in the cache
+ */
+export interface ICertificateEntry {
+    key: string;
+    cert: string;
+    expires?: Date;
+}
+/**
+ * Interface for reverse proxy configuration
+ */
+export interface IReverseProxyConfig {
+    destinationIps: string[];
+    destinationPorts: number[];
+    hostName: string;
+    privateKey: string;
+    publicKey: string;
+    authentication?: {
+        type: 'Basic';
+        user: string;
+        pass: string;
+    };
+    rewriteHostHeader?: boolean;
+}
+/**
+ * Interface for connection tracking in the pool
+ */
+export interface IConnectionEntry {
+    socket: plugins.net.Socket;
+    lastUsed: number;
+    isIdle: boolean;
+}
+/**
+ * WebSocket with heartbeat interface
+ */
+export interface IWebSocketWithHeartbeat extends plugins.wsDefault {
+    lastPong: number;
+    isAlive: boolean;
+}
+/**
+ * Logger interface for consistent logging across components
+ */
+export interface ILogger {
+    debug(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string, data?: any): void;
+}
+/**
+ * Creates a logger based on the specified log level
+ */
+export declare function createLogger(logLevel?: string): ILogger;

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

@@ -0,0 +1,35 @@
+import * as plugins from '../plugins.js';
+/**
+ * Creates a logger based on the specified log level
+ */
+export function createLogger(logLevel = 'info') {
+    const logLevels = {
+        error: 0,
+        warn: 1,
+        info: 2,
+        debug: 3
+    };
+    return {
+        debug: (message, data) => {
+            if (logLevels[logLevel] >= logLevels.debug) {
+                console.log(`[DEBUG] ${message}`, data || '');
+            }
+        },
+        info: (message, data) => {
+            if (logLevels[logLevel] >= logLevels.info) {
+                console.log(`[INFO] ${message}`, data || '');
+            }
+        },
+        warn: (message, data) => {
+            if (logLevels[logLevel] >= logLevels.warn) {
+                console.warn(`[WARN] ${message}`, data || '');
+            }
+        },
+        error: (message, data) => {
+            if (logLevels[logLevel] >= logLevels.error) {
+                console.error(`[ERROR] ${message}`, data || '');
+            }
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5ucC50eXBlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL25ldHdvcmtwcm94eS9jbGFzc2VzLm5wLnR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sZUFBZSxDQUFDO0FBeUZ6Qzs7R0FFRztBQUNILE1BQU0sVUFBVSxZQUFZLENBQUMsV0FBbUIsTUFBTTtJQUNwRCxNQUFNLFNBQVMsR0FBRztRQUNoQixLQUFLLEVBQUUsQ0FBQztRQUNSLElBQUksRUFBRSxDQUFDO1FBQ1AsSUFBSSxFQUFFLENBQUM7UUFDUCxLQUFLLEVBQUUsQ0FBQztLQUNULENBQUM7SUFFRixPQUFPO1FBQ0wsS0FBSyxFQUFFLENBQUMsT0FBZSxFQUFFLElBQVUsRUFBRSxFQUFFO1lBQ3JDLElBQUksU0FBUyxDQUFDLFFBQVEsQ0FBQyxJQUFJLFNBQVMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztnQkFDM0MsT0FBTyxDQUFDLEdBQUcsQ0FBQyxXQUFXLE9BQU8sRUFBRSxFQUFFLElBQUksSUFBSSxFQUFFLENBQUMsQ0FBQztZQUNoRCxDQUFDO1FBQ0gsQ0FBQztRQUNELElBQUksRUFBRSxDQUFDLE9BQWUsRUFBRSxJQUFVLEVBQUUsRUFBRTtZQUNwQyxJQUFJLFNBQVMsQ0FBQyxRQUFRLENBQUMsSUFBSSxTQUFTLENBQUMsSUFBSSxFQUFFLENBQUM7Z0JBQzFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsVUFBVSxPQUFPLEVBQUUsRUFBRSxJQUFJLElBQUksRUFBRSxDQUFDLENBQUM7WUFDL0MsQ0FBQztRQUNILENBQUM7UUFDRCxJQUFJLEVBQUUsQ0FBQyxPQUFlLEVBQUUsSUFBVSxFQUFFLEVBQUU7WUFDcEMsSUFBSSxTQUFTLENBQUMsUUFBUSxDQUFDLElBQUksU0FBUyxDQUFDLElBQUksRUFBRSxDQUFDO2dCQUMxQyxPQUFPLENBQUMsSUFBSSxDQUFDLFVBQVUsT0FBTyxFQUFFLEVBQUUsSUFBSSxJQUFJLEVBQUUsQ0FBQyxDQUFDO1lBQ2hELENBQUM7UUFDSCxDQUFDO1FBQ0QsS0FBSyxFQUFFLENBQUMsT0FBZSxFQUFFLElBQVUsRUFBRSxFQUFFO1lBQ3JDLElBQUksU0FBUyxDQUFDLFFBQVEsQ0FBQyxJQUFJLFNBQVMsQ0FBQyxLQUFLLEVBQUUsQ0FBQztnQkFDM0MsT0FBTyxDQUFDLEtBQUssQ0FBQyxXQUFXLE9BQU8sRUFBRSxFQUFFLElBQUksSUFBSSxFQUFFLENBQUMsQ0FBQztZQUNsRCxDQUFDO1FBQ0gsQ0FBQztLQUNGLENBQUM7QUFDSixDQUFDIn0=

package/dist_ts/networkproxy/classes.np.websockethandler.d.ts

@@ -0,0 +1,38 @@
+import * as plugins from '../plugins.js';
+import { type INetworkProxyOptions } from './classes.np.types.js';
+import { ConnectionPool } from './classes.np.connectionpool.js';
+import { ProxyRouter } from '../classes.router.js';
+/**
+ * Handles WebSocket connections and proxying
+ */
+export declare class WebSocketHandler {
+    private options;
+    private connectionPool;
+    private router;
+    private heartbeatInterval;
+    private wsServer;
+    private logger;
+    constructor(options: INetworkProxyOptions, connectionPool: ConnectionPool, router: ProxyRouter);
+    /**
+     * Initialize WebSocket server on an existing HTTPS server
+     */
+    initialize(server: plugins.https.Server): void;
+    /**
+     * Start the heartbeat interval to check for inactive WebSocket connections
+     */
+    private startHeartbeat;
+    /**
+     * Handle a new WebSocket connection
+     */
+    private handleWebSocketConnection;
+    /**
+     * Get information about active WebSocket connections
+     */
+    getConnectionInfo(): {
+        activeConnections: number;
+    };
+    /**
+     * Shutdown the WebSocket handler
+     */
+    shutdown(): void;
+}

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

@@ -0,0 +1,188 @@
+import * as plugins from '../plugins.js';
+import { createLogger } from './classes.np.types.js';
+import { ConnectionPool } from './classes.np.connectionpool.js';
+import { ProxyRouter } from '../classes.router.js';
+/**
+ * Handles WebSocket connections and proxying
+ */
+export class WebSocketHandler {
+    constructor(options, connectionPool, router) {
+        this.options = options;
+        this.connectionPool = connectionPool;
+        this.router = router;
+        this.heartbeatInterval = null;
+        this.wsServer = null;
+        this.logger = createLogger(options.logLevel || 'info');
+    }
+    /**
+     * Initialize WebSocket server on an existing HTTPS server
+     */
+    initialize(server) {
+        // Create WebSocket server
+        this.wsServer = new plugins.ws.WebSocketServer({
+            server: server,
+            clientTracking: true
+        });
+        // Handle WebSocket connections
+        this.wsServer.on('connection', (wsIncoming, req) => {
+            this.handleWebSocketConnection(wsIncoming, req);
+        });
+        // Start the heartbeat interval
+        this.startHeartbeat();
+        this.logger.info('WebSocket handler initialized');
+    }
+    /**
+     * Start the heartbeat interval to check for inactive WebSocket connections
+     */
+    startHeartbeat() {
+        // Clean up existing interval if any
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+        // Set up the heartbeat interval (check every 30 seconds)
+        this.heartbeatInterval = setInterval(() => {
+            if (!this.wsServer || this.wsServer.clients.size === 0) {
+                return; // Skip if no active connections
+            }
+            this.logger.debug(`WebSocket heartbeat check for ${this.wsServer.clients.size} clients`);
+            this.wsServer.clients.forEach((ws) => {
+                const wsWithHeartbeat = ws;
+                if (wsWithHeartbeat.isAlive === false) {
+                    this.logger.debug('Terminating inactive WebSocket connection');
+                    return wsWithHeartbeat.terminate();
+                }
+                wsWithHeartbeat.isAlive = false;
+                wsWithHeartbeat.ping();
+            });
+        }, 30000);
+        // Make sure the interval doesn't keep the process alive
+        if (this.heartbeatInterval.unref) {
+            this.heartbeatInterval.unref();
+        }
+    }
+    /**
+     * Handle a new WebSocket connection
+     */
+    handleWebSocketConnection(wsIncoming, req) {
+        try {
+            // Initialize heartbeat tracking
+            wsIncoming.isAlive = true;
+            wsIncoming.lastPong = Date.now();
+            // Handle pong messages to track liveness
+            wsIncoming.on('pong', () => {
+                wsIncoming.isAlive = true;
+                wsIncoming.lastPong = Date.now();
+            });
+            // Find target configuration based on request
+            const proxyConfig = this.router.routeReq(req);
+            if (!proxyConfig) {
+                this.logger.warn(`No proxy configuration for WebSocket host: ${req.headers.host}`);
+                wsIncoming.close(1008, 'No proxy configuration for this host');
+                return;
+            }
+            // Get destination target using round-robin if multiple targets
+            const destination = this.connectionPool.getNextTarget(proxyConfig.destinationIps, proxyConfig.destinationPorts[0]);
+            // Build target URL
+            const protocol = req.socket.encrypted ? 'wss' : 'ws';
+            const targetUrl = `${protocol}://${destination.host}:${destination.port}${req.url}`;
+            this.logger.debug(`WebSocket connection from ${req.socket.remoteAddress} to ${targetUrl}`);
+            // Create headers for outgoing WebSocket connection
+            const headers = {};
+            // Copy relevant headers from incoming request
+            for (const [key, value] of Object.entries(req.headers)) {
+                if (value && typeof value === 'string' &&
+                    key.toLowerCase() !== 'connection' &&
+                    key.toLowerCase() !== 'upgrade' &&
+                    key.toLowerCase() !== 'sec-websocket-key' &&
+                    key.toLowerCase() !== 'sec-websocket-version') {
+                    headers[key] = value;
+                }
+            }
+            // Override host header if needed
+            if (proxyConfig.rewriteHostHeader) {
+                headers['host'] = `${destination.host}:${destination.port}`;
+            }
+            // Create outgoing WebSocket connection
+            const wsOutgoing = new plugins.wsDefault(targetUrl, {
+                headers: headers,
+                followRedirects: true
+            });
+            // Handle connection errors
+            wsOutgoing.on('error', (err) => {
+                this.logger.error(`WebSocket target connection error: ${err.message}`);
+                if (wsIncoming.readyState === wsIncoming.OPEN) {
+                    wsIncoming.close(1011, 'Internal server error');
+                }
+            });
+            // Handle outgoing connection open
+            wsOutgoing.on('open', () => {
+                // Forward incoming messages to outgoing connection
+                wsIncoming.on('message', (data, isBinary) => {
+                    if (wsOutgoing.readyState === wsOutgoing.OPEN) {
+                        wsOutgoing.send(data, { binary: isBinary });
+                    }
+                });
+                // Forward outgoing messages to incoming connection
+                wsOutgoing.on('message', (data, isBinary) => {
+                    if (wsIncoming.readyState === wsIncoming.OPEN) {
+                        wsIncoming.send(data, { binary: isBinary });
+                    }
+                });
+                // Handle closing of connections
+                wsIncoming.on('close', (code, reason) => {
+                    this.logger.debug(`WebSocket client connection closed: ${code} ${reason}`);
+                    if (wsOutgoing.readyState === wsOutgoing.OPEN) {
+                        wsOutgoing.close(code, reason);
+                    }
+                });
+                wsOutgoing.on('close', (code, reason) => {
+                    this.logger.debug(`WebSocket target connection closed: ${code} ${reason}`);
+                    if (wsIncoming.readyState === wsIncoming.OPEN) {
+                        wsIncoming.close(code, reason);
+                    }
+                });
+                this.logger.debug(`WebSocket connection established: ${req.headers.host} -> ${destination.host}:${destination.port}`);
+            });
+        }
+        catch (error) {
+            this.logger.error(`Error handling WebSocket connection: ${error.message}`);
+            if (wsIncoming.readyState === wsIncoming.OPEN) {
+                wsIncoming.close(1011, 'Internal server error');
+            }
+        }
+    }
+    /**
+     * Get information about active WebSocket connections
+     */
+    getConnectionInfo() {
+        return {
+            activeConnections: this.wsServer ? this.wsServer.clients.size : 0
+        };
+    }
+    /**
+     * Shutdown the WebSocket handler
+     */
+    shutdown() {
+        // Stop heartbeat interval
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+        // Close all WebSocket connections
+        if (this.wsServer) {
+            this.logger.info(`Closing ${this.wsServer.clients.size} WebSocket connections`);
+            for (const client of this.wsServer.clients) {
+                try {
+                    client.terminate();
+                }
+                catch (error) {
+                    this.logger.error('Error terminating WebSocket client', error);
+                }
+            }
+            // Close the server
+            this.wsServer.close();
+            this.wsServer = null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.np.websockethandler.js","sourceRoot":"","sources":["../../ts/networkproxy/classes.np.websockethandler.ts"],"names":[],"mappings":"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"}

package/dist_ts/networkproxy/index.d.ts

@@ -0,0 +1,6 @@
+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';

package/dist_ts/networkproxy/index.js

@@ -0,0 +1,8 @@
+// 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=