var ft = Object.defineProperty;
var ye = (e, t) => {
  for (var n in t) ft(e, n, { get: t[n], enumerable: !0 });
};
var _e = {};
ye(_e, {
  languages: () => Je,
  options: () => qe,
  parsers: () => Ne,
  printers: () => an,
});
var ht = (e, t, n, i) => {
    if (!(e && t == null))
      return (
        t.replaceAll ? t.replaceAll(n, i)
        : n.global ? t.replace(n, i)
        : t.split(n).join(i)
      );
  },
  j = ht;
var G = 'indent';
var $ = 'group';
var F = 'if-break';
var C = 'line';
var J = 'break-parent';
var ve = () => {},
  L = ve,
  le = ve;
function _(e) {
  return L(e), { type: G, contents: e };
}
function x(e, t = {}) {
  return (
    L(e),
    le(t.expandedStates, !0),
    {
      type: $,
      id: t.id,
      contents: e,
      break: !!t.shouldBreak,
      expandedStates: t.expandedStates,
    }
  );
}
function I(e, t = '', n = {}) {
  return (
    L(e),
    t !== '' && L(t),
    { type: F, breakContents: e, flatContents: t, groupId: n.groupId }
  );
}
var Tt = { type: J };
var Nt = { type: C, hard: !0 };
var k = { type: C },
  p = { type: C, soft: !0 },
  f = [Nt, Tt];
function E(e, t) {
  L(e), le(t);
  let n = [];
  for (let i = 0; i < t.length; i++) i !== 0 && n.push(e), n.push(t[i]);
  return n;
}
function X(e) {
  return (t, n, i) => {
    let r = !!(i != null && i.backwards);
    if (n === !1) return !1;
    let { length: s } = t,
      a = n;
    for (; a >= 0 && a < s; ) {
      let u = t.charAt(a);
      if (e instanceof RegExp) {
        if (!e.test(u)) return a;
      } else if (!e.includes(u)) return a;
      r ? a-- : a++;
    }
    return a === -1 || a === s ? a : !1;
  };
}
var jn = X(/\s/u),
  q = X(' 	'),
  be = X(',; 	'),
  Le = X(/[^\n\r]/u);
function _t(e, t, n) {
  let i = !!(n != null && n.backwards);
  if (t === !1) return !1;
  let r = e.charAt(t);
  if (i) {
    if (
      e.charAt(t - 1) === '\r' &&
      r ===
        `
`
    )
      return t - 2;
    if (
      r ===
        `
` ||
      r === '\r' ||
      r === '\u2028' ||
      r === '\u2029'
    )
      return t - 1;
  } else {
    if (
      r === '\r' &&
      e.charAt(t + 1) ===
        `
`
    )
      return t + 2;
    if (
      r ===
        `
` ||
      r === '\r' ||
      r === '\u2028' ||
      r === '\u2029'
    )
      return t + 1;
  }
  return t;
}
var Q = _t;
function yt(e, t, n = {}) {
  let i = q(e, n.backwards ? t - 1 : t, n),
    r = Q(e, i, n);
  return i !== r;
}
var Re = yt;
function xt(e, t) {
  if (t === !1) return !1;
  if (e.charAt(t) === '/' && e.charAt(t + 1) === '*') {
    for (let n = t + 2; n < e.length; ++n)
      if (e.charAt(n) === '*' && e.charAt(n + 1) === '/') return n + 2;
  }
  return t;
}
var Pe = xt;
function Ot(e, t) {
  return (
    t === !1 ? !1
    : e.charAt(t) === '/' && e.charAt(t + 1) === '/' ? Le(e, t)
    : t
  );
}
var Fe = Ot;
function It(e, t) {
  let n = null,
    i = t;
  for (; i !== n; ) (n = i), (i = be(e, i)), (i = Pe(e, i)), (i = q(e, i));
  return (i = Fe(e, i)), (i = Q(e, i)), i !== !1 && Re(e, i);
}
var we = It;
function Dt(e) {
  return Array.isArray(e) && e.length > 0;
}
var pe = Dt;
var fe = class extends Error {
    name = 'UnexpectedNodeError';
    constructor(t, n, i = 'type') {
      super(`Unexpected ${n} node ${i}: ${JSON.stringify(t[i])}.`),
        (this.node = t);
    }
  },
  Be = fe;
var w = null;
function B(e) {
  if (w !== null && typeof w.property) {
    let t = w;
    return (w = B.prototype = null), t;
  }
  return (w = B.prototype = e ?? Object.create(null)), new B();
}
var gt = 10;
for (let e = 0; e <= gt; e++) B();
function he(e) {
  return B(e);
}
function At(e, t = 'type') {
  he(e);
  function n(i) {
    let r = i[t],
      s = e[r];
    if (!Array.isArray(s))
      throw Object.assign(new Error(`Missing visitor keys for '${r}'.`), {
        node: i,
      });
    return s;
  }
  return n;
}
var Ue = At;
var H = 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 };
    }
  },
  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,
      };
    }
  },
  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'],
  },
  cr = new Set(Object.keys(W));
