{"version":3,"file":"js/app~594ef244.ac133220.js","mappings":"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","sources":["webpack://app/../../node_modules/vuex/dist/vuex.esm-bundler.js","webpack://app/../../node_modules/@vueuse/core/index.mjs","webpack://app/../../node_modules/vuescroll/dist/vuescroll-esm.js","webpack://app/../../node_modules/@vueuse/shared/index.mjs"],"sourcesContent":["/*!\n * vuex v4.1.0\n * (c) 2022 Evan You\n * @license MIT\n */\nimport { inject, effectScope, reactive, watch, computed } from 'vue';\nimport { setupDevtoolsPlugin } from '@vue/devtools-api';\n\nvar storeKey = 'store';\n\nfunction useStore (key) {\n  if ( key === void 0 ) key = null;\n\n  return inject(key !== null ? key : storeKey)\n}\n\n/**\n * Get the first item that pass the test\n * by second argument function\n *\n * @param {Array} list\n * @param {Function} f\n * @return {*}\n */\nfunction find (list, f) {\n  return list.filter(f)[0]\n}\n\n/**\n * Deep copy the given object considering circular structure.\n * This function caches all nested objects and its copies.\n * If it detects circular structure, use cached copy to avoid infinite loop.\n *\n * @param {*} obj\n * @param {Array<Object>} cache\n * @return {*}\n */\nfunction deepCopy (obj, cache) {\n  if ( cache === void 0 ) cache = [];\n\n  // just return if obj is immutable value\n  if (obj === null || typeof obj !== 'object') {\n    return obj\n  }\n\n  // if obj is hit, it is in circular structure\n  var hit = find(cache, function (c) { return c.original === obj; });\n  if (hit) {\n    return hit.copy\n  }\n\n  var copy = Array.isArray(obj) ? [] : {};\n  // put the copy into cache at first\n  // because we want to refer it in recursive deepCopy\n  cache.push({\n    original: obj,\n    copy: copy\n  });\n\n  Object.keys(obj).forEach(function (key) {\n    copy[key] = deepCopy(obj[key], cache);\n  });\n\n  return copy\n}\n\n/**\n * forEach for object\n */\nfunction forEachValue (obj, fn) {\n  Object.keys(obj).forEach(function (key) { return fn(obj[key], key); });\n}\n\nfunction isObject (obj) {\n  return obj !== null && typeof obj === 'object'\n}\n\nfunction isPromise (val) {\n  return val && typeof val.then === 'function'\n}\n\nfunction assert (condition, msg) {\n  if (!condition) { throw new Error((\"[vuex] \" + msg)) }\n}\n\nfunction partial (fn, arg) {\n  return function () {\n    return fn(arg)\n  }\n}\n\nfunction genericSubscribe (fn, subs, options) {\n  if (subs.indexOf(fn) < 0) {\n    options && options.prepend\n      ? subs.unshift(fn)\n      : subs.push(fn);\n  }\n  return function () {\n    var i = subs.indexOf(fn);\n    if (i > -1) {\n      subs.splice(i, 1);\n    }\n  }\n}\n\nfunction resetStore (store, hot) {\n  store._actions = Object.create(null);\n  store._mutations = Object.create(null);\n  store._wrappedGetters = Object.create(null);\n  store._modulesNamespaceMap = Object.create(null);\n  var state = store.state;\n  // init all modules\n  installModule(store, state, [], store._modules.root, true);\n  // reset state\n  resetStoreState(store, state, hot);\n}\n\nfunction resetStoreState (store, state, hot) {\n  var oldState = store._state;\n  var oldScope = store._scope;\n\n  // bind store public getters\n  store.getters = {};\n  // reset local getters cache\n  store._makeLocalGettersCache = Object.create(null);\n  var wrappedGetters = store._wrappedGetters;\n  var computedObj = {};\n  var computedCache = {};\n\n  // create a new effect scope and create computed object inside it to avoid\n  // getters (computed) getting destroyed on component unmount.\n  var scope = effectScope(true);\n\n  scope.run(function () {\n    forEachValue(wrappedGetters, function (fn, key) {\n      // use computed to leverage its lazy-caching mechanism\n      // direct inline function use will lead to closure preserving oldState.\n      // using partial to return function with only arguments preserved in closure environment.\n      computedObj[key] = partial(fn, store);\n      computedCache[key] = computed(function () { return computedObj[key](); });\n      Object.defineProperty(store.getters, key, {\n        get: function () { return computedCache[key].value; },\n        enumerable: true // for local getters\n      });\n    });\n  });\n\n  store._state = reactive({\n    data: state\n  });\n\n  // register the newly created effect scope to the store so that we can\n  // dispose the effects when this method runs again in the future.\n  store._scope = scope;\n\n  // enable strict mode for new state\n  if (store.strict) {\n    enableStrictMode(store);\n  }\n\n  if (oldState) {\n    if (hot) {\n      // dispatch changes in all subscribed watchers\n      // to force getter re-evaluation for hot reloading.\n      store._withCommit(function () {\n        oldState.data = null;\n      });\n    }\n  }\n\n  // dispose previously registered effect scope if there is one.\n  if (oldScope) {\n    oldScope.stop();\n  }\n}\n\nfunction installModule (store, rootState, path, module, hot) {\n  var isRoot = !path.length;\n  var namespace = store._modules.getNamespace(path);\n\n  // register in namespace map\n  if (module.namespaced) {\n    if (store._modulesNamespaceMap[namespace] && (process.env.NODE_ENV !== 'production')) {\n      console.error((\"[vuex] duplicate namespace \" + namespace + \" for the namespaced module \" + (path.join('/'))));\n    }\n    store._modulesNamespaceMap[namespace] = module;\n  }\n\n  // set state\n  if (!isRoot && !hot) {\n    var parentState = getNestedState(rootState, path.slice(0, -1));\n    var moduleName = path[path.length - 1];\n    store._withCommit(function () {\n      if ((process.env.NODE_ENV !== 'production')) {\n        if (moduleName in parentState) {\n          console.warn(\n            (\"[vuex] state field \\\"\" + moduleName + \"\\\" was overridden by a module with the same name at \\\"\" + (path.join('.')) + \"\\\"\")\n          );\n        }\n      }\n      parentState[moduleName] = module.state;\n    });\n  }\n\n  var local = module.context = makeLocalContext(store, namespace, path);\n\n  module.forEachMutation(function (mutation, key) {\n    var namespacedType = namespace + key;\n    registerMutation(store, namespacedType, mutation, local);\n  });\n\n  module.forEachAction(function (action, key) {\n    var type = action.root ? key : namespace + key;\n    var handler = action.handler || action;\n    registerAction(store, type, handler, local);\n  });\n\n  module.forEachGetter(function (getter, key) {\n    var namespacedType = namespace + key;\n    registerGetter(store, namespacedType, getter, local);\n  });\n\n  module.forEachChild(function (child, key) {\n    installModule(store, rootState, path.concat(key), child, hot);\n  });\n}\n\n/**\n * make localized dispatch, commit, getters and state\n * if there is no namespace, just use root ones\n */\nfunction makeLocalContext (store, namespace, path) {\n  var noNamespace = namespace === '';\n\n  var local = {\n    dispatch: noNamespace ? store.dispatch : function (_type, _payload, _options) {\n      var args = unifyObjectStyle(_type, _payload, _options);\n      var payload = args.payload;\n      var options = args.options;\n      var type = args.type;\n\n      if (!options || !options.root) {\n        type = namespace + type;\n        if ((process.env.NODE_ENV !== 'production') && !store._actions[type]) {\n          console.error((\"[vuex] unknown local action type: \" + (args.type) + \", global type: \" + type));\n          return\n        }\n      }\n\n      return store.dispatch(type, payload)\n    },\n\n    commit: noNamespace ? store.commit : function (_type, _payload, _options) {\n      var args = unifyObjectStyle(_type, _payload, _options);\n      var payload = args.payload;\n      var options = args.options;\n      var type = args.type;\n\n      if (!options || !options.root) {\n        type = namespace + type;\n        if ((process.env.NODE_ENV !== 'production') && !store._mutations[type]) {\n          console.error((\"[vuex] unknown local mutation type: \" + (args.type) + \", global type: \" + type));\n          return\n        }\n      }\n\n      store.commit(type, payload, options);\n    }\n  };\n\n  // getters and state object must be gotten lazily\n  // because they will be changed by state update\n  Object.defineProperties(local, {\n    getters: {\n      get: noNamespace\n        ? function () { return store.getters; }\n        : function () { return makeLocalGetters(store, namespace); }\n    },\n    state: {\n      get: function () { return getNestedState(store.state, path); }\n    }\n  });\n\n  return local\n}\n\nfunction makeLocalGetters (store, namespace) {\n  if (!store._makeLocalGettersCache[namespace]) {\n    var gettersProxy = {};\n    var splitPos = namespace.length;\n    Object.keys(store.getters).forEach(function (type) {\n      // skip if the target getter is not match this namespace\n      if (type.slice(0, splitPos) !== namespace) { return }\n\n      // extract local getter type\n      var localType = type.slice(splitPos);\n\n      // Add a port to the getters proxy.\n      // Define as getter property because\n      // we do not want to evaluate the getters in this time.\n      Object.defineProperty(gettersProxy, localType, {\n        get: function () { return store.getters[type]; },\n        enumerable: true\n      });\n    });\n    store._makeLocalGettersCache[namespace] = gettersProxy;\n  }\n\n  return store._makeLocalGettersCache[namespace]\n}\n\nfunction registerMutation (store, type, handler, local) {\n  var entry = store._mutations[type] || (store._mutations[type] = []);\n  entry.push(function wrappedMutationHandler (payload) {\n    handler.call(store, local.state, payload);\n  });\n}\n\nfunction registerAction (store, type, handler, local) {\n  var entry = store._actions[type] || (store._actions[type] = []);\n  entry.push(function wrappedActionHandler (payload) {\n    var res = handler.call(store, {\n      dispatch: local.dispatch,\n      commit: local.commit,\n      getters: local.getters,\n      state: local.state,\n      rootGetters: store.getters,\n      rootState: store.state\n    }, payload);\n    if (!isPromise(res)) {\n      res = Promise.resolve(res);\n    }\n    if (store._devtoolHook) {\n      return res.catch(function (err) {\n        store._devtoolHook.emit('vuex:error', err);\n        throw err\n      })\n    } else {\n      return res\n    }\n  });\n}\n\nfunction registerGetter (store, type, rawGetter, local) {\n  if (store._wrappedGetters[type]) {\n    if ((process.env.NODE_ENV !== 'production')) {\n      console.error((\"[vuex] duplicate getter key: \" + type));\n    }\n    return\n  }\n  store._wrappedGetters[type] = function wrappedGetter (store) {\n    return rawGetter(\n      local.state, // local state\n      local.getters, // local getters\n      store.state, // root state\n      store.getters // root getters\n    )\n  };\n}\n\nfunction enableStrictMode (store) {\n  watch(function () { return store._state.data; }, function () {\n    if ((process.env.NODE_ENV !== 'production')) {\n      assert(store._committing, \"do not mutate vuex store state outside mutation handlers.\");\n    }\n  }, { deep: true, flush: 'sync' });\n}\n\nfunction getNestedState (state, path) {\n  return path.reduce(function (state, key) { return state[key]; }, state)\n}\n\nfunction unifyObjectStyle (type, payload, options) {\n  if (isObject(type) && type.type) {\n    options = payload;\n    payload = type;\n    type = type.type;\n  }\n\n  if ((process.env.NODE_ENV !== 'production')) {\n    assert(typeof type === 'string', (\"expects string as the type, but found \" + (typeof type) + \".\"));\n  }\n\n  return { type: type, payload: payload, options: options }\n}\n\nvar LABEL_VUEX_BINDINGS = 'vuex bindings';\nvar MUTATIONS_LAYER_ID = 'vuex:mutations';\nvar ACTIONS_LAYER_ID = 'vuex:actions';\nvar INSPECTOR_ID = 'vuex';\n\nvar actionId = 0;\n\nfunction addDevtools (app, store) {\n  setupDevtoolsPlugin(\n    {\n      id: 'org.vuejs.vuex',\n      app: app,\n      label: 'Vuex',\n      homepage: 'https://next.vuex.vuejs.org/',\n      logo: 'https://vuejs.org/images/icons/favicon-96x96.png',\n      packageName: 'vuex',\n      componentStateTypes: [LABEL_VUEX_BINDINGS]\n    },\n    function (api) {\n      api.addTimelineLayer({\n        id: MUTATIONS_LAYER_ID,\n        label: 'Vuex Mutations',\n        color: COLOR_LIME_500\n      });\n\n      api.addTimelineLayer({\n        id: ACTIONS_LAYER_ID,\n        label: 'Vuex Actions',\n        color: COLOR_LIME_500\n      });\n\n      api.addInspector({\n        id: INSPECTOR_ID,\n        label: 'Vuex',\n        icon: 'storage',\n        treeFilterPlaceholder: 'Filter stores...'\n      });\n\n      api.on.getInspectorTree(function (payload) {\n        if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {\n          if (payload.filter) {\n            var nodes = [];\n            flattenStoreForInspectorTree(nodes, store._modules.root, payload.filter, '');\n            payload.rootNodes = nodes;\n          } else {\n            payload.rootNodes = [\n              formatStoreForInspectorTree(store._modules.root, '')\n            ];\n          }\n        }\n      });\n\n      api.on.getInspectorState(function (payload) {\n        if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {\n          var modulePath = payload.nodeId;\n          makeLocalGetters(store, modulePath);\n          payload.state = formatStoreForInspectorState(\n            getStoreModule(store._modules, modulePath),\n            modulePath === 'root' ? store.getters : store._makeLocalGettersCache,\n            modulePath\n          );\n        }\n      });\n\n      api.on.editInspectorState(function (payload) {\n        if (payload.app === app && payload.inspectorId === INSPECTOR_ID) {\n          var modulePath = payload.nodeId;\n          var path = payload.path;\n          if (modulePath !== 'root') {\n            path = modulePath.split('/').filter(Boolean).concat( path);\n          }\n          store._withCommit(function () {\n            payload.set(store._state.data, path, payload.state.value);\n          });\n        }\n      });\n\n      store.subscribe(function (mutation, state) {\n        var data = {};\n\n        if (mutation.payload) {\n          data.payload = mutation.payload;\n        }\n\n        data.state = state;\n\n        api.notifyComponentUpdate();\n        api.sendInspectorTree(INSPECTOR_ID);\n        api.sendInspectorState(INSPECTOR_ID);\n\n        api.addTimelineEvent({\n          layerId: MUTATIONS_LAYER_ID,\n          event: {\n            time: Date.now(),\n            title: mutation.type,\n            data: data\n          }\n        });\n      });\n\n      store.subscribeAction({\n        before: function (action, state) {\n          var data = {};\n          if (action.payload) {\n            data.payload = action.payload;\n          }\n          action._id = actionId++;\n          action._time = Date.now();\n          data.state = state;\n\n          api.addTimelineEvent({\n            layerId: ACTIONS_LAYER_ID,\n            event: {\n              time: action._time,\n              title: action.type,\n              groupId: action._id,\n              subtitle: 'start',\n              data: data\n            }\n          });\n        },\n        after: function (action, state) {\n          var data = {};\n          var duration = Date.now() - action._time;\n          data.duration = {\n            _custom: {\n              type: 'duration',\n              display: (duration + \"ms\"),\n              tooltip: 'Action duration',\n              value: duration\n            }\n          };\n          if (action.payload) {\n            data.payload = action.payload;\n          }\n          data.state = state;\n\n          api.addTimelineEvent({\n            layerId: ACTIONS_LAYER_ID,\n            event: {\n              time: Date.now(),\n              title: action.type,\n              groupId: action._id,\n              subtitle: 'end',\n              data: data\n            }\n          });\n        }\n      });\n    }\n  );\n}\n\n// extracted from tailwind palette\nvar COLOR_LIME_500 = 0x84cc16;\nvar COLOR_DARK = 0x666666;\nvar COLOR_WHITE = 0xffffff;\n\nvar TAG_NAMESPACED = {\n  label: 'namespaced',\n  textColor: COLOR_WHITE,\n  backgroundColor: COLOR_DARK\n};\n\n/**\n * @param {string} path\n */\nfunction extractNameFromPath (path) {\n  return path && path !== 'root' ? path.split('/').slice(-2, -1)[0] : 'Root'\n}\n\n/**\n * @param {*} module\n * @return {import('@vue/devtools-api').CustomInspectorNode}\n */\nfunction formatStoreForInspectorTree (module, path) {\n  return {\n    id: path || 'root',\n    // all modules end with a `/`, we want the last segment only\n    // cart/ -> cart\n    // nested/cart/ -> cart\n    label: extractNameFromPath(path),\n    tags: module.namespaced ? [TAG_NAMESPACED] : [],\n    children: Object.keys(module._children).map(function (moduleName) { return formatStoreForInspectorTree(\n        module._children[moduleName],\n        path + moduleName + '/'\n      ); }\n    )\n  }\n}\n\n/**\n * @param {import('@vue/devtools-api').CustomInspectorNode[]} result\n * @param {*} module\n * @param {string} filter\n * @param {string} path\n */\nfunction flattenStoreForInspectorTree (result, module, filter, path) {\n  if (path.includes(filter)) {\n    result.push({\n      id: path || 'root',\n      label: path.endsWith('/') ? path.slice(0, path.length - 1) : path || 'Root',\n      tags: module.namespaced ? [TAG_NAMESPACED] : []\n    });\n  }\n  Object.keys(module._children).forEach(function (moduleName) {\n    flattenStoreForInspectorTree(result, module._children[moduleName], filter, path + moduleName + '/');\n  });\n}\n\n/**\n * @param {*} module\n * @return {import('@vue/devtools-api').CustomInspectorState}\n */\nfunction formatStoreForInspectorState (module, getters, path) {\n  getters = path === 'root' ? getters : getters[path];\n  var gettersKeys = Object.keys(getters);\n  var storeState = {\n    state: Object.keys(module.state).map(function (key) { return ({\n      key: key,\n      editable: true,\n      value: module.state[key]\n    }); })\n  };\n\n  if (gettersKeys.length) {\n    var tree = transformPathsToObjectTree(getters);\n    storeState.getters = Object.keys(tree).map(function (key) { return ({\n      key: key.endsWith('/') ? extractNameFromPath(key) : key,\n      editable: false,\n      value: canThrow(function () { return tree[key]; })\n    }); });\n  }\n\n  return storeState\n}\n\nfunction transformPathsToObjectTree (getters) {\n  var result = {};\n  Object.keys(getters).forEach(function (key) {\n    var path = key.split('/');\n    if (path.length > 1) {\n      var target = result;\n      var leafKey = path.pop();\n      path.forEach(function (p) {\n        if (!target[p]) {\n          target[p] = {\n            _custom: {\n              value: {},\n              display: p,\n              tooltip: 'Module',\n              abstract: true\n            }\n          };\n        }\n        target = target[p]._custom.value;\n      });\n      target[leafKey] = canThrow(function () { return getters[key]; });\n    } else {\n      result[key] = canThrow(function () { return getters[key]; });\n    }\n  });\n  return result\n}\n\nfunction getStoreModule (moduleMap, path) {\n  var names = path.split('/').filter(function (n) { return n; });\n  return names.reduce(\n    function (module, moduleName, i) {\n      var child = module[moduleName];\n      if (!child) {\n        throw new Error((\"Missing module \\\"\" + moduleName + \"\\\" for path \\\"\" + path + \"\\\".\"))\n      }\n      return i === names.length - 1 ? child : child._children\n    },\n    path === 'root' ? moduleMap : moduleMap.root._children\n  )\n}\n\nfunction canThrow (cb) {\n  try {\n    return cb()\n  } catch (e) {\n    return e\n  }\n}\n\n// Base data struct for store's module, package with some attribute and method\nvar Module = function Module (rawModule, runtime) {\n  this.runtime = runtime;\n  // Store some children item\n  this._children = Object.create(null);\n  // Store the origin module object which passed by programmer\n  this._rawModule = rawModule;\n  var rawState = rawModule.state;\n\n  // Store the origin module's state\n  this.state = (typeof rawState === 'function' ? rawState() : rawState) || {};\n};\n\nvar prototypeAccessors$1 = { namespaced: { configurable: true } };\n\nprototypeAccessors$1.namespaced.get = function () {\n  return !!this._rawModule.namespaced\n};\n\nModule.prototype.addChild = function addChild (key, module) {\n  this._children[key] = module;\n};\n\nModule.prototype.removeChild = function removeChild (key) {\n  delete this._children[key];\n};\n\nModule.prototype.getChild = function getChild (key) {\n  return this._children[key]\n};\n\nModule.prototype.hasChild = function hasChild (key) {\n  return key in this._children\n};\n\nModule.prototype.update = function update (rawModule) {\n  this._rawModule.namespaced = rawModule.namespaced;\n  if (rawModule.actions) {\n    this._rawModule.actions = rawModule.actions;\n  }\n  if (rawModule.mutations) {\n    this._rawModule.mutations = rawModule.mutations;\n  }\n  if (rawModule.getters) {\n    this._rawModule.getters = rawModule.getters;\n  }\n};\n\nModule.prototype.forEachChild = function forEachChild (fn) {\n  forEachValue(this._children, fn);\n};\n\nModule.prototype.forEachGetter = function forEachGetter (fn) {\n  if (this._rawModule.getters) {\n    forEachValue(this._rawModule.getters, fn);\n  }\n};\n\nModule.prototype.forEachAction = function forEachAction (fn) {\n  if (this._rawModule.actions) {\n    forEachValue(this._rawModule.actions, fn);\n  }\n};\n\nModule.prototype.forEachMutation = function forEachMutation (fn) {\n  if (this._rawModule.mutations) {\n    forEachValue(this._rawModule.mutations, fn);\n  }\n};\n\nObject.defineProperties( Module.prototype, prototypeAccessors$1 );\n\nvar ModuleCollection = function ModuleCollection (rawRootModule) {\n  // register root module (Vuex.Store options)\n  this.register([], rawRootModule, false);\n};\n\nModuleCollection.prototype.get = function get (path) {\n  return path.reduce(function (module, key) {\n    return module.getChild(key)\n  }, this.root)\n};\n\nModuleCollection.prototype.getNamespace = function getNamespace (path) {\n  var module = this.root;\n  return path.reduce(function (namespace, key) {\n    module = module.getChild(key);\n    return namespace + (module.namespaced ? key + '/' : '')\n  }, '')\n};\n\nModuleCollection.prototype.update = function update$1 (rawRootModule) {\n  update([], this.root, rawRootModule);\n};\n\nModuleCollection.prototype.register = function register (path, rawModule, runtime) {\n    var this$1$1 = this;\n    if ( runtime === void 0 ) runtime = true;\n\n  if ((process.env.NODE_ENV !== 'production')) {\n    assertRawModule(path, rawModule);\n  }\n\n  var newModule = new Module(rawModule, runtime);\n  if (path.length === 0) {\n    this.root = newModule;\n  } else {\n    var parent = this.get(path.slice(0, -1));\n    parent.addChild(path[path.length - 1], newModule);\n  }\n\n  // register nested modules\n  if (rawModule.modules) {\n    forEachValue(rawModule.modules, function (rawChildModule, key) {\n      this$1$1.register(path.concat(key), rawChildModule, runtime);\n    });\n  }\n};\n\nModuleCollection.prototype.unregister = function unregister (path) {\n  var parent = this.get(path.slice(0, -1));\n  var key = path[path.length - 1];\n  var child = parent.getChild(key);\n\n  if (!child) {\n    if ((process.env.NODE_ENV !== 'production')) {\n      console.warn(\n        \"[vuex] trying to unregister module '\" + key + \"', which is \" +\n        \"not registered\"\n      );\n    }\n    return\n  }\n\n  if (!child.runtime) {\n    return\n  }\n\n  parent.removeChild(key);\n};\n\nModuleCollection.prototype.isRegistered = function isRegistered (path) {\n  var parent = this.get(path.slice(0, -1));\n  var key = path[path.length - 1];\n\n  if (parent) {\n    return parent.hasChild(key)\n  }\n\n  return false\n};\n\nfunction update (path, targetModule, newModule) {\n  if ((process.env.NODE_ENV !== 'production')) {\n    assertRawModule(path, newModule);\n  }\n\n  // update target module\n  targetModule.update(newModule);\n\n  // update nested modules\n  if (newModule.modules) {\n    for (var key in newModule.modules) {\n      if (!targetModule.getChild(key)) {\n        if ((process.env.NODE_ENV !== 'production')) {\n          console.warn(\n            \"[vuex] trying to add a new module '\" + key + \"' on hot reloading, \" +\n            'manual reload is needed'\n          );\n        }\n        return\n      }\n      update(\n        path.concat(key),\n        targetModule.getChild(key),\n        newModule.modules[key]\n      );\n    }\n  }\n}\n\nvar functionAssert = {\n  assert: function (value) { return typeof value === 'function'; },\n  expected: 'function'\n};\n\nvar objectAssert = {\n  assert: function (value) { return typeof value === 'function' ||\n    (typeof value === 'object' && typeof value.handler === 'function'); },\n  expected: 'function or object with \"handler\" function'\n};\n\nvar assertTypes = {\n  getters: functionAssert,\n  mutations: functionAssert,\n  actions: objectAssert\n};\n\nfunction assertRawModule (path, rawModule) {\n  Object.keys(assertTypes).forEach(function (key) {\n    if (!rawModule[key]) { return }\n\n    var assertOptions = assertTypes[key];\n\n    forEachValue(rawModule[key], function (value, type) {\n      assert(\n        assertOptions.assert(value),\n        makeAssertionMessage(path, key, type, value, assertOptions.expected)\n      );\n    });\n  });\n}\n\nfunction makeAssertionMessage (path, key, type, value, expected) {\n  var buf = key + \" should be \" + expected + \" but \\\"\" + key + \".\" + type + \"\\\"\";\n  if (path.length > 0) {\n    buf += \" in module \\\"\" + (path.join('.')) + \"\\\"\";\n  }\n  buf += \" is \" + (JSON.stringify(value)) + \".\";\n  return buf\n}\n\nfunction createStore (options) {\n  return new Store(options)\n}\n\nvar Store = function Store (options) {\n  var this$1$1 = this;\n  if ( options === void 0 ) options = {};\n\n  if ((process.env.NODE_ENV !== 'production')) {\n    assert(typeof Promise !== 'undefined', \"vuex requires a Promise polyfill in this browser.\");\n    assert(this instanceof Store, \"store must be called with the new operator.\");\n  }\n\n  var plugins = options.plugins; if ( plugins === void 0 ) plugins = [];\n  var strict = options.strict; if ( strict === void 0 ) strict = false;\n  var devtools = options.devtools;\n\n  // store internal state\n  this._committing = false;\n  this._actions = Object.create(null);\n  this._actionSubscribers = [];\n  this._mutations = Object.create(null);\n  this._wrappedGetters = Object.create(null);\n  this._modules = new ModuleCollection(options);\n  this._modulesNamespaceMap = Object.create(null);\n  this._subscribers = [];\n  this._makeLocalGettersCache = Object.create(null);\n\n  // EffectScope instance. when registering new getters, we wrap them inside\n  // EffectScope so that getters (computed) would not be destroyed on\n  // component unmount.\n  this._scope = null;\n\n  this._devtools = devtools;\n\n  // bind commit and dispatch to self\n  var store = this;\n  var ref = this;\n  var dispatch = ref.dispatch;\n  var commit = ref.commit;\n  this.dispatch = function boundDispatch (type, payload) {\n    return dispatch.call(store, type, payload)\n  };\n  this.commit = function boundCommit (type, payload, options) {\n    return commit.call(store, type, payload, options)\n  };\n\n  // strict mode\n  this.strict = strict;\n\n  var state = this._modules.root.state;\n\n  // init root module.\n  // this also recursively registers all sub-modules\n  // and collects all module getters inside this._wrappedGetters\n  installModule(this, state, [], this._modules.root);\n\n  // initialize the store state, which is responsible for the reactivity\n  // (also registers _wrappedGetters as computed properties)\n  resetStoreState(this, state);\n\n  // apply plugins\n  plugins.forEach(function (plugin) { return plugin(this$1$1); });\n};\n\nvar prototypeAccessors = { state: { configurable: true } };\n\nStore.prototype.install = function install (app, injectKey) {\n  app.provide(injectKey || storeKey, this);\n  app.config.globalProperties.$store = this;\n\n  var useDevtools = this._devtools !== undefined\n    ? this._devtools\n    : (process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__;\n\n  if (useDevtools) {\n    addDevtools(app, this);\n  }\n};\n\nprototypeAccessors.state.get = function () {\n  return this._state.data\n};\n\nprototypeAccessors.state.set = function (v) {\n  if ((process.env.NODE_ENV !== 'production')) {\n    assert(false, \"use store.replaceState() to explicit replace store state.\");\n  }\n};\n\nStore.prototype.commit = function commit (_type, _payload, _options) {\n    var this$1$1 = this;\n\n  // check object-style commit\n  var ref = unifyObjectStyle(_type, _payload, _options);\n    var type = ref.type;\n    var payload = ref.payload;\n    var options = ref.options;\n\n  var mutation = { type: type, payload: payload };\n  var entry = this._mutations[type];\n  if (!entry) {\n    if ((process.env.NODE_ENV !== 'production')) {\n      console.error((\"[vuex] unknown mutation type: \" + type));\n    }\n    return\n  }\n  this._withCommit(function () {\n    entry.forEach(function commitIterator (handler) {\n      handler(payload);\n    });\n  });\n\n  this._subscribers\n    .slice() // shallow copy to prevent iterator invalidation if subscriber synchronously calls unsubscribe\n    .forEach(function (sub) { return sub(mutation, this$1$1.state); });\n\n  if (\n    (process.env.NODE_ENV !== 'production') &&\n    options && options.silent\n  ) {\n    console.warn(\n      \"[vuex] mutation type: \" + type + \". Silent option has been removed. \" +\n      'Use the filter functionality in the vue-devtools'\n    );\n  }\n};\n\nStore.prototype.dispatch = function dispatch (_type, _payload) {\n    var this$1$1 = this;\n\n  // check object-style dispatch\n  var ref = unifyObjectStyle(_type, _payload);\n    var type = ref.type;\n    var payload = ref.payload;\n\n  var action = { type: type, payload: payload };\n  var entry = this._actions[type];\n  if (!entry) {\n    if ((process.env.NODE_ENV !== 'production')) {\n      console.error((\"[vuex] unknown action type: \" + type));\n    }\n    return\n  }\n\n  try {\n    this._actionSubscribers\n      .slice() // shallow copy to prevent iterator invalidation if subscriber synchronously calls unsubscribe\n      .filter(function (sub) { return sub.before; })\n      .forEach(function (sub) { return sub.before(action, this$1$1.state); });\n  } catch (e) {\n    if ((process.env.NODE_ENV !== 'production')) {\n      console.warn(\"[vuex] error in before action subscribers: \");\n      console.error(e);\n    }\n  }\n\n  var result = entry.length > 1\n    ? Promise.all(entry.map(function (handler) { return handler(payload); }))\n    : entry[0](payload);\n\n  return new Promise(function (resolve, reject) {\n    result.then(function (res) {\n      try {\n        this$1$1._actionSubscribers\n          .filter(function (sub) { return sub.after; })\n          .forEach(function (sub) { return sub.after(action, this$1$1.state); });\n      } catch (e) {\n        if ((process.env.NODE_ENV !== 'production')) {\n          console.warn(\"[vuex] error in after action subscribers: \");\n          console.error(e);\n        }\n      }\n      resolve(res);\n    }, function (error) {\n      try {\n        this$1$1._actionSubscribers\n          .filter(function (sub) { return sub.error; })\n          .forEach(function (sub) { return sub.error(action, this$1$1.state, error); });\n      } catch (e) {\n        if ((process.env.NODE_ENV !== 'production')) {\n          console.warn(\"[vuex] error in error action subscribers: \");\n          console.error(e);\n        }\n      }\n      reject(error);\n    });\n  })\n};\n\nStore.prototype.subscribe = function subscribe (fn, options) {\n  return genericSubscribe(fn, this._subscribers, options)\n};\n\nStore.prototype.subscribeAction = function subscribeAction (fn, options) {\n  var subs = typeof fn === 'function' ? { before: fn } : fn;\n  return genericSubscribe(subs, this._actionSubscribers, options)\n};\n\nStore.prototype.watch = function watch$1 (getter, cb, options) {\n    var this$1$1 = this;\n\n  if ((process.env.NODE_ENV !== 'production')) {\n    assert(typeof getter === 'function', \"store.watch only accepts a function.\");\n  }\n  return watch(function () { return getter(this$1$1.state, this$1$1.getters); }, cb, Object.assign({}, options))\n};\n\nStore.prototype.replaceState = function replaceState (state) {\n    var this$1$1 = this;\n\n  this._withCommit(function () {\n    this$1$1._state.data = state;\n  });\n};\n\nStore.prototype.registerModule = function registerModule (path, rawModule, options) {\n    if ( options === void 0 ) options = {};\n\n  if (typeof path === 'string') { path = [path]; }\n\n  if ((process.env.NODE_ENV !== 'production')) {\n    assert(Array.isArray(path), \"module path must be a string or an Array.\");\n    assert(path.length > 0, 'cannot register the root module by using registerModule.');\n  }\n\n  this._modules.register(path, rawModule);\n  installModule(this, this.state, path, this._modules.get(path), options.preserveState);\n  // reset store to update getters...\n  resetStoreState(this, this.state);\n};\n\nStore.prototype.unregisterModule = function unregisterModule (path) {\n    var this$1$1 = this;\n\n  if (typeof path === 'string') { path = [path]; }\n\n  if ((process.env.NODE_ENV !== 'production')) {\n    assert(Array.isArray(path), \"module path must be a string or an Array.\");\n  }\n\n  this._modules.unregister(path);\n  this._withCommit(function () {\n    var parentState = getNestedState(this$1$1.state, path.slice(0, -1));\n    delete parentState[path[path.length - 1]];\n  });\n  resetStore(this);\n};\n\nStore.prototype.hasModule = function hasModule (path) {\n  if (typeof path === 'string') { path = [path]; }\n\n  if ((process.env.NODE_ENV !== 'production')) {\n    assert(Array.isArray(path), \"module path must be a string or an Array.\");\n  }\n\n  return this._modules.isRegistered(path)\n};\n\nStore.prototype.hotUpdate = function hotUpdate (newOptions) {\n  this._modules.update(newOptions);\n  resetStore(this, true);\n};\n\nStore.prototype._withCommit = function _withCommit (fn) {\n  var committing = this._committing;\n  this._committing = true;\n  fn();\n  this._committing = committing;\n};\n\nObject.defineProperties( Store.prototype, prototypeAccessors );\n\n/**\n * Reduce the code which written in Vue.js for getting the state.\n * @param {String} [namespace] - Module's namespace\n * @param {Object|Array} states # Object's item can be a function which accept state and getters for param, you can do something for state and getters in it.\n * @param {Object}\n */\nvar mapState = normalizeNamespace(function (namespace, states) {\n  var res = {};\n  if ((process.env.NODE_ENV !== 'production') && !isValidMap(states)) {\n    console.error('[vuex] mapState: mapper parameter must be either an Array or an Object');\n  }\n  normalizeMap(states).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    res[key] = function mappedState () {\n      var state = this.$store.state;\n      var getters = this.$store.getters;\n      if (namespace) {\n        var module = getModuleByNamespace(this.$store, 'mapState', namespace);\n        if (!module) {\n          return\n        }\n        state = module.context.state;\n        getters = module.context.getters;\n      }\n      return typeof val === 'function'\n        ? val.call(this, state, getters)\n        : state[val]\n    };\n    // mark vuex getter for devtools\n    res[key].vuex = true;\n  });\n  return res\n});\n\n/**\n * Reduce the code which written in Vue.js for committing the mutation\n * @param {String} [namespace] - Module's namespace\n * @param {Object|Array} mutations # Object's item can be a function which accept `commit` function as the first param, it can accept another params. You can commit mutation and do any other things in this function. specially, You need to pass anthor params from the mapped function.\n * @return {Object}\n */\nvar mapMutations = normalizeNamespace(function (namespace, mutations) {\n  var res = {};\n  if ((process.env.NODE_ENV !== 'production') && !isValidMap(mutations)) {\n    console.error('[vuex] mapMutations: mapper parameter must be either an Array or an Object');\n  }\n  normalizeMap(mutations).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    res[key] = function mappedMutation () {\n      var args = [], len = arguments.length;\n      while ( len-- ) args[ len ] = arguments[ len ];\n\n      // Get the commit method from store\n      var commit = this.$store.commit;\n      if (namespace) {\n        var module = getModuleByNamespace(this.$store, 'mapMutations', namespace);\n        if (!module) {\n          return\n        }\n        commit = module.context.commit;\n      }\n      return typeof val === 'function'\n        ? val.apply(this, [commit].concat(args))\n        : commit.apply(this.$store, [val].concat(args))\n    };\n  });\n  return res\n});\n\n/**\n * Reduce the code which written in Vue.js for getting the getters\n * @param {String} [namespace] - Module's namespace\n * @param {Object|Array} getters\n * @return {Object}\n */\nvar mapGetters = normalizeNamespace(function (namespace, getters) {\n  var res = {};\n  if ((process.env.NODE_ENV !== 'production') && !isValidMap(getters)) {\n    console.error('[vuex] mapGetters: mapper parameter must be either an Array or an Object');\n  }\n  normalizeMap(getters).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    // The namespace has been mutated by normalizeNamespace\n    val = namespace + val;\n    res[key] = function mappedGetter () {\n      if (namespace && !getModuleByNamespace(this.$store, 'mapGetters', namespace)) {\n        return\n      }\n      if ((process.env.NODE_ENV !== 'production') && !(val in this.$store.getters)) {\n        console.error((\"[vuex] unknown getter: \" + val));\n        return\n      }\n      return this.$store.getters[val]\n    };\n    // mark vuex getter for devtools\n    res[key].vuex = true;\n  });\n  return res\n});\n\n/**\n * Reduce the code which written in Vue.js for dispatch the action\n * @param {String} [namespace] - Module's namespace\n * @param {Object|Array} actions # Object's item can be a function which accept `dispatch` function as the first param, it can accept anthor params. You can dispatch action and do any other things in this function. specially, You need to pass anthor params from the mapped function.\n * @return {Object}\n */\nvar mapActions = normalizeNamespace(function (namespace, actions) {\n  var res = {};\n  if ((process.env.NODE_ENV !== 'production') && !isValidMap(actions)) {\n    console.error('[vuex] mapActions: mapper parameter must be either an Array or an Object');\n  }\n  normalizeMap(actions).forEach(function (ref) {\n    var key = ref.key;\n    var val = ref.val;\n\n    res[key] = function mappedAction () {\n      var args = [], len = arguments.length;\n      while ( len-- ) args[ len ] = arguments[ len ];\n\n      // get dispatch function from store\n      var dispatch = this.$store.dispatch;\n      if (namespace) {\n        var module = getModuleByNamespace(this.$store, 'mapActions', namespace);\n        if (!module) {\n          return\n        }\n        dispatch = module.context.dispatch;\n      }\n      return typeof val === 'function'\n        ? val.apply(this, [dispatch].concat(args))\n        : dispatch.apply(this.$store, [val].concat(args))\n    };\n  });\n  return res\n});\n\n/**\n * Rebinding namespace param for mapXXX function in special scoped, and return them by simple object\n * @param {String} namespace\n * @return {Object}\n */\nvar createNamespacedHelpers = function (namespace) { return ({\n  mapState: mapState.bind(null, namespace),\n  mapGetters: mapGetters.bind(null, namespace),\n  mapMutations: mapMutations.bind(null, namespace),\n  mapActions: mapActions.bind(null, namespace)\n}); };\n\n/**\n * Normalize the map\n * normalizeMap([1, 2, 3]) => [ { key: 1, val: 1 }, { key: 2, val: 2 }, { key: 3, val: 3 } ]\n * normalizeMap({a: 1, b: 2, c: 3}) => [ { key: 'a', val: 1 }, { key: 'b', val: 2 }, { key: 'c', val: 3 } ]\n * @param {Array|Object} map\n * @return {Object}\n */\nfunction normalizeMap (map) {\n  if (!isValidMap(map)) {\n    return []\n  }\n  return Array.isArray(map)\n    ? map.map(function (key) { return ({ key: key, val: key }); })\n    : Object.keys(map).map(function (key) { return ({ key: key, val: map[key] }); })\n}\n\n/**\n * Validate whether given map is valid or not\n * @param {*} map\n * @return {Boolean}\n */\nfunction isValidMap (map) {\n  return Array.isArray(map) || isObject(map)\n}\n\n/**\n * Return a function expect two param contains namespace and map. it will normalize the namespace and then the param's function will handle the new namespace and the map.\n * @param {Function} fn\n * @return {Function}\n */\nfunction normalizeNamespace (fn) {\n  return function (namespace, map) {\n    if (typeof namespace !== 'string') {\n      map = namespace;\n      namespace = '';\n    } else if (namespace.charAt(namespace.length - 1) !== '/') {\n      namespace += '/';\n    }\n    return fn(namespace, map)\n  }\n}\n\n/**\n * Search a special module from store by namespace. if module not exist, print error message.\n * @param {Object} store\n * @param {String} helper\n * @param {String} namespace\n * @return {Object}\n */\nfunction getModuleByNamespace (store, helper, namespace) {\n  var module = store._modulesNamespaceMap[namespace];\n  if ((process.env.NODE_ENV !== 'production') && !module) {\n    console.error((\"[vuex] module namespace not found in \" + helper + \"(): \" + namespace));\n  }\n  return module\n}\n\n// Credits: borrowed code from fcomb/redux-logger\n\nfunction createLogger (ref) {\n  if ( ref === void 0 ) ref = {};\n  var collapsed = ref.collapsed; if ( collapsed === void 0 ) collapsed = true;\n  var filter = ref.filter; if ( filter === void 0 ) filter = function (mutation, stateBefore, stateAfter) { return true; };\n  var transformer = ref.transformer; if ( transformer === void 0 ) transformer = function (state) { return state; };\n  var mutationTransformer = ref.mutationTransformer; if ( mutationTransformer === void 0 ) mutationTransformer = function (mut) { return mut; };\n  var actionFilter = ref.actionFilter; if ( actionFilter === void 0 ) actionFilter = function (action, state) { return true; };\n  var actionTransformer = ref.actionTransformer; if ( actionTransformer === void 0 ) actionTransformer = function (act) { return act; };\n  var logMutations = ref.logMutations; if ( logMutations === void 0 ) logMutations = true;\n  var logActions = ref.logActions; if ( logActions === void 0 ) logActions = true;\n  var logger = ref.logger; if ( logger === void 0 ) logger = console;\n\n  return function (store) {\n    var prevState = deepCopy(store.state);\n\n    if (typeof logger === 'undefined') {\n      return\n    }\n\n    if (logMutations) {\n      store.subscribe(function (mutation, state) {\n        var nextState = deepCopy(state);\n\n        if (filter(mutation, prevState, nextState)) {\n          var formattedTime = getFormattedTime();\n          var formattedMutation = mutationTransformer(mutation);\n          var message = \"mutation \" + (mutation.type) + formattedTime;\n\n          startMessage(logger, message, collapsed);\n          logger.log('%c prev state', 'color: #9E9E9E; font-weight: bold', transformer(prevState));\n          logger.log('%c mutation', 'color: #03A9F4; font-weight: bold', formattedMutation);\n          logger.log('%c next state', 'color: #4CAF50; font-weight: bold', transformer(nextState));\n          endMessage(logger);\n        }\n\n        prevState = nextState;\n      });\n    }\n\n    if (logActions) {\n      store.subscribeAction(function (action, state) {\n        if (actionFilter(action, state)) {\n          var formattedTime = getFormattedTime();\n          var formattedAction = actionTransformer(action);\n          var message = \"action \" + (action.type) + formattedTime;\n\n          startMessage(logger, message, collapsed);\n          logger.log('%c action', 'color: #03A9F4; font-weight: bold', formattedAction);\n          endMessage(logger);\n        }\n      });\n    }\n  }\n}\n\nfunction startMessage (logger, message, collapsed) {\n  var startMessage = collapsed\n    ? logger.groupCollapsed\n    : logger.group;\n\n  // render\n  try {\n    startMessage.call(logger, message);\n  } catch (e) {\n    logger.log(message);\n  }\n}\n\nfunction endMessage (logger) {\n  try {\n    logger.groupEnd();\n  } catch (e) {\n    logger.log('—— log end ——');\n  }\n}\n\nfunction getFormattedTime () {\n  var time = new Date();\n  return (\" @ \" + (pad(time.getHours(), 2)) + \":\" + (pad(time.getMinutes(), 2)) + \":\" + (pad(time.getSeconds(), 2)) + \".\" + (pad(time.getMilliseconds(), 3)))\n}\n\nfunction repeat (str, times) {\n  return (new Array(times + 1)).join(str)\n}\n\nfunction pad (num, maxLength) {\n  return repeat('0', maxLength - num.toString().length) + num\n}\n\nvar index = {\n  version: '4.1.0',\n  Store: Store,\n  storeKey: storeKey,\n  createStore: createStore,\n  useStore: useStore,\n  mapState: mapState,\n  mapMutations: mapMutations,\n  mapGetters: mapGetters,\n  mapActions: mapActions,\n  createNamespacedHelpers: createNamespacedHelpers,\n  createLogger: createLogger\n};\n\nexport default index;\nexport { Store, createLogger, createNamespacedHelpers, createStore, mapActions, mapGetters, mapMutations, mapState, storeKey, useStore };\n","import { noop, makeDestructurable, camelize, toValue, isClient, isObject, tryOnScopeDispose, isIOS, tryOnMounted, notNullish, objectOmit, promiseTimeout, until, increaseWithUnit, objectEntries, createSingletonPromise, useTimeoutFn, pausableWatch, toRef, createEventHook, computedWithControl, timestamp, pausableFilter, watchIgnorable, debounceFilter, createFilterWrapper, bypassFilter, toRefs, useIntervalFn, containsProp, hasOwn, throttleFilter, useDebounceFn, useThrottleFn, tryOnUnmounted, clamp, syncRef, objectPick, watchWithFilter, tryOnBeforeUnmount, identity, isDef, whenever, isWorker } from '@vueuse/shared';\nexport * from '@vueuse/shared';\nimport { isRef, ref, shallowRef, watchEffect, computed, inject, isVue3, version, defineComponent, h, TransitionGroup, shallowReactive, Fragment, watch, getCurrentInstance, customRef, onUpdated, onMounted, isVue2, readonly, reactive, toRaw, nextTick, markRaw, unref, getCurrentScope, set, del, isReadonly, onBeforeUpdate } from 'vue-demi';\n\nfunction computedAsync(evaluationCallback, initialState, optionsOrRef) {\n  let options;\n  if (isRef(optionsOrRef)) {\n    options = {\n      evaluating: optionsOrRef\n    };\n  } else {\n    options = optionsOrRef || {};\n  }\n  const {\n    lazy = false,\n    evaluating = void 0,\n    shallow = true,\n    onError = noop\n  } = options;\n  const started = ref(!lazy);\n  const current = shallow ? shallowRef(initialState) : ref(initialState);\n  let counter = 0;\n  watchEffect(async (onInvalidate) => {\n    if (!started.value)\n      return;\n    counter++;\n    const counterAtBeginning = counter;\n    let hasFinished = false;\n    if (evaluating) {\n      Promise.resolve().then(() => {\n        evaluating.value = true;\n      });\n    }\n    try {\n      const result = await evaluationCallback((cancelCallback) => {\n        onInvalidate(() => {\n          if (evaluating)\n            evaluating.value = false;\n          if (!hasFinished)\n            cancelCallback();\n        });\n      });\n      if (counterAtBeginning === counter)\n        current.value = result;\n    } catch (e) {\n      onError(e);\n    } finally {\n      if (evaluating && counterAtBeginning === counter)\n        evaluating.value = false;\n      hasFinished = true;\n    }\n  });\n  if (lazy) {\n    return computed(() => {\n      started.value = true;\n      return current.value;\n    });\n  } else {\n    return current;\n  }\n}\n\nfunction computedInject(key, options, defaultSource, treatDefaultAsFactory) {\n  let source = inject(key);\n  if (defaultSource)\n    source = inject(key, defaultSource);\n  if (treatDefaultAsFactory)\n    source = inject(key, defaultSource, treatDefaultAsFactory);\n  if (typeof options === \"function\") {\n    return computed((ctx) => options(source, ctx));\n  } else {\n    return computed({\n      get: (ctx) => options.get(source, ctx),\n      set: options.set\n    });\n  }\n}\n\nfunction createReusableTemplate(options = {}) {\n  if (!isVue3 && !version.startsWith(\"2.7.\")) {\n    if (process.env.NODE_ENV !== \"production\")\n      throw new Error(\"[VueUse] createReusableTemplate only works in Vue 2.7 or above.\");\n    return;\n  }\n  const {\n    inheritAttrs = true\n  } = options;\n  const render = shallowRef();\n  const define = /* #__PURE__ */ defineComponent({\n    setup(_, { slots }) {\n      return () => {\n        render.value = slots.default;\n      };\n    }\n  });\n  const reuse = /* #__PURE__ */ defineComponent({\n    inheritAttrs,\n    setup(_, { attrs, slots }) {\n      return () => {\n        var _a;\n        if (!render.value && process.env.NODE_ENV !== \"production\")\n          throw new Error(\"[VueUse] Failed to find the definition of reusable template\");\n        const vnode = (_a = render.value) == null ? void 0 : _a.call(render, { ...keysToCamelKebabCase(attrs), $slots: slots });\n        return inheritAttrs && (vnode == null ? void 0 : vnode.length) === 1 ? vnode[0] : vnode;\n      };\n    }\n  });\n  return makeDestructurable(\n    { define, reuse },\n    [define, reuse]\n  );\n}\nfunction keysToCamelKebabCase(obj) {\n  const newObj = {};\n  for (const key in obj)\n    newObj[camelize(key)] = obj[key];\n  return newObj;\n}\n\nfunction createTemplatePromise(options = {}) {\n  if (!isVue3) {\n    if (process.env.NODE_ENV !== \"production\")\n      throw new Error(\"[VueUse] createTemplatePromise only works in Vue 3 or above.\");\n    return;\n  }\n  let index = 0;\n  const instances = ref([]);\n  function create(...args) {\n    const props = shallowReactive({\n      key: index++,\n      args,\n      promise: void 0,\n      resolve: () => {\n      },\n      reject: () => {\n      },\n      isResolving: false,\n      options\n    });\n    instances.value.push(props);\n    props.promise = new Promise((_resolve, _reject) => {\n      props.resolve = (v) => {\n        props.isResolving = true;\n        return _resolve(v);\n      };\n      props.reject = _reject;\n    }).finally(() => {\n      props.promise = void 0;\n      const index2 = instances.value.indexOf(props);\n      if (index2 !== -1)\n        instances.value.splice(index2, 1);\n    });\n    return props.promise;\n  }\n  function start(...args) {\n    if (options.singleton && instances.value.length > 0)\n      return instances.value[0].promise;\n    return create(...args);\n  }\n  const component = /* #__PURE__ */ defineComponent((_, { slots }) => {\n    const renderList = () => instances.value.map((props) => {\n      var _a;\n      return h(Fragment, { key: props.key }, (_a = slots.default) == null ? void 0 : _a.call(slots, props));\n    });\n    if (options.transition)\n      return () => h(TransitionGroup, options.transition, renderList);\n    return renderList;\n  });\n  component.start = start;\n  return component;\n}\n\nfunction createUnrefFn(fn) {\n  return function(...args) {\n    return fn.apply(this, args.map((i) => toValue(i)));\n  };\n}\n\nconst defaultWindow = isClient ? window : void 0;\nconst defaultDocument = isClient ? window.document : void 0;\nconst defaultNavigator = isClient ? window.navigator : void 0;\nconst defaultLocation = isClient ? window.location : void 0;\n\nfunction unrefElement(elRef) {\n  var _a;\n  const plain = toValue(elRef);\n  return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;\n}\n\nfunction useEventListener(...args) {\n  let target;\n  let events;\n  let listeners;\n  let options;\n  if (typeof args[0] === \"string\" || Array.isArray(args[0])) {\n    [events, listeners, options] = args;\n    target = defaultWindow;\n  } else {\n    [target, events, listeners, options] = args;\n  }\n  if (!target)\n    return noop;\n  if (!Array.isArray(events))\n    events = [events];\n  if (!Array.isArray(listeners))\n    listeners = [listeners];\n  const cleanups = [];\n  const cleanup = () => {\n    cleanups.forEach((fn) => fn());\n    cleanups.length = 0;\n  };\n  const register = (el, event, listener, options2) => {\n    el.addEventListener(event, listener, options2);\n    return () => el.removeEventListener(event, listener, options2);\n  };\n  const stopWatch = watch(\n    () => [unrefElement(target), toValue(options)],\n    ([el, options2]) => {\n      cleanup();\n      if (!el)\n        return;\n      const optionsClone = isObject(options2) ? { ...options2 } : options2;\n      cleanups.push(\n        ...events.flatMap((event) => {\n          return listeners.map((listener) => register(el, event, listener, optionsClone));\n        })\n      );\n    },\n    { immediate: true, flush: \"post\" }\n  );\n  const stop = () => {\n    stopWatch();\n    cleanup();\n  };\n  tryOnScopeDispose(stop);\n  return stop;\n}\n\nlet _iOSWorkaround = false;\nfunction onClickOutside(target, handler, options = {}) {\n  const { window = defaultWindow, ignore = [], capture = true, detectIframe = false } = options;\n  if (!window)\n    return noop;\n  if (isIOS && !_iOSWorkaround) {\n    _iOSWorkaround = true;\n    Array.from(window.document.body.children).forEach((el) => el.addEventListener(\"click\", noop));\n    window.document.documentElement.addEventListener(\"click\", noop);\n  }\n  let shouldListen = true;\n  const shouldIgnore = (event) => {\n    return toValue(ignore).some((target2) => {\n      if (typeof target2 === \"string\") {\n        return Array.from(window.document.querySelectorAll(target2)).some((el) => el === event.target || event.composedPath().includes(el));\n      } else {\n        const el = unrefElement(target2);\n        return el && (event.target === el || event.composedPath().includes(el));\n      }\n    });\n  };\n  const listener = (event) => {\n    const el = unrefElement(target);\n    if (!el || el === event.target || event.composedPath().includes(el))\n      return;\n    if (event.detail === 0)\n      shouldListen = !shouldIgnore(event);\n    if (!shouldListen) {\n      shouldListen = true;\n      return;\n    }\n    handler(event);\n  };\n  let isProcessingClick = false;\n  const cleanup = [\n    useEventListener(window, \"click\", (event) => {\n      if (!isProcessingClick) {\n        isProcessingClick = true;\n        setTimeout(() => {\n          isProcessingClick = false;\n        }, 0);\n        listener(event);\n      }\n    }, { passive: true, capture }),\n    useEventListener(window, \"pointerdown\", (e) => {\n      const el = unrefElement(target);\n      shouldListen = !shouldIgnore(e) && !!(el && !e.composedPath().includes(el));\n    }, { passive: true }),\n    detectIframe && useEventListener(window, \"blur\", (event) => {\n      setTimeout(() => {\n        var _a;\n        const el = unrefElement(target);\n        if (((_a = window.document.activeElement) == null ? void 0 : _a.tagName) === \"IFRAME\" && !(el == null ? void 0 : el.contains(window.document.activeElement))) {\n          handler(event);\n        }\n      }, 0);\n    })\n  ].filter(Boolean);\n  const stop = () => cleanup.forEach((fn) => fn());\n  return stop;\n}\n\nfunction createKeyPredicate(keyFilter) {\n  if (typeof keyFilter === \"function\")\n    return keyFilter;\n  else if (typeof keyFilter === \"string\")\n    return (event) => event.key === keyFilter;\n  else if (Array.isArray(keyFilter))\n    return (event) => keyFilter.includes(event.key);\n  return () => true;\n}\nfunction onKeyStroke(...args) {\n  let key;\n  let handler;\n  let options = {};\n  if (args.length === 3) {\n    key = args[0];\n    handler = args[1];\n    options = args[2];\n  } else if (args.length === 2) {\n    if (typeof args[1] === \"object\") {\n      key = true;\n      handler = args[0];\n      options = args[1];\n    } else {\n      key = args[0];\n      handler = args[1];\n    }\n  } else {\n    key = true;\n    handler = args[0];\n  }\n  const {\n    target = defaultWindow,\n    eventName = \"keydown\",\n    passive = false,\n    dedupe = false\n  } = options;\n  const predicate = createKeyPredicate(key);\n  const listener = (e) => {\n    if (e.repeat && toValue(dedupe))\n      return;\n    if (predicate(e))\n      handler(e);\n  };\n  return useEventListener(target, eventName, listener, passive);\n}\nfunction onKeyDown(key, handler, options = {}) {\n  return onKeyStroke(key, handler, { ...options, eventName: \"keydown\" });\n}\nfunction onKeyPressed(key, handler, options = {}) {\n  return onKeyStroke(key, handler, { ...options, eventName: \"keypress\" });\n}\nfunction onKeyUp(key, handler, options = {}) {\n  return onKeyStroke(key, handler, { ...options, eventName: \"keyup\" });\n}\n\nconst DEFAULT_DELAY = 500;\nconst DEFAULT_THRESHOLD = 10;\nfunction onLongPress(target, handler, options) {\n  var _a, _b;\n  const elementRef = computed(() => unrefElement(target));\n  let timeout;\n  let posStart;\n  let startTimestamp;\n  let hasLongPressed = false;\n  function clear() {\n    if (timeout) {\n      clearTimeout(timeout);\n      timeout = void 0;\n    }\n    posStart = void 0;\n    startTimestamp = void 0;\n    hasLongPressed = false;\n  }\n  function onRelease(ev) {\n    var _a2, _b2, _c;\n    const [_startTimestamp, _posStart, _hasLongPressed] = [startTimestamp, posStart, hasLongPressed];\n    clear();\n    if (!(options == null ? void 0 : options.onMouseUp) || !_posStart || !_startTimestamp)\n      return;\n    if (((_a2 = options == null ? void 0 : options.modifiers) == null ? void 0 : _a2.self) && ev.target !== elementRef.value)\n      return;\n    if ((_b2 = options == null ? void 0 : options.modifiers) == null ? void 0 : _b2.prevent)\n      ev.preventDefault();\n    if ((_c = options == null ? void 0 : options.modifiers) == null ? void 0 : _c.stop)\n      ev.stopPropagation();\n    const dx = ev.x - _posStart.x;\n    const dy = ev.y - _posStart.y;\n    const distance = Math.sqrt(dx * dx + dy * dy);\n    options.onMouseUp(ev.timeStamp - _startTimestamp, distance, _hasLongPressed);\n  }\n  function onDown(ev) {\n    var _a2, _b2, _c, _d;\n    if (((_a2 = options == null ? void 0 : options.modifiers) == null ? void 0 : _a2.self) && ev.target !== elementRef.value)\n      return;\n    clear();\n    if ((_b2 = options == null ? void 0 : options.modifiers) == null ? void 0 : _b2.prevent)\n      ev.preventDefault();\n    if ((_c = options == null ? void 0 : options.modifiers) == null ? void 0 : _c.stop)\n      ev.stopPropagation();\n    posStart = {\n      x: ev.x,\n      y: ev.y\n    };\n    startTimestamp = ev.timeStamp;\n    timeout = setTimeout(\n      () => {\n        hasLongPressed = true;\n        handler(ev);\n      },\n      (_d = options == null ? void 0 : options.delay) != null ? _d : DEFAULT_DELAY\n    );\n  }\n  function onMove(ev) {\n    var _a2, _b2, _c, _d;\n    if (((_a2 = options == null ? void 0 : options.modifiers) == null ? void 0 : _a2.self) && ev.target !== elementRef.value)\n      return;\n    if (!posStart || (options == null ? void 0 : options.distanceThreshold) === false)\n      return;\n    if ((_b2 = options == null ? void 0 : options.modifiers) == null ? void 0 : _b2.prevent)\n      ev.preventDefault();\n    if ((_c = options == null ? void 0 : options.modifiers) == null ? void 0 : _c.stop)\n      ev.stopPropagation();\n    const dx = ev.x - posStart.x;\n    const dy = ev.y - posStart.y;\n    const distance = Math.sqrt(dx * dx + dy * dy);\n    if (distance >= ((_d = options == null ? void 0 : options.distanceThreshold) != null ? _d : DEFAULT_THRESHOLD))\n      clear();\n  }\n  const listenerOptions = {\n    capture: (_a = options == null ? void 0 : options.modifiers) == null ? void 0 : _a.capture,\n    once: (_b = options == null ? void 0 : options.modifiers) == null ? void 0 : _b.once\n  };\n  const cleanup = [\n    useEventListener(elementRef, \"pointerdown\", onDown, listenerOptions),\n    useEventListener(elementRef, \"pointermove\", onMove, listenerOptions),\n    useEventListener(elementRef, [\"pointerup\", \"pointerleave\"], onRelease, listenerOptions)\n  ];\n  const stop = () => cleanup.forEach((fn) => fn());\n  return stop;\n}\n\nfunction isFocusedElementEditable() {\n  const { activeElement, body } = document;\n  if (!activeElement)\n    return false;\n  if (activeElement === body)\n    return false;\n  switch (activeElement.tagName) {\n    case \"INPUT\":\n    case \"TEXTAREA\":\n      return true;\n  }\n  return activeElement.hasAttribute(\"contenteditable\");\n}\nfunction isTypedCharValid({\n  keyCode,\n  metaKey,\n  ctrlKey,\n  altKey\n}) {\n  if (metaKey || ctrlKey || altKey)\n    return false;\n  if (keyCode >= 48 && keyCode <= 57)\n    return true;\n  if (keyCode >= 65 && keyCode <= 90)\n    return true;\n  if (keyCode >= 97 && keyCode <= 122)\n    return true;\n  return false;\n}\nfunction onStartTyping(callback, options = {}) {\n  const { document: document2 = defaultDocument } = options;\n  const keydown = (event) => {\n    if (!isFocusedElementEditable() && isTypedCharValid(event)) {\n      callback(event);\n    }\n  };\n  if (document2)\n    useEventListener(document2, \"keydown\", keydown, { passive: true });\n}\n\nfunction templateRef(key, initialValue = null) {\n  const instance = getCurrentInstance();\n  let _trigger = () => {\n  };\n  const element = customRef((track, trigger) => {\n    _trigger = trigger;\n    return {\n      get() {\n        var _a, _b;\n        track();\n        return (_b = (_a = instance == null ? void 0 : instance.proxy) == null ? void 0 : _a.$refs[key]) != null ? _b : initialValue;\n      },\n      set() {\n      }\n    };\n  });\n  tryOnMounted(_trigger);\n  onUpdated(_trigger);\n  return element;\n}\n\nfunction useMounted() {\n  const isMounted = ref(false);\n  const instance = getCurrentInstance();\n  if (instance) {\n    onMounted(() => {\n      isMounted.value = true;\n    }, isVue2 ? void 0 : instance);\n  }\n  return isMounted;\n}\n\nfunction useSupported(callback) {\n  const isMounted = useMounted();\n  return computed(() => {\n    isMounted.value;\n    return Boolean(callback());\n  });\n}\n\nfunction useMutationObserver(target, callback, options = {}) {\n  const { window = defaultWindow, ...mutationOptions } = options;\n  let observer;\n  const isSupported = useSupported(() => window && \"MutationObserver\" in window);\n  const cleanup = () => {\n    if (observer) {\n      observer.disconnect();\n      observer = void 0;\n    }\n  };\n  const targets = computed(() => {\n    const value = toValue(target);\n    const items = (Array.isArray(value) ? value : [value]).map(unrefElement).filter(notNullish);\n    return new Set(items);\n  });\n  const stopWatch = watch(\n    () => targets.value,\n    (targets2) => {\n      cleanup();\n      if (isSupported.value && targets2.size) {\n        observer = new MutationObserver(callback);\n        targets2.forEach((el) => observer.observe(el, mutationOptions));\n      }\n    },\n    { immediate: true, flush: \"post\" }\n  );\n  const takeRecords = () => {\n    return observer == null ? void 0 : observer.takeRecords();\n  };\n  const stop = () => {\n    stopWatch();\n    cleanup();\n  };\n  tryOnScopeDispose(stop);\n  return {\n    isSupported,\n    stop,\n    takeRecords\n  };\n}\n\nfunction useActiveElement(options = {}) {\n  var _a;\n  const {\n    window = defaultWindow,\n    deep = true,\n    triggerOnRemoval = false\n  } = options;\n  const document = (_a = options.document) != null ? _a : window == null ? void 0 : window.document;\n  const getDeepActiveElement = () => {\n    var _a2;\n    let element = document == null ? void 0 : document.activeElement;\n    if (deep) {\n      while (element == null ? void 0 : element.shadowRoot)\n        element = (_a2 = element == null ? void 0 : element.shadowRoot) == null ? void 0 : _a2.activeElement;\n    }\n    return element;\n  };\n  const activeElement = ref();\n  const trigger = () => {\n    activeElement.value = getDeepActiveElement();\n  };\n  if (window) {\n    useEventListener(window, \"blur\", (event) => {\n      if (event.relatedTarget !== null)\n        return;\n      trigger();\n    }, true);\n    useEventListener(window, \"focus\", trigger, true);\n  }\n  if (triggerOnRemoval) {\n    useMutationObserver(document, (mutations) => {\n      mutations.filter((m) => m.removedNodes.length).map((n) => Array.from(n.removedNodes)).flat().forEach((node) => {\n        if (node === activeElement.value)\n          trigger();\n      });\n    }, {\n      childList: true,\n      subtree: true\n    });\n  }\n  trigger();\n  return activeElement;\n}\n\nfunction useRafFn(fn, options = {}) {\n  const {\n    immediate = true,\n    fpsLimit = void 0,\n    window = defaultWindow\n  } = options;\n  const isActive = ref(false);\n  const intervalLimit = fpsLimit ? 1e3 / fpsLimit : null;\n  let previousFrameTimestamp = 0;\n  let rafId = null;\n  function loop(timestamp) {\n    if (!isActive.value || !window)\n      return;\n    if (!previousFrameTimestamp)\n      previousFrameTimestamp = timestamp;\n    const delta = timestamp - previousFrameTimestamp;\n    if (intervalLimit && delta < intervalLimit) {\n      rafId = window.requestAnimationFrame(loop);\n      return;\n    }\n    previousFrameTimestamp = timestamp;\n    fn({ delta, timestamp });\n    rafId = window.requestAnimationFrame(loop);\n  }\n  function resume() {\n    if (!isActive.value && window) {\n      isActive.value = true;\n      previousFrameTimestamp = 0;\n      rafId = window.requestAnimationFrame(loop);\n    }\n  }\n  function pause() {\n    isActive.value = false;\n    if (rafId != null && window) {\n      window.cancelAnimationFrame(rafId);\n      rafId = null;\n    }\n  }\n  if (immediate)\n    resume();\n  tryOnScopeDispose(pause);\n  return {\n    isActive: readonly(isActive),\n    pause,\n    resume\n  };\n}\n\nfunction useAnimate(target, keyframes, options) {\n  let config;\n  let animateOptions;\n  if (isObject(options)) {\n    config = options;\n    animateOptions = objectOmit(options, [\"window\", \"immediate\", \"commitStyles\", \"persist\", \"onReady\", \"onError\"]);\n  } else {\n    config = { duration: options };\n    animateOptions = options;\n  }\n  const {\n    window = defaultWindow,\n    immediate = true,\n    commitStyles,\n    persist,\n    playbackRate: _playbackRate = 1,\n    onReady,\n    onError = (e) => {\n      console.error(e);\n    }\n  } = config;\n  const isSupported = useSupported(() => window && HTMLElement && \"animate\" in HTMLElement.prototype);\n  const animate = shallowRef(void 0);\n  const store = shallowReactive({\n    startTime: null,\n    currentTime: null,\n    timeline: null,\n    playbackRate: _playbackRate,\n    pending: false,\n    playState: immediate ? \"idle\" : \"paused\",\n    replaceState: \"active\"\n  });\n  const pending = computed(() => store.pending);\n  const playState = computed(() => store.playState);\n  const replaceState = computed(() => store.replaceState);\n  const startTime = computed({\n    get() {\n      return store.startTime;\n    },\n    set(value) {\n      store.startTime = value;\n      if (animate.value)\n        animate.value.startTime = value;\n    }\n  });\n  const currentTime = computed({\n    get() {\n      return store.currentTime;\n    },\n    set(value) {\n      store.currentTime = value;\n      if (animate.value) {\n        animate.value.currentTime = value;\n        syncResume();\n      }\n    }\n  });\n  const timeline = computed({\n    get() {\n      return store.timeline;\n    },\n    set(value) {\n      store.timeline = value;\n      if (animate.value)\n        animate.value.timeline = value;\n    }\n  });\n  const playbackRate = computed({\n    get() {\n      return store.playbackRate;\n    },\n    set(value) {\n      store.playbackRate = value;\n      if (animate.value)\n        animate.value.playbackRate = value;\n    }\n  });\n  const play = () => {\n    if (animate.value) {\n      try {\n        animate.value.play();\n        syncResume();\n      } catch (e) {\n        syncPause();\n        onError(e);\n      }\n    } else {\n      update();\n    }\n  };\n  const pause = () => {\n    var _a;\n    try {\n      (_a = animate.value) == null ? void 0 : _a.pause();\n      syncPause();\n    } catch (e) {\n      onError(e);\n    }\n  };\n  const reverse = () => {\n    var _a;\n    if (!animate.value)\n      update();\n    try {\n      (_a = animate.value) == null ? void 0 : _a.reverse();\n      syncResume();\n    } catch (e) {\n      syncPause();\n      onError(e);\n    }\n  };\n  const finish = () => {\n    var _a;\n    try {\n      (_a = animate.value) == null ? void 0 : _a.finish();\n      syncPause();\n    } catch (e) {\n      onError(e);\n    }\n  };\n  const cancel = () => {\n    var _a;\n    try {\n      (_a = animate.value) == null ? void 0 : _a.cancel();\n      syncPause();\n    } catch (e) {\n      onError(e);\n    }\n  };\n  watch(() => unrefElement(target), (el) => {\n    if (el)\n      update();\n  });\n  watch(() => keyframes, (value) => {\n    if (animate.value)\n      update();\n    if (!unrefElement(target) && animate.value) {\n      animate.value.effect = new KeyframeEffect(\n        unrefElement(target),\n        toValue(value),\n        animateOptions\n      );\n    }\n  }, { deep: true });\n  tryOnMounted(() => update(true), false);\n  tryOnScopeDispose(cancel);\n  function update(init) {\n    const el = unrefElement(target);\n    if (!isSupported.value || !el)\n      return;\n    if (!animate.value)\n      animate.value = el.animate(toValue(keyframes), animateOptions);\n    if (persist)\n      animate.value.persist();\n    if (_playbackRate !== 1)\n      animate.value.playbackRate = _playbackRate;\n    if (init && !immediate)\n      animate.value.pause();\n    else\n      syncResume();\n    onReady == null ? void 0 : onReady(animate.value);\n  }\n  useEventListener(animate, [\"cancel\", \"finish\", \"remove\"], syncPause);\n  useEventListener(animate, \"finish\", () => {\n    var _a;\n    if (commitStyles)\n      (_a = animate.value) == null ? void 0 : _a.commitStyles();\n  });\n  const { resume: resumeRef, pause: pauseRef } = useRafFn(() => {\n    if (!animate.value)\n      return;\n    store.pending = animate.value.pending;\n    store.playState = animate.value.playState;\n    store.replaceState = animate.value.replaceState;\n    store.startTime = animate.value.startTime;\n    store.currentTime = animate.value.currentTime;\n    store.timeline = animate.value.timeline;\n    store.playbackRate = animate.value.playbackRate;\n  }, { immediate: false });\n  function syncResume() {\n    if (isSupported.value)\n      resumeRef();\n  }\n  function syncPause() {\n    if (isSupported.value && window)\n      window.requestAnimationFrame(pauseRef);\n  }\n  return {\n    isSupported,\n    animate,\n    // actions\n    play,\n    pause,\n    reverse,\n    finish,\n    cancel,\n    // state\n    pending,\n    playState,\n    replaceState,\n    startTime,\n    currentTime,\n    timeline,\n    playbackRate\n  };\n}\n\nfunction useAsyncQueue(tasks, options) {\n  const {\n    interrupt = true,\n    onError = noop,\n    onFinished = noop,\n    signal\n  } = options || {};\n  const promiseState = {\n    aborted: \"aborted\",\n    fulfilled: \"fulfilled\",\n    pending: \"pending\",\n    rejected: \"rejected\"\n  };\n  const initialResult = Array.from(Array.from({ length: tasks.length }), () => ({ state: promiseState.pending, data: null }));\n  const result = reactive(initialResult);\n  const activeIndex = ref(-1);\n  if (!tasks || tasks.length === 0) {\n    onFinished();\n    return {\n      activeIndex,\n      result\n    };\n  }\n  function updateResult(state, res) {\n    activeIndex.value++;\n    result[activeIndex.value].data = res;\n    result[activeIndex.value].state = state;\n  }\n  tasks.reduce((prev, curr) => {\n    return prev.then((prevRes) => {\n      var _a;\n      if (signal == null ? void 0 : signal.aborted) {\n        updateResult(promiseState.aborted, new Error(\"aborted\"));\n        return;\n      }\n      if (((_a = result[activeIndex.value]) == null ? void 0 : _a.state) === promiseState.rejected && interrupt) {\n        onFinished();\n        return;\n      }\n      const done = curr(prevRes).then((currentRes) => {\n        updateResult(promiseState.fulfilled, currentRes);\n        if (activeIndex.value === tasks.length - 1)\n          onFinished();\n        return currentRes;\n      });\n      if (!signal)\n        return done;\n      return Promise.race([done, whenAborted(signal)]);\n    }).catch((e) => {\n      if (signal == null ? void 0 : signal.aborted) {\n        updateResult(promiseState.aborted, e);\n        return e;\n      }\n      updateResult(promiseState.rejected, e);\n      onError();\n      return e;\n    });\n  }, Promise.resolve());\n  return {\n    activeIndex,\n    result\n  };\n}\nfunction whenAborted(signal) {\n  return new Promise((resolve, reject) => {\n    const error = new Error(\"aborted\");\n    if (signal.aborted)\n      reject(error);\n    else\n      signal.addEventListener(\"abort\", () => reject(error), { once: true });\n  });\n}\n\nfunction useAsyncState(promise, initialState, options) {\n  const {\n    immediate = true,\n    delay = 0,\n    onError = noop,\n    onSuccess = noop,\n    resetOnExecute = true,\n    shallow = true,\n    throwError\n  } = options != null ? options : {};\n  const state = shallow ? shallowRef(initialState) : ref(initialState);\n  const isReady = ref(false);\n  const isLoading = ref(false);\n  const error = shallowRef(void 0);\n  async function execute(delay2 = 0, ...args) {\n    if (resetOnExecute)\n      state.value = initialState;\n    error.value = void 0;\n    isReady.value = false;\n    isLoading.value = true;\n    if (delay2 > 0)\n      await promiseTimeout(delay2);\n    const _promise = typeof promise === \"function\" ? promise(...args) : promise;\n    try {\n      const data = await _promise;\n      state.value = data;\n      isReady.value = true;\n      onSuccess(data);\n    } catch (e) {\n      error.value = e;\n      onError(e);\n      if (throwError)\n        throw e;\n    } finally {\n      isLoading.value = false;\n    }\n    return state.value;\n  }\n  if (immediate)\n    execute(delay);\n  const shell = {\n    state,\n    isReady,\n    isLoading,\n    error,\n    execute\n  };\n  function waitUntilIsLoaded() {\n    return new Promise((resolve, reject) => {\n      until(isLoading).toBe(false).then(() => resolve(shell)).catch(reject);\n    });\n  }\n  return {\n    ...shell,\n    then(onFulfilled, onRejected) {\n      return waitUntilIsLoaded().then(onFulfilled, onRejected);\n    }\n  };\n}\n\nconst defaults = {\n  array: (v) => JSON.stringify(v),\n  object: (v) => JSON.stringify(v),\n  set: (v) => JSON.stringify(Array.from(v)),\n  map: (v) => JSON.stringify(Object.fromEntries(v)),\n  null: () => \"\"\n};\nfunction getDefaultSerialization(target) {\n  if (!target)\n    return defaults.null;\n  if (target instanceof Map)\n    return defaults.map;\n  else if (target instanceof Set)\n    return defaults.set;\n  else if (Array.isArray(target))\n    return defaults.array;\n  else\n    return defaults.object;\n}\n\nfunction useBase64(target, options) {\n  const base64 = ref(\"\");\n  const promise = ref();\n  function execute() {\n    if (!isClient)\n      return;\n    promise.value = new Promise((resolve, reject) => {\n      try {\n        const _target = toValue(target);\n        if (_target == null) {\n          resolve(\"\");\n        } else if (typeof _target === \"string\") {\n          resolve(blobToBase64(new Blob([_target], { type: \"text/plain\" })));\n        } else if (_target instanceof Blob) {\n          resolve(blobToBase64(_target));\n        } else if (_target instanceof ArrayBuffer) {\n          resolve(window.btoa(String.fromCharCode(...new Uint8Array(_target))));\n        } else if (_target instanceof HTMLCanvasElement) {\n          resolve(_target.toDataURL(options == null ? void 0 : options.type, options == null ? void 0 : options.quality));\n        } else if (_target instanceof HTMLImageElement) {\n          const img = _target.cloneNode(false);\n          img.crossOrigin = \"Anonymous\";\n          imgLoaded(img).then(() => {\n            const canvas = document.createElement(\"canvas\");\n            const ctx = canvas.getContext(\"2d\");\n            canvas.width = img.width;\n            canvas.height = img.height;\n            ctx.drawImage(img, 0, 0, canvas.width, canvas.height);\n            resolve(canvas.toDataURL(options == null ? void 0 : options.type, options == null ? void 0 : options.quality));\n          }).catch(reject);\n        } else if (typeof _target === \"object\") {\n          const _serializeFn = (options == null ? void 0 : options.serializer) || getDefaultSerialization(_target);\n          const serialized = _serializeFn(_target);\n          return resolve(blobToBase64(new Blob([serialized], { type: \"application/json\" })));\n        } else {\n          reject(new Error(\"target is unsupported types\"));\n        }\n      } catch (error) {\n        reject(error);\n      }\n    });\n    promise.value.then((res) => base64.value = res);\n    return promise.value;\n  }\n  if (isRef(target) || typeof target === \"function\")\n    watch(target, execute, { immediate: true });\n  else\n    execute();\n  return {\n    base64,\n    promise,\n    execute\n  };\n}\nfunction imgLoaded(img) {\n  return new Promise((resolve, reject) => {\n    if (!img.complete) {\n      img.onload = () => {\n        resolve();\n      };\n      img.onerror = reject;\n    } else {\n      resolve();\n    }\n  });\n}\nfunction blobToBase64(blob) {\n  return new Promise((resolve, reject) => {\n    const fr = new FileReader();\n    fr.onload = (e) => {\n      resolve(e.target.result);\n    };\n    fr.onerror = reject;\n    fr.readAsDataURL(blob);\n  });\n}\n\nfunction useBattery(options = {}) {\n  const { navigator = defaultNavigator } = options;\n  const events = [\"chargingchange\", \"chargingtimechange\", \"dischargingtimechange\", \"levelchange\"];\n  const isSupported = useSupported(() => navigator && \"getBattery\" in navigator && typeof navigator.getBattery === \"function\");\n  const charging = ref(false);\n  const chargingTime = ref(0);\n  const dischargingTime = ref(0);\n  const level = ref(1);\n  let battery;\n  function updateBatteryInfo() {\n    charging.value = this.charging;\n    chargingTime.value = this.chargingTime || 0;\n    dischargingTime.value = this.dischargingTime || 0;\n    level.value = this.level;\n  }\n  if (isSupported.value) {\n    navigator.getBattery().then((_battery) => {\n      battery = _battery;\n      updateBatteryInfo.call(battery);\n      useEventListener(battery, events, updateBatteryInfo, { passive: true });\n    });\n  }\n  return {\n    isSupported,\n    charging,\n    chargingTime,\n    dischargingTime,\n    level\n  };\n}\n\nfunction useBluetooth(options) {\n  let {\n    acceptAllDevices = false\n  } = options || {};\n  const {\n    filters = void 0,\n    optionalServices = void 0,\n    navigator = defaultNavigator\n  } = options || {};\n  const isSupported = useSupported(() => navigator && \"bluetooth\" in navigator);\n  const device = shallowRef(void 0);\n  const error = shallowRef(null);\n  watch(device, () => {\n    connectToBluetoothGATTServer();\n  });\n  async function requestDevice() {\n    if (!isSupported.value)\n      return;\n    error.value = null;\n    if (filters && filters.length > 0)\n      acceptAllDevices = false;\n    try {\n      device.value = await (navigator == null ? void 0 : navigator.bluetooth.requestDevice({\n        acceptAllDevices,\n        filters,\n        optionalServices\n      }));\n    } catch (err) {\n      error.value = err;\n    }\n  }\n  const server = ref();\n  const isConnected = computed(() => {\n    var _a;\n    return ((_a = server.value) == null ? void 0 : _a.connected) || false;\n  });\n  async function connectToBluetoothGATTServer() {\n    error.value = null;\n    if (device.value && device.value.gatt) {\n      device.value.addEventListener(\"gattserverdisconnected\", () => {\n      });\n      try {\n        server.value = await device.value.gatt.connect();\n      } catch (err) {\n        error.value = err;\n      }\n    }\n  }\n  tryOnMounted(() => {\n    var _a;\n    if (device.value)\n      (_a = device.value.gatt) == null ? void 0 : _a.connect();\n  });\n  tryOnScopeDispose(() => {\n    var _a;\n    if (device.value)\n      (_a = device.value.gatt) == null ? void 0 : _a.disconnect();\n  });\n  return {\n    isSupported,\n    isConnected,\n    // Device:\n    device,\n    requestDevice,\n    // Server:\n    server,\n    // Errors:\n    error\n  };\n}\n\nfunction useMediaQuery(query, options = {}) {\n  const { window = defaultWindow } = options;\n  const isSupported = useSupported(() => window && \"matchMedia\" in window && typeof window.matchMedia === \"function\");\n  let mediaQuery;\n  const matches = ref(false);\n  const handler = (event) => {\n    matches.value = event.matches;\n  };\n  const cleanup = () => {\n    if (!mediaQuery)\n      return;\n    if (\"removeEventListener\" in mediaQuery)\n      mediaQuery.removeEventListener(\"change\", handler);\n    else\n      mediaQuery.removeListener(handler);\n  };\n  const stopWatch = watchEffect(() => {\n    if (!isSupported.value)\n      return;\n    cleanup();\n    mediaQuery = window.matchMedia(toValue(query));\n    if (\"addEventListener\" in mediaQuery)\n      mediaQuery.addEventListener(\"change\", handler);\n    else\n      mediaQuery.addListener(handler);\n    matches.value = mediaQuery.matches;\n  });\n  tryOnScopeDispose(() => {\n    stopWatch();\n    cleanup();\n    mediaQuery = void 0;\n  });\n  return matches;\n}\n\nconst breakpointsTailwind = {\n  \"sm\": 640,\n  \"md\": 768,\n  \"lg\": 1024,\n  \"xl\": 1280,\n  \"2xl\": 1536\n};\nconst breakpointsBootstrapV5 = {\n  xs: 0,\n  sm: 576,\n  md: 768,\n  lg: 992,\n  xl: 1200,\n  xxl: 1400\n};\nconst breakpointsVuetifyV2 = {\n  xs: 0,\n  sm: 600,\n  md: 960,\n  lg: 1264,\n  xl: 1904\n};\nconst breakpointsVuetifyV3 = {\n  xs: 0,\n  sm: 600,\n  md: 960,\n  lg: 1280,\n  xl: 1920,\n  xxl: 2560\n};\nconst breakpointsVuetify = breakpointsVuetifyV2;\nconst breakpointsAntDesign = {\n  xs: 480,\n  sm: 576,\n  md: 768,\n  lg: 992,\n  xl: 1200,\n  xxl: 1600\n};\nconst breakpointsQuasar = {\n  xs: 0,\n  sm: 600,\n  md: 1024,\n  lg: 1440,\n  xl: 1920\n};\nconst breakpointsSematic = {\n  mobileS: 320,\n  mobileM: 375,\n  mobileL: 425,\n  tablet: 768,\n  laptop: 1024,\n  laptopL: 1440,\n  desktop4K: 2560\n};\nconst breakpointsMasterCss = {\n  \"3xs\": 360,\n  \"2xs\": 480,\n  \"xs\": 600,\n  \"sm\": 768,\n  \"md\": 1024,\n  \"lg\": 1280,\n  \"xl\": 1440,\n  \"2xl\": 1600,\n  \"3xl\": 1920,\n  \"4xl\": 2560\n};\nconst breakpointsPrimeFlex = {\n  sm: 576,\n  md: 768,\n  lg: 992,\n  xl: 1200\n};\nconst breakpointsElement = {\n  xs: 0,\n  sm: 768,\n  md: 992,\n  lg: 1200,\n  xl: 1920\n};\n\nfunction useBreakpoints(breakpoints, options = {}) {\n  function getValue(k, delta) {\n    let v = toValue(breakpoints[toValue(k)]);\n    if (delta != null)\n      v = increaseWithUnit(v, delta);\n    if (typeof v === \"number\")\n      v = `${v}px`;\n    return v;\n  }\n  const { window = defaultWindow, strategy = \"min-width\" } = options;\n  function match(query) {\n    if (!window)\n      return false;\n    return window.matchMedia(query).matches;\n  }\n  const greaterOrEqual = (k) => {\n    return useMediaQuery(() => `(min-width: ${getValue(k)})`, options);\n  };\n  const smallerOrEqual = (k) => {\n    return useMediaQuery(() => `(max-width: ${getValue(k)})`, options);\n  };\n  const shortcutMethods = Object.keys(breakpoints).reduce((shortcuts, k) => {\n    Object.defineProperty(shortcuts, k, {\n      get: () => strategy === \"min-width\" ? greaterOrEqual(k) : smallerOrEqual(k),\n      enumerable: true,\n      configurable: true\n    });\n    return shortcuts;\n  }, {});\n  function current() {\n    const points = Object.keys(breakpoints).map((i) => [i, greaterOrEqual(i)]);\n    return computed(() => points.filter(([, v]) => v.value).map(([k]) => k));\n  }\n  return Object.assign(shortcutMethods, {\n    greaterOrEqual,\n    smallerOrEqual,\n    greater(k) {\n      return useMediaQuery(() => `(min-width: ${getValue(k, 0.1)})`, options);\n    },\n    smaller(k) {\n      return useMediaQuery(() => `(max-width: ${getValue(k, -0.1)})`, options);\n    },\n    between(a, b) {\n      return useMediaQuery(() => `(min-width: ${getValue(a)}) and (max-width: ${getValue(b, -0.1)})`, options);\n    },\n    isGreater(k) {\n      return match(`(min-width: ${getValue(k, 0.1)})`);\n    },\n    isGreaterOrEqual(k) {\n      return match(`(min-width: ${getValue(k)})`);\n    },\n    isSmaller(k) {\n      return match(`(max-width: ${getValue(k, -0.1)})`);\n    },\n    isSmallerOrEqual(k) {\n      return match(`(max-width: ${getValue(k)})`);\n    },\n    isInBetween(a, b) {\n      return match(`(min-width: ${getValue(a)}) and (max-width: ${getValue(b, -0.1)})`);\n    },\n    current,\n    active() {\n      const bps = current();\n      return computed(() => bps.value.length === 0 ? \"\" : bps.value.at(-1));\n    }\n  });\n}\n\nfunction useBroadcastChannel(options) {\n  const {\n    name,\n    window = defaultWindow\n  } = options;\n  const isSupported = useSupported(() => window && \"BroadcastChannel\" in window);\n  const isClosed = ref(false);\n  const channel = ref();\n  const data = ref();\n  const error = shallowRef(null);\n  const post = (data2) => {\n    if (channel.value)\n      channel.value.postMessage(data2);\n  };\n  const close = () => {\n    if (channel.value)\n      channel.value.close();\n    isClosed.value = true;\n  };\n  if (isSupported.value) {\n    tryOnMounted(() => {\n      error.value = null;\n      channel.value = new BroadcastChannel(name);\n      channel.value.addEventListener(\"message\", (e) => {\n        data.value = e.data;\n      }, { passive: true });\n      channel.value.addEventListener(\"messageerror\", (e) => {\n        error.value = e;\n      }, { passive: true });\n      channel.value.addEventListener(\"close\", () => {\n        isClosed.value = true;\n      });\n    });\n  }\n  tryOnScopeDispose(() => {\n    close();\n  });\n  return {\n    isSupported,\n    channel,\n    data,\n    post,\n    close,\n    error,\n    isClosed\n  };\n}\n\nconst WRITABLE_PROPERTIES = [\n  \"hash\",\n  \"host\",\n  \"hostname\",\n  \"href\",\n  \"pathname\",\n  \"port\",\n  \"protocol\",\n  \"search\"\n];\nfunction useBrowserLocation(options = {}) {\n  const { window = defaultWindow } = options;\n  const refs = Object.fromEntries(\n    WRITABLE_PROPERTIES.map((key) => [key, ref()])\n  );\n  for (const [key, ref2] of objectEntries(refs)) {\n    watch(ref2, (value) => {\n      if (!(window == null ? void 0 : window.location) || window.location[key] === value)\n        return;\n      window.location[key] = value;\n    });\n  }\n  const buildState = (trigger) => {\n    var _a;\n    const { state: state2, length } = (window == null ? void 0 : window.history) || {};\n    const { origin } = (window == null ? void 0 : window.location) || {};\n    for (const key of WRITABLE_PROPERTIES)\n      refs[key].value = (_a = window == null ? void 0 : window.location) == null ? void 0 : _a[key];\n    return reactive({\n      trigger,\n      state: state2,\n      length,\n      origin,\n      ...refs\n    });\n  };\n  const state = ref(buildState(\"load\"));\n  if (window) {\n    useEventListener(window, \"popstate\", () => state.value = buildState(\"popstate\"), { passive: true });\n    useEventListener(window, \"hashchange\", () => state.value = buildState(\"hashchange\"), { passive: true });\n  }\n  return state;\n}\n\nfunction useCached(refValue, comparator = (a, b) => a === b, watchOptions) {\n  const cachedValue = ref(refValue.value);\n  watch(() => refValue.value, (value) => {\n    if (!comparator(value, cachedValue.value))\n      cachedValue.value = value;\n  }, watchOptions);\n  return cachedValue;\n}\n\nfunction usePermission(permissionDesc, options = {}) {\n  const {\n    controls = false,\n    navigator = defaultNavigator\n  } = options;\n  const isSupported = useSupported(() => navigator && \"permissions\" in navigator);\n  const permissionStatus = shallowRef();\n  const desc = typeof permissionDesc === \"string\" ? { name: permissionDesc } : permissionDesc;\n  const state = shallowRef();\n  const update = () => {\n    var _a, _b;\n    state.value = (_b = (_a = permissionStatus.value) == null ? void 0 : _a.state) != null ? _b : \"prompt\";\n  };\n  useEventListener(permissionStatus, \"change\", update);\n  const query = createSingletonPromise(async () => {\n    if (!isSupported.value)\n      return;\n    if (!permissionStatus.value) {\n      try {\n        permissionStatus.value = await navigator.permissions.query(desc);\n      } catch (e) {\n        permissionStatus.value = void 0;\n      } finally {\n        update();\n      }\n    }\n    if (controls)\n      return toRaw(permissionStatus.value);\n  });\n  query();\n  if (controls) {\n    return {\n      state,\n      isSupported,\n      query\n    };\n  } else {\n    return state;\n  }\n}\n\nfunction useClipboard(options = {}) {\n  const {\n    navigator = defaultNavigator,\n    read = false,\n    source,\n    copiedDuring = 1500,\n    legacy = false\n  } = options;\n  const isClipboardApiSupported = useSupported(() => navigator && \"clipboard\" in navigator);\n  const permissionRead = usePermission(\"clipboard-read\");\n  const permissionWrite = usePermission(\"clipboard-write\");\n  const isSupported = computed(() => isClipboardApiSupported.value || legacy);\n  const text = ref(\"\");\n  const copied = ref(false);\n  const timeout = useTimeoutFn(() => copied.value = false, copiedDuring);\n  function updateText() {\n    if (isClipboardApiSupported.value && isAllowed(permissionRead.value)) {\n      navigator.clipboard.readText().then((value) => {\n        text.value = value;\n      });\n    } else {\n      text.value = legacyRead();\n    }\n  }\n  if (isSupported.value && read)\n    useEventListener([\"copy\", \"cut\"], updateText);\n  async function copy(value = toValue(source)) {\n    if (isSupported.value && value != null) {\n      if (isClipboardApiSupported.value && isAllowed(permissionWrite.value))\n        await navigator.clipboard.writeText(value);\n      else\n        legacyCopy(value);\n      text.value = value;\n      copied.value = true;\n      timeout.start();\n    }\n  }\n  function legacyCopy(value) {\n    const ta = document.createElement(\"textarea\");\n    ta.value = value != null ? value : \"\";\n    ta.style.position = \"absolute\";\n    ta.style.opacity = \"0\";\n    document.body.appendChild(ta);\n    ta.select();\n    document.execCommand(\"copy\");\n    ta.remove();\n  }\n  function legacyRead() {\n    var _a, _b, _c;\n    return (_c = (_b = (_a = document == null ? void 0 : document.getSelection) == null ? void 0 : _a.call(document)) == null ? void 0 : _b.toString()) != null ? _c : \"\";\n  }\n  function isAllowed(status) {\n    return status === \"granted\" || status === \"prompt\";\n  }\n  return {\n    isSupported,\n    text,\n    copied,\n    copy\n  };\n}\n\nfunction useClipboardItems(options = {}) {\n  const {\n    navigator = defaultNavigator,\n    read = false,\n    source,\n    copiedDuring = 1500\n  } = options;\n  const isSupported = useSupported(() => navigator && \"clipboard\" in navigator);\n  const content = ref([]);\n  const copied = ref(false);\n  const timeout = useTimeoutFn(() => copied.value = false, copiedDuring);\n  function updateContent() {\n    if (isSupported.value) {\n      navigator.clipboard.read().then((items) => {\n        content.value = items;\n      });\n    }\n  }\n  if (isSupported.value && read)\n    useEventListener([\"copy\", \"cut\"], updateContent);\n  async function copy(value = toValue(source)) {\n    if (isSupported.value && value != null) {\n      await navigator.clipboard.write(value);\n      content.value = value;\n      copied.value = true;\n      timeout.start();\n    }\n  }\n  return {\n    isSupported,\n    content,\n    copied,\n    copy\n  };\n}\n\nfunction cloneFnJSON(source) {\n  return JSON.parse(JSON.stringify(source));\n}\nfunction useCloned(source, options = {}) {\n  const cloned = ref({});\n  const {\n    manual,\n    clone = cloneFnJSON,\n    // watch options\n    deep = true,\n    immediate = true\n  } = options;\n  function sync() {\n    cloned.value = clone(toValue(source));\n  }\n  if (!manual && (isRef(source) || typeof source === \"function\")) {\n    watch(source, sync, {\n      ...options,\n      deep,\n      immediate\n    });\n  } else {\n    sync();\n  }\n  return { cloned, sync };\n}\n\nconst _global = typeof globalThis !== \"undefined\" ? globalThis : typeof window !== \"undefined\" ? window : typeof global !== \"undefined\" ? global : typeof self !== \"undefined\" ? self : {};\nconst globalKey = \"__vueuse_ssr_handlers__\";\nconst handlers = /* @__PURE__ */ getHandlers();\nfunction getHandlers() {\n  if (!(globalKey in _global))\n    _global[globalKey] = _global[globalKey] || {};\n  return _global[globalKey];\n}\nfunction getSSRHandler(key, fallback) {\n  return handlers[key] || fallback;\n}\nfunction setSSRHandler(key, fn) {\n  handlers[key] = fn;\n}\n\nfunction usePreferredDark(options) {\n  return useMediaQuery(\"(prefers-color-scheme: dark)\", options);\n}\n\nfunction guessSerializerType(rawInit) {\n  return rawInit == null ? \"any\" : rawInit instanceof Set ? \"set\" : rawInit instanceof Map ? \"map\" : rawInit instanceof Date ? \"date\" : typeof rawInit === \"boolean\" ? \"boolean\" : typeof rawInit === \"string\" ? \"string\" : typeof rawInit === \"object\" ? \"object\" : !Number.isNaN(rawInit) ? \"number\" : \"any\";\n}\n\nconst StorageSerializers = {\n  boolean: {\n    read: (v) => v === \"true\",\n    write: (v) => String(v)\n  },\n  object: {\n    read: (v) => JSON.parse(v),\n    write: (v) => JSON.stringify(v)\n  },\n  number: {\n    read: (v) => Number.parseFloat(v),\n    write: (v) => String(v)\n  },\n  any: {\n    read: (v) => v,\n    write: (v) => String(v)\n  },\n  string: {\n    read: (v) => v,\n    write: (v) => String(v)\n  },\n  map: {\n    read: (v) => new Map(JSON.parse(v)),\n    write: (v) => JSON.stringify(Array.from(v.entries()))\n  },\n  set: {\n    read: (v) => new Set(JSON.parse(v)),\n    write: (v) => JSON.stringify(Array.from(v))\n  },\n  date: {\n    read: (v) => new Date(v),\n    write: (v) => v.toISOString()\n  }\n};\nconst customStorageEventName = \"vueuse-storage\";\nfunction useStorage(key, defaults, storage, options = {}) {\n  var _a;\n  const {\n    flush = \"pre\",\n    deep = true,\n    listenToStorageChanges = true,\n    writeDefaults = true,\n    mergeDefaults = false,\n    shallow,\n    window = defaultWindow,\n    eventFilter,\n    onError = (e) => {\n      console.error(e);\n    },\n    initOnMounted\n  } = options;\n  const data = (shallow ? shallowRef : ref)(typeof defaults === \"function\" ? defaults() : defaults);\n  if (!storage) {\n    try {\n      storage = getSSRHandler(\"getDefaultStorage\", () => {\n        var _a2;\n        return (_a2 = defaultWindow) == null ? void 0 : _a2.localStorage;\n      })();\n    } catch (e) {\n      onError(e);\n    }\n  }\n  if (!storage)\n    return data;\n  const rawInit = toValue(defaults);\n  const type = guessSerializerType(rawInit);\n  const serializer = (_a = options.serializer) != null ? _a : StorageSerializers[type];\n  const { pause: pauseWatch, resume: resumeWatch } = pausableWatch(\n    data,\n    () => write(data.value),\n    { flush, deep, eventFilter }\n  );\n  if (window && listenToStorageChanges) {\n    tryOnMounted(() => {\n      if (storage instanceof Storage)\n        useEventListener(window, \"storage\", update);\n      else\n        useEventListener(window, customStorageEventName, updateFromCustomEvent);\n      if (initOnMounted)\n        update();\n    });\n  }\n  if (!initOnMounted)\n    update();\n  function dispatchWriteEvent(oldValue, newValue) {\n    if (window) {\n      const payload = {\n        key,\n        oldValue,\n        newValue,\n        storageArea: storage\n      };\n      window.dispatchEvent(storage instanceof Storage ? new StorageEvent(\"storage\", payload) : new CustomEvent(customStorageEventName, {\n        detail: payload\n      }));\n    }\n  }\n  function write(v) {\n    try {\n      const oldValue = storage.getItem(key);\n      if (v == null) {\n        dispatchWriteEvent(oldValue, null);\n        storage.removeItem(key);\n      } else {\n        const serialized = serializer.write(v);\n        if (oldValue !== serialized) {\n          storage.setItem(key, serialized);\n          dispatchWriteEvent(oldValue, serialized);\n        }\n      }\n    } catch (e) {\n      onError(e);\n    }\n  }\n  function read(event) {\n    const rawValue = event ? event.newValue : storage.getItem(key);\n    if (rawValue == null) {\n      if (writeDefaults && rawInit != null)\n        storage.setItem(key, serializer.write(rawInit));\n      return rawInit;\n    } else if (!event && mergeDefaults) {\n      const value = serializer.read(rawValue);\n      if (typeof mergeDefaults === \"function\")\n        return mergeDefaults(value, rawInit);\n      else if (type === \"object\" && !Array.isArray(value))\n        return { ...rawInit, ...value };\n      return value;\n    } else if (typeof rawValue !== \"string\") {\n      return rawValue;\n    } else {\n      return serializer.read(rawValue);\n    }\n  }\n  function update(event) {\n    if (event && event.storageArea !== storage)\n      return;\n    if (event && event.key == null) {\n      data.value = rawInit;\n      return;\n    }\n    if (event && event.key !== key)\n      return;\n    pauseWatch();\n    try {\n      if ((event == null ? void 0 : event.newValue) !== serializer.write(data.value))\n        data.value = read(event);\n    } catch (e) {\n      onError(e);\n    } finally {\n      if (event)\n        nextTick(resumeWatch);\n      else\n        resumeWatch();\n    }\n  }\n  function updateFromCustomEvent(event) {\n    update(event.detail);\n  }\n  return data;\n}\n\nconst CSS_DISABLE_TRANS = \"*,*::before,*::after{-webkit-transition:none!important;-moz-transition:none!important;-o-transition:none!important;-ms-transition:none!important;transition:none!important}\";\nfunction useColorMode(options = {}) {\n  const {\n    selector = \"html\",\n    attribute = \"class\",\n    initialValue = \"auto\",\n    window = defaultWindow,\n    storage,\n    storageKey = \"vueuse-color-scheme\",\n    listenToStorageChanges = true,\n    storageRef,\n    emitAuto,\n    disableTransition = true\n  } = options;\n  const modes = {\n    auto: \"\",\n    light: \"light\",\n    dark: \"dark\",\n    ...options.modes || {}\n  };\n  const preferredDark = usePreferredDark({ window });\n  const system = computed(() => preferredDark.value ? \"dark\" : \"light\");\n  const store = storageRef || (storageKey == null ? toRef(initialValue) : useStorage(storageKey, initialValue, storage, { window, listenToStorageChanges }));\n  const state = computed(() => store.value === \"auto\" ? system.value : store.value);\n  const updateHTMLAttrs = getSSRHandler(\n    \"updateHTMLAttrs\",\n    (selector2, attribute2, value) => {\n      const el = typeof selector2 === \"string\" ? window == null ? void 0 : window.document.querySelector(selector2) : unrefElement(selector2);\n      if (!el)\n        return;\n      const classesToAdd = /* @__PURE__ */ new Set();\n      const classesToRemove = /* @__PURE__ */ new Set();\n      let attributeToChange = null;\n      if (attribute2 === \"class\") {\n        const current = value.split(/\\s/g);\n        Object.values(modes).flatMap((i) => (i || \"\").split(/\\s/g)).filter(Boolean).forEach((v) => {\n          if (current.includes(v))\n            classesToAdd.add(v);\n          else\n            classesToRemove.add(v);\n        });\n      } else {\n        attributeToChange = { key: attribute2, value };\n      }\n      if (classesToAdd.size === 0 && classesToRemove.size === 0 && attributeToChange === null)\n        return;\n      let style;\n      if (disableTransition) {\n        style = window.document.createElement(\"style\");\n        style.appendChild(document.createTextNode(CSS_DISABLE_TRANS));\n        window.document.head.appendChild(style);\n      }\n      for (const c of classesToAdd) {\n        el.classList.add(c);\n      }\n      for (const c of classesToRemove) {\n        el.classList.remove(c);\n      }\n      if (attributeToChange) {\n        el.setAttribute(attributeToChange.key, attributeToChange.value);\n      }\n      if (disableTransition) {\n        window.getComputedStyle(style).opacity;\n        document.head.removeChild(style);\n      }\n    }\n  );\n  function defaultOnChanged(mode) {\n    var _a;\n    updateHTMLAttrs(selector, attribute, (_a = modes[mode]) != null ? _a : mode);\n  }\n  function onChanged(mode) {\n    if (options.onChanged)\n      options.onChanged(mode, defaultOnChanged);\n    else\n      defaultOnChanged(mode);\n  }\n  watch(state, onChanged, { flush: \"post\", immediate: true });\n  tryOnMounted(() => onChanged(state.value));\n  const auto = computed({\n    get() {\n      return emitAuto ? store.value : state.value;\n    },\n    set(v) {\n      store.value = v;\n    }\n  });\n  try {\n    return Object.assign(auto, { store, system, state });\n  } catch (e) {\n    return auto;\n  }\n}\n\nfunction useConfirmDialog(revealed = ref(false)) {\n  const confirmHook = createEventHook();\n  const cancelHook = createEventHook();\n  const revealHook = createEventHook();\n  let _resolve = noop;\n  const reveal = (data) => {\n    revealHook.trigger(data);\n    revealed.value = true;\n    return new Promise((resolve) => {\n      _resolve = resolve;\n    });\n  };\n  const confirm = (data) => {\n    revealed.value = false;\n    confirmHook.trigger(data);\n    _resolve({ data, isCanceled: false });\n  };\n  const cancel = (data) => {\n    revealed.value = false;\n    cancelHook.trigger(data);\n    _resolve({ data, isCanceled: true });\n  };\n  return {\n    isRevealed: computed(() => revealed.value),\n    reveal,\n    confirm,\n    cancel,\n    onReveal: revealHook.on,\n    onConfirm: confirmHook.on,\n    onCancel: cancelHook.on\n  };\n}\n\nfunction useCssVar(prop, target, options = {}) {\n  const { window = defaultWindow, initialValue, observe = false } = options;\n  const variable = ref(initialValue);\n  const elRef = computed(() => {\n    var _a;\n    return unrefElement(target) || ((_a = window == null ? void 0 : window.document) == null ? void 0 : _a.documentElement);\n  });\n  function updateCssVar() {\n    var _a;\n    const key = toValue(prop);\n    const el = toValue(elRef);\n    if (el && window && key) {\n      const value = (_a = window.getComputedStyle(el).getPropertyValue(key)) == null ? void 0 : _a.trim();\n      variable.value = value || initialValue;\n    }\n  }\n  if (observe) {\n    useMutationObserver(elRef, updateCssVar, {\n      attributeFilter: [\"style\", \"class\"],\n      window\n    });\n  }\n  watch(\n    [elRef, () => toValue(prop)],\n    (_, old) => {\n      if (old[0] && old[1])\n        old[0].style.removeProperty(old[1]);\n      updateCssVar();\n    },\n    { immediate: true }\n  );\n  watch(\n    variable,\n    (val) => {\n      var _a;\n      const raw_prop = toValue(prop);\n      if (((_a = elRef.value) == null ? void 0 : _a.style) && raw_prop) {\n        if (val == null)\n          elRef.value.style.removeProperty(raw_prop);\n        else\n          elRef.value.style.setProperty(raw_prop, val);\n      }\n    }\n  );\n  return variable;\n}\n\nfunction useCurrentElement(rootComponent) {\n  const vm = getCurrentInstance();\n  const currentElement = computedWithControl(\n    () => null,\n    () => rootComponent ? unrefElement(rootComponent) : vm.proxy.$el\n  );\n  onUpdated(currentElement.trigger);\n  onMounted(currentElement.trigger);\n  return currentElement;\n}\n\nfunction useCycleList(list, options) {\n  const state = shallowRef(getInitialValue());\n  const listRef = toRef(list);\n  const index = computed({\n    get() {\n      var _a;\n      const targetList = listRef.value;\n      let index2 = (options == null ? void 0 : options.getIndexOf) ? options.getIndexOf(state.value, targetList) : targetList.indexOf(state.value);\n      if (index2 < 0)\n        index2 = (_a = options == null ? void 0 : options.fallbackIndex) != null ? _a : 0;\n      return index2;\n    },\n    set(v) {\n      set(v);\n    }\n  });\n  function set(i) {\n    const targetList = listRef.value;\n    const length = targetList.length;\n    const index2 = (i % length + length) % length;\n    const value = targetList[index2];\n    state.value = value;\n    return value;\n  }\n  function shift(delta = 1) {\n    return set(index.value + delta);\n  }\n  function next(n = 1) {\n    return shift(n);\n  }\n  function prev(n = 1) {\n    return shift(-n);\n  }\n  function getInitialValue() {\n    var _a, _b;\n    return (_b = toValue((_a = options == null ? void 0 : options.initialValue) != null ? _a : toValue(list)[0])) != null ? _b : void 0;\n  }\n  watch(listRef, () => set(index.value));\n  return {\n    state,\n    index,\n    next,\n    prev,\n    go: set\n  };\n}\n\nfunction useDark(options = {}) {\n  const {\n    valueDark = \"dark\",\n    valueLight = \"\",\n    window = defaultWindow\n  } = options;\n  const mode = useColorMode({\n    ...options,\n    onChanged: (mode2, defaultHandler) => {\n      var _a;\n      if (options.onChanged)\n        (_a = options.onChanged) == null ? void 0 : _a.call(options, mode2 === \"dark\", defaultHandler, mode2);\n      else\n        defaultHandler(mode2);\n    },\n    modes: {\n      dark: valueDark,\n      light: valueLight\n    }\n  });\n  const system = computed(() => {\n    if (mode.system) {\n      return mode.system.value;\n    } else {\n      const preferredDark = usePreferredDark({ window });\n      return preferredDark.value ? \"dark\" : \"light\";\n    }\n  });\n  const isDark = computed({\n    get() {\n      return mode.value === \"dark\";\n    },\n    set(v) {\n      const modeVal = v ? \"dark\" : \"light\";\n      if (system.value === modeVal)\n        mode.value = \"auto\";\n      else\n        mode.value = modeVal;\n    }\n  });\n  return isDark;\n}\n\nfunction fnBypass(v) {\n  return v;\n}\nfunction fnSetSource(source, value) {\n  return source.value = value;\n}\nfunction defaultDump(clone) {\n  return clone ? typeof clone === \"function\" ? clone : cloneFnJSON : fnBypass;\n}\nfunction defaultParse(clone) {\n  return clone ? typeof clone === \"function\" ? clone : cloneFnJSON : fnBypass;\n}\nfunction useManualRefHistory(source, options = {}) {\n  const {\n    clone = false,\n    dump = defaultDump(clone),\n    parse = defaultParse(clone),\n    setSource = fnSetSource\n  } = options;\n  function _createHistoryRecord() {\n    return markRaw({\n      snapshot: dump(source.value),\n      timestamp: timestamp()\n    });\n  }\n  const last = ref(_createHistoryRecord());\n  const undoStack = ref([]);\n  const redoStack = ref([]);\n  const _setSource = (record) => {\n    setSource(source, parse(record.snapshot));\n    last.value = record;\n  };\n  const commit = () => {\n    undoStack.value.unshift(last.value);\n    last.value = _createHistoryRecord();\n    if (options.capacity && undoStack.value.length > options.capacity)\n      undoStack.value.splice(options.capacity, Number.POSITIVE_INFINITY);\n    if (redoStack.value.length)\n      redoStack.value.splice(0, redoStack.value.length);\n  };\n  const clear = () => {\n    undoStack.value.splice(0, undoStack.value.length);\n    redoStack.value.splice(0, redoStack.value.length);\n  };\n  const undo = () => {\n    const state = undoStack.value.shift();\n    if (state) {\n      redoStack.value.unshift(last.value);\n      _setSource(state);\n    }\n  };\n  const redo = () => {\n    const state = redoStack.value.shift();\n    if (state) {\n      undoStack.value.unshift(last.value);\n      _setSource(state);\n    }\n  };\n  const reset = () => {\n    _setSource(last.value);\n  };\n  const history = computed(() => [last.value, ...undoStack.value]);\n  const canUndo = computed(() => undoStack.value.length > 0);\n  const canRedo = computed(() => redoStack.value.length > 0);\n  return {\n    source,\n    undoStack,\n    redoStack,\n    last,\n    history,\n    canUndo,\n    canRedo,\n    clear,\n    commit,\n    reset,\n    undo,\n    redo\n  };\n}\n\nfunction useRefHistory(source, options = {}) {\n  const {\n    deep = false,\n    flush = \"pre\",\n    eventFilter\n  } = options;\n  const {\n    eventFilter: composedFilter,\n    pause,\n    resume: resumeTracking,\n    isActive: isTracking\n  } = pausableFilter(eventFilter);\n  const {\n    ignoreUpdates,\n    ignorePrevAsyncUpdates,\n    stop\n  } = watchIgnorable(\n    source,\n    commit,\n    { deep, flush, eventFilter: composedFilter }\n  );\n  function setSource(source2, value) {\n    ignorePrevAsyncUpdates();\n    ignoreUpdates(() => {\n      source2.value = value;\n    });\n  }\n  const manualHistory = useManualRefHistory(source, { ...options, clone: options.clone || deep, setSource });\n  const { clear, commit: manualCommit } = manualHistory;\n  function commit() {\n    ignorePrevAsyncUpdates();\n    manualCommit();\n  }\n  function resume(commitNow) {\n    resumeTracking();\n    if (commitNow)\n      commit();\n  }\n  function batch(fn) {\n    let canceled = false;\n    const cancel = () => canceled = true;\n    ignoreUpdates(() => {\n      fn(cancel);\n    });\n    if (!canceled)\n      commit();\n  }\n  function dispose() {\n    stop();\n    clear();\n  }\n  return {\n    ...manualHistory,\n    isTracking,\n    pause,\n    resume,\n    commit,\n    batch,\n    dispose\n  };\n}\n\nfunction useDebouncedRefHistory(source, options = {}) {\n  const filter = options.debounce ? debounceFilter(options.debounce) : void 0;\n  const history = useRefHistory(source, { ...options, eventFilter: filter });\n  return {\n    ...history\n  };\n}\n\nfunction useDeviceMotion(options = {}) {\n  const {\n    window = defaultWindow,\n    eventFilter = bypassFilter\n  } = options;\n  const acceleration = ref({ x: null, y: null, z: null });\n  const rotationRate = ref({ alpha: null, beta: null, gamma: null });\n  const interval = ref(0);\n  const accelerationIncludingGravity = ref({\n    x: null,\n    y: null,\n    z: null\n  });\n  if (window) {\n    const onDeviceMotion = createFilterWrapper(\n      eventFilter,\n      (event) => {\n        acceleration.value = event.acceleration;\n        accelerationIncludingGravity.value = event.accelerationIncludingGravity;\n        rotationRate.value = event.rotationRate;\n        interval.value = event.interval;\n      }\n    );\n    useEventListener(window, \"devicemotion\", onDeviceMotion);\n  }\n  return {\n    acceleration,\n    accelerationIncludingGravity,\n    rotationRate,\n    interval\n  };\n}\n\nfunction useDeviceOrientation(options = {}) {\n  const { window = defaultWindow } = options;\n  const isSupported = useSupported(() => window && \"DeviceOrientationEvent\" in window);\n  const isAbsolute = ref(false);\n  const alpha = ref(null);\n  const beta = ref(null);\n  const gamma = ref(null);\n  if (window && isSupported.value) {\n    useEventListener(window, \"deviceorientation\", (event) => {\n      isAbsolute.value = event.absolute;\n      alpha.value = event.alpha;\n      beta.value = event.beta;\n      gamma.value = event.gamma;\n    });\n  }\n  return {\n    isSupported,\n    isAbsolute,\n    alpha,\n    beta,\n    gamma\n  };\n}\n\nfunction useDevicePixelRatio(options = {}) {\n  const {\n    window = defaultWindow\n  } = options;\n  const pixelRatio = ref(1);\n  if (window) {\n    let observe2 = function() {\n      pixelRatio.value = window.devicePixelRatio;\n      cleanup2();\n      media = window.matchMedia(`(resolution: ${pixelRatio.value}dppx)`);\n      media.addEventListener(\"change\", observe2, { once: true });\n    }, cleanup2 = function() {\n      media == null ? void 0 : media.removeEventListener(\"change\", observe2);\n    };\n    let media;\n    observe2();\n    tryOnScopeDispose(cleanup2);\n  }\n  return { pixelRatio };\n}\n\nfunction useDevicesList(options = {}) {\n  const {\n    navigator = defaultNavigator,\n    requestPermissions = false,\n    constraints = { audio: true, video: true },\n    onUpdated\n  } = options;\n  const devices = ref([]);\n  const videoInputs = computed(() => devices.value.filter((i) => i.kind === \"videoinput\"));\n  const audioInputs = computed(() => devices.value.filter((i) => i.kind === \"audioinput\"));\n  const audioOutputs = computed(() => devices.value.filter((i) => i.kind === \"audiooutput\"));\n  const isSupported = useSupported(() => navigator && navigator.mediaDevices && navigator.mediaDevices.enumerateDevices);\n  const permissionGranted = ref(false);\n  let stream;\n  async function update() {\n    if (!isSupported.value)\n      return;\n    devices.value = await navigator.mediaDevices.enumerateDevices();\n    onUpdated == null ? void 0 : onUpdated(devices.value);\n    if (stream) {\n      stream.getTracks().forEach((t) => t.stop());\n      stream = null;\n    }\n  }\n  async function ensurePermissions() {\n    if (!isSupported.value)\n      return false;\n    if (permissionGranted.value)\n      return true;\n    const { state, query } = usePermission(\"camera\", { controls: true });\n    await query();\n    if (state.value !== \"granted\") {\n      let granted = true;\n      try {\n        stream = await navigator.mediaDevices.getUserMedia(constraints);\n      } catch (e) {\n        stream = null;\n        granted = false;\n      }\n      update();\n      permissionGranted.value = granted;\n    } else {\n      permissionGranted.value = true;\n    }\n    return permissionGranted.value;\n  }\n  if (isSupported.value) {\n    if (requestPermissions)\n      ensurePermissions();\n    useEventListener(navigator.mediaDevices, \"devicechange\", update);\n    update();\n  }\n  return {\n    devices,\n    ensurePermissions,\n    permissionGranted,\n    videoInputs,\n    audioInputs,\n    audioOutputs,\n    isSupported\n  };\n}\n\nfunction useDisplayMedia(options = {}) {\n  var _a;\n  const enabled = ref((_a = options.enabled) != null ? _a : false);\n  const video = options.video;\n  const audio = options.audio;\n  const { navigator = defaultNavigator } = options;\n  const isSupported = useSupported(() => {\n    var _a2;\n    return (_a2 = navigator == null ? void 0 : navigator.mediaDevices) == null ? void 0 : _a2.getDisplayMedia;\n  });\n  const constraint = { audio, video };\n  const stream = shallowRef();\n  async function _start() {\n    var _a2;\n    if (!isSupported.value || stream.value)\n      return;\n    stream.value = await navigator.mediaDevices.getDisplayMedia(constraint);\n    (_a2 = stream.value) == null ? void 0 : _a2.getTracks().forEach((t) => t.addEventListener(\"ended\", stop));\n    return stream.value;\n  }\n  async function _stop() {\n    var _a2;\n    (_a2 = stream.value) == null ? void 0 : _a2.getTracks().forEach((t) => t.stop());\n    stream.value = void 0;\n  }\n  function stop() {\n    _stop();\n    enabled.value = false;\n  }\n  async function start() {\n    await _start();\n    if (stream.value)\n      enabled.value = true;\n    return stream.value;\n  }\n  watch(\n    enabled,\n    (v) => {\n      if (v)\n        _start();\n      else\n        _stop();\n    },\n    { immediate: true }\n  );\n  return {\n    isSupported,\n    stream,\n    start,\n    stop,\n    enabled\n  };\n}\n\nfunction useDocumentVisibility(options = {}) {\n  const { document = defaultDocument } = options;\n  if (!document)\n    return ref(\"visible\");\n  const visibility = ref(document.visibilityState);\n  useEventListener(document, \"visibilitychange\", () => {\n    visibility.value = document.visibilityState;\n  });\n  return visibility;\n}\n\nfunction useDraggable(target, options = {}) {\n  var _a, _b;\n  const {\n    pointerTypes,\n    preventDefault,\n    stopPropagation,\n    exact,\n    onMove,\n    onEnd,\n    onStart,\n    initialValue,\n    axis = \"both\",\n    draggingElement = defaultWindow,\n    containerElement,\n    handle: draggingHandle = target,\n    buttons = [0]\n  } = options;\n  const position = ref(\n    (_a = toValue(initialValue)) != null ? _a : { x: 0, y: 0 }\n  );\n  const pressedDelta = ref();\n  const filterEvent = (e) => {\n    if (pointerTypes)\n      return pointerTypes.includes(e.pointerType);\n    return true;\n  };\n  const handleEvent = (e) => {\n    if (toValue(preventDefault))\n      e.preventDefault();\n    if (toValue(stopPropagation))\n      e.stopPropagation();\n  };\n  const start = (e) => {\n    var _a2;\n    if (!toValue(buttons).includes(e.button))\n      return;\n    if (toValue(options.disabled) || !filterEvent(e))\n      return;\n    if (toValue(exact) && e.target !== toValue(target))\n      return;\n    const container = toValue(containerElement);\n    const containerRect = (_a2 = container == null ? void 0 : container.getBoundingClientRect) == null ? void 0 : _a2.call(container);\n    const targetRect = toValue(target).getBoundingClientRect();\n    const pos = {\n      x: e.clientX - (container ? targetRect.left - containerRect.left + container.scrollLeft : targetRect.left),\n      y: e.clientY - (container ? targetRect.top - containerRect.top + container.scrollTop : targetRect.top)\n    };\n    if ((onStart == null ? void 0 : onStart(pos, e)) === false)\n      return;\n    pressedDelta.value = pos;\n    handleEvent(e);\n  };\n  const move = (e) => {\n    if (toValue(options.disabled) || !filterEvent(e))\n      return;\n    if (!pressedDelta.value)\n      return;\n    const container = toValue(containerElement);\n    const targetRect = toValue(target).getBoundingClientRect();\n    let { x, y } = position.value;\n    if (axis === \"x\" || axis === \"both\") {\n      x = e.clientX - pressedDelta.value.x;\n      if (container)\n        x = Math.min(Math.max(0, x), container.scrollWidth - targetRect.width);\n    }\n    if (axis === \"y\" || axis === \"both\") {\n      y = e.clientY - pressedDelta.value.y;\n      if (container)\n        y = Math.min(Math.max(0, y), container.scrollHeight - targetRect.height);\n    }\n    position.value = {\n      x,\n      y\n    };\n    onMove == null ? void 0 : onMove(position.value, e);\n    handleEvent(e);\n  };\n  const end = (e) => {\n    if (toValue(options.disabled) || !filterEvent(e))\n      return;\n    if (!pressedDelta.value)\n      return;\n    pressedDelta.value = void 0;\n    onEnd == null ? void 0 : onEnd(position.value, e);\n    handleEvent(e);\n  };\n  if (isClient) {\n    const config = { capture: (_b = options.capture) != null ? _b : true };\n    useEventListener(draggingHandle, \"pointerdown\", start, config);\n    useEventListener(draggingElement, \"pointermove\", move, config);\n    useEventListener(draggingElement, \"pointerup\", end, config);\n  }\n  return {\n    ...toRefs(position),\n    position,\n    isDragging: computed(() => !!pressedDelta.value),\n    style: computed(\n      () => `left:${position.value.x}px;top:${position.value.y}px;`\n    )\n  };\n}\n\nfunction useDropZone(target, options = {}) {\n  var _a, _b;\n  const isOverDropZone = ref(false);\n  const files = shallowRef(null);\n  let counter = 0;\n  let isValid = true;\n  if (isClient) {\n    const _options = typeof options === \"function\" ? { onDrop: options } : options;\n    const multiple = (_a = _options.multiple) != null ? _a : true;\n    const preventDefaultForUnhandled = (_b = _options.preventDefaultForUnhandled) != null ? _b : false;\n    const getFiles = (event) => {\n      var _a2, _b2;\n      const list = Array.from((_b2 = (_a2 = event.dataTransfer) == null ? void 0 : _a2.files) != null ? _b2 : []);\n      return list.length === 0 ? null : multiple ? list : [list[0]];\n    };\n    const checkDataTypes = (types) => {\n      if (_options.dataTypes) {\n        const dataTypes = unref(_options.dataTypes);\n        return typeof dataTypes === \"function\" ? dataTypes(types) : dataTypes ? dataTypes.some((item) => types.includes(item)) : true;\n      }\n      return true;\n    };\n    const checkValidity = (event) => {\n      var _a2, _b2;\n      const items = Array.from((_b2 = (_a2 = event.dataTransfer) == null ? void 0 : _a2.items) != null ? _b2 : []);\n      const types = items.map((item) => item.type);\n      const dataTypesValid = checkDataTypes(types);\n      const multipleFilesValid = multiple || items.length <= 1;\n      return dataTypesValid && multipleFilesValid;\n    };\n    const handleDragEvent = (event, eventType) => {\n      var _a2, _b2, _c, _d;\n      isValid = checkValidity(event);\n      if (!isValid) {\n        if (preventDefaultForUnhandled) {\n          event.preventDefault();\n        }\n        if (event.dataTransfer) {\n          event.dataTransfer.dropEffect = \"none\";\n        }\n        return;\n      }\n      event.preventDefault();\n      if (event.dataTransfer) {\n        event.dataTransfer.dropEffect = \"copy\";\n      }\n      const currentFiles = getFiles(event);\n      switch (eventType) {\n        case \"enter\":\n          counter += 1;\n          isOverDropZone.value = true;\n          (_a2 = _options.onEnter) == null ? void 0 : _a2.call(_options, null, event);\n          break;\n        case \"over\":\n          (_b2 = _options.onOver) == null ? void 0 : _b2.call(_options, null, event);\n          break;\n        case \"leave\":\n          counter -= 1;\n          if (counter === 0)\n            isOverDropZone.value = false;\n          (_c = _options.onLeave) == null ? void 0 : _c.call(_options, null, event);\n          break;\n        case \"drop\":\n          counter = 0;\n          isOverDropZone.value = false;\n          if (isValid) {\n            files.value = currentFiles;\n            (_d = _options.onDrop) == null ? void 0 : _d.call(_options, currentFiles, event);\n          }\n          break;\n      }\n    };\n    useEventListener(target, \"dragenter\", (event) => handleDragEvent(event, \"enter\"));\n    useEventListener(target, \"dragover\", (event) => handleDragEvent(event, \"over\"));\n    useEventListener(target, \"dragleave\", (event) => handleDragEvent(event, \"leave\"));\n    useEventListener(target, \"drop\", (event) => handleDragEvent(event, \"drop\"));\n  }\n  return {\n    files,\n    isOverDropZone\n  };\n}\n\nfunction useResizeObserver(target, callback, options = {}) {\n  const { window = defaultWindow, ...observerOptions } = options;\n  let observer;\n  const isSupported = useSupported(() => window && \"ResizeObserver\" in window);\n  const cleanup = () => {\n    if (observer) {\n      observer.disconnect();\n      observer = void 0;\n    }\n  };\n  const targets = computed(() => {\n    const _targets = toValue(target);\n    return Array.isArray(_targets) ? _targets.map((el) => unrefElement(el)) : [unrefElement(_targets)];\n  });\n  const stopWatch = watch(\n    targets,\n    (els) => {\n      cleanup();\n      if (isSupported.value && window) {\n        observer = new ResizeObserver(callback);\n        for (const _el of els) {\n          if (_el)\n            observer.observe(_el, observerOptions);\n        }\n      }\n    },\n    { immediate: true, flush: \"post\" }\n  );\n  const stop = () => {\n    cleanup();\n    stopWatch();\n  };\n  tryOnScopeDispose(stop);\n  return {\n    isSupported,\n    stop\n  };\n}\n\nfunction useElementBounding(target, options = {}) {\n  const {\n    reset = true,\n    windowResize = true,\n    windowScroll = true,\n    immediate = true,\n    updateTiming = \"sync\"\n  } = options;\n  const height = ref(0);\n  const bottom = ref(0);\n  const left = ref(0);\n  const right = ref(0);\n  const top = ref(0);\n  const width = ref(0);\n  const x = ref(0);\n  const y = ref(0);\n  function recalculate() {\n    const el = unrefElement(target);\n    if (!el) {\n      if (reset) {\n        height.value = 0;\n        bottom.value = 0;\n        left.value = 0;\n        right.value = 0;\n        top.value = 0;\n        width.value = 0;\n        x.value = 0;\n        y.value = 0;\n      }\n      return;\n    }\n    const rect = el.getBoundingClientRect();\n    height.value = rect.height;\n    bottom.value = rect.bottom;\n    left.value = rect.left;\n    right.value = rect.right;\n    top.value = rect.top;\n    width.value = rect.width;\n    x.value = rect.x;\n    y.value = rect.y;\n  }\n  function update() {\n    if (updateTiming === \"sync\")\n      recalculate();\n    else if (updateTiming === \"next-frame\")\n      requestAnimationFrame(() => recalculate());\n  }\n  useResizeObserver(target, update);\n  watch(() => unrefElement(target), (ele) => !ele && update());\n  useMutationObserver(target, update, {\n    attributeFilter: [\"style\", \"class\"]\n  });\n  if (windowScroll)\n    useEventListener(\"scroll\", update, { capture: true, passive: true });\n  if (windowResize)\n    useEventListener(\"resize\", update, { passive: true });\n  tryOnMounted(() => {\n    if (immediate)\n      update();\n  });\n  return {\n    height,\n    bottom,\n    left,\n    right,\n    top,\n    width,\n    x,\n    y,\n    update\n  };\n}\n\nfunction useElementByPoint(options) {\n  const {\n    x,\n    y,\n    document = defaultDocument,\n    multiple,\n    interval = \"requestAnimationFrame\",\n    immediate = true\n  } = options;\n  const isSupported = useSupported(() => {\n    if (toValue(multiple))\n      return document && \"elementsFromPoint\" in document;\n    return document && \"elementFromPoint\" in document;\n  });\n  const element = ref(null);\n  const cb = () => {\n    var _a, _b;\n    element.value = toValue(multiple) ? (_a = document == null ? void 0 : document.elementsFromPoint(toValue(x), toValue(y))) != null ? _a : [] : (_b = document == null ? void 0 : document.elementFromPoint(toValue(x), toValue(y))) != null ? _b : null;\n  };\n  const controls = interval === \"requestAnimationFrame\" ? useRafFn(cb, { immediate }) : useIntervalFn(cb, interval, { immediate });\n  return {\n    isSupported,\n    element,\n    ...controls\n  };\n}\n\nfunction useElementHover(el, options = {}) {\n  const {\n    delayEnter = 0,\n    delayLeave = 0,\n    window = defaultWindow\n  } = options;\n  const isHovered = ref(false);\n  let timer;\n  const toggle = (entering) => {\n    const delay = entering ? delayEnter : delayLeave;\n    if (timer) {\n      clearTimeout(timer);\n      timer = void 0;\n    }\n    if (delay)\n      timer = setTimeout(() => isHovered.value = entering, delay);\n    else\n      isHovered.value = entering;\n  };\n  if (!window)\n    return isHovered;\n  useEventListener(el, \"mouseenter\", () => toggle(true), { passive: true });\n  useEventListener(el, \"mouseleave\", () => toggle(false), { passive: true });\n  return isHovered;\n}\n\nfunction useElementSize(target, initialSize = { width: 0, height: 0 }, options = {}) {\n  const { window = defaultWindow, box = \"content-box\" } = options;\n  const isSVG = computed(() => {\n    var _a, _b;\n    return (_b = (_a = unrefElement(target)) == null ? void 0 : _a.namespaceURI) == null ? void 0 : _b.includes(\"svg\");\n  });\n  const width = ref(initialSize.width);\n  const height = ref(initialSize.height);\n  const { stop: stop1 } = useResizeObserver(\n    target,\n    ([entry]) => {\n      const boxSize = box === \"border-box\" ? entry.borderBoxSize : box === \"content-box\" ? entry.contentBoxSize : entry.devicePixelContentBoxSize;\n      if (window && isSVG.value) {\n        const $elem = unrefElement(target);\n        if ($elem) {\n          const rect = $elem.getBoundingClientRect();\n          width.value = rect.width;\n          height.value = rect.height;\n        }\n      } else {\n        if (boxSize) {\n          const formatBoxSize = Array.isArray(boxSize) ? boxSize : [boxSize];\n          width.value = formatBoxSize.reduce((acc, { inlineSize }) => acc + inlineSize, 0);\n          height.value = formatBoxSize.reduce((acc, { blockSize }) => acc + blockSize, 0);\n        } else {\n          width.value = entry.contentRect.width;\n          height.value = entry.contentRect.height;\n        }\n      }\n    },\n    options\n  );\n  tryOnMounted(() => {\n    const ele = unrefElement(target);\n    if (ele) {\n      width.value = \"offsetWidth\" in ele ? ele.offsetWidth : initialSize.width;\n      height.value = \"offsetHeight\" in ele ? ele.offsetHeight : initialSize.height;\n    }\n  });\n  const stop2 = watch(\n    () => unrefElement(target),\n    (ele) => {\n      width.value = ele ? initialSize.width : 0;\n      height.value = ele ? initialSize.height : 0;\n    }\n  );\n  function stop() {\n    stop1();\n    stop2();\n  }\n  return {\n    width,\n    height,\n    stop\n  };\n}\n\nfunction useIntersectionObserver(target, callback, options = {}) {\n  const {\n    root,\n    rootMargin = \"0px\",\n    threshold = 0,\n    window = defaultWindow,\n    immediate = true\n  } = options;\n  const isSupported = useSupported(() => window && \"IntersectionObserver\" in window);\n  const targets = computed(() => {\n    const _target = toValue(target);\n    return (Array.isArray(_target) ? _target : [_target]).map(unrefElement).filter(notNullish);\n  });\n  let cleanup = noop;\n  const isActive = ref(immediate);\n  const stopWatch = isSupported.value ? watch(\n    () => [targets.value, unrefElement(root), isActive.value],\n    ([targets2, root2]) => {\n      cleanup();\n      if (!isActive.value)\n        return;\n      if (!targets2.length)\n        return;\n      const observer = new IntersectionObserver(\n        callback,\n        {\n          root: unrefElement(root2),\n          rootMargin,\n          threshold\n        }\n      );\n      targets2.forEach((el) => el && observer.observe(el));\n      cleanup = () => {\n        observer.disconnect();\n        cleanup = noop;\n      };\n    },\n    { immediate, flush: \"post\" }\n  ) : noop;\n  const stop = () => {\n    cleanup();\n    stopWatch();\n    isActive.value = false;\n  };\n  tryOnScopeDispose(stop);\n  return {\n    isSupported,\n    isActive,\n    pause() {\n      cleanup();\n      isActive.value = false;\n    },\n    resume() {\n      isActive.value = true;\n    },\n    stop\n  };\n}\n\nfunction useElementVisibility(element, options = {}) {\n  const { window = defaultWindow, scrollTarget, threshold = 0 } = options;\n  const elementIsVisible = ref(false);\n  useIntersectionObserver(\n    element,\n    (intersectionObserverEntries) => {\n      let isIntersecting = elementIsVisible.value;\n      let latestTime = 0;\n      for (const entry of intersectionObserverEntries) {\n        if (entry.time >= latestTime) {\n          latestTime = entry.time;\n          isIntersecting = entry.isIntersecting;\n        }\n      }\n      elementIsVisible.value = isIntersecting;\n    },\n    {\n      root: scrollTarget,\n      window,\n      threshold\n    }\n  );\n  return elementIsVisible;\n}\n\nconst events = /* @__PURE__ */ new Map();\n\nfunction useEventBus(key) {\n  const scope = getCurrentScope();\n  function on(listener) {\n    var _a;\n    const listeners = events.get(key) || /* @__PURE__ */ new Set();\n    listeners.add(listener);\n    events.set(key, listeners);\n    const _off = () => off(listener);\n    (_a = scope == null ? void 0 : scope.cleanups) == null ? void 0 : _a.push(_off);\n    return _off;\n  }\n  function once(listener) {\n    function _listener(...args) {\n      off(_listener);\n      listener(...args);\n    }\n    return on(_listener);\n  }\n  function off(listener) {\n    const listeners = events.get(key);\n    if (!listeners)\n      return;\n    listeners.delete(listener);\n    if (!listeners.size)\n      reset();\n  }\n  function reset() {\n    events.delete(key);\n  }\n  function emit(event, payload) {\n    var _a;\n    (_a = events.get(key)) == null ? void 0 : _a.forEach((v) => v(event, payload));\n  }\n  return { on, once, off, emit, reset };\n}\n\nfunction resolveNestedOptions$1(options) {\n  if (options === true)\n    return {};\n  return options;\n}\nfunction useEventSource(url, events = [], options = {}) {\n  const event = ref(null);\n  const data = ref(null);\n  const status = ref(\"CONNECTING\");\n  const eventSource = ref(null);\n  const error = shallowRef(null);\n  const urlRef = toRef(url);\n  const lastEventId = shallowRef(null);\n  let explicitlyClosed = false;\n  let retried = 0;\n  const {\n    withCredentials = false,\n    immediate = true\n  } = options;\n  const close = () => {\n    if (isClient && eventSource.value) {\n      eventSource.value.close();\n      eventSource.value = null;\n      status.value = \"CLOSED\";\n      explicitlyClosed = true;\n    }\n  };\n  const _init = () => {\n    if (explicitlyClosed || typeof urlRef.value === \"undefined\")\n      return;\n    const es = new EventSource(urlRef.value, { withCredentials });\n    status.value = \"CONNECTING\";\n    eventSource.value = es;\n    es.onopen = () => {\n      status.value = \"OPEN\";\n      error.value = null;\n    };\n    es.onerror = (e) => {\n      status.value = \"CLOSED\";\n      error.value = e;\n      if (es.readyState === 2 && !explicitlyClosed && options.autoReconnect) {\n        es.close();\n        const {\n          retries = -1,\n          delay = 1e3,\n          onFailed\n        } = resolveNestedOptions$1(options.autoReconnect);\n        retried += 1;\n        if (typeof retries === \"number\" && (retries < 0 || retried < retries))\n          setTimeout(_init, delay);\n        else if (typeof retries === \"function\" && retries())\n          setTimeout(_init, delay);\n        else\n          onFailed == null ? void 0 : onFailed();\n      }\n    };\n    es.onmessage = (e) => {\n      event.value = null;\n      data.value = e.data;\n      lastEventId.value = e.lastEventId;\n    };\n    for (const event_name of events) {\n      useEventListener(es, event_name, (e) => {\n        event.value = event_name;\n        data.value = e.data || null;\n      });\n    }\n  };\n  const open = () => {\n    if (!isClient)\n      return;\n    close();\n    explicitlyClosed = false;\n    retried = 0;\n    _init();\n  };\n  if (immediate)\n    watch(urlRef, open, { immediate: true });\n  tryOnScopeDispose(close);\n  return {\n    eventSource,\n    event,\n    data,\n    status,\n    error,\n    open,\n    close,\n    lastEventId\n  };\n}\n\nfunction useEyeDropper(options = {}) {\n  const { initialValue = \"\" } = options;\n  const isSupported = useSupported(() => typeof window !== \"undefined\" && \"EyeDropper\" in window);\n  const sRGBHex = ref(initialValue);\n  async function open(openOptions) {\n    if (!isSupported.value)\n      return;\n    const eyeDropper = new window.EyeDropper();\n    const result = await eyeDropper.open(openOptions);\n    sRGBHex.value = result.sRGBHex;\n    return result;\n  }\n  return { isSupported, sRGBHex, open };\n}\n\nfunction useFavicon(newIcon = null, options = {}) {\n  const {\n    baseUrl = \"\",\n    rel = \"icon\",\n    document = defaultDocument\n  } = options;\n  const favicon = toRef(newIcon);\n  const applyIcon = (icon) => {\n    const elements = document == null ? void 0 : document.head.querySelectorAll(`link[rel*=\"${rel}\"]`);\n    if (!elements || elements.length === 0) {\n      const link = document == null ? void 0 : document.createElement(\"link\");\n      if (link) {\n        link.rel = rel;\n        link.href = `${baseUrl}${icon}`;\n        link.type = `image/${icon.split(\".\").pop()}`;\n        document == null ? void 0 : document.head.append(link);\n      }\n      return;\n    }\n    elements == null ? void 0 : elements.forEach((el) => el.href = `${baseUrl}${icon}`);\n  };\n  watch(\n    favicon,\n    (i, o) => {\n      if (typeof i === \"string\" && i !== o)\n        applyIcon(i);\n    },\n    { immediate: true }\n  );\n  return favicon;\n}\n\nconst payloadMapping = {\n  json: \"application/json\",\n  text: \"text/plain\"\n};\nfunction isFetchOptions(obj) {\n  return obj && containsProp(obj, \"immediate\", \"refetch\", \"initialData\", \"timeout\", \"beforeFetch\", \"afterFetch\", \"onFetchError\", \"fetch\", \"updateDataOnError\");\n}\nconst reAbsolute = /^(?:[a-z][a-z\\d+\\-.]*:)?\\/\\//i;\nfunction isAbsoluteURL(url) {\n  return reAbsolute.test(url);\n}\nfunction headersToObject(headers) {\n  if (typeof Headers !== \"undefined\" && headers instanceof Headers)\n    return Object.fromEntries(headers.entries());\n  return headers;\n}\nfunction combineCallbacks(combination, ...callbacks) {\n  if (combination === \"overwrite\") {\n    return async (ctx) => {\n      const callback = callbacks[callbacks.length - 1];\n      if (callback)\n        return { ...ctx, ...await callback(ctx) };\n      return ctx;\n    };\n  } else {\n    return async (ctx) => {\n      for (const callback of callbacks) {\n        if (callback)\n          ctx = { ...ctx, ...await callback(ctx) };\n      }\n      return ctx;\n    };\n  }\n}\nfunction createFetch(config = {}) {\n  const _combination = config.combination || \"chain\";\n  const _options = config.options || {};\n  const _fetchOptions = config.fetchOptions || {};\n  function useFactoryFetch(url, ...args) {\n    const computedUrl = computed(() => {\n      const baseUrl = toValue(config.baseUrl);\n      const targetUrl = toValue(url);\n      return baseUrl && !isAbsoluteURL(targetUrl) ? joinPaths(baseUrl, targetUrl) : targetUrl;\n    });\n    let options = _options;\n    let fetchOptions = _fetchOptions;\n    if (args.length > 0) {\n      if (isFetchOptions(args[0])) {\n        options = {\n          ...options,\n          ...args[0],\n          beforeFetch: combineCallbacks(_combination, _options.beforeFetch, args[0].beforeFetch),\n          afterFetch: combineCallbacks(_combination, _options.afterFetch, args[0].afterFetch),\n          onFetchError: combineCallbacks(_combination, _options.onFetchError, args[0].onFetchError)\n        };\n      } else {\n        fetchOptions = {\n          ...fetchOptions,\n          ...args[0],\n          headers: {\n            ...headersToObject(fetchOptions.headers) || {},\n            ...headersToObject(args[0].headers) || {}\n          }\n        };\n      }\n    }\n    if (args.length > 1 && isFetchOptions(args[1])) {\n      options = {\n        ...options,\n        ...args[1],\n        beforeFetch: combineCallbacks(_combination, _options.beforeFetch, args[1].beforeFetch),\n        afterFetch: combineCallbacks(_combination, _options.afterFetch, args[1].afterFetch),\n        onFetchError: combineCallbacks(_combination, _options.onFetchError, args[1].onFetchError)\n      };\n    }\n    return useFetch(computedUrl, fetchOptions, options);\n  }\n  return useFactoryFetch;\n}\nfunction useFetch(url, ...args) {\n  var _a;\n  const supportsAbort = typeof AbortController === \"function\";\n  let fetchOptions = {};\n  let options = {\n    immediate: true,\n    refetch: false,\n    timeout: 0,\n    updateDataOnError: false\n  };\n  const config = {\n    method: \"GET\",\n    type: \"text\",\n    payload: void 0\n  };\n  if (args.length > 0) {\n    if (isFetchOptions(args[0]))\n      options = { ...options, ...args[0] };\n    else\n      fetchOptions = args[0];\n  }\n  if (args.length > 1) {\n    if (isFetchOptions(args[1]))\n      options = { ...options, ...args[1] };\n  }\n  const {\n    fetch = (_a = defaultWindow) == null ? void 0 : _a.fetch,\n    initialData,\n    timeout\n  } = options;\n  const responseEvent = createEventHook();\n  const errorEvent = createEventHook();\n  const finallyEvent = createEventHook();\n  const isFinished = ref(false);\n  const isFetching = ref(false);\n  const aborted = ref(false);\n  const statusCode = ref(null);\n  const response = shallowRef(null);\n  const error = shallowRef(null);\n  const data = shallowRef(initialData || null);\n  const canAbort = computed(() => supportsAbort && isFetching.value);\n  let controller;\n  let timer;\n  const abort = () => {\n    if (supportsAbort) {\n      controller == null ? void 0 : controller.abort();\n      controller = new AbortController();\n      controller.signal.onabort = () => aborted.value = true;\n      fetchOptions = {\n        ...fetchOptions,\n        signal: controller.signal\n      };\n    }\n  };\n  const loading = (isLoading) => {\n    isFetching.value = isLoading;\n    isFinished.value = !isLoading;\n  };\n  if (timeout)\n    timer = useTimeoutFn(abort, timeout, { immediate: false });\n  let executeCounter = 0;\n  const execute = async (throwOnFailed = false) => {\n    var _a2, _b;\n    abort();\n    loading(true);\n    error.value = null;\n    statusCode.value = null;\n    aborted.value = false;\n    executeCounter += 1;\n    const currentExecuteCounter = executeCounter;\n    const defaultFetchOptions = {\n      method: config.method,\n      headers: {}\n    };\n    if (config.payload) {\n      const headers = headersToObject(defaultFetchOptions.headers);\n      const payload = toValue(config.payload);\n      if (!config.payloadType && payload && Object.getPrototypeOf(payload) === Object.prototype && !(payload instanceof FormData))\n        config.payloadType = \"json\";\n      if (config.payloadType)\n        headers[\"Content-Type\"] = (_a2 = payloadMapping[config.payloadType]) != null ? _a2 : config.payloadType;\n      defaultFetchOptions.body = config.payloadType === \"json\" ? JSON.stringify(payload) : payload;\n    }\n    let isCanceled = false;\n    const context = {\n      url: toValue(url),\n      options: {\n        ...defaultFetchOptions,\n        ...fetchOptions\n      },\n      cancel: () => {\n        isCanceled = true;\n      }\n    };\n    if (options.beforeFetch)\n      Object.assign(context, await options.beforeFetch(context));\n    if (isCanceled || !fetch) {\n      loading(false);\n      return Promise.resolve(null);\n    }\n    let responseData = null;\n    if (timer)\n      timer.start();\n    return fetch(\n      context.url,\n      {\n        ...defaultFetchOptions,\n        ...context.options,\n        headers: {\n          ...headersToObject(defaultFetchOptions.headers),\n          ...headersToObject((_b = context.options) == null ? void 0 : _b.headers)\n        }\n      }\n    ).then(async (fetchResponse) => {\n      response.value = fetchResponse;\n      statusCode.value = fetchResponse.status;\n      responseData = await fetchResponse.clone()[config.type]();\n      if (!fetchResponse.ok) {\n        data.value = initialData || null;\n        throw new Error(fetchResponse.statusText);\n      }\n      if (options.afterFetch) {\n        ({ data: responseData } = await options.afterFetch({\n          data: responseData,\n          response: fetchResponse\n        }));\n      }\n      data.value = responseData;\n      responseEvent.trigger(fetchResponse);\n      return fetchResponse;\n    }).catch(async (fetchError) => {\n      let errorData = fetchError.message || fetchError.name;\n      if (options.onFetchError) {\n        ({ error: errorData, data: responseData } = await options.onFetchError({\n          data: responseData,\n          error: fetchError,\n          response: response.value\n        }));\n      }\n      error.value = errorData;\n      if (options.updateDataOnError)\n        data.value = responseData;\n      errorEvent.trigger(fetchError);\n      if (throwOnFailed)\n        throw fetchError;\n      return null;\n    }).finally(() => {\n      if (currentExecuteCounter === executeCounter)\n        loading(false);\n      if (timer)\n        timer.stop();\n      finallyEvent.trigger(null);\n    });\n  };\n  const refetch = toRef(options.refetch);\n  watch(\n    [\n      refetch,\n      toRef(url)\n    ],\n    ([refetch2]) => refetch2 && execute(),\n    { deep: true }\n  );\n  const shell = {\n    isFinished: readonly(isFinished),\n    isFetching: readonly(isFetching),\n    statusCode,\n    response,\n    error,\n    data,\n    canAbort,\n    aborted,\n    abort,\n    execute,\n    onFetchResponse: responseEvent.on,\n    onFetchError: errorEvent.on,\n    onFetchFinally: finallyEvent.on,\n    // method\n    get: setMethod(\"GET\"),\n    put: setMethod(\"PUT\"),\n    post: setMethod(\"POST\"),\n    delete: setMethod(\"DELETE\"),\n    patch: setMethod(\"PATCH\"),\n    head: setMethod(\"HEAD\"),\n    options: setMethod(\"OPTIONS\"),\n    // type\n    json: setType(\"json\"),\n    text: setType(\"text\"),\n    blob: setType(\"blob\"),\n    arrayBuffer: setType(\"arrayBuffer\"),\n    formData: setType(\"formData\")\n  };\n  function setMethod(method) {\n    return (payload, payloadType) => {\n      if (!isFetching.value) {\n        config.method = method;\n        config.payload = payload;\n        config.payloadType = payloadType;\n        if (isRef(config.payload)) {\n          watch(\n            [\n              refetch,\n              toRef(config.payload)\n            ],\n            ([refetch2]) => refetch2 && execute(),\n            { deep: true }\n          );\n        }\n        return {\n          ...shell,\n          then(onFulfilled, onRejected) {\n            return waitUntilFinished().then(onFulfilled, onRejected);\n          }\n        };\n      }\n      return void 0;\n    };\n  }\n  function waitUntilFinished() {\n    return new Promise((resolve, reject) => {\n      until(isFinished).toBe(true).then(() => resolve(shell)).catch((error2) => reject(error2));\n    });\n  }\n  function setType(type) {\n    return () => {\n      if (!isFetching.value) {\n        config.type = type;\n        return {\n          ...shell,\n          then(onFulfilled, onRejected) {\n            return waitUntilFinished().then(onFulfilled, onRejected);\n          }\n        };\n      }\n      return void 0;\n    };\n  }\n  if (options.immediate)\n    Promise.resolve().then(() => execute());\n  return {\n    ...shell,\n    then(onFulfilled, onRejected) {\n      return waitUntilFinished().then(onFulfilled, onRejected);\n    }\n  };\n}\nfunction joinPaths(start, end) {\n  if (!start.endsWith(\"/\") && !end.startsWith(\"/\"))\n    return `${start}/${end}`;\n  return `${start}${end}`;\n}\n\nconst DEFAULT_OPTIONS = {\n  multiple: true,\n  accept: \"*\",\n  reset: false,\n  directory: false\n};\nfunction useFileDialog(options = {}) {\n  const {\n    document = defaultDocument\n  } = options;\n  const files = ref(null);\n  const { on: onChange, trigger: changeTrigger } = createEventHook();\n  const { on: onCancel, trigger: cancelTrigger } = createEventHook();\n  let input;\n  if (document) {\n    input = document.createElement(\"input\");\n    input.type = \"file\";\n    input.onchange = (event) => {\n      const result = event.target;\n      files.value = result.files;\n      changeTrigger(files.value);\n    };\n    input.oncancel = () => {\n      cancelTrigger();\n    };\n  }\n  const reset = () => {\n    files.value = null;\n    if (input && input.value) {\n      input.value = \"\";\n      changeTrigger(null);\n    }\n  };\n  const open = (localOptions) => {\n    if (!input)\n      return;\n    const _options = {\n      ...DEFAULT_OPTIONS,\n      ...options,\n      ...localOptions\n    };\n    input.multiple = _options.multiple;\n    input.accept = _options.accept;\n    input.webkitdirectory = _options.directory;\n    if (hasOwn(_options, \"capture\"))\n      input.capture = _options.capture;\n    if (_options.reset)\n      reset();\n    input.click();\n  };\n  return {\n    files: readonly(files),\n    open,\n    reset,\n    onCancel,\n    onChange\n  };\n}\n\nfunction useFileSystemAccess(options = {}) {\n  const {\n    window: _window = defaultWindow,\n    dataType = \"Text\"\n  } = options;\n  const window = _window;\n  const isSupported = useSupported(() => window && \"showSaveFilePicker\" in window && \"showOpenFilePicker\" in window);\n  const fileHandle = ref();\n  const data = ref();\n  const file = ref();\n  const fileName = computed(() => {\n    var _a, _b;\n    return (_b = (_a = file.value) == null ? void 0 : _a.name) != null ? _b : \"\";\n  });\n  const fileMIME = computed(() => {\n    var _a, _b;\n    return (_b = (_a = file.value) == null ? void 0 : _a.type) != null ? _b : \"\";\n  });\n  const fileSize = computed(() => {\n    var _a, _b;\n    return (_b = (_a = file.value) == null ? void 0 : _a.size) != null ? _b : 0;\n  });\n  const fileLastModified = computed(() => {\n    var _a, _b;\n    return (_b = (_a = file.value) == null ? void 0 : _a.lastModified) != null ? _b : 0;\n  });\n  async function open(_options = {}) {\n    if (!isSupported.value)\n      return;\n    const [handle] = await window.showOpenFilePicker({ ...toValue(options), ..._options });\n    fileHandle.value = handle;\n    await updateData();\n  }\n  async function create(_options = {}) {\n    if (!isSupported.value)\n      return;\n    fileHandle.value = await window.showSaveFilePicker({ ...options, ..._options });\n    data.value = void 0;\n    await updateData();\n  }\n  async function save(_options = {}) {\n    if (!isSupported.value)\n      return;\n    if (!fileHandle.value)\n      return saveAs(_options);\n    if (data.value) {\n      const writableStream = await fileHandle.value.createWritable();\n      await writableStream.write(data.value);\n      await writableStream.close();\n    }\n    await updateFile();\n  }\n  async function saveAs(_options = {}) {\n    if (!isSupported.value)\n      return;\n    fileHandle.value = await window.showSaveFilePicker({ ...options, ..._options });\n    if (data.value) {\n      const writableStream = await fileHandle.value.createWritable();\n      await writableStream.write(data.value);\n      await writableStream.close();\n    }\n    await updateFile();\n  }\n  async function updateFile() {\n    var _a;\n    file.value = await ((_a = fileHandle.value) == null ? void 0 : _a.getFile());\n  }\n  async function updateData() {\n    var _a, _b;\n    await updateFile();\n    const type = toValue(dataType);\n    if (type === \"Text\")\n      data.value = await ((_a = file.value) == null ? void 0 : _a.text());\n    else if (type === \"ArrayBuffer\")\n      data.value = await ((_b = file.value) == null ? void 0 : _b.arrayBuffer());\n    else if (type === \"Blob\")\n      data.value = file.value;\n  }\n  watch(() => toValue(dataType), updateData);\n  return {\n    isSupported,\n    data,\n    file,\n    fileName,\n    fileMIME,\n    fileSize,\n    fileLastModified,\n    open,\n    create,\n    save,\n    saveAs,\n    updateData\n  };\n}\n\nfunction useFocus(target, options = {}) {\n  const { initialValue = false, focusVisible = false, preventScroll = false } = options;\n  const innerFocused = ref(false);\n  const targetElement = computed(() => unrefElement(target));\n  useEventListener(targetElement, \"focus\", (event) => {\n    var _a, _b;\n    if (!focusVisible || ((_b = (_a = event.target).matches) == null ? void 0 : _b.call(_a, \":focus-visible\")))\n      innerFocused.value = true;\n  });\n  useEventListener(targetElement, \"blur\", () => innerFocused.value = false);\n  const focused = computed({\n    get: () => innerFocused.value,\n    set(value) {\n      var _a, _b;\n      if (!value && innerFocused.value)\n        (_a = targetElement.value) == null ? void 0 : _a.blur();\n      else if (value && !innerFocused.value)\n        (_b = targetElement.value) == null ? void 0 : _b.focus({ preventScroll });\n    }\n  });\n  watch(\n    targetElement,\n    () => {\n      focused.value = initialValue;\n    },\n    { immediate: true, flush: \"post\" }\n  );\n  return { focused };\n}\n\nconst EVENT_FOCUS_IN = \"focusin\";\nconst EVENT_FOCUS_OUT = \"focusout\";\nfunction useFocusWithin(target, options = {}) {\n  const { window = defaultWindow } = options;\n  const targetElement = computed(() => unrefElement(target));\n  const _focused = ref(false);\n  const focused = computed(() => _focused.value);\n  const activeElement = useActiveElement(options);\n  if (!window || !activeElement.value) {\n    return { focused };\n  }\n  useEventListener(targetElement, EVENT_FOCUS_IN, () => _focused.value = true);\n  useEventListener(targetElement, EVENT_FOCUS_OUT, () => _focused.value = false);\n  return { focused };\n}\n\nfunction useFps(options) {\n  var _a;\n  const fps = ref(0);\n  if (typeof performance === \"undefined\")\n    return fps;\n  const every = (_a = options == null ? void 0 : options.every) != null ? _a : 10;\n  let last = performance.now();\n  let ticks = 0;\n  useRafFn(() => {\n    ticks += 1;\n    if (ticks >= every) {\n      const now = performance.now();\n      const diff = now - last;\n      fps.value = Math.round(1e3 / (diff / ticks));\n      last = now;\n      ticks = 0;\n    }\n  });\n  return fps;\n}\n\nconst eventHandlers = [\n  \"fullscreenchange\",\n  \"webkitfullscreenchange\",\n  \"webkitendfullscreen\",\n  \"mozfullscreenchange\",\n  \"MSFullscreenChange\"\n];\nfunction useFullscreen(target, options = {}) {\n  const {\n    document = defaultDocument,\n    autoExit = false\n  } = options;\n  const targetRef = computed(() => {\n    var _a;\n    return (_a = unrefElement(target)) != null ? _a : document == null ? void 0 : document.querySelector(\"html\");\n  });\n  const isFullscreen = ref(false);\n  const requestMethod = computed(() => {\n    return [\n      \"requestFullscreen\",\n      \"webkitRequestFullscreen\",\n      \"webkitEnterFullscreen\",\n      \"webkitEnterFullScreen\",\n      \"webkitRequestFullScreen\",\n      \"mozRequestFullScreen\",\n      \"msRequestFullscreen\"\n    ].find((m) => document && m in document || targetRef.value && m in targetRef.value);\n  });\n  const exitMethod = computed(() => {\n    return [\n      \"exitFullscreen\",\n      \"webkitExitFullscreen\",\n      \"webkitExitFullScreen\",\n      \"webkitCancelFullScreen\",\n      \"mozCancelFullScreen\",\n      \"msExitFullscreen\"\n    ].find((m) => document && m in document || targetRef.value && m in targetRef.value);\n  });\n  const fullscreenEnabled = computed(() => {\n    return [\n      \"fullScreen\",\n      \"webkitIsFullScreen\",\n      \"webkitDisplayingFullscreen\",\n      \"mozFullScreen\",\n      \"msFullscreenElement\"\n    ].find((m) => document && m in document || targetRef.value && m in targetRef.value);\n  });\n  const fullscreenElementMethod = [\n    \"fullscreenElement\",\n    \"webkitFullscreenElement\",\n    \"mozFullScreenElement\",\n    \"msFullscreenElement\"\n  ].find((m) => document && m in document);\n  const isSupported = useSupported(() => targetRef.value && document && requestMethod.value !== void 0 && exitMethod.value !== void 0 && fullscreenEnabled.value !== void 0);\n  const isCurrentElementFullScreen = () => {\n    if (fullscreenElementMethod)\n      return (document == null ? void 0 : document[fullscreenElementMethod]) === targetRef.value;\n    return false;\n  };\n  const isElementFullScreen = () => {\n    if (fullscreenEnabled.value) {\n      if (document && document[fullscreenEnabled.value] != null) {\n        return document[fullscreenEnabled.value];\n      } else {\n        const target2 = targetRef.value;\n        if ((target2 == null ? void 0 : target2[fullscreenEnabled.value]) != null) {\n          return Boolean(target2[fullscreenEnabled.value]);\n        }\n      }\n    }\n    return false;\n  };\n  async function exit() {\n    if (!isSupported.value || !isFullscreen.value)\n      return;\n    if (exitMethod.value) {\n      if ((document == null ? void 0 : document[exitMethod.value]) != null) {\n        await document[exitMethod.value]();\n      } else {\n        const target2 = targetRef.value;\n        if ((target2 == null ? void 0 : target2[exitMethod.value]) != null)\n          await target2[exitMethod.value]();\n      }\n    }\n    isFullscreen.value = false;\n  }\n  async function enter() {\n    if (!isSupported.value || isFullscreen.value)\n      return;\n    if (isElementFullScreen())\n      await exit();\n    const target2 = targetRef.value;\n    if (requestMethod.value && (target2 == null ? void 0 : target2[requestMethod.value]) != null) {\n      await target2[requestMethod.value]();\n      isFullscreen.value = true;\n    }\n  }\n  async function toggle() {\n    await (isFullscreen.value ? exit() : enter());\n  }\n  const handlerCallback = () => {\n    const isElementFullScreenValue = isElementFullScreen();\n    if (!isElementFullScreenValue || isElementFullScreenValue && isCurrentElementFullScreen())\n      isFullscreen.value = isElementFullScreenValue;\n  };\n  useEventListener(document, eventHandlers, handlerCallback, false);\n  useEventListener(() => unrefElement(targetRef), eventHandlers, handlerCallback, false);\n  if (autoExit)\n    tryOnScopeDispose(exit);\n  return {\n    isSupported,\n    isFullscreen,\n    enter,\n    exit,\n    toggle\n  };\n}\n\nfunction mapGamepadToXbox360Controller(gamepad) {\n  return computed(() => {\n    if (gamepad.value) {\n      return {\n        buttons: {\n          a: gamepad.value.buttons[0],\n          b: gamepad.value.buttons[1],\n          x: gamepad.value.buttons[2],\n          y: gamepad.value.buttons[3]\n        },\n        bumper: {\n          left: gamepad.value.buttons[4],\n          right: gamepad.value.buttons[5]\n        },\n        triggers: {\n          left: gamepad.value.buttons[6],\n          right: gamepad.value.buttons[7]\n        },\n        stick: {\n          left: {\n            horizontal: gamepad.value.axes[0],\n            vertical: gamepad.value.axes[1],\n            button: gamepad.value.buttons[10]\n          },\n          right: {\n            horizontal: gamepad.value.axes[2],\n            vertical: gamepad.value.axes[3],\n            button: gamepad.value.buttons[11]\n          }\n        },\n        dpad: {\n          up: gamepad.value.buttons[12],\n          down: gamepad.value.buttons[13],\n          left: gamepad.value.buttons[14],\n          right: gamepad.value.buttons[15]\n        },\n        back: gamepad.value.buttons[8],\n        start: gamepad.value.buttons[9]\n      };\n    }\n    return null;\n  });\n}\nfunction useGamepad(options = {}) {\n  const {\n    navigator = defaultNavigator\n  } = options;\n  const isSupported = useSupported(() => navigator && \"getGamepads\" in navigator);\n  const gamepads = ref([]);\n  const onConnectedHook = createEventHook();\n  const onDisconnectedHook = createEventHook();\n  const stateFromGamepad = (gamepad) => {\n    const hapticActuators = [];\n    const vibrationActuator = \"vibrationActuator\" in gamepad ? gamepad.vibrationActuator : null;\n    if (vibrationActuator)\n      hapticActuators.push(vibrationActuator);\n    if (gamepad.hapticActuators)\n      hapticActuators.push(...gamepad.hapticActuators);\n    return {\n      id: gamepad.id,\n      index: gamepad.index,\n      connected: gamepad.connected,\n      mapping: gamepad.mapping,\n      timestamp: gamepad.timestamp,\n      vibrationActuator: gamepad.vibrationActuator,\n      hapticActuators,\n      axes: gamepad.axes.map((axes) => axes),\n      buttons: gamepad.buttons.map((button) => ({ pressed: button.pressed, touched: button.touched, value: button.value }))\n    };\n  };\n  const updateGamepadState = () => {\n    const _gamepads = (navigator == null ? void 0 : navigator.getGamepads()) || [];\n    for (const gamepad of _gamepads) {\n      if (gamepad && gamepads.value[gamepad.index])\n        gamepads.value[gamepad.index] = stateFromGamepad(gamepad);\n    }\n  };\n  const { isActive, pause, resume } = useRafFn(updateGamepadState);\n  const onGamepadConnected = (gamepad) => {\n    if (!gamepads.value.some(({ index }) => index === gamepad.index)) {\n      gamepads.value.push(stateFromGamepad(gamepad));\n      onConnectedHook.trigger(gamepad.index);\n    }\n    resume();\n  };\n  const onGamepadDisconnected = (gamepad) => {\n    gamepads.value = gamepads.value.filter((x) => x.index !== gamepad.index);\n    onDisconnectedHook.trigger(gamepad.index);\n  };\n  useEventListener(\"gamepadconnected\", (e) => onGamepadConnected(e.gamepad));\n  useEventListener(\"gamepaddisconnected\", (e) => onGamepadDisconnected(e.gamepad));\n  tryOnMounted(() => {\n    const _gamepads = (navigator == null ? void 0 : navigator.getGamepads()) || [];\n    for (const gamepad of _gamepads) {\n      if (gamepad && gamepads.value[gamepad.index])\n        onGamepadConnected(gamepad);\n    }\n  });\n  pause();\n  return {\n    isSupported,\n    onConnected: onConnectedHook.on,\n    onDisconnected: onDisconnectedHook.on,\n    gamepads,\n    pause,\n    resume,\n    isActive\n  };\n}\n\nfunction useGeolocation(options = {}) {\n  const {\n    enableHighAccuracy = true,\n    maximumAge = 3e4,\n    timeout = 27e3,\n    navigator = defaultNavigator,\n    immediate = true\n  } = options;\n  const isSupported = useSupported(() => navigator && \"geolocation\" in navigator);\n  const locatedAt = ref(null);\n  const error = shallowRef(null);\n  const coords = ref({\n    accuracy: 0,\n    latitude: Number.POSITIVE_INFINITY,\n    longitude: Number.POSITIVE_INFINITY,\n    altitude: null,\n    altitudeAccuracy: null,\n    heading: null,\n    speed: null\n  });\n  function updatePosition(position) {\n    locatedAt.value = position.timestamp;\n    coords.value = position.coords;\n    error.value = null;\n  }\n  let watcher;\n  function resume() {\n    if (isSupported.value) {\n      watcher = navigator.geolocation.watchPosition(\n        updatePosition,\n        (err) => error.value = err,\n        {\n          enableHighAccuracy,\n          maximumAge,\n          timeout\n        }\n      );\n    }\n  }\n  if (immediate)\n    resume();\n  function pause() {\n    if (watcher && navigator)\n      navigator.geolocation.clearWatch(watcher);\n  }\n  tryOnScopeDispose(() => {\n    pause();\n  });\n  return {\n    isSupported,\n    coords,\n    locatedAt,\n    error,\n    resume,\n    pause\n  };\n}\n\nconst defaultEvents$1 = [\"mousemove\", \"mousedown\", \"resize\", \"keydown\", \"touchstart\", \"wheel\"];\nconst oneMinute = 6e4;\nfunction useIdle(timeout = oneMinute, options = {}) {\n  const {\n    initialState = false,\n    listenForVisibilityChange = true,\n    events = defaultEvents$1,\n    window = defaultWindow,\n    eventFilter = throttleFilter(50)\n  } = options;\n  const idle = ref(initialState);\n  const lastActive = ref(timestamp());\n  let timer;\n  const reset = () => {\n    idle.value = false;\n    clearTimeout(timer);\n    timer = setTimeout(() => idle.value = true, timeout);\n  };\n  const onEvent = createFilterWrapper(\n    eventFilter,\n    () => {\n      lastActive.value = timestamp();\n      reset();\n    }\n  );\n  if (window) {\n    const document = window.document;\n    for (const event of events)\n      useEventListener(window, event, onEvent, { passive: true });\n    if (listenForVisibilityChange) {\n      useEventListener(document, \"visibilitychange\", () => {\n        if (!document.hidden)\n          onEvent();\n      });\n    }\n    reset();\n  }\n  return {\n    idle,\n    lastActive,\n    reset\n  };\n}\n\nasync function loadImage(options) {\n  return new Promise((resolve, reject) => {\n    const img = new Image();\n    const { src, srcset, sizes, class: clazz, loading, crossorigin, referrerPolicy } = options;\n    img.src = src;\n    if (srcset)\n      img.srcset = srcset;\n    if (sizes)\n      img.sizes = sizes;\n    if (clazz)\n      img.className = clazz;\n    if (loading)\n      img.loading = loading;\n    if (crossorigin)\n      img.crossOrigin = crossorigin;\n    if (referrerPolicy)\n      img.referrerPolicy = referrerPolicy;\n    img.onload = () => resolve(img);\n    img.onerror = reject;\n  });\n}\nfunction useImage(options, asyncStateOptions = {}) {\n  const state = useAsyncState(\n    () => loadImage(toValue(options)),\n    void 0,\n    {\n      resetOnExecute: true,\n      ...asyncStateOptions\n    }\n  );\n  watch(\n    () => toValue(options),\n    () => state.execute(asyncStateOptions.delay),\n    { deep: true }\n  );\n  return state;\n}\n\nfunction resolveElement(el) {\n  if (typeof Window !== \"undefined\" && el instanceof Window)\n    return el.document.documentElement;\n  if (typeof Document !== \"undefined\" && el instanceof Document)\n    return el.documentElement;\n  return el;\n}\n\nconst ARRIVED_STATE_THRESHOLD_PIXELS = 1;\nfunction useScroll(element, options = {}) {\n  const {\n    throttle = 0,\n    idle = 200,\n    onStop = noop,\n    onScroll = noop,\n    offset = {\n      left: 0,\n      right: 0,\n      top: 0,\n      bottom: 0\n    },\n    eventListenerOptions = {\n      capture: false,\n      passive: true\n    },\n    behavior = \"auto\",\n    window = defaultWindow,\n    onError = (e) => {\n      console.error(e);\n    }\n  } = options;\n  const internalX = ref(0);\n  const internalY = ref(0);\n  const x = computed({\n    get() {\n      return internalX.value;\n    },\n    set(x2) {\n      scrollTo(x2, void 0);\n    }\n  });\n  const y = computed({\n    get() {\n      return internalY.value;\n    },\n    set(y2) {\n      scrollTo(void 0, y2);\n    }\n  });\n  function scrollTo(_x, _y) {\n    var _a, _b, _c, _d;\n    if (!window)\n      return;\n    const _element = toValue(element);\n    if (!_element)\n      return;\n    (_c = _element instanceof Document ? window.document.body : _element) == null ? void 0 : _c.scrollTo({\n      top: (_a = toValue(_y)) != null ? _a : y.value,\n      left: (_b = toValue(_x)) != null ? _b : x.value,\n      behavior: toValue(behavior)\n    });\n    const scrollContainer = ((_d = _element == null ? void 0 : _element.document) == null ? void 0 : _d.documentElement) || (_element == null ? void 0 : _element.documentElement) || _element;\n    if (x != null)\n      internalX.value = scrollContainer.scrollLeft;\n    if (y != null)\n      internalY.value = scrollContainer.scrollTop;\n  }\n  const isScrolling = ref(false);\n  const arrivedState = reactive({\n    left: true,\n    right: false,\n    top: true,\n    bottom: false\n  });\n  const directions = reactive({\n    left: false,\n    right: false,\n    top: false,\n    bottom: false\n  });\n  const onScrollEnd = (e) => {\n    if (!isScrolling.value)\n      return;\n    isScrolling.value = false;\n    directions.left = false;\n    directions.right = false;\n    directions.top = false;\n    directions.bottom = false;\n    onStop(e);\n  };\n  const onScrollEndDebounced = useDebounceFn(onScrollEnd, throttle + idle);\n  const setArrivedState = (target) => {\n    var _a;\n    if (!window)\n      return;\n    const el = ((_a = target == null ? void 0 : target.document) == null ? void 0 : _a.documentElement) || (target == null ? void 0 : target.documentElement) || unrefElement(target);\n    const { display, flexDirection } = getComputedStyle(el);\n    const scrollLeft = el.scrollLeft;\n    directions.left = scrollLeft < internalX.value;\n    directions.right = scrollLeft > internalX.value;\n    const left = Math.abs(scrollLeft) <= (offset.left || 0);\n    const right = Math.abs(scrollLeft) + el.clientWidth >= el.scrollWidth - (offset.right || 0) - ARRIVED_STATE_THRESHOLD_PIXELS;\n    if (display === \"flex\" && flexDirection === \"row-reverse\") {\n      arrivedState.left = right;\n      arrivedState.right = left;\n    } else {\n      arrivedState.left = left;\n      arrivedState.right = right;\n    }\n    internalX.value = scrollLeft;\n    let scrollTop = el.scrollTop;\n    if (target === window.document && !scrollTop)\n      scrollTop = window.document.body.scrollTop;\n    directions.top = scrollTop < internalY.value;\n    directions.bottom = scrollTop > internalY.value;\n    const top = Math.abs(scrollTop) <= (offset.top || 0);\n    const bottom = Math.abs(scrollTop) + el.clientHeight >= el.scrollHeight - (offset.bottom || 0) - ARRIVED_STATE_THRESHOLD_PIXELS;\n    if (display === \"flex\" && flexDirection === \"column-reverse\") {\n      arrivedState.top = bottom;\n      arrivedState.bottom = top;\n    } else {\n      arrivedState.top = top;\n      arrivedState.bottom = bottom;\n    }\n    internalY.value = scrollTop;\n  };\n  const onScrollHandler = (e) => {\n    var _a;\n    if (!window)\n      return;\n    const eventTarget = (_a = e.target.documentElement) != null ? _a : e.target;\n    setArrivedState(eventTarget);\n    isScrolling.value = true;\n    onScrollEndDebounced(e);\n    onScroll(e);\n  };\n  useEventListener(\n    element,\n    \"scroll\",\n    throttle ? useThrottleFn(onScrollHandler, throttle, true, false) : onScrollHandler,\n    eventListenerOptions\n  );\n  tryOnMounted(() => {\n    try {\n      const _element = toValue(element);\n      if (!_element)\n        return;\n      setArrivedState(_element);\n    } catch (e) {\n      onError(e);\n    }\n  });\n  useEventListener(\n    element,\n    \"scrollend\",\n    onScrollEnd,\n    eventListenerOptions\n  );\n  return {\n    x,\n    y,\n    isScrolling,\n    arrivedState,\n    directions,\n    measure() {\n      const _element = toValue(element);\n      if (window && _element)\n        setArrivedState(_element);\n    }\n  };\n}\n\nfunction useInfiniteScroll(element, onLoadMore, options = {}) {\n  var _a;\n  const {\n    direction = \"bottom\",\n    interval = 100,\n    canLoadMore = () => true\n  } = options;\n  const state = reactive(useScroll(\n    element,\n    {\n      ...options,\n      offset: {\n        [direction]: (_a = options.distance) != null ? _a : 0,\n        ...options.offset\n      }\n    }\n  ));\n  const promise = ref();\n  const isLoading = computed(() => !!promise.value);\n  const observedElement = computed(() => {\n    return resolveElement(toValue(element));\n  });\n  const isElementVisible = useElementVisibility(observedElement);\n  function checkAndLoad() {\n    state.measure();\n    if (!observedElement.value || !isElementVisible.value || !canLoadMore(observedElement.value))\n      return;\n    const { scrollHeight, clientHeight, scrollWidth, clientWidth } = observedElement.value;\n    const isNarrower = direction === \"bottom\" || direction === \"top\" ? scrollHeight <= clientHeight : scrollWidth <= clientWidth;\n    if (state.arrivedState[direction] || isNarrower) {\n      if (!promise.value) {\n        promise.value = Promise.all([\n          onLoadMore(state),\n          new Promise((resolve) => setTimeout(resolve, interval))\n        ]).finally(() => {\n          promise.value = null;\n          nextTick(() => checkAndLoad());\n        });\n      }\n    }\n  }\n  const stop = watch(\n    () => [state.arrivedState[direction], isElementVisible.value],\n    checkAndLoad,\n    { immediate: true }\n  );\n  tryOnUnmounted(stop);\n  return {\n    isLoading,\n    reset() {\n      nextTick(() => checkAndLoad());\n    }\n  };\n}\n\nconst defaultEvents = [\"mousedown\", \"mouseup\", \"keydown\", \"keyup\"];\nfunction useKeyModifier(modifier, options = {}) {\n  const {\n    events = defaultEvents,\n    document = defaultDocument,\n    initial = null\n  } = options;\n  const state = ref(initial);\n  if (document) {\n    events.forEach((listenerEvent) => {\n      useEventListener(document, listenerEvent, (evt) => {\n        if (typeof evt.getModifierState === \"function\")\n          state.value = evt.getModifierState(modifier);\n      });\n    });\n  }\n  return state;\n}\n\nfunction useLocalStorage(key, initialValue, options = {}) {\n  const { window = defaultWindow } = options;\n  return useStorage(key, initialValue, window == null ? void 0 : window.localStorage, options);\n}\n\nconst DefaultMagicKeysAliasMap = {\n  ctrl: \"control\",\n  command: \"meta\",\n  cmd: \"meta\",\n  option: \"alt\",\n  up: \"arrowup\",\n  down: \"arrowdown\",\n  left: \"arrowleft\",\n  right: \"arrowright\"\n};\n\nfunction useMagicKeys(options = {}) {\n  const {\n    reactive: useReactive = false,\n    target = defaultWindow,\n    aliasMap = DefaultMagicKeysAliasMap,\n    passive = true,\n    onEventFired = noop\n  } = options;\n  const current = reactive(/* @__PURE__ */ new Set());\n  const obj = {\n    toJSON() {\n      return {};\n    },\n    current\n  };\n  const refs = useReactive ? reactive(obj) : obj;\n  const metaDeps = /* @__PURE__ */ new Set();\n  const usedKeys = /* @__PURE__ */ new Set();\n  function setRefs(key, value) {\n    if (key in refs) {\n      if (useReactive)\n        refs[key] = value;\n      else\n        refs[key].value = value;\n    }\n  }\n  function reset() {\n    current.clear();\n    for (const key of usedKeys)\n      setRefs(key, false);\n  }\n  function updateRefs(e, value) {\n    var _a, _b;\n    const key = (_a = e.key) == null ? void 0 : _a.toLowerCase();\n    const code = (_b = e.code) == null ? void 0 : _b.toLowerCase();\n    const values = [code, key].filter(Boolean);\n    if (key) {\n      if (value)\n        current.add(key);\n      else\n        current.delete(key);\n    }\n    for (const key2 of values) {\n      usedKeys.add(key2);\n      setRefs(key2, value);\n    }\n    if (key === \"meta\" && !value) {\n      metaDeps.forEach((key2) => {\n        current.delete(key2);\n        setRefs(key2, false);\n      });\n      metaDeps.clear();\n    } else if (typeof e.getModifierState === \"function\" && e.getModifierState(\"Meta\") && value) {\n      [...current, ...values].forEach((key2) => metaDeps.add(key2));\n    }\n  }\n  useEventListener(target, \"keydown\", (e) => {\n    updateRefs(e, true);\n    return onEventFired(e);\n  }, { passive });\n  useEventListener(target, \"keyup\", (e) => {\n    updateRefs(e, false);\n    return onEventFired(e);\n  }, { passive });\n  useEventListener(\"blur\", reset, { passive: true });\n  useEventListener(\"focus\", reset, { passive: true });\n  const proxy = new Proxy(\n    refs,\n    {\n      get(target2, prop, rec) {\n        if (typeof prop !== \"string\")\n          return Reflect.get(target2, prop, rec);\n        prop = prop.toLowerCase();\n        if (prop in aliasMap)\n          prop = aliasMap[prop];\n        if (!(prop in refs)) {\n          if (/[+_-]/.test(prop)) {\n            const keys = prop.split(/[+_-]/g).map((i) => i.trim());\n            refs[prop] = computed(() => keys.every((key) => toValue(proxy[key])));\n          } else {\n            refs[prop] = ref(false);\n          }\n        }\n        const r = Reflect.get(target2, prop, rec);\n        return useReactive ? toValue(r) : r;\n      }\n    }\n  );\n  return proxy;\n}\n\nfunction usingElRef(source, cb) {\n  if (toValue(source))\n    cb(toValue(source));\n}\nfunction timeRangeToArray(timeRanges) {\n  let ranges = [];\n  for (let i = 0; i < timeRanges.length; ++i)\n    ranges = [...ranges, [timeRanges.start(i), timeRanges.end(i)]];\n  return ranges;\n}\nfunction tracksToArray(tracks) {\n  return Array.from(tracks).map(({ label, kind, language, mode, activeCues, cues, inBandMetadataTrackDispatchType }, id) => ({ id, label, kind, language, mode, activeCues, cues, inBandMetadataTrackDispatchType }));\n}\nconst defaultOptions = {\n  src: \"\",\n  tracks: []\n};\nfunction useMediaControls(target, options = {}) {\n  target = toRef(target);\n  options = {\n    ...defaultOptions,\n    ...options\n  };\n  const {\n    document = defaultDocument\n  } = options;\n  const currentTime = ref(0);\n  const duration = ref(0);\n  const seeking = ref(false);\n  const volume = ref(1);\n  const waiting = ref(false);\n  const ended = ref(false);\n  const playing = ref(false);\n  const rate = ref(1);\n  const stalled = ref(false);\n  const buffered = ref([]);\n  const tracks = ref([]);\n  const selectedTrack = ref(-1);\n  const isPictureInPicture = ref(false);\n  const muted = ref(false);\n  const supportsPictureInPicture = document && \"pictureInPictureEnabled\" in document;\n  const sourceErrorEvent = createEventHook();\n  const playbackErrorEvent = createEventHook();\n  const disableTrack = (track) => {\n    usingElRef(target, (el) => {\n      if (track) {\n        const id = typeof track === \"number\" ? track : track.id;\n        el.textTracks[id].mode = \"disabled\";\n      } else {\n        for (let i = 0; i < el.textTracks.length; ++i)\n          el.textTracks[i].mode = \"disabled\";\n      }\n      selectedTrack.value = -1;\n    });\n  };\n  const enableTrack = (track, disableTracks = true) => {\n    usingElRef(target, (el) => {\n      const id = typeof track === \"number\" ? track : track.id;\n      if (disableTracks)\n        disableTrack();\n      el.textTracks[id].mode = \"showing\";\n      selectedTrack.value = id;\n    });\n  };\n  const togglePictureInPicture = () => {\n    return new Promise((resolve, reject) => {\n      usingElRef(target, async (el) => {\n        if (supportsPictureInPicture) {\n          if (!isPictureInPicture.value) {\n            el.requestPictureInPicture().then(resolve).catch(reject);\n          } else {\n            document.exitPictureInPicture().then(resolve).catch(reject);\n          }\n        }\n      });\n    });\n  };\n  watchEffect(() => {\n    if (!document)\n      return;\n    const el = toValue(target);\n    if (!el)\n      return;\n    const src = toValue(options.src);\n    let sources = [];\n    if (!src)\n      return;\n    if (typeof src === \"string\")\n      sources = [{ src }];\n    else if (Array.isArray(src))\n      sources = src;\n    else if (isObject(src))\n      sources = [src];\n    el.querySelectorAll(\"source\").forEach((e) => {\n      e.removeEventListener(\"error\", sourceErrorEvent.trigger);\n      e.remove();\n    });\n    sources.forEach(({ src: src2, type }) => {\n      const source = document.createElement(\"source\");\n      source.setAttribute(\"src\", src2);\n      source.setAttribute(\"type\", type || \"\");\n      source.addEventListener(\"error\", sourceErrorEvent.trigger);\n      el.appendChild(source);\n    });\n    el.load();\n  });\n  tryOnScopeDispose(() => {\n    const el = toValue(target);\n    if (!el)\n      return;\n    el.querySelectorAll(\"source\").forEach((e) => e.removeEventListener(\"error\", sourceErrorEvent.trigger));\n  });\n  watch([target, volume], () => {\n    const el = toValue(target);\n    if (!el)\n      return;\n    el.volume = volume.value;\n  });\n  watch([target, muted], () => {\n    const el = toValue(target);\n    if (!el)\n      return;\n    el.muted = muted.value;\n  });\n  watch([target, rate], () => {\n    const el = toValue(target);\n    if (!el)\n      return;\n    el.playbackRate = rate.value;\n  });\n  watchEffect(() => {\n    if (!document)\n      return;\n    const textTracks = toValue(options.tracks);\n    const el = toValue(target);\n    if (!textTracks || !textTracks.length || !el)\n      return;\n    el.querySelectorAll(\"track\").forEach((e) => e.remove());\n    textTracks.forEach(({ default: isDefault, kind, label, src, srcLang }, i) => {\n      const track = document.createElement(\"track\");\n      track.default = isDefault || false;\n      track.kind = kind;\n      track.label = label;\n      track.src = src;\n      track.srclang = srcLang;\n      if (track.default)\n        selectedTrack.value = i;\n      el.appendChild(track);\n    });\n  });\n  const { ignoreUpdates: ignoreCurrentTimeUpdates } = watchIgnorable(currentTime, (time) => {\n    const el = toValue(target);\n    if (!el)\n      return;\n    el.currentTime = time;\n  });\n  const { ignoreUpdates: ignorePlayingUpdates } = watchIgnorable(playing, (isPlaying) => {\n    const el = toValue(target);\n    if (!el)\n      return;\n    if (isPlaying) {\n      el.play().catch((e) => {\n        playbackErrorEvent.trigger(e);\n        throw e;\n      });\n    } else {\n      el.pause();\n    }\n  });\n  useEventListener(target, \"timeupdate\", () => ignoreCurrentTimeUpdates(() => currentTime.value = toValue(target).currentTime));\n  useEventListener(target, \"durationchange\", () => duration.value = toValue(target).duration);\n  useEventListener(target, \"progress\", () => buffered.value = timeRangeToArray(toValue(target).buffered));\n  useEventListener(target, \"seeking\", () => seeking.value = true);\n  useEventListener(target, \"seeked\", () => seeking.value = false);\n  useEventListener(target, [\"waiting\", \"loadstart\"], () => {\n    waiting.value = true;\n    ignorePlayingUpdates(() => playing.value = false);\n  });\n  useEventListener(target, \"loadeddata\", () => waiting.value = false);\n  useEventListener(target, \"playing\", () => {\n    waiting.value = false;\n    ended.value = false;\n    ignorePlayingUpdates(() => playing.value = true);\n  });\n  useEventListener(target, \"ratechange\", () => rate.value = toValue(target).playbackRate);\n  useEventListener(target, \"stalled\", () => stalled.value = true);\n  useEventListener(target, \"ended\", () => ended.value = true);\n  useEventListener(target, \"pause\", () => ignorePlayingUpdates(() => playing.value = false));\n  useEventListener(target, \"play\", () => ignorePlayingUpdates(() => playing.value = true));\n  useEventListener(target, \"enterpictureinpicture\", () => isPictureInPicture.value = true);\n  useEventListener(target, \"leavepictureinpicture\", () => isPictureInPicture.value = false);\n  useEventListener(target, \"volumechange\", () => {\n    const el = toValue(target);\n    if (!el)\n      return;\n    volume.value = el.volume;\n    muted.value = el.muted;\n  });\n  const listeners = [];\n  const stop = watch([target], () => {\n    const el = toValue(target);\n    if (!el)\n      return;\n    stop();\n    listeners[0] = useEventListener(el.textTracks, \"addtrack\", () => tracks.value = tracksToArray(el.textTracks));\n    listeners[1] = useEventListener(el.textTracks, \"removetrack\", () => tracks.value = tracksToArray(el.textTracks));\n    listeners[2] = useEventListener(el.textTracks, \"change\", () => tracks.value = tracksToArray(el.textTracks));\n  });\n  tryOnScopeDispose(() => listeners.forEach((listener) => listener()));\n  return {\n    currentTime,\n    duration,\n    waiting,\n    seeking,\n    ended,\n    stalled,\n    buffered,\n    playing,\n    rate,\n    // Volume\n    volume,\n    muted,\n    // Tracks\n    tracks,\n    selectedTrack,\n    enableTrack,\n    disableTrack,\n    // Picture in Picture\n    supportsPictureInPicture,\n    togglePictureInPicture,\n    isPictureInPicture,\n    // Events\n    onSourceError: sourceErrorEvent.on,\n    onPlaybackError: playbackErrorEvent.on\n  };\n}\n\nfunction getMapVue2Compat() {\n  const data = shallowReactive({});\n  return {\n    get: (key) => data[key],\n    set: (key, value) => set(data, key, value),\n    has: (key) => hasOwn(data, key),\n    delete: (key) => del(data, key),\n    clear: () => {\n      Object.keys(data).forEach((key) => {\n        del(data, key);\n      });\n    }\n  };\n}\nfunction useMemoize(resolver, options) {\n  const initCache = () => {\n    if (options == null ? void 0 : options.cache)\n      return shallowReactive(options.cache);\n    if (isVue2)\n      return getMapVue2Compat();\n    return shallowReactive(/* @__PURE__ */ new Map());\n  };\n  const cache = initCache();\n  const generateKey = (...args) => (options == null ? void 0 : options.getKey) ? options.getKey(...args) : JSON.stringify(args);\n  const _loadData = (key, ...args) => {\n    cache.set(key, resolver(...args));\n    return cache.get(key);\n  };\n  const loadData = (...args) => _loadData(generateKey(...args), ...args);\n  const deleteData = (...args) => {\n    cache.delete(generateKey(...args));\n  };\n  const clearData = () => {\n    cache.clear();\n  };\n  const memoized = (...args) => {\n    const key = generateKey(...args);\n    if (cache.has(key))\n      return cache.get(key);\n    return _loadData(key, ...args);\n  };\n  memoized.load = loadData;\n  memoized.delete = deleteData;\n  memoized.clear = clearData;\n  memoized.generateKey = generateKey;\n  memoized.cache = cache;\n  return memoized;\n}\n\nfunction useMemory(options = {}) {\n  const memory = ref();\n  const isSupported = useSupported(() => typeof performance !== \"undefined\" && \"memory\" in performance);\n  if (isSupported.value) {\n    const { interval = 1e3 } = options;\n    useIntervalFn(() => {\n      memory.value = performance.memory;\n    }, interval, { immediate: options.immediate, immediateCallback: options.immediateCallback });\n  }\n  return { isSupported, memory };\n}\n\nconst UseMouseBuiltinExtractors = {\n  page: (event) => [event.pageX, event.pageY],\n  client: (event) => [event.clientX, event.clientY],\n  screen: (event) => [event.screenX, event.screenY],\n  movement: (event) => event instanceof Touch ? null : [event.movementX, event.movementY]\n};\nfunction useMouse(options = {}) {\n  const {\n    type = \"page\",\n    touch = true,\n    resetOnTouchEnds = false,\n    initialValue = { x: 0, y: 0 },\n    window = defaultWindow,\n    target = window,\n    scroll = true,\n    eventFilter\n  } = options;\n  let _prevMouseEvent = null;\n  const x = ref(initialValue.x);\n  const y = ref(initialValue.y);\n  const sourceType = ref(null);\n  const extractor = typeof type === \"function\" ? type : UseMouseBuiltinExtractors[type];\n  const mouseHandler = (event) => {\n    const result = extractor(event);\n    _prevMouseEvent = event;\n    if (result) {\n      [x.value, y.value] = result;\n      sourceType.value = \"mouse\";\n    }\n  };\n  const touchHandler = (event) => {\n    if (event.touches.length > 0) {\n      const result = extractor(event.touches[0]);\n      if (result) {\n        [x.value, y.value] = result;\n        sourceType.value = \"touch\";\n      }\n    }\n  };\n  const scrollHandler = () => {\n    if (!_prevMouseEvent || !window)\n      return;\n    const pos = extractor(_prevMouseEvent);\n    if (_prevMouseEvent instanceof MouseEvent && pos) {\n      x.value = pos[0] + window.scrollX;\n      y.value = pos[1] + window.scrollY;\n    }\n  };\n  const reset = () => {\n    x.value = initialValue.x;\n    y.value = initialValue.y;\n  };\n  const mouseHandlerWrapper = eventFilter ? (event) => eventFilter(() => mouseHandler(event), {}) : (event) => mouseHandler(event);\n  const touchHandlerWrapper = eventFilter ? (event) => eventFilter(() => touchHandler(event), {}) : (event) => touchHandler(event);\n  const scrollHandlerWrapper = eventFilter ? () => eventFilter(() => scrollHandler(), {}) : () => scrollHandler();\n  if (target) {\n    const listenerOptions = { passive: true };\n    useEventListener(target, [\"mousemove\", \"dragover\"], mouseHandlerWrapper, listenerOptions);\n    if (touch && type !== \"movement\") {\n      useEventListener(target, [\"touchstart\", \"touchmove\"], touchHandlerWrapper, listenerOptions);\n      if (resetOnTouchEnds)\n        useEventListener(target, \"touchend\", reset, listenerOptions);\n    }\n    if (scroll && type === \"page\")\n      useEventListener(window, \"scroll\", scrollHandlerWrapper, { passive: true });\n  }\n  return {\n    x,\n    y,\n    sourceType\n  };\n}\n\nfunction useMouseInElement(target, options = {}) {\n  const {\n    handleOutside = true,\n    window = defaultWindow\n  } = options;\n  const type = options.type || \"page\";\n  const { x, y, sourceType } = useMouse(options);\n  const targetRef = ref(target != null ? target : window == null ? void 0 : window.document.body);\n  const elementX = ref(0);\n  const elementY = ref(0);\n  const elementPositionX = ref(0);\n  const elementPositionY = ref(0);\n  const elementHeight = ref(0);\n  const elementWidth = ref(0);\n  const isOutside = ref(true);\n  let stop = () => {\n  };\n  if (window) {\n    stop = watch(\n      [targetRef, x, y],\n      () => {\n        const el = unrefElement(targetRef);\n        if (!el || !(el instanceof Element))\n          return;\n        const {\n          left,\n          top,\n          width,\n          height\n        } = el.getBoundingClientRect();\n        elementPositionX.value = left + (type === \"page\" ? window.pageXOffset : 0);\n        elementPositionY.value = top + (type === \"page\" ? window.pageYOffset : 0);\n        elementHeight.value = height;\n        elementWidth.value = width;\n        const elX = x.value - elementPositionX.value;\n        const elY = y.value - elementPositionY.value;\n        isOutside.value = width === 0 || height === 0 || elX < 0 || elY < 0 || elX > width || elY > height;\n        if (handleOutside || !isOutside.value) {\n          elementX.value = elX;\n          elementY.value = elY;\n        }\n      },\n      { immediate: true }\n    );\n    useEventListener(document, \"mouseleave\", () => {\n      isOutside.value = true;\n    });\n  }\n  return {\n    x,\n    y,\n    sourceType,\n    elementX,\n    elementY,\n    elementPositionX,\n    elementPositionY,\n    elementHeight,\n    elementWidth,\n    isOutside,\n    stop\n  };\n}\n\nfunction useMousePressed(options = {}) {\n  const {\n    touch = true,\n    drag = true,\n    capture = false,\n    initialValue = false,\n    window = defaultWindow\n  } = options;\n  const pressed = ref(initialValue);\n  const sourceType = ref(null);\n  if (!window) {\n    return {\n      pressed,\n      sourceType\n    };\n  }\n  const onPressed = (srcType) => () => {\n    pressed.value = true;\n    sourceType.value = srcType;\n  };\n  const onReleased = () => {\n    pressed.value = false;\n    sourceType.value = null;\n  };\n  const target = computed(() => unrefElement(options.target) || window);\n  useEventListener(target, \"mousedown\", onPressed(\"mouse\"), { passive: true, capture });\n  useEventListener(window, \"mouseleave\", onReleased, { passive: true, capture });\n  useEventListener(window, \"mouseup\", onReleased, { passive: true, capture });\n  if (drag) {\n    useEventListener(target, \"dragstart\", onPressed(\"mouse\"), { passive: true, capture });\n    useEventListener(window, \"drop\", onReleased, { passive: true, capture });\n    useEventListener(window, \"dragend\", onReleased, { passive: true, capture });\n  }\n  if (touch) {\n    useEventListener(target, \"touchstart\", onPressed(\"touch\"), { passive: true, capture });\n    useEventListener(window, \"touchend\", onReleased, { passive: true, capture });\n    useEventListener(window, \"touchcancel\", onReleased, { passive: true, capture });\n  }\n  return {\n    pressed,\n    sourceType\n  };\n}\n\nfunction useNavigatorLanguage(options = {}) {\n  const { window = defaultWindow } = options;\n  const navigator = window == null ? void 0 : window.navigator;\n  const isSupported = useSupported(() => navigator && \"language\" in navigator);\n  const language = ref(navigator == null ? void 0 : navigator.language);\n  useEventListener(window, \"languagechange\", () => {\n    if (navigator)\n      language.value = navigator.language;\n  });\n  return {\n    isSupported,\n    language\n  };\n}\n\nfunction useNetwork(options = {}) {\n  const { window = defaultWindow } = options;\n  const navigator = window == null ? void 0 : window.navigator;\n  const isSupported = useSupported(() => navigator && \"connection\" in navigator);\n  const isOnline = ref(true);\n  const saveData = ref(false);\n  const offlineAt = ref(void 0);\n  const onlineAt = ref(void 0);\n  const downlink = ref(void 0);\n  const downlinkMax = ref(void 0);\n  const rtt = ref(void 0);\n  const effectiveType = ref(void 0);\n  const type = ref(\"unknown\");\n  const connection = isSupported.value && navigator.connection;\n  function updateNetworkInformation() {\n    if (!navigator)\n      return;\n    isOnline.value = navigator.onLine;\n    offlineAt.value = isOnline.value ? void 0 : Date.now();\n    onlineAt.value = isOnline.value ? Date.now() : void 0;\n    if (connection) {\n      downlink.value = connection.downlink;\n      downlinkMax.value = connection.downlinkMax;\n      effectiveType.value = connection.effectiveType;\n      rtt.value = connection.rtt;\n      saveData.value = connection.saveData;\n      type.value = connection.type;\n    }\n  }\n  if (window) {\n    useEventListener(window, \"offline\", () => {\n      isOnline.value = false;\n      offlineAt.value = Date.now();\n    });\n    useEventListener(window, \"online\", () => {\n      isOnline.value = true;\n      onlineAt.value = Date.now();\n    });\n  }\n  if (connection)\n    useEventListener(connection, \"change\", updateNetworkInformation, false);\n  updateNetworkInformation();\n  return {\n    isSupported: readonly(isSupported),\n    isOnline: readonly(isOnline),\n    saveData: readonly(saveData),\n    offlineAt: readonly(offlineAt),\n    onlineAt: readonly(onlineAt),\n    downlink: readonly(downlink),\n    downlinkMax: readonly(downlinkMax),\n    effectiveType: readonly(effectiveType),\n    rtt: readonly(rtt),\n    type: readonly(type)\n  };\n}\n\nfunction useNow(options = {}) {\n  const {\n    controls: exposeControls = false,\n    interval = \"requestAnimationFrame\"\n  } = options;\n  const now = ref(/* @__PURE__ */ new Date());\n  const update = () => now.value = /* @__PURE__ */ new Date();\n  const controls = interval === \"requestAnimationFrame\" ? useRafFn(update, { immediate: true }) : useIntervalFn(update, interval, { immediate: true });\n  if (exposeControls) {\n    return {\n      now,\n      ...controls\n    };\n  } else {\n    return now;\n  }\n}\n\nfunction useObjectUrl(object) {\n  const url = ref();\n  const release = () => {\n    if (url.value)\n      URL.revokeObjectURL(url.value);\n    url.value = void 0;\n  };\n  watch(\n    () => toValue(object),\n    (newObject) => {\n      release();\n      if (newObject)\n        url.value = URL.createObjectURL(newObject);\n    },\n    { immediate: true }\n  );\n  tryOnScopeDispose(release);\n  return readonly(url);\n}\n\nfunction useClamp(value, min, max) {\n  if (typeof value === \"function\" || isReadonly(value))\n    return computed(() => clamp(toValue(value), toValue(min), toValue(max)));\n  const _value = ref(value);\n  return computed({\n    get() {\n      return _value.value = clamp(_value.value, toValue(min), toValue(max));\n    },\n    set(value2) {\n      _value.value = clamp(value2, toValue(min), toValue(max));\n    }\n  });\n}\n\nfunction useOffsetPagination(options) {\n  const {\n    total = Number.POSITIVE_INFINITY,\n    pageSize = 10,\n    page = 1,\n    onPageChange = noop,\n    onPageSizeChange = noop,\n    onPageCountChange = noop\n  } = options;\n  const currentPageSize = useClamp(pageSize, 1, Number.POSITIVE_INFINITY);\n  const pageCount = computed(() => Math.max(\n    1,\n    Math.ceil(toValue(total) / toValue(currentPageSize))\n  ));\n  const currentPage = useClamp(page, 1, pageCount);\n  const isFirstPage = computed(() => currentPage.value === 1);\n  const isLastPage = computed(() => currentPage.value === pageCount.value);\n  if (isRef(page)) {\n    syncRef(page, currentPage, {\n      direction: isReadonly(page) ? \"ltr\" : \"both\"\n    });\n  }\n  if (isRef(pageSize)) {\n    syncRef(pageSize, currentPageSize, {\n      direction: isReadonly(pageSize) ? \"ltr\" : \"both\"\n    });\n  }\n  function prev() {\n    currentPage.value--;\n  }\n  function next() {\n    currentPage.value++;\n  }\n  const returnValue = {\n    currentPage,\n    currentPageSize,\n    pageCount,\n    isFirstPage,\n    isLastPage,\n    prev,\n    next\n  };\n  watch(currentPage, () => {\n    onPageChange(reactive(returnValue));\n  });\n  watch(currentPageSize, () => {\n    onPageSizeChange(reactive(returnValue));\n  });\n  watch(pageCount, () => {\n    onPageCountChange(reactive(returnValue));\n  });\n  return returnValue;\n}\n\nfunction useOnline(options = {}) {\n  const { isOnline } = useNetwork(options);\n  return isOnline;\n}\n\nfunction usePageLeave(options = {}) {\n  const { window = defaultWindow } = options;\n  const isLeft = ref(false);\n  const handler = (event) => {\n    if (!window)\n      return;\n    event = event || window.event;\n    const from = event.relatedTarget || event.toElement;\n    isLeft.value = !from;\n  };\n  if (window) {\n    useEventListener(window, \"mouseout\", handler, { passive: true });\n    useEventListener(window.document, \"mouseleave\", handler, { passive: true });\n    useEventListener(window.document, \"mouseenter\", handler, { passive: true });\n  }\n  return isLeft;\n}\n\nfunction useScreenOrientation(options = {}) {\n  const {\n    window = defaultWindow\n  } = options;\n  const isSupported = useSupported(() => window && \"screen\" in window && \"orientation\" in window.screen);\n  const screenOrientation = isSupported.value ? window.screen.orientation : {};\n  const orientation = ref(screenOrientation.type);\n  const angle = ref(screenOrientation.angle || 0);\n  if (isSupported.value) {\n    useEventListener(window, \"orientationchange\", () => {\n      orientation.value = screenOrientation.type;\n      angle.value = screenOrientation.angle;\n    });\n  }\n  const lockOrientation = (type) => {\n    if (isSupported.value && typeof screenOrientation.lock === \"function\")\n      return screenOrientation.lock(type);\n    return Promise.reject(new Error(\"Not supported\"));\n  };\n  const unlockOrientation = () => {\n    if (isSupported.value && typeof screenOrientation.unlock === \"function\")\n      screenOrientation.unlock();\n  };\n  return {\n    isSupported,\n    orientation,\n    angle,\n    lockOrientation,\n    unlockOrientation\n  };\n}\n\nfunction useParallax(target, options = {}) {\n  const {\n    deviceOrientationTiltAdjust = (i) => i,\n    deviceOrientationRollAdjust = (i) => i,\n    mouseTiltAdjust = (i) => i,\n    mouseRollAdjust = (i) => i,\n    window = defaultWindow\n  } = options;\n  const orientation = reactive(useDeviceOrientation({ window }));\n  const screenOrientation = reactive(useScreenOrientation({ window }));\n  const {\n    elementX: x,\n    elementY: y,\n    elementWidth: width,\n    elementHeight: height\n  } = useMouseInElement(target, { handleOutside: false, window });\n  const source = computed(() => {\n    if (orientation.isSupported && (orientation.alpha != null && orientation.alpha !== 0 || orientation.gamma != null && orientation.gamma !== 0)) {\n      return \"deviceOrientation\";\n    }\n    return \"mouse\";\n  });\n  const roll = computed(() => {\n    if (source.value === \"deviceOrientation\") {\n      let value;\n      switch (screenOrientation.orientation) {\n        case \"landscape-primary\":\n          value = orientation.gamma / 90;\n          break;\n        case \"landscape-secondary\":\n          value = -orientation.gamma / 90;\n          break;\n        case \"portrait-primary\":\n          value = -orientation.beta / 90;\n          break;\n        case \"portrait-secondary\":\n          value = orientation.beta / 90;\n          break;\n        default:\n          value = -orientation.beta / 90;\n      }\n      return deviceOrientationRollAdjust(value);\n    } else {\n      const value = -(y.value - height.value / 2) / height.value;\n      return mouseRollAdjust(value);\n    }\n  });\n  const tilt = computed(() => {\n    if (source.value === \"deviceOrientation\") {\n      let value;\n      switch (screenOrientation.orientation) {\n        case \"landscape-primary\":\n          value = orientation.beta / 90;\n          break;\n        case \"landscape-secondary\":\n          value = -orientation.beta / 90;\n          break;\n        case \"portrait-primary\":\n          value = orientation.gamma / 90;\n          break;\n        case \"portrait-secondary\":\n          value = -orientation.gamma / 90;\n          break;\n        default:\n          value = orientation.gamma / 90;\n      }\n      return deviceOrientationTiltAdjust(value);\n    } else {\n      const value = (x.value - width.value / 2) / width.value;\n      return mouseTiltAdjust(value);\n    }\n  });\n  return { roll, tilt, source };\n}\n\nfunction useParentElement(element = useCurrentElement()) {\n  const parentElement = shallowRef();\n  const update = () => {\n    const el = unrefElement(element);\n    if (el)\n      parentElement.value = el.parentElement;\n  };\n  tryOnMounted(update);\n  watch(() => toValue(element), update);\n  return parentElement;\n}\n\nfunction usePerformanceObserver(options, callback) {\n  const {\n    window = defaultWindow,\n    immediate = true,\n    ...performanceOptions\n  } = options;\n  const isSupported = useSupported(() => window && \"PerformanceObserver\" in window);\n  let observer;\n  const stop = () => {\n    observer == null ? void 0 : observer.disconnect();\n  };\n  const start = () => {\n    if (isSupported.value) {\n      stop();\n      observer = new PerformanceObserver(callback);\n      observer.observe(performanceOptions);\n    }\n  };\n  tryOnScopeDispose(stop);\n  if (immediate)\n    start();\n  return {\n    isSupported,\n    start,\n    stop\n  };\n}\n\nconst defaultState = {\n  x: 0,\n  y: 0,\n  pointerId: 0,\n  pressure: 0,\n  tiltX: 0,\n  tiltY: 0,\n  width: 0,\n  height: 0,\n  twist: 0,\n  pointerType: null\n};\nconst keys = /* @__PURE__ */ Object.keys(defaultState);\nfunction usePointer(options = {}) {\n  const {\n    target = defaultWindow\n  } = options;\n  const isInside = ref(false);\n  const state = ref(options.initialValue || {});\n  Object.assign(state.value, defaultState, state.value);\n  const handler = (event) => {\n    isInside.value = true;\n    if (options.pointerTypes && !options.pointerTypes.includes(event.pointerType))\n      return;\n    state.value = objectPick(event, keys, false);\n  };\n  if (target) {\n    const listenerOptions = { passive: true };\n    useEventListener(target, [\"pointerdown\", \"pointermove\", \"pointerup\"], handler, listenerOptions);\n    useEventListener(target, \"pointerleave\", () => isInside.value = false, listenerOptions);\n  }\n  return {\n    ...toRefs(state),\n    isInside\n  };\n}\n\nfunction usePointerLock(target, options = {}) {\n  const { document = defaultDocument } = options;\n  const isSupported = useSupported(() => document && \"pointerLockElement\" in document);\n  const element = ref();\n  const triggerElement = ref();\n  let targetElement;\n  if (isSupported.value) {\n    useEventListener(document, \"pointerlockchange\", () => {\n      var _a;\n      const currentElement = (_a = document.pointerLockElement) != null ? _a : element.value;\n      if (targetElement && currentElement === targetElement) {\n        element.value = document.pointerLockElement;\n        if (!element.value)\n          targetElement = triggerElement.value = null;\n      }\n    });\n    useEventListener(document, \"pointerlockerror\", () => {\n      var _a;\n      const currentElement = (_a = document.pointerLockElement) != null ? _a : element.value;\n      if (targetElement && currentElement === targetElement) {\n        const action = document.pointerLockElement ? \"release\" : \"acquire\";\n        throw new Error(`Failed to ${action} pointer lock.`);\n      }\n    });\n  }\n  async function lock(e) {\n    var _a;\n    if (!isSupported.value)\n      throw new Error(\"Pointer Lock API is not supported by your browser.\");\n    triggerElement.value = e instanceof Event ? e.currentTarget : null;\n    targetElement = e instanceof Event ? (_a = unrefElement(target)) != null ? _a : triggerElement.value : unrefElement(e);\n    if (!targetElement)\n      throw new Error(\"Target element undefined.\");\n    targetElement.requestPointerLock();\n    return await until(element).toBe(targetElement);\n  }\n  async function unlock() {\n    if (!element.value)\n      return false;\n    document.exitPointerLock();\n    await until(element).toBeNull();\n    return true;\n  }\n  return {\n    isSupported,\n    element,\n    triggerElement,\n    lock,\n    unlock\n  };\n}\n\nfunction usePointerSwipe(target, options = {}) {\n  const targetRef = toRef(target);\n  const {\n    threshold = 50,\n    onSwipe,\n    onSwipeEnd,\n    onSwipeStart,\n    disableTextSelect = false\n  } = options;\n  const posStart = reactive({ x: 0, y: 0 });\n  const updatePosStart = (x, y) => {\n    posStart.x = x;\n    posStart.y = y;\n  };\n  const posEnd = reactive({ x: 0, y: 0 });\n  const updatePosEnd = (x, y) => {\n    posEnd.x = x;\n    posEnd.y = y;\n  };\n  const distanceX = computed(() => posStart.x - posEnd.x);\n  const distanceY = computed(() => posStart.y - posEnd.y);\n  const { max, abs } = Math;\n  const isThresholdExceeded = computed(() => max(abs(distanceX.value), abs(distanceY.value)) >= threshold);\n  const isSwiping = ref(false);\n  const isPointerDown = ref(false);\n  const direction = computed(() => {\n    if (!isThresholdExceeded.value)\n      return \"none\";\n    if (abs(distanceX.value) > abs(distanceY.value)) {\n      return distanceX.value > 0 ? \"left\" : \"right\";\n    } else {\n      return distanceY.value > 0 ? \"up\" : \"down\";\n    }\n  });\n  const eventIsAllowed = (e) => {\n    var _a, _b, _c;\n    const isReleasingButton = e.buttons === 0;\n    const isPrimaryButton = e.buttons === 1;\n    return (_c = (_b = (_a = options.pointerTypes) == null ? void 0 : _a.includes(e.pointerType)) != null ? _b : isReleasingButton || isPrimaryButton) != null ? _c : true;\n  };\n  const stops = [\n    useEventListener(target, \"pointerdown\", (e) => {\n      if (!eventIsAllowed(e))\n        return;\n      isPointerDown.value = true;\n      const eventTarget = e.target;\n      eventTarget == null ? void 0 : eventTarget.setPointerCapture(e.pointerId);\n      const { clientX: x, clientY: y } = e;\n      updatePosStart(x, y);\n      updatePosEnd(x, y);\n      onSwipeStart == null ? void 0 : onSwipeStart(e);\n    }),\n    useEventListener(target, \"pointermove\", (e) => {\n      if (!eventIsAllowed(e))\n        return;\n      if (!isPointerDown.value)\n        return;\n      const { clientX: x, clientY: y } = e;\n      updatePosEnd(x, y);\n      if (!isSwiping.value && isThresholdExceeded.value)\n        isSwiping.value = true;\n      if (isSwiping.value)\n        onSwipe == null ? void 0 : onSwipe(e);\n    }),\n    useEventListener(target, \"pointerup\", (e) => {\n      if (!eventIsAllowed(e))\n        return;\n      if (isSwiping.value)\n        onSwipeEnd == null ? void 0 : onSwipeEnd(e, direction.value);\n      isPointerDown.value = false;\n      isSwiping.value = false;\n    })\n  ];\n  tryOnMounted(() => {\n    var _a, _b, _c, _d, _e, _f, _g, _h;\n    (_b = (_a = targetRef.value) == null ? void 0 : _a.style) == null ? void 0 : _b.setProperty(\"touch-action\", \"none\");\n    if (disableTextSelect) {\n      (_d = (_c = targetRef.value) == null ? void 0 : _c.style) == null ? void 0 : _d.setProperty(\"-webkit-user-select\", \"none\");\n      (_f = (_e = targetRef.value) == null ? void 0 : _e.style) == null ? void 0 : _f.setProperty(\"-ms-user-select\", \"none\");\n      (_h = (_g = targetRef.value) == null ? void 0 : _g.style) == null ? void 0 : _h.setProperty(\"user-select\", \"none\");\n    }\n  });\n  const stop = () => stops.forEach((s) => s());\n  return {\n    isSwiping: readonly(isSwiping),\n    direction: readonly(direction),\n    posStart: readonly(posStart),\n    posEnd: readonly(posEnd),\n    distanceX,\n    distanceY,\n    stop\n  };\n}\n\nfunction usePreferredColorScheme(options) {\n  const isLight = useMediaQuery(\"(prefers-color-scheme: light)\", options);\n  const isDark = useMediaQuery(\"(prefers-color-scheme: dark)\", options);\n  return computed(() => {\n    if (isDark.value)\n      return \"dark\";\n    if (isLight.value)\n      return \"light\";\n    return \"no-preference\";\n  });\n}\n\nfunction usePreferredContrast(options) {\n  const isMore = useMediaQuery(\"(prefers-contrast: more)\", options);\n  const isLess = useMediaQuery(\"(prefers-contrast: less)\", options);\n  const isCustom = useMediaQuery(\"(prefers-contrast: custom)\", options);\n  return computed(() => {\n    if (isMore.value)\n      return \"more\";\n    if (isLess.value)\n      return \"less\";\n    if (isCustom.value)\n      return \"custom\";\n    return \"no-preference\";\n  });\n}\n\nfunction usePreferredLanguages(options = {}) {\n  const { window = defaultWindow } = options;\n  if (!window)\n    return ref([\"en\"]);\n  const navigator = window.navigator;\n  const value = ref(navigator.languages);\n  useEventListener(window, \"languagechange\", () => {\n    value.value = navigator.languages;\n  });\n  return value;\n}\n\nfunction usePreferredReducedMotion(options) {\n  const isReduced = useMediaQuery(\"(prefers-reduced-motion: reduce)\", options);\n  return computed(() => {\n    if (isReduced.value)\n      return \"reduce\";\n    return \"no-preference\";\n  });\n}\n\nfunction usePrevious(value, initialValue) {\n  const previous = shallowRef(initialValue);\n  watch(\n    toRef(value),\n    (_, oldValue) => {\n      previous.value = oldValue;\n    },\n    { flush: \"sync\" }\n  );\n  return readonly(previous);\n}\n\nconst topVarName = \"--vueuse-safe-area-top\";\nconst rightVarName = \"--vueuse-safe-area-right\";\nconst bottomVarName = \"--vueuse-safe-area-bottom\";\nconst leftVarName = \"--vueuse-safe-area-left\";\nfunction useScreenSafeArea() {\n  const top = ref(\"\");\n  const right = ref(\"\");\n  const bottom = ref(\"\");\n  const left = ref(\"\");\n  if (isClient) {\n    const topCssVar = useCssVar(topVarName);\n    const rightCssVar = useCssVar(rightVarName);\n    const bottomCssVar = useCssVar(bottomVarName);\n    const leftCssVar = useCssVar(leftVarName);\n    topCssVar.value = \"env(safe-area-inset-top, 0px)\";\n    rightCssVar.value = \"env(safe-area-inset-right, 0px)\";\n    bottomCssVar.value = \"env(safe-area-inset-bottom, 0px)\";\n    leftCssVar.value = \"env(safe-area-inset-left, 0px)\";\n    update();\n    useEventListener(\"resize\", useDebounceFn(update));\n  }\n  function update() {\n    top.value = getValue(topVarName);\n    right.value = getValue(rightVarName);\n    bottom.value = getValue(bottomVarName);\n    left.value = getValue(leftVarName);\n  }\n  return {\n    top,\n    right,\n    bottom,\n    left,\n    update\n  };\n}\nfunction getValue(position) {\n  return getComputedStyle(document.documentElement).getPropertyValue(position);\n}\n\nfunction useScriptTag(src, onLoaded = noop, options = {}) {\n  const {\n    immediate = true,\n    manual = false,\n    type = \"text/javascript\",\n    async = true,\n    crossOrigin,\n    referrerPolicy,\n    noModule,\n    defer,\n    document = defaultDocument,\n    attrs = {}\n  } = options;\n  const scriptTag = ref(null);\n  let _promise = null;\n  const loadScript = (waitForScriptLoad) => new Promise((resolve, reject) => {\n    const resolveWithElement = (el2) => {\n      scriptTag.value = el2;\n      resolve(el2);\n      return el2;\n    };\n    if (!document) {\n      resolve(false);\n      return;\n    }\n    let shouldAppend = false;\n    let el = document.querySelector(`script[src=\"${toValue(src)}\"]`);\n    if (!el) {\n      el = document.createElement(\"script\");\n      el.type = type;\n      el.async = async;\n      el.src = toValue(src);\n      if (defer)\n        el.defer = defer;\n      if (crossOrigin)\n        el.crossOrigin = crossOrigin;\n      if (noModule)\n        el.noModule = noModule;\n      if (referrerPolicy)\n        el.referrerPolicy = referrerPolicy;\n      Object.entries(attrs).forEach(([name, value]) => el == null ? void 0 : el.setAttribute(name, value));\n      shouldAppend = true;\n    } else if (el.hasAttribute(\"data-loaded\")) {\n      resolveWithElement(el);\n    }\n    el.addEventListener(\"error\", (event) => reject(event));\n    el.addEventListener(\"abort\", (event) => reject(event));\n    el.addEventListener(\"load\", () => {\n      el.setAttribute(\"data-loaded\", \"true\");\n      onLoaded(el);\n      resolveWithElement(el);\n    });\n    if (shouldAppend)\n      el = document.head.appendChild(el);\n    if (!waitForScriptLoad)\n      resolveWithElement(el);\n  });\n  const load = (waitForScriptLoad = true) => {\n    if (!_promise)\n      _promise = loadScript(waitForScriptLoad);\n    return _promise;\n  };\n  const unload = () => {\n    if (!document)\n      return;\n    _promise = null;\n    if (scriptTag.value)\n      scriptTag.value = null;\n    const el = document.querySelector(`script[src=\"${toValue(src)}\"]`);\n    if (el)\n      document.head.removeChild(el);\n  };\n  if (immediate && !manual)\n    tryOnMounted(load);\n  if (!manual)\n    tryOnUnmounted(unload);\n  return { scriptTag, load, unload };\n}\n\nfunction checkOverflowScroll(ele) {\n  const style = window.getComputedStyle(ele);\n  if (style.overflowX === \"scroll\" || style.overflowY === \"scroll\" || style.overflowX === \"auto\" && ele.clientWidth < ele.scrollWidth || style.overflowY === \"auto\" && ele.clientHeight < ele.scrollHeight) {\n    return true;\n  } else {\n    const parent = ele.parentNode;\n    if (!parent || parent.tagName === \"BODY\")\n      return false;\n    return checkOverflowScroll(parent);\n  }\n}\nfunction preventDefault(rawEvent) {\n  const e = rawEvent || window.event;\n  const _target = e.target;\n  if (checkOverflowScroll(_target))\n    return false;\n  if (e.touches.length > 1)\n    return true;\n  if (e.preventDefault)\n    e.preventDefault();\n  return false;\n}\nconst elInitialOverflow = /* @__PURE__ */ new WeakMap();\nfunction useScrollLock(element, initialState = false) {\n  const isLocked = ref(initialState);\n  let stopTouchMoveListener = null;\n  let initialOverflow = \"\";\n  watch(toRef(element), (el) => {\n    const target = resolveElement(toValue(el));\n    if (target) {\n      const ele = target;\n      if (!elInitialOverflow.get(ele))\n        elInitialOverflow.set(ele, ele.style.overflow);\n      if (ele.style.overflow !== \"hidden\")\n        initialOverflow = ele.style.overflow;\n      if (ele.style.overflow === \"hidden\")\n        return isLocked.value = true;\n      if (isLocked.value)\n        return ele.style.overflow = \"hidden\";\n    }\n  }, {\n    immediate: true\n  });\n  const lock = () => {\n    const el = resolveElement(toValue(element));\n    if (!el || isLocked.value)\n      return;\n    if (isIOS) {\n      stopTouchMoveListener = useEventListener(\n        el,\n        \"touchmove\",\n        (e) => {\n          preventDefault(e);\n        },\n        { passive: false }\n      );\n    }\n    el.style.overflow = \"hidden\";\n    isLocked.value = true;\n  };\n  const unlock = () => {\n    const el = resolveElement(toValue(element));\n    if (!el || !isLocked.value)\n      return;\n    if (isIOS)\n      stopTouchMoveListener == null ? void 0 : stopTouchMoveListener();\n    el.style.overflow = initialOverflow;\n    elInitialOverflow.delete(el);\n    isLocked.value = false;\n  };\n  tryOnScopeDispose(unlock);\n  return computed({\n    get() {\n      return isLocked.value;\n    },\n    set(v) {\n      if (v)\n        lock();\n      else unlock();\n    }\n  });\n}\n\nfunction useSessionStorage(key, initialValue, options = {}) {\n  const { window = defaultWindow } = options;\n  return useStorage(key, initialValue, window == null ? void 0 : window.sessionStorage, options);\n}\n\nfunction useShare(shareOptions = {}, options = {}) {\n  const { navigator = defaultNavigator } = options;\n  const _navigator = navigator;\n  const isSupported = useSupported(() => _navigator && \"canShare\" in _navigator);\n  const share = async (overrideOptions = {}) => {\n    if (isSupported.value) {\n      const data = {\n        ...toValue(shareOptions),\n        ...toValue(overrideOptions)\n      };\n      let granted = true;\n      if (data.files && _navigator.canShare)\n        granted = _navigator.canShare({ files: data.files });\n      if (granted)\n        return _navigator.share(data);\n    }\n  };\n  return {\n    isSupported,\n    share\n  };\n}\n\nconst defaultSortFn = (source, compareFn) => source.sort(compareFn);\nconst defaultCompare = (a, b) => a - b;\nfunction useSorted(...args) {\n  var _a, _b, _c, _d;\n  const [source] = args;\n  let compareFn = defaultCompare;\n  let options = {};\n  if (args.length === 2) {\n    if (typeof args[1] === \"object\") {\n      options = args[1];\n      compareFn = (_a = options.compareFn) != null ? _a : defaultCompare;\n    } else {\n      compareFn = (_b = args[1]) != null ? _b : defaultCompare;\n    }\n  } else if (args.length > 2) {\n    compareFn = (_c = args[1]) != null ? _c : defaultCompare;\n    options = (_d = args[2]) != null ? _d : {};\n  }\n  const {\n    dirty = false,\n    sortFn = defaultSortFn\n  } = options;\n  if (!dirty)\n    return computed(() => sortFn([...toValue(source)], compareFn));\n  watchEffect(() => {\n    const result = sortFn(toValue(source), compareFn);\n    if (isRef(source))\n      source.value = result;\n    else\n      source.splice(0, source.length, ...result);\n  });\n  return source;\n}\n\nfunction useSpeechRecognition(options = {}) {\n  const {\n    interimResults = true,\n    continuous = true,\n    maxAlternatives = 1,\n    window = defaultWindow\n  } = options;\n  const lang = toRef(options.lang || \"en-US\");\n  const isListening = ref(false);\n  const isFinal = ref(false);\n  const result = ref(\"\");\n  const error = shallowRef(void 0);\n  const toggle = (value = !isListening.value) => {\n    isListening.value = value;\n  };\n  const start = () => {\n    isListening.value = true;\n  };\n  const stop = () => {\n    isListening.value = false;\n  };\n  const SpeechRecognition = window && (window.SpeechRecognition || window.webkitSpeechRecognition);\n  const isSupported = useSupported(() => SpeechRecognition);\n  let recognition;\n  if (isSupported.value) {\n    recognition = new SpeechRecognition();\n    recognition.continuous = continuous;\n    recognition.interimResults = interimResults;\n    recognition.lang = toValue(lang);\n    recognition.maxAlternatives = maxAlternatives;\n    recognition.onstart = () => {\n      isFinal.value = false;\n    };\n    watch(lang, (lang2) => {\n      if (recognition && !isListening.value)\n        recognition.lang = lang2;\n    });\n    recognition.onresult = (event) => {\n      const currentResult = event.results[event.resultIndex];\n      const { transcript } = currentResult[0];\n      isFinal.value = currentResult.isFinal;\n      result.value = transcript;\n      error.value = void 0;\n    };\n    recognition.onerror = (event) => {\n      error.value = event;\n    };\n    recognition.onend = () => {\n      isListening.value = false;\n      recognition.lang = toValue(lang);\n    };\n    watch(isListening, () => {\n      if (isListening.value)\n        recognition.start();\n      else\n        recognition.stop();\n    });\n  }\n  tryOnScopeDispose(() => {\n    isListening.value = false;\n  });\n  return {\n    isSupported,\n    isListening,\n    isFinal,\n    recognition,\n    result,\n    error,\n    toggle,\n    start,\n    stop\n  };\n}\n\nfunction useSpeechSynthesis(text, options = {}) {\n  const {\n    pitch = 1,\n    rate = 1,\n    volume = 1,\n    window = defaultWindow\n  } = options;\n  const synth = window && window.speechSynthesis;\n  const isSupported = useSupported(() => synth);\n  const isPlaying = ref(false);\n  const status = ref(\"init\");\n  const spokenText = toRef(text || \"\");\n  const lang = toRef(options.lang || \"en-US\");\n  const error = shallowRef(void 0);\n  const toggle = (value = !isPlaying.value) => {\n    isPlaying.value = value;\n  };\n  const bindEventsForUtterance = (utterance2) => {\n    utterance2.lang = toValue(lang);\n    utterance2.voice = toValue(options.voice) || null;\n    utterance2.pitch = toValue(pitch);\n    utterance2.rate = toValue(rate);\n    utterance2.volume = volume;\n    utterance2.onstart = () => {\n      isPlaying.value = true;\n      status.value = \"play\";\n    };\n    utterance2.onpause = () => {\n      isPlaying.value = false;\n      status.value = \"pause\";\n    };\n    utterance2.onresume = () => {\n      isPlaying.value = true;\n      status.value = \"play\";\n    };\n    utterance2.onend = () => {\n      isPlaying.value = false;\n      status.value = \"end\";\n    };\n    utterance2.onerror = (event) => {\n      error.value = event;\n    };\n  };\n  const utterance = computed(() => {\n    isPlaying.value = false;\n    status.value = \"init\";\n    const newUtterance = new SpeechSynthesisUtterance(spokenText.value);\n    bindEventsForUtterance(newUtterance);\n    return newUtterance;\n  });\n  const speak = () => {\n    synth.cancel();\n    if (utterance)\n      synth.speak(utterance.value);\n  };\n  const stop = () => {\n    synth.cancel();\n    isPlaying.value = false;\n  };\n  if (isSupported.value) {\n    bindEventsForUtterance(utterance.value);\n    watch(lang, (lang2) => {\n      if (utterance.value && !isPlaying.value)\n        utterance.value.lang = lang2;\n    });\n    if (options.voice) {\n      watch(options.voice, () => {\n        synth.cancel();\n      });\n    }\n    watch(isPlaying, () => {\n      if (isPlaying.value)\n        synth.resume();\n      else\n        synth.pause();\n    });\n  }\n  tryOnScopeDispose(() => {\n    isPlaying.value = false;\n  });\n  return {\n    isSupported,\n    isPlaying,\n    status,\n    utterance,\n    error,\n    stop,\n    toggle,\n    speak\n  };\n}\n\nfunction useStepper(steps, initialStep) {\n  const stepsRef = ref(steps);\n  const stepNames = computed(() => Array.isArray(stepsRef.value) ? stepsRef.value : Object.keys(stepsRef.value));\n  const index = ref(stepNames.value.indexOf(initialStep != null ? initialStep : stepNames.value[0]));\n  const current = computed(() => at(index.value));\n  const isFirst = computed(() => index.value === 0);\n  const isLast = computed(() => index.value === stepNames.value.length - 1);\n  const next = computed(() => stepNames.value[index.value + 1]);\n  const previous = computed(() => stepNames.value[index.value - 1]);\n  function at(index2) {\n    if (Array.isArray(stepsRef.value))\n      return stepsRef.value[index2];\n    return stepsRef.value[stepNames.value[index2]];\n  }\n  function get(step) {\n    if (!stepNames.value.includes(step))\n      return;\n    return at(stepNames.value.indexOf(step));\n  }\n  function goTo(step) {\n    if (stepNames.value.includes(step))\n      index.value = stepNames.value.indexOf(step);\n  }\n  function goToNext() {\n    if (isLast.value)\n      return;\n    index.value++;\n  }\n  function goToPrevious() {\n    if (isFirst.value)\n      return;\n    index.value--;\n  }\n  function goBackTo(step) {\n    if (isAfter(step))\n      goTo(step);\n  }\n  function isNext(step) {\n    return stepNames.value.indexOf(step) === index.value + 1;\n  }\n  function isPrevious(step) {\n    return stepNames.value.indexOf(step) === index.value - 1;\n  }\n  function isCurrent(step) {\n    return stepNames.value.indexOf(step) === index.value;\n  }\n  function isBefore(step) {\n    return index.value < stepNames.value.indexOf(step);\n  }\n  function isAfter(step) {\n    return index.value > stepNames.value.indexOf(step);\n  }\n  return {\n    steps: stepsRef,\n    stepNames,\n    index,\n    current,\n    next,\n    previous,\n    isFirst,\n    isLast,\n    at,\n    get,\n    goTo,\n    goToNext,\n    goToPrevious,\n    goBackTo,\n    isNext,\n    isPrevious,\n    isCurrent,\n    isBefore,\n    isAfter\n  };\n}\n\nfunction useStorageAsync(key, initialValue, storage, options = {}) {\n  var _a;\n  const {\n    flush = \"pre\",\n    deep = true,\n    listenToStorageChanges = true,\n    writeDefaults = true,\n    mergeDefaults = false,\n    shallow,\n    window = defaultWindow,\n    eventFilter,\n    onError = (e) => {\n      console.error(e);\n    }\n  } = options;\n  const rawInit = toValue(initialValue);\n  const type = guessSerializerType(rawInit);\n  const data = (shallow ? shallowRef : ref)(initialValue);\n  const serializer = (_a = options.serializer) != null ? _a : StorageSerializers[type];\n  if (!storage) {\n    try {\n      storage = getSSRHandler(\"getDefaultStorageAsync\", () => {\n        var _a2;\n        return (_a2 = defaultWindow) == null ? void 0 : _a2.localStorage;\n      })();\n    } catch (e) {\n      onError(e);\n    }\n  }\n  async function read(event) {\n    if (!storage || event && event.key !== key)\n      return;\n    try {\n      const rawValue = event ? event.newValue : await storage.getItem(key);\n      if (rawValue == null) {\n        data.value = rawInit;\n        if (writeDefaults && rawInit !== null)\n          await storage.setItem(key, await serializer.write(rawInit));\n      } else if (mergeDefaults) {\n        const value = await serializer.read(rawValue);\n        if (typeof mergeDefaults === \"function\")\n          data.value = mergeDefaults(value, rawInit);\n        else if (type === \"object\" && !Array.isArray(value))\n          data.value = { ...rawInit, ...value };\n        else data.value = value;\n      } else {\n        data.value = await serializer.read(rawValue);\n      }\n    } catch (e) {\n      onError(e);\n    }\n  }\n  read();\n  if (window && listenToStorageChanges)\n    useEventListener(window, \"storage\", (e) => Promise.resolve().then(() => read(e)));\n  if (storage) {\n    watchWithFilter(\n      data,\n      async () => {\n        try {\n          if (data.value == null)\n            await storage.removeItem(key);\n          else\n            await storage.setItem(key, await serializer.write(data.value));\n        } catch (e) {\n          onError(e);\n        }\n      },\n      {\n        flush,\n        deep,\n        eventFilter\n      }\n    );\n  }\n  return data;\n}\n\nlet _id = 0;\nfunction useStyleTag(css, options = {}) {\n  const isLoaded = ref(false);\n  const {\n    document = defaultDocument,\n    immediate = true,\n    manual = false,\n    id = `vueuse_styletag_${++_id}`\n  } = options;\n  const cssRef = ref(css);\n  let stop = () => {\n  };\n  const load = () => {\n    if (!document)\n      return;\n    const el = document.getElementById(id) || document.createElement(\"style\");\n    if (!el.isConnected) {\n      el.id = id;\n      if (options.media)\n        el.media = options.media;\n      document.head.appendChild(el);\n    }\n    if (isLoaded.value)\n      return;\n    stop = watch(\n      cssRef,\n      (value) => {\n        el.textContent = value;\n      },\n      { immediate: true }\n    );\n    isLoaded.value = true;\n  };\n  const unload = () => {\n    if (!document || !isLoaded.value)\n      return;\n    stop();\n    document.head.removeChild(document.getElementById(id));\n    isLoaded.value = false;\n  };\n  if (immediate && !manual)\n    tryOnMounted(load);\n  if (!manual)\n    tryOnScopeDispose(unload);\n  return {\n    id,\n    css: cssRef,\n    unload,\n    load,\n    isLoaded: readonly(isLoaded)\n  };\n}\n\nfunction useSwipe(target, options = {}) {\n  const {\n    threshold = 50,\n    onSwipe,\n    onSwipeEnd,\n    onSwipeStart,\n    passive = true,\n    window = defaultWindow\n  } = options;\n  const coordsStart = reactive({ x: 0, y: 0 });\n  const coordsEnd = reactive({ x: 0, y: 0 });\n  const diffX = computed(() => coordsStart.x - coordsEnd.x);\n  const diffY = computed(() => coordsStart.y - coordsEnd.y);\n  const { max, abs } = Math;\n  const isThresholdExceeded = computed(() => max(abs(diffX.value), abs(diffY.value)) >= threshold);\n  const isSwiping = ref(false);\n  const direction = computed(() => {\n    if (!isThresholdExceeded.value)\n      return \"none\";\n    if (abs(diffX.value) > abs(diffY.value)) {\n      return diffX.value > 0 ? \"left\" : \"right\";\n    } else {\n      return diffY.value > 0 ? \"up\" : \"down\";\n    }\n  });\n  const getTouchEventCoords = (e) => [e.touches[0].clientX, e.touches[0].clientY];\n  const updateCoordsStart = (x, y) => {\n    coordsStart.x = x;\n    coordsStart.y = y;\n  };\n  const updateCoordsEnd = (x, y) => {\n    coordsEnd.x = x;\n    coordsEnd.y = y;\n  };\n  let listenerOptions;\n  const isPassiveEventSupported = checkPassiveEventSupport(window == null ? void 0 : window.document);\n  if (!passive)\n    listenerOptions = isPassiveEventSupported ? { passive: false, capture: true } : { capture: true };\n  else\n    listenerOptions = isPassiveEventSupported ? { passive: true } : { capture: false };\n  const onTouchEnd = (e) => {\n    if (isSwiping.value)\n      onSwipeEnd == null ? void 0 : onSwipeEnd(e, direction.value);\n    isSwiping.value = false;\n  };\n  const stops = [\n    useEventListener(target, \"touchstart\", (e) => {\n      if (e.touches.length !== 1)\n        return;\n      if (listenerOptions.capture && !listenerOptions.passive)\n        e.preventDefault();\n      const [x, y] = getTouchEventCoords(e);\n      updateCoordsStart(x, y);\n      updateCoordsEnd(x, y);\n      onSwipeStart == null ? void 0 : onSwipeStart(e);\n    }, listenerOptions),\n    useEventListener(target, \"touchmove\", (e) => {\n      if (e.touches.length !== 1)\n        return;\n      const [x, y] = getTouchEventCoords(e);\n      updateCoordsEnd(x, y);\n      if (!isSwiping.value && isThresholdExceeded.value)\n        isSwiping.value = true;\n      if (isSwiping.value)\n        onSwipe == null ? void 0 : onSwipe(e);\n    }, listenerOptions),\n    useEventListener(target, [\"touchend\", \"touchcancel\"], onTouchEnd, listenerOptions)\n  ];\n  const stop = () => stops.forEach((s) => s());\n  return {\n    isPassiveEventSupported,\n    isSwiping,\n    direction,\n    coordsStart,\n    coordsEnd,\n    lengthX: diffX,\n    lengthY: diffY,\n    stop\n  };\n}\nfunction checkPassiveEventSupport(document) {\n  if (!document)\n    return false;\n  let supportsPassive = false;\n  const optionsBlock = {\n    get passive() {\n      supportsPassive = true;\n      return false;\n    }\n  };\n  document.addEventListener(\"x\", noop, optionsBlock);\n  document.removeEventListener(\"x\", noop);\n  return supportsPassive;\n}\n\nfunction useTemplateRefsList() {\n  const refs = ref([]);\n  refs.value.set = (el) => {\n    if (el)\n      refs.value.push(el);\n  };\n  onBeforeUpdate(() => {\n    refs.value.length = 0;\n  });\n  return refs;\n}\n\nfunction useTextDirection(options = {}) {\n  const {\n    document = defaultDocument,\n    selector = \"html\",\n    observe = false,\n    initialValue = \"ltr\"\n  } = options;\n  function getValue() {\n    var _a, _b;\n    return (_b = (_a = document == null ? void 0 : document.querySelector(selector)) == null ? void 0 : _a.getAttribute(\"dir\")) != null ? _b : initialValue;\n  }\n  const dir = ref(getValue());\n  tryOnMounted(() => dir.value = getValue());\n  if (observe && document) {\n    useMutationObserver(\n      document.querySelector(selector),\n      () => dir.value = getValue(),\n      { attributes: true }\n    );\n  }\n  return computed({\n    get() {\n      return dir.value;\n    },\n    set(v) {\n      var _a, _b;\n      dir.value = v;\n      if (!document)\n        return;\n      if (dir.value)\n        (_a = document.querySelector(selector)) == null ? void 0 : _a.setAttribute(\"dir\", dir.value);\n      else\n        (_b = document.querySelector(selector)) == null ? void 0 : _b.removeAttribute(\"dir\");\n    }\n  });\n}\n\nfunction getRangesFromSelection(selection) {\n  var _a;\n  const rangeCount = (_a = selection.rangeCount) != null ? _a : 0;\n  return Array.from({ length: rangeCount }, (_, i) => selection.getRangeAt(i));\n}\nfunction useTextSelection(options = {}) {\n  const {\n    window = defaultWindow\n  } = options;\n  const selection = ref(null);\n  const text = computed(() => {\n    var _a, _b;\n    return (_b = (_a = selection.value) == null ? void 0 : _a.toString()) != null ? _b : \"\";\n  });\n  const ranges = computed(() => selection.value ? getRangesFromSelection(selection.value) : []);\n  const rects = computed(() => ranges.value.map((range) => range.getBoundingClientRect()));\n  function onSelectionChange() {\n    selection.value = null;\n    if (window)\n      selection.value = window.getSelection();\n  }\n  if (window)\n    useEventListener(window.document, \"selectionchange\", onSelectionChange);\n  return {\n    text,\n    rects,\n    ranges,\n    selection\n  };\n}\n\nfunction useTextareaAutosize(options) {\n  var _a;\n  const textarea = ref(options == null ? void 0 : options.element);\n  const input = ref(options == null ? void 0 : options.input);\n  const styleProp = (_a = options == null ? void 0 : options.styleProp) != null ? _a : \"height\";\n  const textareaScrollHeight = ref(1);\n  const textareaOldWidth = ref(0);\n  function triggerResize() {\n    var _a2;\n    if (!textarea.value)\n      return;\n    let height = \"\";\n    textarea.value.style[styleProp] = \"1px\";\n    textareaScrollHeight.value = (_a2 = textarea.value) == null ? void 0 : _a2.scrollHeight;\n    const _styleTarget = toValue(options == null ? void 0 : options.styleTarget);\n    if (_styleTarget)\n      _styleTarget.style[styleProp] = `${textareaScrollHeight.value}px`;\n    else\n      height = `${textareaScrollHeight.value}px`;\n    textarea.value.style[styleProp] = height;\n  }\n  watch([input, textarea], () => nextTick(triggerResize), { immediate: true });\n  watch(textareaScrollHeight, () => {\n    var _a2;\n    return (_a2 = options == null ? void 0 : options.onResize) == null ? void 0 : _a2.call(options);\n  });\n  useResizeObserver(textarea, ([{ contentRect }]) => {\n    if (textareaOldWidth.value === contentRect.width)\n      return;\n    textareaOldWidth.value = contentRect.width;\n    triggerResize();\n  });\n  if (options == null ? void 0 : options.watch)\n    watch(options.watch, triggerResize, { immediate: true, deep: true });\n  return {\n    textarea,\n    input,\n    triggerResize\n  };\n}\n\nfunction useThrottledRefHistory(source, options = {}) {\n  const { throttle = 200, trailing = true } = options;\n  const filter = throttleFilter(throttle, trailing);\n  const history = useRefHistory(source, { ...options, eventFilter: filter });\n  return {\n    ...history\n  };\n}\n\nconst DEFAULT_UNITS = [\n  { max: 6e4, value: 1e3, name: \"second\" },\n  { max: 276e4, value: 6e4, name: \"minute\" },\n  { max: 72e6, value: 36e5, name: \"hour\" },\n  { max: 5184e5, value: 864e5, name: \"day\" },\n  { max: 24192e5, value: 6048e5, name: \"week\" },\n  { max: 28512e6, value: 2592e6, name: \"month\" },\n  { max: Number.POSITIVE_INFINITY, value: 31536e6, name: \"year\" }\n];\nconst DEFAULT_MESSAGES = {\n  justNow: \"just now\",\n  past: (n) => n.match(/\\d/) ? `${n} ago` : n,\n  future: (n) => n.match(/\\d/) ? `in ${n}` : n,\n  month: (n, past) => n === 1 ? past ? \"last month\" : \"next month\" : `${n} month${n > 1 ? \"s\" : \"\"}`,\n  year: (n, past) => n === 1 ? past ? \"last year\" : \"next year\" : `${n} year${n > 1 ? \"s\" : \"\"}`,\n  day: (n, past) => n === 1 ? past ? \"yesterday\" : \"tomorrow\" : `${n} day${n > 1 ? \"s\" : \"\"}`,\n  week: (n, past) => n === 1 ? past ? \"last week\" : \"next week\" : `${n} week${n > 1 ? \"s\" : \"\"}`,\n  hour: (n) => `${n} hour${n > 1 ? \"s\" : \"\"}`,\n  minute: (n) => `${n} minute${n > 1 ? \"s\" : \"\"}`,\n  second: (n) => `${n} second${n > 1 ? \"s\" : \"\"}`,\n  invalid: \"\"\n};\nfunction DEFAULT_FORMATTER(date) {\n  return date.toISOString().slice(0, 10);\n}\nfunction useTimeAgo(time, options = {}) {\n  const {\n    controls: exposeControls = false,\n    updateInterval = 3e4\n  } = options;\n  const { now, ...controls } = useNow({ interval: updateInterval, controls: true });\n  const timeAgo = computed(() => formatTimeAgo(new Date(toValue(time)), options, toValue(now)));\n  if (exposeControls) {\n    return {\n      timeAgo,\n      ...controls\n    };\n  } else {\n    return timeAgo;\n  }\n}\nfunction formatTimeAgo(from, options = {}, now = Date.now()) {\n  var _a;\n  const {\n    max,\n    messages = DEFAULT_MESSAGES,\n    fullDateFormatter = DEFAULT_FORMATTER,\n    units = DEFAULT_UNITS,\n    showSecond = false,\n    rounding = \"round\"\n  } = options;\n  const roundFn = typeof rounding === \"number\" ? (n) => +n.toFixed(rounding) : Math[rounding];\n  const diff = +now - +from;\n  const absDiff = Math.abs(diff);\n  function getValue(diff2, unit) {\n    return roundFn(Math.abs(diff2) / unit.value);\n  }\n  function format(diff2, unit) {\n    const val = getValue(diff2, unit);\n    const past = diff2 > 0;\n    const str = applyFormat(unit.name, val, past);\n    return applyFormat(past ? \"past\" : \"future\", str, past);\n  }\n  function applyFormat(name, val, isPast) {\n    const formatter = messages[name];\n    if (typeof formatter === \"function\")\n      return formatter(val, isPast);\n    return formatter.replace(\"{0}\", val.toString());\n  }\n  if (absDiff < 6e4 && !showSecond)\n    return messages.justNow;\n  if (typeof max === \"number\" && absDiff > max)\n    return fullDateFormatter(new Date(from));\n  if (typeof max === \"string\") {\n    const unitMax = (_a = units.find((i) => i.name === max)) == null ? void 0 : _a.max;\n    if (unitMax && absDiff > unitMax)\n      return fullDateFormatter(new Date(from));\n  }\n  for (const [idx, unit] of units.entries()) {\n    const val = getValue(diff, unit);\n    if (val <= 0 && units[idx - 1])\n      return format(diff, units[idx - 1]);\n    if (absDiff < unit.max)\n      return format(diff, unit);\n  }\n  return messages.invalid;\n}\n\nfunction useTimeoutPoll(fn, interval, timeoutPollOptions) {\n  const { start } = useTimeoutFn(loop, interval, { immediate: false });\n  const isActive = ref(false);\n  async function loop() {\n    if (!isActive.value)\n      return;\n    await fn();\n    start();\n  }\n  function resume() {\n    if (!isActive.value) {\n      isActive.value = true;\n      loop();\n    }\n  }\n  function pause() {\n    isActive.value = false;\n  }\n  if (timeoutPollOptions == null ? void 0 : timeoutPollOptions.immediate)\n    resume();\n  tryOnScopeDispose(pause);\n  return {\n    isActive,\n    pause,\n    resume\n  };\n}\n\nfunction useTimestamp(options = {}) {\n  const {\n    controls: exposeControls = false,\n    offset = 0,\n    immediate = true,\n    interval = \"requestAnimationFrame\",\n    callback\n  } = options;\n  const ts = ref(timestamp() + offset);\n  const update = () => ts.value = timestamp() + offset;\n  const cb = callback ? () => {\n    update();\n    callback(ts.value);\n  } : update;\n  const controls = interval === \"requestAnimationFrame\" ? useRafFn(cb, { immediate }) : useIntervalFn(cb, interval, { immediate });\n  if (exposeControls) {\n    return {\n      timestamp: ts,\n      ...controls\n    };\n  } else {\n    return ts;\n  }\n}\n\nfunction useTitle(newTitle = null, options = {}) {\n  var _a, _b, _c;\n  const {\n    document = defaultDocument,\n    restoreOnUnmount = (t) => t\n  } = options;\n  const originalTitle = (_a = document == null ? void 0 : document.title) != null ? _a : \"\";\n  const title = toRef((_b = newTitle != null ? newTitle : document == null ? void 0 : document.title) != null ? _b : null);\n  const isReadonly = newTitle && typeof newTitle === \"function\";\n  function format(t) {\n    if (!(\"titleTemplate\" in options))\n      return t;\n    const template = options.titleTemplate || \"%s\";\n    return typeof template === \"function\" ? template(t) : toValue(template).replace(/%s/g, t);\n  }\n  watch(\n    title,\n    (t, o) => {\n      if (t !== o && document)\n        document.title = format(typeof t === \"string\" ? t : \"\");\n    },\n    { immediate: true }\n  );\n  if (options.observe && !options.titleTemplate && document && !isReadonly) {\n    useMutationObserver(\n      (_c = document.head) == null ? void 0 : _c.querySelector(\"title\"),\n      () => {\n        if (document && document.title !== title.value)\n          title.value = format(document.title);\n      },\n      { childList: true }\n    );\n  }\n  tryOnBeforeUnmount(() => {\n    if (restoreOnUnmount) {\n      const restoredTitle = restoreOnUnmount(originalTitle, title.value || \"\");\n      if (restoredTitle != null && document)\n        document.title = restoredTitle;\n    }\n  });\n  return title;\n}\n\nconst _TransitionPresets = {\n  easeInSine: [0.12, 0, 0.39, 0],\n  easeOutSine: [0.61, 1, 0.88, 1],\n  easeInOutSine: [0.37, 0, 0.63, 1],\n  easeInQuad: [0.11, 0, 0.5, 0],\n  easeOutQuad: [0.5, 1, 0.89, 1],\n  easeInOutQuad: [0.45, 0, 0.55, 1],\n  easeInCubic: [0.32, 0, 0.67, 0],\n  easeOutCubic: [0.33, 1, 0.68, 1],\n  easeInOutCubic: [0.65, 0, 0.35, 1],\n  easeInQuart: [0.5, 0, 0.75, 0],\n  easeOutQuart: [0.25, 1, 0.5, 1],\n  easeInOutQuart: [0.76, 0, 0.24, 1],\n  easeInQuint: [0.64, 0, 0.78, 0],\n  easeOutQuint: [0.22, 1, 0.36, 1],\n  easeInOutQuint: [0.83, 0, 0.17, 1],\n  easeInExpo: [0.7, 0, 0.84, 0],\n  easeOutExpo: [0.16, 1, 0.3, 1],\n  easeInOutExpo: [0.87, 0, 0.13, 1],\n  easeInCirc: [0.55, 0, 1, 0.45],\n  easeOutCirc: [0, 0.55, 0.45, 1],\n  easeInOutCirc: [0.85, 0, 0.15, 1],\n  easeInBack: [0.36, 0, 0.66, -0.56],\n  easeOutBack: [0.34, 1.56, 0.64, 1],\n  easeInOutBack: [0.68, -0.6, 0.32, 1.6]\n};\nconst TransitionPresets = /* @__PURE__ */ Object.assign({}, { linear: identity }, _TransitionPresets);\nfunction createEasingFunction([p0, p1, p2, p3]) {\n  const a = (a1, a2) => 1 - 3 * a2 + 3 * a1;\n  const b = (a1, a2) => 3 * a2 - 6 * a1;\n  const c = (a1) => 3 * a1;\n  const calcBezier = (t, a1, a2) => ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;\n  const getSlope = (t, a1, a2) => 3 * a(a1, a2) * t * t + 2 * b(a1, a2) * t + c(a1);\n  const getTforX = (x) => {\n    let aGuessT = x;\n    for (let i = 0; i < 4; ++i) {\n      const currentSlope = getSlope(aGuessT, p0, p2);\n      if (currentSlope === 0)\n        return aGuessT;\n      const currentX = calcBezier(aGuessT, p0, p2) - x;\n      aGuessT -= currentX / currentSlope;\n    }\n    return aGuessT;\n  };\n  return (x) => p0 === p1 && p2 === p3 ? x : calcBezier(getTforX(x), p1, p3);\n}\nfunction lerp(a, b, alpha) {\n  return a + alpha * (b - a);\n}\nfunction toVec(t) {\n  return (typeof t === \"number\" ? [t] : t) || [];\n}\nfunction executeTransition(source, from, to, options = {}) {\n  var _a, _b;\n  const fromVal = toValue(from);\n  const toVal = toValue(to);\n  const v1 = toVec(fromVal);\n  const v2 = toVec(toVal);\n  const duration = (_a = toValue(options.duration)) != null ? _a : 1e3;\n  const startedAt = Date.now();\n  const endAt = Date.now() + duration;\n  const trans = typeof options.transition === \"function\" ? options.transition : (_b = toValue(options.transition)) != null ? _b : identity;\n  const ease = typeof trans === \"function\" ? trans : createEasingFunction(trans);\n  return new Promise((resolve) => {\n    source.value = fromVal;\n    const tick = () => {\n      var _a2;\n      if ((_a2 = options.abort) == null ? void 0 : _a2.call(options)) {\n        resolve();\n        return;\n      }\n      const now = Date.now();\n      const alpha = ease((now - startedAt) / duration);\n      const arr = toVec(source.value).map((n, i) => lerp(v1[i], v2[i], alpha));\n      if (Array.isArray(source.value))\n        source.value = arr.map((n, i) => {\n          var _a3, _b2;\n          return lerp((_a3 = v1[i]) != null ? _a3 : 0, (_b2 = v2[i]) != null ? _b2 : 0, alpha);\n        });\n      else if (typeof source.value === \"number\")\n        source.value = arr[0];\n      if (now < endAt) {\n        requestAnimationFrame(tick);\n      } else {\n        source.value = toVal;\n        resolve();\n      }\n    };\n    tick();\n  });\n}\nfunction useTransition(source, options = {}) {\n  let currentId = 0;\n  const sourceVal = () => {\n    const v = toValue(source);\n    return typeof v === \"number\" ? v : v.map(toValue);\n  };\n  const outputRef = ref(sourceVal());\n  watch(sourceVal, async (to) => {\n    var _a, _b;\n    if (toValue(options.disabled))\n      return;\n    const id = ++currentId;\n    if (options.delay)\n      await promiseTimeout(toValue(options.delay));\n    if (id !== currentId)\n      return;\n    const toVal = Array.isArray(to) ? to.map(toValue) : toValue(to);\n    (_a = options.onStarted) == null ? void 0 : _a.call(options);\n    await executeTransition(outputRef, outputRef.value, toVal, {\n      ...options,\n      abort: () => {\n        var _a2;\n        return id !== currentId || ((_a2 = options.abort) == null ? void 0 : _a2.call(options));\n      }\n    });\n    (_b = options.onFinished) == null ? void 0 : _b.call(options);\n  }, { deep: true });\n  watch(() => toValue(options.disabled), (disabled) => {\n    if (disabled) {\n      currentId++;\n      outputRef.value = sourceVal();\n    }\n  });\n  tryOnScopeDispose(() => {\n    currentId++;\n  });\n  return computed(() => toValue(options.disabled) ? sourceVal() : outputRef.value);\n}\n\nfunction useUrlSearchParams(mode = \"history\", options = {}) {\n  const {\n    initialValue = {},\n    removeNullishValues = true,\n    removeFalsyValues = false,\n    write: enableWrite = true,\n    window = defaultWindow\n  } = options;\n  if (!window)\n    return reactive(initialValue);\n  const state = reactive({});\n  function getRawParams() {\n    if (mode === \"history\") {\n      return window.location.search || \"\";\n    } else if (mode === \"hash\") {\n      const hash = window.location.hash || \"\";\n      const index = hash.indexOf(\"?\");\n      return index > 0 ? hash.slice(index) : \"\";\n    } else {\n      return (window.location.hash || \"\").replace(/^#/, \"\");\n    }\n  }\n  function constructQuery(params) {\n    const stringified = params.toString();\n    if (mode === \"history\")\n      return `${stringified ? `?${stringified}` : \"\"}${window.location.hash || \"\"}`;\n    if (mode === \"hash-params\")\n      return `${window.location.search || \"\"}${stringified ? `#${stringified}` : \"\"}`;\n    const hash = window.location.hash || \"#\";\n    const index = hash.indexOf(\"?\");\n    if (index > 0)\n      return `${hash.slice(0, index)}${stringified ? `?${stringified}` : \"\"}`;\n    return `${hash}${stringified ? `?${stringified}` : \"\"}`;\n  }\n  function read() {\n    return new URLSearchParams(getRawParams());\n  }\n  function updateState(params) {\n    const unusedKeys = new Set(Object.keys(state));\n    for (const key of params.keys()) {\n      const paramsForKey = params.getAll(key);\n      state[key] = paramsForKey.length > 1 ? paramsForKey : params.get(key) || \"\";\n      unusedKeys.delete(key);\n    }\n    Array.from(unusedKeys).forEach((key) => delete state[key]);\n  }\n  const { pause, resume } = pausableWatch(\n    state,\n    () => {\n      const params = new URLSearchParams(\"\");\n      Object.keys(state).forEach((key) => {\n        const mapEntry = state[key];\n        if (Array.isArray(mapEntry))\n          mapEntry.forEach((value) => params.append(key, value));\n        else if (removeNullishValues && mapEntry == null)\n          params.delete(key);\n        else if (removeFalsyValues && !mapEntry)\n          params.delete(key);\n        else\n          params.set(key, mapEntry);\n      });\n      write(params);\n    },\n    { deep: true }\n  );\n  function write(params, shouldUpdate) {\n    pause();\n    if (shouldUpdate)\n      updateState(params);\n    window.history.replaceState(\n      window.history.state,\n      window.document.title,\n      window.location.pathname + constructQuery(params)\n    );\n    resume();\n  }\n  function onChanged() {\n    if (!enableWrite)\n      return;\n    write(read(), true);\n  }\n  useEventListener(window, \"popstate\", onChanged, false);\n  if (mode !== \"history\")\n    useEventListener(window, \"hashchange\", onChanged, false);\n  const initial = read();\n  if (initial.keys().next().value)\n    updateState(initial);\n  else\n    Object.assign(state, initialValue);\n  return state;\n}\n\nfunction useUserMedia(options = {}) {\n  var _a, _b;\n  const enabled = ref((_a = options.enabled) != null ? _a : false);\n  const autoSwitch = ref((_b = options.autoSwitch) != null ? _b : true);\n  const constraints = ref(options.constraints);\n  const { navigator = defaultNavigator } = options;\n  const isSupported = useSupported(() => {\n    var _a2;\n    return (_a2 = navigator == null ? void 0 : navigator.mediaDevices) == null ? void 0 : _a2.getUserMedia;\n  });\n  const stream = shallowRef();\n  function getDeviceOptions(type) {\n    switch (type) {\n      case \"video\": {\n        if (constraints.value)\n          return constraints.value.video || false;\n        break;\n      }\n      case \"audio\": {\n        if (constraints.value)\n          return constraints.value.audio || false;\n        break;\n      }\n    }\n  }\n  async function _start() {\n    if (!isSupported.value || stream.value)\n      return;\n    stream.value = await navigator.mediaDevices.getUserMedia({\n      video: getDeviceOptions(\"video\"),\n      audio: getDeviceOptions(\"audio\")\n    });\n    return stream.value;\n  }\n  function _stop() {\n    var _a2;\n    (_a2 = stream.value) == null ? void 0 : _a2.getTracks().forEach((t) => t.stop());\n    stream.value = void 0;\n  }\n  function stop() {\n    _stop();\n    enabled.value = false;\n  }\n  async function start() {\n    await _start();\n    if (stream.value)\n      enabled.value = true;\n    return stream.value;\n  }\n  async function restart() {\n    _stop();\n    return await start();\n  }\n  watch(\n    enabled,\n    (v) => {\n      if (v)\n        _start();\n      else _stop();\n    },\n    { immediate: true }\n  );\n  watch(\n    constraints,\n    () => {\n      if (autoSwitch.value && stream.value)\n        restart();\n    },\n    { immediate: true }\n  );\n  tryOnScopeDispose(() => {\n    stop();\n  });\n  return {\n    isSupported,\n    stream,\n    start,\n    stop,\n    restart,\n    constraints,\n    enabled,\n    autoSwitch\n  };\n}\n\nfunction useVModel(props, key, emit, options = {}) {\n  var _a, _b, _c, _d, _e;\n  const {\n    clone = false,\n    passive = false,\n    eventName,\n    deep = false,\n    defaultValue,\n    shouldEmit\n  } = options;\n  const vm = getCurrentInstance();\n  const _emit = emit || (vm == null ? void 0 : vm.emit) || ((_a = vm == null ? void 0 : vm.$emit) == null ? void 0 : _a.bind(vm)) || ((_c = (_b = vm == null ? void 0 : vm.proxy) == null ? void 0 : _b.$emit) == null ? void 0 : _c.bind(vm == null ? void 0 : vm.proxy));\n  let event = eventName;\n  if (!key) {\n    if (isVue2) {\n      const modelOptions = (_e = (_d = vm == null ? void 0 : vm.proxy) == null ? void 0 : _d.$options) == null ? void 0 : _e.model;\n      key = (modelOptions == null ? void 0 : modelOptions.value) || \"value\";\n      if (!eventName)\n        event = (modelOptions == null ? void 0 : modelOptions.event) || \"input\";\n    } else {\n      key = \"modelValue\";\n    }\n  }\n  event = event || `update:${key.toString()}`;\n  const cloneFn = (val) => !clone ? val : typeof clone === \"function\" ? clone(val) : cloneFnJSON(val);\n  const getValue = () => isDef(props[key]) ? cloneFn(props[key]) : defaultValue;\n  const triggerEmit = (value) => {\n    if (shouldEmit) {\n      if (shouldEmit(value))\n        _emit(event, value);\n    } else {\n      _emit(event, value);\n    }\n  };\n  if (passive) {\n    const initialValue = getValue();\n    const proxy = ref(initialValue);\n    let isUpdating = false;\n    watch(\n      () => props[key],\n      (v) => {\n        if (!isUpdating) {\n          isUpdating = true;\n          proxy.value = cloneFn(v);\n          nextTick(() => isUpdating = false);\n        }\n      }\n    );\n    watch(\n      proxy,\n      (v) => {\n        if (!isUpdating && (v !== props[key] || deep))\n          triggerEmit(v);\n      },\n      { deep }\n    );\n    return proxy;\n  } else {\n    return computed({\n      get() {\n        return getValue();\n      },\n      set(value) {\n        triggerEmit(value);\n      }\n    });\n  }\n}\n\nfunction useVModels(props, emit, options = {}) {\n  const ret = {};\n  for (const key in props) {\n    ret[key] = useVModel(\n      props,\n      key,\n      emit,\n      options\n    );\n  }\n  return ret;\n}\n\nfunction useVibrate(options) {\n  const {\n    pattern = [],\n    interval = 0,\n    navigator = defaultNavigator\n  } = options || {};\n  const isSupported = useSupported(() => typeof navigator !== \"undefined\" && \"vibrate\" in navigator);\n  const patternRef = toRef(pattern);\n  let intervalControls;\n  const vibrate = (pattern2 = patternRef.value) => {\n    if (isSupported.value)\n      navigator.vibrate(pattern2);\n  };\n  const stop = () => {\n    if (isSupported.value)\n      navigator.vibrate(0);\n    intervalControls == null ? void 0 : intervalControls.pause();\n  };\n  if (interval > 0) {\n    intervalControls = useIntervalFn(\n      vibrate,\n      interval,\n      {\n        immediate: false,\n        immediateCallback: false\n      }\n    );\n  }\n  return {\n    isSupported,\n    pattern,\n    intervalControls,\n    vibrate,\n    stop\n  };\n}\n\nfunction useVirtualList(list, options) {\n  const { containerStyle, wrapperProps, scrollTo, calculateRange, currentList, containerRef } = \"itemHeight\" in options ? useVerticalVirtualList(options, list) : useHorizontalVirtualList(options, list);\n  return {\n    list: currentList,\n    scrollTo,\n    containerProps: {\n      ref: containerRef,\n      onScroll: () => {\n        calculateRange();\n      },\n      style: containerStyle\n    },\n    wrapperProps\n  };\n}\nfunction useVirtualListResources(list) {\n  const containerRef = ref(null);\n  const size = useElementSize(containerRef);\n  const currentList = ref([]);\n  const source = shallowRef(list);\n  const state = ref({ start: 0, end: 10 });\n  return { state, source, currentList, size, containerRef };\n}\nfunction createGetViewCapacity(state, source, itemSize) {\n  return (containerSize) => {\n    if (typeof itemSize === \"number\")\n      return Math.ceil(containerSize / itemSize);\n    const { start = 0 } = state.value;\n    let sum = 0;\n    let capacity = 0;\n    for (let i = start; i < source.value.length; i++) {\n      const size = itemSize(i);\n      sum += size;\n      capacity = i;\n      if (sum > containerSize)\n        break;\n    }\n    return capacity - start;\n  };\n}\nfunction createGetOffset(source, itemSize) {\n  return (scrollDirection) => {\n    if (typeof itemSize === \"number\")\n      return Math.floor(scrollDirection / itemSize) + 1;\n    let sum = 0;\n    let offset = 0;\n    for (let i = 0; i < source.value.length; i++) {\n      const size = itemSize(i);\n      sum += size;\n      if (sum >= scrollDirection) {\n        offset = i;\n        break;\n      }\n    }\n    return offset + 1;\n  };\n}\nfunction createCalculateRange(type, overscan, getOffset, getViewCapacity, { containerRef, state, currentList, source }) {\n  return () => {\n    const element = containerRef.value;\n    if (element) {\n      const offset = getOffset(type === \"vertical\" ? element.scrollTop : element.scrollLeft);\n      const viewCapacity = getViewCapacity(type === \"vertical\" ? element.clientHeight : element.clientWidth);\n      const from = offset - overscan;\n      const to = offset + viewCapacity + overscan;\n      state.value = {\n        start: from < 0 ? 0 : from,\n        end: to > source.value.length ? source.value.length : to\n      };\n      currentList.value = source.value.slice(state.value.start, state.value.end).map((ele, index) => ({\n        data: ele,\n        index: index + state.value.start\n      }));\n    }\n  };\n}\nfunction createGetDistance(itemSize, source) {\n  return (index) => {\n    if (typeof itemSize === \"number\") {\n      const size2 = index * itemSize;\n      return size2;\n    }\n    const size = source.value.slice(0, index).reduce((sum, _, i) => sum + itemSize(i), 0);\n    return size;\n  };\n}\nfunction useWatchForSizes(size, list, containerRef, calculateRange) {\n  watch([size.width, size.height, list, containerRef], () => {\n    calculateRange();\n  });\n}\nfunction createComputedTotalSize(itemSize, source) {\n  return computed(() => {\n    if (typeof itemSize === \"number\")\n      return source.value.length * itemSize;\n    return source.value.reduce((sum, _, index) => sum + itemSize(index), 0);\n  });\n}\nconst scrollToDictionaryForElementScrollKey = {\n  horizontal: \"scrollLeft\",\n  vertical: \"scrollTop\"\n};\nfunction createScrollTo(type, calculateRange, getDistance, containerRef) {\n  return (index) => {\n    if (containerRef.value) {\n      containerRef.value[scrollToDictionaryForElementScrollKey[type]] = getDistance(index);\n      calculateRange();\n    }\n  };\n}\nfunction useHorizontalVirtualList(options, list) {\n  const resources = useVirtualListResources(list);\n  const { state, source, currentList, size, containerRef } = resources;\n  const containerStyle = { overflowX: \"auto\" };\n  const { itemWidth, overscan = 5 } = options;\n  const getViewCapacity = createGetViewCapacity(state, source, itemWidth);\n  const getOffset = createGetOffset(source, itemWidth);\n  const calculateRange = createCalculateRange(\"horizontal\", overscan, getOffset, getViewCapacity, resources);\n  const getDistanceLeft = createGetDistance(itemWidth, source);\n  const offsetLeft = computed(() => getDistanceLeft(state.value.start));\n  const totalWidth = createComputedTotalSize(itemWidth, source);\n  useWatchForSizes(size, list, containerRef, calculateRange);\n  const scrollTo = createScrollTo(\"horizontal\", calculateRange, getDistanceLeft, containerRef);\n  const wrapperProps = computed(() => {\n    return {\n      style: {\n        height: \"100%\",\n        width: `${totalWidth.value - offsetLeft.value}px`,\n        marginLeft: `${offsetLeft.value}px`,\n        display: \"flex\"\n      }\n    };\n  });\n  return {\n    scrollTo,\n    calculateRange,\n    wrapperProps,\n    containerStyle,\n    currentList,\n    containerRef\n  };\n}\nfunction useVerticalVirtualList(options, list) {\n  const resources = useVirtualListResources(list);\n  const { state, source, currentList, size, containerRef } = resources;\n  const containerStyle = { overflowY: \"auto\" };\n  const { itemHeight, overscan = 5 } = options;\n  const getViewCapacity = createGetViewCapacity(state, source, itemHeight);\n  const getOffset = createGetOffset(source, itemHeight);\n  const calculateRange = createCalculateRange(\"vertical\", overscan, getOffset, getViewCapacity, resources);\n  const getDistanceTop = createGetDistance(itemHeight, source);\n  const offsetTop = computed(() => getDistanceTop(state.value.start));\n  const totalHeight = createComputedTotalSize(itemHeight, source);\n  useWatchForSizes(size, list, containerRef, calculateRange);\n  const scrollTo = createScrollTo(\"vertical\", calculateRange, getDistanceTop, containerRef);\n  const wrapperProps = computed(() => {\n    return {\n      style: {\n        width: \"100%\",\n        height: `${totalHeight.value - offsetTop.value}px`,\n        marginTop: `${offsetTop.value}px`\n      }\n    };\n  });\n  return {\n    calculateRange,\n    scrollTo,\n    containerStyle,\n    wrapperProps,\n    currentList,\n    containerRef\n  };\n}\n\nfunction useWakeLock(options = {}) {\n  const {\n    navigator = defaultNavigator,\n    document = defaultDocument\n  } = options;\n  const requestedType = ref(false);\n  const sentinel = shallowRef(null);\n  const documentVisibility = useDocumentVisibility({ document });\n  const isSupported = useSupported(() => navigator && \"wakeLock\" in navigator);\n  const isActive = computed(() => !!sentinel.value && documentVisibility.value === \"visible\");\n  if (isSupported.value) {\n    useEventListener(sentinel, \"release\", () => {\n      var _a, _b;\n      requestedType.value = (_b = (_a = sentinel.value) == null ? void 0 : _a.type) != null ? _b : false;\n    });\n    whenever(\n      () => documentVisibility.value === \"visible\" && (document == null ? void 0 : document.visibilityState) === \"visible\" && requestedType.value,\n      (type) => {\n        requestedType.value = false;\n        forceRequest(type);\n      }\n    );\n  }\n  async function forceRequest(type) {\n    var _a;\n    await ((_a = sentinel.value) == null ? void 0 : _a.release());\n    sentinel.value = isSupported.value ? await navigator.wakeLock.request(type) : null;\n  }\n  async function request(type) {\n    if (documentVisibility.value === \"visible\")\n      await forceRequest(type);\n    else\n      requestedType.value = type;\n  }\n  async function release() {\n    requestedType.value = false;\n    const s = sentinel.value;\n    sentinel.value = null;\n    await (s == null ? void 0 : s.release());\n  }\n  return {\n    sentinel,\n    isSupported,\n    isActive,\n    request,\n    forceRequest,\n    release\n  };\n}\n\nfunction useWebNotification(options = {}) {\n  const {\n    window = defaultWindow,\n    requestPermissions: _requestForPermissions = true\n  } = options;\n  const defaultWebNotificationOptions = options;\n  const isSupported = useSupported(() => {\n    if (!window || !(\"Notification\" in window))\n      return false;\n    try {\n      new Notification(\"\");\n    } catch (e) {\n      return false;\n    }\n    return true;\n  });\n  const permissionGranted = ref(isSupported.value && \"permission\" in Notification && Notification.permission === \"granted\");\n  const notification = ref(null);\n  const ensurePermissions = async () => {\n    if (!isSupported.value)\n      return;\n    if (!permissionGranted.value && Notification.permission !== \"denied\") {\n      const result = await Notification.requestPermission();\n      if (result === \"granted\")\n        permissionGranted.value = true;\n    }\n    return permissionGranted.value;\n  };\n  const { on: onClick, trigger: clickTrigger } = createEventHook();\n  const { on: onShow, trigger: showTrigger } = createEventHook();\n  const { on: onError, trigger: errorTrigger } = createEventHook();\n  const { on: onClose, trigger: closeTrigger } = createEventHook();\n  const show = async (overrides) => {\n    if (!isSupported.value || !permissionGranted.value)\n      return;\n    const options2 = Object.assign({}, defaultWebNotificationOptions, overrides);\n    notification.value = new Notification(options2.title || \"\", options2);\n    notification.value.onclick = clickTrigger;\n    notification.value.onshow = showTrigger;\n    notification.value.onerror = errorTrigger;\n    notification.value.onclose = closeTrigger;\n    return notification.value;\n  };\n  const close = () => {\n    if (notification.value)\n      notification.value.close();\n    notification.value = null;\n  };\n  if (_requestForPermissions)\n    tryOnMounted(ensurePermissions);\n  tryOnScopeDispose(close);\n  if (isSupported.value && window) {\n    const document = window.document;\n    useEventListener(document, \"visibilitychange\", (e) => {\n      e.preventDefault();\n      if (document.visibilityState === \"visible\") {\n        close();\n      }\n    });\n  }\n  return {\n    isSupported,\n    notification,\n    ensurePermissions,\n    permissionGranted,\n    show,\n    close,\n    onClick,\n    onShow,\n    onError,\n    onClose\n  };\n}\n\nconst DEFAULT_PING_MESSAGE = \"ping\";\nfunction resolveNestedOptions(options) {\n  if (options === true)\n    return {};\n  return options;\n}\nfunction useWebSocket(url, options = {}) {\n  const {\n    onConnected,\n    onDisconnected,\n    onError,\n    onMessage,\n    immediate = true,\n    autoClose = true,\n    protocols = []\n  } = options;\n  const data = ref(null);\n  const status = ref(\"CLOSED\");\n  const wsRef = ref();\n  const urlRef = toRef(url);\n  let heartbeatPause;\n  let heartbeatResume;\n  let explicitlyClosed = false;\n  let retried = 0;\n  let bufferedData = [];\n  let pongTimeoutWait;\n  const _sendBuffer = () => {\n    if (bufferedData.length && wsRef.value && status.value === \"OPEN\") {\n      for (const buffer of bufferedData)\n        wsRef.value.send(buffer);\n      bufferedData = [];\n    }\n  };\n  const resetHeartbeat = () => {\n    clearTimeout(pongTimeoutWait);\n    pongTimeoutWait = void 0;\n  };\n  const close = (code = 1e3, reason) => {\n    if (!isClient || !wsRef.value)\n      return;\n    explicitlyClosed = true;\n    resetHeartbeat();\n    heartbeatPause == null ? void 0 : heartbeatPause();\n    wsRef.value.close(code, reason);\n    wsRef.value = void 0;\n  };\n  const send = (data2, useBuffer = true) => {\n    if (!wsRef.value || status.value !== \"OPEN\") {\n      if (useBuffer)\n        bufferedData.push(data2);\n      return false;\n    }\n    _sendBuffer();\n    wsRef.value.send(data2);\n    return true;\n  };\n  const _init = () => {\n    if (explicitlyClosed || typeof urlRef.value === \"undefined\")\n      return;\n    const ws = new WebSocket(urlRef.value, protocols);\n    wsRef.value = ws;\n    status.value = \"CONNECTING\";\n    ws.onopen = () => {\n      status.value = \"OPEN\";\n      retried = 0;\n      onConnected == null ? void 0 : onConnected(ws);\n      heartbeatResume == null ? void 0 : heartbeatResume();\n      _sendBuffer();\n    };\n    ws.onclose = (ev) => {\n      status.value = \"CLOSED\";\n      onDisconnected == null ? void 0 : onDisconnected(ws, ev);\n      if (!explicitlyClosed && options.autoReconnect && (wsRef.value == null || ws === wsRef.value)) {\n        const {\n          retries = -1,\n          delay = 1e3,\n          onFailed\n        } = resolveNestedOptions(options.autoReconnect);\n        if (typeof retries === \"number\" && (retries < 0 || retried < retries)) {\n          retried += 1;\n          setTimeout(_init, delay);\n        } else if (typeof retries === \"function\" && retries()) {\n          setTimeout(_init, delay);\n        } else {\n          onFailed == null ? void 0 : onFailed();\n        }\n      }\n    };\n    ws.onerror = (e) => {\n      onError == null ? void 0 : onError(ws, e);\n    };\n    ws.onmessage = (e) => {\n      if (options.heartbeat) {\n        resetHeartbeat();\n        const {\n          message = DEFAULT_PING_MESSAGE,\n          responseMessage = message\n        } = resolveNestedOptions(options.heartbeat);\n        if (e.data === responseMessage)\n          return;\n      }\n      data.value = e.data;\n      onMessage == null ? void 0 : onMessage(ws, e);\n    };\n  };\n  if (options.heartbeat) {\n    const {\n      message = DEFAULT_PING_MESSAGE,\n      interval = 1e3,\n      pongTimeout = 1e3\n    } = resolveNestedOptions(options.heartbeat);\n    const { pause, resume } = useIntervalFn(\n      () => {\n        send(message, false);\n        if (pongTimeoutWait != null)\n          return;\n        pongTimeoutWait = setTimeout(() => {\n          close();\n          explicitlyClosed = false;\n        }, pongTimeout);\n      },\n      interval,\n      { immediate: false }\n    );\n    heartbeatPause = pause;\n    heartbeatResume = resume;\n  }\n  if (autoClose) {\n    if (isClient)\n      useEventListener(\"beforeunload\", () => close());\n    tryOnScopeDispose(close);\n  }\n  const open = () => {\n    if (!isClient && !isWorker)\n      return;\n    close();\n    explicitlyClosed = false;\n    retried = 0;\n    _init();\n  };\n  if (immediate)\n    open();\n  watch(urlRef, open);\n  return {\n    data,\n    status,\n    close,\n    send,\n    open,\n    ws: wsRef\n  };\n}\n\nfunction useWebWorker(arg0, workerOptions, options) {\n  const {\n    window = defaultWindow\n  } = options != null ? options : {};\n  const data = ref(null);\n  const worker = shallowRef();\n  const post = (...args) => {\n    if (!worker.value)\n      return;\n    worker.value.postMessage(...args);\n  };\n  const terminate = function terminate2() {\n    if (!worker.value)\n      return;\n    worker.value.terminate();\n  };\n  if (window) {\n    if (typeof arg0 === \"string\")\n      worker.value = new Worker(arg0, workerOptions);\n    else if (typeof arg0 === \"function\")\n      worker.value = arg0();\n    else\n      worker.value = arg0;\n    worker.value.onmessage = (e) => {\n      data.value = e.data;\n    };\n    tryOnScopeDispose(() => {\n      if (worker.value)\n        worker.value.terminate();\n    });\n  }\n  return {\n    data,\n    post,\n    terminate,\n    worker\n  };\n}\n\nfunction depsParser(deps, localDeps) {\n  if (deps.length === 0 && localDeps.length === 0)\n    return \"\";\n  const depsString = deps.map((dep) => `'${dep}'`).toString();\n  const depsFunctionString = localDeps.filter((dep) => typeof dep === \"function\").map((fn) => {\n    const str = fn.toString();\n    if (str.trim().startsWith(\"function\")) {\n      return str;\n    } else {\n      const name = fn.name;\n      return `const ${name} = ${str}`;\n    }\n  }).join(\";\");\n  const importString = `importScripts(${depsString});`;\n  return `${depsString.trim() === \"\" ? \"\" : importString} ${depsFunctionString}`;\n}\n\nfunction jobRunner(userFunc) {\n  return (e) => {\n    const userFuncArgs = e.data[0];\n    return Promise.resolve(userFunc.apply(void 0, userFuncArgs)).then((result) => {\n      postMessage([\"SUCCESS\", result]);\n    }).catch((error) => {\n      postMessage([\"ERROR\", error]);\n    });\n  };\n}\n\nfunction createWorkerBlobUrl(fn, deps, localDeps) {\n  const blobCode = `${depsParser(deps, localDeps)}; onmessage=(${jobRunner})(${fn})`;\n  const blob = new Blob([blobCode], { type: \"text/javascript\" });\n  const url = URL.createObjectURL(blob);\n  return url;\n}\n\nfunction useWebWorkerFn(fn, options = {}) {\n  const {\n    dependencies = [],\n    localDependencies = [],\n    timeout,\n    window = defaultWindow\n  } = options;\n  const worker = ref();\n  const workerStatus = ref(\"PENDING\");\n  const promise = ref({});\n  const timeoutId = ref();\n  const workerTerminate = (status = \"PENDING\") => {\n    if (worker.value && worker.value._url && window) {\n      worker.value.terminate();\n      URL.revokeObjectURL(worker.value._url);\n      promise.value = {};\n      worker.value = void 0;\n      window.clearTimeout(timeoutId.value);\n      workerStatus.value = status;\n    }\n  };\n  workerTerminate();\n  tryOnScopeDispose(workerTerminate);\n  const generateWorker = () => {\n    const blobUrl = createWorkerBlobUrl(fn, dependencies, localDependencies);\n    const newWorker = new Worker(blobUrl);\n    newWorker._url = blobUrl;\n    newWorker.onmessage = (e) => {\n      const { resolve = () => {\n      }, reject = () => {\n      } } = promise.value;\n      const [status, result] = e.data;\n      switch (status) {\n        case \"SUCCESS\":\n          resolve(result);\n          workerTerminate(status);\n          break;\n        default:\n          reject(result);\n          workerTerminate(\"ERROR\");\n          break;\n      }\n    };\n    newWorker.onerror = (e) => {\n      const { reject = () => {\n      } } = promise.value;\n      e.preventDefault();\n      reject(e);\n      workerTerminate(\"ERROR\");\n    };\n    if (timeout) {\n      timeoutId.value = setTimeout(\n        () => workerTerminate(\"TIMEOUT_EXPIRED\"),\n        timeout\n      );\n    }\n    return newWorker;\n  };\n  const callWorker = (...fnArgs) => new Promise((resolve, reject) => {\n    var _a;\n    promise.value = {\n      resolve,\n      reject\n    };\n    (_a = worker.value) == null ? void 0 : _a.postMessage([[...fnArgs]]);\n    workerStatus.value = \"RUNNING\";\n  });\n  const workerFn = (...fnArgs) => {\n    if (workerStatus.value === \"RUNNING\") {\n      console.error(\n        \"[useWebWorkerFn] You can only run one instance of the worker at a time.\"\n      );\n      return Promise.reject();\n    }\n    worker.value = generateWorker();\n    return callWorker(...fnArgs);\n  };\n  return {\n    workerFn,\n    workerStatus,\n    workerTerminate\n  };\n}\n\nfunction useWindowFocus(options = {}) {\n  const { window = defaultWindow } = options;\n  if (!window)\n    return ref(false);\n  const focused = ref(window.document.hasFocus());\n  useEventListener(window, \"blur\", () => {\n    focused.value = false;\n  });\n  useEventListener(window, \"focus\", () => {\n    focused.value = true;\n  });\n  return focused;\n}\n\nfunction useWindowScroll(options = {}) {\n  const { window = defaultWindow, behavior = \"auto\" } = options;\n  if (!window) {\n    return {\n      x: ref(0),\n      y: ref(0)\n    };\n  }\n  const internalX = ref(window.scrollX);\n  const internalY = ref(window.scrollY);\n  const x = computed({\n    get() {\n      return internalX.value;\n    },\n    set(x2) {\n      scrollTo({ left: x2, behavior });\n    }\n  });\n  const y = computed({\n    get() {\n      return internalY.value;\n    },\n    set(y2) {\n      scrollTo({ top: y2, behavior });\n    }\n  });\n  useEventListener(\n    window,\n    \"scroll\",\n    () => {\n      internalX.value = window.scrollX;\n      internalY.value = window.scrollY;\n    },\n    {\n      capture: false,\n      passive: true\n    }\n  );\n  return { x, y };\n}\n\nfunction useWindowSize(options = {}) {\n  const {\n    window = defaultWindow,\n    initialWidth = Number.POSITIVE_INFINITY,\n    initialHeight = Number.POSITIVE_INFINITY,\n    listenOrientation = true,\n    includeScrollbar = true,\n    type = \"inner\"\n  } = options;\n  const width = ref(initialWidth);\n  const height = ref(initialHeight);\n  const update = () => {\n    if (window) {\n      if (type === \"outer\") {\n        width.value = window.outerWidth;\n        height.value = window.outerHeight;\n      } else if (includeScrollbar) {\n        width.value = window.innerWidth;\n        height.value = window.innerHeight;\n      } else {\n        width.value = window.document.documentElement.clientWidth;\n        height.value = window.document.documentElement.clientHeight;\n      }\n    }\n  };\n  update();\n  tryOnMounted(update);\n  useEventListener(\"resize\", update, { passive: true });\n  if (listenOrientation) {\n    const matches = useMediaQuery(\"(orientation: portrait)\");\n    watch(matches, () => update());\n  }\n  return { width, height };\n}\n\nexport { DefaultMagicKeysAliasMap, StorageSerializers, TransitionPresets, computedAsync as asyncComputed, breakpointsAntDesign, breakpointsBootstrapV5, breakpointsElement, breakpointsMasterCss, breakpointsPrimeFlex, breakpointsQuasar, breakpointsSematic, breakpointsTailwind, breakpointsVuetify, breakpointsVuetifyV2, breakpointsVuetifyV3, cloneFnJSON, computedAsync, computedInject, createFetch, createReusableTemplate, createTemplatePromise, createUnrefFn, customStorageEventName, defaultDocument, defaultLocation, defaultNavigator, defaultWindow, executeTransition, formatTimeAgo, getSSRHandler, mapGamepadToXbox360Controller, onClickOutside, onKeyDown, onKeyPressed, onKeyStroke, onKeyUp, onLongPress, onStartTyping, setSSRHandler, templateRef, unrefElement, useActiveElement, useAnimate, useAsyncQueue, useAsyncState, useBase64, useBattery, useBluetooth, useBreakpoints, useBroadcastChannel, useBrowserLocation, useCached, useClipboard, useClipboardItems, useCloned, useColorMode, useConfirmDialog, useCssVar, useCurrentElement, useCycleList, useDark, useDebouncedRefHistory, useDeviceMotion, useDeviceOrientation, useDevicePixelRatio, useDevicesList, useDisplayMedia, useDocumentVisibility, useDraggable, useDropZone, useElementBounding, useElementByPoint, useElementHover, useElementSize, useElementVisibility, useEventBus, useEventListener, useEventSource, useEyeDropper, useFavicon, useFetch, useFileDialog, useFileSystemAccess, useFocus, useFocusWithin, useFps, useFullscreen, useGamepad, useGeolocation, useIdle, useImage, useInfiniteScroll, useIntersectionObserver, useKeyModifier, useLocalStorage, useMagicKeys, useManualRefHistory, useMediaControls, useMediaQuery, useMemoize, useMemory, useMounted, useMouse, useMouseInElement, useMousePressed, useMutationObserver, useNavigatorLanguage, useNetwork, useNow, useObjectUrl, useOffsetPagination, useOnline, usePageLeave, useParallax, useParentElement, usePerformanceObserver, usePermission, usePointer, usePointerLock, usePointerSwipe, usePreferredColorScheme, usePreferredContrast, usePreferredDark, usePreferredLanguages, usePreferredReducedMotion, usePrevious, useRafFn, useRefHistory, useResizeObserver, useScreenOrientation, useScreenSafeArea, useScriptTag, useScroll, useScrollLock, useSessionStorage, useShare, useSorted, useSpeechRecognition, useSpeechSynthesis, useStepper, useStorage, useStorageAsync, useStyleTag, useSupported, useSwipe, useTemplateRefsList, useTextDirection, useTextSelection, useTextareaAutosize, useThrottledRefHistory, useTimeAgo, useTimeoutPoll, useTimestamp, useTitle, useTransition, useUrlSearchParams, useUserMedia, useVModel, useVModels, useVibrate, useVirtualList, useWakeLock, useWebNotification, useWebSocket, useWebWorker, useWebWorkerFn, useWindowFocus, useWindowScroll, useWindowSize };\n","/*\n    * Vuescroll v5.0.0\n    * (c) 2018-2022 Yi(Yves) Wang\n    * Released under the MIT License\n    * Github: https://github.com/YvesCoding/vuescroll\n    * Website: http://vuescrolljs.yvescoding.me/\n    */\n   \nimport { h } from 'vue';\n\nfunction _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function (obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function (obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nfunction _toConsumableArray(arr) {\n  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return _arrayLikeToArray(arr);\n}\n\nfunction _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && Symbol.iterator in Object(iter)) return Array.from(iter);\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n\n  return arr2;\n}\n\nfunction _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction upperFirstChar(str) {\n  return str.slice(0, 1).toUpperCase() + (str.slice(1) || '');\n}\n/* istanbul ignore next */\n\nvar isServer = function isServer() {\n  return typeof window === 'undefined';\n};\nfunction deepCopy(from, to, shallow) {\n  if (shallow && isUndef(to)) {\n    return from;\n  }\n\n  if (isArray(from)) {\n    to = [];\n    from.forEach(function (item, index) {\n      to[index] = deepCopy(item, to[index]);\n    });\n  } else if (from) {\n    if (!isPlainObj(from)) {\n      return from;\n    }\n\n    to = {};\n\n    for (var key in from) {\n      to[key] = _typeof(from[key]) === 'object' ? deepCopy(from[key], to[key]) : from[key];\n    }\n  }\n\n  return to;\n}\nfunction mergeObject(from, to, force, shallow) {\n  if (shallow && isUndef(to)) {\n    return from;\n  }\n\n  to = to || {};\n\n  if (isArray(from)) {\n    if (!isArray(to) && force) {\n      to = [];\n    }\n\n    if (isArray(to)) {\n      from.forEach(function (item, index) {\n        to[index] = mergeObject(item, to[index], force, shallow);\n      });\n    }\n  } else if (from) {\n    if (!isPlainObj(from)) {\n      if (force) {\n        to = from;\n      }\n    } else {\n      for (var key in from) {\n        if (_typeof(from[key]) === 'object') {\n          if (isUndef(to[key])) {\n            to[key] = deepCopy(from[key], to[key], shallow);\n          } else {\n            mergeObject(from[key], to[key], force, shallow);\n          }\n        } else {\n          if (isUndef(to[key]) || force) to[key] = from[key];\n        }\n      }\n    }\n  }\n\n  return to;\n}\nfunction defineReactive(target, key, source, souceKey) {\n  /* istanbul ignore if */\n  if (!source[key] && typeof source !== 'function') {\n    return;\n  }\n\n  souceKey = souceKey || key;\n  Object.defineProperty(target, key, {\n    get: function get() {\n      return source[souceKey];\n    },\n    configurable: true\n  });\n}\nfunction isIE() {\n  /* istanbul ignore if */\n  if (isServer()) return false;\n  var agent = navigator.userAgent.toLowerCase();\n  return agent.indexOf('msie') !== -1 || agent.indexOf('trident') !== -1 || agent.indexOf(' edge/') !== -1;\n}\nvar isIos = function isIos() {\n  /* istanbul ignore if */\n  if (isServer()) return false;\n  var u = navigator.userAgent;\n  return !!u.match(/\\(i[^;]+;( U;)? CPU.+Mac OS X/);\n};\nvar isArray = function isArray(_) {\n  return Array.isArray(_);\n};\nvar isPlainObj = function isPlainObj(_) {\n  return Object.prototype.toString.call(_) == '[object Object]';\n};\nvar isUndef = function isUndef(_) {\n  return typeof _ === 'undefined';\n}; // do nothing\n\nvar NOOP = function NOOP() {};\nfunction getNumericValue(distance, size) {\n  var number;\n\n  if (!(number = /(-?\\d+(?:\\.\\d+?)?)%$/.exec(distance))) {\n    number = distance - 0;\n  } else {\n    number = number[1] - 0;\n    number = size * number / 100;\n  }\n\n  return number;\n}\n\nvar log = {\n  error: function error(msg) {\n    console.error(\"[vuescroll] \".concat(msg));\n  },\n  warn: function warn(msg) {\n    console.warn(\"[vuescroll] \".concat(msg));\n  }\n};\n\nvar warn = log.warn;\nvar baseConfig = {\n  // vuescroll\n  vuescroll: {\n    // vuescroll's size(height/width) should be a percent(100%)\n    // or be a number that is equal to its parentNode's width or\n    // height ?\n    sizeStrategy: 'percent',\n\n    /** Whether to detect dom resize or not */\n    detectResize: true,\n\n    /** Enable locking to the main axis if user moves only slightly on one of them at start */\n    locking: true\n  },\n  scrollPanel: {\n    // when component mounted.. it will automatically scrolls.\n    initialScrollY: false,\n    initialScrollX: false,\n    // feat: #11\n    scrollingX: true,\n    scrollingY: true,\n    speed: 300,\n    easing: undefined,\n    // Sometimes, the nativebar maybe on the left,\n    // See https://github.com/YvesCoding/vuescroll/issues/64\n    verticalNativeBarPos: 'right',\n    maxHeight: undefined,\n    maxWidth: undefined\n  },\n  //\n  rail: {\n    background: '#01a99a',\n    opacity: 0,\n    border: 'none',\n\n    /** Rail's size(Height/Width) , default -> 6px */\n    size: '6px',\n\n    /** Specify rail's border-radius, or the border-radius of rail and bar will be equal to the rail's size. default -> false **/\n    specifyBorderRadius: false,\n\n    /** Rail the distance from the two ends of the X axis and Y axis. **/\n    gutterOfEnds: null,\n\n    /** Rail the distance from the side of container. **/\n    gutterOfSide: '2px',\n\n    /** Whether to keep rail show or not, default -> false, event content height is not enough */\n    keepShow: false\n  },\n  bar: {\n    /** How long to hide bar after mouseleave, default -> 500 */\n    showDelay: 500,\n\n    /** Specify bar's border-radius, or the border-radius of rail and bar will be equal to the rail's size. default -> false **/\n    specifyBorderRadius: false,\n\n    /** Whether to show bar on scrolling, default -> true */\n    onlyShowBarOnScroll: true,\n\n    /** Whether to keep show or not, default -> false */\n    keepShow: false,\n\n    /** Bar's background , default -> #00a650 */\n    background: 'rgb(3, 185, 118)',\n\n    /** Bar's opacity, default -> 1  */\n    opacity: 1,\n\n    /** bar's size(Height/Width) , default -> 6px */\n    size: '6px',\n    minSize: 0,\n    disable: false\n  },\n  scrollButton: {\n    enable: false,\n    background: 'rgb(3, 185, 118)',\n    opacity: 1,\n    step: 180,\n    mousedownStep: 30\n  }\n};\n/**\n * validate the options\n * @export\n * @param {any} ops\n */\n\nfunction validateOps(ops) {\n  var renderError = false;\n  var scrollPanel = ops.scrollPanel;\n  var _ops$bar = ops.bar,\n      vBar = _ops$bar.vBar,\n      hBar = _ops$bar.hBar;\n  var _ops$rail = ops.rail,\n      vRail = _ops$rail.vRail,\n      hRail = _ops$rail.hRail; // validate scrollPanel\n\n  var initialScrollY = scrollPanel['initialScrollY'];\n  var initialScrollX = scrollPanel['initialScrollX'];\n\n  if (initialScrollY && !String(initialScrollY).match(/^\\d+(\\.\\d+)?(%)?$/)) {\n    warn('The prop `initialScrollY` or `initialScrollX` should be a percent number like `10%` or an exact number that greater than or equal to 0 like `100`.');\n  }\n\n  if (initialScrollX && !String(initialScrollX).match(/^\\d+(\\.\\d+)?(%)?$/)) {\n    warn('The prop `initialScrollY` or `initialScrollX` should be a percent number like `10%` or an exact number that greater than or equal to 0 like `100`.');\n  } // validate deprecated vBar/hBar vRail/hRail\n\n\n  if (vBar || hBar || vRail || hRail) {\n    warn('The options: vRail, hRail, vBar, hBar have been deprecated since v4.7.0,' + 'please use corresponing rail/bar instead!');\n  }\n\n  if (_extraValidate) {\n    _extraValidate = [].concat(_extraValidate);\n\n    _extraValidate.forEach(function (hasError) {\n      if (hasError(ops)) {\n        renderError = true;\n      }\n    });\n  }\n\n  return renderError;\n}\nvar _extraValidate = null;\nvar extendOpts = function extendOpts(extraOpts, extraValidate) {\n  extraOpts = [].concat(extraOpts);\n  extraOpts.forEach(function (opts) {\n    mergeObject(opts, baseConfig);\n  });\n  _extraValidate = extraValidate;\n};\n\n// all modes\nvar modes = ['slide', 'native']; // some small changes.\n\nvar __REFRESH_DOM_NAME = 'refreshDom';\nvar __LOAD_DOM_NAME = 'loadDom';\n\n/**\n * ZoomManager\n * Get the browser zoom ratio\n */\nvar ZoomManager = /*#__PURE__*/function () {\n  function ZoomManager() {\n    var _this = this;\n\n    _classCallCheck(this, ZoomManager);\n\n    this.originPixelRatio = this.getRatio();\n    this.lastPixelRatio = this.originPixelRatio;\n    window.addEventListener('resize', function () {\n      _this.lastPixelRatio = _this.getRatio();\n    });\n  }\n\n  _createClass(ZoomManager, [{\n    key: \"getRatio\",\n    value: function getRatio() {\n      var ratio = 0;\n      var screen = window.screen;\n      var ua = navigator.userAgent.toLowerCase();\n\n      if (window.devicePixelRatio !== undefined) {\n        ratio = window.devicePixelRatio;\n      } else if (~ua.indexOf('msie')) {\n        if (screen.deviceXDPI && screen.logicalXDPI) {\n          ratio = screen.deviceXDPI / screen.logicalXDPI;\n        }\n      } else if (window.outerWidth !== undefined && window.innerWidth !== undefined) {\n        ratio = window.outerWidth / window.innerWidth;\n      }\n\n      if (ratio) {\n        ratio = Math.round(ratio * 100);\n      }\n\n      return ratio;\n    }\n  }, {\n    key: \"getRatioBetweenPreAndCurrent\",\n    value: function getRatioBetweenPreAndCurrent() {\n      return this.originPixelRatio / this.lastPixelRatio;\n    }\n  }]);\n\n  return ZoomManager;\n}();\n\nvar scrollBarWidth;\nvar zoomManager;\nfunction getGutter() {\n  /* istanbul ignore next */\n  if (isServer()) return 0;\n\n  if (!zoomManager) {\n    zoomManager = new ZoomManager();\n  }\n\n  if (scrollBarWidth !== undefined) return scrollBarWidth * zoomManager.getRatioBetweenPreAndCurrent();\n  var outer = document.createElement('div');\n  outer.style.visibility = 'hidden';\n  outer.style.width = '100px';\n  outer.style.position = 'absolute';\n  outer.style.top = '-9999px';\n  document.body.appendChild(outer);\n  var widthNoScroll = outer.offsetWidth;\n  outer.style.overflow = 'scroll';\n  var inner = document.createElement('div');\n  inner.style.width = '100%';\n  outer.appendChild(inner);\n  var widthWithScroll = inner.offsetWidth;\n  outer.parentNode.removeChild(outer);\n  scrollBarWidth = widthNoScroll - widthWithScroll; // multi the browser zoom\n\n  if (!zoomManager) {\n    zoomManager = new ZoomManager();\n  }\n\n  return scrollBarWidth * zoomManager.getRatioBetweenPreAndCurrent();\n}\nfunction eventCenter(dom, eventName, hander) {\n  var capture = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;\n  var type = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'on';\n  type == 'on' ? dom.addEventListener(eventName, hander, capture) : dom.removeEventListener(eventName, hander, capture);\n}\nfunction isChildInParent(child, parent) {\n  var flag = false;\n\n  if (!child || !parent) {\n    return flag;\n  }\n\n  while (child.parentNode !== parent && child.parentNode.nodeType !== 9 && !child.parentNode._isVuescroll) {\n    child = child.parentNode;\n  }\n\n  if (child.parentNode == parent) {\n    flag = true;\n  }\n\n  return flag;\n}\nfunction getPrefix(global) {\n  var docStyle = document.documentElement.style;\n  var engine;\n  /* istanbul ignore if */\n\n  if (global.opera && Object.prototype.toString.call(opera) === '[object Opera]') {\n    engine = 'presto';\n  }\n  /* istanbul ignore next */\n  else if ('MozAppearance' in docStyle) {\n      engine = 'gecko';\n    } else if ('WebkitAppearance' in docStyle) {\n      engine = 'webkit';\n    }\n    /* istanbul ignore next */\n    else if (typeof navigator.cpuClass === 'string') {\n        engine = 'trident';\n      }\n\n  var vendorPrefix = {\n    trident: 'ms',\n    gecko: 'moz',\n    webkit: 'webkit',\n    presto: 'O'\n  }[engine];\n  return vendorPrefix;\n}\nfunction getComplitableStyle(property, value) {\n  /* istanbul ignore if */\n  if (isServer()) return false;\n  var compatibleValue = \"-\".concat(getPrefix(window), \"-\").concat(value);\n  var testElm = document.createElement('div');\n  testElm.style[property] = compatibleValue;\n\n  if (testElm.style[property] == compatibleValue) {\n    return compatibleValue;\n  }\n  /* istanbul ignore next */\n\n\n  return false;\n}\n/**\n * Insert children into user-passed slot at vnode level\n */\n\nfunction insertChildrenIntoSlot(parentVnodeFunc, childVNodeFunc) {\n  var data = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var parentVnode = parentVnodeFunc();\n  var childVNode = childVNodeFunc();\n  /* istanbul ignore if */\n\n  if (parentVnode && parentVnode.length > 1) {\n    return function () {\n      return [].concat(_toConsumableArray(parentVnode), _toConsumableArray(childVNode));\n    };\n  }\n\n  var _getVnodeInfo = getVnodeInfo(parentVnode),\n      ch = _getVnodeInfo.ch,\n      tag = _getVnodeInfo.tag;\n\n  var newCh = function newCh() {\n    return [].concat(_toConsumableArray(ch), _toConsumableArray(childVNode));\n  };\n\n  return h(tag, mergeObject(data, parentVnode[0].props || {}, // merge our props and the props that user passed to custom component.\n  false, true), {\n    \"default\": newCh\n  });\n}\n/**\n *  Get the info of a vnode,\n * vnode must be parentVnode\n */\n\nfunction getVnodeInfo(vnode) {\n  /* istanbul ignore if */\n  if (!vnode || vnode.length > 1) return {};\n  var firstVnode = vnode[0] ? vnode[0] : vnode;\n  var ch;\n  var tag;\n  ch = firstVnode.children || [];\n  tag = firstVnode.type;\n  return {\n    ch: ch,\n    tag: tag\n  };\n}\n/**\n * Get the vuescroll instance instead of\n * user pass component like slot.\n */\n\nfunction getRealParent(ctx) {\n  var parent = ctx.$parent;\n\n  if (!parent.$data._isVuescrollRoot && parent) {\n    parent = parent.$parent;\n  }\n\n  return parent;\n}\nfunction createStyle(styleId, cssText) {\n  /* istanbul ignore if */\n  if (isServer() || document.getElementById(styleId)) {\n    return;\n  }\n\n  var head = document.head || doc.getElementsByTagName('head')[0];\n  var style = document.createElement('style');\n  style.id = styleId;\n  style.type = 'text/css';\n  /* istanbul ignore if */\n\n  if (style.styleSheet) {\n    style.styleSheet.cssText = cssText;\n  } else {\n    style.appendChild(document.createTextNode(cssText));\n  }\n\n  head.appendChild(style);\n} // Hide the ios native scrollbar.\n\nfunction createHideBarStyle() {\n  /* istanbul ignore next */\n  {\n    var cssText = \".__hidebar::-webkit-scrollbar {\\n      width: 0;\\n      height: 0;\\n    }\";\n    createStyle('vuescroll-hide-ios-bar', cssText);\n  }\n} // create slide mode style\n\nfunction createSlideModeStyle() {\n  var cssText = \"\\n    @-webkit-keyframes loading-rotate {\\n      to {\\n        -webkit-transform: rotate(1turn);\\n        transform: rotate(1turn);\\n      }\\n    }\\n\\n    @keyframes loading-rotate {\\n      to {\\n        -webkit-transform: rotate(1turn);\\n        transform: rotate(1turn);\\n      }\\n    }\\n\\n    @-webkit-keyframes loading-wipe {\\n      0% {\\n        stroke-dasharray: 1, 200;\\n        stroke-dashoffset: 0;\\n      }\\n      50% {\\n        stroke-dasharray: 90, 150;\\n        stroke-dashoffset: -40px;\\n      }\\n      to {\\n        stroke-dasharray: 90, 150;\\n        stroke-dashoffset: -120px;\\n      }\\n    }\\n\\n    @keyframes loading-wipe {\\n      0% {\\n        stroke-dasharray: 1, 200;\\n        stroke-dashoffset: 0;\\n      }\\n      50% {\\n        stroke-dasharray: 90, 150;\\n        stroke-dashoffset: -40px;\\n      }\\n      to {\\n        stroke-dasharray: 90, 150;\\n        stroke-dashoffset: -120px;\\n      }\\n    }\\n\\n    .__vuescroll .__refresh,\\n    .__vuescroll .__load {\\n      position: absolute;\\n      width: 100%;\\n      color: black;\\n      height: 50px;\\n      line-height: 50px;\\n      text-align: center;\\n      font-size: 16px;\\n    }\\n    .__vuescroll .__refresh svg,\\n    .__vuescroll .__load svg {\\n      margin-right: 10px;\\n      width: 25px;\\n      height: 25px;\\n      vertical-align: sub;\\n    }\\n    .__vuescroll .__refresh svg.active,\\n    .__vuescroll .__load svg.active {\\n      transition: all 0.2s;\\n    }\\n    .__vuescroll .__refresh svg.active.deactive,\\n    .__vuescroll .__load svg.active.deactive {\\n      transform: rotateZ(180deg);\\n    }\\n    .__vuescroll .__refresh svg path,\\n    .__vuescroll .__refresh svg rect,\\n    .__vuescroll .__load svg path,\\n    .__vuescroll .__load svg rect {\\n      fill: #20a0ff;\\n    }\\n    .__vuescroll .__refresh svg.start,\\n    .__vuescroll .__load svg.start {\\n      stroke: #343640;\\n      stroke-width: 4;\\n      stroke-linecap: round;\\n      -webkit-animation: loading-rotate 2s linear infinite;\\n      animation: loading-rotate 2s linear infinite;\\n    }\\n    .__vuescroll .__refresh svg.start .bg-path,\\n    .__vuescroll .__load svg.start .bg-path {\\n      stroke: #f2f2f2;\\n      fill: none;\\n    }\\n    .__vuescroll .__refresh svg.start .active-path,\\n    .__vuescroll .__load svg.start .active-path {\\n      stroke: #20a0ff;\\n      fill: none;\\n      stroke-dasharray: 90, 150;\\n      stroke-dashoffset: 0;\\n      -webkit-animation: loading-wipe 1.5s ease-in-out infinite;\\n      animation: loading-wipe 1.5s ease-in-out infinite;\\n    }\\n  \";\n  createStyle('vuescroll-silde-mode-style', cssText);\n}\n/**\n * Get the children of parent those are in viewport\n */\n\nfunction getCurrentViewportDom(parent, container) {\n  var children = parent.children;\n  var domFragment = [];\n\n  var isCurrentview = function isCurrentview(dom) {\n    var _dom$getBoundingClien = dom.getBoundingClientRect(),\n        left = _dom$getBoundingClien.left,\n        top = _dom$getBoundingClien.top,\n        width = _dom$getBoundingClien.width,\n        height = _dom$getBoundingClien.height;\n\n    var _container$getBoundin = container.getBoundingClientRect(),\n        parentLeft = _container$getBoundin.left,\n        parentTop = _container$getBoundin.top,\n        parentHeight = _container$getBoundin.height,\n        parentWidth = _container$getBoundin.width;\n\n    if (left - parentLeft + width > 0 && left - parentLeft < parentWidth && top - parentTop + height > 0 && top - parentTop < parentHeight) {\n      return true;\n    }\n\n    return false;\n  };\n\n  for (var i = 0; i < children.length; i++) {\n    var dom = children.item(i);\n\n    if (isCurrentview(dom) && !dom.isResizeElm) {\n      domFragment.push(dom);\n    }\n  }\n\n  return domFragment;\n}\n\nvar scrollMap = {\n  vertical: {\n    size: 'height',\n    opsSize: 'width',\n    posName: 'top',\n    opposName: 'bottom',\n    sidePosName: 'right',\n    page: 'pageY',\n    scroll: 'scrollTop',\n    scrollSize: 'scrollHeight',\n    offset: 'offsetHeight',\n    client: 'clientY',\n    axis: 'Y',\n    scrollButton: {\n      start: 'top',\n      end: 'bottom'\n    }\n  },\n  horizontal: {\n    size: 'width',\n    opsSize: 'height',\n    posName: 'left',\n    opposName: 'right',\n    sidePosName: 'bottom',\n    page: 'pageX',\n    scroll: 'scrollLeft',\n    scrollSize: 'scrollWidth',\n    offset: 'offsetWidth',\n    client: 'clientX',\n    axis: 'X',\n    scrollButton: {\n      start: 'left',\n      end: 'right'\n    }\n  }\n};\n\nvar TouchManager = /*#__PURE__*/function () {\n  function TouchManager() {\n    _classCallCheck(this, TouchManager);\n  }\n\n  _createClass(TouchManager, [{\n    key: \"getEventObject\",\n    value: function getEventObject(originEvent) {\n      return this.touchObject ? this.isTouch ? originEvent.touches : [originEvent] : null;\n    }\n  }, {\n    key: \"getTouchObject\",\n    value: function getTouchObject()\n    /* istanbul ignore next */\n    {\n      if (isServer()) return null;\n      this.isTouch = false;\n      var agent = navigator.userAgent,\n          platform = navigator.platform,\n          touchObject = {};\n      touchObject.touch = !!('ontouchstart' in window && !window.opera || 'msmaxtouchpoints' in window.navigator || 'maxtouchpoints' in window.navigator || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0);\n      touchObject.nonDeskTouch = touchObject.touch && !/win32/i.test(platform) || touchObject.touch && /win32/i.test(platform) && /mobile/i.test(agent);\n      touchObject.eventType = 'onmousedown' in window && !touchObject.nonDeskTouch ? 'mouse' : 'ontouchstart' in window ? 'touch' : 'msmaxtouchpoints' in window.navigator || navigator.msMaxTouchPoints > 0 ? 'mstouchpoints' : 'maxtouchpoints' in window.navigator || navigator.maxTouchPoints > 0 ? 'touchpoints' : 'mouse';\n\n      switch (touchObject.eventType) {\n        case 'mouse':\n          touchObject.touchstart = 'mousedown';\n          touchObject.touchend = 'mouseup';\n          touchObject.touchmove = 'mousemove';\n          touchObject.touchenter = 'mouseenter';\n          touchObject.touchmove = 'mousemove';\n          touchObject.touchleave = 'mouseleave';\n          break;\n\n        case 'touch':\n          touchObject.touchstart = 'touchstart';\n          touchObject.touchend = 'touchend';\n          touchObject.touchmove = 'touchmove';\n          touchObject.touchcancel = 'touchcancel';\n          touchObject.touchenter = 'touchstart';\n          touchObject.touchmove = 'touchmove';\n          touchObject.touchleave = 'touchend';\n          this.isTouch = true;\n          break;\n\n        case 'mstouchpoints':\n          touchObject.touchstart = 'MSPointerDown';\n          touchObject.touchend = 'MSPointerUp';\n          touchObject.touchmove = 'MSPointerMove';\n          touchObject.touchcancel = 'MSPointerCancel';\n          touchObject.touchenter = 'MSPointerDown';\n          touchObject.touchmove = 'MSPointerMove';\n          touchObject.touchleave = 'MSPointerUp';\n          break;\n\n        case 'touchpoints':\n          touchObject.touchstart = 'pointerdown';\n          touchObject.touchend = 'pointerup';\n          touchObject.touchmove = 'pointermove';\n          touchObject.touchcancel = 'pointercancel';\n          touchObject.touchenter = 'pointerdown';\n          touchObject.touchmove = 'pointermove';\n          touchObject.touchleave = 'pointerup';\n          break;\n      }\n\n      Object.keys(touchObject).forEach(function (key) {\n        if (key !== 'touch' && key.startsWith('touch')) {\n          touchObject['_' + key] = touchObject[key];\n          touchObject[key] = 'on' + upperFirstChar(touchObject[key]);\n        }\n      });\n      return this.touchObject = touchObject;\n    }\n  }]);\n\n  return TouchManager;\n}();\n\n/**\n *  Compatible to scroller's animation function\n */\nfunction createEasingFunction(easing, easingPattern) {\n  return function (time) {\n    return easingPattern(easing, time);\n  };\n}\n/**\n * Calculate the easing pattern\n * @link https://github.com/cferdinandi/smooth-scroll/blob/master/src/js/smooth-scroll.js\n * modified by wangyi7099\n * @param {String} type Easing pattern\n * @param {Number} time Time animation should take to complete\n * @returns {Number}\n */\n\nfunction easingPattern(easing, time) {\n  var pattern = null;\n  /* istanbul ignore next */\n\n  {\n    // Default Easing Patterns\n    if (easing === 'easeInQuad') pattern = time * time; // accelerating from zero velocity\n\n    if (easing === 'easeOutQuad') pattern = time * (2 - time); // decelerating to zero velocity\n\n    if (easing === 'easeInOutQuad') pattern = time < 0.5 ? 2 * time * time : -1 + (4 - 2 * time) * time; // acceleration until halfway, then deceleration\n\n    if (easing === 'easeInCubic') pattern = time * time * time; // accelerating from zero velocity\n\n    if (easing === 'easeOutCubic') pattern = --time * time * time + 1; // decelerating to zero velocity\n\n    if (easing === 'easeInOutCubic') pattern = time < 0.5 ? 4 * time * time * time : (time - 1) * (2 * time - 2) * (2 * time - 2) + 1; // acceleration until halfway, then deceleration\n\n    if (easing === 'easeInQuart') pattern = time * time * time * time; // accelerating from zero velocity\n\n    if (easing === 'easeOutQuart') pattern = 1 - --time * time * time * time; // decelerating to zero velocity\n\n    if (easing === 'easeInOutQuart') pattern = time < 0.5 ? 8 * time * time * time * time : 1 - 8 * --time * time * time * time; // acceleration until halfway, then deceleration\n\n    if (easing === 'easeInQuint') pattern = time * time * time * time * time; // accelerating from zero velocity\n\n    if (easing === 'easeOutQuint') pattern = 1 + --time * time * time * time * time; // decelerating to zero velocity\n\n    if (easing === 'easeInOutQuint') pattern = time < 0.5 ? 16 * time * time * time * time * time : 1 + 16 * --time * time * time * time * time; // acceleration until halfway, then deceleration\n  }\n  return pattern || time; // no easing, no acceleration\n}\n\nfunction requestAnimationFrame(global) {\n  // Check for request animation Frame support\n  var requestFrame = global.requestAnimationFrame || global.webkitRequestAnimationFrame || global.mozRequestAnimationFrame || global.oRequestAnimationFrame;\n  var isNative = !!requestFrame;\n\n  if (requestFrame && !/requestAnimationFrame\\(\\)\\s*\\{\\s*\\[native code\\]\\s*\\}/i.test(requestFrame.toString())) {\n    isNative = false;\n  }\n\n  if (isNative) {\n    return function (callback, root) {\n      requestFrame(callback, root);\n    };\n  }\n\n  var TARGET_FPS = 60;\n  var requests = {};\n  var rafHandle = 1;\n  var intervalHandle = null;\n  var lastActive = +new Date();\n  return function (callback) {\n    var callbackHandle = rafHandle++; // Store callback\n\n    requests[callbackHandle] = callback; // Create timeout at first request\n\n    if (intervalHandle === null) {\n      intervalHandle = setInterval(function () {\n        var time = +new Date();\n        var currentRequests = requests; // Reset data structure before executing callbacks\n\n        requests = {};\n\n        for (var key in currentRequests) {\n          if (currentRequests.hasOwnProperty(key)) {\n            currentRequests[key](time);\n            lastActive = time;\n          }\n        } // Disable the timeout when nothing happens for a certain\n        // period of time\n\n\n        if (time - lastActive > 2500) {\n          clearInterval(intervalHandle);\n          intervalHandle = null;\n        }\n      }, 1000 / TARGET_FPS);\n    }\n\n    return callbackHandle;\n  };\n}\n\nfunction noop() {\n  return true;\n}\n/* istanbul ignore next */\n\n\nvar now = Date.now || function () {\n  return new Date().getTime();\n};\n\nvar ScrollControl = /*#__PURE__*/function () {\n  function ScrollControl() {\n    _classCallCheck(this, ScrollControl);\n\n    this.init();\n    this.isRunning = false;\n  }\n\n  _createClass(ScrollControl, [{\n    key: \"pause\",\n    value: function pause() {\n      /* istanbul ignore if */\n      if (!this.isRunning) return;\n      this.isPaused = true;\n    }\n  }, {\n    key: \"stop\",\n    value: function stop() {\n      this.isStopped = true;\n    }\n  }, {\n    key: \"continue\",\n    value: function _continue() {\n      /* istanbul ignore if */\n      if (!this.isPaused) return;\n      this.isPaused = false;\n      this.ts = now() - this.percent * this.spd;\n      this.execScroll();\n    }\n  }, {\n    key: \"startScroll\",\n    value: function startScroll(st, ed, spd) {\n      var stepCb = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : noop;\n      var completeCb = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : noop;\n      var vertifyCb = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : noop;\n      var easingMethod = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : noop;\n      var df = ed - st;\n      var dir = df > 0 ? -1 : 1;\n      var nt = now();\n\n      if (!this.isRunning) {\n        this.init();\n      }\n\n      if (dir != this.dir || nt - this.ts > 200) {\n        this.ts = nt;\n        this.dir = dir;\n        this.st = st;\n        this.ed = ed;\n        this.df = df;\n      }\n      /* istanbul ignore next */\n      else {\n          this.df += df;\n        }\n\n      this.spd = spd;\n      this.completeCb = completeCb;\n      this.vertifyCb = vertifyCb;\n      this.stepCb = stepCb;\n      this.easingMethod = easingMethod;\n      if (!this.isRunning) this.execScroll();\n    }\n  }, {\n    key: \"execScroll\",\n    value: function execScroll() {\n      var _this = this;\n\n      if (!this.df) return;\n      var percent = this.percent || 0;\n      this.percent = 0;\n      this.isRunning = true;\n\n      var loop = function loop() {\n        /* istanbul ignore if */\n        if (!_this.isRunning || !_this.vertifyCb(percent) || _this.isStopped) {\n          _this.isRunning = false;\n          return;\n        }\n\n        percent = (now() - _this.ts) / _this.spd;\n\n        if (_this.isPaused) {\n          _this.percent = percent;\n          _this.isRunning = false;\n          return;\n        }\n\n        if (percent < 1) {\n          var value = _this.st + _this.df * _this.easingMethod(percent);\n\n          _this.stepCb(value);\n\n          _this.ref(loop);\n        } else {\n          // trigger complete\n          _this.stepCb(_this.st + _this.df);\n\n          _this.completeCb();\n\n          _this.isRunning = false;\n        }\n      };\n\n      this.ref(loop);\n    }\n  }, {\n    key: \"init\",\n    value: function init() {\n      this.st = 0;\n      this.ed = 0;\n      this.df = 0;\n      this.spd = 0;\n      this.ts = 0;\n      this.dir = 0;\n      this.ref = requestAnimationFrame(window);\n      this.isPaused = false;\n      this.isStopped = false;\n    }\n  }]);\n\n  return ScrollControl;\n}();\n\nvar warn$1 = log.warn;\nfunction scrollTo(elm, x, y) {\n  var speed = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 300;\n  var easing = arguments.length > 4 ? arguments[4] : undefined;\n  var scrollingComplete = arguments.length > 5 ? arguments[5] : undefined;\n  var scrollLeft, scrollTop, scrollHeight, scrollWidth, clientWidth, clientHeight;\n  var _elm = elm,\n      nodeType = _elm.nodeType;\n  var scrollX = new ScrollControl();\n  var scrollY = new ScrollControl();\n\n  if (!nodeType) {\n    warn$1('You must pass a dom for the first param, ' + 'for window scrolling, ' + 'you can pass document as the first param.');\n    return;\n  }\n\n  if (nodeType == 9) {\n    // document\n    elm = elm.scrollingElement;\n  }\n\n  var _elm2 = elm;\n  scrollLeft = _elm2.scrollLeft;\n  scrollTop = _elm2.scrollTop;\n  scrollHeight = _elm2.scrollHeight;\n  scrollWidth = _elm2.scrollWidth;\n  clientWidth = _elm2.clientWidth;\n  clientHeight = _elm2.clientHeight;\n\n  if (typeof x === 'undefined') {\n    x = scrollLeft;\n  } else {\n    x = getNumericValue(x, scrollWidth - clientWidth);\n  }\n\n  if (typeof y === 'undefined') {\n    y = scrollTop;\n  } else {\n    y = getNumericValue(y, scrollHeight - clientHeight);\n  }\n\n  var easingMethod = createEasingFunction(easing, easingPattern);\n  scrollX.startScroll(scrollLeft, x, speed, function (dx) {\n    elm.scrollLeft = dx;\n  }, scrollingComplete, undefined, easingMethod);\n  scrollY.startScroll(scrollTop, y, speed, function (dy) {\n    elm.scrollTop = dy;\n  }, scrollingComplete, undefined, easingMethod);\n}\nvar nativeApi = {\n  mounted: function mounted() {\n    // registry scroll\n    this.scrollX = new ScrollControl();\n    this.scrollY = new ScrollControl();\n  },\n  methods: {\n    nativeStop: function nativeStop() {\n      this.scrollX.stop();\n      this.scrollY.stop();\n    },\n    nativePause: function nativePause() {\n      this.scrollX.pause();\n      this.scrollY.pause();\n    },\n    nativeContinue: function nativeContinue() {\n      this.scrollX[\"continue\"]();\n      this.scrollY[\"continue\"]();\n    },\n    nativeScrollTo: function nativeScrollTo(x, y, speed, easing) {\n      if (speed === false) ; else if (typeof speed === 'undefined') {\n        speed = this.mergedOptions.scrollPanel.speed;\n      }\n\n      var elm = this.scrollPanelElm;\n      var scrollTop = elm.scrollTop,\n          scrollLeft = elm.scrollLeft,\n          scrollWidth = elm.scrollWidth,\n          clientWidth = elm.clientWidth,\n          scrollHeight = elm.scrollHeight,\n          clientHeight = elm.clientHeight;\n\n      if (typeof x === 'undefined') {\n        x = scrollLeft;\n      } else {\n        x = getNumericValue(x, scrollWidth - clientWidth);\n      }\n\n      if (typeof y === 'undefined') {\n        y = scrollTop;\n      } else {\n        y = getNumericValue(y, scrollHeight - clientHeight);\n      }\n\n      if (speed) {\n        easing = easing || this.mergedOptions.scrollPanel.easing;\n        var easingMethod = createEasingFunction(easing, easingPattern);\n\n        if (x != scrollLeft) {\n          this.scrollX.startScroll(scrollLeft, x, speed, function (x) {\n            elm.scrollLeft = x;\n          }, this.scrollingComplete.bind(this), undefined, easingMethod);\n        }\n\n        if (y != scrollTop) {\n          this.scrollY.startScroll(scrollTop, y, speed, function (y) {\n            elm.scrollTop = y;\n          }, this.scrollingComplete.bind(this), undefined, easingMethod);\n        }\n      } else {\n        elm.scrollTop = y;\n        elm.scrollLeft = x;\n      }\n    },\n    getCurrentviewDomNative: function getCurrentviewDomNative() {\n      var parent = this.scrollContentElm;\n      var domFragment = getCurrentViewportDom(parent, this.$el);\n      return domFragment;\n    }\n  }\n};\n\nvar warn$2 = log.warn;\nvar api = {\n  mounted: function mounted() {\n    vsInstances[this.$.uid] = this;\n  },\n  beforeUnmount: function beforeUnmount() {\n    /* istanbul ignore next */\n    delete vsInstances[this.$.uid];\n  },\n  methods: {\n    // public api\n    scrollTo: function scrollTo(_ref, speed, easing) {\n      var x = _ref.x,\n          y = _ref.y;\n\n      // istanbul ignore if\n      if (speed === true || typeof speed == 'undefined') {\n        speed = this.mergedOptions.scrollPanel.speed;\n      }\n\n      this.internalScrollTo(x, y, speed, easing);\n    },\n    scrollBy: function scrollBy(_ref2, speed, easing) {\n      var _ref2$dx = _ref2.dx,\n          dx = _ref2$dx === void 0 ? 0 : _ref2$dx,\n          _ref2$dy = _ref2.dy,\n          dy = _ref2$dy === void 0 ? 0 : _ref2$dy;\n\n      var _this$getPosition = this.getPosition(),\n          _this$getPosition$scr = _this$getPosition.scrollLeft,\n          scrollLeft = _this$getPosition$scr === void 0 ? 0 : _this$getPosition$scr,\n          _this$getPosition$scr2 = _this$getPosition.scrollTop,\n          scrollTop = _this$getPosition$scr2 === void 0 ? 0 : _this$getPosition$scr2;\n\n      if (dx) {\n        scrollLeft += getNumericValue(dx, this.scrollPanelElm.scrollWidth - this.$el.clientWidth);\n      }\n\n      if (dy) {\n        scrollTop += getNumericValue(dy, this.scrollPanelElm.scrollHeight - this.$el.clientHeight);\n      }\n\n      this.internalScrollTo(scrollLeft, scrollTop, speed, easing);\n    },\n    scrollIntoView: function scrollIntoView(elm) {\n      var animate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n      var parentElm = this.$el;\n\n      if (typeof elm === 'string') {\n        elm = parentElm.querySelector(elm);\n      }\n\n      if (!isChildInParent(elm, parentElm)) {\n        warn$2('The element or selector you passed is not the element of Vuescroll, please pass the element that is in Vuescroll to scrollIntoView API. ');\n        return;\n      } // parent elm left, top\n\n\n      var _this$$el$getBounding = this.$el.getBoundingClientRect(),\n          left = _this$$el$getBounding.left,\n          top = _this$$el$getBounding.top; // child elm left, top\n\n\n      var _elm$getBoundingClien = elm.getBoundingClientRect(),\n          childLeft = _elm$getBoundingClien.left,\n          childTop = _elm$getBoundingClien.top;\n\n      var diffX = left - childLeft;\n      var diffY = top - childTop;\n      this.scrollBy({\n        dx: -diffX,\n        dy: -diffY\n      }, animate);\n    },\n    refresh: function refresh() {\n      this.refreshInternalStatus(); // refresh again to keep status is correct\n\n      this.$nextTick(this.refreshInternalStatus);\n    }\n  }\n};\n/** Public Api */\n\n/**\n * Refresh all\n */\n\nvar vsInstances = {};\nfunction refreshAll() {\n  for (var vs in vsInstances) {\n    vsInstances[vs].refresh();\n  }\n}\n\nfunction _extends(){return _extends=Object.assign||function(a){for(var b,c=1;c<arguments.length;c++)for(var d in b=arguments[c],b)Object.prototype.hasOwnProperty.call(b,d)&&(a[d]=b[d]);return a},_extends.apply(this,arguments)}var normalMerge=[\"attrs\",\"props\",\"domProps\"],toArrayMerge=[\"class\",\"style\",\"directives\"],functionalMerge=[\"on\",\"nativeOn\"],mergeJsxProps=function(a){return a.reduce(function(c,a){for(var b in a)if(!c[b])c[b]=a[b];else if(-1!==normalMerge.indexOf(b))c[b]=_extends({},c[b],a[b]);else if(-1!==toArrayMerge.indexOf(b)){var d=c[b]instanceof Array?c[b]:[c[b]],e=a[b]instanceof Array?a[b]:[a[b]];c[b]=d.concat(e);}else if(-1!==functionalMerge.indexOf(b)){for(var f in a[b])if(c[b][f]){var g=c[b][f]instanceof Array?c[b][f]:[c[b][f]],h=a[b][f]instanceof Array?a[b][f]:[a[b][f]];c[b][f]=g.concat(h);}else c[b][f]=a[b][f];}else if(\"hook\"==b)for(var i in a[b])c[b][i]=c[b][i]?mergeFn(c[b][i],a[b][i]):a[b][i];else c[b]=a[b];return c},{})},mergeFn=function(a,b){return function(){a&&a.apply(this,arguments),b&&b.apply(this,arguments);}};var helper=mergeJsxProps;\n\nvar ScrollPanel = {\n  name: 'ScrollPanel',\n  props: {\n    ops: {\n      type: Object,\n      required: true\n    }\n  },\n  methods: {\n    // trigger scrollPanel options initialScrollX,\n    // initialScrollY\n    updateInitialScroll: function updateInitialScroll() {\n      var x = 0;\n      var y = 0;\n      var parent = getRealParent(this);\n\n      if (this.ops.initialScrollX) {\n        x = this.ops.initialScrollX;\n      }\n\n      if (this.ops.initialScrollY) {\n        y = this.ops.initialScrollY;\n      }\n\n      if (x || y) {\n        parent.scrollTo({\n          x: x,\n          y: y\n        });\n      }\n    }\n  },\n  mounted: function mounted() {\n    var _this = this;\n\n    setTimeout(function () {\n      if (!_this._isDestroyed) {\n        _this.updateInitialScroll();\n      }\n    }, 0);\n  },\n  render: function render() {\n    // eslint-disable-line\n    var data = {\n      \"class\": ['__panel'],\n      style: {\n        position: 'relative',\n        boxSizing: 'border-box'\n      }\n    };\n    var parent = getRealParent(this);\n    var _customPanel = parent.$slots['scroll-panel'];\n\n    if (_customPanel) {\n      return insertChildrenIntoSlot(_customPanel, this.$slots[\"default\"], data);\n    }\n\n    return h(\"div\", helper([{}, data]), [this.$slots[\"default\"]()]);\n  }\n};\n\nvar colorCache = {};\nvar rgbReg = /rgb\\(/;\nvar extractRgbColor = /rgb\\((.*)\\)/; // Transform a common color int oa `rgbA` color\n\nfunction getRgbAColor(color, opacity) {\n  var id = color + '&' + opacity;\n\n  if (colorCache[id]) {\n    return colorCache[id];\n  }\n\n  var div = document.createElement('div');\n  div.style.background = color;\n  document.body.appendChild(div);\n  var computedColor = window.getComputedStyle(div).backgroundColor;\n  document.body.removeChild(div);\n  /* istanbul ignore if */\n\n  if (!rgbReg.test(computedColor)) {\n    return color;\n  }\n\n  return colorCache[id] = \"rgba(\".concat(extractRgbColor.exec(computedColor)[1], \", \").concat(opacity, \")\");\n}\n\nvar Scrollbar = {\n  name: 'Scrollbar',\n  props: {\n    ops: Object,\n    state: Object,\n    hideBar: Boolean,\n    otherBarHide: Boolean,\n    type: String\n  },\n  computed: {\n    bar: function bar() {\n      return scrollMap[this.type];\n    },\n    barSize: function barSize() {\n      return Math.max(this.state.size, this.ops.bar.minSize);\n    },\n    barRatio: function barRatio() {\n      return (1 - this.barSize) / (1 - this.state.size);\n    }\n  },\n  render: function render() {\n    var _style, _style2, _barStyle;\n\n    var vm = this;\n    /** Get rgbA format background color */\n\n    var railBackgroundColor = getRgbAColor(vm.ops.rail.background, vm.ops.rail.opacity);\n    /** Rail Data */\n\n    var railSize = vm.ops.rail.size;\n    var endPos = vm.otherBarHide ? 0 : railSize;\n    var touchObj = vm.touchManager.getTouchObject();\n    var rail = {\n      \"class\": \"__rail-is-\".concat(vm.type),\n      style: (_style = {\n        position: 'absolute',\n        'z-index': '1',\n        borderRadius: vm.ops.rail.specifyBorderRadius || railSize,\n        background: railBackgroundColor,\n        border: vm.ops.rail.border\n      }, _defineProperty(_style, vm.bar.opsSize, railSize), _defineProperty(_style, vm.bar.posName, vm.ops.rail['gutterOfEnds'] || 0), _defineProperty(_style, vm.bar.opposName, vm.ops.rail['gutterOfEnds'] || endPos), _defineProperty(_style, vm.bar.sidePosName, vm.ops.rail['gutterOfSide']), _style)\n    };\n\n    if (touchObj) {\n      rail[touchObj.touchenter] = function () {\n        vm.setRailHover();\n      };\n\n      rail[touchObj.touchleave] = function () {\n        vm.setRailLeave();\n      };\n    } // left space for scroll button\n\n\n    var buttonSize = vm.ops.scrollButton.enable ? railSize : 0;\n    var barWrapper = {\n      \"class\": \"__bar-wrap-is-\".concat(vm.type),\n      style: (_style2 = {\n        position: 'absolute',\n        borderRadius: vm.ops.rail.specifyBorderRadius || railSize\n      }, _defineProperty(_style2, vm.bar.posName, buttonSize), _defineProperty(_style2, vm.bar.opposName, buttonSize), _style2)\n    };\n    var scrollDistance = vm.state.posValue * vm.state.size;\n    var pos = scrollDistance * vm.barRatio / vm.barSize;\n    var opacity = vm.state.opacity;\n    var parent = getRealParent(this); // set class hook\n\n    parent.setClassHook(this.type == 'vertical' ? 'vBarVisible' : 'hBarVisible', !!opacity);\n    /** Scrollbar style */\n\n    var barStyle = (_barStyle = {\n      cursor: 'pointer',\n      position: 'absolute',\n      margin: 'auto',\n      transition: 'opacity 0.5s',\n      'user-select': 'none',\n      'border-radius': 'inherit'\n    }, _defineProperty(_barStyle, vm.bar.size, vm.barSize * 100 + '%'), _defineProperty(_barStyle, \"background\", vm.ops.bar.background), _defineProperty(_barStyle, vm.bar.opsSize, vm.ops.bar.size), _defineProperty(_barStyle, \"opacity\", opacity), _defineProperty(_barStyle, \"transform\", \"translate\".concat(scrollMap[vm.type].axis, \"(\").concat(pos, \"%)\")), _barStyle);\n    var bar = {\n      style: barStyle,\n      \"class\": \"__bar-is-\".concat(vm.type),\n      ref: 'thumb'\n    };\n\n    if (vm.type == 'vertical') {\n      barWrapper.style.width = '100%'; // Let bar to be on the center.\n\n      bar.style.left = 0;\n      bar.style.right = 0;\n    } else {\n      barWrapper.style.height = '100%';\n      bar.style.top = 0;\n      bar.style.bottom = 0;\n    }\n    /* istanbul ignore next */\n\n\n    {\n      var _touchObj = this.touchManager.getTouchObject();\n\n      bar[_touchObj.touchstart] = this.createBarEvent();\n      barWrapper[_touchObj.touchstart] = this.createTrackEvent();\n    }\n    return h(\"div\", helper([{}, rail]), [this.createScrollbarButton('start'), this.hideBar ? null : h(\"div\", helper([{}, barWrapper]), [h(\"div\", helper([{}, bar]))]), this.createScrollbarButton('end')]);\n  },\n  data: function data() {\n    return {\n      touchManager: new TouchManager(),\n      isBarDragging: false\n    };\n  },\n  methods: {\n    setRailHover: function setRailHover() {\n      var parent = getRealParent(this);\n      var state = parent.vuescroll.state;\n\n      if (!state.isRailHover) {\n        state.isRailHover = true;\n        parent.showBar();\n      }\n    },\n    setRailLeave: function setRailLeave() {\n      var parent = getRealParent(this);\n      var state = parent.vuescroll.state;\n      state.isRailHover = false;\n      parent.hideBar();\n    },\n    setBarDrag: function setBarDrag(val)\n    /* istanbul ignore next */\n    {\n      this.$emit('setBarDrag', this.isBarDragging = val);\n      var parent = getRealParent(this); // set class hook\n\n      parent.setClassHook(this.type == 'vertical' ? 'vBarDragging' : 'hBarDragging', !!val);\n    },\n    createBarEvent: function createBarEvent() {\n      var ctx = this;\n      var parent = getRealParent(ctx);\n      var touchObj = ctx.touchManager.getTouchObject();\n\n      function mousedown(e)\n      /* istanbul ignore next */\n      {\n        var event = ctx.touchManager.getEventObject(e);\n        if (!event) return;\n        e.stopImmediatePropagation();\n        e.preventDefault();\n        event = event[0];\n\n        document.onselectstart = function () {\n          return false;\n        };\n\n        ctx.axisStartPos = event[ctx.bar.client] - ctx.$refs['thumb'].getBoundingClientRect()[ctx.bar.posName]; // Tell parent that the mouse has been down.\n\n        ctx.setBarDrag(true);\n        eventCenter(document, touchObj._touchmove, mousemove);\n        eventCenter(document, touchObj._touchend, mouseup);\n      }\n\n      function mousemove(e)\n      /* istanbul ignore next */\n      {\n        if (!ctx.axisStartPos) {\n          return;\n        }\n\n        var event = ctx.touchManager.getEventObject(e);\n        if (!event) return;\n        event = event[0];\n        var thubmParent = ctx.$refs.thumb.parentNode;\n        var delta = event[ctx.bar.client] - thubmParent.getBoundingClientRect()[ctx.bar.posName];\n        delta = delta / ctx.barRatio;\n        var percent = (delta - ctx.axisStartPos) / thubmParent[ctx.bar.offset];\n        parent.scrollTo(_defineProperty({}, ctx.bar.axis.toLowerCase(), parent.scrollPanelElm[ctx.bar.scrollSize] * percent), false);\n      }\n\n      function mouseup()\n      /* istanbul ignore next */\n      {\n        ctx.setBarDrag(false);\n        parent.hideBar();\n        document.onselectstart = null;\n        ctx.axisStartPos = 0;\n        eventCenter(document, touchObj._touchmove, mousemove, false, 'off');\n        eventCenter(document, touchObj._touchend, mouseup, false, 'off');\n      }\n\n      return mousedown;\n    },\n    createTrackEvent: function createTrackEvent() {\n      var ctx = this;\n      return function handleClickTrack(e) {\n        var parent = getRealParent(ctx);\n        var _ctx$bar = ctx.bar,\n            client = _ctx$bar.client,\n            offset = _ctx$bar.offset,\n            posName = _ctx$bar.posName,\n            axis = _ctx$bar.axis;\n        var thumb = ctx.$refs['thumb'];\n        e.preventDefault();\n        e.stopImmediatePropagation();\n        /* istanbul ignore if */\n\n        if (!thumb) return;\n        var barOffset = thumb[offset];\n        var event = ctx.touchManager.getEventObject(e)[0];\n        var percent = (event[client] - e.currentTarget.getBoundingClientRect()[posName] - barOffset / 2) / (e.currentTarget[offset] - barOffset);\n        parent.scrollTo(_defineProperty({}, axis.toLowerCase(), percent * 100 + '%'));\n      };\n    },\n    // Scrollbuton relative things...\n    createScrollbarButton: function createScrollbarButton(type\n    /* start or end  */\n    ) {\n      var _style3;\n\n      var barContext = this;\n\n      if (!barContext.ops.scrollButton.enable) {\n        return null;\n      }\n\n      var size = barContext.ops.rail.size;\n      var _barContext$ops$scrol = barContext.ops.scrollButton,\n          opacity = _barContext$ops$scrol.opacity,\n          background = _barContext$ops$scrol.background;\n      var borderColor = getRgbAColor(background, opacity);\n      var wrapperProps = {\n        \"class\": ['__bar-button', '__bar-button-is-' + barContext.type + '-' + type],\n        style: (_style3 = {}, _defineProperty(_style3, barContext.bar.scrollButton[type], 0), _defineProperty(_style3, \"width\", size), _defineProperty(_style3, \"height\", size), _defineProperty(_style3, \"position\", 'absolute'), _defineProperty(_style3, \"cursor\", 'pointer'), _defineProperty(_style3, \"display\", 'table'), _style3),\n        ref: type\n      };\n      var innerProps = {\n        \"class\": '__bar-button-inner',\n        style: {\n          border: \"calc(\".concat(size, \" / 2.5) solid transparent\"),\n          width: '0',\n          height: '0',\n          margin: 'auto',\n          position: 'absolute',\n          top: '0',\n          bottom: '0',\n          right: '0',\n          left: '0'\n        }\n      };\n\n      if (barContext.type == 'vertical') {\n        if (type == 'start') {\n          innerProps.style['border-bottom-color'] = borderColor;\n          innerProps.style['transform'] = 'translateY(-25%)';\n        } else {\n          innerProps.style['border-top-color'] = borderColor;\n          innerProps.style['transform'] = 'translateY(25%)';\n        }\n      } else {\n        if (type == 'start') {\n          innerProps.style['border-right-color'] = borderColor;\n          innerProps.style['transform'] = 'translateX(-25%)';\n        } else {\n          innerProps.style['border-left-color'] = borderColor;\n          innerProps.style['transform'] = 'translateX(25%)';\n        }\n      }\n      /* istanbul ignore next */\n\n\n      {\n        var touchObj = this.touchManager.getTouchObject();\n        innerProps[touchObj.touchstart] = this.createScrollButtonEvent(type, touchObj);\n      }\n      return h(\"div\", helper([{}, wrapperProps]), [h(\"div\", helper([{}, innerProps]))]);\n    },\n    createScrollButtonEvent: function createScrollButtonEvent(type, touchObj) {\n      var ctx = this;\n      var parent = getRealParent(ctx);\n      var _ctx$ops$scrollButton = ctx.ops.scrollButton,\n          step = _ctx$ops$scrollButton.step,\n          mousedownStep = _ctx$ops$scrollButton.mousedownStep;\n      var stepWithDirection = type == 'start' ? -step : step;\n      var mousedownStepWithDirection = type == 'start' ? -mousedownStep : mousedownStep;\n      var ref = requestAnimationFrame(window); // bar props: type\n\n      var barType = ctx.type;\n      var isMouseDown = false;\n      var isMouseout = true;\n      var timeoutId;\n\n      function start(e) {\n        /* istanbul ignore if */\n        if (3 == e.which) {\n          return;\n        } // set class hook\n\n\n        parent.setClassHook(\"cliking\".concat(barType).concat(type, \"Button\"), true);\n        e.stopImmediatePropagation();\n        e.preventDefault();\n        isMouseout = false;\n        parent.scrollBy(_defineProperty({}, 'd' + ctx.bar.axis.toLowerCase(), stepWithDirection));\n        eventCenter(document, touchObj._touchend, endPress, false);\n\n        if (touchObj._touchstart == 'mousedown') {\n          var elm = ctx.$refs[type];\n          eventCenter(elm, 'mouseenter', enter, false);\n          eventCenter(elm, 'mouseleave', leave, false);\n        }\n\n        clearTimeout(timeoutId);\n        timeoutId = setTimeout(function ()\n        /* istanbul ignore next */\n        {\n          isMouseDown = true;\n          ref(pressing, window);\n        }, 500);\n      }\n\n      function pressing()\n      /* istanbul ignore next */\n      {\n        if (isMouseDown && !isMouseout) {\n          parent.scrollBy(_defineProperty({}, 'd' + ctx.bar.axis.toLowerCase(), mousedownStepWithDirection), false);\n          ref(pressing, window);\n        }\n      }\n\n      function endPress() {\n        clearTimeout(timeoutId);\n        isMouseDown = false;\n        eventCenter(document, touchObj._touchend, endPress, false, 'off');\n\n        if (touchObj._touchstart == 'mousedown') {\n          var elm = ctx.$refs[type];\n          eventCenter(elm, 'mouseenter', enter, false, 'off');\n          eventCenter(elm, 'mouseleave', leave, false, 'off');\n        }\n\n        parent.setClassHook(\"cliking\".concat(barType).concat(type, \"Button\"), false);\n      }\n\n      function enter()\n      /* istanbul ignore next */\n      {\n        isMouseout = false;\n        pressing();\n      }\n\n      function leave()\n      /* istanbul ignore next */\n      {\n        isMouseout = true;\n      }\n\n      return start;\n    }\n  }\n};\n\nfunction getBarData(vm, type) {\n  var axis = scrollMap[type].axis;\n  /** type.charAt(0) = vBar/hBar */\n\n  var barType = \"\".concat(type.charAt(0), \"Bar\");\n  var hideBar = !vm.bar[barType].state.size || !vm.mergedOptions.scrollPanel['scrolling' + axis] || vm.refreshLoad && type !== 'vertical' || vm.mergedOptions.bar.disable;\n  var keepShowRail = vm.mergedOptions.rail.keepShow;\n\n  if (hideBar && !keepShowRail) {\n    return null;\n  }\n\n  return {\n    hideBar: hideBar,\n    type: type,\n    ops: {\n      bar: vm.mergedOptions.bar,\n      rail: vm.mergedOptions.rail,\n      scrollButton: vm.mergedOptions.scrollButton\n    },\n    state: vm.bar[barType].state,\n    onSetBarDrag: vm.setBarDrag,\n    ref: \"\".concat(type, \"Bar\"),\n    key: type\n  };\n}\n/**\n * create bars\n *\n * @param {any} size\n * @param {any} type\n */\n\nfunction createBar(vm) {\n  var verticalBarProps = getBarData(vm, 'vertical');\n  var horizontalBarProps = getBarData(vm, 'horizontal'); // set class hooks\n\n  vm.setClassHook('hasVBar', !!(verticalBarProps && !verticalBarProps.hideBar));\n  vm.setClassHook('hasHBar', !!(horizontalBarProps && !horizontalBarProps.hideBar));\n  return [verticalBarProps ? h(Scrollbar, helper([{}, _objectSpread2(_objectSpread2({}, verticalBarProps), {\n    props: _objectSpread2(_objectSpread2({}, {\n      otherBarHide: !horizontalBarProps\n    }), verticalBarProps.props)\n  })])) : null, horizontalBarProps ? h(Scrollbar, helper([{}, _objectSpread2(_objectSpread2({}, horizontalBarProps), {\n    props: _objectSpread2(_objectSpread2({}, {\n      otherBarHide: !verticalBarProps\n    }), horizontalBarProps.props)\n  })])) : null];\n}\n\n/**\n * This is like a HOC, It extracts the common parts of the\n * native-mode, slide-mode and mix-mode.\n * Each mode must implement the following methods:\n * 1. refreshInternalStatus : use to refresh the component\n * 2. destroy : Destroy some registryed events before component destroy.\n * 3. updateBarStateAndEmitEvent: use to update bar states and emit events.\n */\n\nvar createComponent = function createComponent(_ref) {\n  var _components;\n\n  var _render = _ref.render,\n      mixins = _ref.mixins;\n  var components = (_components = {}, _defineProperty(_components, ScrollPanel.name, ScrollPanel), _defineProperty(_components, Scrollbar.name, Scrollbar), _components);\n  return {\n    name: 'vueScroll',\n    emits: ['refresh-status', 'handle-scroll', 'handle-resize', 'window-resize', 'handle-scroll-complete', 'options-change'],\n    props: {\n      ops: {\n        type: Object\n      }\n    },\n    components: components,\n    mixins: [api].concat(_toConsumableArray([].concat(mixins))),\n    created: function created() {\n      var _this = this;\n\n      /**\n       * Begin to merge options\n       */\n      var _gfc = mergeObject(this.$vuescrollConfig || {}, {});\n\n      var ops = mergeObject(baseConfig, _gfc);\n      var propsOps = this.ops || {};\n      Object.keys(propsOps).forEach(function (key) {\n        {\n          defineReactive(_this.mergedOptions, key, propsOps);\n        }\n      }); // from ops to mergedOptions\n\n      mergeObject(ops, this.mergedOptions);\n      this.$data._isVuescrollRoot = true;\n      this.renderError = validateOps(this.mergedOptions);\n    },\n    render: function render() {\n      var vm = this;\n\n      if (vm.renderError) {\n        return h(\"div\", [[vm.$slots['default']]]);\n      } // vuescroll data\n\n\n      var data = {\n        style: {\n          height: vm.vuescroll.state.height,\n          width: vm.vuescroll.state.width,\n          padding: 0,\n          position: 'relative',\n          overflow: 'hidden'\n        },\n        \"class\": _objectSpread2({\n          __vuescroll: true\n        }, vm.classHooks)\n      };\n      var touchObj = vm.touchManager.getTouchObject();\n\n      if (touchObj) {\n        data[touchObj.touchenter] = function () {\n          vm.vuescroll.state.pointerLeave = false;\n          vm.updateBarStateAndEmitEvent();\n          vm.setClassHook('mouseEnter', true);\n        };\n\n        data[touchObj.touchleave] = function () {\n          vm.vuescroll.state.pointerLeave = true;\n          vm.hideBar();\n          vm.setClassHook('mouseEnter', false);\n        };\n\n        data[touchObj.touchmove] = function ()\n        /* istanbul ignore next */\n        {\n          vm.vuescroll.state.pointerLeave = false;\n          vm.updateBarStateAndEmitEvent();\n        };\n      }\n\n      var ch = {\n        \"default\": function _default() {\n          return [_render(vm)].concat(_toConsumableArray(createBar(vm)));\n        }\n      };\n      var _customContainer = this.$slots['scroll-container'];\n\n      if (_customContainer) {\n        return insertChildrenIntoSlot(_customContainer, ch[\"default\"], data);\n      }\n\n      return h('div', data, ch);\n    },\n    mounted: function mounted() {\n      var _this2 = this;\n\n      if (!this.renderError) {\n        this.initVariables();\n        this.initWatchOpsChange(); // Call external merged Api\n\n        this.refreshInternalStatus();\n        this.updatedCbs.push(function () {\n          _this2.scrollToAnchor(); // need to reflow to deal with the\n          // latest thing.\n\n\n          _this2.updateBarStateAndEmitEvent();\n        });\n      }\n    },\n    updated: function updated() {\n      var _this3 = this;\n\n      this.updatedCbs.forEach(function (cb) {\n        cb.call(_this3);\n      }); // Clear\n\n      this.updatedCbs = [];\n    },\n    beforeUnmount: function beforeUnmount() {\n      /* istanbul ignore next */\n      if (this.destroy) {\n        this.destroy();\n      }\n    },\n\n    /** ------------------------------- Computed ----------------------------- */\n    computed: {\n      scrollPanelElm: function scrollPanelElm() {\n        return this.$refs['scrollPanel'].$el;\n      }\n    },\n    data: function data() {\n      return {\n        touchManager: new TouchManager(),\n        vuescroll: {\n          state: {\n            isDragging: false,\n            pointerLeave: true,\n            isRailHover: false,\n\n            /** Default sizeStrategies */\n            height: '100%',\n            width: '100%',\n            // current size strategy\n            currentSizeStrategy: 'percent',\n            currentScrollState: null,\n            currentScrollInfo: null\n          }\n        },\n        bar: {\n          vBar: {\n            state: {\n              posValue: 0,\n              size: 0,\n              opacity: 0\n            }\n          },\n          hBar: {\n            state: {\n              posValue: 0,\n              size: 0,\n              opacity: 0\n            }\n          }\n        },\n        mergedOptions: {\n          vuescroll: {},\n          scrollPanel: {},\n          scrollContent: {},\n          rail: {},\n          bar: {}\n        },\n        updatedCbs: [],\n        renderError: false,\n        classHooks: {\n          hasVBar: false,\n          hasHBar: false,\n          vBarVisible: false,\n          hBarVisible: false,\n          vBarDragging: false,\n          hBarDragging: false,\n          clikingVerticalStartButton: false,\n          clikingVerticalEndButton: false,\n          clikingHorizontalStartButton: false,\n          clikingHorizontalEndButton: false,\n          mouseEnter: false\n        }\n      };\n    },\n\n    /** ------------------------------- Methods -------------------------------- */\n    methods: {\n      /** ------------------------ Handlers --------------------------- */\n      scrollingComplete: function scrollingComplete() {\n        this.updateBarStateAndEmitEvent('handle-scroll-complete');\n      },\n      setBarDrag: function setBarDrag(val) {\n        /* istanbul ignore next */\n        this.vuescroll.state.isDragging = val;\n      },\n      setClassHook: function setClassHook(name, value) {\n        this.classHooks[name] = value;\n      },\n\n      /** ------------------------ Some Helpers --------------------------- */\n\n      /*\n       * To have a good ux, instead of hiding bar immediately, we hide bar\n       * after some seconds by using this simple debounce-hidebar method.\n       */\n      showAndDefferedHideBar: function showAndDefferedHideBar(forceHideBar) {\n        var _this4 = this;\n\n        this.showBar();\n\n        if (this.timeoutId) {\n          clearTimeout(this.timeoutId);\n          this.timeoutId = 0;\n        }\n\n        this.timeoutId = setTimeout(function () {\n          _this4.timeoutId = 0;\n\n          _this4.hideBar(forceHideBar);\n        }, this.mergedOptions.bar.showDelay);\n      },\n      showBar: function showBar() {\n        var opacity = this.mergedOptions.bar.opacity;\n        this.bar.vBar.state.opacity = opacity;\n        this.bar.hBar.state.opacity = opacity;\n      },\n      hideBar: function hideBar(forceHideBar) {\n        var _this$vuescroll$state = this.vuescroll.state,\n            isDragging = _this$vuescroll$state.isDragging,\n            isRailHover = _this$vuescroll$state.isRailHover;\n        /* istanbul ignore next */\n\n        if (isDragging || isRailHover) {\n          return;\n        }\n\n        if (forceHideBar && !this.mergedOptions.bar.keepShow) {\n          this.bar.hBar.state.opacity = 0;\n          this.bar.vBar.state.opacity = 0;\n        } // add isDragging condition\n        // to prevent from hiding bar while dragging the bar\n\n\n        if (!this.mergedOptions.bar.keepShow && !this.vuescroll.state.isDragging) {\n          this.bar.vBar.state.opacity = 0;\n          this.bar.hBar.state.opacity = 0;\n        }\n      },\n      useNumbericSize: function useNumbericSize() {\n        this.vuescroll.state.currentSizeStrategy = 'number';\n        var _this$mergedOptions$s = this.mergedOptions.scrollPanel,\n            maxHeight = _this$mergedOptions$s.maxHeight,\n            maxWidth = _this$mergedOptions$s.maxWidth;\n        var _this$$el$parentNode = this.$el.parentNode,\n            parentClientHeight = _this$$el$parentNode.clientHeight,\n            parentClientWidth = _this$$el$parentNode.clientWidth;\n        var _this$scrollPanelElm = this.scrollPanelElm,\n            scrollHeight = _this$scrollPanelElm.scrollHeight,\n            scrollWidth = _this$scrollPanelElm.scrollWidth;\n        var width;\n        var height;\n\n        if (maxHeight || maxWidth) {\n          height = scrollHeight <= maxHeight ? undefined : maxHeight;\n          width = scrollWidth <= maxWidth ? undefined : maxWidth;\n        } else {\n          height = parentClientHeight;\n          width = parentClientWidth;\n        }\n\n        this.vuescroll.state.height = height ? height + 'px' : undefined;\n        this.vuescroll.state.width = width ? width + 'px' : undefined;\n      },\n      usePercentSize: function usePercentSize() {\n        this.vuescroll.state.currentSizeStrategy = 'percent';\n        this.vuescroll.state.height = '100%';\n        this.vuescroll.state.width = '100%';\n      },\n      // Set its size to be equal to its parentNode\n      setVsSize: function setVsSize() {\n        var sizeStrategy = this.mergedOptions.vuescroll.sizeStrategy;\n        var _this$mergedOptions$s2 = this.mergedOptions.scrollPanel,\n            maxHeight = _this$mergedOptions$s2.maxHeight,\n            maxWidth = _this$mergedOptions$s2.maxWidth;\n        var _this$scrollPanelElm2 = this.scrollPanelElm,\n            clientHeight = _this$scrollPanelElm2.clientHeight,\n            clientWidth = _this$scrollPanelElm2.clientWidth;\n\n        if (sizeStrategy == 'number' || maxHeight && clientHeight > maxHeight || maxWidth && clientWidth > maxWidth) {\n          this.useNumbericSize();\n        } else if (sizeStrategy == 'percent' && clientHeight != maxHeight && clientWidth != maxWidth) {\n          this.usePercentSize();\n        }\n      },\n\n      /** ------------------------ Init --------------------------- */\n      initWatchOpsChange: function initWatchOpsChange() {\n        var _this5 = this;\n\n        var watchOpts = {\n          deep: true,\n          flush: 'sync'\n        };\n        this.$watch('mergedOptions', function () {\n          setTimeout(function () {\n            if (_this5.isSmallChangeThisTick) {\n              _this5.isSmallChangeThisTick = false;\n\n              _this5.updateBarStateAndEmitEvent('options-change');\n\n              return;\n            }\n\n            _this5.refreshInternalStatus();\n          }, 0);\n        }, watchOpts);\n        /**\n         * We also watch `small` changes, and when small changes happen, we send\n         * a signal to vuescroll, to tell it:\n         * 1. we don't need to registry resize\n         * 2. we don't need to registry scroller.\n         */\n\n        this.$watch(function () {\n          return [_this5.mergedOptions.vuescroll.pullRefresh.tips, _this5.mergedOptions.vuescroll.pushLoad.tips, _this5.mergedOptions.vuescroll.scroller.disable, _this5.mergedOptions.rail, _this5.mergedOptions.bar];\n        }, function () {\n          _this5.isSmallChangeThisTick = true;\n        }, watchOpts);\n      },\n      // scrollTo hash-anchor while mounted component have mounted.\n      scrollToAnchor: function scrollToAnchor()\n      /* istanbul ignore next */\n      {\n        var validateHashSelector = function validateHashSelector(hash) {\n          return /^#[a-zA-Z_]\\d*$/.test(hash);\n        };\n\n        var hash = window.location.hash;\n\n        if (!hash || (hash = hash.slice(hash.lastIndexOf('#'))) && !validateHashSelector(hash)) {\n          return;\n        }\n\n        var elm = document.querySelector(hash);\n\n        if (!isChildInParent(elm, this.$el) || this.mergedOptions.scrollPanel.initialScrollY || this.mergedOptions.scrollPanel.initialScrollX) {\n          return;\n        }\n\n        this.scrollIntoView(elm);\n      }\n      /** ------------------------ Registry Resize --------------------------- */\n\n    }\n  };\n};\n\nfunction _install(core, render) {\n  var extraConfigs = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];\n  var extraValidators = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];\n  var opts = {};\n  opts.render = render;\n  opts.mixins = core;\n  var component = createComponent(opts); // Init Config\n\n  extendOpts(extraConfigs, extraValidators);\n  return _objectSpread2({\n    install: function install(Vue) {\n      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n      Vue.component(opts.name || component.name, component);\n      Vue.config.globalProperties.$vuescrollConfig = opts.ops || {};\n    },\n    version: '5.0.0',\n    refreshAll: refreshAll\n  }, component);\n}\n\nfunction getPanelData(context) {\n  // scrollPanel data start\n  var data = {\n    ref: 'scrollPanel',\n    style: {\n      height: '100%',\n      overflowY: 'scroll',\n      overflowX: 'scroll'\n    },\n    \"class\": [],\n    onScroll: context.handleScroll,\n    onDOMMouseScroll: context.onMouseWheel,\n    onMousewheel: context.onMouseWheel,\n    ops: context.mergedOptions.scrollPanel\n  };\n  context.scrollYEnable = true;\n  context.scrollXEnable = true;\n  var _context$mergedOption = context.mergedOptions.scrollPanel,\n      scrollingY = _context$mergedOption.scrollingY,\n      scrollingX = _context$mergedOption.scrollingX;\n\n  if (!context.bar.hBar.state.size || !scrollingX) {\n    context.scrollXEnable = false;\n    data.style.overflowX = 'hidden';\n  }\n\n  if (!context.bar.vBar.state.size || !scrollingY) {\n    context.scrollYEnable = false;\n    data.style.overflowY = 'hidden';\n  }\n\n  var gutter = getGutter();\n  /* istanbul ignore if */\n\n  if (!gutter) {\n    createHideBarStyle();\n    data[\"class\"].push('__hidebar');\n\n    if (isIos()) {\n      data.style['-webkit-overflow-scrolling'] = 'touch';\n    }\n  } else {\n    // hide system bar by use a negative value px\n    // gutter should be 0 when manually disable scrollingX #14\n    if (context.bar.vBar.state.size && context.mergedOptions.scrollPanel.scrollingY) {\n      if (context.mergedOptions.scrollPanel.verticalNativeBarPos == 'right') {\n        data.style.marginRight = \"-\".concat(gutter, \"px\");\n      }\n      /* istanbul ignore next */\n      else {\n          data.style.marginLeft = \"-\".concat(gutter, \"px\");\n        }\n    }\n\n    if (context.bar.hBar.state.size && context.mergedOptions.scrollPanel.scrollingX) {\n      data.style.height = \"calc(100% + \".concat(gutter, \"px)\");\n    }\n  } // clear legency styles of slide mode...\n\n\n  data.style.transformOrigin = '';\n  data.style.transform = '';\n  return data;\n}\n/**\n * create a scrollPanel\n *\n * @param {any} size\n * @param {any} context\n * @returns\n */\n\nfunction createPanel(context) {\n  var data = {};\n  data = getPanelData(context);\n  return h(ScrollPanel, data, {\n    \"default\": function _default() {\n      return getPanelChildren(context);\n    }\n  });\n}\nfunction getPanelChildren(context) {\n  var viewStyle = {\n    position: 'relative',\n    'box-sizing': 'border-box',\n    'min-width': '100%',\n    'min-height': '100%'\n  };\n  var data = {\n    style: viewStyle,\n    ref: 'scrollContent',\n    \"class\": '__view'\n  };\n  var _customContent = context.$slots['scroll-content'];\n\n  if (context.mergedOptions.scrollPanel.scrollingX) {\n    viewStyle.width = getComplitableStyle('width', 'fit-content');\n  } else {\n    data.style['width'] = '100%';\n  }\n\n  if (context.mergedOptions.scrollPanel.padding) {\n    data.style.paddingRight = context.mergedOptions.rail.size;\n  }\n\n  if (_customContent) {\n    return insertChildrenIntoSlot(_customContent, context.$slots[\"default\"], data);\n  }\n\n  return h(\"div\", helper([{}, data]), [context.$slots[\"default\"]()]);\n}\n\nfunction getPanelData$1(context) {\n  // scrollPanel data start\n  var data = {\n    ref: 'scrollPanel',\n    style: {\n      'user-select': 'none',\n      '-webkit-user-select': 'none',\n      'min-width': '100%',\n      'min-height': '100%'\n    },\n    \"class\": [],\n    ops: context.mergedOptions.scrollPanel\n  };\n  data[\"class\"].push('__slide');\n  /* istanbul ignore if */\n\n  if (isIos()) {\n    data.style = _defineProperty({}, '-webkit-overflow-scrolling', 'touch');\n  }\n\n  if (context.mergedOptions.vuescroll.renderMethod == 'transform') {\n    data.style['transform-origin'] = 'left top 0px';\n  }\n\n  var _context$mergedOption = context.mergedOptions.scrollPanel,\n      scrollingX = _context$mergedOption.scrollingX,\n      scrollingY = _context$mergedOption.scrollingY,\n      padding = _context$mergedOption.padding;\n\n  if (scrollingX && !context.refreshLoad) {\n    var width = getComplitableStyle('width', 'fit-content');\n\n    if (width) {\n      data.style['width'] = width;\n    }\n    /* istanbul ignore next */\n    else {\n        data['display'] = 'inline-block';\n      }\n  }\n  /* istanbul ignore if */\n\n\n  if (!scrollingX) {\n    data[\"class\"].push('x-hidden');\n  }\n  /* istanbul ignore if */\n\n\n  if (!scrollingY) {\n    data[\"class\"].push('y-hidden');\n  }\n\n  if (padding) {\n    data.style.paddingRight = context.mergedOptions.rail.size;\n  }\n\n  return data;\n}\nfunction getPanelChildren$1(context) {\n  var renderChildren = context.$slots['scroll-panel'] || context.$slots[\"default\"];\n  var finalChildren = [];\n  /* istanbul ignore if */\n\n  if (!renderChildren) {\n    context.$slots[\"default\"] = renderChildren = [];\n  } // handle refresh\n\n\n  if (context.mergedOptions.vuescroll.pullRefresh.enable) {\n    finalChildren.push(h(\"div\", {\n      \"class\": \"__refresh\",\n      \"style\": {\n        visibility: context.refrehDomVisiable ? '' : 'hidden'\n      },\n      \"ref\": __REFRESH_DOM_NAME,\n      \"key\": __REFRESH_DOM_NAME\n    }, [createTipDom(context, 'refresh', context.pullRefreshTip)]));\n  }\n\n  finalChildren.push(renderChildren()); // handle load\n\n  if (context.mergedOptions.vuescroll.pushLoad.enable) {\n    finalChildren.push(h(\"div\", {\n      \"ref\": __LOAD_DOM_NAME,\n      \"key\": __LOAD_DOM_NAME,\n      \"class\": \"__load\",\n      \"style\": {\n        visibility: context.loadDomVisiable ? '' : 'hidden'\n      }\n    }, [createTipDom(context, 'load', context.pushLoadTip)]));\n  }\n\n  return finalChildren;\n} // Create load or refresh tip dom of each stages\n\nfunction createTipDom(context, type, tip) {\n  var stage = context.vuescroll.state[\"\".concat(type, \"Stage\")];\n  var dom = null; // Return user specified animation dom\n\n  /* istanbul ignore if */\n\n  if (dom = context.$slots[\"\".concat(type, \"-\").concat(stage)]) {\n    return dom;\n  }\n\n  switch (stage) {\n    // The dom will show at deactive stage\n    case 'deactive':\n    case 'active':\n      {\n        var className = 'active';\n\n        if (stage == 'deactive') {\n          className += ' deactive';\n        }\n\n        dom = h(\"svg\", {\n          \"class\": className,\n          \"attrs\": {\n            \"version\": \"1.1\",\n            \"xmlns\": \"http://www.w3.org/2000/svg\",\n            \"xmlnsXlink\": \"http://www.w3.org/1999/xlink\",\n            \"x\": \"0px\",\n            \"y\": \"0px\",\n            \"viewBox\": \"0 0 1000 1000\",\n            \"enable-background\": \"new 0 0 1000 1000\",\n            \"xmlSpace\": \"preserve\"\n          }\n        }, [h(\"metadata\", [\" Svg Vector Icons : http://www.sfont.cn \"]), h(\"g\", [h(\"g\", {\n          \"attrs\": {\n            \"transform\": \"matrix(1 0 0 -1 0 1008)\"\n          }\n        }, [h(\"path\", {\n          \"attrs\": {\n            \"d\": \"M10,543l490,455l490-455L885,438L570,735.5V18H430v717.5L115,438L10,543z\"\n          }\n        })])])]);\n      }\n      break;\n\n    case 'start':\n      dom = h(\"svg\", {\n        \"attrs\": {\n          \"viewBox\": \"0 0 50 50\"\n        },\n        \"class\": \"start\"\n      }, [h(\"circle\", {\n        \"attrs\": {\n          \"stroke\": \"true\",\n          \"cx\": \"25\",\n          \"cy\": \"25\",\n          \"r\": \"20\"\n        },\n        \"class\": \"bg-path\"\n      }), h(\"circle\", {\n        \"attrs\": {\n          \"cx\": \"25\",\n          \"cy\": \"25\",\n          \"r\": \"20\"\n        },\n        \"class\": \"active-path\"\n      })]);\n      break;\n\n    case 'beforeDeactive':\n      dom = h(\"svg\", {\n        \"attrs\": {\n          \"viewBox\": \"0 0 1024 1024\",\n          \"version\": \"1.1\",\n          \"xmlns\": \"http://www.w3.org/2000/svg\",\n          \"p-id\": \"3562\"\n        }\n      }, [h(\"path\", {\n        \"attrs\": {\n          \"d\": \"M512 0C229.706831 0 0 229.667446 0 512s229.667446 512 512 512c282.293169 0 512-229.667446 512-512S794.332554 0 512 0z m282.994215 353.406031L433.2544 715.145846a31.484062 31.484062 0 0 1-22.275938 9.231754h-0.4096a31.586462 31.586462 0 0 1-22.449231-9.814646L228.430769 546.327631a31.507692 31.507692 0 0 1 45.701908-43.386093l137.4208 144.785724L750.442338 308.854154a31.507692 31.507692 0 1 1 44.551877 44.551877z\",\n          \"fill\": \"\",\n          \"p-id\": \"3563\"\n        }\n      })]);\n      break;\n  }\n\n  return [dom, tip];\n}\n/**\n * create a scrollPanel\n *\n * @param {any} size\n * @param {any} context\n * @returns\n */\n\n\nfunction createPanel$1(context) {\n  var data = getPanelData$1(context);\n  return h(ScrollPanel, data, {\n    \"default\": function _default() {\n      return getPanelChildren$1(context);\n    }\n  });\n}\n\n// begin importing\n/**\n * create a scrollPanel\n *\n * @param {any} size\n * @param {any} vm\n * @returns\n */\n\nfunction createPanel$2(vm) {\n  if (vm.mode == 'native') {\n    return createPanel(vm);\n  } else if (vm.mode == 'slide') {\n    return createPanel$1(vm);\n  }\n}\n\n// detect content size change\nfunction installResizeDetection(element, callback) {\n  return injectObject(element, callback);\n}\n\nfunction injectObject(element, callback) {\n  if (element.hasResized) {\n    return;\n  }\n\n  var OBJECT_STYLE = 'display: block; position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: none; padding: 0; margin: 0; opacity: 0; z-index: -1000; pointer-events: none;'; // define a wrap due to ie's zIndex bug\n\n  var objWrap = document.createElement('div');\n  objWrap.style.cssText = OBJECT_STYLE;\n  var object = document.createElement('object');\n  object.style.cssText = OBJECT_STYLE;\n  object.type = 'text/html';\n  object.tabIndex = -1;\n\n  object.onload = function () {\n    eventCenter(object.contentDocument.defaultView, 'resize', callback);\n  }; // https://github.com/wnr/element-resize-detector/blob/aafe9f7ea11d1eebdab722c7c5b86634e734b9b8/src/detection-strategy/object.js#L159\n\n\n  if (!isIE()) {\n    object.data = 'about:blank';\n  }\n\n  objWrap.isResizeElm = true;\n  objWrap.appendChild(object);\n  element.appendChild(objWrap);\n\n  if (isIE()) {\n    object.data = 'about:blank';\n  }\n\n  return function destroy() {\n    if (object.contentDocument) {\n      eventCenter(object.contentDocument.defaultView, 'resize', callback, 'off');\n    }\n\n    element.removeChild(objWrap);\n    element.hasResized = false;\n  };\n}\n\nvar warn$3 = log.warn;\nvar slideApi = {\n  emits: ['refresh-activate', 'refresh-before-deactivate', 'refresh-before-deactivate-end', 'refresh-deactivate', 'load-activate', 'load-before-deactivate', 'load-before-deactivate-end', 'load-deactivate'],\n  methods: {\n    slideScrollTo: function slideScrollTo(x, y, speed, easing) {\n      var _this$getPosition = this.getPosition(),\n          scrollLeft = _this$getPosition.scrollLeft,\n          scrollTop = _this$getPosition.scrollTop;\n\n      x = getNumericValue(x || scrollLeft, this.scroller.__maxScrollLeft);\n      y = getNumericValue(y || scrollTop, this.scroller.__maxScrollTop);\n      this.scroller.scrollTo(x, y, speed > 0, undefined, false, speed, easing);\n    },\n    zoomBy: function zoomBy(factor, animate, originLeft, originTop, callback) {\n      if (!this.scroller) {\n        warn$3('zoomBy and zoomTo are only for slide mode!');\n        return;\n      }\n\n      this.scroller.zoomBy(factor, animate, originLeft, originTop, callback);\n    },\n    zoomTo: function zoomTo(level) {\n      var animate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n      var originLeft = arguments.length > 2 ? arguments[2] : undefined;\n      var originTop = arguments.length > 3 ? arguments[3] : undefined;\n      var callback = arguments.length > 4 ? arguments[4] : undefined;\n\n      if (!this.scroller) {\n        warn$3('zoomBy and zoomTo are only for slide mode!');\n        return;\n      }\n\n      this.scroller.zoomTo(level, animate, originLeft, originTop, callback);\n    },\n    getCurrentPage: function getCurrentPage() {\n      if (!this.scroller || !this.mergedOptions.vuescroll.paging) {\n        warn$3('getCurrentPage and goToPage are only for slide mode and paging is enble!');\n        return;\n      }\n\n      return this.scroller.getCurrentPage();\n    },\n    goToPage: function goToPage(dest) {\n      var animate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n      if (!this.scroller || !this.mergedOptions.vuescroll.paging) {\n        warn$3('getCurrentPage and goToPage are only for slide mode and paging is enble!');\n        return;\n      }\n\n      this.scroller.goToPage(dest, animate);\n    },\n    triggerRefreshOrLoad: function triggerRefreshOrLoad(type) {\n      if (!this.scroller) {\n        warn$3('You can only use triggerRefreshOrLoad in slide mode!');\n        return;\n      }\n\n      var isRefresh = this.mergedOptions.vuescroll.pullRefresh.enable;\n      var isLoad = this.mergedOptions.vuescroll.pushLoad.enable;\n\n      if (type == 'refresh' && !isRefresh) {\n        warn$3('refresh must be enabled!');\n        return;\n      } else if (type == 'load' && !isLoad) {\n        // eslint-disable-next-line\n        warn$3(\"load must be enabled and content's height > container's height!\");\n        return;\n      } else if (type !== 'refresh' && type !== 'load') {\n        warn$3('param must be one of load and refresh!');\n        return;\n      }\n      /* istanbul ignore if */\n\n\n      if (this.vuescroll.state[\"\".concat(type, \"Stage\")] == 'start') {\n        return;\n      }\n\n      this.scroller.triggerRefreshOrLoad(type);\n      return true;\n    },\n    getCurrentviewDomSlide: function getCurrentviewDomSlide() {\n      var parent = this.scrollPanelElm;\n      var domFragment = getCurrentViewportDom(parent, this.$el);\n      return domFragment;\n    }\n  }\n};\n\nvar api$1 = {\n  // mix slide and nitive modes apis.\n  mixins: [slideApi, nativeApi],\n  methods: {\n    // private api\n    internalScrollTo: function internalScrollTo(destX, destY, speed, easing) {\n      if (this.mode == 'native') {\n        this.nativeScrollTo(destX, destY, speed, easing);\n      } // for non-native we use scroller's scorllTo\n      else if (this.mode == 'slide') {\n          this.slideScrollTo(destX, destY, speed, easing);\n        }\n    },\n    stop: function stop() {\n      this.nativeStop();\n    },\n    pause: function pause() {\n      this.nativePause();\n    },\n    \"continue\": function _continue() {\n      this.nativeContinue();\n    },\n    getCurrentviewDom: function getCurrentviewDom() {\n      return this.mode == 'slide' ? this.getCurrentviewDomSlide() : this.getCurrentviewDomNative();\n    }\n  }\n};\n\n/*\n * Scroller\n * http://github.com/zynga/scroller\n *\n * Copyright 2011, Zynga Inc.\n * Licensed under the MIT License.\n * https://raw.github.com/zynga/scroller/master/MIT-LICENSE.txt\n *\n * Based on the work of: Unify Project (unify-project.org)\n * http://unify-project.org\n * Copyright 2011, Deutsche Telekom AG\n * License: MIT + Apache (V2)\n */\n\nvar time = Date.now || function () {\n  return +new Date();\n};\n\nvar desiredFrames = 60;\nvar millisecondsPerSecond = 1000;\nvar running = {};\nvar counter = 1;\nvar core = {\n  effect: {}\n};\nvar global = null;\n\nif (typeof window !== 'undefined') {\n  global = window;\n} else {\n  global = {};\n}\n\ncore.effect.Animate = {\n  /**\n   * A requestAnimationFrame wrapper / polyfill.\n   *\n   * @param callback {Function} The callback to be invoked before the next repaint.\n   * @param root {HTMLElement} The root element for the repaint\n   */\n  requestAnimationFrame: requestAnimationFrame(global),\n\n  /**\n   * Stops the given animation.\n   *\n   * @param id {Integer} Unique animation ID\n   * @return {Boolean} Whether the animation was stopped (aka, was running before)\n   */\n  stop: function stop(id) {\n    var cleared = running[id] != null;\n\n    if (cleared) {\n      running[id] = null;\n    }\n\n    return cleared;\n  },\n\n  /**\n   * Whether the given animation is still running.\n   *\n   * @param id {Integer} Unique animation ID\n   * @return {Boolean} Whether the animation is still running\n   */\n  isRunning: function isRunning(id) {\n    return running[id] != null;\n  },\n\n  /**\n   * Start the animation.\n   *\n   * @param stepCallback {Function} Pointer to function which is executed on every step.\n   *   Signature of the method should be `function(percent, now, virtual) { return continueWithAnimation; }`\n   * @param verifyCallback {Function} Executed before every animation step.\n   *   Signature of the method should be `function() { return continueWithAnimation; }`\n   * @param completedCallback {Function}\n   *   Signature of the method should be `function(droppedFrames, finishedAnimation) {}`\n   * @param duration {Integer} Milliseconds to run the animation\n   * @param easingMethod {Function} Pointer to easing function\n   *   Signature of the method should be `function(percent) { return modifiedValue; }`\n   * @param root {Element ? document.body} Render root, when available. Used for internal\n   *   usage of requestAnimationFrame.\n   * @return {Integer} Identifier of animation. Can be used to stop it any time.\n   */\n  start: function start(stepCallback, verifyCallback, completedCallback, duration, easingMethod, root) {\n    var start = time();\n    var lastFrame = start;\n    var percent = 0;\n    var dropCounter = 0;\n    var id = counter++;\n\n    if (!root) {\n      root = document.body;\n    } // Compacting running db automatically every few new animations\n\n\n    if (id % 20 === 0) {\n      var newRunning = {};\n\n      for (var usedId in running) {\n        newRunning[usedId] = true;\n      }\n\n      running = newRunning;\n    } // This is the internal step method which is called every few milliseconds\n\n\n    var step = function step(virtual) {\n      // Normalize virtual value\n      var render = virtual !== true; // Get current time\n\n      var now = time(); // Verification is executed before next animation step\n\n      if (!running[id] || verifyCallback && !verifyCallback(id)) {\n        running[id] = null;\n        completedCallback && completedCallback(desiredFrames - dropCounter / ((now - start) / millisecondsPerSecond), id, false);\n        return;\n      } // For the current rendering to apply let's update omitted steps in memory.\n      // This is important to bring internal state variables up-to-date with progress in time.\n\n\n      if (render) {\n        var droppedFrames = Math.round((now - lastFrame) / (millisecondsPerSecond / desiredFrames)) - 1;\n\n        for (var j = 0; j < Math.min(droppedFrames, 4); j++) {\n          step(true);\n          dropCounter++;\n        }\n      }\n\n      if (!running[id]) {\n        return;\n      } // Compute percent value\n\n\n      if (duration) {\n        percent = (now - start) / duration;\n\n        if (percent > 1) {\n          percent = 1;\n        }\n      } // Execute step callback, then...\n\n\n      var value = easingMethod ? easingMethod(percent) : percent;\n\n      if ((stepCallback(value, now, render) === false || percent === 1) && render) {\n        running[id] = null;\n        completedCallback && completedCallback(desiredFrames - dropCounter / ((now - start) / millisecondsPerSecond), id, percent === 1 || duration == null);\n      } else if (render) {\n        lastFrame = now;\n        core.effect.Animate.requestAnimationFrame(step, root);\n      }\n    }; // Mark as running\n\n\n    running[id] = true; // Init first step\n\n    core.effect.Animate.requestAnimationFrame(step, root); // Return unique animation ID\n\n    return id;\n  }\n};\n\n/*\n * Scroller\n * http://github.com/zynga/scroller\n *\n * modified by wangyi7099\n *\n * Copyright 2011, Zynga Inc.\n * Licensed under the MIT License.\n * https://raw.github.com/zynga/scroller/master/MIT-LICENSE.txt\n *\n * Based on the work of: Unify Project (unify-project.org)\n * http://unify-project.org\n * Copyright 2011, Deutsche Telekom AG\n * License: MIT + Apache (V2)\n */\nvar animatingMethod = null;\nvar noAnimatingMethod = null;\nfunction Scroller(callback, options) {\n  this.__callback = callback;\n  this.options = {\n    /** Enable scrolling on x-axis */\n    scrollingX: true,\n\n    /** Enable scrolling on y-axis */\n    scrollingY: true,\n\n    /** Enable animations for deceleration, snap back, zooming and scrolling */\n    animating: true,\n\n    /** duration for animations triggered by scrollTo/zoomTo */\n    animationDuration: 250,\n\n    /** Enable bouncing (content can be slowly moved outside and jumps back after releasing) */\n    bouncing: {\n      top: 100,\n      bottom: 100,\n      left: 100,\n      right: 100\n    },\n\n    /** Enable locking to the main axis if user moves only slightly on one of them at start */\n    locking: true,\n\n    /** Enable pagination mode (switching between full page content panes) */\n    paging: false,\n\n    /** Enable snapping of content to a configured pixel grid */\n    snapping: false,\n\n    /** Enable zooming of content via API, fingers and mouse wheel */\n    zooming: false,\n\n    /** Minimum zoom level */\n    minZoom: 0.5,\n\n    /** Maximum zoom level */\n    maxZoom: 3,\n\n    /** Multiply or decrease scrolling speed **/\n    speedMultiplier: 1,\n\n    /** Callback that is fired on the later of touch end or deceleration end,\n    provided that another scrolling action has not begun. Used to know\n    when to fade out a scrollbar. */\n    scrollingComplete: NOOP,\n    animatingEasing: 'easeOutCubic',\n    noAnimatingEasing: 'easeInOutCubic',\n\n    /** This configures the amount of change applied to deceleration when reaching boundaries  **/\n    penetrationDeceleration: 0.03,\n\n    /** This configures the amount of change applied to acceleration when reaching boundaries  **/\n    penetrationAcceleration: 0.08\n  };\n\n  for (var key in options) {\n    this.options[key] = options[key];\n  }\n\n  animatingMethod = createEasingFunction(this.options.animatingEasing, easingPattern);\n  noAnimatingMethod = createEasingFunction(this.options.noAnimatingEasing, easingPattern);\n}\nvar members = {\n  /*\n  ---------------------------------------------------------------------------\n  INTERNAL FIELDS :: STATUS\n  ---------------------------------------------------------------------------\n  */\n\n  /** {Boolean} Whether only a single finger is used in touch handling */\n  __isSingleTouch: false,\n\n  /** {Boolean} Whether a touch event sequence is in progress */\n  __isTracking: false,\n\n  /** {Boolean} Whether a deceleration animation went to completion. */\n  __didDecelerationComplete: false,\n\n  /**\n   * {Boolean} Whether a gesture zoom/rotate event is in progress. Activates when\n   * a gesturestart event happens. This has higher priority than dragging.\n   */\n  __isGesturing: false,\n\n  /**\n   * {Boolean} Whether the user has moved by such a distance that we have enabled\n   * dragging mode. Hint: It's only enabled after some pixels of movement to\n   * not interrupt with clicks etc.\n   */\n  __isDragging: false,\n\n  /**\n   * {Boolean} Not touching and dragging anymore, and smoothly animating the\n   * touch sequence using deceleration.\n   */\n  __isDecelerating: false,\n\n  /**\n   * {Boolean} Smoothly animating the currently configured change\n   */\n  __isAnimating: false,\n\n  /*\n  ---------------------------------------------------------------------------\n  INTERNAL FIELDS :: DIMENSIONS\n  ---------------------------------------------------------------------------\n  */\n\n  /** {Integer} Available outer left position (from document perspective) */\n  __clientLeft: 0,\n\n  /** {Integer} Available outer top position (from document perspective) */\n  __clientTop: 0,\n\n  /** {Integer} Available outer width */\n  __clientWidth: 0,\n\n  /** {Integer} Available outer height */\n  __clientHeight: 0,\n\n  /** {Integer} Outer width of content */\n  __contentWidth: 0,\n\n  /** {Integer} Outer height of content */\n  __contentHeight: 0,\n\n  /** {Integer} Snapping width for content */\n  __snapWidth: 100,\n\n  /** {Integer} Snapping height for content */\n  __snapHeight: 100,\n\n  /** {Integer} Height to assign to refresh area */\n  __refreshHeight: null,\n\n  /** {Integer} Height to assign to refresh area */\n  __loadHeight: null,\n\n  /** {Boolean} Whether the refresh process is enabled when the event is released now */\n  __refreshActive: false,\n\n  /** {Function} Callback to execute on activation. This is for signalling the user about a refresh is about to happen when he release */\n  __refreshActivate: null,\n  __refreshBeforeDeactivate: null,\n\n  /** {Function} Callback to execute on deactivation. This is for signalling the user about the refresh being cancelled */\n  __refreshDeactivate: null,\n\n  /** {Function} Callback to execute to start the actual refresh. Call {@link #refreshFinish} when done */\n  __refreshStart: null,\n  __loadActive: null,\n  __loadActivate: null,\n  __loadBeforeDeactivate: null,\n  __loadDeactivate: null,\n  __loadStart: null,\n\n  /** {Number} Zoom level */\n  __zoomLevel: 1,\n\n  /** {Number} Scroll position on x-axis */\n  __scrollLeft: 0,\n\n  /** {Number} Scroll position on y-axis */\n  __scrollTop: 0,\n\n  /** {Integer} Maximum allowed scroll position on x-axis */\n  __maxScrollLeft: 0,\n\n  /** {Integer} Maximum allowed scroll position on y-axis */\n  __maxScrollTop: 0,\n\n  /* {Number} Scheduled left position (final position when animating) */\n  __scheduledLeft: 0,\n\n  /* {Number} Scheduled top position (final position when animating) */\n  __scheduledTop: 0,\n\n  /* {Number} Scheduled zoom level (final scale when animating) */\n  __scheduledZoom: 0,\n\n  /**\n   * current page\n   */\n  __currentPageX: null,\n  __currentPageY: null,\n\n  /**\n   * total page\n   */\n  __totalXPage: null,\n  __totalYPage: null,\n\n  /*\n  ---------------------------------------------------------------------------\n  INTERNAL FIELDS :: LAST POSITIONS\n  ---------------------------------------------------------------------------\n  */\n\n  /** whether the scroller is disabled or not */\n  __disable: false,\n\n  /** {Number} Left position of finger at start */\n  __lastTouchLeft: null,\n\n  /** {Number} Top position of finger at start */\n  __lastTouchTop: null,\n\n  /** {Date} Timestamp of last move of finger. Used to limit tracking range for deceleration speed. */\n  __lastTouchMove: null,\n\n  /** {Array} List of positions, uses three indexes for each state: left, top, timestamp */\n  __positions: null,\n\n  /*\n  ---------------------------------------------------------------------------\n  INTERNAL FIELDS :: DECELERATION SUPPORT\n  ---------------------------------------------------------------------------\n  */\n\n  /** {Integer} Minimum left scroll position during deceleration */\n  __minDecelerationScrollLeft: null,\n\n  /** {Integer} Minimum top scroll position during deceleration */\n  __minDecelerationScrollTop: null,\n\n  /** {Integer} Maximum left scroll position during deceleration */\n  __maxDecelerationScrollLeft: null,\n\n  /** {Integer} Maximum top scroll position during deceleration */\n  __maxDecelerationScrollTop: null,\n\n  /** {Number} Current factor to modify horizontal scroll position with on every step */\n  __decelerationVelocityX: null,\n\n  /** {Number} Current factor to modify vertical scroll position with on every step */\n  __decelerationVelocityY: null,\n\n  /*\n  ---------------------------------------------------------------------------\n  PUBLIC API\n  ---------------------------------------------------------------------------\n  */\n\n  /**\n   * Configures the dimensions of the client (outer) and content (inner) elements.\n   * Requires the available space for the outer element and the outer size of the inner element.\n   * All values which are falsy (null or zero etc.) are ignored and the old value is kept.\n   *\n   * @param clientWidth {Integer ? null} Inner width of outer element\n   * @param clientHeight {Integer ? null} Inner height of outer element\n   * @param contentWidth {Integer ? null} Outer width of inner element\n   * @param contentHeight {Integer ? null} Outer height of inner element\n   */\n  setDimensions: function setDimensions(clientWidth, clientHeight, contentWidth, contentHeight, animate) {\n    var noScroll = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : false;\n    var self = this; // Only update values which are defined\n\n    if (clientWidth === +clientWidth) {\n      self.__clientWidth = clientWidth;\n    }\n\n    if (clientHeight === +clientHeight) {\n      self.__clientHeight = clientHeight;\n    }\n\n    if (contentWidth === +contentWidth) {\n      self.__contentWidth = contentWidth;\n    }\n\n    if (contentHeight === +contentHeight) {\n      self.__contentHeight = contentHeight;\n    } // Refresh maximums\n\n\n    self.__computeScrollMax();\n\n    if (!noScroll) {\n      // Refresh scroll position\n      self.scrollTo(self.__scrollLeft, self.__scrollTop, animate);\n    }\n  },\n\n  /**\n   * Sets the client coordinates in relation to the document.\n   *\n   * @param left {Integer ? 0} Left position of outer element\n   * @param top {Integer ? 0} Top position of outer element\n   */\n  setPosition: function setPosition(left, top) {\n    var self = this;\n    self.__clientLeft = left || 0;\n    self.__clientTop = top || 0;\n  },\n\n  /**\n   * Configures the snapping (when snapping is active)\n   *\n   * @param width {Integer} Snapping width\n   * @param height {Integer} Snapping height\n   */\n  setSnapSize: function setSnapSize(width, height) {\n    var self = this;\n    self.__snapWidth = width;\n    self.__snapHeight = height;\n  },\n\n  /**\n   * Activates pull-to-refresh. A special zone on the top of the list to start a list refresh whenever\n   * the user event is released during visibility of this zone. This was introduced by some apps on iOS like\n   * the official Twitter client.\n   *\n   * @param height {Integer} Height of pull-to-refresh zone on top of rendered list\n   * @param activateCallback {Function} Callback to execute on activation. This is for signalling the user about a refresh is about to happen when he release.\n   * @param deactivateCallback {Function} Callback to execute on deactivation. This is for signalling the user about the refresh being cancelled.\n   * @param startCallback {Function} Callback to execute to start the real async refresh action. Call {@link #finishPullToRefresh} after finish of refresh.\n   */\n  activatePullToRefresh: function activatePullToRefresh(height, _ref) {\n    var activateCallback = _ref.activateCallback,\n        deactivateCallback = _ref.deactivateCallback,\n        startCallback = _ref.startCallback,\n        beforeDeactivateCallback = _ref.beforeDeactivateCallback,\n        beforeDeactiveEnd = _ref.beforeDeactiveEnd;\n    var self = this;\n    self.__refreshHeight = height;\n    self.__refreshActivate = activateCallback;\n    self.__refreshBeforeDeactivate = beforeDeactivateCallback;\n    self.__refreshBeforeDeactiveEnd = beforeDeactiveEnd;\n    self.__refreshDeactivate = deactivateCallback;\n    self.__refreshStart = startCallback;\n  },\n  activatePushToLoad: function activatePushToLoad(height, _ref2) {\n    var activateCallback = _ref2.activateCallback,\n        deactivateCallback = _ref2.deactivateCallback,\n        startCallback = _ref2.startCallback,\n        beforeDeactivateCallback = _ref2.beforeDeactivateCallback,\n        beforeDeactiveEnd = _ref2.beforeDeactiveEnd;\n    var self = this;\n    self.__loadHeight = height;\n    self.__loadActivate = activateCallback;\n    self.__loadBeforeDeactivate = beforeDeactivateCallback;\n    self.__loadBeforeDeactiveEnd = beforeDeactiveEnd;\n    self.__loadDeactivate = deactivateCallback;\n    self.__loadStart = startCallback;\n  },\n\n  /**\n   * Starts pull-to-refresh manually.\n   */\n  triggerRefreshOrLoad: function triggerRefreshOrLoad() {\n    var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'refresh';\n    var wasDecelerating = this.__isDecelerating;\n\n    if (wasDecelerating) {\n      core.effect.Animate.stop(wasDecelerating);\n      this.__isDecelerating = false;\n    } // Use publish instead of scrollTo to allow scrolling to out of boundary position\n    // We don't need to normalize scrollLeft, zoomLevel, etc. here because we only y-scrolling when pull-to-refresh is enabled\n\n\n    if (type == 'refresh') {\n      if (this.__refreshActive || this.__refreshBeforeDeactiveStarted) return;\n\n      this.__publish(this.__scrollLeft, -this.__refreshHeight, this.__zoomLevel, true);\n\n      if (this.__refreshStart) {\n        this.__refreshStart();\n\n        this.__refreshActive = true;\n      }\n    } else if (type == 'load') {\n      if (this.__loadActive || this.__loadBeforeDeactiveStarted) return;\n\n      this.__publish(this.__scrollLeft, this.__maxScrollTop + this.__loadHeight, this.__zoomLevel, true);\n\n      if (this.__loadStart) {\n        this.__loadStart();\n\n        this.__loadActive = true;\n      }\n    }\n  },\n\n  /**\n   * Signalizes that pull-to-refresh is finished.\n   */\n  finishRefreshOrLoad: function finishRefreshOrLoad() {\n    var self = this;\n\n    if (self.__refreshActive) {\n      self.__refreshActive = false;\n\n      var endRefreshActive = function endRefreshActive() {\n        if (self.__refreshBeforeDeactiveEnd) {\n          self.__refreshBeforeDeactiveEnd();\n        }\n\n        self.__refreshBeforeDeactiveStarted = true;\n        self.scrollTo(self.__scrollLeft, self.__scrollTop, true);\n      };\n\n      if (self.__refreshBeforeDeactivate) {\n        self.__refreshBeforeDeactivate(endRefreshActive);\n      } else {\n        endRefreshActive();\n      }\n    }\n\n    if (self.__loadActive) {\n      self.__loadActive = false;\n\n      var endLoadActive = function endLoadActive() {\n        if (self.__loadBeforeDeactiveEnd) {\n          self.__loadBeforeDeactiveEnd();\n        }\n\n        self.__loadBeforeDeactiveStarted = true;\n        self.scrollTo(self.__scrollLeft, self.__scrollTop, true);\n      };\n\n      if (self.__loadBeforeDeactivate) {\n        self.__loadBeforeDeactivate(endLoadActive);\n      } else {\n        endLoadActive();\n      }\n    }\n  },\n\n  /**\n   * Returns the scroll position and zooming values\n   *\n   * @return {Map} `left` and `top` scroll position and `zoom` level\n   */\n  getValues: function getValues() {\n    var self = this;\n    return {\n      left: self.__scrollLeft,\n      top: self.__scrollTop,\n      zoom: self.__zoomLevel\n    };\n  },\n\n  /**\n   * Returns the maximum scroll values\n   *\n   * @return {Map} `left` and `top` maximum scroll values\n   */\n  getScrollMax: function getScrollMax() {\n    var self = this;\n    return {\n      left: self.__maxScrollLeft,\n      top: self.__maxScrollTop\n    };\n  },\n\n  /**\n   * Zooms to the given level. Supports optional animation. Zooms\n   * the center when no coordinates are given.\n   *\n   * @param level {Number} Level to zoom to\n   * @param animate {Boolean ? false} Whether to use animation\n   * @param originLeft {Number ? null} Zoom in at given left coordinate\n   * @param originTop {Number ? null} Zoom in at given top coordinate\n   * @param callback {Function ? null} A callback that gets fired when the zoom is complete.\n   */\n  zoomTo: function zoomTo(level, animate, originLeft, originTop, callback) {\n    var self = this;\n\n    if (!self.options.zooming) {\n      throw new Error('Zooming is not enabled!');\n    } // Add callback if exists\n\n\n    if (callback) {\n      self.__zoomComplete = callback;\n    } // Stop deceleration\n\n\n    if (self.__isDecelerating) {\n      core.effect.Animate.stop(self.__isDecelerating);\n      self.__isDecelerating = false;\n    }\n\n    var oldLevel = self.__zoomLevel; // Normalize input origin to center of viewport if not defined\n\n    if (originLeft == null) {\n      originLeft = self.__clientWidth / 2;\n    }\n\n    if (originTop == null) {\n      originTop = self.__clientHeight / 2;\n    } // Limit level according to configuration\n\n\n    level = Math.max(Math.min(level, self.options.maxZoom), self.options.minZoom); // Recompute maximum values while temporary tweaking maximum scroll ranges\n\n    self.__computeScrollMax(level); // Recompute left and top coordinates based on new zoom level\n\n\n    var left = (originLeft + self.__scrollLeft) * level / oldLevel - originLeft;\n    var top = (originTop + self.__scrollTop) * level / oldLevel - originTop; // Limit x-axis\n\n    if (left > self.__maxScrollLeft) {\n      left = self.__maxScrollLeft;\n    } else if (left < 0) {\n      left = 0;\n    } // Limit y-axis\n\n\n    if (top > self.__maxScrollTop) {\n      top = self.__maxScrollTop;\n    } else if (top < 0) {\n      top = 0;\n    } // Push values out\n\n\n    self.__publish(left, top, level, animate);\n  },\n\n  /**\n   * Zooms the content by the given factor.\n   *\n   * @param factor {Number} Zoom by given factor\n   * @param animate {Boolean ? false} Whether to use animation\n   * @param originLeft {Number ? 0} Zoom in at given left coordinate\n   * @param originTop {Number ? 0} Zoom in at given top coordinate\n   * @param callback {Function ? null} A callback that gets fired when the zoom is complete.\n   */\n  zoomBy: function zoomBy(factor, animate, originLeft, originTop, callback) {\n    var self = this;\n    self.zoomTo(self.__zoomLevel * factor, animate, originLeft, originTop, callback);\n  },\n\n  /**\n   * Scrolls to the given position. Respect limitations and snapping automatically.\n   *\n   * @param left {Number?null} Horizontal scroll position, keeps current if value is <code>null</code>\n   * @param top {Number?null} Vertical scroll position, keeps current if value is <code>null</code>\n   * @param animate {Boolean?false} Whether the scrolling should happen using an animation\n   * @param zoom {Number?null} Zoom level to go to\n   */\n  scrollTo: function scrollTo(left, top, animate, zoom, force, speed, easing) {\n    var self = this; // Stop deceleration\n\n    if (self.__isDecelerating) {\n      core.effect.Animate.stop(self.__isDecelerating);\n      self.__isDecelerating = false;\n    } // Correct coordinates based on new zoom level\n\n\n    if (zoom != null && zoom !== self.__zoomLevel) {\n      if (!self.options.zooming) {\n        throw new Error('Zooming is not enabled!');\n      }\n\n      left *= zoom;\n      top *= zoom; // Recompute maximum values while temporary tweaking maximum scroll ranges\n\n      self.__computeScrollMax(zoom);\n    } else {\n      // Keep zoom when not defined\n      zoom = self.__zoomLevel;\n    }\n\n    if (!self.options.scrollingX && !force) {\n      left = self.__scrollLeft;\n    } else {\n      if (self.options.paging) {\n        left = Math.round(left / self.__clientWidth) * self.__clientWidth;\n      } else if (self.options.snapping) {\n        left = Math.round(left / self.__snapWidth) * self.__snapWidth;\n      }\n    }\n\n    if (!self.options.scrollingY && !force) {\n      top = self.__scrollTop;\n    } else {\n      if (self.options.paging) {\n        top = Math.round(top / self.__clientHeight) * self.__clientHeight;\n      } else if (self.options.snapping) {\n        top = Math.round(top / self.__snapHeight) * self.__snapHeight;\n      }\n    }\n\n    if (!force) {\n      // Limit for allowed ranges\n      left = Math.max(Math.min(self.__maxScrollLeft, left), 0);\n      top = Math.max(Math.min(self.__maxScrollTop, top), 0);\n    } // Don't animate when no change detected, still call publish to make sure\n    // that rendered position is really in-sync with internal data\n\n\n    if (left === self.__scrollLeft && top === self.__scrollTop) {\n      animate = false;\n    } // Publish new values\n\n\n    if (!self.__isTracking) {\n      self.__publish(left, top, zoom, animate, speed, easing);\n    }\n  },\n\n  /**\n   * Scroll by the given offset\n   *\n   * @param left {Number ? 0} Scroll x-axis by given offset\n   * @param top {Number ? 0} Scroll x-axis by given offset\n   * @param animate {Boolean ? false} Whether to animate the given change\n   */\n  scrollBy: function scrollBy(left, top, animate) {\n    var self = this;\n    var startLeft = self.__isAnimating ? self.__scheduledLeft : self.__scrollLeft;\n    var startTop = self.__isAnimating ? self.__scheduledTop : self.__scrollTop;\n    self.scrollTo(startLeft + (left || 0), startTop + (top || 0), animate);\n  },\n  getCurrentPage: function getCurrentPage() {\n    this.__computePage();\n\n    return {\n      x: this.__currentPageX,\n      y: this.__currentPageY\n    };\n  },\n  goToPage: function goToPage(_ref3, animate) {\n    var x = _ref3.x,\n        y = _ref3.y;\n\n    if (isNaN(x)) {\n      x = 1;\n    }\n\n    if (isNaN(y)) {\n      y = 1;\n    }\n\n    this.scrollTo((x - 1) * this.__clientWidth, (y - 1) * this.__clientHeight, animate);\n  },\n\n  /*\n  ---------------------------------------------------------------------------\n  EVENT CALLBACKS\n  ---------------------------------------------------------------------------\n  */\n\n  /**\n   * Mouse wheel handler for zooming support\n   */\n  doMouseZoom: function doMouseZoom(wheelDelta, timeStamp, pageX, pageY) {\n    var self = this;\n    var change = wheelDelta > 0 ? 0.97 : 1.03;\n    return self.zoomTo(self.__zoomLevel * change, false, pageX - self.__clientLeft, pageY - self.__clientTop);\n  },\n\n  /**\n   * Touch start handler for scrolling support\n   */\n  doTouchStart: function doTouchStart(touches, timeStamp) {\n    // Array-like check is enough here\n    if (touches.length == null) {\n      throw new Error('Invalid touch list: ' + touches);\n    }\n\n    if (timeStamp instanceof Date) {\n      timeStamp = timeStamp.valueOf();\n    }\n\n    if (typeof timeStamp !== 'number') {\n      throw new Error('Invalid timestamp value: ' + timeStamp);\n    }\n\n    var self = this; // Reset interruptedAnimation flag\n\n    self.__interruptedAnimation = true; // Stop deceleration\n\n    if (self.__isDecelerating) {\n      core.effect.Animate.stop(self.__isDecelerating);\n      self.__isDecelerating = false;\n      self.__interruptedAnimation = true;\n    } // Stop animation\n\n\n    if (self.__isAnimating) {\n      core.effect.Animate.stop(self.__isAnimating);\n      self.__isAnimating = false;\n      self.__interruptedAnimation = true;\n    } // Use center point when dealing with two fingers\n\n\n    var currentTouchLeft, currentTouchTop;\n    var isSingleTouch = touches.length === 1;\n\n    if (isSingleTouch) {\n      currentTouchLeft = touches[0].pageX;\n      currentTouchTop = touches[0].pageY;\n    } else {\n      currentTouchLeft = Math.abs(touches[0].pageX + touches[1].pageX) / 2;\n      currentTouchTop = Math.abs(touches[0].pageY + touches[1].pageY) / 2;\n    } // Store initial positions\n\n\n    self.__initialTouchLeft = currentTouchLeft;\n    self.__initialTouchTop = currentTouchTop; // Store current zoom level\n\n    self.__zoomLevelStart = self.__zoomLevel; // Store initial touch positions\n\n    self.__lastTouchLeft = currentTouchLeft;\n    self.__lastTouchTop = currentTouchTop; // Store initial move time stamp\n\n    self.__lastTouchMove = timeStamp; // Reset initial scale\n\n    self.__lastScale = 1; // Reset locking flags\n\n    self.__enableScrollX = !isSingleTouch && self.options.scrollingX;\n    self.__enableScrollY = !isSingleTouch && self.options.scrollingY; // Reset tracking flag\n\n    self.__isTracking = true; // Reset deceleration complete flag\n\n    self.__didDecelerationComplete = false; // Dragging starts directly with two fingers, otherwise lazy with an offset\n\n    self.__isDragging = !isSingleTouch; // Some features are  in multi touch scenarios\n\n    self.__isSingleTouch = isSingleTouch; // Clearing data structure\n\n    self.__positions = [];\n  },\n\n  /**\n   * Touch move handler for scrolling support\n   */\n  doTouchMove: function doTouchMove(touches, timeStamp, scale) {\n    // Array-like check is enough here\n    if (touches.length == null) {\n      throw new Error('Invalid touch list: ' + touches);\n    }\n\n    if (timeStamp instanceof Date) {\n      timeStamp = timeStamp.valueOf();\n    }\n\n    if (typeof timeStamp !== 'number') {\n      throw new Error('Invalid timestamp value: ' + timeStamp);\n    }\n\n    var self = this; // Ignore event when tracking is not enabled (event might be outside of element)\n\n    if (!self.__isTracking) {\n      return;\n    }\n\n    var currentTouchLeft, currentTouchTop; // Compute move based around of center of fingers\n\n    if (touches.length === 2) {\n      currentTouchLeft = Math.abs(touches[0].pageX + touches[1].pageX) / 2;\n      currentTouchTop = Math.abs(touches[0].pageY + touches[1].pageY) / 2;\n    } else {\n      currentTouchLeft = touches[0].pageX;\n      currentTouchTop = touches[0].pageY;\n    }\n\n    var positions = self.__positions; // Are we already is dragging mode?\n\n    if (self.__isDragging) {\n      // Compute move distance\n      var moveX = currentTouchLeft - self.__lastTouchLeft;\n      var moveY = currentTouchTop - self.__lastTouchTop; // Read previous scroll position and zooming\n\n      var scrollLeft = self.__scrollLeft;\n      var scrollTop = self.__scrollTop;\n      var level = self.__zoomLevel; // Work with scaling\n\n      if (scale != null && self.options.zooming) {\n        var oldLevel = level; // Recompute level based on previous scale and new scale\n\n        level = level / self.__lastScale * scale; // Limit level according to configuration\n\n        level = Math.max(Math.min(level, self.options.maxZoom), self.options.minZoom); // Only do further compution when change happened\n\n        if (oldLevel !== level) {\n          // Compute relative event position to container\n          var currentTouchLeftRel = currentTouchLeft - self.__clientLeft;\n          var currentTouchTopRel = currentTouchTop - self.__clientTop; // Recompute left and top coordinates based on new zoom level\n\n          scrollLeft = (currentTouchLeftRel + scrollLeft) * level / oldLevel - currentTouchLeftRel;\n          scrollTop = (currentTouchTopRel + scrollTop) * level / oldLevel - currentTouchTopRel; // Recompute max scroll values\n\n          self.__computeScrollMax(level);\n        }\n      }\n\n      var bouncing = self.options.bouncing;\n\n      if (self.__enableScrollX) {\n        scrollLeft -= moveX * this.options.speedMultiplier;\n        var maxScrollLeft = self.__maxScrollLeft;\n\n        if (scrollLeft > maxScrollLeft || scrollLeft < 0) {\n          scrollLeft += moveX / 2 * this.options.speedMultiplier; // fix scrollLeft\n\n          scrollLeft = Math.min(Math.max(-bouncing.left, scrollLeft), maxScrollLeft + bouncing.right);\n        }\n      } // Compute new vertical scroll position\n\n\n      if (self.__enableScrollY) {\n        scrollTop -= moveY * this.options.speedMultiplier;\n        var maxScrollTop = self.__maxScrollTop;\n\n        if (scrollTop > maxScrollTop || scrollTop < 0) {\n          scrollTop += moveY / 2 * this.options.speedMultiplier; // fix scrollTop\n\n          scrollTop = Math.min(Math.max(-bouncing.top, scrollTop), maxScrollTop + bouncing.bottom); // Trigger pull to refresh or push to load\n\n          if (!self.__enableScrollX && (self.__refreshHeight != null || self.__loadHeight != null)) {\n            if (!self.__refreshActive && scrollTop <= -self.__refreshHeight) {\n              self.__refreshActive = true;\n\n              if (self.__refreshActivate) {\n                self.__refreshActivate();\n              }\n            } else if (self.__refreshActive && scrollTop > -self.__refreshHeight) {\n              self.__refreshActive = false;\n\n              if (self.__refreshDeactivate) {\n                self.__refreshDeactivate();\n              }\n            } // handle for push-load\n            else if (!self.__loadActive && scrollTop >= self.__maxScrollTop + self.__loadHeight && self.__loadHeight > 0) {\n                self.__loadActive = true;\n\n                if (self.__loadActivate) {\n                  self.__loadActivate();\n                }\n              } else if (self.__loadActive && scrollTop < self.__maxScrollTop + self.__loadHeight) {\n                self.__loadActive = false;\n\n                if (self.__loadDeactivate) {\n                  self.__loadDeactivate();\n                }\n              }\n          }\n        }\n      } // Keep list from growing infinitely (holding min 10, max 20 measure points)\n\n\n      if (positions.length > 60) {\n        positions.splice(0, 30);\n      } // Track scroll movement for decleration\n\n\n      positions.push(scrollLeft, scrollTop, timeStamp); // Sync scroll position\n\n      self.__publish(scrollLeft, scrollTop, level); // Otherwise figure out whether we are switching into dragging mode now.\n\n    } else {\n      var minimumTrackingForScroll = self.options.locking ? 3 : 0;\n      var minimumTrackingForDrag = 5;\n      var distanceX = Math.abs(currentTouchLeft - self.__initialTouchLeft);\n      var distanceY = Math.abs(currentTouchTop - self.__initialTouchTop);\n      self.__enableScrollX = self.options.scrollingX && distanceX >= minimumTrackingForScroll;\n      self.__enableScrollY = self.options.scrollingY && distanceY >= minimumTrackingForScroll;\n      positions.push(self.__scrollLeft, self.__scrollTop, timeStamp);\n      self.__isDragging = (self.__enableScrollX || self.__enableScrollY) && (distanceX >= minimumTrackingForDrag || distanceY >= minimumTrackingForDrag);\n\n      if (self.__isDragging) {\n        self.__interruptedAnimation = false;\n      }\n    } // Update last touch positions and time stamp for next event\n\n\n    self.__lastTouchLeft = currentTouchLeft;\n    self.__lastTouchTop = currentTouchTop;\n    self.__lastTouchMove = timeStamp;\n    self.__lastScale = scale;\n  },\n\n  /**\n   * Touch end handler for scrolling support\n   */\n  doTouchEnd: function doTouchEnd(timeStamp) {\n    if (timeStamp instanceof Date) {\n      timeStamp = timeStamp.valueOf();\n    }\n\n    if (typeof timeStamp !== 'number') {\n      throw new Error('Invalid timestamp value: ' + timeStamp);\n    }\n\n    var self = this; // Ignore event when tracking is not enabled (no touchstart event on element)\n    // This is required as this listener ('touchmove') sits on the document and not on the element itself.\n\n    if (!self.__isTracking) {\n      return;\n    } // Not touching anymore (when two finger hit the screen there are two touch end events)\n\n\n    self.__isTracking = false; // Be sure to reset the dragging flag now. Here we also detect whether\n    // the finger has moved fast enough to switch into a deceleration animation.\n\n    if (self.__isDragging) {\n      // Reset dragging flag\n      self.__isDragging = false; // Start deceleration\n      // Verify that the last move detected was in some relevant time frame\n\n      if (self.__isSingleTouch && self.options.animating && timeStamp - self.__lastTouchMove <= 100) {\n        // Then figure out what the scroll position was about 100ms ago\n        var positions = self.__positions;\n        var endPos = positions.length - 1;\n        var startPos = endPos; // Move pointer to position measured 100ms ago\n\n        for (var i = endPos; i > 0 && positions[i] > self.__lastTouchMove - 100; i -= 3) {\n          startPos = i;\n        } // If start and stop position is identical in a 100ms timeframe,\n        // we cannot compute any useful deceleration.\n\n\n        if (startPos !== endPos) {\n          // Compute relative movement between these two points\n          var timeOffset = positions[endPos] - positions[startPos];\n          var movedLeft = self.__scrollLeft - positions[startPos - 2];\n          var movedTop = self.__scrollTop - positions[startPos - 1]; // Based on 50ms compute the movement to apply for each render step\n\n          self.__decelerationVelocityX = movedLeft / timeOffset * (1000 / 60);\n          self.__decelerationVelocityY = movedTop / timeOffset * (1000 / 60); // How much velocity is required to start the deceleration\n\n          var minVelocityToStartDeceleration = self.options.paging || self.options.snapping ? 4 : 1; // Verify that we have enough velocity to start deceleration\n\n          if (Math.abs(self.__decelerationVelocityX) > minVelocityToStartDeceleration || Math.abs(self.__decelerationVelocityY) > minVelocityToStartDeceleration) {\n            // Deactivate pull-to-refresh when decelerating\n            if (!self.__refreshActive && !self.__loadActive) {\n              self.__startDeceleration(timeStamp);\n            }\n          } else {\n            self.__scrollComplete();\n          }\n        } else {\n          self.__scrollComplete();\n        }\n      } else if (timeStamp - self.__lastTouchMove > 100) {\n        self.__scrollComplete();\n      }\n    } // If this was a slower move it is per default non decelerated, but this\n    // still means that we want snap back to the bounds which is done here.\n    // This is placed outside the condition above to improve edge case stability\n    // e.g. touchend fired without enabled dragging. This should normally do not\n    // have modified the scroll positions or even showed the scrollbars though.\n\n\n    if (!self.__isDecelerating) {\n      if (self.__refreshActive && self.__refreshStart) {\n        // Use publish instead of scrollTo to allow scrolling to out of boundary position\n        // We don't need to normalize scrollLeft, zoomLevel, etc. here because we only y-scrolling when pull-to-refresh is enabled\n        self.__publish(self.__scrollLeft, -self.__refreshHeight, self.__zoomLevel, true);\n\n        if (self.__refreshStart) {\n          self.__refreshStart();\n        }\n      } else if (self.__loadActive && self.__loadStart) {\n        // Use publish instead of scrollTo to allow scrolling to out of boundary position\n        // We don't need to normalize scrollLeft, zoomLevel, etc. here because we only y-scrolling when pull-to-refresh is enabled\n        self.__publish(self.__scrollLeft, self.__maxScrollTop + self.__loadHeight, self.__zoomLevel, true);\n\n        if (self.__loadStart) {\n          self.__loadStart();\n        }\n      } else {\n        if (self.__interruptedAnimation || self.__isDragging) {\n          self.__scrollComplete();\n        }\n\n        self.scrollTo(self.__scrollLeft, self.__scrollTop, true, self.__zoomLevel); // Directly signalize deactivation (nothing todo on refresh?)\n\n        if (self.__refreshActive) {\n          self.__refreshActive = false;\n\n          if (self.__refreshDeactivate) {\n            self.__refreshDeactivate();\n          }\n        } else if (self.__loadActive) {\n          self.__loadActive = false;\n\n          if (self.__loadDeactivate) {\n            self.__loadDeactivate();\n          }\n        }\n      }\n    } // Fully cleanup list\n\n\n    self.__positions.length = 0;\n  },\n\n  /** Handle for scroll/publish */\n  onScroll: NOOP,\n  stop: function stop() {\n    var self = this;\n    self.__disable = true;\n  },\n  start: function start() {\n    var self = this;\n    self.__disable = true;\n  },\n\n  /*\n  ---------------------------------------------------------------------------\n  PRIVATE API\n  ---------------------------------------------------------------------------\n  */\n\n  /**\n   * Applies the scroll position to the content element\n   *\n   * @param left {Number} Left scroll position\n   * @param top {Number} Top scroll position\n   * @param animate {Boolean?false} Whether animation should be used to move to the new coordinates\n   */\n  __publish: function __publish(left, top, zoom, animate, speed, easing) {\n    var self = this;\n\n    if (self.__disable) {\n      return;\n    }\n\n    if (isNaN(left)) {\n      left = this.__scrollLeft;\n    }\n\n    if (isNaN(top)) {\n      top = this.__scrollTop;\n    } // Remember whether we had an animation, then we try to continue based on the current \"drive\" of the animation\n\n\n    var wasAnimating = self.__isAnimating;\n\n    if (wasAnimating) {\n      core.effect.Animate.stop(wasAnimating);\n      self.__isAnimating = false;\n    }\n\n    if (animate && (self.options.animating || speed)) {\n      // Keep scheduled positions for scrollBy/zoomBy functionality\n      self.__scheduledLeft = left;\n      self.__scheduledTop = top;\n      self.__scheduledZoom = zoom;\n      var oldLeft = self.__scrollLeft;\n      var oldTop = self.__scrollTop;\n      var oldZoom = self.__zoomLevel;\n      var diffLeft = left - oldLeft;\n      var diffTop = top - oldTop;\n      var diffZoom = zoom - oldZoom;\n\n      var step = function step(percent, now, render) {\n        if (render) {\n          self.__scrollLeft = oldLeft + diffLeft * percent;\n          self.__scrollTop = oldTop + diffTop * percent;\n          self.__zoomLevel = oldZoom + diffZoom * percent; // Push values out\n\n          if (self.__callback) {\n            self.__callback(self.__scrollLeft, self.__scrollTop, self.__zoomLevel);\n\n            self.onScroll();\n          }\n        }\n      };\n\n      var verify = function verify(id) {\n        return self.__isAnimating === id;\n      };\n\n      var completed = function completed(renderedFramesPerSecond, animationId, wasFinished) {\n        if (animationId === self.__isAnimating) {\n          self.__isAnimating = false;\n        }\n\n        if (self.__didDecelerationComplete || wasFinished) {\n          self.__scrollComplete();\n        }\n\n        if (self.options.zooming) {\n          self.__computeScrollMax();\n\n          if (self.__zoomComplete) {\n            self.__zoomComplete();\n\n            self.__zoomComplete = null;\n          }\n        }\n\n        if (self.__refreshBeforeDeactiveStarted) {\n          self.__refreshBeforeDeactiveStarted = false;\n          if (self.__refreshDeactivate) self.__refreshDeactivate();\n        }\n\n        if (self.__loadBeforeDeactiveStarted) {\n          self.__loadBeforeDeactiveStarted = false;\n          if (self.__loadDeactivate) self.__loadDeactivate();\n        }\n      };\n\n      var easingFunction = animatingMethod;\n\n      if (easing) {\n        easingFunction = createEasingFunction(easing, easingPattern);\n      } // When continuing based on previous animation we choose an ease-out animation instead of ease-in-out\n\n\n      self.__isAnimating = core.effect.Animate.start(step, verify, completed, speed || self.options.animationDuration, wasAnimating ? easingFunction : noAnimatingMethod);\n    } else {\n      self.__scheduledLeft = self.__scrollLeft = left;\n      self.__scheduledTop = self.__scrollTop = top;\n      self.__scheduledZoom = self.__zoomLevel = zoom; // Push values out\n\n      if (self.__callback) {\n        self.__callback(left, top, zoom);\n\n        self.onScroll();\n      } // Fix max scroll ranges\n\n\n      if (self.options.zooming) {\n        self.__computeScrollMax();\n\n        if (self.__zoomComplete) {\n          self.__zoomComplete();\n\n          self.__zoomComplete = null;\n        }\n      }\n\n      if (self.__refreshBeforeDeactiveStarted) {\n        self.__refreshBeforeDeactiveStarted = false;\n        if (self.__refreshDeactivate) self.__refreshDeactivate();\n      }\n\n      if (self.__loadBeforeDeactiveStarted) {\n        self.__loadBeforeDeactiveStarted = false;\n        if (self.__loadDeactivate) self.__loadDeactivate();\n      }\n    }\n  },\n\n  /**\n   * Recomputes scroll minimum values based on client dimensions and content dimensions.\n   */\n  __computeScrollMax: function __computeScrollMax(zoomLevel) {\n    var self = this;\n\n    if (zoomLevel == null) {\n      zoomLevel = self.__zoomLevel;\n    }\n\n    self.__maxScrollLeft = Math.max(self.__contentWidth * zoomLevel - self.__clientWidth, 0);\n    self.__maxScrollTop = Math.max(self.__contentHeight * zoomLevel - self.__clientHeight, 0);\n  },\n\n  /** compute current page total page */\n  __computePage: function __computePage() {\n    var self = this;\n    var clientWidth = self.__clientWidth;\n    var clientHeight = self.__clientHeight;\n    var left = self.__scrollLeft;\n    var top = self.__scrollTop;\n    self.__totalXPage = Math.ceil(self.__contentWidth / clientWidth);\n    self.__currentPageX = Math.ceil(left / clientWidth + 1);\n    self.__totalYPage = Math.ceil(self.__contentHeight / clientHeight);\n    self.__currentPageY = Math.ceil(top / clientHeight + 1);\n  },\n\n  /** complete scroll*/\n  __scrollComplete: function __scrollComplete() {\n    var self = this;\n    self.options.scrollingComplete();\n  },\n\n  /*\n  ---------------------------------------------------------------------------\n  ANIMATION (DECELERATION) SUPPORT\n  ---------------------------------------------------------------------------\n  */\n\n  /**\n   * Called when a touch sequence end and the speed of the finger was high enough\n   * to switch into deceleration mode.\n   */\n  __startDeceleration: function __startDeceleration() {\n    var self = this;\n\n    if (self.options.paging) {\n      var scrollLeft = Math.max(Math.min(self.__scrollLeft, self.__maxScrollLeft), 0);\n      var scrollTop = Math.max(Math.min(self.__scrollTop, self.__maxScrollTop), 0);\n      var clientWidth = self.__clientWidth;\n      var clientHeight = self.__clientHeight; // We limit deceleration not to the min/max values of the allowed range, but to the size of the visible client area.\n      // Each page should have exactly the size of the client area.\n\n      self.__minDecelerationScrollLeft = Math.floor(scrollLeft / clientWidth) * clientWidth;\n      self.__minDecelerationScrollTop = Math.floor(scrollTop / clientHeight) * clientHeight;\n      self.__maxDecelerationScrollLeft = Math.ceil(scrollLeft / clientWidth) * clientWidth;\n      self.__maxDecelerationScrollTop = Math.ceil(scrollTop / clientHeight) * clientHeight;\n    } else {\n      self.__minDecelerationScrollLeft = 0;\n      self.__minDecelerationScrollTop = 0;\n      self.__maxDecelerationScrollLeft = self.__maxScrollLeft;\n      self.__maxDecelerationScrollTop = self.__maxScrollTop;\n    } // Wrap class method\n\n\n    var step = function step(percent, now, render) {\n      self.__stepThroughDeceleration(render);\n    }; // How much velocity is required to keep the deceleration running\n\n\n    var minVelocityToKeepDecelerating = self.options.snapping ? 4 : 0.001; // Detect whether it's still worth to continue animating steps\n    // If we are already slow enough to not being user perceivable anymore, we stop the whole process here.\n\n    var verify = function verify() {\n      var shouldContinue = Math.abs(self.__decelerationVelocityX) >= minVelocityToKeepDecelerating || Math.abs(self.__decelerationVelocityY) >= minVelocityToKeepDecelerating;\n\n      if (!shouldContinue) {\n        self.__didDecelerationComplete = true;\n      }\n\n      return shouldContinue;\n    };\n\n    var completed = function completed() {\n      if (!self.__isDecelerating) {\n        return;\n      }\n\n      self.__isDecelerating = false;\n\n      if (self.__didDecelerationComplete) {\n        self.__scrollComplete();\n      } // Animate to grid when snapping is active, otherwise just fix out-of-boundary positions\n\n\n      self.scrollTo(self.__scrollLeft, self.__scrollTop, self.options.snapping);\n    }; // Start animation and switch on flag\n\n\n    self.__isDecelerating = core.effect.Animate.start(step, verify, completed);\n  },\n\n  /**\n   * Called on every step of the animation\n   *\n   * @param inMemory {Boolean?false} Whether to not render the current step, but keep it in memory only. Used internally only!\n   */\n  __stepThroughDeceleration: function __stepThroughDeceleration(render) {\n    var self = this;\n    var bouncing = self.options.bouncing;\n    var minLeft = self.__minDecelerationScrollLeft;\n    var maxLeft = self.__maxDecelerationScrollLeft;\n    var minTop = self.__minDecelerationScrollTop;\n    var maxTop = self.__maxDecelerationScrollTop; // Add deceleration to scroll position\n\n    var scrollLeft = self.__scrollLeft + self.__decelerationVelocityX;\n    var scrollTop = self.__scrollTop + self.__decelerationVelocityY;\n    var bounceX = scrollLeft < minLeft || scrollLeft > maxLeft;\n    var bounceY = scrollTop < minTop || scrollTop > maxTop; // fix scrollLeft and scrollTop\n\n    var fixedScrollLeft = Math.min(Math.max(minLeft - bouncing.left, scrollLeft), maxLeft + bouncing.right);\n    var fixedScrollTop = Math.min(Math.max(minTop - bouncing.top, scrollTop), maxTop + bouncing.bottom); //\n    // UPDATE SCROLL POSITION\n    //\n\n    if (render) {\n      self.__publish(fixedScrollLeft, fixedScrollTop, self.__zoomLevel);\n    } else {\n      self.__scrollLeft = scrollLeft;\n      self.__scrollTop = scrollTop;\n    } //\n    // SLOW DOWN\n    //\n    // Slow down velocity on every iteration\n\n\n    if (!self.options.paging) {\n      // This is the factor applied to every iteration of the animation\n      // to slow down the process. This should emulate natural behavior where\n      // objects slow down when the initiator of the movement is removed\n      var frictionFactor = 0.95;\n      self.__decelerationVelocityX *= frictionFactor;\n      self.__decelerationVelocityY *= frictionFactor;\n    } //\n    // BOUNCING SUPPORT\n    //\n\n\n    var scrollOutsideX = 0;\n    var scrollOutsideY = 0; // This configures the amount of change applied to deceleration/acceleration when reaching boundaries\n\n    var penetrationDeceleration = self.options.penetrationDeceleration;\n    var penetrationAcceleration = self.options.penetrationAcceleration;\n\n    if (bounceX) {\n      // Check limits\n      if (scrollLeft < self.__minDecelerationScrollLeft) {\n        scrollOutsideX = self.__minDecelerationScrollLeft - scrollLeft;\n      } else if (scrollLeft > self.__maxDecelerationScrollLeft) {\n        scrollOutsideX = self.__maxDecelerationScrollLeft - scrollLeft;\n      }\n    }\n\n    if (bounceY) {\n      if (scrollTop < self.__minDecelerationScrollTop) {\n        scrollOutsideY = self.__minDecelerationScrollTop - scrollTop;\n      } else if (scrollTop > self.__maxDecelerationScrollTop) {\n        scrollOutsideY = self.__maxDecelerationScrollTop - scrollTop;\n      }\n    }\n\n    if (scrollOutsideX !== 0) {\n      if (scrollOutsideX * self.__decelerationVelocityX <= 0) {\n        self.__decelerationVelocityX += scrollOutsideX * penetrationDeceleration;\n\n        if (scrollOutsideX < 0 && -scrollOutsideX >= bouncing.right && self.__decelerationVelocityX > 0) {\n          self.__decelerationVelocityX = -bouncing.right / 2;\n        }\n\n        if (scrollOutsideX > 0 && scrollOutsideX >= bouncing.left && self.__decelerationVelocityX < 0) {\n          self.__decelerationVelocityX = bouncing.left / 2;\n        }\n      } else {\n        self.__decelerationVelocityX = scrollOutsideX * penetrationAcceleration;\n      }\n    }\n\n    if (scrollOutsideY !== 0) {\n      if (scrollOutsideY * self.__decelerationVelocityY <= 0) {\n        self.__decelerationVelocityY += scrollOutsideY * penetrationDeceleration;\n\n        if (scrollOutsideY < 0 && -scrollOutsideY >= bouncing.bottom && self.__decelerationVelocityY > 0) {\n          self.__decelerationVelocityY = -bouncing.bottom / 2;\n        }\n\n        if (scrollOutsideY > 0 && scrollOutsideY >= bouncing.top && self.__decelerationVelocityY < 0) {\n          self.__decelerationVelocityY = bouncing.top / 2;\n        }\n      } else {\n        self.__decelerationVelocityY = scrollOutsideY * penetrationAcceleration / 2;\n      }\n    }\n  }\n}; // Copy over members to prototype\n\nfor (var key in members) {\n  Scroller.prototype[key] = members[key];\n}\n\n/* DOM-based rendering (Uses 3D when available, falls back on margin when transform not available) */\n\nfunction render(content, global, suffix, type) {\n  if (type == 'position') {\n    return function (left, top) {\n      content.style.left = -left + 'px';\n      content.style.top = -top + 'px';\n    };\n  }\n\n  var vendorPrefix = getPrefix(global);\n  var helperElem = document.createElement('div');\n  var undef;\n  var perspectiveProperty = vendorPrefix + 'Perspective';\n  var transformProperty = 'transform'; //vendorPrefix + 'Transform';\n\n  if (helperElem.style[perspectiveProperty] !== undef) {\n    return function (left, top, zoom) {\n      content.style[transformProperty] = 'translate3d(' + -left + suffix + ',' + -top + suffix + ',0) scale(' + zoom + ')';\n    };\n  } else if (helperElem.style[transformProperty] !== undef) {\n    return function (left, top, zoom) {\n      content.style[transformProperty] = 'translate(' + -left + suffix + ',' + -top + suffix + ') scale(' + zoom + ')';\n    };\n  }\n}\n\nvar touch = new TouchManager();\nfunction listenContainer(container, scroller, eventCallback, zooming, preventDefault, preventDefaultOnMove) {\n  var destroy = null;\n  var mousedown = false;\n  var touchObj = touch.getTouchObject();\n\n  function touchstart(e) {\n    var event = touch.getEventObject(e); // Don't react if initial down happens on a form element\n\n    if (event[0] && event[0].target && event[0].target.tagName.match(/input|textarea|select/i) || scroller.__disable) {\n      return;\n    }\n\n    eventCallback('mousedown');\n    mousedown = true;\n    scroller.doTouchStart(event, e.timeStamp);\n\n    if (preventDefault) {\n      e.preventDefault();\n    }\n\n    e.stopPropagation(); // here , we want to manully prevent default, so we\n    // set passive to false\n    // see https://developer.mozilla.org/zh-CN/docs/Web/API/EventTarget/addEventListener\n\n    document.addEventListener(touchObj._touchmove, touchmove, {\n      passive: false\n    });\n  }\n\n  function touchmove(e) {\n    if (scroller.__disable || !mousedown) return;\n    var event = touch.getEventObject(e);\n    eventCallback('mousemove');\n    scroller.doTouchMove(event, e.timeStamp, e.scale);\n\n    if (preventDefaultOnMove) {\n      e.preventDefault();\n    }\n  }\n\n  function touchend(e) {\n    eventCallback('mouseup');\n    mousedown = false;\n    scroller.doTouchEnd(e.timeStamp);\n    document.removeEventListener(touchObj._touchmove, touchmove);\n  }\n\n  function touchcancel(e) {\n    scroller.doTouchEnd(e.timeStamp);\n  }\n\n  function zoomHandle(e) {\n    scroller.doMouseZoom(e.detail ? e.detail * -120 : e.wheelDelta, e.timeStamp, e.pageX, e.pageY);\n  }\n\n  container.addEventListener(touchObj._touchstart, touchstart, false);\n  document.addEventListener(touchObj._touchend, touchend, false);\n  document.addEventListener(touchObj._touchcancel, touchcancel, false);\n\n  if (zooming && !touch.isTouch) {\n    container.addEventListener(navigator.userAgent.indexOf('Firefox') > -1 ? 'DOMMouseScroll' : 'mousewheel', zoomHandle, false);\n  }\n\n  destroy = function destroy() {\n    container.removeEventListener(touchObj._touchstart, touchstart, false);\n    document.removeEventListener(touchObj._touchend, touchend, false);\n    document.removeEventListener(touchObj._touchcancel, touchcancel, false);\n    container.removeEventListener(navigator.userAgent.indexOf('Firefox') > -1 ? 'DOMMouseScroll' : 'mousewheel', zoomHandle, false);\n  }; // handle __publish event\n\n\n  scroller.onScroll = function () {\n    eventCallback('onscroll');\n  };\n\n  return destroy;\n}\n\ncreateSlideModeStyle();\n/**\n * @description refresh and load callback\n */\n\nfunction createStateCallbacks(type, stageType, vm, tipDom) {\n  var listeners = vm.$.vnode.props;\n\n  var activateCallback = function activateCallback() {\n    vm.vuescroll.state[stageType] = 'active';\n    vm.$emit(type + '-activate', vm, tipDom);\n  };\n\n  var deactivateCallback = function deactivateCallback() {\n    vm.vuescroll.state[stageType] = 'deactive';\n    vm.$emit(type + '-deactivate', vm, tipDom);\n  };\n\n  var beforeDeactiveEnd = function beforeDeactiveEnd() {\n    vm.vuescroll.state[stageType] = 'beforeDeactiveEnd';\n    vm.$emit(type + '-before-deactivate-end', vm, tipDom);\n  };\n\n  var startCallback = function startCallback() {\n    vm.vuescroll.state[stageType] = 'start';\n    setTimeout(function () {\n      vm.scroller.finishRefreshOrLoad();\n    }, 2000); // Default start stage duration\n  };\n\n  var beforeDeactivateCallback;\n\n  function hasListens(event) {\n    var listenrWholeName = \"on\".concat(upperFirstChar(type)).concat(upperFirstChar(event));\n    return !!listeners[listenrWholeName];\n  }\n  /* istanbul ignore if */\n\n\n  if (hasListens('beforeDeactivate')) {\n    beforeDeactivateCallback = function beforeDeactivateCallback(done) {\n      vm.vuescroll.state[stageType] = 'beforeDeactive';\n      vm.$emit(type + '-before-deactivate', vm, tipDom, done.bind(vm.scroller));\n    };\n  }\n  /* istanbul ignore if */\n\n\n  if (hasListens('start')) {\n    startCallback = function startCallback() {\n      vm.vuescroll.state[stageType] = 'start';\n      vm.$emit(type + '-start', vm, tipDom, vm.scroller.finishRefreshOrLoad.bind(vm.scroller));\n    };\n  }\n\n  return {\n    activateCallback: activateCallback,\n    deactivateCallback: deactivateCallback,\n    startCallback: startCallback,\n    beforeDeactivateCallback: beforeDeactivateCallback,\n    beforeDeactiveEnd: beforeDeactiveEnd\n  };\n}\n\nvar slideMix = {\n  mounted: function mounted() {\n    this.vsMounted = true;\n  },\n  computed: {\n    pullRefreshTip: function pullRefreshTip() {\n      return this.mergedOptions.vuescroll.pullRefresh.tips[this.vuescroll.state.refreshStage];\n    },\n    pushLoadTip: function pushLoadTip() {\n      return this.mergedOptions.vuescroll.pushLoad.tips[this.vuescroll.state.loadStage];\n    },\n    refreshLoad: function refreshLoad() {\n      return this.mergedOptions.vuescroll.pullRefresh.enable || this.mergedOptions.vuescroll.pushLoad.enable;\n    },\n    refrehDomVisiable: function refrehDomVisiable() {\n      return this.vsMounted && this.outTheTopBoundary;\n    },\n    loadDomVisiable: function loadDomVisiable() {\n      return this.vsMounted && this.outTheBottomBoundary;\n    }\n  },\n  data: function data() {\n    return {\n      vuescroll: {\n        state: {\n          /** Default tips of refresh and load */\n          refreshStage: 'deactive',\n          loadStage: 'deactive'\n        }\n      },\n      vsMounted: false,\n      outTheTopBoundary: false,\n      outTheBottomBoundary: false\n    };\n  },\n  methods: {\n    // Update:\n    // 1. update height/width\n    // 2. update refresh or load\n    updateScroller: function updateScroller() {\n      this.updateDimesion();\n      this.registryRefreshLoad();\n    },\n    updateDimesion: function updateDimesion() {\n      var clientWidth = this.$el.clientWidth;\n      var clientHeight = this.$el.clientHeight;\n      var contentWidth = this.scrollPanelElm.scrollWidth;\n      var contentHeight = this.scrollPanelElm.scrollHeight;\n      var refreshHeight = 0;\n      var loadHeight = 0; // If the refresh option is true,let's  give a \"margin-top\" style to\n      // the refresh-tip dom. let it to be invisible when doesn't trigger\n      // refresh.\n\n      if (this.mergedOptions.vuescroll.pullRefresh.enable) {\n        if (this.vsMounted) {\n          var refreshDom = this.$refs[__REFRESH_DOM_NAME].elm || this.$refs[__REFRESH_DOM_NAME];\n          refreshHeight = refreshDom.offsetHeight;\n          refreshDom.style.marginTop = -refreshHeight + 'px';\n        }\n      }\n\n      if (this.mergedOptions.vuescroll.pushLoad.enable) {\n        if (this.vsMounted) {\n          var loadDom = this.$refs[__LOAD_DOM_NAME].elm || this.$refs[__LOAD_DOM_NAME];\n          loadHeight = loadDom.offsetHeight;\n          contentHeight -= loadHeight;\n          loadDom.style.bottom = \"-\".concat(loadHeight, \"px\");\n        }\n      }\n\n      if (this.scroller) {\n        this.scroller.setDimensions(clientWidth, clientHeight, contentWidth, contentHeight, false);\n      }\n    },\n    registryRefreshLoad: function registryRefreshLoad() {\n      // registry refresh\n      if (this.mergedOptions.vuescroll.pullRefresh.enable) {\n        this.registryEvent('refresh');\n      } // registry load\n\n\n      if (this.mergedOptions.vuescroll.pushLoad.enable) {\n        this.registryEvent('load');\n      }\n    },\n    registryScroller: function registryScroller() {\n      var _this = this;\n\n      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n          _ref$left = _ref.left,\n          left = _ref$left === void 0 ? 0 : _ref$left,\n          _ref$top = _ref.top,\n          top = _ref$top === void 0 ? 0 : _ref$top,\n          _ref$zoom = _ref.zoom,\n          zoom = _ref$zoom === void 0 ? 1 : _ref$zoom;\n\n      var _this$mergedOptions$v = this.mergedOptions.vuescroll.scroller,\n          preventDefault = _this$mergedOptions$v.preventDefault,\n          preventDefaultOnMove = _this$mergedOptions$v.preventDefaultOnMove;\n      var _this$mergedOptions$v2 = this.mergedOptions.vuescroll,\n          paging = _this$mergedOptions$v2.paging,\n          snapping = _this$mergedOptions$v2.snapping.enable,\n          renderMethod = _this$mergedOptions$v2.renderMethod,\n          zooming = _this$mergedOptions$v2.zooming,\n          locking = _this$mergedOptions$v2.locking; // disale zooming when refresh or load enabled\n\n      zooming = !this.refreshLoad && !paging && !snapping && zooming;\n      var _this$mergedOptions$s = this.mergedOptions.scrollPanel,\n          scrollingY = _this$mergedOptions$s.scrollingY,\n          scrollingX = _this$mergedOptions$s.scrollingX;\n      var scrollingComplete = this.scrollingComplete.bind(this); // Initialize Scroller\n\n      this.scroller = new Scroller(render(this.scrollPanelElm, window, 'px', renderMethod), _objectSpread2(_objectSpread2({}, this.mergedOptions.vuescroll.scroller), {}, {\n        zooming: zooming,\n        scrollingY: scrollingY,\n        scrollingX: scrollingX && !this.refreshLoad,\n        animationDuration: this.mergedOptions.scrollPanel.speed,\n        paging: paging,\n        snapping: snapping,\n        scrollingComplete: scrollingComplete,\n        locking: locking\n      }));\n      this.scroller.__disable = this.mergedOptions.vuescroll.scroller.disable;\n      this.scroller.__scrollLeft = left;\n      this.scroller.__scrollTop = top;\n      this.scroller.__zoomLevel = zoom; // Set snap\n\n      if (snapping) {\n        this.scroller.setSnapSize(this.mergedOptions.vuescroll.snapping.width, this.mergedOptions.vuescroll.snapping.height);\n      }\n\n      var rect = this.$el.getBoundingClientRect();\n      this.scroller.setPosition(rect.left + this.$el.clientLeft, rect.top + this.$el.clientTop); // Get destroy callback\n\n      var cb = listenContainer(this.$el, this.scroller, function (eventType) {\n        // Thie is to dispatch the event from the scroller.\n        // to let vuescroll refresh the dom\n        switch (eventType) {\n          case 'mousedown':\n            _this.vuescroll.state.isDragging = true;\n            break;\n\n          case 'onscroll':\n            {\n              /**\n               * Trigger auto load\n               */\n              var stage = _this.vuescroll.state['loadStage'];\n              var _this$mergedOptions$v3 = _this.mergedOptions.vuescroll.pushLoad,\n                  enable = _this$mergedOptions$v3.enable,\n                  auto = _this$mergedOptions$v3.auto,\n                  autoLoadDistance = _this$mergedOptions$v3.autoLoadDistance;\n              var _this$scroller = _this.scroller,\n                  __scrollTop = _this$scroller.__scrollTop,\n                  __maxScrollTop = _this$scroller.__maxScrollTop;\n\n              if (stage != 'start' && enable && auto && !_this.lockAutoLoad && // auto load debounce\n              autoLoadDistance >= __maxScrollTop - __scrollTop && __scrollTop > 0) {\n                _this.lockAutoLoad = true;\n\n                _this.triggerRefreshOrLoad('load');\n              }\n\n              if (autoLoadDistance < __maxScrollTop - __scrollTop) {\n                _this.lockAutoLoad = false;\n              }\n\n              _this.handleScroll(false);\n            }\n            break;\n\n          case 'mouseup':\n            _this.vuescroll.state.isDragging = false;\n            break;\n        }\n      }, zooming, preventDefault, preventDefaultOnMove);\n      this.updateScroller();\n      return cb;\n    },\n    updateSlideModeBarState: function updateSlideModeBarState() {\n      // update slide mode scrollbars' state\n      var heightPercentage, widthPercentage;\n      var vuescroll = this.$el;\n      var scroller = this.scroller;\n      var outerLeft = 0;\n      var outerTop = 0;\n      var _this$$el = this.$el,\n          clientWidth = _this$$el.clientWidth,\n          clientHeight = _this$$el.clientHeight;\n      var contentWidth = clientWidth + this.scroller.__maxScrollLeft;\n      var contentHeight = clientHeight + this.scroller.__maxScrollTop; // We should add the the height or width that is\n      // out of horizontal bountry  to the total length\n\n      /* istanbul ignore if */\n\n      if (scroller.__scrollLeft < 0) {\n        outerLeft = -scroller.__scrollLeft;\n      }\n      /* istanbul ignore next */\n      else if (scroller.__scrollLeft > scroller.__maxScrollLeft) {\n          outerLeft = scroller.__scrollLeft - scroller.__maxScrollLeft;\n        } // out of vertical bountry\n\n\n      if (scroller.__scrollTop < 0) {\n        outerTop = -scroller.__scrollTop;\n        this.outTheBottomBoundary = false;\n        this.outTheTopBoundary = true;\n      } else if (scroller.__scrollTop > scroller.__maxScrollTop) {\n        outerTop = scroller.__scrollTop - scroller.__maxScrollTop;\n        this.outTheTopBoundary = false;\n        this.outTheBottomBoundary = true;\n      } else {\n        this.outTheTopBoundary = this.outTheBottomBoundary = false;\n      }\n\n      heightPercentage = clientHeight / (contentHeight + outerTop);\n      widthPercentage = clientWidth / (contentWidth + outerLeft);\n      var scrollTop = Math.min(Math.max(0, scroller.__scrollTop), scroller.__maxScrollTop);\n      var scrollLeft = Math.min(Math.max(0, scroller.__scrollLeft), scroller.__maxScrollLeft);\n      this.bar.vBar.state.posValue = (scrollTop + outerTop) * 100 / vuescroll.clientHeight;\n      this.bar.hBar.state.posValue = (scrollLeft + outerLeft) * 100 / vuescroll.clientWidth;\n      /* istanbul ignore if */\n\n      if (scroller.__scrollLeft < 0) {\n        this.bar.hBar.state.posValue = 0;\n      }\n\n      if (scroller.__scrollTop < 0) {\n        this.bar.vBar.state.posValue = 0;\n      }\n\n      this.bar.vBar.state.size = heightPercentage < 1 ? heightPercentage : 0;\n      this.bar.hBar.state.size = widthPercentage < 1 ? widthPercentage : 0;\n    },\n    registryEvent: function registryEvent(type) {\n      var domName = type == 'refresh' ? __REFRESH_DOM_NAME : __LOAD_DOM_NAME;\n      var activateFunc = type == 'refresh' ? this.scroller.activatePullToRefresh : this.scroller.activatePushToLoad;\n      var stageType = type == 'refresh' ? 'refreshStage' : 'loadStage';\n      var tipDom = this.$refs[domName].elm || this.$refs[domName];\n      var cbs = createStateCallbacks(type, stageType, this, tipDom);\n      var height = tipDom.offsetHeight;\n      activateFunc.bind(this.scroller)(height, cbs);\n    },\n    getSlidePosition: function getSlidePosition() {\n      return {\n        scrollLeft: this.scroller.__scrollLeft,\n        scrollTop: this.scroller.__scrollTop\n      };\n    }\n  }\n};\n\n/**\n * These mixes is exclusive for native mode\n */\nvar nativeMix = {\n  methods: {\n    updateNativeModeBarState: function updateNativeModeBarState() {\n      var container = this.scrollPanelElm;\n      var isPercent = this.vuescroll.state.currentSizeStrategy == 'percent';\n      var _this$vuescroll$state = this.vuescroll.state,\n          width = _this$vuescroll$state.width,\n          height = _this$vuescroll$state.height;\n      var clientWidth = isPercent || !width ? container.clientWidth : width.slice(0, -2); // xxxpx ==> xxx\n\n      var clientHeight = isPercent || !height ? container.clientHeight : height.slice(0, -2);\n      var heightPercentage = clientHeight / container.scrollHeight;\n      var widthPercentage = clientWidth / container.scrollWidth;\n      this.bar.vBar.state.posValue = container.scrollTop * 100 / clientHeight;\n      this.bar.hBar.state.posValue = container.scrollLeft * 100 / clientWidth;\n      this.bar.vBar.state.size = heightPercentage < 1 ? heightPercentage : 0;\n      this.bar.hBar.state.size = widthPercentage < 1 ? widthPercentage : 0;\n    },\n    getNativePosition: function getNativePosition() {\n      return {\n        scrollTop: this.scrollPanelElm.scrollTop,\n        scrollLeft: this.scrollPanelElm.scrollLeft\n      };\n    },\n    css: function css(dom, style)\n    /* istanbul ignore next */\n    {\n      return window.getComputedStyle(dom)[style];\n    },\n    checkScrollable: function checkScrollable(e, deltaX, deltaY)\n    /* istanbul ignore next */\n    {\n      var scrollable = false; // check mouse point scrollable.\n\n      var dom = e.target ? e.target : e;\n\n      while (dom && dom.nodeType == 1 && dom !== this.scrollPanelElm.parentNode && !/^BODY|HTML/.test(dom.nodeName)) {\n        var ov = this.css(dom, 'overflow') || '';\n\n        if (/scroll|auto/.test(ov)) {\n          var _this$getScrollProces = this.getScrollProcess(dom),\n              v = _this$getScrollProces.v,\n              h = _this$getScrollProces.h;\n\n          var isScrollX = this.css(dom, 'overflowX') !== 'hidden';\n          var isScrollY = this.css(dom, 'overflowY') !== 'hidden';\n\n          if (isScrollX && (deltaX < 0 && h > 0 || deltaX > 0 && h < 1) || isScrollY && (deltaY < 0 && v > 0 || deltaY > 0 && v < 1)) {\n            scrollable = dom == this.scrollPanelElm;\n            break;\n          }\n        }\n\n        dom = dom.parentNode ? dom.parentNode : false;\n      }\n\n      return scrollable;\n    },\n    onMouseWheel: function onMouseWheel(event)\n    /* istanbul ignore next */\n    {\n      var _this$mergedOptions$v = this.mergedOptions.vuescroll,\n          isReverse = _this$mergedOptions$v.wheelDirectionReverse,\n          duration = _this$mergedOptions$v.wheelScrollDuration,\n          checkShiftKey = _this$mergedOptions$v.checkShiftKey,\n          locking = _this$mergedOptions$v.locking;\n      var deltaX;\n      var deltaY;\n\n      if (event.wheelDelta) {\n        if (event.deltaY || event.deltaX) {\n          deltaX = event.deltaX;\n          deltaY = event.deltaY;\n\n          if (locking) {\n            if (Math.abs(event.deltaX) > Math.abs(event.deltaY)) {\n              deltaY = 0;\n            } else {\n              deltaX = 0;\n            }\n          }\n        } else {\n          deltaX = 0;\n          deltaY = -1 * event.wheelDelta / 2;\n        }\n      } else if (event.detail) {\n        deltaY = deltaX = event.detail * 16; // horizontal scroll\n\n        if (event.axis == 1) {\n          deltaY = 0;\n        } else if (event.axis == 2) {\n          // vertical scroll\n          deltaX = 0;\n        }\n      }\n\n      if (checkShiftKey && event.shiftKey) {\n        // swap value\n        deltaX ^= deltaY;\n        deltaY ^= deltaX;\n        deltaX ^= deltaY;\n      }\n\n      if (isReverse) {\n        deltaX ^= deltaY;\n        deltaY ^= deltaX;\n        deltaX ^= deltaY;\n      }\n\n      if (this.checkScrollable(event, deltaX, deltaY)) {\n        event.stopPropagation();\n        event.preventDefault();\n        this.scrollBy({\n          dx: deltaX,\n          dy: deltaY\n        }, duration);\n      }\n    }\n  },\n  computed: {\n    scrollContentElm: function scrollContentElm() {\n      return this.$refs['scrollContent'].$el || this.$refs['scrollContent'];\n    }\n  }\n};\n\nvar update = [slideMix, nativeMix];\n\nvar mixins = [api$1].concat(_toConsumableArray(update));\n\nvar core$1 = {\n  mixins: mixins,\n  mounted: function mounted() {\n    var _this = this;\n\n    if (!this._isDestroyed && !this.renderError) {\n      if (this.mode == 'slide') {\n        this.updatedCbs.push(this.updateScroller);\n      }\n\n      this.$watch(function () {\n        return _this.mergedOptions.vuescroll.scroller.disable;\n      }, function (newVal) {\n        if (_this.scroller) {\n          _this.scroller.__disable = newVal;\n        }\n      }, {\n        flush: 'sync'\n      });\n    }\n  },\n  computed: {\n    mode: function mode() {\n      return this.mergedOptions.vuescroll.mode;\n    }\n  },\n  methods: {\n    destroy: function destroy() {\n      if (this.destroyScroller) {\n        this.scroller.stop();\n        this.destroyScroller();\n        this.destroyScroller = null;\n      }\n      /* istanbul ignore next */\n\n\n      if (this.destroyResize) {\n        this.destroyResize();\n      }\n    },\n    handleScroll: function handleScroll(nativeEvent) {\n      this.updateBarStateAndEmitEvent('handle-scroll', nativeEvent);\n    },\n    updateBarStateAndEmitEvent: function updateBarStateAndEmitEvent(eventType) {\n      var nativeEvent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n\n      if (this.mode == 'native') {\n        this.updateNativeModeBarState();\n      } else if (this.mode == 'slide') {\n        /* istanbul ignore if */\n        if (!this.scroller) {\n          return;\n        }\n\n        this.updateSlideModeBarState();\n      }\n\n      if (eventType) {\n        this.emitEvent(eventType, nativeEvent);\n      }\n\n      if (this.mergedOptions.bar.onlyShowBarOnScroll) {\n        if (eventType == 'handle-scroll' || eventType == 'handle-resize' || eventType == 'refresh-status' || eventType == 'window-resize' || eventType == 'options-change') {\n          this.showAndDefferedHideBar(true\n          /* forceHideBar: true */\n          );\n        }\n      } else {\n        this.showAndDefferedHideBar();\n      }\n    },\n    getScrollProcess: function getScrollProcess() {\n      var _this$scrollPanelElm = this.scrollPanelElm,\n          scrollHeight = _this$scrollPanelElm.scrollHeight,\n          scrollWidth = _this$scrollPanelElm.scrollWidth,\n          clientHeight = _this$scrollPanelElm.clientHeight,\n          clientWidth = _this$scrollPanelElm.clientWidth,\n          scrollTop = _this$scrollPanelElm.scrollTop,\n          scrollLeft = _this$scrollPanelElm.scrollLeft;\n\n      if (this.mode == 'slide') {\n        scrollHeight = this.scroller.__contentHeight;\n        scrollWidth = this.scroller.__contentWidth;\n        scrollTop = this.scroller.__scrollTop;\n        scrollLeft = this.scroller.__scrollLeft;\n        clientHeight = this.$el.clientHeight;\n        clientWidth = this.$el.clientWidth;\n      }\n\n      var v = Math.min(scrollTop / (scrollHeight - clientHeight || 1), 1);\n      var h = Math.min(scrollLeft / (scrollWidth - clientWidth || 1), 1);\n      return {\n        v: v,\n        h: h\n      };\n    },\n    emitEvent: function emitEvent(eventType) {\n      var nativeEvent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n      var _this$scrollPanelElm2 = this.scrollPanelElm,\n          scrollTop = _this$scrollPanelElm2.scrollTop,\n          scrollLeft = _this$scrollPanelElm2.scrollLeft;\n      var vertical = {\n        type: 'vertical'\n      };\n      var horizontal = {\n        type: 'horizontal'\n      };\n\n      var _this$getScrollProces = this.getScrollProcess(),\n          v = _this$getScrollProces.v,\n          h = _this$getScrollProces.h;\n\n      vertical['process'] = v;\n      horizontal['process'] = h;\n      vertical['barSize'] = this.bar.vBar.state.size;\n      horizontal['barSize'] = this.bar.hBar.state.size;\n      vertical['scrollTop'] = scrollTop;\n      horizontal['scrollLeft'] = scrollLeft;\n      this.$emit(eventType, vertical, horizontal, nativeEvent);\n    },\n    initVariables: function initVariables() {\n      this.lastMode = this.mode;\n      this.$el._isVuescroll = true;\n    },\n    refreshMode: function refreshMode() {\n      var initPos;\n\n      if (this.scroller) {\n        initPos = this.scroller.getValues();\n      }\n\n      if (this.destroyScroller) {\n        this.scroller.stop();\n        this.destroyScroller();\n        this.destroyScroller = null;\n      }\n\n      if (this.mode == 'slide') {\n        this.destroyScroller = this.registryScroller(initPos);\n      } else if (this.mode == 'native') {\n        // remove the legacy transform style attribute\n        this.scrollPanelElm.style.transform = '';\n        this.scrollPanelElm.style.transformOrigin = '';\n      }\n    },\n    refreshInternalStatus: function refreshInternalStatus() {\n      // 1.set vuescroll height or width according to\n      // sizeStrategy\n      this.setVsSize(); // 2. registry resize event\n\n      this.registryResize(); // 3. registry scroller if mode is 'slide'\n      // or remove 'transform origin' is the mode is not `slide`\n\n      this.refreshMode(); // 4. update scrollbar's height/width\n\n      this.updateBarStateAndEmitEvent('refresh-status');\n    },\n    registryResize: function registryResize() {\n      var _this2 = this;\n\n      var resizeEnable = this.mergedOptions.vuescroll.detectResize;\n      var modeChanged = false;\n\n      if (this.lastMode != this.mode) {\n        modeChanged = true;\n        this.lastMode = this.mode;\n      }\n      /* istanbul ignore next */\n\n\n      if (this.destroyResize && resizeEnable && !modeChanged) {\n        return;\n      }\n\n      if (this.destroyResize) {\n        this.destroyResize();\n      }\n\n      if (!resizeEnable) {\n        return;\n      }\n\n      var contentElm = null;\n\n      if (this.mode == 'slide') {\n        contentElm = this.scrollPanelElm;\n      } else if (this.mode == 'native') {\n        // scrollContent maybe a vue-component or a pure-dom\n        contentElm = this.scrollContentElm;\n      }\n\n      var vm = this;\n\n      var handleWindowResize = function handleWindowResize()\n      /* istanbul ignore next */\n      {\n        vm.updateBarStateAndEmitEvent('window-resize');\n\n        if (vm.mode == 'slide') {\n          vm.updatedCbs.push(vm.updateScroller);\n          vm.$forceUpdate();\n        }\n      };\n\n      var handleDomResize = function handleDomResize() {\n        var currentSize = {};\n\n        if (_this2.mode == 'slide') {\n          currentSize['width'] = _this2.scroller.__contentWidth;\n          currentSize['height'] = _this2.scroller.__contentHeight;\n\n          _this2.updateBarStateAndEmitEvent('handle-resize', currentSize); // update scroller should after rendering\n\n\n          _this2.updatedCbs.push(_this2.updateScroller);\n\n          _this2.$forceUpdate();\n        } else if (_this2.mode == 'native') {\n          currentSize['width'] = _this2.scrollPanelElm.scrollWidth;\n          currentSize['height'] = _this2.scrollPanelElm.scrollHeight;\n\n          _this2.updateBarStateAndEmitEvent('handle-resize', currentSize);\n        } // Since content sie changes, we should tell parent to set\n        // correct size to fit content's size\n\n\n        _this2.setVsSize();\n      };\n\n      window.addEventListener('resize', handleWindowResize, false);\n      var destroyDomResize = installResizeDetection(contentElm, handleDomResize);\n\n      var destroyWindowResize = function destroyWindowResize() {\n        window.removeEventListener('resize', handleWindowResize, false);\n      };\n\n      this.destroyResize = function () {\n        destroyWindowResize();\n        destroyDomResize();\n        _this2.destroyResize = null;\n      };\n    },\n    getPosition: function getPosition() {\n      if (this.mode == 'slide') {\n        return this.getSlidePosition();\n      } else if (this.mode == 'native') {\n        return this.getNativePosition();\n      }\n    }\n  }\n};\n\n/**\n * The slide mode config\n */\nvar error = log.error;\nvar configs = [{\n  // vuescroll\n  vuescroll: {\n    // position or transform\n    renderMethod: 'transform',\n    // pullRefresh or pushLoad is only for the slide mode...\n    pullRefresh: {\n      enable: false,\n      tips: {\n        deactive: 'Pull to Refresh',\n        active: 'Release to Refresh',\n        start: 'Refreshing...',\n        beforeDeactive: 'Refresh Successfully!'\n      }\n    },\n    pushLoad: {\n      enable: false,\n      tips: {\n        deactive: 'Push to Load',\n        active: 'Release to Load',\n        start: 'Loading...',\n        beforeDeactive: 'Load Successfully!'\n      },\n      auto: false,\n      autoLoadDistance: 0\n    },\n    paging: false,\n    zooming: true,\n    snapping: {\n      enable: false,\n      width: 100,\n      height: 100\n    },\n\n    /* some scroller options */\n    scroller: {\n      /** Enable bouncing (content can be slowly moved outside and jumps back after releasing) */\n      bouncing: {\n        top: 100,\n        bottom: 100,\n        left: 100,\n        right: 100\n      },\n\n      /** Minimum zoom level */\n      minZoom: 0.5,\n\n      /** Maximum zoom level */\n      maxZoom: 3,\n\n      /** Multiply or decrease scrolling speed **/\n      speedMultiplier: 1,\n\n      /** This configures the amount of change applied to deceleration when reaching boundaries  **/\n      penetrationDeceleration: 0.03,\n\n      /** This configures the amount of change applied to acceleration when reaching boundaries  **/\n      penetrationAcceleration: 0.08,\n\n      /** Whether call e.preventDefault event when sliding the content or not */\n      preventDefault: false,\n\n      /** Whether call preventDefault when (mouse/touch)move*/\n      preventDefaultOnMove: true,\n      disable: false\n    }\n  }\n}];\n/**\n * validate the options\n * @export\n * @param {any} ops\n */\n\nfunction configValidator(ops) {\n  var renderError = false;\n  var vuescroll = ops.vuescroll; // validate pushLoad, pullReresh, snapping\n\n  if (vuescroll.paging == vuescroll.snapping.enable && vuescroll.paging && (vuescroll.pullRefresh || vuescroll.pushLoad)) {\n    error('paging, snapping, (pullRefresh with pushLoad) can only one of them to be true.');\n  }\n\n  return renderError;\n}\n\nvar configs$1 = [{\n  vuescroll: {\n    wheelScrollDuration: 0,\n    wheelDirectionReverse: false,\n    checkShiftKey: true\n  }\n}];\n\nvar error$1 = log.error;\nvar config = {\n  // vuescroll\n  vuescroll: {\n    mode: 'native'\n  }\n};\n/**\n * validate the options\n * @export\n * @param {any} ops\n */\n\nfunction configValidator$1(ops) {\n  var renderError = false;\n  var vuescroll = ops.vuescroll; // validate modes\n\n  if (!~modes.indexOf(vuescroll.mode)) {\n    error$1(\"Unknown mode: \".concat(vuescroll.mode, \",the vuescroll's option \\\"mode\\\" should be one of the \").concat(modes));\n    renderError = true;\n  }\n\n  return renderError;\n}\n\nvar configs$2 = [config].concat(_toConsumableArray(configs), _toConsumableArray(configs$1));\nvar configValidators = [configValidator$1, configValidator];\n\nvar Vuescroll = _objectSpread2({\n  scrollTo: scrollTo\n}, _install(core$1, createPanel$2, configs$2, configValidators));\n\nexport default Vuescroll;\n","import { shallowRef, watchEffect, readonly, ref, watch, customRef, getCurrentScope, onScopeDispose, effectScope, getCurrentInstance, inject, provide, isVue3, version, isRef, unref, computed, reactive, toRefs as toRefs$1, toRef as toRef$1, isVue2, set as set$1, onBeforeMount, nextTick, onBeforeUnmount, onMounted, onUnmounted, isReactive } from 'vue-demi';\n\nfunction computedEager(fn, options) {\n  var _a;\n  const result = shallowRef();\n  watchEffect(() => {\n    result.value = fn();\n  }, {\n    ...options,\n    flush: (_a = options == null ? void 0 : options.flush) != null ? _a : \"sync\"\n  });\n  return readonly(result);\n}\n\nfunction computedWithControl(source, fn) {\n  let v = void 0;\n  let track;\n  let trigger;\n  const dirty = ref(true);\n  const update = () => {\n    dirty.value = true;\n    trigger();\n  };\n  watch(source, update, { flush: \"sync\" });\n  const get = typeof fn === \"function\" ? fn : fn.get;\n  const set = typeof fn === \"function\" ? void 0 : fn.set;\n  const result = customRef((_track, _trigger) => {\n    track = _track;\n    trigger = _trigger;\n    return {\n      get() {\n        if (dirty.value) {\n          v = get(v);\n          dirty.value = false;\n        }\n        track();\n        return v;\n      },\n      set(v2) {\n        set == null ? void 0 : set(v2);\n      }\n    };\n  });\n  if (Object.isExtensible(result))\n    result.trigger = update;\n  return result;\n}\n\nfunction tryOnScopeDispose(fn) {\n  if (getCurrentScope()) {\n    onScopeDispose(fn);\n    return true;\n  }\n  return false;\n}\n\nfunction createEventHook() {\n  const fns = /* @__PURE__ */ new Set();\n  const off = (fn) => {\n    fns.delete(fn);\n  };\n  const on = (fn) => {\n    fns.add(fn);\n    const offFn = () => off(fn);\n    tryOnScopeDispose(offFn);\n    return {\n      off: offFn\n    };\n  };\n  const trigger = (...args) => {\n    return Promise.all(Array.from(fns).map((fn) => fn(...args)));\n  };\n  return {\n    on,\n    off,\n    trigger\n  };\n}\n\nfunction createGlobalState(stateFactory) {\n  let initialized = false;\n  let state;\n  const scope = effectScope(true);\n  return (...args) => {\n    if (!initialized) {\n      state = scope.run(() => stateFactory(...args));\n      initialized = true;\n    }\n    return state;\n  };\n}\n\nconst localProvidedStateMap = /* @__PURE__ */ new WeakMap();\n\nconst injectLocal = (...args) => {\n  var _a;\n  const key = args[0];\n  const instance = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;\n  if (instance == null)\n    throw new Error(\"injectLocal must be called in setup\");\n  if (localProvidedStateMap.has(instance) && key in localProvidedStateMap.get(instance))\n    return localProvidedStateMap.get(instance)[key];\n  return inject(...args);\n};\n\nconst provideLocal = (key, value) => {\n  var _a;\n  const instance = (_a = getCurrentInstance()) == null ? void 0 : _a.proxy;\n  if (instance == null)\n    throw new Error(\"provideLocal must be called in setup\");\n  if (!localProvidedStateMap.has(instance))\n    localProvidedStateMap.set(instance, /* @__PURE__ */ Object.create(null));\n  const localProvidedState = localProvidedStateMap.get(instance);\n  localProvidedState[key] = value;\n  provide(key, value);\n};\n\nfunction createInjectionState(composable, options) {\n  const key = (options == null ? void 0 : options.injectionKey) || Symbol(composable.name || \"InjectionState\");\n  const defaultValue = options == null ? void 0 : options.defaultValue;\n  const useProvidingState = (...args) => {\n    const state = composable(...args);\n    provideLocal(key, state);\n    return state;\n  };\n  const useInjectedState = () => injectLocal(key, defaultValue);\n  return [useProvidingState, useInjectedState];\n}\n\nfunction createSharedComposable(composable) {\n  let subscribers = 0;\n  let state;\n  let scope;\n  const dispose = () => {\n    subscribers -= 1;\n    if (scope && subscribers <= 0) {\n      scope.stop();\n      state = void 0;\n      scope = void 0;\n    }\n  };\n  return (...args) => {\n    subscribers += 1;\n    if (!scope) {\n      scope = effectScope(true);\n      state = scope.run(() => composable(...args));\n    }\n    tryOnScopeDispose(dispose);\n    return state;\n  };\n}\n\nfunction extendRef(ref, extend, { enumerable = false, unwrap = true } = {}) {\n  if (!isVue3 && !version.startsWith(\"2.7.\")) {\n    if (process.env.NODE_ENV !== \"production\")\n      throw new Error(\"[VueUse] extendRef only works in Vue 2.7 or above.\");\n    return;\n  }\n  for (const [key, value] of Object.entries(extend)) {\n    if (key === \"value\")\n      continue;\n    if (isRef(value) && unwrap) {\n      Object.defineProperty(ref, key, {\n        get() {\n          return value.value;\n        },\n        set(v) {\n          value.value = v;\n        },\n        enumerable\n      });\n    } else {\n      Object.defineProperty(ref, key, { value, enumerable });\n    }\n  }\n  return ref;\n}\n\nfunction get(obj, key) {\n  if (key == null)\n    return unref(obj);\n  return unref(obj)[key];\n}\n\nfunction isDefined(v) {\n  return unref(v) != null;\n}\n\nfunction makeDestructurable(obj, arr) {\n  if (typeof Symbol !== \"undefined\") {\n    const clone = { ...obj };\n    Object.defineProperty(clone, Symbol.iterator, {\n      enumerable: false,\n      value() {\n        let index = 0;\n        return {\n          next: () => ({\n            value: arr[index++],\n            done: index > arr.length\n          })\n        };\n      }\n    });\n    return clone;\n  } else {\n    return Object.assign([...arr], obj);\n  }\n}\n\nfunction toValue(r) {\n  return typeof r === \"function\" ? r() : unref(r);\n}\nconst resolveUnref = toValue;\n\nfunction reactify(fn, options) {\n  const unrefFn = (options == null ? void 0 : options.computedGetter) === false ? unref : toValue;\n  return function(...args) {\n    return computed(() => fn.apply(this, args.map((i) => unrefFn(i))));\n  };\n}\n\nfunction reactifyObject(obj, optionsOrKeys = {}) {\n  let keys = [];\n  let options;\n  if (Array.isArray(optionsOrKeys)) {\n    keys = optionsOrKeys;\n  } else {\n    options = optionsOrKeys;\n    const { includeOwnProperties = true } = optionsOrKeys;\n    keys.push(...Object.keys(obj));\n    if (includeOwnProperties)\n      keys.push(...Object.getOwnPropertyNames(obj));\n  }\n  return Object.fromEntries(\n    keys.map((key) => {\n      const value = obj[key];\n      return [\n        key,\n        typeof value === \"function\" ? reactify(value.bind(obj), options) : value\n      ];\n    })\n  );\n}\n\nfunction toReactive(objectRef) {\n  if (!isRef(objectRef))\n    return reactive(objectRef);\n  const proxy = new Proxy({}, {\n    get(_, p, receiver) {\n      return unref(Reflect.get(objectRef.value, p, receiver));\n    },\n    set(_, p, value) {\n      if (isRef(objectRef.value[p]) && !isRef(value))\n        objectRef.value[p].value = value;\n      else\n        objectRef.value[p] = value;\n      return true;\n    },\n    deleteProperty(_, p) {\n      return Reflect.deleteProperty(objectRef.value, p);\n    },\n    has(_, p) {\n      return Reflect.has(objectRef.value, p);\n    },\n    ownKeys() {\n      return Object.keys(objectRef.value);\n    },\n    getOwnPropertyDescriptor() {\n      return {\n        enumerable: true,\n        configurable: true\n      };\n    }\n  });\n  return reactive(proxy);\n}\n\nfunction reactiveComputed(fn) {\n  return toReactive(computed(fn));\n}\n\nfunction reactiveOmit(obj, ...keys) {\n  const flatKeys = keys.flat();\n  const predicate = flatKeys[0];\n  return reactiveComputed(() => typeof predicate === \"function\" ? Object.fromEntries(Object.entries(toRefs$1(obj)).filter(([k, v]) => !predicate(toValue(v), k))) : Object.fromEntries(Object.entries(toRefs$1(obj)).filter((e) => !flatKeys.includes(e[0]))));\n}\n\nconst directiveHooks = {\n  mounted: isVue3 ? \"mounted\" : \"inserted\",\n  updated: isVue3 ? \"updated\" : \"componentUpdated\",\n  unmounted: isVue3 ? \"unmounted\" : \"unbind\"\n};\n\nconst isClient = typeof window !== \"undefined\" && typeof document !== \"undefined\";\nconst isWorker = typeof WorkerGlobalScope !== \"undefined\" && globalThis instanceof WorkerGlobalScope;\nconst isDef = (val) => typeof val !== \"undefined\";\nconst notNullish = (val) => val != null;\nconst assert = (condition, ...infos) => {\n  if (!condition)\n    console.warn(...infos);\n};\nconst toString = Object.prototype.toString;\nconst isObject = (val) => toString.call(val) === \"[object Object]\";\nconst now = () => Date.now();\nconst timestamp = () => +Date.now();\nconst clamp = (n, min, max) => Math.min(max, Math.max(min, n));\nconst noop = () => {\n};\nconst rand = (min, max) => {\n  min = Math.ceil(min);\n  max = Math.floor(max);\n  return Math.floor(Math.random() * (max - min + 1)) + min;\n};\nconst hasOwn = (val, key) => Object.prototype.hasOwnProperty.call(val, key);\nconst isIOS = /* @__PURE__ */ getIsIOS();\nfunction getIsIOS() {\n  var _a, _b;\n  return isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || ((_b = window == null ? void 0 : window.navigator) == null ? void 0 : _b.maxTouchPoints) > 2 && /iPad|Macintosh/.test(window == null ? void 0 : window.navigator.userAgent));\n}\n\nfunction createFilterWrapper(filter, fn) {\n  function wrapper(...args) {\n    return new Promise((resolve, reject) => {\n      Promise.resolve(filter(() => fn.apply(this, args), { fn, thisArg: this, args })).then(resolve).catch(reject);\n    });\n  }\n  return wrapper;\n}\nconst bypassFilter = (invoke) => {\n  return invoke();\n};\nfunction debounceFilter(ms, options = {}) {\n  let timer;\n  let maxTimer;\n  let lastRejector = noop;\n  const _clearTimeout = (timer2) => {\n    clearTimeout(timer2);\n    lastRejector();\n    lastRejector = noop;\n  };\n  const filter = (invoke) => {\n    const duration = toValue(ms);\n    const maxDuration = toValue(options.maxWait);\n    if (timer)\n      _clearTimeout(timer);\n    if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {\n      if (maxTimer) {\n        _clearTimeout(maxTimer);\n        maxTimer = null;\n      }\n      return Promise.resolve(invoke());\n    }\n    return new Promise((resolve, reject) => {\n      lastRejector = options.rejectOnCancel ? reject : resolve;\n      if (maxDuration && !maxTimer) {\n        maxTimer = setTimeout(() => {\n          if (timer)\n            _clearTimeout(timer);\n          maxTimer = null;\n          resolve(invoke());\n        }, maxDuration);\n      }\n      timer = setTimeout(() => {\n        if (maxTimer)\n          _clearTimeout(maxTimer);\n        maxTimer = null;\n        resolve(invoke());\n      }, duration);\n    });\n  };\n  return filter;\n}\nfunction throttleFilter(...args) {\n  let lastExec = 0;\n  let timer;\n  let isLeading = true;\n  let lastRejector = noop;\n  let lastValue;\n  let ms;\n  let trailing;\n  let leading;\n  let rejectOnCancel;\n  if (!isRef(args[0]) && typeof args[0] === \"object\")\n    ({ delay: ms, trailing = true, leading = true, rejectOnCancel = false } = args[0]);\n  else\n    [ms, trailing = true, leading = true, rejectOnCancel = false] = args;\n  const clear = () => {\n    if (timer) {\n      clearTimeout(timer);\n      timer = void 0;\n      lastRejector();\n      lastRejector = noop;\n    }\n  };\n  const filter = (_invoke) => {\n    const duration = toValue(ms);\n    const elapsed = Date.now() - lastExec;\n    const invoke = () => {\n      return lastValue = _invoke();\n    };\n    clear();\n    if (duration <= 0) {\n      lastExec = Date.now();\n      return invoke();\n    }\n    if (elapsed > duration && (leading || !isLeading)) {\n      lastExec = Date.now();\n      invoke();\n    } else if (trailing) {\n      lastValue = new Promise((resolve, reject) => {\n        lastRejector = rejectOnCancel ? reject : resolve;\n        timer = setTimeout(() => {\n          lastExec = Date.now();\n          isLeading = true;\n          resolve(invoke());\n          clear();\n        }, Math.max(0, duration - elapsed));\n      });\n    }\n    if (!leading && !timer)\n      timer = setTimeout(() => isLeading = true, duration);\n    isLeading = false;\n    return lastValue;\n  };\n  return filter;\n}\nfunction pausableFilter(extendFilter = bypassFilter) {\n  const isActive = ref(true);\n  function pause() {\n    isActive.value = false;\n  }\n  function resume() {\n    isActive.value = true;\n  }\n  const eventFilter = (...args) => {\n    if (isActive.value)\n      extendFilter(...args);\n  };\n  return { isActive: readonly(isActive), pause, resume, eventFilter };\n}\n\nfunction cacheStringFunction(fn) {\n  const cache = /* @__PURE__ */ Object.create(null);\n  return (str) => {\n    const hit = cache[str];\n    return hit || (cache[str] = fn(str));\n  };\n}\nconst hyphenateRE = /\\B([A-Z])/g;\nconst hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, \"-$1\").toLowerCase());\nconst camelizeRE = /-(\\w)/g;\nconst camelize = cacheStringFunction((str) => {\n  return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : \"\");\n});\n\nfunction promiseTimeout(ms, throwOnTimeout = false, reason = \"Timeout\") {\n  return new Promise((resolve, reject) => {\n    if (throwOnTimeout)\n      setTimeout(() => reject(reason), ms);\n    else\n      setTimeout(resolve, ms);\n  });\n}\nfunction identity(arg) {\n  return arg;\n}\nfunction createSingletonPromise(fn) {\n  let _promise;\n  function wrapper() {\n    if (!_promise)\n      _promise = fn();\n    return _promise;\n  }\n  wrapper.reset = async () => {\n    const _prev = _promise;\n    _promise = void 0;\n    if (_prev)\n      await _prev;\n  };\n  return wrapper;\n}\nfunction invoke(fn) {\n  return fn();\n}\nfunction containsProp(obj, ...props) {\n  return props.some((k) => k in obj);\n}\nfunction increaseWithUnit(target, delta) {\n  var _a;\n  if (typeof target === \"number\")\n    return target + delta;\n  const value = ((_a = target.match(/^-?\\d+\\.?\\d*/)) == null ? void 0 : _a[0]) || \"\";\n  const unit = target.slice(value.length);\n  const result = Number.parseFloat(value) + delta;\n  if (Number.isNaN(result))\n    return target;\n  return result + unit;\n}\nfunction objectPick(obj, keys, omitUndefined = false) {\n  return keys.reduce((n, k) => {\n    if (k in obj) {\n      if (!omitUndefined || obj[k] !== void 0)\n        n[k] = obj[k];\n    }\n    return n;\n  }, {});\n}\nfunction objectOmit(obj, keys, omitUndefined = false) {\n  return Object.fromEntries(Object.entries(obj).filter(([key, value]) => {\n    return (!omitUndefined || value !== void 0) && !keys.includes(key);\n  }));\n}\nfunction objectEntries(obj) {\n  return Object.entries(obj);\n}\nfunction getLifeCycleTarget(target) {\n  return target || getCurrentInstance();\n}\n\nfunction toRef(...args) {\n  if (args.length !== 1)\n    return toRef$1(...args);\n  const r = args[0];\n  return typeof r === \"function\" ? readonly(customRef(() => ({ get: r, set: noop }))) : ref(r);\n}\nconst resolveRef = toRef;\n\nfunction reactivePick(obj, ...keys) {\n  const flatKeys = keys.flat();\n  const predicate = flatKeys[0];\n  return reactiveComputed(() => typeof predicate === \"function\" ? Object.fromEntries(Object.entries(toRefs$1(obj)).filter(([k, v]) => predicate(toValue(v), k))) : Object.fromEntries(flatKeys.map((k) => [k, toRef(obj, k)])));\n}\n\nfunction refAutoReset(defaultValue, afterMs = 1e4) {\n  return customRef((track, trigger) => {\n    let value = toValue(defaultValue);\n    let timer;\n    const resetAfter = () => setTimeout(() => {\n      value = toValue(defaultValue);\n      trigger();\n    }, toValue(afterMs));\n    tryOnScopeDispose(() => {\n      clearTimeout(timer);\n    });\n    return {\n      get() {\n        track();\n        return value;\n      },\n      set(newValue) {\n        value = newValue;\n        trigger();\n        clearTimeout(timer);\n        timer = resetAfter();\n      }\n    };\n  });\n}\n\nfunction useDebounceFn(fn, ms = 200, options = {}) {\n  return createFilterWrapper(\n    debounceFilter(ms, options),\n    fn\n  );\n}\n\nfunction refDebounced(value, ms = 200, options = {}) {\n  const debounced = ref(value.value);\n  const updater = useDebounceFn(() => {\n    debounced.value = value.value;\n  }, ms, options);\n  watch(value, () => updater());\n  return debounced;\n}\n\nfunction refDefault(source, defaultValue) {\n  return computed({\n    get() {\n      var _a;\n      return (_a = source.value) != null ? _a : defaultValue;\n    },\n    set(value) {\n      source.value = value;\n    }\n  });\n}\n\nfunction useThrottleFn(fn, ms = 200, trailing = false, leading = true, rejectOnCancel = false) {\n  return createFilterWrapper(\n    throttleFilter(ms, trailing, leading, rejectOnCancel),\n    fn\n  );\n}\n\nfunction refThrottled(value, delay = 200, trailing = true, leading = true) {\n  if (delay <= 0)\n    return value;\n  const throttled = ref(value.value);\n  const updater = useThrottleFn(() => {\n    throttled.value = value.value;\n  }, delay, trailing, leading);\n  watch(value, () => updater());\n  return throttled;\n}\n\nfunction refWithControl(initial, options = {}) {\n  let source = initial;\n  let track;\n  let trigger;\n  const ref = customRef((_track, _trigger) => {\n    track = _track;\n    trigger = _trigger;\n    return {\n      get() {\n        return get();\n      },\n      set(v) {\n        set(v);\n      }\n    };\n  });\n  function get(tracking = true) {\n    if (tracking)\n      track();\n    return source;\n  }\n  function set(value, triggering = true) {\n    var _a, _b;\n    if (value === source)\n      return;\n    const old = source;\n    if (((_a = options.onBeforeChange) == null ? void 0 : _a.call(options, value, old)) === false)\n      return;\n    source = value;\n    (_b = options.onChanged) == null ? void 0 : _b.call(options, value, old);\n    if (triggering)\n      trigger();\n  }\n  const untrackedGet = () => get(false);\n  const silentSet = (v) => set(v, false);\n  const peek = () => get(false);\n  const lay = (v) => set(v, false);\n  return extendRef(\n    ref,\n    {\n      get,\n      set,\n      untrackedGet,\n      silentSet,\n      peek,\n      lay\n    },\n    { enumerable: true }\n  );\n}\nconst controlledRef = refWithControl;\n\nfunction set(...args) {\n  if (args.length === 2) {\n    const [ref, value] = args;\n    ref.value = value;\n  }\n  if (args.length === 3) {\n    if (isVue2) {\n      set$1(...args);\n    } else {\n      const [target, key, value] = args;\n      target[key] = value;\n    }\n  }\n}\n\nfunction watchWithFilter(source, cb, options = {}) {\n  const {\n    eventFilter = bypassFilter,\n    ...watchOptions\n  } = options;\n  return watch(\n    source,\n    createFilterWrapper(\n      eventFilter,\n      cb\n    ),\n    watchOptions\n  );\n}\n\nfunction watchPausable(source, cb, options = {}) {\n  const {\n    eventFilter: filter,\n    ...watchOptions\n  } = options;\n  const { eventFilter, pause, resume, isActive } = pausableFilter(filter);\n  const stop = watchWithFilter(\n    source,\n    cb,\n    {\n      ...watchOptions,\n      eventFilter\n    }\n  );\n  return { stop, pause, resume, isActive };\n}\n\nfunction syncRef(left, right, ...[options]) {\n  const {\n    flush = \"sync\",\n    deep = false,\n    immediate = true,\n    direction = \"both\",\n    transform = {}\n  } = options || {};\n  const watchers = [];\n  const transformLTR = \"ltr\" in transform && transform.ltr || ((v) => v);\n  const transformRTL = \"rtl\" in transform && transform.rtl || ((v) => v);\n  if (direction === \"both\" || direction === \"ltr\") {\n    watchers.push(watchPausable(\n      left,\n      (newValue) => {\n        watchers.forEach((w) => w.pause());\n        right.value = transformLTR(newValue);\n        watchers.forEach((w) => w.resume());\n      },\n      { flush, deep, immediate }\n    ));\n  }\n  if (direction === \"both\" || direction === \"rtl\") {\n    watchers.push(watchPausable(\n      right,\n      (newValue) => {\n        watchers.forEach((w) => w.pause());\n        left.value = transformRTL(newValue);\n        watchers.forEach((w) => w.resume());\n      },\n      { flush, deep, immediate }\n    ));\n  }\n  const stop = () => {\n    watchers.forEach((w) => w.stop());\n  };\n  return stop;\n}\n\nfunction syncRefs(source, targets, options = {}) {\n  const {\n    flush = \"sync\",\n    deep = false,\n    immediate = true\n  } = options;\n  if (!Array.isArray(targets))\n    targets = [targets];\n  return watch(\n    source,\n    (newValue) => targets.forEach((target) => target.value = newValue),\n    { flush, deep, immediate }\n  );\n}\n\nfunction toRefs(objectRef, options = {}) {\n  if (!isRef(objectRef))\n    return toRefs$1(objectRef);\n  const result = Array.isArray(objectRef.value) ? Array.from({ length: objectRef.value.length }) : {};\n  for (const key in objectRef.value) {\n    result[key] = customRef(() => ({\n      get() {\n        return objectRef.value[key];\n      },\n      set(v) {\n        var _a;\n        const replaceRef = (_a = toValue(options.replaceRef)) != null ? _a : true;\n        if (replaceRef) {\n          if (Array.isArray(objectRef.value)) {\n            const copy = [...objectRef.value];\n            copy[key] = v;\n            objectRef.value = copy;\n          } else {\n            const newObject = { ...objectRef.value, [key]: v };\n            Object.setPrototypeOf(newObject, Object.getPrototypeOf(objectRef.value));\n            objectRef.value = newObject;\n          }\n        } else {\n          objectRef.value[key] = v;\n        }\n      }\n    }));\n  }\n  return result;\n}\n\nfunction tryOnBeforeMount(fn, sync = true, target) {\n  const instance = getLifeCycleTarget(target);\n  if (instance)\n    onBeforeMount(fn, target);\n  else if (sync)\n    fn();\n  else\n    nextTick(fn);\n}\n\nfunction tryOnBeforeUnmount(fn, target) {\n  const instance = getLifeCycleTarget(target);\n  if (instance)\n    onBeforeUnmount(fn, target);\n}\n\nfunction tryOnMounted(fn, sync = true, target) {\n  const instance = getLifeCycleTarget();\n  if (instance)\n    onMounted(fn, target);\n  else if (sync)\n    fn();\n  else\n    nextTick(fn);\n}\n\nfunction tryOnUnmounted(fn, target) {\n  const instance = getLifeCycleTarget(target);\n  if (instance)\n    onUnmounted(fn, target);\n}\n\nfunction createUntil(r, isNot = false) {\n  function toMatch(condition, { flush = \"sync\", deep = false, timeout, throwOnTimeout } = {}) {\n    let stop = null;\n    const watcher = new Promise((resolve) => {\n      stop = watch(\n        r,\n        (v) => {\n          if (condition(v) !== isNot) {\n            if (stop)\n              stop();\n            else\n              nextTick(() => stop == null ? void 0 : stop());\n            resolve(v);\n          }\n        },\n        {\n          flush,\n          deep,\n          immediate: true\n        }\n      );\n    });\n    const promises = [watcher];\n    if (timeout != null) {\n      promises.push(\n        promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => stop == null ? void 0 : stop())\n      );\n    }\n    return Promise.race(promises);\n  }\n  function toBe(value, options) {\n    if (!isRef(value))\n      return toMatch((v) => v === value, options);\n    const { flush = \"sync\", deep = false, timeout, throwOnTimeout } = options != null ? options : {};\n    let stop = null;\n    const watcher = new Promise((resolve) => {\n      stop = watch(\n        [r, value],\n        ([v1, v2]) => {\n          if (isNot !== (v1 === v2)) {\n            if (stop)\n              stop();\n            else\n              nextTick(() => stop == null ? void 0 : stop());\n            resolve(v1);\n          }\n        },\n        {\n          flush,\n          deep,\n          immediate: true\n        }\n      );\n    });\n    const promises = [watcher];\n    if (timeout != null) {\n      promises.push(\n        promiseTimeout(timeout, throwOnTimeout).then(() => toValue(r)).finally(() => {\n          stop == null ? void 0 : stop();\n          return toValue(r);\n        })\n      );\n    }\n    return Promise.race(promises);\n  }\n  function toBeTruthy(options) {\n    return toMatch((v) => Boolean(v), options);\n  }\n  function toBeNull(options) {\n    return toBe(null, options);\n  }\n  function toBeUndefined(options) {\n    return toBe(void 0, options);\n  }\n  function toBeNaN(options) {\n    return toMatch(Number.isNaN, options);\n  }\n  function toContains(value, options) {\n    return toMatch((v) => {\n      const array = Array.from(v);\n      return array.includes(value) || array.includes(toValue(value));\n    }, options);\n  }\n  function changed(options) {\n    return changedTimes(1, options);\n  }\n  function changedTimes(n = 1, options) {\n    let count = -1;\n    return toMatch(() => {\n      count += 1;\n      return count >= n;\n    }, options);\n  }\n  if (Array.isArray(toValue(r))) {\n    const instance = {\n      toMatch,\n      toContains,\n      changed,\n      changedTimes,\n      get not() {\n        return createUntil(r, !isNot);\n      }\n    };\n    return instance;\n  } else {\n    const instance = {\n      toMatch,\n      toBe,\n      toBeTruthy,\n      toBeNull,\n      toBeNaN,\n      toBeUndefined,\n      changed,\n      changedTimes,\n      get not() {\n        return createUntil(r, !isNot);\n      }\n    };\n    return instance;\n  }\n}\nfunction until(r) {\n  return createUntil(r);\n}\n\nfunction defaultComparator(value, othVal) {\n  return value === othVal;\n}\nfunction useArrayDifference(...args) {\n  var _a;\n  const list = args[0];\n  const values = args[1];\n  let compareFn = (_a = args[2]) != null ? _a : defaultComparator;\n  if (typeof compareFn === \"string\") {\n    const key = compareFn;\n    compareFn = (value, othVal) => value[key] === othVal[key];\n  }\n  return computed(() => toValue(list).filter((x) => toValue(values).findIndex((y) => compareFn(x, y)) === -1));\n}\n\nfunction useArrayEvery(list, fn) {\n  return computed(() => toValue(list).every((element, index, array) => fn(toValue(element), index, array)));\n}\n\nfunction useArrayFilter(list, fn) {\n  return computed(() => toValue(list).map((i) => toValue(i)).filter(fn));\n}\n\nfunction useArrayFind(list, fn) {\n  return computed(() => toValue(\n    toValue(list).find((element, index, array) => fn(toValue(element), index, array))\n  ));\n}\n\nfunction useArrayFindIndex(list, fn) {\n  return computed(() => toValue(list).findIndex((element, index, array) => fn(toValue(element), index, array)));\n}\n\nfunction findLast(arr, cb) {\n  let index = arr.length;\n  while (index-- > 0) {\n    if (cb(arr[index], index, arr))\n      return arr[index];\n  }\n  return void 0;\n}\nfunction useArrayFindLast(list, fn) {\n  return computed(() => toValue(\n    !Array.prototype.findLast ? findLast(toValue(list), (element, index, array) => fn(toValue(element), index, array)) : toValue(list).findLast((element, index, array) => fn(toValue(element), index, array))\n  ));\n}\n\nfunction isArrayIncludesOptions(obj) {\n  return isObject(obj) && containsProp(obj, \"formIndex\", \"comparator\");\n}\nfunction useArrayIncludes(...args) {\n  var _a;\n  const list = args[0];\n  const value = args[1];\n  let comparator = args[2];\n  let formIndex = 0;\n  if (isArrayIncludesOptions(comparator)) {\n    formIndex = (_a = comparator.fromIndex) != null ? _a : 0;\n    comparator = comparator.comparator;\n  }\n  if (typeof comparator === \"string\") {\n    const key = comparator;\n    comparator = (element, value2) => element[key] === toValue(value2);\n  }\n  comparator = comparator != null ? comparator : (element, value2) => element === toValue(value2);\n  return computed(() => toValue(list).slice(formIndex).some((element, index, array) => comparator(\n    toValue(element),\n    toValue(value),\n    index,\n    toValue(array)\n  )));\n}\n\nfunction useArrayJoin(list, separator) {\n  return computed(() => toValue(list).map((i) => toValue(i)).join(toValue(separator)));\n}\n\nfunction useArrayMap(list, fn) {\n  return computed(() => toValue(list).map((i) => toValue(i)).map(fn));\n}\n\nfunction useArrayReduce(list, reducer, ...args) {\n  const reduceCallback = (sum, value, index) => reducer(toValue(sum), toValue(value), index);\n  return computed(() => {\n    const resolved = toValue(list);\n    return args.length ? resolved.reduce(reduceCallback, typeof args[0] === \"function\" ? toValue(args[0]()) : toValue(args[0])) : resolved.reduce(reduceCallback);\n  });\n}\n\nfunction useArraySome(list, fn) {\n  return computed(() => toValue(list).some((element, index, array) => fn(toValue(element), index, array)));\n}\n\nfunction uniq(array) {\n  return Array.from(new Set(array));\n}\nfunction uniqueElementsBy(array, fn) {\n  return array.reduce((acc, v) => {\n    if (!acc.some((x) => fn(v, x, array)))\n      acc.push(v);\n    return acc;\n  }, []);\n}\nfunction useArrayUnique(list, compareFn) {\n  return computed(() => {\n    const resolvedList = toValue(list).map((element) => toValue(element));\n    return compareFn ? uniqueElementsBy(resolvedList, compareFn) : uniq(resolvedList);\n  });\n}\n\nfunction useCounter(initialValue = 0, options = {}) {\n  let _initialValue = unref(initialValue);\n  const count = ref(initialValue);\n  const {\n    max = Number.POSITIVE_INFINITY,\n    min = Number.NEGATIVE_INFINITY\n  } = options;\n  const inc = (delta = 1) => count.value = Math.max(Math.min(max, count.value + delta), min);\n  const dec = (delta = 1) => count.value = Math.min(Math.max(min, count.value - delta), max);\n  const get = () => count.value;\n  const set = (val) => count.value = Math.max(min, Math.min(max, val));\n  const reset = (val = _initialValue) => {\n    _initialValue = val;\n    return set(val);\n  };\n  return { count, inc, dec, get, set, reset };\n}\n\nconst REGEX_PARSE = /^(\\d{4})[-/]?(\\d{1,2})?[-/]?(\\d{0,2})[T\\s]*(\\d{1,2})?:?(\\d{1,2})?:?(\\d{1,2})?[.:]?(\\d+)?$/i;\nconst REGEX_FORMAT = /[YMDHhms]o|\\[([^\\]]+)\\]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a{1,2}|A{1,2}|m{1,2}|s{1,2}|Z{1,2}|SSS/g;\nfunction defaultMeridiem(hours, minutes, isLowercase, hasPeriod) {\n  let m = hours < 12 ? \"AM\" : \"PM\";\n  if (hasPeriod)\n    m = m.split(\"\").reduce((acc, curr) => acc += `${curr}.`, \"\");\n  return isLowercase ? m.toLowerCase() : m;\n}\nfunction formatOrdinal(num) {\n  const suffixes = [\"th\", \"st\", \"nd\", \"rd\"];\n  const v = num % 100;\n  return num + (suffixes[(v - 20) % 10] || suffixes[v] || suffixes[0]);\n}\nfunction formatDate(date, formatStr, options = {}) {\n  var _a;\n  const years = date.getFullYear();\n  const month = date.getMonth();\n  const days = date.getDate();\n  const hours = date.getHours();\n  const minutes = date.getMinutes();\n  const seconds = date.getSeconds();\n  const milliseconds = date.getMilliseconds();\n  const day = date.getDay();\n  const meridiem = (_a = options.customMeridiem) != null ? _a : defaultMeridiem;\n  const matches = {\n    Yo: () => formatOrdinal(years),\n    YY: () => String(years).slice(-2),\n    YYYY: () => years,\n    M: () => month + 1,\n    Mo: () => formatOrdinal(month + 1),\n    MM: () => `${month + 1}`.padStart(2, \"0\"),\n    MMM: () => date.toLocaleDateString(toValue(options.locales), { month: \"short\" }),\n    MMMM: () => date.toLocaleDateString(toValue(options.locales), { month: \"long\" }),\n    D: () => String(days),\n    Do: () => formatOrdinal(days),\n    DD: () => `${days}`.padStart(2, \"0\"),\n    H: () => String(hours),\n    Ho: () => formatOrdinal(hours),\n    HH: () => `${hours}`.padStart(2, \"0\"),\n    h: () => `${hours % 12 || 12}`.padStart(1, \"0\"),\n    ho: () => formatOrdinal(hours % 12 || 12),\n    hh: () => `${hours % 12 || 12}`.padStart(2, \"0\"),\n    m: () => String(minutes),\n    mo: () => formatOrdinal(minutes),\n    mm: () => `${minutes}`.padStart(2, \"0\"),\n    s: () => String(seconds),\n    so: () => formatOrdinal(seconds),\n    ss: () => `${seconds}`.padStart(2, \"0\"),\n    SSS: () => `${milliseconds}`.padStart(3, \"0\"),\n    d: () => day,\n    dd: () => date.toLocaleDateString(toValue(options.locales), { weekday: \"narrow\" }),\n    ddd: () => date.toLocaleDateString(toValue(options.locales), { weekday: \"short\" }),\n    dddd: () => date.toLocaleDateString(toValue(options.locales), { weekday: \"long\" }),\n    A: () => meridiem(hours, minutes),\n    AA: () => meridiem(hours, minutes, false, true),\n    a: () => meridiem(hours, minutes, true),\n    aa: () => meridiem(hours, minutes, true, true)\n  };\n  return formatStr.replace(REGEX_FORMAT, (match, $1) => {\n    var _a2, _b;\n    return (_b = $1 != null ? $1 : (_a2 = matches[match]) == null ? void 0 : _a2.call(matches)) != null ? _b : match;\n  });\n}\nfunction normalizeDate(date) {\n  if (date === null)\n    return new Date(Number.NaN);\n  if (date === void 0)\n    return /* @__PURE__ */ new Date();\n  if (date instanceof Date)\n    return new Date(date);\n  if (typeof date === \"string\" && !/Z$/i.test(date)) {\n    const d = date.match(REGEX_PARSE);\n    if (d) {\n      const m = d[2] - 1 || 0;\n      const ms = (d[7] || \"0\").substring(0, 3);\n      return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);\n    }\n  }\n  return new Date(date);\n}\nfunction useDateFormat(date, formatStr = \"HH:mm:ss\", options = {}) {\n  return computed(() => formatDate(normalizeDate(toValue(date)), toValue(formatStr), options));\n}\n\nfunction useIntervalFn(cb, interval = 1e3, options = {}) {\n  const {\n    immediate = true,\n    immediateCallback = false\n  } = options;\n  let timer = null;\n  const isActive = ref(false);\n  function clean() {\n    if (timer) {\n      clearInterval(timer);\n      timer = null;\n    }\n  }\n  function pause() {\n    isActive.value = false;\n    clean();\n  }\n  function resume() {\n    const intervalValue = toValue(interval);\n    if (intervalValue <= 0)\n      return;\n    isActive.value = true;\n    if (immediateCallback)\n      cb();\n    clean();\n    if (isActive.value)\n      timer = setInterval(cb, intervalValue);\n  }\n  if (immediate && isClient)\n    resume();\n  if (isRef(interval) || typeof interval === \"function\") {\n    const stopWatch = watch(interval, () => {\n      if (isActive.value && isClient)\n        resume();\n    });\n    tryOnScopeDispose(stopWatch);\n  }\n  tryOnScopeDispose(pause);\n  return {\n    isActive,\n    pause,\n    resume\n  };\n}\n\nfunction useInterval(interval = 1e3, options = {}) {\n  const {\n    controls: exposeControls = false,\n    immediate = true,\n    callback\n  } = options;\n  const counter = ref(0);\n  const update = () => counter.value += 1;\n  const reset = () => {\n    counter.value = 0;\n  };\n  const controls = useIntervalFn(\n    callback ? () => {\n      update();\n      callback(counter.value);\n    } : update,\n    interval,\n    { immediate }\n  );\n  if (exposeControls) {\n    return {\n      counter,\n      reset,\n      ...controls\n    };\n  } else {\n    return counter;\n  }\n}\n\nfunction useLastChanged(source, options = {}) {\n  var _a;\n  const ms = ref((_a = options.initialValue) != null ? _a : null);\n  watch(\n    source,\n    () => ms.value = timestamp(),\n    options\n  );\n  return ms;\n}\n\nfunction useTimeoutFn(cb, interval, options = {}) {\n  const {\n    immediate = true\n  } = options;\n  const isPending = ref(false);\n  let timer = null;\n  function clear() {\n    if (timer) {\n      clearTimeout(timer);\n      timer = null;\n    }\n  }\n  function stop() {\n    isPending.value = false;\n    clear();\n  }\n  function start(...args) {\n    clear();\n    isPending.value = true;\n    timer = setTimeout(() => {\n      isPending.value = false;\n      timer = null;\n      cb(...args);\n    }, toValue(interval));\n  }\n  if (immediate) {\n    isPending.value = true;\n    if (isClient)\n      start();\n  }\n  tryOnScopeDispose(stop);\n  return {\n    isPending: readonly(isPending),\n    start,\n    stop\n  };\n}\n\nfunction useTimeout(interval = 1e3, options = {}) {\n  const {\n    controls: exposeControls = false,\n    callback\n  } = options;\n  const controls = useTimeoutFn(\n    callback != null ? callback : noop,\n    interval,\n    options\n  );\n  const ready = computed(() => !controls.isPending.value);\n  if (exposeControls) {\n    return {\n      ready,\n      ...controls\n    };\n  } else {\n    return ready;\n  }\n}\n\nfunction useToNumber(value, options = {}) {\n  const {\n    method = \"parseFloat\",\n    radix,\n    nanToZero\n  } = options;\n  return computed(() => {\n    let resolved = toValue(value);\n    if (typeof resolved === \"string\")\n      resolved = Number[method](resolved, radix);\n    if (nanToZero && Number.isNaN(resolved))\n      resolved = 0;\n    return resolved;\n  });\n}\n\nfunction useToString(value) {\n  return computed(() => `${toValue(value)}`);\n}\n\nfunction useToggle(initialValue = false, options = {}) {\n  const {\n    truthyValue = true,\n    falsyValue = false\n  } = options;\n  const valueIsRef = isRef(initialValue);\n  const _value = ref(initialValue);\n  function toggle(value) {\n    if (arguments.length) {\n      _value.value = value;\n      return _value.value;\n    } else {\n      const truthy = toValue(truthyValue);\n      _value.value = _value.value === truthy ? toValue(falsyValue) : truthy;\n      return _value.value;\n    }\n  }\n  if (valueIsRef)\n    return toggle;\n  else\n    return [_value, toggle];\n}\n\nfunction watchArray(source, cb, options) {\n  let oldList = (options == null ? void 0 : options.immediate) ? [] : [...source instanceof Function ? source() : Array.isArray(source) ? source : toValue(source)];\n  return watch(source, (newList, _, onCleanup) => {\n    const oldListRemains = Array.from({ length: oldList.length });\n    const added = [];\n    for (const obj of newList) {\n      let found = false;\n      for (let i = 0; i < oldList.length; i++) {\n        if (!oldListRemains[i] && obj === oldList[i]) {\n          oldListRemains[i] = true;\n          found = true;\n          break;\n        }\n      }\n      if (!found)\n        added.push(obj);\n    }\n    const removed = oldList.filter((_2, i) => !oldListRemains[i]);\n    cb(newList, oldList, added, removed, onCleanup);\n    oldList = [...newList];\n  }, options);\n}\n\nfunction watchAtMost(source, cb, options) {\n  const {\n    count,\n    ...watchOptions\n  } = options;\n  const current = ref(0);\n  const stop = watchWithFilter(\n    source,\n    (...args) => {\n      current.value += 1;\n      if (current.value >= toValue(count))\n        nextTick(() => stop());\n      cb(...args);\n    },\n    watchOptions\n  );\n  return { count: current, stop };\n}\n\nfunction watchDebounced(source, cb, options = {}) {\n  const {\n    debounce = 0,\n    maxWait = void 0,\n    ...watchOptions\n  } = options;\n  return watchWithFilter(\n    source,\n    cb,\n    {\n      ...watchOptions,\n      eventFilter: debounceFilter(debounce, { maxWait })\n    }\n  );\n}\n\nfunction watchDeep(source, cb, options) {\n  return watch(\n    source,\n    cb,\n    {\n      ...options,\n      deep: true\n    }\n  );\n}\n\nfunction watchIgnorable(source, cb, options = {}) {\n  const {\n    eventFilter = bypassFilter,\n    ...watchOptions\n  } = options;\n  const filteredCb = createFilterWrapper(\n    eventFilter,\n    cb\n  );\n  let ignoreUpdates;\n  let ignorePrevAsyncUpdates;\n  let stop;\n  if (watchOptions.flush === \"sync\") {\n    const ignore = ref(false);\n    ignorePrevAsyncUpdates = () => {\n    };\n    ignoreUpdates = (updater) => {\n      ignore.value = true;\n      updater();\n      ignore.value = false;\n    };\n    stop = watch(\n      source,\n      (...args) => {\n        if (!ignore.value)\n          filteredCb(...args);\n      },\n      watchOptions\n    );\n  } else {\n    const disposables = [];\n    const ignoreCounter = ref(0);\n    const syncCounter = ref(0);\n    ignorePrevAsyncUpdates = () => {\n      ignoreCounter.value = syncCounter.value;\n    };\n    disposables.push(\n      watch(\n        source,\n        () => {\n          syncCounter.value++;\n        },\n        { ...watchOptions, flush: \"sync\" }\n      )\n    );\n    ignoreUpdates = (updater) => {\n      const syncCounterPrev = syncCounter.value;\n      updater();\n      ignoreCounter.value += syncCounter.value - syncCounterPrev;\n    };\n    disposables.push(\n      watch(\n        source,\n        (...args) => {\n          const ignore = ignoreCounter.value > 0 && ignoreCounter.value === syncCounter.value;\n          ignoreCounter.value = 0;\n          syncCounter.value = 0;\n          if (ignore)\n            return;\n          filteredCb(...args);\n        },\n        watchOptions\n      )\n    );\n    stop = () => {\n      disposables.forEach((fn) => fn());\n    };\n  }\n  return { stop, ignoreUpdates, ignorePrevAsyncUpdates };\n}\n\nfunction watchImmediate(source, cb, options) {\n  return watch(\n    source,\n    cb,\n    {\n      ...options,\n      immediate: true\n    }\n  );\n}\n\nfunction watchOnce(source, cb, options) {\n  const stop = watch(source, (...args) => {\n    nextTick(() => stop());\n    return cb(...args);\n  }, options);\n  return stop;\n}\n\nfunction watchThrottled(source, cb, options = {}) {\n  const {\n    throttle = 0,\n    trailing = true,\n    leading = true,\n    ...watchOptions\n  } = options;\n  return watchWithFilter(\n    source,\n    cb,\n    {\n      ...watchOptions,\n      eventFilter: throttleFilter(throttle, trailing, leading)\n    }\n  );\n}\n\nfunction watchTriggerable(source, cb, options = {}) {\n  let cleanupFn;\n  function onEffect() {\n    if (!cleanupFn)\n      return;\n    const fn = cleanupFn;\n    cleanupFn = void 0;\n    fn();\n  }\n  function onCleanup(callback) {\n    cleanupFn = callback;\n  }\n  const _cb = (value, oldValue) => {\n    onEffect();\n    return cb(value, oldValue, onCleanup);\n  };\n  const res = watchIgnorable(source, _cb, options);\n  const { ignoreUpdates } = res;\n  const trigger = () => {\n    let res2;\n    ignoreUpdates(() => {\n      res2 = _cb(getWatchSources(source), getOldValue(source));\n    });\n    return res2;\n  };\n  return {\n    ...res,\n    trigger\n  };\n}\nfunction getWatchSources(sources) {\n  if (isReactive(sources))\n    return sources;\n  if (Array.isArray(sources))\n    return sources.map((item) => toValue(item));\n  return toValue(sources);\n}\nfunction getOldValue(source) {\n  return Array.isArray(source) ? source.map(() => void 0) : void 0;\n}\n\nfunction whenever(source, cb, options) {\n  const stop = watch(\n    source,\n    (v, ov, onInvalidate) => {\n      if (v) {\n        if (options == null ? void 0 : options.once)\n          nextTick(() => stop());\n        cb(v, ov, onInvalidate);\n      }\n    },\n    {\n      ...options,\n      once: false\n    }\n  );\n  return stop;\n}\n\nexport { assert, refAutoReset as autoResetRef, bypassFilter, camelize, clamp, computedEager, computedWithControl, containsProp, computedWithControl as controlledComputed, controlledRef, createEventHook, createFilterWrapper, createGlobalState, createInjectionState, reactify as createReactiveFn, createSharedComposable, createSingletonPromise, debounceFilter, refDebounced as debouncedRef, watchDebounced as debouncedWatch, directiveHooks, computedEager as eagerComputed, extendRef, formatDate, get, getLifeCycleTarget, hasOwn, hyphenate, identity, watchIgnorable as ignorableWatch, increaseWithUnit, injectLocal, invoke, isClient, isDef, isDefined, isIOS, isObject, isWorker, makeDestructurable, noop, normalizeDate, notNullish, now, objectEntries, objectOmit, objectPick, pausableFilter, watchPausable as pausableWatch, promiseTimeout, provideLocal, rand, reactify, reactifyObject, reactiveComputed, reactiveOmit, reactivePick, refAutoReset, refDebounced, refDefault, refThrottled, refWithControl, resolveRef, resolveUnref, set, syncRef, syncRefs, throttleFilter, refThrottled as throttledRef, watchThrottled as throttledWatch, timestamp, toReactive, toRef, toRefs, toValue, tryOnBeforeMount, tryOnBeforeUnmount, tryOnMounted, tryOnScopeDispose, tryOnUnmounted, until, useArrayDifference, useArrayEvery, useArrayFilter, useArrayFind, useArrayFindIndex, useArrayFindLast, useArrayIncludes, useArrayJoin, useArrayMap, useArrayReduce, useArraySome, useArrayUnique, useCounter, useDateFormat, refDebounced as useDebounce, useDebounceFn, useInterval, useIntervalFn, useLastChanged, refThrottled as useThrottle, useThrottleFn, useTimeout, useTimeoutFn, useToNumber, useToString, useToggle, watchArray, watchAtMost, watchDebounced, watchDeep, watchIgnorable, watchImmediate, watchOnce, watchPausable, watchThrottled, watchTriggerable, watchWithFilter, whenever };\n"],"names":["storeKey","useStore","key","inject","forEachValue","obj","fn","Object","keys","forEach","isObject","isPromise","val","then","partial","arg","genericSubscribe","subs","options","indexOf","prepend","unshift","push","i","splice","resetStore","store","hot","_actions","create","_mutations","_wrappedGetters","_modulesNamespaceMap","state","installModule","_modules","root","resetStoreState","oldState","_state","oldScope","_scope","getters","_makeLocalGettersCache","wrappedGetters","computedObj","computedCache","scope","effectScope","run","computed","defineProperty","get","value","enumerable","reactive","data","strict","enableStrictMode","_withCommit","stop","rootState","path","module","isRoot","length","namespace","getNamespace","namespaced","parentState","getNestedState","slice","moduleName","local","context","makeLocalContext","forEachMutation","mutation","namespacedType","registerMutation","forEachAction","action","type","handler","registerAction","forEachGetter","getter","registerGetter","forEachChild","child","concat","noNamespace","dispatch","_type","_payload","_options","args","unifyObjectStyle","payload","commit","defineProperties","makeLocalGetters","gettersProxy","splitPos","localType","entry","call","res","rootGetters","Promise","resolve","_devtoolHook","catch","err","emit","rawGetter","watch","process","deep","flush","reduce","LABEL_VUEX_BINDINGS","MUTATIONS_LAYER_ID","ACTIONS_LAYER_ID","INSPECTOR_ID","actionId","addDevtools","app","setupDevtoolsPlugin","id","label","homepage","logo","packageName","componentStateTypes","api","addTimelineLayer","color","COLOR_LIME_500","addInspector","icon","treeFilterPlaceholder","on","getInspectorTree","inspectorId","filter","nodes","flattenStoreForInspectorTree","rootNodes","formatStoreForInspectorTree","getInspectorState","modulePath","nodeId","formatStoreForInspectorState","getStoreModule","editInspectorState","split","Boolean","set","subscribe","notifyComponentUpdate","sendInspectorTree","sendInspectorState","addTimelineEvent","layerId","event","time","Date","now","title","subscribeAction","before","_id","_time","groupId","subtitle","after","duration","_custom","display","tooltip","COLOR_DARK","COLOR_WHITE","TAG_NAMESPACED","textColor","backgroundColor","extractNameFromPath","tags","children","_children","map","result","includes","endsWith","gettersKeys","storeState","editable","tree","transformPathsToObjectTree","canThrow","target","leafKey","pop","p","abstract","moduleMap","names","n","Error","cb","e","Module","rawModule","runtime","this","_rawModule","rawState","prototypeAccessors$1","configurable","prototype","addChild","removeChild","getChild","hasChild","update","actions","mutations","ModuleCollection","rawRootModule","register","targetModule","newModule","modules","this$1$1","parent","rawChildModule","unregister","isRegistered","createStore","Store","plugins","devtools","_committing","_actionSubscribers","_subscribers","_devtools","ref","plugin","prototypeAccessors","install","injectKey","provide","config","globalProperties","$store","useDevtools","undefined","v","sub","all","reject","error","assign","replaceState","registerModule","preserveState","unregisterModule","hasModule","hotUpdate","newOptions","committing","normalizeNamespace","states","normalizeMap","getModuleByNamespace","vuex","len","arguments","apply","isValidMap","Array","isArray","charAt","helper","defaultWindow","isClient","window","document","navigator","location","unrefElement","elRef","_a","plain","toValue","$el","useEventListener","events","listeners","_len3","_key3","noop","cleanups","cleanup","el","listener","options2","addEventListener","removeEventListener","stopWatch","_ref4","optionsClone","flatMap","immediate","tryOnScopeDispose","_iOSWorkaround","onClickOutside","ignore","capture","detectIframe","isIOS","from","body","documentElement","shouldListen","shouldIgnore","some","target2","querySelectorAll","composedPath","detail","isProcessingClick","setTimeout","passive","activeElement","tagName","contains","createKeyPredicate","keyFilter","onKeyStroke","eventName","dedupe","predicate","repeat","globalThis","global","self","useConfirmDialog","revealed","confirmHook","createEventHook","cancelHook","revealHook","_resolve","reveal","trigger","confirm","isCanceled","cancel","isRevealed","onReveal","onConfirm","onCancel","useCycleList","list","shallowRef","getInitialValue","listRef","toRef","index","targetList","index2","getIndexOf","fallbackIndex","shift","delta","next","prev","_b","initialValue","go","Number","POSITIVE_INFINITY","_TransitionPresets","easeInSine","easeOutSine","easeInOutSine","easeInQuad","easeOutQuad","easeInOutQuad","easeInCubic","easeOutCubic","easeInOutCubic","easeInQuart","easeOutQuart","easeInOutQuart","easeInQuint","easeOutQuint","easeInOutQuint","easeInExpo","easeOutExpo","easeInOutExpo","easeInCirc","easeOutCirc","easeInOutCirc","easeInBack","easeOutBack","easeInOutBack","identity","_typeof","Symbol","iterator","constructor","_classCallCheck","instance","Constructor","TypeError","_defineProperties","props","descriptor","writable","_createClass","protoProps","staticProps","_defineProperty","ownKeys","object","enumerableOnly","getOwnPropertySymbols","symbols","sym","getOwnPropertyDescriptor","_objectSpread2","source","getOwnPropertyDescriptors","_toConsumableArray","arr","_arrayWithoutHoles","_iterableToArray","_unsupportedIterableToArray","_nonIterableSpread","_arrayLikeToArray","iter","o","minLen","toString","name","test","arr2","upperFirstChar","str","toUpperCase","isServer","deepCopy","to","shallow","isUndef","item","isPlainObj","mergeObject","force","defineReactive","souceKey","isIE","agent","userAgent","toLowerCase","isIos","u","match","_","NOOP","getNumericValue","distance","size","number","exec","log","msg","console","warn","baseConfig","vuescroll","sizeStrategy","detectResize","locking","scrollPanel","initialScrollY","initialScrollX","scrollingX","scrollingY","speed","easing","verticalNativeBarPos","maxHeight","maxWidth","rail","background","opacity","border","specifyBorderRadius","gutterOfEnds","gutterOfSide","keepShow","bar","showDelay","onlyShowBarOnScroll","minSize","disable","scrollButton","enable","step","mousedownStep","validateOps","ops","renderError","_ops$bar","vBar","hBar","_ops$rail","vRail","hRail","String","_extraValidate","hasError","scrollBarWidth","zoomManager","extendOpts","extraOpts","extraValidate","opts","modes","__REFRESH_DOM_NAME","__LOAD_DOM_NAME","ZoomManager","_this","originPixelRatio","getRatio","lastPixelRatio","ratio","screen","ua","devicePixelRatio","deviceXDPI","logicalXDPI","outerWidth","innerWidth","Math","round","getGutter","getRatioBetweenPreAndCurrent","outer","createElement","style","visibility","width","position","top","appendChild","widthNoScroll","offsetWidth","overflow","inner","widthWithScroll","parentNode","eventCenter","dom","hander","isChildInParent","flag","nodeType","_isVuescroll","getPrefix","engine","docStyle","opera","cpuClass","vendorPrefix","trident","gecko","webkit","presto","getComplitableStyle","property","compatibleValue","testElm","insertChildrenIntoSlot","parentVnodeFunc","childVNodeFunc","parentVnode","childVNode","_getVnodeInfo","getVnodeInfo","ch","tag","newCh","h","vnode","firstVnode","getRealParent","ctx","$parent","$data","_isVuescrollRoot","createStyle","styleId","cssText","getElementById","head","doc","getElementsByTagName","styleSheet","createTextNode","createHideBarStyle","createSlideModeStyle","getCurrentViewportDom","container","domFragment","isCurrentview","_dom$getBoundingClien","getBoundingClientRect","left","height","_container$getBoundin","parentLeft","parentTop","parentHeight","parentWidth","isResizeElm","scrollMap","vertical","opsSize","posName","opposName","sidePosName","page","scroll","scrollSize","offset","client","axis","start","end","horizontal","TouchManager","originEvent","touchObject","isTouch","touches","platform","touch","maxTouchPoints","msMaxTouchPoints","nonDeskTouch","eventType","touchstart","touchend","touchmove","touchenter","touchleave","touchcancel","startsWith","createEasingFunction","easingPattern","pattern","requestAnimationFrame","requestFrame","webkitRequestAnimationFrame","mozRequestAnimationFrame","oRequestAnimationFrame","isNative","callback","TARGET_FPS","requests","rafHandle","intervalHandle","lastActive","callbackHandle","setInterval","currentRequests","hasOwnProperty","clearInterval","getTime","ScrollControl","init","isRunning","isPaused","isStopped","ts","percent","spd","execScroll","st","ed","stepCb","completeCb","vertifyCb","easingMethod","df","dir","nt","loop","warn$1","scrollTo","elm","x","y","scrollLeft","scrollTop","scrollHeight","scrollWidth","clientWidth","clientHeight","scrollingComplete","_elm","scrollX","scrollY","scrollingElement","_elm2","startScroll","dx","dy","nativeApi","mounted","methods","nativeStop","nativePause","pause","nativeContinue","nativeScrollTo","mergedOptions","scrollPanelElm","bind","getCurrentviewDomNative","scrollContentElm","warn$2","vsInstances","$","uid","beforeUnmount","_ref","internalScrollTo","scrollBy","_ref2","_ref2$dx","_ref2$dy","_this$getPosition","getPosition","_this$getPosition$scr","_this$getPosition$scr2","scrollIntoView","animate","parentElm","querySelector","_this$$el$getBounding","_elm$getBoundingClien","childLeft","childTop","diffX","diffY","refresh","refreshInternalStatus","$nextTick","refreshAll","vs","_extends","a","b","c","d","normalMerge","toArrayMerge","functionalMerge","mergeJsxProps","f","g","mergeFn","ScrollPanel","required","updateInitialScroll","_isDestroyed","render","boxSizing","_customPanel","$slots","colorCache","rgbReg","extractRgbColor","getRgbAColor","div","computedColor","getComputedStyle","Scrollbar","hideBar","otherBarHide","barSize","max","barRatio","_style","_style2","_barStyle","vm","railBackgroundColor","railSize","endPos","touchObj","touchManager","getTouchObject","borderRadius","setRailHover","setRailLeave","buttonSize","barWrapper","scrollDistance","posValue","pos","setClassHook","barStyle","cursor","margin","transition","right","bottom","_touchObj","createBarEvent","createTrackEvent","createScrollbarButton","isBarDragging","isRailHover","showBar","setBarDrag","$emit","mousedown","getEventObject","stopImmediatePropagation","preventDefault","onselectstart","axisStartPos","$refs","_touchmove","mousemove","_touchend","mouseup","thubmParent","thumb","_ctx$bar","barOffset","currentTarget","_style3","barContext","_barContext$ops$scrol","borderColor","wrapperProps","innerProps","createScrollButtonEvent","timeoutId","_ctx$ops$scrollButton","stepWithDirection","mousedownStepWithDirection","barType","isMouseDown","isMouseout","which","endPress","_touchstart","enter","leave","clearTimeout","pressing","getBarData","refreshLoad","keepShowRail","onSetBarDrag","createBar","verticalBarProps","horizontalBarProps","createComponent","_components","_render","mixins","components","emits","created","_gfc","$vuescrollConfig","propsOps","padding","__vuescroll","classHooks","pointerLeave","updateBarStateAndEmitEvent","_customContainer","_this2","initVariables","initWatchOpsChange","updatedCbs","scrollToAnchor","updated","_this3","destroy","isDragging","currentSizeStrategy","currentScrollState","currentScrollInfo","scrollContent","hasVBar","hasHBar","vBarVisible","hBarVisible","vBarDragging","hBarDragging","clikingVerticalStartButton","clikingVerticalEndButton","clikingHorizontalStartButton","clikingHorizontalEndButton","mouseEnter","showAndDefferedHideBar","forceHideBar","_this4","_this$vuescroll$state","useNumbericSize","_this$mergedOptions$s","_this$$el$parentNode","parentClientHeight","parentClientWidth","_this$scrollPanelElm","usePercentSize","setVsSize","_this$mergedOptions$s2","_this$scrollPanelElm2","_this5","watchOpts","$watch","isSmallChangeThisTick","pullRefresh","tips","pushLoad","scroller","validateHashSelector","hash","lastIndexOf","_install","core","extraConfigs","extraValidators","component","Vue","version","getPanelData","overflowY","overflowX","onScroll","handleScroll","onDOMMouseScroll","onMouseWheel","onMousewheel","scrollYEnable","scrollXEnable","_context$mergedOption","gutter","marginRight","marginLeft","transformOrigin","transform","createPanel","getPanelChildren","viewStyle","_customContent","paddingRight","getPanelData$1","renderMethod","getPanelChildren$1","renderChildren","finalChildren","refrehDomVisiable","createTipDom","pullRefreshTip","loadDomVisiable","pushLoadTip","tip","stage","className","createPanel$1","createPanel$2","mode","installResizeDetection","element","injectObject","hasResized","OBJECT_STYLE","objWrap","tabIndex","onload","contentDocument","defaultView","warn$3","slideApi","slideScrollTo","__maxScrollLeft","__maxScrollTop","zoomBy","factor","originLeft","originTop","zoomTo","level","getCurrentPage","paging","goToPage","dest","triggerRefreshOrLoad","isRefresh","isLoad","getCurrentviewDomSlide","api$1","destX","destY","getCurrentviewDom","desiredFrames","millisecondsPerSecond","running","counter","effect","Animate","cleared","stepCallback","verifyCallback","completedCallback","lastFrame","dropCounter","newRunning","usedId","virtual","droppedFrames","j","min","animatingMethod","noAnimatingMethod","Scroller","__callback","animating","animationDuration","bouncing","snapping","zooming","minZoom","maxZoom","speedMultiplier","animatingEasing","noAnimatingEasing","penetrationDeceleration","penetrationAcceleration","members","__isSingleTouch","__isTracking","__didDecelerationComplete","__isGesturing","__isDragging","__isDecelerating","__isAnimating","__clientLeft","__clientTop","__clientWidth","__clientHeight","__contentWidth","__contentHeight","__snapWidth","__snapHeight","__refreshHeight","__loadHeight","__refreshActive","__refreshActivate","__refreshBeforeDeactivate","__refreshDeactivate","__refreshStart","__loadActive","__loadActivate","__loadBeforeDeactivate","__loadDeactivate","__loadStart","__zoomLevel","__scrollLeft","__scrollTop","__scheduledLeft","__scheduledTop","__scheduledZoom","__currentPageX","__currentPageY","__totalXPage","__totalYPage","__disable","__lastTouchLeft","__lastTouchTop","__lastTouchMove","__positions","__minDecelerationScrollLeft","__minDecelerationScrollTop","__maxDecelerationScrollLeft","__maxDecelerationScrollTop","__decelerationVelocityX","__decelerationVelocityY","setDimensions","contentWidth","contentHeight","noScroll","__computeScrollMax","setPosition","setSnapSize","activatePullToRefresh","activateCallback","deactivateCallback","startCallback","beforeDeactivateCallback","beforeDeactiveEnd","__refreshBeforeDeactiveEnd","activatePushToLoad","__loadBeforeDeactiveEnd","wasDecelerating","__refreshBeforeDeactiveStarted","__publish","__loadBeforeDeactiveStarted","finishRefreshOrLoad","endRefreshActive","endLoadActive","getValues","zoom","getScrollMax","__zoomComplete","oldLevel","startLeft","startTop","__computePage","_ref3","isNaN","doMouseZoom","wheelDelta","timeStamp","pageX","pageY","change","doTouchStart","valueOf","currentTouchLeft","currentTouchTop","__interruptedAnimation","isSingleTouch","abs","__initialTouchLeft","__initialTouchTop","__zoomLevelStart","__lastScale","__enableScrollX","__enableScrollY","doTouchMove","scale","positions","moveX","moveY","currentTouchLeftRel","currentTouchTopRel","maxScrollLeft","maxScrollTop","minimumTrackingForScroll","minimumTrackingForDrag","distanceX","distanceY","doTouchEnd","startPos","timeOffset","movedLeft","movedTop","minVelocityToStartDeceleration","__startDeceleration","__scrollComplete","wasAnimating","oldLeft","oldTop","oldZoom","diffLeft","diffTop","diffZoom","verify","completed","renderedFramesPerSecond","animationId","wasFinished","easingFunction","zoomLevel","ceil","floor","__stepThroughDeceleration","minVelocityToKeepDecelerating","shouldContinue","minLeft","maxLeft","minTop","maxTop","bounceX","bounceY","fixedScrollLeft","fixedScrollTop","frictionFactor","scrollOutsideX","scrollOutsideY","content","suffix","undef","helperElem","perspectiveProperty","transformProperty","listenContainer","eventCallback","preventDefaultOnMove","stopPropagation","zoomHandle","_touchcancel","createStateCallbacks","stageType","tipDom","hasListens","listenrWholeName","done","slideMix","vsMounted","refreshStage","loadStage","outTheTopBoundary","outTheBottomBoundary","updateScroller","updateDimesion","registryRefreshLoad","refreshHeight","loadHeight","refreshDom","offsetHeight","marginTop","loadDom","registryEvent","registryScroller","_ref$left","_ref$top","_ref$zoom","_this$mergedOptions$v","_this$mergedOptions$v2","rect","clientLeft","clientTop","_this$mergedOptions$v3","auto","autoLoadDistance","_this$scroller","lockAutoLoad","updateSlideModeBarState","heightPercentage","widthPercentage","outerLeft","outerTop","_this$$el","domName","activateFunc","cbs","getSlidePosition","nativeMix","updateNativeModeBarState","isPercent","getNativePosition","css","checkScrollable","deltaX","deltaY","scrollable","nodeName","ov","_this$getScrollProces","getScrollProcess","isScrollX","isScrollY","isReverse","wheelDirectionReverse","wheelScrollDuration","checkShiftKey","shiftKey","core$1","newVal","destroyScroller","destroyResize","nativeEvent","emitEvent","lastMode","refreshMode","initPos","registryResize","resizeEnable","modeChanged","contentElm","handleWindowResize","$forceUpdate","handleDomResize","currentSize","destroyDomResize","destroyWindowResize","configs","deactive","active","beforeDeactive","configValidator","configs$1","error$1","configValidator$1","configs$2","configValidators","Vuescroll","getCurrentScope","onScopeDispose","fns","Set","off","delete","add","offFn","_len","_key","r","unref","isVue3","WorkerGlobalScope","getIsIOS","createFilterWrapper","wrapper","_len7","_key7","thisArg","debounceFilter","ms","timer","maxTimer","lastRejector","_clearTimeout","timer2","invoke","maxDuration","maxWait","rejectOnCancel","cacheStringFunction","cache","hit","hyphenateRE","camelizeRE","replace","toRef$1","readonly","customRef","useDebounceFn","refDebounced","debounced","updater","useTimeoutFn","interval","isPending","clear","_len14","_key14"],"sourceRoot":""}