@vertaaux/cli 0.2.0

package/dist/policy/index.js

@@ -0,0 +1,11 @@
+/**
+ * Policy module for VertaaUX CLI.
+ *
+ * Provides policy-as-code support for organizations to define
+ * quality standards committed to the repository.
+ *
+ * Implements CICD-17: Policy-as-code support.
+ */
+export { policyJsonSchema, DEFAULT_POLICY, POLICY_TEMPLATES, } from "./schema.js";
+export { loadPolicy, loadPolicyFile, validatePolicy, resolveBranchPolicy, getEffectivePolicy, PolicyValidationError, PolicyLoadError, } from "./loader.js";
+export { evaluatePolicy, applyRuleOverrides, filterExcludedPaths, formatPolicyResult, } from "./evaluator.js";

package/dist/policy/loader.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Policy file loader and validator.
+ *
+ * Loads policy files from standard locations and validates
+ * against JSON Schema. Supports branch-specific overrides.
+ *
+ * Implements CICD-17: Policy-as-code support.
+ */
+import type { PolicyFile } from "./schema.js";
+/**
+ * Result of policy loading.
+ */
+export interface PolicyLoadResult {
+    /** The loaded policy (or default if none found) */
+    policy: PolicyFile;
+    /** Path to the policy file (null if using defaults) */
+    path: string | null;
+}
+/**
+ * Result of policy validation.
+ */
+export interface PolicyValidationResult {
+    /** Whether the policy is valid */
+    valid: boolean;
+    /** Validation error messages (empty if valid) */
+    errors: string[];
+}
+/**
+ * Error thrown when policy validation fails.
+ */
+export declare class PolicyValidationError extends Error {
+    readonly errors: string[];
+    constructor(errors: string[], filePath?: string);
+}
+/**
+ * Error thrown when policy file cannot be loaded.
+ */
+export declare class PolicyLoadError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+/**
+ * Validate a policy object against the JSON Schema.
+ *
+ * @param policy - Policy object to validate
+ * @returns Validation result with errors if invalid
+ */
+export declare function validatePolicy(policy: unknown): PolicyValidationResult;
+/**
+ * Load policy file from a specific path.
+ *
+ * @param filePath - Path to policy file
+ * @returns Loaded and validated policy
+ * @throws PolicyLoadError if file cannot be read or parsed
+ * @throws PolicyValidationError if policy fails validation
+ */
+export declare function loadPolicyFile(filePath: string): Promise<PolicyFile>;
+/**
+ * Load policy file from project root.
+ *
+ * Searches for policy file in standard locations:
+ * 1. vertaa.policy.yml
+ * 2. vertaa.policy.yaml
+ * 3. .vertaa.policy.yml
+ * 4. .vertaaux/policy.yml
+ *
+ * Returns default policy if none found.
+ *
+ * @param projectRoot - Root directory to search from (defaults to cwd)
+ * @returns Loaded policy and path (or null path if using defaults)
+ */
+export declare function loadPolicy(projectRoot?: string): Promise<PolicyLoadResult>;
+/**
+ * Resolve policy with branch-specific overrides.
+ *
+ * Looks for matching branch in policy.branches and merges
+ * branch-specific assertions with base assertions.
+ *
+ * @param policy - Base policy
+ * @param branch - Current branch name
+ * @returns Policy with branch-specific overrides applied
+ */
+export declare function resolveBranchPolicy(policy: PolicyFile, branch: string): PolicyFile;
+/**
+ * Get the effective policy for the current context.
+ *
+ * Convenience function that loads policy and resolves branch overrides.
+ *
+ * @param options - Loading options
+ * @returns Effective policy for the current branch
+ */
+export declare function getEffectivePolicy(options?: {
+    projectRoot?: string;
+    branch?: string;
+    policyPath?: string;
+}): Promise<PolicyLoadResult>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/policy/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/policy/loader.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,OAAO,KAAK,EAAE,UAAU,EAAkC,MAAM,aAAa,CAAC;AAa9E;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,mDAAmD;IACnD,MAAM,EAAE,UAAU,CAAC;IACnB,uDAAuD;IACvD,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,kCAAkC;IAClC,KAAK,EAAE,OAAO,CAAC;IACf,iDAAiD;IACjD,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;aAE5B,MAAM,EAAE,MAAM,EAAE;gBAAhB,MAAM,EAAE,MAAM,EAAE,EAChC,QAAQ,CAAC,EAAE,MAAM;CAQpB;AAED;;GAEG;AACH,qBAAa,eAAgB,SAAQ,KAAK;aAGtB,KAAK,CAAC,EAAE,OAAO;gBAD/B,OAAO,EAAE,MAAM,EACC,KAAK,CAAC,EAAE,OAAO,YAAA;CAKlC;AA+BD;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,sBAAsB,CAWtE;AAoBD;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAmB1E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,UAAU,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA8BhF;AAyED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,MAAM,GACb,UAAU,CA+BZ;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,CAAC,EAAE;IACjD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAY5B"}

