@ticketapp-dev/shop-sdk 1.0.14

package/dist/index.js

@@ -0,0 +1,3618 @@
+import { GraphQLClient as C } from "graphql-request";
+import { createSlice as Ce, configureStore as _e } from "@reduxjs/toolkit";
+import { DateTime as y } from "luxon";
+var F = function() {
+  return F = Object.assign || function(e) {
+    for (var t, i = 1, n = arguments.length; i < n; i++) {
+      t = arguments[i];
+      for (var s in t) Object.prototype.hasOwnProperty.call(t, s) && (e[s] = t[s]);
+    }
+    return e;
+  }, F.apply(this, arguments);
+};
+function M(r, e) {
+  if (!!!r)
+    throw new Error(e);
+}
+function Le(r) {
+  return typeof r == "object" && r !== null;
+}
+function Re(r, e) {
+  if (!!!r)
+    throw new Error(
+      "Unexpected invariant triggered."
+    );
+}
+const Fe = /\r\n|[\n\r]/g;
+function z(r, e) {
+  let t = 0, i = 1;
+  for (const n of r.body.matchAll(Fe)) {
+    if (typeof n.index == "number" || Re(!1), n.index >= e)
+      break;
+    t = n.index + n[0].length, i += 1;
+  }
+  return {
+    line: i,
+    column: e + 1 - t
+  };
+}
+function we(r) {
+  return ie(
+    r.source,
+    z(r.source, r.start)
+  );
+}
+function ie(r, e) {
+  const t = r.locationOffset.column - 1, i = "".padStart(t) + r.body, n = e.line - 1, s = r.locationOffset.line - 1, o = e.line + s, u = e.line === 1 ? t : 0, l = e.column + u, f = `${r.name}:${o}:${l}
+`, c = i.split(/\r\n|[\n\r]/g), E = c[n];
+  if (E.length > 120) {
+    const m = Math.floor(l / 80), O = l % 80, I = [];
+    for (let A = 0; A < E.length; A += 80)
+      I.push(E.slice(A, A + 80));
+    return f + J([
+      [`${o} |`, I[0]],
+      ...I.slice(1, m + 1).map((A) => ["|", A]),
+      ["|", "^".padStart(O)],
+      ["|", I[m + 1]]
+    ]);
+  }
+  return f + J([
+    // Lines specified like this: ["prefix", "string"],
+    [`${o - 1} |`, c[n - 1]],
+    [`${o} |`, E],
+    ["|", "^".padStart(l)],
+    [`${o + 1} |`, c[n + 1]]
+  ]);
+}
+function J(r) {
+  const e = r.filter(([i, n]) => n !== void 0), t = Math.max(...e.map(([i]) => i.length));
+  return e.map(([i, n]) => i.padStart(t) + (n ? " " + n : "")).join(`
+`);
+}
+function Be(r) {
+  const e = r[0];
+  return e == null || "kind" in e || "length" in e ? {
+    nodes: e,
+    source: r[1],
+    positions: r[2],
+    path: r[3],
+    originalError: r[4],
+    extensions: r[5]
+  } : e;
+}
+class j extends Error {
+  /**
+   * An array of `{ line, column }` locations within the source GraphQL document
+   * which correspond to this error.
+   *
+   * Errors during validation often contain multiple locations, for example to
+   * point out two things with the same name. Errors during execution include a
+   * single location, the field which produced the error.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   */
+  /**
+   * An array describing the JSON-path into the execution response which
+   * corresponds to this error. Only included for errors during execution.
+   *
+   * Enumerable, and appears in the result of JSON.stringify().
+   */
+  /**
+   * An array of GraphQL AST Nodes corresponding to this error.
+   */
+  /**
+   * The source GraphQL document for the first location of this error.
+   *
+   * Note that if this Error represents more than one node, the source may not
+   * represent nodes after the first node.
+   */
+  /**
+   * An array of character offsets within the source GraphQL document
+   * which correspond to this error.
+   */
+  /**
+   * The original error thrown from a field resolver during execution.
+   */
+  /**
+   * Extension fields to add to the formatted error.
+   */
+  /**
+   * @deprecated Please use the `GraphQLErrorOptions` constructor overload instead.
+   */
+  constructor(e, ...t) {
+    var i, n, s;
+    const { nodes: o, source: u, positions: l, path: f, originalError: c, extensions: E } = Be(t);
+    super(e), this.name = "GraphQLError", this.path = f ?? void 0, this.originalError = c ?? void 0, this.nodes = X(
+      Array.isArray(o) ? o : o ? [o] : void 0
+    );
+    const m = X(
+      (i = this.nodes) === null || i === void 0 ? void 0 : i.map((I) => I.loc).filter((I) => I != null)
+    );
+    this.source = u ?? (m == null || (n = m[0]) === null || n === void 0 ? void 0 : n.source), this.positions = l ?? m?.map((I) => I.start), this.locations = l && u ? l.map((I) => z(u, I)) : m?.map((I) => z(I.source, I.start));
+    const O = Le(
+      c?.extensions
+    ) ? c?.extensions : void 0;
+    this.extensions = (s = E ?? O) !== null && s !== void 0 ? s : /* @__PURE__ */ 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
+      }
+    }), c != null && c.stack ? Object.defineProperty(this, "stack", {
+      value: c.stack,
+      writable: !0,
+      configurable: !0
+    }) : Error.captureStackTrace ? Error.captureStackTrace(this, j) : Object.defineProperty(this, "stack", {
+      value: Error().stack,
+      writable: !0,
+      configurable: !0
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "GraphQLError";
+  }
+  toString() {
+    let e = this.message;
+    if (this.nodes)
+      for (const t of this.nodes)
+        t.loc && (e += `
+
+` + we(t.loc));
+    else if (this.source && this.locations)
+      for (const t of this.locations)
+        e += `
+
+` + ie(this.source, t);
+    return e;
+  }
+  toJSON() {
+    const e = {
+      message: this.message
+    };
+    return this.locations != null && (e.locations = this.locations), this.path != null && (e.path = this.path), this.extensions != null && Object.keys(this.extensions).length > 0 && (e.extensions = this.extensions), e;
+  }
+}
+function X(r) {
+  return r === void 0 || r.length === 0 ? void 0 : r;
+}
+function g(r, e, t) {
+  return new j(`Syntax Error: ${t}`, {
+    source: r,
+    positions: [e]
+  });
+}
+class $e {
+  /**
+   * The character offset at which this Node begins.
+   */
+  /**
+   * The character offset at which this Node ends.
+   */
+  /**
+   * The Token at which this Node begins.
+   */
+  /**
+   * The Token at which this Node ends.
+   */
+  /**
+   * The Source document the AST represents.
+   */
+  constructor(e, t, i) {
+    this.start = e.start, this.end = t.end, this.startToken = e, this.endToken = t, this.source = i;
+  }
+  get [Symbol.toStringTag]() {
+    return "Location";
+  }
+  toJSON() {
+    return {
+      start: this.start,
+      end: this.end
+    };
+  }
+}
+class se {
+  /**
+   * The kind of Token.
+   */
+  /**
+   * The character offset at which this Node begins.
+   */
+  /**
+   * The character offset at which this Node ends.
+   */
+  /**
+   * The 1-indexed line number on which this Token appears.
+   */
+  /**
+   * The 1-indexed column number at which this Token begins.
+   */
+  /**
+   * For non-punctuation tokens, represents the interpreted value of the token.
+   *
+   * Note: is undefined for punctuation tokens, but typed as string for
+   * convenience in the parser.
+   */
+  /**
+   * Tokens exist as nodes in a double-linked-list amongst all tokens
+   * including ignored tokens. <SOF> is always the first node and <EOF>
+   * the last.
+   */
+  constructor(e, t, i, n, s, o) {
+    this.kind = e, this.start = t, this.end = i, this.line = n, this.column = s, this.value = o, 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
+    };
+  }
+}
+const Ue = {
+  Name: [],
+  Document: ["definitions"],
+  OperationDefinition: [
+    "description",
+    "name",
+    "variableDefinitions",
+    "directives",
+    "selectionSet"
+  ],
+  VariableDefinition: [
+    "description",
+    "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: [
+    "description",
+    "name",
+    // Note: fragment variable definitions are deprecated and will removed in v17.0.0
+    "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"],
+  TypeCoordinate: ["name"],
+  MemberCoordinate: ["name", "memberName"],
+  ArgumentCoordinate: ["name", "fieldName", "argumentName"],
+  DirectiveCoordinate: ["name"],
+  DirectiveArgumentCoordinate: ["name", "argumentName"]
+};
+new Set(Object.keys(Ue));
+var x;
+(function(r) {
+  r.QUERY = "query", r.MUTATION = "mutation", r.SUBSCRIPTION = "subscription";
+})(x || (x = {}));
+var q;
+(function(r) {
+  r.QUERY = "QUERY", r.MUTATION = "MUTATION", r.SUBSCRIPTION = "SUBSCRIPTION", r.FIELD = "FIELD", r.FRAGMENT_DEFINITION = "FRAGMENT_DEFINITION", r.FRAGMENT_SPREAD = "FRAGMENT_SPREAD", r.INLINE_FRAGMENT = "INLINE_FRAGMENT", r.VARIABLE_DEFINITION = "VARIABLE_DEFINITION", r.SCHEMA = "SCHEMA", r.SCALAR = "SCALAR", r.OBJECT = "OBJECT", r.FIELD_DEFINITION = "FIELD_DEFINITION", r.ARGUMENT_DEFINITION = "ARGUMENT_DEFINITION", r.INTERFACE = "INTERFACE", r.UNION = "UNION", r.ENUM = "ENUM", r.ENUM_VALUE = "ENUM_VALUE", r.INPUT_OBJECT = "INPUT_OBJECT", r.INPUT_FIELD_DEFINITION = "INPUT_FIELD_DEFINITION";
+})(q || (q = {}));
+var d;
+(function(r) {
+  r.NAME = "Name", r.DOCUMENT = "Document", r.OPERATION_DEFINITION = "OperationDefinition", r.VARIABLE_DEFINITION = "VariableDefinition", r.SELECTION_SET = "SelectionSet", r.FIELD = "Field", r.ARGUMENT = "Argument", r.FRAGMENT_SPREAD = "FragmentSpread", r.INLINE_FRAGMENT = "InlineFragment", r.FRAGMENT_DEFINITION = "FragmentDefinition", r.VARIABLE = "Variable", r.INT = "IntValue", r.FLOAT = "FloatValue", r.STRING = "StringValue", r.BOOLEAN = "BooleanValue", r.NULL = "NullValue", r.ENUM = "EnumValue", r.LIST = "ListValue", r.OBJECT = "ObjectValue", r.OBJECT_FIELD = "ObjectField", r.DIRECTIVE = "Directive", r.NAMED_TYPE = "NamedType", r.LIST_TYPE = "ListType", r.NON_NULL_TYPE = "NonNullType", r.SCHEMA_DEFINITION = "SchemaDefinition", r.OPERATION_TYPE_DEFINITION = "OperationTypeDefinition", r.SCALAR_TYPE_DEFINITION = "ScalarTypeDefinition", r.OBJECT_TYPE_DEFINITION = "ObjectTypeDefinition", r.FIELD_DEFINITION = "FieldDefinition", r.INPUT_VALUE_DEFINITION = "InputValueDefinition", r.INTERFACE_TYPE_DEFINITION = "InterfaceTypeDefinition", r.UNION_TYPE_DEFINITION = "UnionTypeDefinition", r.ENUM_TYPE_DEFINITION = "EnumTypeDefinition", r.ENUM_VALUE_DEFINITION = "EnumValueDefinition", r.INPUT_OBJECT_TYPE_DEFINITION = "InputObjectTypeDefinition", r.DIRECTIVE_DEFINITION = "DirectiveDefinition", r.SCHEMA_EXTENSION = "SchemaExtension", r.SCALAR_TYPE_EXTENSION = "ScalarTypeExtension", r.OBJECT_TYPE_EXTENSION = "ObjectTypeExtension", r.INTERFACE_TYPE_EXTENSION = "InterfaceTypeExtension", r.UNION_TYPE_EXTENSION = "UnionTypeExtension", r.ENUM_TYPE_EXTENSION = "EnumTypeExtension", r.INPUT_OBJECT_TYPE_EXTENSION = "InputObjectTypeExtension", r.TYPE_COORDINATE = "TypeCoordinate", r.MEMBER_COORDINATE = "MemberCoordinate", r.ARGUMENT_COORDINATE = "ArgumentCoordinate", r.DIRECTIVE_COORDINATE = "DirectiveCoordinate", r.DIRECTIVE_ARGUMENT_COORDINATE = "DirectiveArgumentCoordinate";
+})(d || (d = {}));
+function Me(r) {
+  return r === 9 || r === 32;
+}
+function S(r) {
+  return r >= 48 && r <= 57;
+}
+function oe(r) {
+  return r >= 97 && r <= 122 || // A-Z
+  r >= 65 && r <= 90;
+}
+function ae(r) {
+  return oe(r) || r === 95;
+}
+function Ve(r) {
+  return oe(r) || S(r) || r === 95;
+}
+function ze(r) {
+  var e;
+  let t = Number.MAX_SAFE_INTEGER, i = null, n = -1;
+  for (let o = 0; o < r.length; ++o) {
+    var s;
+    const u = r[o], l = qe(u);
+    l !== u.length && (i = (s = i) !== null && s !== void 0 ? s : o, n = o, o !== 0 && l < t && (t = l));
+  }
+  return r.map((o, u) => u === 0 ? o : o.slice(t)).slice(
+    (e = i) !== null && e !== void 0 ? e : 0,
+    n + 1
+  );
+}
+function qe(r) {
+  let e = 0;
+  for (; e < r.length && Me(r.charCodeAt(e)); )
+    ++e;
+  return e;
+}
+var a;
+(function(r) {
+  r.SOF = "<SOF>", r.EOF = "<EOF>", r.BANG = "!", r.DOLLAR = "$", r.AMP = "&", r.PAREN_L = "(", r.PAREN_R = ")", r.DOT = ".", r.SPREAD = "...", r.COLON = ":", r.EQUALS = "=", r.AT = "@", r.BRACKET_L = "[", r.BRACKET_R = "]", r.BRACE_L = "{", r.PIPE = "|", r.BRACE_R = "}", r.NAME = "Name", r.INT = "Int", r.FLOAT = "Float", r.STRING = "String", r.BLOCK_STRING = "BlockString", r.COMMENT = "Comment";
+})(a || (a = {}));
+class Ge {
+  /**
+   * The previously focused non-ignored token.
+   */
+  /**
+   * The currently focused non-ignored token.
+   */
+  /**
+   * The (1-indexed) line containing the current token.
+   */
+  /**
+   * The character offset at which the current line begins.
+   */
+  constructor(e) {
+    const t = new se(a.SOF, 0, 0, 0, 0);
+    this.source = e, this.lastToken = t, this.token = t, this.line = 1, this.lineStart = 0;
+  }
+  get [Symbol.toStringTag]() {
+    return "Lexer";
+  }
+  /**
+   * Advances the token stream to the next non-ignored token.
+   */
+  advance() {
+    return this.lastToken = this.token, this.token = this.lookahead();
+  }
+  /**
+   * Looks ahead and returns the next non-ignored token, but does not change
+   * the state of Lexer.
+   */
+  lookahead() {
+    let e = this.token;
+    if (e.kind !== a.EOF)
+      do
+        if (e.next)
+          e = e.next;
+        else {
+          const t = Ye(this, e.end);
+          e.next = t, t.prev = e, e = t;
+        }
+      while (e.kind === a.COMMENT);
+    return e;
+  }
+}
+function je(r) {
+  return r === a.BANG || r === a.DOLLAR || r === a.AMP || r === a.PAREN_L || r === a.PAREN_R || r === a.DOT || r === a.SPREAD || r === a.COLON || r === a.EQUALS || r === a.AT || r === a.BRACKET_L || r === a.BRACKET_R || r === a.BRACE_L || r === a.PIPE || r === a.BRACE_R;
+}
+function D(r) {
+  return r >= 0 && r <= 55295 || r >= 57344 && r <= 1114111;
+}
+function $(r, e) {
+  return ce(r.charCodeAt(e)) && de(r.charCodeAt(e + 1));
+}
+function ce(r) {
+  return r >= 55296 && r <= 56319;
+}
+function de(r) {
+  return r >= 56320 && r <= 57343;
+}
+function N(r, e) {
+  const t = r.source.body.codePointAt(e);
+  if (t === void 0)
+    return a.EOF;
+  if (t >= 32 && t <= 126) {
+    const i = String.fromCodePoint(t);
+    return i === '"' ? `'"'` : `"${i}"`;
+  }
+  return "U+" + t.toString(16).toUpperCase().padStart(4, "0");
+}
+function h(r, e, t, i, n) {
+  const s = r.line, o = 1 + t - r.lineStart;
+  return new se(e, t, i, s, o, n);
+}
+function Ye(r, e) {
+  const t = r.source.body, i = t.length;
+  let n = e;
+  for (; n < i; ) {
+    const s = t.charCodeAt(n);
+    switch (s) {
+      // Ignored ::
+      //   - UnicodeBOM
+      //   - WhiteSpace
+      //   - LineTerminator
+      //   - Comment
+      //   - Comma
+      //
+      // UnicodeBOM :: "Byte Order Mark (U+FEFF)"
+      //
+      // WhiteSpace ::
+      //   - "Horizontal Tab (U+0009)"
+      //   - "Space (U+0020)"
+      //
+      // Comma :: ,
+      case 65279:
+      // <BOM>
+      case 9:
+      // \t
+      case 32:
+      // <space>
+      case 44:
+        ++n;
+        continue;
+      // LineTerminator ::
+      //   - "New Line (U+000A)"
+      //   - "Carriage Return (U+000D)" [lookahead != "New Line (U+000A)"]
+      //   - "Carriage Return (U+000D)" "New Line (U+000A)"
+      case 10:
+        ++n, ++r.line, r.lineStart = n;
+        continue;
+      case 13:
+        t.charCodeAt(n + 1) === 10 ? n += 2 : ++n, ++r.line, r.lineStart = n;
+        continue;
+      // Comment
+      case 35:
+        return He(r, n);
+      // Token ::
+      //   - Punctuator
+      //   - Name
+      //   - IntValue
+      //   - FloatValue
+      //   - StringValue
+      //
+      // Punctuator :: one of ! $ & ( ) ... : = @ [ ] { | }
+      case 33:
+        return h(r, a.BANG, n, n + 1);
+      case 36:
+        return h(r, a.DOLLAR, n, n + 1);
+      case 38:
+        return h(r, a.AMP, n, n + 1);
+      case 40:
+        return h(r, a.PAREN_L, n, n + 1);
+      case 41:
+        return h(r, a.PAREN_R, n, n + 1);
+      case 46:
+        if (t.charCodeAt(n + 1) === 46 && t.charCodeAt(n + 2) === 46)
+          return h(r, a.SPREAD, n, n + 3);
+        break;
+      case 58:
+        return h(r, a.COLON, n, n + 1);
+      case 61:
+        return h(r, a.EQUALS, n, n + 1);
+      case 64:
+        return h(r, a.AT, n, n + 1);
+      case 91:
+        return h(r, a.BRACKET_L, n, n + 1);
+      case 93:
+        return h(r, a.BRACKET_R, n, n + 1);
+      case 123:
+        return h(r, a.BRACE_L, n, n + 1);
+      case 124:
+        return h(r, a.PIPE, n, n + 1);
+      case 125:
+        return h(r, a.BRACE_R, n, n + 1);
+      // StringValue
+      case 34:
+        return t.charCodeAt(n + 1) === 34 && t.charCodeAt(n + 2) === 34 ? Ze(r, n) : Je(r, n);
+    }
+    if (S(s) || s === 45)
+      return Qe(r, n, s);
+    if (ae(s))
+      return et(r, n);
+    throw g(
+      r.source,
+      n,
+      s === 39 ? `Unexpected single quote character ('), did you mean to use a double quote (")?` : D(s) || $(t, n) ? `Unexpected character: ${N(r, n)}.` : `Invalid character: ${N(r, n)}.`
+    );
+  }
+  return h(r, a.EOF, i, i);
+}
+function He(r, e) {
+  const t = r.source.body, i = t.length;
+  let n = e + 1;
+  for (; n < i; ) {
+    const s = t.charCodeAt(n);
+    if (s === 10 || s === 13)
+      break;
+    if (D(s))
+      ++n;
+    else if ($(t, n))
+      n += 2;
+    else
+      break;
+  }
+  return h(
+    r,
+    a.COMMENT,
+    e,
+    n,
+    t.slice(e + 1, n)
+  );
+}
+function Qe(r, e, t) {
+  const i = r.source.body;
+  let n = e, s = t, o = !1;
+  if (s === 45 && (s = i.charCodeAt(++n)), s === 48) {
+    if (s = i.charCodeAt(++n), S(s))
+      throw g(
+        r.source,
+        n,
+        `Invalid number, unexpected digit after 0: ${N(
+          r,
+          n
+        )}.`
+      );
+  } else
+    n = V(r, n, s), s = i.charCodeAt(n);
+  if (s === 46 && (o = !0, s = i.charCodeAt(++n), n = V(r, n, s), s = i.charCodeAt(n)), (s === 69 || s === 101) && (o = !0, s = i.charCodeAt(++n), (s === 43 || s === 45) && (s = i.charCodeAt(++n)), n = V(r, n, s), s = i.charCodeAt(n)), s === 46 || ae(s))
+    throw g(
+      r.source,
+      n,
+      `Invalid number, expected digit but got: ${N(
+        r,
+        n
+      )}.`
+    );
+  return h(
+    r,
+    o ? a.FLOAT : a.INT,
+    e,
+    n,
+    i.slice(e, n)
+  );
+}
+function V(r, e, t) {
+  if (!S(t))
+    throw g(
+      r.source,
+      e,
+      `Invalid number, expected digit but got: ${N(
+        r,
+        e
+      )}.`
+    );
+  const i = r.source.body;
+  let n = e + 1;
+  for (; S(i.charCodeAt(n)); )
+    ++n;
+  return n;
+}
+function Je(r, e) {
+  const t = r.source.body, i = t.length;
+  let n = e + 1, s = n, o = "";
+  for (; n < i; ) {
+    const u = t.charCodeAt(n);
+    if (u === 34)
+      return o += t.slice(s, n), h(r, a.STRING, e, n + 1, o);
+    if (u === 92) {
+      o += t.slice(s, n);
+      const l = t.charCodeAt(n + 1) === 117 ? t.charCodeAt(n + 2) === 123 ? Xe(r, n) : Ke(r, n) : We(r, n);
+      o += l.value, n += l.size, s = n;
+      continue;
+    }
+    if (u === 10 || u === 13)
+      break;
+    if (D(u))
+      ++n;
+    else if ($(t, n))
+      n += 2;
+    else
+      throw g(
+        r.source,
+        n,
+        `Invalid character within String: ${N(
+          r,
+          n
+        )}.`
+      );
+  }
+  throw g(r.source, n, "Unterminated string.");
+}
+function Xe(r, e) {
+  const t = r.source.body;
+  let i = 0, n = 3;
+  for (; n < 12; ) {
+    const s = t.charCodeAt(e + n++);
+    if (s === 125) {
+      if (n < 5 || !D(i))
+        break;
+      return {
+        value: String.fromCodePoint(i),
+        size: n
+      };
+    }
+    if (i = i << 4 | P(s), i < 0)
+      break;
+  }
+  throw g(
+    r.source,
+    e,
+    `Invalid Unicode escape sequence: "${t.slice(
+      e,
+      e + n
+    )}".`
+  );
+}
+function Ke(r, e) {
+  const t = r.source.body, i = K(t, e + 2);
+  if (D(i))
+    return {
+      value: String.fromCodePoint(i),
+      size: 6
+    };
+  if (ce(i) && t.charCodeAt(e + 6) === 92 && t.charCodeAt(e + 7) === 117) {
+    const n = K(t, e + 8);
+    if (de(n))
+      return {
+        value: String.fromCodePoint(i, n),
+        size: 12
+      };
+  }
+  throw g(
+    r.source,
+    e,
+    `Invalid Unicode escape sequence: "${t.slice(e, e + 6)}".`
+  );
+}
+function K(r, e) {
+  return P(r.charCodeAt(e)) << 12 | P(r.charCodeAt(e + 1)) << 8 | P(r.charCodeAt(e + 2)) << 4 | P(r.charCodeAt(e + 3));
+}
+function P(r) {
+  return r >= 48 && r <= 57 ? r - 48 : r >= 65 && r <= 70 ? r - 55 : r >= 97 && r <= 102 ? r - 87 : -1;
+}
+function We(r, e) {
+  const t = r.source.body;
+  switch (t.charCodeAt(e + 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 g(
+    r.source,
+    e,
+    `Invalid character escape sequence: "${t.slice(
+      e,
+      e + 2
+    )}".`
+  );
+}
+function Ze(r, e) {
+  const t = r.source.body, i = t.length;
+  let n = r.lineStart, s = e + 3, o = s, u = "";
+  const l = [];
+  for (; s < i; ) {
+    const f = t.charCodeAt(s);
+    if (f === 34 && t.charCodeAt(s + 1) === 34 && t.charCodeAt(s + 2) === 34) {
+      u += t.slice(o, s), l.push(u);
+      const c = h(
+        r,
+        a.BLOCK_STRING,
+        e,
+        s + 3,
+        // Return a string of the lines joined with U+000A.
+        ze(l).join(`
+`)
+      );
+      return r.line += l.length - 1, r.lineStart = n, c;
+    }
+    if (f === 92 && t.charCodeAt(s + 1) === 34 && t.charCodeAt(s + 2) === 34 && t.charCodeAt(s + 3) === 34) {
+      u += t.slice(o, s), o = s + 1, s += 4;
+      continue;
+    }
+    if (f === 10 || f === 13) {
+      u += t.slice(o, s), l.push(u), f === 13 && t.charCodeAt(s + 1) === 10 ? s += 2 : ++s, u = "", o = s, n = s;
+      continue;
+    }
+    if (D(f))
+      ++s;
+    else if ($(t, s))
+      s += 2;
+    else
+      throw g(
+        r.source,
+        s,
+        `Invalid character within String: ${N(
+          r,
+          s
+        )}.`
+      );
+  }
+  throw g(r.source, s, "Unterminated string.");
+}
+function et(r, e) {
+  const t = r.source.body, i = t.length;
+  let n = e + 1;
+  for (; n < i; ) {
+    const s = t.charCodeAt(n);
+    if (Ve(s))
+      ++n;
+    else
+      break;
+  }
+  return h(
+    r,
+    a.NAME,
+    e,
+    n,
+    t.slice(e, n)
+  );
+}
+const tt = 10, ue = 2;
+function le(r) {
+  return U(r, []);
+}
+function U(r, e) {
+  switch (typeof r) {
+    case "string":
+      return JSON.stringify(r);
+    case "function":
+      return r.name ? `[function ${r.name}]` : "[function]";
+    case "object":
+      return rt(r, e);
+    default:
+      return String(r);
+  }
+}
+function rt(r, e) {
+  if (r === null)
+    return "null";
+  if (e.includes(r))
+    return "[Circular]";
+  const t = [...e, r];
+  if (nt(r)) {
+    const i = r.toJSON();
+    if (i !== r)
+      return typeof i == "string" ? i : U(i, t);
+  } else if (Array.isArray(r))
+    return st(r, t);
+  return it(r, t);
+}
+function nt(r) {
+  return typeof r.toJSON == "function";
+}
+function it(r, e) {
+  const t = Object.entries(r);
+  return t.length === 0 ? "{}" : e.length > ue ? "[" + ot(r) + "]" : "{ " + t.map(
+    ([n, s]) => n + ": " + U(s, e)
+  ).join(", ") + " }";
+}
+function st(r, e) {
+  if (r.length === 0)
+    return "[]";
+  if (e.length > ue)
+    return "[Array]";
+  const t = Math.min(tt, r.length), i = r.length - t, n = [];
+  for (let s = 0; s < t; ++s)
+    n.push(U(r[s], e));
+  return i === 1 ? n.push("... 1 more item") : i > 1 && n.push(`... ${i} more items`), "[" + n.join(", ") + "]";
+}
+function ot(r) {
+  const e = Object.prototype.toString.call(r).replace(/^\[object /, "").replace(/]$/, "");
+  if (e === "Object" && typeof r.constructor == "function") {
+    const t = r.constructor.name;
+    if (typeof t == "string" && t !== "")
+      return t;
+  }
+  return e;
+}
+const at = globalThis.process && // eslint-disable-next-line no-undef
+process.env.NODE_ENV === "production", ct = (
+  /* c8 ignore next 6 */
+  // FIXME: https://github.com/graphql/graphql-js/issues/2317
+  at ? function(e, t) {
+    return e instanceof t;
+  } : function(e, t) {
+    if (e instanceof t)
+      return !0;
+    if (typeof e == "object" && e !== null) {
+      var i;
+      const n = t.prototype[Symbol.toStringTag], s = (
+        // We still need to support constructor's name to detect conflicts with older versions of this library.
+        Symbol.toStringTag in e ? e[Symbol.toStringTag] : (i = e.constructor) === null || i === void 0 ? void 0 : i.name
+      );
+      if (n === s) {
+        const o = le(e);
+        throw new Error(`Cannot use ${n} "${o}" 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;
+  }
+);
+class pe {
+  constructor(e, t = "GraphQL request", i = {
+    line: 1,
+    column: 1
+  }) {
+    typeof e == "string" || M(!1, `Body must be a string. Received: ${le(e)}.`), this.body = e, this.name = t, this.locationOffset = i, this.locationOffset.line > 0 || M(
+      !1,
+      "line in locationOffset is 1-indexed and must be positive."
+    ), this.locationOffset.column > 0 || M(
+      !1,
+      "column in locationOffset is 1-indexed and must be positive."
+    );
+  }
+  get [Symbol.toStringTag]() {
+    return "Source";
+  }
+}
+function dt(r) {
+  return ct(r, pe);
+}
+function ut(r, e) {
+  const t = new lt(r, e), i = t.parseDocument();
+  return Object.defineProperty(i, "tokenCount", {
+    enumerable: !1,
+    value: t.tokenCount
+  }), i;
+}
+class lt {
+  constructor(e, t = {}) {
+    const { lexer: i, ...n } = t;
+    if (i)
+      this._lexer = i;
+    else {
+      const s = dt(e) ? e : new pe(e);
+      this._lexer = new Ge(s);
+    }
+    this._options = n, this._tokenCounter = 0;
+  }
+  get tokenCount() {
+    return this._tokenCounter;
+  }
+  /**
+   * Converts a name lex token into a name parse node.
+   */
+  parseName() {
+    const e = this.expectToken(a.NAME);
+    return this.node(e, {
+      kind: d.NAME,
+      value: e.value
+    });
+  }
+  // Implements the parsing rules in the Document section.
+  /**
+   * Document : Definition+
+   */
+  parseDocument() {
+    return this.node(this._lexer.token, {
+      kind: d.DOCUMENT,
+      definitions: this.many(
+        a.SOF,
+        this.parseDefinition,
+        a.EOF
+      )
+    });
+  }
+  /**
+   * Definition :
+   *   - ExecutableDefinition
+   *   - TypeSystemDefinition
+   *   - TypeSystemExtension
+   *
+   * ExecutableDefinition :
+   *   - OperationDefinition
+   *   - FragmentDefinition
+   *
+   * TypeSystemDefinition :
+   *   - SchemaDefinition
+   *   - TypeDefinition
+   *   - DirectiveDefinition
+   *
+   * TypeDefinition :
+   *   - ScalarTypeDefinition
+   *   - ObjectTypeDefinition
+   *   - InterfaceTypeDefinition
+   *   - UnionTypeDefinition
+   *   - EnumTypeDefinition
+   *   - InputObjectTypeDefinition
+   */
+  parseDefinition() {
+    if (this.peek(a.BRACE_L))
+      return this.parseOperationDefinition();
+    const e = this.peekDescription(), t = e ? this._lexer.lookahead() : this._lexer.token;
+    if (e && t.kind === a.BRACE_L)
+      throw g(
+        this._lexer.source,
+        this._lexer.token.start,
+        "Unexpected description, descriptions are not supported on shorthand queries."
+      );
+    if (t.kind === a.NAME) {
+      switch (t.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();
+      }
+      switch (t.value) {
+        case "query":
+        case "mutation":
+        case "subscription":
+          return this.parseOperationDefinition();
+        case "fragment":
+          return this.parseFragmentDefinition();
+      }
+      if (e)
+        throw g(
+          this._lexer.source,
+          this._lexer.token.start,
+          "Unexpected description, only GraphQL definitions support descriptions."
+        );
+      if (t.value === "extend")
+        return this.parseTypeSystemExtension();
+    }
+    throw this.unexpected(t);
+  }
+  // Implements the parsing rules in the Operations section.
+  /**
+   * OperationDefinition :
+   *  - SelectionSet
+   *  - OperationType Name? VariableDefinitions? Directives? SelectionSet
+   */
+  parseOperationDefinition() {
+    const e = this._lexer.token;
+    if (this.peek(a.BRACE_L))
+      return this.node(e, {
+        kind: d.OPERATION_DEFINITION,
+        operation: x.QUERY,
+        description: void 0,
+        name: void 0,
+        variableDefinitions: [],
+        directives: [],
+        selectionSet: this.parseSelectionSet()
+      });
+    const t = this.parseDescription(), i = this.parseOperationType();
+    let n;
+    return this.peek(a.NAME) && (n = this.parseName()), this.node(e, {
+      kind: d.OPERATION_DEFINITION,
+      operation: i,
+      description: t,
+      name: n,
+      variableDefinitions: this.parseVariableDefinitions(),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * OperationType : one of query mutation subscription
+   */
+  parseOperationType() {
+    const e = this.expectToken(a.NAME);
+    switch (e.value) {
+      case "query":
+        return x.QUERY;
+      case "mutation":
+        return x.MUTATION;
+      case "subscription":
+        return x.SUBSCRIPTION;
+    }
+    throw this.unexpected(e);
+  }
+  /**
+   * VariableDefinitions : ( VariableDefinition+ )
+   */
+  parseVariableDefinitions() {
+    return this.optionalMany(
+      a.PAREN_L,
+      this.parseVariableDefinition,
+      a.PAREN_R
+    );
+  }
+  /**
+   * VariableDefinition : Variable : Type DefaultValue? Directives[Const]?
+   */
+  parseVariableDefinition() {
+    return this.node(this._lexer.token, {
+      kind: d.VARIABLE_DEFINITION,
+      description: this.parseDescription(),
+      variable: this.parseVariable(),
+      type: (this.expectToken(a.COLON), this.parseTypeReference()),
+      defaultValue: this.expectOptionalToken(a.EQUALS) ? this.parseConstValueLiteral() : void 0,
+      directives: this.parseConstDirectives()
+    });
+  }
+  /**
+   * Variable : $ Name
+   */
+  parseVariable() {
+    const e = this._lexer.token;
+    return this.expectToken(a.DOLLAR), this.node(e, {
+      kind: d.VARIABLE,
+      name: this.parseName()
+    });
+  }
+  /**
+   * ```
+   * SelectionSet : { Selection+ }
+   * ```
+   */
+  parseSelectionSet() {
+    return this.node(this._lexer.token, {
+      kind: d.SELECTION_SET,
+      selections: this.many(
+        a.BRACE_L,
+        this.parseSelection,
+        a.BRACE_R
+      )
+    });
+  }
+  /**
+   * Selection :
+   *   - Field
+   *   - FragmentSpread
+   *   - InlineFragment
+   */
+  parseSelection() {
+    return this.peek(a.SPREAD) ? this.parseFragment() : this.parseField();
+  }
+  /**
+   * Field : Alias? Name Arguments? Directives? SelectionSet?
+   *
+   * Alias : Name :
+   */
+  parseField() {
+    const e = this._lexer.token, t = this.parseName();
+    let i, n;
+    return this.expectOptionalToken(a.COLON) ? (i = t, n = this.parseName()) : n = t, this.node(e, {
+      kind: d.FIELD,
+      alias: i,
+      name: n,
+      arguments: this.parseArguments(!1),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.peek(a.BRACE_L) ? this.parseSelectionSet() : void 0
+    });
+  }
+  /**
+   * Arguments[Const] : ( Argument[?Const]+ )
+   */
+  parseArguments(e) {
+    const t = e ? this.parseConstArgument : this.parseArgument;
+    return this.optionalMany(a.PAREN_L, t, a.PAREN_R);
+  }
+  /**
+   * Argument[Const] : Name : Value[?Const]
+   */
+  parseArgument(e = !1) {
+    const t = this._lexer.token, i = this.parseName();
+    return this.expectToken(a.COLON), this.node(t, {
+      kind: d.ARGUMENT,
+      name: i,
+      value: this.parseValueLiteral(e)
+    });
+  }
+  parseConstArgument() {
+    return this.parseArgument(!0);
+  }
+  // Implements the parsing rules in the Fragments section.
+  /**
+   * Corresponds to both FragmentSpread and InlineFragment in the spec.
+   *
+   * FragmentSpread : ... FragmentName Directives?
+   *
+   * InlineFragment : ... TypeCondition? Directives? SelectionSet
+   */
+  parseFragment() {
+    const e = this._lexer.token;
+    this.expectToken(a.SPREAD);
+    const t = this.expectOptionalKeyword("on");
+    return !t && this.peek(a.NAME) ? this.node(e, {
+      kind: d.FRAGMENT_SPREAD,
+      name: this.parseFragmentName(),
+      directives: this.parseDirectives(!1)
+    }) : this.node(e, {
+      kind: d.INLINE_FRAGMENT,
+      typeCondition: t ? this.parseNamedType() : void 0,
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * FragmentDefinition :
+   *   - fragment FragmentName on TypeCondition Directives? SelectionSet
+   *
+   * TypeCondition : NamedType
+   */
+  parseFragmentDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    return this.expectKeyword("fragment"), this._options.allowLegacyFragmentVariables === !0 ? this.node(e, {
+      kind: d.FRAGMENT_DEFINITION,
+      description: t,
+      name: this.parseFragmentName(),
+      variableDefinitions: this.parseVariableDefinitions(),
+      typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    }) : this.node(e, {
+      kind: d.FRAGMENT_DEFINITION,
+      description: t,
+      name: this.parseFragmentName(),
+      typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * FragmentName : Name but not `on`
+   */
+  parseFragmentName() {
+    if (this._lexer.token.value === "on")
+      throw this.unexpected();
+    return this.parseName();
+  }
+  // Implements the parsing rules in the Values section.
+  /**
+   * Value[Const] :
+   *   - [~Const] Variable
+   *   - IntValue
+   *   - FloatValue
+   *   - StringValue
+   *   - BooleanValue
+   *   - NullValue
+   *   - EnumValue
+   *   - ListValue[?Const]
+   *   - ObjectValue[?Const]
+   *
+   * BooleanValue : one of `true` `false`
+   *
+   * NullValue : `null`
+   *
+   * EnumValue : Name but not `true`, `false` or `null`
+   */
+  parseValueLiteral(e) {
+    const t = this._lexer.token;
+    switch (t.kind) {
+      case a.BRACKET_L:
+        return this.parseList(e);
+      case a.BRACE_L:
+        return this.parseObject(e);
+      case a.INT:
+        return this.advanceLexer(), this.node(t, {
+          kind: d.INT,
+          value: t.value
+        });
+      case a.FLOAT:
+        return this.advanceLexer(), this.node(t, {
+          kind: d.FLOAT,
+          value: t.value
+        });
+      case a.STRING:
+      case a.BLOCK_STRING:
+        return this.parseStringLiteral();
+      case a.NAME:
+        switch (this.advanceLexer(), t.value) {
+          case "true":
+            return this.node(t, {
+              kind: d.BOOLEAN,
+              value: !0
+            });
+          case "false":
+            return this.node(t, {
+              kind: d.BOOLEAN,
+              value: !1
+            });
+          case "null":
+            return this.node(t, {
+              kind: d.NULL
+            });
+          default:
+            return this.node(t, {
+              kind: d.ENUM,
+              value: t.value
+            });
+        }
+      case a.DOLLAR:
+        if (e)
+          if (this.expectToken(a.DOLLAR), this._lexer.token.kind === a.NAME) {
+            const i = this._lexer.token.value;
+            throw g(
+              this._lexer.source,
+              t.start,
+              `Unexpected variable "$${i}" in constant value.`
+            );
+          } else
+            throw this.unexpected(t);
+        return this.parseVariable();
+      default:
+        throw this.unexpected();
+    }
+  }
+  parseConstValueLiteral() {
+    return this.parseValueLiteral(!0);
+  }
+  parseStringLiteral() {
+    const e = this._lexer.token;
+    return this.advanceLexer(), this.node(e, {
+      kind: d.STRING,
+      value: e.value,
+      block: e.kind === a.BLOCK_STRING
+    });
+  }
+  /**
+   * ListValue[Const] :
+   *   - [ ]
+   *   - [ Value[?Const]+ ]
+   */
+  parseList(e) {
+    const t = () => this.parseValueLiteral(e);
+    return this.node(this._lexer.token, {
+      kind: d.LIST,
+      values: this.any(a.BRACKET_L, t, a.BRACKET_R)
+    });
+  }
+  /**
+   * ```
+   * ObjectValue[Const] :
+   *   - { }
+   *   - { ObjectField[?Const]+ }
+   * ```
+   */
+  parseObject(e) {
+    const t = () => this.parseObjectField(e);
+    return this.node(this._lexer.token, {
+      kind: d.OBJECT,
+      fields: this.any(a.BRACE_L, t, a.BRACE_R)
+    });
+  }
+  /**
+   * ObjectField[Const] : Name : Value[?Const]
+   */
+  parseObjectField(e) {
+    const t = this._lexer.token, i = this.parseName();
+    return this.expectToken(a.COLON), this.node(t, {
+      kind: d.OBJECT_FIELD,
+      name: i,
+      value: this.parseValueLiteral(e)
+    });
+  }
+  // Implements the parsing rules in the Directives section.
+  /**
+   * Directives[Const] : Directive[?Const]+
+   */
+  parseDirectives(e) {
+    const t = [];
+    for (; this.peek(a.AT); )
+      t.push(this.parseDirective(e));
+    return t;
+  }
+  parseConstDirectives() {
+    return this.parseDirectives(!0);
+  }
+  /**
+   * ```
+   * Directive[Const] : @ Name Arguments[?Const]?
+   * ```
+   */
+  parseDirective(e) {
+    const t = this._lexer.token;
+    return this.expectToken(a.AT), this.node(t, {
+      kind: d.DIRECTIVE,
+      name: this.parseName(),
+      arguments: this.parseArguments(e)
+    });
+  }
+  // Implements the parsing rules in the Types section.
+  /**
+   * Type :
+   *   - NamedType
+   *   - ListType
+   *   - NonNullType
+   */
+  parseTypeReference() {
+    const e = this._lexer.token;
+    let t;
+    if (this.expectOptionalToken(a.BRACKET_L)) {
+      const i = this.parseTypeReference();
+      this.expectToken(a.BRACKET_R), t = this.node(e, {
+        kind: d.LIST_TYPE,
+        type: i
+      });
+    } else
+      t = this.parseNamedType();
+    return this.expectOptionalToken(a.BANG) ? this.node(e, {
+      kind: d.NON_NULL_TYPE,
+      type: t
+    }) : t;
+  }
+  /**
+   * NamedType : Name
+   */
+  parseNamedType() {
+    return this.node(this._lexer.token, {
+      kind: d.NAMED_TYPE,
+      name: this.parseName()
+    });
+  }
+  // Implements the parsing rules in the Type Definition section.
+  peekDescription() {
+    return this.peek(a.STRING) || this.peek(a.BLOCK_STRING);
+  }
+  /**
+   * Description : StringValue
+   */
+  parseDescription() {
+    if (this.peekDescription())
+      return this.parseStringLiteral();
+  }
+  /**
+   * ```
+   * SchemaDefinition : Description? schema Directives[Const]? { OperationTypeDefinition+ }
+   * ```
+   */
+  parseSchemaDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("schema");
+    const i = this.parseConstDirectives(), n = this.many(
+      a.BRACE_L,
+      this.parseOperationTypeDefinition,
+      a.BRACE_R
+    );
+    return this.node(e, {
+      kind: d.SCHEMA_DEFINITION,
+      description: t,
+      directives: i,
+      operationTypes: n
+    });
+  }
+  /**
+   * OperationTypeDefinition : OperationType : NamedType
+   */
+  parseOperationTypeDefinition() {
+    const e = this._lexer.token, t = this.parseOperationType();
+    this.expectToken(a.COLON);
+    const i = this.parseNamedType();
+    return this.node(e, {
+      kind: d.OPERATION_TYPE_DEFINITION,
+      operation: t,
+      type: i
+    });
+  }
+  /**
+   * ScalarTypeDefinition : Description? scalar Name Directives[Const]?
+   */
+  parseScalarTypeDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("scalar");
+    const i = this.parseName(), n = this.parseConstDirectives();
+    return this.node(e, {
+      kind: d.SCALAR_TYPE_DEFINITION,
+      description: t,
+      name: i,
+      directives: n
+    });
+  }
+  /**
+   * ObjectTypeDefinition :
+   *   Description?
+   *   type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition?
+   */
+  parseObjectTypeDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("type");
+    const i = this.parseName(), n = this.parseImplementsInterfaces(), s = this.parseConstDirectives(), o = this.parseFieldsDefinition();
+    return this.node(e, {
+      kind: d.OBJECT_TYPE_DEFINITION,
+      description: t,
+      name: i,
+      interfaces: n,
+      directives: s,
+      fields: o
+    });
+  }
+  /**
+   * ImplementsInterfaces :
+   *   - implements `&`? NamedType
+   *   - ImplementsInterfaces & NamedType
+   */
+  parseImplementsInterfaces() {
+    return this.expectOptionalKeyword("implements") ? this.delimitedMany(a.AMP, this.parseNamedType) : [];
+  }
+  /**
+   * ```
+   * FieldsDefinition : { FieldDefinition+ }
+   * ```
+   */
+  parseFieldsDefinition() {
+    return this.optionalMany(
+      a.BRACE_L,
+      this.parseFieldDefinition,
+      a.BRACE_R
+    );
+  }
+  /**
+   * FieldDefinition :
+   *   - Description? Name ArgumentsDefinition? : Type Directives[Const]?
+   */
+  parseFieldDefinition() {
+    const e = this._lexer.token, t = this.parseDescription(), i = this.parseName(), n = this.parseArgumentDefs();
+    this.expectToken(a.COLON);
+    const s = this.parseTypeReference(), o = this.parseConstDirectives();
+    return this.node(e, {
+      kind: d.FIELD_DEFINITION,
+      description: t,
+      name: i,
+      arguments: n,
+      type: s,
+      directives: o
+    });
+  }
+  /**
+   * ArgumentsDefinition : ( InputValueDefinition+ )
+   */
+  parseArgumentDefs() {
+    return this.optionalMany(
+      a.PAREN_L,
+      this.parseInputValueDef,
+      a.PAREN_R
+    );
+  }
+  /**
+   * InputValueDefinition :
+   *   - Description? Name : Type DefaultValue? Directives[Const]?
+   */
+  parseInputValueDef() {
+    const e = this._lexer.token, t = this.parseDescription(), i = this.parseName();
+    this.expectToken(a.COLON);
+    const n = this.parseTypeReference();
+    let s;
+    this.expectOptionalToken(a.EQUALS) && (s = this.parseConstValueLiteral());
+    const o = this.parseConstDirectives();
+    return this.node(e, {
+      kind: d.INPUT_VALUE_DEFINITION,
+      description: t,
+      name: i,
+      type: n,
+      defaultValue: s,
+      directives: o
+    });
+  }
+  /**
+   * InterfaceTypeDefinition :
+   *   - Description? interface Name Directives[Const]? FieldsDefinition?
+   */
+  parseInterfaceTypeDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("interface");
+    const i = this.parseName(), n = this.parseImplementsInterfaces(), s = this.parseConstDirectives(), o = this.parseFieldsDefinition();
+    return this.node(e, {
+      kind: d.INTERFACE_TYPE_DEFINITION,
+      description: t,
+      name: i,
+      interfaces: n,
+      directives: s,
+      fields: o
+    });
+  }
+  /**
+   * UnionTypeDefinition :
+   *   - Description? union Name Directives[Const]? UnionMemberTypes?
+   */
+  parseUnionTypeDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("union");
+    const i = this.parseName(), n = this.parseConstDirectives(), s = this.parseUnionMemberTypes();
+    return this.node(e, {
+      kind: d.UNION_TYPE_DEFINITION,
+      description: t,
+      name: i,
+      directives: n,
+      types: s
+    });
+  }
+  /**
+   * UnionMemberTypes :
+   *   - = `|`? NamedType
+   *   - UnionMemberTypes | NamedType
+   */
+  parseUnionMemberTypes() {
+    return this.expectOptionalToken(a.EQUALS) ? this.delimitedMany(a.PIPE, this.parseNamedType) : [];
+  }
+  /**
+   * EnumTypeDefinition :
+   *   - Description? enum Name Directives[Const]? EnumValuesDefinition?
+   */
+  parseEnumTypeDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("enum");
+    const i = this.parseName(), n = this.parseConstDirectives(), s = this.parseEnumValuesDefinition();
+    return this.node(e, {
+      kind: d.ENUM_TYPE_DEFINITION,
+      description: t,
+      name: i,
+      directives: n,
+      values: s
+    });
+  }
+  /**
+   * ```
+   * EnumValuesDefinition : { EnumValueDefinition+ }
+   * ```
+   */
+  parseEnumValuesDefinition() {
+    return this.optionalMany(
+      a.BRACE_L,
+      this.parseEnumValueDefinition,
+      a.BRACE_R
+    );
+  }
+  /**
+   * EnumValueDefinition : Description? EnumValue Directives[Const]?
+   */
+  parseEnumValueDefinition() {
+    const e = this._lexer.token, t = this.parseDescription(), i = this.parseEnumValueName(), n = this.parseConstDirectives();
+    return this.node(e, {
+      kind: d.ENUM_VALUE_DEFINITION,
+      description: t,
+      name: i,
+      directives: n
+    });
+  }
+  /**
+   * EnumValue : Name but not `true`, `false` or `null`
+   */
+  parseEnumValueName() {
+    if (this._lexer.token.value === "true" || this._lexer.token.value === "false" || this._lexer.token.value === "null")
+      throw g(
+        this._lexer.source,
+        this._lexer.token.start,
+        `${_(
+          this._lexer.token
+        )} is reserved and cannot be used for an enum value.`
+      );
+    return this.parseName();
+  }
+  /**
+   * InputObjectTypeDefinition :
+   *   - Description? input Name Directives[Const]? InputFieldsDefinition?
+   */
+  parseInputObjectTypeDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("input");
+    const i = this.parseName(), n = this.parseConstDirectives(), s = this.parseInputFieldsDefinition();
+    return this.node(e, {
+      kind: d.INPUT_OBJECT_TYPE_DEFINITION,
+      description: t,
+      name: i,
+      directives: n,
+      fields: s
+    });
+  }
+  /**
+   * ```
+   * InputFieldsDefinition : { InputValueDefinition+ }
+   * ```
+   */
+  parseInputFieldsDefinition() {
+    return this.optionalMany(
+      a.BRACE_L,
+      this.parseInputValueDef,
+      a.BRACE_R
+    );
+  }
+  /**
+   * TypeSystemExtension :
+   *   - SchemaExtension
+   *   - TypeExtension
+   *
+   * TypeExtension :
+   *   - ScalarTypeExtension
+   *   - ObjectTypeExtension
+   *   - InterfaceTypeExtension
+   *   - UnionTypeExtension
+   *   - EnumTypeExtension
+   *   - InputObjectTypeDefinition
+   */
+  parseTypeSystemExtension() {
+    const e = this._lexer.lookahead();
+    if (e.kind === a.NAME)
+      switch (e.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(e);
+  }
+  /**
+   * ```
+   * SchemaExtension :
+   *  - extend schema Directives[Const]? { OperationTypeDefinition+ }
+   *  - extend schema Directives[Const]
+   * ```
+   */
+  parseSchemaExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("schema");
+    const t = this.parseConstDirectives(), i = this.optionalMany(
+      a.BRACE_L,
+      this.parseOperationTypeDefinition,
+      a.BRACE_R
+    );
+    if (t.length === 0 && i.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: d.SCHEMA_EXTENSION,
+      directives: t,
+      operationTypes: i
+    });
+  }
+  /**
+   * ScalarTypeExtension :
+   *   - extend scalar Name Directives[Const]
+   */
+  parseScalarTypeExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("scalar");
+    const t = this.parseName(), i = this.parseConstDirectives();
+    if (i.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: d.SCALAR_TYPE_EXTENSION,
+      name: t,
+      directives: i
+    });
+  }
+  /**
+   * ObjectTypeExtension :
+   *  - extend type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+   *  - extend type Name ImplementsInterfaces? Directives[Const]
+   *  - extend type Name ImplementsInterfaces
+   */
+  parseObjectTypeExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("type");
+    const t = this.parseName(), i = this.parseImplementsInterfaces(), n = this.parseConstDirectives(), s = this.parseFieldsDefinition();
+    if (i.length === 0 && n.length === 0 && s.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: d.OBJECT_TYPE_EXTENSION,
+      name: t,
+      interfaces: i,
+      directives: n,
+      fields: s
+    });
+  }
+  /**
+   * InterfaceTypeExtension :
+   *  - extend interface Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+   *  - extend interface Name ImplementsInterfaces? Directives[Const]
+   *  - extend interface Name ImplementsInterfaces
+   */
+  parseInterfaceTypeExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("interface");
+    const t = this.parseName(), i = this.parseImplementsInterfaces(), n = this.parseConstDirectives(), s = this.parseFieldsDefinition();
+    if (i.length === 0 && n.length === 0 && s.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: d.INTERFACE_TYPE_EXTENSION,
+      name: t,
+      interfaces: i,
+      directives: n,
+      fields: s
+    });
+  }
+  /**
+   * UnionTypeExtension :
+   *   - extend union Name Directives[Const]? UnionMemberTypes
+   *   - extend union Name Directives[Const]
+   */
+  parseUnionTypeExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("union");
+    const t = this.parseName(), i = this.parseConstDirectives(), n = this.parseUnionMemberTypes();
+    if (i.length === 0 && n.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: d.UNION_TYPE_EXTENSION,
+      name: t,
+      directives: i,
+      types: n
+    });
+  }
+  /**
+   * EnumTypeExtension :
+   *   - extend enum Name Directives[Const]? EnumValuesDefinition
+   *   - extend enum Name Directives[Const]
+   */
+  parseEnumTypeExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("enum");
+    const t = this.parseName(), i = this.parseConstDirectives(), n = this.parseEnumValuesDefinition();
+    if (i.length === 0 && n.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: d.ENUM_TYPE_EXTENSION,
+      name: t,
+      directives: i,
+      values: n
+    });
+  }
+  /**
+   * InputObjectTypeExtension :
+   *   - extend input Name Directives[Const]? InputFieldsDefinition
+   *   - extend input Name Directives[Const]
+   */
+  parseInputObjectTypeExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("input");
+    const t = this.parseName(), i = this.parseConstDirectives(), n = this.parseInputFieldsDefinition();
+    if (i.length === 0 && n.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: d.INPUT_OBJECT_TYPE_EXTENSION,
+      name: t,
+      directives: i,
+      fields: n
+    });
+  }
+  /**
+   * ```
+   * DirectiveDefinition :
+   *   - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations
+   * ```
+   */
+  parseDirectiveDefinition() {
+    const e = this._lexer.token, t = this.parseDescription();
+    this.expectKeyword("directive"), this.expectToken(a.AT);
+    const i = this.parseName(), n = this.parseArgumentDefs(), s = this.expectOptionalKeyword("repeatable");
+    this.expectKeyword("on");
+    const o = this.parseDirectiveLocations();
+    return this.node(e, {
+      kind: d.DIRECTIVE_DEFINITION,
+      description: t,
+      name: i,
+      arguments: n,
+      repeatable: s,
+      locations: o
+    });
+  }
+  /**
+   * DirectiveLocations :
+   *   - `|`? DirectiveLocation
+   *   - DirectiveLocations | DirectiveLocation
+   */
+  parseDirectiveLocations() {
+    return this.delimitedMany(a.PIPE, this.parseDirectiveLocation);
+  }
+  /*
+   * DirectiveLocation :
+   *   - ExecutableDirectiveLocation
+   *   - TypeSystemDirectiveLocation
+   *
+   * ExecutableDirectiveLocation : one of
+   *   `QUERY`
+   *   `MUTATION`
+   *   `SUBSCRIPTION`
+   *   `FIELD`
+   *   `FRAGMENT_DEFINITION`
+   *   `FRAGMENT_SPREAD`
+   *   `INLINE_FRAGMENT`
+   *
+   * TypeSystemDirectiveLocation : one of
+   *   `SCHEMA`
+   *   `SCALAR`
+   *   `OBJECT`
+   *   `FIELD_DEFINITION`
+   *   `ARGUMENT_DEFINITION`
+   *   `INTERFACE`
+   *   `UNION`
+   *   `ENUM`
+   *   `ENUM_VALUE`
+   *   `INPUT_OBJECT`
+   *   `INPUT_FIELD_DEFINITION`
+   */
+  parseDirectiveLocation() {
+    const e = this._lexer.token, t = this.parseName();
+    if (Object.prototype.hasOwnProperty.call(q, t.value))
+      return t;
+    throw this.unexpected(e);
+  }
+  // Schema Coordinates
+  /**
+   * SchemaCoordinate :
+   *   - Name
+   *   - Name . Name
+   *   - Name . Name ( Name : )
+   *   - \@ Name
+   *   - \@ Name ( Name : )
+   */
+  parseSchemaCoordinate() {
+    const e = this._lexer.token, t = this.expectOptionalToken(a.AT), i = this.parseName();
+    let n;
+    !t && this.expectOptionalToken(a.DOT) && (n = this.parseName());
+    let s;
+    return (t || n) && this.expectOptionalToken(a.PAREN_L) && (s = this.parseName(), this.expectToken(a.COLON), this.expectToken(a.PAREN_R)), t ? s ? this.node(e, {
+      kind: d.DIRECTIVE_ARGUMENT_COORDINATE,
+      name: i,
+      argumentName: s
+    }) : this.node(e, {
+      kind: d.DIRECTIVE_COORDINATE,
+      name: i
+    }) : n ? s ? this.node(e, {
+      kind: d.ARGUMENT_COORDINATE,
+      name: i,
+      fieldName: n,
+      argumentName: s
+    }) : this.node(e, {
+      kind: d.MEMBER_COORDINATE,
+      name: i,
+      memberName: n
+    }) : this.node(e, {
+      kind: d.TYPE_COORDINATE,
+      name: i
+    });
+  }
+  // Core parsing utility functions
+  /**
+   * Returns a node that, if configured to do so, sets a "loc" field as a
+   * location object, used to identify the place in the source that created a
+   * given parsed object.
+   */
+  node(e, t) {
+    return this._options.noLocation !== !0 && (t.loc = new $e(
+      e,
+      this._lexer.lastToken,
+      this._lexer.source
+    )), t;
+  }
+  /**
+   * Determines if the next token is of a given kind
+   */
+  peek(e) {
+    return this._lexer.token.kind === e;
+  }
+  /**
+   * If the next token is of the given kind, return that token after advancing the lexer.
+   * Otherwise, do not change the parser state and throw an error.
+   */
+  expectToken(e) {
+    const t = this._lexer.token;
+    if (t.kind === e)
+      return this.advanceLexer(), t;
+    throw g(
+      this._lexer.source,
+      t.start,
+      `Expected ${he(e)}, found ${_(t)}.`
+    );
+  }
+  /**
+   * If the next token is of the given kind, return "true" after advancing the lexer.
+   * Otherwise, do not change the parser state and return "false".
+   */
+  expectOptionalToken(e) {
+    return this._lexer.token.kind === e ? (this.advanceLexer(), !0) : !1;
+  }
+  /**
+   * If the next token is a given keyword, advance the lexer.
+   * Otherwise, do not change the parser state and throw an error.
+   */
+  expectKeyword(e) {
+    const t = this._lexer.token;
+    if (t.kind === a.NAME && t.value === e)
+      this.advanceLexer();
+    else
+      throw g(
+        this._lexer.source,
+        t.start,
+        `Expected "${e}", found ${_(t)}.`
+      );
+  }
+  /**
+   * If the next token is a given keyword, return "true" after advancing the lexer.
+   * Otherwise, do not change the parser state and return "false".
+   */
+  expectOptionalKeyword(e) {
+    const t = this._lexer.token;
+    return t.kind === a.NAME && t.value === e ? (this.advanceLexer(), !0) : !1;
+  }
+  /**
+   * Helper function for creating an error when an unexpected lexed token is encountered.
+   */
+  unexpected(e) {
+    const t = e ?? this._lexer.token;
+    return g(
+      this._lexer.source,
+      t.start,
+      `Unexpected ${_(t)}.`
+    );
+  }
+  /**
+   * Returns a possibly empty list of parse nodes, determined by the parseFn.
+   * This list begins with a lex token of openKind and ends with a lex token of closeKind.
+   * Advances the parser to the next lex token after the closing token.
+   */
+  any(e, t, i) {
+    this.expectToken(e);
+    const n = [];
+    for (; !this.expectOptionalToken(i); )
+      n.push(t.call(this));
+    return n;
+  }
+  /**
+   * Returns a list of parse nodes, determined by the parseFn.
+   * It can be empty only if open token is missing otherwise it will always return non-empty list
+   * that begins with a lex token of openKind and ends with a lex token of closeKind.
+   * Advances the parser to the next lex token after the closing token.
+   */
+  optionalMany(e, t, i) {
+    if (this.expectOptionalToken(e)) {
+      const n = [];
+      do
+        n.push(t.call(this));
+      while (!this.expectOptionalToken(i));
+      return n;
+    }
+    return [];
+  }
+  /**
+   * Returns a non-empty list of parse nodes, determined by the parseFn.
+   * This list begins with a lex token of openKind and ends with a lex token of closeKind.
+   * Advances the parser to the next lex token after the closing token.
+   */
+  many(e, t, i) {
+    this.expectToken(e);
+    const n = [];
+    do
+      n.push(t.call(this));
+    while (!this.expectOptionalToken(i));
+    return n;
+  }
+  /**
+   * Returns a non-empty list of parse nodes, determined by the parseFn.
+   * This list may begin with a lex token of delimiterKind followed by items separated by lex tokens of tokenKind.
+   * Advances the parser to the next lex token after last item in the list.
+   */
+  delimitedMany(e, t) {
+    this.expectOptionalToken(e);
+    const i = [];
+    do
+      i.push(t.call(this));
+    while (this.expectOptionalToken(e));
+    return i;
+  }
+  advanceLexer() {
+    const { maxTokens: e } = this._options, t = this._lexer.advance();
+    if (t.kind !== a.EOF && (++this._tokenCounter, e !== void 0 && this._tokenCounter > e))
+      throw g(
+        this._lexer.source,
+        t.start,
+        `Document contains more that ${e} tokens. Parsing aborted.`
+      );
+  }
+}
+function _(r) {
+  const e = r.value;
+  return he(r.kind) + (e != null ? ` "${e}"` : "");
+}
+function he(r) {
+  return je(r) ? `"${r}"` : r;
+}
+var R = /* @__PURE__ */ new Map(), G = /* @__PURE__ */ new Map(), me = !0, w = !1;
+function ge(r) {
+  return r.replace(/[\s,]+/g, " ").trim();
+}
+function pt(r) {
+  return ge(r.source.body.substring(r.start, r.end));
+}
+function ht(r) {
+  var e = /* @__PURE__ */ new Set(), t = [];
+  return r.definitions.forEach(function(i) {
+    if (i.kind === "FragmentDefinition") {
+      var n = i.name.value, s = pt(i.loc), o = G.get(n);
+      o && !o.has(s) ? me && console.warn("Warning: fragment with name " + n + ` already exists.
+graphql-tag enforces all fragment names across your application to be unique; read more about
+this in the docs: http://dev.apollodata.com/core/fragments.html#unique-names`) : o || G.set(n, o = /* @__PURE__ */ new Set()), o.add(s), e.has(s) || (e.add(s), t.push(i));
+    } else
+      t.push(i);
+  }), F(F({}, r), { definitions: t });
+}
+function mt(r) {
+  var e = new Set(r.definitions);
+  e.forEach(function(i) {
+    i.loc && delete i.loc, Object.keys(i).forEach(function(n) {
+      var s = i[n];
+      s && typeof s == "object" && e.add(s);
+    });
+  });
+  var t = r.loc;
+  return t && (delete t.startToken, delete t.endToken), r;
+}
+function gt(r) {
+  var e = ge(r);
+  if (!R.has(e)) {
+    var t = ut(r, {
+      experimentalFragmentVariables: w,
+      allowLegacyFragmentVariables: w
+    });
+    if (!t || t.kind !== "Document")
+      throw new Error("Not a valid GraphQL document.");
+    R.set(e, mt(ht(t)));
+  }
+  return R.get(e);
+}
+function p(r) {
+  for (var e = [], t = 1; t < arguments.length; t++)
+    e[t - 1] = arguments[t];
+  typeof r == "string" && (r = [r]);
+  var i = r[0];
+  return e.forEach(function(n, s) {
+    n && n.kind === "Document" ? i += n.loc.source.body : i += n, i += r[s + 1];
+  }), gt(i);
+}
+function ft() {
+  R.clear(), G.clear();
+}
+function It() {
+  me = !1;
+}
+function Et() {
+  w = !0;
+}
+function yt() {
+  w = !1;
+}
+var b = {
+  gql: p,
+  resetCaches: ft,
+  disableFragmentWarnings: It,
+  enableExperimentalFragmentVariables: Et,
+  disableExperimentalFragmentVariables: yt
+};
+(function(r) {
+  r.gql = b.gql, r.resetCaches = b.resetCaches, r.disableFragmentWarnings = b.disableFragmentWarnings, r.enableExperimentalFragmentVariables = b.enableExperimentalFragmentVariables, r.disableExperimentalFragmentVariables = b.disableExperimentalFragmentVariables;
+})(p || (p = {}));
+p.default = p;
+const At = p`
+    query EventOverviewPage($organizationId: ID!, $hostingIds: [String!], $trackerId: String, $filterEventStatuses: [EventStatus!], $dateRange: DateRangeInput, $page: PageInput, $sorts: [SortInput!]) {
+  findAllPublicEventByOrganizationId(
+    id: $organizationId
+    hostingIds: $hostingIds
+    trackerLinkId: $trackerId
+    filterEventStatuses: $filterEventStatuses
+    date: $dateRange
+    page: $page
+    sorts: $sorts
+  ) {
+    data {
+      id
+      name
+      icon
+      banner
+      description
+      addonDescription
+      startSalesAt
+      endSalesAt
+      startAt
+      endAt
+      timezone
+      slug
+      status
+      location {
+        id
+        name
+        address
+      }
+      infoDescription
+    }
+    count
+  }
+}
+    `, Ot = p`
+    query EventDetailPage($eventId: ID!) {
+  findPublicEventById(id: $eventId) {
+    id
+    name
+    icon
+    banner
+    description
+    addonDescription
+    startAt
+    endAt
+    startSalesAt
+    endSalesAt
+    facebookPixelId
+    timezone
+    slug
+    status
+    location {
+      id
+      name
+      address
+    }
+    infoDescription
+    maxAmountOfTicketsPerOrder
+  }
+}
+    `, Tt = p`
+    query findProductsByEventId($eventId: ID!, $promoCode: String, $trackerId: String, $productTypes: [ProductType!]) {
+  findPublicProductsByEventId(
+    eventId: $eventId
+    promoCode: $promoCode
+    trackerLinkId: $trackerId
+    filterProductTypes: $productTypes
+  ) {
+    id
+    icon
+    name
+    description
+    currency
+    price
+    depositPrice
+    discountPrice
+    serviceFee
+    type
+    startSalesAt
+    endSalesAt
+    category {
+      id
+      name
+      description
+      order
+    }
+    status
+    maxAmountOfAddons
+    minAmountOfAddons
+    seatsCategory
+    maxAmountPerOrder
+    showEndSalesAtTag
+  }
+}
+    `, kt = (r, e, t, i) => r();
+function vt(r, e = kt) {
+  return {
+    EventOverviewPage(t, i, n) {
+      return e((s) => r.request({ document: At, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "EventOverviewPage", "query", t);
+    },
+    EventDetailPage(t, i, n) {
+      return e((s) => r.request({ document: Ot, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "EventDetailPage", "query", t);
+    },
+    findProductsByEventId(t, i, n) {
+      return e((s) => r.request({ document: Tt, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "findProductsByEventId", "query", t);
+    }
+  };
+}
+class fe {
+  config;
+  sdk;
+  constructor(e) {
+    this.config = e, this.sdk = vt(new C(e.apiUrl));
+  }
+  async fetchEvents(e = {}) {
+    try {
+      e.page && (e.page = {
+        index: e.page.index ?? 0,
+        size: e.page.size ?? 20
+      }), this.debugLog("Fetching events with parameters", {
+        organizationId: this.config.organizationId,
+        hostingIds: e.hostingIds,
+        filterEventStatuses: e.statuses,
+        dateRange: e.dateRange,
+        page: e.page,
+        sorts: e.sorts,
+        trackerId: this.config.trackerId
+      });
+      const t = await this.sdk.EventOverviewPage({
+        organizationId: this.config.organizationId,
+        hostingIds: e.hostingIds,
+        filterEventStatuses: e.statuses,
+        dateRange: e.dateRange && e.dateRange.from && e.dateRange.till ? {
+          from: e.dateRange.from.toISO(),
+          till: e.dateRange.till.toISO()
+        } : void 0,
+        page: e.page,
+        sorts: e.sorts,
+        trackerId: this.config.trackerId
+      });
+      if (this.debugLog("Raw GraphQL response", t), t?.findAllPublicEventByOrganizationId?.data) {
+        const i = t.findAllPublicEventByOrganizationId.data.map((n) => ({
+          id: n.id,
+          name: n.name,
+          icon: n.icon,
+          banner: n.banner,
+          description: n.description,
+          addonDescription: n.addonDescription,
+          startAt: y.fromISO(n.startAt, { zone: n.timezone }),
+          endAt: y.fromISO(n.endAt, { zone: n.timezone }),
+          timezone: n.timezone,
+          startSalesAt: null,
+          endSalesAt: null,
+          slug: n.slug ?? "ERROR",
+          facebookPixelId: null,
+          status: n.status,
+          location: n.location ? {
+            id: n.location.id,
+            name: n.location.name,
+            address: n.location.address
+          } : void 0,
+          infoDescription: n.infoDescription
+        }));
+        return this.debugLog("Processed events", { events: i, count: i.length }), [i, t.findAllPublicEventByOrganizationId.count ?? 0];
+      } else
+        return this.debugLog("No events found in response"), [[], 0];
+    } catch (t) {
+      throw this.debugLog("Error fetching events", t), t;
+    }
+  }
+  async fetchEvent(e) {
+    try {
+      this.debugLog("Fetching single event", { eventId: e });
+      const t = await this.sdk.EventDetailPage({ eventId: e });
+      if (this.debugLog("Raw GraphQL response", t), t?.findPublicEventById) {
+        const i = t.findPublicEventById, n = {
+          id: i.id,
+          name: i.name,
+          icon: i.icon,
+          banner: i.banner,
+          description: i.description,
+          addonDescription: i.addonDescription,
+          startAt: y.fromISO(i.startAt, { zone: i.timezone }),
+          endAt: y.fromISO(i.endAt, { zone: i.timezone }),
+          timezone: i.timezone,
+          startSalesAt: i.startSalesAt,
+          endSalesAt: i.endSalesAt,
+          slug: i.slug ?? "ERROR",
+          facebookPixelId: i.facebookPixelId,
+          status: i.status,
+          location: i.location ? {
+            id: i.location.id,
+            name: i.location.name,
+            address: i.location.address
+          } : void 0,
+          infoDescription: i.infoDescription
+        };
+        return this.debugLog("Processed single event", n), n;
+      } else {
+        this.debugLog("No event found for id", e);
+        return;
+      }
+    } catch (t) {
+      throw this.debugLog("Error fetching single event", t), t;
+    }
+  }
+  async fetchProducts(e, t, i) {
+    try {
+      this.debugLog("Fetching products for event", {
+        eventId: e,
+        promoCode: i,
+        trackerId: this.config.trackerId,
+        productTypes: t
+      });
+      const n = await this.sdk.findProductsByEventId({
+        eventId: e,
+        promoCode: i,
+        trackerId: this.config.trackerId,
+        productTypes: t
+      });
+      if (n?.findPublicProductsByEventId) {
+        const s = n.findPublicProductsByEventId.map((o) => ({
+          id: o.id,
+          name: o.name,
+          category: o.category ? {
+            id: o.category.id,
+            name: o.category.name,
+            description: o.category.description
+          } : void 0,
+          currency: o.currency,
+          depositPrice: o.depositPrice,
+          description: o.description,
+          discountPrice: o.discountPrice,
+          startSalesAt: o.startSalesAt,
+          endSalesAt: o.endSalesAt,
+          icon: o.icon,
+          maxAmountOfAddons: o.maxAmountOfAddons,
+          minAmountOfAddons: o.minAmountOfAddons,
+          maxAmountPerOrder: o.maxAmountPerOrder,
+          price: o.price,
+          serviceFee: o.serviceFee,
+          showEndSalesAtTag: o.showEndSalesAtTag,
+          status: o.status,
+          type: o.type
+        }));
+        return this.debugLog("Products fetched", {
+          eventId: e,
+          count: s.length,
+          types: s.map((o) => o.type)
+        }), s;
+      }
+      return;
+    } catch (n) {
+      throw this.debugLog("Error fetching products", { eventId: e, error: n }), n;
+    }
+  }
+  debugLog(e, t) {
+    this.config.debug && console.log(`[EventService:${this.config.organizationId}] ${e}`, t || "");
+  }
+}
+const Nt = p`
+    query findPaymentMethods($orderId: ID!, $orderItemId: String, $amountOfTickets: Int, $paymentMethodId: String) {
+  findPaymentDetails(
+    orderId: $orderId
+    orderItemId: $orderItemId
+    amountOfTickets: $amountOfTickets
+    paymentMethodId: $paymentMethodId
+  ) {
+    methods {
+      id
+      name
+      fee {
+        type
+        value
+      }
+      issuers {
+        id
+        name
+        image
+      }
+      image
+    }
+    transactionFee
+    transactionPrice
+    transactionDiscount
+    paymentSpesificTransactionFee
+  }
+}
+    `, xt = p`
+    mutation createDigitalPayment($input: CreateDigitalOrderPaymentInput!) {
+  createDigitalOrderPayment(input: $input)
+}
+    `, Dt = (r, e, t, i) => r();
+function bt(r, e = Dt) {
+  return {
+    findPaymentMethods(t, i, n) {
+      return e((s) => r.request({ document: Nt, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "findPaymentMethods", "query", t);
+    },
+    createDigitalPayment(t, i, n) {
+      return e((s) => r.request({ document: xt, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "createDigitalPayment", "mutation", t);
+    }
+  };
+}
+class Ie {
+  config;
+  sdk;
+  constructor(e) {
+    this.config = e, this.sdk = bt(new C(e.apiUrl));
+  }
+  async getPaymentDetails(e) {
+    this.debugLog("Fetching payment methods", e);
+    try {
+      const t = await this.sdk.findPaymentMethods({
+        orderId: e.orderId,
+        orderItemId: e.orderItemId,
+        amountOfTickets: e.amountOfTickets,
+        paymentMethodId: e.paymentMethodId
+      });
+      if (!t?.findPaymentDetails)
+        throw this.debugLog("No payment details found"), new Error("No payment details found for this order");
+      const i = t.findPaymentDetails;
+      return this.debugLog("Payment methods fetched successfully", {
+        methodCount: i.methods?.length ?? 0,
+        transactionPrice: i.transactionPrice,
+        transactionDiscount: i.transactionDiscount,
+        transactionFee: i.transactionFee,
+        paymentSpesificTransactionFee: i.paymentSpesificTransactionFee
+      }), {
+        transactionPrice: i.transactionPrice,
+        transactionDiscount: i.transactionPrice,
+        transactionFee: i.transactionFee ?? null,
+        paymentSpesificTransactionFee: i.paymentSpesificTransactionFee ?? null,
+        methods: i.methods?.map((n) => ({
+          id: n.id,
+          name: n.name,
+          image: n.image,
+          fee: n.fee ? {
+            type: n.fee.type,
+            value: n.fee.value
+          } : null,
+          issuers: n.issuers?.map((s) => ({
+            id: s.id,
+            name: s.name,
+            image: s.image
+          })) ?? null
+        })) ?? null
+      };
+    } catch (t) {
+      throw this.debugLog("Error fetching payment methods", t), t;
+    }
+  }
+  async createPayment(e) {
+    this.debugLog("Creating payment", e);
+    try {
+      const t = {
+        orderId: e.orderId,
+        paymentMethodId: e.paymentMethodId,
+        issuerId: e.issuerId,
+        redirectUrl: e.redirectUrl,
+        // For payment links this input in used
+        initiatedByUserId: e.initiatedByUserId,
+        initiatedByTeamId: e.initiatedByTeamId,
+        amountOfTickets: e.amountOfTickets,
+        orderItemId: e.orderItemId
+      };
+      e.customer && (t.customer = e.customer), e.products && (t.products = e.products), e.description && (t.description = e.description), e.reference && (t.reference = e.reference), e.ipAddress && (t.ipAddress = e.ipAddress);
+      const i = await this.sdk.createDigitalPayment({
+        input: t
+      });
+      if (!i?.createDigitalOrderPayment)
+        throw this.debugLog("Failed to create payment"), new Error("Failed to create payment for this order");
+      const n = i.createDigitalOrderPayment;
+      return this.debugLog("Payment created successfully", { paymentUrl: n }), { paymentUrl: n };
+    } catch (t) {
+      throw this.debugLog("Error creating payment", t), t;
+    }
+  }
+  debugLog(e, t) {
+    this.config.debug && console.log(`[PaymentService] ${e}`, t || "");
+  }
+}
+const Pt = p`
+    query findAllPublicPackagesByOrganizationId($organizationId: ID!) {
+  findAllPublicPackagesByOrganizationId(organizationId: $organizationId) {
+    data {
+      id
+      slug
+      status
+      name
+      description
+      shortTitle
+      shortDescription
+      icon
+      banner
+      currency
+      amountOfEvents
+      prices {
+        price
+        deposit
+        discount
+        serviceFee
+      }
+    }
+    count
+  }
+}
+    `, St = p`
+    query findPublicPackageById($packageId: ID!) {
+  findPublicPackageById(id: $packageId) {
+    id
+    slug
+    status
+    name
+    description
+    shortTitle
+    shortDescription
+    startAvailabilityAt
+    endAvailabilityAt
+    maxAmountOfPersonsPerOrder
+    icon
+    banner
+    currency
+    amountOfEvents
+    amountOfAddons
+    prices {
+      price
+      deposit
+      discount
+      serviceFee
+    }
+  }
+}
+    `, Ct = p`
+    query findPublicItemsByPackageId($packageId: ID!, $types: [PackageItemType!], $page: PageInput) {
+  findPublicItemsByPackageId(packageId: $packageId, types: $types, page: $page) {
+    data {
+      id
+      name
+      description
+      type
+      price
+      depositPrice
+      discountPrice
+      serviceFee
+      banner
+      package {
+        id
+        name
+      }
+      activeEvents {
+        id
+        name
+        startAt
+        endAt
+        timezone
+        icon
+        banner
+        location {
+          id
+          name
+          address
+        }
+      }
+    }
+    count
+  }
+}
+    `, _t = (r, e, t, i) => r();
+function Lt(r, e = _t) {
+  return {
+    findAllPublicPackagesByOrganizationId(t, i, n) {
+      return e((s) => r.request({ document: Pt, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "findAllPublicPackagesByOrganizationId", "query", t);
+    },
+    findPublicPackageById(t, i, n) {
+      return e((s) => r.request({ document: St, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "findPublicPackageById", "query", t);
+    },
+    findPublicItemsByPackageId(t, i, n) {
+      return e((s) => r.request({ document: Ct, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "findPublicItemsByPackageId", "query", t);
+    }
+  };
+}
+class Ee {
+  config;
+  sdk;
+  constructor(e) {
+    if (!e.organizationId)
+      throw new Error("organizationId is required for public package queries");
+    this.config = e, this.sdk = Lt(new C(e.apiUrl));
+  }
+  debugLog(e, t) {
+    this.config.debug && console.log(`[PackageService] ${e}`, t || "");
+  }
+  async getPackages(e = {}) {
+    try {
+      let t;
+      e.page && (t = {
+        index: e.page.index ?? 0,
+        size: e.page.size ?? 20
+      }), this.debugLog("Fetching public packages", {
+        organizationId: this.config.organizationId,
+        page: t,
+        tab: e.tab,
+        statuses: e.statuses
+      });
+      const i = await this.sdk.findAllPublicPackagesByOrganizationId({
+        organizationId: this.config.organizationId
+      });
+      if (i?.findAllPublicPackagesByOrganizationId) {
+        const n = i.findAllPublicPackagesByOrganizationId;
+        return this.debugLog("Public packages fetched", {
+          count: n.count,
+          dataLength: n.data.length
+        }), n;
+      }
+      return null;
+    } catch (t) {
+      throw this.debugLog("Error fetching public packages", t), t;
+    }
+  }
+  async getPackage(e) {
+    try {
+      this.debugLog("Fetching public packages", {
+        packageId: e
+      });
+      const t = await this.sdk.findPublicPackageById({ packageId: e });
+      if (t?.findPublicPackageById) {
+        const i = t.findPublicPackageById;
+        return this.debugLog("Public package fetched"), i;
+      }
+      return null;
+    } catch (t) {
+      throw this.debugLog("Error fetching public packages", t), t;
+    }
+  }
+  async getPackageItems(e, t = [B.Regular, B.AdditionalEvent]) {
+    try {
+      this.debugLog("Fetching public package items", { packageId: e, types: t });
+      const i = await this.sdk.findPublicItemsByPackageId({
+        packageId: e,
+        types: t,
+        page: { index: 0, size: 100 }
+      });
+      if (i?.findPublicItemsByPackageId) {
+        const n = i.findPublicItemsByPackageId;
+        return this.debugLog("Public package items fetched", {
+          count: n.count,
+          dataLength: n.data.length
+        }), n;
+      }
+      return null;
+    } catch (i) {
+      throw this.debugLog("Error fetching public package items", i), i;
+    }
+  }
+}
+const Rt = p`
+    query findAllPublicCategoriesByOrganizationId($organizationId: ID!) {
+  findAllPublicHostingsByOrganizationId(id: $organizationId) {
+    data {
+      id
+      name
+      icon
+    }
+    count
+  }
+}
+    `, Ft = p`
+    query findPublicCategoryById($hostingId: ID!) {
+  findPublicHostingById(id: $hostingId) {
+    id
+    name
+    icon
+  }
+}
+    `, wt = (r, e, t, i) => r();
+function Bt(r, e = wt) {
+  return {
+    findAllPublicCategoriesByOrganizationId(t, i, n) {
+      return e((s) => r.request({ document: Rt, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "findAllPublicCategoriesByOrganizationId", "query", t);
+    },
+    findPublicCategoryById(t, i, n) {
+      return e((s) => r.request({ document: Ft, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "findPublicCategoryById", "query", t);
+    }
+  };
+}
+class ye {
+  config;
+  sdk;
+  constructor(e) {
+    if (!e.organizationId)
+      throw new Error("organizationId is required for category queries");
+    this.config = e, this.sdk = Bt(new C(e.apiUrl));
+  }
+  debugLog(e, t) {
+    this.config.debug && console.log(`[CategoryService] ${e}`, t || "");
+  }
+  async getCategories() {
+    try {
+      this.debugLog("Fetching all categories", { organizationId: this.config.organizationId });
+      const e = await this.sdk.findAllPublicCategoriesByOrganizationId({ organizationId: this.config.organizationId });
+      if (e?.findAllPublicHostingsByOrganizationId) {
+        const t = e.findAllPublicHostingsByOrganizationId;
+        return this.debugLog("Categories fetched", { count: t.count, dataLength: t.data.length }), t.data.map((i) => ({ id: i.id, name: i.name, icon: i.icon }));
+      }
+      return [];
+    } catch (e) {
+      throw this.debugLog("Error fetching categories", e), e;
+    }
+  }
+  async getCategory(e) {
+    try {
+      this.debugLog("Fetching category", { categoryId: e });
+      const t = await this.sdk.findPublicCategoryById({ hostingId: e });
+      if (t?.findPublicHostingById) {
+        const i = t.findPublicHostingById;
+        return this.debugLog("Category fetched", i), { id: i.id, name: i.name, icon: i.icon };
+      }
+      return null;
+    } catch (t) {
+      throw this.debugLog("Error fetching category", t), t;
+    }
+  }
+}
+var k = /* @__PURE__ */ ((r) => (r.PACKAGE = "PACKAGE", r.PRODUCT = "PRODUCT", r.ADD_ONS = "ADD_ONS", r.DELIVERY = "DELIVERY", r.PICKUP = "PICKUP", r))(k || {}), B = /* @__PURE__ */ ((r) => (r.AdditionalEvent = "ADDITIONAL_EVENT", r.Addon = "ADDON", r.Regular = "REGULAR", r))(B || {}), Ae = /* @__PURE__ */ ((r) => (r.Active = "ACTIVE", r.Concept = "CONCEPT", r.Paused = "PAUSED", r.SoldOut = "SOLD_OUT", r))(Ae || {}), Oe = /* @__PURE__ */ ((r) => (r.Active = "ACTIVE", r.Inactive = "INACTIVE", r))(Oe || {}), Te = /* @__PURE__ */ ((r) => (r.Active = "ACTIVE", r.Inactive = "INACTIVE", r.Paused = "PAUSED", r.SoldOut = "SOLD_OUT", r))(Te || {}), ke = /* @__PURE__ */ ((r) => (r.Asc = "ASC", r.Desc = "DESC", r))(ke || {}), ve = /* @__PURE__ */ ((r) => (r.AllReserved = "ALL_RESERVED", r.Available = "AVAILABLE", r.SoldOut = "SOLD_OUT", r))(ve || {}), Ne = /* @__PURE__ */ ((r) => (r.Addon = "ADDON", r.Delivery = "DELIVERY", r.Door = "DOOR", r.Friend = "FRIEND", r.Guest = "GUEST", r.Pickup = "PICKUP", r.Promoter = "PROMOTER", r.Ticket = "TICKET", r))(Ne || {}), xe = /* @__PURE__ */ ((r) => (r.FIXED = "FIXED", r.PERCENTAGE = "PERCENTAGE", r))(xe || {});
+const $t = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BasketOrderType: k,
+  BasketService: be,
+  CategoryService: ye,
+  EventService: fe,
+  EventStatus: Te,
+  PackageItemType: B,
+  PackageService: Ee,
+  PackageStatus: Ae,
+  PackageTabType: Oe,
+  PaymentMethodFeeType: xe,
+  PaymentService: Ie,
+  ProductStatus: ve,
+  ProductType: Ne,
+  SortOrder: ke
+}, Symbol.toStringTag, { value: "Module" })), Ut = p`
+    query findActiveOrderById($id: String) {
+  findOrder(id: $id) {
+    id
+    soldAt
+    mainBooker {
+      firstName
+      lastName
+      email
+      age
+      gender
+      residence
+      extraInfo {
+        key
+        value
+      }
+    }
+    soldByUser {
+      id
+      firstName
+      lastName
+      avatar
+    }
+    organization {
+      id
+      name
+      paymentBanner
+    }
+    currency
+    items {
+      id
+      price
+      depositPrice
+      originalPrice
+      serviceFee
+      amount
+      amountPending
+      expiredAt
+      event {
+        id
+        name
+        startAt
+        endAt
+        timezone
+        icon
+        banner
+        location {
+          id
+          name
+          address
+        }
+      }
+      product {
+        id
+        name
+        icon
+        description
+        type
+        discountPrice
+      }
+      packageItem {
+        id
+        package {
+          id
+          name
+        }
+      }
+      seats {
+        id
+        label
+      }
+    }
+  }
+}
+    `, Mt = p`
+    mutation addToOrder($orderId: ID!, $productId: ID!, $shopId: ID, $additionalData: AdditionalDataInput, $trackerId: ID, $amount: Int) {
+  reserveProduct(
+    input: {orderId: $orderId, productId: $productId, additionalData: $additionalData, trackerId: $trackerId, shopId: $shopId, amountToIncrease: $amount}
+  ) {
+    orderId
+    expiredAt
+    amountReserved
+  }
+}
+    `, Vt = p`
+    mutation removeFromOrder($orderId: ID!, $productId: ID!, $additionalData: AdditionalDataInput, $amount: Int) {
+  releaseProduct(
+    input: {orderId: $orderId, productId: $productId, additionalData: $additionalData, amountToRelease: $amount}
+  ) {
+    orderId
+    amountReleased
+  }
+}
+    `, zt = p`
+    mutation configurePackage($orderId: ID!, $packageId: ID!, $amount: Int!, $items: [ReservedItem!]!, $shopId: ID, $trackerId: ID) {
+  configurePackage(
+    input: {orderId: $orderId, shopId: $shopId, trackerId: $trackerId, packageId: $packageId, amount: $amount, items: $items}
+  ) {
+    orderId
+    expiredAt
+    amountReserved
+  }
+}
+    `, qt = p`
+    mutation reserveAdditionalPackageItem($amount: Int!, $orderId: ID!, $packageId: ID!, $eventId: ID!, $packageItemId: ID!) {
+  reserveAdditionalPackageItem(
+    input: {amount: $amount, eventId: $eventId, orderId: $orderId, packageId: $packageId, packageItemId: $packageItemId}
+  ) {
+    orderId
+    expiredAt
+    amountReserved
+  }
+}
+    `, Gt = p`
+    mutation configureOrderDeliveryOption($orderId: ID!, $productId: ID) {
+  configureDeliveryOption(input: {orderId: $orderId, productId: $productId})
+}
+    `, jt = p`
+    mutation createOrderCustomer($orderId: ID!, $countryCode: String, $customer: CreateCustomerInput!) {
+  createOrderCustomer(
+    input: {id: $orderId, countryCode: $countryCode, customer: $customer}
+  )
+}
+    `, Yt = p`
+    mutation deleteOrder($orderId: ID!) {
+  cancelOrder(id: $orderId)
+}
+    `, Ht = (r, e, t, i) => r();
+function Qt(r, e = Ht) {
+  return {
+    findActiveOrderById(t, i, n) {
+      return e((s) => r.request({ document: Ut, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "findActiveOrderById", "query", t);
+    },
+    addToOrder(t, i, n) {
+      return e((s) => r.request({ document: Mt, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "addToOrder", "mutation", t);
+    },
+    removeFromOrder(t, i, n) {
+      return e((s) => r.request({ document: Vt, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "removeFromOrder", "mutation", t);
+    },
+    configurePackage(t, i, n) {
+      return e((s) => r.request({ document: zt, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "configurePackage", "mutation", t);
+    },
+    reserveAdditionalPackageItem(t, i, n) {
+      return e((s) => r.request({ document: qt, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "reserveAdditionalPackageItem", "mutation", t);
+    },
+    configureOrderDeliveryOption(t, i, n) {
+      return e((s) => r.request({ document: Gt, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "configureOrderDeliveryOption", "mutation", t);
+    },
+    createOrderCustomer(t, i, n) {
+      return e((s) => r.request({ document: jt, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "createOrderCustomer", "mutation", t);
+    },
+    deleteOrder(t, i, n) {
+      return e((s) => r.request({ document: Yt, variables: t, requestHeaders: { ...i, ...s }, signal: n }), "deleteOrder", "mutation", t);
+    }
+  };
+}
+const W = {
+  order: null,
+  processing: !1,
+  error: null
+}, De = Ce({
+  name: "basket",
+  initialState: W,
+  reducers: {
+    setProcessing: (r, e) => {
+      r.processing = e.payload;
+    },
+    setError: (r, e) => {
+      r.error = e.payload;
+    },
+    setOrder: (r, e) => {
+      r.order = e.payload;
+    },
+    initializeOrder: (r, e) => {
+      r.order || (r.order = {
+        id: e.payload.id,
+        currency: e.payload.currency,
+        items: [],
+        expiredAt: e.payload.expiredAt
+      });
+    },
+    addProduct: (r, e) => {
+      const { input: t, amountReserved: i, expiredAt: n } = e.payload;
+      if (!r.order)
+        return;
+      const s = r.order.items.findIndex((o) => t.seat ? o.id === t.id && o.seats?.some((u) => u.id === t.seat?.id) : o.id === t.id);
+      if (s >= 0)
+        r.order.items[s].amount += i;
+      else {
+        const o = {
+          id: t.id,
+          type: "PRODUCT",
+          name: t.name,
+          amount: i,
+          price: t.price,
+          depositPrice: t.depositPrice,
+          serviceFee: t.serviceFee,
+          originalPrice: t.price,
+          seats: t.seat ? [{ id: t.seat.id, label: t.seat.label }] : void 0
+        };
+        r.order.items.push(o);
+      }
+      r.order.expiredAt = n;
+    },
+    removeProduct: (r, e) => {
+      if (!r.order) return;
+      const { id: t, amountReleased: i, seatId: n } = e.payload, s = r.order.items.findIndex(
+        (o) => o.type === "PRODUCT" && o.id === t
+      );
+      if (s !== -1) {
+        const o = r.order.items[s];
+        if (o.amount -= i, o.amount <= 0)
+          r.order.items.splice(s, 1);
+        else if (o.seats && n) {
+          const u = o.seats.findIndex((l) => l.id === n);
+          u !== -1 && o.seats.splice(u, 1);
+        }
+      }
+      r.order.items.length === 0 && (r.order = null);
+    },
+    configurePackage: (r, e) => {
+      const { input: t, amountReserved: i, expiredAt: n } = e.payload;
+      r.order || (r.order = {
+        id: "",
+        currency: t.currency,
+        items: [],
+        expiredAt: n
+      });
+      const s = r.order.items.find(
+        (o) => o.type === "PACKAGE" && o.id === t.id
+      );
+      s ? (s.amount = i, s.packageItems = t.items) : r.order.items.push({
+        id: t.id,
+        type: "PACKAGE",
+        name: t.name,
+        amount: i,
+        price: t.discountPrice ?? t.price,
+        depositPrice: t.depositPrice,
+        originalPrice: t.price,
+        serviceFee: t.serviceFee,
+        packageItems: t.items
+      });
+    },
+    reserveAdditionalPackageItem: (r, e) => {
+      const { input: t, amountReserved: i, expiredAt: n } = e.payload;
+      r.order || (r.order = {
+        id: "",
+        currency: t.currency,
+        items: [],
+        expiredAt: n
+      });
+      const s = r.order.items.findIndex(
+        (u) => u.id === t.packageItemId
+      ), o = r.order.items[s];
+      o ? (o.amount = i, o.packageItems = [
+        {
+          packageItemId: t.packageItemId,
+          eventId: t.eventId,
+          name: t.name,
+          startAt: t.startAt,
+          endAt: t.endAt
+        }
+      ], o.amount === 0 && r.order.items.splice(s, 1)) : r.order.items.push({
+        id: t.packageItemId,
+        type: k.ADD_ONS,
+        name: t.name,
+        amount: i,
+        price: t.discountPrice ?? t.price,
+        depositPrice: t.depositPrice,
+        originalPrice: t.price,
+        serviceFee: t.serviceFee,
+        packageItems: [
+          {
+            packageItemId: t.packageItemId,
+            eventId: t.eventId,
+            name: t.name,
+            startAt: t.startAt,
+            endAt: t.endAt
+          }
+        ]
+      });
+    },
+    configureDelivery: (r, e) => {
+      if (!r.order) return;
+      const t = e.payload, i = r.order.items.findIndex(
+        (n) => n.type === "DELIVERY"
+      );
+      if (t)
+        if (i !== -1) {
+          const n = r.order.items[i];
+          n.id = t.id, n.name = t.name, n.price = t.price, n.serviceFee = t.serviceFee;
+        } else
+          r.order.items.push({
+            id: t.id,
+            type: "PRODUCT",
+            name: t.name,
+            amount: 1,
+            price: t.price,
+            originalPrice: t.price,
+            serviceFee: t.serviceFee
+          });
+      else i !== -1 && r.order.items.splice(i, 1);
+    },
+    configureCustomer: (r, e) => {
+      r.order && (r.order.customer = e.payload);
+    },
+    clearBasket: () => W
+  }
+}), {
+  setProcessing: T,
+  initializeOrder: L,
+  addProduct: Z,
+  removeProduct: Jt,
+  configurePackage: ee,
+  configureDelivery: Xt,
+  configureCustomer: te,
+  reserveAdditionalPackageItem: Kt,
+  clearBasket: re
+} = De.actions;
+class be {
+  orderIdKey = "ORDER_ID";
+  config;
+  sdk;
+  store;
+  constructor(e) {
+    this.config = e, this.store = _e({
+      reducer: {
+        basket: De.reducer
+      }
+    }), this.sdk = Qt(new C(e.apiUrl)), this.restoreOrderFromSession().then(() => {
+      this.debugLog("Restore order from session");
+    });
+  }
+  // Store functions
+  subscribe(e) {
+    return this.store.subscribe(e);
+  }
+  getCurrentOrder() {
+    const e = this.getState();
+    if (!e.order)
+      return null;
+    const t = e.order.items.reduce((i, n) => i + (n.amount || 0), 0);
+    return {
+      ...e.order,
+      count: t
+    };
+  }
+  getSelectedPackageEvent() {
+    return this.getState().order?.items.flatMap((t) => t.packageItems?.map((i) => i.eventId) ?? []) ?? [];
+  }
+  // Basket update functions
+  async addProduct(e) {
+    this.store.dispatch(T(!0));
+    try {
+      const i = this.getState().order?.id ?? sessionStorage.getItem(this.orderIdKey) ?? this.generateOrderId();
+      this.debugLog("Adding product", {
+        productId: e.id,
+        orderId: i,
+        amount: e.amount,
+        seat: e.seat
+      });
+      const n = await this.sdk.addToOrder({
+        productId: e.id,
+        orderId: i,
+        additionalData: e.seat ? {
+          seat: {
+            seatId: e.seat.id,
+            seatLabel: e.seat.label,
+            holdToken: e.seat.holdToken
+          }
+        } : null,
+        trackerId: this.config.trackerId,
+        shopId: this.config.shopId,
+        amount: e.amount
+      });
+      if (n?.reserveProduct) {
+        const { orderId: s, expiredAt: o, amountReserved: u } = n.reserveProduct;
+        this.debugLog("Product added successfully", n.reserveProduct), sessionStorage.setItem(this.orderIdKey, i), this.store.dispatch(
+          L({
+            id: s,
+            currency: e.currency,
+            expiredAt: o ? y.fromISO(o) : void 0
+          })
+        ), this.store.dispatch(
+          Z({
+            input: e,
+            amountReserved: u,
+            expiredAt: o ? y.fromISO(o) : void 0
+          })
+        );
+      }
+    } catch (t) {
+      throw this.debugLog("Error adding product", t), this.handleError(t), t;
+    } finally {
+      this.store.dispatch(T(!1));
+    }
+  }
+  async removeProduct(e) {
+    const i = this.getState().order;
+    if (i) {
+      this.store.dispatch(T(!0));
+      try {
+        this.debugLog("Removing product", {
+          productId: e.id,
+          orderId: i.id,
+          amount: e.amount
+        });
+        const n = await this.sdk.removeFromOrder({
+          productId: e.id,
+          orderId: i.id,
+          additionalData: e.seat ? {
+            seat: {
+              seatId: e.seat.id,
+              seatLabel: e.seat.label
+            }
+          } : null,
+          amount: e.amount
+        });
+        if (n?.releaseProduct) {
+          const { amountReleased: s } = n.releaseProduct;
+          this.debugLog("Product removed successfully", n.releaseProduct), this.store.dispatch(
+            Jt({
+              id: e.id,
+              amountReleased: s,
+              seatId: e.seat?.id
+            })
+          );
+          const o = this.getState();
+          (!o.order || o.order.items.length === 0) && (this.debugLog("Basket is now empty, cancelling order and clearing session"), await this.cancelOrder());
+        }
+      } catch (n) {
+        throw this.debugLog("Error removing product", n), this.handleError(n), n;
+      } finally {
+        this.store.dispatch(T(!1));
+      }
+    }
+  }
+  async configurePackage(e) {
+    this.store.dispatch(T(!0));
+    try {
+      const i = this.store.getState().basket.order?.id ?? sessionStorage.getItem(this.orderIdKey) ?? this.generateOrderId(), n = e.items.map((o) => ({
+        packageItemId: o.packageItemId,
+        eventId: o.eventId
+      }));
+      this.debugLog("Configuring package", {
+        packageId: e.id,
+        orderId: i,
+        amount: e.amount,
+        items: n,
+        shopId: this.config.shopId
+      });
+      const s = await this.sdk.configurePackage({
+        trackerId: this.config.trackerId,
+        shopId: this.config.shopId,
+        packageId: e.id,
+        orderId: i,
+        amount: e.amount,
+        items: n
+      });
+      if (this.debugLog("Configure package response", s), s?.configurePackage && s.configurePackage.amountReserved > 0) {
+        const { orderId: o, expiredAt: u, amountReserved: l } = s.configurePackage;
+        return this.debugLog("Package configured successfully"), sessionStorage.setItem(this.orderIdKey, i), this.store.dispatch(
+          L({
+            id: o,
+            currency: e.currency,
+            expiredAt: u ? y.fromISO(u) : void 0
+          })
+        ), this.store.dispatch(
+          ee({
+            input: e,
+            amountReserved: l,
+            expiredAt: u ? y.fromISO(u) : void 0
+          })
+        ), null;
+      } else
+        return this.debugLog("Package configuration failed - no amount reserved"), { error: "Failed to configure package - no items reserved" };
+    } catch (t) {
+      return this.debugLog("Error configuring package", t), this.handleError(t), { error: t };
+    } finally {
+      this.store.dispatch(T(!1));
+    }
+  }
+  async configureDelivery(e) {
+    this.store.dispatch(T(!0));
+    try {
+      this.store.dispatch(Xt(e));
+    } catch (t) {
+      throw this.debugLog("Error setting delivery", t), this.handleError(t), t;
+    } finally {
+      this.store.dispatch(T(!1));
+    }
+  }
+  async configureCustomer(e) {
+    const i = this.getState().order;
+    if (!i)
+      throw new Error("No active order. Add items to basket first.");
+    this.debugLog("Creating/replacing customer", { orderId: i.id, email: e.email });
+    try {
+      const n = await this.sdk.createOrderCustomer({
+        orderId: i.id,
+        customer: e
+      });
+      this.debugLog("Customer set successfully", n), this.store.dispatch(te(e));
+    } catch (n) {
+      throw this.debugLog("Failed to set customer", n), new Error(`Failed to set customer: ${n.message}`);
+    }
+  }
+  async reserveAdditionalPackageItem(e) {
+    this.store.dispatch(T(!0));
+    try {
+      const i = this.store.getState().basket.order?.id ?? sessionStorage.getItem(this.orderIdKey) ?? this.generateOrderId();
+      this.debugLog("reserve additional packageItem", {
+        orderId: i,
+        eventId: e.eventId,
+        amount: e.amount,
+        packageId: e.packageId,
+        packageItemId: e.packageItemId
+      });
+      const n = await this.sdk.reserveAdditionalPackageItem({
+        orderId: i,
+        eventId: e.eventId,
+        amount: e.amount,
+        packageId: e.packageId,
+        packageItemId: e.packageItemId
+      });
+      if (this.debugLog("reserve additional packageItem", n), n?.reserveAdditionalPackageItem && n.reserveAdditionalPackageItem.amountReserved > 0) {
+        const { orderId: s, expiredAt: o, amountReserved: u } = n.reserveAdditionalPackageItem;
+        return this.debugLog("Reserve configured successfully"), sessionStorage.setItem(this.orderIdKey, i), this.store.dispatch(
+          L({
+            id: s,
+            currency: e.currency,
+            expiredAt: o ? y.fromISO(o) : void 0
+          })
+        ), this.store.dispatch(
+          Kt({
+            input: e,
+            amountReserved: u,
+            expiredAt: o ? y.fromISO(o) : void 0
+          })
+        ), null;
+      } else
+        return this.debugLog("Package configuration failed - no amount reserved"), { error: "Failed to configure package - no items reserved" };
+    } catch (t) {
+      return this.debugLog("Error configuring package", t), this.handleError(t), { error: t };
+    } finally {
+      this.store.dispatch(T(!1));
+    }
+  }
+  // Cancel and clear order functions
+  async cancelOrder() {
+    const e = sessionStorage.getItem(this.orderIdKey);
+    e && (this.debugLog("Cancelling order", { orderId: e }), await this.sdk.deleteOrder({ orderId: e }), this.clearOrderFromSession(), this.debugLog("Order cancelled successfully"));
+  }
+  clearOrderFromSession() {
+    this.debugLog("Clearing order from session"), sessionStorage.removeItem(this.orderIdKey), this.store.dispatch(re());
+  }
+  // Private functions for fetching the current order from a session
+  async restoreOrderFromSession() {
+    const e = sessionStorage.getItem(this.orderIdKey);
+    if (e) {
+      this.debugLog("Found existing order ID in session, restoring...", { orderId: e });
+      try {
+        await this.fetchOrder(e), this.debugLog("Order restored successfully");
+      } catch (t) {
+        this.debugLog("Failed to restore order, clearing session", t), this.clearOrderFromSession();
+      }
+    }
+  }
+  async fetchOrder(e) {
+    this.debugLog("Fetching order from server", { orderId: e });
+    try {
+      const t = await this.sdk.findActiveOrderById({ id: e });
+      if (!t?.findOrder) {
+        this.debugLog("Order not found"), this.clearOrderFromSession();
+        return;
+      }
+      const i = t.findOrder;
+      this.debugLog("Order fetched successfully", i);
+      const n = i.items, s = n.filter((c) => c.product != null && c.amount > 0).map((c) => {
+        let E = k.PRODUCT;
+        return c.product.type === "PROMOTER" ? E = k.ADD_ONS : c.product.type === "PICKUP" ? E = k.PICKUP : c.product.type === "DELIVERY" && (E = k.DELIVERY), {
+          id: c.product.id,
+          type: E,
+          name: c.product.name,
+          icon: c.product.icon,
+          description: c.product.description,
+          amount: c.amount,
+          price: c.price ?? 0,
+          depositPrice: c.depositPrice ?? 0,
+          originalPrice: c.originalPrice ?? 0,
+          serviceFee: c.serviceFee ?? 0,
+          seats: c.seats?.map((m) => ({
+            id: m.id,
+            label: m.label
+          }))
+        };
+      }), o = n.filter((c) => c.packageItem != null && c.amount > 0).reduce((c, E) => {
+        const {
+          packageItem: m,
+          event: O,
+          amount: I,
+          price: A,
+          serviceFee: Y,
+          depositPrice: H,
+          originalPrice: Q
+        } = E, v = m.package.id;
+        c[v] ? (c[v].price += A ?? 0, c[v].serviceFee += Y ?? 0, c[v].originalPrice += Q ?? 0, c[v].depositPrice += H ?? A ?? 0) : c[v] = {
+          id: v,
+          type: k.PACKAGE,
+          name: m.package.name,
+          amount: I,
+          price: A ?? 0,
+          serviceFee: Y ?? 0,
+          depositPrice: H ?? A ?? 0,
+          originalPrice: Q ?? 0,
+          packageItems: []
+        };
+        const Pe = y.fromISO(O.startAt, {
+          zone: O.timezone
+        }), Se = y.fromISO(O.endAt, {
+          zone: O.timezone
+        });
+        return c[v].packageItems.push({
+          packageItemId: m.id,
+          eventId: O.id,
+          name: O.name,
+          startAt: Pe,
+          endAt: Se
+        }), c;
+      }, {}), u = [
+        ...s,
+        ...Object.values(o)
+      ];
+      if (u.length === 0) {
+        this.debugLog("All order items have zero or negative amounts, clearing session"), this.clearOrderFromSession();
+        return;
+      }
+      const l = n.filter((c) => c.amount > 0).map((c) => new Date(c.expiredAt).getTime());
+      if (l.length === 0) {
+        this.debugLog("No valid items with expiration times, clearing session"), this.clearOrderFromSession();
+        return;
+      }
+      const f = y.fromMillis(Math.min(...l));
+      this.store.dispatch(re()), this.store.dispatch(
+        L({
+          id: i.id,
+          currency: i.currency,
+          expiredAt: f
+        })
+      ), u.forEach((c) => {
+        c.type === k.PACKAGE ? this.store.dispatch(
+          ee({
+            input: {
+              id: c.id,
+              name: c.name,
+              currency: i.currency,
+              price: c.originalPrice ?? 0,
+              depositPrice: c.depositPrice,
+              serviceFee: c.serviceFee ?? 0,
+              amount: c.amount,
+              items: c.packageItems || []
+            },
+            amountReserved: c.amount,
+            expiredAt: f
+          })
+        ) : this.store.dispatch(
+          Z({
+            input: {
+              id: c.id,
+              name: c.name,
+              price: c.originalPrice,
+              depositPrice: c.depositPrice,
+              serviceFee: c.serviceFee,
+              currency: i.currency,
+              amount: c.amount
+            },
+            amountReserved: c.amount,
+            expiredAt: f
+          })
+        );
+      }), i.mainBooker && (this.debugLog("Order has customer (mainBooker)", i.mainBooker), this.store.dispatch(
+        te({
+          firstName: i.mainBooker.firstName ?? void 0,
+          lastName: i.mainBooker.lastName ?? void 0,
+          email: i.mainBooker.email ?? void 0,
+          age: i.mainBooker.age ?? void 0
+        })
+      )), this.debugLog("Order state fully synced", this.getState());
+    } catch (t) {
+      throw this.debugLog("Error fetching order", t), t;
+    }
+  }
+  // Private helper functions
+  generateOrderId() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (e) => {
+      const t = Math.random() * 16 | 0;
+      return (e === "x" ? t : t & 3 | 8).toString(16);
+    });
+  }
+  debugLog(e, t) {
+    this.config.debug && console.log(`[BasketService] ${e}`, t || "");
+  }
+  handleError(e) {
+    const t = e;
+    if (t.graphQLErrors && t.graphQLErrors.length > 0) {
+      const i = t.graphQLErrors[0];
+      i.extensions?.status === "RATE_LIMIT" && console.error("Rate Limit reached"), i.extensions?.status === "SOLD_OUT" && console.error("Product sold out");
+    }
+    if (t.response?.errors && t.response.errors.length > 0) {
+      const i = t.response.errors[0];
+      console.error("GraphQL Error:", i.message), i.extensions?.code && console.error("Error Code:", i.extensions.code);
+    }
+  }
+  getState() {
+    return this.store.getState().basket;
+  }
+}
+const Wt = "https://api.ticketapp.com/graphql", ne = "TIC_TRACKER_ID";
+class rr {
+  basket;
+  event;
+  payment;
+  package;
+  category;
+  // Attach selected public types to the SDK class
+  static Types = $t;
+  constructor(e) {
+    const { organizationId: t, debug: i = !1, apiUrl: n = Wt } = e, s = this.getOrInitTrackerId();
+    this.basket = new be({ debug: i, apiUrl: n, shopId: e.shopId, trackerId: s }), this.event = new fe({ organizationId: t, debug: i, apiUrl: n, trackerId: s }), this.payment = new Ie({ debug: i, apiUrl: n }), this.package = new Ee({ organizationId: t, debug: i, apiUrl: n }), this.category = new ye({ organizationId: t, debug: i, apiUrl: n });
+  }
+  // Resolve tracker id from (in order): explicit config, URL query, or session storage
+  // Persist to session when found via config or URL for subsequent page loads
+  getOrInitTrackerId() {
+    try {
+      let e = null, t = null;
+      if (typeof window < "u") {
+        try {
+          t = new URL(window.location.href).searchParams.get("trackerId");
+        } catch {
+        }
+        try {
+          e = window.sessionStorage?.getItem(ne) ?? null;
+        } catch {
+        }
+      }
+      if (t && t.trim().length > 0) {
+        try {
+          typeof window < "u" && window.sessionStorage && sessionStorage.setItem(ne, t);
+        } catch {
+        }
+        return t;
+      }
+      return e && e.trim().length > 0 ? e : void 0;
+    } catch {
+      return;
+    }
+  }
+}
+export {
+  k as BasketOrderType,
+  be as BasketService,
+  ye as CategoryService,
+  fe as EventService,
+  Te as EventStatus,
+  B as PackageItemType,
+  Ee as PackageService,
+  Ae as PackageStatus,
+  Oe as PackageTabType,
+  xe as PaymentMethodFeeType,
+  Ie as PaymentService,
+  ve as ProductStatus,
+  Ne as ProductType,
+  ke as SortOrder,
+  rr as TicketappSDK
+};