@serve.zone/dcrouter 11.0.44 → 11.0.46

package/dist_ts/radius/classes.radius.server.d.ts

@@ -0,0 +1,171 @@
+import type { StorageManager } from '../storage/index.js';
+import { VlanManager, type IMacVlanMapping, type IVlanManagerConfig } from './classes.vlan.manager.js';
+import { AccountingManager, type IAccountingManagerConfig } from './classes.accounting.manager.js';
+/**
+ * RADIUS client (NAS) configuration
+ */
+export interface IRadiusClient {
+    /** Client name for identification */
+    name: string;
+    /** IP address or CIDR range */
+    ipRange: string;
+    /** Shared secret for this client */
+    secret: string;
+    /** Optional description */
+    description?: string;
+    /** Whether this client is enabled */
+    enabled: boolean;
+}
+/**
+ * RADIUS server configuration
+ */
+export interface IRadiusServerConfig {
+    /** Authentication port (default: 1812) */
+    authPort?: number;
+    /** Accounting port (default: 1813) */
+    acctPort?: number;
+    /** Bind address (default: 0.0.0.0) */
+    bindAddress?: string;
+    /** NAS clients configuration */
+    clients: IRadiusClient[];
+    /** VLAN assignment configuration */
+    vlanAssignment?: IVlanManagerConfig & {
+        /** Static MAC to VLAN mappings */
+        mappings?: Array<Omit<IMacVlanMapping, 'createdAt' | 'updatedAt'>>;
+    };
+    /** Accounting configuration */
+    accounting?: IAccountingManagerConfig & {
+        /** Whether accounting is enabled */
+        enabled: boolean;
+    };
+}
+/**
+ * RADIUS authentication result
+ */
+export interface IRadiusAuthResult {
+    /** Whether authentication was successful */
+    success: boolean;
+    /** Reject reason (if not successful) */
+    rejectReason?: string;
+    /** Reply message to send to client */
+    replyMessage?: string;
+    /** Session timeout in seconds */
+    sessionTimeout?: number;
+    /** Idle timeout in seconds */
+    idleTimeout?: number;
+    /** VLAN to assign */
+    vlanId?: number;
+    /** Framed IP address to assign */
+    framedIpAddress?: string;
+}
+/**
+ * Authentication request data from RADIUS
+ */
+export interface IAuthRequestData {
+    username: string;
+    password?: string;
+    nasIpAddress: string;
+    nasPort?: number;
+    nasPortType?: string;
+    nasIdentifier?: string;
+    calledStationId?: string;
+    callingStationId?: string;
+    serviceType?: string;
+    framedMtu?: number;
+}
+/**
+ * RADIUS Server wrapper that provides:
+ * - MAC Authentication Bypass (MAB) for network devices
+ * - VLAN assignment based on MAC address
+ * - Accounting for session tracking and billing
+ * - Integration with SmartProxy routing
+ */
+export declare class RadiusServer {
+    private radiusServer?;
+    private vlanManager;
+    private accountingManager;
+    private config;
+    private storageManager?;
+    private clientSecrets;
+    private running;
+    private stats;
+    constructor(config: IRadiusServerConfig, storageManager?: StorageManager);
+    /**
+     * Start the RADIUS server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the RADIUS server
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle authentication request
+     */
+    private handleAuthentication;
+    /**
+     * Handle accounting request
+     */
+    private handleAccounting;
+    /**
+     * Perform MAC Authentication Bypass
+     */
+    private performMabAuthentication;
+    /**
+     * Extract MAC address from authentication data
+     */
+    private extractMacAddress;
+    /**
+     * Check if a string looks like a MAC address
+     */
+    private looksLikeMac;
+    /**
+     * Normalize MAC address format
+     */
+    private normalizeMac;
+    /**
+     * Build client secrets map from configuration
+     */
+    private buildClientSecretsMap;
+    /**
+     * Get default secret for unknown clients
+     */
+    private getDefaultSecret;
+    /**
+     * Add a RADIUS client
+     */
+    addClient(client: IRadiusClient): Promise<void>;
+    /**
+     * Remove a RADIUS client
+     */
+    removeClient(name: string): boolean;
+    /**
+     * Get configured clients
+     */
+    getClients(): IRadiusClient[];
+    /**
+     * Get VLAN manager for direct access to VLAN operations
+     */
+    getVlanManager(): VlanManager;
+    /**
+     * Get accounting manager for direct access to accounting operations
+     */
+    getAccountingManager(): AccountingManager;
+    /**
+     * Get server statistics
+     */
+    getStats(): {
+        running: boolean;
+        uptime: number;
+        authRequests: number;
+        authAccepts: number;
+        authRejects: number;
+        accountingRequests: number;
+        activeSessions: number;
+        vlanMappings: number;
+        clients: number;
+    };
+    /**
+     * Check if server is running
+     */
+    isRunning(): boolean;
+}

