form_create_for_flow/dist/formCreate.common.js

一个基于Vue3.0 + TS 的表单设计器

module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = "fb15");
/******/ })
/************************************************************************/
/******/ ({

/***/ 0:
/***/ (function(module, exports) {

/* (ignored) */

/***/ }),

/***/ "00b4":
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// TODO: Remove from `core-js@4` since it's moved to entry points
__webpack_require__("ac1f");
var $ = __webpack_require__("23e7");
var global = __webpack_require__("da84");
var call = __webpack_require__("c65b");
var uncurryThis = __webpack_require__("e330");
var isCallable = __webpack_require__("1626");
var isObject = __webpack_require__("861d");

var DELEGATES_TO_EXEC = function () {
  var execCalled = false;
  var re = /[ac]/;
  re.exec = function () {
    execCalled = true;
    return /./.exec.apply(this, arguments);
  };
  return re.test('abc') === true && execCalled;
}();

var Error = global.Error;
var un$Test = uncurryThis(/./.test);

// `RegExp.prototype.test` method
// https://tc39.es/ecma262/#sec-regexp.prototype.test
$({ target: 'RegExp', proto: true, forced: !DELEGATES_TO_EXEC }, {
  test: function (str) {
    var exec = this.exec;
    if (!isCallable(exec)) return un$Test(this, str);
    var result = call(exec, this, str);
    if (result !== null && !isObject(result)) {
      throw new Error('RegExp exec method returned something other than an Object or null');
    }
    return !!result;
  }
});


/***/ }),

/***/ "00ee":
/***/ (function(module, exports, __webpack_require__) {

var wellKnownSymbol = __webpack_require__("b622");

var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var test = {};

test[TO_STRING_TAG] = 'z';

module.exports = String(test) === '[object z]';


/***/ }),

/***/ "01b3":
/***/ (function(module, exports, __webpack_require__) {

"use strict";


__webpack_require__("7a82");

Object.defineProperty(exports, '__esModule', {
  value: true
});

var vue = __webpack_require__("8bbf");

var pluginVue_exportHelper = __webpack_require__("0c99");

var _sfc_main = vue.defineComponent({
  name: "Eleme"
});

var _hoisted_1 = {
  viewBox: "0 0 1024 1024",
  xmlns: "http://www.w3.org/2000/svg"
};

var _hoisted_2 = /* @__PURE__ */vue.createElementVNode("path", {
  fill: "currentColor",
  d: "M300.032 188.8c174.72-113.28 408-63.36 522.24 109.44 5.76 10.56 11.52 20.16 17.28 30.72v.96a22.4 22.4 0 0 1-7.68 26.88l-352.32 228.48c-9.6 6.72-22.08 3.84-28.8-5.76l-18.24-27.84a54.336 54.336 0 0 1 16.32-74.88l225.6-146.88c9.6-6.72 12.48-19.2 5.76-28.8-.96-1.92-1.92-3.84-3.84-4.8a267.84 267.84 0 0 0-315.84-17.28c-123.84 81.6-159.36 247.68-78.72 371.52a268.096 268.096 0 0 0 370.56 78.72 54.336 54.336 0 0 1 74.88 16.32l17.28 26.88c5.76 9.6 3.84 21.12-4.8 27.84-8.64 7.68-18.24 14.4-28.8 21.12a377.92 377.92 0 0 1-522.24-110.4c-113.28-174.72-63.36-408 111.36-522.24zm526.08 305.28a22.336 22.336 0 0 1 28.8 5.76l23.04 35.52a63.232 63.232 0 0 1-18.24 87.36l-35.52 23.04c-9.6 6.72-22.08 3.84-28.8-5.76l-46.08-71.04c-6.72-9.6-3.84-22.08 5.76-28.8l71.04-46.08z"
}, null, -1);

var _hoisted_3 = [_hoisted_2];

function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
  return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1, _hoisted_3);
}

var eleme = /* @__PURE__ */pluginVue_exportHelper["default"](_sfc_main, [["render", _sfc_render]]);
exports["default"] = eleme;

/***/ }),

