@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/parser/parser-builder-base.mjs

@@ -1,336 +0,0 @@
-import { EMPTY_ALT } from "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/parser.mjs";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/lexer_public.mjs";
-import { EOF } from "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens_public.mjs";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/lookahead.mjs";
-import "lodash-es";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/errors_public.mjs";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/exceptions_public.mjs";
-import { isParserRule, isKeyword, isAction, isAssignment, isCrossReference, isRuleCall, isAlternatives, isUnorderedGroup, isGroup, isEndOfFile, isTerminalRule, isDisjunction, isConjunction, isNegation, isParameterReference, isBooleanLiteral } from "../languages/generated/ast.mjs";
-import { ErrorWithLocation, assertUnreachable } from "../utils/errors.mjs";
-import { stream } from "../utils/stream.mjs";
-import { getAllReachableRules, getTypeName, findNameAssignment } from "../utils/grammar-utils.mjs";
-function createParser(grammar, parser, tokens) {
-  const parserContext = {
-    parser,
-    tokens,
-    ruleNames: /* @__PURE__ */ new Map()
-  };
-  buildRules(parserContext, grammar);
-  return parser;
-}
-function buildRules(parserContext, grammar) {
-  const reachable = getAllReachableRules(grammar, false);
-  const parserRules = stream(grammar.rules).filter(isParserRule).filter((rule) => reachable.has(rule));
-  for (const rule of parserRules) {
-    const ctx = Object.assign(Object.assign({}, parserContext), { consume: 1, optional: 1, subrule: 1, many: 1, or: 1 });
-    parserContext.parser.rule(rule, buildElement(ctx, rule.definition));
-  }
-}
-function buildElement(ctx, element, ignoreGuard = false) {
-  let method;
-  if (isKeyword(element)) {
-    method = buildKeyword(ctx, element);
-  } else if (isAction(element)) {
-    method = buildAction(ctx, element);
-  } else if (isAssignment(element)) {
-    method = buildElement(ctx, element.terminal);
-  } else if (isCrossReference(element)) {
-    method = buildCrossReference(ctx, element);
-  } else if (isRuleCall(element)) {
-    method = buildRuleCall(ctx, element);
-  } else if (isAlternatives(element)) {
-    method = buildAlternatives(ctx, element);
-  } else if (isUnorderedGroup(element)) {
-    method = buildUnorderedGroup(ctx, element);
-  } else if (isGroup(element)) {
-    method = buildGroup(ctx, element);
-  } else if (isEndOfFile(element)) {
-    const idx = ctx.consume++;
-    method = () => ctx.parser.consume(idx, EOF, element);
-  } else {
-    throw new ErrorWithLocation(element.$cstNode, `Unexpected element type: ${element.$type}`);
-  }
-  return wrap(ctx, ignoreGuard ? void 0 : getGuardCondition(element), method, element.cardinality);
-}
-function buildAction(ctx, action) {
-  const actionType = getTypeName(action);
-  return () => ctx.parser.action(actionType, action);
-}
-function buildRuleCall(ctx, ruleCall) {
-  const rule = ruleCall.rule.ref;
-  if (isParserRule(rule)) {
-    const idx = ctx.subrule++;
-    const fragment = rule.fragment;
-    const predicate = ruleCall.arguments.length > 0 ? buildRuleCallPredicate(rule, ruleCall.arguments) : () => ({});
-    return (args) => ctx.parser.subrule(idx, getRule(ctx, rule), fragment, ruleCall, predicate(args));
-  } else if (isTerminalRule(rule)) {
-    const idx = ctx.consume++;
-    const method = getToken(ctx, rule.name);
-    return () => ctx.parser.consume(idx, method, ruleCall);
-  } else if (!rule) {
-    throw new ErrorWithLocation(ruleCall.$cstNode, `Undefined rule: ${ruleCall.rule.$refText}`);
-  } else {
-    assertUnreachable();
-  }
-}
-function buildRuleCallPredicate(rule, namedArgs) {
-  const predicates = namedArgs.map((e) => buildPredicate(e.value));
-  return (args) => {
-    const ruleArgs = {};
-    for (let i = 0; i < predicates.length; i++) {
-      const ruleTarget = rule.parameters[i];
-      const predicate = predicates[i];
-      ruleArgs[ruleTarget.name] = predicate(args);
-    }
-    return ruleArgs;
-  };
-}
-function buildPredicate(condition) {
-  if (isDisjunction(condition)) {
-    const left = buildPredicate(condition.left);
-    const right = buildPredicate(condition.right);
-    return (args) => left(args) || right(args);
-  } else if (isConjunction(condition)) {
-    const left = buildPredicate(condition.left);
-    const right = buildPredicate(condition.right);
-    return (args) => left(args) && right(args);
-  } else if (isNegation(condition)) {
-    const value = buildPredicate(condition.value);
-    return (args) => !value(args);
-  } else if (isParameterReference(condition)) {
-    const name = condition.parameter.ref.name;
-    return (args) => args !== void 0 && args[name] === true;
-  } else if (isBooleanLiteral(condition)) {
-    const value = Boolean(condition.true);
-    return () => value;
-  }
-  assertUnreachable();
-}
-function buildAlternatives(ctx, alternatives) {
-  if (alternatives.elements.length === 1) {
-    return buildElement(ctx, alternatives.elements[0]);
-  } else {
-    const methods = [];
-    for (const element of alternatives.elements) {
-      const predicatedMethod = {
-        // Since we handle the guard condition in the alternative already
-        // We can ignore the group guard condition inside
-        ALT: buildElement(ctx, element, true)
-      };
-      const guard = getGuardCondition(element);
-      if (guard) {
-        predicatedMethod.GATE = buildPredicate(guard);
-      }
-      methods.push(predicatedMethod);
-    }
-    const idx = ctx.or++;
-    return (args) => ctx.parser.alternatives(idx, methods.map((method) => {
-      const alt = {
-        ALT: () => method.ALT(args)
-      };
-      const gate = method.GATE;
-      if (gate) {
-        alt.GATE = () => gate(args);
-      }
-      return alt;
-    }));
-  }
-}
-function buildUnorderedGroup(ctx, group) {
-  if (group.elements.length === 1) {
-    return buildElement(ctx, group.elements[0]);
-  }
-  const methods = [];
-  for (const element of group.elements) {
-    const predicatedMethod = {
-      // Since we handle the guard condition in the alternative already
-      // We can ignore the group guard condition inside
-      ALT: buildElement(ctx, element, true)
-    };
-    const guard = getGuardCondition(element);
-    if (guard) {
-      predicatedMethod.GATE = buildPredicate(guard);
-    }
-    methods.push(predicatedMethod);
-  }
-  const orIdx = ctx.or++;
-  const idFunc = (groupIdx, lParser) => {
-    const stackId = lParser.getRuleStack().join("-");
-    return `uGroup_${groupIdx}_${stackId}`;
-  };
-  const alternatives = (args) => ctx.parser.alternatives(orIdx, methods.map((method, idx) => {
-    const alt = { ALT: () => true };
-    const parser = ctx.parser;
-    alt.ALT = () => {
-      method.ALT(args);
-      if (!parser.isRecording()) {
-        const key = idFunc(orIdx, parser);
-        if (!parser.unorderedGroups.get(key)) {
-          parser.unorderedGroups.set(key, []);
-        }
-        const groupState = parser.unorderedGroups.get(key);
-        if (typeof (groupState === null || groupState === void 0 ? void 0 : groupState[idx]) === "undefined") {
-          groupState[idx] = true;
-        }
-      }
-    };
-    const gate = method.GATE;
-    if (gate) {
-      alt.GATE = () => gate(args);
-    } else {
-      alt.GATE = () => {
-        const trackedAlternatives = parser.unorderedGroups.get(idFunc(orIdx, parser));
-        const allow = !(trackedAlternatives === null || trackedAlternatives === void 0 ? void 0 : trackedAlternatives[idx]);
-        return allow;
-      };
-    }
-    return alt;
-  }));
-  const wrapped = wrap(ctx, getGuardCondition(group), alternatives, "*");
-  return (args) => {
-    wrapped(args);
-    if (!ctx.parser.isRecording()) {
-      ctx.parser.unorderedGroups.delete(idFunc(orIdx, ctx.parser));
-    }
-  };
-}
-function buildGroup(ctx, group) {
-  const methods = group.elements.map((e) => buildElement(ctx, e));
-  return (args) => methods.forEach((method) => method(args));
-}
-function getGuardCondition(element) {
-  if (isGroup(element)) {
-    return element.guardCondition;
-  }
-  return void 0;
-}
-function buildCrossReference(ctx, crossRef, terminal = crossRef.terminal) {
-  if (!terminal) {
-    if (!crossRef.type.ref) {
-      throw new Error("Could not resolve reference to type: " + crossRef.type.$refText);
-    }
-    const assignment = findNameAssignment(crossRef.type.ref);
-    const assignTerminal = assignment === null || assignment === void 0 ? void 0 : assignment.terminal;
-    if (!assignTerminal) {
-      throw new Error("Could not find name assignment for type: " + getTypeName(crossRef.type.ref));
-    }
-    return buildCrossReference(ctx, crossRef, assignTerminal);
-  } else if (isRuleCall(terminal) && isParserRule(terminal.rule.ref)) {
-    const rule = terminal.rule.ref;
-    const idx = ctx.subrule++;
-    return (args) => ctx.parser.subrule(idx, getRule(ctx, rule), false, crossRef, args);
-  } else if (isRuleCall(terminal) && isTerminalRule(terminal.rule.ref)) {
-    const idx = ctx.consume++;
-    const terminalRule = getToken(ctx, terminal.rule.ref.name);
-    return () => ctx.parser.consume(idx, terminalRule, crossRef);
-  } else if (isKeyword(terminal)) {
-    const idx = ctx.consume++;
-    const keyword = getToken(ctx, terminal.value);
-    return () => ctx.parser.consume(idx, keyword, crossRef);
-  } else {
-    throw new Error("Could not build cross reference parser");
-  }
-}
-function buildKeyword(ctx, keyword) {
-  const idx = ctx.consume++;
-  const token = ctx.tokens[keyword.value];
-  if (!token) {
-    throw new Error("Could not find token for keyword: " + keyword.value);
-  }
-  return () => ctx.parser.consume(idx, token, keyword);
-}
-function wrap(ctx, guard, method, cardinality) {
-  const gate = guard && buildPredicate(guard);
-  if (!cardinality) {
-    if (gate) {
-      const idx = ctx.or++;
-      return (args) => ctx.parser.alternatives(idx, [
-        {
-          ALT: () => method(args),
-          GATE: () => gate(args)
-        },
-        {
-          ALT: EMPTY_ALT(),
-          GATE: () => !gate(args)
-        }
-      ]);
-    } else {
-      return method;
-    }
-  }
-  if (cardinality === "*") {
-    const idx = ctx.many++;
-    return (args) => ctx.parser.many(idx, {
-      DEF: () => method(args),
-      GATE: gate ? () => gate(args) : void 0
-    });
-  } else if (cardinality === "+") {
-    const idx = ctx.many++;
-    if (gate) {
-      const orIdx = ctx.or++;
-      return (args) => ctx.parser.alternatives(orIdx, [
-        {
-          ALT: () => ctx.parser.atLeastOne(idx, {
-            DEF: () => method(args)
-          }),
-          GATE: () => gate(args)
-        },
-        {
-          ALT: EMPTY_ALT(),
-          GATE: () => !gate(args)
-        }
-      ]);
-    } else {
-      return (args) => ctx.parser.atLeastOne(idx, {
-        DEF: () => method(args)
-      });
-    }
-  } else if (cardinality === "?") {
-    const idx = ctx.optional++;
-    return (args) => ctx.parser.optional(idx, {
-      DEF: () => method(args),
-      GATE: gate ? () => gate(args) : void 0
-    });
-  } else {
-    assertUnreachable();
-  }
-}
-function getRule(ctx, element) {
-  const name = getRuleName(ctx, element);
-  const rule = ctx.parser.getRule(name);
-  if (!rule)
-    throw new Error(`Rule "${name}" not found."`);
-  return rule;
-}
-function getRuleName(ctx, element) {
-  if (isParserRule(element)) {
-    return element.name;
-  } else if (ctx.ruleNames.has(element)) {
-    return ctx.ruleNames.get(element);
-  } else {
-    let item = element;
-    let parent = item.$container;
-    let ruleName = element.$type;
-    while (!isParserRule(parent)) {
-      if (isGroup(parent) || isAlternatives(parent) || isUnorderedGroup(parent)) {
-        const index = parent.elements.indexOf(item);
-        ruleName = index.toString() + ":" + ruleName;
-      }
-      item = parent;
-      parent = parent.$container;
-    }
-    const rule = parent;
-    ruleName = rule.name + ":" + ruleName;
-    ctx.ruleNames.set(element, ruleName);
-    return ruleName;
-  }
-}
-function getToken(ctx, name) {
-  const token = ctx.tokens[name];
-  if (!token)
-    throw new Error(`Token "${name}" not found."`);
-  return token;
-}
-export {
-  createParser
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/token-builder.mjs

@@ -1,105 +0,0 @@
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/parser/parser.mjs";
-import { Lexer } from "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/lexer_public.mjs";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/scan/tokens_public.mjs";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/grammar/lookahead.mjs";
-import "lodash-es";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/errors_public.mjs";
-import "../../../../../chevrotain@11.0.3/node_modules/chevrotain/lib/src/parse/exceptions_public.mjs";
-import { isTerminalRule, isParserRule, isKeyword } from "../languages/generated/ast.mjs";
-import { streamAllContents } from "../utils/ast-utils.mjs";
-import { getAllReachableRules, terminalRegex } from "../utils/grammar-utils.mjs";
-import { isWhitespace, getCaseInsensitivePattern, partialMatches } from "../utils/regexp-utils.mjs";
-import { stream } from "../utils/stream.mjs";
-class DefaultTokenBuilder {
-  constructor() {
-    this.diagnostics = [];
-  }
-  buildTokens(grammar, options) {
-    const reachableRules = stream(getAllReachableRules(grammar, false));
-    const terminalTokens = this.buildTerminalTokens(reachableRules);
-    const tokens = this.buildKeywordTokens(reachableRules, terminalTokens, options);
-    terminalTokens.forEach((terminalToken) => {
-      const pattern = terminalToken.PATTERN;
-      if (typeof pattern === "object" && pattern && "test" in pattern && isWhitespace(pattern)) {
-        tokens.unshift(terminalToken);
-      } else {
-        tokens.push(terminalToken);
-      }
-    });
-    return tokens;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  flushLexingReport(text) {
-    return { diagnostics: this.popDiagnostics() };
-  }
-  popDiagnostics() {
-    const diagnostics = [...this.diagnostics];
-    this.diagnostics = [];
-    return diagnostics;
-  }
-  buildTerminalTokens(rules) {
-    return rules.filter(isTerminalRule).filter((e) => !e.fragment).map((terminal) => this.buildTerminalToken(terminal)).toArray();
-  }
-  buildTerminalToken(terminal) {
-    const regex = terminalRegex(terminal);
-    const pattern = this.requiresCustomPattern(regex) ? this.regexPatternFunction(regex) : regex;
-    const tokenType = {
-      name: terminal.name,
-      PATTERN: pattern
-    };
-    if (typeof pattern === "function") {
-      tokenType.LINE_BREAKS = true;
-    }
-    if (terminal.hidden) {
-      tokenType.GROUP = isWhitespace(regex) ? Lexer.SKIPPED : "hidden";
-    }
-    return tokenType;
-  }
-  requiresCustomPattern(regex) {
-    if (regex.flags.includes("u") || regex.flags.includes("s")) {
-      return true;
-    } else if (regex.source.includes("?<=") || regex.source.includes("?<!")) {
-      return true;
-    } else {
-      return false;
-    }
-  }
-  regexPatternFunction(regex) {
-    const stickyRegex = new RegExp(regex, regex.flags + "y");
-    return (text, offset) => {
-      stickyRegex.lastIndex = offset;
-      const execResult = stickyRegex.exec(text);
-      return execResult;
-    };
-  }
-  buildKeywordTokens(rules, terminalTokens, options) {
-    return rules.filter(isParserRule).flatMap((rule) => streamAllContents(rule).filter(isKeyword)).distinct((e) => e.value).toArray().sort((a, b) => b.value.length - a.value.length).map((keyword) => this.buildKeywordToken(keyword, terminalTokens, Boolean(options === null || options === void 0 ? void 0 : options.caseInsensitive)));
-  }
-  buildKeywordToken(keyword, terminalTokens, caseInsensitive) {
-    const keywordPattern = this.buildKeywordPattern(keyword, caseInsensitive);
-    const tokenType = {
-      name: keyword.value,
-      PATTERN: keywordPattern,
-      LONGER_ALT: this.findLongerAlt(keyword, terminalTokens)
-    };
-    if (typeof keywordPattern === "function") {
-      tokenType.LINE_BREAKS = true;
-    }
-    return tokenType;
-  }
-  buildKeywordPattern(keyword, caseInsensitive) {
-    return caseInsensitive ? new RegExp(getCaseInsensitivePattern(keyword.value)) : keyword.value;
-  }
-  findLongerAlt(keyword, terminalTokens) {
-    return terminalTokens.reduce((longerAlts, token) => {
-      const pattern = token === null || token === void 0 ? void 0 : token.PATTERN;
-      if ((pattern === null || pattern === void 0 ? void 0 : pattern.source) && partialMatches("^" + pattern.source + "$", keyword.value)) {
-        longerAlts.push(token);
-      }
-      return longerAlts;
-    }, []);
-  }
-}
-export {
-  DefaultTokenBuilder
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/parser/value-converter.mjs

@@ -1,111 +0,0 @@
-import { isCrossReference, isRuleCall } from "../languages/generated/ast.mjs";
-import { getCrossReferenceTerminal, getRuleType } from "../utils/grammar-utils.mjs";
-class DefaultValueConverter {
-  convert(input, cstNode) {
-    let feature = cstNode.grammarSource;
-    if (isCrossReference(feature)) {
-      feature = getCrossReferenceTerminal(feature);
-    }
-    if (isRuleCall(feature)) {
-      const rule = feature.rule.ref;
-      if (!rule) {
-        throw new Error("This cst node was not parsed by a rule.");
-      }
-      return this.runConverter(rule, input, cstNode);
-    }
-    return input;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  runConverter(rule, input, cstNode) {
-    var _a;
-    switch (rule.name.toUpperCase()) {
-      case "INT":
-        return ValueConverter.convertInt(input);
-      case "STRING":
-        return ValueConverter.convertString(input);
-      case "ID":
-        return ValueConverter.convertID(input);
-    }
-    switch ((_a = getRuleType(rule)) === null || _a === void 0 ? void 0 : _a.toLowerCase()) {
-      case "number":
-        return ValueConverter.convertNumber(input);
-      case "boolean":
-        return ValueConverter.convertBoolean(input);
-      case "bigint":
-        return ValueConverter.convertBigint(input);
-      case "date":
-        return ValueConverter.convertDate(input);
-      default:
-        return input;
-    }
-  }
-}
-var ValueConverter;
-(function(ValueConverter2) {
-  function convertString(input) {
-    let result = "";
-    for (let i = 1; i < input.length - 1; i++) {
-      const c = input.charAt(i);
-      if (c === "\\") {
-        const c1 = input.charAt(++i);
-        result += convertEscapeCharacter(c1);
-      } else {
-        result += c;
-      }
-    }
-    return result;
-  }
-  ValueConverter2.convertString = convertString;
-  function convertEscapeCharacter(char) {
-    switch (char) {
-      case "b":
-        return "\b";
-      case "f":
-        return "\f";
-      case "n":
-        return "\n";
-      case "r":
-        return "\r";
-      case "t":
-        return "	";
-      case "v":
-        return "\v";
-      case "0":
-        return "\0";
-      default:
-        return char;
-    }
-  }
-  function convertID(input) {
-    if (input.charAt(0) === "^") {
-      return input.substring(1);
-    } else {
-      return input;
-    }
-  }
-  ValueConverter2.convertID = convertID;
-  function convertInt(input) {
-    return parseInt(input);
-  }
-  ValueConverter2.convertInt = convertInt;
-  function convertBigint(input) {
-    return BigInt(input);
-  }
-  ValueConverter2.convertBigint = convertBigint;
-  function convertDate(input) {
-    return new Date(input);
-  }
-  ValueConverter2.convertDate = convertDate;
-  function convertNumber(input) {
-    return Number(input);
-  }
-  ValueConverter2.convertNumber = convertNumber;
-  function convertBoolean(input) {
-    return input.toLowerCase() === "true";
-  }
-  ValueConverter2.convertBoolean = convertBoolean;
-})(ValueConverter || (ValueConverter = {}));
-export {
-  DefaultValueConverter,
-  ValueConverter
-};

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

@@ -1,139 +0,0 @@
-import { isLinkingError, isAstNode, isAstNodeDescription } from "../syntax-tree.mjs";
-import { streamAst, streamReferences, findRootNode } from "../utils/ast-utils.mjs";
-import { interruptAndCheck } from "../utils/promise-utils.mjs";
-import { DocumentState } from "../workspace/documents.mjs";
-import { c as cancellationExports } from "../../../../../../../_virtual/cancellation.mjs";
-const ref_resolving = Symbol("ref_resolving");
-class DefaultLinker {
-  constructor(services) {
-    this.reflection = services.shared.AstReflection;
-    this.langiumDocuments = () => services.shared.workspace.LangiumDocuments;
-    this.scopeProvider = services.references.ScopeProvider;
-    this.astNodeLocator = services.workspace.AstNodeLocator;
-  }
-  async link(document, cancelToken = cancellationExports.CancellationToken.None) {
-    for (const node of streamAst(document.parseResult.value)) {
-      await interruptAndCheck(cancelToken);
-      streamReferences(node).forEach((ref) => this.doLink(ref, document));
-    }
-  }
-  doLink(refInfo, document) {
-    var _a;
-    const ref = refInfo.reference;
-    if (ref._ref === void 0) {
-      ref._ref = ref_resolving;
-      try {
-        const description = this.getCandidate(refInfo);
-        if (isLinkingError(description)) {
-          ref._ref = description;
-        } else {
-          ref._nodeDescription = description;
-          if (this.langiumDocuments().hasDocument(description.documentUri)) {
-            const linkedNode = this.loadAstNode(description);
-            ref._ref = linkedNode !== null && linkedNode !== void 0 ? linkedNode : this.createLinkingError(refInfo, description);
-          } else {
-            ref._ref = void 0;
-          }
-        }
-      } catch (err) {
-        console.error(`An error occurred while resolving reference to '${ref.$refText}':`, err);
-        const errorMessage = (_a = err.message) !== null && _a !== void 0 ? _a : String(err);
-        ref._ref = Object.assign(Object.assign({}, refInfo), { message: `An error occurred while resolving reference to '${ref.$refText}': ${errorMessage}` });
-      }
-      document.references.push(ref);
-    }
-  }
-  unlink(document) {
-    for (const ref of document.references) {
-      delete ref._ref;
-      delete ref._nodeDescription;
-    }
-    document.references = [];
-  }
-  getCandidate(refInfo) {
-    const scope = this.scopeProvider.getScope(refInfo);
-    const description = scope.getElement(refInfo.reference.$refText);
-    return description !== null && description !== void 0 ? description : this.createLinkingError(refInfo);
-  }
-  buildReference(node, property, refNode, refText) {
-    const linker = this;
-    const reference = {
-      $refNode: refNode,
-      $refText: refText,
-      get ref() {
-        var _a;
-        if (isAstNode(this._ref)) {
-          return this._ref;
-        } else if (isAstNodeDescription(this._nodeDescription)) {
-          const linkedNode = linker.loadAstNode(this._nodeDescription);
-          this._ref = linkedNode !== null && linkedNode !== void 0 ? linkedNode : linker.createLinkingError({ reference, container: node, property }, this._nodeDescription);
-        } else if (this._ref === void 0) {
-          this._ref = ref_resolving;
-          const document = findRootNode(node).$document;
-          const refData = linker.getLinkedNode({ reference, container: node, property });
-          if (refData.error && document && document.state < DocumentState.ComputedScopes) {
-            return this._ref = void 0;
-          }
-          this._ref = (_a = refData.node) !== null && _a !== void 0 ? _a : refData.error;
-          this._nodeDescription = refData.descr;
-          document === null || document === void 0 ? void 0 : document.references.push(this);
-        } else if (this._ref === ref_resolving) {
-          throw new Error(`Cyclic reference resolution detected: ${linker.astNodeLocator.getAstNodePath(node)}/${property} (symbol '${refText}')`);
-        }
-        return isAstNode(this._ref) ? this._ref : void 0;
-      },
-      get $nodeDescription() {
-        return this._nodeDescription;
-      },
-      get error() {
-        return isLinkingError(this._ref) ? this._ref : void 0;
-      }
-    };
-    return reference;
-  }
-  getLinkedNode(refInfo) {
-    var _a;
-    try {
-      const description = this.getCandidate(refInfo);
-      if (isLinkingError(description)) {
-        return { error: description };
-      }
-      const linkedNode = this.loadAstNode(description);
-      if (linkedNode) {
-        return { node: linkedNode, descr: description };
-      } else {
-        return {
-          descr: description,
-          error: this.createLinkingError(refInfo, description)
-        };
-      }
-    } catch (err) {
-      console.error(`An error occurred while resolving reference to '${refInfo.reference.$refText}':`, err);
-      const errorMessage = (_a = err.message) !== null && _a !== void 0 ? _a : String(err);
-      return {
-        error: Object.assign(Object.assign({}, refInfo), { message: `An error occurred while resolving reference to '${refInfo.reference.$refText}': ${errorMessage}` })
-      };
-    }
-  }
-  loadAstNode(nodeDescription) {
-    if (nodeDescription.node) {
-      return nodeDescription.node;
-    }
-    const doc = this.langiumDocuments().getDocument(nodeDescription.documentUri);
-    if (!doc) {
-      return void 0;
-    }
-    return this.astNodeLocator.getAstNode(doc.parseResult.value, nodeDescription.path);
-  }
-  createLinkingError(refInfo, targetDescription) {
-    const document = findRootNode(refInfo.container).$document;
-    if (document && document.state < DocumentState.ComputedScopes) {
-      console.warn(`Attempted reference resolution before document reached ComputedScopes state (${document.uri}).`);
-    }
-    const referenceType = this.reflection.getReferenceType(refInfo);
-    return Object.assign(Object.assign({}, refInfo), { message: `Could not resolve reference to ${referenceType} named '${refInfo.reference.$refText}'.`, targetDescription });
-  }
-}
-export {
-  DefaultLinker
-};