{"version":3,"file":"js/97212.49b935cc7d5bb0ae.js","mappings":"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","sources":["webpack://lawline/./resources/assets/js/vue/apps/requirements/components/shared/JurisdictionSelect.vue?327a","webpack://lawline/./resources/assets/js/vue/apps/requirements/components/shared/JurisdictionSelect.vue?9f9e","webpack://lawline/./resources/assets/js/vue/apps/requirements/components/shared/JurisdictionSelect.vue","webpack://lawline/./resources/assets/js/vue/apps/requirements/components/shared/JurisdictionSelect.vue?de2a","webpack://lawline/./resources/assets/js/vue/apps/requirements/components/shared/JurisdictionSelect.vue?1608","webpack://lawline/./node_modules/@popperjs/core/dist/index.mjs","webpack://lawline/./node_modules/@vueuse/core/node_modules/vue-demi/lib/index.mjs","webpack://lawline/./node_modules/@vueuse/core/index.mjs","webpack://lawline/./node_modules/lodash-es/_Set.js","webpack://lawline/./node_modules/lodash-es/_setCacheAdd.js","webpack://lawline/./node_modules/lodash-es/_setCacheHas.js","webpack://lawline/./node_modules/lodash-es/_SetCache.js","webpack://lawline/./node_modules/lodash-es/_stackClear.js","webpack://lawline/./node_modules/lodash-es/_stackDelete.js","webpack://lawline/./node_modules/lodash-es/_stackGet.js","webpack://lawline/./node_modules/lodash-es/_stackHas.js","webpack://lawline/./node_modules/lodash-es/_stackSet.js","webpack://lawline/./node_modules/lodash-es/_Stack.js","webpack://lawline/./node_modules/lodash-es/_Uint8Array.js","webpack://lawline/./node_modules/lodash-es/_baseTimes.js","webpack://lawline/./node_modules/lodash-es/_arrayLikeKeys.js","webpack://lawline/./node_modules/lodash-es/_arrayPush.js","webpack://lawline/./node_modules/lodash-es/_baseFindIndex.js","webpack://lawline/./node_modules/lodash-es/_isFlattenable.js","webpack://lawline/./node_modules/lodash-es/_baseFlatten.js","webpack://lawline/./node_modules/lodash-es/_baseGetAllKeys.js","webpack://lawline/./node_modules/lodash-es/_arraySome.js","webpack://lawline/./node_modules/lodash-es/_equalArrays.js","webpack://lawline/./node_modules/lodash-es/_mapToArray.js","webpack://lawline/./node_modules/lodash-es/_equalByTag.js","webpack://lawline/./node_modules/lodash-es/_equalObjects.js","webpack://lawline/./node_modules/lodash-es/_baseIsEqualDeep.js","webpack://lawline/./node_modules/lodash-es/_baseIsEqual.js","webpack://lawline/./node_modules/lodash-es/_baseIsMatch.js","webpack://lawline/./node_modules/lodash-es/_isStrictComparable.js","webpack://lawline/./node_modules/lodash-es/_getMatchData.js","webpack://lawline/./node_modules/lodash-es/_matchesStrictComparable.js","webpack://lawline/./node_modules/lodash-es/_baseMatches.js","webpack://lawline/./node_modules/lodash-es/_baseMatchesProperty.js","webpack://lawline/./node_modules/lodash-es/_baseProperty.js","webpack://lawline/./node_modules/lodash-es/_basePropertyDeep.js","webpack://lawline/./node_modules/lodash-es/property.js","webpack://lawline/./node_modules/lodash-es/_baseIteratee.js","webpack://lawline/./node_modules/lodash-es/_baseUnary.js","webpack://lawline/./node_modules/lodash-es/_cacheHas.js","webpack://lawline/./node_modules/lodash-es/_flatRest.js","webpack://lawline/./node_modules/lodash-es/_getAllKeys.js","webpack://lawline/./node_modules/lodash-es/_arrayFilter.js","webpack://lawline/./node_modules/lodash-es/_getSymbols.js","webpack://lawline/./node_modules/lodash-es/_DataView.js","webpack://lawline/./node_modules/lodash-es/_Promise.js","webpack://lawline/./node_modules/lodash-es/_WeakMap.js","webpack://lawline/./node_modules/lodash-es/_getTag.js","webpack://lawline/./node_modules/lodash-es/_isPrototype.js","webpack://lawline/./node_modules/lodash-es/_nodeUtil.js","webpack://lawline/./node_modules/lodash-es/_overArg.js","webpack://lawline/./node_modules/lodash-es/_apply.js","webpack://lawline/./node_modules/lodash-es/_overRest.js","webpack://lawline/./node_modules/lodash-es/_setToArray.js","webpack://lawline/./node_modules/lodash-es/constant.js","webpack://lawline/./node_modules/lodash-es/_baseSetToString.js","webpack://lawline/./node_modules/lodash-es/_shortOut.js","webpack://lawline/./node_modules/lodash-es/_setToString.js","webpack://lawline/./node_modules/lodash-es/castArray.js","webpack://lawline/./node_modules/lodash-es/now.js","webpack://lawline/./node_modules/lodash-es/debounce.js","webpack://lawline/./node_modules/lodash-es/toFinite.js","webpack://lawline/./node_modules/lodash-es/toInteger.js","webpack://lawline/./node_modules/lodash-es/findLastIndex.js","webpack://lawline/./node_modules/lodash-es/flatten.js","webpack://lawline/./node_modules/lodash-es/_baseHasIn.js","webpack://lawline/./node_modules/lodash-es/_hasPath.js","webpack://lawline/./node_modules/lodash-es/hasIn.js","webpack://lawline/./node_modules/lodash-es/identity.js","webpack://lawline/./node_modules/lodash-es/_baseIsArguments.js","webpack://lawline/./node_modules/lodash-es/isArguments.js","webpack://lawline/./node_modules/lodash-es/isArrayLike.js","webpack://lawline/./node_modules/lodash-es/stubFalse.js","webpack://lawline/./node_modules/lodash-es/isBuffer.js","webpack://lawline/./node_modules/lodash-es/isEqual.js","webpack://lawline/./node_modules/lodash-es/isLength.js","webpack://lawline/./node_modules/lodash-es/_baseIsTypedArray.js","webpack://lawline/./node_modules/lodash-es/isTypedArray.js","webpack://lawline/./node_modules/lodash-es/isUndefined.js","webpack://lawline/./node_modules/lodash-es/_nativeKeys.js","webpack://lawline/./node_modules/lodash-es/_baseKeys.js","webpack://lawline/./node_modules/lodash-es/keys.js","webpack://lawline/./node_modules/lodash-es/_basePickBy.js","webpack://lawline/./node_modules/lodash-es/_basePick.js","webpack://lawline/./node_modules/lodash-es/pick.js","webpack://lawline/./node_modules/lodash-es/stubArray.js","webpack://lawline/./node_modules/lodash-es/_trimmedEndIndex.js","webpack://lawline/./node_modules/lodash-es/_baseTrim.js","webpack://lawline/./node_modules/lodash-es/toNumber.js"],"sourcesContent":["// Imports\nimport ___CSS_LOADER_API_SOURCEMAP_IMPORT___ from \"../../../../../../../../node_modules/css-loader/dist/runtime/cssWithMappingToString.js\";\nimport ___CSS_LOADER_API_IMPORT___ from \"../../../../../../../../node_modules/css-loader/dist/runtime/api.js\";\nvar ___CSS_LOADER_EXPORT___ = ___CSS_LOADER_API_IMPORT___(___CSS_LOADER_API_SOURCEMAP_IMPORT___);\n// Module\n___CSS_LOADER_EXPORT___.push([module.id, \".state-select .el-select__wrapper{background:none;box-shadow:none}.state-select .el-select__wrapper .el-select__selected-item{color:#fff}.state-select .el-select__wrapper.is-focused,.state-select .el-select__wrapper.is-hovering{box-shadow:none!important}.state-select .el-select__wrapper .el-icon{color:#fff}\", \"\",{\"version\":3,\"sources\":[\"webpack://./resources/assets/js/vue/apps/requirements/components/shared/JurisdictionSelect.vue\"],\"names\":[],\"mappings\":\"AAEI,kCACI,eAAA,CACA,eADR,CAGQ,4DACI,UADZ,CAIQ,2FAEI,yBAHZ,CAMQ,2CACI,UAJZ\",\"sourcesContent\":[\"\\n.state-select {\\n    .el-select__wrapper {\\n        background: none;\\n        box-shadow: none;\\n\\n        .el-select__selected-item {\\n            color: white;\\n        }\\n\\n        &.is-hovering,\\n        &.is-focused {\\n            box-shadow: none !important;\\n        }\\n\\n        .el-icon {\\n            color: white;\\n        }\\n    }\\n}\\n\"],\"sourceRoot\":\"\"}]);\n// Exports\nexport default ___CSS_LOADER_EXPORT___;\n","import { renderSlot as _renderSlot, createElementVNode as _createElementVNode, renderList as _renderList, Fragment as _Fragment, openBlock as _openBlock, createElementBlock as _createElementBlock, resolveComponent as _resolveComponent, createBlock as _createBlock, withCtx as _withCtx, createCommentVNode as _createCommentVNode } from \"vue\";\nvar _hoisted_1 = {\n  \"class\": \"bg-primary\"\n};\nvar _hoisted_2 = {\n  \"class\": \"container flex items-center justify-between px-4 py-6 sm:px-20\"\n};\nvar _hoisted_3 = {\n  \"class\": \"hidden text-xl font-bold text-white sm:text-2xl md:block\"\n};\nvar _hoisted_4 = {\n  key: 1,\n  \"class\": \"skeleton-loader ml-auto h-12 w-full rounded-full bg-gray-300 md:w-1/2\"\n};\nexport function render(_ctx, _cache, $props, $setup, $data, $options) {\n  var _component_el_option = _resolveComponent(\"el-option\");\n  var _component_el_select = _resolveComponent(\"el-select\");\n  return _openBlock(), _createElementBlock(\"div\", _hoisted_1, [_createElementVNode(\"div\", _hoisted_2, [_createElementVNode(\"h4\", _hoisted_3, [_renderSlot(_ctx.$slots, \"default\")]), $options.loaded ? (_openBlock(), _createBlock(_component_el_select, {\n    key: 0,\n    modelValue: $options.selectedJurisdictionSlug,\n    \"onUpdate:modelValue\": _cache[0] || (_cache[0] = function ($event) {\n      return $options.selectedJurisdictionSlug = $event;\n    }),\n    filterable: \"\",\n    placeholder: \"Select \".concat($props.profession.abbr, \" Jurisdiction\"),\n    \"class\": \"state-select ml-auto w-full rounded-full border-2 border-solid border-white px-3 py-1 md:w-1/2 lg:mt-0\",\n    \"popper-append-to-body\": false,\n    size: \"large\",\n    onChange: $options.jurisdictionSelected\n  }, {\n    \"default\": _withCtx(function () {\n      return [(_openBlock(true), _createElementBlock(_Fragment, null, _renderList($options.jurisdictions, function (jurisdiction) {\n        return _openBlock(), _createBlock(_component_el_option, {\n          key: jurisdiction.id,\n          label: $options.getStateName(jurisdiction),\n          value: jurisdiction.slug\n        }, null, 8, [\"label\", \"value\"]);\n      }), 128))];\n    }),\n    _: 1\n  }, 8, [\"modelValue\", \"placeholder\", \"onChange\"])) : (_openBlock(), _createElementBlock(\"div\", _hoisted_4))])]);\n}","function _typeof(obj) { \"@babel/helpers - typeof\"; return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }, _typeof(obj); }\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nfunction _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\nfunction _toPropertyKey(arg) { var key = _toPrimitive(arg, \"string\"); return _typeof(key) === \"symbol\" ? key : String(key); }\nfunction _toPrimitive(input, hint) { if (_typeof(input) !== \"object\" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || \"default\"); if (_typeof(res) !== \"object\") return res; throw new TypeError(\"@@toPrimitive must return a primitive value.\"); } return (hint === \"string\" ? String : Number)(input); }\nimport { mapActions, mapGetters } from 'vuex';\nimport _get from 'lodash/get';\nimport _camelCase from 'lodash/camelCase';\nimport _map from 'lodash/map';\nimport _filter from 'lodash/filter';\nexport default {\n  props: ['profession', 'requirements'],\n  computed: _objectSpread(_objectSpread({}, mapGetters('Requirements', {\n    stateLoaded: 'stateRequirementsLoaded'\n  })), {}, {\n    statesLoaded: function statesLoaded() {\n      return this.$store.getters[\"Requirements/\".concat(_camelCase(this.profession.abbr), \"Requirements\")].loaded;\n    },\n    jurisdictions: function jurisdictions() {\n      var jurisdictions = _map(this.$store.getters[\"Requirements/\".concat(_camelCase(this.profession.abbr), \"Requirements\")].data, 'state');\n      return _filter(jurisdictions, function (jurisdiction) {\n        var specializedJurisdictions = ['TBLS', 'CBLS', 'BLSE'];\n        return !specializedJurisdictions.includes(jurisdiction.abbr);\n      });\n    },\n    selectedJurisdictionSlug: {\n      get: function get() {\n        return _get(this.requirements, 'state.slug');\n      },\n      set: function set(newState) {\n        return newState;\n      }\n    },\n    loaded: function loaded() {\n      if (this.$route.name === 'ProfessionRequirements') {\n        return this.statesLoaded;\n      }\n      return this.statesLoaded && this.stateLoaded;\n    }\n  }),\n  methods: _objectSpread(_objectSpread({}, mapActions('Requirements', ['getStateRequirements', 'updateStateRequirementsType'])), {}, {\n    jurisdictionSelected: function jurisdictionSelected(jurisdictionSlug) {\n      if (this.profession.abbr === 'CLE') {\n        this.updateStateRequirementsType('Experienced');\n      } else {\n        this.updateStateRequirementsType(null);\n      }\n      this.getStateRequirements({\n        professionSlug: this.profession.slug,\n        state: jurisdictionSlug\n      });\n      this.$router.push({\n        name: 'StateRequirements',\n        params: {\n          profession: this.profession.slug,\n          state: jurisdictionSlug\n        }\n      });\n    },\n    getStateName: function getStateName(state) {\n      return state.name === 'General' ? 'Other States' : state.name;\n    }\n  })\n};","/* unplugin-vue-components disabled */import api from \"!../../../../../../../../node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js\";\n            import content from \"!!../../../../../../../../node_modules/css-loader/dist/cjs.js??clonedRuleSet-67.use[1]!../../../../../../../../node_modules/vue-loader/dist/stylePostLoader.js!../../../../../../../../node_modules/postcss-loader/dist/cjs.js??clonedRuleSet-67.use[2]!../../../../../../../../node_modules/sass-loader/dist/cjs.js??clonedRuleSet-67.use[3]!../../../../../../../../node_modules/vue-loader/dist/index.js??ruleSet[0].use[0]!./JurisdictionSelect.vue?vue&type=style&index=0&id=ca52ddc6&lang=scss\";\n\nvar options = {};\n\noptions.insert = \"head\";\noptions.singleton = false;\n\nvar update = api(content, options);\n\n\n\nexport default content.locals || {};","/* unplugin-vue-components disabled */import { render } from \"./JurisdictionSelect.vue?vue&type=template&id=ca52ddc6\"\nimport script from \"./JurisdictionSelect.vue?vue&type=script&lang=js\"\nexport * from \"./JurisdictionSelect.vue?vue&type=script&lang=js\"\n\nimport \"./JurisdictionSelect.vue?vue&type=style&index=0&id=ca52ddc6&lang=scss\"\n\nimport exportComponent from \"../../../../../../../../node_modules/vue-loader/dist/exportHelper.js\"\nconst __exports__ = /*#__PURE__*/exportComponent(script, [['render',render]])\n\nexport default __exports__","var E=\"top\",R=\"bottom\",W=\"right\",P=\"left\",me=\"auto\",G=[E,R,W,P],U=\"start\",J=\"end\",Xe=\"clippingParents\",je=\"viewport\",K=\"popper\",Ye=\"reference\",De=G.reduce(function(t,e){return t.concat([e+\"-\"+U,e+\"-\"+J])},[]),Ee=[].concat(G,[me]).reduce(function(t,e){return t.concat([e,e+\"-\"+U,e+\"-\"+J])},[]),Ge=\"beforeRead\",Je=\"read\",Ke=\"afterRead\",Qe=\"beforeMain\",Ze=\"main\",et=\"afterMain\",tt=\"beforeWrite\",nt=\"write\",rt=\"afterWrite\",ot=[Ge,Je,Ke,Qe,Ze,et,tt,nt,rt];function C(t){return t?(t.nodeName||\"\").toLowerCase():null}function H(t){if(t==null)return window;if(t.toString()!==\"[object Window]\"){var e=t.ownerDocument;return e&&e.defaultView||window}return t}function Q(t){var e=H(t).Element;return t instanceof e||t instanceof Element}function B(t){var e=H(t).HTMLElement;return t instanceof e||t instanceof HTMLElement}function Pe(t){if(typeof ShadowRoot==\"undefined\")return!1;var e=H(t).ShadowRoot;return t instanceof e||t instanceof ShadowRoot}function Mt(t){var e=t.state;Object.keys(e.elements).forEach(function(n){var r=e.styles[n]||{},o=e.attributes[n]||{},i=e.elements[n];!B(i)||!C(i)||(Object.assign(i.style,r),Object.keys(o).forEach(function(a){var s=o[a];s===!1?i.removeAttribute(a):i.setAttribute(a,s===!0?\"\":s)}))})}function Rt(t){var e=t.state,n={popper:{position:e.options.strategy,left:\"0\",top:\"0\",margin:\"0\"},arrow:{position:\"absolute\"},reference:{}};return Object.assign(e.elements.popper.style,n.popper),e.styles=n,e.elements.arrow&&Object.assign(e.elements.arrow.style,n.arrow),function(){Object.keys(e.elements).forEach(function(r){var o=e.elements[r],i=e.attributes[r]||{},a=Object.keys(e.styles.hasOwnProperty(r)?e.styles[r]:n[r]),s=a.reduce(function(f,c){return f[c]=\"\",f},{});!B(o)||!C(o)||(Object.assign(o.style,s),Object.keys(i).forEach(function(f){o.removeAttribute(f)}))})}}var Ae={name:\"applyStyles\",enabled:!0,phase:\"write\",fn:Mt,effect:Rt,requires:[\"computeStyles\"]};function q(t){return t.split(\"-\")[0]}var X=Math.max,ve=Math.min,Z=Math.round;function ee(t,e){e===void 0&&(e=!1);var n=t.getBoundingClientRect(),r=1,o=1;if(B(t)&&e){var i=t.offsetHeight,a=t.offsetWidth;a>0&&(r=Z(n.width)/a||1),i>0&&(o=Z(n.height)/i||1)}return{width:n.width/r,height:n.height/o,top:n.top/o,right:n.right/r,bottom:n.bottom/o,left:n.left/r,x:n.left/r,y:n.top/o}}function ke(t){var e=ee(t),n=t.offsetWidth,r=t.offsetHeight;return Math.abs(e.width-n)<=1&&(n=e.width),Math.abs(e.height-r)<=1&&(r=e.height),{x:t.offsetLeft,y:t.offsetTop,width:n,height:r}}function it(t,e){var n=e.getRootNode&&e.getRootNode();if(t.contains(e))return!0;if(n&&Pe(n)){var r=e;do{if(r&&t.isSameNode(r))return!0;r=r.parentNode||r.host}while(r)}return!1}function N(t){return H(t).getComputedStyle(t)}function Wt(t){return[\"table\",\"td\",\"th\"].indexOf(C(t))>=0}function I(t){return((Q(t)?t.ownerDocument:t.document)||window.document).documentElement}function ge(t){return C(t)===\"html\"?t:t.assignedSlot||t.parentNode||(Pe(t)?t.host:null)||I(t)}function at(t){return!B(t)||N(t).position===\"fixed\"?null:t.offsetParent}function Bt(t){var e=navigator.userAgent.toLowerCase().indexOf(\"firefox\")!==-1,n=navigator.userAgent.indexOf(\"Trident\")!==-1;if(n&&B(t)){var r=N(t);if(r.position===\"fixed\")return null}var o=ge(t);for(Pe(o)&&(o=o.host);B(o)&&[\"html\",\"body\"].indexOf(C(o))<0;){var i=N(o);if(i.transform!==\"none\"||i.perspective!==\"none\"||i.contain===\"paint\"||[\"transform\",\"perspective\"].indexOf(i.willChange)!==-1||e&&i.willChange===\"filter\"||e&&i.filter&&i.filter!==\"none\")return o;o=o.parentNode}return null}function se(t){for(var e=H(t),n=at(t);n&&Wt(n)&&N(n).position===\"static\";)n=at(n);return n&&(C(n)===\"html\"||C(n)===\"body\"&&N(n).position===\"static\")?e:n||Bt(t)||e}function Le(t){return[\"top\",\"bottom\"].indexOf(t)>=0?\"x\":\"y\"}function fe(t,e,n){return X(t,ve(e,n))}function St(t,e,n){var r=fe(t,e,n);return r>n?n:r}function st(){return{top:0,right:0,bottom:0,left:0}}function ft(t){return Object.assign({},st(),t)}function ct(t,e){return e.reduce(function(n,r){return n[r]=t,n},{})}var Tt=function(t,e){return t=typeof t==\"function\"?t(Object.assign({},e.rects,{placement:e.placement})):t,ft(typeof t!=\"number\"?t:ct(t,G))};function Ht(t){var e,n=t.state,r=t.name,o=t.options,i=n.elements.arrow,a=n.modifiersData.popperOffsets,s=q(n.placement),f=Le(s),c=[P,W].indexOf(s)>=0,u=c?\"height\":\"width\";if(!(!i||!a)){var m=Tt(o.padding,n),v=ke(i),l=f===\"y\"?E:P,h=f===\"y\"?R:W,p=n.rects.reference[u]+n.rects.reference[f]-a[f]-n.rects.popper[u],g=a[f]-n.rects.reference[f],x=se(i),y=x?f===\"y\"?x.clientHeight||0:x.clientWidth||0:0,$=p/2-g/2,d=m[l],b=y-v[u]-m[h],w=y/2-v[u]/2+$,O=fe(d,w,b),j=f;n.modifiersData[r]=(e={},e[j]=O,e.centerOffset=O-w,e)}}function Ct(t){var e=t.state,n=t.options,r=n.element,o=r===void 0?\"[data-popper-arrow]\":r;o!=null&&(typeof o==\"string\"&&(o=e.elements.popper.querySelector(o),!o)||!it(e.elements.popper,o)||(e.elements.arrow=o))}var pt={name:\"arrow\",enabled:!0,phase:\"main\",fn:Ht,effect:Ct,requires:[\"popperOffsets\"],requiresIfExists:[\"preventOverflow\"]};function te(t){return t.split(\"-\")[1]}var qt={top:\"auto\",right:\"auto\",bottom:\"auto\",left:\"auto\"};function Vt(t){var e=t.x,n=t.y,r=window,o=r.devicePixelRatio||1;return{x:Z(e*o)/o||0,y:Z(n*o)/o||0}}function ut(t){var e,n=t.popper,r=t.popperRect,o=t.placement,i=t.variation,a=t.offsets,s=t.position,f=t.gpuAcceleration,c=t.adaptive,u=t.roundOffsets,m=t.isFixed,v=a.x,l=v===void 0?0:v,h=a.y,p=h===void 0?0:h,g=typeof u==\"function\"?u({x:l,y:p}):{x:l,y:p};l=g.x,p=g.y;var x=a.hasOwnProperty(\"x\"),y=a.hasOwnProperty(\"y\"),$=P,d=E,b=window;if(c){var w=se(n),O=\"clientHeight\",j=\"clientWidth\";if(w===H(n)&&(w=I(n),N(w).position!==\"static\"&&s===\"absolute\"&&(O=\"scrollHeight\",j=\"scrollWidth\")),w=w,o===E||(o===P||o===W)&&i===J){d=R;var A=m&&w===b&&b.visualViewport?b.visualViewport.height:w[O];p-=A-r.height,p*=f?1:-1}if(o===P||(o===E||o===R)&&i===J){$=W;var k=m&&w===b&&b.visualViewport?b.visualViewport.width:w[j];l-=k-r.width,l*=f?1:-1}}var D=Object.assign({position:s},c&&qt),S=u===!0?Vt({x:l,y:p}):{x:l,y:p};if(l=S.x,p=S.y,f){var L;return Object.assign({},D,(L={},L[d]=y?\"0\":\"\",L[$]=x?\"0\":\"\",L.transform=(b.devicePixelRatio||1)<=1?\"translate(\"+l+\"px, \"+p+\"px)\":\"translate3d(\"+l+\"px, \"+p+\"px, 0)\",L))}return Object.assign({},D,(e={},e[d]=y?p+\"px\":\"\",e[$]=x?l+\"px\":\"\",e.transform=\"\",e))}function Nt(t){var e=t.state,n=t.options,r=n.gpuAcceleration,o=r===void 0?!0:r,i=n.adaptive,a=i===void 0?!0:i,s=n.roundOffsets,f=s===void 0?!0:s,c={placement:q(e.placement),variation:te(e.placement),popper:e.elements.popper,popperRect:e.rects.popper,gpuAcceleration:o,isFixed:e.options.strategy===\"fixed\"};e.modifiersData.popperOffsets!=null&&(e.styles.popper=Object.assign({},e.styles.popper,ut(Object.assign({},c,{offsets:e.modifiersData.popperOffsets,position:e.options.strategy,adaptive:a,roundOffsets:f})))),e.modifiersData.arrow!=null&&(e.styles.arrow=Object.assign({},e.styles.arrow,ut(Object.assign({},c,{offsets:e.modifiersData.arrow,position:\"absolute\",adaptive:!1,roundOffsets:f})))),e.attributes.popper=Object.assign({},e.attributes.popper,{\"data-popper-placement\":e.placement})}var Me={name:\"computeStyles\",enabled:!0,phase:\"beforeWrite\",fn:Nt,data:{}},ye={passive:!0};function It(t){var e=t.state,n=t.instance,r=t.options,o=r.scroll,i=o===void 0?!0:o,a=r.resize,s=a===void 0?!0:a,f=H(e.elements.popper),c=[].concat(e.scrollParents.reference,e.scrollParents.popper);return i&&c.forEach(function(u){u.addEventListener(\"scroll\",n.update,ye)}),s&&f.addEventListener(\"resize\",n.update,ye),function(){i&&c.forEach(function(u){u.removeEventListener(\"scroll\",n.update,ye)}),s&&f.removeEventListener(\"resize\",n.update,ye)}}var Re={name:\"eventListeners\",enabled:!0,phase:\"write\",fn:function(){},effect:It,data:{}},_t={left:\"right\",right:\"left\",bottom:\"top\",top:\"bottom\"};function be(t){return t.replace(/left|right|bottom|top/g,function(e){return _t[e]})}var zt={start:\"end\",end:\"start\"};function lt(t){return t.replace(/start|end/g,function(e){return zt[e]})}function We(t){var e=H(t),n=e.pageXOffset,r=e.pageYOffset;return{scrollLeft:n,scrollTop:r}}function Be(t){return ee(I(t)).left+We(t).scrollLeft}function Ft(t){var e=H(t),n=I(t),r=e.visualViewport,o=n.clientWidth,i=n.clientHeight,a=0,s=0;return r&&(o=r.width,i=r.height,/^((?!chrome|android).)*safari/i.test(navigator.userAgent)||(a=r.offsetLeft,s=r.offsetTop)),{width:o,height:i,x:a+Be(t),y:s}}function Ut(t){var e,n=I(t),r=We(t),o=(e=t.ownerDocument)==null?void 0:e.body,i=X(n.scrollWidth,n.clientWidth,o?o.scrollWidth:0,o?o.clientWidth:0),a=X(n.scrollHeight,n.clientHeight,o?o.scrollHeight:0,o?o.clientHeight:0),s=-r.scrollLeft+Be(t),f=-r.scrollTop;return N(o||n).direction===\"rtl\"&&(s+=X(n.clientWidth,o?o.clientWidth:0)-i),{width:i,height:a,x:s,y:f}}function Se(t){var e=N(t),n=e.overflow,r=e.overflowX,o=e.overflowY;return/auto|scroll|overlay|hidden/.test(n+o+r)}function dt(t){return[\"html\",\"body\",\"#document\"].indexOf(C(t))>=0?t.ownerDocument.body:B(t)&&Se(t)?t:dt(ge(t))}function ce(t,e){var n;e===void 0&&(e=[]);var r=dt(t),o=r===((n=t.ownerDocument)==null?void 0:n.body),i=H(r),a=o?[i].concat(i.visualViewport||[],Se(r)?r:[]):r,s=e.concat(a);return o?s:s.concat(ce(ge(a)))}function Te(t){return Object.assign({},t,{left:t.x,top:t.y,right:t.x+t.width,bottom:t.y+t.height})}function Xt(t){var e=ee(t);return e.top=e.top+t.clientTop,e.left=e.left+t.clientLeft,e.bottom=e.top+t.clientHeight,e.right=e.left+t.clientWidth,e.width=t.clientWidth,e.height=t.clientHeight,e.x=e.left,e.y=e.top,e}function ht(t,e){return e===je?Te(Ft(t)):Q(e)?Xt(e):Te(Ut(I(t)))}function Yt(t){var e=ce(ge(t)),n=[\"absolute\",\"fixed\"].indexOf(N(t).position)>=0,r=n&&B(t)?se(t):t;return Q(r)?e.filter(function(o){return Q(o)&&it(o,r)&&C(o)!==\"body\"}):[]}function Gt(t,e,n){var r=e===\"clippingParents\"?Yt(t):[].concat(e),o=[].concat(r,[n]),i=o[0],a=o.reduce(function(s,f){var c=ht(t,f);return s.top=X(c.top,s.top),s.right=ve(c.right,s.right),s.bottom=ve(c.bottom,s.bottom),s.left=X(c.left,s.left),s},ht(t,i));return a.width=a.right-a.left,a.height=a.bottom-a.top,a.x=a.left,a.y=a.top,a}function mt(t){var e=t.reference,n=t.element,r=t.placement,o=r?q(r):null,i=r?te(r):null,a=e.x+e.width/2-n.width/2,s=e.y+e.height/2-n.height/2,f;switch(o){case E:f={x:a,y:e.y-n.height};break;case R:f={x:a,y:e.y+e.height};break;case W:f={x:e.x+e.width,y:s};break;case P:f={x:e.x-n.width,y:s};break;default:f={x:e.x,y:e.y}}var c=o?Le(o):null;if(c!=null){var u=c===\"y\"?\"height\":\"width\";switch(i){case U:f[c]=f[c]-(e[u]/2-n[u]/2);break;case J:f[c]=f[c]+(e[u]/2-n[u]/2);break}}return f}function ne(t,e){e===void 0&&(e={});var n=e,r=n.placement,o=r===void 0?t.placement:r,i=n.boundary,a=i===void 0?Xe:i,s=n.rootBoundary,f=s===void 0?je:s,c=n.elementContext,u=c===void 0?K:c,m=n.altBoundary,v=m===void 0?!1:m,l=n.padding,h=l===void 0?0:l,p=ft(typeof h!=\"number\"?h:ct(h,G)),g=u===K?Ye:K,x=t.rects.popper,y=t.elements[v?g:u],$=Gt(Q(y)?y:y.contextElement||I(t.elements.popper),a,f),d=ee(t.elements.reference),b=mt({reference:d,element:x,strategy:\"absolute\",placement:o}),w=Te(Object.assign({},x,b)),O=u===K?w:d,j={top:$.top-O.top+p.top,bottom:O.bottom-$.bottom+p.bottom,left:$.left-O.left+p.left,right:O.right-$.right+p.right},A=t.modifiersData.offset;if(u===K&&A){var k=A[o];Object.keys(j).forEach(function(D){var S=[W,R].indexOf(D)>=0?1:-1,L=[E,R].indexOf(D)>=0?\"y\":\"x\";j[D]+=k[L]*S})}return j}function Jt(t,e){e===void 0&&(e={});var n=e,r=n.placement,o=n.boundary,i=n.rootBoundary,a=n.padding,s=n.flipVariations,f=n.allowedAutoPlacements,c=f===void 0?Ee:f,u=te(r),m=u?s?De:De.filter(function(h){return te(h)===u}):G,v=m.filter(function(h){return c.indexOf(h)>=0});v.length===0&&(v=m);var l=v.reduce(function(h,p){return h[p]=ne(t,{placement:p,boundary:o,rootBoundary:i,padding:a})[q(p)],h},{});return Object.keys(l).sort(function(h,p){return l[h]-l[p]})}function Kt(t){if(q(t)===me)return[];var e=be(t);return[lt(t),e,lt(e)]}function Qt(t){var e=t.state,n=t.options,r=t.name;if(!e.modifiersData[r]._skip){for(var o=n.mainAxis,i=o===void 0?!0:o,a=n.altAxis,s=a===void 0?!0:a,f=n.fallbackPlacements,c=n.padding,u=n.boundary,m=n.rootBoundary,v=n.altBoundary,l=n.flipVariations,h=l===void 0?!0:l,p=n.allowedAutoPlacements,g=e.options.placement,x=q(g),y=x===g,$=f||(y||!h?[be(g)]:Kt(g)),d=[g].concat($).reduce(function(z,V){return z.concat(q(V)===me?Jt(e,{placement:V,boundary:u,rootBoundary:m,padding:c,flipVariations:h,allowedAutoPlacements:p}):V)},[]),b=e.rects.reference,w=e.rects.popper,O=new Map,j=!0,A=d[0],k=0;k<d.length;k++){var D=d[k],S=q(D),L=te(D)===U,re=[E,R].indexOf(S)>=0,oe=re?\"width\":\"height\",M=ne(e,{placement:D,boundary:u,rootBoundary:m,altBoundary:v,padding:c}),T=re?L?W:P:L?R:E;b[oe]>w[oe]&&(T=be(T));var pe=be(T),_=[];if(i&&_.push(M[S]<=0),s&&_.push(M[T]<=0,M[pe]<=0),_.every(function(z){return z})){A=D,j=!1;break}O.set(D,_)}if(j)for(var ue=h?3:1,xe=function(z){var V=d.find(function(de){var ae=O.get(de);if(ae)return ae.slice(0,z).every(function(Y){return Y})});if(V)return A=V,\"break\"},ie=ue;ie>0;ie--){var le=xe(ie);if(le===\"break\")break}e.placement!==A&&(e.modifiersData[r]._skip=!0,e.placement=A,e.reset=!0)}}var vt={name:\"flip\",enabled:!0,phase:\"main\",fn:Qt,requiresIfExists:[\"offset\"],data:{_skip:!1}};function gt(t,e,n){return n===void 0&&(n={x:0,y:0}),{top:t.top-e.height-n.y,right:t.right-e.width+n.x,bottom:t.bottom-e.height+n.y,left:t.left-e.width-n.x}}function yt(t){return[E,W,R,P].some(function(e){return t[e]>=0})}function Zt(t){var e=t.state,n=t.name,r=e.rects.reference,o=e.rects.popper,i=e.modifiersData.preventOverflow,a=ne(e,{elementContext:\"reference\"}),s=ne(e,{altBoundary:!0}),f=gt(a,r),c=gt(s,o,i),u=yt(f),m=yt(c);e.modifiersData[n]={referenceClippingOffsets:f,popperEscapeOffsets:c,isReferenceHidden:u,hasPopperEscaped:m},e.attributes.popper=Object.assign({},e.attributes.popper,{\"data-popper-reference-hidden\":u,\"data-popper-escaped\":m})}var bt={name:\"hide\",enabled:!0,phase:\"main\",requiresIfExists:[\"preventOverflow\"],fn:Zt};function en(t,e,n){var r=q(t),o=[P,E].indexOf(r)>=0?-1:1,i=typeof n==\"function\"?n(Object.assign({},e,{placement:t})):n,a=i[0],s=i[1];return a=a||0,s=(s||0)*o,[P,W].indexOf(r)>=0?{x:s,y:a}:{x:a,y:s}}function tn(t){var e=t.state,n=t.options,r=t.name,o=n.offset,i=o===void 0?[0,0]:o,a=Ee.reduce(function(u,m){return u[m]=en(m,e.rects,i),u},{}),s=a[e.placement],f=s.x,c=s.y;e.modifiersData.popperOffsets!=null&&(e.modifiersData.popperOffsets.x+=f,e.modifiersData.popperOffsets.y+=c),e.modifiersData[r]=a}var wt={name:\"offset\",enabled:!0,phase:\"main\",requires:[\"popperOffsets\"],fn:tn};function nn(t){var e=t.state,n=t.name;e.modifiersData[n]=mt({reference:e.rects.reference,element:e.rects.popper,strategy:\"absolute\",placement:e.placement})}var He={name:\"popperOffsets\",enabled:!0,phase:\"read\",fn:nn,data:{}};function rn(t){return t===\"x\"?\"y\":\"x\"}function on(t){var e=t.state,n=t.options,r=t.name,o=n.mainAxis,i=o===void 0?!0:o,a=n.altAxis,s=a===void 0?!1:a,f=n.boundary,c=n.rootBoundary,u=n.altBoundary,m=n.padding,v=n.tether,l=v===void 0?!0:v,h=n.tetherOffset,p=h===void 0?0:h,g=ne(e,{boundary:f,rootBoundary:c,padding:m,altBoundary:u}),x=q(e.placement),y=te(e.placement),$=!y,d=Le(x),b=rn(d),w=e.modifiersData.popperOffsets,O=e.rects.reference,j=e.rects.popper,A=typeof p==\"function\"?p(Object.assign({},e.rects,{placement:e.placement})):p,k=typeof A==\"number\"?{mainAxis:A,altAxis:A}:Object.assign({mainAxis:0,altAxis:0},A),D=e.modifiersData.offset?e.modifiersData.offset[e.placement]:null,S={x:0,y:0};if(w){if(i){var L,re=d===\"y\"?E:P,oe=d===\"y\"?R:W,M=d===\"y\"?\"height\":\"width\",T=w[d],pe=T+g[re],_=T-g[oe],ue=l?-j[M]/2:0,xe=y===U?O[M]:j[M],ie=y===U?-j[M]:-O[M],le=e.elements.arrow,z=l&&le?ke(le):{width:0,height:0},V=e.modifiersData[\"arrow#persistent\"]?e.modifiersData[\"arrow#persistent\"].padding:st(),de=V[re],ae=V[oe],Y=fe(0,O[M],z[M]),jt=$?O[M]/2-ue-Y-de-k.mainAxis:xe-Y-de-k.mainAxis,Dt=$?-O[M]/2+ue+Y+ae+k.mainAxis:ie+Y+ae+k.mainAxis,Oe=e.elements.arrow&&se(e.elements.arrow),Et=Oe?d===\"y\"?Oe.clientTop||0:Oe.clientLeft||0:0,Ce=(L=D==null?void 0:D[d])!=null?L:0,Pt=T+jt-Ce-Et,At=T+Dt-Ce,qe=fe(l?ve(pe,Pt):pe,T,l?X(_,At):_);w[d]=qe,S[d]=qe-T}if(s){var Ve,kt=d===\"x\"?E:P,Lt=d===\"x\"?R:W,F=w[b],he=b===\"y\"?\"height\":\"width\",Ne=F+g[kt],Ie=F-g[Lt],$e=[E,P].indexOf(x)!==-1,_e=(Ve=D==null?void 0:D[b])!=null?Ve:0,ze=$e?Ne:F-O[he]-j[he]-_e+k.altAxis,Fe=$e?F+O[he]+j[he]-_e-k.altAxis:Ie,Ue=l&&$e?St(ze,F,Fe):fe(l?ze:Ne,F,l?Fe:Ie);w[b]=Ue,S[b]=Ue-F}e.modifiersData[r]=S}}var xt={name:\"preventOverflow\",enabled:!0,phase:\"main\",fn:on,requiresIfExists:[\"offset\"]};function an(t){return{scrollLeft:t.scrollLeft,scrollTop:t.scrollTop}}function sn(t){return t===H(t)||!B(t)?We(t):an(t)}function fn(t){var e=t.getBoundingClientRect(),n=Z(e.width)/t.offsetWidth||1,r=Z(e.height)/t.offsetHeight||1;return n!==1||r!==1}function cn(t,e,n){n===void 0&&(n=!1);var r=B(e),o=B(e)&&fn(e),i=I(e),a=ee(t,o),s={scrollLeft:0,scrollTop:0},f={x:0,y:0};return(r||!r&&!n)&&((C(e)!==\"body\"||Se(i))&&(s=sn(e)),B(e)?(f=ee(e,!0),f.x+=e.clientLeft,f.y+=e.clientTop):i&&(f.x=Be(i))),{x:a.left+s.scrollLeft-f.x,y:a.top+s.scrollTop-f.y,width:a.width,height:a.height}}function pn(t){var e=new Map,n=new Set,r=[];t.forEach(function(i){e.set(i.name,i)});function o(i){n.add(i.name);var a=[].concat(i.requires||[],i.requiresIfExists||[]);a.forEach(function(s){if(!n.has(s)){var f=e.get(s);f&&o(f)}}),r.push(i)}return t.forEach(function(i){n.has(i.name)||o(i)}),r}function un(t){var e=pn(t);return ot.reduce(function(n,r){return n.concat(e.filter(function(o){return o.phase===r}))},[])}function ln(t){var e;return function(){return e||(e=new Promise(function(n){Promise.resolve().then(function(){e=void 0,n(t())})})),e}}function dn(t){var e=t.reduce(function(n,r){var o=n[r.name];return n[r.name]=o?Object.assign({},o,r,{options:Object.assign({},o.options,r.options),data:Object.assign({},o.data,r.data)}):r,n},{});return Object.keys(e).map(function(n){return e[n]})}var Ot={placement:\"bottom\",modifiers:[],strategy:\"absolute\"};function $t(){for(var t=arguments.length,e=new Array(t),n=0;n<t;n++)e[n]=arguments[n];return!e.some(function(r){return!(r&&typeof r.getBoundingClientRect==\"function\")})}function we(t){t===void 0&&(t={});var e=t,n=e.defaultModifiers,r=n===void 0?[]:n,o=e.defaultOptions,i=o===void 0?Ot:o;return function(a,s,f){f===void 0&&(f=i);var c={placement:\"bottom\",orderedModifiers:[],options:Object.assign({},Ot,i),modifiersData:{},elements:{reference:a,popper:s},attributes:{},styles:{}},u=[],m=!1,v={state:c,setOptions:function(p){var g=typeof p==\"function\"?p(c.options):p;h(),c.options=Object.assign({},i,c.options,g),c.scrollParents={reference:Q(a)?ce(a):a.contextElement?ce(a.contextElement):[],popper:ce(s)};var x=un(dn([].concat(r,c.options.modifiers)));return c.orderedModifiers=x.filter(function(y){return y.enabled}),l(),v.update()},forceUpdate:function(){if(!m){var p=c.elements,g=p.reference,x=p.popper;if($t(g,x)){c.rects={reference:cn(g,se(x),c.options.strategy===\"fixed\"),popper:ke(x)},c.reset=!1,c.placement=c.options.placement,c.orderedModifiers.forEach(function(j){return c.modifiersData[j.name]=Object.assign({},j.data)});for(var y=0;y<c.orderedModifiers.length;y++){if(c.reset===!0){c.reset=!1,y=-1;continue}var $=c.orderedModifiers[y],d=$.fn,b=$.options,w=b===void 0?{}:b,O=$.name;typeof d==\"function\"&&(c=d({state:c,options:w,name:O,instance:v})||c)}}}},update:ln(function(){return new Promise(function(p){v.forceUpdate(),p(c)})}),destroy:function(){h(),m=!0}};if(!$t(a,s))return v;v.setOptions(f).then(function(p){!m&&f.onFirstUpdate&&f.onFirstUpdate(p)});function l(){c.orderedModifiers.forEach(function(p){var g=p.name,x=p.options,y=x===void 0?{}:x,$=p.effect;if(typeof $==\"function\"){var d=$({state:c,name:g,instance:v,options:y}),b=function(){};u.push(d||b)}})}function h(){u.forEach(function(p){return p()}),u=[]}return v}}var hn=we(),mn=[Re,He,Me,Ae],vn=we({defaultModifiers:mn}),gn=[Re,He,Me,Ae,wt,vt,xt,pt,bt],yn=we({defaultModifiers:gn});export{et as afterMain,Ke as afterRead,rt as afterWrite,Ae as applyStyles,pt as arrow,me as auto,G as basePlacements,Qe as beforeMain,Ge as beforeRead,tt as beforeWrite,R as bottom,Xe as clippingParents,Me as computeStyles,yn as createPopper,hn as createPopperBase,vn as createPopperLite,ne as detectOverflow,J as end,Re as eventListeners,vt as flip,bt as hide,P as left,Ze as main,ot as modifierPhases,wt as offset,Ee as placements,K as popper,we as popperGenerator,He as popperOffsets,xt as preventOverflow,Je as read,Ye as reference,W as right,U as start,E as top,De as variationPlacements,je as viewport,nt as write};\n","import * as Vue from 'vue'\n\nvar isVue2 = false\nvar isVue3 = true\nvar Vue2 = undefined\n\nfunction install() {}\n\nexport function set(target, key, val) {\n  if (Array.isArray(target)) {\n    target.length = Math.max(target.length, key)\n    target.splice(key, 1, val)\n    return val\n  }\n  target[key] = val\n  return val\n}\n\nexport function del(target, key) {\n  if (Array.isArray(target)) {\n    target.splice(key, 1)\n    return\n  }\n  delete target[key]\n}\n\nexport * from 'vue'\nexport {\n  Vue,\n  Vue2,\n  isVue2,\n  isVue3,\n  install,\n}\n","import { noop, resolveUnref, isClient, isString, tryOnScopeDispose, isIOS, tryOnMounted, computedWithControl, promiseTimeout, isFunction, resolveRef, increaseWithUnit, useTimeoutFn, pausableWatch, createEventHook, timestamp, pausableFilter, watchIgnorable, debounceFilter, createFilterWrapper, bypassFilter, createSingletonPromise, toRefs, containsProp, until, hasOwn, throttleFilter, useDebounceFn, useThrottleFn, isObject, isNumber, useIntervalFn, clamp, syncRef, objectPick, tryOnUnmounted, watchWithFilter, identity, isDef } from '@vueuse/shared';\nexport * from '@vueuse/shared';\nimport { isRef, ref, shallowRef, watchEffect, computed, inject, unref, watch, getCurrentInstance, customRef, onUpdated, reactive, nextTick, onMounted, markRaw, readonly, getCurrentScope, isVue2, 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 = false,\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\nconst createUnrefFn = (fn) => {\n  return function(...args) {\n    return fn.apply(this, args.map((i) => unref(i)));\n  };\n};\n\nfunction unrefElement(elRef) {\n  var _a;\n  const plain = resolveUnref(elRef);\n  return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;\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 useEventListener(...args) {\n  let target;\n  let events;\n  let listeners;\n  let options;\n  if (isString(args[0]) || 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(() => [unrefElement(target), resolveUnref(options)], ([el, options2]) => {\n    cleanup();\n    if (!el)\n      return;\n    cleanups.push(...events.flatMap((event) => {\n      return listeners.map((listener) => register(el, event, listener, options2));\n    }));\n  }, { immediate: true, flush: \"post\" });\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;\n  if (isIOS && !_iOSWorkaround) {\n    _iOSWorkaround = true;\n    Array.from(window.document.body.children).forEach((el) => el.addEventListener(\"click\", noop));\n  }\n  let shouldListen = true;\n  const shouldIgnore = (event) => {\n    return 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  const cleanup = [\n    useEventListener(window, \"click\", listener, { passive: true, capture }),\n    useEventListener(window, \"pointerdown\", (e) => {\n      const el = unrefElement(target);\n      if (el)\n        shouldListen = !e.composedPath().includes(el) && !shouldIgnore(e);\n    }, { passive: true }),\n    detectIframe && useEventListener(window, \"blur\", (event) => {\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  ].filter(Boolean);\n  const stop = () => cleanup.forEach((fn) => fn());\n  return stop;\n}\n\nvar __defProp$n = Object.defineProperty;\nvar __defProps$9 = Object.defineProperties;\nvar __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols$p = Object.getOwnPropertySymbols;\nvar __hasOwnProp$p = Object.prototype.hasOwnProperty;\nvar __propIsEnum$p = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$n = (obj, key, value) => key in obj ? __defProp$n(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$n = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$p.call(b, prop))\n      __defNormalProp$n(a, prop, b[prop]);\n  if (__getOwnPropSymbols$p)\n    for (var prop of __getOwnPropSymbols$p(b)) {\n      if (__propIsEnum$p.call(b, prop))\n        __defNormalProp$n(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));\nconst 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 { target = defaultWindow, eventName = \"keydown\", passive = false } = options;\n  const predicate = createKeyPredicate(key);\n  const listener = (e) => {\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, __spreadProps$9(__spreadValues$n({}, options), { eventName: \"keydown\" }));\n}\nfunction onKeyPressed(key, handler, options = {}) {\n  return onKeyStroke(key, handler, __spreadProps$9(__spreadValues$n({}, options), { eventName: \"keypress\" }));\n}\nfunction onKeyUp(key, handler, options = {}) {\n  return onKeyStroke(key, handler, __spreadProps$9(__spreadValues$n({}, options), { eventName: \"keyup\" }));\n}\n\nconst DEFAULT_DELAY = 500;\nfunction onLongPress(target, handler, options) {\n  var _a, _b;\n  const elementRef = computed(() => unrefElement(target));\n  let timeout;\n  function clear() {\n    if (timeout) {\n      clearTimeout(timeout);\n      timeout = void 0;\n    }\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    timeout = setTimeout(() => handler(ev), (_d = options == null ? void 0 : options.delay) != null ? _d : DEFAULT_DELAY);\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  useEventListener(elementRef, \"pointerdown\", onDown, listenerOptions);\n  useEventListener(elementRef, \"pointerup\", clear, listenerOptions);\n  useEventListener(elementRef, \"pointerleave\", clear, listenerOptions);\n}\n\nconst 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};\nconst isTypedCharValid = ({\n  keyCode,\n  metaKey,\n  ctrlKey,\n  altKey\n}) => {\n  if (metaKey || ctrlKey || altKey)\n    return false;\n  if (keyCode >= 48 && keyCode <= 57 || keyCode >= 96 && keyCode <= 105)\n    return true;\n  if (keyCode >= 65 && keyCode <= 90)\n    return true;\n  return false;\n};\nfunction onStartTyping(callback, options = {}) {\n  const { document: document2 = defaultDocument } = options;\n  const keydown = (event) => {\n    !isFocusedElementEditable() && isTypedCharValid(event) && callback(event);\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 useActiveElement(options = {}) {\n  var _a;\n  const { window = defaultWindow } = options;\n  const document = (_a = options.document) != null ? _a : window == null ? void 0 : window.document;\n  const activeElement = computedWithControl(() => null, () => document == null ? void 0 : document.activeElement);\n  if (window) {\n    useEventListener(window, \"blur\", (event) => {\n      if (event.relatedTarget !== null)\n        return;\n      activeElement.trigger();\n    }, true);\n    useEventListener(window, \"focus\", activeElement.trigger, true);\n  }\n  return activeElement;\n}\n\nfunction useAsyncQueue(tasks, options = {}) {\n  const {\n    interrupt = true,\n    onError = noop,\n    onFinished = noop\n  } = options;\n  const promiseState = {\n    pending: \"pending\",\n    rejected: \"rejected\",\n    fulfilled: \"fulfilled\"\n  };\n  const initialResult = Array.from(new Array(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 (((_a = result[activeIndex.value]) == null ? void 0 : _a.state) === promiseState.rejected && interrupt) {\n        onFinished();\n        return;\n      }\n      return curr(prevRes).then((currentRes) => {\n        updateResult(promiseState.fulfilled, currentRes);\n        activeIndex.value === tasks.length - 1 && onFinished();\n        return currentRes;\n      });\n    }).catch((e) => {\n      updateResult(promiseState.rejected, e);\n      onError();\n      return e;\n    });\n  }, Promise.resolve());\n  return {\n    activeIndex,\n    result\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 = ref(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 error;\n    } finally {\n      isLoading.value = false;\n    }\n    return state.value;\n  }\n  if (immediate)\n    execute(delay);\n  return {\n    state,\n    isReady,\n    isLoading,\n    error,\n    execute\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 = resolveUnref(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) || isFunction(target))\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 useSupported(callback, sync = false) {\n  const isSupported = ref();\n  const update = () => isSupported.value = Boolean(callback());\n  update();\n  tryOnMounted(update, sync);\n  return isSupported;\n}\n\nfunction useBattery({ navigator = defaultNavigator } = {}) {\n  const events = [\"chargingchange\", \"chargingtimechange\", \"dischargingtimechange\", \"levelchange\"];\n  const isSupported = useSupported(() => navigator && \"getBattery\" in navigator);\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      for (const event of events)\n        useEventListener(battery, event, 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    requestDevice,\n    server,\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 cleanup = () => {\n    if (!mediaQuery)\n      return;\n    if (\"removeEventListener\" in mediaQuery)\n      mediaQuery.removeEventListener(\"change\", update);\n    else\n      mediaQuery.removeListener(update);\n  };\n  const update = () => {\n    if (!isSupported.value)\n      return;\n    cleanup();\n    mediaQuery = window.matchMedia(resolveRef(query).value);\n    matches.value = mediaQuery.matches;\n    if (\"addEventListener\" in mediaQuery)\n      mediaQuery.addEventListener(\"change\", update);\n    else\n      mediaQuery.addListener(update);\n  };\n  watchEffect(update);\n  tryOnScopeDispose(() => cleanup());\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  sm: 576,\n  md: 768,\n  lg: 992,\n  xl: 1200,\n  xxl: 1400\n};\nconst breakpointsVuetify = {\n  xs: 600,\n  sm: 960,\n  md: 1264,\n  lg: 1904\n};\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: 600,\n  sm: 1024,\n  md: 1440,\n  lg: 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};\n\nvar __defProp$m = Object.defineProperty;\nvar __getOwnPropSymbols$o = Object.getOwnPropertySymbols;\nvar __hasOwnProp$o = Object.prototype.hasOwnProperty;\nvar __propIsEnum$o = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$m = (obj, key, value) => key in obj ? __defProp$m(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$m = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$o.call(b, prop))\n      __defNormalProp$m(a, prop, b[prop]);\n  if (__getOwnPropSymbols$o)\n    for (var prop of __getOwnPropSymbols$o(b)) {\n      if (__propIsEnum$o.call(b, prop))\n        __defNormalProp$m(a, prop, b[prop]);\n    }\n  return a;\n};\nfunction useBreakpoints(breakpoints, options = {}) {\n  function getValue(k, delta) {\n    let v = breakpoints[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 } = 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 shortcutMethods = Object.keys(breakpoints).reduce((shortcuts, k) => {\n    Object.defineProperty(shortcuts, k, {\n      get: () => greaterOrEqual(k),\n      enumerable: true,\n      configurable: true\n    });\n    return shortcuts;\n  }, {});\n  return __spreadValues$m({\n    greater(k) {\n      return useMediaQuery(`(min-width: ${getValue(k, 0.1)})`, options);\n    },\n    greaterOrEqual,\n    smaller(k) {\n      return useMediaQuery(`(max-width: ${getValue(k, -0.1)})`, options);\n    },\n    smallerOrEqual(k) {\n      return useMediaQuery(`(max-width: ${getValue(k)})`, 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  }, shortcutMethods);\n}\n\nconst 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 = ref(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\nfunction useBrowserLocation({ window = defaultWindow } = {}) {\n  const buildState = (trigger) => {\n    const { state: state2, length } = (window == null ? void 0 : window.history) || {};\n    const { hash, host, hostname, href, origin, pathname, port, protocol, search } = (window == null ? void 0 : window.location) || {};\n    return {\n      trigger,\n      state: state2,\n      length,\n      hash,\n      host,\n      hostname,\n      href,\n      origin,\n      pathname,\n      port,\n      protocol,\n      search\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 useClipboard(options = {}) {\n  const {\n    navigator = defaultNavigator,\n    read = false,\n    source,\n    copiedDuring = 1500,\n    legacy = false\n  } = options;\n  const events = [\"copy\", \"cut\"];\n  const isClipboardApiSupported = useSupported(() => navigator && \"clipboard\" in navigator);\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) {\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    for (const event of events)\n      useEventListener(event, updateText);\n  }\n  async function copy(value = resolveUnref(source)) {\n    if (isSupported.value && value != null) {\n      if (isClipboardApiSupported.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  return {\n    isSupported,\n    text,\n    copied,\n    copy\n  };\n}\n\nvar __defProp$l = Object.defineProperty;\nvar __defProps$8 = Object.defineProperties;\nvar __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols$n = Object.getOwnPropertySymbols;\nvar __hasOwnProp$n = Object.prototype.hasOwnProperty;\nvar __propIsEnum$n = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$l = (obj, key, value) => key in obj ? __defProp$l(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$l = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$n.call(b, prop))\n      __defNormalProp$l(a, prop, b[prop]);\n  if (__getOwnPropSymbols$n)\n    for (var prop of __getOwnPropSymbols$n(b)) {\n      if (__propIsEnum$n.call(b, prop))\n        __defNormalProp$l(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));\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    deep = true,\n    immediate = true\n  } = options;\n  function sync() {\n    cloned.value = clone(unref(source));\n  }\n  if (!manual && isRef(source)) {\n    watch(source, sync, __spreadProps$8(__spreadValues$l({}, 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__\";\n_global[globalKey] = _global[globalKey] || {};\nconst handlers = _global[globalKey];\nfunction getSSRHandler(key, fallback) {\n  return handlers[key] || fallback;\n}\nfunction setSSRHandler(key, fn) {\n  handlers[key] = fn;\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\nvar __defProp$k = Object.defineProperty;\nvar __getOwnPropSymbols$m = Object.getOwnPropertySymbols;\nvar __hasOwnProp$m = Object.prototype.hasOwnProperty;\nvar __propIsEnum$m = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$k = (obj, key, value) => key in obj ? __defProp$k(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$k = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$m.call(b, prop))\n      __defNormalProp$k(a, prop, b[prop]);\n  if (__getOwnPropSymbols$m)\n    for (var prop of __getOwnPropSymbols$m(b)) {\n      if (__propIsEnum$m.call(b, prop))\n        __defNormalProp$k(a, prop, b[prop]);\n    }\n  return a;\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  } = options;\n  const data = (shallow ? shallowRef : ref)(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 = resolveUnref(defaults);\n  const type = guessSerializerType(rawInit);\n  const serializer = (_a = options.serializer) != null ? _a : StorageSerializers[type];\n  const { pause: pauseWatch, resume: resumeWatch } = pausableWatch(data, () => write(data.value), { flush, deep, eventFilter });\n  if (window && listenToStorageChanges) {\n    useEventListener(window, \"storage\", update);\n    useEventListener(window, customStorageEventName, updateFromCustomEvent);\n  }\n  update();\n  return data;\n  function write(v) {\n    try {\n      if (v == null) {\n        storage.removeItem(key);\n      } else {\n        const serialized = serializer.write(v);\n        const oldValue = storage.getItem(key);\n        if (oldValue !== serialized) {\n          storage.setItem(key, serialized);\n          if (window) {\n            window.dispatchEvent(new CustomEvent(customStorageEventName, {\n              detail: {\n                key,\n                oldValue,\n                newValue: serialized,\n                storageArea: storage\n              }\n            }));\n          }\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 (isFunction(mergeDefaults))\n        return mergeDefaults(value, rawInit);\n      else if (type === \"object\" && !Array.isArray(value))\n        return __spreadValues$k(__spreadValues$k({}, 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 updateFromCustomEvent(event) {\n    update(event.detail);\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      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}\n\nfunction usePreferredDark(options) {\n  return useMediaQuery(\"(prefers-color-scheme: dark)\", options);\n}\n\nvar __defProp$j = Object.defineProperty;\nvar __getOwnPropSymbols$l = Object.getOwnPropertySymbols;\nvar __hasOwnProp$l = Object.prototype.hasOwnProperty;\nvar __propIsEnum$l = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$j = (obj, key, value) => key in obj ? __defProp$j(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$j = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$l.call(b, prop))\n      __defNormalProp$j(a, prop, b[prop]);\n  if (__getOwnPropSymbols$l)\n    for (var prop of __getOwnPropSymbols$l(b)) {\n      if (__propIsEnum$l.call(b, prop))\n        __defNormalProp$j(a, prop, b[prop]);\n    }\n  return a;\n};\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  } = options;\n  const modes = __spreadValues$j({\n    auto: \"\",\n    light: \"light\",\n    dark: \"dark\"\n  }, options.modes || {});\n  const preferredDark = usePreferredDark({ window });\n  const preferredMode = computed(() => preferredDark.value ? \"dark\" : \"light\");\n  const store = storageRef || (storageKey == null ? ref(initialValue) : useStorage(storageKey, initialValue, storage, { window, listenToStorageChanges }));\n  const state = computed({\n    get() {\n      return store.value === \"auto\" && !emitAuto ? preferredMode.value : store.value;\n    },\n    set(v) {\n      store.value = v;\n    }\n  });\n  const updateHTMLAttrs = getSSRHandler(\"updateHTMLAttrs\", (selector2, attribute2, value) => {\n    const el = window == null ? void 0 : window.document.querySelector(selector2);\n    if (!el)\n      return;\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          el.classList.add(v);\n        else\n          el.classList.remove(v);\n      });\n    } else {\n      el.setAttribute(attribute2, value);\n    }\n  });\n  function defaultOnChanged(mode) {\n    var _a;\n    const resolvedMode = mode === \"auto\" ? preferredMode.value : mode;\n    updateHTMLAttrs(selector, attribute, (_a = modes[resolvedMode]) != null ? _a : resolvedMode);\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  if (emitAuto)\n    watch(preferredMode, () => onChanged(state.value), { flush: \"post\" });\n  tryOnMounted(() => onChanged(state.value));\n  return state;\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, { window = defaultWindow, initialValue = \"\" } = {}) {\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  watch([elRef, () => resolveUnref(prop)], ([el, prop2]) => {\n    var _a;\n    if (el && window) {\n      const value = (_a = window.getComputedStyle(el).getPropertyValue(prop2)) == null ? void 0 : _a.trim();\n      variable.value = value || initialValue;\n    }\n  }, { immediate: true });\n  watch(variable, (val) => {\n    var _a;\n    if ((_a = elRef.value) == null ? void 0 : _a.style)\n      elRef.value.style.setProperty(resolveUnref(prop), val);\n  });\n  return variable;\n}\n\nfunction useCurrentElement() {\n  const vm = getCurrentInstance();\n  const currentElement = computedWithControl(() => null, () => vm.proxy.$el);\n  onUpdated(currentElement.trigger);\n  onMounted(currentElement.trigger);\n  return currentElement;\n}\n\nfunction useCycleList(list, options) {\n  var _a;\n  const state = shallowRef((_a = options == null ? void 0 : options.initialValue) != null ? _a : list[0]);\n  const index = computed({\n    get() {\n      var _a2;\n      let index2 = (options == null ? void 0 : options.getIndexOf) ? options.getIndexOf(state.value, list) : list.indexOf(state.value);\n      if (index2 < 0)\n        index2 = (_a2 = options == null ? void 0 : options.fallbackIndex) != null ? _a2 : 0;\n      return index2;\n    },\n    set(v) {\n      set(v);\n    }\n  });\n  function set(i) {\n    const length = list.length;\n    const index2 = (i % length + length) % length;\n    const value = list[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  return {\n    state,\n    index,\n    next,\n    prev\n  };\n}\n\nvar __defProp$i = Object.defineProperty;\nvar __defProps$7 = Object.defineProperties;\nvar __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols$k = Object.getOwnPropertySymbols;\nvar __hasOwnProp$k = Object.prototype.hasOwnProperty;\nvar __propIsEnum$k = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$i = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$i = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$k.call(b, prop))\n      __defNormalProp$i(a, prop, b[prop]);\n  if (__getOwnPropSymbols$k)\n    for (var prop of __getOwnPropSymbols$k(b)) {\n      if (__propIsEnum$k.call(b, prop))\n        __defNormalProp$i(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));\nfunction useDark(options = {}) {\n  const {\n    valueDark = \"dark\",\n    valueLight = \"\",\n    window = defaultWindow\n  } = options;\n  const mode = useColorMode(__spreadProps$7(__spreadValues$i({}, options), {\n    onChanged: (mode2, defaultHandler) => {\n      var _a;\n      if (options.onChanged)\n        (_a = options.onChanged) == null ? void 0 : _a.call(options, mode2 === \"dark\");\n      else\n        defaultHandler(mode2);\n    },\n    modes: {\n      dark: valueDark,\n      light: valueLight\n    }\n  }));\n  const preferredDark = usePreferredDark({ window });\n  const isDark = computed({\n    get() {\n      return mode.value === \"dark\";\n    },\n    set(v) {\n      if (v === preferredDark.value)\n        mode.value = \"auto\";\n      else\n        mode.value = v ? \"dark\" : \"light\";\n    }\n  });\n  return isDark;\n}\n\nconst fnBypass = (v) => v;\nconst fnSetSource = (source, value) => source.value = value;\nfunction defaultDump(clone) {\n  return clone ? isFunction(clone) ? clone : cloneFnJSON : fnBypass;\n}\nfunction defaultParse(clone) {\n  return clone ? isFunction(clone) ? 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, 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\nvar __defProp$h = Object.defineProperty;\nvar __defProps$6 = Object.defineProperties;\nvar __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols$j = Object.getOwnPropertySymbols;\nvar __hasOwnProp$j = Object.prototype.hasOwnProperty;\nvar __propIsEnum$j = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$h = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$j.call(b, prop))\n      __defNormalProp$h(a, prop, b[prop]);\n  if (__getOwnPropSymbols$j)\n    for (var prop of __getOwnPropSymbols$j(b)) {\n      if (__propIsEnum$j.call(b, prop))\n        __defNormalProp$h(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));\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(source, commit, { deep, flush, eventFilter: composedFilter });\n  function setSource(source2, value) {\n    ignorePrevAsyncUpdates();\n    ignoreUpdates(() => {\n      source2.value = value;\n    });\n  }\n  const manualHistory = useManualRefHistory(source, __spreadProps$6(__spreadValues$h({}, 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 __spreadProps$6(__spreadValues$h({}, manualHistory), {\n    isTracking,\n    pause,\n    resume,\n    commit,\n    batch,\n    dispose\n  });\n}\n\nvar __defProp$g = Object.defineProperty;\nvar __defProps$5 = Object.defineProperties;\nvar __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols$i = Object.getOwnPropertySymbols;\nvar __hasOwnProp$i = Object.prototype.hasOwnProperty;\nvar __propIsEnum$i = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$g = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$i.call(b, prop))\n      __defNormalProp$g(a, prop, b[prop]);\n  if (__getOwnPropSymbols$i)\n    for (var prop of __getOwnPropSymbols$i(b)) {\n      if (__propIsEnum$i.call(b, prop))\n        __defNormalProp$g(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));\nfunction useDebouncedRefHistory(source, options = {}) {\n  const filter = options.debounce ? debounceFilter(options.debounce) : void 0;\n  const history = useRefHistory(source, __spreadProps$5(__spreadValues$g({}, options), { eventFilter: filter }));\n  return __spreadValues$g({}, history);\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(eventFilter, (event) => {\n      acceleration.value = event.acceleration;\n      accelerationIncludingGravity.value = event.accelerationIncludingGravity;\n      rotationRate.value = event.rotationRate;\n      interval.value = event.interval;\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({\n  window = defaultWindow\n} = {}) {\n  const pixelRatio = ref(1);\n  if (window) {\n    let observe = function() {\n      pixelRatio.value = window.devicePixelRatio;\n      cleanup();\n      media = window.matchMedia(`(resolution: ${pixelRatio.value}dppx)`);\n      media.addEventListener(\"change\", observe, { once: true });\n    }, cleanup = function() {\n      media == null ? void 0 : media.removeEventListener(\"change\", observe);\n    };\n    let media;\n    observe();\n    tryOnScopeDispose(cleanup);\n  }\n  return { pixelRatio };\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  let permissionStatus;\n  const desc = typeof permissionDesc === \"string\" ? { name: permissionDesc } : permissionDesc;\n  const state = ref();\n  const onChange = () => {\n    if (permissionStatus)\n      state.value = permissionStatus.state;\n  };\n  const query = createSingletonPromise(async () => {\n    if (!isSupported.value)\n      return;\n    if (!permissionStatus) {\n      try {\n        permissionStatus = await navigator.permissions.query(desc);\n        useEventListener(permissionStatus, \"change\", onChange);\n        onChange();\n      } catch (e) {\n        state.value = \"prompt\";\n      }\n    }\n    return permissionStatus;\n  });\n  query();\n  if (controls) {\n    return {\n      state,\n      isSupported,\n      query\n    };\n  } else {\n    return state;\n  }\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  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  }\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      const stream = await navigator.mediaDevices.getUserMedia(constraints);\n      stream.getTracks().forEach((t) => t.stop());\n      update();\n      permissionGranted.value = true;\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    if (!isSupported.value || stream.value)\n      return;\n    stream.value = await navigator.mediaDevices.getDisplayMedia(constraint);\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(enabled, (v) => {\n    if (v)\n      _start();\n    else\n      _stop();\n  }, { immediate: true });\n  return {\n    isSupported,\n    stream,\n    start,\n    stop,\n    enabled\n  };\n}\n\nfunction useDocumentVisibility({ document = defaultDocument } = {}) {\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\nvar __defProp$f = Object.defineProperty;\nvar __defProps$4 = Object.defineProperties;\nvar __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols$h = Object.getOwnPropertySymbols;\nvar __hasOwnProp$h = Object.prototype.hasOwnProperty;\nvar __propIsEnum$h = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$f = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$h.call(b, prop))\n      __defNormalProp$f(a, prop, b[prop]);\n  if (__getOwnPropSymbols$h)\n    for (var prop of __getOwnPropSymbols$h(b)) {\n      if (__propIsEnum$h.call(b, prop))\n        __defNormalProp$f(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));\nfunction useDraggable(target, options = {}) {\n  var _a, _b, _c;\n  const draggingElement = (_a = options.draggingElement) != null ? _a : defaultWindow;\n  const draggingHandle = (_b = options.handle) != null ? _b : target;\n  const position = ref((_c = resolveUnref(options.initialValue)) != null ? _c : { x: 0, y: 0 });\n  const pressedDelta = ref();\n  const filterEvent = (e) => {\n    if (options.pointerTypes)\n      return options.pointerTypes.includes(e.pointerType);\n    return true;\n  };\n  const handleEvent = (e) => {\n    if (resolveUnref(options.preventDefault))\n      e.preventDefault();\n    if (resolveUnref(options.stopPropagation))\n      e.stopPropagation();\n  };\n  const start = (e) => {\n    var _a2;\n    if (!filterEvent(e))\n      return;\n    if (resolveUnref(options.exact) && e.target !== resolveUnref(target))\n      return;\n    const rect = resolveUnref(target).getBoundingClientRect();\n    const pos = {\n      x: e.clientX - rect.left,\n      y: e.clientY - rect.top\n    };\n    if (((_a2 = options.onStart) == null ? void 0 : _a2.call(options, pos, e)) === false)\n      return;\n    pressedDelta.value = pos;\n    handleEvent(e);\n  };\n  const move = (e) => {\n    var _a2;\n    if (!filterEvent(e))\n      return;\n    if (!pressedDelta.value)\n      return;\n    position.value = {\n      x: e.clientX - pressedDelta.value.x,\n      y: e.clientY - pressedDelta.value.y\n    };\n    (_a2 = options.onMove) == null ? void 0 : _a2.call(options, position.value, e);\n    handleEvent(e);\n  };\n  const end = (e) => {\n    var _a2;\n    if (!filterEvent(e))\n      return;\n    if (!pressedDelta.value)\n      return;\n    pressedDelta.value = void 0;\n    (_a2 = options.onEnd) == null ? void 0 : _a2.call(options, position.value, e);\n    handleEvent(e);\n  };\n  if (isClient) {\n    useEventListener(draggingHandle, \"pointerdown\", start, true);\n    useEventListener(draggingElement, \"pointermove\", move, true);\n    useEventListener(draggingElement, \"pointerup\", end, true);\n  }\n  return __spreadProps$4(__spreadValues$f({}, toRefs(position)), {\n    position,\n    isDragging: computed(() => !!pressedDelta.value),\n    style: computed(() => `left:${position.value.x}px;top:${position.value.y}px;`)\n  });\n}\n\nfunction useDropZone(target, onDrop) {\n  const isOverDropZone = ref(false);\n  let counter = 0;\n  if (isClient) {\n    useEventListener(target, \"dragenter\", (event) => {\n      event.preventDefault();\n      counter += 1;\n      isOverDropZone.value = true;\n    });\n    useEventListener(target, \"dragover\", (event) => {\n      event.preventDefault();\n    });\n    useEventListener(target, \"dragleave\", (event) => {\n      event.preventDefault();\n      counter -= 1;\n      if (counter === 0)\n        isOverDropZone.value = false;\n    });\n    useEventListener(target, \"drop\", (event) => {\n      var _a, _b;\n      event.preventDefault();\n      counter = 0;\n      isOverDropZone.value = false;\n      const files = Array.from((_b = (_a = event.dataTransfer) == null ? void 0 : _a.files) != null ? _b : []);\n      onDrop == null ? void 0 : onDrop(files.length === 0 ? null : files);\n    });\n  }\n  return {\n    isOverDropZone\n  };\n}\n\nvar __getOwnPropSymbols$g = Object.getOwnPropertySymbols;\nvar __hasOwnProp$g = Object.prototype.hasOwnProperty;\nvar __propIsEnum$g = Object.prototype.propertyIsEnumerable;\nvar __objRest$2 = (source, exclude) => {\n  var target = {};\n  for (var prop in source)\n    if (__hasOwnProp$g.call(source, prop) && exclude.indexOf(prop) < 0)\n      target[prop] = source[prop];\n  if (source != null && __getOwnPropSymbols$g)\n    for (var prop of __getOwnPropSymbols$g(source)) {\n      if (exclude.indexOf(prop) < 0 && __propIsEnum$g.call(source, prop))\n        target[prop] = source[prop];\n    }\n  return target;\n};\nfunction useResizeObserver(target, callback, options = {}) {\n  const _a = options, { window = defaultWindow } = _a, observerOptions = __objRest$2(_a, [\"window\"]);\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 stopWatch = watch(() => unrefElement(target), (el) => {\n    cleanup();\n    if (isSupported.value && window && el) {\n      observer = new ResizeObserver(callback);\n      observer.observe(el, observerOptions);\n    }\n  }, { immediate: true, flush: \"post\" });\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  } = 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 update() {\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  useResizeObserver(target, update);\n  watch(() => unrefElement(target), (ele) => !ele && update());\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 useRafFn(fn, options = {}) {\n  const {\n    immediate = true,\n    window = defaultWindow\n  } = options;\n  const isActive = ref(false);\n  let previousFrameTimestamp = 0;\n  let rafId = null;\n  function loop(timestamp) {\n    if (!isActive.value || !window)\n      return;\n    const delta = timestamp - previousFrameTimestamp;\n    fn({ delta, timestamp });\n    previousFrameTimestamp = timestamp;\n    rafId = window.requestAnimationFrame(loop);\n  }\n  function resume() {\n    if (!isActive.value && window) {\n      isActive.value = true;\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\nvar __defProp$e = Object.defineProperty;\nvar __getOwnPropSymbols$f = Object.getOwnPropertySymbols;\nvar __hasOwnProp$f = Object.prototype.hasOwnProperty;\nvar __propIsEnum$f = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$e = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$f.call(b, prop))\n      __defNormalProp$e(a, prop, b[prop]);\n  if (__getOwnPropSymbols$f)\n    for (var prop of __getOwnPropSymbols$f(b)) {\n      if (__propIsEnum$f.call(b, prop))\n        __defNormalProp$e(a, prop, b[prop]);\n    }\n  return a;\n};\nfunction useElementByPoint(options) {\n  const element = ref(null);\n  const { x, y, document = defaultDocument } = options;\n  const controls = useRafFn(() => {\n    element.value = (document == null ? void 0 : document.elementFromPoint(resolveUnref(x), resolveUnref(y))) || null;\n  });\n  return __spreadValues$e({\n    element\n  }, controls);\n}\n\nfunction useElementHover(el, options = {}) {\n  const delayEnter = options ? options.delayEnter : 0;\n  const delayLeave = options ? options.delayLeave : 0;\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  useResizeObserver(target, ([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 styles = window.getComputedStyle($elem);\n        width.value = parseFloat(styles.width);\n        height.value = parseFloat(styles.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  }, options);\n  watch(() => unrefElement(target), (ele) => {\n    width.value = ele ? initialSize.width : 0;\n    height.value = ele ? initialSize.height : 0;\n  });\n  return {\n    width,\n    height\n  };\n}\n\nfunction useElementVisibility(element, { window = defaultWindow, scrollTarget } = {}) {\n  const elementIsVisible = ref(false);\n  const testBounding = () => {\n    if (!window)\n      return;\n    const document = window.document;\n    const el = unrefElement(element);\n    if (!el) {\n      elementIsVisible.value = false;\n    } else {\n      const rect = el.getBoundingClientRect();\n      elementIsVisible.value = rect.top <= (window.innerHeight || document.documentElement.clientHeight) && rect.left <= (window.innerWidth || document.documentElement.clientWidth) && rect.bottom >= 0 && rect.right >= 0;\n    }\n  };\n  watch(() => unrefElement(element), () => testBounding(), { immediate: true, flush: \"post\" });\n  if (window) {\n    useEventListener(scrollTarget || window, \"scroll\", testBounding, {\n      capture: false,\n      passive: true\n    });\n  }\n  return elementIsVisible;\n}\n\nconst events = new Map();\n\nfunction useEventBus(key) {\n  const scope = getCurrentScope();\n  function on(listener) {\n    var _a;\n    const listeners = events.get(key) || [];\n    listeners.push(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    const index = listeners.indexOf(listener);\n    if (index > -1)\n      listeners.splice(index, 1);\n    if (!listeners.length)\n      events.delete(key);\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 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 = ref(null);\n  const {\n    withCredentials = false\n  } = options;\n  const close = () => {\n    if (eventSource.value) {\n      eventSource.value.close();\n      eventSource.value = null;\n      status.value = \"CLOSED\";\n    }\n  };\n  const es = new EventSource(url, { withCredentials });\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  };\n  es.onmessage = (e) => {\n    event.value = null;\n    data.value = e.data;\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  tryOnScopeDispose(() => {\n    close();\n  });\n  return {\n    eventSource,\n    event,\n    data,\n    status,\n    error,\n    close\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 = resolveRef(newIcon);\n  const applyIcon = (icon) => {\n    document == null ? void 0 : document.head.querySelectorAll(`link[rel*=\"${rel}\"]`).forEach((el) => el.href = `${baseUrl}${icon}`);\n  };\n  watch(favicon, (i, o) => {\n    if (isString(i) && i !== o)\n      applyIcon(i);\n  }, { immediate: true });\n  return favicon;\n}\n\nvar __defProp$d = Object.defineProperty;\nvar __defProps$3 = Object.defineProperties;\nvar __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols$e = Object.getOwnPropertySymbols;\nvar __hasOwnProp$e = Object.prototype.hasOwnProperty;\nvar __propIsEnum$e = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$d = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$e.call(b, prop))\n      __defNormalProp$d(a, prop, b[prop]);\n  if (__getOwnPropSymbols$e)\n    for (var prop of __getOwnPropSymbols$e(b)) {\n      if (__propIsEnum$e.call(b, prop))\n        __defNormalProp$d(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));\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\");\n}\nfunction isAbsoluteURL(url) {\n  return /^([a-z][a-z\\d+\\-.]*:)?\\/\\//i.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 !== void 0)\n        await callback(ctx);\n      return ctx;\n    };\n  } else {\n    return async (ctx) => {\n      await callbacks.reduce((prevCallback, callback) => prevCallback.then(async () => {\n        if (callback)\n          ctx = __spreadValues$d(__spreadValues$d({}, ctx), await callback(ctx));\n      }), Promise.resolve());\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 = resolveUnref(config.baseUrl);\n      const targetUrl = resolveUnref(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 = __spreadProps$3(__spreadValues$d(__spreadValues$d({}, options), 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 = __spreadProps$3(__spreadValues$d(__spreadValues$d({}, fetchOptions), args[0]), {\n          headers: __spreadValues$d(__spreadValues$d({}, headersToObject(fetchOptions.headers) || {}), headersToObject(args[0].headers) || {})\n        });\n      }\n    }\n    if (args.length > 1 && isFetchOptions(args[1])) {\n      options = __spreadProps$3(__spreadValues$d(__spreadValues$d({}, options), 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 = { immediate: true, refetch: false, timeout: 0 };\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 = __spreadValues$d(__spreadValues$d({}, options), args[0]);\n    else\n      fetchOptions = args[0];\n  }\n  if (args.length > 1) {\n    if (isFetchOptions(args[1]))\n      options = __spreadValues$d(__spreadValues$d({}, 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);\n  const canAbort = computed(() => supportsAbort && isFetching.value);\n  let controller;\n  let timer;\n  const abort = () => {\n    if (supportsAbort && controller) {\n      controller.abort();\n      controller = void 0;\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  const execute = async (throwOnFailed = false) => {\n    var _a2;\n    loading(true);\n    error.value = null;\n    statusCode.value = null;\n    aborted.value = false;\n    if (supportsAbort) {\n      abort();\n      controller = new AbortController();\n      controller.signal.onabort = () => aborted.value = true;\n      fetchOptions = __spreadProps$3(__spreadValues$d({}, fetchOptions), {\n        signal: controller.signal\n      });\n    }\n    const defaultFetchOptions = {\n      method: config.method,\n      headers: {}\n    };\n    if (config.payload) {\n      const headers = headersToObject(defaultFetchOptions.headers);\n      if (config.payloadType)\n        headers[\"Content-Type\"] = (_a2 = payloadMapping[config.payloadType]) != null ? _a2 : config.payloadType;\n      const payload = resolveUnref(config.payload);\n      defaultFetchOptions.body = config.payloadType === \"json\" ? JSON.stringify(payload) : payload;\n    }\n    let isCanceled = false;\n    const context = {\n      url: resolveUnref(url),\n      options: __spreadValues$d(__spreadValues$d({}, defaultFetchOptions), fetchOptions),\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 new Promise((resolve, reject) => {\n      var _a3;\n      fetch(context.url, __spreadProps$3(__spreadValues$d(__spreadValues$d({}, defaultFetchOptions), context.options), {\n        headers: __spreadValues$d(__spreadValues$d({}, headersToObject(defaultFetchOptions.headers)), headersToObject((_a3 = context.options) == null ? void 0 : _a3.headers))\n      })).then(async (fetchResponse) => {\n        response.value = fetchResponse;\n        statusCode.value = fetchResponse.status;\n        responseData = await fetchResponse[config.type]();\n        if (options.afterFetch && statusCode.value >= 200 && statusCode.value < 300)\n          ({ data: responseData } = await options.afterFetch({ data: responseData, response: fetchResponse }));\n        data.value = responseData;\n        if (!fetchResponse.ok)\n          throw new Error(fetchResponse.statusText);\n        responseEvent.trigger(fetchResponse);\n        return resolve(fetchResponse);\n      }).catch(async (fetchError) => {\n        let errorData = fetchError.message || fetchError.name;\n        if (options.onFetchError)\n          ({ data: responseData, error: errorData } = await options.onFetchError({ data: responseData, error: fetchError, response: response.value }));\n        data.value = responseData;\n        error.value = errorData;\n        errorEvent.trigger(fetchError);\n        if (throwOnFailed)\n          return reject(fetchError);\n        return resolve(null);\n      }).finally(() => {\n        loading(false);\n        if (timer)\n          timer.stop();\n        finallyEvent.trigger(null);\n      });\n    });\n  };\n  const refetch = resolveRef(options.refetch);\n  watch([\n    refetch,\n    resolveRef(url)\n  ], ([refetch2]) => refetch2 && execute(), { deep: true });\n  const shell = {\n    isFinished,\n    statusCode,\n    response,\n    error,\n    data,\n    isFetching,\n    canAbort,\n    aborted,\n    abort,\n    execute,\n    onFetchResponse: responseEvent.on,\n    onFetchError: errorEvent.on,\n    onFetchFinally: finallyEvent.on,\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    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            refetch,\n            resolveRef(config.payload)\n          ], ([refetch2]) => refetch2 && execute(), { deep: true });\n        }\n        const rawPayload = resolveUnref(config.payload);\n        if (!payloadType && rawPayload && Object.getPrototypeOf(rawPayload) === Object.prototype && !(rawPayload instanceof FormData))\n          config.payloadType = \"json\";\n        return __spreadProps$3(__spreadValues$d({}, 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 __spreadProps$3(__spreadValues$d({}, 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    setTimeout(execute, 0);\n  return __spreadProps$3(__spreadValues$d({}, 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\nvar __defProp$c = Object.defineProperty;\nvar __getOwnPropSymbols$d = Object.getOwnPropertySymbols;\nvar __hasOwnProp$d = Object.prototype.hasOwnProperty;\nvar __propIsEnum$d = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$c = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$d.call(b, prop))\n      __defNormalProp$c(a, prop, b[prop]);\n  if (__getOwnPropSymbols$d)\n    for (var prop of __getOwnPropSymbols$d(b)) {\n      if (__propIsEnum$d.call(b, prop))\n        __defNormalProp$c(a, prop, b[prop]);\n    }\n  return a;\n};\nconst DEFAULT_OPTIONS = {\n  multiple: true,\n  accept: \"*\"\n};\nfunction useFileDialog(options = {}) {\n  const {\n    document = defaultDocument\n  } = options;\n  const files = ref(null);\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    };\n  }\n  const open = (localOptions) => {\n    if (!input)\n      return;\n    const _options = __spreadValues$c(__spreadValues$c(__spreadValues$c({}, DEFAULT_OPTIONS), options), localOptions);\n    input.multiple = _options.multiple;\n    input.accept = _options.accept;\n    if (hasOwn(_options, \"capture\"))\n      input.capture = _options.capture;\n    input.click();\n  };\n  const reset = () => {\n    files.value = null;\n    if (input)\n      input.value = \"\";\n  };\n  return {\n    files: readonly(files),\n    open,\n    reset\n  };\n}\n\nvar __defProp$b = Object.defineProperty;\nvar __getOwnPropSymbols$c = Object.getOwnPropertySymbols;\nvar __hasOwnProp$c = Object.prototype.hasOwnProperty;\nvar __propIsEnum$c = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$b = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$c.call(b, prop))\n      __defNormalProp$b(a, prop, b[prop]);\n  if (__getOwnPropSymbols$c)\n    for (var prop of __getOwnPropSymbols$c(b)) {\n      if (__propIsEnum$c.call(b, prop))\n        __defNormalProp$b(a, prop, b[prop]);\n    }\n  return a;\n};\nfunction useFileSystemAccess(options = {}) {\n  const {\n    window: _window = defaultWindow,\n    dataType = \"Text\"\n  } = unref(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(__spreadValues$b(__spreadValues$b({}, unref(options)), _options));\n    fileHandle.value = handle;\n    await updateFile();\n    await updateData();\n  }\n  async function create(_options = {}) {\n    if (!isSupported.value)\n      return;\n    fileHandle.value = await window.showSaveFilePicker(__spreadValues$b(__spreadValues$b({}, unref(options)), _options));\n    data.value = void 0;\n    await updateFile();\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(__spreadValues$b(__spreadValues$b({}, unref(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    if (unref(dataType) === \"Text\")\n      data.value = await ((_a = file.value) == null ? void 0 : _a.text());\n    if (unref(dataType) === \"ArrayBuffer\")\n      data.value = await ((_b = file.value) == null ? void 0 : _b.arrayBuffer());\n    if (unref(dataType) === \"Blob\")\n      data.value = file.value;\n  }\n  watch(() => unref(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 } = options;\n  const innerFocused = ref(false);\n  const targetElement = computed(() => unrefElement(target));\n  useEventListener(targetElement, \"focus\", () => innerFocused.value = true);\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();\n    }\n  });\n  watch(targetElement, () => {\n    focused.value = initialValue;\n  }, { immediate: true, flush: \"post\" });\n  return { focused };\n}\n\nfunction useFocusWithin(target, options = {}) {\n  const activeElement = useActiveElement(options);\n  const targetElement = computed(() => unrefElement(target));\n  const focused = computed(() => targetElement.value && activeElement.value ? targetElement.value.contains(activeElement.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 functionsMap = [\n  [\n    \"requestFullscreen\",\n    \"exitFullscreen\",\n    \"fullscreenElement\",\n    \"fullscreenEnabled\",\n    \"fullscreenchange\",\n    \"fullscreenerror\"\n  ],\n  [\n    \"webkitRequestFullscreen\",\n    \"webkitExitFullscreen\",\n    \"webkitFullscreenElement\",\n    \"webkitFullscreenEnabled\",\n    \"webkitfullscreenchange\",\n    \"webkitfullscreenerror\"\n  ],\n  [\n    \"webkitRequestFullScreen\",\n    \"webkitCancelFullScreen\",\n    \"webkitCurrentFullScreenElement\",\n    \"webkitCancelFullScreen\",\n    \"webkitfullscreenchange\",\n    \"webkitfullscreenerror\"\n  ],\n  [\n    \"mozRequestFullScreen\",\n    \"mozCancelFullScreen\",\n    \"mozFullScreenElement\",\n    \"mozFullScreenEnabled\",\n    \"mozfullscreenchange\",\n    \"mozfullscreenerror\"\n  ],\n  [\n    \"msRequestFullscreen\",\n    \"msExitFullscreen\",\n    \"msFullscreenElement\",\n    \"msFullscreenEnabled\",\n    \"MSFullscreenChange\",\n    \"MSFullscreenError\"\n  ]\n];\nfunction useFullscreen(target, options = {}) {\n  const { document = defaultDocument, autoExit = false } = options;\n  const targetRef = target || (document == null ? void 0 : document.querySelector(\"html\"));\n  const isFullscreen = ref(false);\n  let map = functionsMap[0];\n  const isSupported = useSupported(() => {\n    if (!document) {\n      return false;\n    } else {\n      for (const m of functionsMap) {\n        if (m[1] in document) {\n          map = m;\n          return true;\n        }\n      }\n    }\n    return false;\n  });\n  const [REQUEST, EXIT, ELEMENT, , EVENT] = map;\n  async function exit() {\n    if (!isSupported.value)\n      return;\n    if (document == null ? void 0 : document[ELEMENT])\n      await document[EXIT]();\n    isFullscreen.value = false;\n  }\n  async function enter() {\n    if (!isSupported.value)\n      return;\n    await exit();\n    const target2 = unrefElement(targetRef);\n    if (target2) {\n      await target2[REQUEST]();\n      isFullscreen.value = true;\n    }\n  }\n  async function toggle() {\n    if (isFullscreen.value)\n      await exit();\n    else\n      await enter();\n  }\n  if (document) {\n    useEventListener(document, EVENT, () => {\n      isFullscreen.value = !!(document == null ? void 0 : document[ELEMENT]);\n    }, false);\n  }\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      hapticActuators,\n      index: gamepad.index,\n      mapping: gamepad.mapping,\n      connected: gamepad.connected,\n      timestamp: gamepad.timestamp,\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 (let i = 0; i < _gamepads.length; ++i) {\n      const gamepad = _gamepads[i];\n      if (gamepad) {\n        const index = gamepads.value.findIndex(({ index: index2 }) => index2 === gamepad.index);\n        if (index > -1)\n          gamepads.value[index] = stateFromGamepad(gamepad);\n      }\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    if (_gamepads) {\n      for (let i = 0; i < _gamepads.length; ++i) {\n        const gamepad = _gamepads[i];\n        if (gamepad)\n          onGamepadConnected(gamepad);\n      }\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 = ref(null);\n  const coords = ref({\n    accuracy: 0,\n    latitude: Infinity,\n    longitude: 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(updatePosition, (err) => error.value = err, {\n        enableHighAccuracy,\n        maximumAge,\n        timeout\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 onEvent = createFilterWrapper(eventFilter, () => {\n    idle.value = false;\n    lastActive.value = timestamp();\n    clearTimeout(timer);\n    timer = setTimeout(() => idle.value = true, timeout);\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  }\n  timer = setTimeout(() => idle.value = true, timeout);\n  return { idle, lastActive };\n}\n\nvar __defProp$a = Object.defineProperty;\nvar __getOwnPropSymbols$b = Object.getOwnPropertySymbols;\nvar __hasOwnProp$b = Object.prototype.hasOwnProperty;\nvar __propIsEnum$b = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$a = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$b.call(b, prop))\n      __defNormalProp$a(a, prop, b[prop]);\n  if (__getOwnPropSymbols$b)\n    for (var prop of __getOwnPropSymbols$b(b)) {\n      if (__propIsEnum$b.call(b, prop))\n        __defNormalProp$a(a, prop, b[prop]);\n    }\n  return a;\n};\nasync function loadImage(options) {\n  return new Promise((resolve, reject) => {\n    const img = new Image();\n    const { src, srcset, sizes } = options;\n    img.src = src;\n    if (srcset)\n      img.srcset = srcset;\n    if (sizes)\n      img.sizes = sizes;\n    img.onload = () => resolve(img);\n    img.onerror = reject;\n  });\n}\nconst useImage = (options, asyncStateOptions = {}) => {\n  const state = useAsyncState(() => loadImage(resolveUnref(options)), void 0, __spreadValues$a({\n    resetOnExecute: true\n  }, asyncStateOptions));\n  watch(() => resolveUnref(options), () => state.execute(asyncStateOptions.delay), { deep: true });\n  return state;\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  } = 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;\n    const _element = resolveUnref(element);\n    if (!_element)\n      return;\n    (_c = _element instanceof Document ? document.body : _element) == null ? void 0 : _c.scrollTo({\n      top: (_a = resolveUnref(_y)) != null ? _a : y.value,\n      left: (_b = resolveUnref(_x)) != null ? _b : x.value,\n      behavior: resolveUnref(behavior)\n    });\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 onScrollHandler = (e) => {\n    const eventTarget = e.target === document ? e.target.documentElement : e.target;\n    const scrollLeft = eventTarget.scrollLeft;\n    directions.left = scrollLeft < internalX.value;\n    directions.right = scrollLeft > internalY.value;\n    arrivedState.left = scrollLeft <= 0 + (offset.left || 0);\n    arrivedState.right = scrollLeft + eventTarget.clientWidth >= eventTarget.scrollWidth - (offset.right || 0) - ARRIVED_STATE_THRESHOLD_PIXELS;\n    internalX.value = scrollLeft;\n    let scrollTop = eventTarget.scrollTop;\n    if (e.target === document && !scrollTop)\n      scrollTop = document.body.scrollTop;\n    directions.top = scrollTop < internalY.value;\n    directions.bottom = scrollTop > internalY.value;\n    arrivedState.top = scrollTop <= 0 + (offset.top || 0);\n    arrivedState.bottom = scrollTop + eventTarget.clientHeight >= eventTarget.scrollHeight - (offset.bottom || 0) - ARRIVED_STATE_THRESHOLD_PIXELS;\n    internalY.value = scrollTop;\n    isScrolling.value = true;\n    onScrollEndDebounced(e);\n    onScroll(e);\n  };\n  useEventListener(element, \"scroll\", throttle ? useThrottleFn(onScrollHandler, throttle, true, false) : onScrollHandler, eventListenerOptions);\n  useEventListener(element, \"scrollend\", onScrollEnd, eventListenerOptions);\n  return {\n    x,\n    y,\n    isScrolling,\n    arrivedState,\n    directions\n  };\n}\n\nvar __defProp$9 = Object.defineProperty;\nvar __defProps$2 = Object.defineProperties;\nvar __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols$a = Object.getOwnPropertySymbols;\nvar __hasOwnProp$a = Object.prototype.hasOwnProperty;\nvar __propIsEnum$a = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$9 = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$a.call(b, prop))\n      __defNormalProp$9(a, prop, b[prop]);\n  if (__getOwnPropSymbols$a)\n    for (var prop of __getOwnPropSymbols$a(b)) {\n      if (__propIsEnum$a.call(b, prop))\n        __defNormalProp$9(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));\nfunction useInfiniteScroll(element, onLoadMore, options = {}) {\n  var _a, _b;\n  const direction = (_a = options.direction) != null ? _a : \"bottom\";\n  const state = reactive(useScroll(element, __spreadProps$2(__spreadValues$9({}, options), {\n    offset: __spreadValues$9({\n      [direction]: (_b = options.distance) != null ? _b : 0\n    }, options.offset)\n  })));\n  watch(() => state.arrivedState[direction], async (v) => {\n    var _a2, _b2;\n    if (v) {\n      const elem = resolveUnref(element);\n      const previous = {\n        height: (_a2 = elem == null ? void 0 : elem.scrollHeight) != null ? _a2 : 0,\n        width: (_b2 = elem == null ? void 0 : elem.scrollWidth) != null ? _b2 : 0\n      };\n      await onLoadMore(state);\n      if (options.preserveScrollPosition && elem) {\n        nextTick(() => {\n          elem.scrollTo({\n            top: elem.scrollHeight - previous.height,\n            left: elem.scrollWidth - previous.width\n          });\n        });\n      }\n    }\n  });\n}\n\nfunction useIntersectionObserver(target, callback, options = {}) {\n  const {\n    root,\n    rootMargin = \"0px\",\n    threshold = 0.1,\n    window = defaultWindow\n  } = options;\n  const isSupported = useSupported(() => window && \"IntersectionObserver\" in window);\n  let cleanup = noop;\n  const stopWatch = isSupported.value ? watch(() => ({\n    el: unrefElement(target),\n    root: unrefElement(root)\n  }), ({ el, root: root2 }) => {\n    cleanup();\n    if (!el)\n      return;\n    const observer = new IntersectionObserver(callback, {\n      root: root2,\n      rootMargin,\n      threshold\n    });\n    observer.observe(el);\n    cleanup = () => {\n      observer.disconnect();\n      cleanup = noop;\n    };\n  }, { immediate: true, flush: \"post\" }) : noop;\n  const stop = () => {\n    cleanup();\n    stopWatch();\n  };\n  tryOnScopeDispose(stop);\n  return {\n    isSupported,\n    stop\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(new Set());\n  const obj = {\n    toJSON() {\n      return {};\n    },\n    current\n  };\n  const refs = useReactive ? reactive(obj) : obj;\n  const metaDeps = new Set();\n  const usedKeys = 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(refs, {\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) => unref(proxy[key])));\n        } else {\n          refs[prop] = ref(false);\n        }\n      }\n      const r = Reflect.get(target2, prop, rec);\n      return useReactive ? unref(r) : r;\n    }\n  });\n  return proxy;\n}\n\nvar __defProp$8 = Object.defineProperty;\nvar __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;\nvar __hasOwnProp$9 = Object.prototype.hasOwnProperty;\nvar __propIsEnum$9 = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$8 = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$9.call(b, prop))\n      __defNormalProp$8(a, prop, b[prop]);\n  if (__getOwnPropSymbols$9)\n    for (var prop of __getOwnPropSymbols$9(b)) {\n      if (__propIsEnum$9.call(b, prop))\n        __defNormalProp$8(a, prop, b[prop]);\n    }\n  return a;\n};\nfunction usingElRef(source, cb) {\n  if (resolveUnref(source))\n    cb(resolveUnref(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  options = __spreadValues$8(__spreadValues$8({}, defaultOptions), options);\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 disableTrack = (track) => {\n    usingElRef(target, (el) => {\n      if (track) {\n        const id = isNumber(track) ? 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 = isNumber(track) ? 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 = resolveUnref(target);\n    if (!el)\n      return;\n    const src = resolveUnref(options.src);\n    let sources = [];\n    if (!src)\n      return;\n    if (isString(src))\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 = resolveUnref(target);\n    if (!el)\n      return;\n    el.querySelectorAll(\"source\").forEach((e) => e.removeEventListener(\"error\", sourceErrorEvent.trigger));\n  });\n  watch(volume, (vol) => {\n    const el = resolveUnref(target);\n    if (!el)\n      return;\n    el.volume = vol;\n  });\n  watch(muted, (mute) => {\n    const el = resolveUnref(target);\n    if (!el)\n      return;\n    el.muted = mute;\n  });\n  watch(rate, (rate2) => {\n    const el = resolveUnref(target);\n    if (!el)\n      return;\n    el.playbackRate = rate2;\n  });\n  watchEffect(() => {\n    if (!document)\n      return;\n    const textTracks = resolveUnref(options.tracks);\n    const el = resolveUnref(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 = resolveUnref(target);\n    if (!el)\n      return;\n    el.currentTime = time;\n  });\n  const { ignoreUpdates: ignorePlayingUpdates } = watchIgnorable(playing, (isPlaying) => {\n    const el = resolveUnref(target);\n    if (!el)\n      return;\n    isPlaying ? el.play() : el.pause();\n  });\n  useEventListener(target, \"timeupdate\", () => ignoreCurrentTimeUpdates(() => currentTime.value = resolveUnref(target).currentTime));\n  useEventListener(target, \"durationchange\", () => duration.value = resolveUnref(target).duration);\n  useEventListener(target, \"progress\", () => buffered.value = timeRangeToArray(resolveUnref(target).buffered));\n  useEventListener(target, \"seeking\", () => seeking.value = true);\n  useEventListener(target, \"seeked\", () => seeking.value = false);\n  useEventListener(target, \"waiting\", () => waiting.value = true);\n  useEventListener(target, \"playing\", () => {\n    waiting.value = false;\n    ended.value = false;\n  });\n  useEventListener(target, \"ratechange\", () => rate.value = resolveUnref(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 = resolveUnref(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 = resolveUnref(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    muted,\n    tracks,\n    selectedTrack,\n    enableTrack,\n    disableTrack,\n    supportsPictureInPicture,\n    togglePictureInPicture,\n    isPictureInPicture,\n    onSourceError: sourceErrorEvent.on\n  };\n}\n\nconst getMapVue2Compat = () => {\n  const data = reactive({});\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 reactive(options.cache);\n    if (isVue2)\n      return getMapVue2Compat();\n    return reactive(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\nfunction useMounted() {\n  const isMounted = ref(false);\n  onMounted(() => {\n    isMounted.value = true;\n  });\n  return isMounted;\n}\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    eventFilter\n  } = options;\n  const x = ref(initialValue.x);\n  const y = ref(initialValue.y);\n  const sourceType = ref(null);\n  const mouseHandler = (event) => {\n    if (type === \"page\") {\n      x.value = event.pageX;\n      y.value = event.pageY;\n    } else if (type === \"client\") {\n      x.value = event.clientX;\n      y.value = event.clientY;\n    } else if (type === \"movement\") {\n      x.value = event.movementX;\n      y.value = event.movementY;\n    }\n    sourceType.value = \"mouse\";\n  };\n  const reset = () => {\n    x.value = initialValue.x;\n    y.value = initialValue.y;\n  };\n  const touchHandler = (event) => {\n    if (event.touches.length > 0) {\n      const touch2 = event.touches[0];\n      if (type === \"page\") {\n        x.value = touch2.pageX;\n        y.value = touch2.pageY;\n      } else if (type === \"client\") {\n        x.value = touch2.clientX;\n        y.value = touch2.clientY;\n      }\n      sourceType.value = \"touch\";\n    }\n  };\n  const mouseHandlerWrapper = (event) => {\n    return eventFilter === void 0 ? mouseHandler(event) : eventFilter(() => mouseHandler(event), {});\n  };\n  const touchHandlerWrapper = (event) => {\n    return eventFilter === void 0 ? touchHandler(event) : eventFilter(() => touchHandler(event), {});\n  };\n  if (window) {\n    useEventListener(window, \"mousemove\", mouseHandlerWrapper, { passive: true });\n    useEventListener(window, \"dragover\", mouseHandlerWrapper, { passive: true });\n    if (touch && type !== \"movement\") {\n      useEventListener(window, \"touchstart\", touchHandlerWrapper, { passive: true });\n      useEventListener(window, \"touchmove\", touchHandlerWrapper, { passive: true });\n      if (resetOnTouchEnds)\n        useEventListener(window, \"touchend\", reset, { passive: true });\n    }\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 { 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([targetRef, x, y], () => {\n      const el = unrefElement(targetRef);\n      if (!el)\n        return;\n      const {\n        left,\n        top,\n        width,\n        height\n      } = el.getBoundingClientRect();\n      elementPositionX.value = left + window.pageXOffset;\n      elementPositionY.value = top + window.pageYOffset;\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    }, { immediate: true });\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    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 });\n  useEventListener(window, \"mouseleave\", onReleased, { passive: true });\n  useEventListener(window, \"mouseup\", onReleased, { passive: true });\n  if (drag) {\n    useEventListener(target, \"dragstart\", onPressed(\"mouse\"), { passive: true });\n    useEventListener(window, \"drop\", onReleased, { passive: true });\n    useEventListener(window, \"dragend\", onReleased, { passive: true });\n  }\n  if (touch) {\n    useEventListener(target, \"touchstart\", onPressed(\"touch\"), { passive: true });\n    useEventListener(window, \"touchend\", onReleased, { passive: true });\n    useEventListener(window, \"touchcancel\", onReleased, { passive: true });\n  }\n  return {\n    pressed,\n    sourceType\n  };\n}\n\nvar __getOwnPropSymbols$8 = Object.getOwnPropertySymbols;\nvar __hasOwnProp$8 = Object.prototype.hasOwnProperty;\nvar __propIsEnum$8 = Object.prototype.propertyIsEnumerable;\nvar __objRest$1 = (source, exclude) => {\n  var target = {};\n  for (var prop in source)\n    if (__hasOwnProp$8.call(source, prop) && exclude.indexOf(prop) < 0)\n      target[prop] = source[prop];\n  if (source != null && __getOwnPropSymbols$8)\n    for (var prop of __getOwnPropSymbols$8(source)) {\n      if (exclude.indexOf(prop) < 0 && __propIsEnum$8.call(source, prop))\n        target[prop] = source[prop];\n    }\n  return target;\n};\nfunction useMutationObserver(target, callback, options = {}) {\n  const _a = options, { window = defaultWindow } = _a, mutationOptions = __objRest$1(_a, [\"window\"]);\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 stopWatch = watch(() => unrefElement(target), (el) => {\n    cleanup();\n    if (isSupported.value && window && el) {\n      observer = new MutationObserver(callback);\n      observer.observe(el, mutationOptions);\n    }\n  }, { immediate: true });\n  const stop = () => {\n    cleanup();\n    stopWatch();\n  };\n  tryOnScopeDispose(stop);\n  return {\n    isSupported,\n    stop\n  };\n}\n\nconst 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,\n    isOnline,\n    saveData,\n    offlineAt,\n    onlineAt,\n    downlink,\n    downlinkMax,\n    effectiveType,\n    rtt,\n    type\n  };\n}\n\nvar __defProp$7 = Object.defineProperty;\nvar __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;\nvar __hasOwnProp$7 = Object.prototype.hasOwnProperty;\nvar __propIsEnum$7 = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$7 = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$7.call(b, prop))\n      __defNormalProp$7(a, prop, b[prop]);\n  if (__getOwnPropSymbols$7)\n    for (var prop of __getOwnPropSymbols$7(b)) {\n      if (__propIsEnum$7.call(b, prop))\n        __defNormalProp$7(a, prop, b[prop]);\n    }\n  return a;\n};\nfunction useNow(options = {}) {\n  const {\n    controls: exposeControls = false,\n    interval = \"requestAnimationFrame\"\n  } = options;\n  const now = ref(new Date());\n  const update = () => now.value = new Date();\n  const controls = interval === \"requestAnimationFrame\" ? useRafFn(update, { immediate: true }) : useIntervalFn(update, interval, { immediate: true });\n  if (exposeControls) {\n    return __spreadValues$7({\n      now\n    }, controls);\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(() => unref(object), (newObject) => {\n    release();\n    if (newObject)\n      url.value = URL.createObjectURL(newObject);\n  }, { immediate: true });\n  tryOnScopeDispose(release);\n  return readonly(url);\n}\n\nfunction useClamp(value, min, max) {\n  if (isFunction(value) || isReadonly(value))\n    return computed(() => clamp(resolveUnref(value), resolveUnref(min), resolveUnref(max)));\n  const _value = ref(value);\n  return computed({\n    get() {\n      return _value.value = clamp(_value.value, resolveUnref(min), resolveUnref(max));\n    },\n    set(value2) {\n      _value.value = clamp(value2, resolveUnref(min), resolveUnref(max));\n    }\n  });\n}\n\nfunction useOffsetPagination(options) {\n  const {\n    total = Infinity,\n    pageSize = 10,\n    page = 1,\n    onPageChange = noop,\n    onPageSizeChange = noop,\n    onPageCountChange = noop\n  } = options;\n  const currentPageSize = useClamp(pageSize, 1, Infinity);\n  const pageCount = computed(() => Math.max(1, Math.ceil(unref(total) / unref(currentPageSize))));\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  if (isRef(pageSize))\n    syncRef(pageSize, currentPageSize);\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 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 {\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    return \"mouse\";\n  });\n  const roll = computed(() => {\n    if (source.value === \"deviceOrientation\") {\n      const value = -orientation.beta / 90;\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      const value = orientation.gamma / 90;\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\nvar __defProp$6 = Object.defineProperty;\nvar __defProps$1 = Object.defineProperties;\nvar __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;\nvar __hasOwnProp$6 = Object.prototype.hasOwnProperty;\nvar __propIsEnum$6 = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$6 = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$6.call(b, prop))\n      __defNormalProp$6(a, prop, b[prop]);\n  if (__getOwnPropSymbols$6)\n    for (var prop of __getOwnPropSymbols$6(b)) {\n      if (__propIsEnum$6.call(b, prop))\n        __defNormalProp$6(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));\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    useEventListener(target, \"pointerdown\", handler, { passive: true });\n    useEventListener(target, \"pointermove\", handler, { passive: true });\n    useEventListener(target, \"pointerleave\", () => isInside.value = false, { passive: true });\n  }\n  return __spreadProps$1(__spreadValues$6({}, toRefs(state)), {\n    isInside\n  });\n}\n\nfunction usePointerLock(target, options = {}) {\n  const { document = defaultDocument, pointerLockOptions } = 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, options2) {\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(options2 != null ? options2 : pointerLockOptions);\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\nvar SwipeDirection;\n(function(SwipeDirection2) {\n  SwipeDirection2[\"UP\"] = \"UP\";\n  SwipeDirection2[\"RIGHT\"] = \"RIGHT\";\n  SwipeDirection2[\"DOWN\"] = \"DOWN\";\n  SwipeDirection2[\"LEFT\"] = \"LEFT\";\n  SwipeDirection2[\"NONE\"] = \"NONE\";\n})(SwipeDirection || (SwipeDirection = {}));\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 SwipeDirection.NONE;\n    if (abs(diffX.value) > abs(diffY.value)) {\n      return diffX.value > 0 ? SwipeDirection.LEFT : SwipeDirection.RIGHT;\n    } else {\n      return diffY.value > 0 ? SwipeDirection.UP : SwipeDirection.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 (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      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\", onTouchEnd, listenerOptions),\n    useEventListener(target, \"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 usePointerSwipe(target, options = {}) {\n  const targetRef = resolveRef(target);\n  const {\n    threshold = 50,\n    onSwipe,\n    onSwipeEnd,\n    onSwipeStart\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 SwipeDirection.NONE;\n    if (abs(distanceX.value) > abs(distanceY.value)) {\n      return distanceX.value > 0 ? SwipeDirection.LEFT : SwipeDirection.RIGHT;\n    } else {\n      return distanceY.value > 0 ? SwipeDirection.UP : SwipeDirection.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      var _a, _b;\n      if (!eventIsAllowed(e))\n        return;\n      isPointerDown.value = true;\n      (_b = (_a = targetRef.value) == null ? void 0 : _a.style) == null ? void 0 : _b.setProperty(\"touch-action\", \"none\");\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      var _a, _b;\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      (_b = (_a = targetRef.value) == null ? void 0 : _a.style) == null ? void 0 : _b.setProperty(\"touch-action\", \"initial\");\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(resolveRef(value), (_, oldValue) => {\n    previous.value = oldValue;\n  }, { flush: \"sync\" });\n  return readonly(previous);\n}\n\nconst 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)\n      return Promise.reject(new Error(\"Not supported\"));\n    return screenOrientation.lock(type);\n  };\n  const unlockOrientation = () => {\n    if (isSupported.value)\n      screenOrientation.unlock();\n  };\n  return {\n    isSupported,\n    orientation,\n    angle,\n    lockOrientation,\n    unlockOrientation\n  };\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=\"${resolveUnref(src)}\"]`);\n    if (!el) {\n      el = document.createElement(\"script\");\n      el.type = type;\n      el.async = async;\n      el.src = resolveUnref(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=\"${resolveUnref(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.clientHeight < ele.scrollHeight || style.overflowY === \"auto\" && ele.clientWidth < ele.scrollWidth) {\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}\nfunction useScrollLock(element, initialState = false) {\n  const isLocked = ref(initialState);\n  let stopTouchMoveListener = null;\n  let initialOverflow;\n  watch(resolveRef(element), (el) => {\n    if (el) {\n      const ele = el;\n      initialOverflow = ele.style.overflow;\n      if (isLocked.value)\n        ele.style.overflow = \"hidden\";\n    }\n  }, {\n    immediate: true\n  });\n  const lock = () => {\n    const ele = resolveUnref(element);\n    if (!ele || isLocked.value)\n      return;\n    if (isIOS) {\n      stopTouchMoveListener = useEventListener(ele, \"touchmove\", (e) => {\n        preventDefault(e);\n      }, { passive: false });\n    }\n    ele.style.overflow = \"hidden\";\n    isLocked.value = true;\n  };\n  const unlock = () => {\n    const ele = resolveUnref(element);\n    if (!ele || !isLocked.value)\n      return;\n    isIOS && (stopTouchMoveListener == null ? void 0 : stopTouchMoveListener());\n    ele.style.overflow = initialOverflow;\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\n        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\nvar __defProp$5 = Object.defineProperty;\nvar __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;\nvar __hasOwnProp$5 = Object.prototype.hasOwnProperty;\nvar __propIsEnum$5 = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$5 = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$5.call(b, prop))\n      __defNormalProp$5(a, prop, b[prop]);\n  if (__getOwnPropSymbols$5)\n    for (var prop of __getOwnPropSymbols$5(b)) {\n      if (__propIsEnum$5.call(b, prop))\n        __defNormalProp$5(a, prop, b[prop]);\n    }\n  return a;\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 = __spreadValues$5(__spreadValues$5({}, resolveUnref(shareOptions)), resolveUnref(overrideOptions));\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([...unref(source)], compareFn));\n  watchEffect(() => {\n    const result = sortFn(unref(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    window = defaultWindow\n  } = options;\n  const lang = resolveRef(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 = unref(lang);\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 transcript = Array.from(event.results).map((result2) => {\n        isFinal.value = result2.isFinal;\n        return result2[0];\n      }).map((result2) => result2.transcript).join(\"\");\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 = unref(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 = resolveRef(text || \"\");\n  const lang = resolveRef(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 = unref(lang);\n    utterance2.voice = unref(options.voice) || null;\n    utterance2.pitch = pitch;\n    utterance2.rate = 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    utterance && 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\nvar __defProp$4 = Object.defineProperty;\nvar __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;\nvar __hasOwnProp$4 = Object.prototype.hasOwnProperty;\nvar __propIsEnum$4 = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$4 = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$4.call(b, prop))\n      __defNormalProp$4(a, prop, b[prop]);\n  if (__getOwnPropSymbols$4)\n    for (var prop of __getOwnPropSymbols$4(b)) {\n      if (__propIsEnum$4.call(b, prop))\n        __defNormalProp$4(a, prop, b[prop]);\n    }\n  return a;\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 = resolveUnref(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(\"getDefaultStorage\", () => {\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 (isFunction(mergeDefaults))\n          data.value = mergeDefaults(value, rawInit);\n        else if (type === \"object\" && !Array.isArray(value))\n          data.value = __spreadValues$4(__spreadValues$4({}, rawInit), value);\n        else\n          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) => setTimeout(() => read(e), 0));\n  if (storage) {\n    watchWithFilter(data, 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      flush,\n      deep,\n      eventFilter\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.type = \"text/css\";\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(cssRef, (value) => {\n      el.textContent = value;\n    }, { immediate: true });\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 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(document.querySelector(selector), () => dir.value = getValue(), { attributes: true });\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  const ranges = new Array(rangeCount);\n  for (let i = 0; i < rangeCount; i++) {\n    const range = selection.getRangeAt(i);\n    ranges[i] = range;\n  }\n  return ranges;\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  const textarea = ref(options == null ? void 0 : options.element);\n  const input = ref(options == null ? void 0 : options.input);\n  function triggerResize() {\n    var _a, _b;\n    if (!textarea.value)\n      return;\n    textarea.value.style.height = \"1px\";\n    textarea.value.style.height = `${(_a = textarea.value) == null ? void 0 : _a.scrollHeight}px`;\n    (_b = options == null ? void 0 : options.onResize) == null ? void 0 : _b.call(options);\n  }\n  watch([input, textarea], triggerResize, { immediate: true });\n  useResizeObserver(textarea, () => triggerResize());\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\nvar __defProp$3 = Object.defineProperty;\nvar __defProps = Object.defineProperties;\nvar __getOwnPropDescs = Object.getOwnPropertyDescriptors;\nvar __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;\nvar __hasOwnProp$3 = Object.prototype.hasOwnProperty;\nvar __propIsEnum$3 = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$3 = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$3.call(b, prop))\n      __defNormalProp$3(a, prop, b[prop]);\n  if (__getOwnPropSymbols$3)\n    for (var prop of __getOwnPropSymbols$3(b)) {\n      if (__propIsEnum$3.call(b, prop))\n        __defNormalProp$3(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));\nfunction useThrottledRefHistory(source, options = {}) {\n  const { throttle = 200, trailing = true } = options;\n  const filter = throttleFilter(throttle, trailing);\n  const history = useRefHistory(source, __spreadProps(__spreadValues$3({}, options), { eventFilter: filter }));\n  return __spreadValues$3({}, history);\n}\n\nvar __defProp$2 = Object.defineProperty;\nvar __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;\nvar __hasOwnProp$2 = Object.prototype.hasOwnProperty;\nvar __propIsEnum$2 = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$2 = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$2.call(b, prop))\n      __defNormalProp$2(a, prop, b[prop]);\n  if (__getOwnPropSymbols$2)\n    for (var prop of __getOwnPropSymbols$2(b)) {\n      if (__propIsEnum$2.call(b, prop))\n        __defNormalProp$2(a, prop, b[prop]);\n    }\n  return a;\n};\nvar __objRest = (source, exclude) => {\n  var target = {};\n  for (var prop in source)\n    if (__hasOwnProp$2.call(source, prop) && exclude.indexOf(prop) < 0)\n      target[prop] = source[prop];\n  if (source != null && __getOwnPropSymbols$2)\n    for (var prop of __getOwnPropSymbols$2(source)) {\n      if (exclude.indexOf(prop) < 0 && __propIsEnum$2.call(source, prop))\n        target[prop] = source[prop];\n    }\n  return target;\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: 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};\nconst DEFAULT_FORMATTER = (date) => date.toISOString().slice(0, 10);\nfunction useTimeAgo(time, options = {}) {\n  const {\n    controls: exposeControls = false,\n    updateInterval = 3e4\n  } = options;\n  const _a = useNow({ interval: updateInterval, controls: true }), { now } = _a, controls = __objRest(_a, [\"now\"]);\n  const timeAgo = computed(() => formatTimeAgo(new Date(resolveUnref(time)), options, unref(now.value)));\n  if (exposeControls) {\n    return __spreadValues$2({\n      timeAgo\n    }, controls);\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);\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\nvar __defProp$1 = Object.defineProperty;\nvar __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;\nvar __hasOwnProp$1 = Object.prototype.hasOwnProperty;\nvar __propIsEnum$1 = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues$1 = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp$1.call(b, prop))\n      __defNormalProp$1(a, prop, b[prop]);\n  if (__getOwnPropSymbols$1)\n    for (var prop of __getOwnPropSymbols$1(b)) {\n      if (__propIsEnum$1.call(b, prop))\n        __defNormalProp$1(a, prop, b[prop]);\n    }\n  return a;\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 __spreadValues$1({\n      timestamp: ts\n    }, controls);\n  } else {\n    return ts;\n  }\n}\n\nfunction useTitle(newTitle = null, options = {}) {\n  var _a, _b;\n  const {\n    document = defaultDocument\n  } = options;\n  const title = resolveRef((_a = newTitle != null ? newTitle : document == null ? void 0 : document.title) != null ? _a : null);\n  const isReadonly = newTitle && isFunction(newTitle);\n  function format(t) {\n    if (!(\"titleTemplate\" in options))\n      return t;\n    const template = options.titleTemplate || \"%s\";\n    return isFunction(template) ? template(t) : unref(template).replace(/%s/g, t);\n  }\n  watch(title, (t, o) => {\n    if (t !== o && document)\n      document.title = format(isString(t) ? t : \"\");\n  }, { immediate: true });\n  if (options.observe && !options.titleTemplate && document && !isReadonly) {\n    useMutationObserver((_b = document.head) == null ? void 0 : _b.querySelector(\"title\"), () => {\n      if (document && document.title !== title.value)\n        title.value = format(document.title);\n    }, { childList: true });\n  }\n  return title;\n}\n\nvar __defProp = Object.defineProperty;\nvar __getOwnPropSymbols = Object.getOwnPropertySymbols;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __propIsEnum = Object.prototype.propertyIsEnumerable;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __spreadValues = (a, b) => {\n  for (var prop in b || (b = {}))\n    if (__hasOwnProp.call(b, prop))\n      __defNormalProp(a, prop, b[prop]);\n  if (__getOwnPropSymbols)\n    for (var prop of __getOwnPropSymbols(b)) {\n      if (__propIsEnum.call(b, prop))\n        __defNormalProp(a, prop, b[prop]);\n    }\n  return a;\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 = __spreadValues({\n  linear: identity\n}, _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 useTransition(source, options = {}) {\n  const {\n    delay = 0,\n    disabled = false,\n    duration = 1e3,\n    onFinished = noop,\n    onStarted = noop,\n    transition = identity\n  } = options;\n  const currentTransition = computed(() => {\n    const t = unref(transition);\n    return isFunction(t) ? t : createEasingFunction(t);\n  });\n  const sourceValue = computed(() => {\n    const s = unref(source);\n    return isNumber(s) ? s : s.map(unref);\n  });\n  const sourceVector = computed(() => isNumber(sourceValue.value) ? [sourceValue.value] : sourceValue.value);\n  const outputVector = ref(sourceVector.value.slice(0));\n  let currentDuration;\n  let diffVector;\n  let endAt;\n  let startAt;\n  let startVector;\n  const { resume, pause } = useRafFn(() => {\n    const now = Date.now();\n    const progress = clamp(1 - (endAt - now) / currentDuration, 0, 1);\n    outputVector.value = startVector.map((val, i) => {\n      var _a;\n      return val + ((_a = diffVector[i]) != null ? _a : 0) * currentTransition.value(progress);\n    });\n    if (progress >= 1) {\n      pause();\n      onFinished();\n    }\n  }, { immediate: false });\n  const start = () => {\n    pause();\n    currentDuration = unref(duration);\n    diffVector = outputVector.value.map((n, i) => {\n      var _a, _b;\n      return ((_a = sourceVector.value[i]) != null ? _a : 0) - ((_b = outputVector.value[i]) != null ? _b : 0);\n    });\n    startVector = outputVector.value.slice(0);\n    startAt = Date.now();\n    endAt = startAt + currentDuration;\n    resume();\n    onStarted();\n  };\n  const timeout = useTimeoutFn(start, delay, { immediate: false });\n  watch(sourceVector, () => {\n    if (unref(disabled))\n      return;\n    if (unref(delay) <= 0)\n      start();\n    else\n      timeout.start();\n  }, { deep: true });\n  watch(() => unref(disabled), (v) => {\n    if (v) {\n      outputVector.value = sourceVector.value.slice(0);\n      pause();\n    }\n  });\n  return computed(() => {\n    const targetVector = unref(disabled) ? sourceVector : outputVector;\n    return isNumber(sourceValue.value) ? targetVector.value[0] : targetVector.value;\n  });\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(state, () => {\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  }, { deep: true });\n  function write(params, shouldUpdate) {\n    pause();\n    if (shouldUpdate)\n      updateState(params);\n    window.history.replaceState(window.history.state, window.document.title, window.location.pathname + constructQuery(params));\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 videoDeviceId = ref(options.videoDeviceId);\n  const audioDeviceId = ref(options.audioDeviceId);\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(device) {\n    if (device.value === \"none\" || device.value === false)\n      return false;\n    if (device.value == null)\n      return true;\n    return {\n      deviceId: device.value\n    };\n  }\n  async function _start() {\n    if (!isSupported.value || stream.value)\n      return;\n    stream.value = await navigator.mediaDevices.getUserMedia({\n      video: getDeviceOptions(videoDeviceId),\n      audio: getDeviceOptions(audioDeviceId)\n    });\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  async function restart() {\n    _stop();\n    return await start();\n  }\n  watch(enabled, (v) => {\n    if (v)\n      _start();\n    else\n      _stop();\n  }, { immediate: true });\n  watch([videoDeviceId, audioDeviceId], () => {\n    if (autoSwitch.value && stream.value)\n      restart();\n  }, { immediate: true });\n  return {\n    isSupported,\n    stream,\n    start,\n    stop,\n    restart,\n    videoDeviceId,\n    audioDeviceId,\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  } = 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 = eventName || event || `update:${key.toString()}`;\n  const cloneFn = (val) => !clone ? val : isFunction(clone) ? clone(val) : cloneFnJSON(val);\n  const getValue = () => isDef(props[key]) ? cloneFn(props[key]) : defaultValue;\n  if (passive) {\n    const initialValue = getValue();\n    const proxy = ref(initialValue);\n    watch(() => props[key], (v) => proxy.value = cloneFn(v));\n    watch(proxy, (v) => {\n      if (v !== props[key] || deep)\n        _emit(event, v);\n    }, { deep });\n    return proxy;\n  } else {\n    return computed({\n      get() {\n        return getValue();\n      },\n      set(value) {\n        _emit(event, value);\n      }\n    });\n  }\n}\n\nfunction useVModels(props, emit, options = {}) {\n  const ret = {};\n  for (const key in props)\n    ret[key] = useVModel(props, key, emit, options);\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 = resolveRef(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(vibrate, interval, {\n      immediate: false,\n      immediateCallback: false\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, calculateRange) {\n  watch([size.width, size.height, list], () => {\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, 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, 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\nconst useWakeLock = (options = {}) => {\n  const {\n    navigator = defaultNavigator,\n    document = defaultDocument\n  } = options;\n  let wakeLock;\n  const isSupported = useSupported(() => navigator && \"wakeLock\" in navigator);\n  const isActive = ref(false);\n  async function onVisibilityChange() {\n    if (!isSupported.value || !wakeLock)\n      return;\n    if (document && document.visibilityState === \"visible\")\n      wakeLock = await navigator.wakeLock.request(\"screen\");\n    isActive.value = !wakeLock.released;\n  }\n  if (document)\n    useEventListener(document, \"visibilitychange\", onVisibilityChange, { passive: true });\n  async function request(type) {\n    if (!isSupported.value)\n      return;\n    wakeLock = await navigator.wakeLock.request(type);\n    isActive.value = !wakeLock.released;\n  }\n  async function release() {\n    if (!isSupported.value || !wakeLock)\n      return;\n    await wakeLock.release();\n    isActive.value = !wakeLock.released;\n    wakeLock = null;\n  }\n  return {\n    isSupported,\n    isActive,\n    request,\n    release\n  };\n};\n\nconst useWebNotification = (defaultOptions = {}) => {\n  const {\n    window = defaultWindow\n  } = defaultOptions;\n  const isSupported = useSupported(() => !!window && \"Notification\" in window);\n  const notification = ref(null);\n  const requestPermission = async () => {\n    if (!isSupported.value)\n      return;\n    if (\"permission\" in Notification && Notification.permission !== \"denied\")\n      await Notification.requestPermission();\n  };\n  const onClick = createEventHook();\n  const onShow = createEventHook();\n  const onError = createEventHook();\n  const onClose = createEventHook();\n  const show = async (overrides) => {\n    if (!isSupported.value)\n      return;\n    await requestPermission();\n    const options = Object.assign({}, defaultOptions, overrides);\n    notification.value = new Notification(options.title || \"\", options);\n    notification.value.onclick = (event) => onClick.trigger(event);\n    notification.value.onshow = (event) => onShow.trigger(event);\n    notification.value.onerror = (event) => onError.trigger(event);\n    notification.value.onclose = (event) => onClose.trigger(event);\n    return notification.value;\n  };\n  const close = () => {\n    if (notification.value)\n      notification.value.close();\n    notification.value = null;\n  };\n  tryOnMounted(async () => {\n    if (isSupported.value)\n      await requestPermission();\n  });\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    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 = resolveRef(url);\n  let heartbeatPause;\n  let heartbeatResume;\n  let explicitlyClosed = false;\n  let retried = 0;\n  let bufferedData = [];\n  let pongTimeoutWait;\n  const close = (code = 1e3, reason) => {\n    if (!wsRef.value)\n      return;\n    explicitlyClosed = true;\n    heartbeatPause == null ? void 0 : heartbeatPause();\n    wsRef.value.close(code, reason);\n  };\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 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      onConnected == null ? void 0 : onConnected(ws);\n      heartbeatResume == null ? void 0 : heartbeatResume();\n      _sendBuffer();\n    };\n    ws.onclose = (ev) => {\n      status.value = \"CLOSED\";\n      wsRef.value = void 0;\n      onDisconnected == null ? void 0 : onDisconnected(ws, ev);\n      if (!explicitlyClosed && options.autoReconnect) {\n        const {\n          retries = -1,\n          delay = 1e3,\n          onFailed\n        } = resolveNestedOptions(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    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        } = resolveNestedOptions(options.heartbeat);\n        if (e.data === message)\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      send(message, false);\n      if (pongTimeoutWait != null)\n        return;\n      pongTimeoutWait = setTimeout(() => {\n        close();\n      }, pongTimeout);\n    }, interval, { immediate: false });\n    heartbeatPause = pause;\n    heartbeatResume = resume;\n  }\n  if (autoClose) {\n    useEventListener(window, \"beforeunload\", () => close());\n    tryOnScopeDispose(close);\n  }\n  const open = () => {\n    close();\n    explicitlyClosed = false;\n    retried = 0;\n    _init();\n  };\n  if (immediate)\n    watch(urlRef, open, { immediate: true });\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 = function post2(val) {\n    if (!worker.value)\n      return;\n    worker.value.postMessage(val);\n  };\n  const terminate = function terminate2() {\n    if (!worker.value)\n      return;\n    worker.value.terminate();\n  };\n  if (window) {\n    if (isString(arg0))\n      worker.value = new Worker(arg0, workerOptions);\n    else if (isFunction(arg0))\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\nconst jobRunner = (userFunc) => (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\nconst depsParser = (deps) => {\n  if (deps.length === 0)\n    return \"\";\n  const depsString = deps.map((dep) => `'${dep}'`).toString();\n  return `importScripts(${depsString})`;\n};\n\nconst createWorkerBlobUrl = (fn, deps) => {\n  const blobCode = `${depsParser(deps)}; onmessage=(${jobRunner})(${fn})`;\n  const blob = new Blob([blobCode], { type: \"text/javascript\" });\n  const url = URL.createObjectURL(blob);\n  return url;\n};\n\nconst useWebWorkerFn = (fn, options = {}) => {\n  const {\n    dependencies = [],\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);\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      reject(e);\n      workerTerminate(\"ERROR\");\n    };\n    if (timeout) {\n      timeoutId.value = setTimeout(() => workerTerminate(\"TIMEOUT_EXPIRED\"), timeout);\n    }\n    return newWorker;\n  };\n  const callWorker = (...fnArgs) => new Promise((resolve, reject) => {\n    promise.value = {\n      resolve,\n      reject\n    };\n    worker.value && worker.value.postMessage([[...fnArgs]]);\n    workerStatus.value = \"RUNNING\";\n  });\n  const workerFn = (...fnArgs) => {\n    if (workerStatus.value === \"RUNNING\") {\n      console.error(\"[useWebWorkerFn] You can only run one instance of the worker at a time.\");\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({ window = defaultWindow } = {}) {\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({ window = defaultWindow } = {}) {\n  if (!window) {\n    return {\n      x: ref(0),\n      y: ref(0)\n    };\n  }\n  const x = ref(window.scrollX);\n  const y = ref(window.scrollY);\n  useEventListener(window, \"scroll\", () => {\n    x.value = window.scrollX;\n    y.value = window.scrollY;\n  }, {\n    capture: false,\n    passive: true\n  });\n  return { x, y };\n}\n\nfunction useWindowSize(options = {}) {\n  const {\n    window = defaultWindow,\n    initialWidth = Infinity,\n    initialHeight = Infinity,\n    listenOrientation = true,\n    includeScrollbar = true\n  } = options;\n  const width = ref(initialWidth);\n  const height = ref(initialHeight);\n  const update = () => {\n    if (window) {\n      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    useEventListener(\"orientationchange\", update, { passive: true });\n  return { width, height };\n}\n\nexport { DefaultMagicKeysAliasMap, StorageSerializers, SwipeDirection, TransitionPresets, computedAsync as asyncComputed, breakpointsAntDesign, breakpointsBootstrapV5, breakpointsMasterCss, breakpointsQuasar, breakpointsSematic, breakpointsTailwind, breakpointsVuetify, cloneFnJSON, computedAsync, computedInject, createFetch, createUnrefFn, customStorageEventName, defaultDocument, defaultLocation, defaultNavigator, defaultWindow, formatTimeAgo, getSSRHandler, mapGamepadToXbox360Controller, onClickOutside, onKeyDown, onKeyPressed, onKeyStroke, onKeyUp, onLongPress, onStartTyping, setSSRHandler, templateRef, unrefElement, useActiveElement, useAsyncQueue, useAsyncState, useBase64, useBattery, useBluetooth, useBreakpoints, useBroadcastChannel, useBrowserLocation, useCached, useClipboard, 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, 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","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Set = getNative(root, 'Set');\n\nexport default Set;\n","/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n  this.__data__.set(value, HASH_UNDEFINED);\n  return this;\n}\n\nexport default setCacheAdd;\n","/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n  return this.__data__.has(value);\n}\n\nexport default setCacheHas;\n","import MapCache from './_MapCache.js';\nimport setCacheAdd from './_setCacheAdd.js';\nimport setCacheHas from './_setCacheHas.js';\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n  var index = -1,\n      length = values == null ? 0 : values.length;\n\n  this.__data__ = new MapCache;\n  while (++index < length) {\n    this.add(values[index]);\n  }\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\nexport default SetCache;\n","import ListCache from './_ListCache.js';\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n  this.__data__ = new ListCache;\n  this.size = 0;\n}\n\nexport default stackClear;\n","/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n  var data = this.__data__,\n      result = data['delete'](key);\n\n  this.size = data.size;\n  return result;\n}\n\nexport default stackDelete;\n","/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n  return this.__data__.get(key);\n}\n\nexport default stackGet;\n","/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n  return this.__data__.has(key);\n}\n\nexport default stackHas;\n","import ListCache from './_ListCache.js';\nimport Map from './_Map.js';\nimport MapCache from './_MapCache.js';\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n  var data = this.__data__;\n  if (data instanceof ListCache) {\n    var pairs = data.__data__;\n    if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n      pairs.push([key, value]);\n      this.size = ++data.size;\n      return this;\n    }\n    data = this.__data__ = new MapCache(pairs);\n  }\n  data.set(key, value);\n  this.size = data.size;\n  return this;\n}\n\nexport default stackSet;\n","import ListCache from './_ListCache.js';\nimport stackClear from './_stackClear.js';\nimport stackDelete from './_stackDelete.js';\nimport stackGet from './_stackGet.js';\nimport stackHas from './_stackHas.js';\nimport stackSet from './_stackSet.js';\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n  var data = this.__data__ = new ListCache(entries);\n  this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\nexport default Stack;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Uint8Array = root.Uint8Array;\n\nexport default Uint8Array;\n","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n  var index = -1,\n      result = Array(n);\n\n  while (++index < n) {\n    result[index] = iteratee(index);\n  }\n  return result;\n}\n\nexport default baseTimes;\n","import baseTimes from './_baseTimes.js';\nimport isArguments from './isArguments.js';\nimport isArray from './isArray.js';\nimport isBuffer from './isBuffer.js';\nimport isIndex from './_isIndex.js';\nimport isTypedArray from './isTypedArray.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n  var isArr = isArray(value),\n      isArg = !isArr && isArguments(value),\n      isBuff = !isArr && !isArg && isBuffer(value),\n      isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n      skipIndexes = isArr || isArg || isBuff || isType,\n      result = skipIndexes ? baseTimes(value.length, String) : [],\n      length = result.length;\n\n  for (var key in value) {\n    if ((inherited || hasOwnProperty.call(value, key)) &&\n        !(skipIndexes && (\n           // Safari 9 has enumerable `arguments.length` in strict mode.\n           key == 'length' ||\n           // Node.js 0.10 has enumerable non-index properties on buffers.\n           (isBuff && (key == 'offset' || key == 'parent')) ||\n           // PhantomJS 2 has enumerable non-index properties on typed arrays.\n           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n           // Skip index properties.\n           isIndex(key, length)\n        ))) {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nexport default arrayLikeKeys;\n","/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n  var index = -1,\n      length = values.length,\n      offset = array.length;\n\n  while (++index < length) {\n    array[offset + index] = values[index];\n  }\n  return array;\n}\n\nexport default arrayPush;\n","/**\n * The base implementation of `_.findIndex` and `_.findLastIndex` without\n * support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} predicate The function invoked per iteration.\n * @param {number} fromIndex The index to search from.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction baseFindIndex(array, predicate, fromIndex, fromRight) {\n  var length = array.length,\n      index = fromIndex + (fromRight ? 1 : -1);\n\n  while ((fromRight ? index-- : ++index < length)) {\n    if (predicate(array[index], index, array)) {\n      return index;\n    }\n  }\n  return -1;\n}\n\nexport default baseFindIndex;\n","import Symbol from './_Symbol.js';\nimport isArguments from './isArguments.js';\nimport isArray from './isArray.js';\n\n/** Built-in value references. */\nvar spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;\n\n/**\n * Checks if `value` is a flattenable `arguments` object or array.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n */\nfunction isFlattenable(value) {\n  return isArray(value) || isArguments(value) ||\n    !!(spreadableSymbol && value && value[spreadableSymbol]);\n}\n\nexport default isFlattenable;\n","import arrayPush from './_arrayPush.js';\nimport isFlattenable from './_isFlattenable.js';\n\n/**\n * The base implementation of `_.flatten` with support for restricting flattening.\n *\n * @private\n * @param {Array} array The array to flatten.\n * @param {number} depth The maximum recursion depth.\n * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n * @param {Array} [result=[]] The initial result value.\n * @returns {Array} Returns the new flattened array.\n */\nfunction baseFlatten(array, depth, predicate, isStrict, result) {\n  var index = -1,\n      length = array.length;\n\n  predicate || (predicate = isFlattenable);\n  result || (result = []);\n\n  while (++index < length) {\n    var value = array[index];\n    if (depth > 0 && predicate(value)) {\n      if (depth > 1) {\n        // Recursively flatten arrays (susceptible to call stack limits).\n        baseFlatten(value, depth - 1, predicate, isStrict, result);\n      } else {\n        arrayPush(result, value);\n      }\n    } else if (!isStrict) {\n      result[result.length] = value;\n    }\n  }\n  return result;\n}\n\nexport default baseFlatten;\n","import arrayPush from './_arrayPush.js';\nimport isArray from './isArray.js';\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n  var result = keysFunc(object);\n  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\nexport default baseGetAllKeys;\n","/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n *  else `false`.\n */\nfunction arraySome(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length;\n\n  while (++index < length) {\n    if (predicate(array[index], index, array)) {\n      return true;\n    }\n  }\n  return false;\n}\n\nexport default arraySome;\n","import SetCache from './_SetCache.js';\nimport arraySome from './_arraySome.js';\nimport cacheHas from './_cacheHas.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      arrLength = array.length,\n      othLength = other.length;\n\n  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n    return false;\n  }\n  // Check that cyclic values are equal.\n  var arrStacked = stack.get(array);\n  var othStacked = stack.get(other);\n  if (arrStacked && othStacked) {\n    return arrStacked == other && othStacked == array;\n  }\n  var index = -1,\n      result = true,\n      seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n  stack.set(array, other);\n  stack.set(other, array);\n\n  // Ignore non-index properties.\n  while (++index < arrLength) {\n    var arrValue = array[index],\n        othValue = other[index];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, arrValue, index, other, array, stack)\n        : customizer(arrValue, othValue, index, array, other, stack);\n    }\n    if (compared !== undefined) {\n      if (compared) {\n        continue;\n      }\n      result = false;\n      break;\n    }\n    // Recursively compare arrays (susceptible to call stack limits).\n    if (seen) {\n      if (!arraySome(other, function(othValue, othIndex) {\n            if (!cacheHas(seen, othIndex) &&\n                (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n              return seen.push(othIndex);\n            }\n          })) {\n        result = false;\n        break;\n      }\n    } else if (!(\n          arrValue === othValue ||\n            equalFunc(arrValue, othValue, bitmask, customizer, stack)\n        )) {\n      result = false;\n      break;\n    }\n  }\n  stack['delete'](array);\n  stack['delete'](other);\n  return result;\n}\n\nexport default equalArrays;\n","/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n  var index = -1,\n      result = Array(map.size);\n\n  map.forEach(function(value, key) {\n    result[++index] = [key, value];\n  });\n  return result;\n}\n\nexport default mapToArray;\n","import Symbol from './_Symbol.js';\nimport Uint8Array from './_Uint8Array.js';\nimport eq from './eq.js';\nimport equalArrays from './_equalArrays.js';\nimport mapToArray from './_mapToArray.js';\nimport setToArray from './_setToArray.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]';\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n    symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n  switch (tag) {\n    case dataViewTag:\n      if ((object.byteLength != other.byteLength) ||\n          (object.byteOffset != other.byteOffset)) {\n        return false;\n      }\n      object = object.buffer;\n      other = other.buffer;\n\n    case arrayBufferTag:\n      if ((object.byteLength != other.byteLength) ||\n          !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n        return false;\n      }\n      return true;\n\n    case boolTag:\n    case dateTag:\n    case numberTag:\n      // Coerce booleans to `1` or `0` and dates to milliseconds.\n      // Invalid dates are coerced to `NaN`.\n      return eq(+object, +other);\n\n    case errorTag:\n      return object.name == other.name && object.message == other.message;\n\n    case regexpTag:\n    case stringTag:\n      // Coerce regexes to strings and treat strings, primitives and objects,\n      // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n      // for more details.\n      return object == (other + '');\n\n    case mapTag:\n      var convert = mapToArray;\n\n    case setTag:\n      var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n      convert || (convert = setToArray);\n\n      if (object.size != other.size && !isPartial) {\n        return false;\n      }\n      // Assume cyclic values are equal.\n      var stacked = stack.get(object);\n      if (stacked) {\n        return stacked == other;\n      }\n      bitmask |= COMPARE_UNORDERED_FLAG;\n\n      // Recursively compare objects (susceptible to call stack limits).\n      stack.set(object, other);\n      var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n      stack['delete'](object);\n      return result;\n\n    case symbolTag:\n      if (symbolValueOf) {\n        return symbolValueOf.call(object) == symbolValueOf.call(other);\n      }\n  }\n  return false;\n}\n\nexport default equalByTag;\n","import getAllKeys from './_getAllKeys.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n  var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n      objProps = getAllKeys(object),\n      objLength = objProps.length,\n      othProps = getAllKeys(other),\n      othLength = othProps.length;\n\n  if (objLength != othLength && !isPartial) {\n    return false;\n  }\n  var index = objLength;\n  while (index--) {\n    var key = objProps[index];\n    if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n      return false;\n    }\n  }\n  // Check that cyclic values are equal.\n  var objStacked = stack.get(object);\n  var othStacked = stack.get(other);\n  if (objStacked && othStacked) {\n    return objStacked == other && othStacked == object;\n  }\n  var result = true;\n  stack.set(object, other);\n  stack.set(other, object);\n\n  var skipCtor = isPartial;\n  while (++index < objLength) {\n    key = objProps[index];\n    var objValue = object[key],\n        othValue = other[key];\n\n    if (customizer) {\n      var compared = isPartial\n        ? customizer(othValue, objValue, key, other, object, stack)\n        : customizer(objValue, othValue, key, object, other, stack);\n    }\n    // Recursively compare objects (susceptible to call stack limits).\n    if (!(compared === undefined\n          ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n          : compared\n        )) {\n      result = false;\n      break;\n    }\n    skipCtor || (skipCtor = key == 'constructor');\n  }\n  if (result && !skipCtor) {\n    var objCtor = object.constructor,\n        othCtor = other.constructor;\n\n    // Non `Object` object instances with different constructors are not equal.\n    if (objCtor != othCtor &&\n        ('constructor' in object && 'constructor' in other) &&\n        !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n          typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n      result = false;\n    }\n  }\n  stack['delete'](object);\n  stack['delete'](other);\n  return result;\n}\n\nexport default equalObjects;\n","import Stack from './_Stack.js';\nimport equalArrays from './_equalArrays.js';\nimport equalByTag from './_equalByTag.js';\nimport equalObjects from './_equalObjects.js';\nimport getTag from './_getTag.js';\nimport isArray from './isArray.js';\nimport isBuffer from './isBuffer.js';\nimport isTypedArray from './isTypedArray.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n  var objIsArr = isArray(object),\n      othIsArr = isArray(other),\n      objTag = objIsArr ? arrayTag : getTag(object),\n      othTag = othIsArr ? arrayTag : getTag(other);\n\n  objTag = objTag == argsTag ? objectTag : objTag;\n  othTag = othTag == argsTag ? objectTag : othTag;\n\n  var objIsObj = objTag == objectTag,\n      othIsObj = othTag == objectTag,\n      isSameTag = objTag == othTag;\n\n  if (isSameTag && isBuffer(object)) {\n    if (!isBuffer(other)) {\n      return false;\n    }\n    objIsArr = true;\n    objIsObj = false;\n  }\n  if (isSameTag && !objIsObj) {\n    stack || (stack = new Stack);\n    return (objIsArr || isTypedArray(object))\n      ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n      : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n  }\n  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n    var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n        othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n    if (objIsWrapped || othIsWrapped) {\n      var objUnwrapped = objIsWrapped ? object.value() : object,\n          othUnwrapped = othIsWrapped ? other.value() : other;\n\n      stack || (stack = new Stack);\n      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n    }\n  }\n  if (!isSameTag) {\n    return false;\n  }\n  stack || (stack = new Stack);\n  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\nexport default baseIsEqualDeep;\n","import baseIsEqualDeep from './_baseIsEqualDeep.js';\nimport isObjectLike from './isObjectLike.js';\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n *  1 - Unordered comparison\n *  2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n  if (value === other) {\n    return true;\n  }\n  if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n    return value !== value && other !== other;\n  }\n  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\nexport default baseIsEqual;\n","import Stack from './_Stack.js';\nimport baseIsEqual from './_baseIsEqual.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * The base implementation of `_.isMatch` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property values to match.\n * @param {Array} matchData The property names, values, and compare flags to match.\n * @param {Function} [customizer] The function to customize comparisons.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n */\nfunction baseIsMatch(object, source, matchData, customizer) {\n  var index = matchData.length,\n      length = index,\n      noCustomizer = !customizer;\n\n  if (object == null) {\n    return !length;\n  }\n  object = Object(object);\n  while (index--) {\n    var data = matchData[index];\n    if ((noCustomizer && data[2])\n          ? data[1] !== object[data[0]]\n          : !(data[0] in object)\n        ) {\n      return false;\n    }\n  }\n  while (++index < length) {\n    data = matchData[index];\n    var key = data[0],\n        objValue = object[key],\n        srcValue = data[1];\n\n    if (noCustomizer && data[2]) {\n      if (objValue === undefined && !(key in object)) {\n        return false;\n      }\n    } else {\n      var stack = new Stack;\n      if (customizer) {\n        var result = customizer(objValue, srcValue, key, object, source, stack);\n      }\n      if (!(result === undefined\n            ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)\n            : result\n          )) {\n        return false;\n      }\n    }\n  }\n  return true;\n}\n\nexport default baseIsMatch;\n","import isObject from './isObject.js';\n\n/**\n * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` if suitable for strict\n *  equality comparisons, else `false`.\n */\nfunction isStrictComparable(value) {\n  return value === value && !isObject(value);\n}\n\nexport default isStrictComparable;\n","import isStrictComparable from './_isStrictComparable.js';\nimport keys from './keys.js';\n\n/**\n * Gets the property names, values, and compare flags of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the match data of `object`.\n */\nfunction getMatchData(object) {\n  var result = keys(object),\n      length = result.length;\n\n  while (length--) {\n    var key = result[length],\n        value = object[key];\n\n    result[length] = [key, value, isStrictComparable(value)];\n  }\n  return result;\n}\n\nexport default getMatchData;\n","/**\n * A specialized version of `matchesProperty` for source values suitable\n * for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction matchesStrictComparable(key, srcValue) {\n  return function(object) {\n    if (object == null) {\n      return false;\n    }\n    return object[key] === srcValue &&\n      (srcValue !== undefined || (key in Object(object)));\n  };\n}\n\nexport default matchesStrictComparable;\n","import baseIsMatch from './_baseIsMatch.js';\nimport getMatchData from './_getMatchData.js';\nimport matchesStrictComparable from './_matchesStrictComparable.js';\n\n/**\n * The base implementation of `_.matches` which doesn't clone `source`.\n *\n * @private\n * @param {Object} source The object of property values to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction baseMatches(source) {\n  var matchData = getMatchData(source);\n  if (matchData.length == 1 && matchData[0][2]) {\n    return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n  }\n  return function(object) {\n    return object === source || baseIsMatch(object, source, matchData);\n  };\n}\n\nexport default baseMatches;\n","import baseIsEqual from './_baseIsEqual.js';\nimport get from './get.js';\nimport hasIn from './hasIn.js';\nimport isKey from './_isKey.js';\nimport isStrictComparable from './_isStrictComparable.js';\nimport matchesStrictComparable from './_matchesStrictComparable.js';\nimport toKey from './_toKey.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n    COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.\n *\n * @private\n * @param {string} path The path of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction baseMatchesProperty(path, srcValue) {\n  if (isKey(path) && isStrictComparable(srcValue)) {\n    return matchesStrictComparable(toKey(path), srcValue);\n  }\n  return function(object) {\n    var objValue = get(object, path);\n    return (objValue === undefined && objValue === srcValue)\n      ? hasIn(object, path)\n      : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n  };\n}\n\nexport default baseMatchesProperty;\n","/**\n * The base implementation of `_.property` without support for deep paths.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\nfunction baseProperty(key) {\n  return function(object) {\n    return object == null ? undefined : object[key];\n  };\n}\n\nexport default baseProperty;\n","import baseGet from './_baseGet.js';\n\n/**\n * A specialized version of `baseProperty` which supports deep paths.\n *\n * @private\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\nfunction basePropertyDeep(path) {\n  return function(object) {\n    return baseGet(object, path);\n  };\n}\n\nexport default basePropertyDeep;\n","import baseProperty from './_baseProperty.js';\nimport basePropertyDeep from './_basePropertyDeep.js';\nimport isKey from './_isKey.js';\nimport toKey from './_toKey.js';\n\n/**\n * Creates a function that returns the value at `path` of a given object.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new accessor function.\n * @example\n *\n * var objects = [\n *   { 'a': { 'b': 2 } },\n *   { 'a': { 'b': 1 } }\n * ];\n *\n * _.map(objects, _.property('a.b'));\n * // => [2, 1]\n *\n * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');\n * // => [1, 2]\n */\nfunction property(path) {\n  return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n}\n\nexport default property;\n","import baseMatches from './_baseMatches.js';\nimport baseMatchesProperty from './_baseMatchesProperty.js';\nimport identity from './identity.js';\nimport isArray from './isArray.js';\nimport property from './property.js';\n\n/**\n * The base implementation of `_.iteratee`.\n *\n * @private\n * @param {*} [value=_.identity] The value to convert to an iteratee.\n * @returns {Function} Returns the iteratee.\n */\nfunction baseIteratee(value) {\n  // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.\n  // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.\n  if (typeof value == 'function') {\n    return value;\n  }\n  if (value == null) {\n    return identity;\n  }\n  if (typeof value == 'object') {\n    return isArray(value)\n      ? baseMatchesProperty(value[0], value[1])\n      : baseMatches(value);\n  }\n  return property(value);\n}\n\nexport default baseIteratee;\n","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n  return function(value) {\n    return func(value);\n  };\n}\n\nexport default baseUnary;\n","/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n  return cache.has(key);\n}\n\nexport default cacheHas;\n","import flatten from './flatten.js';\nimport overRest from './_overRest.js';\nimport setToString from './_setToString.js';\n\n/**\n * A specialized version of `baseRest` which flattens the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @returns {Function} Returns the new function.\n */\nfunction flatRest(func) {\n  return setToString(overRest(func, undefined, flatten), func + '');\n}\n\nexport default flatRest;\n","import baseGetAllKeys from './_baseGetAllKeys.js';\nimport getSymbols from './_getSymbols.js';\nimport keys from './keys.js';\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n  return baseGetAllKeys(object, keys, getSymbols);\n}\n\nexport default getAllKeys;\n","/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n  var index = -1,\n      length = array == null ? 0 : array.length,\n      resIndex = 0,\n      result = [];\n\n  while (++index < length) {\n    var value = array[index];\n    if (predicate(value, index, array)) {\n      result[resIndex++] = value;\n    }\n  }\n  return result;\n}\n\nexport default arrayFilter;\n","import arrayFilter from './_arrayFilter.js';\nimport stubArray from './stubArray.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n  if (object == null) {\n    return [];\n  }\n  object = Object(object);\n  return arrayFilter(nativeGetSymbols(object), function(symbol) {\n    return propertyIsEnumerable.call(object, symbol);\n  });\n};\n\nexport default getSymbols;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView');\n\nexport default DataView;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Promise = getNative(root, 'Promise');\n\nexport default Promise;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar WeakMap = getNative(root, 'WeakMap');\n\nexport default WeakMap;\n","import DataView from './_DataView.js';\nimport Map from './_Map.js';\nimport Promise from './_Promise.js';\nimport Set from './_Set.js';\nimport WeakMap from './_WeakMap.js';\nimport baseGetTag from './_baseGetTag.js';\nimport toSource from './_toSource.js';\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n    objectTag = '[object Object]',\n    promiseTag = '[object Promise]',\n    setTag = '[object Set]',\n    weakMapTag = '[object WeakMap]';\n\nvar dataViewTag = '[object DataView]';\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n    mapCtorString = toSource(Map),\n    promiseCtorString = toSource(Promise),\n    setCtorString = toSource(Set),\n    weakMapCtorString = toSource(WeakMap);\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n    (Map && getTag(new Map) != mapTag) ||\n    (Promise && getTag(Promise.resolve()) != promiseTag) ||\n    (Set && getTag(new Set) != setTag) ||\n    (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n  getTag = function(value) {\n    var result = baseGetTag(value),\n        Ctor = result == objectTag ? value.constructor : undefined,\n        ctorString = Ctor ? toSource(Ctor) : '';\n\n    if (ctorString) {\n      switch (ctorString) {\n        case dataViewCtorString: return dataViewTag;\n        case mapCtorString: return mapTag;\n        case promiseCtorString: return promiseTag;\n        case setCtorString: return setTag;\n        case weakMapCtorString: return weakMapTag;\n      }\n    }\n    return result;\n  };\n}\n\nexport default getTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n  var Ctor = value && value.constructor,\n      proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n  return value === proto;\n}\n\nexport default isPrototype;\n","import freeGlobal from './_freeGlobal.js';\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n  try {\n    // Use `util.types` for Node.js 10+.\n    var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n    if (types) {\n      return types;\n    }\n\n    // Legacy `process.binding('util')` for Node.js < 10.\n    return freeProcess && freeProcess.binding && freeProcess.binding('util');\n  } catch (e) {}\n}());\n\nexport default nodeUtil;\n","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n  return function(arg) {\n    return func(transform(arg));\n  };\n}\n\nexport default overArg;\n","/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n  switch (args.length) {\n    case 0: return func.call(thisArg);\n    case 1: return func.call(thisArg, args[0]);\n    case 2: return func.call(thisArg, args[0], args[1]);\n    case 3: return func.call(thisArg, args[0], args[1], args[2]);\n  }\n  return func.apply(thisArg, args);\n}\n\nexport default apply;\n","import apply from './_apply.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n  start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n  return function() {\n    var args = arguments,\n        index = -1,\n        length = nativeMax(args.length - start, 0),\n        array = Array(length);\n\n    while (++index < length) {\n      array[index] = args[start + index];\n    }\n    index = -1;\n    var otherArgs = Array(start + 1);\n    while (++index < start) {\n      otherArgs[index] = args[index];\n    }\n    otherArgs[start] = transform(array);\n    return apply(func, this, otherArgs);\n  };\n}\n\nexport default overRest;\n","/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n  var index = -1,\n      result = Array(set.size);\n\n  set.forEach(function(value) {\n    result[++index] = value;\n  });\n  return result;\n}\n\nexport default setToArray;\n","/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n  return function() {\n    return value;\n  };\n}\n\nexport default constant;\n","import constant from './constant.js';\nimport defineProperty from './_defineProperty.js';\nimport identity from './identity.js';\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n  return defineProperty(func, 'toString', {\n    'configurable': true,\n    'enumerable': false,\n    'value': constant(string),\n    'writable': true\n  });\n};\n\nexport default baseSetToString;\n","/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n    HOT_SPAN = 16;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeNow = Date.now;\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n  var count = 0,\n      lastCalled = 0;\n\n  return function() {\n    var stamp = nativeNow(),\n        remaining = HOT_SPAN - (stamp - lastCalled);\n\n    lastCalled = stamp;\n    if (remaining > 0) {\n      if (++count >= HOT_COUNT) {\n        return arguments[0];\n      }\n    } else {\n      count = 0;\n    }\n    return func.apply(undefined, arguments);\n  };\n}\n\nexport default shortOut;\n","import baseSetToString from './_baseSetToString.js';\nimport shortOut from './_shortOut.js';\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\nexport default setToString;\n","import isArray from './isArray.js';\n\n/**\n * Casts `value` as an array if it's not one.\n *\n * @static\n * @memberOf _\n * @since 4.4.0\n * @category Lang\n * @param {*} value The value to inspect.\n * @returns {Array} Returns the cast array.\n * @example\n *\n * _.castArray(1);\n * // => [1]\n *\n * _.castArray({ 'a': 1 });\n * // => [{ 'a': 1 }]\n *\n * _.castArray('abc');\n * // => ['abc']\n *\n * _.castArray(null);\n * // => [null]\n *\n * _.castArray(undefined);\n * // => [undefined]\n *\n * _.castArray();\n * // => []\n *\n * var array = [1, 2, 3];\n * console.log(_.castArray(array) === array);\n * // => true\n */\nfunction castArray() {\n  if (!arguments.length) {\n    return [];\n  }\n  var value = arguments[0];\n  return isArray(value) ? value : [value];\n}\n\nexport default castArray;\n","import root from './_root.js';\n\n/**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n *   console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\nvar now = function() {\n  return root.Date.now();\n};\n\nexport default now;\n","import isObject from './isObject.js';\nimport now from './now.js';\nimport toNumber from './toNumber.js';\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n *  Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n *  The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n *  Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n *   'leading': true,\n *   'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\nfunction debounce(func, wait, options) {\n  var lastArgs,\n      lastThis,\n      maxWait,\n      result,\n      timerId,\n      lastCallTime,\n      lastInvokeTime = 0,\n      leading = false,\n      maxing = false,\n      trailing = true;\n\n  if (typeof func != 'function') {\n    throw new TypeError(FUNC_ERROR_TEXT);\n  }\n  wait = toNumber(wait) || 0;\n  if (isObject(options)) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time) {\n    var args = lastArgs,\n        thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    result = func.apply(thisArg, args);\n    return result;\n  }\n\n  function leadingEdge(time) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime,\n        timeWaiting = wait - timeSinceLastCall;\n\n    return maxing\n      ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time) {\n    var timeSinceLastCall = time - lastCallTime,\n        timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n      (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n  }\n\n  function timerExpired() {\n    var time = now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(now());\n  }\n\n  function debounced() {\n    var time = now(),\n        isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n  return debounced;\n}\n\nexport default debounce;\n","import toNumber from './toNumber.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0,\n    MAX_INTEGER = 1.7976931348623157e+308;\n\n/**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\nfunction toFinite(value) {\n  if (!value) {\n    return value === 0 ? value : 0;\n  }\n  value = toNumber(value);\n  if (value === INFINITY || value === -INFINITY) {\n    var sign = (value < 0 ? -1 : 1);\n    return sign * MAX_INTEGER;\n  }\n  return value === value ? value : 0;\n}\n\nexport default toFinite;\n","import toFinite from './toFinite.js';\n\n/**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\nfunction toInteger(value) {\n  var result = toFinite(value),\n      remainder = result % 1;\n\n  return result === result ? (remainder ? result - remainder : result) : 0;\n}\n\nexport default toInteger;\n","import baseFindIndex from './_baseFindIndex.js';\nimport baseIteratee from './_baseIteratee.js';\nimport toInteger from './toInteger.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max,\n    nativeMin = Math.min;\n\n/**\n * This method is like `_.findIndex` except that it iterates over elements\n * of `collection` from right to left.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=array.length-1] The index to search from.\n * @returns {number} Returns the index of the found element, else `-1`.\n * @example\n *\n * var users = [\n *   { 'user': 'barney',  'active': true },\n *   { 'user': 'fred',    'active': false },\n *   { 'user': 'pebbles', 'active': false }\n * ];\n *\n * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });\n * // => 2\n *\n * // The `_.matches` iteratee shorthand.\n * _.findLastIndex(users, { 'user': 'barney', 'active': true });\n * // => 0\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.findLastIndex(users, ['active', false]);\n * // => 2\n *\n * // The `_.property` iteratee shorthand.\n * _.findLastIndex(users, 'active');\n * // => 0\n */\nfunction findLastIndex(array, predicate, fromIndex) {\n  var length = array == null ? 0 : array.length;\n  if (!length) {\n    return -1;\n  }\n  var index = length - 1;\n  if (fromIndex !== undefined) {\n    index = toInteger(fromIndex);\n    index = fromIndex < 0\n      ? nativeMax(length + index, 0)\n      : nativeMin(index, length - 1);\n  }\n  return baseFindIndex(array, baseIteratee(predicate, 3), index, true);\n}\n\nexport default findLastIndex;\n","import baseFlatten from './_baseFlatten.js';\n\n/**\n * Flattens `array` a single level deep.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to flatten.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * _.flatten([1, [2, [3, [4]], 5]]);\n * // => [1, 2, [3, [4]], 5]\n */\nfunction flatten(array) {\n  var length = array == null ? 0 : array.length;\n  return length ? baseFlatten(array, 1) : [];\n}\n\nexport default flatten;\n","/**\n * The base implementation of `_.hasIn` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\nfunction baseHasIn(object, key) {\n  return object != null && key in Object(object);\n}\n\nexport default baseHasIn;\n","import castPath from './_castPath.js';\nimport isArguments from './isArguments.js';\nimport isArray from './isArray.js';\nimport isIndex from './_isIndex.js';\nimport isLength from './isLength.js';\nimport toKey from './_toKey.js';\n\n/**\n * Checks if `path` exists on `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @param {Function} hasFunc The function to check properties.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n */\nfunction hasPath(object, path, hasFunc) {\n  path = castPath(path, object);\n\n  var index = -1,\n      length = path.length,\n      result = false;\n\n  while (++index < length) {\n    var key = toKey(path[index]);\n    if (!(result = object != null && hasFunc(object, key))) {\n      break;\n    }\n    object = object[key];\n  }\n  if (result || ++index != length) {\n    return result;\n  }\n  length = object == null ? 0 : object.length;\n  return !!length && isLength(length) && isIndex(key, length) &&\n    (isArray(object) || isArguments(object));\n}\n\nexport default hasPath;\n","import baseHasIn from './_baseHasIn.js';\nimport hasPath from './_hasPath.js';\n\n/**\n * Checks if `path` is a direct or inherited property of `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.hasIn(object, 'a');\n * // => true\n *\n * _.hasIn(object, 'a.b');\n * // => true\n *\n * _.hasIn(object, ['a', 'b']);\n * // => true\n *\n * _.hasIn(object, 'b');\n * // => false\n */\nfunction hasIn(object, path) {\n  return object != null && hasPath(object, path, baseHasIn);\n}\n\nexport default hasIn;\n","/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n  return value;\n}\n\nexport default identity;\n","import baseGetTag from './_baseGetTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n  return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nexport default baseIsArguments;\n","import baseIsArguments from './_baseIsArguments.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n *  else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n  return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n    !propertyIsEnumerable.call(value, 'callee');\n};\n\nexport default isArguments;\n","import isFunction from './isFunction.js';\nimport isLength from './isLength.js';\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n  return value != null && isLength(value.length) && !isFunction(value);\n}\n\nexport default isArrayLike;\n","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n  return false;\n}\n\nexport default stubFalse;\n","import root from './_root.js';\nimport stubFalse from './stubFalse.js';\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nexport default isBuffer;\n","import baseIsEqual from './_baseIsEqual.js';\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n  return baseIsEqual(value, other);\n}\n\nexport default isEqual;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n  return typeof value == 'number' &&\n    value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nexport default isLength;\n","import baseGetTag from './_baseGetTag.js';\nimport isLength from './isLength.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n    arrayTag = '[object Array]',\n    boolTag = '[object Boolean]',\n    dateTag = '[object Date]',\n    errorTag = '[object Error]',\n    funcTag = '[object Function]',\n    mapTag = '[object Map]',\n    numberTag = '[object Number]',\n    objectTag = '[object Object]',\n    regexpTag = '[object RegExp]',\n    setTag = '[object Set]',\n    stringTag = '[object String]',\n    weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n    dataViewTag = '[object DataView]',\n    float32Tag = '[object Float32Array]',\n    float64Tag = '[object Float64Array]',\n    int8Tag = '[object Int8Array]',\n    int16Tag = '[object Int16Array]',\n    int32Tag = '[object Int32Array]',\n    uint8Tag = '[object Uint8Array]',\n    uint8ClampedTag = '[object Uint8ClampedArray]',\n    uint16Tag = '[object Uint16Array]',\n    uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n  return isObjectLike(value) &&\n    isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nexport default baseIsTypedArray;\n","import baseIsTypedArray from './_baseIsTypedArray.js';\nimport baseUnary from './_baseUnary.js';\nimport nodeUtil from './_nodeUtil.js';\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nexport default isTypedArray;\n","/**\n * Checks if `value` is `undefined`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.\n * @example\n *\n * _.isUndefined(void 0);\n * // => true\n *\n * _.isUndefined(null);\n * // => false\n */\nfunction isUndefined(value) {\n  return value === undefined;\n}\n\nexport default isUndefined;\n","import overArg from './_overArg.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\nexport default nativeKeys;\n","import isPrototype from './_isPrototype.js';\nimport nativeKeys from './_nativeKeys.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n  if (!isPrototype(object)) {\n    return nativeKeys(object);\n  }\n  var result = [];\n  for (var key in Object(object)) {\n    if (hasOwnProperty.call(object, key) && key != 'constructor') {\n      result.push(key);\n    }\n  }\n  return result;\n}\n\nexport default baseKeys;\n","import arrayLikeKeys from './_arrayLikeKeys.js';\nimport baseKeys from './_baseKeys.js';\nimport isArrayLike from './isArrayLike.js';\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n *   this.a = 1;\n *   this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\nexport default keys;\n","import baseGet from './_baseGet.js';\nimport baseSet from './_baseSet.js';\nimport castPath from './_castPath.js';\n\n/**\n * The base implementation of  `_.pickBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @param {Function} predicate The function invoked per property.\n * @returns {Object} Returns the new object.\n */\nfunction basePickBy(object, paths, predicate) {\n  var index = -1,\n      length = paths.length,\n      result = {};\n\n  while (++index < length) {\n    var path = paths[index],\n        value = baseGet(object, path);\n\n    if (predicate(value, path)) {\n      baseSet(result, castPath(path, object), value);\n    }\n  }\n  return result;\n}\n\nexport default basePickBy;\n","import basePickBy from './_basePickBy.js';\nimport hasIn from './hasIn.js';\n\n/**\n * The base implementation of `_.pick` without support for individual\n * property identifiers.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @returns {Object} Returns the new object.\n */\nfunction basePick(object, paths) {\n  return basePickBy(object, paths, function(value, path) {\n    return hasIn(object, path);\n  });\n}\n\nexport default basePick;\n","import basePick from './_basePick.js';\nimport flatRest from './_flatRest.js';\n\n/**\n * Creates an object composed of the picked `object` properties.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [paths] The property paths to pick.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.pick(object, ['a', 'c']);\n * // => { 'a': 1, 'c': 3 }\n */\nvar pick = flatRest(function(object, paths) {\n  return object == null ? {} : basePick(object, paths);\n});\n\nexport default pick;\n","/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n  return [];\n}\n\nexport default stubArray;\n","/** Used to match a single whitespace character. */\nvar reWhitespace = /\\s/;\n\n/**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\nfunction trimmedEndIndex(string) {\n  var index = string.length;\n\n  while (index-- && reWhitespace.test(string.charAt(index))) {}\n  return index;\n}\n\nexport default trimmedEndIndex;\n","import trimmedEndIndex from './_trimmedEndIndex.js';\n\n/** Used to match leading whitespace. */\nvar reTrimStart = /^\\s+/;\n\n/**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\nfunction baseTrim(string) {\n  return string\n    ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n    : string;\n}\n\nexport default baseTrim;\n","import baseTrim from './_baseTrim.js';\nimport isObject from './isObject.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar NAN = 0 / 0;\n\n/** Used to detect bad signed hexadecimal string values. */\nvar reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n/** Used to detect binary string values. */\nvar reIsBinary = /^0b[01]+$/i;\n\n/** Used to detect octal string values. */\nvar reIsOctal = /^0o[0-7]+$/i;\n\n/** Built-in method references without a dependency on `root`. */\nvar freeParseInt = parseInt;\n\n/**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\nfunction toNumber(value) {\n  if (typeof value == 'number') {\n    return value;\n  }\n  if (isSymbol(value)) {\n    return NAN;\n  }\n  if (isObject(value)) {\n    var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n    value = isObject(other) ? (other + '') : other;\n  }\n  if (typeof value != 'string') {\n    return value === 0 ? value : +value;\n  }\n  value = baseTrim(value);\n  var isBinary = reIsBinary.test(value);\n  return (isBinary || reIsOctal.test(value))\n    ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n    : (reIsBadHex.test(value) ? NAN : +value);\n}\n\nexport default toNumber;\n"],"names":["___CSS_LOADER_EXPORT___","push","module","id","_hoisted_1","_hoisted_2","_hoisted_3","_hoisted_4","key","_typeof","obj","Symbol","iterator","constructor","prototype","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","apply","_objectSpread","target","i","arguments","length","source","forEach","_defineProperty","getOwnPropertyDescriptors","defineProperties","defineProperty","value","arg","input","hint","prim","toPrimitive","undefined","res","call","TypeError","String","Number","_toPrimitive","_toPropertyKey","configurable","writable","props","computed","stateLoaded","statesLoaded","this","$store","getters","concat","profession","abbr","loaded","jurisdictions","data","jurisdiction","includes","selectedJurisdictionSlug","get","requirements","set","newState","$route","name","methods","jurisdictionSelected","jurisdictionSlug","updateStateRequirementsType","getStateRequirements","professionSlug","slug","state","$router","params","getStateName","options","locals","_ctx","_cache","$props","$setup","$data","$options","_component_el_option","_component_el_select","$slots","modelValue","$event","filterable","placeholder","size","onChange","label","_","E","R","W","P","me","G","U","J","Xe","je","K","Ye","De","reduce","t","e","Ee","ot","C","nodeName","toLowerCase","H","window","toString","ownerDocument","defaultView","Q","Element","B","HTMLElement","Pe","ShadowRoot","Ae","enabled","phase","fn","elements","n","r","styles","o","attributes","assign","style","a","s","removeAttribute","setAttribute","effect","popper","position","strategy","left","top","margin","arrow","reference","hasOwnProperty","f","c","requires","q","split","X","Math","max","ve","min","Z","round","ee","getBoundingClientRect","offsetHeight","offsetWidth","width","height","right","bottom","x","y","ke","abs","offsetLeft","offsetTop","it","getRootNode","contains","isSameNode","parentNode","host","N","getComputedStyle","Wt","indexOf","I","document","documentElement","ge","assignedSlot","at","offsetParent","se","navigator","userAgent","transform","perspective","contain","willChange","Bt","Le","fe","ft","ct","pt","modifiersData","popperOffsets","placement","u","m","rects","Tt","padding","v","l","h","p","g","clientHeight","clientWidth","$","d","b","w","O","j","centerOffset","element","querySelector","requiresIfExists","te","qt","ut","popperRect","variation","offsets","gpuAcceleration","adaptive","roundOffsets","isFixed","visualViewport","L","D","S","devicePixelRatio","Vt","Me","ye","passive","Re","instance","scroll","resize","scrollParents","addEventListener","update","removeEventListener","_t","be","replace","zt","start","end","lt","We","scrollLeft","pageXOffset","scrollTop","pageYOffset","Be","Se","overflow","overflowX","overflowY","test","dt","body","ce","Te","ht","Ft","clientTop","clientLeft","Xt","scrollWidth","scrollHeight","direction","Ut","Gt","Yt","mt","ne","boundary","rootBoundary","elementContext","altBoundary","contextElement","A","offset","k","vt","_skip","mainAxis","altAxis","fallbackPlacements","flipVariations","allowedAutoPlacements","Kt","z","V","sort","Jt","Map","re","oe","M","T","pe","every","xe","find","de","ae","slice","Y","ie","reset","gt","yt","some","bt","preventOverflow","referenceClippingOffsets","popperEscapeOffsets","isReferenceHidden","hasPopperEscaped","wt","en","He","xt","tether","tetherOffset","rn","ue","le","jt","Dt","Oe","Et","Ce","At","qe","Ve","kt","Lt","F","he","Ne","Ie","$e","_e","ze","Fe","Ue","St","cn","an","sn","pn","Set","add","has","ln","Promise","resolve","then","Ot","modifiers","$t","Array","we","defaultModifiers","defaultOptions","orderedModifiers","setOptions","un","map","dn","forceUpdate","destroy","onFirstUpdate","yn","unrefElement","elRef","_a","plain","$el","defaultWindow","defaultDocument","location","useEventListener","args","events","listeners","isArray","cleanups","cleanup","stopWatch","watch","el","options2","flatMap","event","listener","register","immediate","flush","stop","_iOSWorkaround","onClickOutside","handler","ignore","capture","detectIframe","from","children","shouldListen","shouldIgnore","target2","querySelectorAll","composedPath","detail","activeElement","tagName","Boolean","propertyIsEnumerable","useActiveElement","relatedTarget","trigger","useSupported","callback","sync","isSupported","ref","cloneFnJSON","JSON","parse","stringify","_global","globalThis","global","self","globalKey","useCssVar","prop","initialValue","variable","prop2","getPropertyValue","trim","val","setProperty","useDocumentVisibility","visibility","visibilityState","__getOwnPropSymbols$g","__hasOwnProp$g","__propIsEnum$g","__objRest$2","exclude","useResizeObserver","observerOptions","observer","disconnect","ResizeObserver","observe","useElementBounding","windowResize","windowScroll","rect","ele","__getOwnPropSymbols$8","__hasOwnProp$8","__propIsEnum$8","__objRest$1","useMutationObserver","mutationOptions","MutationObserver","SwipeDirection","SwipeDirection2","__defProp","__getOwnPropSymbols","__hasOwnProp","__propIsEnum","__defNormalProp","__spreadValues","linear","easeInSine","easeOutSine","easeInOutSine","easeInQuad","easeOutQuad","easeInOutQuad","easeInCubic","easeOutCubic","easeInOutCubic","easeInQuart","easeOutQuart","easeInOutQuart","easeInQuint","easeOutQuint","easeInOutQuint","easeInExpo","easeOutExpo","easeInOutExpo","easeInCirc","easeOutCirc","easeInOutCirc","easeInBack","easeOutBack","easeInOutBack","useVModel","emit","_b","_c","_d","clone","eventName","deep","defaultValue","vm","getCurrentInstance","_emit","$emit","bind","proxy","modelOptions","model","cloneFn","getValue","useWindowFocus","focused","hasFocus","useWindowSize","initialWidth","Infinity","initialHeight","listenOrientation","includeScrollbar","innerWidth","innerHeight","__data__","SetCache","values","index","result","pairs","LARGE_ARRAY_SIZE","Stack","entries","clear","Uint8Array","iteratee","inherited","isArr","isArg","isArguments","isBuff","isBuffer","isType","isTypedArray","skipIndexes","array","predicate","fromIndex","fromRight","spreadableSymbol","isConcatSpreadable","baseFlatten","depth","isStrict","keysFunc","symbolsFunc","other","bitmask","customizer","equalFunc","stack","isPartial","arrLength","othLength","arrStacked","othStacked","seen","arrValue","othValue","compared","othIndex","symbolProto","symbolValueOf","valueOf","tag","byteLength","byteOffset","buffer","eq","message","convert","stacked","objProps","objLength","objStacked","skipCtor","objValue","objCtor","othCtor","argsTag","arrayTag","objectTag","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","baseIsEqual","isObjectLike","matchData","noCustomizer","srcValue","COMPARE_PARTIAL_FLAG","isObject","path","hasIn","identity","func","cache","resIndex","nativeGetSymbols","symbol","stubArray","mapTag","promiseTag","setTag","weakMapTag","dataViewTag","dataViewCtorString","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","getTag","ArrayBuffer","Ctor","ctorString","objectProto","freeExports","exports","nodeType","freeModule","freeProcess","process","types","require","binding","thisArg","nativeMax","otherArgs","string","nativeNow","Date","now","count","lastCalled","stamp","remaining","nativeMin","wait","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","trailing","invokeFunc","time","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","setTimeout","timeWaiting","remainingWait","debounced","isInvoking","leadingEdge","clearTimeout","toNumber","cancel","INFINITY","remainder","hasFunc","isLength","Buffer","typedArrayTags","nodeIsTypedArray","isArrayLike","paths","reWhitespace","charAt","reTrimStart","reIsBadHex","reIsBinary","reIsOctal","freeParseInt","parseInt","isSymbol","isBinary"],"sourceRoot":""}