{"version":3,"file":"js/6308.2e8eda91.js","mappings":"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","sources":["webpack://console-mf-users-front/./node_modules/tslib/tslib.es6.js","webpack://console-mf-users-front/../../../src/link/utils/createOperation.ts","webpack://console-mf-users-front/../../../src/link/utils/transformOperation.ts","webpack://console-mf-users-front/../../../src/link/utils/validateOperation.ts","webpack://console-mf-users-front/../../../src/link/core/ApolloLink.ts","webpack://console-mf-users-front/../../../src/utilities/common/objects.ts","webpack://console-mf-users-front/../src/invariant.ts","webpack://console-mf-users-front/../../../src/utilities/globals/maybe.ts","webpack://console-mf-users-front/../../../src/utilities/globals/global.ts","webpack://console-mf-users-front/../../../src/utilities/globals/DEV.ts","webpack://console-mf-users-front/./node_modules/ts-invariant/process/index.js","webpack://console-mf-users-front/../../../src/utilities/globals/fix-graphql.ts","webpack://console-mf-users-front/../../../src/utilities/globals/index.ts","webpack://console-mf-users-front/../../../src/utilities/graphql/directives.ts","webpack://console-mf-users-front/../../../src/utilities/graphql/fragments.ts","webpack://console-mf-users-front/../../../src/utilities/graphql/getFromAST.ts","webpack://console-mf-users-front/../../../src/utilities/graphql/storeUtils.ts","webpack://console-mf-users-front/../../../src/utilities/common/filterInPlace.ts","webpack://console-mf-users-front/../../../src/utilities/graphql/transform.ts","webpack://console-mf-users-front/./node_modules/zen-observable-ts/module.js"],"sourcesContent":["/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n","import { GraphQLRequest, Operation } from '../core';\n\nexport function createOperation(\n  starting: any,\n  operation: GraphQLRequest,\n): Operation {\n  let context = { ...starting };\n  const setContext = (next: any) => {\n    if (typeof next === 'function') {\n      context = { ...context, ...next(context) };\n    } else {\n      context = { ...context, ...next };\n    }\n  };\n  const getContext = () => ({ ...context });\n\n  Object.defineProperty(operation, 'setContext', {\n    enumerable: false,\n    value: setContext,\n  });\n\n  Object.defineProperty(operation, 'getContext', {\n    enumerable: false,\n    value: getContext,\n  });\n\n  return operation as Operation;\n}\n","import { GraphQLRequest, Operation } from '../core';\nimport { getOperationName } from '../../utilities';\n\nexport function transformOperation(operation: GraphQLRequest): GraphQLRequest {\n  const transformedOperation: GraphQLRequest = {\n    variables: operation.variables || {},\n    extensions: operation.extensions || {},\n    operationName: operation.operationName,\n    query: operation.query,\n  };\n\n  // Best guess at an operation name\n  if (!transformedOperation.operationName) {\n    transformedOperation.operationName =\n      typeof transformedOperation.query !== 'string'\n        ? getOperationName(transformedOperation.query) || undefined\n        : '';\n  }\n\n  return transformedOperation as Operation;\n}\n","import { InvariantError } from '../../utilities/globals'\nimport { GraphQLRequest } from '../core';\n\nexport function validateOperation(operation: GraphQLRequest): GraphQLRequest {\n  const OPERATION_FIELDS = [\n    'query',\n    'operationName',\n    'variables',\n    'extensions',\n    'context',\n  ];\n  for (let key of Object.keys(operation)) {\n    if (OPERATION_FIELDS.indexOf(key) < 0) {\n      throw new InvariantError(`illegal argument: ${key}`);\n    }\n  }\n\n  return operation;\n}\n","import { InvariantError, invariant } from '../../utilities/globals';\n\nimport { Observable, Observer } from '../../utilities';\nimport {\n  NextLink,\n  Operation,\n  RequestHandler,\n  FetchResult,\n  GraphQLRequest\n} from './types';\nimport {\n  validateOperation,\n  createOperation,\n  transformOperation,\n} from '../utils';\n\nfunction passthrough(op: Operation, forward: NextLink) {\n  return (forward ? forward(op) : Observable.of()) as Observable<FetchResult>;\n}\n\nfunction toLink(handler: RequestHandler | ApolloLink) {\n  return typeof handler === 'function' ? new ApolloLink(handler) : handler;\n}\n\nfunction isTerminating(link: ApolloLink): boolean {\n  return link.request.length <= 1;\n}\n\nclass LinkError extends Error {\n  public link?: ApolloLink;\n  constructor(message?: string, link?: ApolloLink) {\n    super(message);\n    this.link = link;\n  }\n}\n\nexport class ApolloLink {\n  public static empty(): ApolloLink {\n    return new ApolloLink(() => Observable.of());\n  }\n\n  public static from(links: (ApolloLink | RequestHandler)[]): ApolloLink {\n    if (links.length === 0) return ApolloLink.empty();\n    return links.map(toLink).reduce((x, y) => x.concat(y)) as ApolloLink;\n  }\n\n  public static split(\n    test: (op: Operation) => boolean,\n    left: ApolloLink | RequestHandler,\n    right?: ApolloLink | RequestHandler,\n  ): ApolloLink {\n    const leftLink = toLink(left);\n    const rightLink = toLink(right || new ApolloLink(passthrough));\n\n    if (isTerminating(leftLink) && isTerminating(rightLink)) {\n      return new ApolloLink(operation => {\n        return test(operation)\n          ? leftLink.request(operation) || Observable.of()\n          : rightLink.request(operation) || Observable.of();\n      });\n    } else {\n      return new ApolloLink((operation, forward) => {\n        return test(operation)\n          ? leftLink.request(operation, forward) || Observable.of()\n          : rightLink.request(operation, forward) || Observable.of();\n      });\n    }\n  }\n\n  public static execute(\n    link: ApolloLink,\n    operation: GraphQLRequest,\n  ): Observable<FetchResult> {\n    return (\n      link.request(\n        createOperation(\n          operation.context,\n          transformOperation(validateOperation(operation)),\n        ),\n      ) || Observable.of()\n    );\n  }\n\n  public static concat(\n    first: ApolloLink | RequestHandler,\n    second: ApolloLink | RequestHandler,\n  ) {\n    const firstLink = toLink(first);\n    if (isTerminating(firstLink)) {\n      invariant.warn(\n        new LinkError(\n          `You are calling concat on a terminating link, which will have no effect`,\n          firstLink,\n        ),\n      );\n      return firstLink;\n    }\n    const nextLink = toLink(second);\n\n    if (isTerminating(nextLink)) {\n      return new ApolloLink(\n        operation =>\n          firstLink.request(\n            operation,\n            op => nextLink.request(op) || Observable.of(),\n          ) || Observable.of(),\n      );\n    } else {\n      return new ApolloLink((operation, forward) => {\n        return (\n          firstLink.request(operation, op => {\n            return nextLink.request(op, forward) || Observable.of();\n          }) || Observable.of()\n        );\n      });\n    }\n  }\n\n  constructor(request?: RequestHandler) {\n    if (request) this.request = request;\n  }\n\n  public split(\n    test: (op: Operation) => boolean,\n    left: ApolloLink | RequestHandler,\n    right?: ApolloLink | RequestHandler,\n  ): ApolloLink {\n    return this.concat(\n      ApolloLink.split(test, left, right || new ApolloLink(passthrough))\n    );\n  }\n\n  public concat(next: ApolloLink | RequestHandler): ApolloLink {\n    return ApolloLink.concat(this, next);\n  }\n\n  public request(\n    operation: Operation,\n    forward?: NextLink,\n  ): Observable<FetchResult> | null {\n    throw new InvariantError('request is not implemented');\n  }\n\n  protected onError(\n    error: any,\n    observer?: Observer<FetchResult>,\n  ): false | void {\n    if (observer && observer.error) {\n      observer.error(error);\n      // Returning false indicates that observer.error does not need to be\n      // called again, since it was already called (on the previous line).\n      // Calling observer.error again would not cause any real problems,\n      // since only the first call matters, but custom onError functions\n      // might have other reasons for wanting to prevent the default\n      // behavior by returning false.\n      return false;\n    }\n    // Throw errors will be passed to observer.error.\n    throw error;\n  }\n\n  public setOnError(fn: ApolloLink[\"onError\"]): this {\n    this.onError = fn;\n    return this;\n  }\n}\n","export function isNonNullObject(obj: any): obj is Record<string | number, any> {\n  return obj !== null && typeof obj === 'object';\n}\n","const genericMessage = \"Invariant Violation\";\nconst {\n  setPrototypeOf = function (obj: any, proto: any) {\n    obj.__proto__ = proto;\n    return obj;\n  },\n} = Object as any;\n\nexport class InvariantError extends Error {\n  framesToPop = 1;\n  name = genericMessage;\n  constructor(message: string | number = genericMessage) {\n    super(\n      typeof message === \"number\"\n        ? `${genericMessage}: ${message} (see https://github.com/apollographql/invariant-packages)`\n        : message\n    );\n    setPrototypeOf(this, InvariantError.prototype);\n  }\n}\n\nexport function invariant(\n  condition: any,\n  message?: string | number,\n): asserts condition {\n  if (!condition) {\n    throw new InvariantError(message);\n  }\n}\n\nconst verbosityLevels = [\"debug\", \"log\", \"warn\", \"error\", \"silent\"] as const;\nexport type VerbosityLevel = (typeof verbosityLevels)[number];\nexport type ConsoleMethodName = Exclude<VerbosityLevel, \"silent\">;\nlet verbosityLevel = verbosityLevels.indexOf(\"log\");\n\nfunction wrapConsoleMethod<M extends ConsoleMethodName>(name: M) {\n  return function () {\n    if (verbosityLevels.indexOf(name) >= verbosityLevel) {\n      // Default to console.log if this host environment happens not to provide\n      // all the console.* methods we need.\n      const method = console[name] || console.log;\n      return method.apply(console, arguments as any);\n    }\n  } as (typeof console)[M];\n}\n\nexport namespace invariant {\n  export const debug = wrapConsoleMethod(\"debug\");\n  export const log = wrapConsoleMethod(\"log\");\n  export const warn = wrapConsoleMethod(\"warn\");\n  export const error = wrapConsoleMethod(\"error\");\n}\n\nexport function setVerbosity(level: VerbosityLevel): VerbosityLevel {\n  const old = verbosityLevels[verbosityLevel];\n  verbosityLevel = Math.max(0, verbosityLevels.indexOf(level));\n  return old;\n}\n\nexport default invariant;\n","export function maybe<T>(thunk: () => T): T | undefined {\n  try { return thunk() } catch {}\n}\n","import { maybe } from \"./maybe\";\n\ndeclare global {\n  // Despite our attempts to reuse the React Native __DEV__ constant instead of\n  // inventing something new and Apollo-specific, declaring a useful type for\n  // __DEV__ unfortunately conflicts (TS2451) with the global declaration in\n  // @types/react-native/index.d.ts.\n  //\n  // To hide that harmless conflict, we @ts-ignore this line, which should\n  // continue to provide a type for __DEV__ elsewhere in the Apollo Client\n  // codebase, even when @types/react-native is not in use.\n  //\n  // However, because TypeScript drops @ts-ignore comments when generating .d.ts\n  // files (https://github.com/microsoft/TypeScript/issues/38628), we also\n  // sanitize the dist/utilities/globals/global.d.ts file to avoid declaring\n  // __DEV__ globally altogether when @apollo/client is installed in the\n  // node_modules directory of an application.\n  //\n  // @ts-ignore\n  const __DEV__: boolean | undefined;\n}\n\nexport default (\n  maybe(() => globalThis) ||\n  maybe(() => window) ||\n  maybe(() => self) ||\n  maybe(() => global) ||\n  // We don't expect the Function constructor ever to be invoked at runtime, as\n  // long as at least one of globalThis, window, self, or global is defined, so\n  // we are under no obligation to make it easy for static analysis tools to\n  // detect syntactic usage of the Function constructor. If you think you can\n  // improve your static analysis to detect this obfuscation, think again. This\n  // is an arms race you cannot win, at least not in JavaScript.\n  maybe(function() { return maybe.constructor(\"return this\")() })\n) as typeof globalThis & {\n  __DEV__: typeof __DEV__;\n};\n","import global from \"./global\";\nimport { maybe } from \"./maybe\";\n\n// To keep string-based find/replace minifiers from messing with __DEV__ inside\n// string literals or properties like global.__DEV__, we construct the \"__DEV__\"\n// string in a roundabout way that won't be altered by find/replace strategies.\nconst __ = \"__\";\nconst GLOBAL_KEY = [__, __].join(\"DEV\");\n\nfunction getDEV() {\n  try {\n    return Boolean(__DEV__);\n  } catch {\n    Object.defineProperty(global, GLOBAL_KEY, {\n      // In a buildless browser environment, maybe(() => process.env.NODE_ENV)\n      // evaluates as undefined, so __DEV__ becomes true by default, but can be\n      // initialized to false instead by a script/module that runs earlier.\n      value: maybe(() => process.env.NODE_ENV) !== \"production\",\n      enumerable: false,\n      configurable: true,\n      writable: true,\n    });\n    // Using computed property access rather than global.__DEV__ here prevents\n    // string-based find/replace strategies from munging this to global.false:\n    return (global as any)[GLOBAL_KEY];\n  }\n}\n\nexport default getDEV();\n","function maybe(thunk) {\n  try { return thunk() } catch (_) {}\n}\n\nvar safeGlobal = (\n  maybe(function() { return globalThis }) ||\n  maybe(function() { return window }) ||\n  maybe(function() { return self }) ||\n  maybe(function() { return global }) ||\n  // We don't expect the Function constructor ever to be invoked at runtime, as\n  // long as at least one of globalThis, window, self, or global is defined, so\n  // we are under no obligation to make it easy for static analysis tools to\n  // detect syntactic usage of the Function constructor. If you think you can\n  // improve your static analysis to detect this obfuscation, think again. This\n  // is an arms race you cannot win, at least not in JavaScript.\n  maybe(function() { return maybe.constructor(\"return this\")() })\n);\n\nvar needToRemove = false;\n\nexport function install() {\n  if (safeGlobal &&\n      !maybe(function() { return process.env.NODE_ENV }) &&\n      !maybe(function() { return process })) {\n    Object.defineProperty(safeGlobal, \"process\", {\n      value: {\n        env: {\n          // This default needs to be \"production\" instead of \"development\", to\n          // avoid the problem https://github.com/graphql/graphql-js/pull/2894\n          // will eventually solve, once merged and released.\n          NODE_ENV: \"production\",\n        },\n      },\n      // Let anyone else change global.process as they see fit, but hide it from\n      // Object.keys(global) enumeration.\n      configurable: true,\n      enumerable: false,\n      writable: true,\n    });\n    needToRemove = true;\n  }\n}\n\n// Call install() at least once, when this module is imported.\ninstall();\n\nexport function remove() {\n  if (needToRemove) {\n    delete safeGlobal.process;\n    needToRemove = false;\n  }\n}\n","// The ordering of these imports is important, because it ensures the temporary\n// process.env.NODE_ENV polyfill is defined globally (if necessary) before we\n// import { Source } from 'graphql'. The instanceOf function that we really care\n// about (the one that uses process.env.NODE_ENV) is not exported from the\n// top-level graphql package, but graphql/language/source uses instanceOf, and\n// has relatively few dependencies, so importing it here should not increase\n// bundle sizes as much as other options.\nimport { remove } from 'ts-invariant/process';\nimport { Source } from 'graphql';\n\nexport function removeTemporaryGlobals() {\n  // Using Source here here just to make sure it won't be tree-shaken away.\n  return typeof Source === \"function\" ? remove() : remove();\n}\n","import { invariant, InvariantError } from \"ts-invariant\";\n\n// Just in case the graphql package switches from process.env.NODE_ENV to\n// __DEV__, make sure __DEV__ is polyfilled before importing graphql.\nimport DEV from \"./DEV\";\nexport { DEV }\nexport function checkDEV() {\n  invariant(\"boolean\" === typeof DEV, DEV);\n}\n\n// Import graphql/jsutils/instanceOf safely, working around its unchecked usage\n// of process.env.NODE_ENV and https://github.com/graphql/graphql-js/pull/2894.\nimport { removeTemporaryGlobals } from \"./fix-graphql\";\n\n// Synchronously undo the global process.env.NODE_ENV polyfill that we created\n// temporarily while importing the offending graphql/jsutils/instanceOf module.\nremoveTemporaryGlobals();\n\nexport { maybe } from \"./maybe\";\nexport { default as global } from \"./global\";\nexport { invariant, InvariantError }\n\n// Ensure __DEV__ was properly initialized, and prevent tree-shaking bundlers\n// from mistakenly pruning the ./DEV module (see issue #8674).\ncheckDEV();\n","import { invariant } from '../globals';\n\n// Provides the methods that allow QueryManager to handle the `skip` and\n// `include` directives within GraphQL.\nimport {\n  SelectionNode,\n  VariableNode,\n  BooleanValueNode,\n  DirectiveNode,\n  DocumentNode,\n  ArgumentNode,\n  ValueNode,\n  ASTNode,\n  visit,\n} from 'graphql';\n\nexport type DirectiveInfo = {\n  [fieldName: string]: { [argName: string]: any };\n};\n\nexport function shouldInclude(\n  { directives }: SelectionNode,\n  variables?: Record<string, any>,\n): boolean {\n  if (!directives || !directives.length) {\n    return true;\n  }\n  return getInclusionDirectives(\n    directives\n  ).every(({ directive, ifArgument }) => {\n    let evaledValue: boolean = false;\n    if (ifArgument.value.kind === 'Variable') {\n      evaledValue = variables && variables[(ifArgument.value as VariableNode).name.value];\n      invariant(\n        evaledValue !== void 0,\n        `Invalid variable referenced in @${directive.name.value} directive.`,\n      );\n    } else {\n      evaledValue = (ifArgument.value as BooleanValueNode).value;\n    }\n    return directive.name.value === 'skip' ? !evaledValue : evaledValue;\n  });\n}\n\nexport function getDirectiveNames(root: ASTNode) {\n  const names: string[] = [];\n\n  visit(root, {\n    Directive(node: DirectiveNode) {\n      names.push(node.name.value);\n    },\n  });\n\n  return names;\n}\n\nexport function hasDirectives(names: string[], root: ASTNode) {\n  return getDirectiveNames(root).some(\n    (name: string) => names.indexOf(name) > -1,\n  );\n}\n\nexport function hasClientExports(document: DocumentNode) {\n  return (\n    document &&\n    hasDirectives(['client'], document) &&\n    hasDirectives(['export'], document)\n  );\n}\n\nexport type InclusionDirectives = Array<{\n  directive: DirectiveNode;\n  ifArgument: ArgumentNode;\n}>;\n\nfunction isInclusionDirective({ name: { value } }: DirectiveNode): boolean {\n  return value === 'skip' || value === 'include';\n}\n\nexport function getInclusionDirectives(\n  directives: ReadonlyArray<DirectiveNode>,\n): InclusionDirectives {\n  const result: InclusionDirectives = [];\n\n  if (directives && directives.length) {\n    directives.forEach(directive => {\n      if (!isInclusionDirective(directive)) return;\n\n      const directiveArguments = directive.arguments;\n      const directiveName = directive.name.value;\n\n      invariant(\n        directiveArguments && directiveArguments.length === 1,\n        `Incorrect number of arguments for the @${directiveName} directive.`,\n      );\n\n      const ifArgument = directiveArguments![0];\n      invariant(\n        ifArgument.name && ifArgument.name.value === 'if',\n        `Invalid argument for the @${directiveName} directive.`,\n      );\n\n      const ifValue: ValueNode = ifArgument.value;\n\n      // means it has to be a variable value if this is a valid @skip or @include directive\n      invariant(\n        ifValue &&\n          (ifValue.kind === 'Variable' || ifValue.kind === 'BooleanValue'),\n        `Argument for the @${directiveName} directive must be a variable or a boolean value.`,\n      );\n\n      result.push({ directive, ifArgument });\n    });\n  }\n\n  return result;\n}\n\n","import { invariant, InvariantError } from '../globals';\n\nimport {\n  DocumentNode,\n  FragmentDefinitionNode,\n  InlineFragmentNode,\n  SelectionNode,\n} from 'graphql';\n\n// TODO(brian): A hack until this issue is resolved (https://github.com/graphql/graphql-js/issues/3356)\ntype Kind = any;\ntype OperationTypeNode = any;\n/**\n * Returns a query document which adds a single query operation that only\n * spreads the target fragment inside of it.\n *\n * So for example a document of:\n *\n * ```graphql\n * fragment foo on Foo { a b c }\n * ```\n *\n * Turns into:\n *\n * ```graphql\n * { ...foo }\n *\n * fragment foo on Foo { a b c }\n * ```\n *\n * The target fragment will either be the only fragment in the document, or a\n * fragment specified by the provided `fragmentName`. If there is more than one\n * fragment, but a `fragmentName` was not defined then an error will be thrown.\n */\nexport function getFragmentQueryDocument(\n  document: DocumentNode,\n  fragmentName?: string,\n): DocumentNode {\n  let actualFragmentName = fragmentName;\n\n  // Build an array of all our fragment definitions that will be used for\n  // validations. We also do some validations on the other definitions in the\n  // document while building this list.\n  const fragments: Array<FragmentDefinitionNode> = [];\n  document.definitions.forEach(definition => {\n    // Throw an error if we encounter an operation definition because we will\n    // define our own operation definition later on.\n    if (definition.kind === 'OperationDefinition') {\n      throw new InvariantError(\n        `Found a ${definition.operation} operation${\n          definition.name ? ` named '${definition.name.value}'` : ''\n        }. ` +\n          'No operations are allowed when using a fragment as a query. Only fragments are allowed.',\n      );\n    }\n    // Add our definition to the fragments array if it is a fragment\n    // definition.\n    if (definition.kind === 'FragmentDefinition') {\n      fragments.push(definition);\n    }\n  });\n\n  // If the user did not give us a fragment name then let us try to get a\n  // name from a single fragment in the definition.\n  if (typeof actualFragmentName === 'undefined') {\n    invariant(\n      fragments.length === 1,\n      `Found ${\n        fragments.length\n      } fragments. \\`fragmentName\\` must be provided when there is not exactly 1 fragment.`,\n    );\n    actualFragmentName = fragments[0].name.value;\n  }\n\n  // Generate a query document with an operation that simply spreads the\n  // fragment inside of it.\n  const query: DocumentNode = {\n    ...document,\n    definitions: [\n      {\n        kind: 'OperationDefinition' as Kind,\n        // OperationTypeNode is an enum\n        operation: 'query' as OperationTypeNode,\n        selectionSet: {\n          kind: 'SelectionSet' as Kind,\n          selections: [\n            {\n              kind: 'FragmentSpread' as Kind,\n              name: {\n                kind: 'Name' as Kind,\n                value: actualFragmentName,\n              },\n            },\n          ],\n        },\n      },\n      ...document.definitions,\n    ],\n  };\n\n  return query;\n}\n\n/**\n * This is an interface that describes a map from fragment names to fragment definitions.\n */\nexport interface FragmentMap {\n  [fragmentName: string]: FragmentDefinitionNode;\n}\n\n// Utility function that takes a list of fragment definitions and makes a hash out of them\n// that maps the name of the fragment to the fragment definition.\nexport function createFragmentMap(\n  fragments: FragmentDefinitionNode[] = [],\n): FragmentMap {\n  const symTable: FragmentMap = {};\n  fragments.forEach(fragment => {\n    symTable[fragment.name.value] = fragment;\n  });\n  return symTable;\n}\n\nexport function getFragmentFromSelection(\n  selection: SelectionNode,\n  fragmentMap?: FragmentMap,\n): InlineFragmentNode | FragmentDefinitionNode | null {\n  switch (selection.kind) {\n    case 'InlineFragment':\n      return selection;\n    case 'FragmentSpread': {\n      const fragment = fragmentMap && fragmentMap[selection.name.value];\n      invariant(fragment, `No fragment named ${selection.name.value}.`);\n      return fragment!;\n    }\n    default:\n      return null;\n  }\n}\n","import { invariant, InvariantError } from '../globals';\n\nimport {\n  DocumentNode,\n  OperationDefinitionNode,\n  FragmentDefinitionNode,\n  ValueNode,\n} from 'graphql';\n\nimport { valueToObjectRepresentation } from './storeUtils';\n\n// Checks the document for errors and throws an exception if there is an error.\nexport function checkDocument(doc: DocumentNode) {\n  invariant(\n    doc && doc.kind === 'Document',\n    `Expecting a parsed GraphQL document. Perhaps you need to wrap the query \\\nstring in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql`,\n  );\n\n  const operations = doc.definitions\n    .filter(d => d.kind !== 'FragmentDefinition')\n    .map(definition => {\n      if (definition.kind !== 'OperationDefinition') {\n        throw new InvariantError(\n          `Schema type definitions not allowed in queries. Found: \"${\n            definition.kind\n          }\"`,\n        );\n      }\n      return definition;\n    });\n\n  invariant(\n    operations.length <= 1,\n    `Ambiguous GraphQL document: contains ${operations.length} operations`,\n  );\n\n  return doc;\n}\n\nexport function getOperationDefinition(\n  doc: DocumentNode,\n): OperationDefinitionNode | undefined {\n  checkDocument(doc);\n  return doc.definitions.filter(\n    definition => definition.kind === 'OperationDefinition',\n  )[0] as OperationDefinitionNode;\n}\n\nexport function getOperationName(doc: DocumentNode): string | null {\n  return (\n    doc.definitions\n      .filter(\n        definition =>\n          definition.kind === 'OperationDefinition' && definition.name,\n      )\n      .map((x: OperationDefinitionNode) => x!.name!.value)[0] || null\n  );\n}\n\n// Returns the FragmentDefinitions from a particular document as an array\nexport function getFragmentDefinitions(\n  doc: DocumentNode,\n): FragmentDefinitionNode[] {\n  return doc.definitions.filter(\n    definition => definition.kind === 'FragmentDefinition',\n  ) as FragmentDefinitionNode[];\n}\n\nexport function getQueryDefinition(doc: DocumentNode): OperationDefinitionNode {\n  const queryDef = getOperationDefinition(doc) as OperationDefinitionNode;\n\n  invariant(\n    queryDef && queryDef.operation === 'query',\n    'Must contain a query definition.',\n  );\n\n  return queryDef;\n}\n\nexport function getFragmentDefinition(\n  doc: DocumentNode,\n): FragmentDefinitionNode {\n  invariant(\n    doc.kind === 'Document',\n    `Expecting a parsed GraphQL document. Perhaps you need to wrap the query \\\nstring in a \"gql\" tag? http://docs.apollostack.com/apollo-client/core.html#gql`,\n  );\n\n  invariant(\n    doc.definitions.length <= 1,\n    'Fragment must have exactly one definition.',\n  );\n\n  const fragmentDef = doc.definitions[0] as FragmentDefinitionNode;\n\n  invariant(\n    fragmentDef.kind === 'FragmentDefinition',\n    'Must be a fragment definition.',\n  );\n\n  return fragmentDef as FragmentDefinitionNode;\n}\n\n/**\n * Returns the first operation definition found in this document.\n * If no operation definition is found, the first fragment definition will be returned.\n * If no definitions are found, an error will be thrown.\n */\nexport function getMainDefinition(\n  queryDoc: DocumentNode,\n): OperationDefinitionNode | FragmentDefinitionNode {\n  checkDocument(queryDoc);\n\n  let fragmentDefinition;\n\n  for (let definition of queryDoc.definitions) {\n    if (definition.kind === 'OperationDefinition') {\n      const operation = (definition as OperationDefinitionNode).operation;\n      if (\n        operation === 'query' ||\n        operation === 'mutation' ||\n        operation === 'subscription'\n      ) {\n        return definition as OperationDefinitionNode;\n      }\n    }\n    if (definition.kind === 'FragmentDefinition' && !fragmentDefinition) {\n      // we do this because we want to allow multiple fragment definitions\n      // to precede an operation definition.\n      fragmentDefinition = definition as FragmentDefinitionNode;\n    }\n  }\n\n  if (fragmentDefinition) {\n    return fragmentDefinition;\n  }\n\n  throw new InvariantError(\n    'Expected a parsed GraphQL query with a query, mutation, subscription, or a fragment.',\n  );\n}\n\nexport function getDefaultValues(\n  definition: OperationDefinitionNode | undefined,\n): Record<string, any> {\n  const defaultValues = Object.create(null);\n  const defs = definition && definition.variableDefinitions;\n  if (defs && defs.length) {\n    defs.forEach(def => {\n      if (def.defaultValue) {\n        valueToObjectRepresentation(\n          defaultValues,\n          def.variable.name,\n          def.defaultValue as ValueNode,\n        );\n      }\n    });\n  }\n  return defaultValues;\n}\n","import { InvariantError } from '../globals';\n\nimport {\n  DirectiveNode,\n  FieldNode,\n  IntValueNode,\n  FloatValueNode,\n  StringValueNode,\n  BooleanValueNode,\n  ObjectValueNode,\n  ListValueNode,\n  EnumValueNode,\n  NullValueNode,\n  VariableNode,\n  InlineFragmentNode,\n  ValueNode,\n  SelectionNode,\n  NameNode,\n  SelectionSetNode,\n  DocumentNode,\n} from 'graphql';\n\nimport { isNonNullObject } from '../common/objects';\nimport { FragmentMap, getFragmentFromSelection } from './fragments';\n\nexport interface Reference {\n  readonly __ref: string;\n}\n\nexport function makeReference(id: string): Reference {\n  return { __ref: String(id) };\n}\n\nexport function isReference(obj: any): obj is Reference {\n  return Boolean(obj && typeof obj === 'object' && typeof obj.__ref === 'string');\n}\n\nexport type StoreValue =\n  | number\n  | string\n  | string[]\n  | Reference\n  | Reference[]\n  | null\n  | undefined\n  | void\n  | Object;\n\nexport interface StoreObject {\n  __typename?: string;\n  [storeFieldName: string]: StoreValue;\n}\n\nexport function isDocumentNode(value: any): value is DocumentNode {\n  return (\n    isNonNullObject(value) &&\n    (value as DocumentNode).kind === \"Document\" &&\n    Array.isArray((value as DocumentNode).definitions)\n  );\n}\n\nfunction isStringValue(value: ValueNode): value is StringValueNode {\n  return value.kind === 'StringValue';\n}\n\nfunction isBooleanValue(value: ValueNode): value is BooleanValueNode {\n  return value.kind === 'BooleanValue';\n}\n\nfunction isIntValue(value: ValueNode): value is IntValueNode {\n  return value.kind === 'IntValue';\n}\n\nfunction isFloatValue(value: ValueNode): value is FloatValueNode {\n  return value.kind === 'FloatValue';\n}\n\nfunction isVariable(value: ValueNode): value is VariableNode {\n  return value.kind === 'Variable';\n}\n\nfunction isObjectValue(value: ValueNode): value is ObjectValueNode {\n  return value.kind === 'ObjectValue';\n}\n\nfunction isListValue(value: ValueNode): value is ListValueNode {\n  return value.kind === 'ListValue';\n}\n\nfunction isEnumValue(value: ValueNode): value is EnumValueNode {\n  return value.kind === 'EnumValue';\n}\n\nfunction isNullValue(value: ValueNode): value is NullValueNode {\n  return value.kind === 'NullValue';\n}\n\nexport function valueToObjectRepresentation(\n  argObj: any,\n  name: NameNode,\n  value: ValueNode,\n  variables?: Object,\n) {\n  if (isIntValue(value) || isFloatValue(value)) {\n    argObj[name.value] = Number(value.value);\n  } else if (isBooleanValue(value) || isStringValue(value)) {\n    argObj[name.value] = value.value;\n  } else if (isObjectValue(value)) {\n    const nestedArgObj = {};\n    value.fields.map(obj =>\n      valueToObjectRepresentation(nestedArgObj, obj.name, obj.value, variables),\n    );\n    argObj[name.value] = nestedArgObj;\n  } else if (isVariable(value)) {\n    const variableValue = (variables || ({} as any))[value.name.value];\n    argObj[name.value] = variableValue;\n  } else if (isListValue(value)) {\n    argObj[name.value] = value.values.map(listValue => {\n      const nestedArgArrayObj = {};\n      valueToObjectRepresentation(\n        nestedArgArrayObj,\n        name,\n        listValue,\n        variables,\n      );\n      return (nestedArgArrayObj as any)[name.value];\n    });\n  } else if (isEnumValue(value)) {\n    argObj[name.value] = (value as EnumValueNode).value;\n  } else if (isNullValue(value)) {\n    argObj[name.value] = null;\n  } else {\n    throw new InvariantError(\n      `The inline argument \"${name.value}\" of kind \"${(value as any).kind}\"` +\n        'is not supported. Use variables instead of inline arguments to ' +\n        'overcome this limitation.',\n    );\n  }\n}\n\nexport function storeKeyNameFromField(\n  field: FieldNode,\n  variables?: Object,\n): string {\n  let directivesObj: any = null;\n  if (field.directives) {\n    directivesObj = {};\n    field.directives.forEach(directive => {\n      directivesObj[directive.name.value] = {};\n\n      if (directive.arguments) {\n        directive.arguments.forEach(({ name, value }) =>\n          valueToObjectRepresentation(\n            directivesObj[directive.name.value],\n            name,\n            value,\n            variables,\n          ),\n        );\n      }\n    });\n  }\n\n  let argObj: any = null;\n  if (field.arguments && field.arguments.length) {\n    argObj = {};\n    field.arguments.forEach(({ name, value }) =>\n      valueToObjectRepresentation(argObj, name, value, variables),\n    );\n  }\n\n  return getStoreKeyName(field.name.value, argObj, directivesObj);\n}\n\nexport type Directives = {\n  [directiveName: string]: {\n    [argName: string]: any;\n  };\n};\n\nconst KNOWN_DIRECTIVES: string[] = [\n  'connection',\n  'include',\n  'skip',\n  'client',\n  'rest',\n  'export',\n];\n\nexport const getStoreKeyName = Object.assign(function (\n  fieldName: string,\n  args?: Record<string, any> | null,\n  directives?: Directives,\n): string {\n  if (\n    args &&\n    directives &&\n    directives['connection'] &&\n    directives['connection']['key']\n  ) {\n    if (\n      directives['connection']['filter'] &&\n      (directives['connection']['filter'] as string[]).length > 0\n    ) {\n      const filterKeys = directives['connection']['filter']\n        ? (directives['connection']['filter'] as string[])\n        : [];\n      filterKeys.sort();\n\n      const filteredArgs = {} as { [key: string]: any };\n      filterKeys.forEach(key => {\n        filteredArgs[key] = args[key];\n      });\n\n      return `${directives['connection']['key']}(${stringify(\n        filteredArgs,\n      )})`;\n    } else {\n      return directives['connection']['key'];\n    }\n  }\n\n  let completeFieldName: string = fieldName;\n\n  if (args) {\n    // We can't use `JSON.stringify` here since it's non-deterministic,\n    // and can lead to different store key names being created even though\n    // the `args` object used during creation has the same properties/values.\n    const stringifiedArgs: string = stringify(args);\n    completeFieldName += `(${stringifiedArgs})`;\n  }\n\n  if (directives) {\n    Object.keys(directives).forEach(key => {\n      if (KNOWN_DIRECTIVES.indexOf(key) !== -1) return;\n      if (directives[key] && Object.keys(directives[key]).length) {\n        completeFieldName += `@${key}(${stringify(directives[key])})`;\n      } else {\n        completeFieldName += `@${key}`;\n      }\n    });\n  }\n\n  return completeFieldName;\n}, {\n  setStringify(s: typeof stringify) {\n    const previous = stringify;\n    stringify = s;\n    return previous;\n  },\n});\n\n// Default stable JSON.stringify implementation. Can be updated/replaced with\n// something better by calling getStoreKeyName.setStringify.\nlet stringify = function defaultStringify(value: any): string {\n  return JSON.stringify(value, stringifyReplacer);\n};\n\nfunction stringifyReplacer(_key: string, value: any): any {\n  if (isNonNullObject(value) && !Array.isArray(value)) {\n    value = Object.keys(value).sort().reduce((copy, key) => {\n      copy[key] = value[key];\n      return copy;\n    }, {} as Record<string, any>);\n  }\n  return value;\n}\n\nexport function argumentsObjectFromField(\n  field: FieldNode | DirectiveNode,\n  variables?: Record<string, any>,\n): Object | null {\n  if (field.arguments && field.arguments.length) {\n    const argObj: Object = {};\n    field.arguments.forEach(({ name, value }) =>\n      valueToObjectRepresentation(argObj, name, value, variables),\n    );\n    return argObj;\n  }\n  return null;\n}\n\nexport function resultKeyNameFromField(field: FieldNode): string {\n  return field.alias ? field.alias.value : field.name.value;\n}\n\nexport function getTypenameFromResult(\n  result: Record<string, any>,\n  selectionSet: SelectionSetNode,\n  fragmentMap?: FragmentMap,\n): string | undefined {\n  if (typeof result.__typename === 'string') {\n    return result.__typename;\n  }\n\n  for (const selection of selectionSet.selections) {\n    if (isField(selection)) {\n      if (selection.name.value === '__typename') {\n        return result[resultKeyNameFromField(selection)];\n      }\n    } else {\n      const typename = getTypenameFromResult(\n        result,\n        getFragmentFromSelection(selection, fragmentMap)!.selectionSet,\n        fragmentMap,\n      );\n      if (typeof typename === 'string') {\n        return typename;\n      }\n    }\n  }\n}\n\nexport function isField(selection: SelectionNode): selection is FieldNode {\n  return selection.kind === 'Field';\n}\n\nexport function isInlineFragment(\n  selection: SelectionNode,\n): selection is InlineFragmentNode {\n  return selection.kind === 'InlineFragment';\n}\n\nexport type VariableValue = (node: VariableNode) => any;\n","export function filterInPlace<T>(\n  array: T[],\n  test: (elem: T) => boolean,\n  context?: any,\n): T[] {\n  let target = 0;\n  array.forEach(function (elem, i) {\n    if (test.call(this, elem, i, array)) {\n      array[target++] = elem;\n    }\n  }, context);\n  array.length = target;\n  return array;\n}\n","import { invariant } from '../globals';\n\nimport {\n  DocumentNode,\n  SelectionNode,\n  SelectionSetNode,\n  OperationDefinitionNode,\n  FieldNode,\n  DirectiveNode,\n  FragmentDefinitionNode,\n  ArgumentNode,\n  FragmentSpreadNode,\n  VariableDefinitionNode,\n  VariableNode,\n  visit,\n  ASTNode,\n} from 'graphql';\n\n// TODO(brian): A hack until this issue is resolved (https://github.com/graphql/graphql-js/issues/3356)\ntype Kind = any;\n\nimport {\n  checkDocument,\n  getOperationDefinition,\n  getFragmentDefinition,\n  getFragmentDefinitions,\n  getMainDefinition,\n} from './getFromAST';\nimport { filterInPlace } from '../common/filterInPlace';\nimport { isField, isInlineFragment } from './storeUtils';\nimport {\n  createFragmentMap,\n  FragmentMap,\n} from './fragments';\n\nexport type RemoveNodeConfig<N> = {\n  name?: string;\n  test?: (node: N) => boolean;\n  remove?: boolean;\n};\n\nexport type GetNodeConfig<N> = {\n  name?: string;\n  test?: (node: N) => boolean;\n};\n\nexport type RemoveDirectiveConfig = RemoveNodeConfig<DirectiveNode>;\nexport type GetDirectiveConfig = GetNodeConfig<DirectiveNode>;\nexport type RemoveArgumentsConfig = RemoveNodeConfig<ArgumentNode>;\nexport type GetFragmentSpreadConfig = GetNodeConfig<FragmentSpreadNode>;\nexport type RemoveFragmentSpreadConfig = RemoveNodeConfig<FragmentSpreadNode>;\nexport type RemoveFragmentDefinitionConfig = RemoveNodeConfig<\n  FragmentDefinitionNode\n>;\nexport type RemoveVariableDefinitionConfig = RemoveNodeConfig<\n  VariableDefinitionNode\n>;\n\nconst TYPENAME_FIELD: FieldNode = {\n  kind: 'Field' as Kind,\n  name: {\n    kind: 'Name' as Kind,\n    value: '__typename',\n  },\n};\n\nfunction isEmpty(\n  op: OperationDefinitionNode | FragmentDefinitionNode,\n  fragments: FragmentMap,\n): boolean {\n  return op.selectionSet.selections.every(\n    selection =>\n      selection.kind === 'FragmentSpread' &&\n      isEmpty(fragments[selection.name.value], fragments),\n  );\n}\n\nfunction nullIfDocIsEmpty(doc: DocumentNode) {\n  return isEmpty(\n    getOperationDefinition(doc) || getFragmentDefinition(doc),\n    createFragmentMap(getFragmentDefinitions(doc)),\n  )\n    ? null\n    : doc;\n}\n\nfunction getDirectiveMatcher(\n  directives: (RemoveDirectiveConfig | GetDirectiveConfig)[],\n) {\n  return function directiveMatcher(directive: DirectiveNode) {\n    return directives.some(\n      dir =>\n        (dir.name && dir.name === directive.name.value) ||\n        (dir.test && dir.test(directive)),\n    );\n  };\n}\n\nexport function removeDirectivesFromDocument(\n  directives: RemoveDirectiveConfig[],\n  doc: DocumentNode,\n): DocumentNode | null {\n  const variablesInUse: Record<string, boolean> = Object.create(null);\n  let variablesToRemove: RemoveArgumentsConfig[] = [];\n\n  const fragmentSpreadsInUse: Record<string, boolean> = Object.create(null);\n  let fragmentSpreadsToRemove: RemoveFragmentSpreadConfig[] = [];\n\n  let modifiedDoc = nullIfDocIsEmpty(\n    visit(doc, {\n      Variable: {\n        enter(node, _key, parent) {\n          // Store each variable that's referenced as part of an argument\n          // (excluding operation definition variables), so we know which\n          // variables are being used. If we later want to remove a variable\n          // we'll first check to see if it's being used, before continuing with\n          // the removal.\n          if (\n            (parent as VariableDefinitionNode).kind !== 'VariableDefinition'\n          ) {\n            variablesInUse[node.name.value] = true;\n          }\n        },\n      },\n\n      Field: {\n        enter(node) {\n          if (directives && node.directives) {\n            // If `remove` is set to true for a directive, and a directive match\n            // is found for a field, remove the field as well.\n            const shouldRemoveField = directives.some(\n              directive => directive.remove,\n            );\n\n            if (\n              shouldRemoveField &&\n              node.directives &&\n              node.directives.some(getDirectiveMatcher(directives))\n            ) {\n              if (node.arguments) {\n                // Store field argument variables so they can be removed\n                // from the operation definition.\n                node.arguments.forEach(arg => {\n                  if (arg.value.kind === 'Variable') {\n                    variablesToRemove.push({\n                      name: (arg.value as VariableNode).name.value,\n                    });\n                  }\n                });\n              }\n\n              if (node.selectionSet) {\n                // Store fragment spread names so they can be removed from the\n                // document.\n                getAllFragmentSpreadsFromSelectionSet(node.selectionSet).forEach(\n                  frag => {\n                    fragmentSpreadsToRemove.push({\n                      name: frag.name.value,\n                    });\n                  },\n                );\n              }\n\n              // Remove the field.\n              return null;\n            }\n          }\n        },\n      },\n\n      FragmentSpread: {\n        enter(node) {\n          // Keep track of referenced fragment spreads. This is used to\n          // determine if top level fragment definitions should be removed.\n          fragmentSpreadsInUse[node.name.value] = true;\n        },\n      },\n\n      Directive: {\n        enter(node) {\n          // If a matching directive is found, remove it.\n          if (getDirectiveMatcher(directives)(node)) {\n            return null;\n          }\n        },\n      },\n    }),\n  );\n\n  // If we've removed fields with arguments, make sure the associated\n  // variables are also removed from the rest of the document, as long as they\n  // aren't being used elsewhere.\n  if (\n    modifiedDoc &&\n    filterInPlace(variablesToRemove, v => !!v.name && !variablesInUse[v.name]).length\n  ) {\n    modifiedDoc = removeArgumentsFromDocument(variablesToRemove, modifiedDoc);\n  }\n\n  // If we've removed selection sets with fragment spreads, make sure the\n  // associated fragment definitions are also removed from the rest of the\n  // document, as long as they aren't being used elsewhere.\n  if (\n    modifiedDoc &&\n    filterInPlace(fragmentSpreadsToRemove, fs => !!fs.name && !fragmentSpreadsInUse[fs.name])\n      .length\n  ) {\n    modifiedDoc = removeFragmentSpreadFromDocument(\n      fragmentSpreadsToRemove,\n      modifiedDoc,\n    );\n  }\n\n  return modifiedDoc;\n}\n\nexport const addTypenameToDocument = Object.assign(function <\n  TNode extends ASTNode\n>(\n  doc: TNode\n): TNode {\n  return visit(doc, {\n    SelectionSet: {\n      enter(node, _key, parent) {\n        // Don't add __typename to OperationDefinitions.\n        if (\n          parent &&\n          (parent as OperationDefinitionNode).kind === 'OperationDefinition'\n        ) {\n          return;\n        }\n\n        // No changes if no selections.\n        const { selections } = node;\n        if (!selections) {\n          return;\n        }\n\n        // If selections already have a __typename, or are part of an\n        // introspection query, do nothing.\n        const skip = selections.some(selection => {\n          return (\n            isField(selection) &&\n            (selection.name.value === '__typename' ||\n              selection.name.value.lastIndexOf('__', 0) === 0)\n          );\n        });\n        if (skip) {\n          return;\n        }\n\n        // If this SelectionSet is @export-ed as an input variable, it should\n        // not have a __typename field (see issue #4691).\n        const field = parent as FieldNode;\n        if (\n          isField(field) &&\n          field.directives &&\n          field.directives.some(d => d.name.value === 'export')\n        ) {\n          return;\n        }\n\n        // Create and return a new SelectionSet with a __typename Field.\n        return {\n          ...node,\n          selections: [...selections, TYPENAME_FIELD],\n        };\n      },\n    },\n  });\n}, {\n  added(field: FieldNode): boolean {\n    return field === TYPENAME_FIELD;\n  },\n});\n\nconst connectionRemoveConfig = {\n  test: (directive: DirectiveNode) => {\n    const willRemove = directive.name.value === 'connection';\n    if (willRemove) {\n      if (\n        !directive.arguments ||\n        !directive.arguments.some(arg => arg.name.value === 'key')\n      ) {\n        invariant.warn(\n          'Removing an @connection directive even though it does not have a key. ' +\n            'You may want to use the key parameter to specify a store key.',\n        );\n      }\n    }\n\n    return willRemove;\n  },\n};\n\nexport function removeConnectionDirectiveFromDocument(doc: DocumentNode) {\n  return removeDirectivesFromDocument(\n    [connectionRemoveConfig],\n    checkDocument(doc),\n  );\n}\n\nfunction hasDirectivesInSelectionSet(\n  directives: GetDirectiveConfig[],\n  selectionSet: SelectionSetNode | undefined,\n  nestedCheck = true,\n): boolean {\n  return (\n    !!selectionSet &&\n    selectionSet.selections &&\n    selectionSet.selections.some(selection =>\n      hasDirectivesInSelection(directives, selection, nestedCheck),\n    )\n  );\n}\n\nfunction hasDirectivesInSelection(\n  directives: GetDirectiveConfig[],\n  selection: SelectionNode,\n  nestedCheck = true,\n): boolean {\n  if (!isField(selection)) {\n    return true;\n  }\n\n  if (!selection.directives) {\n    return false;\n  }\n\n  return (\n    selection.directives.some(getDirectiveMatcher(directives)) ||\n    (nestedCheck &&\n      hasDirectivesInSelectionSet(\n        directives,\n        selection.selectionSet,\n        nestedCheck,\n      ))\n  );\n}\n\nfunction getArgumentMatcher(config: RemoveArgumentsConfig[]) {\n  return function argumentMatcher(argument: ArgumentNode) {\n    return config.some(\n      (aConfig: RemoveArgumentsConfig) =>\n        argument.value &&\n        argument.value.kind === 'Variable' &&\n        argument.value.name &&\n        (aConfig.name === argument.value.name.value ||\n          (aConfig.test && aConfig.test(argument))),\n    );\n  };\n}\n\nexport function removeArgumentsFromDocument(\n  config: RemoveArgumentsConfig[],\n  doc: DocumentNode,\n): DocumentNode | null {\n  const argMatcher = getArgumentMatcher(config);\n\n  return nullIfDocIsEmpty(\n    visit(doc, {\n      OperationDefinition: {\n        enter(node) {\n          return {\n            ...node,\n            // Remove matching top level variables definitions.\n            variableDefinitions: node.variableDefinitions ? node.variableDefinitions.filter(\n              varDef =>\n                !config.some(arg => arg.name === varDef.variable.name.value),\n            ) : [],\n          };\n        },\n      },\n\n      Field: {\n        enter(node) {\n          // If `remove` is set to true for an argument, and an argument match\n          // is found for a field, remove the field as well.\n          const shouldRemoveField = config.some(argConfig => argConfig.remove);\n\n          if (shouldRemoveField) {\n            let argMatchCount = 0;\n            if (node.arguments) {\n              node.arguments.forEach(arg => {\n                if (argMatcher(arg)) {\n                  argMatchCount += 1;\n                }\n              });\n            }\n\n            if (argMatchCount === 1) {\n              return null;\n            }\n          }\n        },\n      },\n\n      Argument: {\n        enter(node) {\n          // Remove all matching arguments.\n          if (argMatcher(node)) {\n            return null;\n          }\n        },\n      },\n    }),\n  );\n}\n\nexport function removeFragmentSpreadFromDocument(\n  config: RemoveFragmentSpreadConfig[],\n  doc: DocumentNode,\n): DocumentNode | null {\n  function enter(\n    node: FragmentSpreadNode | FragmentDefinitionNode,\n  ): null | void {\n    if (config.some(def => def.name === node.name.value)) {\n      return null;\n    }\n  }\n\n  return nullIfDocIsEmpty(\n    visit(doc, {\n      FragmentSpread: { enter },\n      FragmentDefinition: { enter },\n    }),\n  );\n}\n\nfunction getAllFragmentSpreadsFromSelectionSet(\n  selectionSet: SelectionSetNode,\n): FragmentSpreadNode[] {\n  const allFragments: FragmentSpreadNode[] = [];\n\n  selectionSet.selections.forEach(selection => {\n    if (\n      (isField(selection) || isInlineFragment(selection)) &&\n      selection.selectionSet\n    ) {\n      getAllFragmentSpreadsFromSelectionSet(selection.selectionSet).forEach(\n        frag => allFragments.push(frag),\n      );\n    } else if (selection.kind === 'FragmentSpread') {\n      allFragments.push(selection);\n    }\n  });\n\n  return allFragments;\n}\n\n// If the incoming document is a query, return it as is. Otherwise, build a\n// new document containing a query operation based on the selection set\n// of the previous main operation.\nexport function buildQueryFromSelectionSet(\n  document: DocumentNode,\n): DocumentNode {\n  const definition = getMainDefinition(document);\n  const definitionOperation = (<OperationDefinitionNode>definition).operation;\n\n  if (definitionOperation === 'query') {\n    // Already a query, so return the existing document.\n    return document;\n  }\n\n  // Build a new query using the selection set of the main operation.\n  const modifiedDoc = visit(document, {\n    OperationDefinition: {\n      enter(node) {\n        return {\n          ...node,\n          operation: 'query',\n        };\n      },\n    },\n  });\n  return modifiedDoc;\n}\n\n// Remove fields / selection sets that include an @client directive.\nexport function removeClientSetsFromDocument(\n  document: DocumentNode,\n): DocumentNode | null {\n  checkDocument(document);\n\n  let modifiedDoc = removeDirectivesFromDocument(\n    [\n      {\n        test: (directive: DirectiveNode) => directive.name.value === 'client',\n        remove: true,\n      },\n    ],\n    document,\n  );\n\n  // After a fragment definition has had its @client related document\n  // sets removed, if the only field it has left is a __typename field,\n  // remove the entire fragment operation to prevent it from being fired\n  // on the server.\n  if (modifiedDoc) {\n    modifiedDoc = visit(modifiedDoc, {\n      FragmentDefinition: {\n        enter(node) {\n          if (node.selectionSet) {\n            const isTypenameOnly = node.selectionSet.selections.every(\n              selection =>\n                isField(selection) && selection.name.value === '__typename',\n            );\n            if (isTypenameOnly) {\n              return null;\n            }\n          }\n        },\n      },\n    });\n  }\n\n  return modifiedDoc;\n}\n","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.\"); }\n\nfunction _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); }\n\nfunction _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; }\n\nfunction _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); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n// === Symbol Support ===\nvar hasSymbols = function () {\n  return typeof Symbol === 'function';\n};\n\nvar hasSymbol = function (name) {\n  return hasSymbols() && Boolean(Symbol[name]);\n};\n\nvar getSymbol = function (name) {\n  return hasSymbol(name) ? Symbol[name] : '@@' + name;\n};\n\nif (hasSymbols() && !hasSymbol('observable')) {\n  Symbol.observable = Symbol('observable');\n}\n\nvar SymbolIterator = getSymbol('iterator');\nvar SymbolObservable = getSymbol('observable');\nvar SymbolSpecies = getSymbol('species'); // === Abstract Operations ===\n\nfunction getMethod(obj, key) {\n  var value = obj[key];\n  if (value == null) return undefined;\n  if (typeof value !== 'function') throw new TypeError(value + ' is not a function');\n  return value;\n}\n\nfunction getSpecies(obj) {\n  var ctor = obj.constructor;\n\n  if (ctor !== undefined) {\n    ctor = ctor[SymbolSpecies];\n\n    if (ctor === null) {\n      ctor = undefined;\n    }\n  }\n\n  return ctor !== undefined ? ctor : Observable;\n}\n\nfunction isObservable(x) {\n  return x instanceof Observable; // SPEC: Brand check\n}\n\nfunction hostReportError(e) {\n  if (hostReportError.log) {\n    hostReportError.log(e);\n  } else {\n    setTimeout(function () {\n      throw e;\n    });\n  }\n}\n\nfunction enqueue(fn) {\n  Promise.resolve().then(function () {\n    try {\n      fn();\n    } catch (e) {\n      hostReportError(e);\n    }\n  });\n}\n\nfunction cleanupSubscription(subscription) {\n  var cleanup = subscription._cleanup;\n  if (cleanup === undefined) return;\n  subscription._cleanup = undefined;\n\n  if (!cleanup) {\n    return;\n  }\n\n  try {\n    if (typeof cleanup === 'function') {\n      cleanup();\n    } else {\n      var unsubscribe = getMethod(cleanup, 'unsubscribe');\n\n      if (unsubscribe) {\n        unsubscribe.call(cleanup);\n      }\n    }\n  } catch (e) {\n    hostReportError(e);\n  }\n}\n\nfunction closeSubscription(subscription) {\n  subscription._observer = undefined;\n  subscription._queue = undefined;\n  subscription._state = 'closed';\n}\n\nfunction flushSubscription(subscription) {\n  var queue = subscription._queue;\n\n  if (!queue) {\n    return;\n  }\n\n  subscription._queue = undefined;\n  subscription._state = 'ready';\n\n  for (var i = 0; i < queue.length; ++i) {\n    notifySubscription(subscription, queue[i].type, queue[i].value);\n    if (subscription._state === 'closed') break;\n  }\n}\n\nfunction notifySubscription(subscription, type, value) {\n  subscription._state = 'running';\n  var observer = subscription._observer;\n\n  try {\n    var m = getMethod(observer, type);\n\n    switch (type) {\n      case 'next':\n        if (m) m.call(observer, value);\n        break;\n\n      case 'error':\n        closeSubscription(subscription);\n        if (m) m.call(observer, value);else throw value;\n        break;\n\n      case 'complete':\n        closeSubscription(subscription);\n        if (m) m.call(observer);\n        break;\n    }\n  } catch (e) {\n    hostReportError(e);\n  }\n\n  if (subscription._state === 'closed') cleanupSubscription(subscription);else if (subscription._state === 'running') subscription._state = 'ready';\n}\n\nfunction onNotify(subscription, type, value) {\n  if (subscription._state === 'closed') return;\n\n  if (subscription._state === 'buffering') {\n    subscription._queue.push({\n      type: type,\n      value: value\n    });\n\n    return;\n  }\n\n  if (subscription._state !== 'ready') {\n    subscription._state = 'buffering';\n    subscription._queue = [{\n      type: type,\n      value: value\n    }];\n    enqueue(function () {\n      return flushSubscription(subscription);\n    });\n    return;\n  }\n\n  notifySubscription(subscription, type, value);\n}\n\nvar Subscription = /*#__PURE__*/function () {\n  function Subscription(observer, subscriber) {\n    // ASSERT: observer is an object\n    // ASSERT: subscriber is callable\n    this._cleanup = undefined;\n    this._observer = observer;\n    this._queue = undefined;\n    this._state = 'initializing';\n    var subscriptionObserver = new SubscriptionObserver(this);\n\n    try {\n      this._cleanup = subscriber.call(undefined, subscriptionObserver);\n    } catch (e) {\n      subscriptionObserver.error(e);\n    }\n\n    if (this._state === 'initializing') this._state = 'ready';\n  }\n\n  var _proto = Subscription.prototype;\n\n  _proto.unsubscribe = function unsubscribe() {\n    if (this._state !== 'closed') {\n      closeSubscription(this);\n      cleanupSubscription(this);\n    }\n  };\n\n  _createClass(Subscription, [{\n    key: \"closed\",\n    get: function () {\n      return this._state === 'closed';\n    }\n  }]);\n\n  return Subscription;\n}();\n\nvar SubscriptionObserver = /*#__PURE__*/function () {\n  function SubscriptionObserver(subscription) {\n    this._subscription = subscription;\n  }\n\n  var _proto2 = SubscriptionObserver.prototype;\n\n  _proto2.next = function next(value) {\n    onNotify(this._subscription, 'next', value);\n  };\n\n  _proto2.error = function error(value) {\n    onNotify(this._subscription, 'error', value);\n  };\n\n  _proto2.complete = function complete() {\n    onNotify(this._subscription, 'complete');\n  };\n\n  _createClass(SubscriptionObserver, [{\n    key: \"closed\",\n    get: function () {\n      return this._subscription._state === 'closed';\n    }\n  }]);\n\n  return SubscriptionObserver;\n}();\n\nvar Observable = /*#__PURE__*/function () {\n  function Observable(subscriber) {\n    if (!(this instanceof Observable)) throw new TypeError('Observable cannot be called as a function');\n    if (typeof subscriber !== 'function') throw new TypeError('Observable initializer must be a function');\n    this._subscriber = subscriber;\n  }\n\n  var _proto3 = Observable.prototype;\n\n  _proto3.subscribe = function subscribe(observer) {\n    if (typeof observer !== 'object' || observer === null) {\n      observer = {\n        next: observer,\n        error: arguments[1],\n        complete: arguments[2]\n      };\n    }\n\n    return new Subscription(observer, this._subscriber);\n  };\n\n  _proto3.forEach = function forEach(fn) {\n    var _this = this;\n\n    return new Promise(function (resolve, reject) {\n      if (typeof fn !== 'function') {\n        reject(new TypeError(fn + ' is not a function'));\n        return;\n      }\n\n      function done() {\n        subscription.unsubscribe();\n        resolve();\n      }\n\n      var subscription = _this.subscribe({\n        next: function (value) {\n          try {\n            fn(value, done);\n          } catch (e) {\n            reject(e);\n            subscription.unsubscribe();\n          }\n        },\n        error: reject,\n        complete: resolve\n      });\n    });\n  };\n\n  _proto3.map = function map(fn) {\n    var _this2 = this;\n\n    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n    var C = getSpecies(this);\n    return new C(function (observer) {\n      return _this2.subscribe({\n        next: function (value) {\n          try {\n            value = fn(value);\n          } catch (e) {\n            return observer.error(e);\n          }\n\n          observer.next(value);\n        },\n        error: function (e) {\n          observer.error(e);\n        },\n        complete: function () {\n          observer.complete();\n        }\n      });\n    });\n  };\n\n  _proto3.filter = function filter(fn) {\n    var _this3 = this;\n\n    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n    var C = getSpecies(this);\n    return new C(function (observer) {\n      return _this3.subscribe({\n        next: function (value) {\n          try {\n            if (!fn(value)) return;\n          } catch (e) {\n            return observer.error(e);\n          }\n\n          observer.next(value);\n        },\n        error: function (e) {\n          observer.error(e);\n        },\n        complete: function () {\n          observer.complete();\n        }\n      });\n    });\n  };\n\n  _proto3.reduce = function reduce(fn) {\n    var _this4 = this;\n\n    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n    var C = getSpecies(this);\n    var hasSeed = arguments.length > 1;\n    var hasValue = false;\n    var seed = arguments[1];\n    var acc = seed;\n    return new C(function (observer) {\n      return _this4.subscribe({\n        next: function (value) {\n          var first = !hasValue;\n          hasValue = true;\n\n          if (!first || hasSeed) {\n            try {\n              acc = fn(acc, value);\n            } catch (e) {\n              return observer.error(e);\n            }\n          } else {\n            acc = value;\n          }\n        },\n        error: function (e) {\n          observer.error(e);\n        },\n        complete: function () {\n          if (!hasValue && !hasSeed) return observer.error(new TypeError('Cannot reduce an empty sequence'));\n          observer.next(acc);\n          observer.complete();\n        }\n      });\n    });\n  };\n\n  _proto3.concat = function concat() {\n    var _this5 = this;\n\n    for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {\n      sources[_key] = arguments[_key];\n    }\n\n    var C = getSpecies(this);\n    return new C(function (observer) {\n      var subscription;\n      var index = 0;\n\n      function startNext(next) {\n        subscription = next.subscribe({\n          next: function (v) {\n            observer.next(v);\n          },\n          error: function (e) {\n            observer.error(e);\n          },\n          complete: function () {\n            if (index === sources.length) {\n              subscription = undefined;\n              observer.complete();\n            } else {\n              startNext(C.from(sources[index++]));\n            }\n          }\n        });\n      }\n\n      startNext(_this5);\n      return function () {\n        if (subscription) {\n          subscription.unsubscribe();\n          subscription = undefined;\n        }\n      };\n    });\n  };\n\n  _proto3.flatMap = function flatMap(fn) {\n    var _this6 = this;\n\n    if (typeof fn !== 'function') throw new TypeError(fn + ' is not a function');\n    var C = getSpecies(this);\n    return new C(function (observer) {\n      var subscriptions = [];\n\n      var outer = _this6.subscribe({\n        next: function (value) {\n          if (fn) {\n            try {\n              value = fn(value);\n            } catch (e) {\n              return observer.error(e);\n            }\n          }\n\n          var inner = C.from(value).subscribe({\n            next: function (value) {\n              observer.next(value);\n            },\n            error: function (e) {\n              observer.error(e);\n            },\n            complete: function () {\n              var i = subscriptions.indexOf(inner);\n              if (i >= 0) subscriptions.splice(i, 1);\n              completeIfDone();\n            }\n          });\n          subscriptions.push(inner);\n        },\n        error: function (e) {\n          observer.error(e);\n        },\n        complete: function () {\n          completeIfDone();\n        }\n      });\n\n      function completeIfDone() {\n        if (outer.closed && subscriptions.length === 0) observer.complete();\n      }\n\n      return function () {\n        subscriptions.forEach(function (s) {\n          return s.unsubscribe();\n        });\n        outer.unsubscribe();\n      };\n    });\n  };\n\n  _proto3[SymbolObservable] = function () {\n    return this;\n  };\n\n  Observable.from = function from(x) {\n    var C = typeof this === 'function' ? this : Observable;\n    if (x == null) throw new TypeError(x + ' is not an object');\n    var method = getMethod(x, SymbolObservable);\n\n    if (method) {\n      var observable = method.call(x);\n      if (Object(observable) !== observable) throw new TypeError(observable + ' is not an object');\n      if (isObservable(observable) && observable.constructor === C) return observable;\n      return new C(function (observer) {\n        return observable.subscribe(observer);\n      });\n    }\n\n    if (hasSymbol('iterator')) {\n      method = getMethod(x, SymbolIterator);\n\n      if (method) {\n        return new C(function (observer) {\n          enqueue(function () {\n            if (observer.closed) return;\n\n            for (var _iterator = _createForOfIteratorHelperLoose(method.call(x)), _step; !(_step = _iterator()).done;) {\n              var item = _step.value;\n              observer.next(item);\n              if (observer.closed) return;\n            }\n\n            observer.complete();\n          });\n        });\n      }\n    }\n\n    if (Array.isArray(x)) {\n      return new C(function (observer) {\n        enqueue(function () {\n          if (observer.closed) return;\n\n          for (var i = 0; i < x.length; ++i) {\n            observer.next(x[i]);\n            if (observer.closed) return;\n          }\n\n          observer.complete();\n        });\n      });\n    }\n\n    throw new TypeError(x + ' is not observable');\n  };\n\n  Observable.of = function of() {\n    for (var _len2 = arguments.length, items = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n      items[_key2] = arguments[_key2];\n    }\n\n    var C = typeof this === 'function' ? this : Observable;\n    return new C(function (observer) {\n      enqueue(function () {\n        if (observer.closed) return;\n\n        for (var i = 0; i < items.length; ++i) {\n          observer.next(items[i]);\n          if (observer.closed) return;\n        }\n\n        observer.complete();\n      });\n    });\n  };\n\n  _createClass(Observable, null, [{\n    key: SymbolSpecies,\n    get: function () {\n      return this;\n    }\n  }]);\n\n  return Observable;\n}();\n\nif (hasSymbols()) {\n  Object.defineProperty(Observable, Symbol('extensions'), {\n    value: {\n      symbol: SymbolObservable,\n      hostReportError: hostReportError\n    },\n    configurable: true\n  });\n}\n\nexport { Observable };\n"],"names":["extendStatics","d","b","Object","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","__extends","TypeError","String","__","this","constructor","create","__assign","assign","t","s","i","n","arguments","length","apply","__rest","e","indexOf","getOwnPropertySymbols","propertyIsEnumerable","__awaiter","thisArg","_arguments","P","generator","adopt","value","resolve","Promise","reject","fulfilled","step","next","rejected","result","done","then","__generator","body","f","y","g","_","label","sent","trys","ops","verb","Symbol","iterator","v","op","pop","push","__spreadArray","to","from","pack","ar","l","slice","concat","createOperation","starting","operation","context","setContext","getContext","defineProperty","enumerable","transformOperation","transformedOperation","variables","extensions","operationName","query","getOperationName","undefined","validateOperation","OPERATION_FIELDS","keys","_i","key","__DEV__","passthrough","forward","Observable","toLink","handler","ApolloLink","isTerminating","link","request","message","_super","_this","Error","links","empty","map","reduce","x","test","left","right","leftLink","rightLink","first","second","firstLink","invariant","LinkError","nextLink","split","error","observer","fn","onError","isNonNullObject","obj","genericMessage","proto","_a","InvariantError","condition","verbosityLevels","verbosityLevel","wrapConsoleMethod","name","method","console","log","maybe","thunk","globalThis","window","self","global","GLOBAL_KEY","join","getDEV","Boolean","configurable","writable","safeGlobal","needToRemove","install","process","env","NODE_ENV","remove","removeTemporaryGlobals","Source","checkDEV","DEV","shouldInclude","directives","getInclusionDirectives","every","directive","ifArgument","evaledValue","kind","getDirectiveNames","root","names","visit","Directive","node","hasDirectives","some","hasClientExports","document","isInclusionDirective","forEach","directiveArguments","directiveName","ifValue","getFragmentQueryDocument","fragmentName","actualFragmentName","fragments","definitions","definition","selectionSet","selections","createFragmentMap","symTable","fragment","getFragmentFromSelection","selection","fragmentMap","checkDocument","doc","operations","filter","getOperationDefinition","getFragmentDefinitions","getQueryDefinition","queryDef","getFragmentDefinition","fragmentDef","getMainDefinition","queryDoc","fragmentDefinition","getDefaultValues","defaultValues","defs","variableDefinitions","def","defaultValue","valueToObjectRepresentation","variable","makeReference","id","__ref","isReference","isDocumentNode","isArray","isStringValue","isBooleanValue","isIntValue","isFloatValue","isVariable","isObjectValue","isListValue","isEnumValue","isNullValue","argObj","Number","nestedArgObj_1","fields","variableValue","values","listValue","nestedArgArrayObj","storeKeyNameFromField","field","directivesObj","getStoreKeyName","KNOWN_DIRECTIVES","fieldName","args","filterKeys","sort","filteredArgs_1","stringify","completeFieldName","stringifiedArgs","setStringify","previous","JSON","stringifyReplacer","_key","copy","argumentsObjectFromField","argObj_1","resultKeyNameFromField","alias","getTypenameFromResult","__typename","isField","typename","isInlineFragment","filterInPlace","array","target","elem","TYPENAME_FIELD","isEmpty","nullIfDocIsEmpty","getDirectiveMatcher","dir","removeDirectivesFromDocument","variablesInUse","variablesToRemove","fragmentSpreadsInUse","fragmentSpreadsToRemove","modifiedDoc","Variable","enter","parent","Field","shouldRemoveField","arg","getAllFragmentSpreadsFromSelectionSet","frag","FragmentSpread","removeArgumentsFromDocument","fs","removeFragmentSpreadFromDocument","addTypenameToDocument","SelectionSet","skip","lastIndexOf","added","connectionRemoveConfig","willRemove","removeConnectionDirectiveFromDocument","getArgumentMatcher","config","argument","aConfig","argMatcher","OperationDefinition","varDef","argConfig","argMatchCount_1","Argument","FragmentDefinition","allFragments","buildQueryFromSelectionSet","definitionOperation","removeClientSetsFromDocument","isTypenameOnly","_createForOfIteratorHelperLoose","o","allowArrayLike","it","bind","_unsupportedIterableToArray","minLen","_arrayLikeToArray","toString","arr","len","arr2","_defineProperties","props","descriptor","_createClass","Constructor","protoProps","staticProps","hasSymbols","hasSymbol","getSymbol","observable","SymbolIterator","SymbolObservable","SymbolSpecies","getMethod","getSpecies","ctor","isObservable","hostReportError","setTimeout","enqueue","cleanupSubscription","subscription","cleanup","_cleanup","unsubscribe","closeSubscription","_observer","_queue","_state","flushSubscription","queue","notifySubscription","type","m","onNotify","Subscription","subscriber","subscriptionObserver","SubscriptionObserver","_proto","get","_subscription","_proto2","complete","_subscriber","_proto3","subscribe","_this2","C","_this3","_this4","hasSeed","hasValue","seed","acc","_this5","_len","sources","index","startNext","flatMap","_this6","subscriptions","outer","inner","splice","completeIfDone","closed","_step","_iterator","item","of","_len2","items","_key2","symbol"],"sourceRoot":""}