@likec4/language-server 0.6.3 → 0.18.0

package/dist/lsp/SemanticTokenProvider.js

@@ -1,5 +1,5 @@
 import { AbstractSemanticTokenProvider } from 'langium';
-import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver-protocol';
+import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver';
 import { ast } from '../ast';
 import { isElementRefHead } from '../elementRef';
 export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
@@ -135,46 +135,9 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         if (ast.isElement(node)) {
             return this.highlightAstElement(node, acceptor);
         }
-        // if (ast.isExtendElement(node)) {
-        //   keyword('extend')
-        //   return
-        // }
-        //   if (ast.isElementProperty(node) || ast.isRelationProperty(node) || ast.isViewProperty(node)) {
-        //     acceptor({
-        //       node,
-        //       property: 'key',
-        //       type: SemanticTokenTypes.property,
-        //       modifier: [SemanticTokenModifiers.definition]
-        //     })
-        //     if ('value' in node) {
-        //       acceptor({
-        //         node,
-        //         property: 'value',
-        //         type: SemanticTokenTypes.string
-        //       })
-        //     }
-        //     return
-        //   }
         if (ast.isView(node)) {
             return this.highlightView(node, acceptor);
         }
-        //   if (ast.isDynamicViewSteps(node)) {
-        //     keyword('steps')
-        //     return
-        //   }
-        // if (ast.isViewRuleAutoLayout(node)) {
-        //   keyword('autoLayout')
-        //   return
-        // }
-        // if (ast.isViewRuleStyle(node)) {
-        //   keyword('style')
-        //   return
-        // }
-        // if (ast.isViewRuleExpression(node)) {
-        //   keyword(node.isInclude ? 'include' : 'exclude')
-        //   return
-        // }
-        // //
     }
     highlightAstElement(node, acceptor) {
         acceptor({
@@ -198,11 +161,17 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         }
     }
     highlightView(node, acceptor) {
+        acceptor({
+            node,
+            keyword: 'view',
+            type: SemanticTokenTypes.keyword
+        });
         if (node.name) {
             acceptor({
                 node,
                 property: 'name',
-                type: SemanticTokenTypes.variable
+                type: SemanticTokenTypes.variable,
+                modifier: [SemanticTokenModifiers.declaration]
             });
         }
         if (node.viewOf) {
@@ -212,10 +181,6 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
                 type: SemanticTokenTypes.keyword
             });
         }
-        acceptor({
-            node,
-            keyword: 'view',
-            type: SemanticTokenTypes.keyword
-        });
     }
 }
+//# sourceMappingURL=SemanticTokenProvider.js.map

package/dist/lsp/index.d.ts

@@ -1,3 +1,4 @@
 export * from './DocumentSymbolProvider';
 export * from './HoverProvider';
 export * from './SemanticTokenProvider';
+//# sourceMappingURL=index.d.ts.map

package/dist/lsp/index.js

@@ -1,3 +1,4 @@
 export * from './DocumentSymbolProvider';
 export * from './HoverProvider';
 export * from './SemanticTokenProvider';
+//# sourceMappingURL=index.js.map

package/dist/model/fqn-computation.d.ts

@@ -0,0 +1,4 @@
+import { type LikeC4LangiumDocument } from '../ast';
+import type { LikeC4Services } from '../module';
+export declare function computeDocumentFqn(document: LikeC4LangiumDocument, services: LikeC4Services): void;
+//# sourceMappingURL=fqn-computation.d.ts.map

package/dist/model/fqn-computation.js

