@likec4/language-server 0.57.1 → 0.60.0

package/dist/model/model-builder.js

@@ -4,7 +4,7 @@ import {
   parentFqn
 } from "@likec4/core";
 import { computeView, LikeC4ModelGraph } from "@likec4/graph";
-import { DocumentState } from "langium";
+import { DocumentState, interruptAndCheck } from "langium";
 import * as R from "remeda";
 import { Disposable } from "vscode-languageserver";
 import { isParsedLikeC4LangiumDocument } from "../ast.js";
@@ -36,6 +36,7 @@ function buildModel(services, docs) {
             ...parsed
           };
         }
+        logger.warn(`No kind '${parsed.kind}' found for ${parsed.id}`);
       } catch (e) {
         logWarnError(e);
       }
@@ -63,34 +64,38 @@ function buildModel(services, docs) {
       {}
     )
   );
-  const toModelRelation = ({
-    astPath,
-    source,
-    target,
-    kind,
-    ...model
-  }) => {
-    if (source in elements && target in elements) {
-      if (!!kind && kind in c4Specification.relationships) {
+  const toModelRelation = (doc) => {
+    return ({
+      astPath,
+      source,
+      target,
+      kind,
+      links,
+      ...model
+    }) => {
+      if (source in elements && target in elements) {
+        if (!!kind && kind in c4Specification.relationships) {
+          return {
+            source,
+            target,
+            kind,
+            ...links && { links: resolveLinks(doc, links) },
+            ...c4Specification.relationships[kind],
+            ...model
+          };
+        }
         return {
           source,
           target,
-          kind,
-          ...c4Specification.relationships[kind],
+          ...links && { links: resolveLinks(doc, links) },
           ...model
         };
       }
-      return {
-        source,
-        target,
-        ...model
-      };
-    }
-    return null;
+      return null;
+    };
   };
   const relations = R.pipe(
-    R.flatMap(docs, (d) => d.c4Relations),
-    R.map(toModelRelation),
+    R.flatMap(docs, (d) => R.map(d.c4Relations, toModelRelation(d))),
     R.compact,
     R.mapToObj((r) => [r.id, r])
   );
@@ -160,9 +165,14 @@ export class LikeC4ModelBuilder {
     services.shared.workspace.DocumentBuilder.onBuildPhase(
       DocumentState.Validated,
       async (docs, _cancelToken) => {
-        logger.debug(`[ModelBuilder] onValidated (${docs.length} docs)
+        let parsed = [];
+        try {
+          logger.debug(`[ModelBuilder] onValidated (${docs.length} docs)
 ${printDocs(docs)}`);
-        const parsed = parser.parse(docs).map((d) => d.uri);
+          parsed.push(...parser.parse(docs).map((d) => d.uri));
+        } catch (e) {
+          logger.error(e);
+        }
         if (parsed.length > 0) {
           this.notifyListeners(parsed);
         }
@@ -173,10 +183,13 @@ ${printDocs(docs)}`);
   }
   langiumDocuments;
   listeners = [];
-  buildRawModel() {
-    const cache = this.services.WorkspaceCache;
-    return cache.get(RAW_MODEL_CACHE, () => {
-      try {
+  async buildRawModel(cancelToken) {
+    return await this.services.shared.workspace.WorkspaceLock.read(async () => {
+      if (cancelToken) {
+        await interruptAndCheck(cancelToken);
+      }
+      const cache = this.services.WorkspaceCache;
+      return cache.get(RAW_MODEL_CACHE, () => {
         const docs = this.documents();
         if (docs.length === 0) {
           logger.debug("[ModelBuilder] No documents to build model from");
@@ -185,21 +198,18 @@ ${printDocs(docs)}`);
         logger.debug(`[ModelBuilder] buildModel from ${docs.length} docs:
 ${printDocs(docs)}`);
         return buildModel(this.services, docs);
-      } catch (e) {
-        logError(e);
-        return null;
-      }
+      });
     });
   }
   previousViews = {};
-  buildModel() {
+  async buildModel(cancelToken) {
+    const model = await this.buildRawModel(cancelToken);
+    if (!model) {
+      return null;
+    }
     const cache = this.services.WorkspaceCache;
     const viewsCache = this.services.WorkspaceCache;
     return cache.get(MODEL_CACHE, () => {
-      const model = this.buildRawModel();
-      if (!model) {
-        return null;
-      }
       const index = new LikeC4ModelGraph(model);
       const allViews = [];
       for (const view of R.values(model.views)) {
@@ -225,15 +235,15 @@ ${printDocs(docs)}`);
       };
     });
   }
-  computeView(viewId) {
+  async computeView(viewId, cancelToken) {
+    const model = await this.buildRawModel(cancelToken);
+    const view = model?.views[viewId];
+    if (!view) {
+      logger.warn(`[ModelBuilder] Cannot find view ${viewId}`);
+      return null;
+    }
     const cache = this.services.WorkspaceCache;
     return cache.get(computedViewKey(viewId), () => {
-      const model = this.buildRawModel();
-      const view = model?.views[viewId];
-      if (!view) {
-        logger.warn(`[ModelBuilder] Cannot find view ${viewId}`);
-        return null;
-      }
       const index = new LikeC4ModelGraph(model);
       const result = computeView(view, index);
       if (!result.isSuccess) {

package/dist/model/model-locator.js

@@ -1,5 +1,7 @@
-import { findNodeForKeyword, findNodeForProperty, getDocument } from "langium";
+import { AstUtils, GrammarUtils } from "langium";
 import { ast, isParsedLikeC4LangiumDocument } from "../ast.js";
+const { findNodeForKeyword, findNodeForProperty } = GrammarUtils;
+const { getDocument } = AstUtils;
 export class LikeC4ModelLocator {
   constructor(services) {
     this.services = services;

package/dist/model/model-parser.js

@@ -1,5 +1,5 @@
 import { InvalidModelError, invariant, isNonEmptyArray, nonexhaustive } from "@likec4/core";
-import { getDocument } from "langium";
+import { AstUtils } from "langium";
 import objectHash from "object-hash";
 import { isTruthy } from "remeda";
 import stripIndent from "strip-indent";
@@ -18,6 +18,7 @@ import {
 } from "../ast.js";
 import { elementRef, getFqnElementRef } from "../elementRef.js";
 import { logError, logger, logWarnError } from "../logger.js";
+const { getDocument } = AstUtils;
 function toSingleLine(str) {
   return str ? removeIndent(str).split("\n").join(" ") : void 0;
 }
@@ -111,7 +112,7 @@ export class LikeC4ModelParser {
     const stylePropsAst = astNode.body?.props.find(ast.isStyleProperties)?.props;
     const styleProps = toElementStyleExcludeDefaults(stylePropsAst);
     const astPath = this.getAstNodePath(astNode);
-    let [title, description, technology] = astNode.props;
+    let [title, description, technology] = astNode.props ?? [];
     const bodyProps = astNode.body?.props.filter(ast.isElementStringProperty) ?? [];
     title = toSingleLine(title ?? bodyProps.find((p) => p.key === "title")?.value);
     description = removeIndent(description ?? bodyProps.find((p) => p.key === "description")?.value);
@@ -134,6 +135,7 @@ export class LikeC4ModelParser {
     const target = this.resolveFqn(coupling.target);
     const source = this.resolveFqn(coupling.source);
     const tags = this.convertTags(astNode) ?? this.convertTags(astNode.body);
+    const links = astNode.body?.props.filter(ast.isLinkProperty).map((p) => p.value);
     const kind = astNode.kind?.ref?.name;
     const astPath = this.getAstNodePath(astNode);
     const title = toSingleLine(
@@ -153,6 +155,7 @@ export class LikeC4ModelParser {
       title,
       ...kind && { kind },
       ...tags && { tags },
+      ...isNonEmptyArray(links) && { links },
       ...toRelationshipStyleExcludeDefaults(styleProp?.props)
     };
   }
@@ -372,6 +375,6 @@ export class LikeC4ModelParser {
       return null;
     }
     const tags = withTags.tags?.value.flatMap(({ ref }) => ref ? ref.name : []);
-    return tags && isNonEmptyArray(tags) ? tags : null;
+    return isNonEmptyArray(tags) ? tags : null;
   }
 }

package/dist/module.d.ts

@@ -1,4 +1,5 @@
-import { type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type Module, type PartialLangiumServices, WorkspaceCache } from 'langium';
+import { type Module, WorkspaceCache } from 'langium';
+import { type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices } from 'langium/lsp';
 import { LikeC4CodeLensProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
 import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
 import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';

package/dist/module.js

@@ -1,11 +1,9 @@
 import { normalizeError } from "@likec4/core";
+import { EmptyFileSystem, inject, WorkspaceCache } from "langium";
 import {
   createDefaultModule,
-  createDefaultSharedModule,
-  EmptyFileSystem,
-  inject,
-  WorkspaceCache
-} from "langium";
+  createDefaultSharedModule
+} from "langium/lsp";
 import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from "./generated/module.js";
 import { logger } from "./logger.js";
 import {

package/dist/node/index.js

@@ -1,4 +1,4 @@
-import { startLanguageServer as startLanguim } from "langium";
+import { startLanguageServer as startLanguim } from "langium/lsp";
 import { NodeFileSystem } from "langium/node";
 import { createConnection, ProposedFeatures } from "vscode-languageserver/node";
 import { createLanguageServices } from "../module.js";

package/dist/references/scope-provider.js

@@ -1,17 +1,20 @@
 import {
-  DONE_RESULT,
+  AstUtils,
+  CstUtils,
   DefaultScopeProvider,
+  DONE_RESULT,
   EMPTY_STREAM,
-  StreamImpl,
-  StreamScope,
-  findNodeForProperty,
-  getDocument,
+  GrammarUtils,
   stream,
-  toDocumentSegment
+  StreamImpl,
+  StreamScope
 } from "langium";
 import { ast } from "../ast.js";
 import { elementRef, getFqnElementRef } from "../elementRef.js";
 import { logError } from "../logger.js";
+const { findNodeForProperty } = GrammarUtils;
+const { toDocumentSegment } = CstUtils;
+const { getDocument } = AstUtils;
 function toAstNodeDescription(entry) {
   const $cstNode = findNodeForProperty(entry.el.$cstNode, "name");
   return {

package/dist/shared/NodeKindProvider.d.ts

@@ -1,6 +1,7 @@
-import { type AstNode, type AstNodeDescription, type LangiumSharedServices } from 'langium';
+import { type AstNode, type AstNodeDescription } from 'langium';
+import type { LangiumSharedServices, NodeKindProvider as LspNodeKindProvider } from 'langium/lsp';
 import { CompletionItemKind, SymbolKind } from 'vscode-languageserver-protocol';
-export declare class NodeKindProvider implements NodeKindProvider {
+export declare class NodeKindProvider implements LspNodeKindProvider {
     private services;
     constructor(services: LangiumSharedServices);
     /**

package/dist/shared/WorkspaceSymbolProvider.d.ts

@@ -1,4 +1,4 @@
-import { DefaultWorkspaceSymbolProvider } from 'langium';
+import { DefaultWorkspaceSymbolProvider } from 'langium/lsp';
 export declare class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {
 }
 //# sourceMappingURL=WorkspaceSymbolProvider.d.ts.map

package/dist/shared/WorkspaceSymbolProvider.js

@@ -1,3 +1,3 @@
-import { DefaultWorkspaceSymbolProvider } from "langium";
+import { DefaultWorkspaceSymbolProvider } from "langium/lsp";
 export class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {
 }

package/dist/test/testServices.d.ts

@@ -15,6 +15,7 @@ export declare function createTestServices(workspace?: string): {
         warnings: string[];
     }>;
     buildModel: () => Promise<import("@likec4/core").LikeC4Model>;
+    resetState: () => Promise<void>;
 };
 export type TestServices = ReturnType<typeof createTestServices>;
 export type TestParseFn = TestServices['validate'];

package/dist/test/testServices.js

@@ -1,4 +1,4 @@
-import { EmptyFileSystem } from "langium";
+import { DocumentState, EmptyFileSystem } from "langium";
 import * as assert from "node:assert";
 import stripIndent from "strip-indent";
 import { DiagnosticSeverity } from "vscode-languageserver-protocol";
@@ -19,10 +19,15 @@ export function createTestServices(workspace = "file:///test/workspace") {
   let documentIndex = 1;
   const parse = async (input, uri) => {
     if (!isInitialized) {
-      isInitialized = true;
-      await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder]);
-      Object.assign(services.shared.workspace.WorkspaceManager, {
-        folders: [workspaceFolder]
+      await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
+        if (isInitialized) {
+          return;
+        }
+        isInitialized = true;
+        await services.shared.workspace.WorkspaceManager.initializeWorkspace([workspaceFolder]);
+        Object.assign(services.shared.workspace.WorkspaceManager, {
+          folders: [workspaceFolder]
+        });
       });
     }
     const docUri = Utils.resolvePath(
@@ -35,12 +40,16 @@ export function createTestServices(workspace = "file:///test/workspace") {
       docUri
     );
     langiumDocuments.addDocument(document);
-    await documentBuilder.build([document], { validation: false });
+    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
+      await documentBuilder.build([document], { validation: false });
+    });
     return document;
   };
   const validate = async (input, uri) => {
     const document = typeof input === "string" ? await parse(input, uri) : input;
-    await documentBuilder.build([document], { validation: true });
+    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
+      await documentBuilder.build([document], { validation: true });
+    });
     const diagnostics = document.diagnostics ?? [];
     const warnings = diagnostics.flatMap((d) => d.severity === DiagnosticSeverity.Warning ? d.message : []);
     const errors = diagnostics.flatMap((d) => d.severity === DiagnosticSeverity.Error ? d.message : []);
@@ -53,41 +62,41 @@ export function createTestServices(workspace = "file:///test/workspace") {
   };
   let previousPromise = Promise.resolve();
   const validateAll = async () => {
-    const currentPromise = previousPromise.then(async () => {
-      const docs = langiumDocuments.all.toArray();
-      assert.ok(docs.length > 0, "no documents to validate");
-      await documentBuilder.build(docs, { validation: true });
-      const diagnostics = docs.flatMap((doc) => doc.diagnostics ?? []);
-      const warnings = diagnostics.flatMap((d) => d.severity === DiagnosticSeverity.Warning ? d.message : []);
-      const errors = diagnostics.flatMap((d) => d.severity === DiagnosticSeverity.Error ? d.message : []);
-      return {
-        diagnostics,
-        errors,
-        warnings
-      };
-    }).catch((e) => {
-      console.error(e);
-      return Promise.resolve({
-        diagnostics: [],
-        errors: [],
-        warnings: []
-      });
+    await services.shared.workspace.WorkspaceLock.write(async (_cancelToken) => {
+      const docs2 = langiumDocuments.all.toArray();
+      await documentBuilder.build(docs2, { validation: true });
     });
-    previousPromise = currentPromise;
-    return await currentPromise;
+    await documentBuilder.waitUntil(DocumentState.Validated);
+    const docs = langiumDocuments.all.toArray();
+    assert.ok(docs.length > 0, "no documents to validate");
+    const diagnostics = docs.flatMap((doc) => doc.diagnostics ?? []);
+    const warnings = diagnostics.flatMap((d) => d.severity === DiagnosticSeverity.Warning ? d.message : []);
+    const errors = diagnostics.flatMap((d) => d.severity === DiagnosticSeverity.Error ? d.message : []);
+    return {
+      diagnostics,
+      errors,
+      warnings
+    };
   };
   const buildModel = async () => {
     await validateAll();
-    const model = modelBuilder.buildModel();
+    const model = await modelBuilder.buildModel();
     if (!model)
       throw new Error("No model found");
     return model;
   };
+  const resetState = async () => {
+    await services.shared.workspace.WorkspaceLock.write(async (cancelToken) => {
+      const docs = langiumDocuments.all.toArray().map((doc) => doc.uri);
+      await documentBuilder.update([], docs, cancelToken);
+    });
+  };
   return {
     services,
     parse,
     validate,
     validateAll,
-    buildModel
+    buildModel,
+    resetState
   };
 }

package/dist/validation/element.js

@@ -1,4 +1,5 @@
-import { getDocument } from "langium";
+import { AstUtils } from "langium";
+const { getDocument } = AstUtils;
 export const elementChecks = (services) => {
   const fqnIndex = services.likec4.FqnIndex;
   return (el, accept) => {
@@ -12,21 +13,24 @@ export const elementChecks = (services) => {
     }
     const withSameFqn = fqnIndex.byFqn(fqn).filter((v) => v.el !== el).head();
     if (withSameFqn) {
+      const isAnotherDoc = withSameFqn.doc.uri !== getDocument(el).uri;
       accept(
         "error",
         `Duplicate element name ${el.name !== fqn ? el.name + " (" + fqn + ")" : el.name}`,
         {
           node: el,
           property: "name",
-          relatedInformation: [
-            {
-              location: {
-                range: withSameFqn.el.$cstNode.range,
-                uri: getDocument(withSameFqn.el).uri.toString()
-              },
-              message: `Already defined here`
-            }
-          ]
+          ...isAnotherDoc && {
+            relatedInformation: [
+              {
+                location: {
+                  range: withSameFqn.el.$cstNode.range,
+                  uri: withSameFqn.doc.uri.toString()
+                },
+                message: `conflicting element`
+              }
+            ]
+          }
         }
       );
     }

package/dist/validation/index.js

@@ -10,35 +10,29 @@ import {
   tagChecks
 } from "./specification.js";
 import { viewChecks } from "./view.js";
-import {
-  customElementExprChecks,
-  incomingExpressionChecks,
-  outgoingExpressionChecks
-} from "./view-predicates/index.js";
+import { customElementExprChecks, incomingExpressionChecks, outgoingExpressionChecks } from "./view-predicates/index.js";
 export function registerValidationChecks(services) {
   logger.info("registerValidationChecks");
   const registry = services.validation.ValidationRegistry;
-  registry.register(
-    {
-      SpecificationRule: specificationRuleChecks(services),
-      Model: modelRuleChecks(services),
-      ModelViews: modelViewsChecks(services),
-      ElementView: viewChecks(services),
-      Element: elementChecks(services),
-      ElementKind: elementKindChecks(services),
-      Relation: relationChecks(services),
-      Tag: tagChecks(services),
-      CustomElementExpr: customElementExprChecks(services),
-      RelationshipKind: relationshipChecks(services),
-      IncomingExpr: incomingExpressionChecks(services),
-      OutgoingExpr: outgoingExpressionChecks(services)
-    },
-    "slow"
-  );
+  registry.register({
+    SpecificationRule: specificationRuleChecks(services),
+    Model: modelRuleChecks(services),
+    ModelViews: modelViewsChecks(services),
+    ElementView: viewChecks(services),
+    Element: elementChecks(services),
+    ElementKind: elementKindChecks(services),
+    Relation: relationChecks(services),
+    Tag: tagChecks(services),
+    CustomElementExpr: customElementExprChecks(services),
+    RelationshipKind: relationshipChecks(services),
+    IncomingExpr: incomingExpressionChecks(services),
+    OutgoingExpr: outgoingExpressionChecks(services)
+  });
   const connection = services.shared.lsp.Connection;
   if (connection) {
     services.shared.workspace.DocumentBuilder.onUpdate((_, deleted) => {
       for (const uri of deleted) {
+        logger.debug(`clear diagnostics for deleted ${uri.path}`);
         void connection.sendDiagnostics({
           uri: uri.toString(),
           diagnostics: []

package/dist/validation/specification.d.ts

@@ -1,4 +1,4 @@
-import type { ValidationCheck } from 'langium';
+import { type ValidationCheck } from 'langium';
 import { ast } from '../ast';
 import type { LikeC4Services } from '../module';
 export declare const specificationRuleChecks: (_: LikeC4Services) => ValidationCheck<ast.SpecificationRule>;

package/dist/validation/specification.js

@@ -1,3 +1,4 @@
+import { AstUtils } from "langium";
 import { ast } from "../ast.js";
 export const specificationRuleChecks = (_) => {
   return (node, accept) => {
@@ -32,11 +33,23 @@ export const modelViewsChecks = (_) => {
 export const elementKindChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
   return (node, accept) => {
-    const sameKinds = index.allElements(ast.ElementKind).filter((n) => n.name === node.name).limit(2).count();
-    if (sameKinds > 1) {
+    const sameKind = index.allElements(ast.ElementKind).filter((n) => n.name === node.name && n.node !== node).head();
+    if (sameKind) {
+      const isAnotherDoc = sameKind.documentUri !== AstUtils.getDocument(node).uri;
       accept("error", `Duplicate element kind '${node.name}'`, {
         node,
-        property: "name"
+        property: "name",
+        ...isAnotherDoc && {
+          relatedInformation: [
+            {
+              location: {
+                range: sameKind.nameSegment.range,
+                uri: sameKind.documentUri.toString()
+              },
+              message: `conflicting definition`
+            }
+          ]
+        }
       });
     }
   };
@@ -45,12 +58,28 @@ export const tagChecks = (services) => {
   const index = services.shared.workspace.IndexManager;
   return (node, accept) => {
     const tagname = "#" + node.name;
-    const sameKinds = index.allElements(ast.Tag).filter((n) => n.name === tagname).limit(2).count();
-    if (sameKinds > 1) {
-      accept("error", `Duplicate tag '${node.name}'`, {
-        node,
-        property: "name"
-      });
+    const sameTag = index.allElements(ast.Tag).filter((n) => n.name === tagname && n.node !== node).head();
+    if (sameTag) {
+      const isAnotherDoc = sameTag.documentUri !== AstUtils.getDocument(node).uri;
+      accept(
+        "error",
+        `Duplicate tag '${node.name}'`,
+        {
+          node,
+          property: "name",
+          ...isAnotherDoc && {
+            relatedInformation: [
+              {
+                location: {
+                  range: sameTag.nameSegment.range,
+                  uri: sameTag.documentUri.toString()
+                },
+                message: `conflicting definition`
+              }
+            ]
+          }
+        }
+      );
     }
   };
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "0.57.1",
+  "version": "0.60.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -66,32 +66,32 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@likec4/core": "0.57.1",
-    "@likec4/graph": "0.57.1",
+    "@likec4/core": "0.60.0",
+    "@likec4/graph": "0.60.0",
     "debounce-fn": "^6.0.0",
-    "langium": "^2.1.3",
+    "langium": "^3.0.0",
     "object-hash": "^3.0.0",
     "p-debounce": "^4.0.0",
     "rambdax": "^9.1.1",
     "remeda": "^1.40.1",
     "strip-indent": "^4.0.0",
-    "type-fest": "^4.10.2",
+    "type-fest": "^4.10.3",
     "ufo": "^1.3.2",
     "vscode-languageserver": "9.0.1",
     "vscode-languageserver-protocol": "3.17.5",
     "vscode-uri": "3.0.8"
   },
   "devDependencies": {
-    "@types/node": "^20.11.17",
+    "@types/node": "^20.11.19",
     "@types/object-hash": "^3.0.6",
     "execa": "^8.0.1",
-    "langium-cli": "^2.1.0",
+    "langium-cli": "^3.0.1",
     "npm-run-all2": "^5.0.2",
     "typescript": "^5.3.3",
     "unbuild": "^2.0.0",
-    "vitest": "^1.2.2"
+    "vitest": "^1.3.1"
   },
-  "packageManager": "yarn@4.1.0",
+  "packageManager": "yarn@4.1.1",
   "volta": {
     "extends": "../../package.json"
   }