mnehmos.trace.mcp 1.0.0

package/dist/languages/import-resolver.d.ts

@@ -0,0 +1,645 @@
+/**
+ * 🔗 Cross-File Import Resolution for TypeScript Projects
+ *
+ * This module provides comprehensive import resolution capabilities for TypeScript
+ * projects, including:
+ * - Relative import resolution (./foo, ../bar)
+ * - tsconfig.json path alias resolution (@/utils, models)
+ * - Re-export chain following (export * from, export { X } from)
+ * - Circular reference detection
+ * - Import graph building for visualization
+ *
+ * @module import-resolver
+ * @see ADR Reference: .context/ADR-P2-5-IMPORT-RESOLUTION.md
+ *
+ * @example Basic Usage
+ * ```typescript
+ * import { ImportResolverImpl } from './import-resolver.js';
+ *
+ * const resolver = new ImportResolverImpl({
+ *   tsConfigPath: './tsconfig.json',
+ *   maxReexportDepth: 10,
+ * });
+ *
+ * // Resolve an import
+ * const result = resolver.resolve('./types', '/project/src/index.ts');
+ *
+ * // Get all exported types from a file
+ * const types = resolver.getExportedTypes('/project/src/types/index.ts');
+ *
+ * // Resolve a specific type reference
+ * const typeRef = resolver.resolveTypeRef('User', '/project/src/handlers/user.ts');
+ * ```
+ */
+import { SourceFile } from 'ts-morph';
+import type { NormalizedType } from '../core/types.js';
+/**
+ * Result of resolving an import specifier to a file path.
+ *
+ * This interface represents the complete result of import resolution,
+ * including the resolved file path, export information, and the parsed
+ * source file for further analysis.
+ *
+ * @example
+ * ```typescript
+ * const result: ResolvedImport = {
+ *   filePath: '/project/src/types/user.ts',
+ *   exportName: 'User',
+ *   isDefault: false,
+ *   isNamespace: false,
+ *   isTypeOnly: true,
+ *   originalSpecifier: './types/user',
+ * };
+ * ```
+ */
+export interface ResolvedImport {
+    /** Absolute path to the resolved file */
+    filePath: string;
+    /** The export name (or 'default' for default exports, '*' for namespace) */
+    exportName: string;
+    /** Whether this is a default import (`import X from '...'`) */
+    isDefault: boolean;
+    /** Whether this is a namespace import (`import * as X from '...'`) */
+    isNamespace: boolean;
+    /** Whether this is a type-only import (`import type { X } from '...'`) */
+    isTypeOnly: boolean;
+    /** The source file containing the export (if successfully parsed) */
+    sourceFile?: SourceFile;
+    /** Original import specifier for debugging and error messages */
+    originalSpecifier: string;
+}
+/**
+ * Result of resolving a type reference across files.
+ *
+ * When resolving a type like `User` from a handler file, this interface
+ * provides the fully resolved type definition, the file where it's defined,
+ * and the chain of re-exports that were followed to find it.
+ *
+ * @example
+ * ```typescript
+ * const result: ResolvedTypeRef = {
+ *   type: { kind: 'object', schema: { name: 'User', properties: {...} } },
+ *   definitionFile: '/project/src/types/user.ts',
+ *   definitionLine: 5,
+ *   reexportChain: ['/project/src/types/index.ts'],
+ *   complete: true,
+ * };
+ * ```
+ */
+export interface ResolvedTypeRef {
+    /** The fully resolved type in NormalizedType format */
+    type: NormalizedType;
+    /** Absolute path to the file where the type is defined */
+    definitionFile: string;
+    /** Line number of the type definition (1-indexed) */
+    definitionLine: number;
+    /** Chain of re-export files traversed to reach the definition */
+    reexportChain: string[];
+    /** Whether resolution was complete or partial */
+    complete: boolean;
+    /** Reason if resolution was incomplete (e.g., circular reference, max depth) */
+    incompleteReason?: string;
+}
+/**
+ * Configuration options for the import resolver.
+ *
+ * @example
+ * ```typescript
+ * const config: ImportResolverConfig = {
+ *   tsConfigPath: './tsconfig.json',
+ *   maxReexportDepth: 15,
+ *   maxCacheSize: 1000,
+ *   includeNodeModules: false,
+ * };
+ * ```
+ */
+export interface ImportResolverConfig {
+    /**
+     * Path to tsconfig.json file.
+     * Enables path alias resolution using `compilerOptions.paths` and `baseUrl`.
+     */
+    tsConfigPath?: string;
+    /**
+     * Maximum depth for re-export chain resolution.
+     * Prevents infinite loops in complex re-export scenarios.
+     * @default 10
+     */
+    maxReexportDepth?: number;
+    /**
+     * Maximum number of entries in the file cache (LRU eviction).
+     * Higher values use more memory but improve performance.
+     * @default 500
+     */
+    maxCacheSize?: number;
+    /**
+     * Whether to resolve imports from node_modules.
+     * When false, third-party package imports return null.
+     * @default false
+     */
+    includeNodeModules?: boolean;
+    /**
+     * Custom module resolution path mappings.
+     * Alternative to tsconfig.json paths for dynamic configuration.
+     */
+    pathMappings?: Record<string, string[]>;
+    /**
+     * Base directory for relative path resolution.
+     * Defaults to the directory containing the source file.
+     */
+    baseDir?: string;
+}
+/**
+ * Node in an import dependency graph.
+ *
+ * Represents a file and its import/export relationships for visualization
+ * and dependency analysis.
+ *
+ * @example
+ * ```typescript
+ * const node: ImportGraphNode = {
+ *   filePath: '/project/src/handlers/user.ts',
+ *   imports: [
+ *     { specifier: '../types', resolved: '/project/src/types/index.ts', names: ['User'] },
+ *   ],
+ *   exports: ['getUserHandler', 'createUserHandler'],
+ *   children: [...], // Recursive nodes for imported files
+ * };
+ * ```
+ */
+export interface ImportGraphNode {
+    /** Absolute path to this file */
+    filePath: string;
+    /** List of imports in this file */
+    imports: Array<{
+        /** Original import specifier (e.g., '../types', '@/utils') */
+        specifier: string;
+        /** Resolved absolute path, or null if unresolvable */
+        resolved: string | null;
+        /** Names imported from this specifier */
+        names: string[];
+    }>;
+    /** List of exported type/value names from this file */
+    exports: string[];
+    /** Child nodes for imported files (when depth > 0) */
+    children?: ImportGraphNode[];
+}
+/**
+ * Statistics about the file cache performance.
+ *
+ * Use this to monitor cache effectiveness and tune `maxCacheSize`.
+ */
+export interface CacheStats {
+    /** Current number of cached entries */
+    size: number;
+    /** Maximum cache capacity */
+    maxSize: number;
+    /** Number of cache hits (successful lookups) */
+    hits: number;
+    /** Number of cache misses (new file parses required) */
+    misses: number;
+    /** Cache hit rate as a decimal (0.0 to 1.0) */
+    hitRate: number;
+}
+/**
+ * Import resolution engine interface.
+ *
+ * Provides methods for resolving TypeScript imports, extracting exported types,
+ * and building import dependency graphs.
+ *
+ * @example
+ * ```typescript
+ * const resolver: ImportResolver = new ImportResolverImpl({
+ *   tsConfigPath: './tsconfig.json',
+ * });
+ *
+ * // Resolve a relative import
+ * const resolved = resolver.resolve('./types', '/project/src/index.ts');
+ *
+ * // Get exported types
+ * const types = resolver.getExportedTypes('/project/src/types/index.ts');
+ * ```
+ */
+export interface ImportResolver {
+    /**
+     * Resolves an import specifier from a source file.
+     *
+     * @param importPath - The import specifier (e.g., './types', '@/utils', 'lodash')
+     * @param fromFile - Absolute path to the file containing the import
+     * @returns Resolved import info, or null if unresolvable
+     *
+     * @example
+     * ```typescript
+     * const result = resolver.resolve('./types/user', '/project/src/handlers/index.ts');
+     * // result.filePath === '/project/src/types/user.ts'
+     * ```
+     */
+    resolve(importPath: string, fromFile: string): ResolvedImport | null;
+    /**
+     * Gets all exported types from a file.
+     *
+     * Includes both direct exports and re-exports from other modules.
+     *
+     * @param filePath - Absolute path to the file
+     * @returns Map of export name to NormalizedType
+     *
+     * @example
+     * ```typescript
+     * const types = resolver.getExportedTypes('/project/src/types/index.ts');
+     * // types.get('User') => { kind: 'object', schema: {...} }
+     * ```
+     */
+    getExportedTypes(filePath: string): Map<string, NormalizedType>;
+    /**
+     * Resolves a type reference following imports and re-exports.
+     *
+     * Starting from a source file, follows the import chain to find
+     * where a type is actually defined.
+     *
+     * @param typeName - Name of the type to resolve
+     * @param fromFile - Absolute path to the file using the type
+     * @returns Resolved type reference, or null if not found
+     *
+     * @example
+     * ```typescript
+     * const ref = resolver.resolveTypeRef('User', '/project/src/handlers/user.ts');
+     * // ref.definitionFile === '/project/src/types/user.ts'
+     * // ref.reexportChain === ['/project/src/types/index.ts']
+     * ```
+     */
+    resolveTypeRef(typeName: string, fromFile: string): ResolvedTypeRef | null;
+    /**
+     * Gets the import graph for a file.
+     *
+     * Builds a tree of import dependencies for visualization or analysis.
+     *
+     * @param filePath - Absolute path to the root file
+     * @param depth - How deep to traverse (default: 1)
+     * @returns Import graph node with children
+     *
+     * @example
+     * ```typescript
+     * const graph = resolver.getImportGraph('/project/src/index.ts', 2);
+     * // graph.imports => [{ specifier: './handlers', resolved: '...', names: [...] }]
+     * // graph.children => [{ filePath: '...', imports: [...], ... }]
+     * ```
+     */
+    getImportGraph(filePath: string, depth?: number): ImportGraphNode;
+    /**
+     * Clears all cached data.
+     *
+     * Use after making changes to source files to ensure fresh parsing.
+     */
+    clearCache(): void;
+    /**
+     * Gets cache performance statistics.
+     *
+     * @returns Current cache statistics
+     *
+     * @example
+     * ```typescript
+     * const stats = resolver.getCacheStats();
+     * console.log(`Cache hit rate: ${(stats.hitRate * 100).toFixed(1)}%`);
+     * ```
+     */
+    getCacheStats(): CacheStats;
+    /**
+     * Warms the cache by pre-loading files matching patterns.
+     *
+     * Use before batch operations to improve performance.
+     *
+     * @param patterns - Glob patterns for files to pre-load
+     *
+     * @example
+     * ```typescript
+     * await resolver.warmCache(['src/**\/*.ts', 'lib/**\/*.ts']);
+     * ```
+     */
+    warmCache(patterns: string[]): Promise<void>;
+}
+/**
+ * Cached data for a parsed TypeScript file.
+ * @internal
+ */
+interface CacheEntry {
+    /** Parsed ts-morph source file */
+    sourceFile: SourceFile;
+    /** Exported types (lazily computed on first access) */
+    exportedTypes?: Map<string, NormalizedType>;
+    /** File modification time for cache invalidation */
+    mtime: number;
+    /** Timestamp when this entry was created */
+    cachedAt: number;
+}
+/**
+ * LRU (Least Recently Used) Cache for parsed TypeScript files.
+ *
+ * Provides efficient caching with automatic eviction of least-recently-used
+ * entries when the cache reaches capacity.
+ *
+ * @example
+ * ```typescript
+ * const cache = new FileCache(100);
+ * cache.set('/path/to/file.ts', { sourceFile, mtime: Date.now(), cachedAt: Date.now() });
+ * const entry = cache.get('/path/to/file.ts');
+ * ```
+ */
+export declare class FileCache {
+    private cache;
+    private accessOrder;
+    private readonly maxSize;
+    private hits;
+    private misses;
+    /**
+     * Creates a new FileCache instance.
+     *
+     * @param maxSize - Maximum number of entries before LRU eviction (default: 500)
+     */
+    constructor(maxSize?: number);
+    /**
+     * Gets a cached entry, updating its access order.
+     *
+     * @param filePath - Absolute path to the file
+     * @returns Cached entry, or undefined if not cached
+     */
+    get(filePath: string): CacheEntry | undefined;
+    /**
+     * Sets a cache entry, evicting LRU entries if at capacity.
+     *
+     * @param filePath - Absolute path to the file
+     * @param entry - Cache entry to store
+     */
+    set(filePath: string, entry: CacheEntry): void;
+    /**
+     * Invalidates a cache entry for a modified file.
+     *
+     * @param filePath - Absolute path to the file to invalidate
+     */
+    invalidate(filePath: string): void;
+    /**
+     * Clears all cached data and resets statistics.
+     */
+    clear(): void;
+    /**
+     * Gets cache performance statistics.
+     *
+     * @returns Cache statistics including hit rate
+     */
+    getStats(): CacheStats;
+}
+/**
+ * Implementation of the ImportResolver interface.
+ *
+ * Provides comprehensive import resolution for TypeScript projects including:
+ * - Relative import resolution with extension probing
+ * - tsconfig.json path alias resolution
+ * - Re-export chain following
+ * - Circular reference detection
+ * - LRU caching for performance
+ *
+ * @example
+ * ```typescript
+ * const resolver = new ImportResolverImpl({
+ *   tsConfigPath: './tsconfig.json',
+ *   maxReexportDepth: 15,
+ *   maxCacheSize: 1000,
+ * });
+ *
+ * // Resolve an import
+ * const result = resolver.resolve('./types', '/project/src/index.ts');
+ * if (result) {
+ *   console.log(`Resolved to: ${result.filePath}`);
+ * }
+ *
+ * // Get all exported types
+ * const types = resolver.getExportedTypes('/project/src/types/index.ts');
+ * for (const [name, type] of types) {
+ *   console.log(`Export: ${name} (${type.kind})`);
+ * }
+ * ```
+ */
+export declare class ImportResolverImpl implements ImportResolver {
+    private config;
+    private cache;
+    private project;
+    private tsConfigPaths;
+    private tsConfigDir;
+    /**
+     * Creates a new ImportResolverImpl instance.
+     *
+     * @param config - Configuration options for the resolver
+     *
+     * @example
+     * ```typescript
+     * const resolver = new ImportResolverImpl({
+     *   tsConfigPath: './tsconfig.json',
+     *   maxCacheSize: 1000,
+     * });
+     * ```
+     */
+    constructor(config?: ImportResolverConfig);
+    /**
+     * Resolves an import specifier from a source file.
+     *
+     * Handles relative imports, path aliases, and baseUrl resolution.
+     * Returns null for node_modules imports unless `includeNodeModules` is true.
+     *
+     * @param importPath - The import specifier (e.g., './types', '@/utils')
+     * @param fromFile - Absolute path to the file containing the import
+     * @returns Resolved import info, or null if unresolvable
+     */
+    resolve(importPath: string, fromFile: string): ResolvedImport | null;
+    /**
+     * Gets all exported types from a file.
+     *
+     * Collects direct exports (interfaces, type aliases, enums) and follows
+     * re-export chains to gather all publicly available types.
+     *
+     * @param filePath - Absolute path to the file
+     * @returns Map of export name to NormalizedType
+     */
+    getExportedTypes(filePath: string): Map<string, NormalizedType>;
+    /**
+     * Resolves a type reference following imports and re-exports.
+     *
+     * Starting from a source file, traces the import chain to find where
+     * a type is actually defined, handling re-exports and aliases.
+     *
+     * @param typeName - Name of the type to resolve
+     * @param fromFile - Absolute path to the file using the type
+     * @returns Resolved type reference, or null if not found
+     */
+    resolveTypeRef(typeName: string, fromFile: string): ResolvedTypeRef | null;
+    /**
+     * Gets the import graph for a file.
+     *
+     * Builds a tree structure showing all import dependencies, useful for
+     * visualization and dependency analysis.
+     *
+     * @param filePath - Absolute path to the root file
+     * @param depth - How deep to traverse (default: 1)
+     * @returns Import graph node with children
+     */
+    getImportGraph(filePath: string, depth?: number): ImportGraphNode;
+    /**
+     * Clears all cached data.
+     *
+     * Use after making changes to source files to ensure fresh parsing.
+     */
+    clearCache(): void;
+    /**
+     * Gets cache performance statistics.
+     *
+     * @returns Current cache statistics
+     */
+    getCacheStats(): CacheStats;
+    /**
+     * Warms the cache by pre-loading files matching patterns.
+     *
+     * @param patterns - Glob patterns for files to pre-load
+     */
+    warmCache(patterns: string[]): Promise<void>;
+    /**
+     * Resolves a relative import path (./foo or ../bar).
+     *
+     * @param importPath - The relative import specifier
+     * @param fromFile - Absolute path to the file containing the import
+     * @returns Resolved absolute path, or null if not found
+     * @internal
+     */
+    private resolveRelativeImport;
+    /**
+     * Resolves a path alias from tsconfig.json paths configuration.
+     *
+     * @param importPath - The import specifier (e.g., '@/utils', 'models')
+     * @param fromFile - Absolute path to the file containing the import
+     * @returns Resolved absolute path, or null if not a matching alias
+     * @internal
+     */
+    private resolvePathAlias;
+    /**
+     * Resolves an import using baseUrl from tsconfig.json.
+     *
+     * @param importPath - The import specifier
+     * @param fromFile - Absolute path to the file containing the import
+     * @returns Resolved absolute path, or null if not found
+     * @internal
+     */
+    private resolveFromBaseUrl;
+    /**
+     * Probes for a file with various extensions and index files.
+     *
+     * @param targetBase - Base path to probe
+     * @returns Resolved path if found, or null
+     * @internal
+     */
+    private probeFile;
+    /**
+     * Creates a ResolvedImport object from a resolved file path.
+     *
+     * @param filePath - Resolved absolute file path
+     * @param originalSpecifier - Original import specifier
+     * @returns ResolvedImport object
+     * @internal
+     */
+    private createResolvedImport;
+    /**
+     * Gets or parses a source file, using cache when available.
+     *
+     * @param filePath - Absolute path to the file
+     * @returns Parsed SourceFile, or null if parsing fails
+     * @internal
+     */
+    private getOrParseFile;
+    /**
+     * Collects directly exported types from a source file.
+     *
+     * @param sourceFile - The source file to analyze
+     * @param result - Map to populate with exported types
+     * @internal
+     */
+    private collectDirectExports;
+    /**
+     * Collects re-exported types from a source file.
+     *
+     * Follows `export * from '...'` and `export { X } from '...'` declarations.
+     *
+     * @param sourceFile - The source file to analyze
+     * @param result - Map to populate with re-exported types
+     * @param visited - Set of visited file paths for cycle detection
+     * @param depth - Current recursion depth
+     * @internal
+     */
+    private collectReExports;
+    /**
+     * Converts a TypeScript interface to NormalizedType format.
+     *
+     * @param iface - The interface node to convert
+     * @returns NormalizedType representation
+     * @internal
+     */
+    private convertInterfaceToNormalizedType;
+    /**
+     * Converts a TypeScript type alias to NormalizedType format.
+     *
+     * @param typeAlias - The type alias node to convert
+     * @returns NormalizedType representation
+     * @internal
+     */
+    private convertTypeAliasToNormalizedType;
+    /**
+     * Converts a ts-morph Type to NormalizedType format.
+     *
+     * Handles primitives, literals, arrays, unions, intersections, and objects.
+     *
+     * @param type - The ts-morph Type to convert
+     * @param visitingTypes - Set of type names being visited (for cycle detection)
+     * @returns NormalizedType representation
+     * @internal
+     */
+    private convertTsTypeToNormalized;
+    /**
+     * Internal type reference resolution with cycle detection.
+     *
+     * @param typeName - Name of the type to resolve
+     * @param sourceFile - Current source file being analyzed
+     * @param visited - Set of visited file:type combinations
+     * @param reexportChain - Chain of re-export files traversed
+     * @param depth - Current recursion depth
+     * @returns Resolved type reference, or null if not found
+     * @internal
+     */
+    private resolveTypeRefInternal;
+    /**
+     * Finds a direct type definition in a source file.
+     *
+     * @param typeName - Name of the type to find
+     * @param sourceFile - Source file to search
+     * @returns Type and line number if found, or null
+     * @internal
+     */
+    private findDirectDefinition;
+    /**
+     * Finds a type in the imports of a source file.
+     *
+     * @param typeName - Name of the type to find
+     * @param sourceFile - Source file containing imports
+     * @param visited - Set of visited file:type combinations
+     * @param reexportChain - Chain of re-export files traversed
+     * @param depth - Current recursion depth
+     * @returns Resolved type reference, or null if not found in imports
+     * @internal
+     */
+    private findInImports;
+    /**
+     * Builds an import graph recursively from a source file.
+     *
+     * @param sourceFile - Root source file
+     * @param depth - Remaining depth to traverse
+     * @param visited - Set of visited file paths
+     * @returns Import graph node
+     * @internal
+     */
+    private buildImportGraph;
+}
+export {};
+//# sourceMappingURL=import-resolver.d.ts.map

