@jdlien/validator 1.4.11 → 2.0.0

package/dist/validator.mjs

@@ -0,0 +1,893 @@
+const N = /^(?:[a-z+]+:)?\/\//i, F = /^(?:[-a-z+]+:)?\/\//i, V = /^\d{5}(-\d{4})?$/, x = /^[ABCEGHJKLMNPRSTVXY][0-9][ABCEGHJKLMNPRSTVWXYZ] ?[0-9][ABCEGHJKLMNPRSTVWXYZ][0-9]$/, Y = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?)*\.[a-zA-Z]{2,}$/, k = /^\d{3}-\d{3}-\d{4}$/, B = /^-?\d*$/, U = /^-?\d*\.?\d*$/;
+function R(r) {
+  let t = r.trim().toLowerCase();
+  if (t === "now") {
+    const o = /* @__PURE__ */ new Date();
+    return { hour: o.getHours(), minute: o.getMinutes(), second: o.getSeconds() };
+  }
+  if (t === "noon") return { hour: 12, minute: 0, second: 0 };
+  t = t.replace(/\s+/g, "").replace(/\.+$/g, "");
+  const e = t.replace(/^(\d{1,2})(\d{2})([ap]?m?\.?)$/i, "$1:$2$3").match(/^(\d{1,2})(?::(\d{1,2}))?(?::(\d{1,2}))?\s*([ap])?\.?m?\.?$/i);
+  if (!e) return null;
+  let s = +e[1], a = +(e[2] || 0), i = +(e[3] || 0);
+  const l = e[4]?.toLowerCase();
+  return l === "p" && s < 12 && (s += 12), l === "a" && s === 12 && (s = 0), s > 23 || a > 59 || i > 59 ? null : { hour: s, minute: a, second: i };
+}
+function K(r) {
+  return R(r) !== null;
+}
+const z = "jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec", $ = new RegExp(`(${z})[a-z]*`, "i");
+function P(r) {
+  return (/* @__PURE__ */ new Date(`1 ${r} 2000`)).getMonth();
+}
+function g(r) {
+  if (typeof r == "string" && (r = parseInt(r.replace(/\D/g, ""))), r > 99) return r;
+  const t = ((/* @__PURE__ */ new Date()).getFullYear() + 20) % 100;
+  return r + (r < t ? 2e3 : 1900);
+}
+function y(r) {
+  if (r instanceof Date) return r;
+  let t = r.trim().toLowerCase();
+  const e = new Date((/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0));
+  if (/^(now|today)$/.test(t)) return e;
+  if (t === "tomorrow") return new Date(e.setDate(e.getDate() + 1));
+  t = t.replace(/\b(mon|tue|wed|thu|fri|sat|sun|lun|mar(?:di|tes)|mer|jeu|ven|sam|dim|dom)[a-z]*\.?\b/gi, "").trim();
+  let s = 0, a = 0, i = 0;
+  const l = t.match(/(\d{1,2}:\d{2}(?::\d{2})?\s*[ap]?\.?m?\.?)/i);
+  if (l) {
+    const h = R(l[1]);
+    if (h && ({ hour: s, minute: a, second: i } = h), t = t.replace(l[0], "").trim(), !t || t.length <= 2) {
+      const m = /* @__PURE__ */ new Date();
+      return new Date(m.getFullYear(), m.getMonth(), m.getDate(), s, a, i);
+    }
+  }
+  if (/^\d{8}$/.test(t))
+    return new Date(+t.slice(0, 4), +t.slice(4, 6) - 1, +t.slice(6, 8), s, a, i);
+  if (/^\d{6}$/.test(t))
+    return new Date(g(+t.slice(0, 2)), +t.slice(2, 4) - 1, +t.slice(4, 6), s, a, i);
+  const o = t.match($);
+  let u = -1, n = 0, d = 0;
+  o && (u = P(o[1]), t = t.replace(o[0], " ").trim());
+  const f = t.match(/'(\d{2})\b/);
+  f && (n = g(+f[1]), t = t.replace(f[0], " ").trim());
+  const c = t.match(/\d+/g)?.map(Number) || [];
+  if (u >= 0)
+    c.length >= 2 ? c[0] > 99 ? (n = c[0], d = c[1]) : c[1] > 99 ? (n = c[1], d = c[0]) : c[0] > 31 ? (d = c[1], n = g(c[0])) : c[1] > 31 ? (d = c[0], n = g(c[1])) : (d = c[0], n = n || g(c[1])) : c.length === 1 && (d = c[0], n = n || (/* @__PURE__ */ new Date()).getFullYear());
+  else if (c.length >= 3) {
+    const [h, m, p] = c;
+    h > 31 ? (n = h, u = m - 1, d = p) : h > 12 && p > 12 ? (d = h, u = m - 1, n = p > 31 ? p : g(p)) : p > 31 || p > 12 ? (u = h - 1, d = m, n = p > 31 ? p : g(p)) : (u = h - 1, d = m, n = g(p));
+  } else c.length === 2 && (u = c[0] - 1, d = c[1], n = n || (/* @__PURE__ */ new Date()).getFullYear());
+  return n && u >= 0 && d && d >= 1 && d <= 31 ? new Date(n > 99 ? n : g(n), u, d, s, a, i) : /* @__PURE__ */ new Date("");
+}
+function w(r) {
+  if (r instanceof Date) return r;
+  let t = r.trim();
+  if (t.length < 3) return null;
+  if (t = t.replace(/(\d)T(\d)/i, "$1 $2"), t = t.replace(
+    /(^|[\sT])(\d{1,2})\.(\d{1,2})(?:\.(\d{1,2}))?(?=\s*[ap]\.?m?\.?\b|(?:\s|$))/gi,
+    (o, u, n, d, f) => `${u}${f ? `${n}:${d}:${f}` : `${n}:${d}`}`
+  ), /^now$/i.test(t)) {
+    const o = /* @__PURE__ */ new Date();
+    return o.setMilliseconds(0), o;
+  }
+  if (/^noon$/i.test(t)) {
+    const o = /* @__PURE__ */ new Date();
+    return new Date(o.getFullYear(), o.getMonth(), o.getDate(), 12, 0, 0);
+  }
+  let e = null, s = t;
+  const a = [
+    /(\d{1,2}:\d{1,2}(?::\d{2})?)\s*([ap]\.?m?\.?)?/i,
+    // 14:30, 2:30pm, 1:5
+    /\b(\d{1,2})\s*([ap]\.?m?\.?)\b/i,
+    // 2pm, 2p.m., 2 PM, 1P
+    /\b(\d{3,4})([ap])m?\b/i
+    // 1430pm, 230p, 1200AM
+  ];
+  for (const o of a) {
+    const u = t.match(o);
+    if (u) {
+      const n = R(u[0]);
+      if (n) {
+        e = n, s = t.replace(u[0], " ").replace(/[\s.]+$/g, "").replace(/\s+/g, " ").trim();
+        break;
+      }
+    }
+  }
+  if (!e) {
+    const o = s.match(
+      /^(\d{4}[\-\/\.\s]\d{1,2}[\-\/\.\s]\d{1,2}|\d{8})\s+(\d{1,6})(\s*[ap]\.?m?\.?)?(?:\s*(?:z|utc|gmt|[+-]\d{2}:?\d{2})\b)?$/i
+    );
+    if (o) {
+      const u = o[2], n = (o[3] || "").replace(/\s+/g, "");
+      let d = u + n;
+      u.length === 6 && (d = `${u.slice(0, 2)}:${u.slice(2, 4)}:${u.slice(4, 6)}${n}`);
+      const f = R(d);
+      f && (e = f, s = o[1]);
+    }
+  }
+  if (!e) {
+    const o = s.match(/^(.+?)\s+(\d{1,2})(\s*[ap]\.?m?\.?)?$/i);
+    if (o) {
+      const u = o[2] + (o[3] || ""), n = R(u);
+      n && $.test(o[1]) && (e = n, s = o[1]);
+    }
+  }
+  if (e && (!s || /^,?\s*$/.test(s))) {
+    const o = /* @__PURE__ */ new Date();
+    return new Date(o.getFullYear(), o.getMonth(), o.getDate(), e.hour, e.minute, e.second);
+  }
+  const i = y(s);
+  if (isNaN(i.getTime())) return null;
+  const l = e || { hour: 0, minute: 0, second: 0 };
+  return new Date(i.getFullYear(), i.getMonth(), i.getDate(), l.hour, l.minute, l.second);
+}
+function A(r, t = "YYYY-MM-DD") {
+  if (typeof r == "string" && (r = y(r)), isNaN(r.getTime())) return "";
+  const e = r.getFullYear(), s = r.getMonth(), a = r.getDate(), i = r.getDay(), l = r.getHours(), o = r.getMinutes(), u = r.getSeconds(), n = r.getMilliseconds(), d = (v, b = 2) => String(v).padStart(b, "0"), f = l % 12 || 12, c = l < 12 ? "AM" : "PM", h = ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"], m = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"], p = {
+    YYYY: e,
+    YY: String(e).slice(-2),
+    MMMM: h[s],
+    MMM: h[s].slice(0, 3),
+    MM: d(s + 1),
+    M: s + 1,
+    DD: d(a),
+    D: a,
+    dddd: m[i],
+    ddd: m[i].slice(0, 3),
+    dd: m[i].slice(0, 2),
+    d: i,
+    HH: d(l),
+    H: l,
+    hh: d(f),
+    h: f,
+    mm: d(o),
+    m: o,
+    ss: d(u),
+    s: u,
+    SSS: d(n, 3),
+    A: c,
+    a: c.toLowerCase()
+  };
+  return t.replace(
+    /\[([^\]]+)]|YYYY|YY|MMMM|MMM|MM|M|DD|D|dddd|ddd|dd|d|HH|H|hh|h|mm|m|ss|s|SSS|A|a/g,
+    (v, b) => b ?? String(p[v])
+  );
+}
+function Z(r) {
+  return typeof r != "string" && !(r instanceof Date) ? !1 : !isNaN(y(r).getTime());
+}
+function q(r) {
+  if (typeof r != "string" && !(r instanceof Date)) return !1;
+  const t = w(r);
+  return t !== null && !isNaN(t.getTime());
+}
+function G(r, t = "YYYY-MMM-DD") {
+  const e = y(r);
+  return isNaN(e.getTime()) ? "" : A(e, t);
+}
+function j(r, t = "YYYY-MMM-DD h:mm A") {
+  const e = w(r);
+  return e && !isNaN(e.getTime()) ? A(e, t) : "";
+}
+function X(r, t = "h:mm A") {
+  const e = R(r);
+  if (!e) return "";
+  const s = /* @__PURE__ */ new Date();
+  return s.setHours(e.hour, e.minute, e.second, 0), A(s, t);
+}
+function W(r) {
+  const t = r.match(/^([+-])?(\d+)([dwmy])$/i);
+  if (!t) return null;
+  const [, e, s, a] = t, i = parseInt(s) * (e === "-" ? -1 : 1), l = /* @__PURE__ */ new Date();
+  switch (l.setHours(0, 0, 0, 0), a.toLowerCase()) {
+    case "d":
+      l.setDate(l.getDate() + i);
+      break;
+    case "w":
+      l.setDate(l.getDate() + i * 7);
+      break;
+    case "m":
+      l.setMonth(l.getMonth() + i);
+      break;
+    case "y":
+      l.setFullYear(l.getFullYear() + i);
+      break;
+  }
+  return l;
+}
+const D = /(\d{1,2}:\d{2}|\d{1,2}\.\d{2}|\b\d{1,2}\s*[ap]\b|\b[ap]\.?m\.?\b|\bnoon\b|\bnow\b|T\d{1,2})/i, J = /(\d{1,2}[-/.]\d{1,2}(?:[-/.]\d{2,4})?|\b\d{4}\b|\b\d{6,8}\b|\b(?:jan|feb|mar|apr|may|jun|jul|aug|sep|sept|oct|nov|dec)\b|\btoday\b|\btomorrow\b|\byesterday\b)/i;
+function Q(r, t) {
+  if (t === "past")
+    return r <= /* @__PURE__ */ new Date();
+  if (t === "future")
+    return r.getTime() >= (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0);
+  if (t === "today") {
+    const n = /* @__PURE__ */ new Date();
+    return r.getFullYear() === n.getFullYear() && r.getMonth() === n.getMonth() && r.getDate() === n.getDate();
+  }
+  const e = (n) => {
+    const d = n.trim();
+    if (!d) return { date: null, hasTime: !1, valid: !0 };
+    const f = W(d);
+    if (f) return { date: f, hasTime: !1, valid: !0 };
+    const c = d.search(J);
+    if (c === -1) return { date: null, hasTime: !1, valid: !1 };
+    const h = d.search(D);
+    if (h !== -1 && h < c) return { date: null, hasTime: !1, valid: !1 };
+    const m = w(d);
+    return m && !isNaN(m.getTime()) ? { date: m, hasTime: D.test(d), valid: !0 } : { date: null, hasTime: !1, valid: !1 };
+  };
+  let s = null;
+  if (t.includes(":"))
+    for (let n = 0; n < t.length; n += 1) {
+      if (t[n] !== ":") continue;
+      const d = e(t.slice(0, n)), f = e(t.slice(n + 1));
+      if (d.valid && f.valid) {
+        s = { start: d, end: f };
+        break;
+      }
+    }
+  if (!s) {
+    const n = e(t);
+    return n.valid && n.date ? n.hasTime ? r.getTime() === n.date.getTime() : r.getFullYear() === n.date.getFullYear() && r.getMonth() === n.date.getMonth() && r.getDate() === n.date.getDate() : !0;
+  }
+  const a = s.start, i = s.end, l = a.hasTime || i.hasTime ? r.getTime() : new Date(r.getFullYear(), r.getMonth(), r.getDate()).getTime();
+  let o = null;
+  a.date && (o = a.hasTime ? a.date.getTime() : new Date(a.date.getFullYear(), a.date.getMonth(), a.date.getDate()).getTime());
+  let u = null;
+  return i.date && (u = i.hasTime ? i.date.getTime() : new Date(i.date.getFullYear(), i.date.getMonth(), i.date.getDate(), 23, 59, 59, 999).getTime()), !(o !== null && l < o || u !== null && l > u);
+}
+function tt(r) {
+  return r instanceof HTMLInputElement || r instanceof HTMLSelectElement || r instanceof HTMLTextAreaElement;
+}
+function I(r, t) {
+  return typeof t == "string" && (t = [t]), t.includes(r.dataset.type || "") || t.includes(r.type);
+}
+function et(r) {
+  return r.length <= 255 && Y.test(r);
+}
+function rt(r) {
+  return r.replace(/^[^2-90]+/g, "").replace(/(\d\d\d).*?(\d\d\d).*?(\d\d\d\d)(.*)/, "$1-$2-$3$4");
+}
+function st(r) {
+  return k.test(r);
+}
+function S(r) {
+  return r.replace(/[^0-9]/g, "");
+}
+function at(r) {
+  return B.test(r);
+}
+function _(r) {
+  const t = r.replace(/[^\-0-9.]/g, "");
+  let e = "", s = !1, a = !1;
+  for (let i = 0; i < t.length; i += 1) {
+    const l = t[i];
+    if (l === "-") {
+      !a && e.length === 0 && (e += "-", a = !0);
+      continue;
+    }
+    if (l === ".") {
+      s || (e += ".", s = !0);
+      continue;
+    }
+    e += l;
+  }
+  return e;
+}
+function it(r) {
+  return U.test(r);
+}
+const nt = { "": 1, K: 1e3, M: 1e6, G: 1e9, T: 1e12 }, ot = { "": 1, K: 1024, M: 1024 ** 2, G: 1024 ** 3, T: 1024 ** 4 };
+function C(r) {
+  const t = r.trim().match(/^(\d+(?:\.\d*)?|\.\d+)\s*(B|Ki?B?|Mi?B?|Gi?B?|Ti?B?)?$/i);
+  if (!t) return NaN;
+  const e = Number.parseFloat(t[1]), s = t[2]?.toUpperCase() || "", a = s.includes("I"), i = s.replace(/I?B$/i, "").replace(/I$/i, "") || "";
+  return e * (a ? ot : nt)[i];
+}
+function H(r, t = !0) {
+  const e = t ? 1e3 : 1024, s = ["B", "KB", "MB", "GB", "TB"];
+  if (r < e) return `${r} B`;
+  let a = 0, i = r;
+  for (; i >= e && a < s.length - 1; )
+    i /= e, a++;
+  let l = Math.round(i * 10) / 10;
+  return l >= e && a < s.length - 1 && (l = 1, a++), `${l % 1 === 0 ? l.toFixed(0) : l.toFixed(1)} ${s[a]}`;
+}
+function lt(r) {
+  return r = r.trim(), N.test(r) ? r : "https://" + r;
+}
+function ut(r) {
+  return F.test(r);
+}
+function dt(r) {
+  return r = r.replace(/[^0-9]/g, "").replace(/(.{5})(.*)/, "$1-$2").trim(), r.length === 6 ? r.replace(/-/, "") : r;
+}
+function ct(r) {
+  return V.test(r);
+}
+function ht(r) {
+  return r.toUpperCase().replace(/[^A-Z0-9]/g, "").replace(/(.{3})\s*(.*)/, "$1 $2").trim();
+}
+function ft(r) {
+  return x.test(r);
+}
+function O(r) {
+  return ["transparent", "currentColor"].includes(r) ? !0 : !r.trim() || typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("color", r);
+}
+let M = null;
+const L = /* @__PURE__ */ new Map();
+function mt(r) {
+  if (r = r.trim().toLowerCase(), ["transparent", "currentcolor"].includes(r)) return r;
+  if (L.has(r)) return L.get(r);
+  M || (M = document.createElement("canvas"), M.willReadFrequently = !0);
+  const t = M.getContext("2d");
+  t.fillStyle = r, t.fillRect(0, 0, 1, 1);
+  const e = t.getImageData(0, 0, 1, 1).data, s = "#" + ("000000" + (e[0] << 16 | e[1] << 8 | e[2]).toString(16)).slice(-6);
+  return L.set(r, s), s;
+}
+function pt(r) {
+  if (typeof r == "boolean") return { valid: r, error: !1, messages: [] };
+  if (typeof r == "string") return { valid: !1, error: !1, messages: [r] };
+  const t = { valid: r.valid, error: r.error ?? !1, messages: [] };
+  return typeof r.message == "string" ? t.messages = [r.message] : typeof r.messages == "string" ? t.messages = [r.messages] : Array.isArray(r.messages) && (t.messages = r.messages), t;
+}
+const T = typeof CSS < "u" && typeof CSS.escape == "function" ? (r) => CSS.escape(r) : (r) => r.replace(/([.#{}()\\?*[\]-])/g, "\\$1");
+class Et extends Event {
+  constructor(t, e) {
+    super(t, { cancelable: !0 }), this.submitEvent = e;
+  }
+}
+class E {
+  // Static (global) validator registry
+  static globalValidators = {};
+  /** Register a validator function globally (available to all instances) */
+  static registerValidator(t, e) {
+    E.globalValidators[t] = e;
+  }
+  /** Remove a globally registered validator */
+  static unregisterValidator(t) {
+    delete E.globalValidators[t];
+  }
+  /** Get a copy of all globally registered validators */
+  static getValidators() {
+    return { ...E.globalValidators };
+  }
+  /** Remove all globally registered validators */
+  static clearValidators() {
+    E.globalValidators = {};
+  }
+  /** Validates a single input without needing a Validator instance. */
+  static async validateSingle(t, e = {}) {
+    if (!t || t.disabled) return !0;
+    const s = new E(document.createElement("form"), { autoInit: !1, ...e });
+    return s.inputs = [t], s.validateSingle(t);
+  }
+  /** Clears errors from a single input without needing a Validator instance. */
+  static clearInputErrors(t, e = {}) {
+    if (!t) return;
+    new E(document.createElement("form"), { autoInit: !1, ...e }).clearInputErrors(t);
+  }
+  form;
+  inputs = [];
+  // Keeps track of error messages accumulated for each input
+  inputErrors = {};
+  // Default error messages.
+  messages = {
+    ERROR_MAIN: "There is a problem with your submission.",
+    ERROR_GENERIC: "Enter a valid value.",
+    ERROR_REQUIRED: "This field is required.",
+    OPTION_REQUIRED: "An option must be selected.",
+    CHECKED_REQUIRED: "This must be checked.",
+    ERROR_MAXLENGTH: "This must be ${val} characters or fewer.",
+    ERROR_MINLENGTH: "This must be at least ${val} characters.",
+    ERROR_MIN_VALUE: "The value must be at least ${val}.",
+    ERROR_MAX_VALUE: "The value must be at most ${val}.",
+    ERROR_NUMBER: "This must be a number.",
+    ERROR_INTEGER: "This must be a whole number.",
+    ERROR_TEL: "This is not a valid telephone number.",
+    ERROR_EMAIL: "This is not a valid email address.",
+    ERROR_ZIP: "This is not a valid zip code.",
+    ERROR_POSTAL: "This is not a valid postal code.",
+    ERROR_DATE: "This is not a valid date.",
+    ERROR_DATE_PAST: "The date must be in the past.",
+    ERROR_DATE_FUTURE: "The date must be in the future.",
+    ERROR_DATE_TODAY: "The date must be today.",
+    ERROR_DATE_RANGE: "The date is outside the allowed range.",
+    ERROR_DATETIME: "This is not a valid date and time.",
+    ERROR_TIME: "This is not a valid time.",
+    ERROR_URL: "This is not a valid URL.",
+    ERROR_COLOR: "This is not a valid CSS colour.",
+    ERROR_FILE_TYPE: "This file type is not allowed.",
+    ERROR_FILE_MAX_FILES: "You can upload up to ${val} file(s).",
+    ERROR_FILE_MAX_SIZE: "Each file must be ${val} or smaller.",
+    ERROR_FILE_MIN_SIZE: "Each file must be at least ${val}.",
+    ERROR_CUSTOM_VALIDATION: "There was a problem validating this field."
+  };
+  // Show debug messages in the console
+  debug;
+  // Whether validation should be performed immediately on instantiation
+  autoInit;
+  // Whether to prevent the form from submitting if validation is successful
+  preventSubmit = !1;
+  // Class toggled hide an element (eg display:none)
+  hiddenClasses;
+  // Whether to show the main error message
+  showMainError = !0;
+  // Whether to scroll to the first error on validation failure
+  scrollToError = !1;
+  // Delay in ms before scrolling to the first error (allows animations to complete)
+  scrollToErrorDelay = 0;
+  // Whether to validate inputs when they lose focus (even if unchanged)
+  validateOnBlur = !1;
+  // Classes to apply to the main error message (space-separated)
+  errorMainClasses;
+  // Classes added to an invalid input (space-separated)
+  errorInputClasses;
+  // Timeout for dispatching events on input (used by syncColorInput)
+  dispatchTimeout = 0;
+  // Pre-split class arrays for performance (avoid repeated .split(' ') calls)
+  hiddenClassesArray = [];
+  errorMainClassesArray = [];
+  errorInputClassesArray = [];
+  // Whether the original form has a novalidate attribute
+  originalNoValidate = !1;
+  validationSuccessCallback;
+  validationErrorCallback;
+  // Instance validator registry (highest priority lookup)
+  validators = {};
+  // Sets defaults and adds event listeners
+  constructor(t, e = {}) {
+    if (!t) throw new Error("Validator requires a form to be passed as the first argument.");
+    if (!(t instanceof HTMLFormElement))
+      throw new Error("form argument must be an instance of HTMLFormElement");
+    this.form = t, (t.dataset.preventSubmit === "" || t.dataset.preventSubmit) && (this.preventSubmit = !0), Object.assign(this.messages, e.messages || {}), this.debug = e.debug || !1, this.autoInit = e.autoInit !== !1, this.preventSubmit = e.preventSubmit !== void 0 ? e.preventSubmit : this.preventSubmit, this.hiddenClasses = e.hiddenClasses || "hidden opacity-0", this.errorMainClasses = e.errorMainClasses || "m-2 border border-red-500 bg-red-100 p-3 dark:bg-red-900/80 text-center", this.errorInputClasses = e.errorInputClasses || "border-red-600 dark:border-red-500", this.showMainError = e.showMainError !== void 0 ? e.showMainError : !0, this.scrollToError = e.scrollToError || !1, this.scrollToErrorDelay = e.scrollToErrorDelay || 0, this.validateOnBlur = e.validateOnBlur || !1, this.hiddenClassesArray = this.hiddenClasses.split(" ").filter(Boolean), this.errorMainClassesArray = this.errorMainClasses.split(" ").filter(Boolean), this.errorInputClassesArray = this.errorInputClasses.split(" ").filter(Boolean), this.validationSuccessCallback = e.validationSuccessCallback || (() => {
+    }), this.validationErrorCallback = e.validationErrorCallback || (() => {
+    }), e.validators && Object.assign(this.validators, e.validators), this.autoInit && this.init();
+  }
+  // Event handler references
+  submitHandlerRef = this.submitHandler.bind(this);
+  inputInputHandlerRef = this.inputInputHandler.bind(this);
+  inputChangeHandlerRef = this.inputChangeHandler.bind(this);
+  inputBlurHandlerRef = this.inputBlurHandler.bind(this);
+  inputKeydownHandlerRef = this.inputKeydownHandler.bind(this);
+  addEventListeners() {
+    this.form.addEventListener("submit", this.submitHandlerRef), this.form.addEventListener("input", this.inputInputHandlerRef), this.form.addEventListener("change", this.inputChangeHandlerRef), this.form.addEventListener("keydown", this.inputKeydownHandlerRef), this.validateOnBlur && this.form.addEventListener("blur", this.inputBlurHandlerRef, !0);
+  }
+  removeEventListeners() {
+    this.form.removeEventListener("submit", this.submitHandlerRef), this.form.removeEventListener("input", this.inputInputHandlerRef), this.form.removeEventListener("change", this.inputChangeHandlerRef), this.form.removeEventListener("keydown", this.inputKeydownHandlerRef), this.form.removeEventListener("blur", this.inputBlurHandlerRef, !0);
+  }
+  // Adds event listeners to all formFields in a specified form
+  init() {
+    this.inputErrors = {}, this.inputs = Array.from(this.form.elements).filter(
+      (t) => t instanceof HTMLInputElement || t instanceof HTMLTextAreaElement || t instanceof HTMLSelectElement
+    ), this.inputs.forEach((t) => {
+      !t.name && !t.id && (t.id = `vl-input-${Math.random().toString(36).slice(2)}`), this.inputErrors[t.name || t.id] = [];
+    }), this.originalNoValidate = this.form.hasAttribute("novalidate"), this.form.setAttribute("novalidate", "novalidate"), this.removeEventListeners(), this.addEventListeners();
+  }
+  // end init()
+  getErrorEl(t) {
+    const e = (o) => this.form.querySelector(`#${T(o)}`) || document.getElementById(o) || null, s = t.closest("[data-flux-field]");
+    if (s) {
+      const o = s.querySelector("[data-flux-error]");
+      if (o) return o;
+    }
+    const a = t.getAttribute("aria-describedby");
+    if (a) {
+      const o = e(a);
+      if (o) return o;
+    }
+    const i = e(t.id + "-error");
+    return i || e(t.name + "-error") || null;
+  }
+  addErrorMain(t) {
+    let e = this._getMainErrorElement();
+    e || (e = document.createElement("div"), e.id = "form-error-main", this.form.appendChild(e)), e.classList.add(...this.errorMainClassesArray), e.innerHTML = t || this.messages.ERROR_MAIN, e.classList.remove(...this.hiddenClassesArray);
+  }
+  // Helper method to find the main error element
+  _getMainErrorElement() {
+    if (this.form.id) {
+      const t = `${this.form.id}-error-main`, e = document.getElementById(t);
+      if (e)
+        return e;
+    }
+    return this.form.querySelector("#form-error-main");
+  }
+  // Adds an error to the array of strings to be displayed by an input that failed
+  addInputError(t, e = t.dataset.errorDefault || this.messages.ERROR_GENERIC) {
+    const s = t.name || t.id;
+    this.debug && console.log("Invalid value for " + s + ": " + e), s in this.inputErrors || (this.inputErrors[s] = []), this.inputErrors[s].includes(e) || this.inputErrors[s].push(e);
+  }
+  // Shows an error message in a container with the input's id suffixed with -error.
+  // A future version of this could inject an error element into the DOM if it doesn't exist
+  showInputErrors(t) {
+    if (!t || !t.name && !t.id) return;
+    const e = t.name || t.id, s = e in this.inputErrors ? this.inputErrors[e] : [];
+    if (!s.length) return;
+    t.setAttribute("aria-invalid", "true"), t.classList.add(...this.errorInputClassesArray);
+    let a = this.getErrorEl(t);
+    a && (a.innerHTML = s.join("<br>"), a.classList.remove(...this.hiddenClassesArray));
+  }
+  // Shows all the error messages for all the inputs of the form, and a main error message
+  showFormErrors() {
+    this.inputs.forEach((e) => this.showInputErrors(e));
+    const t = this.inputs.find((e) => this.inputErrors[e.name || e.id]?.length > 0);
+    if (this.showMainError && Object.values(this.inputErrors).some((e) => Array.isArray(e) && e.length)) {
+      let e = this._getMainErrorElement();
+      e ? (e.innerHTML || (e.innerHTML = this.messages.ERROR_MAIN), e.classList.remove(...this.hiddenClassesArray)) : this.addErrorMain();
+    }
+    if (this.scrollToError && t) {
+      const e = () => {
+        t.scrollIntoView({ behavior: "smooth", block: "center" }), t.focus({ preventScroll: !0 });
+      };
+      this.scrollToErrorDelay > 0 ? setTimeout(e, this.scrollToErrorDelay) : e();
+    }
+  }
+  /** Clears error messages from an input and removes its errors from the inputErrors array */
+  clearInputErrors(t) {
+    const e = t.name || t.id;
+    if (this.inputErrors[e] = [], t instanceof HTMLInputElement && (t.type === "checkbox" || t.type === "radio") && t.name) {
+      const a = T(t.name);
+      if (this.form.querySelector(`input[name="${a}"]:checked`)) {
+        this.form.querySelectorAll(`input[name="${a}"]`).forEach((o) => {
+          o.removeAttribute("aria-invalid"), o.classList.remove(...this.errorInputClassesArray);
+        });
+        const l = this.getErrorEl(t);
+        l && (l.classList.add(...this.hiddenClassesArray), l.textContent = "");
+        return;
+      }
+    }
+    t.removeAttribute("aria-invalid"), t.classList.remove(...this.errorInputClassesArray);
+    let s = this.getErrorEl(t);
+    s && (s.classList.add(...this.hiddenClassesArray), s.textContent = "");
+  }
+  /** Clears the main error banner and all input errors */
+  clearAllErrors() {
+    const t = this._getMainErrorElement();
+    t && t.classList.add(...this.hiddenClassesArray), this.inputs.forEach((e) => this.clearInputErrors(e));
+  }
+  hasInputValue(t) {
+    return t instanceof HTMLInputElement && t.type === "file" ? !!t.files && t.files.length > 0 : t.value.length > 0;
+  }
+  // Validates a required input and returns true if it's valid.
+  // Shows an error if the input is required and empty.
+  validateRequired(t) {
+    let e = !0;
+    const s = t instanceof HTMLInputElement && ["checkbox", "radio"].includes(t.type), i = t instanceof HTMLInputElement && t.type === "file" ? !this.hasInputValue(t) : t.value === "" || s && !t.checked;
+    if (t.required && i)
+      if (s) {
+        let l = !1, o = t.name;
+        const u = this.form.querySelectorAll(`input[name="${o}"]`);
+        if (u.forEach((n) => {
+          if (n instanceof HTMLInputElement && n.checked === !0) {
+            l = !0;
+            return;
+          }
+        }), l === !1) {
+          e = !1;
+          let n = u.length > 1 ? this.messages.OPTION_REQUIRED : this.messages.CHECKED_REQUIRED;
+          t.dataset.errorDefault && (n = t.dataset.errorDefault), this.addInputError(t, n);
+        }
+      } else tt(t) && (e = !1, this.addInputError(t, t.dataset.errorDefault || this.messages.ERROR_REQUIRED));
+    return e;
+  }
+  // end validateRequired
+  // Validates a min and max length
+  validateLength(t) {
+    let e = !0;
+    if (t.disabled || t instanceof HTMLInputElement && t.type === "file") return e;
+    if ((t instanceof HTMLInputElement || t instanceof HTMLTextAreaElement) && t.value.length) {
+      let s = t.minLength > 0 ? t.minLength : t.dataset.minLength ? parseInt(t.dataset.minLength) : 0, a = t.maxLength > 0 && t.maxLength < 5e5 ? t.maxLength : t.dataset.maxLength ? parseInt(t.dataset.maxLength) : 1 / 0;
+      s > 0 && t.value.length < s && (e = !1, this.addInputError(
+        t,
+        this.messages.ERROR_MINLENGTH.replace("${val}", s.toString())
+      )), t.value.length > a && (e = !1, this.addInputError(
+        t,
+        this.messages.ERROR_MAXLENGTH.replace("${val}", a.toString())
+      ));
+    }
+    return e;
+  }
+  // Validates min/max numeric value constraints
+  validateValue(t) {
+    let e = !0;
+    if (t.disabled || !(t instanceof HTMLInputElement) || !t.value.length) return e;
+    const s = ["number", "integer", "float", "decimal"], a = t.dataset.type || t.type;
+    if (!s.includes(a) && !s.includes(t.type)) return e;
+    const i = parseFloat(t.value);
+    if (isNaN(i)) return e;
+    const l = t.dataset.min ?? t.min, o = t.dataset.max ?? t.max;
+    if (l !== void 0 && l !== "") {
+      const u = parseFloat(l);
+      !isNaN(u) && i < u && (e = !1, this.addInputError(t, this.messages.ERROR_MIN_VALUE.replace("${val}", l)));
+    }
+    if (o !== void 0 && o !== "") {
+      const u = parseFloat(o);
+      !isNaN(u) && i > u && (e = !1, this.addInputError(t, this.messages.ERROR_MAX_VALUE.replace("${val}", o)));
+    }
+    return e;
+  }
+  // A map of input handlers that can be used for each type of input.
+  // errorKey references this.messages at validation time to support custom messages
+  // Handler for number types (shared by float/decimal aliases)
+  numberHandler = {
+    parse: _,
+    isValid: it,
+    errorKey: "ERROR_NUMBER"
+  };
+  inputHandlers = {
+    number: this.numberHandler,
+    float: this.numberHandler,
+    decimal: this.numberHandler,
+    integer: {
+      parse: S,
+      isValid: at,
+      errorKey: "ERROR_INTEGER"
+    },
+    tel: {
+      parse: rt,
+      isValid: st,
+      errorKey: "ERROR_TEL"
+    },
+    email: {
+      parse: (t) => t.trim(),
+      isValid: et,
+      errorKey: "ERROR_EMAIL"
+    },
+    zip: {
+      parse: dt,
+      isValid: ct,
+      errorKey: "ERROR_ZIP"
+    },
+    postal: {
+      parse: ht,
+      isValid: ft,
+      errorKey: "ERROR_POSTAL"
+    },
+    url: {
+      parse: lt,
+      isValid: ut,
+      errorKey: "ERROR_URL"
+    },
+    date: {
+      parse: G,
+      isValid: Z,
+      errorKey: "ERROR_DATE"
+    },
+    datetime: {
+      parse: j,
+      isValid: q,
+      errorKey: "ERROR_DATETIME"
+    },
+    time: {
+      parse: X,
+      isValid: K,
+      errorKey: "ERROR_TIME"
+    },
+    color: {
+      parse: (t) => t.trim().toLowerCase(),
+      isValid: O,
+      errorKey: "ERROR_COLOR"
+    }
+  };
+  validateInputType(t) {
+    const e = t.dataset.type || t.type, s = this.inputHandlers[t.type] || this.inputHandlers[e];
+    if (s) {
+      const a = t.dataset.dateFormat || t.dataset.timeFormat, i = s.parse(t.value, a), l = ["date", "time", "datetime-local", "month", "week"];
+      if (i.length && !l.includes(t.type) && (t.value = i), !s.isValid(t.value))
+        return this.addInputError(t, this.messages[s.errorKey]), !1;
+    }
+    return !0;
+  }
+  validateDateRange(t) {
+    if (t.dataset.dateRange) {
+      const e = t.dataset.dateRange, s = y(t.value);
+      if (!isNaN(s.getTime()) && !Q(s, e)) {
+        let a = t.dataset.errorDefault || this.messages.ERROR_DATE_RANGE;
+        return e === "past" ? a = this.messages.ERROR_DATE_PAST : e === "future" ? a = this.messages.ERROR_DATE_FUTURE : e === "today" && (a = this.messages.ERROR_DATE_TODAY), this.addInputError(t, a), !1;
+      }
+    }
+    return !0;
+  }
+  parseAcceptList(t) {
+    const e = [], s = [];
+    for (const a of t.split(",")) {
+      const i = a.trim().toLowerCase();
+      i && (i.startsWith(".") ? s.push(i) : i.includes("/") && e.push(i));
+    }
+    return { mimeTypes: e, extensions: s };
+  }
+  validateFileInput(t) {
+    if (t.type !== "file") return !0;
+    const e = Array.from(t.files || []);
+    if (!e.length) return !0;
+    let s = !0;
+    const a = Number.parseInt(t.dataset.maxFiles || "", 10);
+    Number.isFinite(a) && a >= 0 && e.length > a && (this.addInputError(
+      t,
+      this.messages.ERROR_FILE_MAX_FILES.replace("${val}", a.toString())
+    ), s = !1);
+    const i = t.dataset.minFileSize || "";
+    if (i) {
+      const u = C(i);
+      Number.isNaN(u) ? (this.debug && console.warn(`Validator: Invalid min-file-size "${i}"`), this.addInputError(t, this.messages.ERROR_FILE_MIN_SIZE.replace("${val}", i)), s = !1) : e.some((d) => d.size < u) && (this.addInputError(
+        t,
+        this.messages.ERROR_FILE_MIN_SIZE.replace("${val}", H(u))
+      ), s = !1);
+    }
+    const l = t.dataset.maxFileSize || "";
+    if (l) {
+      const u = C(l);
+      Number.isNaN(u) ? (this.debug && console.warn(`Validator: Invalid max-file-size "${l}"`), this.addInputError(t, this.messages.ERROR_FILE_MAX_SIZE.replace("${val}", l)), s = !1) : e.some((d) => d.size > u) && (this.addInputError(
+        t,
+        this.messages.ERROR_FILE_MAX_SIZE.replace("${val}", H(u))
+      ), s = !1);
+    }
+    const o = (t.dataset.accept ?? t.accept ?? "").trim();
+    if (o) {
+      const { mimeTypes: u, extensions: n } = this.parseAcceptList(o);
+      if (u.length || n.length) {
+        const d = (c) => u.some((h) => h === "*/*" ? !0 : h.endsWith("/*") ? c.startsWith(h.slice(0, -1)) : h === c), f = (c) => {
+          const h = c.type.toLowerCase(), m = c.name.toLowerCase(), p = h && u.length ? d(h) : !1, v = n.length ? n.some((b) => m.endsWith(b)) : !1;
+          return p || v;
+        };
+        e.some((c) => !f(c)) && (this.addInputError(t, this.messages.ERROR_FILE_TYPE), s = !1);
+      }
+    }
+    return s;
+  }
+  // Validates a pattern from data-pattern or pattern; data-pattern takes precedence
+  // Anchors pattern to match HTML5 pattern attribute behavior (full value must match)
+  validatePattern(t) {
+    if (t instanceof HTMLInputElement && t.type === "file") return !0;
+    const e = t.dataset.pattern || t instanceof HTMLInputElement && t.pattern || null;
+    if (!e) return !0;
+    let s;
+    try {
+      s = new RegExp(`^(?:${e})$`);
+    } catch {
+      return !0;
+    }
+    return s.test(t.value) ? !0 : (this.addInputError(t), !1);
+  }
+  /**
+   * Resolves a validator function by name using three-tier lookup:
+   * 1. Instance registry (this.validators)
+   * 2. Static registry (Validator.globalValidators)
+   * 3. Window object (legacy fallback)
+   */
+  resolveValidator(t) {
+    if (this.validators[t]) return this.validators[t];
+    if (E.globalValidators[t]) return E.globalValidators[t];
+    const e = window[t];
+    if (typeof e == "function") return e;
+  }
+  /**
+   * Specify a custom function in data-validation and it gets called to validate the input
+   * The custom function can return
+   * - a boolean
+   * - a Promise that resolves to a boolean
+   * - an object with a valid property that is a boolean
+   * - a Promise that resolves to an object with a valid property that is a boolean
+   * - and optionally a messages property that is a string or array of strings
+   * - OR optionally, a message property that is a string
+   * - optionaly, a boolean error property that is true if something went wrong
+   */
+  async validateCustom(t) {
+    if (t.disabled) return !0;
+    const e = t.dataset.validation;
+    if (!e || typeof e != "string") return !0;
+    const s = this.resolveValidator(e);
+    if (!s) return !0;
+    let a;
+    try {
+      a = await Promise.resolve(s(t.value)), a = pt(a);
+    } catch {
+      return this.addInputError(t, this.messages.ERROR_CUSTOM_VALIDATION), !1;
+    }
+    const i = a.messages.join("<br>") || this.messages.ERROR_CUSTOM_VALIDATION;
+    return a.valid || this.addInputError(t, i), a.valid;
+  }
+  // Validates an input with a value and returns true if it's valid
+  // Checks inputs defined in the inputHandlers map, pattern, and date range,
+  async validateInput(t) {
+    if (!(t instanceof HTMLInputElement) || !this.hasInputValue(t)) return !0;
+    let e = !0;
+    const s = t.type === "file";
+    return t.disabled || (s ? e = this.validateFileInput(t) && e : (e = this.validateInputType(t) && e, e = this.validateDateRange(t) && e, e = this.validatePattern(t) && e), e = await this.validateCustom(t) && e), e;
+  }
+  // Validates all the fields in the form. It will show an error message
+  // in all invalid fields and return false if any are invalid.
+  async validate(t) {
+    let e = !0;
+    for (const s of this.inputs)
+      s.disabled || (e = this.validateRequired(s) && e, e = this.validateLength(s) && e, e = this.validateValue(s) && e, e = await this.validateInput(s) && e, this.hasInputValue(s) || (e = await this.validateCustom(s) && e));
+    return e;
+  }
+  //end validate()
+  /**
+   * Validates a single input programmatically and displays any error messages.
+   * Useful for validating inputs on demand (e.g., in multi-step forms or custom UI flows).
+   * @param input The input element to validate
+   * @returns A promise that resolves to true if the input is valid, false otherwise
+   */
+  async validateSingle(t) {
+    if (!t || t.disabled) return !0;
+    if (!this.inputs.includes(t))
+      return console.warn(
+        "Validator.validateSingle(): input is not in this form. Use static Validator.validateSingle() for standalone inputs.",
+        t
+      ), !0;
+    this.clearInputErrors(t);
+    let e = !0;
+    return e = this.validateRequired(t) && e, e = this.validateLength(t) && e, e = this.validateValue(t) && e, e = await this.validateInput(t) && e, this.hasInputValue(t) || (e = await this.validateCustom(t) && e), this.showInputErrors(t), e;
+  }
+  isSubmitting = !1;
+  async submitHandler(t) {
+    if (this.isSubmitting) return;
+    t.preventDefault(), this.clearAllErrors();
+    let e = await this.validate(t);
+    this.showFormErrors();
+    const s = new Et(e ? "validationSuccess" : "validationError", t);
+    this.form.dispatchEvent(s), e ? this.validationSuccessCallback && this.validationSuccessCallback(t) : this.validationErrorCallback && this.validationErrorCallback(t), e && !this.preventSubmit && (this.isSubmitting = !0, s.defaultPrevented || this.form.submit(), this.isSubmitting = !1);
+  }
+  // Skip inputs that have a data-novalidate attribute
+  // Useful when you don't want to return a validationSuccess event when a specific input is changed
+  shouldSkipValidation(t) {
+    return typeof t.dataset.novalidate > "u" ? !1 : t.dataset.novalidate === "" ? !0 : t.dataset.novalidate === "true";
+  }
+  async inputChangeHandler(t) {
+    const e = t.target;
+    !(e instanceof HTMLInputElement || e instanceof HTMLSelectElement || e instanceof HTMLTextAreaElement) || this.shouldSkipValidation(e) || (this.clearInputErrors(e), this.validateLength(e), await this.validateInput(e), this.showInputErrors(e));
+  }
+  // Validates on blur even if value unchanged (catches touched-but-empty required fields)
+  async inputBlurHandler(t) {
+    const e = t.target;
+    !(e instanceof HTMLInputElement || e instanceof HTMLSelectElement || e instanceof HTMLTextAreaElement) || this.shouldSkipValidation(e) || (this.clearInputErrors(e), this.validateRequired(e), this.validateLength(e), this.validateValue(e), await this.validateInput(e), this.hasInputValue(e) || await this.validateCustom(e), this.showInputErrors(e));
+  }
+  inputInputHandler(t) {
+    const e = t.target;
+    this.shouldSkipValidation(e) || (I(e, "integer") && (e.value = S(e.value)), e.type !== "number" && I(e, ["number", "float", "decimal"]) && (e.value = _(e.value)), I(e, "color") && this.syncColorInput(t));
+  }
+  // Sync color inputs (data-type="color") with an associated native color input type
+  syncColorInput(t) {
+    let e = t.target, s = e;
+    if (e.type === "color" && (s = this.form.querySelector(`#${T(e.id.replace(/-color$/, ""))}`), !s))
+      return;
+    let a = this.form.querySelector(
+      `#${T(s.id)}-color-label`
+    );
+    if ((e.dataset.type || "") === "color") {
+      let i = this.form.querySelector(
+        `input#${T(e.id)}-color`
+      );
+      if (!i || !O(e.value)) return;
+      i.value = mt(e.value);
+    }
+    e.type === "color" && s && (s.value = e.value), a && (a.style.backgroundColor = e.value), clearTimeout(this.dispatchTimeout), this.dispatchTimeout = window.setTimeout(() => {
+      s.dispatchEvent(new Event("change", { bubbles: !0 }));
+    }, 200);
+  }
+  // Support using arrow keys to increment/decrement numeric fields.
+  // Use data-arrow-step to customize step size, or set to "" to disable.
+  inputKeydownHandler(t) {
+    if (!(t.target instanceof HTMLInputElement) || t.key !== "ArrowUp" && t.key !== "ArrowDown") return;
+    const e = t.target, s = I(e, "integer"), a = I(e, ["number", "float", "decimal"]);
+    if (!s && !a || e.dataset.arrowStep === "") return;
+    t.preventDefault();
+    const i = parseFloat(e.dataset.arrowStep ?? "1") || 1, l = parseFloat(e.value) || 0, o = t.key === "ArrowUp" ? i : -i;
+    let u = l + o;
+    const n = e.dataset.min ?? e.min, d = e.dataset.max ?? e.max, f = n !== "" ? parseFloat(n) : s ? 0 : -1 / 0, c = d !== "" ? parseFloat(d) : 1 / 0;
+    isNaN(f) || (u = Math.max(f, u)), isNaN(c) || (u = Math.min(c, u));
+    const h = (i.toString().split(".")[1] || "").length, m = (e.value.split(".")[1] || "").length, p = Math.max(h, m);
+    e.value = s ? Math.round(u).toString() : p ? u.toFixed(p) : u.toString();
+  }
+  destroy() {
+    clearTimeout(this.dispatchTimeout), this.removeEventListeners(), this.originalNoValidate || this.form.removeAttribute("novalidate");
+  }
+}
+const gt = E;
+export {
+  Et as ValidationEvent,
+  gt as default
+};