@principal-ai/control-tower-core 0.1.0 → 0.1.2

package/dist/adapters/mock/MockAuthAdapter.js

@@ -0,0 +1,161 @@
+export class MockAuthAdapter {
+    constructor(options) {
+        this.tokens = new Map();
+        this.revokedTokens = new Set();
+        this.users = new Map();
+        this.simulateLatency = 0;
+        this.shouldFailAuth = false;
+        this.tokenCounter = 0;
+        this.simulateLatency = options?.simulateLatency ?? 0;
+        this.shouldFailAuth = options?.shouldFailAuth ?? false;
+        // Add some default test users
+        this.addUser('testuser', 'password123', {
+            userId: 'user-1',
+            email: 'test@example.com',
+            username: 'testuser',
+            permissions: ['read', 'write']
+        });
+        this.addUser('admin', 'admin123', {
+            userId: 'user-admin',
+            email: 'admin@example.com',
+            username: 'admin',
+            permissions: ['read', 'write', 'admin']
+        });
+    }
+    async validateToken(token) {
+        await this.simulateDelay();
+        if (this.shouldFailAuth) {
+            throw new Error('Mock auth validation failed');
+        }
+        if (this.revokedTokens.has(token)) {
+            throw new Error('Token has been revoked');
+        }
+        const payload = this.tokens.get(token);
+        if (!payload) {
+            throw new Error('Invalid token');
+        }
+        // Check expiration
+        if (payload.expiresAt && payload.expiresAt < Date.now()) {
+            this.tokens.delete(token);
+            throw new Error('Token expired');
+        }
+        return payload;
+    }
+    async generateToken(payload) {
+        await this.simulateDelay();
+        if (this.shouldFailAuth) {
+            throw new Error('Mock token generation failed');
+        }
+        const token = `mock-token-${++this.tokenCounter}`;
+        // Set default expiration to 1 hour if not specified
+        const expiresAt = payload.expiresAt ?? Date.now() + 3600000;
+        this.tokens.set(token, { ...payload, expiresAt });
+        return token;
+    }
+    async refreshToken(token) {
+        await this.simulateDelay();
+        if (this.shouldFailAuth) {
+            throw new Error('Mock token refresh failed');
+        }
+        const payload = await this.validateToken(token);
+        // Revoke old token
+        await this.revokeToken(token);
+        // Generate new token with extended expiration
+        const newPayload = {
+            ...payload,
+            expiresAt: Date.now() + 3600000 // 1 hour from now
+        };
+        return this.generateToken(newPayload);
+    }
+    async revokeToken(token) {
+        await this.simulateDelay();
+        if (this.shouldFailAuth) {
+            throw new Error('Mock token revocation failed');
+        }
+        this.tokens.delete(token);
+        this.revokedTokens.add(token);
+    }
+    async authenticate(credentials) {
+        await this.simulateDelay();
+        if (this.shouldFailAuth) {
+            throw new Error('Mock authentication failed');
+        }
+        switch (credentials.type) {
+            case 'password': {
+                if (!credentials.username || !credentials.password) {
+                    throw new Error('Username and password required');
+                }
+                const user = this.users.get(credentials.username);
+                if (!user || user.password !== credentials.password) {
+                    throw new Error('Invalid credentials');
+                }
+                const token = await this.generateToken(user.payload);
+                const refreshToken = `refresh-${token}`;
+                this.tokens.set(refreshToken, user.payload);
+                return {
+                    token,
+                    refreshToken,
+                    user: user.payload,
+                    expiresIn: 3600
+                };
+            }
+            case 'token': {
+                if (!credentials.token) {
+                    throw new Error('Token required');
+                }
+                const payload = await this.validateToken(credentials.token);
+                return {
+                    token: credentials.token,
+                    user: payload,
+                    expiresIn: 3600
+                };
+            }
+            case 'oauth': {
+                // Simulate OAuth flow
+                if (!credentials.code) {
+                    throw new Error('OAuth code required');
+                }
+                // Create a mock OAuth user
+                const payload = {
+                    userId: `oauth-user-${Date.now()}`,
+                    email: 'oauth@example.com',
+                    username: 'oauthuser',
+                    permissions: ['read', 'write']
+                };
+                const token = await this.generateToken(payload);
+                return {
+                    token,
+                    user: payload,
+                    expiresIn: 3600
+                };
+            }
+            default:
+                throw new Error('Unsupported credential type');
+        }
+    }
+    // Test helper methods
+    async simulateDelay() {
+        if (this.simulateLatency > 0) {
+            await new Promise(resolve => setTimeout(resolve, this.simulateLatency));
+        }
+    }
+    addUser(username, password, payload) {
+        this.users.set(username, { password, payload });
+    }
+    removeUser(username) {
+        this.users.delete(username);
+    }
+    getTokenCount() {
+        return this.tokens.size;
+    }
+    getRevokedTokenCount() {
+        return this.revokedTokens.size;
+    }
+    clearTokens() {
+        this.tokens.clear();
+        this.revokedTokens.clear();
+    }
+    setFailAuth(fail) {
+        this.shouldFailAuth = fail;
+    }
+}

