@validex/core 1.0.0

package/dist/chunk-6MGS4JWP.js

@@ -0,0 +1,152 @@
+// src/checks/composition.ts
+function countMatches(value, pattern) {
+  const matches = value.match(pattern);
+  return matches ? matches.length : 0;
+}
+function inRange(count, min, max) {
+  return count >= min && (max === void 0 || count <= max);
+}
+var UPPERCASE_RE = /\p{Lu}/gu;
+var LOWERCASE_RE = /\p{Ll}/gu;
+var DIGIT_RE = /\p{Nd}/gu;
+var SPECIAL_RE = /[^\p{L}\p{Nd}\s]/gu;
+function hasUppercase(value, min, max) {
+  return inRange(countMatches(value, UPPERCASE_RE), min, max);
+}
+function hasLowercase(value, min, max) {
+  return inRange(countMatches(value, LOWERCASE_RE), min, max);
+}
+function hasDigits(value, min, max) {
+  return inRange(countMatches(value, DIGIT_RE), min, max);
+}
+function hasSpecial(value, min, max) {
+  return inRange(countMatches(value, SPECIAL_RE), min, max);
+}
+
+// src/checks/detection.ts
+var EMAIL_RE = /[\w.%+-]+@[a-z0-9.-]+\.[a-z]{2,}/i;
+function containsEmail(value) {
+  return EMAIL_RE.test(value);
+}
+var URL_PROTOCOL_RE = /https?:\/\/\S+/i;
+var URL_WWW_RE = /\bwww\.\S+/i;
+function containsUrl(value) {
+  return URL_PROTOCOL_RE.test(value) || URL_WWW_RE.test(value);
+}
+var HTML_TAG_RE = /<[a-z/][^>]*>/i;
+function containsHtml(value) {
+  return HTML_TAG_RE.test(value);
+}
+
+// src/checks/limits.ts
+var WHITESPACE_RE = /\s+/;
+function maxWords(value, max) {
+  const words = value.split(WHITESPACE_RE).filter((segment) => segment.length > 0);
+  return words.length <= max;
+}
+function minWords(value, min) {
+  const words = value.trim().split(WHITESPACE_RE).filter((segment) => segment.length > 0);
+  return words.length >= min;
+}
+function maxConsecutive(value, max) {
+  const chars = Array.from(value);
+  let count = 1;
+  for (let i = 1; i < chars.length; i++) {
+    if (chars[i] === chars[i - 1]) {
+      count++;
+      if (count > max) {
+        return false;
+      }
+    } else {
+      count = 1;
+    }
+  }
+  return true;
+}
+var ANY_WHITESPACE_RE = /\s/;
+function noSpaces(value) {
+  return !ANY_WHITESPACE_RE.test(value);
+}
+
+// src/checks/restriction.ts
+var ALPHA_RE = /^\p{L}+$/u;
+function onlyAlpha(value) {
+  return ALPHA_RE.test(value);
+}
+var NUMERIC_RE = /^\d+$/;
+function onlyNumeric(value) {
+  return NUMERIC_RE.test(value);
+}
+var ALPHANUMERIC_RE = /^[\p{L}\d]+$/u;
+function onlyAlphanumeric(value) {
+  return ALPHANUMERIC_RE.test(value);
+}
+var ALPHANUMERIC_SPACE_HYPHEN_RE = /^[\p{L}\d\s-]+$/u;
+function onlyAlphanumericSpaceHyphen(value) {
+  return ALPHANUMERIC_SPACE_HYPHEN_RE.test(value);
+}
+var ALPHA_SPACE_HYPHEN_RE = /^[\p{L}\s-]+$/u;
+function onlyAlphaSpaceHyphen(value) {
+  return ALPHA_SPACE_HYPHEN_RE.test(value);
+}
+
+// src/checks/transforms.ts
+function emptyToUndefined(value) {
+  if (value === "" || value === null) {
+    return void 0;
+  }
+  return value;
+}
+function toTitleCase(value) {
+  return value.toLowerCase().split(" ").map(
+    (word) => word.split("-").map((segment) => capitalizeSegment(segment)).join("-")
+  ).join(" ");
+}
+var CAPITALIZE_RE = /(?:^|(?<='))./gu;
+function capitalizeSegment(segment) {
+  if (segment.length === 0) {
+    return segment;
+  }
+  return segment.replace(
+    CAPITALIZE_RE,
+    (char) => char.toUpperCase()
+  );
+}
+var SLUG_NON_ALNUM_RE = /[^a-z\d]+/g;
+var SLUG_MULTI_HYPHEN_RE = /-+/g;
+var SLUG_EDGE_HYPHEN_RE = /^-|-$/g;
+function toSlug(value) {
+  return value.toLowerCase().replace(SLUG_NON_ALNUM_RE, "-").replace(SLUG_MULTI_HYPHEN_RE, "-").replace(SLUG_EDGE_HYPHEN_RE, "");
+}
+var HTML_STRIP_RE = /<[^>]*>/g;
+function stripHtml(value) {
+  return value.replace(HTML_STRIP_RE, "");
+}
+var MULTI_WHITESPACE_RE = /\s+/g;
+function collapseWhitespace(value) {
+  return value.replace(MULTI_WHITESPACE_RE, " ").trim();
+}
+
+export {
+  hasUppercase,
+  hasLowercase,
+  hasDigits,
+  hasSpecial,
+  containsEmail,
+  containsUrl,
+  containsHtml,
+  maxWords,
+  minWords,
+  maxConsecutive,
+  noSpaces,
+  onlyAlpha,
+  onlyNumeric,
+  onlyAlphanumeric,
+  onlyAlphanumericSpaceHyphen,
+  onlyAlphaSpaceHyphen,
+  emptyToUndefined,
+  toTitleCase,
+  toSlug,
+  stripHtml,
+  collapseWhitespace
+};

package/dist/chunk-AGJWIOFF.js

@@ -0,0 +1,24 @@
+// src/loaders/disposableDomains.ts
+var cache;
+async function loadDisposableDomains() {
+  if (cache !== void 0)
+    return cache;
+  const { disposableEmailBlocklistSet } = await import("disposable-email-domains-js");
+  cache = disposableEmailBlocklistSet();
+  return cache;
+}
+function getDisposableDomains() {
+  if (cache === void 0) {
+    throw new Error("Disposable domains not loaded. Call loadDisposableDomains() or preloadData({ disposable: true }) first.");
+  }
+  return cache;
+}
+function clearDisposableDomainsCache() {
+  cache = void 0;
+}
+
+export {
+  loadDisposableDomains,
+  getDisposableDomains,
+  clearDisposableDomainsCache
+};

package/dist/chunk-BAFEYOPS.js

@@ -0,0 +1,43 @@
+// src/utilities/requiredWhen.ts
+import { z } from "zod";
+function requiredWhen(field, condition, options) {
+  const lbl = options?.label ?? field;
+  const message = options?.message ?? `${lbl} is required`;
+  return (data, ctx) => {
+    if (!condition(data)) {
+      return;
+    }
+    const value = data[field];
+    if (value === void 0 || value === null || value === "") {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message,
+        path: [field],
+        params: { code: "required", namespace: "base", label: lbl }
+      });
+    }
+  };
+}
+
+// src/utilities/sameAs.ts
+import { z as z2 } from "zod";
+function sameAs(sourceField, targetField, options) {
+  const srcLabel = options?.label ?? sourceField;
+  const tgtLabel = options?.targetLabel ?? targetField;
+  const message = options?.message ?? `${srcLabel} must match ${tgtLabel}`;
+  return (data, ctx) => {
+    if (data[sourceField] !== data[targetField]) {
+      ctx.addIssue({
+        code: z2.ZodIssueCode.custom,
+        message,
+        path: [sourceField],
+        params: { code: "mismatch", namespace: "confirmation", label: srcLabel, targetLabel: tgtLabel }
+      });
+    }
+  };
+}
+
+export {
+  requiredWhen,
+  sameAs
+};

