@eddacraft/anvil-runtime 0.1.0

package/dist/gate/checks/architecture/dependency-analyzer.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Dependency Analyzer - Wrapper for dependency-cruiser
+ *
+ * Handles loading and executing dependency-cruiser for architectural analysis.
+ */
+/**
+ * Violation from dependency-cruiser
+ */
+export interface CruiserViolation {
+    from: string;
+    to: string;
+    rule: {
+        name: string;
+        severity: 'error' | 'warn' | 'info' | 'ignore';
+    };
+    cycle?: string[];
+    comment?: string;
+}
+/**
+ * Summary from dependency-cruiser
+ */
+export interface CruiserSummary {
+    violations: CruiserViolation[];
+    error: number;
+    warn: number;
+    info: number;
+    totalCruised: number;
+}
+/**
+ * Cruise result from dependency-cruiser
+ */
+export interface ICruiseResult {
+    summary: CruiserSummary;
+    modules: unknown[];
+}
+/**
+ * Cruise function type
+ */
+export type CruiseFn = (fileAndDirectoryArray: string[], options?: Record<string, unknown>) => Promise<{
+    output: ICruiseResult;
+}>;
+/**
+ * Result of dependency analysis
+ */
+export interface AnalysisResult {
+    success: boolean;
+    result?: ICruiseResult;
+    error?: string;
+    skipped?: boolean;
+    reason?: string;
+}
+/**
+ * Dependency analyzer that wraps dependency-cruiser
+ */
+export declare class DependencyAnalyzer {
+    private cruiseFn;
+    /**
+     * Load dependency-cruiser dynamically
+     */
+    loadCruiser(): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Check if dependency-cruiser is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Load dependency-cruiser configuration
+     */
+    loadConfig(workspaceRoot: string, configFile: string): Promise<Record<string, unknown> | null>;
+    /**
+     * Get default cruise options when no config file exists
+     */
+    getDefaultCruiseOptions(): Record<string, unknown>;
+    /**
+     * Run dependency analysis
+     */
+    analyze(filesToCruise: string[], cruiseOptions: Record<string, unknown>): Promise<AnalysisResult>;
+}
+//# sourceMappingURL=dependency-analyzer.d.ts.map

package/dist/gate/checks/architecture/dependency-analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-analyzer.d.ts","sourceRoot":"","sources":["../../../../src/gate/checks/architecture/dependency-analyzer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE;QACJ,IAAI,EAAE,MAAM,CAAC;QACb,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,CAAC;KAChD,CAAC;IACF,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,cAAc,CAAC;IACxB,OAAO,EAAE,OAAO,EAAE,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG,CACrB,qBAAqB,EAAE,MAAM,EAAE,EAC/B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC9B,OAAO,CAAC;IAAE,MAAM,EAAE,aAAa,CAAA;CAAE,CAAC,CAAC;AAExC;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAyB;IAEzC;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAoBlE;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACG,UAAU,CACd,aAAa,EAAE,MAAM,EACrB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAkB1C;;OAEG;IACH,uBAAuB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAkClD;;OAEG;IACG,OAAO,CACX,aAAa,EAAE,MAAM,EAAE,EACvB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACrC,OAAO,CAAC,cAAc,CAAC;CAwC3B"}

package/dist/gate/checks/architecture/dependency-analyzer.js

