api-tests-coverage 1.0.0

package/dist/src/ast/parseFile.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Per-file AST analysis entry point.
+ *
+ * Attempts to parse and analyze a single source file using the registered
+ * LanguageAnalyzer for its language. Links assertions to HTTP interactions.
+ * Returns null when no analyzer is available or when parsing fails — the
+ * caller (astAnalysisOrchestrator) then falls back to regex analysis.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeFileWithAst = analyzeFileWithAst;
+const parserRegistry_1 = require("./parserRegistry");
+/**
+ * Parse and semantically analyze a single source file using the AST layer.
+ *
+ * @returns `ResolvedHttpInteraction[]` on success, `null` to signal fallback.
+ */
+function analyzeFileWithAst(filePath, content, language, context) {
+    const analyzer = (0, parserRegistry_1.getAnalyzer)(language, context.astConfig);
+    if (!analyzer)
+        return null;
+    try {
+        const parsed = analyzer.parse(filePath, content);
+        if (parsed.parseError)
+            return null;
+        const model = analyzer.buildSemanticModel(parsed, context);
+        const interactions = analyzer.extractHttpInteractions(model, context);
+        // Link assertions by matching response variable names
+        if (context.astConfig.assertionAware !== false) {
+            const assertions = analyzer.extractAssertions(model);
+            for (const interaction of interactions) {
+                if (interaction.responseVariable) {
+                    const linked = assertions.find((a) => a.subjectVariable === interaction.responseVariable);
+                    if (linked) {
+                        interaction.assertionLinked = true;
+                        interaction.assertionType = linked.assertionType;
+                    }
+                }
+            }
+        }
+        // Attach business rule refs if the analyzer supports it
+        if (analyzer.extractBusinessRuleRefs) {
+            const refs = analyzer.extractBusinessRuleRefs(model);
+            if (refs.length > 0) {
+                for (const interaction of interactions) {
+                    interaction.businessRuleRefs = refs;
+                }
+            }
+        }
+        // Attach flow refs if the analyzer supports it
+        if (analyzer.extractFlowRefs) {
+            const refs = analyzer.extractFlowRefs(model);
+            if (refs.length > 0) {
+                for (const interaction of interactions) {
+                    interaction.flowRefs = refs;
+                }
+            }
+        }
+        return interactions;
+    }
+    catch {
+        // Any unexpected error → signal fallback, never crash the analysis run
+        return null;
+    }
+}

package/dist/src/ast/parserRegistry.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Language analyzer registry.
+ *
+ * Language modules self-register their analyzers by calling `registerAnalyzer()`
+ * on module load. The orchestrator retrieves them via `getAnalyzer()`, which
+ * respects per-language enable flags and handles native module load failures
+ * gracefully (returning undefined so the caller falls back to regex).
+ */
+import type { LanguageAnalyzer } from './languageAnalyzer';
+import type { SupportedLanguage } from './astTypes';
+import type { AstAnalysisConfig } from '../config/types';
+type AnalyzerFactory = () => LanguageAnalyzer;
+/**
+ * Register a language analyzer factory.
+ * Called once per language module via side-effect import at startup.
+ */
+export declare function registerAnalyzer(language: SupportedLanguage, factory: AnalyzerFactory): void;
+/**
+ * Retrieve an instantiated analyzer for a given language.
+ *
+ * Returns `undefined` when:
+ * - AST is globally disabled (`astConfig.enabled === false`)
+ * - The specific language is disabled in per-language config
+ * - No analyzer has been registered for this language
+ * - The factory throws (e.g. native tree-sitter module failed to load)
+ *
+ * Callers treat `undefined` as "use regex fallback".
+ */
+export declare function getAnalyzer(language: SupportedLanguage, astConfig: AstAnalysisConfig): LanguageAnalyzer | undefined;
+/**
+ * Check whether any analyzer is registered (for testing).
+ */
+export declare function hasAnalyzer(language: SupportedLanguage): boolean;
+/**
+ * Return all registered language keys (for testing / introspection).
+ */
+export declare function registeredLanguages(): SupportedLanguage[];
+export {};
+//# sourceMappingURL=parserRegistry.d.ts.map