package/dist/chunk-BYMZTDYD.js

@@ -0,0 +1,56 @@
+// src/loaders/phoneParser.ts
+var cache = /* @__PURE__ */ new Map();
+async function loadPhoneParser(metadata = "min", customPath) {
+  const cached = cache.get(metadata);
+  if (cached !== void 0)
+    return cached;
+  let parser;
+  switch (metadata) {
+    case "min": {
+      const mod = await import("libphonenumber-js");
+      parser = mod.parsePhoneNumberWithError;
+      break;
+    }
+    case "mobile": {
+      const mod = await import("libphonenumber-js/mobile");
+      parser = mod.parsePhoneNumberWithError;
+      break;
+    }
+    case "max": {
+      const mod = await import("libphonenumber-js/max");
+      parser = mod.parsePhoneNumberWithError;
+      break;
+    }
+    /* v8 ignore start -- custom metadata requires user-provided path; not testable without fixtures */
+    case "custom": {
+      if (customPath === void 0 || customPath === "") {
+        throw new Error('validex: Phone metadata "custom" requires customMetadataPath');
+      }
+      const core = await import("libphonenumber-js/core");
+      const meta = await import(customPath);
+      parser = ((v, c) => (
+        // SAFETY: custom metadata default export is the metadata object by user contract; c cast avoids overload mismatch
+        core.parsePhoneNumberWithError(v, c, meta.default)
+      ));
+      break;
+    }
+  }
+  cache.set(metadata, parser);
+  return parser;
+}
+function getPhoneParser(metadata = "min") {
+  const parser = cache.get(metadata);
+  if (parser === void 0) {
+    throw new Error(`Phone parser (${metadata}) not loaded. Call loadPhoneParser() or preloadData({ phone: '${metadata}' }) first.`);
+  }
+  return parser;
+}
+function clearPhoneParserCache() {
+  cache.clear();
+}
+
+export {
+  loadPhoneParser,
+  getPhoneParser,
+  clearPhoneParserCache
+};

