@0no-co/graphqlsp/dist/chunks/api-chunk.js

TypeScript LSP plugin that finds GraphQL documents in your code and provides hints and auto-generates types.

var e = require("graphql");

var t = require("crypto");

exports.ts = void 0;

class CharacterStream {
  constructor(e) {
    this._start = 0;
    this._pos = 0;
    this.getStartOfToken = () => this._start;
    this.getCurrentPosition = () => this._pos;
    this.eol = () => this._sourceText.length === this._pos;
    this.sol = () => 0 === this._pos;
    this.peek = () => this._sourceText.charAt(this._pos) || null;
    this.next = () => {
      var e = this._sourceText.charAt(this._pos);
      this._pos++;
      return e;
    };
    this.eat = e => {
      if (this._testNextCharacter(e)) {
        this._start = this._pos;
        this._pos++;
        return this._sourceText.charAt(this._pos - 1);
      }
      return;
    };
    this.eatWhile = e => {
      var t = this._testNextCharacter(e);
      var i = !1;
      if (t) {
        i = t;
        this._start = this._pos;
      }
      while (t) {
        this._pos++;
        t = this._testNextCharacter(e);
        i = !0;
      }
      return i;
    };
    this.eatSpace = () => this.eatWhile(/[\s\u00a0]/);
    this.skipToEnd = () => {
      this._pos = this._sourceText.length;
    };
    this.skipTo = e => {
      this._pos = e;
    };
    this.match = (e, t = !0, i = !1) => {
      var r = null;
      var s = null;
      if ("string" == typeof e) {
        s = new RegExp(e, i ? "i" : "g").test(this._sourceText.slice(this._pos, this._pos + e.length));
        r = e;
      } else if (e instanceof RegExp) {
        r = null == (s = this._sourceText.slice(this._pos).match(e)) ? void 0 : s[0];
      }
      if (null != s && ("string" == typeof e || s instanceof Array && this._sourceText.startsWith(s[0], this._pos))) {
        if (t) {
          this._start = this._pos;
          if (r && r.length) {
            this._pos += r.length;
          }
        }
        return s;
      }
      return !1;
    };
    this.backUp = e => {
      this._pos -= e;
    };
    this.column = () => this._pos;
    this.indentation = () => {
      var e = this._sourceText.match(/\s*/);
      var t = 0;
      if (e && 0 !== e.length) {
        var i = e[0];
        var r = 0;
        while (i.length > r) {
          if (9 === i.charCodeAt(r)) {
            t += 2;
          } else {
            t++;
          }
          r++;
        }
      }
      return t;
    };
    this.current = () => this._sourceText.slice(this._start, this._pos);
    this._sourceText = e;
  }
  _testNextCharacter(e) {
    var t = this._sourceText.charAt(this._pos);
    var i = !1;
    if ("string" == typeof e) {
      i = t === e;
    } else {
      i = e instanceof RegExp ? e.test(t) : e(t);
    }
    return i;
  }
}

function opt(e) {
  return {
    ofRule: e
  };
}

function list(e, t) {
  return {
    ofRule: e,
    isList: !0,
    separator: t
  };
}

function t$1(e, t) {
  return {
    style: t,
    match: t => t.kind === e
  };
}

function p$1(e, t) {
  return {
    style: t || "punctuation",
    match: t => "Punctuation" === t.kind && t.value === e
  };
}

var isIgnored = e => " " === e || "\t" === e || "," === e || "\n" === e || "\r" === e || "\ufeff" === e || " " === e;

