{"version":3,"file":"js/1209.a8cf9c2c.js","mappings":"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","sources":["webpack://console-mf-users-front/../throttle.js","webpack://console-mf-users-front/../debounce.js","webpack://console-mf-users-front/../src/useApolloClient.ts","webpack://console-mf-users-front/../src/util/paramToRef.ts","webpack://console-mf-users-front/../src/util/paramToReactive.ts","webpack://console-mf-users-front/../src/util/useEventHook.ts","webpack://console-mf-users-front/../src/util/loadingTracking.ts","webpack://console-mf-users-front/../src/util/toApolloError.ts","webpack://console-mf-users-front/../src/util/env.ts","webpack://console-mf-users-front/../src/useQuery.ts","webpack://console-mf-users-front/../src/useLazyQuery.ts","webpack://console-mf-users-front/../src/useMutation.ts","webpack://console-mf-users-front/../src/useSubscription.ts","webpack://console-mf-users-front/../src/useResult.ts","webpack://console-mf-users-front/../src/useLoading.ts","webpack://console-mf-users-front/./node_modules/tslib/tslib.es6.js","webpack://console-mf-users-front/../errors/index.ts","webpack://console-mf-users-front/../../../src/utilities/common/arrays.ts","webpack://console-mf-users-front/../src/invariant.ts","webpack://console-mf-users-front/../../../src/utilities/globals/maybe.ts","webpack://console-mf-users-front/../../../src/utilities/globals/global.ts","webpack://console-mf-users-front/../../../src/utilities/globals/DEV.ts","webpack://console-mf-users-front/./node_modules/ts-invariant/process/index.js","webpack://console-mf-users-front/../../../src/utilities/globals/fix-graphql.ts","webpack://console-mf-users-front/../../../src/utilities/globals/index.ts","webpack://console-mf-users-front/./node_modules/vue-demi/lib/index.mjs"],"sourcesContent":["/* eslint-disable no-undefined,no-param-reassign,no-shadow */\n\n/**\n * Throttle execution of a function. Especially useful for rate limiting\n * execution of handlers on events like resize and scroll.\n *\n * @param  {number}    delay -          A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.\n * @param  {boolean}   [noTrailing] -   Optional, defaults to false. If noTrailing is true, callback will only execute every `delay` milliseconds while the\n *                                    throttled-function is being called. If noTrailing is false or unspecified, callback will be executed one final time\n *                                    after the last throttled-function call. (After the throttled-function has not been called for `delay` milliseconds,\n *                                    the internal counter is reset).\n * @param  {Function}  callback -       A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,\n *                                    to `callback` when the throttled-function is executed.\n * @param  {boolean}   [debounceMode] - If `debounceMode` is true (at begin), schedule `clear` to execute after `delay` ms. If `debounceMode` is false (at end),\n *                                    schedule `callback` to execute after `delay` ms.\n *\n * @returns {Function}  A new, throttled, function.\n */\nexport default function (delay, noTrailing, callback, debounceMode) {\n\t/*\n\t * After wrapper has stopped being called, this timeout ensures that\n\t * `callback` is executed at the proper times in `throttle` and `end`\n\t * debounce modes.\n\t */\n\tlet timeoutID;\n\tlet cancelled = false;\n\n\t// Keep track of the last time `callback` was executed.\n\tlet lastExec = 0;\n\n\t// Function to clear existing timeout\n\tfunction clearExistingTimeout() {\n\t\tif (timeoutID) {\n\t\t\tclearTimeout(timeoutID);\n\t\t}\n\t}\n\n\t// Function to cancel next exec\n\tfunction cancel() {\n\t\tclearExistingTimeout();\n\t\tcancelled = true;\n\t}\n\n\t// `noTrailing` defaults to falsy.\n\tif (typeof noTrailing !== 'boolean') {\n\t\tdebounceMode = callback;\n\t\tcallback = noTrailing;\n\t\tnoTrailing = undefined;\n\t}\n\n\t/*\n\t * The `wrapper` function encapsulates all of the throttling / debouncing\n\t * functionality and when executed will limit the rate at which `callback`\n\t * is executed.\n\t */\n\tfunction wrapper(...arguments_) {\n\t\tlet self = this;\n\t\tlet elapsed = Date.now() - lastExec;\n\n\t\tif (cancelled) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Execute `callback` and update the `lastExec` timestamp.\n\t\tfunction exec() {\n\t\t\tlastExec = Date.now();\n\t\t\tcallback.apply(self, arguments_);\n\t\t}\n\n\t\t/*\n\t\t * If `debounceMode` is true (at begin) this is used to clear the flag\n\t\t * to allow future `callback` executions.\n\t\t */\n\t\tfunction clear() {\n\t\t\ttimeoutID = undefined;\n\t\t}\n\n\t\tif (debounceMode && !timeoutID) {\n\t\t\t/*\n\t\t\t * Since `wrapper` is being called for the first time and\n\t\t\t * `debounceMode` is true (at begin), execute `callback`.\n\t\t\t */\n\t\t\texec();\n\t\t}\n\n\t\tclearExistingTimeout();\n\n\t\tif (debounceMode === undefined && elapsed > delay) {\n\t\t\t/*\n\t\t\t * In throttle mode, if `delay` time has been exceeded, execute\n\t\t\t * `callback`.\n\t\t\t */\n\t\t\texec();\n\t\t} else if (noTrailing !== true) {\n\t\t\t/*\n\t\t\t * In trailing throttle mode, since `delay` time has not been\n\t\t\t * exceeded, schedule `callback` to execute `delay` ms after most\n\t\t\t * recent execution.\n\t\t\t *\n\t\t\t * If `debounceMode` is true (at begin), schedule `clear` to execute\n\t\t\t * after `delay` ms.\n\t\t\t *\n\t\t\t * If `debounceMode` is false (at end), schedule `callback` to\n\t\t\t * execute after `delay` ms.\n\t\t\t */\n\t\t\ttimeoutID = setTimeout(\n\t\t\t\tdebounceMode ? clear : exec,\n\t\t\t\tdebounceMode === undefined ? delay - elapsed : delay\n\t\t\t);\n\t\t}\n\t}\n\n\twrapper.cancel = cancel;\n\n\t// Return the wrapper function.\n\treturn wrapper;\n}\n","/* eslint-disable no-undefined */\n\nimport throttle from './throttle';\n\n/**\n * Debounce execution of a function. Debouncing, unlike throttling,\n * guarantees that a function is only executed a single time, either at the\n * very beginning of a series of calls, or at the very end.\n *\n * @param  {number}   delay -         A zero-or-greater delay in milliseconds. For event callbacks, values around 100 or 250 (or even higher) are most useful.\n * @param  {boolean}  [atBegin] -     Optional, defaults to false. If atBegin is false or unspecified, callback will only be executed `delay` milliseconds\n *                                  after the last debounced-function call. If atBegin is true, callback will be executed only at the first debounced-function call.\n *                                  (After the throttled-function has not been called for `delay` milliseconds, the internal counter is reset).\n * @param  {Function} callback -      A function to be executed after delay milliseconds. The `this` context and all arguments are passed through, as-is,\n *                                  to `callback` when the debounced-function is executed.\n *\n * @returns {Function} A new, debounced function.\n */\nexport default function (delay, atBegin, callback) {\n\treturn callback === undefined\n\t\t? throttle(delay, atBegin, false)\n\t\t: throttle(delay, callback, atBegin !== false);\n}\n","import { getCurrentInstance, inject } from 'vue-demi'\nimport { ApolloClient } from '@apollo/client/core'\n\nexport const DefaultApolloClient = Symbol('default-apollo-client')\nexport const ApolloClients = Symbol('apollo-clients')\n\ntype ClientId = string\ntype ClientDict<T> = Record<ClientId, ApolloClient<T>>\n\ntype ResolveClient<TCacheShape, TReturn = ApolloClient<TCacheShape>> = (clientId?: ClientId) => TReturn\ntype NullableApolloClient<TCacheShape> = ApolloClient<TCacheShape> | undefined\n\nexport interface UseApolloClientReturn<TCacheShape> {\n  resolveClient: ResolveClient<TCacheShape>\n  readonly client: ApolloClient<TCacheShape>\n}\n\nfunction resolveDefaultClient<T> (providedApolloClients: ClientDict<T> | null, providedApolloClient: ApolloClient<T> | null): NullableApolloClient<T> {\n  const resolvedClient = providedApolloClients\n    ? providedApolloClients.default\n    : (providedApolloClient ?? undefined)\n  return resolvedClient\n}\n\nfunction resolveClientWithId<T> (providedApolloClients: ClientDict<T> | null, clientId: ClientId): NullableApolloClient<T> {\n  if (!providedApolloClients) {\n    throw new Error(`No apolloClients injection found, tried to resolve '${clientId}' clientId`)\n  }\n  return providedApolloClients[clientId]\n}\n\nexport function useApolloClient<TCacheShape = any> (clientId?: ClientId): UseApolloClientReturn<TCacheShape> {\n  let resolveImpl: ResolveClient<TCacheShape, NullableApolloClient<TCacheShape>>\n\n  // Save current client in current closure scope\n  const savedCurrentClients = currentApolloClients\n\n  if (!getCurrentInstance()) {\n    resolveImpl = (id?: ClientId) => {\n      if (id) {\n        return resolveClientWithId(savedCurrentClients, id)\n      }\n      return resolveDefaultClient(savedCurrentClients, savedCurrentClients.default)\n    }\n  } else {\n    const providedApolloClients: ClientDict<TCacheShape> | null = inject(ApolloClients, null)\n    const providedApolloClient: ApolloClient<TCacheShape> | null = inject(DefaultApolloClient, null)\n\n    resolveImpl = (id?: ClientId) => {\n      if (id) {\n        const client = resolveClientWithId(providedApolloClients, id)\n        if (client) {\n          return client\n        }\n        return resolveClientWithId(savedCurrentClients, id)\n      }\n      const client = resolveDefaultClient(providedApolloClients, providedApolloClient)\n      if (client) {\n        return client\n      }\n      return resolveDefaultClient(savedCurrentClients, savedCurrentClients.default)\n    }\n  }\n\n  function resolveClient (id: ClientId | undefined = clientId) {\n    const client = resolveImpl(id)\n    if (!client) {\n      throw new Error(\n        `Apollo client with id ${\n          id ?? 'default'\n        } not found. Use provideApolloClient() if you are outside of a component setup.`,\n      )\n    }\n    return client\n  }\n\n  return {\n    resolveClient,\n    get client () {\n      return resolveClient()\n    },\n  }\n}\n\nlet currentApolloClients: ClientDict<any> = {}\n\nexport function provideApolloClient<TCacheShape = any> (client: ApolloClient<TCacheShape>) {\n  currentApolloClients = {\n    default: client,\n  }\n  return function <TFnResult = any> (fn: () => TFnResult) {\n    const result = fn()\n    currentApolloClients = {}\n    return result\n  }\n}\n\nexport function provideApolloClients<TCacheShape = any> (clients: ClientDict<TCacheShape>) {\n  currentApolloClients = clients\n  return function <TFnResult = any> (fn: () => TFnResult) {\n    const result = fn()\n    currentApolloClients = {}\n    return result\n  }\n}\n","import { Ref, isRef, computed, ref } from 'vue-demi'\nimport { ReactiveFunction } from './ReactiveFunction'\n\nexport function paramToRef<T> (param: T | Ref<T> | ReactiveFunction<T>): Ref<T> {\n  if (isRef(param)) {\n    return param\n  } else if (typeof param === 'function') {\n    return computed(param as ReactiveFunction<T>)\n  } else {\n    return ref(param) as Ref<T>\n  }\n}\n","import { Ref, isRef, reactive, computed } from 'vue-demi'\nimport { ReactiveFunction } from './ReactiveFunction'\n\n// eslint-disable-next-line @typescript-eslint/ban-types\ntype TObject = object\n\nexport function paramToReactive<T extends TObject> (param: T | Ref<T> | ReactiveFunction<T>): T | Ref<T> {\n  if (isRef(param)) {\n    return param\n  } else if (typeof param === 'function') {\n    return computed(param as ReactiveFunction<T>)\n  } else if (param) {\n    return reactive(param) as T\n  } else {\n    return param\n  }\n}\n","export function useEventHook<TParam = any> () {\n  const fns: Array<(param: TParam) => void> = []\n\n  function on (fn: (param: TParam) => void) {\n    fns.push(fn)\n    return {\n      off: () => off(fn),\n    }\n  }\n\n  function off (fn: (param: TParam) => void) {\n    const index = fns.indexOf(fn)\n    if (index !== -1) {\n      fns.splice(index, 1)\n    }\n  }\n\n  function trigger (param: TParam) {\n    for (const fn of fns) {\n      fn(param)\n    }\n  }\n\n  function getCount () {\n    return fns.length\n  }\n\n  return {\n    on,\n    off,\n    trigger,\n    getCount,\n  }\n}\n","import { Ref, watch, onUnmounted, ref, getCurrentInstance, onBeforeUnmount } from 'vue-demi'\nimport type { CurrentInstance } from './types'\n\nexport interface LoadingTracking {\n  queries: Ref<number>\n  mutations: Ref<number>\n  subscriptions: Ref<number>\n}\n\nexport interface AppLoadingTracking extends LoadingTracking {\n  components: Map<any, LoadingTracking>\n}\n\nexport function getAppTracking () {\n  const vm = getCurrentInstance() as CurrentInstance | null\n  const root = vm?.$root ?? vm?.root\n  if (!root) {\n    throw new Error('Instance $root not found')\n  }\n\n  let appTracking: AppLoadingTracking\n\n  if (!root._apolloAppTracking) {\n    // Add per Vue tracking\n    appTracking = root._apolloAppTracking = {\n      queries: ref(0),\n      mutations: ref(0),\n      subscriptions: ref(0),\n      components: new Map(),\n    }\n  } else {\n    appTracking = root._apolloAppTracking\n  }\n\n  return {\n    appTracking,\n  }\n}\n\nexport function getCurrentTracking () {\n  const vm = getCurrentInstance()\n  if (!vm) {\n    throw new Error('getCurrentTracking must be used during a component setup')\n  }\n\n  const { appTracking } = getAppTracking()\n\n  let tracking: LoadingTracking\n\n  if (!appTracking.components.has(vm)) {\n    // Add per-component tracking\n    appTracking.components.set(vm, tracking = {\n      queries: ref(0),\n      mutations: ref(0),\n      subscriptions: ref(0),\n    })\n    // Cleanup\n    onUnmounted(() => {\n      appTracking.components.delete(vm)\n    })\n  } else {\n    tracking = appTracking.components.get(vm) as LoadingTracking\n  }\n\n  return {\n    appTracking,\n    tracking,\n  }\n}\n\nfunction track (loading: Ref<boolean>, type: keyof LoadingTracking) {\n  const { appTracking, tracking } = getCurrentTracking()\n\n  watch(loading, (value, oldValue) => {\n    if (oldValue != null && value !== oldValue) {\n      const mod = value ? 1 : -1\n      tracking[type].value += mod\n      appTracking[type].value += mod\n    }\n  }, {\n    immediate: true,\n  })\n\n  onBeforeUnmount(() => {\n    if (loading.value) {\n      tracking[type].value--\n      appTracking[type].value--\n    }\n  })\n}\n\nexport function trackQuery (loading: Ref<boolean>) {\n  track(loading, 'queries')\n}\n\nexport function trackMutation (loading: Ref<boolean>) {\n  track(loading, 'mutations')\n}\n\nexport function trackSubscription (loading: Ref<boolean>) {\n  track(loading, 'subscriptions')\n}\n","import { ApolloError, isApolloError } from '@apollo/client/core'\nimport { GraphQLErrors } from '@apollo/client/errors'\n\nexport function toApolloError (error: unknown): ApolloError {\n  if (!(error instanceof Error)) {\n    return new ApolloError({\n      networkError: Object.assign(new Error(), { originalError: error }),\n      errorMessage: String(error),\n    })\n  }\n\n  if (isApolloError(error)) {\n    return error\n  }\n\n  return new ApolloError({ networkError: error, errorMessage: error.message })\n}\n\nexport function resultErrorsToApolloError (errors: GraphQLErrors): ApolloError {\n  return new ApolloError({\n    graphQLErrors: errors,\n    errorMessage: `GraphQL response contains errors: ${errors.map((e: any) => e.message).join(' | ')}`,\n  })\n}\n","export const isServer = typeof window === 'undefined'\n","import {\n  ref,\n  Ref,\n  unref,\n  isRef,\n  computed,\n  watch,\n  onServerPrefetch,\n  getCurrentInstance,\n  onBeforeUnmount,\n  nextTick,\n} from 'vue-demi'\nimport { DocumentNode } from 'graphql'\nimport {\n  OperationVariables,\n  WatchQueryOptions,\n  ObservableQuery,\n  ApolloQueryResult,\n  SubscribeToMoreOptions,\n  FetchMoreQueryOptions,\n  FetchMoreOptions,\n  ObservableSubscription,\n  TypedDocumentNode,\n  ApolloError,\n} from '@apollo/client/core'\nimport { throttle, debounce } from 'throttle-debounce'\nimport { useApolloClient } from './useApolloClient'\nimport { ReactiveFunction } from './util/ReactiveFunction'\nimport { paramToRef } from './util/paramToRef'\nimport { paramToReactive } from './util/paramToReactive'\nimport { useEventHook } from './util/useEventHook'\nimport { trackQuery } from './util/loadingTracking'\nimport { resultErrorsToApolloError, toApolloError } from './util/toApolloError'\nimport { isServer } from './util/env'\n\nimport type { CurrentInstance } from './util/types'\n\nexport interface UseQueryOptions<\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  TResult = any,\n  TVariables = OperationVariables\n> extends Omit<WatchQueryOptions<TVariables>, 'query' | 'variables'> {\n  clientId?: string\n  enabled?: boolean\n  throttle?: number\n  debounce?: number\n  prefetch?: boolean\n}\n\ninterface SubscribeToMoreItem {\n  options: any\n  unsubscribeFns: (() => void)[]\n}\n\n// Parameters\nexport type DocumentParameter<TResult, TVariables = undefined> = DocumentNode | Ref<DocumentNode> | ReactiveFunction<DocumentNode> | TypedDocumentNode<TResult, TVariables> | Ref<TypedDocumentNode<TResult, TVariables>> | ReactiveFunction<TypedDocumentNode<TResult, TVariables>>\nexport type VariablesParameter<TVariables> = TVariables | Ref<TVariables> | ReactiveFunction<TVariables>\nexport type OptionsParameter<TResult, TVariables> = UseQueryOptions<TResult, TVariables> | Ref<UseQueryOptions<TResult, TVariables>> | ReactiveFunction<UseQueryOptions<TResult, TVariables>>\n\n// Return\nexport interface UseQueryReturn<TResult, TVariables> {\n  result: Ref<TResult | undefined>\n  loading: Ref<boolean>\n  networkStatus: Ref<number | undefined>\n  error: Ref<ApolloError | null>\n  start: () => void\n  stop: () => void\n  restart: () => void\n  forceDisabled: Ref<boolean>\n  document: Ref<DocumentNode>\n  variables: Ref<TVariables | undefined>\n  options: UseQueryOptions<TResult, TVariables> | Ref<UseQueryOptions<TResult, TVariables>>\n  query: Ref<ObservableQuery<TResult, TVariables> | null | undefined>\n  refetch: (variables?: TVariables) => Promise<ApolloQueryResult<TResult>> | undefined\n  fetchMore: (options: FetchMoreQueryOptions<TVariables, TResult> & FetchMoreOptions<TResult, TVariables>) => Promise<ApolloQueryResult<TResult>> | undefined\n  subscribeToMore: <TSubscriptionVariables = OperationVariables, TSubscriptionData = TResult>(options: SubscribeToMoreOptions<TResult, TSubscriptionVariables, TSubscriptionData> | Ref<SubscribeToMoreOptions<TResult, TSubscriptionVariables, TSubscriptionData>> | ReactiveFunction<SubscribeToMoreOptions<TResult, TSubscriptionVariables, TSubscriptionData>>) => void\n  onResult: (fn: (param: ApolloQueryResult<TResult>) => void) => {\n    off: () => void\n  }\n  onError: (fn: (param: ApolloError) => void) => {\n    off: () => void\n  }\n}\n\n/**\n * Use a query that does not require variables or options.\n * */\nexport function useQuery<TResult = any> (\n  document: DocumentParameter<TResult, undefined>\n): UseQueryReturn<TResult, undefined>\n\n/**\n * Use a query that has optional variables but not options\n */\nexport function useQuery<TResult = any, TVariables extends OperationVariables = OperationVariables> (\n  document: DocumentParameter<TResult, TVariables>\n): UseQueryReturn<TResult, TVariables>\n\n/**\n * Use a query that has required variables but not options\n */\nexport function useQuery<TResult = any, TVariables extends OperationVariables = OperationVariables> (\n  document: DocumentParameter<TResult, TVariables>,\n  variables: VariablesParameter<TVariables>\n): UseQueryReturn<TResult, TVariables>\n\n/**\n * Use a query that requires options but not variables.\n */\nexport function useQuery<TResult = any> (\n  document: DocumentParameter<TResult, undefined>,\n  variables: undefined | null,\n  options: OptionsParameter<TResult, null>,\n): UseQueryReturn<TResult, null>\n\n/**\n * Use a query that requires variables and options.\n */\nexport function useQuery<TResult = any, TVariables extends OperationVariables = OperationVariables> (\n  document: DocumentParameter<TResult, TVariables>,\n  variables: VariablesParameter<TVariables>,\n  options: OptionsParameter<TResult, TVariables>,\n): UseQueryReturn<TResult, TVariables>\n\nexport function useQuery<\n  TResult,\n  TVariables extends OperationVariables\n> (\n  document: DocumentParameter<TResult, TVariables>,\n  variables?: VariablesParameter<TVariables>,\n  options?: OptionsParameter<TResult, TVariables>,\n): UseQueryReturn<TResult, TVariables> {\n  return useQueryImpl<TResult, TVariables>(document, variables, options)\n}\n\nexport function useQueryImpl<\n  TResult,\n  TVariables extends OperationVariables\n> (\n  document: DocumentParameter<TResult, TVariables>,\n  variables?: VariablesParameter<TVariables>,\n  options: OptionsParameter<TResult, TVariables> = {},\n  lazy = false,\n): UseQueryReturn<TResult, TVariables> {\n  // Is on server?\n  const vm = getCurrentInstance() as CurrentInstance | null\n\n  const currentOptions = ref<UseQueryOptions<TResult, TVariables>>()\n\n  const documentRef = paramToRef(document)\n  const variablesRef = paramToRef(variables)\n  const optionsRef = paramToReactive(options)\n\n  // Result\n  /**\n   * Result from the query\n   */\n  const result = ref<TResult | undefined>()\n  const resultEvent = useEventHook<ApolloQueryResult<TResult>>()\n  const error = ref<ApolloError | null>(null)\n  const errorEvent = useEventHook<ApolloError>()\n\n  // Loading\n\n  /**\n   * Indicates if a network request is pending\n   */\n  const loading = ref(false)\n  vm && trackQuery(loading)\n  const networkStatus = ref<number>()\n\n  // SSR\n  let firstResolve: (() => void) | undefined\n  let firstReject: ((apolloError: ApolloError) => void) | undefined\n  vm && onServerPrefetch?.(() => {\n    if (!isEnabled.value || (isServer && currentOptions.value?.prefetch === false)) return\n\n    return new Promise<void>((resolve, reject) => {\n      firstResolve = () => {\n        resolve()\n        firstResolve = undefined\n        firstReject = undefined\n      }\n      firstReject = (apolloError: ApolloError) => {\n        reject(apolloError)\n        firstResolve = undefined\n        firstReject = undefined\n      }\n    }).then(stop).catch(stop)\n  })\n\n  // Apollo Client\n  const { resolveClient } = useApolloClient()\n\n  // Query\n\n  const query: Ref<ObservableQuery<TResult, TVariables> | null | undefined> = ref()\n  let observer: ObservableSubscription | undefined\n  let started = false\n\n  /**\n   * Starts watching the query\n   */\n  function start () {\n    if (\n      started || !isEnabled.value ||\n      (isServer && currentOptions.value?.prefetch === false)\n    ) {\n      if (firstResolve) firstResolve()\n      return\n    }\n\n    started = true\n    error.value = null\n    loading.value = true\n\n    const client = resolveClient(currentOptions.value?.clientId)\n\n    query.value = client.watchQuery<TResult, TVariables>({\n      query: currentDocument,\n      variables: currentVariables,\n      ...currentOptions.value,\n      ...(isServer && currentOptions.value?.fetchPolicy !== 'no-cache')\n        ? {\n          fetchPolicy: 'network-only',\n        }\n        : {},\n    })\n\n    startQuerySubscription()\n\n    if (!isServer && (currentOptions.value?.fetchPolicy !== 'no-cache' || currentOptions.value.notifyOnNetworkStatusChange)) {\n      const currentResult = query.value.getCurrentResult()\n\n      if (!currentResult.loading || currentResult.partial || currentOptions.value?.notifyOnNetworkStatusChange) {\n        onNextResult(currentResult)\n      }\n    }\n\n    if (!isServer) {\n      for (const item of subscribeToMoreItems) {\n        addSubscribeToMore(item)\n      }\n    }\n  }\n\n  function startQuerySubscription () {\n    if (observer && !observer.closed) return\n    if (!query.value) return\n\n    // Create subscription\n    observer = query.value.subscribe({\n      next: onNextResult,\n      error: onError,\n    })\n  }\n\n  function onNextResult (queryResult: ApolloQueryResult<TResult>) {\n    // Remove any previous error that may still be present from the last fetch (so result handlers\n    // don't receive old errors that may not even be applicable anymore).\n    error.value = null\n\n    processNextResult(queryResult)\n\n    // When `errorPolicy` is `all`, `onError` will not get called and\n    // ApolloQueryResult.errors may be set at the same time as we get a result\n    if (!queryResult.error && queryResult.errors?.length) {\n      processError(resultErrorsToApolloError(queryResult.errors))\n    }\n\n    if (firstResolve) {\n      firstResolve()\n      stop()\n    }\n  }\n\n  function processNextResult (queryResult: ApolloQueryResult<TResult>) {\n    result.value = queryResult.data && Object.keys(queryResult.data).length === 0 ? undefined : queryResult.data\n    loading.value = queryResult.loading\n    networkStatus.value = queryResult.networkStatus\n    resultEvent.trigger(queryResult)\n  }\n\n  function onError (queryError: unknown) {\n    // any error should already be an ApolloError, but we make sure\n    const apolloError = toApolloError(queryError)\n    const client = resolveClient(currentOptions.value?.clientId)\n    const errorPolicy = currentOptions.value?.errorPolicy || client.defaultOptions?.watchQuery?.errorPolicy\n\n    if (errorPolicy && errorPolicy !== 'none') {\n      processNextResult((query.value as ObservableQuery<TResult, TVariables>).getCurrentResult())\n    }\n    processError(apolloError)\n    if (firstReject) {\n      firstReject(apolloError)\n      stop()\n    }\n    // The observable closes the sub if an error occurs\n    resubscribeToQuery()\n  }\n\n  function processError (apolloError: ApolloError) {\n    error.value = apolloError\n    loading.value = false\n    networkStatus.value = 8\n    errorEvent.trigger(apolloError)\n  }\n\n  function resubscribeToQuery () {\n    if (!query.value) return\n    const lastError = query.value.getLastError()\n    const lastResult = query.value.getLastResult()\n    query.value.resetLastResults()\n    startQuerySubscription()\n    Object.assign(query.value, { lastError, lastResult })\n  }\n\n  let onStopHandlers: Array<() => void> = []\n\n  /**\n   * Stop watching the query\n   */\n  function stop () {\n    if (firstResolve) firstResolve()\n    if (!started) return\n    started = false\n    loading.value = false\n\n    onStopHandlers.forEach(handler => handler())\n    onStopHandlers = []\n\n    if (query.value) {\n      query.value.stopPolling()\n      query.value = null\n    }\n\n    if (observer) {\n      observer.unsubscribe()\n      observer = undefined\n    }\n  }\n\n  // Restart\n  let restarting = false\n  /**\n   * Queue a restart of the query (on next tick) if it is already active\n   */\n  function baseRestart () {\n    if (!started || restarting) return\n    restarting = true\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    nextTick(() => {\n      if (started) {\n        stop()\n        start()\n      }\n      restarting = false\n    })\n  }\n\n  let debouncedRestart: typeof baseRestart\n  let isRestartDebounceSetup = false\n  function updateRestartFn () {\n    // On server, will be called before currentOptions is initialized\n    // @TODO investigate\n    if (!currentOptions.value) {\n      debouncedRestart = baseRestart\n    } else {\n      if (currentOptions.value?.throttle) {\n        debouncedRestart = throttle(currentOptions.value.throttle, baseRestart)\n      } else if (currentOptions.value?.debounce) {\n        debouncedRestart = debounce(currentOptions.value.debounce, baseRestart)\n      } else {\n        debouncedRestart = baseRestart\n      }\n      isRestartDebounceSetup = true\n    }\n  }\n\n  function restart () {\n    if (!isRestartDebounceSetup) updateRestartFn()\n    debouncedRestart()\n  }\n\n  // Applying document\n  let currentDocument: DocumentNode\n  watch(documentRef, value => {\n    currentDocument = value\n    restart()\n  }, {\n    immediate: true,\n  })\n\n  // Applying variables\n  let currentVariables: TVariables | undefined\n  let currentVariablesSerialized: string\n  watch(variablesRef, (value, oldValue) => {\n    const serialized = JSON.stringify(value)\n    if (serialized !== currentVariablesSerialized) {\n      currentVariables = value\n      restart()\n    }\n    currentVariablesSerialized = serialized\n  }, {\n    deep: true,\n    immediate: true,\n  })\n\n  // Applying options\n  watch(() => unref(optionsRef), value => {\n    if (currentOptions.value && (\n      currentOptions.value.throttle !== value.throttle ||\n      currentOptions.value.debounce !== value.debounce\n    )) {\n      updateRestartFn()\n    }\n    currentOptions.value = value\n    restart()\n  }, {\n    deep: true,\n    immediate: true,\n  })\n\n  // Refetch\n\n  function refetch (variables: TVariables | undefined = undefined) {\n    if (query.value) {\n      if (variables) {\n        currentVariables = variables\n      }\n      error.value = null\n      loading.value = true\n      return query.value.refetch(variables)\n    }\n  }\n\n  // Fetch more\n\n  function fetchMore (options: FetchMoreQueryOptions<TVariables, TResult> & FetchMoreOptions<TResult, TVariables>) {\n    if (query.value) {\n      error.value = null\n      return query.value.fetchMore(options)\n    }\n  }\n\n  // Subscribe to more\n\n  const subscribeToMoreItems: SubscribeToMoreItem[] = []\n\n  function subscribeToMore<\n    TSubscriptionVariables = OperationVariables,\n    TSubscriptionData = TResult\n  > (\n    options: SubscribeToMoreOptions<TResult, TSubscriptionVariables, TSubscriptionData> |\n    Ref<SubscribeToMoreOptions<TResult, TSubscriptionVariables, TSubscriptionData>> |\n    ReactiveFunction<SubscribeToMoreOptions<TResult, TSubscriptionVariables, TSubscriptionData>>,\n  ) {\n    if (isServer) return\n    const optionsRef = paramToRef(options)\n    watch(optionsRef, (value, oldValue, onCleanup) => {\n      const index = subscribeToMoreItems.findIndex(item => item.options === oldValue)\n      if (index !== -1) {\n        subscribeToMoreItems.splice(index, 1)\n      }\n      const item: SubscribeToMoreItem = {\n        options: value,\n        unsubscribeFns: [],\n      }\n      subscribeToMoreItems.push(item)\n\n      addSubscribeToMore(item)\n\n      onCleanup(() => {\n        item.unsubscribeFns.forEach(fn => fn())\n        item.unsubscribeFns = []\n      })\n    }, {\n      immediate: true,\n    })\n  }\n\n  function addSubscribeToMore (item: SubscribeToMoreItem) {\n    if (!started) return\n    if (!query.value) {\n      throw new Error('Query is not defined')\n    }\n    const unsubscribe = query.value.subscribeToMore(item.options)\n    onStopHandlers.push(unsubscribe)\n    item.unsubscribeFns.push(unsubscribe)\n  }\n\n  // Enabled state\n\n  const forceDisabled = ref(lazy)\n  const enabledOption = computed(() => !currentOptions.value || currentOptions.value.enabled == null || currentOptions.value.enabled)\n  const isEnabled = computed(() => enabledOption.value && !forceDisabled.value)\n\n  // Auto start & stop\n  watch(isEnabled, value => {\n    if (value) {\n      start()\n    } else {\n      stop()\n    }\n  }, {\n    immediate: true,\n  })\n\n  // Teardown\n  vm && onBeforeUnmount(() => {\n    stop()\n    subscribeToMoreItems.length = 0\n  })\n\n  return {\n    result,\n    loading,\n    networkStatus,\n    error,\n    start,\n    stop,\n    restart,\n    forceDisabled,\n    document: documentRef,\n    variables: variablesRef,\n    options: optionsRef,\n    query,\n    refetch,\n    fetchMore,\n    subscribeToMore,\n    onResult: resultEvent.on,\n    onError: errorEvent.on,\n  }\n}\n","import { DocumentNode } from 'graphql'\nimport { isRef } from 'vue-demi'\nimport { useQueryImpl, DocumentParameter, VariablesParameter, OptionsParameter, UseQueryOptions } from './useQuery'\n\nexport function useLazyQuery<\n  TResult = any,\n  TVariables = any,\n> (\n  document: DocumentParameter<TResult, TVariables>,\n  variables?: VariablesParameter<TVariables>,\n  options?: OptionsParameter<TResult, TVariables>,\n) {\n  const query = useQueryImpl<TResult, TVariables>(document, variables, options, true)\n\n  function load (\n    document?: DocumentNode,\n    variables?: TVariables,\n    options?: UseQueryOptions,\n  ) {\n    if (document) {\n      query.document.value = document\n    }\n    if (variables) {\n      query.variables.value = variables\n    }\n    if (options) {\n      Object.assign(isRef(query.options) ? query.options.value : query.options, options)\n    }\n    query.forceDisabled.value = false\n  }\n\n  return {\n    ...query,\n    load,\n  }\n}\n","import { DocumentNode } from 'graphql'\nimport { MutationOptions, OperationVariables, FetchResult, TypedDocumentNode, ApolloError } from '@apollo/client/core'\nimport { ref, onBeforeUnmount, isRef, Ref, getCurrentInstance } from 'vue-demi'\nimport { useApolloClient } from './useApolloClient'\nimport { ReactiveFunction } from './util/ReactiveFunction'\nimport { useEventHook } from './util/useEventHook'\nimport { trackMutation } from './util/loadingTracking'\nimport { toApolloError } from './util/toApolloError'\n\n/**\n * `useMutation` options for mutations that don't require `variables`.\n */\nexport interface UseMutationOptions<\n  TResult = any,\n  TVariables = OperationVariables\n> extends Omit<MutationOptions<TResult, TVariables>, 'mutation'> {\n  clientId?: string\n  throws?: 'auto' | 'always' | 'never'\n}\n\ntype DocumentParameter<TResult, TVariables> = DocumentNode | Ref<DocumentNode> | ReactiveFunction<DocumentNode> | TypedDocumentNode<TResult, TVariables> | Ref<TypedDocumentNode<TResult, TVariables>> | ReactiveFunction<TypedDocumentNode<TResult, TVariables>>\ntype OptionsParameter<TResult, TVariables> = UseMutationOptions<TResult, TVariables> | Ref<UseMutationOptions<TResult, TVariables>> | ReactiveFunction<UseMutationOptions<TResult, TVariables>>\n\nexport type MutateOverrideOptions<TResult> = Pick<UseMutationOptions<TResult, OperationVariables>, 'update' | 'optimisticResponse' | 'context' | 'updateQueries' | 'refetchQueries' | 'awaitRefetchQueries' | 'errorPolicy' | 'fetchPolicy' | 'clientId'>\nexport type MutateResult<TResult> = Promise<FetchResult<TResult, Record<string, any>, Record<string, any>> | null>\nexport type MutateFunction<TResult, TVariables> = (variables?: TVariables | null, overrideOptions?: MutateOverrideOptions<TResult>) => MutateResult<TResult>\n\nexport interface UseMutationReturn<TResult, TVariables> {\n  mutate: MutateFunction<TResult, TVariables>\n  loading: Ref<boolean>\n  error: Ref<ApolloError | null>\n  called: Ref<boolean>\n  onDone: (fn: (param: FetchResult<TResult, Record<string, any>, Record<string, any>>) => void) => {\n    off: () => void\n  }\n  onError: (fn: (param: ApolloError) => void) => {\n    off: () => void\n  }\n}\n\nexport function useMutation<\n  TResult = any,\n  TVariables extends OperationVariables = OperationVariables\n> (\n  document: DocumentParameter<TResult, TVariables>,\n  options: OptionsParameter<TResult, TVariables> = {},\n): UseMutationReturn<TResult, TVariables> {\n  const vm = getCurrentInstance()\n  const loading = ref<boolean>(false)\n  vm && trackMutation(loading)\n  const error = ref<ApolloError | null>(null)\n  const called = ref<boolean>(false)\n\n  const doneEvent = useEventHook<FetchResult<TResult, Record<string, any>, Record<string, any>>>()\n  const errorEvent = useEventHook<ApolloError>()\n\n  // Apollo Client\n  const { resolveClient } = useApolloClient()\n\n  async function mutate (variables?: TVariables | null, overrideOptions: Omit<UseMutationOptions<TResult, TVariables>, 'variables'> = {}) {\n    let currentDocument: DocumentNode\n    if (typeof document === 'function') {\n      currentDocument = document()\n    } else if (isRef(document)) {\n      currentDocument = document.value\n    } else {\n      currentDocument = document\n    }\n\n    let currentOptions: UseMutationOptions<TResult, TVariables>\n    if (typeof options === 'function') {\n      currentOptions = options()\n    } else if (isRef(options)) {\n      currentOptions = options.value\n    } else {\n      currentOptions = options\n    }\n    const client = resolveClient(currentOptions.clientId)\n    error.value = null\n    loading.value = true\n    called.value = true\n    try {\n      const result = await client.mutate<TResult, TVariables>({\n        mutation: currentDocument,\n        ...currentOptions,\n        ...overrideOptions,\n        variables: (variables ?? currentOptions.variables)\n          ? {\n            ...(currentOptions.variables as TVariables),\n            ...(variables as TVariables),\n          }\n          : undefined,\n      })\n      loading.value = false\n      doneEvent.trigger(result)\n      return result\n    } catch (e) {\n      const apolloError = toApolloError(e)\n      error.value = apolloError\n      loading.value = false\n      errorEvent.trigger(apolloError)\n      if (currentOptions.throws === 'always' || (currentOptions.throws !== 'never' && !errorEvent.getCount())) {\n        throw apolloError\n      }\n    }\n    return null\n  }\n\n  vm && onBeforeUnmount(() => {\n    loading.value = false\n  })\n\n  return {\n    mutate,\n    loading,\n    error,\n    called,\n    onDone: doneEvent.on,\n    onError: errorEvent.on,\n  }\n}\n","import { DocumentNode } from 'graphql'\nimport {\n  Ref,\n  ref,\n  watch,\n  isRef,\n  computed,\n  getCurrentInstance,\n  onBeforeUnmount,\n  nextTick,\n} from 'vue-demi'\nimport {\n  OperationVariables,\n  SubscriptionOptions,\n  FetchResult,\n  Observable,\n  ObservableSubscription,\n  TypedDocumentNode,\n  ApolloError,\n} from '@apollo/client/core'\nimport { throttle, debounce } from 'throttle-debounce'\nimport { ReactiveFunction } from './util/ReactiveFunction'\nimport { paramToRef } from './util/paramToRef'\nimport { paramToReactive } from './util/paramToReactive'\nimport { useApolloClient } from './useApolloClient'\nimport { useEventHook } from './util/useEventHook'\nimport { trackSubscription } from './util/loadingTracking'\nimport type { CurrentInstance } from './util/types'\nimport { toApolloError } from './util/toApolloError'\nimport { isServer } from './util/env'\n\nexport interface UseSubscriptionOptions <\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  TResult = any,\n  TVariables = OperationVariables\n> extends Omit<SubscriptionOptions<TVariables>, 'query' | 'variables'> {\n  clientId?: string\n  enabled?: boolean\n  throttle?: number\n  debounce?: number\n}\n\ntype DocumentParameter<TResult, TVariables> = DocumentNode | Ref<DocumentNode> | ReactiveFunction<DocumentNode> | TypedDocumentNode<TResult, TVariables> | Ref<TypedDocumentNode<TResult, TVariables>> | ReactiveFunction<TypedDocumentNode<TResult, TVariables>>\ntype VariablesParameter<TVariables> = TVariables | Ref<TVariables> | ReactiveFunction<TVariables>\ntype OptionsParameter<TResult, TVariables> = UseSubscriptionOptions<TResult, TVariables> | Ref<UseSubscriptionOptions<TResult, TVariables>> | ReactiveFunction<UseSubscriptionOptions<TResult, TVariables>>\n\nexport interface UseSubscriptionReturn<TResult, TVariables> {\n  result: Ref<TResult | null | undefined>\n  loading: Ref<boolean>\n  error: Ref<ApolloError | null>\n  start: () => void\n  stop: () => void\n  restart: () => void\n  document: Ref<DocumentNode>\n  variables: Ref<TVariables | undefined>\n  options: UseSubscriptionOptions<TResult, TVariables> | Ref<UseSubscriptionOptions<TResult, TVariables>>\n  subscription: Ref<Observable<FetchResult<TResult, Record<string, any>, Record<string, any>>> | null>\n  onResult: (fn: (param: FetchResult<TResult, Record<string, any>, Record<string, any>>) => void) => {\n    off: () => void\n  }\n  onError: (fn: (param: ApolloError) => void) => {\n    off: () => void\n  }\n}\n\n/**\n * Use a subscription that does not require variables or options.\n * */\nexport function useSubscription<TResult = any> (\n  document: DocumentParameter<TResult, undefined>\n): UseSubscriptionReturn<TResult, undefined>\n\n/**\n * Use a subscription that requires options but not variables.\n */\nexport function useSubscription<TResult = any> (\n  document: DocumentParameter<TResult, undefined>,\n  variables: undefined | null,\n  options: OptionsParameter<TResult, null>\n): UseSubscriptionReturn<TResult, null>\n\n/**\n * Use a subscription that requires variables.\n */\nexport function useSubscription<TResult = any, TVariables extends OperationVariables = OperationVariables> (\n  document: DocumentParameter<TResult, TVariables>,\n  variables: VariablesParameter<TVariables>\n): UseSubscriptionReturn<TResult, TVariables>\n\n/**\n * Use a subscription that has optional variables.\n */\nexport function useSubscription<TResult = any, TVariables extends OperationVariables = OperationVariables> (\n  document: DocumentParameter<TResult, TVariables>,\n): UseSubscriptionReturn<TResult, TVariables>\n\n/**\n * Use a subscription that requires variables and options.\n */\nexport function useSubscription<TResult = any, TVariables extends OperationVariables = OperationVariables> (\n  document: DocumentParameter<TResult, TVariables>,\n  variables: VariablesParameter<TVariables>,\n  options: OptionsParameter<TResult, TVariables>\n): UseSubscriptionReturn<TResult, TVariables>\n\nexport function useSubscription <\n  TResult,\n  TVariables\n> (\n  document: DocumentParameter<TResult, TVariables>,\n  variables: VariablesParameter<TVariables> | undefined = undefined,\n  options: OptionsParameter<TResult, TVariables> = {},\n): UseSubscriptionReturn<TResult, TVariables> {\n  // Is on server?\n  const vm = getCurrentInstance() as CurrentInstance | null\n\n  const documentRef = paramToRef(document)\n  const variablesRef = paramToRef(variables)\n  const optionsRef = paramToReactive(options)\n\n  const result = ref<TResult | null | undefined>()\n  const resultEvent = useEventHook<FetchResult<TResult>>()\n  const error = ref<ApolloError | null>(null)\n  const errorEvent = useEventHook<ApolloError>()\n\n  const loading = ref(false)\n  vm && trackSubscription(loading)\n\n  // Apollo Client\n  const { resolveClient } = useApolloClient()\n\n  const subscription: Ref<Observable<FetchResult<TResult>> | null> = ref(null)\n  let observer: ObservableSubscription | null = null\n  let started = false\n\n  function start () {\n    if (started || !isEnabled.value || isServer) return\n    started = true\n    loading.value = true\n\n    const client = resolveClient(currentOptions.value?.clientId)\n\n    subscription.value = client.subscribe<TResult, TVariables>({\n      query: currentDocument,\n      variables: currentVariables,\n      ...currentOptions.value,\n    })\n\n    observer = subscription.value.subscribe({\n      next: onNextResult,\n      error: onError,\n    })\n  }\n\n  function onNextResult (fetchResult: FetchResult<TResult>) {\n    result.value = fetchResult.data\n    loading.value = false\n    resultEvent.trigger(fetchResult)\n  }\n\n  function onError (fetchError: unknown) {\n    const apolloError = toApolloError(fetchError)\n\n    error.value = apolloError\n    loading.value = false\n    errorEvent.trigger(apolloError)\n  }\n\n  function stop () {\n    if (!started) return\n    started = false\n    loading.value = false\n\n    if (subscription.value) {\n      subscription.value = null\n    }\n\n    if (observer) {\n      observer.unsubscribe()\n      observer = null\n    }\n  }\n\n  // Restart\n  let restarting = false\n  /**\n   * Queue a restart of the query (on next tick) if it is already active\n   */\n  function baseRestart () {\n    if (!started || restarting) return\n    restarting = true\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    nextTick(() => {\n      if (started) {\n        stop()\n        start()\n      }\n      restarting = false\n    })\n  }\n\n  let debouncedRestart: typeof baseRestart\n  function updateRestartFn () {\n    if (currentOptions.value?.throttle) {\n      debouncedRestart = throttle(currentOptions.value.throttle, baseRestart)\n    } else if (currentOptions.value?.debounce) {\n      debouncedRestart = debounce(currentOptions.value.debounce, baseRestart)\n    } else {\n      debouncedRestart = baseRestart\n    }\n  }\n\n  function restart () {\n    if (!debouncedRestart) updateRestartFn()\n    debouncedRestart()\n  }\n\n  // Applying options\n  const currentOptions = ref<UseSubscriptionOptions<TResult, TVariables>>()\n  watch(() => isRef(optionsRef) ? optionsRef.value : optionsRef, value => {\n    if (currentOptions.value && (\n      currentOptions.value.throttle !== value.throttle ||\n      currentOptions.value.debounce !== value.debounce\n    )) {\n      updateRestartFn()\n    }\n    currentOptions.value = value\n    restart()\n  }, {\n    deep: true,\n    immediate: true,\n  })\n\n  // Applying document\n  let currentDocument: DocumentNode\n  watch(documentRef, value => {\n    currentDocument = value\n    restart()\n  }, {\n    immediate: true,\n  })\n\n  // Applying variables\n  let currentVariables: TVariables | undefined\n  let currentVariablesSerialized: string\n  watch(variablesRef, (value, oldValue) => {\n    const serialized = JSON.stringify(value)\n    if (serialized !== currentVariablesSerialized) {\n      currentVariables = value\n      restart()\n    }\n    currentVariablesSerialized = serialized\n  }, {\n    deep: true,\n    immediate: true,\n  })\n\n  // Internal enabled returned to user\n  // @TODO Doesn't fully work yet, need to initialize with option\n  // const enabled = ref<boolean>()\n  const enabledOption = computed(() => !currentOptions.value || currentOptions.value.enabled == null || currentOptions.value.enabled)\n  // const isEnabled = computed(() => !!((typeof enabled.value === 'boolean' && enabled.value) && enabledOption.value))\n  const isEnabled = enabledOption\n\n  // watch(enabled, value => {\n  //   if (value == null) {\n  //     enabled.value = enabledOption.value\n  //   }\n  // })\n\n  // Auto start & stop\n  watch(isEnabled, value => {\n    if (value) {\n      start()\n    } else {\n      stop()\n    }\n  }, {\n    immediate: true,\n  })\n\n  // Teardown\n  vm && onBeforeUnmount(stop)\n\n  return {\n    result,\n    loading,\n    error,\n    // @TODO doesn't fully work yet\n    // enabled,\n    start,\n    stop,\n    restart,\n    document: documentRef,\n    variables: variablesRef,\n    options: optionsRef,\n    subscription,\n    onResult: resultEvent.on,\n    onError: errorEvent.on,\n  }\n}\n","import { Ref, computed } from 'vue-demi'\nimport { ExtractSingleKey } from './util/ExtractSingleKey'\nimport type { DeepNonNullable, DeepRequired } from 'ts-essentials'\n\nexport type UseResultReturn<T> = Readonly<Ref<Readonly<T>>>\n\n/**\n * Resolve a `result`, returning either the first key of the `result` if there\n * is only one, or the `result` itself. The `value` of the ref will be\n * `undefined` until it is resolved.\n *\n * @example\n * const { result } = useQuery(...)\n * const user = useResult(result)\n * // user is `undefined` until the query resolves\n *\n * @param  {Ref<TResult>} result A `result` returned from `useQuery` to resolve.\n * @returns Readonly ref with `undefined` or the resolved `result`.\n * @deprecated Use `computed` instead. Before: `const items = useResult(result, [], data => data.someField.myItems)` After: `const items = computed(() => result.value?.someField.myItems ?? [])`\n */\nexport function useResult<TResult, TResultKey extends keyof NonNullable<TResult> = keyof NonNullable<TResult>> (\n  result: Ref<TResult>\n): UseResultReturn<undefined | ExtractSingleKey<NonNullable<TResult>, TResultKey>>\n\n/**\n * Resolve a `result`, returning either the first key of the `result` if there\n * is only one, or the `result` itself. The `value` of the ref will be\n * `defaultValue` until it is resolved.\n *\n * @example\n * const { result } = useQuery(...)\n * const profile = useResult(result, {})\n * // profile is `{}` until the query resolves\n *\n * @param  {Ref<TResult>} result A `result` returned from `useQuery` to resolve.\n * @param  {TDefaultValue} defaultValue The default return value before `result` is resolved.\n * @returns Readonly ref with the `defaultValue` or the resolved `result`.\n * @deprecated Use `computed` instead. Before: `const items = useResult(result, [], data => data.someField.myItems)` After: `const items = computed(() => result.value?.someField.myItems ?? [])`\n */\nexport function useResult<TResult, TDefaultValue, TResultKey extends keyof NonNullable<TResult> = keyof NonNullable<TResult>> (\n  result: Ref<TResult>,\n  defaultValue: TDefaultValue\n): UseResultReturn<TDefaultValue | ExtractSingleKey<NonNullable<TResult>, TResultKey>>\n\n/**\n * Resolve a `result`, returning the `result` mapped with the `pick` function.\n * The `value` of the ref will be `defaultValue` until it is resolved.\n *\n * @example\n * const { result } = useQuery(...)\n * const comments = useResult(result, undefined, (data) => data.comments)\n * // user is `undefined`, then resolves to the result's `comments`\n *\n * @param  {Ref<TResult>} result A `result` returned from `useQuery` to resolve.\n * @param  {TDefaultValue} defaultValue The default return value before `result` is resolved.\n * @param  {(data:TResult)=>TReturnValue} pick The function that receives `result` and maps a return value from it.\n * @returns Readonly ref with the `defaultValue` or the resolved and `pick`-mapped `result`\n * @deprecated Use `computed` instead. Before: `const items = useResult(result, [], data => data.someField.myItems)` After: `const items = computed(() => result.value?.someField.myItems ?? [])`\n */\nexport function useResult<\n  TResult,\n  TDefaultValue,\n  TReturnValue,\n> (\n  result: Ref<TResult>,\n  defaultValue: TDefaultValue | undefined,\n  pick: (data: DeepRequired<DeepNonNullable<TResult>>) => TReturnValue\n): UseResultReturn<TDefaultValue | TReturnValue>\n\n/**\n * @deprecated Use `computed` instead. Before: `const items = useResult(result, [], data => data.someField.myItems)` After: `const items = computed(() => result.value?.someField.myItems ?? [])`\n */\nexport function useResult<\n  TResult,\n  TDefaultValue,\n  TReturnValue,\n> (\n  result: Ref<TResult>,\n  defaultValue?: TDefaultValue,\n  pick?: (data: DeepRequired<DeepNonNullable<TResult>>) => TReturnValue,\n): UseResultReturn<TResult | TResult[keyof TResult] | TDefaultValue | TReturnValue | undefined> {\n  console.warn(`'useResult' is deprecated and will be removed soon. Plase use a computed instead.\nBefore:\nconst items = useResult(result, [], data => data.someField.myItems)\nAfter:\nconst items = computed(() => result.value?.someField.myItems ?? [])`)\n  return computed(() => {\n    const value = result.value\n    if (value) {\n      if (pick) {\n        try {\n          return pick(value as DeepRequired<DeepNonNullable<TResult>>)\n        } catch (e) {\n          // Silent error\n        }\n      } else {\n        const keys = Object.keys(value)\n        if (keys.length === 1) {\n          // Automatically take the only key in result data\n          return value[keys[0] as keyof TResult]\n        } else {\n          // Return entire result data\n          return value\n        }\n      }\n    }\n    return defaultValue\n  })\n}\n","import { getCurrentTracking, getAppTracking } from './util/loadingTracking'\nimport { computed } from 'vue-demi'\n\nexport function useQueryLoading () {\n  const { tracking } = getCurrentTracking()\n  return computed(() => tracking.queries.value > 0)\n}\n\nexport function useMutationLoading () {\n  const { tracking } = getCurrentTracking()\n  return computed(() => tracking.mutations.value > 0)\n}\n\nexport function useSubscriptionLoading () {\n  const { tracking } = getCurrentTracking()\n  return computed(() => tracking.subscriptions.value > 0)\n}\n\nexport function useGlobalQueryLoading () {\n  const { appTracking } = getAppTracking()\n  return computed(() => appTracking.queries.value > 0)\n}\n\nexport function useGlobalMutationLoading () {\n  const { appTracking } = getAppTracking()\n  return computed(() => appTracking.mutations.value > 0)\n}\n\nexport function useGlobalSubscriptionLoading () {\n  const { appTracking } = getAppTracking()\n  return computed(() => appTracking.subscriptions.value > 0)\n}\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    if (typeof b !== \"function\" && b !== null)\r\n        throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    var desc = Object.getOwnPropertyDescriptor(m, k);\r\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n        desc = { enumerable: true, get: function() { return m[k]; } };\r\n    }\r\n    Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n        if (ar || !(i in from)) {\r\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n            ar[i] = from[i];\r\n        }\r\n    }\r\n    return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n    return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n    if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n    if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n    if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n    return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n    if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n    return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n","import '../utilities/globals';\n\nimport { GraphQLError } from 'graphql';\n\nimport { isNonEmptyArray } from '../utilities';\nimport { ServerParseError } from '../link/http';\nimport { ServerError } from '../link/utils';\n\nexport function isApolloError(err: Error): err is ApolloError {\n  return err.hasOwnProperty('graphQLErrors');\n}\n\n// Sets the error message on this error according to the\n// the GraphQL and network errors that are present.\n// If the error message has already been set through the\n// constructor or otherwise, this function is a nop.\nconst generateErrorMessage = (err: ApolloError) => {\n  let message = '';\n  // If we have GraphQL errors present, add that to the error message.\n  if (isNonEmptyArray(err.graphQLErrors) || isNonEmptyArray(err.clientErrors)) {\n    const errors = ((err.graphQLErrors || []) as readonly Error[])\n      .concat(err.clientErrors || []);\n    errors.forEach((error: Error) => {\n      const errorMessage = error\n        ? error.message\n        : 'Error message not found.';\n      message += `${errorMessage}\\n`;\n    });\n  }\n\n  if (err.networkError) {\n    message += `${err.networkError.message}\\n`;\n  }\n\n  // strip newline from the end of the message\n  message = message.replace(/\\n$/, '');\n  return message;\n};\n\nexport type GraphQLErrors = ReadonlyArray<GraphQLError>;\n\nexport type NetworkError = Error | ServerParseError | ServerError | null;\n\nexport class ApolloError extends Error {\n  public message: string;\n  public graphQLErrors: GraphQLErrors;\n  public clientErrors: ReadonlyArray<Error>;\n  public networkError: Error | ServerParseError | ServerError | null;\n\n  // An object that can be used to provide some additional information\n  // about an error, e.g. specifying the type of error this is. Used\n  // internally within Apollo Client.\n  public extraInfo: any;\n\n  // Constructs an instance of ApolloError given a GraphQLError\n  // or a network error. Note that one of these has to be a valid\n  // value or the constructed error will be meaningless.\n  constructor({\n    graphQLErrors,\n    clientErrors,\n    networkError,\n    errorMessage,\n    extraInfo,\n  }: {\n    graphQLErrors?: ReadonlyArray<GraphQLError>;\n    clientErrors?: ReadonlyArray<Error>;\n    networkError?: Error | ServerParseError | ServerError | null;\n    errorMessage?: string;\n    extraInfo?: any;\n  }) {\n    super(errorMessage);\n    this.graphQLErrors = graphQLErrors || [];\n    this.clientErrors = clientErrors || [];\n    this.networkError = networkError || null;\n    this.message = errorMessage || generateErrorMessage(this);\n    this.extraInfo = extraInfo;\n\n    // We're not using `Object.setPrototypeOf` here as it isn't fully\n    // supported on Android (see issue #3236).\n    (this as any).__proto__ = ApolloError.prototype;\n  }\n}\n","export function isNonEmptyArray<T>(value?: ArrayLike<T>): value is Array<T> {\n  return Array.isArray(value) && value.length > 0;\n}\n","const genericMessage = \"Invariant Violation\";\nconst {\n  setPrototypeOf = function (obj: any, proto: any) {\n    obj.__proto__ = proto;\n    return obj;\n  },\n} = Object as any;\n\nexport class InvariantError extends Error {\n  framesToPop = 1;\n  name = genericMessage;\n  constructor(message: string | number = genericMessage) {\n    super(\n      typeof message === \"number\"\n        ? `${genericMessage}: ${message} (see https://github.com/apollographql/invariant-packages)`\n        : message\n    );\n    setPrototypeOf(this, InvariantError.prototype);\n  }\n}\n\nexport function invariant(\n  condition: any,\n  message?: string | number,\n): asserts condition {\n  if (!condition) {\n    throw new InvariantError(message);\n  }\n}\n\nconst verbosityLevels = [\"debug\", \"log\", \"warn\", \"error\", \"silent\"] as const;\nexport type VerbosityLevel = (typeof verbosityLevels)[number];\nexport type ConsoleMethodName = Exclude<VerbosityLevel, \"silent\">;\nlet verbosityLevel = verbosityLevels.indexOf(\"log\");\n\nfunction wrapConsoleMethod<M extends ConsoleMethodName>(name: M) {\n  return function () {\n    if (verbosityLevels.indexOf(name) >= verbosityLevel) {\n      // Default to console.log if this host environment happens not to provide\n      // all the console.* methods we need.\n      const method = console[name] || console.log;\n      return method.apply(console, arguments as any);\n    }\n  } as (typeof console)[M];\n}\n\nexport namespace invariant {\n  export const debug = wrapConsoleMethod(\"debug\");\n  export const log = wrapConsoleMethod(\"log\");\n  export const warn = wrapConsoleMethod(\"warn\");\n  export const error = wrapConsoleMethod(\"error\");\n}\n\nexport function setVerbosity(level: VerbosityLevel): VerbosityLevel {\n  const old = verbosityLevels[verbosityLevel];\n  verbosityLevel = Math.max(0, verbosityLevels.indexOf(level));\n  return old;\n}\n\nexport default invariant;\n","export function maybe<T>(thunk: () => T): T | undefined {\n  try { return thunk() } catch {}\n}\n","import { maybe } from \"./maybe\";\n\ndeclare global {\n  // Despite our attempts to reuse the React Native __DEV__ constant instead of\n  // inventing something new and Apollo-specific, declaring a useful type for\n  // __DEV__ unfortunately conflicts (TS2451) with the global declaration in\n  // @types/react-native/index.d.ts.\n  //\n  // To hide that harmless conflict, we @ts-ignore this line, which should\n  // continue to provide a type for __DEV__ elsewhere in the Apollo Client\n  // codebase, even when @types/react-native is not in use.\n  //\n  // However, because TypeScript drops @ts-ignore comments when generating .d.ts\n  // files (https://github.com/microsoft/TypeScript/issues/38628), we also\n  // sanitize the dist/utilities/globals/global.d.ts file to avoid declaring\n  // __DEV__ globally altogether when @apollo/client is installed in the\n  // node_modules directory of an application.\n  //\n  // @ts-ignore\n  const __DEV__: boolean | undefined;\n}\n\nexport default (\n  maybe(() => globalThis) ||\n  maybe(() => window) ||\n  maybe(() => self) ||\n  maybe(() => global) ||\n  // We don't expect the Function constructor ever to be invoked at runtime, as\n  // long as at least one of globalThis, window, self, or global is defined, so\n  // we are under no obligation to make it easy for static analysis tools to\n  // detect syntactic usage of the Function constructor. If you think you can\n  // improve your static analysis to detect this obfuscation, think again. This\n  // is an arms race you cannot win, at least not in JavaScript.\n  maybe(function() { return maybe.constructor(\"return this\")() })\n) as typeof globalThis & {\n  __DEV__: typeof __DEV__;\n};\n","import global from \"./global\";\nimport { maybe } from \"./maybe\";\n\n// To keep string-based find/replace minifiers from messing with __DEV__ inside\n// string literals or properties like global.__DEV__, we construct the \"__DEV__\"\n// string in a roundabout way that won't be altered by find/replace strategies.\nconst __ = \"__\";\nconst GLOBAL_KEY = [__, __].join(\"DEV\");\n\nfunction getDEV() {\n  try {\n    return Boolean(__DEV__);\n  } catch {\n    Object.defineProperty(global, GLOBAL_KEY, {\n      // In a buildless browser environment, maybe(() => process.env.NODE_ENV)\n      // evaluates as undefined, so __DEV__ becomes true by default, but can be\n      // initialized to false instead by a script/module that runs earlier.\n      value: maybe(() => process.env.NODE_ENV) !== \"production\",\n      enumerable: false,\n      configurable: true,\n      writable: true,\n    });\n    // Using computed property access rather than global.__DEV__ here prevents\n    // string-based find/replace strategies from munging this to global.false:\n    return (global as any)[GLOBAL_KEY];\n  }\n}\n\nexport default getDEV();\n","function maybe(thunk) {\n  try { return thunk() } catch (_) {}\n}\n\nvar safeGlobal = (\n  maybe(function() { return globalThis }) ||\n  maybe(function() { return window }) ||\n  maybe(function() { return self }) ||\n  maybe(function() { return global }) ||\n  // We don't expect the Function constructor ever to be invoked at runtime, as\n  // long as at least one of globalThis, window, self, or global is defined, so\n  // we are under no obligation to make it easy for static analysis tools to\n  // detect syntactic usage of the Function constructor. If you think you can\n  // improve your static analysis to detect this obfuscation, think again. This\n  // is an arms race you cannot win, at least not in JavaScript.\n  maybe(function() { return maybe.constructor(\"return this\")() })\n);\n\nvar needToRemove = false;\n\nexport function install() {\n  if (safeGlobal &&\n      !maybe(function() { return process.env.NODE_ENV }) &&\n      !maybe(function() { return process })) {\n    Object.defineProperty(safeGlobal, \"process\", {\n      value: {\n        env: {\n          // This default needs to be \"production\" instead of \"development\", to\n          // avoid the problem https://github.com/graphql/graphql-js/pull/2894\n          // will eventually solve, once merged and released.\n          NODE_ENV: \"production\",\n        },\n      },\n      // Let anyone else change global.process as they see fit, but hide it from\n      // Object.keys(global) enumeration.\n      configurable: true,\n      enumerable: false,\n      writable: true,\n    });\n    needToRemove = true;\n  }\n}\n\n// Call install() at least once, when this module is imported.\ninstall();\n\nexport function remove() {\n  if (needToRemove) {\n    delete safeGlobal.process;\n    needToRemove = false;\n  }\n}\n","// The ordering of these imports is important, because it ensures the temporary\n// process.env.NODE_ENV polyfill is defined globally (if necessary) before we\n// import { Source } from 'graphql'. The instanceOf function that we really care\n// about (the one that uses process.env.NODE_ENV) is not exported from the\n// top-level graphql package, but graphql/language/source uses instanceOf, and\n// has relatively few dependencies, so importing it here should not increase\n// bundle sizes as much as other options.\nimport { remove } from 'ts-invariant/process';\nimport { Source } from 'graphql';\n\nexport function removeTemporaryGlobals() {\n  // Using Source here here just to make sure it won't be tree-shaken away.\n  return typeof Source === \"function\" ? remove() : remove();\n}\n","import { invariant, InvariantError } from \"ts-invariant\";\n\n// Just in case the graphql package switches from process.env.NODE_ENV to\n// __DEV__, make sure __DEV__ is polyfilled before importing graphql.\nimport DEV from \"./DEV\";\nexport { DEV }\nexport function checkDEV() {\n  invariant(\"boolean\" === typeof DEV, DEV);\n}\n\n// Import graphql/jsutils/instanceOf safely, working around its unchecked usage\n// of process.env.NODE_ENV and https://github.com/graphql/graphql-js/pull/2894.\nimport { removeTemporaryGlobals } from \"./fix-graphql\";\n\n// Synchronously undo the global process.env.NODE_ENV polyfill that we created\n// temporarily while importing the offending graphql/jsutils/instanceOf module.\nremoveTemporaryGlobals();\n\nexport { maybe } from \"./maybe\";\nexport { default as global } from \"./global\";\nexport { invariant, InvariantError }\n\n// Ensure __DEV__ was properly initialized, and prevent tree-shaking bundlers\n// from mistakenly pruning the ./DEV module (see issue #8674).\ncheckDEV();\n","import * as Vue from 'vue'\n\nvar isVue2 = false\nvar isVue3 = true\nvar Vue2 = undefined\n\nfunction install() {}\n\nexport function set(target, key, val) {\n  if (Array.isArray(target)) {\n    target.length = Math.max(target.length, key)\n    target.splice(key, 1, val)\n    return val\n  }\n  target[key] = val\n  return val\n}\n\nexport function del(target, key) {\n  if (Array.isArray(target)) {\n    target.splice(key, 1)\n    return\n  }\n  delete target[key]\n}\n\nexport * from 'vue'\nexport {\n  Vue,\n  Vue2,\n  isVue2,\n  isVue3,\n  install,\n}\n"],"names":["delay","noTrailing","callback","debounceMode","timeoutID","cancelled","lastExec","clearExistingTimeout","clearTimeout","cancel","wrapper","arguments_","arguments","self","this","elapsed","Date","now","exec","apply","clear","undefined","setTimeout","atBegin","throttle","DefaultApolloClient","Symbol","ApolloClients","resolveDefaultClient","providedApolloClients","providedApolloClient","resolvedClient","default","resolveClientWithId","clientId","Error","useApolloClient","resolveImpl","savedCurrentClients","currentApolloClients","getCurrentInstance","inject","id","client2","client","resolveClient","provideApolloClient","fn","result","provideApolloClients","clients","paramToRef","param","isRef","computed","ref","paramToReactive","isRef2","computed2","reactive","useEventHook","fns","on","push","off","index","indexOf","splice","trigger","getCount","length","getAppTracking","vm","getCurrentInstance2","root","$root","appTracking","_apolloAppTracking","queries","ref2","mutations","subscriptions","components","Map","getCurrentTracking","tracking","has","get","set","onUnmounted","delete","track","loading","type","watch","value","oldValue","mod","immediate","onBeforeUnmount","trackQuery","trackMutation","trackSubscription","toApolloError","error","isApolloError","ApolloError","networkError","errorMessage","message","Object","assign","originalError","String","resultErrorsToApolloError","errors","graphQLErrors","map","e","join","isServer","window","useQuery","document","variables","options","useQueryImpl","lazy","getCurrentInstance3","currentOptions","ref3","documentRef","variablesRef","optionsRef","resultEvent","errorEvent","networkStatus","firstResolve","firstReject","onServerPrefetch","isEnabled","prefetch","Promise","resolve","reject","apolloError","then","stop","catch","query","observer","started","start","watchQuery","currentDocument","currentVariables","fetchPolicy","startQuerySubscription","notifyOnNetworkStatusChange","currentResult","getCurrentResult","partial","onNextResult","item","subscribeToMoreItems","addSubscribeToMore","closed","subscribe","next","onError","queryResult","processNextResult","processError","data","keys","queryError","errorPolicy","defaultOptions","resubscribeToQuery","lastError","getLastError","lastResult","getLastResult","resetLastResults","onStopHandlers","forEach","handler","stopPolling","unsubscribe","debouncedRestart","restarting","baseRestart","nextTick","currentVariablesSerialized","isRestartDebounceSetup","updateRestartFn","debounce","restart","refetch","variables2","fetchMore","options2","watch2","serialized","JSON","stringify","deep","unref","subscribeToMore","optionsRef2","onCleanup","findIndex","item2","unsubscribeFns","forceDisabled","enabledOption","computed3","enabled","onBeforeUnmount2","onResult","useLazyQuery","load","document2","isRef4","useMutation","getCurrentInstance4","ref4","called","doneEvent","async","mutate","overrideOptions","isRef5","mutation","throws","onBeforeUnmount3","onDone","useSubscription","getCurrentInstance5","ref5","subscription","fetchResult","fetchError","nextTick2","throttle2","debounce2","watch3","isRef6","computed4","onBeforeUnmount4","useResult","defaultValue","pick","console","warn","computed5","useQueryLoading","computed6","useMutationLoading","useSubscriptionLoading","useGlobalQueryLoading","useGlobalMutationLoading","useGlobalSubscriptionLoading","extendStatics","d","b","setPrototypeOf","__proto__","Array","p","prototype","hasOwnProperty","call","__extends","TypeError","__","constructor","create","__assign","t","s","i","n","__rest","getOwnPropertySymbols","propertyIsEnumerable","__awaiter","thisArg","_arguments","P","generator","adopt","fulfilled","step","rejected","done","__generator","body","f","y","g","_","label","sent","trys","ops","verb","iterator","v","op","pop","__spreadArray","to","from","pack","ar","l","slice","concat","err","generateErrorMessage","isNonEmptyArray","clientErrors","replace","_a","extraInfo","_super","_this","isArray","genericMessage","obj","proto","InvariantError","invariant","condition","verbosityLevels","verbosityLevel","wrapConsoleMethod","name","method","log","maybe","thunk","globalThis","global","GLOBAL_KEY","getDEV","Boolean","__DEV__","defineProperty","enumerable","configurable","writable","safeGlobal","needToRemove","install","process","env","NODE_ENV","remove","removeTemporaryGlobals","Source","checkDEV","DEV","isVue2","target","key","val","Math","max"],"sourceRoot":""}