@elmethis/core 1.0.0-alpha.146 → 1.0.0-alpha.148

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/collections.mjs

@@ -0,0 +1,177 @@
+import { Reduction, stream } from "./stream.mjs";
+class MultiMap {
+  constructor(elements) {
+    this.map = /* @__PURE__ */ new Map();
+    if (elements) {
+      for (const [key, value] of elements) {
+        this.add(key, value);
+      }
+    }
+  }
+  /**
+   * The total number of values in the multimap.
+   */
+  get size() {
+    return Reduction.sum(stream(this.map.values()).map((a) => a.length));
+  }
+  /**
+   * Clear all entries in the multimap.
+   */
+  clear() {
+    this.map.clear();
+  }
+  /**
+   * Operates differently depending on whether a `value` is given:
+   *  * With a value, this method deletes the specific key / value pair from the multimap.
+   *  * Without a value, all values associated with the given key are deleted.
+   *
+   * @returns `true` if a value existed and has been removed, or `false` if the specified
+   *     key / value does not exist.
+   */
+  delete(key, value) {
+    if (value === void 0) {
+      return this.map.delete(key);
+    } else {
+      const values = this.map.get(key);
+      if (values) {
+        const index = values.indexOf(value);
+        if (index >= 0) {
+          if (values.length === 1) {
+            this.map.delete(key);
+          } else {
+            values.splice(index, 1);
+          }
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+  /**
+   * Returns an array of all values associated with the given key. If no value exists,
+   * an empty array is returned.
+   *
+   * _Note:_ The returned array is assumed not to be modified. Use the `set` method to add a
+   * value and `delete` to remove a value from the multimap.
+   */
+  get(key) {
+    var _a;
+    return (_a = this.map.get(key)) !== null && _a !== void 0 ? _a : [];
+  }
+  /**
+   * Operates differently depending on whether a `value` is given:
+   *  * With a value, this method returns `true` if the specific key / value pair is present in the multimap.
+   *  * Without a value, this method returns `true` if the given key is present in the multimap.
+   */
+  has(key, value) {
+    if (value === void 0) {
+      return this.map.has(key);
+    } else {
+      const values = this.map.get(key);
+      if (values) {
+        return values.indexOf(value) >= 0;
+      }
+      return false;
+    }
+  }
+  /**
+   * Add the given key / value pair to the multimap.
+   */
+  add(key, value) {
+    if (this.map.has(key)) {
+      this.map.get(key).push(value);
+    } else {
+      this.map.set(key, [value]);
+    }
+    return this;
+  }
+  /**
+   * Add the given set of key / value pairs to the multimap.
+   */
+  addAll(key, values) {
+    if (this.map.has(key)) {
+      this.map.get(key).push(...values);
+    } else {
+      this.map.set(key, Array.from(values));
+    }
+    return this;
+  }
+  /**
+   * Invokes the given callback function for every key / value pair in the multimap.
+   */
+  forEach(callbackfn) {
+    this.map.forEach((array, key) => array.forEach((value) => callbackfn(value, key, this)));
+  }
+  /**
+   * Returns an iterator of key, value pairs for every entry in the map.
+   */
+  [Symbol.iterator]() {
+    return this.entries().iterator();
+  }
+  /**
+   * Returns a stream of key, value pairs for every entry in the map.
+   */
+  entries() {
+    return stream(this.map.entries()).flatMap(([key, array]) => array.map((value) => [key, value]));
+  }
+  /**
+   * Returns a stream of keys in the map.
+   */
+  keys() {
+    return stream(this.map.keys());
+  }
+  /**
+   * Returns a stream of values in the map.
+   */
+  values() {
+    return stream(this.map.values()).flat();
+  }
+  /**
+   * Returns a stream of key, value set pairs for every key in the map.
+   */
+  entriesGroupedByKey() {
+    return stream(this.map.entries());
+  }
+}
+class BiMap {
+  get size() {
+    return this.map.size;
+  }
+  constructor(elements) {
+    this.map = /* @__PURE__ */ new Map();
+    this.inverse = /* @__PURE__ */ new Map();
+    if (elements) {
+      for (const [key, value] of elements) {
+        this.set(key, value);
+      }
+    }
+  }
+  clear() {
+    this.map.clear();
+    this.inverse.clear();
+  }
+  set(key, value) {
+    this.map.set(key, value);
+    this.inverse.set(value, key);
+    return this;
+  }
+  get(key) {
+    return this.map.get(key);
+  }
+  getKey(value) {
+    return this.inverse.get(value);
+  }
+  delete(key) {
+    const value = this.map.get(key);
+    if (value !== void 0) {
+      this.map.delete(key);
+      this.inverse.delete(value);
+      return true;
+    }
+    return false;
+  }
+}
+export {
+  BiMap,
+  MultiMap
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/cst-utils.mjs

@@ -0,0 +1,126 @@
+import { isCompositeCstNode, isRootCstNode, isLeafCstNode } from "../syntax-tree.mjs";
+import { TreeStreamImpl } from "./stream.mjs";
+function streamCst(node) {
+  return new TreeStreamImpl(node, (element) => {
+    if (isCompositeCstNode(element)) {
+      return element.content;
+    } else {
+      return [];
+    }
+  }, { includeRoot: true });
+}
+function isChildNode(child, parent) {
+  while (child.container) {
+    child = child.container;
+    if (child === parent) {
+      return true;
+    }
+  }
+  return false;
+}
+function tokenToRange(token) {
+  return {
+    start: {
+      character: token.startColumn - 1,
+      line: token.startLine - 1
+    },
+    end: {
+      character: token.endColumn,
+      // endColumn uses the correct index
+      line: token.endLine - 1
+    }
+  };
+}
+function toDocumentSegment(node) {
+  if (!node) {
+    return void 0;
+  }
+  const { offset, end, range } = node;
+  return {
+    range,
+    offset,
+    end,
+    length: end - offset
+  };
+}
+var RangeComparison;
+(function(RangeComparison2) {
+  RangeComparison2[RangeComparison2["Before"] = 0] = "Before";
+  RangeComparison2[RangeComparison2["After"] = 1] = "After";
+  RangeComparison2[RangeComparison2["OverlapFront"] = 2] = "OverlapFront";
+  RangeComparison2[RangeComparison2["OverlapBack"] = 3] = "OverlapBack";
+  RangeComparison2[RangeComparison2["Inside"] = 4] = "Inside";
+  RangeComparison2[RangeComparison2["Outside"] = 5] = "Outside";
+})(RangeComparison || (RangeComparison = {}));
+function compareRange(range, to) {
+  if (range.end.line < to.start.line || range.end.line === to.start.line && range.end.character <= to.start.character) {
+    return RangeComparison.Before;
+  } else if (range.start.line > to.end.line || range.start.line === to.end.line && range.start.character >= to.end.character) {
+    return RangeComparison.After;
+  }
+  const startInside = range.start.line > to.start.line || range.start.line === to.start.line && range.start.character >= to.start.character;
+  const endInside = range.end.line < to.end.line || range.end.line === to.end.line && range.end.character <= to.end.character;
+  if (startInside && endInside) {
+    return RangeComparison.Inside;
+  } else if (startInside) {
+    return RangeComparison.OverlapBack;
+  } else if (endInside) {
+    return RangeComparison.OverlapFront;
+  } else {
+    return RangeComparison.Outside;
+  }
+}
+function inRange(range, to) {
+  const comparison = compareRange(range, to);
+  return comparison > RangeComparison.After;
+}
+const DefaultNameRegexp = /^[\w\p{L}]$/u;
+function findCommentNode(cstNode, commentNames) {
+  if (cstNode) {
+    const previous = getPreviousNode(cstNode, true);
+    if (previous && isCommentNode(previous, commentNames)) {
+      return previous;
+    }
+    if (isRootCstNode(cstNode)) {
+      const endIndex = cstNode.content.findIndex((e) => !e.hidden);
+      for (let i = endIndex - 1; i >= 0; i--) {
+        const child = cstNode.content[i];
+        if (isCommentNode(child, commentNames)) {
+          return child;
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function isCommentNode(cstNode, commentNames) {
+  return isLeafCstNode(cstNode) && commentNames.includes(cstNode.tokenType.name);
+}
+function getPreviousNode(node, hidden = true) {
+  while (node.container) {
+    const parent = node.container;
+    let index = parent.content.indexOf(node);
+    while (index > 0) {
+      index--;
+      const previous = parent.content[index];
+      if (hidden || !previous.hidden) {
+        return previous;
+      }
+    }
+    node = parent;
+  }
+  return void 0;
+}
+export {
+  DefaultNameRegexp,
+  RangeComparison,
+  compareRange,
+  findCommentNode,
+  getPreviousNode,
+  inRange,
+  isChildNode,
+  isCommentNode,
+  streamCst,
+  toDocumentSegment,
+  tokenToRange
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/disposable.mjs

@@ -0,0 +1,12 @@
+var Disposable;
+(function(Disposable2) {
+  function create(callback) {
+    return {
+      dispose: async () => await callback()
+    };
+  }
+  Disposable2.create = create;
+})(Disposable || (Disposable = {}));
+export {
+  Disposable
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/errors.mjs

@@ -0,0 +1,12 @@
+class ErrorWithLocation extends Error {
+  constructor(node, message) {
+    super(node ? `${message} at ${node.range.start.line}:${node.range.start.character}` : message);
+  }
+}
+function assertUnreachable(_) {
+  throw new Error("Error! The input value was not handled.");
+}
+export {
+  ErrorWithLocation,
+  assertUnreachable
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/grammar-loader.mjs

@@ -0,0 +1,33 @@
+import { createDefaultSharedCoreModule, createDefaultCoreModule } from "../default-module.mjs";
+import { inject } from "../dependency-injection.mjs";
+import { LangiumGrammarAstReflection } from "../languages/generated/ast.mjs";
+import { EmptyFileSystem } from "../workspace/file-system-provider.mjs";
+import "./uri-utils.mjs";
+import { URI } from "../../../../../vscode-uri@3.0.8/node_modules/vscode-uri/lib/esm/index.mjs";
+const minimalGrammarModule = {
+  Grammar: () => void 0,
+  LanguageMetaData: () => ({
+    caseInsensitive: false,
+    fileExtensions: [".langium"],
+    languageId: "langium"
+  })
+};
+const minimalSharedGrammarModule = {
+  AstReflection: () => new LangiumGrammarAstReflection()
+};
+function createMinimalGrammarServices() {
+  const shared = inject(createDefaultSharedCoreModule(EmptyFileSystem), minimalSharedGrammarModule);
+  const grammar = inject(createDefaultCoreModule({ shared }), minimalGrammarModule);
+  shared.ServiceRegistry.register(grammar);
+  return grammar;
+}
+function loadGrammarFromJson(json) {
+  var _a;
+  const services = createMinimalGrammarServices();
+  const astNode = services.serializer.JsonSerializer.deserialize(json);
+  services.shared.workspace.LangiumDocumentFactory.fromModel(astNode, URI.parse(`memory://${(_a = astNode.name) !== null && _a !== void 0 ? _a : "grammar"}.langium`));
+  return astNode;
+}
+export {
+  loadGrammarFromJson
+};