@push.rocks/smartproxy 18.0.2 → 18.2.0

package/dist_ts/certificate/simplified-certificate-manager.js

@@ -0,0 +1,501 @@
+/**
+ * Simplified, unified certificate manager for SmartProxy
+ */
+import * as plugins from '../plugins.js';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { CertificateError, CertificateErrors } from './models/certificate-errors.js';
+import { CertificateEvent } from './events/simplified-events.js';
+/**
+ * Unified certificate manager
+ */
+export class SimplifiedCertificateManager extends plugins.EventEmitter {
+    constructor(config) {
+        super();
+        this.certificateCache = new Map();
+        this.pendingRequests = new Map();
+        // Validate configuration
+        if (!config.certProvider) {
+            throw CertificateErrors.noCertProvider();
+        }
+        if (!config.acmeEmail) {
+            throw CertificateErrors.missingAcmeEmail();
+        }
+        // Set defaults
+        this.config = {
+            ...config,
+            storageDir: config.storageDir || './certs',
+            renewBeforeDays: config.renewBeforeDays || 30,
+            defaultCertPath: config.defaultCertPath || path.join(process.cwd(), 'assets/certs/cert.pem'),
+            defaultKeyPath: config.defaultKeyPath || path.join(process.cwd(), 'assets/certs/key.pem')
+        };
+        // Ensure storage directory exists
+        this.ensureStorageDir();
+    }
+    /**
+     * Initialize the certificate manager
+     */
+    async start() {
+        // Initialize ACME client
+        await this.initializeAcmeClient();
+        // Load stored certificates
+        await this.loadStoredCertificates();
+        // Start renewal timer
+        this.startRenewalTimer();
+    }
+    /**
+     * Stop the certificate manager
+     */
+    async stop() {
+        if (this.renewalTimer) {
+            clearInterval(this.renewalTimer);
+            this.renewalTimer = undefined;
+        }
+    }
+    /**
+     * Get a certificate for a domain (main entry point)
+     */
+    async getCertificate(domain) {
+        // Check cache first
+        const cached = this.certificateCache.get(domain);
+        if (cached && this.isCertificateValid(cached)) {
+            return cached;
+        }
+        // Check for pending request to avoid duplicates
+        const pending = this.pendingRequests.get(domain);
+        if (pending) {
+            return pending;
+        }
+        // Start new certificate request
+        const request = this.requestCertificate(domain);
+        this.pendingRequests.set(domain, request);
+        try {
+            const cert = await request;
+            this.pendingRequests.delete(domain);
+            return cert;
+        }
+        catch (error) {
+            this.pendingRequests.delete(domain);
+            throw error;
+        }
+    }
+    /**
+     * Request a new certificate
+     */
+    async requestCertificate(domain) {
+        try {
+            // Get strategy from provider
+            let strategy;
+            try {
+                strategy = await this.config.certProvider(domain);
+            }
+            catch (providerError) {
+                throw CertificateErrors.invalidCertProvider(providerError);
+            }
+            let certificate;
+            switch (strategy.type) {
+                case 'acme-http':
+                    certificate = await this.requestAcmeHttpCertificate(domain);
+                    break;
+                case 'acme-dns':
+                    certificate = await this.requestAcmeDnsCertificate(domain);
+                    break;
+                case 'static':
+                    certificate = {
+                        domain,
+                        certificate: strategy.cert,
+                        privateKey: strategy.key,
+                        expiresAt: strategy.expiresAt || new Date(Date.now() + 90 * 24 * 60 * 60 * 1000),
+                        source: 'static'
+                    };
+                    break;
+                case 'skip':
+                    throw CertificateErrors.certificateNotFound(domain);
+                default:
+                    throw CertificateErrors.invalidCertProvider(new Error('Unknown strategy type'));
+            }
+            // Cache and store
+            this.certificateCache.set(domain, certificate);
+            await this.storeCertificate(certificate);
+            // Emit success event
+            this.emit(CertificateEvent.OBTAINED, {
+                domain,
+                type: 'new',
+                expiresAt: certificate.expiresAt,
+                source: certificate.source,
+                certificate: certificate.certificate,
+                privateKey: certificate.privateKey
+            });
+            return certificate;
+        }
+        catch (error) {
+            const certError = error instanceof CertificateError
+                ? error
+                : new CertificateError({
+                    code: 'UNKNOWN_ERROR',
+                    message: error.message || 'Unknown error',
+                    domain,
+                    cause: error
+                });
+            this.emit(CertificateEvent.FAILED, {
+                domain,
+                error: certError
+            });
+            throw certError;
+        }
+    }
+    /**
+     * Request certificate via ACME HTTP-01
+     */
+    async requestAcmeHttpCertificate(domain) {
+        if (domain.includes('*')) {
+            throw CertificateErrors.wildcardNotSupported(domain);
+        }
+        try {
+            // Create ACME order
+            const order = await this.acmeClient.createOrder({
+                identifiers: [{ type: 'dns', value: domain }]
+            });
+            // Get authorization
+            const authorization = await this.acmeClient.getAuthorization(order.authorizations[0]);
+            const challenge = authorization.challenges.find(c => c.type === 'http-01');
+            if (!challenge) {
+                throw new Error('No HTTP-01 challenge available');
+            }
+            // Prepare challenge response
+            const keyAuthorization = await this.acmeClient.getChallengeKeyAuthorization(challenge);
+            // Set up HTTP responder (this would integrate with Port80Handler)
+            await this.setupHttpChallenge(challenge.token, keyAuthorization);
+            // Notify ACME server
+            await this.acmeClient.completeChallenge(challenge);
+            await this.acmeClient.waitForValidation(challenge);
+            // Generate CSR
+            const keypair = await this.generateKeypair();
+            const csr = await this.generateCsr(domain, keypair);
+            // Finalize order
+            await this.acmeClient.finalizeOrder(order, csr);
+            const cert = await this.acmeClient.getCertificate(order);
+            // Clean up challenge
+            await this.cleanupHttpChallenge(challenge.token);
+            return {
+                domain,
+                certificate: cert,
+                privateKey: keypair.privateKey,
+                expiresAt: this.extractExpiryDate(cert),
+                source: 'acme-http'
+            };
+        }
+        catch (error) {
+            throw CertificateErrors.acmeHttpChallengeFailed(domain, error);
+        }
+    }
+    /**
+     * Request certificate via ACME DNS-01
+     */
+    async requestAcmeDnsCertificate(domain) {
+        try {
+            // Create ACME order
+            const order = await this.acmeClient.createOrder({
+                identifiers: [{ type: 'dns', value: domain }]
+            });
+            // Get authorization
+            const authorization = await this.acmeClient.getAuthorization(order.authorizations[0]);
+            const challenge = authorization.challenges.find(c => c.type === 'dns-01');
+            if (!challenge) {
+                throw new Error('No DNS-01 challenge available');
+            }
+            // Get DNS record value
+            const keyAuthorization = await this.acmeClient.getChallengeKeyAuthorization(challenge);
+            const dnsRecord = this.acmeClient.keyAuthorizationToDns01(keyAuthorization);
+            // Note: Actual DNS record creation would be handled externally
+            console.log(`Please create DNS TXT record: _acme-challenge.${domain} = ${dnsRecord}`);
+            // In a real implementation, we'd wait for DNS propagation
+            // For now, this is a placeholder
+            await new Promise(resolve => setTimeout(resolve, 60000)); // Wait 60 seconds
+            // Notify ACME server
+            await this.acmeClient.completeChallenge(challenge);
+            await this.acmeClient.waitForValidation(challenge);
+            // Generate CSR
+            const keypair = await this.generateKeypair();
+            const csr = await this.generateCsr(domain, keypair);
+            // Finalize order
+            await this.acmeClient.finalizeOrder(order, csr);
+            const cert = await this.acmeClient.getCertificate(order);
+            return {
+                domain,
+                certificate: cert,
+                privateKey: keypair.privateKey,
+                expiresAt: this.extractExpiryDate(cert),
+                source: 'acme-dns'
+            };
+        }
+        catch (error) {
+            throw CertificateErrors.acmeDnsChallengeFailed(domain, error);
+        }
+    }
+    /**
+     * Renew a certificate
+     */
+    async renewCertificate(domain) {
+        const existing = this.certificateCache.get(domain);
+        if (!existing) {
+            throw CertificateErrors.certificateNotFound(domain);
+        }
+        try {
+            // Request new certificate
+            const renewed = await this.requestCertificate(domain);
+            // Emit renewal event
+            this.emit(CertificateEvent.OBTAINED, {
+                domain,
+                type: 'renewed',
+                expiresAt: renewed.expiresAt,
+                source: renewed.source,
+                certificate: renewed.certificate,
+                privateKey: renewed.privateKey
+            });
+            return renewed;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    /**
+     * Check certificates for renewal
+     */
+    async checkForRenewals() {
+        for (const [domain, cert] of this.certificateCache.entries()) {
+            if (this.shouldRenew(cert)) {
+                try {
+                    await this.renewCertificate(domain);
+                }
+                catch (error) {
+                    console.error(`Failed to renew certificate for ${domain}:`, error);
+                }
+            }
+            else if (this.isExpiringSoon(cert)) {
+                this.emit(CertificateEvent.EXPIRING, {
+                    domain,
+                    expiresAt: cert.expiresAt,
+                    daysRemaining: this.getDaysRemaining(cert)
+                });
+            }
+        }
+    }
+    /**
+     * Initialize ACME client
+     */
+    async initializeAcmeClient() {
+        // ACME client initialization placeholder
+        // In a real implementation, this would use an ACME library
+        console.log(`Initializing ACME client for ${this.config.acmeServer} environment`);
+    }
+    /**
+     * Load stored certificates from disk
+     */
+    async loadStoredCertificates() {
+        try {
+            const files = await fs.readdir(this.config.storageDir);
+            const certFiles = files.filter(f => f.endsWith('.json'));
+            for (const file of certFiles) {
+                try {
+                    const content = await fs.readFile(path.join(this.config.storageDir, file), 'utf-8');
+                    const cert = JSON.parse(content);
+                    cert.expiresAt = new Date(cert.expiresAt);
+                    if (this.isCertificateValid(cert)) {
+                        this.certificateCache.set(cert.domain, cert);
+                    }
+                }
+                catch (error) {
+                    console.error(`Failed to load certificate ${file}:`, error);
+                }
+            }
+        }
+        catch (error) {
+            console.error('Failed to load certificates:', error);
+        }
+    }
+    /**
+     * Store certificate to disk
+     */
+    async storeCertificate(cert) {
+        const filename = `${cert.domain}.json`;
+        const filepath = path.join(this.config.storageDir, filename);
+        try {
+            await fs.writeFile(filepath, JSON.stringify(cert, null, 2));
+            // Also save individual cert and key files
+            await fs.writeFile(path.join(this.config.storageDir, `${cert.domain}.crt`), cert.certificate);
+            await fs.writeFile(path.join(this.config.storageDir, `${cert.domain}.key`), cert.privateKey);
+            // Set proper permissions on key file
+            await fs.chmod(path.join(this.config.storageDir, `${cert.domain}.key`), 0o600);
+        }
+        catch (error) {
+            throw CertificateErrors.storageError('write', filepath, error);
+        }
+    }
+    /**
+     * Ensure storage directory exists
+     */
+    async ensureStorageDir() {
+        try {
+            await fs.mkdir(this.config.storageDir, { recursive: true });
+        }
+        catch (error) {
+            console.error('Failed to create storage directory:', error);
+        }
+    }
+    /**
+     * Get or create ACME account key
+     */
+    async getOrCreateAccountKey() {
+        const keyPath = path.join(this.config.storageDir, 'account.key');
+        try {
+            return await fs.readFile(keyPath, 'utf-8');
+        }
+        catch {
+            // Generate new key - placeholder
+            const dummyKey = '-----BEGIN PRIVATE KEY-----\nDUMMY_KEY_FOR_TESTING\n-----END PRIVATE KEY-----';
+            await fs.writeFile(keyPath, dummyKey);
+            await fs.chmod(keyPath, 0o600);
+            return dummyKey;
+        }
+    }
+    /**
+     * Generate keypair for certificate
+     */
+    async generateKeypair() {
+        // Keypair generation placeholder
+        return {
+            privateKey: '-----BEGIN PRIVATE KEY-----\nDUMMY_PRIVATE_KEY\n-----END PRIVATE KEY-----',
+            publicKey: '-----BEGIN PUBLIC KEY-----\nDUMMY_PUBLIC_KEY\n-----END PUBLIC KEY-----'
+        };
+    }
+    /**
+     * Generate CSR for domain
+     */
+    async generateCsr(domain, keypair) {
+        // CSR generation placeholder
+        return `-----BEGIN CERTIFICATE REQUEST-----\nDUMMY_CSR_FOR_${domain}\n-----END CERTIFICATE REQUEST-----`;
+    }
+    /**
+     * Extract expiry date from certificate
+     */
+    extractExpiryDate(certPem) {
+        // Certificate expiry extraction placeholder
+        // In a real implementation, this would parse the certificate
+        return new Date(Date.now() + 90 * 24 * 60 * 60 * 1000); // 90 days from now
+    }
+    /**
+     * Check if certificate is valid
+     */
+    isCertificateValid(cert) {
+        return cert.expiresAt > new Date();
+    }
+    /**
+     * Check if certificate should be renewed
+     */
+    shouldRenew(cert) {
+        const daysRemaining = this.getDaysRemaining(cert);
+        return daysRemaining <= this.config.renewBeforeDays;
+    }
+    /**
+     * Check if certificate is expiring soon
+     */
+    isExpiringSoon(cert) {
+        const daysRemaining = this.getDaysRemaining(cert);
+        return daysRemaining <= this.config.renewBeforeDays + 7; // Warn 7 days before renewal
+    }
+    /**
+     * Get days remaining until expiry
+     */
+    getDaysRemaining(cert) {
+        const now = new Date();
+        const diff = cert.expiresAt.getTime() - now.getTime();
+        return Math.floor(diff / (1000 * 60 * 60 * 24));
+    }
+    /**
+     * Start renewal timer
+     */
+    startRenewalTimer() {
+        // Check every 6 hours
+        this.renewalTimer = setInterval(() => {
+            this.checkForRenewals().catch(error => {
+                console.error('Renewal check failed:', error);
+            });
+        }, 6 * 60 * 60 * 1000);
+        // Also check immediately
+        this.checkForRenewals().catch(error => {
+            console.error('Initial renewal check failed:', error);
+        });
+    }
+    /**
+     * Get default certificate for SNI fallback
+     */
+    async getDefaultCertificate() {
+        try {
+            const [cert, key] = await Promise.all([
+                fs.readFile(this.config.defaultCertPath, 'utf-8'),
+                fs.readFile(this.config.defaultKeyPath, 'utf-8')
+            ]);
+            return { cert, key };
+        }
+        catch (error) {
+            throw new CertificateError({
+                code: 'DEFAULT_CERT_ERROR',
+                message: 'Failed to load default certificate',
+                solution: 'Ensure default certificate files exist at configured paths',
+                cause: error
+            });
+        }
+    }
+    /**
+     * Set up HTTP challenge responder
+     */
+    async setupHttpChallenge(token, keyAuthorization) {
+        // This would integrate with Port80Handler
+        // For now, it's a placeholder
+        console.log(`HTTP Challenge: /.well-known/acme-challenge/${token} = ${keyAuthorization}`);
+    }
+    /**
+     * Clean up HTTP challenge
+     */
+    async cleanupHttpChallenge(token) {
+        // This would integrate with Port80Handler
+        // For now, it's a placeholder
+        console.log(`Cleanup HTTP Challenge: ${token}`);
+    }
+    /**
+     * Type assertion for event emitter
+     */
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    off(event, listener) {
+        return super.off(event, listener);
+    }
+    emit(event, data) {
+        return super.emit(event, data);
+    }
+    /**
+     * Update routes (placeholder for future implementation)
+     */
+    async updateRoutes(routes) {
+        // Process routes to extract certificate requirements
+        for (const route of routes) {
+            if (route.action.type === 'forward' &&
+                route.action.tls?.mode === 'terminate' &&
+                route.action.tls?.certificate === 'auto' &&
+                route.match.domains) {
+                const domains = Array.isArray(route.match.domains)
+                    ? route.match.domains
+                    : [route.match.domains];
+                for (const domain of domains) {
+                    // Trigger certificate retrieval for auto domains
+                    this.getCertificate(domain).catch(err => {
+                        console.error(`Failed to get certificate for ${domain}:`, err);
+                    });
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simplified-certificate-manager.js","sourceRoot":"","sources":["../../ts/certificate/simplified-certificate-manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/http/index.d.ts

@@ -2,14 +2,6 @@
  * HTTP functionality module
  */
 export * from './models/http-types.js';
-export * from './port80/index.js';
 export * from './router/index.js';
 export * from './redirects/index.js';
-import { Port80Handler } from './port80/port80-handler.js';
-import { ChallengeResponder } from './port80/challenge-responder.js';
-export declare const Http: {
-    Port80: {
-        Handler: typeof Port80Handler;
-        ChallengeResponder: typeof ChallengeResponder;
-    };
-};
+export declare const Http: {};

package/dist_ts/http/index.js

@@ -3,18 +3,12 @@
  */
 // Export types and models
 export * from './models/http-types.js';
-// Export submodules
-export * from './port80/index.js';
+// Export submodules (remove port80 export)
 export * from './router/index.js';
 export * from './redirects/index.js';
-// Import the components we need for the namespace
-import { Port80Handler } from './port80/port80-handler.js';
-import { ChallengeResponder } from './port80/challenge-responder.js';
-// Convenience namespace exports
+// REMOVED: export * from './port80/index.js';
+// Convenience namespace exports (no more Port80)
 export const Http = {
-    Port80: {
-        Handler: Port80Handler,
-        ChallengeResponder: ChallengeResponder
-    }
+// Only router and redirect functionality remain
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9odHRwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsMEJBQTBCO0FBQzFCLGNBQWMsd0JBQXdCLENBQUM7QUFFdkMsb0JBQW9CO0FBQ3BCLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLHNCQUFzQixDQUFDO0FBRXJDLGtEQUFrRDtBQUNsRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDM0QsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0saUNBQWlDLENBQUM7QUFFckUsZ0NBQWdDO0FBQ2hDLE1BQU0sQ0FBQyxNQUFNLElBQUksR0FBRztJQUNsQixNQUFNLEVBQUU7UUFDTixPQUFPLEVBQUUsYUFBYTtRQUN0QixrQkFBa0IsRUFBRSxrQkFBa0I7S0FDdkM7Q0FDRixDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy9odHRwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsMEJBQTBCO0FBQzFCLGNBQWMsd0JBQXdCLENBQUM7QUFFdkMsMkNBQTJDO0FBQzNDLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyw4Q0FBOEM7QUFFOUMsaURBQWlEO0FBQ2pELE1BQU0sQ0FBQyxNQUFNLElBQUksR0FBRztBQUNsQixnREFBZ0Q7Q0FDakQsQ0FBQyJ9

package/dist_ts/plugins.d.ts

@@ -14,11 +14,13 @@ import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrequest from '@push.rocks/smartrequest';
 import * as smartstring from '@push.rocks/smartstring';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartcrypto from '@push.rocks/smartcrypto';
 import * as smartacme from '@push.rocks/smartacme';
 import * as smartacmePlugins from '@push.rocks/smartacme/dist_ts/smartacme.plugins.js';
 import * as smartacmeHandlers from '@push.rocks/smartacme/dist_ts/handlers/index.js';
 import * as taskbuffer from '@push.rocks/taskbuffer';
-export { lik, smartdelay, smartrequest, smartpromise, smartstring, smartacme, smartacmePlugins, smartacmeHandlers, taskbuffer, };
+export { lik, smartdelay, smartrequest, smartpromise, smartstring, smartfile, smartcrypto, smartacme, smartacmePlugins, smartacmeHandlers, taskbuffer, };
 import prettyMs from 'pretty-ms';
 import * as ws from 'ws';
 import wsDefault from 'ws';

package/dist_ts/plugins.js

@@ -17,15 +17,17 @@ import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartpromise from '@push.rocks/smartpromise';
 import * as smartrequest from '@push.rocks/smartrequest';
 import * as smartstring from '@push.rocks/smartstring';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartcrypto from '@push.rocks/smartcrypto';
 import * as smartacme from '@push.rocks/smartacme';
 import * as smartacmePlugins from '@push.rocks/smartacme/dist_ts/smartacme.plugins.js';
 import * as smartacmeHandlers from '@push.rocks/smartacme/dist_ts/handlers/index.js';
 import * as taskbuffer from '@push.rocks/taskbuffer';
-export { lik, smartdelay, smartrequest, smartpromise, smartstring, smartacme, smartacmePlugins, smartacmeHandlers, taskbuffer, };
+export { lik, smartdelay, smartrequest, smartpromise, smartstring, smartfile, smartcrypto, smartacme, smartacmePlugins, smartacmeHandlers, taskbuffer, };
 // third party scope
 import prettyMs from 'pretty-ms';
 import * as ws from 'ws';
 import wsDefault from 'ws';
 import { minimatch } from 'minimatch';
 export { prettyMs, ws, wsDefault, minimatch };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFDdEMsT0FBTyxLQUFLLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFDekIsT0FBTyxLQUFLLElBQUksTUFBTSxNQUFNLENBQUM7QUFDN0IsT0FBTyxLQUFLLEtBQUssTUFBTSxPQUFPLENBQUM7QUFDL0IsT0FBTyxLQUFLLEdBQUcsTUFBTSxLQUFLLENBQUM7QUFDM0IsT0FBTyxLQUFLLEdBQUcsTUFBTSxLQUFLLENBQUM7QUFDM0IsT0FBTyxLQUFLLEdBQUcsTUFBTSxLQUFLLENBQUM7QUFDM0IsT0FBTyxLQUFLLEtBQUssTUFBTSxPQUFPLENBQUM7QUFFL0IsT0FBTyxFQUFFLFlBQVksRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxLQUFLLEVBQUUsQ0FBQztBQUUvRCxnQkFBZ0I7QUFDaEIsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUU1QyxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFFbkIsa0JBQWtCO0FBQ2xCLE9BQU8sS0FBSyxHQUFHLE1BQU0saUJBQWlCLENBQUM7QUFDdkMsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUV2RCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxnQkFBZ0IsTUFBTSxvREFBb0QsQ0FBQztBQUN2RixPQUFPLEtBQUssaUJBQWlCLE1BQU0saURBQWlELENBQUM7QUFDckYsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUVyRCxPQUFPLEVBQ0wsR0FBRyxFQUNILFVBQVUsRUFDVixZQUFZLEVBQ1osWUFBWSxFQUNaLFdBQVcsRUFDWCxTQUFTLEVBQ1QsZ0JBQWdCLEVBQ2hCLGlCQUFpQixFQUNqQixVQUFVLEdBQ1gsQ0FBQztBQUVGLG9CQUFvQjtBQUNwQixPQUFPLFFBQVEsTUFBTSxXQUFXLENBQUM7QUFDakMsT0FBTyxLQUFLLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFDekIsT0FBTyxTQUFTLE1BQU0sSUFBSSxDQUFDO0FBQzNCLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFFdEMsT0FBTyxFQUFFLFFBQVEsRUFBRSxFQUFFLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxDQUFDIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFDdEMsT0FBTyxLQUFLLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFDekIsT0FBTyxLQUFLLElBQUksTUFBTSxNQUFNLENBQUM7QUFDN0IsT0FBTyxLQUFLLEtBQUssTUFBTSxPQUFPLENBQUM7QUFDL0IsT0FBTyxLQUFLLEdBQUcsTUFBTSxLQUFLLENBQUM7QUFDM0IsT0FBTyxLQUFLLEdBQUcsTUFBTSxLQUFLLENBQUM7QUFDM0IsT0FBTyxLQUFLLEdBQUcsTUFBTSxLQUFLLENBQUM7QUFDM0IsT0FBTyxLQUFLLEtBQUssTUFBTSxPQUFPLENBQUM7QUFFL0IsT0FBTyxFQUFFLFlBQVksRUFBRSxFQUFFLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxLQUFLLEVBQUUsQ0FBQztBQUUvRCxnQkFBZ0I7QUFDaEIsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUU1QyxPQUFPLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFFbkIsa0JBQWtCO0FBQ2xCLE9BQU8sS0FBSyxHQUFHLE1BQU0saUJBQWlCLENBQUM7QUFDdkMsT0FBTyxLQUFLLFVBQVUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssZ0JBQWdCLE1BQU0sb0RBQW9ELENBQUM7QUFDdkYsT0FBTyxLQUFLLGlCQUFpQixNQUFNLGlEQUFpRCxDQUFDO0FBQ3JGLE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFFckQsT0FBTyxFQUNMLEdBQUcsRUFDSCxVQUFVLEVBQ1YsWUFBWSxFQUNaLFlBQVksRUFDWixXQUFXLEVBQ1gsU0FBUyxFQUNULFdBQVcsRUFDWCxTQUFTLEVBQ1QsZ0JBQWdCLEVBQ2hCLGlCQUFpQixFQUNqQixVQUFVLEdBQ1gsQ0FBQztBQUVGLG9CQUFvQjtBQUNwQixPQUFPLFFBQVEsTUFBTSxXQUFXLENBQUM7QUFDakMsT0FBTyxLQUFLLEVBQUUsTUFBTSxJQUFJLENBQUM7QUFDekIsT0FBTyxTQUFTLE1BQU0sSUFBSSxDQUFDO0FBQzNCLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFFdEMsT0FBTyxFQUFFLFFBQVEsRUFBRSxFQUFFLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxDQUFDIn0=