api-tests-coverage 1.0.0

package/dist/src/observability.js

@@ -0,0 +1,519 @@
+"use strict";
+/**
+ * Observability module — structured logging, Prometheus metrics, and OpenTelemetry tracing.
+ *
+ * Usage:
+ *   import { createLogger, initMetrics, startMetricsServer, recordCoverageMetrics,
+ *            recordSecurityScanMetrics, initTracing, startSpan, endSpan } from './observability';
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+exports.initLogger = initLogger;
+exports.getLogger = getLogger;
+exports.logCoverageResult = logCoverageResult;
+exports.logThresholdBreach = logThresholdBreach;
+exports.initMetrics = initMetrics;
+exports.getRegistry = getRegistry;
+exports.recordCoverageMetrics = recordCoverageMetrics;
+exports.recordSecurityScanMetrics = recordSecurityScanMetrics;
+exports.recordIntelligenceMetrics = recordIntelligenceMetrics;
+exports.startMetricsServer = startMetricsServer;
+exports.stopMetricsServer = stopMetricsServer;
+exports.initTracing = initTracing;
+exports.startSpan = startSpan;
+exports.getCollectedSpans = getCollectedSpans;
+exports.clearCollectedSpans = clearCollectedSpans;
+exports.buildObservabilityInfo = buildObservabilityInfo;
+const http = __importStar(require("http"));
+const pino_1 = __importDefault(require("pino"));
+const prom_client_1 = require("prom-client");
+/** Create a pino logger at the specified level (defaults to 'info'). */
+function createLogger(level = 'info') {
+    return (0, pino_1.default)({
+        level,
+        timestamp: pino_1.default.stdTimeFunctions.isoTime,
+        formatters: {
+            level(label) {
+                return { level: label };
+            },
+        },
+    });
+}
+/** Shared module-level logger instance — replaced by initLogger(). */
+let _logger = createLogger('info');
+/** Initialise (or replace) the module-level logger. */
+function initLogger(level) {
+    _logger = createLogger(level);
+}
+/** Return the current module-level logger. */
+function getLogger() {
+    return _logger;
+}
+/** Log a coverage result at INFO level with structured fields. */
+function logCoverageResult(logger, result, threshold) {
+    const status = threshold !== undefined
+        ? result.coveragePercent >= threshold
+            ? 'pass'
+            : 'fail'
+        : 'unchecked';
+    logger.info({
+        coverageType: result.type,
+        totalItems: result.totalItems,
+        coveredItems: result.coveredItems,
+        coveragePercent: result.coveragePercent,
+        threshold,
+        status,
+        message: `Coverage result for ${result.type}: ${result.coveragePercent}% (${result.coveredItems}/${result.totalItems})`,
+    });
+}
+/** Log a threshold breach at WARN level. */
+function logThresholdBreach(logger, coverageType, coveragePercent, threshold) {
+    const gap = (threshold - coveragePercent).toFixed(2);
+    logger.warn({
+        event: 'threshold_breach',
+        coverageType,
+        coveragePercent,
+        threshold,
+        gap: parseFloat(gap),
+        message: `Threshold breach: ${coverageType} coverage ${coveragePercent}% is below threshold ${threshold}% (gap: ${gap}%)`,
+    });
+}
+// ─── Prometheus metrics ───────────────────────────────────────────────────────
+/** Per-run Prometheus registry — recreated each run to avoid stale data. */
+let _registry = null;
+/** Gauges populated after each analysis run. */
+let _gauges = null;
+/** Gauges for the security scanning layer. */
+let _securityGauges = null;
+/** Gauges for the coverage intelligence layer. */
+let _intelligenceGauges = null;
+/** Metrics HTTP server (set when --metrics-port is active). */
+let _metricsServer = null;
+/**
+ * Initialise a fresh Prometheus registry and register the coverage gauges.
+ * Call once before recording metrics.
+ */
+function initMetrics(serviceName = 'api-coverage-analyzer') {
+    _registry = new prom_client_1.Registry();
+    // Optional: collect default Node.js process metrics
+    (0, prom_client_1.collectDefaultMetrics)({ register: _registry, prefix: 'nodejs_' });
+    _gauges = {
+        total: new prom_client_1.Gauge({
+            name: 'api_coverage_total',
+            help: 'Total number of items analysed for this coverage type',
+            labelNames: ['service', 'coverage_type'],
+            registers: [_registry],
+        }),
+        covered: new prom_client_1.Gauge({
+            name: 'api_coverage_covered',
+            help: 'Number of covered items for this coverage type',
+            labelNames: ['service', 'coverage_type'],
+            registers: [_registry],
+        }),
+        ratio: new prom_client_1.Gauge({
+            name: 'api_coverage_ratio',
+            help: 'Coverage ratio (0–1) for this coverage type',
+            labelNames: ['service', 'coverage_type'],
+            registers: [_registry],
+        }),
+        thresholdFailure: new prom_client_1.Gauge({
+            name: 'api_coverage_threshold_failure',
+            help: '1 if coverage is below the configured threshold, 0 otherwise',
+            labelNames: ['service', 'coverage_type'],
+            registers: [_registry],
+        }),
+    };
+    _securityGauges = {
+        findings: new prom_client_1.Gauge({
+            name: 'api_security_findings_total',
+            help: 'Number of security scan findings labeled by severity, category and scanner',
+            labelNames: ['service', 'severity', 'category', 'scanner'],
+            registers: [_registry],
+        }),
+        gatePassed: new prom_client_1.Gauge({
+            name: 'api_security_gate_passed',
+            help: '1 if the security gate passed on the last scan, 0 if it failed, -1 if not configured',
+            labelNames: ['service'],
+            registers: [_registry],
+        }),
+        scanTimestamp: new prom_client_1.Gauge({
+            name: 'api_security_scan_timestamp_seconds',
+            help: 'Unix timestamp (seconds) of the last security scan run',
+            labelNames: ['service'],
+            registers: [_registry],
+        }),
+    };
+    // Store service name for use in recordCoverageMetrics
+    _registry._serviceName = serviceName;
+    _intelligenceGauges = {
+        functionalFindingsTotal: new prom_client_1.Gauge({
+            name: 'api_coverage_functional_findings_total',
+            help: 'Total number of functional findings detected by the intelligence engine',
+            labelNames: ['project', 'coverage_type', 'language', 'framework'],
+            registers: [_registry],
+        }),
+        missingTestRecommendationsTotal: new prom_client_1.Gauge({
+            name: 'api_coverage_missing_test_recommendations_total',
+            help: 'Total number of missing test recommendations',
+            labelNames: ['project', 'coverage_type', 'language', 'framework'],
+            registers: [_registry],
+        }),
+        missingTestByPriority: new prom_client_1.Gauge({
+            name: 'api_coverage_missing_test_recommendations_by_priority',
+            help: 'Missing test recommendations grouped by priority',
+            labelNames: ['project', 'priority', 'risk_band'],
+            registers: [_registry],
+        }),
+        riskScoreMax: new prom_client_1.Gauge({
+            name: 'api_coverage_risk_score_max',
+            help: 'Maximum risk score across all recommendations',
+            labelNames: ['project'],
+            registers: [_registry],
+        }),
+        riskScoreAvg: new prom_client_1.Gauge({
+            name: 'api_coverage_risk_score_avg',
+            help: 'Average risk score across all recommendations',
+            labelNames: ['project'],
+            registers: [_registry],
+        }),
+        criticalUncoveredItems: new prom_client_1.Gauge({
+            name: 'api_coverage_critical_uncovered_items_total',
+            help: 'Total number of critical/high severity uncovered items',
+            labelNames: ['project'],
+            registers: [_registry],
+        }),
+        unprotectedSecurityFindings: new prom_client_1.Gauge({
+            name: 'api_coverage_unprotected_security_findings_total',
+            help: 'Number of security findings with no associated test protection',
+            labelNames: ['project'],
+            registers: [_registry],
+        }),
+    };
+    return _registry;
+}
+/** Return the current registry (null if not yet initialised). */
+function getRegistry() {
+    return _registry;
+}
+/**
+ * Record coverage results into the Prometheus gauges.
+ * Must be called after initMetrics().
+ */
+function recordCoverageMetrics(results, thresholds = {}, serviceName = 'api-coverage-analyzer') {
+    if (!_gauges || !_registry)
+        return;
+    for (const r of results) {
+        const labels = { service: serviceName, coverage_type: r.type };
+        const ratio = r.totalItems > 0 ? r.coveredItems / r.totalItems : 0;
+        const threshold = thresholds[r.type];
+        const failing = threshold !== undefined && r.coveragePercent < threshold ? 1 : 0;
+        _gauges.total.set(labels, r.totalItems);
+        _gauges.covered.set(labels, r.coveredItems);
+        _gauges.ratio.set(labels, ratio);
+        _gauges.thresholdFailure.set(labels, failing);
+    }
+}
+/**
+ * Record security scanning results into dedicated Prometheus gauges.
+ *
+ * Exposes:
+ *  - `api_security_findings_total{service, severity, category, scanner}` — count per label combination
+ *  - `api_security_gate_passed{service}` — 1 = passed, 0 = failed, -1 = not configured
+ *  - `api_security_scan_timestamp_seconds{service}` — Unix timestamp of this scan
+ *
+ * Must be called after initMetrics().
+ */
+function recordSecurityScanMetrics(summary, serviceName = 'api-coverage-analyzer') {
+    if (!_securityGauges || !_registry)
+        return;
+    const now = Math.floor(Date.now() / 1000);
+    _securityGauges.scanTimestamp.set({ service: serviceName }, now);
+    // Gate status: 1 passed, 0 failed, -1 not configured
+    const gateValue = summary.gateResult === undefined ? -1 : summary.gateResult.passed ? 1 : 0;
+    _securityGauges.gatePassed.set({ service: serviceName }, gateValue);
+    const severities = ['LOW', 'MEDIUM', 'HIGH', 'CRITICAL'];
+    const categories = Object.keys(summary.byCategory);
+    const scanners = summary.scannersRun.length > 0 ? summary.scannersRun : ['none'];
+    // Zero-out all combinations first so Grafana sees 0 instead of stale values
+    for (const sev of severities) {
+        for (const cat of categories) {
+            for (const scanner of scanners) {
+                _securityGauges.findings.set({ service: serviceName, severity: sev, category: cat, scanner }, 0);
+            }
+        }
+    }
+    if (summary.findings && summary.findings.length > 0) {
+        // Use the per-finding detail list when available (highest granularity)
+        for (const finding of summary.findings) {
+            _securityGauges.findings.inc({ service: serviceName, severity: finding.severity, category: finding.category, scanner: finding.scanner }, 1);
+        }
+    }
+    else {
+        // Fallback: use pre-aggregated severity counts when no per-finding list is provided
+        for (const [sev, count] of Object.entries(summary.bySeverity)) {
+            for (const scanner of scanners) {
+                _securityGauges.findings.set({ service: serviceName, severity: sev, category: 'unknown', scanner }, count);
+            }
+        }
+    }
+}
+/**
+ * Record coverage intelligence results into dedicated Prometheus gauges.
+ *
+ * Must be called after initMetrics().
+ */
+function recordIntelligenceMetrics(summary, projectName) {
+    var _a, _b, _c, _d, _e;
+    if (!_intelligenceGauges || !_registry)
+        return;
+    const project = (_a = projectName !== null && projectName !== void 0 ? projectName : summary.projectName) !== null && _a !== void 0 ? _a : 'unknown';
+    const language = (_c = (_b = summary.languages) === null || _b === void 0 ? void 0 : _b[0]) !== null && _c !== void 0 ? _c : 'unknown';
+    const framework = (_e = (_d = summary.frameworks) === null || _d === void 0 ? void 0 : _d[0]) !== null && _e !== void 0 ? _e : 'unknown';
+    _intelligenceGauges.functionalFindingsTotal.set({ project, coverage_type: 'all', language, framework }, summary.totalFindings);
+    _intelligenceGauges.missingTestRecommendationsTotal.set({ project, coverage_type: 'all', language, framework }, summary.totalRecommendations);
+    _intelligenceGauges.riskScoreMax.set({ project }, summary.maxRiskScore);
+    _intelligenceGauges.riskScoreAvg.set({ project }, summary.avgRiskScore);
+    _intelligenceGauges.criticalUncoveredItems.set({ project }, summary.criticalUncoveredItems);
+    _intelligenceGauges.unprotectedSecurityFindings.set({ project }, summary.unprotectedSecurityFindings);
+    for (const [priority, count] of Object.entries(summary.recommendationsByPriority)) {
+        // Derive a risk band label from priority
+        const riskBand = priority === 'P0' ? 'Critical' :
+            priority === 'P1' ? 'High' :
+                priority === 'P2' ? 'Moderate' : 'Low';
+        _intelligenceGauges.missingTestByPriority.set({ project, priority, risk_band: riskBand }, count);
+    }
+}
+/**
+ * Start an HTTP server that exposes /metrics in Prometheus text format.
+ * Resolves with the bound server instance once the port is open.
+ */
+function startMetricsServer(port) {
+    return new Promise((resolve, reject) => {
+        if (!_registry) {
+            reject(new Error('Metrics registry not initialised — call initMetrics() first'));
+            return;
+        }
+        const registry = _registry;
+        const server = http.createServer(async (req, res) => {
+            if (req.url === '/metrics') {
+                try {
+                    const text = await registry.metrics();
+                    res.writeHead(200, { 'Content-Type': registry.contentType });
+                    res.end(text);
+                }
+                catch (err) {
+                    res.writeHead(500);
+                    res.end(String(err));
+                }
+            }
+            else {
+                res.writeHead(404);
+                res.end('Not found');
+            }
+        });
+        server.once('error', reject);
+        server.listen(port, () => {
+            _metricsServer = server;
+            resolve(server);
+        });
+    });
+}
+/** Stop the metrics server if it is running. */
+function stopMetricsServer() {
+    return new Promise((resolve) => {
+        if (_metricsServer) {
+            _metricsServer.close(() => {
+                _metricsServer = null;
+                resolve();
+            });
+        }
+        else {
+            resolve();
+        }
+    });
+}
+/** In-memory span collector (used when no OTLP endpoint is configured). */
+const _spans = [];
+let _tracingEnabled = false;
+let _otlpEndpoint = null;
+/** Enable or disable tracing. If endpoint is provided, spans are POSTed via OTLP HTTP. */
+function initTracing(enabled, otlpEndpoint) {
+    _tracingEnabled = enabled;
+    _otlpEndpoint = otlpEndpoint !== null && otlpEndpoint !== void 0 ? otlpEndpoint : null;
+    if (enabled) {
+        _logger.debug({ event: 'tracing_init', otlpEndpoint: _otlpEndpoint !== null && _otlpEndpoint !== void 0 ? _otlpEndpoint : 'in-memory' }, 'OpenTelemetry tracing enabled');
+    }
+}
+/** Start a new span. No-op if tracing is disabled. */
+function startSpan(name, attributes = {}) {
+    const span = {
+        name,
+        startTime: Date.now(),
+        attributes: { ...attributes },
+        ended: false,
+        end(extraAttributes) {
+            if (this.ended)
+                return;
+            this.ended = true;
+            this.endTime = Date.now();
+            if (extraAttributes) {
+                Object.assign(this.attributes, extraAttributes);
+            }
+            if (_tracingEnabled) {
+                const durationMs = this.endTime - this.startTime;
+                _logger.debug({
+                    event: 'span_end',
+                    spanName: this.name,
+                    durationMs,
+                    attributes: this.attributes,
+                });
+                _spans.push(this);
+                if (_otlpEndpoint) {
+                    void exportSpanOtlp(this, _otlpEndpoint);
+                }
+            }
+        },
+    };
+    if (_tracingEnabled) {
+        _logger.debug({ event: 'span_start', spanName: name, attributes });
+    }
+    return span;
+}
+/** Return all completed spans collected in memory. */
+function getCollectedSpans() {
+    return [..._spans];
+}
+/** Clear the in-memory span buffer (useful in tests). */
+function clearCollectedSpans() {
+    _spans.length = 0;
+}
+/**
+ * Export a single span to an OTLP HTTP endpoint.
+ * This is a minimal implementation that sends a simplified JSON payload.
+ * For production use, the full @opentelemetry/exporter-trace-otlp-http package
+ * can be substituted.
+ */
+async function exportSpanOtlp(span, endpoint) {
+    var _a;
+    const url = new URL('/v1/traces', endpoint);
+    const body = JSON.stringify({
+        resourceSpans: [
+            {
+                resource: {
+                    attributes: [{ key: 'service.name', value: { stringValue: 'api-coverage-analyzer' } }],
+                },
+                scopeSpans: [
+                    {
+                        spans: [
+                            {
+                                name: span.name,
+                                startTimeUnixNano: String(span.startTime * 1000000),
+                                endTimeUnixNano: String(((_a = span.endTime) !== null && _a !== void 0 ? _a : span.startTime) * 1000000),
+                                attributes: Object.entries(span.attributes).map(([k, v]) => ({
+                                    key: k,
+                                    value: typeof v === 'string'
+                                        ? { stringValue: v }
+                                        : typeof v === 'boolean'
+                                            ? { boolValue: v }
+                                            : { intValue: v },
+                                })),
+                                status: {},
+                            },
+                        ],
+                    },
+                ],
+            },
+        ],
+    });
+    try {
+        const { default: https } = await Promise.resolve().then(() => __importStar(require('https')));
+        const { default: httpModule } = await Promise.resolve().then(() => __importStar(require('http')));
+        const mod = url.protocol === 'https:' ? https : httpModule;
+        await new Promise((resolve, reject) => {
+            const reqOptions = {
+                method: 'POST',
+                hostname: url.hostname,
+                port: url.port || undefined,
+                path: url.pathname,
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Content-Length': Buffer.byteLength(body),
+                },
+            };
+            const req = mod.request(reqOptions, (res) => {
+                res.resume();
+                res.on('end', resolve);
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+    }
+    catch (err) {
+        _logger.warn({ event: 'otlp_export_error', error: String(err) }, 'Failed to export span to OTLP endpoint');
+    }
+}
+/** Build an observability info object for embedding in reports. */
+function buildObservabilityInfo(metricsPort) {
+    return {
+        metricsUrl: metricsPort ? `http://localhost:${metricsPort}/metrics` : null,
+        tracingEnabled: _tracingEnabled,
+        otlpEndpoint: _otlpEndpoint,
+        metricNames: {
+            total: 'api_coverage_total{service="<name>",coverage_type="<type>"}',
+            covered: 'api_coverage_covered{service="<name>",coverage_type="<type>"}',
+            ratio: 'api_coverage_ratio{service="<name>",coverage_type="<type>"}',
+            thresholdFailure: 'api_coverage_threshold_failure{service="<name>",coverage_type="<type>"}',
+        },
+        securityMetricNames: {
+            findings: 'api_security_findings_total{service="<name>",severity="<sev>",category="<cat>",scanner="<scanner>"}',
+            gatePassed: 'api_security_gate_passed{service="<name>"}',
+            scanTimestamp: 'api_security_scan_timestamp_seconds{service="<name>"}',
+        },
+        intelligenceMetricNames: {
+            functionalFindingsTotal: 'api_coverage_functional_findings_total{project="<name>",coverage_type="<type>",language="<lang>",framework="<fw>"}',
+            missingTestRecommendationsTotal: 'api_coverage_missing_test_recommendations_total{project="<name>",coverage_type="<type>",language="<lang>",framework="<fw>"}',
+            missingTestByPriority: 'api_coverage_missing_test_recommendations_by_priority{project="<name>",priority="<P0-P3>",risk_band="<band>"}',
+            riskScoreMax: 'api_coverage_risk_score_max{project="<name>"}',
+            riskScoreAvg: 'api_coverage_risk_score_avg{project="<name>"}',
+            criticalUncoveredItems: 'api_coverage_critical_uncovered_items_total{project="<name>"}',
+            unprotectedSecurityFindings: 'api_coverage_unprotected_security_findings_total{project="<name>"}',
+        },
+    };
+}

package/dist/src/parameterCoverage.d.ts

@@ -0,0 +1,75 @@
+import type { AstAnalysisConfig, DeepAnalysisCoverageConfig } from './config/types';
+export interface SchemaConstraints {
+    type?: string;
+    format?: string;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    enum?: unknown[];
+}
+export interface ParameterInfo {
+    /** e.g. "POST /users" */
+    endpoint: string;
+    method: string;
+    path: string;
+    name: string;
+    location: 'path' | 'query' | 'header' | 'body';
+    required: boolean;
+    schema: SchemaConstraints;
+}
+export interface ParameterCoverage {
+    parameter: ParameterInfo;
+    validValue: boolean;
+    boundaryValue: boolean;
+    missing: boolean;
+    invalidValue: boolean;
+    /** Fraction of the four categories that are covered (0–1). */
+    ratio: number;
+    /**
+     * AST metadata when at least one coverage category was informed by semantic
+     * analysis rather than text scanning alone.
+     */
+    astMetadata?: {
+        sourceLanguage?: string;
+        resolutionType?: string;
+        confidence?: string;
+    };
+}
+/**
+ * Options to enable AST-augmented parameter coverage analysis.
+ * When provided, the AST layer supplements text-scan detection with
+ * semantic parameter scenario signals from language analyzers.
+ */
+export interface AstParameterAnalysisOptions {
+    astConfig: AstAnalysisConfig;
+    deepConfig?: DeepAnalysisCoverageConfig;
+}
+export interface ParameterCoverageReport {
+    totalParameters: number;
+    averageCoverage: number;
+    fullyCoveredPercentage: number;
+    uncoveredParameters: ParameterInfo[];
+    parameters: ParameterCoverage[];
+}
+/**
+ * Parse an OpenAPI 3 spec file and return a flat list of all parameters,
+ * including request-body properties treated as body parameters.
+ */
+export declare function parseParameters(specPath: string): Promise<ParameterInfo[]>;
+/**
+ * For each parameter, scan test files and determine which coverage
+ * categories are satisfied. Optionally augments text-scan results with
+ * AST-derived semantic signals when `astOptions` is provided.
+ */
+export declare function analyzeParameterCoverage(params: ParameterInfo[], testGlob: string, astOptions?: AstParameterAnalysisOptions): Promise<ParameterCoverage[]>;
+/**
+ * Aggregate individual parameter coverages into a summary report.
+ */
+export declare function buildParameterCoverageReport(coverages: ParameterCoverage[]): ParameterCoverageReport;
+/**
+ * Write JSON and HTML parameter-coverage reports to the given directory.
+ */
+export declare function generateParameterReports(report: ParameterCoverageReport, reportsDir: string): void;
+//# sourceMappingURL=parameterCoverage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parameterCoverage.d.ts","sourceRoot":"","sources":["../../src/parameterCoverage.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAUpF,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,yBAAyB;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC/C,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,iBAAiB,CAAC;CAC3B;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,aAAa,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;IACpB,aAAa,EAAE,OAAO,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,OAAO,CAAC;IACtB,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,WAAW,CAAC,EAAE;QACZ,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED;;;;GAIG;AACH,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,iBAAiB,CAAC;IAC7B,UAAU,CAAC,EAAE,0BAA0B,CAAC;CACzC;AAED,MAAM,WAAW,uBAAuB;IACtC,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,mBAAmB,EAAE,aAAa,EAAE,CAAC;IACrC,UAAU,EAAE,iBAAiB,EAAE,CAAC;CACjC;AA0BD;;;GAGG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAkEhF;AAyXD;;;;GAIG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,aAAa,EAAE,EACvB,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,2BAA2B,GACvC,OAAO,CAAC,iBAAiB,EAAE,CAAC,CA+D9B;AAID;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,iBAAiB,EAAE,GAAG,uBAAuB,CAuBpG;AAID;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,uBAAuB,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAwGlG"}