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

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

@@ -0,0 +1,377 @@
+import { assertUnreachable } from "./errors.mjs";
+import { isTerminalRule, isInferredType, isAction, isParserRule, isInterface, isType, isRuleCall, isTerminalAlternatives, isTerminalGroup, isCharacterRange, isTerminalRuleCall, isNegatedToken, isUntilToken, isRegexToken, isWildcard, isAssignment, isSimpleType, isKeyword, isReturnType } from "../languages/generated/ast.mjs";
+import { isCompositeCstNode } from "../syntax-tree.mjs";
+import { streamAllContents, getContainerOfType } from "./ast-utils.mjs";
+import { streamCst } from "./cst-utils.mjs";
+import { escapeRegExp, isWhitespace } from "./regexp-utils.mjs";
+function getEntryRule(grammar) {
+  return grammar.rules.find((e) => isParserRule(e) && e.entry);
+}
+function getHiddenRules(grammar) {
+  return grammar.rules.filter((e) => isTerminalRule(e) && e.hidden);
+}
+function getAllReachableRules(grammar, allTerminals) {
+  const ruleNames = /* @__PURE__ */ new Set();
+  const entryRule = getEntryRule(grammar);
+  if (!entryRule) {
+    return new Set(grammar.rules);
+  }
+  const topMostRules = [entryRule].concat(getHiddenRules(grammar));
+  for (const rule of topMostRules) {
+    ruleDfs(rule, ruleNames, allTerminals);
+  }
+  const rules = /* @__PURE__ */ new Set();
+  for (const rule of grammar.rules) {
+    if (ruleNames.has(rule.name) || isTerminalRule(rule) && rule.hidden) {
+      rules.add(rule);
+    }
+  }
+  return rules;
+}
+function ruleDfs(rule, visitedSet, allTerminals) {
+  visitedSet.add(rule.name);
+  streamAllContents(rule).forEach((node) => {
+    if (isRuleCall(node) || allTerminals) {
+      const refRule = node.rule.ref;
+      if (refRule && !visitedSet.has(refRule.name)) {
+        ruleDfs(refRule, visitedSet, allTerminals);
+      }
+    }
+  });
+}
+function getCrossReferenceTerminal(crossRef) {
+  if (crossRef.terminal) {
+    return crossRef.terminal;
+  } else if (crossRef.type.ref) {
+    const nameAssigment = findNameAssignment(crossRef.type.ref);
+    return nameAssigment === null || nameAssigment === void 0 ? void 0 : nameAssigment.terminal;
+  }
+  return void 0;
+}
+function isCommentTerminal(terminalRule) {
+  return terminalRule.hidden && !isWhitespace(terminalRegex(terminalRule));
+}
+function findNodesForProperty(node, property) {
+  if (!node || !property) {
+    return [];
+  }
+  return findNodesForPropertyInternal(node, property, node.astNode, true);
+}
+function findNodeForProperty(node, property, index) {
+  if (!node || !property) {
+    return void 0;
+  }
+  const nodes = findNodesForPropertyInternal(node, property, node.astNode, true);
+  if (nodes.length === 0) {
+    return void 0;
+  }
+  if (index !== void 0) {
+    index = Math.max(0, Math.min(index, nodes.length - 1));
+  } else {
+    index = 0;
+  }
+  return nodes[index];
+}
+function findNodesForPropertyInternal(node, property, element, first) {
+  if (!first) {
+    const nodeFeature = getContainerOfType(node.grammarSource, isAssignment);
+    if (nodeFeature && nodeFeature.feature === property) {
+      return [node];
+    }
+  }
+  if (isCompositeCstNode(node) && node.astNode === element) {
+    return node.content.flatMap((e) => findNodesForPropertyInternal(e, property, element, false));
+  }
+  return [];
+}
+function findNodeForKeyword(node, keyword, index) {
+  if (!node) {
+    return void 0;
+  }
+  const nodes = findNodesForKeywordInternal(node, keyword, node === null || node === void 0 ? void 0 : node.astNode);
+  if (nodes.length === 0) {
+    return void 0;
+  }
+  if (index !== void 0) {
+    index = Math.max(0, Math.min(index, nodes.length - 1));
+  } else {
+    index = 0;
+  }
+  return nodes[index];
+}
+function findNodesForKeywordInternal(node, keyword, element) {
+  if (node.astNode !== element) {
+    return [];
+  }
+  if (isKeyword(node.grammarSource) && node.grammarSource.value === keyword) {
+    return [node];
+  }
+  const treeIterator = streamCst(node).iterator();
+  let result;
+  const keywordNodes = [];
+  do {
+    result = treeIterator.next();
+    if (!result.done) {
+      const childNode = result.value;
+      if (childNode.astNode === element) {
+        if (isKeyword(childNode.grammarSource) && childNode.grammarSource.value === keyword) {
+          keywordNodes.push(childNode);
+        }
+      } else {
+        treeIterator.prune();
+      }
+    }
+  } while (!result.done);
+  return keywordNodes;
+}
+function findAssignment(cstNode) {
+  var _a;
+  const astNode = cstNode.astNode;
+  while (astNode === ((_a = cstNode.container) === null || _a === void 0 ? void 0 : _a.astNode)) {
+    const assignment = getContainerOfType(cstNode.grammarSource, isAssignment);
+    if (assignment) {
+      return assignment;
+    }
+    cstNode = cstNode.container;
+  }
+  return void 0;
+}
+function findNameAssignment(type) {
+  let startNode = type;
+  if (isInferredType(startNode)) {
+    if (isAction(startNode.$container)) {
+      startNode = startNode.$container.$container;
+    } else if (isParserRule(startNode.$container)) {
+      startNode = startNode.$container;
+    } else {
+      assertUnreachable(startNode.$container);
+    }
+  }
+  return findNameAssignmentInternal(type, startNode, /* @__PURE__ */ new Map());
+}
+function findNameAssignmentInternal(type, startNode, cache) {
+  var _a;
+  function go(node, refType) {
+    let childAssignment = void 0;
+    const parentAssignment = getContainerOfType(node, isAssignment);
+    if (!parentAssignment) {
+      childAssignment = findNameAssignmentInternal(refType, refType, cache);
+    }
+    cache.set(type, childAssignment);
+    return childAssignment;
+  }
+  if (cache.has(type)) {
+    return cache.get(type);
+  }
+  cache.set(type, void 0);
+  for (const node of streamAllContents(startNode)) {
+    if (isAssignment(node) && node.feature.toLowerCase() === "name") {
+      cache.set(type, node);
+      return node;
+    } else if (isRuleCall(node) && isParserRule(node.rule.ref)) {
+      return go(node, node.rule.ref);
+    } else if (isSimpleType(node) && ((_a = node.typeRef) === null || _a === void 0 ? void 0 : _a.ref)) {
+      return go(node, node.typeRef.ref);
+    }
+  }
+  return void 0;
+}
+function isDataTypeRule(rule) {
+  return isDataTypeRuleInternal(rule, /* @__PURE__ */ new Set());
+}
+function isDataTypeRuleInternal(rule, visited) {
+  if (visited.has(rule)) {
+    return true;
+  } else {
+    visited.add(rule);
+  }
+  for (const node of streamAllContents(rule)) {
+    if (isRuleCall(node)) {
+      if (!node.rule.ref) {
+        return false;
+      }
+      if (isParserRule(node.rule.ref) && !isDataTypeRuleInternal(node.rule.ref, visited)) {
+        return false;
+      }
+    } else if (isAssignment(node)) {
+      return false;
+    } else if (isAction(node)) {
+      return false;
+    }
+  }
+  return Boolean(rule.definition);
+}
+function getExplicitRuleType(rule) {
+  if (rule.inferredType) {
+    return rule.inferredType.name;
+  } else if (rule.dataType) {
+    return rule.dataType;
+  } else if (rule.returnType) {
+    const refType = rule.returnType.ref;
+    if (refType) {
+      if (isParserRule(refType)) {
+        return refType.name;
+      } else if (isInterface(refType) || isType(refType)) {
+        return refType.name;
+      }
+    }
+  }
+  return void 0;
+}
+function getTypeName(type) {
+  var _a;
+  if (isParserRule(type)) {
+    return isDataTypeRule(type) ? type.name : (_a = getExplicitRuleType(type)) !== null && _a !== void 0 ? _a : type.name;
+  } else if (isInterface(type) || isType(type) || isReturnType(type)) {
+    return type.name;
+  } else if (isAction(type)) {
+    const actionType = getActionType(type);
+    if (actionType) {
+      return actionType;
+    }
+  } else if (isInferredType(type)) {
+    return type.name;
+  }
+  throw new Error("Cannot get name of Unknown Type");
+}
+function getActionType(action) {
+  var _a;
+  if (action.inferredType) {
+    return action.inferredType.name;
+  } else if ((_a = action.type) === null || _a === void 0 ? void 0 : _a.ref) {
+    return getTypeName(action.type.ref);
+  }
+  return void 0;
+}
+function getRuleType(rule) {
+  var _a, _b, _c;
+  if (isTerminalRule(rule)) {
+    return (_b = (_a = rule.type) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : "string";
+  } else {
+    return (_c = getExplicitRuleType(rule)) !== null && _c !== void 0 ? _c : rule.name;
+  }
+}
+function terminalRegex(terminalRule) {
+  const flags = {
+    s: false,
+    i: false,
+    u: false
+  };
+  const source = abstractElementToRegex(terminalRule.definition, flags);
+  const flagText = Object.entries(flags).filter(([, value]) => value).map(([name]) => name).join("");
+  return new RegExp(source, flagText);
+}
+const WILDCARD = /[\s\S]/.source;
+function abstractElementToRegex(element, flags) {
+  if (isTerminalAlternatives(element)) {
+    return terminalAlternativesToRegex(element);
+  } else if (isTerminalGroup(element)) {
+    return terminalGroupToRegex(element);
+  } else if (isCharacterRange(element)) {
+    return characterRangeToRegex(element);
+  } else if (isTerminalRuleCall(element)) {
+    const rule = element.rule.ref;
+    if (!rule) {
+      throw new Error("Missing rule reference.");
+    }
+    return withCardinality(abstractElementToRegex(rule.definition), {
+      cardinality: element.cardinality,
+      lookahead: element.lookahead
+    });
+  } else if (isNegatedToken(element)) {
+    return negateTokenToRegex(element);
+  } else if (isUntilToken(element)) {
+    return untilTokenToRegex(element);
+  } else if (isRegexToken(element)) {
+    const lastSlash = element.regex.lastIndexOf("/");
+    const source = element.regex.substring(1, lastSlash);
+    const regexFlags = element.regex.substring(lastSlash + 1);
+    if (flags) {
+      flags.i = regexFlags.includes("i");
+      flags.s = regexFlags.includes("s");
+      flags.u = regexFlags.includes("u");
+    }
+    return withCardinality(source, {
+      cardinality: element.cardinality,
+      lookahead: element.lookahead,
+      wrap: false
+    });
+  } else if (isWildcard(element)) {
+    return withCardinality(WILDCARD, {
+      cardinality: element.cardinality,
+      lookahead: element.lookahead
+    });
+  } else {
+    throw new Error(`Invalid terminal element: ${element === null || element === void 0 ? void 0 : element.$type}`);
+  }
+}
+function terminalAlternativesToRegex(alternatives) {
+  return withCardinality(alternatives.elements.map((e) => abstractElementToRegex(e)).join("|"), {
+    cardinality: alternatives.cardinality,
+    lookahead: alternatives.lookahead
+  });
+}
+function terminalGroupToRegex(group) {
+  return withCardinality(group.elements.map((e) => abstractElementToRegex(e)).join(""), {
+    cardinality: group.cardinality,
+    lookahead: group.lookahead
+  });
+}
+function untilTokenToRegex(until) {
+  return withCardinality(`${WILDCARD}*?${abstractElementToRegex(until.terminal)}`, {
+    cardinality: until.cardinality,
+    lookahead: until.lookahead
+  });
+}
+function negateTokenToRegex(negate) {
+  return withCardinality(`(?!${abstractElementToRegex(negate.terminal)})${WILDCARD}*?`, {
+    cardinality: negate.cardinality,
+    lookahead: negate.lookahead
+  });
+}
+function characterRangeToRegex(range) {
+  if (range.right) {
+    return withCardinality(`[${keywordToRegex(range.left)}-${keywordToRegex(range.right)}]`, {
+      cardinality: range.cardinality,
+      lookahead: range.lookahead,
+      wrap: false
+    });
+  }
+  return withCardinality(keywordToRegex(range.left), {
+    cardinality: range.cardinality,
+    lookahead: range.lookahead,
+    wrap: false
+  });
+}
+function keywordToRegex(keyword) {
+  return escapeRegExp(keyword.value);
+}
+function withCardinality(regex, options) {
+  var _a;
+  if (options.wrap !== false || options.lookahead) {
+    regex = `(${(_a = options.lookahead) !== null && _a !== void 0 ? _a : ""}${regex})`;
+  }
+  if (options.cardinality) {
+    return `${regex}${options.cardinality}`;
+  }
+  return regex;
+}
+export {
+  findAssignment,
+  findNameAssignment,
+  findNodeForKeyword,
+  findNodeForProperty,
+  findNodesForKeywordInternal,
+  findNodesForProperty,
+  getActionType,
+  getAllReachableRules,
+  getCrossReferenceTerminal,
+  getEntryRule,
+  getExplicitRuleType,
+  getHiddenRules,
+  getRuleType,
+  getTypeName,
+  isCommentTerminal,
+  isDataTypeRule,
+  terminalRegex
+};

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

@@ -0,0 +1,56 @@
+import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
+function delayNextTick() {
+  return new Promise((resolve) => {
+    if (typeof setImmediate === "undefined") {
+      setTimeout(resolve, 0);
+    } else {
+      setImmediate(resolve);
+    }
+  });
+}
+let lastTick = 0;
+let globalInterruptionPeriod = 10;
+function startCancelableOperation() {
+  lastTick = performance.now();
+  return new cancellationExports.CancellationTokenSource();
+}
+const OperationCancelled = Symbol("OperationCancelled");
+function isOperationCancelled(err) {
+  return err === OperationCancelled;
+}
+async function interruptAndCheck(token) {
+  if (token === cancellationExports.CancellationToken.None) {
+    return;
+  }
+  const current = performance.now();
+  if (current - lastTick >= globalInterruptionPeriod) {
+    lastTick = current;
+    await delayNextTick();
+    lastTick = performance.now();
+  }
+  if (token.isCancellationRequested) {
+    throw OperationCancelled;
+  }
+}
+class Deferred {
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = (arg) => {
+        resolve(arg);
+        return this;
+      };
+      this.reject = (err) => {
+        reject(err);
+        return this;
+      };
+    });
+  }
+}
+export {
+  Deferred,
+  OperationCancelled,
+  delayNextTick,
+  interruptAndCheck,
+  isOperationCancelled,
+  startCancelableOperation
+};

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

