import { init_esm_shims } from './chunk-H26U4HNL.js';

// ../../node_modules/.pnpm/prettier@3.6.2/node_modules/prettier/plugins/graphql.mjs
init_esm_shims();
var Et = Object.defineProperty;
var xe = (e2, t) => {
  for (var n in t) Et(e2, n, {
    get: t[n],
    enumerable: true
  });
};
var Ne = {};
xe(Ne, {
  languages: () => Qe,
  options: () => Ke,
  parsers: () => _e,
  printers: () => pn
});
var Tt = (e2, t, n, i) => {
  if (!(e2 && t == null)) return t.replaceAll ? t.replaceAll(n, i) : n.global ? t.replace(n, i) : t.split(n).join(i);
};
var G = Tt;
var j = "indent";
var $ = "group";
var w = "if-break";
var S = "line";
var X = "break-parent";
var Re = () => {
};
var le = Re;
function N(e2) {
  return {
    type: j,
    contents: e2
  };
}
function y(e2, t = {}) {
  return le(t.expandedStates), {
    type: $,
    id: t.id,
    contents: e2,
    break: !!t.shouldBreak,
    expandedStates: t.expandedStates
  };
}
function I(e2, t = "", n = {}) {
  return {
    type: w,
    breakContents: e2,
    flatContents: t,
    groupId: n.groupId
  };
}
var yt = {
  type: X
};
var Ot = {
  type: S,
  hard: true
};
var k = {
  type: S
};
var p = {
  type: S,
  soft: true
};
var f = [Ot, yt];
function E(e2, t) {
  let n = [];
  for (let i = 0; i < t.length; i++) i !== 0 && n.push(e2), n.push(t[i]);
  return n;
}
function H(e2) {
  return (t, n, i) => {
    let r = !!(i != null && i.backwards);
    if (n === false) return false;
    let {
      length: s
    } = t, a = n;
    for (; a >= 0 && a < s; ) {
      let u = t.charAt(a);
      if (e2 instanceof RegExp) {
        if (!e2.test(u)) return a;
      } else if (!e2.includes(u)) return a;
      r ? a-- : a++;
    }
    return a === -1 || a === s ? a : false;
  };
}
var J = H(" 	");
var ve = H(",; 	");
var Le = H(/[^\n\r]/u);
function It(e2, t, n) {
  let i = !!(n != null && n.backwards);
  if (t === false) return false;
  let r = e2.charAt(t);
  if (i) {
    if (e2.charAt(t - 1) === "\r" && r === `
`) return t - 2;
    if (r === `
` || r === "\r" || r === "\u2028" || r === "\u2029") return t - 1;
  } else {
    if (r === "\r" && e2.charAt(t + 1) === `
`) return t + 2;
    if (r === `
` || r === "\r" || r === "\u2028" || r === "\u2029") return t + 1;
  }
  return t;
}
var q = It;
function At(e2, t, n = {}) {
  let i = J(e2, n.backwards ? t - 1 : t, n), r = q(e2, i, n);
  return i !== r;
}
var be = At;
function Dt(e2, t) {
  if (t === false) return false;
  if (e2.charAt(t) === "/" && e2.charAt(t + 1) === "*") {
    for (let n = t + 2; n < e2.length; ++n) if (e2.charAt(n) === "*" && e2.charAt(n + 1) === "/") return n + 2;
  }
  return t;
}
var Pe = Dt;
function gt(e2, t) {
  return t === false ? false : e2.charAt(t) === "/" && e2.charAt(t + 1) === "/" ? Le(e2, t) : t;
}
var we = gt;
function kt(e2, t) {
  let n = null, i = t;
  for (; i !== n; ) n = i, i = ve(e2, i), i = Pe(e2, i), i = J(e2, i);
  return i = we(e2, i), i = q(e2, i), i !== false && be(e2, i);
}
var Fe = kt;
function St(e2) {
  return Array.isArray(e2) && e2.length > 0;
}
var pe = St;
var fe = class extends Error {
  name = "UnexpectedNodeError";
  constructor(t, n, i = "type") {
    super(`Unexpected ${n} node ${i}: ${JSON.stringify(t[i])}.`), this.node = t;
  }
};
var Be = fe;
var F = null;
function B(e2) {
  if (F !== null && typeof F.property) {
    let t = F;
    return F = B.prototype = null, t;
  }
  return F = B.prototype = e2 ?? /* @__PURE__ */ Object.create(null), new B();
}
var Ct = 10;
for (let e2 = 0; e2 <= Ct; e2++) B();
function he(e2) {
  return B(e2);
}
function Rt(e2, t = "type") {
  he(e2);
  function n(i) {
    let r = i[t], s = e2[r];
    if (!Array.isArray(s)) throw Object.assign(new Error(`Missing visitor keys for '${r}'.`), {
      node: i
    });
    return s;
  }
  return n;
}
var Ue = Rt;
var Q = class {
  constructor(t, n, i) {
    this.start = t.start, this.end = n.end, this.startToken = t, this.endToken = n, this.source = i;
  }
  get [Symbol.toStringTag]() {
    return "Location";
  }
  toJSON() {
    return {
      start: this.start,
      end: this.end
    };
  }
};
var U = class {
  constructor(t, n, i, r, s, a) {
    this.kind = t, this.start = n, this.end = i, this.line = r, this.column = s, this.value = a, this.prev = null, this.next = null;
  }
  get [Symbol.toStringTag]() {
    return "Token";
  }
  toJSON() {
    return {
      kind: this.kind,
      value: this.value,
      line: this.line,
      column: this.column
    };
  }
};
var W = {
  Name: [],
  Document: ["definitions"],
  OperationDefinition: ["name", "variableDefinitions", "directives", "selectionSet"],
  VariableDefinition: ["variable", "type", "defaultValue", "directives"],
  Variable: ["name"],
  SelectionSet: ["selections"],
  Field: ["alias", "name", "arguments", "directives", "selectionSet"],
  Argument: ["name", "value"],
  FragmentSpread: ["name", "directives"],
  InlineFragment: ["typeCondition", "directives", "selectionSet"],
  FragmentDefinition: ["name", "variableDefinitions", "typeCondition", "directives", "selectionSet"],
  IntValue: [],
  FloatValue: [],
  StringValue: [],
  BooleanValue: [],
  NullValue: [],
  EnumValue: [],
  ListValue: ["values"],
  ObjectValue: ["fields"],
  ObjectField: ["name", "value"],
  Directive: ["name", "arguments"],
  NamedType: ["name"],
  ListType: ["type"],
  NonNullType: ["type"],
  SchemaDefinition: ["description", "directives", "operationTypes"],
  OperationTypeDefinition: ["type"],
  ScalarTypeDefinition: ["description", "name", "directives"],
  ObjectTypeDefinition: ["description", "name", "interfaces", "directives", "fields"],
  FieldDefinition: ["description", "name", "arguments", "type", "directives"],
  InputValueDefinition: ["description", "name", "type", "defaultValue", "directives"],
  InterfaceTypeDefinition: ["description", "name", "interfaces", "directives", "fields"],
  UnionTypeDefinition: ["description", "name", "directives", "types"],
  EnumTypeDefinition: ["description", "name", "directives", "values"],
  EnumValueDefinition: ["description", "name", "directives"],
  InputObjectTypeDefinition: ["description", "name", "directives", "fields"],
  DirectiveDefinition: ["description", "name", "arguments", "locations"],
  SchemaExtension: ["directives", "operationTypes"],
  ScalarTypeExtension: ["name", "directives"],
  ObjectTypeExtension: ["name", "interfaces", "directives", "fields"],
  InterfaceTypeExtension: ["name", "interfaces", "directives", "fields"],
  UnionTypeExtension: ["name", "directives", "types"],
  EnumTypeExtension: ["name", "directives", "values"],
  InputObjectTypeExtension: ["name", "directives", "fields"]
};
new Set(Object.keys(W));
var C;
(function(e2) {
  e2.QUERY = "query", e2.MUTATION = "mutation", e2.SUBSCRIPTION = "subscription";
})(C || (C = {}));
var vt = Ue(W, "kind");
var Me = vt;
function K(e2) {
  return e2.loc.start;
}
function z(e2) {
  return e2.loc.end;
}
var Ve = "format";
var Ye = /^\s*#[^\S\n]*@(?:noformat|noprettier)\s*(?:\n|$)/u;
var Ge = /^\s*#[^\S\n]*@(?:format|prettier)\s*(?:\n|$)/u;
function je(e2) {
  return Ge.test(e2);
}
function $e(e2) {
  return Ye.test(e2);
}
function Xe(e2) {
  return `# @${Ve}

${e2}`;
}
function Lt(e2, t, n) {
  let {
    node: i
  } = e2;
  if (!i.description) return "";
  let r = [n("description")];
  return i.kind === "InputValueDefinition" && !i.description.block ? r.push(k) : r.push(f), r;
}
var D = Lt;
function bt(e2, t, n) {
  let {
    node: i
  } = e2;
  switch (i.kind) {
    case "Document":
      return [...E(f, g(e2, t, n, "definitions")), f];
    case "OperationDefinition": {
      let r = t.originalText[K(i)] !== "{", s = !!i.name;
      return [r ? i.operation : "", r && s ? [" ", n("name")] : "", r && !s && pe(i.variableDefinitions) ? " " : "", He(e2, n), x(e2, n, i), !r && !s ? "" : " ", n("selectionSet")];
    }
    case "FragmentDefinition":
      return ["fragment ", n("name"), He(e2, n), " on ", n("typeCondition"), x(e2, n, i), " ", n("selectionSet")];
    case "SelectionSet":
      return ["{", N([f, E(f, g(e2, t, n, "selections"))]), f, "}"];
    case "Field":
      return y([i.alias ? [n("alias"), ": "] : "", n("name"), i.arguments.length > 0 ? y(["(", N([p, E([I("", ", "), p], g(e2, t, n, "arguments"))]), p, ")"]) : "", x(e2, n, i), i.selectionSet ? " " : "", n("selectionSet")]);
    case "Name":
      return i.value;
    case "StringValue":
      if (i.block) {
        let r = G(false, i.value, '"""', String.raw`\"""`).split(`
`);
        return r.length === 1 && (r[0] = r[0].trim()), r.every((s) => s === "") && (r.length = 0), E(f, ['"""', ...r, '"""']);
      }
      return ['"', G(false, G(false, i.value, /["\\]/gu, String.raw`\$&`), `
`, String.raw`\n`), '"'];
    case "IntValue":
    case "FloatValue":
    case "EnumValue":
      return i.value;
    case "BooleanValue":
      return i.value ? "true" : "false";
    case "NullValue":
      return "null";
    case "Variable":
      return ["$", n("name")];
    case "ListValue":
      return y(["[", N([p, E([I("", ", "), p], e2.map(n, "values"))]), p, "]"]);
    case "ObjectValue": {
      let r = t.bracketSpacing && i.fields.length > 0 ? " " : "";
      return y(["{", r, N([p, E([I("", ", "), p], e2.map(n, "fields"))]), p, I("", r), "}"]);
    }
    case "ObjectField":
    case "Argument":
      return [n("name"), ": ", n("value")];
    case "Directive":
      return ["@", n("name"), i.arguments.length > 0 ? y(["(", N([p, E([I("", ", "), p], g(e2, t, n, "arguments"))]), p, ")"]) : ""];
    case "NamedType":
      return n("name");
    case "VariableDefinition":
      return [n("variable"), ": ", n("type"), i.defaultValue ? [" = ", n("defaultValue")] : "", x(e2, n, i)];
    case "ObjectTypeExtension":
    case "ObjectTypeDefinition":
    case "InputObjectTypeExtension":
    case "InputObjectTypeDefinition":
    case "InterfaceTypeExtension":
    case "InterfaceTypeDefinition": {
      let {
        kind: r
      } = i, s = [];
      return r.endsWith("TypeDefinition") ? s.push(D(e2, t, n)) : s.push("extend "), r.startsWith("ObjectType") ? s.push("type") : r.startsWith("InputObjectType") ? s.push("input") : s.push("interface"), s.push(" ", n("name")), !r.startsWith("InputObjectType") && i.interfaces.length > 0 && s.push(" implements ", ...Ft(e2, t, n)), s.push(x(e2, n, i)), i.fields.length > 0 && s.push([" {", N([f, E(f, g(e2, t, n, "fields"))]), f, "}"]), s;
    }
    case "FieldDefinition":
      return [D(e2, t, n), n("name"), i.arguments.length > 0 ? y(["(", N([p, E([I("", ", "), p], g(e2, t, n, "arguments"))]), p, ")"]) : "", ": ", n("type"), x(e2, n, i)];
    case "DirectiveDefinition":
      return [D(e2, t, n), "directive ", "@", n("name"), i.arguments.length > 0 ? y(["(", N([p, E([I("", ", "), p], g(e2, t, n, "arguments"))]), p, ")"]) : "", i.repeatable ? " repeatable" : "", " on ", ...E(" | ", e2.map(n, "locations"))];
    case "EnumTypeExtension":
    case "EnumTypeDefinition":
      return [D(e2, t, n), i.kind === "EnumTypeExtension" ? "extend " : "", "enum ", n("name"), x(e2, n, i), i.values.length > 0 ? [" {", N([f, E(f, g(e2, t, n, "values"))]), f, "}"] : ""];
    case "EnumValueDefinition":
      return [D(e2, t, n), n("name"), x(e2, n, i)];
    case "InputValueDefinition":
      return [D(e2, t, n), n("name"), ": ", n("type"), i.defaultValue ? [" = ", n("defaultValue")] : "", x(e2, n, i)];
    case "SchemaExtension":
      return ["extend schema", x(e2, n, i), ...i.operationTypes.length > 0 ? [" {", N([f, E(f, g(e2, t, n, "operationTypes"))]), f, "}"] : []];
    case "SchemaDefinition":
      return [D(e2, t, n), "schema", x(e2, n, i), " {", i.operationTypes.length > 0 ? N([f, E(f, g(e2, t, n, "operationTypes"))]) : "", f, "}"];
    case "OperationTypeDefinition":
      return [i.operation, ": ", n("type")];
    case "FragmentSpread":
      return ["...", n("name"), x(e2, n, i)];
    case "InlineFragment":
      return ["...", i.typeCondition ? [" on ", n("typeCondition")] : "", x(e2, n, i), " ", n("selectionSet")];
    case "UnionTypeExtension":
    case "UnionTypeDefinition":
      return y([D(e2, t, n), y([i.kind === "UnionTypeExtension" ? "extend " : "", "union ", n("name"), x(e2, n, i), i.types.length > 0 ? [" =", I("", " "), N([I([k, "| "]), E([k, "| "], e2.map(n, "types"))])] : ""])]);
    case "ScalarTypeExtension":
    case "ScalarTypeDefinition":
      return [D(e2, t, n), i.kind === "ScalarTypeExtension" ? "extend " : "", "scalar ", n("name"), x(e2, n, i)];
    case "NonNullType":
      return [n("type"), "!"];
    case "ListType":
      return ["[", n("type"), "]"];
    default:
      throw new Be(i, "Graphql", "kind");
  }
}
function x(e2, t, n) {
  if (n.directives.length === 0) return "";
  let i = E(k, e2.map(t, "directives"));
  return n.kind === "FragmentDefinition" || n.kind === "OperationDefinition" ? y([k, i]) : [" ", y(N([p, i]))];
}
function g(e2, t, n, i) {
  return e2.map(({
    isLast: r,
    node: s
  }) => {
    let a = n();
    return !r && Fe(t.originalText, z(s)) ? [a, f] : a;
  }, i);
}
function Pt(e2) {
  return e2.kind !== "Comment";
}
function wt(e2) {
  let t = e2.node;
  if (t.kind === "Comment") return "#" + t.value.trimEnd();
  throw new Error("Not a comment: " + JSON.stringify(t));
}
function Ft(e2, t, n) {
  let {
    node: i
  } = e2, r = [], {
    interfaces: s
  } = i, a = e2.map(n, "interfaces");
  for (let u = 0; u < s.length; u++) {
    let l = s[u];
    r.push(a[u]);
    let T = s[u + 1];
    if (T) {
      let A = t.originalText.slice(l.loc.end, T.loc.start).includes("#");
      r.push(" &", A ? k : " ");
    }
  }
  return r;
}
function He(e2, t) {
  let {
    node: n
  } = e2;
  return pe(n.variableDefinitions) ? y(["(", N([p, E([I("", ", "), p], e2.map(t, "variableDefinitions"))]), p, ")"]) : "";
}
function Je(e2, t) {
  e2.kind === "StringValue" && e2.block && !e2.value.includes(`
`) && (t.value = e2.value.trim());
}
Je.ignoredProperties = /* @__PURE__ */ new Set(["loc", "comments"]);
function Bt(e2) {
  var n;
  let {
    node: t
  } = e2;
  return (n = t == null ? void 0 : t.comments) == null ? void 0 : n.some((i) => i.value.trim() === "prettier-ignore");
}
var Ut = {
  print: bt,
  massageAstNode: Je,
  hasPrettierIgnore: Bt,
  insertPragma: Xe,
  printComment: wt,
  canAttachComment: Pt,
  getVisitorKeys: Me
};
var qe = Ut;
var Qe = [{
  name: "GraphQL",
  type: "data",
  extensions: [".graphql", ".gql", ".graphqls"],
  tmScope: "source.graphql",
  aceMode: "text",
  parsers: ["graphql"],
  vscodeLanguageIds: ["graphql"],
  linguistLanguageId: 139
}];
var We = {
  bracketSpacing: {
    category: "Common",
    type: "boolean",
    default: true,
    description: "Print spaces between brackets.",
    oppositeDescription: "Do not print spaces between brackets."
  }};
var Mt = {
  bracketSpacing: We.bracketSpacing
};
var Ke = Mt;
var _e = {};
xe(_e, {
  graphql: () => ln
});
function ze(e2) {
  return typeof e2 == "object" && e2 !== null;
}
function Ze(e2, t) {
  throw new Error("Unexpected invariant triggered.");
}
var Vt = /\r\n|[\n\r]/g;
function M(e2, t) {
  let n = 0, i = 1;
  for (let r of e2.body.matchAll(Vt)) {
    if (typeof r.index == "number" || Ze(), r.index >= t) break;
    n = r.index + r[0].length, i += 1;
  }
  return {
    line: i,
    column: t + 1 - n
  };
}
function tt(e2) {
  return de(e2.source, M(e2.source, e2.start));
}
function de(e2, t) {
  let n = e2.locationOffset.column - 1, i = "".padStart(n) + e2.body, r = t.line - 1, s = e2.locationOffset.line - 1, a = t.line + s, u = t.line === 1 ? n : 0, l = t.column + u, T = `${e2.name}:${a}:${l}
`, h = i.split(/\r\n|[\n\r]/g), A = h[r];
  if (A.length > 120) {
    let O = Math.floor(l / 80), ae = l % 80, _ = [];
    for (let v = 0; v < A.length; v += 80) _.push(A.slice(v, v + 80));
    return T + et([[`${a} |`, _[0]], ..._.slice(1, O + 1).map((v) => ["|", v]), ["|", "^".padStart(ae)], ["|", _[O + 1]]]);
  }
  return T + et([[`${a - 1} |`, h[r - 1]], [`${a} |`, A], ["|", "^".padStart(l)], [`${a + 1} |`, h[r + 1]]]);
}
function et(e2) {
  let t = e2.filter(([i, r]) => r !== void 0), n = Math.max(...t.map(([i]) => i.length));
  return t.map(([i, r]) => i.padStart(n) + (r ? " " + r : "")).join(`
`);
}
function Yt(e2) {
  let t = e2[0];
  return t == null || "kind" in t || "length" in t ? {
    nodes: t,
    source: e2[1],
    positions: e2[2],
    path: e2[3],
    originalError: e2[4],
    extensions: e2[5]
  } : t;
}
var Z = class e extends Error {
  constructor(t, ...n) {
    var i, r, s;
    let {
      nodes: a,
      source: u,
      positions: l,
      path: T,
      originalError: h,
      extensions: A
    } = Yt(n);
    super(t), this.name = "GraphQLError", this.path = T ?? void 0, this.originalError = h ?? void 0, this.nodes = nt(Array.isArray(a) ? a : a ? [a] : void 0);
    let O = nt((i = this.nodes) === null || i === void 0 ? void 0 : i.map((_) => _.loc).filter((_) => _ != null));
    this.source = u ?? (O == null || (r = O[0]) === null || r === void 0 ? void 0 : r.source), this.positions = l ?? (O == null ? void 0 : O.map((_) => _.start)), this.locations = l && u ? l.map((_) => M(u, _)) : O == null ? void 0 : O.map((_) => M(_.source, _.start));
    let ae = ze(h == null ? void 0 : h.extensions) ? h == null ? void 0 : h.extensions : void 0;
    this.extensions = (s = A ?? ae) !== null && s !== void 0 ? s : /* @__PURE__ */ Object.create(null), Object.defineProperties(this, {
      message: {
        writable: true,
        enumerable: true
      },
      name: {
        enumerable: false
      },
      nodes: {
        enumerable: false
      },
      source: {
        enumerable: false
      },
      positions: {
        enumerable: false
      },
      originalError: {
        enumerable: false
      }
    }), h != null && h.stack ? Object.defineProperty(this, "stack", {
      value: h.stack,
      writable: true,
      configurable: true
    }) : Error.captureStackTrace ? Error.captureStackTrace(this, e) : Object.defineProperty(this, "stack", {
      value: Error().stack,
      writable: true,
      configurable: true
    });
  }
  get [Symbol.toStringTag]() {
    return "GraphQLError";
  }
  toString() {
    let t = this.message;
    if (this.nodes) for (let n of this.nodes) n.loc && (t += `

` + tt(n.loc));
    else if (this.source && this.locations) for (let n of this.locations) t += `

` + de(this.source, n);
    return t;
  }
  toJSON() {
    let t = {
      message: this.message
    };
    return this.locations != null && (t.locations = this.locations), this.path != null && (t.path = this.path), this.extensions != null && Object.keys(this.extensions).length > 0 && (t.extensions = this.extensions), t;
  }
};
function nt(e2) {
  return e2 === void 0 || e2.length === 0 ? void 0 : e2;
}
function d(e2, t, n) {
  return new Z(`Syntax Error: ${n}`, {
    source: e2,
    positions: [t]
  });
}
var ee;
(function(e2) {
  e2.QUERY = "QUERY", e2.MUTATION = "MUTATION", e2.SUBSCRIPTION = "SUBSCRIPTION", e2.FIELD = "FIELD", e2.FRAGMENT_DEFINITION = "FRAGMENT_DEFINITION", e2.FRAGMENT_SPREAD = "FRAGMENT_SPREAD", e2.INLINE_FRAGMENT = "INLINE_FRAGMENT", e2.VARIABLE_DEFINITION = "VARIABLE_DEFINITION", e2.SCHEMA = "SCHEMA", e2.SCALAR = "SCALAR", e2.OBJECT = "OBJECT", e2.FIELD_DEFINITION = "FIELD_DEFINITION", e2.ARGUMENT_DEFINITION = "ARGUMENT_DEFINITION", e2.INTERFACE = "INTERFACE", e2.UNION = "UNION", e2.ENUM = "ENUM", e2.ENUM_VALUE = "ENUM_VALUE", e2.INPUT_OBJECT = "INPUT_OBJECT", e2.INPUT_FIELD_DEFINITION = "INPUT_FIELD_DEFINITION";
})(ee || (ee = {}));
var c;
(function(e2) {
  e2.NAME = "Name", e2.DOCUMENT = "Document", e2.OPERATION_DEFINITION = "OperationDefinition", e2.VARIABLE_DEFINITION = "VariableDefinition", e2.SELECTION_SET = "SelectionSet", e2.FIELD = "Field", e2.ARGUMENT = "Argument", e2.FRAGMENT_SPREAD = "FragmentSpread", e2.INLINE_FRAGMENT = "InlineFragment", e2.FRAGMENT_DEFINITION = "FragmentDefinition", e2.VARIABLE = "Variable", e2.INT = "IntValue", e2.FLOAT = "FloatValue", e2.STRING = "StringValue", e2.BOOLEAN = "BooleanValue", e2.NULL = "NullValue", e2.ENUM = "EnumValue", e2.LIST = "ListValue", e2.OBJECT = "ObjectValue", e2.OBJECT_FIELD = "ObjectField", e2.DIRECTIVE = "Directive", e2.NAMED_TYPE = "NamedType", e2.LIST_TYPE = "ListType", e2.NON_NULL_TYPE = "NonNullType", e2.SCHEMA_DEFINITION = "SchemaDefinition", e2.OPERATION_TYPE_DEFINITION = "OperationTypeDefinition", e2.SCALAR_TYPE_DEFINITION = "ScalarTypeDefinition", e2.OBJECT_TYPE_DEFINITION = "ObjectTypeDefinition", e2.FIELD_DEFINITION = "FieldDefinition", e2.INPUT_VALUE_DEFINITION = "InputValueDefinition", e2.INTERFACE_TYPE_DEFINITION = "InterfaceTypeDefinition", e2.UNION_TYPE_DEFINITION = "UnionTypeDefinition", e2.ENUM_TYPE_DEFINITION = "EnumTypeDefinition", e2.ENUM_VALUE_DEFINITION = "EnumValueDefinition", e2.INPUT_OBJECT_TYPE_DEFINITION = "InputObjectTypeDefinition", e2.DIRECTIVE_DEFINITION = "DirectiveDefinition", e2.SCHEMA_EXTENSION = "SchemaExtension", e2.SCALAR_TYPE_EXTENSION = "ScalarTypeExtension", e2.OBJECT_TYPE_EXTENSION = "ObjectTypeExtension", e2.INTERFACE_TYPE_EXTENSION = "InterfaceTypeExtension", e2.UNION_TYPE_EXTENSION = "UnionTypeExtension", e2.ENUM_TYPE_EXTENSION = "EnumTypeExtension", e2.INPUT_OBJECT_TYPE_EXTENSION = "InputObjectTypeExtension";
})(c || (c = {}));
function rt(e2) {
  return e2 === 9 || e2 === 32;
}
function b(e2) {
  return e2 >= 48 && e2 <= 57;
}
function it(e2) {
  return e2 >= 97 && e2 <= 122 || e2 >= 65 && e2 <= 90;
}
function me(e2) {
  return it(e2) || e2 === 95;
}
function st(e2) {
  return it(e2) || b(e2) || e2 === 95;
}
function ot(e2) {
  var t;
  let n = Number.MAX_SAFE_INTEGER, i = null, r = -1;
  for (let a = 0; a < e2.length; ++a) {
    var s;
    let u = e2[a], l = Gt(u);
    l !== u.length && (i = (s = i) !== null && s !== void 0 ? s : a, r = a, a !== 0 && l < n && (n = l));
  }
  return e2.map((a, u) => u === 0 ? a : a.slice(n)).slice((t = i) !== null && t !== void 0 ? t : 0, r + 1);
}
function Gt(e2) {
  let t = 0;
  for (; t < e2.length && rt(e2.charCodeAt(t)); ) ++t;
  return t;
}
var o;
(function(e2) {
  e2.SOF = "<SOF>", e2.EOF = "<EOF>", e2.BANG = "!", e2.DOLLAR = "$", e2.AMP = "&", e2.PAREN_L = "(", e2.PAREN_R = ")", e2.SPREAD = "...", e2.COLON = ":", e2.EQUALS = "=", e2.AT = "@", e2.BRACKET_L = "[", e2.BRACKET_R = "]", e2.BRACE_L = "{", e2.PIPE = "|", e2.BRACE_R = "}", e2.NAME = "Name", e2.INT = "Int", e2.FLOAT = "Float", e2.STRING = "String", e2.BLOCK_STRING = "BlockString", e2.COMMENT = "Comment";
})(o || (o = {}));
var te = class {
  constructor(t) {
    let n = new U(o.SOF, 0, 0, 0, 0);
    this.source = t, this.lastToken = n, this.token = n, this.line = 1, this.lineStart = 0;
  }
  get [Symbol.toStringTag]() {
    return "Lexer";
  }
  advance() {
    return this.lastToken = this.token, this.token = this.lookahead();
  }
  lookahead() {
    let t = this.token;
    if (t.kind !== o.EOF) do
      if (t.next) t = t.next;
      else {
        let n = jt(this, t.end);
        t.next = n, n.prev = t, t = n;
      }
    while (t.kind === o.COMMENT);
    return t;
  }
};
function ct(e2) {
  return e2 === o.BANG || e2 === o.DOLLAR || e2 === o.AMP || e2 === o.PAREN_L || e2 === o.PAREN_R || e2 === o.SPREAD || e2 === o.COLON || e2 === o.EQUALS || e2 === o.AT || e2 === o.BRACKET_L || e2 === o.BRACKET_R || e2 === o.BRACE_L || e2 === o.PIPE || e2 === o.BRACE_R;
}
function P(e2) {
  return e2 >= 0 && e2 <= 55295 || e2 >= 57344 && e2 <= 1114111;
}
function ne(e2, t) {
  return ut(e2.charCodeAt(t)) && lt(e2.charCodeAt(t + 1));
}
function ut(e2) {
  return e2 >= 55296 && e2 <= 56319;
}
function lt(e2) {
  return e2 >= 56320 && e2 <= 57343;
}
function R(e2, t) {
  let n = e2.source.body.codePointAt(t);
  if (n === void 0) return o.EOF;
  if (n >= 32 && n <= 126) {
    let i = String.fromCodePoint(n);
    return i === '"' ? `'"'` : `"${i}"`;
  }
  return "U+" + n.toString(16).toUpperCase().padStart(4, "0");
}
function m(e2, t, n, i, r) {
  let s = e2.line, a = 1 + n - e2.lineStart;
  return new U(t, n, i, s, a, r);
}
function jt(e2, t) {
  let n = e2.source.body, i = n.length, r = t;
  for (; r < i; ) {
    let s = n.charCodeAt(r);
    switch (s) {
      case 65279:
      case 9:
      case 32:
      case 44:
        ++r;
        continue;
      case 10:
        ++r, ++e2.line, e2.lineStart = r;
        continue;
      case 13:
        n.charCodeAt(r + 1) === 10 ? r += 2 : ++r, ++e2.line, e2.lineStart = r;
        continue;
      case 35:
        return $t(e2, r);
      case 33:
        return m(e2, o.BANG, r, r + 1);
      case 36:
        return m(e2, o.DOLLAR, r, r + 1);
      case 38:
        return m(e2, o.AMP, r, r + 1);
      case 40:
        return m(e2, o.PAREN_L, r, r + 1);
      case 41:
        return m(e2, o.PAREN_R, r, r + 1);
      case 46:
        if (n.charCodeAt(r + 1) === 46 && n.charCodeAt(r + 2) === 46) return m(e2, o.SPREAD, r, r + 3);
        break;
      case 58:
        return m(e2, o.COLON, r, r + 1);
      case 61:
        return m(e2, o.EQUALS, r, r + 1);
      case 64:
        return m(e2, o.AT, r, r + 1);
      case 91:
        return m(e2, o.BRACKET_L, r, r + 1);
      case 93:
        return m(e2, o.BRACKET_R, r, r + 1);
      case 123:
        return m(e2, o.BRACE_L, r, r + 1);
      case 124:
        return m(e2, o.PIPE, r, r + 1);
      case 125:
        return m(e2, o.BRACE_R, r, r + 1);
      case 34:
        return n.charCodeAt(r + 1) === 34 && n.charCodeAt(r + 2) === 34 ? Wt(e2, r) : Ht(e2, r);
    }
    if (b(s) || s === 45) return Xt(e2, r, s);
    if (me(s)) return Kt(e2, r);
    throw d(e2.source, r, s === 39 ? `Unexpected single quote character ('), did you mean to use a double quote (")?` : P(s) || ne(n, r) ? `Unexpected character: ${R(e2, r)}.` : `Invalid character: ${R(e2, r)}.`);
  }
  return m(e2, o.EOF, i, i);
}
function $t(e2, t) {
  let n = e2.source.body, i = n.length, r = t + 1;
  for (; r < i; ) {
    let s = n.charCodeAt(r);
    if (s === 10 || s === 13) break;
    if (P(s)) ++r;
    else if (ne(n, r)) r += 2;
    else break;
  }
  return m(e2, o.COMMENT, t, r, n.slice(t + 1, r));
}
function Xt(e2, t, n) {
  let i = e2.source.body, r = t, s = n, a = false;
  if (s === 45 && (s = i.charCodeAt(++r)), s === 48) {
    if (s = i.charCodeAt(++r), b(s)) throw d(e2.source, r, `Invalid number, unexpected digit after 0: ${R(e2, r)}.`);
  } else r = Ee(e2, r, s), s = i.charCodeAt(r);
  if (s === 46 && (a = true, s = i.charCodeAt(++r), r = Ee(e2, r, s), s = i.charCodeAt(r)), (s === 69 || s === 101) && (a = true, s = i.charCodeAt(++r), (s === 43 || s === 45) && (s = i.charCodeAt(++r)), r = Ee(e2, r, s), s = i.charCodeAt(r)), s === 46 || me(s)) throw d(e2.source, r, `Invalid number, expected digit but got: ${R(e2, r)}.`);
  return m(e2, a ? o.FLOAT : o.INT, t, r, i.slice(t, r));
}
function Ee(e2, t, n) {
  if (!b(n)) throw d(e2.source, t, `Invalid number, expected digit but got: ${R(e2, t)}.`);
  let i = e2.source.body, r = t + 1;
  for (; b(i.charCodeAt(r)); ) ++r;
  return r;
}
function Ht(e2, t) {
  let n = e2.source.body, i = n.length, r = t + 1, s = r, a = "";
  for (; r < i; ) {
    let u = n.charCodeAt(r);
    if (u === 34) return a += n.slice(s, r), m(e2, o.STRING, t, r + 1, a);
    if (u === 92) {
      a += n.slice(s, r);
      let l = n.charCodeAt(r + 1) === 117 ? n.charCodeAt(r + 2) === 123 ? Jt(e2, r) : qt(e2, r) : Qt(e2, r);
      a += l.value, r += l.size, s = r;
      continue;
    }
    if (u === 10 || u === 13) break;
    if (P(u)) ++r;
    else if (ne(n, r)) r += 2;
    else throw d(e2.source, r, `Invalid character within String: ${R(e2, r)}.`);
  }
  throw d(e2.source, r, "Unterminated string.");
}
function Jt(e2, t) {
  let n = e2.source.body, i = 0, r = 3;
  for (; r < 12; ) {
    let s = n.charCodeAt(t + r++);
    if (s === 125) {
      if (r < 5 || !P(i)) break;
      return {
        value: String.fromCodePoint(i),
        size: r
      };
    }
    if (i = i << 4 | V(s), i < 0) break;
  }
  throw d(e2.source, t, `Invalid Unicode escape sequence: "${n.slice(t, t + r)}".`);
}
function qt(e2, t) {
  let n = e2.source.body, i = at(n, t + 2);
  if (P(i)) return {
    value: String.fromCodePoint(i),
    size: 6
  };
  if (ut(i) && n.charCodeAt(t + 6) === 92 && n.charCodeAt(t + 7) === 117) {
    let r = at(n, t + 8);
    if (lt(r)) return {
      value: String.fromCodePoint(i, r),
      size: 12
    };
  }
  throw d(e2.source, t, `Invalid Unicode escape sequence: "${n.slice(t, t + 6)}".`);
}
function at(e2, t) {
  return V(e2.charCodeAt(t)) << 12 | V(e2.charCodeAt(t + 1)) << 8 | V(e2.charCodeAt(t + 2)) << 4 | V(e2.charCodeAt(t + 3));
}
function V(e2) {
  return e2 >= 48 && e2 <= 57 ? e2 - 48 : e2 >= 65 && e2 <= 70 ? e2 - 55 : e2 >= 97 && e2 <= 102 ? e2 - 87 : -1;
}
function Qt(e2, t) {
  let n = e2.source.body;
  switch (n.charCodeAt(t + 1)) {
    case 34:
      return {
        value: '"',
        size: 2
      };
    case 92:
      return {
        value: "\\",
        size: 2
      };
    case 47:
      return {
        value: "/",
        size: 2
      };
    case 98:
      return {
        value: "\b",
        size: 2
      };
    case 102:
      return {
        value: "\f",
        size: 2
      };
    case 110:
      return {
        value: `
`,
        size: 2
      };
    case 114:
      return {
        value: "\r",
        size: 2
      };
    case 116:
      return {
        value: "	",
        size: 2
      };
  }
  throw d(e2.source, t, `Invalid character escape sequence: "${n.slice(t, t + 2)}".`);
}
function Wt(e2, t) {
  let n = e2.source.body, i = n.length, r = e2.lineStart, s = t + 3, a = s, u = "", l = [];
  for (; s < i; ) {
    let T = n.charCodeAt(s);
    if (T === 34 && n.charCodeAt(s + 1) === 34 && n.charCodeAt(s + 2) === 34) {
      u += n.slice(a, s), l.push(u);
      let h = m(e2, o.BLOCK_STRING, t, s + 3, ot(l).join(`
`));
      return e2.line += l.length - 1, e2.lineStart = r, h;
    }
    if (T === 92 && n.charCodeAt(s + 1) === 34 && n.charCodeAt(s + 2) === 34 && n.charCodeAt(s + 3) === 34) {
      u += n.slice(a, s), a = s + 1, s += 4;
      continue;
    }
    if (T === 10 || T === 13) {
      u += n.slice(a, s), l.push(u), T === 13 && n.charCodeAt(s + 1) === 10 ? s += 2 : ++s, u = "", a = s, r = s;
      continue;
    }
    if (P(T)) ++s;
    else if (ne(n, s)) s += 2;
    else throw d(e2.source, s, `Invalid character within String: ${R(e2, s)}.`);
  }
  throw d(e2.source, s, "Unterminated string.");
}
function Kt(e2, t) {
  let n = e2.source.body, i = n.length, r = t + 1;
  for (; r < i; ) {
    let s = n.charCodeAt(r);
    if (st(s)) ++r;
    else break;
  }
  return m(e2, o.NAME, t, r, n.slice(t, r));
}
function re(e2, t) {
  throw new Error(t);
}
function ie(e2) {
  return se(e2, []);
}
function se(e2, t) {
  switch (typeof e2) {
    case "string":
      return JSON.stringify(e2);
    case "function":
      return e2.name ? `[function ${e2.name}]` : "[function]";
    case "object":
      return zt(e2, t);
    default:
      return String(e2);
  }
}
function zt(e2, t) {
  if (e2 === null) return "null";
  if (t.includes(e2)) return "[Circular]";
  let n = [...t, e2];
  if (Zt(e2)) {
    let i = e2.toJSON();
    if (i !== e2) return typeof i == "string" ? i : se(i, n);
  } else if (Array.isArray(e2)) return tn(e2, n);
  return en(e2, n);
}
function Zt(e2) {
  return typeof e2.toJSON == "function";
}
function en(e2, t) {
  let n = Object.entries(e2);
  return n.length === 0 ? "{}" : t.length > 2 ? "[" + nn(e2) + "]" : "{ " + n.map(([r, s]) => r + ": " + se(s, t)).join(", ") + " }";
}
function tn(e2, t) {
  if (e2.length === 0) return "[]";
  if (t.length > 2) return "[Array]";
  let n = Math.min(10, e2.length), i = e2.length - n, r = [];
  for (let s = 0; s < n; ++s) r.push(se(e2[s], t));
  return i === 1 ? r.push("... 1 more item") : i > 1 && r.push(`... ${i} more items`), "[" + r.join(", ") + "]";
}
function nn(e2) {
  let t = Object.prototype.toString.call(e2).replace(/^\[object /, "").replace(/]$/, "");
  if (t === "Object" && typeof e2.constructor == "function") {
    let n = e2.constructor.name;
    if (typeof n == "string" && n !== "") return n;
  }
  return t;
}
var rn = globalThis.process && true;
var pt = rn ? function(t, n) {
  return t instanceof n;
} : function(t, n) {
  if (t instanceof n) return true;
  if (typeof t == "object" && t !== null) {
    var i;
    let r = n.prototype[Symbol.toStringTag], s = Symbol.toStringTag in t ? t[Symbol.toStringTag] : (i = t.constructor) === null || i === void 0 ? void 0 : i.name;
    if (r === s) {
      let a = ie(t);
      throw new Error(`Cannot use ${r} "${a}" from another module or realm.

Ensure that there is only one instance of "graphql" in the node_modules
directory. If different versions of "graphql" are the dependencies of other
relied on modules, use "resolutions" to ensure only one version is installed.

https://yarnpkg.com/en/docs/selective-version-resolutions

Duplicate "graphql" modules cannot be used at the same time since different
versions may have different capabilities and behavior. The data from one
version used in the function from another could produce confusing and
spurious results.`);
    }
  }
  return false;
};
var Y = class {
  constructor(t, n = "GraphQL request", i = {
    line: 1,
    column: 1
  }) {
    typeof t == "string" || re(false, `Body must be a string. Received: ${ie(t)}.`), this.body = t, this.name = n, this.locationOffset = i, this.locationOffset.line > 0 || re(false, "line in locationOffset is 1-indexed and must be positive."), this.locationOffset.column > 0 || re(false, "column in locationOffset is 1-indexed and must be positive.");
  }
  get [Symbol.toStringTag]() {
    return "Source";
  }
};
function ft(e2) {
  return pt(e2, Y);
}
function ht(e2, t) {
  let n = new Te(e2, t), i = n.parseDocument();
  return Object.defineProperty(i, "tokenCount", {
    enumerable: false,
    value: n.tokenCount
  }), i;
}
var Te = class {
  constructor(t, n = {}) {
    let i = ft(t) ? t : new Y(t);
    this._lexer = new te(i), this._options = n, this._tokenCounter = 0;
  }
  get tokenCount() {
    return this._tokenCounter;
  }
  parseName() {
    let t = this.expectToken(o.NAME);
    return this.node(t, {
      kind: c.NAME,
      value: t.value
    });
  }
  parseDocument() {
    return this.node(this._lexer.token, {
      kind: c.DOCUMENT,
      definitions: this.many(o.SOF, this.parseDefinition, o.EOF)
    });
  }
  parseDefinition() {
    if (this.peek(o.BRACE_L)) return this.parseOperationDefinition();
    let t = this.peekDescription(), n = t ? this._lexer.lookahead() : this._lexer.token;
    if (n.kind === o.NAME) {
      switch (n.value) {
        case "schema":
          return this.parseSchemaDefinition();
        case "scalar":
          return this.parseScalarTypeDefinition();
        case "type":
          return this.parseObjectTypeDefinition();
        case "interface":
          return this.parseInterfaceTypeDefinition();
        case "union":
          return this.parseUnionTypeDefinition();
        case "enum":
          return this.parseEnumTypeDefinition();
        case "input":
          return this.parseInputObjectTypeDefinition();
        case "directive":
          return this.parseDirectiveDefinition();
      }
      if (t) throw d(this._lexer.source, this._lexer.token.start, "Unexpected description, descriptions are supported only on type definitions.");
      switch (n.value) {
        case "query":
        case "mutation":
        case "subscription":
          return this.parseOperationDefinition();
        case "fragment":
          return this.parseFragmentDefinition();
        case "extend":
          return this.parseTypeSystemExtension();
      }
    }
    throw this.unexpected(n);
  }
  parseOperationDefinition() {
    let t = this._lexer.token;
    if (this.peek(o.BRACE_L)) return this.node(t, {
      kind: c.OPERATION_DEFINITION,
      operation: C.QUERY,
      name: void 0,
      variableDefinitions: [],
      directives: [],
      selectionSet: this.parseSelectionSet()
    });
    let n = this.parseOperationType(), i;
    return this.peek(o.NAME) && (i = this.parseName()), this.node(t, {
      kind: c.OPERATION_DEFINITION,
      operation: n,
      name: i,
      variableDefinitions: this.parseVariableDefinitions(),
      directives: this.parseDirectives(false),
      selectionSet: this.parseSelectionSet()
    });
  }
  parseOperationType() {
    let t = this.expectToken(o.NAME);
    switch (t.value) {
      case "query":
        return C.QUERY;
      case "mutation":
        return C.MUTATION;
      case "subscription":
        return C.SUBSCRIPTION;
    }
    throw this.unexpected(t);
  }
  parseVariableDefinitions() {
    return this.optionalMany(o.PAREN_L, this.parseVariableDefinition, o.PAREN_R);
  }
  parseVariableDefinition() {
    return this.node(this._lexer.token, {
      kind: c.VARIABLE_DEFINITION,
      variable: this.parseVariable(),
      type: (this.expectToken(o.COLON), this.parseTypeReference()),
      defaultValue: this.expectOptionalToken(o.EQUALS) ? this.parseConstValueLiteral() : void 0,
      directives: this.parseConstDirectives()
    });
  }
  parseVariable() {
    let t = this._lexer.token;
    return this.expectToken(o.DOLLAR), this.node(t, {
      kind: c.VARIABLE,
      name: this.parseName()
    });
  }
  parseSelectionSet() {
    return this.node(this._lexer.token, {
      kind: c.SELECTION_SET,
      selections: this.many(o.BRACE_L, this.parseSelection, o.BRACE_R)
    });
  }
  parseSelection() {
    return this.peek(o.SPREAD) ? this.parseFragment() : this.parseField();
  }
  parseField() {
    let t = this._lexer.token, n = this.parseName(), i, r;
    return this.expectOptionalToken(o.COLON) ? (i = n, r = this.parseName()) : r = n, this.node(t, {
      kind: c.FIELD,
      alias: i,
      name: r,
      arguments: this.parseArguments(false),
      directives: this.parseDirectives(false),
      selectionSet: this.peek(o.BRACE_L) ? this.parseSelectionSet() : void 0
    });
  }
  parseArguments(t) {
    let n = t ? this.parseConstArgument : this.parseArgument;
    return this.optionalMany(o.PAREN_L, n, o.PAREN_R);
  }
  parseArgument(t = false) {
    let n = this._lexer.token, i = this.parseName();
    return this.expectToken(o.COLON), this.node(n, {
      kind: c.ARGUMENT,
      name: i,
      value: this.parseValueLiteral(t)
    });
  }
  parseConstArgument() {
    return this.parseArgument(true);
  }
  parseFragment() {
    let t = this._lexer.token;
    this.expectToken(o.SPREAD);
    let n = this.expectOptionalKeyword("on");
    return !n && this.peek(o.NAME) ? this.node(t, {
      kind: c.FRAGMENT_SPREAD,
      name: this.parseFragmentName(),
      directives: this.parseDirectives(false)
    }) : this.node(t, {
      kind: c.INLINE_FRAGMENT,
      typeCondition: n ? this.parseNamedType() : void 0,
      directives: this.parseDirectives(false),
      selectionSet: this.parseSelectionSet()
    });
  }
  parseFragmentDefinition() {
    let t = this._lexer.token;
    return this.expectKeyword("fragment"), this._options.allowLegacyFragmentVariables === true ? this.node(t, {
      kind: c.FRAGMENT_DEFINITION,
      name: this.parseFragmentName(),
      variableDefinitions: this.parseVariableDefinitions(),
      typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
      directives: this.parseDirectives(false),
      selectionSet: this.parseSelectionSet()
    }) : this.node(t, {
      kind: c.FRAGMENT_DEFINITION,
      name: this.parseFragmentName(),
      typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
      directives: this.parseDirectives(false),
      selectionSet: this.parseSelectionSet()
    });
  }
  parseFragmentName() {
    if (this._lexer.token.value === "on") throw this.unexpected();
    return this.parseName();
  }
  parseValueLiteral(t) {
    let n = this._lexer.token;
    switch (n.kind) {
      case o.BRACKET_L:
        return this.parseList(t);
      case o.BRACE_L:
        return this.parseObject(t);
      case o.INT:
        return this.advanceLexer(), this.node(n, {
          kind: c.INT,
          value: n.value
        });
      case o.FLOAT:
        return this.advanceLexer(), this.node(n, {
          kind: c.FLOAT,
          value: n.value
        });
      case o.STRING:
      case o.BLOCK_STRING:
        return this.parseStringLiteral();
      case o.NAME:
        switch (this.advanceLexer(), n.value) {
          case "true":
            return this.node(n, {
              kind: c.BOOLEAN,
              value: true
            });
          case "false":
            return this.node(n, {
              kind: c.BOOLEAN,
              value: false
            });
          case "null":
            return this.node(n, {
              kind: c.NULL
            });
          default:
            return this.node(n, {
              kind: c.ENUM,
              value: n.value
            });
        }
      case o.DOLLAR:
        if (t) if (this.expectToken(o.DOLLAR), this._lexer.token.kind === o.NAME) {
          let i = this._lexer.token.value;
          throw d(this._lexer.source, n.start, `Unexpected variable "$${i}" in constant value.`);
        } else throw this.unexpected(n);
        return this.parseVariable();
      default:
        throw this.unexpected();
    }
  }
  parseConstValueLiteral() {
    return this.parseValueLiteral(true);
  }
  parseStringLiteral() {
    let t = this._lexer.token;
    return this.advanceLexer(), this.node(t, {
      kind: c.STRING,
      value: t.value,
      block: t.kind === o.BLOCK_STRING
    });
  }
  parseList(t) {
    let n = () => this.parseValueLiteral(t);
    return this.node(this._lexer.token, {
      kind: c.LIST,
      values: this.any(o.BRACKET_L, n, o.BRACKET_R)
    });
  }
  parseObject(t) {
    let n = () => this.parseObjectField(t);
    return this.node(this._lexer.token, {
      kind: c.OBJECT,
      fields: this.any(o.BRACE_L, n, o.BRACE_R)
    });
  }
  parseObjectField(t) {
    let n = this._lexer.token, i = this.parseName();
    return this.expectToken(o.COLON), this.node(n, {
      kind: c.OBJECT_FIELD,
      name: i,
      value: this.parseValueLiteral(t)
    });
  }
  parseDirectives(t) {
    let n = [];
    for (; this.peek(o.AT); ) n.push(this.parseDirective(t));
    return n;
  }
  parseConstDirectives() {
    return this.parseDirectives(true);
  }
  parseDirective(t) {
    let n = this._lexer.token;
    return this.expectToken(o.AT), this.node(n, {
      kind: c.DIRECTIVE,
      name: this.parseName(),
      arguments: this.parseArguments(t)
    });
  }
  parseTypeReference() {
    let t = this._lexer.token, n;
    if (this.expectOptionalToken(o.BRACKET_L)) {
      let i = this.parseTypeReference();
      this.expectToken(o.BRACKET_R), n = this.node(t, {
        kind: c.LIST_TYPE,
        type: i
      });
    } else n = this.parseNamedType();
    return this.expectOptionalToken(o.BANG) ? this.node(t, {
      kind: c.NON_NULL_TYPE,
      type: n
    }) : n;
  }
  parseNamedType() {
    return this.node(this._lexer.token, {
      kind: c.NAMED_TYPE,
      name: this.parseName()
    });
  }
  peekDescription() {
    return this.peek(o.STRING) || this.peek(o.BLOCK_STRING);
  }
  parseDescription() {
    if (this.peekDescription()) return this.parseStringLiteral();
  }
  parseSchemaDefinition() {
    let t = this._lexer.token, n = this.parseDescription();
    this.expectKeyword("schema");
    let i = this.parseConstDirectives(), r = this.many(o.BRACE_L, this.parseOperationTypeDefinition, o.BRACE_R);
    return this.node(t, {
      kind: c.SCHEMA_DEFINITION,
      description: n,
      directives: i,
      operationTypes: r
    });
  }
  parseOperationTypeDefinition() {
    let t = this._lexer.token, n = this.parseOperationType();
    this.expectToken(o.COLON);
    let i = this.parseNamedType();
    return this.node(t, {
      kind: c.OPERATION_TYPE_DEFINITION,
      operation: n,
      type: i
    });
  }
  parseScalarTypeDefinition() {
    let t = this._lexer.token, n = this.parseDescription();
    this.expectKeyword("scalar");
    let i = this.parseName(), r = this.parseConstDirectives();
    return this.node(t, {
      kind: c.SCALAR_TYPE_DEFINITION,
      description: n,
      name: i,
      directives: r
    });
  }
  parseObjectTypeDefinition() {
    let t = this._lexer.token, n = this.parseDescription();
    this.expectKeyword("type");
    let i = this.parseName(), r = this.parseImplementsInterfaces(), s = this.parseConstDirectives(), a = this.parseFieldsDefinition();
    return this.node(t, {
      kind: c.OBJECT_TYPE_DEFINITION,
      description: n,
      name: i,
      interfaces: r,
      directives: s,
      fields: a
    });
  }
  parseImplementsInterfaces() {
    return this.expectOptionalKeyword("implements") ? this.delimitedMany(o.AMP, this.parseNamedType) : [];
  }
  parseFieldsDefinition() {
    return this.optionalMany(o.BRACE_L, this.parseFieldDefinition, o.BRACE_R);
  }
  parseFieldDefinition() {
    let t = this._lexer.token, n = this.parseDescription(), i = this.parseName(), r = this.parseArgumentDefs();
    this.expectToken(o.COLON);
    let s = this.parseTypeReference(), a = this.parseConstDirectives();
    return this.node(t, {
      kind: c.FIELD_DEFINITION,
      description: n,
      name: i,
      arguments: r,
      type: s,
      directives: a
    });
  }
  parseArgumentDefs() {
    return this.optionalMany(o.PAREN_L, this.parseInputValueDef, o.PAREN_R);
  }
  parseInputValueDef() {
    let t = this._lexer.token, n = this.parseDescription(), i = this.parseName();
    this.expectToken(o.COLON);
    let r = this.parseTypeReference(), s;
    this.expectOptionalToken(o.EQUALS) && (s = this.parseConstValueLiteral());
    let a = this.parseConstDirectives();
    return this.node(t, {
      kind: c.INPUT_VALUE_DEFINITION,
      description: n,
      name: i,
      type: r,
      defaultValue: s,
      directives: a
    });
  }
  parseInterfaceTypeDefinition() {
    let t = this._lexer.token, n = this.parseDescription();
    this.expectKeyword("interface");
    let i = this.parseName(), r = this.parseImplementsInterfaces(), s = this.parseConstDirectives(), a = this.parseFieldsDefinition();
    return this.node(t, {
      kind: c.INTERFACE_TYPE_DEFINITION,
      description: n,
      name: i,
      interfaces: r,
      directives: s,
      fields: a
    });
  }
  parseUnionTypeDefinition() {
    let t = this._lexer.token, n = this.parseDescription();
    this.expectKeyword("union");
    let i = this.parseName(), r = this.parseConstDirectives(), s = this.parseUnionMemberTypes();
    return this.node(t, {
      kind: c.UNION_TYPE_DEFINITION,
      description: n,
      name: i,
      directives: r,
      types: s
    });
  }
  parseUnionMemberTypes() {
    return this.expectOptionalToken(o.EQUALS) ? this.delimitedMany(o.PIPE, this.parseNamedType) : [];
  }
  parseEnumTypeDefinition() {
    let t = this._lexer.token, n = this.parseDescription();
    this.expectKeyword("enum");
    let i = this.parseName(), r = this.parseConstDirectives(), s = this.parseEnumValuesDefinition();
    return this.node(t, {
      kind: c.ENUM_TYPE_DEFINITION,
      description: n,
      name: i,
      directives: r,
      values: s
    });
  }
  parseEnumValuesDefinition() {
    return this.optionalMany(o.BRACE_L, this.parseEnumValueDefinition, o.BRACE_R);
  }
  parseEnumValueDefinition() {
    let t = this._lexer.token, n = this.parseDescription(), i = this.parseEnumValueName(), r = this.parseConstDirectives();
    return this.node(t, {
      kind: c.ENUM_VALUE_DEFINITION,
      description: n,
      name: i,
      directives: r
    });
  }
  parseEnumValueName() {
    if (this._lexer.token.value === "true" || this._lexer.token.value === "false" || this._lexer.token.value === "null") throw d(this._lexer.source, this._lexer.token.start, `${oe(this._lexer.token)} is reserved and cannot be used for an enum value.`);
    return this.parseName();
  }
  parseInputObjectTypeDefinition() {
    let t = this._lexer.token, n = this.parseDescription();
    this.expectKeyword("input");
    let i = this.parseName(), r = this.parseConstDirectives(), s = this.parseInputFieldsDefinition();
    return this.node(t, {
      kind: c.INPUT_OBJECT_TYPE_DEFINITION,
      description: n,
      name: i,
      directives: r,
      fields: s
    });
  }
  parseInputFieldsDefinition() {
    return this.optionalMany(o.BRACE_L, this.parseInputValueDef, o.BRACE_R);
  }
  parseTypeSystemExtension() {
    let t = this._lexer.lookahead();
    if (t.kind === o.NAME) switch (t.value) {
      case "schema":
        return this.parseSchemaExtension();
      case "scalar":
        return this.parseScalarTypeExtension();
      case "type":
        return this.parseObjectTypeExtension();
      case "interface":
        return this.parseInterfaceTypeExtension();
      case "union":
        return this.parseUnionTypeExtension();
      case "enum":
        return this.parseEnumTypeExtension();
      case "input":
        return this.parseInputObjectTypeExtension();
    }
    throw this.unexpected(t);
  }
  parseSchemaExtension() {
    let t = this._lexer.token;
    this.expectKeyword("extend"), this.expectKeyword("schema");
    let n = this.parseConstDirectives(), i = this.optionalMany(o.BRACE_L, this.parseOperationTypeDefinition, o.BRACE_R);
    if (n.length === 0 && i.length === 0) throw this.unexpected();
    return this.node(t, {
      kind: c.SCHEMA_EXTENSION,
      directives: n,
      operationTypes: i
    });
  }
  parseScalarTypeExtension() {
    let t = this._lexer.token;
    this.expectKeyword("extend"), this.expectKeyword("scalar");
    let n = this.parseName(), i = this.parseConstDirectives();
    if (i.length === 0) throw this.unexpected();
    return this.node(t, {
      kind: c.SCALAR_TYPE_EXTENSION,
      name: n,
      directives: i
    });
  }
  parseObjectTypeExtension() {
    let t = this._lexer.token;
    this.expectKeyword("extend"), this.expectKeyword("type");
    let n = this.parseName(), i = this.parseImplementsInterfaces(), r = this.parseConstDirectives(), s = this.parseFieldsDefinition();
    if (i.length === 0 && r.length === 0 && s.length === 0) throw this.unexpected();
    return this.node(t, {
      kind: c.OBJECT_TYPE_EXTENSION,
      name: n,
      interfaces: i,
      directives: r,
      fields: s
    });
  }
  parseInterfaceTypeExtension() {
    let t = this._lexer.token;
    this.expectKeyword("extend"), this.expectKeyword("interface");
    let n = this.parseName(), i = this.parseImplementsInterfaces(), r = this.parseConstDirectives(), s = this.parseFieldsDefinition();
    if (i.length === 0 && r.length === 0 && s.length === 0) throw this.unexpected();
    return this.node(t, {
      kind: c.INTERFACE_TYPE_EXTENSION,
      name: n,
      interfaces: i,
      directives: r,
      fields: s
    });
  }
  parseUnionTypeExtension() {
    let t = this._lexer.token;
    this.expectKeyword("extend"), this.expectKeyword("union");
    let n = this.parseName(), i = this.parseConstDirectives(), r = this.parseUnionMemberTypes();
    if (i.length === 0 && r.length === 0) throw this.unexpected();
    return this.node(t, {
      kind: c.UNION_TYPE_EXTENSION,
      name: n,
      directives: i,
      types: r
    });
  }
  parseEnumTypeExtension() {
    let t = this._lexer.token;
    this.expectKeyword("extend"), this.expectKeyword("enum");
    let n = this.parseName(), i = this.parseConstDirectives(), r = this.parseEnumValuesDefinition();
    if (i.length === 0 && r.length === 0) throw this.unexpected();
    return this.node(t, {
      kind: c.ENUM_TYPE_EXTENSION,
      name: n,
      directives: i,
      values: r
    });
  }
  parseInputObjectTypeExtension() {
    let t = this._lexer.token;
    this.expectKeyword("extend"), this.expectKeyword("input");
    let n = this.parseName(), i = this.parseConstDirectives(), r = this.parseInputFieldsDefinition();
    if (i.length === 0 && r.length === 0) throw this.unexpected();
    return this.node(t, {
      kind: c.INPUT_OBJECT_TYPE_EXTENSION,
      name: n,
      directives: i,
      fields: r
    });
  }
  parseDirectiveDefinition() {
    let t = this._lexer.token, n = this.parseDescription();
    this.expectKeyword("directive"), this.expectToken(o.AT);
    let i = this.parseName(), r = this.parseArgumentDefs(), s = this.expectOptionalKeyword("repeatable");
    this.expectKeyword("on");
    let a = this.parseDirectiveLocations();
    return this.node(t, {
      kind: c.DIRECTIVE_DEFINITION,
      description: n,
      name: i,
      arguments: r,
      repeatable: s,
      locations: a
    });
  }
  parseDirectiveLocations() {
    return this.delimitedMany(o.PIPE, this.parseDirectiveLocation);
  }
  parseDirectiveLocation() {
    let t = this._lexer.token, n = this.parseName();
    if (Object.prototype.hasOwnProperty.call(ee, n.value)) return n;
    throw this.unexpected(t);
  }
  node(t, n) {
    return this._options.noLocation !== true && (n.loc = new Q(t, this._lexer.lastToken, this._lexer.source)), n;
  }
  peek(t) {
    return this._lexer.token.kind === t;
  }
  expectToken(t) {
    let n = this._lexer.token;
    if (n.kind === t) return this.advanceLexer(), n;
    throw d(this._lexer.source, n.start, `Expected ${dt(t)}, found ${oe(n)}.`);
  }
  expectOptionalToken(t) {
    return this._lexer.token.kind === t ? (this.advanceLexer(), true) : false;
  }
  expectKeyword(t) {
    let n = this._lexer.token;
    if (n.kind === o.NAME && n.value === t) this.advanceLexer();
    else throw d(this._lexer.source, n.start, `Expected "${t}", found ${oe(n)}.`);
  }
  expectOptionalKeyword(t) {
    let n = this._lexer.token;
    return n.kind === o.NAME && n.value === t ? (this.advanceLexer(), true) : false;
  }
  unexpected(t) {
    let n = t ?? this._lexer.token;
    return d(this._lexer.source, n.start, `Unexpected ${oe(n)}.`);
  }
  any(t, n, i) {
    this.expectToken(t);
    let r = [];
    for (; !this.expectOptionalToken(i); ) r.push(n.call(this));
    return r;
  }
  optionalMany(t, n, i) {
    if (this.expectOptionalToken(t)) {
      let r = [];
      do
        r.push(n.call(this));
      while (!this.expectOptionalToken(i));
      return r;
    }
    return [];
  }
  many(t, n, i) {
    this.expectToken(t);
    let r = [];
    do
      r.push(n.call(this));
    while (!this.expectOptionalToken(i));
    return r;
  }
  delimitedMany(t, n) {
    this.expectOptionalToken(t);
    let i = [];
    do
      i.push(n.call(this));
    while (this.expectOptionalToken(t));
    return i;
  }
  advanceLexer() {
    let {
      maxTokens: t
    } = this._options, n = this._lexer.advance();
    if (n.kind !== o.EOF && (++this._tokenCounter, t !== void 0 && this._tokenCounter > t)) throw d(this._lexer.source, n.start, `Document contains more that ${t} tokens. Parsing aborted.`);
  }
};
function oe(e2) {
  let t = e2.value;
  return dt(e2.kind) + (t != null ? ` "${t}"` : "");
}
function dt(e2) {
  return ct(e2) ? `"${e2}"` : e2;
}
function sn(e2, t) {
  let n = new SyntaxError(e2 + " (" + t.loc.start.line + ":" + t.loc.start.column + ")");
  return Object.assign(n, t);
}
var mt = sn;
function on(e2) {
  let t = [], {
    startToken: n,
    endToken: i
  } = e2.loc;
  for (let r = n; r !== i; r = r.next) r.kind === "Comment" && t.push({
    ...r,
    loc: {
      start: r.start,
      end: r.end
    }
  });
  return t;
}
var an = {
  allowLegacyFragmentVariables: true
};
function cn(e2) {
  if ((e2 == null ? void 0 : e2.name) === "GraphQLError") {
    let {
      message: t,
      locations: [n]
    } = e2;
    return mt(t, {
      loc: {
        start: n
      },
      cause: e2
    });
  }
  return e2;
}
function un(e2) {
  let t;
  try {
    t = ht(e2, an);
  } catch (n) {
    throw cn(n);
  }
  return t.comments = on(t), t;
}
var ln = {
  parse: un,
  astFormat: "graphql",
  hasPragma: je,
  hasIgnorePragma: $e,
  locStart: K,
  locEnd: z
};
var pn = {
  graphql: qe
};
var Ui = Ne;

export { Ui as default, Qe as languages, Ke as options, _e as parsers, pn as printers };
//# sourceMappingURL=graphql-B3XKUCJB.js.map
//# sourceMappingURL=graphql-B3XKUCJB.js.map