@yasserkhanorg/e2e-agents 0.3.2

package/dist/custom_provider.d.ts

@@ -0,0 +1,20 @@
+import type { CustomConfig, GenerateOptions, ImageInput, LLMResponse, ProviderCapabilities } from './provider_interface.js';
+import { BaseProvider } from './base_provider.js';
+export declare class CustomProvider extends BaseProvider {
+    name: string;
+    private config;
+    capabilities: ProviderCapabilities;
+    constructor(config: CustomConfig);
+    generateText(prompt: string, options?: GenerateOptions): Promise<LLMResponse>;
+    analyzeImage(images: ImageInput[], prompt: string, options?: GenerateOptions): Promise<LLMResponse>;
+    private dispatchRequest;
+    private requestOpenAI;
+    private requestAnthropic;
+    private requestCustom;
+    streamText(): AsyncGenerator<string, void, unknown>;
+    checkHealth(): Promise<{
+        healthy: boolean;
+        message: string;
+    }>;
+}
+//# sourceMappingURL=custom_provider.d.ts.map

package/dist/custom_provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom_provider.d.ts","sourceRoot":"","sources":["../src/custom_provider.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACR,YAAY,EACZ,eAAe,EACf,UAAU,EACV,WAAW,EACX,oBAAoB,EACvB,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AA6DhD,qBAAa,cAAe,SAAQ,YAAY;IAC5C,IAAI,SAAY;IAChB,OAAO,CAAC,MAAM,CAAe;IAE7B,YAAY,EAAE,oBAAoB,CAAC;gBAEvB,MAAM,EAAE,YAAY;IAyB1B,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;IAkC7E,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,WAAW,CAAC;YAyC3F,eAAe;YAiBf,aAAa;YA8Eb,gBAAgB;YA6EhB,aAAa;IAqBpB,UAAU,IAAI,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC;IAKpD,WAAW,IAAI,OAAO,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAAC;CAOpE"}

package/dist/custom_provider.js