package/dist/policy/loader.js

@@ -0,0 +1,281 @@
+/**
+ * Policy file loader and validator.
+ *
+ * Loads policy files from standard locations and validates
+ * against JSON Schema. Supports branch-specific overrides.
+ *
+ * Implements CICD-17: Policy-as-code support.
+ */
+import fs from "fs";
+import path from "path";
+import yaml from "yaml";
+import Ajv from "ajv";
+import { policyJsonSchema, DEFAULT_POLICY } from "./schema.js";
+/**
+ * Standard policy file locations, searched in order.
+ */
+const POLICY_FILES = [
+    "vertaa.policy.yml",
+    "vertaa.policy.yaml",
+    ".vertaa.policy.yml",
+    ".vertaaux/policy.yml",
+];
+/**
+ * Error thrown when policy validation fails.
+ */
+export class PolicyValidationError extends Error {
+    errors;
+    constructor(errors, filePath) {
+        const errorMessages = errors.map((e) => `  - ${e}`).join("\n");
+        super(`Invalid policy file${filePath ? ` (${filePath})` : ""}:\n${errorMessages}`);
+        this.errors = errors;
+        this.name = "PolicyValidationError";
+    }
+}
+/**
+ * Error thrown when policy file cannot be loaded.
+ */
+export class PolicyLoadError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this.name = "PolicyLoadError";
+    }
+}
+// Create Ajv validator instance
+const ajv = new Ajv({ strict: false, allErrors: true });
+const validateSchema = ajv.compile(policyJsonSchema);
+/**
+ * Format Ajv errors into human-readable messages.
+ */
+function formatAjvErrors(errors) {
+    if (!errors)
+        return [];
+    return errors.map((e) => {
+        const path = e.instancePath || "root";
+        const message = e.message || "unknown error";
+        // Add more context for common errors
+        if (e.keyword === "enum") {
+            const allowed = e.params.allowedValues;
+            return `${path}: ${message}. Allowed values: ${allowed?.join(", ")}`;
+        }
+        if (e.keyword === "additionalProperties") {
+            const prop = e.params.additionalProperty;
+            return `${path}: unknown property '${prop}'`;
+        }
+        return `${path}: ${message}`;
+    });
+}
+/**
+ * Validate a policy object against the JSON Schema.
+ *
+ * @param policy - Policy object to validate
+ * @returns Validation result with errors if invalid
+ */
+export function validatePolicy(policy) {
+    const valid = validateSchema(policy);
+    if (valid) {
+        return { valid: true, errors: [] };
+    }
+    return {
+        valid: false,
+        errors: formatAjvErrors(validateSchema.errors),
+    };
+}
+/**
+ * Parse YAML content into a policy object.
+ *
+ * @param content - YAML string content
+ * @param filePath - File path for error messages
+ * @returns Parsed policy object
+ */
+function parseYaml(content, filePath) {
+    try {
+        return yaml.parse(content);
+    }
+    catch (error) {
+        throw new PolicyLoadError(`Failed to parse YAML in ${filePath}: ${error instanceof Error ? error.message : String(error)}`, error);
+    }
+}
+/**
+ * Load policy file from a specific path.
+ *
+ * @param filePath - Path to policy file
+ * @returns Loaded and validated policy
+ * @throws PolicyLoadError if file cannot be read or parsed
+ * @throws PolicyValidationError if policy fails validation
+ */
+export async function loadPolicyFile(filePath) {
+    const absolutePath = path.resolve(process.cwd(), filePath);
+    // Check file exists
+    if (!fs.existsSync(absolutePath)) {
+        throw new PolicyLoadError(`Policy file not found: ${absolutePath}`);
+    }
+    // Read and parse
+    const content = fs.readFileSync(absolutePath, "utf-8");
+    const parsed = parseYaml(content, absolutePath);
+    // Validate
+    const validation = validatePolicy(parsed);
+    if (!validation.valid) {
+        throw new PolicyValidationError(validation.errors, absolutePath);
+    }
+    return parsed;
+}
+/**
+ * Load policy file from project root.
+ *
+ * Searches for policy file in standard locations:
+ * 1. vertaa.policy.yml
+ * 2. vertaa.policy.yaml
+ * 3. .vertaa.policy.yml
+ * 4. .vertaaux/policy.yml
+ *
+ * Returns default policy if none found.
+ *
+ * @param projectRoot - Root directory to search from (defaults to cwd)
+ * @returns Loaded policy and path (or null path if using defaults)
+ */
+export async function loadPolicy(projectRoot) {
+    const root = projectRoot || process.cwd();
+    // Search for policy file in standard locations
+    for (const filename of POLICY_FILES) {
+        const filePath = path.join(root, filename);
+        if (fs.existsSync(filePath)) {
+            try {
+                const policy = await loadPolicyFile(filePath);
+                return { policy, path: filePath };
+            }
+            catch (error) {
+                // Re-throw validation and load errors
+                if (error instanceof PolicyValidationError ||
+                    error instanceof PolicyLoadError) {
+                    throw error;
+                }
+                // Wrap unexpected errors
+                throw new PolicyLoadError(`Failed to load policy from ${filePath}: ${error instanceof Error ? error.message : String(error)}`, error);
+            }
+        }
+    }
+    // No policy file found, return defaults
+    return { policy: { ...DEFAULT_POLICY }, path: null };
+}
+/**
+ * Check if a branch matches a pattern.
+ *
+ * Supports simple glob patterns:
+ * - Exact match: "main"
+ * - Wildcard suffix: "release/*"
+ * - Wildcard prefix: "* /hotfix"
+ * - Full match: "*"
+ *
+ * @param branch - Branch name to check
+ * @param pattern - Pattern to match against
+ * @returns Whether the branch matches the pattern
+ */
+function matchBranch(branch, pattern) {
+    // Exact match
+    if (pattern === branch)
+        return true;
+    // Full wildcard
+    if (pattern === "*")
+        return true;
+    // Wildcard suffix: "release/*" matches "release/1.0"
+    if (pattern.endsWith("/*")) {
+        const prefix = pattern.slice(0, -2);
+        return branch.startsWith(prefix + "/");
+    }
+    // Wildcard prefix: "*/hotfix" matches "feature/hotfix"
+    if (pattern.startsWith("*/")) {
+        const suffix = pattern.slice(2);
+        return branch.endsWith("/" + suffix);
+    }
+    return false;
+}
+/**
+ * Deep merge two assertion objects.
+ *
+ * Override values take precedence over base values.
+ * Undefined values in override do not overwrite base values.
+ */
+function mergeAssertions(base, override) {
+    return {
+        ...base,
+        // Only override defined values
+        ...(override.overall_score !== undefined && {
+            overall_score: override.overall_score,
+        }),
+        ...(override.accessibility_score !== undefined && {
+            accessibility_score: override.accessibility_score,
+        }),
+        ...(override.ux_score !== undefined && { ux_score: override.ux_score }),
+        ...(override.performance_score !== undefined && {
+            performance_score: override.performance_score,
+        }),
+        ...(override.fail_on !== undefined && { fail_on: override.fail_on }),
+        ...(override.max_new_errors !== undefined && {
+            max_new_errors: override.max_new_errors,
+        }),
+        ...(override.max_new_warnings !== undefined && {
+            max_new_warnings: override.max_new_warnings,
+        }),
+        ...(override.max_new_total !== undefined && {
+            max_new_total: override.max_new_total,
+        }),
+    };
+}
+/**
+ * Resolve policy with branch-specific overrides.
+ *
+ * Looks for matching branch in policy.branches and merges
+ * branch-specific assertions with base assertions.
+ *
+ * @param policy - Base policy
+ * @param branch - Current branch name
+ * @returns Policy with branch-specific overrides applied
+ */
+export function resolveBranchPolicy(policy, branch) {
+    // No branches configured
+    if (!policy.branches || !branch) {
+        return policy;
+    }
+    // Find matching branch config
+    let matchedConfig;
+    let matchedKey;
+    for (const [key, config] of Object.entries(policy.branches)) {
+        // Use pattern if specified, otherwise use key as exact match
+        const pattern = config.pattern || key;
+        if (matchBranch(branch, pattern)) {
+            matchedConfig = config;
+            matchedKey = key;
+            break;
+        }
+    }
+    // No matching branch
+    if (!matchedConfig || !matchedConfig.assertions) {
+        return policy;
+    }
+    // Merge assertions
+    return {
+        ...policy,
+        assertions: mergeAssertions(policy.assertions, matchedConfig.assertions),
+    };
+}
+/**
+ * Get the effective policy for the current context.
+ *
+ * Convenience function that loads policy and resolves branch overrides.
+ *
+ * @param options - Loading options
+ * @returns Effective policy for the current branch
+ */
+export async function getEffectivePolicy(options) {
+    const { projectRoot, branch, policyPath } = options || {};
+    // Load from specific path or search
+    const { policy, path: foundPath } = policyPath
+        ? { policy: await loadPolicyFile(policyPath), path: policyPath }
+        : await loadPolicy(projectRoot);
+    // Resolve branch overrides if branch is known
+    const resolved = branch ? resolveBranchPolicy(policy, branch) : policy;
+    return { policy: resolved, path: foundPath };
+}