package/dist/adapters/mock/MockStorageAdapter.d.ts

@@ -0,0 +1,27 @@
+import type { IStorageAdapter, StorageOperation } from '../../abstractions/StorageAdapter';
+interface StorageItem {
+    value: unknown;
+    expiresAt?: number;
+}
+export declare class MockStorageAdapter implements IStorageAdapter {
+    private storage;
+    private simulateLatency;
+    private shouldFailOperations;
+    constructor(options?: {
+        simulateLatency?: number;
+        shouldFailOperations?: boolean;
+    });
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, ttl?: number): Promise<void>;
+    delete(key: string): Promise<void>;
+    exists(key: string): Promise<boolean>;
+    scan(pattern: string): Promise<string[]>;
+    clear(): Promise<void>;
+    transaction<T>(operations: StorageOperation[]): Promise<T>;
+    private simulateDelay;
+    getSize(): number;
+    getRawStorage(): Map<string, StorageItem>;
+    setFailOperations(fail: boolean): void;
+}
+export {};
+//# sourceMappingURL=MockStorageAdapter.d.ts.map

package/dist/adapters/mock/MockStorageAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockStorageAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/mock/MockStorageAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAE3F,UAAU,WAAW;IACnB,KAAK,EAAE,OAAO,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,kBAAmB,YAAW,eAAe;IACxD,OAAO,CAAC,OAAO,CAAuC;IACtD,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,oBAAoB,CAAkB;gBAElC,OAAO,CAAC,EAAE;QACpB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC;IAKK,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;IAmBtC,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAe1D,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUlC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAmBrC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAiCxC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAUtB,WAAW,CAAC,CAAC,EAAE,UAAU,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC,CAAC,CAAC;YA6DlD,aAAa;IAM3B,OAAO,IAAI,MAAM;IAIjB,aAAa,IAAI,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC;IAIzC,iBAAiB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;CAGvC"}

package/dist/adapters/mock/MockStorageAdapter.js