@@ -0,0 +1,276 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomProvider = void 0;
+const provider_interface_js_1 = require("./provider_interface.js");
+const provider_utils_js_1 = require("./provider_utils.js");
+const base_provider_js_1 = require("./base_provider.js");
+const logger_js_1 = require("./logger.js");
+function normalizeUrl(baseUrl, pathSuffix) {
+    const trimmed = baseUrl.replace(/\/+$/, '');
+    if (trimmed.endsWith(pathSuffix)) {
+        return trimmed;
+    }
+    return `${trimmed}${pathSuffix}`;
+}
+async function postJson(url, headers, body, timeoutMs, context) {
+    const controller = new AbortController();
+    const timer = timeoutMs ? setTimeout(() => controller.abort(), timeoutMs) : undefined;
+    try {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                ...headers,
+            },
+            body: JSON.stringify(body),
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error(`Request timeout (${context})`);
+        }
+        throw error;
+    }
+    finally {
+        if (timer) {
+            clearTimeout(timer);
+        }
+    }
+}
+class CustomProvider extends base_provider_js_1.BaseProvider {
+    constructor(config) {
+        super();
+        this.name = 'custom';
+        const validation = (0, provider_utils_js_1.validateAndSanitizeUrl)(config.baseUrl);
+        if (!validation.valid) {
+            throw new Error(`Invalid base URL: ${validation.warning}`);
+        }
+        if (validation.warning) {
+            logger_js_1.logger.warn(`HTTPS required for remote URLs: ${validation.warning}`);
+        }
+        this.config = config;
+        this.capabilities = {
+            vision: config.requestFormat !== 'custom',
+            streaming: false,
+            maxTokens: 0,
+            costPer1MInputTokens: 0,
+            costPer1MOutputTokens: 0,
+            supportsTools: false,
+            supportsPromptCaching: false,
+            typicalResponseTimeMs: 0,
+        };
+    }
+    async generateText(prompt, options) {
+        const startTime = Date.now();
+        try {
+            if (prompt.length > 10 * 1024 * 1024) {
+                throw new Error('Prompt exceeds maximum size (10MB)');
+            }
+            const response = await this.dispatchRequest(prompt, options);
+            const responseTime = Date.now() - startTime;
+            const text = response.text;
+            const usage = response.usage;
+            const cost = response.cost;
+            this.updateStats(usage, responseTime, cost);
+            return {
+                text,
+                usage,
+                cost,
+                metadata: response.metadata,
+            };
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new provider_interface_js_1.LLMProviderError((0, provider_utils_js_1.sanitizeErrorMessage)(error, 'generateText'), this.name, undefined, error);
+        }
+    }
+    async analyzeImage(images, prompt, options) {
+        if (this.config.requestFormat === 'custom') {
+            throw new provider_interface_js_1.UnsupportedCapabilityError(this.name, 'vision');
+        }
+        const startTime = Date.now();
+        try {
+            if (images.length === 0 || images.length > 20) {
+                throw new Error('Image count must be between 1 and 20');
+            }
+            if (prompt.length > 10 * 1024 * 1024) {
+                throw new Error('Prompt exceeds maximum size (10MB)');
+            }
+            const response = await this.dispatchRequest(prompt, options, images);
+            const responseTime = Date.now() - startTime;
+            const text = response.text;
+            const usage = response.usage;
+            const cost = response.cost;
+            this.updateStats(usage, responseTime, cost);
+            return {
+                text,
+                usage,
+                cost,
+                metadata: response.metadata,
+            };
+        }
+        catch (error) {
+            this.stats.failedRequests++;
+            throw new provider_interface_js_1.LLMProviderError((0, provider_utils_js_1.sanitizeErrorMessage)(error, 'analyzeImage'), this.name, undefined, error);
+        }
+    }
+    async dispatchRequest(prompt, options, images) {
+        switch (this.config.requestFormat) {
+            case 'openai':
+                return this.requestOpenAI(prompt, options, images);
+            case 'anthropic':
+                return this.requestAnthropic(prompt, options, images);
+            case 'custom':
+                return this.requestCustom(prompt, options);
+            default:
+                throw new Error(`Unsupported request format: ${this.config.requestFormat}`);
+        }
+    }
+    async requestOpenAI(prompt, options, images) {
+        const url = normalizeUrl(this.config.baseUrl, '/chat/completions');
+        const messages = [];
+        if (options?.systemPrompt) {
+            messages.push({ role: 'system', content: options.systemPrompt });
+        }
+        if (images && images.length > 0) {
+            const content = [
+                { type: 'text', text: prompt },
+            ];
+            for (const image of images) {
+                const mediaType = (image.mimeType || image.mediaType || 'image/png');
+                if (!['image/png', 'image/jpeg', 'image/webp'].includes(mediaType)) {
+                    throw new Error(`Unsupported image type: ${mediaType}`);
+                }
+                const data = image.data || image.base64 || '';
+                if (data.length > 20 * 1024 * 1024) {
+                    throw new Error('Image data exceeds maximum size (20MB)');
+                }
+                content.push({
+                    type: 'image_url',
+                    image_url: { url: `data:${mediaType};base64,${data}` },
+                });
+                if (image.description) {
+                    content.push({ type: 'text', text: `[Image: ${image.description}]` });
+                }
+            }
+            messages.push({ role: 'user', content });
+        }
+        else {
+            messages.push({ role: 'user', content: prompt });
+        }
+        const body = {
+            model: this.config.model,
+            messages,
+            max_tokens: options?.maxTokens,
+            temperature: options?.temperature,
+            top_p: options?.topP,
+            stop: options?.stopSequences,
+        };
+        const response = await postJson(url, this.config.auth, body, options?.timeout, 'openai');
+        const text = response.choices?.[0]?.message?.content || '';
+        const usage = {
+            inputTokens: response.usage?.prompt_tokens || 0,
+            outputTokens: response.usage?.completion_tokens || 0,
+            totalTokens: response.usage?.total_tokens || 0,
+        };
+        return {
+            text,
+            usage,
+            cost: 0,
+            metadata: {
+                finishReason: response.choices?.[0]?.finish_reason,
+            },
+        };
+    }
+    async requestAnthropic(prompt, options, images) {
+        const url = normalizeUrl(this.config.baseUrl, '/messages');
+        const content = [
+            { type: 'text', text: prompt },
+        ];
+        if (images && images.length > 0) {
+            for (const image of images) {
+                const mediaType = (image.mimeType || image.mediaType || 'image/png');
+                if (!['image/png', 'image/jpeg', 'image/webp', 'image/gif'].includes(mediaType)) {
+                    throw new Error(`Unsupported image type: ${mediaType}`);
+                }
+                const data = image.data || image.base64 || '';
+                if (data.length > 20 * 1024 * 1024) {
+                    throw new Error('Image data exceeds maximum size (20MB)');
+                }
+                content.push({
+                    type: 'image',
+                    source: {
+                        type: 'base64',
+                        media_type: mediaType,
+                        data,
+                    },
+                });
+                if (image.description) {
+                    content.push({ type: 'text', text: `[Image: ${image.description}]` });
+                }
+            }
+        }
+        const body = {
+            model: this.config.model,
+            max_tokens: options?.maxTokens || 4000,
+            temperature: options?.temperature,
+            top_p: options?.topP,
+            stop_sequences: options?.stopSequences,
+            system: options?.systemPrompt,
+            messages: [
+                {
+                    role: 'user',
+                    content,
+                },
+            ],
+        };
+        const response = await postJson(url, this.config.auth, body, options?.timeout, 'anthropic');
+        const text = (response.content || []).map((block) => block.text).join('\n');
+        const usage = {
+            inputTokens: response.usage?.input_tokens || 0,
+            outputTokens: response.usage?.output_tokens || 0,
+            totalTokens: (response.usage?.input_tokens || 0) + (response.usage?.output_tokens || 0),
+        };
+        return {
+            text,
+            usage,
+            cost: 0,
+            metadata: {
+                stopReason: response.stop_reason,
+            },
+        };
+    }
+    async requestCustom(prompt, options) {
+        if (!this.config.transformRequest || !this.config.transformResponse) {
+            throw new Error('Custom providers require transformRequest and transformResponse');
+        }
+        const body = this.config.transformRequest(prompt, options);
+        const response = await postJson(this.config.baseUrl, this.config.auth, body, options?.timeout, 'custom');
+        const transformed = this.config.transformResponse(response);
+        return {
+            text: transformed.text,
+            usage: transformed.usage,
+            cost: transformed.cost,
+            metadata: transformed.metadata,
+        };
+    }
+    // CustomProvider doesn't support streaming
+    async *streamText() {
+        throw new Error('Streaming not supported for custom providers');
+    }
+    // CustomProvider doesn't have built-in health checks
+    async checkHealth() {
+        return {
+            healthy: true,
+            message: 'Custom provider configured',
+        };
+    }
+}
+exports.CustomProvider = CustomProvider;

