@yasserkhanorg/impact-gate 2.0.0

package/dist/knowledge/route_families.js

@@ -0,0 +1,410 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesGlob = matchesGlob;
+exports.matchesAnyPattern = matchesAnyPattern;
+exports.loadRouteFamilyManifest = loadRouteFamilyManifest;
+exports.bindFilesToFamilies = bindFilesToFamilies;
+exports.getFamilyById = getFamilyById;
+exports.getFeatureById = getFeatureById;
+exports.getSpecDirsForBinding = getSpecDirsForBinding;
+exports.getCypressSpecDirsForBinding = getCypressSpecDirsForBinding;
+exports.getPriorityForBinding = getPriorityForBinding;
+exports.getUserFlowsForBinding = getUserFlowsForBinding;
+exports.getRoutesForBinding = getRoutesForBinding;
+exports.getAssertionPatternsForBinding = getAssertionPatternsForBinding;
+exports.clearManifestCache = clearManifestCache;
+exports.buildHeuristicFamilies = buildHeuristicFamilies;
+exports.serializeManifest = serializeManifest;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const logger_js_1 = require("../logger.js");
+const manifestCache = new Map();
+function matchesGlob(filePath, pattern) {
+    const normalized = filePath.replace(/\\/g, '/');
+    const parts = pattern.replace(/\\/g, '/').split('*');
+    if (parts.length === 1) {
+        return normalized === parts[0] || normalized.startsWith(parts[0]);
+    }
+    let pos = 0;
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        if (part === '') {
+            continue;
+        }
+        const idx = normalized.indexOf(part, pos);
+        if (idx < 0) {
+            return false;
+        }
+        if (i === 0 && idx !== 0) {
+            return false;
+        }
+        pos = idx + part.length;
+    }
+    return true;
+}
+function matchesAnyPattern(filePath, patterns) {
+    return patterns.some((pattern) => matchesGlob(filePath, pattern));
+}
+function validateApiEndpoint(ep) {
+    if (!ep || typeof ep !== 'object')
+        return null;
+    const obj = ep;
+    if (typeof obj.method !== 'string' || typeof obj.path !== 'string')
+        return null;
+    const result = { method: obj.method, path: obj.path };
+    if (typeof obj.description === 'string')
+        result.description = obj.description;
+    return result;
+}
+function validateFamily(family) {
+    if (!family || typeof family !== 'object') {
+        return null;
+    }
+    const obj = family;
+    if (typeof obj.id !== 'string' || !obj.id.trim()) {
+        return null;
+    }
+    // When testType is 'api', routes may contain API paths like "GET /api/users"
+    const testType = (obj.testType === 'ui' || obj.testType === 'api' || obj.testType === 'both')
+        ? obj.testType
+        : undefined;
+    if (!Array.isArray(obj.routes) || obj.routes.length === 0) {
+        return null;
+    }
+    const routes = obj.routes.filter((r) => typeof r === 'string');
+    if (routes.length === 0) {
+        return null;
+    }
+    const result = {
+        id: obj.id.trim(),
+        routes,
+    };
+    if (Array.isArray(obj.pageObjects)) {
+        result.pageObjects = obj.pageObjects.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.components)) {
+        result.components = obj.components.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.webappPaths)) {
+        result.webappPaths = obj.webappPaths.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.serverPaths)) {
+        result.serverPaths = obj.serverPaths.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.specDirs)) {
+        result.specDirs = obj.specDirs.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.cypressSpecDirs)) {
+        result.cypressSpecDirs = obj.cypressSpecDirs.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.tags)) {
+        result.tags = obj.tags.filter((v) => typeof v === 'string');
+    }
+    if (obj.priority === 'P0' || obj.priority === 'P1' || obj.priority === 'P2') {
+        result.priority = obj.priority;
+    }
+    if (Array.isArray(obj.userFlows)) {
+        result.userFlows = obj.userFlows.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.features)) {
+        result.features = obj.features
+            .map((f) => validateFeature(f))
+            .filter((f) => f !== null);
+    }
+    if (Array.isArray(obj.apiEndpoints)) {
+        const endpoints = obj.apiEndpoints
+            .map((ep) => validateApiEndpoint(ep))
+            .filter((ep) => ep !== null);
+        if (endpoints.length > 0)
+            result.apiEndpoints = endpoints;
+    }
+    if (testType) {
+        result.testType = testType;
+    }
+    if (Array.isArray(obj.assertionPatterns)) {
+        result.assertionPatterns = validateAssertionPatterns(obj.assertionPatterns);
+    }
+    return result;
+}
+const VALID_ASSERTION_TYPES = [
+    'state-change', 'cross-user', 'persistence', 'negative',
+    'permission', 'data-integrity', 'error-handling',
+];
+function validateAssertionPatterns(patterns) {
+    return patterns
+        .filter((p) => p != null && typeof p === 'object')
+        .filter((p) => typeof p.type === 'string' && typeof p.pattern === 'string')
+        .filter((p) => VALID_ASSERTION_TYPES.includes(p.type))
+        .map((p) => ({ type: p.type, pattern: p.pattern }));
+}
+function validateFeature(feature) {
+    if (!feature || typeof feature !== 'object') {
+        return null;
+    }
+    const obj = feature;
+    if (typeof obj.id !== 'string' || !obj.id.trim()) {
+        return null;
+    }
+    const result = { id: obj.id.trim() };
+    if (Array.isArray(obj.routes)) {
+        result.routes = obj.routes.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.webappPaths)) {
+        result.webappPaths = obj.webappPaths.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.serverPaths)) {
+        result.serverPaths = obj.serverPaths.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.specDirs)) {
+        result.specDirs = obj.specDirs.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.cypressSpecDirs)) {
+        result.cypressSpecDirs = obj.cypressSpecDirs.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.tags)) {
+        result.tags = obj.tags.filter((v) => typeof v === 'string');
+    }
+    if (obj.priority === 'P0' || obj.priority === 'P1' || obj.priority === 'P2') {
+        result.priority = obj.priority;
+    }
+    if (Array.isArray(obj.userFlows)) {
+        result.userFlows = obj.userFlows.filter((v) => typeof v === 'string');
+    }
+    if (Array.isArray(obj.assertionPatterns)) {
+        result.assertionPatterns = validateAssertionPatterns(obj.assertionPatterns);
+    }
+    return result;
+}
+function loadRouteFamilyManifest(testsRoot, config) {
+    const candidates = [];
+    if (config?.manifestPath) {
+        candidates.push(config.manifestPath);
+    }
+    candidates.push((0, path_1.join)(testsRoot, '.e2e-ai-agents', 'route-families.json'));
+    for (const candidate of candidates) {
+        try {
+            if (!(0, fs_1.existsSync)(candidate)) {
+                continue;
+            }
+            const mtimeMs = (0, fs_1.statSync)(candidate).mtimeMs;
+            const cached = manifestCache.get(candidate);
+            if (cached && cached.mtimeMs === mtimeMs && cached.manifest) {
+                return cached.manifest;
+            }
+            const raw = JSON.parse((0, fs_1.readFileSync)(candidate, 'utf-8'));
+            if (!raw.families || !Array.isArray(raw.families)) {
+                manifestCache.set(candidate, { mtimeMs, manifest: null });
+                continue;
+            }
+            const families = raw.families
+                .map((f) => validateFamily(f))
+                .filter((f) => f !== null);
+            if (families.length === 0) {
+                manifestCache.set(candidate, { mtimeMs, manifest: null });
+                continue;
+            }
+            const manifest = { families, source: candidate };
+            manifestCache.set(candidate, { mtimeMs, manifest });
+            return manifest;
+        }
+        catch {
+            continue;
+        }
+    }
+    if (config?.strict) {
+        logger_js_1.logger.warn('Route family manifest not found. Create .e2e-ai-agents/route-families.json to enable family-level routing hints.');
+    }
+    return null;
+}
+function bindFilesToFamilies(changedFiles, manifest) {
+    return changedFiles.map((file) => {
+        const normalized = file.replace(/\\/g, '/');
+        const bindings = [];
+        for (const family of manifest.families) {
+            const featureBindings = [];
+            // Check feature-level first (more specific)
+            if (family.features) {
+                for (const feature of family.features) {
+                    const featurePatterns = [
+                        ...(feature.webappPaths || []),
+                        ...(feature.serverPaths || []),
+                        ...(feature.specDirs || []),
+                    ];
+                    if (featurePatterns.length > 0 && matchesAnyPattern(normalized, featurePatterns)) {
+                        featureBindings.push({ family: family.id, feature: feature.id });
+                    }
+                }
+            }
+            if (featureBindings.length > 0) {
+                bindings.push(...featureBindings);
+                continue;
+            }
+            // Fall back to family-level patterns
+            const familyPatterns = [
+                ...(family.webappPaths || []),
+                ...(family.serverPaths || []),
+                ...(family.specDirs || []),
+                ...(family.cypressSpecDirs || []),
+            ];
+            if (familyPatterns.length > 0 && matchesAnyPattern(normalized, familyPatterns)) {
+                bindings.push({ family: family.id });
+            }
+        }
+        return { file: normalized, bindings };
+    });
+}
+function getFamilyById(manifest, familyId) {
+    return manifest.families.find((f) => f.id === familyId);
+}
+function getFeatureById(family, featureId) {
+    return family.features?.find((f) => f.id === featureId);
+}
+function getSpecDirsForBinding(manifest, binding) {
+    const family = getFamilyById(manifest, binding.family);
+    if (!family) {
+        return [];
+    }
+    if (binding.feature) {
+        const feature = getFeatureById(family, binding.feature);
+        // An explicitly declared specDirs (even []) is intentional — don't fall back to family.
+        if (feature && feature.specDirs !== undefined) {
+            return feature.specDirs;
+        }
+    }
+    return family.specDirs || [];
+}
+function getCypressSpecDirsForBinding(manifest, binding) {
+    const family = getFamilyById(manifest, binding.family);
+    if (!family) {
+        return [];
+    }
+    if (binding.feature) {
+        const feature = getFeatureById(family, binding.feature);
+        // An explicitly declared cypressSpecDirs (even []) is intentional — don't fall back to family.
+        if (feature && feature.cypressSpecDirs !== undefined) {
+            return feature.cypressSpecDirs;
+        }
+    }
+    return family.cypressSpecDirs || [];
+}
+function getPriorityForBinding(manifest, binding) {
+    const family = getFamilyById(manifest, binding.family);
+    if (!family) {
+        return 'P2';
+    }
+    if (binding.feature) {
+        const feature = getFeatureById(family, binding.feature);
+        if (feature?.priority) {
+            return feature.priority;
+        }
+    }
+    return family.priority || 'P2';
+}
+function getUserFlowsForBinding(manifest, binding) {
+    const family = getFamilyById(manifest, binding.family);
+    if (!family) {
+        return [];
+    }
+    if (binding.feature) {
+        const feature = getFeatureById(family, binding.feature);
+        if (feature?.userFlows && feature.userFlows.length > 0) {
+            return feature.userFlows;
+        }
+    }
+    return family.userFlows || [];
+}
+function getRoutesForBinding(manifest, binding) {
+    const family = getFamilyById(manifest, binding.family);
+    if (!family) {
+        return [];
+    }
+    if (binding.feature) {
+        const feature = getFeatureById(family, binding.feature);
+        if (feature?.routes && feature.routes.length > 0) {
+            return feature.routes;
+        }
+    }
+    return family.routes;
+}
+function getAssertionPatternsForBinding(manifest, binding) {
+    const family = getFamilyById(manifest, binding.family);
+    if (!family) {
+        return [];
+    }
+    if (binding.feature) {
+        const feature = getFeatureById(family, binding.feature);
+        if (feature?.assertionPatterns && feature.assertionPatterns.length > 0) {
+            return feature.assertionPatterns;
+        }
+    }
+    return family.assertionPatterns || [];
+}
+function clearManifestCache() {
+    manifestCache.clear();
+}
+/**
+ * Build heuristic route families from changed files when no manifest exists.
+ * Groups files by their top-level directory to create rough family groupings.
+ * Results are lower confidence but allow analysis to proceed without training.
+ */
+function buildHeuristicFamilies(changedFiles, testsRoot) {
+    const dirGroups = new Map();
+    for (const file of changedFiles) {
+        const normalized = file.replace(/\\/g, '/');
+        const parts = normalized.split('/');
+        // Use the first meaningful directory segment as the family ID
+        // Skip common prefixes like 'src/', 'app/', 'lib/'
+        const skipDirs = new Set(['src', 'app', 'lib', 'packages', 'components']);
+        let familyDir = parts[0] || 'root';
+        if (skipDirs.has(familyDir) && parts.length > 1) {
+            familyDir = parts[1];
+        }
+        // Normalize to a clean family name
+        familyDir = familyDir.replace(/\.[^.]+$/, ''); // strip file extensions for single files
+        if (!dirGroups.has(familyDir)) {
+            dirGroups.set(familyDir, []);
+        }
+        dirGroups.get(familyDir).push(normalized);
+    }
+    const families = [];
+    for (const [dir, files] of dirGroups) {
+        families.push({
+            id: dir,
+            routes: [`/${dir}`],
+            webappPaths: files.map((f) => `${f}*`),
+        });
+    }
+    logger_js_1.logger.info(`Built ${families.length} heuristic families from ${changedFiles.length} changed files (no route-families.json found)`);
+    logger_js_1.logger.info('Tip: Run `impact-gate train` to generate a proper route-families manifest for better accuracy.');
+    return {
+        families,
+        source: 'heuristic',
+    };
+}
+/**
+ * Serialize a RouteFamilyManifest to clean JSON, stripping empty optional fields.
+ */
+function serializeManifest(manifest) {
+    const output = {
+        families: manifest.families.map((f) => {
+            const cleaned = { ...f };
+            const optionalArrays = [
+                'pageObjects', 'components', 'webappPaths', 'serverPaths',
+                'specDirs', 'cypressSpecDirs', 'tags', 'userFlows', 'features', 'apiEndpoints', 'assertionPatterns',
+            ];
+            for (const key of optionalArrays) {
+                if (!cleaned[key] || (Array.isArray(cleaned[key]) && cleaned[key].length === 0)) {
+                    delete cleaned[key];
+                }
+            }
+            if (!cleaned.priority)
+                delete cleaned.priority;
+            if (!cleaned.testType)
+                delete cleaned.testType;
+            return cleaned;
+        }),
+    };
+    return JSON.stringify(output, null, 2) + '\n';
+}