var i = {
  Name: /^[_A-Za-z][_0-9A-Za-z]*/,
  Punctuation: /^(?:!|\$|\(|\)|\.\.\.|:|=|&|@|\[|]|\{|\||\})/,
  Number: /^-?(?:0|(?:[1-9][0-9]*))(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?/,
  String: /^(?:"""(?:\\"""|[^"]|"[^"]|""[^"])*(?:""")?|"(?:[^"\\]|\\(?:"|\/|\\|b|f|n|r|t|u[0-9a-fA-F]{4}))*"?)/,
  Comment: /^#.*/
};

var r = {
  Document: [ list("Definition") ],
  Definition(t) {
    switch (t.value) {
     case "{":
      return "ShortQuery";

     case "query":
      return "Query";

     case "mutation":
      return "Mutation";

     case "subscription":
      return "Subscription";

     case "fragment":
      return e.Kind.FRAGMENT_DEFINITION;

     case "schema":
      return "SchemaDef";

     case "scalar":
      return "ScalarDef";

     case "type":
      return "ObjectTypeDef";

     case "interface":
      return "InterfaceDef";

     case "union":
      return "UnionDef";

     case "enum":
      return "EnumDef";

     case "input":
      return "InputDef";

     case "extend":
      return "ExtendDef";

     case "directive":
      return "DirectiveDef";
    }
  },
  ShortQuery: [ "SelectionSet" ],
  Query: [ word("query"), opt(name$1("def")), opt("VariableDefinitions"), list("Directive"), "SelectionSet" ],
  Mutation: [ word("mutation"), opt(name$1("def")), opt("VariableDefinitions"), list("Directive"), "SelectionSet" ],
  Subscription: [ word("subscription"), opt(name$1("def")), opt("VariableDefinitions"), list("Directive"), "SelectionSet" ],
  VariableDefinitions: [ p$1("("), list("VariableDefinition"), p$1(")") ],
  VariableDefinition: [ "Variable", p$1(":"), "Type", opt("DefaultValue") ],
  Variable: [ p$1("$", "variable"), name$1("variable") ],
  DefaultValue: [ p$1("="), "Value" ],
  SelectionSet: [ p$1("{"), list("Selection"), p$1("}") ],
  Selection: (e, t) => "..." === e.value ? t.match(/[\s\u00a0,]*(on\b|@|{)/, !1) ? "InlineFragment" : "FragmentSpread" : t.match(/[\s\u00a0,]*:/, !1) ? "AliasedField" : "Field",
  AliasedField: [ name$1("property"), p$1(":"), name$1("qualifier"), opt("Arguments"), list("Directive"), opt("SelectionSet") ],
  Field: [ name$1("property"), opt("Arguments"), list("Directive"), opt("SelectionSet") ],
  Arguments: [ p$1("("), list("Argument"), p$1(")") ],
  Argument: [ name$1("attribute"), p$1(":"), "Value" ],
  FragmentSpread: [ p$1("..."), name$1("def"), list("Directive") ],
  InlineFragment: [ p$1("..."), opt("TypeCondition"), list("Directive"), "SelectionSet" ],
  FragmentDefinition: [ word("fragment"), opt(function butNot(e, t) {
    var i = e.match;
    e.match = e => {
      var r = !1;
      if (i) {
        r = i(e);
      }
      return r && t.every(t => t.match && !t.match(e));
    };
    return e;
  }(name$1("def"), [ word("on") ])), "TypeCondition", list("Directive"), "SelectionSet" ],
  TypeCondition: [ word("on"), "NamedType" ],
  Value(e) {
    switch (e.kind) {
     case "Number":
      return "NumberValue";

     case "String":
      return "StringValue";

     case "Punctuation":
      switch (e.value) {
       case "[":
        return "ListValue";

       case "{":
        return "ObjectValue";

       case "$":
        return "Variable";

       case "&":
        return "NamedType";
      }
      return null;

     case "Name":
      switch (e.value) {
       case "true":
       case "false":
        return "BooleanValue";
      }
      if ("null" === e.value) {
        return "NullValue";
      }
      return "EnumValue";
    }
  },
  NumberValue: [ t$1("Number", "number") ],
  StringValue: [ {
    style: "string",
    match: e => "String" === e.kind,
    update(e, t) {
      if (t.value.startsWith('"""')) {
        e.inBlockstring = !t.value.slice(3).endsWith('"""');
      }
    }
  } ],
  BooleanValue: [ t$1("Name", "builtin") ],
  NullValue: [ t$1("Name", "keyword") ],
  EnumValue: [ name$1("string-2") ],
  ListValue: [ p$1("["), list("Value"), p$1("]") ],
  ObjectValue: [ p$1("{"), list("ObjectField"), p$1("}") ],
  ObjectField: [ name$1("attribute"), p$1(":"), "Value" ],
  Type: e => "[" === e.value ? "ListType" : "NonNullType",
  ListType: [ p$1("["), "Type", p$1("]"), opt(p$1("!")) ],
  NonNullType: [ "NamedType", opt(p$1("!")) ],
  NamedType: [ function type$1(e) {
    return {
      style: e,
      match: e => "Name" === e.kind,
      update(e, t) {
        var i;
        if (null === (i = e.prevState) || void 0 === i ? void 0 : i.prevState) {
          e.name = t.value;
          e.prevState.prevState.type = t.value;
        }
      }
    };
  }("atom") ],
  Directive: [ p$1("@", "meta"), name$1("meta"), opt("Arguments") ],
  DirectiveDef: [ word("directive"), p$1("@", "meta"), name$1("meta"), opt("ArgumentsDef"), word("on"), list("DirectiveLocation", p$1("|")) ],
  InterfaceDef: [ word("interface"), name$1("atom"), opt("Implements"), list("Directive"), p$1("{"), list("FieldDef"), p$1("}") ],
  Implements: [ word("implements"), list("NamedType", p$1("&")) ],
  DirectiveLocation: [ name$1("string-2") ],
  SchemaDef: [ word("schema"), list("Directive"), p$1("{"), list("OperationTypeDef"), p$1("}") ],
  OperationTypeDef: [ name$1("keyword"), p$1(":"), name$1("atom") ],
  ScalarDef: [ word("scalar"), name$1("atom"), list("Directive") ],
  ObjectTypeDef: [ word("type"), name$1("atom"), opt("Implements"), list("Directive"), p$1("{"), list("FieldDef"), p$1("}") ],
  FieldDef: [ name$1("property"), opt("ArgumentsDef"), p$1(":"), "Type", list("Directive") ],
  ArgumentsDef: [ p$1("("), list("InputValueDef"), p$1(")") ],
  InputValueDef: [ name$1("attribute"), p$1(":"), "Type", opt("DefaultValue"), list("Directive") ],
  UnionDef: [ word("union"), name$1("atom"), list("Directive"), p$1("="), list("UnionMember", p$1("|")) ],
  UnionMember: [ "NamedType" ],
  EnumDef: [ word("enum"), name$1("atom"), list("Directive"), p$1("{"), list("EnumValueDef"), p$1("}") ],
  EnumValueDef: [ name$1("string-2"), list("Directive") ],
  InputDef: [ word("input"), name$1("atom"), list("Directive"), p$1("{"), list("InputValueDef"), p$1("}") ],
  ExtendDef: [ word("extend"), "ExtensionDefinition" ],
  ExtensionDefinition(t) {
    switch (t.value) {
     case "schema":
      return e.Kind.SCHEMA_EXTENSION;

     case "scalar":
      return e.Kind.SCALAR_TYPE_EXTENSION;

     case "type":
      return e.Kind.OBJECT_TYPE_EXTENSION;

     case "interface":
      return e.Kind.INTERFACE_TYPE_EXTENSION;

     case "union":
      return e.Kind.UNION_TYPE_EXTENSION;

     case "enum":
      return e.Kind.ENUM_TYPE_EXTENSION;

     case "input":
      return e.Kind.INPUT_OBJECT_TYPE_EXTENSION;
    }
  },
  [e.Kind.SCHEMA_EXTENSION]: [ "SchemaDef" ],
  [e.Kind.SCALAR_TYPE_EXTENSION]: [ "ScalarDef" ],
  [e.Kind.OBJECT_TYPE_EXTENSION]: [ "ObjectTypeDef" ],
  [e.Kind.INTERFACE_TYPE_EXTENSION]: [ "InterfaceDef" ],
  [e.Kind.UNION_TYPE_EXTENSION]: [ "UnionDef" ],
  [e.Kind.ENUM_TYPE_EXTENSION]: [ "EnumDef" ],
  [e.Kind.INPUT_OBJECT_TYPE_EXTENSION]: [ "InputDef" ]
};

function word(e) {
  return {
    style: "keyword",
    match: t => "Name" === t.kind && t.value === e
  };
}

function name$1(e) {
  return {
    style: e,
    match: e => "Name" === e.kind,
    update(e, t) {
      e.name = t.value;
    }
  };
}

