@likec4/language-server 1.42.1 → 1.44.0

package/dist/LikeC4LanguageServices.mjs

@@ -1,197 +0,0 @@
-import {
-  nonexhaustive
-} from "@likec4/core";
-import { LikeC4Model } from "@likec4/core/model";
-import { loggable } from "@likec4/log";
-import { URI } from "langium";
-import { entries, hasAtLeast, indexBy, map, pipe, prop } from "remeda";
-import { DiagnosticSeverity } from "vscode-languageserver-types";
-import { isLikeC4LangiumDocument } from "./ast.mjs";
-import { logger as mainLogger, logWarnError } from "./logger.mjs";
-import { ProjectsManager } from "./workspace/index.mjs";
-const logger = mainLogger.getChild("LanguageServices");
-export class DefaultLikeC4LanguageServices {
-  constructor(services) {
-    this.services = services;
-    this.builder = services.likec4.ModelBuilder;
-    this.projectsManager = services.shared.workspace.ProjectsManager;
-  }
-  builder;
-  projectsManager;
-  get views() {
-    return this.services.likec4.Views;
-  }
-  get workspaceUri() {
-    return this.services.shared.workspace.WorkspaceManager.workspaceUri;
-  }
-  projects() {
-    const projectsManager = this.services.shared.workspace.ProjectsManager;
-    const projectsWithDocs = pipe(
-      this.services.shared.workspace.LangiumDocuments.groupedByProject(),
-      entries(),
-      map(([projectId, docs]) => {
-        const id = projectId;
-        const { folderUri: folderUri2, config: config2 } = projectsManager.getProject(id);
-        return {
-          id,
-          folder: folderUri2,
-          title: config2.title ?? config2.name,
-          documents: map(docs, prop("uri")),
-          config: config2
-        };
-      })
-    );
-    if (hasAtLeast(projectsWithDocs, 2) && projectsManager.defaultProjectId) {
-      const idx = projectsWithDocs.findIndex((p) => p.id === projectsManager.defaultProjectId);
-      if (idx > 0) {
-        const [defaultProject] = projectsWithDocs.splice(idx, 1);
-        return [defaultProject, ...projectsWithDocs];
-      }
-      return projectsWithDocs;
-    }
-    if (hasAtLeast(projectsWithDocs, 1)) {
-      return projectsWithDocs;
-    }
-    const { folderUri, config } = projectsManager.getProject(ProjectsManager.DefaultProjectId);
-    const documents = map(
-      this.services.shared.workspace.LangiumDocuments.projectDocuments(ProjectsManager.DefaultProjectId).toArray(),
-      prop("uri")
-    );
-    return [{
-      id: ProjectsManager.DefaultProjectId,
-      folder: folderUri,
-      title: config.title ?? config.name,
-      documents,
-      config
-    }];
-  }
-  project(projectId) {
-    projectId = this.projectsManager.ensureProjectId(projectId);
-    const projectsManager = this.services.shared.workspace.ProjectsManager;
-    const { folderUri, config } = projectsManager.getProject(projectId);
-    const documents = map(
-      this.services.shared.workspace.LangiumDocuments.projectDocuments(projectId).toArray(),
-      prop("uri")
-    );
-    return {
-      id: projectId,
-      folder: folderUri,
-      title: config.title ?? config.name,
-      documents,
-      config
-    };
-  }
-  /**
-   * Diagram is a computed view, layouted using Graphviz
-   * Used in React components
-   */
-  async diagrams() {
-    return await this.views.diagrams();
-  }
-  /**
-   * Builds LikeC4Model from all documents
-   * Only computes view predicates {@link ComputedView} - i.e. no layout
-   * Not ready for rendering, but enough to traverse
-   */
-  async computedModel(project) {
-    const projectId = this.projectsManager.ensureProjectId(project);
-    return await this.builder.buildLikeC4Model(projectId);
-  }
-  /**
-   * Same as {@link computedModel()}, but also applies layout
-   * Ready for rendering
-   */
-  async layoutedModel(project) {
-    const projectId = this.projectsManager.ensureProjectId(project);
-    const parsed = await this.builder.parseModel(projectId);
-    if (!parsed) {
-      throw new Error("Failed to parse model");
-    }
-    const diagrams = await this.views.diagrams(projectId);
-    return LikeC4Model.create({
-      ...parsed.$data,
-      _stage: "layouted",
-      views: indexBy(diagrams, prop("id"))
-    });
-  }
-  getErrors() {
-    const docs = this.services.shared.workspace.LangiumDocuments.allExcludingBuiltin.toArray();
-    return docs.flatMap((doc) => {
-      return (doc.diagnostics ?? []).filter((d) => d.severity === DiagnosticSeverity.Error).map(({ message, range }) => ({
-        message,
-        line: range.start.line,
-        range,
-        sourceFsPath: doc.uri.fsPath
-      }));
-    });
-  }
-  /**
-   * TODO Replace with watcher
-   */
-  async notifyUpdate({ changed, removed }) {
-    if (!changed && !removed) {
-      return false;
-    }
-    const _changed = changed ? URI.file(changed) : void 0;
-    const _removed = removed ? URI.file(removed) : void 0;
-    const pm = this.services.shared.workspace.ProjectsManager;
-    if (_changed && pm.isConfigFile(_changed) || _removed && pm.isConfigFile(_removed)) {
-      await pm.reloadProjects();
-      return true;
-    }
-    const mutex = this.services.shared.workspace.WorkspaceLock;
-    try {
-      let completed = false;
-      await mutex.write(async (token) => {
-        await this.services.shared.workspace.DocumentBuilder.update(
-          _changed ? [_changed] : [],
-          _removed ? [_removed] : [],
-          token
-        );
-        completed = !token.isCancellationRequested;
-      });
-      return completed;
-    } catch (e) {
-      logger.error(loggable(e));
-      return false;
-    }
-  }
-  locate(params) {
-    switch (true) {
-      case "element" in params:
-        return this.services.likec4.ModelLocator.locateElement(params.element, params.projectId);
-      case "relation" in params:
-        return this.services.likec4.ModelLocator.locateRelation(params.relation, params.projectId);
-      case "view" in params:
-        return this.services.likec4.ModelLocator.locateView(params.view, params.projectId);
-      case "deployment" in params:
-        return this.services.likec4.ModelLocator.locateDeploymentElement(
-          params.deployment,
-          params.projectId
-        );
-      default:
-        nonexhaustive(params);
-    }
-  }
-  /**
-   * Checks if the specified document should be excluded from processing.
-   */
-  isExcluded(doc) {
-    try {
-      return !isLikeC4LangiumDocument(doc) || this.services.shared.workspace.ProjectsManager.checkIfExcluded(doc);
-    } catch (e) {
-      logWarnError(e);
-      return false;
-    }
-  }
-  async dispose() {
-    logger.debug("disposing LikeC4LanguageServices");
-    await this.services.shared.workspace.FileSystemWatcher.dispose();
-    if (this.services.mcp.Server.isStarted) {
-      await this.services.mcp.Server.stop();
-    }
-    this.services.Rpc.dispose();
-    this.services.likec4.ModelBuilder.dispose();
-    logger.debug("LikeC4LanguageServices disposed");
-  }
-}

