@paths.design/caws-cli 5.0.1 → 5.1.0

package/dist/commands/waivers.js

@@ -14,6 +14,7 @@ const yaml = require('js-yaml');
 const chalk = require('chalk');
 const { initializeGlobalSetup } = require('../config');
 const WaiversManager = require('../waivers-manager');
+const { commandWrapper, Output } = require('../utils/command-wrapper');
 
 const WAIVER_DIR = '.caws/waivers';
 
@@ -24,46 +25,44 @@ const WAIVER_DIR = '.caws/waivers';
  * @param {object} options - Command options
  */
 async function waiversCommand(subcommand = 'list', options = {}) {
-  try {
-    console.log('🔍 Detecting CAWS setup...');
-    const setup = initializeGlobalSetup();
-
-    if (setup.hasWorkingSpec) {
-      console.log(`✅ Detected ${setup.setupType} CAWS setup`);
-      console.log(`   Capabilities: ${setup.capabilities.join(', ')}`);
-    }
-
-    // Ensure waivers directory exists
-    const waiversDir = path.join(process.cwd(), WAIVER_DIR);
-    if (!fs.existsSync(waiversDir)) {
-      fs.mkdirSync(waiversDir, { recursive: true });
-    }
-
-    switch (subcommand) {
-      case 'create':
-        await createWaiver(options);
-        break;
-      case 'list':
-        await listWaivers(options);
-        break;
-      case 'show':
-        await showWaiver(options.id, options);
-        break;
-      case 'revoke':
-        await revokeWaiver(options.id, options);
-        break;
-      default:
-        console.error(chalk.red(`\n❌ Unknown waiver subcommand: ${subcommand}`));
-        console.log(chalk.yellow('\n💡 Available subcommands: create, list, show, revoke'));
-        process.exit(1);
+  return commandWrapper(
+    async () => {
+      Output.info('Detecting CAWS setup...');
+      const setup = initializeGlobalSetup();
+
+      if (setup.hasWorkingSpec) {
+        Output.success(`Detected ${setup.setupType} CAWS setup`, {
+          capabilities: setup.capabilities,
+        });
+      }
+
+      // Ensure waivers directory exists
+      const waiversDir = path.join(process.cwd(), WAIVER_DIR);
+      if (!fs.existsSync(waiversDir)) {
+        fs.mkdirSync(waiversDir, { recursive: true });
+      }
+
+      switch (subcommand) {
+        case 'create':
+          return await createWaiver(options);
+        case 'list':
+          return await listWaivers(options);
+        case 'show':
+          return await showWaiver(options.id, options);
+        case 'revoke':
+          return await revokeWaiver(options.id, options);
+        default:
+          throw new Error(
+            `Unknown waiver subcommand: ${subcommand}.\n` +
+            'Available subcommands: create, list, show, revoke'
+          );
+      }
+    },
+    {
+      commandName: `waivers ${subcommand}`,
+      context: { subcommand, options },
     }
-  } catch (error) {
-    console.error(chalk.red(`\n❌ Waiver command failed: ${error.message}`));
-    if (options.verbose) {
-      console.error(error.stack);
-    }
-    process.exit(1);
-  }
+  );
 }
 
 /**

package/dist/commands/workflow.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Workflow command handler
+ *
+ * @param {string} workflowType - Type of workflow
+ * @param {object} options - Command options
+ */
+export function workflowCommand(workflowType: string, options?: object): Promise<void>;
+/**
+ * Generate workflow guidance
+ *
+ * @param {string} workflowType - Type of workflow (tdd, refactor, feature)
+ * @param {number} currentStep - Current step number (1-based)
+ * @param {object} context - Optional context information
+ * @returns {object} Workflow guidance
+ */
+export function generateWorkflowGuidance(workflowType: string, currentStep: number, context?: object): object;
+export namespace WORKFLOW_TEMPLATES {
+    namespace tdd {
+        let name: string;
+        let steps: string[];
+        let guidance: {
+            1: string;
+            2: string;
+            3: string;
+            4: string;
+            5: string;
+            6: string;
+        };
+        let recommendations: {
+            1: string[];
+            2: string[];
+            3: string[];
+            4: string[];
+            5: string[];
+            6: string[];
+        };
+    }
+    namespace refactor {
+        let name_1: string;
+        export { name_1 as name };
+        let steps_1: string[];
+        export { steps_1 as steps };
+        let guidance_1: {
+            1: string;
+            2: string;
+            3: string;
+            4: string;
+            5: string;
+        };
+        export { guidance_1 as guidance };
+        let recommendations_1: {
+            1: string[];
+            2: string[];
+            3: string[];
+            4: string[];
+            5: string[];
+        };
+        export { recommendations_1 as recommendations };
+    }
+    namespace feature {
+        let name_2: string;
+        export { name_2 as name };
+        let steps_2: string[];
+        export { steps_2 as steps };
+        let guidance_2: {
+            1: string;
+            2: string;
+            3: string;
+            4: string;
+            5: string;
+            6: string;
+        };
+        export { guidance_2 as guidance };
+        let recommendations_2: {
+            1: string[];
+            2: string[];
+            3: string[];
+            4: string[];
+            5: string[];
+            6: string[];
+        };
+        export { recommendations_2 as recommendations };
+    }
+}
+//# sourceMappingURL=workflow.d.ts.map

package/dist/commands/workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../src/commands/workflow.js"],"names":[],"mappings":"AA2IA;;;;;GAKG;AACH,8CAHW,MAAM,YACN,MAAM,iBA6FhB;AA7ID;;;;;;;GAOG;AACH,uDALW,MAAM,eACN,MAAM,YACN,MAAM,GACJ,MAAM,CAoClB"}

package/dist/config/index.d.ts

@@ -0,0 +1,29 @@
+import CLI_VERSION_1 = require("../../package.json");
+import CLI_VERSION = CLI_VERSION_1.version;
+/**
+ * Initialize global setup detection
+ * @returns {Object} Setup configuration
+ */
+export function initializeGlobalSetup(): any;
+/**
+ * Load provenance tools dynamically
+ * @returns {Object|null} Provenance tools or null if not available
+ */
+export function loadProvenanceTools(): any | null;
+/**
+ * Initialize language support tools
+ * @returns {Object|null} Language support tools or null if not available
+ */
+export function initializeLanguageSupport(): any | null;
+/**
+ * Get global CAWS setup
+ * @returns {Object} CAWS setup configuration
+ */
+export function getGlobalCAWSSetup(): any;
+/**
+ * Set global CAWS setup (for testing or override)
+ * @param {Object} setup - Setup configuration
+ */
+export function setGlobalCAWSSetup(setup: any): void;
+export { CLI_VERSION };
+//# sourceMappingURL=index.d.ts.map

package/dist/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/config/index.js"],"names":[],"mappings":";mCAakD,OAAO;AAOzD;;;GAGG;AACH,6CAkBC;AAED;;;GAGG;AACH,uCAFa,MAAO,IAAI,CA2CvB;AAED;;;GAGG;AACH,6CAFa,MAAO,IAAI,CAmCvB;AAED;;;GAGG;AACH,0CAEC;AAED;;;GAGG;AACH,qDAEC"}

package/dist/config/modes.d.ts

@@ -0,0 +1,225 @@
+export namespace COMPLEXITY_TIERS {
+    namespace simple {
+        let name: string;
+        let description: string;
+        let color: chalk.Chalk;
+        let icon: string;
+        namespace features {
+            let workingSpec: boolean;
+            let basicValidation: boolean;
+            let statusDisplay: boolean;
+            let noQualityGates: boolean;
+            let noProvenance: boolean;
+            let noWaivers: boolean;
+            let noChangeBudgets: boolean;
+            let noMultiSpec: boolean;
+        }
+        namespace qualityRequirements {
+            let testCoverage: number;
+            let mutationScore: number;
+            let contracts: string;
+        }
+        let riskTiers: string[];
+        namespace commands {
+            let init: boolean;
+            let validate: boolean;
+            let status: boolean;
+            let specs: boolean;
+        }
+    }
+    namespace standard {
+        let name_1: string;
+        export { name_1 as name };
+        let description_1: string;
+        export { description_1 as description };
+        let color_1: chalk.Chalk;
+        export { color_1 as color };
+        let icon_1: string;
+        export { icon_1 as icon };
+        export namespace features_1 {
+            let workingSpec_1: boolean;
+            export { workingSpec_1 as workingSpec };
+            export let fullValidation: boolean;
+            let statusDisplay_1: boolean;
+            export { statusDisplay_1 as statusDisplay };
+            export let qualityGates: boolean;
+            export let provenance: boolean;
+            export let waivers: boolean;
+            export let changeBudgets: boolean;
+            export let multiSpec: boolean;
+            export let changeFolders: boolean;
+        }
+        export { features_1 as features };
+        export namespace qualityRequirements_1 {
+            let testCoverage_1: number;
+            export { testCoverage_1 as testCoverage };
+            let mutationScore_1: number;
+            export { mutationScore_1 as mutationScore };
+            let contracts_1: string;
+            export { contracts_1 as contracts };
+        }
+        export { qualityRequirements_1 as qualityRequirements };
+        let riskTiers_1: string[];
+        export { riskTiers_1 as riskTiers };
+        export namespace commands_1 {
+            let init_1: boolean;
+            export { init_1 as init };
+            let validate_1: boolean;
+            export { validate_1 as validate };
+            let status_1: boolean;
+            export { status_1 as status };
+            let specs_1: boolean;
+            export { specs_1 as specs };
+            export let diagnose: boolean;
+            export let evaluate: boolean;
+            export let iterate: boolean;
+            let provenance_1: boolean;
+            export { provenance_1 as provenance };
+            let waivers_1: boolean;
+            export { waivers_1 as waivers };
+            export let hooks: boolean;
+            export let archive: boolean;
+        }
+        export { commands_1 as commands };
+    }
+    namespace enterprise {
+        let name_2: string;
+        export { name_2 as name };
+        let description_2: string;
+        export { description_2 as description };
+        let color_2: chalk.Chalk;
+        export { color_2 as color };
+        let icon_2: string;
+        export { icon_2 as icon };
+        export namespace features_2 {
+            let workingSpec_2: boolean;
+            export { workingSpec_2 as workingSpec };
+            let fullValidation_1: boolean;
+            export { fullValidation_1 as fullValidation };
+            let statusDisplay_2: boolean;
+            export { statusDisplay_2 as statusDisplay };
+            let qualityGates_1: boolean;
+            export { qualityGates_1 as qualityGates };
+            let provenance_2: boolean;
+            export { provenance_2 as provenance };
+            let waivers_2: boolean;
+            export { waivers_2 as waivers };
+            let changeBudgets_1: boolean;
+            export { changeBudgets_1 as changeBudgets };
+            let multiSpec_1: boolean;
+            export { multiSpec_1 as multiSpec };
+            let changeFolders_1: boolean;
+            export { changeFolders_1 as changeFolders };
+            export let auditTrails: boolean;
+            export let compliance: boolean;
+            export let advancedMonitoring: boolean;
+        }
+        export { features_2 as features };
+        export namespace qualityRequirements_2 {
+            let testCoverage_2: number;
+            export { testCoverage_2 as testCoverage };
+            let mutationScore_2: number;
+            export { mutationScore_2 as mutationScore };
+            let contracts_2: string;
+            export { contracts_2 as contracts };
+        }
+        export { qualityRequirements_2 as qualityRequirements };
+        let riskTiers_2: string[];
+        export { riskTiers_2 as riskTiers };
+        export namespace commands_2 {
+            let init_2: boolean;
+            export { init_2 as init };
+            let validate_2: boolean;
+            export { validate_2 as validate };
+            let status_2: boolean;
+            export { status_2 as status };
+            let specs_2: boolean;
+            export { specs_2 as specs };
+            let diagnose_1: boolean;
+            export { diagnose_1 as diagnose };
+            let evaluate_1: boolean;
+            export { evaluate_1 as evaluate };
+            let iterate_1: boolean;
+            export { iterate_1 as iterate };
+            let provenance_3: boolean;
+            export { provenance_3 as provenance };
+            let waivers_3: boolean;
+            export { waivers_3 as waivers };
+            let hooks_1: boolean;
+            export { hooks_1 as hooks };
+            let archive_1: boolean;
+            export { archive_1 as archive };
+            export let troubleshoot: boolean;
+            export let testAnalysis: boolean;
+            export let qualityMonitor: boolean;
+        }
+        export { commands_2 as commands };
+    }
+}
+/**
+ * Get tier information
+ * @param {string} tier - Tier name
+ * @returns {Object} Tier configuration
+ */
+export function getTier(tier: string): any;
+/**
+ * Get available tiers
+ * @returns {string[]} Array of tier names
+ */
+export function getAvailableTiers(): string[];
+/**
+ * Get current mode from configuration
+ * @returns {Promise<string>} Current mode
+ */
+export function getCurrentMode(): Promise<string>;
+/**
+ * Set current mode in configuration
+ * @param {string} mode - Mode to set
+ * @returns {Promise<boolean>} Success status
+ */
+export function setCurrentMode(mode: string): Promise<boolean>;
+/**
+ * Check if a command is available in the current tier
+ * @param {string} command - Command name
+ * @param {string} tier - Tier name
+ * @returns {boolean} Whether command is available
+ */
+export function isCommandAvailable(command: string, tier?: string): boolean;
+/**
+ * Check if a feature is enabled in the current tier
+ * @param {string} feature - Feature name
+ * @param {string} tier - Tier name
+ * @returns {boolean} Whether feature is enabled
+ */
+export function isFeatureEnabled(feature: string, tier?: string): boolean;
+/**
+ * Get quality requirements for a tier
+ * @param {string} tier - Tier name
+ * @returns {Object} Quality requirements
+ */
+export function getQualityRequirements(tier?: string): any;
+/**
+ * Get supported risk tiers for a complexity tier
+ * @param {string} tier - Tier name
+ * @returns {string[]} Supported risk tiers
+ */
+export function getSupportedRiskTiers(tier?: string): string[];
+/**
+ * Validate if a risk tier is supported in the current complexity tier
+ * @param {string} riskTier - Risk tier to validate
+ * @param {string} complexityTier - Complexity tier
+ * @returns {boolean} Whether risk tier is supported
+ */
+export function isRiskTierSupported(riskTier: string, complexityTier?: string): boolean;
+/**
+ * Display tier comparison
+ */
+export function displayTierComparison(): void;
+/**
+ * Get tier recommendation based on project characteristics
+ * @param {Object} projectInfo - Project information
+ * @returns {string} Recommended tier
+ */
+export function getTierRecommendation(projectInfo?: any): string;
+import chalk = require("chalk");
+//# sourceMappingURL=modes.d.ts.map

package/dist/config/modes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modes.d.ts","sourceRoot":"","sources":["../../src/config/modes.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2HA;;;;GAIG;AACH,8BAHW,MAAM,OAKhB;AAED;;;GAGG;AACH,qCAFa,MAAM,EAAE,CAIpB;AA8FD;;;GAGG;AACH,kCAFa,OAAO,CAAC,MAAM,CAAC,CAgB3B;AAED;;;;GAIG;AACH,qCAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAuB5B;AA1ID;;;;;GAKG;AACH,4CAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAKnB;AAED;;;;;GAKG;AACH,0CAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAKnB;AAED;;;;GAIG;AACH,8CAHW,MAAM,OAMhB;AAED;;;;GAIG;AACH,6CAHW,MAAM,GACJ,MAAM,EAAE,CAKpB;AAED;;;;;GAKG;AACH,8CAJW,MAAM,mBACN,MAAM,GACJ,OAAO,CAKnB;AAED;;GAEG;AACH,8CAkCC;AAkDD;;;;GAIG;AACH,0DAFa,MAAM,CAsBlB"}

package/dist/constants/spec-types.d.ts

@@ -0,0 +1,41 @@
+export namespace SPEC_TYPES {
+    namespace feature {
+        let color: chalk.Chalk;
+        let icon: string;
+        let description: string;
+    }
+    namespace fix {
+        let color_1: chalk.Chalk;
+        export { color_1 as color };
+        let icon_1: string;
+        export { icon_1 as icon };
+        let description_1: string;
+        export { description_1 as description };
+    }
+    namespace refactor {
+        let color_2: chalk.Chalk;
+        export { color_2 as color };
+        let icon_2: string;
+        export { icon_2 as icon };
+        let description_2: string;
+        export { description_2 as description };
+    }
+    namespace chore {
+        let color_3: chalk.Chalk;
+        export { color_3 as color };
+        let icon_3: string;
+        export { icon_3 as icon };
+        let description_3: string;
+        export { description_3 as description };
+    }
+    namespace docs {
+        let color_4: chalk.Chalk;
+        export { color_4 as color };
+        let icon_4: string;
+        export { icon_4 as icon };
+        let description_4: string;
+        export { description_4 as description };
+    }
+}
+import chalk = require("chalk");
+//# sourceMappingURL=spec-types.d.ts.map

package/dist/constants/spec-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec-types.d.ts","sourceRoot":"","sources":["../../src/constants/spec-types.js"],"names":[],"mappings":""}

package/dist/error-handler.d.ts

@@ -0,0 +1,164 @@
+/**
+ * Enhanced error class with category and recovery suggestions
+ */
+export class CAWSError extends Error {
+    constructor(message: any, category?: any, suggestions?: any[]);
+    category: any;
+    suggestions: any[];
+    timestamp: Date;
+    executionTime: any;
+}
+export namespace ERROR_CATEGORIES {
+    let VALIDATION: string;
+    let PERMISSION: string;
+    let FILESYSTEM: string;
+    let NETWORK: string;
+    let CONFIGURATION: string;
+    let USER_INPUT: string;
+    let DEPENDENCY: string;
+    let UNKNOWN: string;
+}
+/**
+ * Execution timing utilities
+ */
+export class ExecutionTimer {
+    startTime: bigint;
+    endTime: bigint;
+    start(): void;
+    end(): number;
+    getDuration(): number;
+    formatDuration(): string;
+}
+/**
+ * Get error category from error object or message
+ * @param {Error|string} error - Error object or message
+ * @returns {string} Error category
+ */
+export function getErrorCategory(error: Error | string): string;
+/**
+ * Wrap async operations with consistent error handling and timing
+ * @param {Function} operation - Async operation to wrap
+ * @param {string} context - Context for error messages
+ * @param {boolean} includeTiming - Whether to include timing in results
+ * @returns {Promise<any>} Operation result or throws handled error
+ */
+export function safeAsync(operation: Function, context?: string, includeTiming?: boolean): Promise<any>;
+/**
+ * Wrap sync operations with timing
+ * @param {Function} operation - Sync operation to wrap
+ * @param {string} context - Context for error messages
+ * @param {boolean} includeTiming - Whether to include timing in results
+ * @returns {any} Operation result or throws handled error
+ */
+export function safeSync(operation: Function, context?: string, includeTiming?: boolean): any;
+/**
+ * Handle CLI errors with consistent formatting and user guidance
+ * @param {Error} error - Error to handle
+ * @param {Object} context - Error context (command, option, etc.)
+ * @param {boolean} exit - Whether to exit the process (default: true)
+ */
+export function handleCliError(error: Error, context?: any, exit?: boolean): void;
+/**
+ * Validate required environment and dependencies
+ * @returns {Object} Validation result with any errors
+ */
+export function validateEnvironment(): any;
+/**
+ * Get recovery suggestions based on error category
+ * @param {Error} error - Original error
+ * @param {string} category - Error category
+ * @param {Object} context - Additional context (command, options, etc.)
+ * @returns {string[]} Array of recovery suggestions
+ */
+export function getRecoverySuggestions(error: Error, category: string, context?: any): string[];
+/**
+ * Get documentation link for error category
+ * @param {string} category - Error category
+ * @param {Object} context - Additional context
+ * @returns {string} Documentation URL
+ */
+export function getDocumentationLink(category: string, context?: any): string;
+/**
+ * Find similar command using Levenshtein distance
+ * @param {string} input - User's input command
+ * @param {string[]} validCommands - List of valid commands
+ * @returns {string|null} Most similar command or null
+ */
+export function findSimilarCommand(input: string, validCommands: string[]): string | null;
+/**
+ * Command-specific error suggestions
+ */
+export const COMMAND_SUGGESTIONS: {
+    'unknown option': (option: any, command: any) => any[];
+    'unknown command': (command: any) => string[];
+    'template not found': () => string[];
+    'not a caws project': () => string[];
+};
+/**
+ * JSON output formatter for programmatic use
+ * @param {Object} data - Data to format as JSON
+ * @param {boolean} pretty - Whether to pretty-print (default: true)
+ */
+export function formatJsonOutput(data: any, pretty?: boolean): string;
+/**
+ * Check if user requested JSON output
+ * @returns {boolean} True if --json flag is present
+ */
+export function isJsonOutput(): boolean;
+/**
+ * Output data in appropriate format (JSON or human-readable)
+ * @param {Object} data - Data to output
+ * @param {boolean} success - Whether this is a success response
+ */
+export function outputResult(data: any, success?: boolean): any;
+/**
+ * Troubleshooting guide system
+ */
+export const TROUBLESHOOTING_GUIDES: {
+    'coverage-report-not-found': {
+        title: string;
+        symptoms: string[];
+        rootCauses: string[];
+        solutions: string[];
+        commands: string[];
+    };
+    'mutation-report-not-found': {
+        title: string;
+        symptoms: string[];
+        rootCauses: string[];
+        solutions: string[];
+        commands: string[];
+    };
+    'working-spec-validation': {
+        title: string;
+        symptoms: string[];
+        rootCauses: string[];
+        solutions: string[];
+        commands: string[];
+    };
+    'monorepo-detection': {
+        title: string;
+        symptoms: string[];
+        rootCauses: string[];
+        solutions: string[];
+        commands: string[];
+    };
+};
+/**
+ * Get troubleshooting guide for a specific issue
+ * @param {string} issueKey - Key for the troubleshooting guide
+ * @returns {Object|null} Troubleshooting guide or null if not found
+ */
+export function getTroubleshootingGuide(issueKey: string): any | null;
+/**
+ * Get all available troubleshooting guides
+ * @returns {Object} All troubleshooting guides
+ */
+export function getAllTroubleshootingGuides(): any;
+/**
+ * Suggest troubleshooting guide based on error message
+ * @param {string} errorMessage - Error message to analyze
+ * @returns {string|null} Issue key if match found, null otherwise
+ */
+export function suggestTroubleshootingGuide(errorMessage: string): string | null;
+//# sourceMappingURL=error-handler.d.ts.map

package/dist/error-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-handler.d.ts","sourceRoot":"","sources":["../src/error-handler.js"],"names":[],"mappings":"AA0GA;;GAEG;AACH;IACE,+DAOC;IAJC,cAAqD;IACrD,mBAA2F;IAC3F,gBAA2B;IAC3B,mBAAyB;CAE5B;;;;;;;;;;;AAED;;GAEG;AACH;IAEI,kBAAqB;IACrB,gBAAmB;IAGrB,cAEC;IAED,cAGC;IAED,sBAIC;IAED,yBAMC;CACF;AAjHD;;;;GAIG;AACH,wCAHW,KAAK,GAAC,MAAM,GACV,MAAM,CA+DlB;AAiDD;;;;;;GAMG;AACH,yDAJW,MAAM,kBACN,OAAO,GACL,OAAO,CAAC,GAAG,CAAC,CA8BxB;AAED;;;;;;GAMG;AACH,wDAJW,MAAM,kBACN,OAAO,GACL,GAAG,CA8Bf;AAgSD;;;;;GAKG;AACH,sCAJW,KAAK,wBAEL,OAAO,QAmDjB;AA0JD;;;GAGG;AACH,2CAqBC;AAnXD;;;;;;GAMG;AACH,8CALW,KAAK,YACL,MAAM,kBAEJ,MAAM,EAAE,CAwDpB;AAED;;;;;GAKG;AACH,+CAJW,MAAM,kBAEJ,MAAM,CA4BlB;AAxJD;;;;;GAKG;AACH,0CAJW,MAAM,iBACN,MAAM,EAAE,GACN,MAAM,GAAC,IAAI,CAiBvB;AAjHD;;GAEG;AACH;;;;;EAuFE;AA4JF;;;;GAIG;AACH,qDAFW,OAAO,UAIjB;AAED;;;GAGG;AACH,gCAFa,OAAO,CAQnB;AAED;;;;GAIG;AACH,kDAFW,OAAO,OAcjB;AA2DD;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0GE;AAEF;;;;GAIG;AACH,kDAHW,MAAM,GACJ,MAAO,IAAI,CAIvB;AAED;;;GAGG;AACH,mDAEC;AAED;;;;GAIG;AACH,0DAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAmBvB"}