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

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

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

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

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