function onlineParser(t = {
  eatWhitespace: e => e.eatWhile(isIgnored),
  lexRules: i,
  parseRules: r,
  editorConfig: {}
}) {
  return {
    startState() {
      var i = {
        level: 0,
        step: 0,
        name: null,
        kind: null,
        type: null,
        rule: null,
        needsSeparator: !1,
        prevState: null
      };
      pushRule(t.parseRules, i, e.Kind.DOCUMENT);
      return i;
    },
    token: (e, i) => function getToken(e, t, i) {
      var r;
      if (t.inBlockstring) {
        if (e.match(/.*"""/)) {
          t.inBlockstring = !1;
          return "string";
        }
        e.skipToEnd();
        return "string";
      }
      var {lexRules: a, parseRules: n, eatWhitespace: o, editorConfig: l} = i;
      if (t.rule && 0 === t.rule.length) {
        popRule(t);
      } else if (t.needsAdvance) {
        t.needsAdvance = !1;
        advanceRule(t, !0);
      }
      if (e.sol()) {
        var u = (null == l ? void 0 : l.tabSize) || 2;
        t.indentLevel = Math.floor(e.indentation() / u);
      }
      if (o(e)) {
        return "ws";
      }
      var p = function lex(e, t) {
        var i = Object.keys(e);
        for (var r = 0; r < i.length; r++) {
          var s = t.match(e[i[r]]);
          if (s && s instanceof Array) {
            return {
              kind: i[r],
              value: s[0]
            };
          }
        }
      }(a, e);
      if (!p) {
        if (!e.match(/\S+/)) {
          e.match(/\s/);
        }
        pushRule(s, t, "Invalid");
        return "invalidchar";
      }
      if ("Comment" === p.kind) {
        pushRule(s, t, "Comment");
        return "comment";
      }
      var f = assign({}, t);
      if ("Punctuation" === p.kind) {
        if (/^[{([]/.test(p.value)) {
          if (void 0 !== t.indentLevel) {
            t.levels = (t.levels || []).concat(t.indentLevel + 1);
          }
        } else if (/^[})\]]/.test(p.value)) {
          var c = t.levels = (t.levels || []).slice(0, -1);
          if (t.indentLevel && c.length > 0 && c.at(-1) < t.indentLevel) {
            t.indentLevel = c.at(-1);
          }
        }
      }
      while (t.rule) {
        var h = "function" == typeof t.rule ? 0 === t.step ? t.rule(p, e) : null : t.rule[t.step];
        if (t.needsSeparator) {
          h = null == h ? void 0 : h.separator;
        }
        if (h) {
          if (h.ofRule) {
            h = h.ofRule;
          }
          if ("string" == typeof h) {
            pushRule(n, t, h);
            continue;
          }
          if (null === (r = h.match) || void 0 === r ? void 0 : r.call(h, p)) {
            if (h.update) {
              h.update(t, p);
            }
            if ("Punctuation" === p.kind) {
              advanceRule(t, !0);
            } else {
              t.needsAdvance = !0;
            }
            return h.style;
          }
        }
        unsuccessful(t);
      }
      assign(t, f);
      pushRule(s, t, "Invalid");
      return "invalidchar";
    }(e, i, t)
  };
}

function assign(e, t) {
  var i = Object.keys(t);
  for (var r = 0; r < i.length; r++) {
    e[i[r]] = t[i[r]];
  }
  return e;
}

var s = {
  Invalid: [],
  Comment: []
};

function pushRule(e, t, i) {
  if (!e[i]) {
    throw new TypeError("Unknown rule: " + i);
  }
  t.prevState = Object.assign({}, t);
  t.kind = i;
  t.name = null;
  t.type = null;
  t.rule = e[i];
  t.step = 0;
  t.needsSeparator = !1;
}

function popRule(e) {
  if (!e.prevState) {
    return;
  }
  e.kind = e.prevState.kind;
  e.name = e.prevState.name;
  e.type = e.prevState.type;
  e.rule = e.prevState.rule;
  e.step = e.prevState.step;
  e.needsSeparator = e.prevState.needsSeparator;
  e.prevState = e.prevState.prevState;
}

function advanceRule(e, t) {
  var i;
  if (isList(e) && e.rule) {
    var r = e.rule[e.step];
    if (r.separator) {
      var {separator: s} = r;
      e.needsSeparator = !e.needsSeparator;
      if (!e.needsSeparator && s.ofRule) {
        return;
      }
    }
    if (t) {
      return;
    }
  }
  e.needsSeparator = !1;
  e.step++;
  while (e.rule && !(Array.isArray(e.rule) && e.step < e.rule.length)) {
    popRule(e);
    if (e.rule) {
      if (isList(e)) {
        if (null === (i = e.rule) || void 0 === i ? void 0 : i[e.step].separator) {
          e.needsSeparator = !e.needsSeparator;
        }
      } else {
        e.needsSeparator = !1;
        e.step++;
      }
    }
  }
}

function isList(e) {
  var t = Array.isArray(e.rule) && "string" != typeof e.rule[e.step] && e.rule[e.step];
  return t && t.isList;
}

function unsuccessful(e) {
  while (e.rule && (!Array.isArray(e.rule) || !e.rule[e.step].ofRule)) {
    popRule(e);
  }
  if (e.rule) {
    advanceRule(e, !1);
  }
}

function getDefaultExportFromCjs(e) {
  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
}

class Range {
  constructor(e, t) {
    this.containsPosition = e => {
      if (this.start.line === e.line) {
        return this.start.character <= e.character;
      }
      if (this.end.line === e.line) {
        return this.end.character >= e.character;
      }
      return this.start.line <= e.line && this.end.line >= e.line;
    };
    this.start = e;
    this.end = t;
  }
  setStart(e, t) {
    this.start = new Position(e, t);
  }
  setEnd(e, t) {
    this.end = new Position(e, t);
  }
}

class Position {
  constructor(e, t) {
    this.lessThanOrEqualTo = e => this.line < e.line || this.line === e.line && this.character <= e.character;
    this.line = e;
    this.character = t;
  }
  setLine(e) {
    this.line = e;
  }
  setCharacter(e) {
    this.character = e;
  }
}

var a = [ e.LoneSchemaDefinitionRule, e.UniqueOperationTypesRule, e.UniqueTypeNamesRule, e.UniqueEnumValueNamesRule, e.UniqueFieldDefinitionNamesRule, e.UniqueDirectiveNamesRule, e.KnownTypeNamesRule, e.KnownDirectivesRule, e.UniqueDirectivesPerLocationRule, e.PossibleTypeExtensionsRule, e.UniqueArgumentNamesRule, e.UniqueInputFieldNamesRule ];

var n = "Error", o = "Warning", l = "Information", u = "Hint";

var p = {
  [n]: 1,
  [o]: 2,
  [l]: 3,
  [u]: 4
};

var invariant = (e, t) => {
  if (!e) {
    throw new Error(t);
  }
};

function getDiagnostics(t, i = null, r, s, n) {
  var o, l;
  var u = null;
  var f = "";
  if (n) {
    f = "string" == typeof n ? n : n.reduce((t, i) => t + e.print(i) + "\n\n", "");
  }
  var c = f ? `${t}\n\n${f}` : t;
  try {
    u = e.parse(c);
  } catch (t) {
    if (t instanceof e.GraphQLError) {
      var h = function getRange(e, t) {
        var i = onlineParser();
        var r = i.startState();
        var s = t.split("\n");
        invariant(s.length >= e.line, "Query text must have more lines than where the error happened");
        var a = null;
        for (var n = 0; n < e.line; n++) {
          a = new CharacterStream(s[n]);
          while (!a.eol()) {
            if ("invalidchar" === i.token(a, r)) {
              break;
            }
          }
        }
        invariant(a, "Expected Parser stream to be available.");
        var o = e.line - 1;
        var l = a.getStartOfToken();
        var u = a.getCurrentPosition();
        return new Range(new Position(o, l), new Position(o, u));
      }(null !== (l = null === (o = t.locations) || void 0 === o ? void 0 : o[0]) && void 0 !== l ? l : {
        line: 0,
        column: 0
      }, c);
      return [ {
        severity: p.Error,
        message: t.message,
        source: "GraphQL: Syntax",
        range: h
      } ];
    }
    throw t;
  }
  return function validateQuery(t, i = null, r, s) {
    if (!i) {
      return [];
    }
    var n = function validateWithCustomRules(t, i, r, s, n) {
      var o = e.specifiedRules.filter(t => {
        if (t === e.NoUnusedFragmentsRule || t === e.ExecutableDefinitionsRule) {
          return !1;
        }
        if (s && t === e.KnownFragmentNamesRule) {
          return !1;
        }
        return !0;
      });
      if (r) {
        Array.prototype.push.apply(o, r);
      }
      if (n) {
        Array.prototype.push.apply(o, a);
      }
      return e.validate(t, i, o).filter(t => {
        if (t.message.includes("Unknown directive") && t.nodes) {
          var i = t.nodes[0];
          if (i && i.kind === e.Kind.DIRECTIVE) {
            var r = i.name.value;
            if ("arguments" === r || "argumentDefinitions" === r) {
              return !1;
            }
          }
        }
        return !0;
      });
    }(i, t, r, s).flatMap(e => annotations(e, p.Error, "Validation"));
    var o = e.validate(i, t, [ e.NoDeprecatedCustomRule ]).flatMap(e => annotations(e, p.Warning, "Deprecation"));
    return n.concat(o);
  }(u, i, r, s);
}

function annotations(e, t, i) {
  if (!e.nodes) {
    return [];
  }
  var r = [];
  for (var [s, a] of e.nodes.entries()) {
    var n = "Variable" !== a.kind && "name" in a && void 0 !== a.name ? a.name : "variable" in a && void 0 !== a.variable ? a.variable : a;
    if (n) {
      invariant(e.locations, "GraphQL validation error requires locations.");
      var o = e.locations[s];
      var l = getLocation(n);
      var u = o.column + (l.end - l.start);
      r.push({
        source: `GraphQL: ${i}`,
        message: e.message,
        severity: t,
        range: new Range(new Position(o.line - 1, o.column - 1), new Position(o.line - 1, u))
      });
    }
  }
  return r;
}

function getLocation(e) {
  var t = e.loc;
  invariant(t, "Expected ASTNode to have a location.");
  return t;
}

var f = "FragmentDefinition";

class GraphQLError extends Error {
  constructor(e, t, i, r, s, a, n) {
    super(e);
    this.name = "GraphQLError";
    this.message = e;
    if (s) {
      this.path = s;
    }
    if (t) {
      this.nodes = Array.isArray(t) ? t : [ t ];
    }
    if (i) {
      this.source = i;
    }
    if (r) {
      this.positions = r;
    }
    if (a) {
      this.originalError = a;
    }
    var o = n;
    if (!o && a) {
      var l = a.extensions;
      if (l && "object" == typeof l) {
        o = l;
      }
    }
    this.extensions = o || {};
  }
  toJSON() {
    return {
      ...this,
      message: this.message
    };
  }
  toString() {
    return this.message;
  }
  get [Symbol.toStringTag]() {
    return "GraphQLError";
  }
}

var c;

var h;

function error(e) {
  return new GraphQLError(`Syntax Error: Unexpected token at ${h} in ${e}`);
}

function advance(e) {
  e.lastIndex = h;
  if (e.test(c)) {
    return c.slice(h, h = e.lastIndex);
  }
}

var d = / +(?=[^\s])/y;

function blockString(e) {
  var t = e.split("\n");
  var i = "";
  var r = 0;
  var s = 0;
  var a = t.length - 1;
  for (var n = 0; n < t.length; n++) {
    d.lastIndex = 0;
    if (d.test(t[n])) {
      if (n && (!r || d.lastIndex < r)) {
        r = d.lastIndex;
      }
      s = s || n;
      a = n;
    }
  }
  for (var o = s; o <= a; o++) {
    if (o !== s) {
      i += "\n";
    }
    i += t[o].slice(r).replace(/\\"""/g, '"""');
  }
  return i;
}

function ignored() {
  for (var e = 0 | c.charCodeAt(h++); 9 === e || 10 === e || 13 === e || 32 === e || 35 === e || 44 === e || 65279 === e; e = 0 | c.charCodeAt(h++)) {
    if (35 === e) {
      while (10 !== (e = c.charCodeAt(h++)) && 13 !== e) {}
    }
  }
  h--;
}

var v = /[_A-Za-z]\w*/y;

function name() {
  var e;
  if (e = advance(v)) {
    return {
      kind: "Name",
      value: e
    };
  }
}

var g = /(?:null|true|false)/y;

var m = /\$[_A-Za-z]\w*/y;

var x = /-?\d+/y;

var S = /(?:\.\d+)?[eE][+-]?\d+|\.\d+/y;

var y = /\\/g;

var T = /"""(?:"""|(?:[\s\S]*?[^\\])""")/y;

var E = /"(?:"|[^\r\n]*?[^\\]")/y;

function value(e) {
  var t;
  var i;
  if (i = advance(g)) {
    t = "null" === i ? {
      kind: "NullValue"
    } : {
      kind: "BooleanValue",
      value: "true" === i
    };
  } else if (!e && (i = advance(m))) {
    t = {
      kind: "Variable",
      name: {
        kind: "Name",
        value: i.slice(1)
      }
    };
  } else if (i = advance(x)) {
    var r = i;
    if (i = advance(S)) {
      t = {
        kind: "FloatValue",
        value: r + i
      };
    } else {
      t = {
        kind: "IntValue",
        value: r
      };
    }
  } else if (i = advance(v)) {
    t = {
      kind: "EnumValue",
      value: i
    };
  } else if (i = advance(T)) {
    t = {
      kind: "StringValue",
      value: blockString(i.slice(3, -3)),
      block: !0
    };
  } else if (i = advance(E)) {
    t = {
      kind: "StringValue",
      value: y.test(i) ? JSON.parse(i) : i.slice(1, -1),
      block: !1
    };
  } else if (t = function list(e) {
    var t;
    if (91 === c.charCodeAt(h)) {
      h++;
      ignored();
      var i = [];
      while (t = value(e)) {
        i.push(t);
      }
      if (93 !== c.charCodeAt(h++)) {
        throw error("ListValue");
      }
      ignored();
      return {
        kind: "ListValue",
        values: i
      };
    }
  }(e) || function object(e) {
    if (123 === c.charCodeAt(h)) {
      h++;
      ignored();
      var t = [];
      var i;
      while (i = name()) {
        ignored();
        if (58 !== c.charCodeAt(h++)) {
          throw error("ObjectField");
        }
        ignored();
        var r = value(e);
        if (!r) {
          throw error("ObjectField");
        }
        t.push({
          kind: "ObjectField",
          name: i,
          value: r
        });
      }
      if (125 !== c.charCodeAt(h++)) {
        throw error("ObjectValue");
      }
      ignored();
      return {
        kind: "ObjectValue",
        fields: t
      };
    }
  }(e)) {
    return t;
  }
  ignored();
  return t;
}

function arguments_(e) {
  var t = [];
  ignored();
  if (40 === c.charCodeAt(h)) {
    h++;
    ignored();
    var i;
    while (i = name()) {
      ignored();
      if (58 !== c.charCodeAt(h++)) {
        throw error("Argument");
      }
      ignored();
      var r = value(e);
      if (!r) {
        throw error("Argument");
      }
      t.push({
        kind: "Argument",
        name: i,
        value: r
      });
    }
    if (!t.length || 41 !== c.charCodeAt(h++)) {
      throw error("Argument");
    }
    ignored();
  }
  return t;
}

function directives(e) {
  var t = [];
  ignored();
  while (64 === c.charCodeAt(h)) {
    h++;
    var i = name();
    if (!i) {
      throw error("Directive");
    }
    ignored();
    t.push({
      kind: "Directive",
      name: i,
      arguments: arguments_(e)
    });
  }
  return t;
}

function field() {
  var e = name();
  if (e) {
    ignored();
    var t;
    if (58 === c.charCodeAt(h)) {
      h++;
      ignored();
      t = e;
      if (!(e = name())) {
        throw error("Field");
      }
      ignored();
    }
    return {
      kind: "Field",
      alias: t,
      name: e,
      arguments: arguments_(!1),
      directives: directives(!1),
      selectionSet: selectionSet()
    };
  }
}

function type() {
  var e;
  ignored();
  if (91 === c.charCodeAt(h)) {
    h++;
    ignored();
    var t = type();
    if (!t || 93 !== c.charCodeAt(h++)) {
      throw error("ListType");
    }
    e = {
      kind: "ListType",
      type: t
    };
  } else if (e = name()) {
    e = {
      kind: "NamedType",
      name: e
    };
  } else {
    throw error("NamedType");
  }
  ignored();
  if (33 === c.charCodeAt(h)) {
    h++;
    ignored();
    return {
      kind: "NonNullType",
      type: e
    };
  } else {
    return e;
  }
}

var A = /on/y;

function typeCondition() {
  if (advance(A)) {
    ignored();
    var e = name();
    if (!e) {
      throw error("NamedType");
    }
    ignored();
    return {
      kind: "NamedType",
      name: e
    };
  }
}

var b = /\.\.\./y;

function fragmentSpread() {
  if (advance(b)) {
    ignored();
    var e = h;
    var t;
    if ((t = name()) && "on" !== t.value) {
      return {
        kind: "FragmentSpread",
        name: t,
        directives: directives(!1)
      };
    } else {
      h = e;
      var i = typeCondition();
      var r = directives(!1);
      var s = selectionSet();
      if (!s) {
        throw error("InlineFragment");
      }
      return {
        kind: "InlineFragment",
        typeCondition: i,
        directives: r,
        selectionSet: s
      };
    }
  }
}

function selectionSet() {
  var e;
  ignored();
  if (123 === c.charCodeAt(h)) {
    h++;
    ignored();
    var t = [];
    while (e = fragmentSpread() || field()) {
      t.push(e);
    }
    if (!t.length || 125 !== c.charCodeAt(h++)) {
      throw error("SelectionSet");
    }
    ignored();
    return {
      kind: "SelectionSet",
      selections: t
    };
  }
}

var D = /fragment/y;

function fragmentDefinition() {
  if (advance(D)) {
    ignored();
    var e = name();
    if (!e) {
      throw error("FragmentDefinition");
    }
    ignored();
    var t = typeCondition();
    if (!t) {
      throw error("FragmentDefinition");
    }
    var i = directives(!1);
    var r = selectionSet();
    if (!r) {
      throw error("FragmentDefinition");
    }
    return {
      kind: "FragmentDefinition",
      name: e,
      typeCondition: t,
      directives: i,
      selectionSet: r
    };
  }
}

var w = /(?:query|mutation|subscription)/y;

function operationDefinition() {
  var e;
  var t;
  var i = [];
  var r = [];
  if (e = advance(w)) {
    ignored();
    t = name();
    i = function variableDefinitions() {
      var e;
      var t = [];
      ignored();
      if (40 === c.charCodeAt(h)) {
        h++;
        ignored();
        while (e = advance(m)) {
          ignored();
          if (58 !== c.charCodeAt(h++)) {
            throw error("VariableDefinition");
          }
          var i = type();
          var r = void 0;
          if (61 === c.charCodeAt(h)) {
            h++;
            ignored();
            if (!(r = value(!0))) {
              throw error("VariableDefinition");
            }
          }
          ignored();
          t.push({
            kind: "VariableDefinition",
            variable: {
              kind: "Variable",
              name: {
                kind: "Name",
                value: e.slice(1)
              }
            },
            type: i,
            defaultValue: r,
            directives: directives(!0)
          });
        }
        if (41 !== c.charCodeAt(h++)) {
          throw error("VariableDefinition");
        }
        ignored();
      }
      return t;
    }();
    r = directives(!1);
  }
  var s = selectionSet();
  if (s) {
    return {
      kind: "OperationDefinition",
      operation: e || "query",
      name: t,
      variableDefinitions: i,
      directives: r,
      selectionSet: s
    };
  }
}

function parse(e, t) {
  c = "string" == typeof e.body ? e.body : e;
  h = 0;
  return function document() {
    var e;
    ignored();
    var t = [];
    while (e = fragmentDefinition() || operationDefinition()) {
      t.push(e);
    }
    return {
      kind: "Document",
      definitions: t
    };
  }();
}

var k = {};

function visit(e, t) {
  var i = [];
  var r = [];
  try {
    var s = function traverse(e, s, a) {
      var n = !1;
      var o = t[e.kind] && t[e.kind].enter || t[e.kind] || t.enter;
      var l = o && o.call(t, e, s, a, r, i);
      if (!1 === l) {
        return e;
      } else if (null === l) {
        return null;
      } else if (l === k) {
        throw k;
      } else if (l && "string" == typeof l.kind) {
        n = l !== e;
        e = l;
      }
      if (a) {
        i.push(a);
      }
      var u;
      var p = {
        ...e
      };
      for (var f in e) {
        r.push(f);
        var c = e[f];
        if (Array.isArray(c)) {
          var h = [];
          for (var d = 0; d < c.length; d++) {
            if (null != c[d] && "string" == typeof c[d].kind) {
              i.push(e);
              r.push(d);
              u = traverse(c[d], d, c);
              r.pop();
              i.pop();
              if (null == u) {
                n = !0;
              } else {
                n = n || u !== c[d];
                h.push(u);
              }
            }
          }
          c = h;
        } else if (null != c && "string" == typeof c.kind) {
          if (void 0 !== (u = traverse(c, f, e))) {
            n = n || c !== u;
            c = u;
          }
        }
        r.pop();
        if (n) {
          p[f] = c;
        }
      }
      if (a) {
        i.pop();
      }
      var v = t[e.kind] && t[e.kind].leave || t.leave;
      var g = v && v.call(t, e, s, a, r, i);
      if (g === k) {
        throw k;
      } else if (void 0 !== g) {
        return g;
      } else if (void 0 !== l) {
        return n ? p : l;
      } else {
        return n ? p : e;
      }
    }(e);
    return void 0 !== s && !1 !== s ? s : e;
  } catch (t) {
    if (t !== k) {
      throw t;
    }
    return e;
  }
}

var hasItems = e => !(!e || !e.length);

var F = {
  OperationDefinition(e) {
    if ("query" === e.operation && !e.name && !hasItems(e.variableDefinitions) && !hasItems(e.directives)) {
      return F.SelectionSet(e.selectionSet);
    }
    var t = e.operation;
    if (e.name) {
      t += " " + e.name.value;
    }
    if (hasItems(e.variableDefinitions)) {
      if (!e.name) {
        t += " ";
      }
      t += "(" + e.variableDefinitions.map(F.VariableDefinition).join(", ") + ")";
    }
    if (hasItems(e.directives)) {
      t += " " + e.directives.map(F.Directive).join(" ");
    }
    return t + " " + F.SelectionSet(e.selectionSet);
  },
  VariableDefinition(e) {
    var t = F.Variable(e.variable) + ": " + print(e.type);
    if (e.defaultValue) {
      t += " = " + print(e.defaultValue);
    }
    if (hasItems(e.directives)) {
      t += " " + e.directives.map(F.Directive).join(" ");
    }
    return t;
  },
  Field(e) {
    var t = (e.alias ? e.alias.value + ": " : "") + e.name.value;
    if (hasItems(e.arguments)) {
      var i = e.arguments.map(F.Argument);
      var r = t + "(" + i.join(", ") + ")";
      t = r.length > 80 ? t + "(\n  " + i.join("\n").replace(/\n/g, "\n  ") + "\n)" : r;
    }
    if (hasItems(e.directives)) {
      t += " " + e.directives.map(F.Directive).join(" ");
    }
    return e.selectionSet ? t + " " + F.SelectionSet(e.selectionSet) : t;
  },
  StringValue: e => e.block ? function printBlockString(e) {
    return '"""\n' + e.replace(/"""/g, '\\"""') + '\n"""';
  }(e.value) : function printString(e) {
    return JSON.stringify(e);
  }(e.value),
  BooleanValue: e => "" + e.value,
  NullValue: e => "null",
  IntValue: e => e.value,
  FloatValue: e => e.value,
  EnumValue: e => e.value,
  Name: e => e.value,
  Variable: e => "$" + e.name.value,
  ListValue: e => "[" + e.values.map(print).join(", ") + "]",
  ObjectValue: e => "{" + e.fields.map(F.ObjectField).join(", ") + "}",
  ObjectField: e => e.name.value + ": " + print(e.value),
  Document: e => hasItems(e.definitions) ? e.definitions.map(print).join("\n\n") : "",
  SelectionSet: e => "{\n  " + e.selections.map(print).join("\n").replace(/\n/g, "\n  ") + "\n}",
  Argument: e => e.name.value + ": " + print(e.value),
  FragmentSpread(e) {
    var t = "..." + e.name.value;
    if (hasItems(e.directives)) {
      t += " " + e.directives.map(F.Directive).join(" ");
    }
    return t;
  },
  InlineFragment(e) {
    var t = "...";
    if (e.typeCondition) {
      t += " on " + e.typeCondition.name.value;
    }
    if (hasItems(e.directives)) {
      t += " " + e.directives.map(F.Directive).join(" ");
    }
    return t + " " + print(e.selectionSet);
  },
  FragmentDefinition(e) {
    var t = "fragment " + e.name.value;
    t += " on " + e.typeCondition.name.value;
    if (hasItems(e.directives)) {
      t += " " + e.directives.map(F.Directive).join(" ");
    }
    return t + " " + print(e.selectionSet);
  },
  Directive(e) {
    var t = "@" + e.name.value;
    if (hasItems(e.arguments)) {
      t += "(" + e.arguments.map(F.Argument).join(", ") + ")";
    }
    return t;
  },
  NamedType: e => e.name.value,
  ListType: e => "[" + print(e.type) + "]",
  NonNullType: e => print(e.type) + "!"
};

function print(e) {
  return F[e.kind] ? F[e.kind](e) : "";
}

var C = new Set([ "gql", "graphql" ]);

var isIIFE = e => exports.ts.isCallExpression(e) && 0 === e.arguments.length && (exports.ts.isFunctionExpression(e.expression) || exports.ts.isArrowFunction(e.expression)) && !e.expression.asteriskToken && !e.expression.modifiers?.length;

var isGraphQLFunctionIdentifier = e => exports.ts.isIdentifier(e) && C.has(e.escapedText);

var isTadaGraphQLFunction = (e, t) => {
  if (!exports.ts.isLeftHandSideExpression(e)) {
    return !1;
  }
  var i = t?.getTypeAtLocation(e);
  return null != i && null != i.getProperty("scalar") && null != i.getProperty("persisted");
};

var isTadaGraphQLCall = (e, t) => {
  if (!exports.ts.isCallExpression(e)) {
    return !1;
  } else if (e.arguments.length < 1 || e.arguments.length > 2) {
    return !1;
  } else if (!exports.ts.isStringLiteralLike(e.arguments[0])) {
    return !1;
  }
  return t ? isTadaGraphQLFunction(e.expression, t) : !1;
};

var isTadaPersistedCall = (e, t) => {
  if (!e) {
    return !1;
  } else if (!exports.ts.isCallExpression(e)) {
    return !1;
  } else if (!exports.ts.isPropertyAccessExpression(e.expression)) {
    return !1;
  } else if (!exports.ts.isIdentifier(e.expression.name) || "persisted" !== e.expression.name.escapedText) {
    return !1;
  } else if (isGraphQLFunctionIdentifier(e.expression.expression)) {
    return !0;
  } else {
    return isTadaGraphQLFunction(e.expression.expression, t);
  }
};

var isGraphQLCall = (e, t) => exports.ts.isCallExpression(e) && e.arguments.length >= 1 && e.arguments.length <= 2 && (isGraphQLFunctionIdentifier(e.expression) || isTadaGraphQLCall(e, t));

var isGraphQLTag = e => exports.ts.isTaggedTemplateExpression(e) && isGraphQLFunctionIdentifier(e.tag);

var getSchemaName = (e, t, i = !1) => {
  if (!t) {
    return null;
  }
  var r = t.getTypeAtLocation(i ? e.getChildAt(0).getChildAt(0) : e.expression);
  if (r) {
    var s = r.getProperty("__name");
    if (s) {
      var a = t.getTypeOfSymbol(s);
      if (a.isUnionOrIntersection()) {
        var n = a.types.find(e => e.isStringLiteral());
        return n && n.isStringLiteral() ? n.value : null;
      } else if (a.isStringLiteral()) {
        return a.value;
      }
    }
  }
  return null;
};

function isValueDeclaration(e) {
  switch (e.kind) {
   case exports.ts.SyntaxKind.BinaryExpression:
   case exports.ts.SyntaxKind.ArrowFunction:
   case exports.ts.SyntaxKind.BindingElement:
   case exports.ts.SyntaxKind.ClassDeclaration:
   case exports.ts.SyntaxKind.ClassExpression:
   case exports.ts.SyntaxKind.ClassStaticBlockDeclaration:
   case exports.ts.SyntaxKind.Constructor:
   case exports.ts.SyntaxKind.EnumDeclaration:
   case exports.ts.SyntaxKind.EnumMember:
   case exports.ts.SyntaxKind.ExportAssignment:
   case exports.ts.SyntaxKind.FunctionDeclaration:
   case exports.ts.SyntaxKind.FunctionExpression:
   case exports.ts.SyntaxKind.GetAccessor:
   case exports.ts.SyntaxKind.JsxAttribute:
   case exports.ts.SyntaxKind.MethodDeclaration:
   case exports.ts.SyntaxKind.Parameter:
   case exports.ts.SyntaxKind.PropertyAssignment:
   case exports.ts.SyntaxKind.PropertyDeclaration:
   case exports.ts.SyntaxKind.SetAccessor:
   case exports.ts.SyntaxKind.ShorthandPropertyAssignment:
   case exports.ts.SyntaxKind.VariableDeclaration:
    return !0;

   default:
    return !1;
  }
}

function getValueOfValueDeclaration(e) {
  switch (e.kind) {
   case exports.ts.SyntaxKind.ClassExpression:
   case exports.ts.SyntaxKind.ClassDeclaration:
   case exports.ts.SyntaxKind.ArrowFunction:
   case exports.ts.SyntaxKind.ClassStaticBlockDeclaration:
   case exports.ts.SyntaxKind.Constructor:
   case exports.ts.SyntaxKind.EnumDeclaration:
   case exports.ts.SyntaxKind.FunctionDeclaration:
   case exports.ts.SyntaxKind.FunctionExpression:
   case exports.ts.SyntaxKind.GetAccessor:
   case exports.ts.SyntaxKind.SetAccessor:
   case exports.ts.SyntaxKind.MethodDeclaration:
    return e;

   case exports.ts.SyntaxKind.BindingElement:
   case exports.ts.SyntaxKind.EnumMember:
   case exports.ts.SyntaxKind.JsxAttribute:
   case exports.ts.SyntaxKind.Parameter:
   case exports.ts.SyntaxKind.PropertyAssignment:
   case exports.ts.SyntaxKind.PropertyDeclaration:
   case exports.ts.SyntaxKind.VariableDeclaration:
    return e.initializer;

   case exports.ts.SyntaxKind.ExportAssignment:
    return e.expression;

   case exports.ts.SyntaxKind.BinaryExpression:
    return function isAssignmentOperator(e) {
      switch (e.kind) {
       case exports.ts.SyntaxKind.EqualsToken:
       case exports.ts.SyntaxKind.BarBarEqualsToken:
       case exports.ts.SyntaxKind.AmpersandAmpersandEqualsToken:
       case exports.ts.SyntaxKind.QuestionQuestionEqualsToken:
        return !0;

       default:
        return !1;
      }
    }(e.operatorToken) ? e.right : void 0;

   case exports.ts.SyntaxKind.ShorthandPropertyAssignment:
    return e.objectAssignmentInitializer;

   default:
    return;
  }
}

function climbPastPropertyOrElementAccess(e) {
  if (e.parent && exports.ts.isPropertyAccessExpression(e.parent) && e.parent.name === e) {
    return e.parent;
  } else if (e.parent && exports.ts.isElementAccessExpression(e.parent) && e.parent.argumentExpression === e) {
    return e.parent;
  } else {
    return e;
  }
}

function getNameFromPropertyName(e) {
  if (exports.ts.isComputedPropertyName(e)) {
    return exports.ts.isStringLiteralLike(e.expression) || exports.ts.isNumericLiteral(e.expression) ? e.expression.text : void 0;
  } else if (exports.ts.isPrivateIdentifier(e) || exports.ts.isMemberName(e)) {
    return exports.ts.idText(e);
  } else {
    return e.text;
  }
}

function getDeclarationOfIdentifier(e, t) {
  var i = t.getSymbolAtLocation(e);
  if (i?.declarations?.[0] && i.flags & exports.ts.SymbolFlags.Alias && (e.parent === i?.declarations?.[0] || !exports.ts.isNamespaceImport(i.declarations[0]))) {
    var r = t.getAliasedSymbol(i);
    if (r.declarations) {
      i = r;
    }
  }
  if (i && exports.ts.isShorthandPropertyAssignment(e.parent)) {
    var s = t.getShorthandAssignmentValueSymbol(i.valueDeclaration);
    if (s) {
      i = s;
    }
  } else if (exports.ts.isBindingElement(e.parent) && exports.ts.isObjectBindingPattern(e.parent.parent) && e === (e.parent.propertyName || e.parent.name)) {
    var a = getNameFromPropertyName(e);
    var n = a ? t.getTypeAtLocation(e.parent.parent).getProperty(a) : void 0;
    if (n) {
      i = n;
    }
  } else if (exports.ts.isObjectLiteralElement(e.parent) && (exports.ts.isObjectLiteralExpression(e.parent.parent) || exports.ts.isJsxAttributes(e.parent.parent)) && e.parent.name === e) {
    var o = getNameFromPropertyName(e);
    var l = o ? t.getContextualType(e.parent.parent)?.getProperty(o) : void 0;
    if (l) {
      i = l;
    }
  }
  if (i && i.declarations?.length) {
    if (i.flags & exports.ts.SymbolFlags.Class && !(i.flags & (exports.ts.SymbolFlags.Function | exports.ts.SymbolFlags.Variable)) && function isNewExpressionTarget(e) {
      var t = climbPastPropertyOrElementAccess(e).parent;
      return exports.ts.isNewExpression(t) && t.expression === e;
    }(e)) {
      for (var u of i.declarations) {
        if (exports.ts.isClassLike(u)) {
          return u;
        }
      }
    } else if (function isCallOrNewExpressionTarget(e) {
      var t = climbPastPropertyOrElementAccess(e).parent;
      return exports.ts.isCallOrNewExpression(t) && t.expression === e;
    }(e) || function isNameOfFunctionDeclaration(e) {
      return exports.ts.isIdentifier(e) && e.parent && exports.ts.isFunctionLike(e.parent) && e.parent.name === e;
    }(e)) {
      for (var p of i.declarations) {
        if (exports.ts.isFunctionLike(p) && p.body && isValueDeclaration(p)) {
          return p;
        }
      }
    }
    if (i.valueDeclaration && exports.ts.isPropertyAccessExpression(i.valueDeclaration)) {
      var f = i.valueDeclaration.parent;
      if (f && exports.ts.isBinaryExpression(f) && f.left === i.valueDeclaration) {
        return f;
      }
    }
    if (i.valueDeclaration && isValueDeclaration(i.valueDeclaration)) {
      return i.valueDeclaration;
    }
    for (var c of i.declarations) {
      if (isValueDeclaration(c)) {
        return c;
      }
    }
  }
  return;
}

function getValueOfIdentifier(e, t) {
  while (exports.ts.isIdentifier(e)) {
    var i = getDeclarationOfIdentifier(e, t);
    if (!i) {
      return;
    } else {
      var r = getValueOfValueDeclaration(i);
      if (r && exports.ts.isIdentifier(r) && r !== e) {
        e = r;
      } else {
        return r;
      }
    }
  }
}

function resolveTemplate(e, t, i) {
  if (exports.ts.isStringLiteralLike(e)) {
    return {
      combinedText: e.getText().slice(1, -1),
      resolvedSpans: []
    };
  }
  var r = e.template.getText().slice(1, -1);
  if (exports.ts.isNoSubstitutionTemplateLiteral(e.template) || 0 === e.template.templateSpans.length) {
    return {
      combinedText: r,
      resolvedSpans: []
    };
  }
  var s = 0;
  var a = e.template.templateSpans.map(e => {
    if (exports.ts.isIdentifier(e.expression)) {
      var t = i.languageService.getProgram()?.getTypeChecker();
      if (!t) {
        return;
      }
      var a = getDeclarationOfIdentifier(e.expression, t);
      if (!a) {
        return;
      }
      var n = a;
      if (exports.ts.isVariableDeclaration(n)) {
        var o = e.expression.escapedText;
        var l = getValueOfValueDeclaration(n);
        if (!l) {
          return;
        }
        var u = e.expression.getStart() - 2;
        var p = {
          start: u,
          length: e.expression.end - u + 1
        };
        if (exports.ts.isTaggedTemplateExpression(l)) {
          var f = resolveTemplate(l, n.getSourceFile().fileName, i);
          r = r.replace("${" + e.expression.escapedText + "}", f.combinedText);
          var c = {
            lines: f.combinedText.split("\n").length,
            identifier: o,
            original: p,
            new: {
              start: p.start + s,
              length: f.combinedText.length
            }
          };
          s += f.combinedText.length - p.length;
          return c;
        } else if (exports.ts.isAsExpression(l) && exports.ts.isTaggedTemplateExpression(l.expression)) {
          var h = resolveTemplate(l.expression, n.getSourceFile().fileName, i);
          r = r.replace("${" + e.expression.escapedText + "}", h.combinedText);
          var d = {
            lines: h.combinedText.split("\n").length,
            identifier: o,
            original: p,
            new: {
              start: p.start + s,
              length: h.combinedText.length
            }
          };
          s += h.combinedText.length - p.length;
          return d;
        } else if (exports.ts.isAsExpression(l) && exports.ts.isAsExpression(l.expression) && exports.ts.isObjectLiteralExpression(l.expression.expression)) {
          var v = print(JSON.parse(l.expression.expression.getText()));
          r = r.replace("${" + e.expression.escapedText + "}", v);
          var g = {
            lines: v.split("\n").length,
            identifier: o,
            original: p,
            new: {
              start: p.start + s,
              length: v.length
            }
          };
          s += v.length - p.length;
          return g;
        }
        return;
      }
    }
    return;
  }).filter(Boolean);
  return {
    combinedText: r,
    resolvedSpans: a
  };
}

var resolveTadaFragmentArray = e => {
  if (!e) {
    return;
  }
  while (exports.ts.isAsExpression(e)) {
    e = e.expression;
  }
  if (!exports.ts.isArrayLiteralExpression(e)) {
    return;
  }
  if (e.elements.every(exports.ts.isIdentifier)) {
    return e.elements;
  }
  var t = [];
  for (var i of e.elements) {
    while (exports.ts.isPropertyAccessExpression(i)) {
      i = i.name;
    }
    if (exports.ts.isIdentifier(i)) {
      t.push(i);
    }
  }
  return t;
};

function getSource(e, t) {
  var i = e.languageService.getProgram();
  if (!i) {
    return;
  }
  var r = i.getSourceFile(t);
  if (!r) {
    return;
  }
  return r;
}

function findNode(e, t) {
  return function find(e) {
    if (t >= e.getStart() && t < e.getEnd()) {
      return exports.ts.forEachChild(e, find) || e;
    }
  }(e);
}

function unrollFragment(t, i, r) {
  var s = [];
  var a = [ t ];
  var n = new WeakSet;
  var _unrollElement = t => {
    if (n.has(t)) {
      return;
    }
    n.add(t);
    var i = function resolveIdentifierToGraphQLCall(e, t, i) {
      if (!i) {
        return null;
      }
      var r = getValueOfIdentifier(e, i);
      if (!r) {
        return null;
      }
      return isGraphQLCall(r, i) ? r : null;
    }(t, 0, r);
    if (!i) {
      return;
    }
    var o = resolveTadaFragmentArray(i.arguments[1]);
    if (o) {
      a.push(...o);
    }
    try {
      e.parse(i.arguments[0].getText().slice(1, -1), {
        noLocation: !0
      }).definitions.forEach(e => {
        if ("FragmentDefinition" === e.kind) {
          s.push(e);
        }
      });
    } catch (e) {}
  };
  var o;
  while (void 0 !== (o = a.shift())) {
    _unrollElement(o);
  }
  return s;
}

function unrollTadaFragments(e, t, i) {
  var r = i.languageService.getProgram()?.getTypeChecker();
  e.elements.forEach(e => {
    if (exports.ts.isIdentifier(e)) {
      t.push(...unrollFragment(e, 0, r));
    } else if (exports.ts.isPropertyAccessExpression(e)) {
      var i = e;
      while (exports.ts.isPropertyAccessExpression(i.expression)) {
        i = i.expression;
      }
      if (exports.ts.isIdentifier(i.name)) {
        t.push(...unrollFragment(i.name, 0, r));
      }
    }
  });
  return t;
}

function findAllCallExpressions(e, t, i = !0) {
  var r = t.languageService.getProgram()?.getTypeChecker();
  var s = [];
  var a = [];
  var n = i ? !1 : !0;
  !function find(e) {
    if (!exports.ts.isCallExpression(e) || isIIFE(e)) {
      return exports.ts.forEachChild(e, find);
    }
    if (!isGraphQLCall(e, r)) {
      return exports.ts.forEachChild(e, find);
    }
    var i = getSchemaName(e, r);
    var o = e.arguments[0];
    var l = resolveTadaFragmentArray(e.arguments[1]);
    var u = isTadaGraphQLCall(e, r);
    if (!n && !l) {
      if (!u) {
        n = !0;
        a.push(...getAllFragments(e, t));
      }
    } else if (l) {
      for (var p of l) {
        a.push(...unrollFragment(p, 0, r));
      }
    }
    if (o && exports.ts.isStringLiteralLike(o)) {
      s.push({
        node: o,
        schema: i,
        tadaFragmentRefs: u ? void 0 === l ? [] : l : void 0
      });
    }
  }(e);
  return {
    nodes: s,
    fragments: a
  };
}

function findAllPersistedCallExpressions(e, t) {
  var i = [];
  var r = t?.languageService.getProgram()?.getTypeChecker();
  !function find(e) {
    if (!exports.ts.isCallExpression(e) || isIIFE(e)) {
      return exports.ts.forEachChild(e, find);
    }
    if (!isTadaPersistedCall(e, r)) {
      return;
    } else if (t) {
      var s = getSchemaName(e, r, !0);
      i.push({
        node: e,
        schema: s
      });
    } else {
      i.push(e);
    }
  }(e);
  return i;
}

function getAllFragments(t, i) {
  var r = [];
  var s = i.languageService.getProgram()?.getTypeChecker();
  if (!exports.ts.isCallExpression(t)) {
    return r;
  }
  var a = resolveTadaFragmentArray(t.arguments[1]);
  if (a) {
    var n = i.languageService.getProgram()?.getTypeChecker();
    for (var o of a) {
      r.push(...unrollFragment(o, 0, n));
    }
    return r;
  } else if (isTadaGraphQLCall(t, s)) {
    return r;
  }
  if (!s) {
    return r;
  }
  var l =