var S;
(function (e) {
  (e.QUERY = 'query'),
    (e.MUTATION = 'mutation'),
    (e.SUBSCRIPTION = 'subscription');
})(S || (S = {}));
var kt = Ue(W, 'kind'),
  Ve = kt;
function K(e) {
  return e.loc.start;
}
function z(e) {
  return e.loc.end;
}
function Ye(e) {
  return /^\s*#[^\S\n]*@(?:format|prettier)\s*(?:\n|$)/u.test(e);
}
function Me(e) {
  return (
    `# @format

` + e
  );
}
function Ct(e, t, n) {
  let { node: i } = e;
  if (!i.description) return '';
  let r = [n('description')];
  return (
    i.kind === 'InputValueDefinition' && !i.description.block ?
      r.push(k)
    : r.push(f),
    r
  );
}
var g = Ct;
function St(e, t, n) {
  let { node: i } = e;
  switch (i.kind) {
    case 'Document':
      return [...E(f, A(e, 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) ? ' ' : '',
        je(e, n),
        y(e, n, i),
        !r && !s ? '' : ' ',
        n('selectionSet'),
      ];
    }
    case 'FragmentDefinition':
      return [
        'fragment ',
        n('name'),
        je(e, n),
        ' on ',
        n('typeCondition'),
        y(e, n, i),
        ' ',
        n('selectionSet'),
      ];
    case 'SelectionSet':
      return ['{', _([f, E(f, A(e, t, n, 'selections'))]), f, '}'];
    case 'Field':
      return x([
        i.alias ? [n('alias'), ': '] : '',
        n('name'),
        i.arguments.length > 0 ?
          x(['(', _([p, E([I('', ', '), p], A(e, t, n, 'arguments'))]), p, ')'])
        : '',
        y(e, n, i),
        i.selectionSet ? ' ' : '',
        n('selectionSet'),
      ]);
    case 'Name':
      return i.value;
    case 'StringValue':
      if (i.block) {
        let r = j(!1, 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 [
        '"',
        j(
          !1,
          j(!1, 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 x(['[', _([p, E([I('', ', '), p], e.map(n, 'values'))]), p, ']']);
    case 'ObjectValue': {
      let r = t.bracketSpacing && i.fields.length > 0 ? ' ' : '';
      return x([
        '{',
        r,
        _([p, E([I('', ', '), p], e.map(n, 'fields'))]),
        p,
        I('', r),
        '}',
      ]);
    }
    case 'ObjectField':
    case 'Argument':
      return [n('name'), ': ', n('value')];
    case 'Directive':
      return [
        '@',
        n('name'),
        i.arguments.length > 0 ?
          x(['(', _([p, E([I('', ', '), p], A(e, t, n, 'arguments'))]), p, ')'])
        : '',
      ];
    case 'NamedType':
      return n('name');
    case 'VariableDefinition':
      return [
        n('variable'),
        ': ',
        n('type'),
        i.defaultValue ? [' = ', n('defaultValue')] : '',
        y(e, 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(g(e, 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 ', ...Lt(e, t, n)),
        s.push(y(e, n, i)),
        i.fields.length > 0 &&
          s.push([' {', _([f, E(f, A(e, t, n, 'fields'))]), f, '}']),
        s
      );
    }
    case 'FieldDefinition':
      return [
        g(e, t, n),
        n('name'),
        i.arguments.length > 0 ?
          x(['(', _([p, E([I('', ', '), p], A(e, t, n, 'arguments'))]), p, ')'])
        : '',
        ': ',
        n('type'),
        y(e, n, i),
      ];
    case 'DirectiveDefinition':
      return [
        g(e, t, n),
        'directive ',
        '@',
        n('name'),
        i.arguments.length > 0 ?
          x(['(', _([p, E([I('', ', '), p], A(e, t, n, 'arguments'))]), p, ')'])
        : '',
        i.repeatable ? ' repeatable' : '',
        ' on ',
        ...E(' | ', e.map(n, 'locations')),
      ];
    case 'EnumTypeExtension':
    case 'EnumTypeDefinition':
      return [
        g(e, t, n),
        i.kind === 'EnumTypeExtension' ? 'extend ' : '',
        'enum ',
        n('name'),
        y(e, n, i),
        i.values.length > 0 ?
          [' {', _([f, E(f, A(e, t, n, 'values'))]), f, '}']
        : '',
      ];
    case 'EnumValueDefinition':
      return [g(e, t, n), n('name'), y(e, n, i)];
    case 'InputValueDefinition':
      return [
        g(e, t, n),
        n('name'),
        ': ',
        n('type'),
        i.defaultValue ? [' = ', n('defaultValue')] : '',
        y(e, n, i),
      ];
    case 'SchemaExtension':
      return [
        'extend schema',
        y(e, n, i),
        ...(i.operationTypes.length > 0 ?
          [' {', _([f, E(f, A(e, t, n, 'operationTypes'))]), f, '}']
        : []),
      ];
    case 'SchemaDefinition':
      return [
        g(e, t, n),
        'schema',
        y(e, n, i),
        ' {',
        i.operationTypes.length > 0 ?
          _([f, E(f, A(e, t, n, 'operationTypes'))])
        : '',
        f,
        '}',
      ];
    case 'OperationTypeDefinition':
      return [i.operation, ': ', n('type')];
    case 'FragmentSpread':
      return ['...', n('name'), y(e, n, i)];
    case 'InlineFragment':
      return [
        '...',
        i.typeCondition ? [' on ', n('typeCondition')] : '',
        y(e, n, i),
        ' ',
        n('selectionSet'),
      ];
    case 'UnionTypeExtension':
    case 'UnionTypeDefinition':
      return x([
        g(e, t, n),
        x([
          i.kind === 'UnionTypeExtension' ? 'extend ' : '',
          'union ',
          n('name'),
          y(e, n, i),
          i.types.length > 0 ?
            [
              ' =',
              I('', ' '),
              _([I([k, '| ']), E([k, '| '], e.map(n, 'types'))]),
            ]
          : '',
        ]),
      ]);
    case 'ScalarTypeExtension':
    case 'ScalarTypeDefinition':
      return [
        g(e, t, n),
        i.kind === 'ScalarTypeExtension' ? 'extend ' : '',
        'scalar ',
        n('name'),
        y(e, n, i),
      ];
    case 'NonNullType':
      return [n('type'), '!'];
    case 'ListType':
      return ['[', n('type'), ']'];
    default:
      throw new Be(i, 'Graphql', 'kind');
  }
}
function y(e, t, n) {
  if (n.directives.length === 0) return '';
  let i = E(k, e.map(t, 'directives'));
  return n.kind === 'FragmentDefinition' || n.kind === 'OperationDefinition' ?
      x([k, i])
    : [' ', x(_([p, i]))];
}
function A(e, t, n, i) {
  return e.map(({ isLast: r, node: s }) => {
    let a = n();
    return !r && we(t.originalText, z(s)) ? [a, f] : a;
  }, i);
}
function vt(e) {
  return e.kind !== 'Comment';
}
function bt(e) {
  let t = e.node;
  if (t.kind === 'Comment') return '#' + t.value.trimEnd();
  throw new Error('Not a comment: ' + JSON.stringify(t));
}
function Lt(e, t, n) {
  let { node: i } = e,
    r = [],
    { interfaces: s } = i,
    a = e.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 D = t.originalText.slice(l.loc.end, T.loc.start).includes('#');
      r.push(' &', D ? k : ' ');
    }
  }
  return r;
}
function je(e, t) {
  let { node: n } = e;
  return pe(n.variableDefinitions) ?
      x([
        '(',
        _([p, E([I('', ', '), p], e.map(t, 'variableDefinitions'))]),
        p,
        ')',
      ])
    : '';
}
function Ge(e, t) {
  e.kind === 'StringValue' &&
    e.block &&
    !e.value.includes(`
`) &&
    (t.value = e.value.trim());
}
Ge.ignoredProperties = new Set(['loc', 'comments']);
function Rt(e) {
  var n;
  let { node: t } = e;
  return (n = t == null ? void 0 : t.comments) == null ?
      void 0
    : n.some((i) => i.value.trim() === 'prettier-ignore');
}
var Pt = {
    print: St,
    massageAstNode: Ge,
    hasPrettierIgnore: Rt,
    insertPragma: Me,
    printComment: bt,
    canAttachComment: vt,
    getVisitorKeys: Ve,
  },
  $e = Pt;
var Je = [
  {
    linguistLanguageId: 139,
    name: 'GraphQL',
    type: 'data',
    color: '#e10098',
    extensions: ['.graphql', '.gql', '.graphqls'],
    tmScope: 'source.graphql',
    aceMode: 'text',
    parsers: ['graphql'],
    vscodeLanguageIds: ['graphql'],
  },
];
var Xe = {
  bracketSpacing: {
    category: 'Common',
    type: 'boolean',
    default: !0,
    description: 'Print spaces between brackets.',
    oppositeDescription: 'Do not print spaces between brackets.',
  },
  objectWrap: {
    category: 'Common',
    type: 'choice',
    default: 'preserve',
    description: 'How to wrap object literals.',
    choices: [
      {
        value: 'preserve',
        description:
          'Keep as multi-line, if there is a newline between the opening brace and first property.',
      },
      { value: 'collapse', description: 'Fit to a single line when possible.' },
    ],
  },
  singleQuote: {
    category: 'Common',
    type: 'boolean',
    default: !1,
    description: 'Use single quotes instead of double quotes.',
  },
  proseWrap: {
    category: 'Common',
    type: 'choice',
    default: 'preserve',
    description: 'How to wrap prose.',
    choices: [
      {
        value: 'always',
        description: 'Wrap prose if it exceeds the print width.',
      },
      { value: 'never', description: 'Do not wrap prose.' },
      { value: 'preserve', description: 'Wrap prose as-is.' },
    ],
  },
  bracketSameLine: {
    category: 'Common',
    type: 'boolean',
    default: !1,
    description:
      'Put > of opening tags on the last line instead of on a new line.',
  },
  singleAttributePerLine: {
    category: 'Common',
    type: 'boolean',
    default: !1,
    description: 'Enforce single attribute per line in HTML, Vue and JSX.',
  },
};
var Ft = { bracketSpacing: Xe.bracketSpacing },
  qe = Ft;
var Ne = {};
ye(Ne, { graphql: () => on });
function Qe(e) {
  return typeof e == 'object' && e !== null;
}
function He(e, t) {
  if (!!!e) throw new Error(t ?? 'Unexpected invariant triggered.');
}
var wt = /\r\n|[\n\r]/g;
function V(e, t) {
  let n = 0,
    i = 1;
  for (let r of e.body.matchAll(wt)) {
    if ((typeof r.index == 'number' || He(!1), r.index >= t)) break;
    (n = r.index + r[0].length), (i += 1);
  }
  return { line: i, column: t + 1 - n };
}
function Ke(e) {
  return de(e.source, V(e.source, e.start));
}
function de(e, t) {
  let n = e.locationOffset.column - 1,
    i = ''.padStart(n) + e.body,
    r = t.line - 1,
    s = e.locationOffset.line - 1,
    a = t.line + s,
    u = t.line === 1 ? n : 0,
    l = t.column + u,
    T = `${e.name}:${a}:${l}
`,
    h = i.split(/\r\n|[\n\r]/g),
    D = h[r];
  if (D.length > 120) {
    let O = Math.floor(l / 80),
      ae = l % 80,
      N = [];
    for (let b = 0; b < D.length; b += 80) N.push(D.slice(b, b + 80));
    return (
      T +
      We([
        [`${a} |`, N[0]],
        ...N.slice(1, O + 1).map((b) => ['|', b]),
        ['|', '^'.padStart(ae)],
        ['|', N[O + 1]],
      ])
    );
  }
  return (
    T +
    We([
      [`${a - 1} |`, h[r - 1]],
      [`${a} |`, D],
      ['|', '^'.padStart(l)],
      [`${a + 1} |`, h[r + 1]],
    ])
  );
}
function We(e) {
  let t = e.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 Bt(e) {
  let t = e[0];
  return t == null || 'kind' in t || 'length' in t ?
      {
        nodes: t,
        source: e[1],
        positions: e[2],
        path: e[3],
        originalError: e[4],
        extensions: e[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: D,
    } = Bt(n);
    super(t),
      (this.name = 'GraphQLError'),
      (this.path = T ?? void 0),
      (this.originalError = h ?? void 0),
      (this.nodes = ze(
        Array.isArray(a) ? a
        : a ? [a]
        : void 0
      ));
    let O = ze(
      (i = this.nodes) === null || i === void 0 ?
        void 0
      : i.map((N) => N.loc).filter((N) => N != 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((N) => N.start))),
      (this.locations =
        l && u ? l.map((N) => V(u, N))
        : O == null ? void 0
        : O.map((N) => V(N.source, N.start)));
    let ae =
      Qe(h == null ? void 0 : h.extensions) ?
        h == null ?
          void 0
        : h.extensions
      : void 0;
    (this.extensions =
      (s = D ?? ae) !== null && s !== void 0 ? s : Object.create(null)),
      Object.defineProperties(this, {
        message: { writable: !0, enumerable: !0 },
        name: { enumerable: !1 },
        nodes: { enumerable: !1 },
        source: { enumerable: !1 },
        positions: { enumerable: !1 },
        originalError: { enumerable: !1 },
      }),
      h != null && h.stack ?
        Object.defineProperty(this, 'stack', {
          value: h.stack,
          writable: !0,
          configurable: !0,
        })
      : Error.captureStackTrace ? Error.captureStackTrace(this, e)
      : Object.defineProperty(this, 'stack', {
          value: Error().stack,
          writable: !0,
          configurable: !0,
        });
  }
  get [Symbol.toStringTag]() {
    return 'GraphQLError';
  }
  toString() {
    let t = this.message;
    if (this.nodes)
      for (let n of this.nodes)
        n.loc &&
          (t +=
            `

` + Ke(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 ze(e) {
  return e === void 0 || e.length === 0 ? void 0 : e;
}
function d(e, t, n) {
  return new Z(`Syntax Error: ${n}`, { source: e, positions: [t] });
}
var ee;
(function (e) {
  (e.QUERY = 'QUERY'),
    (e.MUTATION = 'MUTATION'),
    (e.SUBSCRIPTION = 'SUBSCRIPTION'),
    (e.FIELD = 'FIELD'),
    (e.FRAGMENT_DEFINITION = 'FRAGMENT_DEFINITION'),
    (e.FRAGMENT_SPREAD = 'FRAGMENT_SPREAD'),
    (e.INLINE_FRAGMENT = 'INLINE_FRAGMENT'),
    (e.VARIABLE_DEFINITION = 'VARIABLE_DEFINITION'),
    (e.SCHEMA = 'SCHEMA'),
    (e.SCALAR = 'SCALAR'),
    (e.OBJECT = 'OBJECT'),
    (e.FIELD_DEFINITION = 'FIELD_DEFINITION'),
    (e.ARGUMENT_DEFINITION = 'ARGUMENT_DEFINITION'),
    (e.INTERFACE = 'INTERFACE'),
    (e.UNION = 'UNION'),
    (e.ENUM = 'ENUM'),
    (e.ENUM_VALUE = 'ENUM_VALUE'),
    (e.INPUT_OBJECT = 'INPUT_OBJECT'),
    (e.INPUT_FIELD_DEFINITION = 'INPUT_FIELD_DEFINITION');
})(ee || (ee = {}));
var c;
(function (e) {
  (e.NAME = 'Name'),
    (e.DOCUMENT = 'Document'),
    (e.OPERATION_DEFINITION = 'OperationDefinition'),
    (e.VARIABLE_DEFINITION = 'VariableDefinition'),
    (e.SELECTION_SET = 'SelectionSet'),
    (e.FIELD = 'Field'),
    (e.ARGUMENT = 'Argument'),
    (e.FRAGMENT_SPREAD = 'FragmentSpread'),
    (e.INLINE_FRAGMENT = 'InlineFragment'),
    (e.FRAGMENT_DEFINITION = 'FragmentDefinition'),
    (e.VARIABLE = 'Variable'),
    (e.INT = 'IntValue'),
    (e.FLOAT = 'FloatValue'),
    (e.STRING = 'StringValue'),
    (e.BOOLEAN = 'BooleanValue'),
    (e.NULL = 'NullValue'),
    (e.ENUM = 'EnumValue'),
    (e.LIST = 'ListValue'),
    (e.OBJECT = 'ObjectValue'),
    (e.OBJECT_FIELD = 'ObjectField'),
    (e.DIRECTIVE = 'Directive'),
    (e.NAMED_TYPE = 'NamedType'),
    (e.LIST_TYPE = 'ListType'),
    (e.NON_NULL_TYPE = 'NonNullType'),
    (e.SCHEMA_DEFINITION = 'SchemaDefinition'),
    (e.OPERATION_TYPE_DEFINITION = 'OperationTypeDefinition'),
    (e.SCALAR_TYPE_DEFINITION = 'ScalarTypeDefinition'),
    (e.OBJECT_TYPE_DEFINITION = 'ObjectTypeDefinition'),
    (e.FIELD_DEFINITION = 'FieldDefinition'),
    (e.INPUT_VALUE_DEFINITION = 'InputValueDefinition'),
    (e.INTERFACE_TYPE_DEFINITION = 'InterfaceTypeDefinition'),
    (e.UNION_TYPE_DEFINITION = 'UnionTypeDefinition'),
    (e.ENUM_TYPE_DEFINITION = 'EnumTypeDefinition'),
    (e.ENUM_VALUE_DEFINITION = 'EnumValueDefinition'),
    (e.INPUT_OBJECT_TYPE_DEFINITION = 'InputObjectTypeDefinition'),
    (e.DIRECTIVE_DEFINITION = 'DirectiveDefinition'),
    (e.SCHEMA_EXTENSION = 'SchemaExtension'),
    (e.SCALAR_TYPE_EXTENSION = 'ScalarTypeExtension'),
    (e.OBJECT_TYPE_EXTENSION = 'ObjectTypeExtension'),
    (e.INTERFACE_TYPE_EXTENSION = 'InterfaceTypeExtension'),
    (e.UNION_TYPE_EXTENSION = 'UnionTypeExtension'),
    (e.ENUM_TYPE_EXTENSION = 'EnumTypeExtension'),
    (e.INPUT_OBJECT_TYPE_EXTENSION = 'InputObjectTypeExtension');
})(c || (c = {}));
function Ze(e) {
  return e === 9 || e === 32;
}
function R(e) {
  return e >= 48 && e <= 57;
}
function et(e) {
  return (e >= 97 && e <= 122) || (e >= 65 && e <= 90);
}
function me(e) {
  return et(e) || e === 95;
}
function tt(e) {
  return et(e) || R(e) || e === 95;
}
function nt(e) {
  var t;
  let n = Number.MAX_SAFE_INTEGER,
    i = null,
    r = -1;
  for (let a = 0; a < e.length; ++a) {
    var s;
    let u = e[a],
      l = Ut(u);
    l !== u.length &&
      ((i = (s = i) !== null && s !== void 0 ? s : a),
      (r = a),
      a !== 0 && l < n && (n = l));
  }
  return e
    .map((a, u) => (u === 0 ? a : a.slice(n)))
    .slice((t = i) !== null && t !== void 0 ? t : 0, r + 1);
}
function Ut(e) {
  let t = 0;
  for (; t < e.length && Ze(e.charCodeAt(t)); ) ++t;
  return t;
}
var o;
(function (e) {
  (e.SOF = '<SOF>'),
    (e.EOF = '<EOF>'),
    (e.BANG = '!'),
    (e.DOLLAR = '$'),
    (e.AMP = '&'),
    (e.PAREN_L = '('),
    (e.PAREN_R = ')'),
    (e.SPREAD = '...'),
    (e.COLON = ':'),
    (e.EQUALS = '='),
    (e.AT = '@'),
    (e.BRACKET_L = '['),
    (e.BRACKET_R = ']'),
    (e.BRACE_L = '{'),
    (e.PIPE = '|'),
    (e.BRACE_R = '}'),
    (e.NAME = 'Name'),
    (e.INT = 'Int'),
    (e.FLOAT = 'Float'),
    (e.STRING = 'String'),
    (e.BLOCK_STRING = 'BlockString'),
    (e.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 = Vt(this, t.end);
          (t.next = n), (n.prev = t), (t = n);
        }
      while (t.kind === o.COMMENT);
    return t;
  }
};
function it(e) {
  return (
    e === o.BANG ||
    e === o.DOLLAR ||
    e === o.AMP ||
    e === o.PAREN_L ||
    e === o.PAREN_R ||
    e === o.SPREAD ||
    e === o.COLON ||
    e === o.EQUALS ||
    e === o.AT ||
    e === o.BRACKET_L ||
    e === o.BRACKET_R ||
    e === o.BRACE_L ||
    e === o.PIPE ||
    e === o.BRACE_R
  );
}
function P(e) {
  return (e >= 0 && e <= 55295) || (e >= 57344 && e <= 1114111);
}
function ne(e, t) {
  return st(e.charCodeAt(t)) && ot(e.charCodeAt(t + 1));
}
function st(e) {
  return e >= 55296 && e <= 56319;
}
function ot(e) {
  return e >= 56320 && e <= 57343;
}
function v(e, t) {
  let n = e.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(e, t, n, i, r) {
  let s = e.line,
    a = 1 + n - e.lineStart;
  return new U(t, n, i, s, a, r);
}
function Vt(e, t) {
  let n = e.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, ++e.line, (e.lineStart = r);
        continue;
      case 13:
        n.charCodeAt(r + 1) === 10 ? (r += 2) : ++r,
          ++e.line,
          (e.lineStart = r);
        continue;
      case 35:
        return Yt(e, r);
      case 33:
        return m(e, o.BANG, r, r + 1);
      case 36:
        return m(e, o.DOLLAR, r, r + 1);
      case 38:
        return m(e, o.AMP, r, r + 1);
      case 40:
        return m(e, o.PAREN_L, r, r + 1);
      case 41:
        return m(e, o.PAREN_R, r, r + 1);
      case 46:
        if (n.charCodeAt(r + 1) === 46 && n.charCodeAt(r + 2) === 46)
          return m(e, o.SPREAD, r, r + 3);
        break;
      case 58:
        return m(e, o.COLON, r, r + 1);
      case 61:
        return m(e, o.EQUALS, r, r + 1);
      case 64:
        return m(e, o.AT, r, r + 1);
      case 91:
        return m(e, o.BRACKET_L, r, r + 1);
      case 93:
        return m(e, o.BRACKET_R, r, r + 1);
      case 123:
        return m(e, o.BRACE_L, r, r + 1);
      case 124:
        return m(e, o.PIPE, r, r + 1);
      case 125:
        return m(e, o.BRACE_R, r, r + 1);
      case 34:
        return n.charCodeAt(r + 1) === 34 && n.charCodeAt(r + 2) === 34 ?
            Xt(e, r)
          : jt(e, r);
    }
    if (R(s) || s === 45) return Mt(e, r, s);
    if (me(s)) return qt(e, r);
    throw d(
      e.source,
      r,
      s === 39 ?
        `Unexpected single quote character ('), did you mean to use a double quote (")?`
      : P(s) || ne(n, r) ? `Unexpected character: ${v(e, r)}.`
      : `Invalid character: ${v(e, r)}.`
    );
  }
  return m(e, o.EOF, i, i);
}
function Yt(e, t) {
  let n = e.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(e, o.COMMENT, t, r, n.slice(t + 1, r));
}
function Mt(e, t, n) {
  let i = e.source.body,
    r = t,
    s = n,
    a = !1;
  if ((s === 45 && (s = i.charCodeAt(++r)), s === 48)) {
    if (((s = i.charCodeAt(++r)), R(s)))
      throw d(
        e.source,
        r,
        `Invalid number, unexpected digit after 0: ${v(e, r)}.`
      );
  } else (r = Ee(e, r, s)), (s = i.charCodeAt(r));
  if (
    (s === 46 &&
      ((a = !0),
      (s = i.charCodeAt(++r)),
      (r = Ee(e, r, s)),
      (s = i.charCodeAt(r))),
    (s === 69 || s === 101) &&
      ((a = !0),
      (s = i.charCodeAt(++r)),
      (s === 43 || s === 45) && (s = i.charCodeAt(++r)),
      (r = Ee(e, r, s)),
      (s = i.charCodeAt(r))),
    s === 46 || me(s))
  )
    throw d(e.source, r, `Invalid number, expected digit but got: ${v(e, r)}.`);
  return m(e, a ? o.FLOAT : o.INT, t, r, i.slice(t, r));
}
function Ee(e, t, n) {
  if (!R(n))
    throw d(e.source, t, `Invalid number, expected digit but got: ${v(e, t)}.`);
  let i = e.source.body,
    r = t + 1;
  for (; R(i.charCodeAt(r)); ) ++r;
  return r;
}
function jt(e, t) {
  let n = e.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(e, 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 ?
            Gt(e, r)
          : $t(e, r)
        : Jt(e, 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(e.source, r, `Invalid character within String: ${v(e, r)}.`);
  }
  throw d(e.source, r, 'Unterminated string.');
}
function Gt(e, t) {
  let n = e.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) | Y(s)), i < 0)) break;
  }
  throw d(
    e.source,
    t,
    `Invalid Unicode escape sequence: "${n.slice(t, t + r)}".`
  );
}
function $t(e, t) {
  let n = e.source.body,
    i = rt(n, t + 2);
  if (P(i)) return { value: String.fromCodePoint(i), size: 6 };
  if (st(i) && n.charCodeAt(t + 6) === 92 && n.charCodeAt(t + 7) === 117) {
    let r = rt(n, t + 8);
    if (ot(r)) return { value: String.fromCodePoint(i, r), size: 12 };
  }
  throw d(
    e.source,
    t,
    `Invalid Unicode escape sequence: "${n.slice(t, t + 6)}".`
  );
}
function rt(e, t) {
  return (
    (Y(e.charCodeAt(t)) << 12) |
    (Y(e.charCodeAt(t + 1)) << 8) |
    (Y(e.charCodeAt(t + 2)) << 4) |
    Y(e.charCodeAt(t + 3))
  );
}
function Y(e) {
  return (
    e >= 48 && e <= 57 ? e - 48
    : e >= 65 && e <= 70 ? e - 55
    : e >= 97 && e <= 102 ? e - 87
    : -1
  );
}
function Jt(e, t) {
  let n = e.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(
    e.source,
    t,
    `Invalid character escape sequence: "${n.slice(t, t + 2)}".`
  );
}
function Xt(e, t) {
  let n = e.source.body,
    i = n.length,
    r = e.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(
        e,
        o.BLOCK_STRING,
        t,
        s + 3,
        nt(l).join(`
`)
      );
      return (e.line += l.length - 1), (e.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(e.source, s, `Invalid character within String: ${v(e, s)}.`);
  }
  throw d(e.source, s, 'Unterminated string.');
}
function qt(e, t) {
  let n = e.source.body,
    i = n.length,
    r = t + 1;
  for (; r < i; ) {
    let s = n.charCodeAt(r);
    if (tt(s)) ++r;
    else break;
  }
  return m(e, o.NAME, t, r, n.slice(t, r));
}
function re(e, t) {
  if (!!!e) throw new Error(t);
}
function ie(e) {
  return se(e, []);
}
function se(e, t) {
  switch (typeof e) {
    case 'string':
      return JSON.stringify(e);
    case 'function':
      return e.name ? `[function ${e.name}]` : '[function]';
    case 'object':
      return Qt(e, t);
    default:
      return String(e);
  }
}
function Qt(e, t) {
  if (e === null) return 'null';
  if (t.includes(e)) return '[Circular]';
  let n = [...t, e];
  if (Ht(e)) {
    let i = e.toJSON();
    if (i !== e) return typeof i == 'string' ? i : se(i, n);
  } else if (Array.isArray(e)) return Kt(e, n);
  return Wt(e, n);
}
function Ht(e) {
  return typeof e.toJSON == 'function';
}
function Wt(e, t) {
  let n = Object.entries(e);
  return (
    n.length === 0 ? '{}'
    : t.length > 2 ? '[' + zt(e) + ']'
    : '{ ' + n.map(([r, s]) => r + ': ' + se(s, t)).join(', ') + ' }'
  );
}
function Kt(e, t) {
  if (e.length === 0) return '[]';
  if (t.length > 2) return '[Array]';
  let n = Math.min(10, e.length),
    i = e.length - n,
    r = [];
  for (let s = 0; s < n; ++s) r.push(se(e[s], t));
  return (
    i === 1 ?
      r.push('... 1 more item')
    : i > 1 && r.push(`... ${i} more items`),
    '[' + r.join(', ') + ']'
  );
}
function zt(e) {
  let t = Object.prototype.toString
    .call(e)
    .replace(/^\[object /, '')
    .replace(/]$/, '');
  if (t === 'Object' && typeof e.constructor == 'function') {
    let n = e.constructor.name;
    if (typeof n == 'string' && n !== '') return n;
  }
  return t;
}
var Zt = globalThis.process && !0,
  at =
    Zt ?
      function (t, n) {
        return t instanceof n;
      }
    : function (t, n) {
        if (t instanceof n) return !0;
        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 !1;
      };
var M = class {
  constructor(t, n = 'GraphQL request', i = { line: 1, column: 1 }) {
    typeof t == 'string' ||
      re(!1, `Body must be a string. Received: ${ie(t)}.`),
      (this.body = t),
      (this.name = n),
      (this.locationOffset = i),
      this.locationOffset.line > 0 ||
        re(!1, 'line in locationOffset is 1-indexed and must be positive.'),
      this.locationOffset.column > 0 ||
        re(!1, 'column in locationOffset is 1-indexed and must be positive.');
  }
  get [Symbol.toStringTag]() {
    return 'Source';
  }
};
function ct(e) {
  return at(e, M);
}
function ut(e, t) {
  let n = new Te(e, t),
    i = n.parseDocument();
  return (
    Object.defineProperty(i, 'tokenCount', {
      enumerable: !1,
      value: n.tokenCount,
    }),
    i
  );
}
var Te = class {
  constructor(t, n = {}) {
    let i = ct(t) ? t : new M(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: S.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(!1),
        selectionSet: this.parseSelectionSet(),
      })
    );
  }
  parseOperationType() {
    let t = this.expectToken(o.NAME);
    switch (t.value) {
      case 'query':
        return S.QUERY;
      case 'mutation':
        return S.MUTATION;
      case 'subscription':
        return S.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(!1),
        directives: this.parseDirectives(!1),
        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 = !1) {
    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(!0);
  }
  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(!1),
        })
      : this.node(t, {
          kind: c.INLINE_FRAGMENT,
          typeCondition: n ? this.parseNamedType() : void 0,
          directives: this.parseDirectives(!1),
          selectionSet: this.parseSelectionSet(),
        });
  }
  parseFragmentDefinition() {
    let t = this._lexer.token;
    return (
      this.expectKeyword('fragment'),
      this._options.allowLegacyFragmentVariables === !0 ?
        this.node(t, {
          kind: c.FRAGMENT_DEFINITION,
          name: this.parseFragmentName(),
          variableDefinitions: this.parseVariableDefinitions(),
          typeCondition: (this.expectKeyword('on'), this.parseNamedType()),
          directives: this.parseDirectives(!1),
          selectionSet: this.parseSelectionSet(),
        })
      : this.node(t, {
          kind: c.FRAGMENT_DEFINITION,
          name: this.parseFragmentName(),
          typeCondition: (this.expectKeyword('on'), this.parseNamedType()),
          directives: this.parseDirectives(!1),
          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: !0 });
          case 'false':
            return this.node(n, { kind: c.BOOLEAN, value: !1 });
          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(!0);
  }
  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(!0);
  }
  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 !== !0 &&
        (n.loc = new H(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 ${lt(t)}, found ${oe(n)}.`);
  }
  expectOptionalToken(t) {
    return this._lexer.token.kind === t ? (this.advanceLexer(), !0) : !1;
  }
  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(), !0) : !1;
  }
  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(e) {
  let t = e.value;
  return lt(e.kind) + (t != null ? ` "${t}"` : '');
}
function lt(e) {
  return it(e) ? `"${e}"` : e;
}
function en(e, t) {
  let n = new SyntaxError(
    e + ' (' + t.loc.start.line + ':' + t.loc.start.column + ')'
  );
  return Object.assign(n, t);
}
var pt = en;
function tn(e) {
  let t = [],
    { startToken: n, endToken: i } = e.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 nn = { allowLegacyFragmentVariables: !0 };
function rn(e) {
  if ((e == null ? void 0 : e.name) === 'GraphQLError') {
    let {
      message: t,
      locations: [n],
    } = e;
    return pt(t, { loc: { start: n }, cause: e });
  }
  return e;
}
function sn(e) {
  let t;
  try {
    t = ut(e, nn);
  } catch (n) {
    throw rn(n);
  }
  return (t.comments = tn(t)), t;
}
var on = {
  parse: sn,
  astFormat: 'graphql',
  hasPragma: Ye,
  locStart: K,
  locEnd: z,
};
var an = { graphql: $e };
var Si = _e;
export {
  Si as default,
  Je as languages,
  qe as options,
  Ne as parsers,
  an as printers,
};