package/dist/knowledge/spec_index.d.ts

@@ -0,0 +1,18 @@
+import type { RouteFamilyManifest } from './route_families.js';
+export interface SpecEntry {
+    path: string;
+    relativePath: string;
+    testTitles: string[];
+    tags: string[];
+    familyId?: string;
+    featureId?: string;
+}
+export interface SpecIndex {
+    specs: SpecEntry[];
+    indexedAt: string;
+}
+export declare function buildSpecIndex(testsRoot: string, _specPatterns?: string[], manifest?: RouteFamilyManifest | null): SpecIndex;
+export declare function getSpecsForFamily(index: SpecIndex, familyId: string, featureId?: string): SpecEntry[];
+export declare function getSpecByPath(index: SpecIndex, relativePath: string): SpecEntry | undefined;
+export declare function formatSpecsForPrompt(specs: SpecEntry[]): string;
+//# sourceMappingURL=spec_index.d.ts.map

package/dist/knowledge/spec_index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec_index.d.ts","sourceRoot":"","sources":["../../src/knowledge/spec_index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,qBAAqB,CAAC;AAE7D,MAAM,WAAW,SAAS;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,SAAS;IACtB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACrB;AAwFD,wBAAgB,cAAc,CAC1B,SAAS,EAAE,MAAM,EACjB,aAAa,CAAC,EAAE,MAAM,EAAE,EACxB,QAAQ,CAAC,EAAE,mBAAmB,GAAG,IAAI,GACtC,SAAS,CAcX;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,EAAE,CAUrG;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAE3F;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM,CAQ/D"}

