@debugged-development/ticketapp-sdk 0.0.3

package/dist/index.js

@@ -0,0 +1,3141 @@
+import { GraphQLClient as j } from "graphql-request";
+import { createSlice as ae, configureStore as ce } from "@reduxjs/toolkit";
+import { DateTime as x } from "luxon";
+const J = {
+  order: null,
+  processing: !1,
+  error: null
+}, de = ae({
+  name: "basket",
+  initialState: J,
+  reducers: {
+    setProcessing: (t, e) => {
+      t.processing = e.payload;
+    },
+    setError: (t, e) => {
+      t.error = e.payload;
+    },
+    setOrder: (t, e) => {
+      t.order = e.payload;
+    },
+    initializeOrder: (t, e) => {
+      t.order || (t.order = {
+        id: e.payload.id,
+        currency: e.payload.currency,
+        items: [],
+        expiredAt: x.fromISO(e.payload.expiredAt)
+      });
+    },
+    addProductToOrder: (t, e) => {
+      const { input: r, amountReserved: s, expiredAt: n } = e.payload;
+      if (!t.order)
+        return;
+      const i = t.order.items.findIndex((a) => r.seat ? a.id === r.id && a.seats?.some((u) => u.id === r.seat?.id) : a.id === r.id);
+      if (i >= 0)
+        t.order.items[i].amount += s;
+      else {
+        const a = {
+          id: r.id,
+          type: "PRODUCT",
+          name: r.name,
+          amount: s,
+          price: r.price,
+          depositPrice: r.depositPrice,
+          serviceFee: r.serviceFee,
+          originalPrice: r.price,
+          seats: r.seat ? [{ id: r.seat.id, label: r.seat.label }] : void 0
+        };
+        t.order.items.push(a);
+      }
+      t.order.expiredAt = x.fromISO(n);
+    },
+    removeProductFromOrder: (t, e) => {
+      if (!t.order) return;
+      const { id: r, amountReleased: s, seatId: n } = e.payload, i = t.order.items.findIndex(
+        (a) => a.type === "PRODUCT" && a.id === r
+      );
+      if (i !== -1) {
+        const a = t.order.items[i];
+        if (a.amount -= s, a.amount <= 0)
+          t.order.items.splice(i, 1);
+        else if (a.seats && n) {
+          const u = a.seats.findIndex((l) => l.id === n);
+          u !== -1 && a.seats.splice(u, 1);
+        }
+      }
+      t.order.items.length === 0 && (t.order = null);
+    },
+    setPackageInOrder: (t, e) => {
+      const { input: r, amountReserved: s, expiredAt: n } = e.payload;
+      t.order || (t.order = {
+        id: "",
+        currency: r.currency,
+        items: [],
+        expiredAt: x.fromISO(n)
+      });
+      const i = t.order.items.find(
+        (a) => a.type === "PACKAGE" && a.id === r.id
+      );
+      i ? (i.amount = s, i.packageItems = r.items) : t.order.items.push({
+        id: r.id,
+        type: "PACKAGE",
+        name: r.name,
+        amount: s,
+        price: r.discountPrice ?? r.price,
+        depositPrice: r.depositPrice,
+        originalPrice: r.price,
+        serviceFee: r.serviceFee,
+        packageItems: r.items
+      });
+    },
+    setDeliveryOption: (t, e) => {
+      if (!t.order) return;
+      const r = e.payload, s = t.order.items.findIndex(
+        (n) => n.type === "DELIVERY"
+      );
+      if (r)
+        if (s !== -1) {
+          const n = t.order.items[s];
+          n.id = r.id, n.name = r.name, n.price = r.price, n.serviceFee = r.serviceFee;
+        } else
+          t.order.items.push({
+            id: r.id,
+            type: "PRODUCT",
+            name: r.name,
+            amount: 1,
+            price: r.price,
+            originalPrice: r.price,
+            serviceFee: r.serviceFee
+          });
+      else s !== -1 && t.order.items.splice(s, 1);
+    },
+    setCustomer: (t, e) => {
+      t.order && (t.order.customer = e.payload);
+    },
+    clearBasket: () => J
+  }
+}), {
+  setProcessing: N,
+  setError: Ut,
+  setOrder: Mt,
+  initializeOrder: $,
+  addProductToOrder: X,
+  removeProductFromOrder: Ae,
+  setPackageInOrder: K,
+  setDeliveryOption: De,
+  setCustomer: W,
+  clearBasket: Z
+} = de.actions, ke = de.reducer, ee = {
+  events: [],
+  processing: !1,
+  error: null,
+  loadingProducts: {}
+}, ue = ae({
+  name: "event",
+  initialState: ee,
+  reducers: {
+    setProcessing: (t, e) => {
+      t.processing = e.payload;
+    },
+    setError: (t, e) => {
+      t.error = e.payload;
+    },
+    setEvents: (t, e) => {
+      t.events = e.payload;
+    },
+    setEventProducts: (t, e) => {
+      const r = t.events.find((s) => s.id === e.payload.eventId);
+      r && (r.products = e.payload.products);
+    },
+    setLoadingProducts: (t, e) => {
+      t.loadingProducts[e.payload.eventId] = e.payload.loading;
+    },
+    clearEvents: () => ee
+  }
+}), {
+  setProcessing: te,
+  setError: Se,
+  setEvents: re,
+  setEventProducts: be,
+  setLoadingProducts: ne,
+  clearEvents: _e
+} = ue.actions, Ce = ue.reducer;
+var L = function() {
+  return L = Object.assign || function(e) {
+    for (var r, s = 1, n = arguments.length; s < n; s++) {
+      r = arguments[s];
+      for (var i in r) Object.prototype.hasOwnProperty.call(r, i) && (e[i] = r[i]);
+    }
+    return e;
+  }, L.apply(this, arguments);
+};
+function B(t, e) {
+  if (!!!t)
+    throw new Error(e);
+}
+function Pe(t) {
+  return typeof t == "object" && t !== null;
+}
+function Le(t, e) {
+  if (!!!t)
+    throw new Error(
+      "Unexpected invariant triggered."
+    );
+}
+const Fe = /\r\n|[\n\r]/g;
+function M(t, e) {
+  let r = 0, s = 1;
+  for (const n of t.body.matchAll(Fe)) {
+    if (typeof n.index == "number" || Le(!1), n.index >= e)
+      break;
+    r = n.index + n[0].length, s += 1;
+  }
+  return {
+    line: s,
+    column: e + 1 - r
+  };
+}
+function Re(t) {
+  return le(
+    t.source,
+    M(t.source, t.start)
+  );
+}
+function le(t, e) {
+  const r = t.locationOffset.column - 1, s = "".padStart(r) + t.body, n = e.line - 1, i = t.locationOffset.line - 1, a = e.line + i, u = e.line === 1 ? r : 0, l = e.column + u, p = `${t.name}:${a}:${l}
+`, c = s.split(/\r\n|[\n\r]/g), E = c[n];
+  if (E.length > 120) {
+    const f = Math.floor(l / 80), T = l % 80, g = [];
+    for (let y = 0; y < E.length; y += 80)
+      g.push(E.slice(y, y + 80));
+    return p + se([
+      [`${a} |`, g[0]],
+      ...g.slice(1, f + 1).map((y) => ["|", y]),
+      ["|", "^".padStart(T)],
+      ["|", g[f + 1]]
+    ]);
+  }
+  return p + se([
+    // Lines specified like this: ["prefix", "string"],
+    [`${a - 1} |`, c[n - 1]],
+    [`${a} |`, E],
+    ["|", "^".padStart(l)],
+    [`${a + 1} |`, c[n + 1]]
+  ]);
+}
+function se(t) {
+  const e = t.filter(([s, n]) => n !== void 0), r = Math.max(...e.map(([s]) => s.length));
+  return e.map(([s, n]) => s.padStart(r) + (n ? " " + n : "")).join(`
+`);
+}
+function we(t) {
+  const e = t[0];
+  return e == null || "kind" in e || "length" in e ? {
+    nodes: e,
+    source: t[1],
+    positions: t[2],
+    path: t[3],
+    originalError: t[4],
+    extensions: t[5]
+  } : e;
+}
+class q 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, ...r) {
+    var s, n, i;
+    const { nodes: a, source: u, positions: l, path: p, originalError: c, extensions: E } = we(r);
+    super(e), this.name = "GraphQLError", this.path = p ?? void 0, this.originalError = c ?? void 0, this.nodes = ie(
+      Array.isArray(a) ? a : a ? [a] : void 0
+    );
+    const f = ie(
+      (s = this.nodes) === null || s === void 0 ? void 0 : s.map((g) => g.loc).filter((g) => g != null)
+    );
+    this.source = u ?? (f == null || (n = f[0]) === null || n === void 0 ? void 0 : n.source), this.positions = l ?? f?.map((g) => g.start), this.locations = l && u ? l.map((g) => M(u, g)) : f?.map((g) => M(g.source, g.start));
+    const T = Pe(
+      c?.extensions
+    ) ? c?.extensions : void 0;
+    this.extensions = (i = E ?? T) !== null && i !== void 0 ? i : /* @__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, q) : 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 r of this.nodes)
+        r.loc && (e += `
+
+` + Re(r.loc));
+    else if (this.source && this.locations)
+      for (const r of this.locations)
+        e += `
+
+` + le(this.source, r);
+    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 ie(t) {
+  return t === void 0 || t.length === 0 ? void 0 : t;
+}
+function m(t, e, r) {
+  return new q(`Syntax Error: ${r}`, {
+    source: t,
+    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, r, s) {
+    this.start = e.start, this.end = r.end, this.startToken = e, this.endToken = r, this.source = s;
+  }
+  get [Symbol.toStringTag]() {
+    return "Location";
+  }
+  toJSON() {
+    return {
+      start: this.start,
+      end: this.end
+    };
+  }
+}
+class he {
+  /**
+   * 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, r, s, n, i, a) {
+    this.kind = e, this.start = r, this.end = s, this.line = n, this.column = i, this.value = a, this.prev = null, this.next = null;
+  }
+  get [Symbol.toStringTag]() {
+    return "Token";
+  }
+  toJSON() {
+    return {
+      kind: this.kind,
+      value: this.value,
+      line: this.line,
+      column: this.column
+    };
+  }
+}
+const Be = {
+  Name: [],
+  Document: ["definitions"],
+  OperationDefinition: [
+    "name",
+    "variableDefinitions",
+    "directives",
+    "selectionSet"
+  ],
+  VariableDefinition: ["variable", "type", "defaultValue", "directives"],
+  Variable: ["name"],
+  SelectionSet: ["selections"],
+  Field: ["alias", "name", "arguments", "directives", "selectionSet"],
+  Argument: ["name", "value"],
+  FragmentSpread: ["name", "directives"],
+  InlineFragment: ["typeCondition", "directives", "selectionSet"],
+  FragmentDefinition: [
+    "name",
+    // 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"]
+};
+new Set(Object.keys(Be));
+var D;
+(function(t) {
+  t.QUERY = "query", t.MUTATION = "mutation", t.SUBSCRIPTION = "subscription";
+})(D || (D = {}));
+var V;
+(function(t) {
+  t.QUERY = "QUERY", t.MUTATION = "MUTATION", t.SUBSCRIPTION = "SUBSCRIPTION", t.FIELD = "FIELD", t.FRAGMENT_DEFINITION = "FRAGMENT_DEFINITION", t.FRAGMENT_SPREAD = "FRAGMENT_SPREAD", t.INLINE_FRAGMENT = "INLINE_FRAGMENT", t.VARIABLE_DEFINITION = "VARIABLE_DEFINITION", t.SCHEMA = "SCHEMA", t.SCALAR = "SCALAR", t.OBJECT = "OBJECT", t.FIELD_DEFINITION = "FIELD_DEFINITION", t.ARGUMENT_DEFINITION = "ARGUMENT_DEFINITION", t.INTERFACE = "INTERFACE", t.UNION = "UNION", t.ENUM = "ENUM", t.ENUM_VALUE = "ENUM_VALUE", t.INPUT_OBJECT = "INPUT_OBJECT", t.INPUT_FIELD_DEFINITION = "INPUT_FIELD_DEFINITION";
+})(V || (V = {}));
+var d;
+(function(t) {
+  t.NAME = "Name", t.DOCUMENT = "Document", t.OPERATION_DEFINITION = "OperationDefinition", t.VARIABLE_DEFINITION = "VariableDefinition", t.SELECTION_SET = "SelectionSet", t.FIELD = "Field", t.ARGUMENT = "Argument", t.FRAGMENT_SPREAD = "FragmentSpread", t.INLINE_FRAGMENT = "InlineFragment", t.FRAGMENT_DEFINITION = "FragmentDefinition", t.VARIABLE = "Variable", t.INT = "IntValue", t.FLOAT = "FloatValue", t.STRING = "StringValue", t.BOOLEAN = "BooleanValue", t.NULL = "NullValue", t.ENUM = "EnumValue", t.LIST = "ListValue", t.OBJECT = "ObjectValue", t.OBJECT_FIELD = "ObjectField", t.DIRECTIVE = "Directive", t.NAMED_TYPE = "NamedType", t.LIST_TYPE = "ListType", t.NON_NULL_TYPE = "NonNullType", t.SCHEMA_DEFINITION = "SchemaDefinition", t.OPERATION_TYPE_DEFINITION = "OperationTypeDefinition", t.SCALAR_TYPE_DEFINITION = "ScalarTypeDefinition", t.OBJECT_TYPE_DEFINITION = "ObjectTypeDefinition", t.FIELD_DEFINITION = "FieldDefinition", t.INPUT_VALUE_DEFINITION = "InputValueDefinition", t.INTERFACE_TYPE_DEFINITION = "InterfaceTypeDefinition", t.UNION_TYPE_DEFINITION = "UnionTypeDefinition", t.ENUM_TYPE_DEFINITION = "EnumTypeDefinition", t.ENUM_VALUE_DEFINITION = "EnumValueDefinition", t.INPUT_OBJECT_TYPE_DEFINITION = "InputObjectTypeDefinition", t.DIRECTIVE_DEFINITION = "DirectiveDefinition", t.SCHEMA_EXTENSION = "SchemaExtension", t.SCALAR_TYPE_EXTENSION = "ScalarTypeExtension", t.OBJECT_TYPE_EXTENSION = "ObjectTypeExtension", t.INTERFACE_TYPE_EXTENSION = "InterfaceTypeExtension", t.UNION_TYPE_EXTENSION = "UnionTypeExtension", t.ENUM_TYPE_EXTENSION = "EnumTypeExtension", t.INPUT_OBJECT_TYPE_EXTENSION = "InputObjectTypeExtension";
+})(d || (d = {}));
+function Ue(t) {
+  return t === 9 || t === 32;
+}
+function _(t) {
+  return t >= 48 && t <= 57;
+}
+function pe(t) {
+  return t >= 97 && t <= 122 || // A-Z
+  t >= 65 && t <= 90;
+}
+function fe(t) {
+  return pe(t) || t === 95;
+}
+function Me(t) {
+  return pe(t) || _(t) || t === 95;
+}
+function Ve(t) {
+  var e;
+  let r = Number.MAX_SAFE_INTEGER, s = null, n = -1;
+  for (let a = 0; a < t.length; ++a) {
+    var i;
+    const u = t[a], l = Ge(u);
+    l !== u.length && (s = (i = s) !== null && i !== void 0 ? i : a, n = a, a !== 0 && l < r && (r = l));
+  }
+  return t.map((a, u) => u === 0 ? a : a.slice(r)).slice(
+    (e = s) !== null && e !== void 0 ? e : 0,
+    n + 1
+  );
+}
+function Ge(t) {
+  let e = 0;
+  for (; e < t.length && Ue(t.charCodeAt(e)); )
+    ++e;
+  return e;
+}
+var o;
+(function(t) {
+  t.SOF = "<SOF>", t.EOF = "<EOF>", t.BANG = "!", t.DOLLAR = "$", t.AMP = "&", t.PAREN_L = "(", t.PAREN_R = ")", t.SPREAD = "...", t.COLON = ":", t.EQUALS = "=", t.AT = "@", t.BRACKET_L = "[", t.BRACKET_R = "]", t.BRACE_L = "{", t.PIPE = "|", t.BRACE_R = "}", t.NAME = "Name", t.INT = "Int", t.FLOAT = "Float", t.STRING = "String", t.BLOCK_STRING = "BlockString", t.COMMENT = "Comment";
+})(o || (o = {}));
+class je {
+  /**
+   * 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 r = new he(o.SOF, 0, 0, 0, 0);
+    this.source = e, this.lastToken = r, this.token = r, 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 !== o.EOF)
+      do
+        if (e.next)
+          e = e.next;
+        else {
+          const r = Ye(this, e.end);
+          e.next = r, r.prev = e, e = r;
+        }
+      while (e.kind === o.COMMENT);
+    return e;
+  }
+}
+function qe(t) {
+  return t === o.BANG || t === o.DOLLAR || t === o.AMP || t === o.PAREN_L || t === o.PAREN_R || t === o.SPREAD || t === o.COLON || t === o.EQUALS || t === o.AT || t === o.BRACKET_L || t === o.BRACKET_R || t === o.BRACE_L || t === o.PIPE || t === o.BRACE_R;
+}
+function k(t) {
+  return t >= 0 && t <= 55295 || t >= 57344 && t <= 1114111;
+}
+function R(t, e) {
+  return me(t.charCodeAt(e)) && ge(t.charCodeAt(e + 1));
+}
+function me(t) {
+  return t >= 55296 && t <= 56319;
+}
+function ge(t) {
+  return t >= 56320 && t <= 57343;
+}
+function A(t, e) {
+  const r = t.source.body.codePointAt(e);
+  if (r === void 0)
+    return o.EOF;
+  if (r >= 32 && r <= 126) {
+    const s = String.fromCodePoint(r);
+    return s === '"' ? `'"'` : `"${s}"`;
+  }
+  return "U+" + r.toString(16).toUpperCase().padStart(4, "0");
+}
+function h(t, e, r, s, n) {
+  const i = t.line, a = 1 + r - t.lineStart;
+  return new he(e, r, s, i, a, n);
+}
+function Ye(t, e) {
+  const r = t.source.body, s = r.length;
+  let n = e;
+  for (; n < s; ) {
+    const i = r.charCodeAt(n);
+    switch (i) {
+      // 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, ++t.line, t.lineStart = n;
+        continue;
+      case 13:
+        r.charCodeAt(n + 1) === 10 ? n += 2 : ++n, ++t.line, t.lineStart = n;
+        continue;
+      // Comment
+      case 35:
+        return ze(t, n);
+      // Token ::
+      //   - Punctuator
+      //   - Name
+      //   - IntValue
+      //   - FloatValue
+      //   - StringValue
+      //
+      // Punctuator :: one of ! $ & ( ) ... : = @ [ ] { | }
+      case 33:
+        return h(t, o.BANG, n, n + 1);
+      case 36:
+        return h(t, o.DOLLAR, n, n + 1);
+      case 38:
+        return h(t, o.AMP, n, n + 1);
+      case 40:
+        return h(t, o.PAREN_L, n, n + 1);
+      case 41:
+        return h(t, o.PAREN_R, n, n + 1);
+      case 46:
+        if (r.charCodeAt(n + 1) === 46 && r.charCodeAt(n + 2) === 46)
+          return h(t, o.SPREAD, n, n + 3);
+        break;
+      case 58:
+        return h(t, o.COLON, n, n + 1);
+      case 61:
+        return h(t, o.EQUALS, n, n + 1);
+      case 64:
+        return h(t, o.AT, n, n + 1);
+      case 91:
+        return h(t, o.BRACKET_L, n, n + 1);
+      case 93:
+        return h(t, o.BRACKET_R, n, n + 1);
+      case 123:
+        return h(t, o.BRACE_L, n, n + 1);
+      case 124:
+        return h(t, o.PIPE, n, n + 1);
+      case 125:
+        return h(t, o.BRACE_R, n, n + 1);
+      // StringValue
+      case 34:
+        return r.charCodeAt(n + 1) === 34 && r.charCodeAt(n + 2) === 34 ? We(t, n) : Qe(t, n);
+    }
+    if (_(i) || i === 45)
+      return He(t, n, i);
+    if (fe(i))
+      return Ze(t, n);
+    throw m(
+      t.source,
+      n,
+      i === 39 ? `Unexpected single quote character ('), did you mean to use a double quote (")?` : k(i) || R(r, n) ? `Unexpected character: ${A(t, n)}.` : `Invalid character: ${A(t, n)}.`
+    );
+  }
+  return h(t, o.EOF, s, s);
+}
+function ze(t, e) {
+  const r = t.source.body, s = r.length;
+  let n = e + 1;
+  for (; n < s; ) {
+    const i = r.charCodeAt(n);
+    if (i === 10 || i === 13)
+      break;
+    if (k(i))
+      ++n;
+    else if (R(r, n))
+      n += 2;
+    else
+      break;
+  }
+  return h(
+    t,
+    o.COMMENT,
+    e,
+    n,
+    r.slice(e + 1, n)
+  );
+}
+function He(t, e, r) {
+  const s = t.source.body;
+  let n = e, i = r, a = !1;
+  if (i === 45 && (i = s.charCodeAt(++n)), i === 48) {
+    if (i = s.charCodeAt(++n), _(i))
+      throw m(
+        t.source,
+        n,
+        `Invalid number, unexpected digit after 0: ${A(
+          t,
+          n
+        )}.`
+      );
+  } else
+    n = U(t, n, i), i = s.charCodeAt(n);
+  if (i === 46 && (a = !0, i = s.charCodeAt(++n), n = U(t, n, i), i = s.charCodeAt(n)), (i === 69 || i === 101) && (a = !0, i = s.charCodeAt(++n), (i === 43 || i === 45) && (i = s.charCodeAt(++n)), n = U(t, n, i), i = s.charCodeAt(n)), i === 46 || fe(i))
+    throw m(
+      t.source,
+      n,
+      `Invalid number, expected digit but got: ${A(
+        t,
+        n
+      )}.`
+    );
+  return h(
+    t,
+    a ? o.FLOAT : o.INT,
+    e,
+    n,
+    s.slice(e, n)
+  );
+}
+function U(t, e, r) {
+  if (!_(r))
+    throw m(
+      t.source,
+      e,
+      `Invalid number, expected digit but got: ${A(
+        t,
+        e
+      )}.`
+    );
+  const s = t.source.body;
+  let n = e + 1;
+  for (; _(s.charCodeAt(n)); )
+    ++n;
+  return n;
+}
+function Qe(t, e) {
+  const r = t.source.body, s = r.length;
+  let n = e + 1, i = n, a = "";
+  for (; n < s; ) {
+    const u = r.charCodeAt(n);
+    if (u === 34)
+      return a += r.slice(i, n), h(t, o.STRING, e, n + 1, a);
+    if (u === 92) {
+      a += r.slice(i, n);
+      const l = r.charCodeAt(n + 1) === 117 ? r.charCodeAt(n + 2) === 123 ? Je(t, n) : Xe(t, n) : Ke(t, n);
+      a += l.value, n += l.size, i = n;
+      continue;
+    }
+    if (u === 10 || u === 13)
+      break;
+    if (k(u))
+      ++n;
+    else if (R(r, n))
+      n += 2;
+    else
+      throw m(
+        t.source,
+        n,
+        `Invalid character within String: ${A(
+          t,
+          n
+        )}.`
+      );
+  }
+  throw m(t.source, n, "Unterminated string.");
+}
+function Je(t, e) {
+  const r = t.source.body;
+  let s = 0, n = 3;
+  for (; n < 12; ) {
+    const i = r.charCodeAt(e + n++);
+    if (i === 125) {
+      if (n < 5 || !k(s))
+        break;
+      return {
+        value: String.fromCodePoint(s),
+        size: n
+      };
+    }
+    if (s = s << 4 | b(i), s < 0)
+      break;
+  }
+  throw m(
+    t.source,
+    e,
+    `Invalid Unicode escape sequence: "${r.slice(
+      e,
+      e + n
+    )}".`
+  );
+}
+function Xe(t, e) {
+  const r = t.source.body, s = oe(r, e + 2);
+  if (k(s))
+    return {
+      value: String.fromCodePoint(s),
+      size: 6
+    };
+  if (me(s) && r.charCodeAt(e + 6) === 92 && r.charCodeAt(e + 7) === 117) {
+    const n = oe(r, e + 8);
+    if (ge(n))
+      return {
+        value: String.fromCodePoint(s, n),
+        size: 12
+      };
+  }
+  throw m(
+    t.source,
+    e,
+    `Invalid Unicode escape sequence: "${r.slice(e, e + 6)}".`
+  );
+}
+function oe(t, e) {
+  return b(t.charCodeAt(e)) << 12 | b(t.charCodeAt(e + 1)) << 8 | b(t.charCodeAt(e + 2)) << 4 | b(t.charCodeAt(e + 3));
+}
+function b(t) {
+  return t >= 48 && t <= 57 ? t - 48 : t >= 65 && t <= 70 ? t - 55 : t >= 97 && t <= 102 ? t - 87 : -1;
+}
+function Ke(t, e) {
+  const r = t.source.body;
+  switch (r.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 m(
+    t.source,
+    e,
+    `Invalid character escape sequence: "${r.slice(
+      e,
+      e + 2
+    )}".`
+  );
+}
+function We(t, e) {
+  const r = t.source.body, s = r.length;
+  let n = t.lineStart, i = e + 3, a = i, u = "";
+  const l = [];
+  for (; i < s; ) {
+    const p = r.charCodeAt(i);
+    if (p === 34 && r.charCodeAt(i + 1) === 34 && r.charCodeAt(i + 2) === 34) {
+      u += r.slice(a, i), l.push(u);
+      const c = h(
+        t,
+        o.BLOCK_STRING,
+        e,
+        i + 3,
+        // Return a string of the lines joined with U+000A.
+        Ve(l).join(`
+`)
+      );
+      return t.line += l.length - 1, t.lineStart = n, c;
+    }
+    if (p === 92 && r.charCodeAt(i + 1) === 34 && r.charCodeAt(i + 2) === 34 && r.charCodeAt(i + 3) === 34) {
+      u += r.slice(a, i), a = i + 1, i += 4;
+      continue;
+    }
+    if (p === 10 || p === 13) {
+      u += r.slice(a, i), l.push(u), p === 13 && r.charCodeAt(i + 1) === 10 ? i += 2 : ++i, u = "", a = i, n = i;
+      continue;
+    }
+    if (k(p))
+      ++i;
+    else if (R(r, i))
+      i += 2;
+    else
+      throw m(
+        t.source,
+        i,
+        `Invalid character within String: ${A(
+          t,
+          i
+        )}.`
+      );
+  }
+  throw m(t.source, i, "Unterminated string.");
+}
+function Ze(t, e) {
+  const r = t.source.body, s = r.length;
+  let n = e + 1;
+  for (; n < s; ) {
+    const i = r.charCodeAt(n);
+    if (Me(i))
+      ++n;
+    else
+      break;
+  }
+  return h(
+    t,
+    o.NAME,
+    e,
+    n,
+    r.slice(e, n)
+  );
+}
+const et = 10, Ie = 2;
+function Ee(t) {
+  return w(t, []);
+}
+function w(t, e) {
+  switch (typeof t) {
+    case "string":
+      return JSON.stringify(t);
+    case "function":
+      return t.name ? `[function ${t.name}]` : "[function]";
+    case "object":
+      return tt(t, e);
+    default:
+      return String(t);
+  }
+}
+function tt(t, e) {
+  if (t === null)
+    return "null";
+  if (e.includes(t))
+    return "[Circular]";
+  const r = [...e, t];
+  if (rt(t)) {
+    const s = t.toJSON();
+    if (s !== t)
+      return typeof s == "string" ? s : w(s, r);
+  } else if (Array.isArray(t))
+    return st(t, r);
+  return nt(t, r);
+}
+function rt(t) {
+  return typeof t.toJSON == "function";
+}
+function nt(t, e) {
+  const r = Object.entries(t);
+  return r.length === 0 ? "{}" : e.length > Ie ? "[" + it(t) + "]" : "{ " + r.map(
+    ([n, i]) => n + ": " + w(i, e)
+  ).join(", ") + " }";
+}
+function st(t, e) {
+  if (t.length === 0)
+    return "[]";
+  if (e.length > Ie)
+    return "[Array]";
+  const r = Math.min(et, t.length), s = t.length - r, n = [];
+  for (let i = 0; i < r; ++i)
+    n.push(w(t[i], e));
+  return s === 1 ? n.push("... 1 more item") : s > 1 && n.push(`... ${s} more items`), "[" + n.join(", ") + "]";
+}
+function it(t) {
+  const e = Object.prototype.toString.call(t).replace(/^\[object /, "").replace(/]$/, "");
+  if (e === "Object" && typeof t.constructor == "function") {
+    const r = t.constructor.name;
+    if (typeof r == "string" && r !== "")
+      return r;
+  }
+  return e;
+}
+const ot = globalThis.process && // eslint-disable-next-line no-undef
+process.env.NODE_ENV === "production", at = (
+  /* c8 ignore next 6 */
+  // FIXME: https://github.com/graphql/graphql-js/issues/2317
+  ot ? function(e, r) {
+    return e instanceof r;
+  } : function(e, r) {
+    if (e instanceof r)
+      return !0;
+    if (typeof e == "object" && e !== null) {
+      var s;
+      const n = r.prototype[Symbol.toStringTag], i = (
+        // We still need to support constructor's name to detect conflicts with older versions of this library.
+        Symbol.toStringTag in e ? e[Symbol.toStringTag] : (s = e.constructor) === null || s === void 0 ? void 0 : s.name
+      );
+      if (n === i) {
+        const a = Ee(e);
+        throw new Error(`Cannot use ${n} "${a}" from another module or realm.
+
+Ensure that there is only one instance of "graphql" in the node_modules
+directory. If different versions of "graphql" are the dependencies of other
+relied on modules, use "resolutions" to ensure only one version is installed.
+
+https://yarnpkg.com/en/docs/selective-version-resolutions
+
+Duplicate "graphql" modules cannot be used at the same time since different
+versions may have different capabilities and behavior. The data from one
+version used in the function from another could produce confusing and
+spurious results.`);
+      }
+    }
+    return !1;
+  }
+);
+class ye {
+  constructor(e, r = "GraphQL request", s = {
+    line: 1,
+    column: 1
+  }) {
+    typeof e == "string" || B(!1, `Body must be a string. Received: ${Ee(e)}.`), this.body = e, this.name = r, this.locationOffset = s, this.locationOffset.line > 0 || B(
+      !1,
+      "line in locationOffset is 1-indexed and must be positive."
+    ), this.locationOffset.column > 0 || B(
+      !1,
+      "column in locationOffset is 1-indexed and must be positive."
+    );
+  }
+  get [Symbol.toStringTag]() {
+    return "Source";
+  }
+}
+function ct(t) {
+  return at(t, ye);
+}
+function dt(t, e) {
+  const r = new ut(t, e), s = r.parseDocument();
+  return Object.defineProperty(s, "tokenCount", {
+    enumerable: !1,
+    value: r.tokenCount
+  }), s;
+}
+class ut {
+  constructor(e, r = {}) {
+    const s = ct(e) ? e : new ye(e);
+    this._lexer = new je(s), this._options = r, this._tokenCounter = 0;
+  }
+  get tokenCount() {
+    return this._tokenCounter;
+  }
+  /**
+   * Converts a name lex token into a name parse node.
+   */
+  parseName() {
+    const e = this.expectToken(o.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(
+        o.SOF,
+        this.parseDefinition,
+        o.EOF
+      )
+    });
+  }
+  /**
+   * Definition :
+   *   - ExecutableDefinition
+   *   - TypeSystemDefinition
+   *   - TypeSystemExtension
+   *
+   * ExecutableDefinition :
+   *   - OperationDefinition
+   *   - FragmentDefinition
+   *
+   * TypeSystemDefinition :
+   *   - SchemaDefinition
+   *   - TypeDefinition
+   *   - DirectiveDefinition
+   *
+   * TypeDefinition :
+   *   - ScalarTypeDefinition
+   *   - ObjectTypeDefinition
+   *   - InterfaceTypeDefinition
+   *   - UnionTypeDefinition
+   *   - EnumTypeDefinition
+   *   - InputObjectTypeDefinition
+   */
+  parseDefinition() {
+    if (this.peek(o.BRACE_L))
+      return this.parseOperationDefinition();
+    const e = this.peekDescription(), r = e ? this._lexer.lookahead() : this._lexer.token;
+    if (r.kind === o.NAME) {
+      switch (r.value) {
+        case "schema":
+          return this.parseSchemaDefinition();
+        case "scalar":
+          return this.parseScalarTypeDefinition();
+        case "type":
+          return this.parseObjectTypeDefinition();
+        case "interface":
+          return this.parseInterfaceTypeDefinition();
+        case "union":
+          return this.parseUnionTypeDefinition();
+        case "enum":
+          return this.parseEnumTypeDefinition();
+        case "input":
+          return this.parseInputObjectTypeDefinition();
+        case "directive":
+          return this.parseDirectiveDefinition();
+      }
+      if (e)
+        throw m(
+          this._lexer.source,
+          this._lexer.token.start,
+          "Unexpected description, descriptions are supported only on type definitions."
+        );
+      switch (r.value) {
+        case "query":
+        case "mutation":
+        case "subscription":
+          return this.parseOperationDefinition();
+        case "fragment":
+          return this.parseFragmentDefinition();
+        case "extend":
+          return this.parseTypeSystemExtension();
+      }
+    }
+    throw this.unexpected(r);
+  }
+  // Implements the parsing rules in the Operations section.
+  /**
+   * OperationDefinition :
+   *  - SelectionSet
+   *  - OperationType Name? VariableDefinitions? Directives? SelectionSet
+   */
+  parseOperationDefinition() {
+    const e = this._lexer.token;
+    if (this.peek(o.BRACE_L))
+      return this.node(e, {
+        kind: d.OPERATION_DEFINITION,
+        operation: D.QUERY,
+        name: void 0,
+        variableDefinitions: [],
+        directives: [],
+        selectionSet: this.parseSelectionSet()
+      });
+    const r = this.parseOperationType();
+    let s;
+    return this.peek(o.NAME) && (s = this.parseName()), this.node(e, {
+      kind: d.OPERATION_DEFINITION,
+      operation: r,
+      name: s,
+      variableDefinitions: this.parseVariableDefinitions(),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * OperationType : one of query mutation subscription
+   */
+  parseOperationType() {
+    const e = this.expectToken(o.NAME);
+    switch (e.value) {
+      case "query":
+        return D.QUERY;
+      case "mutation":
+        return D.MUTATION;
+      case "subscription":
+        return D.SUBSCRIPTION;
+    }
+    throw this.unexpected(e);
+  }
+  /**
+   * VariableDefinitions : ( VariableDefinition+ )
+   */
+  parseVariableDefinitions() {
+    return this.optionalMany(
+      o.PAREN_L,
+      this.parseVariableDefinition,
+      o.PAREN_R
+    );
+  }
+  /**
+   * VariableDefinition : Variable : Type DefaultValue? Directives[Const]?
+   */
+  parseVariableDefinition() {
+    return this.node(this._lexer.token, {
+      kind: d.VARIABLE_DEFINITION,
+      variable: this.parseVariable(),
+      type: (this.expectToken(o.COLON), this.parseTypeReference()),
+      defaultValue: this.expectOptionalToken(o.EQUALS) ? this.parseConstValueLiteral() : void 0,
+      directives: this.parseConstDirectives()
+    });
+  }
+  /**
+   * Variable : $ Name
+   */
+  parseVariable() {
+    const e = this._lexer.token;
+    return this.expectToken(o.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(
+        o.BRACE_L,
+        this.parseSelection,
+        o.BRACE_R
+      )
+    });
+  }
+  /**
+   * Selection :
+   *   - Field
+   *   - FragmentSpread
+   *   - InlineFragment
+   */
+  parseSelection() {
+    return this.peek(o.SPREAD) ? this.parseFragment() : this.parseField();
+  }
+  /**
+   * Field : Alias? Name Arguments? Directives? SelectionSet?
+   *
+   * Alias : Name :
+   */
+  parseField() {
+    const e = this._lexer.token, r = this.parseName();
+    let s, n;
+    return this.expectOptionalToken(o.COLON) ? (s = r, n = this.parseName()) : n = r, this.node(e, {
+      kind: d.FIELD,
+      alias: s,
+      name: n,
+      arguments: this.parseArguments(!1),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.peek(o.BRACE_L) ? this.parseSelectionSet() : void 0
+    });
+  }
+  /**
+   * Arguments[Const] : ( Argument[?Const]+ )
+   */
+  parseArguments(e) {
+    const r = e ? this.parseConstArgument : this.parseArgument;
+    return this.optionalMany(o.PAREN_L, r, o.PAREN_R);
+  }
+  /**
+   * Argument[Const] : Name : Value[?Const]
+   */
+  parseArgument(e = !1) {
+    const r = this._lexer.token, s = this.parseName();
+    return this.expectToken(o.COLON), this.node(r, {
+      kind: d.ARGUMENT,
+      name: s,
+      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(o.SPREAD);
+    const r = this.expectOptionalKeyword("on");
+    return !r && this.peek(o.NAME) ? this.node(e, {
+      kind: d.FRAGMENT_SPREAD,
+      name: this.parseFragmentName(),
+      directives: this.parseDirectives(!1)
+    }) : this.node(e, {
+      kind: d.INLINE_FRAGMENT,
+      typeCondition: r ? 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;
+    return this.expectKeyword("fragment"), this._options.allowLegacyFragmentVariables === !0 ? this.node(e, {
+      kind: d.FRAGMENT_DEFINITION,
+      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,
+      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 r = this._lexer.token;
+    switch (r.kind) {
+      case o.BRACKET_L:
+        return this.parseList(e);
+      case o.BRACE_L:
+        return this.parseObject(e);
+      case o.INT:
+        return this.advanceLexer(), this.node(r, {
+          kind: d.INT,
+          value: r.value
+        });
+      case o.FLOAT:
+        return this.advanceLexer(), this.node(r, {
+          kind: d.FLOAT,
+          value: r.value
+        });
+      case o.STRING:
+      case o.BLOCK_STRING:
+        return this.parseStringLiteral();
+      case o.NAME:
+        switch (this.advanceLexer(), r.value) {
+          case "true":
+            return this.node(r, {
+              kind: d.BOOLEAN,
+              value: !0
+            });
+          case "false":
+            return this.node(r, {
+              kind: d.BOOLEAN,
+              value: !1
+            });
+          case "null":
+            return this.node(r, {
+              kind: d.NULL
+            });
+          default:
+            return this.node(r, {
+              kind: d.ENUM,
+              value: r.value
+            });
+        }
+      case o.DOLLAR:
+        if (e)
+          if (this.expectToken(o.DOLLAR), this._lexer.token.kind === o.NAME) {
+            const s = this._lexer.token.value;
+            throw m(
+              this._lexer.source,
+              r.start,
+              `Unexpected variable "$${s}" in constant value.`
+            );
+          } else
+            throw this.unexpected(r);
+        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 === o.BLOCK_STRING
+    });
+  }
+  /**
+   * ListValue[Const] :
+   *   - [ ]
+   *   - [ Value[?Const]+ ]
+   */
+  parseList(e) {
+    const r = () => this.parseValueLiteral(e);
+    return this.node(this._lexer.token, {
+      kind: d.LIST,
+      values: this.any(o.BRACKET_L, r, o.BRACKET_R)
+    });
+  }
+  /**
+   * ```
+   * ObjectValue[Const] :
+   *   - { }
+   *   - { ObjectField[?Const]+ }
+   * ```
+   */
+  parseObject(e) {
+    const r = () => this.parseObjectField(e);
+    return this.node(this._lexer.token, {
+      kind: d.OBJECT,
+      fields: this.any(o.BRACE_L, r, o.BRACE_R)
+    });
+  }
+  /**
+   * ObjectField[Const] : Name : Value[?Const]
+   */
+  parseObjectField(e) {
+    const r = this._lexer.token, s = this.parseName();
+    return this.expectToken(o.COLON), this.node(r, {
+      kind: d.OBJECT_FIELD,
+      name: s,
+      value: this.parseValueLiteral(e)
+    });
+  }
+  // Implements the parsing rules in the Directives section.
+  /**
+   * Directives[Const] : Directive[?Const]+
+   */
+  parseDirectives(e) {
+    const r = [];
+    for (; this.peek(o.AT); )
+      r.push(this.parseDirective(e));
+    return r;
+  }
+  parseConstDirectives() {
+    return this.parseDirectives(!0);
+  }
+  /**
+   * ```
+   * Directive[Const] : @ Name Arguments[?Const]?
+   * ```
+   */
+  parseDirective(e) {
+    const r = this._lexer.token;
+    return this.expectToken(o.AT), this.node(r, {
+      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 r;
+    if (this.expectOptionalToken(o.BRACKET_L)) {
+      const s = this.parseTypeReference();
+      this.expectToken(o.BRACKET_R), r = this.node(e, {
+        kind: d.LIST_TYPE,
+        type: s
+      });
+    } else
+      r = this.parseNamedType();
+    return this.expectOptionalToken(o.BANG) ? this.node(e, {
+      kind: d.NON_NULL_TYPE,
+      type: r
+    }) : r;
+  }
+  /**
+   * 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(o.STRING) || this.peek(o.BLOCK_STRING);
+  }
+  /**
+   * Description : StringValue
+   */
+  parseDescription() {
+    if (this.peekDescription())
+      return this.parseStringLiteral();
+  }
+  /**
+   * ```
+   * SchemaDefinition : Description? schema Directives[Const]? { OperationTypeDefinition+ }
+   * ```
+   */
+  parseSchemaDefinition() {
+    const e = this._lexer.token, r = this.parseDescription();
+    this.expectKeyword("schema");
+    const s = this.parseConstDirectives(), n = this.many(
+      o.BRACE_L,
+      this.parseOperationTypeDefinition,
+      o.BRACE_R
+    );
+    return this.node(e, {
+      kind: d.SCHEMA_DEFINITION,
+      description: r,
+      directives: s,
+      operationTypes: n
+    });
+  }
+  /**
+   * OperationTypeDefinition : OperationType : NamedType
+   */
+  parseOperationTypeDefinition() {
+    const e = this._lexer.token, r = this.parseOperationType();
+    this.expectToken(o.COLON);
+    const s = this.parseNamedType();
+    return this.node(e, {
+      kind: d.OPERATION_TYPE_DEFINITION,
+      operation: r,
+      type: s
+    });
+  }
+  /**
+   * ScalarTypeDefinition : Description? scalar Name Directives[Const]?
+   */
+  parseScalarTypeDefinition() {
+    const e = this._lexer.token, r = this.parseDescription();
+    this.expectKeyword("scalar");
+    const s = this.parseName(), n = this.parseConstDirectives();
+    return this.node(e, {
+      kind: d.SCALAR_TYPE_DEFINITION,
+      description: r,
+      name: s,
+      directives: n
+    });
+  }
+  /**
+   * ObjectTypeDefinition :
+   *   Description?
+   *   type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition?
+   */
+  parseObjectTypeDefinition() {
+    const e = this._lexer.token, r = this.parseDescription();
+    this.expectKeyword("type");
+    const s = this.parseName(), n = this.parseImplementsInterfaces(), i = this.parseConstDirectives(), a = this.parseFieldsDefinition();
+    return this.node(e, {
+      kind: d.OBJECT_TYPE_DEFINITION,
+      description: r,
+      name: s,
+      interfaces: n,
+      directives: i,
+      fields: a
+    });
+  }
+  /**
+   * ImplementsInterfaces :
+   *   - implements `&`? NamedType
+   *   - ImplementsInterfaces & NamedType
+   */
+  parseImplementsInterfaces() {
+    return this.expectOptionalKeyword("implements") ? this.delimitedMany(o.AMP, this.parseNamedType) : [];
+  }
+  /**
+   * ```
+   * FieldsDefinition : { FieldDefinition+ }
+   * ```
+   */
+  parseFieldsDefinition() {
+    return this.optionalMany(
+      o.BRACE_L,
+      this.parseFieldDefinition,
+      o.BRACE_R
+    );
+  }
+  /**
+   * FieldDefinition :
+   *   - Description? Name ArgumentsDefinition? : Type Directives[Const]?
+   */
+  parseFieldDefinition() {
+    const e = this._lexer.token, r = this.parseDescription(), s = this.parseName(), n = this.parseArgumentDefs();
+    this.expectToken(o.COLON);
+    const i = this.parseTypeReference(), a = this.parseConstDirectives();
+    return this.node(e, {
+      kind: d.FIELD_DEFINITION,
+      description: r,
+      name: s,
+      arguments: n,
+      type: i,
+      directives: a
+    });
+  }
+  /**
+   * ArgumentsDefinition : ( InputValueDefinition+ )
+   */
+  parseArgumentDefs() {
+    return this.optionalMany(
+      o.PAREN_L,
+      this.parseInputValueDef,
+      o.PAREN_R
+    );
+  }
+  /**
+   * InputValueDefinition :
+   *   - Description? Name : Type DefaultValue? Directives[Const]?
+   */
+  parseInputValueDef() {
+    const e = this._lexer.token, r = this.parseDescription(), s = this.parseName();
+    this.expectToken(o.COLON);
+    const n = this.parseTypeReference();
+    let i;
+    this.expectOptionalToken(o.EQUALS) && (i = this.parseConstValueLiteral());
+    const a = this.parseConstDirectives();
+    return this.node(e, {
+      kind: d.INPUT_VALUE_DEFINITION,
+      description: r,
+      name: s,
+      type: n,
+      defaultValue: i,
+      directives: a
+    });
+  }
+  /**
+   * InterfaceTypeDefinition :
+   *   - Description? interface Name Directives[Const]? FieldsDefinition?
+   */
+  parseInterfaceTypeDefinition() {
+    const e = this._lexer.token, r = this.parseDescription();
+    this.expectKeyword("interface");
+    const s = this.parseName(), n = this.parseImplementsInterfaces(), i = this.parseConstDirectives(), a = this.parseFieldsDefinition();
+    return this.node(e, {
+      kind: d.INTERFACE_TYPE_DEFINITION,
+      description: r,
+      name: s,
+      interfaces: n,
+      directives: i,
+      fields: a
+    });
+  }
+  /**
+   * UnionTypeDefinition :
+   *   - Description? union Name Directives[Const]? UnionMemberTypes?
+   */
+  parseUnionTypeDefinition() {
+    const e = this._lexer.token, r = this.parseDescription();
+    this.expectKeyword("union");
+    const s = this.parseName(), n = this.parseConstDirectives(), i = this.parseUnionMemberTypes();
+    return this.node(e, {
+      kind: d.UNION_TYPE_DEFINITION,
+      description: r,
+      name: s,
+      directives: n,
+      types: i
+    });
+  }
+  /**
+   * UnionMemberTypes :
+   *   - = `|`? NamedType
+   *   - UnionMemberTypes | NamedType
+   */
+  parseUnionMemberTypes() {
+    return this.expectOptionalToken(o.EQUALS) ? this.delimitedMany(o.PIPE, this.parseNamedType) : [];
+  }
+  /**
+   * EnumTypeDefinition :
+   *   - Description? enum Name Directives[Const]? EnumValuesDefinition?
+   */
+  parseEnumTypeDefinition() {
+    const e = this._lexer.token, r = this.parseDescription();
+    this.expectKeyword("enum");
+    const s = this.parseName(), n = this.parseConstDirectives(), i = this.parseEnumValuesDefinition();
+    return this.node(e, {
+      kind: d.ENUM_TYPE_DEFINITION,
+      description: r,
+      name: s,
+      directives: n,
+      values: i
+    });
+  }
+  /**
+   * ```
+   * EnumValuesDefinition : { EnumValueDefinition+ }
+   * ```
+   */
+  parseEnumValuesDefinition() {
+    return this.optionalMany(
+      o.BRACE_L,
+      this.parseEnumValueDefinition,
+      o.BRACE_R
+    );
+  }
+  /**
+   * EnumValueDefinition : Description? EnumValue Directives[Const]?
+   */
+  parseEnumValueDefinition() {
+    const e = this._lexer.token, r = this.parseDescription(), s = this.parseEnumValueName(), n = this.parseConstDirectives();
+    return this.node(e, {
+      kind: d.ENUM_VALUE_DEFINITION,
+      description: r,
+      name: s,
+      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 m(
+        this._lexer.source,
+        this._lexer.token.start,
+        `${C(
+          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, r = this.parseDescription();
+    this.expectKeyword("input");
+    const s = this.parseName(), n = this.parseConstDirectives(), i = this.parseInputFieldsDefinition();
+    return this.node(e, {
+      kind: d.INPUT_OBJECT_TYPE_DEFINITION,
+      description: r,
+      name: s,
+      directives: n,
+      fields: i
+    });
+  }
+  /**
+   * ```
+   * InputFieldsDefinition : { InputValueDefinition+ }
+   * ```
+   */
+  parseInputFieldsDefinition() {
+    return this.optionalMany(
+      o.BRACE_L,
+      this.parseInputValueDef,
+      o.BRACE_R
+    );
+  }
+  /**
+   * TypeSystemExtension :
+   *   - SchemaExtension
+   *   - TypeExtension
+   *
+   * TypeExtension :
+   *   - ScalarTypeExtension
+   *   - ObjectTypeExtension
+   *   - InterfaceTypeExtension
+   *   - UnionTypeExtension
+   *   - EnumTypeExtension
+   *   - InputObjectTypeDefinition
+   */
+  parseTypeSystemExtension() {
+    const e = this._lexer.lookahead();
+    if (e.kind === o.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 r = this.parseConstDirectives(), s = this.optionalMany(
+      o.BRACE_L,
+      this.parseOperationTypeDefinition,
+      o.BRACE_R
+    );
+    if (r.length === 0 && s.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: d.SCHEMA_EXTENSION,
+      directives: r,
+      operationTypes: s
+    });
+  }
+  /**
+   * ScalarTypeExtension :
+   *   - extend scalar Name Directives[Const]
+   */
+  parseScalarTypeExtension() {
+    const e = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("scalar");
+    const r = this.parseName(), s = this.parseConstDirectives();
+    if (s.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: d.SCALAR_TYPE_EXTENSION,
+      name: r,
+      directives: s
+    });
+  }
+  /**
+   * 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 r = this.parseName(), s = this.parseImplementsInterfaces(), n = this.parseConstDirectives(), i = this.parseFieldsDefinition();
+    if (s.length === 0 && n.length === 0 && i.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: d.OBJECT_TYPE_EXTENSION,
+      name: r,
+      interfaces: s,
+      directives: n,
+      fields: i
+    });
+  }
+  /**
+   * 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 r = this.parseName(), s = this.parseImplementsInterfaces(), n = this.parseConstDirectives(), i = this.parseFieldsDefinition();
+    if (s.length === 0 && n.length === 0 && i.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: d.INTERFACE_TYPE_EXTENSION,
+      name: r,
+      interfaces: s,
+      directives: n,
+      fields: i
+    });
+  }
+  /**
+   * 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 r = this.parseName(), s = this.parseConstDirectives(), n = this.parseUnionMemberTypes();
+    if (s.length === 0 && n.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: d.UNION_TYPE_EXTENSION,
+      name: r,
+      directives: s,
+      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 r = this.parseName(), s = this.parseConstDirectives(), n = this.parseEnumValuesDefinition();
+    if (s.length === 0 && n.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: d.ENUM_TYPE_EXTENSION,
+      name: r,
+      directives: s,
+      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 r = this.parseName(), s = this.parseConstDirectives(), n = this.parseInputFieldsDefinition();
+    if (s.length === 0 && n.length === 0)
+      throw this.unexpected();
+    return this.node(e, {
+      kind: d.INPUT_OBJECT_TYPE_EXTENSION,
+      name: r,
+      directives: s,
+      fields: n
+    });
+  }
+  /**
+   * ```
+   * DirectiveDefinition :
+   *   - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations
+   * ```
+   */
+  parseDirectiveDefinition() {
+    const e = this._lexer.token, r = this.parseDescription();
+    this.expectKeyword("directive"), this.expectToken(o.AT);
+    const s = this.parseName(), n = this.parseArgumentDefs(), i = this.expectOptionalKeyword("repeatable");
+    this.expectKeyword("on");
+    const a = this.parseDirectiveLocations();
+    return this.node(e, {
+      kind: d.DIRECTIVE_DEFINITION,
+      description: r,
+      name: s,
+      arguments: n,
+      repeatable: i,
+      locations: a
+    });
+  }
+  /**
+   * DirectiveLocations :
+   *   - `|`? DirectiveLocation
+   *   - DirectiveLocations | DirectiveLocation
+   */
+  parseDirectiveLocations() {
+    return this.delimitedMany(o.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, r = this.parseName();
+    if (Object.prototype.hasOwnProperty.call(V, r.value))
+      return r;
+    throw this.unexpected(e);
+  }
+  // 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, r) {
+    return this._options.noLocation !== !0 && (r.loc = new $e(
+      e,
+      this._lexer.lastToken,
+      this._lexer.source
+    )), r;
+  }
+  /**
+   * 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 r = this._lexer.token;
+    if (r.kind === e)
+      return this.advanceLexer(), r;
+    throw m(
+      this._lexer.source,
+      r.start,
+      `Expected ${Te(e)}, found ${C(r)}.`
+    );
+  }
+  /**
+   * 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 r = this._lexer.token;
+    if (r.kind === o.NAME && r.value === e)
+      this.advanceLexer();
+    else
+      throw m(
+        this._lexer.source,
+        r.start,
+        `Expected "${e}", found ${C(r)}.`
+      );
+  }
+  /**
+   * 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 r = this._lexer.token;
+    return r.kind === o.NAME && r.value === e ? (this.advanceLexer(), !0) : !1;
+  }
+  /**
+   * Helper function for creating an error when an unexpected lexed token is encountered.
+   */
+  unexpected(e) {
+    const r = e ?? this._lexer.token;
+    return m(
+      this._lexer.source,
+      r.start,
+      `Unexpected ${C(r)}.`
+    );
+  }
+  /**
+   * 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, r, s) {
+    this.expectToken(e);
+    const n = [];
+    for (; !this.expectOptionalToken(s); )
+      n.push(r.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, r, s) {
+    if (this.expectOptionalToken(e)) {
+      const n = [];
+      do
+        n.push(r.call(this));
+      while (!this.expectOptionalToken(s));
+      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, r, s) {
+    this.expectToken(e);
+    const n = [];
+    do
+      n.push(r.call(this));
+    while (!this.expectOptionalToken(s));
+    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, r) {
+    this.expectOptionalToken(e);
+    const s = [];
+    do
+      s.push(r.call(this));
+    while (this.expectOptionalToken(e));
+    return s;
+  }
+  advanceLexer() {
+    const { maxTokens: e } = this._options, r = this._lexer.advance();
+    if (r.kind !== o.EOF && (++this._tokenCounter, e !== void 0 && this._tokenCounter > e))
+      throw m(
+        this._lexer.source,
+        r.start,
+        `Document contains more that ${e} tokens. Parsing aborted.`
+      );
+  }
+}
+function C(t) {
+  const e = t.value;
+  return Te(t.kind) + (e != null ? ` "${e}"` : "");
+}
+function Te(t) {
+  return qe(t) ? `"${t}"` : t;
+}
+var P = /* @__PURE__ */ new Map(), G = /* @__PURE__ */ new Map(), Oe = !0, F = !1;
+function Ne(t) {
+  return t.replace(/[\s,]+/g, " ").trim();
+}
+function lt(t) {
+  return Ne(t.source.body.substring(t.start, t.end));
+}
+function ht(t) {
+  var e = /* @__PURE__ */ new Set(), r = [];
+  return t.definitions.forEach(function(s) {
+    if (s.kind === "FragmentDefinition") {
+      var n = s.name.value, i = lt(s.loc), a = G.get(n);
+      a && !a.has(i) ? Oe && 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`) : a || G.set(n, a = /* @__PURE__ */ new Set()), a.add(i), e.has(i) || (e.add(i), r.push(s));
+    } else
+      r.push(s);
+  }), L(L({}, t), { definitions: r });
+}
+function pt(t) {
+  var e = new Set(t.definitions);
+  e.forEach(function(s) {
+    s.loc && delete s.loc, Object.keys(s).forEach(function(n) {
+      var i = s[n];
+      i && typeof i == "object" && e.add(i);
+    });
+  });
+  var r = t.loc;
+  return r && (delete r.startToken, delete r.endToken), t;
+}
+function ft(t) {
+  var e = Ne(t);
+  if (!P.has(e)) {
+    var r = dt(t, {
+      experimentalFragmentVariables: F,
+      allowLegacyFragmentVariables: F
+    });
+    if (!r || r.kind !== "Document")
+      throw new Error("Not a valid GraphQL document.");
+    P.set(e, pt(ht(r)));
+  }
+  return P.get(e);
+}
+function I(t) {
+  for (var e = [], r = 1; r < arguments.length; r++)
+    e[r - 1] = arguments[r];
+  typeof t == "string" && (t = [t]);
+  var s = t[0];
+  return e.forEach(function(n, i) {
+    n && n.kind === "Document" ? s += n.loc.source.body : s += n, s += t[i + 1];
+  }), ft(s);
+}
+function mt() {
+  P.clear(), G.clear();
+}
+function gt() {
+  Oe = !1;
+}
+function It() {
+  F = !0;
+}
+function Et() {
+  F = !1;
+}
+var S = {
+  gql: I,
+  resetCaches: mt,
+  disableFragmentWarnings: gt,
+  enableExperimentalFragmentVariables: It,
+  disableExperimentalFragmentVariables: Et
+};
+(function(t) {
+  t.gql = S.gql, t.resetCaches = S.resetCaches, t.disableFragmentWarnings = S.disableFragmentWarnings, t.enableExperimentalFragmentVariables = S.enableExperimentalFragmentVariables, t.disableExperimentalFragmentVariables = S.disableExperimentalFragmentVariables;
+})(I || (I = {}));
+I.default = I;
+const yt = I`
+    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
+      }
+    }
+  }
+}
+    `, Tt = I`
+    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
+  }
+}
+    `, Ot = I`
+    mutation removeFromOrder($orderId: ID!, $productId: ID!, $additionalData: AdditionalDataInput, $amount: Int) {
+  releaseProduct(
+    input: {orderId: $orderId, productId: $productId, additionalData: $additionalData, amountToRelease: $amount}
+  ) {
+    orderId
+    amountReleased
+  }
+}
+    `, Nt = I`
+    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
+  }
+}
+    `, xt = I`
+    mutation configureOrderDeliveryOption($orderId: ID!, $productId: ID) {
+  configureDeliveryOption(input: {orderId: $orderId, productId: $productId})
+}
+    `, vt = I`
+    mutation createOrderCustomer($orderId: ID!, $countryCode: String, $customer: CreateCustomerInput!) {
+  createOrderCustomer(
+    input: {id: $orderId, countryCode: $countryCode, customer: $customer}
+  )
+}
+    `, At = I`
+    mutation deleteOrder($orderId: ID!) {
+  cancelOrder(id: $orderId)
+}
+    `, Dt = I`
+    query EventOverviewPage($organizationId: ID!, $locationIds: [String!], $hostingIds: [String!], $trackerId: String, $showDoorTickets: Boolean) {
+  findAllPublicEventByOrganizationId(
+    id: $organizationId
+    locationIds: $locationIds
+    hostingIds: $hostingIds
+    trackerLinkId: $trackerId
+    showDoorTickets: $showDoorTickets
+  ) {
+    data {
+      id
+      name
+      icon
+      banner
+      description
+      addonDescription
+      startAt
+      endAt
+      timezone
+      startSalesAt
+      endSalesAt
+      slug
+      facebookPixelId
+      status
+      location {
+        id
+        name
+        address
+      }
+      infoDescription
+    }
+  }
+}
+    `, kt = I`
+    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
+  }
+}
+    `, St = I`
+    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
+    }
+    transactionPrice
+    baseTransactionFee
+    additionalTransactionFee
+  }
+}
+    `, bt = I`
+    mutation createDigitalPayment($input: CreateDigitalOrderPaymentInput!) {
+  createDigitalOrderPayment(input: $input)
+}
+    `, _t = (t, e, r, s) => t();
+function Y(t, e = _t) {
+  return {
+    findActiveOrderById(r, s, n) {
+      return e((i) => t.request({ document: yt, variables: r, requestHeaders: { ...s, ...i }, signal: n }), "findActiveOrderById", "query", r);
+    },
+    addToOrder(r, s, n) {
+      return e((i) => t.request({ document: Tt, variables: r, requestHeaders: { ...s, ...i }, signal: n }), "addToOrder", "mutation", r);
+    },
+    removeFromOrder(r, s, n) {
+      return e((i) => t.request({ document: Ot, variables: r, requestHeaders: { ...s, ...i }, signal: n }), "removeFromOrder", "mutation", r);
+    },
+    configurePackage(r, s, n) {
+      return e((i) => t.request({ document: Nt, variables: r, requestHeaders: { ...s, ...i }, signal: n }), "configurePackage", "mutation", r);
+    },
+    configureOrderDeliveryOption(r, s, n) {
+      return e((i) => t.request({ document: xt, variables: r, requestHeaders: { ...s, ...i }, signal: n }), "configureOrderDeliveryOption", "mutation", r);
+    },
+    createOrderCustomer(r, s, n) {
+      return e((i) => t.request({ document: vt, variables: r, requestHeaders: { ...s, ...i }, signal: n }), "createOrderCustomer", "mutation", r);
+    },
+    deleteOrder(r, s, n) {
+      return e((i) => t.request({ document: At, variables: r, requestHeaders: { ...s, ...i }, signal: n }), "deleteOrder", "mutation", r);
+    },
+    EventOverviewPage(r, s, n) {
+      return e((i) => t.request({ document: Dt, variables: r, requestHeaders: { ...s, ...i }, signal: n }), "EventOverviewPage", "query", r);
+    },
+    findProductsByEventId(r, s, n) {
+      return e((i) => t.request({ document: kt, variables: r, requestHeaders: { ...s, ...i }, signal: n }), "findProductsByEventId", "query", r);
+    },
+    findPaymentMethods(r, s, n) {
+      return e((i) => t.request({ document: St, variables: r, requestHeaders: { ...s, ...i }, signal: n }), "findPaymentMethods", "query", r);
+    },
+    createDigitalPayment(r, s, n) {
+      return e((i) => t.request({ document: bt, variables: r, requestHeaders: { ...s, ...i }, signal: n }), "createDigitalPayment", "mutation", r);
+    }
+  };
+}
+const Ct = "http://localhost:3001/graphql";
+class Vt {
+  config;
+  sdk;
+  store;
+  constructor(e) {
+    this.config = {
+      ...e
+    }, this.store = ce({
+      reducer: {
+        event: Ce
+      }
+    });
+    const r = new j(Ct);
+    this.sdk = Y(r);
+  }
+  getState() {
+    return this.store.getState().event;
+  }
+  subscribe(e) {
+    return this.store.subscribe(e);
+  }
+  debugLog(e, r) {
+    this.config.debug && console.log(`[EventService:${this.config.organizationId}] ${e}`, r || "");
+  }
+  async fetchEvents() {
+    this.store.dispatch(te(!0));
+    try {
+      const e = sessionStorage.getItem("TIC_TRACKER_ID") || void 0;
+      this.debugLog("Fetching events with parameters", {
+        organizationId: this.config.organizationId,
+        locationIds: this.config.filteredLocationIds,
+        hostingIds: this.config.filteredHostingIds,
+        trackerId: e,
+        showDoorTickets: this.config.enableDoorTickets
+      });
+      const r = await this.sdk.EventOverviewPage({
+        organizationId: this.config.organizationId,
+        locationIds: this.config.filteredLocationIds,
+        hostingIds: this.config.filteredHostingIds,
+        trackerId: e,
+        showDoorTickets: this.config.enableDoorTickets
+      });
+      if (this.debugLog("Raw GraphQL response", r), r?.findAllPublicEventByOrganizationId?.data) {
+        const s = r.findAllPublicEventByOrganizationId.data.map((n) => ({
+          id: n.id,
+          name: n.name,
+          icon: n.icon ?? null,
+          banner: n.banner ?? null,
+          description: n.description ?? null,
+          addonDescription: n.addonDescription ?? null,
+          infoDescription: n.infoDescription ?? null,
+          startAt: x.fromISO(n.startAt, { zone: n.timezone }),
+          endAt: x.fromISO(n.endAt, { zone: n.timezone }),
+          timezone: n.timezone,
+          startSalesAt: n.startSalesAt ?? null,
+          endSalesAt: n.endSalesAt ?? null,
+          slug: n.slug ?? "",
+          facebookPixelId: n.facebookPixelId ?? null,
+          status: n.status,
+          location: n.location ? {
+            id: n.location.id,
+            name: n.location.name,
+            address: n.location.address
+          } : { id: "", name: "", address: null },
+          products: []
+        }));
+        this.debugLog("Processed events", { events: s, count: s.length }), this.store.dispatch(re(s)), this.debugLog("Redux state after setEvents", this.getState());
+      } else
+        this.debugLog("No events found in response"), this.store.dispatch(re([]));
+    } catch (e) {
+      throw this.debugLog("Error fetching events", e), this.store.dispatch(Se(e.message || "Failed to fetch events")), e;
+    } finally {
+      this.store.dispatch(te(!1));
+    }
+  }
+  async fetchProductsForEvent(e, r, s) {
+    this.store.dispatch(ne({ eventId: e, loading: !0 }));
+    try {
+      const n = sessionStorage.getItem("TIC_TRACKER_ID") || void 0, i = this.config.enableDoorTickets && r ? r : void 0;
+      this.debugLog("Fetching products for event", {
+        eventId: e,
+        promoCode: s,
+        trackerId: n,
+        productTypes: i
+      });
+      const a = await this.sdk.findProductsByEventId({
+        eventId: e,
+        promoCode: s,
+        trackerId: n,
+        productTypes: i
+      });
+      if (a?.findPublicProductsByEventId) {
+        const u = a.findPublicProductsByEventId.map((l) => ({
+          ...l
+        }));
+        return this.debugLog("Products fetched", {
+          eventId: e,
+          count: u.length,
+          types: u.map((l) => l.type)
+        }), this.store.dispatch(be({ eventId: e, products: u })), u;
+      }
+      return;
+    } catch (n) {
+      throw this.debugLog("Error fetching products", { eventId: e, error: n }), n;
+    } finally {
+      this.store.dispatch(ne({ eventId: e, loading: !1 }));
+    }
+  }
+  clearEvents() {
+    this.debugLog("Clearing events"), this.store.dispatch(_e());
+  }
+}
+const Pt = "http://localhost:3001/graphql";
+class Gt {
+  config;
+  sdk;
+  constructor(e = {}) {
+    this.config = e;
+    const r = new j(Pt, {
+      headers: e.headers
+    });
+    this.sdk = Y(r);
+  }
+  debugLog(e, r) {
+    this.config.debug && console.log(`[PaymentService] ${e}`, r || "");
+  }
+  async getPaymentMethods(e) {
+    this.debugLog("Fetching payment methods", e);
+    try {
+      const r = await this.sdk.findPaymentMethods({
+        orderId: e.orderId,
+        orderItemId: e.orderItemId,
+        amountOfTickets: e.amountOfTickets,
+        paymentMethodId: e.paymentMethodId
+      });
+      if (!r?.findPaymentDetails)
+        throw this.debugLog("No payment details found"), new Error("No payment details found for this order");
+      const s = r.findPaymentDetails;
+      return this.debugLog("Payment methods fetched successfully", {
+        methodCount: s.methods?.length ?? 0,
+        transactionPrice: s.transactionPrice,
+        baseTransactionFee: s.baseTransactionFee,
+        additionalTransactionFee: s.additionalTransactionFee
+      }), {
+        transactionPrice: s.transactionPrice,
+        baseTransactionFee: s.baseTransactionFee ?? null,
+        additionalTransactionFee: s.additionalTransactionFee ?? null,
+        methods: s.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((i) => ({
+            id: i.id,
+            name: i.name,
+            image: i.image
+          })) ?? null
+        })) ?? null
+      };
+    } catch (r) {
+      throw this.debugLog("Error fetching payment methods", r), r;
+    }
+  }
+  async createPayment(e) {
+    this.debugLog("Creating payment", e);
+    try {
+      const r = {
+        orderId: e.orderId,
+        paymentMethodId: e.paymentMethodId,
+        issuerId: e.issuerId,
+        redirectUrl: e.redirectUrl,
+        initiatedByUserId: e.initiatedByUserId,
+        initiatedByTeamId: e.initiatedByTeamId,
+        orderItemId: e.orderItemId,
+        amountOfTickets: e.amountOfTickets
+      };
+      e.customer && (r.customer = e.customer), e.products && (r.products = e.products), e.description && (r.description = e.description), e.reference && (r.reference = e.reference), e.ipAddress && (r.ipAddress = e.ipAddress);
+      const s = await this.sdk.createDigitalPayment({
+        input: r
+      });
+      if (!s?.createDigitalOrderPayment)
+        throw this.debugLog("Failed to create payment"), new Error("Failed to create payment for this order");
+      const n = s.createDigitalOrderPayment;
+      return this.debugLog("Payment created successfully", {
+        paymentUrl: n
+      }), {
+        paymentUrl: n
+      };
+    } catch (r) {
+      throw this.debugLog("Error creating payment", r), r;
+    }
+  }
+  calculateTotalWithFee(e, r) {
+    return r.fee ? r.fee.type === "FIXED" ? e + r.fee.value : r.fee.type === "PERCENTAGE" ? e + e * (r.fee.value / 100) : e : e;
+  }
+  calculateFee(e, r) {
+    return r.fee ? r.fee.type === "FIXED" ? r.fee.value : r.fee.type === "PERCENTAGE" ? e * (r.fee.value / 100) : 0 : 0;
+  }
+  formatFee(e, r = "€") {
+    return e.fee ? e.fee.type === "FIXED" ? `${r}${e.fee.value.toFixed(2)}` : e.fee.type === "PERCENTAGE" ? `${e.fee.value}%` : "Free" : "Free";
+  }
+}
+var v = /* @__PURE__ */ ((t) => (t.PACKAGE = "PACKAGE", t.PRODUCT = "PRODUCT", t.ADD_ONS = "ADD_ONS", t.DELIVERY = "DELIVERY", t.PICKUP = "PICKUP", t))(v || {}), Lt = /* @__PURE__ */ ((t) => (t.Ticket = "Ticket", t.Door = "Door", t.Addon = "Addon", t.Promoter = "Promoter", t.Pickup = "Pickup", t.Delivery = "Delivery", t))(Lt || {}), Ft = /* @__PURE__ */ ((t) => (t.FIXED = "FIXED", t.PERCENTAGE = "PERCENTAGE", t))(Ft || {});
+const Rt = "http://localhost:3001/graphql";
+class jt {
+  config;
+  orderIdKey;
+  sdk;
+  store;
+  constructor(e) {
+    this.config = {
+      ...e
+    }, this.orderIdKey = `ORDER_ID_${e.shopSlug}`, this.store = ce({
+      reducer: {
+        basket: ke
+      }
+    });
+    const r = new j(Rt);
+    this.sdk = Y(r), this.restoreOrderFromSession();
+  }
+  async restoreOrderFromSession() {
+    const e = this.getOrderId();
+    if (e) {
+      this.debugLog("Found existing order ID in session, restoring...", { orderId: e });
+      try {
+        await this.fetchOrder(e), this.debugLog("Order restored successfully");
+      } catch (r) {
+        this.debugLog("Failed to restore order, clearing session", r), this.clearOrderFromSession();
+      }
+    }
+  }
+  getState() {
+    return this.store.getState().basket;
+  }
+  subscribe(e) {
+    return this.store.subscribe(e);
+  }
+  /**
+   * Get the current order with a count of total items
+   * @returns CurrentOrder object with count property, or null if no order exists
+   */
+  getCurrentOrder() {
+    const e = this.getState();
+    if (!e.order)
+      return null;
+    const r = e.order.items.reduce((s, n) => s + (n.amount || 0), 0);
+    return {
+      ...e.order,
+      count: r
+    };
+  }
+  getOrderId() {
+    return sessionStorage.getItem(this.orderIdKey);
+  }
+  setOrderId(e) {
+    sessionStorage.setItem(this.orderIdKey, e);
+  }
+  getTrackerId() {
+    return sessionStorage.getItem("TIC_TRACKER_ID");
+  }
+  generateOrderId() {
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (e) => {
+      const r = Math.random() * 16 | 0;
+      return (e === "x" ? r : r & 3 | 8).toString(16);
+    });
+  }
+  debugLog(e, r) {
+    this.config.debug && console.log(`[BasketService:${this.config.shopSlug}] ${e}`, r || "");
+  }
+  async addProduct(e) {
+    this.store.dispatch(N(!0));
+    try {
+      const s = this.store.getState().basket.order?.id ?? this.getOrderId() ?? this.generateOrderId(), n = this.getTrackerId();
+      this.debugLog("Adding product", {
+        productId: e.id,
+        orderId: s,
+        amount: e.amount,
+        seat: e.seat
+      });
+      const i = await this.sdk.addToOrder({
+        productId: e.id,
+        orderId: s,
+        additionalData: e.seat ? {
+          seat: {
+            seatId: e.seat.id,
+            seatLabel: e.seat.label,
+            holdToken: e.seat.holdToken
+          }
+        } : null,
+        trackerId: n || void 0,
+        shopId: this.config.shopId,
+        amount: e.amount
+      });
+      if (i?.reserveProduct) {
+        const { orderId: a, expiredAt: u, amountReserved: l } = i.reserveProduct;
+        this.debugLog("Product added successfully", i.reserveProduct), this.setOrderId(a), this.store.dispatch(
+          $({
+            id: a,
+            currency: e.currency,
+            expiredAt: u
+          })
+        ), this.store.dispatch(
+          X({
+            input: e,
+            amountReserved: l,
+            expiredAt: u
+          })
+        );
+      }
+    } catch (r) {
+      throw this.debugLog("Error adding product", r), this.handleError(r), r;
+    } finally {
+      this.store.dispatch(N(!1));
+    }
+  }
+  async removeProduct(e) {
+    const s = this.getState().order;
+    if (s) {
+      this.store.dispatch(N(!0));
+      try {
+        this.debugLog("Removing product", {
+          productId: e.id,
+          orderId: s.id,
+          amount: e.amount
+        });
+        const n = await this.sdk.removeFromOrder({
+          productId: e.id,
+          orderId: s.id,
+          additionalData: e.seat ? {
+            seat: {
+              seatId: e.seat.id,
+              seatLabel: e.seat.label
+            }
+          } : null,
+          amount: e.amount
+        });
+        if (n?.releaseProduct) {
+          const { amountReleased: i } = n.releaseProduct;
+          this.debugLog("Product removed successfully", n.releaseProduct), this.store.dispatch(
+            Ae({
+              id: e.id,
+              amountReleased: i,
+              seatId: e.seat?.id
+            })
+          );
+          const a = this.getState();
+          (!a.order || a.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(N(!1));
+      }
+    }
+  }
+  async configurePackage(e) {
+    this.store.dispatch(N(!0));
+    try {
+      const s = this.store.getState().basket.order?.id ?? this.getOrderId() ?? this.generateOrderId(), n = this.getTrackerId(), i = e.items.map((u) => ({
+        packageItemId: u.packageItemId,
+        eventId: u.eventId
+      }));
+      this.debugLog("Configuring package", {
+        packageId: e.id,
+        orderId: s,
+        amount: e.amount,
+        items: i,
+        shopId: this.config.shopId
+      });
+      const a = await this.sdk.configurePackage({
+        trackerId: n || void 0,
+        shopId: this.config.shopId,
+        packageId: e.id,
+        orderId: s,
+        amount: e.amount,
+        items: i
+      });
+      if (this.debugLog("Configure package response", a), a?.configurePackage && a.configurePackage.amountReserved > 0) {
+        const { orderId: u, expiredAt: l, amountReserved: p } = a.configurePackage;
+        return this.debugLog("Package configured successfully"), this.setOrderId(u), this.store.dispatch(
+          $({
+            id: u,
+            currency: e.currency,
+            expiredAt: l
+          })
+        ), this.store.dispatch(
+          K({
+            input: e,
+            amountReserved: p,
+            expiredAt: l
+          })
+        ), null;
+      } else
+        return this.debugLog("Package configuration failed - no amount reserved"), { error: "Failed to configure package - no items reserved" };
+    } catch (r) {
+      return this.debugLog("Error configuring package", r), this.handleError(r), { error: r };
+    } finally {
+      this.store.dispatch(N(!1));
+    }
+  }
+  async setDelivery(e) {
+    this.store.dispatch(N(!0));
+    try {
+      this.store.dispatch(De(e));
+    } catch (r) {
+      throw this.debugLog("Error setting delivery", r), this.handleError(r), r;
+    } finally {
+      this.store.dispatch(N(!1));
+    }
+  }
+  async fetchOrder(e) {
+    this.debugLog("Fetching order from server", { orderId: e });
+    try {
+      const r = await this.sdk.findActiveOrderById({ id: e });
+      if (!r?.findOrder) {
+        this.debugLog("Order not found"), this.clearOrderFromSession();
+        return;
+      }
+      const s = r.findOrder;
+      this.debugLog("Order fetched successfully", s);
+      const n = s.items, i = n.filter((c) => c.product != null && c.amount > 0).map((c) => {
+        let E = v.PRODUCT;
+        return c.product.type === "PROMOTER" ? E = v.ADD_ONS : c.product.type === "PICKUP" ? E = v.PICKUP : c.product.type === "DELIVERY" && (E = v.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((f) => ({
+            id: f.id,
+            label: f.label
+          }))
+        };
+      }), a = n.filter((c) => c.packageItem != null && c.amount > 0).reduce((c, E) => {
+        const {
+          packageItem: f,
+          event: T,
+          amount: g,
+          price: y,
+          serviceFee: z,
+          depositPrice: H,
+          originalPrice: Q
+        } = E, O = f.package.id;
+        c[O] ? (c[O].price += y ?? 0, c[O].serviceFee += z ?? 0, c[O].originalPrice += Q ?? 0, c[O].depositPrice += H ?? y ?? 0) : c[O] = {
+          id: O,
+          type: v.PACKAGE,
+          name: f.package.name,
+          amount: g,
+          price: y ?? 0,
+          serviceFee: z ?? 0,
+          depositPrice: H ?? y ?? 0,
+          originalPrice: Q ?? 0,
+          packageItems: []
+        };
+        const xe = x.fromISO(T.startAt, {
+          zone: T.timezone
+        }), ve = x.fromISO(T.endAt, {
+          zone: T.timezone
+        });
+        return c[O].packageItems.push({
+          packageItemId: f.id,
+          eventId: T.id,
+          name: T.name,
+          startAt: xe,
+          endAt: ve
+        }), c;
+      }, {}), u = [
+        ...i,
+        ...Object.values(a)
+      ];
+      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 p = x.fromMillis(Math.min(...l));
+      this.store.dispatch(Z()), this.store.dispatch(
+        $({
+          id: s.id,
+          currency: s.currency,
+          expiredAt: p.toISO()
+        })
+      ), u.forEach((c) => {
+        c.type === v.PACKAGE ? this.store.dispatch(
+          K({
+            input: {
+              id: c.id,
+              name: c.name,
+              currency: s.currency,
+              price: c.originalPrice ?? 0,
+              depositPrice: c.depositPrice,
+              serviceFee: c.serviceFee ?? 0,
+              amount: c.amount,
+              items: c.packageItems || []
+            },
+            amountReserved: c.amount,
+            expiredAt: p.toISO()
+          })
+        ) : this.store.dispatch(
+          X({
+            input: {
+              id: c.id,
+              name: c.name,
+              price: c.originalPrice,
+              depositPrice: c.depositPrice,
+              serviceFee: c.serviceFee,
+              currency: s.currency,
+              amount: c.amount
+            },
+            amountReserved: c.amount,
+            expiredAt: p.toISO()
+          })
+        );
+      }), s.mainBooker && (this.debugLog("Order has customer (mainBooker)", s.mainBooker), this.store.dispatch(
+        W({
+          firstName: s.mainBooker.firstName ?? void 0,
+          lastName: s.mainBooker.lastName ?? void 0,
+          email: s.mainBooker.email ?? void 0,
+          age: s.mainBooker.age ?? void 0
+        })
+      )), this.debugLog("Order state fully synced", this.getState());
+    } catch (r) {
+      throw this.debugLog("Error fetching order", r), r;
+    }
+  }
+  async createCustomer(e) {
+    const s = this.store.getState().basket.order;
+    if (!s)
+      throw new Error("No active order. Add items to basket first.");
+    await this.fetchOrder(s.id);
+    const n = this.store.getState().basket;
+    if (n.order?.customer)
+      throw this.debugLog("Order already has a customer after fetching", n.order.customer), new Error("Order already has a customer associated with it.");
+    this.debugLog("Creating customer", {
+      orderId: s.id,
+      email: e.email,
+      orderHasItems: s.items.length > 0
+    });
+    try {
+      const i = await this.sdk.createOrderCustomer({
+        orderId: s.id,
+        customer: e
+      });
+      this.debugLog("Customer created successfully", i), this.store.dispatch(W(e));
+    } catch (i) {
+      throw this.debugLog("Failed to create customer", {
+        error: i.message,
+        response: i.response,
+        graphQLErrors: i.response?.errors
+      }), new Error(`Failed to create customer: ${i.message}`);
+    }
+  }
+  async cancelOrder() {
+    const e = this.getOrderId();
+    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(Z());
+  }
+  handleError(e) {
+    const r = e;
+    if (r.graphQLErrors && r.graphQLErrors.length > 0) {
+      const s = r.graphQLErrors[0];
+      s.extensions?.status === "RATE_LIMIT" && console.error("Rate Limit reached"), s.extensions?.status === "SOLD_OUT" && console.error("Product sold out");
+    }
+    if (r.response?.errors && r.response.errors.length > 0) {
+      const s = r.response.errors[0];
+      console.error("GraphQL Error:", s.message), s.extensions?.code && console.error("Error Code:", s.extensions.code);
+    }
+  }
+}
+export {
+  v as BasketOrderType,
+  jt as BasketService,
+  Vt as EventService,
+  Ft as PaymentMethodFeeType,
+  Gt as PaymentService,
+  Lt as ProductType
+};