package/dist/languages/import-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-resolver.d.ts","sourceRoot":"","sources":["../../src/languages/import-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAAW,UAAU,EAAkD,MAAM,UAAU,CAAC;AAC/F,OAAO,KAAK,EAAE,cAAc,EAA4C,MAAM,kBAAkB,CAAC;AAqGjG;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,cAAc;IAC7B,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAC;IAEjB,4EAA4E;IAC5E,UAAU,EAAE,MAAM,CAAC;IAEnB,+DAA+D;IAC/D,SAAS,EAAE,OAAO,CAAC;IAEnB,sEAAsE;IACtE,WAAW,EAAE,OAAO,CAAC;IAErB,0EAA0E;IAC1E,UAAU,EAAE,OAAO,CAAC;IAEpB,qEAAqE;IACrE,UAAU,CAAC,EAAE,UAAU,CAAC;IAExB,iEAAiE;IACjE,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,eAAe;IAC9B,uDAAuD;IACvD,IAAI,EAAE,cAAc,CAAC;IAErB,0DAA0D;IAC1D,cAAc,EAAE,MAAM,CAAC;IAEvB,qDAAqD;IACrD,cAAc,EAAE,MAAM,CAAC;IAEvB,iEAAiE;IACjE,aAAa,EAAE,MAAM,EAAE,CAAC;IAExB,iDAAiD;IACjD,QAAQ,EAAE,OAAO,CAAC;IAElB,gFAAgF;IAChF,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAE1B;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAE7B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAExC;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,eAAe;IAC9B,iCAAiC;IACjC,QAAQ,EAAE,MAAM,CAAC;IAEjB,mCAAmC;IACnC,OAAO,EAAE,KAAK,CAAC;QACb,8DAA8D;QAC9D,SAAS,EAAE,MAAM,CAAC;QAClB,sDAAsD;QACtD,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;QACxB,yCAAyC;QACzC,KAAK,EAAE,MAAM,EAAE,CAAC;KACjB,CAAC,CAAC;IAEH,uDAAuD;IACvD,OAAO,EAAE,MAAM,EAAE,CAAC;IAElB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,UAAU;IACzB,uCAAuC;IACvC,IAAI,EAAE,MAAM,CAAC;IAEb,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAC;IAEhB,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IAEb,wDAAwD;IACxD,MAAM,EAAE,MAAM,CAAC;IAEf,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,cAAc;IAC7B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAAC;IAErE;;;;;;;;;;;;;OAaG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAEhE;;;;;;;;;;;;;;;;OAgBG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAAC;IAE3E;;;;;;;;;;;;;;;OAeG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,eAAe,CAAC;IAElE;;;;OAIG;IACH,UAAU,IAAI,IAAI,CAAC;IAEnB;;;;;;;;;;OAUG;IACH,aAAa,IAAI,UAAU,CAAC;IAE5B;;;;;;;;;;;OAWG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9C;AAMD;;;GAGG;AACH,UAAU,UAAU;IAClB,kCAAkC;IAClC,UAAU,EAAE,UAAU,CAAC;IAEvB,uDAAuD;IACvD,aAAa,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC;IAE5C,oDAAoD;IACpD,KAAK,EAAE,MAAM,CAAC;IAEd,4CAA4C;IAC5C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAA0B;IACvC,OAAO,CAAC,WAAW,CAAW;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,MAAM,CAAK;IAEnB;;;;OAIG;gBACS,OAAO,SAAM;IAMzB;;;;;OAKG;IACH,GAAG,CAAC,QAAQ,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAgB7C;;;;;OAKG;IACH,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI;IAuB9C;;;;OAIG;IACH,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI;IAQlC;;OAEG;IACH,KAAK,IAAI,IAAI;IAOb;;;;OAIG;IACH,QAAQ,IAAI,UAAU;CAUvB;AA8CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,kBAAmB,YAAW,cAAc;IACvD,OAAO,CAAC,MAAM,CAC4D;IAC1E,OAAO,CAAC,KAAK,CAAY;IACzB,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,WAAW,CAAc;IAEjC;;;;;;;;;;;;OAYG;gBACS,MAAM,GAAE,oBAAyB;IAgC7C;;;;;;;;;OASG;IACH,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAsCpE;;;;;;;;OAQG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC;IAsB/D;;;;;;;;;OASG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI;IAwB1E;;;;;;;;;OASG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,GAAE,MAAU,GAAG,eAAe;IAmBpE;;;;OAIG;IACH,UAAU,IAAI,IAAI;IAIlB;;;;OAIG;IACH,aAAa,IAAI,UAAU;IAI3B;;;;OAIG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BlD;;;;;;;OAOG;IACH,OAAO,CAAC,qBAAqB;IAiE7B;;;;;;;OAOG;IACH,OAAO,CAAC,gBAAgB;IA2CxB;;;;;;;OAOG;IACH,OAAO,CAAC,kBAAkB;IAc1B;;;;;;OAMG;IACH,OAAO,CAAC,SAAS;IAsBjB;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAuB5B;;;;;;OAMG;IACH,OAAO,CAAC,cAAc;IAwCtB;;;;;;OAMG;IACH,OAAO,CAAC,oBAAoB;IAkC5B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,gBAAgB;IAuExB;;;;;;OAMG;IACH,OAAO,CAAC,gCAAgC;IA6CxC;;;;;;OAMG;IACH,OAAO,CAAC,gCAAgC;IASxC;;;;;;;;;OASG;IACH,OAAO,CAAC,yBAAyB;IAuJjC;;;;;;;;;;OAUG;IACH,OAAO,CAAC,sBAAsB;IAuG9B;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IAqC5B;;;;;;;;;;OAUG;IACH,OAAO,CAAC,aAAa;IA6CrB;;;;;;;;OAQG;IACH,OAAO,CAAC,gBAAgB;CA2FzB"}