package/dist/knowledge/spec_index.js

@@ -0,0 +1,128 @@
+"use strict";
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSpecIndex = buildSpecIndex;
+exports.getSpecsForFamily = getSpecsForFamily;
+exports.getSpecByPath = getSpecByPath;
+exports.formatSpecsForPrompt = formatSpecsForPrompt;
+const fs_1 = require("fs");
+const path_1 = require("path");
+function extractTestTitles(content) {
+    const titles = [];
+    const testRe = /\btest\s*\(\s*(['"`])((?:(?!\1).|\\.)*)\1/g;
+    let match;
+    while ((match = testRe.exec(content)) !== null) {
+        const title = match[2].trim();
+        if (title) {
+            titles.push(title);
+        }
+    }
+    return titles;
+}
+function extractTags(content) {
+    const tags = new Set();
+    const singleTagRe = /\btag:\s*['"`](@[\w-]+)['"`]/g;
+    let match;
+    while ((match = singleTagRe.exec(content)) !== null) {
+        tags.add(match[1]);
+    }
+    const arrayTagRe = /\btag:\s*\[([^\]]*)\]/g;
+    while ((match = arrayTagRe.exec(content)) !== null) {
+        const inner = match[1];
+        const tagRe = /['"`](@[\w-]+)['"`]/g;
+        let tagMatch;
+        while ((tagMatch = tagRe.exec(inner)) !== null) {
+            tags.add(tagMatch[1]);
+        }
+    }
+    return Array.from(tags);
+}
+function scanSpecDir(dir, testsRoot) {
+    const entries = [];
+    if (!(0, fs_1.existsSync)(dir)) {
+        return entries;
+    }
+    const items = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+    for (const item of items) {
+        const fullPath = (0, path_1.join)(dir, item.name);
+        if (item.isDirectory()) {
+            entries.push(...scanSpecDir(fullPath, testsRoot));
+            continue;
+        }
+        if (!item.name.endsWith('.spec.ts') && !item.name.endsWith('.spec.tsx')) {
+            continue;
+        }
+        try {
+            const content = (0, fs_1.readFileSync)(fullPath, 'utf-8');
+            entries.push({
+                path: fullPath,
+                relativePath: (0, path_1.relative)(testsRoot, fullPath).replace(/\\/g, '/'),
+                testTitles: extractTestTitles(content),
+                tags: extractTags(content),
+            });
+        }
+        catch {
+            continue;
+        }
+    }
+    return entries;
+}
+function bindSpecToFamily(spec, manifest) {
+    const specPath = spec.relativePath;
+    for (const family of manifest.families) {
+        if (family.features) {
+            for (const feature of family.features) {
+                if (feature.specDirs?.some((dir) => specPath.startsWith(dir))) {
+                    spec.familyId = family.id;
+                    spec.featureId = feature.id;
+                    return;
+                }
+            }
+        }
+        if (family.specDirs?.some((dir) => specPath.startsWith(dir))) {
+            spec.familyId = family.id;
+            return;
+        }
+        if (family.tags && spec.tags.some((t) => family.tags.includes(t))) {
+            spec.familyId = family.id;
+            return;
+        }
+    }
+}
+function buildSpecIndex(testsRoot, _specPatterns, manifest) {
+    const specsDir = (0, path_1.join)(testsRoot, 'specs');
+    const specs = scanSpecDir(specsDir, testsRoot);
+    if (manifest) {
+        for (const spec of specs) {
+            bindSpecToFamily(spec, manifest);
+        }
+    }
+    return {
+        specs,
+        indexedAt: new Date().toISOString(),
+    };
+}
+function getSpecsForFamily(index, familyId, featureId) {
+    return index.specs.filter((s) => {
+        if (s.familyId !== familyId) {
+            return false;
+        }
+        if (featureId && s.featureId && s.featureId !== featureId) {
+            return false;
+        }
+        return true;
+    });
+}
+function getSpecByPath(index, relativePath) {
+    return index.specs.find((s) => s.relativePath === relativePath);
+}
+function formatSpecsForPrompt(specs) {
+    return specs
+        .map((s) => {
+        const titles = s.testTitles.map((t) => `  - ${t}`).join('\n');
+        const tagsStr = s.tags.length > 0 ? ` [${s.tags.join(', ')}]` : '';
+        return `${s.relativePath}${tagsStr}\n${titles}`;
+    })
+        .join('\n\n');
+}

package/dist/logger.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Structured logging system.
+ * Environment variable: LOG_LEVEL (ERROR, WARN, INFO, DEBUG)
+ */
+export declare enum LogLevel {
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    DEBUG = 3
+}
+export declare class Logger {
+    private level;
+    private jsonMode;
+    constructor(minLevel?: LogLevel);
+    error(message: string, context?: Record<string, unknown>): void;
+    warn(message: string, context?: Record<string, unknown>): void;
+    info(message: string, context?: Record<string, unknown>): void;
+    debug(message: string, context?: Record<string, unknown>): void;
+    setLevel(level: LogLevel): void;
+    setJsonMode(enabled: boolean): void;
+    /**
+     * Start a timer for measuring duration of an operation.
+     * Returns an object with `end()` that logs at DEBUG level and returns elapsed ms.
+     */
+    timer(label: string): {
+        end: () => number;
+    };
+    private log;
+}
+export declare const logger: Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAGA;;;GAGG;AAEH,oBAAY,QAAQ;IAChB,KAAK,IAAI;IACT,IAAI,IAAI;IACR,IAAI,IAAI;IACR,KAAK,IAAI;CACZ;AAqCD,qBAAa,MAAM;IACf,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,QAAQ,CAAU;gBAEd,QAAQ,CAAC,EAAE,QAAQ;IAK/B,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM/D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM9D,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM9D,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAM/D,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI;IAI/B,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAInC;;;OAGG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG;QAAC,GAAG,EAAE,MAAM,MAAM,CAAA;KAAC;IAWzC,OAAO,CAAC,GAAG;CAoBd;AAGD,eAAO,MAAM,MAAM,QAAe,CAAC"}