@likec4/language-server 0.37.1 → 0.41.0

package/dist/module.js

@@ -1,69 +1,78 @@
-import { EmptyFileSystem, createDefaultModule, createDefaultSharedModule, inject } from 'langium';
-import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from './generated/module';
-import { LikeC4CodeLensProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
-import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
-import { LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
-import { registerProtocolHandlers } from './registerProtocolHandlers';
-import { LikeC4WorkspaceManager } from './shared';
-import { registerValidationChecks } from './validation';
-import { logger } from './logger';
-import { serializeError } from '@likec4/core';
+import {
+  WorkspaceCache
+} from "langium";
+import { EmptyFileSystem, createDefaultModule, createDefaultSharedModule, inject } from "langium";
+import { LikeC4GeneratedModule, LikeC4GeneratedSharedModule } from "./generated/module.js";
+import {
+  LikeC4CodeLensProvider,
+  LikeC4DocumentLinkProvider,
+  LikeC4DocumentSymbolProvider,
+  LikeC4HoverProvider,
+  LikeC4SemanticTokenProvider
+} from "./lsp/index.js";
+import { FqnIndex, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from "./model/index.js";
+import { LikeC4ScopeComputation, LikeC4ScopeProvider } from "./references/index.js";
+import { Rpc } from "./Rpc.js";
+import { LikeC4WorkspaceManager } from "./shared/index.js";
+import { registerValidationChecks } from "./validation/index.js";
+import { logger } from "./logger.js";
+import { serializeError } from "@likec4/core";
 function bind(Type) {
-    return (services) => new Type(services);
+  return (services) => new Type(services);
 }
 export const LikeC4Module = {
-    likec4: {
-        FqnIndex: bind(FqnIndex),
-        ModelParser: bind(LikeC4ModelParser),
-        ModelBuilder: bind(LikeC4ModelBuilder),
-        ModelLocator: bind(LikeC4ModelLocator)
-    },
-    lsp: {
-        DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
-        SemanticTokenProvider: bind(LikeC4SemanticTokenProvider),
-        HoverProvider: bind(LikeC4HoverProvider),
-        CodeLensProvider: bind(LikeC4CodeLensProvider),
-        DocumentLinkProvider: bind(LikeC4DocumentLinkProvider)
-    },
-    //
-    //   // Formatter: bind(LikeC4Formatter),
-    //
-    // },
-    references: {
-        ScopeComputation: bind(LikeC4ScopeComputation),
-        ScopeProvider: bind(LikeC4ScopeProvider)
-    }
+  WorkspaceCache: (services) => new WorkspaceCache(services.shared),
+  Rpc: bind(Rpc),
+  likec4: {
+    FqnIndex: bind(FqnIndex),
+    ModelParser: bind(LikeC4ModelParser),
+    ModelBuilder: bind(LikeC4ModelBuilder),
+    ModelLocator: bind(LikeC4ModelLocator)
+  },
+  lsp: {
+    DocumentSymbolProvider: bind(LikeC4DocumentSymbolProvider),
+    SemanticTokenProvider: bind(LikeC4SemanticTokenProvider),
+    HoverProvider: bind(LikeC4HoverProvider),
+    CodeLensProvider: bind(LikeC4CodeLensProvider),
+    DocumentLinkProvider: bind(LikeC4DocumentLinkProvider)
+  },
+  references: {
+    ScopeComputation: bind(LikeC4ScopeComputation),
+    ScopeProvider: bind(LikeC4ScopeProvider)
+  }
 };
 const LikeC4SharedModule = {
-    workspace: {
-        WorkspaceManager: services => new LikeC4WorkspaceManager(services)
-    }
+  workspace: {
+    WorkspaceManager: (services) => new LikeC4WorkspaceManager(services)
+  }
 };
 export function createLanguageServices(context) {
-    const connection = context?.connection;
-    if (connection) {
-        // eslint-disable-next-line @typescript-eslint/unbound-method
-        const original = logger.error.bind(logger);
-        logger.error = (arg) => {
-            if (typeof arg === 'string') {
-                original(arg);
-                connection.telemetry.logEvent({ eventName: 'error', error: arg });
-                return;
-            }
-            const { message, error } = serializeError(arg);
-            original(error);
-            connection.telemetry.logEvent({ eventName: 'error', error: message });
-        };
-    }
-    const moduleContext = {
-        ...EmptyFileSystem,
-        ...context
+  const connection = context?.connection;
+  if (connection) {
+    const original = logger.error.bind(logger);
+    logger.error = (arg) => {
+      if (typeof arg === "string") {
+        original(arg);
+        connection.telemetry.logEvent({ eventName: "error", error: arg });
+        return;
+      }
+      const { message, error } = serializeError(arg);
+      original(error);
+      connection.telemetry.logEvent({ eventName: "error", error: message });
     };
-    const shared = inject(createDefaultSharedModule(moduleContext), LikeC4GeneratedSharedModule, LikeC4SharedModule);
-    const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module);
-    shared.ServiceRegistry.register(likec4);
-    registerValidationChecks(likec4);
-    registerProtocolHandlers(likec4);
-    return { shared, likec4 };
+  }
+  const moduleContext = {
+    ...EmptyFileSystem,
+    ...context
+  };
+  const shared = inject(
+    createDefaultSharedModule(moduleContext),
+    LikeC4GeneratedSharedModule,
+    LikeC4SharedModule
+  );
+  const likec4 = inject(createDefaultModule({ shared }), LikeC4GeneratedModule, LikeC4Module);
+  shared.ServiceRegistry.register(likec4);
+  registerValidationChecks(likec4);
+  likec4.Rpc.init();
+  return { shared, likec4 };
 }
-//# sourceMappingURL=module.js.map

package/dist/protocol.d.ts

@@ -1,9 +1,25 @@
 import type { ComputedView, Fqn, LikeC4Model, LikeC4RawModel, RelationID, ViewID } from '@likec4/core';
 import type { DocumentUri, Location } from 'vscode-languageserver-protocol';
 import { NotificationType, RequestType, RequestType0 } from 'vscode-languageserver-protocol';
+export declare const onDidChangeModel: NotificationType<string>;
+export declare const fetchRawModel: RequestType0<{
+    rawmodel: LikeC4RawModel | null;
+}, void>;
+export declare const fetchModel: RequestType0<{
+    model: LikeC4Model | null;
+}, void>;
+export declare const computeView: RequestType<{
+    viewId: ViewID;
+}, {
+    view: ComputedView | null;
+}, void>;
+export declare const rebuild: RequestType0<{
+    docs: DocumentUri[];
+}, void>;
 interface BuildDocumentsParams {
     docs: DocumentUri[];
 }
+export declare const buildDocuments: RequestType<BuildDocumentsParams, void, void>;
 export type LocateParams = {
     element: Fqn;
     property?: string;
@@ -13,24 +29,5 @@ export type LocateParams = {
     view: ViewID;
 };
 export declare const locate: RequestType<LocateParams, Location | null, void>;
-export declare const Rpc: {
-    readonly onDidChangeModel: NotificationType<string>;
-    readonly fetchModel: RequestType0<{
-        model: LikeC4Model | null;
-    }, void>;
-    readonly fetchRawModel: RequestType0<{
-        rawmodel: LikeC4RawModel | null;
-    }, void>;
-    readonly computeView: RequestType<{
-        viewId: ViewID;
-    }, {
-        view: ComputedView | null;
-    }, void>;
-    readonly rebuild: RequestType0<{
-        docs: DocumentUri[];
-    }, void>;
-    readonly buildDocuments: RequestType<BuildDocumentsParams, void, void>;
-    readonly locate: RequestType<LocateParams, Location | null, void>;
-};
 export {};
 //# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.js

@@ -1,22 +1,14 @@
-import { NotificationType, RequestType, RequestType0 } from 'vscode-languageserver-protocol';
-//#region From server
-const onDidChangeModel = new NotificationType('likec4/onDidChangeModel');
-//#endregion
-//#region To server
-const fetchRawModel = new RequestType0('likec4/fetchRaw');
-const fetchModel = new RequestType0('likec4/fetchModel');
-const computeView = new RequestType('likec4/computeView');
-const rebuild = new RequestType0('likec4/rebuildModel');
-const buildDocuments = new RequestType('likec4/buildDocuments');
-export const locate = new RequestType('likec4/locate');
-//#endregion
-export const Rpc = {
-    onDidChangeModel,
-    fetchModel,
-    fetchRawModel,
-    computeView,
-    rebuild,
-    buildDocuments,
-    locate
-};
-//# sourceMappingURL=protocol.js.map
+import { NotificationType, RequestType, RequestType0 } from "vscode-languageserver-protocol";
+export const onDidChangeModel = new NotificationType("likec4/onDidChangeModel");
+export const fetchRawModel = new RequestType0(
+  "likec4/fetchRaw"
+);
+export const fetchModel = new RequestType0("likec4/fetchModel");
+export const computeView = new RequestType(
+  "likec4/computeView"
+);
+export const rebuild = new RequestType0("likec4/rebuildModel");
+export const buildDocuments = new RequestType(
+  "likec4/buildDocuments"
+);
+export const locate = new RequestType("likec4/locate");

package/dist/references/index.js

@@ -1,3 +1,2 @@
-export * from './scope-computation';
-export * from './scope-provider';
-//# sourceMappingURL=index.js.map
+export * from "./scope-computation.js";
+export * from "./scope-provider.js";

package/dist/references/scope-computation.js

@@ -1,80 +1,83 @@
-import { DefaultScopeComputation, MultiMap } from 'langium';
-import { isEmpty } from 'remeda';
-import { ast } from '../ast';
+import {
+  DefaultScopeComputation,
+  MultiMap
+} from "langium";
+import { isEmpty } from "remeda";
+import { ast } from "../ast.js";
 export class LikeC4ScopeComputation extends DefaultScopeComputation {
-    computeExports(document, _cancelToken) {
-        const { specification, model, views } = document.parseResult.value;
-        const docExports = [];
-        if (specification) {
-            for (const spec of specification.elements) {
-                if (spec.kind && !isEmpty(spec.kind.name)) {
-                    docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
-                }
-            }
-            for (const spec of specification.tags) {
-                if (spec.tag && !isEmpty(spec.tag.name)) {
-                    docExports.push(this.descriptions.createDescription(spec.tag, spec.tag.name, document));
-                    docExports.push(this.descriptions.createDescription(spec.tag, '#' + spec.tag.name, document));
-                }
-            }
+  computeExports(document, _cancelToken) {
+    const { specification, model, views } = document.parseResult.value;
+    const docExports = [];
+    if (specification) {
+      for (const spec of specification.elements) {
+        if (spec.kind && !isEmpty(spec.kind.name)) {
+          docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
         }
-        // Only root model elements are exported
-        if (model && model.elements.length > 0) {
-            for (const elAst of model.elements) {
-                if (ast.isElement(elAst) && !isEmpty(elAst.name)) {
-                    docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
-                }
-            }
+      }
+      for (const spec of specification.tags) {
+        if (spec.tag && !isEmpty(spec.tag.name)) {
+          docExports.push(this.descriptions.createDescription(spec.tag, spec.tag.name, document));
+          docExports.push(this.descriptions.createDescription(spec.tag, "#" + spec.tag.name, document));
         }
-        if (views && views.views.length > 0) {
-            for (const viewAst of views.views) {
-                if (viewAst.name && !isEmpty(viewAst.name)) {
-                    docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
-                }
-            }
+      }
+      for (const spec of specification.relationships) {
+        if (spec.kind && !isEmpty(spec.kind.name)) {
+          docExports.push(this.descriptions.createDescription(spec.kind, spec.kind.name, document));
         }
-        return Promise.resolve(docExports);
+      }
     }
-    async computeLocalScopes(document, _cancelToken) {
-        const root = document.parseResult.value;
-        const scopes = new MultiMap();
-        if (root.model) {
-            const nested = this.processContainer(root.model, scopes, document);
-            scopes.addAll(root, nested.values());
+    if (model && model.elements.length > 0) {
+      for (const elAst of model.elements) {
+        if (ast.isElement(elAst) && !isEmpty(elAst.name)) {
+          docExports.push(this.descriptions.createDescription(elAst, elAst.name, document));
         }
-        return Promise.resolve(scopes);
+      }
     }
-    processContainer(container, scopes, document) {
-        const localScope = new MultiMap();
-        const nestedScopes = new MultiMap();
-        for (const el of container.elements) {
-            if (ast.isRelation(el)) {
-                continue;
-            }
-            let subcontainer;
-            if (ast.isElement(el) && !isEmpty(el.name)) {
-                localScope.add(el.name, this.descriptions.createDescription(el, el.name, document));
-                subcontainer = el.body;
-            }
-            else if (ast.isExtendElement(el)) {
-                subcontainer = el.body;
-            }
-            if (subcontainer && subcontainer.elements.length > 0) {
-                const nested = this.processContainer(subcontainer, scopes, document);
-                for (const [nestedName, desc] of nested) {
-                    nestedScopes.add(nestedName, desc);
-                }
-            }
+    if (views && views.views.length > 0) {
+      for (const viewAst of views.views) {
+        if (viewAst.name && !isEmpty(viewAst.name)) {
+          docExports.push(this.descriptions.createDescription(viewAst, viewAst.name, document));
         }
-        for (const [name, descriptions] of nestedScopes.entriesGroupedByKey()) {
-            // If name is unique for current scope
-            if (!localScope.has(name) && descriptions.length === 1) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                localScope.add(name, descriptions[0]);
-            }
+      }
+    }
+    return Promise.resolve(docExports);
+  }
+  async computeLocalScopes(document, _cancelToken) {
+    const root = document.parseResult.value;
+    const scopes = new MultiMap();
+    if (root.model) {
+      const nested = this.processContainer(root.model, scopes, document);
+      scopes.addAll(root, nested.values());
+    }
+    return Promise.resolve(scopes);
+  }
+  processContainer(container, scopes, document) {
+    const localScope = new MultiMap();
+    const nestedScopes = new MultiMap();
+    for (const el of container.elements) {
+      if (ast.isRelation(el)) {
+        continue;
+      }
+      let subcontainer;
+      if (ast.isElement(el) && !isEmpty(el.name)) {
+        localScope.add(el.name, this.descriptions.createDescription(el, el.name, document));
+        subcontainer = el.body;
+      } else if (ast.isExtendElement(el)) {
+        subcontainer = el.body;
+      }
+      if (subcontainer && subcontainer.elements.length > 0) {
+        const nested = this.processContainer(subcontainer, scopes, document);
+        for (const [nestedName, desc] of nested) {
+          nestedScopes.add(nestedName, desc);
         }
-        scopes.addAll(container, localScope.values());
-        return localScope;
+      }
+    }
+    for (const [name, descriptions] of nestedScopes.entriesGroupedByKey()) {
+      if (!localScope.has(name) && descriptions.length === 1) {
+        localScope.add(name, descriptions[0]);
+      }
     }
+    scopes.addAll(container, localScope.values());
+    return localScope;
+  }
 }
-//# sourceMappingURL=scope-computation.js.map

package/dist/references/scope-provider.js

@@ -1,129 +1,139 @@
-import { DONE_RESULT, DefaultScopeProvider, EMPTY_STREAM, StreamImpl, StreamScope, getDocument, stream, findNodeForProperty, toDocumentSegment } from 'langium';
-import { ast } from '../ast';
-import { elementRef, isElementRefHead, parentFqnElementRef } from '../elementRef';
-import { logError } from '../logger';
+import {
+  DONE_RESULT,
+  DefaultScopeProvider,
+  EMPTY_STREAM,
+  StreamImpl,
+  StreamScope,
+  getDocument,
+  stream,
+  findNodeForProperty,
+  toDocumentSegment
+} from "langium";
+import { ast } from "../ast.js";
+import { elementRef, isElementRefHead, parentFqnElementRef } from "../elementRef.js";
+import { logError } from "../logger.js";
 function toAstNodeDescription(entry) {
-    const $cstNode = findNodeForProperty(entry.el.$cstNode, 'name');
-    return {
-        documentUri: entry.doc.uri,
-        name: entry.name,
-        ...(entry.el.$cstNode && {
-            selectionSegment: toDocumentSegment(entry.el.$cstNode)
-        }),
-        ...($cstNode && {
-            nameSegment: toDocumentSegment($cstNode)
-        }),
-        path: entry.path,
-        type: ast.Element
-    };
+  const $cstNode = findNodeForProperty(entry.el.$cstNode, "name");
+  return {
+    documentUri: entry.doc.uri,
+    name: entry.name,
+    ...entry.el.$cstNode && {
+      selectionSegment: toDocumentSegment(entry.el.$cstNode)
+    },
+    ...$cstNode && {
+      nameSegment: toDocumentSegment($cstNode)
+    },
+    path: entry.path,
+    type: ast.Element
+  };
 }
 export class LikeC4ScopeProvider extends DefaultScopeProvider {
-    fqnIndex;
-    constructor(services) {
-        super(services);
-        this.fqnIndex = services.likec4.FqnIndex;
-    }
-    directChildrenOf(parent) {
-        return this.fqnIndex.directChildrenOf(parent).map(toAstNodeDescription);
-    }
-    // we need lazy resolving here
-    uniqueDescedants(of) {
-        return new StreamImpl(() => {
-            const element = of();
-            const fqn = element && this.fqnIndex.getFqn(element);
-            if (fqn) {
-                return this.fqnIndex.uniqueDescedants(fqn).map(toAstNodeDescription).iterator();
-            }
-            return null;
-        }, iterator => {
-            if (iterator) {
-                return iterator.next();
-            }
-            return DONE_RESULT;
-        });
-    }
-    scopeElementRef(ref) {
-        const parentNode = ref.$container;
-        if (!ast.isElementRef(parentNode)) {
-            throw new Error('Expected be inside ElementRef');
+  fqnIndex;
+  constructor(services) {
+    super(services);
+    this.fqnIndex = services.likec4.FqnIndex;
+  }
+  directChildrenOf(parent) {
+    return this.fqnIndex.directChildrenOf(parent).map(toAstNodeDescription);
+  }
+  // we need lazy resolving here
+  uniqueDescedants(of) {
+    return new StreamImpl(
+      () => {
+        const element = of();
+        const fqn = element && this.fqnIndex.getFqn(element);
+        if (fqn) {
+          return this.fqnIndex.uniqueDescedants(fqn).map(toAstNodeDescription).iterator();
         }
-        return this.uniqueDescedants(() => parentNode.el.ref);
+        return null;
+      },
+      (iterator) => {
+        if (iterator) {
+          return iterator.next();
+        }
+        return DONE_RESULT;
+      }
+    );
+  }
+  scopeElementRef(ref) {
+    const parentNode = ref.$container;
+    if (!ast.isElementRef(parentNode)) {
+      throw new Error("Expected be inside ElementRef");
     }
-    scopeExtendElement(extend) {
-        return this.uniqueDescedants(() => elementRef(extend.element));
+    return this.uniqueDescedants(() => parentNode.el.ref);
+  }
+  scopeExtendElement(extend) {
+    return this.uniqueDescedants(() => elementRef(extend.element));
+  }
+  scopeElementView({ viewOf, extends: ext }) {
+    if (ext) {
+      return stream([ext]).flatMap((v) => {
+        const view = v.view.ref;
+        return view ? this.scopeElementView(view) : EMPTY_STREAM;
+      });
     }
-    scopeElementView({ viewOf, extends: ext }) {
-        if (ext) {
-            return stream([ext]).flatMap(v => {
-                const view = v.view.ref;
-                return view ? this.scopeElementView(view) : EMPTY_STREAM;
-            });
-        }
-        if (viewOf) {
-            return this.uniqueDescedants(() => elementRef(viewOf));
-        }
-        return EMPTY_STREAM;
+    if (viewOf) {
+      return this.uniqueDescedants(() => elementRef(viewOf));
     }
-    getScope(context) {
-        const referenceType = this.reflection.getReferenceType(context);
-        try {
-            const container = context.container;
-            // const path = this.services.workspace.AstNodeLocator.getAstNodePath(node)
-            if (referenceType === ast.Element) {
-                if (ast.isStrictElementRef(container)) {
-                    if (isElementRefHead(container)) {
-                        return this.getGlobalScope(referenceType);
-                    }
-                    const parent = parentFqnElementRef(container);
-                    return new StreamScope(this.directChildrenOf(parent));
-                }
-                if (ast.isElementRef(container) && !isElementRefHead(container)) {
-                    return new StreamScope(this.scopeElementRef(container));
-                }
-            }
-            return this.computeScope(container, referenceType);
-        }
-        catch (e) {
-            logError(e);
+    return EMPTY_STREAM;
+  }
+  getScope(context) {
+    const referenceType = this.reflection.getReferenceType(context);
+    try {
+      const container = context.container;
+      if (referenceType === ast.Element) {
+        if (ast.isStrictElementRef(container)) {
+          if (isElementRefHead(container)) {
             return this.getGlobalScope(referenceType);
+          }
+          const parent = parentFqnElementRef(container);
+          return new StreamScope(this.directChildrenOf(parent));
         }
-    }
-    computeScope(node, referenceType) {
-        const scopes = [];
-        const doc = getDocument(node);
-        const precomputed = doc.precomputedScopes;
-        const byReferenceType = (desc) => this.reflection.isSubtype(desc.type, referenceType);
-        if (precomputed) {
-            const elements = precomputed.get(node).filter(byReferenceType);
-            if (elements.length > 0) {
-                scopes.push(stream(elements));
-            }
-            let container = node.$container;
-            while (container) {
-                const elements = precomputed.get(container).filter(byReferenceType);
-                if (elements.length > 0) {
-                    scopes.push(stream(elements));
-                }
-                if (referenceType === ast.Element) {
-                    if (ast.isExtendElementBody(container)) {
-                        scopes.push(this.scopeExtendElement(container.$container));
-                    }
-                    if (ast.isElementViewBody(container)) {
-                        scopes.push(this.scopeElementView(container.$container));
-                    }
-                }
-                container = container.$container;
-            }
+        if (ast.isElementRef(container) && !isElementRefHead(container)) {
+          return new StreamScope(this.scopeElementRef(container));
         }
-        return scopes.reduceRight((outerScope, elements) => {
-            return this.createScope(elements, outerScope);
-        }, this.getGlobalScope(referenceType));
+      }
+      return this.computeScope(container, referenceType);
+    } catch (e) {
+      logError(e);
+      return this.getGlobalScope(referenceType);
     }
-    /**
-     * Create a global scope filtered for the given reference type.
-     */
-    getGlobalScope(referenceType) {
-        return new StreamScope(this.indexManager.allElements(referenceType));
+  }
+  computeScope(node, referenceType) {
+    const scopes = [];
+    const doc = getDocument(node);
+    const precomputed = doc.precomputedScopes;
+    const byReferenceType = (desc) => this.reflection.isSubtype(desc.type, referenceType);
+    if (precomputed) {
+      const elements = precomputed.get(node).filter(byReferenceType);
+      if (elements.length > 0) {
+        scopes.push(stream(elements));
+      }
+      let container = node.$container;
+      while (container) {
+        const elements2 = precomputed.get(container).filter(byReferenceType);
+        if (elements2.length > 0) {
+          scopes.push(stream(elements2));
+        }
+        if (referenceType === ast.Element) {
+          if (ast.isExtendElementBody(container)) {
+            scopes.push(this.scopeExtendElement(container.$container));
+          }
+          if (ast.isElementViewBody(container)) {
+            scopes.push(this.scopeElementView(container.$container));
+          }
+        }
+        container = container.$container;
+      }
     }
+    return scopes.reduceRight((outerScope, elements) => {
+      return this.createScope(elements, outerScope);
+    }, this.getGlobalScope(referenceType));
+  }
+  /**
+   * Create a global scope filtered for the given reference type.
+   */
+  getGlobalScope(referenceType) {
+    return new StreamScope(this.indexManager.allElements(referenceType));
+  }
 }
-//# sourceMappingURL=scope-provider.js.map