/***/ "01b4":
/***/ (function(module, exports) {

var Queue = function () {
  this.head = null;
  this.tail = null;
};

Queue.prototype = {
  add: function (item) {
    var entry = { item: item, next: null };
    if (this.head) this.tail.next = entry;
    else this.head = entry;
    this.tail = entry;
  },
  get: function () {
    var entry = this.head;
    if (entry) {
      this.head = entry.next;
      if (this.tail === entry) this.tail = null;
      return entry.item;
    }
  }
};

module.exports = Queue;


/***/ }),

/***/ "026d":
/***/ (function(module, exports, __webpack_require__) {

"use strict";


__webpack_require__("7a82");

Object.defineProperty(exports, '__esModule', {
  value: true
});

var vue = __webpack_require__("8bbf");

var pluginVue_exportHelper = __webpack_require__("0c99");

var _sfc_main = vue.defineComponent({
  name: "Message"
});

var _hoisted_1 = {
  viewBox: "0 0 1024 1024",
  xmlns: "http://www.w3.org/2000/svg"
};

var _hoisted_2 = /* @__PURE__ */vue.createElementVNode("path", {
  fill: "currentColor",
  d: "M128 224v512a64 64 0 0 0 64 64h640a64 64 0 0 0 64-64V224H128zm0-64h768a64 64 0 0 1 64 64v512a128 128 0 0 1-128 128H192A128 128 0 0 1 64 736V224a64 64 0 0 1 64-64z"
}, null, -1);

var _hoisted_3 = /* @__PURE__ */vue.createElementVNode("path", {
  fill: "currentColor",
  d: "M904 224 656.512 506.88a192 192 0 0 1-289.024 0L120 224h784zm-698.944 0 210.56 240.704a128 128 0 0 0 192.704 0L818.944 224H205.056z"
}, null, -1);

var _hoisted_4 = [_hoisted_2, _hoisted_3];

function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
  return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1, _hoisted_4);
}

var message = /* @__PURE__ */pluginVue_exportHelper["default"](_sfc_main, [["render", _sfc_render]]);
exports["default"] = message;

/***/ }),

