@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/utils/grammar-utils.mjs

@@ -1,377 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,239 +0,0 @@
-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
-};