@@ -0,0 +1,41 @@
+import { failExpectedNever } from '@likec4/core';
+import { Fqn } from '@likec4/core/types';
+import { MultiMap } from 'langium';
+import { isEmpty, isNil } from 'rambdax';
+import { ElementOps, ast } from '../ast';
+import { strictElementRefFqn } from '../elementRef';
+export function computeDocumentFqn(document, services) {
+    const c4fqns = document.c4fqns = new MultiMap();
+    const { model } = document.parseResult.value;
+    if (!model?.elements) {
+        return;
+    }
+    const locator = services.workspace.AstNodeLocator;
+    const traverseStack = model.elements.map(el => [el, null]);
+    let pair;
+    while ((pair = traverseStack.shift())) {
+        const [el, parent] = pair;
+        if (ast.isRelation(el)) {
+            continue;
+        }
+        if (ast.isExtendElement(el)) {
+            if (!isNil(el.body) && !isEmpty(el.body.elements)) {
+                const fqn = strictElementRefFqn(el.element);
+                el.body.elements.forEach(child => traverseStack.push([child, fqn]));
+            }
+            continue;
+        }
+        if (ast.isElement(el)) {
+            const fqn = Fqn(el.name, parent);
+            const path = locator.getAstNodePath(el);
+            c4fqns.add(fqn, path);
+            ElementOps.writeId(el, fqn);
+            if (!isNil(el.body) && !isEmpty(el.body.elements)) {
+                el.body.elements.forEach(child => traverseStack.push([child, fqn]));
+            }
+            continue;
+        }
+        failExpectedNever(el);
+    }
+}
+//# sourceMappingURL=fqn-computation.js.map

package/dist/model/fqn-index.d.ts

@@ -1,17 +1,42 @@
-import { StreamImpl } from 'langium';
-import type { AstNodeDescription, AstNodeDescriptionProvider } from 'langium';
-import { ast } from '../ast';
+import type { Fqn } from '@likec4/core/types';
+import type { LangiumDocuments } from 'langium';
+import { DocumentState, MultiMap, StreamImpl } from 'langium';
+import type { SetNonNullable } from 'type-fest';
+import type { ast } from '../ast';
+import { type LikeC4LangiumDocument } from '../ast';
 import type { LikeC4Services } from '../module';
-import { Fqn } from '@likec4/core/types';
+export interface FqnIndexEntry {
+    fqn: Fqn;
+    name: string;
+    doc: LikeC4LangiumDocument;
+    path: string;
+}
 export declare class FqnIndex {
-    #private;
     private services;
-    protected readonly descriptions: AstNodeDescriptionProvider;
+    protected langiumDocuments: LangiumDocuments;
     constructor(services: LikeC4Services);
+    private documents;
+    private entries;
     get(el: ast.Element): Fqn | null;
-    byFqn(fqn: Fqn): readonly AstNodeDescription[];
-    directChildrenOf(parent: Fqn): import("langium").Stream<AstNodeDescription>;
-    uniqueDescedants(parent: Fqn): StreamImpl<IterableIterator<AstNodeDescription> | null, AstNodeDescription>;
-    private doIndexElements;
-    private cleanIndexedElements;
+    byFqn(fqn: Fqn): import("langium").Stream<{
+        path: string;
+        doc: SetNonNullable<{
+            c4hash?: string;
+            c4Specification: import("../ast").ParsedAstSpecification;
+            c4Elements: import("../ast").ParsedAstElement[];
+            c4Relations: import("../ast").ParsedAstRelation[];
+            c4Views: import("../ast").ParsedAstElementView[];
+            readonly uri: import("vscode-uri").URI;
+            readonly textDocument: import("vscode-languageserver-textdocument").TextDocument;
+            state: DocumentState;
+            parseResult: import("langium").ParseResult<ast.LikeC4Document>;
+            precomputedScopes?: import("langium").PrecomputedScopes;
+            references: import("langium").Reference<import("langium").AstNode>[];
+            diagnostics?: import("vscode-languageserver-types").Diagnostic[];
+            c4fqns: MultiMap<Fqn, string> | undefined;
+        }, "c4fqns">;
+    }>;
+    directChildrenOf(parent: Fqn): import("langium").Stream<FqnIndexEntry>;
+    uniqueDescedants(parent: Fqn): StreamImpl<IterableIterator<FqnIndexEntry> | null, FqnIndexEntry>;
 }
+//# sourceMappingURL=fqn-index.d.ts.map

package/dist/model/fqn-index.js

@@ -1,48 +1,60 @@
-import { DocumentState, DONE_RESULT, MultiMap, StreamImpl } from 'langium';
-import { ast, ElementOps } from '../ast';
+import { nameFromFqn, parentFqn } from '@likec4/core/utils';
+import { DocumentState, DONE_RESULT, getDocument, MultiMap, StreamImpl } from 'langium';
+import { isNil } from 'rambdax';
+import { ElementOps, isLikeC4LangiumDocument } from '../ast';
 import { logger } from '../logger';
