{"version":3,"file":"chunk.a5afa73672bc6f3f6132.js","mappings":"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","sources":["webpack:///../../../node_modules/.pnpm/neverthrow@4.2.1/node_modules/neverthrow/dist/index.es.js","webpack:///../../../node_modules/.pnpm/react@18.2.0/node_modules/react/index.js","webpack:///../../../node_modules/.pnpm/ts-invariant@0.4.4/node_modules/ts-invariant/lib/invariant.esm.js","webpack:///../../../node_modules/.pnpm/@tanstack+query-core@5.28.4/node_modules/@tanstack/query-core/build/modern/focusManager.js","webpack:///../../../node_modules/.pnpm/@tanstack+query-core@5.28.4/node_modules/@tanstack/query-core/build/modern/notifyManager.js","webpack:///../../../node_modules/.pnpm/@tanstack+query-core@5.28.4/node_modules/@tanstack/query-core/build/modern/onlineManager.js","webpack:///../../../node_modules/.pnpm/@tanstack+query-core@5.28.4/node_modules/@tanstack/query-core/build/modern/query.js","webpack:///../../../node_modules/.pnpm/@tanstack+query-core@5.28.4/node_modules/@tanstack/query-core/build/modern/queryObserver.js","webpack:///../../../node_modules/.pnpm/@tanstack+query-core@5.28.4/node_modules/@tanstack/query-core/build/modern/removable.js","webpack:///../../../node_modules/.pnpm/@tanstack+query-core@5.28.4/node_modules/@tanstack/query-core/build/modern/retryer.js","webpack:///../../../node_modules/.pnpm/@tanstack+query-core@5.28.4/node_modules/@tanstack/query-core/build/modern/subscribable.js","webpack:///../../../node_modules/.pnpm/@tanstack+query-core@5.28.4/node_modules/@tanstack/query-core/build/modern/utils.js","webpack:///../../../node_modules/.pnpm/@tanstack+react-query@5.28.4_react@18.2.0/node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js","webpack:///../../../node_modules/.pnpm/@tanstack+react-query@5.28.4_react@18.2.0/node_modules/@tanstack/react-query/build/modern/QueryErrorResetBoundary.js","webpack:///../../../node_modules/.pnpm/@tanstack+react-query@5.28.4_react@18.2.0/node_modules/@tanstack/react-query/build/modern/isRestoring.js","webpack:///../../../node_modules/.pnpm/@tanstack+react-query@5.28.4_react@18.2.0/node_modules/@tanstack/react-query/build/modern/errorBoundaryUtils.js","webpack:///../../../node_modules/.pnpm/@tanstack+react-query@5.28.4_react@18.2.0/node_modules/@tanstack/react-query/build/modern/suspense.js","webpack:///../../../node_modules/.pnpm/@tanstack+react-query@5.28.4_react@18.2.0/node_modules/@tanstack/react-query/build/modern/useBaseQuery.js","webpack:///../../../node_modules/.pnpm/@tanstack+react-query@5.28.4_react@18.2.0/node_modules/@tanstack/react-query/build/modern/useQuery.js","webpack:///../../../node_modules/.pnpm/@tanstack+react-query@5.28.4_react@18.2.0/node_modules/@tanstack/react-query/build/modern/utils.js","webpack:///../../../node_modules/.pnpm/ramda@0.30.1/node_modules/ramda/es/always.js"],"sourcesContent":["/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n\r\nfunction __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\nfunction __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\nfunction __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\nfunction __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}\n\nvar defaultErrorConfig = {\r\n    withStackTrace: false,\r\n};\r\n// Custom error object\r\n// Context / discussion: https://github.com/supermacro/neverthrow/pull/215\r\nvar createNeverThrowError = function (message, result, config) {\r\n    if (config === void 0) { config = defaultErrorConfig; }\r\n    var data = result.isOk()\r\n        ? { type: 'Ok', value: result.value }\r\n        : { type: 'Err', value: result.error };\r\n    var maybeStack = config.withStackTrace ? new Error().stack : undefined;\r\n    return {\r\n        data: data,\r\n        message: message,\r\n        stack: maybeStack,\r\n    };\r\n};\n\n// eslint-disable-next-line @typescript-eslint/no-namespace\r\nvar Result;\r\n(function (Result) {\r\n    /**\r\n     * Wraps a function with a try catch, creating a new function with the same\r\n     * arguments but returning `Ok` if successful, `Err` if the function throws\r\n     *\r\n     * @param fn function to wrap with ok on success or err on failure\r\n     * @param errorFn when an error is thrown, this will wrap the error result if provided\r\n     */\r\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\r\n    function fromThrowable(fn, errorFn) {\r\n        return function () {\r\n            var args = [];\r\n            for (var _i = 0; _i < arguments.length; _i++) {\r\n                args[_i] = arguments[_i];\r\n            }\r\n            try {\r\n                var result = fn.apply(void 0, __spread(args));\r\n                return ok(result);\r\n            }\r\n            catch (e) {\r\n                return err(errorFn ? errorFn(e) : e);\r\n            }\r\n        };\r\n    }\r\n    Result.fromThrowable = fromThrowable;\r\n})(Result || (Result = {}));\r\nvar ok = function (value) { return new Ok(value); };\r\nvar err = function (err) { return new Err(err); };\r\nvar Ok = /** @class */ (function () {\r\n    function Ok(value) {\r\n        this.value = value;\r\n    }\r\n    Ok.prototype.isOk = function () {\r\n        return true;\r\n    };\r\n    Ok.prototype.isErr = function () {\r\n        return !this.isOk();\r\n    };\r\n    Ok.prototype.map = function (f) {\r\n        return ok(f(this.value));\r\n    };\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    Ok.prototype.mapErr = function (_f) {\r\n        return ok(this.value);\r\n    };\r\n    Ok.prototype.andThen = function (f) {\r\n        return f(this.value);\r\n    };\r\n    Ok.prototype.orElse = function (_f) {\r\n        return ok(this.value);\r\n    };\r\n    Ok.prototype.asyncAndThen = function (f) {\r\n        return f(this.value);\r\n    };\r\n    Ok.prototype.asyncMap = function (f) {\r\n        return ResultAsync.fromSafePromise(f(this.value));\r\n    };\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    Ok.prototype.unwrapOr = function (_v) {\r\n        return this.value;\r\n    };\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    Ok.prototype.match = function (ok, _err) {\r\n        return ok(this.value);\r\n    };\r\n    Ok.prototype._unsafeUnwrap = function (_) {\r\n        return this.value;\r\n    };\r\n    Ok.prototype._unsafeUnwrapErr = function (config) {\r\n        throw createNeverThrowError('Called `_unsafeUnwrapErr` on an Ok', this, config);\r\n    };\r\n    return Ok;\r\n}());\r\nvar Err = /** @class */ (function () {\r\n    function Err(error) {\r\n        this.error = error;\r\n    }\r\n    Err.prototype.isOk = function () {\r\n        return false;\r\n    };\r\n    Err.prototype.isErr = function () {\r\n        return !this.isOk();\r\n    };\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    Err.prototype.map = function (_f) {\r\n        return err(this.error);\r\n    };\r\n    Err.prototype.mapErr = function (f) {\r\n        return err(f(this.error));\r\n    };\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    Err.prototype.andThen = function (_f) {\r\n        return err(this.error);\r\n    };\r\n    Err.prototype.orElse = function (f) {\r\n        return f(this.error);\r\n    };\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    Err.prototype.asyncAndThen = function (_f) {\r\n        return errAsync(this.error);\r\n    };\r\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\r\n    Err.prototype.asyncMap = function (_f) {\r\n        return errAsync(this.error);\r\n    };\r\n    Err.prototype.unwrapOr = function (v) {\r\n        return v;\r\n    };\r\n    Err.prototype.match = function (_ok, err) {\r\n        return err(this.error);\r\n    };\r\n    Err.prototype._unsafeUnwrap = function (config) {\r\n        throw createNeverThrowError('Called `_unsafeUnwrap` on an Err', this, config);\r\n    };\r\n    Err.prototype._unsafeUnwrapErr = function (_) {\r\n        return this.error;\r\n    };\r\n    return Err;\r\n}());\r\nvar fromThrowable = Result.fromThrowable;\n\nvar ResultAsync = /** @class */ (function () {\r\n    function ResultAsync(res) {\r\n        this._promise = res;\r\n    }\r\n    ResultAsync.fromSafePromise = function (promise) {\r\n        var newPromise = promise.then(function (value) { return new Ok(value); });\r\n        return new ResultAsync(newPromise);\r\n    };\r\n    ResultAsync.fromPromise = function (promise, errorFn) {\r\n        var newPromise = promise\r\n            .then(function (value) { return new Ok(value); })[\"catch\"](function (e) { return new Err(errorFn(e)); });\r\n        return new ResultAsync(newPromise);\r\n    };\r\n    ResultAsync.prototype.map = function (f) {\r\n        var _this = this;\r\n        return new ResultAsync(this._promise.then(function (res) { return __awaiter(_this, void 0, void 0, function () {\r\n            var _a;\r\n            return __generator(this, function (_b) {\r\n                switch (_b.label) {\r\n                    case 0:\r\n                        if (res.isErr()) {\r\n                            return [2 /*return*/, new Err(res.error)];\r\n                        }\r\n                        _a = Ok.bind;\r\n                        return [4 /*yield*/, f(res.value)];\r\n                    case 1: return [2 /*return*/, new (_a.apply(Ok, [void 0, _b.sent()]))()];\r\n                }\r\n            });\r\n        }); }));\r\n    };\r\n    ResultAsync.prototype.mapErr = function (f) {\r\n        var _this = this;\r\n        return new ResultAsync(this._promise.then(function (res) { return __awaiter(_this, void 0, void 0, function () {\r\n            var _a;\r\n            return __generator(this, function (_b) {\r\n                switch (_b.label) {\r\n                    case 0:\r\n                        if (res.isOk()) {\r\n                            return [2 /*return*/, new Ok(res.value)];\r\n                        }\r\n                        _a = Err.bind;\r\n                        return [4 /*yield*/, f(res.error)];\r\n                    case 1: return [2 /*return*/, new (_a.apply(Err, [void 0, _b.sent()]))()];\r\n                }\r\n            });\r\n        }); }));\r\n    };\r\n    ResultAsync.prototype.andThen = function (f) {\r\n        return new ResultAsync(this._promise.then(function (res) {\r\n            if (res.isErr()) {\r\n                return new Err(res.error);\r\n            }\r\n            var newValue = f(res.value);\r\n            return newValue instanceof ResultAsync ? newValue._promise : newValue;\r\n        }));\r\n    };\r\n    ResultAsync.prototype.orElse = function (f) {\r\n        var _this = this;\r\n        return new ResultAsync(this._promise.then(function (res) { return __awaiter(_this, void 0, void 0, function () {\r\n            return __generator(this, function (_a) {\r\n                if (res.isErr()) {\r\n                    return [2 /*return*/, f(res.error)];\r\n                }\r\n                return [2 /*return*/, new Ok(res.value)];\r\n            });\r\n        }); }));\r\n    };\r\n    ResultAsync.prototype.match = function (ok, _err) {\r\n        return this._promise.then(function (res) { return res.match(ok, _err); });\r\n    };\r\n    ResultAsync.prototype.unwrapOr = function (t) {\r\n        return this._promise.then(function (res) { return res.unwrapOr(t); });\r\n    };\r\n    // Makes ResultAsync implement PromiseLike<Result>\r\n    ResultAsync.prototype.then = function (successCallback, failureCallback) {\r\n        return this._promise.then(successCallback, failureCallback);\r\n    };\r\n    return ResultAsync;\r\n}());\r\nvar okAsync = function (value) {\r\n    return new ResultAsync(Promise.resolve(new Ok(value)));\r\n};\r\nvar errAsync = function (err) {\r\n    return new ResultAsync(Promise.resolve(new Err(err)));\r\n};\r\nvar fromPromise = ResultAsync.fromPromise;\r\nvar fromSafePromise = ResultAsync.fromSafePromise;\n\nvar appendValueToEndOfList = function (value) { return function (list) {\r\n    // need to wrap `value` inside of an array in order to prevent\r\n    // Array.prototype.concat from destructuring the contents of `value`\r\n    // into `list`.\r\n    //\r\n    // Otherwise you will receive [ 'hi', 1, 2, 3 ]\r\n    // when you actually expected a tuple containing [ 'hi', [ 1, 2, 3 ] ]\r\n    if (Array.isArray(value)) {\r\n        return list.concat([value]);\r\n    }\r\n    return list.concat(value);\r\n}; };\r\n/**\r\n * Short circuits on the FIRST Err value that we find\r\n */\r\nvar combineResultList = function (resultList) {\r\n    return resultList.reduce(function (acc, result) {\r\n        return acc.isOk()\r\n            ? result.isErr()\r\n                ? err(result.error)\r\n                : acc.map(appendValueToEndOfList(result.value))\r\n            : acc;\r\n    }, ok([]));\r\n};\r\n/* This is the typesafe version of Promise.all\r\n *\r\n * Takes a list of ResultAsync<T, E> and success if all inner results are Ok values\r\n * or fails if one (or more) of the inner results are Err values\r\n */\r\nvar combineResultAsyncList = function (asyncResultList) {\r\n    return ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);\r\n};\r\n// eslint-disable-next-line\r\nfunction combine(list) {\r\n    if (list[0] instanceof ResultAsync) {\r\n        return combineResultAsyncList(list);\r\n    }\r\n    else {\r\n        return combineResultList(list);\r\n    }\r\n}\r\n/**\r\n * Give a list of all the errors we find\r\n */\r\nvar combineResultListWithAllErrors = function (resultList) {\r\n    return resultList.reduce(function (acc, result) {\r\n        return result.isErr()\r\n            ? acc.isErr()\r\n                ? err(__spread(acc.error, [result.error]))\r\n                : err([result.error])\r\n            : acc.isErr()\r\n                ? acc\r\n                : ok(__spread(acc.value, [result.value]));\r\n    }, ok([]));\r\n};\r\nvar combineResultAsyncListWithAllErrors = function (asyncResultList) {\r\n    return ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);\r\n};\r\n// eslint-disable-next-line\r\nfunction combineWithAllErrors(list) {\r\n    if (list[0] instanceof ResultAsync) {\r\n        return combineResultAsyncListWithAllErrors(list);\r\n    }\r\n    else {\r\n        return combineResultListWithAllErrors(list);\r\n    }\r\n}\n\nexport { Err, Ok, Result, ResultAsync, combine, combineWithAllErrors, err, errAsync, fromPromise, fromSafePromise, fromThrowable, ok, okAsync };\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react.production.min.js');\n} else {\n  module.exports = require('./cjs/react.development.js');\n}\n","import { __extends } from 'tslib';\n\nvar genericMessage = \"Invariant Violation\";\r\nvar _a = Object.setPrototypeOf, setPrototypeOf = _a === void 0 ? function (obj, proto) {\r\n    obj.__proto__ = proto;\r\n    return obj;\r\n} : _a;\r\nvar InvariantError = /** @class */ (function (_super) {\r\n    __extends(InvariantError, _super);\r\n    function InvariantError(message) {\r\n        if (message === void 0) { message = genericMessage; }\r\n        var _this = _super.call(this, typeof message === \"number\"\r\n            ? genericMessage + \": \" + message + \" (see https://github.com/apollographql/invariant-packages)\"\r\n            : message) || this;\r\n        _this.framesToPop = 1;\r\n        _this.name = genericMessage;\r\n        setPrototypeOf(_this, InvariantError.prototype);\r\n        return _this;\r\n    }\r\n    return InvariantError;\r\n}(Error));\r\nfunction invariant(condition, message) {\r\n    if (!condition) {\r\n        throw new InvariantError(message);\r\n    }\r\n}\r\nfunction wrapConsoleMethod(method) {\r\n    return function () {\r\n        return console[method].apply(console, arguments);\r\n    };\r\n}\r\n(function (invariant) {\r\n    invariant.warn = wrapConsoleMethod(\"warn\");\r\n    invariant.error = wrapConsoleMethod(\"error\");\r\n})(invariant || (invariant = {}));\r\n// Code that uses ts-invariant with rollup-plugin-invariant may want to\r\n// import this process stub to avoid errors evaluating process.env.NODE_ENV.\r\n// However, because most ESM-to-CJS compilers will rewrite the process import\r\n// as tsInvariant.process, which prevents proper replacement by minifiers, we\r\n// also attempt to define the stub globally when it is not already defined.\r\nvar processStub = { env: {} };\r\nif (typeof process === \"object\") {\r\n    processStub = process;\r\n}\r\nelse\r\n    try {\r\n        // Using Function to evaluate this assignment in global scope also escapes\r\n        // the strict mode of the current module, thereby allowing the assignment.\r\n        // Inspired by https://github.com/facebook/regenerator/pull/369.\r\n        Function(\"stub\", \"process = stub\")(processStub);\r\n    }\r\n    catch (atLeastWeTried) {\r\n        // The assignment can fail if a Content Security Policy heavy-handedly\r\n        // forbids Function usage. In those environments, developers should take\r\n        // extra care to replace process.env.NODE_ENV in their production builds,\r\n        // or define an appropriate global.process polyfill.\r\n    }\r\nvar invariant$1 = invariant;\n\nexport default invariant$1;\nexport { InvariantError, invariant, processStub as process };\n//# sourceMappingURL=invariant.esm.js.map\n","// src/focusManager.ts\nimport { Subscribable } from \"./subscribable.js\";\nimport { isServer } from \"./utils.js\";\nvar FocusManager = class extends Subscribable {\n  #focused;\n  #cleanup;\n  #setup;\n  constructor() {\n    super();\n    this.#setup = (onFocus) => {\n      if (!isServer && window.addEventListener) {\n        const listener = () => onFocus();\n        window.addEventListener(\"visibilitychange\", listener, false);\n        return () => {\n          window.removeEventListener(\"visibilitychange\", listener);\n        };\n      }\n      return;\n    };\n  }\n  onSubscribe() {\n    if (!this.#cleanup) {\n      this.setEventListener(this.#setup);\n    }\n  }\n  onUnsubscribe() {\n    if (!this.hasListeners()) {\n      this.#cleanup?.();\n      this.#cleanup = void 0;\n    }\n  }\n  setEventListener(setup) {\n    this.#setup = setup;\n    this.#cleanup?.();\n    this.#cleanup = setup((focused) => {\n      if (typeof focused === \"boolean\") {\n        this.setFocused(focused);\n      } else {\n        this.onFocus();\n      }\n    });\n  }\n  setFocused(focused) {\n    const changed = this.#focused !== focused;\n    if (changed) {\n      this.#focused = focused;\n      this.onFocus();\n    }\n  }\n  onFocus() {\n    const isFocused = this.isFocused();\n    this.listeners.forEach((listener) => {\n      listener(isFocused);\n    });\n  }\n  isFocused() {\n    if (typeof this.#focused === \"boolean\") {\n      return this.#focused;\n    }\n    return globalThis.document?.visibilityState !== \"hidden\";\n  }\n};\nvar focusManager = new FocusManager();\nexport {\n  FocusManager,\n  focusManager\n};\n//# sourceMappingURL=focusManager.js.map","// src/notifyManager.ts\nfunction createNotifyManager() {\n  let queue = [];\n  let transactions = 0;\n  let notifyFn = (callback) => {\n    callback();\n  };\n  let batchNotifyFn = (callback) => {\n    callback();\n  };\n  let scheduleFn = (cb) => setTimeout(cb, 0);\n  const setScheduler = (fn) => {\n    scheduleFn = fn;\n  };\n  const batch = (callback) => {\n    let result;\n    transactions++;\n    try {\n      result = callback();\n    } finally {\n      transactions--;\n      if (!transactions) {\n        flush();\n      }\n    }\n    return result;\n  };\n  const schedule = (callback) => {\n    if (transactions) {\n      queue.push(callback);\n    } else {\n      scheduleFn(() => {\n        notifyFn(callback);\n      });\n    }\n  };\n  const batchCalls = (callback) => {\n    return (...args) => {\n      schedule(() => {\n        callback(...args);\n      });\n    };\n  };\n  const flush = () => {\n    const originalQueue = queue;\n    queue = [];\n    if (originalQueue.length) {\n      scheduleFn(() => {\n        batchNotifyFn(() => {\n          originalQueue.forEach((callback) => {\n            notifyFn(callback);\n          });\n        });\n      });\n    }\n  };\n  const setNotifyFunction = (fn) => {\n    notifyFn = fn;\n  };\n  const setBatchNotifyFunction = (fn) => {\n    batchNotifyFn = fn;\n  };\n  return {\n    batch,\n    batchCalls,\n    schedule,\n    setNotifyFunction,\n    setBatchNotifyFunction,\n    setScheduler\n  };\n}\nvar notifyManager = createNotifyManager();\nexport {\n  createNotifyManager,\n  notifyManager\n};\n//# sourceMappingURL=notifyManager.js.map","// src/onlineManager.ts\nimport { Subscribable } from \"./subscribable.js\";\nimport { isServer } from \"./utils.js\";\nvar OnlineManager = class extends Subscribable {\n  #online = true;\n  #cleanup;\n  #setup;\n  constructor() {\n    super();\n    this.#setup = (onOnline) => {\n      if (!isServer && window.addEventListener) {\n        const onlineListener = () => onOnline(true);\n        const offlineListener = () => onOnline(false);\n        window.addEventListener(\"online\", onlineListener, false);\n        window.addEventListener(\"offline\", offlineListener, false);\n        return () => {\n          window.removeEventListener(\"online\", onlineListener);\n          window.removeEventListener(\"offline\", offlineListener);\n        };\n      }\n      return;\n    };\n  }\n  onSubscribe() {\n    if (!this.#cleanup) {\n      this.setEventListener(this.#setup);\n    }\n  }\n  onUnsubscribe() {\n    if (!this.hasListeners()) {\n      this.#cleanup?.();\n      this.#cleanup = void 0;\n    }\n  }\n  setEventListener(setup) {\n    this.#setup = setup;\n    this.#cleanup?.();\n    this.#cleanup = setup(this.setOnline.bind(this));\n  }\n  setOnline(online) {\n    const changed = this.#online !== online;\n    if (changed) {\n      this.#online = online;\n      this.listeners.forEach((listener) => {\n        listener(online);\n      });\n    }\n  }\n  isOnline() {\n    return this.#online;\n  }\n};\nvar onlineManager = new OnlineManager();\nexport {\n  OnlineManager,\n  onlineManager\n};\n//# sourceMappingURL=onlineManager.js.map","// src/query.ts\nimport { noop, replaceData, skipToken, timeUntilStale } from \"./utils.js\";\nimport { notifyManager } from \"./notifyManager.js\";\nimport { canFetch, createRetryer, isCancelledError } from \"./retryer.js\";\nimport { Removable } from \"./removable.js\";\nvar Query = class extends Removable {\n  #initialState;\n  #revertState;\n  #cache;\n  #retryer;\n  #observers;\n  #defaultOptions;\n  #abortSignalConsumed;\n  constructor(config) {\n    super();\n    this.#abortSignalConsumed = false;\n    this.#defaultOptions = config.defaultOptions;\n    this.setOptions(config.options);\n    this.#observers = [];\n    this.#cache = config.cache;\n    this.queryKey = config.queryKey;\n    this.queryHash = config.queryHash;\n    this.#initialState = config.state || getDefaultState(this.options);\n    this.state = this.#initialState;\n    this.scheduleGc();\n  }\n  get meta() {\n    return this.options.meta;\n  }\n  setOptions(options) {\n    this.options = { ...this.#defaultOptions, ...options };\n    this.updateGcTime(this.options.gcTime);\n  }\n  optionalRemove() {\n    if (!this.#observers.length && this.state.fetchStatus === \"idle\") {\n      this.#cache.remove(this);\n    }\n  }\n  setData(newData, options) {\n    const data = replaceData(this.state.data, newData, this.options);\n    this.#dispatch({\n      data,\n      type: \"success\",\n      dataUpdatedAt: options?.updatedAt,\n      manual: options?.manual\n    });\n    return data;\n  }\n  setState(state, setStateOptions) {\n    this.#dispatch({ type: \"setState\", state, setStateOptions });\n  }\n  cancel(options) {\n    const promise = this.#retryer?.promise;\n    this.#retryer?.cancel(options);\n    return promise ? promise.then(noop).catch(noop) : Promise.resolve();\n  }\n  destroy() {\n    super.destroy();\n    this.cancel({ silent: true });\n  }\n  reset() {\n    this.destroy();\n    this.setState(this.#initialState);\n  }\n  isActive() {\n    return this.#observers.some(\n      (observer) => observer.options.enabled !== false\n    );\n  }\n  isDisabled() {\n    return this.getObserversCount() > 0 && !this.isActive();\n  }\n  isStale() {\n    if (this.state.isInvalidated) {\n      return true;\n    }\n    if (this.getObserversCount() > 0) {\n      return this.#observers.some(\n        (observer) => observer.getCurrentResult().isStale\n      );\n    }\n    return this.state.data === void 0;\n  }\n  isStaleByTime(staleTime = 0) {\n    return this.state.isInvalidated || this.state.data === void 0 || !timeUntilStale(this.state.dataUpdatedAt, staleTime);\n  }\n  onFocus() {\n    const observer = this.#observers.find((x) => x.shouldFetchOnWindowFocus());\n    observer?.refetch({ cancelRefetch: false });\n    this.#retryer?.continue();\n  }\n  onOnline() {\n    const observer = this.#observers.find((x) => x.shouldFetchOnReconnect());\n    observer?.refetch({ cancelRefetch: false });\n    this.#retryer?.continue();\n  }\n  addObserver(observer) {\n    if (!this.#observers.includes(observer)) {\n      this.#observers.push(observer);\n      this.clearGcTimeout();\n      this.#cache.notify({ type: \"observerAdded\", query: this, observer });\n    }\n  }\n  removeObserver(observer) {\n    if (this.#observers.includes(observer)) {\n      this.#observers = this.#observers.filter((x) => x !== observer);\n      if (!this.#observers.length) {\n        if (this.#retryer) {\n          if (this.#abortSignalConsumed) {\n            this.#retryer.cancel({ revert: true });\n          } else {\n            this.#retryer.cancelRetry();\n          }\n        }\n        this.scheduleGc();\n      }\n      this.#cache.notify({ type: \"observerRemoved\", query: this, observer });\n    }\n  }\n  getObserversCount() {\n    return this.#observers.length;\n  }\n  invalidate() {\n    if (!this.state.isInvalidated) {\n      this.#dispatch({ type: \"invalidate\" });\n    }\n  }\n  fetch(options, fetchOptions) {\n    if (this.state.fetchStatus !== \"idle\") {\n      if (this.state.data !== void 0 && fetchOptions?.cancelRefetch) {\n        this.cancel({ silent: true });\n      } else if (this.#retryer) {\n        this.#retryer.continueRetry();\n        return this.#retryer.promise;\n      }\n    }\n    if (options) {\n      this.setOptions(options);\n    }\n    if (!this.options.queryFn) {\n      const observer = this.#observers.find((x) => x.options.queryFn);\n      if (observer) {\n        this.setOptions(observer.options);\n      }\n    }\n    if (process.env.NODE_ENV !== \"production\") {\n      if (!Array.isArray(this.options.queryKey)) {\n        console.error(\n          `As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']`\n        );\n      }\n    }\n    const abortController = new AbortController();\n    const queryFnContext = {\n      queryKey: this.queryKey,\n      meta: this.meta\n    };\n    const addSignalProperty = (object) => {\n      Object.defineProperty(object, \"signal\", {\n        enumerable: true,\n        get: () => {\n          this.#abortSignalConsumed = true;\n          return abortController.signal;\n        }\n      });\n    };\n    addSignalProperty(queryFnContext);\n    const fetchFn = () => {\n      if (process.env.NODE_ENV !== \"production\") {\n        if (this.options.queryFn === skipToken) {\n          console.error(\n            `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${this.options.queryHash}'`\n          );\n        }\n      }\n      if (!this.options.queryFn || this.options.queryFn === skipToken) {\n        return Promise.reject(\n          new Error(`Missing queryFn: '${this.options.queryHash}'`)\n        );\n      }\n      this.#abortSignalConsumed = false;\n      if (this.options.persister) {\n        return this.options.persister(\n          this.options.queryFn,\n          queryFnContext,\n          this\n        );\n      }\n      return this.options.queryFn(\n        queryFnContext\n      );\n    };\n    const context = {\n      fetchOptions,\n      options: this.options,\n      queryKey: this.queryKey,\n      state: this.state,\n      fetchFn\n    };\n    addSignalProperty(context);\n    this.options.behavior?.onFetch(\n      context,\n      this\n    );\n    this.#revertState = this.state;\n    if (this.state.fetchStatus === \"idle\" || this.state.fetchMeta !== context.fetchOptions?.meta) {\n      this.#dispatch({ type: \"fetch\", meta: context.fetchOptions?.meta });\n    }\n    const onError = (error) => {\n      if (!(isCancelledError(error) && error.silent)) {\n        this.#dispatch({\n          type: \"error\",\n          error\n        });\n      }\n      if (!isCancelledError(error)) {\n        this.#cache.config.onError?.(\n          error,\n          this\n        );\n        this.#cache.config.onSettled?.(\n          this.state.data,\n          error,\n          this\n        );\n      }\n      if (!this.isFetchingOptimistic) {\n        this.scheduleGc();\n      }\n      this.isFetchingOptimistic = false;\n    };\n    this.#retryer = createRetryer({\n      fn: context.fetchFn,\n      abort: abortController.abort.bind(abortController),\n      onSuccess: (data) => {\n        if (data === void 0) {\n          if (process.env.NODE_ENV !== \"production\") {\n            console.error(\n              `Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}`\n            );\n          }\n          onError(new Error(`${this.queryHash} data is undefined`));\n          return;\n        }\n        this.setData(data);\n        this.#cache.config.onSuccess?.(data, this);\n        this.#cache.config.onSettled?.(\n          data,\n          this.state.error,\n          this\n        );\n        if (!this.isFetchingOptimistic) {\n          this.scheduleGc();\n        }\n        this.isFetchingOptimistic = false;\n      },\n      onError,\n      onFail: (failureCount, error) => {\n        this.#dispatch({ type: \"failed\", failureCount, error });\n      },\n      onPause: () => {\n        this.#dispatch({ type: \"pause\" });\n      },\n      onContinue: () => {\n        this.#dispatch({ type: \"continue\" });\n      },\n      retry: context.options.retry,\n      retryDelay: context.options.retryDelay,\n      networkMode: context.options.networkMode\n    });\n    return this.#retryer.promise;\n  }\n  #dispatch(action) {\n    const reducer = (state) => {\n      switch (action.type) {\n        case \"failed\":\n          return {\n            ...state,\n            fetchFailureCount: action.failureCount,\n            fetchFailureReason: action.error\n          };\n        case \"pause\":\n          return {\n            ...state,\n            fetchStatus: \"paused\"\n          };\n        case \"continue\":\n          return {\n            ...state,\n            fetchStatus: \"fetching\"\n          };\n        case \"fetch\":\n          return {\n            ...state,\n            ...fetchState(state.data, this.options),\n            fetchMeta: action.meta ?? null\n          };\n        case \"success\":\n          return {\n            ...state,\n            data: action.data,\n            dataUpdateCount: state.dataUpdateCount + 1,\n            dataUpdatedAt: action.dataUpdatedAt ?? Date.now(),\n            error: null,\n            isInvalidated: false,\n            status: \"success\",\n            ...!action.manual && {\n              fetchStatus: \"idle\",\n              fetchFailureCount: 0,\n              fetchFailureReason: null\n            }\n          };\n        case \"error\":\n          const error = action.error;\n          if (isCancelledError(error) && error.revert && this.#revertState) {\n            return { ...this.#revertState, fetchStatus: \"idle\" };\n          }\n          return {\n            ...state,\n            error,\n            errorUpdateCount: state.errorUpdateCount + 1,\n            errorUpdatedAt: Date.now(),\n            fetchFailureCount: state.fetchFailureCount + 1,\n            fetchFailureReason: error,\n            fetchStatus: \"idle\",\n            status: \"error\"\n          };\n        case \"invalidate\":\n          return {\n            ...state,\n            isInvalidated: true\n          };\n        case \"setState\":\n          return {\n            ...state,\n            ...action.state\n          };\n      }\n    };\n    this.state = reducer(this.state);\n    notifyManager.batch(() => {\n      this.#observers.forEach((observer) => {\n        observer.onQueryUpdate();\n      });\n      this.#cache.notify({ query: this, type: \"updated\", action });\n    });\n  }\n};\nfunction fetchState(data, options) {\n  return {\n    fetchFailureCount: 0,\n    fetchFailureReason: null,\n    fetchStatus: canFetch(options.networkMode) ? \"fetching\" : \"paused\",\n    ...data === void 0 && {\n      error: null,\n      status: \"pending\"\n    }\n  };\n}\nfunction getDefaultState(options) {\n  const data = typeof options.initialData === \"function\" ? options.initialData() : options.initialData;\n  const hasData = data !== void 0;\n  const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === \"function\" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;\n  return {\n    data,\n    dataUpdateCount: 0,\n    dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0,\n    error: null,\n    errorUpdateCount: 0,\n    errorUpdatedAt: 0,\n    fetchFailureCount: 0,\n    fetchFailureReason: null,\n    fetchMeta: null,\n    isInvalidated: false,\n    status: hasData ? \"success\" : \"pending\",\n    fetchStatus: \"idle\"\n  };\n}\nexport {\n  Query,\n  fetchState\n};\n//# sourceMappingURL=query.js.map","// src/queryObserver.ts\nimport {\n  isServer,\n  isValidTimeout,\n  noop,\n  replaceData,\n  shallowEqualObjects,\n  timeUntilStale\n} from \"./utils.js\";\nimport { notifyManager } from \"./notifyManager.js\";\nimport { focusManager } from \"./focusManager.js\";\nimport { Subscribable } from \"./subscribable.js\";\nimport { fetchState } from \"./query.js\";\nvar QueryObserver = class extends Subscribable {\n  constructor(client, options) {\n    super();\n    this.options = options;\n    this.#client = client;\n    this.#selectError = null;\n    this.bindMethods();\n    this.setOptions(options);\n  }\n  #client;\n  #currentQuery = void 0;\n  #currentQueryInitialState = void 0;\n  #currentResult = void 0;\n  #currentResultState;\n  #currentResultOptions;\n  #selectError;\n  #selectFn;\n  #selectResult;\n  // This property keeps track of the last query with defined data.\n  // It will be used to pass the previous data and query to the placeholder function between renders.\n  #lastQueryWithDefinedData;\n  #staleTimeoutId;\n  #refetchIntervalId;\n  #currentRefetchInterval;\n  #trackedProps = /* @__PURE__ */ new Set();\n  bindMethods() {\n    this.refetch = this.refetch.bind(this);\n  }\n  onSubscribe() {\n    if (this.listeners.size === 1) {\n      this.#currentQuery.addObserver(this);\n      if (shouldFetchOnMount(this.#currentQuery, this.options)) {\n        this.#executeFetch();\n      } else {\n        this.updateResult();\n      }\n      this.#updateTimers();\n    }\n  }\n  onUnsubscribe() {\n    if (!this.hasListeners()) {\n      this.destroy();\n    }\n  }\n  shouldFetchOnReconnect() {\n    return shouldFetchOn(\n      this.#currentQuery,\n      this.options,\n      this.options.refetchOnReconnect\n    );\n  }\n  shouldFetchOnWindowFocus() {\n    return shouldFetchOn(\n      this.#currentQuery,\n      this.options,\n      this.options.refetchOnWindowFocus\n    );\n  }\n  destroy() {\n    this.listeners = /* @__PURE__ */ new Set();\n    this.#clearStaleTimeout();\n    this.#clearRefetchInterval();\n    this.#currentQuery.removeObserver(this);\n  }\n  setOptions(options, notifyOptions) {\n    const prevOptions = this.options;\n    const prevQuery = this.#currentQuery;\n    this.options = this.#client.defaultQueryOptions(options);\n    if (this.options.enabled !== void 0 && typeof this.options.enabled !== \"boolean\") {\n      throw new Error(\"Expected enabled to be a boolean\");\n    }\n    this.#updateQuery();\n    this.#currentQuery.setOptions(this.options);\n    if (prevOptions._defaulted && !shallowEqualObjects(this.options, prevOptions)) {\n      this.#client.getQueryCache().notify({\n        type: \"observerOptionsUpdated\",\n        query: this.#currentQuery,\n        observer: this\n      });\n    }\n    const mounted = this.hasListeners();\n    if (mounted && shouldFetchOptionally(\n      this.#currentQuery,\n      prevQuery,\n      this.options,\n      prevOptions\n    )) {\n      this.#executeFetch();\n    }\n    this.updateResult(notifyOptions);\n    if (mounted && (this.#currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.staleTime !== prevOptions.staleTime)) {\n      this.#updateStaleTimeout();\n    }\n    const nextRefetchInterval = this.#computeRefetchInterval();\n    if (mounted && (this.#currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || nextRefetchInterval !== this.#currentRefetchInterval)) {\n      this.#updateRefetchInterval(nextRefetchInterval);\n    }\n  }\n  getOptimisticResult(options) {\n    const query = this.#client.getQueryCache().build(this.#client, options);\n    const result = this.createResult(query, options);\n    if (shouldAssignObserverCurrentProperties(this, result)) {\n      this.#currentResult = result;\n      this.#currentResultOptions = this.options;\n      this.#currentResultState = this.#currentQuery.state;\n    }\n    return result;\n  }\n  getCurrentResult() {\n    return this.#currentResult;\n  }\n  trackResult(result, onPropTracked) {\n    const trackedResult = {};\n    Object.keys(result).forEach((key) => {\n      Object.defineProperty(trackedResult, key, {\n        configurable: false,\n        enumerable: true,\n        get: () => {\n          this.trackProp(key);\n          onPropTracked?.(key);\n          return result[key];\n        }\n      });\n    });\n    return trackedResult;\n  }\n  trackProp(key) {\n    this.#trackedProps.add(key);\n  }\n  getCurrentQuery() {\n    return this.#currentQuery;\n  }\n  refetch({ ...options } = {}) {\n    return this.fetch({\n      ...options\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  fetch(fetchOptions) {\n    return this.#executeFetch({\n      ...fetchOptions,\n      cancelRefetch: fetchOptions.cancelRefetch ?? true\n    }).then(() => {\n      this.updateResult();\n      return this.#currentResult;\n    });\n  }\n  #executeFetch(fetchOptions) {\n    this.#updateQuery();\n    let promise = this.#currentQuery.fetch(\n      this.options,\n      fetchOptions\n    );\n    if (!fetchOptions?.throwOnError) {\n      promise = promise.catch(noop);\n    }\n    return promise;\n  }\n  #updateStaleTimeout() {\n    this.#clearStaleTimeout();\n    if (isServer || this.#currentResult.isStale || !isValidTimeout(this.options.staleTime)) {\n      return;\n    }\n    const time = timeUntilStale(\n      this.#currentResult.dataUpdatedAt,\n      this.options.staleTime\n    );\n    const timeout = time + 1;\n    this.#staleTimeoutId = setTimeout(() => {\n      if (!this.#currentResult.isStale) {\n        this.updateResult();\n      }\n    }, timeout);\n  }\n  #computeRefetchInterval() {\n    return (typeof this.options.refetchInterval === \"function\" ? this.options.refetchInterval(this.#currentQuery) : this.options.refetchInterval) ?? false;\n  }\n  #updateRefetchInterval(nextInterval) {\n    this.#clearRefetchInterval();\n    this.#currentRefetchInterval = nextInterval;\n    if (isServer || this.options.enabled === false || !isValidTimeout(this.#currentRefetchInterval) || this.#currentRefetchInterval === 0) {\n      return;\n    }\n    this.#refetchIntervalId = setInterval(() => {\n      if (this.options.refetchIntervalInBackground || focusManager.isFocused()) {\n        this.#executeFetch();\n      }\n    }, this.#currentRefetchInterval);\n  }\n  #updateTimers() {\n    this.#updateStaleTimeout();\n    this.#updateRefetchInterval(this.#computeRefetchInterval());\n  }\n  #clearStaleTimeout() {\n    if (this.#staleTimeoutId) {\n      clearTimeout(this.#staleTimeoutId);\n      this.#staleTimeoutId = void 0;\n    }\n  }\n  #clearRefetchInterval() {\n    if (this.#refetchIntervalId) {\n      clearInterval(this.#refetchIntervalId);\n      this.#refetchIntervalId = void 0;\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 { state } = query;\n    let newState = { ...state };\n    let isPlaceholderData = false;\n    let data;\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      if (fetchOnMount || fetchOptionally) {\n        newState = {\n          ...newState,\n          ...fetchState(state.data, query.options)\n        };\n      }\n      if (options._optimisticResults === \"isRestoring\") {\n        newState.fetchStatus = \"idle\";\n      }\n    }\n    let { error, errorUpdatedAt, status } = newState;\n    if (options.select && newState.data !== void 0) {\n      if (prevResult && newState.data === prevResultState?.data && options.select === this.#selectFn) {\n        data = this.#selectResult;\n      } else {\n        try {\n          this.#selectFn = options.select;\n          data = options.select(newState.data);\n          data = replaceData(prevResult?.data, data, options);\n          this.#selectResult = data;\n          this.#selectError = null;\n        } catch (selectError) {\n          this.#selectError = selectError;\n        }\n      }\n    } else {\n      data = newState.data;\n    }\n    if (options.placeholderData !== void 0 && data === void 0 && status === \"pending\") {\n      let placeholderData;\n      if (prevResult?.isPlaceholderData && options.placeholderData === prevResultOptions?.placeholderData) {\n        placeholderData = prevResult.data;\n      } else {\n        placeholderData = typeof options.placeholderData === \"function\" ? options.placeholderData(\n          this.#lastQueryWithDefinedData?.state.data,\n          this.#lastQueryWithDefinedData\n        ) : options.placeholderData;\n        if (options.select && placeholderData !== void 0) {\n          try {\n            placeholderData = options.select(placeholderData);\n            this.#selectError = null;\n          } catch (selectError) {\n            this.#selectError = selectError;\n          }\n        }\n      }\n      if (placeholderData !== void 0) {\n        status = \"success\";\n        data = replaceData(\n          prevResult?.data,\n          placeholderData,\n          options\n        );\n        isPlaceholderData = true;\n      }\n    }\n    if (this.#selectError) {\n      error = this.#selectError;\n      data = this.#selectResult;\n      errorUpdatedAt = Date.now();\n      status = \"error\";\n    }\n    const isFetching = newState.fetchStatus === \"fetching\";\n    const isPending = status === \"pending\";\n    const isError = status === \"error\";\n    const isLoading = isPending && isFetching;\n    const hasData = data !== void 0;\n    const result = {\n      status,\n      fetchStatus: newState.fetchStatus,\n      isPending,\n      isSuccess: status === \"success\",\n      isError,\n      isInitialLoading: isLoading,\n      isLoading,\n      data,\n      dataUpdatedAt: newState.dataUpdatedAt,\n      error,\n      errorUpdatedAt,\n      failureCount: newState.fetchFailureCount,\n      failureReason: newState.fetchFailureReason,\n      errorUpdateCount: newState.errorUpdateCount,\n      isFetched: newState.dataUpdateCount > 0 || newState.errorUpdateCount > 0,\n      isFetchedAfterMount: newState.dataUpdateCount > queryInitialState.dataUpdateCount || newState.errorUpdateCount > queryInitialState.errorUpdateCount,\n      isFetching,\n      isRefetching: isFetching && !isPending,\n      isLoadingError: isError && !hasData,\n      isPaused: newState.fetchStatus === \"paused\",\n      isPlaceholderData,\n      isRefetchError: isError && hasData,\n      isStale: isStale(query, options),\n      refetch: this.refetch\n    };\n    return result;\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;\n    if (this.#currentResultState.data !== void 0) {\n      this.#lastQueryWithDefinedData = this.#currentQuery;\n    }\n    if (shallowEqualObjects(nextResult, prevResult)) {\n      return;\n    }\n    this.#currentResult = nextResult;\n    const defaultNotifyOptions = {};\n    const shouldNotifyListeners = () => {\n      if (!prevResult) {\n        return true;\n      }\n      const { notifyOnChangeProps } = this.options;\n      const notifyOnChangePropsValue = typeof notifyOnChangeProps === \"function\" ? notifyOnChangeProps() : notifyOnChangeProps;\n      if (notifyOnChangePropsValue === \"all\" || !notifyOnChangePropsValue && !this.#trackedProps.size) {\n        return true;\n      }\n      const includedProps = new Set(\n        notifyOnChangePropsValue ?? this.#trackedProps\n      );\n      if (this.options.throwOnError) {\n        includedProps.add(\"error\");\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    if (notifyOptions?.listeners !== false && shouldNotifyListeners()) {\n      defaultNotifyOptions.listeners = true;\n    }\n    this.#notify({ ...defaultNotifyOptions, ...notifyOptions });\n  }\n  #updateQuery() {\n    const query = this.#client.getQueryCache().build(this.#client, this.options);\n    if (query === this.#currentQuery) {\n      return;\n    }\n    const prevQuery = this.#currentQuery;\n    this.#currentQuery = query;\n    this.#currentQueryInitialState = query.state;\n    if (this.hasListeners()) {\n      prevQuery?.removeObserver(this);\n      query.addObserver(this);\n    }\n  }\n  onQueryUpdate() {\n    this.updateResult();\n    if (this.hasListeners()) {\n      this.#updateTimers();\n    }\n  }\n  #notify(notifyOptions) {\n    notifyManager.batch(() => {\n      if (notifyOptions.listeners) {\n        this.listeners.forEach((listener) => {\n          listener(this.#currentResult);\n        });\n      }\n      this.#client.getQueryCache().notify({\n        query: this.#currentQuery,\n        type: \"observerResultsUpdated\"\n      });\n    });\n  }\n};\nfunction shouldLoadOnMount(query, options) {\n  return options.enabled !== false && query.state.data === void 0 && !(query.state.status === \"error\" && options.retryOnMount === false);\n}\nfunction shouldFetchOnMount(query, options) {\n  return shouldLoadOnMount(query, options) || query.state.data !== void 0 && shouldFetchOn(query, options, options.refetchOnMount);\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  return false;\n}\nfunction shouldFetchOptionally(query, prevQuery, options, prevOptions) {\n  return (query !== prevQuery || prevOptions.enabled === false) && (!options.suspense || query.state.status !== \"error\") && isStale(query, options);\n}\nfunction isStale(query, options) {\n  return options.enabled !== false && query.isStaleByTime(options.staleTime);\n}\nfunction shouldAssignObserverCurrentProperties(observer, optimisticResult) {\n  if (!shallowEqualObjects(observer.getCurrentResult(), optimisticResult)) {\n    return true;\n  }\n  return false;\n}\nexport {\n  QueryObserver\n};\n//# sourceMappingURL=queryObserver.js.map","// src/removable.ts\nimport { isServer, isValidTimeout } from \"./utils.js\";\nvar Removable = class {\n  #gcTimeout;\n  destroy() {\n    this.clearGcTimeout();\n  }\n  scheduleGc() {\n    this.clearGcTimeout();\n    if (isValidTimeout(this.gcTime)) {\n      this.#gcTimeout = setTimeout(() => {\n        this.optionalRemove();\n      }, this.gcTime);\n    }\n  }\n  updateGcTime(newGcTime) {\n    this.gcTime = Math.max(\n      this.gcTime || 0,\n      newGcTime ?? (isServer ? Infinity : 5 * 60 * 1e3)\n    );\n  }\n  clearGcTimeout() {\n    if (this.#gcTimeout) {\n      clearTimeout(this.#gcTimeout);\n      this.#gcTimeout = void 0;\n    }\n  }\n};\nexport {\n  Removable\n};\n//# sourceMappingURL=removable.js.map","// src/retryer.ts\nimport { focusManager } from \"./focusManager.js\";\nimport { onlineManager } from \"./onlineManager.js\";\nimport { isServer, sleep } from \"./utils.js\";\nfunction defaultRetryDelay(failureCount) {\n  return Math.min(1e3 * 2 ** failureCount, 3e4);\n}\nfunction canFetch(networkMode) {\n  return (networkMode ?? \"online\") === \"online\" ? onlineManager.isOnline() : true;\n}\nvar CancelledError = class {\n  constructor(options) {\n    this.revert = options?.revert;\n    this.silent = options?.silent;\n  }\n};\nfunction isCancelledError(value) {\n  return value instanceof CancelledError;\n}\nfunction createRetryer(config) {\n  let isRetryCancelled = false;\n  let failureCount = 0;\n  let isResolved = false;\n  let continueFn;\n  let promiseResolve;\n  let promiseReject;\n  const promise = new Promise((outerResolve, outerReject) => {\n    promiseResolve = outerResolve;\n    promiseReject = outerReject;\n  });\n  const cancel = (cancelOptions) => {\n    if (!isResolved) {\n      reject(new CancelledError(cancelOptions));\n      config.abort?.();\n    }\n  };\n  const cancelRetry = () => {\n    isRetryCancelled = true;\n  };\n  const continueRetry = () => {\n    isRetryCancelled = false;\n  };\n  const shouldPause = () => !focusManager.isFocused() || config.networkMode !== \"always\" && !onlineManager.isOnline();\n  const resolve = (value) => {\n    if (!isResolved) {\n      isResolved = true;\n      config.onSuccess?.(value);\n      continueFn?.();\n      promiseResolve(value);\n    }\n  };\n  const reject = (value) => {\n    if (!isResolved) {\n      isResolved = true;\n      config.onError?.(value);\n      continueFn?.();\n      promiseReject(value);\n    }\n  };\n  const pause = () => {\n    return new Promise((continueResolve) => {\n      continueFn = (value) => {\n        const canContinue = isResolved || !shouldPause();\n        if (canContinue) {\n          continueResolve(value);\n        }\n        return canContinue;\n      };\n      config.onPause?.();\n    }).then(() => {\n      continueFn = void 0;\n      if (!isResolved) {\n        config.onContinue?.();\n      }\n    });\n  };\n  const run = () => {\n    if (isResolved) {\n      return;\n    }\n    let promiseOrValue;\n    try {\n      promiseOrValue = config.fn();\n    } catch (error) {\n      promiseOrValue = Promise.reject(error);\n    }\n    Promise.resolve(promiseOrValue).then(resolve).catch((error) => {\n      if (isResolved) {\n        return;\n      }\n      const retry = config.retry ?? (isServer ? 0 : 3);\n      const retryDelay = config.retryDelay ?? defaultRetryDelay;\n      const delay = typeof retryDelay === \"function\" ? retryDelay(failureCount, error) : retryDelay;\n      const shouldRetry = retry === true || typeof retry === \"number\" && failureCount < retry || typeof retry === \"function\" && retry(failureCount, error);\n      if (isRetryCancelled || !shouldRetry) {\n        reject(error);\n        return;\n      }\n      failureCount++;\n      config.onFail?.(failureCount, error);\n      sleep(delay).then(() => {\n        if (shouldPause()) {\n          return pause();\n        }\n        return;\n      }).then(() => {\n        if (isRetryCancelled) {\n          reject(error);\n        } else {\n          run();\n        }\n      });\n    });\n  };\n  if (canFetch(config.networkMode)) {\n    run();\n  } else {\n    pause().then(run);\n  }\n  return {\n    promise,\n    cancel,\n    continue: () => {\n      const didContinue = continueFn?.();\n      return didContinue ? promise : Promise.resolve();\n    },\n    cancelRetry,\n    continueRetry\n  };\n}\nexport {\n  CancelledError,\n  canFetch,\n  createRetryer,\n  isCancelledError\n};\n//# sourceMappingURL=retryer.js.map","// src/subscribable.ts\nvar Subscribable = class {\n  constructor() {\n    this.listeners = /* @__PURE__ */ new Set();\n    this.subscribe = this.subscribe.bind(this);\n  }\n  subscribe(listener) {\n    this.listeners.add(listener);\n    this.onSubscribe();\n    return () => {\n      this.listeners.delete(listener);\n      this.onUnsubscribe();\n    };\n  }\n  hasListeners() {\n    return this.listeners.size > 0;\n  }\n  onSubscribe() {\n  }\n  onUnsubscribe() {\n  }\n};\nexport {\n  Subscribable\n};\n//# sourceMappingURL=subscribable.js.map","// src/utils.ts\nvar isServer = typeof window === \"undefined\" || \"Deno\" in globalThis;\nfunction noop() {\n  return void 0;\n}\nfunction functionalUpdate(updater, input) {\n  return typeof updater === \"function\" ? updater(input) : updater;\n}\nfunction isValidTimeout(value) {\n  return typeof value === \"number\" && value >= 0 && value !== Infinity;\n}\nfunction timeUntilStale(updatedAt, staleTime) {\n  return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);\n}\nfunction matchQuery(filters, query) {\n  const {\n    type = \"all\",\n    exact,\n    fetchStatus,\n    predicate,\n    queryKey,\n    stale\n  } = filters;\n  if (queryKey) {\n    if (exact) {\n      if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) {\n        return false;\n      }\n    } else if (!partialMatchKey(query.queryKey, queryKey)) {\n      return false;\n    }\n  }\n  if (type !== \"all\") {\n    const isActive = query.isActive();\n    if (type === \"active\" && !isActive) {\n      return false;\n    }\n    if (type === \"inactive\" && isActive) {\n      return false;\n    }\n  }\n  if (typeof stale === \"boolean\" && query.isStale() !== stale) {\n    return false;\n  }\n  if (fetchStatus && fetchStatus !== query.state.fetchStatus) {\n    return false;\n  }\n  if (predicate && !predicate(query)) {\n    return false;\n  }\n  return true;\n}\nfunction matchMutation(filters, mutation) {\n  const { exact, status, predicate, mutationKey } = filters;\n  if (mutationKey) {\n    if (!mutation.options.mutationKey) {\n      return false;\n    }\n    if (exact) {\n      if (hashKey(mutation.options.mutationKey) !== hashKey(mutationKey)) {\n        return false;\n      }\n    } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) {\n      return false;\n    }\n  }\n  if (status && mutation.state.status !== status) {\n    return false;\n  }\n  if (predicate && !predicate(mutation)) {\n    return false;\n  }\n  return true;\n}\nfunction hashQueryKeyByOptions(queryKey, options) {\n  const hashFn = options?.queryKeyHashFn || hashKey;\n  return hashFn(queryKey);\n}\nfunction hashKey(queryKey) {\n  return JSON.stringify(\n    queryKey,\n    (_, val) => isPlainObject(val) ? Object.keys(val).sort().reduce((result, key) => {\n      result[key] = val[key];\n      return result;\n    }, {}) : val\n  );\n}\nfunction partialMatchKey(a, b) {\n  if (a === b) {\n    return true;\n  }\n  if (typeof a !== typeof b) {\n    return false;\n  }\n  if (a && b && typeof a === \"object\" && typeof b === \"object\") {\n    return !Object.keys(b).some((key) => !partialMatchKey(a[key], b[key]));\n  }\n  return false;\n}\nfunction replaceEqualDeep(a, b) {\n  if (a === b) {\n    return a;\n  }\n  const array = isPlainArray(a) && isPlainArray(b);\n  if (array || isPlainObject(a) && isPlainObject(b)) {\n    const aItems = array ? a : Object.keys(a);\n    const aSize = aItems.length;\n    const bItems = array ? b : Object.keys(b);\n    const bSize = bItems.length;\n    const copy = array ? [] : {};\n    let equalItems = 0;\n    for (let i = 0; i < bSize; i++) {\n      const key = array ? i : bItems[i];\n      if (!array && a[key] === void 0 && b[key] === void 0 && aItems.includes(key)) {\n        copy[key] = void 0;\n        equalItems++;\n      } else {\n        copy[key] = replaceEqualDeep(a[key], b[key]);\n        if (copy[key] === a[key] && a[key] !== void 0) {\n          equalItems++;\n        }\n      }\n    }\n    return aSize === bSize && equalItems === aSize ? a : copy;\n  }\n  return b;\n}\nfunction shallowEqualObjects(a, b) {\n  if (!b || Object.keys(a).length !== Object.keys(b).length) {\n    return false;\n  }\n  for (const key in a) {\n    if (a[key] !== b[key]) {\n      return false;\n    }\n  }\n  return true;\n}\nfunction isPlainArray(value) {\n  return Array.isArray(value) && value.length === Object.keys(value).length;\n}\nfunction isPlainObject(o) {\n  if (!hasObjectPrototype(o)) {\n    return false;\n  }\n  const ctor = o.constructor;\n  if (ctor === void 0) {\n    return true;\n  }\n  const prot = ctor.prototype;\n  if (!hasObjectPrototype(prot)) {\n    return false;\n  }\n  if (!prot.hasOwnProperty(\"isPrototypeOf\")) {\n    return false;\n  }\n  return true;\n}\nfunction hasObjectPrototype(o) {\n  return Object.prototype.toString.call(o) === \"[object Object]\";\n}\nfunction sleep(ms) {\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\nfunction replaceData(prevData, data, options) {\n  if (typeof options.structuralSharing === \"function\") {\n    return options.structuralSharing(prevData, data);\n  } else if (options.structuralSharing !== false) {\n    return replaceEqualDeep(prevData, data);\n  }\n  return data;\n}\nfunction keepPreviousData(previousData) {\n  return previousData;\n}\nfunction addToEnd(items, item, max = 0) {\n  const newItems = [...items, item];\n  return max && newItems.length > max ? newItems.slice(1) : newItems;\n}\nfunction addToStart(items, item, max = 0) {\n  const newItems = [item, ...items];\n  return max && newItems.length > max ? newItems.slice(0, -1) : newItems;\n}\nvar skipToken = Symbol();\nexport {\n  addToEnd,\n  addToStart,\n  functionalUpdate,\n  hashKey,\n  hashQueryKeyByOptions,\n  isPlainArray,\n  isPlainObject,\n  isServer,\n  isValidTimeout,\n  keepPreviousData,\n  matchMutation,\n  matchQuery,\n  noop,\n  partialMatchKey,\n  replaceData,\n  replaceEqualDeep,\n  shallowEqualObjects,\n  skipToken,\n  sleep,\n  timeUntilStale\n};\n//# sourceMappingURL=utils.js.map","\"use client\";\n\n// src/QueryClientProvider.tsx\nimport * as React from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\nvar QueryClientContext = React.createContext(\n  void 0\n);\nvar useQueryClient = (queryClient) => {\n  const client = React.useContext(QueryClientContext);\n  if (queryClient) {\n    return queryClient;\n  }\n  if (!client) {\n    throw new Error(\"No QueryClient set, use QueryClientProvider to set one\");\n  }\n  return client;\n};\nvar QueryClientProvider = ({\n  client,\n  children\n}) => {\n  React.useEffect(() => {\n    client.mount();\n    return () => {\n      client.unmount();\n    };\n  }, [client]);\n  return /* @__PURE__ */ jsx(QueryClientContext.Provider, { value: client, children });\n};\nexport {\n  QueryClientContext,\n  QueryClientProvider,\n  useQueryClient\n};\n//# sourceMappingURL=QueryClientProvider.js.map","\"use client\";\n\n// src/QueryErrorResetBoundary.tsx\nimport * as React from \"react\";\nimport { jsx } from \"react/jsx-runtime\";\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}\nvar QueryErrorResetBoundaryContext = React.createContext(createValue());\nvar useQueryErrorResetBoundary = () => React.useContext(QueryErrorResetBoundaryContext);\nvar QueryErrorResetBoundary = ({\n  children\n}) => {\n  const [value] = React.useState(() => createValue());\n  return /* @__PURE__ */ jsx(QueryErrorResetBoundaryContext.Provider, { value, children: typeof children === \"function\" ? children(value) : children });\n};\nexport {\n  QueryErrorResetBoundary,\n  useQueryErrorResetBoundary\n};\n//# sourceMappingURL=QueryErrorResetBoundary.js.map","\"use client\";\n\n// src/isRestoring.ts\nimport * as React from \"react\";\nvar IsRestoringContext = React.createContext(false);\nvar useIsRestoring = () => React.useContext(IsRestoringContext);\nvar IsRestoringProvider = IsRestoringContext.Provider;\nexport {\n  IsRestoringProvider,\n  useIsRestoring\n};\n//# sourceMappingURL=isRestoring.js.map","\"use client\";\n\n// src/errorBoundaryUtils.ts\nimport * as React from \"react\";\nimport { shouldThrowError } from \"./utils.js\";\nvar ensurePreventErrorBoundaryRetry = (options, errorResetBoundary) => {\n  if (options.suspense || options.throwOnError) {\n    if (!errorResetBoundary.isReset()) {\n      options.retryOnMount = false;\n    }\n  }\n};\nvar useClearResetErrorBoundary = (errorResetBoundary) => {\n  React.useEffect(() => {\n    errorResetBoundary.clearReset();\n  }, [errorResetBoundary]);\n};\nvar getHasError = ({\n  result,\n  errorResetBoundary,\n  throwOnError,\n  query\n}) => {\n  return result.isError && !errorResetBoundary.isReset() && !result.isFetching && query && shouldThrowError(throwOnError, [result.error, query]);\n};\nexport {\n  ensurePreventErrorBoundaryRetry,\n  getHasError,\n  useClearResetErrorBoundary\n};\n//# sourceMappingURL=errorBoundaryUtils.js.map","// src/suspense.ts\nvar defaultThrowOnError = (_error, query) => query.state.data === void 0;\nvar ensureStaleTime = (defaultedOptions) => {\n  if (defaultedOptions.suspense) {\n    if (typeof defaultedOptions.staleTime !== \"number\") {\n      defaultedOptions.staleTime = 1e3;\n    }\n  }\n};\nvar willFetch = (result, isRestoring) => result.isLoading && result.isFetching && !isRestoring;\nvar shouldSuspend = (defaultedOptions, result) => defaultedOptions?.suspense && result.isPending;\nvar fetchOptimistic = (defaultedOptions, observer, errorResetBoundary) => observer.fetchOptimistic(defaultedOptions).catch(() => {\n  errorResetBoundary.clearReset();\n});\nexport {\n  defaultThrowOnError,\n  ensureStaleTime,\n  fetchOptimistic,\n  shouldSuspend,\n  willFetch\n};\n//# sourceMappingURL=suspense.js.map","\"use client\";\n\n// src/useBaseQuery.ts\nimport * as React from \"react\";\nimport { notifyManager } from \"@tanstack/query-core\";\nimport { useQueryErrorResetBoundary } from \"./QueryErrorResetBoundary.js\";\nimport { useQueryClient } from \"./QueryClientProvider.js\";\nimport { useIsRestoring } from \"./isRestoring.js\";\nimport {\n  ensurePreventErrorBoundaryRetry,\n  getHasError,\n  useClearResetErrorBoundary\n} from \"./errorBoundaryUtils.js\";\nimport { ensureStaleTime, fetchOptimistic, shouldSuspend } from \"./suspense.js\";\nfunction useBaseQuery(options, Observer, queryClient) {\n  if (process.env.NODE_ENV !== \"production\") {\n    if (typeof options !== \"object\" || Array.isArray(options)) {\n      throw new Error(\n        'Bad argument type. Starting with v5, only the \"Object\" form is allowed when calling query related functions. Please use the error stack to find the culprit call. More info here: https://tanstack.com/query/latest/docs/react/guides/migrating-to-v5#supports-a-single-signature-one-object'\n      );\n    }\n  }\n  const client = useQueryClient(queryClient);\n  const isRestoring = useIsRestoring();\n  const errorResetBoundary = useQueryErrorResetBoundary();\n  const defaultedOptions = client.defaultQueryOptions(options);\n  defaultedOptions._optimisticResults = isRestoring ? \"isRestoring\" : \"optimistic\";\n  ensureStaleTime(defaultedOptions);\n  ensurePreventErrorBoundaryRetry(defaultedOptions, errorResetBoundary);\n  useClearResetErrorBoundary(errorResetBoundary);\n  const [observer] = React.useState(\n    () => new Observer(\n      client,\n      defaultedOptions\n    )\n  );\n  const result = observer.getOptimisticResult(defaultedOptions);\n  React.useSyncExternalStore(\n    React.useCallback(\n      (onStoreChange) => {\n        const unsubscribe = isRestoring ? () => void 0 : observer.subscribe(notifyManager.batchCalls(onStoreChange));\n        observer.updateResult();\n        return unsubscribe;\n      },\n      [observer, isRestoring]\n    ),\n    () => observer.getCurrentResult(),\n    () => observer.getCurrentResult()\n  );\n  React.useEffect(() => {\n    observer.setOptions(defaultedOptions, { listeners: false });\n  }, [defaultedOptions, observer]);\n  if (shouldSuspend(defaultedOptions, result)) {\n    throw fetchOptimistic(defaultedOptions, observer, errorResetBoundary);\n  }\n  if (getHasError({\n    result,\n    errorResetBoundary,\n    throwOnError: defaultedOptions.throwOnError,\n    query: client.getQueryCache().get(defaultedOptions.queryHash)\n  })) {\n    throw result.error;\n  }\n  return !defaultedOptions.notifyOnChangeProps ? observer.trackResult(result) : result;\n}\nexport {\n  useBaseQuery\n};\n//# sourceMappingURL=useBaseQuery.js.map","\"use client\";\n\n// src/useQuery.ts\nimport { QueryObserver } from \"@tanstack/query-core\";\nimport { useBaseQuery } from \"./useBaseQuery.js\";\nfunction useQuery(options, queryClient) {\n  return useBaseQuery(options, QueryObserver, queryClient);\n}\nexport {\n  useQuery\n};\n//# sourceMappingURL=useQuery.js.map","// src/utils.ts\nfunction shouldThrowError(throwError, params) {\n  if (typeof throwError === \"function\") {\n    return throwError(...params);\n  }\n  return !!throwError;\n}\nfunction noop() {\n}\nexport {\n  noop,\n  shouldThrowError\n};\n//# sourceMappingURL=utils.js.map","import _curry1 from \"./internal/_curry1.js\";\n\n/**\n * Returns a function that always returns the given value. Note that for\n * non-primitives the value returned is a reference to the original value.\n *\n * This function is known as `const`, `constant`, or `K` (for K combinator) in\n * other languages and libraries.\n *\n * @func\n * @memberOf R\n * @since v0.1.0\n * @category Function\n * @sig a -> (* -> a)\n * @param {*} val The value to wrap in a function\n * @return {Function} A Function :: * -> val.\n * @example\n *\n *      const t = R.always('Tee');\n *      t(); //=> 'Tee'\n */\nvar always = /*#__PURE__*/_curry1(function always(val) {\n  return function () {\n    return val;\n  };\n});\nexport default always;"],"names":["__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","value","step","next","e","result","done","then","fulfilled","rejected","apply","__generator","body","f","y","t","g","_","label","sent","trys","ops","verb","Symbol","iterator","this","n","v","op","TypeError","call","pop","length","push","__read","o","m","r","i","ar","error","Result","defaultErrorConfig","withStackTrace","createNeverThrowError","message","config","data","isOk","type","stack","Error","fromThrowable","fn","errorFn","args","_i","arguments","concat","__spread","ok","err","Ok","Err","prototype","isErr","map","mapErr","_f","andThen","orElse","asyncAndThen","asyncMap","ResultAsync","fromSafePromise","unwrapOr","_v","match","_err","_unsafeUnwrap","_unsafeUnwrapErr","errAsync","_ok","res","_promise","promise","fromPromise","_this","_a","_b","bind","newValue","successCallback","failureCallback","module","genericMessage","Object","setPrototypeOf","obj","proto","__proto__","InvariantError","_super","framesToPop","name","invariant","condition","wrapConsoleMethod","method","console","warn","processStub","env","process","Function","atLeastWeTried","focusManager","constructor","super","onFocus","window","addEventListener","listener","removeEventListener","onSubscribe","setEventListener","onUnsubscribe","hasListeners","setup","focused","setFocused","isFocused","listeners","forEach","globalThis","document","visibilityState","notifyManager","queue","transactions","notifyFn","callback","batchNotifyFn","scheduleFn","cb","setTimeout","schedule","batch","originalQueue","flush","batchCalls","setNotifyFunction","setBatchNotifyFunction","setScheduler","createNotifyManager","onlineManager","onOnline","onlineListener","offlineListener","setOnline","online","isOnline","Query","defaultOptions","setOptions","options","cache","queryKey","queryHash","state","initialData","hasData","initialDataUpdatedAt","dataUpdateCount","dataUpdatedAt","Date","now","errorUpdateCount","errorUpdatedAt","fetchFailureCount","fetchFailureReason","fetchMeta","isInvalidated","status","fetchStatus","getDefaultState","scheduleGc","meta","updateGcTime","gcTime","optionalRemove","remove","setData","newData","updatedAt","manual","setState","setStateOptions","cancel","catch","destroy","silent","reset","isActive","some","observer","enabled","isDisabled","getObserversCount","isStale","getCurrentResult","isStaleByTime","staleTime","find","x","shouldFetchOnWindowFocus","refetch","cancelRefetch","continue","shouldFetchOnReconnect","addObserver","includes","clearGcTimeout","notify","query","removeObserver","filter","revert","cancelRetry","invalidate","fetch","fetchOptions","continueRetry","queryFn","abortController","AbortController","queryFnContext","addSignalProperty","object","defineProperty","enumerable","get","signal","context","fetchFn","persister","behavior","onFetch","onError","onSettled","isFetchingOptimistic","abort","onSuccess","onFail","failureCount","onPause","onContinue","retry","retryDelay","networkMode","action","fetchState","reducer","onQueryUpdate","QueryObserver","client","Set","bindMethods","size","shouldFetchOnMount","updateResult","shouldFetchOn","refetchOnReconnect","refetchOnWindowFocus","notifyOptions","prevOptions","prevQuery","defaultQueryOptions","_defaulted","getQueryCache","mounted","shouldFetchOptionally","nextRefetchInterval","getOptimisticResult","build","createResult","optimisticResult","trackResult","onPropTracked","trackedResult","keys","key","configurable","trackProp","add","getCurrentQuery","fetchOptimistic","defaultedOptions","prevResult","prevResultState","prevResultOptions","queryInitialState","newState","isPlaceholderData","_optimisticResults","fetchOnMount","fetchOptionally","select","selectError","placeholderData","isFetching","isPending","isError","isLoading","isSuccess","isInitialLoading","failureReason","isFetched","isFetchedAfterMount","isRefetching","isLoadingError","isPaused","isRefetchError","nextResult","defaultNotifyOptions","notifyOnChangeProps","notifyOnChangePropsValue","includedProps","throwOnError","typedKey","has","shouldNotifyListeners","time","refetchInterval","nextInterval","setInterval","refetchIntervalInBackground","clearTimeout","clearInterval","retryOnMount","shouldLoadOnMount","refetchOnMount","field","suspense","Removable","newGcTime","Math","max","Infinity","defaultRetryDelay","min","canFetch","CancelledError","isCancelledError","createRetryer","continueFn","promiseResolve","promiseReject","isRetryCancelled","isResolved","outerResolve","outerReject","shouldPause","pause","continueResolve","canContinue","run","promiseOrValue","delay","shouldRetry","cancelOptions","Subscribable","subscribe","delete","isServer","noop","functionalUpdate","updater","input","isValidTimeout","timeUntilStale","matchQuery","filters","exact","predicate","stale","hashQueryKeyByOptions","partialMatchKey","matchMutation","mutation","mutationKey","hashKey","queryKeyHashFn","JSON","stringify","val","isPlainObject","sort","reduce","a","b","replaceEqualDeep","array","isPlainArray","aItems","aSize","bItems","bSize","copy","equalItems","shallowEqualObjects","Array","isArray","hasObjectPrototype","ctor","prot","hasOwnProperty","toString","sleep","ms","replaceData","prevData","structuralSharing","addToEnd","items","item","newItems","slice","addToStart","skipToken","QueryClientContext","useQueryClient","queryClient","QueryClientProvider","children","mount","unmount","jsx","Provider","QueryErrorResetBoundaryContext","isReset","clearReset","createValue","useQueryErrorResetBoundary","IsRestoringContext","useIsRestoring","ensurePreventErrorBoundaryRetry","errorResetBoundary","useClearResetErrorBoundary","getHasError","ensureStaleTime","shouldSuspend","useBaseQuery","Observer","isRestoring","onStoreChange","unsubscribe","useQuery","shouldThrowError","throwError","params"],"sourceRoot":""}