@regle/rules 0.1.5 → 0.1.7

package/dist/index.cjs

@@ -0,0 +1,823 @@
+'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
+  });
+  newRule._params = _params;
+  newRule._patched = true;
+  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 = depsArray;
+  return newRule;
+}
+function withParams(rule, depsArray) {
+  const validator = (value, ...params) => {
+    return rule(value, ...params);
+  };
+  const newRule = core.createRule({
+    type: core.InternalRuleType.Inline,
+    validator,
+    message: ""
+  });
+  newRule._params = depsArray;
+  return newRule;
+}
+function applyIf(_condition, rule) {
+  let _type;
+  let validator;
+  let _params;
+  let _message = "";
+  if (typeof rule === "function") {
+    _type = core.InternalRuleType.Inline;
+    validator = rule;
+  } else {
+    ({ _type, validator, _params, _message } = rule);
+    _params?.push(_condition);
+  }
+  function newValidator(value, ...args) {
+    const [condition] = core.unwrapRuleParameters([_condition]);
+    if (condition) {
+      return validator(value, ...args);
+    }
+    return true;
+  }
+  function newActive(value, metadata) {
+    const [condition] = core.unwrapRuleParameters([_condition]);
+    return condition;
+  }
+  const newRule = core.createRule({
+    type: _type,
+    validator: newValidator,
+    active: newActive,
+    message: _message
+  });
+  newRule._params = _params;
+  return newRule;
+}
+
+// src/helpers/ruleHelpers/isEmpty.ts
+function isEmpty(value) {
+  if (value === void 0 || value === null) {
+    return true;
+  }
+  if (value === false) {
+    return false;
+  }
+  if (value instanceof Date) {
+    return isNaN(value.getTime());
+  }
+  if (Array.isArray(value)) {
+    return value.length === 0;
+  }
+  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) {
+    const isPadded = argument.trim() !== argument;
+    if (isPadded) {
+      return NaN;
+    }
+    return +argument;
+  }
+  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) && ruleHelpers.isNumber(value)) {
+        return value <= count;
+      }
+      console.warn(
+        `[maxValue] Value or parameter isn't a number, got value: ${value}, parameter: ${count}`
+      );
+      return false;
+    }
+    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) && ruleHelpers.isNumber(value)) {
+        return value >= count;
+      }
+      console.warn(
+        `[minValue] Value or parameter isn't a number, got value: ${value}, parameter: ${count}`
+      );
+      return false;
+    }
+    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) {
+    if (ruleHelpers.isEmpty(value)) {
+      return true;
+    }
+    return value === target;
+  },
+  message(_, { $params: [target] }) {
+    return `Value must be equal to "${target}"`;
+  }
+});
+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"
+});
+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] }) => {
+    return `The date must be after ${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 ${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 ${before} and ${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;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/helpers/withMessage.ts","../src/helpers/withAsync.ts","../src/helpers/withParams.ts","../src/helpers/applyIf.ts","../src/helpers/ruleHelpers/isEmpty.ts","../src/helpers/ruleHelpers/isFilled.ts","../src/helpers/ruleHelpers/isNumber.ts","../src/helpers/ruleHelpers/regex.ts","../src/helpers/ruleHelpers/size.ts","../src/helpers/ruleHelpers/isDate.ts","../src/helpers/ruleHelpers/toDate.ts","../src/helpers/ruleHelpers/toNumber.ts","../src/helpers/ruleHelpers/index.ts","../src/helpers/and.ts","../src/helpers/or.ts","../src/helpers/not.ts","../src/rules/required.ts","../src/rules/maxLength.ts","../src/rules/requiredIf.ts","../src/rules/alpha.ts","../src/rules/alphaNum.ts","../src/rules/between.ts","../src/rules/decimal.ts","../src/rules/email.ts","../src/rules/integer.ts","../src/rules/maxValue.ts","../src/rules/minLength.ts","../src/rules/minValue.ts","../src/rules/exactLength.ts","../src/rules/numeric.ts","../src/rules/requiredUnless.ts","../src/rules/sameAs.ts","../src/rules/url.ts","../src/rules/dateAfter.ts","../src/rules/dateBefore.ts","../src/rules/dateBetween.ts","../src/rules/ipAddress.ts","../src/rules/macAddress.ts","../src/rules/checked.ts","../src/rules/contains.ts","../src/rules/startsWith.ts","../src/rules/endsWith.ts","../src/rules/regex.ts"],"names":["InternalRuleType","createRule","unwrapRuleParameters","unref","rules","params","numeric","regex"],"mappings":";;;;;;AAqDO,SAAS,WAAA,CACd,MACA,UAK6F,EAAA;AAC7F,EAAI,IAAA,KAAA;AACJ,EAAI,IAAA,SAAA;AACJ,EAAI,IAAA,OAAA;AAIJ,EAAI,IAAA,OAAA;AAEJ,EAAA,IAAI,OAAO,IAAA,KAAS,UAAc,IAAA,EAAE,gBAAgB,IAAO,CAAA,EAAA;AACzD,IAAA,KAAA,GAAQA,qBAAiB,CAAA,MAAA;AACzB,IAAY,SAAA,GAAA,IAAA;AAAA,GACP,MAAA;AACL,IAAA,CAAC,EAAE,KAAA,EAAO,SAAW,EAAA,OAAA,EAAS,SAAY,GAAA,IAAA;AAAA;AAG5C,EAAA,MAAM,UAAUC,eAAW,CAAA;AAAA,IACzB,IAAM,EAAA,KAAA;AAAA,IACN,SAAA;AAAA,IACA,MAAQ,EAAA,OAAA;AAAA,IACR,OAAS,EAAA;AAAA,GACV,CAAA;AAED,EAAA,OAAA,CAAQ,OAAU,GAAA,OAAA;AAClB,EAAA,OAAA,CAAQ,QAAW,GAAA,IAAA;AAEnB,EAAO,OAAA,OAAA;AACT;AC9EO,SAAS,SAAA,CAQd,MACA,SACmF,EAAA;AACnF,EAAM,MAAA,SAAA,GAAY,OAAO,KAAA,EAAA,GAAkC,MAAkB,KAAA;AAC3E,IAAO,OAAA,IAAA,CAAK,KAAO,EAAA,GAAI,MAAc,CAAA;AAAA,GACvC;AAEA,EAAA,MAAM,UAAUA,eAAW,CAAA;AAAA,IACzB,MAAMD,qBAAiB,CAAA,KAAA;AAAA,IACvB,SAAA;AAAA,IACA,OAAS,EAAA;AAAA,GACV,CAAA;AAED,EAAA,OAAA,CAAQ,OAAU,GAAA,SAAA;AAElB,EAAO,OAAA,OAAA;AACT;ACxBO,SAAS,UAAA,CAMd,MACA,SACmF,EAAA;AACnF,EAAM,MAAA,SAAA,GAAY,CAAC,KAAA,EAAA,GAAkC,MAAkB,KAAA;AACrE,IAAO,OAAA,IAAA,CAAK,KAAO,EAAA,GAAI,MAAc,CAAA;AAAA,GACvC;AAEA,EAAA,MAAM,UAAUC,eAAW,CAAA;AAAA,IACzB,MAAMD,qBAAiB,CAAA,MAAA;AAAA,IACvB,SAAA;AAAA,IACA,OAAS,EAAA;AAAA,GACV,CAAA;AAED,EAAA,OAAA,CAAQ,OAAU,GAAA,SAAA;AAElB,EAAO,OAAA,OAAA;AACT;ACpBO,SAAS,OAAA,CASd,YACA,IAGoD,EAAA;AACpD,EAAI,IAAA,KAAA;AACJ,EAAI,IAAA,SAAA;AACJ,EAAI,IAAA,OAAA;AACJ,EAAA,IAAI,QAIA,GAAA,EAAA;AAEJ,EAAI,IAAA,OAAO,SAAS,UAAY,EAAA;AAC9B,IAAA,KAAA,GAAQA,qBAAiB,CAAA,MAAA;AACzB,IAAY,SAAA,GAAA,IAAA;AAAA,GACP,MAAA;AACL,IAAA,CAAC,EAAE,KAAA,EAAO,SAAW,EAAA,OAAA,EAAS,UAAa,GAAA,IAAA;AAC3C,IAAA,OAAA,EAAS,KAAK,UAAU,CAAA;AAAA;AAG1B,EAAS,SAAA,YAAA,CAAa,UAAe,IAAa,EAAA;AAChD,IAAA,MAAM,CAAC,SAAS,CAAA,GAAIE,yBAAgC,CAAA,CAAC,UAAU,CAAC,CAAA;AAChE,IAAA,IAAI,SAAW,EAAA;AACb,MAAO,OAAA,SAAA,CAAU,KAAO,EAAA,GAAG,IAAI,CAAA;AAAA;AAEjC,IAAO,OAAA,IAAA;AAAA;AAGT,EAAS,SAAA,SAAA,CAAU,OAAY,QAAiD,EAAA;AAC9E,IAAA,MAAM,CAAC,SAAS,CAAA,GAAIA,yBAAgC,CAAA,CAAC,UAAU,CAAC,CAAA;AAChE,IAAO,OAAA,SAAA;AAAA;AAGT,EAAA,MAAM,UAAUD,eAAW,CAAA;AAAA,IACzB,IAAM,EAAA,KAAA;AAAA,IACN,SAAW,EAAA,YAAA;AAAA,IACX,MAAQ,EAAA,SAAA;AAAA,IACR,OAAS,EAAA;AAAA,GACV,CAAA;AAED,EAAA,OAAA,CAAQ,OAAU,GAAA,OAAA;AAElB,EAAO,OAAA,OAAA;AACT;;;AC/DO,SAAS,QAAQ,KAA8D,EAAA;AACpF,EAAI,IAAA,KAAA,KAAU,KAAa,CAAA,IAAA,KAAA,KAAU,IAAM,EAAA;AACzC,IAAO,OAAA,IAAA;AAAA;AAGT,EAAA,IAAI,UAAU,KAAO,EAAA;AACnB,IAAO,OAAA,KAAA;AAAA;AAGT,EAAA,IAAI,iBAAiB,IAAM,EAAA;AAEzB,IAAO,OAAA,KAAA,CAAM,KAAM,CAAA,OAAA,EAAS,CAAA;AAAA;AAE9B,EAAI,IAAA,KAAA,CAAM,OAAQ,CAAA,KAAK,CAAG,EAAA;AACxB,IAAA,OAAO,MAAM,MAAW,KAAA,CAAA;AAAA;AAE1B,EAAA,IAAI,OAAO,KAAA,KAAU,QAAY,IAAA,KAAA,IAAS,IAAM,EAAA;AAC9C,IAAA,OAAO,MAAO,CAAA,IAAA,CAAK,KAAK,CAAA,CAAE,MAAW,KAAA,CAAA;AAAA;AAEvC,EAAO,OAAA,CAAC,MAAO,CAAA,KAAK,CAAE,CAAA,MAAA;AACxB;;;ACpBO,SAAS,SAA4B,KAAmC,EAAA;AAC7E,EAAO,OAAA,CAAC,QAAQ,OAAO,KAAA,KAAU,WAAW,KAAM,CAAA,IAAA,KAAS,KAAK,CAAA;AAClE;;;ACJO,SAAS,SAAS,KAAiC,EAAA;AACxD,EAAI,IAAA,KAAA,IAAS,MAAa,OAAA,KAAA;AAAA,OACjB,IAAA,OAAO,UAAU,QAAU,EAAA;AAClC,IAAO,OAAA,KAAA;AAAA,GACT,MAAA,IAAW,KAAM,CAAA,KAAK,CAAG,EAAA;AACvB,IAAO,OAAA,KAAA;AAAA,GACF,MAAA;AACL,IAAO,OAAA,IAAA;AAAA;AAEX;;;ACPO,SAAS,KAAA,CAAM,WAA+C,IAAyB,EAAA;AAC5F,EAAI,IAAA,OAAA,CAAQ,MAAM,CAAG,EAAA;AACnB,IAAO,OAAA,IAAA;AAAA;AAET,EAAA,MAAM,QAAQ,OAAO,MAAA,KAAW,QAAW,GAAA,MAAA,CAAO,UAAa,GAAA,MAAA;AAC/D,EAAO,OAAA,IAAA,CAAK,KAAM,CAAA,CAAC,GAAQ,KAAA;AACzB,IAAA,GAAA,CAAI,SAAY,GAAA,CAAA;AAChB,IAAO,OAAA,GAAA,CAAI,KAAK,KAAK,CAAA;AAAA,GACtB,CAAA;AACH;ACRO,SAAS,KAAK,KAAwE,EAAA;AAC3F,EAAM,MAAA,MAAA,GAASE,UAAM,KAAK,CAAA;AAC1B,EAAA,IAAI,KAAM,CAAA,OAAA,CAAQ,MAAM,CAAA,SAAU,MAAO,CAAA,MAAA;AACzC,EAAI,IAAA,OAAO,WAAW,QAAU,EAAA;AAC9B,IAAO,OAAA,MAAA,CAAO,IAAK,CAAA,MAAM,CAAE,CAAA,MAAA;AAAA;AAE7B,EAAI,IAAA,OAAO,WAAW,QAAU,EAAA;AAC9B,IAAI,IAAA,KAAA,CAAM,MAAM,CAAG,EAAA;AACjB,MAAO,OAAA,CAAA;AAAA;AAET,IAAO,OAAA,MAAA;AAAA;AAET,EAAO,OAAA,MAAA,CAAO,MAAM,CAAE,CAAA,MAAA;AACxB;;;ACdO,SAAS,OAAO,KAA+B,EAAA;AACpD,EAAI,IAAA,OAAA,CAAQ,KAAK,CAAG,EAAA;AAClB,IAAO,OAAA,KAAA;AAAA;AAET,EAAI,IAAA;AACF,IAAA,IAAI,YAA4B,GAAA,IAAA;AAChC,IAAA,IAAI,iBAAiB,IAAM,EAAA;AACzB,MAAe,YAAA,GAAA,KAAA;AAAA,eACN,OAAO,KAAA,KAAU,YAAY,CAAC,KAAA,CAAM,KAAK,CAAG,EAAA;AACrD,MAAe,YAAA,GAAA,IAAI,KAAK,KAAK,CAAA;AAAA,KAC/B,MAAA,IAAW,OAAO,KAAA,KAAU,QAAU,EAAA;AACpC,MAAM,MAAA,IAAA,GAAO,IAAI,IAAA,CAAK,KAAK,CAAA;AAC3B,MAAI,IAAA,IAAA,CAAK,QAAS,EAAA,KAAM,cAAgB,EAAA;AACtC,QAAO,OAAA,KAAA;AAAA;AAET,MAAe,YAAA,GAAA,IAAA;AAAA;AAEjB,IAAA,OAAO,CAAC,CAAC,YAAA;AAAA,WACF,CAAG,EAAA;AACV,IAAO,OAAA,KAAA;AAAA;AAEX;;;ACrBO,SAAS,OAAO,QAA+C,EAAA;AACpE,EAAA,MAAM,MAAS,GAAA,MAAA,CAAO,SAAU,CAAA,QAAA,CAAS,KAAK,QAAQ,CAAA;AACtD,EAAA,IAAI,YAAY,IAAM,EAAA;AACpB,IAAO,uBAAA,IAAI,KAAK,GAAG,CAAA;AAAA,aAEnB,QAAoB,YAAA,IAAA,IACnB,OAAO,QAAa,KAAA,QAAA,IAAY,WAAW,eAC5C,EAAA;AACA,IAAA,OAAO,IAAI,IAAA,CAAK,QAAS,CAAA,OAAA,EAAS,CAAA;AAAA,GACzB,MAAA,IAAA,OAAO,QAAa,KAAA,QAAA,IAAY,WAAW,iBAAmB,EAAA;AACvE,IAAO,OAAA,IAAI,KAAK,QAAQ,CAAA;AAAA,GACf,MAAA,IAAA,OAAO,QAAa,KAAA,QAAA,IAAY,WAAW,iBAAmB,EAAA;AACvE,IAAO,OAAA,IAAI,KAAK,QAAQ,CAAA;AAAA,GACnB,MAAA;AACL,IAAO,uBAAA,IAAI,KAAK,GAAG,CAAA;AAAA;AAEvB;;;ACfO,SAAS,SAAgD,QAAqB,EAAA;AACnF,EAAI,IAAA,OAAO,aAAa,QAAU,EAAA;AAChC,IAAO,OAAA,QAAA;AAAA,GACT,MAAA,IAAW,YAAY,IAAM,EAAA;AAC3B,IAAM,MAAA,QAAA,GAAW,QAAS,CAAA,IAAA,EAAW,KAAA,QAAA;AACrC,IAAA,IAAI,QAAU,EAAA;AACZ,MAAO,OAAA,GAAA;AAAA;AAET,IAAA,OAAO,CAAC,QAAA;AAAA;AAEV,EAAO,OAAA,GAAA;AACT;;;ACLO,IAAM,WAAc,GAAA;AAAA,EACzB,OAAA;AAAA,EACA,QAAA;AAAA,EACA,IAAA;AAAA,EACA,KAAA;AAAA,EACA,QAAA;AAAA,EACA,MAAA;AAAA,EACA,MAAA;AAAA,EACA;AACF;ACJO,SAAS,OACX,KAMH,EAAA;AACA,EAAA,MAAM,cAAiB,GAAA,KAAA,CAAM,IAAK,CAAA,CAAC,IAAS,KAAA;AAC1C,IAAI,IAAA,OAAO,SAAS,UAAY,EAAA;AAC9B,MAAO,OAAA,IAAA,CAAK,YAAY,IAAS,KAAA,eAAA;AAAA,KAC5B,MAAA;AACL,MAAA,OAAO,IAAK,CAAA,MAAA;AAAA;AACd,GACD,CAAA;AAED,EAAA,MAAM,OAAU,GAAA,KAAA,CACb,GAAI,CAAA,CAAC,IAAS,KAAA;AACb,IAAI,IAAA,OAAO,SAAS,UAAY,EAAA;AAC9B,MAAO,OAAA,IAAA;AAAA,KACF,MAAA;AACL,MAAA,MAAM,UAAU,IAAK,CAAA,OAAA;AACrB,MAAI,IAAA,CAAC,SAAS,MAAQ,EAAA;AACpB,QAAA,OAAO,CAAC,IAAI,CAAA;AAAA,OACP,MAAA;AACL,QAAO,OAAA,OAAA;AAAA;AACT;AACF,GACD,EACA,IAAK,EAAA,CACL,OAAO,CAAC,KAAA,KAAwB,CAAC,CAAC,KAAK,CAAA;AAE1C,EAAS,SAAA,YAAA,CAAaC,MAAoB,EAAA,KAAA,EAAA,GAAe,MAAe,EAAA;AACtE,IAAA,MAAM,SAAgB,EAAC;AACvB,IAAA,IAAI,UAAa,GAAA,CAAA;AAEjB,IAAA,KAAA,IAAS,QAAQA,MAAO,EAAA;AACtB,MAAI,IAAA,OAAO,SAAS,UAAY,EAAA;AAC9B,QAAO,MAAA,CAAA,IAAA,CAAK,IAAK,CAAA,KAAK,CAAC,CAAA;AACvB,QAAA,UAAA,EAAA;AAAA,OACK,MAAA;AACL,QAAM,MAAA,YAAA,GAAe,IAAK,CAAA,OAAA,EAAS,MAAU,IAAA,CAAA;AAC7C,QAAO,MAAA,CAAA,IAAA,CAAK,IAAK,CAAA,SAAA,CAAU,KAAO,EAAA,GAAG,OAAO,KAAM,CAAA,UAAA,EAAY,YAAY,CAAC,CAAC,CAAA;AAC5E,QAAA,IAAI,YAAc,EAAA;AAChB,UAAc,UAAA,IAAA,YAAA;AAAA;AAChB;AACF;AAGF,IAAO,OAAA,MAAA;AAAA;AAGT,EAAA,SAAS,gBACP,OACiD,EAAA;AACjD,IAAA,MAAM,sBAAsB,OAAQ,CAAA,IAAA,CAAK,CAAC,CAAM,KAAA,OAAO,MAAM,SAAS,CAAA;AACtE,IAAA,IAAI,mBAAqB,EAAA;AACvB,MAAO,OAAA;AAAA,QACL,MAAQ,EAAA,OAAA,CAAQ,KAAM,CAAA,CAAC,MAAW,KAAA;AAChC,UAAI,IAAA,OAAO,WAAW,SAAW,EAAA;AAC/B,YAAA,OAAO,CAAC,CAAC,MAAA;AAAA;AAEX,UAAA,OAAO,MAAO,CAAA,MAAA;AAAA,SACf,CAAA;AAAA,QACD,GAAG,OAAA,CAAQ,MAAO,CAAA,CAAC,KAAK,MAAW,KAAA;AACjC,UAAI,IAAA,OAAO,WAAW,SAAW,EAAA;AAC/B,YAAO,OAAA,GAAA;AAAA;AAET,UAAA,MAAM,EAAE,MAAA,EAAQ,GAAG,IAAA,EAAS,GAAA,MAAA;AAC5B,UAAA,OAAO,EAAE,GAAG,GAAK,EAAA,GAAG,IAAK,EAAA;AAAA,SAC3B,EAAG,EAAE;AAAA,OACP;AAAA,KACK,MAAA;AACL,MAAA,OAAO,QAAQ,KAAM,CAAA,CAAC,MAAW,KAAA,CAAC,CAAC,MAAM,CAAA;AAAA;AAC3C;AAGF,EAAI,IAAA,SAAA;AAEJ,EAAI,IAAA,CAAC,CAAC,KAAA,CAAM,MAAQ,EAAA;AAClB,IAAY,SAAA,GAAA,cAAA,GACR,OAAO,KAAA,EAAA,GAAkC,MAAkB,KAAA;AACzD,MAAM,MAAA,OAAA,GAAU,MAAM,OAAQ,CAAA,GAAA,CAAI,aAAa,KAAO,EAAA,KAAA,EAAO,GAAG,MAAM,CAAC,CAAA;AACvE,MAAA,OAAO,gBAAgB,OAAO,CAAA;AAAA,KAChC,GACA,CAAC,KAAA,EAAA,GAAkC,MAAkB,KAAA;AACnD,MAAA,MAAM,MAAS,GAAA,YAAA,CAAa,KAAO,EAAA,KAAA,EAAO,GAAG,MAAM,CAAA;AACnD,MAAA,OAAO,gBAAgB,MAAM,CAAA;AAAA,KAC/B;AAAA,GACC,MAAA;AACL,IAAA,SAAA,GAAY,CAAC,KAAe,KAAA;AAC1B,MAAO,OAAA,KAAA;AAAA,KACT;AAAA;AAGF,EAAA,MAAM,UAAUH,eAAW,CAAA;AAAA,IACzB,IAAM,EAAA,KAAA;AAAA,IACN,SAAA;AAAA,IACA,OAAS,EAAA;AAAA,GACV,CAAA;AAED,EAAA,OAAA,CAAQ,OAAU,GAAA,OAAA;AAElB,EAAO,OAAA,OAAA;AACT;AC5GO,SAAS,MACX,KAMH,EAAA;AACA,EAAA,MAAM,cAAiB,GAAA,KAAA,CAAM,IAAK,CAAA,CAAC,IAAS,KAAA;AAC1C,IAAI,IAAA,OAAO,SAAS,UAAY,EAAA;AAC9B,MAAO,OAAA,IAAA,CAAK,YAAY,IAAS,KAAA,eAAA;AAAA,KAC5B,MAAA;AACL,MAAA,OAAO,IAAK,CAAA,MAAA;AAAA;AACd,GACD,CAAA;AAED,EAAA,MAAM,MAAS,GAAA,KAAA,CACZ,GAAI,CAAA,CAAC,IAAS,KAAA;AACb,IAAI,IAAA,OAAO,SAAS,UAAY,EAAA;AAC9B,MAAO,OAAA,IAAA;AAAA,KACF,MAAA;AACL,MAAA,OAAO,IAAK,CAAA,OAAA;AAAA;AACd,GACD,EACA,IAAK,EAAA,CACL,OAAO,CAAC,KAAA,KAAwB,CAAC,CAAC,KAAK,CAAA;AAE1C,EAAS,SAAA,YAAA,CAAaG,MAAoB,EAAA,KAAA,EAAA,GAAeC,OAAe,EAAA;AACtE,IAAA,MAAM,SAAgB,EAAC;AACvB,IAAA,IAAI,UAAa,GAAA,CAAA;AAEjB,IAAA,KAAA,IAAS,QAAQD,MAAO,EAAA;AACtB,MAAI,IAAA,OAAO,SAAS,UAAY,EAAA;AAC9B,QAAO,MAAA,CAAA,IAAA,CAAK,IAAK,CAAA,KAAK,CAAC,CAAA;AACvB,QAAA,UAAA,EAAA;AAAA,OACK,MAAA;AACL,QAAM,MAAA,YAAA,GAAe,IAAK,CAAA,OAAA,EAAS,MAAU,IAAA,CAAA;AAC7C,QAAO,MAAA,CAAA,IAAA,CAAK,IAAK,CAAA,SAAA,CAAU,KAAO,EAAA,GAAGC,QAAO,KAAM,CAAA,UAAA,EAAY,YAAY,CAAC,CAAC,CAAA;AAC5E,QAAA,IAAI,YAAc,EAAA;AAChB,UAAc,UAAA,IAAA,YAAA;AAAA;AAChB;AACF;AAGF,IAAO,OAAA,MAAA;AAAA;AAGT,EAAA,SAAS,gBACP,OACiD,EAAA;AACjD,IAAA,MAAM,sBAAsB,OAAQ,CAAA,IAAA,CAAK,CAAC,CAAM,KAAA,OAAO,MAAM,SAAS,CAAA;AACtE,IAAA,IAAI,mBAAqB,EAAA;AACvB,MAAO,OAAA;AAAA,QACL,MAAQ,EAAA,OAAA,CAAQ,IAAK,CAAA,CAAC,MAAW,KAAA;AAC/B,UAAI,IAAA,OAAO,WAAW,SAAW,EAAA;AAC/B,YAAA,OAAO,CAAC,CAAC,MAAA;AAAA;AAEX,UAAA,OAAO,MAAO,CAAA,MAAA;AAAA,SACf,CAAA;AAAA,QACD,GAAG,OAAA,CAAQ,MAAO,CAAA,CAAC,KAAK,MAAW,KAAA;AACjC,UAAI,IAAA,OAAO,WAAW,SAAW,EAAA;AAC/B,YAAO,OAAA,GAAA;AAAA;AAET,UAAA,MAAM,EAAE,MAAA,EAAQ,GAAG,IAAA,EAAS,GAAA,MAAA;AAC5B,UAAA,OAAO,EAAE,GAAG,GAAK,EAAA,GAAG,IAAK,EAAA;AAAA,SAC3B,EAAG,EAAE;AAAA,OACP;AAAA,KACK,MAAA;AACL,MAAA,OAAO,QAAQ,IAAK,CAAA,CAAC,MAAW,KAAA,CAAC,CAAC,MAAM,CAAA;AAAA;AAC1C;AAGF,EAAA,MAAM,SAAY,GAAA,cAAA,GACd,OAAO,KAAA,EAAA,GAAkCA,OAAkB,KAAA;AACzD,IAAM,MAAA,OAAA,GAAU,MAAM,OAAQ,CAAA,GAAA,CAAI,aAAa,KAAO,EAAA,KAAA,EAAO,GAAGA,OAAM,CAAC,CAAA;AACvE,IAAA,OAAO,gBAAgB,OAAO,CAAA;AAAA,GAChC,GACA,CAAC,KAAA,EAAA,GAAkCA,OAAkB,KAAA;AACnD,IAAA,MAAM,MAAS,GAAA,YAAA,CAAa,KAAO,EAAA,KAAA,EAAO,GAAGA,OAAM,CAAA;AACnD,IAAA,OAAO,gBAAgB,MAAM,CAAA;AAAA,GAC/B;AAEJ,EAAA,MAAM,UAAUJ,eAAW,CAAA;AAAA,IACzB,IAAM,EAAA,IAAA;AAAA,IACN,SAAA;AAAA,IACA,OAAS,EAAA;AAAA,GACV,CAAA;AAED,EAAA,OAAA,CAAQ,OAAU,GAAA,MAAA;AAElB,EAAO,OAAA,OAAA;AACT;AC1FO,SAAS,GAAA,CASd,MAGA,OAKyD,EAAA;AACzD,EAAI,IAAA,KAAA;AACJ,EAAI,IAAA,SAAA;AACJ,EAAI,IAAA,YAAA;AACJ,EAAI,IAAA,OAAA;AAEJ,EAAI,IAAA,MAAA;AAEJ,EAAI,IAAA,OAAO,SAAS,UAAY,EAAA;AAC9B,IAAY,SAAA,GAAA,IAAA;AACZ,IAAS,MAAA,GAAA,IAAA,CAAK,YAAY,IAAS,KAAA,eAAA;AAAA,GAC9B,MAAA;AACL,IAAA,CAAC,EAAE,KAAA,EAAO,SAAW,EAAA,OAAA,EAAY,GAAA,IAAA;AACjC,IAAA,MAAA,GAAS,IAAK,CAAA,MAAA;AAAA;AAGhB,EAAA,IAAI,MAAQ,EAAA;AACV,IAAe,YAAA,GAAA,OAAO,UAAe,MAAkB,KAAA;AACrD,MAAI,IAAA,WAAA,CAAY,QAAS,CAAA,KAAK,CAAG,EAAA;AAC/B,QAAA,MAAM,MAAS,GAAA,MAAM,SAAU,CAAA,KAAA,EAAO,GAAI,MAAc,CAAA;AACxD,QAAA,OAAO,CAAC,MAAA;AAAA;AAEV,MAAO,OAAA,IAAA;AAAA,KACT;AAAA,GACK,MAAA;AACL,IAAe,YAAA,GAAA,CAAC,UAAe,MAAkB,KAAA;AAC/C,MAAI,IAAA,WAAA,CAAY,QAAS,CAAA,KAAK,CAAG,EAAA;AAC/B,QAAA,OAAO,CAAC,SAAA,CAAU,KAAO,EAAA,GAAI,MAAc,CAAA;AAAA;AAE7C,MAAO,OAAA,IAAA;AAAA,KACT;AAAA;AAGF,EAAA,MAAM,UAAUA,eAAW,CAAA;AAAA,IACzB,IAAM,EAAA,KAAA;AAAA,IACN,SAAW,EAAA,YAAA;AAAA,IACX,SAAU,OAAmB,IAAA;AAAA,GAC9B,CAAA;AAED,EAAA,OAAA,CAAQ,OAAU,GAAA,OAAA;AAElB,EAAO,OAAA,OAAA;AACT;AClEO,IAAM,WAAsEA,eAAW,CAAA;AAAA,EAC5F,IAAM,EAAA,UAAA;AAAA,EACN,SAAA,EAAW,CAAC,KAAmB,KAAA;AAC7B,IAAO,OAAA,WAAA,CAAY,SAAS,KAAK,CAAA;AAAA,GACnC;AAAA,EACA,OAAS,EAAA;AACX,CAAC;ACNM,IAAM,YAKTA,eAAW,CAAA;AAAA,EACb,IAAM,EAAA,WAAA;AAAA,EACN,SAAA,EAAW,CAAC,KAAA,EAAyD,KAAkB,KAAA;AACrF,IAAA,IAAI,YAAY,QAAS,CAAA,KAAK,KAAK,WAAY,CAAA,QAAA,CAAS,KAAK,CAAG,EAAA;AAC9D,MAAI,IAAA,WAAA,CAAY,QAAS,CAAA,KAAK,CAAG,EAAA;AAC/B,QAAO,OAAA,WAAA,CAAY,IAAK,CAAA,KAAK,CAAK,IAAA,KAAA;AAAA;AAEpC,MAAQ,OAAA,CAAA,IAAA;AAAA,QACN,CAAA,0DAAA,EAA6D,KAAK,CAAA,aAAA,EAAgB,KAAK,CAAA;AAAA,OACzF;AACA,MAAO,OAAA,KAAA;AAAA;AAET,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,OAAA,EAAS,CAAC,KAAO,EAAA,EAAE,SAAS,CAAC,KAAK,GAAQ,KAAA;AACxC,IAAI,IAAA,KAAA,CAAM,OAAQ,CAAA,KAAK,CAAG,EAAA;AACxB,MAAA,OAAO,iCAAiC,KAAK,CAAA,MAAA,CAAA;AAAA;AAE/C,IAAA,OAAO,iCAAiC,KAAK,CAAA,CAAA;AAAA;AAEjD,CAAC;ACzBM,IAAM,aAKTA,eAAW,CAAA;AAAA,EACb,IAAM,EAAA,UAAA;AAAA,EACN,SAAA,CAAU,OAAgB,SAAoB,EAAA;AAC5C,IAAA,IAAI,SAAW,EAAA;AACb,MAAO,OAAA,WAAA,CAAY,SAAS,KAAK,CAAA;AAAA;AAEnC,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,OAAS,EAAA,wBAAA;AAAA,EACT,OAAO,CAAG,EAAA,EAAE,SAAS,CAAC,SAAS,GAAK,EAAA;AAClC,IAAO,OAAA,SAAA;AAAA;AAEX,CAAC;ACjBD,IAAM,UAAa,GAAA,aAAA;AAEZ,IAAM,QAAiEA,eAAW,CAAA;AAAA,EACvF,IAAM,EAAA,OAAA;AAAA,EACN,UAAU,KAAsB,EAAA;AAC9B,IAAI,IAAA,WAAA,CAAY,OAAQ,CAAA,KAAK,CAAG,EAAA;AAC9B,MAAO,OAAA,IAAA;AAAA;AAET,IAAO,OAAA,WAAA,CAAY,KAAM,CAAA,KAAA,EAAO,UAAU,CAAA;AAAA,GAC5C;AAAA,EACA,OAAS,EAAA;AACX,CAAC;ACXD,IAAM,aAAgB,GAAA,gBAAA;AAEf,IAAM,WACXA,eAAW,CAAA;AAAA,EACT,IAAM,EAAA,OAAA;AAAA,EACN,UAAU,KAA+B,EAAA;AACvC,IAAI,IAAA,WAAA,CAAY,OAAQ,CAAA,KAAK,CAAG,EAAA;AAC9B,MAAO,OAAA,IAAA;AAAA;AAET,IAAO,OAAA,WAAA,CAAY,KAAM,CAAA,KAAA,EAAO,aAAa,CAAA;AAAA,GAC/C;AAAA,EACA,OAAS,EAAA;AACX,CAAC;ACZI,IAAM,UAKTA,eAAW,CAAA;AAAA,EACb,IAAM,EAAA,SAAA;AAAA,EACN,SAAW,EAAA,CAAC,KAAsB,EAAA,GAAA,EAAa,GAAgB,KAAA;AAC7D,IAAI,IAAA,WAAA,CAAY,QAAS,CAAA,KAAK,CAAK,IAAA,WAAA,CAAY,QAAS,CAAA,GAAG,CAAK,IAAA,WAAA,CAAY,QAAS,CAAA,GAAG,CAAG,EAAA;AACzF,MAAM,MAAA,MAAA,GAAS,WAAY,CAAA,QAAA,CAAS,KAAK,CAAA;AACzC,MAAM,MAAA,IAAA,GAAO,WAAY,CAAA,QAAA,CAAS,GAAG,CAAA;AACrC,MAAM,MAAA,IAAA,GAAO,WAAY,CAAA,QAAA,CAAS,GAAG,CAAA;AACrC,MACE,IAAA,WAAA,CAAY,QAAS,CAAA,MAAM,CAC3B,IAAA,WAAA,CAAY,QAAS,CAAA,IAAI,CACzB,IAAA,WAAA,CAAY,QAAS,CAAA,IAAI,CACzB,EAAA;AACA,QAAO,OAAA,MAAA,IAAU,QAAQ,MAAU,IAAA,IAAA;AAAA;AAErC,MAAQ,OAAA,CAAA,IAAA;AAAA,QACN,CAA4D,yDAAA,EAAA,KAAK,CAAU,OAAA,EAAA,GAAG,UAAU,GAAG,CAAA;AAAA,OAC7F;AACA,MAAO,OAAA,KAAA;AAAA;AAET,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,OAAA,EAAS,CAAC,CAAG,EAAA,EAAE,SAAS,CAAC,GAAA,EAAK,GAAG,CAAA,EAAQ,KAAA;AACvC,IAAO,OAAA,CAAA,0BAAA,EAA6B,GAAG,CAAA,KAAA,EAAQ,GAAG,CAAA,CAAA;AAAA;AAEtD,CAAC;AC7BD,IAAM,YAAe,GAAA,mBAAA;AAEd,IAAM,UACXA,eAAW,CAAA;AAAA,EACT,IAAM,EAAA,SAAA;AAAA,EACN,UAAU,KAA+B,EAAA;AACvC,IAAI,IAAA,WAAA,CAAY,OAAQ,CAAA,KAAK,CAAG,EAAA;AAC9B,MAAO,OAAA,IAAA;AAAA;AAET,IAAO,OAAA,WAAA,CAAY,KAAM,CAAA,KAAA,EAAO,YAAY,CAAA;AAAA,GAC9C;AAAA,EACA,OAAS,EAAA;AACX,CAAC;ACZH,IAAM,UACJ,GAAA,ibAAA;AAEK,IAAM,QAAiEA,eAAW,CAAA;AAAA,EACvF,IAAM,EAAA,OAAA;AAAA,EACN,UAAU,KAAsB,EAAA;AAC9B,IAAI,IAAA,WAAA,CAAY,OAAQ,CAAA,KAAK,CAAG,EAAA;AAC9B,MAAO,OAAA,IAAA;AAAA;AAET,IAAO,OAAA,WAAA,CAAY,KAAM,CAAA,KAAA,EAAO,UAAU,CAAA;AAAA,GAC5C;AAAA,EACA,OAAS,EAAA;AACX,CAAC;ACZD,IAAM,YAAe,GAAA,wBAAA;AAEd,IAAM,UACXA,eAAW,CAAA;AAAA,EACT,IAAM,EAAA,SAAA;AAAA,EACN,UAAU,KAA+B,EAAA;AACvC,IAAI,IAAA,WAAA,CAAY,OAAQ,CAAA,KAAK,CAAG,EAAA;AAC9B,MAAO,OAAA,IAAA;AAAA;AAET,IAAO,OAAA,WAAA,CAAY,KAAM,CAAA,KAAA,EAAO,YAAY,CAAA;AAAA,GAC9C;AAAA,EACA,OAAS,EAAA;AACX,CAAC;ACZI,IAAM,WACXA,eAAW,CAAA;AAAA,EACT,IAAM,EAAA,UAAA;AAAA,EACN,SAAA,EAAW,CAAC,KAAA,EAAsB,KAAkB,KAAA;AAClD,IAAA,IAAI,YAAY,QAAS,CAAA,KAAK,KAAK,WAAY,CAAA,QAAA,CAAS,KAAK,CAAG,EAAA;AAC9D,MAAA,IAAI,YAAY,QAAS,CAAA,KAAK,KAAK,WAAY,CAAA,QAAA,CAAS,KAAK,CAAG,EAAA;AAC9D,QAAA,OAAO,KAAS,IAAA,KAAA;AAAA;AAElB,MAAQ,OAAA,CAAA,IAAA;AAAA,QACN,CAAA,yDAAA,EAA4D,KAAK,CAAA,aAAA,EAAgB,KAAK,CAAA;AAAA,OACxF;AACA,MAAO,OAAA,KAAA;AAAA;AAET,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,OAAA,EAAS,CAAC,CAAG,EAAA,EAAE,SAAS,CAAC,KAAK,GAAQ,KAAA;AACpC,IAAA,OAAO,gCAAgC,KAAK,CAAA,CAAA;AAAA;AAEhD,CAAC;AClBI,IAAM,YAKTA,eAAW,CAAA;AAAA,EACb,IAAM,EAAA,WAAA;AAAA,EACN,SAAA,EAAW,CAAC,KAAA,EAAyD,KAAkB,KAAA;AACrF,IAAA,IAAI,YAAY,QAAS,CAAA,KAAK,KAAK,WAAY,CAAA,QAAA,CAAS,KAAK,CAAG,EAAA;AAC9D,MAAI,IAAA,WAAA,CAAY,QAAS,CAAA,KAAK,CAAG,EAAA;AAC/B,QAAO,OAAA,WAAA,CAAY,IAAK,CAAA,KAAK,CAAK,IAAA,KAAA;AAAA;AAEpC,MAAQ,OAAA,CAAA,IAAA,CAAK,CAAwD,qDAAA,EAAA,KAAK,CAAE,CAAA,CAAA;AAC5E,MAAO,OAAA,KAAA;AAAA;AAET,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,OAAA,EAAS,CAAC,KAAO,EAAA,EAAE,SAAS,CAAC,KAAK,GAAQ,KAAA;AACxC,IAAI,IAAA,KAAA,CAAM,OAAQ,CAAA,KAAK,CAAG,EAAA;AACxB,MAAA,OAAO,kCAAkC,KAAK,CAAA,MAAA,CAAA;AAAA;AAEhD,IAAA,OAAO,iCAAiC,KAAK,CAAA,gBAAA,CAAA;AAAA;AAEjD,CAAC;ACvBM,IAAM,WACXA,eAAW,CAAA;AAAA,EACT,IAAM,EAAA,UAAA;AAAA,EACN,SAAA,EAAW,CAAC,KAAA,EAAsB,KAAkB,KAAA;AAClD,IAAA,IAAI,YAAY,QAAS,CAAA,KAAK,KAAK,WAAY,CAAA,QAAA,CAAS,KAAK,CAAG,EAAA;AAC9D,MAAA,IAAI,YAAY,QAAS,CAAA,KAAK,KAAK,WAAY,CAAA,QAAA,CAAS,KAAK,CAAG,EAAA;AAC9D,QAAA,OAAO,KAAS,IAAA,KAAA;AAAA;AAElB,MAAQ,OAAA,CAAA,IAAA;AAAA,QACN,CAAA,yDAAA,EAA4D,KAAK,CAAA,aAAA,EAAgB,KAAK,CAAA;AAAA,OACxF;AACA,MAAO,OAAA,KAAA;AAAA;AAET,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,OAAA,EAAS,CAAC,CAAG,EAAA,EAAE,SAAS,CAAC,KAAK,GAAQ,KAAA;AACpC,IAAA,OAAO,gCAAgC,KAAK,CAAA,CAAA;AAAA;AAEhD,CAAC;AClBI,IAAM,cAKTA,eAAW,CAAA;AAAA,EACb,IAAM,EAAA,aAAA;AAAA,EACN,SAAA,EAAW,CAAC,KAAA,EAAyD,KAAkB,KAAA;AACrF,IAAA,IAAI,YAAY,QAAS,CAAA,KAAK,KAAK,WAAY,CAAA,QAAA,CAAS,KAAK,CAAG,EAAA;AAC9D,MAAI,IAAA,WAAA,CAAY,QAAS,CAAA,KAAK,CAAG,EAAA;AAC/B,QAAO,OAAA,WAAA,CAAY,IAAK,CAAA,KAAK,CAAM,KAAA,KAAA;AAAA;AAErC,MAAQ,OAAA,CAAA,IAAA,CAAK,CAAwD,qDAAA,EAAA,KAAK,CAAE,CAAA,CAAA;AAC5E,MAAO,OAAA,KAAA;AAAA;AAET,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,OAAA,EAAS,CAAC,CAAG,EAAA,EAAE,SAAS,CAAC,KAAK,GAAQ,KAAA;AACpC,IAAA,OAAO,gCAAgC,KAAK,CAAA,gBAAA,CAAA;AAAA;AAEhD,CAAC;ACpBD,IAAM,YAAe,GAAA,eAAA;AAEd,IAAM,UACXA,eAAW,CAAA;AAAA,EACT,IAAM,EAAA,SAAA;AAAA,EACN,UAAU,KAA+B,EAAA;AACvC,IAAI,IAAA,WAAA,CAAY,OAAQ,CAAA,KAAK,CAAG,EAAA;AAC9B,MAAO,OAAA,IAAA;AAAA;AAET,IAAO,OAAA,WAAA,CAAY,KAAM,CAAA,KAAA,EAAO,YAAY,CAAA;AAAA,GAC9C;AAAA,EACA,OAAS,EAAA;AACX,CAAC;ACZI,IAAM,iBAKTA,eAAW,CAAA;AAAA,EACb,IAAM,EAAA,UAAA;AAAA,EACN,SAAA,CAAU,OAAgB,SAAoB,EAAA;AAC5C,IAAA,IAAI,CAAC,SAAW,EAAA;AACd,MAAO,OAAA,WAAA,CAAY,SAAS,KAAK,CAAA;AAAA;AAEnC,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,OAAS,EAAA,wBAAA;AAAA,EACT,OAAO,CAAG,EAAA,EAAE,SAAS,CAAC,SAAS,GAAK,EAAA;AAClC,IAAA,OAAO,CAAC,SAAA;AAAA;AAEZ,CAAC;ACjBM,IAAM,SACXA,eAAW,CAAA;AAAA,EACT,IAAM,EAAA,QAAA;AAAA,EACN,SAAA,CAAU,OAAgB,MAAiB,EAAA;AACzC,IAAI,IAAA,WAAA,CAAY,OAAQ,CAAA,KAAK,CAAG,EAAA;AAC9B,MAAO,OAAA,IAAA;AAAA;AAET,IAAA,OAAO,KAAU,KAAA,MAAA;AAAA,GACnB;AAAA,EACA,QAAQ,CAAG,EAAA,EAAE,SAAS,CAAC,MAAM,GAAK,EAAA;AAChC,IAAA,OAAO,2BAA2B,MAAM,CAAA,CAAA,CAAA;AAAA;AAE5C,CAAC;ACTH,IAAM,QACJ,GAAA,yaAAA;AAEK,IAAM,MAA+DA,eAAW,CAAA;AAAA,EACrF,IAAM,EAAA,KAAA;AAAA,EACN,UAAU,KAAsB,EAAA;AAC9B,IAAI,IAAA,WAAA,CAAY,OAAQ,CAAA,KAAK,CAAG,EAAA;AAC9B,MAAO,OAAA,IAAA;AAAA;AAET,IAAO,OAAA,WAAA,CAAY,KAAM,CAAA,KAAA,EAAO,QAAQ,CAAA;AAAA,GAC1C;AAAA,EACA,OAAS,EAAA;AACX,CAAC;ACfM,IAAM,YAaTA,eAAW,CAAA;AAAA,EACb,IAAM,EAAA,WAAA;AAAA,EACN,SAAA,EAAW,CAAC,KAAA,EAA6B,KAAgC,KAAA;AACvE,IAAA,IAAI,YAAY,QAAS,CAAA,KAAK,KAAK,WAAY,CAAA,QAAA,CAAS,KAAK,CAAG,EAAA;AAC9D,MAAA,IAAI,YAAY,MAAO,CAAA,KAAK,KAAK,WAAY,CAAA,MAAA,CAAO,KAAK,CAAG,EAAA;AAC1D,QAAM,MAAA,MAAA,GAAS,WAAY,CAAA,MAAA,CAAO,KAAK,CAAA,CAAE,OAAQ,EAAA,GAAI,WAAY,CAAA,MAAA,CAAO,KAAK,CAAA,CAAE,OAAQ,EAAA;AACvF,QAAA,IAAI,MAAQ,EAAA;AACV,UAAO,OAAA,IAAA;AAAA;AAET,QAAA,OAAO,EAAE,MAAA,EAAQ,KAAO,EAAA,KAAA,EAAO,gBAA0B,EAAA;AAAA;AAE3D,MAAA,OAAO,EAAE,MAAA,EAAQ,KAAO,EAAA,KAAA,EAAO,+BAAyC,EAAA;AAAA;AAE1E,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,OAAA,EAAS,CAAC,CAAG,EAAA,EAAE,SAAS,CAAC,KAAK,GAAQ,KAAA;AAIpC,IAAA,OAAO,0BAA0B,KAAK,CAAA,CAAA;AAAA;AAE1C,CAAC;AClCM,IAAM,aAaTA,eAAW,CAAA;AAAA,EACb,IAAM,EAAA,YAAA;AAAA,EACN,SAAA,EAAW,CAAC,KAAA,EAA6B,MAAiC,KAAA;AACxE,IAAA,IAAI,YAAY,QAAS,CAAA,KAAK,KAAK,WAAY,CAAA,QAAA,CAAS,MAAM,CAAG,EAAA;AAC/D,MAAA,IAAI,YAAY,MAAO,CAAA,KAAK,KAAK,WAAY,CAAA,MAAA,CAAO,MAAM,CAAG,EAAA;AAC3D,QAAM,MAAA,MAAA,GAAS,WAAY,CAAA,MAAA,CAAO,KAAK,CAAA,CAAE,OAAQ,EAAA,GAAI,WAAY,CAAA,MAAA,CAAO,MAAM,CAAA,CAAE,OAAQ,EAAA;AACxF,QAAA,IAAI,MAAQ,EAAA;AACV,UAAO,OAAA,IAAA;AAAA;AAET,QAAA,OAAO,EAAE,MAAA,EAAQ,KAAO,EAAA,KAAA,EAAO,iBAA2B,EAAA;AAAA;AAE5D,MAAA,OAAO,EAAE,MAAA,EAAQ,KAAO,EAAA,KAAA,EAAO,+BAAyC,EAAA;AAAA;AAE1E,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,OAAA,EAAS,CAAC,CAAG,EAAA,EAAE,SAAS,CAAC,MAAM,CAAG,EAAA,KAAA,EAAY,KAAA;AAC5C,IAAA,IAAI,UAAU,+BAAiC,EAAA;AAC7C,MAAO,OAAA,0BAAA;AAAA;AAET,IAAA,OAAO,2BAA2B,MAAM,CAAA,CAAA;AAAA;AAE5C,CAAC;AClCM,IAAM,cAKTA,eAAW,CAAA;AAAA,EACb,IAAM,EAAA,aAAA;AAAA,EACN,SAAW,EAAA,CACT,KACA,EAAA,MAAA,EACA,KACG,KAAA;AACH,IAAI,IAAA,WAAA,CAAY,MAAO,CAAA,KAAK,CAAK,IAAA,WAAA,CAAY,MAAO,CAAA,MAAM,CAAK,IAAA,WAAA,CAAY,MAAO,CAAA,KAAK,CAAG,EAAA;AACxF,MACE,OAAA,WAAA,CAAY,OAAO,KAAK,CAAA,CAAE,SAAY,GAAA,WAAA,CAAY,MAAO,CAAA,MAAM,CAAE,CAAA,OAAA,MACjE,WAAY,CAAA,MAAA,CAAO,KAAK,CAAE,CAAA,OAAA,KAAY,WAAY,CAAA,MAAA,CAAO,KAAK,CAAA,CAAE,OAAQ,EAAA;AAAA;AAG5E,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,OAAA,EAAS,CAAC,CAAG,EAAA,EAAE,SAAS,CAAC,MAAA,EAAQ,KAAK,CAAA,EAAQ,KAAA;AAC5C,IAAO,OAAA,CAAA,yBAAA,EAA4B,MAAM,CAAA,KAAA,EAAQ,KAAK,CAAA,CAAA;AAAA;AAE1D,CAAC;ACvBD,SAAS,YAAY,MAAgB,EAAA;AACnC,EAAA,IAAI,MAAO,CAAA,MAAA,GAAS,CAAK,IAAA,MAAA,CAAO,WAAW,CAAG,EAAA;AAC5C,IAAO,OAAA,KAAA;AAAA;AAGT,EAAA,IAAI,MAAO,CAAA,CAAC,CAAM,KAAA,GAAA,IAAO,WAAW,GAAK,EAAA;AACvC,IAAO,OAAA,KAAA;AAAA;AAGT,EAAA,IAAI,CAAC,MAAA,CAAO,KAAM,CAAA,OAAO,CAAG,EAAA;AAC1B,IAAO,OAAA,KAAA;AAAA;AAGT,EAAMK,MAAAA,QAAAA,GAAU,CAAC,MAAS,GAAA,CAAA;AAC1B,EAAOA,OAAAA,QAAAA,IAAW,KAAKA,QAAW,IAAA,GAAA;AACpC;AAEO,IAAM,YAAqEL,eAAW,CAAA;AAAA,EAC3F,IAAM,EAAA,WAAA;AAAA,EACN,UAAU,KAAsB,EAAA;AAC9B,IAAI,IAAA,WAAA,CAAY,OAAQ,CAAA,KAAK,CAAG,EAAA;AAC9B,MAAO,OAAA,IAAA;AAAA;AAGT,IAAI,IAAA,OAAO,UAAU,QAAU,EAAA;AAC7B,MAAO,OAAA,KAAA;AAAA;AAGT,IAAM,MAAA,OAAA,GAAU,KAAM,CAAA,KAAA,CAAM,GAAG,CAAA;AAC/B,IAAA,OAAO,OAAQ,CAAA,MAAA,KAAW,CAAK,IAAA,OAAA,CAAQ,MAAM,WAAW,CAAA;AAAA,GAC1D;AAAA,EACA,OAAS,EAAA;AACX,CAAC;AChCM,IAAM,aAKTA,eAAW,CAAA;AAAA,EACb,IAAM,EAAA,YAAA;AAAA,EACN,SAAA,CAAU,KAAsB,EAAA,SAAA,GAAY,GAAK,EAAA;AAC/C,IAAI,IAAA,WAAA,CAAY,OAAQ,CAAA,KAAK,CAAG,EAAA;AAC9B,MAAO,OAAA,IAAA;AAAA;AAGT,IAAI,IAAA,OAAO,UAAU,QAAU,EAAA;AAC7B,MAAO,OAAA,KAAA;AAAA;AAGT,IAAA,MAAM,QACJ,OAAO,SAAA,KAAc,YAAY,SAAc,KAAA,EAAA,GAC3C,MAAM,KAAM,CAAA,SAAS,IACrB,KAAM,CAAA,MAAA,KAAW,MAAM,KAAM,CAAA,MAAA,KAAW,KACtC,KAAM,CAAA,KAAA,CAAM,OAAO,CACnB,GAAA,IAAA;AAER,IAAO,OAAA,KAAA,KAAU,IAAS,KAAA,KAAA,CAAM,MAAW,KAAA,CAAA,IAAK,MAAM,MAAW,KAAA,CAAA,CAAA,IAAM,KAAM,CAAA,KAAA,CAAM,QAAQ,CAAA;AAAA,GAC7F;AAAA,EACA,OAAS,EAAA;AACX,CAAC;AAED,IAAM,WAAW,CAAC,GAAA,KAAgB,IAAI,WAAY,EAAA,CAAE,MAAM,eAAe,CAAA;AC5BlE,IAAM,UAAqEA,eAAW,CAAA;AAAA,EAC3F,IAAM,EAAA,SAAA;AAAA,EACN,SAAA,EAAW,CAAC,KAA0B,KAAA;AACpC,IAAI,IAAA,WAAA,CAAY,QAAS,CAAA,KAAK,CAAG,EAAA;AAC/B,MAAA,OAAO,KAAU,KAAA,IAAA;AAAA;AAEnB,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,OAAS,EAAA;AACX,CAAC;ACTM,IAAM,WAKTA,eAAW,CAAA;AAAA,EACb,IAAM,EAAA,UAAA;AAAA,EACN,SAAA,CAAU,OAAsB,IAAqB,EAAA;AACnD,IAAA,IAAI,YAAY,QAAS,CAAA,KAAK,KAAK,WAAY,CAAA,QAAA,CAAS,IAAI,CAAG,EAAA;AAC7D,MAAO,OAAA,KAAA,CAAM,SAAS,IAAI,CAAA;AAAA;AAE5B,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,QAAQ,CAAG,EAAA,EAAE,SAAS,CAAC,IAAI,GAAK,EAAA;AAC9B,IAAA,OAAO,sBAAsB,IAAI,CAAA,CAAA;AAAA;AAErC,CAAC;AChBM,IAAM,aAKTA,eAAW,CAAA;AAAA,EACb,IAAM,EAAA,YAAA;AAAA,EACN,SAAA,CAAU,OAAsB,IAAqB,EAAA;AACnD,IAAA,IAAI,YAAY,QAAS,CAAA,KAAK,KAAK,WAAY,CAAA,QAAA,CAAS,IAAI,CAAG,EAAA;AAC7D,MAAO,OAAA,KAAA,CAAM,WAAW,IAAI,CAAA;AAAA;AAE9B,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,QAAQ,CAAG,EAAA,EAAE,SAAS,CAAC,IAAI,GAAK,EAAA;AAC9B,IAAA,OAAO,uBAAuB,IAAI,CAAA,CAAA;AAAA;AAEtC,CAAC;AChBM,IAAM,WAKTA,eAAW,CAAA;AAAA,EACb,IAAM,EAAA,UAAA;AAAA,EACN,SAAA,CAAU,OAAsB,IAAqB,EAAA;AACnD,IAAA,IAAI,YAAY,QAAS,CAAA,KAAK,KAAK,WAAY,CAAA,QAAA,CAAS,IAAI,CAAG,EAAA;AAC7D,MAAO,OAAA,KAAA,CAAM,SAAS,IAAI,CAAA;AAAA;AAE5B,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,QAAQ,CAAG,EAAA,EAAE,SAAS,CAAC,IAAI,GAAK,EAAA;AAC9B,IAAA,OAAO,uBAAuB,IAAI,CAAA,CAAA;AAAA;AAEtC,CAAC;AChBM,IAAMM,SAKTN,eAAW,CAAA;AAAA,EACb,IAAM,EAAA,OAAA;AAAA,EACN,SAAA,CAAU,OAA+B,MAAgB,EAAA;AACvD,IAAI,IAAA,WAAA,CAAY,QAAS,CAAA,KAAK,CAAG,EAAA;AAC/B,MAAO,OAAA,WAAA,CAAY,KAAM,CAAA,KAAA,EAAO,MAAM,CAAA;AAAA;AAExC,IAAO,OAAA,IAAA;AAAA,GACT;AAAA,EACA,OAAS,EAAA;AACX,CAAC","file":"index.cjs","sourcesContent":["import type {\n  InlineRuleDeclaration,\n  RegleRuleDefinition,\n  RegleRuleDefinitionProcessor,\n  RegleRuleDefinitionWithMetadataProcessor,\n  RegleRuleMetadataConsumer,\n  RegleRuleMetadataDefinition,\n  RegleRuleRaw,\n  RegleRuleWithParamsDefinition,\n} from '@regle/core';\nimport { createRule, InternalRuleType } from '@regle/core';\n\nexport function withMessage<\n  TValue extends any,\n  TParams extends any[],\n  TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>,\n  TAsync extends boolean = TReturn extends Promise<any> ? true : false,\n>(\n  rule: InlineRuleDeclaration<TValue, TParams, TReturn>,\n  newMessage: RegleRuleDefinitionWithMetadataProcessor<\n    TValue,\n    RegleRuleMetadataConsumer<TParams, TReturn extends Promise<infer M> ? M : TReturn>,\n    string | string[]\n  >\n): RegleRuleDefinition<TValue, [], TAsync, TReturn extends Promise<infer M> ? M : TReturn>;\nexport function withMessage<\n  TValue extends any,\n  TParams extends any[],\n  TMetadata extends RegleRuleMetadataDefinition,\n  TReturn extends TMetadata | Promise<TMetadata>,\n  TAsync extends boolean = TReturn extends Promise<any> ? true : false,\n>(\n  rule: RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>,\n  newMessage: RegleRuleDefinitionWithMetadataProcessor<\n    TValue,\n    RegleRuleMetadataConsumer<TParams, TMetadata>,\n    string | string[]\n  >\n): RegleRuleWithParamsDefinition<TValue, TParams, TAsync>;\nexport function withMessage<\n  TValue extends any,\n  TParams extends any[],\n  TMetadata extends RegleRuleMetadataDefinition,\n  TReturn extends TMetadata | Promise<TMetadata>,\n  TAsync extends boolean,\n>(\n  rule: RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>,\n  newMessage: RegleRuleDefinitionWithMetadataProcessor<\n    TValue,\n    RegleRuleMetadataConsumer<TParams, TMetadata>,\n    string | string[]\n  >\n): RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>;\nexport function withMessage(\n  rule: RegleRuleRaw<any, any, any, any> | InlineRuleDeclaration<any, any>,\n  newMessage: RegleRuleDefinitionWithMetadataProcessor<\n    any,\n    RegleRuleMetadataConsumer<any[], any>,\n    string | string[]\n  >\n): RegleRuleWithParamsDefinition<any, any, any, any> | RegleRuleDefinition<any, any, any, any> {\n  let _type: string | undefined;\n  let validator: RegleRuleDefinitionProcessor<any | Promise<any>>;\n  let _active:\n    | boolean\n    | RegleRuleDefinitionWithMetadataProcessor<any, RegleRuleMetadataConsumer<any, any>, boolean>\n    | undefined;\n  let _params: any[] | undefined;\n\n  if (typeof rule === 'function' && !('_validator' in rule)) {\n    _type = InternalRuleType.Inline;\n    validator = rule;\n  } else {\n    ({ _type, validator, _active, _params } = rule);\n  }\n\n  const newRule = createRule({\n    type: _type as any,\n    validator: validator as any,\n    active: _active as any,\n    message: newMessage,\n  });\n\n  newRule._params = _params as any;\n  newRule._patched = true;\n\n  return newRule;\n}\n","import type { Ref } from 'vue';\nimport type {\n  InlineRuleDeclaration,\n  RegleRuleDefinition,\n  RegleRuleMetadataDefinition,\n  UnwrapRegleUniversalParams,\n} from '@regle/core';\nimport { createRule, InternalRuleType } from '@regle/core';\n\nexport function withAsync<\n  TValue,\n  TParams extends (Ref<unknown> | (() => unknown))[] = [],\n  TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> =\n    | RegleRuleMetadataDefinition\n    | Promise<RegleRuleMetadataDefinition>,\n  TMetadata extends RegleRuleMetadataDefinition = TReturn extends Promise<infer M> ? M : TReturn,\n>(\n  rule: InlineRuleDeclaration<TValue, TParams, TReturn>,\n  depsArray?: [...TParams]\n): RegleRuleDefinition<TValue, UnwrapRegleUniversalParams<TParams>, true, TMetadata> {\n  const validator = async (value: any | null | undefined, ...params: any[]) => {\n    return rule(value, ...(params as any));\n  };\n\n  const newRule = createRule({\n    type: InternalRuleType.Async,\n    validator: validator as any,\n    message: '',\n  });\n\n  newRule._params = depsArray as any;\n\n  return newRule as any;\n}\n","import type { Ref } from 'vue';\nimport type {\n  InlineRuleDeclaration,\n  RegleRuleDefinition,\n  RegleRuleMetadataDefinition,\n  UnwrapRegleUniversalParams,\n} from '@regle/core';\nimport { createRule, InternalRuleType } from '@regle/core';\n\nexport function withParams<\n  TValue,\n  TParams extends (Ref<unknown> | (() => unknown))[] = [],\n  TReturn extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition,\n  TMetadata extends RegleRuleMetadataDefinition = TReturn extends Promise<infer M> ? M : TReturn,\n>(\n  rule: InlineRuleDeclaration<TValue, TParams, TReturn>,\n  depsArray: [...TParams]\n): RegleRuleDefinition<TValue, UnwrapRegleUniversalParams<TParams>, true, TMetadata> {\n  const validator = (value: any | null | undefined, ...params: any[]) => {\n    return rule(value, ...(params as any));\n  };\n\n  const newRule = createRule({\n    type: InternalRuleType.Inline,\n    validator: validator as any,\n    message: '',\n  });\n\n  newRule._params = depsArray as any;\n\n  return newRule as any;\n}\n","import type {\n  InlineRuleDeclaration,\n  RegleRuleDefinition,\n  RegleRuleDefinitionProcessor,\n  ParamDecl,\n  RegleRuleMetadataDefinition,\n  RegleRuleMetadataConsumer,\n  RegleRuleDefinitionWithMetadataProcessor,\n} from '@regle/core';\nimport { createRule, InternalRuleType, unwrapRuleParameters } from '@regle/core';\n\nexport function applyIf<\n  TValue extends any,\n  TParams extends any[],\n  TReturn extends\n    | RegleRuleMetadataDefinition\n    | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition,\n  TMetadata extends RegleRuleMetadataDefinition = TReturn extends Promise<infer M> ? M : TReturn,\n  TAsync extends boolean = TReturn extends Promise<any> ? true : false,\n>(\n  _condition: ParamDecl<boolean>,\n  rule:\n    | InlineRuleDeclaration<TValue, TParams, TReturn>\n    | RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>\n): RegleRuleDefinition<TValue, [], TAsync, TMetadata> {\n  let _type: string | undefined;\n  let validator: RegleRuleDefinitionProcessor<any, any, any>;\n  let _params: any[] | undefined;\n  let _message: RegleRuleDefinitionWithMetadataProcessor<\n    any,\n    RegleRuleMetadataConsumer<any, any>,\n    string | string[]\n  > = '';\n\n  if (typeof rule === 'function') {\n    _type = InternalRuleType.Inline;\n    validator = rule;\n  } else {\n    ({ _type, validator, _params, _message } = rule);\n    _params?.push(_condition);\n  }\n\n  function newValidator(value: any, ...args: any[]) {\n    const [condition] = unwrapRuleParameters<[boolean]>([_condition]);\n    if (condition) {\n      return validator(value, ...args);\n    }\n    return true;\n  }\n\n  function newActive(value: any, metadata: RegleRuleMetadataConsumer<any[], any>) {\n    const [condition] = unwrapRuleParameters<[boolean]>([_condition]);\n    return condition;\n  }\n\n  const newRule = createRule({\n    type: _type as any,\n    validator: newValidator as any,\n    active: newActive,\n    message: _message,\n  });\n\n  newRule._params = _params as any;\n\n  return newRule as any;\n}\n","import type { EmptyObject } from 'type-fest';\n\nexport function isEmpty(value: unknown): value is null | undefined | [] | EmptyObject {\n  if (value === undefined || value === null) {\n    return true;\n  }\n\n  if (value === false) {\n    return false;\n  }\n\n  if (value instanceof Date) {\n    // invalid date won't pass\n    return isNaN(value.getTime());\n  }\n  if (Array.isArray(value)) {\n    return value.length === 0;\n  }\n  if (typeof value === 'object' && value != null) {\n    return Object.keys(value).length === 0;\n  }\n  return !String(value).length;\n}\n","import { isEmpty } from './isEmpty';\n\nexport function isFilled<T extends unknown>(value: T): value is NonNullable<T> {\n  return !isEmpty(typeof value === 'string' ? value.trim() : value);\n}\n","export function isNumber(value: unknown): value is number {\n  if (value == null) return false;\n  else if (typeof value !== 'number') {\n    return false;\n  } else if (isNaN(value)) {\n    return false;\n  } else {\n    return true;\n  }\n}\n","import { isEmpty } from './isEmpty';\n\nexport function regex(_value: string | number | null | undefined, ...expr: RegExp[]): boolean {\n  if (isEmpty(_value)) {\n    return true;\n  }\n  const value = typeof _value === 'number' ? _value.toString() : _value;\n  return expr.every((reg) => {\n    reg.lastIndex = 0;\n    return reg.test(value);\n  });\n}\n","import type { MaybeRef } from 'vue';\nimport { unref } from 'vue';\n\nexport function size(value: MaybeRef<string | any[] | Record<string, any> | number>): number {\n  const _value = unref(value);\n  if (Array.isArray(_value)) return _value.length;\n  if (typeof _value === 'object') {\n    return Object.keys(_value).length;\n  }\n  if (typeof _value === 'number') {\n    if (isNaN(_value)) {\n      return 0;\n    }\n    return _value;\n  }\n  return String(_value).length;\n}\n","import { isEmpty } from './isEmpty';\n\nexport function isDate(value: unknown): value is Date {\n  if (isEmpty(value)) {\n    return false;\n  }\n  try {\n    let possibleDate: Date | null = null;\n    if (value instanceof Date) {\n      possibleDate = value;\n    } else if (typeof value === 'number' && !isNaN(value)) {\n      possibleDate = new Date(value);\n    } else if (typeof value === 'string') {\n      const date = new Date(value);\n      if (date.toString() === 'Invalid Date') {\n        return false;\n      }\n      possibleDate = date;\n    }\n    return !!possibleDate;\n  } catch (e) {\n    return false;\n  }\n}\n","import type { Maybe } from '@regle/core';\n\nexport function toDate(argument: Maybe<Date | number | string>): Date {\n  const argStr = Object.prototype.toString.call(argument);\n  if (argument == null) {\n    return new Date(NaN);\n  } else if (\n    argument instanceof Date ||\n    (typeof argument === 'object' && argStr === '[object Date]')\n  ) {\n    return new Date(argument.getTime());\n  } else if (typeof argument === 'number' || argStr === '[object Number]') {\n    return new Date(argument);\n  } else if (typeof argument === 'string' || argStr === '[object String]') {\n    return new Date(argument);\n  } else {\n    return new Date(NaN);\n  }\n}\n","/**\n * @returns ⚠️ Warning, returned value can be NaN\n */\nexport function toNumber<T extends number | string | undefined>(argument: T): number {\n  if (typeof argument === 'number') {\n    return argument;\n  } else if (argument != null) {\n    const isPadded = argument.trim() !== argument;\n    if (isPadded) {\n      return NaN;\n    }\n    return +argument;\n  }\n  return NaN;\n}\n","import { isEmpty } from './isEmpty';\nimport { isFilled } from './isFilled';\nimport { isNumber } from './isNumber';\nimport { regex } from './regex';\nimport { size } from './size';\nimport { isDate } from './isDate';\nimport { toDate } from './toDate';\nimport { toNumber } from './toNumber';\n\nexport const ruleHelpers = {\n  isEmpty,\n  isFilled,\n  size,\n  regex,\n  isNumber,\n  isDate,\n  toDate,\n  toNumber,\n};\n","import type {\n  FormRuleDeclaration,\n  RegleRuleDefinition,\n  RegleRuleDefinitionProcessor,\n} from '@regle/core';\nimport { createRule } from '@regle/core';\nimport type {\n  ExtractValueFromRules,\n  ExtractParamsFromRules,\n  UnwrapTuples,\n  GuessAsyncFromRules,\n  GuessMetadataFromRules,\n} from '../types';\n\nexport function and<TRules extends FormRuleDeclaration<any, any>[]>(\n  ...rules: [...TRules]\n): RegleRuleDefinition<\n  ExtractValueFromRules<TRules>[number],\n  UnwrapTuples<ExtractParamsFromRules<TRules>>,\n  GuessAsyncFromRules<TRules>,\n  GuessMetadataFromRules<TRules>\n> {\n  const isAnyRuleAsync = rules.some((rule) => {\n    if (typeof rule === 'function') {\n      return rule.constructor.name === 'AsyncFunction';\n    } else {\n      return rule._async;\n    }\n  });\n\n  const _params = rules\n    .map((rule) => {\n      if (typeof rule === 'function') {\n        return null;\n      } else {\n        const $params = rule._params;\n        if (!$params?.length) {\n          return [null];\n        } else {\n          return $params;\n        }\n      }\n    })\n    .flat()\n    .filter((param): param is any => !!param);\n\n  function computeRules(rules: [...TRules], value: any, ...params: any[]) {\n    const $rules: any[] = [];\n    let paramIndex = 0;\n\n    for (let rule of rules) {\n      if (typeof rule === 'function') {\n        $rules.push(rule(value));\n        paramIndex++;\n      } else {\n        const paramsLength = rule._params?.length ?? 0;\n        $rules.push(rule.validator(value, ...params.slice(paramIndex, paramsLength)));\n        if (paramsLength) {\n          paramIndex += paramsLength;\n        }\n      }\n    }\n\n    return $rules;\n  }\n\n  function computeMetadata(\n    results: (boolean | { $valid: boolean; [x: string]: any })[]\n  ): boolean | { $valid: boolean; [x: string]: any } {\n    const isAnyResultMetaData = results.some((s) => typeof s !== 'boolean');\n    if (isAnyResultMetaData) {\n      return {\n        $valid: results.every((result) => {\n          if (typeof result === 'boolean') {\n            return !!result;\n          }\n          return result.$valid;\n        }),\n        ...results.reduce((acc, result) => {\n          if (typeof result === 'boolean') {\n            return acc;\n          }\n          const { $valid, ...rest } = result;\n          return { ...acc, ...rest };\n        }, {}),\n      };\n    } else {\n      return results.every((result) => !!result);\n    }\n  }\n\n  let validator: RegleRuleDefinitionProcessor;\n\n  if (!!rules.length) {\n    validator = isAnyRuleAsync\n      ? async (value: any | null | undefined, ...params: any[]) => {\n          const results = await Promise.all(computeRules(rules, value, ...params));\n          return computeMetadata(results);\n        }\n      : (value: any | null | undefined, ...params: any[]) => {\n          const $rules = computeRules(rules, value, ...params);\n          return computeMetadata($rules);\n        };\n  } else {\n    validator = (value: any) => {\n      return false;\n    };\n  }\n\n  const newRule = createRule({\n    type: 'and',\n    validator: validator as any,\n    message: 'The value does not match all of the provided validators',\n  });\n\n  newRule._params = _params as any;\n\n  return newRule as any;\n}\n","import type { FormRuleDeclaration, RegleRuleDefinition } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport type {\n  ExtractParamsFromRules,\n  ExtractValueFromRules,\n  GuessAsyncFromRules,\n  GuessMetadataFromRules,\n  UnwrapTuples,\n} from '../types';\n\nexport function or<TRules extends FormRuleDeclaration<any, any>[]>(\n  ...rules: [...TRules]\n): RegleRuleDefinition<\n  ExtractValueFromRules<TRules>[number],\n  UnwrapTuples<ExtractParamsFromRules<TRules>>,\n  GuessAsyncFromRules<TRules>,\n  GuessMetadataFromRules<TRules>\n> {\n  const isAnyRuleAsync = rules.some((rule) => {\n    if (typeof rule === 'function') {\n      return rule.constructor.name === 'AsyncFunction';\n    } else {\n      return rule._async;\n    }\n  });\n\n  const params = rules\n    .map((rule) => {\n      if (typeof rule === 'function') {\n        return null;\n      } else {\n        return rule._params;\n      }\n    })\n    .flat()\n    .filter((param): param is any => !!param);\n\n  function computeRules(rules: [...TRules], value: any, ...params: any[]) {\n    const $rules: any[] = [];\n    let paramIndex = 0;\n\n    for (let rule of rules) {\n      if (typeof rule === 'function') {\n        $rules.push(rule(value));\n        paramIndex++;\n      } else {\n        const paramsLength = rule._params?.length ?? 0;\n        $rules.push(rule.validator(value, ...params.slice(paramIndex, paramsLength)));\n        if (paramsLength) {\n          paramIndex += paramsLength;\n        }\n      }\n    }\n\n    return $rules;\n  }\n\n  function computeMetadata(\n    results: (boolean | { $valid: boolean; [x: string]: any })[]\n  ): boolean | { $valid: boolean; [x: string]: any } {\n    const isAnyResultMetaData = results.some((s) => typeof s !== 'boolean');\n    if (isAnyResultMetaData) {\n      return {\n        $valid: results.some((result) => {\n          if (typeof result === 'boolean') {\n            return !!result;\n          }\n          return result.$valid;\n        }),\n        ...results.reduce((acc, result) => {\n          if (typeof result === 'boolean') {\n            return acc;\n          }\n          const { $valid, ...rest } = result;\n          return { ...acc, ...rest };\n        }, {}),\n      };\n    } else {\n      return results.some((result) => !!result);\n    }\n  }\n\n  const validator = isAnyRuleAsync\n    ? async (value: any | null | undefined, ...params: any[]) => {\n        const results = await Promise.all(computeRules(rules, value, ...params));\n        return computeMetadata(results);\n      }\n    : (value: any | null | undefined, ...params: any[]) => {\n        const $rules = computeRules(rules, value, ...params);\n        return computeMetadata($rules);\n      };\n\n  const newRule = createRule({\n    type: 'or',\n    validator: validator as any,\n    message: 'The value does not match any of the provided validators',\n  });\n\n  newRule._params = params as any;\n\n  return newRule as any;\n}\n","import type {\n  InlineRuleDeclaration,\n  RegleRuleDefinition,\n  RegleRuleDefinitionProcessor,\n  RegleRuleDefinitionWithMetadataProcessor,\n  RegleRuleMetadataConsumer,\n  RegleRuleMetadataDefinition,\n} from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from './ruleHelpers';\n\nexport function not<\n  TValue,\n  TParams extends any[] = [],\n  TReturn extends\n    | RegleRuleMetadataDefinition\n    | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition,\n  TMetadata extends RegleRuleMetadataDefinition = TReturn extends Promise<infer M> ? M : TReturn,\n  TAsync extends boolean = TReturn extends Promise<any> ? true : false,\n>(\n  rule:\n    | RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>\n    | InlineRuleDeclaration<TValue, TParams, TReturn>,\n  message?: RegleRuleDefinitionWithMetadataProcessor<\n    TValue,\n    RegleRuleMetadataConsumer<TParams, TMetadata>,\n    string | string[]\n  >\n): RegleRuleDefinition<TValue, TParams, TAsync, TMetadata> {\n  let _type: string | undefined;\n  let validator: RegleRuleDefinitionProcessor<any, any, any>;\n  let newValidator: RegleRuleDefinitionProcessor<any, any, any>;\n  let _params: any[] | undefined;\n\n  let _async: boolean;\n\n  if (typeof rule === 'function') {\n    validator = rule;\n    _async = rule.constructor.name === 'AsyncFunction';\n  } else {\n    ({ _type, validator, _params } = rule);\n    _async = rule._async;\n  }\n\n  if (_async) {\n    newValidator = async (value: any, ...params: any[]) => {\n      if (ruleHelpers.isFilled(value)) {\n        const result = await validator(value, ...(params as any));\n        return !result;\n      }\n      return true;\n    };\n  } else {\n    newValidator = (value: any, ...params: any[]) => {\n      if (ruleHelpers.isFilled(value)) {\n        return !validator(value, ...(params as any));\n      }\n      return true;\n    };\n  }\n\n  const newRule = createRule({\n    type: 'not',\n    validator: newValidator as any,\n    message: (message as any) ?? 'Error',\n  });\n\n  newRule._params = _params as any;\n\n  return newRule as any;\n}\n","import type { RegleRuleDefinition } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nexport const required: RegleRuleDefinition<unknown, [], false, boolean, unknown> = createRule({\n  type: 'required',\n  validator: (value: unknown) => {\n    return ruleHelpers.isFilled(value);\n  },\n  message: 'This field is required',\n});\n","import { ruleHelpers } from '../helpers';\nimport type { RegleRuleWithParamsDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\n\nexport const maxLength: RegleRuleWithParamsDefinition<\n  string | any[] | Record<PropertyKey, any>,\n  [count: number],\n  false,\n  boolean\n> = createRule({\n  type: 'maxLength',\n  validator: (value: Maybe<string | Record<PropertyKey, any> | any[]>, count: number) => {\n    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(count)) {\n      if (ruleHelpers.isNumber(count)) {\n        return ruleHelpers.size(value) <= count;\n      }\n      console.warn(\n        `[maxLength] Value or parameter isn't a number, got value: ${value}, parameter: ${count}`\n      );\n      return false;\n    }\n    return true;\n  },\n  message: (value, { $params: [count] }) => {\n    if (Array.isArray(value)) {\n      return `This list should have maximum ${count} items`;\n    }\n    return `The maximum length allowed is ${count}`;\n  },\n});\n","import type { RegleRuleWithParamsDefinition } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nexport const requiredIf: RegleRuleWithParamsDefinition<\n  unknown,\n  [condition: boolean],\n  false,\n  boolean\n> = createRule({\n  type: 'required',\n  validator(value: unknown, condition: boolean) {\n    if (condition) {\n      return ruleHelpers.isFilled(value);\n    }\n    return true;\n  },\n  message: 'This field is required',\n  active(_, { $params: [condition] }) {\n    return condition;\n  },\n});\n","import type { RegleRuleDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nconst alphaRegex = /^[a-zA-Z]*$/;\n\nexport const alpha: RegleRuleDefinition<string, [], false, boolean, string> = createRule({\n  type: 'alpha',\n  validator(value: Maybe<string>) {\n    if (ruleHelpers.isEmpty(value)) {\n      return true;\n    }\n    return ruleHelpers.regex(value, alphaRegex);\n  },\n  message: 'The value is not alphabetical',\n});\n","import type { RegleRuleDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nconst alphaNumRegex = /^[a-zA-Z0-9]*$/;\n\nexport const alphaNum: RegleRuleDefinition<string | number, [], false, boolean, string | number> =\n  createRule({\n    type: 'alpha',\n    validator(value: Maybe<string | number>) {\n      if (ruleHelpers.isEmpty(value)) {\n        return true;\n      }\n      return ruleHelpers.regex(value, alphaNumRegex);\n    },\n    message: 'The value must be alpha-numeric',\n  });\n","import { ruleHelpers } from '../helpers';\nimport type { RegleRuleWithParamsDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\n\nexport const between: RegleRuleWithParamsDefinition<\n  number,\n  [min: number, max: number],\n  false,\n  boolean\n> = createRule({\n  type: 'between',\n  validator: (value: Maybe<number>, min: number, max: number) => {\n    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(min) && ruleHelpers.isFilled(max)) {\n      const tValue = ruleHelpers.toNumber(value);\n      const tMin = ruleHelpers.toNumber(min);\n      const tMax = ruleHelpers.toNumber(max);\n      if (\n        ruleHelpers.isNumber(tValue) &&\n        ruleHelpers.isNumber(tMin) &&\n        ruleHelpers.isNumber(tMax)\n      ) {\n        return tValue >= tMin && tValue <= tMax;\n      }\n      console.warn(\n        `[between] Value or parameters aren't numbers, got value: ${value}, min: ${min}, max: ${max}`\n      );\n      return false;\n    }\n    return true;\n  },\n  message: (_, { $params: [min, max] }) => {\n    return `The value must be between ${min} and ${max}`;\n  },\n});\n","import type { RegleRuleDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nconst decimalRegex = /^[-]?\\d*(\\.\\d+)?$/;\n\nexport const decimal: RegleRuleDefinition<string | number, [], false, boolean, string | number> =\n  createRule({\n    type: 'decimal',\n    validator(value: Maybe<number | string>) {\n      if (ruleHelpers.isEmpty(value)) {\n        return true;\n      }\n      return ruleHelpers.regex(value, decimalRegex);\n    },\n    message: 'Value must be decimal',\n  });\n","import type { RegleRuleDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nconst emailRegex =\n  /^(?:[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;\n\nexport const email: RegleRuleDefinition<string, [], false, boolean, string> = createRule({\n  type: 'email',\n  validator(value: Maybe<string>) {\n    if (ruleHelpers.isEmpty(value)) {\n      return true;\n    }\n    return ruleHelpers.regex(value, emailRegex);\n  },\n  message: 'Value must be an valid email address',\n});\n","import type { RegleRuleDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nconst integerRegex = /(^[0-9]*$)|(^-[0-9]+$)/;\n\nexport const integer: RegleRuleDefinition<string | number, [], false, boolean, string | number> =\n  createRule({\n    type: 'integer',\n    validator(value: Maybe<number | string>) {\n      if (ruleHelpers.isEmpty(value)) {\n        return true;\n      }\n      return ruleHelpers.regex(value, integerRegex);\n    },\n    message: 'Value must be an integer',\n  });\n","import { ruleHelpers } from '../helpers';\nimport type { RegleRuleWithParamsDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\n\nexport const maxValue: RegleRuleWithParamsDefinition<number, [count: number], false, boolean> =\n  createRule({\n    type: 'maxValue',\n    validator: (value: Maybe<number>, count: number) => {\n      if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(count)) {\n        if (ruleHelpers.isNumber(count) && ruleHelpers.isNumber(value)) {\n          return value <= count;\n        }\n        console.warn(\n          `[maxValue] Value or parameter isn't a number, got value: ${value}, parameter: ${count}`\n        );\n        return false;\n      }\n      return true;\n    },\n    message: (_, { $params: [count] }) => {\n      return `The maximum value allowed is ${count}`;\n    },\n  });\n","import { ruleHelpers } from '../helpers';\nimport type { RegleRuleWithParamsDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\n\nexport const minLength: RegleRuleWithParamsDefinition<\n  string | any[] | Record<PropertyKey, any>,\n  [count: number],\n  false,\n  boolean\n> = createRule({\n  type: 'minLength',\n  validator: (value: Maybe<string | Record<PropertyKey, any> | any[]>, count: number) => {\n    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(count)) {\n      if (ruleHelpers.isNumber(count)) {\n        return ruleHelpers.size(value) >= count;\n      }\n      console.warn(`[minLength] Parameter isn't a number, got parameter: ${count}`);\n      return false;\n    }\n    return true;\n  },\n  message: (value, { $params: [count] }) => {\n    if (Array.isArray(value)) {\n      return `This list should have at least ${count} items`;\n    }\n    return `This field should be at least ${count} characters long`;\n  },\n});\n","import { ruleHelpers } from '../helpers';\nimport type { RegleRuleWithParamsDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\n\nexport const minValue: RegleRuleWithParamsDefinition<number, [count: number], false, boolean> =\n  createRule({\n    type: 'minValue',\n    validator: (value: Maybe<number>, count: number) => {\n      if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(count)) {\n        if (ruleHelpers.isNumber(count) && ruleHelpers.isNumber(value)) {\n          return value >= count;\n        }\n        console.warn(\n          `[minValue] Value or parameter isn't a number, got value: ${value}, parameter: ${count}`\n        );\n        return false;\n      }\n      return true;\n    },\n    message: (_, { $params: [count] }) => {\n      return `The minimum value allowed is ${count}`;\n    },\n  });\n","import { ruleHelpers } from '../helpers';\nimport type { Maybe, RegleRuleWithParamsDefinition } from '@regle/core';\nimport { createRule } from '@regle/core';\n\nexport const exactLength: RegleRuleWithParamsDefinition<\n  string | any[] | Record<PropertyKey, any>,\n  [count: number],\n  false,\n  boolean\n> = createRule({\n  type: 'exactLength',\n  validator: (value: Maybe<string | Record<PropertyKey, any> | any[]>, count: number) => {\n    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(count)) {\n      if (ruleHelpers.isNumber(count)) {\n        return ruleHelpers.size(value) === count;\n      }\n      console.warn(`[minLength] Parameter isn't a number, got parameter: ${count}`);\n      return false;\n    }\n    return true;\n  },\n  message: (_, { $params: [count] }) => {\n    return `This field should be exactly ${count} characters long`;\n  },\n});\n","import type { RegleRuleDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nconst numericRegex = /^\\d*(\\.\\d+)?$/;\n\nexport const numeric: RegleRuleDefinition<string | number, [], false, boolean, string | number> =\n  createRule({\n    type: 'numeric',\n    validator(value: Maybe<string | number>) {\n      if (ruleHelpers.isEmpty(value)) {\n        return true;\n      }\n      return ruleHelpers.regex(value, numericRegex);\n    },\n    message: 'This field must be numeric',\n  });\n","import type { RegleRuleWithParamsDefinition } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nexport const requiredUnless: RegleRuleWithParamsDefinition<\n  unknown,\n  [condition: boolean],\n  false,\n  boolean\n> = createRule({\n  type: 'required',\n  validator(value: unknown, condition: boolean) {\n    if (!condition) {\n      return ruleHelpers.isFilled(value);\n    }\n    return true;\n  },\n  message: 'This field is required',\n  active(_, { $params: [condition] }) {\n    return !condition;\n  },\n});\n","import type { RegleRuleWithParamsDefinition } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nexport const sameAs: RegleRuleWithParamsDefinition<unknown, [target: unknown], false, boolean> =\n  createRule({\n    type: 'sameAs',\n    validator(value: unknown, target: unknown) {\n      if (ruleHelpers.isEmpty(value)) {\n        return true;\n      }\n      return value === target;\n    },\n    message(_, { $params: [target] }) {\n      return `Value must be equal to \"${target}\"`;\n    },\n  });\n","import type { RegleRuleDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\n/**\n * Regex taken from {@link https://gist.github.com/dperini/729294}\n */\nconst urlRegex =\n  /^(?:(?:(?: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;\n\nexport const url: RegleRuleDefinition<string, [], false, boolean, string> = createRule({\n  type: 'url',\n  validator(value: Maybe<string>) {\n    if (ruleHelpers.isEmpty(value)) {\n      return true;\n    }\n    return ruleHelpers.regex(value, urlRegex);\n  },\n  message: 'The value is not a valid URL address',\n});\n","import { ruleHelpers } from '../helpers';\nimport type { Maybe, RegleRuleWithParamsDefinition } from '@regle/core';\nimport { createRule } from '@regle/core';\n\nexport const dateAfter: RegleRuleWithParamsDefinition<\n  string | Date,\n  [after: Maybe<string | Date>],\n  false,\n  | true\n  | {\n      $valid: false;\n      error: 'date-not-after';\n    }\n  | {\n      $valid: false;\n      error: 'value-or-paramater-not-a-date';\n    }\n> = createRule({\n  type: 'dateAfter',\n  validator: (value: Maybe<Date | string>, after: Maybe<Date | string>) => {\n    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(after)) {\n      if (ruleHelpers.isDate(value) && ruleHelpers.isDate(after)) {\n        const result = ruleHelpers.toDate(value).getTime() > ruleHelpers.toDate(after).getTime();\n        if (result) {\n          return true;\n        }\n        return { $valid: false, error: 'date-not-after' as const };\n      }\n      return { $valid: false, error: 'value-or-paramater-not-a-date' as const };\n    }\n    return true;\n  },\n  message: (_, { $params: [after] }) => {\n    // if (error === 'value-or-paramater-not-a-date') {\n    //   return 'The inputs must be Dates';\n    // }\n    return `The date must be after ${after}`;\n  },\n});\n","import { ruleHelpers } from '../helpers';\nimport type { Maybe, RegleRuleWithParamsDefinition } from '@regle/core';\nimport { createRule } from '@regle/core';\n\nexport const dateBefore: RegleRuleWithParamsDefinition<\n  string | Date,\n  [before: Maybe<string | Date>],\n  false,\n  | true\n  | {\n      $valid: false;\n      error: 'date-not-before';\n    }\n  | {\n      $valid: false;\n      error: 'value-or-paramater-not-a-date';\n    }\n> = createRule({\n  type: 'dateBefore',\n  validator: (value: Maybe<Date | string>, before: Maybe<Date | string>) => {\n    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(before)) {\n      if (ruleHelpers.isDate(value) && ruleHelpers.isDate(before)) {\n        const result = ruleHelpers.toDate(value).getTime() < ruleHelpers.toDate(before).getTime();\n        if (result) {\n          return true;\n        }\n        return { $valid: false, error: 'date-not-before' as const };\n      }\n      return { $valid: false, error: 'value-or-paramater-not-a-date' as const };\n    }\n    return true;\n  },\n  message: (_, { $params: [before], error }) => {\n    if (error === 'value-or-paramater-not-a-date') {\n      return 'The fields must be Dates';\n    }\n    return `The date must be before ${before}`;\n  },\n});\n","import { ruleHelpers } from '../helpers';\nimport type { Maybe, RegleRuleWithParamsDefinition } from '@regle/core';\nimport { createRule } from '@regle/core';\n\nexport const dateBetween: RegleRuleWithParamsDefinition<\n  string | Date,\n  [before: Maybe<string | Date>, after: Maybe<string | Date>],\n  false,\n  boolean\n> = createRule({\n  type: 'dateBetween',\n  validator: (\n    value: Maybe<Date | string>,\n    before: Maybe<Date | string>,\n    after: Maybe<Date | string>\n  ) => {\n    if (ruleHelpers.isDate(value) && ruleHelpers.isDate(before) && ruleHelpers.isDate(after)) {\n      return (\n        ruleHelpers.toDate(value).getTime() > ruleHelpers.toDate(before).getTime() &&\n        ruleHelpers.toDate(value).getTime() < ruleHelpers.toDate(after).getTime()\n      );\n    }\n    return true;\n  },\n  message: (_, { $params: [before, after] }) => {\n    return `The date must be between ${before} and ${after}`;\n  },\n});\n","import type { RegleRuleDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nfunction nibbleValid(nibble: string) {\n  if (nibble.length > 3 || nibble.length === 0) {\n    return false;\n  }\n\n  if (nibble[0] === '0' && nibble !== '0') {\n    return false;\n  }\n\n  if (!nibble.match(/^\\d+$/)) {\n    return false;\n  }\n\n  const numeric = +nibble | 0;\n  return numeric >= 0 && numeric <= 255;\n}\n\nexport const ipAddress: RegleRuleDefinition<string, [], false, boolean, string> = createRule({\n  type: 'ipAddress',\n  validator(value: Maybe<string>) {\n    if (ruleHelpers.isEmpty(value)) {\n      return true;\n    }\n\n    if (typeof value !== 'string') {\n      return false;\n    }\n\n    const nibbles = value.split('.');\n    return nibbles.length === 4 && nibbles.every(nibbleValid);\n  },\n  message: 'The value is not a valid IP address',\n});\n","import type { RegleRuleWithParamsDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nexport const macAddress: RegleRuleWithParamsDefinition<\n  string,\n  [separator?: string | undefined],\n  false,\n  boolean\n> = createRule({\n  type: 'macAddress',\n  validator(value: Maybe<string>, separator = ':') {\n    if (ruleHelpers.isEmpty(value)) {\n      return true;\n    }\n\n    if (typeof value !== 'string') {\n      return false;\n    }\n\n    const parts =\n      typeof separator === 'string' && separator !== ''\n        ? value.split(separator)\n        : value.length === 12 || value.length === 16\n          ? value.match(/.{2}/g)\n          : null;\n\n    return parts !== null && (parts.length === 6 || parts.length === 8) && parts.every(hexValid);\n  },\n  message: 'The value is not a valid MAC Address',\n});\n\nconst hexValid = (hex: string) => hex.toLowerCase().match(/^[0-9a-f]{2}$/);\n","import type { Maybe, RegleRuleDefinition } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nexport const checked: RegleRuleDefinition<boolean, [], false, boolean, boolean> = createRule({\n  type: 'checked',\n  validator: (value: Maybe<boolean>) => {\n    if (ruleHelpers.isFilled(value)) {\n      return value === true;\n    }\n    return true;\n  },\n  message: 'This field must be checked',\n});\n","import type { RegleRuleWithParamsDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nexport const contains: RegleRuleWithParamsDefinition<\n  string,\n  [part: Maybe<string>],\n  false,\n  boolean\n> = createRule({\n  type: 'contains',\n  validator(value: Maybe<string>, part: Maybe<string>) {\n    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(part)) {\n      return value.includes(part);\n    }\n    return true;\n  },\n  message(_, { $params: [part] }) {\n    return `Field must contain ${part}`;\n  },\n});\n","import type { RegleRuleWithParamsDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nexport const startsWith: RegleRuleWithParamsDefinition<\n  string,\n  [part: Maybe<string>],\n  false,\n  boolean\n> = createRule({\n  type: 'startsWith',\n  validator(value: Maybe<string>, part: Maybe<string>) {\n    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(part)) {\n      return value.startsWith(part);\n    }\n    return true;\n  },\n  message(_, { $params: [part] }) {\n    return `Field must end with ${part}`;\n  },\n});\n","import type { RegleRuleWithParamsDefinition, Maybe } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nexport const endsWith: RegleRuleWithParamsDefinition<\n  string,\n  [part: Maybe<string>],\n  false,\n  boolean\n> = createRule({\n  type: 'endsWith',\n  validator(value: Maybe<string>, part: Maybe<string>) {\n    if (ruleHelpers.isFilled(value) && ruleHelpers.isFilled(part)) {\n      return value.endsWith(part);\n    }\n    return true;\n  },\n  message(_, { $params: [part] }) {\n    return `Field must end with ${part}`;\n  },\n});\n","import type { Maybe, RegleRuleWithParamsDefinition } from '@regle/core';\nimport { createRule } from '@regle/core';\nimport { ruleHelpers } from '../helpers';\n\nexport const regex: RegleRuleWithParamsDefinition<\n  string | number,\n  [regexp: RegExp],\n  false,\n  boolean\n> = createRule({\n  type: 'regex',\n  validator(value: Maybe<string | number>, regexp: RegExp) {\n    if (ruleHelpers.isFilled(value)) {\n      return ruleHelpers.regex(value, regexp);\n    }\n    return true;\n  },\n  message: 'This field does not match the required pattern',\n});\n"]}