@objectstack/core 0.6.1 → 0.7.2

package/dist/plugin-loader.js

@@ -0,0 +1,287 @@
+/**
+ * Service Lifecycle Types
+ * Defines how services are instantiated and managed
+ */
+export var ServiceLifecycle;
+(function (ServiceLifecycle) {
+    /** Single instance shared across all requests */
+    ServiceLifecycle["SINGLETON"] = "singleton";
+    /** New instance created for each request */
+    ServiceLifecycle["TRANSIENT"] = "transient";
+    /** New instance per scope (e.g., per HTTP request) */
+    ServiceLifecycle["SCOPED"] = "scoped";
+})(ServiceLifecycle || (ServiceLifecycle = {}));
+/**
+ * Enhanced Plugin Loader
+ * Provides advanced plugin loading capabilities with validation, security, and lifecycle management
+ */
+export class PluginLoader {
+    constructor(logger) {
+        this.loadedPlugins = new Map();
+        this.serviceFactories = new Map();
+        this.serviceInstances = new Map();
+        this.scopedServices = new Map();
+        this.logger = logger;
+    }
+    /**
+     * Load a plugin asynchronously with validation
+     */
+    async loadPlugin(plugin) {
+        const startTime = Date.now();
+        try {
+            this.logger.info(`Loading plugin: ${plugin.name}`);
+            // Convert to PluginMetadata
+            const metadata = this.toPluginMetadata(plugin);
+            // Validate plugin structure
+            this.validatePluginStructure(metadata);
+            // Check version compatibility
+            const versionCheck = this.checkVersionCompatibility(metadata);
+            if (!versionCheck.compatible) {
+                throw new Error(`Version incompatible: ${versionCheck.message}`);
+            }
+            // Validate configuration if schema is provided
+            if (metadata.configSchema) {
+                this.validatePluginConfig(metadata);
+            }
+            // Verify signature if provided
+            if (metadata.signature) {
+                await this.verifyPluginSignature(metadata);
+            }
+            // Store loaded plugin
+            this.loadedPlugins.set(metadata.name, metadata);
+            const loadTime = Date.now() - startTime;
+            this.logger.info(`Plugin loaded: ${plugin.name} (${loadTime}ms)`);
+            return {
+                success: true,
+                plugin: metadata,
+                loadTime,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to load plugin: ${plugin.name}`, error);
+            return {
+                success: false,
+                error: error,
+                loadTime: Date.now() - startTime,
+            };
+        }
+    }
+    /**
+     * Register a service with factory function
+     */
+    registerServiceFactory(registration) {
+        if (this.serviceFactories.has(registration.name)) {
+            throw new Error(`Service factory '${registration.name}' already registered`);
+        }
+        this.serviceFactories.set(registration.name, registration);
+        this.logger.debug(`Service factory registered: ${registration.name} (${registration.lifecycle})`);
+    }
+    /**
+     * Get or create a service instance based on lifecycle type
+     */
+    async getService(name, scopeId) {
+        const registration = this.serviceFactories.get(name);
+        if (!registration) {
+            // Fall back to static service instances
+            const instance = this.serviceInstances.get(name);
+            if (!instance) {
+                throw new Error(`Service '${name}' not found`);
+            }
+            return instance;
+        }
+        switch (registration.lifecycle) {
+            case ServiceLifecycle.SINGLETON:
+                return await this.getSingletonService(registration);
+            case ServiceLifecycle.TRANSIENT:
+                return await this.createTransientService(registration);
+            case ServiceLifecycle.SCOPED:
+                if (!scopeId) {
+                    throw new Error(`Scope ID required for scoped service '${name}'`);
+                }
+                return await this.getScopedService(registration, scopeId);
+            default:
+                throw new Error(`Unknown service lifecycle: ${registration.lifecycle}`);
+        }
+    }
+    /**
+     * Register a static service instance (legacy support)
+     */
+    registerService(name, service) {
+        if (this.serviceInstances.has(name)) {
+            throw new Error(`Service '${name}' already registered`);
+        }
+        this.serviceInstances.set(name, service);
+    }
+    /**
+     * Detect circular dependencies in service factories
+     * Note: This only detects cycles in service dependencies, not plugin dependencies.
+     * Plugin dependency cycles are detected in the kernel's resolveDependencies method.
+     */
+    detectCircularDependencies() {
+        const cycles = [];
+        const visited = new Set();
+        const visiting = new Set();
+        const visit = (serviceName, path = []) => {
+            if (visiting.has(serviceName)) {
+                const cycle = [...path, serviceName].join(' -> ');
+                cycles.push(cycle);
+                return;
+            }
+            if (visited.has(serviceName)) {
+                return;
+            }
+            visiting.add(serviceName);
+            const registration = this.serviceFactories.get(serviceName);
+            if (registration?.dependencies) {
+                for (const dep of registration.dependencies) {
+                    visit(dep, [...path, serviceName]);
+                }
+            }
+            visiting.delete(serviceName);
+            visited.add(serviceName);
+        };
+        for (const serviceName of this.serviceFactories.keys()) {
+            visit(serviceName);
+        }
+        return cycles;
+    }
+    /**
+     * Check plugin health
+     */
+    async checkPluginHealth(pluginName) {
+        const plugin = this.loadedPlugins.get(pluginName);
+        if (!plugin) {
+            return {
+                healthy: false,
+                message: 'Plugin not found',
+                lastCheck: new Date(),
+            };
+        }
+        if (!plugin.healthCheck) {
+            return {
+                healthy: true,
+                message: 'No health check defined',
+                lastCheck: new Date(),
+            };
+        }
+        try {
+            const status = await plugin.healthCheck();
+            return {
+                ...status,
+                lastCheck: new Date(),
+            };
+        }
+        catch (error) {
+            return {
+                healthy: false,
+                message: `Health check failed: ${error.message}`,
+                lastCheck: new Date(),
+            };
+        }
+    }
+    /**
+     * Clear scoped services for a scope
+     */
+    clearScope(scopeId) {
+        this.scopedServices.delete(scopeId);
+        this.logger.debug(`Cleared scope: ${scopeId}`);
+    }
+    /**
+     * Get all loaded plugins
+     */
+    getLoadedPlugins() {
+        return new Map(this.loadedPlugins);
+    }
+    // Private helper methods
+    toPluginMetadata(plugin) {
+        return {
+            ...plugin,
+            version: plugin.version || '0.0.0',
+        };
+    }
+    validatePluginStructure(plugin) {
+        if (!plugin.name) {
+            throw new Error('Plugin name is required');
+        }
+        if (!plugin.init) {
+            throw new Error('Plugin init function is required');
+        }
+        if (!this.isValidSemanticVersion(plugin.version)) {
+            throw new Error(`Invalid semantic version: ${plugin.version}`);
+        }
+    }
+    checkVersionCompatibility(plugin) {
+        // Basic semantic version compatibility check
+        // In a real implementation, this would check against kernel version
+        const version = plugin.version;
+        if (!this.isValidSemanticVersion(version)) {
+            return {
+                compatible: false,
+                pluginVersion: version,
+                message: 'Invalid semantic version format',
+            };
+        }
+        return {
+            compatible: true,
+            pluginVersion: version,
+        };
+    }
+    isValidSemanticVersion(version) {
+        const semverRegex = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/;
+        return semverRegex.test(version);
+    }
+    validatePluginConfig(plugin) {
+        if (!plugin.configSchema) {
+            return;
+        }
+        // TODO: Configuration validation implementation
+        // This requires plugin config to be passed during loading
+        // For now, just validate that the schema exists
+        this.logger.debug(`Plugin ${plugin.name} has configuration schema (validation not yet implemented)`);
+    }
+    async verifyPluginSignature(plugin) {
+        if (!plugin.signature) {
+            return;
+        }
+        // TODO: Plugin signature verification implementation
+        // In a real implementation:
+        // 1. Extract public key from trusted source
+        // 2. Verify signature against plugin code hash
+        // 3. Throw error if verification fails
+        this.logger.debug(`Plugin ${plugin.name} signature verification (not yet implemented)`);
+    }
+    async getSingletonService(registration) {
+        let instance = this.serviceInstances.get(registration.name);
+        if (!instance) {
+            // Create instance (would need context)
+            instance = await this.createServiceInstance(registration);
+            this.serviceInstances.set(registration.name, instance);
+            this.logger.debug(`Singleton service created: ${registration.name}`);
+        }
+        return instance;
+    }
+    async createTransientService(registration) {
+        const instance = await this.createServiceInstance(registration);
+        this.logger.debug(`Transient service created: ${registration.name}`);
+        return instance;
+    }
+    async getScopedService(registration, scopeId) {
+        if (!this.scopedServices.has(scopeId)) {
+            this.scopedServices.set(scopeId, new Map());
+        }
+        const scope = this.scopedServices.get(scopeId);
+        let instance = scope.get(registration.name);
+        if (!instance) {
+            instance = await this.createServiceInstance(registration);
+            scope.set(registration.name, instance);
+            this.logger.debug(`Scoped service created: ${registration.name} (scope: ${scopeId})`);
+        }
+        return instance;
+    }
+    async createServiceInstance(registration) {
+        // This is a simplified version - in real implementation,
+        // we would need to pass proper context with resolved dependencies
+        const mockContext = {};
+        return await registration.factory(mockContext);
+    }
+}

package/dist/plugin-loader.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=plugin-loader.test.d.ts.map

package/dist/plugin-loader.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin-loader.test.d.ts","sourceRoot":"","sources":["../src/plugin-loader.test.ts"],"names":[],"mappings":""}

package/dist/plugin-loader.test.js

@@ -0,0 +1,339 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { PluginLoader, ServiceLifecycle } from './plugin-loader';
+import { createLogger } from './logger';
+describe('PluginLoader', () => {
+    let loader;
+    beforeEach(() => {
+        const logger = createLogger({ level: 'error' }); // Suppress logs in tests
+        loader = new PluginLoader(logger);
+    });
+    describe('Plugin Loading', () => {
+        it('should load a valid plugin', async () => {
+            const plugin = {
+                name: 'test-plugin',
+                version: '1.0.0',
+                init: async () => { },
+            };
+            const result = await loader.loadPlugin(plugin);
+            expect(result.success).toBe(true);
+            expect(result.plugin?.name).toBe('test-plugin');
+            expect(result.plugin?.version).toBe('1.0.0');
+            expect(result.loadTime).toBeGreaterThanOrEqual(0);
+        });
+        it('should reject plugin with invalid name', async () => {
+            const plugin = {
+                name: '',
+                init: async () => { },
+            };
+            const result = await loader.loadPlugin(plugin);
+            expect(result.success).toBe(false);
+            expect(result.error?.message).toContain('name is required');
+        });
+        it('should reject plugin without init function', async () => {
+            const plugin = {
+                name: 'invalid-plugin',
+            };
+            const result = await loader.loadPlugin(plugin);
+            expect(result.success).toBe(false);
+            expect(result.error?.message).toContain('init function is required');
+        });
+        it('should use default version 0.0.0 if not provided', async () => {
+            const plugin = {
+                name: 'no-version',
+                init: async () => { },
+            };
+            const result = await loader.loadPlugin(plugin);
+            expect(result.success).toBe(true);
+            expect(result.plugin?.version).toBe('0.0.0');
+        });
+    });
+    describe('Version Compatibility', () => {
+        it('should accept valid semantic versions', async () => {
+            const validVersions = ['1.0.0', '2.3.4', '0.0.1', '10.20.30'];
+            for (const version of validVersions) {
+                const plugin = {
+                    name: `plugin-${version}`,
+                    version,
+                    init: async () => { },
+                };
+                const result = await loader.loadPlugin(plugin);
+                expect(result.success).toBe(true);
+            }
+        });
+        it('should accept versions with pre-release tags', async () => {
+            const plugin = {
+                name: 'prerelease',
+                version: '1.0.0-alpha.1',
+                init: async () => { },
+            };
+            const result = await loader.loadPlugin(plugin);
+            expect(result.success).toBe(true);
+        });
+        it('should accept versions with build metadata', async () => {
+            const plugin = {
+                name: 'build-meta',
+                version: '1.0.0+20230101',
+                init: async () => { },
+            };
+            const result = await loader.loadPlugin(plugin);
+            expect(result.success).toBe(true);
+        });
+        it('should reject invalid semantic versions', async () => {
+            const invalidVersions = ['1.0', 'v1.0.0', '1', 'invalid'];
+            for (const version of invalidVersions) {
+                const plugin = {
+                    name: `invalid-${version}`,
+                    version,
+                    init: async () => { },
+                };
+                const result = await loader.loadPlugin(plugin);
+                expect(result.success).toBe(false);
+            }
+        });
+    });
+    describe('Service Factory Registration', () => {
+        it('should register a singleton service factory', () => {
+            let callCount = 0;
+            const factory = () => {
+                callCount++;
+                return { value: callCount };
+            };
+            loader.registerServiceFactory({
+                name: 'singleton-service',
+                factory,
+                lifecycle: ServiceLifecycle.SINGLETON,
+            });
+            expect(() => {
+                loader.registerServiceFactory({
+                    name: 'singleton-service',
+                    factory,
+                    lifecycle: ServiceLifecycle.SINGLETON,
+                });
+            }).toThrow('already registered');
+        });
+        it('should register multiple service factories with different names', () => {
+            loader.registerServiceFactory({
+                name: 'service-1',
+                factory: () => ({ id: 1 }),
+                lifecycle: ServiceLifecycle.SINGLETON,
+            });
+            loader.registerServiceFactory({
+                name: 'service-2',
+                factory: () => ({ id: 2 }),
+                lifecycle: ServiceLifecycle.TRANSIENT,
+            });
+            // Should not throw
+            expect(true).toBe(true);
+        });
+    });
+    describe('Service Retrieval with Lifecycle', () => {
+        it('should create singleton service only once', async () => {
+            let callCount = 0;
+            loader.registerServiceFactory({
+                name: 'counter',
+                factory: () => {
+                    callCount++;
+                    return { count: callCount };
+                },
+                lifecycle: ServiceLifecycle.SINGLETON,
+            });
+            const service1 = await loader.getService('counter');
+            const service2 = await loader.getService('counter');
+            expect(callCount).toBe(1);
+            expect(service1).toBe(service2);
+        });
+        it('should create new transient service on each request', async () => {
+            let callCount = 0;
+            loader.registerServiceFactory({
+                name: 'transient',
+                factory: () => {
+                    callCount++;
+                    return { count: callCount };
+                },
+                lifecycle: ServiceLifecycle.TRANSIENT,
+            });
+            const service1 = await loader.getService('transient');
+            const service2 = await loader.getService('transient');
+            expect(callCount).toBe(2);
+            expect(service1).not.toBe(service2);
+            expect(service1.count).toBe(1);
+            expect(service2.count).toBe(2);
+        });
+        it('should create scoped service once per scope', async () => {
+            let callCount = 0;
+            loader.registerServiceFactory({
+                name: 'scoped',
+                factory: () => {
+                    callCount++;
+                    return { count: callCount };
+                },
+                lifecycle: ServiceLifecycle.SCOPED,
+            });
+            const scope1Service1 = await loader.getService('scoped', 'scope-1');
+            const scope1Service2 = await loader.getService('scoped', 'scope-1');
+            const scope2Service1 = await loader.getService('scoped', 'scope-2');
+            expect(callCount).toBe(2); // Once per scope
+            expect(scope1Service1).toBe(scope1Service2); // Same within scope
+            expect(scope1Service1).not.toBe(scope2Service1); // Different across scopes
+        });
+        it('should throw error for scoped service without scope ID', async () => {
+            loader.registerServiceFactory({
+                name: 'scoped-no-id',
+                factory: () => ({ value: 'test' }),
+                lifecycle: ServiceLifecycle.SCOPED,
+            });
+            await expect(async () => {
+                await loader.getService('scoped-no-id');
+            }).rejects.toThrow('Scope ID required');
+        });
+        it('should throw error for non-existent service', async () => {
+            await expect(async () => {
+                await loader.getService('non-existent');
+            }).rejects.toThrow('not found');
+        });
+    });
+    describe('Circular Dependency Detection', () => {
+        it('should detect simple circular dependency', () => {
+            loader.registerServiceFactory({
+                name: 'service-a',
+                factory: () => ({}),
+                lifecycle: ServiceLifecycle.SINGLETON,
+                dependencies: ['service-b'],
+            });
+            loader.registerServiceFactory({
+                name: 'service-b',
+                factory: () => ({}),
+                lifecycle: ServiceLifecycle.SINGLETON,
+                dependencies: ['service-a'],
+            });
+            const cycles = loader.detectCircularDependencies();
+            expect(cycles.length).toBeGreaterThan(0);
+            expect(cycles[0]).toContain('service-a');
+            expect(cycles[0]).toContain('service-b');
+        });
+        it('should detect complex circular dependency', () => {
+            loader.registerServiceFactory({
+                name: 'service-a',
+                factory: () => ({}),
+                lifecycle: ServiceLifecycle.SINGLETON,
+                dependencies: ['service-b'],
+            });
+            loader.registerServiceFactory({
+                name: 'service-b',
+                factory: () => ({}),
+                lifecycle: ServiceLifecycle.SINGLETON,
+                dependencies: ['service-c'],
+            });
+            loader.registerServiceFactory({
+                name: 'service-c',
+                factory: () => ({}),
+                lifecycle: ServiceLifecycle.SINGLETON,
+                dependencies: ['service-a'],
+            });
+            const cycles = loader.detectCircularDependencies();
+            expect(cycles.length).toBeGreaterThan(0);
+        });
+        it('should not report false positives for valid dependency chains', () => {
+            loader.registerServiceFactory({
+                name: 'service-a',
+                factory: () => ({}),
+                lifecycle: ServiceLifecycle.SINGLETON,
+                dependencies: ['service-b'],
+            });
+            loader.registerServiceFactory({
+                name: 'service-b',
+                factory: () => ({}),
+                lifecycle: ServiceLifecycle.SINGLETON,
+                dependencies: ['service-c'],
+            });
+            loader.registerServiceFactory({
+                name: 'service-c',
+                factory: () => ({}),
+                lifecycle: ServiceLifecycle.SINGLETON,
+            });
+            const cycles = loader.detectCircularDependencies();
+            expect(cycles.length).toBe(0);
+        });
+    });
+    describe('Plugin Health Checks', () => {
+        it('should return healthy for plugin without health check', async () => {
+            const plugin = {
+                name: 'no-health-check',
+                version: '1.0.0',
+                init: async () => { },
+            };
+            await loader.loadPlugin(plugin);
+            const health = await loader.checkPluginHealth('no-health-check');
+            expect(health.healthy).toBe(true);
+            expect(health.message).toContain('No health check');
+        });
+        it('should execute plugin health check', async () => {
+            const plugin = {
+                name: 'with-health-check',
+                version: '1.0.0',
+                init: async () => { },
+                healthCheck: async () => ({
+                    healthy: true,
+                    message: 'All systems operational',
+                }),
+            };
+            await loader.loadPlugin(plugin);
+            const health = await loader.checkPluginHealth('with-health-check');
+            expect(health.healthy).toBe(true);
+            expect(health.message).toBe('All systems operational');
+            expect(health.lastCheck).toBeInstanceOf(Date);
+        });
+        it('should handle failing health check', async () => {
+            const plugin = {
+                name: 'failing-health',
+                version: '1.0.0',
+                init: async () => { },
+                healthCheck: async () => {
+                    throw new Error('Service unavailable');
+                },
+            };
+            await loader.loadPlugin(plugin);
+            const health = await loader.checkPluginHealth('failing-health');
+            expect(health.healthy).toBe(false);
+            expect(health.message).toContain('Health check failed');
+        });
+        it('should return not found for unknown plugin', async () => {
+            const health = await loader.checkPluginHealth('unknown-plugin');
+            expect(health.healthy).toBe(false);
+            expect(health.message).toContain('not found');
+        });
+    });
+    describe('Scope Management', () => {
+        it('should clear scoped services', async () => {
+            let callCount = 0;
+            loader.registerServiceFactory({
+                name: 'scoped-clear',
+                factory: () => {
+                    callCount++;
+                    return { count: callCount };
+                },
+                lifecycle: ServiceLifecycle.SCOPED,
+            });
+            const service1 = await loader.getService('scoped-clear', 'scope-1');
+            expect(service1.count).toBe(1);
+            loader.clearScope('scope-1');
+            const service2 = await loader.getService('scoped-clear', 'scope-1');
+            expect(service2.count).toBe(2); // New instance created
+        });
+    });
+    describe('Static Service Registration', () => {
+        it('should register static service instance', () => {
+            const service = { value: 'test' };
+            loader.registerService('static-service', service);
+            expect(() => {
+                loader.registerService('static-service', service);
+            }).toThrow('already registered');
+        });
+        it('should retrieve static service', async () => {
+            const service = { value: 'static' };
+            loader.registerService('static', service);
+            const retrieved = await loader.getService('static');
+            expect(retrieved).toBe(service);
+        });
+    });
+});

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import { ObjectKernel } from './kernel.js';
+import type { Logger } from '@objectstack/spec/contracts';
 /**
  * PluginContext - Runtime context available to plugins
  *
@@ -41,7 +42,7 @@ export interface PluginContext {
     /**
      * Logger instance
      */
-    logger: Console;
+    logger: Logger;
     /**
      * Get the kernel instance (for advanced use cases)
      * @returns Kernel instance

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC1B;;;;OAIG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,IAAI,CAAC;IAElD;;;;;OAKG;IACH,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC;IAE/B;;OAEG;IACH,WAAW,IAAI,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAEhC;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAE5E;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAErD;;OAEG;IACH,MAAM,EAAE,OAAO,CAAC;IAEhB;;;OAGG;IACH,SAAS,IAAI,YAAY,CAAC;CAC7B;AAED;;;;GAIG;AACH,MAAM,WAAW,MAAM;IACnB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAExB;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAE/C;;;;OAIG;IACH,KAAK,CAAC,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAEjD;;;OAGG;IACH,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACpC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAC;AAE1D;;;;;;;;GAQG;AACH,MAAM,WAAW,aAAa;IAC1B;;;;OAIG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,IAAI,CAAC;IAElD;;;;;OAKG;IACH,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC;IAE/B;;OAEG;IACH,WAAW,IAAI,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAEhC;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAE5E;;;;OAIG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAErD;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,SAAS,IAAI,YAAY,CAAC;CAC7B;AAED;;;;GAIG;AACH,MAAM,WAAW,MAAM;IACnB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IAExB;;;;OAIG;IACH,IAAI,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAE/C;;;;OAIG;IACH,KAAK,CAAC,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAEjD;;;OAGG;IACH,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CACpC"}