package/dist_ts/radius/classes.radius.server.js

@@ -0,0 +1,385 @@
+import * as plugins from '../plugins.js';
+import { logger } from '../logger.js';
+import { VlanManager } from './classes.vlan.manager.js';
+import { AccountingManager } from './classes.accounting.manager.js';
+/**
+ * RADIUS Server wrapper that provides:
+ * - MAC Authentication Bypass (MAB) for network devices
+ * - VLAN assignment based on MAC address
+ * - Accounting for session tracking and billing
+ * - Integration with SmartProxy routing
+ */
+export class RadiusServer {
+    radiusServer;
+    vlanManager;
+    accountingManager;
+    config;
+    storageManager;
+    clientSecrets = new Map();
+    running = false;
+    // Statistics
+    stats = {
+        authRequests: 0,
+        authAccepts: 0,
+        authRejects: 0,
+        accountingRequests: 0,
+        startTime: 0,
+    };
+    constructor(config, storageManager) {
+        this.config = {
+            authPort: config.authPort ?? 1812,
+            acctPort: config.acctPort ?? 1813,
+            bindAddress: config.bindAddress ?? '0.0.0.0',
+            ...config,
+        };
+        this.storageManager = storageManager;
+        // Initialize VLAN manager
+        this.vlanManager = new VlanManager(config.vlanAssignment, storageManager);
+        // Initialize accounting manager
+        this.accountingManager = new AccountingManager(config.accounting, storageManager);
+    }
+    /**
+     * Start the RADIUS server
+     */
+    async start() {
+        if (this.running) {
+            logger.log('warn', 'RADIUS server is already running');
+            return;
+        }
+        logger.log('info', `Starting RADIUS server on ${this.config.bindAddress}:${this.config.authPort} (auth) and ${this.config.acctPort} (acct)`);
+        // Initialize managers
+        await this.vlanManager.initialize();
+        await this.accountingManager.initialize();
+        // Import static VLAN mappings if provided
+        if (this.config.vlanAssignment?.mappings) {
+            await this.vlanManager.importMappings(this.config.vlanAssignment.mappings);
+        }
+        // Build client secrets map
+        this.buildClientSecretsMap();
+        // Create the RADIUS server
+        this.radiusServer = new plugins.smartradius.RadiusServer({
+            authPort: this.config.authPort,
+            acctPort: this.config.acctPort,
+            bindAddress: this.config.bindAddress,
+            defaultSecret: this.getDefaultSecret(),
+            authenticationHandler: this.handleAuthentication.bind(this),
+            accountingHandler: this.handleAccounting.bind(this),
+        });
+        // Configure per-client secrets
+        for (const [ip, secret] of this.clientSecrets) {
+            this.radiusServer.setClientSecret(ip, secret);
+        }
+        // Start the server
+        await this.radiusServer.start();
+        this.running = true;
+        this.stats.startTime = Date.now();
+        logger.log('info', `RADIUS server started with ${this.config.clients.length} configured clients`);
+    }
+    /**
+     * Stop the RADIUS server
+     */
+    async stop() {
+        if (!this.running) {
+            return;
+        }
+        logger.log('info', 'Stopping RADIUS server...');
+        if (this.radiusServer) {
+            await this.radiusServer.stop();
+            this.radiusServer = undefined;
+        }
+        this.running = false;
+        logger.log('info', 'RADIUS server stopped');
+    }
+    /**
+     * Handle authentication request
+     */
+    async handleAuthentication(request) {
+        this.stats.authRequests++;
+        const authData = {
+            username: request.attributes?.UserName || '',
+            password: request.attributes?.UserPassword,
+            nasIpAddress: request.attributes?.NasIpAddress || request.source?.address || '',
+            nasPort: request.attributes?.NasPort,
+            nasPortType: request.attributes?.NasPortType,
+            nasIdentifier: request.attributes?.NasIdentifier,
+            calledStationId: request.attributes?.CalledStationId,
+            callingStationId: request.attributes?.CallingStationId,
+            serviceType: request.attributes?.ServiceType,
+        };
+        logger.log('debug', `RADIUS Auth Request: user=${authData.username}, NAS=${authData.nasIpAddress}`);
+        // Perform MAC Authentication Bypass (MAB)
+        // In MAB, the username is typically the MAC address
+        const result = await this.performMabAuthentication(authData);
+        if (result.success) {
+            this.stats.authAccepts++;
+            logger.log('info', `RADIUS Auth Accept: user=${authData.username}, VLAN=${result.vlanId}`);
+            // Build response with VLAN attributes
+            const response = {
+                code: plugins.smartradius.ERadiusCode.AccessAccept,
+                replyMessage: result.replyMessage,
+            };
+            // Add VLAN attributes if assigned
+            if (result.vlanId !== undefined) {
+                response.tunnelType = 13; // VLAN
+                response.tunnelMediumType = 6; // IEEE 802
+                response.tunnelPrivateGroupId = String(result.vlanId);
+            }
+            // Add session timeout if specified
+            if (result.sessionTimeout) {
+                response.sessionTimeout = result.sessionTimeout;
+            }
+            // Add idle timeout if specified
+            if (result.idleTimeout) {
+                response.idleTimeout = result.idleTimeout;
+            }
+            // Add framed IP if specified
+            if (result.framedIpAddress) {
+                response.framedIpAddress = result.framedIpAddress;
+            }
+            return response;
+        }
+        else {
+            this.stats.authRejects++;
+            logger.log('warn', `RADIUS Auth Reject: user=${authData.username}, reason=${result.rejectReason}`);
+            return {
+                code: plugins.smartradius.ERadiusCode.AccessReject,
+                replyMessage: result.rejectReason || 'Access Denied',
+            };
+        }
+    }
+    /**
+     * Handle accounting request
+     */
+    async handleAccounting(request) {
+        this.stats.accountingRequests++;
+        if (!this.config.accounting?.enabled) {
+            // Still respond even if not tracking
+            return { code: plugins.smartradius.ERadiusCode.AccountingResponse };
+        }
+        const statusType = request.attributes?.AcctStatusType;
+        const sessionId = request.attributes?.AcctSessionId || '';
+        const accountingData = {
+            sessionId,
+            username: request.attributes?.UserName || '',
+            macAddress: request.attributes?.CallingStationId,
+            nasIpAddress: request.attributes?.NasIpAddress || request.source?.address || '',
+            nasPort: request.attributes?.NasPort,
+            nasPortType: request.attributes?.NasPortType,
+            nasIdentifier: request.attributes?.NasIdentifier,
+            calledStationId: request.attributes?.CalledStationId,
+            callingStationId: request.attributes?.CallingStationId,
+            inputOctets: request.attributes?.AcctInputOctets,
+            outputOctets: request.attributes?.AcctOutputOctets,
+            inputPackets: request.attributes?.AcctInputPackets,
+            outputPackets: request.attributes?.AcctOutputPackets,
+            sessionTime: request.attributes?.AcctSessionTime,
+            terminateCause: request.attributes?.AcctTerminateCause,
+            serviceType: request.attributes?.ServiceType,
+        };
+        try {
+            switch (statusType) {
+                case plugins.smartradius.EAcctStatusType.Start:
+                    logger.log('debug', `RADIUS Acct Start: session=${sessionId}, user=${accountingData.username}`);
+                    await this.accountingManager.handleAccountingStart(accountingData);
+                    break;
+                case plugins.smartradius.EAcctStatusType.Stop:
+                    logger.log('debug', `RADIUS Acct Stop: session=${sessionId}`);
+                    await this.accountingManager.handleAccountingStop(accountingData);
+                    break;
+                case plugins.smartradius.EAcctStatusType.InterimUpdate:
+                    logger.log('debug', `RADIUS Acct Interim: session=${sessionId}`);
+                    await this.accountingManager.handleAccountingUpdate(accountingData);
+                    break;
+                default:
+                    logger.log('debug', `RADIUS Acct Unknown status type: ${statusType}`);
+            }
+        }
+        catch (error) {
+            logger.log('error', `RADIUS accounting error: ${error.message}`);
+        }
+        return { code: plugins.smartradius.ERadiusCode.AccountingResponse };
+    }
+    /**
+     * Perform MAC Authentication Bypass
+     */
+    async performMabAuthentication(data) {
+        // Extract MAC address from username or CallingStationId
+        const macAddress = this.extractMacAddress(data);
+        if (!macAddress) {
+            return {
+                success: false,
+                rejectReason: 'No MAC address found',
+            };
+        }
+        // Look up VLAN assignment
+        const vlanResult = this.vlanManager.assignVlan(macAddress);
+        if (!vlanResult.assigned) {
+            return {
+                success: false,
+                rejectReason: 'Unknown MAC address',
+            };
+        }
+        // Build successful result
+        const result = {
+            success: true,
+            vlanId: vlanResult.vlan,
+            replyMessage: vlanResult.isDefault
+                ? `Assigned to default VLAN ${vlanResult.vlan}`
+                : `Assigned to VLAN ${vlanResult.vlan}`,
+        };
+        // Apply any additional settings from the matched rule
+        if (vlanResult.matchedRule) {
+            // Future: Add session timeout, idle timeout, etc. from rule
+        }
+        return result;
+    }
+    /**
+     * Extract MAC address from authentication data
+     */
+    extractMacAddress(data) {
+        // Try CallingStationId first (most common for MAB)
+        if (data.callingStationId) {
+            return this.normalizeMac(data.callingStationId);
+        }
+        // Try username (often MAC address in MAB)
+        if (data.username && this.looksLikeMac(data.username)) {
+            return this.normalizeMac(data.username);
+        }
+        return null;
+    }
+    /**
+     * Check if a string looks like a MAC address
+     */
+    looksLikeMac(value) {
+        // Remove common separators and check length
+        const cleaned = value.replace(/[-:. ]/g, '');
+        return /^[0-9a-fA-F]{12}$/.test(cleaned);
+    }
+    /**
+     * Normalize MAC address format
+     */
+    normalizeMac(mac) {
+        return this.vlanManager.normalizeMac(mac);
+    }
+    /**
+     * Build client secrets map from configuration
+     */
+    buildClientSecretsMap() {
+        this.clientSecrets.clear();
+        for (const client of this.config.clients) {
+            if (!client.enabled) {
+                continue;
+            }
+            // Handle CIDR ranges
+            if (client.ipRange.includes('/')) {
+                // For CIDR ranges, we'll use the network address as key
+                // In practice, smartradius may handle this differently
+                const [network] = client.ipRange.split('/');
+                this.clientSecrets.set(network, client.secret);
+            }
+            else {
+                this.clientSecrets.set(client.ipRange, client.secret);
+            }
+        }
+    }
+    /**
+     * Get default secret for unknown clients
+     */
+    getDefaultSecret() {
+        // Use first enabled client's secret as default, or a random one
+        for (const client of this.config.clients) {
+            if (client.enabled) {
+                return client.secret;
+            }
+        }
+        return plugins.crypto.randomBytes(16).toString('hex');
+    }
+    /**
+     * Add a RADIUS client
+     */
+    async addClient(client) {
+        // Check if client already exists
+        const existingIndex = this.config.clients.findIndex(c => c.name === client.name);
+        if (existingIndex >= 0) {
+            this.config.clients[existingIndex] = client;
+        }
+        else {
+            this.config.clients.push(client);
+        }
+        // Update client secrets if running
+        if (this.running && this.radiusServer && client.enabled) {
+            if (client.ipRange.includes('/')) {
+                const [network] = client.ipRange.split('/');
+                this.radiusServer.setClientSecret(network, client.secret);
+                this.clientSecrets.set(network, client.secret);
+            }
+            else {
+                this.radiusServer.setClientSecret(client.ipRange, client.secret);
+                this.clientSecrets.set(client.ipRange, client.secret);
+            }
+        }
+        logger.log('info', `RADIUS client ${client.enabled ? 'added' : 'disabled'}: ${client.name} (${client.ipRange})`);
+    }
+    /**
+     * Remove a RADIUS client
+     */
+    removeClient(name) {
+        const index = this.config.clients.findIndex(c => c.name === name);
+        if (index >= 0) {
+            const client = this.config.clients[index];
+            this.config.clients.splice(index, 1);
+            // Remove from secrets map
+            if (client.ipRange.includes('/')) {
+                const [network] = client.ipRange.split('/');
+                this.clientSecrets.delete(network);
+            }
+            else {
+                this.clientSecrets.delete(client.ipRange);
+            }
+            logger.log('info', `RADIUS client removed: ${name}`);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get configured clients
+     */
+    getClients() {
+        return [...this.config.clients];
+    }
+    /**
+     * Get VLAN manager for direct access to VLAN operations
+     */
+    getVlanManager() {
+        return this.vlanManager;
+    }
+    /**
+     * Get accounting manager for direct access to accounting operations
+     */
+    getAccountingManager() {
+        return this.accountingManager;
+    }
+    /**
+     * Get server statistics
+     */
+    getStats() {
+        return {
+            running: this.running,
+            uptime: this.running ? Date.now() - this.stats.startTime : 0,
+            authRequests: this.stats.authRequests,
+            authAccepts: this.stats.authAccepts,
+            authRejects: this.stats.authRejects,
+            accountingRequests: this.stats.accountingRequests,
+            activeSessions: this.accountingManager.getStats().activeSessions,
+            vlanMappings: this.vlanManager.getStats().totalMappings,
+            clients: this.config.clients.filter(c => c.enabled).length,
+        };
+    }
+    /**
+     * Check if server is running
+     */
+    isRunning() {
+        return this.running;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.radius.server.js","sourceRoot":"","sources":["../../../ts/radius/classes.radius.server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,WAAW,EAAiD,MAAM,2BAA2B,CAAC;AACvG,OAAO,EAAE,iBAAiB,EAA0D,MAAM,iCAAiC,CAAC;AA8E5H;;;;;;GAMG;AACH,MAAM,OAAO,YAAY;IACf,YAAY,CAAoC;IAChD,WAAW,CAAc;IACzB,iBAAiB,CAAoB;IACrC,MAAM,CAAsB;IAC5B,cAAc,CAAkB;IAChC,aAAa,GAAwB,IAAI,GAAG,EAAE,CAAC;IAC/C,OAAO,GAAY,KAAK,CAAC;IAEjC,aAAa;IACL,KAAK,GAAG;QACd,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,CAAC;QACd,WAAW,EAAE,CAAC;QACd,kBAAkB,EAAE,CAAC;QACrB,SAAS,EAAE,CAAC;KACb,CAAC;IAEF,YAAY,MAA2B,EAAE,cAA+B;QACtE,IAAI,CAAC,MAAM,GAAG;YACZ,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,IAAI;YACjC,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,IAAI;YACjC,WAAW,EAAE,MAAM,CAAC,WAAW,IAAI,SAAS;YAC5C,GAAG,MAAM;SACV,CAAC;QACF,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QAErC,0BAA0B;QAC1B,IAAI,CAAC,WAAW,GAAG,IAAI,WAAW,CAAC,MAAM,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC;QAE1E,gCAAgC;QAChC,IAAI,CAAC,iBAAiB,GAAG,IAAI,iBAAiB,CAAC,MAAM,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;IACpF,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAK;QACT,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,kCAAkC,CAAC,CAAC;YACvD,OAAO;QACT,CAAC;QAED,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,6BAA6B,IAAI,CAAC,MAAM,CAAC,WAAW,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,eAAe,IAAI,CAAC,MAAM,CAAC,QAAQ,SAAS,CAAC,CAAC;QAE7I,sBAAsB;QACtB,MAAM,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,CAAC;QACpC,MAAM,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,CAAC;QAE1C,0CAA0C;QAC1C,IAAI,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,QAAQ,EAAE,CAAC;YACzC,MAAM,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC;QAC7E,CAAC;QAED,2BAA2B;QAC3B,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAE7B,2BAA2B;QAC3B,IAAI,CAAC,YAAY,GAAG,IAAI,OAAO,CAAC,WAAW,CAAC,YAAY,CAAC;YACvD,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;YAC9B,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;YAC9B,WAAW,EAAE,IAAI,CAAC,MAAM,CAAC,WAAW;YACpC,aAAa,EAAE,IAAI,CAAC,gBAAgB,EAAE;YACtC,qBAAqB,EAAE,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC;YAC3D,iBAAiB,EAAE,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC;SACpD,CAAC,CAAC;QAEH,+BAA+B;QAC/B,KAAK,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YAC9C,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;QAChD,CAAC;QAED,mBAAmB;QACnB,MAAM,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;QAEhC,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,IAAI,CAAC,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAElC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,8BAA8B,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,qBAAqB,CAAC,CAAC;IACpG,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,IAAI;QACR,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;YAClB,OAAO;QACT,CAAC;QAED,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,2BAA2B,CAAC,CAAC;QAEhD,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,MAAM,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;YAC/B,IAAI,CAAC,YAAY,GAAG,SAAS,CAAC;QAChC,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QACrB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,oBAAoB,CAAC,OAAY;QAC7C,IAAI,CAAC,KAAK,CAAC,YAAY,EAAE,CAAC;QAE1B,MAAM,QAAQ,GAAqB;YACjC,QAAQ,EAAE,OAAO,CAAC,UAAU,EAAE,QAAQ,IAAI,EAAE;YAC5C,QAAQ,EAAE,OAAO,CAAC,UAAU,EAAE,YAAY;YAC1C,YAAY,EAAE,OAAO,CAAC,UAAU,EAAE,YAAY,IAAI,OAAO,CAAC,MAAM,EAAE,OAAO,IAAI,EAAE;YAC/E,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,OAAO;YACpC,WAAW,EAAE,OAAO,CAAC,UAAU,EAAE,WAAW;YAC5C,aAAa,EAAE,OAAO,CAAC,UAAU,EAAE,aAAa;YAChD,eAAe,EAAE,OAAO,CAAC,UAAU,EAAE,eAAe;YACpD,gBAAgB,EAAE,OAAO,CAAC,UAAU,EAAE,gBAAgB;YACtD,WAAW,EAAE,OAAO,CAAC,UAAU,EAAE,WAAW;SAC7C,CAAC;QAEF,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,6BAA6B,QAAQ,CAAC,QAAQ,SAAS,QAAQ,CAAC,YAAY,EAAE,CAAC,CAAC;QAEpG,0CAA0C;QAC1C,oDAAoD;QACpD,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,wBAAwB,CAAC,QAAQ,CAAC,CAAC;QAE7D,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YACnB,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;YACzB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,4BAA4B,QAAQ,CAAC,QAAQ,UAAU,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;YAE3F,sCAAsC;YACtC,MAAM,QAAQ,GAAQ;gBACpB,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,YAAY;gBAClD,YAAY,EAAE,MAAM,CAAC,YAAY;aAClC,CAAC;YAEF,kCAAkC;YAClC,IAAI,MAAM,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;gBAChC,QAAQ,CAAC,UAAU,GAAG,EAAE,CAAC,CAAC,OAAO;gBACjC,QAAQ,CAAC,gBAAgB,GAAG,CAAC,CAAC,CAAC,WAAW;gBAC1C,QAAQ,CAAC,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YACxD,CAAC;YAED,mCAAmC;YACnC,IAAI,MAAM,CAAC,cAAc,EAAE,CAAC;gBAC1B,QAAQ,CAAC,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC;YAClD,CAAC;YAED,gCAAgC;YAChC,IAAI,MAAM,CAAC,WAAW,EAAE,CAAC;gBACvB,QAAQ,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;YAC5C,CAAC;YAED,6BAA6B;YAC7B,IAAI,MAAM,CAAC,eAAe,EAAE,CAAC;gBAC3B,QAAQ,CAAC,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;YACpD,CAAC;YAED,OAAO,QAAQ,CAAC;QAClB,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;YACzB,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,4BAA4B,QAAQ,CAAC,QAAQ,YAAY,MAAM,CAAC,YAAY,EAAE,CAAC,CAAC;YAEnG,OAAO;gBACL,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,YAAY;gBAClD,YAAY,EAAE,MAAM,CAAC,YAAY,IAAI,eAAe;aACrD,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,gBAAgB,CAAC,OAAY;QACzC,IAAI,CAAC,KAAK,CAAC,kBAAkB,EAAE,CAAC;QAEhC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,CAAC;YACrC,qCAAqC;YACrC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,kBAAkB,EAAE,CAAC;QACtE,CAAC;QAED,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,EAAE,cAAc,CAAC;QACtD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,EAAE,aAAa,IAAI,EAAE,CAAC;QAE1D,MAAM,cAAc,GAAG;YACrB,SAAS;YACT,QAAQ,EAAE,OAAO,CAAC,UAAU,EAAE,QAAQ,IAAI,EAAE;YAC5C,UAAU,EAAE,OAAO,CAAC,UAAU,EAAE,gBAAgB;YAChD,YAAY,EAAE,OAAO,CAAC,UAAU,EAAE,YAAY,IAAI,OAAO,CAAC,MAAM,EAAE,OAAO,IAAI,EAAE;YAC/E,OAAO,EAAE,OAAO,CAAC,UAAU,EAAE,OAAO;YACpC,WAAW,EAAE,OAAO,CAAC,UAAU,EAAE,WAAW;YAC5C,aAAa,EAAE,OAAO,CAAC,UAAU,EAAE,aAAa;YAChD,eAAe,EAAE,OAAO,CAAC,UAAU,EAAE,eAAe;YACpD,gBAAgB,EAAE,OAAO,CAAC,UAAU,EAAE,gBAAgB;YACtD,WAAW,EAAE,OAAO,CAAC,UAAU,EAAE,eAAe;YAChD,YAAY,EAAE,OAAO,CAAC,UAAU,EAAE,gBAAgB;YAClD,YAAY,EAAE,OAAO,CAAC,UAAU,EAAE,gBAAgB;YAClD,aAAa,EAAE,OAAO,CAAC,UAAU,EAAE,iBAAiB;YACpD,WAAW,EAAE,OAAO,CAAC,UAAU,EAAE,eAAe;YAChD,cAAc,EAAE,OAAO,CAAC,UAAU,EAAE,kBAAkB;YACtD,WAAW,EAAE,OAAO,CAAC,UAAU,EAAE,WAAW;SAC7C,CAAC;QAEF,IAAI,CAAC;YACH,QAAQ,UAAU,EAAE,CAAC;gBACnB,KAAK,OAAO,CAAC,WAAW,CAAC,eAAe,CAAC,KAAK;oBAC5C,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,8BAA8B,SAAS,UAAU,cAAc,CAAC,QAAQ,EAAE,CAAC,CAAC;oBAChG,MAAM,IAAI,CAAC,iBAAiB,CAAC,qBAAqB,CAAC,cAAc,CAAC,CAAC;oBACnE,MAAM;gBAER,KAAK,OAAO,CAAC,WAAW,CAAC,eAAe,CAAC,IAAI;oBAC3C,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,6BAA6B,SAAS,EAAE,CAAC,CAAC;oBAC9D,MAAM,IAAI,CAAC,iBAAiB,CAAC,oBAAoB,CAAC,cAAc,CAAC,CAAC;oBAClE,MAAM;gBAER,KAAK,OAAO,CAAC,WAAW,CAAC,eAAe,CAAC,aAAa;oBACpD,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,gCAAgC,SAAS,EAAE,CAAC,CAAC;oBACjE,MAAM,IAAI,CAAC,iBAAiB,CAAC,sBAAsB,CAAC,cAAc,CAAC,CAAC;oBACpE,MAAM;gBAER;oBACE,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,oCAAoC,UAAU,EAAE,CAAC,CAAC;YAC1E,CAAC;QACH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE,4BAA4B,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QACnE,CAAC;QAED,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,kBAAkB,EAAE,CAAC;IACtE,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,wBAAwB,CAAC,IAAsB;QAC3D,wDAAwD;QACxD,MAAM,UAAU,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAEhD,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,YAAY,EAAE,sBAAsB;aACrC,CAAC;QACJ,CAAC;QAED,0BAA0B;QAC1B,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;QAE3D,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;YACzB,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,YAAY,EAAE,qBAAqB;aACpC,CAAC;QACJ,CAAC;QAED,0BAA0B;QAC1B,MAAM,MAAM,GAAsB;YAChC,OAAO,EAAE,IAAI;YACb,MAAM,EAAE,UAAU,CAAC,IAAI;YACvB,YAAY,EAAE,UAAU,CAAC,SAAS;gBAChC,CAAC,CAAC,4BAA4B,UAAU,CAAC,IAAI,EAAE;gBAC/C,CAAC,CAAC,oBAAoB,UAAU,CAAC,IAAI,EAAE;SAC1C,CAAC;QAEF,sDAAsD;QACtD,IAAI,UAAU,CAAC,WAAW,EAAE,CAAC;YAC3B,4DAA4D;QAC9D,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACK,iBAAiB,CAAC,IAAsB;QAC9C,mDAAmD;QACnD,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAClD,CAAC;QAED,0CAA0C;QAC1C,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YACtD,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC1C,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACK,YAAY,CAAC,KAAa;QAChC,4CAA4C;QAC5C,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;QAC7C,OAAO,mBAAmB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACK,YAAY,CAAC,GAAW;QAC9B,OAAO,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;IAC5C,CAAC;IAED;;OAEG;IACK,qBAAqB;QAC3B,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAE3B,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACzC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBACpB,SAAS;YACX,CAAC;YAED,qBAAqB;YACrB,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBACjC,wDAAwD;gBACxD,uDAAuD;gBACvD,MAAM,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC5C,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;YACjD,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;YACxD,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACK,gBAAgB;QACtB,gEAAgE;QAChE,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACzC,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;gBACnB,OAAO,MAAM,CAAC,MAAM,CAAC;YACvB,CAAC;QACH,CAAC;QACD,OAAO,OAAO,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACxD,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS,CAAC,MAAqB;QACnC,iCAAiC;QACjC,MAAM,aAAa,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC;QACjF,IAAI,aAAa,IAAI,CAAC,EAAE,CAAC;YACvB,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,GAAG,MAAM,CAAC;QAC9C,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACnC,CAAC;QAED,mCAAmC;QACnC,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,YAAY,IAAI,MAAM,CAAC,OAAO,EAAE,CAAC;YACxD,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBACjC,MAAM,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC5C,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;gBAC1D,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;YACjD,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,YAAY,CAAC,eAAe,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;gBACjE,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC;YACxD,CAAC;QACH,CAAC;QAED,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,iBAAiB,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,KAAK,MAAM,CAAC,IAAI,KAAK,MAAM,CAAC,OAAO,GAAG,CAAC,CAAC;IACnH,CAAC;IAED;;OAEG;IACH,YAAY,CAAC,IAAY;QACvB,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QAClE,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;YACf,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC1C,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;YAErC,0BAA0B;YAC1B,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBACjC,MAAM,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC5C,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACrC,CAAC;iBAAM,CAAC;gBACN,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAC5C,CAAC;YAED,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,0BAA0B,IAAI,EAAE,CAAC,CAAC;YACrD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;OAEG;IACH,UAAU;QACR,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAClC,CAAC;IAED;;OAEG;IACH,cAAc;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED;;OAEG;IACH,oBAAoB;QAClB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,QAAQ;QAWN,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YAC5D,YAAY,EAAE,IAAI,CAAC,KAAK,CAAC,YAAY;YACrC,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,WAAW;YACnC,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,WAAW;YACnC,kBAAkB,EAAE,IAAI,CAAC,KAAK,CAAC,kBAAkB;YACjD,cAAc,EAAE,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,CAAC,cAAc;YAChE,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,CAAC,aAAa;YACvD,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,MAAM;SAC3D,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CACF"}