@@ -0,0 +1,162 @@
+export class MockStorageAdapter {
+    constructor(options) {
+        this.storage = new Map();
+        this.simulateLatency = 0;
+        this.shouldFailOperations = false;
+        this.simulateLatency = options?.simulateLatency ?? 0;
+        this.shouldFailOperations = options?.shouldFailOperations ?? false;
+    }
+    async get(key) {
+        await this.simulateDelay();
+        if (this.shouldFailOperations) {
+            throw new Error('Mock storage operation failed');
+        }
+        const item = this.storage.get(key);
+        if (!item)
+            return null;
+        // Check expiration
+        if (item.expiresAt && item.expiresAt < Date.now()) {
+            this.storage.delete(key);
+            return null;
+        }
+        return item.value;
+    }
+    async set(key, value, ttl) {
+        await this.simulateDelay();
+        if (this.shouldFailOperations) {
+            throw new Error('Mock storage operation failed');
+        }
+        const item = {
+            value,
+            expiresAt: ttl ? Date.now() + ttl : undefined
+        };
+        this.storage.set(key, item);
+    }
+    async delete(key) {
+        await this.simulateDelay();
+        if (this.shouldFailOperations) {
+            throw new Error('Mock storage operation failed');
+        }
+        this.storage.delete(key);
+    }
+    async exists(key) {
+        await this.simulateDelay();
+        if (this.shouldFailOperations) {
+            throw new Error('Mock storage operation failed');
+        }
+        const item = this.storage.get(key);
+        if (!item)
+            return false;
+        // Check expiration
+        if (item.expiresAt && item.expiresAt < Date.now()) {
+            this.storage.delete(key);
+            return false;
+        }
+        return true;
+    }
+    async scan(pattern) {
+        await this.simulateDelay();
+        if (this.shouldFailOperations) {
+            throw new Error('Mock storage operation failed');
+        }
+        // Convert pattern to regex (simple glob to regex conversion)
+        const regexPattern = pattern
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.')
+            .replace(/\[!/g, '[^')
+            .replace(/\[/g, '[')
+            .replace(/\]/g, ']');
+        const regex = new RegExp(`^${regexPattern}$`);
+        const keys = [];
+        for (const [key, item] of this.storage.entries()) {
+            // Skip expired items
+            if (item.expiresAt && item.expiresAt < Date.now()) {
+                this.storage.delete(key);
+                continue;
+            }
+            if (regex.test(key)) {
+                keys.push(key);
+            }
+        }
+        return keys;
+    }
+    async clear() {
+        await this.simulateDelay();
+        if (this.shouldFailOperations) {
+            throw new Error('Mock storage operation failed');
+        }
+        this.storage.clear();
+    }
+    async transaction(operations) {
+        await this.simulateDelay();
+        if (this.shouldFailOperations) {
+            throw new Error('Mock storage operation failed');
+        }
+        const results = [];
+        const rollback = [];
+        try {
+            for (const op of operations) {
+                switch (op.type) {
+                    case 'get': {
+                        const value = await this.get(op.key);
+                        results.push(value);
+                        break;
+                    }
+                    case 'set': {
+                        const oldValue = await this.get(op.key);
+                        await this.set(op.key, op.value, op.ttl);
+                        rollback.push(() => {
+                            if (oldValue !== null) {
+                                this.storage.set(op.key, { value: oldValue });
+                            }
+                            else {
+                                this.storage.delete(op.key);
+                            }
+                        });
+                        results.push(true);
+                        break;
+                    }
+                    case 'delete': {
+                        const oldValue = await this.get(op.key);
+                        await this.delete(op.key);
+                        rollback.push(() => {
+                            if (oldValue !== null) {
+                                this.storage.set(op.key, { value: oldValue });
+                            }
+                        });
+                        results.push(true);
+                        break;
+                    }
+                    case 'exists': {
+                        const exists = await this.exists(op.key);
+                        results.push(exists);
+                        break;
+                    }
+                }
+            }
+            return results;
+        }
+        catch (error) {
+            // Rollback on error
+            for (const rollbackFn of rollback.reverse()) {
+                rollbackFn();
+            }
+            throw error;
+        }
+    }
+    // Test helper methods
+    async simulateDelay() {
+        if (this.simulateLatency > 0) {
+            await new Promise(resolve => setTimeout(resolve, this.simulateLatency));
+        }
+    }
+    getSize() {
+        return this.storage.size;
+    }
+    getRawStorage() {
+        return new Map(this.storage);
+    }
+    setFailOperations(fail) {
+        this.shouldFailOperations = fail;
+    }
+}

package/dist/adapters/mock/MockTransportAdapter.d.ts

@@ -0,0 +1,31 @@
+import type { ITransportAdapter } from '../../abstractions/TransportAdapter';
+import type { ConnectionState, ConnectionOptions, Message, MessageHandler, ErrorHandler, CloseHandler } from '../../types';
+export declare class MockTransportAdapter implements ITransportAdapter {
+    private state;
+    private messageHandlers;
+    private errorHandlers;
+    private closeHandlers;
+    private messageQueue;
+    private simulateLatency;
+    private shouldFailConnection;
+    private connectedUrl;
+    constructor(options?: {
+        simulateLatency?: number;
+        shouldFailConnection?: boolean;
+    });
+    connect(url: string, _options?: ConnectionOptions): Promise<void>;
+    disconnect(): Promise<void>;
+    send(message: Message): Promise<void>;
+    onMessage(handler: MessageHandler): void;
+    onError(handler: ErrorHandler): void;
+    onClose(handler: CloseHandler): void;
+    getState(): ConnectionState;
+    isConnected(): boolean;
+    simulateMessage(message: Message): void;
+    simulateError(error: Error): void;
+    simulateClose(code: number, reason: string): void;
+    getMessageQueue(): Message[];
+    clearMessageQueue(): void;
+    getConnectedUrl(): string | null;
+}
+//# sourceMappingURL=MockTransportAdapter.d.ts.map

package/dist/adapters/mock/MockTransportAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MockTransportAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/mock/MockTransportAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,OAAO,EACP,cAAc,EACd,YAAY,EACZ,YAAY,EACb,MAAM,aAAa,CAAC;AAErB,qBAAa,oBAAqB,YAAW,iBAAiB;IAC5D,OAAO,CAAC,KAAK,CAAmC;IAChD,OAAO,CAAC,eAAe,CAAkC;IACzD,OAAO,CAAC,aAAa,CAAgC;IACrD,OAAO,CAAC,aAAa,CAAgC;IACrD,OAAO,CAAC,YAAY,CAAiB;IACrC,OAAO,CAAC,eAAe,CAAa;IACpC,OAAO,CAAC,oBAAoB,CAAkB;IAC9C,OAAO,CAAC,YAAY,CAAuB;gBAE/B,OAAO,CAAC,EAAE;QACpB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,oBAAoB,CAAC,EAAE,OAAO,CAAC;KAChC;IAKK,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBjE,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAgB3B,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAa3C,SAAS,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAIxC,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAIpC,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAIpC,QAAQ,IAAI,eAAe;IAI3B,WAAW,IAAI,OAAO;IAKtB,eAAe,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAOvC,aAAa,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI;IAIjC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAKjD,eAAe,IAAI,OAAO,EAAE;IAI5B,iBAAiB,IAAI,IAAI;IAIzB,eAAe,IAAI,MAAM,GAAG,IAAI;CAGjC"}

package/dist/adapters/mock/MockTransportAdapter.js

@@ -0,0 +1,90 @@
+export class MockTransportAdapter {
+    constructor(options) {
+        this.state = 'disconnected';
+        this.messageHandlers = new Set();
+        this.errorHandlers = new Set();
+        this.closeHandlers = new Set();
+        this.messageQueue = [];
+        this.simulateLatency = 0;
+        this.shouldFailConnection = false;
+        this.connectedUrl = null;
+        this.simulateLatency = options?.simulateLatency ?? 0;
+        this.shouldFailConnection = options?.shouldFailConnection ?? false;
+    }
+    async connect(url, _options) {
+        if (this.shouldFailConnection) {
+            this.state = 'disconnected';
+            const error = new Error('Mock connection failed');
+            this.errorHandlers.forEach(handler => handler(error));
+            throw error;
+        }
+        this.state = 'connecting';
+        this.connectedUrl = url;
+        // Simulate connection delay
+        if (this.simulateLatency > 0) {
+            await new Promise(resolve => setTimeout(resolve, this.simulateLatency));
+        }
+        this.state = 'connected';
+    }
+    async disconnect() {
+        if (this.state === 'disconnected')
+            return;
+        this.state = 'disconnecting';
+        // Simulate disconnect delay
+        if (this.simulateLatency > 0) {
+            await new Promise(resolve => setTimeout(resolve, this.simulateLatency / 2));
+        }
+        this.state = 'disconnected';
+        this.connectedUrl = null;
+        this.closeHandlers.forEach(handler => handler(1000, 'Normal closure'));
+        this.messageQueue = [];
+    }
+    async send(message) {
+        if (this.state !== 'connected') {
+            throw new Error('Not connected');
+        }
+        // Simulate send latency
+        if (this.simulateLatency > 0) {
+            await new Promise(resolve => setTimeout(resolve, this.simulateLatency));
+        }
+        this.messageQueue.push(message);
+    }
+    onMessage(handler) {
+        this.messageHandlers.add(handler);
+    }
+    onError(handler) {
+        this.errorHandlers.add(handler);
+    }
+    onClose(handler) {
+        this.closeHandlers.add(handler);
+    }
+    getState() {
+        return this.state;
+    }
+    isConnected() {
+        return this.state === 'connected';
+    }
+    // Test helper methods
+    simulateMessage(message) {
+        if (this.state !== 'connected') {
+            throw new Error('Cannot simulate message when not connected');
+        }
+        this.messageHandlers.forEach(handler => handler(message));
+    }
+    simulateError(error) {
+        this.errorHandlers.forEach(handler => handler(error));
+    }
+    simulateClose(code, reason) {
+        this.state = 'disconnected';
+        this.closeHandlers.forEach(handler => handler(code, reason));
+    }
+    getMessageQueue() {
+        return [...this.messageQueue];
+    }
+    clearMessageQueue() {
+        this.messageQueue = [];
+    }
+    getConnectedUrl() {
+        return this.connectedUrl;
+    }
+}

package/dist/adapters/mock/index.d.ts

@@ -0,0 +1,4 @@
+export { MockTransportAdapter } from './MockTransportAdapter';
+export { MockStorageAdapter } from './MockStorageAdapter';
+export { MockAuthAdapter } from './MockAuthAdapter';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/mock/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/mock/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC"}

package/dist/adapters/mock/index.js

@@ -0,0 +1,3 @@
+export { MockTransportAdapter } from './MockTransportAdapter';
+export { MockStorageAdapter } from './MockStorageAdapter';
+export { MockAuthAdapter } from './MockAuthAdapter';

package/dist/adapters/websocket/WebSocketTransportAdapter.d.ts

@@ -0,0 +1,40 @@
+import type { ITransportAdapter } from '../../abstractions/TransportAdapter';
+import type { ConnectionState, ConnectionOptions, Message, MessageHandler, ErrorHandler, CloseHandler } from '../../types';
+import type { Server as HttpServer } from 'http';
+import type { Server as HttpsServer } from 'https';
+import { WebSocketServer, WebSocket } from 'ws';
+interface ClientConnection {
+    id: string;
+    ws: WebSocket;
+    userId?: string;
+}
+export declare class WebSocketTransportAdapter implements ITransportAdapter {
+    private state;
+    private messageHandlers;
+    private errorHandlers;
+    private closeHandlers;
+    private wss?;
+    private serverUrl?;
+    private attachedServer?;
+    private attachedWss?;
+    private webSocketPath?;
+    private clients;
+    private mode;
+    connect(url: string, _options?: ConnectionOptions): Promise<void>;
+    attach(server: HttpServer | HttpsServer, path?: string): Promise<void>;
+    attachToWebSocketServer(wss: WebSocketServer): Promise<void>;
+    private handleConnection;
+    disconnect(): Promise<void>;
+    send(message: Message): Promise<void>;
+    onMessage(handler: MessageHandler): void;
+    onError(handler: ErrorHandler): void;
+    onClose(handler: CloseHandler): void;
+    getState(): ConnectionState;
+    isConnected(): boolean;
+    getConnectedClients(): ClientConnection[];
+    getClientCount(): number;
+    getMode(): 'standalone' | 'integration';
+    private generateId;
+}
+export {};
+//# sourceMappingURL=WebSocketTransportAdapter.d.ts.map

package/dist/adapters/websocket/WebSocketTransportAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebSocketTransportAdapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/websocket/WebSocketTransportAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,KAAK,EACV,eAAe,EACf,iBAAiB,EACjB,OAAO,EACP,cAAc,EACd,YAAY,EACZ,YAAY,EACb,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,MAAM,CAAC;AACjD,OAAO,KAAK,EAAE,MAAM,IAAI,WAAW,EAAE,MAAM,OAAO,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAEhD,UAAU,gBAAgB;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,SAAS,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qBAAa,yBAA0B,YAAW,iBAAiB;IACjE,OAAO,CAAC,KAAK,CAAmC;IAChD,OAAO,CAAC,eAAe,CAAkC;IACzD,OAAO,CAAC,aAAa,CAAgC;IACrD,OAAO,CAAC,aAAa,CAAgC;IAGrD,OAAO,CAAC,GAAG,CAAC,CAAkB;IAC9B,OAAO,CAAC,SAAS,CAAC,CAAS;IAG3B,OAAO,CAAC,cAAc,CAAC,CAA2B;IAClD,OAAO,CAAC,WAAW,CAAC,CAAkB;IACtC,OAAO,CAAC,aAAa,CAAC,CAAS;IAG/B,OAAO,CAAC,OAAO,CAAuC;IACtD,OAAO,CAAC,IAAI,CAA8C;IAGpD,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC;IAsCjE,MAAM,CAAC,MAAM,EAAE,UAAU,GAAG,WAAW,EAAE,IAAI,GAAE,MAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAiC7E,uBAAuB,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IA2BlE,OAAO,CAAC,gBAAgB;IAqClB,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA8B3B,IAAI,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IA8B3C,SAAS,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAIxC,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAIpC,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAIpC,QAAQ,IAAI,eAAe;IAI3B,WAAW,IAAI,OAAO;IAKtB,mBAAmB,IAAI,gBAAgB,EAAE;IAIzC,cAAc,IAAI,MAAM;IAIxB,OAAO,IAAI,YAAY,GAAG,aAAa;IAIvC,OAAO,CAAC,UAAU;CAGnB"}