{"version":3,"file":"js/6655-3c171093c9ded78eb649.js","mappings":"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","sources":["webpack:///./node_modules/@apollo/client/react/hooks/internal/__use.js","webpack:///./node_modules/@apollo/client/react/hooks/constants.js","webpack:///./node_modules/@apollo/client/react/hooks/useSuspenseQuery.js","webpack:///./node_modules/@apollo/client/react/hooks/internal/useDeepMemo.js","webpack:///./node_modules/@apollo/client/react/internal/cache/QueryReference.js","webpack:///./node_modules/@apollo/client/react/internal/cache/SuspenseCache.js","webpack:///./node_modules/@apollo/client/react/internal/cache/getSuspenseCache.js","webpack:///./node_modules/@apollo/client/utilities/promises/decoration.js"],"sourcesContent":["import { wrapPromiseWithState } from \"../../../utilities/index.js\";\nimport * as React from \"rehackt\";\n// Prevent webpack from complaining about our feature detection of the\n// use property of the React namespace, which is expected not\n// to exist when using current stable versions, and that's fine.\nvar useKey = \"use\";\nvar realHook = React[useKey];\n// This is named with two underscores to allow this hook to evade typical rules of\n// hooks (i.e. it can be used conditionally)\nexport var __use = realHook ||\n    function __use(promise) {\n        var statefulPromise = wrapPromiseWithState(promise);\n        switch (statefulPromise.status) {\n            case \"pending\":\n                throw statefulPromise;\n            case \"rejected\":\n                throw statefulPromise.reason;\n            case \"fulfilled\":\n                return statefulPromise.value;\n        }\n    };\n//# sourceMappingURL=__use.js.map","export var skipToken = Symbol.for(\"apollo.skipToken\");\n//# sourceMappingURL=constants.js.map","import { __assign, __spreadArray } from \"tslib\";\nimport * as React from \"rehackt\";\nimport { invariant } from \"../../utilities/globals/index.js\";\nimport { ApolloError, NetworkStatus } from \"../../core/index.js\";\nimport { isNonEmptyArray } from \"../../utilities/index.js\";\nimport { useApolloClient } from \"./useApolloClient.js\";\nimport { DocumentType, verifyDocumentType } from \"../parser/index.js\";\nimport { __use, useDeepMemo, wrapHook } from \"./internal/index.js\";\nimport { getSuspenseCache } from \"../internal/index.js\";\nimport { canonicalStringify } from \"../../cache/index.js\";\nimport { skipToken } from \"./constants.js\";\nexport function useSuspenseQuery(query, options) {\n    if (options === void 0) { options = Object.create(null); }\n    return wrapHook(\"useSuspenseQuery\", _useSuspenseQuery, useApolloClient(typeof options === \"object\" ? options.client : undefined))(query, options);\n}\nfunction _useSuspenseQuery(query, options) {\n    var client = useApolloClient(options.client);\n    var suspenseCache = getSuspenseCache(client);\n    var watchQueryOptions = useWatchQueryOptions({\n        client: client,\n        query: query,\n        options: options,\n    });\n    var fetchPolicy = watchQueryOptions.fetchPolicy, variables = watchQueryOptions.variables;\n    var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;\n    var cacheKey = __spreadArray([\n        query,\n        canonicalStringify(variables)\n    ], [].concat(queryKey), true);\n    var queryRef = suspenseCache.getQueryRef(cacheKey, function () {\n        return client.watchQuery(watchQueryOptions);\n    });\n    var _b = React.useState([queryRef.key, queryRef.promise]), current = _b[0], setPromise = _b[1];\n    // This saves us a re-execution of the render function when a variable changed.\n    if (current[0] !== queryRef.key) {\n        current[0] = queryRef.key;\n        current[1] = queryRef.promise;\n    }\n    var promise = current[1];\n    if (queryRef.didChangeOptions(watchQueryOptions)) {\n        current[1] = promise = queryRef.applyOptions(watchQueryOptions);\n    }\n    React.useEffect(function () {\n        var dispose = queryRef.retain();\n        var removeListener = queryRef.listen(function (promise) {\n            setPromise([queryRef.key, promise]);\n        });\n        return function () {\n            removeListener();\n            dispose();\n        };\n    }, [queryRef]);\n    var skipResult = React.useMemo(function () {\n        var error = toApolloError(queryRef.result);\n        return {\n            loading: false,\n            data: queryRef.result.data,\n            networkStatus: error ? NetworkStatus.error : NetworkStatus.ready,\n            error: error,\n        };\n    }, [queryRef.result]);\n    var result = fetchPolicy === \"standby\" ? skipResult : __use(promise);\n    var fetchMore = React.useCallback(function (options) {\n        var promise = queryRef.fetchMore(options);\n        setPromise([queryRef.key, queryRef.promise]);\n        return promise;\n    }, [queryRef]);\n    var refetch = React.useCallback(function (variables) {\n        var promise = queryRef.refetch(variables);\n        setPromise([queryRef.key, queryRef.promise]);\n        return promise;\n    }, [queryRef]);\n    var subscribeToMore = queryRef.observable.subscribeToMore;\n    return React.useMemo(function () {\n        return {\n            client: client,\n            data: result.data,\n            error: toApolloError(result),\n            networkStatus: result.networkStatus,\n            fetchMore: fetchMore,\n            refetch: refetch,\n            subscribeToMore: subscribeToMore,\n        };\n    }, [client, fetchMore, refetch, result, subscribeToMore]);\n}\nfunction validateOptions(options) {\n    var query = options.query, fetchPolicy = options.fetchPolicy, returnPartialData = options.returnPartialData;\n    verifyDocumentType(query, DocumentType.Query);\n    validateFetchPolicy(fetchPolicy);\n    validatePartialDataReturn(fetchPolicy, returnPartialData);\n}\nfunction validateFetchPolicy(fetchPolicy) {\n    if (fetchPolicy === void 0) { fetchPolicy = \"cache-first\"; }\n    var supportedFetchPolicies = [\n        \"cache-first\",\n        \"network-only\",\n        \"no-cache\",\n        \"cache-and-network\",\n    ];\n    invariant(supportedFetchPolicies.includes(fetchPolicy), 58, fetchPolicy);\n}\nfunction validatePartialDataReturn(fetchPolicy, returnPartialData) {\n    if (fetchPolicy === \"no-cache\" && returnPartialData) {\n        globalThis.__DEV__ !== false && invariant.warn(59);\n    }\n}\nexport function toApolloError(result) {\n    return isNonEmptyArray(result.errors) ?\n        new ApolloError({ graphQLErrors: result.errors })\n        : result.error;\n}\nexport function useWatchQueryOptions(_a) {\n    var client = _a.client, query = _a.query, options = _a.options;\n    return useDeepMemo(function () {\n        var _a;\n        if (options === skipToken) {\n            return { query: query, fetchPolicy: \"standby\" };\n        }\n        var fetchPolicy = options.fetchPolicy ||\n            ((_a = client.defaultOptions.watchQuery) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||\n            \"cache-first\";\n        var watchQueryOptions = __assign(__assign({}, options), { fetchPolicy: fetchPolicy, query: query, notifyOnNetworkStatusChange: false, nextFetchPolicy: void 0 });\n        if (globalThis.__DEV__ !== false) {\n            validateOptions(watchQueryOptions);\n        }\n        // Assign the updated fetch policy after our validation since `standby` is\n        // not a supported fetch policy on its own without the use of `skip`.\n        if (options.skip) {\n            watchQueryOptions.fetchPolicy = \"standby\";\n        }\n        return watchQueryOptions;\n    }, [client, options, query]);\n}\n//# sourceMappingURL=useSuspenseQuery.js.map","import * as React from \"rehackt\";\nimport { equal } from \"@wry/equality\";\nexport function useDeepMemo(memoFn, deps) {\n    var ref = React.useRef();\n    if (!ref.current || !equal(ref.current.deps, deps)) {\n        ref.current = { value: memoFn(), deps: deps };\n    }\n    return ref.current.value;\n}\n//# sourceMappingURL=useDeepMemo.js.map","import { __assign } from \"tslib\";\nimport { equal } from \"@wry/equality\";\nimport { createFulfilledPromise, createRejectedPromise, } from \"../../../utilities/index.js\";\nimport { wrapPromiseWithState } from \"../../../utilities/index.js\";\nimport { invariant } from \"../../../utilities/globals/invariantWrappers.js\";\nvar QUERY_REFERENCE_SYMBOL = Symbol();\nvar PROMISE_SYMBOL = Symbol();\nexport function wrapQueryRef(internalQueryRef) {\n    var _a;\n    var ref = (_a = {\n            toPromise: function () {\n                // We avoid resolving this promise with the query data because we want to\n                // discourage using the server data directly from the queryRef. Instead,\n                // the data should be accessed through `useReadQuery`. When the server\n                // data is needed, its better to use `client.query()` directly.\n                //\n                // Here we resolve with the ref itself to make using this in React Router\n                // or TanStack Router `loader` functions a bit more ergonomic e.g.\n                //\n                // function loader() {\n                //   return { queryRef: await preloadQuery(query).toPromise() }\n                // }\n                return getWrappedPromise(ref).then(function () { return ref; });\n            }\n        },\n        _a[QUERY_REFERENCE_SYMBOL] = internalQueryRef,\n        _a[PROMISE_SYMBOL] = internalQueryRef.promise,\n        _a);\n    return ref;\n}\nexport function assertWrappedQueryRef(queryRef) {\n    invariant(!queryRef || QUERY_REFERENCE_SYMBOL in queryRef, 61);\n}\nexport function getWrappedPromise(queryRef) {\n    var internalQueryRef = unwrapQueryRef(queryRef);\n    return internalQueryRef.promise.status === \"fulfilled\" ?\n        internalQueryRef.promise\n        : queryRef[PROMISE_SYMBOL];\n}\nexport function unwrapQueryRef(queryRef) {\n    return queryRef[QUERY_REFERENCE_SYMBOL];\n}\nexport function updateWrappedQueryRef(queryRef, promise) {\n    queryRef[PROMISE_SYMBOL] = promise;\n}\nvar OBSERVED_CHANGED_OPTIONS = [\n    \"canonizeResults\",\n    \"context\",\n    \"errorPolicy\",\n    \"fetchPolicy\",\n    \"refetchWritePolicy\",\n    \"returnPartialData\",\n];\nvar InternalQueryReference = /** @class */ (function () {\n    function InternalQueryReference(observable, options) {\n        var _this = this;\n        this.key = {};\n        this.listeners = new Set();\n        this.references = 0;\n        this.softReferences = 0;\n        this.handleNext = this.handleNext.bind(this);\n        this.handleError = this.handleError.bind(this);\n        this.dispose = this.dispose.bind(this);\n        this.observable = observable;\n        if (options.onDispose) {\n            this.onDispose = options.onDispose;\n        }\n        this.setResult();\n        this.subscribeToQuery();\n        // Start a timer that will automatically dispose of the query if the\n        // suspended resource does not use this queryRef in the given time. This\n        // helps prevent memory leaks when a component has unmounted before the\n        // query has finished loading.\n        var startDisposeTimer = function () {\n            var _a;\n            if (!_this.references) {\n                _this.autoDisposeTimeoutId = setTimeout(_this.dispose, (_a = options.autoDisposeTimeoutMs) !== null && _a !== void 0 ? _a : 30000);\n            }\n        };\n        // We wait until the request has settled to ensure we don't dispose of the\n        // query ref before the request finishes, otherwise we would leave the\n        // promise in a pending state rendering the suspense boundary indefinitely.\n        this.promise.then(startDisposeTimer, startDisposeTimer);\n    }\n    Object.defineProperty(InternalQueryReference.prototype, \"disposed\", {\n        get: function () {\n            return this.subscription.closed;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(InternalQueryReference.prototype, \"watchQueryOptions\", {\n        get: function () {\n            return this.observable.options;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    InternalQueryReference.prototype.reinitialize = function () {\n        var observable = this.observable;\n        var originalFetchPolicy = this.watchQueryOptions.fetchPolicy;\n        var avoidNetworkRequests = originalFetchPolicy === \"no-cache\" || originalFetchPolicy === \"standby\";\n        try {\n            if (avoidNetworkRequests) {\n                observable.silentSetOptions({ fetchPolicy: \"standby\" });\n            }\n            else {\n                observable.resetLastResults();\n                observable.silentSetOptions({ fetchPolicy: \"cache-first\" });\n            }\n            this.subscribeToQuery();\n            if (avoidNetworkRequests) {\n                return;\n            }\n            observable.resetDiff();\n            this.setResult();\n        }\n        finally {\n            observable.silentSetOptions({ fetchPolicy: originalFetchPolicy });\n        }\n    };\n    InternalQueryReference.prototype.retain = function () {\n        var _this = this;\n        this.references++;\n        clearTimeout(this.autoDisposeTimeoutId);\n        var disposed = false;\n        return function () {\n            if (disposed) {\n                return;\n            }\n            disposed = true;\n            _this.references--;\n            setTimeout(function () {\n                if (!_this.references) {\n                    _this.dispose();\n                }\n            });\n        };\n    };\n    InternalQueryReference.prototype.softRetain = function () {\n        var _this = this;\n        this.softReferences++;\n        var disposed = false;\n        return function () {\n            // Tracking if this has already been called helps ensure that\n            // multiple calls to this function won't decrement the reference\n            // counter more than it should. Subsequent calls just result in a noop.\n            if (disposed) {\n                return;\n            }\n            disposed = true;\n            _this.softReferences--;\n            setTimeout(function () {\n                if (!_this.softReferences && !_this.references) {\n                    _this.dispose();\n                }\n            });\n        };\n    };\n    InternalQueryReference.prototype.didChangeOptions = function (watchQueryOptions) {\n        var _this = this;\n        return OBSERVED_CHANGED_OPTIONS.some(function (option) {\n            return option in watchQueryOptions &&\n                !equal(_this.watchQueryOptions[option], watchQueryOptions[option]);\n        });\n    };\n    InternalQueryReference.prototype.applyOptions = function (watchQueryOptions) {\n        var _a = this.watchQueryOptions, currentFetchPolicy = _a.fetchPolicy, currentCanonizeResults = _a.canonizeResults;\n        // \"standby\" is used when `skip` is set to `true`. Detect when we've\n        // enabled the query (i.e. `skip` is `false`) to execute a network request.\n        if (currentFetchPolicy === \"standby\" &&\n            currentFetchPolicy !== watchQueryOptions.fetchPolicy) {\n            this.initiateFetch(this.observable.reobserve(watchQueryOptions));\n        }\n        else {\n            this.observable.silentSetOptions(watchQueryOptions);\n            if (currentCanonizeResults !== watchQueryOptions.canonizeResults) {\n                this.result = __assign(__assign({}, this.result), this.observable.getCurrentResult());\n                this.promise = createFulfilledPromise(this.result);\n            }\n        }\n        return this.promise;\n    };\n    InternalQueryReference.prototype.listen = function (listener) {\n        var _this = this;\n        this.listeners.add(listener);\n        return function () {\n            _this.listeners.delete(listener);\n        };\n    };\n    InternalQueryReference.prototype.refetch = function (variables) {\n        return this.initiateFetch(this.observable.refetch(variables));\n    };\n    InternalQueryReference.prototype.fetchMore = function (options) {\n        return this.initiateFetch(this.observable.fetchMore(options));\n    };\n    InternalQueryReference.prototype.dispose = function () {\n        this.subscription.unsubscribe();\n        this.onDispose();\n    };\n    InternalQueryReference.prototype.onDispose = function () {\n        // noop. overridable by options\n    };\n    InternalQueryReference.prototype.handleNext = function (result) {\n        var _a;\n        switch (this.promise.status) {\n            case \"pending\": {\n                // Maintain the last successful `data` value if the next result does not\n                // have one.\n                if (result.data === void 0) {\n                    result.data = this.result.data;\n                }\n                this.result = result;\n                (_a = this.resolve) === null || _a === void 0 ? void 0 : _a.call(this, result);\n                break;\n            }\n            default: {\n                // This occurs when switching to a result that is fully cached when this\n                // class is instantiated. ObservableQuery will run reobserve when\n                // subscribing, which delivers a result from the cache.\n                if (result.data === this.result.data &&\n                    result.networkStatus === this.result.networkStatus) {\n                    return;\n                }\n                // Maintain the last successful `data` value if the next result does not\n                // have one.\n                if (result.data === void 0) {\n                    result.data = this.result.data;\n                }\n                this.result = result;\n                this.promise = createFulfilledPromise(result);\n                this.deliver(this.promise);\n                break;\n            }\n        }\n    };\n    InternalQueryReference.prototype.handleError = function (error) {\n        var _a;\n        this.subscription.unsubscribe();\n        this.subscription = this.observable.resubscribeAfterError(this.handleNext, this.handleError);\n        switch (this.promise.status) {\n            case \"pending\": {\n                (_a = this.reject) === null || _a === void 0 ? void 0 : _a.call(this, error);\n                break;\n            }\n            default: {\n                this.promise = createRejectedPromise(error);\n                this.deliver(this.promise);\n            }\n        }\n    };\n    InternalQueryReference.prototype.deliver = function (promise) {\n        this.listeners.forEach(function (listener) { return listener(promise); });\n    };\n    InternalQueryReference.prototype.initiateFetch = function (returnedPromise) {\n        var _this = this;\n        this.promise = this.createPendingPromise();\n        this.promise.catch(function () { });\n        // If the data returned from the fetch is deeply equal to the data already\n        // in the cache, `handleNext` will not be triggered leaving the promise we\n        // created in a pending state forever. To avoid this situtation, we attempt\n        // to resolve the promise if `handleNext` hasn't been run to ensure the\n        // promise is resolved correctly.\n        returnedPromise\n            .then(function () {\n            // In the case of `fetchMore`, this promise is resolved before a cache\n            // result is emitted due to the fact that `fetchMore` sets a `no-cache`\n            // fetch policy and runs `cache.batch` in its `.then` handler. Because\n            // the timing is different, we accidentally run this update twice\n            // causing an additional re-render with the `fetchMore` result by\n            // itself. By wrapping in `setTimeout`, this should provide a short\n            // delay to allow the `QueryInfo.notify` handler to run before this\n            // promise is checked.\n            // See https://github.com/apollographql/apollo-client/issues/11315 for\n            // more information\n            setTimeout(function () {\n                var _a;\n                if (_this.promise.status === \"pending\") {\n                    // Use the current result from the observable instead of the value\n                    // resolved from the promise. This avoids issues in some cases where\n                    // the raw resolved value should not be the emitted value, such as\n                    // when a `fetchMore` call returns an empty array after it has\n                    // reached the end of the list.\n                    //\n                    // See the following for more information:\n                    // https://github.com/apollographql/apollo-client/issues/11642\n                    _this.result = _this.observable.getCurrentResult();\n                    (_a = _this.resolve) === null || _a === void 0 ? void 0 : _a.call(_this, _this.result);\n                }\n            });\n        })\n            .catch(function (error) { var _a; return (_a = _this.reject) === null || _a === void 0 ? void 0 : _a.call(_this, error); });\n        return returnedPromise;\n    };\n    InternalQueryReference.prototype.subscribeToQuery = function () {\n        var _this = this;\n        this.subscription = this.observable\n            .filter(function (result) { return !equal(result.data, {}) && !equal(result, _this.result); })\n            .subscribe(this.handleNext, this.handleError);\n    };\n    InternalQueryReference.prototype.setResult = function () {\n        // Don't save this result as last result to prevent delivery of last result\n        // when first subscribing\n        var result = this.observable.getCurrentResult(false);\n        if (equal(result, this.result)) {\n            return;\n        }\n        this.result = result;\n        this.promise =\n            (result.data &&\n                (!result.partial || this.watchQueryOptions.returnPartialData)) ?\n                createFulfilledPromise(result)\n                : this.createPendingPromise();\n    };\n    InternalQueryReference.prototype.createPendingPromise = function () {\n        var _this = this;\n        return wrapPromiseWithState(new Promise(function (resolve, reject) {\n            _this.resolve = resolve;\n            _this.reject = reject;\n        }));\n    };\n    return InternalQueryReference;\n}());\nexport { InternalQueryReference };\n//# sourceMappingURL=QueryReference.js.map","import { Trie } from \"@wry/trie\";\nimport { canUseWeakMap } from \"../../../utilities/index.js\";\nimport { InternalQueryReference } from \"./QueryReference.js\";\nvar SuspenseCache = /** @class */ (function () {\n    function SuspenseCache(options) {\n        if (options === void 0) { options = Object.create(null); }\n        this.queryRefs = new Trie(canUseWeakMap);\n        this.options = options;\n    }\n    SuspenseCache.prototype.getQueryRef = function (cacheKey, createObservable) {\n        var ref = this.queryRefs.lookupArray(cacheKey);\n        if (!ref.current) {\n            ref.current = new InternalQueryReference(createObservable(), {\n                autoDisposeTimeoutMs: this.options.autoDisposeTimeoutMs,\n                onDispose: function () {\n                    delete ref.current;\n                },\n            });\n        }\n        return ref.current;\n    };\n    SuspenseCache.prototype.add = function (cacheKey, queryRef) {\n        var ref = this.queryRefs.lookupArray(cacheKey);\n        ref.current = queryRef;\n    };\n    return SuspenseCache;\n}());\nexport { SuspenseCache };\n//# sourceMappingURL=SuspenseCache.js.map","import { SuspenseCache } from \"./SuspenseCache.js\";\nvar suspenseCacheSymbol = Symbol.for(\"apollo.suspenseCache\");\nexport function getSuspenseCache(client) {\n    var _a;\n    if (!client[suspenseCacheSymbol]) {\n        client[suspenseCacheSymbol] = new SuspenseCache((_a = client.defaultOptions.react) === null || _a === void 0 ? void 0 : _a.suspense);\n    }\n    return client[suspenseCacheSymbol];\n}\n//# sourceMappingURL=getSuspenseCache.js.map","export function createFulfilledPromise(value) {\n    var promise = Promise.resolve(value);\n    promise.status = \"fulfilled\";\n    promise.value = value;\n    return promise;\n}\nexport function createRejectedPromise(reason) {\n    var promise = Promise.reject(reason);\n    // prevent potential edge cases leaking unhandled error rejections\n    promise.catch(function () { });\n    promise.status = \"rejected\";\n    promise.reason = reason;\n    return promise;\n}\nexport function isStatefulPromise(promise) {\n    return \"status\" in promise;\n}\nexport function wrapPromiseWithState(promise) {\n    if (isStatefulPromise(promise)) {\n        return promise;\n    }\n    var pendingPromise = promise;\n    pendingPromise.status = \"pending\";\n    pendingPromise.then(function (value) {\n        if (pendingPromise.status === \"pending\") {\n            var fulfilledPromise = pendingPromise;\n            fulfilledPromise.status = \"fulfilled\";\n            fulfilledPromise.value = value;\n        }\n    }, function (reason) {\n        if (pendingPromise.status === \"pending\") {\n            var rejectedPromise = pendingPromise;\n            rejectedPromise.status = \"rejected\";\n            rejectedPromise.reason = reason;\n        }\n    });\n    return promise;\n}\n//# sourceMappingURL=decoration.js.map"],"names":["__use","promise","statefulPromise","status","reason","value","skipToken","Symbol","for","useSuspenseQuery","query","options","Object","create","wrapHook","_useSuspenseQuery","useApolloClient","client","undefined","suspenseCache","getSuspenseCache","watchQueryOptions","useWatchQueryOptions","fetchPolicy","variables","_a","queryKey","cacheKey","canonicalStringify","concat","queryRef","getQueryRef","watchQuery","_b","key","current","setPromise","didChangeOptions","applyOptions","dispose","retain","removeListener","listen","skipResult","error","toApolloError","result","loading","data","networkStatus","ready","fetchMore","refetch","subscribeToMore","observable","validateOptions","returnPartialData","Query","supportedFetchPolicies","includes","validateFetchPolicy","globalThis","__DEV__","warn","validatePartialDataReturn","errors","graphQLErrors","memoFn","deps","ref","defaultOptions","notifyOnNetworkStatusChange","nextFetchPolicy","skip","QUERY_REFERENCE_SYMBOL","PROMISE_SYMBOL","wrapQueryRef","internalQueryRef","toPromise","unwrapQueryRef","getWrappedPromise","then","updateWrappedQueryRef","OBSERVED_CHANGED_OPTIONS","InternalQueryReference","_this","this","listeners","Set","references","softReferences","handleNext","bind","handleError","onDispose","setResult","subscribeToQuery","startDisposeTimer","autoDisposeTimeoutId","setTimeout","autoDisposeTimeoutMs","defineProperty","prototype","get","subscription","closed","enumerable","configurable","reinitialize","originalFetchPolicy","avoidNetworkRequests","silentSetOptions","resetLastResults","resetDiff","clearTimeout","disposed","softRetain","some","option","currentFetchPolicy","currentCanonizeResults","canonizeResults","initiateFetch","reobserve","getCurrentResult","listener","add","delete","unsubscribe","resolve","call","deliver","resubscribeAfterError","reject","forEach","returnedPromise","createPendingPromise","catch","filter","subscribe","partial","Promise","SuspenseCache","queryRefs","canUse","createObservable","lookupArray","suspenseCacheSymbol","react","suspense","createFulfilledPromise","createRejectedPromise","wrapPromiseWithState","isStatefulPromise","pendingPromise","fulfilledPromise","rejectedPromise"],"sourceRoot":""}