@samline/formatter 1.0.0 → 1.1.0

package/dist/vanilla/index.d.ts

@@ -111,7 +111,93 @@ declare const format: (value: unknown, formatType: FormatType, options?: FormatO
  */
 declare const formatPhone: (value: string, country?: string, delimiter?: string) => string;
 
-declare const regex: {
+/**
+ * # Regex Module
+ *
+ * Validation patterns exposed as public API for form consumers that pair
+ * formatting with validation. Each entry bundles the regex with a ready-to-use
+ * error message so consumers do not have to keep them in sync.
+ *
+ * ## Usage
+ *
+ * **Static (backward compatible):**
+ * ```ts
+ * regex.phone.pattern.test('5512345678')  // true
+ * regex.email.errorMessage                // 'Please enter a valid email address.'
+ * ```
+ *
+ * **Parametric (dynamic):**
+ * ```ts
+ * regex.digits(10).pattern.test('1234567890')  // true
+ * regex.digits(7).pattern.test('1234567')      // true
+ * regex.phone({ length: 10 }).pattern.test('1234567890')
+ * regex.phone({ length: 7 }).pattern.test('1234567')
+ * ```
+ *
+ * **Custom regex:**
+ * ```ts
+ * regex.custom(/^[A-Z]{5}$/, 'Must be 5 uppercase letters').pattern.test('HELLO')
+ * ```
+ *
+ * ## Available Patterns
+ *
+ * | Key | Static | Parametric | Description |
+ * | --- | --- | --- | --- |
+ * | `phone` | ✅ | ✅ `({ length })` | Phone numbers |
+ * | `email` | ✅ | — | Email addresses |
+ * | `rfc` | ✅ | — | Mexican RFC |
+ * | `curp` | ✅ | — | Mexican CURP |
+ * | `cp` | ✅ | — | Mexican postal code (5 digits) |
+ * | `numeral` | ✅ | — | Numbers with separators |
+ * | `onlyNumbers` | ✅ | ✅ `({ length })` | Digits only |
+ * | `digits` | — | ✅ `({ length, min, max })` | Variable digit count |
+ * | `creditCard` | ✅ | ✅ `({ min, max })` | Card numbers |
+ * | `expirationDate` | ✅ | — | MM/YY format |
+ * | `cardCvc` | ✅ | — | 3-4 digit CVC |
+ * | `onlyLetters` | ✅ | — | Letters only |
+ * | `onlyAlphanumeric` | ✅ | — | Letters and numbers |
+ * | `url` | ✅ | ✅ `({ protocol })` | URLs |
+ * | `ipv4` | ✅ | — | IPv4 addresses |
+ * | `ipv6` | ✅ | — | IPv6 addresses |
+ * | `uuid` | ✅ | — | UUID v4 |
+ * | `hexColor` | ✅ | — | Hex color codes |
+ * | `hashtag` | ✅ | — | Social media hashtags |
+ * | `mention` | ✅ | — | Social media mentions |
+ * | `password` | — | ✅ `({ min, max, rules })` | Password strength |
+ * | `custom` | — | ✅ `({ pattern, errorMessage })` | User-defined regex |
+ */
+interface RegexEntry {
+    pattern: RegExp;
+    errorMessage: string;
+}
+interface PhoneParams {
+    length?: number;
+}
+interface DigitsParams {
+    length?: number;
+    min?: number;
+    max?: number;
+}
+interface CreditCardParams {
+    min?: number;
+    max?: number;
+}
+interface UrlParams {
+    protocol?: 'http' | 'https' | 'ftp' | 'all';
+}
+interface PasswordParams {
+    min?: number;
+    max?: number;
+    uppercase?: boolean;
+    lowercase?: boolean;
+    numbers?: boolean;
+    special?: boolean;
+}
+interface CustomParams {
+    pattern: RegExp;
+    errorMessage: string;
+}
+declare const _regex: {
     readonly phone: {
         readonly pattern: RegExp;
         readonly errorMessage: "Please enter a valid 10-digit phone number.";
@@ -124,6 +210,14 @@ declare const regex: {
         readonly pattern: RegExp;
         readonly errorMessage: "Please enter a valid RFC.";
     };
+    readonly curp: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid CURP.";
+    };
+    readonly cp: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid 5-digit postal code.";
+    };
     readonly numeral: {
         readonly pattern: RegExp;
         readonly errorMessage: "Please enter a valid number.";
@@ -134,15 +228,174 @@ declare const regex: {
     };
     readonly creditCard: {
         readonly pattern: RegExp;
-        readonly errorMessage: "Please enter a valid card number.";
+        readonly errorMessage: "Please enter a valid card number (15-16 digits).";
+    };
+    readonly expirationDate: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid expiration date (MM/YY or MM/YYYY).";
+    };
+    readonly cardCvc: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid CVC (3-4 digits).";
+    };
+    readonly onlyLetters: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter only letters.";
+    };
+    readonly onlyAlphanumeric: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter only letters and numbers.";
+    };
+    readonly url: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid URL.";
+    };
+    readonly ipv4: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid IPv4 address.";
+    };
+    readonly ipv6: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid IPv6 address.";
+    };
+    readonly uuid: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid UUID.";
+    };
+    readonly hexColor: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid hex color code (e.g., #FFF or #FFFFFF).";
+    };
+    readonly hashtag: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid hashtag (e.g., #example).";
+    };
+    readonly mention: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid mention (e.g., @username).";
+    };
+    readonly postalCode: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid postal code (e.g., 90210 or 90210-1234).";
+    };
+    readonly time24: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid 24-hour time (HH:MM).";
+    };
+    readonly date: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid date (YYYY-MM-DD).";
+    };
+    readonly slug: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid slug (lowercase, hyphens, no spaces).";
+    };
+    readonly username: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid username (3-20 chars, letters, numbers, _ or -).";
+    };
+    readonly macAddress: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid MAC address (e.g., 00:1B:44:11:3A:B7).";
+    };
+    readonly semver: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid semantic version (e.g., 1.2.3).";
+    };
+    readonly base64: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid Base64 encoded string.";
+    };
+};
+/**
+ * Digits with configurable length.
+ * @example
+ * regex.digits(10).pattern.test('1234567890')     // true
+ * regex.digits({ length: 7 }).pattern.test('1234567') // true
+ * regex.digits({ min: 3, max: 10 }).pattern.test('12345') // true
+ */
+declare function digits(params?: number | DigitsParams): RegexEntry;
+/**
+ * Phone with configurable digit count.
+ *
+ * Also available as static entry: regex.phone.pattern (10 digits)
+ * @example
+ * regex.phone().pattern.test('5512345678')         // true (10 digits)
+ * regex.phone({ length: 7 }).pattern.test('1234567') // true (7 digits)
+ */
+declare function _phoneFn(params?: PhoneParams): RegexEntry;
+/**
+ * Credit card with configurable digit range.
+ *
+ * Also available as static entry: regex.creditCard.pattern (15-16 digits)
+ * @example
+ * regex.creditCard().pattern.test('4111111111111111')      // true (15-16)
+ * regex.creditCard({ min: 13, max: 19 }).pattern.test('1234567890123') // true
+ */
+declare function _creditCardFn(params?: CreditCardParams): RegexEntry;
+/**
+ * URL with configurable protocol.
+ *
+ * Also available as static entry: regex.url.pattern (any protocol)
+ * @example
+ * regex.url().pattern.test('https://example.com')   // true
+ * regex.url({ protocol: 'https' }).pattern.test('https://example.com') // true
+ * regex.url({ protocol: 'https' }).pattern.test('ftp://example.com')  // false
+ */
+declare function _urlFn(params?: UrlParams): RegexEntry;
+/**
+ * Password with configurable strength rules.
+ * @example
+ * regex.password().pattern.test('Passw0rd!')  // true (default: 8+ chars, upper, lower, number)
+ * regex.password({ min: 12, special: true }).pattern.test('MyP@ssw0rd!') // true
+ */
+declare function _passwordFn(params?: PasswordParams): RegexEntry;
+/**
+ * Custom regex provided by the user.
+ * @example
+ * regex.custom(/^[A-Z]{5}$/, 'Must be 5 uppercase letters').pattern.test('HELLO') // true
+ * regex.custom({ pattern: /^\d+$/, errorMessage: 'Numbers only' }).pattern.test('123') // true
+ */
+declare function _customFn(pattern: RegExp, errorMessage?: string): RegexEntry;
+declare function _customFn(params: CustomParams): RegexEntry;
+declare const regex: {
+    readonly digits: typeof digits & RegexEntry;
+    readonly phone: typeof _phoneFn & RegexEntry;
+    readonly creditCard: typeof _creditCardFn & RegexEntry;
+    readonly url: typeof _urlFn & RegexEntry;
+    readonly password: typeof _passwordFn & RegexEntry;
+    readonly custom: typeof _customFn & RegexEntry;
+    readonly email: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid email address.";
+    };
+    readonly rfc: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid RFC.";
+    };
+    readonly curp: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid CURP.";
+    };
+    readonly cp: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid 5-digit postal code.";
+    };
+    readonly numeral: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid number.";
+    };
+    readonly onlyNumbers: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter only numbers.";
     };
     readonly expirationDate: {
         readonly pattern: RegExp;
-        readonly errorMessage: "Please enter a valid expiration date.";
+        readonly errorMessage: "Please enter a valid expiration date (MM/YY or MM/YYYY).";
     };
     readonly cardCvc: {
         readonly pattern: RegExp;
-        readonly errorMessage: "Please enter a valid CVC.";
+        readonly errorMessage: "Please enter a valid CVC (3-4 digits).";
     };
     readonly onlyLetters: {
         readonly pattern: RegExp;
@@ -152,7 +405,64 @@ declare const regex: {
         readonly pattern: RegExp;
         readonly errorMessage: "Please enter only letters and numbers.";
     };
+    readonly ipv4: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid IPv4 address.";
+    };
+    readonly ipv6: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid IPv6 address.";
+    };
+    readonly uuid: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid UUID.";
+    };
+    readonly hexColor: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid hex color code (e.g., #FFF or #FFFFFF).";
+    };
+    readonly hashtag: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid hashtag (e.g., #example).";
+    };
+    readonly mention: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid mention (e.g., @username).";
+    };
+    readonly postalCode: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid postal code (e.g., 90210 or 90210-1234).";
+    };
+    readonly time24: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid 24-hour time (HH:MM).";
+    };
+    readonly date: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid date (YYYY-MM-DD).";
+    };
+    readonly slug: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid slug (lowercase, hyphens, no spaces).";
+    };
+    readonly username: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid username (3-20 chars, letters, numbers, _ or -).";
+    };
+    readonly macAddress: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid MAC address (e.g., 00:1B:44:11:3A:B7).";
+    };
+    readonly semver: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid semantic version (e.g., 1.2.3).";
+    };
+    readonly base64: {
+        readonly pattern: RegExp;
+        readonly errorMessage: "Please enter a valid Base64 encoded string.";
+    };
 };
