appmax-client-vue3 5.0.3 → 5.0.4

package/dist/index-C9VJ4W4D.js

@@ -0,0 +1,961 @@
+import { an as getCurrentInstance, r as ref, M as onBeforeMount, A as watch, aA as isRef, z as reactive, f as onBeforeUnmount, e as computed, l as unref, af as inject, ah as provide, b0 as isReactive, b1 as isReadonly, L as nextTick } from "./main-BxSNdVUz.js";
+function ownKeys$1(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread2$1(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys$1(Object(source), true).forEach(function(key) {
+      _defineProperty$1(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys$1(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _defineProperty$1(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function unwrapObj(obj) {
+  let ignoreKeys = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  return Object.keys(obj).reduce((o, k) => {
+    if (ignoreKeys.includes(k)) return o;
+    o[k] = unref(obj[k]);
+    return o;
+  }, {});
+}
+function isFunction$1(val) {
+  return typeof val === "function";
+}
+function isProxy(value) {
+  return isReactive(value) || isReadonly(value);
+}
+function get(obj, stringPath, def) {
+  let current = obj;
+  const path = stringPath.split(".");
+  for (let i = 0; i < path.length; i++) {
+    if (!current[path[i]]) return def;
+    current = current[path[i]];
+  }
+  return current;
+}
+function gatherBooleanGroupProperties(group, nestedResults, property) {
+  return computed(() => {
+    return group.some((path) => {
+      return get(nestedResults, path, {
+        [property]: false
+      })[property];
+    });
+  });
+}
+function gatherArrayGroupProperties(group, nestedResults, property) {
+  return computed(() => {
+    return group.reduce((all, path) => {
+      const fetchedProperty = get(nestedResults, path, {
+        [property]: false
+      })[property] || [];
+      return all.concat(fetchedProperty);
+    }, []);
+  });
+}
+function callRule(rule, value, siblingState, instance) {
+  return rule.call(instance, unref(value), unref(siblingState), instance);
+}
+function normalizeValidatorResponse(result) {
+  return result.$valid !== void 0 ? !result.$valid : !result;
+}
+function createAsyncResult(rule, model, $pending, $dirty, _ref, $response, instance) {
+  let {
+    $lazy,
+    $rewardEarly
+  } = _ref;
+  let watchTargets = arguments.length > 7 && arguments[7] !== void 0 ? arguments[7] : [];
+  let siblingState = arguments.length > 8 ? arguments[8] : void 0;
+  let $lastInvalidState = arguments.length > 9 ? arguments[9] : void 0;
+  let $lastCommittedOn = arguments.length > 10 ? arguments[10] : void 0;
+  const $invalid = ref(!!$dirty.value);
+  const $pendingCounter = ref(0);
+  $pending.value = false;
+  const $unwatch = watch([model, $dirty].concat(watchTargets, $lastCommittedOn), () => {
+    if ($lazy && !$dirty.value || $rewardEarly && !$lastInvalidState.value && !$pending.value) {
+      return;
+    }
+    let ruleResult;
+    try {
+      ruleResult = callRule(rule, model, siblingState, instance);
+    } catch (err) {
+      ruleResult = Promise.reject(err);
+    }
+    $pendingCounter.value++;
+    $pending.value = !!$pendingCounter.value;
+    $invalid.value = false;
+    Promise.resolve(ruleResult).then((data) => {
+      $pendingCounter.value--;
+      $pending.value = !!$pendingCounter.value;
+      $response.value = data;
+      $invalid.value = normalizeValidatorResponse(data);
+    }).catch((error) => {
+      $pendingCounter.value--;
+      $pending.value = !!$pendingCounter.value;
+      $response.value = error;
+      $invalid.value = true;
+    });
+  }, {
+    immediate: true,
+    deep: typeof model === "object"
+  });
+  return {
+    $invalid,
+    $unwatch
+  };
+}
+function createSyncResult(rule, model, $dirty, _ref2, $response, instance, siblingState, $lastInvalidState) {
+  let {
+    $lazy,
+    $rewardEarly
+  } = _ref2;
+  const $unwatch = () => ({});
+  const $invalid = computed(() => {
+    if ($lazy && !$dirty.value || $rewardEarly && !$lastInvalidState.value) {
+      return false;
+    }
+    let returnValue = true;
+    try {
+      const result = callRule(rule, model, siblingState, instance);
+      $response.value = result;
+      returnValue = normalizeValidatorResponse(result);
+    } catch (err) {
+      $response.value = err;
+    }
+    return returnValue;
+  });
+  return {
+    $unwatch,
+    $invalid
+  };
+}
+function createValidatorResult(rule, model, $dirty, config, instance, validatorName, propertyKey, propertyPath, siblingState, $lastInvalidState, $lastCommittedOn) {
+  const $pending = ref(false);
+  const $params = rule.$params || {};
+  const $response = ref(null);
+  let $invalid;
+  let $unwatch;
+  if (rule.$async) {
+    ({
+      $invalid,
+      $unwatch
+    } = createAsyncResult(rule.$validator, model, $pending, $dirty, config, $response, instance, rule.$watchTargets, siblingState, $lastInvalidState, $lastCommittedOn));
+  } else {
+    ({
+      $invalid,
+      $unwatch
+    } = createSyncResult(rule.$validator, model, $dirty, config, $response, instance, siblingState, $lastInvalidState));
+  }
+  const message = rule.$message;
+  const $message = isFunction$1(message) ? computed(() => message(unwrapObj({
+    $pending,
+    $invalid,
+    $params: unwrapObj($params),
+    $model: model,
+    $response,
+    $validator: validatorName,
+    $propertyPath: propertyPath,
+    $property: propertyKey
+  }))) : message || "";
+  return {
+    $message,
+    $params,
+    $pending,
+    $invalid,
+    $response,
+    $unwatch
+  };
+}
+function sortValidations() {
+  let validationsRaw = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  const validations = unref(validationsRaw);
+  const validationKeys = Object.keys(validations);
+  const rules = {};
+  const nestedValidators = {};
+  const config = {};
+  let validationGroups = null;
+  validationKeys.forEach((key) => {
+    const v = validations[key];
+    switch (true) {
+      case isFunction$1(v.$validator):
+        rules[key] = v;
+        break;
+      case isFunction$1(v):
+        rules[key] = {
+          $validator: v
+        };
+        break;
+      case key === "$validationGroups":
+        validationGroups = v;
+        break;
+      case key.startsWith("$"):
+        config[key] = v;
+        break;
+      default:
+        nestedValidators[key] = v;
+    }
+  });
+  return {
+    rules,
+    nestedValidators,
+    config,
+    validationGroups
+  };
+}
+const ROOT_PATH = "__root";
+function createValidationResults(rules, model, key, resultsCache, path, config, instance, externalResults, siblingState) {
+  const ruleKeys = Object.keys(rules);
+  const cachedResult = resultsCache.get(path, rules);
+  const $dirty = ref(false);
+  const $lastInvalidState = ref(false);
+  const $lastCommittedOn = ref(0);
+  if (cachedResult) {
+    if (!cachedResult.$partial) return cachedResult;
+    cachedResult.$unwatch();
+    $dirty.value = cachedResult.$dirty.value;
+  }
+  const result = {
+    $dirty,
+    $path: path,
+    $touch: () => {
+      if (!$dirty.value) $dirty.value = true;
+    },
+    $reset: () => {
+      if ($dirty.value) $dirty.value = false;
+    },
+    $commit: () => {
+    }
+  };
+  if (!ruleKeys.length) {
+    cachedResult && resultsCache.set(path, rules, result);
+    return result;
+  }
+  ruleKeys.forEach((ruleKey) => {
+    result[ruleKey] = createValidatorResult(rules[ruleKey], model, result.$dirty, config, instance, ruleKey, key, path, siblingState, $lastInvalidState, $lastCommittedOn);
+  });
+  result.$externalResults = computed(() => {
+    if (!externalResults.value) return [];
+    return [].concat(externalResults.value).map((stringError, index) => ({
+      $propertyPath: path,
+      $property: key,
+      $validator: "$externalResults",
+      $uid: `${path}-externalResult-${index}`,
+      $message: stringError,
+      $params: {},
+      $response: null,
+      $pending: false
+    }));
+  });
+  result.$invalid = computed(() => {
+    const r = ruleKeys.some((ruleKey) => unref(result[ruleKey].$invalid));
+    $lastInvalidState.value = r;
+    return !!result.$externalResults.value.length || r;
+  });
+  result.$pending = computed(() => ruleKeys.some((ruleKey) => unref(result[ruleKey].$pending)));
+  result.$error = computed(() => result.$dirty.value ? result.$pending.value || result.$invalid.value : false);
+  result.$silentErrors = computed(() => ruleKeys.filter((ruleKey) => unref(result[ruleKey].$invalid)).map((ruleKey) => {
+    const res = result[ruleKey];
+    return reactive({
+      $propertyPath: path,
+      $property: key,
+      $validator: ruleKey,
+      $uid: `${path}-${ruleKey}`,
+      $message: res.$message,
+      $params: res.$params,
+      $response: res.$response,
+      $pending: res.$pending
+    });
+  }).concat(result.$externalResults.value));
+  result.$errors = computed(() => result.$dirty.value ? result.$silentErrors.value : []);
+  result.$unwatch = () => ruleKeys.forEach((ruleKey) => {
+    result[ruleKey].$unwatch();
+  });
+  result.$commit = () => {
+    $lastInvalidState.value = true;
+    $lastCommittedOn.value = Date.now();
+  };
+  resultsCache.set(path, rules, result);
+  return result;
+}
+function collectNestedValidationResults(validations, nestedState, path, resultsCache, config, instance, nestedExternalResults) {
+  const nestedValidationKeys = Object.keys(validations);
+  if (!nestedValidationKeys.length) return {};
+  return nestedValidationKeys.reduce((results, nestedKey) => {
+    results[nestedKey] = setValidations({
+      validations: validations[nestedKey],
+      state: nestedState,
+      key: nestedKey,
+      parentKey: path,
+      resultsCache,
+      globalConfig: config,
+      instance,
+      externalResults: nestedExternalResults
+    });
+    return results;
+  }, {});
+}
+function createMetaFields(results, nestedResults, childResults) {
+  const allResults = computed(() => [nestedResults, childResults].filter((res) => res).reduce((allRes, res) => {
+    return allRes.concat(Object.values(unref(res)));
+  }, []));
+  const $dirty = computed({
+    get() {
+      return results.$dirty.value || (allResults.value.length ? allResults.value.every((r) => r.$dirty) : false);
+    },
+    set(v) {
+      results.$dirty.value = v;
+    }
+  });
+  const $silentErrors = computed(() => {
+    const modelErrors = unref(results.$silentErrors) || [];
+    const nestedErrors = allResults.value.filter((result) => (unref(result).$silentErrors || []).length).reduce((errors, result) => {
+      return errors.concat(...result.$silentErrors);
+    }, []);
+    return modelErrors.concat(nestedErrors);
+  });
+  const $errors = computed(() => {
+    const modelErrors = unref(results.$errors) || [];
+    const nestedErrors = allResults.value.filter((result) => (unref(result).$errors || []).length).reduce((errors, result) => {
+      return errors.concat(...result.$errors);
+    }, []);
+    return modelErrors.concat(nestedErrors);
+  });
+  const $invalid = computed(() => allResults.value.some((r) => r.$invalid) || unref(results.$invalid) || false);
+  const $pending = computed(() => allResults.value.some((r) => unref(r.$pending)) || unref(results.$pending) || false);
+  const $anyDirty = computed(() => allResults.value.some((r) => r.$dirty) || allResults.value.some((r) => r.$anyDirty) || $dirty.value);
+  const $error = computed(() => $dirty.value ? $pending.value || $invalid.value : false);
+  const $touch = () => {
+    results.$touch();
+    allResults.value.forEach((result) => {
+      result.$touch();
+    });
+  };
+  const $commit = () => {
+    results.$commit();
+    allResults.value.forEach((result) => {
+      result.$commit();
+    });
+  };
+  const $reset = () => {
+    results.$reset();
+    allResults.value.forEach((result) => {
+      result.$reset();
+    });
+  };
+  if (allResults.value.length && allResults.value.every((nr) => nr.$dirty)) $touch();
+  return {
+    $dirty,
+    $errors,
+    $invalid,
+    $anyDirty,
+    $error,
+    $pending,
+    $touch,
+    $reset,
+    $silentErrors,
+    $commit
+  };
+}
+function setValidations(_ref) {
+  let {
+    validations,
+    state,
+    key,
+    parentKey,
+    childResults,
+    resultsCache,
+    globalConfig = {},
+    instance,
+    externalResults
+  } = _ref;
+  const path = parentKey ? `${parentKey}.${key}` : key;
+  const {
+    rules,
+    nestedValidators,
+    config,
+    validationGroups
+  } = sortValidations(validations);
+  const mergedConfig = _objectSpread2$1(_objectSpread2$1({}, globalConfig), config);
+  const nestedState = key ? computed(() => {
+    const s = unref(state);
+    return s ? unref(s[key]) : void 0;
+  }) : state;
+  const cachedExternalResults = _objectSpread2$1({}, unref(externalResults) || {});
+  const nestedExternalResults = computed(() => {
+    const results2 = unref(externalResults);
+    if (!key) return results2;
+    return results2 ? unref(results2[key]) : void 0;
+  });
+  const results = createValidationResults(rules, nestedState, key, resultsCache, path, mergedConfig, instance, nestedExternalResults, state);
+  const nestedResults = collectNestedValidationResults(nestedValidators, nestedState, path, resultsCache, mergedConfig, instance, nestedExternalResults);
+  const $validationGroups = {};
+  if (validationGroups) {
+    Object.entries(validationGroups).forEach((_ref2) => {
+      let [key2, group] = _ref2;
+      $validationGroups[key2] = {
+        $invalid: gatherBooleanGroupProperties(group, nestedResults, "$invalid"),
+        $error: gatherBooleanGroupProperties(group, nestedResults, "$error"),
+        $pending: gatherBooleanGroupProperties(group, nestedResults, "$pending"),
+        $errors: gatherArrayGroupProperties(group, nestedResults, "$errors"),
+        $silentErrors: gatherArrayGroupProperties(group, nestedResults, "$silentErrors")
+      };
+    });
+  }
+  const {
+    $dirty,
+    $errors,
+    $invalid,
+    $anyDirty,
+    $error,
+    $pending,
+    $touch,
+    $reset,
+    $silentErrors,
+    $commit
+  } = createMetaFields(results, nestedResults, childResults);
+  const $model = key ? computed({
+    get: () => unref(nestedState),
+    set: (val) => {
+      $dirty.value = true;
+      const s = unref(state);
+      const external = unref(externalResults);
+      if (external) {
+        external[key] = cachedExternalResults[key];
+      }
+      if (isRef(s[key])) {
+        s[key].value = val;
+      } else {
+        s[key] = val;
+      }
+    }
+  }) : null;
+  if (key && mergedConfig.$autoDirty) {
+    watch(nestedState, () => {
+      if (!$dirty.value) $touch();
+      const external = unref(externalResults);
+      if (external) {
+        external[key] = cachedExternalResults[key];
+      }
+    }, {
+      flush: "sync"
+    });
+  }
+  async function $validate() {
+    $touch();
+    if (mergedConfig.$rewardEarly) {
+      $commit();
+      await nextTick();
+    }
+    await nextTick();
+    return new Promise((resolve) => {
+      if (!$pending.value) return resolve(!$invalid.value);
+      const unwatch = watch($pending, () => {
+        resolve(!$invalid.value);
+        unwatch();
+      });
+    });
+  }
+  function $getResultsForChild(key2) {
+    return (childResults.value || {})[key2];
+  }
+  function $clearExternalResults() {
+    if (isRef(externalResults)) {
+      externalResults.value = cachedExternalResults;
+    } else {
+      if (Object.keys(cachedExternalResults).length === 0) {
+        Object.keys(externalResults).forEach((k) => {
+          delete externalResults[k];
+        });
+      } else {
+        Object.assign(externalResults, cachedExternalResults);
+      }
+    }
+  }
+  return reactive(_objectSpread2$1(_objectSpread2$1(_objectSpread2$1({}, results), {}, {
+    $model,
+    $dirty,
+    $error,
+    $errors,
+    $invalid,
+    $anyDirty,
+    $pending,
+    $touch,
+    $reset,
+    $path: path || ROOT_PATH,
+    $silentErrors,
+    $validate,
+    $commit
+  }, childResults && {
+    $getResultsForChild,
+    $clearExternalResults,
+    $validationGroups
+  }), nestedResults));
+}
+class ResultsStorage {
+  constructor() {
+    this.storage = /* @__PURE__ */ new Map();
+  }
+  set(path, rules, result) {
+    this.storage.set(path, {
+      rules,
+      result
+    });
+  }
+  checkRulesValidity(path, rules, storedRules) {
+    const storedRulesKeys = Object.keys(storedRules);
+    const newRulesKeys = Object.keys(rules);
+    if (newRulesKeys.length !== storedRulesKeys.length) return false;
+    const hasAllValidators = newRulesKeys.every((ruleKey) => storedRulesKeys.includes(ruleKey));
+    if (!hasAllValidators) return false;
+    return newRulesKeys.every((ruleKey) => {
+      if (!rules[ruleKey].$params) return true;
+      return Object.keys(rules[ruleKey].$params).every((paramKey) => {
+        return unref(storedRules[ruleKey].$params[paramKey]) === unref(rules[ruleKey].$params[paramKey]);
+      });
+    });
+  }
+  get(path, rules) {
+    const storedRuleResultPair = this.storage.get(path);
+    if (!storedRuleResultPair) return void 0;
+    const {
+      rules: storedRules,
+      result
+    } = storedRuleResultPair;
+    const isValidCache = this.checkRulesValidity(path, rules, storedRules);
+    const $unwatch = result.$unwatch ? result.$unwatch : () => ({});
+    if (!isValidCache) return {
+      $dirty: result.$dirty,
+      $partial: true,
+      $unwatch
+    };
+    return result;
+  }
+}
+const CollectFlag = {
+  COLLECT_ALL: true,
+  COLLECT_NONE: false
+};
+const VuelidateInjectChildResults = Symbol("vuelidate#injectChildResults");
+const VuelidateRemoveChildResults = Symbol("vuelidate#removeChildResults");
+function nestedValidations(_ref) {
+  let {
+    $scope,
+    instance
+  } = _ref;
+  const childResultsRaw = {};
+  const childResultsKeys = ref([]);
+  const childResults = computed(() => childResultsKeys.value.reduce((results, key) => {
+    results[key] = unref(childResultsRaw[key]);
+    return results;
+  }, {}));
+  function injectChildResultsIntoParent(results, _ref2) {
+    let {
+      $registerAs: key,
+      $scope: childScope,
+      $stopPropagation
+    } = _ref2;
+    if ($stopPropagation || $scope === CollectFlag.COLLECT_NONE || childScope === CollectFlag.COLLECT_NONE || $scope !== CollectFlag.COLLECT_ALL && $scope !== childScope) return;
+    childResultsRaw[key] = results;
+    childResultsKeys.value.push(key);
+  }
+  instance.__vuelidateInjectInstances = [].concat(instance.__vuelidateInjectInstances || [], injectChildResultsIntoParent);
+  function removeChildResultsFromParent(key) {
+    childResultsKeys.value = childResultsKeys.value.filter((childKey) => childKey !== key);
+    delete childResultsRaw[key];
+  }
+  instance.__vuelidateRemoveInstances = [].concat(instance.__vuelidateRemoveInstances || [], removeChildResultsFromParent);
+  const sendValidationResultsToParent = inject(VuelidateInjectChildResults, []);
+  provide(VuelidateInjectChildResults, instance.__vuelidateInjectInstances);
+  const removeValidationResultsFromParent = inject(VuelidateRemoveChildResults, []);
+  provide(VuelidateRemoveChildResults, instance.__vuelidateRemoveInstances);
+  return {
+    childResults,
+    sendValidationResultsToParent,
+    removeValidationResultsFromParent
+  };
+}
+function ComputedProxyFactory(target) {
+  return new Proxy(target, {
+    get(target2, prop) {
+      return typeof target2[prop] === "object" ? ComputedProxyFactory(target2[prop]) : computed(() => target2[prop]);
+    }
+  });
+}
+let uid = 0;
+function useVuelidate(validations, state) {
+  var _getCurrentInstance;
+  let globalConfig = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  if (arguments.length === 1) {
+    globalConfig = validations;
+    validations = void 0;
+    state = void 0;
+  }
+  let {
+    $registerAs,
+    $scope = CollectFlag.COLLECT_ALL,
+    $stopPropagation,
+    $externalResults,
+    currentVueInstance
+  } = globalConfig;
+  const instance = currentVueInstance || ((_getCurrentInstance = getCurrentInstance()) === null || _getCurrentInstance === void 0 ? void 0 : _getCurrentInstance.proxy);
+  const componentOptions = instance ? instance.$options : {};
+  if (!$registerAs) {
+    uid += 1;
+    $registerAs = `_vuelidate_${uid}`;
+  }
+  const validationResults = ref({});
+  const resultsCache = new ResultsStorage();
+  const {
+    childResults,
+    sendValidationResultsToParent,
+    removeValidationResultsFromParent
+  } = instance ? nestedValidations({
+    $scope,
+    instance
+  }) : {
+    childResults: ref({})
+  };
+  if (!validations && componentOptions.validations) {
+    const rules = componentOptions.validations;
+    state = ref({});
+    onBeforeMount(() => {
+      state.value = instance;
+      watch(() => isFunction$1(rules) ? rules.call(state.value, new ComputedProxyFactory(state.value)) : rules, (validations2) => {
+        validationResults.value = setValidations({
+          validations: validations2,
+          state,
+          childResults,
+          resultsCache,
+          globalConfig,
+          instance,
+          externalResults: $externalResults || instance.vuelidateExternalResults
+        });
+      }, {
+        immediate: true
+      });
+    });
+    globalConfig = componentOptions.validationsConfig || globalConfig;
+  } else {
+    const validationsWatchTarget = isRef(validations) || isProxy(validations) ? validations : reactive(validations || {});
+    watch(validationsWatchTarget, (newValidationRules) => {
+      validationResults.value = setValidations({
+        validations: newValidationRules,
+        state,
+        childResults,
+        resultsCache,
+        globalConfig,
+        instance: instance !== null && instance !== void 0 ? instance : {},
+        externalResults: $externalResults
+      });
+    }, {
+      immediate: true
+    });
+  }
+  if (instance) {
+    sendValidationResultsToParent.forEach((f) => f(validationResults, {
+      $registerAs,
+      $scope,
+      $stopPropagation
+    }));
+    onBeforeUnmount(() => removeValidationResultsFromParent.forEach((f) => f($registerAs)));
+  }
+  return computed(() => {
+    return _objectSpread2$1(_objectSpread2$1({}, unref(validationResults.value)), childResults.value);
+  });
+}
+function ownKeys(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    enumerableOnly && (symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    })), keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread2(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), true).forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function(key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
+  }
+  return target;
+}
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function isFunction(val) {
+  return typeof val === "function";
+}
+function isObject(o) {
+  return o !== null && typeof o === "object" && !Array.isArray(o);
+}
+function normalizeValidatorObject(validator) {
+  return isFunction(validator.$validator) ? _objectSpread2({}, validator) : {
+    $validator: validator
+  };
+}
+function unwrapValidatorResponse(result) {
+  if (typeof result === "object") return result.$valid;
+  return result;
+}
+function unwrapNormalizedValidator(validator) {
+  return validator.$validator || validator;
+}
+function withParams($params, $validator) {
+  if (!isObject($params)) throw new Error(`[@vuelidate/validators]: First parameter to "withParams" should be an object, provided ${typeof $params}`);
+  if (!isObject($validator) && !isFunction($validator)) throw new Error(`[@vuelidate/validators]: Validator must be a function or object with $validator parameter`);
+  const validatorObj = normalizeValidatorObject($validator);
+  validatorObj.$params = _objectSpread2(_objectSpread2({}, validatorObj.$params || {}), $params);
+  return validatorObj;
+}
+function withMessage($message, $validator) {
+  if (!isFunction($message) && typeof unref($message) !== "string") throw new Error(`[@vuelidate/validators]: First parameter to "withMessage" should be string or a function returning a string, provided ${typeof $message}`);
+  if (!isObject($validator) && !isFunction($validator)) throw new Error(`[@vuelidate/validators]: Validator must be a function or object with $validator parameter`);
+  const validatorObj = normalizeValidatorObject($validator);
+  validatorObj.$message = $message;
+  return validatorObj;
+}
+function withAsync($validator) {
+  let $watchTargets = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [];
+  const validatorObj = normalizeValidatorObject($validator);
+  return _objectSpread2(_objectSpread2({}, validatorObj), {}, {
+    $async: true,
+    $watchTargets
+  });
+}
+function forEach(validators) {
+  return {
+    $validator(collection) {
+      for (var _len = arguments.length, others = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        others[_key - 1] = arguments[_key];
+      }
+      return unref(collection).reduce((previous, collectionItem, index) => {
+        const collectionEntryResult = Object.entries(collectionItem).reduce((all, _ref) => {
+          let [property, $model] = _ref;
+          const innerValidators = validators[property] || {};
+          const propertyResult = Object.entries(innerValidators).reduce((all2, _ref2) => {
+            let [validatorName, currentValidator] = _ref2;
+            const validatorFunction = unwrapNormalizedValidator(currentValidator);
+            const $response = validatorFunction.call(this, $model, collectionItem, index, ...others);
+            const $valid = unwrapValidatorResponse($response);
+            all2.$data[validatorName] = $response;
+            all2.$data.$invalid = !$valid || !!all2.$data.$invalid;
+            all2.$data.$error = all2.$data.$invalid;
+            if (!$valid) {
+              let $message = currentValidator.$message || "";
+              const $params = currentValidator.$params || {};
+              if (typeof $message === "function") {
+                $message = $message({
+                  $pending: false,
+                  $invalid: !$valid,
+                  $params,
+                  $model,
+                  $response
+                });
+              }
+              all2.$errors.push({
+                $property: property,
+                $message,
+                $params,
+                $response,
+                $model,
+                $pending: false,
+                $validator: validatorName
+              });
+            }
+            return {
+              $valid: all2.$valid && $valid,
+              $data: all2.$data,
+              $errors: all2.$errors
+            };
+          }, {
+            $valid: true,
+            $data: {},
+            $errors: []
+          });
+          all.$data[property] = propertyResult.$data;
+          all.$errors[property] = propertyResult.$errors;
+          return {
+            $valid: all.$valid && propertyResult.$valid,
+            $data: all.$data,
+            $errors: all.$errors
+          };
+        }, {
+          $valid: true,
+          $data: {},
+          $errors: {}
+        });
+        return {
+          $valid: previous.$valid && collectionEntryResult.$valid,
+          $data: previous.$data.concat(collectionEntryResult.$data),
+          $errors: previous.$errors.concat(collectionEntryResult.$errors)
+        };
+      }, {
+        $valid: true,
+        $data: [],
+        $errors: []
+      });
+    },
+    $message: (_ref3) => {
+      let {
+        $response
+      } = _ref3;
+      return $response ? $response.$errors.map((context) => {
+        return Object.values(context).map((errors) => errors.map((error) => error.$message)).reduce((a, b) => a.concat(b), []);
+      }) : [];
+    }
+  };
+}
+const req = (value) => {
+  value = unref(value);
+  if (Array.isArray(value)) return !!value.length;
+  if (value === void 0 || value === null) {
+    return false;
+  }
+  if (value === false) {
+    return true;
+  }
+  if (value instanceof Date) {
+    return !isNaN(value.getTime());
+  }
+  if (typeof value === "object") {
+    for (let _ in value) return true;
+    return false;
+  }
+  return !!String(value).length;
+};
+const len = (value) => {
+  value = unref(value);
+  if (Array.isArray(value)) return value.length;
+  if (typeof value === "object") {
+    return Object.keys(value).length;
+  }
+  return String(value).length;
+};
+function regex() {
+  for (var _len = arguments.length, expr = new Array(_len), _key = 0; _key < _len; _key++) {
+    expr[_key] = arguments[_key];
+  }
+  return (value) => {
+    value = unref(value);
+    return !req(value) || expr.every((reg) => {
+      reg.lastIndex = 0;
+      return reg.test(value);
+    });
+  };
+}
+var common = /* @__PURE__ */ Object.freeze({
+  __proto__: null,
+  forEach,
+  len,
+  normalizeValidatorObject,
+  regex,
+  req,
+  unwrap: unref,
+  unwrapNormalizedValidator,
+  unwrapValidatorResponse,
+  withAsync,
+  withMessage,
+  withParams
+});
+regex(/^[a-zA-Z]*$/);
+regex(/^[a-zA-Z0-9]*$/);
+regex(/^\d*(\.\d+)?$/);
+const emailRegex = /^(?:[A-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9]{2,}(?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/i;
+regex(emailRegex);
+function maxLength$1(length) {
+  return (value) => !req(value) || len(value) <= unref(length);
+}
+function maxLength(max) {
+  return {
+    $validator: maxLength$1(max),
+    $message: (_ref) => {
+      let {
+        $params
+      } = _ref;
+      return `The maximum length allowed is ${$params.max}`;
+    },
+    $params: {
+      max,
+      type: "maxLength"
+    }
+  };
+}
+function minLength$1(length) {
+  return (value) => !req(value) || len(value) >= unref(length);
+}
+function minLength(min) {
+  return {
+    $validator: minLength$1(min),
+    $message: (_ref) => {
+      let {
+        $params
+      } = _ref;
+      return `This field should be at least ${$params.min} characters long`;
+    },
+    $params: {
+      min,
+      type: "minLength"
+    }
+  };
+}
+function required$1(value) {
+  if (typeof value === "string") {
+    value = value.trim();
+  }
+  return req(value);
+}
+var required = {
+  $validator: required$1,
+  $message: "Value is required",
+  $params: {
+    type: "required"
+  }
+};
+const urlRegex = /^(?:(?:(?:https?|ftp):)?\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z0-9\u00a1-\uffff][a-z0-9\u00a1-\uffff_-]{0,62})?[a-z0-9\u00a1-\uffff]\.)+(?:[a-z\u00a1-\uffff]{2,}\.?))(?::\d{2,5})?(?:[/?#]\S*)?$/i;
+regex(urlRegex);
+regex(/(^[0-9]*$)|(^-[0-9]+$)/);
+regex(/^[-]?\d*(\.\d+)?$/);
+export {
+  minLength as a,
+  common as c,
+  maxLength as m,
+  required as r,
+  useVuelidate as u
+};