@cedarjs/web 6.0.0-canary.2780 → 6.0.0-canary.2781

package/dist/bundled/apollo-upload-client.js

@@ -1,4 +1,2730 @@
-import UploadHttpLink from "apollo-upload-client/UploadHttpLink.mjs";
+// ../../node_modules/tslib/tslib.es6.mjs
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+}
+function __spreadArray(to, from, pack) {
+  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+// ../../node_modules/rxjs/dist/esm5/internal/util/isFunction.js
+function isFunction(value) {
+  return typeof value === "function";
+}
+
+// ../../node_modules/rxjs/dist/esm5/internal/util/createErrorClass.js
+function createErrorClass(createImpl) {
+  var _super = function(instance) {
+    Error.call(instance);
+    instance.stack = new Error().stack;
+  };
+  var ctorFunc = createImpl(_super);
+  ctorFunc.prototype = Object.create(Error.prototype);
+  ctorFunc.prototype.constructor = ctorFunc;
+  return ctorFunc;
+}
+
+// ../../node_modules/rxjs/dist/esm5/internal/util/UnsubscriptionError.js
+var UnsubscriptionError = createErrorClass(function(_super) {
+  return function UnsubscriptionErrorImpl(errors) {
+    _super(this);
+    this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+      return i + 1 + ") " + err.toString();
+    }).join("\n  ") : "";
+    this.name = "UnsubscriptionError";
+    this.errors = errors;
+  };
+});
+
+// ../../node_modules/rxjs/dist/esm5/internal/util/arrRemove.js
+function arrRemove(arr, item) {
+  if (arr) {
+    var index = arr.indexOf(item);
+    0 <= index && arr.splice(index, 1);
+  }
+}
+
+// ../../node_modules/rxjs/dist/esm5/internal/Subscription.js
+var Subscription = (function() {
+  function Subscription2(initialTeardown) {
+    this.initialTeardown = initialTeardown;
+    this.closed = false;
+    this._parentage = null;
+    this._finalizers = null;
+  }
+  Subscription2.prototype.unsubscribe = function() {
+    var e_1, _a, e_2, _b;
+    var errors;
+    if (!this.closed) {
+      this.closed = true;
+      var _parentage = this._parentage;
+      if (_parentage) {
+        this._parentage = null;
+        if (Array.isArray(_parentage)) {
+          try {
+            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+              var parent_1 = _parentage_1_1.value;
+              parent_1.remove(this);
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+          }
+        } else {
+          _parentage.remove(this);
+        }
+      }
+      var initialFinalizer = this.initialTeardown;
+      if (isFunction(initialFinalizer)) {
+        try {
+          initialFinalizer();
+        } catch (e) {
+          errors = e instanceof UnsubscriptionError ? e.errors : [e];
+        }
+      }
+      var _finalizers = this._finalizers;
+      if (_finalizers) {
+        this._finalizers = null;
+        try {
+          for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+            var finalizer = _finalizers_1_1.value;
+            try {
+              execFinalizer(finalizer);
+            } catch (err) {
+              errors = errors !== null && errors !== void 0 ? errors : [];
+              if (err instanceof UnsubscriptionError) {
+                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+              } else {
+                errors.push(err);
+              }
+            }
+          }
+        } catch (e_2_1) {
+          e_2 = { error: e_2_1 };
+        } finally {
+          try {
+            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+          } finally {
+            if (e_2) throw e_2.error;
+          }
+        }
+      }
+      if (errors) {
+        throw new UnsubscriptionError(errors);
+      }
+    }
+  };
+  Subscription2.prototype.add = function(teardown) {
+    var _a;
+    if (teardown && teardown !== this) {
+      if (this.closed) {
+        execFinalizer(teardown);
+      } else {
+        if (teardown instanceof Subscription2) {
+          if (teardown.closed || teardown._hasParent(this)) {
+            return;
+          }
+          teardown._addParent(this);
+        }
+        (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+      }
+    }
+  };
+  Subscription2.prototype._hasParent = function(parent) {
+    var _parentage = this._parentage;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+  };
+  Subscription2.prototype._addParent = function(parent) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+  };
+  Subscription2.prototype._removeParent = function(parent) {
+    var _parentage = this._parentage;
+    if (_parentage === parent) {
+      this._parentage = null;
+    } else if (Array.isArray(_parentage)) {
+      arrRemove(_parentage, parent);
+    }
+  };
+  Subscription2.prototype.remove = function(teardown) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown);
+    if (teardown instanceof Subscription2) {
+      teardown._removeParent(this);
+    }
+  };
+  Subscription2.EMPTY = (function() {
+    var empty = new Subscription2();
+    empty.closed = true;
+    return empty;
+  })();
+  return Subscription2;
+})();
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value) {
+  return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+}
+function execFinalizer(finalizer) {
+  if (isFunction(finalizer)) {
+    finalizer();
+  } else {
+    finalizer.unsubscribe();
+  }
+}
+
+// ../../node_modules/rxjs/dist/esm5/internal/config.js
+var config = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: void 0,
+  useDeprecatedSynchronousErrorHandling: false,
+  useDeprecatedNextContext: false
+};
+
+// ../../node_modules/rxjs/dist/esm5/internal/scheduler/timeoutProvider.js
+var timeoutProvider = {
+  setTimeout: function(handler, timeout) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
+    }
+    var delegate = timeoutProvider.delegate;
+    if (delegate === null || delegate === void 0 ? void 0 : delegate.setTimeout) {
+      return delegate.setTimeout.apply(delegate, __spreadArray([handler, timeout], __read(args)));
+    }
+    return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+  },
+  clearTimeout: function(handle) {
+    var delegate = timeoutProvider.delegate;
+    return ((delegate === null || delegate === void 0 ? void 0 : delegate.clearTimeout) || clearTimeout)(handle);
+  },
+  delegate: void 0
+};
+
+// ../../node_modules/rxjs/dist/esm5/internal/util/reportUnhandledError.js
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function() {
+    var onUnhandledError = config.onUnhandledError;
+    if (onUnhandledError) {
+      onUnhandledError(err);
+    } else {
+      throw err;
+    }
+  });
+}
+
+// ../../node_modules/rxjs/dist/esm5/internal/util/noop.js
+function noop() {
+}
+
+// ../../node_modules/rxjs/dist/esm5/internal/NotificationFactories.js
+var COMPLETE_NOTIFICATION = (function() {
+  return createNotification("C", void 0, void 0);
+})();
+function errorNotification(error) {
+  return createNotification("E", void 0, error);
+}
+function nextNotification(value) {
+  return createNotification("N", value, void 0);
+}
+function createNotification(kind, value, error) {
+  return {
+    kind,
+    value,
+    error
+  };
+}
+
+// ../../node_modules/rxjs/dist/esm5/internal/util/errorContext.js
+var context = null;
+function errorContext(cb) {
+  if (config.useDeprecatedSynchronousErrorHandling) {
+    var isRoot = !context;
+    if (isRoot) {
+      context = { errorThrown: false, error: null };
+    }
+    cb();
+    if (isRoot) {
+      var _a = context, errorThrown = _a.errorThrown, error = _a.error;
+      context = null;
+      if (errorThrown) {
+        throw error;
+      }
+    }
+  } else {
+    cb();
+  }
+}
+function captureError(err) {
+  if (config.useDeprecatedSynchronousErrorHandling && context) {
+    context.errorThrown = true;
+    context.error = err;
+  }
+}
+
+// ../../node_modules/rxjs/dist/esm5/internal/Subscriber.js
+var Subscriber = (function(_super) {
+  __extends(Subscriber2, _super);
+  function Subscriber2(destination) {
+    var _this = _super.call(this) || this;
+    _this.isStopped = false;
+    if (destination) {
+      _this.destination = destination;
+      if (isSubscription(destination)) {
+        destination.add(_this);
+      }
+    } else {
+      _this.destination = EMPTY_OBSERVER;
+    }
+    return _this;
+  }
+  Subscriber2.create = function(next, error, complete) {
+    return new SafeSubscriber(next, error, complete);
+  };
+  Subscriber2.prototype.next = function(value) {
+    if (this.isStopped) {
+      handleStoppedNotification(nextNotification(value), this);
+    } else {
+      this._next(value);
+    }
+  };
+  Subscriber2.prototype.error = function(err) {
+    if (this.isStopped) {
+      handleStoppedNotification(errorNotification(err), this);
+    } else {
+      this.isStopped = true;
+      this._error(err);
+    }
+  };
+  Subscriber2.prototype.complete = function() {
+    if (this.isStopped) {
+      handleStoppedNotification(COMPLETE_NOTIFICATION, this);
+    } else {
+      this.isStopped = true;
+      this._complete();
+    }
+  };
+  Subscriber2.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      this.isStopped = true;
+      _super.prototype.unsubscribe.call(this);
+      this.destination = null;
+    }
+  };
+  Subscriber2.prototype._next = function(value) {
+    this.destination.next(value);
+  };
+  Subscriber2.prototype._error = function(err) {
+    try {
+      this.destination.error(err);
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  Subscriber2.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  return Subscriber2;
+})(Subscription);
+var _bind = Function.prototype.bind;
+function bind(fn, thisArg) {
+  return _bind.call(fn, thisArg);
+}
+var ConsumerObserver = (function() {
+  function ConsumerObserver2(partialObserver) {
+    this.partialObserver = partialObserver;
+  }
+  ConsumerObserver2.prototype.next = function(value) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.next) {
+      try {
+        partialObserver.next(value);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  ConsumerObserver2.prototype.error = function(err) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.error) {
+      try {
+        partialObserver.error(err);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    } else {
+      handleUnhandledError(err);
+    }
+  };
+  ConsumerObserver2.prototype.complete = function() {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.complete) {
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  return ConsumerObserver2;
+})();
+var SafeSubscriber = (function(_super) {
+  __extends(SafeSubscriber2, _super);
+  function SafeSubscriber2(observerOrNext, error, complete) {
+    var _this = _super.call(this) || this;
+    var partialObserver;
+    if (isFunction(observerOrNext) || !observerOrNext) {
+      partialObserver = {
+        next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
+        error: error !== null && error !== void 0 ? error : void 0,
+        complete: complete !== null && complete !== void 0 ? complete : void 0
+      };
+    } else {
+      var context_1;
+      if (_this && config.useDeprecatedNextContext) {
+        context_1 = Object.create(observerOrNext);
+        context_1.unsubscribe = function() {
+          return _this.unsubscribe();
+        };
+        partialObserver = {
+          next: observerOrNext.next && bind(observerOrNext.next, context_1),
+          error: observerOrNext.error && bind(observerOrNext.error, context_1),
+          complete: observerOrNext.complete && bind(observerOrNext.complete, context_1)
+        };
+      } else {
+        partialObserver = observerOrNext;
+      }
+    }
+    _this.destination = new ConsumerObserver(partialObserver);
+    return _this;
+  }
+  return SafeSubscriber2;
+})(Subscriber);
+function handleUnhandledError(error) {
+  if (config.useDeprecatedSynchronousErrorHandling) {
+    captureError(error);
+  } else {
+    reportUnhandledError(error);
+  }
+}
+function defaultErrorHandler(err) {
+  throw err;
+}
+function handleStoppedNotification(notification, subscriber) {
+  var onStoppedNotification = config.onStoppedNotification;
+  onStoppedNotification && timeoutProvider.setTimeout(function() {
+    return onStoppedNotification(notification, subscriber);
+  });
+}
+var EMPTY_OBSERVER = {
+  closed: true,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
+
+// ../../node_modules/rxjs/dist/esm5/internal/symbol/observable.js
+var observable = (function() {
+  return typeof Symbol === "function" && Symbol.observable || "@@observable";
+})();
+
+// ../../node_modules/rxjs/dist/esm5/internal/util/identity.js
+function identity(x) {
+  return x;
+}
+
+// ../../node_modules/rxjs/dist/esm5/internal/util/pipe.js
+function pipeFromArray(fns) {
+  if (fns.length === 0) {
+    return identity;
+  }
+  if (fns.length === 1) {
+    return fns[0];
+  }
+  return function piped(input) {
+    return fns.reduce(function(prev, fn) {
+      return fn(prev);
+    }, input);
+  };
+}
+
+// ../../node_modules/rxjs/dist/esm5/internal/Observable.js
+var Observable = (function() {
+  function Observable2(subscribe) {
+    if (subscribe) {
+      this._subscribe = subscribe;
+    }
+  }
+  Observable2.prototype.lift = function(operator) {
+    var observable2 = new Observable2();
+    observable2.source = this;
+    observable2.operator = operator;
+    return observable2;
+  };
+  Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
+    var _this = this;
+    var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+    errorContext(function() {
+      var _a = _this, operator = _a.operator, source = _a.source;
+      subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+    });
+    return subscriber;
+  };
+  Observable2.prototype._trySubscribe = function(sink) {
+    try {
+      return this._subscribe(sink);
+    } catch (err) {
+      sink.error(err);
+    }
+  };
+  Observable2.prototype.forEach = function(next, promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve, reject) {
+      var subscriber = new SafeSubscriber({
+        next: function(value) {
+          try {
+            next(value);
+          } catch (err) {
+            reject(err);
+            subscriber.unsubscribe();
+          }
+        },
+        error: reject,
+        complete: resolve
+      });
+      _this.subscribe(subscriber);
+    });
+  };
+  Observable2.prototype._subscribe = function(subscriber) {
+    var _a;
+    return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+  };
+  Observable2.prototype[observable] = function() {
+    return this;
+  };
+  Observable2.prototype.pipe = function() {
+    var operations = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      operations[_i] = arguments[_i];
+    }
+    return pipeFromArray(operations)(this);
+  };
+  Observable2.prototype.toPromise = function(promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve, reject) {
+      var value;
+      _this.subscribe(function(x) {
+        return value = x;
+      }, function(err) {
+        return reject(err);
+      }, function() {
+        return resolve(value);
+      });
+    });
+  };
+  Observable2.create = function(subscribe) {
+    return new Observable2(subscribe);
+  };
+  return Observable2;
+})();
+function getPromiseCtor(promiseCtor) {
+  var _a;
+  return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+}
+function isObserver(value) {
+  return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+}
+function isSubscriber(value) {
+  return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+}
+
+// ../../node_modules/rxjs/dist/esm5/internal/observable/empty.js
+var EMPTY = new Observable(function(subscriber) {
+  return subscriber.complete();
+});
+
+// ../../node_modules/graphql/jsutils/devAssert.mjs
+function devAssert(condition, message) {
+  const booleanCondition = Boolean(condition);
+  if (!booleanCondition) {
+    throw new Error(message);
+  }
+}
+
+// ../../node_modules/graphql/language/ast.mjs
+var QueryDocumentKeys = {
+  Name: [],
+  Document: ["definitions"],
+  OperationDefinition: [
+    "description",
+    "name",
+    "variableDefinitions",
+    "directives",
+    "selectionSet"
+  ],
+  VariableDefinition: [
+    "description",
+    "variable",
+    "type",
+    "defaultValue",
+    "directives"
+  ],
+  Variable: ["name"],
+  SelectionSet: ["selections"],
+  Field: ["alias", "name", "arguments", "directives", "selectionSet"],
+  Argument: ["name", "value"],
+  FragmentSpread: ["name", "directives"],
+  InlineFragment: ["typeCondition", "directives", "selectionSet"],
+  FragmentDefinition: [
+    "description",
+    "name",
+    // Note: fragment variable definitions are deprecated and will removed in v17.0.0
+    "variableDefinitions",
+    "typeCondition",
+    "directives",
+    "selectionSet"
+  ],
+  IntValue: [],
+  FloatValue: [],
+  StringValue: [],
+  BooleanValue: [],
+  NullValue: [],
+  EnumValue: [],
+  ListValue: ["values"],
+  ObjectValue: ["fields"],
+  ObjectField: ["name", "value"],
+  Directive: ["name", "arguments"],
+  NamedType: ["name"],
+  ListType: ["type"],
+  NonNullType: ["type"],
+  SchemaDefinition: ["description", "directives", "operationTypes"],
+  OperationTypeDefinition: ["type"],
+  ScalarTypeDefinition: ["description", "name", "directives"],
+  ObjectTypeDefinition: [
+    "description",
+    "name",
+    "interfaces",
+    "directives",
+    "fields"
+  ],
+  FieldDefinition: ["description", "name", "arguments", "type", "directives"],
+  InputValueDefinition: [
+    "description",
+    "name",
+    "type",
+    "defaultValue",
+    "directives"
+  ],
+  InterfaceTypeDefinition: [
+    "description",
+    "name",
+    "interfaces",
+    "directives",
+    "fields"
+  ],
+  UnionTypeDefinition: ["description", "name", "directives", "types"],
+  EnumTypeDefinition: ["description", "name", "directives", "values"],
+  EnumValueDefinition: ["description", "name", "directives"],
+  InputObjectTypeDefinition: ["description", "name", "directives", "fields"],
+  DirectiveDefinition: [
+    "description",
+    "name",
+    "arguments",
+    "directives",
+    "locations"
+  ],
+  SchemaExtension: ["directives", "operationTypes"],
+  DirectiveExtension: ["name", "directives"],
+  ScalarTypeExtension: ["name", "directives"],
+  ObjectTypeExtension: ["name", "interfaces", "directives", "fields"],
+  InterfaceTypeExtension: ["name", "interfaces", "directives", "fields"],
+  UnionTypeExtension: ["name", "directives", "types"],
+  EnumTypeExtension: ["name", "directives", "values"],
+  InputObjectTypeExtension: ["name", "directives", "fields"],
+  TypeCoordinate: ["name"],
+  MemberCoordinate: ["name", "memberName"],
+  ArgumentCoordinate: ["name", "fieldName", "argumentName"],
+  DirectiveCoordinate: ["name"],
+  DirectiveArgumentCoordinate: ["name", "argumentName"]
+};
+var kindValues = new Set(Object.keys(QueryDocumentKeys));
+function isNode(maybeNode) {
+  const maybeKind = maybeNode === null || maybeNode === void 0 ? void 0 : maybeNode.kind;
+  return typeof maybeKind === "string" && kindValues.has(maybeKind);
+}
+var OperationTypeNode;
+(function(OperationTypeNode2) {
+  OperationTypeNode2["QUERY"] = "query";
+  OperationTypeNode2["MUTATION"] = "mutation";
+  OperationTypeNode2["SUBSCRIPTION"] = "subscription";
+})(OperationTypeNode || (OperationTypeNode = {}));
+
+// ../../node_modules/graphql/language/kinds.mjs
+var Kind;
+(function(Kind2) {
+  Kind2["NAME"] = "Name";
+  Kind2["DOCUMENT"] = "Document";
+  Kind2["OPERATION_DEFINITION"] = "OperationDefinition";
+  Kind2["VARIABLE_DEFINITION"] = "VariableDefinition";
+  Kind2["SELECTION_SET"] = "SelectionSet";
+  Kind2["FIELD"] = "Field";
+  Kind2["ARGUMENT"] = "Argument";
+  Kind2["FRAGMENT_SPREAD"] = "FragmentSpread";
+  Kind2["INLINE_FRAGMENT"] = "InlineFragment";
+  Kind2["FRAGMENT_DEFINITION"] = "FragmentDefinition";
+  Kind2["VARIABLE"] = "Variable";
+  Kind2["INT"] = "IntValue";
+  Kind2["FLOAT"] = "FloatValue";
+  Kind2["STRING"] = "StringValue";
+  Kind2["BOOLEAN"] = "BooleanValue";
+  Kind2["NULL"] = "NullValue";
+  Kind2["ENUM"] = "EnumValue";
+  Kind2["LIST"] = "ListValue";
+  Kind2["OBJECT"] = "ObjectValue";
+  Kind2["OBJECT_FIELD"] = "ObjectField";
+  Kind2["DIRECTIVE"] = "Directive";
+  Kind2["NAMED_TYPE"] = "NamedType";
+  Kind2["LIST_TYPE"] = "ListType";
+  Kind2["NON_NULL_TYPE"] = "NonNullType";
+  Kind2["SCHEMA_DEFINITION"] = "SchemaDefinition";
+  Kind2["OPERATION_TYPE_DEFINITION"] = "OperationTypeDefinition";
+  Kind2["SCALAR_TYPE_DEFINITION"] = "ScalarTypeDefinition";
+  Kind2["OBJECT_TYPE_DEFINITION"] = "ObjectTypeDefinition";
+  Kind2["FIELD_DEFINITION"] = "FieldDefinition";
+  Kind2["INPUT_VALUE_DEFINITION"] = "InputValueDefinition";
+  Kind2["INTERFACE_TYPE_DEFINITION"] = "InterfaceTypeDefinition";
+  Kind2["UNION_TYPE_DEFINITION"] = "UnionTypeDefinition";
+  Kind2["ENUM_TYPE_DEFINITION"] = "EnumTypeDefinition";
+  Kind2["ENUM_VALUE_DEFINITION"] = "EnumValueDefinition";
+  Kind2["INPUT_OBJECT_TYPE_DEFINITION"] = "InputObjectTypeDefinition";
+  Kind2["DIRECTIVE_DEFINITION"] = "DirectiveDefinition";
+  Kind2["SCHEMA_EXTENSION"] = "SchemaExtension";
+  Kind2["DIRECTIVE_EXTENSION"] = "DirectiveExtension";
+  Kind2["SCALAR_TYPE_EXTENSION"] = "ScalarTypeExtension";
+  Kind2["OBJECT_TYPE_EXTENSION"] = "ObjectTypeExtension";
+  Kind2["INTERFACE_TYPE_EXTENSION"] = "InterfaceTypeExtension";
+  Kind2["UNION_TYPE_EXTENSION"] = "UnionTypeExtension";
+  Kind2["ENUM_TYPE_EXTENSION"] = "EnumTypeExtension";
+  Kind2["INPUT_OBJECT_TYPE_EXTENSION"] = "InputObjectTypeExtension";
+  Kind2["TYPE_COORDINATE"] = "TypeCoordinate";
+  Kind2["MEMBER_COORDINATE"] = "MemberCoordinate";
+  Kind2["ARGUMENT_COORDINATE"] = "ArgumentCoordinate";
+  Kind2["DIRECTIVE_COORDINATE"] = "DirectiveCoordinate";
+  Kind2["DIRECTIVE_ARGUMENT_COORDINATE"] = "DirectiveArgumentCoordinate";
+})(Kind || (Kind = {}));
+
+// ../../node_modules/graphql/language/characterClasses.mjs
+function isWhiteSpace(code) {
+  return code === 9 || code === 32;
+}
+
+// ../../node_modules/graphql/language/blockString.mjs
+function printBlockString(value, options) {
+  const escapedValue = value.replace(/"""/g, '\\"""');
+  const lines = escapedValue.split(/\r\n|[\n\r]/g);
+  const isSingleLine = lines.length === 1;
+  const forceLeadingNewLine = lines.length > 1 && lines.slice(1).every((line) => line.length === 0 || isWhiteSpace(line.charCodeAt(0)));
+  const hasTrailingTripleQuotes = escapedValue.endsWith('\\"""');
+  const hasTrailingQuote = value.endsWith('"') && !hasTrailingTripleQuotes;
+  const hasTrailingSlash = value.endsWith("\\");
+  const forceTrailingNewline = hasTrailingQuote || hasTrailingSlash;
+  const printAsMultipleLines = !(options !== null && options !== void 0 && options.minimize) && // add leading and trailing new lines only if it improves readability
+  (!isSingleLine || value.length > 70 || forceTrailingNewline || forceLeadingNewLine || hasTrailingTripleQuotes);
+  let result = "";
+  const skipLeadingNewLine = isSingleLine && isWhiteSpace(value.charCodeAt(0));
+  if (printAsMultipleLines && !skipLeadingNewLine || forceLeadingNewLine) {
+    result += "\n";
+  }
+  result += escapedValue;
+  if (printAsMultipleLines || forceTrailingNewline) {
+    result += "\n";
+  }
+  return '"""' + result + '"""';
+}
+
+// ../../node_modules/graphql/jsutils/inspect.mjs
+var MAX_ARRAY_LENGTH = 10;
+var MAX_RECURSIVE_DEPTH = 2;
+function inspect(value) {
+  return formatValue(value, []);
+}
+function formatValue(value, seenValues) {
+  switch (typeof value) {
+    case "string":
+      return JSON.stringify(value);
+    case "function":
+      return value.name ? `[function ${value.name}]` : "[function]";
+    case "object":
+      return formatObjectValue(value, seenValues);
+    default:
+      return String(value);
+  }
+}
+function formatObjectValue(value, previouslySeenValues) {
+  if (value === null) {
+    return "null";
+  }
+  if (previouslySeenValues.includes(value)) {
+    return "[Circular]";
+  }
+  const seenValues = [...previouslySeenValues, value];
+  if (isJSONable(value)) {
+    const jsonValue = value.toJSON();
+    if (jsonValue !== value) {
+      return typeof jsonValue === "string" ? jsonValue : formatValue(jsonValue, seenValues);
+    }
+  } else if (Array.isArray(value)) {
+    return formatArray(value, seenValues);
+  }
+  return formatObject(value, seenValues);
+}
+function isJSONable(value) {
+  return typeof value.toJSON === "function";
+}
+function formatObject(object, seenValues) {
+  const entries = Object.entries(object);
+  if (entries.length === 0) {
+    return "{}";
+  }
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return "[" + getObjectTag(object) + "]";
+  }
+  const properties = entries.map(
+    ([key, value]) => key + ": " + formatValue(value, seenValues)
+  );
+  return "{ " + properties.join(", ") + " }";
+}
+function formatArray(array, seenValues) {
+  if (array.length === 0) {
+    return "[]";
+  }
+  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
+    return "[Array]";
+  }
+  const len = Math.min(MAX_ARRAY_LENGTH, array.length);
+  const remaining = array.length - len;
+  const items = [];
+  for (let i = 0; i < len; ++i) {
+    items.push(formatValue(array[i], seenValues));
+  }
+  if (remaining === 1) {
+    items.push("... 1 more item");
+  } else if (remaining > 1) {
+    items.push(`... ${remaining} more items`);
+  }
+  return "[" + items.join(", ") + "]";
+}
+function getObjectTag(object) {
+  const tag = Object.prototype.toString.call(object).replace(/^\[object /, "").replace(/]$/, "");
+  if (tag === "Object" && typeof object.constructor === "function") {
+    const name = object.constructor.name;
+    if (typeof name === "string" && name !== "") {
+      return name;
+    }
+  }
+  return tag;
+}
+
+// ../../node_modules/graphql/language/printString.mjs
+function printString(str) {
+  return `"${str.replace(escapedRegExp, escapedReplacer)}"`;
+}
+var escapedRegExp = /[\x00-\x1f\x22\x5c\x7f-\x9f]/g;
+function escapedReplacer(str) {
+  return escapeSequences[str.charCodeAt(0)];
+}
+var escapeSequences = [
+  "\\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"
+];
+
+// ../../node_modules/graphql/language/visitor.mjs
+var BREAK = Object.freeze({});
+function visit(root, visitor, visitorKeys = QueryDocumentKeys) {
+  const enterLeaveMap = /* @__PURE__ */ new Map();
+  for (const kind of Object.values(Kind)) {
+    enterLeaveMap.set(kind, getEnterLeaveForKind(visitor, kind));
+  }
+  let stack = void 0;
+  let inArray = Array.isArray(root);
+  let keys = [root];
+  let index = -1;
+  let edits = [];
+  let node = root;
+  let key = void 0;
+  let parent = void 0;
+  const path = [];
+  const ancestors = [];
+  do {
+    index++;
+    const isLeaving = index === keys.length;
+    const isEdited = isLeaving && edits.length !== 0;
+    if (isLeaving) {
+      key = ancestors.length === 0 ? void 0 : path[path.length - 1];
+      node = parent;
+      parent = ancestors.pop();
+      if (isEdited) {
+        if (inArray) {
+          node = node.slice();
+          let editOffset = 0;
+          for (const [editKey, editValue] of edits) {
+            const arrayKey = editKey - editOffset;
+            if (editValue === null) {
+              node.splice(arrayKey, 1);
+              editOffset++;
+            } else {
+              node[arrayKey] = editValue;
+            }
+          }
+        } else {
+          node = { ...node };
+          for (const [editKey, editValue] of edits) {
+            node[editKey] = editValue;
+          }
+        }
+      }
+      index = stack.index;
+      keys = stack.keys;
+      edits = stack.edits;
+      inArray = stack.inArray;
+      stack = stack.prev;
+    } else if (parent) {
+      key = inArray ? index : keys[index];
+      node = parent[key];
+      if (node === null || node === void 0) {
+        continue;
+      }
+      path.push(key);
+    }
+    let result;
+    if (!Array.isArray(node)) {
+      var _enterLeaveMap$get, _enterLeaveMap$get2;
+      isNode(node) || devAssert(false, `Invalid AST Node: ${inspect(node)}.`);
+      const visitFn = isLeaving ? (_enterLeaveMap$get = enterLeaveMap.get(node.kind)) === null || _enterLeaveMap$get === void 0 ? void 0 : _enterLeaveMap$get.leave : (_enterLeaveMap$get2 = enterLeaveMap.get(node.kind)) === null || _enterLeaveMap$get2 === void 0 ? void 0 : _enterLeaveMap$get2.enter;
+      result = visitFn === null || visitFn === void 0 ? void 0 : visitFn.call(visitor, node, key, parent, path, ancestors);
+      if (result === BREAK) {
+        break;
+      }
+      if (result === false) {
+        if (!isLeaving) {
+          path.pop();
+          continue;
+        }
+      } else if (result !== void 0) {
+        edits.push([key, result]);
+        if (!isLeaving) {
+          if (isNode(result)) {
+            node = result;
+          } else {
+            path.pop();
+            continue;
+          }
+        }
+      }
+    }
+    if (result === void 0 && isEdited) {
+      edits.push([key, node]);
+    }
+    if (isLeaving) {
+      path.pop();
+    } else {
+      var _node$kind;
+      stack = {
+        inArray,
+        index,
+        keys,
+        edits,
+        prev: stack
+      };
+      inArray = Array.isArray(node);
+      keys = inArray ? node : (_node$kind = visitorKeys[node.kind]) !== null && _node$kind !== void 0 ? _node$kind : [];
+      index = -1;
+      edits = [];
+      if (parent) {
+        ancestors.push(parent);
+      }
+      parent = node;
+    }
+  } while (stack !== void 0);
+  if (edits.length !== 0) {
+    return edits[edits.length - 1][1];
+  }
+  return root;
+}
+function getEnterLeaveForKind(visitor, kind) {
+  const kindVisitor = visitor[kind];
+  if (typeof kindVisitor === "object") {
+    return kindVisitor;
+  } else if (typeof kindVisitor === "function") {
+    return {
+      enter: kindVisitor,
+      leave: void 0
+    };
+  }
+  return {
+    enter: visitor.enter,
+    leave: visitor.leave
+  };
+}
+
+// ../../node_modules/graphql/language/printer.mjs
+function print(ast) {
+  return visit(ast, printDocASTReducer);
+}
+var MAX_LINE_LENGTH = 80;
+var printDocASTReducer = {
+  Name: {
+    leave: (node) => node.value
+  },
+  Variable: {
+    leave: (node) => "$" + node.name
+  },
+  // Document
+  Document: {
+    leave: (node) => join(node.definitions, "\n\n")
+  },
+  OperationDefinition: {
+    leave(node) {
+      const varDefs = hasMultilineItems(node.variableDefinitions) ? wrap("(\n", join(node.variableDefinitions, "\n"), "\n)") : wrap("(", join(node.variableDefinitions, ", "), ")");
+      const prefix = wrap("", node.description, "\n") + join(
+        [
+          node.operation,
+          join([node.name, varDefs]),
+          join(node.directives, " ")
+        ],
+        " "
+      );
+      return (prefix === "query" ? "" : prefix + " ") + node.selectionSet;
+    }
+  },
+  VariableDefinition: {
+    leave: ({ variable, type, defaultValue, directives, description }) => wrap("", description, "\n") + variable + ": " + type + wrap(" = ", defaultValue) + wrap(" ", join(directives, " "))
+  },
+  SelectionSet: {
+    leave: ({ selections }) => block(selections)
+  },
+  Field: {
+    leave({ alias, name, arguments: args, directives, selectionSet }) {
+      const prefix = wrap("", alias, ": ") + name;
+      let argsLine = prefix + wrap("(", join(args, ", "), ")");
+      if (argsLine.length > MAX_LINE_LENGTH) {
+        argsLine = prefix + wrap("(\n", indent(join(args, "\n")), "\n)");
+      }
+      return join([argsLine, join(directives, " "), selectionSet], " ");
+    }
+  },
+  Argument: {
+    leave: ({ name, value }) => name + ": " + value
+  },
+  // Fragments
+  FragmentSpread: {
+    leave: ({ name, directives }) => "..." + name + wrap(" ", join(directives, " "))
+  },
+  InlineFragment: {
+    leave: ({ typeCondition, directives, selectionSet }) => join(
+      [
+        "...",
+        wrap("on ", typeCondition),
+        join(directives, " "),
+        selectionSet
+      ],
+      " "
+    )
+  },
+  FragmentDefinition: {
+    leave: ({
+      name,
+      typeCondition,
+      variableDefinitions,
+      directives,
+      selectionSet,
+      description
+    }) => wrap("", description, "\n") + // Note: fragment variable definitions are experimental and may be changed
+    // or removed in the future.
+    `fragment ${name}${wrap("(", join(variableDefinitions, ", "), ")")} on ${typeCondition} ${wrap("", join(directives, " "), " ")}` + selectionSet
+  },
+  // Value
+  IntValue: {
+    leave: ({ value }) => value
+  },
+  FloatValue: {
+    leave: ({ value }) => value
+  },
+  StringValue: {
+    leave: ({ value, block: isBlockString }) => isBlockString ? printBlockString(value) : printString(value)
+  },
+  BooleanValue: {
+    leave: ({ value }) => value ? "true" : "false"
+  },
+  NullValue: {
+    leave: () => "null"
+  },
+  EnumValue: {
+    leave: ({ value }) => value
+  },
+  ListValue: {
+    leave: ({ values }) => "[" + join(values, ", ") + "]"
+  },
+  ObjectValue: {
+    leave: ({ fields }) => "{" + join(fields, ", ") + "}"
+  },
+  ObjectField: {
+    leave: ({ name, value }) => name + ": " + value
+  },
+  // Directive
+  Directive: {
+    leave: ({ name, arguments: args }) => "@" + name + wrap("(", join(args, ", "), ")")
+  },
+  // Type
+  NamedType: {
+    leave: ({ name }) => name
+  },
+  ListType: {
+    leave: ({ type }) => "[" + type + "]"
+  },
+  NonNullType: {
+    leave: ({ type }) => type + "!"
+  },
+  // Type System Definitions
+  SchemaDefinition: {
+    leave: ({ description, directives, operationTypes }) => wrap("", description, "\n") + join(["schema", join(directives, " "), block(operationTypes)], " ")
+  },
+  OperationTypeDefinition: {
+    leave: ({ operation, type }) => operation + ": " + type
+  },
+  ScalarTypeDefinition: {
+    leave: ({ description, name, directives }) => wrap("", description, "\n") + join(["scalar", name, join(directives, " ")], " ")
+  },
+  ObjectTypeDefinition: {
+    leave: ({ description, name, interfaces, directives, fields }) => wrap("", description, "\n") + join(
+      [
+        "type",
+        name,
+        wrap("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  FieldDefinition: {
+    leave: ({ description, name, arguments: args, type, directives }) => wrap("", description, "\n") + name + (hasMultilineItems(args) ? wrap("(\n", indent(join(args, "\n")), "\n)") : wrap("(", join(args, ", "), ")")) + ": " + type + wrap(" ", join(directives, " "))
+  },
+  InputValueDefinition: {
+    leave: ({ description, name, type, defaultValue, directives }) => wrap("", description, "\n") + join(
+      [name + ": " + type, wrap("= ", defaultValue), join(directives, " ")],
+      " "
+    )
+  },
+  InterfaceTypeDefinition: {
+    leave: ({ description, name, interfaces, directives, fields }) => wrap("", description, "\n") + join(
+      [
+        "interface",
+        name,
+        wrap("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  UnionTypeDefinition: {
+    leave: ({ description, name, directives, types }) => wrap("", description, "\n") + join(
+      ["union", name, join(directives, " "), wrap("= ", join(types, " | "))],
+      " "
+    )
+  },
+  EnumTypeDefinition: {
+    leave: ({ description, name, directives, values }) => wrap("", description, "\n") + join(["enum", name, join(directives, " "), block(values)], " ")
+  },
+  EnumValueDefinition: {
+    leave: ({ description, name, directives }) => wrap("", description, "\n") + join([name, join(directives, " ")], " ")
+  },
+  InputObjectTypeDefinition: {
+    leave: ({ description, name, directives, fields }) => wrap("", description, "\n") + join(["input", name, join(directives, " "), block(fields)], " ")
+  },
+  DirectiveDefinition: {
+    leave: ({
+      description,
+      name,
+      arguments: args,
+      directives,
+      repeatable,
+      locations
+    }) => wrap("", description, "\n") + "directive @" + name + (hasMultilineItems(args) ? wrap("(\n", indent(join(args, "\n")), "\n)") : wrap("(", join(args, ", "), ")")) + wrap(" ", join(directives, " ")) + (repeatable ? " repeatable" : "") + " on " + join(locations, " | ")
+  },
+  SchemaExtension: {
+    leave: ({ directives, operationTypes }) => join(
+      ["extend schema", join(directives, " "), block(operationTypes)],
+      " "
+    )
+  },
+  ScalarTypeExtension: {
+    leave: ({ name, directives }) => join(["extend scalar", name, join(directives, " ")], " ")
+  },
+  ObjectTypeExtension: {
+    leave: ({ name, interfaces, directives, fields }) => join(
+      [
+        "extend type",
+        name,
+        wrap("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  InterfaceTypeExtension: {
+    leave: ({ name, interfaces, directives, fields }) => join(
+      [
+        "extend interface",
+        name,
+        wrap("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  UnionTypeExtension: {
+    leave: ({ name, directives, types }) => join(
+      [
+        "extend union",
+        name,
+        join(directives, " "),
+        wrap("= ", join(types, " | "))
+      ],
+      " "
+    )
+  },
+  EnumTypeExtension: {
+    leave: ({ name, directives, values }) => join(["extend enum", name, join(directives, " "), block(values)], " ")
+  },
+  InputObjectTypeExtension: {
+    leave: ({ name, directives, fields }) => join(["extend input", name, join(directives, " "), block(fields)], " ")
+  },
+  DirectiveExtension: {
+    leave: ({ name, directives }) => join(["extend directive @" + name, join(directives, " ")], " ")
+  },
+  // Schema Coordinates
+  TypeCoordinate: {
+    leave: ({ name }) => name
+  },
+  MemberCoordinate: {
+    leave: ({ name, memberName }) => join([name, wrap(".", memberName)])
+  },
+  ArgumentCoordinate: {
+    leave: ({ name, fieldName, argumentName }) => join([name, wrap(".", fieldName), wrap("(", argumentName, ":)")])
+  },
+  DirectiveCoordinate: {
+    leave: ({ name }) => join(["@", name])
+  },
+  DirectiveArgumentCoordinate: {
+    leave: ({ name, argumentName }) => join(["@", name, wrap("(", argumentName, ":)")])
+  }
+};
+function join(maybeArray, separator = "") {
+  var _maybeArray$filter$jo;
+  return (_maybeArray$filter$jo = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.filter((x) => x).join(separator)) !== null && _maybeArray$filter$jo !== void 0 ? _maybeArray$filter$jo : "";
+}
+function block(array) {
+  return wrap("{\n", indent(join(array, "\n")), "\n}");
+}
+function wrap(start, maybeString, end = "") {
+  return maybeString != null && maybeString !== "" ? start + maybeString + end : "";
+}
+function indent(str) {
+  return wrap("  ", str.replace(/\n/g, "\n  "));
+}
+function hasMultilineItems(maybeArray) {
+  var _maybeArray$some;
+  return (_maybeArray$some = maybeArray === null || maybeArray === void 0 ? void 0 : maybeArray.some((str) => str.includes("\n"))) !== null && _maybeArray$some !== void 0 ? _maybeArray$some : false;
+}
+
+// ../../node_modules/@apollo/client/utilities/environment/index.js
+var __DEV__ = globalThis.__DEV__ === true;
+
+// ../../node_modules/@apollo/client/utilities/internal/globals/maybe.js
+function maybe(thunk) {
+  try {
+    return thunk();
+  } catch {
+  }
+}
+
+// ../../node_modules/@apollo/client/utilities/internal/globals/global.js
+var global_default = (
+  // We don't expect the Function constructor ever to be invoked at runtime, as
+  // long as at least one of globalThis, window, self, or global is defined, so
+  // we are under no obligation to make it easy for static analysis tools to
+  // detect syntactic usage of the Function constructor. If you think you can
+  maybe(() => globalThis) || maybe(() => window) || maybe(() => self) || maybe(() => global) || // improve your static analysis to detect this obfuscation, think again. This
+  // is an arms race you cannot win, at least not in JavaScript.
+  maybe(function() {
+    return maybe.constructor("return this")();
+  })
+);
+
+// ../../node_modules/@apollo/client/version.js
+var version = "4.2.7";
+
+// ../../node_modules/@apollo/client/utilities/internal/makeUniqueId.js
+var prefixCounts = /* @__PURE__ */ new Map();
+function makeUniqueId(prefix) {
+  const count = prefixCounts.get(prefix) || 1;
+  prefixCounts.set(prefix, count + 1);
+  return `${prefix}:${count}:${Math.random().toString(36).slice(2)}`;
+}
+
+// ../../node_modules/@apollo/client/utilities/internal/stringifyForDisplay.js
+function stringifyForDisplay(value, space = 0) {
+  const undefId = makeUniqueId("stringifyForDisplay");
+  return JSON.stringify(value, (_, value2) => {
+    return value2 === void 0 ? undefId : value2;
+  }, space).split(JSON.stringify(undefId)).join("<undefined>");
+}
+
+// ../../node_modules/@apollo/client/utilities/invariant/index.js
+var genericMessage = "Invariant Violation";
+var InvariantError = class _InvariantError extends Error {
+  constructor(message = genericMessage) {
+    super(message);
+    this.name = genericMessage;
+    Object.setPrototypeOf(this, _InvariantError.prototype);
+  }
+};
+var verbosityLevels = ["debug", "log", "warn", "error", "silent"];
+var verbosityLevel = verbosityLevels.indexOf(__DEV__ ? "log" : "silent");
+function invariant(condition, ...args) {
+  if (!condition) {
+    throw newInvariantError(...args);
+  }
+}
+function wrapConsoleMethod(name) {
+  return function(message, ...args) {
+    if (verbosityLevels.indexOf(name) >= verbosityLevel) {
+      const method = console[name] || console.log;
+      if (typeof message === "number") {
+        const arg0 = message;
+        message = getHandledErrorMsg(arg0);
+        if (!message) {
+          message = getFallbackErrorMsg(arg0, args);
+          args = [];
+        }
+      }
+      method(message, ...args);
+    }
+  };
+}
+invariant.debug = wrapConsoleMethod("debug");
+invariant.log = wrapConsoleMethod("log");
+invariant.warn = wrapConsoleMethod("warn");
+invariant.error = wrapConsoleMethod("error");
+function newInvariantError(message, ...optionalParams) {
+  return new InvariantError(getHandledErrorMsg(message, optionalParams) || getFallbackErrorMsg(message, optionalParams));
+}
+var ApolloErrorMessageHandler = /* @__PURE__ */ Symbol.for("ApolloErrorMessageHandler_" + version);
+function stringify(arg) {
+  if (typeof arg == "string") {
+    return arg;
+  }
+  try {
+    return stringifyForDisplay(arg, 2).slice(0, 1e3);
+  } catch {
+    return "<non-serializable>";
+  }
+}
+function getHandledErrorMsg(message, messageArgs = []) {
+  if (!message)
+    return;
+  return global_default[ApolloErrorMessageHandler] && global_default[ApolloErrorMessageHandler](message, messageArgs.map(stringify));
+}
+function getFallbackErrorMsg(message, messageArgs = []) {
+  if (!message)
+    return;
+  if (typeof message === "string") {
+    return messageArgs.reduce((msg, arg) => msg.replace(/%[sdfo]/, stringify(arg)), message);
+  }
+  return `An error occurred! For more details, see the full error text at https://go.apollo.dev/c/err#${encodeURIComponent(JSON.stringify({
+    version,
+    message,
+    args: messageArgs.map(stringify)
+  }))}`;
+}
+
+// ../../node_modules/@apollo/client/utilities/caching/sizes.js
+var cacheSizeSymbol = /* @__PURE__ */ Symbol.for("apollo.cacheSize");
+var cacheSizes = { ...global_default[cacheSizeSymbol] };
+
+// ../../node_modules/@apollo/client/utilities/internal/getOperationName.js
+function getOperationName(doc, fallback) {
+  return doc.definitions.find((definition) => definition.kind === "OperationDefinition" && !!definition.name)?.name.value ?? fallback;
+}
+
+// ../../node_modules/@wry/trie/lib/index.js
+var defaultMakeData = () => /* @__PURE__ */ Object.create(null);
+var { forEach, slice } = Array.prototype;
+var { hasOwnProperty } = Object.prototype;
+var Trie = class _Trie {
+  constructor(weakness = true, makeData = defaultMakeData) {
+    this.weakness = weakness;
+    this.makeData = makeData;
+  }
+  lookup() {
+    return this.lookupArray(arguments);
+  }
+  lookupArray(array) {
+    let node = this;
+    forEach.call(array, (key) => node = node.getChildTrie(key));
+    return hasOwnProperty.call(node, "data") ? node.data : node.data = this.makeData(slice.call(array));
+  }
+  peek() {
+    return this.peekArray(arguments);
+  }
+  peekArray(array) {
+    let node = this;
+    for (let i = 0, len = array.length; node && i < len; ++i) {
+      const map = node.mapFor(array[i], false);
+      node = map && map.get(array[i]);
+    }
+    return node && node.data;
+  }
+  remove() {
+    return this.removeArray(arguments);
+  }
+  removeArray(array) {
+    let data;
+    if (array.length) {
+      const head = array[0];
+      const map = this.mapFor(head, false);
+      const child = map && map.get(head);
+      if (child) {
+        data = child.removeArray(slice.call(array, 1));
+        if (!child.data && !child.weak && !(child.strong && child.strong.size)) {
+          map.delete(head);
+        }
+      }
+    } else {
+      data = this.data;
+      delete this.data;
+    }
+    return data;
+  }
+  getChildTrie(key) {
+    const map = this.mapFor(key, true);
+    let child = map.get(key);
+    if (!child)
+      map.set(key, child = new _Trie(this.weakness, this.makeData));
+    return child;
+  }
+  mapFor(key, create) {
+    return this.weakness && isObjRef(key) ? this.weak || (create ? this.weak = /* @__PURE__ */ new WeakMap() : void 0) : this.strong || (create ? this.strong = /* @__PURE__ */ new Map() : void 0);
+  }
+};
+function isObjRef(value) {
+  switch (typeof value) {
+    case "object":
+      if (value === null)
+        break;
+    // Fall through to return true...
+    case "function":
+      return true;
+  }
+  return false;
+}
+
+// ../../node_modules/@wry/caches/lib/weak.js
+function noop2() {
+}
+var defaultDispose = noop2;
+var _WeakRef = typeof WeakRef !== "undefined" ? WeakRef : function(value) {
+  return { deref: () => value };
+};
+var _WeakMap = typeof WeakMap !== "undefined" ? WeakMap : Map;
+var _FinalizationRegistry = typeof FinalizationRegistry !== "undefined" ? FinalizationRegistry : function() {
+  return {
+    register: noop2,
+    unregister: noop2
+  };
+};
+var finalizationBatchSize = 10024;
+var WeakCache = class {
+  constructor(max = Infinity, dispose = defaultDispose) {
+    this.max = max;
+    this.dispose = dispose;
+    this.map = new _WeakMap();
+    this.newest = null;
+    this.oldest = null;
+    this.unfinalizedNodes = /* @__PURE__ */ new Set();
+    this.finalizationScheduled = false;
+    this.size = 0;
+    this.finalize = () => {
+      const iterator = this.unfinalizedNodes.values();
+      for (let i = 0; i < finalizationBatchSize; i++) {
+        const node = iterator.next().value;
+        if (!node)
+          break;
+        this.unfinalizedNodes.delete(node);
+        const key = node.key;
+        delete node.key;
+        node.keyRef = new _WeakRef(key);
+        this.registry.register(key, node, node);
+      }
+      if (this.unfinalizedNodes.size > 0) {
+        queueMicrotask(this.finalize);
+      } else {
+        this.finalizationScheduled = false;
+      }
+    };
+    this.registry = new _FinalizationRegistry(this.deleteNode.bind(this));
+  }
+  has(key) {
+    return this.map.has(key);
+  }
+  get(key) {
+    const node = this.getNode(key);
+    return node && node.value;
+  }
+  getNode(key) {
+    const node = this.map.get(key);
+    if (node && node !== this.newest) {
+      const { older, newer } = node;
+      if (newer) {
+        newer.older = older;
+      }
+      if (older) {
+        older.newer = newer;
+      }
+      node.older = this.newest;
+      node.older.newer = node;
+      node.newer = null;
+      this.newest = node;
+      if (node === this.oldest) {
+        this.oldest = newer;
+      }
+    }
+    return node;
+  }
+  set(key, value) {
+    let node = this.getNode(key);
+    if (node) {
+      return node.value = value;
+    }
+    node = {
+      key,
+      value,
+      newer: null,
+      older: this.newest
+    };
+    if (this.newest) {
+      this.newest.newer = node;
+    }
+    this.newest = node;
+    this.oldest = this.oldest || node;
+    this.scheduleFinalization(node);
+    this.map.set(key, node);
+    this.size++;
+    return node.value;
+  }
+  clean() {
+    while (this.oldest && this.size > this.max) {
+      this.deleteNode(this.oldest);
+    }
+  }
+  deleteNode(node) {
+    if (node === this.newest) {
+      this.newest = node.older;
+    }
+    if (node === this.oldest) {
+      this.oldest = node.newer;
+    }
+    if (node.newer) {
+      node.newer.older = node.older;
+    }
+    if (node.older) {
+      node.older.newer = node.newer;
+    }
+    this.size--;
+    const key = node.key || node.keyRef && node.keyRef.deref();
+    this.dispose(node.value, key);
+    if (!node.keyRef) {
+      this.unfinalizedNodes.delete(node);
+    } else {
+      this.registry.unregister(node);
+    }
+    if (key)
+      this.map.delete(key);
+  }
+  delete(key) {
+    const node = this.map.get(key);
+    if (node) {
+      this.deleteNode(node);
+      return true;
+    }
+    return false;
+  }
+  scheduleFinalization(node) {
+    this.unfinalizedNodes.add(node);
+    if (!this.finalizationScheduled) {
+      this.finalizationScheduled = true;
+      queueMicrotask(this.finalize);
+    }
+  }
+};
+
+// ../../node_modules/@apollo/client/utilities/internal/caches.js
+var scheduledCleanup = /* @__PURE__ */ new WeakSet();
+function schedule(cache) {
+  if (cache.size <= (cache.max || -1)) {
+    return;
+  }
+  if (!scheduledCleanup.has(cache)) {
+    scheduledCleanup.add(cache);
+    setTimeout(() => {
+      cache.clean();
+      scheduledCleanup.delete(cache);
+    }, 100);
+  }
+}
+var AutoCleanedWeakCache = function(max, dispose) {
+  const cache = new WeakCache(max, dispose);
+  cache.set = function(key, value) {
+    const ret = WeakCache.prototype.set.call(this, key, value);
+    schedule(this);
+    return ret;
+  };
+  return cache;
+};
+
+// ../../node_modules/@apollo/client/utilities/internal/memoize.js
+function memoize(fn, { max, makeCacheKey = (args) => args }) {
+  const keys = new Trie(true);
+  const cache = new AutoCleanedWeakCache(max);
+  return (...args) => {
+    const cacheKey = keys.lookupArray(makeCacheKey(args));
+    const cached = cache.get(cacheKey);
+    if (cached) {
+      if (cached.error) {
+        throw cached.error;
+      }
+      return cached.result;
+    }
+    const entry = cache.set(cacheKey, {});
+    try {
+      return entry.result = fn(...args);
+    } catch (error) {
+      entry.error = error;
+      throw error;
+    }
+  };
+}
+
+// ../../node_modules/@apollo/client/utilities/internal/checkDocument.js
+var checkDocument = memoize((doc, expectedType) => {
+  invariant(doc && doc.kind === "Document", 1);
+  const operations = doc.definitions.filter((d) => d.kind === "OperationDefinition");
+  if (__DEV__) {
+    doc.definitions.forEach((definition) => {
+      if (definition.kind !== "OperationDefinition" && definition.kind !== "FragmentDefinition") {
+        throw newInvariantError(2, definition.kind);
+      }
+    });
+    invariant(operations.length <= 1, 3, operations.length);
+  }
+  if (expectedType) {
+    invariant(
+      operations.length == 1 && operations[0].operation === expectedType,
+      4,
+      expectedType,
+      expectedType,
+      operations[0].operation
+    );
+  }
+  visit(doc, {
+    Field(field, _, __, path) {
+      if (field.alias && (field.alias.value === "__typename" || field.alias.value.startsWith("__ac_")) && field.alias.value !== field.name.value) {
+        let current = doc, fieldPath = [];
+        for (const key of path) {
+          current = current[key];
+          if (current.kind === Kind.FIELD) {
+            fieldPath.push(current.alias?.value || current.name.value);
+          }
+        }
+        fieldPath.splice(-1, 1, field.name.value);
+        throw newInvariantError(
+          5,
+          field.alias.value,
+          fieldPath.join("."),
+          operations[0].operation,
+          getOperationName(doc, "(anonymous)")
+        );
+      }
+    }
+  });
+}, {
+  max: cacheSizes["checkDocument"] || 2e3
+});
+
+// ../../node_modules/@apollo/client/utilities/internal/getOperationDefinition.js
+function getOperationDefinition(doc) {
+  checkDocument(doc);
+  return doc.definitions.filter((definition) => definition.kind === "OperationDefinition")[0];
+}
+
+// ../../node_modules/@apollo/client/utilities/internal/getMemoryInternals.js
+var globalCaches = {};
+function registerGlobalCache(name, getSize) {
+  globalCaches[name] = getSize;
+}
+
+// ../../node_modules/@apollo/client/link/utils/createOperation.js
+function createOperation(request, { client }) {
+  const operation = {
+    query: request.query,
+    variables: request.variables || {},
+    extensions: request.extensions || {},
+    operationName: getOperationName(request.query),
+    operationType: getOperationDefinition(request.query).operation
+  };
+  let context2 = { ...request.context };
+  const setContext = (next) => {
+    if (typeof next === "function") {
+      context2 = { ...context2, ...next(getContext()) };
+    } else {
+      context2 = { ...context2, ...next };
+    }
+  };
+  const getContext = () => Object.freeze({ ...context2 });
+  Object.defineProperty(operation, "setContext", {
+    enumerable: false,
+    value: setContext
+  });
+  Object.defineProperty(operation, "getContext", {
+    enumerable: false,
+    value: getContext
+  });
+  Object.defineProperty(operation, "client", {
+    enumerable: false,
+    value: client
+  });
+  return operation;
+}
+
+// ../../node_modules/@apollo/client/link/utils/filterOperationVariables.js
+function filterOperationVariables(variables, query) {
+  const result = { ...variables };
+  const unusedNames = new Set(Object.keys(variables));
+  visit(query, {
+    Variable(node, _key, parent) {
+      if (parent && parent.kind !== "VariableDefinition") {
+        unusedNames.delete(node.name.value);
+      }
+    }
+  });
+  unusedNames.forEach((name) => {
+    delete result[name];
+  });
+  return result;
+}
+
+// ../../node_modules/@apollo/client/link/core/ApolloLink.js
+var ApolloLink = class _ApolloLink {
+  /**
+   * Creates a link that completes immediately and does not emit a result.
+   *
+   * @example
+   *
+   * ```ts
+   * const link = ApolloLink.empty();
+   * ```
+   */
+  static empty() {
+    return new _ApolloLink(() => EMPTY);
+  }
+  /**
+   * Composes multiple links into a single composed link that executes each
+   * provided link in serial order.
+   *
+   * @example
+   *
+   * ```ts
+   * import { from, HttpLink, ApolloLink } from "@apollo/client";
+   * import { RetryLink } from "@apollo/client/link/retry";
+   * import MyAuthLink from "../auth";
+   *
+   * const link = ApolloLink.from([
+   *   new RetryLink(),
+   *   new MyAuthLink(),
+   *   new HttpLink({ uri: "http://localhost:4000/graphql" }),
+   * ]);
+   * ```
+   *
+   * @param links - An array of `ApolloLink` instances or request handlers that
+   * are executed in serial order.
+   */
+  static from(links) {
+    if (links.length === 0)
+      return _ApolloLink.empty();
+    const [first, ...rest] = links;
+    return first.concat(...rest);
+  }
+  /**
+   * Creates a link that conditionally routes a request to different links.
+   *
+   * @example
+   *
+   * ```ts
+   * import { ApolloLink, HttpLink } from "@apollo/client";
+   *
+   * const link = ApolloLink.split(
+   *   (operation) => operation.getContext().version === 1,
+   *   new HttpLink({ uri: "http://localhost:4000/v1/graphql" }),
+   *   new HttpLink({ uri: "http://localhost:4000/v2/graphql" })
+   * );
+   * ```
+   *
+   * @param test - A predicate function that receives the current `operation`
+   * and returns a boolean indicating which link to execute. Returning `true`
+   * executes the `left` link. Returning `false` executes the `right` link.
+   *
+   * @param left - The link that executes when the `test` function returns
+   * `true`.
+   *
+   * @param right - The link that executes when the `test` function returns
+   * `false`. If the `right` link is not provided, the request is forwarded to
+   * the next link in the chain.
+   */
+  static split(test, left, right = new _ApolloLink((op, forward) => forward(op))) {
+    const link = new _ApolloLink((operation, forward) => {
+      const result = test(operation);
+      if (__DEV__) {
+        if (typeof result !== "boolean") {
+          __DEV__ && invariant.warn(63, result);
+        }
+      }
+      return result ? left.request(operation, forward) : right.request(operation, forward);
+    });
+    return Object.assign(link, { left, right });
+  }
+  /**
+   * Executes a GraphQL request against a link. The `execute` function begins
+   * the request by calling the request handler of the link.
+   *
+   * @example
+   *
+   * ```ts
+   * const observable = ApolloLink.execute(link, { query, variables }, { client });
+   *
+   * observable.subscribe({
+   *   next(value) {
+   *     console.log("Received", value);
+   *   },
+   *   error(error) {
+   *     console.error("Oops got error", error);
+   *   },
+   *   complete() {
+   *     console.log("Request complete");
+   *   },
+   * });
+   * ```
+   *
+   * @param link - The `ApolloLink` instance to execute the request.
+   *
+   * @param request - The GraphQL request details, such as the `query` and
+   * `variables`.
+   *
+   * @param context - The execution context for the request, such as the
+   * `client` making the request.
+   */
+  static execute(link, request, context2) {
+    return link.request(createOperation(request, context2), () => {
+      if (__DEV__) {
+        __DEV__ && invariant.warn(64);
+      }
+      return EMPTY;
+    });
+  }
+  /**
+   * Combines multiple links into a single composed link.
+   *
+   * @example
+   *
+   * ```ts
+   * const link = ApolloLink.concat(firstLink, secondLink, thirdLink);
+   * ```
+   *
+   * @param links - The links to concatenate into a single link. Each link will
+   * execute in serial order.
+   *
+   * @deprecated Use `ApolloLink.from` instead. `ApolloLink.concat` will be
+   * removed in a future major version.
+   */
+  static concat(...links) {
+    return _ApolloLink.from(links);
+  }
+  constructor(request) {
+    if (request)
+      this.request = request;
+  }
+  /**
+   * Concatenates a link that conditionally routes a request to different links.
+   *
+   * @example
+   *
+   * ```ts
+   * import { ApolloLink, HttpLink } from "@apollo/client";
+   *
+   * const previousLink = new ApolloLink((operation, forward) => {
+   *   // Handle the request
+   *
+   *   return forward(operation);
+   * });
+   *
+   * const link = previousLink.split(
+   *   (operation) => operation.getContext().version === 1,
+   *   new HttpLink({ uri: "http://localhost:4000/v1/graphql" }),
+   *   new HttpLink({ uri: "http://localhost:4000/v2/graphql" })
+   * );
+   * ```
+   *
+   * @param test - A predicate function that receives the current `operation`
+   * and returns a boolean indicating which link to execute. Returning `true`
+   * executes the `left` link. Returning `false` executes the `right` link.
+   *
+   * @param left - The link that executes when the `test` function returns
+   * `true`.
+   *
+   * @param right - The link that executes when the `test` function returns
+   * `false`. If the `right` link is not provided, the request is forwarded to
+   * the next link in the chain.
+   */
+  split(test, left, right) {
+    return this.concat(_ApolloLink.split(test, left, right));
+  }
+  /**
+   * Combines the link with other links into a single composed link.
+   *
+   * @example
+   *
+   * ```ts
+   * import { ApolloLink, HttpLink } from "@apollo/client";
+   *
+   * const previousLink = new ApolloLink((operation, forward) => {
+   *   // Handle the request
+   *
+   *   return forward(operation);
+   * });
+   *
+   * const link = previousLink.concat(
+   *   link1,
+   *   link2,
+   *   new HttpLink({ uri: "http://localhost:4000/graphql" })
+   * );
+   * ```
+   */
+  concat(...links) {
+    if (links.length === 0) {
+      return this;
+    }
+    return links.reduce(this.combine.bind(this), this);
+  }
+  combine(left, right) {
+    const link = new _ApolloLink((operation, forward) => {
+      return left.request(operation, (op) => right.request(op, forward));
+    });
+    return Object.assign(link, { left, right });
+  }
+  /**
+   * Runs the request handler for the provided operation.
+   *
+   * > [!NOTE]
+   * > This is called by the `ApolloLink.execute` function for you and should
+   * > not be called directly. Prefer using `ApolloLink.execute` to make the
+   * > request instead.
+   */
+  request(operation, forward) {
+    throw newInvariantError(65);
+  }
+  /**
+  * @internal
+  * Used to iterate through all links that are concatenations or `split` links.
+  * 
+  * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+  */
+  left;
+  /**
+  * @internal
+  * Used to iterate through all links that are concatenations or `split` links.
+  * 
+  * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+  */
+  right;
+};
+
+// ../../node_modules/@apollo/client/errors/utils.js
+function isBranded(error, name) {
+  return typeof error === "object" && error !== null && error[/* @__PURE__ */ Symbol.for("apollo.error")] === name;
+}
+function brand(error) {
+  Object.defineProperty(error, /* @__PURE__ */ Symbol.for("apollo.error"), {
+    value: error.name,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+}
+
+// ../../node_modules/@apollo/client/errors/ServerError.js
+var ServerError = class _ServerError extends Error {
+  /**
+   * A method that determines whether an error is a `ServerError` object. This
+   * method enables TypeScript to narrow the error type.
+   *
+   * @example
+   *
+   * ```ts
+   * if (ServerError.is(error)) {
+   *   // TypeScript now knows `error` is a ServerError object
+   *   console.log(error.errors);
+   * }
+   * ```
+   */
+  static is(error) {
+    return isBranded(error, "ServerError");
+  }
+  /**
+  * The raw [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) object provided by the [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API).
+  */
+  response;
+  /**
+  * The status code returned by the server in the response. This is provided as
+  * a shortcut for `response.status`.
+  */
+  statusCode;
+  /**
+  * The raw response body text.
+  */
+  bodyText;
+  constructor(message, options) {
+    super(message);
+    this.name = "ServerError";
+    this.response = options.response;
+    this.statusCode = options.response.status;
+    this.bodyText = options.bodyText;
+    brand(this);
+    Object.setPrototypeOf(this, _ServerError.prototype);
+  }
+};
+
+// ../../node_modules/@apollo/client/errors/ServerParseError.js
+var ServerParseError = class _ServerParseError extends Error {
+  /**
+   * A method that determines whether an error is a `ServerParseError`
+   * object. This method enables TypeScript to narrow the error type.
+   *
+   * @example
+   *
+   * ```ts
+   * if (ServerParseError.is(error)) {
+   *   // TypeScript now knows `error` is a ServerParseError object
+   *   console.log(error.statusCode);
+   * }
+   * ```
+   */
+  static is(error) {
+    return isBranded(error, "ServerParseError");
+  }
+  /**
+  * The raw [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) object provided by the [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API).
+  */
+  response;
+  /**
+  * The status code returned by the server in the response. This is provided
+  * as a shortcut for `response.status`.
+  */
+  statusCode;
+  /**
+  * The raw response body text.
+  */
+  bodyText;
+  constructor(originalParseError, options) {
+    super(originalParseError instanceof Error ? originalParseError.message : "Could not parse server response", { cause: originalParseError });
+    this.name = "ServerParseError";
+    this.response = options.response;
+    this.statusCode = options.response.status;
+    this.bodyText = options.bodyText;
+    brand(this);
+    Object.setPrototypeOf(this, _ServerParseError.prototype);
+  }
+};
+
+// ../../node_modules/@apollo/client/link/http/parseAndCheckHttpResponse.js
+var { hasOwnProperty: hasOwnProperty2 } = Object.prototype;
+function parseJsonEncoding(response, bodyText) {
+  if (response.status >= 300) {
+    throw new ServerError(`Response not successful: Received status code ${response.status}`, { response, bodyText });
+  }
+  try {
+    return JSON.parse(bodyText);
+  } catch (err) {
+    throw new ServerParseError(err, { response, bodyText });
+  }
+}
+function parseGraphQLResponseJsonEncoding(response, bodyText) {
+  try {
+    return JSON.parse(bodyText);
+  } catch (err) {
+    throw new ServerParseError(err, { response, bodyText });
+  }
+}
+function parseResponse(response, bodyText) {
+  const contentType = response.headers.get("content-type");
+  if (contentType?.includes("application/graphql-response+json")) {
+    return parseGraphQLResponseJsonEncoding(response, bodyText);
+  }
+  return parseJsonEncoding(response, bodyText);
+}
+function parseAndCheckHttpResponse(operations) {
+  return (response) => response.text().then((bodyText) => {
+    const result = parseResponse(response, bodyText);
+    if (!Array.isArray(result) && !hasOwnProperty2.call(result, "data") && !hasOwnProperty2.call(result, "errors")) {
+      throw new ServerError(`Server response was malformed for query '${Array.isArray(operations) ? operations.map((op) => op.operationName) : operations.operationName}'.`, { response, bodyText });
+    }
+    return result;
+  });
+}
+
+// ../../node_modules/@apollo/client/utilities/graphql/print.js
+var printCache;
+var print2 = Object.assign((ast) => {
+  let result = printCache.get(ast);
+  if (!result) {
+    result = print(ast);
+    printCache.set(ast, result);
+  }
+  return result;
+}, {
+  reset() {
+    printCache = new AutoCleanedWeakCache(
+      cacheSizes.print || 2e3
+      /* defaultCacheSizes.print */
+    );
+  }
+});
+print2.reset();
+if (__DEV__) {
+  registerGlobalCache("print", () => printCache ? printCache.size : 0);
+}
+
+// ../../node_modules/@apollo/client/link/http/selectHttpOptionsAndBody.js
+var defaultHttpOptions = {
+  includeQuery: true,
+  includeExtensions: true,
+  preserveHeaderCase: false
+};
+var defaultHeaders = {
+  // headers are case insensitive (https://stackoverflow.com/a/5259004)
+  accept: "application/graphql-response+json,application/json;q=0.9",
+  // The content-type header describes the type of the body of the request, and
+  // so it typically only is sent with requests that actually have bodies. One
+  // could imagine that Apollo Client would remove this header when constructing
+  // a GET request (which has no body), but we historically have not done that.
+  // This means that browsers will preflight all Apollo Client requests (even
+  // GET requests). Apollo Server's CSRF prevention feature (introduced in
+  // AS3.7) takes advantage of this fact and does not block requests with this
+  // header. If you want to drop this header from GET requests, then you should
+  // probably replace it with a `apollo-require-preflight` header, or servers
+  // with CSRF prevention enabled might block your GET request. See
+  // https://www.apollographql.com/docs/apollo-server/security/cors/#preventing-cross-site-request-forgery-csrf
+  // for more details.
+  "content-type": "application/json"
+};
+var defaultOptions = {
+  method: "POST"
+};
+var fallbackHttpConfig = {
+  http: defaultHttpOptions,
+  headers: defaultHeaders,
+  options: defaultOptions
+};
+var defaultPrinter = (ast, printer) => printer(ast);
+function selectHttpOptionsAndBodyInternal(operation, printer, ...configs) {
+  let options = {};
+  let http = {};
+  configs.forEach((config2) => {
+    options = {
+      ...options,
+      ...config2.options,
+      headers: {
+        ...options.headers,
+        ...config2.headers
+      }
+    };
+    if (config2.credentials) {
+      options.credentials = config2.credentials;
+    }
+    options.headers.accept = (config2.http?.accept || []).concat(options.headers.accept).join(",");
+    http = {
+      ...http,
+      ...config2.http
+    };
+  });
+  options.headers = removeDuplicateHeaders(options.headers, http.preserveHeaderCase);
+  const { operationName, extensions, variables, query } = operation;
+  const body = { operationName, variables };
+  if (http.includeExtensions && Object.keys(extensions || {}).length)
+    body.extensions = extensions;
+  if (http.includeQuery)
+    body.query = printer(query, print2);
+  return {
+    options,
+    body
+  };
+}
+function removeDuplicateHeaders(headers, preserveHeaderCase) {
+  if (!preserveHeaderCase) {
+    const normalizedHeaders2 = {};
+    Object.keys(Object(headers)).forEach((name) => {
+      normalizedHeaders2[name.toLowerCase()] = headers[name];
+    });
+    return normalizedHeaders2;
+  }
+  const headerData = {};
+  Object.keys(Object(headers)).forEach((name) => {
+    headerData[name.toLowerCase()] = {
+      originalName: name,
+      value: headers[name]
+    };
+  });
+  const normalizedHeaders = {};
+  Object.keys(headerData).forEach((name) => {
+    normalizedHeaders[headerData[name].originalName] = headerData[name].value;
+  });
+  return normalizedHeaders;
+}
+
+// ../../node_modules/@apollo/client/link/http/selectURI.js
+var selectURI = (operation, fallbackURI) => {
+  const context2 = operation.getContext();
+  const contextURI = context2.uri;
+  if (contextURI) {
+    return contextURI;
+  } else if (typeof fallbackURI === "function") {
+    return fallbackURI(operation);
+  } else {
+    return fallbackURI || "/graphql";
+  }
+};
+
+// ../../node_modules/@apollo/client/link/http/rewriteURIForGET.js
+function rewriteURIForGET(chosenURI, body) {
+  const queryParams = [];
+  const addQueryParam = (key, value) => {
+    queryParams.push(`${key}=${encodeURIComponent(value)}`);
+  };
+  if ("query" in body) {
+    addQueryParam("query", body.query);
+  }
+  if (body.operationName) {
+    addQueryParam("operationName", body.operationName);
+  }
+  if (body.variables) {
+    let serializedVariables;
+    try {
+      serializedVariables = JSON.stringify(body.variables);
+    } catch (parseError) {
+      return { parseError };
+    }
+    addQueryParam("variables", serializedVariables);
+  }
+  if (body.extensions) {
+    let serializedExtensions;
+    try {
+      serializedExtensions = JSON.stringify(body.extensions);
+    } catch (parseError) {
+      return { parseError };
+    }
+    addQueryParam("extensions", serializedExtensions);
+  }
+  let fragment = "", preFragment = chosenURI;
+  const fragmentStart = chosenURI.indexOf("#");
+  if (fragmentStart !== -1) {
+    fragment = chosenURI.substr(fragmentStart);
+    preFragment = chosenURI.substr(0, fragmentStart);
+  }
+  const queryParamsPrefix = preFragment.indexOf("?") === -1 ? "?" : "&";
+  const newURI = preFragment + queryParamsPrefix + queryParams.join("&") + fragment;
+  return { newURI };
+}
+
+// ../../node_modules/is-plain-obj/index.js
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+
+// ../../node_modules/extract-files/extractFiles.mjs
+function extractFiles(value, isExtractable, path = "") {
+  if (!arguments.length) throw new TypeError("Argument 1 `value` is required.");
+  if (typeof isExtractable !== "function")
+    throw new TypeError("Argument 2 `isExtractable` must be a function.");
+  if (typeof path !== "string")
+    throw new TypeError("Argument 3 `path` must be a string.");
+  const clones = /* @__PURE__ */ new Map();
+  const files = /* @__PURE__ */ new Map();
+  function recurse(value2, path2, recursed) {
+    if (isExtractable(value2)) {
+      const filePaths = files.get(value2);
+      filePaths ? filePaths.push(path2) : files.set(value2, [path2]);
+      return null;
+    }
+    const valueIsList = Array.isArray(value2) || typeof FileList !== "undefined" && value2 instanceof FileList;
+    const valueIsPlainObject = isPlainObject(value2);
+    if (valueIsList || valueIsPlainObject) {
+      let clone = clones.get(value2);
+      const uncloned = !clone;
+      if (uncloned) {
+        clone = valueIsList ? [] : (
+          // Replicate if the plain object is an `Object` instance.
+          value2 instanceof /** @type {any} */
+          Object ? {} : /* @__PURE__ */ Object.create(null)
+        );
+        clones.set(
+          value2,
+          /** @type {Clone} */
+          clone
+        );
+      }
+      if (!recursed.has(value2)) {
+        const pathPrefix = path2 ? `${path2}.` : "";
+        const recursedDeeper = new Set(recursed).add(value2);
+        if (valueIsList) {
+          let index = 0;
+          for (const item of value2) {
+            const itemClone = recurse(
+              item,
+              pathPrefix + index++,
+              recursedDeeper
+            );
+            if (uncloned) clone.push(itemClone);
+          }
+        } else
+          for (const key in value2) {
+            const propertyClone = recurse(
+              value2[key],
+              pathPrefix + key,
+              recursedDeeper
+            );
+            if (uncloned)
+              clone[key] = propertyClone;
+          }
+      }
+      return clone;
+    }
+    return value2;
+  }
+  return {
+    clone: recurse(value, path, /* @__PURE__ */ new Set()),
+    files
+  };
+}
+
+// ../../node_modules/apollo-upload-client/formDataAppendFile.mjs
+function formDataAppendFile(formData, fieldName, file) {
+  "name" in file ? formData.append(fieldName, file, file.name) : formData.append(fieldName, file);
+}
+
+// ../../node_modules/extract-files/isExtractableFile.mjs
+function isExtractableFile(value) {
+  return typeof File !== "undefined" && value instanceof File || typeof Blob !== "undefined" && value instanceof Blob;
+}
+
+// ../../node_modules/apollo-upload-client/UploadHttpLink.mjs
+var UploadHttpLink = class extends ApolloLink {
+  /**
+   * @param {object} options Options.
+   * @param {Parameters<typeof selectURI>[1]} [options.uri] GraphQL endpoint
+   *   URI. Defaults to `"/graphql"`.
+   * @param {boolean} [options.useGETForQueries] Should GET be used to fetch
+   *   queries, if there are no files to upload.
+   * @param {ExtractableFileMatcher} [options.isExtractableFile] Matches
+   *   extractable files in the GraphQL operation. Defaults to
+   *   {@linkcode isExtractableFile}.
+   * @param {typeof FormData} [options.FormData]
+   *   [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData)
+   *   class. Defaults to the {@linkcode FormData} global.
+   * @param {FormDataFileAppender} [options.formDataAppendFile]
+   *   Customizes how extracted files are appended to the
+   *   [`FormData`](https://developer.mozilla.org/en-US/docs/Web/API/FormData)
+   *   instance. Defaults to {@linkcode formDataAppendFile}.
+   * @param {BaseHttpLink.Printer} [options.print] Prints the GraphQL query or
+   *   mutation AST to a string for transport. Defaults to
+   *   {@linkcode defaultPrinter}.
+   * @param {typeof fetch} [options.fetch]
+   *   [`fetch`](https://fetch.spec.whatwg.org) implementation. Defaults to the
+   *   {@linkcode fetch} global.
+   * @param {RequestInit} [options.fetchOptions] `fetch` options; overridden by
+   *   upload requirements.
+   * @param {string} [options.credentials] Overrides
+   *   {@linkcode RequestInit.credentials credentials} in
+   *   {@linkcode fetchOptions}.
+   * @param {{ [headerName: string]: string }} [options.headers] Merges with and
+   *   overrides {@linkcode RequestInit.headers headers} in
+   *   {@linkcode fetchOptions}.
+   * @param {boolean} [options.includeExtensions] Toggles sending `extensions`
+   *   fields to the GraphQL server. Defaults to `false`.
+   * @param {boolean} [options.includeUnusedVariables] Toggles including unused
+   *   GraphQL variables in the request. Defaults to `false`.
+   */
+  constructor({
+    uri: fetchUri = "/graphql",
+    useGETForQueries,
+    isExtractableFile: customIsExtractableFile = isExtractableFile,
+    FormData: CustomFormData,
+    formDataAppendFile: customFormDataAppendFile = formDataAppendFile,
+    print: print3 = defaultPrinter,
+    fetch: customFetch,
+    fetchOptions,
+    credentials,
+    headers,
+    includeExtensions,
+    includeUnusedVariables = false
+  } = {}) {
+    super(
+      (operation) => new Observable((observer) => {
+        const context2 = operation.getContext();
+        const { options, body } = selectHttpOptionsAndBodyInternal(
+          operation,
+          print3,
+          fallbackHttpConfig,
+          {
+            http: {
+              includeExtensions
+            },
+            options: fetchOptions,
+            credentials,
+            headers
+          },
+          {
+            http: context2.http,
+            options: context2.fetchOptions,
+            credentials: context2.credentials,
+            headers: context2.headers
+          }
+        );
+        if (body.variables && !includeUnusedVariables)
+          body.variables = filterOperationVariables(
+            body.variables,
+            operation.query
+          );
+        const { clone, files } = extractFiles(
+          body,
+          customIsExtractableFile,
+          ""
+        );
+        let uri = selectURI(operation, fetchUri);
+        if (files.size) {
+          if (options.headers)
+            delete options.headers["content-type"];
+          const RuntimeFormData = CustomFormData || FormData;
+          const form = new RuntimeFormData();
+          form.append("operations", JSON.stringify(clone));
+          const map = {};
+          let i = 0;
+          files.forEach((paths) => {
+            map[++i] = paths;
+          });
+          form.append("map", JSON.stringify(map));
+          i = 0;
+          files.forEach((_paths, file) => {
+            customFormDataAppendFile(form, String(++i), file);
+          });
+          options.body = form;
+        } else {
+          if (useGETForQueries && // If the operation contains some mutations GET shouldn’t be used.
+          !operation.query.definitions.some(
+            (definition) => definition.kind === "OperationDefinition" && definition.operation === "mutation"
+          ))
+            options.method = "GET";
+          if (options.method === "GET") {
+            const result = (
+              /** @type {{ newURI: string } | { parseError: unknown }} */
+              // The return type is incorrect; `newURI` and `parseError`
+              // will never both be present.
+              rewriteURIForGET(uri, body)
+            );
+            if ("parseError" in result) throw result.parseError;
+            uri = result.newURI;
+          } else options.body = JSON.stringify(clone);
+        }
+        let controller;
+        if (typeof AbortController !== "undefined") {
+          controller = new AbortController();
+          if (options.signal)
+            options.signal.aborted ? (
+              // Signal already aborted, so immediately abort.
+              controller.abort()
+            ) : (
+              // Signal not already aborted, so setup a listener to abort
+              // when it does.
+              options.signal.addEventListener(
+                "abort",
+                () => {
+                  controller.abort();
+                },
+                {
+                  // Prevent a memory leak if the user configured abort
+                  // controller is long lasting, or controls multiple
+                  // things.
+                  once: true
+                }
+              )
+            );
+          options.signal = controller.signal;
+        }
+        const runtimeFetch = customFetch || fetch;
+        let cleaningUp;
+        runtimeFetch(uri, options).then((response) => {
+          operation.setContext({ response });
+          return response;
+        }).then(parseAndCheckHttpResponse(operation)).then((result) => {
+          observer.next(result);
+          observer.complete();
+        }).catch((error) => {
+          if (!cleaningUp) observer.error(error);
+        });
+        return () => {
+          cleaningUp = true;
+          if (controller) controller.abort();
+        };
+      })
+    );
+  }
+};
 export {
   UploadHttpLink
 };