@elmethis/core 1.0.0-alpha.149 → 1.0.0-alpha.150

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/name-provider.mjs

@@ -1,19 +0,0 @@
-import { findNodeForProperty } from "../utils/grammar-utils.mjs";
-function isNamed(node) {
-  return typeof node.name === "string";
-}
-class DefaultNameProvider {
-  getName(node) {
-    if (isNamed(node)) {
-      return node.name;
-    }
-    return void 0;
-  }
-  getNameNode(node) {
-    return findNodeForProperty(node.$cstNode, "name");
-  }
-}
-export {
-  DefaultNameProvider,
-  isNamed
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/references.mjs

@@ -1,80 +0,0 @@
-import { findAssignment } from "../utils/grammar-utils.mjs";
-import { isReference } from "../syntax-tree.mjs";
-import { getDocument } from "../utils/ast-utils.mjs";
-import { isChildNode, toDocumentSegment } from "../utils/cst-utils.mjs";
-import { stream } from "../utils/stream.mjs";
-import { UriUtils } from "../utils/uri-utils.mjs";
-class DefaultReferences {
-  constructor(services) {
-    this.nameProvider = services.references.NameProvider;
-    this.index = services.shared.workspace.IndexManager;
-    this.nodeLocator = services.workspace.AstNodeLocator;
-  }
-  findDeclaration(sourceCstNode) {
-    if (sourceCstNode) {
-      const assignment = findAssignment(sourceCstNode);
-      const nodeElem = sourceCstNode.astNode;
-      if (assignment && nodeElem) {
-        const reference = nodeElem[assignment.feature];
-        if (isReference(reference)) {
-          return reference.ref;
-        } else if (Array.isArray(reference)) {
-          for (const ref of reference) {
-            if (isReference(ref) && ref.$refNode && ref.$refNode.offset <= sourceCstNode.offset && ref.$refNode.end >= sourceCstNode.end) {
-              return ref.ref;
-            }
-          }
-        }
-      }
-      if (nodeElem) {
-        const nameNode = this.nameProvider.getNameNode(nodeElem);
-        if (nameNode && (nameNode === sourceCstNode || isChildNode(sourceCstNode, nameNode))) {
-          return nodeElem;
-        }
-      }
-    }
-    return void 0;
-  }
-  findDeclarationNode(sourceCstNode) {
-    const astNode = this.findDeclaration(sourceCstNode);
-    if (astNode === null || astNode === void 0 ? void 0 : astNode.$cstNode) {
-      const targetNode = this.nameProvider.getNameNode(astNode);
-      return targetNode !== null && targetNode !== void 0 ? targetNode : astNode.$cstNode;
-    }
-    return void 0;
-  }
-  findReferences(targetNode, options) {
-    const refs = [];
-    if (options.includeDeclaration) {
-      const ref = this.getReferenceToSelf(targetNode);
-      if (ref) {
-        refs.push(ref);
-      }
-    }
-    let indexReferences = this.index.findAllReferences(targetNode, this.nodeLocator.getAstNodePath(targetNode));
-    if (options.documentUri) {
-      indexReferences = indexReferences.filter((ref) => UriUtils.equals(ref.sourceUri, options.documentUri));
-    }
-    refs.push(...indexReferences);
-    return stream(refs);
-  }
-  getReferenceToSelf(targetNode) {
-    const nameNode = this.nameProvider.getNameNode(targetNode);
-    if (nameNode) {
-      const doc = getDocument(targetNode);
-      const path = this.nodeLocator.getAstNodePath(targetNode);
-      return {
-        sourceUri: doc.uri,
-        sourcePath: path,
-        targetUri: doc.uri,
-        targetPath: path,
-        segment: toDocumentSegment(nameNode),
-        local: true
-      };
-    }
-    return void 0;
-  }
-}
-export {
-  DefaultReferences
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/scope-computation.mjs

@@ -1,70 +0,0 @@
-import { streamContents, streamAllContents } from "../utils/ast-utils.mjs";
-import { MultiMap } from "../utils/collections.mjs";
-import { interruptAndCheck } from "../utils/promise-utils.mjs";
-import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
-class DefaultScopeComputation {
-  constructor(services) {
-    this.nameProvider = services.references.NameProvider;
-    this.descriptions = services.workspace.AstNodeDescriptionProvider;
-  }
-  async computeExports(document, cancelToken = cancellationExports.CancellationToken.None) {
-    return this.computeExportsForNode(document.parseResult.value, document, void 0, cancelToken);
-  }
-  /**
-   * Creates {@link AstNodeDescription AstNodeDescriptions} for the given {@link AstNode parentNode} and its children.
-   * The list of children to be considered is determined by the function parameter {@link children}.
-   * By default only the direct children of {@link parentNode} are visited, nested nodes are not exported.
-   *
-   * @param parentNode AST node to be exported, i.e., of which an {@link AstNodeDescription} shall be added to the returned list.
-   * @param document The document containing the AST node to be exported.
-   * @param children A function called with {@link parentNode} as single argument and returning an {@link Iterable} supplying the children to be visited, which must be directly or transitively contained in {@link parentNode}.
-   * @param cancelToken Indicates when to cancel the current operation.
-   * @throws `OperationCancelled` if a user action occurs during execution.
-   * @returns A list of {@link AstNodeDescription AstNodeDescriptions} to be published to index.
-   */
-  async computeExportsForNode(parentNode, document, children = streamContents, cancelToken = cancellationExports.CancellationToken.None) {
-    const exports = [];
-    this.exportNode(parentNode, exports, document);
-    for (const node of children(parentNode)) {
-      await interruptAndCheck(cancelToken);
-      this.exportNode(node, exports, document);
-    }
-    return exports;
-  }
-  /**
-   * Add a single node to the list of exports if it has a name. Override this method to change how
-   * symbols are exported, e.g. by modifying their exported name.
-   */
-  exportNode(node, exports, document) {
-    const name = this.nameProvider.getName(node);
-    if (name) {
-      exports.push(this.descriptions.createDescription(node, name, document));
-    }
-  }
-  async computeLocalScopes(document, cancelToken = cancellationExports.CancellationToken.None) {
-    const rootNode = document.parseResult.value;
-    const scopes = new MultiMap();
-    for (const node of streamAllContents(rootNode)) {
-      await interruptAndCheck(cancelToken);
-      this.processNode(node, document, scopes);
-    }
-    return scopes;
-  }
-  /**
-   * Process a single node during scopes computation. The default implementation makes the node visible
-   * in the subtree of its container (if the node has a name). Override this method to change this,
-   * e.g. by increasing the visibility to a higher level in the AST.
-   */
-  processNode(node, document, scopes) {
-    const container = node.$container;
-    if (container) {
-      const name = this.nameProvider.getName(node);
-      if (name) {
-        scopes.add(container, this.descriptions.createDescription(node, name, document));
-      }
-    }
-  }
-}
-export {
-  DefaultScopeComputation
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/scope-provider.mjs

@@ -1,62 +0,0 @@
-import { StreamScope, MapScope } from "./scope.mjs";
-import { getDocument } from "../utils/ast-utils.mjs";
-import { stream } from "../utils/stream.mjs";
-import { WorkspaceCache } from "../utils/caching.mjs";
-class DefaultScopeProvider {
-  constructor(services) {
-    this.reflection = services.shared.AstReflection;
-    this.nameProvider = services.references.NameProvider;
-    this.descriptions = services.workspace.AstNodeDescriptionProvider;
-    this.indexManager = services.shared.workspace.IndexManager;
-    this.globalScopeCache = new WorkspaceCache(services.shared);
-  }
-  getScope(context) {
-    const scopes = [];
-    const referenceType = this.reflection.getReferenceType(context);
-    const precomputed = getDocument(context.container).precomputedScopes;
-    if (precomputed) {
-      let currentNode = context.container;
-      do {
-        const allDescriptions = precomputed.get(currentNode);
-        if (allDescriptions.length > 0) {
-          scopes.push(stream(allDescriptions).filter((desc) => this.reflection.isSubtype(desc.type, referenceType)));
-        }
-        currentNode = currentNode.$container;
-      } while (currentNode);
-    }
-    let result = this.getGlobalScope(referenceType, context);
-    for (let i = scopes.length - 1; i >= 0; i--) {
-      result = this.createScope(scopes[i], result);
-    }
-    return result;
-  }
-  /**
-   * Create a scope for the given collection of AST node descriptions.
-   */
-  createScope(elements, outerScope, options) {
-    return new StreamScope(stream(elements), outerScope, options);
-  }
-  /**
-   * Create a scope for the given collection of AST nodes, which need to be transformed into respective
-   * descriptions first. This is done using the `NameProvider` and `AstNodeDescriptionProvider` services.
-   */
-  createScopeForNodes(elements, outerScope, options) {
-    const s = stream(elements).map((e) => {
-      const name = this.nameProvider.getName(e);
-      if (name) {
-        return this.descriptions.createDescription(e, name);
-      }
-      return void 0;
-    }).nonNullable();
-    return new StreamScope(s, outerScope, options);
-  }
-  /**
-   * Create a global scope filtered for the given reference type.
-   */
-  getGlobalScope(referenceType, _context) {
-    return this.globalScopeCache.get(referenceType, () => new MapScope(this.indexManager.allElements(referenceType)));
-  }
-}
-export {
-  DefaultScopeProvider
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/references/scope.mjs

@@ -1,60 +0,0 @@
-import { stream } from "../utils/stream.mjs";
-class StreamScope {
-  constructor(elements, outerScope, options) {
-    var _a;
-    this.elements = elements;
-    this.outerScope = outerScope;
-    this.caseInsensitive = (_a = options === null || options === void 0 ? void 0 : options.caseInsensitive) !== null && _a !== void 0 ? _a : false;
-  }
-  getAllElements() {
-    if (this.outerScope) {
-      return this.elements.concat(this.outerScope.getAllElements());
-    } else {
-      return this.elements;
-    }
-  }
-  getElement(name) {
-    const local = this.caseInsensitive ? this.elements.find((e) => e.name.toLowerCase() === name.toLowerCase()) : this.elements.find((e) => e.name === name);
-    if (local) {
-      return local;
-    }
-    if (this.outerScope) {
-      return this.outerScope.getElement(name);
-    }
-    return void 0;
-  }
-}
-class MapScope {
-  constructor(elements, outerScope, options) {
-    var _a;
-    this.elements = /* @__PURE__ */ new Map();
-    this.caseInsensitive = (_a = options === null || options === void 0 ? void 0 : options.caseInsensitive) !== null && _a !== void 0 ? _a : false;
-    for (const element of elements) {
-      const name = this.caseInsensitive ? element.name.toLowerCase() : element.name;
-      this.elements.set(name, element);
-    }
-    this.outerScope = outerScope;
-  }
-  getElement(name) {
-    const localName = this.caseInsensitive ? name.toLowerCase() : name;
-    const local = this.elements.get(localName);
-    if (local) {
-      return local;
-    }
-    if (this.outerScope) {
-      return this.outerScope.getElement(name);
-    }
-    return void 0;
-  }
-  getAllElements() {
-    let elementStream = stream(this.elements.values());
-    if (this.outerScope) {
-      elementStream = elementStream.concat(this.outerScope.getAllElements());
-    }
-    return elementStream;
-  }
-}
-export {
-  MapScope,
-  StreamScope
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/serializer/hydrator.mjs

@@ -1,256 +0,0 @@
-import { RootCstNodeImpl, CompositeCstNodeImpl, LeafCstNodeImpl } from "../parser/cst-node-builder.mjs";
-import { isAbstractElement } from "../languages/generated/ast.mjs";
-import { isAstNode, isReference, isRootCstNode, isCompositeCstNode, isLeafCstNode } from "../syntax-tree.mjs";
-import { streamAst } from "../utils/ast-utils.mjs";
-import { BiMap } from "../utils/collections.mjs";
-import { streamCst } from "../utils/cst-utils.mjs";
-class DefaultHydrator {
-  constructor(services) {
-    this.grammarElementIdMap = new BiMap();
-    this.tokenTypeIdMap = new BiMap();
-    this.grammar = services.Grammar;
-    this.lexer = services.parser.Lexer;
-    this.linker = services.references.Linker;
-  }
-  dehydrate(result) {
-    return {
-      lexerErrors: result.lexerErrors,
-      lexerReport: result.lexerReport ? this.dehydrateLexerReport(result.lexerReport) : void 0,
-      // We need to create shallow copies of the errors
-      // The original errors inherit from the `Error` class, which is not transferable across worker threads
-      parserErrors: result.parserErrors.map((e) => Object.assign(Object.assign({}, e), { message: e.message })),
-      value: this.dehydrateAstNode(result.value, this.createDehyrationContext(result.value))
-    };
-  }
-  dehydrateLexerReport(lexerReport) {
-    return lexerReport;
-  }
-  createDehyrationContext(node) {
-    const astNodes = /* @__PURE__ */ new Map();
-    const cstNodes = /* @__PURE__ */ new Map();
-    for (const astNode of streamAst(node)) {
-      astNodes.set(astNode, {});
-    }
-    if (node.$cstNode) {
-      for (const cstNode of streamCst(node.$cstNode)) {
-        cstNodes.set(cstNode, {});
-      }
-    }
-    return {
-      astNodes,
-      cstNodes
-    };
-  }
-  dehydrateAstNode(node, context) {
-    const obj = context.astNodes.get(node);
-    obj.$type = node.$type;
-    obj.$containerIndex = node.$containerIndex;
-    obj.$containerProperty = node.$containerProperty;
-    if (node.$cstNode !== void 0) {
-      obj.$cstNode = this.dehydrateCstNode(node.$cstNode, context);
-    }
-    for (const [name, value] of Object.entries(node)) {
-      if (name.startsWith("$")) {
-        continue;
-      }
-      if (Array.isArray(value)) {
-        const arr = [];
-        obj[name] = arr;
-        for (const item of value) {
-          if (isAstNode(item)) {
-            arr.push(this.dehydrateAstNode(item, context));
-          } else if (isReference(item)) {
-            arr.push(this.dehydrateReference(item, context));
-          } else {
-            arr.push(item);
-          }
-        }
-      } else if (isAstNode(value)) {
-        obj[name] = this.dehydrateAstNode(value, context);
-      } else if (isReference(value)) {
-        obj[name] = this.dehydrateReference(value, context);
-      } else if (value !== void 0) {
-        obj[name] = value;
-      }
-    }
-    return obj;
-  }
-  dehydrateReference(reference, context) {
-    const obj = {};
-    obj.$refText = reference.$refText;
-    if (reference.$refNode) {
-      obj.$refNode = context.cstNodes.get(reference.$refNode);
-    }
-    return obj;
-  }
-  dehydrateCstNode(node, context) {
-    const cstNode = context.cstNodes.get(node);
-    if (isRootCstNode(node)) {
-      cstNode.fullText = node.fullText;
-    } else {
-      cstNode.grammarSource = this.getGrammarElementId(node.grammarSource);
-    }
-    cstNode.hidden = node.hidden;
-    cstNode.astNode = context.astNodes.get(node.astNode);
-    if (isCompositeCstNode(node)) {
-      cstNode.content = node.content.map((child) => this.dehydrateCstNode(child, context));
-    } else if (isLeafCstNode(node)) {
-      cstNode.tokenType = node.tokenType.name;
-      cstNode.offset = node.offset;
-      cstNode.length = node.length;
-      cstNode.startLine = node.range.start.line;
-      cstNode.startColumn = node.range.start.character;
-      cstNode.endLine = node.range.end.line;
-      cstNode.endColumn = node.range.end.character;
-    }
-    return cstNode;
-  }
-  hydrate(result) {
-    const node = result.value;
-    const context = this.createHydrationContext(node);
-    if ("$cstNode" in node) {
-      this.hydrateCstNode(node.$cstNode, context);
-    }
-    return {
-      lexerErrors: result.lexerErrors,
-      lexerReport: result.lexerReport,
-      parserErrors: result.parserErrors,
-      value: this.hydrateAstNode(node, context)
-    };
-  }
-  createHydrationContext(node) {
-    const astNodes = /* @__PURE__ */ new Map();
-    const cstNodes = /* @__PURE__ */ new Map();
-    for (const astNode of streamAst(node)) {
-      astNodes.set(astNode, {});
-    }
-    let root;
-    if (node.$cstNode) {
-      for (const cstNode of streamCst(node.$cstNode)) {
-        let cst;
-        if ("fullText" in cstNode) {
-          cst = new RootCstNodeImpl(cstNode.fullText);
-          root = cst;
-        } else if ("content" in cstNode) {
-          cst = new CompositeCstNodeImpl();
-        } else if ("tokenType" in cstNode) {
-          cst = this.hydrateCstLeafNode(cstNode);
-        }
-        if (cst) {
-          cstNodes.set(cstNode, cst);
-          cst.root = root;
-        }
-      }
-    }
-    return {
-      astNodes,
-      cstNodes
-    };
-  }
-  hydrateAstNode(node, context) {
-    const astNode = context.astNodes.get(node);
-    astNode.$type = node.$type;
-    astNode.$containerIndex = node.$containerIndex;
-    astNode.$containerProperty = node.$containerProperty;
-    if (node.$cstNode) {
-      astNode.$cstNode = context.cstNodes.get(node.$cstNode);
-    }
-    for (const [name, value] of Object.entries(node)) {
-      if (name.startsWith("$")) {
-        continue;
-      }
-      if (Array.isArray(value)) {
-        const arr = [];
-        astNode[name] = arr;
-        for (const item of value) {
-          if (isAstNode(item)) {
-            arr.push(this.setParent(this.hydrateAstNode(item, context), astNode));
-          } else if (isReference(item)) {
-            arr.push(this.hydrateReference(item, astNode, name, context));
-          } else {
-            arr.push(item);
-          }
-        }
-      } else if (isAstNode(value)) {
-        astNode[name] = this.setParent(this.hydrateAstNode(value, context), astNode);
-      } else if (isReference(value)) {
-        astNode[name] = this.hydrateReference(value, astNode, name, context);
-      } else if (value !== void 0) {
-        astNode[name] = value;
-      }
-    }
-    return astNode;
-  }
-  setParent(node, parent) {
-    node.$container = parent;
-    return node;
-  }
-  hydrateReference(reference, node, name, context) {
-    return this.linker.buildReference(node, name, context.cstNodes.get(reference.$refNode), reference.$refText);
-  }
-  hydrateCstNode(cstNode, context, num = 0) {
-    const cstNodeObj = context.cstNodes.get(cstNode);
-    if (typeof cstNode.grammarSource === "number") {
-      cstNodeObj.grammarSource = this.getGrammarElement(cstNode.grammarSource);
-    }
-    cstNodeObj.astNode = context.astNodes.get(cstNode.astNode);
-    if (isCompositeCstNode(cstNodeObj)) {
-      for (const child of cstNode.content) {
-        const hydrated = this.hydrateCstNode(child, context, num++);
-        cstNodeObj.content.push(hydrated);
-      }
-    }
-    return cstNodeObj;
-  }
-  hydrateCstLeafNode(cstNode) {
-    const tokenType = this.getTokenType(cstNode.tokenType);
-    const offset = cstNode.offset;
-    const length = cstNode.length;
-    const startLine = cstNode.startLine;
-    const startColumn = cstNode.startColumn;
-    const endLine = cstNode.endLine;
-    const endColumn = cstNode.endColumn;
-    const hidden = cstNode.hidden;
-    const node = new LeafCstNodeImpl(offset, length, {
-      start: {
-        line: startLine,
-        character: startColumn
-      },
-      end: {
-        line: endLine,
-        character: endColumn
-      }
-    }, tokenType, hidden);
-    return node;
-  }
-  getTokenType(name) {
-    return this.lexer.definition[name];
-  }
-  getGrammarElementId(node) {
-    if (!node) {
-      return void 0;
-    }
-    if (this.grammarElementIdMap.size === 0) {
-      this.createGrammarElementIdMap();
-    }
-    return this.grammarElementIdMap.get(node);
-  }
-  getGrammarElement(id) {
-    if (this.grammarElementIdMap.size === 0) {
-      this.createGrammarElementIdMap();
-    }
-    const element = this.grammarElementIdMap.getKey(id);
-    return element;
-  }
-  createGrammarElementIdMap() {
-    let id = 0;
-    for (const element of streamAst(this.grammar)) {
-      if (isAbstractElement(element)) {
-        this.grammarElementIdMap.set(element, id++);
-      }
-    }
-  }
-}
-export {
-  DefaultHydrator
-};