@yasserkhanorg/e2e-agents 0.3.2

package/dist/agent/spec-builder.js

@@ -0,0 +1,273 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpecBridge = void 0;
+exports.createAnthropicBridge = createAnthropicBridge;
+exports.createOllamaBridge = createOllamaBridge;
+/**
+ * Spec Bridge - Bridge between PDF specs and Playwright Agent workflow
+ *
+ * This module converts specification documents (PDF, Markdown, JSON) into
+ * Playwright-compatible markdown files that can be consumed by Playwright's
+ * native agents (Planner, Generator, Healer).
+ *
+ * Flow: PDF → SpecParser → Markdown specs → Playwright Planner
+ *
+ * The Playwright agents (available in Playwright 1.56+) provide production-ready:
+ * - Test planning and exploration
+ * - Test code generation
+ * - Automatic test healing
+ *
+ * Usage:
+ * ```typescript
+ * const bridge = new SpecBridge({type: 'anthropic', apiKey: process.env.ANTHROPIC_API_KEY});
+ * const specPaths = await bridge.convertToPlaywrightSpecs('spec.pdf', 'specs/');
+ * // Now use Playwright agents: @planner, @generator, @healer
+ * ```
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const provider_factory_js_1 = require("../provider_factory.js");
+const spec_parser_js_1 = require("../e2e-test-gen/spec_parser.js");
+/**
+ * Bridge between PDF/JSON specs and Playwright Agent workflow
+ *
+ * Converts specification documents into Playwright-compatible markdown
+ * that can be consumed by Playwright's native agents.
+ */
+class SpecBridge {
+    constructor(config) {
+        // Handle both single provider and hybrid config
+        let llmProvider;
+        if ('primary' in config.llmConfig) {
+            // It's a HybridConfig
+            llmProvider = provider_factory_js_1.LLMProviderFactory.createHybrid(config.llmConfig);
+        }
+        else {
+            // It's a ProviderConfig
+            llmProvider = provider_factory_js_1.LLMProviderFactory.create(config.llmConfig);
+        }
+        this.parser = new spec_parser_js_1.SpecificationParser(llmProvider);
+        this.outputDir = config.outputDir || 'specs';
+        this.overwrite = config.overwrite !== false;
+    }
+    /**
+     * Convert a specification file to Playwright-compatible markdown specs
+     *
+     * @param inputPath - Path to the input specification (PDF, MD, or JSON)
+     * @param outputDir - Optional override for output directory
+     * @returns Conversion result with paths and metadata
+     */
+    async convertToPlaywrightSpecs(inputPath, outputDir) {
+        /* eslint-disable no-console */
+        const targetDir = outputDir || this.outputDir;
+        const warnings = [];
+        console.log(`Converting specification: ${inputPath}`);
+        // Parse the specification
+        const specs = await this.parser.parse(inputPath, 'file');
+        if (specs.length === 0) {
+            warnings.push('No features extracted from specification');
+            return {
+                specPaths: [],
+                features: [],
+                totalScenarios: 0,
+                warnings,
+            };
+        }
+        // Create output directory
+        (0, fs_1.mkdirSync)(targetDir, { recursive: true });
+        const specPaths = [];
+        let totalScenarios = 0;
+        for (const spec of specs) {
+            // Validate the spec
+            const validation = this.parser.validateSpec(spec);
+            if (!validation.valid) {
+                warnings.push(`Feature "${spec.name}": ${validation.errors.join(', ')}`);
+            }
+            // Convert to Playwright markdown format
+            const markdown = this.toPlaywrightMarkdown(spec);
+            // Generate output filename
+            const filename = `${spec.id}.md`;
+            const outputPath = (0, path_1.join)(targetDir, filename);
+            // Check for existing file
+            if ((0, fs_1.existsSync)(outputPath) && !this.overwrite) {
+                warnings.push(`Skipping existing file: ${outputPath}`);
+                continue;
+            }
+            // Write the spec file
+            (0, fs_1.writeFileSync)(outputPath, markdown, 'utf-8');
+            specPaths.push(outputPath);
+            totalScenarios += spec.scenarios.length;
+            console.log(`  Created: ${outputPath} (${spec.scenarios.length} scenarios)`);
+        }
+        console.log(`Converted ${specs.length} feature(s) with ${totalScenarios} scenario(s)`);
+        /* eslint-enable no-console */
+        return {
+            specPaths,
+            features: specs,
+            totalScenarios,
+            warnings,
+        };
+    }
+    /**
+     * Convert a FeatureSpecification to Playwright Agent markdown format
+     *
+     * The format is designed to be consumed by Playwright's Planner and Generator agents.
+     * It includes structured test scenarios in Given-When-Then format.
+     */
+    toPlaywrightMarkdown(spec) {
+        const lines = [];
+        // Header
+        lines.push(`# ${spec.name}`);
+        lines.push('');
+        // Metadata
+        lines.push(`**Priority**: ${spec.priority}`);
+        if (spec.targetUrls.length > 0) {
+            lines.push(`**Target URLs**: ${spec.targetUrls.join(', ')}`);
+        }
+        lines.push('');
+        // Description
+        if (spec.description) {
+            lines.push('## Description');
+            lines.push('');
+            lines.push(spec.description);
+            lines.push('');
+        }
+        // Test Scenarios
+        if (spec.scenarios.length > 0) {
+            lines.push('## Test Scenarios');
+            lines.push('');
+            for (const scenario of spec.scenarios) {
+                lines.push(this.formatScenario(scenario));
+                lines.push('');
+            }
+        }
+        // Acceptance Criteria
+        if (spec.acceptanceCriteria.length > 0) {
+            lines.push('## Acceptance Criteria');
+            lines.push('');
+            for (const criterion of spec.acceptanceCriteria) {
+                lines.push(`- ${criterion}`);
+            }
+            lines.push('');
+        }
+        // Screenshots reference (if any)
+        if (spec.screenshots.length > 0) {
+            lines.push('## Reference Screenshots');
+            lines.push('');
+            for (const screenshot of spec.screenshots) {
+                lines.push(`- ${screenshot.description}: \`${screenshot.path}\``);
+            }
+            lines.push('');
+        }
+        // Metadata footer
+        lines.push('---');
+        lines.push(`*Generated from: ${(0, path_1.basename)(spec.sourcePath)}*`);
+        lines.push(`*Feature ID: ${spec.id}*`);
+        return lines.join('\n');
+    }
+    /**
+     * Format a business scenario in Playwright-friendly markdown
+     */
+    formatScenario(scenario) {
+        const lines = [];
+        lines.push(`### ${scenario.name}`);
+        lines.push('');
+        lines.push(`**Priority**: ${scenario.priority}`);
+        lines.push('');
+        if (scenario.given) {
+            lines.push(`**Given**: ${scenario.given}`);
+        }
+        if (scenario.when) {
+            lines.push(`**When**: ${scenario.when}`);
+        }
+        if (scenario.then) {
+            lines.push(`**Then**: ${scenario.then}`);
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Parse a spec file without writing output
+     * Useful for validation or inspection
+     */
+    async parseSpec(inputPath) {
+        return this.parser.parse(inputPath, 'file');
+    }
+    /**
+     * Validate a specification file
+     */
+    async validateSpec(inputPath) {
+        const specs = await this.parser.parse(inputPath, 'file');
+        const allErrors = [];
+        let totalScenarios = 0;
+        for (const spec of specs) {
+            const validation = this.parser.validateSpec(spec);
+            if (!validation.valid) {
+                allErrors.push(...validation.errors.map((e) => `${spec.name}: ${e}`));
+            }
+            totalScenarios += spec.scenarios.length;
+        }
+        return {
+            valid: allErrors.length === 0,
+            errors: allErrors,
+            features: specs.length,
+            scenarios: totalScenarios,
+        };
+    }
+    /**
+     * Get a summary of the specification
+     */
+    async getSpecSummary(inputPath) {
+        const specs = await this.parser.parse(inputPath, 'file');
+        const lines = [];
+        lines.push(`Specification Summary: ${(0, path_1.basename)(inputPath)}`);
+        lines.push('='.repeat(50));
+        lines.push('');
+        for (const spec of specs) {
+            const summary = this.parser.getSpecSummary(spec);
+            lines.push(`Feature: ${summary.name}`);
+            lines.push(`  Priority: ${summary.priority}`);
+            lines.push(`  Scenarios: ${summary.scenarioCount}`);
+            lines.push(`    - Must-have: ${summary.mustHaveScenarios}`);
+            lines.push(`    - Should-have: ${summary.shouldHaveScenarios}`);
+            lines.push(`    - Nice-to-have: ${summary.niceToHaveScenarios}`);
+            lines.push(`  Acceptance Criteria: ${summary.acceptanceCriteriaCount}`);
+            lines.push(`  Has Screenshots: ${summary.hasScreenshots ? 'Yes' : 'No'}`);
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+}
+exports.SpecBridge = SpecBridge;
+/**
+ * Create a SpecBridge with Anthropic provider
+ * Convenience function for common use case
+ */
+function createAnthropicBridge(apiKey, outputDir) {
+    return new SpecBridge({
+        llmConfig: {
+            type: 'anthropic',
+            config: {
+                apiKey: apiKey || process.env.ANTHROPIC_API_KEY || '',
+            },
+        },
+        outputDir,
+    });
+}
+/**
+ * Create a SpecBridge with Ollama provider (free, local)
+ * Convenience function for local development
+ */
+function createOllamaBridge(model, outputDir) {
+    return new SpecBridge({
+        llmConfig: {
+            type: 'ollama',
+            config: {
+                model: model || 'deepseek-r1:7b',
+                baseUrl: process.env.OLLAMA_BASE_URL || 'http://localhost:11434',
+            },
+        },
+        outputDir,
+    });
+}

package/dist/agent/subsystem_risk.d.ts

@@ -0,0 +1,23 @@
+import type { SubsystemRiskImpactConfig } from './config.js';
+export type RiskPriority = 'P0' | 'P1' | 'P2';
+export interface SubsystemRiskRuleMatch {
+    ruleId: string;
+    scoreDelta: number;
+    priorityFloor?: RiskPriority;
+    reasons: string[];
+    keywords: string[];
+}
+export interface SubsystemRiskMapInfo {
+    source: 'map';
+    enabled: boolean;
+    mapPath: string;
+    mapFound: boolean;
+    rulesLoaded: number;
+}
+export interface SubsystemRiskResolver {
+    info: SubsystemRiskMapInfo;
+    warnings: string[];
+    matchFile: (relativePath: string) => SubsystemRiskRuleMatch[];
+}
+export declare function loadSubsystemRiskResolver(config: SubsystemRiskImpactConfig): SubsystemRiskResolver;
+//# sourceMappingURL=subsystem_risk.d.ts.map

package/dist/agent/subsystem_risk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subsystem_risk.d.ts","sourceRoot":"","sources":["../../src/agent/subsystem_risk.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,yBAAyB,EAAC,MAAM,aAAa,CAAC;AAG3D,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AA2B9C,MAAM,WAAW,sBAAsB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,YAAY,CAAC;IAC7B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,oBAAoB;IACjC,MAAM,EAAE,KAAK,CAAC;IACd,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,qBAAqB;IAClC,IAAI,EAAE,oBAAoB,CAAC;IAC3B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,SAAS,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,sBAAsB,EAAE,CAAC;CACjE;AAyGD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,yBAAyB,GAAG,qBAAqB,CAuHlG"}

package/dist/agent/subsystem_risk.js

@@ -0,0 +1,207 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSubsystemRiskResolver = loadSubsystemRiskResolver;
+const fs_1 = require("fs");
+const utils_js_1 = require("./utils.js");
+const PRIORITY_RANK = {
+    P0: 0,
+    P1: 1,
+    P2: 2,
+};
+function coerceNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+function normalizePriority(value) {
+    if (value === 'P0' || value === 'P1' || value === 'P2') {
+        return value;
+    }
+    return undefined;
+}
+function parseStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .filter((item) => typeof item === 'string')
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function parsePathArray(value) {
+    return parseStringArray(value).map((item) => (0, utils_js_1.normalizePath)(item));
+}
+function parseKeywords(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return Array.from(new Set(value
+        .filter((item) => typeof item === 'string')
+        .map((item) => item.trim().toLowerCase())
+        .filter(Boolean)));
+}
+function parseRules(rawRules, warnings) {
+    if (!Array.isArray(rawRules)) {
+        warnings.push('Subsystem risk map has no "rules" array.');
+        return [];
+    }
+    const parsed = [];
+    for (let i = 0; i < rawRules.length; i += 1) {
+        const rawRule = rawRules[i];
+        if (!rawRule || typeof rawRule !== 'object') {
+            continue;
+        }
+        const patterns = parsePathArray(rawRule.patterns);
+        if (patterns.length === 0) {
+            warnings.push(`Subsystem risk rule at index ${i} has no valid patterns and was skipped.`);
+            continue;
+        }
+        const id = typeof rawRule.id === 'string' && rawRule.id.trim()
+            ? rawRule.id.trim()
+            : `rule-${i + 1}`;
+        const description = typeof rawRule.description === 'string' ? rawRule.description.trim() : undefined;
+        const reasons = parseStringArray(rawRule.reasons);
+        const keywords = parseKeywords(rawRule.keywords);
+        const scoreDelta = coerceNumber(rawRule.scoreDelta) ?? 0;
+        const priorityFloor = normalizePriority(rawRule.priorityFloor);
+        const normalizedReasons = reasons.length > 0
+            ? reasons
+            : (description ? [description] : []);
+        parsed.push({
+            id,
+            description,
+            patterns,
+            scoreDelta,
+            priorityFloor,
+            reasons: normalizedReasons,
+            keywords,
+        });
+    }
+    return parsed;
+}
+function comparePriority(a, b) {
+    return PRIORITY_RANK[a] <= PRIORITY_RANK[b] ? a : b;
+}
+function loadSubsystemRiskResolver(config) {
+    const mapPath = (0, utils_js_1.normalizePath)(config.mapPath);
+    const warnings = [];
+    if (!config.enabled) {
+        return {
+            info: {
+                source: 'map',
+                enabled: false,
+                mapPath,
+                mapFound: false,
+                rulesLoaded: 0,
+            },
+            warnings,
+            matchFile: () => [],
+        };
+    }
+    if (!(0, fs_1.existsSync)(config.mapPath)) {
+        warnings.push(`Subsystem risk map file not found: ${config.mapPath}`);
+        return {
+            info: {
+                source: 'map',
+                enabled: true,
+                mapPath,
+                mapFound: false,
+                rulesLoaded: 0,
+            },
+            warnings,
+            matchFile: () => [],
+        };
+    }
+    let raw;
+    try {
+        raw = JSON.parse((0, fs_1.readFileSync)(config.mapPath, 'utf-8'));
+    }
+    catch {
+        warnings.push(`Subsystem risk map is invalid JSON: ${config.mapPath}`);
+        return {
+            info: {
+                source: 'map',
+                enabled: true,
+                mapPath,
+                mapFound: true,
+                rulesLoaded: 0,
+            },
+            warnings,
+            matchFile: () => [],
+        };
+    }
+    const rules = parseRules(raw.rules, warnings);
+    if (rules.length === 0) {
+        warnings.push(`Subsystem risk map loaded but no valid rules were found: ${config.mapPath}`);
+    }
+    const maxRules = Math.max(1, Math.round(config.maxRulesPerFile));
+    return {
+        info: {
+            source: 'map',
+            enabled: true,
+            mapPath,
+            mapFound: true,
+            rulesLoaded: rules.length,
+        },
+        warnings,
+        matchFile: (relativePath) => {
+            const normalizedPath = (0, utils_js_1.normalizePath)(relativePath);
+            const matches = [];
+            for (const rule of rules) {
+                const matched = rule.patterns.some((pattern) => (0, utils_js_1.matchGlob)(normalizedPath, pattern));
+                if (!matched) {
+                    continue;
+                }
+                const reasons = rule.reasons.length > 0
+                    ? rule.reasons
+                    : [`Subsystem risk rule matched: ${rule.id}`];
+                matches.push({
+                    ruleId: rule.id,
+                    scoreDelta: rule.scoreDelta,
+                    priorityFloor: rule.priorityFloor,
+                    reasons,
+                    keywords: rule.keywords,
+                    priorityRank: rule.priorityFloor ? PRIORITY_RANK[rule.priorityFloor] : 99,
+                });
+            }
+            if (matches.length <= maxRules) {
+                return matches.map(({ priorityRank, ...rest }) => rest);
+            }
+            matches.sort((a, b) => {
+                const deltaDiff = Math.abs(b.scoreDelta) - Math.abs(a.scoreDelta);
+                if (deltaDiff !== 0) {
+                    return deltaDiff;
+                }
+                const priorityDiff = a.priorityRank - b.priorityRank;
+                if (priorityDiff !== 0) {
+                    return priorityDiff;
+                }
+                return a.ruleId.localeCompare(b.ruleId);
+            });
+            const capped = matches.slice(0, maxRules).map(({ priorityRank, ...rest }) => rest);
+            let floor;
+            for (const match of capped) {
+                if (match.priorityFloor) {
+                    floor = floor ? comparePriority(floor, match.priorityFloor) : match.priorityFloor;
+                }
+            }
+            if (floor) {
+                for (const match of capped) {
+                    if (!match.priorityFloor) {
+                        match.priorityFloor = floor;
+                    }
+                }
+            }
+            return capped;
+        },
+    };
+}

package/dist/agent/telemetry.d.ts

@@ -0,0 +1,84 @@
+export interface GenerationMetric {
+    id: string;
+    timestamp: string;
+    operation: 'explore' | 'generate' | 'heal' | 'validate' | 'score' | 'pdf-parse';
+    model: string;
+    tokensInput: number;
+    tokensOutput: number;
+    costUsd: number;
+    durationMs: number;
+    success: boolean;
+    errorType?: string;
+    errorMessage?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TelemetryReport {
+    period: {
+        start: string;
+        end: string;
+    };
+    summary: {
+        totalOperations: number;
+        successCount: number;
+        failureCount: number;
+        successRate: number;
+        totalCost: number;
+        avgCost: number;
+        totalTokens: number;
+        avgDuration: number;
+    };
+    byModel: Record<string, {
+        count: number;
+        totalCost: number;
+        avgCost: number;
+        successRate: number;
+    }>;
+    byOperation: Record<string, {
+        count: number;
+        totalCost: number;
+        avgDuration: number;
+        successRate: number;
+    }>;
+}
+export declare class TelemetryCollector {
+    private metricsDir;
+    private metrics;
+    constructor(metricsDir?: string);
+    /**
+     * Ensure metrics directory exists
+     */
+    private ensureMetricsDir;
+    /**
+     * Get today's metrics file path
+     */
+    private getTodayPath;
+    /**
+     * Load metrics from disk
+     */
+    private loadTodayMetrics;
+    /**
+     * Track a metric
+     */
+    track(metric: Omit<GenerationMetric, 'id'>): void;
+    /**
+     * Save metrics to disk
+     */
+    private saveMetrics;
+    /**
+     * Calculate cost for a metric
+     */
+    static calculateCost(model: string, tokensInput: number, tokensOutput: number): number;
+    /**
+     * Generate report for a date range
+     */
+    generateReport(since?: Date, until?: Date): TelemetryReport;
+    /**
+     * Format report for console output
+     */
+    static formatReport(report: TelemetryReport): string;
+    /**
+     * Export metrics as JSON
+     */
+    exportJson(filepath: string): void;
+}
+//# sourceMappingURL=telemetry.d.ts.map

package/dist/agent/telemetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../../src/agent/telemetry.ts"],"names":[],"mappings":"AAoBA,MAAM,WAAW,gBAAgB;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,SAAS,GAAG,UAAU,GAAG,MAAM,GAAG,UAAU,GAAG,OAAO,GAAG,WAAW,CAAC;IAChF,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAED,MAAM,WAAW,eAAe;IAC5B,MAAM,EAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAC,CAAC;IACrC,OAAO,EAAE;QACL,eAAe,EAAE,MAAM,CAAC;QACxB,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;QACrB,WAAW,EAAE,MAAM,CAAC;QACpB,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,OAAO,EAAE,MAAM,CACX,MAAM,EACN;QACI,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;KACvB,CACJ,CAAC;IACF,WAAW,EAAE,MAAM,CACf,MAAM,EACN;QACI,KAAK,EAAE,MAAM,CAAC;QACd,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,WAAW,EAAE,MAAM,CAAC;KACvB,CACJ,CAAC;CACL;AAQD,qBAAa,kBAAkB;IAC3B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,OAAO,CAA8C;gBAEjD,UAAU,GAAE,MAAiC;IAMzD;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAMpB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAYxB;;OAEG;IACH,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,EAAE,IAAI,CAAC,GAAG,IAAI;IAejD;;OAEG;IACH,OAAO,CAAC,WAAW;IAMnB;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM;IAMtF;;OAEG;IACH,cAAc,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC,EAAE,IAAI,GAAG,eAAe;IAuF3D;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM;IAmCpD;;OAEG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;CAQrC"}