@hazeljs/core 0.2.0-beta.1

package/dist/__tests__/utils/sanitize.test.js

@@ -0,0 +1,291 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sanitize_1 = require("../../utils/sanitize");
+describe('Sanitize Utilities', () => {
+    describe('sanitizeHtml', () => {
+        it('should remove script tags', () => {
+            const input = '<div>Hello <script>alert("xss")</script> World</div>';
+            const result = (0, sanitize_1.sanitizeHtml)(input);
+            expect(result).not.toContain('<script>');
+            expect(result).toContain('Hello');
+            expect(result).toContain('World');
+        });
+        it('should remove iframe tags', () => {
+            const input = '<div>Content <iframe src="evil.com"></iframe></div>';
+            const result = (0, sanitize_1.sanitizeHtml)(input);
+            expect(result).not.toContain('<iframe>');
+        });
+        it('should remove event handlers', () => {
+            const input = '<div onclick="alert(\'xss\')">Click me</div>';
+            const result = (0, sanitize_1.sanitizeHtml)(input);
+            expect(result).not.toContain('onclick');
+        });
+        it('should remove javascript: protocol', () => {
+            const input = '<a href="javascript:alert(\'xss\')">Link</a>';
+            const result = (0, sanitize_1.sanitizeHtml)(input);
+            expect(result).not.toContain('javascript:');
+        });
+        it('should remove data:text/html', () => {
+            const input = '<a href="data:text/html,<script>alert(\'xss\')</script>">Link</a>';
+            const result = (0, sanitize_1.sanitizeHtml)(input);
+            expect(result).not.toContain('data:text/html');
+        });
+        it('should handle non-string input', () => {
+            const result = (0, sanitize_1.sanitizeHtml)(123);
+            expect(result).toBe('123');
+        });
+        it('should preserve safe HTML', () => {
+            const input = '<div><p>Safe content</p></div>';
+            const result = (0, sanitize_1.sanitizeHtml)(input);
+            expect(result).toContain('<div>');
+            expect(result).toContain('<p>');
+            expect(result).toContain('Safe content');
+        });
+        it('should remove multiple script tags', () => {
+            const input = '<script>bad1</script>Content<script>bad2</script>';
+            const result = (0, sanitize_1.sanitizeHtml)(input);
+            expect(result).not.toContain('<script>');
+            expect(result).toContain('Content');
+        });
+    });
+    describe('sanitizeString', () => {
+        it('should remove control characters', () => {
+            const input = 'Hello\x00\x01World';
+            const result = (0, sanitize_1.sanitizeString)(input);
+            expect(result).toBe('HelloWorld');
+        });
+        it('should trim whitespace', () => {
+            const input = '  Hello World  ';
+            const result = (0, sanitize_1.sanitizeString)(input);
+            expect(result).toBe('Hello World');
+        });
+        it('should normalize multiple spaces', () => {
+            const input = 'Hello    World';
+            const result = (0, sanitize_1.sanitizeString)(input);
+            expect(result).toBe('Hello World');
+        });
+        it('should handle tabs and newlines', () => {
+            const input = 'Hello\t\nWorld';
+            const result = (0, sanitize_1.sanitizeString)(input);
+            // Tabs and newlines are normalized to single space
+            expect(result).toContain('Hello');
+            expect(result).toContain('World');
+        });
+        it('should handle non-string input', () => {
+            const result = (0, sanitize_1.sanitizeString)(456);
+            expect(result).toBe('456');
+        });
+        it('should handle empty string', () => {
+            const result = (0, sanitize_1.sanitizeString)('');
+            expect(result).toBe('');
+        });
+        it('should remove all control characters', () => {
+            const input = '\x00\x01\x02\x03Hello\x7F\x80\x9F';
+            const result = (0, sanitize_1.sanitizeString)(input);
+            expect(result).toBe('Hello');
+        });
+    });
+    describe('sanitizeUrl', () => {
+        it('should allow valid http URL', () => {
+            const input = 'http://example.com';
+            const result = (0, sanitize_1.sanitizeUrl)(input);
+            expect(result).toBe('http://example.com/');
+        });
+        it('should allow valid https URL', () => {
+            const input = 'https://example.com';
+            const result = (0, sanitize_1.sanitizeUrl)(input);
+            expect(result).toBe('https://example.com/');
+        });
+        it('should reject javascript: protocol', () => {
+            const input = 'javascript:alert("xss")';
+            const result = (0, sanitize_1.sanitizeUrl)(input);
+            expect(result).toBe('');
+        });
+        it('should reject data: protocol', () => {
+            const input = 'data:text/html,<script>alert("xss")</script>';
+            const result = (0, sanitize_1.sanitizeUrl)(input);
+            expect(result).toBe('');
+        });
+        it('should reject file: protocol', () => {
+            const input = 'file:///etc/passwd';
+            const result = (0, sanitize_1.sanitizeUrl)(input);
+            expect(result).toBe('');
+        });
+        it('should handle invalid URL', () => {
+            const input = 'not a url';
+            const result = (0, sanitize_1.sanitizeUrl)(input);
+            expect(result).toBe('');
+        });
+        it('should handle non-string input', () => {
+            const result = (0, sanitize_1.sanitizeUrl)(123);
+            expect(result).toBe('');
+        });
+        it('should preserve URL with path and query', () => {
+            const input = 'https://example.com/path?query=value';
+            const result = (0, sanitize_1.sanitizeUrl)(input);
+            expect(result).toContain('example.com');
+            expect(result).toContain('/path');
+            expect(result).toContain('query=value');
+        });
+    });
+    describe('sanitizeEmail', () => {
+        it('should accept valid email', () => {
+            const input = 'user@example.com';
+            const result = (0, sanitize_1.sanitizeEmail)(input);
+            expect(result).toBe('user@example.com');
+        });
+        it('should convert to lowercase', () => {
+            const input = 'User@Example.COM';
+            const result = (0, sanitize_1.sanitizeEmail)(input);
+            expect(result).toBe('user@example.com');
+        });
+        it('should trim whitespace', () => {
+            const input = '  user@example.com  ';
+            const result = (0, sanitize_1.sanitizeEmail)(input);
+            expect(result).toBe('user@example.com');
+        });
+        it('should reject invalid email', () => {
+            const input = 'not-an-email';
+            const result = (0, sanitize_1.sanitizeEmail)(input);
+            expect(result).toBe('');
+        });
+        it('should reject email without @', () => {
+            const input = 'userexample.com';
+            const result = (0, sanitize_1.sanitizeEmail)(input);
+            expect(result).toBe('');
+        });
+        it('should reject email without domain', () => {
+            const input = 'user@';
+            const result = (0, sanitize_1.sanitizeEmail)(input);
+            expect(result).toBe('');
+        });
+        it('should handle non-string input', () => {
+            const result = (0, sanitize_1.sanitizeEmail)(123);
+            expect(result).toBe('');
+        });
+        it('should accept email with subdomain', () => {
+            const input = 'user@mail.example.com';
+            const result = (0, sanitize_1.sanitizeEmail)(input);
+            expect(result).toBe('user@mail.example.com');
+        });
+    });
+    describe('sanitizeSql', () => {
+        it('should escape single quotes', () => {
+            const input = "O'Reilly";
+            const result = (0, sanitize_1.sanitizeSql)(input);
+            expect(result).toBe("O''Reilly");
+        });
+        it('should remove semicolons', () => {
+            const input = 'DROP TABLE users;';
+            const result = (0, sanitize_1.sanitizeSql)(input);
+            expect(result).not.toContain(';');
+        });
+        it('should remove SQL comments', () => {
+            const input = 'SELECT * FROM users -- comment';
+            const result = (0, sanitize_1.sanitizeSql)(input);
+            expect(result).not.toContain('--');
+        });
+        it('should remove block comments', () => {
+            const input = 'SELECT * /* comment */ FROM users';
+            const result = (0, sanitize_1.sanitizeSql)(input);
+            expect(result).not.toContain('/*');
+            expect(result).not.toContain('*/');
+        });
+        it('should handle non-string input', () => {
+            const result = (0, sanitize_1.sanitizeSql)(123);
+            expect(result).toBe('');
+        });
+        it('should handle multiple dangerous characters', () => {
+            const input = "'; DROP TABLE users; --";
+            const result = (0, sanitize_1.sanitizeSql)(input);
+            expect(result).toBe("'' DROP TABLE users ");
+        });
+    });
+    describe('sanitizeObject', () => {
+        it('should sanitize string values in object', () => {
+            const input = {
+                name: '  John  ',
+                email: 'JOHN@EXAMPLE.COM',
+            };
+            const result = (0, sanitize_1.sanitizeObject)(input);
+            expect(result.name).toBe('John');
+            expect(result.email).toBe('JOHN@EXAMPLE.COM');
+        });
+        it('should handle nested objects', () => {
+            const input = {
+                user: {
+                    name: '  Jane  ',
+                },
+            };
+            const result = (0, sanitize_1.sanitizeObject)(input);
+            expect(result.user.name).toBe('Jane');
+        });
+        it('should preserve non-string values', () => {
+            const input = {
+                name: 'John',
+                age: 30,
+                active: true,
+            };
+            const result = (0, sanitize_1.sanitizeObject)(input);
+            expect(result.age).toBe(30);
+            expect(result.active).toBe(true);
+        });
+        it('should handle arrays in objects', () => {
+            const input = {
+                tags: ['  tag1  ', '  tag2  '],
+            };
+            const result = (0, sanitize_1.sanitizeObject)(input);
+            expect(result.tags[0]).toBe('tag1');
+            expect(result.tags[1]).toBe('tag2');
+        });
+        it('should handle null values', () => {
+            const input = {
+                name: 'John',
+                email: null,
+            };
+            const result = (0, sanitize_1.sanitizeObject)(input);
+            expect(result.email).toBeNull();
+        });
+    });
+    describe('escapeHtml', () => {
+        it('should escape HTML entities', () => {
+            const input = '<div>Hello & "World"</div>';
+            const result = (0, sanitize_1.escapeHtml)(input);
+            expect(result).toBe('&lt;div&gt;Hello &amp; &quot;World&quot;&lt;/div&gt;');
+        });
+        it('should escape ampersand', () => {
+            const input = 'Tom & Jerry';
+            const result = (0, sanitize_1.escapeHtml)(input);
+            expect(result).toBe('Tom &amp; Jerry');
+        });
+        it('should escape less than', () => {
+            const input = '5 < 10';
+            const result = (0, sanitize_1.escapeHtml)(input);
+            expect(result).toBe('5 &lt; 10');
+        });
+        it('should escape greater than', () => {
+            const input = '10 > 5';
+            const result = (0, sanitize_1.escapeHtml)(input);
+            expect(result).toBe('10 &gt; 5');
+        });
+        it('should escape double quotes', () => {
+            const input = 'He said "Hello"';
+            const result = (0, sanitize_1.escapeHtml)(input);
+            expect(result).toBe('He said &quot;Hello&quot;');
+        });
+        it('should escape single quotes', () => {
+            const input = "It's working";
+            const result = (0, sanitize_1.escapeHtml)(input);
+            expect(result).toBe('It&#039;s working');
+        });
+        it('should handle non-string input', () => {
+            const result = (0, sanitize_1.escapeHtml)(123);
+            expect(result).toBe('123');
+        });
+        it('should escape all special characters', () => {
+            const input = `<>&"'`;
+            const result = (0, sanitize_1.escapeHtml)(input);
+            expect(result).toBe('&lt;&gt;&amp;&quot;&#039;');
+        });
+    });
+});

