@paths.design/caws-cli 8.0.0 → 8.1.0

package/dist/test-analysis.js

@@ -82,12 +82,117 @@ class WaiverPatternLearner {
   }
 
   /**
-   * Load historical working specs (mock implementation)
+   * Load historical working specs from git history
+   * Retrieves past versions of spec files to analyze patterns
    */
   loadHistoricalSpecs() {
-    // In a real implementation, this would load from git history or a local cache
-    // For v0.1, we'll use mock data based on waivers
-    return [];
+    const { execSync } = require('child_process');
+    const specs = [];
+
+    try {
+      // Get list of commits that modified spec files
+      const specPaths = [
+        '.caws/working-spec.yaml',
+        '.caws/specs/*.yaml',
+      ];
+
+      for (const specPattern of specPaths) {
+        try {
+          // Get commits that touched spec files
+          const logOutput = execSync(
+            `git log --pretty=format:"%H" --follow -- "${specPattern}" 2>/dev/null | head -20`,
+            { cwd: this.projectRoot, encoding: 'utf8' }
+          ).trim();
+
+          if (!logOutput) continue;
+
+          const commits = logOutput.split('\n').filter(Boolean);
+
+          for (const commitHash of commits) {
+            try {
+              // Get the list of files matching the pattern at that commit
+              const filesOutput = execSync(
+                `git ls-tree -r --name-only ${commitHash} -- "${specPattern}" 2>/dev/null`,
+                { cwd: this.projectRoot, encoding: 'utf8' }
+              ).trim();
+
+              if (!filesOutput) continue;
+
+              const files = filesOutput.split('\n').filter(Boolean);
+
+              for (const filePath of files) {
+                try {
+                  // Get the spec content at that commit
+                  const specContent = execSync(
+                    `git show ${commitHash}:"${filePath}" 2>/dev/null`,
+                    { cwd: this.projectRoot, encoding: 'utf8' }
+                  );
+
+                  const spec = yaml.load(specContent);
+                  if (spec && spec.id) {
+                    // Get commit date for context
+                    const commitDate = execSync(
+                      `git show -s --format=%ci ${commitHash}`,
+                      { cwd: this.projectRoot, encoding: 'utf8' }
+                    ).trim();
+
+                    specs.push({
+                      ...spec,
+                      _commit: commitHash.substring(0, 7),
+                      _date: commitDate,
+                      _file: filePath,
+                    });
+                  }
+                } catch {
+                  // Skip files that can't be loaded
+                }
+              }
+            } catch {
+              // Skip commits with issues
+            }
+          }
+        } catch {
+          // Pattern didn't match any files
+        }
+      }
+
+      // Also check archived specs in .caws/archive/
+      const archiveDir = path.join(this.projectRoot, '.caws', 'archive');
+      if (fs.existsSync(archiveDir)) {
+        const archiveFiles = fs.readdirSync(archiveDir)
+          .filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
+
+        for (const file of archiveFiles) {
+          try {
+            const archivePath = path.join(archiveDir, file);
+            const spec = yaml.load(fs.readFileSync(archivePath, 'utf8'));
+            if (spec && spec.id) {
+              specs.push({
+                ...spec,
+                _source: 'archive',
+                _file: file,
+              });
+            }
+          } catch {
+            // Skip invalid archive files
+          }
+        }
+      }
+
+      // Deduplicate by spec ID, keeping the most recent version
+      const uniqueSpecs = new Map();
+      for (const spec of specs) {
+        const existing = uniqueSpecs.get(spec.id);
+        if (!existing || (spec._date && (!existing._date || spec._date > existing._date))) {
+          uniqueSpecs.set(spec.id, spec);
+        }
+      }
+
+      return Array.from(uniqueSpecs.values());
+    } catch (error) {
+      console.warn(`Failed to load historical specs: ${error.message}`);
+      return [];
+    }
   }
 
   /**
@@ -186,16 +291,41 @@ class WaiverPatternLearner {
 class ProjectSimilarityMatcher {
   constructor(projectRoot = process.cwd()) {
     this.projectRoot = projectRoot;
+    this.patternLearner = new WaiverPatternLearner(projectRoot);
   }
 
   /**
    * Find projects similar to the current spec
+   * Uses real historical specs from git history when available
    */
   findSimilarProjects(currentSpec) {
-    // For v0.1, we'll use mock historical data based on waiver patterns
-    // In a real implementation, this would load from git history or local cache
+    // Load real historical specs first
+    const historicalSpecs = this.patternLearner.loadHistoricalSpecs();
+
+    // Convert historical specs to project format with budget data
+    const historicalProjects = historicalSpecs
+      .filter(spec => spec.id !== currentSpec.id) // Exclude current spec
+      .map(spec => this.specToProject(spec));
+
+    // If we have real historical data, use it
+    if (historicalProjects.length > 0) {
+      return historicalProjects
+        .map((project) => ({
+          project: project.id,
+          similarity_score: this.calculateSimilarity(currentSpec, project),
+          budget_accuracy: project.allocated_budget.files > 0
+            ? project.actual_budget.files / project.allocated_budget.files
+            : 1.0,
+          waiver_count: project.waivers?.length || 0,
+          details: project,
+        }))
+        .filter((p) => p.similarity_score > 0.3)
+        .sort((a, b) => b.similarity_score - a.similarity_score)
+        .slice(0, 5);
+    }
 
-    const mockHistoricalProjects = [
+    // Fallback to demo data if no historical specs found
+    const demoProjects = [
       {
         id: 'PROJ-0123',
         title: 'API Enhancement',
@@ -231,9 +361,9 @@ class ProjectSimilarityMatcher {
       },
     ];
 
-    // Add a mock project similar to ARCH-0001 for demonstration
+    // Add a demo project similar to ARCH-0001 for demonstration
     if (currentSpec.id === 'ARCH-0001') {
-      mockHistoricalProjects.push({
+      demoProjects.push({
         id: 'ARCH-0002',
         title: 'Policy System Refactor',
         risk_tier: 1,
@@ -246,7 +376,7 @@ class ProjectSimilarityMatcher {
       });
     }
 
-    return mockHistoricalProjects
+    return demoProjects
       .map((project) => ({
         project: project.id,
         similarity_score: this.calculateSimilarity(currentSpec, project),
@@ -259,6 +389,69 @@ class ProjectSimilarityMatcher {
       .slice(0, 5); // Top 5 matches
   }
 
+  /**
+   * Convert a spec object to project format for similarity comparison
+   */
+  specToProject(spec) {
+    // Extract budget info from spec
+    const budget = spec.budget || spec.scope?.budget || {};
+    const allocatedFiles = budget.max_files || budget.files || 50;
+    const allocatedLoc = budget.max_loc || budget.loc || 5000;
+
+    // If spec has actual metrics, use them; otherwise estimate from allocated
+    const actualFiles = spec.metrics?.files_changed || spec.actual_files || allocatedFiles;
+    const actualLoc = spec.metrics?.lines_changed || spec.actual_loc || allocatedLoc;
+
+    // Extract tech stack from spec metadata
+    let techStack = spec.tech_stack || spec.metadata?.tech_stack || 'unknown';
+    if (!techStack || techStack === 'unknown') {
+      // Try to infer from title or description
+      const text = `${spec.title || ''} ${spec.description || ''}`.toLowerCase();
+      if (text.includes('react') || text.includes('ui') || text.includes('component')) {
+        techStack = 'react';
+      } else if (text.includes('api') || text.includes('node') || text.includes('server')) {
+        techStack = 'node';
+      } else if (text.includes('python') || text.includes('django') || text.includes('flask')) {
+        techStack = 'python';
+      }
+    }
+
+    // Extract feature type
+    let featureType = spec.feature_type || spec.type || 'general';
+    if (featureType === 'general') {
+      const text = `${spec.title || ''} ${spec.description || ''}`.toLowerCase();
+      if (text.includes('api') || text.includes('endpoint')) {
+        featureType = 'api';
+      } else if (text.includes('ui') || text.includes('component') || text.includes('view')) {
+        featureType = 'ui';
+      } else if (text.includes('data') || text.includes('migration') || text.includes('database')) {
+        featureType = 'data';
+      } else if (text.includes('refactor') || text.includes('architecture')) {
+        featureType = 'architecture';
+      }
+    }
+
+    return {
+      id: spec.id,
+      title: spec.title || spec.name || spec.id,
+      risk_tier: spec.risk_tier || spec.tier || 2,
+      mode: spec.mode || 'feature',
+      tech_stack: techStack,
+      feature_type: featureType,
+      actual_budget: {
+        files: actualFiles,
+        loc: actualLoc,
+      },
+      allocated_budget: {
+        files: allocatedFiles,
+        loc: allocatedLoc,
+      },
+      waivers: spec.waivers || [],
+      _source: spec._source,
+      _date: spec._date,
+    };
+  }
+
   /**
    * Calculate similarity score between two specs/projects
    */

package/dist/tool-interface.d.ts

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+/**
+ * Standard tool execution result
+ */
+export type ToolExecutionResult = {
+    /**
+     * - Whether execution succeeded
+     */
+    success: boolean;
+    /**
+     * - Execution duration in milliseconds
+     */
+    duration: number;
+    /**
+     * - Tool-specific output data
+     */
+    output: any;
+    /**
+     * - Error messages if execution failed
+     */
+    errors: Array<string>;
+    /**
+     * - Additional execution metadata
+     */
+    metadata: any;
+};
+/**
+ * Tool metadata structure
+ */
+export type ToolMetadata = {
+    /**
+     * - Unique tool identifier
+     */
+    id: string;
+    /**
+     * - Human-readable tool name
+     */
+    name: string;
+    /**
+     * - Tool version (semver)
+     */
+    version: string;
+    /**
+     * - Tool description
+     */
+    description: string;
+    /**
+     * - Tool capabilities (e.g., ['validation', 'security'])
+     */
+    capabilities: Array<string>;
+    /**
+     * - Tool author
+     */
+    author: string;
+    /**
+     * - Tool license
+     */
+    license: string;
+    /**
+     * - Required Node.js dependencies
+     */
+    dependencies: Array<string>;
+};
+/**
+ * Tool execution context
+ */
+export type ToolExecutionContext = {
+    /**
+     * - Current working directory
+     */
+    workingDirectory: string;
+    /**
+     * - Environment variables
+     */
+    environment: any;
+    /**
+     * - CAWS configuration
+     */
+    config: any;
+    /**
+     * - Current working specification
+     */
+    workingSpec: any;
+    /**
+     * - Execution timeout in milliseconds
+     */
+    timeout: number;
+};
+/**
+ * @fileoverview CAWS Tool Interface - Base classes and contracts for tool implementation
+ * Defines the standard interface that all CAWS tools must implement
+ * @author @darianrosebrook
+ */
+/**
+ * Standard tool execution result
+ * @typedef {Object} ToolExecutionResult
+ * @property {boolean} success - Whether execution succeeded
+ * @property {number} duration - Execution duration in milliseconds
+ * @property {Object} output - Tool-specific output data
+ * @property {Array<string>} errors - Error messages if execution failed
+ * @property {Object} metadata - Additional execution metadata
+ */
+/**
+ * Tool metadata structure
+ * @typedef {Object} ToolMetadata
+ * @property {string} id - Unique tool identifier
+ * @property {string} name - Human-readable tool name
+ * @property {string} version - Tool version (semver)
+ * @property {string} description - Tool description
+ * @property {Array<string>} capabilities - Tool capabilities (e.g., ['validation', 'security'])
+ * @property {string} author - Tool author
+ * @property {string} license - Tool license
+ * @property {Array<string>} dependencies - Required Node.js dependencies
+ */
+/**
+ * Tool execution context
+ * @typedef {Object} ToolExecutionContext
+ * @property {string} workingDirectory - Current working directory
+ * @property {Object} environment - Environment variables
+ * @property {Object} config - CAWS configuration
+ * @property {Object} workingSpec - Current working specification
+ * @property {number} timeout - Execution timeout in milliseconds
+ */
+/**
+ * Base Tool class - All CAWS tools should extend this class
+ */
+export class BaseTool {
+    metadata: ToolMetadata;
+    /**
+     * Execute the tool with given parameters
+     * @param {Object} parameters - Tool-specific execution parameters
+     * @param {ToolExecutionContext} context - Execution context
+     * @returns {Promise<ToolExecutionResult>} Execution result
+     */
+    execute(parameters?: any, context?: ToolExecutionContext): Promise<ToolExecutionResult>;
+    /**
+     * Get tool metadata
+     * @returns {ToolMetadata} Tool metadata
+     */
+    getMetadata(): ToolMetadata;
+    /**
+     * Validate tool parameters
+     * @param {Object} _parameters - Parameters to validate
+     * @throws {Error} If parameters are invalid
+     */
+    validateParameters(_parameters: any): boolean;
+    /**
+     * Execute tool implementation (must be overridden by subclasses)
+     * @param {Object} _parameters - Tool parameters
+     * @param {ToolExecutionContext} _context - Execution context
+     * @returns {Promise<Object>} Tool-specific result
+     */
+    executeImpl(_parameters: any, _context: ToolExecutionContext): Promise<any>;
+    /**
+     * Normalize execution result to standard format
+     * @private
+     * @param {Object} result - Raw tool result
+     * @param {number} duration - Execution duration
+     * @returns {ToolExecutionResult} Normalized result
+     */
+    private normalizeResult;
+    /**
+     * Create error result
+     * @private
+     * @param {Error} error - Execution error
+     * @param {number} duration - Execution duration
+     * @returns {ToolExecutionResult} Error result
+     */
+    private createErrorResult;
+}
+/**
+ * Validation Tool base class - For tools that perform validation checks
+ */
+export class ValidationTool extends BaseTool {
+    capabilities: string[];
+    /**
+     * Execute validation
+     * @param {Object} parameters - Validation parameters
+     * @param {ToolExecutionContext} context - Execution context
+     * @returns {Promise<ToolExecutionResult>} Validation result
+     */
+    executeImpl(parameters: any, context: ToolExecutionContext): Promise<ToolExecutionResult>;
+    /**
+     * Perform validation (must be implemented by subclasses)
+     * @param {Object} parameters - Validation parameters
+     * @param {ToolExecutionContext} context - Execution context
+     * @returns {Promise<Object>} Validation result
+     */
+    validate(_parameters: any, _context: any): Promise<any>;
+}
+/**
+ * Quality Gate Tool base class - For tools that enforce quality standards
+ */
+export class QualityGateTool extends ValidationTool {
+    /**
+     * Get quality gate thresholds for current tier
+     * @param {number} tier - Risk tier (1-3)
+     * @returns {Object} Threshold configuration
+     */
+    getTierThresholds(tier: number): any;
+}
+/**
+ * Security Tool base class - For tools that perform security checks
+ */
+export class SecurityTool extends ValidationTool {
+    /**
+     * Check for security violations
+     * @param {Object} target - Target to check (file, code, etc.)
+     * @returns {Promise<Array<Object>>} Array of security violations
+     */
+    checkSecurityViolations(target: any): Promise<Array<any>>;
+}
+export namespace ToolUtils {
+    /**
+     * Create standardized success result
+     * @param {Object} output - Tool output
+     * @param {Object} metadata - Additional metadata
+     * @returns {ToolExecutionResult} Success result
+     */
+    function createSuccessResult(output?: any, metadata?: any): ToolExecutionResult;
+    /**
+     * Create standardized error result
+     * @param {string} message - Error message
+     * @param {string} errorType - Error type
+     * @returns {ToolExecutionResult} Error result
+     */
+    function createErrorResult(message: string, errorType?: string): ToolExecutionResult;
+    /**
+     * Validate required parameters
+     * @param {Object} _params - Parameters object
+     * @param {Array<string>} _required - Required parameter names
+     * @throws {Error} If required parameters are missing
+     */
+    function validateRequired(_params: any, _required: Array<string>): void;
+}
+//# sourceMappingURL=tool-interface.d.ts.map

package/dist/tool-interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-interface.d.ts","sourceRoot":"","sources":["../src/tool-interface.js"],"names":[],"mappings":";;;;;;;;aAWc,OAAO;;;;cACP,MAAM;;;;;;;;YAEN,KAAK,CAAC,MAAM,CAAC;;;;;;;;;;;;;QAOb,MAAM;;;;UACN,MAAM;;;;aACN,MAAM;;;;iBACN,MAAM;;;;kBACN,KAAK,CAAC,MAAM,CAAC;;;;YACb,MAAM;;;;aACN,MAAM;;;;kBACN,KAAK,CAAC,MAAM,CAAC;;;;;;;;;sBAMb,MAAM;;;;;;;;;;;;;;;;aAIN,MAAM;;AApCpB;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AACH;IAEI,uBAAkC;IAGpC;;;;;OAKG;IACH,oCAHW,oBAAoB,GAClB,OAAO,CAAC,mBAAmB,CAAC,CAmBxC;IAED;;;OAGG;IACH,eAFa,YAAY,CAIxB;IAED;;;;OAIG;IACH,8CAGC;IAED;;;;;OAKG;IACH,wCAHW,oBAAoB,GAClB,OAAO,KAAQ,CAI3B;IAED;;;;;;OAMG;IACH,wBAQC;IAED;;;;;;OAMG;IACH,0BAWC;CACF;AAED;;GAEG;AACH;IAGI,uBAAkC;IAGpC;;;;;OAKG;IACH,sCAHW,oBAAoB,GAClB,OAAO,CAAC,mBAAmB,CAAC,CAcxC;IAED;;;;;OAKG;IACH,2CAFa,OAAO,KAAQ,CAI3B;CACF;AAED;;GAEG;AACH;IAME;;;;OAIG;IACH,wBAHW,MAAM,OA6BhB;CACF;AAED;;GAEG;AACH;IAME;;;;OAIG;IACH,sCAFa,OAAO,CAAC,KAAK,KAAQ,CAAC,CAmBlC;CACF;;IAMC;;;;;OAKG;IACH,4DAFa,mBAAmB,CAU/B;IAED;;;;;OAKG;IACH,oCAJW,MAAM,cACN,MAAM,GACJ,mBAAmB,CAU/B;IAED;;;;;OAKG;IACH,mDAHW,KAAK,CAAC,MAAM,CAAC,QAQvB"}

package/dist/tool-loader.d.ts

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+export = ToolLoader;
+/**
+ * Tool Loader - Discovers, validates, and loads CAWS tools dynamically
+ * @extends EventEmitter
+ */
+declare class ToolLoader extends EventEmitter<[never]> {
+    constructor(options?: {});
+    options: {
+        toolsDir: any;
+        cacheEnabled: boolean;
+        timeout: any;
+        maxTools: any;
+    };
+    loadedTools: Map<any, any>;
+    discoveredTools: Set<any>;
+    loadingState: string;
+    /**
+     * Discover available tools in the tools directory
+     * @returns {Promise<Array<string>>} Array of tool file paths
+     */
+    discoverTools(): Promise<Array<string>>;
+    /**
+     * Load a specific tool module
+     * @param {string} toolPath - Path to tool file
+     * @returns {Promise<Object>} Loaded tool module
+     */
+    loadTool(toolPath: string): Promise<any>;
+    /**
+     * Load all discovered tools
+     * @returns {Promise<Map<string, Object>>} Map of loaded tools
+     */
+    loadAllTools(): Promise<Map<string, any>>;
+    /**
+     * Get a loaded tool by ID
+     * @param {string} toolId - Tool identifier
+     * @returns {Object|null} Tool object or null if not found
+     */
+    getTool(toolId: string): any | null;
+    /**
+     * Get all loaded tools
+     * @returns {Map<string, Object>} Map of loaded tools
+     */
+    getAllTools(): Map<string, any>;
+    /**
+     * Unload a tool (remove from cache)
+     * @param {string} toolId - Tool identifier
+     * @returns {boolean} True if tool was unloaded
+     */
+    unloadTool(toolId: string): boolean;
+    /**
+     * Validate tool file before loading
+     * @private
+     * @param {string} toolPath - Path to tool file
+     */
+    private validateToolFile;
+    /**
+     * Load module with timeout protection
+     * @private
+     * @param {string} toolPath - Path to tool file
+     */
+    private loadModuleWithTimeout;
+    /**
+     * Validate tool interface compliance
+     * @private
+     * @param {Object} toolModule - Loaded tool module
+     * @param {string} toolId - Tool identifier
+     */
+    private validateToolInterface;
+    /**
+     * Get loader statistics
+     * @returns {Object} Statistics object
+     */
+    getStats(): any;
+}
+import { EventEmitter } from "events";
+//# sourceMappingURL=tool-loader.d.ts.map

package/dist/tool-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-loader.d.ts","sourceRoot":"","sources":["../src/tool-loader.js"],"names":[],"mappings":";;AAcA;;;GAGG;AACH;IACE,0BAkBC;IAXC;;;;;MAMC;IAED,2BAA4B;IAC5B,0BAAgC;IAChC,qBAA0B;IAG5B;;;OAGG;IACH,iBAFa,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAkDlC;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,KAAQ,CAmC3B;IAED;;;OAGG;IACH,gBAFa,OAAO,CAAC,GAAG,CAAC,MAAM,MAAS,CAAC,CAuBxC;IAED;;;;OAIG;IACH,gBAHW,MAAM,GACJ,MAAO,IAAI,CAIvB;IAED;;;OAGG;IACH,eAFa,GAAG,CAAC,MAAM,MAAS,CAI/B;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAQnB;IAED;;;;OAIG;IACH,yBAgCC;IAED;;;;OAIG;IACH,8BAkBC;IAED;;;;;OAKG;IACH,8BAyBC;IAED;;;OAGG;IACH,gBAQC;CACF"}

package/dist/tool-validator.d.ts

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+export = ToolValidator;
+/**
+ * Tool Validator - Security validation and allowlist enforcement
+ */
+declare class ToolValidator {
+    constructor(options?: {});
+    options: {
+        allowlistPath: any;
+        strictMode: boolean;
+        maxFileSize: any;
+    };
+    allowlist: any;
+    validationCache: Map<any, any>;
+    /**
+     * Load and parse the tools allowlist
+     * @returns {Promise<Array<string>>} Array of allowed commands/patterns
+     */
+    loadAllowlist(): Promise<Array<string>>;
+    /**
+     * Validate a tool against security requirements
+     * @param {Object} tool - Tool object with module and metadata
+     * @returns {Promise<Object>} Validation result
+     */
+    validateTool(tool: any): Promise<any>;
+    /**
+     * Check file-level security
+     * @private
+     * @param {Object} tool - Tool object
+     */
+    private checkFileSecurity;
+    /**
+     * Check code-level security
+     * @private
+     * @param {Object} tool - Tool object
+     */
+    private checkCodeSecurity;
+    /**
+     * Check interface compliance
+     * @private
+     * @param {Object} tool - Tool object
+     */
+    private checkInterfaceCompliance;
+    /**
+     * Check metadata validity
+     * @private
+     * @param {Object} tool - Tool object
+     */
+    private checkMetadataValidity;
+    /**
+     * Check dependency safety
+     * @private
+     * @param {Object} tool - Tool object
+     */
+    private checkDependencySafety;
+    /**
+     * Validate a command against the allowlist
+     * @param {string} command - Command to validate
+     * @returns {boolean} True if command is allowed
+     */
+    validateCommand(command: string): boolean;
+    /**
+     * Clear validation cache
+     */
+    clearCache(): void;
+    /**
+     * Get validator statistics
+     * @returns {Object} Statistics object
+     */
+    getStats(): any;
+}
+//# sourceMappingURL=tool-validator.d.ts.map

package/dist/tool-validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-validator.d.ts","sourceRoot":"","sources":["../src/tool-validator.js"],"names":[],"mappings":";;AAYA;;GAEG;AACH;IACE,0BAiBC;IATC;;;;MAKC;IAED,eAAqB;IACrB,+BAAgC;IAGlC;;;OAGG;IACH,iBAFa,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAqBlC;IAED;;;;OAIG;IACH,yBAFa,OAAO,KAAQ,CAsF3B;IAED;;;;OAIG;IACH,0BAgCC;IAED;;;;OAIG;IACH,0BA8CC;IAED;;;;OAIG;IACH,iCAkBC;IAED;;;;OAIG;IACH,8BAqCC;IAED;;;;OAIG;IACH,8BA4BC;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,OAAO,CAmBnB;IAED;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,gBAOC;CACF"}