package/dist/chunk-D232V332.cjs

@@ -0,0 +1,30 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }// src/loaders/vatPatterns.ts
+var cache;
+async function loadVatPatterns() {
+  if (cache !== void 0)
+    return cache;
+  const raw = (await Promise.resolve().then(() => _interopRequireWildcard(require("./vatPatterns-NPN6SV2Y.cjs")))).default;
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of raw) {
+    map.set(entry.country, new RegExp(entry.regex));
+  }
+  cache = map;
+  return cache;
+}
+function getVatPatterns() {
+  if (cache === void 0) {
+    throw new Error(
+      "validex: VAT patterns not loaded. Use parseAsync() or call preloadData() first."
+    );
+  }
+  return cache;
+}
+function clearVatPatternsCache() {
+  cache = void 0;
+}
+
+
+
+
+
+exports.loadVatPatterns = loadVatPatterns; exports.getVatPatterns = getVatPatterns; exports.clearVatPatternsCache = clearVatPatternsCache;

package/dist/chunk-FD77PZXB.js

@@ -0,0 +1,9 @@
+// src/checks/phoneDetection.ts
+async function containsPhoneNumber(value) {
+  const { findPhoneNumbersInText } = await import("libphonenumber-js");
+  return findPhoneNumbersInText(value).length > 0;
+}
+
+export {
+  containsPhoneNumber
+};

package/dist/chunk-H3XHQLZF.cjs

@@ -0,0 +1,43 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/utilities/requiredWhen.ts
+var _zod = require('zod');
+function requiredWhen(field, condition, options) {
+  const lbl = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.label]), () => ( field));
+  const message = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.message]), () => ( `${lbl} is required`));
+  return (data, ctx) => {
+    if (!condition(data)) {
+      return;
+    }
+    const value = data[field];
+    if (value === void 0 || value === null || value === "") {
+      ctx.addIssue({
+        code: _zod.z.ZodIssueCode.custom,
+        message,
+        path: [field],
+        params: { code: "required", namespace: "base", label: lbl }
+      });
+    }
+  };
+}
+
+// src/utilities/sameAs.ts
+
+function sameAs(sourceField, targetField, options) {
+  const srcLabel = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _3 => _3.label]), () => ( sourceField));
+  const tgtLabel = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _4 => _4.targetLabel]), () => ( targetField));
+  const message = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _5 => _5.message]), () => ( `${srcLabel} must match ${tgtLabel}`));
+  return (data, ctx) => {
+    if (data[sourceField] !== data[targetField]) {
+      ctx.addIssue({
+        code: _zod.z.ZodIssueCode.custom,
+        message,
+        path: [sourceField],
+        params: { code: "mismatch", namespace: "confirmation", label: srcLabel, targetLabel: tgtLabel }
+      });
+    }
+  };
+}
+
+
+
+
+exports.requiredWhen = requiredWhen; exports.sameAs = sameAs;

package/dist/chunk-ISY3F7TI.cjs