@@ -0,0 +1,136 @@
+/**
+ * Dependency Analyzer - Wrapper for dependency-cruiser
+ *
+ * Handles loading and executing dependency-cruiser for architectural analysis.
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { createDebugger } from '@eddacraft/anvil-core';
+const log = createDebugger('check');
+/**
+ * Dependency analyzer that wraps dependency-cruiser
+ */
+export class DependencyAnalyzer {
+    cruiseFn = null;
+    /**
+     * Load dependency-cruiser dynamically
+     */
+    async loadCruiser() {
+        log('dependency-analyzer: loading dependency-cruiser');
+        try {
+            // Dynamic import - dependency-cruiser is an optional peer dependency
+            // Using Function constructor to avoid bundler static analysis
+            const depCruiser = (await Function('return import("dependency-cruiser")')());
+            this.cruiseFn = depCruiser.cruise;
+            log('dependency-analyzer: dependency-cruiser loaded successfully');
+            return { success: true };
+        }
+        catch {
+            log('dependency-analyzer: dependency-cruiser not installed');
+            return {
+                success: false,
+                error: 'dependency-cruiser not installed',
+            };
+        }
+    }
+    /**
+     * Check if dependency-cruiser is available
+     */
+    isAvailable() {
+        return this.cruiseFn !== null;
+    }
+    /**
+     * Load dependency-cruiser configuration
+     */
+    async loadConfig(workspaceRoot, configFile) {
+        const configPath = join(workspaceRoot, configFile);
+        if (!existsSync(configPath)) {
+            log(`dependency-analyzer: config file not found at ${configPath}`);
+            return null;
+        }
+        try {
+            const configModule = await import(configPath);
+            log(`dependency-analyzer: config loaded from ${configPath}`);
+            return configModule.default || configModule;
+        }
+        catch {
+            log(`dependency-analyzer: failed to load config from ${configPath}`);
+            return null;
+        }
+    }
+    /**
+     * Get default cruise options when no config file exists
+     */
+    getDefaultCruiseOptions() {
+        return {
+            validate: true,
+            ruleSet: {
+                forbidden: [
+                    {
+                        name: 'no-circular',
+                        severity: 'error',
+                        comment: 'Circular dependencies are not allowed',
+                        from: {},
+                        to: {
+                            circular: true,
+                        },
+                    },
+                    {
+                        name: 'no-orphans',
+                        severity: 'warn',
+                        comment: 'Modules without dependents or dependencies',
+                        from: {
+                            orphan: true,
+                            pathNot: [
+                                '\\.d\\.ts$',
+                                '\\.test\\.(ts|js)$',
+                                '\\.spec\\.(ts|js)$',
+                                'index\\.(ts|js)$',
+                            ],
+                        },
+                        to: {},
+                    },
+                ],
+            },
+        };
+    }
+    /**
+     * Run dependency analysis
+     */
+    async analyze(filesToCruise, cruiseOptions) {
+        if (!this.cruiseFn) {
+            log('dependency-analyzer: cruise function not available, skipping analysis');
+            return {
+                success: false,
+                skipped: true,
+                reason: 'dependency-cruiser not available',
+            };
+        }
+        log(`dependency-analyzer: analysing ${filesToCruise.length} files/patterns`);
+        try {
+            const cruiseResult = await this.cruiseFn(filesToCruise, {
+                ...cruiseOptions,
+                outputType: 'json',
+            });
+            const summary = cruiseResult.output.summary;
+            log('dependency-analyzer: analysis complete', {
+                totalCruised: summary.totalCruised,
+                violations: summary.violations.length,
+                error: summary.error,
+                warn: summary.warn,
+                info: summary.info,
+            });
+            return {
+                success: true,
+                result: cruiseResult.output,
+            };
+        }
+        catch (error) {
+            log(`dependency-analyzer: analysis failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    }
+}

package/dist/gate/checks/architecture/layer-validator.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Layer Validator - Score calculation and validation for architecture violations
+ *
+ * Handles scoring, pass/fail determination, and severity-based blocking.
+ */
+import type { CruiserViolation } from './dependency-analyzer.js';
+/**
+ * Configuration for architecture check
+ */
+export interface ArchitectureCheckConfig {
+    /** Path to dependency-cruiser config (default: .anvil/dependency-cruiser.js) */
+    config_file?: string;
+    /** Scope of analysis: 'affected' | 'full' */
+    scope?: 'affected' | 'full';
+    /** Minimum severity to fail the check */
+    severity_threshold?: 'error' | 'warn' | 'info';
+    /** Whether circular dependencies should fail the check */
+    fail_on_circular?: boolean;
+    /** Whether orphaned modules should fail the check */
+    fail_on_orphan?: boolean;
+    /** Include patterns (glob) for full scope */
+    include_patterns?: string[];
+    /** Exclude patterns (glob) */
+    exclude_patterns?: string[];
+}
+/**
+ * Default configuration
+ */
+export declare const DEFAULT_CONFIG: Required<ArchitectureCheckConfig>;
+/**
+ * Result of score calculation
+ */
+export interface ScoreResult {
+    score: number;
+    passed: boolean;
+    violationsByType: Record<string, number>;
+}
+/**
+ * Layer validator for architecture constraints
+ */
+export declare class LayerValidator {
+    /**
+     * Parse and validate check configuration
+     */
+    parseConfig(checkConfig: Record<string, unknown>): Required<ArchitectureCheckConfig>;
+    /**
+     * Parse scope option
+     */
+    private parseScope;
+    /**
+     * Parse severity threshold
+     */
+    private parseSeverity;
+    /**
+     * Calculate score based on violations
+     */
+    calculateScore(violations: CruiserViolation[], config: Required<ArchitectureCheckConfig>): ScoreResult;
+    /**
+     * Check if a severity level should block the check
+     */
+    private isBlockingSeverity;
+    /**
+     * Check if a file should be analysed
+     */
+    isAnalysableFile(filePath: string, config: Required<ArchitectureCheckConfig>): boolean;
+    /**
+     * Simple glob pattern matching (for common patterns)
+     */
+    private matchesGlobPattern;
+    /**
+     * Build human-readable message
+     */
+    buildMessage(violations: CruiserViolation[], totalCruised: number, passed: boolean): string;
+}
+//# sourceMappingURL=layer-validator.d.ts.map

package/dist/gate/checks/architecture/layer-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-validator.d.ts","sourceRoot":"","sources":["../../../../src/gate/checks/architecture/layer-validator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAKjE;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,gFAAgF;IAChF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6CAA6C;IAC7C,KAAK,CAAC,EAAE,UAAU,GAAG,MAAM,CAAC;IAC5B,yCAAyC;IACzC,kBAAkB,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;IAC/C,0DAA0D;IAC1D,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,qDAAqD;IACrD,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,6CAA6C;IAC7C,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,8BAA8B;IAC9B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC7B;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,uBAAuB,CAc5D,CAAC;AAYF;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C;AAED;;GAEG;AACH,qBAAa,cAAc;IACzB;;OAEG;IACH,WAAW,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,QAAQ,CAAC,uBAAuB,CAAC;IAoBpF;;OAEG;IACH,OAAO,CAAC,UAAU;IAOlB;;OAEG;IACH,OAAO,CAAC,aAAa;IASrB;;OAEG;IACH,cAAc,CACZ,UAAU,EAAE,gBAAgB,EAAE,EAC9B,MAAM,EAAE,QAAQ,CAAC,uBAAuB,CAAC,GACxC,WAAW;IA8Dd;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAQ1B;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,uBAAuB,CAAC,GAAG,OAAO;IAgBtF;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAe1B;;OAEG;IACH,YAAY,CAAC,UAAU,EAAE,gBAAgB,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,MAAM;CAiB5F"}

package/dist/gate/checks/architecture/layer-validator.js

@@ -0,0 +1,193 @@
+/**
+ * Layer Validator - Score calculation and validation for architecture violations
+ *
+ * Handles scoring, pass/fail determination, and severity-based blocking.
+ */
+import { createDebugger } from '@eddacraft/anvil-core';
+const log = createDebugger('check');
+/**
+ * Default configuration
+ */
+export const DEFAULT_CONFIG = {
+    config_file: '.anvil/dependency-cruiser.js',
+    scope: 'affected',
+    severity_threshold: 'error',
+    fail_on_circular: true,
+    fail_on_orphan: false,
+    include_patterns: ['src/**/*.ts', 'src/**/*.js'],
+    exclude_patterns: [
+        '**/*.test.ts',
+        '**/*.spec.ts',
+        '**/__fixtures__/**',
+        '**/__tests__/**',
+        '**/node_modules/**',
+    ],
+};
+/**
+ * Score penalties per severity
+ */
+const SEVERITY_PENALTIES = {
+    error: 15,
+    warn: 5,
+    info: 1,
+    ignore: 0,
+};
+/**
+ * Layer validator for architecture constraints
+ */
+export class LayerValidator {
+    /**
+     * Parse and validate check configuration
+     */
+    parseConfig(checkConfig) {
+        return {
+            config_file: typeof checkConfig.config_file === 'string'
+                ? checkConfig.config_file
+                : DEFAULT_CONFIG.config_file,
+            scope: this.parseScope(checkConfig.scope),
+            severity_threshold: this.parseSeverity(checkConfig.severity_threshold) || DEFAULT_CONFIG.severity_threshold,
+            fail_on_circular: checkConfig.fail_on_circular !== false,
+            fail_on_orphan: checkConfig.fail_on_orphan === true,
+            include_patterns: Array.isArray(checkConfig.include_patterns)
+                ? checkConfig.include_patterns.filter((p) => typeof p === 'string')
+                : DEFAULT_CONFIG.include_patterns,
+            exclude_patterns: Array.isArray(checkConfig.exclude_patterns)
+                ? checkConfig.exclude_patterns.filter((p) => typeof p === 'string')
+                : DEFAULT_CONFIG.exclude_patterns,
+        };
+    }
+    /**
+     * Parse scope option
+     */
+    parseScope(value) {
+        if (value === 'full' || value === 'affected') {
+            return value;
+        }
+        return DEFAULT_CONFIG.scope;
+    }
+    /**
+     * Parse severity threshold
+     */
+    parseSeverity(value) {
+        if (typeof value !== 'string')
+            return undefined;
+        const lower = value.toLowerCase();
+        if (lower === 'error' || lower === 'warn' || lower === 'info') {
+            return lower;
+        }
+        return undefined;
+    }
+    /**
+     * Calculate score based on violations
+     */
+    calculateScore(violations, config) {
+        log(`layer-validator: calculating score for ${violations.length} violations (threshold=${config.severity_threshold})`);
+        const violationsByType = {
+            circular: 0,
+            orphan: 0,
+            layer: 0,
+            other: 0,
+        };
+        let totalPenalty = 0;
+        let hasBlockingViolation = false;
+        for (const v of violations) {
+            // Categorise violation
+            if (v.cycle && v.cycle.length > 0) {
+                violationsByType.circular++;
+                if (config.fail_on_circular &&
+                    this.isBlockingSeverity(v.rule.severity, config.severity_threshold)) {
+                    hasBlockingViolation = true;
+                }
+            }
+            else if (v.rule.name.includes('orphan')) {
+                violationsByType.orphan++;
+                if (config.fail_on_orphan &&
+                    this.isBlockingSeverity(v.rule.severity, config.severity_threshold)) {
+                    hasBlockingViolation = true;
+                }
+            }
+            else if (v.rule.name.includes('layer') || v.rule.name.includes('boundary')) {
+                violationsByType.layer++;
+                if (this.isBlockingSeverity(v.rule.severity, config.severity_threshold)) {
+                    hasBlockingViolation = true;
+                }
+            }
+            else {
+                violationsByType.other++;
+                if (this.isBlockingSeverity(v.rule.severity, config.severity_threshold)) {
+                    hasBlockingViolation = true;
+                }
+            }
+            // Calculate penalty
+            totalPenalty += SEVERITY_PENALTIES[v.rule.severity] || 0;
+        }
+        const score = Math.max(0, 100 - totalPenalty);
+        const passed = !hasBlockingViolation;
+        log('layer-validator result', {
+            score,
+            passed,
+            penalty: totalPenalty,
+            blocking: hasBlockingViolation,
+            violationsByType,
+        });
+        return { score, passed, violationsByType };
+    }
+    /**
+     * Check if a severity level should block the check
+     */
+    isBlockingSeverity(severity, threshold) {
+        const levels = { error: 3, warn: 2, info: 1, ignore: 0 };
+        return levels[severity] >= levels[threshold];
+    }
+    /**
+     * Check if a file should be analysed
+     */
+    isAnalysableFile(filePath, config) {
+        const analysableExtensions = ['.js', '.ts', '.jsx', '.tsx', '.mjs', '.cjs'];
+        const hasValidExtension = analysableExtensions.some((ext) => filePath.endsWith(ext));
+        if (!hasValidExtension)
+            return false;
+        // Check exclusions
+        for (const pattern of config.exclude_patterns) {
+            if (this.matchesGlobPattern(filePath, pattern)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Simple glob pattern matching (for common patterns)
+     */
+    matchesGlobPattern(filePath, pattern) {
+        // Normalise to forward slashes for consistent cross-platform matching
+        const normalizedPath = filePath.replace(/\\/g, '/');
+        // Convert glob to regex (simplified)
+        const regexPattern = pattern
+            .replace(/\*\*/g, '{{GLOBSTAR}}')
+            .replace(/\*/g, '[^/]*')
+            .replace(/{{GLOBSTAR}}/g, '.*')
+            .replace(/\?/g, '.');
+        const regex = new RegExp(regexPattern);
+        return regex.test(normalizedPath);
+    }
+    /**
+     * Build human-readable message
+     */
+    buildMessage(violations, totalCruised, passed) {
+        if (violations.length === 0) {
+            return `Architecture check passed: ${totalCruised} modules analysed, no violations`;
+        }
+        const errorCount = violations.filter((v) => v.rule.severity === 'error').length;
+        const warnCount = violations.filter((v) => v.rule.severity === 'warn').length;
+        const infoCount = violations.filter((v) => v.rule.severity === 'info').length;
+        const parts = [];
+        if (errorCount > 0)
+            parts.push(`${errorCount} error${errorCount > 1 ? 's' : ''}`);
+        if (warnCount > 0)
+            parts.push(`${warnCount} warning${warnCount > 1 ? 's' : ''}`);
+        if (infoCount > 0)
+            parts.push(`${infoCount} info`);
+        const status = passed ? 'passed with issues' : 'failed';
+        return `Architecture check ${status}: ${parts.join(', ')} (${totalCruised} modules analysed)`;
+    }
+}

package/dist/gate/checks/architecture.check.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Architecture Check - Validate architectural constraints using dependency-cruiser
+ *
+ * Detects:
+ * - Circular dependencies
+ * - Layer/boundary violations
+ * - Orphaned modules (optional)
+ */
+import { BaseCheck } from '../check.interface.js';
+import { CheckContext, GateResult } from '../../types/gate.types.js';
+export type { ArchitectureCheckConfig } from './architecture/layer-validator.js';
+/**
+ * Architecture check that validates project structure using dependency-cruiser
+ */
+export declare class ArchitectureCheck extends BaseCheck {
+    name: string;
+    description: string;
+    private analyzer;
+    private detector;
+    private validator;
+    run(context: CheckContext): Promise<GateResult>;
+    private convertViolationToWarning;
+    private mapCruiserSeverity;
+    private createArchWarningResult;
+    /**
+     * Get files to cruise based on scope
+     */
+    private getFilesToCruise;
+    /**
+     * Check if a file should be analysed
+     * @internal Reserved for future use
+     */
+    private _isAnalysableFile;
+    private matchesGlobPattern;
+    /**
+     * Get default cruise options when no config file exists
+     * @internal Reserved for future use
+     */
+    private _getDefaultCruiseOptions;
+    /**
+     * Calculate score based on violations
+     * @internal Reserved for future use
+     */
+    private _calculateScore;
+    /**
+     * Check if a severity level should block the check
+     */
+    private isBlockingSeverity;
+    /**
+     * Build human-readable message
+     * @internal Reserved for future use
+     */
+    private _buildMessage;
+    private buildArchitectureContext;
+}
+//# sourceMappingURL=architecture.check.d.ts.map

package/dist/gate/checks/architecture.check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"architecture.check.d.ts","sourceRoot":"","sources":["../../../src/gate/checks/architecture.check.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,UAAU,EAAuB,MAAM,2BAA2B,CAAC;AA0B1F,YAAY,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AA2CjF;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,SAAS;IAC9C,IAAI,SAAkB;IACtB,WAAW,SAAiE;IAE5E,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,QAAQ,CAA0B;IAC1C,OAAO,CAAC,SAAS,CAAwB;IAEnC,GAAG,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,UAAU,CAAC;IAyJrD,OAAO,CAAC,yBAAyB;IAqCjC,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,uBAAuB;IAU/B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAsBxB;;;OAGG;IAEH,OAAO,CAAC,iBAAiB;IAgBzB,OAAO,CAAC,kBAAkB;IAM1B;;;OAGG;IAEH,OAAO,CAAC,wBAAwB;IAkChC;;;OAGG;IAEH,OAAO,CAAC,eAAe;IA0DvB;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAQ1B;;;OAGG;IAEH,OAAO,CAAC,aAAa;IAsBrB,OAAO,CAAC,wBAAwB;CA6CjC"}