{"version":3,"sources":["webpack:///./node_modules/xstate/es/invokeUtils.js","webpack:///./node_modules/xstate/es/StateNode.js","webpack:///./node_modules/xstate/es/Machine.js","webpack:///./src/machines/bookMachine.ts","webpack:///./node_modules/@xstate/vue/es/useInterpret.js","webpack:///./node_modules/@xstate/vue/es/useMachine.js","webpack:///./src/machines/dataMachine.ts","webpack:///./src/components/TooltipStatus.vue","webpack:///./node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js","webpack:///./node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js","webpack:///./node_modules/@babel/runtime/helpers/esm/nonIterableRest.js","webpack:///./node_modules/@babel/runtime/helpers/esm/slicedToArray.js","webpack:///./src/components/TooltipButton.vue","webpack:///./src/components/TooltipButton.vue?577d","webpack:///./src/components/TooltipButton.vue?87c5","webpack:///./src/components/TooltipStatus.vue?7b44","webpack:///./src/components/TooltipStatus.vue?1c59","webpack:///./src/components/TooltipStatus.vue?dd82","webpack:///./src/utils/book.ts","webpack:///./node_modules/vue-query/esm/index.js","webpack:///./src/utils/QueryClient.ts","webpack:///./src/utils/listItems.ts"],"names":["toInvokeSource","src","simpleSrc","type","toInvokeDefinition","invokeConfig","toJSON","onDone","onError","invokeDef","NULL_EVENT","STATE_IDENTIFIER","WILDCARD","EMPTY_OBJECT","isStateId","str","createDefaultOptions","actions","guards","services","activities","delays","validateArrayifiedTransitions","stateNode","event","transitions","hasNonLastUnguardedTarget","slice","some","transition","target","eventText","id","StateNode","config","options","_context","_a","_this","this","context","undefined","order","__xstatenode","__cache","events","relativeValue","Map","initialStateValue","initialState","on","candidates","delayedTransitions","idMap","tags","Object","assign","parent","_parent","key","_key","machine","path","concat","delimiter","join","version","parallel","states","length","history","schema","initial","stateConfig","dfs","e_1","_b","_c","next","done","child","value","e_1_1","error","return","call","_transient","always","Array","isArray","strict","onEntry","entry","map","action","onExit","exit","meta","doneData","data","invoke","i","invokeSrc","invokeSource","activity","bind","prototype","_init","forEach","withConfig","withContext","defineProperty","get","enumerable","configurable","state","definition","reduce","eventType","push","getDelayedTransitions","formatTransitions","getCandidates","eventName","transient","filter","sameEventType","afterConfig","after","mutateEntryExit","delay","delayRef","configTransition","resolvedTransition","resolvedDelay","isNaN","delayedTransition","formatTransition","getStateNodes","stateValue","State","getStateNode","subStateKeys","subStateNodes","subStateKey","allSubStateNodes","subStateNode","handles","includes","resolveState","configuration","from","resolve","transitionLeafNode","_event","transitionCompoundNode","_transition","transitionParallelNode","e_2","transitionMap","subStateValue","e_2_1","stateTransitions","enabledTransitions","st","willTransition","entryNodes","t","entrySet","exitSet","source","e_3","selectedTransition","name","nextStateNodes","candidate","cond","stateIn","in","resolvedContext","isInState","matches","getStateNodeById","guardPassed","err","Error","message","apply","e_3_1","allNextStateNodes","getRelativeStateNodes","historyValue","isInternal","internal","reentryNodes","n","nodesFromChild","childStateNode","escapes","nodes","marker","getActions","currentContext","prevState","e_4","e_5","prevConfig","resolvedConfig","resolvedConfig_1","resolvedConfig_1_1","sn","e_4_1","prevConfig_1","prevConfig_1_1","e_5_1","doneEvents","grandparent","every","parentNode","sort","a","b","entryStates","Set","exitStates","entryActions","exitActions","currentState","resolvedStateValue","getResolvedPath","stateTransition","resolveTransition","resolveRaisedTransition","originalEvent","currentActions","unshift","e_6","actions_1","actions_1_1","e_6_1","preserveActionOrder","resolvedActions","updatedContext","to","Internal","raisedEvents","nonRaisedActions","invokeActions","children","acc","resolvedConfiguration","isDone","nextState","_sessionid","didUpdateContext","changed","isTransient","maybeNextState","raisedEvent","shift","stateKey","result","stateId","resolvedStateId","getStateNodeByPath","statePath","e","arrayStatePath","currentStateNode","stateIdentifier","getInitialState","historyConfig","relativeStateId","resolveHistory","initialStateNodes","initialStateNodePaths","initialPath","getFromRelativePath","relativePath","childStatePath","relativeStateValue","current","historyTarget","relativeChildPath","subHistoryValue","subStatePath","childStateIds","stateIds","e_7","e_8","ownEvents","_d","_e","_f","event_1","add","e_8_1","e_7_1","resolveTarget","_target","isInternalTarget","resolvedTarget","targetStateNode","transitionConfig","normalizedTarget","e_9","onConfig","wildcardConfigs","strictTransitionConfigs_1","transitionConfigArray","eventlessConfig","doneConfig","String","settleTransitions","formattedTransitions","delayedTransitions_1","delayedTransitions_1_1","e_9_1","createMachine","bookModel","book","listItem","buttons","star","note","ADD","REMOVE","FINISH","UNFINISH","RATE","WRITE","bookMachine","item","bookId","bookIdv","loadBookInitial","loadBook","failure","success","pending","unread","read","duration","finish","unfinish","rateStar","isUnread","isRead","isFinish","finishDate","performBook","performListItem","buildNote","performRequest","ctx","notes","sendParent","buildStar","buildAddButtons","buildRemoveFinishUnfinishButtons","Date","now","console","log","setBook","setListItem","removeListItem","clearError","__assign","s","arguments","p","hasOwnProperty","__rest","indexOf","getOwnPropertySymbols","propertyIsEnumerable","toObserver","nextHandler","errorHandler","completionHandler","noop","complete","useInterpret","getMachine","observerOrListener","sub","rehydratedState","interpreterOptions","machineConfig","machineWithConfig","service","start","create","subscribe","stop","unsubscribe","useMachine","listener","initialStateChanged","keys","send","dataMachine","idle","CLICK","loading","class","showRemoveBtn","icon","label","btn","btnState","removeState","clickHandler","evtFun","remove","showAddBtn","createState","showUnfinBtn","unfinishState","showFinBtn","finishState","_arrayWithHoles","arr","_iterableToArrayLimit","_i","Symbol","iterator","_s","_arr","_n","_nonIterableRest","TypeError","_slicedToArray","arrayWithHoles","iterableToArrayLimit","unsupportedIterableToArray","nonIterableRest","aria-label","content","isError","placement","effect","model-value","manual","native-type","size","circle","disabled","isLoading","props","Function","required","setup","render","buttonsRef","bookState","ref","useActor","components","TooltipButton","__scopeId","client","fetchQuery","then","bookSearchFunction","query","encodeURIComponent","books","bookSearch","queryKey","queryFn","refetchBookSearch","removeQueries","exact","prefetchQuery","_setPrototypeOf","o","setPrototypeOf","__proto__","_inheritsLoose","subClass","superClass","constructor","Subscribable","listeners","_proto","callback","onSubscribe","x","onUnsubscribe","hasListeners","_extends","isServer","window","functionalUpdate","updater","input","isValidTimeout","Infinity","ensureQueryKeyArray","timeUntilStale","updatedAt","staleTime","Math","max","parseQueryArgs$1","arg1","arg2","arg3","isQueryKey$1","parseFilterArgs$1","matchQuery","filters","isActive","active","fetching","inactive","predicate","stale","queryHash","hashQueryKeyByOptions","partialMatchKey","isStale","isFetching","matchMutation","mutation","mutationKey","hashQueryKey","status","hashFn","queryKeyHashFn","asArray","stableValueHash","JSON","stringify","_","val","isPlainObject","partialDeepEqual","replaceEqualDeep","array","aSize","bItems","bSize","copy","equalItems","hasObjectPrototype","ctor","prot","toString","sleep","timeout","Promise","setTimeout","scheduleMicrotask","catch","FocusManager","_Subscribable","removeEventListener","setDefaultEventListener","setEventListener","focused","setFocused","onFocus","isFocused","document","visibilityState","_window","addEventListener","focusManager","OnlineManager","online","setOnline","onOnline","isOnline","navigator","onLine","onlineManager","defaultRetryDelay","failureCount","min","pow","isCancelable","cancel","CancelledError","revert","silent","isCancelledError","Retryer","cancelFn","continueFn","promiseResolve","promiseReject","cancelRetry","cancelOptions","continue","isPaused","isResolved","isTransportCancelable","promise","outerResolve","outerReject","onSuccess","reject","pause","continueResolve","onPause","onContinue","run","promiseOrValue","fn","_unused","_config$retry","_config$retryDelay","retry","retryDelay","shouldRetry","onFail","NotifyManager","queue","transactions","notifyFn","batchNotifyFn","batch","flush","schedule","batchCalls","_this2","_len","args","_this3","setNotifyFunction","setBatchNotifyFunction","notifyManager","logger","warn","getLogger","Query","defaultOptions","setOptions","observers","cache","getDefaultState","scheduleGc","_this$options$cacheTi","cacheTime","setDefaultOptions","clearGcTimeout","gcTimeout","optionalRemove","clearTimeout","setData","_this$options$isDataE","_this$options","prevData","isDataEqual","structuralSharing","dispatch","dataUpdatedAt","setState","setStateOptions","_this$retryer","retryer","destroy","reset","observer","enabled","isInvalidated","getCurrentResult","isStaleByTime","_this$retryer2","find","shouldFetchOnWindowFocus","refetch","_this$retryer3","shouldFetchOnReconnect","addObserver","notify","removeObserver","getObserversCount","invalidate","fetch","fetchOptions","_this$options$behavio","_context$fetchOptions","cancelRefetch","_this$options$behavio2","_context$fetchOptions2","queryFnContext","pageParam","fetchFn","behavior","onFetch","revertState","fetchMeta","reducer","onQueryUpdate","initialData","hasInitialData","initialDataUpdatedAt","hasData","dataUpdateCount","errorUpdateCount","errorUpdatedAt","fetchFailureCount","_action$meta","_action$dataUpdatedAt","QueryCache","queries","queriesMap","build","_options$queryHash","defaultQueryOptions","getQueryDefaults","queryInMap","clear","getAll","_parseFilterArgs","findAll","_parseFilterArgs2","_this4","_this5","Mutation","mutationId","mutationCache","execute","restored","variables","onMutate","executeMutation","onSettled","_this$options$retry","mutationFn","onMutationUpdate","MutationCache","mutations","defaultMutationOptions","getMutationDefaults","resumePausedMutations","pausedMutations","infiniteQueryBehavior","_context$state$data","_context$state$data2","fetchMore","isFetchingNextPage","direction","isFetchingPreviousPage","oldPages","pages","oldPageParams","pageParams","newPageParams","cancelled","fetchPage","param","previous","queryFnResult","page","promiseAsAny","getNextPageParam","_manual","_param","getPreviousPageParam","_loop","finalPromise","finalPromiseAsAny","QueryClient","queryCache","queryDefaults","mutationDefaults","mount","unsubscribeFocus","unsubscribeOnline","unmount","_this$unsubscribeFocu","_this$unsubscribeOnli","isMutating","getQueryData","_this$queryCache$find","setQueryData","parsedOptions","defaultedOptions","setQueriesData","queryKeyOrFilters","getQueryCache","_ref","getQueryState","_this$queryCache$find2","resetQueries","_parseFilterArgs3","refetchFilters","refetchQueries","cancelQueries","_parseFilterArgs4","_parseFilterArgs4$","promises","all","invalidateQueries","_filters$refetchActiv","_parseFilterArgs5","refetchActive","refetchInactive","_this6","_parseFilterArgs6","throwOnError","fetchInfiniteQuery","prefetchInfiniteQuery","cancelMutations","_this7","getMutationCache","getDefaultOptions","setQueryDefaults","_this$queryDefaults$f","setMutationDefaults","_this$mutationDefault","_defaulted","defaultQueryObserverOptions","performListItems","listItems","performCreateListItem","method","performRemoveListItem","listItemId","perfermUdateListItem","payload","perform","optimisticUpdate","oldvalue"],"mappings":"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","file":"js/book~discover~finished~readingList.c70bf1b6.js","sourcesContent":["import { __assign, __rest } from './_virtual/_tslib.js';\nimport './environment.js';\nimport './utils.js';\nimport './types.js';\nimport { invoke } from './actionTypes.js';\n\nfunction toInvokeSource(src) {\n  if (typeof src === 'string') {\n    var simpleSrc = {\n      type: src\n    };\n\n    simpleSrc.toString = function () {\n      return src;\n    }; // v4 compat - TODO: remove in v5\n\n\n    return simpleSrc;\n  }\n\n  return src;\n}\nfunction toInvokeDefinition(invokeConfig) {\n  return __assign(__assign({\n    type: invoke\n  }, invokeConfig), {\n    toJSON: function () {\n      var onDone = invokeConfig.onDone,\n          onError = invokeConfig.onError,\n          invokeDef = __rest(invokeConfig, [\"onDone\", \"onError\"]);\n\n      return __assign(__assign({}, invokeDef), {\n        type: invoke,\n        src: toInvokeSource(invokeConfig.src)\n      });\n    }\n  });\n}\n\nexport { toInvokeDefinition, toInvokeSource };\n","import { __assign, __values, __spreadArray, __read, __rest } from './_virtual/_tslib.js';\nimport { STATE_DELIMITER } from './constants.js';\nimport { IS_PRODUCTION } from './environment.js';\nimport { isFunction, mapValues, isArray, flatten, keys, toArray, toStateValue, isString, getEventType, matchesState, path, evaluateGuard, mapContext, toSCXMLEvent, pathToStateValue, isBuiltInEvent, partition, updateHistoryValue, toStatePath, mapFilterValues, warn, toStatePaths, nestedPath, normalizeTarget, toGuard, toTransitionConfigArray, isMachine } from './utils.js';\nimport { SpecialTargets } from './types.js';\nimport { getAllStateNodes, getConfiguration, isInFinalState, has, getChildren, getValue, isLeafNode } from './stateUtils.js';\nimport { start as start$1, stop as stop$1, invoke, update, nullEvent, raise as raise$1, send as send$1 } from './actionTypes.js';\nimport { done, start, raise, stop, toActionObjects, resolveActions, doneInvoke, error, toActionObject, toActivityDefinition, after, send, cancel, initEvent } from './actions.js';\nimport { State, stateValuesEqual } from './State.js';\nimport { createInvocableActor } from './Actor.js';\nimport { toInvokeDefinition } from './invokeUtils.js';\n\nvar NULL_EVENT = '';\nvar STATE_IDENTIFIER = '#';\nvar WILDCARD = '*';\nvar EMPTY_OBJECT = {};\n\nvar isStateId = function (str) {\n  return str[0] === STATE_IDENTIFIER;\n};\n\nvar createDefaultOptions = function () {\n  return {\n    actions: {},\n    guards: {},\n    services: {},\n    activities: {},\n    delays: {}\n  };\n};\n\nvar validateArrayifiedTransitions = function (stateNode, event, transitions) {\n  var hasNonLastUnguardedTarget = transitions.slice(0, -1).some(function (transition) {\n    return !('cond' in transition) && !('in' in transition) && (isString(transition.target) || isMachine(transition.target));\n  });\n  var eventText = event === NULL_EVENT ? 'the transient event' : \"event '\" + event + \"'\";\n  warn(!hasNonLastUnguardedTarget, \"One or more transitions for \" + eventText + \" on state '\" + stateNode.id + \"' are unreachable. \" + \"Make sure that the default transition is the last one defined.\");\n};\n\nvar StateNode =\n/*#__PURE__*/\n\n/** @class */\nfunction () {\n  function StateNode(\n  /**\r\n   * The raw config used to create the machine.\r\n   */\n  config, options,\n  /**\r\n   * The initial extended state\r\n   */\n  _context // TODO: this is unsafe, but we're removing it in v5 anyway\n  ) {\n    var _this = this;\n\n    if (_context === void 0) {\n      _context = 'context' in config ? config.context : undefined;\n    }\n\n    var _a;\n\n    this.config = config;\n    this._context = _context;\n    /**\r\n     * The order this state node appears. Corresponds to the implicit SCXML document order.\r\n     */\n\n    this.order = -1;\n    this.__xstatenode = true;\n    this.__cache = {\n      events: undefined,\n      relativeValue: new Map(),\n      initialStateValue: undefined,\n      initialState: undefined,\n      on: undefined,\n      transitions: undefined,\n      candidates: {},\n      delayedTransitions: undefined\n    };\n    this.idMap = {};\n    this.tags = [];\n    this.options = Object.assign(createDefaultOptions(), options);\n    this.parent = this.options._parent;\n    this.key = this.config.key || this.options._key || this.config.id || '(machine)';\n    this.machine = this.parent ? this.parent.machine : this;\n    this.path = this.parent ? this.parent.path.concat(this.key) : [];\n    this.delimiter = this.config.delimiter || (this.parent ? this.parent.delimiter : STATE_DELIMITER);\n    this.id = this.config.id || __spreadArray([this.machine.key], __read(this.path)).join(this.delimiter);\n    this.version = this.parent ? this.parent.version : this.config.version;\n    this.type = this.config.type || (this.config.parallel ? 'parallel' : this.config.states && keys(this.config.states).length ? 'compound' : this.config.history ? 'history' : 'atomic');\n    this.schema = this.parent ? this.machine.schema : (_a = this.config.schema) !== null && _a !== void 0 ? _a : {};\n\n    if (!IS_PRODUCTION) {\n      warn(!('parallel' in this.config), \"The \\\"parallel\\\" property is deprecated and will be removed in version 4.1. \" + (this.config.parallel ? \"Replace with `type: 'parallel'`\" : \"Use `type: '\" + this.type + \"'`\") + \" in the config for state node '\" + this.id + \"' instead.\");\n    }\n\n    this.initial = this.config.initial;\n    this.states = this.config.states ? mapValues(this.config.states, function (stateConfig, key) {\n      var _a;\n\n      var stateNode = new StateNode(stateConfig, {\n        _parent: _this,\n        _key: key\n      });\n      Object.assign(_this.idMap, __assign((_a = {}, _a[stateNode.id] = stateNode, _a), stateNode.idMap));\n      return stateNode;\n    }) : EMPTY_OBJECT; // Document order\n\n    var order = 0;\n\n    function dfs(stateNode) {\n      var e_1, _a;\n\n      stateNode.order = order++;\n\n      try {\n        for (var _b = __values(getChildren(stateNode)), _c = _b.next(); !_c.done; _c = _b.next()) {\n          var child = _c.value;\n          dfs(child);\n        }\n      } catch (e_1_1) {\n        e_1 = {\n          error: e_1_1\n        };\n      } finally {\n        try {\n          if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n        } finally {\n          if (e_1) throw e_1.error;\n        }\n      }\n    }\n\n    dfs(this); // History config\n\n    this.history = this.config.history === true ? 'shallow' : this.config.history || false;\n    this._transient = !!this.config.always || (!this.config.on ? false : Array.isArray(this.config.on) ? this.config.on.some(function (_a) {\n      var event = _a.event;\n      return event === NULL_EVENT;\n    }) : NULL_EVENT in this.config.on);\n    this.strict = !!this.config.strict; // TODO: deprecate (entry)\n\n    this.onEntry = toArray(this.config.entry || this.config.onEntry).map(function (action) {\n      return toActionObject(action);\n    }); // TODO: deprecate (exit)\n\n    this.onExit = toArray(this.config.exit || this.config.onExit).map(function (action) {\n      return toActionObject(action);\n    });\n    this.meta = this.config.meta;\n    this.doneData = this.type === 'final' ? this.config.data : undefined;\n    this.invoke = toArray(this.config.invoke).map(function (invokeConfig, i) {\n      var _a, _b;\n\n      if (isMachine(invokeConfig)) {\n        _this.machine.options.services = __assign((_a = {}, _a[invokeConfig.id] = invokeConfig, _a), _this.machine.options.services);\n        return toInvokeDefinition({\n          src: invokeConfig.id,\n          id: invokeConfig.id\n        });\n      } else if (isString(invokeConfig.src)) {\n        return toInvokeDefinition(__assign(__assign({}, invokeConfig), {\n          id: invokeConfig.id || invokeConfig.src,\n          src: invokeConfig.src\n        }));\n      } else if (isMachine(invokeConfig.src) || isFunction(invokeConfig.src)) {\n        var invokeSrc = _this.id + \":invocation[\" + i + \"]\"; // TODO: util function\n\n        _this.machine.options.services = __assign((_b = {}, _b[invokeSrc] = invokeConfig.src, _b), _this.machine.options.services);\n        return toInvokeDefinition(__assign(__assign({\n          id: invokeSrc\n        }, invokeConfig), {\n          src: invokeSrc\n        }));\n      } else {\n        var invokeSource = invokeConfig.src;\n        return toInvokeDefinition(__assign(__assign({\n          id: invokeSource.type\n        }, invokeConfig), {\n          src: invokeSource\n        }));\n      }\n    });\n    this.activities = toArray(this.config.activities).concat(this.invoke).map(function (activity) {\n      return toActivityDefinition(activity);\n    });\n    this.transition = this.transition.bind(this);\n    this.tags = toArray(this.config.tags); // TODO: this is the real fix for initialization once\n    // state node getters are deprecated\n    // if (!this.parent) {\n    //   this._init();\n    // }\n  }\n\n  StateNode.prototype._init = function () {\n    if (this.__cache.transitions) {\n      return;\n    }\n\n    getAllStateNodes(this).forEach(function (stateNode) {\n      return stateNode.on;\n    });\n  };\n  /**\r\n   * Clones this state machine with custom options and context.\r\n   *\r\n   * @param options Options (actions, guards, activities, services) to recursively merge with the existing options.\r\n   * @param context Custom context (will override predefined context)\r\n   */\n\n\n  StateNode.prototype.withConfig = function (options, context) {\n    var _a = this.options,\n        actions = _a.actions,\n        activities = _a.activities,\n        guards = _a.guards,\n        services = _a.services,\n        delays = _a.delays;\n    return new StateNode(this.config, {\n      actions: __assign(__assign({}, actions), options.actions),\n      activities: __assign(__assign({}, activities), options.activities),\n      guards: __assign(__assign({}, guards), options.guards),\n      services: __assign(__assign({}, services), options.services),\n      delays: __assign(__assign({}, delays), options.delays)\n    }, context !== null && context !== void 0 ? context : this.context);\n  };\n  /**\r\n   * Clones this state machine with custom context.\r\n   *\r\n   * @param context Custom context (will override predefined context, not recursive)\r\n   */\n\n\n  StateNode.prototype.withContext = function (context) {\n    return new StateNode(this.config, this.options, context);\n  };\n\n  Object.defineProperty(StateNode.prototype, \"context\", {\n    get: function () {\n      return isFunction(this._context) ? this._context() : this._context;\n    },\n    enumerable: false,\n    configurable: true\n  });\n  Object.defineProperty(StateNode.prototype, \"definition\", {\n    /**\r\n     * The well-structured state node definition.\r\n     */\n    get: function () {\n      return {\n        id: this.id,\n        key: this.key,\n        version: this.version,\n        context: this.context,\n        type: this.type,\n        initial: this.initial,\n        history: this.history,\n        states: mapValues(this.states, function (state) {\n          return state.definition;\n        }),\n        on: this.on,\n        transitions: this.transitions,\n        entry: this.onEntry,\n        exit: this.onExit,\n        activities: this.activities || [],\n        meta: this.meta,\n        order: this.order || -1,\n        data: this.doneData,\n        invoke: this.invoke\n      };\n    },\n    enumerable: false,\n    configurable: true\n  });\n\n  StateNode.prototype.toJSON = function () {\n    return this.definition;\n  };\n\n  Object.defineProperty(StateNode.prototype, \"on\", {\n    /**\r\n     * The mapping of events to transitions.\r\n     */\n    get: function () {\n      if (this.__cache.on) {\n        return this.__cache.on;\n      }\n\n      var transitions = this.transitions;\n      return this.__cache.on = transitions.reduce(function (map, transition) {\n        map[transition.eventType] = map[transition.eventType] || [];\n        map[transition.eventType].push(transition);\n        return map;\n      }, {});\n    },\n    enumerable: false,\n    configurable: true\n  });\n  Object.defineProperty(StateNode.prototype, \"after\", {\n    get: function () {\n      return this.__cache.delayedTransitions || (this.__cache.delayedTransitions = this.getDelayedTransitions(), this.__cache.delayedTransitions);\n    },\n    enumerable: false,\n    configurable: true\n  });\n  Object.defineProperty(StateNode.prototype, \"transitions\", {\n    /**\r\n     * All the transitions that can be taken from this state node.\r\n     */\n    get: function () {\n      return this.__cache.transitions || (this.__cache.transitions = this.formatTransitions(), this.__cache.transitions);\n    },\n    enumerable: false,\n    configurable: true\n  });\n\n  StateNode.prototype.getCandidates = function (eventName) {\n    if (this.__cache.candidates[eventName]) {\n      return this.__cache.candidates[eventName];\n    }\n\n    var transient = eventName === NULL_EVENT;\n    var candidates = this.transitions.filter(function (transition) {\n      var sameEventType = transition.eventType === eventName; // null events should only match against eventless transitions\n\n      return transient ? sameEventType : sameEventType || transition.eventType === WILDCARD;\n    });\n    this.__cache.candidates[eventName] = candidates;\n    return candidates;\n  };\n  /**\r\n   * All delayed transitions from the config.\r\n   */\n\n\n  StateNode.prototype.getDelayedTransitions = function () {\n    var _this = this;\n\n    var afterConfig = this.config.after;\n\n    if (!afterConfig) {\n      return [];\n    }\n\n    var mutateEntryExit = function (delay, i) {\n      var delayRef = isFunction(delay) ? _this.id + \":delay[\" + i + \"]\" : delay;\n      var eventType = after(delayRef, _this.id);\n\n      _this.onEntry.push(send(eventType, {\n        delay: delay\n      }));\n\n      _this.onExit.push(cancel(eventType));\n\n      return eventType;\n    };\n\n    var delayedTransitions = isArray(afterConfig) ? afterConfig.map(function (transition, i) {\n      var eventType = mutateEntryExit(transition.delay, i);\n      return __assign(__assign({}, transition), {\n        event: eventType\n      });\n    }) : flatten(keys(afterConfig).map(function (delay, i) {\n      var configTransition = afterConfig[delay];\n      var resolvedTransition = isString(configTransition) ? {\n        target: configTransition\n      } : configTransition;\n      var resolvedDelay = !isNaN(+delay) ? +delay : delay;\n      var eventType = mutateEntryExit(resolvedDelay, i);\n      return toArray(resolvedTransition).map(function (transition) {\n        return __assign(__assign({}, transition), {\n          event: eventType,\n          delay: resolvedDelay\n        });\n      });\n    }));\n    return delayedTransitions.map(function (delayedTransition) {\n      var delay = delayedTransition.delay;\n      return __assign(__assign({}, _this.formatTransition(delayedTransition)), {\n        delay: delay\n      });\n    });\n  };\n  /**\r\n   * Returns the state nodes represented by the current state value.\r\n   *\r\n   * @param state The state value or State instance\r\n   */\n\n\n  StateNode.prototype.getStateNodes = function (state) {\n    var _a;\n\n    var _this = this;\n\n    if (!state) {\n      return [];\n    }\n\n    var stateValue = state instanceof State ? state.value : toStateValue(state, this.delimiter);\n\n    if (isString(stateValue)) {\n      var initialStateValue = this.getStateNode(stateValue).initial;\n      return initialStateValue !== undefined ? this.getStateNodes((_a = {}, _a[stateValue] = initialStateValue, _a)) : [this, this.states[stateValue]];\n    }\n\n    var subStateKeys = keys(stateValue);\n    var subStateNodes = subStateKeys.map(function (subStateKey) {\n      return _this.getStateNode(subStateKey);\n    });\n    subStateNodes.push(this);\n    return subStateNodes.concat(subStateKeys.reduce(function (allSubStateNodes, subStateKey) {\n      var subStateNode = _this.getStateNode(subStateKey).getStateNodes(stateValue[subStateKey]);\n\n      return allSubStateNodes.concat(subStateNode);\n    }, []));\n  };\n  /**\r\n   * Returns `true` if this state node explicitly handles the given event.\r\n   *\r\n   * @param event The event in question\r\n   */\n\n\n  StateNode.prototype.handles = function (event) {\n    var eventType = getEventType(event);\n    return this.events.includes(eventType);\n  };\n  /**\r\n   * Resolves the given `state` to a new `State` instance relative to this machine.\r\n   *\r\n   * This ensures that `.events` and `.nextEvents` represent the correct values.\r\n   *\r\n   * @param state The state to resolve\r\n   */\n\n\n  StateNode.prototype.resolveState = function (state) {\n    var configuration = Array.from(getConfiguration([], this.getStateNodes(state.value)));\n    return new State(__assign(__assign({}, state), {\n      value: this.resolve(state.value),\n      configuration: configuration,\n      done: isInFinalState(configuration, this)\n    }));\n  };\n\n  StateNode.prototype.transitionLeafNode = function (stateValue, state, _event) {\n    var stateNode = this.getStateNode(stateValue);\n    var next = stateNode.next(state, _event);\n\n    if (!next || !next.transitions.length) {\n      return this.next(state, _event);\n    }\n\n    return next;\n  };\n\n  StateNode.prototype.transitionCompoundNode = function (stateValue, state, _event) {\n    var subStateKeys = keys(stateValue);\n    var stateNode = this.getStateNode(subStateKeys[0]);\n\n    var next = stateNode._transition(stateValue[subStateKeys[0]], state, _event);\n\n    if (!next || !next.transitions.length) {\n      return this.next(state, _event);\n    }\n\n    return next;\n  };\n\n  StateNode.prototype.transitionParallelNode = function (stateValue, state, _event) {\n    var e_2, _a;\n\n    var transitionMap = {};\n\n    try {\n      for (var _b = __values(keys(stateValue)), _c = _b.next(); !_c.done; _c = _b.next()) {\n        var subStateKey = _c.value;\n        var subStateValue = stateValue[subStateKey];\n\n        if (!subStateValue) {\n          continue;\n        }\n\n        var subStateNode = this.getStateNode(subStateKey);\n\n        var next = subStateNode._transition(subStateValue, state, _event);\n\n        if (next) {\n          transitionMap[subStateKey] = next;\n        }\n      }\n    } catch (e_2_1) {\n      e_2 = {\n        error: e_2_1\n      };\n    } finally {\n      try {\n        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n      } finally {\n        if (e_2) throw e_2.error;\n      }\n    }\n\n    var stateTransitions = keys(transitionMap).map(function (key) {\n      return transitionMap[key];\n    });\n    var enabledTransitions = flatten(stateTransitions.map(function (st) {\n      return st.transitions;\n    }));\n    var willTransition = stateTransitions.some(function (st) {\n      return st.transitions.length > 0;\n    });\n\n    if (!willTransition) {\n      return this.next(state, _event);\n    }\n\n    var entryNodes = flatten(stateTransitions.map(function (t) {\n      return t.entrySet;\n    }));\n    var configuration = flatten(keys(transitionMap).map(function (key) {\n      return transitionMap[key].configuration;\n    }));\n    return {\n      transitions: enabledTransitions,\n      entrySet: entryNodes,\n      exitSet: flatten(stateTransitions.map(function (t) {\n        return t.exitSet;\n      })),\n      configuration: configuration,\n      source: state,\n      actions: flatten(keys(transitionMap).map(function (key) {\n        return transitionMap[key].actions;\n      }))\n    };\n  };\n\n  StateNode.prototype._transition = function (stateValue, state, _event) {\n    // leaf node\n    if (isString(stateValue)) {\n      return this.transitionLeafNode(stateValue, state, _event);\n    } // hierarchical node\n\n\n    if (keys(stateValue).length === 1) {\n      return this.transitionCompoundNode(stateValue, state, _event);\n    } // orthogonal node\n\n\n    return this.transitionParallelNode(stateValue, state, _event);\n  };\n\n  StateNode.prototype.next = function (state, _event) {\n    var e_3, _a;\n\n    var _this = this;\n\n    var eventName = _event.name;\n    var actions = [];\n    var nextStateNodes = [];\n    var selectedTransition;\n\n    try {\n      for (var _b = __values(this.getCandidates(eventName)), _c = _b.next(); !_c.done; _c = _b.next()) {\n        var candidate = _c.value;\n        var cond = candidate.cond,\n            stateIn = candidate.in;\n        var resolvedContext = state.context;\n        var isInState = stateIn ? isString(stateIn) && isStateId(stateIn) ? // Check if in state by ID\n        state.matches(toStateValue(this.getStateNodeById(stateIn).path, this.delimiter)) : // Check if in state by relative grandparent\n        matchesState(toStateValue(stateIn, this.delimiter), path(this.path.slice(0, -2))(state.value)) : true;\n        var guardPassed = false;\n\n        try {\n          guardPassed = !cond || evaluateGuard(this.machine, cond, resolvedContext, _event, state);\n        } catch (err) {\n          throw new Error(\"Unable to evaluate guard '\" + (cond.name || cond.type) + \"' in transition for event '\" + eventName + \"' in state node '\" + this.id + \"':\\n\" + err.message);\n        }\n\n        if (guardPassed && isInState) {\n          if (candidate.target !== undefined) {\n            nextStateNodes = candidate.target;\n          }\n\n          actions.push.apply(actions, __spreadArray([], __read(candidate.actions)));\n          selectedTransition = candidate;\n          break;\n        }\n      }\n    } catch (e_3_1) {\n      e_3 = {\n        error: e_3_1\n      };\n    } finally {\n      try {\n        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);\n      } finally {\n        if (e_3) throw e_3.error;\n      }\n    }\n\n    if (!selectedTransition) {\n      return undefined;\n    }\n\n    if (!nextStateNodes.length) {\n      return {\n        transitions: [selectedTransition],\n        entrySet: [],\n        exitSet: [],\n        configuration: state.value ? [this] : [],\n        source: state,\n        actions: actions\n      };\n    }\n\n    var allNextStateNodes = flatten(nextStateNodes.map(function (stateNode) {\n      return _this.getRelativeStateNodes(stateNode, state.historyValue);\n    }));\n    var isInternal = !!selectedTransition.internal;\n    var reentryNodes = isInternal ? [] : flatten(allNextStateNodes.map(function (n) {\n      return _this.nodesFromChild(n);\n    }));\n    return {\n      transitions: [selectedTransition],\n      entrySet: reentryNodes,\n      exitSet: isInternal ? [] : [this],\n      configuration: allNextStateNodes,\n      source: state,\n      actions: actions\n    };\n  };\n\n  StateNode.prototype.nodesFromChild = function (childStateNode) {\n    if (childStateNode.escapes(this)) {\n      return [];\n    }\n\n    var nodes = [];\n    var marker = childStateNode;\n\n    while (marker && marker !== this) {\n      nodes.push(marker);\n      marker = marker.parent;\n    }\n\n    nodes.push(this); // inclusive\n\n    return nodes;\n  };\n  /**\r\n   * Whether the given state node \"escapes\" this state node. If the `stateNode` is equal to or the parent of\r\n   * this state node, it does not escape.\r\n   */\n\n\n  StateNode.prototype.escapes = function (stateNode) {\n    if (this === stateNode) {\n      return false;\n    }\n\n    var parent = this.parent;\n\n    while (parent) {\n      if (parent === stateNode) {\n        return false;\n      }\n\n      parent = parent.parent;\n    }\n\n    return true;\n  };\n\n  StateNode.prototype.getActions = function (transition, currentContext, _event, prevState) {\n    var e_4, _a, e_5, _b;\n\n    var prevConfig = getConfiguration([], prevState ? this.getStateNodes(prevState.value) : [this]);\n    var resolvedConfig = transition.configuration.length ? getConfiguration(prevConfig, transition.configuration) : prevConfig;\n\n    try {\n      for (var resolvedConfig_1 = __values(resolvedConfig), resolvedConfig_1_1 = resolvedConfig_1.next(); !resolvedConfig_1_1.done; resolvedConfig_1_1 = resolvedConfig_1.next()) {\n        var sn = resolvedConfig_1_1.value;\n\n        if (!has(prevConfig, sn)) {\n          transition.entrySet.push(sn);\n        }\n      }\n    } catch (e_4_1) {\n      e_4 = {\n        error: e_4_1\n      };\n    } finally {\n      try {\n        if (resolvedConfig_1_1 && !resolvedConfig_1_1.done && (_a = resolvedConfig_1.return)) _a.call(resolvedConfig_1);\n      } finally {\n        if (e_4) throw e_4.error;\n      }\n    }\n\n    try {\n      for (var prevConfig_1 = __values(prevConfig), prevConfig_1_1 = prevConfig_1.next(); !prevConfig_1_1.done; prevConfig_1_1 = prevConfig_1.next()) {\n        var sn = prevConfig_1_1.value;\n\n        if (!has(resolvedConfig, sn) || has(transition.exitSet, sn.parent)) {\n          transition.exitSet.push(sn);\n        }\n      }\n    } catch (e_5_1) {\n      e_5 = {\n        error: e_5_1\n      };\n    } finally {\n      try {\n        if (prevConfig_1_1 && !prevConfig_1_1.done && (_b = prevConfig_1.return)) _b.call(prevConfig_1);\n      } finally {\n        if (e_5) throw e_5.error;\n      }\n    }\n\n    if (!transition.source) {\n      transition.exitSet = []; // Ensure that root StateNode (machine) is entered\n\n      transition.entrySet.push(this);\n    }\n\n    var doneEvents = flatten(transition.entrySet.map(function (sn) {\n      var events = [];\n\n      if (sn.type !== 'final') {\n        return events;\n      }\n\n      var parent = sn.parent;\n\n      if (!parent.parent) {\n        return events;\n      }\n\n      events.push(done(sn.id, sn.doneData), // TODO: deprecate - final states should not emit done events for their own state.\n      done(parent.id, sn.doneData ? mapContext(sn.doneData, currentContext, _event) : undefined));\n      var grandparent = parent.parent;\n\n      if (grandparent.type === 'parallel') {\n        if (getChildren(grandparent).every(function (parentNode) {\n          return isInFinalState(transition.configuration, parentNode);\n        })) {\n          events.push(done(grandparent.id));\n        }\n      }\n\n      return events;\n    }));\n    transition.exitSet.sort(function (a, b) {\n      return b.order - a.order;\n    });\n    transition.entrySet.sort(function (a, b) {\n      return a.order - b.order;\n    });\n    var entryStates = new Set(transition.entrySet);\n    var exitStates = new Set(transition.exitSet);\n\n    var _c = __read([flatten(Array.from(entryStates).map(function (stateNode) {\n      return __spreadArray(__spreadArray([], __read(stateNode.activities.map(function (activity) {\n        return start(activity);\n      }))), __read(stateNode.onEntry));\n    })).concat(doneEvents.map(raise)), flatten(Array.from(exitStates).map(function (stateNode) {\n      return __spreadArray(__spreadArray([], __read(stateNode.onExit)), __read(stateNode.activities.map(function (activity) {\n        return stop(activity);\n      })));\n    }))], 2),\n        entryActions = _c[0],\n        exitActions = _c[1];\n\n    var actions = toActionObjects(exitActions.concat(transition.actions).concat(entryActions), this.machine.options.actions);\n    return actions;\n  };\n  /**\r\n   * Determines the next state given the current `state` and sent `event`.\r\n   *\r\n   * @param state The current State instance or state value\r\n   * @param event The event that was sent at the current state\r\n   * @param context The current context (extended state) of the current state\r\n   */\n\n\n  StateNode.prototype.transition = function (state, event, context) {\n    if (state === void 0) {\n      state = this.initialState;\n    }\n\n    var _event = toSCXMLEvent(event);\n\n    var currentState;\n\n    if (state instanceof State) {\n      currentState = context === undefined ? state : this.resolveState(State.from(state, context));\n    } else {\n      var resolvedStateValue = isString(state) ? this.resolve(pathToStateValue(this.getResolvedPath(state))) : this.resolve(state);\n      var resolvedContext = context !== null && context !== void 0 ? context : this.machine.context;\n      currentState = this.resolveState(State.from(resolvedStateValue, resolvedContext));\n    }\n\n    if (!IS_PRODUCTION && _event.name === WILDCARD) {\n      throw new Error(\"An event cannot have the wildcard type ('\" + WILDCARD + \"')\");\n    }\n\n    if (this.strict) {\n      if (!this.events.includes(_event.name) && !isBuiltInEvent(_event.name)) {\n        throw new Error(\"Machine '\" + this.id + \"' does not accept event '\" + _event.name + \"'\");\n      }\n    }\n\n    var stateTransition = this._transition(currentState.value, currentState, _event) || {\n      transitions: [],\n      configuration: [],\n      entrySet: [],\n      exitSet: [],\n      source: currentState,\n      actions: []\n    };\n    var prevConfig = getConfiguration([], this.getStateNodes(currentState.value));\n    var resolvedConfig = stateTransition.configuration.length ? getConfiguration(prevConfig, stateTransition.configuration) : prevConfig;\n    stateTransition.configuration = __spreadArray([], __read(resolvedConfig));\n    return this.resolveTransition(stateTransition, currentState, _event);\n  };\n\n  StateNode.prototype.resolveRaisedTransition = function (state, _event, originalEvent) {\n    var _a;\n\n    var currentActions = state.actions;\n    state = this.transition(state, _event); // Save original event to state\n    // TODO: this should be the raised event! Delete in V5 (breaking)\n\n    state._event = originalEvent;\n    state.event = originalEvent.data;\n\n    (_a = state.actions).unshift.apply(_a, __spreadArray([], __read(currentActions)));\n\n    return state;\n  };\n\n  StateNode.prototype.resolveTransition = function (stateTransition, currentState, _event, context) {\n    var e_6, _a;\n\n    var _this = this;\n\n    if (_event === void 0) {\n      _event = initEvent;\n    }\n\n    if (context === void 0) {\n      context = this.machine.context;\n    }\n\n    var configuration = stateTransition.configuration; // Transition will \"apply\" if:\n    // - this is the initial state (there is no current state)\n    // - OR there are transitions\n\n    var willTransition = !currentState || stateTransition.transitions.length > 0;\n    var resolvedStateValue = willTransition ? getValue(this.machine, configuration) : undefined;\n    var historyValue = currentState ? currentState.historyValue ? currentState.historyValue : stateTransition.source ? this.machine.historyValue(currentState.value) : undefined : undefined;\n    var currentContext = currentState ? currentState.context : context;\n    var actions = this.getActions(stateTransition, currentContext, _event, currentState);\n    var activities = currentState ? __assign({}, currentState.activities) : {};\n\n    try {\n      for (var actions_1 = __values(actions), actions_1_1 = actions_1.next(); !actions_1_1.done; actions_1_1 = actions_1.next()) {\n        var action = actions_1_1.value;\n\n        if (action.type === start$1) {\n          activities[action.activity.id || action.activity.type] = action;\n        } else if (action.type === stop$1) {\n          activities[action.activity.id || action.activity.type] = false;\n        }\n      }\n    } catch (e_6_1) {\n      e_6 = {\n        error: e_6_1\n      };\n    } finally {\n      try {\n        if (actions_1_1 && !actions_1_1.done && (_a = actions_1.return)) _a.call(actions_1);\n      } finally {\n        if (e_6) throw e_6.error;\n      }\n    }\n\n    var _b = __read(resolveActions(this, currentState, currentContext, _event, actions, this.machine.config.preserveActionOrder), 2),\n        resolvedActions = _b[0],\n        updatedContext = _b[1];\n\n    var _c = __read(partition(resolvedActions, function (action) {\n      return action.type === raise$1 || action.type === send$1 && action.to === SpecialTargets.Internal;\n    }), 2),\n        raisedEvents = _c[0],\n        nonRaisedActions = _c[1];\n\n    var invokeActions = resolvedActions.filter(function (action) {\n      var _a;\n\n      return action.type === start$1 && ((_a = action.activity) === null || _a === void 0 ? void 0 : _a.type) === invoke;\n    });\n    var children = invokeActions.reduce(function (acc, action) {\n      acc[action.activity.id] = createInvocableActor(action.activity, _this.machine, updatedContext, _event);\n      return acc;\n    }, currentState ? __assign({}, currentState.children) : {});\n    var resolvedConfiguration = resolvedStateValue ? stateTransition.configuration : currentState ? currentState.configuration : [];\n    var isDone = isInFinalState(resolvedConfiguration, this);\n    var nextState = new State({\n      value: resolvedStateValue || currentState.value,\n      context: updatedContext,\n      _event: _event,\n      // Persist _sessionid between states\n      _sessionid: currentState ? currentState._sessionid : null,\n      historyValue: resolvedStateValue ? historyValue ? updateHistoryValue(historyValue, resolvedStateValue) : undefined : currentState ? currentState.historyValue : undefined,\n      history: !resolvedStateValue || stateTransition.source ? currentState : undefined,\n      actions: resolvedStateValue ? nonRaisedActions : [],\n      activities: resolvedStateValue ? activities : currentState ? currentState.activities : {},\n      events: [],\n      configuration: resolvedConfiguration,\n      transitions: stateTransition.transitions,\n      children: children,\n      done: isDone,\n      tags: currentState === null || currentState === void 0 ? void 0 : currentState.tags,\n      machine: this\n    });\n    var didUpdateContext = currentContext !== updatedContext;\n    nextState.changed = _event.name === update || didUpdateContext; // Dispose of penultimate histories to prevent memory leaks\n\n    var history = nextState.history;\n\n    if (history) {\n      delete history.history;\n    } // There are transient transitions if the machine is not in a final state\n    // and if some of the state nodes have transient (\"always\") transitions.\n\n\n    var isTransient = !isDone && (this._transient || configuration.some(function (stateNode) {\n      return stateNode._transient;\n    })); // If there are no enabled transitions, check if there are transient transitions.\n    // If there are transient transitions, continue checking for more transitions\n    // because an transient transition should be triggered even if there are no\n    // enabled transitions.\n    //\n    // If we're already working on an transient transition (by checking\n    // if the event is a NULL_EVENT), then stop to prevent an infinite loop.\n    //\n    // Otherwise, if there are no enabled nor transient transitions, we are done.\n\n    if (!willTransition && (!isTransient || _event.name === NULL_EVENT)) {\n      return nextState;\n    }\n\n    var maybeNextState = nextState;\n\n    if (!isDone) {\n      if (isTransient) {\n        maybeNextState = this.resolveRaisedTransition(maybeNextState, {\n          type: nullEvent\n        }, _event);\n      }\n\n      while (raisedEvents.length) {\n        var raisedEvent = raisedEvents.shift();\n        maybeNextState = this.resolveRaisedTransition(maybeNextState, raisedEvent._event, _event);\n      }\n    } // Detect if state changed\n\n\n    var changed = maybeNextState.changed || (history ? !!maybeNextState.actions.length || didUpdateContext || typeof history.value !== typeof maybeNextState.value || !stateValuesEqual(maybeNextState.value, history.value) : undefined);\n    maybeNextState.changed = changed; // Preserve original history after raised events\n\n    maybeNextState.history = history;\n    maybeNextState.tags = new Set(flatten(maybeNextState.configuration.map(function (sn) {\n      return sn.tags;\n    })));\n    return maybeNextState;\n  };\n  /**\r\n   * Returns the child state node from its relative `stateKey`, or throws.\r\n   */\n\n\n  StateNode.prototype.getStateNode = function (stateKey) {\n    if (isStateId(stateKey)) {\n      return this.machine.getStateNodeById(stateKey);\n    }\n\n    if (!this.states) {\n      throw new Error(\"Unable to retrieve child state '\" + stateKey + \"' from '\" + this.id + \"'; no child states exist.\");\n    }\n\n    var result = this.states[stateKey];\n\n    if (!result) {\n      throw new Error(\"Child state '\" + stateKey + \"' does not exist on '\" + this.id + \"'\");\n    }\n\n    return result;\n  };\n  /**\r\n   * Returns the state node with the given `stateId`, or throws.\r\n   *\r\n   * @param stateId The state ID. The prefix \"#\" is removed.\r\n   */\n\n\n  StateNode.prototype.getStateNodeById = function (stateId) {\n    var resolvedStateId = isStateId(stateId) ? stateId.slice(STATE_IDENTIFIER.length) : stateId;\n\n    if (resolvedStateId === this.id) {\n      return this;\n    }\n\n    var stateNode = this.machine.idMap[resolvedStateId];\n\n    if (!stateNode) {\n      throw new Error(\"Child state node '#\" + resolvedStateId + \"' does not exist on machine '\" + this.id + \"'\");\n    }\n\n    return stateNode;\n  };\n  /**\r\n   * Returns the relative state node from the given `statePath`, or throws.\r\n   *\r\n   * @param statePath The string or string array relative path to the state node.\r\n   */\n\n\n  StateNode.prototype.getStateNodeByPath = function (statePath) {\n    if (typeof statePath === 'string' && isStateId(statePath)) {\n      try {\n        return this.getStateNodeById(statePath.slice(1));\n      } catch (e) {// try individual paths\n        // throw e;\n      }\n    }\n\n    var arrayStatePath = toStatePath(statePath, this.delimiter).slice();\n    var currentStateNode = this;\n\n    while (arrayStatePath.length) {\n      var key = arrayStatePath.shift();\n\n      if (!key.length) {\n        break;\n      }\n\n      currentStateNode = currentStateNode.getStateNode(key);\n    }\n\n    return currentStateNode;\n  };\n  /**\r\n   * Resolves a partial state value with its full representation in this machine.\r\n   *\r\n   * @param stateValue The partial state value to resolve.\r\n   */\n\n\n  StateNode.prototype.resolve = function (stateValue) {\n    var _a;\n\n    var _this = this;\n\n    if (!stateValue) {\n      return this.initialStateValue || EMPTY_OBJECT; // TODO: type-specific properties\n    }\n\n    switch (this.type) {\n      case 'parallel':\n        return mapValues(this.initialStateValue, function (subStateValue, subStateKey) {\n          return subStateValue ? _this.getStateNode(subStateKey).resolve(stateValue[subStateKey] || subStateValue) : EMPTY_OBJECT;\n        });\n\n      case 'compound':\n        if (isString(stateValue)) {\n          var subStateNode = this.getStateNode(stateValue);\n\n          if (subStateNode.type === 'parallel' || subStateNode.type === 'compound') {\n            return _a = {}, _a[stateValue] = subStateNode.initialStateValue, _a;\n          }\n\n          return stateValue;\n        }\n\n        if (!keys(stateValue).length) {\n          return this.initialStateValue || {};\n        }\n\n        return mapValues(stateValue, function (subStateValue, subStateKey) {\n          return subStateValue ? _this.getStateNode(subStateKey).resolve(subStateValue) : EMPTY_OBJECT;\n        });\n\n      default:\n        return stateValue || EMPTY_OBJECT;\n    }\n  };\n\n  StateNode.prototype.getResolvedPath = function (stateIdentifier) {\n    if (isStateId(stateIdentifier)) {\n      var stateNode = this.machine.idMap[stateIdentifier.slice(STATE_IDENTIFIER.length)];\n\n      if (!stateNode) {\n        throw new Error(\"Unable to find state node '\" + stateIdentifier + \"'\");\n      }\n\n      return stateNode.path;\n    }\n\n    return toStatePath(stateIdentifier, this.delimiter);\n  };\n\n  Object.defineProperty(StateNode.prototype, \"initialStateValue\", {\n    get: function () {\n      var _a;\n\n      if (this.__cache.initialStateValue) {\n        return this.__cache.initialStateValue;\n      }\n\n      var initialStateValue;\n\n      if (this.type === 'parallel') {\n        initialStateValue = mapFilterValues(this.states, function (state) {\n          return state.initialStateValue || EMPTY_OBJECT;\n        }, function (stateNode) {\n          return !(stateNode.type === 'history');\n        });\n      } else if (this.initial !== undefined) {\n        if (!this.states[this.initial]) {\n          throw new Error(\"Initial state '\" + this.initial + \"' not found on '\" + this.key + \"'\");\n        }\n\n        initialStateValue = isLeafNode(this.states[this.initial]) ? this.initial : (_a = {}, _a[this.initial] = this.states[this.initial].initialStateValue, _a);\n      } else {\n        // The finite state value of a machine without child states is just an empty object\n        initialStateValue = {};\n      }\n\n      this.__cache.initialStateValue = initialStateValue;\n      return this.__cache.initialStateValue;\n    },\n    enumerable: false,\n    configurable: true\n  });\n\n  StateNode.prototype.getInitialState = function (stateValue, context) {\n    var configuration = this.getStateNodes(stateValue);\n    return this.resolveTransition({\n      configuration: configuration,\n      entrySet: configuration,\n      exitSet: [],\n      transitions: [],\n      source: undefined,\n      actions: []\n    }, undefined, undefined, context);\n  };\n\n  Object.defineProperty(StateNode.prototype, \"initialState\", {\n    /**\r\n     * The initial State instance, which includes all actions to be executed from\r\n     * entering the initial state.\r\n     */\n    get: function () {\n      this._init(); // TODO: this should be in the constructor (see note in constructor)\n\n\n      var initialStateValue = this.initialStateValue;\n\n      if (!initialStateValue) {\n        throw new Error(\"Cannot retrieve initial state from simple state '\" + this.id + \"'.\");\n      }\n\n      return this.getInitialState(initialStateValue);\n    },\n    enumerable: false,\n    configurable: true\n  });\n  Object.defineProperty(StateNode.prototype, \"target\", {\n    /**\r\n     * The target state value of the history state node, if it exists. This represents the\r\n     * default state value to transition to if no history value exists yet.\r\n     */\n    get: function () {\n      var target;\n\n      if (this.type === 'history') {\n        var historyConfig = this.config;\n\n        if (isString(historyConfig.target)) {\n          target = isStateId(historyConfig.target) ? pathToStateValue(this.machine.getStateNodeById(historyConfig.target).path.slice(this.path.length - 1)) : historyConfig.target;\n        } else {\n          target = historyConfig.target;\n        }\n      }\n\n      return target;\n    },\n    enumerable: false,\n    configurable: true\n  });\n  /**\r\n   * Returns the leaf nodes from a state path relative to this state node.\r\n   *\r\n   * @param relativeStateId The relative state path to retrieve the state nodes\r\n   * @param history The previous state to retrieve history\r\n   * @param resolve Whether state nodes should resolve to initial child state nodes\r\n   */\n\n  StateNode.prototype.getRelativeStateNodes = function (relativeStateId, historyValue, resolve) {\n    if (resolve === void 0) {\n      resolve = true;\n    }\n\n    return resolve ? relativeStateId.type === 'history' ? relativeStateId.resolveHistory(historyValue) : relativeStateId.initialStateNodes : [relativeStateId];\n  };\n\n  Object.defineProperty(StateNode.prototype, \"initialStateNodes\", {\n    get: function () {\n      var _this = this;\n\n      if (isLeafNode(this)) {\n        return [this];\n      } // Case when state node is compound but no initial state is defined\n\n\n      if (this.type === 'compound' && !this.initial) {\n        if (!IS_PRODUCTION) {\n          warn(false, \"Compound state node '\" + this.id + \"' has no initial state.\");\n        }\n\n        return [this];\n      }\n\n      var initialStateNodePaths = toStatePaths(this.initialStateValue);\n      return flatten(initialStateNodePaths.map(function (initialPath) {\n        return _this.getFromRelativePath(initialPath);\n      }));\n    },\n    enumerable: false,\n    configurable: true\n  });\n  /**\r\n   * Retrieves state nodes from a relative path to this state node.\r\n   *\r\n   * @param relativePath The relative path from this state node\r\n   * @param historyValue\r\n   */\n\n  StateNode.prototype.getFromRelativePath = function (relativePath) {\n    if (!relativePath.length) {\n      return [this];\n    }\n\n    var _a = __read(relativePath),\n        stateKey = _a[0],\n        childStatePath = _a.slice(1);\n\n    if (!this.states) {\n      throw new Error(\"Cannot retrieve subPath '\" + stateKey + \"' from node with no states\");\n    }\n\n    var childStateNode = this.getStateNode(stateKey);\n\n    if (childStateNode.type === 'history') {\n      return childStateNode.resolveHistory();\n    }\n\n    if (!this.states[stateKey]) {\n      throw new Error(\"Child state '\" + stateKey + \"' does not exist on '\" + this.id + \"'\");\n    }\n\n    return this.states[stateKey].getFromRelativePath(childStatePath);\n  };\n\n  StateNode.prototype.historyValue = function (relativeStateValue) {\n    if (!keys(this.states).length) {\n      return undefined;\n    }\n\n    return {\n      current: relativeStateValue || this.initialStateValue,\n      states: mapFilterValues(this.states, function (stateNode, key) {\n        if (!relativeStateValue) {\n          return stateNode.historyValue();\n        }\n\n        var subStateValue = isString(relativeStateValue) ? undefined : relativeStateValue[key];\n        return stateNode.historyValue(subStateValue || stateNode.initialStateValue);\n      }, function (stateNode) {\n        return !stateNode.history;\n      })\n    };\n  };\n  /**\r\n   * Resolves to the historical value(s) of the parent state node,\r\n   * represented by state nodes.\r\n   *\r\n   * @param historyValue\r\n   */\n\n\n  StateNode.prototype.resolveHistory = function (historyValue) {\n    var _this = this;\n\n    if (this.type !== 'history') {\n      return [this];\n    }\n\n    var parent = this.parent;\n\n    if (!historyValue) {\n      var historyTarget = this.target;\n      return historyTarget ? flatten(toStatePaths(historyTarget).map(function (relativeChildPath) {\n        return parent.getFromRelativePath(relativeChildPath);\n      })) : parent.initialStateNodes;\n    }\n\n    var subHistoryValue = nestedPath(parent.path, 'states')(historyValue).current;\n\n    if (isString(subHistoryValue)) {\n      return [parent.getStateNode(subHistoryValue)];\n    }\n\n    return flatten(toStatePaths(subHistoryValue).map(function (subStatePath) {\n      return _this.history === 'deep' ? parent.getFromRelativePath(subStatePath) : [parent.states[subStatePath[0]]];\n    }));\n  };\n\n  Object.defineProperty(StateNode.prototype, \"stateIds\", {\n    /**\r\n     * All the state node IDs of this state node and its descendant state nodes.\r\n     */\n    get: function () {\n      var _this = this;\n\n      var childStateIds = flatten(keys(this.states).map(function (stateKey) {\n        return _this.states[stateKey].stateIds;\n      }));\n      return [this.id].concat(childStateIds);\n    },\n    enumerable: false,\n    configurable: true\n  });\n  Object.defineProperty(StateNode.prototype, \"events\", {\n    /**\r\n     * All the event types accepted by this state node and its descendants.\r\n     */\n    get: function () {\n      var e_7, _a, e_8, _b;\n\n      if (this.__cache.events) {\n        return this.__cache.events;\n      }\n\n      var states = this.states;\n      var events = new Set(this.ownEvents);\n\n      if (states) {\n        try {\n          for (var _c = __values(keys(states)), _d = _c.next(); !_d.done; _d = _c.next()) {\n            var stateId = _d.value;\n            var state = states[stateId];\n\n            if (state.states) {\n              try {\n                for (var _e = (e_8 = void 0, __values(state.events)), _f = _e.next(); !_f.done; _f = _e.next()) {\n                  var event_1 = _f.value;\n                  events.add(\"\" + event_1);\n                }\n              } catch (e_8_1) {\n                e_8 = {\n                  error: e_8_1\n                };\n              } finally {\n                try {\n                  if (_f && !_f.done && (_b = _e.return)) _b.call(_e);\n                } finally {\n                  if (e_8) throw e_8.error;\n                }\n              }\n            }\n          }\n        } catch (e_7_1) {\n          e_7 = {\n            error: e_7_1\n          };\n        } finally {\n          try {\n            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);\n          } finally {\n            if (e_7) throw e_7.error;\n          }\n        }\n      }\n\n      return this.__cache.events = Array.from(events);\n    },\n    enumerable: false,\n    configurable: true\n  });\n  Object.defineProperty(StateNode.prototype, \"ownEvents\", {\n    /**\r\n     * All the events that have transitions directly from this state node.\r\n     *\r\n     * Excludes any inert events.\r\n     */\n    get: function () {\n      var events = new Set(this.transitions.filter(function (transition) {\n        return !(!transition.target && !transition.actions.length && transition.internal);\n      }).map(function (transition) {\n        return transition.eventType;\n      }));\n      return Array.from(events);\n    },\n    enumerable: false,\n    configurable: true\n  });\n\n  StateNode.prototype.resolveTarget = function (_target) {\n    var _this = this;\n\n    if (_target === undefined) {\n      // an undefined target signals that the state node should not transition from that state when receiving that event\n      return undefined;\n    }\n\n    return _target.map(function (target) {\n      if (!isString(target)) {\n        return target;\n      }\n\n      var isInternalTarget = target[0] === _this.delimiter; // If internal target is defined on machine,\n      // do not include machine key on target\n\n      if (isInternalTarget && !_this.parent) {\n        return _this.getStateNodeByPath(target.slice(1));\n      }\n\n      var resolvedTarget = isInternalTarget ? _this.key + target : target;\n\n      if (_this.parent) {\n        try {\n          var targetStateNode = _this.parent.getStateNodeByPath(resolvedTarget);\n\n          return targetStateNode;\n        } catch (err) {\n          throw new Error(\"Invalid transition definition for state node '\" + _this.id + \"':\\n\" + err.message);\n        }\n      } else {\n        return _this.getStateNodeByPath(resolvedTarget);\n      }\n    });\n  };\n\n  StateNode.prototype.formatTransition = function (transitionConfig) {\n    var _this = this;\n\n    var normalizedTarget = normalizeTarget(transitionConfig.target);\n    var internal = 'internal' in transitionConfig ? transitionConfig.internal : normalizedTarget ? normalizedTarget.some(function (_target) {\n      return isString(_target) && _target[0] === _this.delimiter;\n    }) : true;\n    var guards = this.machine.options.guards;\n    var target = this.resolveTarget(normalizedTarget);\n\n    var transition = __assign(__assign({}, transitionConfig), {\n      actions: toActionObjects(toArray(transitionConfig.actions)),\n      cond: toGuard(transitionConfig.cond, guards),\n      target: target,\n      source: this,\n      internal: internal,\n      eventType: transitionConfig.event,\n      toJSON: function () {\n        return __assign(__assign({}, transition), {\n          target: transition.target ? transition.target.map(function (t) {\n            return \"#\" + t.id;\n          }) : undefined,\n          source: \"#\" + _this.id\n        });\n      }\n    });\n\n    return transition;\n  };\n\n  StateNode.prototype.formatTransitions = function () {\n    var e_9, _a;\n\n    var _this = this;\n\n    var onConfig;\n\n    if (!this.config.on) {\n      onConfig = [];\n    } else if (Array.isArray(this.config.on)) {\n      onConfig = this.config.on;\n    } else {\n      var _b = this.config.on,\n          _c = WILDCARD,\n          _d = _b[_c],\n          wildcardConfigs = _d === void 0 ? [] : _d,\n          strictTransitionConfigs_1 = __rest(_b, [typeof _c === \"symbol\" ? _c : _c + \"\"]);\n\n      onConfig = flatten(keys(strictTransitionConfigs_1).map(function (key) {\n        if (!IS_PRODUCTION && key === NULL_EVENT) {\n          warn(false, \"Empty string transition configs (e.g., `{ on: { '': ... }}`) for transient transitions are deprecated. Specify the transition in the `{ always: ... }` property instead. \" + (\"Please check the `on` configuration for \\\"#\" + _this.id + \"\\\".\"));\n        }\n\n        var transitionConfigArray = toTransitionConfigArray(key, strictTransitionConfigs_1[key]);\n\n        if (!IS_PRODUCTION) {\n          validateArrayifiedTransitions(_this, key, transitionConfigArray);\n        }\n\n        return transitionConfigArray;\n      }).concat(toTransitionConfigArray(WILDCARD, wildcardConfigs)));\n    }\n\n    var eventlessConfig = this.config.always ? toTransitionConfigArray('', this.config.always) : [];\n    var doneConfig = this.config.onDone ? toTransitionConfigArray(String(done(this.id)), this.config.onDone) : [];\n\n    if (!IS_PRODUCTION) {\n      warn(!(this.config.onDone && !this.parent), \"Root nodes cannot have an \\\".onDone\\\" transition. Please check the config of \\\"\" + this.id + \"\\\".\");\n    }\n\n    var invokeConfig = flatten(this.invoke.map(function (invokeDef) {\n      var settleTransitions = [];\n\n      if (invokeDef.onDone) {\n        settleTransitions.push.apply(settleTransitions, __spreadArray([], __read(toTransitionConfigArray(String(doneInvoke(invokeDef.id)), invokeDef.onDone))));\n      }\n\n      if (invokeDef.onError) {\n        settleTransitions.push.apply(settleTransitions, __spreadArray([], __read(toTransitionConfigArray(String(error(invokeDef.id)), invokeDef.onError))));\n      }\n\n      return settleTransitions;\n    }));\n    var delayedTransitions = this.after;\n    var formattedTransitions = flatten(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(doneConfig)), __read(invokeConfig)), __read(onConfig)), __read(eventlessConfig)).map(function (transitionConfig) {\n      return toArray(transitionConfig).map(function (transition) {\n        return _this.formatTransition(transition);\n      });\n    }));\n\n    try {\n      for (var delayedTransitions_1 = __values(delayedTransitions), delayedTransitions_1_1 = delayedTransitions_1.next(); !delayedTransitions_1_1.done; delayedTransitions_1_1 = delayedTransitions_1.next()) {\n        var delayedTransition = delayedTransitions_1_1.value;\n        formattedTransitions.push(delayedTransition);\n      }\n    } catch (e_9_1) {\n      e_9 = {\n        error: e_9_1\n      };\n    } finally {\n      try {\n        if (delayedTransitions_1_1 && !delayedTransitions_1_1.done && (_a = delayedTransitions_1.return)) _a.call(delayedTransitions_1);\n      } finally {\n        if (e_9) throw e_9.error;\n      }\n    }\n\n    return formattedTransitions;\n  };\n\n  return StateNode;\n}();\n\nexport { StateNode };\n","import { StateNode } from './StateNode.js';\n\nfunction Machine(config, options, initialContext) {\n  if (initialContext === void 0) {\n    initialContext = config.context;\n  }\n\n  return new StateNode(config, options, initialContext);\n}\nfunction createMachine(config, options) {\n  return new StateNode(config, options);\n}\n\nexport { Machine, createMachine };\n","/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any */\nimport {\n  assign,\n  sendParent,\n  spawn,\n  ContextFrom,\n  EventFrom,\n  Interpreter,\n  StateMachine,\n} from \"xstate\";\nimport { createModel } from \"xstate/lib/model\";\nimport type { book, item } from \"@/types\";\nimport {\n  performListItem,\n  performCreateListItem,\n  performRemoveListItem,\n  perfermUdateListItem,\n} from \"@/utils/listItems\";\nimport { performBook } from \"@/utils/book\";\nimport { DataMachineActor, dataMachine } from \"./dataMachine\";\n\nexport type BookMachineState =\n  | {\n      value: \"loadBook\";\n      context: BookMachineContext;\n    }\n  | {\n      value: \"loadBook.book\";\n      context: BookMachineContext;\n    }\n  | {\n      value: \"loadBook.listItem\";\n      context: BookMachineContext;\n    }\n  | {\n      value: \"loadBook.failure\";\n      context: BookMachineContext;\n    }\n  | {\n      value:\n        | \"success\"\n        | \"success.pending\"\n        | \"success.unread\"\n        | \"success.read\"\n        | \"success.read.duration.unfinish\"\n        | \"success.read.duration.finish\";\n      context: BookMachineContext;\n    };\n\nconst bookModel = createModel(\n  {\n    message: undefined,\n    book: undefined as undefined | book,\n    listItem: undefined as undefined | item,\n    buttons: [] as DataMachineActor[],\n    star: undefined as undefined | DataMachineActor,\n    note: undefined as undefined | DataMachineActor,\n  },\n  {\n    events: {\n      ADD: (data: item) => ({ data }),\n      REMOVE: () => ({}),\n      FINISH: (data: item) => ({ data }),\n      UNFINISH: (data: item) => ({ data }),\n      RATE: (data: item) => ({ data }),\n      WRITE: (data: item) => ({ data }),\n    },\n  }\n);\ntype BookMachineContext = ContextFrom<typeof bookModel>;\ntype BookMachineEvents = EventFrom<typeof bookModel>;\nexport type BookMachineActor = Interpreter<\n  BookMachineContext,\n  any,\n  BookMachineEvents,\n  BookMachineState\n>;\nexport type BookState = BookMachineActor[\"state\"];\n\nexport function bookMachine({\n  book,\n  item,\n  bookId,\n}: {\n  book?: book;\n  item?: item;\n  bookId?: string;\n}): StateMachine<BookMachineContext, any, BookMachineEvents, BookMachineState> {\n  const bookIdv = (bookId || book?.id) as string;\n  const initial = book && item ? \"success\" : \"loadBook\";\n  const loadBookInitial = book ? \"listItem\" : \"book\";\n\n  return bookModel.createMachine(\n    {\n      id: \"bookMachine\",\n      initial: initial,\n      context: {\n        message: undefined,\n        book: book,\n        listItem: item,\n        buttons: [],\n        star: undefined,\n        note: undefined,\n      },\n      states: {\n        loadBook: {\n          initial: loadBookInitial,\n          states: {\n            book: {\n              invoke: {\n                src: \"performBook\",\n                onDone: { target: \"listItem\", actions: \"setBook\" },\n                onError: { target: \"failure\", actions: \"onError\" },\n              },\n            },\n            listItem: {\n              invoke: {\n                src: \"performListItem\",\n                onDone: {\n                  target: \"#bookMachine.success.pending\",\n                  actions: \"setListItem\",\n                },\n                onError: { target: \"failure\", actions: \"onError\" },\n              },\n            },\n            failure: {},\n          },\n        },\n        success: {\n          id: \"book\",\n          initial: \"pending\",\n          states: {\n            pending: {\n              entry: [\"buildAddButtons\", \"buildStar\", \"buildNote\"],\n              always: [\n                { target: \"unread\", cond: \"isUnread\" },\n                { target: \"read\", cond: \"isRead\" },\n              ],\n            },\n            unread: {\n              id: \"unread\",\n              on: { ADD: { target: \"#read\", actions: \"setListItem\" } },\n            },\n            read: {\n              entry: [\"buildRemoveFinishUnfinishButtons\"],\n              id: \"read\",\n              on: {\n                REMOVE: { target: \"#unread\", actions: \"removeListItem\" },\n              },\n              type: \"parallel\",\n              states: {\n                duration: {\n                  id: \"duration\",\n                  initial: \"pending\",\n                  states: {\n                    pending: {\n                      always: [\n                        { target: \"finish\", cond: \"isFinish\" },\n                        { target: \"unfinish\" },\n                      ],\n                    },\n                    finish: {\n                      on: {\n                        UNFINISH: {\n                          target: \"#duration.unfinish\",\n                          actions: \"setListItem\",\n                        },\n                      },\n                    },\n                    unfinish: {\n                      on: {\n                        FINISH: {\n                          target: \"#duration.finish\",\n                          actions: \"setListItem\",\n                        },\n                      },\n                    },\n                  },\n                },\n                rateStar: {\n                  on: {\n                    RATE: {\n                      target: \"rateStar\",\n                      actions: \"setListItem\",\n                    },\n                  },\n                },\n                note: {\n                  on: {\n                    WRITE: {\n                      target: \"note\",\n                      actions: \"setListItem\",\n                    },\n                  },\n                },\n              },\n            },\n          },\n        },\n      },\n    },\n    {\n      guards: {\n        isUnread(context) {\n          return context.listItem === undefined;\n        },\n        isRead(context) {\n          return context.listItem !== undefined;\n        },\n        isFinish(context) {\n          return (\n            context.listItem !== undefined &&\n            typeof context.listItem.finishDate === \"number\"\n          );\n        },\n      },\n      services: {\n        performBook(context) {\n          return performBook(bookIdv);\n        },\n        performListItem(context) {\n          return performListItem(bookIdv);\n        },\n      },\n      actions: {\n        buildNote: assign({\n          note: (context) =>\n            spawn(\n              dataMachine.withConfig({\n                services: {\n                  performRequest(ctx, event) {\n                    return perfermUdateListItem({\n                      // @ts-expect-error: no problem\n                      id: context.listItem.id,\n                      notes: event.data.notes,\n                    });\n                  },\n                },\n                actions: {\n                  sendParent: sendParent((context, event: any) => ({\n                    type: \"WRITE\",\n                    data: event.data,\n                  })),\n                },\n              }),\n              \"note\"\n            ),\n        }),\n        buildStar: assign({\n          star: (context) =>\n            spawn(\n              dataMachine.withConfig({\n                services: {\n                  performRequest(ctx, event) {\n                    return perfermUdateListItem(event.data);\n                  },\n                },\n                actions: {\n                  sendParent: sendParent((context, event: any) => ({\n                    type: \"RATE\",\n                    data: event.data,\n                  })),\n                },\n              }),\n              \"star\"\n            ),\n        }),\n        buildAddButtons: assign({\n          buttons: (context) => {\n            return [\n              //add:\n              spawn(\n                dataMachine.withConfig({\n                  services: {\n                    performRequest(ctx, event) {\n                      return performCreateListItem(bookIdv);\n                    },\n                  },\n                  actions: {\n                    sendParent: sendParent((context, event: any) => ({\n                      type: \"ADD\",\n                      data: event.data,\n                    })),\n                  },\n                }),\n                \"addBtn\"\n              ),\n            ];\n          },\n        }),\n        buildRemoveFinishUnfinishButtons: assign({\n          buttons: (context) => {\n            return [\n              ...context.buttons,\n\n              //remove:\n              spawn(\n                dataMachine.withConfig({\n                  services: {\n                    performRequest(ctx, event) {\n                      debugger;\n                      // @ts-expect-error: no problem\n                      return performRemoveListItem(context.listItem.id);\n                    },\n                  },\n                  actions: {\n                    sendParent: sendParent(\"REMOVE\"),\n                  },\n                }),\n                \"removeBtn\"\n              ),\n\n              // finish:\n              spawn(\n                dataMachine.withConfig({\n                  services: {\n                    performRequest(ctx, event) {\n                      return perfermUdateListItem({\n                        // @ts-expect-error: no problem\n                        id: context.listItem.id,\n                        finishDate: Date.now(),\n                      });\n                    },\n                  },\n                  actions: {\n                    sendParent: sendParent((context, event: any) => ({\n                      type: \"FINISH\",\n                      data: event.data,\n                    })),\n                  },\n                }),\n                \"finishBtn\"\n              ),\n\n              // unfinish\n              spawn(\n                dataMachine.withConfig({\n                  services: {\n                    performRequest(ctx, event) {\n                      console.log(\"finish\");\n                      return perfermUdateListItem({\n                        // @ts-expect-error: no problem\n                        id: context.listItem.id,\n                        finishDate: null,\n                      });\n                    },\n                  },\n                  actions: {\n                    sendParent: sendParent((context, event: any) => ({\n                      type: \"UNFINISH\",\n                      data: event.data,\n                    })),\n                  },\n                }),\n                \"unfinishBtn\"\n              ),\n            ];\n          },\n        }),\n        setBook: assign({\n          book: (context, event: any) => {\n            return event.data;\n          },\n        }),\n        setListItem: assign({\n          listItem: (context, event: any) => {\n            return event.data;\n          },\n        }),\n        removeListItem: assign({\n          listItem: (context, event: any) => {\n            return undefined;\n          },\n        }),\n        onError: assign({\n          message: (context, event: any) => {\n            return event.data.message;\n          },\n        }),\n        clearError: assign({\n          message: (context, event: any) => {\n            return undefined;\n          },\n        }),\n      },\n    }\n  );\n}\n","var __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nimport { interpret, State } from 'xstate';\nimport { onBeforeUnmount, onMounted } from 'vue';\n// copied from core/src/utils.ts\n// it avoids a breaking change between this package and XState which is its peer dep\nfunction toObserver(nextHandler, errorHandler, completionHandler) {\n    if (typeof nextHandler === 'object') {\n        return nextHandler;\n    }\n    var noop = function () { return void 0; };\n    return {\n        next: nextHandler,\n        error: errorHandler || noop,\n        complete: completionHandler || noop\n    };\n}\nexport function useInterpret(getMachine, options, observerOrListener) {\n    if (options === void 0) { options = {}; }\n    var machine = typeof getMachine === 'function' ? getMachine() : getMachine;\n    var context = options.context, guards = options.guards, actions = options.actions, activities = options.activities, services = options.services, delays = options.delays, rehydratedState = options.state, interpreterOptions = __rest(options, [\"context\", \"guards\", \"actions\", \"activities\", \"services\", \"delays\", \"state\"]);\n    var machineConfig = {\n        context: context,\n        guards: guards,\n        actions: actions,\n        activities: activities,\n        services: services,\n        delays: delays\n    };\n    var machineWithConfig = machine.withConfig(machineConfig, __assign(__assign({}, machine.context), context));\n    var service = interpret(machineWithConfig, interpreterOptions).start(rehydratedState ? State.create(rehydratedState) : undefined);\n    var sub;\n    onMounted(function () {\n        if (observerOrListener) {\n            sub = service.subscribe(toObserver(observerOrListener));\n        }\n    });\n    onBeforeUnmount(function () {\n        service.stop();\n        sub === null || sub === void 0 ? void 0 : sub.unsubscribe();\n    });\n    return service;\n}\n","import { shallowRef } from 'vue';\nimport { State } from 'xstate';\nimport { useInterpret } from './useInterpret';\nexport function useMachine(getMachine, options) {\n    if (options === void 0) { options = {}; }\n    var service = useInterpret(getMachine, options, listener);\n    var initialState = service.machine.initialState;\n    var state = shallowRef((options.state ? State.create(options.state) : initialState));\n    function listener(nextState) {\n        // Only change the current state if:\n        // - the incoming state is the \"live\" initial state (since it might have new actors)\n        // - OR the incoming state actually changed.\n        //\n        // The \"live\" initial state will have .changed === undefined.\n        var initialStateChanged = nextState.changed === undefined && Object.keys(nextState.children).length;\n        if (nextState.changed || initialStateChanged) {\n            state.value = nextState;\n        }\n    }\n    return { state: state, send: service.send, service: service };\n}\n","/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any */\nimport { createMachine, assign, ActorRefWithDeprecatedState } from \"xstate\";\n\nexport type DataMachineEvents = { type: \"CLICK\"; data?: any };\nexport interface DataMachineContext {\n  message?: string;\n  result: any[];\n}\n\ntype DataMachineState =\n  | {\n      value: \"idle\";\n      context: DataMachineContext;\n    }\n  | {\n      value: \"loading\";\n      context: DataMachineContext;\n    }\n  | {\n      value: \"failure\";\n      context: DataMachineContext;\n    }\n  | {\n      value: \"success\";\n      context: DataMachineContext;\n    };\n\nexport type DataMachineActor = ActorRefWithDeprecatedState<\n  DataMachineContext,\n  DataMachineEvents,\n  DataMachineState\n>;\nexport const dataMachine = createMachine<\n  DataMachineContext,\n  DataMachineEvents,\n  DataMachineState\n>(\n  {\n    id: \"dataMachine\",\n    context: {\n      message: undefined,\n      result: [],\n    },\n    initial: \"idle\",\n    states: {\n      idle: {\n        on: { CLICK: \"loading\" },\n      },\n      loading: {\n        invoke: {\n          src: \"performRequest\",\n          onDone: { target: \"success\", actions: \"onDone\" },\n          onError: { target: \"failure\", actions: \"onError\" },\n        },\n      },\n      failure: {\n        on: { CLICK: \"loading\" },\n        onExit: \"clearError\",\n      },\n      success: {\n        on: { CLICK: \"loading\" },\n        entry: \"sendParent\",\n      },\n    },\n  },\n  {\n    actions: {\n      onError: assign({\n        message: (context, event: any) => {\n          return event.data.message;\n        },\n      }),\n      // xstate complain about no those functon, those functions are overwritten by function in wichConfig\n      onDone: assign({}),\n      clearError: assign({}),\n      sendParent: assign({}),\n    },\n  }\n);\n","<template>\n  <div class=\"tooltip\">\n    <tooltip-button\n      class=\"button\"\n      icon=\"el-icon-close\"\n      label=\"Remove from list\"\n      :state=\"btn.btnState.removeState\"\n      :clickHandler=\"btn.evtFun.remove\"\n      v-if=\"showRemoveBtn\"\n    />\n    <tooltip-button\n      class=\"button\"\n      icon=\"el-icon-circle-plus\"\n      label=\"Add to list\"\n      :state=\"btn.btnState.createState\"\n      :clickHandler=\"btn.evtFun.create\"\n      v-if=\"showAddBtn\"\n    />\n    <tooltip-button\n      class=\"button\"\n      icon=\"el-icon-notebook-1\"\n      label=\"Mark as unfinish\"\n      :state=\"btn.btnState.unfinishState\"\n      :clickHandler=\"btn.evtFun.unfinish\"\n      v-if=\"showUnfinBtn\"\n    >\n    </tooltip-button>\n    <tooltip-button\n      class=\"button\"\n      icon=\"el-icon-check\"\n      label=\"MarK as finish\"\n      :state=\"btn.btnState.finishState\"\n      :clickHandler=\"btn.evtFun.finish\"\n      v-if=\"showFinBtn\"\n    />\n  </div>\n</template>\n\n<script lang=\"ts\">\nimport { computed, defineComponent, PropType } from \"vue\";\nimport TooltipButton from \"@/components/TooltipButton.vue\";\nimport { useActor } from \"@xstate/vue\";\nimport { DataMachineActor } from \"@/machines/dataMachine\";\nimport { BookState } from \"@/machines/bookMachine\";\n\nexport default defineComponent({\n  props: {\n    buttonsRef: {\n      type: Object as PropType<DataMachineActor[]>,\n      required: true,\n    },\n    bookState: {\n      type: Object as PropType<BookState>,\n      required: true,\n    },\n  },\n  setup(props) {\n    const btn = computed(function btnState() {\n      const buttons = props.buttonsRef.map((ref) => useActor(ref));\n      const [createState, removeState, finishState, unfinishState] =\n        buttons.map((btn) => ({\n          isLoading: computed(() => btn.state.value.matches(\"loading\")),\n          isError: computed(() => btn.state.value.matches(\"failure\")),\n          error: computed(() => btn.state.value.context?.message),\n        }));\n\n      const [create, remove, finish, unfinish] = buttons.map(\n        (btn) => () => btn.send({ type: \"CLICK\" })\n      );\n      return {\n        btnState: { createState, removeState, finishState, unfinishState },\n        evtFun: { create, remove, finish, unfinish },\n      };\n    });\n\n    // when to show\n    // const showBtns = computed(() => props.bookState.matches(\"success\"));\n    const showAddBtn = computed(() =>\n      props.bookState.matches(\"success.unread\")\n    );\n    const showRemoveBtn = computed(() =>\n      props.bookState.matches(\"success.read\")\n    );\n    const showFinBtn = computed(() =>\n      props.bookState.matches(\"success.read.duration.unfinish\")\n    );\n    const showUnfinBtn = computed(() =>\n      props.bookState.matches(\"success.read.duration.finish\")\n    );\n    return {\n      showAddBtn,\n      showRemoveBtn,\n      showFinBtn,\n      showUnfinBtn,\n      btn,\n    };\n  },\n  components: {\n    TooltipButton,\n  },\n});\n</script>\n\n<style scoped>\n.tooltip {\n  display: flex;\n  flex-direction: column;\n  justify-content: space-evenly;\n  align-items: center;\n  margin-left: -15px;\n  height: 100%;\n}\n</style>\n","export default function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}","export default function _iterableToArrayLimit(arr, i) {\n  var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n\n  var _s, _e;\n\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}","export default function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}","import arrayWithHoles from \"./arrayWithHoles.js\";\nimport iterableToArrayLimit from \"./iterableToArrayLimit.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableRest from \"./nonIterableRest.js\";\nexport default function _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}","<template>\n  <el-tooltip\n    :content=\"isError ? error : label\"\n    placement=\"bottom\"\n    effect=\"light\"\n    :model-value=\"isError ? true : null\"\n    :manual=\"isError\"\n  >\n    <div>\n      <el-button\n        class=\"button\"\n        native-type=\"button\"\n        :aria-label=\"isError ? `${label} ${error}` : label\"\n        size=\"mini\"\n        circle\n        @click.prevent.stop=\"clickHandler\"\n        :disabled=\"isLoading\"\n      >\n        <!-- optimisticUpdate  -->\n        <i class=\"el-icon-loading\" aria-label=\"loading\" v-if=\"isLoading\" />\n        <i :class=\"icon\" v-else />\n        <!-- <i :class=\"icon\"  /> -->\n      </el-button>\n    </div>\n  </el-tooltip>\n</template>\n\n<script lang=\"ts\">\nimport { defineComponent } from \"vue\";\n\nexport default defineComponent({\n  props: {\n    label: String,\n    clickHandler: { type: Function, required: true },\n    icon: { type: String, required: true },\n    state: { type: Object, required: true },\n  },\n  setup(props) {\n    return {\n      isLoading: props.state.isLoading,\n      isError: props.state.isError,\n      error: props.state.error,\n    };\n  },\n});\n</script>\n\n<style lang=\"scss\" scoped></style>\n","\nimport { defineComponent } from \"vue\";\n\nexport default defineComponent({\n  props: {\n    label: String,\n    clickHandler: { type: Function, required: true },\n    icon: { type: String, required: true },\n    state: { type: Object, required: true },\n  },\n  setup(props) {\n    return {\n      isLoading: props.state.isLoading,\n      isError: props.state.isError,\n      error: props.state.error,\n    };\n  },\n});\n","import { render } from \"./TooltipButton.vue?vue&type=template&id=2dde8136\"\nimport script from \"./TooltipButton.vue?vue&type=script&lang=ts\"\nexport * from \"./TooltipButton.vue?vue&type=script&lang=ts\"\nscript.render = render\n\nexport default script","\nimport { computed, defineComponent, PropType } from \"vue\";\nimport TooltipButton from \"@/components/TooltipButton.vue\";\nimport { useActor } from \"@xstate/vue\";\nimport { DataMachineActor } from \"@/machines/dataMachine\";\nimport { BookState } from \"@/machines/bookMachine\";\n\nexport default defineComponent({\n  props: {\n    buttonsRef: {\n      type: Object as PropType<DataMachineActor[]>,\n      required: true,\n    },\n    bookState: {\n      type: Object as PropType<BookState>,\n      required: true,\n    },\n  },\n  setup(props) {\n    const btn = computed(function btnState() {\n      const buttons = props.buttonsRef.map((ref) => useActor(ref));\n      const [createState, removeState, finishState, unfinishState] =\n        buttons.map((btn) => ({\n          isLoading: computed(() => btn.state.value.matches(\"loading\")),\n          isError: computed(() => btn.state.value.matches(\"failure\")),\n          error: computed(() => btn.state.value.context?.message),\n        }));\n\n      const [create, remove, finish, unfinish] = buttons.map(\n        (btn) => () => btn.send({ type: \"CLICK\" })\n      );\n      return {\n        btnState: { createState, removeState, finishState, unfinishState },\n        evtFun: { create, remove, finish, unfinish },\n      };\n    });\n\n    // when to show\n    // const showBtns = computed(() => props.bookState.matches(\"success\"));\n    const showAddBtn = computed(() =>\n      props.bookState.matches(\"success.unread\")\n    );\n    const showRemoveBtn = computed(() =>\n      props.bookState.matches(\"success.read\")\n    );\n    const showFinBtn = computed(() =>\n      props.bookState.matches(\"success.read.duration.unfinish\")\n    );\n    const showUnfinBtn = computed(() =>\n      props.bookState.matches(\"success.read.duration.finish\")\n    );\n    return {\n      showAddBtn,\n      showRemoveBtn,\n      showFinBtn,\n      showUnfinBtn,\n      btn,\n    };\n  },\n  components: {\n    TooltipButton,\n  },\n});\n","import { render } from \"./TooltipStatus.vue?vue&type=template&id=0ea53b20&scoped=true\"\nimport script from \"./TooltipStatus.vue?vue&type=script&lang=ts\"\nexport * from \"./TooltipStatus.vue?vue&type=script&lang=ts\"\n\nimport \"./TooltipStatus.vue?vue&type=style&index=0&id=0ea53b20&scoped=true&lang=css\"\nscript.render = render\nscript.__scopeId = \"data-v-0ea53b20\"\n\nexport default script","export * from \"-!../../node_modules/mini-css-extract-plugin/dist/loader.js??ref--6-oneOf-1-0!../../node_modules/css-loader/dist/cjs.js??ref--6-oneOf-1-1!../../node_modules/vue-loader-v16/dist/stylePostLoader.js!../../node_modules/postcss-loader/src/index.js??ref--6-oneOf-1-2!../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../node_modules/vue-loader-v16/dist/index.js??ref--0-1!./TooltipStatus.vue?vue&type=style&index=0&id=0ea53b20&scoped=true&lang=css\"","/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\nimport { useClient } from \"@/utils/client\";\nimport { isBookData, isBooksData } from \"@/type-guards\";\nimport { areYouABadBody } from \"@/utils/client\";\nimport type { HttpError, book } from \"@/types\";\nimport { queryClient } from \"@/utils/QueryClient\";\n\nexport function performBook(bookId: string) {\n  const client = useClient();\n\n  const data = queryClient.fetchQuery<book, HttpError>(\n    [\"book\", { bookId }],\n    () =>\n      client(`books/${bookId}`)\n        .then(areYouABadBody(isBookData))\n        .then((data) => data.book)\n    // { initialData: loadingBook }\n  );\n  return data;\n}\n\nexport const bookSearchFunction = function bookSearchFunction(query: string) {\n  const client = useClient();\n  return () =>\n    client(`books?query=${encodeURIComponent(query)}`)\n      .then(areYouABadBody(isBooksData))\n      .then((data) => data.books);\n};\n\nexport function bookSearch(query: string) {\n  const result = queryClient.fetchQuery<book[], HttpError>({\n    queryKey: \"bookSearchh\",\n    queryFn: bookSearchFunction(query),\n  });\n  return result;\n}\n// update cache. remove the book in read list\nexport function refetchBookSearch(): void {\n  queryClient.removeQueries(\"bookSearch\", { exact: true });\n  queryClient.prefetchQuery(\"bookSearch\", bookSearchFunction(\"\"));\n}\n","import { getCurrentInstance, inject, provide, onUnmounted, reactive, watchEffect, toRefs, readonly, set, watch, ref } from 'vue-demi';\n\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nfunction _inheritsLoose(subClass, superClass) {\n  subClass.prototype = Object.create(superClass.prototype);\n  subClass.prototype.constructor = subClass;\n  _setPrototypeOf(subClass, superClass);\n}\n\nvar Subscribable = /*#__PURE__*/function () {\n  function Subscribable() {\n    this.listeners = [];\n  }\n\n  var _proto = Subscribable.prototype;\n\n  _proto.subscribe = function subscribe(listener) {\n    var _this = this;\n\n    var callback = listener || function () {\n      return undefined;\n    };\n\n    this.listeners.push(callback);\n    this.onSubscribe();\n    return function () {\n      _this.listeners = _this.listeners.filter(function (x) {\n        return x !== callback;\n      });\n\n      _this.onUnsubscribe();\n    };\n  };\n\n  _proto.hasListeners = function hasListeners() {\n    return this.listeners.length > 0;\n  };\n\n  _proto.onSubscribe = function onSubscribe() {// Do nothing\n  };\n\n  _proto.onUnsubscribe = function onUnsubscribe() {// Do nothing\n  };\n\n  return Subscribable;\n}();\n\nfunction _extends() {\n  _extends = Object.assign || function (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n\n      for (var key in source) {\n        if (Object.prototype.hasOwnProperty.call(source, key)) {\n          target[key] = source[key];\n        }\n      }\n    }\n\n    return target;\n  };\n\n  return _extends.apply(this, arguments);\n}\n\n// TYPES\n// UTILS\nvar isServer = typeof window === 'undefined';\nfunction noop() {\n  return undefined;\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 ensureQueryKeyArray(value) {\n  return Array.isArray(value) ? value : [value];\n}\nfunction difference(array1, array2) {\n  return array1.filter(function (x) {\n    return array2.indexOf(x) === -1;\n  });\n}\nfunction replaceAt(array, index, value) {\n  var copy = array.slice(0);\n  copy[index] = value;\n  return copy;\n}\nfunction timeUntilStale(updatedAt, staleTime) {\n  return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0);\n}\nfunction parseQueryArgs$1(arg1, arg2, arg3) {\n  if (!isQueryKey$1(arg1)) {\n    return arg1;\n  }\n\n  if (typeof arg2 === 'function') {\n    return _extends({}, arg3, {\n      queryKey: arg1,\n      queryFn: arg2\n    });\n  }\n\n  return _extends({}, arg2, {\n    queryKey: arg1\n  });\n}\nfunction parseFilterArgs$1(arg1, arg2, arg3) {\n  return isQueryKey$1(arg1) ? [_extends({}, arg2, {\n    queryKey: arg1\n  }), arg3] : [arg1 || {}, arg2];\n}\nfunction matchQuery(filters, query) {\n  var active = filters.active,\n      exact = filters.exact,\n      fetching = filters.fetching,\n      inactive = filters.inactive,\n      predicate = filters.predicate,\n      queryKey = filters.queryKey,\n      stale = filters.stale;\n\n  if (isQueryKey$1(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\n  var isActive;\n\n  if (inactive === false || active && !inactive) {\n    isActive = true;\n  } else if (active === false || inactive && !active) {\n    isActive = false;\n  }\n\n  if (typeof isActive === 'boolean' && query.isActive() !== isActive) {\n    return false;\n  }\n\n  if (typeof stale === 'boolean' && query.isStale() !== stale) {\n    return false;\n  }\n\n  if (typeof fetching === 'boolean' && query.isFetching() !== fetching) {\n    return false;\n  }\n\n  if (predicate && !predicate(query)) {\n    return false;\n  }\n\n  return true;\n}\nfunction matchMutation(filters, mutation) {\n  var exact = filters.exact,\n      fetching = filters.fetching,\n      predicate = filters.predicate,\n      mutationKey = filters.mutationKey;\n\n  if (isQueryKey$1(mutationKey)) {\n    if (!mutation.options.mutationKey) {\n      return false;\n    }\n\n    if (exact) {\n      if (hashQueryKey(mutation.options.mutationKey) !== hashQueryKey(mutationKey)) {\n        return false;\n      }\n    } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) {\n      return false;\n    }\n  }\n\n  if (typeof fetching === 'boolean' && mutation.state.status === 'loading' !== fetching) {\n    return false;\n  }\n\n  if (predicate && !predicate(mutation)) {\n    return false;\n  }\n\n  return true;\n}\nfunction hashQueryKeyByOptions(queryKey, options) {\n  var hashFn = (options == null ? void 0 : options.queryKeyHashFn) || hashQueryKey;\n  return hashFn(queryKey);\n}\n/**\n * Default query keys hash function.\n */\n\nfunction hashQueryKey(queryKey) {\n  var asArray = ensureQueryKeyArray(queryKey);\n  return stableValueHash(asArray);\n}\n/**\n * Hashes the value into a stable hash.\n */\n\nfunction stableValueHash(value) {\n  return JSON.stringify(value, function (_, val) {\n    return isPlainObject(val) ? Object.keys(val).sort().reduce(function (result, key) {\n      result[key] = val[key];\n      return result;\n    }, {}) : val;\n  });\n}\n/**\n * Checks if key `b` partially matches with key `a`.\n */\n\nfunction partialMatchKey(a, b) {\n  return partialDeepEqual(ensureQueryKeyArray(a), ensureQueryKeyArray(b));\n}\n/**\n * Checks if `b` partially matches with `a`.\n */\n\nfunction partialDeepEqual(a, b) {\n  if (a === b) {\n    return true;\n  }\n\n  if (typeof a !== typeof b) {\n    return false;\n  }\n\n  if (a && b && typeof a === 'object' && typeof b === 'object') {\n    return !Object.keys(b).some(function (key) {\n      return !partialDeepEqual(a[key], b[key]);\n    });\n  }\n\n  return false;\n}\n/**\n * This function returns `a` if `b` is deeply equal.\n * If not, it will replace any deeply equal children of `b` with those of `a`.\n * This can be used for structural sharing between JSON values for example.\n */\n\nfunction replaceEqualDeep(a, b) {\n  if (a === b) {\n    return a;\n  }\n\n  var array = Array.isArray(a) && Array.isArray(b);\n\n  if (array || isPlainObject(a) && isPlainObject(b)) {\n    var aSize = array ? a.length : Object.keys(a).length;\n    var bItems = array ? b : Object.keys(b);\n    var bSize = bItems.length;\n    var copy = array ? [] : {};\n    var equalItems = 0;\n\n    for (var i = 0; i < bSize; i++) {\n      var key = array ? i : bItems[i];\n      copy[key] = replaceEqualDeep(a[key], b[key]);\n\n      if (copy[key] === a[key]) {\n        equalItems++;\n      }\n    }\n\n    return aSize === bSize && equalItems === aSize ? a : copy;\n  }\n\n  return b;\n}\n/**\n * Shallow compare objects. Only works with objects that always have the same properties.\n */\n\nfunction shallowEqualObjects(a, b) {\n  if (a && !b || b && !a) {\n    return false;\n  }\n\n  for (var key in a) {\n    if (a[key] !== b[key]) {\n      return false;\n    }\n  }\n\n  return true;\n} // Copied from: https://github.com/jonschlinkert/is-plain-object\n\nfunction isPlainObject(o) {\n  if (!hasObjectPrototype(o)) {\n    return false;\n  } // If has modified constructor\n\n\n  var ctor = o.constructor;\n\n  if (typeof ctor === 'undefined') {\n    return true;\n  } // If has modified prototype\n\n\n  var prot = ctor.prototype;\n\n  if (!hasObjectPrototype(prot)) {\n    return false;\n  } // If constructor does not have an Object-specific method\n\n\n  if (!prot.hasOwnProperty('isPrototypeOf')) {\n    return false;\n  } // Most likely a plain Object\n\n\n  return true;\n}\n\nfunction hasObjectPrototype(o) {\n  return Object.prototype.toString.call(o) === '[object Object]';\n}\n\nfunction isQueryKey$1(value) {\n  return typeof value === 'string' || Array.isArray(value);\n}\nfunction sleep(timeout) {\n  return new Promise(function (resolve) {\n    setTimeout(resolve, timeout);\n  });\n}\n/**\n * Schedules a microtask.\n * This can be useful to schedule state updates after rendering.\n */\n\nfunction scheduleMicrotask(callback) {\n  Promise.resolve().then(callback).catch(function (error) {\n    return setTimeout(function () {\n      throw error;\n    });\n  });\n}\n\nvar FocusManager = /*#__PURE__*/function (_Subscribable) {\n  _inheritsLoose(FocusManager, _Subscribable);\n\n  function FocusManager() {\n    return _Subscribable.apply(this, arguments) || this;\n  }\n\n  var _proto = FocusManager.prototype;\n\n  _proto.onSubscribe = function onSubscribe() {\n    if (!this.removeEventListener) {\n      this.setDefaultEventListener();\n    }\n  };\n\n  _proto.setEventListener = function setEventListener(setup) {\n    var _this = this;\n\n    if (this.removeEventListener) {\n      this.removeEventListener();\n    }\n\n    this.removeEventListener = setup(function (focused) {\n      if (typeof focused === 'boolean') {\n        _this.setFocused(focused);\n      } else {\n        _this.onFocus();\n      }\n    });\n  };\n\n  _proto.setFocused = function setFocused(focused) {\n    this.focused = focused;\n\n    if (focused) {\n      this.onFocus();\n    }\n  };\n\n  _proto.onFocus = function onFocus() {\n    this.listeners.forEach(function (listener) {\n      listener();\n    });\n  };\n\n  _proto.isFocused = function isFocused() {\n    if (typeof this.focused === 'boolean') {\n      return this.focused;\n    } // document global can be unavailable in react native\n\n\n    if (typeof document === 'undefined') {\n      return true;\n    }\n\n    return [undefined, 'visible', 'prerender'].includes(document.visibilityState);\n  };\n\n  _proto.setDefaultEventListener = function setDefaultEventListener() {\n    var _window;\n\n    if (!isServer && ((_window = window) == null ? void 0 : _window.addEventListener)) {\n      this.setEventListener(function (onFocus) {\n        var listener = function listener() {\n          return onFocus();\n        }; // Listen to visibillitychange and focus\n\n\n        window.addEventListener('visibilitychange', listener, false);\n        window.addEventListener('focus', listener, false);\n        return function () {\n          // Be sure to unsubscribe if a new handler is set\n          window.removeEventListener('visibilitychange', listener);\n          window.removeEventListener('focus', listener);\n        };\n      });\n    }\n  };\n\n  return FocusManager;\n}(Subscribable);\n\nvar focusManager = new FocusManager();\n\nvar OnlineManager = /*#__PURE__*/function (_Subscribable) {\n  _inheritsLoose(OnlineManager, _Subscribable);\n\n  function OnlineManager() {\n    return _Subscribable.apply(this, arguments) || this;\n  }\n\n  var _proto = OnlineManager.prototype;\n\n  _proto.onSubscribe = function onSubscribe() {\n    if (!this.removeEventListener) {\n      this.setDefaultEventListener();\n    }\n  };\n\n  _proto.setEventListener = function setEventListener(setup) {\n    var _this = this;\n\n    if (this.removeEventListener) {\n      this.removeEventListener();\n    }\n\n    this.removeEventListener = setup(function (online) {\n      if (typeof online === 'boolean') {\n        _this.setOnline(online);\n      } else {\n        _this.onOnline();\n      }\n    });\n  };\n\n  _proto.setOnline = function setOnline(online) {\n    this.online = online;\n\n    if (online) {\n      this.onOnline();\n    }\n  };\n\n  _proto.onOnline = function onOnline() {\n    this.listeners.forEach(function (listener) {\n      listener();\n    });\n  };\n\n  _proto.isOnline = function isOnline() {\n    if (typeof this.online === 'boolean') {\n      return this.online;\n    }\n\n    if (typeof navigator === 'undefined' || typeof navigator.onLine === 'undefined') {\n      return true;\n    }\n\n    return navigator.onLine;\n  };\n\n  _proto.setDefaultEventListener = function setDefaultEventListener() {\n    var _window;\n\n    if (!isServer && ((_window = window) == null ? void 0 : _window.addEventListener)) {\n      this.setEventListener(function (onOnline) {\n        var listener = function listener() {\n          return onOnline();\n        }; // Listen to online\n\n\n        window.addEventListener('online', listener, false);\n        window.addEventListener('offline', listener, false);\n        return function () {\n          // Be sure to unsubscribe if a new handler is set\n          window.removeEventListener('online', listener);\n          window.removeEventListener('offline', listener);\n        };\n      });\n    }\n  };\n\n  return OnlineManager;\n}(Subscribable);\n\nvar onlineManager = new OnlineManager();\n\nfunction defaultRetryDelay(failureCount) {\n  return Math.min(1000 * Math.pow(2, failureCount), 30000);\n}\n\nfunction isCancelable(value) {\n  return typeof (value == null ? void 0 : value.cancel) === 'function';\n}\nvar CancelledError = function CancelledError(options) {\n  this.revert = options == null ? void 0 : options.revert;\n  this.silent = options == null ? void 0 : options.silent;\n};\nfunction isCancelledError(value) {\n  return value instanceof CancelledError;\n} // CLASS\n\nvar Retryer = function Retryer(config) {\n  var _this = this;\n\n  var cancelRetry = false;\n  var cancelFn;\n  var continueFn;\n  var promiseResolve;\n  var promiseReject;\n\n  this.cancel = function (cancelOptions) {\n    return cancelFn == null ? void 0 : cancelFn(cancelOptions);\n  };\n\n  this.cancelRetry = function () {\n    cancelRetry = true;\n  };\n\n  this.continue = function () {\n    return continueFn == null ? void 0 : continueFn();\n  };\n\n  this.failureCount = 0;\n  this.isPaused = false;\n  this.isResolved = false;\n  this.isTransportCancelable = false;\n  this.promise = new Promise(function (outerResolve, outerReject) {\n    promiseResolve = outerResolve;\n    promiseReject = outerReject;\n  });\n\n  var resolve = function resolve(value) {\n    if (!_this.isResolved) {\n      _this.isResolved = true;\n      config.onSuccess == null ? void 0 : config.onSuccess(value);\n      continueFn == null ? void 0 : continueFn();\n      promiseResolve(value);\n    }\n  };\n\n  var reject = function reject(value) {\n    if (!_this.isResolved) {\n      _this.isResolved = true;\n      config.onError == null ? void 0 : config.onError(value);\n      continueFn == null ? void 0 : continueFn();\n      promiseReject(value);\n    }\n  };\n\n  var pause = function pause() {\n    return new Promise(function (continueResolve) {\n      continueFn = continueResolve;\n      _this.isPaused = true;\n      config.onPause == null ? void 0 : config.onPause();\n    }).then(function () {\n      continueFn = undefined;\n      _this.isPaused = false;\n      config.onContinue == null ? void 0 : config.onContinue();\n    });\n  }; // Create loop function\n\n\n  var run = function run() {\n    // Do nothing if already resolved\n    if (_this.isResolved) {\n      return;\n    }\n\n    var promiseOrValue; // Execute query\n\n    try {\n      promiseOrValue = config.fn();\n    } catch (error) {\n      promiseOrValue = Promise.reject(error);\n    } // Create callback to cancel this fetch\n\n\n    cancelFn = function cancelFn(cancelOptions) {\n      if (!_this.isResolved) {\n        reject(new CancelledError(cancelOptions)); // Cancel transport if supported\n\n        if (isCancelable(promiseOrValue)) {\n          try {\n            promiseOrValue.cancel();\n          } catch (_unused) {}\n        }\n      }\n    }; // Check if the transport layer support cancellation\n\n\n    _this.isTransportCancelable = isCancelable(promiseOrValue);\n    Promise.resolve(promiseOrValue).then(resolve).catch(function (error) {\n      var _config$retry, _config$retryDelay;\n\n      // Stop if the fetch is already resolved\n      if (_this.isResolved) {\n        return;\n      } // Do we need to retry the request?\n\n\n      var retry = (_config$retry = config.retry) != null ? _config$retry : 3;\n      var retryDelay = (_config$retryDelay = config.retryDelay) != null ? _config$retryDelay : defaultRetryDelay;\n      var delay = typeof retryDelay === 'function' ? retryDelay(_this.failureCount, error) : retryDelay;\n      var shouldRetry = retry === true || typeof retry === 'number' && _this.failureCount < retry || typeof retry === 'function' && retry(_this.failureCount, error);\n\n      if (cancelRetry || !shouldRetry) {\n        // We are done if the query does not need to be retried\n        reject(error);\n        return;\n      }\n\n      _this.failureCount++; // Notify on fail\n\n      config.onFail == null ? void 0 : config.onFail(_this.failureCount, error); // Delay\n\n      sleep(delay) // Pause if the document is not visible or when the device is offline\n      .then(function () {\n        if (!focusManager.isFocused() || !onlineManager.isOnline()) {\n          return pause();\n        }\n      }).then(function () {\n        if (cancelRetry) {\n          reject(error);\n        } else {\n          run();\n        }\n      });\n    });\n  }; // Start loop\n\n\n  run();\n};\n\n// CLASS\nvar NotifyManager = /*#__PURE__*/function () {\n  function NotifyManager() {\n    this.queue = [];\n    this.transactions = 0;\n\n    this.notifyFn = function (callback) {\n      callback();\n    };\n\n    this.batchNotifyFn = function (callback) {\n      callback();\n    };\n  }\n\n  var _proto = NotifyManager.prototype;\n\n  _proto.batch = function batch(callback) {\n    this.transactions++;\n    var result = callback();\n    this.transactions--;\n\n    if (!this.transactions) {\n      this.flush();\n    }\n\n    return result;\n  };\n\n  _proto.schedule = function schedule(callback) {\n    var _this = this;\n\n    if (this.transactions) {\n      this.queue.push(callback);\n    } else {\n      scheduleMicrotask(function () {\n        _this.notifyFn(callback);\n      });\n    }\n  }\n  /**\n   * All calls to the wrapped function will be batched.\n   */\n  ;\n\n  _proto.batchCalls = function batchCalls(callback) {\n    var _this2 = this;\n\n    return function () {\n      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n        args[_key] = arguments[_key];\n      }\n\n      _this2.schedule(function () {\n        callback.apply(void 0, args);\n      });\n    };\n  };\n\n  _proto.flush = function flush() {\n    var _this3 = this;\n\n    var queue = this.queue;\n    this.queue = [];\n\n    if (queue.length) {\n      scheduleMicrotask(function () {\n        _this3.batchNotifyFn(function () {\n          queue.forEach(function (callback) {\n            _this3.notifyFn(callback);\n          });\n        });\n      });\n    }\n  }\n  /**\n   * Use this method to set a custom notify function.\n   * This can be used to for example wrap notifications with `React.act` while running tests.\n   */\n  ;\n\n  _proto.setNotifyFunction = function setNotifyFunction(fn) {\n    this.notifyFn = fn;\n  }\n  /**\n   * Use this method to set a custom function to batch notifications together into a single tick.\n   * By default React Query will use the batch function provided by ReactDOM or React Native.\n   */\n  ;\n\n  _proto.setBatchNotifyFunction = function setBatchNotifyFunction(fn) {\n    this.batchNotifyFn = fn;\n  };\n\n  return NotifyManager;\n}(); // SINGLETON\n\n\nvar notifyManager = new NotifyManager();\n\n// FUNCTIONS\nvar logger = console || {\n  error: noop,\n  warn: noop,\n  log: noop\n};\nfunction getLogger() {\n  return logger;\n}\n\n// CLASS\nvar Query = /*#__PURE__*/function () {\n  function Query(config) {\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 || this.getDefaultState(this.options);\n    this.state = this.initialState;\n    this.scheduleGc();\n  }\n\n  var _proto = Query.prototype;\n\n  _proto.setOptions = function setOptions(options) {\n    var _this$options$cacheTi;\n\n    this.options = _extends({}, this.defaultOptions, options); // Default to 5 minutes if not cache time is set\n\n    this.cacheTime = Math.max(this.cacheTime || 0, (_this$options$cacheTi = this.options.cacheTime) != null ? _this$options$cacheTi : 5 * 60 * 1000);\n  };\n\n  _proto.setDefaultOptions = function setDefaultOptions(options) {\n    this.defaultOptions = options;\n  };\n\n  _proto.scheduleGc = function scheduleGc() {\n    var _this = this;\n\n    this.clearGcTimeout();\n\n    if (isValidTimeout(this.cacheTime)) {\n      this.gcTimeout = setTimeout(function () {\n        _this.optionalRemove();\n      }, this.cacheTime);\n    }\n  };\n\n  _proto.clearGcTimeout = function clearGcTimeout() {\n    clearTimeout(this.gcTimeout);\n    this.gcTimeout = undefined;\n  };\n\n  _proto.optionalRemove = function optionalRemove() {\n    if (!this.observers.length && !this.state.isFetching) {\n      this.cache.remove(this);\n    }\n  };\n\n  _proto.setData = function setData(updater, options) {\n    var _this$options$isDataE, _this$options;\n\n    var prevData = this.state.data; // Get the new data\n\n    var data = functionalUpdate(updater, prevData); // Use prev data if an isDataEqual function is defined and returns `true`\n\n    if ((_this$options$isDataE = (_this$options = this.options).isDataEqual) == null ? void 0 : _this$options$isDataE.call(_this$options, prevData, data)) {\n      data = prevData;\n    } else if (this.options.structuralSharing !== false) {\n      // Structurally share data between prev and new data if needed\n      data = replaceEqualDeep(prevData, data);\n    } // Set data and mark it as cached\n\n\n    this.dispatch({\n      data: data,\n      type: 'success',\n      dataUpdatedAt: options == null ? void 0 : options.updatedAt\n    });\n    return data;\n  };\n\n  _proto.setState = function setState(state, setStateOptions) {\n    this.dispatch({\n      type: 'setState',\n      state: state,\n      setStateOptions: setStateOptions\n    });\n  };\n\n  _proto.cancel = function cancel(options) {\n    var _this$retryer;\n\n    var promise = this.promise;\n    (_this$retryer = this.retryer) == null ? void 0 : _this$retryer.cancel(options);\n    return promise ? promise.then(noop).catch(noop) : Promise.resolve();\n  };\n\n  _proto.destroy = function destroy() {\n    this.clearGcTimeout();\n    this.cancel({\n      silent: true\n    });\n  };\n\n  _proto.reset = function reset() {\n    this.destroy();\n    this.setState(this.initialState);\n  };\n\n  _proto.isActive = function isActive() {\n    return this.observers.some(function (observer) {\n      return observer.options.enabled !== false;\n    });\n  };\n\n  _proto.isFetching = function isFetching() {\n    return this.state.isFetching;\n  };\n\n  _proto.isStale = function isStale() {\n    return this.state.isInvalidated || !this.state.dataUpdatedAt || this.observers.some(function (observer) {\n      return observer.getCurrentResult().isStale;\n    });\n  };\n\n  _proto.isStaleByTime = function isStaleByTime(staleTime) {\n    if (staleTime === void 0) {\n      staleTime = 0;\n    }\n\n    return this.state.isInvalidated || !this.state.dataUpdatedAt || !timeUntilStale(this.state.dataUpdatedAt, staleTime);\n  };\n\n  _proto.onFocus = function onFocus() {\n    var _this$retryer2;\n\n    var observer = this.observers.find(function (x) {\n      return x.shouldFetchOnWindowFocus();\n    });\n\n    if (observer) {\n      observer.refetch();\n    } // Continue fetch if currently paused\n\n\n    (_this$retryer2 = this.retryer) == null ? void 0 : _this$retryer2.continue();\n  };\n\n  _proto.onOnline = function onOnline() {\n    var _this$retryer3;\n\n    var observer = this.observers.find(function (x) {\n      return x.shouldFetchOnReconnect();\n    });\n\n    if (observer) {\n      observer.refetch();\n    } // Continue fetch if currently paused\n\n\n    (_this$retryer3 = this.retryer) == null ? void 0 : _this$retryer3.continue();\n  };\n\n  _proto.addObserver = function addObserver(observer) {\n    if (this.observers.indexOf(observer) === -1) {\n      this.observers.push(observer); // Stop the query from being garbage collected\n\n      this.clearGcTimeout();\n      this.cache.notify({\n        type: 'observerAdded',\n        query: this,\n        observer: observer\n      });\n    }\n  };\n\n  _proto.removeObserver = function removeObserver(observer) {\n    if (this.observers.indexOf(observer) !== -1) {\n      this.observers = this.observers.filter(function (x) {\n        return x !== observer;\n      });\n\n      if (!this.observers.length) {\n        // If the transport layer does not support cancellation\n        // we'll let the query continue so the result can be cached\n        if (this.retryer) {\n          if (this.retryer.isTransportCancelable) {\n            this.retryer.cancel({\n              revert: true\n            });\n          } else {\n            this.retryer.cancelRetry();\n          }\n        }\n\n        if (this.cacheTime) {\n          this.scheduleGc();\n        } else {\n          this.cache.remove(this);\n        }\n      }\n\n      this.cache.notify({\n        type: 'observerRemoved',\n        query: this,\n        observer: observer\n      });\n    }\n  };\n\n  _proto.getObserversCount = function getObserversCount() {\n    return this.observers.length;\n  };\n\n  _proto.invalidate = function invalidate() {\n    if (!this.state.isInvalidated) {\n      this.dispatch({\n        type: 'invalidate'\n      });\n    }\n  };\n\n  _proto.fetch = function fetch(options, fetchOptions) {\n    var _this2 = this,\n        _this$options$behavio,\n        _context$fetchOptions;\n\n    if (this.state.isFetching) {\n      if (this.state.dataUpdatedAt && (fetchOptions == null ? void 0 : fetchOptions.cancelRefetch)) {\n        // Silently cancel current fetch if the user wants to cancel refetches\n        this.cancel({\n          silent: true\n        });\n      } else if (this.promise) {\n        // Return current promise if we are already fetching\n        return this.promise;\n      }\n    } // Update config if passed, otherwise the config from the last execution is used\n\n\n    if (options) {\n      this.setOptions(options);\n    } // Use the options from the first observer with a query function if no function is found.\n    // This can happen when the query is hydrated or created with setQueryData.\n\n\n    if (!this.options.queryFn) {\n      var observer = this.observers.find(function (x) {\n        return x.options.queryFn;\n      });\n\n      if (observer) {\n        this.setOptions(observer.options);\n      }\n    }\n\n    var queryKey = ensureQueryKeyArray(this.queryKey); // Create query function context\n\n    var queryFnContext = {\n      queryKey: queryKey,\n      pageParam: undefined\n    }; // Create fetch function\n\n    var fetchFn = function fetchFn() {\n      return _this2.options.queryFn ? _this2.options.queryFn(queryFnContext) : Promise.reject('Missing queryFn');\n    }; // Trigger behavior hook\n\n\n    var context = {\n      fetchOptions: fetchOptions,\n      options: this.options,\n      queryKey: queryKey,\n      state: this.state,\n      fetchFn: fetchFn\n    };\n\n    if ((_this$options$behavio = this.options.behavior) == null ? void 0 : _this$options$behavio.onFetch) {\n      var _this$options$behavio2;\n\n      (_this$options$behavio2 = this.options.behavior) == null ? void 0 : _this$options$behavio2.onFetch(context);\n    } // Store state in case the current fetch needs to be reverted\n\n\n    this.revertState = this.state; // Set to fetching state if not already in it\n\n    if (!this.state.isFetching || this.state.fetchMeta !== ((_context$fetchOptions = context.fetchOptions) == null ? void 0 : _context$fetchOptions.meta)) {\n      var _context$fetchOptions2;\n\n      this.dispatch({\n        type: 'fetch',\n        meta: (_context$fetchOptions2 = context.fetchOptions) == null ? void 0 : _context$fetchOptions2.meta\n      });\n    } // Try to fetch the data\n\n\n    this.retryer = new Retryer({\n      fn: context.fetchFn,\n      onSuccess: function onSuccess(data) {\n        _this2.setData(data); // Remove query after fetching if cache time is 0\n\n\n        if (_this2.cacheTime === 0) {\n          _this2.optionalRemove();\n        }\n      },\n      onError: function onError(error) {\n        // Optimistically update state if needed\n        if (!(isCancelledError(error) && error.silent)) {\n          _this2.dispatch({\n            type: 'error',\n            error: error\n          });\n        }\n\n        if (!isCancelledError(error)) {\n          // Notify cache callback\n          if (_this2.cache.config.onError) {\n            _this2.cache.config.onError(error, _this2);\n          } // Log error\n\n\n          getLogger().error(error);\n        } // Remove query after fetching if cache time is 0\n\n\n        if (_this2.cacheTime === 0) {\n          _this2.optionalRemove();\n        }\n      },\n      onFail: function onFail() {\n        _this2.dispatch({\n          type: 'failed'\n        });\n      },\n      onPause: function onPause() {\n        _this2.dispatch({\n          type: 'pause'\n        });\n      },\n      onContinue: function onContinue() {\n        _this2.dispatch({\n          type: 'continue'\n        });\n      },\n      retry: context.options.retry,\n      retryDelay: context.options.retryDelay\n    });\n    this.promise = this.retryer.promise;\n    return this.promise;\n  };\n\n  _proto.dispatch = function dispatch(action) {\n    var _this3 = this;\n\n    this.state = this.reducer(this.state, action);\n    notifyManager.batch(function () {\n      _this3.observers.forEach(function (observer) {\n        observer.onQueryUpdate(action);\n      });\n\n      _this3.cache.notify({\n        query: _this3,\n        type: 'queryUpdated',\n        action: action\n      });\n    });\n  };\n\n  _proto.getDefaultState = function getDefaultState(options) {\n    var data = typeof options.initialData === 'function' ? options.initialData() : options.initialData;\n    var hasInitialData = typeof options.initialData !== 'undefined';\n    var initialDataUpdatedAt = hasInitialData ? typeof options.initialDataUpdatedAt === 'function' ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0;\n    var hasData = typeof data !== 'undefined';\n    return {\n      data: data,\n      dataUpdateCount: 0,\n      dataUpdatedAt: hasData ? initialDataUpdatedAt != null ? initialDataUpdatedAt : Date.now() : 0,\n      error: null,\n      errorUpdateCount: 0,\n      errorUpdatedAt: 0,\n      fetchFailureCount: 0,\n      fetchMeta: null,\n      isFetching: false,\n      isInvalidated: false,\n      isPaused: false,\n      status: hasData ? 'success' : 'idle'\n    };\n  };\n\n  _proto.reducer = function reducer(state, action) {\n    var _action$meta, _action$dataUpdatedAt;\n\n    switch (action.type) {\n      case 'failed':\n        return _extends({}, state, {\n          fetchFailureCount: state.fetchFailureCount + 1\n        });\n\n      case 'pause':\n        return _extends({}, state, {\n          isPaused: true\n        });\n\n      case 'continue':\n        return _extends({}, state, {\n          isPaused: false\n        });\n\n      case 'fetch':\n        return _extends({}, state, {\n          fetchFailureCount: 0,\n          fetchMeta: (_action$meta = action.meta) != null ? _action$meta : null,\n          isFetching: true,\n          isPaused: false,\n          status: !state.dataUpdatedAt ? 'loading' : state.status\n        });\n\n      case 'success':\n        return _extends({}, state, {\n          data: action.data,\n          dataUpdateCount: state.dataUpdateCount + 1,\n          dataUpdatedAt: (_action$dataUpdatedAt = action.dataUpdatedAt) != null ? _action$dataUpdatedAt : Date.now(),\n          error: null,\n          fetchFailureCount: 0,\n          isFetching: false,\n          isInvalidated: false,\n          isPaused: false,\n          status: 'success'\n        });\n\n      case 'error':\n        var error = action.error;\n\n        if (isCancelledError(error) && error.revert && this.revertState) {\n          return _extends({}, this.revertState);\n        }\n\n        return _extends({}, state, {\n          error: error,\n          errorUpdateCount: state.errorUpdateCount + 1,\n          errorUpdatedAt: Date.now(),\n          fetchFailureCount: state.fetchFailureCount + 1,\n          isFetching: false,\n          isPaused: false,\n          status: 'error'\n        });\n\n      case 'invalidate':\n        return _extends({}, state, {\n          isInvalidated: true\n        });\n\n      case 'setState':\n        return _extends({}, state, action.state);\n\n      default:\n        return state;\n    }\n  };\n\n  return Query;\n}();\n\n// CLASS\nvar QueryCache = /*#__PURE__*/function (_Subscribable) {\n  _inheritsLoose(QueryCache, _Subscribable);\n\n  function QueryCache(config) {\n    var _this;\n\n    _this = _Subscribable.call(this) || this;\n    _this.config = config || {};\n    _this.queries = [];\n    _this.queriesMap = {};\n    return _this;\n  }\n\n  var _proto = QueryCache.prototype;\n\n  _proto.build = function build(client, options, state) {\n    var _options$queryHash;\n\n    var queryKey = options.queryKey;\n    var queryHash = (_options$queryHash = options.queryHash) != null ? _options$queryHash : hashQueryKeyByOptions(queryKey, options);\n    var query = this.get(queryHash);\n\n    if (!query) {\n      query = new Query({\n        cache: this,\n        queryKey: queryKey,\n        queryHash: queryHash,\n        options: client.defaultQueryOptions(options),\n        state: state,\n        defaultOptions: client.getQueryDefaults(queryKey)\n      });\n      this.add(query);\n    }\n\n    return query;\n  };\n\n  _proto.add = function add(query) {\n    if (!this.queriesMap[query.queryHash]) {\n      this.queriesMap[query.queryHash] = query;\n      this.queries.push(query);\n      this.notify({\n        type: 'queryAdded',\n        query: query\n      });\n    }\n  };\n\n  _proto.remove = function remove(query) {\n    var queryInMap = this.queriesMap[query.queryHash];\n\n    if (queryInMap) {\n      query.destroy();\n      this.queries = this.queries.filter(function (x) {\n        return x !== query;\n      });\n\n      if (queryInMap === query) {\n        delete this.queriesMap[query.queryHash];\n      }\n\n      this.notify({\n        type: 'queryRemoved',\n        query: query\n      });\n    }\n  };\n\n  _proto.clear = function clear() {\n    var _this2 = this;\n\n    notifyManager.batch(function () {\n      _this2.queries.forEach(function (query) {\n        _this2.remove(query);\n      });\n    });\n  };\n\n  _proto.get = function get(queryHash) {\n    return this.queriesMap[queryHash];\n  };\n\n  _proto.getAll = function getAll() {\n    return this.queries;\n  };\n\n  _proto.find = function find(arg1, arg2) {\n    var _parseFilterArgs = parseFilterArgs$1(arg1, arg2),\n        filters = _parseFilterArgs[0];\n\n    if (typeof filters.exact === 'undefined') {\n      filters.exact = true;\n    }\n\n    return this.queries.find(function (query) {\n      return matchQuery(filters, query);\n    });\n  };\n\n  _proto.findAll = function findAll(arg1, arg2) {\n    var _parseFilterArgs2 = parseFilterArgs$1(arg1, arg2),\n        filters = _parseFilterArgs2[0];\n\n    return filters ? this.queries.filter(function (query) {\n      return matchQuery(filters, query);\n    }) : this.queries;\n  };\n\n  _proto.notify = function notify(event) {\n    var _this3 = this;\n\n    notifyManager.batch(function () {\n      _this3.listeners.forEach(function (listener) {\n        listener(event);\n      });\n    });\n  };\n\n  _proto.onFocus = function onFocus() {\n    var _this4 = this;\n\n    notifyManager.batch(function () {\n      _this4.queries.forEach(function (query) {\n        query.onFocus();\n      });\n    });\n  };\n\n  _proto.onOnline = function onOnline() {\n    var _this5 = this;\n\n    notifyManager.batch(function () {\n      _this5.queries.forEach(function (query) {\n        query.onOnline();\n      });\n    });\n  };\n\n  return QueryCache;\n}(Subscribable);\n\n// CLASS\nvar Mutation = /*#__PURE__*/function () {\n  function Mutation(config) {\n    this.options = _extends({}, config.defaultOptions, config.options);\n    this.mutationId = config.mutationId;\n    this.mutationCache = config.mutationCache;\n    this.observers = [];\n    this.state = config.state || getDefaultState();\n  }\n\n  var _proto = Mutation.prototype;\n\n  _proto.setState = function setState(state) {\n    this.dispatch({\n      type: 'setState',\n      state: state\n    });\n  };\n\n  _proto.addObserver = function addObserver(observer) {\n    if (this.observers.indexOf(observer) === -1) {\n      this.observers.push(observer);\n    }\n  };\n\n  _proto.removeObserver = function removeObserver(observer) {\n    this.observers = this.observers.filter(function (x) {\n      return x !== observer;\n    });\n  };\n\n  _proto.cancel = function cancel() {\n    if (this.retryer) {\n      this.retryer.cancel();\n      return this.retryer.promise.then(noop).catch(noop);\n    }\n\n    return Promise.resolve();\n  };\n\n  _proto.continue = function _continue() {\n    if (this.retryer) {\n      this.retryer.continue();\n      return this.retryer.promise;\n    }\n\n    return this.execute();\n  };\n\n  _proto.execute = function execute() {\n    var _this = this;\n\n    var data;\n    var restored = this.state.status === 'loading';\n    var promise = Promise.resolve();\n\n    if (!restored) {\n      this.dispatch({\n        type: 'loading',\n        variables: this.options.variables\n      });\n      promise = promise.then(function () {\n        return _this.options.onMutate == null ? void 0 : _this.options.onMutate(_this.state.variables);\n      }).then(function (context) {\n        if (context !== _this.state.context) {\n          _this.dispatch({\n            type: 'loading',\n            context: context,\n            variables: _this.state.variables\n          });\n        }\n      });\n    }\n\n    return promise.then(function () {\n      return _this.executeMutation();\n    }).then(function (result) {\n      data = result;\n    }).then(function () {\n      return _this.options.onSuccess == null ? void 0 : _this.options.onSuccess(data, _this.state.variables, _this.state.context);\n    }).then(function () {\n      return _this.options.onSettled == null ? void 0 : _this.options.onSettled(data, null, _this.state.variables, _this.state.context);\n    }).then(function () {\n      _this.dispatch({\n        type: 'success',\n        data: data\n      });\n\n      return data;\n    }).catch(function (error) {\n      // Notify cache callback\n      if (_this.mutationCache.config.onError) {\n        _this.mutationCache.config.onError(error, _this.state.variables, _this.state.context, _this);\n      } // Log error\n\n\n      getLogger().error(error);\n      return Promise.resolve().then(function () {\n        return _this.options.onError == null ? void 0 : _this.options.onError(error, _this.state.variables, _this.state.context);\n      }).then(function () {\n        return _this.options.onSettled == null ? void 0 : _this.options.onSettled(undefined, error, _this.state.variables, _this.state.context);\n      }).then(function () {\n        _this.dispatch({\n          type: 'error',\n          error: error\n        });\n\n        throw error;\n      });\n    });\n  };\n\n  _proto.executeMutation = function executeMutation() {\n    var _this2 = this,\n        _this$options$retry;\n\n    this.retryer = new Retryer({\n      fn: function fn() {\n        if (!_this2.options.mutationFn) {\n          return Promise.reject('No mutationFn found');\n        }\n\n        return _this2.options.mutationFn(_this2.state.variables);\n      },\n      onFail: function onFail() {\n        _this2.dispatch({\n          type: 'failed'\n        });\n      },\n      onPause: function onPause() {\n        _this2.dispatch({\n          type: 'pause'\n        });\n      },\n      onContinue: function onContinue() {\n        _this2.dispatch({\n          type: 'continue'\n        });\n      },\n      retry: (_this$options$retry = this.options.retry) != null ? _this$options$retry : 0,\n      retryDelay: this.options.retryDelay\n    });\n    return this.retryer.promise;\n  };\n\n  _proto.dispatch = function dispatch(action) {\n    var _this3 = this;\n\n    this.state = reducer(this.state, action);\n    notifyManager.batch(function () {\n      _this3.observers.forEach(function (observer) {\n        observer.onMutationUpdate(action);\n      });\n\n      _this3.mutationCache.notify(_this3);\n    });\n  };\n\n  return Mutation;\n}();\nfunction getDefaultState() {\n  return {\n    context: undefined,\n    data: undefined,\n    error: null,\n    failureCount: 0,\n    isPaused: false,\n    status: 'idle',\n    variables: undefined\n  };\n}\n\nfunction reducer(state, action) {\n  switch (action.type) {\n    case 'failed':\n      return _extends({}, state, {\n        failureCount: state.failureCount + 1\n      });\n\n    case 'pause':\n      return _extends({}, state, {\n        isPaused: true\n      });\n\n    case 'continue':\n      return _extends({}, state, {\n        isPaused: false\n      });\n\n    case 'loading':\n      return _extends({}, state, {\n        context: action.context,\n        data: undefined,\n        error: null,\n        isPaused: false,\n        status: 'loading',\n        variables: action.variables\n      });\n\n    case 'success':\n      return _extends({}, state, {\n        data: action.data,\n        error: null,\n        status: 'success',\n        isPaused: false\n      });\n\n    case 'error':\n      return _extends({}, state, {\n        data: undefined,\n        error: action.error,\n        failureCount: state.failureCount + 1,\n        isPaused: false,\n        status: 'error'\n      });\n\n    case 'setState':\n      return _extends({}, state, action.state);\n\n    default:\n      return state;\n  }\n}\n\n// CLASS\nvar MutationCache = /*#__PURE__*/function (_Subscribable) {\n  _inheritsLoose(MutationCache, _Subscribable);\n\n  function MutationCache(config) {\n    var _this;\n\n    _this = _Subscribable.call(this) || this;\n    _this.config = config || {};\n    _this.mutations = [];\n    _this.mutationId = 0;\n    return _this;\n  }\n\n  var _proto = MutationCache.prototype;\n\n  _proto.build = function build(client, options, state) {\n    var mutation = new Mutation({\n      mutationCache: this,\n      mutationId: ++this.mutationId,\n      options: client.defaultMutationOptions(options),\n      state: state,\n      defaultOptions: options.mutationKey ? client.getMutationDefaults(options.mutationKey) : undefined\n    });\n    this.add(mutation);\n    return mutation;\n  };\n\n  _proto.add = function add(mutation) {\n    this.mutations.push(mutation);\n    this.notify(mutation);\n  };\n\n  _proto.remove = function remove(mutation) {\n    this.mutations = this.mutations.filter(function (x) {\n      return x !== mutation;\n    });\n    mutation.cancel();\n    this.notify(mutation);\n  };\n\n  _proto.clear = function clear() {\n    var _this2 = this;\n\n    notifyManager.batch(function () {\n      _this2.mutations.forEach(function (mutation) {\n        _this2.remove(mutation);\n      });\n    });\n  };\n\n  _proto.getAll = function getAll() {\n    return this.mutations;\n  };\n\n  _proto.find = function find(filters) {\n    if (typeof filters.exact === 'undefined') {\n      filters.exact = true;\n    }\n\n    return this.mutations.find(function (mutation) {\n      return matchMutation(filters, mutation);\n    });\n  };\n\n  _proto.findAll = function findAll(filters) {\n    return this.mutations.filter(function (mutation) {\n      return matchMutation(filters, mutation);\n    });\n  };\n\n  _proto.notify = function notify(mutation) {\n    var _this3 = this;\n\n    notifyManager.batch(function () {\n      _this3.listeners.forEach(function (listener) {\n        listener(mutation);\n      });\n    });\n  };\n\n  _proto.onFocus = function onFocus() {\n    this.resumePausedMutations();\n  };\n\n  _proto.onOnline = function onOnline() {\n    this.resumePausedMutations();\n  };\n\n  _proto.resumePausedMutations = function resumePausedMutations() {\n    var pausedMutations = this.mutations.filter(function (x) {\n      return x.state.isPaused;\n    });\n    return notifyManager.batch(function () {\n      return pausedMutations.reduce(function (promise, mutation) {\n        return promise.then(function () {\n          return mutation.continue().catch(noop);\n        });\n      }, Promise.resolve());\n    });\n  };\n\n  return MutationCache;\n}(Subscribable);\n\nfunction infiniteQueryBehavior() {\n  return {\n    onFetch: function onFetch(context) {\n      context.fetchFn = function () {\n        var _context$fetchOptions, _context$fetchOptions2, _context$state$data, _context$state$data2;\n\n        var fetchMore = (_context$fetchOptions = context.fetchOptions) == null ? void 0 : (_context$fetchOptions2 = _context$fetchOptions.meta) == null ? void 0 : _context$fetchOptions2.fetchMore;\n        var pageParam = fetchMore == null ? void 0 : fetchMore.pageParam;\n        var isFetchingNextPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'forward';\n        var isFetchingPreviousPage = (fetchMore == null ? void 0 : fetchMore.direction) === 'backward';\n        var oldPages = ((_context$state$data = context.state.data) == null ? void 0 : _context$state$data.pages) || [];\n        var oldPageParams = ((_context$state$data2 = context.state.data) == null ? void 0 : _context$state$data2.pageParams) || [];\n        var newPageParams = oldPageParams;\n        var cancelled = false; // Get query function\n\n        var queryFn = context.options.queryFn || function () {\n          return Promise.reject('Missing queryFn');\n        }; // Create function to fetch a page\n\n\n        var fetchPage = function fetchPage(pages, manual, param, previous) {\n          if (cancelled) {\n            return Promise.reject('Cancelled');\n          }\n\n          if (typeof param === 'undefined' && !manual && pages.length) {\n            return Promise.resolve(pages);\n          }\n\n          var queryFnContext = {\n            queryKey: context.queryKey,\n            pageParam: param\n          };\n          var queryFnResult = queryFn(queryFnContext);\n          var promise = Promise.resolve(queryFnResult).then(function (page) {\n            newPageParams = previous ? [param].concat(newPageParams) : [].concat(newPageParams, [param]);\n            return previous ? [page].concat(pages) : [].concat(pages, [page]);\n          });\n\n          if (isCancelable(queryFnResult)) {\n            var promiseAsAny = promise;\n            promiseAsAny.cancel = queryFnResult.cancel;\n          }\n\n          return promise;\n        };\n\n        var promise; // Fetch first page?\n\n        if (!oldPages.length) {\n          promise = fetchPage([]);\n        } // Fetch next page?\n        else if (isFetchingNextPage) {\n            var manual = typeof pageParam !== 'undefined';\n            var param = manual ? pageParam : getNextPageParam(context.options, oldPages);\n            promise = fetchPage(oldPages, manual, param);\n          } // Fetch previous page?\n          else if (isFetchingPreviousPage) {\n              var _manual = typeof pageParam !== 'undefined';\n\n              var _param = _manual ? pageParam : getPreviousPageParam(context.options, oldPages);\n\n              promise = fetchPage(oldPages, _manual, _param, true);\n            } // Refetch pages\n            else {\n                (function () {\n                  newPageParams = [];\n                  var manual = typeof context.options.getNextPageParam === 'undefined'; // Fetch first page\n\n                  promise = fetchPage([], manual, oldPageParams[0]); // Fetch remaining pages\n\n                  var _loop = function _loop(i) {\n                    promise = promise.then(function (pages) {\n                      var param = manual ? oldPageParams[i] : getNextPageParam(context.options, pages);\n                      return fetchPage(pages, manual, param);\n                    });\n                  };\n\n                  for (var i = 1; i < oldPages.length; i++) {\n                    _loop(i);\n                  }\n                })();\n              }\n\n        var finalPromise = promise.then(function (pages) {\n          return {\n            pages: pages,\n            pageParams: newPageParams\n          };\n        });\n        var finalPromiseAsAny = finalPromise;\n\n        finalPromiseAsAny.cancel = function () {\n          cancelled = true;\n\n          if (isCancelable(promise)) {\n            promise.cancel();\n          }\n        };\n\n        return finalPromise;\n      };\n    }\n  };\n}\nfunction getNextPageParam(options, pages) {\n  return options.getNextPageParam == null ? void 0 : options.getNextPageParam(pages[pages.length - 1], pages);\n}\nfunction getPreviousPageParam(options, pages) {\n  return options.getPreviousPageParam == null ? void 0 : options.getPreviousPageParam(pages[0], pages);\n}\n/**\n * Checks if there is a next page.\n * Returns `undefined` if it cannot be determined.\n */\n\nfunction hasNextPage(options, pages) {\n  if (options.getNextPageParam && Array.isArray(pages)) {\n    var nextPageParam = getNextPageParam(options, pages);\n    return typeof nextPageParam !== 'undefined' && nextPageParam !== null && nextPageParam !== false;\n  }\n}\n/**\n * Checks if there is a previous page.\n * Returns `undefined` if it cannot be determined.\n */\n\nfunction hasPreviousPage(options, pages) {\n  if (options.getPreviousPageParam && Array.isArray(pages)) {\n    var previousPageParam = getPreviousPageParam(options, pages);\n    return typeof previousPageParam !== 'undefined' && previousPageParam !== null && previousPageParam !== false;\n  }\n}\n\n// CLASS\nvar QueryClient = /*#__PURE__*/function () {\n  function QueryClient(config) {\n    if (config === void 0) {\n      config = {};\n    }\n\n    this.queryCache = config.queryCache || new QueryCache();\n    this.mutationCache = config.mutationCache || new MutationCache();\n    this.defaultOptions = config.defaultOptions || {};\n    this.queryDefaults = [];\n    this.mutationDefaults = [];\n  }\n\n  var _proto = QueryClient.prototype;\n\n  _proto.mount = function mount() {\n    var _this = this;\n\n    this.unsubscribeFocus = focusManager.subscribe(function () {\n      if (focusManager.isFocused() && onlineManager.isOnline()) {\n        _this.mutationCache.onFocus();\n\n        _this.queryCache.onFocus();\n      }\n    });\n    this.unsubscribeOnline = onlineManager.subscribe(function () {\n      if (focusManager.isFocused() && onlineManager.isOnline()) {\n        _this.mutationCache.onOnline();\n\n        _this.queryCache.onOnline();\n      }\n    });\n  };\n\n  _proto.unmount = function unmount() {\n    var _this$unsubscribeFocu, _this$unsubscribeOnli;\n\n    (_this$unsubscribeFocu = this.unsubscribeFocus) == null ? void 0 : _this$unsubscribeFocu.call(this);\n    (_this$unsubscribeOnli = this.unsubscribeOnline) == null ? void 0 : _this$unsubscribeOnli.call(this);\n  };\n\n  _proto.isFetching = function isFetching(arg1, arg2) {\n    var _parseFilterArgs = parseFilterArgs$1(arg1, arg2),\n        filters = _parseFilterArgs[0];\n\n    filters.fetching = true;\n    return this.queryCache.findAll(filters).length;\n  };\n\n  _proto.isMutating = function isMutating(filters) {\n    return this.mutationCache.findAll(_extends({}, filters, {\n      fetching: true\n    })).length;\n  };\n\n  _proto.getQueryData = function getQueryData(queryKey, filters) {\n    var _this$queryCache$find;\n\n    return (_this$queryCache$find = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find.state.data;\n  };\n\n  _proto.setQueryData = function setQueryData(queryKey, updater, options) {\n    var parsedOptions = parseQueryArgs$1(queryKey);\n    var defaultedOptions = this.defaultQueryOptions(parsedOptions);\n    return this.queryCache.build(this, defaultedOptions).setData(updater, options);\n  };\n\n  _proto.setQueriesData = function setQueriesData(queryKeyOrFilters, updater, options) {\n    var _this2 = this;\n\n    return notifyManager.batch(function () {\n      return _this2.getQueryCache().findAll(queryKeyOrFilters).map(function (_ref) {\n        var queryKey = _ref.queryKey;\n        return [queryKey, _this2.setQueryData(queryKey, updater, options)];\n      });\n    });\n  };\n\n  _proto.getQueryState = function getQueryState(queryKey, filters) {\n    var _this$queryCache$find2;\n\n    return (_this$queryCache$find2 = this.queryCache.find(queryKey, filters)) == null ? void 0 : _this$queryCache$find2.state;\n  };\n\n  _proto.removeQueries = function removeQueries(arg1, arg2) {\n    var _parseFilterArgs2 = parseFilterArgs$1(arg1, arg2),\n        filters = _parseFilterArgs2[0];\n\n    var queryCache = this.queryCache;\n    notifyManager.batch(function () {\n      queryCache.findAll(filters).forEach(function (query) {\n        queryCache.remove(query);\n      });\n    });\n  };\n\n  _proto.resetQueries = function resetQueries(arg1, arg2, arg3) {\n    var _this3 = this;\n\n    var _parseFilterArgs3 = parseFilterArgs$1(arg1, arg2, arg3),\n        filters = _parseFilterArgs3[0],\n        options = _parseFilterArgs3[1];\n\n    var queryCache = this.queryCache;\n\n    var refetchFilters = _extends({}, filters, {\n      active: true\n    });\n\n    return notifyManager.batch(function () {\n      queryCache.findAll(filters).forEach(function (query) {\n        query.reset();\n      });\n      return _this3.refetchQueries(refetchFilters, options);\n    });\n  };\n\n  _proto.cancelQueries = function cancelQueries(arg1, arg2, arg3) {\n    var _this4 = this;\n\n    var _parseFilterArgs4 = parseFilterArgs$1(arg1, arg2, arg3),\n        filters = _parseFilterArgs4[0],\n        _parseFilterArgs4$ = _parseFilterArgs4[1],\n        cancelOptions = _parseFilterArgs4$ === void 0 ? {} : _parseFilterArgs4$;\n\n    if (typeof cancelOptions.revert === 'undefined') {\n      cancelOptions.revert = true;\n    }\n\n    var promises = notifyManager.batch(function () {\n      return _this4.queryCache.findAll(filters).map(function (query) {\n        return query.cancel(cancelOptions);\n      });\n    });\n    return Promise.all(promises).then(noop).catch(noop);\n  };\n\n  _proto.invalidateQueries = function invalidateQueries(arg1, arg2, arg3) {\n    var _filters$refetchActiv,\n        _this5 = this;\n\n    var _parseFilterArgs5 = parseFilterArgs$1(arg1, arg2, arg3),\n        filters = _parseFilterArgs5[0],\n        options = _parseFilterArgs5[1];\n\n    var refetchFilters = _extends({}, filters, {\n      active: (_filters$refetchActiv = filters.refetchActive) != null ? _filters$refetchActiv : true,\n      inactive: filters.refetchInactive\n    });\n\n    return notifyManager.batch(function () {\n      _this5.queryCache.findAll(filters).forEach(function (query) {\n        query.invalidate();\n      });\n\n      return _this5.refetchQueries(refetchFilters, options);\n    });\n  };\n\n  _proto.refetchQueries = function refetchQueries(arg1, arg2, arg3) {\n    var _this6 = this;\n\n    var _parseFilterArgs6 = parseFilterArgs$1(arg1, arg2, arg3),\n        filters = _parseFilterArgs6[0],\n        options = _parseFilterArgs6[1];\n\n    var promises = notifyManager.batch(function () {\n      return _this6.queryCache.findAll(filters).map(function (query) {\n        return query.fetch();\n      });\n    });\n    var promise = Promise.all(promises).then(noop);\n\n    if (!(options == null ? void 0 : options.throwOnError)) {\n      promise = promise.catch(noop);\n    }\n\n    return promise;\n  };\n\n  _proto.fetchQuery = function fetchQuery(arg1, arg2, arg3) {\n    var parsedOptions = parseQueryArgs$1(arg1, arg2, arg3);\n    var defaultedOptions = this.defaultQueryOptions(parsedOptions); // https://github.com/tannerlinsley/react-query/issues/652\n\n    if (typeof defaultedOptions.retry === 'undefined') {\n      defaultedOptions.retry = false;\n    }\n\n    var query = this.queryCache.build(this, defaultedOptions);\n    return query.isStaleByTime(defaultedOptions.staleTime) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data);\n  };\n\n  _proto.prefetchQuery = function prefetchQuery(arg1, arg2, arg3) {\n    return this.fetchQuery(arg1, arg2, arg3).then(noop).catch(noop);\n  };\n\n  _proto.fetchInfiniteQuery = function fetchInfiniteQuery(arg1, arg2, arg3) {\n    var parsedOptions = parseQueryArgs$1(arg1, arg2, arg3);\n    parsedOptions.behavior = infiniteQueryBehavior();\n    return this.fetchQuery(parsedOptions);\n  };\n\n  _proto.prefetchInfiniteQuery = function prefetchInfiniteQuery(arg1, arg2, arg3) {\n    return this.fetchInfiniteQuery(arg1, arg2, arg3).then(noop).catch(noop);\n  };\n\n  _proto.cancelMutations = function cancelMutations() {\n    var _this7 = this;\n\n    var promises = notifyManager.batch(function () {\n      return _this7.mutationCache.getAll().map(function (mutation) {\n        return mutation.cancel();\n      });\n    });\n    return Promise.all(promises).then(noop).catch(noop);\n  };\n\n  _proto.resumePausedMutations = function resumePausedMutations() {\n    return this.getMutationCache().resumePausedMutations();\n  };\n\n  _proto.executeMutation = function executeMutation(options) {\n    return this.mutationCache.build(this, options).execute();\n  };\n\n  _proto.getQueryCache = function getQueryCache() {\n    return this.queryCache;\n  };\n\n  _proto.getMutationCache = function getMutationCache() {\n    return this.mutationCache;\n  };\n\n  _proto.getDefaultOptions = function getDefaultOptions() {\n    return this.defaultOptions;\n  };\n\n  _proto.setDefaultOptions = function setDefaultOptions(options) {\n    this.defaultOptions = options;\n  };\n\n  _proto.setQueryDefaults = function setQueryDefaults(queryKey, options) {\n    var result = this.queryDefaults.find(function (x) {\n      return hashQueryKey(queryKey) === hashQueryKey(x.queryKey);\n    });\n\n    if (result) {\n      result.defaultOptions = options;\n    } else {\n      this.queryDefaults.push({\n        queryKey: queryKey,\n        defaultOptions: options\n      });\n    }\n  };\n\n  _proto.getQueryDefaults = function getQueryDefaults(queryKey) {\n    var _this$queryDefaults$f;\n\n    return queryKey ? (_this$queryDefaults$f = this.queryDefaults.find(function (x) {\n      return partialMatchKey(queryKey, x.queryKey);\n    })) == null ? void 0 : _this$queryDefaults$f.defaultOptions : undefined;\n  };\n\n  _proto.setMutationDefaults = function setMutationDefaults(mutationKey, options) {\n    var result = this.mutationDefaults.find(function (x) {\n      return hashQueryKey(mutationKey) === hashQueryKey(x.mutationKey);\n    });\n\n    if (result) {\n      result.defaultOptions = options;\n    } else {\n      this.mutationDefaults.push({\n        mutationKey: mutationKey,\n        defaultOptions: options\n      });\n    }\n  };\n\n  _proto.getMutationDefaults = function getMutationDefaults(mutationKey) {\n    var _this$mutationDefault;\n\n    return mutationKey ? (_this$mutationDefault = this.mutationDefaults.find(function (x) {\n      return partialMatchKey(mutationKey, x.mutationKey);\n    })) == null ? void 0 : _this$mutationDefault.defaultOptions : undefined;\n  };\n\n  _proto.defaultQueryOptions = function defaultQueryOptions(options) {\n    if (options == null ? void 0 : options._defaulted) {\n      return options;\n    }\n\n    var defaultedOptions = _extends({}, this.defaultOptions.queries, this.getQueryDefaults(options == null ? void 0 : options.queryKey), options, {\n      _defaulted: true\n    });\n\n    if (!defaultedOptions.queryHash && defaultedOptions.queryKey) {\n      defaultedOptions.queryHash = hashQueryKeyByOptions(defaultedOptions.queryKey, defaultedOptions);\n    }\n\n    return defaultedOptions;\n  };\n\n  _proto.defaultQueryObserverOptions = function defaultQueryObserverOptions(options) {\n    return this.defaultQueryOptions(options);\n  };\n\n  _proto.defaultMutationOptions = function defaultMutationOptions(options) {\n    if (options == null ? void 0 : options._defaulted) {\n      return options;\n    }\n\n    return _extends({}, this.defaultOptions.mutations, this.getMutationDefaults(options == null ? void 0 : options.mutationKey), options, {\n      _defaulted: true\n    });\n  };\n\n  _proto.clear = function clear() {\n    this.queryCache.clear();\n    this.mutationCache.clear();\n  };\n\n  return QueryClient;\n}();\n\nvar QueryObserver = /*#__PURE__*/function (_Subscribable) {\n  _inheritsLoose(QueryObserver, _Subscribable);\n\n  function QueryObserver(client, options) {\n    var _this;\n\n    _this = _Subscribable.call(this) || this;\n    _this.client = client;\n    _this.options = options;\n    _this.trackedProps = [];\n    _this.previousSelectError = null;\n\n    _this.bindMethods();\n\n    _this.setOptions(options);\n\n    return _this;\n  }\n\n  var _proto = QueryObserver.prototype;\n\n  _proto.bindMethods = function bindMethods() {\n    this.remove = this.remove.bind(this);\n    this.refetch = this.refetch.bind(this);\n  };\n\n  _proto.onSubscribe = function onSubscribe() {\n    if (this.listeners.length === 1) {\n      this.currentQuery.addObserver(this);\n\n      if (shouldFetchOnMount(this.currentQuery, this.options)) {\n        this.executeFetch();\n      }\n\n      this.updateTimers();\n    }\n  };\n\n  _proto.onUnsubscribe = function onUnsubscribe() {\n    if (!this.listeners.length) {\n      this.destroy();\n    }\n  };\n\n  _proto.shouldFetchOnReconnect = function shouldFetchOnReconnect() {\n    return _shouldFetchOnReconnect(this.currentQuery, this.options);\n  };\n\n  _proto.shouldFetchOnWindowFocus = function shouldFetchOnWindowFocus() {\n    return _shouldFetchOnWindowFocus(this.currentQuery, this.options);\n  };\n\n  _proto.destroy = function destroy() {\n    this.listeners = [];\n    this.clearTimers();\n    this.currentQuery.removeObserver(this);\n  };\n\n  _proto.setOptions = function setOptions(options, notifyOptions) {\n    var prevOptions = this.options;\n    var prevQuery = this.currentQuery;\n    this.options = this.client.defaultQueryObserverOptions(options);\n\n    if (typeof this.options.enabled !== 'undefined' && typeof this.options.enabled !== 'boolean') {\n      throw new Error('Expected enabled to be a boolean');\n    } // Keep previous query key if the user does not supply one\n\n\n    if (!this.options.queryKey) {\n      this.options.queryKey = prevOptions.queryKey;\n    }\n\n    this.updateQuery();\n    var mounted = this.hasListeners(); // Fetch if there are subscribers\n\n    if (mounted && shouldFetchOptionally(this.currentQuery, prevQuery, this.options, prevOptions)) {\n      this.executeFetch();\n    } // Update result\n\n\n    this.updateResult(notifyOptions); // Update stale interval if needed\n\n    if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.staleTime !== prevOptions.staleTime)) {\n      this.updateStaleTimeout();\n    } // Update refetch interval if needed\n\n\n    if (mounted && (this.currentQuery !== prevQuery || this.options.enabled !== prevOptions.enabled || this.options.refetchInterval !== prevOptions.refetchInterval)) {\n      this.updateRefetchInterval();\n    }\n  };\n\n  _proto.getOptimisticResult = function getOptimisticResult(options) {\n    var defaultedOptions = this.client.defaultQueryObserverOptions(options);\n    var query = this.client.getQueryCache().build(this.client, defaultedOptions);\n    return this.createResult(query, defaultedOptions);\n  };\n\n  _proto.getCurrentResult = function getCurrentResult() {\n    return this.currentResult;\n  };\n\n  _proto.trackResult = function trackResult(result) {\n    var _this2 = this;\n\n    var trackedResult = {};\n    Object.keys(result).forEach(function (key) {\n      Object.defineProperty(trackedResult, key, {\n        configurable: false,\n        enumerable: true,\n        get: function get() {\n          var typedKey = key;\n\n          if (!_this2.trackedProps.includes(typedKey)) {\n            _this2.trackedProps.push(typedKey);\n          }\n\n          return result[typedKey];\n        }\n      });\n    });\n    return trackedResult;\n  };\n\n  _proto.getNextResult = function getNextResult(options) {\n    var _this3 = this;\n\n    return new Promise(function (resolve, reject) {\n      var unsubscribe = _this3.subscribe(function (result) {\n        if (!result.isFetching) {\n          unsubscribe();\n\n          if (result.isError && (options == null ? void 0 : options.throwOnError)) {\n            reject(result.error);\n          } else {\n            resolve(result);\n          }\n        }\n      });\n    });\n  };\n\n  _proto.getCurrentQuery = function getCurrentQuery() {\n    return this.currentQuery;\n  };\n\n  _proto.remove = function remove() {\n    this.client.getQueryCache().remove(this.currentQuery);\n  };\n\n  _proto.refetch = function refetch(options) {\n    return this.fetch(options);\n  };\n\n  _proto.fetchOptimistic = function fetchOptimistic(options) {\n    var _this4 = this;\n\n    var defaultedOptions = this.client.defaultQueryObserverOptions(options);\n    var query = this.client.getQueryCache().build(this.client, defaultedOptions);\n    return query.fetch().then(function () {\n      return _this4.createResult(query, defaultedOptions);\n    });\n  };\n\n  _proto.fetch = function fetch(fetchOptions) {\n    var _this5 = this;\n\n    return this.executeFetch(fetchOptions).then(function () {\n      _this5.updateResult();\n\n      return _this5.currentResult;\n    });\n  };\n\n  _proto.executeFetch = function executeFetch(fetchOptions) {\n    // Make sure we reference the latest query as the current one might have been removed\n    this.updateQuery(); // Fetch\n\n    var promise = this.currentQuery.fetch(this.options, fetchOptions);\n\n    if (!(fetchOptions == null ? void 0 : fetchOptions.throwOnError)) {\n      promise = promise.catch(noop);\n    }\n\n    return promise;\n  };\n\n  _proto.updateStaleTimeout = function updateStaleTimeout() {\n    var _this6 = this;\n\n    this.clearStaleTimeout();\n\n    if (isServer || this.currentResult.isStale || !isValidTimeout(this.options.staleTime)) {\n      return;\n    }\n\n    var time = timeUntilStale(this.currentResult.dataUpdatedAt, this.options.staleTime); // The timeout is sometimes triggered 1 ms before the stale time expiration.\n    // To mitigate this issue we always add 1 ms to the timeout.\n\n    var timeout = time + 1;\n    this.staleTimeoutId = setTimeout(function () {\n      if (!_this6.currentResult.isStale) {\n        _this6.updateResult();\n      }\n    }, timeout);\n  };\n\n  _proto.updateRefetchInterval = function updateRefetchInterval() {\n    var _this7 = this;\n\n    this.clearRefetchInterval();\n\n    if (isServer || this.options.enabled === false || !isValidTimeout(this.options.refetchInterval)) {\n      return;\n    }\n\n    this.refetchIntervalId = setInterval(function () {\n      if (_this7.options.refetchIntervalInBackground || focusManager.isFocused()) {\n        _this7.executeFetch();\n      }\n    }, this.options.refetchInterval);\n  };\n\n  _proto.updateTimers = function updateTimers() {\n    this.updateStaleTimeout();\n    this.updateRefetchInterval();\n  };\n\n  _proto.clearTimers = function clearTimers() {\n    this.clearStaleTimeout();\n    this.clearRefetchInterval();\n  };\n\n  _proto.clearStaleTimeout = function clearStaleTimeout() {\n    clearTimeout(this.staleTimeoutId);\n    this.staleTimeoutId = undefined;\n  };\n\n  _proto.clearRefetchInterval = function clearRefetchInterval() {\n    clearInterval(this.refetchIntervalId);\n    this.refetchIntervalId = undefined;\n  };\n\n  _proto.createResult = function createResult(query, options) {\n    var prevQuery = this.currentQuery;\n    var prevOptions = this.options;\n    var prevResult = this.currentResult;\n    var prevResultState = this.currentResultState;\n    var prevResultOptions = this.currentResultOptions;\n    var queryChange = query !== prevQuery;\n    var queryInitialState = queryChange ? query.state : this.currentQueryInitialState;\n    var prevQueryResult = queryChange ? this.currentResult : this.previousQueryResult;\n    var state = query.state;\n    var dataUpdatedAt = state.dataUpdatedAt,\n        error = state.error,\n        errorUpdatedAt = state.errorUpdatedAt,\n        isFetching = state.isFetching,\n        status = state.status;\n    var isPreviousData = false;\n    var isPlaceholderData = false;\n    var data; // Optimistically set result in fetching state if needed\n\n    if (options.optimisticResults) {\n      var mounted = this.hasListeners();\n      var fetchOnMount = !mounted && shouldFetchOnMount(query, options);\n      var fetchOptionally = mounted && shouldFetchOptionally(query, prevQuery, options, prevOptions);\n\n      if (fetchOnMount || fetchOptionally) {\n        isFetching = true;\n\n        if (!dataUpdatedAt) {\n          status = 'loading';\n        }\n      }\n    } // Keep previous data if needed\n\n\n    if (options.keepPreviousData && !state.dataUpdateCount && (prevQueryResult == null ? void 0 : prevQueryResult.isSuccess) && status !== 'error') {\n      data = prevQueryResult.data;\n      dataUpdatedAt = prevQueryResult.dataUpdatedAt;\n      status = prevQueryResult.status;\n      isPreviousData = true;\n    } // Select data if needed\n    else if (options.select && typeof state.data !== 'undefined') {\n        // Memoize select result\n        if (prevResult && state.data === (prevResultState == null ? void 0 : prevResultState.data) && options.select === (prevResultOptions == null ? void 0 : prevResultOptions.select) && !this.previousSelectError) {\n          data = prevResult.data;\n        } else {\n          try {\n            data = options.select(state.data);\n\n            if (options.structuralSharing !== false) {\n              data = replaceEqualDeep(prevResult == null ? void 0 : prevResult.data, data);\n            }\n\n            this.previousSelectError = null;\n          } catch (selectError) {\n            getLogger().error(selectError);\n            error = selectError;\n            this.previousSelectError = selectError;\n            errorUpdatedAt = Date.now();\n            status = 'error';\n          }\n        }\n      } // Use query data\n      else {\n          data = state.data;\n        } // Show placeholder data if needed\n\n\n    if (typeof options.placeholderData !== 'undefined' && typeof data === 'undefined' && status === 'loading') {\n      var placeholderData; // Memoize placeholder data\n\n      if ((prevResult == null ? void 0 : prevResult.isPlaceholderData) && options.placeholderData === (prevResultOptions == null ? void 0 : prevResultOptions.placeholderData)) {\n        placeholderData = prevResult.data;\n      } else {\n        placeholderData = typeof options.placeholderData === 'function' ? options.placeholderData() : options.placeholderData;\n\n        if (options.select && typeof placeholderData !== 'undefined') {\n          try {\n            placeholderData = options.select(placeholderData);\n\n            if (options.structuralSharing !== false) {\n              placeholderData = replaceEqualDeep(prevResult == null ? void 0 : prevResult.data, placeholderData);\n            }\n\n            this.previousSelectError = null;\n          } catch (selectError) {\n            getLogger().error(selectError);\n            error = selectError;\n            this.previousSelectError = selectError;\n            errorUpdatedAt = Date.now();\n            status = 'error';\n          }\n        }\n      }\n\n      if (typeof placeholderData !== 'undefined') {\n        status = 'success';\n        data = placeholderData;\n        isPlaceholderData = true;\n      }\n    }\n\n    var result = {\n      status: status,\n      isLoading: status === 'loading',\n      isSuccess: status === 'success',\n      isError: status === 'error',\n      isIdle: status === 'idle',\n      data: data,\n      dataUpdatedAt: dataUpdatedAt,\n      error: error,\n      errorUpdatedAt: errorUpdatedAt,\n      failureCount: state.fetchFailureCount,\n      isFetched: state.dataUpdateCount > 0 || state.errorUpdateCount > 0,\n      isFetchedAfterMount: state.dataUpdateCount > queryInitialState.dataUpdateCount || state.errorUpdateCount > queryInitialState.errorUpdateCount,\n      isFetching: isFetching,\n      isLoadingError: status === 'error' && state.dataUpdatedAt === 0,\n      isPlaceholderData: isPlaceholderData,\n      isPreviousData: isPreviousData,\n      isRefetchError: status === 'error' && state.dataUpdatedAt !== 0,\n      isStale: isStale(query, options),\n      refetch: this.refetch,\n      remove: this.remove\n    };\n    return result;\n  };\n\n  _proto.shouldNotifyListeners = function shouldNotifyListeners(result, prevResult) {\n    if (!prevResult) {\n      return true;\n    }\n\n    if (result === prevResult) {\n      return false;\n    }\n\n    var _this$options = this.options,\n        notifyOnChangeProps = _this$options.notifyOnChangeProps,\n        notifyOnChangePropsExclusions = _this$options.notifyOnChangePropsExclusions;\n\n    if (!notifyOnChangeProps && !notifyOnChangePropsExclusions) {\n      return true;\n    }\n\n    if (notifyOnChangeProps === 'tracked' && !this.trackedProps.length) {\n      return true;\n    }\n\n    var includedProps = notifyOnChangeProps === 'tracked' ? this.trackedProps : notifyOnChangeProps;\n    return Object.keys(result).some(function (key) {\n      var typedKey = key;\n      var changed = result[typedKey] !== prevResult[typedKey];\n      var isIncluded = includedProps == null ? void 0 : includedProps.some(function (x) {\n        return x === key;\n      });\n      var isExcluded = notifyOnChangePropsExclusions == null ? void 0 : notifyOnChangePropsExclusions.some(function (x) {\n        return x === key;\n      });\n      return changed && !isExcluded && (!includedProps || isIncluded);\n    });\n  };\n\n  _proto.updateResult = function updateResult(notifyOptions) {\n    var prevResult = this.currentResult;\n    this.currentResult = this.createResult(this.currentQuery, this.options);\n    this.currentResultState = this.currentQuery.state;\n    this.currentResultOptions = this.options; // Only notify if something has changed\n\n    if (shallowEqualObjects(this.currentResult, prevResult)) {\n      return;\n    } // Determine which callbacks to trigger\n\n\n    var defaultNotifyOptions = {\n      cache: true\n    };\n\n    if ((notifyOptions == null ? void 0 : notifyOptions.listeners) !== false && this.shouldNotifyListeners(this.currentResult, prevResult)) {\n      defaultNotifyOptions.listeners = true;\n    }\n\n    this.notify(_extends({}, defaultNotifyOptions, notifyOptions));\n  };\n\n  _proto.updateQuery = function updateQuery() {\n    var query = this.client.getQueryCache().build(this.client, this.options);\n\n    if (query === this.currentQuery) {\n      return;\n    }\n\n    var prevQuery = this.currentQuery;\n    this.currentQuery = query;\n    this.currentQueryInitialState = query.state;\n    this.previousQueryResult = this.currentResult;\n\n    if (this.hasListeners()) {\n      prevQuery == null ? void 0 : prevQuery.removeObserver(this);\n      query.addObserver(this);\n    }\n  };\n\n  _proto.onQueryUpdate = function onQueryUpdate(action) {\n    var notifyOptions = {};\n\n    if (action.type === 'success') {\n      notifyOptions.onSuccess = true;\n    } else if (action.type === 'error') {\n      notifyOptions.onError = true;\n    }\n\n    this.updateResult(notifyOptions);\n\n    if (this.hasListeners()) {\n      this.updateTimers();\n    }\n  };\n\n  _proto.notify = function notify(notifyOptions) {\n    var _this8 = this;\n\n    notifyManager.batch(function () {\n      // First trigger the configuration callbacks\n      if (notifyOptions.onSuccess) {\n        _this8.options.onSuccess == null ? void 0 : _this8.options.onSuccess(_this8.currentResult.data);\n        _this8.options.onSettled == null ? void 0 : _this8.options.onSettled(_this8.currentResult.data, null);\n      } else if (notifyOptions.onError) {\n        _this8.options.onError == null ? void 0 : _this8.options.onError(_this8.currentResult.error);\n        _this8.options.onSettled == null ? void 0 : _this8.options.onSettled(undefined, _this8.currentResult.error);\n      } // Then trigger the listeners\n\n\n      if (notifyOptions.listeners) {\n        _this8.listeners.forEach(function (listener) {\n          listener(_this8.currentResult);\n        });\n      } // Then the cache listeners\n\n\n      if (notifyOptions.cache) {\n        _this8.client.getQueryCache().notify({\n          query: _this8.currentQuery,\n          type: 'observerResultsUpdated'\n        });\n      }\n    });\n  };\n\n  return QueryObserver;\n}(Subscribable);\n\nfunction shouldLoadOnMount(query, options) {\n  return options.enabled !== false && !query.state.dataUpdatedAt && !(query.state.status === 'error' && options.retryOnMount === false);\n}\n\nfunction shouldRefetchOnMount(query, options) {\n  return options.enabled !== false && query.state.dataUpdatedAt > 0 && (options.refetchOnMount === 'always' || options.refetchOnMount !== false && isStale(query, options));\n}\n\nfunction shouldFetchOnMount(query, options) {\n  return shouldLoadOnMount(query, options) || shouldRefetchOnMount(query, options);\n}\n\nfunction _shouldFetchOnReconnect(query, options) {\n  return options.enabled !== false && (options.refetchOnReconnect === 'always' || options.refetchOnReconnect !== false && isStale(query, options));\n}\n\nfunction _shouldFetchOnWindowFocus(query, options) {\n  return options.enabled !== false && (options.refetchOnWindowFocus === 'always' || options.refetchOnWindowFocus !== false && isStale(query, options));\n}\n\nfunction shouldFetchOptionally(query, prevQuery, options, prevOptions) {\n  return options.enabled !== false && (query !== prevQuery || prevOptions.enabled === false) && isStale(query, options);\n}\n\nfunction isStale(query, options) {\n  return query.isStaleByTime(options.staleTime);\n}\n\nvar QueriesObserver = /*#__PURE__*/function (_Subscribable) {\n  _inheritsLoose(QueriesObserver, _Subscribable);\n\n  function QueriesObserver(client, queries) {\n    var _this;\n\n    _this = _Subscribable.call(this) || this;\n    _this.client = client;\n    _this.queries = [];\n    _this.result = [];\n    _this.observers = [];\n    _this.observersMap = {};\n\n    if (queries) {\n      _this.setQueries(queries);\n    }\n\n    return _this;\n  }\n\n  var _proto = QueriesObserver.prototype;\n\n  _proto.onSubscribe = function onSubscribe() {\n    var _this2 = this;\n\n    if (this.listeners.length === 1) {\n      this.observers.forEach(function (observer) {\n        observer.subscribe(function (result) {\n          _this2.onUpdate(observer, result);\n        });\n      });\n    }\n  };\n\n  _proto.onUnsubscribe = function onUnsubscribe() {\n    if (!this.listeners.length) {\n      this.destroy();\n    }\n  };\n\n  _proto.destroy = function destroy() {\n    this.listeners = [];\n    this.observers.forEach(function (observer) {\n      observer.destroy();\n    });\n  };\n\n  _proto.setQueries = function setQueries(queries, notifyOptions) {\n    this.queries = queries;\n    this.updateObservers(notifyOptions);\n  };\n\n  _proto.getCurrentResult = function getCurrentResult() {\n    return this.result;\n  };\n\n  _proto.getOptimisticResult = function getOptimisticResult(queries) {\n    var _this3 = this;\n\n    return queries.map(function (options) {\n      var defaultedOptions = _this3.client.defaultQueryObserverOptions(options);\n\n      return _this3.getObserver(defaultedOptions).getOptimisticResult(defaultedOptions);\n    });\n  };\n\n  _proto.getObserver = function getObserver(options) {\n    var defaultedOptions = this.client.defaultQueryObserverOptions(options);\n    return this.observersMap[defaultedOptions.queryHash] || new QueryObserver(this.client, defaultedOptions);\n  };\n\n  _proto.updateObservers = function updateObservers(notifyOptions) {\n    var _this4 = this;\n\n    notifyManager.batch(function () {\n      var hasIndexChange = false;\n      var prevObservers = _this4.observers;\n      var prevOberversMap = _this4.observersMap;\n      var newResult = [];\n      var newObservers = [];\n      var newObserversMap = {};\n\n      _this4.queries.forEach(function (options, i) {\n        var defaultedOptions = _this4.client.defaultQueryObserverOptions(options);\n\n        var queryHash = defaultedOptions.queryHash;\n\n        var observer = _this4.getObserver(defaultedOptions);\n\n        if (prevOberversMap[queryHash]) {\n          observer.setOptions(defaultedOptions, notifyOptions);\n        }\n\n        if (observer !== prevObservers[i]) {\n          hasIndexChange = true;\n        }\n\n        newObservers.push(observer);\n        newResult.push(observer.getCurrentResult());\n        newObserversMap[queryHash] = observer;\n      });\n\n      if (prevObservers.length === newObservers.length && !hasIndexChange) {\n        return;\n      }\n\n      _this4.observers = newObservers;\n      _this4.observersMap = newObserversMap;\n      _this4.result = newResult;\n\n      if (!_this4.hasListeners()) {\n        return;\n      }\n\n      difference(prevObservers, newObservers).forEach(function (observer) {\n        observer.destroy();\n      });\n      difference(newObservers, prevObservers).forEach(function (observer) {\n        observer.subscribe(function (result) {\n          _this4.onUpdate(observer, result);\n        });\n      });\n\n      _this4.notify();\n    });\n  };\n\n  _proto.onUpdate = function onUpdate(observer, result) {\n    var index = this.observers.indexOf(observer);\n\n    if (index !== -1) {\n      this.result = replaceAt(this.result, index, result);\n      this.notify();\n    }\n  };\n\n  _proto.notify = function notify() {\n    var _this5 = this;\n\n    notifyManager.batch(function () {\n      _this5.listeners.forEach(function (listener) {\n        listener(_this5.result);\n      });\n    });\n  };\n\n  return QueriesObserver;\n}(Subscribable);\n\nvar InfiniteQueryObserver = /*#__PURE__*/function (_QueryObserver) {\n  _inheritsLoose(InfiniteQueryObserver, _QueryObserver);\n\n  // Type override\n  // Type override\n  // Type override\n  // eslint-disable-next-line @typescript-eslint/no-useless-constructor\n  function InfiniteQueryObserver(client, options) {\n    return _QueryObserver.call(this, client, options) || this;\n  }\n\n  var _proto = InfiniteQueryObserver.prototype;\n\n  _proto.bindMethods = function bindMethods() {\n    _QueryObserver.prototype.bindMethods.call(this);\n\n    this.fetchNextPage = this.fetchNextPage.bind(this);\n    this.fetchPreviousPage = this.fetchPreviousPage.bind(this);\n  };\n\n  _proto.setOptions = function setOptions(options) {\n    _QueryObserver.prototype.setOptions.call(this, _extends({}, options, {\n      behavior: infiniteQueryBehavior()\n    }));\n  };\n\n  _proto.getOptimisticResult = function getOptimisticResult(options) {\n    options.behavior = infiniteQueryBehavior();\n    return _QueryObserver.prototype.getOptimisticResult.call(this, options);\n  };\n\n  _proto.fetchNextPage = function fetchNextPage(options) {\n    return this.fetch({\n      cancelRefetch: true,\n      throwOnError: options == null ? void 0 : options.throwOnError,\n      meta: {\n        fetchMore: {\n          direction: 'forward',\n          pageParam: options == null ? void 0 : options.pageParam\n        }\n      }\n    });\n  };\n\n  _proto.fetchPreviousPage = function fetchPreviousPage(options) {\n    return this.fetch({\n      cancelRefetch: true,\n      throwOnError: options == null ? void 0 : options.throwOnError,\n      meta: {\n        fetchMore: {\n          direction: 'backward',\n          pageParam: options == null ? void 0 : options.pageParam\n        }\n      }\n    });\n  };\n\n  _proto.createResult = function createResult(query, options) {\n    var _state$data, _state$data2, _state$fetchMeta, _state$fetchMeta$fetc, _state$fetchMeta2, _state$fetchMeta2$fet;\n\n    var state = query.state;\n\n    var result = _QueryObserver.prototype.createResult.call(this, query, options);\n\n    return _extends({}, result, {\n      fetchNextPage: this.fetchNextPage,\n      fetchPreviousPage: this.fetchPreviousPage,\n      hasNextPage: hasNextPage(options, (_state$data = state.data) == null ? void 0 : _state$data.pages),\n      hasPreviousPage: hasPreviousPage(options, (_state$data2 = state.data) == null ? void 0 : _state$data2.pages),\n      isFetchingNextPage: state.isFetching && ((_state$fetchMeta = state.fetchMeta) == null ? void 0 : (_state$fetchMeta$fetc = _state$fetchMeta.fetchMore) == null ? void 0 : _state$fetchMeta$fetc.direction) === 'forward',\n      isFetchingPreviousPage: state.isFetching && ((_state$fetchMeta2 = state.fetchMeta) == null ? void 0 : (_state$fetchMeta2$fet = _state$fetchMeta2.fetchMore) == null ? void 0 : _state$fetchMeta2$fet.direction) === 'backward'\n    });\n  };\n\n  return InfiniteQueryObserver;\n}(QueryObserver);\n\n// CLASS\nvar MutationObserver = /*#__PURE__*/function (_Subscribable) {\n  _inheritsLoose(MutationObserver, _Subscribable);\n\n  function MutationObserver(client, options) {\n    var _this;\n\n    _this = _Subscribable.call(this) || this;\n    _this.client = client;\n\n    _this.setOptions(options);\n\n    _this.bindMethods();\n\n    _this.updateResult();\n\n    return _this;\n  }\n\n  var _proto = MutationObserver.prototype;\n\n  _proto.bindMethods = function bindMethods() {\n    this.mutate = this.mutate.bind(this);\n    this.reset = this.reset.bind(this);\n  };\n\n  _proto.setOptions = function setOptions(options) {\n    this.options = this.client.defaultMutationOptions(options);\n  };\n\n  _proto.onUnsubscribe = function onUnsubscribe() {\n    if (!this.listeners.length) {\n      var _this$currentMutation;\n\n      (_this$currentMutation = this.currentMutation) == null ? void 0 : _this$currentMutation.removeObserver(this);\n    }\n  };\n\n  _proto.onMutationUpdate = function onMutationUpdate(action) {\n    this.updateResult(); // Determine which callbacks to trigger\n\n    var notifyOptions = {\n      listeners: true\n    };\n\n    if (action.type === 'success') {\n      notifyOptions.onSuccess = true;\n    } else if (action.type === 'error') {\n      notifyOptions.onError = true;\n    }\n\n    this.notify(notifyOptions);\n  };\n\n  _proto.getCurrentResult = function getCurrentResult() {\n    return this.currentResult;\n  };\n\n  _proto.reset = function reset() {\n    this.currentMutation = undefined;\n    this.updateResult();\n    this.notify({\n      listeners: true\n    });\n  };\n\n  _proto.mutate = function mutate(variables, options) {\n    this.mutateOptions = options;\n\n    if (this.currentMutation) {\n      this.currentMutation.removeObserver(this);\n    }\n\n    this.currentMutation = this.client.getMutationCache().build(this.client, _extends({}, this.options, {\n      variables: typeof variables !== 'undefined' ? variables : this.options.variables\n    }));\n    this.currentMutation.addObserver(this);\n    return this.currentMutation.execute();\n  };\n\n  _proto.updateResult = function updateResult() {\n    var state = this.currentMutation ? this.currentMutation.state : getDefaultState();\n    this.currentResult = _extends({}, state, {\n      isLoading: state.status === 'loading',\n      isSuccess: state.status === 'success',\n      isError: state.status === 'error',\n      isIdle: state.status === 'idle',\n      mutate: this.mutate,\n      reset: this.reset\n    });\n  };\n\n  _proto.notify = function notify(options) {\n    var _this2 = this;\n\n    notifyManager.batch(function () {\n      // First trigger the mutate callbacks\n      if (_this2.mutateOptions) {\n        if (options.onSuccess) {\n          _this2.mutateOptions.onSuccess == null ? void 0 : _this2.mutateOptions.onSuccess(_this2.currentResult.data, _this2.currentResult.variables, _this2.currentResult.context);\n          _this2.mutateOptions.onSettled == null ? void 0 : _this2.mutateOptions.onSettled(_this2.currentResult.data, null, _this2.currentResult.variables, _this2.currentResult.context);\n        } else if (options.onError) {\n          _this2.mutateOptions.onError == null ? void 0 : _this2.mutateOptions.onError(_this2.currentResult.error, _this2.currentResult.variables, _this2.currentResult.context);\n          _this2.mutateOptions.onSettled == null ? void 0 : _this2.mutateOptions.onSettled(undefined, _this2.currentResult.error, _this2.currentResult.variables, _this2.currentResult.context);\n        }\n      } // Then trigger the listeners\n\n\n      if (options.listeners) {\n        _this2.listeners.forEach(function (listener) {\n          listener(_this2.currentResult);\n        });\n      }\n    });\n  };\n\n  return MutationObserver;\n}(Subscribable);\n\nvar VUE_QUERY_CLIENT = \"VUE_QUERY_CLIENT\";\r\nfunction useQueryClient() {\r\n    var _a;\r\n    var vm = (_a = getCurrentInstance()) === null || _a === void 0 ? void 0 : _a.proxy;\r\n    if (!vm) {\r\n        throw new Error(\"vue-query hooks can only be used inside setup() function.\");\r\n    }\r\n    var queryClient = inject(VUE_QUERY_CLIENT);\r\n    if (!queryClient) {\r\n        throw new Error(\"No queryClient found in Vue context, use 'useQueryProvider' to set one in the root component.\");\r\n    }\r\n    return queryClient;\r\n}\n\nfunction useQueryProvider(config) {\r\n    if (config === void 0) { config = {}; }\r\n    var queryClient = new QueryClient(config);\r\n    queryClient.mount();\r\n    provide(VUE_QUERY_CLIENT, queryClient);\r\n    onUnmounted(function () {\r\n        queryClient.unmount();\r\n    });\r\n}\n\n/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n\r\nvar __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    };\r\n    return __assign.apply(this, arguments);\r\n};\n\nfunction isQueryKey(value) {\r\n    return typeof value === \"string\" || Array.isArray(value);\r\n}\r\nfunction parseQueryArgs(arg1, arg2, arg3) {\r\n    if (arg2 === void 0) { arg2 = {}; }\r\n    if (arg3 === void 0) { arg3 = {}; }\r\n    if (!isQueryKey(arg1)) {\r\n        return arg1;\r\n    }\r\n    if (typeof arg2 === \"function\") {\r\n        return Object.assign(arg3, {\r\n            queryKey: arg1,\r\n            queryFn: arg2,\r\n        });\r\n    }\r\n    return Object.assign(arg2, { queryKey: arg1 });\r\n}\r\nfunction parseFilterArgs(arg1, arg2, arg3) {\r\n    if (arg2 === void 0) { arg2 = {}; }\r\n    if (arg3 === void 0) { arg3 = {}; }\r\n    if (isQueryKey(arg1)) {\r\n        return [Object.assign(arg2, { queryKey: arg1 }), arg3];\r\n    }\r\n    return [arg1 || {}, arg2];\r\n}\r\nfunction parseMutationArgs(arg1, arg2, arg3) {\r\n    if (arg2 === void 0) { arg2 = {}; }\r\n    if (arg3 === void 0) { arg3 = {}; }\r\n    if (isQueryKey(arg1)) {\r\n        if (typeof arg2 === \"function\") {\r\n            return Object.assign(arg3, {\r\n                mutationKey: arg1,\r\n                mutationFn: arg2,\r\n            });\r\n        }\r\n        return Object.assign(arg2, { mutationKey: arg1 });\r\n    }\r\n    if (typeof arg1 === \"function\") {\r\n        return Object.assign(arg2, { mutationFn: arg1 });\r\n    }\r\n    return arg1;\r\n}\r\nfunction updateState(state, update) {\r\n    Object.keys(state).forEach(function (key) {\r\n        state[key] = update[key];\r\n    });\r\n}\n\nfunction useBaseQuery(options, Observer) {\r\n    var queryClient = useQueryClient();\r\n    var defaultedOptions = queryClient.defaultQueryObserverOptions(options);\r\n    var observer = new Observer(queryClient, defaultedOptions);\r\n    var state = reactive(observer.getCurrentResult());\r\n    var unsubscribe = observer.subscribe(function (result) {\r\n        updateState(state, result);\r\n    });\r\n    watchEffect(function () {\r\n        observer.setOptions(queryClient.defaultQueryObserverOptions(options));\r\n    });\r\n    onUnmounted(function () {\r\n        unsubscribe();\r\n    });\r\n    var resultRefs = toRefs(readonly(state));\r\n    var currentInstance = getCurrentInstance();\r\n    var isSuspense = Boolean(currentInstance === null || currentInstance === void 0 ? void 0 : currentInstance.suspense);\r\n    var suspense = isSuspense\r\n        ? function () { return observer.fetchOptimistic(defaultedOptions); }\r\n        : function () { return undefined; };\r\n    return __assign(__assign({}, resultRefs), { suspense: suspense });\r\n}\n\nfunction useQuery(arg1, arg2, arg3) {\r\n    var parsedOptions = parseQueryArgs(arg1, arg2, arg3);\r\n    return useBaseQuery(parsedOptions, QueryObserver);\r\n}\n\nfunction useQueries(queries) {\r\n    var queryClient = useQueryClient();\r\n    var observer = new QueriesObserver(queryClient, queries);\r\n    var state = reactive(observer.getCurrentResult());\r\n    var unsubscribe = observer.subscribe(function (result) {\r\n        result.forEach(function (resultEntry, index) {\r\n            set(state, index, resultEntry);\r\n        });\r\n    });\r\n    watch(function () { return queries; }, function () {\r\n        observer.setQueries(queries);\r\n    }, { deep: true });\r\n    onUnmounted(function () {\r\n        unsubscribe();\r\n    });\r\n    return readonly(state);\r\n}\n\nfunction useInfiniteQuery(arg1, arg2, arg3) {\r\n    var parsedOptions = parseQueryArgs(arg1, arg2, arg3);\r\n    return useBaseQuery(parsedOptions, InfiniteQueryObserver);\r\n}\n\nfunction useMutation(arg1, arg2, arg3) {\r\n    var options = parseMutationArgs(arg1, arg2, arg3);\r\n    var queryClient = useQueryClient();\r\n    var observer = new MutationObserver(queryClient, options);\r\n    var state = reactive(observer.getCurrentResult());\r\n    var unsubscribe = observer.subscribe(function () {\r\n        updateState(state, observer.getCurrentResult());\r\n    });\r\n    var mutate = function (variables, mutateOptions) {\r\n        observer.mutate(variables, mutateOptions).catch(function () { });\r\n    };\r\n    watchEffect(function () {\r\n        observer.setOptions(options);\r\n    });\r\n    onUnmounted(function () {\r\n        unsubscribe();\r\n    });\r\n    var resultRefs = toRefs(readonly(state));\r\n    return __assign(__assign({}, resultRefs), { mutate: mutate, mutateAsync: state.mutate });\r\n}\n\nfunction useIsFetching(arg1, arg2) {\r\n    var filters = ref({});\r\n    var queryClient = useQueryClient();\r\n    var parsedFilters = parseFilterArgs(arg1, arg2)[0];\r\n    filters.value = parsedFilters;\r\n    var isFetching = ref(queryClient.isFetching(filters.value));\r\n    var unsubscribe = queryClient.getQueryCache().subscribe(function () {\r\n        isFetching.value = queryClient.isFetching(filters.value);\r\n    });\r\n    watchEffect(function () {\r\n        var parsedFilters = parseFilterArgs(arg1, arg2)[0];\r\n        filters.value = parsedFilters;\r\n    });\r\n    onUnmounted(function () {\r\n        unsubscribe();\r\n    });\r\n    return isFetching;\r\n}\n\nfunction useIsMutating(filters) {\r\n    var queryClient = useQueryClient();\r\n    var isMutating = ref(queryClient.isMutating(filters));\r\n    var unsubscribe = queryClient.getMutationCache().subscribe(function () {\r\n        isMutating.value = queryClient.isMutating(filters);\r\n    });\r\n    onUnmounted(function () {\r\n        unsubscribe();\r\n    });\r\n    return isMutating;\r\n}\n\nexport { InfiniteQueryObserver, MutationCache, MutationObserver, QueriesObserver, QueryCache, QueryClient, QueryObserver, VUE_QUERY_CLIENT, useInfiniteQuery, useIsFetching, useIsMutating, useMutation, useQueries, useQuery, useQueryClient, useQueryProvider };\n//# sourceMappingURL=index.js.map\n","import { QueryClient, VUE_QUERY_CLIENT } from \"vue-query\";\nimport { provide, onUnmounted } from \"vue\";\nimport { isErrorInfoData } from \"@/type-guards\";\n\nconst queryClient = new QueryClient();\n\nfunction useQueryProvider(): void {\n  queryClient.setDefaultOptions({\n    queries: {\n      refetchOnWindowFocus: false,\n      retry(failureCount: number, error: unknown) {\n        if (isErrorInfoData(error)) {\n          return error.status >= 500 ? true : false;\n        } else if (failureCount < 2) return true;\n        return false;\n      },\n    },\n    mutations: {\n      onError(err, variables, recover) {\n        typeof recover === \"function\" ? recover() : null;\n      },\n      onSettled: () => queryClient.invalidateQueries(\"list-items\"),\n    },\n  });\n\n  queryClient.mount();\n  provide(VUE_QUERY_CLIENT, queryClient);\n\n  onUnmounted(() => {\n    queryClient.unmount();\n  });\n}\n\nexport { useQueryProvider, queryClient };\n","/* eslint-disable @typescript-eslint/explicit-module-boundary-types */\nimport { useClient } from \"@/utils/client\";\nimport type { item, HttpError } from \"@/types\";\nimport { isListItemsData, isItemData } from \"@/type-guards\";\nimport { areYouABadBody } from \"@/utils/client\";\nimport { queryClient } from \"@/utils/QueryClient\";\n\ntype updateItemPayload = {\n  id: string;\n  finishDate?: number | null;\n  rating?: number;\n  notes?: string;\n};\n\ntype createItemPayload = { bookId: string };\ntype removeItmPayload = { id: string };\n\nexport function performListItems(): Promise<item[]> {\n  const client = useClient();\n\n  const listItems = queryClient.fetchQuery<item[], HttpError>(\n    \"list-items\",\n    () =>\n      client(\"list-items\")\n        .then(areYouABadBody(isListItemsData))\n        .then((data) => data.listItems)\n  );\n  return listItems;\n}\n\nexport function performListItem(bookId: string): Promise<item | undefined> {\n  return performListItems().then(\n    (listItems) => listItems.find((book) => book.bookId === bookId) ?? undefined\n  );\n}\nexport function performCreateListItem(bookId: string) {\n  const client = useClient();\n\n  return queryClient.executeMutation<item, HttpError, createItemPayload>({\n    mutationFn: () => {\n      return client(\"list-items\", {\n        data: { bookId },\n        method: \"POST\",\n      })\n        .then(areYouABadBody(isItemData))\n        .then((data) => data.listItem);\n    },\n    onSettled: () => queryClient.invalidateQueries(\"list-items\"),\n  });\n}\n\nexport function performRemoveListItem(listItemId: string) {\n  const client = useClient();\n  const remove = () => client(`list-items/${listItemId}`, { method: \"DELETE\" });\n  // remove  return this type form serve. I don't think I will use it.\n  // type removeSuccessful = { success: true };\n\n  return queryClient.executeMutation<unknown, HttpError, removeItmPayload>({\n    mutationFn: remove,\n    onSettled: () => queryClient.invalidateQueries(\"list-items\"),\n  });\n}\n\nexport function perfermUdateListItem(payload: updateItemPayload) {\n  const client = useClient();\n  function perform(): Promise<item> {\n    return client(`list-items/${payload.id}`, {\n      data: payload,\n      method: \"PUT\",\n    })\n      .then(areYouABadBody(isItemData))\n      .then((data) => data.listItem);\n  }\n  function optimisticUpdate(): unknown {\n    const oldvalue = queryClient.getQueryData(\"list-items\");\n\n    queryClient.setQueryData<item[]>(\n      \"list-items\",\n      function updateCache(listItems: item[] | undefined) {\n        if (typeof listItems === \"undefined\") return [];\n        return listItems.map((item) =>\n          item.id === payload.id ? { ...item, ...payload } : item\n        );\n      }\n    );\n    return oldvalue;\n  }\n\n  // just rollback whaterver previous cached value, I don't care what type you are. you are unknow. (this unknow probability is undefined or item. not sure)\n  return queryClient.executeMutation<\n    item,\n    HttpError,\n    updateItemPayload,\n    unknown\n  >({\n    mutationFn: perform,\n    onSettled: () => queryClient.invalidateQueries(\"list-items\"),\n    onMutate: optimisticUpdate,\n    onError: (err, payload, oldvalue) => {\n      queryClient.setQueryData(\"list-items\", oldvalue);\n    },\n  });\n}\n"],"sourceRoot":""}