package/dist/Rpc.mjs

@@ -1,296 +0,0 @@
-import { filter, flatMap, funnel, indexBy, keys, map, mapValues, pipe, sort } from "remeda";
-import { logger as rootLogger } from "./logger.mjs";
-import { serializableLikeC4ProjectConfig } from "@likec4/config";
-import {
-  invariant,
-  nonexhaustive
-} from "@likec4/core";
-import { LikeC4Model } from "@likec4/core/model";
-import { Disposable, interruptAndCheck, URI, UriUtils } from "langium";
-import { DiagnosticSeverity } from "vscode-languageserver-protocol";
-import {
-  BuildDocuments,
-  ChangeView,
-  ComputeView,
-  DidChangeModelNotification,
-  DidRequestOpenViewNotification,
-  FetchComputedModel,
-  FetchLayoutedModel,
-  FetchProjects,
-  FetchTelemetryMetrics,
-  FetchViewsFromAllProjects,
-  GetDocumentTags,
-  LayoutView,
-  Locate,
-  RegisterProject,
-  ReloadProjects,
-  ValidateLayout
-} from "./protocol.mjs";
-import { ADisposable } from "./utils/index.mjs";
-const logger = rootLogger.getChild("rpc");
-export class Rpc extends ADisposable {
-  constructor(services) {
-    super();
-    this.services = services;
-  }
-  init() {
-    const connection = this.services.shared.lsp.Connection;
-    if (!connection) {
-      logger.info(`[ServerRpc] no connection, not initializing`);
-      return;
-    }
-    logger.info(`[ServerRpc] init`);
-    const likec4Services = this.services.likec4;
-    const projects = this.services.shared.workspace.ProjectsManager;
-    const LangiumDocuments = this.services.shared.workspace.LangiumDocuments;
-    const DocumentBuilder = this.services.shared.workspace.DocumentBuilder;
-    const notifyModelParsed = funnel(
-      () => {
-        logger.debug`sendNotification ${"onDidChangeModel"}`;
-        connection.sendNotification(DidChangeModelNotification.type, "").catch((error) => {
-          logger.warn(`[ServerRpc] error sending onDidChangeModel:`, { error });
-          return;
-        });
-      },
-      {
-        triggerAt: "end",
-        minQuietPeriodMs: 150,
-        maxBurstDurationMs: 500,
-        minGapMs: 300
-      }
-    );
-    let isFirstBuild = true;
-    this.onDispose(
-      likec4Services.ModelBuilder.onModelParsed(() => notifyModelParsed.call()),
-      connection.onRequest(FetchComputedModel.req, async ({ projectId, cleanCaches }, cancelToken) => {
-        logger.debug`received request ${"fetchComputedModel"} for project ${projectId}`;
-        if (cleanCaches) {
-          const docs = projectId ? LangiumDocuments.projectDocuments(projectId) : LangiumDocuments.allExcludingBuiltin;
-          const uris = docs.toArray().map((d) => d.uri);
-          await DocumentBuilder.update(uris, [], cancelToken);
-        }
-        const likec4model = await likec4Services.ModelBuilder.buildLikeC4Model(projectId, cancelToken);
-        if (likec4model !== LikeC4Model.EMPTY) {
-          return { model: likec4model.$model };
-        }
-        return { model: null };
-      }),
-      connection.onRequest(ComputeView.req, async ({ viewId, projectId }, cancelToken) => {
-        const view = await likec4Services.ModelBuilder.computeView(viewId, projectId, cancelToken);
-        return { view };
-      }),
-      connection.onRequest(FetchLayoutedModel.req, async ({ projectId }, cancelToken) => {
-        const model = await likec4Services.ModelBuilder.parseModel(projectId, cancelToken);
-        if (model === null) {
-          return { model: null };
-        }
-        const diagrams = await likec4Services.Views.diagrams(projectId, cancelToken);
-        return {
-          model: {
-            ...model.$data,
-            _stage: "layouted",
-            views: indexBy(diagrams, (d) => d.id)
-          }
-        };
-      }),
-      connection.onRequest(LayoutView.req, async ({ viewId, projectId }, cancelToken) => {
-        logger.debug`received request ${"layoutView"} of ${viewId} from project ${projectId}`;
-        const result = await likec4Services.Views.layoutView(viewId, projectId, cancelToken);
-        return { result };
-      }),
-      connection.onRequest(ValidateLayout.Req, async ({ projectId }, cancelToken) => {
-        const layouts = await likec4Services.Views.layoutAllViews(projectId, cancelToken);
-        const result = reportLayoutDrift(layouts.map((l) => l.diagram));
-        return { result };
-      }),
-      connection.onRequest(FetchProjects.req, async (_cancelToken) => {
-        logger.debug`received request ${"FetchProjects"}`;
-        const docsByProject = LangiumDocuments.groupedByProject();
-        return {
-          projects: mapValues(docsByProject, (docs, projectId) => {
-            const {
-              folderUri,
-              config
-            } = projects.getProject(projectId);
-            return {
-              folder: folderUri.toString(),
-              config: serializableLikeC4ProjectConfig(config),
-              docs: map(docs, (d) => d.uri.toString())
-            };
-          })
-        };
-      }),
-      connection.onRequest(ReloadProjects.req, async () => {
-        logger.debug`received request ${"ReloadProjects"}`;
-        await projects.reloadProjects();
-        return;
-      }),
-      connection.onRequest(RegisterProject.req, async (params) => {
-        logger.debug`received request ${"RegisterProject"}`;
-        const project = await projects.registerProject(params);
-        return { id: project.id };
-      }),
-      connection.onRequest(FetchViewsFromAllProjects.req, async (cancelToken) => {
-        logger.debug`received request ${"FetchViewsFromAllProjects"}`;
-        const promises = projects.all.map(async (projectId) => {
-          const computedViews = await likec4Services.Views.computedViews(projectId, cancelToken);
-          return pipe(
-            computedViews,
-            map((v) => ({
-              id: v.id,
-              title: v.title ?? v.id,
-              projectId
-            })),
-            sort((a, b) => {
-              if (a.id === "index") {
-                return -1;
-              }
-              if (b.id === "index") {
-                return 1;
-              }
-              return a.title.localeCompare(b.title);
-            })
-          );
-        });
-        const results = await Promise.allSettled(promises);
-        await interruptAndCheck(cancelToken);
-        return {
-          views: pipe(
-            results,
-            filter((r) => r.status === "fulfilled"),
-            flatMap((r) => r.value)
-          )
-        };
-      }),
-      connection.onRequest(BuildDocuments.Req, async ({ docs }, cancelToken) => {
-        const changed = docs.map((d) => URI.parse(d));
-        const notChanged = (uri) => changed.every((c) => !UriUtils.equals(c, uri));
-        const deleted = LangiumDocuments.allExcludingBuiltin.toArray().filter((d) => notChanged(d.uri)).map((d) => d.uri);
-        logger.debug(
-          `[ServerRpc] received request to build:
-  changed (total ${changed.length}):${docs.map((d) => "\n    - " + d).join("")}
-  deleted (total ${deleted.length}):${deleted.map((d) => "\n    - " + d.toString()).join("\n")}`
-        );
-        if (!isFirstBuild && changed.length + deleted.length > 0) {
-          await Promise.allSettled(
-            [...changed, ...deleted].map(async (d) => {
-              const uri = d.toString();
-              logger.debug(`clear diagnostics for ${uri}`);
-              try {
-                await connection.sendDiagnostics({
-                  uri,
-                  diagnostics: []
-                });
-              } catch (e) {
-                logger.warn(`error clearing diagnostics for ${uri}: ${e}`);
-              }
-            })
-          );
-        }
-        isFirstBuild = false;
-        await interruptAndCheck(cancelToken);
-        await DocumentBuilder.update(changed, deleted, cancelToken);
-      }),
-      connection.onRequest(Locate.Req, (params) => {
-        switch (true) {
-          case "element" in params:
-            return likec4Services.ModelLocator.locateElement(params.element, params.projectId);
-          case "relation" in params:
-            return likec4Services.ModelLocator.locateRelation(params.relation, params.projectId);
-          case "astPath" in params:
-            return likec4Services.ModelLocator.locateDynamicViewStep({
-              view: params.view,
-              astPath: params.astPath,
-              projectId: params.projectId
-            });
-          case "view" in params:
-            return likec4Services.ModelLocator.locateView(params.view, params.projectId);
-          case "deployment" in params:
-            return likec4Services.ModelLocator.locateDeploymentElement(params.deployment, params.projectId);
-          default:
-            nonexhaustive(params);
-        }
-      }),
-      connection.onRequest(ChangeView.Req, async (request, _cancelToken) => {
-        logger.debug`received request ${"changeView"} of ${request.viewId} from project ${request.projectId}`;
-        return await likec4Services.ModelChanges.applyChange(request);
-      }),
-      connection.onRequest(FetchTelemetryMetrics.req, async (cancelToken) => {
-        const projectsIds = [...projects.all];
-        const promises = projectsIds.map(async (projectId) => {
-          const model = await likec4Services.ModelBuilder.buildLikeC4Model(projectId, cancelToken);
-          if (model === LikeC4Model.EMPTY) {
-            return Promise.reject(new Error(`Model is empty`));
-          }
-          return {
-            elementKinds: keys(model.specification.elements).length,
-            deploymentKinds: keys(model.specification.deployments).length,
-            relationshipKinds: keys(model.specification.relationships).length,
-            tags: keys(model.specification.tags).length,
-            customColors: keys(model.specification.customColors ?? {}).length,
-            elements: keys(model.$data.elements).length,
-            deploymentNodes: [...model.deployment.nodes()].length,
-            relationships: keys(model.$data.relations).length,
-            views: keys(model.$data.views).length,
-            projects: 1
-          };
-        });
-        const results = await Promise.allSettled(promises);
-        await interruptAndCheck(cancelToken);
-        const values = results.filter((r) => r.status === "fulfilled").map((r) => r.value);
-        const metrics = values.length > 0 ? values.reduce((acc, r) => ({
-          elementKinds: acc.elementKinds + r.elementKinds,
-          deploymentKinds: acc.deploymentKinds + r.deploymentKinds,
-          relationshipKinds: acc.relationshipKinds + r.relationshipKinds,
-          tags: acc.tags + r.tags,
-          customColors: acc.customColors + r.customColors,
-          elements: acc.elements + r.elements,
-          deploymentNodes: acc.deploymentNodes + r.deploymentNodes,
-          relationships: acc.relationships + r.relationships,
-          views: acc.views + r.views,
-          projects: acc.projects + 1
-        })) : null;
-        return {
-          metrics
-        };
-      }),
-      connection.onRequest(GetDocumentTags.req, async ({ documentUri }, cancelToken) => {
-        const tags = await likec4Services.ModelLocator.locateDocumentTags(URI.parse(documentUri), cancelToken);
-        return {
-          tags
-        };
-      }),
-      Disposable.create(() => {
-        notifyModelParsed.cancel();
-      })
-    );
-    function reportLayoutDrift(diagrams) {
-      return pipe(
-        diagrams,
-        filter((d) => !!d.hasLayoutDrift),
-        map((d) => {
-          const loc = likec4Services.ModelLocator.locateView(d.id);
-          invariant(loc, `View ${d.id} not found`);
-          return {
-            uri: loc.uri,
-            viewId: d.id,
-            severity: DiagnosticSeverity.Warning,
-            message: `Layout drift detected for view '${d.id}'`,
-            range: loc.range
-          };
-        })
-      );
-    }
-  }
-  async openView(params) {
-    const lspConnection = this.services.shared.lsp.Connection;
-    if (!lspConnection) {
-      logger.warn("No LSP connection");
-      return;
-    }
-    await lspConnection.sendNotification(
-      DidRequestOpenViewNotification.type,
-      params
-    );
-  }
-}