/***/ "02e2":
/***/ (function(module, __webpack_exports__, __webpack_require__) {

"use strict";
__webpack_require__.r(__webpack_exports__);
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__onlyVue3", function() { return __onlyVue3; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "and", function() { return logicAnd; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "assert", function() { return assert; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "autoResetRef", function() { return refAutoReset; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "bypassFilter", function() { return bypassFilter; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clamp", function() { return clamp; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "computedEager", function() { return computedEager; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "computedWithControl", function() { return computedWithControl; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "containsProp", function() { return containsProp; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "controlledComputed", function() { return computedWithControl; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "controlledRef", function() { return controlledRef; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createEventHook", function() { return createEventHook; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createFilterWrapper", function() { return createFilterWrapper; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createGlobalState", function() { return createGlobalState; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createInjectionState", function() { return createInjectionState; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createReactiveFn", function() { return reactify; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createSharedComposable", function() { return createSharedComposable; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "createSingletonPromise", function() { return createSingletonPromise; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "debounceFilter", function() { return debounceFilter; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "debouncedRef", function() { return refDebounced; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "debouncedWatch", function() { return watchDebounced; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "directiveHooks", function() { return directiveHooks; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "eagerComputed", function() { return computedEager; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "extendRef", function() { return extendRef; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "formatDate", function() { return formatDate; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "get", function() { return get; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "identity", function() { return identity; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ignorableWatch", function() { return watchIgnorable; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "increaseWithUnit", function() { return increaseWithUnit; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "invoke", function() { return invoke; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isBoolean", function() { return isBoolean; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isClient", function() { return isClient; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isDef", function() { return isDef; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isDefined", function() { return isDefined; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isFunction", function() { return isFunction; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isIOS", function() { return isIOS; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isNumber", function() { return isNumber; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isObject", function() { return isObject; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isString", function() { return isString; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isWindow", function() { return isWindow; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "logicAnd", function() { return logicAnd; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "logicNot", function() { return logicNot; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "logicOr", function() { return logicOr; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "makeDestructurable", function() { return makeDestructurable; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "noop", function() { return noop; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "normalizeDate", function() { return normalizeDate; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "not", function() { return logicNot; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "now", function() { return now; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "objectPick", function() { return objectPick; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "or", function() { return logicOr; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "pausableFilter", function() { return pausableFilter; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "pausableWatch", function() { return watchPausable; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "promiseTimeout", function() { return promiseTimeout; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rand", function() { return rand; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "reactify", function() { return reactify; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "reactifyObject", function() { return reactifyObject; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "reactiveComputed", function() { return reactiveComputed; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "reactiveOmit", function() { return reactiveOmit; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "reactivePick", function() { return reactivePick; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "refAutoReset", function() { return refAutoReset; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "refDebounced", function() { return refDebounced; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "refDefault", function() { return refDefault; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "refThrottled", function() { return refThrottled; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "refWithControl", function() { return refWithControl; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "resolveRef", function() { return resolveRef; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "resolveUnref", function() { return resolveUnref; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "set", function() { return set; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "syncRef", function() { return syncRef; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "syncRefs", function() { return syncRefs; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "throttleFilter", function() { return throttleFilter; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "throttledRef", function() { return refThrottled; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "throttledWatch", function() { return watchThrottled; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "timestamp", function() { return timestamp; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toReactive", function() { return toReactive; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toRefs", function() { return toRefs; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tryOnBeforeMount", function() { return tryOnBeforeMount; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tryOnBeforeUnmount", function() { return tryOnBeforeUnmount; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tryOnMounted", function() { return tryOnMounted; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tryOnScopeDispose", function() { return tryOnScopeDispose; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "tryOnUnmounted", function() { return tryOnUnmounted; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "until", function() { return until; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "useCounter", function() { return useCounter; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "useDateFormat", function() { return useDateFormat; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "useDebounce", function() { return refDebounced; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "useDebounceFn", function() { return useDebounceFn; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "useInterval", function() { return useInterval; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "useIntervalFn", function() { return useIntervalFn; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "useLastChanged", function() { return useLastChanged; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "useThrottle", function() { return refThrottled; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "useThrottleFn", function() { return useThrottleFn; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "useTimeout", function() { return useTimeout; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "useTimeoutFn", function() { return useTimeoutFn; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "useToggle", function() { return useToggle; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "watchArray", function() { return watchArray; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "watchAtMost", function() { return watchAtMost; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "watchDebounced", function() { return watchDebounced; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "watchIgnorable", function() { return watchIgnorable; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "watchOnce", function() { return watchOnce; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "watchPausable", function() { return watchPausable; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "watchThrottled", function() { return watchThrottled; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "watchTriggerable", function() { return watchTriggerable; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "watchWithFilter", function() { return watchWithFilter; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "whenever", function() { return whenever; });
/* harmony import */ var vue_demi__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("ca45");
/* harmony import */ var vue_demi__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(vue_demi__WEBPACK_IMPORTED_MODULE_0__);


var __defProp$9 = Object.defineProperty;
var __defProps$6 = Object.defineProperties;
var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
var __hasOwnProp$b = Object.prototype.hasOwnProperty;
var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$9 = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp$b.call(b, prop))
      __defNormalProp$9(a, prop, b[prop]);
  if (__getOwnPropSymbols$b)
    for (var prop of __getOwnPropSymbols$b(b)) {
      if (__propIsEnum$b.call(b, prop))
        __defNormalProp$9(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
function computedEager(fn, options) {
  var _a;
  const result = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["shallowRef"])();
  Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["watchEffect"])(() => {
    result.value = fn();
  }, __spreadProps$6(__spreadValues$9({}, options), {
    flush: (_a = options == null ? void 0 : options.flush) != null ? _a : "sync"
  }));
  return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["readonly"])(result);
}

var _a;
const isClient = typeof window !== "undefined";
const isDef = (val) => typeof val !== "undefined";
const assert = (condition, ...infos) => {
  if (!condition)
    console.warn(...infos);
};
const toString = Object.prototype.toString;
const isBoolean = (val) => typeof val === "boolean";
const isFunction = (val) => typeof val === "function";
const isNumber = (val) => typeof val === "number";
const isString = (val) => typeof val === "string";
const isObject = (val) => toString.call(val) === "[object Object]";
const isWindow = (val) => typeof window !== "undefined" && toString.call(val) === "[object Window]";
const now = () => Date.now();
const timestamp = () => +Date.now();
const clamp = (n, min, max) => Math.min(max, Math.max(min, n));
const noop = () => {
};
const rand = (min, max) => {
  min = Math.ceil(min);
  max = Math.floor(max);
  return Math.floor(Math.random() * (max - min + 1)) + min;
};
const isIOS = isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && /iP(ad|hone|od)/.test(window.navigator.userAgent);

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 = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(ms);
    const maxDuration = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(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 throttleFilter(ms, trailing = true, leading = true) {
  let lastExec = 0;
  let timer;
  let isLeading = true;
  const clear = () => {
    if (timer) {
      clearTimeout(timer);
      timer = void 0;
    }
  };
  const filter = (invoke) => {
    const duration = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(ms);
    const elapsed = Date.now() - lastExec;
    clear();
    if (duration <= 0) {
      lastExec = Date.now();
      return invoke();
    }
    if (elapsed > duration && (leading || !isLeading)) {
      lastExec = Date.now();
      invoke();
    } else if (trailing) {
      timer = setTimeout(() => {
        lastExec = Date.now();
        isLeading = true;
        clear();
        invoke();
      }, duration);
    }
    if (!leading && !timer)
      timer = setTimeout(() => isLeading = true, duration);
    isLeading = false;
  };
  return filter;
}
function pausableFilter(extendFilter = bypassFilter) {
  const isActive = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["ref"])(true);
  function pause() {
    isActive.value = false;
  }
  function resume() {
    isActive.value = true;
  }
  const eventFilter = (...args) => {
    if (isActive.value)
      extendFilter(...args);
  };
  return { isActive, pause, resume, eventFilter };
}

function __onlyVue3(name = "this function") {
  if (vue_demi__WEBPACK_IMPORTED_MODULE_0__["isVue3"])
    return;
  throw new Error(`[VueUse] ${name} is only works on Vue 3.`);
}
const directiveHooks = {
  mounted: vue_demi__WEBPACK_IMPORTED_MODULE_0__["isVue3"] ? "mounted" : "inserted",
  updated: vue_demi__WEBPACK_IMPORTED_MODULE_0__["isVue3"] ? "updated" : "componentUpdated",
  unmounted: vue_demi__WEBPACK_IMPORTED_MODULE_0__["isVue3"] ? "unmounted" : "unbind"
};

function promiseTimeout(ms, throwOnTimeout = false, reason = "Timeout") {
  return new Promise((resolve, reject) => {
    if (throwOnTimeout)
      setTimeout(() => reject(reason), ms);
    else
      setTimeout(resolve, ms);
  });
}
function identity(arg) {
  return arg;
}
function createSingletonPromise(fn) {
  let _promise;
  function wrapper() {
    if (!_promise)
      _promise = fn();
    return _promise;
  }
  wrapper.reset = async () => {
    const _prev = _promise;
    _promise = void 0;
    if (_prev)
      await _prev;
  };
  return wrapper;
}
function invoke(fn) {
  return fn();
}
function containsProp(obj, ...props) {
  return props.some((k) => k in obj);
}
function increaseWithUnit(target, delta) {
  var _a;
  if (typeof target === "number")
    return target + delta;
  const value = ((_a = target.match(/^-?[0-9]+\.?[0-9]*/)) == null ? void 0 : _a[0]) || "";
  const unit = target.slice(value.length);
  const result = parseFloat(value) + delta;
  if (Number.isNaN(result))
    return target;
  return result + unit;
}
function objectPick(obj, keys, omitUndefined = false) {
  return keys.reduce((n, k) => {
    if (k in obj) {
      if (!omitUndefined || obj[k] !== void 0)
        n[k] = obj[k];
    }
    return n;
  }, {});
}

function computedWithControl(source, fn) {
  let v = void 0;
  let track;
  let trigger;
  const dirty = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["ref"])(true);
  const update = () => {
    dirty.value = true;
    trigger();
  };
  Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["watch"])(source, update, { flush: "sync" });
  const get = isFunction(fn) ? fn : fn.get;
  const set = isFunction(fn) ? void 0 : fn.set;
  const result = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["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 createEventHook() {
  const fns = [];
  const off = (fn) => {
    const index = fns.indexOf(fn);
    if (index !== -1)
      fns.splice(index, 1);
  };
  const on = (fn) => {
    fns.push(fn);
    return {
      off: () => off(fn)
    };
  };
  const trigger = (param) => {
    fns.forEach((fn) => fn(param));
  };
  return {
    on,
    off,
    trigger
  };
}

function createGlobalState(stateFactory) {
  let initialized = false;
  let state;
  const scope = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["effectScope"])(true);
  return () => {
    if (!initialized) {
      state = scope.run(stateFactory);
      initialized = true;
    }
    return state;
  };
}

function createInjectionState(composable) {
  const key = Symbol("InjectionState");
  const useProvidingState = (...args) => {
    Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["provide"])(key, composable(...args));
  };
  const useInjectedState = () => Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["inject"])(key);
  return [useProvidingState, useInjectedState];
}

function tryOnScopeDispose(fn) {
  if (Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["getCurrentScope"])()) {
    Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["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 = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["effectScope"])(true);
      state = scope.run(() => composable(...args));
    }
    tryOnScopeDispose(dispose);
    return state;
  };
}

function extendRef(ref, extend, { enumerable = false, unwrap = true } = {}) {
  __onlyVue3();
  for (const [key, value] of Object.entries(extend)) {
    if (key === "value")
      continue;
    if (Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["isRef"])(value) && unwrap) {
      Object.defineProperty(ref, key, {
        get() {
          return value.value;
        },
        set(v) {
          value.value = v;
        },
        enumerable
      });
    } else {
      Object.defineProperty(ref, key, { value, enumerable });
    }
  }
  return ref;
}

function get(obj, key) {
  if (key == null)
    return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(obj);
  return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(obj)[key];
}

function isDefined(v) {
  return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(v) != null;
}

function logicAnd(...args) {
  return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["computed"])(() => args.every((i) => Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(i)));
}

function logicNot(v) {
  return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["computed"])(() => !Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(v));
}

function logicOr(...args) {
  return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["computed"])(() => args.some((i) => Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(i)));
}

var __defProp$8 = Object.defineProperty;
var __getOwnPropSymbols$a = Object.getOwnPropertySymbols;
var __hasOwnProp$a = Object.prototype.hasOwnProperty;
var __propIsEnum$a = Object.prototype.propertyIsEnumerable;
var __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues$8 = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp$a.call(b, prop))
      __defNormalProp$8(a, prop, b[prop]);
  if (__getOwnPropSymbols$a)
    for (var prop of __getOwnPropSymbols$a(b)) {
      if (__propIsEnum$a.call(b, prop))
        __defNormalProp$8(a, prop, b[prop]);
    }
  return a;
};
function makeDestructurable(obj, arr) {
  if (typeof Symbol !== "undefined") {
    const clone = __spreadValues$8({}, obj);
    Object.defineProperty(clone, Symbol.iterator, {
      enumerable: false,
      value() {
        let index = 0;
        return {
          next: () => ({
            value: arr[index++],
            done: index > arr.length
          })
        };
      }
    });
    return clone;
  } else {
    return Object.assign([...arr], obj);
  }
}

function reactify(fn) {
  return function(...args) {
    return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["computed"])(() => fn.apply(this, args.map((i) => Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(i))));
  };
}

function reactifyObject(obj, optionsOrKeys = {}) {
  let keys = [];
  if (Array.isArray(optionsOrKeys)) {
    keys = optionsOrKeys;
  } else {
    const { includeOwnProperties = true } = optionsOrKeys;
    keys.push(...Object.keys(obj));
    if (includeOwnProperties)
      keys.push(...Object.getOwnPropertyNames(obj));
  }
  return Object.fromEntries(keys.map((key) => {
    const value = obj[key];
    return [
      key,
      typeof value === "function" ? reactify(value.bind(obj)) : value
    ];
  }));
}

function toReactive(objectRef) {
  if (!Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["isRef"])(objectRef))
    return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["reactive"])(objectRef);
  const proxy = new Proxy({}, {
    get(_, p, receiver) {
      return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(Reflect.get(objectRef.value, p, receiver));
    },
    set(_, p, value) {
      if (Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["isRef"])(objectRef.value[p]) && !Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["isRef"])(value))
        objectRef.value[p].value = value;
      else
        objectRef.value[p] = value;
      return true;
    },
    deleteProperty(_, p) {
      return Reflect.deleteProperty(objectRef.value, p);
    },
    has(_, p) {
      return Reflect.has(objectRef.value, p);
    },
    ownKeys() {
      return Object.keys(objectRef.value);
    },
    getOwnPropertyDescriptor() {
      return {
        enumerable: true,
        configurable: true
      };
    }
  });
  return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["reactive"])(proxy);
}

function reactiveComputed(fn) {
  return toReactive(Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["computed"])(fn));
}

function reactiveOmit(obj, ...keys) {
  const flatKeys = keys.flat();
  return reactiveComputed(() => Object.fromEntries(Object.entries(Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["toRefs"])(obj)).filter((e) => !flatKeys.includes(e[0]))));
}

function reactivePick(obj, ...keys) {
  const flatKeys = keys.flat();
  return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["reactive"])(Object.fromEntries(flatKeys.map((k) => [k, Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["toRef"])(obj, k)])));
}

function refAutoReset(defaultValue, afterMs = 1e4) {
  return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["customRef"])((track, trigger) => {
    let value = defaultValue;
    let timer;
    const resetAfter = () => setTimeout(() => {
      value = defaultValue;
      trigger();
    }, Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(afterMs));
    tryOnScopeDispose(() => {
      clearTimeout(timer);
    });
    return {
      get() {
        track();
        return value;
      },
      set(newValue) {
        value = newValue;
        trigger();
        clearTimeout(timer);
        timer = resetAfter();
      }
    };
  });
}

function useDebounceFn(fn, ms = 200, options = {}) {
  return createFilterWrapper(debounceFilter(ms, options), fn);
}

function refDebounced(value, ms = 200, options = {}) {
  if (ms <= 0)
    return value;
  const debounced = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["ref"])(value.value);
  const updater = useDebounceFn(() => {
    debounced.value = value.value;
  }, ms, options);
  Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["watch"])(value, () => updater());
  return debounced;
}

function refDefault(source, defaultValue) {
  return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["computed"])({
    get() {
      var _a;
      return (_a = source.value) != null ? _a : defaultValue;
    },
    set(value) {
      source.value = value;
    }
  });
}

function useThrottleFn(fn, ms = 200, trailing = true, leading = true) {
  return createFilterWrapper(throttleFilter(ms, trailing, leading), fn);
}

function refThrottled(value, delay = 200, trailing = true, leading = true) {
  if (delay <= 0)
    return value;
  const throttled = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["ref"])(value.value);
  const updater = useThrottleFn(() => {
    throttled.value = value.value;
  }, delay, trailing, leading);
  Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["watch"])(value, () => updater());
  return throttled;
}

function refWithControl(initial, options = {}) {
  let source = initial;
  let track;
  let trigger;
  const ref = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["customRef"])((_track, _trigger) => {
    track = _track;
    trigger = _trigger;
    return {
      get() {
        return get();
      },
      set(v) {
        set(v);
      }
    };
  });
  function get(tracking = true) {
    if (tracking)
      track();
    return source;
  }
  function set(value, triggering = true) {
    var _a, _b;
    if (value === source)
      return;
    const old = source;
    if (((_a = options.onBeforeChange) == null ? void 0 : _a.call(options, value, old)) === false)
      return;
    source = value;
    (_b = options.onChanged) == null ? void 0 : _b.call(options, value, old);
    if (triggering)
      trigger();
  }
  const untrackedGet = () => get(false);
  const silentSet = (v) => set(v, false);
  const peek = () => get(false);
  const lay = (v) => set(v, false);
  return extendRef(ref, {
    get,
    set,
    untrackedGet,
    silentSet,
    peek,
    lay
  }, { enumerable: true });
}
const controlledRef = refWithControl;

function resolveRef(r) {
  return typeof r === "function" ? Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["computed"])(r) : Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["ref"])(r);
}

function resolveUnref(r) {
  return typeof r === "function" ? r() : Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(r);
}

function set(...args) {
  if (args.length === 2) {
    const [ref, value] = args;
    ref.value = value;
  }
  if (args.length === 3) {
    if (vue_demi__WEBPACK_IMPORTED_MODULE_0__["isVue2"]) {
      Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["set"])(...args);
    } else {
      const [target, key, value] = args;
      target[key] = value;
    }
  }
}

function syncRef(left, right, options = {}) {
  const {
    flush = "sync",
    deep = false,
    immediate = true,
    direction = "both"
  } = options;
  let stop1, stop2;
  if (direction === "both" || direction === "ltr") {
    stop1 = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["watch"])(left, (newValue) => right.value = newValue, { flush, deep, immediate });
  }
  if (direction === "both" || direction === "rtl") {
    stop2 = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["watch"])(right, (newValue) => left.value = newValue, { flush, deep, immediate });
  }
  return () => {
    stop1 == null ? void 0 : stop1();
    stop2 == null ? void 0 : stop2();
  };
}

function syncRefs(source, targets, options = {}) {
  const {
    flush = "sync",
    deep = false,
    immediate = true
  } = options;
  if (!Array.isArray(targets))
    targets = [targets];
  return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["watch"])(source, (newValue) => targets.forEach((target) => target.value = newValue), { flush, deep, immediate });
}

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 (!Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["isRef"])(objectRef))
    return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["toRefs"])(objectRef);
  const result = Array.isArray(objectRef.value) ? new Array(objectRef.value.length) : {};
  for (const key in objectRef.value) {
    result[key] = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["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 tryOnBeforeMount(fn, sync = true) {
  if (Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["getCurrentInstance"])())
    Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["onBeforeMount"])(fn);
  else if (sync)
    fn();
  else
    Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["nextTick"])(fn);
}

function tryOnBeforeUnmount(fn) {
  if (Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["getCurrentInstance"])())
    Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["onBeforeUnmount"])(fn);
}

function tryOnMounted(fn, sync = true) {
  if (Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["getCurrentInstance"])())
    Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["onMounted"])(fn);
  else if (sync)
    fn();
  else
    Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["nextTick"])(fn);
}

function tryOnUnmounted(fn) {
  if (Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["getCurrentInstance"])())
    Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["onUnmounted"])(fn);
}

function until(r) {
  let isNot = false;
  function toMatch(condition, { flush = "sync", deep = false, timeout, throwOnTimeout } = {}) {
    let stop = null;
    const watcher = new Promise((resolve) => {
      stop = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["watch"])(r, (v) => {
        if (condition(v) !== isNot) {
          stop == null ? void 0 : stop();
          resolve(v);
        }
      }, {
        flush,
        deep,
        immediate: true
      });
    });
    const promises = [watcher];
    if (timeout != null) {
      promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(r)).finally(() => stop == null ? void 0 : stop()));
    }
    return Promise.race(promises);
  }
  function toBe(value, options) {
    if (!Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["isRef"])(value))
      return toMatch((v) => v === value, options);
    const { flush = "sync", deep = false, timeout, throwOnTimeout } = options != null ? options : {};
    let stop = null;
    const watcher = new Promise((resolve) => {
      stop = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["watch"])([r, value], ([v1, v2]) => {
        if (isNot !== (v1 === v2)) {
          stop == null ? void 0 : stop();
          resolve(v1);
        }
      }, {
        flush,
        deep,
        immediate: true
      });
    });
    const promises = [watcher];
    if (timeout != null) {
      promises.push(promiseTimeout(timeout, throwOnTimeout).then(() => Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(r)).finally(() => {
        stop == null ? void 0 : stop();
        return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(r);
      }));
    }
    return Promise.race(promises);
  }
  function toBeTruthy(options) {
    return toMatch((v) => Boolean(v), options);
  }
  function toBeNull(options) {
    return toBe(null, options);
  }
  function toBeUndefined(options) {
    return toBe(void 0, options);
  }
  function toBeNaN(options) {
    return toMatch(Number.isNaN, options);
  }
  function toContains(value, options) {
    return toMatch((v) => {
      const array = Array.from(v);
      return array.includes(value) || array.includes(Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(value));
    }, options);
  }
  function changed(options) {
    return changedTimes(1, options);
  }
  function changedTimes(n = 1, options) {
    let count = -1;
    return toMatch(() => {
      count += 1;
      return count >= n;
    }, options);
  }
  if (Array.isArray(Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(r))) {
    const instance = {
      toMatch,
      toContains,
      changed,
      changedTimes,
      get not() {
        isNot = !isNot;
        return this;
      }
    };
    return instance;
  } else {
    const instance = {
      toMatch,
      toBe,
      toBeTruthy,
      toBeNull,
      toBeNaN,
      toBeUndefined,
      changed,
      changedTimes,
      get not() {
        isNot = !isNot;
        return this;
      }
    };
    return instance;
  }
}

function useCounter(initialValue = 0, options = {}) {
  const count = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["ref"])(initialValue);
  const {
    max = Infinity,
    min = -Infinity
  } = options;
  const inc = (delta = 1) => count.value = Math.min(max, count.value + delta);
  const dec = (delta = 1) => count.value = Math.max(min, count.value - delta);
  const get = () => count.value;
  const set = (val) => count.value = val;
  const reset = (val = initialValue) => {
    initialValue = val;
    return set(val);
  };
  return { count, inc, dec, get, set, reset };
}

const REGEX_PARSE = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/;
const REGEX_FORMAT = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g;
const formatDate = (date, formatStr) => {
  const years = date.getFullYear();
  const month = date.getMonth();
  const days = date.getDate();
  const hours = date.getHours();
  const minutes = date.getMinutes();
  const seconds = date.getSeconds();
  const milliseconds = date.getMilliseconds();
  const day = date.getDay();
  const matches = {
    YY: String(years).slice(-2),
    YYYY: years,
    M: month + 1,
    MM: `${month + 1}`.padStart(2, "0"),
    D: String(days),
    DD: `${days}`.padStart(2, "0"),
    H: String(hours),
    HH: `${hours}`.padStart(2, "0"),
    h: `${hours % 12 || 12}`.padStart(1, "0"),
    hh: `${hours % 12 || 12}`.padStart(2, "0"),
    m: String(minutes),
    mm: `${minutes}`.padStart(2, "0"),
    s: String(seconds),
    ss: `${seconds}`.padStart(2, "0"),
    SSS: `${milliseconds}`.padStart(3, "0"),
    d: day
  };
  return formatStr.replace(REGEX_FORMAT, (match, $1) => $1 || matches[match]);
};
const normalizeDate = (date) => {
  if (date === null)
    return new Date(NaN);
  if (date === void 0)
    return new Date();
  if (date instanceof Date)
    return new Date(date);
  if (typeof date === "string" && !/Z$/i.test(date)) {
    const d = date.match(REGEX_PARSE);
    if (d) {
      const m = d[2] - 1 || 0;
      const ms = (d[7] || "0").substring(0, 3);
      return new Date(d[1], m, d[3] || 1, d[4] || 0, d[5] || 0, d[6] || 0, ms);
    }
  }
  return new Date(date);
};
function useDateFormat(date, formatStr = "HH:mm:ss") {
  return Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["computed"])(() => formatDate(normalizeDate(Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(date)), Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(formatStr)));
}

function useIntervalFn(cb, interval = 1e3, options = {}) {
  const {
    immediate = true,
    immediateCallback = false
  } = options;
  let timer = null;
  const isActive = Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["ref"])(false);
  function clean() {
    if (timer) {
      clearInterval(timer);
      timer = null;
    }
  }
  function pause() {
    isActive.value = false;
    clean();
  }
  function resume() {
    if (Object(vue_demi__WEBPACK_IMPORTED_MODULE_0__["unref"])(interval) <= 0)
      return;
    isActive.value = true;
    if (immediateCallback)
      cb();
    clean();
    timer = setInterval(cb, Object(vue_demi__WEBPACK_IMPORTED_MO