package/dist/policy/schema.d.ts

@@ -0,0 +1,297 @@
+/**
+ * Policy file schema for vertaa.policy.yml.
+ *
+ * Enables policy-as-code for organizations to define:
+ * - Quality thresholds and assertions
+ * - Rule severity overrides
+ * - Branch-specific policies
+ * - Bypass labels for emergency deploys
+ *
+ * Modeled on Semgrep/ESLint policy patterns.
+ *
+ * Implements CICD-17: Policy-as-code support.
+ */
+/**
+ * Policy file structure for vertaa.policy.yml.
+ */
+export interface PolicyFile {
+    /** JSON Schema reference for IDE support */
+    $schema?: string;
+    /** Policy format version */
+    version: 1;
+    /** Human-readable policy name */
+    name?: string;
+    /** Policy description */
+    description?: string;
+    /** Threshold assertions - fail if not met */
+    assertions: PolicyAssertions;
+    /** Rule-specific customizations */
+    rules?: Record<string, RuleOverride>;
+    /** Branch-specific policy overrides */
+    branches?: Record<string, BranchPolicy>;
+    /** Labels that bypass quality gate */
+    bypass_labels?: string[];
+    /** Paths to exclude from auditing */
+    exclude_paths?: string[];
+    /** Required minimum CLI version */
+    required_version?: string;
+}
+/**
+ * Policy assertions that must pass for the gate to pass.
+ */
+export interface PolicyAssertions {
+    /** Minimum overall score (0-100) */
+    overall_score?: number;
+    /** Minimum accessibility score */
+    accessibility_score?: number;
+    /** Minimum UX score */
+    ux_score?: number;
+    /** Minimum performance score */
+    performance_score?: number;
+    /** Fail on issues at or above this severity */
+    fail_on?: "error" | "warning" | "info";
+    /** Maximum new error-severity issues allowed */
+    max_new_errors?: number;
+    /** Maximum new warning-severity issues allowed */
+    max_new_warnings?: number;
+    /** Maximum total new issues allowed */
+    max_new_total?: number;
+}
+/**
+ * Rule-specific override configuration.
+ */
+export interface RuleOverride {
+    /** Override severity: error, warning, info, or ignore */
+    severity: "error" | "warning" | "info" | "ignore";
+    /** Reason for override (for audit trail) */
+    reason?: string;
+    /** Override only applies to these paths (glob patterns) */
+    paths?: string[];
+}
+/**
+ * Branch-specific policy configuration.
+ */
+export interface BranchPolicy {
+    /** Branch pattern (glob) - if not specified, uses the branch name as exact match */
+    pattern?: string;
+    /** Override assertions for this branch */
+    assertions?: Partial<PolicyAssertions>;
+}
+/**
+ * JSON Schema for vertaa.policy.yml validation.
+ *
+ * Used for:
+ * - Runtime validation with Ajv
+ * - IDE autocompletion and validation
+ * - Documentation generation
+ */
+export declare const policyJsonSchema: {
+    $schema: string;
+    $id: string;
+    title: string;
+    description: string;
+    type: string;
+    properties: {
+        $schema: {
+            type: string;
+            description: string;
+        };
+        version: {
+            type: string;
+            enum: number[];
+            description: string;
+        };
+        name: {
+            type: string;
+            description: string;
+        };
+        description: {
+            type: string;
+            description: string;
+        };
+        assertions: {
+            type: string;
+            description: string;
+            properties: {
+                overall_score: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                    description: string;
+                };
+                accessibility_score: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                    description: string;
+                };
+                ux_score: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                    description: string;
+                };
+                performance_score: {
+                    type: string;
+                    minimum: number;
+                    maximum: number;
+                    description: string;
+                };
+                fail_on: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                max_new_errors: {
+                    type: string;
+                    minimum: number;
+                    description: string;
+                };
+                max_new_warnings: {
+                    type: string;
+                    minimum: number;
+                    description: string;
+                };
+                max_new_total: {
+                    type: string;
+                    minimum: number;
+                    description: string;
+                };
+            };
+            additionalProperties: boolean;
+        };
+        rules: {
+            type: string;
+            description: string;
+            additionalProperties: {
+                type: string;
+                properties: {
+                    severity: {
+                        type: string;
+                        enum: string[];
+                        description: string;
+                    };
+                    reason: {
+                        type: string;
+                        description: string;
+                    };
+                    paths: {
+                        type: string;
+                        items: {
+                            type: string;
+                        };
+                        description: string;
+                    };
+                };
+                required: string[];
+                additionalProperties: boolean;
+            };
+        };
+        branches: {
+            type: string;
+            description: string;
+            additionalProperties: {
+                type: string;
+                properties: {
+                    pattern: {
+                        type: string;
+                        description: string;
+                    };
+                    assertions: {
+                        $ref: string;
+                        description: string;
+                    };
+                };
+                additionalProperties: boolean;
+            };
+        };
+        bypass_labels: {
+            type: string;
+            items: {
+                type: string;
+            };
+            description: string;
+        };
+        exclude_paths: {
+            type: string;
+            items: {
+                type: string;
+            };
+            description: string;
+        };
+        required_version: {
+            type: string;
+            description: string;
+        };
+    };
+    required: string[];
+    additionalProperties: boolean;
+};
+/**
+ * Default policy with sensible enterprise defaults.
+ *
+ * - Only fail on errors (not warnings/info)
+ * - Only fail on NEW errors (existing debt allowed)
+ * - Common emergency bypass labels
+ */
+export declare const DEFAULT_POLICY: PolicyFile;
+/**
+ * Policy templates for different strictness levels.
+ */
+export declare const POLICY_TEMPLATES: {
+    /**
+     * Basic template - fail only on new errors.
+     */
+    basic: {
+        version: 1;
+        name: string;
+        description: string;
+        assertions: {
+            fail_on: "error";
+            max_new_errors: number;
+        };
+        bypass_labels: string[];
+    };
+    /**
+     * Strict template - fail on warnings, require minimum scores.
+     */
+    strict: {
+        version: 1;
+        name: string;
+        description: string;
+        assertions: {
+            fail_on: "warning";
+            overall_score: number;
+            max_new_errors: number;
+            max_new_warnings: number;
+        };
+        branches: {
+            main: {
+                assertions: {
+                    overall_score: number;
+                };
+            };
+            "release/*": {
+                pattern: string;
+                assertions: {
+                    overall_score: number;
+                };
+            };
+        };
+        bypass_labels: string[];
+    };
+    /**
+     * Lenient template - fail only on critical errors.
+     */
+    lenient: {
+        version: 1;
+        name: string;
+        description: string;
+        assertions: {
+            fail_on: "error";
+        };
+        bypass_labels: string[];
+    };
+};
+export type PolicyTemplate = keyof typeof POLICY_TEMPLATES;
+//# sourceMappingURL=schema.d.ts.map

