{"version":3,"file":"9421.bundle.997a943b9707191a3aee.js","mappings":"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","sources":["webpack://fieldlevel.app/./node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.production.js","webpack://fieldlevel.app/./node_modules/use-sync-external-store/shim/index.js","webpack://fieldlevel.app/./node_modules/@tanstack/query-core/build/lib/queryObserver.mjs","webpack://fieldlevel.app/./node_modules/@tanstack/react-query/build/lib/QueryErrorResetBoundary.mjs","webpack://fieldlevel.app/./node_modules/@tanstack/react-query/build/lib/isRestoring.mjs","webpack://fieldlevel.app/./node_modules/@tanstack/react-query/build/lib/errorBoundaryUtils.mjs","webpack://fieldlevel.app/./node_modules/@tanstack/react-query/build/lib/suspense.mjs","webpack://fieldlevel.app/./node_modules/@tanstack/react-query/build/lib/useBaseQuery.mjs","webpack://fieldlevel.app/./node_modules/@tanstack/react-query/build/lib/useQuery.mjs","webpack://fieldlevel.app/./node_modules/@tanstack/react-query/build/lib/useSyncExternalStore.mjs","webpack://fieldlevel.app/./node_modules/@tanstack/react-query/build/lib/utils.mjs"],"sourcesContent":["/**\n * @license React\n * use-sync-external-store-shim.production.js\n *\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n\"use strict\";\nvar React = require(\"react\");\nfunction is(x, y) {\n  return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);\n}\nvar objectIs = \"function\" === typeof Object.is ? Object.is : is,\n  useState = React.useState,\n  useEffect = React.useEffect,\n  useLayoutEffect = React.useLayoutEffect,\n  useDebugValue = React.useDebugValue;\nfunction useSyncExternalStore$2(subscribe, getSnapshot) {\n  var value = getSnapshot(),\n    _useState = useState({ inst: { value: value, getSnapshot: getSnapshot } }),\n    inst = _useState[0].inst,\n    forceUpdate = _useState[1];\n  useLayoutEffect(\n    function () {\n      inst.value = value;\n      inst.getSnapshot = getSnapshot;\n      checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });\n    },\n    [subscribe, value, getSnapshot]\n  );\n  useEffect(\n    function () {\n      checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });\n      return subscribe(function () {\n        checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });\n      });\n    },\n    [subscribe]\n  );\n  useDebugValue(value);\n  return value;\n}\nfunction checkIfSnapshotChanged(inst) {\n  var latestGetSnapshot = inst.getSnapshot;\n  inst = inst.value;\n  try {\n    var nextValue = latestGetSnapshot();\n    return !objectIs(inst, nextValue);\n  } catch (error) {\n    return !0;\n  }\n}\nfunction useSyncExternalStore$1(subscribe, getSnapshot) {\n  return getSnapshot();\n}\nvar shim =\n  \"undefined\" === typeof window ||\n  \"undefined\" === typeof window.document ||\n  \"undefined\" === typeof window.document.createElement\n    ? useSyncExternalStore$1\n    : useSyncExternalStore$2;\nexports.useSyncExternalStore =\n  void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('../cjs/use-sync-external-store-shim.production.js');\n} else {\n  module.exports = require('../cjs/use-sync-external-store-shim.development.js');\n}\n","import { shallowEqualObjects, noop, isServer, isValidTimeout, timeUntilStale, replaceData } from './utils.mjs';\nimport { notifyManager } from './notifyManager.mjs';\nimport { focusManager } from './focusManager.mjs';\nimport { Subscribable } from './subscribable.mjs';\nimport { canFetch, isCancelledError } from './retryer.mjs';\n\nclass QueryObserver extends Subscribable {\n  constructor(client, options) {\n    super();\n    this.client = client;\n    this.options = options;\n    this.trackedProps = new Set();\n    this.selectError = null;\n    this.bindMethods();\n    this.setOptions(options);\n  }\n\n  bindMethods() {\n    this.remove = this.remove.bind(this);\n    this.refetch = this.refetch.bind(this);\n  }\n\n  onSubscribe() {\n    if (this.listeners.size === 1) {\n      this.currentQuery.addObserver(this);\n\n      if (shouldFetchOnMount(this.currentQuery, this.options)) {\n        this.executeFetch();\n      }\n\n      this.updateTimers();\n    }\n  }\n\n  onUnsubscribe() {\n    if (!this.hasListeners()) {\n      this.destroy();\n    }\n  }\n\n  shouldFetchOnReconnect() {\n    return shouldFetchOn(this.currentQuery, this.options, this.options.refetchOnReconnect);\n  }\n\n  shouldFetchOnWindowFocus() {\n    return shouldFetchOn(this.currentQuery, this.options, this.options.refetchOnWindowFocus);\n  }\n\n  destroy() {\n    this.listeners = new Set();\n    this.clearStaleTimeout();\n    this.clearRefetchInterval();\n    this.currentQuery.removeObserver(this);\n  }\n\n  setOptions(options, notifyOptions) {\n    const prevOptions = this.options;\n    const prevQuery = this.currentQuery;\n    this.options = this.client.defaultQueryOptions(options);\n\n    if (process.env.NODE_ENV !== 'production' && typeof (options == null ? void 0 : options.isDataEqual) !== 'undefined') {\n      this.client.getLogger().error(\"The isDataEqual option has been deprecated and will be removed in the next major version. You can achieve the same functionality by passing a function as the structuralSharing option\");\n    }\n\n    if (!shallowEqualObjects(prevOptions, this.options)) {\n      this.client.getQueryCache().notify({\n        type: 'observerOptionsUpdated',\n        query: this.currentQuery,\n        observer: this\n      });\n    }\n\n    if (typeof this.options.enabled !== 'undefined' && typeof this.options.enabled !== 'boolean') {\n      throw new Error('Expected enabled to be a boolean');\n    } // Keep previous query key if the user does not supply one\n\n\n    if (!this.options.queryKey) {\n      this.options.queryKey = prevOptions.queryKey;\n    }\n\n    this.updateQuery();\n    const mounted = this.hasListeners(); // Fetch if there are subscribers\n\n    if (mounted && shouldFetchOptionally(this.currentQuery, prevQuery, this.options, prevOptions)) {\n      this.executeFetch();\n    } // Update result\n\n\n    this.updateResult(notifyOptions); // Update stale interval if needed\n\n    if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.staleTime !== prevOptions.staleTime)) {\n      this.updateStaleTimeout();\n    }\n\n    const nextRefetchInterval = this.computeRefetchInterval(); // Update refetch interval if needed\n\n    if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || nextRefetchInterval !== this.currentRefetchInterval)) {\n      this.updateRefetchInterval(nextRefetchInterval);\n    }\n  }\n\n  getOptimisticResult(options) {\n    const query = this.client.getQueryCache().build(this.client, options);\n    const result = this.createResult(query, options);\n\n    if (shouldAssignObserverCurrentProperties(this, result, options)) {\n      // this assigns the optimistic result to the current Observer\n      // because if the query function changes, useQuery will be performing\n      // an effect where it would fetch again.\n      // When the fetch finishes, we perform a deep data cloning in order\n      // to reuse objects references. This deep data clone is performed against\n      // the `observer.currentResult.data` property\n      // When QueryKey changes, we refresh the query and get new `optimistic`\n      // result, while we leave the `observer.currentResult`, so when new data\n      // arrives, it finds the old `observer.currentResult` which is related\n      // to the old QueryKey. Which means that currentResult and selectData are\n      // out of sync already.\n      // To solve this, we move the cursor of the currentResult everytime\n      // an observer reads an optimistic value.\n      // When keeping the previous data, the result doesn't change until new\n      // data arrives.\n      this.currentResult = result;\n      this.currentResultOptions = this.options;\n      this.currentResultState = this.currentQuery.state;\n    }\n\n    return result;\n  }\n\n  getCurrentResult() {\n    return this.currentResult;\n  }\n\n  trackResult(result) {\n    const trackedResult = {};\n    Object.keys(result).forEach(key => {\n      Object.defineProperty(trackedResult, key, {\n        configurable: false,\n        enumerable: true,\n        get: () => {\n          this.trackedProps.add(key);\n          return result[key];\n        }\n      });\n    });\n    return trackedResult;\n  }\n\n  getCurrentQuery() {\n    return this.currentQuery;\n  }\n\n  remove() {\n    this.client.getQueryCache().remove(this.currentQuery);\n  }\n\n  refetch({\n    refetchPage,\n    ...options\n  } = {}) {\n    return this.fetch({ ...options,\n      meta: {\n        refetchPage\n      }\n    });\n  }\n\n  fetchOptimistic(options) {\n    const defaultedOptions = this.client.defaultQueryOptions(options);\n    const query = this.client.getQueryCache().build(this.client, defaultedOptions);\n    query.isFetchingOptimistic = true;\n    return query.fetch().then(() => this.createResult(query, defaultedOptions));\n  }\n\n  fetch(fetchOptions) {\n    var _fetchOptions$cancelR;\n\n    return this.executeFetch({ ...fetchOptions,\n      cancelRefetch: (_fetchOptions$cancelR = fetchOptions.cancelRefetch) != null ? _fetchOptions$cancelR : true\n    }).then(() => {\n      this.updateResult();\n      return this.currentResult;\n    });\n  }\n\n  executeFetch(fetchOptions) {\n    // Make sure we reference the latest query as the current one might have been removed\n    this.updateQuery(); // Fetch\n\n    let promise = this.currentQuery.fetch(this.options, fetchOptions);\n\n    if (!(fetchOptions != null && fetchOptions.throwOnError)) {\n      promise = promise.catch(noop);\n    }\n\n    return promise;\n  }\n\n  updateStaleTimeout() {\n    this.clearStaleTimeout();\n\n    if (isServer || this.currentResult.isStale || !isValidTimeout(this.options.staleTime)) {\n      return;\n    }\n\n    const time = timeUntilStale(this.currentResult.dataUpdatedAt, this.options.staleTime); // The timeout is sometimes triggered 1 ms before the stale time expiration.\n    // To mitigate this issue we always add 1 ms to the timeout.\n\n    const timeout = time + 1;\n    this.staleTimeoutId = setTimeout(() => {\n      if (!this.currentResult.isStale) {\n        this.updateResult();\n      }\n    }, timeout);\n  }\n\n  computeRefetchInterval() {\n    var _this$options$refetch;\n\n    return typeof this.options.refetchInterval === 'function' ? this.options.refetchInterval(this.currentResult.data, this.currentQuery) : (_this$options$refetch = this.options.refetchInterval) != null ? _this$options$refetch : false;\n  }\n\n  updateRefetchInterval(nextInterval) {\n    this.clearRefetchInterval();\n    this.currentRefetchInterval = nextInterval;\n\n    if (isServer || this.options.enabled === false || !isValidTimeout(this.currentRefetchInterval) || this.currentRefetchInterval === 0) {\n      return;\n    }\n\n    this.refetchIntervalId = setInterval(() => {\n      if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {\n        this.executeFetch();\n      }\n    }, this.currentRefetchInterval);\n  }\n\n  updateTimers() {\n    this.updateStaleTimeout();\n    this.updateRefetchInterval(this.computeRefetchInterval());\n  }\n\n  clearStaleTimeout() {\n    if (this.staleTimeoutId) {\n      clearTimeout(this.staleTimeoutId);\n      this.staleTimeoutId = undefined;\n    }\n  }\n\n  clearRefetchInterval() {\n    if (this.refetchIntervalId) {\n      clearInterval(this.refetchIntervalId);\n      this.refetchIntervalId = undefined;\n    }\n  }\n\n  createResult(query, options) {\n    const prevQuery = this.currentQuery;\n    const prevOptions = this.options;\n    const prevResult = this.currentResult;\n    const prevResultState = this.currentResultState;\n    const prevResultOptions = this.currentResultOptions;\n    const queryChange = query !== prevQuery;\n    const queryInitialState = queryChange ? query.state : this.currentQueryInitialState;\n    const prevQueryResult = queryChange ? this.currentResult : this.previousQueryResult;\n    const {\n      state\n    } = query;\n    let {\n      dataUpdatedAt,\n      error,\n      errorUpdatedAt,\n      fetchStatus,\n      status\n    } = state;\n    let isPreviousData = false;\n    let isPlaceholderData = false;\n    let data; // Optimistically set result in fetching state if needed\n\n    if (options._optimisticResults) {\n      const mounted = this.hasListeners();\n      const fetchOnMount = !mounted && shouldFetchOnMount(query, options);\n      const fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);\n\n      if (fetchOnMount || fetchOptionally) {\n        fetchStatus = canFetch(query.options.networkMode) ? 'fetching' : 'paused';\n\n        if (!dataUpdatedAt) {\n          status = 'loading';\n        }\n      }\n\n      if (options._optimisticResults === 'isRestoring') {\n        fetchStatus = 'idle';\n      }\n    } // Keep previous data if needed\n\n\n    if (options.keepPreviousData && !state.dataUpdatedAt && prevQueryResult != null && prevQueryResult.isSuccess && status !== 'error') {\n      data = prevQueryResult.data;\n      dataUpdatedAt = prevQueryResult.dataUpdatedAt;\n      status = prevQueryResult.status;\n      isPreviousData = true;\n    } // Select data if needed\n    else if (options.select && typeof state.data !== 'undefined') {\n      // Memoize select result\n      if (prevResult && state.data === (prevResultState == null ? void 0 : prevResultState.data) && options.select === this.selectFn) {\n        data = this.selectResult;\n      } else {\n        try {\n          this.selectFn = options.select;\n          data = options.select(state.data);\n          data = replaceData(prevResult == null ? void 0 : prevResult.data, data, options);\n          this.selectResult = data;\n          this.selectError = null;\n        } catch (selectError) {\n          if (process.env.NODE_ENV !== 'production') {\n            this.client.getLogger().error(selectError);\n          }\n\n          this.selectError = selectError;\n        }\n      }\n    } // Use query data\n    else {\n      data = state.data;\n    } // Show placeholder data if needed\n\n\n    if (typeof options.placeholderData !== 'undefined' && typeof data === 'undefined' && status === 'loading') {\n      let placeholderData; // Memoize placeholder data\n\n      if (prevResult != null && prevResult.isPlaceholderData && options.placeholderData === (prevResultOptions == null ? void 0 : prevResultOptions.placeholderData)) {\n        placeholderData = prevResult.data;\n      } else {\n        placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData() : options.placeholderData;\n\n        if (options.select && typeof placeholderData !== 'undefined') {\n          try {\n            placeholderData = options.select(placeholderData);\n            this.selectError = null;\n          } catch (selectError) {\n            if (process.env.NODE_ENV !== 'production') {\n              this.client.getLogger().error(selectError);\n            }\n\n            this.selectError = selectError;\n          }\n        }\n      }\n\n      if (typeof placeholderData !== 'undefined') {\n        status = 'success';\n        data = replaceData(prevResult == null ? void 0 : prevResult.data, placeholderData, options);\n        isPlaceholderData = true;\n      }\n    }\n\n    if (this.selectError) {\n      error = this.selectError;\n      data = this.selectResult;\n      errorUpdatedAt = Date.now();\n      status = 'error';\n    }\n\n    const isFetching = fetchStatus === 'fetching';\n    const isLoading = status === 'loading';\n    const isError = status === 'error';\n    const result = {\n      status,\n      fetchStatus,\n      isLoading,\n      isSuccess: status === 'success',\n      isError,\n      isInitialLoading: isLoading && isFetching,\n      data,\n      dataUpdatedAt,\n      error,\n      errorUpdatedAt,\n      failureCount: state.fetchFailureCount,\n      failureReason: state.fetchFailureReason,\n      errorUpdateCount: state.errorUpdateCount,\n      isFetched: state.dataUpdateCount > 0 || state.errorUpdateCount > 0,\n      isFetchedAfterMount: state.dataUpdateCount > queryInitialState.dataUpdateCount || state.errorUpdateCount > queryInitialState.errorUpdateCount,\n      isFetching,\n      isRefetching: isFetching && !isLoading,\n      isLoadingError: isError && state.dataUpdatedAt === 0,\n      isPaused: fetchStatus === 'paused',\n      isPlaceholderData,\n      isPreviousData,\n      isRefetchError: isError && state.dataUpdatedAt !== 0,\n      isStale: isStale(query, options),\n      refetch: this.refetch,\n      remove: this.remove\n    };\n    return result;\n  }\n\n  updateResult(notifyOptions) {\n    const prevResult = this.currentResult;\n    const nextResult = this.createResult(this.currentQuery, this.options);\n    this.currentResultState = this.currentQuery.state;\n    this.currentResultOptions = this.options; // Only notify and update result if something has changed\n\n    if (shallowEqualObjects(nextResult, prevResult)) {\n      return;\n    }\n\n    this.currentResult = nextResult; // Determine which callbacks to trigger\n\n    const defaultNotifyOptions = {\n      cache: true\n    };\n\n    const shouldNotifyListeners = () => {\n      if (!prevResult) {\n        return true;\n      }\n\n      const {\n        notifyOnChangeProps\n      } = this.options;\n      const notifyOnChangePropsValue = typeof notifyOnChangeProps === 'function' ? notifyOnChangeProps() : notifyOnChangeProps;\n\n      if (notifyOnChangePropsValue === 'all' || !notifyOnChangePropsValue && !this.trackedProps.size) {\n        return true;\n      }\n\n      const includedProps = new Set(notifyOnChangePropsValue != null ? notifyOnChangePropsValue : this.trackedProps);\n\n      if (this.options.useErrorBoundary) {\n        includedProps.add('error');\n      }\n\n      return Object.keys(this.currentResult).some(key => {\n        const typedKey = key;\n        const changed = this.currentResult[typedKey] !== prevResult[typedKey];\n        return changed && includedProps.has(typedKey);\n      });\n    };\n\n    if ((notifyOptions == null ? void 0 : notifyOptions.listeners) !== false && shouldNotifyListeners()) {\n      defaultNotifyOptions.listeners = true;\n    }\n\n    this.notify({ ...defaultNotifyOptions,\n      ...notifyOptions\n    });\n  }\n\n  updateQuery() {\n    const query = this.client.getQueryCache().build(this.client, this.options);\n\n    if (query === this.currentQuery) {\n      return;\n    }\n\n    const prevQuery = this.currentQuery;\n    this.currentQuery = query;\n    this.currentQueryInitialState = query.state;\n    this.previousQueryResult = this.currentResult;\n\n    if (this.hasListeners()) {\n      prevQuery == null ? void 0 : prevQuery.removeObserver(this);\n      query.addObserver(this);\n    }\n  }\n\n  onQueryUpdate(action) {\n    const notifyOptions = {};\n\n    if (action.type === 'success') {\n      notifyOptions.onSuccess = !action.manual;\n    } else if (action.type === 'error' && !isCancelledError(action.error)) {\n      notifyOptions.onError = true;\n    }\n\n    this.updateResult(notifyOptions);\n\n    if (this.hasListeners()) {\n      this.updateTimers();\n    }\n  }\n\n  notify(notifyOptions) {\n    notifyManager.batch(() => {\n      // First trigger the configuration callbacks\n      if (notifyOptions.onSuccess) {\n        var _this$options$onSucce, _this$options, _this$options$onSettl, _this$options2;\n\n        (_this$options$onSucce = (_this$options = this.options).onSuccess) == null ? void 0 : _this$options$onSucce.call(_this$options, this.currentResult.data);\n        (_this$options$onSettl = (_this$options2 = this.options).onSettled) == null ? void 0 : _this$options$onSettl.call(_this$options2, this.currentResult.data, null);\n      } else if (notifyOptions.onError) {\n        var _this$options$onError, _this$options3, _this$options$onSettl2, _this$options4;\n\n        (_this$options$onError = (_this$options3 = this.options).onError) == null ? void 0 : _this$options$onError.call(_this$options3, this.currentResult.error);\n        (_this$options$onSettl2 = (_this$options4 = this.options).onSettled) == null ? void 0 : _this$options$onSettl2.call(_this$options4, undefined, this.currentResult.error);\n      } // Then trigger the listeners\n\n\n      if (notifyOptions.listeners) {\n        this.listeners.forEach(({\n          listener\n        }) => {\n          listener(this.currentResult);\n        });\n      } // Then the cache listeners\n\n\n      if (notifyOptions.cache) {\n        this.client.getQueryCache().notify({\n          query: this.currentQuery,\n          type: 'observerResultsUpdated'\n        });\n      }\n    });\n  }\n\n}\n\nfunction shouldLoadOnMount(query, options) {\n  return options.enabled !== false && !query.state.dataUpdatedAt && !(query.state.status === 'error' && options.retryOnMount === false);\n}\n\nfunction shouldFetchOnMount(query, options) {\n  return shouldLoadOnMount(query, options) || query.state.dataUpdatedAt > 0 && shouldFetchOn(query, options, options.refetchOnMount);\n}\n\nfunction shouldFetchOn(query, options, field) {\n  if (options.enabled !== false) {\n    const value = typeof field === 'function' ? field(query) : field;\n    return value === 'always' || value !== false && isStale(query, options);\n  }\n\n  return false;\n}\n\nfunction shouldFetchOptionally(query, prevQuery, options, prevOptions) {\n  return options.enabled !== false && (query !== prevQuery || prevOptions.enabled === false) && (!options.suspense || query.state.status !== 'error') && isStale(query, options);\n}\n\nfunction isStale(query, options) {\n  return query.isStaleByTime(options.staleTime);\n} // this function would decide if we will update the observer's 'current'\n// properties after an optimistic reading via getOptimisticResult\n\n\nfunction shouldAssignObserverCurrentProperties(observer, optimisticResult, options) {\n  // it is important to keep this condition like this for three reasons:\n  // 1. It will get removed in the v5\n  // 2. it reads: don't update the properties if we want to keep the previous\n  // data.\n  // 3. The opposite condition (!options.keepPreviousData) would fallthrough\n  // and will result in a bad decision\n  if (options.keepPreviousData) {\n    return false;\n  } // this means we want to put some placeholder data when pending and queryKey\n  // changed.\n\n\n  if (options.placeholderData !== undefined) {\n    // re-assign properties only if current data is placeholder data\n    // which means that data did not arrive yet, so, if there is some cached data\n    // we need to \"prepare\" to receive it\n    return optimisticResult.isPlaceholderData;\n  } // if the newly created result isn't what the observer is holding as current,\n  // then we'll need to update the properties as well\n\n\n  if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {\n    return true;\n  } // basically, just keep previous properties if nothing changed\n\n\n  return false;\n}\n\nexport { QueryObserver };\n//# sourceMappingURL=queryObserver.mjs.map\n","'use client';\nimport * as React from 'react';\n\nfunction createValue() {\n  let isReset = false;\n  return {\n    clearReset: () => {\n      isReset = false;\n    },\n    reset: () => {\n      isReset = true;\n    },\n    isReset: () => {\n      return isReset;\n    }\n  };\n}\n\nconst QueryErrorResetBoundaryContext = /*#__PURE__*/React.createContext(createValue()); // HOOK\n\nconst useQueryErrorResetBoundary = () => React.useContext(QueryErrorResetBoundaryContext); // COMPONENT\n\nconst QueryErrorResetBoundary = ({\n  children\n}) => {\n  const [value] = React.useState(() => createValue());\n  return /*#__PURE__*/React.createElement(QueryErrorResetBoundaryContext.Provider, {\n    value: value\n  }, typeof children === 'function' ? children(value) : children);\n};\n\nexport { QueryErrorResetBoundary, useQueryErrorResetBoundary };\n//# sourceMappingURL=QueryErrorResetBoundary.mjs.map\n","'use client';\nimport * as React from 'react';\n\nconst IsRestoringContext = /*#__PURE__*/React.createContext(false);\nconst useIsRestoring = () => React.useContext(IsRestoringContext);\nconst IsRestoringProvider = IsRestoringContext.Provider;\n\nexport { IsRestoringProvider, useIsRestoring };\n//# sourceMappingURL=isRestoring.mjs.map\n","'use client';\nimport * as React from 'react';\nimport { shouldThrowError } from './utils.mjs';\n\nconst ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {\n  if (options.suspense || options.useErrorBoundary) {\n    // Prevent retrying failed query if the error boundary has not been reset yet\n    if (!errorResetBoundary.isReset()) {\n      options.retryOnMount = false;\n    }\n  }\n};\nconst useClearResetErrorBoundary = errorResetBoundary => {\n  React.useEffect(() => {\n    errorResetBoundary.clearReset();\n  }, [errorResetBoundary]);\n};\nconst getHasError = ({\n  result,\n  errorResetBoundary,\n  useErrorBoundary,\n  query\n}) => {\n  return result.isError && !errorResetBoundary.isReset() && !result.isFetching && shouldThrowError(useErrorBoundary, [result.error, query]);\n};\n\nexport { ensurePreventErrorBoundaryRetry, getHasError, useClearResetErrorBoundary };\n//# sourceMappingURL=errorBoundaryUtils.mjs.map\n","const ensureStaleTime = defaultedOptions => {\n  if (defaultedOptions.suspense) {\n    // Always set stale time when using suspense to prevent\n    // fetching again when directly mounting after suspending\n    if (typeof defaultedOptions.staleTime !== 'number') {\n      defaultedOptions.staleTime = 1000;\n    }\n  }\n};\nconst willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;\nconst shouldSuspend = (defaultedOptions, result, isRestoring) => (defaultedOptions == null ? void 0 : defaultedOptions.suspense) && willFetch(result, isRestoring);\nconst fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).then(({\n  data\n}) => {\n  defaultedOptions.onSuccess == null ? void 0 : defaultedOptions.onSuccess(data);\n  defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(data, null);\n}).catch(error => {\n  errorResetBoundary.clearReset();\n  defaultedOptions.onError == null ? void 0 : defaultedOptions.onError(error);\n  defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(undefined, error);\n});\n\nexport { ensureStaleTime, fetchOptimistic, shouldSuspend, willFetch };\n//# sourceMappingURL=suspense.mjs.map\n","'use client';\nimport * as React from 'react';\nimport { notifyManager } from '@tanstack/query-core';\nimport { useSyncExternalStore } from './useSyncExternalStore.mjs';\nimport { useQueryErrorResetBoundary } from './QueryErrorResetBoundary.mjs';\nimport { useQueryClient } from './QueryClientProvider.mjs';\nimport { useIsRestoring } from './isRestoring.mjs';\nimport { ensurePreventErrorBoundaryRetry, useClearResetErrorBoundary, getHasError } from './errorBoundaryUtils.mjs';\nimport { ensureStaleTime, shouldSuspend, fetchOptimistic } from './suspense.mjs';\n\nfunction useBaseQuery(options, Observer) {\n  const queryClient = useQueryClient({\n    context: options.context\n  });\n  const isRestoring = useIsRestoring();\n  const errorResetBoundary = useQueryErrorResetBoundary();\n  const defaultedOptions = queryClient.defaultQueryOptions(options); // Make sure results are optimistically set in fetching state before subscribing or updating options\n\n  defaultedOptions._optimisticResults = isRestoring ? 'isRestoring' : 'optimistic'; // Include callbacks in batch renders\n\n  if (defaultedOptions.onError) {\n    defaultedOptions.onError = notifyManager.batchCalls(defaultedOptions.onError);\n  }\n\n  if (defaultedOptions.onSuccess) {\n    defaultedOptions.onSuccess = notifyManager.batchCalls(defaultedOptions.onSuccess);\n  }\n\n  if (defaultedOptions.onSettled) {\n    defaultedOptions.onSettled = notifyManager.batchCalls(defaultedOptions.onSettled);\n  }\n\n  ensureStaleTime(defaultedOptions);\n  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);\n  useClearResetErrorBoundary(errorResetBoundary);\n  const [observer] = React.useState(() => new Observer(queryClient, defaultedOptions));\n  const result = observer.getOptimisticResult(defaultedOptions);\n  useSyncExternalStore(React.useCallback(onStoreChange => {\n    const unsubscribe = isRestoring ? () => undefined : observer.subscribe(notifyManager.batchCalls(onStoreChange)); // Update result to make sure we did not miss any query updates\n    // between creating the observer and subscribing to it.\n\n    observer.updateResult();\n    return unsubscribe;\n  }, [observer, isRestoring]), () => observer.getCurrentResult(), () => observer.getCurrentResult());\n  React.useEffect(() => {\n    // Do not notify on updates because of changes in the options because\n    // these changes should already be reflected in the optimistic result.\n    observer.setOptions(defaultedOptions, {\n      listeners: false\n    });\n  }, [defaultedOptions, observer]); // Handle suspense\n\n  if (shouldSuspend(defaultedOptions, result, isRestoring)) {\n    throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);\n  } // Handle error boundary\n\n\n  if (getHasError({\n    result,\n    errorResetBoundary,\n    useErrorBoundary: defaultedOptions.useErrorBoundary,\n    query: observer.getCurrentQuery()\n  })) {\n    throw result.error;\n  } // Handle result property usage tracking\n\n\n  return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;\n}\n\nexport { useBaseQuery };\n//# sourceMappingURL=useBaseQuery.mjs.map\n","'use client';\nimport { parseQueryArgs, QueryObserver } from '@tanstack/query-core';\nimport { useBaseQuery } from './useBaseQuery.mjs';\n\nfunction useQuery(arg1, arg2, arg3) {\n  const parsedOptions = parseQueryArgs(arg1, arg2, arg3);\n  return useBaseQuery(parsedOptions, QueryObserver);\n}\n\nexport { useQuery };\n//# sourceMappingURL=useQuery.mjs.map\n","'use client';\nimport { useSyncExternalStore as useSyncExternalStore$1 } from 'use-sync-external-store/shim/index.js';\n\nconst useSyncExternalStore = useSyncExternalStore$1;\n\nexport { useSyncExternalStore };\n//# sourceMappingURL=useSyncExternalStore.mjs.map\n","function shouldThrowError(_useErrorBoundary, params) {\n  // Allow useErrorBoundary function to override throwing behavior on a per-error basis\n  if (typeof _useErrorBoundary === 'function') {\n    return _useErrorBoundary(...params);\n  }\n\n  return !!_useErrorBoundary;\n}\n\nexport { shouldThrowError };\n//# sourceMappingURL=utils.mjs.map\n"],"names":["React","objectIs","Object","is","x","y","useState","useEffect","useLayoutEffect","useDebugValue","checkIfSnapshotChanged","inst","latestGetSnapshot","getSnapshot","value","nextValue","error","shim","window","document","createElement","subscribe","_useState","forceUpdate","exports","useSyncExternalStore","module","QueryObserver","constructor","client","options","super","this","trackedProps","Set","selectError","bindMethods","setOptions","remove","bind","refetch","onSubscribe","listeners","size","currentQuery","addObserver","shouldFetchOnMount","executeFetch","updateTimers","onUnsubscribe","hasListeners","destroy","shouldFetchOnReconnect","shouldFetchOn","refetchOnReconnect","shouldFetchOnWindowFocus","refetchOnWindowFocus","clearStaleTimeout","clearRefetchInterval","removeObserver","notifyOptions","prevOptions","prevQuery","defaultQueryOptions","getQueryCache","notify","type","query","observer","enabled","Error","queryKey","updateQuery","mounted","shouldFetchOptionally","updateResult","staleTime","updateStaleTimeout","nextRefetchInterval","computeRefetchInterval","currentRefetchInterval","updateRefetchInterval","getOptimisticResult","build","result","createResult","optimisticResult","keepPreviousData","undefined","placeholderData","isPlaceholderData","getCurrentResult","shouldAssignObserverCurrentProperties","currentResult","currentResultOptions","currentResultState","state","trackResult","trackedResult","keys","forEach","key","defineProperty","configurable","enumerable","get","add","getCurrentQuery","refetchPage","fetch","meta","fetchOptimistic","defaultedOptions","isFetchingOptimistic","then","fetchOptions","_fetchOptions$cancelR","cancelRefetch","promise","throwOnError","catch","isStale","timeout","dataUpdatedAt","staleTimeoutId","setTimeout","_this$options$refetch","refetchInterval","data","nextInterval","refetchIntervalId","setInterval","refetchIntervalInBackground","isFocused","clearTimeout","clearInterval","prevResult","prevResultState","prevResultOptions","queryChange","queryInitialState","currentQueryInitialState","prevQueryResult","previousQueryResult","errorUpdatedAt","fetchStatus","status","isPreviousData","_optimisticResults","fetchOnMount","fetchOptionally","networkMode","isSuccess","select","selectFn","selectResult","Date","now","isFetching","isLoading","isError","isInitialLoading","failureCount","fetchFailureCount","failureReason","fetchFailureReason","errorUpdateCount","isFetched","dataUpdateCount","isFetchedAfterMount","isRefetching","isLoadingError","isPaused","isRefetchError","nextResult","defaultNotifyOptions","cache","notifyOnChangeProps","notifyOnChangePropsValue","includedProps","useErrorBoundary","some","typedKey","has","shouldNotifyListeners","onQueryUpdate","action","onSuccess","manual","onError","batch","_this$options$onSucce","_this$options","_this$options$onSettl","_this$options2","call","onSettled","_this$options$onError","_this$options3","_this$options$onSettl2","_this$options4","listener","retryOnMount","shouldLoadOnMount","refetchOnMount","field","suspense","isStaleByTime","createValue","isReset","clearReset","reset","QueryErrorResetBoundaryContext","useQueryErrorResetBoundary","IsRestoringContext","useIsRestoring","Provider","ensurePreventErrorBoundaryRetry","errorResetBoundary","useClearResetErrorBoundary","getHasError","ensureStaleTime","shouldSuspend","isRestoring","willFetch","useBaseQuery","Observer","queryClient","context","notifyManager","batchCalls","onStoreChange","unsubscribe","useQuery","arg1","arg2","arg3","parsedOptions","shouldThrowError","_useErrorBoundary","params"],"sourceRoot":""}