@domainlang/language 0.1.20 → 0.1.82

package/src/validation/import.ts

@@ -1,295 +1,171 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
 import type { ValidationAcceptor, ValidationChecks } from 'langium';
-import { Cancellation } from 'langium';
-import type { DomainLangAstType, ImportStatement } from '../generated/ast.js';
+import type { DomainLangAstType, ImportStatement, Model } from '../generated/ast.js';
+import { resolveImportPath } from '../utils/import-utils.js';
 import type { DomainLangServices } from '../domain-lang-module.js';
 import type { LangiumDocument } from 'langium';
-import type { WorkspaceManager } from '../services/workspace-manager.js';
-import type { ExtendedDependencySpec, ModelManifest, LockFile } from '../services/types.js';
-import { ValidationMessages, buildCodeDescription, IssueCodes } from './constants.js';
 
 /**
  * Validates import statements in DomainLang.
- *
- * Uses async validators (Langium 4.x supports MaybePromise<void>) to leverage
- * the shared WorkspaceManager service with its cached manifest/lock file reading.
- *
+ * 
  * Checks:
- * - External imports require manifest + alias
- * - Local path dependencies stay inside workspace  
- * - Lock file exists for external dependencies
+ * - Import paths are resolvable
+ * - Named imports exist in target document
+ * - Import aliases don't conflict with local names
  */
 export class ImportValidator {
-    private readonly workspaceManager: WorkspaceManager;
+    private readonly documents: DomainLangServices['shared']['workspace']['LangiumDocuments'];
 
     constructor(services: DomainLangServices) {
-        this.workspaceManager = services.imports.WorkspaceManager;
+        this.documents = services.shared.workspace.LangiumDocuments;
     }
 
     /**
-     * Validates an import statement asynchronously.
-     *
-     * Langium validators can return MaybePromise<void>, enabling async operations
-     * like reading manifests via the shared, cached WorkspaceManager.
+     * Validates that an import path is resolvable.
      */
     async checkImportPath(
         imp: ImportStatement,
         accept: ValidationAcceptor,
-        document: LangiumDocument,
-        _cancelToken: Cancellation.CancellationToken
+        document: LangiumDocument
     ): Promise<void> {
         if (!imp.uri) {
-            accept('error', ValidationMessages.IMPORT_MISSING_URI(), {
+            accept('error', 'Import statement must have a URI', { 
                 node: imp,
-                keyword: 'import',
-                codeDescription: buildCodeDescription('language.md', 'imports'),
-                data: { code: IssueCodes.ImportMissingUri }
+                keyword: 'import'
             });
             return;
         }
 
-        if (!this.isExternalImport(imp.uri)) {
-            return;
-        }
-
-        // Initialize workspace manager from document location
-        const docDir = path.dirname(document.uri.fsPath);
-        await this.workspaceManager.initialize(docDir);
-
-        const manifest = await this.workspaceManager.getManifest();
-        if (!manifest) {
-            accept('error', ValidationMessages.IMPORT_REQUIRES_MANIFEST(imp.uri), {
-                node: imp,
-                property: 'uri',
-                codeDescription: buildCodeDescription('language.md', 'imports'),
-                data: { code: IssueCodes.ImportRequiresManifest, specifier: imp.uri }
-            });
-            return;
-        }
-
-        const alias = imp.uri.split('/')[0];
-        const dependency = this.getDependency(manifest, alias);
-
-        if (!dependency) {
-            accept('error', ValidationMessages.IMPORT_NOT_IN_MANIFEST(alias), {
+        try {
+            await resolveImportPath(document, imp.uri);
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            accept('error', `Cannot resolve import: ${message}`, {
                 node: imp,
-                property: 'uri',
-                codeDescription: buildCodeDescription('language.md', 'imports'),
-                data: { code: IssueCodes.ImportNotInManifest, alias }
+                property: 'uri'
             });
-            return;
-        }
-
-        this.validateDependencyConfig(dependency, alias, accept, imp);
-
-        // External source dependencies require lock file and cached packages
-        if (dependency.source) {
-            const lockFile = await this.workspaceManager.getLockFile();
-            if (!lockFile) {
-                accept('error', ValidationMessages.IMPORT_NOT_INSTALLED(alias), {
-                    node: imp,
-                    property: 'uri',
-                    codeDescription: buildCodeDescription('language.md', 'imports'),
-                    data: { code: IssueCodes.ImportNotInstalled, alias }
-                });
-                return;
-            }
-
-            await this.validateCachedPackage(dependency, alias, lockFile, accept, imp);
-        }
-    }
-
-    /**
-     * Determines if an import URI is external (requires manifest).
-     *
-     * Per PRS-010:
-     * - Local relative: ./path, ../path
-     * - Path aliases: @/path, @alias/path (resolved via manifest paths section)
-     * - External: owner/package (requires manifest dependencies)
-     */
-    private isExternalImport(uri: string): boolean {
-        if (uri.startsWith('./') || uri.startsWith('../')) {
-            return false;
-        }
-        if (uri.startsWith('@')) {
-            return false;
         }
-        return true;
     }
 
     /**
-     * Gets the normalized dependency configuration for an alias.
+     * Validates that named imports exist in the target document.
      */
-    private getDependency(manifest: ModelManifest, alias: string): ExtendedDependencySpec | undefined {
-        const dep = manifest.dependencies?.[alias];
-        if (!dep) {
-            return undefined;
-        }
-
-        if (typeof dep === 'string') {
-            return { source: alias, ref: dep };
-        }
-
-        if (!dep.source && !dep.path) {
-            return { ...dep, source: alias };
-        }
-
-        return dep;
-    }
-
-    /**
-     * Validates dependency configuration.
-     */
-    private validateDependencyConfig(
-        dependency: ExtendedDependencySpec,
-        alias: string,
+    async checkNamedImports(
+        imp: ImportStatement,
         accept: ValidationAcceptor,
-        imp: ImportStatement
-    ): void {
-        if (dependency.source && dependency.path) {
-            accept('error', ValidationMessages.IMPORT_CONFLICTING_SOURCE_PATH(alias), {
-                node: imp,
-                property: 'uri',
-                codeDescription: buildCodeDescription('language.md', 'imports'),
-                data: { code: IssueCodes.ImportConflictingSourcePath, alias }
-            });
+        document: LangiumDocument
+    ): Promise<void> {
+        // Only check if we have named imports
+        if (!imp.symbols || imp.symbols.length === 0) {
             return;
         }
 
-        if (!dependency.source && !dependency.path) {
-            accept('error', ValidationMessages.IMPORT_MISSING_SOURCE_OR_PATH(alias), {
-                node: imp,
-                property: 'uri',
-                codeDescription: buildCodeDescription('language.md', 'imports'),
-                data: { code: IssueCodes.ImportMissingSourceOrPath, alias }
-            });
-            return;
+        if (!imp.uri) {
+            return; // Already reported by checkImportPath
         }
 
-        if (dependency.source && !dependency.ref) {
-            accept('error', ValidationMessages.IMPORT_MISSING_REF(alias), {
-                node: imp,
-                property: 'uri',
-                codeDescription: buildCodeDescription('language.md', 'imports'),
-                data: { code: IssueCodes.ImportMissingRef, alias }
-            });
-        }
+        try {
+            // Resolve the target document
+            const targetUri = await resolveImportPath(document, imp.uri);
+            const targetDoc = await this.documents.getOrCreateDocument(targetUri);
+            
+            if (!targetDoc.parseResult?.value) {
+                accept('error', `Cannot load imported document: ${imp.uri}`, {
+                    node: imp,
+                    property: 'uri'
+                });
+                return;
+            }
 
-        if (dependency.path) {
-            this.validateLocalPathDependency(dependency.path, alias, accept, imp);
+            // Get all exported symbols from target document
+            const targetModel = targetDoc.parseResult.value as Model;
+            const exportedSymbols = this.getExportedSymbols(targetModel);
+
+            // Check each imported symbol
+            for (const symbol of imp.symbols) {
+                if (!exportedSymbols.has(symbol)) {
+                    accept('error', 
+                        `Symbol '${symbol}' not found in ${imp.uri}`,
+                        {
+                            node: imp,
+                            property: 'symbols'
+                        }
+                    );
+                }
+            }
+        } catch {
+            // Import path error already reported by checkImportPath
+            return;
         }
     }
 
     /**
-     * Validates local path dependencies stay within workspace.
+     * Gets all exportable symbols from a model.
+     * 
+     * In DomainLang, top-level declarations are implicitly exported:
+     * - Domains
+     * - BoundedContexts
+     * - Classifications
+     * - Groups
      */
-    private validateLocalPathDependency(
-        dependencyPath: string,
-        alias: string,
-        accept: ValidationAcceptor,
-        imp: ImportStatement
-    ): void {
-        if (path.isAbsolute(dependencyPath)) {
-            accept('error', ValidationMessages.IMPORT_ABSOLUTE_PATH(alias, dependencyPath), {
-                node: imp,
-                property: 'uri',
-                codeDescription: buildCodeDescription('language.md', 'imports'),
-                data: { code: IssueCodes.ImportAbsolutePath, alias, path: dependencyPath }
-            });
-            return;
+    private getExportedSymbols(model: Model): Set<string> {
+        const symbols = new Set<string>();
+
+        // Iterate through all structure elements
+        for (const element of model.children ?? []) {
+            // Check if element has a name and add it
+            if ('name' in element && typeof element.name === 'string') {
+                symbols.add(element.name);
+            }
         }
 
-        const workspaceRoot = this.workspaceManager.getWorkspaceRoot();
-        const resolvedPath = path.resolve(workspaceRoot, dependencyPath);
-        const relativeToWorkspace = path.relative(workspaceRoot, resolvedPath);
-
-        if (relativeToWorkspace.startsWith('..') || path.isAbsolute(relativeToWorkspace)) {
-            accept('error', ValidationMessages.IMPORT_ESCAPES_WORKSPACE(alias), {
-                node: imp,
-                property: 'uri',
-                codeDescription: buildCodeDescription('language.md', 'imports'),
-                data: { code: IssueCodes.ImportEscapesWorkspace, alias }
-            });
-        }
+        return symbols;
     }
 
     /**
-     * Validates that external dependency is in lock file and cached.
+     * Checks for unused imports.
+     * 
+     * This is a warning, not an error, to avoid being too strict.
      */
-    private async validateCachedPackage(
-        dependency: ExtendedDependencySpec,
-        alias: string,
-        lockFile: LockFile,
-        accept: ValidationAcceptor,
-        imp: ImportStatement
-    ): Promise<void> {
-        // Source is guaranteed to exist when this method is called (see caller)
-        const packageKey = dependency.source ?? alias;
-        const lockedDep = lockFile.dependencies[packageKey];
-
-        if (!lockedDep) {
-            accept('error', ValidationMessages.IMPORT_NOT_INSTALLED(alias), {
-                node: imp,
-                property: 'uri',
-                codeDescription: buildCodeDescription('language.md', 'imports'),
-                data: { code: IssueCodes.ImportNotInstalled, alias }
-            });
+    checkUnusedImports(
+        imp: ImportStatement,
+        _accept: ValidationAcceptor,
+        _model: Model
+    ): void {
+        // Skip check for wildcard imports (no named imports)
+        if (!imp.symbols || imp.symbols.length === 0) {
             return;
         }
 
-        const workspaceRoot = this.workspaceManager.getWorkspaceRoot();
-        const cacheDir = this.getCacheDirectory(workspaceRoot, packageKey, lockedDep.commit);
-
-        const cacheExists = await this.directoryExists(cacheDir);
-        if (!cacheExists) {
-            accept('error', ValidationMessages.IMPORT_NOT_INSTALLED(alias), {
-                node: imp,
-                property: 'uri',
-                codeDescription: buildCodeDescription('language.md', 'imports'),
-                data: { code: IssueCodes.ImportNotInstalled, alias }
-            });
-        }
-    }
-
-    /**
-     * Gets the cache directory for a dependency.
-     * Per PRS-010: Project-local cache at .dlang/packages/{owner}/{repo}/{commit}/
-     */
-    private getCacheDirectory(workspaceRoot: string, source: string, commitHash: string): string {
-        const [owner, repo] = source.split('/');
-        return path.join(workspaceRoot, '.dlang', 'packages', owner, repo, commitHash);
-    }
-
-    /**
-     * Checks if a directory exists (async).
-     */
-    private async directoryExists(dirPath: string): Promise<boolean> {
-        try {
-            const stat = await fs.stat(dirPath);
-            return stat.isDirectory();
-        } catch {
-            return false;
-        }
+        // For now, just a placeholder - would require tracking symbol usage
+        // across the entire document, which is complex
+        // TODO: Implement symbol usage tracking
     }
 }
 
 /**
  * Creates validation checks for import statements.
- *
- * Returns async validators that leverage the shared WorkspaceManager
- * for cached manifest/lock file reading.
  */
-export function createImportChecks(services: DomainLangServices): ValidationChecks<DomainLangAstType> {
-    const validator = new ImportValidator(services);
+export function createImportChecks(_services: DomainLangServices): ValidationChecks<DomainLangAstType> {
 
     return {
-        // Langium 4.x supports async validators via MaybePromise<void>
-        ImportStatement: async (imp, accept, cancelToken) => {
+        ImportStatement: (imp, accept) => {
             const document = imp.$document;
             if (!document) return;
 
-            await validator.checkImportPath(imp, accept, document, cancelToken);
+            // Note: Langium's validation is synchronous, so async checks won't
+            // execute during document validation. These checks will run during
+            // the build phase when documents are fully loaded.
+            
+            // For now, just do basic syntax validation
+            if (!imp.uri) {
+                accept('error', 'Import statement must have a URI', { 
+                    node: imp,
+                    keyword: 'import'
+                });
+            }
+
+            // TODO: Implement async validation in a separate build phase
+            // This would require using DocumentBuilder.onBuildPhase() or similar
         }
     };
 }

package/src/validation/maps.ts

@@ -1,6 +1,5 @@
 import type { ValidationAcceptor } from 'langium';
 import type { ContextMap, DomainMap } from '../generated/ast.js';
-import { ValidationMessages, buildCodeDescription } from './constants.js';
 
 /**
  * Validates that a context map contains at least one bounded context.
@@ -14,10 +13,9 @@ function validateContextMapHasContexts(
     accept: ValidationAcceptor
 ): void {
     if (!map.boundedContexts || map.boundedContexts.length === 0) {
-        accept('warning', ValidationMessages.CONTEXT_MAP_NO_CONTEXTS(map.name), {
+        accept('warning', `Context Map '${map.name}' contains no bounded contexts`, {
             node: map,
-            keyword: 'contains',
-            codeDescription: buildCodeDescription('language.md', 'context-maps')
+            keyword: 'contains'
         });
     }
 }
@@ -38,10 +36,9 @@ function validateContextMapHasRelationships(
     
     // Only warn if multiple contexts exist without relationships
     if (contextCount > 1 && relationshipCount === 0) {
-        accept('info', ValidationMessages.CONTEXT_MAP_NO_RELATIONSHIPS(map.name, contextCount), {
+        accept('info', `Context Map '${map.name}' contains ${contextCount} contexts but no documented relationships`, {
             node: map,
-            keyword: 'ContextMap',
-            codeDescription: buildCodeDescription('language.md', 'context-maps')
+            keyword: 'ContextMap'
         });
     }
 }
@@ -58,10 +55,9 @@ function validateDomainMapHasDomains(
     accept: ValidationAcceptor
 ): void {
     if (!map.domains || map.domains.length === 0) {
-        accept('warning', ValidationMessages.DOMAIN_MAP_NO_DOMAINS(map.name), {
+        accept('warning', `Domain Map '${map.name}' contains no domains`, {
             node: map,
-            keyword: 'contains',
-            codeDescription: buildCodeDescription('language.md', 'domain-maps')
+            keyword: 'contains'
         });
     }
 }

package/src/validation/metadata.ts

@@ -1,6 +1,5 @@
 import type { ValidationChecks } from 'langium';
 import type { Metadata, DomainLangAstType } from '../generated/ast.js';
-import { ValidationMessages, buildCodeDescription } from './constants.js';
 
 /**
  * Validation checks for Metadata elements.
@@ -9,10 +8,7 @@ import { ValidationMessages, buildCodeDescription } from './constants.js';
 export const metadataChecks: ValidationChecks<DomainLangAstType> = {
     Metadata(metadata: Metadata, accept) {
         if (!metadata.name) {
-            accept('error', ValidationMessages.METADATA_MISSING_NAME(), { 
-                node: metadata,
-                codeDescription: buildCodeDescription('language.md', 'metadata')
-            });
+            accept('error', 'Metadata must have a name', { node: metadata });
         }
     },
 };

package/out/lsp/domain-lang-code-actions.d.ts

@@ -1,55 +0,0 @@
-/**
- * Code Action Provider for DomainLang.
- *
- * Provides quick-fix code actions for validation diagnostics.
- *
- * Key Features:
- * - "Add dependency to model.yaml" for unknown import aliases
- * - "Run dlang install" for uninstalled dependencies
- *
- * @module
- */
-import type { CodeAction, CodeActionParams, Command } from 'vscode-languageserver';
-import type { MaybePromise, LangiumDocument } from 'langium';
-import type { CodeActionProvider } from 'langium/lsp';
-/**
- * Code action provider for DomainLang LSP features.
- *
- * Implements quick fixes for:
- * - Import validation errors (add to model.yaml, run install)
- */
-export declare class DomainLangCodeActionProvider implements CodeActionProvider {
-    /**
-     * Generates code actions for the given diagnostics.
-     *
-     * @param document - The document containing the diagnostics
-     * @param params - Code action request parameters including diagnostics
-     * @returns Array of code actions, or undefined if none applicable
-     */
-    getCodeActions(document: LangiumDocument, params: CodeActionParams): MaybePromise<Array<Command | CodeAction> | undefined>;
-    /**
-     * Creates code actions for a specific diagnostic.
-     *
-     * Matches on diagnostic.data.code to determine which quick fix to offer.
-     */
-    private createCodeActions;
-    /**
-     * Creates a code action to add a dependency to model.yaml.
-     *
-     * This generates a WorkspaceEdit that modifies model.yaml to add
-     * the missing dependency with a placeholder version.
-     */
-    private createAddToManifestAction;
-    /**
-     * Creates a code action to create model.yaml with the dependency.
-     */
-    private createCreateManifestAction;
-    /**
-     * Creates a code action to run dlang install.
-     */
-    private createRunInstallAction;
-    /**
-     * Creates a code action to add ref to dependency.
-     */
-    private createAddRefAction;
-}

package/out/lsp/domain-lang-code-actions.js

@@ -1,143 +0,0 @@
-/**
- * Code Action Provider for DomainLang.
- *
- * Provides quick-fix code actions for validation diagnostics.
- *
- * Key Features:
- * - "Add dependency to model.yaml" for unknown import aliases
- * - "Run dlang install" for uninstalled dependencies
- *
- * @module
- */
-import { CodeActionKind } from 'vscode-languageserver';
-import { IssueCodes } from '../validation/constants.js';
-/**
- * Code action provider for DomainLang LSP features.
- *
- * Implements quick fixes for:
- * - Import validation errors (add to model.yaml, run install)
- */
-export class DomainLangCodeActionProvider {
-    /**
-     * Generates code actions for the given diagnostics.
-     *
-     * @param document - The document containing the diagnostics
-     * @param params - Code action request parameters including diagnostics
-     * @returns Array of code actions, or undefined if none applicable
-     */
-    getCodeActions(document, params) {
-        const result = [];
-        const acceptor = (ca) => {
-            if (ca)
-                result.push(ca);
-        };
-        for (const diagnostic of params.context.diagnostics) {
-            this.createCodeActions(diagnostic, document, acceptor);
-        }
-        return result.length > 0 ? result : undefined;
-    }
-    /**
-     * Creates code actions for a specific diagnostic.
-     *
-     * Matches on diagnostic.data.code to determine which quick fix to offer.
-     */
-    createCodeActions(diagnostic, document, accept) {
-        const data = diagnostic.data;
-        if (!data?.code)
-            return;
-        switch (data.code) {
-            case IssueCodes.ImportNotInManifest:
-                if (data.alias) {
-                    accept(this.createAddToManifestAction(diagnostic, document, data.alias));
-                }
-                break;
-            case IssueCodes.ImportRequiresManifest:
-                if (data.specifier) {
-                    accept(this.createCreateManifestAction(diagnostic, document, data.specifier));
-                }
-                break;
-            case IssueCodes.ImportNotInstalled:
-                if (data.alias) {
-                    accept(this.createRunInstallAction(diagnostic, data.alias));
-                }
-                break;
-            case IssueCodes.ImportMissingRef:
-                if (data.alias) {
-                    accept(this.createAddRefAction(diagnostic, data.alias));
-                }
-                break;
-        }
-    }
-    /**
-     * Creates a code action to add a dependency to model.yaml.
-     *
-     * This generates a WorkspaceEdit that modifies model.yaml to add
-     * the missing dependency with a placeholder version.
-     */
-    createAddToManifestAction(diagnostic, _document, alias) {
-        // Create a command that will be executed to add the dependency
-        // Since we can't directly edit model.yaml from here (it's not the current document),
-        // we provide a command that the extension can handle
-        return {
-            title: `Add '${alias}' to model.yaml`,
-            kind: CodeActionKind.QuickFix,
-            diagnostics: [diagnostic],
-            isPreferred: true,
-            command: {
-                title: `Add '${alias}' to model.yaml`,
-                command: 'domainlang.addDependency',
-                arguments: [alias]
-            }
-        };
-    }
-    /**
-     * Creates a code action to create model.yaml with the dependency.
-     */
-    createCreateManifestAction(diagnostic, _document, specifier) {
-        const alias = specifier.split('/')[0];
-        return {
-            title: `Create model.yaml with '${alias}' dependency`,
-            kind: CodeActionKind.QuickFix,
-            diagnostics: [diagnostic],
-            isPreferred: true,
-            command: {
-                title: `Create model.yaml`,
-                command: 'domainlang.createManifest',
-                arguments: [alias, specifier]
-            }
-        };
-    }
-    /**
-     * Creates a code action to run dlang install.
-     */
-    createRunInstallAction(diagnostic, alias) {
-        return {
-            title: `Run 'dlang install' to fetch '${alias}'`,
-            kind: CodeActionKind.QuickFix,
-            diagnostics: [diagnostic],
-            isPreferred: true,
-            command: {
-                title: 'Install dependencies',
-                command: 'domainlang.install',
-                arguments: []
-            }
-        };
-    }
-    /**
-     * Creates a code action to add ref to dependency.
-     */
-    createAddRefAction(diagnostic, alias) {
-        return {
-            title: `Add git ref to '${alias}' in model.yaml`,
-            kind: CodeActionKind.QuickFix,
-            diagnostics: [diagnostic],
-            isPreferred: false,
-            command: {
-                title: 'Add ref',
-                command: 'domainlang.addRef',
-                arguments: [alias]
-            }
-        };
-    }
-}
-//# sourceMappingURL=domain-lang-code-actions.js.map

package/out/lsp/domain-lang-code-actions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"domain-lang-code-actions.js","sourceRoot":"","sources":["../../src/lsp/domain-lang-code-actions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAGvD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAaxD;;;;;GAKG;AACH,MAAM,OAAO,4BAA4B;IAErC;;;;;;OAMG;IACH,cAAc,CACV,QAAyB,EACzB,MAAwB;QAExB,MAAM,MAAM,GAAiB,EAAE,CAAC;QAChC,MAAM,QAAQ,GAAG,CAAC,EAA0B,EAAQ,EAAE;YAClD,IAAI,EAAE;gBAAE,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC5B,CAAC,CAAC;QAEF,KAAK,MAAM,UAAU,IAAI,MAAM,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;YAClD,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC3D,CAAC;QAED,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACK,iBAAiB,CACrB,UAAsB,EACtB,QAAyB,EACzB,MAA4C;QAE5C,MAAM,IAAI,GAAG,UAAU,CAAC,IAAwC,CAAC;QACjE,IAAI,CAAC,IAAI,EAAE,IAAI;YAAE,OAAO;QAExB,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;YAChB,KAAK,UAAU,CAAC,mBAAmB;gBAC/B,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;oBACb,MAAM,CAAC,IAAI,CAAC,yBAAyB,CAAC,UAAU,EAAE,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;gBAC7E,CAAC;gBACD,MAAM;YAEV,KAAK,UAAU,CAAC,sBAAsB;gBAClC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;oBACjB,MAAM,CAAC,IAAI,CAAC,0BAA0B,CAAC,UAAU,EAAE,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;gBAClF,CAAC;gBACD,MAAM;YAEV,KAAK,UAAU,CAAC,kBAAkB;gBAC9B,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;oBACb,MAAM,CAAC,IAAI,CAAC,sBAAsB,CAAC,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;gBAChE,CAAC;gBACD,MAAM;YAEV,KAAK,UAAU,CAAC,gBAAgB;gBAC5B,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;oBACb,MAAM,CAAC,IAAI,CAAC,kBAAkB,CAAC,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;gBAC5D,CAAC;gBACD,MAAM;QACd,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACK,yBAAyB,CAC7B,UAAsB,EACtB,SAA0B,EAC1B,KAAa;QAEb,+DAA+D;QAC/D,qFAAqF;QACrF,qDAAqD;QACrD,OAAO;YACH,KAAK,EAAE,QAAQ,KAAK,iBAAiB;YACrC,IAAI,EAAE,cAAc,CAAC,QAAQ;YAC7B,WAAW,EAAE,CAAC,UAAU,CAAC;YACzB,WAAW,EAAE,IAAI;YACjB,OAAO,EAAE;gBACL,KAAK,EAAE,QAAQ,KAAK,iBAAiB;gBACrC,OAAO,EAAE,0BAA0B;gBACnC,SAAS,EAAE,CAAC,KAAK,CAAC;aACrB;SACJ,CAAC;IACN,CAAC;IAED;;OAEG;IACK,0BAA0B,CAC9B,UAAsB,EACtB,SAA0B,EAC1B,SAAiB;QAEjB,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;QACtC,OAAO;YACH,KAAK,EAAE,2BAA2B,KAAK,cAAc;YACrD,IAAI,EAAE,cAAc,CAAC,QAAQ;YAC7B,WAAW,EAAE,CAAC,UAAU,CAAC;YACzB,WAAW,EAAE,IAAI;YACjB,OAAO,EAAE;gBACL,KAAK,EAAE,mBAAmB;gBAC1B,OAAO,EAAE,2BAA2B;gBACpC,SAAS,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC;aAChC;SACJ,CAAC;IACN,CAAC;IAED;;OAEG;IACK,sBAAsB,CAC1B,UAAsB,EACtB,KAAa;QAEb,OAAO;YACH,KAAK,EAAE,iCAAiC,KAAK,GAAG;YAChD,IAAI,EAAE,cAAc,CAAC,QAAQ;YAC7B,WAAW,EAAE,CAAC,UAAU,CAAC;YACzB,WAAW,EAAE,IAAI;YACjB,OAAO,EAAE;gBACL,KAAK,EAAE,sBAAsB;gBAC7B,OAAO,EAAE,oBAAoB;gBAC7B,SAAS,EAAE,EAAE;aAChB;SACJ,CAAC;IACN,CAAC;IAED;;OAEG;IACK,kBAAkB,CACtB,UAAsB,EACtB,KAAa;QAEb,OAAO;YACH,KAAK,EAAE,mBAAmB,KAAK,iBAAiB;YAChD,IAAI,EAAE,cAAc,CAAC,QAAQ;YAC7B,WAAW,EAAE,CAAC,UAAU,CAAC;YACzB,WAAW,EAAE,KAAK;YAClB,OAAO,EAAE;gBACL,KAAK,EAAE,SAAS;gBAChB,OAAO,EAAE,mBAAmB;gBAC5B,SAAS,EAAE,CAAC,KAAK,CAAC;aACrB;SACJ,CAAC;IACN,CAAC;CACJ"}