-import { parentFqn } from '@likec4/core/utils';
-import { Fqn } from '@likec4/core/types';
-import { strictElementRefFqn } from '../elementRef';
+import { computeDocumentFqn } from './fqn-computation';
+const isFqnIndexedDocument = (doc) => isLikeC4LangiumDocument(doc) && doc.state >= DocumentState.IndexedContent && !isNil(doc.c4fqns);
 export class FqnIndex {
     services;
-    // #fqnMap = new WeakMap<ast.Element, Fqn>()
-    #index = new MultiMap();
-    descriptions;
+    langiumDocuments;
     constructor(services) {
         this.services = services;
-        this.descriptions = services.workspace.AstNodeDescriptionProvider;
-        services.shared.workspace.DocumentBuilder.onUpdate((_changed, removed) => {
-            for (const uri of [...removed]) {
-                this.cleanIndexedElements(uri);
-            }
-        });
-        services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.ComputedScopes, (docs, _cancelToken) => {
+        this.langiumDocuments = services.shared.workspace.LangiumDocuments;
+        services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.IndexedContent, (docs, _cancelToken) => {
             for (const doc of docs) {
-                this.cleanIndexedElements(doc.uri);
-                this.doIndexElements(doc);
+                if (isLikeC4LangiumDocument(doc)) {
+                    try {
+                        computeDocumentFqn(doc, services);
+                    }
+                    catch (e) {
+                        logger.error(e);
+                    }
+                }
             }
         });
     }
+    documents() {
+        return this.langiumDocuments.all.filter(isFqnIndexedDocument);
+    }
+    entries() {
+        return this.documents().flatMap(doc => doc.c4fqns.entries().map(([fqn, path]) => ({ fqn, path, doc })));
+    }
     get(el) {
         let fqn = ElementOps.readId(el) ?? null;
-        // if ()
-        // let fqn = this.#fqnMap.get(el) ?? null
-        if (fqn && !this.#index.has(fqn)) {
+        if (fqn) {
+            const doc = getDocument(el);
+            if (isFqnIndexedDocument(doc) && doc.c4fqns.has(fqn)) {
+                return fqn;
+            }
             const path = this.services.workspace.AstNodeLocator.getAstNodePath(el);
             logger.error(`Clean cached FQN ${fqn} at ${path}`);
-            // this.#fqnMap.delete(el)
+            ElementOps.writeId(el, null);
             fqn = null;
         }
         return fqn;
     }
     byFqn(fqn) {
-        return this.#index.get(fqn);
+        return this.documents()
+            .flatMap(doc => {
+            return doc.c4fqns.get(fqn).map(path => ({ path, doc }));
+        });
     }
     directChildrenOf(parent) {
-        return this.#index
-            .entriesGroupedByKey()
-            .flatMap(([fqn, descrs]) => (descrs.length === 1 && parentFqn(fqn) === parent ? descrs : []));
+        return this
+            .entries()
+            .filter(e => parentFqn(e.fqn) === parent)
+            .map((e) => ({ ...e, name: nameFromFqn(e.fqn) }));
     }
     uniqueDescedants(parent) {
         return new StreamImpl(() => {
@@ -50,24 +62,26 @@ export class FqnIndex {
             const children = [];
             const childrenNames = new Set();
             const descedants = [];
-            this.#index.entries().forEach(([fqn, desc]) => {
-                if (fqn.startsWith(prefix)) {
-                    if (parentFqn(fqn) === parent) {
-                        childrenNames.add(desc.name);
-                        children.push([fqn, desc]);
+            this.entries().forEach(e => {
+                if (e.fqn.startsWith(prefix)) {
+                    const name = nameFromFqn(e.fqn);
+                    const entry = { ...e, name };
+                    if (parentFqn(e.fqn) === parent) {
+                        childrenNames.add(name);
+                        children.push(entry);
                     }
                     else {
-                        descedants.push([fqn, desc]);
+                        descedants.push(entry);
                     }
                 }
             });
             if (children.length + descedants.length === 0) {
                 return null;
             }
-            const nested = new MultiMap(children.map(([_fqn, desc]) => [desc.name, desc]));
-            for (const [_, indexed] of descedants) {
-                if (!childrenNames.has(indexed.name)) {
-                    nested.add(indexed.name, indexed);
+            const nested = new MultiMap(children.map(entry => [entry.name, entry]));
+            for (const descedant of descedants) {
+                if (!childrenNames.has(descedant.name)) {
+                    nested.add(descedant.name, descedant);
                 }
             }
             return nested
@@ -81,58 +95,5 @@ export class FqnIndex {
             return DONE_RESULT;
         });
     }
-    doIndexElements(doc) {
-        const visitElement = (element, parent = null) => {
-            try {
-                const name = element.name;
-                const fqn = Fqn(name, parent);
-                this.#index.add(fqn, this.descriptions.createDescription(element, name, doc));
-                ElementOps.writeId(element, fqn);
-                // this.#fqnMap.set(element, fqn)
-                if (element.body) {
-                    for (const nested of element.body.elements) {
-                        if (ast.isElement(nested)) {
-                            visitElement(nested, fqn);
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                logger.warn(e);
-            }
-        };
-        const visitExtendElement = (extendElement) => {
-            try {
-                const fqn = strictElementRefFqn(extendElement.element);
-                for (const nested of extendElement.body.elements) {
-                    if (ast.isElement(nested)) {
-                        visitElement(nested, fqn);
-                    }
-                }
-            }
-            catch (e) {
-                logger.warn(e);
-            }
-        };
-        const elements = doc.parseResult.value.model?.elements ?? [];
-        for (const modelElement of elements) {
-            if (ast.isExtendElement(modelElement)) {
-                visitExtendElement(modelElement);
-                continue;
-            }
-            if (ast.isElement(modelElement)) {
-                visitElement(modelElement);
-                continue;
-            }
-        }
-    }
-    cleanIndexedElements(docUri) {
-        const docUriAsString = docUri.toString();
-        const toDelete = this.#index
-            .entries()
-            .filter(([, indexed]) => indexed.documentUri.toString() === docUriAsString);
-        for (const [fqn, indexed] of toDelete.toArray()) {
-            this.#index.delete(fqn, indexed);
-        }
-    }
 }
+//# sourceMappingURL=fqn-index.js.map

package/dist/model/index.d.ts

@@ -1,3 +1,5 @@
+export * from './fqn-computation';
 export * from './fqn-index';
 export * from './model-builder';
 export * from './model-locator';
+//# sourceMappingURL=index.d.ts.map

package/dist/model/index.js

@@ -1,3 +1,5 @@
+export * from './fqn-computation';
 export * from './fqn-index';
 export * from './model-builder';
 export * from './model-locator';
+//# sourceMappingURL=index.js.map

package/dist/model/model-builder.d.ts

@@ -24,3 +24,4 @@ export declare class LikeC4ModelBuilder {
     private convertTags;
     private notifyClient;
 }
+//# sourceMappingURL=model-builder.d.ts.map

package/dist/model/model-builder.js

@@ -2,15 +2,14 @@ import { computeViews } from '@likec4/core/compute-view';
 import { DefaultElementShape, DefaultThemeColor } from '@likec4/core/types';
 import { compareByFqnHierarchically, parentFqn } from '@likec4/core/utils';
 import { A, O, flow, pipe } from '@mobily/ts-belt';
-import { DocumentState, getDocument, interruptAndCheck } from 'langium';
+import { DocumentState, getDocument } from 'langium';
 import objectHash from 'object-hash';
-import { clone, isNil, mergeDeepRight, omit, reduce } from 'rambdax';
+import { clone, isNil, mergeDeepRight, reduce } from 'rambdax';
 import invariant from 'tiny-invariant';
-import { toAutoLayout } from '../ast';
-import { ElementViewOps, ast, c4hash, cleanParsedModel, isLikeC4LangiumDocument, isParsedLikeC4LangiumDocument, resolveRelationPoints, streamModel, toElementStyle } from '../ast';
+import { ElementViewOps, ast, c4hash, cleanParsedModel, isLikeC4LangiumDocument, isParsedLikeC4LangiumDocument, resolveRelationPoints, streamModel, toAutoLayout, toElementStyle } from '../ast';
 import { elementRef, strictElementRefFqn } from '../elementRef';
 import { logger } from '../logger';
-import { Rpc } from '@likec4/language-protocol';
+import { Rpc } from '../protocol';
 import { failExpectedNever } from '../utils';
 export class LikeC4ModelBuilder {
     services;
@@ -20,26 +19,24 @@ export class LikeC4ModelBuilder {
         this.services = services;
         this.fqnIndex = services.likec4.FqnIndex;
         this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-        services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.Validated, async (docs, cancelToken) => {
+        services.shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.Validated, (docs, cancelToken) => {
             let countOfChangedDocs = 0;
-            try {
-                for (const doc of docs) {
-                    await interruptAndCheck(cancelToken);
-                    try {
-                        if (isLikeC4LangiumDocument(doc) && this.parseDocument(doc)) {
-                            countOfChangedDocs++;
-                        }
-                    }
-                    catch (e) {
-                        logger.warn(`Error parsing document ${doc.uri.toString()}`);
+            for (const doc of docs) {
+                if (cancelToken.isCancellationRequested) {
+                    break;
+                }
+                try {
+                    if (isLikeC4LangiumDocument(doc) && this.parseDocument(doc)) {
+                        countOfChangedDocs++;
                     }
                 }
-            }
-            finally {
-                if (countOfChangedDocs > 0 && !cancelToken.isCancellationRequested) {
-                    await this.notifyClient();
+                catch (e) {
+                    logger.warn(`Error parsing document ${doc.uri.toString()}`);
                 }
             }
+            if (countOfChangedDocs > 0 && !cancelToken.isCancellationRequested) {
+                void this.notifyClient();
+            }
         });
     }
     get connection() {
@@ -51,8 +48,10 @@ export class LikeC4ModelBuilder {
     buildModel() {
         const docs = this.documents();
         if (docs.length === 0) {
+            logger.debug('No documents to build model from');
             return;
         }
+        // TODO:
         try {
             const c4Specification = reduce((acc, doc) => mergeDeepRight(acc, doc.c4Specification), {
                 kinds: {}
@@ -65,43 +64,58 @@ export class LikeC4ModelBuilder {
             const toModelElement = (el) => {
                 const kind = c4Specification.kinds[el.kind];
                 if (kind) {
+                    const { astPath, ...model } = el;
                     return {
                         ...(kind.shape !== DefaultElementShape ? { shape: kind.shape } : {}),
                         ...(kind.color !== DefaultThemeColor ? { color: kind.color } : {}),
-                        ...omit(['astPath'], el)
+                        ...model
                     };
                 }
                 return null;
             };
             const toModelRelation = (rel) => {
-                return omit(['astPath'], rel);
+                const { astPath, ...model } = rel;
+                return model;
             };
             const elements = pipe(docs.flatMap(d => d.c4Elements), A.filterMap(flow(toModelElement, O.fromNullable)), A.sort(compareByFqnHierarchically), A.reduce({}, (acc, el) => {
                 const parent = parentFqn(el.id);
                 if (!parent || parent in acc) {
-                    invariant(!(el.id in acc), 'Duplicate element id: ' + el.id);
+                    if (el.id in acc) {
+                        logger.warn(`Duplicate element id: ${el.id}`);
+                        return acc;
+                    }
                     acc[el.id] = el;
                 }
                 return acc;
             }));
             const relations = pipe(docs.flatMap(d => d.c4Relations), A.filterMap(flow(toModelRelation, O.fromPredicate(({ source, target }) => source in elements && target in elements))), A.reduce({}, (acc, el) => {
-                invariant(!(el.id in acc), 'Duplicate relation id: ' + el.id);
+                if (el.id in acc) {
+                    logger.warn(`Duplicate relation id: ${el.id}`);
+                    return acc;
+                }
                 acc[el.id] = el;
                 return acc;
             }));
             const toModelView = (view) => {
-                let title = view.title;
+                // eslint-disable-next-line prefer-const
+                let { astPath, rules, title, ...model } = view;
                 if (!title && view.viewOf) {
                     title = elements[view.viewOf]?.title;
                 }
+                if (!title && view.id === 'index') {
+                    title = 'Landscape view';
+                }
                 return {
-                    ...omit(['astPath', 'rules', 'tite'], view),
-                    ...(!!title ? { title } : {}),
-                    rules: clone(view.rules)
+                    ...model,
+                    ...(title && { title }),
+                    rules: clone(rules)
                 };
             };
             const views = pipe(docs.flatMap(d => d.c4Views), A.filterMap(flow(toModelView, O.fromPredicate(v => isNil(v.viewOf) || v.viewOf in elements))), A.reduce({}, (acc, v) => {
-                invariant(!(v.id in acc), 'Duplicate view id: ' + v.id);
+                if (v.id in acc) {
+                    logger.warn(`Duplicate view id: ${v.id}`);
+                    return acc;
+                }
                 acc[v.id] = v;
                 return acc;
             }));
@@ -326,7 +340,7 @@ export class LikeC4ModelBuilder {
         if (!connection) {
             return;
         }
-        logger.debug('Send onDidChangeModel');
         await connection.sendNotification(Rpc.onDidChangeModel);
     }
 }
+//# sourceMappingURL=model-builder.js.map

package/dist/model/model-locator.d.ts

@@ -14,3 +14,4 @@ export declare class LikeC4ModelLocator {
     locateRelation(relationId: c4.RelationID): Location | null;
     locateView(viewId: c4.ViewID): Location | null;
 }
+//# sourceMappingURL=model-locator.d.ts.map

package/dist/model/model-locator.js

@@ -1,6 +1,4 @@
-import { getDocument } from 'langium';
-import { findNodeForKeyword, findNodeForProperty } from 'langium';
-import { head } from 'rambdax';
+import { findNodeForKeyword, findNodeForProperty, getDocument } from 'langium';
 import { ast, isParsedLikeC4LangiumDocument } from '../ast';
 export class LikeC4ModelLocator {
     services;
@@ -25,19 +23,28 @@ export class LikeC4ModelLocator {
         return doc.c4Elements.find(e => e.id === fqn) ?? null;
     }
     locateElement(fqn, property = 'name') {
-        const descr = head(this.fqnIndex.byFqn(fqn));
-        if (!descr)
-            return null;
-        const docUri = descr.documentUri.toString();
-        const doc = this.documents().find(d => d.uri.toString() === docUri);
-        const node = doc && this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, descr.path);
-        if (!ast.isElement(node) || !node.$cstNode)
-            return null;
-        const propertyNode = findNodeForProperty(node.$cstNode, property);
-        return {
-            uri: docUri,
-            range: propertyNode?.range ?? node.$cstNode.range
-        };
+        for (const doc of this.documents()) {
+            if (doc.c4fqns && !doc.c4fqns.has(fqn)) {
+                continue;
+            }
+            const element = doc.c4Elements.find(e => e.id === fqn);
+            if (!element) {
+                continue;
+            }
+            const node = this.services.workspace.AstNodeLocator.getAstNode(doc.parseResult.value, element.astPath);
+            if (!ast.isElement(node)) {
+                continue;
+            }
+            const propertyNode = findNodeForProperty(node.$cstNode, property) ?? node.$cstNode;
+            if (!propertyNode) {
+                return null;
+            }
+            return {
+                uri: doc.uri.toString(),
+                range: propertyNode.range
+            };
+        }
+        return null;
     }
     locateRelation(relationId) {
         for (const doc of this.documents()) {
@@ -106,3 +113,4 @@ export class LikeC4ModelLocator {
         return null;
     }
 }
+//# sourceMappingURL=model-locator.js.map

package/dist/module.d.ts

@@ -18,3 +18,4 @@ export declare function createLanguageServices(context?: LanguageServicesContext
     likec4: LikeC4Services;
 };
 export {};
+//# sourceMappingURL=module.d.ts.map

package/dist/module.js

@@ -14,10 +14,6 @@ export const LikeC4Module = {
         FqnIndex: bind(FqnIndex),
         ModelBuilder: bind(LikeC4ModelBuilder),
         ModelLocator: bind(LikeC4ModelLocator)
-        // Model: bind(LikeC4Model),
-        // Model: bind(LikeC4Model),
-        // SpecIndex: bind(LikeC4SpecIndex),
-        // Validator: bind(LikeC4Validator)
     },
     lsp: {
         DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
@@ -63,3 +59,4 @@ export function createLanguageServices(context) {
     registerProtocolHandlers(likec4);
     return { shared, likec4 };
 }
+//# sourceMappingURL=module.js.map