@@ -0,0 +1,239 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/locales/en.json
+var lang = "en";
+var validation = {
+  labels: {
+    email: "Email",
+    personName: "Name",
+    businessName: "Business Name",
+    password: "Password",
+    passwordConfirmation: "Password Confirmation",
+    phone: "Phone",
+    website: "Website",
+    url: "URL",
+    username: "Username",
+    slug: "Slug",
+    postalCode: "Postal Code",
+    licenseKey: "License Key",
+    uuid: "UUID",
+    jwt: "JWT",
+    dateTime: "Date/Time",
+    token: "Token",
+    text: "Text",
+    country: "Country",
+    currency: "Currency",
+    color: "Color",
+    creditCard: "Credit Card",
+    iban: "IBAN",
+    vatNumber: "VAT Number",
+    macAddress: "MAC Address",
+    ipAddress: "IP Address",
+    string: "Value"
+  },
+  messages: {
+    base: {
+      required: "{{label}} is required",
+      min: "{{label}} must be at least {{minimum}} characters",
+      max: "{{label}} must be at most {{maximum}} characters",
+      type: "{{label}} must be a {{expected}}",
+      format: "{{label}} is not valid"
+    },
+    email: {
+      invalid: "{{label}} is not a valid email address",
+      disposableBlocked: "{{label}} must not use a disposable email provider",
+      plusAliasBlocked: "{{label}} must not use plus aliases",
+      domainBlocked: "Email domain '{{domain}}' is not allowed",
+      domainNotAllowed: "Email domain '{{domain}}' is not in the allowed list",
+      subdomainNotAllowed: "Subdomain email addresses are not allowed",
+      custom: "{{label}} failed custom validation"
+    },
+    personName: {
+      invalid: "{{label}} is not a valid name",
+      maxWords: "{{label}} must have at most {{maximum}} words",
+      boundary: "{{label}} must start and end with a letter",
+      maxConsecutive: "{{label}} must not repeat the same character more than {{maximum}} times",
+      custom: "{{label}} failed custom validation"
+    },
+    businessName: {
+      invalid: "{{label}} is not a valid business name",
+      boundary: "{{label}} must start and end with an alphanumeric character",
+      maxConsecutive: "{{label}} must not repeat the same character more than {{maximum}} times",
+      custom: "{{label}} failed custom validation"
+    },
+    password: {
+      minUppercase: "{{label}} must have at least {{minimum}} uppercase characters",
+      minLowercase: "{{label}} must have at least {{minimum}} lowercase characters",
+      minDigits: "{{label}} must have at least {{minimum}} digits",
+      minSpecial: "{{label}} must have at least {{minimum}} special characters",
+      maxUppercase: "{{label}} must have at most {{maximum}} uppercase characters",
+      maxLowercase: "{{label}} must have at most {{maximum}} lowercase characters",
+      maxDigits: "{{label}} must have at most {{maximum}} digits",
+      maxSpecial: "{{label}} must have at most {{maximum}} special characters",
+      maxConsecutive: "{{label}} must not have more than {{maximum}} consecutive identical characters",
+      commonBlocked: "{{label}} is too common",
+      custom: "{{label}} failed custom validation"
+    },
+    confirmation: {
+      mismatch: "{{label}} must match {{targetLabel}}",
+      custom: "{{label}} failed custom validation"
+    },
+    phone: {
+      invalid: "{{label}} is not a valid phone number",
+      requireMobile: "{{label}} must be a mobile phone number",
+      countryCodeRequired: "{{label}} must include a country code prefix",
+      countryBlocked: "Phone numbers from '{{country}}' are not allowed",
+      countryNotAllowed: "Phone numbers from '{{country}}' are not in the allowed list",
+      custom: "{{label}} failed custom validation"
+    },
+    website: {
+      invalid: "{{label}} is not a valid website URL",
+      httpsRequired: "{{label}} must use HTTPS",
+      wwwRequired: "{{label}} must include www prefix",
+      pathNotAllowed: "{{label}} must not contain URL paths",
+      queryNotAllowed: "{{label}} must not contain query strings",
+      domainBlocked: "Domain '{{domain}}' is not allowed",
+      domainNotAllowed: "Domain '{{domain}}' is not in the allowed list",
+      subdomainNotAllowed: "Subdomain URLs are not allowed",
+      custom: "{{label}} failed custom validation"
+    },
+    url: {
+      invalid: "{{label}} is not a valid URL",
+      protocolNotAllowed: "Protocol '{{protocol}}' is not allowed",
+      tldRequired: "{{label}} must include a top-level domain",
+      queryNotAllowed: "{{label}} must not contain query strings",
+      authNotAllowed: "{{label}} must not contain credentials",
+      domainBlocked: "Domain '{{domain}}' is not allowed",
+      domainNotAllowed: "Domain '{{domain}}' is not in the allowed list",
+      custom: "{{label}} failed custom validation"
+    },
+    username: {
+      invalid: "{{label}} is not a valid username",
+      reservedBlocked: "The username '{{value}}' is reserved",
+      boundary: "{{label}} must start and end with an alphanumeric character",
+      maxConsecutive: "{{label}} must not repeat the same character more than {{maximum}} times",
+      custom: "{{label}} failed custom validation"
+    },
+    slug: {
+      invalid: "{{label}} is not a valid slug",
+      custom: "{{label}} failed custom validation"
+    },
+    postalCode: {
+      invalid: "{{label}} is not a valid postal code",
+      custom: "{{label}} failed custom validation"
+    },
+    licenseKey: {
+      invalid: "{{label}} is not a valid license key",
+      custom: "{{label}} failed custom validation"
+    },
+    uuid: {
+      invalid: "{{label}} is not a valid UUID",
+      custom: "{{label}} failed custom validation"
+    },
+    jwt: {
+      invalid: "{{label}} is not a valid JWT",
+      expiryRequired: "{{label}} must have an expiration claim",
+      expired: "{{label}} has expired",
+      notYetValid: "{{label}} is not yet valid",
+      missingClaim: "Required claim '{{claim}}' is missing",
+      algorithmNotAllowed: "Algorithm '{{algorithm}}' is not allowed",
+      custom: "{{label}} failed custom validation"
+    },
+    dateTime: {
+      invalid: "{{label}} is not a valid date",
+      tooEarly: "{{label}} must be after {{minimum}}",
+      tooLate: "{{label}} must be before {{maximum}}",
+      noFuture: "{{label}} must not be in the future",
+      noPast: "{{label}} must not be in the past",
+      custom: "{{label}} failed custom validation"
+    },
+    token: {
+      invalid: "{{label}} is not a valid {{type}} token",
+      custom: "{{label}} failed custom validation"
+    },
+    text: {
+      invalid: "{{label}} is not valid text",
+      noEmails: "{{label}} must not contain email addresses",
+      noUrls: "{{label}} must not contain URLs",
+      noPhoneNumbers: "{{label}} must not contain phone numbers",
+      noHtml: "{{label}} must not contain HTML",
+      minWords: "{{label}} must have at least {{minimum}} words",
+      maxWords: "{{label}} must have at most {{maximum}} words",
+      maxConsecutive: "{{label}} must not repeat the same character more than {{maximum}} times",
+      custom: "{{label}} failed custom validation"
+    },
+    country: {
+      invalid: "{{label}} is not a valid country code",
+      blocked: "Country '{{country}}' is not allowed",
+      notAllowed: "Country '{{country}}' is not in the allowed list",
+      custom: "{{label}} failed custom validation"
+    },
+    currency: {
+      invalid: "{{label}} is not a valid currency code",
+      blocked: "Currency '{{currency}}' is not allowed",
+      notAllowed: "Currency '{{currency}}' is not in the allowed list",
+      custom: "{{label}} failed custom validation"
+    },
+    color: {
+      invalid: "{{label}} is not a valid color",
+      custom: "{{label}} failed custom validation"
+    },
+    creditCard: {
+      invalid: "{{label}} is not a valid credit card number",
+      issuerNotAllowed: "Card issuer '{{issuer}}' is not in the allowed list",
+      issuerBlocked: "Card issuer '{{issuer}}' is not allowed",
+      custom: "{{label}} failed custom validation"
+    },
+    iban: {
+      invalid: "{{label}} is not a valid IBAN",
+      countryBlocked: "IBANs from '{{country}}' are not allowed",
+      countryNotAllowed: "IBANs from '{{country}}' are not in the allowed list",
+      custom: "{{label}} failed custom validation"
+    },
+    vatNumber: {
+      invalid: "{{label}} is not a valid VAT number",
+      custom: "{{label}} failed custom validation"
+    },
+    macAddress: {
+      invalid: "{{label}} is not a valid MAC address",
+      custom: "{{label}} failed custom validation"
+    },
+    ipAddress: {
+      invalid: "{{label}} is not a valid IP address",
+      privateNotAllowed: "{{label}} must not be a private IP address",
+      custom: "{{label}} failed custom validation"
+    },
+    string: {
+      minUppercase: "{{label}} must have at least {{minimum}} uppercase characters",
+      maxUppercase: "{{label}} must have at most {{maximum}} uppercase characters",
+      minLowercase: "{{label}} must have at least {{minimum}} lowercase characters",
+      maxLowercase: "{{label}} must have at most {{maximum}} lowercase characters",
+      minDigits: "{{label}} must have at least {{minimum}} digits",
+      maxDigits: "{{label}} must have at most {{maximum}} digits",
+      minSpecial: "{{label}} must have at least {{minimum}} special characters",
+      maxSpecial: "{{label}} must have at most {{maximum}} special characters",
+      noEmails: "{{label}} must not contain email addresses",
+      noUrls: "{{label}} must not contain URLs",
+      noPhoneNumbers: "{{label}} must not contain phone numbers",
+      noHtml: "{{label}} must not contain HTML",
+      noSpaces: "{{label}} must not contain spaces",
+      onlyAlpha: "{{label}} must contain only letters",
+      onlyNumeric: "{{label}} must contain only digits",
+      onlyAlphanumeric: "{{label}} must contain only letters and digits",
+      onlyAlphaSpaceHyphen: "{{label}} must contain only letters, spaces, and hyphens",
+      onlyAlphanumericSpaceHyphen: "{{label}} must contain only letters, digits, spaces, and hyphens",
+      minWords: "{{label}} must have at least {{minimum}} words",
+      maxWords: "{{label}} must have at most {{maximum}} words",
+      maxConsecutive: "{{label}} must not repeat the same character more than {{maximum}} times",
+      custom: "{{label}} failed custom validation"
+    }
+  }
+};
+var en_default = {
+  lang,
+  validation
+};
+
+
+
+
+
+exports.lang = lang; exports.validation = validation; exports.en_default = en_default;