package/dist/__tests__/validator.test.d.ts

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

package/dist/__tests__/validator.test.d.ts.map

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

package/dist/__tests__/validator.test.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const validator_1 = require("../validator");
+describe('Validator', () => {
+    describe('required validation', () => {
+        it('should validate required fields', () => {
+            const schema = {
+                name: { type: 'string', required: true },
+            };
+            const errors = validator_1.Validator.validate({}, schema);
+            expect(errors).toHaveLength(1);
+            expect(errors[0]).toEqual({
+                field: 'name',
+                message: 'name is required',
+            });
+        });
+        it('should reject null values for required fields', () => {
+            const schema = {
+                email: { type: 'string', required: true },
+            };
+            const errors = validator_1.Validator.validate({ email: null }, schema);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].field).toBe('email');
+        });
+        it('should reject empty strings for required fields', () => {
+            const schema = {
+                username: { type: 'string', required: true },
+            };
+            const errors = validator_1.Validator.validate({ username: '' }, schema);
+            expect(errors).toHaveLength(1);
+        });
+        it('should pass when required field is present', () => {
+            const schema = {
+                name: { type: 'string', required: true },
+            };
+            const errors = validator_1.Validator.validate({ name: 'John' }, schema);
+            expect(errors).toHaveLength(0);
+        });
+    });
+    describe('string validation', () => {
+        it('should validate string type', () => {
+            const schema = {
+                name: { type: 'string' },
+            };
+            const errors = validator_1.Validator.validate({ name: 123 }, schema);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].message).toBe('name must be a string');
+        });
+        it('should validate minimum length', () => {
+            const schema = {
+                password: { type: 'string', min: 8 },
+            };
+            const errors = validator_1.Validator.validate({ password: 'short' }, schema);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].message).toBe('password must be at least 8 characters');
+        });
+        it('should validate maximum length', () => {
+            const schema = {
+                username: { type: 'string', max: 10 },
+            };
+            const errors = validator_1.Validator.validate({ username: 'verylongusername' }, schema);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].message).toBe('username must be at most 10 characters');
+        });
+        it('should validate pattern', () => {
+            const schema = {
+                email: { type: 'string', pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/ },
+            };
+            const errors = validator_1.Validator.validate({ email: 'invalid-email' }, schema);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].message).toBe('email has invalid format');
+        });
+        it('should pass valid string', () => {
+            const schema = {
+                name: { type: 'string', min: 2, max: 50 },
+            };
+            const errors = validator_1.Validator.validate({ name: 'John Doe' }, schema);
+            expect(errors).toHaveLength(0);
+        });
+    });
+    describe('number validation', () => {
+        it('should validate number type', () => {
+            const schema = {
+                age: { type: 'number' },
+            };
+            const errors = validator_1.Validator.validate({ age: '25' }, schema);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].message).toBe('age must be a number');
+        });
+        it('should validate minimum value', () => {
+            const schema = {
+                age: { type: 'number', min: 18 },
+            };
+            const errors = validator_1.Validator.validate({ age: 16 }, schema);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].message).toBe('age must be at least 18');
+        });
+        it('should validate maximum value', () => {
+            const schema = {
+                percentage: { type: 'number', max: 100 },
+            };
+            const errors = validator_1.Validator.validate({ percentage: 150 }, schema);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].message).toBe('percentage must be at most 100');
+        });
+        it('should pass valid number', () => {
+            const schema = {
+                score: { type: 'number', min: 0, max: 100 },
+            };
+            const errors = validator_1.Validator.validate({ score: 85 }, schema);
+            expect(errors).toHaveLength(0);
+        });
+    });
+    describe('boolean validation', () => {
+        it('should validate boolean type', () => {
+            const schema = {
+                active: { type: 'boolean' },
+            };
+            const errors = validator_1.Validator.validate({ active: 'true' }, schema);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].message).toBe('active must be a boolean');
+        });
+        it('should pass valid boolean', () => {
+            const schema = {
+                active: { type: 'boolean' },
+            };
+            const errors = validator_1.Validator.validate({ active: true }, schema);
+            expect(errors).toHaveLength(0);
+        });
+    });
+    describe('object validation', () => {
+        it('should validate object type', () => {
+            const schema = {
+                user: { type: 'object' },
+            };
+            const errors = validator_1.Validator.validate({ user: 'not an object' }, schema);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].message).toBe('user must be an object');
+        });
+        it('should reject arrays as objects', () => {
+            const schema = {
+                user: { type: 'object' },
+            };
+            const errors = validator_1.Validator.validate({ user: [] }, schema);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].message).toBe('user must be an object');
+        });
+        it('should validate nested properties', () => {
+            const schema = {
+                user: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string', required: true },
+                        age: { type: 'number', min: 0 },
+                    },
+                },
+            };
+            const errors = validator_1.Validator.validate({
+                user: {
+                    age: -5,
+                },
+            }, schema);
+            expect(errors.length).toBeGreaterThan(0);
+            expect(errors.some((e) => e.field === 'name')).toBe(true);
+            expect(errors.some((e) => e.field === 'age')).toBe(true);
+        });
+        it('should pass valid nested object', () => {
+            const schema = {
+                user: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string', required: true },
+                        age: { type: 'number', min: 0 },
+                    },
+                },
+            };
+            const errors = validator_1.Validator.validate({
+                user: {
+                    name: 'John',
+                    age: 25,
+                },
+            }, schema);
+            expect(errors).toHaveLength(0);
+        });
+    });
+    describe('array validation', () => {
+        it('should validate array type', () => {
+            const schema = {
+                tags: { type: 'array' },
+            };
+            const errors = validator_1.Validator.validate({ tags: 'not an array' }, schema);
+            expect(errors).toHaveLength(1);
+            expect(errors[0].message).toBe('tags must be an array');
+        });
+        it('should validate array items', () => {
+            const schema = {
+                scores: {
+                    type: 'array',
+                    items: { type: 'number', min: 0, max: 100 },
+                },
+            };
+            const errors = validator_1.Validator.validate({ scores: [50, 150, -10] }, schema);
+            expect(errors.length).toBeGreaterThan(0);
+        });
+        it('should pass valid array', () => {
+            const schema = {
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                },
+            };
+            const errors = validator_1.Validator.validate({ tags: ['tag1', 'tag2', 'tag3'] }, schema);
+            expect(errors).toHaveLength(0);
+        });
+        it('should validate array without item schema', () => {
+            const schema = {
+                items: { type: 'array' },
+            };
+            const errors = validator_1.Validator.validate({ items: [1, 'two', true] }, schema);
+            expect(errors).toHaveLength(0);
+        });
+    });
+    describe('optional fields', () => {
+        it('should skip validation for undefined optional fields', () => {
+            const schema = {
+                name: { type: 'string', required: true },
+                age: { type: 'number' },
+            };
+            const errors = validator_1.Validator.validate({ name: 'John' }, schema);
+            expect(errors).toHaveLength(0);
+        });
+        it('should skip validation for null optional fields', () => {
+            const schema = {
+                bio: { type: 'string', max: 500 },
+            };
+            const errors = validator_1.Validator.validate({ bio: null }, schema);
+            expect(errors).toHaveLength(0);
+        });
+    });
+    describe('complex validation scenarios', () => {
+        it('should validate multiple fields with multiple errors', () => {
+            const schema = {
+                username: { type: 'string', required: true, min: 3, max: 20 },
+                email: { type: 'string', required: true, pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/ },
+                age: { type: 'number', min: 18, max: 120 },
+            };
+            const errors = validator_1.Validator.validate({
+                username: 'ab',
+                email: 'invalid',
+                age: 15,
+            }, schema);
+            expect(errors.length).toBe(3);
+        });
+        it('should validate deeply nested objects', () => {
+            const schema = {
+                profile: {
+                    type: 'object',
+                    properties: {
+                        address: {
+                            type: 'object',
+                            properties: {
+                                street: { type: 'string', required: true },
+                                city: { type: 'string', required: true },
+                            },
+                        },
+                    },
+                },
+            };
+            const errors = validator_1.Validator.validate({
+                profile: {
+                    address: {
+                        street: '123 Main St',
+                    },
+                },
+            }, schema);
+            expect(errors.some((e) => e.field === 'city')).toBe(true);
+        });
+        it('should validate arrays of objects', () => {
+            const schema = {
+                users: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', required: true },
+                            email: { type: 'string', required: true },
+                        },
+                    },
+                },
+            };
+            const errors = validator_1.Validator.validate({
+                users: [
+                    { name: 'John', email: 'john@example.com' },
+                    { name: 'Jane' }, // missing email
+                ],
+            }, schema);
+            expect(errors.length).toBeGreaterThan(0);
+        });
+    });
+});

