@cedarjs/web 0.0.4

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

@@ -0,0 +1,2474 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/bundled/apollo-upload-client.ts
+var apollo_upload_client_exports = {};
+__export(apollo_upload_client_exports, {
+  createUploadLink: () => createUploadLink
+});
+module.exports = __toCommonJS(apollo_upload_client_exports);
+
+// ../../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 __());
+}
+var __assign = function() {
+  __assign = Object.assign || function __assign2(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+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/ts-invariant/lib/invariant.js
+var genericMessage = "Invariant Violation";
+var _a = Object.setPrototypeOf;
+var setPrototypeOf = _a === void 0 ? function(obj, proto) {
+  obj.__proto__ = proto;
+  return obj;
+} : _a;
+var InvariantError = (
+  /** @class */
+  function(_super) {
+    __extends(InvariantError2, _super);
+    function InvariantError2(message) {
+      if (message === void 0) {
+        message = genericMessage;
+      }
+      var _this = _super.call(this, typeof message === "number" ? genericMessage + ": " + message + " (see https://github.com/apollographql/invariant-packages)" : message) || this;
+      _this.framesToPop = 1;
+      _this.name = genericMessage;
+      setPrototypeOf(_this, InvariantError2.prototype);
+      return _this;
+    }
+    return InvariantError2;
+  }(Error)
+);
+function invariant(condition, message) {
+  if (!condition) {
+    throw new InvariantError(message);
+  }
+}
+var verbosityLevels = ["debug", "log", "warn", "error", "silent"];
+var verbosityLevel = verbosityLevels.indexOf("log");
+function wrapConsoleMethod(name) {
+  return function() {
+    if (verbosityLevels.indexOf(name) >= verbosityLevel) {
+      var method = console[name] || console.log;
+      return method.apply(console, arguments);
+    }
+  };
+}
+(function(invariant4) {
+  invariant4.debug = wrapConsoleMethod("debug");
+  invariant4.log = wrapConsoleMethod("log");
+  invariant4.warn = wrapConsoleMethod("warn");
+  invariant4.error = wrapConsoleMethod("error");
+})(invariant || (invariant = {}));
+
+// ../../node_modules/@apollo/client/version.js
+var version = "3.11.1";
+
+// ../../node_modules/@apollo/client/utilities/globals/maybe.js
+function maybe(thunk) {
+  try {
+    return thunk();
+  } catch (_a2) {
+  }
+}
+
+// ../../node_modules/@apollo/client/utilities/globals/global.js
+var global_default = maybe(function() {
+  return globalThis;
+}) || maybe(function() {
+  return window;
+}) || maybe(function() {
+  return self;
+}) || maybe(function() {
+  return global;
+}) || // 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
+// 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/utilities/common/makeUniqueId.js
+var prefixCounts = /* @__PURE__ */ new Map();
+function makeUniqueId(prefix) {
+  var count = prefixCounts.get(prefix) || 1;
+  prefixCounts.set(prefix, count + 1);
+  return "".concat(prefix, ":").concat(count, ":").concat(Math.random().toString(36).slice(2));
+}
+
+// ../../node_modules/@apollo/client/utilities/common/stringifyForDisplay.js
+function stringifyForDisplay(value, space) {
+  if (space === void 0) {
+    space = 0;
+  }
+  var undefId = makeUniqueId("stringifyForDisplay");
+  return JSON.stringify(value, function(key, value2) {
+    return value2 === void 0 ? undefId : value2;
+  }, space).split(JSON.stringify(undefId)).join("<undefined>");
+}
+
+// ../../node_modules/@apollo/client/utilities/globals/invariantWrappers.js
+function wrap(fn) {
+  return function(message) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+      args[_i - 1] = arguments[_i];
+    }
+    if (typeof message === "number") {
+      var arg0 = message;
+      message = getHandledErrorMsg(arg0);
+      if (!message) {
+        message = getFallbackErrorMsg(arg0, args);
+        args = [];
+      }
+    }
+    fn.apply(void 0, [message].concat(args));
+  };
+}
+var invariant2 = Object.assign(function invariant3(condition, message) {
+  var args = [];
+  for (var _i = 2; _i < arguments.length; _i++) {
+    args[_i - 2] = arguments[_i];
+  }
+  if (!condition) {
+    invariant(condition, getHandledErrorMsg(message, args) || getFallbackErrorMsg(message, args));
+  }
+}, {
+  debug: wrap(invariant.debug),
+  log: wrap(invariant.log),
+  warn: wrap(invariant.warn),
+  error: wrap(invariant.error)
+});
+function newInvariantError(message) {
+  var optionalParams = [];
+  for (var _i = 1; _i < arguments.length; _i++) {
+    optionalParams[_i - 1] = arguments[_i];
+  }
+  return new InvariantError(getHandledErrorMsg(message, optionalParams) || getFallbackErrorMsg(message, optionalParams));
+}
+var ApolloErrorMessageHandler = Symbol.for("ApolloErrorMessageHandler_" + version);
+function stringify(arg) {
+  if (typeof arg == "string") {
+    return arg;
+  }
+  try {
+    return stringifyForDisplay(arg, 2).slice(0, 1e3);
+  } catch (_a2) {
+    return "<non-serializable>";
+  }
+}
+function getHandledErrorMsg(message, messageArgs) {
+  if (messageArgs === void 0) {
+    messageArgs = [];
+  }
+  if (!message)
+    return;
+  return global_default[ApolloErrorMessageHandler] && global_default[ApolloErrorMessageHandler](message, messageArgs.map(stringify));
+}
+function getFallbackErrorMsg(message, messageArgs) {
+  if (messageArgs === void 0) {
+    messageArgs = [];
+  }
+  if (!message)
+    return;
+  return "An error occurred! For more details, see the full error text at https://go.apollo.dev/c/err#".concat(encodeURIComponent(JSON.stringify({
+    version,
+    message,
+    args: messageArgs.map(stringify)
+  })));
+}
+
+// ../../node_modules/@apollo/client/utilities/globals/index.js
+var DEV = globalThis.__DEV__ !== false;
+
+// ../../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: [
+    "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"]
+};
+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["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";
+})(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 result2 = "";
+  const skipLeadingNewLine = isSingleLine && isWhiteSpace(value.charCodeAt(0));
+  if (printAsMultipleLines && !skipLeadingNewLine || forceLeadingNewLine) {
+    result2 += "\n";
+  }
+  result2 += escapedValue;
+  if (printAsMultipleLines || forceTrailingNewline) {
+    result2 += "\n";
+  }
+  return '"""' + result2 + '"""';
+}
+
+// ../../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(root2, 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(root2);
+  let keys = [root2];
+  let index = -1;
+  let edits = [];
+  let node = root2;
+  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 = Object.defineProperties(
+            {},
+            Object.getOwnPropertyDescriptors(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 result2;
+    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;
+      result2 = visitFn === null || visitFn === void 0 ? void 0 : visitFn.call(visitor, node, key, parent, path, ancestors);
+      if (result2 === BREAK) {
+        break;
+      }
+      if (result2 === false) {
+        if (!isLeaving) {
+          path.pop();
+          continue;
+        }
+      } else if (result2 !== void 0) {
+        edits.push([key, result2]);
+        if (!isLeaving) {
+          if (isNode(result2)) {
+            node = result2;
+          } else {
+            path.pop();
+            continue;
+          }
+        }
+      }
+    }
+    if (result2 === 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 root2;
+}
+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 = wrap2("(", join(node.variableDefinitions, ", "), ")");
+      const prefix = join(
+        [
+          node.operation,
+          join([node.name, varDefs]),
+          join(node.directives, " ")
+        ],
+        " "
+      );
+      return (prefix === "query" ? "" : prefix + " ") + node.selectionSet;
+    }
+  },
+  VariableDefinition: {
+    leave: ({ variable, type, defaultValue, directives }) => variable + ": " + type + wrap2(" = ", defaultValue) + wrap2(" ", join(directives, " "))
+  },
+  SelectionSet: {
+    leave: ({ selections }) => block(selections)
+  },
+  Field: {
+    leave({ alias, name, arguments: args, directives, selectionSet }) {
+      const prefix = wrap2("", alias, ": ") + name;
+      let argsLine = prefix + wrap2("(", join(args, ", "), ")");
+      if (argsLine.length > MAX_LINE_LENGTH) {
+        argsLine = prefix + wrap2("(\n", indent(join(args, "\n")), "\n)");
+      }
+      return join([argsLine, join(directives, " "), selectionSet], " ");
+    }
+  },
+  Argument: {
+    leave: ({ name, value }) => name + ": " + value
+  },
+  // Fragments
+  FragmentSpread: {
+    leave: ({ name, directives }) => "..." + name + wrap2(" ", join(directives, " "))
+  },
+  InlineFragment: {
+    leave: ({ typeCondition, directives, selectionSet }) => join(
+      [
+        "...",
+        wrap2("on ", typeCondition),
+        join(directives, " "),
+        selectionSet
+      ],
+      " "
+    )
+  },
+  FragmentDefinition: {
+    leave: ({ name, typeCondition, variableDefinitions, directives, selectionSet }) => (
+      // or removed in the future.
+      `fragment ${name}${wrap2("(", join(variableDefinitions, ", "), ")")} on ${typeCondition} ${wrap2("", 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 + wrap2("(", join(args, ", "), ")")
+  },
+  // Type
+  NamedType: {
+    leave: ({ name }) => name
+  },
+  ListType: {
+    leave: ({ type }) => "[" + type + "]"
+  },
+  NonNullType: {
+    leave: ({ type }) => type + "!"
+  },
+  // Type System Definitions
+  SchemaDefinition: {
+    leave: ({ description, directives, operationTypes }) => wrap2("", description, "\n") + join(["schema", join(directives, " "), block(operationTypes)], " ")
+  },
+  OperationTypeDefinition: {
+    leave: ({ operation, type }) => operation + ": " + type
+  },
+  ScalarTypeDefinition: {
+    leave: ({ description, name, directives }) => wrap2("", description, "\n") + join(["scalar", name, join(directives, " ")], " ")
+  },
+  ObjectTypeDefinition: {
+    leave: ({ description, name, interfaces, directives, fields }) => wrap2("", description, "\n") + join(
+      [
+        "type",
+        name,
+        wrap2("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  FieldDefinition: {
+    leave: ({ description, name, arguments: args, type, directives }) => wrap2("", description, "\n") + name + (hasMultilineItems(args) ? wrap2("(\n", indent(join(args, "\n")), "\n)") : wrap2("(", join(args, ", "), ")")) + ": " + type + wrap2(" ", join(directives, " "))
+  },
+  InputValueDefinition: {
+    leave: ({ description, name, type, defaultValue, directives }) => wrap2("", description, "\n") + join(
+      [name + ": " + type, wrap2("= ", defaultValue), join(directives, " ")],
+      " "
+    )
+  },
+  InterfaceTypeDefinition: {
+    leave: ({ description, name, interfaces, directives, fields }) => wrap2("", description, "\n") + join(
+      [
+        "interface",
+        name,
+        wrap2("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  UnionTypeDefinition: {
+    leave: ({ description, name, directives, types }) => wrap2("", description, "\n") + join(
+      ["union", name, join(directives, " "), wrap2("= ", join(types, " | "))],
+      " "
+    )
+  },
+  EnumTypeDefinition: {
+    leave: ({ description, name, directives, values }) => wrap2("", description, "\n") + join(["enum", name, join(directives, " "), block(values)], " ")
+  },
+  EnumValueDefinition: {
+    leave: ({ description, name, directives }) => wrap2("", description, "\n") + join([name, join(directives, " ")], " ")
+  },
+  InputObjectTypeDefinition: {
+    leave: ({ description, name, directives, fields }) => wrap2("", description, "\n") + join(["input", name, join(directives, " "), block(fields)], " ")
+  },
+  DirectiveDefinition: {
+    leave: ({ description, name, arguments: args, repeatable, locations }) => wrap2("", description, "\n") + "directive @" + name + (hasMultilineItems(args) ? wrap2("(\n", indent(join(args, "\n")), "\n)") : wrap2("(", join(args, ", "), ")")) + (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,
+        wrap2("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  InterfaceTypeExtension: {
+    leave: ({ name, interfaces, directives, fields }) => join(
+      [
+        "extend interface",
+        name,
+        wrap2("implements ", join(interfaces, " & ")),
+        join(directives, " "),
+        block(fields)
+      ],
+      " "
+    )
+  },
+  UnionTypeExtension: {
+    leave: ({ name, directives, types }) => join(
+      [
+        "extend union",
+        name,
+        join(directives, " "),
+        wrap2("= ", 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)], " ")
+  }
+};
+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 wrap2("{\n", indent(join(array, "\n")), "\n}");
+}
+function wrap2(start, maybeString, end = "") {
+  return maybeString != null && maybeString !== "" ? start + maybeString + end : "";
+}
+function indent(str) {
+  return wrap2("  ", 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/@wry/caches/lib/weak.js
+function noop() {
+}
+var defaultDispose = noop;
+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: noop,
+    unregister: noop
+  };
+};
+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/caching/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(function() {
+      cache.clean();
+      scheduledCleanup.delete(cache);
+    }, 100);
+  }
+}
+var AutoCleanedWeakCache = function(max, dispose) {
+  var cache = new WeakCache(max, dispose);
+  cache.set = function(key, value) {
+    var ret = WeakCache.prototype.set.call(this, key, value);
+    schedule(this);
+    return ret;
+  };
+  return cache;
+};
+
+// ../../node_modules/@apollo/client/utilities/caching/sizes.js
+var cacheSizeSymbol = Symbol.for("apollo.cacheSize");
+var cacheSizes = __assign({}, global_default[cacheSizeSymbol]);
+
+// ../../node_modules/@apollo/client/utilities/caching/getMemoryInternals.js
+var globalCaches = {};
+function registerGlobalCache(name, getSize) {
+  globalCaches[name] = getSize;
+}
+var getApolloClientMemoryInternals = globalThis.__DEV__ !== false ? _getApolloClientMemoryInternals : void 0;
+var getInMemoryCacheMemoryInternals = globalThis.__DEV__ !== false ? _getInMemoryCacheMemoryInternals : void 0;
+var getApolloCacheMemoryInternals = globalThis.__DEV__ !== false ? _getApolloCacheMemoryInternals : void 0;
+function getCurrentCacheSizes() {
+  var defaults = {
+    parser: 1e3,
+    canonicalStringify: 1e3,
+    print: 2e3,
+    "documentTransform.cache": 2e3,
+    "queryManager.getDocumentInfo": 2e3,
+    "PersistedQueryLink.persistedQueryHashes": 2e3,
+    "fragmentRegistry.transform": 2e3,
+    "fragmentRegistry.lookup": 1e3,
+    "fragmentRegistry.findFragmentSpreads": 4e3,
+    "cache.fragmentQueryDocuments": 1e3,
+    "removeTypenameFromVariables.getVariableDefinitions": 2e3,
+    "inMemoryCache.maybeBroadcastWatch": 5e3,
+    "inMemoryCache.executeSelectionSet": 5e4,
+    "inMemoryCache.executeSubSelectedArray": 1e4
+  };
+  return Object.fromEntries(Object.entries(defaults).map(function(_a2) {
+    var k = _a2[0], v = _a2[1];
+    return [
+      k,
+      cacheSizes[k] || v
+    ];
+  }));
+}
+function _getApolloClientMemoryInternals() {
+  var _a2, _b, _c, _d, _e;
+  if (!(globalThis.__DEV__ !== false))
+    throw new Error("only supported in development mode");
+  return {
+    limits: getCurrentCacheSizes(),
+    sizes: __assign({ print: (_a2 = globalCaches.print) === null || _a2 === void 0 ? void 0 : _a2.call(globalCaches), parser: (_b = globalCaches.parser) === null || _b === void 0 ? void 0 : _b.call(globalCaches), canonicalStringify: (_c = globalCaches.canonicalStringify) === null || _c === void 0 ? void 0 : _c.call(globalCaches), links: linkInfo(this.link), queryManager: {
+      getDocumentInfo: this["queryManager"]["transformCache"].size,
+      documentTransforms: transformInfo(this["queryManager"].documentTransform)
+    } }, (_e = (_d = this.cache).getMemoryInternals) === null || _e === void 0 ? void 0 : _e.call(_d))
+  };
+}
+function _getApolloCacheMemoryInternals() {
+  return {
+    cache: {
+      fragmentQueryDocuments: getWrapperInformation(this["getFragmentDoc"])
+    }
+  };
+}
+function _getInMemoryCacheMemoryInternals() {
+  var fragments = this.config.fragments;
+  return __assign(__assign({}, _getApolloCacheMemoryInternals.apply(this)), { addTypenameDocumentTransform: transformInfo(this["addTypenameTransform"]), inMemoryCache: {
+    executeSelectionSet: getWrapperInformation(this["storeReader"]["executeSelectionSet"]),
+    executeSubSelectedArray: getWrapperInformation(this["storeReader"]["executeSubSelectedArray"]),
+    maybeBroadcastWatch: getWrapperInformation(this["maybeBroadcastWatch"])
+  }, fragmentRegistry: {
+    findFragmentSpreads: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.findFragmentSpreads),
+    lookup: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.lookup),
+    transform: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.transform)
+  } });
+}
+function isWrapper(f) {
+  return !!f && "dirtyKey" in f;
+}
+function getWrapperInformation(f) {
+  return isWrapper(f) ? f.size : void 0;
+}
+function isDefined(value) {
+  return value != null;
+}
+function transformInfo(transform) {
+  return recurseTransformInfo(transform).map(function(cache) {
+    return { cache };
+  });
+}
+function recurseTransformInfo(transform) {
+  return transform ? __spreadArray(__spreadArray([
+    getWrapperInformation(transform === null || transform === void 0 ? void 0 : transform["performWork"])
+  ], recurseTransformInfo(transform === null || transform === void 0 ? void 0 : transform["left"]), true), recurseTransformInfo(transform === null || transform === void 0 ? void 0 : transform["right"]), true).filter(isDefined) : [];
+}
+function linkInfo(link) {
+  var _a2;
+  return link ? __spreadArray(__spreadArray([
+    (_a2 = link === null || link === void 0 ? void 0 : link.getMemoryInternals) === null || _a2 === void 0 ? void 0 : _a2.call(link)
+  ], linkInfo(link === null || link === void 0 ? void 0 : link.left), true), linkInfo(link === null || link === void 0 ? void 0 : link.right), true).filter(isDefined) : [];
+}
+
+// ../../node_modules/@apollo/client/utilities/graphql/getFromAST.js
+function getOperationName(doc) {
+  return doc.definitions.filter(function(definition) {
+    return definition.kind === "OperationDefinition" && !!definition.name;
+  }).map(function(x) {
+    return x.name.value;
+  })[0] || null;
+}
+
+// ../../node_modules/@apollo/client/utilities/graphql/print.js
+var printCache;
+var print2 = Object.assign(function(ast) {
+  var result2 = printCache.get(ast);
+  if (!result2) {
+    result2 = print(ast);
+    printCache.set(ast, result2);
+  }
+  return result2;
+}, {
+  reset: function() {
+    printCache = new AutoCleanedWeakCache(
+      cacheSizes.print || 2e3
+      /* defaultCacheSizes.print */
+    );
+  }
+});
+print2.reset();
+if (globalThis.__DEV__ !== false) {
+  registerGlobalCache("print", function() {
+    return printCache ? printCache.size : 0;
+  });
+}
+
+// ../../node_modules/zen-observable-ts/module.js
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (it) return (it = it.call(o)).next.bind(it);
+  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+    if (it) o = it;
+    var i = 0;
+    return function() {
+      if (i >= o.length) return { done: true };
+      return { done: false, value: o[i++] };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) {
+    arr2[i] = arr[i];
+  }
+  return arr2;
+}
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", { writable: false });
+  return Constructor;
+}
+var hasSymbols = function() {
+  return typeof Symbol === "function";
+};
+var hasSymbol = function(name) {
+  return hasSymbols() && Boolean(Symbol[name]);
+};
+var getSymbol = function(name) {
+  return hasSymbol(name) ? Symbol[name] : "@@" + name;
+};
+if (hasSymbols() && !hasSymbol("observable")) {
+  Symbol.observable = Symbol("observable");
+}
+var SymbolIterator = getSymbol("iterator");
+var SymbolObservable = getSymbol("observable");
+var SymbolSpecies = getSymbol("species");
+function getMethod(obj, key) {
+  var value = obj[key];
+  if (value == null) return void 0;
+  if (typeof value !== "function") throw new TypeError(value + " is not a function");
+  return value;
+}
+function getSpecies(obj) {
+  var ctor = obj.constructor;
+  if (ctor !== void 0) {
+    ctor = ctor[SymbolSpecies];
+    if (ctor === null) {
+      ctor = void 0;
+    }
+  }
+  return ctor !== void 0 ? ctor : Observable;
+}
+function isObservable(x) {
+  return x instanceof Observable;
+}
+function hostReportError(e) {
+  if (hostReportError.log) {
+    hostReportError.log(e);
+  } else {
+    setTimeout(function() {
+      throw e;
+    });
+  }
+}
+function enqueue(fn) {
+  Promise.resolve().then(function() {
+    try {
+      fn();
+    } catch (e) {
+      hostReportError(e);
+    }
+  });
+}
+function cleanupSubscription(subscription) {
+  var cleanup = subscription._cleanup;
+  if (cleanup === void 0) return;
+  subscription._cleanup = void 0;
+  if (!cleanup) {
+    return;
+  }
+  try {
+    if (typeof cleanup === "function") {
+      cleanup();
+    } else {
+      var unsubscribe = getMethod(cleanup, "unsubscribe");
+      if (unsubscribe) {
+        unsubscribe.call(cleanup);
+      }
+    }
+  } catch (e) {
+    hostReportError(e);
+  }
+}
+function closeSubscription(subscription) {
+  subscription._observer = void 0;
+  subscription._queue = void 0;
+  subscription._state = "closed";
+}
+function flushSubscription(subscription) {
+  var queue = subscription._queue;
+  if (!queue) {
+    return;
+  }
+  subscription._queue = void 0;
+  subscription._state = "ready";
+  for (var i = 0; i < queue.length; ++i) {
+    notifySubscription(subscription, queue[i].type, queue[i].value);
+    if (subscription._state === "closed") break;
+  }
+}
+function notifySubscription(subscription, type, value) {
+  subscription._state = "running";
+  var observer = subscription._observer;
+  try {
+    var m = getMethod(observer, type);
+    switch (type) {
+      case "next":
+        if (m) m.call(observer, value);
+        break;
+      case "error":
+        closeSubscription(subscription);
+        if (m) m.call(observer, value);
+        else throw value;
+        break;
+      case "complete":
+        closeSubscription(subscription);
+        if (m) m.call(observer);
+        break;
+    }
+  } catch (e) {
+    hostReportError(e);
+  }
+  if (subscription._state === "closed") cleanupSubscription(subscription);
+  else if (subscription._state === "running") subscription._state = "ready";
+}
+function onNotify(subscription, type, value) {
+  if (subscription._state === "closed") return;
+  if (subscription._state === "buffering") {
+    subscription._queue.push({
+      type,
+      value
+    });
+    return;
+  }
+  if (subscription._state !== "ready") {
+    subscription._state = "buffering";
+    subscription._queue = [{
+      type,
+      value
+    }];
+    enqueue(function() {
+      return flushSubscription(subscription);
+    });
+    return;
+  }
+  notifySubscription(subscription, type, value);
+}
+var Subscription = /* @__PURE__ */ function() {
+  function Subscription2(observer, subscriber) {
+    this._cleanup = void 0;
+    this._observer = observer;
+    this._queue = void 0;
+    this._state = "initializing";
+    var subscriptionObserver = new SubscriptionObserver(this);
+    try {
+      this._cleanup = subscriber.call(void 0, subscriptionObserver);
+    } catch (e) {
+      subscriptionObserver.error(e);
+    }
+    if (this._state === "initializing") this._state = "ready";
+  }
+  var _proto = Subscription2.prototype;
+  _proto.unsubscribe = function unsubscribe() {
+    if (this._state !== "closed") {
+      closeSubscription(this);
+      cleanupSubscription(this);
+    }
+  };
+  _createClass(Subscription2, [{
+    key: "closed",
+    get: function() {
+      return this._state === "closed";
+    }
+  }]);
+  return Subscription2;
+}();
+var SubscriptionObserver = /* @__PURE__ */ function() {
+  function SubscriptionObserver2(subscription) {
+    this._subscription = subscription;
+  }
+  var _proto2 = SubscriptionObserver2.prototype;
+  _proto2.next = function next(value) {
+    onNotify(this._subscription, "next", value);
+  };
+  _proto2.error = function error(value) {
+    onNotify(this._subscription, "error", value);
+  };
+  _proto2.complete = function complete() {
+    onNotify(this._subscription, "complete");
+  };
+  _createClass(SubscriptionObserver2, [{
+    key: "closed",
+    get: function() {
+      return this._subscription._state === "closed";
+    }
+  }]);
+  return SubscriptionObserver2;
+}();
+var Observable = /* @__PURE__ */ function() {
+  function Observable2(subscriber) {
+    if (!(this instanceof Observable2)) throw new TypeError("Observable cannot be called as a function");
+    if (typeof subscriber !== "function") throw new TypeError("Observable initializer must be a function");
+    this._subscriber = subscriber;
+  }
+  var _proto3 = Observable2.prototype;
+  _proto3.subscribe = function subscribe(observer) {
+    if (typeof observer !== "object" || observer === null) {
+      observer = {
+        next: observer,
+        error: arguments[1],
+        complete: arguments[2]
+      };
+    }
+    return new Subscription(observer, this._subscriber);
+  };
+  _proto3.forEach = function forEach(fn) {
+    var _this = this;
+    return new Promise(function(resolve, reject) {
+      if (typeof fn !== "function") {
+        reject(new TypeError(fn + " is not a function"));
+        return;
+      }
+      function done() {
+        subscription.unsubscribe();
+        resolve();
+      }
+      var subscription = _this.subscribe({
+        next: function(value) {
+          try {
+            fn(value, done);
+          } catch (e) {
+            reject(e);
+            subscription.unsubscribe();
+          }
+        },
+        error: reject,
+        complete: resolve
+      });
+    });
+  };
+  _proto3.map = function map(fn) {
+    var _this2 = this;
+    if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
+    var C = getSpecies(this);
+    return new C(function(observer) {
+      return _this2.subscribe({
+        next: function(value) {
+          try {
+            value = fn(value);
+          } catch (e) {
+            return observer.error(e);
+          }
+          observer.next(value);
+        },
+        error: function(e) {
+          observer.error(e);
+        },
+        complete: function() {
+          observer.complete();
+        }
+      });
+    });
+  };
+  _proto3.filter = function filter(fn) {
+    var _this3 = this;
+    if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
+    var C = getSpecies(this);
+    return new C(function(observer) {
+      return _this3.subscribe({
+        next: function(value) {
+          try {
+            if (!fn(value)) return;
+          } catch (e) {
+            return observer.error(e);
+          }
+          observer.next(value);
+        },
+        error: function(e) {
+          observer.error(e);
+        },
+        complete: function() {
+          observer.complete();
+        }
+      });
+    });
+  };
+  _proto3.reduce = function reduce(fn) {
+    var _this4 = this;
+    if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
+    var C = getSpecies(this);
+    var hasSeed = arguments.length > 1;
+    var hasValue = false;
+    var seed = arguments[1];
+    var acc = seed;
+    return new C(function(observer) {
+      return _this4.subscribe({
+        next: function(value) {
+          var first = !hasValue;
+          hasValue = true;
+          if (!first || hasSeed) {
+            try {
+              acc = fn(acc, value);
+            } catch (e) {
+              return observer.error(e);
+            }
+          } else {
+            acc = value;
+          }
+        },
+        error: function(e) {
+          observer.error(e);
+        },
+        complete: function() {
+          if (!hasValue && !hasSeed) return observer.error(new TypeError("Cannot reduce an empty sequence"));
+          observer.next(acc);
+          observer.complete();
+        }
+      });
+    });
+  };
+  _proto3.concat = function concat() {
+    var _this5 = this;
+    for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
+      sources[_key] = arguments[_key];
+    }
+    var C = getSpecies(this);
+    return new C(function(observer) {
+      var subscription;
+      var index = 0;
+      function startNext(next) {
+        subscription = next.subscribe({
+          next: function(v) {
+            observer.next(v);
+          },
+          error: function(e) {
+            observer.error(e);
+          },
+          complete: function() {
+            if (index === sources.length) {
+              subscription = void 0;
+              observer.complete();
+            } else {
+              startNext(C.from(sources[index++]));
+            }
+          }
+        });
+      }
+      startNext(_this5);
+      return function() {
+        if (subscription) {
+          subscription.unsubscribe();
+          subscription = void 0;
+        }
+      };
+    });
+  };
+  _proto3.flatMap = function flatMap(fn) {
+    var _this6 = this;
+    if (typeof fn !== "function") throw new TypeError(fn + " is not a function");
+    var C = getSpecies(this);
+    return new C(function(observer) {
+      var subscriptions = [];
+      var outer = _this6.subscribe({
+        next: function(value) {
+          if (fn) {
+            try {
+              value = fn(value);
+            } catch (e) {
+              return observer.error(e);
+            }
+          }
+          var inner = C.from(value).subscribe({
+            next: function(value2) {
+              observer.next(value2);
+            },
+            error: function(e) {
+              observer.error(e);
+            },
+            complete: function() {
+              var i = subscriptions.indexOf(inner);
+              if (i >= 0) subscriptions.splice(i, 1);
+              completeIfDone();
+            }
+          });
+          subscriptions.push(inner);
+        },
+        error: function(e) {
+          observer.error(e);
+        },
+        complete: function() {
+          completeIfDone();
+        }
+      });
+      function completeIfDone() {
+        if (outer.closed && subscriptions.length === 0) observer.complete();
+      }
+      return function() {
+        subscriptions.forEach(function(s) {
+          return s.unsubscribe();
+        });
+        outer.unsubscribe();
+      };
+    });
+  };
+  _proto3[SymbolObservable] = function() {
+    return this;
+  };
+  Observable2.from = function from(x) {
+    var C = typeof this === "function" ? this : Observable2;
+    if (x == null) throw new TypeError(x + " is not an object");
+    var method = getMethod(x, SymbolObservable);
+    if (method) {
+      var observable = method.call(x);
+      if (Object(observable) !== observable) throw new TypeError(observable + " is not an object");
+      if (isObservable(observable) && observable.constructor === C) return observable;
+      return new C(function(observer) {
+        return observable.subscribe(observer);
+      });
+    }
+    if (hasSymbol("iterator")) {
+      method = getMethod(x, SymbolIterator);
+      if (method) {
+        return new C(function(observer) {
+          enqueue(function() {
+            if (observer.closed) return;
+            for (var _iterator = _createForOfIteratorHelperLoose(method.call(x)), _step; !(_step = _iterator()).done; ) {
+              var item = _step.value;
+              observer.next(item);
+              if (observer.closed) return;
+            }
+            observer.complete();
+          });
+        });
+      }
+    }
+    if (Array.isArray(x)) {
+      return new C(function(observer) {
+        enqueue(function() {
+          if (observer.closed) return;
+          for (var i = 0; i < x.length; ++i) {
+            observer.next(x[i]);
+            if (observer.closed) return;
+          }
+          observer.complete();
+        });
+      });
+    }
+    throw new TypeError(x + " is not observable");
+  };
+  Observable2.of = function of() {
+    for (var _len2 = arguments.length, items = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      items[_key2] = arguments[_key2];
+    }
+    var C = typeof this === "function" ? this : Observable2;
+    return new C(function(observer) {
+      enqueue(function() {
+        if (observer.closed) return;
+        for (var i = 0; i < items.length; ++i) {
+          observer.next(items[i]);
+          if (observer.closed) return;
+        }
+        observer.complete();
+      });
+    });
+  };
+  _createClass(Observable2, null, [{
+    key: SymbolSpecies,
+    get: function() {
+      return this;
+    }
+  }]);
+  return Observable2;
+}();
+if (hasSymbols()) {
+  Object.defineProperty(Observable, Symbol("extensions"), {
+    value: {
+      symbol: SymbolObservable,
+      hostReportError
+    },
+    configurable: true
+  });
+}
+
+// ../../node_modules/symbol-observable/es/ponyfill.js
+function symbolObservablePonyfill(root2) {
+  var result2;
+  var Symbol2 = root2.Symbol;
+  if (typeof Symbol2 === "function") {
+    if (Symbol2.observable) {
+      result2 = Symbol2.observable;
+    } else {
+      if (typeof Symbol2.for === "function") {
+        result2 = Symbol2.for("https://github.com/benlesh/symbol-observable");
+      } else {
+        result2 = Symbol2("https://github.com/benlesh/symbol-observable");
+      }
+      try {
+        Symbol2.observable = result2;
+      } catch (err) {
+      }
+    }
+  } else {
+    result2 = "@@observable";
+  }
+  return result2;
+}
+
+// ../../node_modules/symbol-observable/es/index.js
+var root;
+if (typeof self !== "undefined") {
+  root = self;
+} else if (typeof window !== "undefined") {
+  root = window;
+} else if (typeof global !== "undefined") {
+  root = global;
+} else if (typeof module !== "undefined") {
+  root = module;
+} else {
+  root = Function("return this")();
+}
+var result = symbolObservablePonyfill(root);
+
+// ../../node_modules/@apollo/client/utilities/observables/Observable.js
+var prototype = Observable.prototype;
+var fakeObsSymbol = "@@observable";
+if (!prototype[fakeObsSymbol]) {
+  prototype[fakeObsSymbol] = function() {
+    return this;
+  };
+}
+
+// ../../node_modules/@apollo/client/link/utils/throwServerError.js
+var throwServerError = function(response, result2, message) {
+  var error = new Error(message);
+  error.name = "ServerError";
+  error.response = response;
+  error.statusCode = response.status;
+  error.result = result2;
+  throw error;
+};
+
+// ../../node_modules/@apollo/client/link/utils/validateOperation.js
+function validateOperation(operation) {
+  var OPERATION_FIELDS = [
+    "query",
+    "operationName",
+    "variables",
+    "extensions",
+    "context"
+  ];
+  for (var _i = 0, _a2 = Object.keys(operation); _i < _a2.length; _i++) {
+    var key = _a2[_i];
+    if (OPERATION_FIELDS.indexOf(key) < 0) {
+      throw newInvariantError(43, key);
+    }
+  }
+  return operation;
+}
+
+// ../../node_modules/@apollo/client/link/utils/createOperation.js
+function createOperation(starting, operation) {
+  var context = __assign({}, starting);
+  var setContext = function(next) {
+    if (typeof next === "function") {
+      context = __assign(__assign({}, context), next(context));
+    } else {
+      context = __assign(__assign({}, context), next);
+    }
+  };
+  var getContext = function() {
+    return __assign({}, context);
+  };
+  Object.defineProperty(operation, "setContext", {
+    enumerable: false,
+    value: setContext
+  });
+  Object.defineProperty(operation, "getContext", {
+    enumerable: false,
+    value: getContext
+  });
+  return operation;
+}
+
+// ../../node_modules/@apollo/client/link/utils/transformOperation.js
+function transformOperation(operation) {
+  var transformedOperation = {
+    variables: operation.variables || {},
+    extensions: operation.extensions || {},
+    operationName: operation.operationName,
+    query: operation.query
+  };
+  if (!transformedOperation.operationName) {
+    transformedOperation.operationName = typeof transformedOperation.query !== "string" ? getOperationName(transformedOperation.query) || void 0 : "";
+  }
+  return transformedOperation;
+}
+
+// ../../node_modules/@apollo/client/link/core/ApolloLink.js
+function passthrough(op, forward) {
+  return forward ? forward(op) : Observable.of();
+}
+function toLink(handler) {
+  return typeof handler === "function" ? new ApolloLink(handler) : handler;
+}
+function isTerminating(link) {
+  return link.request.length <= 1;
+}
+var ApolloLink = (
+  /** @class */
+  function() {
+    function ApolloLink2(request) {
+      if (request)
+        this.request = request;
+    }
+    ApolloLink2.empty = function() {
+      return new ApolloLink2(function() {
+        return Observable.of();
+      });
+    };
+    ApolloLink2.from = function(links) {
+      if (links.length === 0)
+        return ApolloLink2.empty();
+      return links.map(toLink).reduce(function(x, y) {
+        return x.concat(y);
+      });
+    };
+    ApolloLink2.split = function(test, left, right) {
+      var leftLink = toLink(left);
+      var rightLink = toLink(right || new ApolloLink2(passthrough));
+      var ret;
+      if (isTerminating(leftLink) && isTerminating(rightLink)) {
+        ret = new ApolloLink2(function(operation) {
+          return test(operation) ? leftLink.request(operation) || Observable.of() : rightLink.request(operation) || Observable.of();
+        });
+      } else {
+        ret = new ApolloLink2(function(operation, forward) {
+          return test(operation) ? leftLink.request(operation, forward) || Observable.of() : rightLink.request(operation, forward) || Observable.of();
+        });
+      }
+      return Object.assign(ret, { left: leftLink, right: rightLink });
+    };
+    ApolloLink2.execute = function(link, operation) {
+      return link.request(createOperation(operation.context, transformOperation(validateOperation(operation)))) || Observable.of();
+    };
+    ApolloLink2.concat = function(first, second) {
+      var firstLink = toLink(first);
+      if (isTerminating(firstLink)) {
+        globalThis.__DEV__ !== false && invariant2.warn(35, firstLink);
+        return firstLink;
+      }
+      var nextLink = toLink(second);
+      var ret;
+      if (isTerminating(nextLink)) {
+        ret = new ApolloLink2(function(operation) {
+          return firstLink.request(operation, function(op) {
+            return nextLink.request(op) || Observable.of();
+          }) || Observable.of();
+        });
+      } else {
+        ret = new ApolloLink2(function(operation, forward) {
+          return firstLink.request(operation, function(op) {
+            return nextLink.request(op, forward) || Observable.of();
+          }) || Observable.of();
+        });
+      }
+      return Object.assign(ret, { left: firstLink, right: nextLink });
+    };
+    ApolloLink2.prototype.split = function(test, left, right) {
+      return this.concat(ApolloLink2.split(test, left, right || new ApolloLink2(passthrough)));
+    };
+    ApolloLink2.prototype.concat = function(next) {
+      return ApolloLink2.concat(this, next);
+    };
+    ApolloLink2.prototype.request = function(operation, forward) {
+      throw newInvariantError(36);
+    };
+    ApolloLink2.prototype.onError = function(error, observer) {
+      if (observer && observer.error) {
+        observer.error(error);
+        return false;
+      }
+      throw error;
+    };
+    ApolloLink2.prototype.setOnError = function(fn) {
+      this.onError = fn;
+      return this;
+    };
+    return ApolloLink2;
+  }()
+);
+
+// ../../node_modules/@apollo/client/link/http/createSignalIfSupported.js
+var createSignalIfSupported = function() {
+  if (typeof AbortController === "undefined")
+    return { controller: false, signal: false };
+  var controller = new AbortController();
+  var signal = controller.signal;
+  return { controller, signal };
+};
+
+// ../../node_modules/@apollo/client/link/http/parseAndCheckHttpResponse.js
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function parseJsonBody(response, bodyText) {
+  if (response.status >= 300) {
+    var getResult = function() {
+      try {
+        return JSON.parse(bodyText);
+      } catch (err) {
+        return bodyText;
+      }
+    };
+    throwServerError(response, getResult(), "Response not successful: Received status code ".concat(response.status));
+  }
+  try {
+    return JSON.parse(bodyText);
+  } catch (err) {
+    var parseError = err;
+    parseError.name = "ServerParseError";
+    parseError.response = response;
+    parseError.statusCode = response.status;
+    parseError.bodyText = bodyText;
+    throw parseError;
+  }
+}
+function parseAndCheckHttpResponse(operations) {
+  return function(response) {
+    return response.text().then(function(bodyText) {
+      return parseJsonBody(response, bodyText);
+    }).then(function(result2) {
+      if (!Array.isArray(result2) && !hasOwnProperty.call(result2, "data") && !hasOwnProperty.call(result2, "errors")) {
+        throwServerError(response, result2, "Server response was missing for query '".concat(Array.isArray(operations) ? operations.map(function(op) {
+          return op.operationName;
+        }) : operations.operationName, "'."));
+      }
+      return result2;
+    });
+  };
+}
+
+// ../../node_modules/@apollo/client/link/http/serializeFetchParameter.js
+var serializeFetchParameter = function(p, label) {
+  var serialized;
+  try {
+    serialized = JSON.stringify(p);
+  } catch (e) {
+    var parseError = newInvariantError(39, label, e.message);
+    parseError.parseError = e;
+    throw parseError;
+  }
+  return serialized;
+};
+
+// ../../node_modules/@apollo/client/link/http/rewriteURIForGET.js
+function rewriteURIForGET(chosenURI, body) {
+  var queryParams = [];
+  var addQueryParam = function(key, value) {
+    queryParams.push("".concat(key, "=").concat(encodeURIComponent(value)));
+  };
+  if ("query" in body) {
+    addQueryParam("query", body.query);
+  }
+  if (body.operationName) {
+    addQueryParam("operationName", body.operationName);
+  }
+  if (body.variables) {
+    var serializedVariables = void 0;
+    try {
+      serializedVariables = serializeFetchParameter(body.variables, "Variables map");
+    } catch (parseError) {
+      return { parseError };
+    }
+    addQueryParam("variables", serializedVariables);
+  }
+  if (body.extensions) {
+    var serializedExtensions = void 0;
+    try {
+      serializedExtensions = serializeFetchParameter(body.extensions, "Extensions map");
+    } catch (parseError) {
+      return { parseError };
+    }
+    addQueryParam("extensions", serializedExtensions);
+  }
+  var fragment = "", preFragment = chosenURI;
+  var fragmentStart = chosenURI.indexOf("#");
+  if (fragmentStart !== -1) {
+    fragment = chosenURI.substr(fragmentStart);
+    preFragment = chosenURI.substr(0, fragmentStart);
+  }
+  var queryParamsPrefix = preFragment.indexOf("?") === -1 ? "?" : "&";
+  var newURI = preFragment + queryParamsPrefix + queryParams.join("&") + fragment;
+  return { newURI };
+}
+
+// ../../node_modules/@apollo/client/link/http/selectHttpOptionsAndBody.js
+var defaultHttpOptions = {
+  includeQuery: true,
+  includeExtensions: false,
+  preserveHeaderCase: false
+};
+var defaultHeaders = {
+  // headers are case insensitive (https://stackoverflow.com/a/5259004)
+  accept: "*/*",
+  // 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 = function(ast, printer) {
+  return printer(ast);
+};
+function selectHttpOptionsAndBodyInternal(operation, printer) {
+  var configs = [];
+  for (var _i = 2; _i < arguments.length; _i++) {
+    configs[_i - 2] = arguments[_i];
+  }
+  var options = {};
+  var http = {};
+  configs.forEach(function(config) {
+    options = __assign(__assign(__assign({}, options), config.options), { headers: __assign(__assign({}, options.headers), config.headers) });
+    if (config.credentials) {
+      options.credentials = config.credentials;
+    }
+    http = __assign(__assign({}, http), config.http);
+  });
+  if (options.headers) {
+    options.headers = removeDuplicateHeaders(options.headers, http.preserveHeaderCase);
+  }
+  var operationName = operation.operationName, extensions = operation.extensions, variables = operation.variables, query = operation.query;
+  var body = { operationName, variables };
+  if (http.includeExtensions)
+    body.extensions = extensions;
+  if (http.includeQuery)
+    body.query = printer(query, print2);
+  return {
+    options,
+    body
+  };
+}
+function removeDuplicateHeaders(headers, preserveHeaderCase) {
+  if (!preserveHeaderCase) {
+    var normalizedHeaders_1 = /* @__PURE__ */ Object.create(null);
+    Object.keys(Object(headers)).forEach(function(name) {
+      normalizedHeaders_1[name.toLowerCase()] = headers[name];
+    });
+    return normalizedHeaders_1;
+  }
+  var headerData = /* @__PURE__ */ Object.create(null);
+  Object.keys(Object(headers)).forEach(function(name) {
+    headerData[name.toLowerCase()] = {
+      originalName: name,
+      value: headers[name]
+    };
+  });
+  var normalizedHeaders = /* @__PURE__ */ Object.create(null);
+  Object.keys(headerData).forEach(function(name) {
+    normalizedHeaders[headerData[name].originalName] = headerData[name].value;
+  });
+  return normalizedHeaders;
+}
+
+// ../../node_modules/@apollo/client/link/http/selectURI.js
+var selectURI = function(operation, fallbackURI) {
+  var context = operation.getContext();
+  var contextURI = context.uri;
+  if (contextURI) {
+    return contextURI;
+  } else if (typeof fallbackURI === "function") {
+    return fallbackURI(operation);
+  } else {
+    return fallbackURI || "/graphql";
+  }
+};
+
+// ../../node_modules/apollo-upload-client/node_modules/is-plain-obj/index.js
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const prototype2 = Object.getPrototypeOf(value);
+  return (prototype2 === null || prototype2 === Object.prototype || Object.getPrototypeOf(prototype2) === null) && !(Symbol.toStringTag in value) && !(Symbol.iterator in value);
+}
+
+// ../../node_modules/apollo-upload-client/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/apollo-upload-client/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/createUploadLink.mjs
+function createUploadLink({
+  uri: fetchUri = "/graphql",
+  useGETForQueries,
+  isExtractableFile: customIsExtractableFile = isExtractableFile,
+  FormData: CustomFormData,
+  formDataAppendFile: customFormDataAppendFile = formDataAppendFile,
+  print: print3 = defaultPrinter,
+  fetch: customFetch,
+  fetchOptions,
+  credentials,
+  headers,
+  includeExtensions
+} = {}) {
+  const linkConfig = {
+    http: { includeExtensions },
+    options: fetchOptions,
+    credentials,
+    headers
+  };
+  return new ApolloLink((operation) => {
+    const context = (
+      /**
+       * @type {import("@apollo/client/core/types.js").DefaultContext & {
+       *   clientAwareness?: {
+       *     name?: string,
+       *     version?: string,
+       *   },
+       * }}
+       */
+      operation.getContext()
+    );
+    const {
+      // Apollo Studio client awareness `name` and `version` can be configured
+      // via `ApolloClient` constructor options:
+      // https://www.apollographql.com/docs/graphos/metrics/client-awareness/#setup
+      clientAwareness: { name, version: version2 } = {},
+      headers: headers2
+    } = context;
+    const contextConfig = {
+      http: context.http,
+      options: context.fetchOptions,
+      credentials: context.credentials,
+      headers: {
+        // Client awareness headers can be overridden by context `headers`.
+        ...name && { "apollographql-client-name": name },
+        ...version2 && { "apollographql-client-version": version2 },
+        ...headers2
+      }
+    };
+    const { options, body } = selectHttpOptionsAndBodyInternal(
+      operation,
+      print3,
+      fallbackHttpConfig,
+      linkConfig,
+      contextConfig
+    );
+    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", serializeFetchParameter(clone, "Payload"));
+      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 { newURI, parseError } = rewriteURIForGET(uri, body);
+        if (parseError)
+          return new Observable((observer) => {
+            observer.error(parseError);
+          });
+        uri = newURI;
+      } else options.body = serializeFetchParameter(clone, "Payload");
+    }
+    const { controller } = createSignalIfSupported();
+    if (typeof controller !== "boolean") {
+      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;
+    return new Observable((observer) => {
+      let cleaningUp;
+      runtimeFetch(uri, options).then((response) => {
+        operation.setContext({ response });
+        return response;
+      }).then(parseAndCheckHttpResponse(operation)).then((result2) => {
+        observer.next(result2);
+        observer.complete();
+      }).catch((error) => {
+        if (!cleaningUp) {
+          if (error.result && error.result.errors && error.result.data)
+            observer.next(error.result);
+          observer.error(error);
+        }
+      });
+      return () => {
+        cleaningUp = true;
+        if (typeof controller !== "boolean") controller.abort();
+      };
+    });
+  });
+}