@launchdarkly/o11y 0.0.0-stage → 1.2.0

package/dist/common-DQ61tUu9.js

@@ -0,0 +1,4587 @@
+var tn = Object.defineProperty, nn = Object.defineProperties;
+var rn = Object.getOwnPropertyDescriptors;
+var ce = Object.getOwnPropertySymbols;
+var rt = Object.prototype.hasOwnProperty, it = Object.prototype.propertyIsEnumerable;
+var Oe = (e, t) => (t = Symbol[e]) ? t : Symbol.for("Symbol." + e), sn = (e) => {
+  throw TypeError(e);
+};
+var De = (e, t, n) => t in e ? tn(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n, _ = (e, t) => {
+  for (var n in t || (t = {}))
+    rt.call(t, n) && De(e, n, t[n]);
+  if (ce)
+    for (var n of ce(t))
+      it.call(t, n) && De(e, n, t[n]);
+  return e;
+}, q = (e, t) => nn(e, rn(t));
+var H = (e, t) => {
+  var n = {};
+  for (var r in e)
+    rt.call(e, r) && t.indexOf(r) < 0 && (n[r] = e[r]);
+  if (e != null && ce)
+    for (var r of ce(e))
+      t.indexOf(r) < 0 && it.call(e, r) && (n[r] = e[r]);
+  return n;
+};
+var G = (e, t, n) => De(e, typeof t != "symbol" ? t + "" : t, n);
+var U = (e, t, n) => new Promise((r, i) => {
+  var s = (c) => {
+    try {
+      a(n.next(c));
+    } catch (f) {
+      i(f);
+    }
+  }, o = (c) => {
+    try {
+      a(n.throw(c));
+    } catch (f) {
+      i(f);
+    }
+  }, a = (c) => c.done ? r(c.value) : Promise.resolve(c.value).then(s, o);
+  a((n = n.apply(e, t)).next());
+}), on = function(e, t) {
+  this[0] = e, this[1] = t;
+};
+var we = (e) => {
+  var t = e[Oe("asyncIterator")], n = !1, r, i = {};
+  return t == null ? (t = e[Oe("iterator")](), r = (s) => i[s] = (o) => t[s](o)) : (t = t.call(e), r = (s) => i[s] = (o) => {
+    if (n) {
+      if (n = !1, s === "throw") throw o;
+      return o;
+    }
+    return n = !0, {
+      done: !1,
+      value: new on(new Promise((a) => {
+        var c = t[s](o);
+        c instanceof Object || sn("Object expected"), a(c);
+      }), 1)
+    };
+  }), i[Oe("iterator")] = () => i, r("next"), "throw" in t ? r("throw") : i.throw = (s) => {
+    throw s;
+  }, "return" in t && r("return"), i;
+};
+import { a as K, B as an, i as st } from "./buffer-DIFxvF2Q.js";
+function de(e, t) {
+  if (!!!e)
+    throw new Error(t);
+}
+function cn(e) {
+  return typeof e == "object" && e !== null;
+}
+function un(e, t) {
+  if (!!!e)
+    throw new Error(
+      "Unexpected invariant triggered."
+    );
+}
+const ln = /\r\n|[\n\r]/g;
+function Ue(e, t) {
+  let n = 0, r = 1;
+  for (const i of e.body.matchAll(ln)) {
+    if (typeof i.index == "number" || un(!1), i.index >= t)
+      break;
+    n = i.index + i[0].length, r += 1;
+  }
+  return {
+    line: r,
+    column: t + 1 - n
+  };
+}
+function fn(e) {
+  return At(
+    e.source,
+    Ue(e.source, e.start)
+  );
+}
+function At(e, t) {
+  const n = e.locationOffset.column - 1, r = "".padStart(n) + e.body, i = t.line - 1, s = e.locationOffset.line - 1, o = t.line + s, a = t.line === 1 ? n : 0, c = t.column + a, f = `${e.name}:${o}:${c}
+`, h = r.split(/\r\n|[\n\r]/g), m = h[i];
+  if (m.length > 120) {
+    const E = Math.floor(c / 80), S = c % 80, y = [];
+    for (let N = 0; N < m.length; N += 80)
+      y.push(m.slice(N, N + 80));
+    return f + ot([
+      [`${o} |`, y[0]],
+      ...y.slice(1, E + 1).map((N) => ["|", N]),
+      ["|", "^".padStart(S)],
+      ["|", y[E + 1]]
+    ]);
+  }
+  return f + ot([
+    // Lines specified like this: ["prefix", "string"],
+    [`${o - 1} |`, h[i - 1]],
+    [`${o} |`, m],
+    ["|", "^".padStart(c)],
+    [`${o + 1} |`, h[i + 1]]
+  ]);
+}
+function ot(e) {
+  const t = e.filter(([r, i]) => i !== void 0), n = Math.max(...t.map(([r]) => r.length));
+  return t.map(([r, i]) => r.padStart(n) + (i ? " " + i : "")).join(`
+`);
+}
+function hn(e) {
+  const t = e[0];
+  return t == null || "kind" in t || "length" in t ? {
+    nodes: t,
+    source: e[1],
+    positions: e[2],
+    path: e[3],
+    originalError: e[4],
+    extensions: e[5]
+  } : t;
+}
+class Qe 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(t, ...n) {
+    var r, i, s;
+    const { nodes: o, source: a, positions: c, path: f, originalError: h, extensions: m } = hn(n);
+    super(t), this.name = "GraphQLError", this.path = f != null ? f : void 0, this.originalError = h != null ? h : void 0, this.nodes = at(
+      Array.isArray(o) ? o : o ? [o] : void 0
+    );
+    const E = at(
+      (r = this.nodes) === null || r === void 0 ? void 0 : r.map((y) => y.loc).filter((y) => y != null)
+    );
+    this.source = a != null ? a : E == null || (i = E[0]) === null || i === void 0 ? void 0 : i.source, this.positions = c != null ? c : E == null ? void 0 : E.map((y) => y.start), this.locations = c && a ? c.map((y) => Ue(a, y)) : E == null ? void 0 : E.map((y) => Ue(y.source, y.start));
+    const S = cn(
+      h == null ? void 0 : h.extensions
+    ) ? h == null ? void 0 : h.extensions : void 0;
+    this.extensions = (s = m != null ? m : S) !== null && s !== void 0 ? s : /* @__PURE__ */ Object.create(null), Object.defineProperties(this, {
+      message: {
+        writable: !0,
+        enumerable: !0
+      },
+      name: {
+        enumerable: !1
+      },
+      nodes: {
+        enumerable: !1
+      },
+      source: {
+        enumerable: !1
+      },
+      positions: {
+        enumerable: !1
+      },
+      originalError: {
+        enumerable: !1
+      }
+    }), h != null && h.stack ? Object.defineProperty(this, "stack", {
+      value: h.stack,
+      writable: !0,
+      configurable: !0
+    }) : Error.captureStackTrace ? Error.captureStackTrace(this, Qe) : Object.defineProperty(this, "stack", {
+      value: Error().stack,
+      writable: !0,
+      configurable: !0
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "GraphQLError";
+  }
+  toString() {
+    let t = this.message;
+    if (this.nodes)
+      for (const n of this.nodes)
+        n.loc && (t += `
+
+` + fn(n.loc));
+    else if (this.source && this.locations)
+      for (const n of this.locations)
+        t += `
+
+` + At(this.source, n);
+    return t;
+  }
+  toJSON() {
+    const t = {
+      message: this.message
+    };
+    return this.locations != null && (t.locations = this.locations), this.path != null && (t.path = this.path), this.extensions != null && Object.keys(this.extensions).length > 0 && (t.extensions = this.extensions), t;
+  }
+}
+function at(e) {
+  return e === void 0 || e.length === 0 ? void 0 : e;
+}
+function O(e, t, n) {
+  return new Qe(`Syntax Error: ${n}`, {
+    source: e,
+    positions: [t]
+  });
+}
+class dn {
+  /**
+   * 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(t, n, r) {
+    this.start = t.start, this.end = n.end, this.startToken = t, this.endToken = n, this.source = r;
+  }
+  get [Symbol.toStringTag]() {
+    return "Location";
+  }
+  toJSON() {
+    return {
+      start: this.start,
+      end: this.end
+    };
+  }
+}
+class Nt {
+  /**
+   * 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(t, n, r, i, s, o) {
+    this.kind = t, this.start = n, this.end = r, this.line = i, this.column = s, this.value = o, this.prev = null, this.next = null;
+  }
+  get [Symbol.toStringTag]() {
+    return "Token";
+  }
+  toJSON() {
+    return {
+      kind: this.kind,
+      value: this.value,
+      line: this.line,
+      column: this.column
+    };
+  }
+}
+const It = {
+  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"]
+}, pn = new Set(Object.keys(It));
+function ct(e) {
+  const t = e == null ? void 0 : e.kind;
+  return typeof t == "string" && pn.has(t);
+}
+var J;
+(function(e) {
+  e.QUERY = "query", e.MUTATION = "mutation", e.SUBSCRIPTION = "subscription";
+})(J || (J = {}));
+var Be;
+(function(e) {
+  e.QUERY = "QUERY", e.MUTATION = "MUTATION", e.SUBSCRIPTION = "SUBSCRIPTION", e.FIELD = "FIELD", e.FRAGMENT_DEFINITION = "FRAGMENT_DEFINITION", e.FRAGMENT_SPREAD = "FRAGMENT_SPREAD", e.INLINE_FRAGMENT = "INLINE_FRAGMENT", e.VARIABLE_DEFINITION = "VARIABLE_DEFINITION", e.SCHEMA = "SCHEMA", e.SCALAR = "SCALAR", e.OBJECT = "OBJECT", e.FIELD_DEFINITION = "FIELD_DEFINITION", e.ARGUMENT_DEFINITION = "ARGUMENT_DEFINITION", e.INTERFACE = "INTERFACE", e.UNION = "UNION", e.ENUM = "ENUM", e.ENUM_VALUE = "ENUM_VALUE", e.INPUT_OBJECT = "INPUT_OBJECT", e.INPUT_FIELD_DEFINITION = "INPUT_FIELD_DEFINITION";
+})(Be || (Be = {}));
+var g;
+(function(e) {
+  e.NAME = "Name", e.DOCUMENT = "Document", e.OPERATION_DEFINITION = "OperationDefinition", e.VARIABLE_DEFINITION = "VariableDefinition", e.SELECTION_SET = "SelectionSet", e.FIELD = "Field", e.ARGUMENT = "Argument", e.FRAGMENT_SPREAD = "FragmentSpread", e.INLINE_FRAGMENT = "InlineFragment", e.FRAGMENT_DEFINITION = "FragmentDefinition", e.VARIABLE = "Variable", e.INT = "IntValue", e.FLOAT = "FloatValue", e.STRING = "StringValue", e.BOOLEAN = "BooleanValue", e.NULL = "NullValue", e.ENUM = "EnumValue", e.LIST = "ListValue", e.OBJECT = "ObjectValue", e.OBJECT_FIELD = "ObjectField", e.DIRECTIVE = "Directive", e.NAMED_TYPE = "NamedType", e.LIST_TYPE = "ListType", e.NON_NULL_TYPE = "NonNullType", e.SCHEMA_DEFINITION = "SchemaDefinition", e.OPERATION_TYPE_DEFINITION = "OperationTypeDefinition", e.SCALAR_TYPE_DEFINITION = "ScalarTypeDefinition", e.OBJECT_TYPE_DEFINITION = "ObjectTypeDefinition", e.FIELD_DEFINITION = "FieldDefinition", e.INPUT_VALUE_DEFINITION = "InputValueDefinition", e.INTERFACE_TYPE_DEFINITION = "InterfaceTypeDefinition", e.UNION_TYPE_DEFINITION = "UnionTypeDefinition", e.ENUM_TYPE_DEFINITION = "EnumTypeDefinition", e.ENUM_VALUE_DEFINITION = "EnumValueDefinition", e.INPUT_OBJECT_TYPE_DEFINITION = "InputObjectTypeDefinition", e.DIRECTIVE_DEFINITION = "DirectiveDefinition", e.SCHEMA_EXTENSION = "SchemaExtension", e.SCALAR_TYPE_EXTENSION = "ScalarTypeExtension", e.OBJECT_TYPE_EXTENSION = "ObjectTypeExtension", e.INTERFACE_TYPE_EXTENSION = "InterfaceTypeExtension", e.UNION_TYPE_EXTENSION = "UnionTypeExtension", e.ENUM_TYPE_EXTENSION = "EnumTypeExtension", e.INPUT_OBJECT_TYPE_EXTENSION = "InputObjectTypeExtension";
+})(g || (g = {}));
+function Ve(e) {
+  return e === 9 || e === 32;
+}
+function ie(e) {
+  return e >= 48 && e <= 57;
+}
+function bt(e) {
+  return e >= 97 && e <= 122 || // A-Z
+  e >= 65 && e <= 90;
+}
+function xt(e) {
+  return bt(e) || e === 95;
+}
+function mn(e) {
+  return bt(e) || ie(e) || e === 95;
+}
+function gn(e) {
+  var t;
+  let n = Number.MAX_SAFE_INTEGER, r = null, i = -1;
+  for (let o = 0; o < e.length; ++o) {
+    var s;
+    const a = e[o], c = yn(a);
+    c !== a.length && (r = (s = r) !== null && s !== void 0 ? s : o, i = o, o !== 0 && c < n && (n = c));
+  }
+  return e.map((o, a) => a === 0 ? o : o.slice(n)).slice(
+    (t = r) !== null && t !== void 0 ? t : 0,
+    i + 1
+  );
+}
+function yn(e) {
+  let t = 0;
+  for (; t < e.length && Ve(e.charCodeAt(t)); )
+    ++t;
+  return t;
+}
+function En(e, t) {
+  const n = e.replace(/"""/g, '\\"""'), r = n.split(/\r\n|[\n\r]/g), i = r.length === 1, s = r.length > 1 && r.slice(1).every((S) => S.length === 0 || Ve(S.charCodeAt(0))), o = n.endsWith('\\"""'), a = e.endsWith('"') && !o, c = e.endsWith("\\"), f = a || c, h = (
+    // add leading and trailing new lines only if it improves readability
+    !i || e.length > 70 || f || s || o
+  );
+  let m = "";
+  const E = i && Ve(e.charCodeAt(0));
+  return (h && !E || s) && (m += `
+`), m += n, (h || f) && (m += `
+`), '"""' + m + '"""';
+}
+var l;
+(function(e) {
+  e.SOF = "<SOF>", e.EOF = "<EOF>", e.BANG = "!", e.DOLLAR = "$", e.AMP = "&", e.PAREN_L = "(", e.PAREN_R = ")", e.SPREAD = "...", e.COLON = ":", e.EQUALS = "=", e.AT = "@", e.BRACKET_L = "[", e.BRACKET_R = "]", e.BRACE_L = "{", e.PIPE = "|", e.BRACE_R = "}", e.NAME = "Name", e.INT = "Int", e.FLOAT = "Float", e.STRING = "String", e.BLOCK_STRING = "BlockString", e.COMMENT = "Comment";
+})(l || (l = {}));
+class _n {
+  /**
+   * 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(t) {
+    const n = new Nt(l.SOF, 0, 0, 0, 0);
+    this.source = t, this.lastToken = n, this.token = n, this.line = 1, this.lineStart = 0;
+  }
+  get [Symbol.toStringTag]() {
+    return "Lexer";
+  }
+  /**
+   * 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 t = this.token;
+    if (t.kind !== l.EOF)
+      do
+        if (t.next)
+          t = t.next;
+        else {
+          const n = vn(this, t.end);
+          t.next = n, n.prev = t, t = n;
+        }
+      while (t.kind === l.COMMENT);
+    return t;
+  }
+}
+function Tn(e) {
+  return e === l.BANG || e === l.DOLLAR || e === l.AMP || e === l.PAREN_L || e === l.PAREN_R || e === l.SPREAD || e === l.COLON || e === l.EQUALS || e === l.AT || e === l.BRACKET_L || e === l.BRACKET_R || e === l.BRACE_L || e === l.PIPE || e === l.BRACE_R;
+}
+function Z(e) {
+  return e >= 0 && e <= 55295 || e >= 57344 && e <= 1114111;
+}
+function ve(e, t) {
+  return Ot(e.charCodeAt(t)) && Dt(e.charCodeAt(t + 1));
+}
+function Ot(e) {
+  return e >= 55296 && e <= 56319;
+}
+function Dt(e) {
+  return e >= 56320 && e <= 57343;
+}
+function B(e, t) {
+  const n = e.source.body.codePointAt(t);
+  if (n === void 0)
+    return l.EOF;
+  if (n >= 32 && n <= 126) {
+    const r = String.fromCodePoint(n);
+    return r === '"' ? `'"'` : `"${r}"`;
+  }
+  return "U+" + n.toString(16).toUpperCase().padStart(4, "0");
+}
+function I(e, t, n, r, i) {
+  const s = e.line, o = 1 + n - e.lineStart;
+  return new Nt(t, n, r, s, o, i);
+}
+function vn(e, t) {
+  const n = e.source.body, r = n.length;
+  let i = t;
+  for (; i < r; ) {
+    const s = n.charCodeAt(i);
+    switch (s) {
+      // Ignored ::
+      //   - UnicodeBOM
+      //   - WhiteSpace
+      //   - LineTerminator
+      //   - Comment
+      //   - Comma
+      //
+      // UnicodeBOM :: "Byte Order Mark (U+FEFF)"
+      //
+      // WhiteSpace ::
+      //   - "Horizontal Tab (U+0009)"
+      //   - "Space (U+0020)"
+      //
+      // Comma :: ,
+      case 65279:
+      // <BOM>
+      case 9:
+      // \t
+      case 32:
+      // <space>
+      case 44:
+        ++i;
+        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:
+        ++i, ++e.line, e.lineStart = i;
+        continue;
+      case 13:
+        n.charCodeAt(i + 1) === 10 ? i += 2 : ++i, ++e.line, e.lineStart = i;
+        continue;
+      // Comment
+      case 35:
+        return Sn(e, i);
+      // Token ::
+      //   - Punctuator
+      //   - Name
+      //   - IntValue
+      //   - FloatValue
+      //   - StringValue
+      //
+      // Punctuator :: one of ! $ & ( ) ... : = @ [ ] { | }
+      case 33:
+        return I(e, l.BANG, i, i + 1);
+      case 36:
+        return I(e, l.DOLLAR, i, i + 1);
+      case 38:
+        return I(e, l.AMP, i, i + 1);
+      case 40:
+        return I(e, l.PAREN_L, i, i + 1);
+      case 41:
+        return I(e, l.PAREN_R, i, i + 1);
+      case 46:
+        if (n.charCodeAt(i + 1) === 46 && n.charCodeAt(i + 2) === 46)
+          return I(e, l.SPREAD, i, i + 3);
+        break;
+      case 58:
+        return I(e, l.COLON, i, i + 1);
+      case 61:
+        return I(e, l.EQUALS, i, i + 1);
+      case 64:
+        return I(e, l.AT, i, i + 1);
+      case 91:
+        return I(e, l.BRACKET_L, i, i + 1);
+      case 93:
+        return I(e, l.BRACKET_R, i, i + 1);
+      case 123:
+        return I(e, l.BRACE_L, i, i + 1);
+      case 124:
+        return I(e, l.PIPE, i, i + 1);
+      case 125:
+        return I(e, l.BRACE_R, i, i + 1);
+      // StringValue
+      case 34:
+        return n.charCodeAt(i + 1) === 34 && n.charCodeAt(i + 2) === 34 ? On(e, i) : Nn(e, i);
+    }
+    if (ie(s) || s === 45)
+      return An(e, i, s);
+    if (xt(s))
+      return Dn(e, i);
+    throw O(
+      e.source,
+      i,
+      s === 39 ? `Unexpected single quote character ('), did you mean to use a double quote (")?` : Z(s) || ve(n, i) ? `Unexpected character: ${B(e, i)}.` : `Invalid character: ${B(e, i)}.`
+    );
+  }
+  return I(e, l.EOF, r, r);
+}
+function Sn(e, t) {
+  const n = e.source.body, r = n.length;
+  let i = t + 1;
+  for (; i < r; ) {
+    const s = n.charCodeAt(i);
+    if (s === 10 || s === 13)
+      break;
+    if (Z(s))
+      ++i;
+    else if (ve(n, i))
+      i += 2;
+    else
+      break;
+  }
+  return I(
+    e,
+    l.COMMENT,
+    t,
+    i,
+    n.slice(t + 1, i)
+  );
+}
+function An(e, t, n) {
+  const r = e.source.body;
+  let i = t, s = n, o = !1;
+  if (s === 45 && (s = r.charCodeAt(++i)), s === 48) {
+    if (s = r.charCodeAt(++i), ie(s))
+      throw O(
+        e.source,
+        i,
+        `Invalid number, unexpected digit after 0: ${B(
+          e,
+          i
+        )}.`
+      );
+  } else
+    i = Ce(e, i, s), s = r.charCodeAt(i);
+  if (s === 46 && (o = !0, s = r.charCodeAt(++i), i = Ce(e, i, s), s = r.charCodeAt(i)), (s === 69 || s === 101) && (o = !0, s = r.charCodeAt(++i), (s === 43 || s === 45) && (s = r.charCodeAt(++i)), i = Ce(e, i, s), s = r.charCodeAt(i)), s === 46 || xt(s))
+    throw O(
+      e.source,
+      i,
+      `Invalid number, expected digit but got: ${B(
+        e,
+        i
+      )}.`
+    );
+  return I(
+    e,
+    o ? l.FLOAT : l.INT,
+    t,
+    i,
+    r.slice(t, i)
+  );
+}
+function Ce(e, t, n) {
+  if (!ie(n))
+    throw O(
+      e.source,
+      t,
+      `Invalid number, expected digit but got: ${B(
+        e,
+        t
+      )}.`
+    );
+  const r = e.source.body;
+  let i = t + 1;
+  for (; ie(r.charCodeAt(i)); )
+    ++i;
+  return i;
+}
+function Nn(e, t) {
+  const n = e.source.body, r = n.length;
+  let i = t + 1, s = i, o = "";
+  for (; i < r; ) {
+    const a = n.charCodeAt(i);
+    if (a === 34)
+      return o += n.slice(s, i), I(e, l.STRING, t, i + 1, o);
+    if (a === 92) {
+      o += n.slice(s, i);
+      const c = n.charCodeAt(i + 1) === 117 ? n.charCodeAt(i + 2) === 123 ? In(e, i) : bn(e, i) : xn(e, i);
+      o += c.value, i += c.size, s = i;
+      continue;
+    }
+    if (a === 10 || a === 13)
+      break;
+    if (Z(a))
+      ++i;
+    else if (ve(n, i))
+      i += 2;
+    else
+      throw O(
+        e.source,
+        i,
+        `Invalid character within String: ${B(
+          e,
+          i
+        )}.`
+      );
+  }
+  throw O(e.source, i, "Unterminated string.");
+}
+function In(e, t) {
+  const n = e.source.body;
+  let r = 0, i = 3;
+  for (; i < 12; ) {
+    const s = n.charCodeAt(t + i++);
+    if (s === 125) {
+      if (i < 5 || !Z(r))
+        break;
+      return {
+        value: String.fromCodePoint(r),
+        size: i
+      };
+    }
+    if (r = r << 4 | re(s), r < 0)
+      break;
+  }
+  throw O(
+    e.source,
+    t,
+    `Invalid Unicode escape sequence: "${n.slice(
+      t,
+      t + i
+    )}".`
+  );
+}
+function bn(e, t) {
+  const n = e.source.body, r = ut(n, t + 2);
+  if (Z(r))
+    return {
+      value: String.fromCodePoint(r),
+      size: 6
+    };
+  if (Ot(r) && n.charCodeAt(t + 6) === 92 && n.charCodeAt(t + 7) === 117) {
+    const i = ut(n, t + 8);
+    if (Dt(i))
+      return {
+        value: String.fromCodePoint(r, i),
+        size: 12
+      };
+  }
+  throw O(
+    e.source,
+    t,
+    `Invalid Unicode escape sequence: "${n.slice(t, t + 6)}".`
+  );
+}
+function ut(e, t) {
+  return re(e.charCodeAt(t)) << 12 | re(e.charCodeAt(t + 1)) << 8 | re(e.charCodeAt(t + 2)) << 4 | re(e.charCodeAt(t + 3));
+}
+function re(e) {
+  return e >= 48 && e <= 57 ? e - 48 : e >= 65 && e <= 70 ? e - 55 : e >= 97 && e <= 102 ? e - 87 : -1;
+}
+function xn(e, t) {
+  const n = e.source.body;
+  switch (n.charCodeAt(t + 1)) {
+    case 34:
+      return {
+        value: '"',
+        size: 2
+      };
+    case 92:
+      return {
+        value: "\\",
+        size: 2
+      };
+    case 47:
+      return {
+        value: "/",
+        size: 2
+      };
+    case 98:
+      return {
+        value: "\b",
+        size: 2
+      };
+    case 102:
+      return {
+        value: "\f",
+        size: 2
+      };
+    case 110:
+      return {
+        value: `
+`,
+        size: 2
+      };
+    case 114:
+      return {
+        value: "\r",
+        size: 2
+      };
+    case 116:
+      return {
+        value: "	",
+        size: 2
+      };
+  }
+  throw O(
+    e.source,
+    t,
+    `Invalid character escape sequence: "${n.slice(
+      t,
+      t + 2
+    )}".`
+  );
+}
+function On(e, t) {
+  const n = e.source.body, r = n.length;
+  let i = e.lineStart, s = t + 3, o = s, a = "";
+  const c = [];
+  for (; s < r; ) {
+    const f = n.charCodeAt(s);
+    if (f === 34 && n.charCodeAt(s + 1) === 34 && n.charCodeAt(s + 2) === 34) {
+      a += n.slice(o, s), c.push(a);
+      const h = I(
+        e,
+        l.BLOCK_STRING,
+        t,
+        s + 3,
+        // Return a string of the lines joined with U+000A.
+        gn(c).join(`
+`)
+      );
+      return e.line += c.length - 1, e.lineStart = i, h;
+    }
+    if (f === 92 && n.charCodeAt(s + 1) === 34 && n.charCodeAt(s + 2) === 34 && n.charCodeAt(s + 3) === 34) {
+      a += n.slice(o, s), o = s + 1, s += 4;
+      continue;
+    }
+    if (f === 10 || f === 13) {
+      a += n.slice(o, s), c.push(a), f === 13 && n.charCodeAt(s + 1) === 10 ? s += 2 : ++s, a = "", o = s, i = s;
+      continue;
+    }
+    if (Z(f))
+      ++s;
+    else if (ve(n, s))
+      s += 2;
+    else
+      throw O(
+        e.source,
+        s,
+        `Invalid character within String: ${B(
+          e,
+          s
+        )}.`
+      );
+  }
+  throw O(e.source, s, "Unterminated string.");
+}
+function Dn(e, t) {
+  const n = e.source.body, r = n.length;
+  let i = t + 1;
+  for (; i < r; ) {
+    const s = n.charCodeAt(i);
+    if (mn(s))
+      ++i;
+    else
+      break;
+  }
+  return I(
+    e,
+    l.NAME,
+    t,
+    i,
+    n.slice(t, i)
+  );
+}
+const wn = 10, wt = 2;
+function Ke(e) {
+  return Se(e, []);
+}
+function Se(e, t) {
+  switch (typeof e) {
+    case "string":
+      return JSON.stringify(e);
+    case "function":
+      return e.name ? `[function ${e.name}]` : "[function]";
+    case "object":
+      return Cn(e, t);
+    default:
+      return String(e);
+  }
+}
+function Cn(e, t) {
+  if (e === null)
+    return "null";
+  if (t.includes(e))
+    return "[Circular]";
+  const n = [...t, e];
+  if (Rn(e)) {
+    const r = e.toJSON();
+    if (r !== e)
+      return typeof r == "string" ? r : Se(r, n);
+  } else if (Array.isArray(e))
+    return Ln(e, n);
+  return kn(e, n);
+}
+function Rn(e) {
+  return typeof e.toJSON == "function";
+}
+function kn(e, t) {
+  const n = Object.entries(e);
+  return n.length === 0 ? "{}" : t.length > wt ? "[" + Pn(e) + "]" : "{ " + n.map(
+    ([i, s]) => i + ": " + Se(s, t)
+  ).join(", ") + " }";
+}
+function Ln(e, t) {
+  if (e.length === 0)
+    return "[]";
+  if (t.length > wt)
+    return "[Array]";
+  const n = Math.min(wn, e.length), r = e.length - n, i = [];
+  for (let s = 0; s < n; ++s)
+    i.push(Se(e[s], t));
+  return r === 1 ? i.push("... 1 more item") : r > 1 && i.push(`... ${r} more items`), "[" + i.join(", ") + "]";
+}
+function Pn(e) {
+  const t = Object.prototype.toString.call(e).replace(/^\[object /, "").replace(/]$/, "");
+  if (t === "Object" && typeof e.constructor == "function") {
+    const n = e.constructor.name;
+    if (typeof n == "string" && n !== "")
+      return n;
+  }
+  return t;
+}
+const Fn = globalThis.process && // eslint-disable-next-line no-undef
+process.env.NODE_ENV === "production", Mn = (
+  /* c8 ignore next 6 */
+  // FIXME: https://github.com/graphql/graphql-js/issues/2317
+  Fn ? function(t, n) {
+    return t instanceof n;
+  } : function(t, n) {
+    if (t instanceof n)
+      return !0;
+    if (typeof t == "object" && t !== null) {
+      var r;
+      const i = n.prototype[Symbol.toStringTag], s = (
+        // We still need to support constructor's name to detect conflicts with older versions of this library.
+        Symbol.toStringTag in t ? t[Symbol.toStringTag] : (r = t.constructor) === null || r === void 0 ? void 0 : r.name
+      );
+      if (i === s) {
+        const o = Ke(t);
+        throw new Error(`Cannot use ${i} "${o}" from another module or realm.
+
+Ensure that there is only one instance of "graphql" in the node_modules
+directory. If different versions of "graphql" are the dependencies of other
+relied on modules, use "resolutions" to ensure only one version is installed.
+
+https://yarnpkg.com/en/docs/selective-version-resolutions
+
+Duplicate "graphql" modules cannot be used at the same time since different
+versions may have different capabilities and behavior. The data from one
+version used in the function from another could produce confusing and
+spurious results.`);
+      }
+    }
+    return !1;
+  }
+);
+class Ct {
+  constructor(t, n = "GraphQL request", r = {
+    line: 1,
+    column: 1
+  }) {
+    typeof t == "string" || de(!1, `Body must be a string. Received: ${Ke(t)}.`), this.body = t, this.name = n, this.locationOffset = r, this.locationOffset.line > 0 || de(
+      !1,
+      "line in locationOffset is 1-indexed and must be positive."
+    ), this.locationOffset.column > 0 || de(
+      !1,
+      "column in locationOffset is 1-indexed and must be positive."
+    );
+  }
+  get [Symbol.toStringTag]() {
+    return "Source";
+  }
+}
+function $n(e) {
+  return Mn(e, Ct);
+}
+function Rt(e, t) {
+  const n = new Un(e, t), r = n.parseDocument();
+  return Object.defineProperty(r, "tokenCount", {
+    enumerable: !1,
+    value: n.tokenCount
+  }), r;
+}
+class Un {
+  constructor(t, n = {}) {
+    const r = $n(t) ? t : new Ct(t);
+    this._lexer = new _n(r), this._options = n, this._tokenCounter = 0;
+  }
+  get tokenCount() {
+    return this._tokenCounter;
+  }
+  /**
+   * Converts a name lex token into a name parse node.
+   */
+  parseName() {
+    const t = this.expectToken(l.NAME);
+    return this.node(t, {
+      kind: g.NAME,
+      value: t.value
+    });
+  }
+  // Implements the parsing rules in the Document section.
+  /**
+   * Document : Definition+
+   */
+  parseDocument() {
+    return this.node(this._lexer.token, {
+      kind: g.DOCUMENT,
+      definitions: this.many(
+        l.SOF,
+        this.parseDefinition,
+        l.EOF
+      )
+    });
+  }
+  /**
+   * Definition :
+   *   - ExecutableDefinition
+   *   - TypeSystemDefinition
+   *   - TypeSystemExtension
+   *
+   * ExecutableDefinition :
+   *   - OperationDefinition
+   *   - FragmentDefinition
+   *
+   * TypeSystemDefinition :
+   *   - SchemaDefinition
+   *   - TypeDefinition
+   *   - DirectiveDefinition
+   *
+   * TypeDefinition :
+   *   - ScalarTypeDefinition
+   *   - ObjectTypeDefinition
+   *   - InterfaceTypeDefinition
+   *   - UnionTypeDefinition
+   *   - EnumTypeDefinition
+   *   - InputObjectTypeDefinition
+   */
+  parseDefinition() {
+    if (this.peek(l.BRACE_L))
+      return this.parseOperationDefinition();
+    const t = this.peekDescription(), n = t ? this._lexer.lookahead() : this._lexer.token;
+    if (n.kind === l.NAME) {
+      switch (n.value) {
+        case "schema":
+          return this.parseSchemaDefinition();
+        case "scalar":
+          return this.parseScalarTypeDefinition();
+        case "type":
+          return this.parseObjectTypeDefinition();
+        case "interface":
+          return this.parseInterfaceTypeDefinition();
+        case "union":
+          return this.parseUnionTypeDefinition();
+        case "enum":
+          return this.parseEnumTypeDefinition();
+        case "input":
+          return this.parseInputObjectTypeDefinition();
+        case "directive":
+          return this.parseDirectiveDefinition();
+      }
+      if (t)
+        throw O(
+          this._lexer.source,
+          this._lexer.token.start,
+          "Unexpected description, descriptions are supported only on type definitions."
+        );
+      switch (n.value) {
+        case "query":
+        case "mutation":
+        case "subscription":
+          return this.parseOperationDefinition();
+        case "fragment":
+          return this.parseFragmentDefinition();
+        case "extend":
+          return this.parseTypeSystemExtension();
+      }
+    }
+    throw this.unexpected(n);
+  }
+  // Implements the parsing rules in the Operations section.
+  /**
+   * OperationDefinition :
+   *  - SelectionSet
+   *  - OperationType Name? VariableDefinitions? Directives? SelectionSet
+   */
+  parseOperationDefinition() {
+    const t = this._lexer.token;
+    if (this.peek(l.BRACE_L))
+      return this.node(t, {
+        kind: g.OPERATION_DEFINITION,
+        operation: J.QUERY,
+        name: void 0,
+        variableDefinitions: [],
+        directives: [],
+        selectionSet: this.parseSelectionSet()
+      });
+    const n = this.parseOperationType();
+    let r;
+    return this.peek(l.NAME) && (r = this.parseName()), this.node(t, {
+      kind: g.OPERATION_DEFINITION,
+      operation: n,
+      name: r,
+      variableDefinitions: this.parseVariableDefinitions(),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * OperationType : one of query mutation subscription
+   */
+  parseOperationType() {
+    const t = this.expectToken(l.NAME);
+    switch (t.value) {
+      case "query":
+        return J.QUERY;
+      case "mutation":
+        return J.MUTATION;
+      case "subscription":
+        return J.SUBSCRIPTION;
+    }
+    throw this.unexpected(t);
+  }
+  /**
+   * VariableDefinitions : ( VariableDefinition+ )
+   */
+  parseVariableDefinitions() {
+    return this.optionalMany(
+      l.PAREN_L,
+      this.parseVariableDefinition,
+      l.PAREN_R
+    );
+  }
+  /**
+   * VariableDefinition : Variable : Type DefaultValue? Directives[Const]?
+   */
+  parseVariableDefinition() {
+    return this.node(this._lexer.token, {
+      kind: g.VARIABLE_DEFINITION,
+      variable: this.parseVariable(),
+      type: (this.expectToken(l.COLON), this.parseTypeReference()),
+      defaultValue: this.expectOptionalToken(l.EQUALS) ? this.parseConstValueLiteral() : void 0,
+      directives: this.parseConstDirectives()
+    });
+  }
+  /**
+   * Variable : $ Name
+   */
+  parseVariable() {
+    const t = this._lexer.token;
+    return this.expectToken(l.DOLLAR), this.node(t, {
+      kind: g.VARIABLE,
+      name: this.parseName()
+    });
+  }
+  /**
+   * ```
+   * SelectionSet : { Selection+ }
+   * ```
+   */
+  parseSelectionSet() {
+    return this.node(this._lexer.token, {
+      kind: g.SELECTION_SET,
+      selections: this.many(
+        l.BRACE_L,
+        this.parseSelection,
+        l.BRACE_R
+      )
+    });
+  }
+  /**
+   * Selection :
+   *   - Field
+   *   - FragmentSpread
+   *   - InlineFragment
+   */
+  parseSelection() {
+    return this.peek(l.SPREAD) ? this.parseFragment() : this.parseField();
+  }
+  /**
+   * Field : Alias? Name Arguments? Directives? SelectionSet?
+   *
+   * Alias : Name :
+   */
+  parseField() {
+    const t = this._lexer.token, n = this.parseName();
+    let r, i;
+    return this.expectOptionalToken(l.COLON) ? (r = n, i = this.parseName()) : i = n, this.node(t, {
+      kind: g.FIELD,
+      alias: r,
+      name: i,
+      arguments: this.parseArguments(!1),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.peek(l.BRACE_L) ? this.parseSelectionSet() : void 0
+    });
+  }
+  /**
+   * Arguments[Const] : ( Argument[?Const]+ )
+   */
+  parseArguments(t) {
+    const n = t ? this.parseConstArgument : this.parseArgument;
+    return this.optionalMany(l.PAREN_L, n, l.PAREN_R);
+  }
+  /**
+   * Argument[Const] : Name : Value[?Const]
+   */
+  parseArgument(t = !1) {
+    const n = this._lexer.token, r = this.parseName();
+    return this.expectToken(l.COLON), this.node(n, {
+      kind: g.ARGUMENT,
+      name: r,
+      value: this.parseValueLiteral(t)
+    });
+  }
+  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 t = this._lexer.token;
+    this.expectToken(l.SPREAD);
+    const n = this.expectOptionalKeyword("on");
+    return !n && this.peek(l.NAME) ? this.node(t, {
+      kind: g.FRAGMENT_SPREAD,
+      name: this.parseFragmentName(),
+      directives: this.parseDirectives(!1)
+    }) : this.node(t, {
+      kind: g.INLINE_FRAGMENT,
+      typeCondition: n ? this.parseNamedType() : void 0,
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    });
+  }
+  /**
+   * FragmentDefinition :
+   *   - fragment FragmentName on TypeCondition Directives? SelectionSet
+   *
+   * TypeCondition : NamedType
+   */
+  parseFragmentDefinition() {
+    const t = this._lexer.token;
+    return this.expectKeyword("fragment"), this._options.allowLegacyFragmentVariables === !0 ? this.node(t, {
+      kind: g.FRAGMENT_DEFINITION,
+      name: this.parseFragmentName(),
+      variableDefinitions: this.parseVariableDefinitions(),
+      typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
+      directives: this.parseDirectives(!1),
+      selectionSet: this.parseSelectionSet()
+    }) : this.node(t, {
+      kind: g.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(t) {
+    const n = this._lexer.token;
+    switch (n.kind) {
+      case l.BRACKET_L:
+        return this.parseList(t);
+      case l.BRACE_L:
+        return this.parseObject(t);
+      case l.INT:
+        return this.advanceLexer(), this.node(n, {
+          kind: g.INT,
+          value: n.value
+        });
+      case l.FLOAT:
+        return this.advanceLexer(), this.node(n, {
+          kind: g.FLOAT,
+          value: n.value
+        });
+      case l.STRING:
+      case l.BLOCK_STRING:
+        return this.parseStringLiteral();
+      case l.NAME:
+        switch (this.advanceLexer(), n.value) {
+          case "true":
+            return this.node(n, {
+              kind: g.BOOLEAN,
+              value: !0
+            });
+          case "false":
+            return this.node(n, {
+              kind: g.BOOLEAN,
+              value: !1
+            });
+          case "null":
+            return this.node(n, {
+              kind: g.NULL
+            });
+          default:
+            return this.node(n, {
+              kind: g.ENUM,
+              value: n.value
+            });
+        }
+      case l.DOLLAR:
+        if (t)
+          if (this.expectToken(l.DOLLAR), this._lexer.token.kind === l.NAME) {
+            const r = this._lexer.token.value;
+            throw O(
+              this._lexer.source,
+              n.start,
+              `Unexpected variable "$${r}" in constant value.`
+            );
+          } else
+            throw this.unexpected(n);
+        return this.parseVariable();
+      default:
+        throw this.unexpected();
+    }
+  }
+  parseConstValueLiteral() {
+    return this.parseValueLiteral(!0);
+  }
+  parseStringLiteral() {
+    const t = this._lexer.token;
+    return this.advanceLexer(), this.node(t, {
+      kind: g.STRING,
+      value: t.value,
+      block: t.kind === l.BLOCK_STRING
+    });
+  }
+  /**
+   * ListValue[Const] :
+   *   - [ ]
+   *   - [ Value[?Const]+ ]
+   */
+  parseList(t) {
+    const n = () => this.parseValueLiteral(t);
+    return this.node(this._lexer.token, {
+      kind: g.LIST,
+      values: this.any(l.BRACKET_L, n, l.BRACKET_R)
+    });
+  }
+  /**
+   * ```
+   * ObjectValue[Const] :
+   *   - { }
+   *   - { ObjectField[?Const]+ }
+   * ```
+   */
+  parseObject(t) {
+    const n = () => this.parseObjectField(t);
+    return this.node(this._lexer.token, {
+      kind: g.OBJECT,
+      fields: this.any(l.BRACE_L, n, l.BRACE_R)
+    });
+  }
+  /**
+   * ObjectField[Const] : Name : Value[?Const]
+   */
+  parseObjectField(t) {
+    const n = this._lexer.token, r = this.parseName();
+    return this.expectToken(l.COLON), this.node(n, {
+      kind: g.OBJECT_FIELD,
+      name: r,
+      value: this.parseValueLiteral(t)
+    });
+  }
+  // Implements the parsing rules in the Directives section.
+  /**
+   * Directives[Const] : Directive[?Const]+
+   */
+  parseDirectives(t) {
+    const n = [];
+    for (; this.peek(l.AT); )
+      n.push(this.parseDirective(t));
+    return n;
+  }
+  parseConstDirectives() {
+    return this.parseDirectives(!0);
+  }
+  /**
+   * ```
+   * Directive[Const] : @ Name Arguments[?Const]?
+   * ```
+   */
+  parseDirective(t) {
+    const n = this._lexer.token;
+    return this.expectToken(l.AT), this.node(n, {
+      kind: g.DIRECTIVE,
+      name: this.parseName(),
+      arguments: this.parseArguments(t)
+    });
+  }
+  // Implements the parsing rules in the Types section.
+  /**
+   * Type :
+   *   - NamedType
+   *   - ListType
+   *   - NonNullType
+   */
+  parseTypeReference() {
+    const t = this._lexer.token;
+    let n;
+    if (this.expectOptionalToken(l.BRACKET_L)) {
+      const r = this.parseTypeReference();
+      this.expectToken(l.BRACKET_R), n = this.node(t, {
+        kind: g.LIST_TYPE,
+        type: r
+      });
+    } else
+      n = this.parseNamedType();
+    return this.expectOptionalToken(l.BANG) ? this.node(t, {
+      kind: g.NON_NULL_TYPE,
+      type: n
+    }) : n;
+  }
+  /**
+   * NamedType : Name
+   */
+  parseNamedType() {
+    return this.node(this._lexer.token, {
+      kind: g.NAMED_TYPE,
+      name: this.parseName()
+    });
+  }
+  // Implements the parsing rules in the Type Definition section.
+  peekDescription() {
+    return this.peek(l.STRING) || this.peek(l.BLOCK_STRING);
+  }
+  /**
+   * Description : StringValue
+   */
+  parseDescription() {
+    if (this.peekDescription())
+      return this.parseStringLiteral();
+  }
+  /**
+   * ```
+   * SchemaDefinition : Description? schema Directives[Const]? { OperationTypeDefinition+ }
+   * ```
+   */
+  parseSchemaDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("schema");
+    const r = this.parseConstDirectives(), i = this.many(
+      l.BRACE_L,
+      this.parseOperationTypeDefinition,
+      l.BRACE_R
+    );
+    return this.node(t, {
+      kind: g.SCHEMA_DEFINITION,
+      description: n,
+      directives: r,
+      operationTypes: i
+    });
+  }
+  /**
+   * OperationTypeDefinition : OperationType : NamedType
+   */
+  parseOperationTypeDefinition() {
+    const t = this._lexer.token, n = this.parseOperationType();
+    this.expectToken(l.COLON);
+    const r = this.parseNamedType();
+    return this.node(t, {
+      kind: g.OPERATION_TYPE_DEFINITION,
+      operation: n,
+      type: r
+    });
+  }
+  /**
+   * ScalarTypeDefinition : Description? scalar Name Directives[Const]?
+   */
+  parseScalarTypeDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("scalar");
+    const r = this.parseName(), i = this.parseConstDirectives();
+    return this.node(t, {
+      kind: g.SCALAR_TYPE_DEFINITION,
+      description: n,
+      name: r,
+      directives: i
+    });
+  }
+  /**
+   * ObjectTypeDefinition :
+   *   Description?
+   *   type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition?
+   */
+  parseObjectTypeDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("type");
+    const r = this.parseName(), i = this.parseImplementsInterfaces(), s = this.parseConstDirectives(), o = this.parseFieldsDefinition();
+    return this.node(t, {
+      kind: g.OBJECT_TYPE_DEFINITION,
+      description: n,
+      name: r,
+      interfaces: i,
+      directives: s,
+      fields: o
+    });
+  }
+  /**
+   * ImplementsInterfaces :
+   *   - implements `&`? NamedType
+   *   - ImplementsInterfaces & NamedType
+   */
+  parseImplementsInterfaces() {
+    return this.expectOptionalKeyword("implements") ? this.delimitedMany(l.AMP, this.parseNamedType) : [];
+  }
+  /**
+   * ```
+   * FieldsDefinition : { FieldDefinition+ }
+   * ```
+   */
+  parseFieldsDefinition() {
+    return this.optionalMany(
+      l.BRACE_L,
+      this.parseFieldDefinition,
+      l.BRACE_R
+    );
+  }
+  /**
+   * FieldDefinition :
+   *   - Description? Name ArgumentsDefinition? : Type Directives[Const]?
+   */
+  parseFieldDefinition() {
+    const t = this._lexer.token, n = this.parseDescription(), r = this.parseName(), i = this.parseArgumentDefs();
+    this.expectToken(l.COLON);
+    const s = this.parseTypeReference(), o = this.parseConstDirectives();
+    return this.node(t, {
+      kind: g.FIELD_DEFINITION,
+      description: n,
+      name: r,
+      arguments: i,
+      type: s,
+      directives: o
+    });
+  }
+  /**
+   * ArgumentsDefinition : ( InputValueDefinition+ )
+   */
+  parseArgumentDefs() {
+    return this.optionalMany(
+      l.PAREN_L,
+      this.parseInputValueDef,
+      l.PAREN_R
+    );
+  }
+  /**
+   * InputValueDefinition :
+   *   - Description? Name : Type DefaultValue? Directives[Const]?
+   */
+  parseInputValueDef() {
+    const t = this._lexer.token, n = this.parseDescription(), r = this.parseName();
+    this.expectToken(l.COLON);
+    const i = this.parseTypeReference();
+    let s;
+    this.expectOptionalToken(l.EQUALS) && (s = this.parseConstValueLiteral());
+    const o = this.parseConstDirectives();
+    return this.node(t, {
+      kind: g.INPUT_VALUE_DEFINITION,
+      description: n,
+      name: r,
+      type: i,
+      defaultValue: s,
+      directives: o
+    });
+  }
+  /**
+   * InterfaceTypeDefinition :
+   *   - Description? interface Name Directives[Const]? FieldsDefinition?
+   */
+  parseInterfaceTypeDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("interface");
+    const r = this.parseName(), i = this.parseImplementsInterfaces(), s = this.parseConstDirectives(), o = this.parseFieldsDefinition();
+    return this.node(t, {
+      kind: g.INTERFACE_TYPE_DEFINITION,
+      description: n,
+      name: r,
+      interfaces: i,
+      directives: s,
+      fields: o
+    });
+  }
+  /**
+   * UnionTypeDefinition :
+   *   - Description? union Name Directives[Const]? UnionMemberTypes?
+   */
+  parseUnionTypeDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("union");
+    const r = this.parseName(), i = this.parseConstDirectives(), s = this.parseUnionMemberTypes();
+    return this.node(t, {
+      kind: g.UNION_TYPE_DEFINITION,
+      description: n,
+      name: r,
+      directives: i,
+      types: s
+    });
+  }
+  /**
+   * UnionMemberTypes :
+   *   - = `|`? NamedType
+   *   - UnionMemberTypes | NamedType
+   */
+  parseUnionMemberTypes() {
+    return this.expectOptionalToken(l.EQUALS) ? this.delimitedMany(l.PIPE, this.parseNamedType) : [];
+  }
+  /**
+   * EnumTypeDefinition :
+   *   - Description? enum Name Directives[Const]? EnumValuesDefinition?
+   */
+  parseEnumTypeDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("enum");
+    const r = this.parseName(), i = this.parseConstDirectives(), s = this.parseEnumValuesDefinition();
+    return this.node(t, {
+      kind: g.ENUM_TYPE_DEFINITION,
+      description: n,
+      name: r,
+      directives: i,
+      values: s
+    });
+  }
+  /**
+   * ```
+   * EnumValuesDefinition : { EnumValueDefinition+ }
+   * ```
+   */
+  parseEnumValuesDefinition() {
+    return this.optionalMany(
+      l.BRACE_L,
+      this.parseEnumValueDefinition,
+      l.BRACE_R
+    );
+  }
+  /**
+   * EnumValueDefinition : Description? EnumValue Directives[Const]?
+   */
+  parseEnumValueDefinition() {
+    const t = this._lexer.token, n = this.parseDescription(), r = this.parseEnumValueName(), i = this.parseConstDirectives();
+    return this.node(t, {
+      kind: g.ENUM_VALUE_DEFINITION,
+      description: n,
+      name: r,
+      directives: i
+    });
+  }
+  /**
+   * 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 O(
+        this._lexer.source,
+        this._lexer.token.start,
+        `${ue(
+          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 t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("input");
+    const r = this.parseName(), i = this.parseConstDirectives(), s = this.parseInputFieldsDefinition();
+    return this.node(t, {
+      kind: g.INPUT_OBJECT_TYPE_DEFINITION,
+      description: n,
+      name: r,
+      directives: i,
+      fields: s
+    });
+  }
+  /**
+   * ```
+   * InputFieldsDefinition : { InputValueDefinition+ }
+   * ```
+   */
+  parseInputFieldsDefinition() {
+    return this.optionalMany(
+      l.BRACE_L,
+      this.parseInputValueDef,
+      l.BRACE_R
+    );
+  }
+  /**
+   * TypeSystemExtension :
+   *   - SchemaExtension
+   *   - TypeExtension
+   *
+   * TypeExtension :
+   *   - ScalarTypeExtension
+   *   - ObjectTypeExtension
+   *   - InterfaceTypeExtension
+   *   - UnionTypeExtension
+   *   - EnumTypeExtension
+   *   - InputObjectTypeDefinition
+   */
+  parseTypeSystemExtension() {
+    const t = this._lexer.lookahead();
+    if (t.kind === l.NAME)
+      switch (t.value) {
+        case "schema":
+          return this.parseSchemaExtension();
+        case "scalar":
+          return this.parseScalarTypeExtension();
+        case "type":
+          return this.parseObjectTypeExtension();
+        case "interface":
+          return this.parseInterfaceTypeExtension();
+        case "union":
+          return this.parseUnionTypeExtension();
+        case "enum":
+          return this.parseEnumTypeExtension();
+        case "input":
+          return this.parseInputObjectTypeExtension();
+      }
+    throw this.unexpected(t);
+  }
+  /**
+   * ```
+   * SchemaExtension :
+   *  - extend schema Directives[Const]? { OperationTypeDefinition+ }
+   *  - extend schema Directives[Const]
+   * ```
+   */
+  parseSchemaExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("schema");
+    const n = this.parseConstDirectives(), r = this.optionalMany(
+      l.BRACE_L,
+      this.parseOperationTypeDefinition,
+      l.BRACE_R
+    );
+    if (n.length === 0 && r.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: g.SCHEMA_EXTENSION,
+      directives: n,
+      operationTypes: r
+    });
+  }
+  /**
+   * ScalarTypeExtension :
+   *   - extend scalar Name Directives[Const]
+   */
+  parseScalarTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("scalar");
+    const n = this.parseName(), r = this.parseConstDirectives();
+    if (r.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: g.SCALAR_TYPE_EXTENSION,
+      name: n,
+      directives: r
+    });
+  }
+  /**
+   * ObjectTypeExtension :
+   *  - extend type Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+   *  - extend type Name ImplementsInterfaces? Directives[Const]
+   *  - extend type Name ImplementsInterfaces
+   */
+  parseObjectTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("type");
+    const n = this.parseName(), r = this.parseImplementsInterfaces(), i = this.parseConstDirectives(), s = this.parseFieldsDefinition();
+    if (r.length === 0 && i.length === 0 && s.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: g.OBJECT_TYPE_EXTENSION,
+      name: n,
+      interfaces: r,
+      directives: i,
+      fields: s
+    });
+  }
+  /**
+   * InterfaceTypeExtension :
+   *  - extend interface Name ImplementsInterfaces? Directives[Const]? FieldsDefinition
+   *  - extend interface Name ImplementsInterfaces? Directives[Const]
+   *  - extend interface Name ImplementsInterfaces
+   */
+  parseInterfaceTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("interface");
+    const n = this.parseName(), r = this.parseImplementsInterfaces(), i = this.parseConstDirectives(), s = this.parseFieldsDefinition();
+    if (r.length === 0 && i.length === 0 && s.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: g.INTERFACE_TYPE_EXTENSION,
+      name: n,
+      interfaces: r,
+      directives: i,
+      fields: s
+    });
+  }
+  /**
+   * UnionTypeExtension :
+   *   - extend union Name Directives[Const]? UnionMemberTypes
+   *   - extend union Name Directives[Const]
+   */
+  parseUnionTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("union");
+    const n = this.parseName(), r = this.parseConstDirectives(), i = this.parseUnionMemberTypes();
+    if (r.length === 0 && i.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: g.UNION_TYPE_EXTENSION,
+      name: n,
+      directives: r,
+      types: i
+    });
+  }
+  /**
+   * EnumTypeExtension :
+   *   - extend enum Name Directives[Const]? EnumValuesDefinition
+   *   - extend enum Name Directives[Const]
+   */
+  parseEnumTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("enum");
+    const n = this.parseName(), r = this.parseConstDirectives(), i = this.parseEnumValuesDefinition();
+    if (r.length === 0 && i.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: g.ENUM_TYPE_EXTENSION,
+      name: n,
+      directives: r,
+      values: i
+    });
+  }
+  /**
+   * InputObjectTypeExtension :
+   *   - extend input Name Directives[Const]? InputFieldsDefinition
+   *   - extend input Name Directives[Const]
+   */
+  parseInputObjectTypeExtension() {
+    const t = this._lexer.token;
+    this.expectKeyword("extend"), this.expectKeyword("input");
+    const n = this.parseName(), r = this.parseConstDirectives(), i = this.parseInputFieldsDefinition();
+    if (r.length === 0 && i.length === 0)
+      throw this.unexpected();
+    return this.node(t, {
+      kind: g.INPUT_OBJECT_TYPE_EXTENSION,
+      name: n,
+      directives: r,
+      fields: i
+    });
+  }
+  /**
+   * ```
+   * DirectiveDefinition :
+   *   - Description? directive @ Name ArgumentsDefinition? `repeatable`? on DirectiveLocations
+   * ```
+   */
+  parseDirectiveDefinition() {
+    const t = this._lexer.token, n = this.parseDescription();
+    this.expectKeyword("directive"), this.expectToken(l.AT);
+    const r = this.parseName(), i = this.parseArgumentDefs(), s = this.expectOptionalKeyword("repeatable");
+    this.expectKeyword("on");
+    const o = this.parseDirectiveLocations();
+    return this.node(t, {
+      kind: g.DIRECTIVE_DEFINITION,
+      description: n,
+      name: r,
+      arguments: i,
+      repeatable: s,
+      locations: o
+    });
+  }
+  /**
+   * DirectiveLocations :
+   *   - `|`? DirectiveLocation
+   *   - DirectiveLocations | DirectiveLocation
+   */
+  parseDirectiveLocations() {
+    return this.delimitedMany(l.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 t = this._lexer.token, n = this.parseName();
+    if (Object.prototype.hasOwnProperty.call(Be, n.value))
+      return n;
+    throw this.unexpected(t);
+  }
+  // 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(t, n) {
+    return this._options.noLocation !== !0 && (n.loc = new dn(
+      t,
+      this._lexer.lastToken,
+      this._lexer.source
+    )), n;
+  }
+  /**
+   * Determines if the next token is of a given kind
+   */
+  peek(t) {
+    return this._lexer.token.kind === t;
+  }
+  /**
+   * 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(t) {
+    const n = this._lexer.token;
+    if (n.kind === t)
+      return this.advanceLexer(), n;
+    throw O(
+      this._lexer.source,
+      n.start,
+      `Expected ${kt(t)}, found ${ue(n)}.`
+    );
+  }
+  /**
+   * 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(t) {
+    return this._lexer.token.kind === t ? (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(t) {
+    const n = this._lexer.token;
+    if (n.kind === l.NAME && n.value === t)
+      this.advanceLexer();
+    else
+      throw O(
+        this._lexer.source,
+        n.start,
+        `Expected "${t}", found ${ue(n)}.`
+      );
+  }
+  /**
+   * 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(t) {
+    const n = this._lexer.token;
+    return n.kind === l.NAME && n.value === t ? (this.advanceLexer(), !0) : !1;
+  }
+  /**
+   * Helper function for creating an error when an unexpected lexed token is encountered.
+   */
+  unexpected(t) {
+    const n = t != null ? t : this._lexer.token;
+    return O(
+      this._lexer.source,
+      n.start,
+      `Unexpected ${ue(n)}.`
+    );
+  }
+  /**
+   * 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(t, n, r) {
+    this.expectToken(t);
+    const i = [];
+    for (; !this.expectOptionalToken(r); )
+      i.push(n.call(this));
+    return i;
+  }
+  /**
+   * 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(t, n, r) {
+    if (this.expectOptionalToken(t)) {
+      const i = [];
+      do
+        i.push(n.call(this));
+      while (!this.expectOptionalToken(r));
+      return i;
+    }
+    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(t, n, r) {
+    this.expectToken(t);
+    const i = [];
+    do
+      i.push(n.call(this));
+    while (!this.expectOptionalToken(r));
+    return i;
+  }
+  /**
+   * 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(t, n) {
+    this.expectOptionalToken(t);
+    const r = [];
+    do
+      r.push(n.call(this));
+    while (this.expectOptionalToken(t));
+    return r;
+  }
+  advanceLexer() {
+    const { maxTokens: t } = this._options, n = this._lexer.advance();
+    if (n.kind !== l.EOF && (++this._tokenCounter, t !== void 0 && this._tokenCounter > t))
+      throw O(
+        this._lexer.source,
+        n.start,
+        `Document contains more that ${t} tokens. Parsing aborted.`
+      );
+  }
+}
+function ue(e) {
+  const t = e.value;
+  return kt(e.kind) + (t != null ? ` "${t}"` : "");
+}
+function kt(e) {
+  return Tn(e) ? `"${e}"` : e;
+}
+function Bn(e) {
+  return `"${e.replace(Vn, jn)}"`;
+}
+const Vn = /[\x00-\x1f\x22\x5c\x7f-\x9f]/g;
+function jn(e) {
+  return qn[e.charCodeAt(0)];
+}
+const qn = [
+  "\\u0000",
+  "\\u0001",
+  "\\u0002",
+  "\\u0003",
+  "\\u0004",
+  "\\u0005",
+  "\\u0006",
+  "\\u0007",
+  "\\b",
+  "\\t",
+  "\\n",
+  "\\u000B",
+  "\\f",
+  "\\r",
+  "\\u000E",
+  "\\u000F",
+  "\\u0010",
+  "\\u0011",
+  "\\u0012",
+  "\\u0013",
+  "\\u0014",
+  "\\u0015",
+  "\\u0016",
+  "\\u0017",
+  "\\u0018",
+  "\\u0019",
+  "\\u001A",
+  "\\u001B",
+  "\\u001C",
+  "\\u001D",
+  "\\u001E",
+  "\\u001F",
+  "",
+  "",
+  '\\"',
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  // 2F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  // 3F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  // 4F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "\\\\",
+  "",
+  "",
+  "",
+  // 5F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  // 6F
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "\\u007F",
+  "\\u0080",
+  "\\u0081",
+  "\\u0082",
+  "\\u0083",
+  "\\u0084",
+  "\\u0085",
+  "\\u0086",
+  "\\u0087",
+  "\\u0088",
+  "\\u0089",
+  "\\u008A",
+  "\\u008B",
+  "\\u008C",
+  "\\u008D",
+  "\\u008E",
+  "\\u008F",
+  "\\u0090",
+  "\\u0091",
+  "\\u0092",
+  "\\u0093",
+  "\\u0094",
+  "\\u0095",
+  "\\u0096",
+  "\\u0097",
+  "\\u0098",
+  "\\u0099",
+  "\\u009A",
+  "\\u009B",
+  "\\u009C",
+  "\\u009D",
+  "\\u009E",
+  "\\u009F"
+], Hn = Object.freeze({});
+function Gn(e, t, n = It) {
+  const r = /* @__PURE__ */ new Map();
+  for (const x of Object.values(g))
+    r.set(x, Yn(t, x));
+  let i, s = Array.isArray(e), o = [e], a = -1, c = [], f = e, h, m;
+  const E = [], S = [];
+  do {
+    a++;
+    const x = a === o.length, V = x && c.length !== 0;
+    if (x) {
+      if (h = S.length === 0 ? void 0 : E[E.length - 1], f = m, m = S.pop(), V)
+        if (s) {
+          f = f.slice();
+          let P = 0;
+          for (const [j, se] of c) {
+            const oe = j - P;
+            se === null ? (f.splice(oe, 1), P++) : f[oe] = se;
+          }
+        } else {
+          f = _({}, f);
+          for (const [P, j] of c)
+            f[P] = j;
+        }
+      a = i.index, o = i.keys, c = i.edits, s = i.inArray, i = i.prev;
+    } else if (m) {
+      if (h = s ? a : o[a], f = m[h], f == null)
+        continue;
+      E.push(h);
+    }
+    let k;
+    if (!Array.isArray(f)) {
+      var y, N;
+      ct(f) || de(!1, `Invalid AST Node: ${Ke(f)}.`);
+      const P = x ? (y = r.get(f.kind)) === null || y === void 0 ? void 0 : y.leave : (N = r.get(f.kind)) === null || N === void 0 ? void 0 : N.enter;
+      if (k = P == null ? void 0 : P.call(t, f, h, m, E, S), k === Hn)
+        break;
+      if (k === !1) {
+        if (!x) {
+          E.pop();
+          continue;
+        }
+      } else if (k !== void 0 && (c.push([h, k]), !x))
+        if (ct(k))
+          f = k;
+        else {
+          E.pop();
+          continue;
+        }
+    }
+    if (k === void 0 && V && c.push([h, f]), x)
+      E.pop();
+    else {
+      var b;
+      i = {
+        inArray: s,
+        index: a,
+        keys: o,
+        edits: c,
+        prev: i
+      }, s = Array.isArray(f), o = s ? f : (b = n[f.kind]) !== null && b !== void 0 ? b : [], a = -1, c = [], m && S.push(m), m = f;
+    }
+  } while (i !== void 0);
+  return c.length !== 0 ? c[c.length - 1][1] : e;
+}
+function Yn(e, t) {
+  const n = e[t];
+  return typeof n == "object" ? n : typeof n == "function" ? {
+    enter: n,
+    leave: void 0
+  } : {
+    enter: e.enter,
+    leave: e.leave
+  };
+}
+function zn(e) {
+  return Gn(e, Xn);
+}
+const Jn = 80, Xn = {
+  Name: {
+    leave: (e) => e.value
+  },
+  Variable: {
+    leave: (e) => "$" + e.name
+  },
+  // Document
+  Document: {
+    leave: (e) => p(e.definitions, `
+
+`)
+  },
+  OperationDefinition: {
+    leave(e) {
+      const t = v("(", p(e.variableDefinitions, ", "), ")"), n = p(
+        [
+          e.operation,
+          p([e.name, t]),
+          p(e.directives, " ")
+        ],
+        " "
+      );
+      return (n === "query" ? "" : n + " ") + e.selectionSet;
+    }
+  },
+  VariableDefinition: {
+    leave: ({ variable: e, type: t, defaultValue: n, directives: r }) => e + ": " + t + v(" = ", n) + v(" ", p(r, " "))
+  },
+  SelectionSet: {
+    leave: ({ selections: e }) => F(e)
+  },
+  Field: {
+    leave({ alias: e, name: t, arguments: n, directives: r, selectionSet: i }) {
+      const s = v("", e, ": ") + t;
+      let o = s + v("(", p(n, ", "), ")");
+      return o.length > Jn && (o = s + v(`(
+`, pe(p(n, `
+`)), `
+)`)), p([o, p(r, " "), i], " ");
+    }
+  },
+  Argument: {
+    leave: ({ name: e, value: t }) => e + ": " + t
+  },
+  // Fragments
+  FragmentSpread: {
+    leave: ({ name: e, directives: t }) => "..." + e + v(" ", p(t, " "))
+  },
+  InlineFragment: {
+    leave: ({ typeCondition: e, directives: t, selectionSet: n }) => p(
+      [
+        "...",
+        v("on ", e),
+        p(t, " "),
+        n
+      ],
+      " "
+    )
+  },
+  FragmentDefinition: {
+    leave: ({ name: e, typeCondition: t, variableDefinitions: n, directives: r, selectionSet: i }) => (
+      // or removed in the future.
+      `fragment ${e}${v("(", p(n, ", "), ")")} on ${t} ${v("", p(r, " "), " ")}` + i
+    )
+  },
+  // Value
+  IntValue: {
+    leave: ({ value: e }) => e
+  },
+  FloatValue: {
+    leave: ({ value: e }) => e
+  },
+  StringValue: {
+    leave: ({ value: e, block: t }) => t ? En(e) : Bn(e)
+  },
+  BooleanValue: {
+    leave: ({ value: e }) => e ? "true" : "false"
+  },
+  NullValue: {
+    leave: () => "null"
+  },
+  EnumValue: {
+    leave: ({ value: e }) => e
+  },
+  ListValue: {
+    leave: ({ values: e }) => "[" + p(e, ", ") + "]"
+  },
+  ObjectValue: {
+    leave: ({ fields: e }) => "{" + p(e, ", ") + "}"
+  },
+  ObjectField: {
+    leave: ({ name: e, value: t }) => e + ": " + t
+  },
+  // Directive
+  Directive: {
+    leave: ({ name: e, arguments: t }) => "@" + e + v("(", p(t, ", "), ")")
+  },
+  // Type
+  NamedType: {
+    leave: ({ name: e }) => e
+  },
+  ListType: {
+    leave: ({ type: e }) => "[" + e + "]"
+  },
+  NonNullType: {
+    leave: ({ type: e }) => e + "!"
+  },
+  // Type System Definitions
+  SchemaDefinition: {
+    leave: ({ description: e, directives: t, operationTypes: n }) => v("", e, `
+`) + p(["schema", p(t, " "), F(n)], " ")
+  },
+  OperationTypeDefinition: {
+    leave: ({ operation: e, type: t }) => e + ": " + t
+  },
+  ScalarTypeDefinition: {
+    leave: ({ description: e, name: t, directives: n }) => v("", e, `
+`) + p(["scalar", t, p(n, " ")], " ")
+  },
+  ObjectTypeDefinition: {
+    leave: ({ description: e, name: t, interfaces: n, directives: r, fields: i }) => v("", e, `
+`) + p(
+      [
+        "type",
+        t,
+        v("implements ", p(n, " & ")),
+        p(r, " "),
+        F(i)
+      ],
+      " "
+    )
+  },
+  FieldDefinition: {
+    leave: ({ description: e, name: t, arguments: n, type: r, directives: i }) => v("", e, `
+`) + t + (lt(n) ? v(`(
+`, pe(p(n, `
+`)), `
+)`) : v("(", p(n, ", "), ")")) + ": " + r + v(" ", p(i, " "))
+  },
+  InputValueDefinition: {
+    leave: ({ description: e, name: t, type: n, defaultValue: r, directives: i }) => v("", e, `
+`) + p(
+      [t + ": " + n, v("= ", r), p(i, " ")],
+      " "
+    )
+  },
+  InterfaceTypeDefinition: {
+    leave: ({ description: e, name: t, interfaces: n, directives: r, fields: i }) => v("", e, `
+`) + p(
+      [
+        "interface",
+        t,
+        v("implements ", p(n, " & ")),
+        p(r, " "),
+        F(i)
+      ],
+      " "
+    )
+  },
+  UnionTypeDefinition: {
+    leave: ({ description: e, name: t, directives: n, types: r }) => v("", e, `
+`) + p(
+      ["union", t, p(n, " "), v("= ", p(r, " | "))],
+      " "
+    )
+  },
+  EnumTypeDefinition: {
+    leave: ({ description: e, name: t, directives: n, values: r }) => v("", e, `
+`) + p(["enum", t, p(n, " "), F(r)], " ")
+  },
+  EnumValueDefinition: {
+    leave: ({ description: e, name: t, directives: n }) => v("", e, `
+`) + p([t, p(n, " ")], " ")
+  },
+  InputObjectTypeDefinition: {
+    leave: ({ description: e, name: t, directives: n, fields: r }) => v("", e, `
+`) + p(["input", t, p(n, " "), F(r)], " ")
+  },
+  DirectiveDefinition: {
+    leave: ({ description: e, name: t, arguments: n, repeatable: r, locations: i }) => v("", e, `
+`) + "directive @" + t + (lt(n) ? v(`(
+`, pe(p(n, `
+`)), `
+)`) : v("(", p(n, ", "), ")")) + (r ? " repeatable" : "") + " on " + p(i, " | ")
+  },
+  SchemaExtension: {
+    leave: ({ directives: e, operationTypes: t }) => p(
+      ["extend schema", p(e, " "), F(t)],
+      " "
+    )
+  },
+  ScalarTypeExtension: {
+    leave: ({ name: e, directives: t }) => p(["extend scalar", e, p(t, " ")], " ")
+  },
+  ObjectTypeExtension: {
+    leave: ({ name: e, interfaces: t, directives: n, fields: r }) => p(
+      [
+        "extend type",
+        e,
+        v("implements ", p(t, " & ")),
+        p(n, " "),
+        F(r)
+      ],
+      " "
+    )
+  },
+  InterfaceTypeExtension: {
+    leave: ({ name: e, interfaces: t, directives: n, fields: r }) => p(
+      [
+        "extend interface",
+        e,
+        v("implements ", p(t, " & ")),
+        p(n, " "),
+        F(r)
+      ],
+      " "
+    )
+  },
+  UnionTypeExtension: {
+    leave: ({ name: e, directives: t, types: n }) => p(
+      [
+        "extend union",
+        e,
+        p(t, " "),
+        v("= ", p(n, " | "))
+      ],
+      " "
+    )
+  },
+  EnumTypeExtension: {
+    leave: ({ name: e, directives: t, values: n }) => p(["extend enum", e, p(t, " "), F(n)], " ")
+  },
+  InputObjectTypeExtension: {
+    leave: ({ name: e, directives: t, fields: n }) => p(["extend input", e, p(t, " "), F(n)], " ")
+  }
+};
+function p(e, t = "") {
+  var n;
+  return (n = e == null ? void 0 : e.filter((r) => r).join(t)) !== null && n !== void 0 ? n : "";
+}
+function F(e) {
+  return v(`{
+`, pe(p(e, `
+`)), `
+}`);
+}
+function v(e, t, n = "") {
+  return t != null && t !== "" ? e + t + n : "";
+}
+function pe(e) {
+  return v("  ", e.replace(/\n/g, `
+  `));
+}
+function lt(e) {
+  var t;
+  return (t = e == null ? void 0 : e.some((n) => n.includes(`
+`))) !== null && t !== void 0 ? t : !1;
+}
+const We = JSON, Qn = (e) => e.toUpperCase(), Kn = (e) => {
+  const t = {};
+  return e.forEach((n, r) => {
+    t[r] = n;
+  }), t;
+}, Wn = (e, t, n) => e.document ? e : {
+  document: e,
+  variables: t,
+  requestHeaders: n,
+  signal: void 0
+}, Zn = (e, t, n) => e.query ? e : {
+  query: e,
+  variables: t,
+  requestHeaders: n,
+  signal: void 0
+}, er = (e, t) => e.documents ? e : {
+  documents: e,
+  requestHeaders: t,
+  signal: void 0
+}, ft = (e) => {
+  var r, i;
+  let t;
+  const n = e.definitions.filter((s) => s.kind === "OperationDefinition");
+  return n.length === 1 && (t = (i = (r = n[0]) == null ? void 0 : r.name) == null ? void 0 : i.value), t;
+}, Re = (e) => {
+  if (typeof e == "string") {
+    let n;
+    try {
+      const r = Rt(e);
+      n = ft(r);
+    } catch (r) {
+    }
+    return { query: e, operationName: n };
+  }
+  const t = ft(e);
+  return { query: zn(e), operationName: t };
+};
+class X extends Error {
+  constructor(t, n) {
+    const r = `${X.extractMessage(t)}: ${JSON.stringify({
+      response: t,
+      request: n
+    })}`;
+    super(r), Object.setPrototypeOf(this, X.prototype), this.response = t, this.request = n, typeof Error.captureStackTrace == "function" && Error.captureStackTrace(this, X);
+  }
+  static extractMessage(t) {
+    var n, r, i;
+    return (i = (r = (n = t.errors) == null ? void 0 : n[0]) == null ? void 0 : r.message) != null ? i : `GraphQL Error (Code: ${t.status})`;
+  }
+}
+var tr = typeof globalThis != "undefined" ? globalThis : typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : {};
+function Ze(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var je = { exports: {} };
+(function(e, t) {
+  var n = typeof self != "undefined" ? self : tr, r = function() {
+    function s() {
+      this.fetch = !1, this.DOMException = n.DOMException;
+    }
+    return s.prototype = n, new s();
+  }();
+  (function(s) {
+    (function(o) {
+      var a = {
+        searchParams: "URLSearchParams" in s,
+        iterable: "Symbol" in s && "iterator" in Symbol,
+        blob: "FileReader" in s && "Blob" in s && function() {
+          try {
+            return new Blob(), !0;
+          } catch (u) {
+            return !1;
+          }
+        }(),
+        formData: "FormData" in s,
+        arrayBuffer: "ArrayBuffer" in s
+      };
+      function c(u) {
+        return u && DataView.prototype.isPrototypeOf(u);
+      }
+      if (a.arrayBuffer)
+        var f = [
+          "[object Int8Array]",
+          "[object Uint8Array]",
+          "[object Uint8ClampedArray]",
+          "[object Int16Array]",
+          "[object Uint16Array]",
+          "[object Int32Array]",
+          "[object Uint32Array]",
+          "[object Float32Array]",
+          "[object Float64Array]"
+        ], h = ArrayBuffer.isView || function(u) {
+          return u && f.indexOf(Object.prototype.toString.call(u)) > -1;
+        };
+      function m(u) {
+        if (typeof u != "string" && (u = String(u)), /[^a-z0-9\-#$%&'*+.^_`|~]/i.test(u))
+          throw new TypeError("Invalid character in header field name");
+        return u.toLowerCase();
+      }
+      function E(u) {
+        return typeof u != "string" && (u = String(u)), u;
+      }
+      function S(u) {
+        var d = {
+          next: function() {
+            var T = u.shift();
+            return { done: T === void 0, value: T };
+          }
+        };
+        return a.iterable && (d[Symbol.iterator] = function() {
+          return d;
+        }), d;
+      }
+      function y(u) {
+        this.map = {}, u instanceof y ? u.forEach(function(d, T) {
+          this.append(T, d);
+        }, this) : Array.isArray(u) ? u.forEach(function(d) {
+          this.append(d[0], d[1]);
+        }, this) : u && Object.getOwnPropertyNames(u).forEach(function(d) {
+          this.append(d, u[d]);
+        }, this);
+      }
+      y.prototype.append = function(u, d) {
+        u = m(u), d = E(d);
+        var T = this.map[u];
+        this.map[u] = T ? T + ", " + d : d;
+      }, y.prototype.delete = function(u) {
+        delete this.map[m(u)];
+      }, y.prototype.get = function(u) {
+        return u = m(u), this.has(u) ? this.map[u] : null;
+      }, y.prototype.has = function(u) {
+        return this.map.hasOwnProperty(m(u));
+      }, y.prototype.set = function(u, d) {
+        this.map[m(u)] = E(d);
+      }, y.prototype.forEach = function(u, d) {
+        for (var T in this.map)
+          this.map.hasOwnProperty(T) && u.call(d, this.map[T], T, this);
+      }, y.prototype.keys = function() {
+        var u = [];
+        return this.forEach(function(d, T) {
+          u.push(T);
+        }), S(u);
+      }, y.prototype.values = function() {
+        var u = [];
+        return this.forEach(function(d) {
+          u.push(d);
+        }), S(u);
+      }, y.prototype.entries = function() {
+        var u = [];
+        return this.forEach(function(d, T) {
+          u.push([T, d]);
+        }), S(u);
+      }, a.iterable && (y.prototype[Symbol.iterator] = y.prototype.entries);
+      function N(u) {
+        if (u.bodyUsed)
+          return Promise.reject(new TypeError("Already read"));
+        u.bodyUsed = !0;
+      }
+      function b(u) {
+        return new Promise(function(d, T) {
+          u.onload = function() {
+            d(u.result);
+          }, u.onerror = function() {
+            T(u.error);
+          };
+        });
+      }
+      function x(u) {
+        var d = new FileReader(), T = b(d);
+        return d.readAsArrayBuffer(u), T;
+      }
+      function V(u) {
+        var d = new FileReader(), T = b(d);
+        return d.readAsText(u), T;
+      }
+      function k(u) {
+        for (var d = new Uint8Array(u), T = new Array(d.length), w = 0; w < d.length; w++)
+          T[w] = String.fromCharCode(d[w]);
+        return T.join("");
+      }
+      function P(u) {
+        if (u.slice)
+          return u.slice(0);
+        var d = new Uint8Array(u.byteLength);
+        return d.set(new Uint8Array(u)), d.buffer;
+      }
+      function j() {
+        return this.bodyUsed = !1, this._initBody = function(u) {
+          this._bodyInit = u, u ? typeof u == "string" ? this._bodyText = u : a.blob && Blob.prototype.isPrototypeOf(u) ? this._bodyBlob = u : a.formData && FormData.prototype.isPrototypeOf(u) ? this._bodyFormData = u : a.searchParams && URLSearchParams.prototype.isPrototypeOf(u) ? this._bodyText = u.toString() : a.arrayBuffer && a.blob && c(u) ? (this._bodyArrayBuffer = P(u.buffer), this._bodyInit = new Blob([this._bodyArrayBuffer])) : a.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(u) || h(u)) ? this._bodyArrayBuffer = P(u) : this._bodyText = u = Object.prototype.toString.call(u) : this._bodyText = "", this.headers.get("content-type") || (typeof u == "string" ? this.headers.set("content-type", "text/plain;charset=UTF-8") : this._bodyBlob && this._bodyBlob.type ? this.headers.set("content-type", this._bodyBlob.type) : a.searchParams && URLSearchParams.prototype.isPrototypeOf(u) && this.headers.set("content-type", "application/x-www-form-urlencoded;charset=UTF-8"));
+        }, a.blob && (this.blob = function() {
+          var u = N(this);
+          if (u)
+            return u;
+          if (this._bodyBlob)
+            return Promise.resolve(this._bodyBlob);
+          if (this._bodyArrayBuffer)
+            return Promise.resolve(new Blob([this._bodyArrayBuffer]));
+          if (this._bodyFormData)
+            throw new Error("could not read FormData body as blob");
+          return Promise.resolve(new Blob([this._bodyText]));
+        }, this.arrayBuffer = function() {
+          return this._bodyArrayBuffer ? N(this) || Promise.resolve(this._bodyArrayBuffer) : this.blob().then(x);
+        }), this.text = function() {
+          var u = N(this);
+          if (u)
+            return u;
+          if (this._bodyBlob)
+            return V(this._bodyBlob);
+          if (this._bodyArrayBuffer)
+            return Promise.resolve(k(this._bodyArrayBuffer));
+          if (this._bodyFormData)
+            throw new Error("could not read FormData body as text");
+          return Promise.resolve(this._bodyText);
+        }, a.formData && (this.formData = function() {
+          return this.text().then(Wt);
+        }), this.json = function() {
+          return this.text().then(JSON.parse);
+        }, this;
+      }
+      var se = ["DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"];
+      function oe(u) {
+        var d = u.toUpperCase();
+        return se.indexOf(d) > -1 ? d : u;
+      }
+      function $(u, d) {
+        d = d || {};
+        var T = d.body;
+        if (u instanceof $) {
+          if (u.bodyUsed)
+            throw new TypeError("Already read");
+          this.url = u.url, this.credentials = u.credentials, d.headers || (this.headers = new y(u.headers)), this.method = u.method, this.mode = u.mode, this.signal = u.signal, !T && u._bodyInit != null && (T = u._bodyInit, u.bodyUsed = !0);
+        } else
+          this.url = String(u);
+        if (this.credentials = d.credentials || this.credentials || "same-origin", (d.headers || !this.headers) && (this.headers = new y(d.headers)), this.method = oe(d.method || this.method || "GET"), this.mode = d.mode || this.mode || null, this.signal = d.signal || this.signal, this.referrer = null, (this.method === "GET" || this.method === "HEAD") && T)
+          throw new TypeError("Body not allowed for GET or HEAD requests");
+        this._initBody(T);
+      }
+      $.prototype.clone = function() {
+        return new $(this, { body: this._bodyInit });
+      };
+      function Wt(u) {
+        var d = new FormData();
+        return u.trim().split("&").forEach(function(T) {
+          if (T) {
+            var w = T.split("="), D = w.shift().replace(/\+/g, " "), A = w.join("=").replace(/\+/g, " ");
+            d.append(decodeURIComponent(D), decodeURIComponent(A));
+          }
+        }), d;
+      }
+      function Zt(u) {
+        var d = new y(), T = u.replace(/\r?\n[\t ]+/g, " ");
+        return T.split(/\r?\n/).forEach(function(w) {
+          var D = w.split(":"), A = D.shift().trim();
+          if (A) {
+            var ae = D.join(":").trim();
+            d.append(A, ae);
+          }
+        }), d;
+      }
+      j.call($.prototype);
+      function M(u, d) {
+        d || (d = {}), this.type = "default", this.status = d.status === void 0 ? 200 : d.status, this.ok = this.status >= 200 && this.status < 300, this.statusText = "statusText" in d ? d.statusText : "OK", this.headers = new y(d.headers), this.url = d.url || "", this._initBody(u);
+      }
+      j.call(M.prototype), M.prototype.clone = function() {
+        return new M(this._bodyInit, {
+          status: this.status,
+          statusText: this.statusText,
+          headers: new y(this.headers),
+          url: this.url
+        });
+      }, M.error = function() {
+        var u = new M(null, { status: 0, statusText: "" });
+        return u.type = "error", u;
+      };
+      var en = [301, 302, 303, 307, 308];
+      M.redirect = function(u, d) {
+        if (en.indexOf(d) === -1)
+          throw new RangeError("Invalid status code");
+        return new M(null, { status: d, headers: { location: u } });
+      }, o.DOMException = s.DOMException;
+      try {
+        new o.DOMException();
+      } catch (u) {
+        o.DOMException = function(d, T) {
+          this.message = d, this.name = T;
+          var w = Error(d);
+          this.stack = w.stack;
+        }, o.DOMException.prototype = Object.create(Error.prototype), o.DOMException.prototype.constructor = o.DOMException;
+      }
+      function be(u, d) {
+        return new Promise(function(T, w) {
+          var D = new $(u, d);
+          if (D.signal && D.signal.aborted)
+            return w(new o.DOMException("Aborted", "AbortError"));
+          var A = new XMLHttpRequest();
+          function ae() {
+            A.abort();
+          }
+          A.onload = function() {
+            var te = {
+              status: A.status,
+              statusText: A.statusText,
+              headers: Zt(A.getAllResponseHeaders() || "")
+            };
+            te.url = "responseURL" in A ? A.responseURL : te.headers.get("X-Request-URL");
+            var xe = "response" in A ? A.response : A.responseText;
+            T(new M(xe, te));
+          }, A.onerror = function() {
+            w(new TypeError("Network request failed"));
+          }, A.ontimeout = function() {
+            w(new TypeError("Network request failed"));
+          }, A.onabort = function() {
+            w(new o.DOMException("Aborted", "AbortError"));
+          }, A.open(D.method, D.url, !0), D.credentials === "include" ? A.withCredentials = !0 : D.credentials === "omit" && (A.withCredentials = !1), "responseType" in A && a.blob && (A.responseType = "blob"), D.headers.forEach(function(te, xe) {
+            A.setRequestHeader(xe, te);
+          }), D.signal && (D.signal.addEventListener("abort", ae), A.onreadystatechange = function() {
+            A.readyState === 4 && D.signal.removeEventListener("abort", ae);
+          }), A.send(typeof D._bodyInit == "undefined" ? null : D._bodyInit);
+        });
+      }
+      return be.polyfill = !0, s.fetch || (s.fetch = be, s.Headers = y, s.Request = $, s.Response = M), o.Headers = y, o.Request = $, o.Response = M, o.fetch = be, Object.defineProperty(o, "__esModule", { value: !0 }), o;
+    })({});
+  })(r), r.fetch.ponyfill = !0, delete r.fetch.polyfill;
+  var i = r;
+  t = i.fetch, t.default = i.fetch, t.fetch = i.fetch, t.Headers = i.Headers, t.Request = i.Request, t.Response = i.Response, e.exports = t;
+})(je, je.exports);
+var qe = je.exports;
+const me = /* @__PURE__ */ Ze(qe), nr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: me
+}, Symbol.toStringTag, { value: "Module" })), Y = (e) => {
+  let t = {};
+  return e && (typeof Headers != "undefined" && e instanceof Headers || nr && qe.Headers && e instanceof qe.Headers ? t = Kn(e) : Array.isArray(e) ? e.forEach(([n, r]) => {
+    n && r !== void 0 && (t[n] = r);
+  }) : t = e), t;
+}, ht = (e) => e.replace(/([\s,]|#[^\n\r]+)+/g, " ").trim(), rr = (e) => {
+  if (!Array.isArray(e.query)) {
+    const r = e, i = [`query=${encodeURIComponent(ht(r.query))}`];
+    return e.variables && i.push(`variables=${encodeURIComponent(r.jsonSerializer.stringify(r.variables))}`), r.operationName && i.push(`operationName=${encodeURIComponent(r.operationName)}`), i.join("&");
+  }
+  if (typeof e.variables != "undefined" && !Array.isArray(e.variables))
+    throw new Error("Cannot create query with given variable type, array expected");
+  const t = e, n = e.query.reduce((r, i, s) => (r.push({
+    query: ht(i),
+    variables: t.variables ? t.jsonSerializer.stringify(t.variables[s]) : void 0
+  }), r), []);
+  return `query=${encodeURIComponent(t.jsonSerializer.stringify(n))}`;
+}, ir = (e) => (t) => U(void 0, null, function* () {
+  var N;
+  const { url: n, query: r, variables: i, operationName: s, fetch: o, fetchOptions: a, middleware: c } = t, f = _({}, t.headers);
+  let h = "", m;
+  e === "POST" ? (m = sr(r, i, s, a.jsonSerializer), typeof m == "string" && (f["Content-Type"] = "application/json")) : h = rr({
+    query: r,
+    variables: i,
+    operationName: s,
+    jsonSerializer: (N = a.jsonSerializer) != null ? N : We
+  });
+  const E = _({
+    method: e,
+    headers: f,
+    body: m
+  }, a);
+  let S = n, y = E;
+  if (c) {
+    const b = yield Promise.resolve(c(q(_({}, E), { url: n, operationName: s, variables: i }))), { url: V } = b, k = H(b, ["url"]);
+    S = V, y = k;
+  }
+  return h && (S = `${S}?${h}`), yield o(S, y);
+});
+class vi {
+  constructor(t, n = {}) {
+    this.url = t, this.requestConfig = n, this.rawRequest = (...r) => U(this, null, function* () {
+      const [i, s, o] = r, a = Zn(i, s, o), b = this.requestConfig, { headers: c, fetch: f = me, method: h = "POST", requestMiddleware: m, responseMiddleware: E } = b, S = H(b, ["headers", "fetch", "method", "requestMiddleware", "responseMiddleware"]), { url: y } = this;
+      a.signal !== void 0 && (S.signal = a.signal);
+      const { operationName: N } = Re(a.query);
+      return ke({
+        url: y,
+        query: a.query,
+        variables: a.variables,
+        headers: _(_({}, Y(Le(c))), Y(a.requestHeaders)),
+        operationName: N,
+        fetch: f,
+        method: h,
+        fetchOptions: S,
+        middleware: m
+      }).then((x) => (E && E(x), x)).catch((x) => {
+        throw E && E(x), x;
+      });
+    });
+  }
+  request(t, ...n) {
+    return U(this, null, function* () {
+      const [r, i] = n, s = Wn(t, r, i), N = this.requestConfig, { headers: o, fetch: a = me, method: c = "POST", requestMiddleware: f, responseMiddleware: h } = N, m = H(N, ["headers", "fetch", "method", "requestMiddleware", "responseMiddleware"]), { url: E } = this;
+      s.signal !== void 0 && (m.signal = s.signal);
+      const { query: S, operationName: y } = Re(s.document);
+      return ke({
+        url: E,
+        query: S,
+        variables: s.variables,
+        headers: _(_({}, Y(Le(o))), Y(s.requestHeaders)),
+        operationName: y,
+        fetch: a,
+        method: c,
+        fetchOptions: m,
+        middleware: f
+      }).then((b) => (h && h(b), b.data)).catch((b) => {
+        throw h && h(b), b;
+      });
+    });
+  }
+  // prettier-ignore
+  batchRequests(t, n) {
+    var f;
+    const r = er(t, n), c = this.requestConfig, { headers: i } = c, s = H(c, ["headers"]);
+    r.signal !== void 0 && (s.signal = r.signal);
+    const o = r.documents.map(({ document: h }) => Re(h).query), a = r.documents.map(({ variables: h }) => h);
+    return ke({
+      url: this.url,
+      query: o,
+      // @ts-expect-error TODO reconcile batch variables into system.
+      variables: a,
+      headers: _(_({}, Y(Le(i))), Y(r.requestHeaders)),
+      operationName: void 0,
+      fetch: (f = this.requestConfig.fetch) != null ? f : me,
+      method: this.requestConfig.method || "POST",
+      fetchOptions: s,
+      middleware: this.requestConfig.requestMiddleware
+    }).then((h) => (this.requestConfig.responseMiddleware && this.requestConfig.responseMiddleware(h), h.data)).catch((h) => {
+      throw this.requestConfig.responseMiddleware && this.requestConfig.responseMiddleware(h), h;
+    });
+  }
+  setHeaders(t) {
+    return this.requestConfig.headers = t, this;
+  }
+  /**
+   * Attach a header to the client. All subsequent requests will have this header.
+   */
+  setHeader(t, n) {
+    const { headers: r } = this.requestConfig;
+    return r ? r[t] = n : this.requestConfig.headers = { [t]: n }, this;
+  }
+  /**
+   * Change the client endpoint. All subsequent requests will send to this endpoint.
+   */
+  setEndpoint(t) {
+    return this.url = t, this;
+  }
+}
+const ke = (e) => U(void 0, null, function* () {
+  var h, m;
+  const { query: t, variables: n, fetchOptions: r } = e, i = ir(Qn((h = e.method) != null ? h : "post")), s = Array.isArray(e.query), o = yield i(e), a = yield or(o, (m = r.jsonSerializer) != null ? m : We), c = Array.isArray(a) ? !a.some(({ data: S }) => !S) : !!a.data, f = Array.isArray(a) || !a.errors || Array.isArray(a.errors) && !a.errors.length || r.errorPolicy === "all" || r.errorPolicy === "ignore";
+  if (o.ok && f && c) {
+    const E = (Array.isArray(a), a), { errors: S } = E, y = H(E, ["errors"]), N = r.errorPolicy === "ignore" ? y : a;
+    return q(_({}, s ? { data: N } : N), {
+      headers: o.headers,
+      status: o.status
+    });
+  } else {
+    const S = typeof a == "string" ? {
+      error: a
+    } : a;
+    throw new X(
+      // @ts-expect-error TODO
+      q(_({}, S), { status: o.status, headers: o.headers }),
+      { query: t, variables: n }
+    );
+  }
+}), sr = (e, t, n, r) => {
+  const i = r != null ? r : We;
+  if (!Array.isArray(e))
+    return i.stringify({ query: e, variables: t, operationName: n });
+  if (typeof t != "undefined" && !Array.isArray(t))
+    throw new Error("Cannot create request body with given variable type, array expected");
+  const s = e.reduce((o, a, c) => (o.push({ query: a, variables: t ? t[c] : void 0 }), o), []);
+  return i.stringify(s);
+}, or = (e, t) => U(void 0, null, function* () {
+  let n;
+  return e.headers.forEach((r, i) => {
+    i.toLowerCase() === "content-type" && (n = r);
+  }), n && (n.toLowerCase().startsWith("application/json") || n.toLowerCase().startsWith("application/graphql+json") || n.toLowerCase().startsWith("application/graphql-response+json")) ? t.parse(yield e.text()) : e.text();
+}), Le = (e) => typeof e == "function" ? e() : e;
+var He = { exports: {} };
+(function(e, t) {
+  t = e.exports = n, t.getSerialize = r;
+  function n(i, s, o, a) {
+    return JSON.stringify(i, r(s, a), o);
+  }
+  function r(i, s) {
+    var o = [], a = [];
+    return s == null && (s = function(c, f) {
+      return o[0] === f ? "[Circular ~]" : "[Circular ~." + a.slice(0, o.indexOf(f)).join(".") + "]";
+    }), function(c, f) {
+      if (o.length > 0) {
+        var h = o.indexOf(this);
+        ~h ? o.splice(h + 1) : o.push(this), ~h ? a.splice(h, 1 / 0, c) : a.push(c), ~o.indexOf(f) && (f = s.call(this, c, f));
+      } else o.push(f);
+      return i == null ? f : i.call(this, c, f);
+    };
+  }
+})(He, He.exports);
+var ar = He.exports;
+const Si = /* @__PURE__ */ Ze(ar);
+var ye = function() {
+  return ye = Object.assign || function(t) {
+    for (var n, r = 1, i = arguments.length; r < i; r++) {
+      n = arguments[r];
+      for (var s in n) Object.prototype.hasOwnProperty.call(n, s) && (t[s] = n[s]);
+    }
+    return t;
+  }, ye.apply(this, arguments);
+}, ge = /* @__PURE__ */ new Map(), Ge = /* @__PURE__ */ new Map(), Lt = !0, Ee = !1;
+function Pt(e) {
+  return e.replace(/[\s,]+/g, " ").trim();
+}
+function cr(e) {
+  return Pt(e.source.body.substring(e.start, e.end));
+}
+function ur(e) {
+  var t = /* @__PURE__ */ new Set(), n = [];
+  return e.definitions.forEach(function(r) {
+    if (r.kind === "FragmentDefinition") {
+      var i = r.name.value, s = cr(r.loc), o = Ge.get(i);
+      o && !o.has(s) ? Lt && console.warn("Warning: fragment with name " + i + ` already exists.
+graphql-tag enforces all fragment names across your application to be unique; read more about
+this in the docs: http://dev.apollodata.com/core/fragments.html#unique-names`) : o || Ge.set(i, o = /* @__PURE__ */ new Set()), o.add(s), t.has(s) || (t.add(s), n.push(r));
+    } else
+      n.push(r);
+  }), ye(ye({}, e), { definitions: n });
+}
+function lr(e) {
+  var t = new Set(e.definitions);
+  t.forEach(function(r) {
+    r.loc && delete r.loc, Object.keys(r).forEach(function(i) {
+      var s = r[i];
+      s && typeof s == "object" && t.add(s);
+    });
+  });
+  var n = e.loc;
+  return n && (delete n.startToken, delete n.endToken), e;
+}
+function fr(e) {
+  var t = Pt(e);
+  if (!ge.has(t)) {
+    var n = Rt(e, {
+      experimentalFragmentVariables: Ee,
+      allowLegacyFragmentVariables: Ee
+    });
+    if (!n || n.kind !== "Document")
+      throw new Error("Not a valid GraphQL document.");
+    ge.set(t, lr(ur(n)));
+  }
+  return ge.get(t);
+}
+function R(e) {
+  for (var t = [], n = 1; n < arguments.length; n++)
+    t[n - 1] = arguments[n];
+  typeof e == "string" && (e = [e]);
+  var r = e[0];
+  return t.forEach(function(i, s) {
+    i && i.kind === "Document" ? r += i.loc.source.body : r += i, r += e[s + 1];
+  }), fr(r);
+}
+function hr() {
+  ge.clear(), Ge.clear();
+}
+function dr() {
+  Lt = !1;
+}
+function pr() {
+  Ee = !0;
+}
+function mr() {
+  Ee = !1;
+}
+var ne = {
+  gql: R,
+  resetCaches: hr,
+  disableFragmentWarnings: dr,
+  enableExperimentalFragmentVariables: pr,
+  disableExperimentalFragmentVariables: mr
+};
+(function(e) {
+  e.gql = ne.gql, e.resetCaches = ne.resetCaches, e.disableFragmentWarnings = ne.disableFragmentWarnings, e.enableExperimentalFragmentVariables = ne.enableExperimentalFragmentVariables, e.disableExperimentalFragmentVariables = ne.disableExperimentalFragmentVariables;
+})(R || (R = {}));
+R.default = R;
+const Ft = R`
+	fragment MatchParts on MatchConfig {
+		regexValue
+		matchValue
+	}
+`, gr = R`
+	mutation PushPayload(
+		$session_secure_id: String!
+		$payload_id: ID!
+		$events: ReplayEventsInput!
+		$messages: String!
+		$resources: String!
+		$web_socket_events: String!
+		$errors: [ErrorObjectInput]!
+		$is_beacon: Boolean
+		$has_session_unloaded: Boolean
+		$highlight_logs: String
+	) {
+		pushPayload(
+			session_secure_id: $session_secure_id
+			payload_id: $payload_id
+			events: $events
+			messages: $messages
+			resources: $resources
+			web_socket_events: $web_socket_events
+			errors: $errors
+			is_beacon: $is_beacon
+			has_session_unloaded: $has_session_unloaded
+			highlight_logs: $highlight_logs
+		)
+	}
+`, yr = R`
+	mutation PushSessionEvents(
+		$session_secure_id: String!
+		$payload_id: Int64ID!
+		$data: String!
+	) {
+		pushSessionEvents(
+			session_secure_id: $session_secure_id
+			payload_id: $payload_id
+			data: $data
+		)
+	}
+`, Er = R`
+	mutation identifySession(
+		$session_secure_id: String!
+		$user_identifier: String!
+		$user_object: Any
+	) {
+		identifySession(
+			session_secure_id: $session_secure_id
+			user_identifier: $user_identifier
+			user_object: $user_object
+		)
+	}
+`, _r = R`
+	mutation addSessionProperties(
+		$session_secure_id: String!
+		$properties_object: Any
+	) {
+		addSessionProperties(
+			session_secure_id: $session_secure_id
+			properties_object: $properties_object
+		)
+	}
+`, Tr = R`
+	mutation pushMetrics($metrics: [MetricInput]!) {
+		pushMetrics(metrics: $metrics)
+	}
+`, vr = R`
+	mutation addSessionFeedback(
+		$session_secure_id: String!
+		$user_name: String
+		$user_email: String
+		$verbatim: String!
+		$timestamp: Timestamp!
+	) {
+		addSessionFeedback(
+			session_secure_id: $session_secure_id
+			user_name: $user_name
+			user_email: $user_email
+			verbatim: $verbatim
+			timestamp: $timestamp
+		)
+	}
+`, Sr = R`
+	mutation initializeSession(
+		$session_secure_id: String!
+		$session_key: String
+		$organization_verbose_id: String!
+		$enable_strict_privacy: Boolean!
+		$privacy_setting: String!
+		$enable_recording_network_contents: Boolean!
+		$clientVersion: String!
+		$firstloadVersion: String!
+		$clientConfig: String!
+		$environment: String!
+		$id: String!
+		$appVersion: String
+		$serviceName: String!
+		$client_id: String!
+		$network_recording_domains: [String!]
+		$disable_session_recording: Boolean
+	) {
+		initializeSession(
+			session_secure_id: $session_secure_id
+			session_key: $session_key
+			organization_verbose_id: $organization_verbose_id
+			enable_strict_privacy: $enable_strict_privacy
+			enable_recording_network_contents: $enable_recording_network_contents
+			clientVersion: $clientVersion
+			firstloadVersion: $firstloadVersion
+			clientConfig: $clientConfig
+			environment: $environment
+			appVersion: $appVersion
+			serviceName: $serviceName
+			fingerprint: $id
+			client_id: $client_id
+			network_recording_domains: $network_recording_domains
+			disable_session_recording: $disable_session_recording
+			privacy_setting: $privacy_setting
+		) {
+			secure_id
+			project_id
+			sampling {
+				spans {
+					name {
+						...MatchParts
+					}
+					attributes {
+						key {
+							...MatchParts
+						}
+						attribute {
+							...MatchParts
+						}
+					}
+					events {
+						name {
+							...MatchParts
+						}
+						attributes {
+							key {
+								...MatchParts
+							}
+							attribute {
+								...MatchParts
+							}
+						}
+					}
+					samplingRatio
+				}
+				logs {
+					message {
+						...MatchParts
+					}
+					severityText {
+						...MatchParts
+					}
+					attributes {
+						key {
+							...MatchParts
+						}
+						attribute {
+							...MatchParts
+						}
+					}
+					samplingRatio
+				}
+			}
+		}
+	}
+	${Ft}
+`, Ar = R`
+	query Ignore($id: ID!) {
+		ignore(id: $id)
+	}
+`, Nr = R`
+	query GetSamplingConfig($organization_verbose_id: String!) {
+		sampling(organization_verbose_id: $organization_verbose_id) {
+			spans {
+				name {
+					...MatchParts
+				}
+				attributes {
+					key {
+						...MatchParts
+					}
+					attribute {
+						...MatchParts
+					}
+				}
+				events {
+					name {
+						...MatchParts
+					}
+					attributes {
+						key {
+							...MatchParts
+						}
+						attribute {
+							...MatchParts
+						}
+					}
+				}
+				samplingRatio
+			}
+			logs {
+				message {
+					...MatchParts
+				}
+				severityText {
+					...MatchParts
+				}
+				attributes {
+					key {
+						...MatchParts
+					}
+					attribute {
+						...MatchParts
+					}
+				}
+				samplingRatio
+			}
+		}
+	}
+	${Ft}
+`, Ir = (e, t, n, r) => e();
+function Ai(e, t = Ir) {
+  return {
+    PushPayload(n, r) {
+      return t(
+        (i) => e.request(
+          gr,
+          n,
+          _(_({}, r), i)
+        ),
+        "PushPayload",
+        "mutation",
+        n
+      );
+    },
+    PushSessionEvents(n, r) {
+      return t(
+        (i) => e.request(
+          yr,
+          n,
+          _(_({}, r), i)
+        ),
+        "PushSessionEvents",
+        "mutation",
+        n
+      );
+    },
+    identifySession(n, r) {
+      return t(
+        (i) => e.request(
+          Er,
+          n,
+          _(_({}, r), i)
+        ),
+        "identifySession",
+        "mutation",
+        n
+      );
+    },
+    addSessionProperties(n, r) {
+      return t(
+        (i) => e.request(
+          _r,
+          n,
+          _(_({}, r), i)
+        ),
+        "addSessionProperties",
+        "mutation",
+        n
+      );
+    },
+    pushMetrics(n, r) {
+      return t(
+        (i) => e.request(
+          Tr,
+          n,
+          _(_({}, r), i)
+        ),
+        "pushMetrics",
+        "mutation",
+        n
+      );
+    },
+    addSessionFeedback(n, r) {
+      return t(
+        (i) => e.request(
+          vr,
+          n,
+          _(_({}, r), i)
+        ),
+        "addSessionFeedback",
+        "mutation",
+        n
+      );
+    },
+    initializeSession(n, r) {
+      return t(
+        (i) => e.request(
+          Sr,
+          n,
+          _(_({}, r), i)
+        ),
+        "initializeSession",
+        "mutation",
+        n
+      );
+    },
+    Ignore(n, r) {
+      return t(
+        (i) => e.request(Ar, n, _(_({}, r), i)),
+        "Ignore",
+        "query",
+        n
+      );
+    },
+    GetSamplingConfig(n, r) {
+      return t(
+        (i) => e.request(
+          Nr,
+          n,
+          _(_({}, r), i)
+        ),
+        "GetSamplingConfig",
+        "query",
+        n
+      );
+    }
+  };
+}
+function Ni(e, t, n) {
+  try {
+    if (!(t in e))
+      return () => {
+      };
+    const r = e[t], i = n(r);
+    return typeof i == "function" && (i.prototype = i.prototype || {}, Object.defineProperties(i, {
+      __rrweb_original__: {
+        enumerable: !1,
+        value: r
+      }
+    })), e[t] = i, () => {
+      e[t] = r;
+    };
+  } catch (r) {
+    return () => {
+    };
+  }
+}
+function br(e) {
+  if (!e || !e.outerHTML)
+    return "";
+  let t = "";
+  for (; e.parentElement; ) {
+    let n = e.localName;
+    if (!n)
+      break;
+    n = n.toLowerCase();
+    let r = e.parentElement, i = [];
+    if (r.children && r.children.length > 0)
+      for (let s = 0; s < r.children.length; s++) {
+        let o = r.children[s];
+        o.localName && o.localName.toLowerCase && o.localName.toLowerCase() === n && i.push(o);
+      }
+    i.length > 1 && (n += ":eq(" + i.indexOf(e) + ")"), t = n + (t ? ">" + t : ""), e = r;
+  }
+  return t;
+}
+function Ye(e) {
+  return Object.prototype.toString.call(e) === "[object Object]";
+}
+function Mt(e, t) {
+  if (t === 0)
+    return !0;
+  const n = Object.keys(e);
+  for (const r of n)
+    if (Ye(e[r]) && Mt(e[r], t - 1))
+      return !0;
+  return !1;
+}
+function Ii(e, t) {
+  const n = {
+    numOfKeysLimit: 50,
+    depthOfLimit: 4
+  };
+  Object.assign(n, t);
+  const r = [], i = [];
+  return JSON.stringify(e, function(a, c) {
+    if (r.length > 0) {
+      const f = r.indexOf(this);
+      ~f ? r.splice(f + 1) : r.push(this), ~f ? i.splice(f, 1 / 0, a) : i.push(a), ~r.indexOf(c) && (r[0] === c ? c = "[Circular ~]" : c = "[Circular ~." + i.slice(0, r.indexOf(c)).join(".") + "]");
+    } else
+      r.push(c);
+    if (c == null)
+      return c;
+    if (s(c))
+      return o(c);
+    if (c instanceof Event) {
+      const f = {};
+      for (const h in c) {
+        const m = c[h];
+        Array.isArray(m) ? f[h] = br(
+          m.length ? m[0] : null
+        ) : f[h] = m;
+      }
+      return f;
+    } else {
+      if (c instanceof Node)
+        return c instanceof HTMLElement ? c ? c.outerHTML : "" : c.nodeName;
+      if (c instanceof Error)
+        return c.name + ": " + c.message;
+    }
+    return c;
+  });
+  function s(a) {
+    return Ye(a) && Object.keys(a).length > n.numOfKeysLimit || typeof a == "function" ? !0 : a instanceof Event && a.isTrusted === !1 ? Object.keys(a).length === 1 : !!(Ye(a) && Mt(a, n.depthOfLimit));
+  }
+  function o(a) {
+    let c = a.toString();
+    return n.stringLengthLimit && c.length > n.stringLengthLimit && (c = `${c.slice(0, n.stringLengthLimit)}...`), c;
+  }
+}
+function xr() {
+  var e = document.createElement("canvas");
+  return e.getContext && e.getContext("2d") ? e.toDataURL("image/webp").indexOf("data:image/webp") == 0 : !1;
+}
+function bi() {
+  return xr() ? {
+    type: "image/webp",
+    quality: 0.9
+  } : {
+    type: "image/jpeg",
+    quality: 0.6
+  };
+}
+function xi(e) {
+  return typeof e == "number" && !isNaN(e) && isFinite(e);
+}
+const Oi = "exception.message", Di = "exception.stacktrace", wi = "exception.type", Ci = "http.response.status_code", Ri = "server.address", ki = "service.name", Li = "service.version", Pi = "telemetry.sdk.name", Fi = "telemetry.sdk.version", Mi = "url.full", $i = "url.path", Ui = "url.query", Bi = "user_agent.original", Vi = 1e3, ji = 1e3 * 2, qi = 4 * 60 * 60 * 1e3, et = 15 * 60 * 1e3, Hi = {
+  normal: {
+    bytes: 1e7,
+    time: 4 * 60 * 1e3
+  },
+  canvas: {
+    bytes: 16e6,
+    time: 5e3
+  }
+}, Gi = 100, Yi = "app.highlight.io", zi = "https://app.launchdarkly.com", Ji = {
+  "observability.ld-stg.launchdarkly.com": "ld-stg.launchdarkly.com",
+  "observability.app.launchdarkly.com": "app.launchdarkly.com",
+  "observability.app.ld.catamorphic.com": "app.ld.catamorphic.com"
+}, Xi = "/projects/default", Qi = new RegExp("pub\\.(?<domain>.+)");
+/*! js-cookie v3.0.8 | MIT */
+function le(e) {
+  for (var t = 1; t < arguments.length; t++) {
+    var n = arguments[t];
+    for (var r in n)
+      r !== "__proto__" && (e[r] = n[r]);
+  }
+  return e;
+}
+var Or = {
+  read: function(e) {
+    return e[0] === '"' && (e = e.slice(1, -1)), e.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
+  },
+  write: function(e) {
+    return encodeURIComponent(e).replace(
+      /%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g,
+      decodeURIComponent
+    );
+  }
+};
+function ze(e, t) {
+  function n(i, s, o) {
+    if (typeof document != "undefined") {
+      o = le({}, t, o), typeof o.expires == "number" && (o.expires = new Date(Date.now() + o.expires * 864e5)), o.expires && (o.expires = o.expires.toUTCString()), i = encodeURIComponent(i).replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent).replace(/[()]/g, escape);
+      var a = "";
+      for (var c in o)
+        o[c] && (a += "; " + c, o[c] !== !0 && (a += "=" + o[c].split(";")[0]));
+      return document.cookie = i + "=" + e.write(s, i) + a;
+    }
+  }
+  function r(i) {
+    if (!(typeof document == "undefined" || arguments.length && !i)) {
+      for (var s = document.cookie ? document.cookie.split("; ") : [], o = {}, a = 0; a < s.length; a++) {
+        var c = s[a].split("="), f = c.slice(1).join("=");
+        try {
+          var h = decodeURIComponent(c[0]);
+          if (h in o || (o[h] = e.read(f, h)), i === h)
+            break;
+        } catch (m) {
+        }
+      }
+      return i ? o[i] : o;
+    }
+  }
+  return Object.create(
+    {
+      set: n,
+      get: r,
+      remove: function(i, s) {
+        n(
+          i,
+          "",
+          le({}, s, {
+            expires: -1
+          })
+        );
+      },
+      withAttributes: function(i) {
+        return ze(this.converter, le({}, this.attributes, i));
+      },
+      withConverter: function(i) {
+        return ze(le({}, this.converter, i), this.attributes);
+      }
+    },
+    {
+      attributes: { value: Object.freeze(t) },
+      converter: { value: Object.freeze(e) }
+    }
+  );
+}
+var fe = ze(Or, { path: "/" }), Dr = /* @__PURE__ */ ((e) => (e.CLIENT_ID = "highlightClientID", e))(Dr || {});
+let _e = "localStorage", Je = !0;
+class wr {
+  constructor() {
+    G(this, "storage", {});
+  }
+  get length() {
+    return Object.keys(this.storage).length;
+  }
+  key(t) {
+    var r;
+    return (r = Object.keys(this.storage)[t]) != null ? r : null;
+  }
+  getItem(t) {
+    var n;
+    return (n = this.storage[t]) != null ? n : "";
+  }
+  setItem(t, n) {
+    this.storage[t] = n;
+  }
+  removeItem(t) {
+    delete this.storage[t];
+  }
+}
+class Cr {
+  getItem(t) {
+    var n;
+    return (n = fe.get(t)) != null ? n : "";
+  }
+  setItem(t, n) {
+    if (!Je)
+      return;
+    const r = /* @__PURE__ */ new Date();
+    r.setTime(r.getTime() + et), fe.set(t, n, { expires: r });
+  }
+  removeItem(t) {
+    Je && fe.remove(t);
+  }
+  keys() {
+    var t;
+    return Object.keys((t = fe.get()) != null ? t : {});
+  }
+}
+const Q = new wr(), W = new Cr(), Ae = () => {
+  let e = null;
+  if (typeof window == "undefined")
+    return Q;
+  try {
+    switch (_e) {
+      case "localStorage":
+        e = window.localStorage;
+        break;
+      case "sessionStorage":
+        e = window.sessionStorage;
+        break;
+    }
+    e || (K(
+      "storage",
+      "getPersistentStorage",
+      "debug",
+      `persistent storage was not found for mode ${_e}; using global storage`
+    ), e = Q);
+  } catch (t) {
+    K(
+      "storage",
+      "getPersistentStorage",
+      "debug",
+      "failed to get persistent storage; using global storage",
+      t
+    ), e = Q;
+  }
+  return e;
+}, Rr = (e) => {
+  _e = e;
+}, dt = (e) => {
+  Je = e;
+}, tt = (e) => {
+  try {
+    return Ae().getItem(e);
+  } catch (t) {
+    return K(
+      "storage",
+      "getItem",
+      "debug",
+      `failed to get item ${e}; using global storage`,
+      t
+    ), Q.getItem(e);
+  }
+}, $t = (e, t) => {
+  W.setItem(e, t);
+  try {
+    return Ae().setItem(e, t);
+  } catch (n) {
+    return K(
+      "storage",
+      "setItem",
+      "debug",
+      `failed to set item ${e}; using global storage`,
+      n
+    ), Q.setItem(e, t);
+  }
+}, Ut = (e) => {
+  W.removeItem(e);
+  try {
+    return Ae().removeItem(e);
+  } catch (t) {
+    return K(
+      "storage",
+      "removeItem",
+      "debug",
+      `failed to remove item ${e}; using global storage`,
+      t
+    ), Q.removeItem(e);
+  }
+}, Ki = (e) => {
+  if (_e === "sessionStorage") {
+    console.warn(
+      "highlight.io cannot use local storage; segment integration will not work"
+    );
+    return;
+  }
+  if (typeof window == "undefined") {
+    console.warn(
+      "highlight.io cannot use local storage (not a window); segment integration will not work"
+    );
+    return;
+  }
+  const t = window.localStorage.setItem;
+  window.localStorage.setItem = function() {
+    const [n, r] = arguments;
+    e({ keyName: n, keyValue: r }), t.apply(this, [n, r]);
+  };
+};
+var ee = /* @__PURE__ */ ((e) => (e.SEGMENT_LAST_SENT_HASH_KEY = "HIGHLIGHT_SEGMENT_LAST_SENT_HASH_KEY", e.SESSION_ID = "sessionID", e.SESSION_DATA = "sessionData", e.USER_IDENTIFIER = "highlightIdentifier", e.USER_OBJECT = "highlightUserObject", e))(ee || {});
+const Ne = (e) => `${ee.SESSION_DATA}_${e}`, kr = () => {
+  var e;
+  return typeof globalThis != "undefined" && ((e = globalThis.persistentSessionSecureID) != null && e.length) ? globalThis.persistentSessionSecureID : Bt();
+}, Lr = (e) => {
+  typeof globalThis != "undefined" && (e != null && e.length) && (globalThis.persistentSessionSecureID = e);
+}, Bt = () => {
+  var e;
+  return (e = tt(ee.SESSION_ID)) != null ? e : "";
+}, Vt = (e) => {
+  $t(ee.SESSION_ID, e);
+}, Pr = (e) => {
+  const t = Ne(e);
+  return JSON.parse(tt(t) || "{}");
+}, Fr = (e) => {
+  e || (e = Bt());
+  let t = Pr(e);
+  if (t && t.lastPushTime && Date.now() - t.lastPushTime < et)
+    return t;
+  Ut(Ne(e));
+}, jt = function(e) {
+  if (!(e != null && e.sessionSecureID)) return;
+  const t = e.sessionSecureID;
+  Lr(t);
+  const n = Ne(t);
+  $t(n, JSON.stringify(e)), $r(n);
+}, Mr = function() {
+  const e = W.getItem(
+    ee.SESSION_ID
+  );
+  Vt(e);
+  const t = Ne(e), n = W.getItem(t);
+  try {
+    jt(JSON.parse(n));
+  } catch (r) {
+  }
+};
+function $r(e) {
+  var i;
+  const t = `${ee.SESSION_DATA}_`, n = /* @__PURE__ */ new Set(), r = Ae();
+  for (let s = r.length - 1; s >= 0; s--) {
+    const o = r.key(s);
+    o && o.startsWith(t) && o !== e && n.add(o);
+  }
+  for (const s of W.keys())
+    s.startsWith(t) && s !== e && n.add(s);
+  for (const s of n) {
+    let o = !0;
+    try {
+      const a = tt(s) || W.getItem(s) || "{}", c = JSON.parse(a), f = (i = c.lastPushTime) != null ? i : c.sessionStartTime;
+      o = f === void 0 || Date.now() - f >= et;
+    } catch (a) {
+    }
+    o && (K(
+      "highlightSession",
+      "pruneSessionData",
+      "debug",
+      `removing session data for stale key ${s}`
+    ), Ut(s));
+  }
+}
+var qt = /* @__PURE__ */ ((e) => (e.BillingQuotaExceeded = "BillingQuotaExceeded", e))(qt || {});
+const Ur = 3, Br = 1e3, Vr = 500, jr = [qt.BillingQuotaExceeded.toString()], qr = (e) => {
+  var n;
+  return ((n = e.response.errors) == null ? void 0 : n.find(
+    (r) => jr.includes(r.message)
+  )) === void 0;
+}, Wi = () => {
+  const e = (t, n, r, i, s = 0) => U(void 0, null, function* () {
+    try {
+      return yield t();
+    } catch (o) {
+      if (o instanceof X && !qr(o))
+        throw o;
+      if (s < Ur)
+        return yield new Promise(
+          (a) => setTimeout(
+            a,
+            Br + Vr * Math.pow(2, s)
+          )
+        ), yield e(
+          t,
+          n,
+          r,
+          i,
+          s + 1
+        );
+      throw console.error(
+        `highlight.io: data request failed after ${s} retries`
+      ), o;
+    }
+  });
+  return e;
+}, C = "feature_flag", Ht = "launchdarkly", Gt = "evaluation", Hr = `${C}.${Gt}`, Zi = `${C}.set.id`, Gr = `${C}.key`, Yr = `${C}.contextKeys`, zr = `${C}.context.id`, Jr = `${C}.result.value`, Xr = `${C}.provider.name`, pt = {
+  kind: `${C}.result.reason.kind`,
+  errorKind: `${C}.result.reason.errorKind`,
+  ruleIndex: `${C}.result.reason.ruleIndex`,
+  ruleId: `${C}.result.reason.ruleId`,
+  prerequisiteKey: `${C}.result.reason.prerequisiteKey`,
+  inExperiment: `${C}.result.reason.inExperiment`,
+  bigSegmentsStatus: `${C}.result.reason.bigSegmentsStatus`
+}, Qr = `${C}.result.variationIndex`, es = `${Ht}.application.id`, ts = `${Ht}.application.version`, Kr = "context", ns = `${Kr}.contextKeys`, Wr = "$ld:telemetry:session:init", mt = "$ld:telemetry:track", rs = "launchdarkly.track", is = "page_view", ss = "document_load", os = "result.status";
+function gt(e) {
+  return e.includes("%") || e.includes(":") ? e.replace(/%/g, "%25").replace(/:/g, "%3A") : e;
+}
+function Yt(e) {
+  return e.kind === "multi";
+}
+function yt(e) {
+  return Yt(e) ? Object.keys(e).sort().filter((t) => t !== "kind").map((t) => `${t}:${gt(e[t].key)}`).join(":") : "kind" in e && e.kind === "user" ? e.key : "kind" in e ? `${e.kind}:${gt(e.key)}` : e.key;
+}
+function Et(e) {
+  return Yt(e) ? Object.keys(e).sort().filter((t) => t !== "kind").map((t) => ({
+    [t]: e[t].key
+  })).reduce((t, n) => _(_({}, t), n), {}) : "kind" in e ? {
+    [e.kind]: e.key
+  } : {
+    user: e.key
+  };
+}
+function as(e, t, n) {
+  t.addHook({
+    getMetadata: () => ({
+      name: "highlight.run"
+    }),
+    afterIdentify: (r, i, s) => {
+      var a, c;
+      const o = q(_({}, Et(r.context)), {
+        key: (c = (a = n == null ? void 0 : n.contextFriendlyName) == null ? void 0 : a.call(n, r.context)) != null ? c : yt(r.context)
+      });
+      return e.log("LD.identify", "INFO", o), s.status === "completed" && e.identify(o.key, o, "LaunchDarkly"), i;
+    },
+    afterEvaluation: (r, i, s) => {
+      const o = _({
+        [Xr]: "LaunchDarkly",
+        [Gr]: r.flagKey,
+        [Jr]: JSON.stringify(s.value)
+      }, s.variationIndex !== void 0 && s.variationIndex !== null ? {
+        [Qr]: s.variationIndex
+      } : {});
+      if (s.reason)
+        for (const a in pt) {
+          const c = a, f = s.reason[c];
+          f != null && (o[pt[c]] = f);
+        }
+      return r.context && (o[Yr] = JSON.stringify(
+        Et(r.context)
+      ), o[zr] = yt(
+        r.context
+      )), e.startSpan(Gt, (a) => {
+        a && a.addEvent(Hr, o);
+      }), i;
+    }
+  });
+}
+class Zr {
+  constructor(t, n) {
+    G(this, "client");
+    G(this, "metadata");
+    this.client = t, this.metadata = n;
+  }
+  getHooks(t) {
+    return [];
+  }
+  init(t) {
+    this.client.track(Wr, {
+      sessionID: t
+    });
+  }
+  recordGauge(t, n) {
+  }
+  identify(t, n, r = {}, i) {
+  }
+  error(t, n) {
+  }
+  track(t, n) {
+    const r = n.event;
+    this.client.track(
+      r ? `${mt}:${r}` : mt,
+      q(_({}, n), {
+        sessionID: t
+      })
+    );
+  }
+}
+class cs extends an {
+  constructor(n, r) {
+    super();
+    G(this, "client");
+    this.client = new Zr(n, r);
+  }
+  getHooks(n) {
+    return [
+      {
+        getMetadata: () => ({
+          name: "highlight.run/ld"
+        }),
+        afterIdentify: (r, i, s) => (this.load(this.client), i)
+      }
+    ];
+  }
+  init(n) {
+    return this._bufferCall("init", [n]);
+  }
+  recordGauge(n, r) {
+    return this._bufferCall("recordGauge", [n, r]);
+  }
+  identify(n, r, i = {}, s) {
+    return this._bufferCall("identify", [
+      n,
+      r,
+      i,
+      s
+    ]);
+  }
+  error(n, r) {
+    return this._bufferCall("error", [n, r]);
+  }
+  track(n, r) {
+    return this._bufferCall("track", [n, r]);
+  }
+}
+const us = (e) => {
+  e(window.location.href);
+  const t = history.pushState;
+  history.pushState = /* @__PURE__ */ ((s) => function() {
+    var a = s.apply(this, arguments);
+    return window.dispatchEvent(new Event("pushstate")), window.dispatchEvent(new Event("locationchange")), a;
+  })(history.pushState);
+  const n = history.replaceState;
+  history.replaceState = /* @__PURE__ */ ((s) => function() {
+    var a = s.apply(this, arguments);
+    return window.dispatchEvent(new Event("replacestate")), window.dispatchEvent(new Event("locationchange")), a;
+  })(history.replaceState);
+  const r = () => {
+    window.dispatchEvent(new Event("locationchange"));
+  };
+  window.addEventListener("popstate", r);
+  const i = function() {
+    e(window.location.href);
+  };
+  return window.addEventListener("locationchange", i), () => {
+    window.removeEventListener("popstate", r), window.removeEventListener("locationchange", i), history.pushState = t, history.replaceState = n;
+  };
+}, ei = "1.2.0", ti = {
+  version: ei
+}, ls = ti.version;
+let L, nt;
+function fs(e, t) {
+  return e.nodeType, Node.ELEMENT_NODE, Xe(e);
+  return ni(e, t);
+}
+function hs(e) {
+  if (e.id.length)
+    return `#${e.id}`;
+  if (e.classList.length) {
+    let t = [];
+    for (const n of e.classList)
+      t.push(`.${n}`);
+    return `${e.nodeName.toLowerCase()}${t.join(",")}`;
+  }
+  return e.nodeName.toLowerCase();
+}
+function ni(e, t) {
+  if (e.tagName.toLowerCase() === "html")
+    return "html";
+  try {
+    const n = {
+      root: document.body,
+      idName: (i) => !0,
+      className: (i) => !0,
+      tagName: (i) => !0,
+      attr: (i, s) => !1,
+      seedMinLength: 1,
+      optimizedMinLength: 2,
+      threshold: 50,
+      maxNumberOfTries: 1e3,
+      optimized: !0
+    };
+    L = _(_({}, n), t), nt = ri(L.root, n);
+    let r = Pe(
+      e,
+      0,
+      () => Pe(
+        e,
+        1,
+        () => Pe(
+          e,
+          2
+          /* One */
+        )
+      )
+    );
+    if (r) {
+      if (L.optimized) {
+        const i = Xt(Qt(r, e));
+        i.length > 0 && (r = i[0]);
+      }
+      return Ie(r);
+    } else
+      return Xe(e);
+  } catch (n) {
+    return Xe(e);
+  }
+}
+function ri(e, t) {
+  return e.nodeType === Node.DOCUMENT_NODE ? e : e === t.root ? e.ownerDocument : e;
+}
+function Pe(e, t, n) {
+  let r = null, i = [], s = e, o = 0;
+  for (; s && s !== L.root.parentElement; ) {
+    let a = he(ii(s)) || he(...si(s)) || he(...oi(s)) || he(ai(s)) || [ci()];
+    const c = ui(s);
+    if (t === 0)
+      c && (a = a.concat(
+        a.filter(Me).map((f) => Fe(f, c))
+      ));
+    else if (t === 1)
+      a = a.slice(0, 1), c && (a = a.concat(
+        a.filter(Me).map((f) => Fe(f, c))
+      ));
+    else if (t === 2) {
+      const [f] = a = a.slice(0, 1);
+      c && Me(f) && (a = [Fe(f, c)]);
+    }
+    for (let f of a)
+      f.level = o;
+    if (i.push(a), i.length >= L.seedMinLength && (r = _t(i, n), r))
+      break;
+    s = s.parentElement, o++;
+  }
+  return r || (r = _t(i, n)), r;
+}
+function _t(e, t) {
+  const n = Xt(Jt(e));
+  if (n.length > L.threshold)
+    return t ? t() : null;
+  for (let r of n)
+    if (zt(r))
+      return r;
+  return null;
+}
+function Ie(e) {
+  let t = e[0], n = t.name;
+  for (let r = 1; r < e.length; r++) {
+    const i = e[r].level || 0;
+    t.level === i - 1 ? n = `${e[r].name} > ${n}` : n = `${e[r].name} ${n}`, t = e[r];
+  }
+  return n;
+}
+function Tt(e) {
+  return e.map((t) => t.penalty).reduce((t, n) => t + n, 0);
+}
+function zt(e) {
+  switch (nt.querySelectorAll(Ie(e)).length) {
+    case 0:
+      return !0;
+    case 1:
+      return !0;
+    default:
+      return !1;
+  }
+}
+function ii(e) {
+  const t = e.getAttribute("id");
+  return t && L.idName(t) ? {
+    name: "#" + Te(t, { isIdentifier: !0 }),
+    penalty: 0
+  } : null;
+}
+function si(e) {
+  return Array.from(e.attributes).filter(
+    (n) => L.attr(n.name, n.value)
+  ).map(
+    (n) => ({
+      name: "[" + Te(n.name, { isIdentifier: !0 }) + '="' + Te(n.value) + '"]',
+      penalty: 0.5
+    })
+  );
+}
+function oi(e) {
+  return Array.from(e.classList).filter(L.className).map(
+    (n) => ({
+      name: "." + Te(n, { isIdentifier: !0 }),
+      penalty: 1
+    })
+  );
+}
+function ai(e) {
+  const t = e.tagName.toLowerCase();
+  return L.tagName(t) ? {
+    name: t,
+    penalty: 2
+  } : null;
+}
+function ci() {
+  return {
+    name: "*",
+    penalty: 3
+  };
+}
+function ui(e) {
+  const t = e.parentNode;
+  if (!t)
+    return null;
+  let n = t.firstChild;
+  if (!n)
+    return null;
+  let r = 0;
+  for (; n && (n.nodeType === Node.ELEMENT_NODE && r++, n !== e); )
+    n = n.nextSibling;
+  return r;
+}
+function Fe(e, t) {
+  return {
+    name: e.name + `:nth-child(${t})`,
+    penalty: e.penalty + 1
+  };
+}
+function Me(e) {
+  return e.name !== "html" && !e.name.startsWith("#");
+}
+function he(...e) {
+  const t = e.filter(li);
+  return t.length > 0 ? t : null;
+}
+function li(e) {
+  return e != null;
+}
+function* Jt(e, t = []) {
+  if (e.length > 0)
+    for (let n of e[0])
+      yield* we(Jt(e.slice(1, e.length), t.concat(n)));
+  else
+    yield t;
+}
+function Xt(e) {
+  return Array.from(e).sort((t, n) => Tt(t) - Tt(n));
+}
+function* Qt(e, t, n = {
+  counter: 0,
+  visited: /* @__PURE__ */ new Map()
+}) {
+  if (e.length > 2 && e.length > L.optimizedMinLength)
+    for (let r = 1; r < e.length - 1; r++) {
+      if (n.counter > L.maxNumberOfTries)
+        return;
+      n.counter += 1;
+      const i = [...e];
+      i.splice(r, 1);
+      const s = Ie(i);
+      if (n.visited.has(s))
+        return;
+      zt(i) && fi(i, t) && (yield i, n.visited.set(s, !0), yield* we(Qt(i, t, n)));
+    }
+}
+function fi(e, t) {
+  return nt.querySelector(Ie(e)) === t;
+}
+const hi = /[ -,\.\/:-@\[-\^`\{-~]/, di = /[ -,\.\/:-@\[\]\^`\{-~]/, pi = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g, mi = {
+  escapeEverything: !1,
+  isIdentifier: !1,
+  quotes: "single",
+  wrap: !1
+};
+function Te(e, t = {}) {
+  const n = _(_({}, mi), t);
+  n.quotes != "single" && n.quotes != "double" && (n.quotes = "single");
+  const r = n.quotes == "double" ? '"' : "'", i = n.isIdentifier, s = e.charAt(0);
+  let o = "", a = 0;
+  const c = e.length;
+  for (; a < c; ) {
+    const f = e.charAt(a++);
+    let h = f.charCodeAt(0), m;
+    if (h < 32 || h > 126) {
+      if (h >= 55296 && h <= 56319 && a < c) {
+        const E = e.charCodeAt(a++);
+        (E & 64512) == 56320 ? h = ((h & 1023) << 10) + (E & 1023) + 65536 : a--;
+      }
+      m = "\\" + h.toString(16).toUpperCase() + " ";
+    } else
+      n.escapeEverything ? hi.test(f) ? m = "\\" + f : m = "\\" + h.toString(16).toUpperCase() + " " : /[\t\n\f\r\x0B]/.test(f) ? m = "\\" + h.toString(16).toUpperCase() + " " : f == "\\" || !i && (f == '"' && r == f || f == "'" && r == f) || i && di.test(f) ? m = "\\" + f : m = f;
+    o += m;
+  }
+  return i && (/^-[-\d]/.test(o) ? o = "\\-" + o.slice(1) : /\d/.test(s) && (o = "\\3" + s + " " + o.slice(1))), o = o.replace(pi, function(f, h, m) {
+    return h && h.length % 2 ? f : (h || "") + m;
+  }), !i && n.wrap ? r + o + r : o;
+}
+const Xe = (e) => {
+  let t = "";
+  const n = e.getAttribute("class"), r = e.getAttribute("id");
+  return r && (t = t.concat(vt(r, "#"))), n && (t = t.concat(vt(n, "."))), t === "" && (t = t.concat(e.tagName.toLowerCase())), t;
+}, vt = (e, t) => `${t}${e.trim().split(" ").join(t)}`, ds = (e) => {
+  let t;
+  const r = () => {
+    clearTimeout(t), t = setTimeout(() => {
+      var i, s;
+      e({
+        height: window.innerHeight,
+        width: window.innerWidth,
+        availHeight: window.screen.availHeight,
+        availWidth: window.screen.availWidth,
+        colorDepth: window.screen.colorDepth,
+        pixelDepth: window.screen.pixelDepth,
+        orientation: (s = (i = window.screen.orientation) == null ? void 0 : i.angle) != null ? s : 0
+      });
+    }, 500);
+  };
+  return window.addEventListener("resize", r), r(), () => window.removeEventListener("resize", r);
+};
+var Kt = { exports: {} };
+/**
+ * @preserve
+ * JS Implementation of incremental MurmurHash3 (r150) (as of May 10, 2013)
+ *
+ * @author <a href="mailto:jensyt@gmail.com">Jens Taylor</a>
+ * @see http://github.com/homebrewing/brauhaus-diff
+ * @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
+ * @see http://github.com/garycourt/murmurhash-js
+ * @author <a href="mailto:aappleby@gmail.com">Austin Appleby</a>
+ * @see http://sites.google.com/site/murmurhash/
+ */
+(function(e) {
+  (function() {
+    var t;
+    function n(r, i) {
+      var s = this instanceof n ? this : t;
+      if (s.reset(i), typeof r == "string" && r.length > 0 && s.hash(r), s !== this)
+        return s;
+    }
+    n.prototype.hash = function(r) {
+      var i, s, o, a, c;
+      switch (c = r.length, this.len += c, s = this.k1, o = 0, this.rem) {
+        case 0:
+          s ^= c > o ? r.charCodeAt(o++) & 65535 : 0;
+        case 1:
+          s ^= c > o ? (r.charCodeAt(o++) & 65535) << 8 : 0;
+        case 2:
+          s ^= c > o ? (r.charCodeAt(o++) & 65535) << 16 : 0;
+        case 3:
+          s ^= c > o ? (r.charCodeAt(o) & 255) << 24 : 0, s ^= c > o ? (r.charCodeAt(o++) & 65280) >> 8 : 0;
+      }
+      if (this.rem = c + this.rem & 3, c -= this.rem, c > 0) {
+        for (i = this.h1; s = s * 11601 + (s & 65535) * 3432906752 & 4294967295, s = s << 15 | s >>> 17, s = s * 13715 + (s & 65535) * 461832192 & 4294967295, i ^= s, i = i << 13 | i >>> 19, i = i * 5 + 3864292196 & 4294967295, !(o >= c); )
+          s = r.charCodeAt(o++) & 65535 ^ (r.charCodeAt(o++) & 65535) << 8 ^ (r.charCodeAt(o++) & 65535) << 16, a = r.charCodeAt(o++), s ^= (a & 255) << 24 ^ (a & 65280) >> 8;
+        switch (s = 0, this.rem) {
+          case 3:
+            s ^= (r.charCodeAt(o + 2) & 65535) << 16;
+          case 2:
+            s ^= (r.charCodeAt(o + 1) & 65535) << 8;
+          case 1:
+            s ^= r.charCodeAt(o) & 65535;
+        }
+        this.h1 = i;
+      }
+      return this.k1 = s, this;
+    }, n.prototype.result = function() {
+      var r, i;
+      return r = this.k1, i = this.h1, r > 0 && (r = r * 11601 + (r & 65535) * 3432906752 & 4294967295, r = r << 15 | r >>> 17, r = r * 13715 + (r & 65535) * 461832192 & 4294967295, i ^= r), i ^= this.len, i ^= i >>> 16, i = i * 51819 + (i & 65535) * 2246770688 & 4294967295, i ^= i >>> 13, i = i * 44597 + (i & 65535) * 3266445312 & 4294967295, i ^= i >>> 16, i >>> 0;
+    }, n.prototype.reset = function(r) {
+      return this.h1 = typeof r == "number" ? r : 0, this.rem = this.k1 = this.len = 0, this;
+    }, t = new n(), e.exports = n;
+  })();
+})(Kt);
+var gi = Kt.exports;
+const yi = /* @__PURE__ */ Ze(gi), $e = 28, z = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", Ei = 2246822507, St = (e) => {
+  var n;
+  var t = "";
+  if (e) {
+    const r = yi(e).result();
+    for (let i = 0; i < $e; i++) {
+      const o = ((r ^ i * Ei) >>> 0) % z.length;
+      t += z.charAt(o);
+    }
+  } else {
+    const r = typeof window != "undefined" && ((n = window.crypto) == null ? void 0 : n.getRandomValues), i = new Uint32Array($e);
+    r && window.crypto.getRandomValues(i);
+    for (let s = 0; s < $e; s++)
+      r ? t += z.charAt(
+        i[s] % z.length
+      ) : t += z.charAt(
+        Math.floor(Math.random() * z.length)
+      );
+  }
+  return t;
+};
+class ps {
+  constructor(t) {
+    G(this, "sessionSecureID");
+    try {
+      t != null && t.storageMode && Rr(t == null ? void 0 : t.storageMode), dt(!!(t != null && t.sessionCookie)), t != null && t.sessionCookie ? Mr() : dt(!1);
+    } catch (n) {
+      st(
+        "Error initializing @launchdarkly observability plugin",
+        "error",
+        n
+      );
+    }
+  }
+  configureSession(t, n) {
+    try {
+      const r = kr();
+      let i = Fr(
+        r
+      );
+      i != null && i.sessionSecureID ? this.sessionSecureID = i.sessionSecureID : (n != null && n.sessionKey ? this.sessionSecureID = St(
+        `${t}-${n.sessionKey}`
+      ) : this.sessionSecureID = St(), Vt(this.sessionSecureID), jt({
+        sessionSecureID: this.sessionSecureID,
+        sessionKey: n == null ? void 0 : n.sessionKey,
+        projectID: 0,
+        sessionStartTime: Date.now(),
+        lastPushTime: Date.now()
+      }));
+    } catch (r) {
+      st(
+        "Error configuring session in @launchdarkly observability plugin",
+        "error",
+        r
+      );
+    }
+  }
+}
+export {
+  Br as $,
+  Qi as A,
+  zi as B,
+  Ji as C,
+  Xi as D,
+  ps as E,
+  Vi as F,
+  St as G,
+  Yi as H,
+  yt as I,
+  Et as J,
+  ts as K,
+  cs as L,
+  qi as M,
+  es as N,
+  Xr as O,
+  us as P,
+  Zi as Q,
+  Fi as R,
+  ee as S,
+  Pi as T,
+  tr as U,
+  Gi as V,
+  Ze as W,
+  Ni as X,
+  Ii as Y,
+  kr as Z,
+  Ur as _,
+  tt as a,
+  Vr as a0,
+  Mi as a1,
+  is as a2,
+  Ci as a3,
+  Bi as a4,
+  Li as a5,
+  ki as a6,
+  ss as a7,
+  Ui as a8,
+  $i as a9,
+  wi as aa,
+  Oi as ab,
+  Di as ac,
+  ns as ad,
+  Ri as ae,
+  rs as af,
+  Jr as ag,
+  Gt as ah,
+  C as ai,
+  Qr as aj,
+  Gr as ak,
+  pt as al,
+  Yr as am,
+  zr as an,
+  os as ao,
+  bi as b,
+  Ai as c,
+  $t as d,
+  Vt as e,
+  jt as f,
+  Fr as g,
+  ds as h,
+  ji as i,
+  dt as j,
+  Hi as k,
+  Dr as l,
+  Rr as m,
+  Wi as n,
+  vi as o,
+  zn as p,
+  hs as q,
+  Ut as r,
+  Si as s,
+  xi as t,
+  yr as u,
+  as as v,
+  Mr as w,
+  ls as x,
+  fs as y,
+  Ki as z
+};
+//# sourceMappingURL=common-DQ61tUu9.js.map