@validex/core 1.0.0

package/dist/chunk-TBVAKZA5.js

@@ -0,0 +1,2688 @@
+import {
+  getCreditCardPrefixes,
+  loadCreditCardPrefixes
+} from "./chunk-OOFMB7K5.js";
+import {
+  getPostalCodes,
+  loadPostalCodes
+} from "./chunk-NDLUDRZJ.js";
+import {
+  getCountryCodes,
+  loadCountryCodes
+} from "./chunk-PFPNNQGJ.js";
+import {
+  getCurrencyCodes,
+  loadCurrencyCodes
+} from "./chunk-SMDC2EAD.js";
+import {
+  getIbanPatterns,
+  loadIbanPatterns
+} from "./chunk-KTN4NQQL.js";
+import {
+  getVatPatterns,
+  loadVatPatterns
+} from "./chunk-5DOFRLSB.js";
+import {
+  getCommonPasswords,
+  loadCommonPasswords
+} from "./chunk-OTPQTLPM.js";
+import {
+  getReservedUsernames,
+  loadReservedUsernames
+} from "./chunk-WKVMDEA3.js";
+import {
+  loadPhoneParser
+} from "./chunk-BYMZTDYD.js";
+import {
+  collapseWhitespace,
+  containsEmail,
+  containsHtml,
+  containsUrl,
+  hasDigits,
+  hasLowercase,
+  hasSpecial,
+  hasUppercase,
+  maxConsecutive,
+  maxWords,
+  minWords,
+  noSpaces,
+  onlyAlpha,
+  onlyAlphaSpaceHyphen,
+  onlyAlphanumeric,
+  onlyAlphanumericSpaceHyphen,
+  onlyNumeric,
+  stripHtml,
+  toSlug,
+  toTitleCase
+} from "./chunk-6MGS4JWP.js";
+import {
+  en_default
+} from "./chunk-TB6J73U7.js";
+import {
+  getDisposableDomains
+} from "./chunk-AGJWIOFF.js";
+
+// src/rules/businessName.ts
+import { z as z3 } from "zod";
+
+// src/core/createRule.ts
+import { z as z2 } from "zod";
+
+// src/augmentation/methods.ts
+import { ZodType } from "zod";
+
+// src/core/customError.ts
+import { z } from "zod";
+
+// src/config/store.ts
+var DEFAULT_I18N = {
+  enabled: false,
+  prefix: "validation",
+  separator: ".",
+  pathMode: "semantic"
+};
+var DEFAULT_CONFIG = {
+  i18n: DEFAULT_I18N,
+  label: { fallback: "derived" }
+};
+var config = { ...DEFAULT_CONFIG, i18n: { ...DEFAULT_I18N } };
+var initialized = false;
+function getConfig() {
+  return config;
+}
+function setConfig(newConfig) {
+  config = newConfig;
+  initialized = true;
+}
+function isInitialized() {
+  return initialized;
+}
+function resetConfig() {
+  config = { ...DEFAULT_CONFIG, i18n: { ...DEFAULT_I18N } };
+  initialized = false;
+  _resetCustomErrorFlag();
+}
+
+// src/core/errorMap.ts
+var TEMPLATE_PARAM_RE = /\{\{(\w+)\}\}/g;
+var MESSAGE_MAP = en_default.validation.messages;
+function getErrorMessage(namespace, code, params = {}) {
+  const nsMap = MESSAGE_MAP[namespace];
+  const template = nsMap?.[code] ?? MESSAGE_MAP["base"]?.["format"] ?? "";
+  return template.replace(TEMPLATE_PARAM_RE, (_match, key) => {
+    const value = params[key];
+    return value !== void 0 && value !== null ? String(value) : `{{${key}}}`;
+  });
+}
+function buildMessageKey(prefix, separator, namespace, code, pathMode = "semantic", path = []) {
+  if (typeof pathMode === "function") {
+    const transformed = pathMode(path);
+    return [prefix, "messages", transformed, namespace, code].join(separator);
+  }
+  if (pathMode === "key" && path.length > 0) {
+    const last = String(path.at(-1));
+    return [prefix, "messages", last, namespace, code].join(separator);
+  }
+  if (pathMode === "full" && path.length > 0) {
+    const pathSegments = path.map(String);
+    return [prefix, "messages", ...pathSegments, namespace, code].join(separator);
+  }
+  return [prefix, "messages", namespace, code].join(separator);
+}
+function registerMessages(namespace, messages) {
+  const existing = MESSAGE_MAP[namespace];
+  MESSAGE_MAP[namespace] = { ...existing, ...messages };
+}
+
+// src/internal/fieldLabel.ts
+var CAMEL_SPLIT_RE = /([a-z])([A-Z])/g;
+var SEPARATOR_RE = /[_-]/g;
+var WORD_START_RE = /\b\w/g;
+function fieldNameToLabel(str) {
+  return str.replace(CAMEL_SPLIT_RE, "$1 $2").replace(SEPARATOR_RE, " ").replace(WORD_START_RE, (c) => c.toUpperCase());
+}
+
+// src/core/getParams.ts
+function mapNativeCode(issue) {
+  const issueCode = issue.code;
+  if (issueCode === void 0)
+    return void 0;
+  const ns = "base";
+  const mapping = {
+    too_small: () => issue.minimum === 1 ? { namespace: ns, code: "required" } : { namespace: ns, code: "min" },
+    too_big: () => ({ namespace: ns, code: "max" }),
+    invalid_type: () => issue.received === "undefined" || issue.input === void 0 ? { namespace: ns, code: "required" } : { namespace: ns, code: "type" },
+    invalid_format: () => ({ namespace: ns, code: "format" }),
+    invalid_string: () => ({ namespace: ns, code: "format" })
+  };
+  const factory = mapping[issueCode];
+  return factory !== void 0 ? factory() : void 0;
+}
+function deriveLabel(path, explicitLabel) {
+  if (explicitLabel !== void 0)
+    return explicitLabel;
+  const config2 = getConfig();
+  const fallback = config2.label?.fallback ?? "derived";
+  let defaultLabel;
+  if (fallback === "none") {
+    defaultLabel = "";
+  } else if (fallback === "generic") {
+    defaultLabel = "This field";
+  } else {
+    const last = path.at(-1);
+    if (last === void 0) {
+      defaultLabel = "This field";
+    } else {
+      defaultLabel = typeof last === "string" ? fieldNameToLabel(last) : `Item ${String(last)}`;
+    }
+  }
+  if (config2.label?.transform !== void 0) {
+    const last = path.at(-1);
+    const fieldName = last !== void 0 ? String(last) : "";
+    return config2.label.transform({ path, fieldName, defaultLabel });
+  }
+  return defaultLabel;
+}
+function resolveI18nLabel(label, labelKey, explicitLabel, config2) {
+  if (explicitLabel !== void 0 || config2.label?.transform !== void 0 || config2.i18n.t === void 0) {
+    return label;
+  }
+  const translated = config2.i18n.t(labelKey);
+  return translated !== labelKey && translated !== "" ? translated : label;
+}
+function getParams(issue) {
+  const path = issue.path ?? [];
+  const params = issue.params ?? {};
+  const validexCode = params["code"];
+  const validexNs = params["namespace"];
+  const hasValidex = validexCode !== void 0 && validexNs !== void 0;
+  const native = hasValidex ? void 0 : mapNativeCode(issue);
+  const namespace = validexNs ?? native?.namespace ?? "base";
+  const code = validexCode ?? native?.code ?? "format";
+  const explicitLabel = params["label"];
+  const label = deriveLabel(path, explicitLabel);
+  const config2 = getConfig();
+  const i18n = config2.i18n;
+  const prefix = i18n.prefix ?? "validation";
+  const separator = i18n.separator ?? ".";
+  const pathMode = i18n.pathMode ?? "semantic";
+  const key = buildMessageKey(prefix, separator, namespace, code, pathMode, path);
+  const extra = {};
+  for (const [k, v] of Object.entries(params)) {
+    if (k !== "code" && k !== "namespace" && k !== "label") {
+      extra[k] = v;
+    }
+  }
+  if (issue.minimum !== void 0)
+    extra["minimum"] = issue.minimum;
+  if (issue.maximum !== void 0)
+    extra["maximum"] = issue.maximum;
+  if (issue.expected !== void 0)
+    extra["expected"] = issue.expected;
+  const base = {
+    code,
+    namespace,
+    label,
+    key,
+    path,
+    ...extra
+  };
+  if (i18n.enabled) {
+    const labelKey = [prefix, "labels", ...path.map(String)].join(separator);
+    const resolvedLabel = resolveI18nLabel(label, labelKey, explicitLabel, config2);
+    return { ...base, label: resolvedLabel, labelKey };
+  }
+  return base;
+}
+
+// src/core/customError.ts
+var NATIVE_CODES = /* @__PURE__ */ new Set([
+  "too_small",
+  "too_big",
+  "invalid_type",
+  "invalid_format",
+  "invalid_string"
+]);
+function adaptIssue(issue) {
+  const rawPath = issue["path"];
+  const path = Array.isArray(rawPath) ? rawPath.filter(
+    (s) => typeof s === "string" || typeof s === "number"
+  ) : void 0;
+  return {
+    /* v8 ignore start -- defensive ternary guards; Zod always provides code/expected/received as strings when present */
+    code: typeof issue["code"] === "string" ? issue["code"] : void 0,
+    path,
+    minimum: issue["minimum"],
+    maximum: issue["maximum"],
+    expected: typeof issue["expected"] === "string" ? issue["expected"] : void 0,
+    received: typeof issue["received"] === "string" ? issue["received"] : void 0,
+    input: issue["input"],
+    format: typeof issue["format"] === "string" ? issue["format"] : void 0,
+    /* v8 ignore stop */
+    // SAFETY: Zod issues have untyped params; narrowed via isValidexIssue guard
+    params: issue["params"]
+  };
+}
+function isValidexIssue(params) {
+  return params["code"] !== void 0 && params["namespace"] !== void 0;
+}
+var _registered = false;
+function ensureCustomError() {
+  if (_registered)
+    return;
+  registerCustomError();
+}
+function registerCustomError() {
+  const prev = z.config().customError;
+  z.config({
+    customError(issue) {
+      const adapted = adaptIssue(issue);
+      const params = adapted.params ?? {};
+      const shouldHandle = isValidexIssue(params) || adapted.code !== void 0 && NATIVE_CODES.has(adapted.code);
+      if (!shouldHandle) {
+        return prev?.(issue) ?? void 0;
+      }
+      const errorParams = getParams(adapted);
+      const config2 = getConfig();
+      const i18n = config2.i18n;
+      let msg;
+      if (i18n.enabled && i18n.t !== void 0) {
+        msg = i18n.t(errorParams.key, { ...errorParams });
+      } else if (i18n.enabled) {
+        msg = errorParams.key;
+      } else {
+        msg = getErrorMessage(
+          errorParams.namespace,
+          errorParams.code,
+          { ...errorParams }
+        );
+      }
+      if (config2.message?.transform !== void 0) {
+        msg = config2.message.transform({
+          key: errorParams.key,
+          code: errorParams.code,
+          namespace: errorParams.namespace,
+          path: errorParams.path,
+          label: errorParams.label,
+          message: msg,
+          params: { ...errorParams }
+        });
+      }
+      return { message: msg };
+    }
+  });
+  _registered = true;
+}
+function _resetCustomErrorFlag() {
+  _registered = false;
+}
+
+// src/augmentation/methods.ts
+var _initialized = false;
+function initAugmentation() {
+  if (_initialized)
+    return;
+  _initialized = true;
+  ensureCustomError();
+  ZodType.prototype.hasUppercase = function(opts = {}) {
+    const min = opts.min ?? 1;
+    const max = opts.max;
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (min > 0 && !hasUppercase(v, min)) {
+        ctx.addIssue({ code: "custom", params: { code: "minUppercase", namespace: ns, minimum: min, label: lbl } });
+      }
+      if (max !== void 0 && !hasUppercase(v, 0, max)) {
+        ctx.addIssue({ code: "custom", params: { code: "maxUppercase", namespace: ns, maximum: max, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.hasLowercase = function(opts = {}) {
+    const min = opts.min ?? 1;
+    const max = opts.max;
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (min > 0 && !hasLowercase(v, min)) {
+        ctx.addIssue({ code: "custom", params: { code: "minLowercase", namespace: ns, minimum: min, label: lbl } });
+      }
+      if (max !== void 0 && !hasLowercase(v, 0, max)) {
+        ctx.addIssue({ code: "custom", params: { code: "maxLowercase", namespace: ns, maximum: max, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.hasDigits = function(opts = {}) {
+    const min = opts.min ?? 1;
+    const max = opts.max;
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (min > 0 && !hasDigits(v, min)) {
+        ctx.addIssue({ code: "custom", params: { code: "minDigits", namespace: ns, minimum: min, label: lbl } });
+      }
+      if (max !== void 0 && !hasDigits(v, 0, max)) {
+        ctx.addIssue({ code: "custom", params: { code: "maxDigits", namespace: ns, maximum: max, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.hasSpecial = function(opts = {}) {
+    const min = opts.min ?? 1;
+    const max = opts.max;
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (min > 0 && !hasSpecial(v, min)) {
+        ctx.addIssue({ code: "custom", params: { code: "minSpecial", namespace: ns, minimum: min, label: lbl } });
+      }
+      if (max !== void 0 && !hasSpecial(v, 0, max)) {
+        ctx.addIssue({ code: "custom", params: { code: "maxSpecial", namespace: ns, maximum: max, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.noEmails = function(opts = {}) {
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (containsEmail(v)) {
+        ctx.addIssue({ code: "custom", params: { code: "noEmails", namespace: ns, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.noUrls = function(opts = {}) {
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (containsUrl(v)) {
+        ctx.addIssue({ code: "custom", params: { code: "noUrls", namespace: ns, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.noHtml = function(opts = {}) {
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (containsHtml(v)) {
+        ctx.addIssue({ code: "custom", params: { code: "noHtml", namespace: ns, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.noPhoneNumbers = function(opts = {}) {
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    return this.superRefine(async (v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      const { containsPhoneNumber } = await import("./phoneDetection-G23LZ6MU.js");
+      if (await containsPhoneNumber(v)) {
+        ctx.addIssue({ code: "custom", params: { code: "noPhoneNumbers", namespace: ns, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.noSpaces = function(opts = {}) {
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (!noSpaces(v)) {
+        ctx.addIssue({ code: "custom", params: { code: "noSpaces", namespace: ns, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.onlyAlpha = function(opts = {}) {
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (!onlyAlpha(v)) {
+        ctx.addIssue({ code: "custom", params: { code: "onlyAlpha", namespace: ns, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.onlyNumeric = function(opts = {}) {
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (!onlyNumeric(v)) {
+        ctx.addIssue({ code: "custom", params: { code: "onlyNumeric", namespace: ns, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.onlyAlphanumeric = function(opts = {}) {
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (!onlyAlphanumeric(v)) {
+        ctx.addIssue({ code: "custom", params: { code: "onlyAlphanumeric", namespace: ns, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.onlyAlphaSpaceHyphen = function(opts = {}) {
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (!onlyAlphaSpaceHyphen(v)) {
+        ctx.addIssue({ code: "custom", params: { code: "onlyAlphaSpaceHyphen", namespace: ns, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.onlyAlphanumericSpaceHyphen = function(opts = {}) {
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (!onlyAlphanumericSpaceHyphen(v)) {
+        ctx.addIssue({ code: "custom", params: { code: "onlyAlphanumericSpaceHyphen", namespace: ns, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.maxWords = function(opts) {
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    const max = opts.max;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (!maxWords(v, max)) {
+        ctx.addIssue({ code: "custom", params: { code: "maxWords", namespace: ns, maximum: max, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.minWords = function(opts) {
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    const min = opts.min;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (!minWords(v, min)) {
+        ctx.addIssue({ code: "custom", params: { code: "minWords", namespace: ns, minimum: min, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.maxConsecutive = function(opts) {
+    const ns = opts.namespace ?? "string";
+    const lbl = opts.label;
+    const max = opts.max;
+    return this.superRefine((v, ctx) => {
+      if (typeof v !== "string")
+        return;
+      if (!maxConsecutive(v, max)) {
+        ctx.addIssue({ code: "custom", params: { code: "maxConsecutive", namespace: ns, maximum: max, label: lbl } });
+      }
+    });
+  };
+  ZodType.prototype.toTitleCase = function() {
+    return this.transform(
+      (v) => typeof v === "string" ? toTitleCase(v) : String(v)
+    );
+  };
+  ZodType.prototype.toSlug = function() {
+    return this.transform(
+      (v) => typeof v === "string" ? toSlug(v) : String(v)
+    );
+  };
+  ZodType.prototype.stripHtml = function() {
+    return this.transform(
+      (v) => typeof v === "string" ? stripHtml(v) : String(v)
+    );
+  };
+  ZodType.prototype.collapseWhitespace = function() {
+    return this.transform(
+      (v) => typeof v === "string" ? collapseWhitespace(v) : String(v)
+    );
+  };
+  ZodType.prototype.emptyToUndefined = function() {
+    return this.transform(
+      (v) => v === "" || v === null ? void 0 : v
+    );
+  };
+}
+
+// src/config/defaults.ts
+var RULE_DEFAULTS = {
+  email: {
+    length: { max: 254 },
+    blockPlusAlias: false,
+    blockDomains: [],
+    allowDomains: [],
+    blockDisposable: false,
+    allowSubdomains: true,
+    emptyToUndefined: true,
+    normalize: true
+  },
+  personName: {
+    length: { min: 2, max: 50 },
+    words: { max: 5 },
+    allowUnicode: true,
+    boundary: "alpha",
+    consecutive: { max: 3 },
+    titleCase: false,
+    emptyToUndefined: true,
+    normalize: true
+  },
+  businessName: {
+    length: { min: 2, max: 100 },
+    boundary: "alphanumeric",
+    consecutive: { max: 4 },
+    titleCase: false,
+    emptyToUndefined: true,
+    normalize: true
+  },
+  password: {
+    length: { min: 8, max: 128 },
+    uppercase: { min: 1 },
+    lowercase: { min: 1 },
+    digits: { min: 1 },
+    special: { min: 1 },
+    consecutive: { max: 3 },
+    blockCommon: false,
+    emptyToUndefined: true,
+    normalize: true
+  },
+  passwordConfirmation: {
+    passwordField: "password",
+    emptyToUndefined: true,
+    normalize: true
+  },
+  phone: {
+    allowCountries: [],
+    blockCountries: [],
+    requireMobile: false,
+    requireCountryCode: false,
+    format: "e164",
+    metadata: "min",
+    emptyToUndefined: true,
+    normalize: true
+  },
+  website: {
+    length: { max: 255 },
+    requireWww: false,
+    requireHttps: false,
+    allowDomains: [],
+    blockDomains: [],
+    allowSubdomains: true,
+    allowPath: true,
+    allowQuery: false,
+    emptyToUndefined: true,
+    normalize: true
+  },
+  url: {
+    protocols: ["http", "https"],
+    requireTLD: true,
+    length: { max: 2048 },
+    allowDomains: [],
+    blockDomains: [],
+    allowQuery: true,
+    allowAuth: false,
+    emptyToUndefined: true,
+    normalize: true
+  },
+  username: {
+    length: { min: 3, max: 20 },
+    pattern: "alphanumeric-underscore",
+    boundary: "alphanumeric",
+    ignoreCase: true,
+    blockReserved: false,
+    reservedWords: [],
+    emptyToUndefined: true,
+    normalize: true
+  },
+  slug: {
+    length: { min: 3, max: 100 },
+    emptyToUndefined: true,
+    normalize: true
+  },
+  postalCode: {
+    emptyToUndefined: true,
+    normalize: true
+  },
+  licenseKey: {
+    type: "custom",
+    segments: 5,
+    segmentLength: 5,
+    separator: "-",
+    charset: "alphanumeric",
+    emptyToUndefined: true,
+    normalize: true
+  },
+  uuid: {
+    version: "any",
+    emptyToUndefined: true,
+    normalize: true
+  },
+  jwt: {
+    requireExpiry: false,
+    checkExpiry: false,
+    checkNotBefore: false,
+    clockTolerance: 0,
+    emptyToUndefined: true,
+    normalize: true
+  },
+  dateTime: {
+    format: "iso",
+    allowFuture: true,
+    allowPast: true,
+    allowOffset: true,
+    allowLocal: false,
+    emptyToUndefined: true,
+    normalize: true
+  },
+  token: {
+    emptyToUndefined: true,
+    normalize: true
+  },
+  text: {
+    noEmails: false,
+    noUrls: false,
+    noPhoneNumbers: false,
+    noHtml: false,
+    emptyToUndefined: true,
+    normalize: true
+  },
+  country: {
+    format: "alpha2",
+    allowCountries: [],
+    blockCountries: [],
+    emptyToUndefined: true,
+    normalize: true
+  },
+  currency: {
+    allowCurrencies: [],
+    blockCurrencies: [],
+    emptyToUndefined: true,
+    normalize: true
+  },
+  color: {
+    format: "hex",
+    alpha: true,
+    emptyToUndefined: true,
+    normalize: true
+  },
+  creditCard: {
+    emptyToUndefined: true,
+    normalize: true
+  },
+  iban: {
+    allowCountries: [],
+    blockCountries: [],
+    emptyToUndefined: true,
+    normalize: true
+  },
+  vatNumber: {
+    requirePrefix: false,
+    emptyToUndefined: true,
+    normalize: true
+  },
+  macAddress: {
+    delimiter: ":",
+    emptyToUndefined: true,
+    normalize: true
+  },
+  ipAddress: {
+    version: "any",
+    allowCidr: false,
+    allowPrivate: true,
+    emptyToUndefined: true,
+    normalize: true
+  }
+};
+
+// src/config/merge.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof RegExp) && !(value instanceof Date);
+}
+function deepMergeTwo(base, override) {
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const overrideValue = override[key];
+    if (overrideValue === void 0) {
+      delete result[key];
+      continue;
+    }
+    const baseValue = base[key];
+    if (isPlainObject(baseValue) && isPlainObject(overrideValue)) {
+      result[key] = deepMergeTwo(baseValue, overrideValue);
+    } else {
+      result[key] = overrideValue;
+    }
+  }
+  return result;
+}
+function mergeThreeTiers(defaults, globals, perCall) {
+  const afterGlobals = deepMergeTwo(defaults, globals);
+  return deepMergeTwo(afterGlobals, perCall);
+}
+
+// src/config/index.ts
+function configure(config2) {
+  const current = getConfig();
+  const merged = deepMergeTwo(
+    current,
+    config2
+  );
+  setConfig(merged);
+}
+function setup(config2) {
+  if (config2 !== void 0) {
+    configure(config2);
+  } else if (!isInitialized()) {
+    setConfig(getConfig());
+  }
+  initAugmentation();
+}
+function getConfig2() {
+  return getConfig();
+}
+async function preloadData(options) {
+  const tasks = [];
+  if (options.disposable === true) {
+    const { loadDisposableDomains } = await import("./disposableDomains-DCXSV422.js");
+    tasks.push(loadDisposableDomains());
+  }
+  if (options.passwords !== void 0 && options.passwords !== false) {
+    const tier = options.passwords === true ? "basic" : options.passwords;
+    const { loadCommonPasswords: loadCommonPasswords2 } = await import("./commonPasswords-ZYOEI6PG.js");
+    tasks.push(loadCommonPasswords2(tier));
+  }
+  if (options.reserved === true) {
+    const { loadReservedUsernames: loadReservedUsernames2 } = await import("./reservedUsernames-QR4ONXSL.js");
+    tasks.push(loadReservedUsernames2());
+  }
+  if (options.phone !== void 0) {
+    const { loadPhoneParser: loadPhoneParser2 } = await import("./phoneParser-2RTXDB6H.js");
+    tasks.push(loadPhoneParser2(options.phone));
+  }
+  if (options.countryCodes === true) {
+    const { loadCountryCodes: loadCountryCodes2 } = await import("./countryCodes-RTJZVCLB.js");
+    tasks.push(loadCountryCodes2());
+  }
+  if (options.currencyCodes === true) {
+    const { loadCurrencyCodes: loadCurrencyCodes2 } = await import("./currencyCodes-U6TSAWDR.js");
+    tasks.push(loadCurrencyCodes2());
+  }
+  if (options.ibanPatterns === true) {
+    const { loadIbanPatterns: loadIbanPatterns2 } = await import("./ibanPatterns-LJRPR7FV.js");
+    tasks.push(loadIbanPatterns2());
+  }
+  if (options.vatPatterns === true) {
+    const { loadVatPatterns: loadVatPatterns2 } = await import("./vatPatterns-DNVZJPTW.js");
+    tasks.push(loadVatPatterns2());
+  }
+  if (options.creditCardPrefixes === true) {
+    const { loadCreditCardPrefixes: loadCreditCardPrefixes2 } = await import("./creditCardPrefixes-EZK7T4IZ.js");
+    tasks.push(loadCreditCardPrefixes2());
+  }
+  if (options.postalCodes === true) {
+    const { loadPostalCodes: loadPostalCodes2 } = await import("./postalCodes-ZPAJB3P5.js");
+    tasks.push(loadPostalCodes2());
+  }
+  await Promise.all(tasks);
+}
+
+// src/core/crossFieldRegistry.ts
+var registry = /* @__PURE__ */ new WeakMap();
+function registerCrossField(schema, meta) {
+  registry.set(schema, meta);
+}
+function getCrossField(schema) {
+  return registry.get(schema);
+}
+
+// src/core/createRule.ts
+var RESERVED_NAMESPACES = ["base", "string", "confirmation"];
+var FALLBACK_MESSAGE = "Validation failed";
+function assertNotReserved(name) {
+  if (RESERVED_NAMESPACES.includes(name)) {
+    throw new Error(
+      `validex: "${name}" is a reserved namespace and cannot be used as a rule name`
+    );
+  }
+}
+function applyEmptyToUndefined(schema, label) {
+  return z2.preprocess(
+    (val) => {
+      if (val === "")
+        return void 0;
+      if (val === null)
+        return void 0;
+      return val;
+    },
+    z2.unknown().superRefine((val, ctx) => {
+      if (val === void 0 || val === null) {
+        ctx.addIssue({ code: "custom", params: { code: "required", namespace: "base", label } });
+      }
+    }).pipe(schema)
+  );
+}
+function applyCustomFn(schema, customFn, namespace, label) {
+  return schema.superRefine(async (value, ctx) => {
+    if (typeof value !== "string")
+      return;
+    const result = await customFn(value);
+    if (result === true)
+      return;
+    const errorMsg = typeof result === "string" ? result : FALLBACK_MESSAGE;
+    const params = { code: "custom", namespace };
+    if (label !== void 0)
+      params["label"] = label;
+    ctx.addIssue({
+      code: "custom",
+      message: errorMsg,
+      params
+    });
+  });
+}
+function createRule(config2) {
+  assertNotReserved(config2.name);
+  let messagesRegistered = false;
+  return (options) => {
+    initAugmentation();
+    if (!messagesRegistered) {
+      if (Object.keys(config2.messages).length > 0) {
+        registerMessages(config2.name, config2.messages);
+      }
+      messagesRegistered = true;
+    }
+    const tier1Defaults = RULE_DEFAULTS[config2.name] ?? {};
+    const tier1 = { ...tier1Defaults, ...config2.defaults };
+    const globals = getConfig2().rules?.[config2.name] ?? {};
+    const mergedOpts = mergeThreeTiers(
+      tier1,
+      globals,
+      // SAFETY: Options are plain objects flowing through three-tier merge
+      options ?? {}
+    );
+    const baseSchema = config2.build(mergedOpts);
+    let schema = mergedOpts.emptyToUndefined !== false ? applyEmptyToUndefined(baseSchema, mergedOpts.label) : baseSchema;
+    if (mergedOpts.customFn !== void 0) {
+      const customRefine = applyCustomFn(z2.string(), mergedOpts.customFn, config2.name, mergedOpts.label);
+      schema = schema.pipe(customRefine);
+    }
+    if (mergedOpts.sameAs !== void 0 || mergedOpts.requiredWhen !== void 0 || mergedOpts.label !== void 0) {
+      registerCrossField(schema, {
+        sameAs: mergedOpts.sameAs,
+        requiredWhen: mergedOpts.requiredWhen,
+        label: mergedOpts.label
+      });
+    }
+    return schema;
+  };
+}
+
+// src/internal/boundary.ts
+var UNICODE_ALPHA_RE = /^\p{L}$/u;
+var UNICODE_ALPHANUMERIC_RE = /^[\p{L}\p{Nd}]$/u;
+function checkUnicodeBoundary(value, boundary) {
+  const chars = Array.from(value);
+  const first = chars[0];
+  const last = chars.at(-1);
+  if (first === void 0 || last === void 0) {
+    return false;
+  }
+  if (boundary.start === "alpha" && !UNICODE_ALPHA_RE.test(first))
+    return false;
+  if (boundary.start === "alphanumeric" && !UNICODE_ALPHANUMERIC_RE.test(first))
+    return false;
+  if (boundary.end === "alpha" && !UNICODE_ALPHA_RE.test(last))
+    return false;
+  if (boundary.end === "alphanumeric" && !UNICODE_ALPHANUMERIC_RE.test(last))
+    return false;
+  return true;
+}
+var ASCII_ALPHA_RE = /^[a-z]$/;
+var ASCII_ALPHANUMERIC_RE = /^[a-z0-9]$/;
+function checkAsciiBoundary(value, boundary) {
+  const first = value.charAt(0);
+  const last = value.charAt(value.length - 1);
+  if (first === "" || last === "")
+    return false;
+  if (boundary.start === "alpha" && !ASCII_ALPHA_RE.test(first))
+    return false;
+  if (boundary.start === "alphanumeric" && !ASCII_ALPHANUMERIC_RE.test(first))
+    return false;
+  if (boundary.end === "alpha" && !ASCII_ALPHA_RE.test(last))
+    return false;
+  if (boundary.end === "alphanumeric" && !ASCII_ALPHANUMERIC_RE.test(last))
+    return false;
+  return true;
+}
+
+// src/internal/escapeRegex.ts
+var ESCAPE_REGEX_RE = /[-.*+?^${}()|[\]\\]/g;
+function escapeRegexChars(str) {
+  return str.replace(ESCAPE_REGEX_RE, "\\$&");
+}
+
+// src/internal/resolveBoundary.ts
+function resolveBoundary(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return { start: value, end: value };
+  }
+  return {
+    start: value.start ?? "any",
+    end: value.end ?? "any"
+  };
+}
+
+// src/internal/resolveRange.ts
+function resolveRange(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "number") {
+    return { min: value, max: value };
+  }
+  const result = {};
+  if (value.min !== void 0) {
+    result.min = value.min;
+  }
+  if (value.max !== void 0) {
+    result.max = value.max;
+  }
+  return result;
+}
+
+// src/rules/businessName.ts
+var DEFAULT_EXTRA = " &.,-'()";
+function buildBusinessCharsetRegex(extraChars, disallowChars) {
+  let allowed = DEFAULT_EXTRA;
+  if (extraChars !== void 0) {
+    allowed += extraChars;
+  }
+  if (disallowChars !== void 0) {
+    for (const ch of disallowChars) {
+      allowed = allowed.replaceAll(ch, "");
+    }
+  }
+  const extra = escapeRegexChars(allowed);
+  return new RegExp(`^[\\p{L}\\p{Nd}${extra}]+$`, "u");
+}
+var BusinessName = /* @__PURE__ */ createRule({
+  name: "businessName",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const range = resolveRange(opts.length);
+    const consecutiveRange = resolveRange(opts.consecutive);
+    const boundary = resolveBoundary(opts.boundary);
+    const base = opts.normalize !== false ? z3.string().trim() : z3.string();
+    const minLen = range?.min;
+    const maxLen = range?.max;
+    const lbl = opts.label;
+    const pattern = opts.regex ?? buildBusinessCharsetRegex(
+      opts.extraChars,
+      opts.disallowChars
+    );
+    const stage1 = base.superRefine((v, ctx) => {
+      if (minLen !== void 0 && v.length < minLen) {
+        ctx.addIssue({ code: "custom", params: { code: "min", namespace: "base", label: lbl, minimum: minLen } });
+        return;
+      }
+      if (maxLen !== void 0 && v.length > maxLen) {
+        ctx.addIssue({ code: "custom", params: { code: "max", namespace: "base", label: lbl, maximum: maxLen } });
+        return;
+      }
+      if (!pattern.test(v)) {
+        ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "businessName", label: opts.label } });
+        return;
+      }
+      if (boundary !== void 0 && !checkUnicodeBoundary(v, boundary)) {
+        ctx.addIssue({ code: "custom", params: { code: "boundary", namespace: "businessName", label: opts.label } });
+      }
+    });
+    let stage2 = z3.string();
+    if (consecutiveRange?.max !== void 0) {
+      stage2 = stage2.maxConsecutive({ max: consecutiveRange.max, namespace: "businessName", label: opts.label });
+    }
+    const validated = stage1.pipe(stage2);
+    if (opts.titleCase === true) {
+      return validated.transform(toTitleCase);
+    }
+    return validated;
+  }
+});
+
+// src/rules/color.ts
+import { z as z4 } from "zod";
+var HEX_ALPHA = /^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var HEX_NO_ALPHA = /^#([0-9a-f]{3}|[0-9a-f]{6})$/i;
+var RGB_ALPHA = /^rgba?\(\s*\d{1,3}\s*,\s*\d{1,3}\s*,\s*\d{1,3}\s*(,\s*(0|1|0?\.\d+)\s*)?\)$/;
+var RGB_NO_ALPHA = /^rgb\(\s*\d{1,3}\s*,\s*\d{1,3}\s*,\s*\d{1,3}\s*\)$/;
+var HSL_ALPHA = /^hsla?\(\s*\d{1,3}\s*,\s*\d{1,3}%\s*,\s*\d{1,3}%\s*(,\s*(0|1|0?\.\d+)\s*)?\)$/;
+var HSL_NO_ALPHA = /^hsl\(\s*\d{1,3}\s*,\s*\d{1,3}%\s*,\s*\d{1,3}%\s*\)$/;
+function getHexPattern(alpha) {
+  return alpha ? HEX_ALPHA : HEX_NO_ALPHA;
+}
+function getRgbPattern(alpha) {
+  return alpha ? RGB_ALPHA : RGB_NO_ALPHA;
+}
+function getHslPattern(alpha) {
+  return alpha ? HSL_ALPHA : HSL_NO_ALPHA;
+}
+function matchesAnyFormat(value, alpha) {
+  return getHexPattern(alpha).test(value) || getRgbPattern(alpha).test(value) || getHslPattern(alpha).test(value);
+}
+var Color = /* @__PURE__ */ createRule({
+  name: "color",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const format = opts.format ?? "hex";
+    const alpha = opts.alpha !== false;
+    const base = opts.normalize !== false ? z4.string().transform((v) => v.trim().toLowerCase()) : z4.string();
+    return base.pipe(
+      z4.string().refine(
+        (v) => {
+          switch (format) {
+            case "hex":
+              return getHexPattern(alpha).test(v);
+            case "rgb":
+              return getRgbPattern(alpha).test(v);
+            case "hsl":
+              return getHslPattern(alpha).test(v);
+            case "any":
+              return matchesAnyFormat(v, alpha);
+            /* v8 ignore start -- exhaustive default; format is constrained to hex|rgb|hsl|any by TypeScript */
+            default:
+              return false;
+          }
+        },
+        { params: { code: "invalid", namespace: "color", label: opts.label } }
+      )
+    );
+  }
+});
+
+// src/rules/country.ts
+import { z as z5 } from "zod";
+async function resolveCountryCodes() {
+  try {
+    return getCountryCodes();
+  } catch {
+    return loadCountryCodes();
+  }
+}
+function isValidCountryCode(value, format, codes) {
+  if (format === "alpha2") {
+    return codes.has(value);
+  }
+  for (const entry of codes.values()) {
+    if (entry.alpha3 === value)
+      return true;
+  }
+  return false;
+}
+var Country = /* @__PURE__ */ createRule({
+  name: "country",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const format = opts.format ?? "alpha2";
+    const allow = opts.allowCountries ?? [];
+    const block = opts.blockCountries ?? [];
+    let schema = opts.normalize !== false ? z5.string().transform((v) => v.trim().toUpperCase()) : z5.string();
+    schema = schema.pipe(
+      z5.string().refine(
+        async (v) => {
+          const codes = await resolveCountryCodes();
+          return isValidCountryCode(v, format, codes);
+        },
+        { params: { code: "invalid", namespace: "country", label: opts.label } }
+      )
+    );
+    if (allow.length > 0) {
+      schema = schema.pipe(
+        z5.string().superRefine((v, ctx) => {
+          if (!allow.includes(v)) {
+            ctx.addIssue({ code: "custom", params: { code: "notAllowed", namespace: "country", country: v, label: opts.label } });
+          }
+        })
+      );
+    }
+    if (block.length > 0) {
+      schema = schema.pipe(
+        z5.string().superRefine((v, ctx) => {
+          if (block.includes(v)) {
+            ctx.addIssue({ code: "custom", params: { code: "blocked", namespace: "country", country: v, label: opts.label } });
+          }
+        })
+      );
+    }
+    return schema;
+  }
+});
+
+// src/rules/creditCard.ts
+import { z as z6 } from "zod";
+var DIGITS_ONLY_RE = /^\d+$/;
+var STRIP_RE = /[\s-]/g;
+var MIN_LENGTH = 13;
+var MAX_LENGTH = 19;
+async function resolvePrefixes() {
+  try {
+    return getCreditCardPrefixes();
+  } catch {
+    return loadCreditCardPrefixes();
+  }
+}
+function luhnCheck(digits) {
+  let sum = 0;
+  let alternate = false;
+  for (let i = digits.length - 1; i >= 0; i--) {
+    let n = Number(digits[i]);
+    if (alternate) {
+      n *= 2;
+      if (n > 9)
+        n -= 9;
+    }
+    sum += n;
+    alternate = !alternate;
+  }
+  return sum % 10 === 0;
+}
+function matchPrefix(cardNumber, prefix) {
+  if (prefix.includes("-")) {
+    const parts = prefix.split("-");
+    const low = parts[0];
+    const high = parts[1];
+    if (low === void 0 || high === void 0)
+      return false;
+    const cardPrefix = Number(cardNumber.slice(0, low.length));
+    return cardPrefix >= Number(low) && cardPrefix <= Number(high);
+  }
+  return cardNumber.startsWith(prefix);
+}
+function detectIssuer(cardNumber, prefixes) {
+  for (const [issuer, data] of prefixes) {
+    for (const prefix of data.prefixes) {
+      if (matchPrefix(cardNumber, prefix))
+        return issuer;
+    }
+  }
+  return void 0;
+}
+var CreditCard = /* @__PURE__ */ createRule({
+  name: "creditCard",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const allow = opts.allowIssuers ?? [];
+    const block = opts.blockIssuers ?? [];
+    let schema = opts.normalize !== false ? z6.string().transform((v) => v.trim().replace(STRIP_RE, "")) : z6.string();
+    schema = schema.pipe(
+      z6.string().refine(
+        (v) => {
+          if (!DIGITS_ONLY_RE.test(v))
+            return false;
+          if (v.length < MIN_LENGTH || v.length > MAX_LENGTH)
+            return false;
+          return luhnCheck(v);
+        },
+        { params: { code: "invalid", namespace: "creditCard", label: opts.label } }
+      )
+    );
+    if (allow.length > 0) {
+      schema = schema.pipe(
+        z6.string().superRefine(async (v, ctx) => {
+          const prefixes = await resolvePrefixes();
+          const issuer = detectIssuer(v, prefixes);
+          if (issuer === void 0 || !allow.includes(issuer)) {
+            ctx.addIssue({
+              code: "custom",
+              params: { code: "issuerNotAllowed", namespace: "creditCard", issuer: issuer ?? "unknown", label: opts.label }
+            });
+          }
+        })
+      );
+    }
+    if (block.length > 0) {
+      schema = schema.pipe(
+        z6.string().superRefine(async (v, ctx) => {
+          const prefixes = await resolvePrefixes();
+          const issuer = detectIssuer(v, prefixes);
+          if (issuer !== void 0 && block.includes(issuer)) {
+            ctx.addIssue({
+              code: "custom",
+              params: { code: "issuerBlocked", namespace: "creditCard", issuer, label: opts.label }
+            });
+          }
+        })
+      );
+    }
+    return schema;
+  }
+});
+
+// src/rules/currency.ts
+import { z as z7 } from "zod";
+async function resolveCurrencyCodes() {
+  try {
+    return getCurrencyCodes();
+  } catch {
+    return loadCurrencyCodes();
+  }
+}
+var Currency = /* @__PURE__ */ createRule({
+  name: "currency",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const allow = opts.allowCurrencies ?? [];
+    const block = opts.blockCurrencies ?? [];
+    let schema = opts.normalize !== false ? z7.string().transform((v) => v.trim().toUpperCase()) : z7.string();
+    schema = schema.pipe(
+      z7.string().refine(
+        async (v) => {
+          const codes = await resolveCurrencyCodes();
+          return codes.has(v);
+        },
+        { params: { code: "invalid", namespace: "currency", label: opts.label } }
+      )
+    );
+    if (allow.length > 0) {
+      schema = schema.pipe(
+        z7.string().superRefine((v, ctx) => {
+          if (!allow.includes(v)) {
+            ctx.addIssue({ code: "custom", params: { code: "notAllowed", namespace: "currency", currency: v, label: opts.label } });
+          }
+        })
+      );
+    }
+    if (block.length > 0) {
+      schema = schema.pipe(
+        z7.string().superRefine((v, ctx) => {
+          if (block.includes(v)) {
+            ctx.addIssue({ code: "custom", params: { code: "blocked", namespace: "currency", currency: v, label: opts.label } });
+          }
+        })
+      );
+    }
+    return schema;
+  }
+});
+
+// src/rules/dateTime.ts
+import { z as z8 } from "zod";
+var DATETIME_FORMAT_CHECK = z8.string().datetime();
+var DATE_FORMAT_CHECK = z8.string().date();
+var TIME_FORMAT_CHECK = z8.string().time();
+function parseToDate(value) {
+  return value instanceof Date ? value : new Date(value);
+}
+function buildDateTimeSchema(opts) {
+  const hasCustomOpts = opts.allowOffset !== void 0 || opts.allowLocal !== void 0 || opts.precision !== void 0;
+  let check;
+  if (hasCustomOpts) {
+    const datetimeOpts = {};
+    if (opts.allowOffset !== void 0)
+      datetimeOpts.offset = opts.allowOffset;
+    if (opts.allowLocal !== void 0)
+      datetimeOpts.local = opts.allowLocal;
+    if (opts.precision !== void 0)
+      datetimeOpts.precision = opts.precision;
+    check = z8.string().datetime(datetimeOpts);
+  } else {
+    check = DATETIME_FORMAT_CHECK;
+  }
+  const base = opts.normalize !== false ? z8.string().trim() : z8.string();
+  return base.pipe(z8.string().superRefine((v, ctx) => {
+    if (!check.safeParse(v).success) {
+      ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "dateTime", label: opts.label } });
+    }
+  }));
+}
+function buildDateSchema(opts) {
+  const base = opts.normalize !== false ? z8.string().trim() : z8.string();
+  return base.pipe(z8.string().superRefine((v, ctx) => {
+    if (!DATE_FORMAT_CHECK.safeParse(v).success) {
+      ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "dateTime", label: opts.label } });
+    }
+  }));
+}
+function buildTimeSchema(opts) {
+  const check = opts.precision !== void 0 ? z8.string().time({ precision: opts.precision }) : TIME_FORMAT_CHECK;
+  const base = opts.normalize !== false ? z8.string().trim() : z8.string();
+  return base.pipe(z8.string().superRefine((v, ctx) => {
+    if (!check.safeParse(v).success) {
+      ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "dateTime", label: opts.label } });
+    }
+  }));
+}
+function applyRangeRefinements(schema, opts) {
+  let result = schema;
+  if (opts.min !== void 0) {
+    const minDate = parseToDate(opts.min);
+    result = result.refine(
+      // SAFETY: refine callback on z.string() schema; v is always a string
+      (v) => new Date(v) >= minDate,
+      { params: { code: "tooEarly", namespace: "dateTime", minimum: minDate.toISOString(), label: opts.label } }
+    );
+  }
+  if (opts.max !== void 0) {
+    const maxDate = parseToDate(opts.max);
+    result = result.refine(
+      // SAFETY: refine callback on z.string() schema; v is always a string
+      (v) => new Date(v) <= maxDate,
+      { params: { code: "tooLate", namespace: "dateTime", maximum: maxDate.toISOString(), label: opts.label } }
+    );
+  }
+  if (opts.allowFuture === false) {
+    result = result.refine(
+      // SAFETY: refine callback on z.string() schema; v is always a string
+      (v) => new Date(v) <= /* @__PURE__ */ new Date(),
+      { params: { code: "noFuture", namespace: "dateTime", label: opts.label } }
+    );
+  }
+  if (opts.allowPast === false) {
+    result = result.refine(
+      // SAFETY: refine callback on z.string() schema; v is always a string
+      (v) => new Date(v) >= /* @__PURE__ */ new Date(),
+      { params: { code: "noPast", namespace: "dateTime", label: opts.label } }
+    );
+  }
+  return result;
+}
+var DateTime = /* @__PURE__ */ createRule({
+  name: "dateTime",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    let schema;
+    switch (opts.format) {
+      case "date":
+        schema = buildDateSchema(opts);
+        break;
+      case "time":
+        schema = buildTimeSchema(opts);
+        break;
+      case "iso":
+      case void 0:
+        schema = buildDateTimeSchema(opts);
+        break;
+    }
+    if (opts.format !== "time") {
+      schema = applyRangeRefinements(schema, opts);
+    }
+    return schema;
+  }
+});
+
+// src/rules/email.ts
+import { z as z9 } from "zod";
+
+// src/internal/domainMatch.ts
+function matchesDomainList(hostname, domains) {
+  return domains.some(
+    (d) => hostname === d || hostname.endsWith(`.${d}`)
+  );
+}
+
+// src/internal/lengthCheck.ts
+function applyLengthCheck(value, min, max, label, ctx) {
+  if (min !== void 0 && value.length < min) {
+    ctx.addIssue({ code: "custom", params: { code: "min", namespace: "base", label, minimum: min } });
+  }
+  if (max !== void 0 && value.length > max) {
+    ctx.addIssue({ code: "custom", params: { code: "max", namespace: "base", label, maximum: max } });
+  }
+}
+
+// src/rules/email.ts
+function extractDomain(email) {
+  return email.split("@")[1] ?? "";
+}
+function extractLocalPart(email) {
+  return email.split("@")[0] ?? "";
+}
+var EMAIL_FORMAT_CHECK = z9.string().email();
+var Email = /* @__PURE__ */ createRule({
+  name: "email",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const range = resolveRange(opts.length);
+    const maxLen = range?.max ?? 254;
+    const minLen = range?.min;
+    const ns = "email";
+    const lbl = opts.label;
+    const base = opts.normalize !== false ? z9.string().trim().toLowerCase() : z9.string();
+    let schema = base.pipe(z9.string().superRefine((v, ctx) => {
+      if (!EMAIL_FORMAT_CHECK.safeParse(v).success) {
+        ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: ns, label: lbl } });
+        return;
+      }
+      applyLengthCheck(v, minLen, maxLen, lbl, ctx);
+    }));
+    schema = applyBusinessRules(schema, opts);
+    return schema;
+  }
+});
+function applyBusinessRules(schema, opts) {
+  let result = schema;
+  if (opts.blockPlusAlias === true) {
+    result = result.pipe(z9.string().refine(
+      (v) => !extractLocalPart(v).includes("+"),
+      { params: { code: "plusAliasBlocked", namespace: "email", label: opts.label } }
+    ));
+  }
+  result = applyDomainFilters(result, opts);
+  if (opts.allowSubdomains === false) {
+    result = result.pipe(z9.string().refine(
+      (v) => extractDomain(v).split(".").length <= 2,
+      { params: { code: "subdomainNotAllowed", namespace: "email", label: opts.label } }
+    ));
+  }
+  if (opts.blockDisposable === true) {
+    result = applyDisposableCheck(result, opts.label);
+  }
+  return result;
+}
+function applyDomainFilters(schema, opts) {
+  let result = schema;
+  const allow = opts.allowDomains ?? [];
+  const block = opts.blockDomains ?? [];
+  if (allow.length > 0) {
+    result = result.pipe(z9.string().superRefine((v, ctx) => {
+      if (!matchesDomainList(extractDomain(v), allow)) {
+        ctx.addIssue({ code: "custom", params: { code: "domainNotAllowed", namespace: "email", domain: extractDomain(v), label: opts.label } });
+      }
+    }));
+  }
+  if (block.length > 0) {
+    result = result.pipe(z9.string().superRefine((v, ctx) => {
+      if (matchesDomainList(extractDomain(v), block)) {
+        ctx.addIssue({ code: "custom", params: { code: "domainBlocked", namespace: "email", domain: extractDomain(v), label: opts.label } });
+      }
+    }));
+  }
+  return result;
+}
+function applyDisposableCheck(schema, label) {
+  return schema.pipe(z9.string().refine(
+    async (value) => {
+      const domain = extractDomain(value);
+      try {
+        const preloaded = getDisposableDomains();
+        return !preloaded.has(domain);
+      } catch {
+        try {
+          const { isDisposableEmailDomain } = await import("disposable-email-domains-js");
+          return !isDisposableEmailDomain(domain);
+        } catch {
+          return true;
+        }
+      }
+    },
+    { params: { code: "disposableBlocked", namespace: "email", label } }
+  ));
+}
+
+// src/rules/iban.ts
+import { z as z10 } from "zod";
+var IBAN_STRUCTURE_RE = /^[A-Z]{2}\d{2}[A-Z0-9]+$/;
+var STRIP_SPACES_RE = /\s/g;
+async function resolvePatterns() {
+  try {
+    return getIbanPatterns();
+  } catch {
+    return loadIbanPatterns();
+  }
+}
+function mod97(ibanDigits) {
+  let remainder = 0;
+  for (const char of ibanDigits) {
+    remainder = (remainder * 10 + Number(char)) % 97;
+  }
+  return remainder;
+}
+function validateMod97(iban) {
+  const rearranged = iban.slice(4) + iban.slice(0, 4);
+  let digits = "";
+  for (const char of rearranged) {
+    if (char >= "A" && char <= "Z") {
+      digits += String(char.charCodeAt(0) - 55);
+    } else {
+      digits += char;
+    }
+  }
+  return mod97(digits) === 1;
+}
+var Iban = /* @__PURE__ */ createRule({
+  name: "iban",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const allow = opts.allowCountries ?? [];
+    const block = opts.blockCountries ?? [];
+    let schema = opts.normalize !== false ? z10.string().transform(
+      (v) => v.trim().toUpperCase().replace(STRIP_SPACES_RE, "")
+    ) : z10.string();
+    schema = schema.pipe(
+      z10.string().refine(
+        async (v) => {
+          if (!IBAN_STRUCTURE_RE.test(v))
+            return false;
+          const country = v.slice(0, 2);
+          const patterns = await resolvePatterns();
+          const pattern = patterns.get(country);
+          if (pattern === void 0)
+            return false;
+          if (v.length !== pattern.length)
+            return false;
+          if (!pattern.regex.test(v))
+            return false;
+          return validateMod97(v);
+        },
+        { params: { code: "invalid", namespace: "iban", label: opts.label } }
+      )
+    );
+    if (allow.length > 0) {
+      schema = schema.pipe(
+        z10.string().superRefine((v, ctx) => {
+          if (!allow.includes(v.slice(0, 2))) {
+            ctx.addIssue({ code: "custom", params: { code: "countryNotAllowed", namespace: "iban", country: v.slice(0, 2), label: opts.label } });
+          }
+        })
+      );
+    }
+    if (block.length > 0) {
+      schema = schema.pipe(
+        z10.string().superRefine((v, ctx) => {
+          if (block.includes(v.slice(0, 2))) {
+            ctx.addIssue({ code: "custom", params: { code: "countryBlocked", namespace: "iban", country: v.slice(0, 2), label: opts.label } });
+          }
+        })
+      );
+    }
+    return schema;
+  }
+});
+
+// src/rules/ipAddress.ts
+import { z as z11 } from "zod";
+function isPrivateIpv4(ip) {
+  const parts = ip.split(".").map(Number);
+  const first = parts[0] ?? -1;
+  const second = parts[1] ?? -1;
+  if (first === 10)
+    return true;
+  if (first === 172 && second >= 16 && second <= 31)
+    return true;
+  if (first === 192 && second === 168)
+    return true;
+  if (first === 127)
+    return true;
+  if (first === 0)
+    return true;
+  return false;
+}
+function isPrivateIpv6(ip) {
+  const lower = ip.toLowerCase();
+  if (lower === "::1")
+    return true;
+  if (lower.startsWith("fc") || lower.startsWith("fd"))
+    return true;
+  if (lower.startsWith("fe80"))
+    return true;
+  if (lower === "::")
+    return true;
+  return false;
+}
+function stripCidr(ip) {
+  const slashIndex = ip.indexOf("/");
+  return slashIndex === -1 ? ip : ip.slice(0, slashIndex);
+}
+var IPV4_CHECK = z11.string().ipv4();
+var IPV6_CHECK = z11.string().ipv6();
+var CIDRV4_CHECK = z11.string().cidrv4();
+var CIDRV6_CHECK = z11.string().cidrv6();
+function buildV4Schema(allowCidr, normalize, label) {
+  const base = normalize ? z11.string().trim() : z11.string();
+  const check = allowCidr ? CIDRV4_CHECK : IPV4_CHECK;
+  return base.superRefine((v, ctx) => {
+    if (!check.safeParse(v).success) {
+      ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "ipAddress", label } });
+    }
+  });
+}
+function buildV6Schema(allowCidr, normalize, label) {
+  const base = normalize ? z11.string().trim() : z11.string();
+  const check = allowCidr ? CIDRV6_CHECK : IPV6_CHECK;
+  return base.superRefine((v, ctx) => {
+    if (!check.safeParse(v).success) {
+      ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "ipAddress", label } });
+    }
+  });
+}
+function buildAnyVersionSchema(allowCidr, normalize, label) {
+  const v4Check = allowCidr ? CIDRV4_CHECK : IPV4_CHECK;
+  const v6Check = allowCidr ? CIDRV6_CHECK : IPV6_CHECK;
+  const base = normalize ? z11.string().trim() : z11.string();
+  return base.superRefine((v, ctx) => {
+    if (!v4Check.safeParse(v).success && !v6Check.safeParse(v).success) {
+      ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "ipAddress", label } });
+    }
+  });
+}
+function applyPrivateRefinement(schema, version, label) {
+  return schema.refine(
+    (v) => {
+      const bare = stripCidr(v);
+      if (version === "v4")
+        return !isPrivateIpv4(bare);
+      if (version === "v6")
+        return !isPrivateIpv6(bare);
+      return bare.includes(":") ? !isPrivateIpv6(bare) : !isPrivateIpv4(bare);
+    },
+    { params: { code: "privateNotAllowed", namespace: "ipAddress", label } }
+  );
+}
+var IpAddress = /* @__PURE__ */ createRule({
+  name: "ipAddress",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const version = opts.version ?? "any";
+    const allowCidr = opts.allowCidr === true;
+    const normalize = opts.normalize !== false;
+    let schema;
+    switch (version) {
+      case "v4":
+        schema = buildV4Schema(allowCidr, normalize, opts.label);
+        break;
+      case "v6":
+        schema = buildV6Schema(allowCidr, normalize, opts.label);
+        break;
+      case "any":
+        schema = buildAnyVersionSchema(allowCidr, normalize, opts.label);
+        break;
+    }
+    if (opts.allowPrivate === false) {
+      schema = applyPrivateRefinement(schema, version, opts.label);
+    }
+    return schema;
+  }
+});
+
+// src/rules/jwt.ts
+import { z as z12 } from "zod";
+var BASE64URL_HYPHEN_RE = /-/g;
+var BASE64URL_UNDERSCORE_RE = /_/g;
+function base64UrlDecode(str) {
+  let base64 = str.replace(BASE64URL_HYPHEN_RE, "+").replace(BASE64URL_UNDERSCORE_RE, "/");
+  const padding = base64.length % 4;
+  if (padding === 2)
+    base64 += "==";
+  else if (padding === 3)
+    base64 += "=";
+  return atob(base64);
+}
+function decodeJwtParts(value) {
+  const segments = value.split(".");
+  if (segments.length !== 3)
+    return null;
+  try {
+    const headerStr = segments[0] ?? "";
+    const payloadStr = segments[1] ?? "";
+    const header = JSON.parse(base64UrlDecode(headerStr));
+    const payload = JSON.parse(base64UrlDecode(payloadStr));
+    return { header, payload };
+  } catch {
+    return null;
+  }
+}
+function isExpired(payload, tolerance) {
+  const exp = payload["exp"];
+  if (typeof exp !== "number")
+    return true;
+  const now = Math.floor(Date.now() / 1e3);
+  return exp <= now - tolerance;
+}
+function isNotYetValid(payload, tolerance) {
+  const nbf = payload["nbf"];
+  if (typeof nbf !== "number")
+    return false;
+  const now = Math.floor(Date.now() / 1e3);
+  return nbf > now + tolerance;
+}
+function validateAlgorithm(header, algorithms, ctx, label) {
+  const alg = header["alg"];
+  if (typeof alg !== "string" || !algorithms.includes(alg)) {
+    ctx.addIssue({
+      code: "custom",
+      params: {
+        code: "algorithmNotAllowed",
+        namespace: "jwt",
+        algorithm: String(alg ?? "unknown"),
+        label
+      }
+    });
+  }
+}
+function validateClaims(payload, claims, ctx, label) {
+  for (const claim of claims) {
+    if (payload[claim] === void 0) {
+      ctx.addIssue({
+        code: "custom",
+        params: { code: "missingClaim", namespace: "jwt", claim, label }
+      });
+    }
+  }
+}
+function validateTemporal(payload, opts, ctx) {
+  const tolerance = opts.clockTolerance ?? 0;
+  if (opts.requireExpiry === true && payload["exp"] === void 0) {
+    ctx.addIssue({
+      code: "custom",
+      params: { code: "expiryRequired", namespace: "jwt", label: opts.label }
+    });
+  }
+  if (opts.checkExpiry === true && isExpired(payload, tolerance)) {
+    ctx.addIssue({
+      code: "custom",
+      params: { code: "expired", namespace: "jwt", label: opts.label }
+    });
+  }
+  if (opts.checkNotBefore === true && isNotYetValid(payload, tolerance)) {
+    ctx.addIssue({
+      code: "custom",
+      params: { code: "notYetValid", namespace: "jwt", label: opts.label }
+    });
+  }
+}
+var Jwt = /* @__PURE__ */ createRule({
+  name: "jwt",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const schema = opts.normalize !== false ? z12.string().trim() : z12.string();
+    return schema.superRefine((value, ctx) => {
+      const parts = decodeJwtParts(value);
+      if (!parts) {
+        ctx.addIssue({
+          code: "custom",
+          params: { code: "invalid", namespace: "jwt", label: opts.label }
+        });
+        return;
+      }
+      const { header, payload } = parts;
+      if (opts.allowAlgorithms && opts.allowAlgorithms.length > 0) {
+        validateAlgorithm(header, opts.allowAlgorithms, ctx, opts.label);
+      }
+      validateTemporal(payload, opts, ctx);
+      if (opts.requireClaims && opts.requireClaims.length > 0) {
+        validateClaims(payload, opts.requireClaims, ctx, opts.label);
+      }
+    });
+  }
+});
+
+// src/rules/licenseKey.ts
+import { z as z13 } from "zod";
+var CHARSET_MAP = {
+  alphanumeric: "A-Z0-9",
+  alpha: "A-Z",
+  numeric: "0-9",
+  hex: "0-9A-F"
+};
+function buildLicenseKeyPattern(segments, segmentLength, separator, charset) {
+  const charClass = CHARSET_MAP[charset] ?? CHARSET_MAP["alphanumeric"];
+  const sep = escapeRegexChars(separator);
+  const segPart = `[${charClass}]{${segmentLength}}`;
+  const repeatPart = segments > 1 ? `(${sep}${segPart}){${segments - 1}}` : "";
+  return new RegExp(`^${segPart}${repeatPart}$`);
+}
+var UUID_FORMAT_CHECK = z13.string().uuid();
+var LicenseKey = /* @__PURE__ */ createRule({
+  name: "licenseKey",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    if (opts.type === "uuid") {
+      const uuidBase = opts.normalize !== false ? z13.string().trim().toUpperCase() : z13.string();
+      return uuidBase.pipe(z13.string().superRefine((v, ctx) => {
+        if (!UUID_FORMAT_CHECK.safeParse(v.toLowerCase()).success) {
+          ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "licenseKey", label: opts.label } });
+        }
+      }));
+    }
+    const base = opts.normalize !== false ? z13.string().transform((v) => v.trim().toUpperCase()).pipe(z13.string()) : z13.string();
+    const pattern = opts.regex ?? buildLicenseKeyPattern(
+      opts.segments ?? 5,
+      opts.segmentLength ?? 5,
+      opts.separator ?? "-",
+      opts.charset ?? "alphanumeric"
+    );
+    return base.refine(
+      (v) => pattern.test(v),
+      { params: { code: "invalid", namespace: "licenseKey", label: opts.label } }
+    );
+  }
+});
+
+// src/rules/macAddress.ts
+import { z as z14 } from "zod";
+var COLON_PATTERN = /^[\dA-F]{2}(:[\dA-F]{2}){5}$/i;
+var HYPHEN_PATTERN = /^[\dA-F]{2}(-[\dA-F]{2}){5}$/i;
+var BARE_PATTERN = /^[\dA-F]{12}$/i;
+var PATTERNS = {
+  ":": COLON_PATTERN,
+  "-": HYPHEN_PATTERN,
+  "none": BARE_PATTERN
+};
+function getPattern(delimiter) {
+  return PATTERNS[delimiter] ?? COLON_PATTERN;
+}
+var MacAddress = /* @__PURE__ */ createRule({
+  name: "macAddress",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const delimiter = opts.delimiter ?? ":";
+    const pattern = getPattern(delimiter);
+    const base = opts.normalize !== false ? z14.string().trim() : z14.string();
+    return base.refine(
+      (v) => pattern.test(v),
+      { params: { code: "invalid", namespace: "macAddress", label: opts.label } }
+    );
+  }
+});
+
+// src/rules/password.ts
+import { z as z15 } from "zod";
+function applyLength(schema, range, label) {
+  if (range === void 0)
+    return schema;
+  const min = range.min;
+  const max = range.max;
+  return schema.superRefine((v, ctx) => {
+    applyLengthCheck(v, min, max, label, ctx);
+  });
+}
+function applyBlockCommon(schema, blockCommon, label) {
+  const tier = blockCommon === true || blockCommon === "basic" ? "basic" : blockCommon;
+  return schema.refine(
+    async (v) => {
+      if (typeof v !== "string")
+        return true;
+      try {
+        const passwords = getCommonPasswords(tier);
+        return !passwords.has(v.toLowerCase());
+      } catch {
+        const passwords = await loadCommonPasswords(tier);
+        return !passwords.has(v.toLowerCase());
+      }
+    },
+    { params: { code: "commonBlocked", namespace: "password", label } }
+  );
+}
+var Password = /* @__PURE__ */ createRule({
+  name: "password",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const ns = "password";
+    let base = z15.string();
+    if (opts.normalize !== false) {
+      base = base.trim();
+    }
+    let schema = applyLength(base, resolveRange(opts.length), opts.label);
+    const upper = resolveRange(opts.uppercase);
+    const lower = resolveRange(opts.lowercase);
+    const digit = resolveRange(opts.digits);
+    const special = resolveRange(opts.special);
+    const consec = resolveRange(opts.consecutive);
+    const lbl = opts.label;
+    if (upper !== void 0 && (upper.min !== void 0 && upper.min > 0 || upper.max !== void 0)) {
+      schema = schema.hasUppercase({ min: upper.min ?? 0, max: upper.max, namespace: ns, label: lbl });
+    }
+    if (lower !== void 0 && (lower.min !== void 0 && lower.min > 0 || lower.max !== void 0)) {
+      schema = schema.hasLowercase({ min: lower.min ?? 0, max: lower.max, namespace: ns, label: lbl });
+    }
+    if (digit !== void 0 && (digit.min !== void 0 && digit.min > 0 || digit.max !== void 0)) {
+      schema = schema.hasDigits({ min: digit.min ?? 0, max: digit.max, namespace: ns, label: lbl });
+    }
+    if (special !== void 0 && (special.min !== void 0 && special.min > 0 || special.max !== void 0)) {
+      schema = schema.hasSpecial({ min: special.min ?? 0, max: special.max, namespace: ns, label: lbl });
+    }
+    if (consec?.max !== void 0) {
+      schema = schema.maxConsecutive({ max: consec.max, namespace: ns, label: lbl });
+    }
+    if (opts.blockCommon !== false && opts.blockCommon !== void 0) {
+      schema = applyBlockCommon(schema, opts.blockCommon, opts.label);
+    }
+    return schema;
+  }
+});
+
+// src/rules/passwordConfirmation.ts
+var PasswordConfirmation = /* @__PURE__ */ (() => {
+  return (options) => {
+    initAugmentation();
+    const tier1 = RULE_DEFAULTS["passwordConfirmation"] ?? {};
+    const tier2 = getConfig2().rules?.passwordConfirmation ?? {};
+    const merged = mergeThreeTiers(
+      tier1,
+      tier2,
+      options ?? {}
+    );
+    const passthrough = {};
+    if (merged.label !== void 0)
+      passthrough["label"] = merged.label;
+    if (merged.emptyToUndefined !== void 0)
+      passthrough["emptyToUndefined"] = merged.emptyToUndefined;
+    if (merged.normalize !== void 0)
+      passthrough["normalize"] = merged.normalize;
+    if (merged.customFn !== void 0)
+      passthrough["customFn"] = merged.customFn;
+    const schema = Password(passthrough);
+    registerCrossField(schema, {
+      sameAs: merged.passwordField ?? "password",
+      label: merged.label
+    });
+    return schema;
+  };
+})();
+
+// src/rules/personName.ts
+import { z as z16 } from "zod";
+var DEFAULT_EXTRA2 = " -'\u2019";
+function buildCharsetRegex(allowUnicode, extraChars, disallowChars) {
+  let allowed = DEFAULT_EXTRA2;
+  if (extraChars !== void 0) {
+    allowed += extraChars;
+  }
+  if (disallowChars !== void 0) {
+    for (const ch of disallowChars) {
+      allowed = allowed.replaceAll(ch, "");
+    }
+  }
+  const letterClass = allowUnicode ? "\\p{L}" : "a-zA-Z";
+  const extra = escapeRegexChars(allowed);
+  return new RegExp(`^[${letterClass}${extra}]+$`, "u");
+}
+var PersonName = /* @__PURE__ */ createRule({
+  name: "personName",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const range = resolveRange(opts.length);
+    const wordsRange = resolveRange(opts.words);
+    const consecutiveRange = resolveRange(opts.consecutive);
+    const boundary = resolveBoundary(opts.boundary);
+    const base = opts.normalize !== false ? z16.string().trim() : z16.string();
+    const minLen = range?.min;
+    const maxLen = range?.max;
+    const lbl = opts.label;
+    const pattern = opts.regex ?? buildCharsetRegex(
+      opts.allowUnicode !== false,
+      opts.extraChars,
+      opts.disallowChars
+    );
+    const stage1 = base.superRefine((v, ctx) => {
+      if (minLen !== void 0 && v.length < minLen) {
+        ctx.addIssue({ code: "custom", params: { code: "min", namespace: "base", label: lbl, minimum: minLen } });
+        return;
+      }
+      if (maxLen !== void 0 && v.length > maxLen) {
+        ctx.addIssue({ code: "custom", params: { code: "max", namespace: "base", label: lbl, maximum: maxLen } });
+        return;
+      }
+      if (!pattern.test(v)) {
+        ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "personName", label: lbl } });
+        return;
+      }
+      if (boundary !== void 0 && !checkUnicodeBoundary(v, boundary)) {
+        ctx.addIssue({ code: "custom", params: { code: "boundary", namespace: "personName", label: lbl } });
+      }
+    });
+    let stage2 = z16.string();
+    if (consecutiveRange?.max !== void 0) {
+      stage2 = stage2.maxConsecutive({ max: consecutiveRange.max, namespace: "personName", label: lbl });
+    }
+    if (wordsRange?.max !== void 0) {
+      stage2 = stage2.maxWords({ max: wordsRange.max, namespace: "personName", label: lbl });
+    }
+    const validated = stage1.pipe(stage2);
+    if (opts.titleCase === true) {
+      return validated.transform(toTitleCase);
+    }
+    return validated;
+  }
+});
+
+// src/rules/phone.ts
+import { z as z17 } from "zod";
+function formatPhoneNumber(parsed, fmt) {
+  switch (fmt) {
+    case "e164":
+      return parsed.format("E.164");
+    case "international":
+      return parsed.format("INTERNATIONAL");
+    case "national":
+      return parsed.format("NATIONAL");
+  }
+}
+function tryParsePhone(value, country, parser) {
+  try {
+    return parser(value, country);
+  } catch {
+    return null;
+  }
+}
+function addPhoneIssue(ctx, code, label, extras) {
+  ctx.addIssue({
+    code: "custom",
+    params: { code, namespace: "phone", label, ...extras }
+  });
+}
+function validatePhoneConstraints(parsed, opts, ctx) {
+  const lbl = opts.label;
+  if (opts.requireMobile) {
+    const phoneType = parsed.getType();
+    if (phoneType !== "MOBILE" && phoneType !== "FIXED_LINE_OR_MOBILE") {
+      addPhoneIssue(ctx, "requireMobile", lbl);
+      return;
+    }
+  }
+  const parsedCountry = parsed.country;
+  const allow = opts.allowCountries ?? [];
+  const block = opts.blockCountries ?? [];
+  if (allow.length > 0 && (!parsedCountry || !allow.includes(parsedCountry))) {
+    addPhoneIssue(ctx, "countryNotAllowed", lbl, { country: parsedCountry ?? "unknown" });
+    return;
+  }
+  if (block.length > 0 && parsedCountry && block.includes(parsedCountry)) {
+    addPhoneIssue(ctx, "countryBlocked", lbl, { country: parsedCountry });
+  }
+}
+var Phone = /* @__PURE__ */ createRule({
+  name: "phone",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const metadata = opts.metadata;
+    if (opts.requireMobile && metadata === "min") {
+      throw new Error(
+        'validex: requireMobile: true requires metadata: "mobile" or "max". Min metadata cannot detect mobile numbers reliably.'
+      );
+    }
+    if (metadata === "custom" && (opts.customMetadataPath === void 0 || opts.customMetadataPath === "")) {
+      throw new Error('validex: Phone metadata "custom" requires customMetadataPath');
+    }
+    const fmt = opts.format ?? "e164";
+    const base = opts.normalize !== false ? z17.string().trim() : z17.string();
+    let cachedParsed;
+    return base.superRefine(
+      async (value, ctx) => {
+        cachedParsed = void 0;
+        if (opts.requireCountryCode && !value.startsWith("+")) {
+          addPhoneIssue(ctx, "countryCodeRequired", opts.label);
+          return;
+        }
+        const parser = await loadPhoneParser(metadata, opts.customMetadataPath);
+        const parsed = tryParsePhone(value, opts.country, parser);
+        if (!parsed || !parsed.isValid()) {
+          addPhoneIssue(ctx, "invalid", opts.label);
+          return;
+        }
+        cachedParsed = parsed;
+        validatePhoneConstraints(parsed, opts, ctx);
+      }
+    ).transform(async (value) => {
+      if (opts.normalize === false)
+        return value;
+      if (cachedParsed === void 0)
+        return value;
+      return formatPhoneNumber(cachedParsed, fmt);
+    });
+  }
+});
+
+// src/rules/postalCode.ts
+import { z as z18 } from "zod";
+var PostalCode = /* @__PURE__ */ createRule({
+  name: "postalCode",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const country = opts.country.toUpperCase();
+    const mod = getPostalCodes();
+    if (mod !== void 0 && !opts.regex && !opts.customFn && !mod.postcodeValidatorExistsForCountry(country)) {
+      throw new Error(
+        `validex: PostalCode country "${opts.country}" is not supported. Provide a regex or customFn for custom validation.`
+      );
+    }
+    const base = opts.normalize !== false ? z18.string().transform((v) => v.trim().toUpperCase()) : z18.string();
+    return base.pipe(
+      z18.string().superRefine(async (value, ctx) => {
+        if (opts.regex) {
+          if (!opts.regex.test(value)) {
+            ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "postalCode", label: opts.label } });
+          }
+          return;
+        }
+        const resolved = mod ?? await loadPostalCodes();
+        if (!resolved.postcodeValidatorExistsForCountry(country)) {
+          if (!opts.customFn) {
+            ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "postalCode", label: opts.label } });
+          }
+          return;
+        }
+        if (!resolved.postcodeValidator(value, country)) {
+          ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "postalCode", label: opts.label } });
+        }
+      })
+    );
+  }
+});
+
+// src/rules/slug.ts
+import { z as z19 } from "zod";
+var ESCAPE_REGEX_RE2 = /[.*+?^${}()|[\]\\]/g;
+var DEFAULT_SLUG_RE = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+function buildSlugPattern(extraChars) {
+  if (extraChars !== void 0 && extraChars.length > 0) {
+    const escaped = extraChars.replace(ESCAPE_REGEX_RE2, "\\$&");
+    return new RegExp(`^[a-z0-9${escaped}]+(-[a-z0-9${escaped}]+)*$`);
+  }
+  return DEFAULT_SLUG_RE;
+}
+var Slug = /* @__PURE__ */ createRule({
+  name: "slug",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const range = resolveRange(opts.length);
+    const min = range?.min ?? 1;
+    const max = range?.max ?? 100;
+    const pattern = opts.regex ?? buildSlugPattern(opts.extraChars);
+    const base = opts.normalize !== false ? z19.string().transform((v) => v.trim().toLowerCase()) : z19.string();
+    const lbl = opts.label;
+    return base.pipe(
+      z19.string().superRefine((v, ctx) => {
+        if (v.length < min) {
+          ctx.addIssue({ code: "custom", params: { code: "min", namespace: "base", label: lbl, minimum: min } });
+          return;
+        }
+        if (v.length > max) {
+          ctx.addIssue({ code: "custom", params: { code: "max", namespace: "base", label: lbl, maximum: max } });
+          return;
+        }
+        if (!pattern.test(v)) {
+          ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "slug", label: lbl } });
+        }
+      })
+    );
+  }
+});
+
+// src/rules/text.ts
+import { z as z20 } from "zod";
+var Text = /* @__PURE__ */ createRule({
+  name: "text",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const range = resolveRange(opts.length);
+    const wordsRange = resolveRange(opts.words);
+    const consecutiveRange = resolveRange(opts.consecutive);
+    const base = opts.normalize !== false ? z20.string().trim() : z20.string();
+    const lengthSchema = buildLengthSchema(range, opts.label);
+    let schema = base.pipe(lengthSchema);
+    if (opts.regex !== void 0) {
+      const pattern = opts.regex;
+      schema = schema.pipe(z20.string().refine(
+        (v) => pattern.test(v),
+        { params: { code: "invalid", namespace: "text", label: opts.label } }
+      ));
+    }
+    if (opts.noEmails === true) {
+      schema = schema.noEmails({ namespace: "text", label: opts.label });
+    }
+    if (opts.noUrls === true) {
+      schema = schema.noUrls({ namespace: "text", label: opts.label });
+    }
+    if (opts.noHtml === true) {
+      schema = schema.noHtml({ namespace: "text", label: opts.label });
+    }
+    if (opts.noPhoneNumbers === true) {
+      schema = schema.noPhoneNumbers({ namespace: "text", label: opts.label });
+    }
+    if (wordsRange?.min !== void 0) {
+      schema = schema.minWords({ min: wordsRange.min, namespace: "text", label: opts.label });
+    }
+    if (wordsRange?.max !== void 0) {
+      schema = schema.maxWords({ max: wordsRange.max, namespace: "text", label: opts.label });
+    }
+    if (consecutiveRange?.max !== void 0) {
+      schema = schema.maxConsecutive({ max: consecutiveRange.max, namespace: "text", label: opts.label });
+    }
+    return schema;
+  }
+});
+function buildLengthSchema(range, label) {
+  const min = range?.min;
+  const max = range?.max;
+  return z20.string().superRefine((v, ctx) => {
+    applyLengthCheck(v, min, max, label, ctx);
+  });
+}
+
+// src/rules/token.ts
+import { z as z21 } from "zod";
+var TOKEN_SPECS = {
+  nanoid: { pattern: /^[\w-]+$/, defaultLength: 21 },
+  cuid: { pattern: /^c[a-z0-9]+$/, defaultLength: 25 },
+  cuid2: { pattern: /^[a-z][a-z0-9]+$/, defaultLength: 24 },
+  ulid: { pattern: /^[0-9A-HJKMNP-TV-Z]{26}$/i, defaultLength: 26 },
+  hex: { pattern: /^[0-9a-f]+$/i },
+  base64: { pattern: /^[A-Z0-9+/]+=*$/i }
+};
+var Token = /* @__PURE__ */ createRule({
+  name: "token",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const spec = TOKEN_SPECS[opts.type];
+    const range = resolveRange(opts.length);
+    const schema = opts.normalize !== false ? z21.string().trim() : z21.string();
+    const min = range?.min ?? spec.defaultLength ?? void 0;
+    const max = range?.max ?? spec.defaultLength ?? void 0;
+    const pattern = opts.regex ?? spec.pattern;
+    const lbl = opts.label;
+    const tokenType = opts.type;
+    return schema.superRefine((v, ctx) => {
+      if (min !== void 0 && v.length < min) {
+        ctx.addIssue({ code: "custom", params: { code: "min", namespace: "base", label: lbl, minimum: min } });
+        return;
+      }
+      if (max !== void 0 && v.length > max) {
+        ctx.addIssue({ code: "custom", params: { code: "max", namespace: "base", label: lbl, maximum: max } });
+        return;
+      }
+      if (!pattern.test(v)) {
+        ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "token", type: tokenType, label: lbl } });
+      }
+    });
+  }
+});
+
+// src/rules/url.ts
+import { z as z23 } from "zod";
+
+// src/internal/formatChecks.ts
+import { z as z22 } from "zod";
+var URL_FORMAT_CHECK = z22.string().url();
+
+// src/rules/url.ts
+var TRAILING_COLON_RE = /:$/;
+function parseUrlSafely(value) {
+  try {
+    return new URL(value);
+  } catch {
+    return void 0;
+  }
+}
+function checkUrlConstraints(parsed, opts, ctx, ns, lbl, protocols, blockDomains, allowDomains) {
+  const protocol = parsed.protocol.replace(TRAILING_COLON_RE, "");
+  const { hostname } = parsed;
+  if (protocols.length > 0 && !protocols.includes(protocol)) {
+    ctx.addIssue({ code: "custom", params: { code: "protocolNotAllowed", namespace: ns, protocol, label: lbl } });
+  }
+  if (opts.requireTLD === true && !hostname.includes(".")) {
+    ctx.addIssue({ code: "custom", params: { code: "tldRequired", namespace: ns, label: lbl } });
+  }
+  if (opts.allowAuth !== true && (parsed.username !== "" || parsed.password !== "")) {
+    ctx.addIssue({ code: "custom", params: { code: "authNotAllowed", namespace: ns, label: lbl } });
+  }
+  if (blockDomains.length > 0 && matchesDomainList(hostname, blockDomains)) {
+    ctx.addIssue({ code: "custom", params: { code: "domainBlocked", namespace: ns, domain: hostname, label: lbl } });
+  }
+  if (allowDomains.length > 0 && !matchesDomainList(hostname, allowDomains)) {
+    ctx.addIssue({ code: "custom", params: { code: "domainNotAllowed", namespace: ns, domain: hostname, label: lbl } });
+  }
+  if (opts.allowQuery === false && parsed.search !== "") {
+    ctx.addIssue({ code: "custom", params: { code: "queryNotAllowed", namespace: ns, label: lbl } });
+  }
+}
+var Url = /* @__PURE__ */ createRule({
+  name: "url",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const range = resolveRange(opts.length);
+    const max = range?.max ?? 2048;
+    const protocols = opts.protocols ?? ["http", "https"];
+    const min = range?.min;
+    const base = opts.normalize !== false ? z23.string().trim() : z23.string();
+    const lbl = opts.label;
+    const ns = "url";
+    const blockDomains = opts.blockDomains ?? [];
+    const allowDomains = opts.allowDomains ?? [];
+    return base.pipe(z23.string().superRefine((v, ctx) => {
+      applyLengthCheck(v, min, max, lbl, ctx);
+      if (!URL_FORMAT_CHECK.safeParse(v).success) {
+        ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: ns, label: lbl } });
+        return;
+      }
+      const parsed = parseUrlSafely(v);
+      if (parsed === void 0)
+        return;
+      checkUrlConstraints(parsed, opts, ctx, ns, lbl, protocols, blockDomains, allowDomains);
+    }));
+  }
+});
+
+// src/rules/username.ts
+import { z as z24 } from "zod";
+var PATTERN_MAP = {
+  "alphanumeric": "a-z0-9",
+  "alphanumeric-dash": "a-z0-9\\-",
+  "alphanumeric-underscore": "a-z0-9_"
+};
+function buildUsernamePattern(pattern, extraChars, disallowChars) {
+  let charClass = PATTERN_MAP[pattern] ?? "a-z0-9_";
+  if (extraChars !== void 0 && extraChars.length > 0) {
+    charClass += escapeRegexChars(extraChars);
+  }
+  if (disallowChars !== void 0) {
+    for (const ch of disallowChars) {
+      charClass = charClass.replaceAll(escapeRegexChars(ch), "");
+    }
+  }
+  return new RegExp(`^[${charClass}]+$`);
+}
+function applyReservedRefine(schema, ignoreCase, customReserved, label) {
+  return schema.superRefine(async (v, ctx) => {
+    if (typeof v !== "string")
+      return;
+    const normalized = ignoreCase ? v.toLowerCase() : v;
+    if (customReserved.length > 0) {
+      const customSet = customReserved.map((w) => ignoreCase ? w.toLowerCase() : w);
+      if (customSet.includes(normalized)) {
+        ctx.addIssue({ code: "custom", params: { code: "reservedBlocked", namespace: "username", value: normalized, label } });
+        return;
+      }
+    }
+    let isReserved = false;
+    try {
+      const reserved = getReservedUsernames();
+      isReserved = reserved.has(normalized);
+    } catch {
+      const reserved = await loadReservedUsernames();
+      isReserved = reserved.has(normalized);
+    }
+    if (isReserved) {
+      ctx.addIssue({ code: "custom", params: { code: "reservedBlocked", namespace: "username", value: normalized, label } });
+    }
+  });
+}
+var Username = /* @__PURE__ */ createRule({
+  name: "username",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const range = resolveRange(opts.length);
+    const consecutiveRange = resolveRange(opts.consecutive);
+    const boundary = resolveBoundary(opts.boundary);
+    const min = range?.min ?? 3;
+    const max = range?.max ?? 20;
+    const pattern = opts.regex ?? buildUsernamePattern(
+      opts.pattern ?? "alphanumeric-underscore",
+      /* v8 ignore stop */
+      opts.extraChars,
+      opts.disallowChars
+    );
+    const base = opts.normalize !== false ? z24.string().transform((v) => v.trim().toLowerCase()) : z24.string();
+    const lbl = opts.label;
+    const stage1 = z24.string().superRefine((v, ctx) => {
+      if (v.length < min) {
+        ctx.addIssue({ code: "custom", params: { code: "min", namespace: "base", label: lbl, minimum: min } });
+        return;
+      }
+      if (v.length > max) {
+        ctx.addIssue({ code: "custom", params: { code: "max", namespace: "base", label: lbl, maximum: max } });
+        return;
+      }
+      if (!pattern.test(v)) {
+        ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "username", label: lbl } });
+        return;
+      }
+      if (boundary !== void 0 && !checkAsciiBoundary(v, boundary)) {
+        ctx.addIssue({ code: "custom", params: { code: "boundary", namespace: "username", label: lbl } });
+      }
+    });
+    let stage2 = z24.string();
+    if (consecutiveRange?.max !== void 0) {
+      stage2 = stage2.maxConsecutive({ max: consecutiveRange.max, namespace: "username", label: lbl });
+    }
+    let inner = stage1.pipe(stage2);
+    if (opts.blockReserved === true) {
+      inner = applyReservedRefine(
+        inner,
+        opts.ignoreCase !== false,
+        opts.reservedWords ?? [],
+        opts.label
+      );
+    }
+    return base.pipe(inner);
+  }
+});
+
+// src/rules/uuid.ts
+import { z as z25 } from "zod";
+var UUID_VERSION_INDEX = 14;
+var UUID_FORMAT_CHECK2 = z25.string().uuid();
+var Uuid = /* @__PURE__ */ createRule({
+  name: "uuid",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const base = opts.normalize !== false ? z25.string().trim().toLowerCase() : z25.string();
+    let schema = base.pipe(z25.string().superRefine((v, ctx) => {
+      if (!UUID_FORMAT_CHECK2.safeParse(v).success) {
+        ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: "uuid", label: opts.label } });
+      }
+    }));
+    if (opts.version !== void 0 && opts.version !== "any") {
+      const expected = String(opts.version);
+      schema = schema.refine(
+        (v) => typeof v === "string" && v.charAt(UUID_VERSION_INDEX) === expected,
+        { params: { code: "invalid", namespace: "uuid", label: opts.label } }
+      );
+    }
+    return schema;
+  }
+});
+
+// src/rules/vatNumber.ts
+import { z as z26 } from "zod";
+var WHITESPACE_RE = /\s+/g;
+async function resolveVatPatterns() {
+  try {
+    return getVatPatterns();
+  } catch {
+    return loadVatPatterns();
+  }
+}
+function extractCountryAndNumber(value, country, requirePrefix) {
+  if (country === void 0 || country === "") {
+    const cc = value.slice(0, 2);
+    return [cc, value.slice(2)];
+  }
+  if (requirePrefix) {
+    if (!value.startsWith(country))
+      return null;
+    return [country, value.slice(country.length)];
+  }
+  const numberPart = value.startsWith(country) ? value.slice(country.length) : value;
+  return [country, numberPart];
+}
+var VatNumber = /* @__PURE__ */ createRule({
+  name: "vatNumber",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const requirePrefix = opts.requirePrefix ?? false;
+    const schema = opts.normalize !== false ? z26.string().transform(
+      (v) => v.trim().toUpperCase().replace(WHITESPACE_RE, "")
+    ) : z26.string();
+    return schema.pipe(
+      z26.string().refine(
+        async (value) => {
+          const patterns = await resolveVatPatterns();
+          const parts = extractCountryAndNumber(
+            value,
+            opts.country,
+            requirePrefix
+          );
+          if (!parts)
+            return false;
+          const [cc, numberPart] = parts;
+          const pattern = patterns.get(cc);
+          if (!pattern)
+            return false;
+          return pattern.test(numberPart);
+        },
+        { params: { code: "invalid", namespace: "vatNumber", label: opts.label } }
+      )
+    );
+  }
+});
+
+// src/rules/website.ts
+import { z as z27 } from "zod";
+var PROTOCOL_PREFIX_RE = /^[a-z][a-z\d+\-.]*:/i;
+function normalizeWebsiteInput(value) {
+  const normalized = value.trim().toLowerCase();
+  if (PROTOCOL_PREFIX_RE.test(normalized))
+    return normalized;
+  return `https://${normalized}`;
+}
+function isBaseDomain(hostname) {
+  const stripped = hostname.startsWith("www.") ? hostname.slice(4) : hostname;
+  return stripped.split(".").length <= 2;
+}
+function checkWebsiteConstraints(parsed, opts, ctx, ns, lbl, blockDomains, allowDomains) {
+  const { protocol, hostname, pathname, search } = parsed;
+  const isHttp = protocol === "http:" || protocol === "https:";
+  if (!isHttp) {
+    ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: ns, label: lbl } });
+    return;
+  }
+  if (opts.requireHttps === true && protocol !== "https:") {
+    ctx.addIssue({ code: "custom", params: { code: "httpsRequired", namespace: ns, label: lbl } });
+  }
+  if (opts.requireWww === true && !hostname.startsWith("www.")) {
+    ctx.addIssue({ code: "custom", params: { code: "wwwRequired", namespace: ns, label: lbl } });
+  }
+  if (blockDomains.length > 0 && matchesDomainList(hostname, blockDomains)) {
+    ctx.addIssue({ code: "custom", params: { code: "domainBlocked", namespace: ns, domain: hostname, label: lbl } });
+  }
+  if (allowDomains.length > 0 && !matchesDomainList(hostname, allowDomains)) {
+    ctx.addIssue({ code: "custom", params: { code: "domainNotAllowed", namespace: ns, domain: hostname, label: lbl } });
+  }
+  if (opts.allowSubdomains === false && !isBaseDomain(hostname)) {
+    ctx.addIssue({ code: "custom", params: { code: "subdomainNotAllowed", namespace: ns, label: lbl } });
+  }
+  if (opts.allowPath === false && pathname !== "/" && pathname !== "") {
+    ctx.addIssue({ code: "custom", params: { code: "pathNotAllowed", namespace: ns, label: lbl } });
+  }
+  if (opts.allowQuery !== true && search !== "") {
+    ctx.addIssue({ code: "custom", params: { code: "queryNotAllowed", namespace: ns, label: lbl } });
+  }
+}
+var Website = /* @__PURE__ */ createRule({
+  name: "website",
+  defaults: {},
+  messages: {},
+  build: (opts) => {
+    const range = resolveRange(opts.length);
+    const max = range?.max ?? 255;
+    const min = range?.min;
+    const lbl = opts.label;
+    const ns = "website";
+    const blockDomains = opts.blockDomains ?? [];
+    const allowDomains = opts.allowDomains ?? [];
+    const base = opts.normalize !== false ? z27.string().transform(normalizeWebsiteInput) : z27.string();
+    return base.pipe(z27.string().superRefine((v, ctx) => {
+      applyLengthCheck(v, min, max, lbl, ctx);
+      if (!URL_FORMAT_CHECK.safeParse(v).success) {
+        ctx.addIssue({ code: "custom", params: { code: "invalid", namespace: ns, label: lbl } });
+        return;
+      }
+      try {
+        checkWebsiteConstraints(new URL(v), opts, ctx, ns, lbl, blockDomains, allowDomains);
+      } catch {
+      }
+    }));
+  }
+});
+
+export {
+  getConfig,
+  resetConfig,
+  getErrorMessage,
+  fieldNameToLabel,
+  getParams,
+  initAugmentation,
+  configure,
+  setup,
+  getConfig2,
+  preloadData,
+  getCrossField,
+  createRule,
+  BusinessName,
+  Color,
+  Country,
+  CreditCard,
+  Currency,
+  DateTime,
+  Email,
+  Iban,
+  IpAddress,
+  Jwt,
+  LicenseKey,
+  MacAddress,
+  Password,
+  PasswordConfirmation,
+  PersonName,
+  Phone,
+  PostalCode,
+  Slug,
+  Text,
+  Token,
+  Url,
+  Username,
+  Uuid,
+  VatNumber,
+  Website
+};