package/dist/container.d.ts

@@ -0,0 +1,80 @@
+import { Type } from './types';
+import 'reflect-metadata';
+export declare enum Scope {
+    SINGLETON = "singleton",
+    TRANSIENT = "transient",
+    REQUEST = "request"
+}
+export type InjectionToken<T = unknown> = string | symbol | Type<T>;
+export interface Provider<T = unknown> {
+    token: InjectionToken<T>;
+    useClass?: Type<T>;
+    useValue?: T;
+    useFactory?: (...args: unknown[]) => T | Promise<T>;
+    scope?: Scope;
+    inject?: InjectionToken[];
+}
+export declare class Container {
+    private static instance;
+    private providers;
+    private requestScopedProviders;
+    private constructor();
+    static getInstance(): Container;
+    /**
+     * Create a new container instance (for testing)
+     */
+    static createTestInstance(): Container;
+    /**
+     * Register a provider with the container
+     */
+    register<T>(token: InjectionToken<T>, provider: T | Provider<T>, scope?: Scope): void;
+    /**
+     * Register a provider configuration
+     */
+    registerProvider<T>(provider: Provider<T>): void;
+    /**
+     * Resolve a dependency from the container
+     */
+    resolve<T>(token: InjectionToken<T>, requestId?: string, resolutionStack?: Set<InjectionToken>): T;
+    /**
+     * Resolve from provider metadata
+     */
+    private resolveFromMetadata;
+    /**
+     * Resolve request-scoped provider
+     */
+    private resolveRequestScoped;
+    /**
+     * Auto-resolve a class without explicit registration
+     */
+    private autoResolve;
+    /**
+     * Create instance of a class with dependency injection
+     */
+    private createInstance;
+    /**
+     * Clear request-scoped providers for a specific request
+     */
+    clearRequestScope(requestId: string): void;
+    /**
+     * Clear all providers
+     */
+    clear(): void;
+    /**
+     * Check if a token is registered
+     */
+    has(token: InjectionToken): boolean;
+    /**
+     * Get all registered tokens
+     */
+    getTokens(): InjectionToken[];
+    /**
+     * Helper to get token name for logging
+     */
+    private getTokenName;
+    /**
+     * Type guard to check if value is a Provider
+     */
+    private isProvider;
+}
+//# sourceMappingURL=container.d.ts.map