package/dist/chunk-JEKRBIPN.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/chunk-KTN4NQQL.js

@@ -0,0 +1,33 @@
+// src/loaders/ibanPatterns.ts
+var cache;
+async function loadIbanPatterns() {
+  if (cache !== void 0)
+    return cache;
+  const raw = (await import("./ibanPatterns-BSQUWKLY.js")).default;
+  const map = /* @__PURE__ */ new Map();
+  for (const entry of raw) {
+    map.set(entry.country, {
+      length: entry.length,
+      regex: new RegExp(entry.regex)
+    });
+  }
+  cache = map;
+  return cache;
+}
+function getIbanPatterns() {
+  if (cache === void 0) {
+    throw new Error(
+      "validex: IBAN patterns not loaded. Use parseAsync() or call preloadData() first."
+    );
+  }
+  return cache;
+}
+function clearIbanPatternsCache() {
+  cache = void 0;
+}
+
+export {
+  loadIbanPatterns,
+  getIbanPatterns,
+  clearIbanPatternsCache
+};

package/dist/chunk-LSQNDPFQ.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }// src/checks/phoneDetection.ts
+async function containsPhoneNumber(value) {
+  const { findPhoneNumbersInText } = await Promise.resolve().then(() => _interopRequireWildcard(require("libphonenumber-js")));
+  return findPhoneNumbersInText(value).length > 0;
+}
+
+
+
+exports.containsPhoneNumber = containsPhoneNumber;

package/dist/chunk-NDLUDRZJ.js

@@ -0,0 +1,24 @@
+// src/loaders/postalCodes.ts
+var cache;
+async function loadPostalCodes() {
+  if (cache !== void 0)
+    return cache;
+  const mod = await import("postcode-validator");
+  cache = {
+    postcodeValidator: mod.postcodeValidator,
+    postcodeValidatorExistsForCountry: mod.postcodeValidatorExistsForCountry
+  };
+  return cache;
+}
+function getPostalCodes() {
+  return cache;
+}
+function clearPostalCodesCache() {
+  cache = void 0;
+}
+
+export {
+  loadPostalCodes,
+  getPostalCodes,
+  clearPostalCodesCache
+};