@onereach/ui-components 8.3.1 → 8.4.0-beta.3653.0

package/dist/bundled/{v3/hooks/useTheme.js → v2/components/OrBottomSheetV3-a3df65d0.js}

@@ -1,3 +1,3040 @@
+import { R as RX_ABBREVIATION_FROM_STRING } from './OrAvatarV3-3f78b50a.js';
+import { effectScope, isRef, ref, watch, unref, customRef, getCurrentScope, onScopeDispose, computed, toRefs as toRefs$1, getCurrentInstance, onMounted, nextTick, reactive, isVue2, watchEffect, readonly, useAttrs, isVue3, defineComponent } from 'vue-demi';
+import { _ as __vue_component__$1 } from './OrOverlayV3-d081cbd5.js';
+import { n as normalizeComponent } from './OrAvatar-56c993c9.js';
+
+var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+/**
+ * Checks if `value` is object-like. A value is object-like if it's not `null`
+ * and has a `typeof` result of "object".
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+ * @example
+ *
+ * _.isObjectLike({});
+ * // => true
+ *
+ * _.isObjectLike([1, 2, 3]);
+ * // => true
+ *
+ * _.isObjectLike(_.noop);
+ * // => false
+ *
+ * _.isObjectLike(null);
+ * // => false
+ */
+function isObjectLike$3(value) {
+  return value != null && typeof value == 'object';
+}
+var isObjectLike_1 = isObjectLike$3;
+
+/** Detect free variable `global` from Node.js. */
+var freeGlobal$1 = typeof commonjsGlobal == 'object' && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+var _freeGlobal = freeGlobal$1;
+
+var freeGlobal = _freeGlobal;
+
+/** Detect free variable `self`. */
+var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+/** Used as a reference to the global object. */
+var root$3 = freeGlobal || freeSelf || Function('return this')();
+var _root = root$3;
+
+var root$2 = _root;
+
+/** Built-in value references. */
+var Symbol$4 = root$2.Symbol;
+var _Symbol = Symbol$4;
+
+var Symbol$3 = _Symbol;
+
+/** Used for built-in method references. */
+var objectProto$5 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString$1 = objectProto$5.toString;
+
+/** Built-in value references. */
+var symToStringTag$1 = Symbol$3 ? Symbol$3.toStringTag : undefined;
+
+/**
+ * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the raw `toStringTag`.
+ */
+function getRawTag$1(value) {
+  var isOwn = hasOwnProperty$4.call(value, symToStringTag$1),
+    tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = undefined;
+    var unmasked = true;
+  } catch (e) {}
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var _getRawTag = getRawTag$1;
+
+/** Used for built-in method references. */
+var objectProto$4 = Object.prototype;
+
+/**
+ * Used to resolve the
+ * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+ * of values.
+ */
+var nativeObjectToString = objectProto$4.toString;
+
+/**
+ * Converts `value` to a string using `Object.prototype.toString`.
+ *
+ * @private
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ */
+function objectToString$1(value) {
+  return nativeObjectToString.call(value);
+}
+var _objectToString = objectToString$1;
+
+var Symbol$2 = _Symbol,
+  getRawTag = _getRawTag,
+  objectToString = _objectToString;
+
+/** `Object#toString` result references. */
+var nullTag = '[object Null]',
+  undefinedTag = '[object Undefined]';
+
+/** Built-in value references. */
+var symToStringTag = Symbol$2 ? Symbol$2.toStringTag : undefined;
+
+/**
+ * The base implementation of `getTag` without fallbacks for buggy environments.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag$3(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+var _baseGetTag = baseGetTag$3;
+
+/**
+ * Creates a unary function that invokes `func` with its argument transformed.
+ *
+ * @private
+ * @param {Function} func The function to wrap.
+ * @param {Function} transform The argument transform.
+ * @returns {Function} Returns the new function.
+ */
+function overArg$1(func, transform) {
+  return function (arg) {
+    return func(transform(arg));
+  };
+}
+var _overArg = overArg$1;
+
+var overArg = _overArg;
+
+/** Built-in value references. */
+var getPrototype$1 = overArg(Object.getPrototypeOf, Object);
+var _getPrototype = getPrototype$1;
+
+var baseGetTag$2 = _baseGetTag,
+  getPrototype = _getPrototype,
+  isObjectLike$2 = isObjectLike_1;
+
+/** `Object#toString` result references. */
+var objectTag = '[object Object]';
+
+/** Used for built-in method references. */
+var funcProto$2 = Function.prototype,
+  objectProto$3 = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString$2 = funcProto$2.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$3 = objectProto$3.hasOwnProperty;
+
+/** Used to infer the `Object` constructor. */
+var objectCtorString = funcToString$2.call(Object);
+
+/**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * `Object` constructor or one with a `[[Prototype]]` of `null`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.8.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ * }
+ *
+ * _.isPlainObject(new Foo);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ *
+ * _.isPlainObject(Object.create(null));
+ * // => true
+ */
+function isPlainObject$1(value) {
+  if (!isObjectLike$2(value) || baseGetTag$2(value) != objectTag) {
+    return false;
+  }
+  var proto = getPrototype(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty$3.call(proto, 'constructor') && proto.constructor;
+  return typeof Ctor == 'function' && Ctor instanceof Ctor && funcToString$2.call(Ctor) == objectCtorString;
+}
+var isPlainObject_1 = isPlainObject$1;
+
+var isObjectLike$1 = isObjectLike_1,
+  isPlainObject = isPlainObject_1;
+
+/**
+ * Checks if `value` is likely a DOM element.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
+ * @example
+ *
+ * _.isElement(document.body);
+ * // => true
+ *
+ * _.isElement('<body>');
+ * // => false
+ */
+function isElement(value) {
+  return isObjectLike$1(value) && value.nodeType === 1 && !isPlainObject(value);
+}
+var isElement_1 = isElement;
+
+/**
+ * Checks if `value` is classified as an `Array` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+ * @example
+ *
+ * _.isArray([1, 2, 3]);
+ * // => true
+ *
+ * _.isArray(document.body.children);
+ * // => false
+ *
+ * _.isArray('abc');
+ * // => false
+ *
+ * _.isArray(_.noop);
+ * // => false
+ */
+var isArray$3 = Array.isArray;
+var isArray_1 = isArray$3;
+
+var baseGetTag$1 = _baseGetTag,
+  isObjectLike = isObjectLike_1;
+
+/** `Object#toString` result references. */
+var symbolTag = '[object Symbol]';
+
+/**
+ * Checks if `value` is classified as a `Symbol` primitive or object.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+ * @example
+ *
+ * _.isSymbol(Symbol.iterator);
+ * // => true
+ *
+ * _.isSymbol('abc');
+ * // => false
+ */
+function isSymbol$3(value) {
+  return typeof value == 'symbol' || isObjectLike(value) && baseGetTag$1(value) == symbolTag;
+}
+var isSymbol_1 = isSymbol$3;
+
+var isArray$2 = isArray_1,
+  isSymbol$2 = isSymbol_1;
+
+/** Used to match property names within property paths. */
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
+  reIsPlainProp = /^\w*$/;
+
+/**
+ * Checks if `value` is a property name and not a property path.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+ */
+function isKey$1(value, object) {
+  if (isArray$2(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == 'number' || type == 'symbol' || type == 'boolean' || value == null || isSymbol$2(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var _isKey = isKey$1;
+
+/**
+ * Checks if `value` is the
+ * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+ * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+ * @example
+ *
+ * _.isObject({});
+ * // => true
+ *
+ * _.isObject([1, 2, 3]);
+ * // => true
+ *
+ * _.isObject(_.noop);
+ * // => true
+ *
+ * _.isObject(null);
+ * // => false
+ */
+function isObject$2(value) {
+  var type = typeof value;
+  return value != null && (type == 'object' || type == 'function');
+}
+var isObject_1 = isObject$2;
+
+var baseGetTag = _baseGetTag,
+  isObject$1 = isObject_1;
+
+/** `Object#toString` result references. */
+var asyncTag = '[object AsyncFunction]',
+  funcTag = '[object Function]',
+  genTag = '[object GeneratorFunction]',
+  proxyTag = '[object Proxy]';
+
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction$2(value) {
+  if (!isObject$1(value)) {
+    return false;
+  }
+  // The use of `Object#toString` avoids issues with the `typeof` operator
+  // in Safari 9 which returns 'object' for typed arrays and other constructors.
+  var tag = baseGetTag(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_1 = isFunction$2;
+
+var root$1 = _root;
+
+/** Used to detect overreaching core-js shims. */
+var coreJsData$1 = root$1['__core-js_shared__'];
+var _coreJsData = coreJsData$1;
+
+var coreJsData = _coreJsData;
+
+/** Used to detect methods masquerading as native. */
+var maskSrcKey = function () {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+  return uid ? 'Symbol(src)_1.' + uid : '';
+}();
+
+/**
+ * Checks if `func` has its source masked.
+ *
+ * @private
+ * @param {Function} func The function to check.
+ * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+ */
+function isMasked$1(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var _isMasked = isMasked$1;
+
+/** Used for built-in method references. */
+var funcProto$1 = Function.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString$1 = funcProto$1.toString;
+
+/**
+ * Converts `func` to its source code.
+ *
+ * @private
+ * @param {Function} func The function to convert.
+ * @returns {string} Returns the source code.
+ */
+function toSource$1(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {}
+    try {
+      return func + '';
+    } catch (e) {}
+  }
+  return '';
+}
+var _toSource = toSource$1;
+
+var isFunction$1 = isFunction_1,
+  isMasked = _isMasked,
+  isObject = isObject_1,
+  toSource = _toSource;
+
+/**
+ * Used to match `RegExp`
+ * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+ */
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+/** Used to detect host constructors (Safari). */
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+  objectProto$2 = Object.prototype;
+
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+
+/** Used to detect if a method is native. */
+var reIsNative = RegExp('^' + funcToString.call(hasOwnProperty$2).replace(reRegExpChar, '\\$&').replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');
+
+/**
+ * The base implementation of `_.isNative` without bad shim checks.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a native function,
+ *  else `false`.
+ */
+function baseIsNative$1(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction$1(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+var _baseIsNative = baseIsNative$1;
+
+/**
+ * Gets the value at `key` of `object`.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {string} key The key of the property to get.
+ * @returns {*} Returns the property value.
+ */
+function getValue$1(object, key) {
+  return object == null ? undefined : object[key];
+}
+var _getValue = getValue$1;
+
+var baseIsNative = _baseIsNative,
+  getValue = _getValue;
+
+/**
+ * Gets the native function at `key` of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {string} key The key of the method to get.
+ * @returns {*} Returns the function if it's native, else `undefined`.
+ */
+function getNative$2(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : undefined;
+}
+var _getNative = getNative$2;
+
+var getNative$1 = _getNative;
+
+/* Built-in method references that are verified to be native. */
+var nativeCreate$4 = getNative$1(Object, 'create');
+var _nativeCreate = nativeCreate$4;
+
+var nativeCreate$3 = _nativeCreate;
+
+/**
+ * Removes all key-value entries from the hash.
+ *
+ * @private
+ * @name clear
+ * @memberOf Hash
+ */
+function hashClear$1() {
+  this.__data__ = nativeCreate$3 ? nativeCreate$3(null) : {};
+  this.size = 0;
+}
+var _hashClear = hashClear$1;
+
+/**
+ * Removes `key` and its value from the hash.
+ *
+ * @private
+ * @name delete
+ * @memberOf Hash
+ * @param {Object} hash The hash to modify.
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function hashDelete$1(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _hashDelete = hashDelete$1;
+
+var nativeCreate$2 = _nativeCreate;
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED$1 = '__lodash_hash_undefined__';
+
+/** Used for built-in method references. */
+var objectProto$1 = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+
+/**
+ * Gets the hash value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf Hash
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function hashGet$1(key) {
+  var data = this.__data__;
+  if (nativeCreate$2) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$1 ? undefined : result;
+  }
+  return hasOwnProperty$1.call(data, key) ? data[key] : undefined;
+}
+var _hashGet = hashGet$1;
+
+var nativeCreate$1 = _nativeCreate;
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Checks if a hash value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf Hash
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function hashHas$1(key) {
+  var data = this.__data__;
+  return nativeCreate$1 ? data[key] !== undefined : hasOwnProperty.call(data, key);
+}
+var _hashHas = hashHas$1;
+
+var nativeCreate = _nativeCreate;
+
+/** Used to stand-in for `undefined` hash values. */
+var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+/**
+ * Sets the hash `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf Hash
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the hash instance.
+ */
+function hashSet$1(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;
+  return this;
+}
+var _hashSet = hashSet$1;
+
+var hashClear = _hashClear,
+  hashDelete = _hashDelete,
+  hashGet = _hashGet,
+  hashHas = _hashHas,
+  hashSet = _hashSet;
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash$1(entries) {
+  var index = -1,
+    length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `Hash`.
+Hash$1.prototype.clear = hashClear;
+Hash$1.prototype['delete'] = hashDelete;
+Hash$1.prototype.get = hashGet;
+Hash$1.prototype.has = hashHas;
+Hash$1.prototype.set = hashSet;
+var _Hash = Hash$1;
+
+/**
+ * Removes all key-value entries from the list cache.
+ *
+ * @private
+ * @name clear
+ * @memberOf ListCache
+ */
+function listCacheClear$1() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var _listCacheClear = listCacheClear$1;
+
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq$1(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_1 = eq$1;
+
+var eq = eq_1;
+
+/**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function assocIndexOf$4(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var _assocIndexOf = assocIndexOf$4;
+
+var assocIndexOf$3 = _assocIndexOf;
+
+/** Used for built-in method references. */
+var arrayProto = Array.prototype;
+
+/** Built-in value references. */
+var splice = arrayProto.splice;
+
+/**
+ * Removes `key` and its value from the list cache.
+ *
+ * @private
+ * @name delete
+ * @memberOf ListCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function listCacheDelete$1(key) {
+  var data = this.__data__,
+    index = assocIndexOf$3(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+var _listCacheDelete = listCacheDelete$1;
+
+var assocIndexOf$2 = _assocIndexOf;
+
+/**
+ * Gets the list cache value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf ListCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function listCacheGet$1(key) {
+  var data = this.__data__,
+    index = assocIndexOf$2(data, key);
+  return index < 0 ? undefined : data[index][1];
+}
+var _listCacheGet = listCacheGet$1;
+
+var assocIndexOf$1 = _assocIndexOf;
+
+/**
+ * Checks if a list cache value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf ListCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function listCacheHas$1(key) {
+  return assocIndexOf$1(this.__data__, key) > -1;
+}
+var _listCacheHas = listCacheHas$1;
+
+var assocIndexOf = _assocIndexOf;
+
+/**
+ * Sets the list cache `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf ListCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the list cache instance.
+ */
+function listCacheSet$1(key, value) {
+  var data = this.__data__,
+    index = assocIndexOf(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var _listCacheSet = listCacheSet$1;
+
+var listCacheClear = _listCacheClear,
+  listCacheDelete = _listCacheDelete,
+  listCacheGet = _listCacheGet,
+  listCacheHas = _listCacheHas,
+  listCacheSet = _listCacheSet;
+
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function ListCache$1(entries) {
+  var index = -1,
+    length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `ListCache`.
+ListCache$1.prototype.clear = listCacheClear;
+ListCache$1.prototype['delete'] = listCacheDelete;
+ListCache$1.prototype.get = listCacheGet;
+ListCache$1.prototype.has = listCacheHas;
+ListCache$1.prototype.set = listCacheSet;
+var _ListCache = ListCache$1;
+
+var getNative = _getNative,
+  root = _root;
+
+/* Built-in method references that are verified to be native. */
+var Map$2 = getNative(root, 'Map');
+var _Map = Map$2;
+
+var Hash = _Hash,
+  ListCache = _ListCache,
+  Map$1 = _Map;
+
+/**
+ * Removes all key-value entries from the map.
+ *
+ * @private
+ * @name clear
+ * @memberOf MapCache
+ */
+function mapCacheClear$1() {
+  this.size = 0;
+  this.__data__ = {
+    'hash': new Hash(),
+    'map': new (Map$1 || ListCache)(),
+    'string': new Hash()
+  };
+}
+var _mapCacheClear = mapCacheClear$1;
+
+/**
+ * Checks if `value` is suitable for use as unique object key.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+ */
+function isKeyable$1(value) {
+  var type = typeof value;
+  return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean' ? value !== '__proto__' : value === null;
+}
+var _isKeyable = isKeyable$1;
+
+var isKeyable = _isKeyable;
+
+/**
+ * Gets the data for `map`.
+ *
+ * @private
+ * @param {Object} map The map to query.
+ * @param {string} key The reference key.
+ * @returns {*} Returns the map data.
+ */
+function getMapData$4(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;
+}
+var _getMapData = getMapData$4;
+
+var getMapData$3 = _getMapData;
+
+/**
+ * Removes `key` and its value from the map.
+ *
+ * @private
+ * @name delete
+ * @memberOf MapCache
+ * @param {string} key The key of the value to remove.
+ * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+ */
+function mapCacheDelete$1(key) {
+  var result = getMapData$3(this, key)['delete'](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _mapCacheDelete = mapCacheDelete$1;
+
+var getMapData$2 = _getMapData;
+
+/**
+ * Gets the map value for `key`.
+ *
+ * @private
+ * @name get
+ * @memberOf MapCache
+ * @param {string} key The key of the value to get.
+ * @returns {*} Returns the entry value.
+ */
+function mapCacheGet$1(key) {
+  return getMapData$2(this, key).get(key);
+}
+var _mapCacheGet = mapCacheGet$1;
+
+var getMapData$1 = _getMapData;
+
+/**
+ * Checks if a map value for `key` exists.
+ *
+ * @private
+ * @name has
+ * @memberOf MapCache
+ * @param {string} key The key of the entry to check.
+ * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+ */
+function mapCacheHas$1(key) {
+  return getMapData$1(this, key).has(key);
+}
+var _mapCacheHas = mapCacheHas$1;
+
+var getMapData = _getMapData;
+
+/**
+ * Sets the map `key` to `value`.
+ *
+ * @private
+ * @name set
+ * @memberOf MapCache
+ * @param {string} key The key of the value to set.
+ * @param {*} value The value to set.
+ * @returns {Object} Returns the map cache instance.
+ */
+function mapCacheSet$1(key, value) {
+  var data = getMapData(this, key),
+    size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var _mapCacheSet = mapCacheSet$1;
+
+var mapCacheClear = _mapCacheClear,
+  mapCacheDelete = _mapCacheDelete,
+  mapCacheGet = _mapCacheGet,
+  mapCacheHas = _mapCacheHas,
+  mapCacheSet = _mapCacheSet;
+
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function MapCache$1(entries) {
+  var index = -1,
+    length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `MapCache`.
+MapCache$1.prototype.clear = mapCacheClear;
+MapCache$1.prototype['delete'] = mapCacheDelete;
+MapCache$1.prototype.get = mapCacheGet;
+MapCache$1.prototype.has = mapCacheHas;
+MapCache$1.prototype.set = mapCacheSet;
+var _MapCache = MapCache$1;
+
+var MapCache = _MapCache;
+
+/** Error message constants. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/**
+ * Creates a function that memoizes the result of `func`. If `resolver` is
+ * provided, it determines the cache key for storing the result based on the
+ * arguments provided to the memoized function. By default, the first argument
+ * provided to the memoized function is used as the map cache key. The `func`
+ * is invoked with the `this` binding of the memoized function.
+ *
+ * **Note:** The cache is exposed as the `cache` property on the memoized
+ * function. Its creation may be customized by replacing the `_.memoize.Cache`
+ * constructor with one whose instances implement the
+ * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+ * method interface of `clear`, `delete`, `get`, `has`, and `set`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Function
+ * @param {Function} func The function to have its output memoized.
+ * @param {Function} [resolver] The function to resolve the cache key.
+ * @returns {Function} Returns the new memoized function.
+ * @example
+ *
+ * var object = { 'a': 1, 'b': 2 };
+ * var other = { 'c': 3, 'd': 4 };
+ *
+ * var values = _.memoize(_.values);
+ * values(object);
+ * // => [1, 2]
+ *
+ * values(other);
+ * // => [3, 4]
+ *
+ * object.a = 2;
+ * values(object);
+ * // => [1, 2]
+ *
+ * // Modify the result cache.
+ * values.cache.set(object, ['a', 'b']);
+ * values(object);
+ * // => ['a', 'b']
+ *
+ * // Replace `_.memoize.Cache`.
+ * _.memoize.Cache = WeakMap;
+ */
+function memoize$1(func, resolver) {
+  if (typeof func != 'function' || resolver != null && typeof resolver != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function () {
+    var args = arguments,
+      key = resolver ? resolver.apply(this, args) : args[0],
+      cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize$1.Cache || MapCache)();
+  return memoized;
+}
+
+// Expose `MapCache`.
+memoize$1.Cache = MapCache;
+var memoize_1 = memoize$1;
+
+var memoize = memoize_1;
+
+/** Used as the maximum memoize cache size. */
+var MAX_MEMOIZE_SIZE = 500;
+
+/**
+ * A specialized version of `_.memoize` which clears the memoized function's
+ * cache when it exceeds `MAX_MEMOIZE_SIZE`.
+ *
+ * @private
+ * @param {Function} func The function to have its output memoized.
+ * @returns {Function} Returns the new memoized function.
+ */
+function memoizeCapped$1(func) {
+  var result = memoize(func, function (key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var _memoizeCapped = memoizeCapped$1;
+
+var memoizeCapped = _memoizeCapped;
+
+/** Used to match property names within property paths. */
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+
+/** Used to match backslashes in property paths. */
+var reEscapeChar = /\\(\\)?/g;
+
+/**
+ * Converts `string` to a property path array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the property path array.
+ */
+var stringToPath$1 = memoizeCapped(function (string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46 /* . */) {
+    result.push('');
+  }
+  string.replace(rePropName, function (match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, '$1') : number || match);
+  });
+  return result;
+});
+var _stringToPath = stringToPath$1;
+
+/**
+ * A specialized version of `_.map` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function arrayMap$1(array, iteratee) {
+  var index = -1,
+    length = array == null ? 0 : array.length,
+    result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+var _arrayMap = arrayMap$1;
+
+var Symbol$1 = _Symbol,
+  arrayMap = _arrayMap,
+  isArray$1 = isArray_1,
+  isSymbol$1 = isSymbol_1;
+
+/** Used as references for various `Number` constants. */
+var INFINITY$1 = 1 / 0;
+
+/** Used to convert symbols to primitives and strings. */
+var symbolProto = Symbol$1 ? Symbol$1.prototype : undefined,
+  symbolToString = symbolProto ? symbolProto.toString : undefined;
+
+/**
+ * The base implementation of `_.toString` which doesn't convert nullish
+ * values to empty strings.
+ *
+ * @private
+ * @param {*} value The value to process.
+ * @returns {string} Returns the string.
+ */
+function baseToString$1(value) {
+  // Exit early for strings to avoid a performance hit in some environments.
+  if (typeof value == 'string') {
+    return value;
+  }
+  if (isArray$1(value)) {
+    // Recursively convert values (susceptible to call stack limits).
+    return arrayMap(value, baseToString$1) + '';
+  }
+  if (isSymbol$1(value)) {
+    return symbolToString ? symbolToString.call(value) : '';
+  }
+  var result = value + '';
+  return result == '0' && 1 / value == -INFINITY$1 ? '-0' : result;
+}
+var _baseToString = baseToString$1;
+
+var baseToString = _baseToString;
+
+/**
+ * Converts `value` to a string. An empty string is returned for `null`
+ * and `undefined` values. The sign of `-0` is preserved.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to convert.
+ * @returns {string} Returns the converted string.
+ * @example
+ *
+ * _.toString(null);
+ * // => ''
+ *
+ * _.toString(-0);
+ * // => '-0'
+ *
+ * _.toString([1, 2, 3]);
+ * // => '1,2,3'
+ */
+function toString$1(value) {
+  return value == null ? '' : baseToString(value);
+}
+var toString_1 = toString$1;
+
+var isArray = isArray_1,
+  isKey = _isKey,
+  stringToPath = _stringToPath,
+  toString = toString_1;
+
+/**
+ * Casts `value` to a path array if it's not one.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @param {Object} [object] The object to query keys on.
+ * @returns {Array} Returns the cast property path array.
+ */
+function castPath$1(value, object) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath(toString(value));
+}
+var _castPath = castPath$1;
+
+var isSymbol = isSymbol_1;
+
+/** Used as references for various `Number` constants. */
+var INFINITY = 1 / 0;
+
+/**
+ * Converts `value` to a string key if it's not a string or symbol.
+ *
+ * @private
+ * @param {*} value The value to inspect.
+ * @returns {string|symbol} Returns the key.
+ */
+function toKey$1(value) {
+  if (typeof value == 'string' || isSymbol(value)) {
+    return value;
+  }
+  var result = value + '';
+  return result == '0' && 1 / value == -INFINITY ? '-0' : result;
+}
+var _toKey = toKey$1;
+
+var castPath = _castPath,
+  toKey = _toKey;
+
+/**
+ * The base implementation of `_.get` without support for default values.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @returns {*} Returns the resolved value.
+ */
+function baseGet$1(object, path) {
+  path = castPath(path, object);
+  var index = 0,
+    length = path.length;
+  while (object != null && index < length) {
+    object = object[toKey(path[index++])];
+  }
+  return index && index == length ? object : undefined;
+}
+var _baseGet = baseGet$1;
+
+var baseGet = _baseGet;
+
+/**
+ * Gets the value at `path` of `object`. If the resolved value is
+ * `undefined`, the `defaultValue` is returned in its place.
+ *
+ * @static
+ * @memberOf _
+ * @since 3.7.0
+ * @category Object
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+ *
+ * _.get(object, 'a[0].b.c');
+ * // => 3
+ *
+ * _.get(object, ['a', '0', 'b', 'c']);
+ * // => 3
+ *
+ * _.get(object, 'a.b.c', 'default');
+ * // => 'default'
+ */
+function get(object, path, defaultValue) {
+  var result = object == null ? undefined : baseGet(object, path);
+  return result === undefined ? defaultValue : result;
+}
+var get_1 = get;
+
+const WINDOW = typeof window !== 'undefined' ? window : null;
+const MutationObs = (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.MutationObserver) || (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.WebKitMutationObserver) || (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.MozMutationObserver) || null;
+const requestAF = ((WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.requestAnimationFrame) || (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.webkitRequestAnimationFrame) || (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.mozRequestAnimationFrame) || (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.msRequestAnimationFrame) || (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.oRequestAnimationFrame) || (
+// Fallback, but not a true polyfill
+// Only needed for Opera Mini
+cb => setTimeout(cb, 16))).bind(WINDOW);
+// eslint-disable-next-line no-unsafe-optional-chaining
+const cancelAF = ((WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.cancelAnimationFrame) || (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.mozCancelAnimationFrame)).bind(WINDOW);
+// Remove a node from DOM
+const removeNode = el => {
+  el && el.parentNode && el.parentNode.removeChild(el);
+};
+// Determine if an HTML element is visible - Faster than CSS check
+const isVisible$1 = el => {
+  if (!isElement_1(el) || !el.parentNode || !contains(document.body, el)) {
+    // Note this can fail for shadow dom elements since they
+    // are not a direct descendant of document.body
+    return false;
+  }
+  if (getStyle(el, 'display') === 'none') {
+    // We do this check to help with vue-test-utils when using v-show
+    return false;
+  }
+  // All browsers support getBoundingClientRect(), except JSDOM as it returns all 0's for values :(
+  // So any tests that need isVisible will fail in JSDOM
+  // Except when we override the getBCR prototype in some tests
+  const bcr = getBCR(el);
+  return !!(bcr && bcr.height > 0 && bcr.width > 0);
+};
+// Cause/wait-for an element to reflow its content (adjusting its height/width)
+const reflow = el => {
+  // Requesting an elements offsetHeight will trigger a reflow of the element content
+  return get_1(el, ['offsetHeight'], null);
+};
+// Select all elements matching selector. Returns `[]` if none found
+const selectAll = (selector, root) => [...(root && isElement_1(root) ? root : document).querySelectorAll(selector)];
+// Select a single element, returns `null` if not found
+const select = (selector, root) => (root && isElement_1(root) ? root : document).querySelector(selector) || null;
+// Returns true if the parent element contains the child element
+const contains = (parent, child) => parent && typeof parent.contains === 'function' ? parent.contains(child) : false;
+// Get an element given an ID
+const getById = id => document.getElementById(/^#/.test(id) ? id.slice(1) : id) || null;
+// Add a class to an element
+const addClass = (el, className) => {
+  // We are checking for `el.classList` existence here since IE 11
+  // returns `undefined` for some elements (e.g. SVG elements)
+  if (className && isElement_1(el) && el.classList) {
+    el.classList.add(className);
+  }
+};
+// Remove a class from an element
+const removeClass = (el, className) => {
+  // We are checking for `el.classList` existence here since IE 11
+  // returns `undefined` for some elements (e.g. SVG elements)
+  if (className && isElement_1(el) && el.classList) el.classList.remove(className);
+};
+// Test if an element has a class
+const hasClass = (el, className) => {
+  // We are checking for `el.classList` existence here since IE 11
+  // returns `undefined` for some elements (e.g. SVG elements)
+  if (className && isElement_1(el) && el.classList) return el.classList.contains(className);
+  return false;
+};
+// Set an attribute on an element
+const setAttr = (el, attr, value) => {
+  if (attr && isElement_1(el)) {
+    el.setAttribute(attr, value);
+  }
+};
+// Remove an attribute from an element
+const removeAttr = (el, attr) => {
+  if (attr && isElement_1(el)) {
+    el.removeAttribute(attr);
+  }
+};
+// Get an attribute value from an element
+const getAttr = (el, attr) => attr && isElement_1(el) ? el.getAttribute(attr) : null;
+// Determine if an attribute exists on an element
+// Returns `true` or `false`, or `null` if element not found
+const hasAttr = (el, attr) => attr && isElement_1(el) ? el.hasAttribute(attr) : null;
+// Set an style property on an element
+const setStyle = (el, prop, value) => {
+  if (prop && isElement_1(el)) {
+    el.style[prop] = value;
+  }
+};
+// Remove an style property from an element
+const removeStyle = (el, prop) => {
+  if (prop && isElement_1(el)) {
+    el.style[prop] = '';
+  }
+};
+// Get an style property value from an element
+// Returns `null` if not found
+const getStyle = (el, prop) => prop && isElement_1(el) ? el.style[prop] || null : null;
+// Return the Bounding Client Rect of an element
+const getBCR = el => isElement_1(el) ? el.getBoundingClientRect() : null;
+// Get computed style object for an element
+const getCS = el => get_1(WINDOW, 'getComputedStyle', null) && isElement_1(el) ? getComputedStyle(el) : {};
+// Return an element's offset with respect to document element
+const offset = el => {
+  const _offset = {
+    top: 0,
+    left: 0
+  };
+  if (!isElement_1(el) || el.getClientRects().length === 0) {
+    return _offset;
+  }
+  const bcr = getBCR(el);
+  if (bcr) {
+    const win = el.ownerDocument.defaultView;
+    _offset.top = bcr.top + get_1(win, 'pageYOffset', 0);
+    _offset.left = bcr.left + get_1(win, 'pageXOffset', 0);
+  }
+  return _offset;
+};
+// Return an element's offset with respect to to its offsetParent
+const position = el => {
+  let _offset = {
+    top: 0,
+    left: 0
+  };
+  if (!isElement_1(el)) {
+    return _offset;
+  }
+  let parentOffset = {
+    top: 0,
+    left: 0
+  };
+  const elStyles = getCS(el);
+  if (elStyles.position === 'fixed') {
+    _offset = getBCR(el) || _offset;
+  } else {
+    _offset = offset(el);
+    const doc = el.ownerDocument;
+    let offsetParent = el.offsetParent || doc.documentElement;
+    while (offsetParent && (offsetParent === doc.body || offsetParent === doc.documentElement) && getCS(offsetParent).position === 'static') {
+      offsetParent = offsetParent.parentNode;
+    }
+    if (offsetParent && offsetParent !== el && offsetParent.nodeType === Node.ELEMENT_NODE) {
+      parentOffset = offset(offsetParent);
+      const offsetParentStyles = getCS(offsetParent);
+      parentOffset.top += parseFloat(offsetParentStyles.borderTopWidth);
+      parentOffset.left += parseFloat(offsetParentStyles.borderLeftWidth);
+    }
+  }
+  return {
+    top: _offset.top - parentOffset.top - parseFloat(elStyles.marginTop),
+    left: _offset.left - parentOffset.left - parseFloat(elStyles.marginLeft)
+  };
+};
+const getMaxZIndex = element => {
+  let maxZIndex = 0;
+  while (element) {
+    const cs = getCS(element);
+    const zIndex = cs.zIndex;
+    if (zIndex !== 'auto') {
+      maxZIndex = +zIndex > maxZIndex ? +zIndex : maxZIndex;
+    }
+    element = element.parentElement;
+  }
+  return maxZIndex;
+};
+
+const pxToRem = value => value === 0 ? '0' : `${value / 16}rem`;
+
+var _a;
+const isClient = typeof window !== "undefined";
+const isDef = (val) => typeof val !== "undefined";
+const isFunction = (val) => typeof val === "function";
+const isString = (val) => typeof val === "string";
+const clamp = (n, min, max) => Math.min(max, Math.max(min, n));
+const noop = () => {
+};
+const isIOS = isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && /iP(ad|hone|od)/.test(window.navigator.userAgent);
+
+function resolveUnref(r) {
+  return typeof r === "function" ? r() : unref(r);
+}
+
+function createFilterWrapper(filter, fn) {
+  function wrapper(...args) {
+    filter(() => fn.apply(this, args), { fn, thisArg: this, args });
+  }
+  return wrapper;
+}
+const bypassFilter = (invoke) => {
+  return invoke();
+};
+function debounceFilter(ms, options = {}) {
+  let timer;
+  let maxTimer;
+  const filter = (invoke) => {
+    const duration = resolveUnref(ms);
+    const maxDuration = resolveUnref(options.maxWait);
+    if (timer)
+      clearTimeout(timer);
+    if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
+      if (maxTimer) {
+        clearTimeout(maxTimer);
+        maxTimer = null;
+      }
+      return invoke();
+    }
+    if (maxDuration && !maxTimer) {
+      maxTimer = setTimeout(() => {
+        if (timer)
+          clearTimeout(timer);
+        maxTimer = null;
+        invoke();
+      }, maxDuration);
+    }
+    timer = setTimeout(() => {
+      if (maxTimer)
+        clearTimeout(maxTimer);
+      maxTimer = null;
+      invoke();
+    }, duration);
+  };
+  return filter;
+}
+function identity(arg) {
+  return arg;
+}
+
+function computedWithControl(source, fn) {
+  let v = void 0;
+  let track;
+  let trigger;
+  const dirty = ref(true);
+  const update = () => {
+    dirty.value = true;
+    trigger();
+  };
+  watch(source, update, { flush: "sync" });
+  const get = isFunction(fn) ? fn : fn.get;
+  const set = isFunction(fn) ? void 0 : fn.set;
+  const result = customRef((_track, _trigger) => {
+    track = _track;
+    trigger = _trigger;
+    return {
+      get() {
+        if (dirty.value) {
+          v = get();
+          dirty.value = false;
+        }
+        track();
+        return v;
+      },
+      set(v2) {
+        set == null ? void 0 : set(v2);
+      }
+    };
+  });
+  if (Object.isExtensible(result))
+    result.trigger = update;
+  return result;
+}
+
+function tryOnScopeDispose(fn) {
+  if (getCurrentScope()) {
+    onScopeDispose(fn);
+    return true;
+  }
+  return false;
+}
+
+function createSharedComposable(composable) {
+  let subscribers = 0;
+  let state;
+  let scope;
+  const dispose = () => {
+    subscribers -= 1;
+    if (scope && subscribers <= 0) {
+      scope.stop();
+      state = void 0;
+      scope = void 0;
+    }
+  };
+  return (...args) => {
+    subscribers += 1;
+    if (!state) {
+      scope = effectScope(true);
+      state = scope.run(() => composable(...args));
+    }
+    tryOnScopeDispose(dispose);
+    return state;
+  };
+}
+
+function useDebounceFn(fn, ms = 200, options = {}) {
+  return createFilterWrapper(debounceFilter(ms, options), fn);
+}
+
+function refDebounced(value, ms = 200, options = {}) {
+  const debounced = ref(value.value);
+  const updater = useDebounceFn(() => {
+    debounced.value = value.value;
+  }, ms, options);
+  watch(value, () => updater());
+  return debounced;
+}
+
+function resolveRef(r) {
+  return typeof r === "function" ? computed(r) : ref(r);
+}
+
+var __defProp$7 = Object.defineProperty;
+var __defProps$5 = Object.defineProperties;
+var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$9 = Object.getOwnPropertySymbols;
+var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
+var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$7 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$9.call(b, prop))
+      __defNormalProp$7(a, prop, b[prop]);
+  if (__getOwnPropSymbols$9)
+    for (var prop of __getOwnPropSymbols$9(b)) {
+      if (__propIsEnum$9.call(b, prop))
+        __defNormalProp$7(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
+function toRefs(objectRef) {
+  if (!isRef(objectRef))
+    return toRefs$1(objectRef);
+  const result = Array.isArray(objectRef.value) ? new Array(objectRef.value.length) : {};
+  for (const key in objectRef.value) {
+    result[key] = customRef(() => ({
+      get() {
+        return objectRef.value[key];
+      },
+      set(v) {
+        if (Array.isArray(objectRef.value)) {
+          const copy = [...objectRef.value];
+          copy[key] = v;
+          objectRef.value = copy;
+        } else {
+          const newObject = __spreadProps$5(__spreadValues$7({}, objectRef.value), { [key]: v });
+          Object.setPrototypeOf(newObject, objectRef.value);
+          objectRef.value = newObject;
+        }
+      }
+    }));
+  }
+  return result;
+}
+
+function tryOnMounted(fn, sync = true) {
+  if (getCurrentInstance())
+    onMounted(fn);
+  else if (sync)
+    fn();
+  else
+    nextTick(fn);
+}
+
+function useToggle$1(initialValue = false, options = {}) {
+  const {
+    truthyValue = true,
+    falsyValue = false
+  } = options;
+  const valueIsRef = isRef(initialValue);
+  const _value = ref(initialValue);
+  function toggle(value) {
+    if (arguments.length) {
+      _value.value = value;
+      return _value.value;
+    } else {
+      const truthy = resolveUnref(truthyValue);
+      _value.value = _value.value === truthy ? resolveUnref(falsyValue) : truthy;
+      return _value.value;
+    }
+  }
+  if (valueIsRef)
+    return toggle;
+  else
+    return [_value, toggle];
+}
+
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __objRest$5 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$6.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$6.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function watchWithFilter(source, cb, options = {}) {
+  const _a = options, {
+    eventFilter = bypassFilter
+  } = _a, watchOptions = __objRest$5(_a, [
+    "eventFilter"
+  ]);
+  return watch(source, createFilterWrapper(eventFilter, cb), watchOptions);
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defProps$4$1 = Object.defineProperties;
+var __getOwnPropDescs$4$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$4$1 = (a, b) => __defProps$4$1(a, __getOwnPropDescs$4$1(b));
+var __objRest$3 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$4.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$4.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function watchDebounced(source, cb, options = {}) {
+  const _a = options, {
+    debounce = 0,
+    maxWait = void 0
+  } = _a, watchOptions = __objRest$3(_a, [
+    "debounce",
+    "maxWait"
+  ]);
+  return watchWithFilter(source, cb, __spreadProps$4$1(__spreadValues$4({}, watchOptions), {
+    eventFilter: debounceFilter(debounce, { maxWait })
+  }));
+}
+
+function whenever(source, cb, options) {
+  return watch(source, (v, ov, onInvalidate) => {
+    if (v)
+      cb(v, ov, onInvalidate);
+  }, options);
+}
+
+function unrefElement(elRef) {
+  var _a;
+  const plain = resolveUnref(elRef);
+  return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
+}
+
+const defaultWindow = isClient ? window : void 0;
+
+function useEventListener(...args) {
+  let target;
+  let events;
+  let listeners;
+  let options;
+  if (isString(args[0]) || Array.isArray(args[0])) {
+    [events, listeners, options] = args;
+    target = defaultWindow;
+  } else {
+    [target, events, listeners, options] = args;
+  }
+  if (!target)
+    return noop;
+  if (!Array.isArray(events))
+    events = [events];
+  if (!Array.isArray(listeners))
+    listeners = [listeners];
+  const cleanups = [];
+  const cleanup = () => {
+    cleanups.forEach((fn) => fn());
+    cleanups.length = 0;
+  };
+  const register = (el, event, listener) => {
+    el.addEventListener(event, listener, options);
+    return () => el.removeEventListener(event, listener, options);
+  };
+  const stopWatch = watch(() => unrefElement(target), (el) => {
+    cleanup();
+    if (!el)
+      return;
+    cleanups.push(...events.flatMap((event) => {
+      return listeners.map((listener) => register(el, event, listener));
+    }));
+  }, { immediate: true, flush: "post" });
+  const stop = () => {
+    stopWatch();
+    cleanup();
+  };
+  tryOnScopeDispose(stop);
+  return stop;
+}
+
+function onClickOutside(target, handler, options = {}) {
+  const { window = defaultWindow, ignore, capture = true, detectIframe = false } = options;
+  if (!window)
+    return;
+  const shouldListen = ref(true);
+  let fallback;
+  const listener = (event) => {
+    window.clearTimeout(fallback);
+    const el = unrefElement(target);
+    if (!el || el === event.target || event.composedPath().includes(el) || !shouldListen.value)
+      return;
+    handler(event);
+  };
+  const shouldIgnore = (event) => {
+    return ignore && ignore.some((target2) => {
+      const el = unrefElement(target2);
+      return el && (event.target === el || event.composedPath().includes(el));
+    });
+  };
+  const cleanup = [
+    useEventListener(window, "click", listener, { passive: true, capture }),
+    useEventListener(window, "pointerdown", (e) => {
+      const el = unrefElement(target);
+      shouldListen.value = !!el && !e.composedPath().includes(el) && !shouldIgnore(e);
+    }, { passive: true }),
+    useEventListener(window, "pointerup", (e) => {
+      if (e.button === 0) {
+        const path = e.composedPath();
+        e.composedPath = () => path;
+        fallback = window.setTimeout(() => listener(e), 50);
+      }
+    }, { passive: true }),
+    detectIframe && useEventListener(window, "blur", (event) => {
+      var _a;
+      const el = unrefElement(target);
+      if (((_a = window.document.activeElement) == null ? void 0 : _a.tagName) === "IFRAME" && !(el == null ? void 0 : el.contains(window.document.activeElement)))
+        handler(event);
+    })
+  ].filter(Boolean);
+  const stop = () => cleanup.forEach((fn) => fn());
+  return stop;
+}
+
+function useActiveElement(options = {}) {
+  const { window = defaultWindow } = options;
+  const activeElement = computedWithControl(() => null, () => window == null ? void 0 : window.document.activeElement);
+  if (window) {
+    useEventListener(window, "blur", activeElement.trigger, true);
+    useEventListener(window, "focus", activeElement.trigger, true);
+  }
+  return activeElement;
+}
+
+function useSupported(callback, sync = false) {
+  const isSupported = ref();
+  const update = () => isSupported.value = Boolean(callback());
+  update();
+  tryOnMounted(update, sync);
+  return isSupported;
+}
+
+function useMediaQuery(query, options = {}) {
+  const { window = defaultWindow } = options;
+  const isSupported = useSupported(() => window && "matchMedia" in window && typeof window.matchMedia === "function");
+  let mediaQuery;
+  const matches = ref(false);
+  const cleanup = () => {
+    if (!mediaQuery)
+      return;
+    if ("removeEventListener" in mediaQuery)
+      mediaQuery.removeEventListener("change", update);
+    else
+      mediaQuery.removeListener(update);
+  };
+  const update = () => {
+    if (!isSupported.value)
+      return;
+    cleanup();
+    mediaQuery = window.matchMedia(resolveRef(query).value);
+    matches.value = mediaQuery.matches;
+    if ("addEventListener" in mediaQuery)
+      mediaQuery.addEventListener("change", update);
+    else
+      mediaQuery.addListener(update);
+  };
+  watchEffect(update);
+  tryOnScopeDispose(() => cleanup());
+  return matches;
+}
+function cloneFnJSON(source) {
+  return JSON.parse(JSON.stringify(source));
+}
+
+const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+const globalKey = "__vueuse_ssr_handlers__";
+_global[globalKey] = _global[globalKey] || {};
+_global[globalKey];
+
+var __defProp$e = Object.defineProperty;
+var __defProps$4 = Object.defineProperties;
+var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$g = Object.getOwnPropertySymbols;
+var __hasOwnProp$g = Object.prototype.hasOwnProperty;
+var __propIsEnum$g = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$e = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$g.call(b, prop))
+      __defNormalProp$e(a, prop, b[prop]);
+  if (__getOwnPropSymbols$g)
+    for (var prop of __getOwnPropSymbols$g(b)) {
+      if (__propIsEnum$g.call(b, prop))
+        __defNormalProp$e(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
+function useDraggable(target, options = {}) {
+  var _a, _b, _c;
+  const draggingElement = (_a = options.draggingElement) != null ? _a : defaultWindow;
+  const draggingHandle = (_b = options.handle) != null ? _b : target;
+  const position = ref((_c = resolveUnref(options.initialValue)) != null ? _c : { x: 0, y: 0 });
+  const pressedDelta = ref();
+  const filterEvent = (e) => {
+    if (options.pointerTypes)
+      return options.pointerTypes.includes(e.pointerType);
+    return true;
+  };
+  const handleEvent = (e) => {
+    if (resolveUnref(options.preventDefault))
+      e.preventDefault();
+    if (resolveUnref(options.stopPropagation))
+      e.stopPropagation();
+  };
+  const start = (e) => {
+    var _a2;
+    if (!filterEvent(e))
+      return;
+    if (resolveUnref(options.exact) && e.target !== resolveUnref(target))
+      return;
+    const rect = resolveUnref(target).getBoundingClientRect();
+    const pos = {
+      x: e.pageX - rect.left,
+      y: e.pageY - rect.top
+    };
+    if (((_a2 = options.onStart) == null ? void 0 : _a2.call(options, pos, e)) === false)
+      return;
+    pressedDelta.value = pos;
+    handleEvent(e);
+  };
+  const move = (e) => {
+    var _a2;
+    if (!filterEvent(e))
+      return;
+    if (!pressedDelta.value)
+      return;
+    position.value = {
+      x: e.pageX - pressedDelta.value.x,
+      y: e.pageY - pressedDelta.value.y
+    };
+    (_a2 = options.onMove) == null ? void 0 : _a2.call(options, position.value, e);
+    handleEvent(e);
+  };
+  const end = (e) => {
+    var _a2;
+    if (!filterEvent(e))
+      return;
+    if (!pressedDelta.value)
+      return;
+    pressedDelta.value = void 0;
+    (_a2 = options.onEnd) == null ? void 0 : _a2.call(options, position.value, e);
+    handleEvent(e);
+  };
+  if (isClient) {
+    useEventListener(draggingHandle, "pointerdown", start, true);
+    useEventListener(draggingElement, "pointermove", move, true);
+    useEventListener(draggingElement, "pointerup", end, true);
+  }
+  return __spreadProps$4(__spreadValues$e({}, toRefs(position)), {
+    position,
+    isDragging: computed(() => !!pressedDelta.value),
+    style: computed(() => `left:${position.value.x}px;top:${position.value.y}px;`)
+  });
+}
+
+var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
+var __hasOwnProp$f = Object.prototype.hasOwnProperty;
+var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
+var __objRest$2 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$f.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$f)
+    for (var prop of __getOwnPropSymbols$f(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$f.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function useResizeObserver(target, callback, options = {}) {
+  const _a = options, { window = defaultWindow } = _a, observerOptions = __objRest$2(_a, ["window"]);
+  let observer;
+  const isSupported = useSupported(() => window && "ResizeObserver" in window);
+  const cleanup = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = void 0;
+    }
+  };
+  const stopWatch = watch(() => unrefElement(target), (el) => {
+    cleanup();
+    if (isSupported.value && window && el) {
+      observer = new ResizeObserver(callback);
+      observer.observe(el, observerOptions);
+    }
+  }, { immediate: true, flush: "post" });
+  const stop = () => {
+    cleanup();
+    stopWatch();
+  };
+  tryOnScopeDispose(stop);
+  return {
+    isSupported,
+    stop
+  };
+}
+
+function useElementBounding(target, options = {}) {
+  const {
+    reset = true,
+    windowResize = true,
+    windowScroll = true,
+    immediate = true
+  } = options;
+  const height = ref(0);
+  const bottom = ref(0);
+  const left = ref(0);
+  const right = ref(0);
+  const top = ref(0);
+  const width = ref(0);
+  const x = ref(0);
+  const y = ref(0);
+  function update() {
+    const el = unrefElement(target);
+    if (!el) {
+      if (reset) {
+        height.value = 0;
+        bottom.value = 0;
+        left.value = 0;
+        right.value = 0;
+        top.value = 0;
+        width.value = 0;
+        x.value = 0;
+        y.value = 0;
+      }
+      return;
+    }
+    const rect = el.getBoundingClientRect();
+    height.value = rect.height;
+    bottom.value = rect.bottom;
+    left.value = rect.left;
+    right.value = rect.right;
+    top.value = rect.top;
+    width.value = rect.width;
+    x.value = rect.x;
+    y.value = rect.y;
+  }
+  useResizeObserver(target, update);
+  watch(() => unrefElement(target), (ele) => !ele && update());
+  if (windowScroll)
+    useEventListener("scroll", update, { passive: true });
+  if (windowResize)
+    useEventListener("resize", update, { passive: true });
+  tryOnMounted(() => {
+    if (immediate)
+      update();
+  });
+  return {
+    height,
+    bottom,
+    left,
+    right,
+    top,
+    width,
+    x,
+    y,
+    update
+  };
+}
+
+function useElementHover(el) {
+  const isHovered = ref(false);
+  useEventListener(el, "mouseenter", () => isHovered.value = true);
+  useEventListener(el, "mouseleave", () => isHovered.value = false);
+  return isHovered;
+}
+
+function useElementSize(target, initialSize = { width: 0, height: 0 }, options = {}) {
+  const { box = "content-box" } = options;
+  const width = ref(initialSize.width);
+  const height = ref(initialSize.height);
+  useResizeObserver(target, ([entry]) => {
+    const boxSize = box === "border-box" ? entry.borderBoxSize : box === "content-box" ? entry.contentBoxSize : entry.devicePixelContentBoxSize;
+    if (boxSize) {
+      width.value = boxSize.reduce((acc, { inlineSize }) => acc + inlineSize, 0);
+      height.value = boxSize.reduce((acc, { blockSize }) => acc + blockSize, 0);
+    } else {
+      width.value = entry.contentRect.width;
+      height.value = entry.contentRect.height;
+    }
+  }, options);
+  watch(() => unrefElement(target), (ele) => {
+    width.value = ele ? initialSize.width : 0;
+    height.value = ele ? initialSize.height : 0;
+  });
+  return {
+    width,
+    height
+  };
+}
+
+const events = new Map();
+
+function useEventBus(key) {
+  const scope = getCurrentScope();
+  function on(listener) {
+    var _a;
+    const listeners = events.get(key) || [];
+    listeners.push(listener);
+    events.set(key, listeners);
+    const _off = () => off(listener);
+    (_a = scope == null ? void 0 : scope.cleanups) == null ? void 0 : _a.push(_off);
+    return _off;
+  }
+  function once(listener) {
+    function _listener(...args) {
+      off(_listener);
+      listener(...args);
+    }
+    return on(_listener);
+  }
+  function off(listener) {
+    const listeners = events.get(key);
+    if (!listeners)
+      return;
+    const index = listeners.indexOf(listener);
+    if (index > -1)
+      listeners.splice(index, 1);
+    if (!listeners.length)
+      events.delete(key);
+  }
+  function reset() {
+    events.delete(key);
+  }
+  function emit(event, payload) {
+    var _a;
+    (_a = events.get(key)) == null ? void 0 : _a.forEach((v) => v(event, payload));
+  }
+  return { on, once, off, emit, reset };
+}
+
+function useFocus(target, options = {}) {
+  const { initialValue = false } = options;
+  const activeElement = useActiveElement(options);
+  const targetElement = computed(() => unrefElement(target));
+  const focused = computed({
+    get() {
+      return isDef(activeElement.value) && isDef(targetElement.value) && activeElement.value === targetElement.value;
+    },
+    set(value) {
+      var _a, _b;
+      if (!value && focused.value)
+        (_a = targetElement.value) == null ? void 0 : _a.blur();
+      if (value && !focused.value)
+        (_b = targetElement.value) == null ? void 0 : _b.focus();
+    }
+  });
+  watch(targetElement, () => {
+    focused.value = initialValue;
+  }, { immediate: true, flush: "post" });
+  return { focused };
+}
+
+const DefaultMagicKeysAliasMap = {
+  ctrl: "control",
+  command: "meta",
+  cmd: "meta",
+  option: "alt",
+  up: "arrowup",
+  down: "arrowdown",
+  left: "arrowleft",
+  right: "arrowright"
+};
+
+function useMagicKeys(options = {}) {
+  const {
+    reactive: useReactive = false,
+    target = defaultWindow,
+    aliasMap = DefaultMagicKeysAliasMap,
+    passive = true,
+    onEventFired = noop
+  } = options;
+  const current = reactive(new Set());
+  const obj = { toJSON() {
+    return {};
+  }, current };
+  const refs = useReactive ? reactive(obj) : obj;
+  const metaDeps = new Set();
+  const usedKeys = new Set();
+  function setRefs(key, value) {
+    if (key in refs) {
+      if (useReactive)
+        refs[key] = value;
+      else
+        refs[key].value = value;
+    }
+  }
+  function reset() {
+    for (const key of usedKeys)
+      setRefs(key, false);
+  }
+  function updateRefs(e, value) {
+    var _a, _b;
+    const key = (_a = e.key) == null ? void 0 : _a.toLowerCase();
+    const code = (_b = e.code) == null ? void 0 : _b.toLowerCase();
+    const values = [code, key].filter(Boolean);
+    if (key) {
+      if (value)
+        current.add(key);
+      else
+        current.delete(key);
+    }
+    for (const key2 of values) {
+      usedKeys.add(key2);
+      setRefs(key2, value);
+    }
+    if (key === "meta" && !value) {
+      metaDeps.forEach((key2) => {
+        current.delete(key2);
+        setRefs(key2, false);
+      });
+      metaDeps.clear();
+    } else if (typeof e.getModifierState === "function" && e.getModifierState("Meta") && value) {
+      [...current, ...values].forEach((key2) => metaDeps.add(key2));
+    }
+  }
+  useEventListener(target, "keydown", (e) => {
+    updateRefs(e, true);
+    return onEventFired(e);
+  }, { passive });
+  useEventListener(target, "keyup", (e) => {
+    updateRefs(e, false);
+    return onEventFired(e);
+  }, { passive });
+  useEventListener("blur", reset, { passive: true });
+  useEventListener("focus", reset, { passive: true });
+  const proxy = new Proxy(refs, {
+    get(target2, prop, rec) {
+      if (typeof prop !== "string")
+        return Reflect.get(target2, prop, rec);
+      prop = prop.toLowerCase();
+      if (prop in aliasMap)
+        prop = aliasMap[prop];
+      if (!(prop in refs)) {
+        if (/[+_-]/.test(prop)) {
+          const keys = prop.split(/[+_-]/g).map((i) => i.trim());
+          refs[prop] = computed(() => keys.every((key) => unref(proxy[key])));
+        } else {
+          refs[prop] = ref(false);
+        }
+      }
+      const r = Reflect.get(target2, prop, rec);
+      return useReactive ? unref(r) : r;
+    }
+  });
+  return proxy;
+}
+
+var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
+var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
+var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
+var __objRest$1 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp$7.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols$7)
+    for (var prop of __getOwnPropSymbols$7(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum$7.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+function useMutationObserver(target, callback, options = {}) {
+  const _a = options, { window = defaultWindow } = _a, mutationOptions = __objRest$1(_a, ["window"]);
+  let observer;
+  const isSupported = useSupported(() => window && "MutationObserver" in window);
+  const cleanup = () => {
+    if (observer) {
+      observer.disconnect();
+      observer = void 0;
+    }
+  };
+  const stopWatch = watch(() => unrefElement(target), (el) => {
+    cleanup();
+    if (isSupported.value && window && el) {
+      observer = new MutationObserver(callback);
+      observer.observe(el, mutationOptions);
+    }
+  }, { immediate: true });
+  const stop = () => {
+    cleanup();
+    stopWatch();
+  };
+  tryOnScopeDispose(stop);
+  return {
+    isSupported,
+    stop
+  };
+}
+
+var SwipeDirection;
+(function(SwipeDirection2) {
+  SwipeDirection2["UP"] = "UP";
+  SwipeDirection2["RIGHT"] = "RIGHT";
+  SwipeDirection2["DOWN"] = "DOWN";
+  SwipeDirection2["LEFT"] = "LEFT";
+  SwipeDirection2["NONE"] = "NONE";
+})(SwipeDirection || (SwipeDirection = {}));
+
+function usePointerSwipe(target, options = {}) {
+  const targetRef = resolveRef(target);
+  const {
+    threshold = 50,
+    onSwipe,
+    onSwipeEnd,
+    onSwipeStart
+  } = options;
+  const posStart = reactive({ x: 0, y: 0 });
+  const updatePosStart = (x, y) => {
+    posStart.x = x;
+    posStart.y = y;
+  };
+  const posEnd = reactive({ x: 0, y: 0 });
+  const updatePosEnd = (x, y) => {
+    posEnd.x = x;
+    posEnd.y = y;
+  };
+  const distanceX = computed(() => posStart.x - posEnd.x);
+  const distanceY = computed(() => posStart.y - posEnd.y);
+  const { max, abs } = Math;
+  const isThresholdExceeded = computed(() => max(abs(distanceX.value), abs(distanceY.value)) >= threshold);
+  const isSwiping = ref(false);
+  const isPointerDown = ref(false);
+  const direction = computed(() => {
+    if (!isThresholdExceeded.value)
+      return SwipeDirection.NONE;
+    if (abs(distanceX.value) > abs(distanceY.value)) {
+      return distanceX.value > 0 ? SwipeDirection.LEFT : SwipeDirection.RIGHT;
+    } else {
+      return distanceY.value > 0 ? SwipeDirection.UP : SwipeDirection.DOWN;
+    }
+  });
+  const eventIsAllowed = (e) => {
+    var _a, _b, _c;
+    const isReleasingButton = e.buttons === 0;
+    const isPrimaryButton = e.buttons === 1;
+    return (_c = (_b = (_a = options.pointerTypes) == null ? void 0 : _a.includes(e.pointerType)) != null ? _b : isReleasingButton || isPrimaryButton) != null ? _c : true;
+  };
+  const stops = [
+    useEventListener(target, "pointerdown", (e) => {
+      var _a, _b;
+      if (!eventIsAllowed(e))
+        return;
+      isPointerDown.value = true;
+      (_b = (_a = targetRef.value) == null ? void 0 : _a.style) == null ? void 0 : _b.setProperty("touch-action", "none");
+      const eventTarget = e.target;
+      eventTarget == null ? void 0 : eventTarget.setPointerCapture(e.pointerId);
+      const { clientX: x, clientY: y } = e;
+      updatePosStart(x, y);
+      updatePosEnd(x, y);
+      onSwipeStart == null ? void 0 : onSwipeStart(e);
+    }),
+    useEventListener(target, "pointermove", (e) => {
+      if (!eventIsAllowed(e))
+        return;
+      if (!isPointerDown.value)
+        return;
+      const { clientX: x, clientY: y } = e;
+      updatePosEnd(x, y);
+      if (!isSwiping.value && isThresholdExceeded.value)
+        isSwiping.value = true;
+      if (isSwiping.value)
+        onSwipe == null ? void 0 : onSwipe(e);
+    }),
+    useEventListener(target, "pointerup", (e) => {
+      var _a, _b;
+      if (!eventIsAllowed(e))
+        return;
+      if (isSwiping.value)
+        onSwipeEnd == null ? void 0 : onSwipeEnd(e, direction.value);
+      isPointerDown.value = false;
+      isSwiping.value = false;
+      (_b = (_a = targetRef.value) == null ? void 0 : _a.style) == null ? void 0 : _b.setProperty("touch-action", "initial");
+    })
+  ];
+  const stop = () => stops.forEach((s) => s());
+  return {
+    isSwiping: readonly(isSwiping),
+    direction: readonly(direction),
+    posStart: readonly(posStart),
+    posEnd: readonly(posEnd),
+    distanceX,
+    distanceY,
+    stop
+  };
+}
+
+function preventDefault(rawEvent) {
+  const e = rawEvent || window.event;
+  if (e.touches.length > 1)
+    return true;
+  if (e.preventDefault)
+    e.preventDefault();
+  return false;
+}
+function useScrollLock(element, initialState = false) {
+  const isLocked = ref(initialState);
+  let stopTouchMoveListener = null;
+  let initialOverflow;
+  watch(resolveRef(element), (el) => {
+    if (el) {
+      const ele = el;
+      initialOverflow = ele.style.overflow;
+      if (isLocked.value)
+        ele.style.overflow = "hidden";
+    }
+  }, {
+    immediate: true
+  });
+  const lock = () => {
+    const ele = resolveUnref(element);
+    if (!ele || isLocked.value)
+      return;
+    if (isIOS) {
+      stopTouchMoveListener = useEventListener(ele, "touchmove", preventDefault, { passive: false });
+    }
+    ele.style.overflow = "hidden";
+    isLocked.value = true;
+  };
+  const unlock = () => {
+    const ele = resolveUnref(element);
+    if (!ele || !isLocked.value)
+      return;
+    isIOS && (stopTouchMoveListener == null ? void 0 : stopTouchMoveListener());
+    ele.style.overflow = initialOverflow;
+    isLocked.value = false;
+  };
+  tryOnScopeDispose(unlock);
+  return computed({
+    get() {
+      return isLocked.value;
+    },
+    set(v) {
+      if (v)
+        lock();
+      else
+        unlock();
+    }
+  });
+}
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+const _TransitionPresets = {
+  easeInSine: [0.12, 0, 0.39, 0],
+  easeOutSine: [0.61, 1, 0.88, 1],
+  easeInOutSine: [0.37, 0, 0.63, 1],
+  easeInQuad: [0.11, 0, 0.5, 0],
+  easeOutQuad: [0.5, 1, 0.89, 1],
+  easeInOutQuad: [0.45, 0, 0.55, 1],
+  easeInCubic: [0.32, 0, 0.67, 0],
+  easeOutCubic: [0.33, 1, 0.68, 1],
+  easeInOutCubic: [0.65, 0, 0.35, 1],
+  easeInQuart: [0.5, 0, 0.75, 0],
+  easeOutQuart: [0.25, 1, 0.5, 1],
+  easeInOutQuart: [0.76, 0, 0.24, 1],
+  easeInQuint: [0.64, 0, 0.78, 0],
+  easeOutQuint: [0.22, 1, 0.36, 1],
+  easeInOutQuint: [0.83, 0, 0.17, 1],
+  easeInExpo: [0.7, 0, 0.84, 0],
+  easeOutExpo: [0.16, 1, 0.3, 1],
+  easeInOutExpo: [0.87, 0, 0.13, 1],
+  easeInCirc: [0.55, 0, 1, 0.45],
+  easeOutCirc: [0, 0.55, 0.45, 1],
+  easeInOutCirc: [0.85, 0, 0.15, 1],
+  easeInBack: [0.36, 0, 0.66, -0.56],
+  easeOutBack: [0.34, 1.56, 0.64, 1],
+  easeInOutBack: [0.68, -0.6, 0.32, 1.6]
+};
+__spreadValues({
+  linear: identity
+}, _TransitionPresets);
+
+function useVModel(props, key, emit, options = {}) {
+  var _a, _b, _c, _d, _e;
+  const {
+    clone = false,
+    passive = false,
+    eventName,
+    deep = false,
+    defaultValue
+  } = options;
+  const vm = getCurrentInstance();
+  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));
+  let event = eventName;
+  if (!key) {
+    if (isVue2) {
+      const modelOptions = (_e = (_d = vm == null ? void 0 : vm.proxy) == null ? void 0 : _d.$options) == null ? void 0 : _e.model;
+      key = (modelOptions == null ? void 0 : modelOptions.value) || "value";
+      if (!eventName)
+        event = (modelOptions == null ? void 0 : modelOptions.event) || "input";
+    } else {
+      key = "modelValue";
+    }
+  }
+  event = eventName || event || `update:${key.toString()}`;
+  const cloneFn = (val) => !clone ? val : isFunction(clone) ? clone(val) : cloneFnJSON(val);
+  const getValue = () => isDef(props[key]) ? cloneFn(props[key]) : defaultValue;
+  if (passive) {
+    const initialValue = getValue();
+    const proxy = ref(initialValue);
+    watch(() => props[key], (v) => proxy.value = cloneFn(v));
+    watch(proxy, (v) => {
+      if (v !== props[key] || deep)
+        _emit(event, v);
+    }, { deep });
+    return proxy;
+  } else {
+    return computed({
+      get() {
+        return getValue();
+      },
+      set(value) {
+        _emit(event, value);
+      }
+    });
+  }
+}
+
+function useControlAttributes() {
+  const attributes = useAttrs();
+  return {
+    readonly: computed(() => attributes['readonly']),
+    disabled: computed(() => attributes['disabled']),
+    'force-state': computed(() => attributes['force-state'])
+  };
+}
+
+function isVisible(element) {
+  return element.getClientRects().length > 0;
+}
+
+function useElevation(element, trigger) {
+  const elementRef = isRef(element) ? element : ref(element);
+  const triggerRef = isRef(trigger) ? trigger : ref();
+  // Functions
+  function getPageElevations(currentElement) {
+    return [...document.body.querySelectorAll('*')].filter(isVisible).filter(element => !element.isEqualNode(currentElement)).map(element => getComputedStyle(element)).map(style => Number(style.zIndex)).filter(zIndex => !isNaN(zIndex));
+  }
+  function setElementElevation(element) {
+    element.style.zIndex = String(Math.max(0, ...getPageElevations(element)) + 1);
+  }
+  // Effects
+  watch([elementRef, triggerRef], _ref => {
+    let [element] = _ref;
+    if (element) {
+      setElementElevation(element);
+    }
+  }, {
+    immediate: true
+  });
+}
+
+function useIdAttribute() {
+  const attributes = useAttrs(),
+    component = getCurrentInstance();
+  return computed(() => {
+    var _a;
+    return (_a = attributes['id']) !== null && _a !== void 0 ? _a : component === null || component === void 0 ? void 0 : component.uid.toString();
+  });
+}
+
+const CODE_BACKSPACE = 8;
+const CODE_BREAK = 19;
+const CODE_DELETE = 46;
+const CODE_DOWN = 40;
+const CODE_END = 35;
+const CODE_ENTER = 13;
+const CODE_ESC = 27;
+const CODE_HOME = 36;
+const CODE_LEFT = 37;
+const CODE_PAGEDOWN = 34;
+const CODE_PAGEUP = 33;
+const CODE_RIGHT = 39;
+const CODE_SPACE = 32;
+const CODE_UP = 38;
+
+const PLACEMENT_TOP_START = 'top-start';
+const PLACEMENT_TOP_END = 'top-end';
+const PLACEMENT_BOTTOM_START = 'bottom-start';
+const PLACEMENT_BOTTOM_END = 'bottom-end';
+const PLACEMENT_RIGHT_START = 'right-start';
+const PLACEMENT_RIGHT_END = 'right-end';
+const PLACEMENT_LEFT_START = 'left-start';
+const PLACEMENT_LEFT_END = 'left-end';
+
+function flattenDeep() {
+  let arr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  return arr.flatMap(subArray => Array.isArray(subArray) ? flattenDeep(subArray) : subArray);
+}
+
+function getAbbreviation(text, limit) {
+  var _a;
+  if (typeof text != 'string' || !text) return '';
+  return ((_a = text.match(RX_ABBREVIATION_FROM_STRING)) !== null && _a !== void 0 ? _a : []).reduce((previous, next) => previous + (+next === 0 || parseInt(next) ? parseInt(next) : next[0] || ''), '').toUpperCase().substring(0, limit);
+}
+
+function isEmpty(val) {
+  return val == null || !(Object.keys(val) || val).length;
+}
+
+function isEmptyValue(val) {
+  return val === undefined || val === null || val === '';
+}
+
+function isEqualValue(val1, val2) {
+  if (typeof val1 === 'object' && typeof val2 === 'object') {
+    return JSON.stringify(val1) === JSON.stringify(val2);
+  }
+  return val1 === val2;
+}
+
+function useOverflow(container) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const {
+    hide = true,
+    threshold = 0
+  } = options;
+  const containerRef = isRef(container) ? container : ref(container);
+  // State
+  const innerItemsRef = ref([]);
+  const outerItemsRef = ref([]);
+  // Functions
+  function updateState() {
+    const container = containerRef.value;
+    if (container) {
+      const update = [...container.children].reduce((_ref, child) => {
+        let {
+          innerItems,
+          outerItems
+        } = _ref;
+        const item = child;
+        const {
+          x: itemOffset,
+          width: itemWidth
+        } = item.getBoundingClientRect();
+        const {
+          x: containerOffset,
+          width: containerWidth
+        } = container.getBoundingClientRect();
+        if (itemOffset + itemWidth > containerOffset + containerWidth + threshold) {
+          if (hide) {
+            item.style.setProperty('visibility', 'hidden');
+          }
+          return {
+            innerItems,
+            outerItems: [...outerItems, item]
+          };
+        } else {
+          if (hide) {
+            item.style.removeProperty('visibility');
+          }
+          return {
+            innerItems: [...innerItems, item],
+            outerItems
+          };
+        }
+      }, {
+        innerItems: [],
+        outerItems: []
+      });
+      innerItemsRef.value = update.innerItems;
+      outerItemsRef.value = update.outerItems;
+    } else {
+      innerItemsRef.value = [];
+      outerItemsRef.value = [];
+    }
+  }
+  // Effects
+  watch(containerRef, updateState, {
+    immediate: true
+  });
+  useMutationObserver(containerRef, updateState, {
+    childList: true
+  });
+  useResizeObserver(containerRef, () => requestAF(updateState));
+  return {
+    innerItems: innerItemsRef,
+    outerItems: outerItemsRef
+  };
+}
+
+// TODO: Use `defineEmits` after migration to Vue 3
+function usePopoverState(isOpen, emit) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  // State
+  const state = ref(isOpen.value ? 'open' : 'closed');
+  watch(isOpen, value => {
+    state.value = value ? 'open' : 'closed';
+  });
+  const debouncedState = options.debounce ? refDebounced(state, options.debounce) : state;
+  watch(debouncedState, value => {
+    emit('update:state', value);
+    switch (value) {
+      case 'open':
+        emit('open');
+        break;
+      case 'closed':
+        emit('close');
+        break;
+    }
+  });
+  // Methods
+  function open() {
+    state.value = 'open';
+  }
+  function close() {
+    state.value = 'closed';
+  }
+  function toggle() {
+    state.value = state.value === 'open' ? 'closed' : 'open';
+  }
+  return {
+    state: debouncedState,
+    open,
+    close,
+    toggle
+  };
+}
+
+function useProxyModelValue(modelValue, emit) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const {
+    defaultValue
+  } = options;
+  if (defaultValue) {
+    return computed({
+      get: () => {
+        var _a;
+        return (_a = modelValue.value) !== null && _a !== void 0 ? _a : defaultValue.value;
+      },
+      set: value => {
+        emit('update:modelValue', value);
+      }
+    });
+  }
+  return computed({
+    get: () => {
+      return modelValue.value;
+    },
+    set: value => {
+      emit('update:modelValue', value);
+    }
+  });
+}
+
+var createPlugin$2 = {};
+
+var createPlugin$1 = {};
+
+(function (exports) {
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function () {
+      return _default;
+    }
+  });
+  function createPlugin(plugin, config) {
+    return {
+      handler: plugin,
+      config
+    };
+  }
+  createPlugin.withOptions = function (pluginFunction) {
+    let configFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : () => ({});
+    const optionsFunction = function (options) {
+      return {
+        __options: options,
+        handler: pluginFunction(options),
+        config: configFunction(options)
+      };
+    };
+    optionsFunction.__isOptionsFunction = true;
+    // Expose plugin dependencies so that `object-hash` returns a different
+    // value if anything here changes, to ensure a rebuild is triggered.
+    optionsFunction.__pluginFunction = pluginFunction;
+    optionsFunction.__configFunction = configFunction;
+    return optionsFunction;
+  };
+  const _default = createPlugin;
+})(createPlugin$1);
+
+(function (exports) {
+
+  Object.defineProperty(exports, "__esModule", {
+    value: true
+  });
+  Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function () {
+      return _default;
+    }
+  });
+  const _createPlugin = /*#__PURE__*/_interop_require_default(createPlugin$1);
+  function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+      default: obj
+    };
+  }
+  const _default = _createPlugin.default;
+})(createPlugin$2);
+
+let createPlugin = createPlugin$2;
+var plugin$1 = (createPlugin.__esModule ? createPlugin : {
+  default: createPlugin
+}).default;
+
+const plugin = plugin$1;
+
+const screens = {
+  'sm': '640px',
+  'md': '768px',
+  'lg': '1024px',
+  'xl': '1280px',
+  '2xl': '1536px',
+};
+
+const variants = {
+  'children': ['& > *'],
+
+  'first-child': ['& > *:first-child'],
+  'middle-child': ['& > *:not(:first-child, :last-child)'],
+  'last-child': ['& > *:last-child'],
+
+  'links': ['& :any-link'],
+
+  'checked': ['&[checked]:not([checked="false"])', '&:checked'],
+  'selected': ['&[selected]:not([selected="false"])', '&:checked'],
+  'activated': ['&[activated]:not([activated="false"])'],
+
+  'valid': ['&:not([invalid])', '&[invalid="false"]'],
+  'invalid': ['&[invalid]:not([invalid="false"])'],
+
+  'required': ['&[required]:not([required="false"])'],
+  'optional': ['&:not([required])', '&[required="false"]'],
+
+  'read-write': ['&:not([readonly])', '&[readonly="false"]'],
+  'read-only': ['&[readonly]:not([readonly="false"])'],
+
+  'enabled': ['&:not([disabled])', '&[disabled="false"]'],
+  'disabled': ['&[disabled]:not([disabled="false"])'],
+
+  'draggable': ['&[draggable]:not([draggable="false"])'],
+
+  'hover': [
+    '&:not(.interactivity-none):hover',
+    '&:not(.interactivity-none)[force-state="hover"]',
+  ],
+
+  'focus': [
+    '&:not(.interactivity-none):focus',
+    '&:not(.interactivity-none)[force-state="focus"]',
+  ],
+
+  'focus-within': [
+    '&:not(.interactivity-none):focus-within',
+    '&:not(.interactivity-none)[force-state="focus-within"]',
+  ],
+
+  'focus-visible': [
+    '&:not(.interactivity-none):focus-visible',
+    '&:not(.interactivity-none)[force-state="focus-visible"]',
+  ],
+
+  'active': [
+    '&:not(.interactivity-none):active',
+    '&:not(.interactivity-none)[force-state="active"]',
+  ],
+};
+
+var core = {
+  screens,
+  variants,
+
+  plugin: plugin(({ addVariant, addUtilities }) => {
+    Object.entries(screens).forEach(([breakpoint, width]) => {
+      addVariant(breakpoint, [
+        `@media (min-width: ${width})`,
+        `[force-screen~="${breakpoint}"] &`,
+        `&[force-screen~="${breakpoint}"]`,
+      ]);
+    });
+
+    Object.entries(variants).forEach(([modifier, selectors]) => {
+      addVariant(modifier, selectors);
+    });
+
+    // TODO: Remove when migration complete
+    addUtilities({
+      '.visually-hidden': {
+        width: 0,
+        height: 0,
+        visibility: 'hidden',
+      },
+    });
+  }),
+};
+
+function useResponsive(element) {
+  const currentInstance = getCurrentInstance();
+  const currentRootElement = ref();
+  if (element) {
+    watch(element, value => {
+      currentRootElement.value = value;
+    });
+  } else {
+    onMounted(() => {
+      if (currentInstance) {
+        const element = currentInstance.vnode[isVue3 ? 'el' : 'elm'];
+        if (element instanceof Element) {
+          currentRootElement.value = element;
+        }
+      }
+    });
+  }
+  // State
+  const isDesktop = computed(() => {
+    return isForcedDesktop(currentRootElement.value) || desktopQuery.value;
+  });
+  const isMobile = computed(() => {
+    return !isDesktop.value;
+  });
+  const desktopQuery = useMediaQuery(`(min-width: ${core.screens.md})`);
+  // Helpers
+  function isForcedDesktop(element) {
+    var _a, _b;
+    if (!element) {
+      return false;
+    }
+    const forcedScreens = (_a = element.getAttribute('force-screen')) === null || _a === void 0 ? void 0 : _a.split(/\s+/);
+    if (forcedScreens === null || forcedScreens === void 0 ? void 0 : forcedScreens.some(forcedScreen => ['md', 'lg', 'xl', '2xl'].includes(forcedScreen))) {
+      return true;
+    }
+    return isForcedDesktop((_b = element.parentElement) !== null && _b !== void 0 ? _b : undefined);
+  }
+  return {
+    isDesktop,
+    isMobile
+  };
+}
+
 var theme = {
 	screens: {
 	},
@@ -3747,4 +6784,280 @@ function useTheme() {
   return defaultConfig.theme;
 }
 
-export { useTheme };
+function useToggle() {
+  let defaultValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  const isActiveToggle = ref(defaultValue);
+  function show() {
+    isActiveToggle.value = true;
+  }
+  function hide() {
+    isActiveToggle.value = false;
+  }
+  function toggle() {
+    isActiveToggle.value = !isActiveToggle.value;
+  }
+  return {
+    isActiveToggle,
+    show,
+    hide,
+    toggle
+  };
+}
+
+function useValidationAttributes() {
+  const attributes = useAttrs();
+  return {
+    required: computed(() => attributes['required']),
+    minlength: computed(() => attributes['minlength']),
+    maxlength: computed(() => attributes['maxlength']),
+    pattern: computed(() => attributes['pattern']),
+    min: computed(() => attributes['min']),
+    max: computed(() => attributes['max']),
+    step: computed(() => attributes['step'])
+  };
+}
+
+var BottomSheetVariant;
+(function (BottomSheetVariant) {
+  BottomSheetVariant["Basic"] = "basic";
+  BottomSheetVariant["Advanced"] = "advanced";
+})(BottomSheetVariant || (BottomSheetVariant = {}));
+
+function useBottomSheetSwipeState(root, content, fullscreen, variant, close) {
+  const inlineSwipingStyles = ref({});
+  const skipSwipe = ref(false);
+  const theme = useTheme();
+  const isEventSkipped = event => {
+    return variant.value === BottomSheetVariant.Basic || event.composedPath().includes(content.value) && fullscreen.value;
+  };
+  const {
+    isSwiping
+  } = usePointerSwipe(root, {
+    threshold: 12,
+    onSwipe(event) {
+      skipSwipe.value = isEventSkipped(event);
+      if (variant.value === BottomSheetVariant.Advanced) {
+        const rootElement = unref(root);
+        inlineSwipingStyles.value = {
+          transitionProperty: 'none',
+          minHeight: `${rootElement.clientHeight - event.offsetY}px`,
+          maxHeight: `${rootElement.clientHeight - event.offsetY}px`
+        };
+      }
+    },
+    onSwipeEnd(event, direction) {
+      if (isEventSkipped(event)) {
+        return;
+      }
+      if (variant.value === BottomSheetVariant.Advanced) {
+        switch (direction) {
+          case SwipeDirection.UP:
+            fullscreen.value = true;
+            break;
+          case SwipeDirection.DOWN:
+            if (fullscreen.value) {
+              fullscreen.value = false;
+            } else {
+              close();
+            }
+            break;
+        }
+      }
+    }
+  });
+  const rootInlineStyles = computed(() => {
+    if (variant.value === BottomSheetVariant.Basic) {
+      return {
+        transitionProperty: 'min-height, max-height',
+        minHeight: '0',
+        maxHeight: `calc(100% - ${theme.spacing.xl})`
+      };
+    }
+    return isSwiping.value && !skipSwipe.value ? inlineSwipingStyles.value : fullscreen.value ? {
+      transitionProperty: 'min-height, max-height',
+      minHeight: `calc(100% - ${theme.spacing.xl})`,
+      maxHeight: `calc(100% - ${theme.spacing.xl})`
+    } : {
+      transitionProperty: 'min-height, max-height',
+      minHeight: '0',
+      maxHeight: '50%'
+    };
+  });
+  return {
+    rootInlineStyles
+  };
+}
+
+const BottomSheet = [
+// Position
+'fixed', 'left-none', 'right-none', 'bottom-none',
+// Layout
+'layout-column',
+// Shape
+'rounded-t-lg',
+// Elevation
+'shadow-contextual', 'dark:shadow-contextual-dark',
+// Typography
+'typography-body-2-regular',
+// Theme
+'theme-background-base', 'dark:theme-background-base-dark', 'theme-foreground-default', 'dark:theme-foreground-default-dark'];
+const BottomSheetVariants = {
+  [BottomSheetVariant.Basic]: [],
+  [BottomSheetVariant.Advanced]: [
+  // Box
+  'max-h-[50%]',
+  // Transition
+  'transition-[min-height]', 'transition-[max-height]']
+};
+const BottomSheetHandle = [
+// Layout
+'layout-row justify-center',
+// Interactivity
+'interactivity-drag',
+// Box
+'after:w-2xl', 'after:h-xs',
+// Spacing
+'px-sm', 'py-sm',
+// Shape
+'after:rounded-full',
+// Theme
+'after:bg-outline', 'after:dark:bg-outline'];
+const BottomSheetHeader = [
+// Layout (empty)
+'empty:hidden',
+// Spacing
+'px-lg', 'py-md',
+// Typography
+'typography-headline-3'];
+const BottomSheetContent = [
+// Layout
+'layout-column', 'grow'];
+
+var script = defineComponent({
+  name: 'OrBottomSheet',
+  components: {
+    OrOverlay: __vue_component__$1
+  },
+  inheritAttrs: false,
+  props: {
+    isOpen: {
+      type: Boolean,
+      default: false
+    },
+    variant: {
+      type: String,
+      default: BottomSheetVariant.Advanced
+    }
+  },
+  emits: ['update:state', 'open', 'close'],
+  expose: ['root', 'state', 'open', 'close', 'toggle'],
+  setup(props, context) {
+    // Refs
+    const root = ref();
+    const content = ref();
+    // Props
+    const {
+      variant,
+      isOpen
+    } = toRefs$1(props);
+    // State
+    const {
+      state,
+      open,
+      close,
+      toggle
+    } = usePopoverState(isOpen, context.emit);
+    const fullscreen = ref(false);
+    // Styles
+    const rootStyles = computed(() => ['or-bottom-sheet-v3', ...BottomSheet, ...BottomSheetVariants[props.variant]]);
+    const handleStyles = computed(() => [...BottomSheetHandle]);
+    const headerStyles = computed(() => [...BottomSheetHeader]);
+    const contentStyles = computed(() => [...BottomSheetContent, fullscreen.value || variant.value === 'basic' ? 'overflow-y-auto' : 'overflow-hidden']);
+    // Effects
+    // #region Swipe
+    const {
+      rootInlineStyles
+    } = useBottomSheetSwipeState(root, content, fullscreen, variant, close);
+    // #endregion
+    watch(state, value => {
+      if (value === 'closed') {
+        fullscreen.value = false;
+      }
+    });
+    // #region Click Outside
+    onClickOutside(root, event => {
+      const path = event.composedPath();
+      if (!path.some(_ref => {
+        let {
+          classList
+        } = _ref;
+        return (classList === null || classList === void 0 ? void 0 : classList.contains('or-popover-v3')) || (classList === null || classList === void 0 ? void 0 : classList.contains('or-bottom-sheet-v3'));
+      })) {
+        close();
+      }
+    });
+    // #endregion
+    return {
+      root,
+      content,
+      rootStyles,
+      rootInlineStyles,
+      handleStyles,
+      headerStyles,
+      contentStyles,
+      state,
+      fullscreen,
+      open,
+      close,
+      toggle
+    };
+  }
+});
+
+/* script */
+const __vue_script__ = script;
+
+/* template */
+var __vue_render__ = function () {
+  var _vm = this;
+  var _h = _vm.$createElement;
+  var _c = _vm._self._c || _h;
+  return _vm.state === 'open' ? _c('OrOverlay', {
+    attrs: {
+      "fullscreen": _vm.fullscreen
+    }
+  }, [_c('div', _vm._b({
+    ref: "root",
+    class: _vm.rootStyles,
+    style: _vm.rootInlineStyles
+  }, 'div', _vm.$attrs, false), [_vm.variant === 'advanced' ? [_c('div', {
+    class: _vm.handleStyles
+  })] : _vm._e(), _vm._v(" "), _c('div', {
+    class: _vm.headerStyles
+  }, [_vm._t("header")], 2), _vm._v(" "), _c('div', {
+    ref: "content",
+    class: _vm.contentStyles
+  }, [_vm._t("default")], 2)], 2)]) : _vm._e();
+};
+var __vue_staticRenderFns__ = [];
+
+/* style */
+const __vue_inject_styles__ = undefined;
+/* scoped */
+const __vue_scope_id__ = undefined;
+/* module identifier */
+const __vue_module_identifier__ = undefined;
+/* functional template */
+const __vue_is_functional_template__ = false;
+/* style inject */
+
+/* style inject SSR */
+
+/* style inject shadow dom */
+
+const __vue_component__ = /*#__PURE__*/normalizeComponent({
+  render: __vue_render__,
+  staticRenderFns: __vue_staticRenderFns__
+}, __vue_inject_styles__, __vue_script__, __vue_scope_id__, __vue_is_functional_template__, __vue_module_identifier__, false, undefined, undefined, undefined);
+
+export { useElementBounding as $, getCS as A, getMaxZIndex as B, useVModel as C, _ListCache as D, _Map as E, _MapCache as F, _getNative as G, eq_1 as H, _baseGetTag as I, isObjectLike_1 as J, _root as K, _freeGlobal as L, isArray_1 as M, _overArg as N, isFunction_1 as O, _getPrototype as P, _toSource as Q, _Symbol as R, isEmpty as S, useElementSize as T, unrefElement as U, tryOnScopeDispose as V, useElevation as W, useScrollLock as X, useToggle as Y, __vue_component__ as Z, _baseToString as _, useToggle$1 as a, BottomSheetHandle as a$, get_1 as a0, useDraggable as a1, clamp as a2, commonjsGlobal as a3, getDefaultExportFromCjs as a4, useResizeObserver as a5, useDebounceFn as a6, watchDebounced as a7, _castPath as a8, _toKey as a9, PLACEMENT_TOP_END as aA, PLACEMENT_BOTTOM_START as aB, PLACEMENT_BOTTOM_END as aC, PLACEMENT_RIGHT_START as aD, PLACEMENT_RIGHT_END as aE, PLACEMENT_LEFT_START as aF, PLACEMENT_LEFT_END as aG, MutationObs as aH, removeNode as aI, isVisible$1 as aJ, selectAll as aK, select as aL, contains as aM, getById as aN, hasClass as aO, setAttr as aP, removeAttr as aQ, getAttr as aR, hasAttr as aS, getStyle as aT, offset as aU, position as aV, getAbbreviation as aW, isVisible as aX, useBottomSheetSwipeState as aY, BottomSheet as aZ, BottomSheetVariants as a_, _isKey as aa, _baseGet as ab, useFocus as ac, isEqualValue as ad, addClass as ae, removeClass as af, useOverflow as ag, createSharedComposable as ah, useEventBus as ai, noop as aj, BottomSheetVariant as ak, CODE_BACKSPACE as al, CODE_BREAK as am, CODE_DELETE as an, CODE_DOWN as ao, CODE_END as ap, CODE_ENTER as aq, CODE_ESC as ar, CODE_HOME as as, CODE_LEFT as at, CODE_PAGEDOWN as au, CODE_PAGEUP as av, CODE_RIGHT as aw, CODE_SPACE as ax, CODE_UP as ay, PLACEMENT_TOP_START as az, useIdAttribute as b, BottomSheetHeader as b0, BottomSheetContent as b1, useControlAttributes as c, useElementHover as d, useValidationAttributes as e, flattenDeep as f, useTheme as g, reflow as h, isEmptyValue as i, removeStyle as j, cancelAF as k, getBCR as l, resolveUnref as m, useMagicKeys as n, onClickOutside as o, pxToRem as p, useActiveElement as q, requestAF as r, setStyle as s, usePopoverState as t, useProxyModelValue as u, useResponsive as v, whenever as w, isObject_1 as x, isSymbol_1 as y, toString_1 as z };