package/dist/container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"container.d.ts","sourceRoot":"","sources":["../src/container.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,kBAAkB,CAAC;AAG1B,oBAAY,KAAK;IACf,SAAS,cAAc;IACvB,SAAS,cAAc;IACvB,OAAO,YAAY;CACpB;AAED,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,OAAO,IAAI,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;AAEpE,MAAM,WAAW,QAAQ,CAAC,CAAC,GAAG,OAAO;IACnC,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,CAAC;IACzB,QAAQ,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;IACnB,QAAQ,CAAC,EAAE,CAAC,CAAC;IACb,UAAU,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IACpD,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,MAAM,CAAC,EAAE,cAAc,EAAE,CAAC;CAC3B;AASD,qBAAa,SAAS;IACpB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAY;IACnC,OAAO,CAAC,SAAS,CAAoD;IACrE,OAAO,CAAC,sBAAsB,CAAwD;IAGtF,OAAO;IAIP,MAAM,CAAC,WAAW,IAAI,SAAS;IAO/B;;OAEG;IACH,MAAM,CAAC,kBAAkB,IAAI,SAAS;IAItC;;OAEG;IACH,QAAQ,CAAC,CAAC,EACR,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,EACxB,QAAQ,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,EACzB,KAAK,GAAE,KAAuB,GAC7B,IAAI;IAcP;;OAEG;IACH,gBAAgB,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,IAAI;IAsBhD;;OAEG;IACH,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,cAAc,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,GAAG,CAAC,cAAc,CAAC,GAAG,CAAC;IA+BlG;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA4D3B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAyB5B;;OAEG;IACH,OAAO,CAAC,WAAW;IAqBnB;;OAEG;IACH,OAAO,CAAC,cAAc;IAuCtB;;OAEG;IACH,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAO1C;;OAEG;IACH,KAAK,IAAI,IAAI;IAMb;;OAEG;IACH,GAAG,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO;IAInC;;OAEG;IACH,SAAS,IAAI,cAAc,EAAE;IAI7B;;OAEG;IACH,OAAO,CAAC,YAAY;IAOpB;;OAEG;IACH,OAAO,CAAC,UAAU;CAGnB"}