@git.zone/tsdoc 1.5.2 → 1.6.1

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@git.zone/tsdoc',
-    version: '1.5.2',
+    version: '1.6.1',
     description: 'A comprehensive TypeScript documentation tool that leverages AI to generate and enhance project documentation, including dynamic README creation, API docs via TypeDoc, and smart commit message generation.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxpQkFBaUI7SUFDdkIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDhNQUE4TTtDQUM1TixDQUFBIn0=

package/dist_ts/context/config-manager.d.ts

@@ -1,4 +1,4 @@
-import type { IContextConfig, ITrimConfig, ITaskConfig, TaskType } from './types.js';
+import type { IContextConfig, ITrimConfig, ITaskConfig, TaskType, ICacheConfig, IAnalyzerConfig, IPrioritizationWeights, ITierConfig } from './types.js';
 /**
  * Manages configuration for context building
  */
@@ -6,6 +6,7 @@ export declare class ConfigManager {
     private static instance;
     private config;
     private projectDir;
+    private configCache;
     /**
      * Get the singleton instance of ConfigManager
      */
@@ -55,4 +56,24 @@ export declare class ConfigManager {
      * @param config The new configuration
      */
     updateConfig(config: Partial<IContextConfig>): Promise<void>;
+    /**
+     * Get cache configuration
+     */
+    getCacheConfig(): ICacheConfig;
+    /**
+     * Get analyzer configuration
+     */
+    getAnalyzerConfig(): IAnalyzerConfig;
+    /**
+     * Get prioritization weights
+     */
+    getPrioritizationWeights(): IPrioritizationWeights;
+    /**
+     * Get tier configuration
+     */
+    getTierConfig(): ITierConfig;
+    /**
+     * Clear the config cache (force reload on next access)
+     */
+    clearCache(): void;
 }

package/dist_ts/context/config-manager.js

@@ -1,4 +1,5 @@
 import * as plugins from '../plugins.js';
+import * as fs from 'fs';
 /**
  * Manages configuration for context building
  */
@@ -17,6 +18,7 @@ export class ConfigManager {
      */
     constructor() {
         this.projectDir = '';
+        this.configCache = null;
         this.config = this.getDefaultConfig();
     }
     /**
@@ -57,6 +59,27 @@ export class ConfigManager {
                 maxFunctionLines: 5,
                 removeComments: true,
                 removeBlankLines: true
+            },
+            cache: {
+                enabled: true,
+                ttl: 3600, // 1 hour
+                maxSize: 100, // 100MB
+                directory: undefined // Will be set to .nogit/context-cache by ContextCache
+            },
+            analyzer: {
+                useAIRefinement: false, // Disabled by default for now
+                aiModel: 'haiku'
+            },
+            prioritization: {
+                dependencyWeight: 0.3,
+                relevanceWeight: 0.4,
+                efficiencyWeight: 0.2,
+                recencyWeight: 0.1
+            },
+            tiers: {
+                essential: { minScore: 0.8, trimLevel: 'none' },
+                important: { minScore: 0.5, trimLevel: 'light' },
+                optional: { minScore: 0.2, trimLevel: 'aggressive' }
             }
         };
     }
@@ -68,16 +91,33 @@ export class ConfigManager {
             if (!this.projectDir) {
                 return;
             }
-            // Create KeyValueStore for this project
-            // We'll just use smartfile directly instead of KeyValueStore
+            const npmextraJsonPath = plugins.path.join(this.projectDir, 'npmextra.json');
+            // Check if file exists
+            const fileExists = await plugins.smartfile.fs.fileExists(npmextraJsonPath);
+            if (!fileExists) {
+                return;
+            }
+            // Check cache
+            const stats = await fs.promises.stat(npmextraJsonPath);
+            const currentMtime = Math.floor(stats.mtimeMs);
+            if (this.configCache && this.configCache.mtime === currentMtime) {
+                // Use cached config
+                this.config = this.configCache.config;
+                return;
+            }
             // Read the npmextra.json file
-            const npmextraJsonFile = await plugins.smartfile.SmartFile.fromFilePath(plugins.path.join(this.projectDir, 'npmextra.json'));
+            const npmextraJsonFile = await plugins.smartfile.SmartFile.fromFilePath(npmextraJsonPath);
             const npmextraContent = JSON.parse(npmextraJsonFile.contents.toString());
             // Check for tsdoc context configuration
             if (npmextraContent?.tsdoc?.context) {
                 // Merge with default config
                 this.config = this.mergeConfigs(this.config, npmextraContent.tsdoc.context);
             }
+            // Cache the config
+            this.configCache = {
+                mtime: currentMtime,
+                config: { ...this.config }
+            };
         }
         catch (error) {
             console.error('Error loading context configuration:', error);
@@ -115,6 +155,34 @@ export class ConfigManager {
                 ...userConfig.trimming
             };
         }
+        // Merge cache configuration
+        if (userConfig.cache) {
+            result.cache = {
+                ...result.cache,
+                ...userConfig.cache
+            };
+        }
+        // Merge analyzer configuration
+        if (userConfig.analyzer) {
+            result.analyzer = {
+                ...result.analyzer,
+                ...userConfig.analyzer
+            };
+        }
+        // Merge prioritization weights
+        if (userConfig.prioritization) {
+            result.prioritization = {
+                ...result.prioritization,
+                ...userConfig.prioritization
+            };
+        }
+        // Merge tier configuration
+        if (userConfig.tiers) {
+            result.tiers = {
+                ...result.tiers,
+                ...userConfig.tiers
+            };
+        }
         return result;
     }
     /**
@@ -155,6 +223,8 @@ export class ConfigManager {
     async updateConfig(config) {
         // Merge with existing config
         this.config = this.mergeConfigs(this.config, config);
+        // Invalidate cache
+        this.configCache = null;
         try {
             if (!this.projectDir) {
                 return;
@@ -179,5 +249,44 @@ export class ConfigManager {
             console.error('Error updating context configuration:', error);
         }
     }
+    /**
+     * Get cache configuration
+     */
+    getCacheConfig() {
+        return this.config.cache || { enabled: true, ttl: 3600, maxSize: 100 };
+    }
+    /**
+     * Get analyzer configuration
+     */
+    getAnalyzerConfig() {
+        return this.config.analyzer || { useAIRefinement: false, aiModel: 'haiku' };
+    }
+    /**
+     * Get prioritization weights
+     */
+    getPrioritizationWeights() {
+        return this.config.prioritization || {
+            dependencyWeight: 0.3,
+            relevanceWeight: 0.4,
+            efficiencyWeight: 0.2,
+            recencyWeight: 0.1
+        };
+    }
+    /**
+     * Get tier configuration
+     */
+    getTierConfig() {
+        return this.config.tiers || {
+            essential: { minScore: 0.8, trimLevel: 'none' },
+            important: { minScore: 0.5, trimLevel: 'light' },
+            optional: { minScore: 0.2, trimLevel: 'aggressive' }
+        };
+    }
+    /**
+     * Clear the config cache (force reload on next access)
+     */
+    clearCache() {
+        this.configCache = null;
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"config-manager.js","sourceRoot":"","sources":["../../ts/context/config-manager.ts"],"names":[],"mappings":"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"}

package/dist_ts/context/context-analyzer.d.ts

@@ -0,0 +1,73 @@
+import type { IFileMetadata, IAnalysisResult, TaskType, IPrioritizationWeights, ITierConfig } from './types.js';
+/**
+ * ContextAnalyzer provides intelligent file selection and prioritization
+ * based on dependency analysis, task relevance, and configurable weights
+ */
+export declare class ContextAnalyzer {
+    private projectRoot;
+    private weights;
+    private tiers;
+    /**
+     * Creates a new ContextAnalyzer
+     * @param projectRoot - Root directory of the project
+     * @param weights - Prioritization weights
+     * @param tiers - Tier configuration
+     */
+    constructor(projectRoot: string, weights?: Partial<IPrioritizationWeights>, tiers?: Partial<ITierConfig>);
+    /**
+     * Analyzes files for a specific task type
+     * @param metadata - Array of file metadata to analyze
+     * @param taskType - Type of task being performed
+     * @param changedFiles - Optional list of recently changed files (for commits)
+     * @returns Analysis result with scored files
+     */
+    analyze(metadata: IFileMetadata[], taskType: TaskType, changedFiles?: string[]): Promise<IAnalysisResult>;
+    /**
+     * Builds a dependency graph from file metadata
+     * @param metadata - Array of file metadata
+     * @returns Dependency graph as a map
+     */
+    private buildDependencyGraph;
+    /**
+     * Extracts import statements from file contents
+     * @param contents - File contents
+     * @param filePath - Path of the file being analyzed
+     * @returns Array of absolute paths to imported files
+     */
+    private extractImports;
+    /**
+     * Calculates centrality scores for all nodes in the dependency graph
+     * Uses a simplified PageRank-like algorithm
+     * @param graph - Dependency graph
+     */
+    private calculateCentrality;
+    /**
+     * Analyzes a single file
+     * @param meta - File metadata
+     * @param taskType - Task being performed
+     * @param graph - Dependency graph
+     * @param changedFiles - Recently changed files
+     * @returns File analysis
+     */
+    private analyzeFile;
+    /**
+     * Calculates task-specific relevance score
+     */
+    private calculateRelevance;
+    /**
+     * Calculates efficiency score (information density)
+     */
+    private calculateEfficiency;
+    /**
+     * Calculates recency score for changed files
+     */
+    private calculateRecency;
+    /**
+     * Assigns a tier based on importance score
+     */
+    private assignTier;
+    /**
+     * Generates a human-readable reason for the score
+     */
+    private generateReason;
+}

package/dist_ts/context/context-analyzer.js

@@ -0,0 +1,311 @@
+import * as plugins from '../plugins.js';
+/**
+ * ContextAnalyzer provides intelligent file selection and prioritization
+ * based on dependency analysis, task relevance, and configurable weights
+ */
+export class ContextAnalyzer {
+    /**
+     * Creates a new ContextAnalyzer
+     * @param projectRoot - Root directory of the project
+     * @param weights - Prioritization weights
+     * @param tiers - Tier configuration
+     */
+    constructor(projectRoot, weights = {}, tiers = {}) {
+        this.projectRoot = projectRoot;
+        // Default weights
+        this.weights = {
+            dependencyWeight: weights.dependencyWeight ?? 0.3,
+            relevanceWeight: weights.relevanceWeight ?? 0.4,
+            efficiencyWeight: weights.efficiencyWeight ?? 0.2,
+            recencyWeight: weights.recencyWeight ?? 0.1,
+        };
+        // Default tiers
+        this.tiers = {
+            essential: tiers.essential ?? { minScore: 0.8, trimLevel: 'none' },
+            important: tiers.important ?? { minScore: 0.5, trimLevel: 'light' },
+            optional: tiers.optional ?? { minScore: 0.2, trimLevel: 'aggressive' },
+        };
+    }
+    /**
+     * Analyzes files for a specific task type
+     * @param metadata - Array of file metadata to analyze
+     * @param taskType - Type of task being performed
+     * @param changedFiles - Optional list of recently changed files (for commits)
+     * @returns Analysis result with scored files
+     */
+    async analyze(metadata, taskType, changedFiles = []) {
+        const startTime = Date.now();
+        // Build dependency graph
+        const dependencyGraph = await this.buildDependencyGraph(metadata);
+        // Calculate centrality scores
+        this.calculateCentrality(dependencyGraph);
+        // Analyze each file
+        const files = [];
+        for (const meta of metadata) {
+            const analysis = await this.analyzeFile(meta, taskType, dependencyGraph, changedFiles);
+            files.push(analysis);
+        }
+        // Sort by importance score (highest first)
+        files.sort((a, b) => b.importanceScore - a.importanceScore);
+        const analysisDuration = Date.now() - startTime;
+        return {
+            taskType,
+            files,
+            dependencyGraph,
+            totalFiles: metadata.length,
+            analysisDuration,
+        };
+    }
+    /**
+     * Builds a dependency graph from file metadata
+     * @param metadata - Array of file metadata
+     * @returns Dependency graph as a map
+     */
+    async buildDependencyGraph(metadata) {
+        const graph = new Map();
+        // Initialize graph entries
+        for (const meta of metadata) {
+            graph.set(meta.path, {
+                path: meta.path,
+                imports: [],
+                importedBy: [],
+                centrality: 0,
+            });
+        }
+        // Parse imports from each file
+        for (const meta of metadata) {
+            try {
+                const contents = await plugins.smartfile.fs.toStringSync(meta.path);
+                const imports = this.extractImports(contents, meta.path);
+                const deps = graph.get(meta.path);
+                deps.imports = imports;
+                // Update importedBy for imported files
+                for (const importPath of imports) {
+                    const importedDeps = graph.get(importPath);
+                    if (importedDeps) {
+                        importedDeps.importedBy.push(meta.path);
+                    }
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to parse imports from ${meta.path}:`, error.message);
+            }
+        }
+        return graph;
+    }
+    /**
+     * Extracts import statements from file contents
+     * @param contents - File contents
+     * @param filePath - Path of the file being analyzed
+     * @returns Array of absolute paths to imported files
+     */
+    extractImports(contents, filePath) {
+        const imports = [];
+        const fileDir = plugins.path.dirname(filePath);
+        // Match various import patterns
+        const importRegex = /(?:import|export).*?from\s+['"](.+?)['"]/g;
+        let match;
+        while ((match = importRegex.exec(contents)) !== null) {
+            const importPath = match[1];
+            // Skip external modules
+            if (!importPath.startsWith('.')) {
+                continue;
+            }
+            // Resolve relative import to absolute path
+            let resolvedPath = plugins.path.resolve(fileDir, importPath);
+            // Handle various file extensions
+            const extensions = ['.ts', '.js', '.tsx', '.jsx', '/index.ts', '/index.js'];
+            let found = false;
+            for (const ext of extensions) {
+                const testPath = resolvedPath.endsWith(ext) ? resolvedPath : resolvedPath + ext;
+                try {
+                    // Use synchronous file check to avoid async in this context
+                    const fs = require('fs');
+                    const exists = fs.existsSync(testPath);
+                    if (exists) {
+                        imports.push(testPath);
+                        found = true;
+                        break;
+                    }
+                }
+                catch (error) {
+                    // Continue trying other extensions
+                }
+            }
+            if (!found && !resolvedPath.includes('.')) {
+                // Try with .ts extension as default
+                imports.push(resolvedPath + '.ts');
+            }
+        }
+        return imports;
+    }
+    /**
+     * Calculates centrality scores for all nodes in the dependency graph
+     * Uses a simplified PageRank-like algorithm
+     * @param graph - Dependency graph
+     */
+    calculateCentrality(graph) {
+        const damping = 0.85;
+        const iterations = 10;
+        const nodeCount = graph.size;
+        // Initialize scores
+        const scores = new Map();
+        for (const path of graph.keys()) {
+            scores.set(path, 1.0 / nodeCount);
+        }
+        // Iterative calculation
+        for (let i = 0; i < iterations; i++) {
+            const newScores = new Map();
+            for (const [path, deps] of graph.entries()) {
+                let score = (1 - damping) / nodeCount;
+                // Add contributions from nodes that import this file
+                for (const importerPath of deps.importedBy) {
+                    const importerDeps = graph.get(importerPath);
+                    if (importerDeps) {
+                        const importerScore = scores.get(importerPath) ?? 0;
+                        const outgoingCount = importerDeps.imports.length || 1;
+                        score += damping * (importerScore / outgoingCount);
+                    }
+                }
+                newScores.set(path, score);
+            }
+            // Update scores
+            for (const [path, score] of newScores) {
+                scores.set(path, score);
+            }
+        }
+        // Normalize scores to 0-1 range
+        const maxScore = Math.max(...scores.values());
+        if (maxScore > 0) {
+            for (const deps of graph.values()) {
+                const score = scores.get(deps.path) ?? 0;
+                deps.centrality = score / maxScore;
+            }
+        }
+    }
+    /**
+     * Analyzes a single file
+     * @param meta - File metadata
+     * @param taskType - Task being performed
+     * @param graph - Dependency graph
+     * @param changedFiles - Recently changed files
+     * @returns File analysis
+     */
+    async analyzeFile(meta, taskType, graph, changedFiles) {
+        const deps = graph.get(meta.path);
+        const centralityScore = deps?.centrality ?? 0;
+        // Calculate task-specific relevance
+        const relevanceScore = this.calculateRelevance(meta, taskType);
+        // Calculate efficiency (information per token)
+        const efficiencyScore = this.calculateEfficiency(meta);
+        // Calculate recency (for commit tasks)
+        const recencyScore = this.calculateRecency(meta, changedFiles);
+        // Calculate combined importance score
+        const importanceScore = relevanceScore * this.weights.relevanceWeight +
+            centralityScore * this.weights.dependencyWeight +
+            efficiencyScore * this.weights.efficiencyWeight +
+            recencyScore * this.weights.recencyWeight;
+        // Assign tier
+        const tier = this.assignTier(importanceScore);
+        return {
+            path: meta.path,
+            relevanceScore,
+            centralityScore,
+            efficiencyScore,
+            recencyScore,
+            importanceScore,
+            tier,
+            reason: this.generateReason(meta, taskType, importanceScore, tier),
+        };
+    }
+    /**
+     * Calculates task-specific relevance score
+     */
+    calculateRelevance(meta, taskType) {
+        const relativePath = meta.relativePath.toLowerCase();
+        let score = 0.5; // Base score
+        // README generation - prioritize public APIs and main exports
+        if (taskType === 'readme') {
+            if (relativePath.includes('index.ts'))
+                score += 0.3;
+            if (relativePath.match(/^ts\/[^\/]+\.ts$/))
+                score += 0.2; // Root level exports
+            if (relativePath.includes('test/'))
+                score -= 0.3;
+            if (relativePath.includes('classes/'))
+                score += 0.1;
+            if (relativePath.includes('interfaces/'))
+                score += 0.1;
+        }
+        // Commit messages - prioritize changed files and their dependencies
+        if (taskType === 'commit') {
+            if (relativePath.includes('test/'))
+                score -= 0.2;
+            // Recency will handle changed files
+        }
+        // Description generation - prioritize main exports and core interfaces
+        if (taskType === 'description') {
+            if (relativePath.includes('index.ts'))
+                score += 0.4;
+            if (relativePath.match(/^ts\/[^\/]+\.ts$/))
+                score += 0.3;
+            if (relativePath.includes('test/'))
+                score -= 0.4;
+            if (relativePath.includes('interfaces/'))
+                score += 0.2;
+        }
+        return Math.max(0, Math.min(1, score));
+    }
+    /**
+     * Calculates efficiency score (information density)
+     */
+    calculateEfficiency(meta) {
+        // Prefer files that are not too large (good signal-to-noise ratio)
+        const optimalSize = 5000; // ~1250 tokens
+        const distance = Math.abs(meta.estimatedTokens - optimalSize);
+        const normalized = Math.max(0, 1 - distance / optimalSize);
+        return normalized;
+    }
+    /**
+     * Calculates recency score for changed files
+     */
+    calculateRecency(meta, changedFiles) {
+        if (changedFiles.length === 0) {
+            return 0;
+        }
+        // Check if this file was changed
+        const isChanged = changedFiles.some((changed) => changed === meta.path);
+        return isChanged ? 1.0 : 0.0;
+    }
+    /**
+     * Assigns a tier based on importance score
+     */
+    assignTier(score) {
+        if (score >= this.tiers.essential.minScore)
+            return 'essential';
+        if (score >= this.tiers.important.minScore)
+            return 'important';
+        if (score >= this.tiers.optional.minScore)
+            return 'optional';
+        return 'excluded';
+    }
+    /**
+     * Generates a human-readable reason for the score
+     */
+    generateReason(meta, taskType, score, tier) {
+        const reasons = [];
+        if (meta.relativePath.includes('index.ts')) {
+            reasons.push('main export file');
+        }
+        if (meta.relativePath.includes('test/')) {
+            reasons.push('test file (lower priority)');
+        }
+        if (taskType === 'readme' && meta.relativePath.match(/^ts\/[^\/]+\.ts$/)) {
+            reasons.push('root-level module');
+        }
+        reasons.push(`score: ${score.toFixed(2)}`);
+        reasons.push(`tier: ${tier}`);
+        return reasons.join(', ');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"context-analyzer.js","sourceRoot":"","sources":["../../ts/context/context-analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,eAAe,CAAC;AAWzC;;;GAGG;AACH,MAAM,OAAO,eAAe;IAK1B;;;;;OAKG;IACH,YACE,WAAmB,EACnB,UAA2C,EAAE,EAC7C,QAA8B,EAAE;QAEhC,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAE/B,kBAAkB;QAClB,IAAI,CAAC,OAAO,GAAG;YACb,gBAAgB,EAAE,OAAO,CAAC,gBAAgB,IAAI,GAAG;YACjD,eAAe,EAAE,OAAO,CAAC,eAAe,IAAI,GAAG;YAC/C,gBAAgB,EAAE,OAAO,CAAC,gBAAgB,IAAI,GAAG;YACjD,aAAa,EAAE,OAAO,CAAC,aAAa,IAAI,GAAG;SAC5C,CAAC;QAEF,gBAAgB;QAChB,IAAI,CAAC,KAAK,GAAG;YACX,SAAS,EAAE,KAAK,CAAC,SAAS,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE;YAClE,SAAS,EAAE,KAAK,CAAC,SAAS,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,EAAE,OAAO,EAAE;YACnE,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,SAAS,EAAE,YAAY,EAAE;SACvE,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACI,KAAK,CAAC,OAAO,CAClB,QAAyB,EACzB,QAAkB,EAClB,eAAyB,EAAE;QAE3B,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAE7B,yBAAyB;QACzB,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC,QAAQ,CAAC,CAAC;QAElE,8BAA8B;QAC9B,IAAI,CAAC,mBAAmB,CAAC,eAAe,CAAC,CAAC;QAE1C,oBAAoB;QACpB,MAAM,KAAK,GAAoB,EAAE,CAAC;QAClC,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;YAC5B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CACrC,IAAI,EACJ,QAAQ,EACR,eAAe,EACf,YAAY,CACb,CAAC;YACF,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACvB,CAAC;QAED,2CAA2C;QAC3C,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,eAAe,GAAG,CAAC,CAAC,eAAe,CAAC,CAAC;QAE5D,MAAM,gBAAgB,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;QAEhD,OAAO;YACL,QAAQ;YACR,KAAK;YACL,eAAe;YACf,UAAU,EAAE,QAAQ,CAAC,MAAM;YAC3B,gBAAgB;SACjB,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,oBAAoB,CAChC,QAAyB;QAEzB,MAAM,KAAK,GAAG,IAAI,GAAG,EAA6B,CAAC;QAEnD,2BAA2B;QAC3B,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;YAC5B,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE;gBACnB,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,OAAO,EAAE,EAAE;gBACX,UAAU,EAAE,EAAE;gBACd,UAAU,EAAE,CAAC;aACd,CAAC,CAAC;QACL,CAAC;QAED,+BAA+B;QAC/B,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;YAC5B,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACpE,MAAM,OAAO,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;gBAEzD,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAE,CAAC;gBACnC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;gBAEvB,uCAAuC;gBACvC,KAAK,MAAM,UAAU,IAAI,OAAO,EAAE,CAAC;oBACjC,MAAM,YAAY,GAAG,KAAK,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;oBAC3C,IAAI,YAAY,EAAE,CAAC;wBACjB,YAAY,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBAC1C,CAAC;gBACH,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,OAAO,CAAC,IAAI,CAAC,gCAAgC,IAAI,CAAC,IAAI,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;YAC5E,CAAC;QACH,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;OAKG;IACK,cAAc,CAAC,QAAgB,EAAE,QAAgB;QACvD,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,MAAM,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QAE/C,gCAAgC;QAChC,MAAM,WAAW,GAAG,2CAA2C,CAAC;QAChE,IAAI,KAAK,CAAC;QAEV,OAAO,CAAC,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC;YACrD,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YAE5B,wBAAwB;YACxB,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;gBAChC,SAAS;YACX,CAAC;YAED,2CAA2C;YAC3C,IAAI,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;YAE7D,iCAAiC;YACjC,MAAM,UAAU,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,WAAW,CAAC,CAAC;YAC5E,IAAI,KAAK,GAAG,KAAK,CAAC;YAElB,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;gBAC7B,MAAM,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,YAAY,GAAG,GAAG,CAAC;gBAChF,IAAI,CAAC;oBACH,4DAA4D;oBAC5D,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;oBACzB,MAAM,MAAM,GAAG,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;oBACvC,IAAI,MAAM,EAAE,CAAC;wBACX,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;wBACvB,KAAK,GAAG,IAAI,CAAC;wBACb,MAAM;oBACR,CAAC;gBACH,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,mCAAmC;gBACrC,CAAC;YACH,CAAC;YAED,IAAI,CAAC,KAAK,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;gBAC1C,oCAAoC;gBACpC,OAAO,CAAC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,CAAC;YACrC,CAAC;QACH,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;OAIG;IACK,mBAAmB,CAAC,KAAqC;QAC/D,MAAM,OAAO,GAAG,IAAI,CAAC;QACrB,MAAM,UAAU,GAAG,EAAE,CAAC;QACtB,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC;QAE7B,oBAAoB;QACpB,MAAM,MAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;QACzC,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,IAAI,EAAE,EAAE,CAAC;YAChC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,GAAG,SAAS,CAAC,CAAC;QACpC,CAAC;QAED,wBAAwB;QACxB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;YACpC,MAAM,SAAS,GAAG,IAAI,GAAG,EAAkB,CAAC;YAE5C,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;gBAC3C,IAAI,KAAK,GAAG,CAAC,CAAC,GAAG,OAAO,CAAC,GAAG,SAAS,CAAC;gBAEtC,qDAAqD;gBACrD,KAAK,MAAM,YAAY,IAAI,IAAI,CAAC,UAAU,EAAE,CAAC;oBAC3C,MAAM,YAAY,GAAG,KAAK,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;oBAC7C,IAAI,YAAY,EAAE,CAAC;wBACjB,MAAM,aAAa,GAAG,MAAM,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;wBACpD,MAAM,aAAa,GAAG,YAAY,CAAC,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC;wBACvD,KAAK,IAAI,OAAO,GAAG,CAAC,aAAa,GAAG,aAAa,CAAC,CAAC;oBACrD,CAAC;gBACH,CAAC;gBAED,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAC7B,CAAC;YAED,gBAAgB;YAChB,KAAK,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,SAAS,EAAE,CAAC;gBACtC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAC1B,CAAC;QACH,CAAC;QAED,gCAAgC;QAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;QAC9C,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;YACjB,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;gBAClC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACzC,IAAI,CAAC,UAAU,GAAG,KAAK,GAAG,QAAQ,CAAC;YACrC,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACK,KAAK,CAAC,WAAW,CACvB,IAAmB,EACnB,QAAkB,EAClB,KAAqC,EACrC,YAAsB;QAEtB,MAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAClC,MAAM,eAAe,GAAG,IAAI,EAAE,UAAU,IAAI,CAAC,CAAC;QAE9C,oCAAoC;QACpC,MAAM,cAAc,GAAG,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QAE/D,+CAA+C;QAC/C,MAAM,eAAe,GAAG,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;QAEvD,uCAAuC;QACvC,MAAM,YAAY,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;QAE/D,sCAAsC;QACtC,MAAM,eAAe,GACnB,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,eAAe;YAC7C,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB;YAC/C,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB;YAC/C,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC;QAE5C,cAAc;QACd,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;QAE9C,OAAO;YACL,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,cAAc;YACd,eAAe;YACf,eAAe;YACf,YAAY;YACZ,eAAe;YACf,IAAI;YACJ,MAAM,EAAE,IAAI,CAAC,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,eAAe,EAAE,IAAI,CAAC;SACnE,CAAC;IACJ,CAAC;IAED;;OAEG;IACK,kBAAkB,CAAC,IAAmB,EAAE,QAAkB;QAChE,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;QACrD,IAAI,KAAK,GAAG,GAAG,CAAC,CAAC,aAAa;QAE9B,8DAA8D;QAC9D,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;YAC1B,IAAI,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC;gBAAE,KAAK,IAAI,GAAG,CAAC;YACpD,IAAI,YAAY,CAAC,KAAK,CAAC,kBAAkB,CAAC;gBAAE,KAAK,IAAI,GAAG,CAAC,CAAC,qBAAqB;YAC/E,IAAI,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC;gBAAE,KAAK,IAAI,GAAG,CAAC;YACjD,IAAI,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC;gBAAE,KAAK,IAAI,GAAG,CAAC;YACpD,IAAI,YAAY,CAAC,QAAQ,CAAC,aAAa,CAAC;gBAAE,KAAK,IAAI,GAAG,CAAC;QACzD,CAAC;QAED,oEAAoE;QACpE,IAAI,QAAQ,KAAK,QAAQ,EAAE,CAAC;YAC1B,IAAI,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC;gBAAE,KAAK,IAAI,GAAG,CAAC;YACjD,oCAAoC;QACtC,CAAC;QAED,uEAAuE;QACvE,IAAI,QAAQ,KAAK,aAAa,EAAE,CAAC;YAC/B,IAAI,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC;gBAAE,KAAK,IAAI,GAAG,CAAC;YACpD,IAAI,YAAY,CAAC,KAAK,CAAC,kBAAkB,CAAC;gBAAE,KAAK,IAAI,GAAG,CAAC;YACzD,IAAI,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC;gBAAE,KAAK,IAAI,GAAG,CAAC;YACjD,IAAI,YAAY,CAAC,QAAQ,CAAC,aAAa,CAAC;gBAAE,KAAK,IAAI,GAAG,CAAC;QACzD,CAAC;QAED,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACK,mBAAmB,CAAC,IAAmB;QAC7C,mEAAmE;QACnE,MAAM,WAAW,GAAG,IAAI,CAAC,CAAC,eAAe;QACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,GAAG,WAAW,CAAC,CAAC;QAC9D,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,QAAQ,GAAG,WAAW,CAAC,CAAC;QAE3D,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;OAEG;IACK,gBAAgB,CAAC,IAAmB,EAAE,YAAsB;QAClE,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9B,OAAO,CAAC,CAAC;QACX,CAAC;QAED,iCAAiC;QACjC,MAAM,SAAS,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,KAAK,IAAI,CAAC,IAAI,CAAC,CAAC;QAExE,OAAO,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;IAC/B,CAAC;IAED;;OAEG;IACK,UAAU,CAAC,KAAa;QAC9B,IAAI,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ;YAAE,OAAO,WAAW,CAAC;QAC/D,IAAI,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,QAAQ;YAAE,OAAO,WAAW,CAAC;QAC/D,IAAI,KAAK,IAAI,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,QAAQ;YAAE,OAAO,UAAU,CAAC;QAC7D,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;OAEG;IACK,cAAc,CACpB,IAAmB,EACnB,QAAkB,EAClB,KAAa,EACb,IAAY;QAEZ,MAAM,OAAO,GAAa,EAAE,CAAC;QAE7B,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;YAC3C,OAAO,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACnC,CAAC;QAED,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YACxC,OAAO,CAAC,IAAI,CAAC,4BAA4B,CAAC,CAAC;QAC7C,CAAC;QAED,IAAI,QAAQ,KAAK,QAAQ,IAAI,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,kBAAkB,CAAC,EAAE,CAAC;YACzE,OAAO,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;QACpC,CAAC;QAED,OAAO,CAAC,IAAI,CAAC,UAAU,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC3C,OAAO,CAAC,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC,CAAC;QAE9B,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5B,CAAC;CACF"}