package/dist/ast.mjs

@@ -1,221 +0,0 @@
-import { nonexhaustive } from "@likec4/core/utils";
-import { AstUtils, DocumentState } from "langium";
-import { clamp, isNullish, isTruthy } from "remeda";
-import * as ast from "./generated/ast.mjs";
-import { LikeC4LanguageMetaData } from "./generated/module.mjs";
-export { ast };
-const idattr = Symbol.for("idattr");
-export const ViewOps = {
-  writeId(node, id) {
-    node[idattr] = id;
-    return node;
-  },
-  readId(node) {
-    return node[idattr];
-  }
-};
-export const ElementOps = {
-  writeId(node, id) {
-    if (isNullish(id)) {
-      node[idattr] = void 0;
-    } else {
-      node[idattr] = id;
-    }
-    return node;
-  },
-  readId(node) {
-    return node[idattr];
-  }
-};
-export function isLikeC4LangiumDocument(doc) {
-  return doc.textDocument.languageId === LikeC4LanguageMetaData.languageId;
-}
-export function isParsedLikeC4LangiumDocument(doc) {
-  return isLikeC4LangiumDocument(doc) && doc.state == DocumentState.Validated && !!doc.c4Specification && !!doc.c4Elements && !!doc.c4ExtendElements && !!doc.c4ExtendDeployments && !!doc.c4Relations && !!doc.c4Views && !!doc.c4Deployments && !!doc.c4DeploymentRelations && !!doc.c4Imports;
-}
-export function parseMarkdownAsString(node) {
-  return node?.markdown || node?.text;
-}
-export function parseAstPercent(value) {
-  const opacity = parseFloat(value);
-  return isNaN(opacity) ? 100 : clamp(opacity, { min: 0, max: 100 });
-}
-export function parseAstOpacityProperty({ value }) {
-  return parseAstPercent(value);
-}
-export function parseAstSizeValue({ value }) {
-  switch (value) {
-    case "xs":
-    case "sm":
-    case "md":
-    case "lg":
-    case "xl":
-      return value;
-    case "xsmall":
-      return "xs";
-    case "small":
-      return "sm";
-    case "medium":
-      return "md";
-    case "large":
-      return "lg";
-    case "xlarge":
-      return "xl";
-    default:
-      nonexhaustive(value);
-  }
-}
-export function toRelationshipStyle(props, isValid) {
-  const result = {};
-  if (!props || props.length === 0) {
-    return result;
-  }
-  for (const prop of props) {
-    if (!isValid(prop)) {
-      continue;
-    }
-    switch (true) {
-      case ast.isColorProperty(prop): {
-        const color = toColor(prop);
-        if (isTruthy(color)) {
-          result.color = color;
-        }
-        break;
-      }
-      case ast.isLineProperty(prop): {
-        result.line = prop.value;
-        break;
-      }
-      case ast.isArrowProperty(prop): {
-        switch (prop.key) {
-          case "head": {
-            result.head = prop.value;
-            break;
-          }
-          case "tail": {
-            result.tail = prop.value;
-            break;
-          }
-          default: {
-            nonexhaustive(prop);
-          }
-        }
-        break;
-      }
-      default: {
-        nonexhaustive(prop);
-      }
-    }
-  }
-  return result;
-}
-export function toColor(astNode) {
-  return astNode?.themeColor ?? astNode?.customColor?.$refText;
-}
-export function toAutoLayout(rule) {
-  const rankSep = rule.rankSep;
-  const nodeSep = rule.nodeSep;
-  let direction;
-  switch (rule.direction) {
-    case "TopBottom": {
-      direction = "TB";
-      break;
-    }
-    case "BottomTop": {
-      direction = "BT";
-      break;
-    }
-    case "LeftRight": {
-      direction = "LR";
-      break;
-    }
-    case "RightLeft": {
-      direction = "RL";
-      break;
-    }
-    default:
-      nonexhaustive(rule.direction);
-  }
-  return {
-    direction,
-    ...nodeSep && { nodeSep },
-    ...rankSep && { rankSep }
-  };
-}
-export function toAstViewLayoutDirection(c4) {
-  switch (c4) {
-    case "TB": {
-      return "TopBottom";
-    }
-    case "BT": {
-      return "BottomTop";
-    }
-    case "LR": {
-      return "LeftRight";
-    }
-    case "RL": {
-      return "RightLeft";
-    }
-    default:
-      nonexhaustive(c4);
-  }
-}
-export function getViewRulePredicateContainer(el) {
-  return AstUtils.getContainerOfType(
-    el,
-    (n) => {
-      return ast.isViewRulePredicate(n) || ast.isDeploymentViewRulePredicate(n) || ast.isDynamicViewIncludePredicate(n);
-    }
-  );
-}
-const _isModel = (astNode) => {
-  return ast.isModel(astNode) || ast.isElementBody(astNode) || ast.isExtendElementBody(astNode) || ast.isElementViewBody(astNode) || ast.isDynamicViewBody(astNode) || ast.isElementRef(astNode);
-};
-const _isDeployment = (astNode) => {
-  return ast.isModelDeployments(astNode) || ast.isDeploymentViewBody(astNode) || ast.isDeploymentNodeBody(astNode) || ast.isExtendDeploymentBody(astNode) || ast.isDeployedInstanceBody(astNode);
-};
-export function isFqnRefInsideGlobals(astNode) {
-  while (true) {
-    if (_isDeployment(astNode) || _isModel(astNode)) {
-      return false;
-    }
-    if (ast.isGlobals(astNode) || ast.isModelViews(astNode)) {
-      return true;
-    }
-    if (astNode.$container) {
-      astNode = astNode.$container;
-    } else {
-      return false;
-    }
-  }
-}
-export function isFqnRefInsideModel(astNode) {
-  while (true) {
-    if (_isDeployment(astNode)) {
-      return false;
-    }
-    if (_isModel(astNode)) {
-      return true;
-    }
-    if (astNode.$container) {
-      astNode = astNode.$container;
-    } else {
-      return false;
-    }
-  }
-}
-export function isFqnRefInsideDeployment(astNode) {
-  while (true) {
-    if (_isModel(astNode)) {
-      return false;
-    }
-    if (_isDeployment(astNode)) {
-      return true;
-    }
-    if (astNode.$container) {
-      astNode = astNode.$container;
-    } else {
-      return false;
-    }
-  }
-}