deploy: ebd4cc0010

node_modules/@vueuse/integrations/useAsyncValidator.iife.js

@@ -1,189 +0,0 @@
-var VueDemi = (function (VueDemi, Vue, VueCompositionAPI) {
-  if (VueDemi.install) {
-    return VueDemi
-  }
-  if (!Vue) {
-    console.error('[vue-demi] no Vue instance found, please be sure to import `vue` before `vue-demi`.')
-    return VueDemi
-  }
-
-  // Vue 2.7
-  if (Vue.version.slice(0, 4) === '2.7.') {
-    for (var key in Vue) {
-      VueDemi[key] = Vue[key]
-    }
-    VueDemi.isVue2 = true
-    VueDemi.isVue3 = false
-    VueDemi.install = function () {}
-    VueDemi.Vue = Vue
-    VueDemi.Vue2 = Vue
-    VueDemi.version = Vue.version
-    VueDemi.warn = Vue.util.warn
-    VueDemi.hasInjectionContext = () => !!VueDemi.getCurrentInstance()
-    function createApp(rootComponent, rootProps) {
-      var vm
-      var provide = {}
-      var app = {
-        config: Vue.config,
-        use: Vue.use.bind(Vue),
-        mixin: Vue.mixin.bind(Vue),
-        component: Vue.component.bind(Vue),
-        provide: function (key, value) {
-          provide[key] = value
-          return this
-        },
-        directive: function (name, dir) {
-          if (dir) {
-            Vue.directive(name, dir)
-            return app
-          } else {
-            return Vue.directive(name)
-          }
-        },
-        mount: function (el, hydrating) {
-          if (!vm) {
-            vm = new Vue(Object.assign({ propsData: rootProps }, rootComponent, { provide: Object.assign(provide, rootComponent.provide) }))
-            vm.$mount(el, hydrating)
-            return vm
-          } else {
-            return vm
-          }
-        },
-        unmount: function () {
-          if (vm) {
-            vm.$destroy()
-            vm = undefined
-          }
-        },
-      }
-      return app
-    }
-    VueDemi.createApp = createApp
-  }
-  // Vue 2.6.x
-  else if (Vue.version.slice(0, 2) === '2.') {
-    if (VueCompositionAPI) {
-      for (var key in VueCompositionAPI) {
-        VueDemi[key] = VueCompositionAPI[key]
-      }
-      VueDemi.isVue2 = true
-      VueDemi.isVue3 = false
-      VueDemi.install = function () {}
-      VueDemi.Vue = Vue
-      VueDemi.Vue2 = Vue
-      VueDemi.version = Vue.version
-      VueDemi.hasInjectionContext = () => !!VueDemi.getCurrentInstance()
-    } else {
-      console.error('[vue-demi] no VueCompositionAPI instance found, please be sure to import `@vue/composition-api` before `vue-demi`.')
-    }
-  }
-  // Vue 3
-  else if (Vue.version.slice(0, 2) === '3.') {
-    for (var key in Vue) {
-      VueDemi[key] = Vue[key]
-    }
-    VueDemi.isVue2 = false
-    VueDemi.isVue3 = true
-    VueDemi.install = function () {}
-    VueDemi.Vue = Vue
-    VueDemi.Vue2 = undefined
-    VueDemi.version = Vue.version
-    VueDemi.set = function (target, key, val) {
-      if (Array.isArray(target)) {
-        target.length = Math.max(target.length, key)
-        target.splice(key, 1, val)
-        return val
-      }
-      target[key] = val
-      return val
-    }
-    VueDemi.del = function (target, key) {
-      if (Array.isArray(target)) {
-        target.splice(key, 1)
-        return
-      }
-      delete target[key]
-    }
-  } else {
-    console.error('[vue-demi] Vue version ' + Vue.version + ' is unsupported.')
-  }
-  return VueDemi
-})(
-  (this.VueDemi = this.VueDemi || (typeof VueDemi !== 'undefined' ? VueDemi : {})),
-  this.Vue || (typeof Vue !== 'undefined' ? Vue : undefined),
-  this.VueCompositionAPI || (typeof VueCompositionAPI !== 'undefined' ? VueCompositionAPI : undefined)
-);
-;
-;(function (exports, shared, Schema, vueDemi) {
-  'use strict';
-
-  const AsyncValidatorSchema = Schema.default || Schema;
-  function useAsyncValidator(value, rules, options = {}) {
-    const {
-      validateOption = {},
-      immediate = true,
-      manual = false
-    } = options;
-    const valueRef = shared.toRef(value);
-    const errorInfo = vueDemi.shallowRef(null);
-    const isFinished = vueDemi.ref(true);
-    const pass = vueDemi.ref(!immediate || manual);
-    const errors = vueDemi.computed(() => {
-      var _a;
-      return ((_a = errorInfo.value) == null ? void 0 : _a.errors) || [];
-    });
-    const errorFields = vueDemi.computed(() => {
-      var _a;
-      return ((_a = errorInfo.value) == null ? void 0 : _a.fields) || {};
-    });
-    const validator = vueDemi.computed(() => new AsyncValidatorSchema(shared.toValue(rules)));
-    const execute = async () => {
-      isFinished.value = false;
-      pass.value = false;
-      try {
-        await validator.value.validate(valueRef.value, validateOption);
-        pass.value = true;
-        errorInfo.value = null;
-      } catch (err) {
-        errorInfo.value = err;
-      } finally {
-        isFinished.value = true;
-      }
-      return {
-        pass: pass.value,
-        errorInfo: errorInfo.value,
-        errors: errors.value,
-        errorFields: errorFields.value
-      };
-    };
-    if (!manual) {
-      vueDemi.watch(
-        [valueRef, validator],
-        () => execute(),
-        { immediate, deep: true }
-      );
-    }
-    const shell = {
-      isFinished,
-      pass,
-      errors,
-      errorInfo,
-      errorFields,
-      execute
-    };
-    function waitUntilFinished() {
-      return new Promise((resolve, reject) => {
-        shared.until(isFinished).toBe(true).then(() => resolve(shell)).catch((error) => reject(error));
-      });
-    }
-    return {
-      ...shell,
-      then(onFulfilled, onRejected) {
-        return waitUntilFinished().then(onFulfilled, onRejected);
-      }
-    };
-  }
-
-  exports.useAsyncValidator = useAsyncValidator;
-
-})(this.VueUse = this.VueUse || {}, VueUse, AsyncValidator, VueDemi);