-type RegexKey = keyof typeof regex;
+type RegexKey = keyof typeof _regex;
+type Regex = typeof regex;
 
-export { FORMAT_TYPES, type FormatOptions, type FormatType, type FormatterResult, type RegexKey, format, formatPhone, formatValue, getDateValueFromRaw, getRawValue, getTimeValueFromRaw, getValueForFormatting, isFormatType, regex, resolveRuntimeOptions, stripPrefixAndSuffix };
+export { FORMAT_TYPES, type FormatOptions, type FormatType, type FormatterResult, type Regex, type RegexEntry, type RegexKey, format, formatPhone, formatValue, getDateValueFromRaw, getRawValue, getTimeValueFromRaw, getValueForFormatting, isFormatType, regex, resolveRuntimeOptions, stripPrefixAndSuffix };

package/dist/vanilla/index.js

@@ -4,9 +4,9 @@ import { AsYouType } from 'libphonenumber-js';
 // src/core/format.ts
 var formatPhone = (value, country = "MX", delimiter = " ") => {
   if (!value) return "";
-  const digits = value.replace(/[^\d+]/g, "");
+  const digits2 = value.replace(/[^\d+]/g, "");
   const formatter = new AsYouType(country);
-  const formatted = formatter.input(digits);
+  const formatted = formatter.input(digits2);
   if (delimiter !== " ") {
     return formatted.replace(/ /g, delimiter);
   }
@@ -41,12 +41,12 @@ var normalizeDateSegment = (segment, unit) => {
   }
 };
 var getDateSegments = (value, pattern) => {
-  const digits = value.replace(/[^\d]/g, "");
+  const digits2 = value.replace(/[^\d]/g, "");
   const segments = {};
   let start = 0;
   for (const unit of pattern) {
     const end = start + getDateUnitLength(unit);
-    const segment = digits.slice(start, end);
+    const segment = digits2.slice(start, end);
     if (segment) {
       segments[getDateSegmentKey(unit)] = segment;
     }
@@ -68,12 +68,12 @@ var getTimeSegmentKey = (unit) => {
   }
 };
 var getTimeSegments = (value, pattern) => {
-  const digits = value.replace(/[^\d]/g, "");
+  const digits2 = value.replace(/[^\d]/g, "");
   const segments = {};
   let start = 0;
   for (const unit of pattern) {
     const end = start + 2;
-    const segment = digits.slice(start, end);
+    const segment = digits2.slice(start, end);
     if (segment) {
       segments[getTimeSegmentKey(unit)] = segment;
     }
@@ -239,21 +239,81 @@ var format = (value, formatType, options = {}) => {
 };
 
 // src/core/regex.ts
-var regex = {
+function createDigits(min, max, errorMsg) {
+  return {
+    pattern: new RegExp(`^\\d{${min},${max}}$`),
+    errorMessage: errorMsg
+  };
+}
+function createPhone(length) {
+  return {
+    pattern: new RegExp(`^(?:\\D*\\d){${length}}\\D*$`),
+    errorMessage: `Please enter a valid ${length}-digit phone number.`
+  };
+}
+function createCreditCard(min, max) {
+  return {
+    pattern: new RegExp(`^(?:\\D*\\d){${min},${max}}\\D*$`),
+    errorMessage: `Please enter a valid card number (${min}-${max} digits).`
+  };
+}
+function createUrl(requireProtocol) {
+  const protocol = requireProtocol === "all" ? "https?" : requireProtocol;
+  return {
+    pattern: new RegExp(`^${protocol}://[^\\s]+$`),
+    errorMessage: `Please enter a valid URL${requireProtocol !== "all" ? ` (${requireProtocol}://...)` : ""}.`
+  };
+}
+function createPassword(params) {
+  const {
+    min = 8,
+    max = 128,
+    uppercase = true,
+    lowercase = true,
+    numbers = true,
+    special = false
+  } = params;
+  let chars = "";
+  if (uppercase) chars += "A-Z";
+  if (lowercase) chars += "a-z";
+  if (numbers) chars += "0-9";
+  if (special) chars += `!@#$%^&*()_+\\-=\\[\\]{}|;:'",.<>?/`;
+  const ruleParts = [];
+  if (uppercase) ruleParts.push("uppercase letter");
+  if (lowercase) ruleParts.push("lowercase letter");
+  if (numbers) ruleParts.push("number");
+  if (special) ruleParts.push("special character");
+  const rulesText = ruleParts.length > 2 ? ruleParts.slice(0, -1).join(", ") + " and " + ruleParts.slice(-1) : ruleParts.join(" and ");
+  return {
+    pattern: new RegExp(`^[${chars}]{${min},${max}}$`),
+    errorMessage: `Password must be ${min}-${max} characters with at least one ${rulesText}.`
+  };
+}
+var _regex = {
   phone: {
-    // 10 digit phone numbers, allowing for optional country code and delimiters
     pattern: /^(?:\D*\d){10}\D*$/,
     errorMessage: "Please enter a valid 10-digit phone number."
   },
   email: {
+    // Simple but effective email validation
     pattern: /^[^\s@]+@[^\s@]+\.[a-zA-Z]{2,}$/,
     errorMessage: "Please enter a valid email address."
   },
   rfc: {
-    // Mexican RFC format (simplified)
+    // Mexican RFC ( Personas Morales y Físicas )
     pattern: /^([A-ZÑ&]{3,4})\d{6}([A-Z0-9]{0,3})$/i,
     errorMessage: "Please enter a valid RFC."
   },
+  curp: {
+    // Mexican CURP (18 characters)
+    pattern: /^[A-Z]{4}\d{6}[A-Z]{6}[0-9A-Z]\d$/i,
+    errorMessage: "Please enter a valid CURP."
+  },
+  cp: {
+    // Mexican postal code (5 digits)
+    pattern: /^\d{5}$/,
+    errorMessage: "Please enter a valid 5-digit postal code."
+  },
   numeral: {
     // Numbers with optional thousand separators and decimal points
     pattern: /\d{1,3}(,\d{3})*(\.\d+)?/,
@@ -266,17 +326,17 @@ var regex = {
   creditCard: {
     // 15 or 16 digits, allowing spaces or delimiters
     pattern: /^(?:\D*\d){15,16}\D*$/,
-    errorMessage: "Please enter a valid card number."
+    errorMessage: "Please enter a valid card number (15-16 digits)."
   },
   expirationDate: {
-    // MM/YY format
-    pattern: /^(0[1-9]|1[0-2])\/\d{2}$/,
-    errorMessage: "Please enter a valid expiration date."
+    // MM/YY or MM/YYYY format
+    pattern: /^(0[1-9]|1[0-2])\/(\d{2}|\d{4})$/,
+    errorMessage: "Please enter a valid expiration date (MM/YY or MM/YYYY)."
   },
   cardCvc: {
     // 3 or 4 digit card security codes
     pattern: /^\d{3,4}$/,
-    errorMessage: "Please enter a valid CVC."
+    errorMessage: "Please enter a valid CVC (3-4 digits)."
   },
   onlyLetters: {
     // Letters only (including accented characters and spaces)
@@ -287,7 +347,142 @@ var regex = {
     // Letters and numbers (including accented characters and spaces)
     pattern: /^[A-Za-zÁÉÍÓÚáéíóúÑñ0-9\s]+$/,
     errorMessage: "Please enter only letters and numbers."
+  },
+  url: {
+    // Accepts http, https, ftp
+    pattern: /^(?:https?|ftp):\/\/[^\s]+$/,
+    errorMessage: "Please enter a valid URL."
+  },
+  ipv4: {
+    // IPv4 addresses (0-255 per octet)
+    pattern: /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,
+    errorMessage: "Please enter a valid IPv4 address."
+  },
+  ipv6: {
+    // IPv6 addresses (simplified)
+    pattern: /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/,
+    errorMessage: "Please enter a valid IPv6 address."
+  },
+  uuid: {
+    // UUID v4
+    pattern: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+    errorMessage: "Please enter a valid UUID."
+  },
+  hexColor: {
+    // Hex color codes (#RGB or #RRGGBB)
+    pattern: /^#(?:[0-9a-fA-F]{3}){1,2}$/,
+    errorMessage: "Please enter a valid hex color code (e.g., #FFF or #FFFFFF)."
+  },
+  hashtag: {
+    // Social media hashtags
+    pattern: /^#[a-zA-Z_][a-zA-Z0-9_]*$/,
+    errorMessage: "Please enter a valid hashtag (e.g., #example)."
+  },
+  mention: {
+    // Social media mentions
+    pattern: /^@[a-zA-Z_][a-zA-Z0-9_]*$/,
+    errorMessage: "Please enter a valid mention (e.g., @username)."
+  },
+  postalCode: {
+    // Generic 5-digit postal code (US-style ZIP / MX CP)
+    pattern: /^\d{5}(?:-\d{4})?$/,
+    errorMessage: "Please enter a valid postal code (e.g., 90210 or 90210-1234)."
+  },
+  time24: {
+    // 24-hour time HH:MM
+    pattern: /^([01]\d|2[0-3]):([0-5]\d)$/,
+    errorMessage: "Please enter a valid 24-hour time (HH:MM)."
+  },
+  date: {
+    // ISO-like date YYYY-MM-DD (loose)
+    pattern: /^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/,
+    errorMessage: "Please enter a valid date (YYYY-MM-DD)."
+  },
+  slug: {
+    // URL slug (lowercase, hyphens, no spaces)
+    pattern: /^[a-z0-9]+(?:-[a-z0-9]+)*$/,
+    errorMessage: "Please enter a valid slug (lowercase, hyphens, no spaces)."
+  },
+  username: {
+    // Username: 3-20 chars, alphanumeric, underscore, hyphen
+    pattern: /^[a-zA-Z0-9_-]{3,20}$/,
+    errorMessage: "Please enter a valid username (3-20 chars, letters, numbers, _ or -)."
+  },
+  macAddress: {
+    // MAC address (colon or hyphen separated)
+    pattern: /^([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}$/,
+    errorMessage: "Please enter a valid MAC address (e.g., 00:1B:44:11:3A:B7)."
+  },
+  semver: {
+    // Semantic version (X.Y.Z with optional -prerelease)
+    pattern: /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[a-zA-Z0-9.-]+)?$/,
+    errorMessage: "Please enter a valid semantic version (e.g., 1.2.3)."
+  },
+  base64: {
+    // Base64 encoded string
+    pattern: /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/,
+    errorMessage: "Please enter a valid Base64 encoded string."
+  }
+};
+function digits(params) {
+  if (typeof params === "number") {
+    return createDigits(params, params, `Please enter exactly ${params} digits.`);
   }
+  const { length, min = 1, max = 20 } = params ?? {};
+  const actualMin = length ?? min;
+  const actualMax = length ?? max;
+  if (actualMin === actualMax) {
+    return createDigits(actualMin, actualMax, `Please enter exactly ${actualMin} digits.`);
+  }
+  return createDigits(actualMin, actualMax, `Please enter ${actualMin}-${actualMax} digits.`);
+}
+function _phoneFn(params) {
+  const length = params?.length ?? 10;
+  return createPhone(length);
+}
+function _creditCardFn(params) {
+  const min = params?.min ?? 15;
+  const max = params?.max ?? 16;
+  return createCreditCard(min, max);
+}
+function _urlFn(params) {
+  const protocol = params?.protocol ?? "all";
+  return createUrl(protocol);
+}
+function _passwordFn(params) {
+  return createPassword(params ?? {});
+}
+function _customFn(arg1, arg2) {
+  if (arg1 instanceof RegExp) {
+    return { pattern: arg1, errorMessage: arg2 ?? "Invalid value." };
+  }
+  return { pattern: arg1.pattern, errorMessage: arg1.errorMessage };
+}
+var phoneFn = _phoneFn;
+phoneFn.pattern = _regex.phone.pattern;
+phoneFn.errorMessage = _regex.phone.errorMessage;
+var creditCardFn = _creditCardFn;
+creditCardFn.pattern = _regex.creditCard.pattern;
+creditCardFn.errorMessage = _regex.creditCard.errorMessage;
+var urlFn = _urlFn;
+urlFn.pattern = _regex.url.pattern;
+urlFn.errorMessage = _regex.url.errorMessage;
+var digitsFn = digits;
+digitsFn.errorMessage = "Please enter a valid number.";
+var passwordFn = _passwordFn;
+passwordFn.errorMessage = "Please enter a valid password.";
+var customFn = _customFn;
+customFn.errorMessage = "Please enter a valid value.";
+var regex = {
+  // Static entries (backward compatible - spread first)
+  ..._regex,
+  // Parametric functions
+  digits: digitsFn,
+  phone: phoneFn,
+  creditCard: creditCardFn,
+  url: urlFn,
+  password: passwordFn,
+  custom: customFn
 };
 
 export { FORMAT_TYPES, format, formatPhone, formatValue, getDateValueFromRaw, getRawValue, getTimeValueFromRaw, getValueForFormatting, isFormatType, regex, resolveRuntimeOptions, stripPrefixAndSuffix };