package/dist/e2e-test-gen/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Autonomous E2E Testing System
+ *
+ * A specification-driven testing system that bridges PDF/Markdown specs
+ * with Playwright's native agents for test planning, generation, and healing.
+ *
+ * Quick Start:
+ * ```typescript
+ * import {SpecBridge, createAnthropicBridge} from '@mattermost/playwright-lib/autonomous';
+ *
+ * // Convert a specification to Playwright-compatible markdown
+ * const bridge = createAnthropicBridge(process.env.ANTHROPIC_API_KEY);
+ * const result = await bridge.convertToPlaywrightSpecs('spec.pdf', 'specs/');
+ *
+ * // Then use Playwright agents:
+ * // @planner explore http://localhost:8065
+ * // @generator create tests from specs/
+ * // @healer fix failing tests
+ * ```
+ *
+ * Architecture:
+ * - SpecificationParser: Parses PDF/MD/JSON specs into structured format
+ * - SpecBridge: Converts specs to Playwright Agent-compatible markdown
+ * - LLM Providers: Pluggable AI providers (Anthropic, Ollama, OpenAI)
+ *
+ * The heavy lifting (test generation, execution, healing) is delegated to
+ * Playwright's built-in agents which are production-ready and maintained
+ * by the Playwright team.
+ */
+export { SpecificationParser } from './spec_parser.js';
+export type { SpecSummary, SpecificationCache } from './spec_parser.js';
+export { LLMProviderFactory } from '../provider_factory.js';
+export { OllamaProvider } from '../ollama_provider.js';
+export { AnthropicProvider } from '../anthropic_provider.js';
+export type { LLMProvider, LLMResponse, GenerateOptions, ImageInput, ProviderCapabilities, ProviderUsageStats, ProviderConfig, OllamaConfig, AnthropicConfig, } from '../provider_interface.js';
+export type { HybridConfig } from '../provider_factory.js';
+export type { FeatureSpecification, BusinessScenario, SpecScreenshot, GeneratedTest, } from './types.js';
+/**
+ * Version info
+ */
+export declare const VERSION = "2.0.0";
+export declare const SUPPORTED_PLAYWRIGHT_VERSION = "1.56.0";
+/**
+ * Feature flags
+ */
+export declare const FEATURES: {
+    readonly LLM_AGNOSTIC: true;
+    readonly SPECIFICATION_DRIVEN: true;
+    readonly PLAYWRIGHT_AGENTS: true;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/e2e-test-gen/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/e2e-test-gen/index.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,EAAC,mBAAmB,EAAC,MAAM,kBAAkB,CAAC;AACrD,YAAY,EAAC,WAAW,EAAE,kBAAkB,EAAC,MAAM,kBAAkB,CAAC;AAGtE,OAAO,EAAC,kBAAkB,EAAC,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAC,cAAc,EAAC,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAC,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAE3D,YAAY,EACR,WAAW,EACX,WAAW,EACX,eAAe,EACf,UAAU,EACV,oBAAoB,EACpB,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,eAAe,GAClB,MAAM,0BAA0B,CAAC;AAClC,YAAY,EAAC,YAAY,EAAC,MAAM,wBAAwB,CAAC;AAGzD,YAAY,EAER,oBAAoB,EACpB,gBAAgB,EAChB,cAAc,EAGd,aAAa,GAChB,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,eAAO,MAAM,OAAO,UAAU,CAAC;AAC/B,eAAO,MAAM,4BAA4B,WAAW,CAAC;AAErD;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;CAIX,CAAC"}

package/dist/e2e-test-gen/index.js

@@ -0,0 +1,57 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FEATURES = exports.SUPPORTED_PLAYWRIGHT_VERSION = exports.VERSION = exports.AnthropicProvider = exports.OllamaProvider = exports.LLMProviderFactory = exports.SpecificationParser = void 0;
+/**
+ * Autonomous E2E Testing System
+ *
+ * A specification-driven testing system that bridges PDF/Markdown specs
+ * with Playwright's native agents for test planning, generation, and healing.
+ *
+ * Quick Start:
+ * ```typescript
+ * import {SpecBridge, createAnthropicBridge} from '@mattermost/playwright-lib/autonomous';
+ *
+ * // Convert a specification to Playwright-compatible markdown
+ * const bridge = createAnthropicBridge(process.env.ANTHROPIC_API_KEY);
+ * const result = await bridge.convertToPlaywrightSpecs('spec.pdf', 'specs/');
+ *
+ * // Then use Playwright agents:
+ * // @planner explore http://localhost:8065
+ * // @generator create tests from specs/
+ * // @healer fix failing tests
+ * ```
+ *
+ * Architecture:
+ * - SpecificationParser: Parses PDF/MD/JSON specs into structured format
+ * - SpecBridge: Converts specs to Playwright Agent-compatible markdown
+ * - LLM Providers: Pluggable AI providers (Anthropic, Ollama, OpenAI)
+ *
+ * The heavy lifting (test generation, execution, healing) is delegated to
+ * Playwright's built-in agents which are production-ready and maintained
+ * by the Playwright team.
+ */
+// Core Components
+var spec_parser_js_1 = require("./spec_parser.js");
+Object.defineProperty(exports, "SpecificationParser", { enumerable: true, get: function () { return spec_parser_js_1.SpecificationParser; } });
+// LLM Providers (re-exported from parent package)
+var provider_factory_js_1 = require("../provider_factory.js");
+Object.defineProperty(exports, "LLMProviderFactory", { enumerable: true, get: function () { return provider_factory_js_1.LLMProviderFactory; } });
+var ollama_provider_js_1 = require("../ollama_provider.js");
+Object.defineProperty(exports, "OllamaProvider", { enumerable: true, get: function () { return ollama_provider_js_1.OllamaProvider; } });
+var anthropic_provider_js_1 = require("../anthropic_provider.js");
+Object.defineProperty(exports, "AnthropicProvider", { enumerable: true, get: function () { return anthropic_provider_js_1.AnthropicProvider; } });
+/**
+ * Version info
+ */
+exports.VERSION = '2.0.0';
+exports.SUPPORTED_PLAYWRIGHT_VERSION = '1.56.0';
+/**
+ * Feature flags
+ */
+exports.FEATURES = {
+    LLM_AGNOSTIC: true,
+    SPECIFICATION_DRIVEN: true,
+    PLAYWRIGHT_AGENTS: true,
+};

package/dist/e2e-test-gen/spec_parser.d.ts

@@ -0,0 +1,142 @@
+import type { LLMProvider } from '../provider_interface.js';
+import type { FeatureSpecification } from './types.js';
+/**
+ * Optional cache interface for PDF parsing results
+ * Implementations can provide caching to avoid re-parsing PDFs
+ */
+export interface SpecificationCache {
+    isSpecificationCached(path: string, hash: string): boolean;
+    getCachedSpecifications(path: string, hash: string): FeatureSpecification[];
+    saveSpecification(spec: FeatureSpecification): void;
+}
+/**
+ * Specification Parser
+ *
+ * Parses user-provided specification documents to guide autonomous testing.
+ * Supports multiple formats:
+ * - Markdown (.md) with embedded screenshots and Given-When-Then scenarios
+ * - JSON (.json) with structured feature definitions
+ * - PDF (.pdf) with text, diagrams, and screenshots extracted via LLM
+ * - Plain text focus strings (natural language)
+ *
+ * Extracts:
+ * - Feature name, description, priority
+ * - Target URLs to prioritize in crawling
+ * - Business scenarios (Given-When-Then)
+ * - Acceptance criteria
+ * - Reference screenshots for visual comparison
+ * - UI mockups and wireframes from PDFs
+ *
+ * The parsed specifications guide:
+ * - Crawler URL prioritization
+ * - Test scenario generation
+ * - Visual regression comparison
+ * - Coverage gap detection
+ */
+export declare class SpecificationParser {
+    private llmProvider;
+    private cache?;
+    constructor(llmProvider: LLMProvider, cache?: SpecificationCache);
+    /**
+     * Parse specification from file or string
+     */
+    parse(source: string, sourceType?: 'file' | 'string'): Promise<FeatureSpecification[]>;
+    /**
+     * Parse Markdown specification
+     *
+     * Expected format:
+     * # Feature: Feature Name
+     * **Priority**: High
+     * **Target URLs**: /path1, /path2
+     *
+     * ## Description
+     * Feature description...
+     *
+     * ## Business Scenarios
+     * ### Scenario 1: Name
+     * - **Given**: Precondition
+     * - **When**: Action
+     * - **Then**: Expected outcome
+     *
+     * ## Acceptance Criteria
+     * - Criterion 1
+     * - Criterion 2
+     *
+     * ## Screenshots
+     * ![Description](path/to/image.png)
+     */
+    private parseMarkdown;
+    /**
+     * Parse JSON specification
+     */
+    private parseJSON;
+    /**
+     * Parse PDF specification using LLM vision
+     *
+     * PDFs can contain:
+     * - Product requirement documents (PRDs)
+     * - Feature specifications with screenshots
+     * - UI mockups and wireframes
+     * - User flow diagrams
+     * - Acceptance criteria and test plans
+     *
+     * The LLM will extract structured information including:
+     * - Feature name and description
+     * - Business scenarios
+     * - Target URLs (inferred from screenshots/mockups)
+     * - Acceptance criteria
+     * - Screenshots/mockups for visual comparison
+     */
+    private parsePDF;
+    /**
+     * Parse natural language focus string using LLM
+     */
+    private parseFocusString;
+    /**
+     * Finalize partial spec
+     */
+    private finalizeSpec;
+    /**
+     * Finalize partial scenario
+     */
+    private finalizeScenario;
+    /**
+     * Generate spec ID from name
+     */
+    private generateSpecId;
+    /**
+     * Resolve image path relative to spec file
+     */
+    private resolveImagePath;
+    /**
+     * Load screenshot data from files
+     */
+    private loadScreenshots;
+    /**
+     * Validate parsed specification
+     */
+    validateSpec(spec: FeatureSpecification): {
+        valid: boolean;
+        errors: string[];
+    };
+    /**
+     * Get spec coverage summary
+     */
+    getSpecSummary(spec: FeatureSpecification): SpecSummary;
+}
+/**
+ * Specification summary
+ */
+export interface SpecSummary {
+    id: string;
+    name: string;
+    priority: string;
+    targetUrlCount: number;
+    scenarioCount: number;
+    mustHaveScenarios: number;
+    shouldHaveScenarios: number;
+    niceToHaveScenarios: number;
+    acceptanceCriteriaCount: number;
+    hasScreenshots: boolean;
+}
+//# sourceMappingURL=spec_parser.d.ts.map

package/dist/e2e-test-gen/spec_parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec_parser.d.ts","sourceRoot":"","sources":["../../src/e2e-test-gen/spec_parser.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,0BAA0B,CAAC;AAE1D,OAAO,KAAK,EAAmB,oBAAoB,EAAiB,MAAM,YAAY,CAAC;AAEvF;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IAC/B,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAC3D,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,oBAAoB,EAAE,CAAC;IAC5E,iBAAiB,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAAC;CACvD;AASD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,mBAAmB;IAC5B,OAAO,CAAC,WAAW,CAAc;IACjC,OAAO,CAAC,KAAK,CAAC,CAAqB;gBAEvB,WAAW,EAAE,WAAW,EAAE,KAAK,CAAC,EAAE,kBAAkB;IAKhE;;OAEG;IACG,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,GAAE,MAAM,GAAG,QAAiB,GAAG,OAAO,CAAC,oBAAoB,EAAE,CAAC;IA6BpG;;;;;;;;;;;;;;;;;;;;;;;OAuBG;YACW,aAAa;IAyI3B;;OAEG;IACH,OAAO,CAAC,SAAS;IAgFjB;;;;;;;;;;;;;;;;OAgBG;YACW,QAAQ;IA8TtB;;OAEG;YACW,gBAAgB;IA8E9B;;OAEG;IACH,OAAO,CAAC,YAAY;IAcpB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAUxB;;OAEG;IACH,OAAO,CAAC,cAAc;IAOtB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAcxB;;OAEG;YACW,eAAe;IAmB7B;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,oBAAoB,GAAG;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAA;KAAC;IAwB5E;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,oBAAoB,GAAG,WAAW;CAc1D;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,mBAAmB,EAAE,MAAM,CAAC;IAC5B,uBAAuB,EAAE,MAAM,CAAC;IAChC,cAAc,EAAE,OAAO,CAAC;CAC3B"}