@@ -0,0 +1,239 @@
+import { RegExpParser } from "../../../../../@chevrotain_regexp-to-ast@11.0.3/node_modules/@chevrotain/regexp-to-ast/lib/src/regexp-parser.mjs";
+import { BaseRegExpVisitor } from "../../../../../@chevrotain_regexp-to-ast@11.0.3/node_modules/@chevrotain/regexp-to-ast/lib/src/base-regexp-visitor.mjs";
+const NEWLINE_REGEXP = /\r?\n/gm;
+const regexpParser = new RegExpParser();
+class TerminalRegExpVisitor extends BaseRegExpVisitor {
+  constructor() {
+    super(...arguments);
+    this.isStarting = true;
+    this.endRegexpStack = [];
+    this.multiline = false;
+  }
+  get endRegex() {
+    return this.endRegexpStack.join("");
+  }
+  reset(regex) {
+    this.multiline = false;
+    this.regex = regex;
+    this.startRegexp = "";
+    this.isStarting = true;
+    this.endRegexpStack = [];
+  }
+  visitGroup(node) {
+    if (node.quantifier) {
+      this.isStarting = false;
+      this.endRegexpStack = [];
+    }
+  }
+  visitCharacter(node) {
+    const char = String.fromCharCode(node.value);
+    if (!this.multiline && char === "\n") {
+      this.multiline = true;
+    }
+    if (node.quantifier) {
+      this.isStarting = false;
+      this.endRegexpStack = [];
+    } else {
+      const escapedChar = escapeRegExp(char);
+      this.endRegexpStack.push(escapedChar);
+      if (this.isStarting) {
+        this.startRegexp += escapedChar;
+      }
+    }
+  }
+  visitSet(node) {
+    if (!this.multiline) {
+      const set = this.regex.substring(node.loc.begin, node.loc.end);
+      const regex = new RegExp(set);
+      this.multiline = Boolean("\n".match(regex));
+    }
+    if (node.quantifier) {
+      this.isStarting = false;
+      this.endRegexpStack = [];
+    } else {
+      const set = this.regex.substring(node.loc.begin, node.loc.end);
+      this.endRegexpStack.push(set);
+      if (this.isStarting) {
+        this.startRegexp += set;
+      }
+    }
+  }
+  visitChildren(node) {
+    if (node.type === "Group") {
+      const group = node;
+      if (group.quantifier) {
+        return;
+      }
+    }
+    super.visitChildren(node);
+  }
+}
+const visitor = new TerminalRegExpVisitor();
+function isMultilineComment(regexp) {
+  try {
+    if (typeof regexp === "string") {
+      regexp = new RegExp(regexp);
+    }
+    regexp = regexp.toString();
+    visitor.reset(regexp);
+    visitor.visit(regexpParser.pattern(regexp));
+    return visitor.multiline;
+  } catch (_a) {
+    return false;
+  }
+}
+const whitespaceCharacters = "\f\n\r	\v              \u2028\u2029  　\uFEFF".split("");
+function isWhitespace(value) {
+  const regexp = typeof value === "string" ? new RegExp(value) : value;
+  return whitespaceCharacters.some((ws) => regexp.test(ws));
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getCaseInsensitivePattern(keyword) {
+  return Array.prototype.map.call(keyword, (letter) => /\w/.test(letter) ? `[${letter.toLowerCase()}${letter.toUpperCase()}]` : escapeRegExp(letter)).join("");
+}
+function partialMatches(regex, input) {
+  const partial = partialRegExp(regex);
+  const match = input.match(partial);
+  return !!match && match[0].length > 0;
+}
+function partialRegExp(regex) {
+  if (typeof regex === "string") {
+    regex = new RegExp(regex);
+  }
+  const re = regex, source = regex.source;
+  let i = 0;
+  function process() {
+    let result = "", tmp;
+    function appendRaw(nbChars) {
+      result += source.substr(i, nbChars);
+      i += nbChars;
+    }
+    function appendOptional(nbChars) {
+      result += "(?:" + source.substr(i, nbChars) + "|$)";
+      i += nbChars;
+    }
+    while (i < source.length) {
+      switch (source[i]) {
+        case "\\":
+          switch (source[i + 1]) {
+            case "c":
+              appendOptional(3);
+              break;
+            case "x":
+              appendOptional(4);
+              break;
+            case "u":
+              if (re.unicode) {
+                if (source[i + 2] === "{") {
+                  appendOptional(source.indexOf("}", i) - i + 1);
+                } else {
+                  appendOptional(6);
+                }
+              } else {
+                appendOptional(2);
+              }
+              break;
+            case "p":
+            case "P":
+              if (re.unicode) {
+                appendOptional(source.indexOf("}", i) - i + 1);
+              } else {
+                appendOptional(2);
+              }
+              break;
+            case "k":
+              appendOptional(source.indexOf(">", i) - i + 1);
+              break;
+            default:
+              appendOptional(2);
+              break;
+          }
+          break;
+        case "[":
+          tmp = /\[(?:\\.|.)*?\]/g;
+          tmp.lastIndex = i;
+          tmp = tmp.exec(source) || [];
+          appendOptional(tmp[0].length);
+          break;
+        case "|":
+        case "^":
+        case "$":
+        case "*":
+        case "+":
+        case "?":
+          appendRaw(1);
+          break;
+        case "{":
+          tmp = /\{\d+,?\d*\}/g;
+          tmp.lastIndex = i;
+          tmp = tmp.exec(source);
+          if (tmp) {
+            appendRaw(tmp[0].length);
+          } else {
+            appendOptional(1);
+          }
+          break;
+        case "(":
+          if (source[i + 1] === "?") {
+            switch (source[i + 2]) {
+              case ":":
+                result += "(?:";
+                i += 3;
+                result += process() + "|$)";
+                break;
+              case "=":
+                result += "(?=";
+                i += 3;
+                result += process() + ")";
+                break;
+              case "!":
+                tmp = i;
+                i += 3;
+                process();
+                result += source.substr(tmp, i - tmp);
+                break;
+              case "<":
+                switch (source[i + 3]) {
+                  case "=":
+                  case "!":
+                    tmp = i;
+                    i += 4;
+                    process();
+                    result += source.substr(tmp, i - tmp);
+                    break;
+                  default:
+                    appendRaw(source.indexOf(">", i) - i + 1);
+                    result += process() + "|$)";
+                    break;
+                }
+                break;
+            }
+          } else {
+            appendRaw(1);
+            result += process() + "|$)";
+          }
+          break;
+        case ")":
+          ++i;
+          return result;
+        default:
+          appendOptional(1);
+          break;
+      }
+    }
+    return result;
+  }
+  return new RegExp(process(), regex.flags);
+}
+export {
+  NEWLINE_REGEXP,
+  escapeRegExp,
+  getCaseInsensitivePattern,
+  isMultilineComment,
+  isWhitespace,
+  partialMatches,
+  partialRegExp,
+  whitespaceCharacters
+};