@regle/rules 1.2.0-beta.1 → 1.2.0-beta.3

package/dist/regle-rules.mjs

@@ -23,9 +23,12 @@ function withMessage(rule, newMessage) {
   newRule._params = newParams;
   newRule._message_patched = true;
   if (typeof newRule === "function") {
-    const executedRule = newRule(...newParams);
-    executedRule._message_patched = true;
-    return executedRule;
+    if (_params != null) {
+      const executedRule = newRule(...newParams);
+      executedRule._message_patched = true;
+      return executedRule;
+    }
+    return newRule;
   } else {
     return newRule;
   }
@@ -177,11 +180,11 @@ function isDate(value) {
     if (value instanceof Date) {
       possibleDate = value;
     } else if (typeof value === "string") {
-      const date = new Date(value);
-      if (date.toString() === "Invalid Date") {
+      const date2 = new Date(value);
+      if (date2.toString() === "Invalid Date") {
         return false;
       }
-      possibleDate = date;
+      possibleDate = date2;
     }
     return !!possibleDate;
   } catch (e) {
@@ -469,50 +472,6 @@ function not(rule, message) {
     return newRule;
   }
 }
-var required = createRule({
-  type: "required",
-  validator: (value) => {
-    return isFilled(value);
-  },
-  message: "This field is required"
-});
-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 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 alphaRegex = /^[a-zA-Z]*$/;
 var alphaSymbolRegex = /^[\w.]+$/;
 var alpha = createRule({
@@ -567,193 +526,47 @@ var between = createRule({
     return `The value must be between ${min} and ${max}`;
   }
 });
-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 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"
-});
-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;
+var boolean = createRule({
+  type: "boolean",
+  validator: (value) => {
+    if (isFilled(value)) {
+      return typeof value === "boolean";
     }
     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}`;
-    }
-  }
+  message: "The value must be a native boolean"
 });
-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;
+var checked = createRule({
+  type: "checked",
+  validator: (value) => {
+    if (isFilled(value)) {
+      return value === true;
     }
     return true;
   },
-  message: ({ $params: [count] }) => {
-    return `The value must be equal to ${count}`;
-  }
+  message: "The field must be checked"
 });
-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;
+var contains = createRule({
+  type: "contains",
+  validator(value, part) {
+    if (isFilled(value) && isFilled(part)) {
+      return value.includes(part);
     }
     return true;
   },
-  message: ({ $params: [count] }) => {
-    return `The value should be exactly ${count} characters long`;
+  message({ $params: [part] }) {
+    return `The value must contain ${part}`;
   }
 });
-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"
-});
-var requiredUnless = createRule({
-  type: "required",
-  validator(value, condition) {
-    if (!condition) {
-      return isFilled(value);
+var date = createRule({
+  type: "date",
+  validator: (value) => {
+    if (isFilled(value)) {
+      return value instanceof Date;
     }
     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 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"
+  message: "The value must be a native Date constructor"
 });
 
 // src/utils/getLocale.util.ts
@@ -761,9 +574,9 @@ function getUserLocale() {
   if (navigator.languages != void 0) return navigator.languages[0];
   return navigator.language;
 }
-function formatLocaleDate(date) {
-  if (date) {
-    return new Intl.DateTimeFormat(getUserLocale(), { dateStyle: "short" }).format(new Date(date));
+function formatLocaleDate(date2) {
+  if (date2) {
+    return new Intl.DateTimeFormat(getUserLocale(), { dateStyle: "short" }).format(new Date(date2));
   }
   return "?";
 }
@@ -771,21 +584,22 @@ function formatLocaleDate(date) {
 // src/rules/dateAfter.ts
 var dateAfter = createRule({
   type: "dateAfter",
-  validator: (value, after) => {
+  validator: (value, after, options) => {
+    const { allowEqual = true } = options ?? {};
     if (isFilled(value) && isFilled(after)) {
       if (isDate(value) && isDate(after)) {
-        const result = toDate(value).getTime() > toDate(after).getTime();
+        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-paramater-not-a-date" };
+      return { $valid: false, error: "value-or-parameter-not-a-date" };
     }
     return true;
   },
   message: ({ $params: [after], error }) => {
-    if (error === "value-or-paramater-not-a-date") {
+    if (error === "value-or-parameter-not-a-date") {
       return "The values must be dates";
     }
     return `The date must be after ${formatLocaleDate(after)}`;
@@ -793,21 +607,22 @@ var dateAfter = createRule({
 });
 var dateBefore = createRule({
   type: "dateBefore",
-  validator: (value, before) => {
+  validator: (value, before, options) => {
+    const { allowEqual = true } = options ?? {};
     if (isFilled(value) && isFilled(before)) {
       if (isDate(value) && isDate(before)) {
-        const result = toDate(value).getTime() < toDate(before).getTime();
+        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-paramater-not-a-date" };
+      return { $valid: false, error: "value-or-parameter-not-a-date" };
     }
     return true;
   },
   message: ({ $params: [before], error }) => {
-    if (error === "value-or-paramater-not-a-date") {
+    if (error === "value-or-parameter-not-a-date") {
       return "The values must be dates";
     }
     return `The date must be before ${formatLocaleDate(before)}`;
@@ -815,9 +630,14 @@ var dateBefore = createRule({
 });
 var dateBetween = createRule({
   type: "dateBetween",
-  validator: (value, before, after) => {
+  validator: (value, before, after, options) => {
+    const { allowEqual = true } = options ?? {};
     if (isDate(value) && isDate(before) && isDate(after)) {
-      return toDate(value).getTime() > toDate(before).getTime() && toDate(value).getTime() < toDate(after).getTime();
+      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;
   },
@@ -825,21 +645,109 @@ var dateBetween = createRule({
     return `The date must be between ${formatLocaleDate(before)} and ${formatLocaleDate(after)}`;
   }
 });
-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",
+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;
@@ -852,6 +760,22 @@ var ipv4Address = createRule({
   },
   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 = ":") {
@@ -867,79 +791,106 @@ var macAddress = createRule({
   message: "The value is not a valid MAC Address"
 });
 var hexValid = (hex) => hex.toLowerCase().match(/^[0-9a-f]{2}$/);
-var checked = createRule({
-  type: "checked",
-  validator: (value) => {
-    if (isFilled(value)) {
-      return value === true;
+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: "The field must be checked"
-});
-var contains = createRule({
-  type: "contains",
-  validator(value, part) {
-    if (isFilled(value) && isFilled(part)) {
-      return value.includes(part);
+  message: ({ $value, $params: [count] }) => {
+    if (Array.isArray($value)) {
+      return `This list should have maximum ${count} items`;
     }
-    return true;
-  },
-  message({ $params: [part] }) {
-    return `The value must contain ${part}`;
+    return `The value length should not exceed ${count}`;
   }
 });
-var startsWith = createRule({
-  type: "startsWith",
-  validator(value, part) {
-    if (isFilled(value) && isFilled(part)) {
-      return value.startsWith(part);
+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: [part] }) {
-    return `The value must end with ${part}`;
+  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 endsWith = createRule({
-  type: "endsWith",
-  validator(value, part) {
-    if (isFilled(value) && isFilled(part)) {
-      return value.endsWith(part);
+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({ $params: [part] }) {
-    return `The value must end with ${part}`;
+  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 regex = createRule({
-  type: "regex",
-  validator(value, regexp) {
-    if (isFilled(value)) {
-      const filteredRegxp = Array.isArray(regexp) ? regexp : [regexp];
-      return matchRegex(value, ...filteredRegxp);
+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: "The value does not match the required pattern"
+  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 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;
-}
 function getValidEnumValues(obj) {
   const validKeys = Object.keys(obj).filter((k) => typeof obj[obj[k]] !== "number");
   const filtered = {};
@@ -965,23 +916,136 @@ function nativeEnum(enumLike) {
   );
   return rule;
 }
-function literal(literal2) {
-  const params = computed(() => toValue(literal2));
+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, literal3) => {
-        return literal3 === value;
+      (value, options2) => {
+        if (isFilled(value) && isFilled(options2, false)) {
+          return options2.includes(value);
+        }
+        return true;
       },
       [params]
     ),
-    ({ $params: [literal3] }) => `Value should be ${literal3}.`
+    ({ $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, checked, contains, dateAfter, dateBefore, dateBetween, decimal, email, endsWith, exactLength, exactValue, getSize, integer, ipv4Address, isDate, isEmpty, isFilled, isNumber, literal, macAddress, matchRegex, maxLength, maxValue, minLength, minValue, nativeEnum, not, numeric, oneOf, or, regex, required, requiredIf, requiredUnless, sameAs, startsWith, toDate, toNumber, type, url, withAsync, withMessage, withParams, withTooltip };
+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 };