package/dist/src/ast/parserRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parserRegistry.d.ts","sourceRoot":"","sources":["../../../src/ast/parserRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEzD,KAAK,eAAe,GAAG,MAAM,gBAAgB,CAAC;AAI9C;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,iBAAiB,EAAE,OAAO,EAAE,eAAe,GAAG,IAAI,CAE5F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,iBAAiB,EAC3B,SAAS,EAAE,iBAAiB,GAC3B,gBAAgB,GAAG,SAAS,CAmB9B;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,iBAAiB,GAAG,OAAO,CAEhE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,iBAAiB,EAAE,CAEzD"}

package/dist/src/ast/parserRegistry.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Language analyzer registry.
+ *
+ * Language modules self-register their analyzers by calling `registerAnalyzer()`
+ * on module load. The orchestrator retrieves them via `getAnalyzer()`, which
+ * respects per-language enable flags and handles native module load failures
+ * gracefully (returning undefined so the caller falls back to regex).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAnalyzer = registerAnalyzer;
+exports.getAnalyzer = getAnalyzer;
+exports.hasAnalyzer = hasAnalyzer;
+exports.registeredLanguages = registeredLanguages;
+const registry = new Map();
+/**
+ * Register a language analyzer factory.
+ * Called once per language module via side-effect import at startup.
+ */
+function registerAnalyzer(language, factory) {
+    registry.set(language, factory);
+}
+/**
+ * Retrieve an instantiated analyzer for a given language.
+ *
+ * Returns `undefined` when:
+ * - AST is globally disabled (`astConfig.enabled === false`)
+ * - The specific language is disabled in per-language config
+ * - No analyzer has been registered for this language
+ * - The factory throws (e.g. native tree-sitter module failed to load)
+ *
+ * Callers treat `undefined` as "use regex fallback".
+ */
+function getAnalyzer(language, astConfig) {
+    var _a;
+    if (astConfig.enabled === false)
+        return undefined;
+    const normalizedLang = language === 'auto' ? undefined : language;
+    if (!normalizedLang)
+        return undefined;
+    const langConfig = (_a = astConfig.languages) === null || _a === void 0 ? void 0 : _a[normalizedLang];
+    if ((langConfig === null || langConfig === void 0 ? void 0 : langConfig.enabled) === false)
+        return undefined;
+    const factory = registry.get(normalizedLang);
+    if (!factory)
+        return undefined;
+    try {
+        return factory();
+    }
+    catch {
+        // Native module (tree-sitter grammar) failed to load — signal fallback
+        return undefined;
+    }
+}
+/**
+ * Check whether any analyzer is registered (for testing).
+ */
+function hasAnalyzer(language) {
+    return registry.has(language);
+}
+/**
+ * Return all registered language keys (for testing / introspection).
+ */
+function registeredLanguages() {
+    return Array.from(registry.keys());
+}

package/dist/src/buildSummary.d.ts

@@ -0,0 +1,26 @@
+import type { CoverageResult } from './reporting';
+import type { QualityGateResult } from './qualityGate';
+import type { BuildMetadata } from './publishing';
+/**
+ * Generate a Markdown string suitable for the GitHub Actions step summary
+ * ($GITHUB_STEP_SUMMARY).
+ */
+export declare function generateStepSummary(results: CoverageResult[], qualityGate: QualityGateResult, metadata: BuildMetadata, pagesUrl?: string, artifactsUrl?: string): string;
+/**
+ * Write the step summary to `$GITHUB_STEP_SUMMARY` if that environment
+ * variable is set (i.e. we are running inside GitHub Actions).
+ *
+ * @returns `true` if the summary was written, `false` otherwise.
+ */
+export declare function writeStepSummary(summary: string): boolean;
+/**
+ * Generate a concise markdown string suitable for a PR comment.
+ * This is a shorter version of the step summary.
+ */
+export declare function generatePrComment(results: CoverageResult[], qualityGate: QualityGateResult, metadata: BuildMetadata, pagesUrl?: string): string;
+/**
+ * Print a concise, human-readable summary to stdout.
+ * This is always called regardless of pass/fail.
+ */
+export declare function printCiSummary(results: CoverageResult[], qualityGate: QualityGateResult): void;
+//# sourceMappingURL=buildSummary.d.ts.map