package/dist/policy/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/policy/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,4CAA4C;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,4BAA4B;IAC5B,OAAO,EAAE,CAAC,CAAC;IAEX,iCAAiC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,yBAAyB;IACzB,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,6CAA6C;IAC7C,UAAU,EAAE,gBAAgB,CAAC;IAE7B,mCAAmC;IACnC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAErC,uCAAuC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAExC,sCAAsC;IACtC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB,qCAAqC;IACrC,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IAEzB,mCAAmC;IACnC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,oCAAoC;IACpC,aAAa,CAAC,EAAE,MAAM,CAAC;IAEvB,kCAAkC;IAClC,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAE7B,uBAAuB;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,gCAAgC;IAChC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAE3B,+CAA+C;IAC/C,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IAEvC,gDAAgD;IAChD,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,kDAAkD;IAClD,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B,uCAAuC;IACvC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,yDAAyD;IACzD,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;IAElD,4CAA4C;IAC5C,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,2DAA2D;IAC3D,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,oFAAoF;IACpF,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,0CAA0C;IAC1C,UAAU,CAAC,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC;CACxC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0I5B,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,EAAE,UAO5B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B;;OAEG;;;;;;;;;;;IAYH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;IA4BH;;OAEG;;;;;;;;;;CAUiC,CAAC;AAEvC,MAAM,MAAM,cAAc,GAAG,MAAM,OAAO,gBAAgB,CAAC"}