{"version":3,"file":"static/chunks/2571-6fd7dcaceb1f7185.js","mappings":"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ACA,0EGpFAK,aFKA,IAAAC,EAAA,gCAEA,SAAAC,EAAAC,CAAA,EACA,OAAAC,CAAA,CAAAD,EAAAE,UAAA,KAGA,IAAAD,EAAA,CACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,MACA,MACA,MACA,UACA,MACA,MACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,GACA,GACA,MACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,OACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,GACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,UACA,gBCnKA,IAAAE,EAAA,CACAC,KAAA,CACAC,MAAA,GAAApiC,EAAAxe,KAAA,EAEAo2C,SAAA,CACAwK,MAAA,OAAApiC,EAAA/I,IAAA,EAGAorC,SAAA,CACAD,MAAA,GAAAl9B,EAAAlF,EAAAymB,WAAA,QACA,EACA6b,oBAAA,CACAF,MAAApiC,CAAA,EACA,IAAAuiC,EAAAC,EAAA,IAAAt9B,EAAAlF,EAAA2b,mBAAA,YACA8mB,EAAAv9B,EACA,CACAlF,EAAA0mB,SAAA,CACAxhB,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","sources":["webpack://_N_E/./node_modules/next/dist/client/components/noop-head.js","webpack://_N_E/./node_modules/redux-persist/es/constants.js","webpack://_N_E/./node_modules/redux-persist/es/stateReconciler/autoMergeLevel1.js","webpack://_N_E/./node_modules/redux-persist/es/createPersistoid.js","webpack://_N_E/./node_modules/redux-persist/es/getStoredState.js","webpack://_N_E/./node_modules/redux-persist/es/purgeStoredState.js","webpack://_N_E/./node_modules/redux-persist/es/persistReducer.js","webpack://_N_E/./node_modules/redux-persist/es/persistStore.js","webpack://_N_E/./node_modules/redux-persist/es/index.js","webpack://_N_E/./node_modules/redux-persist/es/integration/react.js","webpack://_N_E/./node_modules/redux-persist/lib/storage/createWebStorage.js","webpack://_N_E/./node_modules/redux-persist/lib/storage/getStorage.js","webpack://_N_E/./node_modules/redux-persist/lib/storage/index.js","webpack://_N_E/./node_modules/next/font/google/target.css","webpack://_N_E/./node_modules/next/font/google/target.css?b29c","webpack://_N_E/./node_modules/@apollo/client/cache/core/cache.js","webpack://_N_E/./node_modules/@apollo/client/cache/core/types/common.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/helpers.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/entityStore.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/object-canon.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/readFromStore.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/key-extractor.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/policies.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/writeToStore.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/inMemoryCache.js","webpack://_N_E/./node_modules/@apollo/client/cache/inmemory/reactiveVars.js","webpack://_N_E/./node_modules/@apollo/client/link/core/execute.js","webpack://_N_E/./node_modules/@apollo/client/link/http/HttpLink.js","webpack://_N_E/./node_modules/@apollo/client/utilities/observables/asyncMap.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/errorHandling.js","webpack://_N_E/./node_modules/@apollo/client/utilities/observables/iteration.js","webpack://_N_E/./node_modules/@apollo/client/utilities/observables/subclassing.js","webpack://_N_E/./node_modules/@apollo/client/utilities/observables/Concast.js","webpack://_N_E/./node_modules/@apollo/client/core/ObservableQuery.js","webpack://_N_E/./node_modules/@apollo/client/core/QueryInfo.js","webpack://_N_E/./node_modules/@apollo/client/core/QueryManager.js","webpack://_N_E/./node_modules/graphql/language/predicates.mjs","webpack://_N_E/./node_modules/@apollo/client/core/LocalState.js","webpack://_N_E/./node_modules/@apollo/client/core/ApolloClient.js","webpack://_N_E/./node_modules/@apollo/client/core/equalByQuery.js","webpack://_N_E/./node_modules/@apollo/client/core/networkStatus.js","webpack://_N_E/./node_modules/@apollo/client/link/context/index.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/createOperation.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/transformOperation.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/validateOperation.js","webpack://_N_E/./node_modules/@apollo/client/link/core/ApolloLink.js","webpack://_N_E/./node_modules/@apollo/client/link/error/index.js","webpack://_N_E/./node_modules/@apollo/client/link/http/serializeFetchParameter.js","webpack://_N_E/./node_modules/@apollo/client/link/http/selectURI.js","webpack://_N_E/./node_modules/@apollo/client/link/http/iterators/async.js","webpack://_N_E/./node_modules/@apollo/client/link/http/iterators/nodeStream.js","webpack://_N_E/./node_modules/@apollo/client/link/http/iterators/promise.js","webpack://_N_E/./node_modules/@apollo/client/link/http/iterators/reader.js","webpack://_N_E/./node_modules/@apollo/client/link/http/responseIterator.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/throwServerError.js","webpack://_N_E/./node_modules/@apollo/client/link/http/parseAndCheckHttpResponse.js","webpack://_N_E/./node_modules/@apollo/client/link/http/checkFetcher.js","webpack://_N_E/./node_modules/@apollo/client/link/http/selectHttpOptionsAndBody.js","webpack://_N_E/./node_modules/@apollo/client/link/http/rewriteURIForGET.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/fromError.js","webpack://_N_E/./node_modules/@apollo/client/link/utils/filterOperationVariables.js","webpack://_N_E/./node_modules/@apollo/client/link/http/createHttpLink.js","webpack://_N_E/./node_modules/@apollo/client/react/context/ApolloProvider.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/arrays.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/canonicalStringify.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/cloneDeep.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/incrementalResult.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/maybeDeepFreeze.js","webpack://_N_E/./node_modules/@apollo/client/utilities/common/mergeDeep.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/DocumentTransform.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/directives.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/fragments.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/getFromAST.js","webpack://_N_E/./node_modules/graphql/language/printString.mjs","webpack://_N_E/./node_modules/graphql/language/printer.mjs","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/print.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/storeUtils.js","webpack://_N_E/./node_modules/@apollo/client/utilities/graphql/transform.js","webpack://_N_E/./node_modules/@wry/trie/lib/index.js","webpack://_N_E/./node_modules/graphql/language/visitor.mjs","webpack://_N_E/./node_modules/optimism/node_modules/@wry/trie/lib/index.js","webpack://_N_E/./node_modules/@wry/context/lib/slot.js","webpack://_N_E/./node_modules/@wry/context/lib/index.js","webpack://_N_E/./node_modules/optimism/lib/context.js","webpack://_N_E/./node_modules/optimism/lib/helpers.js","webpack://_N_E/./node_modules/optimism/lib/entry.js","webpack://_N_E/./node_modules/optimism/lib/dep.js","webpack://_N_E/./node_modules/optimism/lib/index.js","webpack://_N_E/./node_modules/zen-observable-ts/module.js","webpack://_N_E/<anon>"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nObject.defineProperty(exports, \"default\", {\n    enumerable: true,\n    get: function() {\n        return NoopHead;\n    }\n});\nfunction NoopHead() {\n    return null;\n}\n\nif ((typeof exports.default === 'function' || (typeof exports.default === 'object' && exports.default !== null)) && typeof exports.default.__esModule === 'undefined') {\n  Object.defineProperty(exports.default, '__esModule', { value: true });\n  Object.assign(exports.default, exports);\n  module.exports = exports.default;\n}\n\n//# sourceMappingURL=noop-head.js.map","export var KEY_PREFIX = 'persist:';\nexport var FLUSH = 'persist/FLUSH';\nexport var REHYDRATE = 'persist/REHYDRATE';\nexport var PAUSE = 'persist/PAUSE';\nexport var PERSIST = 'persist/PERSIST';\nexport var PURGE = 'persist/PURGE';\nexport var REGISTER = 'persist/REGISTER';\nexport var DEFAULT_VERSION = -1;","function _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\n/*\n  autoMergeLevel1: \n    - merges 1 level of substate\n    - skips substate if already modified\n*/\nexport default function autoMergeLevel1(inboundState, originalState, reducedState, _ref) {\n  var debug = _ref.debug;\n\n  var newState = _objectSpread({}, reducedState); // only rehydrate if inboundState exists and is an object\n\n\n  if (inboundState && _typeof(inboundState) === 'object') {\n    Object.keys(inboundState).forEach(function (key) {\n      // ignore _persist data\n      if (key === '_persist') return; // if reducer modifies substate, skip auto rehydration\n\n      if (originalState[key] !== reducedState[key]) {\n        if (process.env.NODE_ENV !== 'production' && debug) console.log('redux-persist/stateReconciler: sub state for key `%s` modified, skipping.', key);\n        return;\n      } // otherwise hard set the new value\n\n\n      newState[key] = inboundState[key];\n    });\n  }\n\n  if (process.env.NODE_ENV !== 'production' && debug && inboundState && _typeof(inboundState) === 'object') console.log(\"redux-persist/stateReconciler: rehydrated keys '\".concat(Object.keys(inboundState).join(', '), \"'\"));\n  return newState;\n}","import { KEY_PREFIX, REHYDRATE } from './constants';\n// @TODO remove once flow < 0.63 support is no longer required.\nexport default function createPersistoid(config) {\n  // defaults\n  var blacklist = config.blacklist || null;\n  var whitelist = config.whitelist || null;\n  var transforms = config.transforms || [];\n  var throttle = config.throttle || 0;\n  var storageKey = \"\".concat(config.keyPrefix !== undefined ? config.keyPrefix : KEY_PREFIX).concat(config.key);\n  var storage = config.storage;\n  var serialize;\n\n  if (config.serialize === false) {\n    serialize = function serialize(x) {\n      return x;\n    };\n  } else if (typeof config.serialize === 'function') {\n    serialize = config.serialize;\n  } else {\n    serialize = defaultSerialize;\n  }\n\n  var writeFailHandler = config.writeFailHandler || null; // initialize stateful values\n\n  var lastState = {};\n  var stagedState = {};\n  var keysToProcess = [];\n  var timeIterator = null;\n  var writePromise = null;\n\n  var update = function update(state) {\n    // add any changed keys to the queue\n    Object.keys(state).forEach(function (key) {\n      if (!passWhitelistBlacklist(key)) return; // is keyspace ignored? noop\n\n      if (lastState[key] === state[key]) return; // value unchanged? noop\n\n      if (keysToProcess.indexOf(key) !== -1) return; // is key already queued? noop\n\n      keysToProcess.push(key); // add key to queue\n    }); //if any key is missing in the new state which was present in the lastState,\n    //add it for processing too\n\n    Object.keys(lastState).forEach(function (key) {\n      if (state[key] === undefined && passWhitelistBlacklist(key) && keysToProcess.indexOf(key) === -1 && lastState[key] !== undefined) {\n        keysToProcess.push(key);\n      }\n    }); // start the time iterator if not running (read: throttle)\n\n    if (timeIterator === null) {\n      timeIterator = setInterval(processNextKey, throttle);\n    }\n\n    lastState = state;\n  };\n\n  function processNextKey() {\n    if (keysToProcess.length === 0) {\n      if (timeIterator) clearInterval(timeIterator);\n      timeIterator = null;\n      return;\n    }\n\n    var key = keysToProcess.shift();\n    var endState = transforms.reduce(function (subState, transformer) {\n      return transformer.in(subState, key, lastState);\n    }, lastState[key]);\n\n    if (endState !== undefined) {\n      try {\n        stagedState[key] = serialize(endState);\n      } catch (err) {\n        console.error('redux-persist/createPersistoid: error serializing state', err);\n      }\n    } else {\n      //if the endState is undefined, no need to persist the existing serialized content\n      delete stagedState[key];\n    }\n\n    if (keysToProcess.length === 0) {\n      writeStagedState();\n    }\n  }\n\n  function writeStagedState() {\n    // cleanup any removed keys just before write.\n    Object.keys(stagedState).forEach(function (key) {\n      if (lastState[key] === undefined) {\n        delete stagedState[key];\n      }\n    });\n    writePromise = storage.setItem(storageKey, serialize(stagedState)).catch(onWriteFail);\n  }\n\n  function passWhitelistBlacklist(key) {\n    if (whitelist && whitelist.indexOf(key) === -1 && key !== '_persist') return false;\n    if (blacklist && blacklist.indexOf(key) !== -1) return false;\n    return true;\n  }\n\n  function onWriteFail(err) {\n    // @TODO add fail handlers (typically storage full)\n    if (writeFailHandler) writeFailHandler(err);\n\n    if (err && process.env.NODE_ENV !== 'production') {\n      console.error('Error storing data', err);\n    }\n  }\n\n  var flush = function flush() {\n    while (keysToProcess.length !== 0) {\n      processNextKey();\n    }\n\n    return writePromise || Promise.resolve();\n  }; // return `persistoid`\n\n\n  return {\n    update: update,\n    flush: flush\n  };\n} // @NOTE in the future this may be exposed via config\n\nfunction defaultSerialize(data) {\n  return JSON.stringify(data);\n}","import { KEY_PREFIX } from './constants';\nexport default function getStoredState(config) {\n  var transforms = config.transforms || [];\n  var storageKey = \"\".concat(config.keyPrefix !== undefined ? config.keyPrefix : KEY_PREFIX).concat(config.key);\n  var storage = config.storage;\n  var debug = config.debug;\n  var deserialize;\n\n  if (config.deserialize === false) {\n    deserialize = function deserialize(x) {\n      return x;\n    };\n  } else if (typeof config.deserialize === 'function') {\n    deserialize = config.deserialize;\n  } else {\n    deserialize = defaultDeserialize;\n  }\n\n  return storage.getItem(storageKey).then(function (serialized) {\n    if (!serialized) return undefined;else {\n      try {\n        var state = {};\n        var rawState = deserialize(serialized);\n        Object.keys(rawState).forEach(function (key) {\n          state[key] = transforms.reduceRight(function (subState, transformer) {\n            return transformer.out(subState, key, rawState);\n          }, deserialize(rawState[key]));\n        });\n        return state;\n      } catch (err) {\n        if (process.env.NODE_ENV !== 'production' && debug) console.log(\"redux-persist/getStoredState: Error restoring data \".concat(serialized), err);\n        throw err;\n      }\n    }\n  });\n}\n\nfunction defaultDeserialize(serial) {\n  return JSON.parse(serial);\n}","import { KEY_PREFIX } from './constants';\nexport default function purgeStoredState(config) {\n  var storage = config.storage;\n  var storageKey = \"\".concat(config.keyPrefix !== undefined ? config.keyPrefix : KEY_PREFIX).concat(config.key);\n  return storage.removeItem(storageKey, warnIfRemoveError);\n}\n\nfunction warnIfRemoveError(err) {\n  if (err && process.env.NODE_ENV !== 'production') {\n    console.error('redux-persist/purgeStoredState: Error purging data stored state', err);\n  }\n}","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\n\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\n\nimport { FLUSH, PAUSE, PERSIST, PURGE, REHYDRATE, DEFAULT_VERSION } from './constants';\nimport autoMergeLevel1 from './stateReconciler/autoMergeLevel1';\nimport createPersistoid from './createPersistoid';\nimport defaultGetStoredState from './getStoredState';\nimport purgeStoredState from './purgeStoredState';\nvar DEFAULT_TIMEOUT = 5000;\n/*\n  @TODO add validation / handling for:\n  - persisting a reducer which has nested _persist\n  - handling actions that fire before reydrate is called\n*/\n\nexport default function persistReducer(config, baseReducer) {\n  if (process.env.NODE_ENV !== 'production') {\n    if (!config) throw new Error('config is required for persistReducer');\n    if (!config.key) throw new Error('key is required in persistor config');\n    if (!config.storage) throw new Error(\"redux-persist: config.storage is required. Try using one of the provided storage engines `import storage from 'redux-persist/lib/storage'`\");\n  }\n\n  var version = config.version !== undefined ? config.version : DEFAULT_VERSION;\n  var debug = config.debug || false;\n  var stateReconciler = config.stateReconciler === undefined ? autoMergeLevel1 : config.stateReconciler;\n  var getStoredState = config.getStoredState || defaultGetStoredState;\n  var timeout = config.timeout !== undefined ? config.timeout : DEFAULT_TIMEOUT;\n  var _persistoid = null;\n  var _purge = false;\n  var _paused = true;\n\n  var conditionalUpdate = function conditionalUpdate(state) {\n    // update the persistoid only if we are rehydrated and not paused\n    state._persist.rehydrated && _persistoid && !_paused && _persistoid.update(state);\n    return state;\n  };\n\n  return function (state, action) {\n    var _ref = state || {},\n        _persist = _ref._persist,\n        rest = _objectWithoutProperties(_ref, [\"_persist\"]); // $FlowIgnore need to update State type\n\n\n    var restState = rest;\n\n    if (action.type === PERSIST) {\n      var _sealed = false;\n\n      var _rehydrate = function _rehydrate(payload, err) {\n        // dev warning if we are already sealed\n        if (process.env.NODE_ENV !== 'production' && _sealed) console.error(\"redux-persist: rehydrate for \\\"\".concat(config.key, \"\\\" called after timeout.\"), payload, err); // only rehydrate if we are not already sealed\n\n        if (!_sealed) {\n          action.rehydrate(config.key, payload, err);\n          _sealed = true;\n        }\n      };\n\n      timeout && setTimeout(function () {\n        !_sealed && _rehydrate(undefined, new Error(\"redux-persist: persist timed out for persist key \\\"\".concat(config.key, \"\\\"\")));\n      }, timeout); // @NOTE PERSIST resumes if paused.\n\n      _paused = false; // @NOTE only ever create persistoid once, ensure we call it at least once, even if _persist has already been set\n\n      if (!_persistoid) _persistoid = createPersistoid(config); // @NOTE PERSIST can be called multiple times, noop after the first\n\n      if (_persist) {\n        // We still need to call the base reducer because there might be nested\n        // uses of persistReducer which need to be aware of the PERSIST action\n        return _objectSpread({}, baseReducer(restState, action), {\n          _persist: _persist\n        });\n      }\n\n      if (typeof action.rehydrate !== 'function' || typeof action.register !== 'function') throw new Error('redux-persist: either rehydrate or register is not a function on the PERSIST action. This can happen if the action is being replayed. This is an unexplored use case, please open an issue and we will figure out a resolution.');\n      action.register(config.key);\n      getStoredState(config).then(function (restoredState) {\n        var migrate = config.migrate || function (s, v) {\n          return Promise.resolve(s);\n        };\n\n        migrate(restoredState, version).then(function (migratedState) {\n          _rehydrate(migratedState);\n        }, function (migrateErr) {\n          if (process.env.NODE_ENV !== 'production' && migrateErr) console.error('redux-persist: migration error', migrateErr);\n\n          _rehydrate(undefined, migrateErr);\n        });\n      }, function (err) {\n        _rehydrate(undefined, err);\n      });\n      return _objectSpread({}, baseReducer(restState, action), {\n        _persist: {\n          version: version,\n          rehydrated: false\n        }\n      });\n    } else if (action.type === PURGE) {\n      _purge = true;\n      action.result(purgeStoredState(config));\n      return _objectSpread({}, baseReducer(restState, action), {\n        _persist: _persist\n      });\n    } else if (action.type === FLUSH) {\n      action.result(_persistoid && _persistoid.flush());\n      return _objectSpread({}, baseReducer(restState, action), {\n        _persist: _persist\n      });\n    } else if (action.type === PAUSE) {\n      _paused = true;\n    } else if (action.type === REHYDRATE) {\n      // noop on restState if purging\n      if (_purge) return _objectSpread({}, restState, {\n        _persist: _objectSpread({}, _persist, {\n          rehydrated: true\n        }) // @NOTE if key does not match, will continue to default else below\n\n      });\n\n      if (action.key === config.key) {\n        var reducedState = baseReducer(restState, action);\n        var inboundState = action.payload; // only reconcile state if stateReconciler and inboundState are both defined\n\n        var reconciledRest = stateReconciler !== false && inboundState !== undefined ? stateReconciler(inboundState, state, reducedState, config) : reducedState;\n\n        var _newState = _objectSpread({}, reconciledRest, {\n          _persist: _objectSpread({}, _persist, {\n            rehydrated: true\n          })\n        });\n\n        return conditionalUpdate(_newState);\n      }\n    } // if we have not already handled PERSIST, straight passthrough\n\n\n    if (!_persist) return baseReducer(state, action); // run base reducer:\n    // is state modified ? return original : return updated\n\n    var newState = baseReducer(restState, action);\n    if (newState === restState) return state;\n    return conditionalUpdate(_objectSpread({}, newState, {\n      _persist: _persist\n    }));\n  };\n}","function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }\n\nfunction _nonIterableSpread() { throw new TypeError(\"Invalid attempt to spread non-iterable instance\"); }\n\nfunction _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === \"[object Arguments]\") return Array.from(iter); }\n\nfunction _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport { createStore } from 'redux';\nimport { FLUSH, PAUSE, PERSIST, PURGE, REGISTER, REHYDRATE } from './constants';\nvar initialState = {\n  registry: [],\n  bootstrapped: false\n};\n\nvar persistorReducer = function persistorReducer() {\n  var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialState;\n  var action = arguments.length > 1 ? arguments[1] : undefined;\n\n  switch (action.type) {\n    case REGISTER:\n      return _objectSpread({}, state, {\n        registry: [].concat(_toConsumableArray(state.registry), [action.key])\n      });\n\n    case REHYDRATE:\n      var firstIndex = state.registry.indexOf(action.key);\n\n      var registry = _toConsumableArray(state.registry);\n\n      registry.splice(firstIndex, 1);\n      return _objectSpread({}, state, {\n        registry: registry,\n        bootstrapped: registry.length === 0\n      });\n\n    default:\n      return state;\n  }\n};\n\nexport default function persistStore(store, options, cb) {\n  // help catch incorrect usage of passing PersistConfig in as PersistorOptions\n  if (process.env.NODE_ENV !== 'production') {\n    var optionsToTest = options || {};\n    var bannedKeys = ['blacklist', 'whitelist', 'transforms', 'storage', 'keyPrefix', 'migrate'];\n    bannedKeys.forEach(function (k) {\n      if (!!optionsToTest[k]) console.error(\"redux-persist: invalid option passed to persistStore: \\\"\".concat(k, \"\\\". You may be incorrectly passing persistConfig into persistStore, whereas it should be passed into persistReducer.\"));\n    });\n  }\n\n  var boostrappedCb = cb || false;\n\n  var _pStore = createStore(persistorReducer, initialState, options && options.enhancer ? options.enhancer : undefined);\n\n  var register = function register(key) {\n    _pStore.dispatch({\n      type: REGISTER,\n      key: key\n    });\n  };\n\n  var rehydrate = function rehydrate(key, payload, err) {\n    var rehydrateAction = {\n      type: REHYDRATE,\n      payload: payload,\n      err: err,\n      key: key // dispatch to `store` to rehydrate and `persistor` to track result\n\n    };\n    store.dispatch(rehydrateAction);\n\n    _pStore.dispatch(rehydrateAction);\n\n    if (boostrappedCb && persistor.getState().bootstrapped) {\n      boostrappedCb();\n      boostrappedCb = false;\n    }\n  };\n\n  var persistor = _objectSpread({}, _pStore, {\n    purge: function purge() {\n      var results = [];\n      store.dispatch({\n        type: PURGE,\n        result: function result(purgeResult) {\n          results.push(purgeResult);\n        }\n      });\n      return Promise.all(results);\n    },\n    flush: function flush() {\n      var results = [];\n      store.dispatch({\n        type: FLUSH,\n        result: function result(flushResult) {\n          results.push(flushResult);\n        }\n      });\n      return Promise.all(results);\n    },\n    pause: function pause() {\n      store.dispatch({\n        type: PAUSE\n      });\n    },\n    persist: function persist() {\n      store.dispatch({\n        type: PERSIST,\n        register: register,\n        rehydrate: rehydrate\n      });\n    }\n  });\n\n  if (!(options && options.manualPersist)) {\n    persistor.persist();\n  }\n\n  return persistor;\n}","export { default as persistReducer } from './persistReducer';\nexport { default as persistCombineReducers } from './persistCombineReducers';\nexport { default as persistStore } from './persistStore';\nexport { default as createMigrate } from './createMigrate';\nexport { default as createTransform } from './createTransform';\nexport { default as getStoredState } from './getStoredState';\nexport { default as createPersistoid } from './createPersistoid';\nexport { default as purgeStoredState } from './purgeStoredState';\nexport * from './constants';","function _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\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\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport React, { PureComponent } from 'react'; // eslint-disable-line import/no-unresolved\n\nexport var PersistGate =\n/*#__PURE__*/\nfunction (_PureComponent) {\n  _inherits(PersistGate, _PureComponent);\n\n  function PersistGate() {\n    var _getPrototypeOf2;\n\n    var _this;\n\n    _classCallCheck(this, PersistGate);\n\n    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n      args[_key] = arguments[_key];\n    }\n\n    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(PersistGate)).call.apply(_getPrototypeOf2, [this].concat(args)));\n\n    _defineProperty(_assertThisInitialized(_this), \"state\", {\n      bootstrapped: false\n    });\n\n    _defineProperty(_assertThisInitialized(_this), \"_unsubscribe\", void 0);\n\n    _defineProperty(_assertThisInitialized(_this), \"handlePersistorState\", function () {\n      var persistor = _this.props.persistor;\n\n      var _persistor$getState = persistor.getState(),\n          bootstrapped = _persistor$getState.bootstrapped;\n\n      if (bootstrapped) {\n        if (_this.props.onBeforeLift) {\n          Promise.resolve(_this.props.onBeforeLift()).finally(function () {\n            return _this.setState({\n              bootstrapped: true\n            });\n          });\n        } else {\n          _this.setState({\n            bootstrapped: true\n          });\n        }\n\n        _this._unsubscribe && _this._unsubscribe();\n      }\n    });\n\n    return _this;\n  }\n\n  _createClass(PersistGate, [{\n    key: \"componentDidMount\",\n    value: function componentDidMount() {\n      this._unsubscribe = this.props.persistor.subscribe(this.handlePersistorState);\n      this.handlePersistorState();\n    }\n  }, {\n    key: \"componentWillUnmount\",\n    value: function componentWillUnmount() {\n      this._unsubscribe && this._unsubscribe();\n    }\n  }, {\n    key: \"render\",\n    value: function render() {\n      if (process.env.NODE_ENV !== 'production') {\n        if (typeof this.props.children === 'function' && this.props.loading) console.error('redux-persist: PersistGate expects either a function child or loading prop, but not both. The loading prop will be ignored.');\n      }\n\n      if (typeof this.props.children === 'function') {\n        return this.props.children(this.state.bootstrapped);\n      }\n\n      return this.state.bootstrapped ? this.props.children : this.props.loading;\n    }\n  }]);\n\n  return PersistGate;\n}(PureComponent);\n\n_defineProperty(PersistGate, \"defaultProps\", {\n  children: null,\n  loading: null\n});","\"use strict\";\n\nexports.__esModule = true;\nexports.default = createWebStorage;\n\nvar _getStorage = _interopRequireDefault(require(\"./getStorage\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nfunction createWebStorage(type) {\n  var storage = (0, _getStorage.default)(type);\n  return {\n    getItem: function getItem(key) {\n      return new Promise(function (resolve, reject) {\n        resolve(storage.getItem(key));\n      });\n    },\n    setItem: function setItem(key, item) {\n      return new Promise(function (resolve, reject) {\n        resolve(storage.setItem(key, item));\n      });\n    },\n    removeItem: function removeItem(key) {\n      return new Promise(function (resolve, reject) {\n        resolve(storage.removeItem(key));\n      });\n    }\n  };\n}","\"use strict\";\n\nexports.__esModule = true;\nexports.default = getStorage;\n\nfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction noop() {}\n\nvar noopStorage = {\n  getItem: noop,\n  setItem: noop,\n  removeItem: noop\n};\n\nfunction hasStorage(storageType) {\n  if ((typeof self === \"undefined\" ? \"undefined\" : _typeof(self)) !== 'object' || !(storageType in self)) {\n    return false;\n  }\n\n  try {\n    var storage = self[storageType];\n    var testKey = \"redux-persist \".concat(storageType, \" test\");\n    storage.setItem(testKey, 'test');\n    storage.getItem(testKey);\n    storage.removeItem(testKey);\n  } catch (e) {\n    if (process.env.NODE_ENV !== 'production') console.warn(\"redux-persist \".concat(storageType, \" test failed, persistence will be disabled.\"));\n    return false;\n  }\n\n  return true;\n}\n\nfunction getStorage(type) {\n  var storageType = \"\".concat(type, \"Storage\");\n  if (hasStorage(storageType)) return self[storageType];else {\n    if (process.env.NODE_ENV !== 'production') {\n      console.error(\"redux-persist failed to create sync storage. falling back to noop storage.\");\n    }\n\n    return noopStorage;\n  }\n}","\"use strict\";\n\nexports.__esModule = true;\nexports.default = void 0;\n\nvar _createWebStorage = _interopRequireDefault(require(\"./createWebStorage\"));\n\nfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\nvar _default = (0, _createWebStorage.default)('local');\n\nexports.default = _default;","// extracted by mini-css-extract-plugin\nmodule.exports = {\"style\":{\"fontFamily\":\"'__Hind_0f85a8', '__Hind_Fallback_0f85a8'\",\"fontStyle\":\"normal\"},\"className\":\"__className_0f85a8\",\"variable\":\"__variable_0f85a8\"};","// extracted by mini-css-extract-plugin\nmodule.exports = {\"style\":{\"fontFamily\":\"'__Poppins_559008', '__Poppins_Fallback_559008'\",\"fontStyle\":\"normal\"},\"className\":\"__className_559008\",\"variable\":\"__variable_559008\"};","import { __assign, __rest } from \"tslib\";\nimport { wrap } from \"optimism\";\nimport { Observable, cacheSizes, getFragmentQueryDocument, mergeDeepArray, } from \"../../utilities/index.js\";\nimport { WeakCache } from \"@wry/caches\";\nimport { getApolloCacheMemoryInternals } from \"../../utilities/caching/getMemoryInternals.js\";\nimport { equalByQuery } from \"../../core/equalByQuery.js\";\nvar ApolloCache = /** @class */ (function () {\n    function ApolloCache() {\n        this.assumeImmutableResults = false;\n        // Make sure we compute the same (===) fragment query document every\n        // time we receive the same fragment in readFragment.\n        this.getFragmentDoc = wrap(getFragmentQueryDocument, {\n            max: cacheSizes[\"cache.fragmentQueryDocuments\"] ||\n                1000 /* defaultCacheSizes[\"cache.fragmentQueryDocuments\"] */,\n            cache: WeakCache,\n        });\n    }\n    // Transactional API\n    // The batch method is intended to replace/subsume both performTransaction\n    // and recordOptimisticTransaction, but performTransaction came first, so we\n    // provide a default batch implementation that's just another way of calling\n    // performTransaction. Subclasses of ApolloCache (such as InMemoryCache) can\n    // override the batch method to do more interesting things with its options.\n    ApolloCache.prototype.batch = function (options) {\n        var _this = this;\n        var optimisticId = typeof options.optimistic === \"string\" ? options.optimistic\n            : options.optimistic === false ? null\n                : void 0;\n        var updateResult;\n        this.performTransaction(function () { return (updateResult = options.update(_this)); }, optimisticId);\n        return updateResult;\n    };\n    ApolloCache.prototype.recordOptimisticTransaction = function (transaction, optimisticId) {\n        this.performTransaction(transaction, optimisticId);\n    };\n    // Optional API\n    // Called once per input document, allowing the cache to make static changes\n    // to the query, such as adding __typename fields.\n    ApolloCache.prototype.transformDocument = function (document) {\n        return document;\n    };\n    // Called before each ApolloLink request, allowing the cache to make dynamic\n    // changes to the query, such as filling in missing fragment definitions.\n    ApolloCache.prototype.transformForLink = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.identify = function (object) {\n        return;\n    };\n    ApolloCache.prototype.gc = function () {\n        return [];\n    };\n    ApolloCache.prototype.modify = function (options) {\n        return false;\n    };\n    // DataProxy API\n    ApolloCache.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = !!options.optimistic; }\n        return this.read(__assign(__assign({}, options), { rootId: options.id || \"ROOT_QUERY\", optimistic: optimistic }));\n    };\n    /** {@inheritDoc @apollo/client!ApolloClient#watchFragment:member(1)} */\n    ApolloCache.prototype.watchFragment = function (options) {\n        var _this = this;\n        var fragment = options.fragment, fragmentName = options.fragmentName, from = options.from, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, otherOptions = __rest(options, [\"fragment\", \"fragmentName\", \"from\", \"optimistic\"]);\n        var query = this.getFragmentDoc(fragment, fragmentName);\n        var diffOptions = __assign(__assign({}, otherOptions), { returnPartialData: true, id: \n            // While our TypeScript types do not allow for `undefined` as a valid\n            // `from`, its possible `useFragment` gives us an `undefined` since it\n            // calls` cache.identify` and provides that value to `from`. We are\n            // adding this fix here however to ensure those using plain JavaScript\n            // and using `cache.identify` themselves will avoid seeing the obscure\n            // warning.\n            typeof from === \"undefined\" || typeof from === \"string\" ?\n                from\n                : this.identify(from), query: query, optimistic: optimistic });\n        var latestDiff;\n        return new Observable(function (observer) {\n            return _this.watch(__assign(__assign({}, diffOptions), { immediate: true, callback: function (diff) {\n                    if (\n                    // Always ensure we deliver the first result\n                    latestDiff &&\n                        equalByQuery(query, { data: latestDiff === null || latestDiff === void 0 ? void 0 : latestDiff.result }, { data: diff.result })) {\n                        return;\n                    }\n                    var result = {\n                        data: diff.result,\n                        complete: !!diff.complete,\n                    };\n                    if (diff.missing) {\n                        result.missing = mergeDeepArray(diff.missing.map(function (error) { return error.missing; }));\n                    }\n                    latestDiff = diff;\n                    observer.next(result);\n                } }));\n        });\n    };\n    ApolloCache.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = !!options.optimistic; }\n        return this.read(__assign(__assign({}, options), { query: this.getFragmentDoc(options.fragment, options.fragmentName), rootId: options.id, optimistic: optimistic }));\n    };\n    ApolloCache.prototype.writeQuery = function (_a) {\n        var id = _a.id, data = _a.data, options = __rest(_a, [\"id\", \"data\"]);\n        return this.write(Object.assign(options, {\n            dataId: id || \"ROOT_QUERY\",\n            result: data,\n        }));\n    };\n    ApolloCache.prototype.writeFragment = function (_a) {\n        var id = _a.id, data = _a.data, fragment = _a.fragment, fragmentName = _a.fragmentName, options = __rest(_a, [\"id\", \"data\", \"fragment\", \"fragmentName\"]);\n        return this.write(Object.assign(options, {\n            query: this.getFragmentDoc(fragment, fragmentName),\n            dataId: id,\n            result: data,\n        }));\n    };\n    ApolloCache.prototype.updateQuery = function (options, update) {\n        return this.batch({\n            update: function (cache) {\n                var value = cache.readQuery(options);\n                var data = update(value);\n                if (data === void 0 || data === null)\n                    return value;\n                cache.writeQuery(__assign(__assign({}, options), { data: data }));\n                return data;\n            },\n        });\n    };\n    ApolloCache.prototype.updateFragment = function (options, update) {\n        return this.batch({\n            update: function (cache) {\n                var value = cache.readFragment(options);\n                var data = update(value);\n                if (data === void 0 || data === null)\n                    return value;\n                cache.writeFragment(__assign(__assign({}, options), { data: data }));\n                return data;\n            },\n        });\n    };\n    return ApolloCache;\n}());\nexport { ApolloCache };\nif (globalThis.__DEV__ !== false) {\n    ApolloCache.prototype.getMemoryInternals = getApolloCacheMemoryInternals;\n}\n//# sourceMappingURL=cache.js.map","import { __extends } from \"tslib\";\nvar MissingFieldError = /** @class */ (function (_super) {\n    __extends(MissingFieldError, _super);\n    function MissingFieldError(message, path, query, variables) {\n        var _a;\n        // 'Error' breaks prototype chain here\n        var _this = _super.call(this, message) || this;\n        _this.message = message;\n        _this.path = path;\n        _this.query = query;\n        _this.variables = variables;\n        if (Array.isArray(_this.path)) {\n            _this.missing = _this.message;\n            for (var i = _this.path.length - 1; i >= 0; --i) {\n                _this.missing = (_a = {}, _a[_this.path[i]] = _this.missing, _a);\n            }\n        }\n        else {\n            _this.missing = _this.path;\n        }\n        // We're not using `Object.setPrototypeOf` here as it isn't fully supported\n        // on Android (see issue #3236).\n        _this.__proto__ = MissingFieldError.prototype;\n        return _this;\n    }\n    return MissingFieldError;\n}(Error));\nexport { MissingFieldError };\n//# sourceMappingURL=common.js.map","import { isReference, isField, DeepMerger, resultKeyNameFromField, shouldInclude, isNonNullObject, compact, createFragmentMap, getFragmentDefinitions, isArray, } from \"../../utilities/index.js\";\nexport var hasOwn = Object.prototype.hasOwnProperty;\nexport function isNullish(value) {\n    return value === null || value === void 0;\n}\nexport { isArray };\nexport function defaultDataIdFromObject(_a, context) {\n    var __typename = _a.__typename, id = _a.id, _id = _a._id;\n    if (typeof __typename === \"string\") {\n        if (context) {\n            context.keyObject =\n                !isNullish(id) ? { id: id }\n                    : !isNullish(_id) ? { _id: _id }\n                        : void 0;\n        }\n        // If there is no object.id, fall back to object._id.\n        if (isNullish(id) && !isNullish(_id)) {\n            id = _id;\n        }\n        if (!isNullish(id)) {\n            return \"\".concat(__typename, \":\").concat(typeof id === \"number\" || typeof id === \"string\" ?\n                id\n                : JSON.stringify(id));\n        }\n    }\n}\nvar defaultConfig = {\n    dataIdFromObject: defaultDataIdFromObject,\n    addTypename: true,\n    resultCaching: true,\n    // Thanks to the shouldCanonizeResults helper, this should be the only line\n    // you have to change to reenable canonization by default in the future.\n    canonizeResults: false,\n};\nexport function normalizeConfig(config) {\n    return compact(defaultConfig, config);\n}\nexport function shouldCanonizeResults(config) {\n    var value = config.canonizeResults;\n    return value === void 0 ? defaultConfig.canonizeResults : value;\n}\nexport function getTypenameFromStoreObject(store, objectOrReference) {\n    return isReference(objectOrReference) ?\n        store.get(objectOrReference.__ref, \"__typename\")\n        : objectOrReference && objectOrReference.__typename;\n}\nexport var TypeOrFieldNameRegExp = /^[_a-z][_0-9a-z]*/i;\nexport function fieldNameFromStoreName(storeFieldName) {\n    var match = storeFieldName.match(TypeOrFieldNameRegExp);\n    return match ? match[0] : storeFieldName;\n}\nexport function selectionSetMatchesResult(selectionSet, result, variables) {\n    if (isNonNullObject(result)) {\n        return isArray(result) ?\n            result.every(function (item) {\n                return selectionSetMatchesResult(selectionSet, item, variables);\n            })\n            : selectionSet.selections.every(function (field) {\n                if (isField(field) && shouldInclude(field, variables)) {\n                    var key = resultKeyNameFromField(field);\n                    return (hasOwn.call(result, key) &&\n                        (!field.selectionSet ||\n                            selectionSetMatchesResult(field.selectionSet, result[key], variables)));\n                }\n                // If the selection has been skipped with @skip(true) or\n                // @include(false), it should not count against the matching. If\n                // the selection is not a field, it must be a fragment (inline or\n                // named). We will determine if selectionSetMatchesResult for that\n                // fragment when we get to it, so for now we return true.\n                return true;\n            });\n    }\n    return false;\n}\nexport function storeValueIsStoreObject(value) {\n    return isNonNullObject(value) && !isReference(value) && !isArray(value);\n}\nexport function makeProcessedFieldsMerger() {\n    return new DeepMerger();\n}\nexport function extractFragmentContext(document, fragments) {\n    // FragmentMap consisting only of fragments defined directly in document, not\n    // including other fragments registered in the FragmentRegistry.\n    var fragmentMap = createFragmentMap(getFragmentDefinitions(document));\n    return {\n        fragmentMap: fragmentMap,\n        lookupFragment: function (name) {\n            var def = fragmentMap[name];\n            if (!def && fragments) {\n                def = fragments.lookup(name);\n            }\n            return def || null;\n        },\n    };\n}\n//# sourceMappingURL=helpers.js.map","import { __assign, __extends, __rest } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport { dep } from \"optimism\";\nimport { equal } from \"@wry/equality\";\nimport { Trie } from \"@wry/trie\";\nimport { isReference, makeReference, DeepMerger, maybeDeepFreeze, canUseWeakMap, isNonNullObject, } from \"../../utilities/index.js\";\nimport { hasOwn, fieldNameFromStoreName } from \"./helpers.js\";\nvar DELETE = Object.create(null);\nvar delModifier = function () { return DELETE; };\nvar INVALIDATE = Object.create(null);\nvar EntityStore = /** @class */ (function () {\n    function EntityStore(policies, group) {\n        var _this = this;\n        this.policies = policies;\n        this.group = group;\n        this.data = Object.create(null);\n        // Maps root entity IDs to the number of times they have been retained, minus\n        // the number of times they have been released. Retained entities keep other\n        // entities they reference (even indirectly) from being garbage collected.\n        this.rootIds = Object.create(null);\n        // Lazily tracks { __ref: <dataId> } strings contained by this.data[dataId].\n        this.refs = Object.create(null);\n        // Bound function that can be passed around to provide easy access to fields\n        // of Reference objects as well as ordinary objects.\n        this.getFieldValue = function (objectOrReference, storeFieldName) {\n            return maybeDeepFreeze(isReference(objectOrReference) ?\n                _this.get(objectOrReference.__ref, storeFieldName)\n                : objectOrReference && objectOrReference[storeFieldName]);\n        };\n        // Returns true for non-normalized StoreObjects and non-dangling\n        // References, indicating that readField(name, objOrRef) has a chance of\n        // working. Useful for filtering out dangling references from lists.\n        this.canRead = function (objOrRef) {\n            return isReference(objOrRef) ?\n                _this.has(objOrRef.__ref)\n                : typeof objOrRef === \"object\";\n        };\n        // Bound function that converts an id or an object with a __typename and\n        // primary key fields to a Reference object. If called with a Reference object,\n        // that same Reference object is returned. Pass true for mergeIntoStore to persist\n        // an object into the store.\n        this.toReference = function (objOrIdOrRef, mergeIntoStore) {\n            if (typeof objOrIdOrRef === \"string\") {\n                return makeReference(objOrIdOrRef);\n            }\n            if (isReference(objOrIdOrRef)) {\n                return objOrIdOrRef;\n            }\n            var id = _this.policies.identify(objOrIdOrRef)[0];\n            if (id) {\n                var ref = makeReference(id);\n                if (mergeIntoStore) {\n                    _this.merge(id, objOrIdOrRef);\n                }\n                return ref;\n            }\n        };\n    }\n    // Although the EntityStore class is abstract, it contains concrete\n    // implementations of the various NormalizedCache interface methods that\n    // are inherited by the Root and Layer subclasses.\n    EntityStore.prototype.toObject = function () {\n        return __assign({}, this.data);\n    };\n    EntityStore.prototype.has = function (dataId) {\n        return this.lookup(dataId, true) !== void 0;\n    };\n    EntityStore.prototype.get = function (dataId, fieldName) {\n        this.group.depend(dataId, fieldName);\n        if (hasOwn.call(this.data, dataId)) {\n            var storeObject = this.data[dataId];\n            if (storeObject && hasOwn.call(storeObject, fieldName)) {\n                return storeObject[fieldName];\n            }\n        }\n        if (fieldName === \"__typename\" &&\n            hasOwn.call(this.policies.rootTypenamesById, dataId)) {\n            return this.policies.rootTypenamesById[dataId];\n        }\n        if (this instanceof Layer) {\n            return this.parent.get(dataId, fieldName);\n        }\n    };\n    EntityStore.prototype.lookup = function (dataId, dependOnExistence) {\n        // The has method (above) calls lookup with dependOnExistence = true, so\n        // that it can later be invalidated when we add or remove a StoreObject for\n        // this dataId. Any consumer who cares about the contents of the StoreObject\n        // should not rely on this dependency, since the contents could change\n        // without the object being added or removed.\n        if (dependOnExistence)\n            this.group.depend(dataId, \"__exists\");\n        if (hasOwn.call(this.data, dataId)) {\n            return this.data[dataId];\n        }\n        if (this instanceof Layer) {\n            return this.parent.lookup(dataId, dependOnExistence);\n        }\n        if (this.policies.rootTypenamesById[dataId]) {\n            return Object.create(null);\n        }\n    };\n    EntityStore.prototype.merge = function (older, newer) {\n        var _this = this;\n        var dataId;\n        // Convert unexpected references to ID strings.\n        if (isReference(older))\n            older = older.__ref;\n        if (isReference(newer))\n            newer = newer.__ref;\n        var existing = typeof older === \"string\" ? this.lookup((dataId = older)) : older;\n        var incoming = typeof newer === \"string\" ? this.lookup((dataId = newer)) : newer;\n        // If newer was a string ID, but that ID was not defined in this store,\n        // then there are no fields to be merged, so we're done.\n        if (!incoming)\n            return;\n        invariant(typeof dataId === \"string\", 1);\n        var merged = new DeepMerger(storeObjectReconciler).merge(existing, incoming);\n        // Even if merged === existing, existing may have come from a lower\n        // layer, so we always need to set this.data[dataId] on this level.\n        this.data[dataId] = merged;\n        if (merged !== existing) {\n            delete this.refs[dataId];\n            if (this.group.caching) {\n                var fieldsToDirty_1 = Object.create(null);\n                // If we added a new StoreObject where there was previously none, dirty\n                // anything that depended on the existence of this dataId, such as the\n                // EntityStore#has method.\n                if (!existing)\n                    fieldsToDirty_1.__exists = 1;\n                // Now invalidate dependents who called getFieldValue for any fields\n                // that are changing as a result of this merge.\n                Object.keys(incoming).forEach(function (storeFieldName) {\n                    if (!existing ||\n                        existing[storeFieldName] !== merged[storeFieldName]) {\n                        // Always dirty the full storeFieldName, which may include\n                        // serialized arguments following the fieldName prefix.\n                        fieldsToDirty_1[storeFieldName] = 1;\n                        // Also dirty fieldNameFromStoreName(storeFieldName) if it's\n                        // different from storeFieldName and this field does not have\n                        // keyArgs configured, because that means the cache can't make\n                        // any assumptions about how field values with the same field\n                        // name but different arguments might be interrelated, so it\n                        // must err on the side of invalidating all field values that\n                        // share the same short fieldName, regardless of arguments.\n                        var fieldName = fieldNameFromStoreName(storeFieldName);\n                        if (fieldName !== storeFieldName &&\n                            !_this.policies.hasKeyArgs(merged.__typename, fieldName)) {\n                            fieldsToDirty_1[fieldName] = 1;\n                        }\n                        // If merged[storeFieldName] has become undefined, and this is the\n                        // Root layer, actually delete the property from the merged object,\n                        // which is guaranteed to have been created fresh in this method.\n                        if (merged[storeFieldName] === void 0 && !(_this instanceof Layer)) {\n                            delete merged[storeFieldName];\n                        }\n                    }\n                });\n                if (fieldsToDirty_1.__typename &&\n                    !(existing && existing.__typename) &&\n                    // Since we return default root __typename strings\n                    // automatically from store.get, we don't need to dirty the\n                    // ROOT_QUERY.__typename field if merged.__typename is equal\n                    // to the default string (usually \"Query\").\n                    this.policies.rootTypenamesById[dataId] === merged.__typename) {\n                    delete fieldsToDirty_1.__typename;\n                }\n                Object.keys(fieldsToDirty_1).forEach(function (fieldName) {\n                    return _this.group.dirty(dataId, fieldName);\n                });\n            }\n        }\n    };\n    EntityStore.prototype.modify = function (dataId, fields) {\n        var _this = this;\n        var storeObject = this.lookup(dataId);\n        if (storeObject) {\n            var changedFields_1 = Object.create(null);\n            var needToMerge_1 = false;\n            var allDeleted_1 = true;\n            var sharedDetails_1 = {\n                DELETE: DELETE,\n                INVALIDATE: INVALIDATE,\n                isReference: isReference,\n                toReference: this.toReference,\n                canRead: this.canRead,\n                readField: function (fieldNameOrOptions, from) {\n                    return _this.policies.readField(typeof fieldNameOrOptions === \"string\" ?\n                        {\n                            fieldName: fieldNameOrOptions,\n                            from: from || makeReference(dataId),\n                        }\n                        : fieldNameOrOptions, { store: _this });\n                },\n            };\n            Object.keys(storeObject).forEach(function (storeFieldName) {\n                var fieldName = fieldNameFromStoreName(storeFieldName);\n                var fieldValue = storeObject[storeFieldName];\n                if (fieldValue === void 0)\n                    return;\n                var modify = typeof fields === \"function\" ? fields : (fields[storeFieldName] || fields[fieldName]);\n                if (modify) {\n                    var newValue = modify === delModifier ? DELETE : (modify(maybeDeepFreeze(fieldValue), __assign(__assign({}, sharedDetails_1), { fieldName: fieldName, storeFieldName: storeFieldName, storage: _this.getStorage(dataId, storeFieldName) })));\n                    if (newValue === INVALIDATE) {\n                        _this.group.dirty(dataId, storeFieldName);\n                    }\n                    else {\n                        if (newValue === DELETE)\n                            newValue = void 0;\n                        if (newValue !== fieldValue) {\n                            changedFields_1[storeFieldName] = newValue;\n                            needToMerge_1 = true;\n                            fieldValue = newValue;\n                            if (globalThis.__DEV__ !== false) {\n                                var checkReference = function (ref) {\n                                    if (_this.lookup(ref.__ref) === undefined) {\n                                        globalThis.__DEV__ !== false && invariant.warn(2, ref);\n                                        return true;\n                                    }\n                                };\n                                if (isReference(newValue)) {\n                                    checkReference(newValue);\n                                }\n                                else if (Array.isArray(newValue)) {\n                                    // Warn about writing \"mixed\" arrays of Reference and non-Reference objects\n                                    var seenReference = false;\n                                    var someNonReference = void 0;\n                                    for (var _i = 0, newValue_1 = newValue; _i < newValue_1.length; _i++) {\n                                        var value = newValue_1[_i];\n                                        if (isReference(value)) {\n                                            seenReference = true;\n                                            if (checkReference(value))\n                                                break;\n                                        }\n                                        else {\n                                            // Do not warn on primitive values, since those could never be represented\n                                            // by a reference. This is a valid (albeit uncommon) use case.\n                                            if (typeof value === \"object\" && !!value) {\n                                                var id = _this.policies.identify(value)[0];\n                                                // check if object could even be referenced, otherwise we are not interested in it for this warning\n                                                if (id) {\n                                                    someNonReference = value;\n                                                }\n                                            }\n                                        }\n                                        if (seenReference && someNonReference !== undefined) {\n                                            globalThis.__DEV__ !== false && invariant.warn(3, someNonReference);\n                                            break;\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n                if (fieldValue !== void 0) {\n                    allDeleted_1 = false;\n                }\n            });\n            if (needToMerge_1) {\n                this.merge(dataId, changedFields_1);\n                if (allDeleted_1) {\n                    if (this instanceof Layer) {\n                        this.data[dataId] = void 0;\n                    }\n                    else {\n                        delete this.data[dataId];\n                    }\n                    this.group.dirty(dataId, \"__exists\");\n                }\n                return true;\n            }\n        }\n        return false;\n    };\n    // If called with only one argument, removes the entire entity\n    // identified by dataId. If called with a fieldName as well, removes all\n    // fields of that entity whose names match fieldName according to the\n    // fieldNameFromStoreName helper function. If called with a fieldName\n    // and variables, removes all fields of that entity whose names match fieldName\n    // and whose arguments when cached exactly match the variables passed.\n    EntityStore.prototype.delete = function (dataId, fieldName, args) {\n        var _a;\n        var storeObject = this.lookup(dataId);\n        if (storeObject) {\n            var typename = this.getFieldValue(storeObject, \"__typename\");\n            var storeFieldName = fieldName && args ?\n                this.policies.getStoreFieldName({ typename: typename, fieldName: fieldName, args: args })\n                : fieldName;\n            return this.modify(dataId, storeFieldName ? (_a = {},\n                _a[storeFieldName] = delModifier,\n                _a) : delModifier);\n        }\n        return false;\n    };\n    EntityStore.prototype.evict = function (options, limit) {\n        var evicted = false;\n        if (options.id) {\n            if (hasOwn.call(this.data, options.id)) {\n                evicted = this.delete(options.id, options.fieldName, options.args);\n            }\n            if (this instanceof Layer && this !== limit) {\n                evicted = this.parent.evict(options, limit) || evicted;\n            }\n            // Always invalidate the field to trigger rereading of watched\n            // queries, even if no cache data was modified by the eviction,\n            // because queries may depend on computed fields with custom read\n            // functions, whose values are not stored in the EntityStore.\n            if (options.fieldName || evicted) {\n                this.group.dirty(options.id, options.fieldName || \"__exists\");\n            }\n        }\n        return evicted;\n    };\n    EntityStore.prototype.clear = function () {\n        this.replace(null);\n    };\n    EntityStore.prototype.extract = function () {\n        var _this = this;\n        var obj = this.toObject();\n        var extraRootIds = [];\n        this.getRootIdSet().forEach(function (id) {\n            if (!hasOwn.call(_this.policies.rootTypenamesById, id)) {\n                extraRootIds.push(id);\n            }\n        });\n        if (extraRootIds.length) {\n            obj.__META = { extraRootIds: extraRootIds.sort() };\n        }\n        return obj;\n    };\n    EntityStore.prototype.replace = function (newData) {\n        var _this = this;\n        Object.keys(this.data).forEach(function (dataId) {\n            if (!(newData && hasOwn.call(newData, dataId))) {\n                _this.delete(dataId);\n            }\n        });\n        if (newData) {\n            var __META = newData.__META, rest_1 = __rest(newData, [\"__META\"]);\n            Object.keys(rest_1).forEach(function (dataId) {\n                _this.merge(dataId, rest_1[dataId]);\n            });\n            if (__META) {\n                __META.extraRootIds.forEach(this.retain, this);\n            }\n        }\n    };\n    EntityStore.prototype.retain = function (rootId) {\n        return (this.rootIds[rootId] = (this.rootIds[rootId] || 0) + 1);\n    };\n    EntityStore.prototype.release = function (rootId) {\n        if (this.rootIds[rootId] > 0) {\n            var count = --this.rootIds[rootId];\n            if (!count)\n                delete this.rootIds[rootId];\n            return count;\n        }\n        return 0;\n    };\n    // Return a Set<string> of all the ID strings that have been retained by\n    // this layer/root *and* any layers/roots beneath it.\n    EntityStore.prototype.getRootIdSet = function (ids) {\n        if (ids === void 0) { ids = new Set(); }\n        Object.keys(this.rootIds).forEach(ids.add, ids);\n        if (this instanceof Layer) {\n            this.parent.getRootIdSet(ids);\n        }\n        else {\n            // Official singleton IDs like ROOT_QUERY and ROOT_MUTATION are\n            // always considered roots for garbage collection, regardless of\n            // their retainment counts in this.rootIds.\n            Object.keys(this.policies.rootTypenamesById).forEach(ids.add, ids);\n        }\n        return ids;\n    };\n    // The goal of garbage collection is to remove IDs from the Root layer of the\n    // store that are no longer reachable starting from any IDs that have been\n    // explicitly retained (see retain and release, above). Returns an array of\n    // dataId strings that were removed from the store.\n    EntityStore.prototype.gc = function () {\n        var _this = this;\n        var ids = this.getRootIdSet();\n        var snapshot = this.toObject();\n        ids.forEach(function (id) {\n            if (hasOwn.call(snapshot, id)) {\n                // Because we are iterating over an ECMAScript Set, the IDs we add here\n                // will be visited in later iterations of the forEach loop only if they\n                // were not previously contained by the Set.\n                Object.keys(_this.findChildRefIds(id)).forEach(ids.add, ids);\n                // By removing IDs from the snapshot object here, we protect them from\n                // getting removed from the root store layer below.\n                delete snapshot[id];\n            }\n        });\n        var idsToRemove = Object.keys(snapshot);\n        if (idsToRemove.length) {\n            var root_1 = this;\n            while (root_1 instanceof Layer)\n                root_1 = root_1.parent;\n            idsToRemove.forEach(function (id) { return root_1.delete(id); });\n        }\n        return idsToRemove;\n    };\n    EntityStore.prototype.findChildRefIds = function (dataId) {\n        if (!hasOwn.call(this.refs, dataId)) {\n            var found_1 = (this.refs[dataId] = Object.create(null));\n            var root = this.data[dataId];\n            if (!root)\n                return found_1;\n            var workSet_1 = new Set([root]);\n            // Within the store, only arrays and objects can contain child entity\n            // references, so we can prune the traversal using this predicate:\n            workSet_1.forEach(function (obj) {\n                if (isReference(obj)) {\n                    found_1[obj.__ref] = true;\n                    // In rare cases, a { __ref } Reference object may have other fields.\n                    // This often indicates a mismerging of References with StoreObjects,\n                    // but garbage collection should not be fooled by a stray __ref\n                    // property in a StoreObject (ignoring all the other fields just\n                    // because the StoreObject looks like a Reference). To avoid this\n                    // premature termination of findChildRefIds recursion, we fall through\n                    // to the code below, which will handle any other properties of obj.\n                }\n                if (isNonNullObject(obj)) {\n                    Object.keys(obj).forEach(function (key) {\n                        var child = obj[key];\n                        // No need to add primitive values to the workSet, since they cannot\n                        // contain reference objects.\n                        if (isNonNullObject(child)) {\n                            workSet_1.add(child);\n                        }\n                    });\n                }\n            });\n        }\n        return this.refs[dataId];\n    };\n    EntityStore.prototype.makeCacheKey = function () {\n        return this.group.keyMaker.lookupArray(arguments);\n    };\n    return EntityStore;\n}());\nexport { EntityStore };\n// A single CacheGroup represents a set of one or more EntityStore objects,\n// typically the Root store in a CacheGroup by itself, and all active Layer\n// stores in a group together. A single EntityStore object belongs to only\n// one CacheGroup, store.group. The CacheGroup is responsible for tracking\n// dependencies, so store.group is helpful for generating unique keys for\n// cached results that need to be invalidated when/if those dependencies\n// change. If we used the EntityStore objects themselves as cache keys (that\n// is, store rather than store.group), the cache would become unnecessarily\n// fragmented by all the different Layer objects. Instead, the CacheGroup\n// approach allows all optimistic Layer objects in the same linked list to\n// belong to one CacheGroup, with the non-optimistic Root object belonging\n// to another CacheGroup, allowing resultCaching dependencies to be tracked\n// separately for optimistic and non-optimistic entity data.\nvar CacheGroup = /** @class */ (function () {\n    function CacheGroup(caching, parent) {\n        if (parent === void 0) { parent = null; }\n        this.caching = caching;\n        this.parent = parent;\n        this.d = null;\n        this.resetCaching();\n    }\n    CacheGroup.prototype.resetCaching = function () {\n        this.d = this.caching ? dep() : null;\n        this.keyMaker = new Trie(canUseWeakMap);\n    };\n    CacheGroup.prototype.depend = function (dataId, storeFieldName) {\n        if (this.d) {\n            this.d(makeDepKey(dataId, storeFieldName));\n            var fieldName = fieldNameFromStoreName(storeFieldName);\n            if (fieldName !== storeFieldName) {\n                // Fields with arguments that contribute extra identifying\n                // information to the fieldName (thus forming the storeFieldName)\n                // depend not only on the full storeFieldName but also on the\n                // short fieldName, so the field can be invalidated using either\n                // level of specificity.\n                this.d(makeDepKey(dataId, fieldName));\n            }\n            if (this.parent) {\n                this.parent.depend(dataId, storeFieldName);\n            }\n        }\n    };\n    CacheGroup.prototype.dirty = function (dataId, storeFieldName) {\n        if (this.d) {\n            this.d.dirty(makeDepKey(dataId, storeFieldName), \n            // When storeFieldName === \"__exists\", that means the entity identified\n            // by dataId has either disappeared from the cache or was newly added,\n            // so the result caching system would do well to \"forget everything it\n            // knows\" about that object. To achieve that kind of invalidation, we\n            // not only dirty the associated result cache entry, but also remove it\n            // completely from the dependency graph. For the optimism implementation\n            // details, see https://github.com/benjamn/optimism/pull/195.\n            storeFieldName === \"__exists\" ? \"forget\" : \"setDirty\");\n        }\n    };\n    return CacheGroup;\n}());\nfunction makeDepKey(dataId, storeFieldName) {\n    // Since field names cannot have '#' characters in them, this method\n    // of joining the field name and the ID should be unambiguous, and much\n    // cheaper than JSON.stringify([dataId, fieldName]).\n    return storeFieldName + \"#\" + dataId;\n}\nexport function maybeDependOnExistenceOfEntity(store, entityId) {\n    if (supportsResultCaching(store)) {\n        // We use this pseudo-field __exists elsewhere in the EntityStore code to\n        // represent changes in the existence of the entity object identified by\n        // entityId. This dependency gets reliably dirtied whenever an object with\n        // this ID is deleted (or newly created) within this group, so any result\n        // cache entries (for example, StoreReader#executeSelectionSet results) that\n        // depend on __exists for this entityId will get dirtied as well, leading to\n        // the eventual recomputation (instead of reuse) of those result objects the\n        // next time someone reads them from the cache.\n        store.group.depend(entityId, \"__exists\");\n    }\n}\n(function (EntityStore) {\n    // Refer to this class as EntityStore.Root outside this namespace.\n    var Root = /** @class */ (function (_super) {\n        __extends(Root, _super);\n        function Root(_a) {\n            var policies = _a.policies, _b = _a.resultCaching, resultCaching = _b === void 0 ? true : _b, seed = _a.seed;\n            var _this = _super.call(this, policies, new CacheGroup(resultCaching)) || this;\n            _this.stump = new Stump(_this);\n            _this.storageTrie = new Trie(canUseWeakMap);\n            if (seed)\n                _this.replace(seed);\n            return _this;\n        }\n        Root.prototype.addLayer = function (layerId, replay) {\n            // Adding an optimistic Layer on top of the Root actually adds the Layer\n            // on top of the Stump, so the Stump always comes between the Root and\n            // any Layer objects that we've added.\n            return this.stump.addLayer(layerId, replay);\n        };\n        Root.prototype.removeLayer = function () {\n            // Never remove the root layer.\n            return this;\n        };\n        Root.prototype.getStorage = function () {\n            return this.storageTrie.lookupArray(arguments);\n        };\n        return Root;\n    }(EntityStore));\n    EntityStore.Root = Root;\n})(EntityStore || (EntityStore = {}));\n// Not exported, since all Layer instances are created by the addLayer method\n// of the EntityStore.Root class.\nvar Layer = /** @class */ (function (_super) {\n    __extends(Layer, _super);\n    function Layer(id, parent, replay, group) {\n        var _this = _super.call(this, parent.policies, group) || this;\n        _this.id = id;\n        _this.parent = parent;\n        _this.replay = replay;\n        _this.group = group;\n        replay(_this);\n        return _this;\n    }\n    Layer.prototype.addLayer = function (layerId, replay) {\n        return new Layer(layerId, this, replay, this.group);\n    };\n    Layer.prototype.removeLayer = function (layerId) {\n        var _this = this;\n        // Remove all instances of the given id, not just the first one.\n        var parent = this.parent.removeLayer(layerId);\n        if (layerId === this.id) {\n            if (this.group.caching) {\n                // Dirty every ID we're removing. Technically we might be able to avoid\n                // dirtying fields that have values in higher layers, but we don't have\n                // easy access to higher layers here, and we're about to recreate those\n                // layers anyway (see parent.addLayer below).\n                Object.keys(this.data).forEach(function (dataId) {\n                    var ownStoreObject = _this.data[dataId];\n                    var parentStoreObject = parent[\"lookup\"](dataId);\n                    if (!parentStoreObject) {\n                        // The StoreObject identified by dataId was defined in this layer\n                        // but will be undefined in the parent layer, so we can delete the\n                        // whole entity using this.delete(dataId). Since we're about to\n                        // throw this layer away, the only goal of this deletion is to dirty\n                        // the removed fields.\n                        _this.delete(dataId);\n                    }\n                    else if (!ownStoreObject) {\n                        // This layer had an entry for dataId but it was undefined, which\n                        // means the entity was deleted in this layer, and it's about to\n                        // become undeleted when we remove this layer, so we need to dirty\n                        // all fields that are about to be reexposed.\n                        _this.group.dirty(dataId, \"__exists\");\n                        Object.keys(parentStoreObject).forEach(function (storeFieldName) {\n                            _this.group.dirty(dataId, storeFieldName);\n                        });\n                    }\n                    else if (ownStoreObject !== parentStoreObject) {\n                        // If ownStoreObject is not exactly the same as parentStoreObject,\n                        // dirty any fields whose values will change as a result of this\n                        // removal.\n                        Object.keys(ownStoreObject).forEach(function (storeFieldName) {\n                            if (!equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {\n                                _this.group.dirty(dataId, storeFieldName);\n                            }\n                        });\n                    }\n                });\n            }\n            return parent;\n        }\n        // No changes are necessary if the parent chain remains identical.\n        if (parent === this.parent)\n            return this;\n        // Recreate this layer on top of the new parent.\n        return parent.addLayer(this.id, this.replay);\n    };\n    Layer.prototype.toObject = function () {\n        return __assign(__assign({}, this.parent.toObject()), this.data);\n    };\n    Layer.prototype.findChildRefIds = function (dataId) {\n        var fromParent = this.parent.findChildRefIds(dataId);\n        return hasOwn.call(this.data, dataId) ? __assign(__assign({}, fromParent), _super.prototype.findChildRefIds.call(this, dataId)) : fromParent;\n    };\n    Layer.prototype.getStorage = function () {\n        var p = this.parent;\n        while (p.parent)\n            p = p.parent;\n        return p.getStorage.apply(p, \n        // @ts-expect-error\n        arguments);\n    };\n    return Layer;\n}(EntityStore));\n// Represents a Layer permanently installed just above the Root, which allows\n// reading optimistically (and registering optimistic dependencies) even when\n// no optimistic layers are currently active. The stump.group CacheGroup object\n// is shared by any/all Layer objects added on top of the Stump.\nvar Stump = /** @class */ (function (_super) {\n    __extends(Stump, _super);\n    function Stump(root) {\n        return _super.call(this, \"EntityStore.Stump\", root, function () { }, new CacheGroup(root.group.caching, root.group)) || this;\n    }\n    Stump.prototype.removeLayer = function () {\n        // Never remove the Stump layer.\n        return this;\n    };\n    Stump.prototype.merge = function (older, newer) {\n        // We never want to write any data into the Stump, so we forward any merge\n        // calls to the Root instead. Another option here would be to throw an\n        // exception, but the toReference(object, true) function can sometimes\n        // trigger Stump writes (which used to be Root writes, before the Stump\n        // concept was introduced).\n        return this.parent.merge(older, newer);\n    };\n    return Stump;\n}(Layer));\nfunction storeObjectReconciler(existingObject, incomingObject, property) {\n    var existingValue = existingObject[property];\n    var incomingValue = incomingObject[property];\n    // Wherever there is a key collision, prefer the incoming value, unless\n    // it is deeply equal to the existing value. It's worth checking deep\n    // equality here (even though blindly returning incoming would be\n    // logically correct) because preserving the referential identity of\n    // existing data can prevent needless rereading and rerendering.\n    return equal(existingValue, incomingValue) ? existingValue : incomingValue;\n}\nexport function supportsResultCaching(store) {\n    // When result caching is disabled, store.depend will be null.\n    return !!(store instanceof EntityStore && store.group.caching);\n}\n//# sourceMappingURL=entityStore.js.map","import { __assign } from \"tslib\";\nimport { Trie } from \"@wry/trie\";\nimport { canUseWeakMap, canUseWeakSet, isNonNullObject as isObjectOrArray, } from \"../../utilities/index.js\";\nimport { isArray } from \"./helpers.js\";\nfunction shallowCopy(value) {\n    if (isObjectOrArray(value)) {\n        return isArray(value) ?\n            value.slice(0)\n            : __assign({ __proto__: Object.getPrototypeOf(value) }, value);\n    }\n    return value;\n}\n// When programmers talk about the \"canonical form\" of an object, they\n// usually have the following meaning in mind, which I've copied from\n// https://en.wiktionary.org/wiki/canonical_form:\n//\n// 1. A standard or normal presentation of a mathematical entity [or\n//    object]. A canonical form is an element of a set of representatives\n//    of equivalence classes of forms such that there is a function or\n//    procedure which projects every element of each equivalence class\n//    onto that one element, the canonical form of that equivalence\n//    class. The canonical form is expected to be simpler than the rest of\n//    the forms in some way.\n//\n// That's a long-winded way of saying any two objects that have the same\n// canonical form may be considered equivalent, even if they are !==,\n// which usually means the objects are structurally equivalent (deeply\n// equal), but don't necessarily use the same memory.\n//\n// Like a literary or musical canon, this ObjectCanon class represents a\n// collection of unique canonical items (JavaScript objects), with the\n// important property that canon.admit(a) === canon.admit(b) if a and b\n// are deeply equal to each other. In terms of the definition above, the\n// canon.admit method is the \"function or procedure which projects every\"\n// object \"onto that one element, the canonical form.\"\n//\n// In the worst case, the canonicalization process may involve looking at\n// every property in the provided object tree, so it takes the same order\n// of time as deep equality checking. Fortunately, already-canonicalized\n// objects are returned immediately from canon.admit, so the presence of\n// canonical subtrees tends to speed up canonicalization.\n//\n// Since consumers of canonical objects can check for deep equality in\n// constant time, canonicalizing cache results can massively improve the\n// performance of application code that skips re-rendering unchanged\n// results, such as \"pure\" UI components in a framework like React.\n//\n// Of course, since canonical objects may be shared widely between\n// unrelated consumers, it's important to think of them as immutable, even\n// though they are not actually frozen with Object.freeze in production,\n// due to the extra performance overhead that comes with frozen objects.\n//\n// Custom scalar objects whose internal class name is neither Array nor\n// Object can be included safely in the admitted tree, but they will not\n// be replaced with a canonical version (to put it another way, they are\n// assumed to be canonical already).\n//\n// If we ignore custom objects, no detection of cycles or repeated object\n// references is currently required by the StoreReader class, since\n// GraphQL result objects are JSON-serializable trees (and thus contain\n// neither cycles nor repeated subtrees), so we can avoid the complexity\n// of keeping track of objects we've already seen during the recursion of\n// the admit method.\n//\n// In the future, we may consider adding additional cases to the switch\n// statement to handle other common object types, such as \"[object Date]\"\n// objects, as needed.\nvar ObjectCanon = /** @class */ (function () {\n    function ObjectCanon() {\n        // Set of all canonical objects this ObjectCanon has admitted, allowing\n        // canon.admit to return previously-canonicalized objects immediately.\n        this.known = new (canUseWeakSet ? WeakSet : Set)();\n        // Efficient storage/lookup structure for canonical objects.\n        this.pool = new Trie(canUseWeakMap);\n        // Make the ObjectCanon assume this value has already been\n        // canonicalized.\n        this.passes = new WeakMap();\n        // Arrays that contain the same elements in a different order can share\n        // the same SortedKeysInfo object, to save memory.\n        this.keysByJSON = new Map();\n        // This has to come last because it depends on keysByJSON.\n        this.empty = this.admit({});\n    }\n    ObjectCanon.prototype.isKnown = function (value) {\n        return isObjectOrArray(value) && this.known.has(value);\n    };\n    ObjectCanon.prototype.pass = function (value) {\n        if (isObjectOrArray(value)) {\n            var copy = shallowCopy(value);\n            this.passes.set(copy, value);\n            return copy;\n        }\n        return value;\n    };\n    ObjectCanon.prototype.admit = function (value) {\n        var _this = this;\n        if (isObjectOrArray(value)) {\n            var original = this.passes.get(value);\n            if (original)\n                return original;\n            var proto = Object.getPrototypeOf(value);\n            switch (proto) {\n                case Array.prototype: {\n                    if (this.known.has(value))\n                        return value;\n                    var array = value.map(this.admit, this);\n                    // Arrays are looked up in the Trie using their recursively\n                    // canonicalized elements, and the known version of the array is\n                    // preserved as node.array.\n                    var node = this.pool.lookupArray(array);\n                    if (!node.array) {\n                        this.known.add((node.array = array));\n                        // Since canonical arrays may be shared widely between\n                        // unrelated consumers, it's important to regard them as\n                        // immutable, even if they are not frozen in production.\n                        if (globalThis.__DEV__ !== false) {\n                            Object.freeze(array);\n                        }\n                    }\n                    return node.array;\n                }\n                case null:\n                case Object.prototype: {\n                    if (this.known.has(value))\n                        return value;\n                    var proto_1 = Object.getPrototypeOf(value);\n                    var array_1 = [proto_1];\n                    var keys = this.sortedKeys(value);\n                    array_1.push(keys.json);\n                    var firstValueIndex_1 = array_1.length;\n                    keys.sorted.forEach(function (key) {\n                        array_1.push(_this.admit(value[key]));\n                    });\n                    // Objects are looked up in the Trie by their prototype (which\n                    // is *not* recursively canonicalized), followed by a JSON\n                    // representation of their (sorted) keys, followed by the\n                    // sequence of recursively canonicalized values corresponding to\n                    // those keys. To keep the final results unambiguous with other\n                    // sequences (such as arrays that just happen to contain [proto,\n                    // keys.json, value1, value2, ...]), the known version of the\n                    // object is stored as node.object.\n                    var node = this.pool.lookupArray(array_1);\n                    if (!node.object) {\n                        var obj_1 = (node.object = Object.create(proto_1));\n                        this.known.add(obj_1);\n                        keys.sorted.forEach(function (key, i) {\n                            obj_1[key] = array_1[firstValueIndex_1 + i];\n                        });\n                        // Since canonical objects may be shared widely between\n                        // unrelated consumers, it's important to regard them as\n                        // immutable, even if they are not frozen in production.\n                        if (globalThis.__DEV__ !== false) {\n                            Object.freeze(obj_1);\n                        }\n                    }\n                    return node.object;\n                }\n            }\n        }\n        return value;\n    };\n    // It's worthwhile to cache the sorting of arrays of strings, since the\n    // same initial unsorted arrays tend to be encountered many times.\n    // Fortunately, we can reuse the Trie machinery to look up the sorted\n    // arrays in linear time (which is faster than sorting large arrays).\n    ObjectCanon.prototype.sortedKeys = function (obj) {\n        var keys = Object.keys(obj);\n        var node = this.pool.lookupArray(keys);\n        if (!node.keys) {\n            keys.sort();\n            var json = JSON.stringify(keys);\n            if (!(node.keys = this.keysByJSON.get(json))) {\n                this.keysByJSON.set(json, (node.keys = { sorted: keys, json: json }));\n            }\n        }\n        return node.keys;\n    };\n    return ObjectCanon;\n}());\nexport { ObjectCanon };\n//# sourceMappingURL=object-canon.js.map","import { __assign } from \"tslib\";\nimport { invariant, newInvariantError } from \"../../utilities/globals/index.js\";\nimport { Kind } from \"graphql\";\nimport { wrap } from \"optimism\";\nimport { isField, resultKeyNameFromField, isReference, makeReference, shouldInclude, addTypenameToDocument, getDefaultValues, getMainDefinition, getQueryDefinition, getFragmentFromSelection, maybeDeepFreeze, mergeDeepArray, DeepMerger, isNonNullObject, canUseWeakMap, compact, canonicalStringify, cacheSizes, } from \"../../utilities/index.js\";\nimport { maybeDependOnExistenceOfEntity, supportsResultCaching, } from \"./entityStore.js\";\nimport { isArray, extractFragmentContext, getTypenameFromStoreObject, shouldCanonizeResults, } from \"./helpers.js\";\nimport { MissingFieldError } from \"../core/types/common.js\";\nimport { ObjectCanon } from \"./object-canon.js\";\nfunction execSelectionSetKeyArgs(options) {\n    return [\n        options.selectionSet,\n        options.objectOrReference,\n        options.context,\n        // We split out this property so we can pass different values\n        // independently without modifying options.context itself.\n        options.context.canonizeResults,\n    ];\n}\nvar StoreReader = /** @class */ (function () {\n    function StoreReader(config) {\n        var _this = this;\n        this.knownResults = new (canUseWeakMap ? WeakMap : Map)();\n        this.config = compact(config, {\n            addTypename: config.addTypename !== false,\n            canonizeResults: shouldCanonizeResults(config),\n        });\n        this.canon = config.canon || new ObjectCanon();\n        // memoized functions in this class will be \"garbage-collected\"\n        // by recreating the whole `StoreReader` in\n        // `InMemoryCache.resetResultsCache`\n        // (triggered from `InMemoryCache.gc` with `resetResultCache: true`)\n        this.executeSelectionSet = wrap(function (options) {\n            var _a;\n            var canonizeResults = options.context.canonizeResults;\n            var peekArgs = execSelectionSetKeyArgs(options);\n            // Negate this boolean option so we can find out if we've already read\n            // this result using the other boolean value.\n            peekArgs[3] = !canonizeResults;\n            var other = (_a = _this.executeSelectionSet).peek.apply(_a, peekArgs);\n            if (other) {\n                if (canonizeResults) {\n                    return __assign(__assign({}, other), { \n                        // If we previously read this result without canonizing it, we can\n                        // reuse that result simply by canonizing it now.\n                        result: _this.canon.admit(other.result) });\n                }\n                // If we previously read this result with canonization enabled, we can\n                // return that canonized result as-is.\n                return other;\n            }\n            maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);\n            // Finally, if we didn't find any useful previous results, run the real\n            // execSelectionSetImpl method with the given options.\n            return _this.execSelectionSetImpl(options);\n        }, {\n            max: this.config.resultCacheMaxSize ||\n                cacheSizes[\"inMemoryCache.executeSelectionSet\"] ||\n                50000 /* defaultCacheSizes[\"inMemoryCache.executeSelectionSet\"] */,\n            keyArgs: execSelectionSetKeyArgs,\n            // Note that the parameters of makeCacheKey are determined by the\n            // array returned by keyArgs.\n            makeCacheKey: function (selectionSet, parent, context, canonizeResults) {\n                if (supportsResultCaching(context.store)) {\n                    return context.store.makeCacheKey(selectionSet, isReference(parent) ? parent.__ref : parent, context.varString, canonizeResults);\n                }\n            },\n        });\n        this.executeSubSelectedArray = wrap(function (options) {\n            maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);\n            return _this.execSubSelectedArrayImpl(options);\n        }, {\n            max: this.config.resultCacheMaxSize ||\n                cacheSizes[\"inMemoryCache.executeSubSelectedArray\"] ||\n                10000 /* defaultCacheSizes[\"inMemoryCache.executeSubSelectedArray\"] */,\n            makeCacheKey: function (_a) {\n                var field = _a.field, array = _a.array, context = _a.context;\n                if (supportsResultCaching(context.store)) {\n                    return context.store.makeCacheKey(field, array, context.varString);\n                }\n            },\n        });\n    }\n    StoreReader.prototype.resetCanon = function () {\n        this.canon = new ObjectCanon();\n    };\n    /**\n     * Given a store and a query, return as much of the result as possible and\n     * identify if any data was missing from the store.\n     */\n    StoreReader.prototype.diffQueryAgainstStore = function (_a) {\n        var store = _a.store, query = _a.query, _b = _a.rootId, rootId = _b === void 0 ? \"ROOT_QUERY\" : _b, variables = _a.variables, _c = _a.returnPartialData, returnPartialData = _c === void 0 ? true : _c, _d = _a.canonizeResults, canonizeResults = _d === void 0 ? this.config.canonizeResults : _d;\n        var policies = this.config.cache.policies;\n        variables = __assign(__assign({}, getDefaultValues(getQueryDefinition(query))), variables);\n        var rootRef = makeReference(rootId);\n        var execResult = this.executeSelectionSet({\n            selectionSet: getMainDefinition(query).selectionSet,\n            objectOrReference: rootRef,\n            enclosingRef: rootRef,\n            context: __assign({ store: store, query: query, policies: policies, variables: variables, varString: canonicalStringify(variables), canonizeResults: canonizeResults }, extractFragmentContext(query, this.config.fragments)),\n        });\n        var missing;\n        if (execResult.missing) {\n            // For backwards compatibility we still report an array of\n            // MissingFieldError objects, even though there will only ever be at most\n            // one of them, now that all missing field error messages are grouped\n            // together in the execResult.missing tree.\n            missing = [\n                new MissingFieldError(firstMissing(execResult.missing), execResult.missing, query, variables),\n            ];\n            if (!returnPartialData) {\n                throw missing[0];\n            }\n        }\n        return {\n            result: execResult.result,\n            complete: !missing,\n            missing: missing,\n        };\n    };\n    StoreReader.prototype.isFresh = function (result, parent, selectionSet, context) {\n        if (supportsResultCaching(context.store) &&\n            this.knownResults.get(result) === selectionSet) {\n            var latest = this.executeSelectionSet.peek(selectionSet, parent, context, \n            // If result is canonical, then it could only have been previously\n            // cached by the canonizing version of executeSelectionSet, so we can\n            // avoid checking both possibilities here.\n            this.canon.isKnown(result));\n            if (latest && result === latest.result) {\n                return true;\n            }\n        }\n        return false;\n    };\n    // Uncached version of executeSelectionSet.\n    StoreReader.prototype.execSelectionSetImpl = function (_a) {\n        var _this = this;\n        var selectionSet = _a.selectionSet, objectOrReference = _a.objectOrReference, enclosingRef = _a.enclosingRef, context = _a.context;\n        if (isReference(objectOrReference) &&\n            !context.policies.rootTypenamesById[objectOrReference.__ref] &&\n            !context.store.has(objectOrReference.__ref)) {\n            return {\n                result: this.canon.empty,\n                missing: \"Dangling reference to missing \".concat(objectOrReference.__ref, \" object\"),\n            };\n        }\n        var variables = context.variables, policies = context.policies, store = context.store;\n        var typename = store.getFieldValue(objectOrReference, \"__typename\");\n        var objectsToMerge = [];\n        var missing;\n        var missingMerger = new DeepMerger();\n        if (this.config.addTypename &&\n            typeof typename === \"string\" &&\n            !policies.rootIdsByTypename[typename]) {\n            // Ensure we always include a default value for the __typename\n            // field, if we have one, and this.config.addTypename is true. Note\n            // that this field can be overridden by other merged objects.\n            objectsToMerge.push({ __typename: typename });\n        }\n        function handleMissing(result, resultName) {\n            var _a;\n            if (result.missing) {\n                missing = missingMerger.merge(missing, (_a = {},\n                    _a[resultName] = result.missing,\n                    _a));\n            }\n            return result.result;\n        }\n        var workSet = new Set(selectionSet.selections);\n        workSet.forEach(function (selection) {\n            var _a, _b;\n            // Omit fields with directives @skip(if: <truthy value>) or\n            // @include(if: <falsy value>).\n            if (!shouldInclude(selection, variables))\n                return;\n            if (isField(selection)) {\n                var fieldValue = policies.readField({\n                    fieldName: selection.name.value,\n                    field: selection,\n                    variables: context.variables,\n                    from: objectOrReference,\n                }, context);\n                var resultName = resultKeyNameFromField(selection);\n                if (fieldValue === void 0) {\n                    if (!addTypenameToDocument.added(selection)) {\n                        missing = missingMerger.merge(missing, (_a = {},\n                            _a[resultName] = \"Can't find field '\".concat(selection.name.value, \"' on \").concat(isReference(objectOrReference) ?\n                                objectOrReference.__ref + \" object\"\n                                : \"object \" + JSON.stringify(objectOrReference, null, 2)),\n                            _a));\n                    }\n                }\n                else if (isArray(fieldValue)) {\n                    if (fieldValue.length > 0) {\n                        fieldValue = handleMissing(_this.executeSubSelectedArray({\n                            field: selection,\n                            array: fieldValue,\n                            enclosingRef: enclosingRef,\n                            context: context,\n                        }), resultName);\n                    }\n                }\n                else if (!selection.selectionSet) {\n                    // If the field does not have a selection set, then we handle it\n                    // as a scalar value. To keep this.canon from canonicalizing\n                    // this value, we use this.canon.pass to wrap fieldValue in a\n                    // Pass object that this.canon.admit will later unwrap as-is.\n                    if (context.canonizeResults) {\n                        fieldValue = _this.canon.pass(fieldValue);\n                    }\n                }\n                else if (fieldValue != null) {\n                    // In this case, because we know the field has a selection set,\n                    // it must be trying to query a GraphQLObjectType, which is why\n                    // fieldValue must be != null.\n                    fieldValue = handleMissing(_this.executeSelectionSet({\n                        selectionSet: selection.selectionSet,\n                        objectOrReference: fieldValue,\n                        enclosingRef: isReference(fieldValue) ? fieldValue : enclosingRef,\n                        context: context,\n                    }), resultName);\n                }\n                if (fieldValue !== void 0) {\n                    objectsToMerge.push((_b = {}, _b[resultName] = fieldValue, _b));\n                }\n            }\n            else {\n                var fragment = getFragmentFromSelection(selection, context.lookupFragment);\n                if (!fragment && selection.kind === Kind.FRAGMENT_SPREAD) {\n                    throw newInvariantError(9, selection.name.value);\n                }\n                if (fragment && policies.fragmentMatches(fragment, typename)) {\n                    fragment.selectionSet.selections.forEach(workSet.add, workSet);\n                }\n            }\n        });\n        var result = mergeDeepArray(objectsToMerge);\n        var finalResult = { result: result, missing: missing };\n        var frozen = context.canonizeResults ?\n            this.canon.admit(finalResult)\n            // Since this.canon is normally responsible for freezing results (only in\n            // development), freeze them manually if canonization is disabled.\n            : maybeDeepFreeze(finalResult);\n        // Store this result with its selection set so that we can quickly\n        // recognize it again in the StoreReader#isFresh method.\n        if (frozen.result) {\n            this.knownResults.set(frozen.result, selectionSet);\n        }\n        return frozen;\n    };\n    // Uncached version of executeSubSelectedArray.\n    StoreReader.prototype.execSubSelectedArrayImpl = function (_a) {\n        var _this = this;\n        var field = _a.field, array = _a.array, enclosingRef = _a.enclosingRef, context = _a.context;\n        var missing;\n        var missingMerger = new DeepMerger();\n        function handleMissing(childResult, i) {\n            var _a;\n            if (childResult.missing) {\n                missing = missingMerger.merge(missing, (_a = {}, _a[i] = childResult.missing, _a));\n            }\n            return childResult.result;\n        }\n        if (field.selectionSet) {\n            array = array.filter(context.store.canRead);\n        }\n        array = array.map(function (item, i) {\n            // null value in array\n            if (item === null) {\n                return null;\n            }\n            // This is a nested array, recurse\n            if (isArray(item)) {\n                return handleMissing(_this.executeSubSelectedArray({\n                    field: field,\n                    array: item,\n                    enclosingRef: enclosingRef,\n                    context: context,\n                }), i);\n            }\n            // This is an object, run the selection set on it\n            if (field.selectionSet) {\n                return handleMissing(_this.executeSelectionSet({\n                    selectionSet: field.selectionSet,\n                    objectOrReference: item,\n                    enclosingRef: isReference(item) ? item : enclosingRef,\n                    context: context,\n                }), i);\n            }\n            if (globalThis.__DEV__ !== false) {\n                assertSelectionSetForIdValue(context.store, field, item);\n            }\n            return item;\n        });\n        return {\n            result: context.canonizeResults ? this.canon.admit(array) : array,\n            missing: missing,\n        };\n    };\n    return StoreReader;\n}());\nexport { StoreReader };\nfunction firstMissing(tree) {\n    try {\n        JSON.stringify(tree, function (_, value) {\n            if (typeof value === \"string\")\n                throw value;\n            return value;\n        });\n    }\n    catch (result) {\n        return result;\n    }\n}\nfunction assertSelectionSetForIdValue(store, field, fieldValue) {\n    if (!field.selectionSet) {\n        var workSet_1 = new Set([fieldValue]);\n        workSet_1.forEach(function (value) {\n            if (isNonNullObject(value)) {\n                invariant(\n                    !isReference(value),\n                    10,\n                    getTypenameFromStoreObject(store, value),\n                    field.name.value\n                );\n                Object.values(value).forEach(workSet_1.add, workSet_1);\n            }\n        });\n    }\n}\n//# sourceMappingURL=readFromStore.js.map","import { invariant } from \"../../utilities/globals/index.js\";\nimport { argumentsObjectFromField, DeepMerger, isNonEmptyArray, isNonNullObject, } from \"../../utilities/index.js\";\nimport { hasOwn, isArray } from \"./helpers.js\";\n// Mapping from JSON-encoded KeySpecifier strings to associated information.\nvar specifierInfoCache = Object.create(null);\nfunction lookupSpecifierInfo(spec) {\n    // It's safe to encode KeySpecifier arrays with JSON.stringify, since they're\n    // just arrays of strings or nested KeySpecifier arrays, and the order of the\n    // array elements is important (and suitably preserved by JSON.stringify).\n    var cacheKey = JSON.stringify(spec);\n    return (specifierInfoCache[cacheKey] ||\n        (specifierInfoCache[cacheKey] = Object.create(null)));\n}\nexport function keyFieldsFnFromSpecifier(specifier) {\n    var info = lookupSpecifierInfo(specifier);\n    return (info.keyFieldsFn || (info.keyFieldsFn = function (object, context) {\n            var extract = function (from, key) {\n                return context.readField(key, from);\n            };\n            var keyObject = (context.keyObject = collectSpecifierPaths(specifier, function (schemaKeyPath) {\n                var extracted = extractKeyPath(context.storeObject, schemaKeyPath, \n                // Using context.readField to extract paths from context.storeObject\n                // allows the extraction to see through Reference objects and respect\n                // custom read functions.\n                extract);\n                if (extracted === void 0 &&\n                    object !== context.storeObject &&\n                    hasOwn.call(object, schemaKeyPath[0])) {\n                    // If context.storeObject fails to provide a value for the requested\n                    // path, fall back to the raw result object, if it has a top-level key\n                    // matching the first key in the path (schemaKeyPath[0]). This allows\n                    // key fields included in the written data to be saved in the cache\n                    // even if they are not selected explicitly in context.selectionSet.\n                    // Not being mentioned by context.selectionSet is convenient here,\n                    // since it means these extra fields cannot be affected by field\n                    // aliasing, which is why we can use extractKey instead of\n                    // context.readField for this extraction.\n                    extracted = extractKeyPath(object, schemaKeyPath, extractKey);\n                }\n                invariant(extracted !== void 0, 4, schemaKeyPath.join(\".\"), object);\n                return extracted;\n            }));\n            return \"\".concat(context.typename, \":\").concat(JSON.stringify(keyObject));\n        }));\n}\n// The keyArgs extraction process is roughly analogous to keyFields extraction,\n// but there are no aliases involved, missing fields are tolerated (by merely\n// omitting them from the key), and drawing from field.directives or variables\n// is allowed (in addition to drawing from the field's arguments object).\n// Concretely, these differences mean passing a different key path extractor\n// function to collectSpecifierPaths, reusing the shared extractKeyPath helper\n// wherever possible.\nexport function keyArgsFnFromSpecifier(specifier) {\n    var info = lookupSpecifierInfo(specifier);\n    return (info.keyArgsFn ||\n        (info.keyArgsFn = function (args, _a) {\n            var field = _a.field, variables = _a.variables, fieldName = _a.fieldName;\n            var collected = collectSpecifierPaths(specifier, function (keyPath) {\n                var firstKey = keyPath[0];\n                var firstChar = firstKey.charAt(0);\n                if (firstChar === \"@\") {\n                    if (field && isNonEmptyArray(field.directives)) {\n                        var directiveName_1 = firstKey.slice(1);\n                        // If the directive appears multiple times, only the first\n                        // occurrence's arguments will be used. TODO Allow repetition?\n                        // TODO Cache this work somehow, a la aliasMap?\n                        var d = field.directives.find(function (d) { return d.name.value === directiveName_1; });\n                        // Fortunately argumentsObjectFromField works for DirectiveNode!\n                        var directiveArgs = d && argumentsObjectFromField(d, variables);\n                        // For directives without arguments (d defined, but directiveArgs ===\n                        // null), the presence or absence of the directive still counts as\n                        // part of the field key, so we return null in those cases. If no\n                        // directive with this name was found for this field (d undefined and\n                        // thus directiveArgs undefined), we return undefined, which causes\n                        // this value to be omitted from the key object returned by\n                        // collectSpecifierPaths.\n                        return (directiveArgs &&\n                            extractKeyPath(directiveArgs, \n                            // If keyPath.length === 1, this code calls extractKeyPath with an\n                            // empty path, which works because it uses directiveArgs as the\n                            // extracted value.\n                            keyPath.slice(1)));\n                    }\n                    // If the key started with @ but there was no corresponding directive,\n                    // we want to omit this value from the key object, not fall through to\n                    // treating @whatever as a normal argument name.\n                    return;\n                }\n                if (firstChar === \"$\") {\n                    var variableName = firstKey.slice(1);\n                    if (variables && hasOwn.call(variables, variableName)) {\n                        var varKeyPath = keyPath.slice(0);\n                        varKeyPath[0] = variableName;\n                        return extractKeyPath(variables, varKeyPath);\n                    }\n                    // If the key started with $ but there was no corresponding variable, we\n                    // want to omit this value from the key object, not fall through to\n                    // treating $whatever as a normal argument name.\n                    return;\n                }\n                if (args) {\n                    return extractKeyPath(args, keyPath);\n                }\n            });\n            var suffix = JSON.stringify(collected);\n            // If no arguments were passed to this field, and it didn't have any other\n            // field key contributions from directives or variables, hide the empty\n            // :{} suffix from the field key. However, a field passed no arguments can\n            // still end up with a non-empty :{...} suffix if its key configuration\n            // refers to directives or variables.\n            if (args || suffix !== \"{}\") {\n                fieldName += \":\" + suffix;\n            }\n            return fieldName;\n        }));\n}\nexport function collectSpecifierPaths(specifier, extractor) {\n    // For each path specified by specifier, invoke the extractor, and repeatedly\n    // merge the results together, with appropriate ancestor context.\n    var merger = new DeepMerger();\n    return getSpecifierPaths(specifier).reduce(function (collected, path) {\n        var _a;\n        var toMerge = extractor(path);\n        if (toMerge !== void 0) {\n            // This path is not expected to contain array indexes, so the toMerge\n            // reconstruction will not contain arrays. TODO Fix this?\n            for (var i = path.length - 1; i >= 0; --i) {\n                toMerge = (_a = {}, _a[path[i]] = toMerge, _a);\n            }\n            collected = merger.merge(collected, toMerge);\n        }\n        return collected;\n    }, Object.create(null));\n}\nexport function getSpecifierPaths(spec) {\n    var info = lookupSpecifierInfo(spec);\n    if (!info.paths) {\n        var paths_1 = (info.paths = []);\n        var currentPath_1 = [];\n        spec.forEach(function (s, i) {\n            if (isArray(s)) {\n                getSpecifierPaths(s).forEach(function (p) { return paths_1.push(currentPath_1.concat(p)); });\n                currentPath_1.length = 0;\n            }\n            else {\n                currentPath_1.push(s);\n                if (!isArray(spec[i + 1])) {\n                    paths_1.push(currentPath_1.slice(0));\n                    currentPath_1.length = 0;\n                }\n            }\n        });\n    }\n    return info.paths;\n}\nfunction extractKey(object, key) {\n    return object[key];\n}\nexport function extractKeyPath(object, path, extract) {\n    // For each key in path, extract the corresponding child property from obj,\n    // flattening arrays if encountered (uncommon for keyFields and keyArgs, but\n    // possible). The final result of path.reduce is normalized so unexpected leaf\n    // objects have their keys safely sorted. That final result is difficult to\n    // type as anything other than any. You're welcome to try to improve the\n    // return type, but keep in mind extractKeyPath is not a public function\n    // (exported only for testing), so the effort may not be worthwhile unless the\n    // limited set of actual callers (see above) pass arguments that TypeScript\n    // can statically type. If we know only that path is some array of strings\n    // (and not, say, a specific tuple of statically known strings), any (or\n    // possibly unknown) is the honest answer.\n    extract = extract || extractKey;\n    return normalize(path.reduce(function reducer(obj, key) {\n        return isArray(obj) ?\n            obj.map(function (child) { return reducer(child, key); })\n            : obj && extract(obj, key);\n    }, object));\n}\nfunction normalize(value) {\n    // Usually the extracted value will be a scalar value, since most primary\n    // key fields are scalar, but just in case we get an object or an array, we\n    // need to do some normalization of the order of (nested) keys.\n    if (isNonNullObject(value)) {\n        if (isArray(value)) {\n            return value.map(normalize);\n        }\n        return collectSpecifierPaths(Object.keys(value).sort(), function (path) {\n            return extractKeyPath(value, path);\n        });\n    }\n    return value;\n}\n//# sourceMappingURL=key-extractor.js.map","import { __assign, __rest } from \"tslib\";\nimport { invariant, newInvariantError } from \"../../utilities/globals/index.js\";\nimport { storeKeyNameFromField, argumentsObjectFromField, isReference, getStoreKeyName, isNonNullObject, stringifyForDisplay, } from \"../../utilities/index.js\";\nimport { hasOwn, fieldNameFromStoreName, storeValueIsStoreObject, selectionSetMatchesResult, TypeOrFieldNameRegExp, defaultDataIdFromObject, isArray, } from \"./helpers.js\";\nimport { cacheSlot } from \"./reactiveVars.js\";\nimport { keyArgsFnFromSpecifier, keyFieldsFnFromSpecifier, } from \"./key-extractor.js\";\nfunction argsFromFieldSpecifier(spec) {\n    return (spec.args !== void 0 ? spec.args\n        : spec.field ? argumentsObjectFromField(spec.field, spec.variables)\n            : null);\n}\nvar nullKeyFieldsFn = function () { return void 0; };\nvar simpleKeyArgsFn = function (_args, context) { return context.fieldName; };\n// These merge functions can be selected by specifying merge:true or\n// merge:false in a field policy.\nvar mergeTrueFn = function (existing, incoming, _a) {\n    var mergeObjects = _a.mergeObjects;\n    return mergeObjects(existing, incoming);\n};\nvar mergeFalseFn = function (_, incoming) { return incoming; };\nvar Policies = /** @class */ (function () {\n    function Policies(config) {\n        this.config = config;\n        this.typePolicies = Object.create(null);\n        this.toBeAdded = Object.create(null);\n        // Map from subtype names to sets of supertype names. Note that this\n        // representation inverts the structure of possibleTypes (whose keys are\n        // supertypes and whose values are arrays of subtypes) because it tends\n        // to be much more efficient to search upwards than downwards.\n        this.supertypeMap = new Map();\n        // Any fuzzy subtypes specified by possibleTypes will be converted to\n        // RegExp objects and recorded here. Every key of this map can also be\n        // found in supertypeMap. In many cases this Map will be empty, which\n        // means no fuzzy subtype checking will happen in fragmentMatches.\n        this.fuzzySubtypes = new Map();\n        this.rootIdsByTypename = Object.create(null);\n        this.rootTypenamesById = Object.create(null);\n        this.usingPossibleTypes = false;\n        this.config = __assign({ dataIdFromObject: defaultDataIdFromObject }, config);\n        this.cache = this.config.cache;\n        this.setRootTypename(\"Query\");\n        this.setRootTypename(\"Mutation\");\n        this.setRootTypename(\"Subscription\");\n        if (config.possibleTypes) {\n            this.addPossibleTypes(config.possibleTypes);\n        }\n        if (config.typePolicies) {\n            this.addTypePolicies(config.typePolicies);\n        }\n    }\n    Policies.prototype.identify = function (object, partialContext) {\n        var _a;\n        var policies = this;\n        var typename = (partialContext &&\n            (partialContext.typename || ((_a = partialContext.storeObject) === null || _a === void 0 ? void 0 : _a.__typename))) ||\n            object.__typename;\n        // It should be possible to write root Query fields with writeFragment,\n        // using { __typename: \"Query\", ... } as the data, but it does not make\n        // sense to allow the same identification behavior for the Mutation and\n        // Subscription types, since application code should never be writing\n        // directly to (or reading directly from) those root objects.\n        if (typename === this.rootTypenamesById.ROOT_QUERY) {\n            return [\"ROOT_QUERY\"];\n        }\n        // Default context.storeObject to object if not otherwise provided.\n        var storeObject = (partialContext && partialContext.storeObject) || object;\n        var context = __assign(__assign({}, partialContext), { typename: typename, storeObject: storeObject, readField: (partialContext && partialContext.readField) ||\n                function () {\n                    var options = normalizeReadFieldOptions(arguments, storeObject);\n                    return policies.readField(options, {\n                        store: policies.cache[\"data\"],\n                        variables: options.variables,\n                    });\n                } });\n        var id;\n        var policy = typename && this.getTypePolicy(typename);\n        var keyFn = (policy && policy.keyFn) || this.config.dataIdFromObject;\n        while (keyFn) {\n            var specifierOrId = keyFn(__assign(__assign({}, object), storeObject), context);\n            if (isArray(specifierOrId)) {\n                keyFn = keyFieldsFnFromSpecifier(specifierOrId);\n            }\n            else {\n                id = specifierOrId;\n                break;\n            }\n        }\n        id = id ? String(id) : void 0;\n        return context.keyObject ? [id, context.keyObject] : [id];\n    };\n    Policies.prototype.addTypePolicies = function (typePolicies) {\n        var _this = this;\n        Object.keys(typePolicies).forEach(function (typename) {\n            var _a = typePolicies[typename], queryType = _a.queryType, mutationType = _a.mutationType, subscriptionType = _a.subscriptionType, incoming = __rest(_a, [\"queryType\", \"mutationType\", \"subscriptionType\"]);\n            // Though {query,mutation,subscription}Type configurations are rare,\n            // it's important to call setRootTypename as early as possible,\n            // since these configurations should apply consistently for the\n            // entire lifetime of the cache. Also, since only one __typename can\n            // qualify as one of these root types, these three properties cannot\n            // be inherited, unlike the rest of the incoming properties. That\n            // restriction is convenient, because the purpose of this.toBeAdded\n            // is to delay the processing of type/field policies until the first\n            // time they're used, allowing policies to be added in any order as\n            // long as all relevant policies (including policies for supertypes)\n            // have been added by the time a given policy is used for the first\n            // time. In other words, since inheritance doesn't matter for these\n            // properties, there's also no need to delay their processing using\n            // the this.toBeAdded queue.\n            if (queryType)\n                _this.setRootTypename(\"Query\", typename);\n            if (mutationType)\n                _this.setRootTypename(\"Mutation\", typename);\n            if (subscriptionType)\n                _this.setRootTypename(\"Subscription\", typename);\n            if (hasOwn.call(_this.toBeAdded, typename)) {\n                _this.toBeAdded[typename].push(incoming);\n            }\n            else {\n                _this.toBeAdded[typename] = [incoming];\n            }\n        });\n    };\n    Policies.prototype.updateTypePolicy = function (typename, incoming) {\n        var _this = this;\n        var existing = this.getTypePolicy(typename);\n        var keyFields = incoming.keyFields, fields = incoming.fields;\n        function setMerge(existing, merge) {\n            existing.merge =\n                typeof merge === \"function\" ? merge\n                    // Pass merge:true as a shorthand for a merge implementation\n                    // that returns options.mergeObjects(existing, incoming).\n                    : merge === true ? mergeTrueFn\n                        // Pass merge:false to make incoming always replace existing\n                        // without any warnings about data clobbering.\n                        : merge === false ? mergeFalseFn\n                            : existing.merge;\n        }\n        // Type policies can define merge functions, as an alternative to\n        // using field policies to merge child objects.\n        setMerge(existing, incoming.merge);\n        existing.keyFn =\n            // Pass false to disable normalization for this typename.\n            keyFields === false ? nullKeyFieldsFn\n                // Pass an array of strings to use those fields to compute a\n                // composite ID for objects of this typename.\n                : isArray(keyFields) ? keyFieldsFnFromSpecifier(keyFields)\n                    // Pass a function to take full control over identification.\n                    : typeof keyFields === \"function\" ? keyFields\n                        // Leave existing.keyFn unchanged if above cases fail.\n                        : existing.keyFn;\n        if (fields) {\n            Object.keys(fields).forEach(function (fieldName) {\n                var existing = _this.getFieldPolicy(typename, fieldName, true);\n                var incoming = fields[fieldName];\n                if (typeof incoming === \"function\") {\n                    existing.read = incoming;\n                }\n                else {\n                    var keyArgs = incoming.keyArgs, read = incoming.read, merge = incoming.merge;\n                    existing.keyFn =\n                        // Pass false to disable argument-based differentiation of\n                        // field identities.\n                        keyArgs === false ? simpleKeyArgsFn\n                            // Pass an array of strings to use named arguments to\n                            // compute a composite identity for the field.\n                            : isArray(keyArgs) ? keyArgsFnFromSpecifier(keyArgs)\n                                // Pass a function to take full control over field identity.\n                                : typeof keyArgs === \"function\" ? keyArgs\n                                    // Leave existing.keyFn unchanged if above cases fail.\n                                    : existing.keyFn;\n                    if (typeof read === \"function\") {\n                        existing.read = read;\n                    }\n                    setMerge(existing, merge);\n                }\n                if (existing.read && existing.merge) {\n                    // If we have both a read and a merge function, assume\n                    // keyArgs:false, because read and merge together can take\n                    // responsibility for interpreting arguments in and out. This\n                    // default assumption can always be overridden by specifying\n                    // keyArgs explicitly in the FieldPolicy.\n                    existing.keyFn = existing.keyFn || simpleKeyArgsFn;\n                }\n            });\n        }\n    };\n    Policies.prototype.setRootTypename = function (which, typename) {\n        if (typename === void 0) { typename = which; }\n        var rootId = \"ROOT_\" + which.toUpperCase();\n        var old = this.rootTypenamesById[rootId];\n        if (typename !== old) {\n            invariant(!old || old === which, 5, which);\n            // First, delete any old __typename associated with this rootId from\n            // rootIdsByTypename.\n            if (old)\n                delete this.rootIdsByTypename[old];\n            // Now make this the only __typename that maps to this rootId.\n            this.rootIdsByTypename[typename] = rootId;\n            // Finally, update the __typename associated with this rootId.\n            this.rootTypenamesById[rootId] = typename;\n        }\n    };\n    Policies.prototype.addPossibleTypes = function (possibleTypes) {\n        var _this = this;\n        this.usingPossibleTypes = true;\n        Object.keys(possibleTypes).forEach(function (supertype) {\n            // Make sure all types have an entry in this.supertypeMap, even if\n            // their supertype set is empty, so we can return false immediately\n            // from policies.fragmentMatches for unknown supertypes.\n            _this.getSupertypeSet(supertype, true);\n            possibleTypes[supertype].forEach(function (subtype) {\n                _this.getSupertypeSet(subtype, true).add(supertype);\n                var match = subtype.match(TypeOrFieldNameRegExp);\n                if (!match || match[0] !== subtype) {\n                    // TODO Don't interpret just any invalid typename as a RegExp.\n                    _this.fuzzySubtypes.set(subtype, new RegExp(subtype));\n                }\n            });\n        });\n    };\n    Policies.prototype.getTypePolicy = function (typename) {\n        var _this = this;\n        if (!hasOwn.call(this.typePolicies, typename)) {\n            var policy_1 = (this.typePolicies[typename] = Object.create(null));\n            policy_1.fields = Object.create(null);\n            // When the TypePolicy for typename is first accessed, instead of\n            // starting with an empty policy object, inherit any properties or\n            // fields from the type policies of the supertypes of typename.\n            //\n            // Any properties or fields defined explicitly within the TypePolicy\n            // for typename will take precedence, and if there are multiple\n            // supertypes, the properties of policies whose types were added\n            // later via addPossibleTypes will take precedence over those of\n            // earlier supertypes. TODO Perhaps we should warn about these\n            // conflicts in development, and recommend defining the property\n            // explicitly in the subtype policy?\n            //\n            // Field policy inheritance is atomic/shallow: you can't inherit a\n            // field policy and then override just its read function, since read\n            // and merge functions often need to cooperate, so changing only one\n            // of them would be a recipe for inconsistency.\n            //\n            // Once the TypePolicy for typename has been accessed, its properties can\n            // still be updated directly using addTypePolicies, but future changes to\n            // inherited supertype policies will not be reflected in this subtype\n            // policy, because this code runs at most once per typename.\n            var supertypes_1 = this.supertypeMap.get(typename);\n            if (!supertypes_1 && this.fuzzySubtypes.size) {\n                // To make the inheritance logic work for unknown typename strings that\n                // may have fuzzy supertypes, we give this typename an empty supertype\n                // set and then populate it with any fuzzy supertypes that match.\n                supertypes_1 = this.getSupertypeSet(typename, true);\n                // This only works for typenames that are directly matched by a fuzzy\n                // supertype. What if there is an intermediate chain of supertypes?\n                // While possible, that situation can only be solved effectively by\n                // specifying the intermediate relationships via possibleTypes, manually\n                // and in a non-fuzzy way.\n                this.fuzzySubtypes.forEach(function (regExp, fuzzy) {\n                    if (regExp.test(typename)) {\n                        // The fuzzy parameter is just the original string version of regExp\n                        // (not a valid __typename string), but we can look up the\n                        // associated supertype(s) in this.supertypeMap.\n                        var fuzzySupertypes = _this.supertypeMap.get(fuzzy);\n                        if (fuzzySupertypes) {\n                            fuzzySupertypes.forEach(function (supertype) {\n                                return supertypes_1.add(supertype);\n                            });\n                        }\n                    }\n                });\n            }\n            if (supertypes_1 && supertypes_1.size) {\n                supertypes_1.forEach(function (supertype) {\n                    var _a = _this.getTypePolicy(supertype), fields = _a.fields, rest = __rest(_a, [\"fields\"]);\n                    Object.assign(policy_1, rest);\n                    Object.assign(policy_1.fields, fields);\n                });\n            }\n        }\n        var inbox = this.toBeAdded[typename];\n        if (inbox && inbox.length) {\n            // Merge the pending policies into this.typePolicies, in the order they\n            // were originally passed to addTypePolicy.\n            inbox.splice(0).forEach(function (policy) {\n                _this.updateTypePolicy(typename, policy);\n            });\n        }\n        return this.typePolicies[typename];\n    };\n    Policies.prototype.getFieldPolicy = function (typename, fieldName, createIfMissing) {\n        if (typename) {\n            var fieldPolicies = this.getTypePolicy(typename).fields;\n            return (fieldPolicies[fieldName] ||\n                (createIfMissing && (fieldPolicies[fieldName] = Object.create(null))));\n        }\n    };\n    Policies.prototype.getSupertypeSet = function (subtype, createIfMissing) {\n        var supertypeSet = this.supertypeMap.get(subtype);\n        if (!supertypeSet && createIfMissing) {\n            this.supertypeMap.set(subtype, (supertypeSet = new Set()));\n        }\n        return supertypeSet;\n    };\n    Policies.prototype.fragmentMatches = function (fragment, typename, result, variables) {\n        var _this = this;\n        if (!fragment.typeCondition)\n            return true;\n        // If the fragment has a type condition but the object we're matching\n        // against does not have a __typename, the fragment cannot match.\n        if (!typename)\n            return false;\n        var supertype = fragment.typeCondition.name.value;\n        // Common case: fragment type condition and __typename are the same.\n        if (typename === supertype)\n            return true;\n        if (this.usingPossibleTypes && this.supertypeMap.has(supertype)) {\n            var typenameSupertypeSet = this.getSupertypeSet(typename, true);\n            var workQueue_1 = [typenameSupertypeSet];\n            var maybeEnqueue_1 = function (subtype) {\n                var supertypeSet = _this.getSupertypeSet(subtype, false);\n                if (supertypeSet &&\n                    supertypeSet.size &&\n                    workQueue_1.indexOf(supertypeSet) < 0) {\n                    workQueue_1.push(supertypeSet);\n                }\n            };\n            // We need to check fuzzy subtypes only if we encountered fuzzy\n            // subtype strings in addPossibleTypes, and only while writing to\n            // the cache, since that's when selectionSetMatchesResult gives a\n            // strong signal of fragment matching. The StoreReader class calls\n            // policies.fragmentMatches without passing a result object, so\n            // needToCheckFuzzySubtypes is always false while reading.\n            var needToCheckFuzzySubtypes = !!(result && this.fuzzySubtypes.size);\n            var checkingFuzzySubtypes = false;\n            // It's important to keep evaluating workQueue.length each time through\n            // the loop, because the queue can grow while we're iterating over it.\n            for (var i = 0; i < workQueue_1.length; ++i) {\n                var supertypeSet = workQueue_1[i];\n                if (supertypeSet.has(supertype)) {\n                    if (!typenameSupertypeSet.has(supertype)) {\n                        if (checkingFuzzySubtypes) {\n                            globalThis.__DEV__ !== false && invariant.warn(6, typename, supertype);\n                        }\n                        // Record positive results for faster future lookup.\n                        // Unfortunately, we cannot safely cache negative results,\n                        // because new possibleTypes data could always be added to the\n                        // Policies class.\n                        typenameSupertypeSet.add(supertype);\n                    }\n                    return true;\n                }\n                supertypeSet.forEach(maybeEnqueue_1);\n                if (needToCheckFuzzySubtypes &&\n                    // Start checking fuzzy subtypes only after exhausting all\n                    // non-fuzzy subtypes (after the final iteration of the loop).\n                    i === workQueue_1.length - 1 &&\n                    // We could wait to compare fragment.selectionSet to result\n                    // after we verify the supertype, but this check is often less\n                    // expensive than that search, and we will have to do the\n                    // comparison anyway whenever we find a potential match.\n                    selectionSetMatchesResult(fragment.selectionSet, result, variables)) {\n                    // We don't always need to check fuzzy subtypes (if no result\n                    // was provided, or !this.fuzzySubtypes.size), but, when we do,\n                    // we only want to check them once.\n                    needToCheckFuzzySubtypes = false;\n                    checkingFuzzySubtypes = true;\n                    // If we find any fuzzy subtypes that match typename, extend the\n                    // workQueue to search through the supertypes of those fuzzy\n                    // subtypes. Otherwise the for-loop will terminate and we'll\n                    // return false below.\n                    this.fuzzySubtypes.forEach(function (regExp, fuzzyString) {\n                        var match = typename.match(regExp);\n                        if (match && match[0] === typename) {\n                            maybeEnqueue_1(fuzzyString);\n                        }\n                    });\n                }\n            }\n        }\n        return false;\n    };\n    Policies.prototype.hasKeyArgs = function (typename, fieldName) {\n        var policy = this.getFieldPolicy(typename, fieldName, false);\n        return !!(policy && policy.keyFn);\n    };\n    Policies.prototype.getStoreFieldName = function (fieldSpec) {\n        var typename = fieldSpec.typename, fieldName = fieldSpec.fieldName;\n        var policy = this.getFieldPolicy(typename, fieldName, false);\n        var storeFieldName;\n        var keyFn = policy && policy.keyFn;\n        if (keyFn && typename) {\n            var context = {\n                typename: typename,\n                fieldName: fieldName,\n                field: fieldSpec.field || null,\n                variables: fieldSpec.variables,\n            };\n            var args = argsFromFieldSpecifier(fieldSpec);\n            while (keyFn) {\n                var specifierOrString = keyFn(args, context);\n                if (isArray(specifierOrString)) {\n                    keyFn = keyArgsFnFromSpecifier(specifierOrString);\n                }\n                else {\n                    // If the custom keyFn returns a falsy value, fall back to\n                    // fieldName instead.\n                    storeFieldName = specifierOrString || fieldName;\n                    break;\n                }\n            }\n        }\n        if (storeFieldName === void 0) {\n            storeFieldName =\n                fieldSpec.field ?\n                    storeKeyNameFromField(fieldSpec.field, fieldSpec.variables)\n                    : getStoreKeyName(fieldName, argsFromFieldSpecifier(fieldSpec));\n        }\n        // Returning false from a keyArgs function is like configuring\n        // keyArgs: false, but more dynamic.\n        if (storeFieldName === false) {\n            return fieldName;\n        }\n        // Make sure custom field names start with the actual field.name.value\n        // of the field, so we can always figure out which properties of a\n        // StoreObject correspond to which original field names.\n        return fieldName === fieldNameFromStoreName(storeFieldName) ? storeFieldName\n            : fieldName + \":\" + storeFieldName;\n    };\n    Policies.prototype.readField = function (options, context) {\n        var objectOrReference = options.from;\n        if (!objectOrReference)\n            return;\n        var nameOrField = options.field || options.fieldName;\n        if (!nameOrField)\n            return;\n        if (options.typename === void 0) {\n            var typename = context.store.getFieldValue(objectOrReference, \"__typename\");\n            if (typename)\n                options.typename = typename;\n        }\n        var storeFieldName = this.getStoreFieldName(options);\n        var fieldName = fieldNameFromStoreName(storeFieldName);\n        var existing = context.store.getFieldValue(objectOrReference, storeFieldName);\n        var policy = this.getFieldPolicy(options.typename, fieldName, false);\n        var read = policy && policy.read;\n        if (read) {\n            var readOptions = makeFieldFunctionOptions(this, objectOrReference, options, context, context.store.getStorage(isReference(objectOrReference) ?\n                objectOrReference.__ref\n                : objectOrReference, storeFieldName));\n            // Call read(existing, readOptions) with cacheSlot holding this.cache.\n            return cacheSlot.withValue(this.cache, read, [\n                existing,\n                readOptions,\n            ]);\n        }\n        return existing;\n    };\n    Policies.prototype.getReadFunction = function (typename, fieldName) {\n        var policy = this.getFieldPolicy(typename, fieldName, false);\n        return policy && policy.read;\n    };\n    Policies.prototype.getMergeFunction = function (parentTypename, fieldName, childTypename) {\n        var policy = this.getFieldPolicy(parentTypename, fieldName, false);\n        var merge = policy && policy.merge;\n        if (!merge && childTypename) {\n            policy = this.getTypePolicy(childTypename);\n            merge = policy && policy.merge;\n        }\n        return merge;\n    };\n    Policies.prototype.runMergeFunction = function (existing, incoming, _a, context, storage) {\n        var field = _a.field, typename = _a.typename, merge = _a.merge;\n        if (merge === mergeTrueFn) {\n            // Instead of going to the trouble of creating a full\n            // FieldFunctionOptions object and calling mergeTrueFn, we can\n            // simply call mergeObjects, as mergeTrueFn would.\n            return makeMergeObjectsFunction(context.store)(existing, incoming);\n        }\n        if (merge === mergeFalseFn) {\n            // Likewise for mergeFalseFn, whose implementation is even simpler.\n            return incoming;\n        }\n        // If cache.writeQuery or cache.writeFragment was called with\n        // options.overwrite set to true, we still call merge functions, but\n        // the existing data is always undefined, so the merge function will\n        // not attempt to combine the incoming data with the existing data.\n        if (context.overwrite) {\n            existing = void 0;\n        }\n        return merge(existing, incoming, makeFieldFunctionOptions(this, \n        // Unlike options.readField for read functions, we do not fall\n        // back to the current object if no foreignObjOrRef is provided,\n        // because it's not clear what the current object should be for\n        // merge functions: the (possibly undefined) existing object, or\n        // the incoming object? If you think your merge function needs\n        // to read sibling fields in order to produce a new value for\n        // the current field, you might want to rethink your strategy,\n        // because that's a recipe for making merge behavior sensitive\n        // to the order in which fields are written into the cache.\n        // However, readField(name, ref) is useful for merge functions\n        // that need to deduplicate child objects and references.\n        void 0, {\n            typename: typename,\n            fieldName: field.name.value,\n            field: field,\n            variables: context.variables,\n        }, context, storage || Object.create(null)));\n    };\n    return Policies;\n}());\nexport { Policies };\nfunction makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, context, storage) {\n    var storeFieldName = policies.getStoreFieldName(fieldSpec);\n    var fieldName = fieldNameFromStoreName(storeFieldName);\n    var variables = fieldSpec.variables || context.variables;\n    var _a = context.store, toReference = _a.toReference, canRead = _a.canRead;\n    return {\n        args: argsFromFieldSpecifier(fieldSpec),\n        field: fieldSpec.field || null,\n        fieldName: fieldName,\n        storeFieldName: storeFieldName,\n        variables: variables,\n        isReference: isReference,\n        toReference: toReference,\n        storage: storage,\n        cache: policies.cache,\n        canRead: canRead,\n        readField: function () {\n            return policies.readField(normalizeReadFieldOptions(arguments, objectOrReference, variables), context);\n        },\n        mergeObjects: makeMergeObjectsFunction(context.store),\n    };\n}\nexport function normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables) {\n    var fieldNameOrOptions = readFieldArgs[0], from = readFieldArgs[1], argc = readFieldArgs.length;\n    var options;\n    if (typeof fieldNameOrOptions === \"string\") {\n        options = {\n            fieldName: fieldNameOrOptions,\n            // Default to objectOrReference only when no second argument was\n            // passed for the from parameter, not when undefined is explicitly\n            // passed as the second argument.\n            from: argc > 1 ? from : objectOrReference,\n        };\n    }\n    else {\n        options = __assign({}, fieldNameOrOptions);\n        // Default to objectOrReference only when fieldNameOrOptions.from is\n        // actually omitted, rather than just undefined.\n        if (!hasOwn.call(options, \"from\")) {\n            options.from = objectOrReference;\n        }\n    }\n    if (globalThis.__DEV__ !== false && options.from === void 0) {\n        globalThis.__DEV__ !== false && invariant.warn(7, stringifyForDisplay(Array.from(readFieldArgs)));\n    }\n    if (void 0 === options.variables) {\n        options.variables = variables;\n    }\n    return options;\n}\nfunction makeMergeObjectsFunction(store) {\n    return function mergeObjects(existing, incoming) {\n        if (isArray(existing) || isArray(incoming)) {\n            throw newInvariantError(8);\n        }\n        // These dynamic checks are necessary because the parameters of a\n        // custom merge function can easily have the any type, so the type\n        // system cannot always enforce the StoreObject | Reference parameter\n        // types of options.mergeObjects.\n        if (isNonNullObject(existing) && isNonNullObject(incoming)) {\n            var eType = store.getFieldValue(existing, \"__typename\");\n            var iType = store.getFieldValue(incoming, \"__typename\");\n            var typesDiffer = eType && iType && eType !== iType;\n            if (typesDiffer) {\n                return incoming;\n            }\n            if (isReference(existing) && storeValueIsStoreObject(incoming)) {\n                // Update the normalized EntityStore for the entity identified by\n                // existing.__ref, preferring/overwriting any fields contributed by the\n                // newer incoming StoreObject.\n                store.merge(existing.__ref, incoming);\n                return existing;\n            }\n            if (storeValueIsStoreObject(existing) && isReference(incoming)) {\n                // Update the normalized EntityStore for the entity identified by\n                // incoming.__ref, taking fields from the older existing object only if\n                // those fields are not already present in the newer StoreObject\n                // identified by incoming.__ref.\n                store.merge(existing, incoming.__ref);\n                return incoming;\n            }\n            if (storeValueIsStoreObject(existing) &&\n                storeValueIsStoreObject(incoming)) {\n                return __assign(__assign({}, existing), incoming);\n            }\n        }\n        return incoming;\n    };\n}\n//# sourceMappingURL=policies.js.map","import { __assign } from \"tslib\";\nimport { invariant, newInvariantError } from \"../../utilities/globals/index.js\";\nimport { equal } from \"@wry/equality\";\nimport { Trie } from \"@wry/trie\";\nimport { Kind } from \"graphql\";\nimport { getFragmentFromSelection, getDefaultValues, getOperationDefinition, getTypenameFromResult, makeReference, isField, resultKeyNameFromField, isReference, shouldInclude, cloneDeep, addTypenameToDocument, isNonEmptyArray, argumentsObjectFromField, canonicalStringify, } from \"../../utilities/index.js\";\nimport { isArray, makeProcessedFieldsMerger, fieldNameFromStoreName, storeValueIsStoreObject, extractFragmentContext, } from \"./helpers.js\";\nimport { normalizeReadFieldOptions } from \"./policies.js\";\n// Since there are only four possible combinations of context.clientOnly and\n// context.deferred values, we should need at most four \"flavors\" of any given\n// WriteContext. To avoid creating multiple copies of the same context, we cache\n// the contexts in the context.flavors Map (shared by all flavors) according to\n// their clientOnly and deferred values (always in that order).\nfunction getContextFlavor(context, clientOnly, deferred) {\n    var key = \"\".concat(clientOnly).concat(deferred);\n    var flavored = context.flavors.get(key);\n    if (!flavored) {\n        context.flavors.set(key, (flavored =\n            context.clientOnly === clientOnly && context.deferred === deferred ?\n                context\n                : __assign(__assign({}, context), { clientOnly: clientOnly, deferred: deferred })));\n    }\n    return flavored;\n}\nvar StoreWriter = /** @class */ (function () {\n    function StoreWriter(cache, reader, fragments) {\n        this.cache = cache;\n        this.reader = reader;\n        this.fragments = fragments;\n    }\n    StoreWriter.prototype.writeToStore = function (store, _a) {\n        var _this = this;\n        var query = _a.query, result = _a.result, dataId = _a.dataId, variables = _a.variables, overwrite = _a.overwrite;\n        var operationDefinition = getOperationDefinition(query);\n        var merger = makeProcessedFieldsMerger();\n        variables = __assign(__assign({}, getDefaultValues(operationDefinition)), variables);\n        var context = __assign(__assign({ store: store, written: Object.create(null), merge: function (existing, incoming) {\n                return merger.merge(existing, incoming);\n            }, variables: variables, varString: canonicalStringify(variables) }, extractFragmentContext(query, this.fragments)), { overwrite: !!overwrite, incomingById: new Map(), clientOnly: false, deferred: false, flavors: new Map() });\n        var ref = this.processSelectionSet({\n            result: result || Object.create(null),\n            dataId: dataId,\n            selectionSet: operationDefinition.selectionSet,\n            mergeTree: { map: new Map() },\n            context: context,\n        });\n        if (!isReference(ref)) {\n            throw newInvariantError(11, result);\n        }\n        // So far, the store has not been modified, so now it's time to process\n        // context.incomingById and merge those incoming fields into context.store.\n        context.incomingById.forEach(function (_a, dataId) {\n            var storeObject = _a.storeObject, mergeTree = _a.mergeTree, fieldNodeSet = _a.fieldNodeSet;\n            var entityRef = makeReference(dataId);\n            if (mergeTree && mergeTree.map.size) {\n                var applied = _this.applyMerges(mergeTree, entityRef, storeObject, context);\n                if (isReference(applied)) {\n                    // Assume References returned by applyMerges have already been merged\n                    // into the store. See makeMergeObjectsFunction in policies.ts for an\n                    // example of how this can happen.\n                    return;\n                }\n                // Otherwise, applyMerges returned a StoreObject, whose fields we should\n                // merge into the store (see store.merge statement below).\n                storeObject = applied;\n            }\n            if (globalThis.__DEV__ !== false && !context.overwrite) {\n                var fieldsWithSelectionSets_1 = Object.create(null);\n                fieldNodeSet.forEach(function (field) {\n                    if (field.selectionSet) {\n                        fieldsWithSelectionSets_1[field.name.value] = true;\n                    }\n                });\n                var hasSelectionSet_1 = function (storeFieldName) {\n                    return fieldsWithSelectionSets_1[fieldNameFromStoreName(storeFieldName)] ===\n                        true;\n                };\n                var hasMergeFunction_1 = function (storeFieldName) {\n                    var childTree = mergeTree && mergeTree.map.get(storeFieldName);\n                    return Boolean(childTree && childTree.info && childTree.info.merge);\n                };\n                Object.keys(storeObject).forEach(function (storeFieldName) {\n                    // If a merge function was defined for this field, trust that it\n                    // did the right thing about (not) clobbering data. If the field\n                    // has no selection set, it's a scalar field, so it doesn't need\n                    // a merge function (even if it's an object, like JSON data).\n                    if (hasSelectionSet_1(storeFieldName) &&\n                        !hasMergeFunction_1(storeFieldName)) {\n                        warnAboutDataLoss(entityRef, storeObject, storeFieldName, context.store);\n                    }\n                });\n            }\n            store.merge(dataId, storeObject);\n        });\n        // Any IDs written explicitly to the cache will be retained as\n        // reachable root IDs for garbage collection purposes. Although this\n        // logic includes root IDs like ROOT_QUERY and ROOT_MUTATION, their\n        // retainment counts are effectively ignored because cache.gc() always\n        // includes them in its root ID set.\n        store.retain(ref.__ref);\n        return ref;\n    };\n    StoreWriter.prototype.processSelectionSet = function (_a) {\n        var _this = this;\n        var dataId = _a.dataId, result = _a.result, selectionSet = _a.selectionSet, context = _a.context, \n        // This object allows processSelectionSet to report useful information\n        // to its callers without explicitly returning that information.\n        mergeTree = _a.mergeTree;\n        var policies = this.cache.policies;\n        // This variable will be repeatedly updated using context.merge to\n        // accumulate all fields that need to be written into the store.\n        var incoming = Object.create(null);\n        // If typename was not passed in, infer it. Note that typename is\n        // always passed in for tricky-to-infer cases such as \"Query\" for\n        // ROOT_QUERY.\n        var typename = (dataId && policies.rootTypenamesById[dataId]) ||\n            getTypenameFromResult(result, selectionSet, context.fragmentMap) ||\n            (dataId && context.store.get(dataId, \"__typename\"));\n        if (\"string\" === typeof typename) {\n            incoming.__typename = typename;\n        }\n        // This readField function will be passed as context.readField in the\n        // KeyFieldsContext object created within policies.identify (called below).\n        // In addition to reading from the existing context.store (thanks to the\n        // policies.readField(options, context) line at the very bottom), this\n        // version of readField can read from Reference objects that are currently\n        // pending in context.incomingById, which is important whenever keyFields\n        // need to be extracted from a child object that processSelectionSet has\n        // turned into a Reference.\n        var readField = function () {\n            var options = normalizeReadFieldOptions(arguments, incoming, context.variables);\n            if (isReference(options.from)) {\n                var info = context.incomingById.get(options.from.__ref);\n                if (info) {\n                    var result_1 = policies.readField(__assign(__assign({}, options), { from: info.storeObject }), context);\n                    if (result_1 !== void 0) {\n                        return result_1;\n                    }\n                }\n            }\n            return policies.readField(options, context);\n        };\n        var fieldNodeSet = new Set();\n        this.flattenFields(selectionSet, result, \n        // This WriteContext will be the default context value for fields returned\n        // by the flattenFields method, but some fields may be assigned a modified\n        // context, depending on the presence of @client and other directives.\n        context, typename).forEach(function (context, field) {\n            var _a;\n            var resultFieldKey = resultKeyNameFromField(field);\n            var value = result[resultFieldKey];\n            fieldNodeSet.add(field);\n            if (value !== void 0) {\n                var storeFieldName = policies.getStoreFieldName({\n                    typename: typename,\n                    fieldName: field.name.value,\n                    field: field,\n                    variables: context.variables,\n                });\n                var childTree = getChildMergeTree(mergeTree, storeFieldName);\n                var incomingValue = _this.processFieldValue(value, field, \n                // Reset context.clientOnly and context.deferred to their default\n                // values before processing nested selection sets.\n                field.selectionSet ?\n                    getContextFlavor(context, false, false)\n                    : context, childTree);\n                // To determine if this field holds a child object with a merge function\n                // defined in its type policy (see PR #7070), we need to figure out the\n                // child object's __typename.\n                var childTypename = void 0;\n                // The field's value can be an object that has a __typename only if the\n                // field has a selection set. Otherwise incomingValue is scalar.\n                if (field.selectionSet &&\n                    (isReference(incomingValue) || storeValueIsStoreObject(incomingValue))) {\n                    childTypename = readField(\"__typename\", incomingValue);\n                }\n                var merge = policies.getMergeFunction(typename, field.name.value, childTypename);\n                if (merge) {\n                    childTree.info = {\n                        // TODO Check compatibility against any existing childTree.field?\n                        field: field,\n                        typename: typename,\n                        merge: merge,\n                    };\n                }\n                else {\n                    maybeRecycleChildMergeTree(mergeTree, storeFieldName);\n                }\n                incoming = context.merge(incoming, (_a = {},\n                    _a[storeFieldName] = incomingValue,\n                    _a));\n            }\n            else if (globalThis.__DEV__ !== false &&\n                !context.clientOnly &&\n                !context.deferred &&\n                !addTypenameToDocument.added(field) &&\n                // If the field has a read function, it may be a synthetic field or\n                // provide a default value, so its absence from the written data should\n                // not be cause for alarm.\n                !policies.getReadFunction(typename, field.name.value)) {\n                globalThis.__DEV__ !== false && invariant.error(12, resultKeyNameFromField(field), result);\n            }\n        });\n        // Identify the result object, even if dataId was already provided,\n        // since we always need keyObject below.\n        try {\n            var _b = policies.identify(result, {\n                typename: typename,\n                selectionSet: selectionSet,\n                fragmentMap: context.fragmentMap,\n                storeObject: incoming,\n                readField: readField,\n            }), id = _b[0], keyObject = _b[1];\n            // If dataId was not provided, fall back to the id just generated by\n            // policies.identify.\n            dataId = dataId || id;\n            // Write any key fields that were used during identification, even if\n            // they were not mentioned in the original query.\n            if (keyObject) {\n                // TODO Reverse the order of the arguments?\n                incoming = context.merge(incoming, keyObject);\n            }\n        }\n        catch (e) {\n            // If dataId was provided, tolerate failure of policies.identify.\n            if (!dataId)\n                throw e;\n        }\n        if (\"string\" === typeof dataId) {\n            var dataRef = makeReference(dataId);\n            // Avoid processing the same entity object using the same selection\n            // set more than once. We use an array instead of a Set since most\n            // entity IDs will be written using only one selection set, so the\n            // size of this array is likely to be very small, meaning indexOf is\n            // likely to be faster than Set.prototype.has.\n            var sets = context.written[dataId] || (context.written[dataId] = []);\n            if (sets.indexOf(selectionSet) >= 0)\n                return dataRef;\n            sets.push(selectionSet);\n            // If we're about to write a result object into the store, but we\n            // happen to know that the exact same (===) result object would be\n            // returned if we were to reread the result with the same inputs,\n            // then we can skip the rest of the processSelectionSet work for\n            // this object, and immediately return a Reference to it.\n            if (this.reader &&\n                this.reader.isFresh(result, dataRef, selectionSet, context)) {\n                return dataRef;\n            }\n            var previous_1 = context.incomingById.get(dataId);\n            if (previous_1) {\n                previous_1.storeObject = context.merge(previous_1.storeObject, incoming);\n                previous_1.mergeTree = mergeMergeTrees(previous_1.mergeTree, mergeTree);\n                fieldNodeSet.forEach(function (field) { return previous_1.fieldNodeSet.add(field); });\n            }\n            else {\n                context.incomingById.set(dataId, {\n                    storeObject: incoming,\n                    // Save a reference to mergeTree only if it is not empty, because\n                    // empty MergeTrees may be recycled by maybeRecycleChildMergeTree and\n                    // reused for entirely different parts of the result tree.\n                    mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,\n                    fieldNodeSet: fieldNodeSet,\n                });\n            }\n            return dataRef;\n        }\n        return incoming;\n    };\n    StoreWriter.prototype.processFieldValue = function (value, field, context, mergeTree) {\n        var _this = this;\n        if (!field.selectionSet || value === null) {\n            // In development, we need to clone scalar values so that they can be\n            // safely frozen with maybeDeepFreeze in readFromStore.ts. In production,\n            // it's cheaper to store the scalar values directly in the cache.\n            return globalThis.__DEV__ !== false ? cloneDeep(value) : value;\n        }\n        if (isArray(value)) {\n            return value.map(function (item, i) {\n                var value = _this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i));\n                maybeRecycleChildMergeTree(mergeTree, i);\n                return value;\n            });\n        }\n        return this.processSelectionSet({\n            result: value,\n            selectionSet: field.selectionSet,\n            context: context,\n            mergeTree: mergeTree,\n        });\n    };\n    // Implements https://spec.graphql.org/draft/#sec-Field-Collection, but with\n    // some additions for tracking @client and @defer directives.\n    StoreWriter.prototype.flattenFields = function (selectionSet, result, context, typename) {\n        if (typename === void 0) { typename = getTypenameFromResult(result, selectionSet, context.fragmentMap); }\n        var fieldMap = new Map();\n        var policies = this.cache.policies;\n        var limitingTrie = new Trie(false); // No need for WeakMap, since limitingTrie does not escape.\n        (function flatten(selectionSet, inheritedContext) {\n            var visitedNode = limitingTrie.lookup(selectionSet, \n            // Because we take inheritedClientOnly and inheritedDeferred into\n            // consideration here (in addition to selectionSet), it's possible for\n            // the same selection set to be flattened more than once, if it appears\n            // in the query with different @client and/or @directive configurations.\n            inheritedContext.clientOnly, inheritedContext.deferred);\n            if (visitedNode.visited)\n                return;\n            visitedNode.visited = true;\n            selectionSet.selections.forEach(function (selection) {\n                if (!shouldInclude(selection, context.variables))\n                    return;\n                var clientOnly = inheritedContext.clientOnly, deferred = inheritedContext.deferred;\n                if (\n                // Since the presence of @client or @defer on this field can only\n                // cause clientOnly or deferred to become true, we can skip the\n                // forEach loop if both clientOnly and deferred are already true.\n                !(clientOnly && deferred) &&\n                    isNonEmptyArray(selection.directives)) {\n                    selection.directives.forEach(function (dir) {\n                        var name = dir.name.value;\n                        if (name === \"client\")\n                            clientOnly = true;\n                        if (name === \"defer\") {\n                            var args = argumentsObjectFromField(dir, context.variables);\n                            // The @defer directive takes an optional args.if boolean\n                            // argument, similar to @include(if: boolean). Note that\n                            // @defer(if: false) does not make context.deferred false, but\n                            // instead behaves as if there was no @defer directive.\n                            if (!args || args.if !== false) {\n                                deferred = true;\n                            }\n                            // TODO In the future, we may want to record args.label using\n                            // context.deferred, if a label is specified.\n                        }\n                    });\n                }\n                if (isField(selection)) {\n                    var existing = fieldMap.get(selection);\n                    if (existing) {\n                        // If this field has been visited along another recursive path\n                        // before, the final context should have clientOnly or deferred set\n                        // to true only if *all* paths have the directive (hence the &&).\n                        clientOnly = clientOnly && existing.clientOnly;\n                        deferred = deferred && existing.deferred;\n                    }\n                    fieldMap.set(selection, getContextFlavor(context, clientOnly, deferred));\n                }\n                else {\n                    var fragment = getFragmentFromSelection(selection, context.lookupFragment);\n                    if (!fragment && selection.kind === Kind.FRAGMENT_SPREAD) {\n                        throw newInvariantError(13, selection.name.value);\n                    }\n                    if (fragment &&\n                        policies.fragmentMatches(fragment, typename, result, context.variables)) {\n                        flatten(fragment.selectionSet, getContextFlavor(context, clientOnly, deferred));\n                    }\n                }\n            });\n        })(selectionSet, context);\n        return fieldMap;\n    };\n    StoreWriter.prototype.applyMerges = function (mergeTree, existing, incoming, context, getStorageArgs) {\n        var _a;\n        var _this = this;\n        if (mergeTree.map.size && !isReference(incoming)) {\n            var e_1 = \n            // Items in the same position in different arrays are not\n            // necessarily related to each other, so when incoming is an array\n            // we process its elements as if there was no existing data.\n            (!isArray(incoming) &&\n                // Likewise, existing must be either a Reference or a StoreObject\n                // in order for its fields to be safe to merge with the fields of\n                // the incoming object.\n                (isReference(existing) || storeValueIsStoreObject(existing))) ?\n                existing\n                : void 0;\n            // This narrowing is implied by mergeTree.map.size > 0 and\n            // !isReference(incoming), though TypeScript understandably cannot\n            // hope to infer this type.\n            var i_1 = incoming;\n            // The options.storage objects provided to read and merge functions\n            // are derived from the identity of the parent object plus a\n            // sequence of storeFieldName strings/numbers identifying the nested\n            // field name path of each field value to be merged.\n            if (e_1 && !getStorageArgs) {\n                getStorageArgs = [isReference(e_1) ? e_1.__ref : e_1];\n            }\n            // It's possible that applying merge functions to this subtree will\n            // not change the incoming data, so this variable tracks the fields\n            // that did change, so we can create a new incoming object when (and\n            // only when) at least one incoming field has changed. We use a Map\n            // to preserve the type of numeric keys.\n            var changedFields_1;\n            var getValue_1 = function (from, name) {\n                return (isArray(from) ?\n                    typeof name === \"number\" ?\n                        from[name]\n                        : void 0\n                    : context.store.getFieldValue(from, String(name)));\n            };\n            mergeTree.map.forEach(function (childTree, storeFieldName) {\n                var eVal = getValue_1(e_1, storeFieldName);\n                var iVal = getValue_1(i_1, storeFieldName);\n                // If we have no incoming data, leave any existing data untouched.\n                if (void 0 === iVal)\n                    return;\n                if (getStorageArgs) {\n                    getStorageArgs.push(storeFieldName);\n                }\n                var aVal = _this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);\n                if (aVal !== iVal) {\n                    changedFields_1 = changedFields_1 || new Map();\n                    changedFields_1.set(storeFieldName, aVal);\n                }\n                if (getStorageArgs) {\n                    invariant(getStorageArgs.pop() === storeFieldName);\n                }\n            });\n            if (changedFields_1) {\n                // Shallow clone i so we can add changed fields to it.\n                incoming = (isArray(i_1) ? i_1.slice(0) : __assign({}, i_1));\n                changedFields_1.forEach(function (value, name) {\n                    incoming[name] = value;\n                });\n            }\n        }\n        if (mergeTree.info) {\n            return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && (_a = context.store).getStorage.apply(_a, getStorageArgs));\n        }\n        return incoming;\n    };\n    return StoreWriter;\n}());\nexport { StoreWriter };\nvar emptyMergeTreePool = [];\nfunction getChildMergeTree(_a, name) {\n    var map = _a.map;\n    if (!map.has(name)) {\n        map.set(name, emptyMergeTreePool.pop() || { map: new Map() });\n    }\n    return map.get(name);\n}\nfunction mergeMergeTrees(left, right) {\n    if (left === right || !right || mergeTreeIsEmpty(right))\n        return left;\n    if (!left || mergeTreeIsEmpty(left))\n        return right;\n    var info = left.info && right.info ? __assign(__assign({}, left.info), right.info) : left.info || right.info;\n    var needToMergeMaps = left.map.size && right.map.size;\n    var map = needToMergeMaps ? new Map()\n        : left.map.size ? left.map\n            : right.map;\n    var merged = { info: info, map: map };\n    if (needToMergeMaps) {\n        var remainingRightKeys_1 = new Set(right.map.keys());\n        left.map.forEach(function (leftTree, key) {\n            merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));\n            remainingRightKeys_1.delete(key);\n        });\n        remainingRightKeys_1.forEach(function (key) {\n            merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));\n        });\n    }\n    return merged;\n}\nfunction mergeTreeIsEmpty(tree) {\n    return !tree || !(tree.info || tree.map.size);\n}\nfunction maybeRecycleChildMergeTree(_a, name) {\n    var map = _a.map;\n    var childTree = map.get(name);\n    if (childTree && mergeTreeIsEmpty(childTree)) {\n        emptyMergeTreePool.push(childTree);\n        map.delete(name);\n    }\n}\nvar warnings = new Set();\n// Note that this function is unused in production, and thus should be\n// pruned by any well-configured minifier.\nfunction warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {\n    var getChild = function (objOrRef) {\n        var child = store.getFieldValue(objOrRef, storeFieldName);\n        return typeof child === \"object\" && child;\n    };\n    var existing = getChild(existingRef);\n    if (!existing)\n        return;\n    var incoming = getChild(incomingObj);\n    if (!incoming)\n        return;\n    // It's always safe to replace a reference, since it refers to data\n    // safely stored elsewhere.\n    if (isReference(existing))\n        return;\n    // If the values are structurally equivalent, we do not need to worry\n    // about incoming replacing existing.\n    if (equal(existing, incoming))\n        return;\n    // If we're replacing every key of the existing object, then the\n    // existing data would be overwritten even if the objects were\n    // normalized, so warning would not be helpful here.\n    if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {\n        return;\n    }\n    var parentType = store.getFieldValue(existingRef, \"__typename\") ||\n        store.getFieldValue(incomingObj, \"__typename\");\n    var fieldName = fieldNameFromStoreName(storeFieldName);\n    var typeDotName = \"\".concat(parentType, \".\").concat(fieldName);\n    // Avoid warning more than once for the same type and field name.\n    if (warnings.has(typeDotName))\n        return;\n    warnings.add(typeDotName);\n    var childTypenames = [];\n    // Arrays do not have __typename fields, and always need a custom merge\n    // function, even if their elements are normalized entities.\n    if (!isArray(existing) && !isArray(incoming)) {\n        [existing, incoming].forEach(function (child) {\n            var typename = store.getFieldValue(child, \"__typename\");\n            if (typeof typename === \"string\" && !childTypenames.includes(typename)) {\n                childTypenames.push(typename);\n            }\n        });\n    }\n    globalThis.__DEV__ !== false && invariant.warn(14, fieldName, parentType, childTypenames.length ?\n        \"either ensure all objects of type \" +\n            childTypenames.join(\" and \") +\n            \" have an ID or a custom merge function, or \"\n        : \"\", typeDotName, __assign({}, existing), __assign({}, incoming));\n}\n//# sourceMappingURL=writeToStore.js.map","import { __assign, __extends } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\n// Make builtins like Map and Set safe to use with non-extensible objects.\nimport \"./fixPolyfills.js\";\nimport { wrap } from \"optimism\";\nimport { equal } from \"@wry/equality\";\nimport { ApolloCache } from \"../core/cache.js\";\nimport { MissingFieldError } from \"../core/types/common.js\";\nimport { addTypenameToDocument, isReference, DocumentTransform, canonicalStringify, print, cacheSizes, } from \"../../utilities/index.js\";\nimport { StoreReader } from \"./readFromStore.js\";\nimport { StoreWriter } from \"./writeToStore.js\";\nimport { EntityStore, supportsResultCaching } from \"./entityStore.js\";\nimport { makeVar, forgetCache, recallCache } from \"./reactiveVars.js\";\nimport { Policies } from \"./policies.js\";\nimport { hasOwn, normalizeConfig, shouldCanonizeResults } from \"./helpers.js\";\nimport { getInMemoryCacheMemoryInternals } from \"../../utilities/caching/getMemoryInternals.js\";\nvar InMemoryCache = /** @class */ (function (_super) {\n    __extends(InMemoryCache, _super);\n    function InMemoryCache(config) {\n        if (config === void 0) { config = {}; }\n        var _this = _super.call(this) || this;\n        _this.watches = new Set();\n        _this.addTypenameTransform = new DocumentTransform(addTypenameToDocument);\n        // Override the default value, since InMemoryCache result objects are frozen\n        // in development and expected to remain logically immutable in production.\n        _this.assumeImmutableResults = true;\n        _this.makeVar = makeVar;\n        _this.txCount = 0;\n        _this.config = normalizeConfig(config);\n        _this.addTypename = !!_this.config.addTypename;\n        _this.policies = new Policies({\n            cache: _this,\n            dataIdFromObject: _this.config.dataIdFromObject,\n            possibleTypes: _this.config.possibleTypes,\n            typePolicies: _this.config.typePolicies,\n        });\n        _this.init();\n        return _this;\n    }\n    InMemoryCache.prototype.init = function () {\n        // Passing { resultCaching: false } in the InMemoryCache constructor options\n        // will completely disable dependency tracking, which will improve memory\n        // usage but worsen the performance of repeated reads.\n        var rootStore = (this.data = new EntityStore.Root({\n            policies: this.policies,\n            resultCaching: this.config.resultCaching,\n        }));\n        // When no optimistic writes are currently active, cache.optimisticData ===\n        // cache.data, so there are no additional layers on top of the actual data.\n        // When an optimistic update happens, this.optimisticData will become a\n        // linked list of EntityStore Layer objects that terminates with the\n        // original this.data cache object.\n        this.optimisticData = rootStore.stump;\n        this.resetResultCache();\n    };\n    InMemoryCache.prototype.resetResultCache = function (resetResultIdentities) {\n        var _this = this;\n        var previousReader = this.storeReader;\n        var fragments = this.config.fragments;\n        // The StoreWriter is mostly stateless and so doesn't really need to be\n        // reset, but it does need to have its writer.storeReader reference updated,\n        // so it's simpler to update this.storeWriter as well.\n        this.storeWriter = new StoreWriter(this, (this.storeReader = new StoreReader({\n            cache: this,\n            addTypename: this.addTypename,\n            resultCacheMaxSize: this.config.resultCacheMaxSize,\n            canonizeResults: shouldCanonizeResults(this.config),\n            canon: resetResultIdentities ? void 0 : (previousReader && previousReader.canon),\n            fragments: fragments,\n        })), fragments);\n        this.maybeBroadcastWatch = wrap(function (c, options) {\n            return _this.broadcastWatch(c, options);\n        }, {\n            max: this.config.resultCacheMaxSize ||\n                cacheSizes[\"inMemoryCache.maybeBroadcastWatch\"] ||\n                5000 /* defaultCacheSizes[\"inMemoryCache.maybeBroadcastWatch\"] */,\n            makeCacheKey: function (c) {\n                // Return a cache key (thus enabling result caching) only if we're\n                // currently using a data store that can track cache dependencies.\n                var store = c.optimistic ? _this.optimisticData : _this.data;\n                if (supportsResultCaching(store)) {\n                    var optimistic = c.optimistic, id = c.id, variables = c.variables;\n                    return store.makeCacheKey(c.query, \n                    // Different watches can have the same query, optimistic\n                    // status, rootId, and variables, but if their callbacks are\n                    // different, the (identical) result needs to be delivered to\n                    // each distinct callback. The easiest way to achieve that\n                    // separation is to include c.callback in the cache key for\n                    // maybeBroadcastWatch calls. See issue #5733.\n                    c.callback, canonicalStringify({ optimistic: optimistic, id: id, variables: variables }));\n                }\n            },\n        });\n        // Since we have thrown away all the cached functions that depend on the\n        // CacheGroup dependencies maintained by EntityStore, we should also reset\n        // all CacheGroup dependency information.\n        new Set([this.data.group, this.optimisticData.group]).forEach(function (group) {\n            return group.resetCaching();\n        });\n    };\n    InMemoryCache.prototype.restore = function (data) {\n        this.init();\n        // Since calling this.init() discards/replaces the entire StoreReader, along\n        // with the result caches it maintains, this.data.replace(data) won't have\n        // to bother deleting the old data.\n        if (data)\n            this.data.replace(data);\n        return this;\n    };\n    InMemoryCache.prototype.extract = function (optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return (optimistic ? this.optimisticData : this.data).extract();\n    };\n    InMemoryCache.prototype.read = function (options) {\n        var \n        // Since read returns data or null, without any additional metadata\n        // about whether/where there might have been missing fields, the\n        // default behavior cannot be returnPartialData = true (like it is\n        // for the diff method), since defaulting to true would violate the\n        // integrity of the T in the return type. However, partial data may\n        // be useful in some cases, so returnPartialData:true may be\n        // specified explicitly.\n        _a = options.returnPartialData, \n        // Since read returns data or null, without any additional metadata\n        // about whether/where there might have been missing fields, the\n        // default behavior cannot be returnPartialData = true (like it is\n        // for the diff method), since defaulting to true would violate the\n        // integrity of the T in the return type. However, partial data may\n        // be useful in some cases, so returnPartialData:true may be\n        // specified explicitly.\n        returnPartialData = _a === void 0 ? false : _a;\n        try {\n            return (this.storeReader.diffQueryAgainstStore(__assign(__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, config: this.config, returnPartialData: returnPartialData })).result || null);\n        }\n        catch (e) {\n            if (e instanceof MissingFieldError) {\n                // Swallow MissingFieldError and return null, so callers do not need to\n                // worry about catching \"normal\" exceptions resulting from incomplete\n                // cache data. Unexpected errors will be re-thrown. If you need more\n                // information about which fields were missing, use cache.diff instead,\n                // and examine diffResult.missing.\n                return null;\n            }\n            throw e;\n        }\n    };\n    InMemoryCache.prototype.write = function (options) {\n        try {\n            ++this.txCount;\n            return this.storeWriter.writeToStore(this.data, options);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.modify = function (options) {\n        if (hasOwn.call(options, \"id\") && !options.id) {\n            // To my knowledge, TypeScript does not currently provide a way to\n            // enforce that an optional property?:type must *not* be undefined\n            // when present. That ability would be useful here, because we want\n            // options.id to default to ROOT_QUERY only when no options.id was\n            // provided. If the caller attempts to pass options.id with a\n            // falsy/undefined value (perhaps because cache.identify failed), we\n            // should not assume the goal was to modify the ROOT_QUERY object.\n            // We could throw, but it seems natural to return false to indicate\n            // that nothing was modified.\n            return false;\n        }\n        var store = ((options.optimistic) // Defaults to false.\n        ) ?\n            this.optimisticData\n            : this.data;\n        try {\n            ++this.txCount;\n            return store.modify(options.id || \"ROOT_QUERY\", options.fields);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.diff = function (options) {\n        return this.storeReader.diffQueryAgainstStore(__assign(__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, rootId: options.id || \"ROOT_QUERY\", config: this.config }));\n    };\n    InMemoryCache.prototype.watch = function (watch) {\n        var _this = this;\n        if (!this.watches.size) {\n            // In case we previously called forgetCache(this) because\n            // this.watches became empty (see below), reattach this cache to any\n            // reactive variables on which it previously depended. It might seem\n            // paradoxical that we're able to recall something we supposedly\n            // forgot, but the point of calling forgetCache(this) is to silence\n            // useless broadcasts while this.watches is empty, and to allow the\n            // cache to be garbage collected. If, however, we manage to call\n            // recallCache(this) here, this cache object must not have been\n            // garbage collected yet, and should resume receiving updates from\n            // reactive variables, now that it has a watcher to notify.\n            recallCache(this);\n        }\n        this.watches.add(watch);\n        if (watch.immediate) {\n            this.maybeBroadcastWatch(watch);\n        }\n        return function () {\n            // Once we remove the last watch from this.watches, cache.broadcastWatches\n            // no longer does anything, so we preemptively tell the reactive variable\n            // system to exclude this cache from future broadcasts.\n            if (_this.watches.delete(watch) && !_this.watches.size) {\n                forgetCache(_this);\n            }\n            // Remove this watch from the LRU cache managed by the\n            // maybeBroadcastWatch OptimisticWrapperFunction, to prevent memory\n            // leaks involving the closure of watch.callback.\n            _this.maybeBroadcastWatch.forget(watch);\n        };\n    };\n    InMemoryCache.prototype.gc = function (options) {\n        var _a;\n        canonicalStringify.reset();\n        print.reset();\n        this.addTypenameTransform.resetCache();\n        (_a = this.config.fragments) === null || _a === void 0 ? void 0 : _a.resetCaches();\n        var ids = this.optimisticData.gc();\n        if (options && !this.txCount) {\n            if (options.resetResultCache) {\n                this.resetResultCache(options.resetResultIdentities);\n            }\n            else if (options.resetResultIdentities) {\n                this.storeReader.resetCanon();\n            }\n        }\n        return ids;\n    };\n    // Call this method to ensure the given root ID remains in the cache after\n    // garbage collection, along with its transitive child entities. Note that\n    // the cache automatically retains all directly written entities. By default,\n    // the retainment persists after optimistic updates are removed. Pass true\n    // for the optimistic argument if you would prefer for the retainment to be\n    // discarded when the top-most optimistic layer is removed. Returns the\n    // resulting (non-negative) retainment count.\n    InMemoryCache.prototype.retain = function (rootId, optimistic) {\n        return (optimistic ? this.optimisticData : this.data).retain(rootId);\n    };\n    // Call this method to undo the effect of the retain method, above. Once the\n    // retainment count falls to zero, the given ID will no longer be preserved\n    // during garbage collection, though it may still be preserved by other safe\n    // entities that refer to it. Returns the resulting (non-negative) retainment\n    // count, in case that's useful.\n    InMemoryCache.prototype.release = function (rootId, optimistic) {\n        return (optimistic ? this.optimisticData : this.data).release(rootId);\n    };\n    // Returns the canonical ID for a given StoreObject, obeying typePolicies\n    // and keyFields (and dataIdFromObject, if you still use that). At minimum,\n    // the object must contain a __typename and any primary key fields required\n    // to identify entities of that type. If you pass a query result object, be\n    // sure that none of the primary key fields have been renamed by aliasing.\n    // If you pass a Reference object, its __ref ID string will be returned.\n    InMemoryCache.prototype.identify = function (object) {\n        if (isReference(object))\n            return object.__ref;\n        try {\n            return this.policies.identify(object)[0];\n        }\n        catch (e) {\n            globalThis.__DEV__ !== false && invariant.warn(e);\n        }\n    };\n    InMemoryCache.prototype.evict = function (options) {\n        if (!options.id) {\n            if (hasOwn.call(options, \"id\")) {\n                // See comment in modify method about why we return false when\n                // options.id exists but is falsy/undefined.\n                return false;\n            }\n            options = __assign(__assign({}, options), { id: \"ROOT_QUERY\" });\n        }\n        try {\n            // It's unlikely that the eviction will end up invoking any other\n            // cache update operations while it's running, but {in,de}crementing\n            // this.txCount still seems like a good idea, for uniformity with\n            // the other update methods.\n            ++this.txCount;\n            // Pass this.data as a limit on the depth of the eviction, so evictions\n            // during optimistic updates (when this.data is temporarily set equal to\n            // this.optimisticData) do not escape their optimistic Layer.\n            return this.optimisticData.evict(options, this.data);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.reset = function (options) {\n        var _this = this;\n        this.init();\n        canonicalStringify.reset();\n        if (options && options.discardWatches) {\n            // Similar to what happens in the unsubscribe function returned by\n            // cache.watch, applied to all current watches.\n            this.watches.forEach(function (watch) { return _this.maybeBroadcastWatch.forget(watch); });\n            this.watches.clear();\n            forgetCache(this);\n        }\n        else {\n            // Calling this.init() above unblocks all maybeBroadcastWatch caching, so\n            // this.broadcastWatches() triggers a broadcast to every current watcher\n            // (letting them know their data is now missing). This default behavior is\n            // convenient because it means the watches do not have to be manually\n            // reestablished after resetting the cache. To prevent this broadcast and\n            // cancel all watches, pass true for options.discardWatches.\n            this.broadcastWatches();\n        }\n        return Promise.resolve();\n    };\n    InMemoryCache.prototype.removeOptimistic = function (idToRemove) {\n        var newOptimisticData = this.optimisticData.removeLayer(idToRemove);\n        if (newOptimisticData !== this.optimisticData) {\n            this.optimisticData = newOptimisticData;\n            this.broadcastWatches();\n        }\n    };\n    InMemoryCache.prototype.batch = function (options) {\n        var _this = this;\n        var update = options.update, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, removeOptimistic = options.removeOptimistic, onWatchUpdated = options.onWatchUpdated;\n        var updateResult;\n        var perform = function (layer) {\n            var _a = _this, data = _a.data, optimisticData = _a.optimisticData;\n            ++_this.txCount;\n            if (layer) {\n                _this.data = _this.optimisticData = layer;\n            }\n            try {\n                return (updateResult = update(_this));\n            }\n            finally {\n                --_this.txCount;\n                _this.data = data;\n                _this.optimisticData = optimisticData;\n            }\n        };\n        var alreadyDirty = new Set();\n        if (onWatchUpdated && !this.txCount) {\n            // If an options.onWatchUpdated callback is provided, we want to call it\n            // with only the Cache.WatchOptions objects affected by options.update,\n            // but there might be dirty watchers already waiting to be broadcast that\n            // have nothing to do with the update. To prevent including those watchers\n            // in the post-update broadcast, we perform this initial broadcast to\n            // collect the dirty watchers, so we can re-dirty them later, after the\n            // post-update broadcast, allowing them to receive their pending\n            // broadcasts the next time broadcastWatches is called, just as they would\n            // if we never called cache.batch.\n            this.broadcastWatches(__assign(__assign({}, options), { onWatchUpdated: function (watch) {\n                    alreadyDirty.add(watch);\n                    return false;\n                } }));\n        }\n        if (typeof optimistic === \"string\") {\n            // Note that there can be multiple layers with the same optimistic ID.\n            // When removeOptimistic(id) is called for that id, all matching layers\n            // will be removed, and the remaining layers will be reapplied.\n            this.optimisticData = this.optimisticData.addLayer(optimistic, perform);\n        }\n        else if (optimistic === false) {\n            // Ensure both this.data and this.optimisticData refer to the root\n            // (non-optimistic) layer of the cache during the update. Note that\n            // this.data could be a Layer if we are currently executing an optimistic\n            // update function, but otherwise will always be an EntityStore.Root\n            // instance.\n            perform(this.data);\n        }\n        else {\n            // Otherwise, leave this.data and this.optimisticData unchanged and run\n            // the update with broadcast batching.\n            perform();\n        }\n        if (typeof removeOptimistic === \"string\") {\n            this.optimisticData = this.optimisticData.removeLayer(removeOptimistic);\n        }\n        // Note: if this.txCount > 0, then alreadyDirty.size === 0, so this code\n        // takes the else branch and calls this.broadcastWatches(options), which\n        // does nothing when this.txCount > 0.\n        if (onWatchUpdated && alreadyDirty.size) {\n            this.broadcastWatches(__assign(__assign({}, options), { onWatchUpdated: function (watch, diff) {\n                    var result = onWatchUpdated.call(this, watch, diff);\n                    if (result !== false) {\n                        // Since onWatchUpdated did not return false, this diff is\n                        // about to be broadcast to watch.callback, so we don't need\n                        // to re-dirty it with the other alreadyDirty watches below.\n                        alreadyDirty.delete(watch);\n                    }\n                    return result;\n                } }));\n            // Silently re-dirty any watches that were already dirty before the update\n            // was performed, and were not broadcast just now.\n            if (alreadyDirty.size) {\n                alreadyDirty.forEach(function (watch) { return _this.maybeBroadcastWatch.dirty(watch); });\n            }\n        }\n        else {\n            // If alreadyDirty is empty or we don't have an onWatchUpdated\n            // function, we don't need to go to the trouble of wrapping\n            // options.onWatchUpdated.\n            this.broadcastWatches(options);\n        }\n        return updateResult;\n    };\n    InMemoryCache.prototype.performTransaction = function (update, optimisticId) {\n        return this.batch({\n            update: update,\n            optimistic: optimisticId || optimisticId !== null,\n        });\n    };\n    InMemoryCache.prototype.transformDocument = function (document) {\n        return this.addTypenameToDocument(this.addFragmentsToDocument(document));\n    };\n    InMemoryCache.prototype.broadcastWatches = function (options) {\n        var _this = this;\n        if (!this.txCount) {\n            this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c, options); });\n        }\n    };\n    InMemoryCache.prototype.addFragmentsToDocument = function (document) {\n        var fragments = this.config.fragments;\n        return fragments ? fragments.transform(document) : document;\n    };\n    InMemoryCache.prototype.addTypenameToDocument = function (document) {\n        if (this.addTypename) {\n            return this.addTypenameTransform.transformDocument(document);\n        }\n        return document;\n    };\n    // This method is wrapped by maybeBroadcastWatch, which is called by\n    // broadcastWatches, so that we compute and broadcast results only when\n    // the data that would be broadcast might have changed. It would be\n    // simpler to check for changes after recomputing a result but before\n    // broadcasting it, but this wrapping approach allows us to skip both\n    // the recomputation and the broadcast, in most cases.\n    InMemoryCache.prototype.broadcastWatch = function (c, options) {\n        var lastDiff = c.lastDiff;\n        // Both WatchOptions and DiffOptions extend ReadOptions, and DiffOptions\n        // currently requires no additional properties, so we can use c (a\n        // WatchOptions object) as DiffOptions, without having to allocate a new\n        // object, and without having to enumerate the relevant properties (query,\n        // variables, etc.) explicitly. There will be some additional properties\n        // (lastDiff, callback, etc.), but cache.diff ignores them.\n        var diff = this.diff(c);\n        if (options) {\n            if (c.optimistic && typeof options.optimistic === \"string\") {\n                diff.fromOptimisticTransaction = true;\n            }\n            if (options.onWatchUpdated &&\n                options.onWatchUpdated.call(this, c, diff, lastDiff) === false) {\n                // Returning false from the onWatchUpdated callback will prevent\n                // calling c.callback(diff) for this watcher.\n                return;\n            }\n        }\n        if (!lastDiff || !equal(lastDiff.result, diff.result)) {\n            c.callback((c.lastDiff = diff), lastDiff);\n        }\n    };\n    return InMemoryCache;\n}(ApolloCache));\nexport { InMemoryCache };\nif (globalThis.__DEV__ !== false) {\n    InMemoryCache.prototype.getMemoryInternals = getInMemoryCacheMemoryInternals;\n}\n//# sourceMappingURL=inMemoryCache.js.map","import { dep, Slot } from \"optimism\";\n// Contextual Slot that acquires its value when custom read functions are\n// called in Policies#readField.\nexport var cacheSlot = new Slot();\nvar cacheInfoMap = new WeakMap();\nfunction getCacheInfo(cache) {\n    var info = cacheInfoMap.get(cache);\n    if (!info) {\n        cacheInfoMap.set(cache, (info = {\n            vars: new Set(),\n            dep: dep(),\n        }));\n    }\n    return info;\n}\nexport function forgetCache(cache) {\n    getCacheInfo(cache).vars.forEach(function (rv) { return rv.forgetCache(cache); });\n}\n// Calling forgetCache(cache) serves to silence broadcasts and allows the\n// cache to be garbage collected. However, the varsByCache WeakMap\n// preserves the set of reactive variables that were previously associated\n// with this cache, which makes it possible to \"recall\" the cache at a\n// later time, by reattaching it to those variables. If the cache has been\n// garbage collected in the meantime, because it is no longer reachable,\n// you won't be able to call recallCache(cache), and the cache will\n// automatically disappear from the varsByCache WeakMap.\nexport function recallCache(cache) {\n    getCacheInfo(cache).vars.forEach(function (rv) { return rv.attachCache(cache); });\n}\nexport function makeVar(value) {\n    var caches = new Set();\n    var listeners = new Set();\n    var rv = function (newValue) {\n        if (arguments.length > 0) {\n            if (value !== newValue) {\n                value = newValue;\n                caches.forEach(function (cache) {\n                    // Invalidate any fields with custom read functions that\n                    // consumed this variable, so query results involving those\n                    // fields will be recomputed the next time we read them.\n                    getCacheInfo(cache).dep.dirty(rv);\n                    // Broadcast changes to any caches that have previously read\n                    // from this variable.\n                    broadcast(cache);\n                });\n                // Finally, notify any listeners added via rv.onNextChange.\n                var oldListeners = Array.from(listeners);\n                listeners.clear();\n                oldListeners.forEach(function (listener) { return listener(value); });\n            }\n        }\n        else {\n            // When reading from the variable, obtain the current cache from\n            // context via cacheSlot. This isn't entirely foolproof, but it's\n            // the same system that powers varDep.\n            var cache = cacheSlot.getValue();\n            if (cache) {\n                attach(cache);\n                getCacheInfo(cache).dep(rv);\n            }\n        }\n        return value;\n    };\n    rv.onNextChange = function (listener) {\n        listeners.add(listener);\n        return function () {\n            listeners.delete(listener);\n        };\n    };\n    var attach = (rv.attachCache = function (cache) {\n        caches.add(cache);\n        getCacheInfo(cache).vars.add(rv);\n        return rv;\n    });\n    rv.forgetCache = function (cache) { return caches.delete(cache); };\n    return rv;\n}\nfunction broadcast(cache) {\n    if (cache.broadcastWatches) {\n        cache.broadcastWatches();\n    }\n}\n//# sourceMappingURL=reactiveVars.js.map","import { ApolloLink } from \"./ApolloLink.js\";\nexport var execute = ApolloLink.execute;\n//# sourceMappingURL=execute.js.map","import { __extends } from \"tslib\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { createHttpLink } from \"./createHttpLink.js\";\nvar HttpLink = /** @class */ (function (_super) {\n    __extends(HttpLink, _super);\n    function HttpLink(options) {\n        if (options === void 0) { options = {}; }\n        var _this = _super.call(this, createHttpLink(options).request) || this;\n        _this.options = options;\n        return _this;\n    }\n    return HttpLink;\n}(ApolloLink));\nexport { HttpLink };\n//# sourceMappingURL=HttpLink.js.map","import { Observable } from \"./Observable.js\";\n// Like Observable.prototype.map, except that the mapping function can\n// optionally return a Promise (or be async).\nexport function asyncMap(observable, mapFn, catchFn) {\n    return new Observable(function (observer) {\n        var promiseQueue = {\n            // Normally we would initialize promiseQueue to Promise.resolve(), but\n            // in this case, for backwards compatibility, we need to be careful to\n            // invoke the first callback synchronously.\n            then: function (callback) {\n                return new Promise(function (resolve) { return resolve(callback()); });\n            },\n        };\n        function makeCallback(examiner, key) {\n            return function (arg) {\n                if (examiner) {\n                    var both = function () {\n                        // If the observer is closed, we don't want to continue calling the\n                        // mapping function - it's result will be swallowed anyways.\n                        return observer.closed ?\n                            /* will be swallowed */ 0\n                            : examiner(arg);\n                    };\n                    promiseQueue = promiseQueue.then(both, both).then(function (result) { return observer.next(result); }, function (error) { return observer.error(error); });\n                }\n                else {\n                    observer[key](arg);\n                }\n            };\n        }\n        var handler = {\n            next: makeCallback(mapFn, \"next\"),\n            error: makeCallback(catchFn, \"error\"),\n            complete: function () {\n                // no need to reassign `promiseQueue`, after `observer.complete`,\n                // the observer will be closed and short-circuit everything anyways\n                /*promiseQueue = */ promiseQueue.then(function () { return observer.complete(); });\n            },\n        };\n        var sub = observable.subscribe(handler);\n        return function () { return sub.unsubscribe(); };\n    });\n}\n//# sourceMappingURL=asyncMap.js.map","import { isNonEmptyArray } from \"./arrays.js\";\nimport { isExecutionPatchIncrementalResult } from \"./incrementalResult.js\";\nexport function graphQLResultHasError(result) {\n    var errors = getGraphQLErrorsFromResult(result);\n    return isNonEmptyArray(errors);\n}\nexport function getGraphQLErrorsFromResult(result) {\n    var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];\n    if (isExecutionPatchIncrementalResult(result) &&\n        isNonEmptyArray(result.incremental)) {\n        result.incremental.forEach(function (incrementalResult) {\n            if (incrementalResult.errors) {\n                graphQLErrors.push.apply(graphQLErrors, incrementalResult.errors);\n            }\n        });\n    }\n    return graphQLErrors;\n}\n//# sourceMappingURL=errorHandling.js.map","export function iterateObserversSafely(observers, method, argument) {\n    // In case observers is modified during iteration, we need to commit to the\n    // original elements, which also provides an opportunity to filter them down\n    // to just the observers with the given method.\n    var observersWithMethod = [];\n    observers.forEach(function (obs) { return obs[method] && observersWithMethod.push(obs); });\n    observersWithMethod.forEach(function (obs) { return obs[method](argument); });\n}\n//# sourceMappingURL=iteration.js.map","import { Observable } from \"./Observable.js\";\nimport { canUseSymbol } from \"../common/canUse.js\";\n// Generic implementations of Observable.prototype methods like map and\n// filter need to know how to create a new Observable from an Observable\n// subclass (like Concast or ObservableQuery). Those methods assume\n// (perhaps unwisely?) that they can call the subtype's constructor with a\n// Subscriber function, even though the subclass constructor might expect\n// different parameters. Defining this static Symbol.species property on\n// the subclass is a hint to generic Observable code to use the default\n// constructor instead of trying to do `new Subclass(observer => ...)`.\nexport function fixObservableSubclass(subclass) {\n    function set(key) {\n        // Object.defineProperty is necessary because the Symbol.species\n        // property is a getter by default in modern JS environments, so we\n        // can't assign to it with a normal assignment expression.\n        Object.defineProperty(subclass, key, { value: Observable });\n    }\n    if (canUseSymbol && Symbol.species) {\n        set(Symbol.species);\n    }\n    // The \"@@species\" string is used as a fake Symbol.species value in some\n    // polyfill systems (including the SymbolSpecies variable used by\n    // zen-observable), so we should set it as well, to be safe.\n    set(\"@@species\");\n    return subclass;\n}\n//# sourceMappingURL=subclassing.js.map","import { __extends } from \"tslib\";\nimport { Observable } from \"./Observable.js\";\nimport { iterateObserversSafely } from \"./iteration.js\";\nimport { fixObservableSubclass } from \"./subclassing.js\";\nfunction isPromiseLike(value) {\n    return value && typeof value.then === \"function\";\n}\n// A Concast<T> observable concatenates the given sources into a single\n// non-overlapping sequence of Ts, automatically unwrapping any promises,\n// and broadcasts the T elements of that sequence to any number of\n// subscribers, all without creating a bunch of intermediary Observable\n// wrapper objects.\n//\n// Even though any number of observers can subscribe to the Concast, each\n// source observable is guaranteed to receive at most one subscribe call,\n// and the results are multicast to all observers.\n//\n// In addition to broadcasting every next/error message to this.observers,\n// the Concast stores the most recent message using this.latest, so any\n// new observers can immediately receive the latest message, even if it\n// was originally delivered in the past. This behavior means we can assume\n// every active observer in this.observers has received the same most\n// recent message.\n//\n// With the exception of this.latest replay, a Concast is a \"hot\"\n// observable in the sense that it does not replay past results from the\n// beginning of time for each new observer.\n//\n// Could we have used some existing RxJS class instead? Concast<T> is\n// similar to a BehaviorSubject<T>, because it is multicast and redelivers\n// the latest next/error message to new subscribers. Unlike Subject<T>,\n// Concast<T> does not expose an Observer<T> interface (this.handlers is\n// intentionally private), since Concast<T> gets its inputs from the\n// concatenated sources. If we ever switch to RxJS, there may be some\n// value in reusing their code, but for now we use zen-observable, which\n// does not contain any Subject implementations.\nvar Concast = /** @class */ (function (_super) {\n    __extends(Concast, _super);\n    // Not only can the individual elements of the iterable be promises, but\n    // also the iterable itself can be wrapped in a promise.\n    function Concast(sources) {\n        var _this = _super.call(this, function (observer) {\n            _this.addObserver(observer);\n            return function () { return _this.removeObserver(observer); };\n        }) || this;\n        // Active observers receiving broadcast messages. Thanks to this.latest,\n        // we can assume all observers in this Set have received the same most\n        // recent message, though possibly at different times in the past.\n        _this.observers = new Set();\n        _this.promise = new Promise(function (resolve, reject) {\n            _this.resolve = resolve;\n            _this.reject = reject;\n        });\n        // Bound handler functions that can be reused for every internal\n        // subscription.\n        _this.handlers = {\n            next: function (result) {\n                if (_this.sub !== null) {\n                    _this.latest = [\"next\", result];\n                    _this.notify(\"next\", result);\n                    iterateObserversSafely(_this.observers, \"next\", result);\n                }\n            },\n            error: function (error) {\n                var sub = _this.sub;\n                if (sub !== null) {\n                    // Delay unsubscribing from the underlying subscription slightly,\n                    // so that immediately subscribing another observer can keep the\n                    // subscription active.\n                    if (sub)\n                        setTimeout(function () { return sub.unsubscribe(); });\n                    _this.sub = null;\n                    _this.latest = [\"error\", error];\n                    _this.reject(error);\n                    _this.notify(\"error\", error);\n                    iterateObserversSafely(_this.observers, \"error\", error);\n                }\n            },\n            complete: function () {\n                var _a = _this, sub = _a.sub, _b = _a.sources, sources = _b === void 0 ? [] : _b;\n                if (sub !== null) {\n                    // If complete is called before concast.start, this.sources may be\n                    // undefined, so we use a default value of [] for sources. That works\n                    // here because it falls into the if (!value) {...} block, which\n                    // appropriately terminates the Concast, even if this.sources might\n                    // eventually have been initialized to a non-empty array.\n                    var value = sources.shift();\n                    if (!value) {\n                        if (sub)\n                            setTimeout(function () { return sub.unsubscribe(); });\n                        _this.sub = null;\n                        if (_this.latest && _this.latest[0] === \"next\") {\n                            _this.resolve(_this.latest[1]);\n                        }\n                        else {\n                            _this.resolve();\n                        }\n                        _this.notify(\"complete\");\n                        // We do not store this.latest = [\"complete\"], because doing so\n                        // discards useful information about the previous next (or\n                        // error) message. Instead, if new observers subscribe after\n                        // this Concast has completed, they will receive the final\n                        // 'next' message (unless there was an error) immediately\n                        // followed by a 'complete' message (see addObserver).\n                        iterateObserversSafely(_this.observers, \"complete\");\n                    }\n                    else if (isPromiseLike(value)) {\n                        value.then(function (obs) { return (_this.sub = obs.subscribe(_this.handlers)); }, _this.handlers.error);\n                    }\n                    else {\n                        _this.sub = value.subscribe(_this.handlers);\n                    }\n                }\n            },\n        };\n        _this.nextResultListeners = new Set();\n        // A public way to abort observation and broadcast.\n        _this.cancel = function (reason) {\n            _this.reject(reason);\n            _this.sources = [];\n            _this.handlers.error(reason);\n        };\n        // Suppress rejection warnings for this.promise, since it's perfectly\n        // acceptable to pay no attention to this.promise if you're consuming\n        // the results through the normal observable API.\n        _this.promise.catch(function (_) { });\n        // If someone accidentally tries to create a Concast using a subscriber\n        // function, recover by creating an Observable from that subscriber and\n        // using it as the source.\n        if (typeof sources === \"function\") {\n            sources = [new Observable(sources)];\n        }\n        if (isPromiseLike(sources)) {\n            sources.then(function (iterable) { return _this.start(iterable); }, _this.handlers.error);\n        }\n        else {\n            _this.start(sources);\n        }\n        return _this;\n    }\n    Concast.prototype.start = function (sources) {\n        if (this.sub !== void 0)\n            return;\n        // In practice, sources is most often simply an Array of observables.\n        // TODO Consider using sources[Symbol.iterator]() to take advantage\n        // of the laziness of non-Array iterables.\n        this.sources = Array.from(sources);\n        // Calling this.handlers.complete() kicks off consumption of the first\n        // source observable. It's tempting to do this step lazily in\n        // addObserver, but this.promise can be accessed without calling\n        // addObserver, so consumption needs to begin eagerly.\n        this.handlers.complete();\n    };\n    Concast.prototype.deliverLastMessage = function (observer) {\n        if (this.latest) {\n            var nextOrError = this.latest[0];\n            var method = observer[nextOrError];\n            if (method) {\n                method.call(observer, this.latest[1]);\n            }\n            // If the subscription is already closed, and the last message was\n            // a 'next' message, simulate delivery of the final 'complete'\n            // message again.\n            if (this.sub === null && nextOrError === \"next\" && observer.complete) {\n                observer.complete();\n            }\n        }\n    };\n    Concast.prototype.addObserver = function (observer) {\n        if (!this.observers.has(observer)) {\n            // Immediately deliver the most recent message, so we can always\n            // be sure all observers have the latest information.\n            this.deliverLastMessage(observer);\n            this.observers.add(observer);\n        }\n    };\n    Concast.prototype.removeObserver = function (observer) {\n        if (this.observers.delete(observer) && this.observers.size < 1) {\n            // In case there are still any listeners in this.nextResultListeners, and\n            // no error or completion has been broadcast yet, make sure those\n            // observers have a chance to run and then remove themselves from\n            // this.observers.\n            this.handlers.complete();\n        }\n    };\n    Concast.prototype.notify = function (method, arg) {\n        var nextResultListeners = this.nextResultListeners;\n        if (nextResultListeners.size) {\n            // Replacing this.nextResultListeners first ensures it does not grow while\n            // we are iterating over it, potentially leading to infinite loops.\n            this.nextResultListeners = new Set();\n            nextResultListeners.forEach(function (listener) { return listener(method, arg); });\n        }\n    };\n    // We need a way to run callbacks just *before* the next result (or error or\n    // completion) is delivered by this Concast, so we can be sure any code that\n    // runs as a result of delivering that result/error observes the effects of\n    // running the callback(s). It was tempting to reuse the Observer type instead\n    // of introducing NextResultListener, but that messes with the sizing and\n    // maintenance of this.observers, and ends up being more code overall.\n    Concast.prototype.beforeNext = function (callback) {\n        var called = false;\n        this.nextResultListeners.add(function (method, arg) {\n            if (!called) {\n                called = true;\n                callback(method, arg);\n            }\n        });\n    };\n    return Concast;\n}(Observable));\nexport { Concast };\n// Necessary because the Concast constructor has a different signature\n// than the Observable constructor.\nfixObservableSubclass(Concast);\n//# sourceMappingURL=Concast.js.map","import { __assign, __extends } from \"tslib\";\nimport { invariant } from \"../utilities/globals/index.js\";\nimport { equal } from \"@wry/equality\";\nimport { NetworkStatus, isNetworkRequestInFlight } from \"./networkStatus.js\";\nimport { cloneDeep, compact, getOperationDefinition, Observable, iterateObserversSafely, fixObservableSubclass, getQueryDefinition, } from \"../utilities/index.js\";\nimport { ApolloError, isApolloError } from \"../errors/index.js\";\nimport { equalByQuery } from \"./equalByQuery.js\";\nvar assign = Object.assign, hasOwnProperty = Object.hasOwnProperty;\nvar ObservableQuery = /** @class */ (function (_super) {\n    __extends(ObservableQuery, _super);\n    function ObservableQuery(_a) {\n        var queryManager = _a.queryManager, queryInfo = _a.queryInfo, options = _a.options;\n        var _this = _super.call(this, function (observer) {\n            // Zen Observable has its own error function, so in order to log correctly\n            // we need to provide a custom error callback.\n            try {\n                var subObserver = observer._subscription._observer;\n                if (subObserver && !subObserver.error) {\n                    subObserver.error = defaultSubscriptionObserverErrorCallback;\n                }\n            }\n            catch (_a) { }\n            var first = !_this.observers.size;\n            _this.observers.add(observer);\n            // Deliver most recent error or result.\n            var last = _this.last;\n            if (last && last.error) {\n                observer.error && observer.error(last.error);\n            }\n            else if (last && last.result) {\n                observer.next && observer.next(last.result);\n            }\n            // Initiate observation of this query if it hasn't been reported to\n            // the QueryManager yet.\n            if (first) {\n                // Blindly catching here prevents unhandled promise rejections,\n                // and is safe because the ObservableQuery handles this error with\n                // this.observer.error, so we're not just swallowing the error by\n                // ignoring it here.\n                _this.reobserve().catch(function () { });\n            }\n            return function () {\n                if (_this.observers.delete(observer) && !_this.observers.size) {\n                    _this.tearDownQuery();\n                }\n            };\n        }) || this;\n        _this.observers = new Set();\n        _this.subscriptions = new Set();\n        // related classes\n        _this.queryInfo = queryInfo;\n        _this.queryManager = queryManager;\n        // active state\n        _this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy);\n        _this.isTornDown = false;\n        _this.subscribeToMore = _this.subscribeToMore.bind(_this);\n        var _b = queryManager.defaultOptions.watchQuery, _c = _b === void 0 ? {} : _b, _d = _c.fetchPolicy, defaultFetchPolicy = _d === void 0 ? \"cache-first\" : _d;\n        var _e = options.fetchPolicy, fetchPolicy = _e === void 0 ? defaultFetchPolicy : _e, \n        // Make sure we don't store \"standby\" as the initialFetchPolicy.\n        _f = options.initialFetchPolicy, \n        // Make sure we don't store \"standby\" as the initialFetchPolicy.\n        initialFetchPolicy = _f === void 0 ? fetchPolicy === \"standby\" ? defaultFetchPolicy : (fetchPolicy) : _f;\n        _this.options = __assign(__assign({}, options), { \n            // Remember the initial options.fetchPolicy so we can revert back to this\n            // policy when variables change. This information can also be specified\n            // (or overridden) by providing options.initialFetchPolicy explicitly.\n            initialFetchPolicy: initialFetchPolicy, \n            // This ensures this.options.fetchPolicy always has a string value, in\n            // case options.fetchPolicy was not provided.\n            fetchPolicy: fetchPolicy });\n        _this.queryId = queryInfo.queryId || queryManager.generateQueryId();\n        var opDef = getOperationDefinition(_this.query);\n        _this.queryName = opDef && opDef.name && opDef.name.value;\n        return _this;\n    }\n    Object.defineProperty(ObservableQuery.prototype, \"query\", {\n        // The `query` computed property will always reflect the document transformed\n        // by the last run query. `this.options.query` will always reflect the raw\n        // untransformed query to ensure document transforms with runtime conditionals\n        // are run on the original document.\n        get: function () {\n            return this.lastQuery || this.options.query;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(ObservableQuery.prototype, \"variables\", {\n        // Computed shorthand for this.options.variables, preserved for\n        // backwards compatibility.\n        /**\n         * An object containing the variables that were provided for the query.\n         */\n        get: function () {\n            return this.options.variables;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    ObservableQuery.prototype.result = function () {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            // TODO: this code doesn’t actually make sense insofar as the observer\n            // will never exist in this.observers due how zen-observable wraps observables.\n            // https://github.com/zenparsing/zen-observable/blob/master/src/Observable.js#L169\n            var observer = {\n                next: function (result) {\n                    resolve(result);\n                    // Stop the query within the QueryManager if we can before\n                    // this function returns.\n                    //\n                    // We do this in order to prevent observers piling up within\n                    // the QueryManager. Notice that we only fully unsubscribe\n                    // from the subscription in a setTimeout(..., 0)  call. This call can\n                    // actually be handled by the browser at a much later time. If queries\n                    // are fired in the meantime, observers that should have been removed\n                    // from the QueryManager will continue to fire, causing an unnecessary\n                    // performance hit.\n                    _this.observers.delete(observer);\n                    if (!_this.observers.size) {\n                        _this.queryManager.removeQuery(_this.queryId);\n                    }\n                    setTimeout(function () {\n                        subscription.unsubscribe();\n                    }, 0);\n                },\n                error: reject,\n            };\n            var subscription = _this.subscribe(observer);\n        });\n    };\n    /** @internal */\n    ObservableQuery.prototype.resetDiff = function () {\n        this.queryInfo.resetDiff();\n    };\n    ObservableQuery.prototype.getCurrentResult = function (saveAsLastResult) {\n        if (saveAsLastResult === void 0) { saveAsLastResult = true; }\n        // Use the last result as long as the variables match this.variables.\n        var lastResult = this.getLastResult(true);\n        var networkStatus = this.queryInfo.networkStatus ||\n            (lastResult && lastResult.networkStatus) ||\n            NetworkStatus.ready;\n        var result = __assign(__assign({}, lastResult), { loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus });\n        var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? \"cache-first\" : _a;\n        if (\n        // These fetch policies should never deliver data from the cache, unless\n        // redelivering a previously delivered result.\n        skipCacheDataFor(fetchPolicy) ||\n            // If this.options.query has @client(always: true) fields, we cannot\n            // trust diff.result, since it was read from the cache without running\n            // local resolvers (and it's too late to run resolvers now, since we must\n            // return a result synchronously).\n            this.queryManager.getDocumentInfo(this.query).hasForcedResolvers) {\n            // Fall through.\n        }\n        else if (this.waitForOwnResult) {\n            // This would usually be a part of `QueryInfo.getDiff()`.\n            // which we skip in the waitForOwnResult case since we are not\n            // interested in the diff.\n            this.queryInfo[\"updateWatch\"]();\n        }\n        else {\n            var diff = this.queryInfo.getDiff();\n            if (diff.complete || this.options.returnPartialData) {\n                result.data = diff.result;\n            }\n            if (equal(result.data, {})) {\n                result.data = void 0;\n            }\n            if (diff.complete) {\n                // Similar to setting result.partial to false, but taking advantage of the\n                // falsiness of missing fields.\n                delete result.partial;\n                // If the diff is complete, and we're using a FetchPolicy that\n                // terminates after a complete cache read, we can assume the next result\n                // we receive will have NetworkStatus.ready and !loading.\n                if (diff.complete &&\n                    result.networkStatus === NetworkStatus.loading &&\n                    (fetchPolicy === \"cache-first\" || fetchPolicy === \"cache-only\")) {\n                    result.networkStatus = NetworkStatus.ready;\n                    result.loading = false;\n                }\n            }\n            else {\n                result.partial = true;\n            }\n            if (globalThis.__DEV__ !== false &&\n                !diff.complete &&\n                !this.options.partialRefetch &&\n                !result.loading &&\n                !result.data &&\n                !result.error) {\n                logMissingFieldErrors(diff.missing);\n            }\n        }\n        if (saveAsLastResult) {\n            this.updateLastResult(result);\n        }\n        return result;\n    };\n    // Compares newResult to the snapshot we took of this.lastResult when it was\n    // first received.\n    ObservableQuery.prototype.isDifferentFromLastResult = function (newResult, variables) {\n        if (!this.last) {\n            return true;\n        }\n        var resultIsDifferent = this.queryManager.getDocumentInfo(this.query).hasNonreactiveDirective ?\n            !equalByQuery(this.query, this.last.result, newResult, this.variables)\n            : !equal(this.last.result, newResult);\n        return (resultIsDifferent || (variables && !equal(this.last.variables, variables)));\n    };\n    ObservableQuery.prototype.getLast = function (key, variablesMustMatch) {\n        var last = this.last;\n        if (last &&\n            last[key] &&\n            (!variablesMustMatch || equal(last.variables, this.variables))) {\n            return last[key];\n        }\n    };\n    ObservableQuery.prototype.getLastResult = function (variablesMustMatch) {\n        return this.getLast(\"result\", variablesMustMatch);\n    };\n    ObservableQuery.prototype.getLastError = function (variablesMustMatch) {\n        return this.getLast(\"error\", variablesMustMatch);\n    };\n    ObservableQuery.prototype.resetLastResults = function () {\n        delete this.last;\n        this.isTornDown = false;\n    };\n    ObservableQuery.prototype.resetQueryStoreErrors = function () {\n        this.queryManager.resetErrors(this.queryId);\n    };\n    /**\n     * Update the variables of this observable query, and fetch the new results.\n     * This method should be preferred over `setVariables` in most use cases.\n     *\n     * @param variables - The new set of variables. If there are missing variables,\n     * the previous values of those variables will be used.\n     */\n    ObservableQuery.prototype.refetch = function (variables) {\n        var _a;\n        var reobserveOptions = {\n            // Always disable polling for refetches.\n            pollInterval: 0,\n        };\n        // Unless the provided fetchPolicy always consults the network\n        // (no-cache, network-only, or cache-and-network), override it with\n        // network-only to force the refetch for this fetchQuery call.\n        var fetchPolicy = this.options.fetchPolicy;\n        if (fetchPolicy === \"cache-and-network\") {\n            reobserveOptions.fetchPolicy = fetchPolicy;\n        }\n        else if (fetchPolicy === \"no-cache\") {\n            reobserveOptions.fetchPolicy = \"no-cache\";\n        }\n        else {\n            reobserveOptions.fetchPolicy = \"network-only\";\n        }\n        if (globalThis.__DEV__ !== false && variables && hasOwnProperty.call(variables, \"variables\")) {\n            var queryDef = getQueryDefinition(this.query);\n            var vars = queryDef.variableDefinitions;\n            if (!vars || !vars.some(function (v) { return v.variable.name.value === \"variables\"; })) {\n                globalThis.__DEV__ !== false && invariant.warn(\n                    20,\n                    variables,\n                    ((_a = queryDef.name) === null || _a === void 0 ? void 0 : _a.value) || queryDef\n                );\n            }\n        }\n        if (variables && !equal(this.options.variables, variables)) {\n            // Update the existing options with new variables\n            reobserveOptions.variables = this.options.variables = __assign(__assign({}, this.options.variables), variables);\n        }\n        this.queryInfo.resetLastWrite();\n        return this.reobserve(reobserveOptions, NetworkStatus.refetch);\n    };\n    /**\n     * A function that helps you fetch the next set of results for a [paginated list field](https://www.apollographql.com/docs/react/pagination/core-api/).\n     */\n    ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {\n        var _this = this;\n        var combinedOptions = __assign(__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : (__assign(__assign(__assign(__assign({}, this.options), { query: this.options.query }), fetchMoreOptions), { variables: __assign(__assign({}, this.options.variables), fetchMoreOptions.variables) })))), { \n            // The fetchMore request goes immediately to the network and does\n            // not automatically write its result to the cache (hence no-cache\n            // instead of network-only), because we allow the caller of\n            // fetchMore to provide an updateQuery callback that determines how\n            // the data gets written to the cache.\n            fetchPolicy: \"no-cache\" });\n        combinedOptions.query = this.transformDocument(combinedOptions.query);\n        var qid = this.queryManager.generateQueryId();\n        // If a temporary query is passed to `fetchMore`, we don't want to store\n        // it as the last query result since it may be an optimized query for\n        // pagination. We will however run the transforms on the original document\n        // as well as the document passed in `fetchMoreOptions` to ensure the cache\n        // uses the most up-to-date document which may rely on runtime conditionals.\n        this.lastQuery =\n            fetchMoreOptions.query ?\n                this.transformDocument(this.options.query)\n                : combinedOptions.query;\n        // Simulate a loading result for the original query with\n        // result.networkStatus === NetworkStatus.fetchMore.\n        var queryInfo = this.queryInfo;\n        var originalNetworkStatus = queryInfo.networkStatus;\n        queryInfo.networkStatus = NetworkStatus.fetchMore;\n        if (combinedOptions.notifyOnNetworkStatusChange) {\n            this.observe();\n        }\n        var updatedQuerySet = new Set();\n        var updateQuery = fetchMoreOptions === null || fetchMoreOptions === void 0 ? void 0 : fetchMoreOptions.updateQuery;\n        var isCached = this.options.fetchPolicy !== \"no-cache\";\n        if (!isCached) {\n            invariant(updateQuery, 21);\n        }\n        return this.queryManager\n            .fetchQuery(qid, combinedOptions, NetworkStatus.fetchMore)\n            .then(function (fetchMoreResult) {\n            _this.queryManager.removeQuery(qid);\n            if (queryInfo.networkStatus === NetworkStatus.fetchMore) {\n                queryInfo.networkStatus = originalNetworkStatus;\n            }\n            if (isCached) {\n                // Performing this cache update inside a cache.batch transaction ensures\n                // any affected cache.watch watchers are notified at most once about any\n                // updates. Most watchers will be using the QueryInfo class, which\n                // responds to notifications by calling reobserveCacheFirst to deliver\n                // fetchMore cache results back to this ObservableQuery.\n                _this.queryManager.cache.batch({\n                    update: function (cache) {\n                        var updateQuery = fetchMoreOptions.updateQuery;\n                        if (updateQuery) {\n                            cache.updateQuery({\n                                query: _this.query,\n                                variables: _this.variables,\n                                returnPartialData: true,\n                                optimistic: false,\n                            }, function (previous) {\n                                return updateQuery(previous, {\n                                    fetchMoreResult: fetchMoreResult.data,\n                                    variables: combinedOptions.variables,\n                                });\n                            });\n                        }\n                        else {\n                            // If we're using a field policy instead of updateQuery, the only\n                            // thing we need to do is write the new data to the cache using\n                            // combinedOptions.variables (instead of this.variables, which is\n                            // what this.updateQuery uses, because it works by abusing the\n                            // original field value, keyed by the original variables).\n                            cache.writeQuery({\n                                query: combinedOptions.query,\n                                variables: combinedOptions.variables,\n                                data: fetchMoreResult.data,\n                            });\n                        }\n                    },\n                    onWatchUpdated: function (watch) {\n                        // Record the DocumentNode associated with any watched query whose\n                        // data were updated by the cache writes above.\n                        updatedQuerySet.add(watch.query);\n                    },\n                });\n            }\n            else {\n                // There is a possibility `lastResult` may not be set when\n                // `fetchMore` is called which would cause this to crash. This should\n                // only happen if we haven't previously reported a result. We don't\n                // quite know what the right behavior should be here since this block\n                // of code runs after the fetch result has executed on the network.\n                // We plan to let it crash in the meantime.\n                //\n                // If we get bug reports due to the `data` property access on\n                // undefined, this should give us a real-world scenario that we can\n                // use to test against and determine the right behavior. If we do end\n                // up changing this behavior, this may require, for example, an\n                // adjustment to the types on `updateQuery` since that function\n                // expects that the first argument always contains previous result\n                // data, but not `undefined`.\n                var lastResult = _this.getLast(\"result\");\n                var data = updateQuery(lastResult.data, {\n                    fetchMoreResult: fetchMoreResult.data,\n                    variables: combinedOptions.variables,\n                });\n                _this.reportResult(__assign(__assign({}, lastResult), { data: data }), _this.variables);\n            }\n            return fetchMoreResult;\n        })\n            .finally(function () {\n            // In case the cache writes above did not generate a broadcast\n            // notification (which would have been intercepted by onWatchUpdated),\n            // likely because the written data were the same as what was already in\n            // the cache, we still want fetchMore to deliver its final loading:false\n            // result with the unchanged data.\n            if (isCached && !updatedQuerySet.has(_this.query)) {\n                reobserveCacheFirst(_this);\n            }\n        });\n    };\n    // XXX the subscription variables are separate from the query variables.\n    // if you want to update subscription variables, right now you have to do that separately,\n    // and you can only do it by stopping the subscription and then subscribing again with new variables.\n    /**\n     * A function that enables you to execute a [subscription](https://www.apollographql.com/docs/react/data/subscriptions/), usually to subscribe to specific fields that were included in the query.\n     *\n     * This function returns _another_ function that you can call to terminate the subscription.\n     */\n    ObservableQuery.prototype.subscribeToMore = function (options) {\n        var _this = this;\n        var subscription = this.queryManager\n            .startGraphQLSubscription({\n            query: options.document,\n            variables: options.variables,\n            context: options.context,\n        })\n            .subscribe({\n            next: function (subscriptionData) {\n                var updateQuery = options.updateQuery;\n                if (updateQuery) {\n                    _this.updateQuery(function (previous, _a) {\n                        var variables = _a.variables;\n                        return updateQuery(previous, {\n                            subscriptionData: subscriptionData,\n                            variables: variables,\n                        });\n                    });\n                }\n            },\n            error: function (err) {\n                if (options.onError) {\n                    options.onError(err);\n                    return;\n                }\n                globalThis.__DEV__ !== false && invariant.error(22, err);\n            },\n        });\n        this.subscriptions.add(subscription);\n        return function () {\n            if (_this.subscriptions.delete(subscription)) {\n                subscription.unsubscribe();\n            }\n        };\n    };\n    ObservableQuery.prototype.setOptions = function (newOptions) {\n        return this.reobserve(newOptions);\n    };\n    ObservableQuery.prototype.silentSetOptions = function (newOptions) {\n        var mergedOptions = compact(this.options, newOptions || {});\n        assign(this.options, mergedOptions);\n    };\n    /**\n     * Update the variables of this observable query, and fetch the new results\n     * if they've changed. Most users should prefer `refetch` instead of\n     * `setVariables` in order to to be properly notified of results even when\n     * they come from the cache.\n     *\n     * Note: the `next` callback will *not* fire if the variables have not changed\n     * or if the result is coming from cache.\n     *\n     * Note: the promise will return the old results immediately if the variables\n     * have not changed.\n     *\n     * Note: the promise will return null immediately if the query is not active\n     * (there are no subscribers).\n     *\n     * @param variables - The new set of variables. If there are missing variables,\n     * the previous values of those variables will be used.\n     */\n    ObservableQuery.prototype.setVariables = function (variables) {\n        if (equal(this.variables, variables)) {\n            // If we have no observers, then we don't actually want to make a network\n            // request. As soon as someone observes the query, the request will kick\n            // off. For now, we just store any changes. (See #1077)\n            return this.observers.size ? this.result() : Promise.resolve();\n        }\n        this.options.variables = variables;\n        // See comment above\n        if (!this.observers.size) {\n            return Promise.resolve();\n        }\n        return this.reobserve({\n            // Reset options.fetchPolicy to its original value.\n            fetchPolicy: this.options.initialFetchPolicy,\n            variables: variables,\n        }, NetworkStatus.setVariables);\n    };\n    /**\n     * A function that enables you to update the query's cached result without executing a followup GraphQL operation.\n     *\n     * See [using updateQuery and updateFragment](https://www.apollographql.com/docs/react/caching/cache-interaction/#using-updatequery-and-updatefragment) for additional information.\n     */\n    ObservableQuery.prototype.updateQuery = function (mapFn) {\n        var queryManager = this.queryManager;\n        var result = queryManager.cache.diff({\n            query: this.options.query,\n            variables: this.variables,\n            returnPartialData: true,\n            optimistic: false,\n        }).result;\n        var newResult = mapFn(result, {\n            variables: this.variables,\n        });\n        if (newResult) {\n            queryManager.cache.writeQuery({\n                query: this.options.query,\n                data: newResult,\n                variables: this.variables,\n            });\n            queryManager.broadcastQueries();\n        }\n    };\n    /**\n     * A function that instructs the query to begin re-executing at a specified interval (in milliseconds).\n     */\n    ObservableQuery.prototype.startPolling = function (pollInterval) {\n        this.options.pollInterval = pollInterval;\n        this.updatePolling();\n    };\n    /**\n     * A function that instructs the query to stop polling after a previous call to `startPolling`.\n     */\n    ObservableQuery.prototype.stopPolling = function () {\n        this.options.pollInterval = 0;\n        this.updatePolling();\n    };\n    // Update options.fetchPolicy according to options.nextFetchPolicy.\n    ObservableQuery.prototype.applyNextFetchPolicy = function (reason, \n    // It's possible to use this method to apply options.nextFetchPolicy to\n    // options.fetchPolicy even if options !== this.options, though that happens\n    // most often when the options are temporary, used for only one request and\n    // then thrown away, so nextFetchPolicy may not end up mattering.\n    options) {\n        if (options.nextFetchPolicy) {\n            var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? \"cache-first\" : _a, _b = options.initialFetchPolicy, initialFetchPolicy = _b === void 0 ? fetchPolicy : _b;\n            if (fetchPolicy === \"standby\") {\n                // Do nothing, leaving options.fetchPolicy unchanged.\n            }\n            else if (typeof options.nextFetchPolicy === \"function\") {\n                // When someone chooses \"cache-and-network\" or \"network-only\" as their\n                // initial FetchPolicy, they often do not want future cache updates to\n                // trigger unconditional network requests, which is what repeatedly\n                // applying the \"cache-and-network\" or \"network-only\" policies would\n                // seem to imply. Instead, when the cache reports an update after the\n                // initial network request, it may be desirable for subsequent network\n                // requests to be triggered only if the cache result is incomplete. To\n                // that end, the options.nextFetchPolicy option provides an easy way to\n                // update options.fetchPolicy after the initial network request, without\n                // having to call observableQuery.setOptions.\n                options.fetchPolicy = options.nextFetchPolicy(fetchPolicy, {\n                    reason: reason,\n                    options: options,\n                    observable: this,\n                    initialFetchPolicy: initialFetchPolicy,\n                });\n            }\n            else if (reason === \"variables-changed\") {\n                options.fetchPolicy = initialFetchPolicy;\n            }\n            else {\n                options.fetchPolicy = options.nextFetchPolicy;\n            }\n        }\n        return options.fetchPolicy;\n    };\n    ObservableQuery.prototype.fetch = function (options, newNetworkStatus, query) {\n        // TODO Make sure we update the networkStatus (and infer fetchVariables)\n        // before actually committing to the fetch.\n        this.queryManager.setObservableQuery(this);\n        return this.queryManager[\"fetchConcastWithInfo\"](this.queryId, options, newNetworkStatus, query);\n    };\n    // Turns polling on or off based on this.options.pollInterval.\n    ObservableQuery.prototype.updatePolling = function () {\n        var _this = this;\n        // Avoid polling in SSR mode\n        if (this.queryManager.ssrMode) {\n            return;\n        }\n        var _a = this, pollingInfo = _a.pollingInfo, pollInterval = _a.options.pollInterval;\n        if (!pollInterval || !this.hasObservers()) {\n            if (pollingInfo) {\n                clearTimeout(pollingInfo.timeout);\n                delete this.pollingInfo;\n            }\n            return;\n        }\n        if (pollingInfo && pollingInfo.interval === pollInterval) {\n            return;\n        }\n        invariant(pollInterval, 23);\n        var info = pollingInfo || (this.pollingInfo = {});\n        info.interval = pollInterval;\n        var maybeFetch = function () {\n            var _a, _b;\n            if (_this.pollingInfo) {\n                if (!isNetworkRequestInFlight(_this.queryInfo.networkStatus) &&\n                    !((_b = (_a = _this.options).skipPollAttempt) === null || _b === void 0 ? void 0 : _b.call(_a))) {\n                    _this.reobserve({\n                        // Most fetchPolicy options don't make sense to use in a polling context, as\n                        // users wouldn't want to be polling the cache directly. However, network-only and\n                        // no-cache are both useful for when the user wants to control whether or not the\n                        // polled results are written to the cache.\n                        fetchPolicy: _this.options.initialFetchPolicy === \"no-cache\" ?\n                            \"no-cache\"\n                            : \"network-only\",\n                    }, NetworkStatus.poll).then(poll, poll);\n                }\n                else {\n                    poll();\n                }\n            }\n        };\n        var poll = function () {\n            var info = _this.pollingInfo;\n            if (info) {\n                clearTimeout(info.timeout);\n                info.timeout = setTimeout(maybeFetch, info.interval);\n            }\n        };\n        poll();\n    };\n    ObservableQuery.prototype.updateLastResult = function (newResult, variables) {\n        if (variables === void 0) { variables = this.variables; }\n        var error = this.getLastError();\n        // Preserve this.last.error unless the variables have changed.\n        if (error && this.last && !equal(variables, this.last.variables)) {\n            error = void 0;\n        }\n        return (this.last = __assign({ result: this.queryManager.assumeImmutableResults ?\n                newResult\n                : cloneDeep(newResult), variables: variables }, (error ? { error: error } : null)));\n    };\n    ObservableQuery.prototype.reobserveAsConcast = function (newOptions, newNetworkStatus) {\n        var _this = this;\n        this.isTornDown = false;\n        var useDisposableConcast = \n        // Refetching uses a disposable Concast to allow refetches using different\n        // options/variables, without permanently altering the options of the\n        // original ObservableQuery.\n        newNetworkStatus === NetworkStatus.refetch ||\n            // The fetchMore method does not actually call the reobserve method, but,\n            // if it did, it would definitely use a disposable Concast.\n            newNetworkStatus === NetworkStatus.fetchMore ||\n            // Polling uses a disposable Concast so the polling options (which force\n            // fetchPolicy to be \"network-only\" or \"no-cache\") won't override the original options.\n            newNetworkStatus === NetworkStatus.poll;\n        // Save the old variables, since Object.assign may modify them below.\n        var oldVariables = this.options.variables;\n        var oldFetchPolicy = this.options.fetchPolicy;\n        var mergedOptions = compact(this.options, newOptions || {});\n        var options = useDisposableConcast ?\n            // Disposable Concast fetches receive a shallow copy of this.options\n            // (merged with newOptions), leaving this.options unmodified.\n            mergedOptions\n            : assign(this.options, mergedOptions);\n        // Don't update options.query with the transformed query to avoid\n        // overwriting this.options.query when we aren't using a disposable concast.\n        // We want to ensure we can re-run the custom document transforms the next\n        // time a request is made against the original query.\n        var query = this.transformDocument(options.query);\n        this.lastQuery = query;\n        if (!useDisposableConcast) {\n            // We can skip calling updatePolling if we're not changing this.options.\n            this.updatePolling();\n            // Reset options.fetchPolicy to its original value when variables change,\n            // unless a new fetchPolicy was provided by newOptions.\n            if (newOptions &&\n                newOptions.variables &&\n                !equal(newOptions.variables, oldVariables) &&\n                // Don't mess with the fetchPolicy if it's currently \"standby\".\n                options.fetchPolicy !== \"standby\" &&\n                // If we're changing the fetchPolicy anyway, don't try to change it here\n                // using applyNextFetchPolicy. The explicit options.fetchPolicy wins.\n                (options.fetchPolicy === oldFetchPolicy ||\n                    // A `nextFetchPolicy` function has even higher priority, though,\n                    // so in that case `applyNextFetchPolicy` must be called.\n                    typeof options.nextFetchPolicy === \"function\")) {\n                this.applyNextFetchPolicy(\"variables-changed\", options);\n                if (newNetworkStatus === void 0) {\n                    newNetworkStatus = NetworkStatus.setVariables;\n                }\n            }\n        }\n        this.waitForOwnResult && (this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy));\n        var finishWaitingForOwnResult = function () {\n            if (_this.concast === concast) {\n                _this.waitForOwnResult = false;\n            }\n        };\n        var variables = options.variables && __assign({}, options.variables);\n        var _a = this.fetch(options, newNetworkStatus, query), concast = _a.concast, fromLink = _a.fromLink;\n        var observer = {\n            next: function (result) {\n                if (equal(_this.variables, variables)) {\n                    finishWaitingForOwnResult();\n                    _this.reportResult(result, variables);\n                }\n            },\n            error: function (error) {\n                if (equal(_this.variables, variables)) {\n                    // Coming from `getResultsFromLink`, `error` here should always be an `ApolloError`.\n                    // However, calling `concast.cancel` can inject another type of error, so we have to\n                    // wrap it again here.\n                    if (!isApolloError(error)) {\n                        error = new ApolloError({ networkError: error });\n                    }\n                    finishWaitingForOwnResult();\n                    _this.reportError(error, variables);\n                }\n            },\n        };\n        if (!useDisposableConcast && (fromLink || !this.concast)) {\n            // We use the {add,remove}Observer methods directly to avoid wrapping\n            // observer with an unnecessary SubscriptionObserver object.\n            if (this.concast && this.observer) {\n                this.concast.removeObserver(this.observer);\n            }\n            this.concast = concast;\n            this.observer = observer;\n        }\n        concast.addObserver(observer);\n        return concast;\n    };\n    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {\n        return this.reobserveAsConcast(newOptions, newNetworkStatus)\n            .promise;\n    };\n    ObservableQuery.prototype.resubscribeAfterError = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        // If `lastError` is set in the current when the subscription is re-created,\n        // the subscription will immediately receive the error, which will\n        // cause it to terminate again. To avoid this, we first clear\n        // the last error/result from the `observableQuery` before re-starting\n        // the subscription, and restore the last value afterwards so that the\n        // subscription has a chance to stay open.\n        var last = this.last;\n        this.resetLastResults();\n        var subscription = this.subscribe.apply(this, args);\n        this.last = last;\n        return subscription;\n    };\n    // (Re)deliver the current result to this.observers without applying fetch\n    // policies or making network requests.\n    ObservableQuery.prototype.observe = function () {\n        this.reportResult(\n        // Passing false is important so that this.getCurrentResult doesn't\n        // save the fetchMore result as this.lastResult, causing it to be\n        // ignored due to the this.isDifferentFromLastResult check in\n        // this.reportResult.\n        this.getCurrentResult(false), this.variables);\n    };\n    ObservableQuery.prototype.reportResult = function (result, variables) {\n        var lastError = this.getLastError();\n        var isDifferent = this.isDifferentFromLastResult(result, variables);\n        // Update the last result even when isDifferentFromLastResult returns false,\n        // because the query may be using the @nonreactive directive, and we want to\n        // save the the latest version of any nonreactive subtrees (in case\n        // getCurrentResult is called), even though we skip broadcasting changes.\n        if (lastError || !result.partial || this.options.returnPartialData) {\n            this.updateLastResult(result, variables);\n        }\n        if (lastError || isDifferent) {\n            iterateObserversSafely(this.observers, \"next\", result);\n        }\n    };\n    ObservableQuery.prototype.reportError = function (error, variables) {\n        // Since we don't get the current result on errors, only the error, we\n        // must mirror the updates that occur in QueryStore.markQueryError here\n        var errorResult = __assign(__assign({}, this.getLastResult()), { error: error, errors: error.graphQLErrors, networkStatus: NetworkStatus.error, loading: false });\n        this.updateLastResult(errorResult, variables);\n        iterateObserversSafely(this.observers, \"error\", (this.last.error = error));\n    };\n    ObservableQuery.prototype.hasObservers = function () {\n        return this.observers.size > 0;\n    };\n    ObservableQuery.prototype.tearDownQuery = function () {\n        if (this.isTornDown)\n            return;\n        if (this.concast && this.observer) {\n            this.concast.removeObserver(this.observer);\n            delete this.concast;\n            delete this.observer;\n        }\n        this.stopPolling();\n        // stop all active GraphQL subscriptions\n        this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });\n        this.subscriptions.clear();\n        this.queryManager.stopQuery(this.queryId);\n        this.observers.clear();\n        this.isTornDown = true;\n    };\n    ObservableQuery.prototype.transformDocument = function (document) {\n        return this.queryManager.transform(document);\n    };\n    return ObservableQuery;\n}(Observable));\nexport { ObservableQuery };\n// Necessary because the ObservableQuery constructor has a different\n// signature than the Observable constructor.\nfixObservableSubclass(ObservableQuery);\n// Reobserve with fetchPolicy effectively set to \"cache-first\", triggering\n// delivery of any new data from the cache, possibly falling back to the network\n// if any cache data are missing. This allows _complete_ cache results to be\n// delivered without also kicking off unnecessary network requests when\n// this.options.fetchPolicy is \"cache-and-network\" or \"network-only\". When\n// this.options.fetchPolicy is any other policy (\"cache-first\", \"cache-only\",\n// \"standby\", or \"no-cache\"), we call this.reobserve() as usual.\nexport function reobserveCacheFirst(obsQuery) {\n    var _a = obsQuery.options, fetchPolicy = _a.fetchPolicy, nextFetchPolicy = _a.nextFetchPolicy;\n    if (fetchPolicy === \"cache-and-network\" || fetchPolicy === \"network-only\") {\n        return obsQuery.reobserve({\n            fetchPolicy: \"cache-first\",\n            // Use a temporary nextFetchPolicy function that replaces itself with the\n            // previous nextFetchPolicy value and returns the original fetchPolicy.\n            nextFetchPolicy: function (currentFetchPolicy, context) {\n                // Replace this nextFetchPolicy function in the options object with the\n                // original this.options.nextFetchPolicy value.\n                this.nextFetchPolicy = nextFetchPolicy;\n                // If the original nextFetchPolicy value was a function, give it a\n                // chance to decide what happens here.\n                if (typeof this.nextFetchPolicy === \"function\") {\n                    return this.nextFetchPolicy(currentFetchPolicy, context);\n                }\n                // Otherwise go back to the original this.options.fetchPolicy.\n                return fetchPolicy;\n            },\n        });\n    }\n    return obsQuery.reobserve();\n}\nfunction defaultSubscriptionObserverErrorCallback(error) {\n    globalThis.__DEV__ !== false && invariant.error(24, error.message, error.stack);\n}\nexport function logMissingFieldErrors(missing) {\n    if (globalThis.__DEV__ !== false && missing) {\n        globalThis.__DEV__ !== false && invariant.debug(25, missing);\n    }\n}\nfunction skipCacheDataFor(fetchPolicy /* `undefined` would mean `\"cache-first\"` */) {\n    return (fetchPolicy === \"network-only\" ||\n        fetchPolicy === \"no-cache\" ||\n        fetchPolicy === \"standby\");\n}\n//# sourceMappingURL=ObservableQuery.js.map","import { __assign } from \"tslib\";\nimport { equal } from \"@wry/equality\";\nimport { DeepMerger } from \"../utilities/index.js\";\nimport { mergeIncrementalData } from \"../utilities/index.js\";\nimport { reobserveCacheFirst } from \"./ObservableQuery.js\";\nimport { isNonEmptyArray, graphQLResultHasError, canUseWeakMap, } from \"../utilities/index.js\";\nimport { NetworkStatus, isNetworkRequestInFlight } from \"./networkStatus.js\";\nvar destructiveMethodCounts = new (canUseWeakMap ? WeakMap : Map)();\nfunction wrapDestructiveCacheMethod(cache, methodName) {\n    var original = cache[methodName];\n    if (typeof original === \"function\") {\n        // @ts-expect-error this is just too generic to be typed correctly\n        cache[methodName] = function () {\n            destructiveMethodCounts.set(cache, \n            // The %1e15 allows the count to wrap around to 0 safely every\n            // quadrillion evictions, so there's no risk of overflow. To be\n            // clear, this is more of a pedantic principle than something\n            // that matters in any conceivable practical scenario.\n            (destructiveMethodCounts.get(cache) + 1) % 1e15);\n            // @ts-expect-error this is just too generic to be typed correctly\n            return original.apply(this, arguments);\n        };\n    }\n}\nfunction cancelNotifyTimeout(info) {\n    if (info[\"notifyTimeout\"]) {\n        clearTimeout(info[\"notifyTimeout\"]);\n        info[\"notifyTimeout\"] = void 0;\n    }\n}\n// A QueryInfo object represents a single query managed by the\n// QueryManager, which tracks all QueryInfo objects by queryId in its\n// this.queries Map. QueryInfo objects store the latest results and errors\n// for the given query, and are responsible for reporting those results to\n// the corresponding ObservableQuery, via the QueryInfo.notify method.\n// Results are reported asynchronously whenever setDiff marks the\n// QueryInfo object as dirty, though a call to the QueryManager's\n// broadcastQueries method may trigger the notification before it happens\n// automatically. This class used to be a simple interface type without\n// any field privacy or meaningful methods, which is why it still has so\n// many public fields. The effort to lock down and simplify the QueryInfo\n// interface is ongoing, and further improvements are welcome.\nvar QueryInfo = /** @class */ (function () {\n    function QueryInfo(queryManager, queryId) {\n        if (queryId === void 0) { queryId = queryManager.generateQueryId(); }\n        this.queryId = queryId;\n        this.listeners = new Set();\n        this.document = null;\n        this.lastRequestId = 1;\n        this.stopped = false;\n        this.dirty = false;\n        this.observableQuery = null;\n        var cache = (this.cache = queryManager.cache);\n        // Track how often cache.evict is called, since we want eviction to\n        // override the feud-stopping logic in the markResult method, by\n        // causing shouldWrite to return true. Wrapping the cache.evict method\n        // is a bit of a hack, but it saves us from having to make eviction\n        // counting an official part of the ApolloCache API.\n        if (!destructiveMethodCounts.has(cache)) {\n            destructiveMethodCounts.set(cache, 0);\n            wrapDestructiveCacheMethod(cache, \"evict\");\n            wrapDestructiveCacheMethod(cache, \"modify\");\n            wrapDestructiveCacheMethod(cache, \"reset\");\n        }\n    }\n    QueryInfo.prototype.init = function (query) {\n        var networkStatus = query.networkStatus || NetworkStatus.loading;\n        if (this.variables &&\n            this.networkStatus !== NetworkStatus.loading &&\n            !equal(this.variables, query.variables)) {\n            networkStatus = NetworkStatus.setVariables;\n        }\n        if (!equal(query.variables, this.variables)) {\n            this.lastDiff = void 0;\n        }\n        Object.assign(this, {\n            document: query.document,\n            variables: query.variables,\n            networkError: null,\n            graphQLErrors: this.graphQLErrors || [],\n            networkStatus: networkStatus,\n        });\n        if (query.observableQuery) {\n            this.setObservableQuery(query.observableQuery);\n        }\n        if (query.lastRequestId) {\n            this.lastRequestId = query.lastRequestId;\n        }\n        return this;\n    };\n    QueryInfo.prototype.reset = function () {\n        cancelNotifyTimeout(this);\n        this.dirty = false;\n    };\n    QueryInfo.prototype.resetDiff = function () {\n        this.lastDiff = void 0;\n    };\n    QueryInfo.prototype.getDiff = function () {\n        var options = this.getDiffOptions();\n        if (this.lastDiff && equal(options, this.lastDiff.options)) {\n            return this.lastDiff.diff;\n        }\n        this.updateWatch(this.variables);\n        var oq = this.observableQuery;\n        if (oq && oq.options.fetchPolicy === \"no-cache\") {\n            return { complete: false };\n        }\n        var diff = this.cache.diff(options);\n        this.updateLastDiff(diff, options);\n        return diff;\n    };\n    QueryInfo.prototype.updateLastDiff = function (diff, options) {\n        this.lastDiff =\n            diff ?\n                {\n                    diff: diff,\n                    options: options || this.getDiffOptions(),\n                }\n                : void 0;\n    };\n    QueryInfo.prototype.getDiffOptions = function (variables) {\n        var _a;\n        if (variables === void 0) { variables = this.variables; }\n        return {\n            query: this.document,\n            variables: variables,\n            returnPartialData: true,\n            optimistic: true,\n            canonizeResults: (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.options.canonizeResults,\n        };\n    };\n    QueryInfo.prototype.setDiff = function (diff) {\n        var _this = this;\n        var _a;\n        var oldDiff = this.lastDiff && this.lastDiff.diff;\n        // If we are trying to deliver an incomplete cache result, we avoid\n        // reporting it if the query has errored, otherwise we let the broadcast try\n        // and repair the partial result by refetching the query. This check avoids\n        // a situation where a query that errors and another succeeds with\n        // overlapping data does not report the partial data result to the errored\n        // query.\n        //\n        // See https://github.com/apollographql/apollo-client/issues/11400 for more\n        // information on this issue.\n        if (diff && !diff.complete && ((_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.getLastError())) {\n            return;\n        }\n        this.updateLastDiff(diff);\n        if (!this.dirty && !equal(oldDiff && oldDiff.result, diff && diff.result)) {\n            this.dirty = true;\n            if (!this.notifyTimeout) {\n                this.notifyTimeout = setTimeout(function () { return _this.notify(); }, 0);\n            }\n        }\n    };\n    QueryInfo.prototype.setObservableQuery = function (oq) {\n        var _this = this;\n        if (oq === this.observableQuery)\n            return;\n        if (this.oqListener) {\n            this.listeners.delete(this.oqListener);\n        }\n        this.observableQuery = oq;\n        if (oq) {\n            oq[\"queryInfo\"] = this;\n            this.listeners.add((this.oqListener = function () {\n                var diff = _this.getDiff();\n                if (diff.fromOptimisticTransaction) {\n                    // If this diff came from an optimistic transaction, deliver the\n                    // current cache data to the ObservableQuery, but don't perform a\n                    // reobservation, since oq.reobserveCacheFirst might make a network\n                    // request, and we never want to trigger network requests in the\n                    // middle of optimistic updates.\n                    oq[\"observe\"]();\n                }\n                else {\n                    // Otherwise, make the ObservableQuery \"reobserve\" the latest data\n                    // using a temporary fetch policy of \"cache-first\", so complete cache\n                    // results have a chance to be delivered without triggering additional\n                    // network requests, even when options.fetchPolicy is \"network-only\"\n                    // or \"cache-and-network\". All other fetch policies are preserved by\n                    // this method, and are handled by calling oq.reobserve(). If this\n                    // reobservation is spurious, isDifferentFromLastResult still has a\n                    // chance to catch it before delivery to ObservableQuery subscribers.\n                    reobserveCacheFirst(oq);\n                }\n            }));\n        }\n        else {\n            delete this.oqListener;\n        }\n    };\n    QueryInfo.prototype.notify = function () {\n        var _this = this;\n        cancelNotifyTimeout(this);\n        if (this.shouldNotify()) {\n            this.listeners.forEach(function (listener) { return listener(_this); });\n        }\n        this.dirty = false;\n    };\n    QueryInfo.prototype.shouldNotify = function () {\n        if (!this.dirty || !this.listeners.size) {\n            return false;\n        }\n        if (isNetworkRequestInFlight(this.networkStatus) && this.observableQuery) {\n            var fetchPolicy = this.observableQuery.options.fetchPolicy;\n            if (fetchPolicy !== \"cache-only\" && fetchPolicy !== \"cache-and-network\") {\n                return false;\n            }\n        }\n        return true;\n    };\n    QueryInfo.prototype.stop = function () {\n        if (!this.stopped) {\n            this.stopped = true;\n            // Cancel the pending notify timeout\n            this.reset();\n            this.cancel();\n            // Revert back to the no-op version of cancel inherited from\n            // QueryInfo.prototype.\n            this.cancel = QueryInfo.prototype.cancel;\n            var oq = this.observableQuery;\n            if (oq)\n                oq.stopPolling();\n        }\n    };\n    // This method is a no-op by default, until/unless overridden by the\n    // updateWatch method.\n    QueryInfo.prototype.cancel = function () { };\n    QueryInfo.prototype.updateWatch = function (variables) {\n        var _this = this;\n        if (variables === void 0) { variables = this.variables; }\n        var oq = this.observableQuery;\n        if (oq && oq.options.fetchPolicy === \"no-cache\") {\n            return;\n        }\n        var watchOptions = __assign(__assign({}, this.getDiffOptions(variables)), { watcher: this, callback: function (diff) { return _this.setDiff(diff); } });\n        if (!this.lastWatch || !equal(watchOptions, this.lastWatch)) {\n            this.cancel();\n            this.cancel = this.cache.watch((this.lastWatch = watchOptions));\n        }\n    };\n    QueryInfo.prototype.resetLastWrite = function () {\n        this.lastWrite = void 0;\n    };\n    QueryInfo.prototype.shouldWrite = function (result, variables) {\n        var lastWrite = this.lastWrite;\n        return !(lastWrite &&\n            // If cache.evict has been called since the last time we wrote this\n            // data into the cache, there's a chance writing this result into\n            // the cache will repair what was evicted.\n            lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&\n            equal(variables, lastWrite.variables) &&\n            equal(result.data, lastWrite.result.data));\n    };\n    QueryInfo.prototype.markResult = function (result, document, options, cacheWriteBehavior) {\n        var _this = this;\n        var merger = new DeepMerger();\n        var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];\n        // Cancel the pending notify timeout (if it exists) to prevent extraneous network\n        // requests. To allow future notify timeouts, diff and dirty are reset as well.\n        this.reset();\n        if (\"incremental\" in result && isNonEmptyArray(result.incremental)) {\n            var mergedData = mergeIncrementalData(this.getDiff().result, result);\n            result.data = mergedData;\n            // Detect the first chunk of a deferred query and merge it with existing\n            // cache data. This ensures a `cache-first` fetch policy that returns\n            // partial cache data or a `cache-and-network` fetch policy that already\n            // has full data in the cache does not complain when trying to merge the\n            // initial deferred server data with existing cache data.\n        }\n        else if (\"hasNext\" in result && result.hasNext) {\n            var diff = this.getDiff();\n            result.data = merger.merge(diff.result, result.data);\n        }\n        this.graphQLErrors = graphQLErrors;\n        if (options.fetchPolicy === \"no-cache\") {\n            this.updateLastDiff({ result: result.data, complete: true }, this.getDiffOptions(options.variables));\n        }\n        else if (cacheWriteBehavior !== 0 /* CacheWriteBehavior.FORBID */) {\n            if (shouldWriteResult(result, options.errorPolicy)) {\n                // Using a transaction here so we have a chance to read the result\n                // back from the cache before the watch callback fires as a result\n                // of writeQuery, so we can store the new diff quietly and ignore\n                // it when we receive it redundantly from the watch callback.\n                this.cache.performTransaction(function (cache) {\n                    if (_this.shouldWrite(result, options.variables)) {\n                        cache.writeQuery({\n                            query: document,\n                            data: result.data,\n                            variables: options.variables,\n                            overwrite: cacheWriteBehavior === 1 /* CacheWriteBehavior.OVERWRITE */,\n                        });\n                        _this.lastWrite = {\n                            result: result,\n                            variables: options.variables,\n                            dmCount: destructiveMethodCounts.get(_this.cache),\n                        };\n                    }\n                    else {\n                        // If result is the same as the last result we received from\n                        // the network (and the variables match too), avoid writing\n                        // result into the cache again. The wisdom of skipping this\n                        // cache write is far from obvious, since any cache write\n                        // could be the one that puts the cache back into a desired\n                        // state, fixing corruption or missing data. However, if we\n                        // always write every network result into the cache, we enable\n                        // feuds between queries competing to update the same data in\n                        // incompatible ways, which can lead to an endless cycle of\n                        // cache broadcasts and useless network requests. As with any\n                        // feud, eventually one side must step back from the brink,\n                        // letting the other side(s) have the last word(s). There may\n                        // be other points where we could break this cycle, such as\n                        // silencing the broadcast for cache.writeQuery (not a good\n                        // idea, since it just delays the feud a bit) or somehow\n                        // avoiding the network request that just happened (also bad,\n                        // because the server could return useful new data). All\n                        // options considered, skipping this cache write seems to be\n                        // the least damaging place to break the cycle, because it\n                        // reflects the intuition that we recently wrote this exact\n                        // result into the cache, so the cache *should* already/still\n                        // contain this data. If some other query has clobbered that\n                        // data in the meantime, that's too bad, but there will be no\n                        // winners if every query blindly reverts to its own version\n                        // of the data. This approach also gives the network a chance\n                        // to return new data, which will be written into the cache as\n                        // usual, notifying only those queries that are directly\n                        // affected by the cache updates, as usual. In the future, an\n                        // even more sophisticated cache could perhaps prevent or\n                        // mitigate the clobbering somehow, but that would make this\n                        // particular cache write even less important, and thus\n                        // skipping it would be even safer than it is today.\n                        if (_this.lastDiff && _this.lastDiff.diff.complete) {\n                            // Reuse data from the last good (complete) diff that we\n                            // received, when possible.\n                            result.data = _this.lastDiff.diff.result;\n                            return;\n                        }\n                        // If the previous this.diff was incomplete, fall through to\n                        // re-reading the latest data with cache.diff, below.\n                    }\n                    var diffOptions = _this.getDiffOptions(options.variables);\n                    var diff = cache.diff(diffOptions);\n                    // In case the QueryManager stops this QueryInfo before its\n                    // results are delivered, it's important to avoid restarting the\n                    // cache watch when markResult is called. We also avoid updating\n                    // the watch if we are writing a result that doesn't match the current\n                    // variables to avoid race conditions from broadcasting the wrong\n                    // result.\n                    if (!_this.stopped && equal(_this.variables, options.variables)) {\n                        // Any time we're about to update this.diff, we need to make\n                        // sure we've started watching the cache.\n                        _this.updateWatch(options.variables);\n                    }\n                    // If we're allowed to write to the cache, and we can read a\n                    // complete result from the cache, update result.data to be the\n                    // result from the cache, rather than the raw network result.\n                    // Set without setDiff to avoid triggering a notify call, since\n                    // we have other ways of notifying for this result.\n                    _this.updateLastDiff(diff, diffOptions);\n                    if (diff.complete) {\n                        result.data = diff.result;\n                    }\n                });\n            }\n            else {\n                this.lastWrite = void 0;\n            }\n        }\n    };\n    QueryInfo.prototype.markReady = function () {\n        this.networkError = null;\n        return (this.networkStatus = NetworkStatus.ready);\n    };\n    QueryInfo.prototype.markError = function (error) {\n        this.networkStatus = NetworkStatus.error;\n        this.lastWrite = void 0;\n        this.reset();\n        if (error.graphQLErrors) {\n            this.graphQLErrors = error.graphQLErrors;\n        }\n        if (error.networkError) {\n            this.networkError = error.networkError;\n        }\n        return error;\n    };\n    return QueryInfo;\n}());\nexport { QueryInfo };\nexport function shouldWriteResult(result, errorPolicy) {\n    if (errorPolicy === void 0) { errorPolicy = \"none\"; }\n    var ignoreErrors = errorPolicy === \"ignore\" || errorPolicy === \"all\";\n    var writeWithErrors = !graphQLResultHasError(result);\n    if (!writeWithErrors && ignoreErrors && result.data) {\n        writeWithErrors = true;\n    }\n    return writeWithErrors;\n}\n//# sourceMappingURL=QueryInfo.js.map","import { __assign, __awaiter, __generator } from \"tslib\";\nimport { invariant, newInvariantError } from \"../utilities/globals/index.js\";\nimport { equal } from \"@wry/equality\";\nimport { execute } from \"../link/core/index.js\";\nimport { hasDirectives, isExecutionPatchIncrementalResult, isExecutionPatchResult, removeDirectivesFromDocument, } from \"../utilities/index.js\";\nimport { canonicalStringify } from \"../cache/index.js\";\nimport { getDefaultValues, getOperationDefinition, getOperationName, hasClientExports, graphQLResultHasError, getGraphQLErrorsFromResult, Observable, asyncMap, isNonEmptyArray, Concast, makeUniqueId, isDocumentNode, isNonNullObject, DocumentTransform, } from \"../utilities/index.js\";\nimport { mergeIncrementalData } from \"../utilities/common/incrementalResult.js\";\nimport { ApolloError, isApolloError, graphQLResultHasProtocolErrors, } from \"../errors/index.js\";\nimport { ObservableQuery, logMissingFieldErrors } from \"./ObservableQuery.js\";\nimport { NetworkStatus, isNetworkRequestInFlight } from \"./networkStatus.js\";\nimport { QueryInfo, shouldWriteResult, } from \"./QueryInfo.js\";\nimport { PROTOCOL_ERRORS_SYMBOL } from \"../errors/index.js\";\nimport { print } from \"../utilities/index.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar IGNORE = Object.create(null);\nimport { Trie } from \"@wry/trie\";\nimport { AutoCleanedWeakCache, cacheSizes } from \"../utilities/index.js\";\nvar QueryManager = /** @class */ (function () {\n    function QueryManager(options) {\n        var _this = this;\n        this.clientAwareness = {};\n        // All the queries that the QueryManager is currently managing (not\n        // including mutations and subscriptions).\n        this.queries = new Map();\n        // Maps from queryId strings to Promise rejection functions for\n        // currently active queries and fetches.\n        // Use protected instead of private field so\n        // @apollo/experimental-nextjs-app-support can access type info.\n        this.fetchCancelFns = new Map();\n        this.transformCache = new AutoCleanedWeakCache(cacheSizes[\"queryManager.getDocumentInfo\"] ||\n            2000 /* defaultCacheSizes[\"queryManager.getDocumentInfo\"] */);\n        this.queryIdCounter = 1;\n        this.requestIdCounter = 1;\n        this.mutationIdCounter = 1;\n        // Use protected instead of private field so\n        // @apollo/experimental-nextjs-app-support can access type info.\n        this.inFlightLinkObservables = new Trie(false);\n        var defaultDocumentTransform = new DocumentTransform(function (document) { return _this.cache.transformDocument(document); }, \n        // Allow the apollo cache to manage its own transform caches\n        { cache: false });\n        this.cache = options.cache;\n        this.link = options.link;\n        this.defaultOptions = options.defaultOptions;\n        this.queryDeduplication = options.queryDeduplication;\n        this.clientAwareness = options.clientAwareness;\n        this.localState = options.localState;\n        this.ssrMode = options.ssrMode;\n        this.assumeImmutableResults = options.assumeImmutableResults;\n        var documentTransform = options.documentTransform;\n        this.documentTransform =\n            documentTransform ?\n                defaultDocumentTransform\n                    .concat(documentTransform)\n                    // The custom document transform may add new fragment spreads or new\n                    // field selections, so we want to give the cache a chance to run\n                    // again. For example, the InMemoryCache adds __typename to field\n                    // selections and fragments from the fragment registry.\n                    .concat(defaultDocumentTransform)\n                : defaultDocumentTransform;\n        this.defaultContext = options.defaultContext || Object.create(null);\n        if ((this.onBroadcast = options.onBroadcast)) {\n            this.mutationStore = Object.create(null);\n        }\n    }\n    /**\n     * Call this method to terminate any active query processes, making it safe\n     * to dispose of this QueryManager instance.\n     */\n    QueryManager.prototype.stop = function () {\n        var _this = this;\n        this.queries.forEach(function (_info, queryId) {\n            _this.stopQueryNoBroadcast(queryId);\n        });\n        this.cancelPendingFetches(newInvariantError(26));\n    };\n    QueryManager.prototype.cancelPendingFetches = function (error) {\n        this.fetchCancelFns.forEach(function (cancel) { return cancel(error); });\n        this.fetchCancelFns.clear();\n    };\n    QueryManager.prototype.mutate = function (_a) {\n        return __awaiter(this, arguments, void 0, function (_b) {\n            var mutationId, hasClientExports, mutationStoreValue, isOptimistic, self;\n            var _c, _d;\n            var mutation = _b.mutation, variables = _b.variables, optimisticResponse = _b.optimisticResponse, updateQueries = _b.updateQueries, _e = _b.refetchQueries, refetchQueries = _e === void 0 ? [] : _e, _f = _b.awaitRefetchQueries, awaitRefetchQueries = _f === void 0 ? false : _f, updateWithProxyFn = _b.update, onQueryUpdated = _b.onQueryUpdated, _g = _b.fetchPolicy, fetchPolicy = _g === void 0 ? ((_c = this.defaultOptions.mutate) === null || _c === void 0 ? void 0 : _c.fetchPolicy) || \"network-only\" : _g, _h = _b.errorPolicy, errorPolicy = _h === void 0 ? ((_d = this.defaultOptions.mutate) === null || _d === void 0 ? void 0 : _d.errorPolicy) || \"none\" : _h, keepRootFields = _b.keepRootFields, context = _b.context;\n            return __generator(this, function (_j) {\n                switch (_j.label) {\n                    case 0:\n                        invariant(mutation, 27);\n                        invariant(fetchPolicy === \"network-only\" || fetchPolicy === \"no-cache\", 28);\n                        mutationId = this.generateMutationId();\n                        mutation = this.cache.transformForLink(this.transform(mutation));\n                        hasClientExports = this.getDocumentInfo(mutation).hasClientExports;\n                        variables = this.getVariables(mutation, variables);\n                        if (!hasClientExports) return [3 /*break*/, 2];\n                        return [4 /*yield*/, this.localState.addExportedVariables(mutation, variables, context)];\n                    case 1:\n                        variables = (_j.sent());\n                        _j.label = 2;\n                    case 2:\n                        mutationStoreValue = this.mutationStore &&\n                            (this.mutationStore[mutationId] = {\n                                mutation: mutation,\n                                variables: variables,\n                                loading: true,\n                                error: null,\n                            });\n                        isOptimistic = optimisticResponse &&\n                            this.markMutationOptimistic(optimisticResponse, {\n                                mutationId: mutationId,\n                                document: mutation,\n                                variables: variables,\n                                fetchPolicy: fetchPolicy,\n                                errorPolicy: errorPolicy,\n                                context: context,\n                                updateQueries: updateQueries,\n                                update: updateWithProxyFn,\n                                keepRootFields: keepRootFields,\n                            });\n                        this.broadcastQueries();\n                        self = this;\n                        return [2 /*return*/, new Promise(function (resolve, reject) {\n                                return asyncMap(self.getObservableFromLink(mutation, __assign(__assign({}, context), { optimisticResponse: isOptimistic ? optimisticResponse : void 0 }), variables, {}, false), function (result) {\n                                    if (graphQLResultHasError(result) && errorPolicy === \"none\") {\n                                        throw new ApolloError({\n                                            graphQLErrors: getGraphQLErrorsFromResult(result),\n                                        });\n                                    }\n                                    if (mutationStoreValue) {\n                                        mutationStoreValue.loading = false;\n                                        mutationStoreValue.error = null;\n                                    }\n                                    var storeResult = __assign({}, result);\n                                    if (typeof refetchQueries === \"function\") {\n                                        refetchQueries = refetchQueries(storeResult);\n                                    }\n                                    if (errorPolicy === \"ignore\" && graphQLResultHasError(storeResult)) {\n                                        delete storeResult.errors;\n                                    }\n                                    return self.markMutationResult({\n                                        mutationId: mutationId,\n                                        result: storeResult,\n                                        document: mutation,\n                                        variables: variables,\n                                        fetchPolicy: fetchPolicy,\n                                        errorPolicy: errorPolicy,\n                                        context: context,\n                                        update: updateWithProxyFn,\n                                        updateQueries: updateQueries,\n                                        awaitRefetchQueries: awaitRefetchQueries,\n                                        refetchQueries: refetchQueries,\n                                        removeOptimistic: isOptimistic ? mutationId : void 0,\n                                        onQueryUpdated: onQueryUpdated,\n                                        keepRootFields: keepRootFields,\n                                    });\n                                }).subscribe({\n                                    next: function (storeResult) {\n                                        self.broadcastQueries();\n                                        // Since mutations might receive multiple payloads from the\n                                        // ApolloLink chain (e.g. when used with @defer),\n                                        // we resolve with a SingleExecutionResult or after the final\n                                        // ExecutionPatchResult has arrived and we have assembled the\n                                        // multipart response into a single result.\n                                        if (!(\"hasNext\" in storeResult) || storeResult.hasNext === false) {\n                                            resolve(storeResult);\n                                        }\n                                    },\n                                    error: function (err) {\n                                        if (mutationStoreValue) {\n                                            mutationStoreValue.loading = false;\n                                            mutationStoreValue.error = err;\n                                        }\n                                        if (isOptimistic) {\n                                            self.cache.removeOptimistic(mutationId);\n                                        }\n                                        self.broadcastQueries();\n                                        reject(err instanceof ApolloError ? err : (new ApolloError({\n                                            networkError: err,\n                                        })));\n                                    },\n                                });\n                            })];\n                }\n            });\n        });\n    };\n    QueryManager.prototype.markMutationResult = function (mutation, cache) {\n        var _this = this;\n        if (cache === void 0) { cache = this.cache; }\n        var result = mutation.result;\n        var cacheWrites = [];\n        var skipCache = mutation.fetchPolicy === \"no-cache\";\n        if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {\n            if (!isExecutionPatchIncrementalResult(result)) {\n                cacheWrites.push({\n                    result: result.data,\n                    dataId: \"ROOT_MUTATION\",\n                    query: mutation.document,\n                    variables: mutation.variables,\n                });\n            }\n            if (isExecutionPatchIncrementalResult(result) &&\n                isNonEmptyArray(result.incremental)) {\n                var diff = cache.diff({\n                    id: \"ROOT_MUTATION\",\n                    // The cache complains if passed a mutation where it expects a\n                    // query, so we transform mutations and subscriptions to queries\n                    // (only once, thanks to this.transformCache).\n                    query: this.getDocumentInfo(mutation.document).asQuery,\n                    variables: mutation.variables,\n                    optimistic: false,\n                    returnPartialData: true,\n                });\n                var mergedData = void 0;\n                if (diff.result) {\n                    mergedData = mergeIncrementalData(diff.result, result);\n                }\n                if (typeof mergedData !== \"undefined\") {\n                    // cast the ExecutionPatchResult to FetchResult here since\n                    // ExecutionPatchResult never has `data` when returned from the server\n                    result.data = mergedData;\n                    cacheWrites.push({\n                        result: mergedData,\n                        dataId: \"ROOT_MUTATION\",\n                        query: mutation.document,\n                        variables: mutation.variables,\n                    });\n                }\n            }\n            var updateQueries_1 = mutation.updateQueries;\n            if (updateQueries_1) {\n                this.queries.forEach(function (_a, queryId) {\n                    var observableQuery = _a.observableQuery;\n                    var queryName = observableQuery && observableQuery.queryName;\n                    if (!queryName || !hasOwnProperty.call(updateQueries_1, queryName)) {\n                        return;\n                    }\n                    var updater = updateQueries_1[queryName];\n                    var _b = _this.queries.get(queryId), document = _b.document, variables = _b.variables;\n                    // Read the current query result from the store.\n                    var _c = cache.diff({\n                        query: document,\n                        variables: variables,\n                        returnPartialData: true,\n                        optimistic: false,\n                    }), currentQueryResult = _c.result, complete = _c.complete;\n                    if (complete && currentQueryResult) {\n                        // Run our reducer using the current query result and the mutation result.\n                        var nextQueryResult = updater(currentQueryResult, {\n                            mutationResult: result,\n                            queryName: (document && getOperationName(document)) || void 0,\n                            queryVariables: variables,\n                        });\n                        // Write the modified result back into the store if we got a new result.\n                        if (nextQueryResult) {\n                            cacheWrites.push({\n                                result: nextQueryResult,\n                                dataId: \"ROOT_QUERY\",\n                                query: document,\n                                variables: variables,\n                            });\n                        }\n                    }\n                });\n            }\n        }\n        if (cacheWrites.length > 0 ||\n            (mutation.refetchQueries || \"\").length > 0 ||\n            mutation.update ||\n            mutation.onQueryUpdated ||\n            mutation.removeOptimistic) {\n            var results_1 = [];\n            this.refetchQueries({\n                updateCache: function (cache) {\n                    if (!skipCache) {\n                        cacheWrites.forEach(function (write) { return cache.write(write); });\n                    }\n                    // If the mutation has some writes associated with it then we need to\n                    // apply those writes to the store by running this reducer again with\n                    // a write action.\n                    var update = mutation.update;\n                    // Determine whether result is a SingleExecutionResult,\n                    // or the final ExecutionPatchResult.\n                    var isFinalResult = !isExecutionPatchResult(result) ||\n                        (isExecutionPatchIncrementalResult(result) && !result.hasNext);\n                    if (update) {\n                        if (!skipCache) {\n                            // Re-read the ROOT_MUTATION data we just wrote into the cache\n                            // (the first cache.write call in the cacheWrites.forEach loop\n                            // above), so field read functions have a chance to run for\n                            // fields within mutation result objects.\n                            var diff = cache.diff({\n                                id: \"ROOT_MUTATION\",\n                                // The cache complains if passed a mutation where it expects a\n                                // query, so we transform mutations and subscriptions to queries\n                                // (only once, thanks to this.transformCache).\n                                query: _this.getDocumentInfo(mutation.document).asQuery,\n                                variables: mutation.variables,\n                                optimistic: false,\n                                returnPartialData: true,\n                            });\n                            if (diff.complete) {\n                                result = __assign(__assign({}, result), { data: diff.result });\n                                if (\"incremental\" in result) {\n                                    delete result.incremental;\n                                }\n                                if (\"hasNext\" in result) {\n                                    delete result.hasNext;\n                                }\n                            }\n                        }\n                        // If we've received the whole response,\n                        // either a SingleExecutionResult or the final ExecutionPatchResult,\n                        // call the update function.\n                        if (isFinalResult) {\n                            update(cache, result, {\n                                context: mutation.context,\n                                variables: mutation.variables,\n                            });\n                        }\n                    }\n                    // TODO Do this with cache.evict({ id: 'ROOT_MUTATION' }) but make it\n                    // shallow to allow rolling back optimistic evictions.\n                    if (!skipCache && !mutation.keepRootFields && isFinalResult) {\n                        cache.modify({\n                            id: \"ROOT_MUTATION\",\n                            fields: function (value, _a) {\n                                var fieldName = _a.fieldName, DELETE = _a.DELETE;\n                                return fieldName === \"__typename\" ? value : DELETE;\n                            },\n                        });\n                    }\n                },\n                include: mutation.refetchQueries,\n                // Write the final mutation.result to the root layer of the cache.\n                optimistic: false,\n                // Remove the corresponding optimistic layer at the same time as we\n                // write the final non-optimistic result.\n                removeOptimistic: mutation.removeOptimistic,\n                // Let the caller of client.mutate optionally determine the refetching\n                // behavior for watched queries after the mutation.update function runs.\n                // If no onQueryUpdated function was provided for this mutation, pass\n                // null instead of undefined to disable the default refetching behavior.\n                onQueryUpdated: mutation.onQueryUpdated || null,\n            }).forEach(function (result) { return results_1.push(result); });\n            if (mutation.awaitRefetchQueries || mutation.onQueryUpdated) {\n                // Returning a promise here makes the mutation await that promise, so we\n                // include results in that promise's work if awaitRefetchQueries or an\n                // onQueryUpdated function was specified.\n                return Promise.all(results_1).then(function () { return result; });\n            }\n        }\n        return Promise.resolve(result);\n    };\n    QueryManager.prototype.markMutationOptimistic = function (optimisticResponse, mutation) {\n        var _this = this;\n        var data = typeof optimisticResponse === \"function\" ?\n            optimisticResponse(mutation.variables, { IGNORE: IGNORE })\n            : optimisticResponse;\n        if (data === IGNORE) {\n            return false;\n        }\n        this.cache.recordOptimisticTransaction(function (cache) {\n            try {\n                _this.markMutationResult(__assign(__assign({}, mutation), { result: { data: data } }), cache);\n            }\n            catch (error) {\n                globalThis.__DEV__ !== false && invariant.error(error);\n            }\n        }, mutation.mutationId);\n        return true;\n    };\n    QueryManager.prototype.fetchQuery = function (queryId, options, networkStatus) {\n        return this.fetchConcastWithInfo(queryId, options, networkStatus).concast\n            .promise;\n    };\n    QueryManager.prototype.getQueryStore = function () {\n        var store = Object.create(null);\n        this.queries.forEach(function (info, queryId) {\n            store[queryId] = {\n                variables: info.variables,\n                networkStatus: info.networkStatus,\n                networkError: info.networkError,\n                graphQLErrors: info.graphQLErrors,\n            };\n        });\n        return store;\n    };\n    QueryManager.prototype.resetErrors = function (queryId) {\n        var queryInfo = this.queries.get(queryId);\n        if (queryInfo) {\n            queryInfo.networkError = undefined;\n            queryInfo.graphQLErrors = [];\n        }\n    };\n    QueryManager.prototype.transform = function (document) {\n        return this.documentTransform.transformDocument(document);\n    };\n    QueryManager.prototype.getDocumentInfo = function (document) {\n        var transformCache = this.transformCache;\n        if (!transformCache.has(document)) {\n            var cacheEntry = {\n                // TODO These three calls (hasClientExports, shouldForceResolvers, and\n                // usesNonreactiveDirective) are performing independent full traversals\n                // of the transformed document. We should consider merging these\n                // traversals into a single pass in the future, though the work is\n                // cached after the first time.\n                hasClientExports: hasClientExports(document),\n                hasForcedResolvers: this.localState.shouldForceResolvers(document),\n                hasNonreactiveDirective: hasDirectives([\"nonreactive\"], document),\n                clientQuery: this.localState.clientQuery(document),\n                serverQuery: removeDirectivesFromDocument([\n                    { name: \"client\", remove: true },\n                    { name: \"connection\" },\n                    { name: \"nonreactive\" },\n                ], document),\n                defaultVars: getDefaultValues(getOperationDefinition(document)),\n                // Transform any mutation or subscription operations to query operations\n                // so we can read/write them from/to the cache.\n                asQuery: __assign(__assign({}, document), { definitions: document.definitions.map(function (def) {\n                        if (def.kind === \"OperationDefinition\" &&\n                            def.operation !== \"query\") {\n                            return __assign(__assign({}, def), { operation: \"query\" });\n                        }\n                        return def;\n                    }) }),\n            };\n            transformCache.set(document, cacheEntry);\n        }\n        return transformCache.get(document);\n    };\n    QueryManager.prototype.getVariables = function (document, variables) {\n        return __assign(__assign({}, this.getDocumentInfo(document).defaultVars), variables);\n    };\n    QueryManager.prototype.watchQuery = function (options) {\n        var query = this.transform(options.query);\n        // assign variable default values if supplied\n        // NOTE: We don't modify options.query here with the transformed query to\n        // ensure observable.options.query is set to the raw untransformed query.\n        options = __assign(__assign({}, options), { variables: this.getVariables(query, options.variables) });\n        if (typeof options.notifyOnNetworkStatusChange === \"undefined\") {\n            options.notifyOnNetworkStatusChange = false;\n        }\n        var queryInfo = new QueryInfo(this);\n        var observable = new ObservableQuery({\n            queryManager: this,\n            queryInfo: queryInfo,\n            options: options,\n        });\n        observable[\"lastQuery\"] = query;\n        this.queries.set(observable.queryId, queryInfo);\n        // We give queryInfo the transformed query to ensure the first cache diff\n        // uses the transformed query instead of the raw query\n        queryInfo.init({\n            document: query,\n            observableQuery: observable,\n            variables: observable.variables,\n        });\n        return observable;\n    };\n    QueryManager.prototype.query = function (options, queryId) {\n        var _this = this;\n        if (queryId === void 0) { queryId = this.generateQueryId(); }\n        invariant(options.query, 29);\n        invariant(options.query.kind === \"Document\", 30);\n        invariant(!options.returnPartialData, 31);\n        invariant(!options.pollInterval, 32);\n        return this.fetchQuery(queryId, __assign(__assign({}, options), { query: this.transform(options.query) })).finally(function () { return _this.stopQuery(queryId); });\n    };\n    QueryManager.prototype.generateQueryId = function () {\n        return String(this.queryIdCounter++);\n    };\n    QueryManager.prototype.generateRequestId = function () {\n        return this.requestIdCounter++;\n    };\n    QueryManager.prototype.generateMutationId = function () {\n        return String(this.mutationIdCounter++);\n    };\n    QueryManager.prototype.stopQueryInStore = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {\n        var queryInfo = this.queries.get(queryId);\n        if (queryInfo)\n            queryInfo.stop();\n    };\n    QueryManager.prototype.clearStore = function (options) {\n        if (options === void 0) { options = {\n            discardWatches: true,\n        }; }\n        // Before we have sent the reset action to the store, we can no longer\n        // rely on the results returned by in-flight requests since these may\n        // depend on values that previously existed in the data portion of the\n        // store. So, we cancel the promises and observers that we have issued\n        // so far and not yet resolved (in the case of queries).\n        this.cancelPendingFetches(newInvariantError(33));\n        this.queries.forEach(function (queryInfo) {\n            if (queryInfo.observableQuery) {\n                // Set loading to true so listeners don't trigger unless they want\n                // results with partial data.\n                queryInfo.networkStatus = NetworkStatus.loading;\n            }\n            else {\n                queryInfo.stop();\n            }\n        });\n        if (this.mutationStore) {\n            this.mutationStore = Object.create(null);\n        }\n        // begin removing data from the store\n        return this.cache.reset(options);\n    };\n    QueryManager.prototype.getObservableQueries = function (include) {\n        var _this = this;\n        if (include === void 0) { include = \"active\"; }\n        var queries = new Map();\n        var queryNamesAndDocs = new Map();\n        var legacyQueryOptions = new Set();\n        if (Array.isArray(include)) {\n            include.forEach(function (desc) {\n                if (typeof desc === \"string\") {\n                    queryNamesAndDocs.set(desc, false);\n                }\n                else if (isDocumentNode(desc)) {\n                    queryNamesAndDocs.set(_this.transform(desc), false);\n                }\n                else if (isNonNullObject(desc) && desc.query) {\n                    legacyQueryOptions.add(desc);\n                }\n            });\n        }\n        this.queries.forEach(function (_a, queryId) {\n            var oq = _a.observableQuery, document = _a.document;\n            if (oq) {\n                if (include === \"all\") {\n                    queries.set(queryId, oq);\n                    return;\n                }\n                var queryName = oq.queryName, fetchPolicy = oq.options.fetchPolicy;\n                if (fetchPolicy === \"standby\" ||\n                    (include === \"active\" && !oq.hasObservers())) {\n                    return;\n                }\n                if (include === \"active\" ||\n                    (queryName && queryNamesAndDocs.has(queryName)) ||\n                    (document && queryNamesAndDocs.has(document))) {\n                    queries.set(queryId, oq);\n                    if (queryName)\n                        queryNamesAndDocs.set(queryName, true);\n                    if (document)\n                        queryNamesAndDocs.set(document, true);\n                }\n            }\n        });\n        if (legacyQueryOptions.size) {\n            legacyQueryOptions.forEach(function (options) {\n                // We will be issuing a fresh network request for this query, so we\n                // pre-allocate a new query ID here, using a special prefix to enable\n                // cleaning up these temporary queries later, after fetching.\n                var queryId = makeUniqueId(\"legacyOneTimeQuery\");\n                var queryInfo = _this.getQuery(queryId).init({\n                    document: options.query,\n                    variables: options.variables,\n                });\n                var oq = new ObservableQuery({\n                    queryManager: _this,\n                    queryInfo: queryInfo,\n                    options: __assign(__assign({}, options), { fetchPolicy: \"network-only\" }),\n                });\n                invariant(oq.queryId === queryId);\n                queryInfo.setObservableQuery(oq);\n                queries.set(queryId, oq);\n            });\n        }\n        if (globalThis.__DEV__ !== false && queryNamesAndDocs.size) {\n            queryNamesAndDocs.forEach(function (included, nameOrDoc) {\n                if (!included) {\n                    globalThis.__DEV__ !== false && invariant.warn(typeof nameOrDoc === \"string\" ? 34 : 35, nameOrDoc);\n                }\n            });\n        }\n        return queries;\n    };\n    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {\n        var _this = this;\n        if (includeStandby === void 0) { includeStandby = false; }\n        var observableQueryPromises = [];\n        this.getObservableQueries(includeStandby ? \"all\" : \"active\").forEach(function (observableQuery, queryId) {\n            var fetchPolicy = observableQuery.options.fetchPolicy;\n            observableQuery.resetLastResults();\n            if (includeStandby ||\n                (fetchPolicy !== \"standby\" && fetchPolicy !== \"cache-only\")) {\n                observableQueryPromises.push(observableQuery.refetch());\n            }\n            _this.getQuery(queryId).setDiff(null);\n        });\n        this.broadcastQueries();\n        return Promise.all(observableQueryPromises);\n    };\n    QueryManager.prototype.setObservableQuery = function (observableQuery) {\n        this.getQuery(observableQuery.queryId).setObservableQuery(observableQuery);\n    };\n    QueryManager.prototype.startGraphQLSubscription = function (_a) {\n        var _this = this;\n        var query = _a.query, fetchPolicy = _a.fetchPolicy, _b = _a.errorPolicy, errorPolicy = _b === void 0 ? \"none\" : _b, variables = _a.variables, _c = _a.context, context = _c === void 0 ? {} : _c, _d = _a.extensions, extensions = _d === void 0 ? {} : _d;\n        query = this.transform(query);\n        variables = this.getVariables(query, variables);\n        var makeObservable = function (variables) {\n            return _this.getObservableFromLink(query, context, variables, extensions).map(function (result) {\n                if (fetchPolicy !== \"no-cache\") {\n                    // the subscription interface should handle not sending us results we no longer subscribe to.\n                    // XXX I don't think we ever send in an object with errors, but we might in the future...\n                    if (shouldWriteResult(result, errorPolicy)) {\n                        _this.cache.write({\n                            query: query,\n                            result: result.data,\n                            dataId: \"ROOT_SUBSCRIPTION\",\n                            variables: variables,\n                        });\n                    }\n                    _this.broadcastQueries();\n                }\n                var hasErrors = graphQLResultHasError(result);\n                var hasProtocolErrors = graphQLResultHasProtocolErrors(result);\n                if (hasErrors || hasProtocolErrors) {\n                    var errors = {};\n                    if (hasErrors) {\n                        errors.graphQLErrors = result.errors;\n                    }\n                    if (hasProtocolErrors) {\n                        errors.protocolErrors = result.extensions[PROTOCOL_ERRORS_SYMBOL];\n                    }\n                    // `errorPolicy` is a mechanism for handling GraphQL errors, according\n                    // to our documentation, so we throw protocol errors regardless of the\n                    // set error policy.\n                    if (errorPolicy === \"none\" || hasProtocolErrors) {\n                        throw new ApolloError(errors);\n                    }\n                }\n                if (errorPolicy === \"ignore\") {\n                    delete result.errors;\n                }\n                return result;\n            });\n        };\n        if (this.getDocumentInfo(query).hasClientExports) {\n            var observablePromise_1 = this.localState\n                .addExportedVariables(query, variables, context)\n                .then(makeObservable);\n            return new Observable(function (observer) {\n                var sub = null;\n                observablePromise_1.then(function (observable) { return (sub = observable.subscribe(observer)); }, observer.error);\n                return function () { return sub && sub.unsubscribe(); };\n            });\n        }\n        return makeObservable(variables);\n    };\n    QueryManager.prototype.stopQuery = function (queryId) {\n        this.stopQueryNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.removeQuery(queryId);\n    };\n    QueryManager.prototype.removeQuery = function (queryId) {\n        // teardown all links\n        // Both `QueryManager.fetchRequest` and `QueryManager.query` create separate promises\n        // that each add their reject functions to fetchCancelFns.\n        // A query created with `QueryManager.query()` could trigger a `QueryManager.fetchRequest`.\n        // The same queryId could have two rejection fns for two promises\n        this.fetchCancelFns.delete(queryId);\n        if (this.queries.has(queryId)) {\n            this.getQuery(queryId).stop();\n            this.queries.delete(queryId);\n        }\n    };\n    QueryManager.prototype.broadcastQueries = function () {\n        if (this.onBroadcast)\n            this.onBroadcast();\n        this.queries.forEach(function (info) { return info.notify(); });\n    };\n    QueryManager.prototype.getLocalState = function () {\n        return this.localState;\n    };\n    QueryManager.prototype.getObservableFromLink = function (query, context, variables, extensions, \n    // Prefer context.queryDeduplication if specified.\n    deduplication) {\n        var _this = this;\n        var _a;\n        if (deduplication === void 0) { deduplication = (_a = context === null || context === void 0 ? void 0 : context.queryDeduplication) !== null && _a !== void 0 ? _a : this.queryDeduplication; }\n        var observable;\n        var _b = this.getDocumentInfo(query), serverQuery = _b.serverQuery, clientQuery = _b.clientQuery;\n        if (serverQuery) {\n            var _c = this, inFlightLinkObservables_1 = _c.inFlightLinkObservables, link = _c.link;\n            var operation = {\n                query: serverQuery,\n                variables: variables,\n                operationName: getOperationName(serverQuery) || void 0,\n                context: this.prepareContext(__assign(__assign({}, context), { forceFetch: !deduplication })),\n                extensions: extensions,\n            };\n            context = operation.context;\n            if (deduplication) {\n                var printedServerQuery_1 = print(serverQuery);\n                var varJson_1 = canonicalStringify(variables);\n                var entry = inFlightLinkObservables_1.lookup(printedServerQuery_1, varJson_1);\n                observable = entry.observable;\n                if (!observable) {\n                    var concast = new Concast([\n                        execute(link, operation),\n                    ]);\n                    observable = entry.observable = concast;\n                    concast.beforeNext(function () {\n                        inFlightLinkObservables_1.remove(printedServerQuery_1, varJson_1);\n                    });\n                }\n            }\n            else {\n                observable = new Concast([\n                    execute(link, operation),\n                ]);\n            }\n        }\n        else {\n            observable = new Concast([Observable.of({ data: {} })]);\n            context = this.prepareContext(context);\n        }\n        if (clientQuery) {\n            observable = asyncMap(observable, function (result) {\n                return _this.localState.runResolvers({\n                    document: clientQuery,\n                    remoteResult: result,\n                    context: context,\n                    variables: variables,\n                });\n            });\n        }\n        return observable;\n    };\n    QueryManager.prototype.getResultsFromLink = function (queryInfo, cacheWriteBehavior, options) {\n        var requestId = (queryInfo.lastRequestId = this.generateRequestId());\n        // Performing transformForLink here gives this.cache a chance to fill in\n        // missing fragment definitions (for example) before sending this document\n        // through the link chain.\n        var linkDocument = this.cache.transformForLink(options.query);\n        return asyncMap(this.getObservableFromLink(linkDocument, options.context, options.variables), function (result) {\n            var graphQLErrors = getGraphQLErrorsFromResult(result);\n            var hasErrors = graphQLErrors.length > 0;\n            var errorPolicy = options.errorPolicy;\n            // If we interrupted this request by calling getResultsFromLink again\n            // with the same QueryInfo object, we ignore the old results.\n            if (requestId >= queryInfo.lastRequestId) {\n                if (hasErrors && errorPolicy === \"none\") {\n                    // Throwing here effectively calls observer.error.\n                    throw queryInfo.markError(new ApolloError({\n                        graphQLErrors: graphQLErrors,\n                    }));\n                }\n                // Use linkDocument rather than queryInfo.document so the\n                // operation/fragments used to write the result are the same as the\n                // ones used to obtain it from the link.\n                queryInfo.markResult(result, linkDocument, options, cacheWriteBehavior);\n                queryInfo.markReady();\n            }\n            var aqr = {\n                data: result.data,\n                loading: false,\n                networkStatus: NetworkStatus.ready,\n            };\n            // In the case we start multiple network requests simulatenously, we\n            // want to ensure we properly set `data` if we're reporting on an old\n            // result which will not be caught by the conditional above that ends up\n            // throwing the markError result.\n            if (hasErrors && errorPolicy === \"none\") {\n                aqr.data = void 0;\n            }\n            if (hasErrors && errorPolicy !== \"ignore\") {\n                aqr.errors = graphQLErrors;\n                aqr.networkStatus = NetworkStatus.error;\n            }\n            return aqr;\n        }, function (networkError) {\n            var error = isApolloError(networkError) ? networkError : (new ApolloError({ networkError: networkError }));\n            // Avoid storing errors from older interrupted queries.\n            if (requestId >= queryInfo.lastRequestId) {\n                queryInfo.markError(error);\n            }\n            throw error;\n        });\n    };\n    QueryManager.prototype.fetchConcastWithInfo = function (queryId, options, \n    // The initial networkStatus for this fetch, most often\n    // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,\n    // or setVariables.\n    networkStatus, query) {\n        var _this = this;\n        if (networkStatus === void 0) { networkStatus = NetworkStatus.loading; }\n        if (query === void 0) { query = options.query; }\n        var variables = this.getVariables(query, options.variables);\n        var queryInfo = this.getQuery(queryId);\n        var defaults = this.defaultOptions.watchQuery;\n        var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? (defaults && defaults.fetchPolicy) || \"cache-first\" : _a, _b = options.errorPolicy, errorPolicy = _b === void 0 ? (defaults && defaults.errorPolicy) || \"none\" : _b, _c = options.returnPartialData, returnPartialData = _c === void 0 ? false : _c, _d = options.notifyOnNetworkStatusChange, notifyOnNetworkStatusChange = _d === void 0 ? false : _d, _e = options.context, context = _e === void 0 ? {} : _e;\n        var normalized = Object.assign({}, options, {\n            query: query,\n            variables: variables,\n            fetchPolicy: fetchPolicy,\n            errorPolicy: errorPolicy,\n            returnPartialData: returnPartialData,\n            notifyOnNetworkStatusChange: notifyOnNetworkStatusChange,\n            context: context,\n        });\n        var fromVariables = function (variables) {\n            // Since normalized is always a fresh copy of options, it's safe to\n            // modify its properties here, rather than creating yet another new\n            // WatchQueryOptions object.\n            normalized.variables = variables;\n            var sourcesWithInfo = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);\n            if (\n            // If we're in standby, postpone advancing options.fetchPolicy using\n            // applyNextFetchPolicy.\n            normalized.fetchPolicy !== \"standby\" &&\n                // The \"standby\" policy currently returns [] from fetchQueryByPolicy, so\n                // this is another way to detect when nothing was done/fetched.\n                sourcesWithInfo.sources.length > 0 &&\n                queryInfo.observableQuery) {\n                queryInfo.observableQuery[\"applyNextFetchPolicy\"](\"after-fetch\", options);\n            }\n            return sourcesWithInfo;\n        };\n        // This cancel function needs to be set before the concast is created,\n        // in case concast creation synchronously cancels the request.\n        var cleanupCancelFn = function () { return _this.fetchCancelFns.delete(queryId); };\n        this.fetchCancelFns.set(queryId, function (reason) {\n            cleanupCancelFn();\n            // This delay ensures the concast variable has been initialized.\n            setTimeout(function () { return concast.cancel(reason); });\n        });\n        var concast, containsDataFromLink;\n        // If the query has @export(as: ...) directives, then we need to\n        // process those directives asynchronously. When there are no\n        // @export directives (the common case), we deliberately avoid\n        // wrapping the result of this.fetchQueryByPolicy in a Promise,\n        // since the timing of result delivery is (unfortunately) important\n        // for backwards compatibility. TODO This code could be simpler if\n        // we deprecated and removed LocalState.\n        if (this.getDocumentInfo(normalized.query).hasClientExports) {\n            concast = new Concast(this.localState\n                .addExportedVariables(normalized.query, normalized.variables, normalized.context)\n                .then(fromVariables)\n                .then(function (sourcesWithInfo) { return sourcesWithInfo.sources; }));\n            // there is just no way we can synchronously get the *right* value here,\n            // so we will assume `true`, which is the behaviour before the bug fix in\n            // #10597. This means that bug is not fixed in that case, and is probably\n            // un-fixable with reasonable effort for the edge case of @export as\n            // directives.\n            containsDataFromLink = true;\n        }\n        else {\n            var sourcesWithInfo = fromVariables(normalized.variables);\n            containsDataFromLink = sourcesWithInfo.fromLink;\n            concast = new Concast(sourcesWithInfo.sources);\n        }\n        concast.promise.then(cleanupCancelFn, cleanupCancelFn);\n        return {\n            concast: concast,\n            fromLink: containsDataFromLink,\n        };\n    };\n    QueryManager.prototype.refetchQueries = function (_a) {\n        var _this = this;\n        var updateCache = _a.updateCache, include = _a.include, _b = _a.optimistic, optimistic = _b === void 0 ? false : _b, _c = _a.removeOptimistic, removeOptimistic = _c === void 0 ? optimistic ? makeUniqueId(\"refetchQueries\") : void 0 : _c, onQueryUpdated = _a.onQueryUpdated;\n        var includedQueriesById = new Map();\n        if (include) {\n            this.getObservableQueries(include).forEach(function (oq, queryId) {\n                includedQueriesById.set(queryId, {\n                    oq: oq,\n                    lastDiff: _this.getQuery(queryId).getDiff(),\n                });\n            });\n        }\n        var results = new Map();\n        if (updateCache) {\n            this.cache.batch({\n                update: updateCache,\n                // Since you can perform any combination of cache reads and/or writes in\n                // the cache.batch update function, its optimistic option can be either\n                // a boolean or a string, representing three distinct modes of\n                // operation:\n                //\n                // * false: read/write only the root layer\n                // * true: read/write the topmost layer\n                // * string: read/write a fresh optimistic layer with that ID string\n                //\n                // When typeof optimistic === \"string\", a new optimistic layer will be\n                // temporarily created within cache.batch with that string as its ID. If\n                // we then pass that same string as the removeOptimistic option, we can\n                // make cache.batch immediately remove the optimistic layer after\n                // running the updateCache function, triggering only one broadcast.\n                //\n                // However, the refetchQueries method accepts only true or false for its\n                // optimistic option (not string). We interpret true to mean a temporary\n                // optimistic layer should be created, to allow efficiently rolling back\n                // the effect of the updateCache function, which involves passing a\n                // string instead of true as the optimistic option to cache.batch, when\n                // refetchQueries receives optimistic: true.\n                //\n                // In other words, we are deliberately not supporting the use case of\n                // writing to an *existing* optimistic layer (using the refetchQueries\n                // updateCache function), since that would potentially interfere with\n                // other optimistic updates in progress. Instead, you can read/write\n                // only the root layer by passing optimistic: false to refetchQueries,\n                // or you can read/write a brand new optimistic layer that will be\n                // automatically removed by passing optimistic: true.\n                optimistic: (optimistic && removeOptimistic) || false,\n                // The removeOptimistic option can also be provided by itself, even if\n                // optimistic === false, to remove some previously-added optimistic\n                // layer safely and efficiently, like we do in markMutationResult.\n                //\n                // If an explicit removeOptimistic string is provided with optimistic:\n                // true, the removeOptimistic string will determine the ID of the\n                // temporary optimistic layer, in case that ever matters.\n                removeOptimistic: removeOptimistic,\n                onWatchUpdated: function (watch, diff, lastDiff) {\n                    var oq = watch.watcher instanceof QueryInfo && watch.watcher.observableQuery;\n                    if (oq) {\n                        if (onQueryUpdated) {\n                            // Since we're about to handle this query now, remove it from\n                            // includedQueriesById, in case it was added earlier because of\n                            // options.include.\n                            includedQueriesById.delete(oq.queryId);\n                            var result = onQueryUpdated(oq, diff, lastDiff);\n                            if (result === true) {\n                                // The onQueryUpdated function requested the default refetching\n                                // behavior by returning true.\n                                result = oq.refetch();\n                            }\n                            // Record the result in the results Map, as long as onQueryUpdated\n                            // did not return false to skip/ignore this result.\n                            if (result !== false) {\n                                results.set(oq, result);\n                            }\n                            // Allow the default cache broadcast to happen, except when\n                            // onQueryUpdated returns false.\n                            return result;\n                        }\n                        if (onQueryUpdated !== null) {\n                            // If we don't have an onQueryUpdated function, and onQueryUpdated\n                            // was not disabled by passing null, make sure this query is\n                            // \"included\" like any other options.include-specified query.\n                            includedQueriesById.set(oq.queryId, { oq: oq, lastDiff: lastDiff, diff: diff });\n                        }\n                    }\n                },\n            });\n        }\n        if (includedQueriesById.size) {\n            includedQueriesById.forEach(function (_a, queryId) {\n                var oq = _a.oq, lastDiff = _a.lastDiff, diff = _a.diff;\n                var result;\n                // If onQueryUpdated is provided, we want to use it for all included\n                // queries, even the QueryOptions ones.\n                if (onQueryUpdated) {\n                    if (!diff) {\n                        var info = oq[\"queryInfo\"];\n                        info.reset(); // Force info.getDiff() to read from cache.\n                        diff = info.getDiff();\n                    }\n                    result = onQueryUpdated(oq, diff, lastDiff);\n                }\n                // Otherwise, we fall back to refetching.\n                if (!onQueryUpdated || result === true) {\n                    result = oq.refetch();\n                }\n                if (result !== false) {\n                    results.set(oq, result);\n                }\n                if (queryId.indexOf(\"legacyOneTimeQuery\") >= 0) {\n                    _this.stopQueryNoBroadcast(queryId);\n                }\n            });\n        }\n        if (removeOptimistic) {\n            // In case no updateCache callback was provided (so cache.batch was not\n            // called above, and thus did not already remove the optimistic layer),\n            // remove it here. Since this is a no-op when the layer has already been\n            // removed, we do it even if we called cache.batch above, since it's\n            // possible this.cache is an instance of some ApolloCache subclass other\n            // than InMemoryCache, and does not fully support the removeOptimistic\n            // option for cache.batch.\n            this.cache.removeOptimistic(removeOptimistic);\n        }\n        return results;\n    };\n    QueryManager.prototype.fetchQueryByPolicy = function (queryInfo, _a, \n    // The initial networkStatus for this fetch, most often\n    // NetworkStatus.loading, but also possibly fetchMore, poll, refetch,\n    // or setVariables.\n    networkStatus) {\n        var _this = this;\n        var query = _a.query, variables = _a.variables, fetchPolicy = _a.fetchPolicy, refetchWritePolicy = _a.refetchWritePolicy, errorPolicy = _a.errorPolicy, returnPartialData = _a.returnPartialData, context = _a.context, notifyOnNetworkStatusChange = _a.notifyOnNetworkStatusChange;\n        var oldNetworkStatus = queryInfo.networkStatus;\n        queryInfo.init({\n            document: query,\n            variables: variables,\n            networkStatus: networkStatus,\n        });\n        var readCache = function () { return queryInfo.getDiff(); };\n        var resultsFromCache = function (diff, networkStatus) {\n            if (networkStatus === void 0) { networkStatus = queryInfo.networkStatus || NetworkStatus.loading; }\n            var data = diff.result;\n            if (globalThis.__DEV__ !== false && !returnPartialData && !equal(data, {})) {\n                logMissingFieldErrors(diff.missing);\n            }\n            var fromData = function (data) {\n                return Observable.of(__assign({ data: data, loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus }, (diff.complete ? null : { partial: true })));\n            };\n            if (data && _this.getDocumentInfo(query).hasForcedResolvers) {\n                return _this.localState\n                    .runResolvers({\n                    document: query,\n                    remoteResult: { data: data },\n                    context: context,\n                    variables: variables,\n                    onlyRunForcedResolvers: true,\n                })\n                    .then(function (resolved) { return fromData(resolved.data || void 0); });\n            }\n            // Resolves https://github.com/apollographql/apollo-client/issues/10317.\n            // If errorPolicy is 'none' and notifyOnNetworkStatusChange is true,\n            // data was incorrectly returned from the cache on refetch:\n            // if diff.missing exists, we should not return cache data.\n            if (errorPolicy === \"none\" &&\n                networkStatus === NetworkStatus.refetch &&\n                Array.isArray(diff.missing)) {\n                return fromData(void 0);\n            }\n            return fromData(data);\n        };\n        var cacheWriteBehavior = fetchPolicy === \"no-cache\" ? 0 /* CacheWriteBehavior.FORBID */\n            // Watched queries must opt into overwriting existing data on refetch,\n            // by passing refetchWritePolicy: \"overwrite\" in their WatchQueryOptions.\n            : (networkStatus === NetworkStatus.refetch &&\n                refetchWritePolicy !== \"merge\") ?\n                1 /* CacheWriteBehavior.OVERWRITE */\n                : 2 /* CacheWriteBehavior.MERGE */;\n        var resultsFromLink = function () {\n            return _this.getResultsFromLink(queryInfo, cacheWriteBehavior, {\n                query: query,\n                variables: variables,\n                context: context,\n                fetchPolicy: fetchPolicy,\n                errorPolicy: errorPolicy,\n            });\n        };\n        var shouldNotify = notifyOnNetworkStatusChange &&\n            typeof oldNetworkStatus === \"number\" &&\n            oldNetworkStatus !== networkStatus &&\n            isNetworkRequestInFlight(networkStatus);\n        switch (fetchPolicy) {\n            default:\n            case \"cache-first\": {\n                var diff = readCache();\n                if (diff.complete) {\n                    return {\n                        fromLink: false,\n                        sources: [resultsFromCache(diff, queryInfo.markReady())],\n                    };\n                }\n                if (returnPartialData || shouldNotify) {\n                    return {\n                        fromLink: true,\n                        sources: [resultsFromCache(diff), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            }\n            case \"cache-and-network\": {\n                var diff = readCache();\n                if (diff.complete || returnPartialData || shouldNotify) {\n                    return {\n                        fromLink: true,\n                        sources: [resultsFromCache(diff), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            }\n            case \"cache-only\":\n                return {\n                    fromLink: false,\n                    sources: [resultsFromCache(readCache(), queryInfo.markReady())],\n                };\n            case \"network-only\":\n                if (shouldNotify) {\n                    return {\n                        fromLink: true,\n                        sources: [resultsFromCache(readCache()), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            case \"no-cache\":\n                if (shouldNotify) {\n                    return {\n                        fromLink: true,\n                        // Note that queryInfo.getDiff() for no-cache queries does not call\n                        // cache.diff, but instead returns a { complete: false } stub result\n                        // when there is no queryInfo.diff already defined.\n                        sources: [resultsFromCache(queryInfo.getDiff()), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            case \"standby\":\n                return { fromLink: false, sources: [] };\n        }\n    };\n    QueryManager.prototype.getQuery = function (queryId) {\n        if (queryId && !this.queries.has(queryId)) {\n            this.queries.set(queryId, new QueryInfo(this, queryId));\n        }\n        return this.queries.get(queryId);\n    };\n    QueryManager.prototype.prepareContext = function (context) {\n        if (context === void 0) { context = {}; }\n        var newContext = this.localState.prepareContext(context);\n        return __assign(__assign(__assign({}, this.defaultContext), newContext), { clientAwareness: this.clientAwareness });\n    };\n    return QueryManager;\n}());\nexport { QueryManager };\n//# sourceMappingURL=QueryManager.js.map","import { Kind } from './kinds.mjs';\nexport function isDefinitionNode(node) {\n  return (\n    isExecutableDefinitionNode(node) ||\n    isTypeSystemDefinitionNode(node) ||\n    isTypeSystemExtensionNode(node)\n  );\n}\nexport function isExecutableDefinitionNode(node) {\n  return (\n    node.kind === Kind.OPERATION_DEFINITION ||\n    node.kind === Kind.FRAGMENT_DEFINITION\n  );\n}\nexport function isSelectionNode(node) {\n  return (\n    node.kind === Kind.FIELD ||\n    node.kind === Kind.FRAGMENT_SPREAD ||\n    node.kind === Kind.INLINE_FRAGMENT\n  );\n}\nexport function isValueNode(node) {\n  return (\n    node.kind === Kind.VARIABLE ||\n    node.kind === Kind.INT ||\n    node.kind === Kind.FLOAT ||\n    node.kind === Kind.STRING ||\n    node.kind === Kind.BOOLEAN ||\n    node.kind === Kind.NULL ||\n    node.kind === Kind.ENUM ||\n    node.kind === Kind.LIST ||\n    node.kind === Kind.OBJECT\n  );\n}\nexport function isConstValueNode(node) {\n  return (\n    isValueNode(node) &&\n    (node.kind === Kind.LIST\n      ? node.values.some(isConstValueNode)\n      : node.kind === Kind.OBJECT\n      ? node.fields.some((field) => isConstValueNode(field.value))\n      : node.kind !== Kind.VARIABLE)\n  );\n}\nexport function isTypeNode(node) {\n  return (\n    node.kind === Kind.NAMED_TYPE ||\n    node.kind === Kind.LIST_TYPE ||\n    node.kind === Kind.NON_NULL_TYPE\n  );\n}\nexport function isTypeSystemDefinitionNode(node) {\n  return (\n    node.kind === Kind.SCHEMA_DEFINITION ||\n    isTypeDefinitionNode(node) ||\n    node.kind === Kind.DIRECTIVE_DEFINITION\n  );\n}\nexport function isTypeDefinitionNode(node) {\n  return (\n    node.kind === Kind.SCALAR_TYPE_DEFINITION ||\n    node.kind === Kind.OBJECT_TYPE_DEFINITION ||\n    node.kind === Kind.INTERFACE_TYPE_DEFINITION ||\n    node.kind === Kind.UNION_TYPE_DEFINITION ||\n    node.kind === Kind.ENUM_TYPE_DEFINITION ||\n    node.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION\n  );\n}\nexport function isTypeSystemExtensionNode(node) {\n  return node.kind === Kind.SCHEMA_EXTENSION || isTypeExtensionNode(node);\n}\nexport function isTypeExtensionNode(node) {\n  return (\n    node.kind === Kind.SCALAR_TYPE_EXTENSION ||\n    node.kind === Kind.OBJECT_TYPE_EXTENSION ||\n    node.kind === Kind.INTERFACE_TYPE_EXTENSION ||\n    node.kind === Kind.UNION_TYPE_EXTENSION ||\n    node.kind === Kind.ENUM_TYPE_EXTENSION ||\n    node.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION\n  );\n}\n","import { __assign, __awaiter, __generator } from \"tslib\";\nimport { invariant } from \"../utilities/globals/index.js\";\nimport { visit, BREAK, isSelectionNode } from \"graphql\";\nimport { argumentsObjectFromField, buildQueryFromSelectionSet, createFragmentMap, getFragmentDefinitions, getMainDefinition, hasDirectives, isField, isInlineFragment, mergeDeep, mergeDeepArray, removeClientSetsFromDocument, resultKeyNameFromField, shouldInclude, } from \"../utilities/index.js\";\nimport { cacheSlot } from \"../cache/index.js\";\nvar LocalState = /** @class */ (function () {\n    function LocalState(_a) {\n        var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;\n        this.selectionsToResolveCache = new WeakMap();\n        this.cache = cache;\n        if (client) {\n            this.client = client;\n        }\n        if (resolvers) {\n            this.addResolvers(resolvers);\n        }\n        if (fragmentMatcher) {\n            this.setFragmentMatcher(fragmentMatcher);\n        }\n    }\n    LocalState.prototype.addResolvers = function (resolvers) {\n        var _this = this;\n        this.resolvers = this.resolvers || {};\n        if (Array.isArray(resolvers)) {\n            resolvers.forEach(function (resolverGroup) {\n                _this.resolvers = mergeDeep(_this.resolvers, resolverGroup);\n            });\n        }\n        else {\n            this.resolvers = mergeDeep(this.resolvers, resolvers);\n        }\n    };\n    LocalState.prototype.setResolvers = function (resolvers) {\n        this.resolvers = {};\n        this.addResolvers(resolvers);\n    };\n    LocalState.prototype.getResolvers = function () {\n        return this.resolvers || {};\n    };\n    // Run local client resolvers against the incoming query and remote data.\n    // Locally resolved field values are merged with the incoming remote data,\n    // and returned. Note that locally resolved fields will overwrite\n    // remote data using the same field name.\n    LocalState.prototype.runResolvers = function (_a) {\n        return __awaiter(this, arguments, void 0, function (_b) {\n            var document = _b.document, remoteResult = _b.remoteResult, context = _b.context, variables = _b.variables, _c = _b.onlyRunForcedResolvers, onlyRunForcedResolvers = _c === void 0 ? false : _c;\n            return __generator(this, function (_d) {\n                if (document) {\n                    return [2 /*return*/, this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (__assign(__assign({}, remoteResult), { data: localResult.result })); })];\n                }\n                return [2 /*return*/, remoteResult];\n            });\n        });\n    };\n    LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {\n        this.fragmentMatcher = fragmentMatcher;\n    };\n    LocalState.prototype.getFragmentMatcher = function () {\n        return this.fragmentMatcher;\n    };\n    // Client queries contain everything in the incoming document (if a @client\n    // directive is found).\n    LocalState.prototype.clientQuery = function (document) {\n        if (hasDirectives([\"client\"], document)) {\n            if (this.resolvers) {\n                return document;\n            }\n        }\n        return null;\n    };\n    // Server queries are stripped of all @client based selection sets.\n    LocalState.prototype.serverQuery = function (document) {\n        return removeClientSetsFromDocument(document);\n    };\n    LocalState.prototype.prepareContext = function (context) {\n        var cache = this.cache;\n        return __assign(__assign({}, context), { cache: cache, \n            // Getting an entry's cache key is useful for local state resolvers.\n            getCacheKey: function (obj) {\n                return cache.identify(obj);\n            } });\n    };\n    // To support `@client @export(as: \"someVar\")` syntax, we'll first resolve\n    // @client @export fields locally, then pass the resolved values back to be\n    // used alongside the original operation variables.\n    LocalState.prototype.addExportedVariables = function (document_1) {\n        return __awaiter(this, arguments, void 0, function (document, variables, context) {\n            if (variables === void 0) { variables = {}; }\n            if (context === void 0) { context = {}; }\n            return __generator(this, function (_a) {\n                if (document) {\n                    return [2 /*return*/, this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (__assign(__assign({}, variables), data.exportedVariables)); })];\n                }\n                return [2 /*return*/, __assign({}, variables)];\n            });\n        });\n    };\n    LocalState.prototype.shouldForceResolvers = function (document) {\n        var forceResolvers = false;\n        visit(document, {\n            Directive: {\n                enter: function (node) {\n                    if (node.name.value === \"client\" && node.arguments) {\n                        forceResolvers = node.arguments.some(function (arg) {\n                            return arg.name.value === \"always\" &&\n                                arg.value.kind === \"BooleanValue\" &&\n                                arg.value.value === true;\n                        });\n                        if (forceResolvers) {\n                            return BREAK;\n                        }\n                    }\n                },\n            },\n        });\n        return forceResolvers;\n    };\n    // Query the cache and return matching data.\n    LocalState.prototype.buildRootValueFromCache = function (document, variables) {\n        return this.cache.diff({\n            query: buildQueryFromSelectionSet(document),\n            variables: variables,\n            returnPartialData: true,\n            optimistic: false,\n        }).result;\n    };\n    LocalState.prototype.resolveDocument = function (document_1, rootValue_1) {\n        return __awaiter(this, arguments, void 0, function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {\n            var mainDefinition, fragments, fragmentMap, selectionsToResolve, definitionOperation, defaultOperationType, _a, cache, client, execContext, isClientFieldDescendant;\n            if (context === void 0) { context = {}; }\n            if (variables === void 0) { variables = {}; }\n            if (fragmentMatcher === void 0) { fragmentMatcher = function () { return true; }; }\n            if (onlyRunForcedResolvers === void 0) { onlyRunForcedResolvers = false; }\n            return __generator(this, function (_b) {\n                mainDefinition = getMainDefinition(document);\n                fragments = getFragmentDefinitions(document);\n                fragmentMap = createFragmentMap(fragments);\n                selectionsToResolve = this.collectSelectionsToResolve(mainDefinition, fragmentMap);\n                definitionOperation = mainDefinition.operation;\n                defaultOperationType = definitionOperation ?\n                    definitionOperation.charAt(0).toUpperCase() +\n                        definitionOperation.slice(1)\n                    : \"Query\";\n                _a = this, cache = _a.cache, client = _a.client;\n                execContext = {\n                    fragmentMap: fragmentMap,\n                    context: __assign(__assign({}, context), { cache: cache, client: client }),\n                    variables: variables,\n                    fragmentMatcher: fragmentMatcher,\n                    defaultOperationType: defaultOperationType,\n                    exportedVariables: {},\n                    selectionsToResolve: selectionsToResolve,\n                    onlyRunForcedResolvers: onlyRunForcedResolvers,\n                };\n                isClientFieldDescendant = false;\n                return [2 /*return*/, this.resolveSelectionSet(mainDefinition.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (result) { return ({\n                        result: result,\n                        exportedVariables: execContext.exportedVariables,\n                    }); })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSelectionSet = function (selectionSet, isClientFieldDescendant, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var fragmentMap, context, variables, resultsToMerge, execute;\n            var _this = this;\n            return __generator(this, function (_a) {\n                fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;\n                resultsToMerge = [rootValue];\n                execute = function (selection) { return __awaiter(_this, void 0, void 0, function () {\n                    var fragment, typeCondition;\n                    return __generator(this, function (_a) {\n                        if (!isClientFieldDescendant &&\n                            !execContext.selectionsToResolve.has(selection)) {\n                            // Skip selections without @client directives\n                            // (still processing if one of the ancestors or one of the child fields has @client directive)\n                            return [2 /*return*/];\n                        }\n                        if (!shouldInclude(selection, variables)) {\n                            // Skip this entirely.\n                            return [2 /*return*/];\n                        }\n                        if (isField(selection)) {\n                            return [2 /*return*/, this.resolveField(selection, isClientFieldDescendant, rootValue, execContext).then(function (fieldResult) {\n                                    var _a;\n                                    if (typeof fieldResult !== \"undefined\") {\n                                        resultsToMerge.push((_a = {},\n                                            _a[resultKeyNameFromField(selection)] = fieldResult,\n                                            _a));\n                                    }\n                                })];\n                        }\n                        if (isInlineFragment(selection)) {\n                            fragment = selection;\n                        }\n                        else {\n                            // This is a named fragment.\n                            fragment = fragmentMap[selection.name.value];\n                            invariant(fragment, 18, selection.name.value);\n                        }\n                        if (fragment && fragment.typeCondition) {\n                            typeCondition = fragment.typeCondition.name.value;\n                            if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {\n                                return [2 /*return*/, this.resolveSelectionSet(fragment.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (fragmentResult) {\n                                        resultsToMerge.push(fragmentResult);\n                                    })];\n                            }\n                        }\n                        return [2 /*return*/];\n                    });\n                }); };\n                return [2 /*return*/, Promise.all(selectionSet.selections.map(execute)).then(function () {\n                        return mergeDeepArray(resultsToMerge);\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveField = function (field, isClientFieldDescendant, rootValue, execContext) {\n        return __awaiter(this, void 0, void 0, function () {\n            var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;\n            var _this = this;\n            return __generator(this, function (_a) {\n                if (!rootValue) {\n                    return [2 /*return*/, null];\n                }\n                variables = execContext.variables;\n                fieldName = field.name.value;\n                aliasedFieldName = resultKeyNameFromField(field);\n                aliasUsed = fieldName !== aliasedFieldName;\n                defaultResult = rootValue[aliasedFieldName] || rootValue[fieldName];\n                resultPromise = Promise.resolve(defaultResult);\n                // Usually all local resolvers are run when passing through here, but\n                // if we've specifically identified that we only want to run forced\n                // resolvers (that is, resolvers for fields marked with\n                // `@client(always: true)`), then we'll skip running non-forced resolvers.\n                if (!execContext.onlyRunForcedResolvers ||\n                    this.shouldForceResolvers(field)) {\n                    resolverType = rootValue.__typename || execContext.defaultOperationType;\n                    resolverMap = this.resolvers && this.resolvers[resolverType];\n                    if (resolverMap) {\n                        resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];\n                        if (resolve) {\n                            resultPromise = Promise.resolve(\n                            // In case the resolve function accesses reactive variables,\n                            // set cacheSlot to the current cache instance.\n                            cacheSlot.withValue(this.cache, resolve, [\n                                rootValue,\n                                argumentsObjectFromField(field, variables),\n                                execContext.context,\n                                { field: field, fragmentMap: execContext.fragmentMap },\n                            ]));\n                        }\n                    }\n                }\n                return [2 /*return*/, resultPromise.then(function (result) {\n                        var _a, _b;\n                        if (result === void 0) { result = defaultResult; }\n                        // If an @export directive is associated with the current field, store\n                        // the `as` export variable name and current result for later use.\n                        if (field.directives) {\n                            field.directives.forEach(function (directive) {\n                                if (directive.name.value === \"export\" && directive.arguments) {\n                                    directive.arguments.forEach(function (arg) {\n                                        if (arg.name.value === \"as\" && arg.value.kind === \"StringValue\") {\n                                            execContext.exportedVariables[arg.value.value] = result;\n                                        }\n                                    });\n                                }\n                            });\n                        }\n                        // Handle all scalar types here.\n                        if (!field.selectionSet) {\n                            return result;\n                        }\n                        // From here down, the field has a selection set, which means it's trying\n                        // to query a GraphQLObjectType.\n                        if (result == null) {\n                            // Basically any field in a GraphQL response can be null, or missing\n                            return result;\n                        }\n                        var isClientField = (_b = (_a = field.directives) === null || _a === void 0 ? void 0 : _a.some(function (d) { return d.name.value === \"client\"; })) !== null && _b !== void 0 ? _b : false;\n                        if (Array.isArray(result)) {\n                            return _this.resolveSubSelectedArray(field, isClientFieldDescendant || isClientField, result, execContext);\n                        }\n                        // Returned value is an object, and the query has a sub-selection. Recurse.\n                        if (field.selectionSet) {\n                            return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant || isClientField, result, execContext);\n                        }\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSubSelectedArray = function (field, isClientFieldDescendant, result, execContext) {\n        var _this = this;\n        return Promise.all(result.map(function (item) {\n            if (item === null) {\n                return null;\n            }\n            // This is a nested array, recurse.\n            if (Array.isArray(item)) {\n                return _this.resolveSubSelectedArray(field, isClientFieldDescendant, item, execContext);\n            }\n            // This is an object, run the selection set on it.\n            if (field.selectionSet) {\n                return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant, item, execContext);\n            }\n        }));\n    };\n    // Collect selection nodes on paths from document root down to all @client directives.\n    // This function takes into account transitive fragment spreads.\n    // Complexity equals to a single `visit` over the full document.\n    LocalState.prototype.collectSelectionsToResolve = function (mainDefinition, fragmentMap) {\n        var isSingleASTNode = function (node) { return !Array.isArray(node); };\n        var selectionsToResolveCache = this.selectionsToResolveCache;\n        function collectByDefinition(definitionNode) {\n            if (!selectionsToResolveCache.has(definitionNode)) {\n                var matches_1 = new Set();\n                selectionsToResolveCache.set(definitionNode, matches_1);\n                visit(definitionNode, {\n                    Directive: function (node, _, __, ___, ancestors) {\n                        if (node.name.value === \"client\") {\n                            ancestors.forEach(function (node) {\n                                if (isSingleASTNode(node) && isSelectionNode(node)) {\n                                    matches_1.add(node);\n                                }\n                            });\n                        }\n                    },\n                    FragmentSpread: function (spread, _, __, ___, ancestors) {\n                        var fragment = fragmentMap[spread.name.value];\n                        invariant(fragment, 19, spread.name.value);\n                        var fragmentSelections = collectByDefinition(fragment);\n                        if (fragmentSelections.size > 0) {\n                            // Fragment for this spread contains @client directive (either directly or transitively)\n                            // Collect selection nodes on paths from the root down to fields with the @client directive\n                            ancestors.forEach(function (node) {\n                                if (isSingleASTNode(node) && isSelectionNode(node)) {\n                                    matches_1.add(node);\n                                }\n                            });\n                            matches_1.add(spread);\n                            fragmentSelections.forEach(function (selection) {\n                                matches_1.add(selection);\n                            });\n                        }\n                    },\n                });\n            }\n            return selectionsToResolveCache.get(definitionNode);\n        }\n        return collectByDefinition(mainDefinition);\n    };\n    return LocalState;\n}());\nexport { LocalState };\n//# sourceMappingURL=LocalState.js.map","import { __assign } from \"tslib\";\nimport { invariant, newInvariantError } from \"../utilities/globals/index.js\";\nimport { ApolloLink, execute } from \"../link/core/index.js\";\nimport { version } from \"../version.js\";\nimport { HttpLink } from \"../link/http/index.js\";\nimport { QueryManager } from \"./QueryManager.js\";\nimport { LocalState } from \"./LocalState.js\";\nvar hasSuggestedDevtools = false;\n// Though mergeOptions now resides in @apollo/client/utilities, it was\n// previously declared and exported from this module, and then reexported from\n// @apollo/client/core. Since we need to preserve that API anyway, the easiest\n// solution is to reexport mergeOptions where it was previously declared (here).\nimport { mergeOptions } from \"../utilities/index.js\";\nimport { getApolloClientMemoryInternals } from \"../utilities/caching/getMemoryInternals.js\";\nexport { mergeOptions };\n/**\n * This is the primary Apollo Client class. It is used to send GraphQL documents (i.e. queries\n * and mutations) to a GraphQL spec-compliant server over an `ApolloLink` instance,\n * receive results from the server and cache the results in a store. It also delivers updates\n * to GraphQL queries through `Observable` instances.\n */\nvar ApolloClient = /** @class */ (function () {\n    /**\n     * Constructs an instance of `ApolloClient`.\n     *\n     * @example\n     * ```js\n     * import { ApolloClient, InMemoryCache } from '@apollo/client';\n     *\n     * const cache = new InMemoryCache();\n     *\n     * const client = new ApolloClient({\n     *   // Provide required constructor fields\n     *   cache: cache,\n     *   uri: 'http://localhost:4000/',\n     *\n     *   // Provide some optional constructor fields\n     *   name: 'react-web-client',\n     *   version: '1.3',\n     *   queryDeduplication: false,\n     *   defaultOptions: {\n     *     watchQuery: {\n     *       fetchPolicy: 'cache-and-network',\n     *     },\n     *   },\n     * });\n     * ```\n     */\n    function ApolloClient(options) {\n        var _this = this;\n        this.resetStoreCallbacks = [];\n        this.clearStoreCallbacks = [];\n        if (!options.cache) {\n            throw newInvariantError(15);\n        }\n        var uri = options.uri, credentials = options.credentials, headers = options.headers, cache = options.cache, documentTransform = options.documentTransform, _a = options.ssrMode, ssrMode = _a === void 0 ? false : _a, _b = options.ssrForceFetchDelay, ssrForceFetchDelay = _b === void 0 ? 0 : _b, \n        // Expose the client instance as window.__APOLLO_CLIENT__ and call\n        // onBroadcast in queryManager.broadcastQueries to enable browser\n        // devtools, but disable them by default in production.\n        connectToDevTools = options.connectToDevTools, _c = options.queryDeduplication, queryDeduplication = _c === void 0 ? true : _c, defaultOptions = options.defaultOptions, defaultContext = options.defaultContext, _d = options.assumeImmutableResults, assumeImmutableResults = _d === void 0 ? cache.assumeImmutableResults : _d, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwarenessName = options.name, clientAwarenessVersion = options.version, devtools = options.devtools;\n        var link = options.link;\n        if (!link) {\n            link =\n                uri ? new HttpLink({ uri: uri, credentials: credentials, headers: headers }) : ApolloLink.empty();\n        }\n        this.link = link;\n        this.cache = cache;\n        this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;\n        this.queryDeduplication = queryDeduplication;\n        this.defaultOptions = defaultOptions || Object.create(null);\n        this.typeDefs = typeDefs;\n        this.devtoolsConfig = __assign(__assign({}, devtools), { enabled: (devtools === null || devtools === void 0 ? void 0 : devtools.enabled) || connectToDevTools });\n        if (this.devtoolsConfig.enabled === undefined) {\n            this.devtoolsConfig.enabled = globalThis.__DEV__ !== false;\n        }\n        if (ssrForceFetchDelay) {\n            setTimeout(function () { return (_this.disableNetworkFetches = false); }, ssrForceFetchDelay);\n        }\n        this.watchQuery = this.watchQuery.bind(this);\n        this.query = this.query.bind(this);\n        this.mutate = this.mutate.bind(this);\n        this.watchFragment = this.watchFragment.bind(this);\n        this.resetStore = this.resetStore.bind(this);\n        this.reFetchObservableQueries = this.reFetchObservableQueries.bind(this);\n        this.version = version;\n        this.localState = new LocalState({\n            cache: cache,\n            client: this,\n            resolvers: resolvers,\n            fragmentMatcher: fragmentMatcher,\n        });\n        this.queryManager = new QueryManager({\n            cache: this.cache,\n            link: this.link,\n            defaultOptions: this.defaultOptions,\n            defaultContext: defaultContext,\n            documentTransform: documentTransform,\n            queryDeduplication: queryDeduplication,\n            ssrMode: ssrMode,\n            clientAwareness: {\n                name: clientAwarenessName,\n                version: clientAwarenessVersion,\n            },\n            localState: this.localState,\n            assumeImmutableResults: assumeImmutableResults,\n            onBroadcast: this.devtoolsConfig.enabled ?\n                function () {\n                    if (_this.devToolsHookCb) {\n                        _this.devToolsHookCb({\n                            action: {},\n                            state: {\n                                queries: _this.queryManager.getQueryStore(),\n                                mutations: _this.queryManager.mutationStore || {},\n                            },\n                            dataWithOptimisticResults: _this.cache.extract(true),\n                        });\n                    }\n                }\n                : void 0,\n        });\n        if (this.devtoolsConfig.enabled)\n            this.connectToDevTools();\n    }\n    ApolloClient.prototype.connectToDevTools = function () {\n        if (typeof window === \"undefined\") {\n            return;\n        }\n        var windowWithDevTools = window;\n        var devtoolsSymbol = Symbol.for(\"apollo.devtools\");\n        (windowWithDevTools[devtoolsSymbol] =\n            windowWithDevTools[devtoolsSymbol] || []).push(this);\n        windowWithDevTools.__APOLLO_CLIENT__ = this;\n        /**\n         * Suggest installing the devtools for developers who don't have them\n         */\n        if (!hasSuggestedDevtools && globalThis.__DEV__ !== false) {\n            hasSuggestedDevtools = true;\n            if (window.document &&\n                window.top === window.self &&\n                /^(https?|file):$/.test(window.location.protocol)) {\n                setTimeout(function () {\n                    if (!window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__) {\n                        var nav = window.navigator;\n                        var ua = nav && nav.userAgent;\n                        var url = void 0;\n                        if (typeof ua === \"string\") {\n                            if (ua.indexOf(\"Chrome/\") > -1) {\n                                url =\n                                    \"https://chrome.google.com/webstore/detail/\" +\n                                        \"apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm\";\n                            }\n                            else if (ua.indexOf(\"Firefox/\") > -1) {\n                                url =\n                                    \"https://addons.mozilla.org/en-US/firefox/addon/apollo-developer-tools/\";\n                            }\n                        }\n                        if (url) {\n                            globalThis.__DEV__ !== false && invariant.log(\"Download the Apollo DevTools for a better development \" +\n                                \"experience: %s\", url);\n                        }\n                    }\n                }, 10000);\n            }\n        }\n    };\n    Object.defineProperty(ApolloClient.prototype, \"documentTransform\", {\n        /**\n         * The `DocumentTransform` used to modify GraphQL documents before a request\n         * is made. If a custom `DocumentTransform` is not provided, this will be the\n         * default document transform.\n         */\n        get: function () {\n            return this.queryManager.documentTransform;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    /**\n     * Call this method to terminate any active client processes, making it safe\n     * to dispose of this `ApolloClient` instance.\n     */\n    ApolloClient.prototype.stop = function () {\n        this.queryManager.stop();\n    };\n    /**\n     * This watches the cache store of the query according to the options specified and\n     * returns an `ObservableQuery`. We can subscribe to this `ObservableQuery` and\n     * receive updated results through an observer when the cache store changes.\n     *\n     * Note that this method is not an implementation of GraphQL subscriptions. Rather,\n     * it uses Apollo's store in order to reactively deliver updates to your query results.\n     *\n     * For example, suppose you call watchQuery on a GraphQL query that fetches a person's\n     * first and last name and this person has a particular object identifier, provided by\n     * dataIdFromObject. Later, a different query fetches that same person's\n     * first and last name and the first name has now changed. Then, any observers associated\n     * with the results of the first query will be updated with a new result object.\n     *\n     * Note that if the cache does not change, the subscriber will *not* be notified.\n     *\n     * See [here](https://medium.com/apollo-stack/the-concepts-of-graphql-bc68bd819be3#.3mb0cbcmc) for\n     * a description of store reactivity.\n     */\n    ApolloClient.prototype.watchQuery = function (options) {\n        if (this.defaultOptions.watchQuery) {\n            options = mergeOptions(this.defaultOptions.watchQuery, options);\n        }\n        // XXX Overwriting options is probably not the best way to do this long term...\n        if (this.disableNetworkFetches &&\n            (options.fetchPolicy === \"network-only\" ||\n                options.fetchPolicy === \"cache-and-network\")) {\n            options = __assign(__assign({}, options), { fetchPolicy: \"cache-first\" });\n        }\n        return this.queryManager.watchQuery(options);\n    };\n    /**\n     * This resolves a single query according to the options specified and\n     * returns a `Promise` which is either resolved with the resulting data\n     * or rejected with an error.\n     *\n     * @param options - An object of type `QueryOptions` that allows us to\n     * describe how this query should be treated e.g. whether it should hit the\n     * server at all or just resolve from the cache, etc.\n     */\n    ApolloClient.prototype.query = function (options) {\n        if (this.defaultOptions.query) {\n            options = mergeOptions(this.defaultOptions.query, options);\n        }\n        invariant(options.fetchPolicy !== \"cache-and-network\", 16);\n        if (this.disableNetworkFetches && options.fetchPolicy === \"network-only\") {\n            options = __assign(__assign({}, options), { fetchPolicy: \"cache-first\" });\n        }\n        return this.queryManager.query(options);\n    };\n    /**\n     * This resolves a single mutation according to the options specified and returns a\n     * Promise which is either resolved with the resulting data or rejected with an\n     * error. In some cases both `data` and `errors` might be undefined, for example\n     * when `errorPolicy` is set to `'ignore'`.\n     *\n     * It takes options as an object with the following keys and values:\n     */\n    ApolloClient.prototype.mutate = function (options) {\n        if (this.defaultOptions.mutate) {\n            options = mergeOptions(this.defaultOptions.mutate, options);\n        }\n        return this.queryManager.mutate(options);\n    };\n    /**\n     * This subscribes to a graphql subscription according to the options specified and returns an\n     * `Observable` which either emits received data or an error.\n     */\n    ApolloClient.prototype.subscribe = function (options) {\n        return this.queryManager.startGraphQLSubscription(options);\n    };\n    /**\n     * Tries to read some data from the store in the shape of the provided\n     * GraphQL query without making a network request. This method will start at\n     * the root query. To start at a specific id returned by `dataIdFromObject`\n     * use `readFragment`.\n     *\n     * @param optimistic - Set to `true` to allow `readQuery` to return\n     * optimistic results. Is `false` by default.\n     */\n    ApolloClient.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readQuery(options, optimistic);\n    };\n    /**\n     * Watches the cache store of the fragment according to the options specified\n     * and returns an `Observable`. We can subscribe to this\n     * `Observable` and receive updated results through an\n     * observer when the cache store changes.\n     *\n     * You must pass in a GraphQL document with a single fragment or a document\n     * with multiple fragments that represent what you are reading. If you pass\n     * in a document with multiple fragments then you must also specify a\n     * `fragmentName`.\n     *\n     * @since 3.10.0\n     * @param options - An object of type `WatchFragmentOptions` that allows\n     * the cache to identify the fragment and optionally specify whether to react\n     * to optimistic updates.\n     */\n    ApolloClient.prototype.watchFragment = function (options) {\n        return this.cache.watchFragment(options);\n    };\n    /**\n     * Tries to read some data from the store in the shape of the provided\n     * GraphQL fragment without making a network request. This method will read a\n     * GraphQL fragment from any arbitrary id that is currently cached, unlike\n     * `readQuery` which will only read from the root query.\n     *\n     * You must pass in a GraphQL document with a single fragment or a document\n     * with multiple fragments that represent what you are reading. If you pass\n     * in a document with multiple fragments then you must also specify a\n     * `fragmentName`.\n     *\n     * @param optimistic - Set to `true` to allow `readFragment` to return\n     * optimistic results. Is `false` by default.\n     */\n    ApolloClient.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readFragment(options, optimistic);\n    };\n    /**\n     * Writes some data in the shape of the provided GraphQL query directly to\n     * the store. This method will start at the root query. To start at a\n     * specific id returned by `dataIdFromObject` then use `writeFragment`.\n     */\n    ApolloClient.prototype.writeQuery = function (options) {\n        var ref = this.cache.writeQuery(options);\n        if (options.broadcast !== false) {\n            this.queryManager.broadcastQueries();\n        }\n        return ref;\n    };\n    /**\n     * Writes some data in the shape of the provided GraphQL fragment directly to\n     * the store. This method will write to a GraphQL fragment from any arbitrary\n     * id that is currently cached, unlike `writeQuery` which will only write\n     * from the root query.\n     *\n     * You must pass in a GraphQL document with a single fragment or a document\n     * with multiple fragments that represent what you are writing. If you pass\n     * in a document with multiple fragments then you must also specify a\n     * `fragmentName`.\n     */\n    ApolloClient.prototype.writeFragment = function (options) {\n        var ref = this.cache.writeFragment(options);\n        if (options.broadcast !== false) {\n            this.queryManager.broadcastQueries();\n        }\n        return ref;\n    };\n    ApolloClient.prototype.__actionHookForDevTools = function (cb) {\n        this.devToolsHookCb = cb;\n    };\n    ApolloClient.prototype.__requestRaw = function (payload) {\n        return execute(this.link, payload);\n    };\n    /**\n     * Resets your entire store by clearing out your cache and then re-executing\n     * all of your active queries. This makes it so that you may guarantee that\n     * there is no data left in your store from a time before you called this\n     * method.\n     *\n     * `resetStore()` is useful when your user just logged out. You’ve removed the\n     * user session, and you now want to make sure that any references to data you\n     * might have fetched while the user session was active is gone.\n     *\n     * It is important to remember that `resetStore()` *will* refetch any active\n     * queries. This means that any components that might be mounted will execute\n     * their queries again using your network interface. If you do not want to\n     * re-execute any queries then you should make sure to stop watching any\n     * active queries.\n     */\n    ApolloClient.prototype.resetStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () {\n            return _this.queryManager.clearStore({\n                discardWatches: false,\n            });\n        })\n            .then(function () { return Promise.all(_this.resetStoreCallbacks.map(function (fn) { return fn(); })); })\n            .then(function () { return _this.reFetchObservableQueries(); });\n    };\n    /**\n     * Remove all data from the store. Unlike `resetStore`, `clearStore` will\n     * not refetch any active queries.\n     */\n    ApolloClient.prototype.clearStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () {\n            return _this.queryManager.clearStore({\n                discardWatches: true,\n            });\n        })\n            .then(function () { return Promise.all(_this.clearStoreCallbacks.map(function (fn) { return fn(); })); });\n    };\n    /**\n     * Allows callbacks to be registered that are executed when the store is\n     * reset. `onResetStore` returns an unsubscribe function that can be used\n     * to remove registered callbacks.\n     */\n    ApolloClient.prototype.onResetStore = function (cb) {\n        var _this = this;\n        this.resetStoreCallbacks.push(cb);\n        return function () {\n            _this.resetStoreCallbacks = _this.resetStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    /**\n     * Allows callbacks to be registered that are executed when the store is\n     * cleared. `onClearStore` returns an unsubscribe function that can be used\n     * to remove registered callbacks.\n     */\n    ApolloClient.prototype.onClearStore = function (cb) {\n        var _this = this;\n        this.clearStoreCallbacks.push(cb);\n        return function () {\n            _this.clearStoreCallbacks = _this.clearStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    /**\n     * Refetches all of your active queries.\n     *\n     * `reFetchObservableQueries()` is useful if you want to bring the client back to proper state in case of a network outage\n     *\n     * It is important to remember that `reFetchObservableQueries()` *will* refetch any active\n     * queries. This means that any components that might be mounted will execute\n     * their queries again using your network interface. If you do not want to\n     * re-execute any queries then you should make sure to stop watching any\n     * active queries.\n     * Takes optional parameter `includeStandby` which will include queries in standby-mode when refetching.\n     */\n    ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {\n        return this.queryManager.reFetchObservableQueries(includeStandby);\n    };\n    /**\n     * Refetches specified active queries. Similar to \"reFetchObservableQueries()\" but with a specific list of queries.\n     *\n     * `refetchQueries()` is useful for use cases to imperatively refresh a selection of queries.\n     *\n     * It is important to remember that `refetchQueries()` *will* refetch specified active\n     * queries. This means that any components that might be mounted will execute\n     * their queries again using your network interface. If you do not want to\n     * re-execute any queries then you should make sure to stop watching any\n     * active queries.\n     */\n    ApolloClient.prototype.refetchQueries = function (options) {\n        var map = this.queryManager.refetchQueries(options);\n        var queries = [];\n        var results = [];\n        map.forEach(function (result, obsQuery) {\n            queries.push(obsQuery);\n            results.push(result);\n        });\n        var result = Promise.all(results);\n        // In case you need the raw results immediately, without awaiting\n        // Promise.all(results):\n        result.queries = queries;\n        result.results = results;\n        // If you decide to ignore the result Promise because you're using\n        // result.queries and result.results instead, you shouldn't have to worry\n        // about preventing uncaught rejections for the Promise.all result.\n        result.catch(function (error) {\n            globalThis.__DEV__ !== false && invariant.debug(17, error);\n        });\n        return result;\n    };\n    /**\n     * Get all currently active `ObservableQuery` objects, in a `Map` keyed by\n     * query ID strings.\n     *\n     * An \"active\" query is one that has observers and a `fetchPolicy` other than\n     * \"standby\" or \"cache-only\".\n     *\n     * You can include all `ObservableQuery` objects (including the inactive ones)\n     * by passing \"all\" instead of \"active\", or you can include just a subset of\n     * active queries by passing an array of query names or DocumentNode objects.\n     */\n    ApolloClient.prototype.getObservableQueries = function (include) {\n        if (include === void 0) { include = \"active\"; }\n        return this.queryManager.getObservableQueries(include);\n    };\n    /**\n     * Exposes the cache's complete state, in a serializable format for later restoration.\n     */\n    ApolloClient.prototype.extract = function (optimistic) {\n        return this.cache.extract(optimistic);\n    };\n    /**\n     * Replaces existing state in the cache (if any) with the values expressed by\n     * `serializedState`.\n     *\n     * Called when hydrating a cache (server side rendering, or offline storage),\n     * and also (potentially) during hot reloads.\n     */\n    ApolloClient.prototype.restore = function (serializedState) {\n        return this.cache.restore(serializedState);\n    };\n    /**\n     * Add additional local resolvers.\n     */\n    ApolloClient.prototype.addResolvers = function (resolvers) {\n        this.localState.addResolvers(resolvers);\n    };\n    /**\n     * Set (override existing) local resolvers.\n     */\n    ApolloClient.prototype.setResolvers = function (resolvers) {\n        this.localState.setResolvers(resolvers);\n    };\n    /**\n     * Get all registered local resolvers.\n     */\n    ApolloClient.prototype.getResolvers = function () {\n        return this.localState.getResolvers();\n    };\n    /**\n     * Set a custom local state fragment matcher.\n     */\n    ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {\n        this.localState.setFragmentMatcher(fragmentMatcher);\n    };\n    /**\n     * Define a new ApolloLink (or link chain) that Apollo Client will use.\n     */\n    ApolloClient.prototype.setLink = function (newLink) {\n        this.link = this.queryManager.link = newLink;\n    };\n    Object.defineProperty(ApolloClient.prototype, \"defaultContext\", {\n        get: function () {\n            return this.queryManager.defaultContext;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return ApolloClient;\n}());\nexport { ApolloClient };\nif (globalThis.__DEV__ !== false) {\n    ApolloClient.prototype.getMemoryInternals = getApolloClientMemoryInternals;\n}\n//# sourceMappingURL=ApolloClient.js.map","import { __rest } from \"tslib\";\nimport equal from \"@wry/equality\";\nimport { createFragmentMap, getFragmentDefinitions, getFragmentFromSelection, getMainDefinition, isField, resultKeyNameFromField, shouldInclude, } from \"../utilities/index.js\";\n// Returns true if aResult and bResult are deeply equal according to the fields\n// selected by the given query, ignoring any fields marked as @nonreactive.\nexport function equalByQuery(query, _a, _b, variables) {\n    var aData = _a.data, aRest = __rest(_a, [\"data\"]);\n    var bData = _b.data, bRest = __rest(_b, [\"data\"]);\n    return (equal(aRest, bRest) &&\n        equalBySelectionSet(getMainDefinition(query).selectionSet, aData, bData, {\n            fragmentMap: createFragmentMap(getFragmentDefinitions(query)),\n            variables: variables,\n        }));\n}\nfunction equalBySelectionSet(selectionSet, aResult, bResult, context) {\n    if (aResult === bResult) {\n        return true;\n    }\n    var seenSelections = new Set();\n    // Returning true from this Array.prototype.every callback function skips the\n    // current field/subtree. Returning false aborts the entire traversal\n    // immediately, causing equalBySelectionSet to return false.\n    return selectionSet.selections.every(function (selection) {\n        // Avoid re-processing the same selection at the same level of recursion, in\n        // case the same field gets included via multiple indirect fragment spreads.\n        if (seenSelections.has(selection))\n            return true;\n        seenSelections.add(selection);\n        // Ignore @skip(if: true) and @include(if: false) fields.\n        if (!shouldInclude(selection, context.variables))\n            return true;\n        // If the field or (named) fragment spread has a @nonreactive directive on\n        // it, we don't care if it's different, so we pretend it's the same.\n        if (selectionHasNonreactiveDirective(selection))\n            return true;\n        if (isField(selection)) {\n            var resultKey = resultKeyNameFromField(selection);\n            var aResultChild = aResult && aResult[resultKey];\n            var bResultChild = bResult && bResult[resultKey];\n            var childSelectionSet = selection.selectionSet;\n            if (!childSelectionSet) {\n                // These are scalar values, so we can compare them with deep equal\n                // without redoing the main recursive work.\n                return equal(aResultChild, bResultChild);\n            }\n            var aChildIsArray = Array.isArray(aResultChild);\n            var bChildIsArray = Array.isArray(bResultChild);\n            if (aChildIsArray !== bChildIsArray)\n                return false;\n            if (aChildIsArray && bChildIsArray) {\n                var length_1 = aResultChild.length;\n                if (bResultChild.length !== length_1) {\n                    return false;\n                }\n                for (var i = 0; i < length_1; ++i) {\n                    if (!equalBySelectionSet(childSelectionSet, aResultChild[i], bResultChild[i], context)) {\n                        return false;\n                    }\n                }\n                return true;\n            }\n            return equalBySelectionSet(childSelectionSet, aResultChild, bResultChild, context);\n        }\n        else {\n            var fragment = getFragmentFromSelection(selection, context.fragmentMap);\n            if (fragment) {\n                // The fragment might === selection if it's an inline fragment, but\n                // could be !== if it's a named fragment ...spread.\n                if (selectionHasNonreactiveDirective(fragment))\n                    return true;\n                return equalBySelectionSet(fragment.selectionSet, \n                // Notice that we reuse the same aResult and bResult values here,\n                // since the fragment ...spread does not specify a field name, but\n                // consists of multiple fields (within the fragment's selection set)\n                // that should be applied to the current result value(s).\n                aResult, bResult, context);\n            }\n        }\n    });\n}\nfunction selectionHasNonreactiveDirective(selection) {\n    return (!!selection.directives && selection.directives.some(directiveIsNonreactive));\n}\nfunction directiveIsNonreactive(dir) {\n    return dir.name.value === \"nonreactive\";\n}\n//# sourceMappingURL=equalByQuery.js.map","/**\n * The current status of a query’s execution in our system.\n */\nexport var NetworkStatus;\n(function (NetworkStatus) {\n    /**\n     * The query has never been run before and the query is now currently running. A query will still\n     * have this network status even if a partial data result was returned from the cache, but a\n     * query was dispatched anyway.\n     */\n    NetworkStatus[NetworkStatus[\"loading\"] = 1] = \"loading\";\n    /**\n     * If `setVariables` was called and a query was fired because of that then the network status\n     * will be `setVariables` until the result of that query comes back.\n     */\n    NetworkStatus[NetworkStatus[\"setVariables\"] = 2] = \"setVariables\";\n    /**\n     * Indicates that `fetchMore` was called on this query and that the query created is currently in\n     * flight.\n     */\n    NetworkStatus[NetworkStatus[\"fetchMore\"] = 3] = \"fetchMore\";\n    /**\n     * Similar to the `setVariables` network status. It means that `refetch` was called on a query\n     * and the refetch request is currently in flight.\n     */\n    NetworkStatus[NetworkStatus[\"refetch\"] = 4] = \"refetch\";\n    /**\n     * Indicates that a polling query is currently in flight. So for example if you are polling a\n     * query every 10 seconds then the network status will switch to `poll` every 10 seconds whenever\n     * a poll request has been sent but not resolved.\n     */\n    NetworkStatus[NetworkStatus[\"poll\"] = 6] = \"poll\";\n    /**\n     * No request is in flight for this query, and no errors happened. Everything is OK.\n     */\n    NetworkStatus[NetworkStatus[\"ready\"] = 7] = \"ready\";\n    /**\n     * No request is in flight for this query, but one or more errors were detected.\n     */\n    NetworkStatus[NetworkStatus[\"error\"] = 8] = \"error\";\n})(NetworkStatus || (NetworkStatus = {}));\n/**\n * Returns true if there is currently a network request in flight according to a given network\n * status.\n */\nexport function isNetworkRequestInFlight(networkStatus) {\n    return networkStatus ? networkStatus < 7 : false;\n}\n/**\n * Returns true if the network request is in ready or error state according to a given network\n * status.\n */\nexport function isNetworkRequestSettled(networkStatus) {\n    return networkStatus === 7 || networkStatus === 8;\n}\n//# sourceMappingURL=networkStatus.js.map","import { __rest } from \"tslib\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { Observable } from \"../../utilities/index.js\";\nexport function setContext(setter) {\n    return new ApolloLink(function (operation, forward) {\n        var request = __rest(operation, []);\n        return new Observable(function (observer) {\n            var handle;\n            var closed = false;\n            Promise.resolve(request)\n                .then(function (req) { return setter(req, operation.getContext()); })\n                .then(operation.setContext)\n                .then(function () {\n                // if the observer is already closed, no need to subscribe.\n                if (closed)\n                    return;\n                handle = forward(operation).subscribe({\n                    next: observer.next.bind(observer),\n                    error: observer.error.bind(observer),\n                    complete: observer.complete.bind(observer),\n                });\n            })\n                .catch(observer.error.bind(observer));\n            return function () {\n                closed = true;\n                if (handle)\n                    handle.unsubscribe();\n            };\n        });\n    });\n}\n//# sourceMappingURL=index.js.map","import { __assign } from \"tslib\";\nexport function createOperation(starting, operation) {\n    var context = __assign({}, starting);\n    var setContext = function (next) {\n        if (typeof next === \"function\") {\n            context = __assign(__assign({}, context), next(context));\n        }\n        else {\n            context = __assign(__assign({}, context), next);\n        }\n    };\n    var getContext = function () { return (__assign({}, context)); };\n    Object.defineProperty(operation, \"setContext\", {\n        enumerable: false,\n        value: setContext,\n    });\n    Object.defineProperty(operation, \"getContext\", {\n        enumerable: false,\n        value: getContext,\n    });\n    return operation;\n}\n//# sourceMappingURL=createOperation.js.map","import { getOperationName } from \"../../utilities/index.js\";\nexport function transformOperation(operation) {\n    var transformedOperation = {\n        variables: operation.variables || {},\n        extensions: operation.extensions || {},\n        operationName: operation.operationName,\n        query: operation.query,\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    return transformedOperation;\n}\n//# sourceMappingURL=transformOperation.js.map","import { newInvariantError } from \"../../utilities/globals/index.js\";\nexport function validateOperation(operation) {\n    var OPERATION_FIELDS = [\n        \"query\",\n        \"operationName\",\n        \"variables\",\n        \"extensions\",\n        \"context\",\n    ];\n    for (var _i = 0, _a = Object.keys(operation); _i < _a.length; _i++) {\n        var key = _a[_i];\n        if (OPERATION_FIELDS.indexOf(key) < 0) {\n            throw newInvariantError(44, key);\n        }\n    }\n    return operation;\n}\n//# sourceMappingURL=validateOperation.js.map","import { newInvariantError, invariant } from \"../../utilities/globals/index.js\";\nimport { Observable } from \"../../utilities/index.js\";\nimport { validateOperation, createOperation, transformOperation, } from \"../utils/index.js\";\nfunction passthrough(op, forward) {\n    return (forward ? forward(op) : Observable.of());\n}\nfunction toLink(handler) {\n    return typeof handler === \"function\" ? new ApolloLink(handler) : handler;\n}\nfunction isTerminating(link) {\n    return link.request.length <= 1;\n}\nvar ApolloLink = /** @class */ (function () {\n    function ApolloLink(request) {\n        if (request)\n            this.request = request;\n    }\n    ApolloLink.empty = function () {\n        return new ApolloLink(function () { return Observable.of(); });\n    };\n    ApolloLink.from = function (links) {\n        if (links.length === 0)\n            return ApolloLink.empty();\n        return links.map(toLink).reduce(function (x, y) { return x.concat(y); });\n    };\n    ApolloLink.split = function (test, left, right) {\n        var leftLink = toLink(left);\n        var rightLink = toLink(right || new ApolloLink(passthrough));\n        var ret;\n        if (isTerminating(leftLink) && isTerminating(rightLink)) {\n            ret = new ApolloLink(function (operation) {\n                return test(operation) ?\n                    leftLink.request(operation) || Observable.of()\n                    : rightLink.request(operation) || Observable.of();\n            });\n        }\n        else {\n            ret = new ApolloLink(function (operation, forward) {\n                return test(operation) ?\n                    leftLink.request(operation, forward) || Observable.of()\n                    : rightLink.request(operation, forward) || Observable.of();\n            });\n        }\n        return Object.assign(ret, { left: leftLink, right: rightLink });\n    };\n    ApolloLink.execute = function (link, operation) {\n        return (link.request(createOperation(operation.context, transformOperation(validateOperation(operation)))) || Observable.of());\n    };\n    ApolloLink.concat = function (first, second) {\n        var firstLink = toLink(first);\n        if (isTerminating(firstLink)) {\n            globalThis.__DEV__ !== false && invariant.warn(36, firstLink);\n            return firstLink;\n        }\n        var nextLink = toLink(second);\n        var ret;\n        if (isTerminating(nextLink)) {\n            ret = new ApolloLink(function (operation) {\n                return firstLink.request(operation, function (op) { return nextLink.request(op) || Observable.of(); }) || Observable.of();\n            });\n        }\n        else {\n            ret = new ApolloLink(function (operation, forward) {\n                return (firstLink.request(operation, function (op) {\n                    return nextLink.request(op, forward) || Observable.of();\n                }) || Observable.of());\n            });\n        }\n        return Object.assign(ret, { left: firstLink, right: nextLink });\n    };\n    ApolloLink.prototype.split = function (test, left, right) {\n        return this.concat(ApolloLink.split(test, left, right || new ApolloLink(passthrough)));\n    };\n    ApolloLink.prototype.concat = function (next) {\n        return ApolloLink.concat(this, next);\n    };\n    ApolloLink.prototype.request = function (operation, forward) {\n        throw newInvariantError(37);\n    };\n    ApolloLink.prototype.onError = function (error, observer) {\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    ApolloLink.prototype.setOnError = function (fn) {\n        this.onError = fn;\n        return this;\n    };\n    return ApolloLink;\n}());\nexport { ApolloLink };\n//# sourceMappingURL=ApolloLink.js.map","import { __extends } from \"tslib\";\nimport { Observable } from \"../../utilities/index.js\";\nimport { ApolloLink } from \"../core/index.js\";\nexport function onError(errorHandler) {\n    return new ApolloLink(function (operation, forward) {\n        return new Observable(function (observer) {\n            var sub;\n            var retriedSub;\n            var retriedResult;\n            try {\n                sub = forward(operation).subscribe({\n                    next: function (result) {\n                        if (result.errors) {\n                            retriedResult = errorHandler({\n                                graphQLErrors: result.errors,\n                                response: result,\n                                operation: operation,\n                                forward: forward,\n                            });\n                            if (retriedResult) {\n                                retriedSub = retriedResult.subscribe({\n                                    next: observer.next.bind(observer),\n                                    error: observer.error.bind(observer),\n                                    complete: observer.complete.bind(observer),\n                                });\n                                return;\n                            }\n                        }\n                        observer.next(result);\n                    },\n                    error: function (networkError) {\n                        retriedResult = errorHandler({\n                            operation: operation,\n                            networkError: networkError,\n                            //Network errors can return GraphQL errors on for example a 403\n                            graphQLErrors: (networkError &&\n                                networkError.result &&\n                                networkError.result.errors) ||\n                                void 0,\n                            forward: forward,\n                        });\n                        if (retriedResult) {\n                            retriedSub = retriedResult.subscribe({\n                                next: observer.next.bind(observer),\n                                error: observer.error.bind(observer),\n                                complete: observer.complete.bind(observer),\n                            });\n                            return;\n                        }\n                        observer.error(networkError);\n                    },\n                    complete: function () {\n                        // disable the previous sub from calling complete on observable\n                        // if retry is in flight.\n                        if (!retriedResult) {\n                            observer.complete.bind(observer)();\n                        }\n                    },\n                });\n            }\n            catch (e) {\n                errorHandler({ networkError: e, operation: operation, forward: forward });\n                observer.error(e);\n            }\n            return function () {\n                if (sub)\n                    sub.unsubscribe();\n                if (retriedSub)\n                    sub.unsubscribe();\n            };\n        });\n    });\n}\nvar ErrorLink = /** @class */ (function (_super) {\n    __extends(ErrorLink, _super);\n    function ErrorLink(errorHandler) {\n        var _this = _super.call(this) || this;\n        _this.link = onError(errorHandler);\n        return _this;\n    }\n    ErrorLink.prototype.request = function (operation, forward) {\n        return this.link.request(operation, forward);\n    };\n    return ErrorLink;\n}(ApolloLink));\nexport { ErrorLink };\n//# sourceMappingURL=index.js.map","import { newInvariantError } from \"../../utilities/globals/index.js\";\nexport var serializeFetchParameter = function (p, label) {\n    var serialized;\n    try {\n        serialized = JSON.stringify(p);\n    }\n    catch (e) {\n        var parseError = newInvariantError(40, label, e.message);\n        parseError.parseError = e;\n        throw parseError;\n    }\n    return serialized;\n};\n//# sourceMappingURL=serializeFetchParameter.js.map","export var selectURI = function (operation, fallbackURI) {\n    var context = operation.getContext();\n    var contextURI = context.uri;\n    if (contextURI) {\n        return contextURI;\n    }\n    else if (typeof fallbackURI === \"function\") {\n        return fallbackURI(operation);\n    }\n    else {\n        return fallbackURI || \"/graphql\";\n    }\n};\n//# sourceMappingURL=selectURI.js.map","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/iterators/async.ts\n */\nexport default function asyncIterator(source) {\n    var _a;\n    var iterator = source[Symbol.asyncIterator]();\n    return _a = {\n            next: function () {\n                return iterator.next();\n            }\n        },\n        _a[Symbol.asyncIterator] = function () {\n            return this;\n        },\n        _a;\n}\n//# sourceMappingURL=async.js.map","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/iterators/nodeStream.ts\n */\nimport { canUseAsyncIteratorSymbol } from \"../../../utilities/index.js\";\nexport default function nodeStreamIterator(stream) {\n    var cleanup = null;\n    var error = null;\n    var done = false;\n    var data = [];\n    var waiting = [];\n    function onData(chunk) {\n        if (error)\n            return;\n        if (waiting.length) {\n            var shiftedArr = waiting.shift();\n            if (Array.isArray(shiftedArr) && shiftedArr[0]) {\n                return shiftedArr[0]({ value: chunk, done: false });\n            }\n        }\n        data.push(chunk);\n    }\n    function onError(err) {\n        error = err;\n        var all = waiting.slice();\n        all.forEach(function (pair) {\n            pair[1](err);\n        });\n        !cleanup || cleanup();\n    }\n    function onEnd() {\n        done = true;\n        var all = waiting.slice();\n        all.forEach(function (pair) {\n            pair[0]({ value: undefined, done: true });\n        });\n        !cleanup || cleanup();\n    }\n    cleanup = function () {\n        cleanup = null;\n        stream.removeListener(\"data\", onData);\n        stream.removeListener(\"error\", onError);\n        stream.removeListener(\"end\", onEnd);\n        stream.removeListener(\"finish\", onEnd);\n        stream.removeListener(\"close\", onEnd);\n    };\n    stream.on(\"data\", onData);\n    stream.on(\"error\", onError);\n    stream.on(\"end\", onEnd);\n    stream.on(\"finish\", onEnd);\n    stream.on(\"close\", onEnd);\n    function getNext() {\n        return new Promise(function (resolve, reject) {\n            if (error)\n                return reject(error);\n            if (data.length)\n                return resolve({ value: data.shift(), done: false });\n            if (done)\n                return resolve({ value: undefined, done: true });\n            waiting.push([resolve, reject]);\n        });\n    }\n    var iterator = {\n        next: function () {\n            return getNext();\n        },\n    };\n    if (canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n//# sourceMappingURL=nodeStream.js.map","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/iterators/promise.ts\n */\nimport { canUseAsyncIteratorSymbol } from \"../../../utilities/index.js\";\nexport default function promiseIterator(promise) {\n    var resolved = false;\n    var iterator = {\n        next: function () {\n            if (resolved)\n                return Promise.resolve({\n                    value: undefined,\n                    done: true,\n                });\n            resolved = true;\n            return new Promise(function (resolve, reject) {\n                promise\n                    .then(function (value) {\n                    resolve({ value: value, done: false });\n                })\n                    .catch(reject);\n            });\n        },\n    };\n    if (canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n//# sourceMappingURL=promise.js.map","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/iterators/reader.ts\n */\nimport { canUseAsyncIteratorSymbol } from \"../../../utilities/index.js\";\nexport default function readerIterator(reader) {\n    var iterator = {\n        next: function () {\n            return reader.read();\n        },\n    };\n    if (canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n//# sourceMappingURL=reader.js.map","/**\n * Original source:\n * https://github.com/kmalakoff/response-iterator/blob/master/src/index.ts\n */\nimport { canUseAsyncIteratorSymbol } from \"../../utilities/index.js\";\nimport asyncIterator from \"./iterators/async.js\";\nimport nodeStreamIterator from \"./iterators/nodeStream.js\";\nimport promiseIterator from \"./iterators/promise.js\";\nimport readerIterator from \"./iterators/reader.js\";\nfunction isNodeResponse(value) {\n    return !!value.body;\n}\nfunction isReadableStream(value) {\n    return !!value.getReader;\n}\nfunction isAsyncIterableIterator(value) {\n    return !!(canUseAsyncIteratorSymbol &&\n        value[Symbol.asyncIterator]);\n}\nfunction isStreamableBlob(value) {\n    return !!value.stream;\n}\nfunction isBlob(value) {\n    return !!value.arrayBuffer;\n}\nfunction isNodeReadableStream(value) {\n    return !!value.pipe;\n}\nexport function responseIterator(response) {\n    var body = response;\n    if (isNodeResponse(response))\n        body = response.body;\n    if (isAsyncIterableIterator(body))\n        return asyncIterator(body);\n    if (isReadableStream(body))\n        return readerIterator(body.getReader());\n    // this errors without casting to ReadableStream<T>\n    // because Blob.stream() returns a NodeJS ReadableStream\n    if (isStreamableBlob(body)) {\n        return readerIterator(body.stream().getReader());\n    }\n    if (isBlob(body))\n        return promiseIterator(body.arrayBuffer());\n    if (isNodeReadableStream(body))\n        return nodeStreamIterator(body);\n    throw new Error(\"Unknown body type for responseIterator. Please pass a streamable response.\");\n}\n//# sourceMappingURL=responseIterator.js.map","export var throwServerError = function (response, result, message) {\n    var error = new Error(message);\n    error.name = \"ServerError\";\n    error.response = response;\n    error.statusCode = response.status;\n    error.result = result;\n    throw error;\n};\n//# sourceMappingURL=throwServerError.js.map","import { __assign, __awaiter, __generator } from \"tslib\";\nimport { responseIterator } from \"./responseIterator.js\";\nimport { throwServerError } from \"../utils/index.js\";\nimport { PROTOCOL_ERRORS_SYMBOL } from \"../../errors/index.js\";\nimport { isApolloPayloadResult } from \"../../utilities/common/incrementalResult.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function readMultipartBody(response, nextValue) {\n    return __awaiter(this, void 0, void 0, function () {\n        var decoder, contentType, delimiter, boundaryVal, boundary, buffer, iterator, running, _a, value, done, chunk, searchFrom, bi, message, i, headers, contentType_1, body, result, next;\n        var _b, _c;\n        var _d;\n        return __generator(this, function (_e) {\n            switch (_e.label) {\n                case 0:\n                    if (TextDecoder === undefined) {\n                        throw new Error(\"TextDecoder must be defined in the environment: please import a polyfill.\");\n                    }\n                    decoder = new TextDecoder(\"utf-8\");\n                    contentType = (_d = response.headers) === null || _d === void 0 ? void 0 : _d.get(\"content-type\");\n                    delimiter = \"boundary=\";\n                    boundaryVal = (contentType === null || contentType === void 0 ? void 0 : contentType.includes(delimiter)) ?\n                        contentType === null || contentType === void 0 ? void 0 : contentType.substring((contentType === null || contentType === void 0 ? void 0 : contentType.indexOf(delimiter)) + delimiter.length).replace(/['\"]/g, \"\").replace(/\\;(.*)/gm, \"\").trim()\n                        : \"-\";\n                    boundary = \"\\r\\n--\".concat(boundaryVal);\n                    buffer = \"\";\n                    iterator = responseIterator(response);\n                    running = true;\n                    _e.label = 1;\n                case 1:\n                    if (!running) return [3 /*break*/, 3];\n                    return [4 /*yield*/, iterator.next()];\n                case 2:\n                    _a = _e.sent(), value = _a.value, done = _a.done;\n                    chunk = typeof value === \"string\" ? value : decoder.decode(value);\n                    searchFrom = buffer.length - boundary.length + 1;\n                    running = !done;\n                    buffer += chunk;\n                    bi = buffer.indexOf(boundary, searchFrom);\n                    while (bi > -1) {\n                        message = void 0;\n                        _b = [\n                            buffer.slice(0, bi),\n                            buffer.slice(bi + boundary.length),\n                        ], message = _b[0], buffer = _b[1];\n                        i = message.indexOf(\"\\r\\n\\r\\n\");\n                        headers = parseHeaders(message.slice(0, i));\n                        contentType_1 = headers[\"content-type\"];\n                        if (contentType_1 &&\n                            contentType_1.toLowerCase().indexOf(\"application/json\") === -1) {\n                            throw new Error(\"Unsupported patch content type: application/json is required.\");\n                        }\n                        body = message.slice(i);\n                        if (body) {\n                            result = parseJsonBody(response, body);\n                            if (Object.keys(result).length > 1 ||\n                                \"data\" in result ||\n                                \"incremental\" in result ||\n                                \"errors\" in result ||\n                                \"payload\" in result) {\n                                if (isApolloPayloadResult(result)) {\n                                    next = {};\n                                    if (\"payload\" in result) {\n                                        if (Object.keys(result).length === 1 && result.payload === null) {\n                                            return [2 /*return*/];\n                                        }\n                                        next = __assign({}, result.payload);\n                                    }\n                                    if (\"errors\" in result) {\n                                        next = __assign(__assign({}, next), { extensions: __assign(__assign({}, (\"extensions\" in next ? next.extensions : null)), (_c = {}, _c[PROTOCOL_ERRORS_SYMBOL] = result.errors, _c)) });\n                                    }\n                                    nextValue(next);\n                                }\n                                else {\n                                    // for the last chunk with only `hasNext: false`\n                                    // we don't need to call observer.next as there is no data/errors\n                                    nextValue(result);\n                                }\n                            }\n                            else if (\n                            // If the chunk contains only a \"hasNext: false\", we can call\n                            // observer.complete() immediately.\n                            Object.keys(result).length === 1 &&\n                                \"hasNext\" in result &&\n                                !result.hasNext) {\n                                return [2 /*return*/];\n                            }\n                        }\n                        bi = buffer.indexOf(boundary);\n                    }\n                    return [3 /*break*/, 1];\n                case 3: return [2 /*return*/];\n            }\n        });\n    });\n}\nexport function parseHeaders(headerText) {\n    var headersInit = {};\n    headerText.split(\"\\n\").forEach(function (line) {\n        var i = line.indexOf(\":\");\n        if (i > -1) {\n            // normalize headers to lowercase\n            var name_1 = line.slice(0, i).trim().toLowerCase();\n            var value = line.slice(i + 1).trim();\n            headersInit[name_1] = value;\n        }\n    });\n    return headersInit;\n}\nexport function parseJsonBody(response, bodyText) {\n    if (response.status >= 300) {\n        // Network error\n        var getResult = function () {\n            try {\n                return JSON.parse(bodyText);\n            }\n            catch (err) {\n                return bodyText;\n            }\n        };\n        throwServerError(response, getResult(), \"Response not successful: Received status code \".concat(response.status));\n    }\n    try {\n        return JSON.parse(bodyText);\n    }\n    catch (err) {\n        var parseError = err;\n        parseError.name = \"ServerParseError\";\n        parseError.response = response;\n        parseError.statusCode = response.status;\n        parseError.bodyText = bodyText;\n        throw parseError;\n    }\n}\nexport function handleError(err, observer) {\n    // if it is a network error, BUT there is graphql result info fire\n    // the next observer before calling error this gives apollo-client\n    // (and react-apollo) the `graphqlErrors` and `networkErrors` to\n    // pass to UI this should only happen if we *also* have data as\n    // part of the response key per the spec\n    if (err.result && err.result.errors && err.result.data) {\n        // if we don't call next, the UI can only show networkError\n        // because AC didn't get any graphqlErrors this is graphql\n        // execution result info (i.e errors and possibly data) this is\n        // because there is no formal spec how errors should translate to\n        // http status codes. So an auth error (401) could have both data\n        // from a public field, errors from a private field, and a status\n        // of 401\n        // {\n        //  user { // this will have errors\n        //    firstName\n        //  }\n        //  products { // this is public so will have data\n        //    cost\n        //  }\n        // }\n        //\n        // the result of above *could* look like this:\n        // {\n        //   data: { products: [{ cost: \"$10\" }] },\n        //   errors: [{\n        //      message: 'your session has timed out',\n        //      path: []\n        //   }]\n        // }\n        // status code of above would be a 401\n        // in the UI you want to show data where you can, errors as data where you can\n        // and use correct http status codes\n        observer.next(err.result);\n    }\n    observer.error(err);\n}\nexport function parseAndCheckHttpResponse(operations) {\n    return function (response) {\n        return response\n            .text()\n            .then(function (bodyText) { return parseJsonBody(response, bodyText); })\n            .then(function (result) {\n            if (!Array.isArray(result) &&\n                !hasOwnProperty.call(result, \"data\") &&\n                !hasOwnProperty.call(result, \"errors\")) {\n                // Data error\n                throwServerError(response, result, \"Server response was missing for query '\".concat(Array.isArray(operations) ?\n                    operations.map(function (op) { return op.operationName; })\n                    : operations.operationName, \"'.\"));\n            }\n            return result;\n        });\n    };\n}\n//# sourceMappingURL=parseAndCheckHttpResponse.js.map","import { newInvariantError } from \"../../utilities/globals/index.js\";\nexport var checkFetcher = function (fetcher) {\n    if (!fetcher && typeof fetch === \"undefined\") {\n        throw newInvariantError(38);\n    }\n};\n//# sourceMappingURL=checkFetcher.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { print } from \"../../utilities/index.js\";\nvar defaultHttpOptions = {\n    includeQuery: true,\n    includeExtensions: false,\n    preserveHeaderCase: false,\n};\nvar defaultHeaders = {\n    // headers are case insensitive (https://stackoverflow.com/a/5259004)\n    accept: \"*/*\",\n    // The content-type header describes the type of the body of the request, and\n    // so it typically only is sent with requests that actually have bodies. One\n    // could imagine that Apollo Client would remove this header when constructing\n    // a GET request (which has no body), but we historically have not done that.\n    // This means that browsers will preflight all Apollo Client requests (even\n    // GET requests). Apollo Server's CSRF prevention feature (introduced in\n    // AS3.7) takes advantage of this fact and does not block requests with this\n    // header. If you want to drop this header from GET requests, then you should\n    // probably replace it with a `apollo-require-preflight` header, or servers\n    // with CSRF prevention enabled might block your GET request. See\n    // https://www.apollographql.com/docs/apollo-server/security/cors/#preventing-cross-site-request-forgery-csrf\n    // for more details.\n    \"content-type\": \"application/json\",\n};\nvar defaultOptions = {\n    method: \"POST\",\n};\nexport var fallbackHttpConfig = {\n    http: defaultHttpOptions,\n    headers: defaultHeaders,\n    options: defaultOptions,\n};\nexport var defaultPrinter = function (ast, printer) { return printer(ast); };\nexport function selectHttpOptionsAndBody(operation, fallbackConfig) {\n    var configs = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        configs[_i - 2] = arguments[_i];\n    }\n    configs.unshift(fallbackConfig);\n    return selectHttpOptionsAndBodyInternal.apply(void 0, __spreadArray([operation,\n        defaultPrinter], configs, false));\n}\nexport function selectHttpOptionsAndBodyInternal(operation, printer) {\n    var configs = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        configs[_i - 2] = arguments[_i];\n    }\n    var options = {};\n    var http = {};\n    configs.forEach(function (config) {\n        options = __assign(__assign(__assign({}, options), config.options), { headers: __assign(__assign({}, options.headers), config.headers) });\n        if (config.credentials) {\n            options.credentials = config.credentials;\n        }\n        http = __assign(__assign({}, http), config.http);\n    });\n    if (options.headers) {\n        options.headers = removeDuplicateHeaders(options.headers, http.preserveHeaderCase);\n    }\n    //The body depends on the http options\n    var operationName = operation.operationName, extensions = operation.extensions, variables = operation.variables, query = operation.query;\n    var body = { operationName: operationName, variables: variables };\n    if (http.includeExtensions)\n        body.extensions = extensions;\n    // not sending the query (i.e persisted queries)\n    if (http.includeQuery)\n        body.query = printer(query, print);\n    return {\n        options: options,\n        body: body,\n    };\n}\n// Remove potential duplicate header names, preserving last (by insertion order).\n// This is done to prevent unintentionally duplicating a header instead of\n// overwriting it (See #8447 and #8449).\nfunction removeDuplicateHeaders(headers, preserveHeaderCase) {\n    // If we're not preserving the case, just remove duplicates w/ normalization.\n    if (!preserveHeaderCase) {\n        var normalizedHeaders_1 = {};\n        Object.keys(Object(headers)).forEach(function (name) {\n            normalizedHeaders_1[name.toLowerCase()] = headers[name];\n        });\n        return normalizedHeaders_1;\n    }\n    // If we are preserving the case, remove duplicates w/ normalization,\n    // preserving the original name.\n    // This allows for non-http-spec-compliant servers that expect intentionally\n    // capitalized header names (See #6741).\n    var headerData = {};\n    Object.keys(Object(headers)).forEach(function (name) {\n        headerData[name.toLowerCase()] = {\n            originalName: name,\n            value: headers[name],\n        };\n    });\n    var normalizedHeaders = {};\n    Object.keys(headerData).forEach(function (name) {\n        normalizedHeaders[headerData[name].originalName] = headerData[name].value;\n    });\n    return normalizedHeaders;\n}\n//# sourceMappingURL=selectHttpOptionsAndBody.js.map","import { serializeFetchParameter } from \"./serializeFetchParameter.js\";\n// For GET operations, returns the given URI rewritten with parameters, or a\n// parse error.\nexport function rewriteURIForGET(chosenURI, body) {\n    // Implement the standard HTTP GET serialization, plus 'extensions'. Note\n    // the extra level of JSON serialization!\n    var queryParams = [];\n    var addQueryParam = function (key, value) {\n        queryParams.push(\"\".concat(key, \"=\").concat(encodeURIComponent(value)));\n    };\n    if (\"query\" in body) {\n        addQueryParam(\"query\", body.query);\n    }\n    if (body.operationName) {\n        addQueryParam(\"operationName\", body.operationName);\n    }\n    if (body.variables) {\n        var serializedVariables = void 0;\n        try {\n            serializedVariables = serializeFetchParameter(body.variables, \"Variables map\");\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam(\"variables\", serializedVariables);\n    }\n    if (body.extensions) {\n        var serializedExtensions = void 0;\n        try {\n            serializedExtensions = serializeFetchParameter(body.extensions, \"Extensions map\");\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam(\"extensions\", serializedExtensions);\n    }\n    // Reconstruct the URI with added query params.\n    // XXX This assumes that the URI is well-formed and that it doesn't\n    //     already contain any of these query params. We could instead use the\n    //     URL API and take a polyfill (whatwg-url@6) for older browsers that\n    //     don't support URLSearchParams. Note that some browsers (and\n    //     versions of whatwg-url) support URL but not URLSearchParams!\n    var fragment = \"\", preFragment = chosenURI;\n    var fragmentStart = chosenURI.indexOf(\"#\");\n    if (fragmentStart !== -1) {\n        fragment = chosenURI.substr(fragmentStart);\n        preFragment = chosenURI.substr(0, fragmentStart);\n    }\n    var queryParamsPrefix = preFragment.indexOf(\"?\") === -1 ? \"?\" : \"&\";\n    var newURI = preFragment + queryParamsPrefix + queryParams.join(\"&\") + fragment;\n    return { newURI: newURI };\n}\n//# sourceMappingURL=rewriteURIForGET.js.map","import { Observable } from \"../../utilities/index.js\";\nexport function fromError(errorValue) {\n    return new Observable(function (observer) {\n        observer.error(errorValue);\n    });\n}\n//# sourceMappingURL=fromError.js.map","import { __assign } from \"tslib\";\nimport { visit } from \"graphql\";\nexport function filterOperationVariables(variables, query) {\n    var result = __assign({}, variables);\n    var unusedNames = new Set(Object.keys(variables));\n    visit(query, {\n        Variable: function (node, _key, parent) {\n            // A variable type definition at the top level of a query is not\n            // enough to silence server-side errors about the variable being\n            // unused, so variable definitions do not count as usage.\n            // https://spec.graphql.org/draft/#sec-All-Variables-Used\n            if (parent &&\n                parent.kind !== \"VariableDefinition\") {\n                unusedNames.delete(node.name.value);\n            }\n        },\n    });\n    unusedNames.forEach(function (name) {\n        delete result[name];\n    });\n    return result;\n}\n//# sourceMappingURL=filterOperationVariables.js.map","import { __assign, __rest } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport { ApolloLink } from \"../core/index.js\";\nimport { Observable, hasDirectives } from \"../../utilities/index.js\";\nimport { serializeFetchParameter } from \"./serializeFetchParameter.js\";\nimport { selectURI } from \"./selectURI.js\";\nimport { handleError, readMultipartBody, parseAndCheckHttpResponse, } from \"./parseAndCheckHttpResponse.js\";\nimport { checkFetcher } from \"./checkFetcher.js\";\nimport { selectHttpOptionsAndBodyInternal, defaultPrinter, fallbackHttpConfig, } from \"./selectHttpOptionsAndBody.js\";\nimport { rewriteURIForGET } from \"./rewriteURIForGET.js\";\nimport { fromError, filterOperationVariables } from \"../utils/index.js\";\nimport { maybe, getMainDefinition, removeClientSetsFromDocument, } from \"../../utilities/index.js\";\nvar backupFetch = maybe(function () { return fetch; });\nexport var createHttpLink = function (linkOptions) {\n    if (linkOptions === void 0) { linkOptions = {}; }\n    var _a = linkOptions.uri, uri = _a === void 0 ? \"/graphql\" : _a, \n    // use default global fetch if nothing passed in\n    preferredFetch = linkOptions.fetch, _b = linkOptions.print, print = _b === void 0 ? defaultPrinter : _b, includeExtensions = linkOptions.includeExtensions, preserveHeaderCase = linkOptions.preserveHeaderCase, useGETForQueries = linkOptions.useGETForQueries, _c = linkOptions.includeUnusedVariables, includeUnusedVariables = _c === void 0 ? false : _c, requestOptions = __rest(linkOptions, [\"uri\", \"fetch\", \"print\", \"includeExtensions\", \"preserveHeaderCase\", \"useGETForQueries\", \"includeUnusedVariables\"]);\n    if (globalThis.__DEV__ !== false) {\n        // Make sure at least one of preferredFetch, window.fetch, or backupFetch is\n        // defined, so requests won't fail at runtime.\n        checkFetcher(preferredFetch || backupFetch);\n    }\n    var linkConfig = {\n        http: { includeExtensions: includeExtensions, preserveHeaderCase: preserveHeaderCase },\n        options: requestOptions.fetchOptions,\n        credentials: requestOptions.credentials,\n        headers: requestOptions.headers,\n    };\n    return new ApolloLink(function (operation) {\n        var chosenURI = selectURI(operation, uri);\n        var context = operation.getContext();\n        // `apollographql-client-*` headers are automatically set if a\n        // `clientAwareness` object is found in the context. These headers are\n        // set first, followed by the rest of the headers pulled from\n        // `context.headers`. If desired, `apollographql-client-*` headers set by\n        // the `clientAwareness` object can be overridden by\n        // `apollographql-client-*` headers set in `context.headers`.\n        var clientAwarenessHeaders = {};\n        if (context.clientAwareness) {\n            var _a = context.clientAwareness, name_1 = _a.name, version = _a.version;\n            if (name_1) {\n                clientAwarenessHeaders[\"apollographql-client-name\"] = name_1;\n            }\n            if (version) {\n                clientAwarenessHeaders[\"apollographql-client-version\"] = version;\n            }\n        }\n        var contextHeaders = __assign(__assign({}, clientAwarenessHeaders), context.headers);\n        var contextConfig = {\n            http: context.http,\n            options: context.fetchOptions,\n            credentials: context.credentials,\n            headers: contextHeaders,\n        };\n        if (hasDirectives([\"client\"], operation.query)) {\n            var transformedQuery = removeClientSetsFromDocument(operation.query);\n            if (!transformedQuery) {\n                return fromError(new Error(\"HttpLink: Trying to send a client-only query to the server. To send to the server, ensure a non-client field is added to the query or set the `transformOptions.removeClientFields` option to `true`.\"));\n            }\n            operation.query = transformedQuery;\n        }\n        //uses fallback, link, and then context to build options\n        var _b = selectHttpOptionsAndBodyInternal(operation, print, fallbackHttpConfig, linkConfig, contextConfig), options = _b.options, body = _b.body;\n        if (body.variables && !includeUnusedVariables) {\n            body.variables = filterOperationVariables(body.variables, operation.query);\n        }\n        var controller;\n        if (!options.signal && typeof AbortController !== \"undefined\") {\n            controller = new AbortController();\n            options.signal = controller.signal;\n        }\n        // If requested, set method to GET if there are no mutations.\n        var definitionIsMutation = function (d) {\n            return d.kind === \"OperationDefinition\" && d.operation === \"mutation\";\n        };\n        var definitionIsSubscription = function (d) {\n            return d.kind === \"OperationDefinition\" && d.operation === \"subscription\";\n        };\n        var isSubscription = definitionIsSubscription(getMainDefinition(operation.query));\n        // does not match custom directives beginning with @defer\n        var hasDefer = hasDirectives([\"defer\"], operation.query);\n        if (useGETForQueries &&\n            !operation.query.definitions.some(definitionIsMutation)) {\n            options.method = \"GET\";\n        }\n        if (hasDefer || isSubscription) {\n            options.headers = options.headers || {};\n            var acceptHeader = \"multipart/mixed;\";\n            // Omit defer-specific headers if the user attempts to defer a selection\n            // set on a subscription and log a warning.\n            if (isSubscription && hasDefer) {\n                globalThis.__DEV__ !== false && invariant.warn(39);\n            }\n            if (isSubscription) {\n                acceptHeader +=\n                    \"boundary=graphql;subscriptionSpec=1.0,application/json\";\n            }\n            else if (hasDefer) {\n                acceptHeader += \"deferSpec=20220824,application/json\";\n            }\n            options.headers.accept = acceptHeader;\n        }\n        if (options.method === \"GET\") {\n            var _c = rewriteURIForGET(chosenURI, body), newURI = _c.newURI, parseError = _c.parseError;\n            if (parseError) {\n                return fromError(parseError);\n            }\n            chosenURI = newURI;\n        }\n        else {\n            try {\n                options.body = serializeFetchParameter(body, \"Payload\");\n            }\n            catch (parseError) {\n                return fromError(parseError);\n            }\n        }\n        return new Observable(function (observer) {\n            // Prefer linkOptions.fetch (preferredFetch) if provided, and otherwise\n            // fall back to the *current* global window.fetch function (see issue\n            // #7832), or (if all else fails) the backupFetch function we saved when\n            // this module was first evaluated. This last option protects against the\n            // removal of window.fetch, which is unlikely but not impossible.\n            var currentFetch = preferredFetch || maybe(function () { return fetch; }) || backupFetch;\n            var observerNext = observer.next.bind(observer);\n            currentFetch(chosenURI, options)\n                .then(function (response) {\n                var _a;\n                operation.setContext({ response: response });\n                var ctype = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get(\"content-type\");\n                if (ctype !== null && /^multipart\\/mixed/i.test(ctype)) {\n                    return readMultipartBody(response, observerNext);\n                }\n                else {\n                    return parseAndCheckHttpResponse(operation)(response).then(observerNext);\n                }\n            })\n                .then(function () {\n                controller = undefined;\n                observer.complete();\n            })\n                .catch(function (err) {\n                controller = undefined;\n                handleError(err, observer);\n            });\n            return function () {\n                // XXX support canceling this request\n                // https://developers.google.com/web/updates/2017/09/abortable-fetch\n                if (controller)\n                    controller.abort();\n            };\n        });\n    });\n};\n//# sourceMappingURL=createHttpLink.js.map","import { __assign } from \"tslib\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport * as React from \"rehackt\";\nimport { getApolloContext } from \"./ApolloContext.js\";\nexport var ApolloProvider = function (_a) {\n    var client = _a.client, children = _a.children;\n    var ApolloContext = getApolloContext();\n    var parentContext = React.useContext(ApolloContext);\n    var context = React.useMemo(function () {\n        return __assign(__assign({}, parentContext), { client: client || parentContext.client });\n    }, [parentContext, client]);\n    invariant(context.client, 47);\n    return (React.createElement(ApolloContext.Provider, { value: context }, children));\n};\n//# sourceMappingURL=ApolloProvider.js.map","// A version of Array.isArray that works better with readonly arrays.\nexport var isArray = Array.isArray;\nexport function isNonEmptyArray(value) {\n    return Array.isArray(value) && value.length > 0;\n}\n//# sourceMappingURL=arrays.js.map","import { AutoCleanedStrongCache, cacheSizes, } from \"../../utilities/caching/index.js\";\nimport { registerGlobalCache } from \"../caching/getMemoryInternals.js\";\n/**\n * Like JSON.stringify, but with object keys always sorted in the same order.\n *\n * To achieve performant sorting, this function uses a Map from JSON-serialized\n * arrays of keys (in any order) to sorted arrays of the same keys, with a\n * single sorted array reference shared by all permutations of the keys.\n *\n * As a drawback, this function will add a little bit more memory for every\n * object encountered that has different (more, less, a different order of) keys\n * than in the past.\n *\n * In a typical application, this extra memory usage should not play a\n * significant role, as `canonicalStringify` will be called for only a limited\n * number of object shapes, and the cache will not grow beyond a certain point.\n * But in some edge cases, this could be a problem, so we provide\n * canonicalStringify.reset() as a way of clearing the cache.\n * */\nexport var canonicalStringify = Object.assign(function canonicalStringify(value) {\n    return JSON.stringify(value, stableObjectReplacer);\n}, {\n    reset: function () {\n        // Clearing the sortingMap will reclaim all cached memory, without\n        // affecting the logical results of canonicalStringify, but potentially\n        // sacrificing performance until the cache is refilled.\n        sortingMap = new AutoCleanedStrongCache(cacheSizes.canonicalStringify || 1000 /* defaultCacheSizes.canonicalStringify */);\n    },\n});\nif (globalThis.__DEV__ !== false) {\n    registerGlobalCache(\"canonicalStringify\", function () { return sortingMap.size; });\n}\n// Values are JSON-serialized arrays of object keys (in any order), and values\n// are sorted arrays of the same keys.\nvar sortingMap;\ncanonicalStringify.reset();\n// The JSON.stringify function takes an optional second argument called a\n// replacer function. This function is called for each key-value pair in the\n// object being stringified, and its return value is used instead of the\n// original value. If the replacer function returns a new value, that value is\n// stringified as JSON instead of the original value of the property.\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#the_replacer_parameter\nfunction stableObjectReplacer(key, value) {\n    if (value && typeof value === \"object\") {\n        var proto = Object.getPrototypeOf(value);\n        // We don't want to mess with objects that are not \"plain\" objects, which\n        // means their prototype is either Object.prototype or null. This check also\n        // prevents needlessly rearranging the indices of arrays.\n        if (proto === Object.prototype || proto === null) {\n            var keys = Object.keys(value);\n            // If keys is already sorted, let JSON.stringify serialize the original\n            // value instead of creating a new object with keys in the same order.\n            if (keys.every(everyKeyInOrder))\n                return value;\n            var unsortedKey = JSON.stringify(keys);\n            var sortedKeys = sortingMap.get(unsortedKey);\n            if (!sortedKeys) {\n                keys.sort();\n                var sortedKey = JSON.stringify(keys);\n                // Checking for sortedKey in the sortingMap allows us to share the same\n                // sorted array reference for all permutations of the same set of keys.\n                sortedKeys = sortingMap.get(sortedKey) || keys;\n                sortingMap.set(unsortedKey, sortedKeys);\n                sortingMap.set(sortedKey, sortedKeys);\n            }\n            var sortedObject_1 = Object.create(proto);\n            // Reassigning the keys in sorted order will cause JSON.stringify to\n            // serialize them in sorted order.\n            sortedKeys.forEach(function (key) {\n                sortedObject_1[key] = value[key];\n            });\n            return sortedObject_1;\n        }\n    }\n    return value;\n}\n// Since everything that happens in stableObjectReplacer benefits from being as\n// efficient as possible, we use a static function as the callback for\n// keys.every in order to test if the provided keys are already sorted without\n// allocating extra memory for a callback.\nfunction everyKeyInOrder(key, i, keys) {\n    return i === 0 || keys[i - 1] <= key;\n}\n//# sourceMappingURL=canonicalStringify.js.map","var toString = Object.prototype.toString;\n/**\n * Deeply clones a value to create a new instance.\n */\nexport function cloneDeep(value) {\n    return cloneDeepHelper(value);\n}\nfunction cloneDeepHelper(val, seen) {\n    switch (toString.call(val)) {\n        case \"[object Array]\": {\n            seen = seen || new Map();\n            if (seen.has(val))\n                return seen.get(val);\n            var copy_1 = val.slice(0);\n            seen.set(val, copy_1);\n            copy_1.forEach(function (child, i) {\n                copy_1[i] = cloneDeepHelper(child, seen);\n            });\n            return copy_1;\n        }\n        case \"[object Object]\": {\n            seen = seen || new Map();\n            if (seen.has(val))\n                return seen.get(val);\n            // High fidelity polyfills of Object.create and Object.getPrototypeOf are\n            // possible in all JS environments, so we will assume they exist/work.\n            var copy_2 = Object.create(Object.getPrototypeOf(val));\n            seen.set(val, copy_2);\n            Object.keys(val).forEach(function (key) {\n                copy_2[key] = cloneDeepHelper(val[key], seen);\n            });\n            return copy_2;\n        }\n        default:\n            return val;\n    }\n}\n//# sourceMappingURL=cloneDeep.js.map","import { isNonNullObject } from \"./objects.js\";\nimport { isNonEmptyArray } from \"./arrays.js\";\nimport { DeepMerger } from \"./mergeDeep.js\";\nexport function isExecutionPatchIncrementalResult(value) {\n    return \"incremental\" in value;\n}\nexport function isExecutionPatchInitialResult(value) {\n    return \"hasNext\" in value && \"data\" in value;\n}\nexport function isExecutionPatchResult(value) {\n    return (isExecutionPatchIncrementalResult(value) ||\n        isExecutionPatchInitialResult(value));\n}\n// This function detects an Apollo payload result before it is transformed\n// into a FetchResult via HttpLink; it cannot detect an ApolloPayloadResult\n// once it leaves the link chain.\nexport function isApolloPayloadResult(value) {\n    return isNonNullObject(value) && \"payload\" in value;\n}\nexport function mergeIncrementalData(prevResult, result) {\n    var mergedData = prevResult;\n    var merger = new DeepMerger();\n    if (isExecutionPatchIncrementalResult(result) &&\n        isNonEmptyArray(result.incremental)) {\n        result.incremental.forEach(function (_a) {\n            var data = _a.data, path = _a.path;\n            for (var i = path.length - 1; i >= 0; --i) {\n                var key = path[i];\n                var isNumericKey = !isNaN(+key);\n                var parent_1 = isNumericKey ? [] : {};\n                parent_1[key] = data;\n                data = parent_1;\n            }\n            mergedData = merger.merge(mergedData, data);\n        });\n    }\n    return mergedData;\n}\n//# sourceMappingURL=incrementalResult.js.map","import { isNonNullObject } from \"./objects.js\";\nfunction deepFreeze(value) {\n    var workSet = new Set([value]);\n    workSet.forEach(function (obj) {\n        if (isNonNullObject(obj) && shallowFreeze(obj) === obj) {\n            Object.getOwnPropertyNames(obj).forEach(function (name) {\n                if (isNonNullObject(obj[name]))\n                    workSet.add(obj[name]);\n            });\n        }\n    });\n    return value;\n}\nfunction shallowFreeze(obj) {\n    if (globalThis.__DEV__ !== false && !Object.isFrozen(obj)) {\n        try {\n            Object.freeze(obj);\n        }\n        catch (e) {\n            // Some types like Uint8Array and Node.js's Buffer cannot be frozen, but\n            // they all throw a TypeError when you try, so we re-throw any exceptions\n            // that are not TypeErrors, since that would be unexpected.\n            if (e instanceof TypeError)\n                return null;\n            throw e;\n        }\n    }\n    return obj;\n}\nexport function maybeDeepFreeze(obj) {\n    if (globalThis.__DEV__ !== false) {\n        deepFreeze(obj);\n    }\n    return obj;\n}\n//# sourceMappingURL=maybeDeepFreeze.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { isNonNullObject } from \"./objects.js\";\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nexport function mergeDeep() {\n    var sources = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sources[_i] = arguments[_i];\n    }\n    return mergeDeepArray(sources);\n}\n// In almost any situation where you could succeed in getting the\n// TypeScript compiler to infer a tuple type for the sources array, you\n// could just use mergeDeep instead of mergeDeepArray, so instead of\n// trying to convert T[] to an intersection type we just infer the array\n// element type, which works perfectly when the sources array has a\n// consistent element type.\nexport function mergeDeepArray(sources) {\n    var target = sources[0] || {};\n    var count = sources.length;\n    if (count > 1) {\n        var merger = new DeepMerger();\n        for (var i = 1; i < count; ++i) {\n            target = merger.merge(target, sources[i]);\n        }\n    }\n    return target;\n}\nvar defaultReconciler = function (target, source, property) {\n    return this.merge(target[property], source[property]);\n};\nvar DeepMerger = /** @class */ (function () {\n    function DeepMerger(reconciler) {\n        if (reconciler === void 0) { reconciler = defaultReconciler; }\n        this.reconciler = reconciler;\n        this.isObject = isNonNullObject;\n        this.pastCopies = new Set();\n    }\n    DeepMerger.prototype.merge = function (target, source) {\n        var _this = this;\n        var context = [];\n        for (var _i = 2; _i < arguments.length; _i++) {\n            context[_i - 2] = arguments[_i];\n        }\n        if (isNonNullObject(source) && isNonNullObject(target)) {\n            Object.keys(source).forEach(function (sourceKey) {\n                if (hasOwnProperty.call(target, sourceKey)) {\n                    var targetValue = target[sourceKey];\n                    if (source[sourceKey] !== targetValue) {\n                        var result = _this.reconciler.apply(_this, __spreadArray([target,\n                            source,\n                            sourceKey], context, false));\n                        // A well-implemented reconciler may return targetValue to indicate\n                        // the merge changed nothing about the structure of the target.\n                        if (result !== targetValue) {\n                            target = _this.shallowCopyForMerge(target);\n                            target[sourceKey] = result;\n                        }\n                    }\n                }\n                else {\n                    // If there is no collision, the target can safely share memory with\n                    // the source, and the recursion can terminate here.\n                    target = _this.shallowCopyForMerge(target);\n                    target[sourceKey] = source[sourceKey];\n                }\n            });\n            return target;\n        }\n        // If source (or target) is not an object, let source replace target.\n        return source;\n    };\n    DeepMerger.prototype.shallowCopyForMerge = function (value) {\n        if (isNonNullObject(value)) {\n            if (!this.pastCopies.has(value)) {\n                if (Array.isArray(value)) {\n                    value = value.slice(0);\n                }\n                else {\n                    value = __assign({ __proto__: Object.getPrototypeOf(value) }, value);\n                }\n                this.pastCopies.add(value);\n            }\n        }\n        return value;\n    };\n    return DeepMerger;\n}());\nexport { DeepMerger };\n//# sourceMappingURL=mergeDeep.js.map","import { Trie } from \"@wry/trie\";\nimport { canUseWeakMap, canUseWeakSet } from \"../common/canUse.js\";\nimport { checkDocument } from \"./getFromAST.js\";\nimport { invariant } from \"../globals/index.js\";\nimport { WeakCache } from \"@wry/caches\";\nimport { wrap } from \"optimism\";\nimport { cacheSizes } from \"../caching/index.js\";\nfunction identity(document) {\n    return document;\n}\nvar DocumentTransform = /** @class */ (function () {\n    function DocumentTransform(transform, options) {\n        if (options === void 0) { options = Object.create(null); }\n        this.resultCache = canUseWeakSet ? new WeakSet() : new Set();\n        this.transform = transform;\n        if (options.getCacheKey) {\n            // Override default `getCacheKey` function, which returns [document].\n            this.getCacheKey = options.getCacheKey;\n        }\n        this.cached = options.cache !== false;\n        this.resetCache();\n    }\n    // This default implementation of getCacheKey can be overridden by providing\n    // options.getCacheKey to the DocumentTransform constructor. In general, a\n    // getCacheKey function may either return an array of keys (often including\n    // the document) to be used as a cache key, or undefined to indicate the\n    // transform for this document should not be cached.\n    DocumentTransform.prototype.getCacheKey = function (document) {\n        return [document];\n    };\n    DocumentTransform.identity = function () {\n        // No need to cache this transform since it just returns the document\n        // unchanged. This should save a bit of memory that would otherwise be\n        // needed to populate the `documentCache` of this transform.\n        return new DocumentTransform(identity, { cache: false });\n    };\n    DocumentTransform.split = function (predicate, left, right) {\n        if (right === void 0) { right = DocumentTransform.identity(); }\n        return Object.assign(new DocumentTransform(function (document) {\n            var documentTransform = predicate(document) ? left : right;\n            return documentTransform.transformDocument(document);\n        }, \n        // Reasonably assume both `left` and `right` transforms handle their own caching\n        { cache: false }), { left: left, right: right });\n    };\n    /**\n     * Resets the internal cache of this transform, if it has one.\n     */\n    DocumentTransform.prototype.resetCache = function () {\n        var _this = this;\n        if (this.cached) {\n            var stableCacheKeys_1 = new Trie(canUseWeakMap);\n            this.performWork = wrap(DocumentTransform.prototype.performWork.bind(this), {\n                makeCacheKey: function (document) {\n                    var cacheKeys = _this.getCacheKey(document);\n                    if (cacheKeys) {\n                        invariant(Array.isArray(cacheKeys), 69);\n                        return stableCacheKeys_1.lookupArray(cacheKeys);\n                    }\n                },\n                max: cacheSizes[\"documentTransform.cache\"],\n                cache: (WeakCache),\n            });\n        }\n    };\n    DocumentTransform.prototype.performWork = function (document) {\n        checkDocument(document);\n        return this.transform(document);\n    };\n    DocumentTransform.prototype.transformDocument = function (document) {\n        // If a user passes an already transformed result back to this function,\n        // immediately return it.\n        if (this.resultCache.has(document)) {\n            return document;\n        }\n        var transformedDocument = this.performWork(document);\n        this.resultCache.add(transformedDocument);\n        return transformedDocument;\n    };\n    DocumentTransform.prototype.concat = function (otherTransform) {\n        var _this = this;\n        return Object.assign(new DocumentTransform(function (document) {\n            return otherTransform.transformDocument(_this.transformDocument(document));\n        }, \n        // Reasonably assume both transforms handle their own caching\n        { cache: false }), {\n            left: this,\n            right: otherTransform,\n        });\n    };\n    return DocumentTransform;\n}());\nexport { DocumentTransform };\n//# sourceMappingURL=DocumentTransform.js.map","import { invariant } from \"../globals/index.js\";\nimport { visit, BREAK } from \"graphql\";\nexport function shouldInclude(_a, variables) {\n    var directives = _a.directives;\n    if (!directives || !directives.length) {\n        return true;\n    }\n    return getInclusionDirectives(directives).every(function (_a) {\n        var directive = _a.directive, ifArgument = _a.ifArgument;\n        var evaledValue = false;\n        if (ifArgument.value.kind === \"Variable\") {\n            evaledValue =\n                variables && variables[ifArgument.value.name.value];\n            invariant(evaledValue !== void 0, 70, directive.name.value);\n        }\n        else {\n            evaledValue = ifArgument.value.value;\n        }\n        return directive.name.value === \"skip\" ? !evaledValue : evaledValue;\n    });\n}\nexport function getDirectiveNames(root) {\n    var names = [];\n    visit(root, {\n        Directive: function (node) {\n            names.push(node.name.value);\n        },\n    });\n    return names;\n}\nexport var hasAnyDirectives = function (names, root) {\n    return hasDirectives(names, root, false);\n};\nexport var hasAllDirectives = function (names, root) {\n    return hasDirectives(names, root, true);\n};\nexport function hasDirectives(names, root, all) {\n    var nameSet = new Set(names);\n    var uniqueCount = nameSet.size;\n    visit(root, {\n        Directive: function (node) {\n            if (nameSet.delete(node.name.value) && (!all || !nameSet.size)) {\n                return BREAK;\n            }\n        },\n    });\n    // If we found all the names, nameSet will be empty. If we only care about\n    // finding some of them, the < condition is sufficient.\n    return all ? !nameSet.size : nameSet.size < uniqueCount;\n}\nexport function hasClientExports(document) {\n    return document && hasDirectives([\"client\", \"export\"], document, true);\n}\nfunction isInclusionDirective(_a) {\n    var value = _a.name.value;\n    return value === \"skip\" || value === \"include\";\n}\nexport function getInclusionDirectives(directives) {\n    var result = [];\n    if (directives && directives.length) {\n        directives.forEach(function (directive) {\n            if (!isInclusionDirective(directive))\n                return;\n            var directiveArguments = directive.arguments;\n            var directiveName = directive.name.value;\n            invariant(directiveArguments && directiveArguments.length === 1, 71, directiveName);\n            var ifArgument = directiveArguments[0];\n            invariant(ifArgument.name && ifArgument.name.value === \"if\", 72, directiveName);\n            var ifValue = ifArgument.value;\n            // means it has to be a variable value if this is a valid @skip or @include directive\n            invariant(ifValue &&\n                (ifValue.kind === \"Variable\" || ifValue.kind === \"BooleanValue\"), 73, directiveName);\n            result.push({ directive: directive, ifArgument: ifArgument });\n        });\n    }\n    return result;\n}\n//# sourceMappingURL=directives.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { invariant, newInvariantError } from \"../globals/index.js\";\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(document, fragmentName) {\n    var actualFragmentName = fragmentName;\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    var fragments = [];\n    document.definitions.forEach(function (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 newInvariantError(\n                74,\n                definition.operation,\n                definition.name ? \" named '\".concat(definition.name.value, \"'\") : \"\"\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    // 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(fragments.length === 1, 75, fragments.length);\n        actualFragmentName = fragments[0].name.value;\n    }\n    // Generate a query document with an operation that simply spreads the\n    // fragment inside of it.\n    var query = __assign(__assign({}, document), { definitions: __spreadArray([\n            {\n                kind: \"OperationDefinition\",\n                // OperationTypeNode is an enum\n                operation: \"query\",\n                selectionSet: {\n                    kind: \"SelectionSet\",\n                    selections: [\n                        {\n                            kind: \"FragmentSpread\",\n                            name: {\n                                kind: \"Name\",\n                                value: actualFragmentName,\n                            },\n                        },\n                    ],\n                },\n            }\n        ], document.definitions, true) });\n    return query;\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(fragments) {\n    if (fragments === void 0) { fragments = []; }\n    var symTable = {};\n    fragments.forEach(function (fragment) {\n        symTable[fragment.name.value] = fragment;\n    });\n    return symTable;\n}\nexport function getFragmentFromSelection(selection, fragmentMap) {\n    switch (selection.kind) {\n        case \"InlineFragment\":\n            return selection;\n        case \"FragmentSpread\": {\n            var fragmentName = selection.name.value;\n            if (typeof fragmentMap === \"function\") {\n                return fragmentMap(fragmentName);\n            }\n            var fragment = fragmentMap && fragmentMap[fragmentName];\n            invariant(fragment, 76, fragmentName);\n            return fragment || null;\n        }\n        default:\n            return null;\n    }\n}\n//# sourceMappingURL=fragments.js.map","import { invariant, newInvariantError } from \"../globals/index.js\";\nimport { valueToObjectRepresentation } from \"./storeUtils.js\";\n// Checks the document for errors and throws an exception if there is an error.\nexport function checkDocument(doc) {\n    invariant(doc && doc.kind === \"Document\", 77);\n    var operations = doc.definitions\n        .filter(function (d) { return d.kind !== \"FragmentDefinition\"; })\n        .map(function (definition) {\n        if (definition.kind !== \"OperationDefinition\") {\n            throw newInvariantError(78, definition.kind);\n        }\n        return definition;\n    });\n    invariant(operations.length <= 1, 79, operations.length);\n    return doc;\n}\nexport function getOperationDefinition(doc) {\n    checkDocument(doc);\n    return doc.definitions.filter(function (definition) {\n        return definition.kind === \"OperationDefinition\";\n    })[0];\n}\nexport function getOperationName(doc) {\n    return (doc.definitions\n        .filter(function (definition) {\n        return definition.kind === \"OperationDefinition\" && !!definition.name;\n    })\n        .map(function (x) { return x.name.value; })[0] || null);\n}\n// Returns the FragmentDefinitions from a particular document as an array\nexport function getFragmentDefinitions(doc) {\n    return doc.definitions.filter(function (definition) {\n        return definition.kind === \"FragmentDefinition\";\n    });\n}\nexport function getQueryDefinition(doc) {\n    var queryDef = getOperationDefinition(doc);\n    invariant(queryDef && queryDef.operation === \"query\", 80);\n    return queryDef;\n}\nexport function getFragmentDefinition(doc) {\n    invariant(doc.kind === \"Document\", 81);\n    invariant(doc.definitions.length <= 1, 82);\n    var fragmentDef = doc.definitions[0];\n    invariant(fragmentDef.kind === \"FragmentDefinition\", 83);\n    return fragmentDef;\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(queryDoc) {\n    checkDocument(queryDoc);\n    var fragmentDefinition;\n    for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {\n        var definition = _a[_i];\n        if (definition.kind === \"OperationDefinition\") {\n            var operation = definition.operation;\n            if (operation === \"query\" ||\n                operation === \"mutation\" ||\n                operation === \"subscription\") {\n                return definition;\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;\n        }\n    }\n    if (fragmentDefinition) {\n        return fragmentDefinition;\n    }\n    throw newInvariantError(84);\n}\nexport function getDefaultValues(definition) {\n    var defaultValues = Object.create(null);\n    var defs = definition && definition.variableDefinitions;\n    if (defs && defs.length) {\n        defs.forEach(function (def) {\n            if (def.defaultValue) {\n                valueToObjectRepresentation(defaultValues, def.variable.name, def.defaultValue);\n            }\n        });\n    }\n    return defaultValues;\n}\n//# sourceMappingURL=getFromAST.js.map","/**\n * Prints a string as a GraphQL StringValue literal. Replaces control characters\n * and excluded characters (\" U+0022 and \\\\ U+005C) with escape sequences.\n */\nexport function printString(str) {\n  return `\"${str.replace(escapedRegExp, escapedReplacer)}\"`;\n} // eslint-disable-next-line no-control-regex\n\nconst escapedRegExp = /[\\x00-\\x1f\\x22\\x5c\\x7f-\\x9f]/g;\n\nfunction escapedReplacer(str) {\n  return escapeSequences[str.charCodeAt(0)];\n} // prettier-ignore\n\nconst escapeSequences = [\n  '\\\\u0000',\n  '\\\\u0001',\n  '\\\\u0002',\n  '\\\\u0003',\n  '\\\\u0004',\n  '\\\\u0005',\n  '\\\\u0006',\n  '\\\\u0007',\n  '\\\\b',\n  '\\\\t',\n  '\\\\n',\n  '\\\\u000B',\n  '\\\\f',\n  '\\\\r',\n  '\\\\u000E',\n  '\\\\u000F',\n  '\\\\u0010',\n  '\\\\u0011',\n  '\\\\u0012',\n  '\\\\u0013',\n  '\\\\u0014',\n  '\\\\u0015',\n  '\\\\u0016',\n  '\\\\u0017',\n  '\\\\u0018',\n  '\\\\u0019',\n  '\\\\u001A',\n  '\\\\u001B',\n  '\\\\u001C',\n  '\\\\u001D',\n  '\\\\u001E',\n  '\\\\u001F',\n  '',\n  '',\n  '\\\\\"',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '', // 2F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '', // 3F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '', // 4F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '\\\\\\\\',\n  '',\n  '',\n  '', // 5F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '', // 6F\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '',\n  '\\\\u007F',\n  '\\\\u0080',\n  '\\\\u0081',\n  '\\\\u0082',\n  '\\\\u0083',\n  '\\\\u0084',\n  '\\\\u0085',\n  '\\\\u0086',\n  '\\\\u0087',\n  '\\\\u0088',\n  '\\\\u0089',\n  '\\\\u008A',\n  '\\\\u008B',\n  '\\\\u008C',\n  '\\\\u008D',\n  '\\\\u008E',\n  '\\\\u008F',\n  '\\\\u0090',\n  '\\\\u0091',\n  '\\\\u0092',\n  '\\\\u0093',\n  '\\\\u0094',\n  '\\\\u0095',\n  '\\\\u0096',\n  '\\\\u0097',\n  '\\\\u0098',\n  '\\\\u0099',\n  '\\\\u009A',\n  '\\\\u009B',\n  '\\\\u009C',\n  '\\\\u009D',\n  '\\\\u009E',\n  '\\\\u009F',\n];\n","import { printBlockString } from './blockString.mjs';\nimport { printString } from './printString.mjs';\nimport { visit } from './visitor.mjs';\n/**\n * Converts an AST into a string, using one set of reasonable\n * formatting rules.\n */\n\nexport function print(ast) {\n  return visit(ast, printDocASTReducer);\n}\nconst MAX_LINE_LENGTH = 80;\nconst printDocASTReducer = {\n  Name: {\n    leave: (node) => node.value,\n  },\n  Variable: {\n    leave: (node) => '$' + node.name,\n  },\n  // Document\n  Document: {\n    leave: (node) => join(node.definitions, '\\n\\n'),\n  },\n  OperationDefinition: {\n    leave(node) {\n      const varDefs = wrap('(', join(node.variableDefinitions, ', '), ')');\n      const prefix = join(\n        [\n          node.operation,\n          join([node.name, varDefs]),\n          join(node.directives, ' '),\n        ],\n        ' ',\n      ); // Anonymous queries with no directives or variable definitions can use\n      // the query short form.\n\n      return (prefix === 'query' ? '' : prefix + ' ') + node.selectionSet;\n    },\n  },\n  VariableDefinition: {\n    leave: ({ variable, type, defaultValue, directives }) =>\n      variable +\n      ': ' +\n      type +\n      wrap(' = ', defaultValue) +\n      wrap(' ', join(directives, ' ')),\n  },\n  SelectionSet: {\n    leave: ({ selections }) => block(selections),\n  },\n  Field: {\n    leave({ alias, name, arguments: args, directives, selectionSet }) {\n      const prefix = wrap('', alias, ': ') + name;\n      let argsLine = prefix + wrap('(', join(args, ', '), ')');\n\n      if (argsLine.length > MAX_LINE_LENGTH) {\n        argsLine = prefix + wrap('(\\n', indent(join(args, '\\n')), '\\n)');\n      }\n\n      return join([argsLine, join(directives, ' '), selectionSet], ' ');\n    },\n  },\n  Argument: {\n    leave: ({ name, value }) => name + ': ' + value,\n  },\n  // Fragments\n  FragmentSpread: {\n    leave: ({ name, directives }) =>\n      '...' + name + wrap(' ', join(directives, ' ')),\n  },\n  InlineFragment: {\n    leave: ({ typeCondition, directives, selectionSet }) =>\n      join(\n        [\n          '...',\n          wrap('on ', typeCondition),\n          join(directives, ' '),\n          selectionSet,\n        ],\n        ' ',\n      ),\n  },\n  FragmentDefinition: {\n    leave: (\n      { name, typeCondition, variableDefinitions, directives, selectionSet }, // Note: fragment variable definitions are experimental and may be changed\n    ) =>\n      // or removed in the future.\n      `fragment ${name}${wrap('(', join(variableDefinitions, ', '), ')')} ` +\n      `on ${typeCondition} ${wrap('', join(directives, ' '), ' ')}` +\n      selectionSet,\n  },\n  // Value\n  IntValue: {\n    leave: ({ value }) => value,\n  },\n  FloatValue: {\n    leave: ({ value }) => value,\n  },\n  StringValue: {\n    leave: ({ value, block: isBlockString }) =>\n      isBlockString ? printBlockString(value) : printString(value),\n  },\n  BooleanValue: {\n    leave: ({ value }) => (value ? 'true' : 'false'),\n  },\n  NullValue: {\n    leave: () => 'null',\n  },\n  EnumValue: {\n    leave: ({ value }) => value,\n  },\n  ListValue: {\n    leave: ({ values }) => '[' + join(values, ', ') + ']',\n  },\n  ObjectValue: {\n    leave: ({ fields }) => '{' + join(fields, ', ') + '}',\n  },\n  ObjectField: {\n    leave: ({ name, value }) => name + ': ' + value,\n  },\n  // Directive\n  Directive: {\n    leave: ({ name, arguments: args }) =>\n      '@' + name + wrap('(', join(args, ', '), ')'),\n  },\n  // Type\n  NamedType: {\n    leave: ({ name }) => name,\n  },\n  ListType: {\n    leave: ({ type }) => '[' + type + ']',\n  },\n  NonNullType: {\n    leave: ({ type }) => type + '!',\n  },\n  // Type System Definitions\n  SchemaDefinition: {\n    leave: ({ description, directives, operationTypes }) =>\n      wrap('', description, '\\n') +\n      join(['schema', join(directives, ' '), block(operationTypes)], ' '),\n  },\n  OperationTypeDefinition: {\n    leave: ({ operation, type }) => operation + ': ' + type,\n  },\n  ScalarTypeDefinition: {\n    leave: ({ description, name, directives }) =>\n      wrap('', description, '\\n') +\n      join(['scalar', name, join(directives, ' ')], ' '),\n  },\n  ObjectTypeDefinition: {\n    leave: ({ description, name, interfaces, directives, fields }) =>\n      wrap('', description, '\\n') +\n      join(\n        [\n          'type',\n          name,\n          wrap('implements ', join(interfaces, ' & ')),\n          join(directives, ' '),\n          block(fields),\n        ],\n        ' ',\n      ),\n  },\n  FieldDefinition: {\n    leave: ({ description, name, arguments: args, type, directives }) =>\n      wrap('', description, '\\n') +\n      name +\n      (hasMultilineItems(args)\n        ? wrap('(\\n', indent(join(args, '\\n')), '\\n)')\n        : wrap('(', join(args, ', '), ')')) +\n      ': ' +\n      type +\n      wrap(' ', join(directives, ' ')),\n  },\n  InputValueDefinition: {\n    leave: ({ description, name, type, defaultValue, directives }) =>\n      wrap('', description, '\\n') +\n      join(\n        [name + ': ' + type, wrap('= ', defaultValue), join(directives, ' ')],\n        ' ',\n      ),\n  },\n  InterfaceTypeDefinition: {\n    leave: ({ description, name, interfaces, directives, fields }) =>\n      wrap('', description, '\\n') +\n      join(\n        [\n          'interface',\n          name,\n          wrap('implements ', join(interfaces, ' & ')),\n          join(directives, ' '),\n          block(fields),\n        ],\n        ' ',\n      ),\n  },\n  UnionTypeDefinition: {\n    leave: ({ description, name, directives, types }) =>\n      wrap('', description, '\\n') +\n      join(\n        ['union', name, join(directives, ' '), wrap('= ', join(types, ' | '))],\n        ' ',\n      ),\n  },\n  EnumTypeDefinition: {\n    leave: ({ description, name, directives, values }) =>\n      wrap('', description, '\\n') +\n      join(['enum', name, join(directives, ' '), block(values)], ' '),\n  },\n  EnumValueDefinition: {\n    leave: ({ description, name, directives }) =>\n      wrap('', description, '\\n') + join([name, join(directives, ' ')], ' '),\n  },\n  InputObjectTypeDefinition: {\n    leave: ({ description, name, directives, fields }) =>\n      wrap('', description, '\\n') +\n      join(['input', name, join(directives, ' '), block(fields)], ' '),\n  },\n  DirectiveDefinition: {\n    leave: ({ description, name, arguments: args, repeatable, locations }) =>\n      wrap('', description, '\\n') +\n      'directive @' +\n      name +\n      (hasMultilineItems(args)\n        ? wrap('(\\n', indent(join(args, '\\n')), '\\n)')\n        : wrap('(', join(args, ', '), ')')) +\n      (repeatable ? ' repeatable' : '') +\n      ' on ' +\n      join(locations, ' | '),\n  },\n  SchemaExtension: {\n    leave: ({ directives, operationTypes }) =>\n      join(\n        ['extend schema', join(directives, ' '), block(operationTypes)],\n        ' ',\n      ),\n  },\n  ScalarTypeExtension: {\n    leave: ({ name, directives }) =>\n      join(['extend scalar', name, join(directives, ' ')], ' '),\n  },\n  ObjectTypeExtension: {\n    leave: ({ name, interfaces, directives, fields }) =>\n      join(\n        [\n          'extend type',\n          name,\n          wrap('implements ', join(interfaces, ' & ')),\n          join(directives, ' '),\n          block(fields),\n        ],\n        ' ',\n      ),\n  },\n  InterfaceTypeExtension: {\n    leave: ({ name, interfaces, directives, fields }) =>\n      join(\n        [\n          'extend interface',\n          name,\n          wrap('implements ', join(interfaces, ' & ')),\n          join(directives, ' '),\n          block(fields),\n        ],\n        ' ',\n      ),\n  },\n  UnionTypeExtension: {\n    leave: ({ name, directives, types }) =>\n      join(\n        [\n          'extend union',\n          name,\n          join(directives, ' '),\n          wrap('= ', join(types, ' | ')),\n        ],\n        ' ',\n      ),\n  },\n  EnumTypeExtension: {\n    leave: ({ name, directives, values }) =>\n      join(['extend enum', name, join(directives, ' '), block(values)], ' '),\n  },\n  InputObjectTypeExtension: {\n    leave: ({ name, directives, fields }) =>\n      join(['extend input', name, join(directives, ' '), block(fields)], ' '),\n  },\n};\n/**\n * Given maybeArray, print an empty string if it is null or empty, otherwise\n * print all items together separated by separator if provided\n */\n\nfunction join(maybeArray, separator = '') {\n  var _maybeArray$filter$jo;\n\n  return (_maybeArray$filter$jo =\n    maybeArray === null || maybeArray === void 0\n      ? void 0\n      : maybeArray.filter((x) => x).join(separator)) !== null &&\n    _maybeArray$filter$jo !== void 0\n    ? _maybeArray$filter$jo\n    : '';\n}\n/**\n * Given array, print each item on its own line, wrapped in an indented `{ }` block.\n */\n\nfunction block(array) {\n  return wrap('{\\n', indent(join(array, '\\n')), '\\n}');\n}\n/**\n * If maybeString is not null or empty, then wrap with start and end, otherwise print an empty string.\n */\n\nfunction wrap(start, maybeString, end = '') {\n  return maybeString != null && maybeString !== ''\n    ? start + maybeString + end\n    : '';\n}\n\nfunction indent(str) {\n  return wrap('  ', str.replace(/\\n/g, '\\n  '));\n}\n\nfunction hasMultilineItems(maybeArray) {\n  var _maybeArray$some;\n\n  // FIXME: https://github.com/graphql/graphql-js/issues/2203\n\n  /* c8 ignore next */\n  return (_maybeArray$some =\n    maybeArray === null || maybeArray === void 0\n      ? void 0\n      : maybeArray.some((str) => str.includes('\\n'))) !== null &&\n    _maybeArray$some !== void 0\n    ? _maybeArray$some\n    : false;\n}\n","import { print as origPrint } from \"graphql\";\nimport { AutoCleanedWeakCache, cacheSizes, } from \"../caching/index.js\";\nimport { registerGlobalCache } from \"../caching/getMemoryInternals.js\";\nvar printCache;\nexport var print = Object.assign(function (ast) {\n    var result = printCache.get(ast);\n    if (!result) {\n        result = origPrint(ast);\n        printCache.set(ast, result);\n    }\n    return result;\n}, {\n    reset: function () {\n        printCache = new AutoCleanedWeakCache(cacheSizes.print || 2000 /* defaultCacheSizes.print */);\n    },\n});\nprint.reset();\nif (globalThis.__DEV__ !== false) {\n    registerGlobalCache(\"print\", function () { return (printCache ? printCache.size : 0); });\n}\n//# sourceMappingURL=print.js.map","import { newInvariantError } from \"../globals/index.js\";\nimport { isNonNullObject } from \"../common/objects.js\";\nimport { getFragmentFromSelection } from \"./fragments.js\";\nimport { canonicalStringify } from \"../common/canonicalStringify.js\";\nexport function makeReference(id) {\n    return { __ref: String(id) };\n}\nexport function isReference(obj) {\n    return Boolean(obj && typeof obj === \"object\" && typeof obj.__ref === \"string\");\n}\nexport function isDocumentNode(value) {\n    return (isNonNullObject(value) &&\n        value.kind === \"Document\" &&\n        Array.isArray(value.definitions));\n}\nfunction isStringValue(value) {\n    return value.kind === \"StringValue\";\n}\nfunction isBooleanValue(value) {\n    return value.kind === \"BooleanValue\";\n}\nfunction isIntValue(value) {\n    return value.kind === \"IntValue\";\n}\nfunction isFloatValue(value) {\n    return value.kind === \"FloatValue\";\n}\nfunction isVariable(value) {\n    return value.kind === \"Variable\";\n}\nfunction isObjectValue(value) {\n    return value.kind === \"ObjectValue\";\n}\nfunction isListValue(value) {\n    return value.kind === \"ListValue\";\n}\nfunction isEnumValue(value) {\n    return value.kind === \"EnumValue\";\n}\nfunction isNullValue(value) {\n    return value.kind === \"NullValue\";\n}\nexport function valueToObjectRepresentation(argObj, name, value, variables) {\n    if (isIntValue(value) || isFloatValue(value)) {\n        argObj[name.value] = Number(value.value);\n    }\n    else if (isBooleanValue(value) || isStringValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isObjectValue(value)) {\n        var nestedArgObj_1 = {};\n        value.fields.map(function (obj) {\n            return valueToObjectRepresentation(nestedArgObj_1, obj.name, obj.value, variables);\n        });\n        argObj[name.value] = nestedArgObj_1;\n    }\n    else if (isVariable(value)) {\n        var variableValue = (variables || {})[value.name.value];\n        argObj[name.value] = variableValue;\n    }\n    else if (isListValue(value)) {\n        argObj[name.value] = value.values.map(function (listValue) {\n            var nestedArgArrayObj = {};\n            valueToObjectRepresentation(nestedArgArrayObj, name, listValue, variables);\n            return nestedArgArrayObj[name.value];\n        });\n    }\n    else if (isEnumValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isNullValue(value)) {\n        argObj[name.value] = null;\n    }\n    else {\n        throw newInvariantError(85, name.value, value.kind);\n    }\n}\nexport function storeKeyNameFromField(field, variables) {\n    var directivesObj = null;\n    if (field.directives) {\n        directivesObj = {};\n        field.directives.forEach(function (directive) {\n            directivesObj[directive.name.value] = {};\n            if (directive.arguments) {\n                directive.arguments.forEach(function (_a) {\n                    var name = _a.name, value = _a.value;\n                    return valueToObjectRepresentation(directivesObj[directive.name.value], name, value, variables);\n                });\n            }\n        });\n    }\n    var argObj = null;\n    if (field.arguments && field.arguments.length) {\n        argObj = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj, name, value, variables);\n        });\n    }\n    return getStoreKeyName(field.name.value, argObj, directivesObj);\n}\nvar KNOWN_DIRECTIVES = [\n    \"connection\",\n    \"include\",\n    \"skip\",\n    \"client\",\n    \"rest\",\n    \"export\",\n    \"nonreactive\",\n];\n// Default stable JSON.stringify implementation used by getStoreKeyName. Can be\n// updated/replaced with something better by calling\n// getStoreKeyName.setStringify(newStringifyFunction).\nvar storeKeyNameStringify = canonicalStringify;\nexport var getStoreKeyName = Object.assign(function (fieldName, args, directives) {\n    if (args &&\n        directives &&\n        directives[\"connection\"] &&\n        directives[\"connection\"][\"key\"]) {\n        if (directives[\"connection\"][\"filter\"] &&\n            directives[\"connection\"][\"filter\"].length > 0) {\n            var filterKeys = directives[\"connection\"][\"filter\"] ?\n                directives[\"connection\"][\"filter\"]\n                : [];\n            filterKeys.sort();\n            var filteredArgs_1 = {};\n            filterKeys.forEach(function (key) {\n                filteredArgs_1[key] = args[key];\n            });\n            return \"\".concat(directives[\"connection\"][\"key\"], \"(\").concat(storeKeyNameStringify(filteredArgs_1), \")\");\n        }\n        else {\n            return directives[\"connection\"][\"key\"];\n        }\n    }\n    var completeFieldName = fieldName;\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        var stringifiedArgs = storeKeyNameStringify(args);\n        completeFieldName += \"(\".concat(stringifiedArgs, \")\");\n    }\n    if (directives) {\n        Object.keys(directives).forEach(function (key) {\n            if (KNOWN_DIRECTIVES.indexOf(key) !== -1)\n                return;\n            if (directives[key] && Object.keys(directives[key]).length) {\n                completeFieldName += \"@\".concat(key, \"(\").concat(storeKeyNameStringify(directives[key]), \")\");\n            }\n            else {\n                completeFieldName += \"@\".concat(key);\n            }\n        });\n    }\n    return completeFieldName;\n}, {\n    setStringify: function (s) {\n        var previous = storeKeyNameStringify;\n        storeKeyNameStringify = s;\n        return previous;\n    },\n});\nexport function argumentsObjectFromField(field, variables) {\n    if (field.arguments && field.arguments.length) {\n        var argObj_1 = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj_1, name, value, variables);\n        });\n        return argObj_1;\n    }\n    return null;\n}\nexport function resultKeyNameFromField(field) {\n    return field.alias ? field.alias.value : field.name.value;\n}\nexport function getTypenameFromResult(result, selectionSet, fragmentMap) {\n    var fragments;\n    for (var _i = 0, _a = selectionSet.selections; _i < _a.length; _i++) {\n        var selection = _a[_i];\n        if (isField(selection)) {\n            if (selection.name.value === \"__typename\") {\n                return result[resultKeyNameFromField(selection)];\n            }\n        }\n        else if (fragments) {\n            fragments.push(selection);\n        }\n        else {\n            fragments = [selection];\n        }\n    }\n    if (typeof result.__typename === \"string\") {\n        return result.__typename;\n    }\n    if (fragments) {\n        for (var _b = 0, fragments_1 = fragments; _b < fragments_1.length; _b++) {\n            var selection = fragments_1[_b];\n            var typename = getTypenameFromResult(result, getFragmentFromSelection(selection, fragmentMap).selectionSet, fragmentMap);\n            if (typeof typename === \"string\") {\n                return typename;\n            }\n        }\n    }\n}\nexport function isField(selection) {\n    return selection.kind === \"Field\";\n}\nexport function isInlineFragment(selection) {\n    return selection.kind === \"InlineFragment\";\n}\n//# sourceMappingURL=storeUtils.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport { invariant } from \"../globals/index.js\";\nimport { visit, Kind } from \"graphql\";\nimport { checkDocument, getOperationDefinition, getFragmentDefinition, getFragmentDefinitions, getMainDefinition, } from \"./getFromAST.js\";\nimport { isField } from \"./storeUtils.js\";\nimport { createFragmentMap } from \"./fragments.js\";\nimport { isArray, isNonEmptyArray } from \"../common/arrays.js\";\nvar TYPENAME_FIELD = {\n    kind: Kind.FIELD,\n    name: {\n        kind: Kind.NAME,\n        value: \"__typename\",\n    },\n};\nfunction isEmpty(op, fragmentMap) {\n    return (!op ||\n        op.selectionSet.selections.every(function (selection) {\n            return selection.kind === Kind.FRAGMENT_SPREAD &&\n                isEmpty(fragmentMap[selection.name.value], fragmentMap);\n        }));\n}\nfunction nullIfDocIsEmpty(doc) {\n    return (isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc)))) ?\n        null\n        : doc;\n}\nfunction getDirectiveMatcher(configs) {\n    var names = new Map();\n    var tests = new Map();\n    configs.forEach(function (directive) {\n        if (directive) {\n            if (directive.name) {\n                names.set(directive.name, directive);\n            }\n            else if (directive.test) {\n                tests.set(directive.test, directive);\n            }\n        }\n    });\n    return function (directive) {\n        var config = names.get(directive.name.value);\n        if (!config && tests.size) {\n            tests.forEach(function (testConfig, test) {\n                if (test(directive)) {\n                    config = testConfig;\n                }\n            });\n        }\n        return config;\n    };\n}\nfunction makeInUseGetterFunction(defaultKey) {\n    var map = new Map();\n    return function inUseGetterFunction(key) {\n        if (key === void 0) { key = defaultKey; }\n        var inUse = map.get(key);\n        if (!inUse) {\n            map.set(key, (inUse = {\n                // Variable and fragment spread names used directly within this\n                // operation or fragment definition, as identified by key. These sets\n                // will be populated during the first traversal of the document in\n                // removeDirectivesFromDocument below.\n                variables: new Set(),\n                fragmentSpreads: new Set(),\n            }));\n        }\n        return inUse;\n    };\n}\nexport function removeDirectivesFromDocument(directives, doc) {\n    checkDocument(doc);\n    // Passing empty strings to makeInUseGetterFunction means we handle anonymous\n    // operations as if their names were \"\". Anonymous fragment definitions are\n    // not supposed to be possible, but the same default naming strategy seems\n    // appropriate for that case as well.\n    var getInUseByOperationName = makeInUseGetterFunction(\"\");\n    var getInUseByFragmentName = makeInUseGetterFunction(\"\");\n    var getInUse = function (ancestors) {\n        for (var p = 0, ancestor = void 0; p < ancestors.length && (ancestor = ancestors[p]); ++p) {\n            if (isArray(ancestor))\n                continue;\n            if (ancestor.kind === Kind.OPERATION_DEFINITION) {\n                // If an operation is anonymous, we use the empty string as its key.\n                return getInUseByOperationName(ancestor.name && ancestor.name.value);\n            }\n            if (ancestor.kind === Kind.FRAGMENT_DEFINITION) {\n                return getInUseByFragmentName(ancestor.name.value);\n            }\n        }\n        globalThis.__DEV__ !== false && invariant.error(86);\n        return null;\n    };\n    var operationCount = 0;\n    for (var i = doc.definitions.length - 1; i >= 0; --i) {\n        if (doc.definitions[i].kind === Kind.OPERATION_DEFINITION) {\n            ++operationCount;\n        }\n    }\n    var directiveMatcher = getDirectiveMatcher(directives);\n    var shouldRemoveField = function (nodeDirectives) {\n        return isNonEmptyArray(nodeDirectives) &&\n            nodeDirectives\n                .map(directiveMatcher)\n                .some(function (config) { return config && config.remove; });\n    };\n    var originalFragmentDefsByPath = new Map();\n    // Any time the first traversal of the document below makes a change like\n    // removing a fragment (by returning null), this variable should be set to\n    // true. Once it becomes true, it should never be set to false again. If this\n    // variable remains false throughout the traversal, then we can return the\n    // original doc immediately without any modifications.\n    var firstVisitMadeChanges = false;\n    var fieldOrInlineFragmentVisitor = {\n        enter: function (node) {\n            if (shouldRemoveField(node.directives)) {\n                firstVisitMadeChanges = true;\n                return null;\n            }\n        },\n    };\n    var docWithoutDirectiveSubtrees = visit(doc, {\n        // These two AST node types share the same implementation, defined above.\n        Field: fieldOrInlineFragmentVisitor,\n        InlineFragment: fieldOrInlineFragmentVisitor,\n        VariableDefinition: {\n            enter: function () {\n                // VariableDefinition nodes do not count as variables in use, though\n                // they do contain Variable nodes that might be visited below. To avoid\n                // counting variable declarations as usages, we skip visiting the\n                // contents of this VariableDefinition node by returning false.\n                return false;\n            },\n        },\n        Variable: {\n            enter: function (node, _key, _parent, _path, ancestors) {\n                var inUse = getInUse(ancestors);\n                if (inUse) {\n                    inUse.variables.add(node.name.value);\n                }\n            },\n        },\n        FragmentSpread: {\n            enter: function (node, _key, _parent, _path, ancestors) {\n                if (shouldRemoveField(node.directives)) {\n                    firstVisitMadeChanges = true;\n                    return null;\n                }\n                var inUse = getInUse(ancestors);\n                if (inUse) {\n                    inUse.fragmentSpreads.add(node.name.value);\n                }\n                // We might like to remove this FragmentSpread by returning null here if\n                // the corresponding FragmentDefinition node is also going to be removed\n                // by the logic below, but we can't control the relative order of those\n                // events, so we have to postpone the removal of dangling FragmentSpread\n                // nodes until after the current visit of the document has finished.\n            },\n        },\n        FragmentDefinition: {\n            enter: function (node, _key, _parent, path) {\n                originalFragmentDefsByPath.set(JSON.stringify(path), node);\n            },\n            leave: function (node, _key, _parent, path) {\n                var originalNode = originalFragmentDefsByPath.get(JSON.stringify(path));\n                if (node === originalNode) {\n                    // If the FragmentNode received by this leave function is identical to\n                    // the one received by the corresponding enter function (above), then\n                    // the visitor must not have made any changes within this\n                    // FragmentDefinition node. This fragment definition may still be\n                    // removed if there are no ...spread references to it, but it won't be\n                    // removed just because it has only a __typename field.\n                    return node;\n                }\n                if (\n                // This logic applies only if the document contains one or more\n                // operations, since removing all fragments from a document containing\n                // only fragments makes the document useless.\n                operationCount > 0 &&\n                    node.selectionSet.selections.every(function (selection) {\n                        return selection.kind === Kind.FIELD &&\n                            selection.name.value === \"__typename\";\n                    })) {\n                    // This is a somewhat opinionated choice: if a FragmentDefinition ends\n                    // up having no fields other than __typename, we remove the whole\n                    // fragment definition, and later prune ...spread references to it.\n                    getInUseByFragmentName(node.name.value).removed = true;\n                    firstVisitMadeChanges = true;\n                    return null;\n                }\n            },\n        },\n        Directive: {\n            leave: function (node) {\n                // If a matching directive is found, remove the directive itself. Note\n                // that this does not remove the target (field, argument, etc) of the\n                // directive, but only the directive itself.\n                if (directiveMatcher(node)) {\n                    firstVisitMadeChanges = true;\n                    return null;\n                }\n            },\n        },\n    });\n    if (!firstVisitMadeChanges) {\n        // If our first pass did not change anything about the document, then there\n        // is no cleanup we need to do, and we can return the original doc.\n        return doc;\n    }\n    // Utility for making sure inUse.transitiveVars is recursively populated.\n    // Because this logic assumes inUse.fragmentSpreads has been completely\n    // populated and inUse.removed has been set if appropriate,\n    // populateTransitiveVars must be called after that information has been\n    // collected by the first traversal of the document.\n    var populateTransitiveVars = function (inUse) {\n        if (!inUse.transitiveVars) {\n            inUse.transitiveVars = new Set(inUse.variables);\n            if (!inUse.removed) {\n                inUse.fragmentSpreads.forEach(function (childFragmentName) {\n                    populateTransitiveVars(getInUseByFragmentName(childFragmentName)).transitiveVars.forEach(function (varName) {\n                        inUse.transitiveVars.add(varName);\n                    });\n                });\n            }\n        }\n        return inUse;\n    };\n    // Since we've been keeping track of fragment spreads used by particular\n    // operations and fragment definitions, we now need to compute the set of all\n    // spreads used (transitively) by any operations in the document.\n    var allFragmentNamesUsed = new Set();\n    docWithoutDirectiveSubtrees.definitions.forEach(function (def) {\n        if (def.kind === Kind.OPERATION_DEFINITION) {\n            populateTransitiveVars(getInUseByOperationName(def.name && def.name.value)).fragmentSpreads.forEach(function (childFragmentName) {\n                allFragmentNamesUsed.add(childFragmentName);\n            });\n        }\n        else if (def.kind === Kind.FRAGMENT_DEFINITION &&\n            // If there are no operations in the document, then all fragment\n            // definitions count as usages of their own fragment names. This heuristic\n            // prevents accidentally removing all fragment definitions from the\n            // document just because it contains no operations that use the fragments.\n            operationCount === 0 &&\n            !getInUseByFragmentName(def.name.value).removed) {\n            allFragmentNamesUsed.add(def.name.value);\n        }\n    });\n    // Now that we have added all fragment spreads used by operations to the\n    // allFragmentNamesUsed set, we can complete the set by transitively adding\n    // all fragment spreads used by those fragments, and so on.\n    allFragmentNamesUsed.forEach(function (fragmentName) {\n        // Once all the childFragmentName strings added here have been seen already,\n        // the top-level allFragmentNamesUsed.forEach loop will terminate.\n        populateTransitiveVars(getInUseByFragmentName(fragmentName)).fragmentSpreads.forEach(function (childFragmentName) {\n            allFragmentNamesUsed.add(childFragmentName);\n        });\n    });\n    var fragmentWillBeRemoved = function (fragmentName) {\n        return !!(\n        // A fragment definition will be removed if there are no spreads that refer\n        // to it, or the fragment was explicitly removed because it had no fields\n        // other than __typename.\n        (!allFragmentNamesUsed.has(fragmentName) ||\n            getInUseByFragmentName(fragmentName).removed));\n    };\n    var enterVisitor = {\n        enter: function (node) {\n            if (fragmentWillBeRemoved(node.name.value)) {\n                return null;\n            }\n        },\n    };\n    return nullIfDocIsEmpty(visit(docWithoutDirectiveSubtrees, {\n        // If the fragment is going to be removed, then leaving any dangling\n        // FragmentSpread nodes with the same name would be a mistake.\n        FragmentSpread: enterVisitor,\n        // This is where the fragment definition is actually removed.\n        FragmentDefinition: enterVisitor,\n        OperationDefinition: {\n            leave: function (node) {\n                // Upon leaving each operation in the depth-first AST traversal, prune\n                // any variables that are declared by the operation but unused within.\n                if (node.variableDefinitions) {\n                    var usedVariableNames_1 = populateTransitiveVars(\n                    // If an operation is anonymous, we use the empty string as its key.\n                    getInUseByOperationName(node.name && node.name.value)).transitiveVars;\n                    // According to the GraphQL spec, all variables declared by an\n                    // operation must either be used by that operation or used by some\n                    // fragment included transitively into that operation:\n                    // https://spec.graphql.org/draft/#sec-All-Variables-Used\n                    //\n                    // To stay on the right side of this validation rule, if/when we\n                    // remove the last $var references from an operation or its fragments,\n                    // we must also remove the corresponding $var declaration from the\n                    // enclosing operation. This pruning applies only to operations and\n                    // not fragment definitions, at the moment. Fragments may be able to\n                    // declare variables eventually, but today they can only consume them.\n                    if (usedVariableNames_1.size < node.variableDefinitions.length) {\n                        return __assign(__assign({}, node), { variableDefinitions: node.variableDefinitions.filter(function (varDef) {\n                                return usedVariableNames_1.has(varDef.variable.name.value);\n                            }) });\n                    }\n                }\n            },\n        },\n    }));\n}\nexport var addTypenameToDocument = Object.assign(function (doc) {\n    return visit(doc, {\n        SelectionSet: {\n            enter: function (node, _key, parent) {\n                // Don't add __typename to OperationDefinitions.\n                if (parent &&\n                    parent.kind ===\n                        Kind.OPERATION_DEFINITION) {\n                    return;\n                }\n                // No changes if no selections.\n                var selections = node.selections;\n                if (!selections) {\n                    return;\n                }\n                // If selections already have a __typename, or are part of an\n                // introspection query, do nothing.\n                var skip = selections.some(function (selection) {\n                    return (isField(selection) &&\n                        (selection.name.value === \"__typename\" ||\n                            selection.name.value.lastIndexOf(\"__\", 0) === 0));\n                });\n                if (skip) {\n                    return;\n                }\n                // If this SelectionSet is @export-ed as an input variable, it should\n                // not have a __typename field (see issue #4691).\n                var field = parent;\n                if (isField(field) &&\n                    field.directives &&\n                    field.directives.some(function (d) { return d.name.value === \"export\"; })) {\n                    return;\n                }\n                // Create and return a new SelectionSet with a __typename Field.\n                return __assign(__assign({}, node), { selections: __spreadArray(__spreadArray([], selections, true), [TYPENAME_FIELD], false) });\n            },\n        },\n    });\n}, {\n    added: function (field) {\n        return field === TYPENAME_FIELD;\n    },\n});\nvar connectionRemoveConfig = {\n    test: function (directive) {\n        var willRemove = directive.name.value === \"connection\";\n        if (willRemove) {\n            if (!directive.arguments ||\n                !directive.arguments.some(function (arg) { return arg.name.value === \"key\"; })) {\n                globalThis.__DEV__ !== false && invariant.warn(87);\n            }\n        }\n        return willRemove;\n    },\n};\nexport function removeConnectionDirectiveFromDocument(doc) {\n    return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));\n}\nfunction hasDirectivesInSelectionSet(directives, selectionSet, nestedCheck) {\n    if (nestedCheck === void 0) { nestedCheck = true; }\n    return (!!selectionSet &&\n        selectionSet.selections &&\n        selectionSet.selections.some(function (selection) {\n            return hasDirectivesInSelection(directives, selection, nestedCheck);\n        }));\n}\nfunction hasDirectivesInSelection(directives, selection, nestedCheck) {\n    if (nestedCheck === void 0) { nestedCheck = true; }\n    if (!isField(selection)) {\n        return true;\n    }\n    if (!selection.directives) {\n        return false;\n    }\n    return (selection.directives.some(getDirectiveMatcher(directives)) ||\n        (nestedCheck &&\n            hasDirectivesInSelectionSet(directives, selection.selectionSet, nestedCheck)));\n}\nfunction getArgumentMatcher(config) {\n    return function argumentMatcher(argument) {\n        return config.some(function (aConfig) {\n            return argument.value &&\n                argument.value.kind === Kind.VARIABLE &&\n                argument.value.name &&\n                (aConfig.name === argument.value.name.value ||\n                    (aConfig.test && aConfig.test(argument)));\n        });\n    };\n}\nexport function removeArgumentsFromDocument(config, doc) {\n    var argMatcher = getArgumentMatcher(config);\n    return nullIfDocIsEmpty(visit(doc, {\n        OperationDefinition: {\n            enter: function (node) {\n                return __assign(__assign({}, node), { \n                    // Remove matching top level variables definitions.\n                    variableDefinitions: node.variableDefinitions ?\n                        node.variableDefinitions.filter(function (varDef) {\n                            return !config.some(function (arg) { return arg.name === varDef.variable.name.value; });\n                        })\n                        : [] });\n            },\n        },\n        Field: {\n            enter: function (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                var shouldRemoveField = config.some(function (argConfig) { return argConfig.remove; });\n                if (shouldRemoveField) {\n                    var argMatchCount_1 = 0;\n                    if (node.arguments) {\n                        node.arguments.forEach(function (arg) {\n                            if (argMatcher(arg)) {\n                                argMatchCount_1 += 1;\n                            }\n                        });\n                    }\n                    if (argMatchCount_1 === 1) {\n                        return null;\n                    }\n                }\n            },\n        },\n        Argument: {\n            enter: function (node) {\n                // Remove all matching arguments.\n                if (argMatcher(node)) {\n                    return null;\n                }\n            },\n        },\n    }));\n}\nexport function removeFragmentSpreadFromDocument(config, doc) {\n    function enter(node) {\n        if (config.some(function (def) { return def.name === node.name.value; })) {\n            return null;\n        }\n    }\n    return nullIfDocIsEmpty(visit(doc, {\n        FragmentSpread: { enter: enter },\n        FragmentDefinition: { enter: enter },\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(document) {\n    var definition = getMainDefinition(document);\n    var definitionOperation = definition.operation;\n    if (definitionOperation === \"query\") {\n        // Already a query, so return the existing document.\n        return document;\n    }\n    // Build a new query using the selection set of the main operation.\n    var modifiedDoc = visit(document, {\n        OperationDefinition: {\n            enter: function (node) {\n                return __assign(__assign({}, node), { operation: \"query\" });\n            },\n        },\n    });\n    return modifiedDoc;\n}\n// Remove fields / selection sets that include an @client directive.\nexport function removeClientSetsFromDocument(document) {\n    checkDocument(document);\n    var modifiedDoc = removeDirectivesFromDocument([\n        {\n            test: function (directive) { return directive.name.value === \"client\"; },\n            remove: true,\n        },\n    ], document);\n    return modifiedDoc;\n}\n//# sourceMappingURL=transform.js.map","// A [trie](https://en.wikipedia.org/wiki/Trie) data structure that holds\n// object keys weakly, yet can also hold non-object keys, unlike the\n// native `WeakMap`.\n// If no makeData function is supplied, the looked-up data will be an empty,\n// null-prototype Object.\nconst defaultMakeData = () => Object.create(null);\n// Useful for processing arguments objects as well as arrays.\nconst { forEach, slice } = Array.prototype;\nconst { hasOwnProperty } = Object.prototype;\nexport class Trie {\n    constructor(weakness = true, makeData = defaultMakeData) {\n        this.weakness = weakness;\n        this.makeData = makeData;\n    }\n    lookup() {\n        return this.lookupArray(arguments);\n    }\n    lookupArray(array) {\n        let node = this;\n        forEach.call(array, key => node = node.getChildTrie(key));\n        return hasOwnProperty.call(node, \"data\")\n            ? node.data\n            : node.data = this.makeData(slice.call(array));\n    }\n    peek() {\n        return this.peekArray(arguments);\n    }\n    peekArray(array) {\n        let node = this;\n        for (let i = 0, len = array.length; node && i < len; ++i) {\n            const map = node.mapFor(array[i], false);\n            node = map && map.get(array[i]);\n        }\n        return node && node.data;\n    }\n    remove() {\n        return this.removeArray(arguments);\n    }\n    removeArray(array) {\n        let data;\n        if (array.length) {\n            const head = array[0];\n            const map = this.mapFor(head, false);\n            const child = map && map.get(head);\n            if (child) {\n                data = child.removeArray(slice.call(array, 1));\n                if (!child.data && !child.weak && !(child.strong && child.strong.size)) {\n                    map.delete(head);\n                }\n            }\n        }\n        else {\n            data = this.data;\n            delete this.data;\n        }\n        return data;\n    }\n    getChildTrie(key) {\n        const map = this.mapFor(key, true);\n        let child = map.get(key);\n        if (!child)\n            map.set(key, child = new Trie(this.weakness, this.makeData));\n        return child;\n    }\n    mapFor(key, create) {\n        return this.weakness && isObjRef(key)\n            ? this.weak || (create ? this.weak = new WeakMap : void 0)\n            : this.strong || (create ? this.strong = new Map : void 0);\n    }\n}\nfunction isObjRef(value) {\n    switch (typeof value) {\n        case \"object\":\n            if (value === null)\n                break;\n        // Fall through to return true...\n        case \"function\":\n            return true;\n    }\n    return false;\n}\n//# sourceMappingURL=index.js.map","import { devAssert } from '../jsutils/devAssert.mjs';\nimport { inspect } from '../jsutils/inspect.mjs';\nimport { isNode, QueryDocumentKeys } from './ast.mjs';\nimport { Kind } from './kinds.mjs';\n/**\n * A visitor is provided to visit, it contains the collection of\n * relevant functions to be called during the visitor's traversal.\n */\n\nexport const BREAK = Object.freeze({});\n/**\n * visit() will walk through an AST using a depth-first traversal, calling\n * the visitor's enter function at each node in the traversal, and calling the\n * leave function after visiting that node and all of its child nodes.\n *\n * By returning different values from the enter and leave functions, the\n * behavior of the visitor can be altered, including skipping over a sub-tree of\n * the AST (by returning false), editing the AST by returning a value or null\n * to remove the value, or to stop the whole traversal by returning BREAK.\n *\n * When using visit() to edit an AST, the original AST will not be modified, and\n * a new version of the AST with the changes applied will be returned from the\n * visit function.\n *\n * ```ts\n * const editedAST = visit(ast, {\n *   enter(node, key, parent, path, ancestors) {\n *     // @return\n *     //   undefined: no action\n *     //   false: skip visiting this node\n *     //   visitor.BREAK: stop visiting altogether\n *     //   null: delete this node\n *     //   any value: replace this node with the returned value\n *   },\n *   leave(node, key, parent, path, ancestors) {\n *     // @return\n *     //   undefined: no action\n *     //   false: no action\n *     //   visitor.BREAK: stop visiting altogether\n *     //   null: delete this node\n *     //   any value: replace this node with the returned value\n *   }\n * });\n * ```\n *\n * Alternatively to providing enter() and leave() functions, a visitor can\n * instead provide functions named the same as the kinds of AST nodes, or\n * enter/leave visitors at a named key, leading to three permutations of the\n * visitor API:\n *\n * 1) Named visitors triggered when entering a node of a specific kind.\n *\n * ```ts\n * visit(ast, {\n *   Kind(node) {\n *     // enter the \"Kind\" node\n *   }\n * })\n * ```\n *\n * 2) Named visitors that trigger upon entering and leaving a node of a specific kind.\n *\n * ```ts\n * visit(ast, {\n *   Kind: {\n *     enter(node) {\n *       // enter the \"Kind\" node\n *     }\n *     leave(node) {\n *       // leave the \"Kind\" node\n *     }\n *   }\n * })\n * ```\n *\n * 3) Generic visitors that trigger upon entering and leaving any node.\n *\n * ```ts\n * visit(ast, {\n *   enter(node) {\n *     // enter any node\n *   },\n *   leave(node) {\n *     // leave any node\n *   }\n * })\n * ```\n */\n\nexport function visit(root, visitor, visitorKeys = QueryDocumentKeys) {\n  const enterLeaveMap = new Map();\n\n  for (const kind of Object.values(Kind)) {\n    enterLeaveMap.set(kind, getEnterLeaveForKind(visitor, kind));\n  }\n  /* eslint-disable no-undef-init */\n\n  let stack = undefined;\n  let inArray = Array.isArray(root);\n  let keys = [root];\n  let index = -1;\n  let edits = [];\n  let node = root;\n  let key = undefined;\n  let parent = undefined;\n  const path = [];\n  const ancestors = [];\n  /* eslint-enable no-undef-init */\n\n  do {\n    index++;\n    const isLeaving = index === keys.length;\n    const isEdited = isLeaving && edits.length !== 0;\n\n    if (isLeaving) {\n      key = ancestors.length === 0 ? undefined : path[path.length - 1];\n      node = parent;\n      parent = ancestors.pop();\n\n      if (isEdited) {\n        if (inArray) {\n          node = node.slice();\n          let editOffset = 0;\n\n          for (const [editKey, editValue] of edits) {\n            const arrayKey = editKey - editOffset;\n\n            if (editValue === null) {\n              node.splice(arrayKey, 1);\n              editOffset++;\n            } else {\n              node[arrayKey] = editValue;\n            }\n          }\n        } else {\n          node = Object.defineProperties(\n            {},\n            Object.getOwnPropertyDescriptors(node),\n          );\n\n          for (const [editKey, editValue] of edits) {\n            node[editKey] = editValue;\n          }\n        }\n      }\n\n      index = stack.index;\n      keys = stack.keys;\n      edits = stack.edits;\n      inArray = stack.inArray;\n      stack = stack.prev;\n    } else if (parent) {\n      key = inArray ? index : keys[index];\n      node = parent[key];\n\n      if (node === null || node === undefined) {\n        continue;\n      }\n\n      path.push(key);\n    }\n\n    let result;\n\n    if (!Array.isArray(node)) {\n      var _enterLeaveMap$get, _enterLeaveMap$get2;\n\n      isNode(node) || devAssert(false, `Invalid AST Node: ${inspect(node)}.`);\n      const visitFn = isLeaving\n        ? (_enterLeaveMap$get = enterLeaveMap.get(node.kind)) === null ||\n          _enterLeaveMap$get === void 0\n          ? void 0\n          : _enterLeaveMap$get.leave\n        : (_enterLeaveMap$get2 = enterLeaveMap.get(node.kind)) === null ||\n          _enterLeaveMap$get2 === void 0\n        ? void 0\n        : _enterLeaveMap$get2.enter;\n      result =\n        visitFn === null || visitFn === void 0\n          ? void 0\n          : visitFn.call(visitor, node, key, parent, path, ancestors);\n\n      if (result === BREAK) {\n        break;\n      }\n\n      if (result === false) {\n        if (!isLeaving) {\n          path.pop();\n          continue;\n        }\n      } else if (result !== undefined) {\n        edits.push([key, result]);\n\n        if (!isLeaving) {\n          if (isNode(result)) {\n            node = result;\n          } else {\n            path.pop();\n            continue;\n          }\n        }\n      }\n    }\n\n    if (result === undefined && isEdited) {\n      edits.push([key, node]);\n    }\n\n    if (isLeaving) {\n      path.pop();\n    } else {\n      var _node$kind;\n\n      stack = {\n        inArray,\n        index,\n        keys,\n        edits,\n        prev: stack,\n      };\n      inArray = Array.isArray(node);\n      keys = inArray\n        ? node\n        : (_node$kind = visitorKeys[node.kind]) !== null &&\n          _node$kind !== void 0\n        ? _node$kind\n        : [];\n      index = -1;\n      edits = [];\n\n      if (parent) {\n        ancestors.push(parent);\n      }\n\n      parent = node;\n    }\n  } while (stack !== undefined);\n\n  if (edits.length !== 0) {\n    // New root\n    return edits[edits.length - 1][1];\n  }\n\n  return root;\n}\n/**\n * Creates a new visitor instance which delegates to many visitors to run in\n * parallel. Each visitor will be visited for each node before moving on.\n *\n * If a prior visitor edits a node, no following visitors will see that node.\n */\n\nexport function visitInParallel(visitors) {\n  const skipping = new Array(visitors.length).fill(null);\n  const mergedVisitor = Object.create(null);\n\n  for (const kind of Object.values(Kind)) {\n    let hasVisitor = false;\n    const enterList = new Array(visitors.length).fill(undefined);\n    const leaveList = new Array(visitors.length).fill(undefined);\n\n    for (let i = 0; i < visitors.length; ++i) {\n      const { enter, leave } = getEnterLeaveForKind(visitors[i], kind);\n      hasVisitor || (hasVisitor = enter != null || leave != null);\n      enterList[i] = enter;\n      leaveList[i] = leave;\n    }\n\n    if (!hasVisitor) {\n      continue;\n    }\n\n    const mergedEnterLeave = {\n      enter(...args) {\n        const node = args[0];\n\n        for (let i = 0; i < visitors.length; i++) {\n          if (skipping[i] === null) {\n            var _enterList$i;\n\n            const result =\n              (_enterList$i = enterList[i]) === null || _enterList$i === void 0\n                ? void 0\n                : _enterList$i.apply(visitors[i], args);\n\n            if (result === false) {\n              skipping[i] = node;\n            } else if (result === BREAK) {\n              skipping[i] = BREAK;\n            } else if (result !== undefined) {\n              return result;\n            }\n          }\n        }\n      },\n\n      leave(...args) {\n        const node = args[0];\n\n        for (let i = 0; i < visitors.length; i++) {\n          if (skipping[i] === null) {\n            var _leaveList$i;\n\n            const result =\n              (_leaveList$i = leaveList[i]) === null || _leaveList$i === void 0\n                ? void 0\n                : _leaveList$i.apply(visitors[i], args);\n\n            if (result === BREAK) {\n              skipping[i] = BREAK;\n            } else if (result !== undefined && result !== false) {\n              return result;\n            }\n          } else if (skipping[i] === node) {\n            skipping[i] = null;\n          }\n        }\n      },\n    };\n    mergedVisitor[kind] = mergedEnterLeave;\n  }\n\n  return mergedVisitor;\n}\n/**\n * Given a visitor instance and a node kind, return EnterLeaveVisitor for that kind.\n */\n\nexport function getEnterLeaveForKind(visitor, kind) {\n  const kindVisitor = visitor[kind];\n\n  if (typeof kindVisitor === 'object') {\n    // { Kind: { enter() {}, leave() {} } }\n    return kindVisitor;\n  } else if (typeof kindVisitor === 'function') {\n    // { Kind() {} }\n    return {\n      enter: kindVisitor,\n      leave: undefined,\n    };\n  } // { enter() {}, leave() {} }\n\n  return {\n    enter: visitor.enter,\n    leave: visitor.leave,\n  };\n}\n/**\n * Given a visitor instance, if it is leaving or not, and a node kind, return\n * the function the visitor runtime should call.\n *\n * @deprecated Please use `getEnterLeaveForKind` instead. Will be removed in v17\n */\n\n/* c8 ignore next 8 */\n\nexport function getVisitFn(visitor, kind, isLeaving) {\n  const { enter, leave } = getEnterLeaveForKind(visitor, kind);\n  return isLeaving ? leave : enter;\n}\n","// A [trie](https://en.wikipedia.org/wiki/Trie) data structure that holds\n// object keys weakly, yet can also hold non-object keys, unlike the\n// native `WeakMap`.\n// If no makeData function is supplied, the looked-up data will be an empty,\n// null-prototype Object.\nconst defaultMakeData = () => Object.create(null);\n// Useful for processing arguments objects as well as arrays.\nconst { forEach, slice } = Array.prototype;\nconst { hasOwnProperty } = Object.prototype;\nexport class Trie {\n    constructor(weakness = true, makeData = defaultMakeData) {\n        this.weakness = weakness;\n        this.makeData = makeData;\n    }\n    lookup(...array) {\n        return this.lookupArray(array);\n    }\n    lookupArray(array) {\n        let node = this;\n        forEach.call(array, key => node = node.getChildTrie(key));\n        return hasOwnProperty.call(node, \"data\")\n            ? node.data\n            : node.data = this.makeData(slice.call(array));\n    }\n    peek(...array) {\n        return this.peekArray(array);\n    }\n    peekArray(array) {\n        let node = this;\n        for (let i = 0, len = array.length; node && i < len; ++i) {\n            const map = this.weakness && isObjRef(array[i]) ? node.weak : node.strong;\n            node = map && map.get(array[i]);\n        }\n        return node && node.data;\n    }\n    getChildTrie(key) {\n        const map = this.weakness && isObjRef(key)\n            ? this.weak || (this.weak = new WeakMap())\n            : this.strong || (this.strong = new Map());\n        let child = map.get(key);\n        if (!child)\n            map.set(key, child = new Trie(this.weakness, this.makeData));\n        return child;\n    }\n}\nfunction isObjRef(value) {\n    switch (typeof value) {\n        case \"object\":\n            if (value === null)\n                break;\n        // Fall through to return true...\n        case \"function\":\n            return true;\n    }\n    return false;\n}\n//# sourceMappingURL=index.js.map","// This currentContext variable will only be used if the makeSlotClass\n// function is called, which happens only if this is the first copy of the\n// @wry/context package to be imported.\nlet currentContext = null;\n// This unique internal object is used to denote the absence of a value\n// for a given Slot, and is never exposed to outside code.\nconst MISSING_VALUE = {};\nlet idCounter = 1;\n// Although we can't do anything about the cost of duplicated code from\n// accidentally bundling multiple copies of the @wry/context package, we can\n// avoid creating the Slot class more than once using makeSlotClass.\nconst makeSlotClass = () => class Slot {\n    constructor() {\n        // If you have a Slot object, you can find out its slot.id, but you cannot\n        // guess the slot.id of a Slot you don't have access to, thanks to the\n        // randomized suffix.\n        this.id = [\n            \"slot\",\n            idCounter++,\n            Date.now(),\n            Math.random().toString(36).slice(2),\n        ].join(\":\");\n    }\n    hasValue() {\n        for (let context = currentContext; context; context = context.parent) {\n            // We use the Slot object iself as a key to its value, which means the\n            // value cannot be obtained without a reference to the Slot object.\n            if (this.id in context.slots) {\n                const value = context.slots[this.id];\n                if (value === MISSING_VALUE)\n                    break;\n                if (context !== currentContext) {\n                    // Cache the value in currentContext.slots so the next lookup will\n                    // be faster. This caching is safe because the tree of contexts and\n                    // the values of the slots are logically immutable.\n                    currentContext.slots[this.id] = value;\n                }\n                return true;\n            }\n        }\n        if (currentContext) {\n            // If a value was not found for this Slot, it's never going to be found\n            // no matter how many times we look it up, so we might as well cache\n            // the absence of the value, too.\n            currentContext.slots[this.id] = MISSING_VALUE;\n        }\n        return false;\n    }\n    getValue() {\n        if (this.hasValue()) {\n            return currentContext.slots[this.id];\n        }\n    }\n    withValue(value, callback, \n    // Given the prevalence of arrow functions, specifying arguments is likely\n    // to be much more common than specifying `this`, hence this ordering:\n    args, thisArg) {\n        const slots = {\n            __proto__: null,\n            [this.id]: value,\n        };\n        const parent = currentContext;\n        currentContext = { parent, slots };\n        try {\n            // Function.prototype.apply allows the arguments array argument to be\n            // omitted or undefined, so args! is fine here.\n            return callback.apply(thisArg, args);\n        }\n        finally {\n            currentContext = parent;\n        }\n    }\n    // Capture the current context and wrap a callback function so that it\n    // reestablishes the captured context when called.\n    static bind(callback) {\n        const context = currentContext;\n        return function () {\n            const saved = currentContext;\n            try {\n                currentContext = context;\n                return callback.apply(this, arguments);\n            }\n            finally {\n                currentContext = saved;\n            }\n        };\n    }\n    // Immediately run a callback function without any captured context.\n    static noContext(callback, \n    // Given the prevalence of arrow functions, specifying arguments is likely\n    // to be much more common than specifying `this`, hence this ordering:\n    args, thisArg) {\n        if (currentContext) {\n            const saved = currentContext;\n            try {\n                currentContext = null;\n                // Function.prototype.apply allows the arguments array argument to be\n                // omitted or undefined, so args! is fine here.\n                return callback.apply(thisArg, args);\n            }\n            finally {\n                currentContext = saved;\n            }\n        }\n        else {\n            return callback.apply(thisArg, args);\n        }\n    }\n};\nfunction maybe(fn) {\n    try {\n        return fn();\n    }\n    catch (ignored) { }\n}\n// We store a single global implementation of the Slot class as a permanent\n// non-enumerable property of the globalThis object. This obfuscation does\n// nothing to prevent access to the Slot class, but at least it ensures the\n// implementation (i.e. currentContext) cannot be tampered with, and all copies\n// of the @wry/context package (hopefully just one) will share the same Slot\n// implementation. Since the first copy of the @wry/context package to be\n// imported wins, this technique imposes a steep cost for any future breaking\n// changes to the Slot class.\nconst globalKey = \"@wry/context:Slot\";\nconst host = \n// Prefer globalThis when available.\n// https://github.com/benjamn/wryware/issues/347\nmaybe(() => globalThis) ||\n    // Fall back to global, which works in Node.js and may be converted by some\n    // bundlers to the appropriate identifier (window, self, ...) depending on the\n    // bundling target. https://github.com/endojs/endo/issues/576#issuecomment-1178515224\n    maybe(() => global) ||\n    // Otherwise, use a dummy host that's local to this module. We used to fall\n    // back to using the Array constructor as a namespace, but that was flagged in\n    // https://github.com/benjamn/wryware/issues/347, and can be avoided.\n    Object.create(null);\n// Whichever globalHost we're using, make TypeScript happy about the additional\n// globalKey property.\nconst globalHost = host;\nexport const Slot = globalHost[globalKey] ||\n    // Earlier versions of this package stored the globalKey property on the Array\n    // constructor, so we check there as well, to prevent Slot class duplication.\n    Array[globalKey] ||\n    (function (Slot) {\n        try {\n            Object.defineProperty(globalHost, globalKey, {\n                value: Slot,\n                enumerable: false,\n                writable: false,\n                // When it was possible for globalHost to be the Array constructor (a\n                // legacy Slot dedup strategy), it was important for the property to be\n                // configurable:true so it could be deleted. That does not seem to be as\n                // important when globalHost is the global object, but I don't want to\n                // cause similar problems again, and configurable:true seems safest.\n                // https://github.com/endojs/endo/issues/576#issuecomment-1178274008\n                configurable: true\n            });\n        }\n        finally {\n            return Slot;\n        }\n    })(makeSlotClass());\n//# sourceMappingURL=slot.js.map","import { Slot } from \"./slot.js\";\nexport { Slot };\nexport const { bind, noContext } = Slot;\n// Like global.setTimeout, except the callback runs with captured context.\nexport { setTimeoutWithContext as setTimeout };\nfunction setTimeoutWithContext(callback, delay) {\n    return setTimeout(bind(callback), delay);\n}\n// Turn any generator function into an async function (using yield instead\n// of await), with context automatically preserved across yields.\nexport function asyncFromGen(genFn) {\n    return function () {\n        const gen = genFn.apply(this, arguments);\n        const boundNext = bind(gen.next);\n        const boundThrow = bind(gen.throw);\n        return new Promise((resolve, reject) => {\n            function invoke(method, argument) {\n                try {\n                    var result = method.call(gen, argument);\n                }\n                catch (error) {\n                    return reject(error);\n                }\n                const next = result.done ? resolve : invokeNext;\n                if (isPromiseLike(result.value)) {\n                    result.value.then(next, result.done ? reject : invokeThrow);\n                }\n                else {\n                    next(result.value);\n                }\n            }\n            const invokeNext = (value) => invoke(boundNext, value);\n            const invokeThrow = (error) => invoke(boundThrow, error);\n            invokeNext();\n        });\n    };\n}\nfunction isPromiseLike(value) {\n    return value && typeof value.then === \"function\";\n}\n// If you use the fibers npm package to implement coroutines in Node.js,\n// you should call this function at least once to ensure context management\n// remains coherent across any yields.\nconst wrappedFibers = [];\nexport function wrapYieldingFiberMethods(Fiber) {\n    // There can be only one implementation of Fiber per process, so this array\n    // should never grow longer than one element.\n    if (wrappedFibers.indexOf(Fiber) < 0) {\n        const wrap = (obj, method) => {\n            const fn = obj[method];\n            obj[method] = function () {\n                return noContext(fn, arguments, this);\n            };\n        };\n        // These methods can yield, according to\n        // https://github.com/laverdet/node-fibers/blob/ddebed9b8ae3883e57f822e2108e6943e5c8d2a8/fibers.js#L97-L100\n        wrap(Fiber, \"yield\");\n        wrap(Fiber.prototype, \"run\");\n        wrap(Fiber.prototype, \"throwInto\");\n        wrappedFibers.push(Fiber);\n    }\n    return Fiber;\n}\n//# sourceMappingURL=index.js.map","import { Slot } from \"@wry/context\";\nexport const parentEntrySlot = new Slot();\nexport function nonReactive(fn) {\n    return parentEntrySlot.withValue(void 0, fn);\n}\nexport { Slot };\nexport { bind as bindContext, noContext, setTimeout, asyncFromGen, } from \"@wry/context\";\n//# sourceMappingURL=context.js.map","export const { hasOwnProperty, } = Object.prototype;\nexport const arrayFromSet = Array.from ||\n    function (set) {\n        const array = [];\n        set.forEach(item => array.push(item));\n        return array;\n    };\nexport function maybeUnsubscribe(entryOrDep) {\n    const { unsubscribe } = entryOrDep;\n    if (typeof unsubscribe === \"function\") {\n        entryOrDep.unsubscribe = void 0;\n        unsubscribe();\n    }\n}\n//# sourceMappingURL=helpers.js.map","import { parentEntrySlot } from \"./context.js\";\nimport { maybeUnsubscribe, arrayFromSet } from \"./helpers.js\";\nconst emptySetPool = [];\nconst POOL_TARGET_SIZE = 100;\n// Since this package might be used browsers, we should avoid using the\n// Node built-in assert module.\nfunction assert(condition, optionalMessage) {\n    if (!condition) {\n        throw new Error(optionalMessage || \"assertion failure\");\n    }\n}\nfunction valueIs(a, b) {\n    const len = a.length;\n    return (\n    // Unknown values are not equal to each other.\n    len > 0 &&\n        // Both values must be ordinary (or both exceptional) to be equal.\n        len === b.length &&\n        // The underlying value or exception must be the same.\n        a[len - 1] === b[len - 1]);\n}\nfunction valueGet(value) {\n    switch (value.length) {\n        case 0: throw new Error(\"unknown value\");\n        case 1: return value[0];\n        case 2: throw value[1];\n    }\n}\nfunction valueCopy(value) {\n    return value.slice(0);\n}\nexport class Entry {\n    constructor(fn) {\n        this.fn = fn;\n        this.parents = new Set();\n        this.childValues = new Map();\n        // When this Entry has children that are dirty, this property becomes\n        // a Set containing other Entry objects, borrowed from emptySetPool.\n        // When the set becomes empty, it gets recycled back to emptySetPool.\n        this.dirtyChildren = null;\n        this.dirty = true;\n        this.recomputing = false;\n        this.value = [];\n        this.deps = null;\n        ++Entry.count;\n    }\n    peek() {\n        if (this.value.length === 1 && !mightBeDirty(this)) {\n            rememberParent(this);\n            return this.value[0];\n        }\n    }\n    // This is the most important method of the Entry API, because it\n    // determines whether the cached this.value can be returned immediately,\n    // or must be recomputed. The overall performance of the caching system\n    // depends on the truth of the following observations: (1) this.dirty is\n    // usually false, (2) this.dirtyChildren is usually null/empty, and thus\n    // (3) valueGet(this.value) is usually returned without recomputation.\n    recompute(args) {\n        assert(!this.recomputing, \"already recomputing\");\n        rememberParent(this);\n        return mightBeDirty(this)\n            ? reallyRecompute(this, args)\n            : valueGet(this.value);\n    }\n    setDirty() {\n        if (this.dirty)\n            return;\n        this.dirty = true;\n        reportDirty(this);\n        // We can go ahead and unsubscribe here, since any further dirty\n        // notifications we receive will be redundant, and unsubscribing may\n        // free up some resources, e.g. file watchers.\n        maybeUnsubscribe(this);\n    }\n    dispose() {\n        this.setDirty();\n        // Sever any dependency relationships with our own children, so those\n        // children don't retain this parent Entry in their child.parents sets,\n        // thereby preventing it from being fully garbage collected.\n        forgetChildren(this);\n        // Because this entry has been kicked out of the cache (in index.js),\n        // we've lost the ability to find out if/when this entry becomes dirty,\n        // whether that happens through a subscription, because of a direct call\n        // to entry.setDirty(), or because one of its children becomes dirty.\n        // Because of this loss of future information, we have to assume the\n        // worst (that this entry might have become dirty very soon), so we must\n        // immediately mark this entry's parents as dirty. Normally we could\n        // just call entry.setDirty() rather than calling parent.setDirty() for\n        // each parent, but that would leave this entry in parent.childValues\n        // and parent.dirtyChildren, which would prevent the child from being\n        // truly forgotten.\n        eachParent(this, (parent, child) => {\n            parent.setDirty();\n            forgetChild(parent, this);\n        });\n    }\n    forget() {\n        // The code that creates Entry objects in index.ts will replace this method\n        // with one that actually removes the Entry from the cache, which will also\n        // trigger the entry.dispose method.\n        this.dispose();\n    }\n    dependOn(dep) {\n        dep.add(this);\n        if (!this.deps) {\n            this.deps = emptySetPool.pop() || new Set();\n        }\n        this.deps.add(dep);\n    }\n    forgetDeps() {\n        if (this.deps) {\n            arrayFromSet(this.deps).forEach(dep => dep.delete(this));\n            this.deps.clear();\n            emptySetPool.push(this.deps);\n            this.deps = null;\n        }\n    }\n}\nEntry.count = 0;\nfunction rememberParent(child) {\n    const parent = parentEntrySlot.getValue();\n    if (parent) {\n        child.parents.add(parent);\n        if (!parent.childValues.has(child)) {\n            parent.childValues.set(child, []);\n        }\n        if (mightBeDirty(child)) {\n            reportDirtyChild(parent, child);\n        }\n        else {\n            reportCleanChild(parent, child);\n        }\n        return parent;\n    }\n}\nfunction reallyRecompute(entry, args) {\n    forgetChildren(entry);\n    // Set entry as the parent entry while calling recomputeNewValue(entry).\n    parentEntrySlot.withValue(entry, recomputeNewValue, [entry, args]);\n    if (maybeSubscribe(entry, args)) {\n        // If we successfully recomputed entry.value and did not fail to\n        // (re)subscribe, then this Entry is no longer explicitly dirty.\n        setClean(entry);\n    }\n    return valueGet(entry.value);\n}\nfunction recomputeNewValue(entry, args) {\n    entry.recomputing = true;\n    const { normalizeResult } = entry;\n    let oldValueCopy;\n    if (normalizeResult && entry.value.length === 1) {\n        oldValueCopy = valueCopy(entry.value);\n    }\n    // Make entry.value an empty array, representing an unknown value.\n    entry.value.length = 0;\n    try {\n        // If entry.fn succeeds, entry.value will become a normal Value.\n        entry.value[0] = entry.fn.apply(null, args);\n        // If we have a viable oldValueCopy to compare with the (successfully\n        // recomputed) new entry.value, and they are not already === identical, give\n        // normalizeResult a chance to pick/choose/reuse parts of oldValueCopy[0]\n        // and/or entry.value[0] to determine the final cached entry.value.\n        if (normalizeResult && oldValueCopy && !valueIs(oldValueCopy, entry.value)) {\n            try {\n                entry.value[0] = normalizeResult(entry.value[0], oldValueCopy[0]);\n            }\n            catch (_a) {\n                // If normalizeResult throws, just use the newer value, rather than\n                // saving the exception as entry.value[1].\n            }\n        }\n    }\n    catch (e) {\n        // If entry.fn throws, entry.value will hold that exception.\n        entry.value[1] = e;\n    }\n    // Either way, this line is always reached.\n    entry.recomputing = false;\n}\nfunction mightBeDirty(entry) {\n    return entry.dirty || !!(entry.dirtyChildren && entry.dirtyChildren.size);\n}\nfunction setClean(entry) {\n    entry.dirty = false;\n    if (mightBeDirty(entry)) {\n        // This Entry may still have dirty children, in which case we can't\n        // let our parents know we're clean just yet.\n        return;\n    }\n    reportClean(entry);\n}\nfunction reportDirty(child) {\n    eachParent(child, reportDirtyChild);\n}\nfunction reportClean(child) {\n    eachParent(child, reportCleanChild);\n}\nfunction eachParent(child, callback) {\n    const parentCount = child.parents.size;\n    if (parentCount) {\n        const parents = arrayFromSet(child.parents);\n        for (let i = 0; i < parentCount; ++i) {\n            callback(parents[i], child);\n        }\n    }\n}\n// Let a parent Entry know that one of its children may be dirty.\nfunction reportDirtyChild(parent, child) {\n    // Must have called rememberParent(child) before calling\n    // reportDirtyChild(parent, child).\n    assert(parent.childValues.has(child));\n    assert(mightBeDirty(child));\n    const parentWasClean = !mightBeDirty(parent);\n    if (!parent.dirtyChildren) {\n        parent.dirtyChildren = emptySetPool.pop() || new Set;\n    }\n    else if (parent.dirtyChildren.has(child)) {\n        // If we already know this child is dirty, then we must have already\n        // informed our own parents that we are dirty, so we can terminate\n        // the recursion early.\n        return;\n    }\n    parent.dirtyChildren.add(child);\n    // If parent was clean before, it just became (possibly) dirty (according to\n    // mightBeDirty), since we just added child to parent.dirtyChildren.\n    if (parentWasClean) {\n        reportDirty(parent);\n    }\n}\n// Let a parent Entry know that one of its children is no longer dirty.\nfunction reportCleanChild(parent, child) {\n    // Must have called rememberChild(child) before calling\n    // reportCleanChild(parent, child).\n    assert(parent.childValues.has(child));\n    assert(!mightBeDirty(child));\n    const childValue = parent.childValues.get(child);\n    if (childValue.length === 0) {\n        parent.childValues.set(child, valueCopy(child.value));\n    }\n    else if (!valueIs(childValue, child.value)) {\n        parent.setDirty();\n    }\n    removeDirtyChild(parent, child);\n    if (mightBeDirty(parent)) {\n        return;\n    }\n    reportClean(parent);\n}\nfunction removeDirtyChild(parent, child) {\n    const dc = parent.dirtyChildren;\n    if (dc) {\n        dc.delete(child);\n        if (dc.size === 0) {\n            if (emptySetPool.length < POOL_TARGET_SIZE) {\n                emptySetPool.push(dc);\n            }\n            parent.dirtyChildren = null;\n        }\n    }\n}\n// Removes all children from this entry and returns an array of the\n// removed children.\nfunction forgetChildren(parent) {\n    if (parent.childValues.size > 0) {\n        parent.childValues.forEach((_value, child) => {\n            forgetChild(parent, child);\n        });\n    }\n    // Remove this parent Entry from any sets to which it was added by the\n    // addToSet method.\n    parent.forgetDeps();\n    // After we forget all our children, this.dirtyChildren must be empty\n    // and therefore must have been reset to null.\n    assert(parent.dirtyChildren === null);\n}\nfunction forgetChild(parent, child) {\n    child.parents.delete(parent);\n    parent.childValues.delete(child);\n    removeDirtyChild(parent, child);\n}\nfunction maybeSubscribe(entry, args) {\n    if (typeof entry.subscribe === \"function\") {\n        try {\n            maybeUnsubscribe(entry); // Prevent double subscriptions.\n            entry.unsubscribe = entry.subscribe.apply(null, args);\n        }\n        catch (e) {\n            // If this Entry has a subscribe function and it threw an exception\n            // (or an unsubscribe function it previously returned now throws),\n            // return false to indicate that we were not able to subscribe (or\n            // unsubscribe), and this Entry should remain dirty.\n            entry.setDirty();\n            return false;\n        }\n    }\n    // Returning true indicates either that there was no entry.subscribe\n    // function or that it succeeded.\n    return true;\n}\n//# sourceMappingURL=entry.js.map","import { parentEntrySlot } from \"./context.js\";\nimport { hasOwnProperty, maybeUnsubscribe, arrayFromSet, } from \"./helpers.js\";\nconst EntryMethods = {\n    setDirty: true,\n    dispose: true,\n    forget: true, // Fully remove parent Entry from LRU cache and computation graph\n};\nexport function dep(options) {\n    const depsByKey = new Map();\n    const subscribe = options && options.subscribe;\n    function depend(key) {\n        const parent = parentEntrySlot.getValue();\n        if (parent) {\n            let dep = depsByKey.get(key);\n            if (!dep) {\n                depsByKey.set(key, dep = new Set);\n            }\n            parent.dependOn(dep);\n            if (typeof subscribe === \"function\") {\n                maybeUnsubscribe(dep);\n                dep.unsubscribe = subscribe(key);\n            }\n        }\n    }\n    depend.dirty = function dirty(key, entryMethodName) {\n        const dep = depsByKey.get(key);\n        if (dep) {\n            const m = (entryMethodName &&\n                hasOwnProperty.call(EntryMethods, entryMethodName)) ? entryMethodName : \"setDirty\";\n            // We have to use arrayFromSet(dep).forEach instead of dep.forEach,\n            // because modifying a Set while iterating over it can cause elements in\n            // the Set to be removed from the Set before they've been iterated over.\n            arrayFromSet(dep).forEach(entry => entry[m]());\n            depsByKey.delete(key);\n            maybeUnsubscribe(dep);\n        }\n    };\n    return depend;\n}\n//# sourceMappingURL=dep.js.map","import { Trie } from \"@wry/trie\";\nimport { StrongCache } from \"@wry/caches\";\nimport { Entry } from \"./entry.js\";\nimport { parentEntrySlot } from \"./context.js\";\n// These helper functions are important for making optimism work with\n// asynchronous code. In order to register parent-child dependencies,\n// optimism needs to know about any currently active parent computations.\n// In ordinary synchronous code, the parent context is implicit in the\n// execution stack, but asynchronous code requires some extra guidance in\n// order to propagate context from one async task segment to the next.\nexport { bindContext, noContext, nonReactive, setTimeout, asyncFromGen, Slot, } from \"./context.js\";\n// A lighter-weight dependency, similar to OptimisticWrapperFunction, except\n// with only one argument, no makeCacheKey, no wrapped function to recompute,\n// and no result value. Useful for representing dependency leaves in the graph\n// of computation. Subscriptions are supported.\nexport { dep } from \"./dep.js\";\n// The defaultMakeCacheKey function is remarkably powerful, because it gives\n// a unique object for any shallow-identical list of arguments. If you need\n// to implement a custom makeCacheKey function, you may find it helpful to\n// delegate the final work to defaultMakeCacheKey, which is why we export it\n// here. However, you may want to avoid defaultMakeCacheKey if your runtime\n// does not support WeakMap, or you have the ability to return a string key.\n// In those cases, just write your own custom makeCacheKey functions.\nlet defaultKeyTrie;\nexport function defaultMakeCacheKey(...args) {\n    const trie = defaultKeyTrie || (defaultKeyTrie = new Trie(typeof WeakMap === \"function\"));\n    return trie.lookupArray(args);\n}\n// If you're paranoid about memory leaks, or you want to avoid using WeakMap\n// under the hood, but you still need the behavior of defaultMakeCacheKey,\n// import this constructor to create your own tries.\nexport { Trie as KeyTrie };\n;\nconst caches = new Set();\nexport function wrap(originalFunction, { max = Math.pow(2, 16), keyArgs, makeCacheKey = defaultMakeCacheKey, normalizeResult, subscribe, cache: cacheOption = StrongCache, } = Object.create(null)) {\n    const cache = typeof cacheOption === \"function\"\n        ? new cacheOption(max, entry => entry.dispose())\n        : cacheOption;\n    const optimistic = function () {\n        const key = makeCacheKey.apply(null, keyArgs ? keyArgs.apply(null, arguments) : arguments);\n        if (key === void 0) {\n            return originalFunction.apply(null, arguments);\n        }\n        let entry = cache.get(key);\n        if (!entry) {\n            cache.set(key, entry = new Entry(originalFunction));\n            entry.normalizeResult = normalizeResult;\n            entry.subscribe = subscribe;\n            // Give the Entry the ability to trigger cache.delete(key), even though\n            // the Entry itself does not know about key or cache.\n            entry.forget = () => cache.delete(key);\n        }\n        const value = entry.recompute(Array.prototype.slice.call(arguments));\n        // Move this entry to the front of the least-recently used queue,\n        // since we just finished computing its value.\n        cache.set(key, entry);\n        caches.add(cache);\n        // Clean up any excess entries in the cache, but only if there is no\n        // active parent entry, meaning we're not in the middle of a larger\n        // computation that might be flummoxed by the cleaning.\n        if (!parentEntrySlot.hasValue()) {\n            caches.forEach(cache => cache.clean());\n            caches.clear();\n        }\n        return value;\n    };\n    Object.defineProperty(optimistic, \"size\", {\n        get: () => cache.size,\n        configurable: false,\n        enumerable: false,\n    });\n    Object.freeze(optimistic.options = {\n        max,\n        keyArgs,\n        makeCacheKey,\n        normalizeResult,\n        subscribe,\n        cache,\n    });\n    function dirtyKey(key) {\n        const entry = key && cache.get(key);\n        if (entry) {\n            entry.setDirty();\n        }\n    }\n    optimistic.dirtyKey = dirtyKey;\n    optimistic.dirty = function dirty() {\n        dirtyKey(makeCacheKey.apply(null, arguments));\n    };\n    function peekKey(key) {\n        const entry = key && cache.get(key);\n        if (entry) {\n            return entry.peek();\n        }\n    }\n    optimistic.peekKey = peekKey;\n    optimistic.peek = function peek() {\n        return peekKey(makeCacheKey.apply(null, arguments));\n    };\n    function forgetKey(key) {\n        return key ? cache.delete(key) : false;\n    }\n    optimistic.forgetKey = forgetKey;\n    optimistic.forget = function forget() {\n        return forgetKey(makeCacheKey.apply(null, arguments));\n    };\n    optimistic.makeCacheKey = makeCacheKey;\n    optimistic.getKey = keyArgs ? function getKey() {\n        return makeCacheKey.apply(null, keyArgs.apply(null, arguments));\n    } : makeCacheKey;\n    return Object.freeze(optimistic);\n}\n//# sourceMappingURL=index.js.map","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); Object.defineProperty(Constructor, \"prototype\", { writable: false }); 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":["NoopHead","Object","value","enumerable","get","exports","default","__esModule","defineProperty","assign","module","KEY_PREFIX","FLUSH","REHYDRATE","PAUSE","PERSIST","PURGE","REGISTER","_typeof","obj","Symbol","iterator","constructor","prototype","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","push","apply","autoMergeLevel1","inboundState","originalState","reducedState","_ref","debug","newState","_objectSpread","target","i","arguments","length","source","forEach","key","configurable","writable","getOwnPropertyDescriptors","defineProperties","defaultSerialize","data","JSON","stringify","getStoredState_getStoredState","config","deserialize","transforms","storageKey","concat","undefined","keyPrefix","storage","x","defaultDeserialize","getItem","then","serialized","state","rawState","reduceRight","subState","transformer","out","err","serial","parse","warnIfRemoveError","persistReducer_ownKeys","persistReducer_objectSpread","persistReducer","baseReducer","version","stateReconciler","getStoredState","timeout","_persistoid","_purge","_paused","conditionalUpdate","_persist","rehydrated","update","action","rest","_objectWithoutProperties","excluded","_objectWithoutPropertiesLoose","sourceKeys","indexOf","sourceSymbolKeys","propertyIsEnumerable","call","type","_sealed","_rehydrate","payload","rehydrate","setTimeout","createPersistoid","serialize","blacklist","whitelist","throttle","writeFailHandler","lastState","stagedState","keysToProcess","timeIterator","writePromise","processNextKey","clearInterval","shift","endState","reduce","in","console","error","setItem","catch","onWriteFail","passWhitelistBlacklist","setInterval","flush","Promise","resolve","register","restoredState","migrate","s","v","migratedState","migrateErr","result","removeItem","_toConsumableArray","arr","_arrayWithoutHoles","Array","isArray","arr2","_iterableToArray","iter","toString","from","_nonIterableSpread","persistStore_ownKeys","persistStore_objectSpread","initialState","registry","bootstrapped","persistorReducer","firstIndex","splice","persistStore","store","options","cb","boostrappedCb","_pStore","redux","MT","enhancer","dispatch","rehydrateAction","persistor","getState","purge","results","purgeResult","all","flushResult","pause","persist","manualPersist","_defineProperties","props","descriptor","_getPrototypeOf","o","setPrototypeOf","getPrototypeOf","__proto__","_assertThisInitialized","self","_setPrototypeOf","p","_defineProperty","PersistGate","_PureComponent","staticProps","_classCallCheck","instance","Constructor","_getPrototypeOf2","_this","_len","args","_key","_persistor$getState","onBeforeLift","finally","setState","_unsubscribe","_inherits","subClass","superClass","create","subscribe","handlePersistorState","children","loading","react__WEBPACK_IMPORTED_MODULE_0__","PureComponent","_getStorage","reject","item","__webpack_require__","noop","storageType","hasStorage","testKey","e","noopStorage","Z","_default","_createWebStorage","EntityStore","Root","ApolloCache","assumeImmutableResults","getFragmentDoc","lib","re","graphql_fragments","Yk","max","sizes","Q","cache","weak","k","batch","updateResult","optimisticId","optimistic","performTransaction","recordOptimisticTransaction","transaction","transformDocument","document","transformForLink","identify","gc","modify","readQuery","read","tslib_es6","__assign","rootId","id","watchFragment","latestDiff","fragment","fragmentName","_a","otherOptions","__rest","query","diffOptions","returnPartialData","zen_observable_ts_module","y","observer","watch","immediate","callback","diff","equalByQuery","W","complete","missing","mergeDeep","bw","map","next","readFragment","writeQuery","write","dataId","writeFragment","updateQuery","updateFragment","globalThis","__DEV__","getMemoryInternals","Kb","MissingFieldError","_super","message","path","variables","__extends","Error","hasOwn","hasOwnProperty","isNullish","defaultDataIdFromObject","context","__typename","_id","keyObject","defaultConfig","dataIdFromObject","addTypename","resultCaching","canonizeResults","shouldCanonizeResults","TypeOrFieldNameRegExp","fieldNameFromStoreName","storeFieldName","match","storeValueIsStoreObject","objects","storeUtils","arrays","extractFragmentContext","fragments","fragmentMap","F","getFromAST","kU","lookupFragment","name","def","lookup","DELETE","delModifier","INVALIDATE","policies","group","rootIds","refs","getFieldValue","objectOrReference","maybeDeepFreeze","J","__ref","canRead","objOrRef","has","toReference","objOrIdOrRef","mergeIntoStore","kQ","ref","merge","toObject","fieldName","depend","storeObject","rootTypenamesById","Layer","parent","dependOnExistence","older","newer","existing","incoming","globals","kG","merged","w0","storeObjectReconciler","caching","fieldsToDirty_1","__exists","hasKeyArgs","dirty","fields","changedFields_1","needToMerge_1","allDeleted_1","sharedDetails_1","isReference","readField","fieldNameOrOptions","fieldValue","newValue","getStorage","checkReference","warn","seenReference","someNonReference","_i","newValue_1","delete","typename","getStoreFieldName","evict","limit","evicted","clear","replace","extract","extraRootIds","getRootIdSet","__META","sort","newData","rest_1","retain","release","count","ids","Set","add","snapshot","findChildRefIds","idsToRemove","root_1","found_1","root","workSet_1","child","makeCacheKey","keyMaker","lookupArray","CacheGroup","d","resetCaching","dP","trie_lib","B","canUse","mr","maybeDependOnExistenceOfEntity","entityId","supportsResultCaching","_b","seed","stump","Stump","storageTrie","addLayer","layerId","replay","removeLayer","ownStoreObject","parentStoreObject","equality_lib","D","fromParent","existingObject","incomingObject","property","existingValue","incomingValue","ObjectCanon","known","sy","WeakSet","pool","passes","WeakMap","keysByJSON","Map","empty","admit","isKnown","pass","copy","slice","set","original","array","node","freeze","proto_1","array_1","sortedKeys","json","firstValueIndex_1","sorted","obj_1","execSelectionSetKeyArgs","selectionSet","StoreReader","knownResults","compact","canon","executeSelectionSet","peekArgs","other","peek","enclosingRef","execSelectionSetImpl","resultCacheMaxSize","keyArgs","varString","executeSubSelectedArray","execSubSelectedArrayImpl","field","resetCanon","diffQueryAgainstStore","_c","_d","O4","iW","rootRef","execResult","p$","canonicalStringify","firstMissing","tree","_","isFresh","latest","objectsToMerge","missingMerger","handleMissing","resultName","rootIdsByTypename","workSet","selections","selection","directives","LZ","My","u2","transform","Gw","added","hi","kind","kinds","h","FRAGMENT_SPREAD","_K","fragmentMatches","finalResult","frozen","childResult","assertSelectionSetForIdValue","values","specifierInfoCache","lookupSpecifierInfo","spec","cacheKey","keyFieldsFnFromSpecifier","specifier","info","keyFieldsFn","collectSpecifierPaths","schemaKeyPath","extracted","extractKeyPath","extractKey","join","keyArgsFnFromSpecifier","keyArgsFn","suffix","keyPath","firstKey","firstChar","charAt","O","directiveName_1","find","directiveArgs","NC","variableName","varKeyPath","extractor","merger","getSpecifierPaths","paths","paths_1","currentPath_1","collected","toMerge","normalize","reducer","argsFromFieldSpecifier","nullKeyFieldsFn","simpleKeyArgsFn","_args","mergeTrueFn","mergeObjects","mergeFalseFn","Policies","typePolicies","toBeAdded","supertypeMap","fuzzySubtypes","usingPossibleTypes","setRootTypename","possibleTypes","addPossibleTypes","addTypePolicies","partialContext","ROOT_QUERY","normalizeReadFieldOptions","policy","getTypePolicy","keyFn","specifierOrId","String","queryType","mutationType","subscriptionType","updateTypePolicy","keyFields","setMerge","getFieldPolicy","which","toUpperCase","old","supertype","getSupertypeSet","subtype","RegExp","policy_1","supertypes_1","size","regExp","fuzzy","test","fuzzySupertypes","inbox","createIfMissing","fieldPolicies","supertypeSet","typeCondition","typenameSupertypeSet","workQueue_1","maybeEnqueue_1","needToCheckFuzzySubtypes","checkingFuzzySubtypes","selectionSetMatchesResult","every","fuzzyString","fieldSpec","specifierOrString","vf","PT","readOptions","makeFieldFunctionOptions","reactiveVars","ab","withValue","getReadFunction","getMergeFunction","parentTypename","childTypename","runMergeFunction","makeMergeObjectsFunction","overwrite","readFieldArgs","argc","stringifyForDisplay","eType","iType","getContextFlavor","clientOnly","deferred","flavored","flavors","StoreWriter","reader","writeToStore","operationDefinition","getOperationDefinition","getDefaultValues","written","incomingById","processSelectionSet","mergeTree","newInvariantError","fieldNodeSet","entityRef","makeReference","applied","applyMerges","fieldsWithSelectionSets_1","hasMergeFunction_1","childTree","Boolean","warnAboutDataLoss","existingRef","incomingObj","getChild","equal","parentType","typeDotName","warnings","childTypenames","includes","invariant","getTypenameFromResult","result_1","flattenFields","resultKeyNameFromField","getChildMergeTree","processFieldValue","maybeRecycleChildMergeTree","addTypenameToDocument","dataRef","sets","previous_1","mergeMergeTrees","left","right","mergeTreeIsEmpty","needToMergeMaps","remainingRightKeys_1","leftTree","cloneDeep","fieldMap","limitingTrie","Trie","flatten","inheritedContext","visitedNode","visited","shouldInclude","isNonEmptyArray","dir","argumentsObjectFromField","if","isField","getFragmentFromSelection","Kind","getStorageArgs","e_1","i_1","getValue_1","eVal","iVal","aVal","pop","emptyMergeTreePool","InMemoryCache","watches","addTypenameTransform","DocumentTransform","A","makeVar","QS","txCount","init","rootStore","optimisticData","resetResultCache","resetResultIdentities","previousReader","storeReader","storeWriter","maybeBroadcastWatch","c","broadcastWatch","restore","broadcast","broadcastWatches","_v","li","forget","reset","print","S","resetCache","resetCaches","discardWatches","removeOptimistic","idToRemove","newOptimisticData","onWatchUpdated","perform","layer","alreadyDirty","addFragmentsToDocument","lastDiff","fromOptimisticTransaction","q4","cacheSlot","optimism__WEBPACK_IMPORTED_MODULE_0__","g7","cacheInfoMap","getCacheInfo","vars","dep","forgetCache","rv","recallCache","attachCache","caches","listeners","oldListeners","listener","getValue","attach","onNextChange","execute","ApolloLink","HttpLink","createHttpLink","L","request","asyncMap","observable","mapFn","catchFn","promiseQueue","makeCallback","examiner","arg","both","closed","handler","sub","unsubscribe","graphQLResultHasError","errors","getGraphQLErrorsFromResult","graphQLErrors","incrementalResult","GG","incremental","iterateObserversSafely","observers","method","argument","observersWithMethod","obs","fixObservableSubclass","subclass","aS","species","isPromiseLike","Concast","sources","addObserver","removeObserver","promise","handlers","notify","nextResultListeners","cancel","reason","iterable","start","deliverLastMessage","nextOrError","beforeNext","called","ObservableQuery_assign","ObservableQuery_hasOwnProperty","ObservableQuery","queryManager","queryInfo","subObserver","_subscription","_observer","defaultSubscriptionObserverErrorCallback","first","last","reobserve","tearDownQuery","subscriptions","waitForOwnResult","skipCacheDataFor","fetchPolicy","isTornDown","subscribeToMore","bind","defaultOptions","watchQuery","defaultFetchPolicy","_e","_f","initialFetchPolicy","queryId","generateQueryId","opDef","$H","queryName","lastQuery","removeQuery","subscription","resetDiff","getCurrentResult","saveAsLastResult","lastResult","getLastResult","networkStatus","core_networkStatus","Ie","ready","Oj","getDocumentInfo","hasForcedResolvers","getDiff","partial","partialRefetch","logMissingFieldErrors","updateLastResult","isDifferentFromLastResult","newResult","hasNonreactiveDirective","getLast","variablesMustMatch","getLastError","resetLastResults","resetQueryStoreErrors","resetErrors","refetch","reobserveOptions","pollInterval","queryDef","variableDefinitions","some","variable","resetLastWrite","fetchMore","fetchMoreOptions","combinedOptions","qid","originalNetworkStatus","notifyOnNetworkStatusChange","observe","updatedQuerySet","isCached","fetchQuery","fetchMoreResult","previous","reportResult","reobserveCacheFirst","startGraphQLSubscription","subscriptionData","onError","setOptions","newOptions","silentSetOptions","mergedOptions","setVariables","broadcastQueries","startPolling","updatePolling","stopPolling","applyNextFetchPolicy","nextFetchPolicy","fetch","newNetworkStatus","setObservableQuery","ssrMode","pollingInfo","hasObservers","clearTimeout","interval","maybeFetch","skipPollAttempt","poll","X","reobserveAsConcast","useDisposableConcast","oldVariables","oldFetchPolicy","finishWaitingForOwnResult","concast","fromLink","client_errors","MS","cA","networkError","reportError","resubscribeAfterError","lastError","isDifferent","errorResult","stopQuery","obsQuery","currentFetchPolicy","stack","destructiveMethodCounts","wrapDestructiveCacheMethod","methodName","cancelNotifyTimeout","QueryInfo","lastRequestId","stopped","observableQuery","getDiffOptions","updateWatch","oq","updateLastDiff","setDiff","oldDiff","notifyTimeout","oqListener","shouldNotify","stop","watchOptions","watcher","lastWatch","lastWrite","shouldWrite","dmCount","markResult","cacheWriteBehavior","mergedData","mT","hasNext","shouldWriteResult","errorPolicy","markReady","markError","ignoreErrors","writeWithErrors","QueryManager_hasOwnProperty","IGNORE","QueryManager","clientAwareness","queries","fetchCancelFns","transformCache","queryIdCounter","requestIdCounter","mutationIdCounter","inFlightLinkObservables","defaultDocumentTransform","link","queryDeduplication","localState","documentTransform","defaultContext","onBroadcast","mutationStore","_info","stopQueryNoBroadcast","cancelPendingFetches","mutate","__awaiter","mutationId","hasClientExports","mutationStoreValue","isOptimistic","mutation","optimisticResponse","updateQueries","refetchQueries","awaitRefetchQueries","updateWithProxyFn","onQueryUpdated","_g","_h","keepRootFields","__generator","_j","label","generateMutationId","getVariables","addExportedVariables","sent","markMutationOptimistic","getObservableFromLink","storeResult","markMutationResult","cacheWrites","skipCache","asQuery","updateQueries_1","updater","currentQueryResult","nextQueryResult","mutationResult","rY","queryVariables","results_1","updateCache","isFinalResult","M0","include","fetchConcastWithInfo","getQueryStore","cacheEntry","mj","shouldForceResolvers","FS","clientQuery","serverQuery","bi","remove","defaultVars","definitions","operation","generateRequestId","stopQueryInStore","stopQueryInStoreNoBroadcast","clearStore","getObservableQueries","queryNamesAndDocs","legacyQueryOptions","desc","JW","makeUniqueId","getQuery","included","nameOrDoc","reFetchObservableQueries","includeStandby","observableQueryPromises","extensions","makeObservable","hasErrors","hasProtocolErrors","ls","protocolErrors","YG","observablePromise_1","getLocalState","deduplication","inFlightLinkObservables_1","operationName","prepareContext","forceFetch","printedServerQuery_1","varJson_1","entry","of","runResolvers","remoteResult","getResultsFromLink","requestId","linkDocument","aqr","containsDataFromLink","defaults","normalized","fromVariables","sourcesWithInfo","fetchQueryByPolicy","cleanupCancelFn","includedQueriesById","refetchWritePolicy","oldNetworkStatus","readCache","resultsFromCache","fromData","onlyRunForcedResolvers","resolved","resultsFromLink","newContext","isSelectionNode","FIELD","INLINE_FRAGMENT","LocalState","client","resolvers","fragmentMatcher","selectionsToResolveCache","addResolvers","setFragmentMatcher","resolverGroup","Ee","setResolvers","getResolvers","resolveDocument","localResult","getFragmentMatcher","ob","getCacheKey","document_1","buildRootValueFromCache","exportedVariables","forceResolvers","visitor","Vn","Directive","enter","$_","aL","rootValue_1","rootValue","mainDefinition","selectionsToResolve","definitionOperation","defaultOperationType","execContext","collectSelectionsToResolve","resolveSelectionSet","isClientFieldDescendant","resultsToMerge","resolveField","fieldResult","Ao","fragmentResult","aliasedFieldName","aliasUsed","defaultResult","resultPromise","resolverType","resolverMap","directive","isClientField","resolveSubSelectedArray","isSingleASTNode","collectByDefinition","definitionNode","matches_1","__","___","ancestors","FragmentSpread","spread","fragmentSelections","hasSuggestedDevtools","ApolloClient","resetStoreCallbacks","clearStoreCallbacks","uri","credentials","headers","ssrForceFetchDelay","connectToDevTools","typeDefs","clientAwarenessName","clientAwarenessVersion","devtools","disableNetworkFetches","devtoolsConfig","enabled","resetStore","devToolsHookCb","mutations","dataWithOptimisticResults","window","windowWithDevTools","devtoolsSymbol","for","__APOLLO_CLIENT__","top","location","protocol","__APOLLO_DEVTOOLS_GLOBAL_HOOK__","nav","navigator","ua","userAgent","url","log","mergeOptions","__actionHookForDevTools","__requestRaw","fn","onResetStore","onClearStore","serializedState","setLocalStateFragmentMatcher","setLink","newLink","su","aData","aRest","tslib__WEBPACK_IMPORTED_MODULE_1__","bData","bRest","_wry_equality__WEBPACK_IMPORTED_MODULE_0__","equalBySelectionSet","aResult","bResult","seenSelections","_utilities_index_js__WEBPACK_IMPORTED_MODULE_4__","selectionHasNonreactiveDirective","_utilities_index_js__WEBPACK_IMPORTED_MODULE_5__","resultKey","aResultChild","bResultChild","childSelectionSet","aChildIsArray","bChildIsArray","length_1","_utilities_index_js__WEBPACK_IMPORTED_MODULE_3__","_utilities_index_js__WEBPACK_IMPORTED_MODULE_2__","directiveIsNonreactive","NetworkStatus","isNetworkRequestInFlight","setContext","setter","_core_index_js__WEBPACK_IMPORTED_MODULE_0__","forward","handle","req","getContext","passthrough","op","toLink","isTerminating","links","split","leftLink","rightLink","transformedOperation","starting","validateOperation","OPERATION_FIELDS","second","firstLink","nextLink","setOnError","errorHandler","_utilities_index_js__WEBPACK_IMPORTED_MODULE_1__","retriedSub","retriedResult","response","ErrorLink","tslib__WEBPACK_IMPORTED_MODULE_2__","serializeFetchParameter","parseError","readerIterator","DN","asyncIterator","throwServerError","statusCode","status","parseAndCheckHttpResponse_hasOwnProperty","parseJsonBody","bodyText","getResult","checkFetcher","fetcher","fallbackHttpConfig","http","includeQuery","includeExtensions","preserveHeaderCase","accept","defaultPrinter","ast","printer","fromError","errorValue","backupFetch","wY","linkOptions","preferredFetch","useGETForQueries","includeUnusedVariables","requestOptions","linkConfig","fetchOptions","fallbackURI","unusedNames","controller","chosenURI","clientAwarenessHeaders","name_1","contextHeaders","contextConfig","transformedQuery","selectHttpOptionsAndBodyInternal","configs","removeDuplicateHeaders","normalizedHeaders_1","toLowerCase","headerData","originalName","normalizedHeaders","body","Variable","signal","AbortController","isSubscription","hasDefer","acceptHeader","rewriteURIForGET","queryParams","addQueryParam","encodeURIComponent","serializedVariables","serializedExtensions","preFragment","fragmentStart","substr","queryParamsPrefix","newURI","currentFetch","observerNext","ctype","readMultipartBody","nextValue","decoder","contentType","delimiter","boundaryVal","boundary","buffer","running","done","chunk","searchFrom","contentType_1","TextDecoder","substring","trim","responseIterator","getReader","stream","arrayBuffer","pipe","nodeStreamIterator","cleanup","waiting","onData","shiftedArr","pair","onEnd","removeListener","on","decode","headerText","headersInit","line","yU","parseAndCheckHttpResponse","text","operations","abort","ApolloProvider","ApolloContext","_ApolloContext_js__WEBPACK_IMPORTED_MODULE_2__","K","parentContext","rehackt__WEBPACK_IMPORTED_MODULE_1__","useContext","useMemo","tslib__WEBPACK_IMPORTED_MODULE_3__","_utilities_globals_index_js__WEBPACK_IMPORTED_MODULE_0__","createElement","Provider","sortingMap","stableObjectReplacer","_utilities_caching_index_js__WEBPACK_IMPORTED_MODULE_0__","_utilities_caching_index_js__WEBPACK_IMPORTED_MODULE_1__","proto","everyKeyInOrder","unsortedKey","sortedKey","sortedObject_1","_caching_getMemoryInternals_js__WEBPACK_IMPORTED_MODULE_2__","zP","cloneDeepHelper","val","seen","copy_1","copy_2","isExecutionPatchIncrementalResult","isExecutionPatchResult","isApolloPayloadResult","_objects_js__WEBPACK_IMPORTED_MODULE_0__","mergeIncrementalData","prevResult","_mergeDeep_js__WEBPACK_IMPORTED_MODULE_1__","_arrays_js__WEBPACK_IMPORTED_MODULE_2__","parent_1","isNumericKey","shallowFreeze","isFrozen","TypeError","getOwnPropertyNames","mergeDeepArray","DeepMerger","defaultReconciler","reconciler","isObject","pastCopies","sourceKey","targetValue","__spreadArray","shallowCopyForMerge","identity","resultCache","_common_canUse_js__WEBPACK_IMPORTED_MODULE_3__","cached","predicate","stableCacheKeys_1","_wry_trie__WEBPACK_IMPORTED_MODULE_0__","performWork","optimism__WEBPACK_IMPORTED_MODULE_2__","cacheKeys","_globals_index_js__WEBPACK_IMPORTED_MODULE_1__","_caching_index_js__WEBPACK_IMPORTED_MODULE_4__","_wry_caches__WEBPACK_IMPORTED_MODULE_5__","_getFromAST_js__WEBPACK_IMPORTED_MODULE_6__","A$","transformedDocument","otherTransform","getInclusionDirectives","directiveArguments","directiveName","_globals_index_js__WEBPACK_IMPORTED_MODULE_0__","ifArgument","ifValue","evaledValue","hasDirectives","names","nameSet","uniqueCount","graphql__WEBPACK_IMPORTED_MODULE_1__","getFragmentQueryDocument","actualFragmentName","definition","createFragmentMap","symTable","checkDocument","doc","getOperationName","getFragmentDefinitions","getQueryDefinition","getFragmentDefinition","fragmentDef","getMainDefinition","queryDoc","fragmentDefinition","defaultValues","defs","defaultValue","_storeUtils_js__WEBPACK_IMPORTED_MODULE_1__","vb","printCache","escapedRegExp","escapedReplacer","str","escapeSequences","charCodeAt","printDocASTReducer","Name","leave","Document","OperationDefinition","varDefs","wrap","prefix","VariableDefinition","SelectionSet","block","Field","alias","argsLine","indent","Argument","InlineFragment","FragmentDefinition","IntValue","FloatValue","StringValue","isBlockString","blockString","BooleanValue","NullValue","EnumValue","ListValue","ObjectValue","ObjectField","NamedType","ListType","NonNullType","SchemaDefinition","description","operationTypes","OperationTypeDefinition","ScalarTypeDefinition","ObjectTypeDefinition","interfaces","FieldDefinition","hasMultilineItems","InputValueDefinition","InterfaceTypeDefinition","UnionTypeDefinition","types","EnumTypeDefinition","EnumValueDefinition","InputObjectTypeDefinition","DirectiveDefinition","repeatable","locations","SchemaExtension","ScalarTypeExtension","ObjectTypeExtension","InterfaceTypeExtension","UnionTypeExtension","EnumTypeExtension","InputObjectTypeExtension","maybeArray","separator","_maybeArray$filter$jo","maybeString","end","_maybeArray$some","print_print","fragments_1","_fragments_js__WEBPACK_IMPORTED_MODULE_3__","isDocumentNode","_common_objects_js__WEBPACK_IMPORTED_MODULE_1__","valueToObjectRepresentation","argObj","isIntValue","Number","isBooleanValue","nestedArgObj_1","variableValue","listValue","nestedArgArrayObj","storeKeyNameFromField","directivesObj","getStoreKeyName","KNOWN_DIRECTIVES","storeKeyNameStringify","_common_canonicalStringify_js__WEBPACK_IMPORTED_MODULE_2__","filterKeys","filteredArgs_1","completeFieldName","stringifiedArgs","setStringify","argObj_1","isInlineFragment","TYPENAME_FIELD","NAME","makeInUseGetterFunction","defaultKey","inUse","fragmentSpreads","removeDirectivesFromDocument","_getFromAST_js__WEBPACK_IMPORTED_MODULE_2__","tests","getInUseByOperationName","getInUseByFragmentName","getInUse","ancestor","_common_arrays_js__WEBPACK_IMPORTED_MODULE_4__","OPERATION_DEFINITION","FRAGMENT_DEFINITION","operationCount","directiveMatcher","testConfig","shouldRemoveField","nodeDirectives","originalFragmentDefsByPath","firstVisitMadeChanges","fieldOrInlineFragmentVisitor","docWithoutDirectiveSubtrees","graphql__WEBPACK_IMPORTED_MODULE_5__","_parent","_path","removed","populateTransitiveVars","transitiveVars","childFragmentName","varName","allFragmentNamesUsed","enterVisitor","usedVariableNames_1","tslib__WEBPACK_IMPORTED_MODULE_6__","varDef","isEmpty","pD","_storeUtils_js__WEBPACK_IMPORTED_MODULE_7__","lastIndexOf","buildQueryFromSelectionSet","removeClientSetsFromDocument","defaultMakeData","weakness","makeData","getChildTrie","peekArray","len","mapFor","removeArray","head","strong","isObjRef","BREAK","visit","visitorKeys","_ast_mjs__WEBPACK_IMPORTED_MODULE_0__","h8","enterLeaveMap","_kinds_mjs__WEBPACK_IMPORTED_MODULE_1__","getEnterLeaveForKind","kindVisitor","inArray","index","edits","_enterLeaveMap$get","_enterLeaveMap$get2","_node$kind","isLeaving","isEdited","editOffset","editKey","editValue","arrayKey","prev","UG","_jsutils_devAssert_mjs__WEBPACK_IMPORTED_MODULE_2__","a","_jsutils_inspect_mjs__WEBPACK_IMPORTED_MODULE_3__","visitFn","defaultKeyTrie","lib_hasOwnProperty","currentContext","MISSING_VALUE","idCounter","maybe","ignored","globalKey","host","global","Slot","globalHost","Date","now","Math","random","hasValue","slots","thisArg","saved","noContext","parentEntrySlot","helpers_hasOwnProperty","arrayFromSet","maybeUnsubscribe","entryOrDep","emptySetPool","assert","condition","optionalMessage","valueIs","b","valueGet","Entry","parents","childValues","dirtyChildren","recomputing","deps","mightBeDirty","rememberParent","recompute","forgetChildren","recomputeNewValue","maybeSubscribe","setDirty","eachParent","reportCleanChild","reportDirtyChild","dispose","forgetChild","dependOn","forgetDeps","oldValueCopy","normalizeResult","parentCount","parentWasClean","childValue","removeDirtyChild","dc","_value","EntryMethods","depsByKey","entryMethodName","m","defaultMakeCacheKey","trie","originalFunction","cacheOption","clean","dirtyKey","peekKey","forgetKey","getKey","_arrayLikeToArray","_createClass","protoProps","hasSymbols","hasSymbol","getSymbol","SymbolIterator","SymbolObservable","SymbolSpecies","getMethod","getSpecies","ctor","Observable","hostReportError","enqueue","cleanupSubscription","_cleanup","closeSubscription","_queue","_state","notifySubscription","onNotify","flushSubscription","queue","Subscription","subscriber","subscriptionObserver","SubscriptionObserver","_proto","_proto2","_subscriber","_proto3","_this2","_this3","_this4","C","hasSeed","acc","_this5","startNext","flatMap","_this6","outer","inner","completeIfDone","_step","_iterator","_createForOfIteratorHelperLoose","allowArrayLike","it","_unsupportedIterableToArray","minLen","n","_len2","items","_key2","symbol"],"sourceRoot":""}