package/dist/src/buildSummary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildSummary.d.ts","sourceRoot":"","sources":["../../src/buildSummary.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAIlD;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,cAAc,EAAE,EACzB,WAAW,EAAE,iBAAiB,EAC9B,QAAQ,EAAE,aAAa,EACvB,QAAQ,CAAC,EAAE,MAAM,EACjB,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,CAkFR;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAUzD;AAID;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,cAAc,EAAE,EACzB,WAAW,EAAE,iBAAiB,EAC9B,QAAQ,EAAE,aAAa,EACvB,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,CAiCR;AAID;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,cAAc,EAAE,EACzB,WAAW,EAAE,iBAAiB,GAC7B,IAAI,CAoBN"}

package/dist/src/buildSummary.js

@@ -0,0 +1,193 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateStepSummary = generateStepSummary;
+exports.writeStepSummary = writeStepSummary;
+exports.generatePrComment = generatePrComment;
+exports.printCiSummary = printCiSummary;
+const fs = __importStar(require("fs"));
+// ─── GitHub Actions Step Summary ─────────────────────────────────────────────
+/**
+ * Generate a Markdown string suitable for the GitHub Actions step summary
+ * ($GITHUB_STEP_SUMMARY).
+ */
+function generateStepSummary(results, qualityGate, metadata, pagesUrl, artifactsUrl) {
+    var _a, _b;
+    const statusEmoji = metadata.passed ? '✅' : '❌';
+    const lines = [
+        `## ${statusEmoji} API Coverage Report — ${metadata.passed ? 'PASSED' : 'FAILED'}`,
+        '',
+        `| | |`,
+        `|---|---|`,
+        `| **Project** | ${metadata.projectName} |`,
+        `| **Branch** | ${(_a = metadata.branch) !== null && _a !== void 0 ? _a : 'N/A'} |`,
+        `| **Commit** | \`${(_b = metadata.commitSha) !== null && _b !== void 0 ? _b : 'N/A'}\` |`,
+        `| **Build ID** | \`${metadata.buildId}\` |`,
+        `| **Timestamp** | ${metadata.buildTimestamp} |`,
+        '',
+        '### Coverage Summary',
+        '',
+        '| Category | Total | Covered | Coverage | Status |',
+        '|---|---|---|---|---|',
+    ];
+    for (const r of results) {
+        const pct = r.coveragePercent.toFixed(2);
+        const failed = qualityGate.failures.some((f) => f.category === r.type);
+        const status = failed ? '❌ Below threshold' : r.coveragePercent === 0 ? '⚠️ No coverage' : '✅ Pass';
+        lines.push(`| ${r.type} | ${r.totalItems} | ${r.coveredItems} | ${pct}% | ${status} |`);
+    }
+    lines.push('');
+    lines.push('### Quality Gate');
+    lines.push('');
+    if (qualityGate.failures.length === 0) {
+        lines.push('✅ All coverage thresholds met.');
+    }
+    else {
+        lines.push(`❌ **${qualityGate.failures.length} threshold(s) not met:**`);
+        lines.push('');
+        for (const f of qualityGate.failures) {
+            lines.push(`- **${f.category}**: expected ≥ ${f.expected}%, actual ${f.actual}%, gap **${f.gap}%**`);
+        }
+    }
+    // Top 5 coverage gaps
+    const top5Gaps = results
+        .filter((r) => r.coveragePercent < 100)
+        .sort((a, b) => a.coveragePercent - b.coveragePercent)
+        .slice(0, 5);
+    if (top5Gaps.length > 0) {
+        lines.push('');
+        lines.push('### Top Coverage Gaps');
+        lines.push('');
+        for (const g of top5Gaps) {
+            const missing = g.totalItems - g.coveredItems;
+            lines.push(`- **${g.type}**: ${missing} item(s) not covered (${g.coveragePercent.toFixed(2)}%)`);
+        }
+    }
+    if (pagesUrl) {
+        lines.push('');
+        lines.push(`📊 **[View Full Report on GitHub Pages](${pagesUrl})**`);
+    }
+    if (artifactsUrl) {
+        lines.push('');
+        lines.push(`📦 **[Download Artifacts](${artifactsUrl})**`);
+    }
+    lines.push('');
+    lines.push('### Recommended Next Action');
+    lines.push('');
+    if (qualityGate.failures.length > 0) {
+        const worstFailure = [...qualityGate.failures].sort((a, b) => b.gap - a.gap)[0];
+        if (worstFailure) {
+            lines.push(`Increase **${worstFailure.category}** coverage by at least ${worstFailure.gap}% ` +
+                `(currently ${worstFailure.actual}%, required ${worstFailure.expected}%).`);
+        }
+    }
+    else {
+        lines.push('All thresholds met. Consider raising thresholds to enforce higher coverage standards.');
+    }
+    return lines.join('\n');
+}
+/**
+ * Write the step summary to `$GITHUB_STEP_SUMMARY` if that environment
+ * variable is set (i.e. we are running inside GitHub Actions).
+ *
+ * @returns `true` if the summary was written, `false` otherwise.
+ */
+function writeStepSummary(summary) {
+    const summaryFile = process.env['GITHUB_STEP_SUMMARY'];
+    if (!summaryFile)
+        return false;
+    try {
+        fs.appendFileSync(summaryFile, summary + '\n');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── PR Annotation / Comment ──────────────────────────────────────────────────
+/**
+ * Generate a concise markdown string suitable for a PR comment.
+ * This is a shorter version of the step summary.
+ */
+function generatePrComment(results, qualityGate, metadata, pagesUrl) {
+    const statusEmoji = metadata.passed ? '✅' : '❌';
+    const header = `${statusEmoji} **API Coverage: ${metadata.passed ? 'PASSED' : 'FAILED'}** — Build \`${metadata.buildId}\``;
+    const tableRows = results.map((r) => {
+        const pct = r.coveragePercent.toFixed(2);
+        const failed = qualityGate.failures.some((f) => f.category === r.type);
+        const icon = failed ? '❌' : r.coveragePercent === 0 ? '⚠️' : '✅';
+        return `| ${r.type} | ${pct}% | ${icon} |`;
+    });
+    const lines = [
+        header,
+        '',
+        '| Category | Coverage | Status |',
+        '|---|---|---|',
+        ...tableRows,
+        '',
+    ];
+    if (qualityGate.failures.length > 0) {
+        lines.push('**Failures:**');
+        for (const f of qualityGate.failures) {
+            lines.push(`- ${f.category}: ${f.actual}% < ${f.expected}% (gap: ${f.gap}%)`);
+        }
+        lines.push('');
+    }
+    if (pagesUrl) {
+        lines.push(`[View full report](${pagesUrl})`);
+    }
+    return lines.join('\n');
+}
+// ─── CI output summary ────────────────────────────────────────────────────────
+/**
+ * Print a concise, human-readable summary to stdout.
+ * This is always called regardless of pass/fail.
+ */
+function printCiSummary(results, qualityGate) {
+    const status = qualityGate.passed ? '✅ PASSED' : '❌ FAILED';
+    console.log(`\n=== API Coverage Quality Gate: ${status} ===\n`);
+    for (const r of results) {
+        const failed = qualityGate.failures.some((f) => f.category === r.type);
+        const indicator = failed ? '❌' : '✅';
+        console.log(`  ${indicator} ${r.type.padEnd(20)} ${String(r.coveredItems).padStart(4)}/${String(r.totalItems).padEnd(4)} (${r.coveragePercent.toFixed(2)}%)`);
+    }
+    if (qualityGate.failures.length > 0) {
+        console.log('\nThreshold failures:');
+        for (const f of qualityGate.failures) {
+            console.log(`  ❌ ${f.category}: expected ≥ ${f.expected}%, actual ${f.actual}%, gap ${f.gap}%`);
+        }
+    }
+    console.log('');
+}

package/dist/src/businessCoverage.d.ts

@@ -0,0 +1,68 @@
+export interface BusinessRuleScenario {
+    /** Unique scenario ID, e.g. "BL001-success" */
+    id: string;
+    /** Human-readable description of this scenario */
+    description: string;
+    /** Keywords used to detect this scenario in test names/content */
+    keywords?: string[];
+}
+export interface BusinessRule {
+    /** Unique rule ID, e.g. "BL001" */
+    id: string;
+    /** Human-readable description of the business rule */
+    description: string;
+    /** API endpoints involved in this rule, e.g. ["POST /users"] */
+    endpoints?: string[];
+    /**
+     * Keywords used to detect this rule in test names/content.
+     * A test is mapped to a rule when any keyword appears in its description.
+     */
+    keywords: string[];
+    /** Optional list of sub-scenarios (success path, failure path, etc.) */
+    scenarios?: BusinessRuleScenario[];
+}
+export interface BusinessRulesFile {
+    rules: BusinessRule[];
+}
+export interface ScenarioCoverage {
+    scenario: BusinessRuleScenario;
+    covered: boolean;
+    matchedTests: string[];
+}
+export interface BusinessRuleCoverage {
+    rule: BusinessRule;
+    /** True if at least one test maps to this rule */
+    covered: boolean;
+    /** Test file paths that contain at least one matching test */
+    testFiles: string[];
+    /** Test description strings that matched the rule */
+    matchedTests: string[];
+    /** Coverage for each defined scenario */
+    scenarios: ScenarioCoverage[];
+}
+export interface BusinessCoverageReport {
+    total: number;
+    covered: number;
+    percentage: number;
+    uncoveredRules: BusinessRule[];
+    rules: BusinessRuleCoverage[];
+}
+/**
+ * Parse a YAML or JSON business-rules definition file.
+ * The file must contain a top-level `rules` array.
+ */
+export declare function parseBusinessRules(rulesPath: string): BusinessRule[];
+/**
+ * Analyse test files matching the given glob pattern and determine which
+ * business rules are covered.
+ */
+export declare function analyzeBusinessCoverage(rules: BusinessRule[], testGlob: string): Promise<BusinessRuleCoverage[]>;
+/**
+ * Build the coverage summary from a list of per-rule coverages.
+ */
+export declare function buildBusinessCoverageReport(coverages: BusinessRuleCoverage[]): BusinessCoverageReport;
+/**
+ * Write JSON and HTML business-coverage reports to the given directory.
+ */
+export declare function generateBusinessReports(report: BusinessCoverageReport, reportsDir: string): void;
+//# sourceMappingURL=businessCoverage.d.ts.map

package/dist/src/businessCoverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"businessCoverage.d.ts","sourceRoot":"","sources":["../../src/businessCoverage.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,oBAAoB;IACnC,+CAA+C;IAC/C,EAAE,EAAE,MAAM,CAAC;IACX,kDAAkD;IAClD,WAAW,EAAE,MAAM,CAAC;IACpB,kEAAkE;IAClE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,YAAY;IAC3B,mCAAmC;IACnC,EAAE,EAAE,MAAM,CAAC;IACX,sDAAsD;IACtD,WAAW,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB;;;OAGG;IACH,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,wEAAwE;IACxE,SAAS,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACpC;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,YAAY,CAAC;IACnB,kDAAkD;IAClD,OAAO,EAAE,OAAO,CAAC;IACjB,8DAA8D;IAC9D,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,qDAAqD;IACrD,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,yCAAyC;IACzC,SAAS,EAAE,gBAAgB,EAAE,CAAC;CAC/B;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,YAAY,EAAE,CAAC;IAC/B,KAAK,EAAE,oBAAoB,EAAE,CAAC;CAC/B;AAID;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,EAAE,CAuBpE;AAmED;;;GAGG;AACH,wBAAsB,uBAAuB,CAC3C,KAAK,EAAE,YAAY,EAAE,EACrB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,oBAAoB,EAAE,CAAC,CAyDjC;AAID;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,oBAAoB,EAAE,GAChC,sBAAsB,CAOxB;AAID;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,sBAAsB,EAC9B,UAAU,EAAE,MAAM,GACjB,IAAI,CAgHN"}