@regle/rules 0.4.4 → 0.4.6-beta.1

package/dist/regle-rules.cjs

@@ -0,0 +1,876 @@
+'use strict';
+
+var core = require('@regle/core');
+var vue = require('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 = core.InternalRuleType.Inline;
+    validator = rule;
+  } else {
+    ({ _type, validator, _active, _params } = rule);
+  }
+  const newRule = core.createRule({
+    type: _type,
+    validator,
+    active: _active,
+    message: newMessage
+  });
+  const newParams = [..._params ?? []];
+  newRule._params = newParams;
+  newRule._message_patched = true;
+  if (typeof newRule === "function") {
+    const executedRule = newRule(...newParams);
+    executedRule._message_patched = true;
+    return executedRule;
+  } 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 = core.InternalRuleType.Inline;
+    validator = rule;
+  } else {
+    ({ _type, validator, _active, _params, _message } = rule);
+  }
+  const newRule = core.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) {
+  const validator = async (value, ...params) => {
+    return rule(value, ...params);
+  };
+  const newRule = core.createRule({
+    type: core.InternalRuleType.Async,
+    validator,
+    message: ""
+  });
+  newRule._params = newRule._params?.concat(depsArray);
+  return newRule(...depsArray ?? []);
+}
+function withParams(rule, depsArray) {
+  const validator = (value, ...params) => {
+    return rule(value, ...params);
+  };
+  const newRule = core.createRule({
+    type: core.InternalRuleType.Inline,
+    validator,
+    message: ""
+  });
+  newRule._params = newRule._params?.concat(depsArray);
+  return newRule(...depsArray);
+}
+function applyIf(_condition, rule) {
+  let _type;
+  let validator;
+  let _params = [];
+  let _message = "";
+  if (typeof rule === "function") {
+    _type = core.InternalRuleType.Inline;
+    validator = rule;
+    _params = [_condition];
+  } else {
+    ({ _type, validator, _message } = rule);
+    _params = rule._params?.concat([_condition]);
+  }
+  function newValidator(value, ...args) {
+    const [condition] = core.unwrapRuleParameters([_condition]);
+    if (condition) {
+      return validator(value, ...args);
+    }
+    return true;
+  }
+  function newActive(metadata) {
+    const [condition] = core.unwrapRuleParameters([_condition]);
+    return condition;
+  }
+  const newRule = core.createRule({
+    type: _type,
+    validator: newValidator,
+    active: newActive,
+    message: _message
+  });
+  const newParams = [..._params ?? []];
+  newRule._params = newParams;
+  if (typeof newRule === "function") {
+    const executedRule = newRule(...newParams);
+    executedRule._message_patched = true;
+    return executedRule;
+  } else {
+    return newRule;
+  }
+}
+
+// ../shared/utils/isEmpty.ts
+function isEmpty(value) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (value instanceof Date) {
+    return isNaN(value.getTime());
+  }
+  if (Array.isArray(value)) {
+    return false;
+  }
+  if (typeof value === "object" && value != null) {
+    return Object.keys(value).length === 0;
+  }
+  return !String(value).length;
+}
+
+// src/helpers/ruleHelpers/isFilled.ts
+function isFilled(value) {
+  return !isEmpty(typeof value === "string" ? value.trim() : value);
+}
+
+// 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/regex.ts
+function regex(_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 size(value) {
+  const _value = vue.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/isDate.ts
+function isDate(value) {
+  if (isEmpty(value)) {
+    return false;
+  }
+  try {
+    let possibleDate = null;
+    if (value instanceof Date) {
+      possibleDate = value;
+    } else if (typeof value === "number" && !isNaN(value)) {
+      possibleDate = new Date(value);
+    } else if (typeof value === "string") {
+      const date = new Date(value);
+      if (date.toString() === "Invalid Date") {
+        return false;
+      }
+      possibleDate = date;
+    }
+    return !!possibleDate;
+  } catch (e) {
+    return false;
+  }
+}
+
+// src/helpers/ruleHelpers/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/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;
+}
+
+// src/helpers/ruleHelpers/index.ts
+var ruleHelpers = {
+  isEmpty,
+  isFilled,
+  size,
+  regex,
+  isNumber,
+  isDate,
+  toDate,
+  toNumber
+};
+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 [null];
+      } 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 = core.createRule({
+    type: "and",
+    validator,
+    message: "The value does not match all of the provided validators"
+  });
+  newRule._params = _params;
+  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, ...params2) {
+    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, ...params2.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, ...params2) => {
+    const results = await Promise.all(computeRules(rules, value, ...params2));
+    return computeMetadata(results);
+  } : (value, ...params2) => {
+    const $rules = computeRules(rules, value, ...params2);
+    return computeMetadata($rules);
+  };
+  const newRule = core.createRule({
+    type: "or",
+    validator,
+    message: "The value does not match any of the provided validators"
+  });
+  newRule._params = params;
+  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 (ruleHelpers.isFilled(value)) {
+        const result = await validator(value, ...params);
+        return !result;
+      }
+      return true;
+    };
+  } else {
+    newValidator = (value, ...params) => {
+      if (ruleHelpers.isFilled(value)) {
+        return !validator(value, ...params);
+      }
+      return true;
+    };
+  }
+  const newRule = core.createRule({
+    type: "not",
+    validator: newValidator,
+    message: message ?? "Error"
+  });
+  newRule._params = _params;
+  return newRule;
+}
+var required = core.createRule({
+  type: "required",
+  validator: (value) => {
+    return ruleHelpers.isFilled(value);
+  },
+  message: "This field is required"
+});
+var maxLength = core.createRule({
+  type: "maxLength",
+  validator: (value, count) => {
+    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(count)) {
+      if (ruleHelpers.isNumber(count)) {
+        return ruleHelpers.size(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 maximum length allowed is ${count}`;
+  }
+});
+var requiredIf = core.createRule({
+  type: "required",
+  validator(value, condition) {
+    if (condition) {
+      return ruleHelpers.isFilled(value);
+    }
+    return true;
+  },
+  message: "This field is required",
+  active({ $params: [condition] }) {
+    return condition;
+  }
+});
+var alphaRegex = /^[a-zA-Z]*$/;
+var alpha = core.createRule({
+  type: "alpha",
+  validator(value) {
+    if (ruleHelpers.isEmpty(value)) {
+      return true;
+    }
+    return ruleHelpers.regex(value, alphaRegex);
+  },
+  message: "The value is not alphabetical"
+});
+var alphaNumRegex = /^[a-zA-Z0-9]*$/;
+var alphaNum = core.createRule({
+  type: "alpha",
+  validator(value) {
+    if (ruleHelpers.isEmpty(value)) {
+      return true;
+    }
+    return ruleHelpers.regex(value, alphaNumRegex);
+  },
+  message: "The value must be alpha-numeric"
+});
+var between = core.createRule({
+  type: "between",
+  validator: (value, min, max) => {
+    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(min) && ruleHelpers.isFilled(max)) {
+      const tValue = ruleHelpers.toNumber(value);
+      const tMin = ruleHelpers.toNumber(min);
+      const tMax = ruleHelpers.toNumber(max);
+      if (ruleHelpers.isNumber(tValue) && ruleHelpers.isNumber(tMin) && ruleHelpers.isNumber(tMax)) {
+        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 decimalRegex = /^[-]?\d*(\.\d+)?$/;
+var decimal = core.createRule({
+  type: "decimal",
+  validator(value) {
+    if (ruleHelpers.isEmpty(value)) {
+      return true;
+    }
+    return ruleHelpers.regex(value, decimalRegex);
+  },
+  message: "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 = core.createRule({
+  type: "email",
+  validator(value) {
+    if (ruleHelpers.isEmpty(value)) {
+      return true;
+    }
+    return ruleHelpers.regex(value, emailRegex);
+  },
+  message: "Value must be an valid email address"
+});
+var integerRegex = /(^[0-9]*$)|(^-[0-9]+$)/;
+var integer = core.createRule({
+  type: "integer",
+  validator(value) {
+    if (ruleHelpers.isEmpty(value)) {
+      return true;
+    }
+    return ruleHelpers.regex(value, integerRegex);
+  },
+  message: "Value must be an integer"
+});
+var maxValue = core.createRule({
+  type: "maxValue",
+  validator: (value, count) => {
+    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(count)) {
+      if (ruleHelpers.isNumber(count) && !isNaN(toNumber(value))) {
+        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] }) => {
+    return `The maximum value allowed is ${count}`;
+  }
+});
+var minLength = core.createRule({
+  type: "minLength",
+  validator: (value, count) => {
+    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(count)) {
+      if (ruleHelpers.isNumber(count)) {
+        return ruleHelpers.size(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 `This list should have at least ${count} items`;
+    }
+    return `This field should be at least ${count} characters long`;
+  }
+});
+var minValue = core.createRule({
+  type: "minValue",
+  validator: (value, count) => {
+    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(count)) {
+      if (ruleHelpers.isNumber(count) && !isNaN(toNumber(value))) {
+        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] }) => {
+    return `The minimum value allowed is ${count}`;
+  }
+});
+var exactLength = core.createRule({
+  type: "exactLength",
+  validator: (value, count) => {
+    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(count)) {
+      if (ruleHelpers.isNumber(count)) {
+        return ruleHelpers.size(value) === count;
+      }
+      console.warn(`[minLength] Parameter isn't a number, got parameter: ${count}`);
+      return false;
+    }
+    return true;
+  },
+  message: ({ $params: [count] }) => {
+    return `This field should be exactly ${count} characters long`;
+  }
+});
+var numericRegex = /^\d*(\.\d+)?$/;
+var numeric = core.createRule({
+  type: "numeric",
+  validator(value) {
+    if (ruleHelpers.isEmpty(value)) {
+      return true;
+    }
+    return ruleHelpers.regex(value, numericRegex);
+  },
+  message: "This field must be numeric"
+});
+var requiredUnless = core.createRule({
+  type: "required",
+  validator(value, condition) {
+    if (!condition) {
+      return ruleHelpers.isFilled(value);
+    }
+    return true;
+  },
+  message: "This field is required",
+  active({ $params: [condition] }) {
+    return !condition;
+  }
+});
+var sameAs = core.createRule({
+  type: "sameAs",
+  validator(value, target, otherName = "other") {
+    if (ruleHelpers.isEmpty(value)) {
+      return true;
+    }
+    return value === target;
+  },
+  message({ $params: [_, otherName] }) {
+    return `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 = core.createRule({
+  type: "url",
+  validator(value) {
+    if (ruleHelpers.isEmpty(value)) {
+      return true;
+    }
+    return ruleHelpers.regex(value, urlRegex);
+  },
+  message: "The value is not a valid URL address"
+});
+
+// src/utils/getLocale.util.ts
+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));
+  }
+  return "?";
+}
+
+// src/rules/dateAfter.ts
+var dateAfter = core.createRule({
+  type: "dateAfter",
+  validator: (value, after) => {
+    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(after)) {
+      if (ruleHelpers.isDate(value) && ruleHelpers.isDate(after)) {
+        const result = ruleHelpers.toDate(value).getTime() > ruleHelpers.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 true;
+  },
+  message: ({ $params: [after], error }) => {
+    if (error === "value-or-paramater-not-a-date") {
+      return "The inputs must be Dates";
+    }
+    return `The date must be after ${formatLocaleDate(after)}`;
+  }
+});
+var dateBefore = core.createRule({
+  type: "dateBefore",
+  validator: (value, before) => {
+    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(before)) {
+      if (ruleHelpers.isDate(value) && ruleHelpers.isDate(before)) {
+        const result = ruleHelpers.toDate(value).getTime() < ruleHelpers.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 true;
+  },
+  message: ({ $params: [before], error }) => {
+    if (error === "value-or-paramater-not-a-date") {
+      return "The fields must be Dates";
+    }
+    return `The date must be before ${formatLocaleDate(before)}`;
+  }
+});
+var dateBetween = core.createRule({
+  type: "dateBetween",
+  validator: (value, before, after) => {
+    if (ruleHelpers.isDate(value) && ruleHelpers.isDate(before) && ruleHelpers.isDate(after)) {
+      return ruleHelpers.toDate(value).getTime() > ruleHelpers.toDate(before).getTime() && ruleHelpers.toDate(value).getTime() < ruleHelpers.toDate(after).getTime();
+    }
+    return true;
+  },
+  message: ({ $params: [before, after] }) => {
+    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 ipAddress = core.createRule({
+  type: "ipAddress",
+  validator(value) {
+    if (ruleHelpers.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 IP address"
+});
+var macAddress = core.createRule({
+  type: "macAddress",
+  validator(value, separator = ":") {
+    if (ruleHelpers.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 checked = core.createRule({
+  type: "checked",
+  validator: (value) => {
+    if (ruleHelpers.isFilled(value)) {
+      return value === true;
+    }
+    return true;
+  },
+  message: "This field must be checked"
+});
+var contains = core.createRule({
+  type: "contains",
+  validator(value, part) {
+    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(part)) {
+      return value.includes(part);
+    }
+    return true;
+  },
+  message({ $params: [part] }) {
+    return `Field must contain ${part}`;
+  }
+});
+var startsWith = core.createRule({
+  type: "startsWith",
+  validator(value, part) {
+    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(part)) {
+      return value.startsWith(part);
+    }
+    return true;
+  },
+  message({ $params: [part] }) {
+    return `Field must end with ${part}`;
+  }
+});
+var endsWith = core.createRule({
+  type: "endsWith",
+  validator(value, part) {
+    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(part)) {
+      return value.endsWith(part);
+    }
+    return true;
+  },
+  message({ $params: [part] }) {
+    return `Field must end with ${part}`;
+  }
+});
+var regex2 = core.createRule({
+  type: "regex",
+  validator(value, ...regexp) {
+    if (ruleHelpers.isFilled(value)) {
+      return ruleHelpers.regex(value, ...regexp);
+    }
+    return true;
+  },
+  message: "This field does not match the required pattern"
+});
+
+exports.alpha = alpha;
+exports.alphaNum = alphaNum;
+exports.and = and;
+exports.applyIf = applyIf;
+exports.between = between;
+exports.checked = checked;
+exports.contains = contains;
+exports.dateAfter = dateAfter;
+exports.dateBefore = dateBefore;
+exports.dateBetween = dateBetween;
+exports.decimal = decimal;
+exports.email = email;
+exports.endsWith = endsWith;
+exports.exactLength = exactLength;
+exports.integer = integer;
+exports.ipAddress = ipAddress;
+exports.macAddress = macAddress;
+exports.maxLength = maxLength;
+exports.maxValue = maxValue;
+exports.minLength = minLength;
+exports.minValue = minValue;
+exports.not = not;
+exports.numeric = numeric;
+exports.or = or;
+exports.regex = regex2;
+exports.required = required;
+exports.requiredIf = requiredIf;
+exports.requiredUnless = requiredUnless;
+exports.ruleHelpers = ruleHelpers;
+exports.sameAs = sameAs;
+exports.startsWith = startsWith;
+exports.url = url;
+exports.withAsync = withAsync;
+exports.withMessage = withMessage;
+exports.withParams = withParams;
+exports.withTooltip = withTooltip;