@regle/rules 1.2.3 → 1.3.0-beta.1

package/dist/regle-rules.mjs

@@ -1,1056 +0,0 @@
-import { createRule, InternalRuleType, unwrapRuleParameters } from '@regle/core';
-import { unref, computed, toValue } from 'vue';
-
-// src/helpers/withMessage.ts
-function withMessage(rule, newMessage) {
-  let _type;
-  let validator;
-  let _active;
-  let _params;
-  if (typeof rule === "function" && !("_validator" in rule)) {
-    _type = InternalRuleType.Inline;
-    validator = rule;
-  } else {
-    ({ _type, validator, _active, _params } = rule);
-  }
-  const newRule = createRule({
-    type: _type,
-    validator,
-    active: _active,
-    message: newMessage
-  });
-  const newParams = [..._params ?? []];
-  newRule._params = newParams;
-  newRule._message_patched = true;
-  if (typeof newRule === "function") {
-    if (_params != null) {
-      const executedRule = newRule(...newParams);
-      executedRule._message_patched = true;
-      return executedRule;
-    }
-    return newRule;
-  } else {
-    return newRule;
-  }
-}
-function withTooltip(rule, newTooltip) {
-  let _type;
-  let validator;
-  let _active;
-  let _params;
-  let _message;
-  if (typeof rule === "function" && !("_validator" in rule)) {
-    _type = InternalRuleType.Inline;
-    validator = rule;
-  } else {
-    ({ _type, validator, _active, _params, _message } = rule);
-  }
-  const newRule = createRule({
-    type: _type,
-    validator,
-    active: _active,
-    message: _message,
-    tooltip: newTooltip
-  });
-  const newParams = [..._params ?? []];
-  newRule._params = newParams;
-  newRule._tooltip_patched = true;
-  if (typeof newRule === "function") {
-    const executedRule = newRule(...newParams);
-    newRule._tooltip_patched = true;
-    return executedRule;
-  } else {
-    return newRule;
-  }
-}
-function withAsync(rule, depsArray) {
-  let _type;
-  let validator;
-  let _params = [];
-  let _message = "";
-  if (typeof rule === "function") {
-    _type = InternalRuleType.Inline;
-    validator = async (value, ...params) => {
-      return rule(value, ...params);
-    };
-    _params = [depsArray];
-  } else {
-    ({ _type, _message } = rule);
-    _params = _params = rule._params?.concat(depsArray);
-    validator = async (...args) => rule.validator(args);
-  }
-  const newRule = createRule({
-    type: InternalRuleType.Async,
-    validator,
-    message: _message
-  });
-  newRule._params = newRule._params?.concat(_params);
-  return newRule(...depsArray ?? []);
-}
-function withParams(rule, depsArray) {
-  let _type;
-  let validator;
-  let _params = [];
-  let _message = "";
-  if (typeof rule === "function") {
-    _type = InternalRuleType.Inline;
-    validator = (value, ...params) => {
-      return rule(value, ...params);
-    };
-    _params = [depsArray];
-  } else {
-    ({ _type, validator, _message } = rule);
-    _params = _params = rule._params?.concat(depsArray);
-  }
-  const newRule = createRule({
-    type: InternalRuleType.Inline,
-    validator,
-    message: _message
-  });
-  newRule._params = newRule._params?.concat(_params);
-  return newRule(...depsArray);
-}
-function applyIf(_condition, rule) {
-  let _type;
-  let validator;
-  let _params = [];
-  let _message = "";
-  if (typeof rule === "function") {
-    _type = InternalRuleType.Inline;
-    validator = rule;
-    _params = [_condition];
-  } else {
-    ({ _type, validator, _message } = rule);
-    _params = rule._params?.concat([_condition]);
-  }
-  function newValidator(value, ...args) {
-    const [condition] = unwrapRuleParameters([_condition]);
-    if (condition) {
-      return validator(value, ...args);
-    }
-    return true;
-  }
-  function newActive(metadata) {
-    const [condition] = unwrapRuleParameters([_condition]);
-    return condition;
-  }
-  const newRule = createRule({
-    type: _type,
-    validator: newValidator,
-    active: newActive,
-    message: _message
-  });
-  const newParams = [..._params ?? []];
-  newRule._params = newParams;
-  if (typeof newRule === "function") {
-    const executedRule = newRule(...newParams);
-    return executedRule;
-  } else {
-    return newRule;
-  }
-}
-
-// ../shared/utils/isFile.ts
-function isFile(value) {
-  return value?.constructor.name == "File" || value?.constructor.name == "FileList";
-}
-
-// ../shared/utils/isEmpty.ts
-function isEmpty(value, considerEmptyArrayInvalid = true) {
-  if (value === void 0 || value === null) {
-    return true;
-  }
-  if (value instanceof Date) {
-    return isNaN(value.getTime());
-  } else if (isFile(value)) {
-    return value.size <= 0;
-  } else if (Array.isArray(value)) {
-    if (considerEmptyArrayInvalid) {
-      return value.length === 0;
-    }
-    return false;
-  } else if (typeof value === "object" && value != null) {
-    return Object.keys(value).length === 0;
-  }
-  return !String(value).length;
-}
-
-// ../shared/utils/isDate.ts
-function isDate(value) {
-  if (isEmpty(value)) {
-    return false;
-  }
-  try {
-    let possibleDate = null;
-    if (value instanceof Date) {
-      possibleDate = value;
-    } else if (typeof value === "string") {
-      const date2 = new Date(value);
-      if (date2.toString() === "Invalid Date") {
-        return false;
-      }
-      possibleDate = date2;
-    }
-    return !!possibleDate;
-  } catch (e) {
-    return false;
-  }
-}
-
-// ../shared/utils/toDate.ts
-function toDate(argument) {
-  const argStr = Object.prototype.toString.call(argument);
-  if (argument == null) {
-    return /* @__PURE__ */ new Date(NaN);
-  } else if (argument instanceof Date || typeof argument === "object" && argStr === "[object Date]") {
-    return new Date(argument.getTime());
-  } else if (typeof argument === "number" || argStr === "[object Number]") {
-    return new Date(argument);
-  } else if (typeof argument === "string" || argStr === "[object String]") {
-    return new Date(argument);
-  } else {
-    return /* @__PURE__ */ new Date(NaN);
-  }
-}
-
-// src/helpers/ruleHelpers/isFilled.ts
-function isFilled(value, considerEmptyArrayInvalid = true) {
-  return !isEmpty(typeof value === "string" ? value.trim() : value, considerEmptyArrayInvalid);
-}
-
-// src/helpers/ruleHelpers/isNumber.ts
-function isNumber(value) {
-  if (value == null) return false;
-  else if (typeof value !== "number") {
-    return false;
-  } else if (isNaN(value)) {
-    return false;
-  } else {
-    return true;
-  }
-}
-
-// src/helpers/ruleHelpers/matchRegex.ts
-function matchRegex(_value, ...expr) {
-  if (isEmpty(_value)) {
-    return true;
-  }
-  const value = typeof _value === "number" ? _value.toString() : _value;
-  return expr.every((reg) => {
-    reg.lastIndex = 0;
-    return reg.test(value);
-  });
-}
-function getSize(value) {
-  const _value = unref(value);
-  if (Array.isArray(_value)) return _value.length;
-  if (typeof _value === "object") {
-    return Object.keys(_value).length;
-  }
-  if (typeof _value === "number") {
-    if (isNaN(_value)) {
-      return 0;
-    }
-    return _value;
-  }
-  return String(_value).length;
-}
-
-// src/helpers/ruleHelpers/toNumber.ts
-function toNumber(argument) {
-  if (typeof argument === "number") {
-    return argument;
-  } else if (argument != null) {
-    if (typeof argument === "string") {
-      const isPadded = argument.trim() !== argument;
-      if (isPadded) {
-        return NaN;
-      }
-      return +argument;
-    }
-    return NaN;
-  }
-  return NaN;
-}
-function and(...rules) {
-  const isAnyRuleAsync = rules.some((rule) => {
-    if (typeof rule === "function") {
-      return rule.constructor.name === "AsyncFunction";
-    } else {
-      return rule._async;
-    }
-  });
-  const _params = rules.map((rule) => {
-    if (typeof rule === "function") {
-      return null;
-    } else {
-      const $params = rule._params;
-      if (!$params?.length) {
-        return [];
-      } else {
-        return $params;
-      }
-    }
-  }).flat().filter((param) => !!param);
-  function computeRules(rules2, value, ...params) {
-    const $rules = [];
-    let paramIndex = 0;
-    for (let rule of rules2) {
-      if (typeof rule === "function") {
-        $rules.push(rule(value));
-        paramIndex++;
-      } else {
-        const paramsLength = rule._params?.length ?? 0;
-        $rules.push(rule.validator(value, ...params.slice(paramIndex, paramsLength)));
-        if (paramsLength) {
-          paramIndex += paramsLength;
-        }
-      }
-    }
-    return $rules;
-  }
-  function computeMetadata(results) {
-    const isAnyResultMetaData = results?.some((s) => typeof s !== "boolean");
-    if (isAnyResultMetaData) {
-      return {
-        $valid: results.every((result) => {
-          if (typeof result === "boolean") {
-            return !!result;
-          }
-          return result.$valid;
-        }),
-        ...results.reduce((acc, result) => {
-          if (typeof result === "boolean") {
-            return acc;
-          }
-          const { $valid, ...rest } = result;
-          return { ...acc, ...rest };
-        }, {})
-      };
-    } else {
-      return results.every((result) => !!result);
-    }
-  }
-  let validator;
-  if (!!rules.length) {
-    validator = isAnyRuleAsync ? async (value, ...params) => {
-      const results = await Promise.all(computeRules(rules, value, ...params));
-      return computeMetadata(results);
-    } : (value, ...params) => {
-      const $rules = computeRules(rules, value, ...params);
-      return computeMetadata($rules);
-    };
-  } else {
-    validator = (value) => {
-      return false;
-    };
-  }
-  const newRule = createRule({
-    type: "and",
-    validator,
-    message: "The value does not match all of the provided validators"
-  });
-  const newParams = [..._params ?? []];
-  newRule._params = newParams;
-  if (typeof newRule === "function") {
-    const executedRule = newRule(...newParams);
-    return executedRule;
-  } else {
-    return newRule;
-  }
-}
-function or(...rules) {
-  const isAnyRuleAsync = rules.some((rule) => {
-    if (typeof rule === "function") {
-      return rule.constructor.name === "AsyncFunction";
-    } else {
-      return rule._async;
-    }
-  });
-  const _params = rules.map((rule) => {
-    if (typeof rule === "function") {
-      return null;
-    } else {
-      return rule._params;
-    }
-  }).flat().filter((param) => !!param);
-  function computeRules(rules2, value, ...params) {
-    const $rules = [];
-    let paramIndex = 0;
-    for (let rule of rules2) {
-      if (typeof rule === "function") {
-        $rules.push(rule(value));
-        paramIndex++;
-      } else {
-        const paramsLength = rule._params?.length ?? 0;
-        $rules.push(rule.validator(value, ...params.slice(paramIndex, paramsLength)));
-        if (paramsLength) {
-          paramIndex += paramsLength;
-        }
-      }
-    }
-    return $rules;
-  }
-  function computeMetadata(results) {
-    const isAnyResultMetaData = results.some((s) => typeof s !== "boolean");
-    if (isAnyResultMetaData) {
-      return {
-        $valid: results.some((result) => {
-          if (typeof result === "boolean") {
-            return !!result;
-          }
-          return result.$valid;
-        }),
-        ...results.reduce((acc, result) => {
-          if (typeof result === "boolean") {
-            return acc;
-          }
-          const { $valid, ...rest } = result;
-          return { ...acc, ...rest };
-        }, {})
-      };
-    } else {
-      return results.some((result) => !!result);
-    }
-  }
-  const validator = isAnyRuleAsync ? async (value, ...params) => {
-    const results = await Promise.all(computeRules(rules, value, ...params));
-    return computeMetadata(results);
-  } : (value, ...params) => {
-    const $rules = computeRules(rules, value, ...params);
-    return computeMetadata($rules);
-  };
-  const newRule = createRule({
-    type: "or",
-    validator,
-    message: "The value does not match any of the provided validators"
-  });
-  const newParams = [..._params ?? []];
-  newRule._params = newParams;
-  if (typeof newRule === "function") {
-    const executedRule = newRule(...newParams);
-    return executedRule;
-  } else {
-    return newRule;
-  }
-}
-function not(rule, message) {
-  let _type;
-  let validator;
-  let newValidator;
-  let _params;
-  let _async;
-  if (typeof rule === "function") {
-    validator = rule;
-    _async = rule.constructor.name === "AsyncFunction";
-  } else {
-    ({ _type, validator, _params } = rule);
-    _async = rule._async;
-  }
-  if (_async) {
-    newValidator = async (value, ...params) => {
-      if (isFilled(value)) {
-        const result = await validator(value, ...params);
-        return !result;
-      }
-      return true;
-    };
-  } else {
-    newValidator = (value, ...params) => {
-      if (isFilled(value)) {
-        return !validator(value, ...params);
-      }
-      return true;
-    };
-  }
-  const newRule = createRule({
-    type: "not",
-    validator: newValidator,
-    message: message ?? "Error"
-  });
-  const newParams = [..._params ?? []];
-  newRule._params = newParams;
-  if (typeof newRule === "function") {
-    const executedRule = newRule(...newParams);
-    return executedRule;
-  } else {
-    return newRule;
-  }
-}
-var alphaRegex = /^[a-zA-Z]*$/;
-var alphaSymbolRegex = /^[\w.]+$/;
-var alpha = createRule({
-  type: "alpha",
-  validator(value, options) {
-    if (isEmpty(value)) {
-      return true;
-    }
-    if (options?.allowSymbols) {
-      return matchRegex(value, alphaSymbolRegex);
-    }
-    return matchRegex(value, alphaRegex);
-  },
-  message: "The value is not alphabetical"
-});
-var alphaNumRegex = /^[a-zA-Z0-9]*$/;
-var alphaNumSymbolRegex = /^[a-zA-Z0-9_]*$/;
-var alphaNum = createRule({
-  type: "alphaNum",
-  validator(value, options) {
-    if (isEmpty(value)) {
-      return true;
-    }
-    if (options?.allowSymbols) {
-      return matchRegex(value, alphaNumSymbolRegex);
-    }
-    return matchRegex(value, alphaNumRegex);
-  },
-  message: "The value must be alpha-numeric"
-});
-var between = createRule({
-  type: "between",
-  validator: (value, min, max, options) => {
-    const { allowEqual = true } = options ?? {};
-    if (isFilled(value) && isFilled(min) && isFilled(max)) {
-      const tValue = toNumber(value);
-      const tMin = toNumber(min);
-      const tMax = toNumber(max);
-      if (isNumber(tValue) && isNumber(tMin) && isNumber(tMax)) {
-        if (allowEqual) {
-          return tValue >= tMin && tValue <= tMax;
-        } else {
-          return tValue > tMin && tValue < tMax;
-        }
-      }
-      console.warn(`[between] Value or parameters aren't numbers, got value: ${value}, min: ${min}, max: ${max}`);
-      return false;
-    }
-    return true;
-  },
-  message: ({ $params: [min, max] }) => {
-    return `The value must be between ${min} and ${max}`;
-  }
-});
-var boolean = createRule({
-  type: "boolean",
-  validator: (value) => {
-    if (isFilled(value)) {
-      return typeof value === "boolean";
-    }
-    return true;
-  },
-  message: "The value must be a native boolean"
-});
-var checked = createRule({
-  type: "checked",
-  validator: (value) => {
-    if (isFilled(value)) {
-      return value === true;
-    }
-    return true;
-  },
-  message: "The field must be checked"
-});
-var contains = createRule({
-  type: "contains",
-  validator(value, part) {
-    if (isFilled(value) && isFilled(part)) {
-      return value.includes(part);
-    }
-    return true;
-  },
-  message({ $params: [part] }) {
-    return `The value must contain ${part}`;
-  }
-});
-var date = createRule({
-  type: "date",
-  validator: (value) => {
-    if (isFilled(value)) {
-      return value instanceof Date;
-    }
-    return true;
-  },
-  message: "The value must be a native Date constructor"
-});
-
-// src/utils/getLocale.util.ts
-function getUserLocale() {
-  if (navigator.languages != void 0) return navigator.languages[0];
-  return navigator.language;
-}
-function formatLocaleDate(date2) {
-  if (date2) {
-    return new Intl.DateTimeFormat(getUserLocale(), { dateStyle: "short" }).format(new Date(date2));
-  }
-  return "?";
-}
-
-// src/rules/dateAfter.ts
-var dateAfter = createRule({
-  type: "dateAfter",
-  validator: (value, after, options) => {
-    const { allowEqual = true } = options ?? {};
-    if (isFilled(value) && isFilled(after)) {
-      if (isDate(value) && isDate(after)) {
-        const result = allowEqual ? toDate(value).getTime() >= toDate(after).getTime() : toDate(value).getTime() > toDate(after).getTime();
-        if (result) {
-          return true;
-        }
-        return { $valid: false, error: "date-not-after" };
-      }
-      return { $valid: false, error: "value-or-parameter-not-a-date" };
-    }
-    return true;
-  },
-  message: ({ $params: [after], error }) => {
-    if (error === "value-or-parameter-not-a-date") {
-      return "The values must be dates";
-    }
-    return `The date must be after ${formatLocaleDate(after)}`;
-  }
-});
-var dateBefore = createRule({
-  type: "dateBefore",
-  validator: (value, before, options) => {
-    const { allowEqual = true } = options ?? {};
-    if (isFilled(value) && isFilled(before)) {
-      if (isDate(value) && isDate(before)) {
-        const result = allowEqual ? toDate(value).getTime() <= toDate(before).getTime() : toDate(value).getTime() < toDate(before).getTime();
-        if (result) {
-          return true;
-        }
-        return { $valid: false, error: "date-not-before" };
-      }
-      return { $valid: false, error: "value-or-parameter-not-a-date" };
-    }
-    return true;
-  },
-  message: ({ $params: [before], error }) => {
-    if (error === "value-or-parameter-not-a-date") {
-      return "The values must be dates";
-    }
-    return `The date must be before ${formatLocaleDate(before)}`;
-  }
-});
-var dateBetween = createRule({
-  type: "dateBetween",
-  validator: (value, before, after, options) => {
-    const { allowEqual = true } = options ?? {};
-    if (isDate(value) && isDate(before) && isDate(after)) {
-      if (allowEqual) {
-        return toDate(value).getTime() >= toDate(before).getTime() && toDate(value).getTime() <= toDate(after).getTime();
-      } else {
-        return toDate(value).getTime() > toDate(before).getTime() && toDate(value).getTime() < toDate(after).getTime();
-      }
-    }
-    return true;
-  },
-  message: ({ $params: [before, after] }) => {
-    return `The date must be between ${formatLocaleDate(before)} and ${formatLocaleDate(after)}`;
-  }
-});
-var decimalRegex = /^[-]?\d*(\.\d+)?$/;
-var decimal = createRule({
-  type: "decimal",
-  validator(value) {
-    if (isEmpty(value)) {
-      return true;
-    }
-    return matchRegex(value, decimalRegex);
-  },
-  message: "The value must be decimal"
-});
-var 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;
-var email = createRule({
-  type: "email",
-  validator(value) {
-    if (isEmpty(value)) {
-      return true;
-    }
-    return matchRegex(value, emailRegex);
-  },
-  message: "The value must be an valid email address"
-});
-var endsWith = createRule({
-  type: "endsWith",
-  validator(value, part) {
-    if (isFilled(value) && isFilled(part)) {
-      return value.endsWith(part);
-    }
-    return true;
-  },
-  message({ $params: [part] }) {
-    return `The value must end with ${part}`;
-  }
-});
-var exactLength = createRule({
-  type: "exactLength",
-  validator: (value, count) => {
-    if (isFilled(value, false) && isFilled(count)) {
-      if (isNumber(count)) {
-        return getSize(value) === count;
-      }
-      console.warn(`[minLength] Parameter isn't a number, got parameter: ${count}`);
-      return false;
-    }
-    return true;
-  },
-  message: ({ $params: [count] }) => {
-    return `The value should be exactly ${count} characters long`;
-  }
-});
-var exactValue = createRule({
-  type: "exactValue",
-  validator: (value, count) => {
-    if (isFilled(value) && isFilled(count)) {
-      if (isNumber(count) && !isNaN(toNumber(value))) {
-        return toNumber(value) === count;
-      }
-      console.warn(`[exactValue] Value or parameter isn't a number, got value: ${value}, parameter: ${count}`);
-      return true;
-    }
-    return true;
-  },
-  message: ({ $params: [count] }) => {
-    return `The value must be equal to ${count}`;
-  }
-});
-var hexadecimalRegex = /^[a-fA-F0-9]*$/;
-var hexadecimal = createRule({
-  type: "hexadecimal",
-  validator(value) {
-    if (isEmpty(value)) {
-      return true;
-    }
-    return matchRegex(value, hexadecimalRegex);
-  },
-  message: "The value must be hexadecimal"
-});
-var integerRegex = /(^[0-9]*$)|(^-[0-9]+$)/;
-var integer = createRule({
-  type: "integer",
-  validator(value) {
-    if (isEmpty(value)) {
-      return true;
-    }
-    return matchRegex(value, integerRegex);
-  },
-  message: "The value must be an integer"
-});
-function nibbleValid(nibble) {
-  if (nibble.length > 3 || nibble.length === 0) {
-    return false;
-  }
-  if (nibble[0] === "0" && nibble !== "0") {
-    return false;
-  }
-  if (!nibble.match(/^\d+$/)) {
-    return false;
-  }
-  const numeric2 = +nibble | 0;
-  return numeric2 >= 0 && numeric2 <= 255;
-}
-var ipv4Address = createRule({
-  type: "ipv4Address",
-  validator(value) {
-    if (isEmpty(value)) {
-      return true;
-    }
-    if (typeof value !== "string") {
-      return false;
-    }
-    const nibbles = value.split(".");
-    return nibbles.length === 4 && nibbles.every(nibbleValid);
-  },
-  message: "The value is not a valid IPv4 address"
-});
-function literal(literal2) {
-  const params = computed(() => toValue(literal2));
-  const rule = withMessage(
-    withParams(
-      (value, literal3) => {
-        if (isFilled(value) && isFilled(literal3)) {
-          return literal3 === value;
-        }
-        return true;
-      },
-      [params]
-    ),
-    ({ $params: [literal3] }) => `Value should be ${literal3}.`
-  );
-  return rule;
-}
-var macAddress = createRule({
-  type: "macAddress",
-  validator(value, separator = ":") {
-    if (isEmpty(value)) {
-      return true;
-    }
-    if (typeof value !== "string") {
-      return false;
-    }
-    const parts = typeof separator === "string" && separator !== "" ? value.split(separator) : value.length === 12 || value.length === 16 ? value.match(/.{2}/g) : null;
-    return parts !== null && (parts.length === 6 || parts.length === 8) && parts.every(hexValid);
-  },
-  message: "The value is not a valid MAC Address"
-});
-var hexValid = (hex) => hex.toLowerCase().match(/^[0-9a-f]{2}$/);
-var maxLength = createRule({
-  type: "maxLength",
-  validator: (value, count, options) => {
-    const { allowEqual = true } = options ?? {};
-    if (isFilled(value, false) && isFilled(count)) {
-      if (isNumber(count)) {
-        if (allowEqual) {
-          return getSize(value) <= count;
-        } else {
-          return getSize(value) < count;
-        }
-      }
-      console.warn(`[maxLength] Value or parameter isn't a number, got value: ${value}, parameter: ${count}`);
-      return false;
-    }
-    return true;
-  },
-  message: ({ $value, $params: [count] }) => {
-    if (Array.isArray($value)) {
-      return `This list should have maximum ${count} items`;
-    }
-    return `The value length should not exceed ${count}`;
-  }
-});
-var maxValue = createRule({
-  type: "maxValue",
-  validator: (value, count, options) => {
-    const { allowEqual = true } = options ?? {};
-    if (isFilled(value) && isFilled(count)) {
-      if (isNumber(count) && !isNaN(toNumber(value))) {
-        if (allowEqual) {
-          return toNumber(value) <= count;
-        } else {
-          return toNumber(value) < count;
-        }
-      }
-      console.warn(`[maxValue] Value or parameter isn't a number, got value: ${value}, parameter: ${count}`);
-      return true;
-    }
-    return true;
-  },
-  message: ({ $params: [count, options] }) => {
-    const { allowEqual = true } = options ?? {};
-    if (allowEqual) {
-      return `The value must be less than or equal to ${count}`;
-    } else {
-      return `The value must be less than ${count}`;
-    }
-  }
-});
-var minLength = createRule({
-  type: "minLength",
-  validator: (value, count, options) => {
-    const { allowEqual = true } = options ?? {};
-    if (isFilled(value, false) && isFilled(count)) {
-      if (isNumber(count)) {
-        if (allowEqual) {
-          return getSize(value) >= count;
-        } else {
-          return getSize(value) > count;
-        }
-      }
-      console.warn(`[minLength] Parameter isn't a number, got parameter: ${count}`);
-      return false;
-    }
-    return true;
-  },
-  message: ({ $value, $params: [count] }) => {
-    if (Array.isArray($value)) {
-      return `The list should have at least ${count} items`;
-    }
-    return `The value length should be at least ${count}`;
-  }
-});
-var minValue = createRule({
-  type: "minValue",
-  validator: (value, count, options) => {
-    const { allowEqual = true } = options ?? {};
-    if (isFilled(value) && isFilled(count)) {
-      if (isNumber(count) && !isNaN(toNumber(value))) {
-        if (allowEqual) {
-          return toNumber(value) >= count;
-        } else {
-          return toNumber(value) > count;
-        }
-      }
-      console.warn(`[minValue] Value or parameter isn't a number, got value: ${value}, parameter: ${count}`);
-      return true;
-    }
-    return true;
-  },
-  message: ({ $params: [count, options] }) => {
-    const { allowEqual = true } = options ?? {};
-    if (allowEqual) {
-      return `The value must be greater than or equal to ${count}`;
-    } else {
-      return `The value must be greater than ${count}`;
-    }
-  }
-});
-function getValidEnumValues(obj) {
-  const validKeys = Object.keys(obj).filter((k) => typeof obj[obj[k]] !== "number");
-  const filtered = {};
-  for (const k of validKeys) {
-    filtered[k] = obj[k];
-  }
-  return Object.values(filtered);
-}
-function nativeEnum(enumLike) {
-  const params = computed(() => toValue(enumLike));
-  const rule = withMessage(
-    withParams(
-      (value, enumLike2) => {
-        if (isFilled(value) && !isEmpty(enumLike2)) {
-          const validValues = getValidEnumValues(enumLike2);
-          return validValues.includes(value);
-        }
-        return true;
-      },
-      [params]
-    ),
-    ({ $params: [enumLike2] }) => `The value should be one of those options: ${Object.values(enumLike2).join(", ")}.`
-  );
-  return rule;
-}
-var number = createRule({
-  type: "number",
-  validator: (value) => {
-    if (isFilled(value)) {
-      return isNumber(value);
-    }
-    return true;
-  },
-  message: "The value must be a native number"
-});
-var numericRegex = /^\d*(\.\d+)?$/;
-var numeric = createRule({
-  type: "numeric",
-  validator(value) {
-    if (isEmpty(value)) {
-      return true;
-    }
-    return matchRegex(value, numericRegex);
-  },
-  message: "The value must be numeric"
-});
-function oneOf(options) {
-  const params = computed(() => toValue(options));
-  const rule = withMessage(
-    withParams(
-      (value, options2) => {
-        if (isFilled(value) && isFilled(options2, false)) {
-          return options2.includes(value);
-        }
-        return true;
-      },
-      [params]
-    ),
-    ({ $params: [options2] }) => `The value should be one of those options: ${options2.join(", ")}.`
-  );
-  return rule;
-}
-var regex = createRule({
-  type: "regex",
-  validator(value, regexp) {
-    if (isFilled(value)) {
-      const filteredRegexp = Array.isArray(regexp) ? regexp : [regexp];
-      return matchRegex(value, ...filteredRegexp);
-    }
-    return true;
-  },
-  message: "The value does not match the required pattern"
-});
-var required = createRule({
-  type: "required",
-  validator: (value) => {
-    return isFilled(value);
-  },
-  message: "This field is required"
-});
-var requiredIf = createRule({
-  type: "required",
-  validator(value, condition) {
-    if (condition) {
-      return isFilled(value);
-    }
-    return true;
-  },
-  message: "This field is required",
-  active({ $params: [condition] }) {
-    return condition;
-  }
-});
-var requiredUnless = createRule({
-  type: "required",
-  validator(value, condition) {
-    if (!condition) {
-      return isFilled(value);
-    }
-    return true;
-  },
-  message: "This field is required",
-  active({ $params: [condition] }) {
-    return !condition;
-  }
-});
-var sameAs = createRule({
-  type: "sameAs",
-  validator(value, target, otherName) {
-    if (isEmpty(value)) {
-      return true;
-    }
-    return value === target;
-  },
-  message({ $params: [_, otherName = "other"] }) {
-    return `The value must be equal to the ${otherName} value`;
-  }
-});
-var startsWith = createRule({
-  type: "startsWith",
-  validator(value, part) {
-    if (isFilled(value) && isFilled(part)) {
-      return value.startsWith(part);
-    }
-    return true;
-  },
-  message({ $params: [part] }) {
-    return `The value must end with ${part}`;
-  }
-});
-var string = createRule({
-  type: "string",
-  validator: (value) => {
-    if (isFilled(value)) {
-      return typeof value === "string";
-    }
-    return true;
-  },
-  message: "The value must be a string"
-});
-
-// src/rules/type.ts
-function type() {
-  return () => true;
-}
-var 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;
-var url = createRule({
-  type: "url",
-  validator(value) {
-    if (isEmpty(value)) {
-      return true;
-    }
-    return matchRegex(value, urlRegex);
-  },
-  message: "The value is not a valid URL address"
-});
-
-export { alpha, alphaNum, and, applyIf, between, boolean, checked, contains, date, dateAfter, dateBefore, dateBetween, decimal, email, endsWith, exactLength, exactValue, getSize, hexadecimal, integer, ipv4Address, isDate, isEmpty, isFilled, isNumber, literal, macAddress, matchRegex, maxLength, maxValue, minLength, minValue, nativeEnum, not, number, numeric, oneOf, or, regex, required, requiredIf, requiredUnless, sameAs, startsWith, string, toDate, toNumber, type, url, withAsync, withMessage, withParams, withTooltip };