@oxog/vld 2.0.2 → 2.1.0

package/dist/cjs/locales/lazy.cjs

@@ -1,109 +1,7 @@
 'use strict';
 
-const en = {
-    // String validation messages
-    invalidString: 'Invalid string',
-    stringMin: (min) => `String must be at least ${min} characters`,
-    stringMax: (max) => `String must be at most ${max} characters`,
-    stringLength: (length) => `String must be exactly ${length} characters`,
-    stringEmail: 'Invalid email address',
-    stringUrl: 'Invalid URL',
-    stringUuid: 'Invalid UUID',
-    stringRegex: 'Invalid format',
-    stringStartsWith: (prefix) => `String must start with "${prefix}"`,
-    stringEndsWith: (suffix) => `String must end with "${suffix}"`,
-    stringIncludes: (substring) => `String must include "${substring}"`,
-    stringIp: 'Invalid IP address',
-    stringIpv4: 'Invalid IPv4 address',
-    stringIpv6: 'Invalid IPv6 address',
-    stringEmpty: 'String must not be empty',
-    // Number validation messages
-    invalidNumber: 'Invalid number',
-    numberMin: (min) => `Number must be at least ${min}`,
-    numberMax: (max) => `Number must be at most ${max}`,
-    numberInt: 'Number must be an integer',
-    numberPositive: 'Number must be positive',
-    numberNegative: 'Number must be negative',
-    numberNonnegative: 'Number must be non-negative',
-    numberNonpositive: 'Number must be non-positive',
-    numberFinite: 'Number must be finite',
-    numberSafe: 'Number must be a safe integer',
-    numberMultipleOf: (value) => `Number must be a multiple of ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'Invalid boolean',
-    // Date validation messages
-    invalidDate: 'Invalid date',
-    dateMin: (date) => `Date must be after ${date.toISOString()}`,
-    dateMax: (date) => `Date must be before ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Invalid object',
-    unexpectedKeys: (keys) => `Unexpected keys: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Invalid array',
-    arrayMin: (min) => `Array must have at least ${min} items`,
-    arrayMax: (max) => `Array must have at most ${max} items`,
-    arrayLength: (length) => `Array must have exactly ${length} items`,
-    arrayEmpty: 'Array must not be empty',
-    arrayItem: (index, error) => `Invalid item at index ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Invalid field "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `No union member matched: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Intersection validation failed: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Expected ${expected}, got ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Expected one of [${values.join(', ')}], got ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Expected undefined',
-    neverType: 'Never type cannot be parsed',
-    // New advanced type validation messages
-    invalidBigint: 'Invalid bigint',
-    invalidSymbol: 'Invalid symbol',
-    invalidTuple: 'Invalid tuple',
-    tupleLength: (expected, received) => `Tuple must have exactly ${expected} elements, got ${received}`,
-    invalidRecord: 'Invalid record',
-    invalidSet: 'Invalid set',
-    invalidMap: 'Invalid map',
-    // Transformation and refinement messages
-    transformError: (error) => `Transform failed: ${error}`,
-    refinementError: (error) => `Refinement failed: ${error}`,
-    customValidationError: (error) => `Custom validation failed: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Cannot coerce ${JSON.stringify(value)} to ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Expected ${expected}, got ${received}`,
-    stringBoolExpected: (validValues, received) => `Invalid boolean string. Expected one of: ${validValues}, got "${received}"`,
-    invalidJson: 'Invalid JSON',
-    stringPatternInvalid: 'String does not match the required pattern',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(', ')}`,
-    // Function validation messages
-    invalidFunction: 'Expected a function',
-    // CIDR validation messages
-    stringCidrv4: 'Invalid IPv4 CIDR block',
-    stringCidrv6: 'Invalid IPv6 CIDR block',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Cannot override existing keys: ${keys.join(', ')}. Use extend() if you want to override.`
-};
+var locales_runtime = require('./runtime.cjs');
+require('./en.cjs');
 
 /**
  * VLD Lazy Locale System
@@ -123,44 +21,38 @@ const en = {
  * registerLocale('tr', tr);
  * ```
  */
-// ============================================
-// State
-// ============================================
-let currentLocale = 'en';
-let currentMessages = en;
-const loadedLocales = new Map([['en', en]]);
 const localeLoaders = {
     // Base languages
-    tr: () => Promise.resolve().then(function () { return tr$1; }).then(m => m.tr),
-    es: () => Promise.resolve().then(function () { return es$1; }).then(m => m.es),
-    fr: () => Promise.resolve().then(function () { return fr$1; }).then(m => m.fr),
-    de: () => Promise.resolve().then(function () { return de$1; }).then(m => m.de),
-    it: () => Promise.resolve().then(function () { return it$1; }).then(m => m.it),
-    pt: () => Promise.resolve().then(function () { return pt$1; }).then(m => m.pt),
-    ru: () => Promise.resolve().then(function () { return ru$1; }).then(m => m.ru),
-    ja: () => Promise.resolve().then(function () { return ja$1; }).then(m => m.ja),
-    ko: () => Promise.resolve().then(function () { return ko$1; }).then(m => m.ko),
-    zh: () => Promise.resolve().then(function () { return zh$1; }).then(m => m.zh),
-    ar: () => Promise.resolve().then(function () { return ar$1; }).then(m => m.ar),
-    hi: () => Promise.resolve().then(function () { return hi$1; }).then(m => m.hi),
-    nl: () => Promise.resolve().then(function () { return nl$1; }).then(m => m.nl),
-    pl: () => Promise.resolve().then(function () { return pl$1; }).then(m => m.pl),
+    tr: () => Promise.resolve().then(function () { return require('./tr.cjs'); }).then(m => m.tr),
+    es: () => Promise.resolve().then(function () { return require('./es.cjs'); }).then(m => m.es),
+    fr: () => Promise.resolve().then(function () { return require('./fr.cjs'); }).then(m => m.fr),
+    de: () => Promise.resolve().then(function () { return require('./de.cjs'); }).then(m => m.de),
+    it: () => Promise.resolve().then(function () { return require('./it.cjs'); }).then(m => m.it),
+    pt: () => Promise.resolve().then(function () { return require('./pt.cjs'); }).then(m => m.pt),
+    ru: () => Promise.resolve().then(function () { return require('./ru.cjs'); }).then(m => m.ru),
+    ja: () => Promise.resolve().then(function () { return require('./ja.cjs'); }).then(m => m.ja),
+    ko: () => Promise.resolve().then(function () { return require('./ko.cjs'); }).then(m => m.ko),
+    zh: () => Promise.resolve().then(function () { return require('./zh.cjs'); }).then(m => m.zh),
+    ar: () => Promise.resolve().then(function () { return require('./ar.cjs'); }).then(m => m.ar),
+    hi: () => Promise.resolve().then(function () { return require('./hi.cjs'); }).then(m => m.hi),
+    nl: () => Promise.resolve().then(function () { return require('./nl.cjs'); }).then(m => m.nl),
+    pl: () => Promise.resolve().then(function () { return require('./pl.cjs'); }).then(m => m.pl),
     // Major European Languages
-    da: () => Promise.resolve().then(function () { return da$1; }).then(m => m.da),
-    sv: () => Promise.resolve().then(function () { return sv$1; }).then(m => m.sv),
-    no: () => Promise.resolve().then(function () { return no$1; }).then(m => m.no),
-    fi: () => Promise.resolve().then(function () { return fi$1; }).then(m => m.fi),
+    da: () => Promise.resolve().then(function () { return require('./da.cjs'); }).then(m => m.da),
+    sv: () => Promise.resolve().then(function () { return require('./sv.cjs'); }).then(m => m.sv),
+    no: () => Promise.resolve().then(function () { return require('./no.cjs'); }).then(m => m.no),
+    fi: () => Promise.resolve().then(function () { return require('./fi.cjs'); }).then(m => m.fi),
     // Major Asian Languages
-    th: () => Promise.resolve().then(function () { return th$1; }).then(m => m.th),
-    vi: () => Promise.resolve().then(function () { return vi$1; }).then(m => m.vi),
-    id: () => Promise.resolve().then(function () { return id$1; }).then(m => m.id),
-    bn: () => Promise.resolve().then(function () { return bn$1; }).then(m => m.bn),
+    th: () => Promise.resolve().then(function () { return require('./th.cjs'); }).then(m => m.th),
+    vi: () => Promise.resolve().then(function () { return require('./vi.cjs'); }).then(m => m.vi),
+    id: () => Promise.resolve().then(function () { return require('./id.cjs'); }).then(m => m.id),
+    bn: () => Promise.resolve().then(function () { return require('./bn.cjs'); }).then(m => m.bn),
     // African Languages
-    sw: () => Promise.resolve().then(function () { return sw$1; }).then(m => m.sw),
-    af: () => Promise.resolve().then(function () { return af$1; }).then(m => m.af),
+    sw: () => Promise.resolve().then(function () { return require('./sw.cjs'); }).then(m => m.sw),
+    af: () => Promise.resolve().then(function () { return require('./af.cjs'); }).then(m => m.af),
     // American Languages
-    'pt-BR': () => Promise.resolve().then(function () { return ptBR$1; }).then(m => m.ptBR),
-    'es-MX': () => Promise.resolve().then(function () { return esMX$1; }).then(m => m.esMX),
+    'pt-BR': () => Promise.resolve().then(function () { return require('./pt-BR.cjs'); }).then(m => m.ptBR),
+    'es-MX': () => Promise.resolve().then(function () { return require('./es-MX.cjs'); }).then(m => m.esMX),
 };
 // ============================================
 // Public API
@@ -180,15 +72,13 @@ const localeLoaders = {
  */
 async function setLocaleAsync(locale) {
     // If already loaded, just switch
-    if (loadedLocales.has(locale)) {
-        currentLocale = locale;
-        currentMessages = loadedLocales.get(locale);
+    if (locales_runtime.isLocaleLoaded(locale)) {
+        locales_runtime.setLocale(locale);
         return;
     }
     // If English, it's already bundled
     if (locale === 'en') {
-        currentLocale = 'en';
-        currentMessages = en;
+        locales_runtime.setLocale('en');
         return;
     }
     // Try to load dynamically
@@ -199,9 +89,8 @@ async function setLocaleAsync(locale) {
     }
     try {
         const messages = await loader();
-        loadedLocales.set(locale, messages);
-        currentLocale = locale;
-        currentMessages = messages;
+        locales_runtime.registerLocale(locale, messages);
+        locales_runtime.setLocale(locale);
     }
     catch (error) {
         console.warn(`Failed to load locale "${locale}". Falling back to English.`, error);
@@ -223,9 +112,8 @@ async function setLocaleAsync(locale) {
  * ```
  */
 function setLocale(locale) {
-    if (loadedLocales.has(locale)) {
-        currentLocale = locale;
-        currentMessages = loadedLocales.get(locale);
+    if (locales_runtime.isLocaleLoaded(locale)) {
+        locales_runtime.setLocale(locale);
         return;
     }
     throw new Error(`Locale "${locale}" not preloaded. Use setLocaleAsync() for lazy loading ` +
@@ -245,39 +133,6 @@ function setLocale(locale) {
  * registerLocale('tr', tr);
  * ```
  */
-function registerLocale(locale, messages) {
-    loadedLocales.set(locale, messages);
-}
-/**
- * Get the current locale code
- */
-function getLocale() {
-    return currentLocale;
-}
-/**
- * Get messages for the current locale
- * This is used internally by validators to get error messages.
- */
-function getMessages() {
-    return currentMessages;
-}
-/**
- * Get messages for a specific locale
- * Returns English fallback if locale is not loaded.
- *
- * @param locale - The locale to get messages for
- */
-function getMessagesForLocale(locale) {
-    return loadedLocales.get(locale) || en;
-}
-/**
- * Check if a locale is loaded and available for synchronous use
- *
- * @param locale - The locale to check
- */
-function isLocaleLoaded(locale) {
-    return loadedLocales.has(locale);
-}
 /**
  * Check if a locale is supported (can be lazy loaded)
  *
@@ -306,12 +161,12 @@ function getSupportedLocales() {
  */
 async function preloadLocales(locales) {
     await Promise.all(locales.map(async (locale) => {
-        if (!loadedLocales.has(locale) && locale !== 'en') {
+        if (!locales_runtime.isLocaleLoaded(locale) && locale !== 'en') {
             const loader = localeLoaders[locale];
             if (loader) {
                 try {
                     const messages = await loader();
-                    loadedLocales.set(locale, messages);
+                    locales_runtime.registerLocale(locale, messages);
                 }
                 catch {
                     // Silently ignore preload failures
@@ -321,2849 +176,13 @@ async function preloadLocales(locales) {
     }));
 }
 
-const tr = {
-    // String validation messages
-    invalidString: 'Geçersiz metin',
-    stringMin: (min) => `Metin en az ${min} karakter olmalı`,
-    stringMax: (max) => `Metin en fazla ${max} karakter olmalı`,
-    stringLength: (length) => `Metin tam olarak ${length} karakter olmalı`,
-    stringEmail: 'Geçersiz e-posta adresi',
-    stringUrl: 'Geçersiz URL',
-    stringUuid: 'Geçersiz UUID',
-    stringRegex: 'Geçersiz format',
-    stringStartsWith: (prefix) => `Metin "${prefix}" ile başlamalı`,
-    stringEndsWith: (suffix) => `Metin "${suffix}" ile bitmeli`,
-    stringIncludes: (substring) => `Metin "${substring}" içermeli`,
-    stringIp: 'Geçersiz IP adresi',
-    stringIpv4: 'Geçersiz IPv4 adresi',
-    stringIpv6: 'Geçersiz IPv6 adresi',
-    stringEmpty: 'Metin boş olmamalı',
-    // Number validation messages
-    invalidNumber: 'Geçersiz sayı',
-    numberMin: (min) => `Sayı en az ${min} olmalı`,
-    numberMax: (max) => `Sayı en fazla ${max} olmalı`,
-    numberInt: 'Sayı tam sayı olmalı',
-    numberPositive: 'Sayı pozitif olmalı',
-    numberNegative: 'Sayı negatif olmalı',
-    numberNonnegative: 'Sayı negatif olmamalı',
-    numberNonpositive: 'Sayı pozitif olmamalı',
-    numberFinite: 'Sayı sonlu olmalı',
-    numberSafe: 'Sayı güvenli tam sayı olmalı',
-    numberMultipleOf: (value) => `Sayı ${value}'nin katı olmalı`,
-    // Boolean validation messages
-    invalidBoolean: 'Geçersiz boolean',
-    // Date validation messages
-    invalidDate: 'Geçersiz tarih',
-    dateMin: (date) => `Tarih ${date.toISOString()} sonrasında olmalı`,
-    dateMax: (date) => `Tarih ${date.toISOString()} öncesinde olmalı`,
-    // Object validation messages
-    invalidObject: 'Geçersiz nesne',
-    unexpectedKeys: (keys) => `Beklenmeyen anahtarlar: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Geçersiz dizi',
-    arrayMin: (min) => `Dizi en az ${min} eleman içermeli`,
-    arrayMax: (max) => `Dizi en fazla ${max} eleman içermeli`,
-    arrayLength: (length) => `Dizi tam olarak ${length} eleman içermeli`,
-    arrayEmpty: 'Dizi boş olmamalı',
-    arrayItem: (index, error) => `${index} indeksindeki eleman geçersiz: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `"${field}" alanı geçersiz: ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Hiçbir union üyesi eşleşmedi: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Intersection doğrulaması başarısız: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `${expected} beklendi, ${received} alındı`,
-    // Enum validation messages
-    enumExpected: (values, received) => `[${values.join(', ')}] değerlerinden biri beklendi, ${received} alındı`,
-    // Special type validation messages
-    expectedUndefined: 'Undefined beklendi',
-    neverType: 'Never tipi parse edilemez',
-    // New advanced type validation messages
-    invalidBigint: 'Geçersiz bigint',
-    invalidSymbol: 'Geçersiz symbol',
-    invalidTuple: 'Geçersiz tuple',
-    tupleLength: (expected, received) => `Tuple tam olarak ${expected} elemana sahip olmalı, ${received} aldı`,
-    invalidRecord: 'Geçersiz record',
-    invalidSet: 'Geçersiz set',
-    invalidMap: 'Geçersiz map',
-    // Transformation and refinement messages
-    transformError: (error) => `Dönüştürme başarısız: ${error}`,
-    refinementError: (error) => `Doğrulama başarısız: ${error}`,
-    customValidationError: (error) => `Özel doğrulama başarısız: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `${JSON.stringify(value)} değeri ${type} tipine dönüştürülemez`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Beklenen: ${expected}, alınan: ${received}`,
-    stringBoolExpected: (validValues, received) => `Geçersiz boolean string. Şunlardan biri olmalı: ${validValues}, alınan: "${received}"`,
-    invalidJson: 'Geçersiz JSON',
-    stringPatternInvalid: 'Dize gerekli kalıpla eşleşmiyor',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'Bir fonksiyon bekleniyor',
-    // CIDR validation messages
-    stringCidrv4: 'Geçersiz IPv4 CIDR bloğu',
-    stringCidrv6: 'Geçersiz IPv6 CIDR bloğu',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Mevcut anahtarlar üzerine yazılamaz: ${keys.join(', ')}. Üzerine yazmak istiyorsanız extend() kullanın.`
-};
-
-var tr$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    tr: tr
-});
-
-const es = {
-    invalidString: 'Cadena inválida',
-    stringMin: (min) => `La cadena debe tener al menos ${min} caracteres`,
-    stringMax: (max) => `La cadena debe tener como máximo ${max} caracteres`,
-    stringLength: (length) => `La cadena debe tener exactamente ${length} caracteres`,
-    stringEmail: 'Dirección de correo inválida',
-    stringUrl: 'URL inválida',
-    stringUuid: 'UUID inválido',
-    stringRegex: 'Formato inválido',
-    stringStartsWith: (prefix) => `La cadena debe comenzar con "${prefix}"`,
-    stringEndsWith: (suffix) => `La cadena debe terminar con "${suffix}"`,
-    stringIncludes: (substring) => `La cadena debe incluir "${substring}"`,
-    stringIp: 'Dirección IP inválida',
-    stringIpv4: 'Dirección IPv4 inválida',
-    stringIpv6: 'Dirección IPv6 inválida',
-    stringEmpty: 'La cadena no debe estar vacía',
-    invalidNumber: 'Número inválido',
-    numberMin: (min) => `El número debe ser al menos ${min}`,
-    numberMax: (max) => `El número debe ser como máximo ${max}`,
-    numberInt: 'El número debe ser un entero',
-    numberPositive: 'El número debe ser positivo',
-    numberNegative: 'El número debe ser negativo',
-    numberNonnegative: 'El número debe ser no negativo',
-    numberNonpositive: 'El número debe ser no positivo',
-    numberFinite: 'El número debe ser finito',
-    numberSafe: 'El número debe ser un entero seguro',
-    numberMultipleOf: (value) => `El número debe ser múltiplo de ${value}`,
-    invalidBoolean: 'Boolean inválido',
-    invalidDate: 'Fecha inválida',
-    dateMin: (date) => `La fecha debe ser posterior a ${date.toISOString()}`,
-    dateMax: (date) => `La fecha debe ser anterior a ${date.toISOString()}`,
-    invalidObject: 'Objeto inválido',
-    unexpectedKeys: (keys) => `Claves inesperadas: ${keys.join(', ')}`,
-    invalidArray: 'Array inválido',
-    arrayMin: (min) => `El array debe tener al menos ${min} elementos`,
-    arrayMax: (max) => `El array debe tener como máximo ${max} elementos`,
-    arrayLength: (length) => `El array debe tener exactamente ${length} elementos`,
-    arrayEmpty: 'El array no debe estar vacío',
-    arrayItem: (index, error) => `Elemento inválido en índice ${index}: ${error}`,
-    objectField: (field, error) => `Campo inválido "${field}": ${error}`,
-    unionNoMatch: (errors) => `Ningún miembro de la unión coincidió: ${errors.join(', ')}`,
-    intersectionError: (error) => `Error de validación de intersección: ${error}`,
-    literalExpected: (expected, received) => `Se esperaba ${expected}, se recibió ${received}`,
-    enumExpected: (values, received) => `Se esperaba uno de [${values.join(', ')}], se recibió ${received}`,
-    expectedUndefined: 'Se esperaba undefined',
-    neverType: 'El tipo never no puede ser parseado',
-    // New advanced type validation messages
-    invalidBigint: 'Bigint inválido',
-    invalidSymbol: 'Símbolo inválido',
-    invalidTuple: 'Tupla inválida',
-    tupleLength: (expected, received) => `La tupla debe tener exactamente ${expected} elementos, se recibieron ${received}`,
-    invalidRecord: 'Registro inválido',
-    invalidSet: 'Set inválido',
-    invalidMap: 'Map inválido',
-    // Transformation and refinement messages
-    transformError: (error) => `Transformación fallida: ${error}`,
-    refinementError: (error) => `Refinamiento fallido: ${error}`,
-    customValidationError: (error) => `Validación personalizada falló: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `No se puede coaccionar ${JSON.stringify(value)} a ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Se esperaba ${expected}, se obtuvo ${received}`,
-    stringBoolExpected: (validValues, received) => `Cadena booleana no válida. Se esperaba uno de: ${validValues}, se obtuvo "${received}"`,
-    invalidJson: 'JSON no válido',
-    stringPatternInvalid: 'La cadena no coincide con el patrón requerido',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'Se esperaba una función',
-    // CIDR validation messages
-    stringCidrv4: 'Bloque CIDR IPv4 inválido',
-    stringCidrv6: 'Bloque CIDR IPv6 inválido',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `No se pueden sobrescribir las claves existentes: ${keys.join(', ')}. Use extend() si desea sobrescribir.`
-};
-
-var es$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    es: es
-});
-
-const fr = {
-    invalidString: 'Chaîne invalide',
-    stringMin: (min) => `La chaîne doit contenir au moins ${min} caractères`,
-    stringMax: (max) => `La chaîne doit contenir au maximum ${max} caractères`,
-    stringLength: (length) => `La chaîne doit contenir exactement ${length} caractères`,
-    stringEmail: 'Adresse e-mail invalide',
-    stringUrl: 'URL invalide',
-    stringUuid: 'UUID invalide',
-    stringRegex: 'Format invalide',
-    stringStartsWith: (prefix) => `La chaîne doit commencer par "${prefix}"`,
-    stringEndsWith: (suffix) => `La chaîne doit se terminer par "${suffix}"`,
-    stringIncludes: (substring) => `La chaîne doit contenir "${substring}"`,
-    stringIp: 'Adresse IP invalide',
-    stringIpv4: 'Adresse IPv4 invalide',
-    stringIpv6: 'Adresse IPv6 invalide',
-    stringEmpty: 'La chaîne ne doit pas être vide',
-    invalidNumber: 'Nombre invalide',
-    numberMin: (min) => `Le nombre doit être d'au moins ${min}`,
-    numberMax: (max) => `Le nombre doit être d'au maximum ${max}`,
-    numberInt: 'Le nombre doit être un entier',
-    numberPositive: 'Le nombre doit être positif',
-    numberNegative: 'Le nombre doit être négatif',
-    numberNonnegative: 'Le nombre ne doit pas être négatif',
-    numberNonpositive: 'Le nombre ne doit pas être positif',
-    numberFinite: 'Le nombre doit être fini',
-    numberSafe: 'Le nombre doit être un entier sûr',
-    numberMultipleOf: (value) => `Le nombre doit être un multiple de ${value}`,
-    invalidBoolean: 'Boolean invalide',
-    invalidDate: 'Date invalide',
-    dateMin: (date) => `La date doit être postérieure à ${date.toISOString()}`,
-    dateMax: (date) => `La date doit être antérieure à ${date.toISOString()}`,
-    invalidObject: 'Objet invalide',
-    unexpectedKeys: (keys) => `Clés inattendues: ${keys.join(', ')}`,
-    invalidArray: 'Tableau invalide',
-    arrayMin: (min) => `Le tableau doit contenir au moins ${min} éléments`,
-    arrayMax: (max) => `Le tableau doit contenir au maximum ${max} éléments`,
-    arrayLength: (length) => `Le tableau doit contenir exactement ${length} éléments`,
-    arrayEmpty: 'Le tableau ne doit pas être vide',
-    arrayItem: (index, error) => `Élément invalide à l'index ${index}: ${error}`,
-    objectField: (field, error) => `Champ invalide "${field}": ${error}`,
-    unionNoMatch: (errors) => `Aucun membre de l'union n'a correspondu: ${errors.join(', ')}`,
-    intersectionError: (error) => `Échec de validation d'intersection: ${error}`,
-    literalExpected: (expected, received) => `Attendu ${expected}, reçu ${received}`,
-    enumExpected: (values, received) => `Attendu un de [${values.join(', ')}], reçu ${received}`,
-    expectedUndefined: 'Undefined attendu',
-    neverType: 'Le type never ne peut pas être analysé',
-    // New advanced type validation messages
-    invalidBigint: 'Bigint invalide',
-    invalidSymbol: 'Symbole invalide',
-    invalidTuple: 'Tuple invalide',
-    tupleLength: (expected, received) => `Le tuple doit contenir exactement ${expected} éléments, ${received} reçus`,
-    invalidRecord: 'Enregistrement invalide',
-    invalidSet: 'Set invalide',
-    invalidMap: 'Map invalide',
-    // Transformation and refinement messages
-    transformError: (error) => `Transformation échouée : ${error}`,
-    refinementError: (error) => `Raffinement échoué : ${error}`,
-    customValidationError: (error) => `Validation personnalisée échouée : ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Impossible de convertir ${JSON.stringify(value)} en ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Attendu: ${expected}, reçu: ${received}`,
-    stringBoolExpected: (validValues, received) => `Chaîne booléenne invalide. Attendu: l'un de ${validValues}, reçu: "${received}"`,
-    invalidJson: 'JSON invalide',
-    stringPatternInvalid: 'La chaîne ne correspond pas au modèle requis',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'Une fonction est attendue',
-    // CIDR validation messages
-    stringCidrv4: 'Bloc CIDR IPv4 invalide',
-    stringCidrv6: 'Bloc CIDR IPv6 invalide',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Impossible de remplacer les clés existantes: ${keys.join(', ')}. Utilisez extend() pour remplacer.`
-};
-
-var fr$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    fr: fr
-});
-
-const de = {
-    // String validation messages
-    invalidString: 'Ungültiger String',
-    stringMin: (min) => `String muss mindestens ${min} Zeichen lang sein`,
-    stringMax: (max) => `String darf höchstens ${max} Zeichen lang sein`,
-    stringLength: (length) => `String muss genau ${length} Zeichen lang sein`,
-    stringEmail: 'Ungültige E-Mail-Adresse',
-    stringUrl: 'Ungültige URL',
-    stringUuid: 'Ungültige UUID',
-    stringRegex: 'Ungültiges Format',
-    stringStartsWith: (prefix) => `String muss mit "${prefix}" beginnen`,
-    stringEndsWith: (suffix) => `String muss mit "${suffix}" enden`,
-    stringIncludes: (substring) => `String muss "${substring}" enthalten`,
-    stringIp: 'Ungültige IP-Adresse',
-    stringIpv4: 'Ungültige IPv4-Adresse',
-    stringIpv6: 'Ungültige IPv6-Adresse',
-    stringEmpty: 'String darf nicht leer sein',
-    // Number validation messages
-    invalidNumber: 'Ungültige Nummer',
-    numberMin: (min) => `Nummer muss mindestens ${min} betragen`,
-    numberMax: (max) => `Nummer darf höchstens ${max} betragen`,
-    numberInt: 'Nummer muss eine ganze Zahl sein',
-    numberPositive: 'Nummer muss positiv sein',
-    numberNegative: 'Nummer muss negativ sein',
-    numberNonnegative: 'Nummer darf nicht negativ sein',
-    numberNonpositive: 'Nummer darf nicht positiv sein',
-    numberFinite: 'Nummer muss endlich sein',
-    numberSafe: 'Nummer muss eine sichere ganze Zahl sein',
-    numberMultipleOf: (value) => `Nummer muss ein Vielfaches von ${value} sein`,
-    // Boolean validation messages
-    invalidBoolean: 'Ungültiger Boolean-Wert',
-    // Date validation messages
-    invalidDate: 'Ungültiges Datum',
-    dateMin: (date) => `Datum muss nach ${date.toISOString()} liegen`,
-    dateMax: (date) => `Datum muss vor ${date.toISOString()} liegen`,
-    // Object validation messages
-    invalidObject: 'Ungültiges Objekt',
-    unexpectedKeys: (keys) => `Unerwartete Schlüssel: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Ungültiges Array',
-    arrayMin: (min) => `Array muss mindestens ${min} Elemente haben`,
-    arrayMax: (max) => `Array darf höchstens ${max} Elemente haben`,
-    arrayLength: (length) => `Array muss genau ${length} Elemente haben`,
-    arrayEmpty: 'Array darf nicht leer sein',
-    arrayItem: (index, error) => `Ungültiges Element bei Index ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Ungültiges Feld "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Kein Union-Mitglied passte: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Intersection-Validierung fehlgeschlagen: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Erwartet ${expected}, erhalten ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Erwartet einer von [${values.join(', ')}], erhalten ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Undefined erwartet',
-    neverType: 'Never-Typ kann nicht geparst werden',
-    // New advanced type validation messages
-    invalidBigint: 'Ungültiger Bigint',
-    invalidSymbol: 'Ungültiges Symbol',
-    invalidTuple: 'Ungültiges Tupel',
-    tupleLength: (expected, received) => `Tupel muss genau ${expected} Elemente haben, ${received} erhalten`,
-    invalidRecord: 'Ungültiger Datensatz',
-    invalidSet: 'Ungültiges Set',
-    invalidMap: 'Ungültige Map',
-    // Transformation and refinement messages
-    transformError: (error) => `Transformation fehlgeschlagen: ${error}`,
-    refinementError: (error) => `Verfeinerung fehlgeschlagen: ${error}`,
-    customValidationError: (error) => `Benutzerdefinierte Validierung fehlgeschlagen: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Kann ${JSON.stringify(value)} nicht zu ${type} konvertieren`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `${expected} erwartet, ${received} erhalten`,
-    stringBoolExpected: (validValues, received) => `Ungültige Boolean-Zeichenkette. Eines von erwartet: ${validValues}, erhalten: "${received}"`,
-    invalidJson: 'Ungültiges JSON',
-    stringPatternInvalid: 'Zeichenfolge entspricht nicht dem erforderlichen Muster',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'Eine Funktion erwartet',
-    // CIDR validation messages
-    stringCidrv4: 'Ungültiger IPv4 CIDR-Block',
-    stringCidrv6: 'Ungültiger IPv6 CIDR-Block',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Bestehende Schlüssel können nicht überschrieben werden: ${keys.join(', ')}. Verwenden Sie extend() zum Überschreiben.`
-};
-
-var de$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    de: de
-});
-
-const it = {
-    // String validation messages
-    invalidString: 'Stringa non valida',
-    stringMin: (min) => `La stringa deve avere almeno ${min} caratteri`,
-    stringMax: (max) => `La stringa non può avere più di ${max} caratteri`,
-    stringLength: (length) => `La stringa deve avere esattamente ${length} caratteri`,
-    stringEmail: 'Indirizzo email non valido',
-    stringUrl: 'URL non valido',
-    stringUuid: 'UUID non valido',
-    stringRegex: 'Formato non valido',
-    stringStartsWith: (prefix) => `La stringa deve iniziare con "${prefix}"`,
-    stringEndsWith: (suffix) => `La stringa deve finire con "${suffix}"`,
-    stringIncludes: (substring) => `La stringa deve contenere "${substring}"`,
-    stringIp: 'Indirizzo IP non valido',
-    stringIpv4: 'Indirizzo IPv4 non valido',
-    stringIpv6: 'Indirizzo IPv6 non valido',
-    stringEmpty: 'La stringa non può essere vuota',
-    // Number validation messages
-    invalidNumber: 'Numero non valido',
-    numberMin: (min) => `Il numero deve essere almeno ${min}`,
-    numberMax: (max) => `Il numero non può essere maggiore di ${max}`,
-    numberInt: 'Il numero deve essere intero',
-    numberPositive: 'Il numero deve essere positivo',
-    numberNegative: 'Il numero deve essere negativo',
-    numberNonnegative: 'Il numero non può essere negativo',
-    numberNonpositive: 'Il numero non può essere positivo',
-    numberFinite: 'Il numero deve essere finito',
-    numberSafe: 'Il numero deve essere un intero sicuro',
-    numberMultipleOf: (value) => `Il numero deve essere multiplo di ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'Valore booleano non valido',
-    // Date validation messages
-    invalidDate: 'Data non valida',
-    dateMin: (date) => `La data deve essere dopo ${date.toISOString()}`,
-    dateMax: (date) => `La data deve essere prima di ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Oggetto non valido',
-    unexpectedKeys: (keys) => `Chiavi impreviste: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Array non valido',
-    arrayMin: (min) => `L'array deve avere almeno ${min} elementi`,
-    arrayMax: (max) => `L'array non può avere più di ${max} elementi`,
-    arrayLength: (length) => `L'array deve avere esattamente ${length} elementi`,
-    arrayEmpty: 'L\'array non può essere vuoto',
-    arrayItem: (index, error) => `Elemento non valido all'indice ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Campo non valido "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Nessun membro dell'unione corrisponde: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Validazione intersezione fallita: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Previsto ${expected}, ricevuto ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Previsto uno di [${values.join(', ')}], ricevuto ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Previsto undefined',
-    neverType: 'Il tipo never non può essere analizzato',
-    // New advanced type validation messages
-    invalidBigint: 'Bigint non valido',
-    invalidSymbol: 'Simbolo non valido',
-    invalidTuple: 'Tupla non valida',
-    tupleLength: (expected, received) => `La tupla deve avere esattamente ${expected} elementi, ricevuti ${received}`,
-    invalidRecord: 'Record non valido',
-    invalidSet: 'Set non valido',
-    invalidMap: 'Map non valida',
-    // Transformation and refinement messages
-    transformError: (error) => `Trasformazione fallita: ${error}`,
-    refinementError: (error) => `Raffinamento fallito: ${error}`,
-    customValidationError: (error) => `Validazione personalizzata fallita: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Impossibile convertire ${JSON.stringify(value)} in ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Previsto ${expected}, ricevuto ${received}`,
-    stringBoolExpected: (validValues, received) => `Stringa booleana non valida. Previsto uno di: ${validValues}, ricevuto: "${received}"`,
-    invalidJson: 'JSON non valido',
-    stringPatternInvalid: 'La stringa non corrisponde al pattern richiesto',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'È prevista una funzione',
-    // CIDR validation messages
-    stringCidrv4: 'Blocco CIDR IPv4 non valido',
-    stringCidrv6: 'Blocco CIDR IPv6 non valido',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Impossibile sovrascrivere chiavi esistenti: ${keys.join(', ')}. Usa extend() per sovrascrivere.`
-};
-
-var it$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    it: it
-});
-
-const pt = {
-    // String validation messages
-    invalidString: 'String inválida',
-    stringMin: (min) => `String deve ter pelo menos ${min} caracteres`,
-    stringMax: (max) => `String não pode ter mais que ${max} caracteres`,
-    stringLength: (length) => `String deve ter exactamente ${length} caracteres`,
-    stringEmail: 'Endereço de email inválido',
-    stringUrl: 'URL inválido',
-    stringUuid: 'UUID inválido',
-    stringRegex: 'Formato inválido',
-    stringStartsWith: (prefix) => `String deve começar com "${prefix}"`,
-    stringEndsWith: (suffix) => `String deve terminar com "${suffix}"`,
-    stringIncludes: (substring) => `String deve conter "${substring}"`,
-    stringIp: 'Endereço IP inválido',
-    stringIpv4: 'Endereço IPv4 inválido',
-    stringIpv6: 'Endereço IPv6 inválido',
-    stringEmpty: 'String não pode estar vazia',
-    // Number validation messages
-    invalidNumber: 'Número inválido',
-    numberMin: (min) => `Número deve ser pelo menos ${min}`,
-    numberMax: (max) => `Número não pode ser maior que ${max}`,
-    numberInt: 'Número deve ser inteiro',
-    numberPositive: 'Número deve ser positivo',
-    numberNegative: 'Número deve ser negativo',
-    numberNonnegative: 'Número não pode ser negativo',
-    numberNonpositive: 'Número não pode ser positivo',
-    numberFinite: 'Número deve ser finito',
-    numberSafe: 'Número deve ser um inteiro seguro',
-    numberMultipleOf: (value) => `Número deve ser múltiplo de ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'Valor booleano inválido',
-    // Date validation messages
-    invalidDate: 'Data inválida',
-    dateMin: (date) => `Data deve ser após ${date.toISOString()}`,
-    dateMax: (date) => `Data deve ser antes de ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Objecto inválido',
-    unexpectedKeys: (keys) => `Chaves inesperadas: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Array inválido',
-    arrayMin: (min) => `Array deve ter pelo menos ${min} elementos`,
-    arrayMax: (max) => `Array não pode ter mais que ${max} elementos`,
-    arrayLength: (length) => `Array deve ter exactamente ${length} elementos`,
-    arrayEmpty: 'Array não pode estar vazio',
-    arrayItem: (index, error) => `Item inválido no índice ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Campo inválido "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Nenhum membro da união correspondeu: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Validação de intersecção falhou: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Esperado ${expected}, recebido ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Esperado um de [${values.join(', ')}], recebido ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Esperado undefined',
-    neverType: 'Tipo never não pode ser analisado',
-    // New advanced type validation messages
-    invalidBigint: 'Bigint inválido',
-    invalidSymbol: 'Símbolo inválido',
-    invalidTuple: 'Tupla inválida',
-    tupleLength: (expected, received) => `Tupla deve ter exactamente ${expected} elementos, recebidos ${received}`,
-    invalidRecord: 'Registo inválido',
-    invalidSet: 'Set inválido',
-    invalidMap: 'Map inválido',
-    // Transformation and refinement messages
-    transformError: (error) => `Transformação falhou: ${error}`,
-    refinementError: (error) => `Refinamento falhou: ${error}`,
-    customValidationError: (error) => `Validação personalizada falhou: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Não é possível converter ${JSON.stringify(value)} para ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Esperado ${expected}, recebido ${received}`,
-    stringBoolExpected: (validValues, received) => `String boolean inválida. Esperado um de: ${validValues}, recebido: "${received}"`,
-    invalidJson: 'JSON inválido',
-    stringPatternInvalid: 'A string não corresponde ao padrão necessário',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'Uma função é esperada',
-    // CIDR validation messages
-    stringCidrv4: 'Bloco CIDR IPv4 inválido',
-    stringCidrv6: 'Bloco CIDR IPv6 inválido',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Não é possível substituir chaves existentes: ${keys.join(', ')}. Use extend() se quiser substituir.`
-};
-
-var pt$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    pt: pt
-});
-
-const ru = {
-    // String validation messages
-    invalidString: 'Некорректная строка',
-    stringMin: (min) => `Строка должна содержать не менее ${min} символов`,
-    stringMax: (max) => `Строка не может содержать более ${max} символов`,
-    stringLength: (length) => `Строка должна содержать ровно ${length} символов`,
-    stringEmail: 'Некорректный email адрес',
-    stringUrl: 'Некорректный URL',
-    stringUuid: 'Некорректный UUID',
-    stringRegex: 'Некорректный формат',
-    stringStartsWith: (prefix) => `Строка должна начинаться с "${prefix}"`,
-    stringEndsWith: (suffix) => `Строка должна заканчиваться на "${suffix}"`,
-    stringIncludes: (substring) => `Строка должна содержать "${substring}"`,
-    stringIp: 'Некорректный IP адрес',
-    stringIpv4: 'Некорректный IPv4 адрес',
-    stringIpv6: 'Некорректный IPv6 адрес',
-    stringEmpty: 'Строка не может быть пустой',
-    // Number validation messages
-    invalidNumber: 'Некорректное число',
-    numberMin: (min) => `Число должно быть не менее ${min}`,
-    numberMax: (max) => `Число не может быть больше ${max}`,
-    numberInt: 'Число должно быть целым',
-    numberPositive: 'Число должно быть положительным',
-    numberNegative: 'Число должно быть отрицательным',
-    numberNonnegative: 'Число не может быть отрицательным',
-    numberNonpositive: 'Число не может быть положительным',
-    numberFinite: 'Число должно быть конечным',
-    numberSafe: 'Число должно быть безопасным целым',
-    numberMultipleOf: (value) => `Число должно быть кратно ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'Некорректный boolean',
-    // Date validation messages
-    invalidDate: 'Некорректная дата',
-    dateMin: (date) => `Дата должна быть после ${date.toISOString()}`,
-    dateMax: (date) => `Дата должна быть до ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Некорректный объект',
-    unexpectedKeys: (keys) => `Неожиданные ключи: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Некорректный массив',
-    arrayMin: (min) => `Массив должен содержать не менее ${min} элементов`,
-    arrayMax: (max) => `Массив не может содержать более ${max} элементов`,
-    arrayLength: (length) => `Массив должен содержать ровно ${length} элементов`,
-    arrayEmpty: 'Массив не может быть пустым',
-    arrayItem: (index, error) => `Некорректный элемент по индексу ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Некорректное поле "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Ни один член объединения не подошёл: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Не удалось выполнить валидацию пересечения: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Ожидалось ${expected}, получено ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Ожидалось одно из [${values.join(', ')}], получено ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Ожидалось undefined',
-    neverType: 'Тип never не может быть разобран',
-    // New advanced type validation messages
-    invalidBigint: 'Некорректный bigint',
-    invalidSymbol: 'Некорректный символ',
-    invalidTuple: 'Некорректный кортеж',
-    tupleLength: (expected, received) => `Кортеж должен содержать ровно ${expected} элементов, получено ${received}`,
-    invalidRecord: 'Некорректная запись',
-    invalidSet: 'Некорректный set',
-    invalidMap: 'Некорректная map',
-    // Transformation and refinement messages
-    transformError: (error) => `Преобразование не удалось: ${error}`,
-    refinementError: (error) => `Уточнение не удалось: ${error}`,
-    customValidationError: (error) => `Пользовательская проверка не удалась: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Невозможно привести ${JSON.stringify(value)} к типу ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Ожидалось ${expected}, получено ${received}`,
-    stringBoolExpected: (validValues, received) => `Некорректная boolean строка. Ожидалось одно из: ${validValues}, получено: "${received}"`,
-    invalidJson: 'Недопустимый JSON',
-    stringPatternInvalid: 'Строка не соответствует требуемому шаблону',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'Ожидалась функция',
-    // CIDR validation messages
-    stringCidrv4: 'Некорректный IPv4 CIDR блок',
-    stringCidrv6: 'Некорректный IPv6 CIDR блок',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Невозможно переопределить существующие ключи: ${keys.join(', ')}. Используйте extend() для переопределения.`
-};
-
-var ru$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ru: ru
-});
-
-const ja = {
-    // String validation messages
-    invalidString: '無効な文字列',
-    stringMin: (min) => `文字列は${min}文字以上である必要があります`,
-    stringMax: (max) => `文字列は${max}文字以下である必要があります`,
-    stringLength: (length) => `文字列はちょうど${length}文字である必要があります`,
-    stringEmail: '無効なメールアドレス',
-    stringUrl: '無効なURL',
-    stringUuid: '無効なUUID',
-    stringRegex: '無効なフォーマット',
-    stringStartsWith: (prefix) => `文字列は「${prefix}」で始まる必要があります`,
-    stringEndsWith: (suffix) => `文字列は「${suffix}」で終わる必要があります`,
-    stringIncludes: (substring) => `文字列は「${substring}」を含む必要があります`,
-    stringIp: '無効なIPアドレス',
-    stringIpv4: '無効なIPv4アドレス',
-    stringIpv6: '無効なIPv6アドレス',
-    stringEmpty: '文字列は空にできません',
-    // Number validation messages
-    invalidNumber: '無効な数値',
-    numberMin: (min) => `数値は${min}以上である必要があります`,
-    numberMax: (max) => `数値は${max}以下である必要があります`,
-    numberInt: '数値は整数である必要があります',
-    numberPositive: '数値は正の値である必要があります',
-    numberNegative: '数値は負の値である必要があります',
-    numberNonnegative: '数値は負の値にできません',
-    numberNonpositive: '数値は正の値にできません',
-    numberFinite: '数値は有限である必要があります',
-    numberSafe: '数値は安全な整数である必要があります',
-    numberMultipleOf: (value) => `数値は${value}の倍数である必要があります`,
-    // Boolean validation messages
-    invalidBoolean: '無効なブール値',
-    // Date validation messages
-    invalidDate: '無効な日付',
-    dateMin: (date) => `日付は${date.toISOString()}より後である必要があります`,
-    dateMax: (date) => `日付は${date.toISOString()}より前である必要があります`,
-    // Object validation messages
-    invalidObject: '無効なオブジェクト',
-    unexpectedKeys: (keys) => `予期しないキー: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: '無効な配列',
-    arrayMin: (min) => `配列は${min}個以上の要素が必要です`,
-    arrayMax: (max) => `配列は${max}個以下の要素でなければなりません`,
-    arrayLength: (length) => `配列はちょうど${length}個の要素が必要です`,
-    arrayEmpty: '配列は空にできません',
-    arrayItem: (index, error) => `インデックス${index}の無効な要素: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `無効なフィールド「${field}」: ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `どのユニオンメンバーもマッチしませんでした: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `交差検証に失敗しました: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `${expected}が期待されましたが、${received}を受け取りました`,
-    // Enum validation messages
-    enumExpected: (values, received) => `[${values.join(', ')}]のいずれかが期待されましたが、${received}を受け取りました`,
-    // Special type validation messages
-    expectedUndefined: 'undefinedが期待されました',
-    neverType: 'neverタイプは解析できません',
-    // New advanced type validation messages
-    invalidBigint: '無効なbigint',
-    invalidSymbol: '無効なシンボル',
-    invalidTuple: '無効なタプル',
-    tupleLength: (expected, received) => `タプルはちょうど${expected}個の要素が必要ですが、${received}個を受け取りました`,
-    invalidRecord: '無効なレコード',
-    invalidSet: '無効なSet',
-    invalidMap: '無効なMap',
-    // Transformation and refinement messages
-    transformError: (error) => `変換に失敗しました: ${error}`,
-    refinementError: (error) => `リファインメントに失敗しました: ${error}`,
-    customValidationError: (error) => `カスタム検証が失敗しました: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `${JSON.stringify(value)}を${type}に変換できません`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `${expected}が期待されましたが、${received}を受け取りました`,
-    stringBoolExpected: (validValues, received) => `無効なブール文字列です。次のいずれかである必要があります: ${validValues}、受け取りました: "${received}"`,
-    invalidJson: '無効なJSON',
-    stringPatternInvalid: '文字列が必要なパターンと一致しません',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: '関数が期待されました',
-    // CIDR validation messages
-    stringCidrv4: '無効なIPv4 CIDRブロック',
-    stringCidrv6: '無効なIPv6 CIDRブロック',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `既存のキーを上書きできません: ${keys.join(', ')}。上書きしたい場合はextend()を使用してください。`
-};
-
-var ja$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ja: ja
-});
-
-const ko = {
-    // String validation messages
-    invalidString: '유효하지 않은 문자열',
-    stringMin: (min) => `문자열은 최소 ${min}자여야 합니다`,
-    stringMax: (max) => `문자열은 최대 ${max}자여야 합니다`,
-    stringLength: (length) => `문자열은 정확히 ${length}자여야 합니다`,
-    stringEmail: '유효하지 않은 이메일 주소',
-    stringUrl: '유효하지 않은 URL',
-    stringUuid: '유효하지 않은 UUID',
-    stringRegex: '유효하지 않은 형식',
-    stringStartsWith: (prefix) => `문자열은 "${prefix}"로 시작해야 합니다`,
-    stringEndsWith: (suffix) => `문자열은 "${suffix}"로 끝나야 합니다`,
-    stringIncludes: (substring) => `문자열은 "${substring}"을 포함해야 합니다`,
-    stringIp: '유효하지 않은 IP 주소',
-    stringIpv4: '유효하지 않은 IPv4 주소',
-    stringIpv6: '유효하지 않은 IPv6 주소',
-    stringEmpty: '문자열은 비어있을 수 없습니다',
-    // Number validation messages
-    invalidNumber: '유효하지 않은 숫자',
-    numberMin: (min) => `숫자는 최소 ${min}이어야 합니다`,
-    numberMax: (max) => `숫자는 최대 ${max}이어야 합니다`,
-    numberInt: '숫자는 정수여야 합니다',
-    numberPositive: '숫자는 양수여야 합니다',
-    numberNegative: '숫자는 음수여야 합니다',
-    numberNonnegative: '숫자는 음수일 수 없습니다',
-    numberNonpositive: '숫자는 양수일 수 없습니다',
-    numberFinite: '숫자는 유한해야 합니다',
-    numberSafe: '숫자는 안전한 정수여야 합니다',
-    numberMultipleOf: (value) => `숫자는 ${value}의 배수여야 합니다`,
-    // Boolean validation messages
-    invalidBoolean: '유효하지 않은 불린 값',
-    // Date validation messages
-    invalidDate: '유효하지 않은 날짜',
-    dateMin: (date) => `날짜는 ${date.toISOString()} 이후여야 합니다`,
-    dateMax: (date) => `날짜는 ${date.toISOString()} 이전이어야 합니다`,
-    // Object validation messages
-    invalidObject: '유효하지 않은 객체',
-    unexpectedKeys: (keys) => `예상치 못한 키: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: '유효하지 않은 배열',
-    arrayMin: (min) => `배열은 최소 ${min}개의 요소가 있어야 합니다`,
-    arrayMax: (max) => `배열은 최대 ${max}개의 요소가 있어야 합니다`,
-    arrayLength: (length) => `배열은 정확히 ${length}개의 요소가 있어야 합니다`,
-    arrayEmpty: '배열은 비어있을 수 없습니다',
-    arrayItem: (index, error) => `인덱스 ${index}의 유효하지 않은 요소: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `유효하지 않은 필드 "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `어떤 유니온 멤버도 일치하지 않았습니다: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `교집합 검증에 실패했습니다: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `${expected}가 예상되었지만 ${received}를 받았습니다`,
-    // Enum validation messages
-    enumExpected: (values, received) => `[${values.join(', ')}] 중 하나가 예상되었지만 ${received}를 받았습니다`,
-    // Special type validation messages
-    expectedUndefined: 'undefined가 예상되었습니다',
-    neverType: 'never 타입은 파싱할 수 없습니다',
-    // New advanced type validation messages
-    invalidBigint: '유효하지 않은 bigint',
-    invalidSymbol: '유효하지 않은 심볼',
-    invalidTuple: '유효하지 않은 튜플',
-    tupleLength: (expected, received) => `튜플은 정확히 ${expected}개의 요소가 있어야 하지만 ${received}개를 받았습니다`,
-    invalidRecord: '유효하지 않은 레코드',
-    invalidSet: '유효하지 않은 Set',
-    invalidMap: '유효하지 않은 Map',
-    // Transformation and refinement messages
-    transformError: (error) => `변환 실패: ${error}`,
-    refinementError: (error) => `정제 실패: ${error}`,
-    customValidationError: (error) => `사용자 정의 유효성 검사 실패: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `${JSON.stringify(value)}를 ${type}로 강제 변환할 수 없습니다`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `${expected}가 예상되었지만 ${received}를 받았습니다`,
-    stringBoolExpected: (validValues, received) => `잘못된 불린 문자열입니다. 다음 중 하나여야 합니다: ${validValues}, 받은 값: "${received}"`,
-    invalidJson: '잘못된 JSON',
-    stringPatternInvalid: '문자열이 필요한 패턴과 일치하지 않습니다',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: '함수가 예상되었습니다',
-    // CIDR validation messages
-    stringCidrv4: '유효하지 않은 IPv4 CIDR 블록',
-    stringCidrv6: '유효하지 않은 IPv6 CIDR 블록',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `기존 키를 덮어쓸 수 없습니다: ${keys.join(', ')}. 덮어쓰려면 extend()를 사용하세요.`
-};
-
-var ko$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ko: ko
-});
-
-const zh = {
-    // String validation messages
-    invalidString: '无效字符串',
-    stringMin: (min) => `字符串必须至少${min}个字符`,
-    stringMax: (max) => `字符串不能超过${max}个字符`,
-    stringLength: (length) => `字符串必须正好${length}个字符`,
-    stringEmail: '无效邮箱地址',
-    stringUrl: '无效URL',
-    stringUuid: '无效UUID',
-    stringRegex: '无效格式',
-    stringStartsWith: (prefix) => `字符串必须以"${prefix}"开头`,
-    stringEndsWith: (suffix) => `字符串必须以"${suffix}"结尾`,
-    stringIncludes: (substring) => `字符串必须包含"${substring}"`,
-    stringIp: '无效IP地址',
-    stringIpv4: '无效IPv4地址',
-    stringIpv6: '无效IPv6地址',
-    stringEmpty: '字符串不能为空',
-    // Number validation messages
-    invalidNumber: '无效数字',
-    numberMin: (min) => `数字必须至少为${min}`,
-    numberMax: (max) => `数字不能大于${max}`,
-    numberInt: '数字必须是整数',
-    numberPositive: '数字必须是正数',
-    numberNegative: '数字必须是负数',
-    numberNonnegative: '数字不能是负数',
-    numberNonpositive: '数字不能是正数',
-    numberFinite: '数字必须是有限的',
-    numberSafe: '数字必须是安全整数',
-    numberMultipleOf: (value) => `数字必须是${value}的倍数`,
-    // Boolean validation messages
-    invalidBoolean: '无效布尔值',
-    // Date validation messages
-    invalidDate: '无效日期',
-    dateMin: (date) => `日期必须在${date.toISOString()}之后`,
-    dateMax: (date) => `日期必须在${date.toISOString()}之前`,
-    // Object validation messages
-    invalidObject: '无效对象',
-    unexpectedKeys: (keys) => `意外的键: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: '无效数组',
-    arrayMin: (min) => `数组必须至少有${min}个元素`,
-    arrayMax: (max) => `数组不能超过${max}个元素`,
-    arrayLength: (length) => `数组必须正好有${length}个元素`,
-    arrayEmpty: '数组不能为空',
-    arrayItem: (index, error) => `索引${index}处的无效元素: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `无效字段"${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `没有匹配的联合成员: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `交集验证失败: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `期望${expected}，得到${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `期望[${values.join(', ')}]中的一个，得到${received}`,
-    // Special type validation messages
-    expectedUndefined: '期望undefined',
-    neverType: 'never类型无法解析',
-    // New advanced type validation messages
-    invalidBigint: '无效bigint',
-    invalidSymbol: '无效符号',
-    invalidTuple: '无效元组',
-    tupleLength: (expected, received) => `元组必须正好有${expected}个元素，得到${received}个`,
-    invalidRecord: '无效记录',
-    invalidSet: '无效Set',
-    invalidMap: '无效Map',
-    // Transformation and refinement messages
-    transformError: (error) => `转换失败: ${error}`,
-    refinementError: (error) => `细化失败: ${error}`,
-    customValidationError: (error) => `自定义验证失败: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `无法将${JSON.stringify(value)}强制转换为${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `期望${expected}，得到${received}`,
-    stringBoolExpected: (validValues, received) => `无效的布尔字符串。期望以下之一: ${validValues}，得到: "${received}"`,
-    invalidJson: '无效的JSON',
-    stringPatternInvalid: '字符串与所需模式不匹配',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: '期望一个函数',
-    // CIDR validation messages
-    stringCidrv4: '无效的IPv4 CIDR块',
-    stringCidrv6: '无效的IPv6 CIDR块',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `无法覆盖现有键: ${keys.join(', ')}。如果要覆盖请使用extend()。`
-};
-
-var zh$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    zh: zh
-});
-
-const ar = {
-    // String validation messages
-    invalidString: 'نص غير صحيح',
-    stringMin: (min) => `يجب أن يحتوي النص على ${min} حرف على الأقل`,
-    stringMax: (max) => `لا يمكن أن يحتوي النص على أكثر من ${max} حرف`,
-    stringLength: (length) => `يجب أن يحتوي النص على ${length} حرف بالضبط`,
-    stringEmail: 'عنوان بريد إلكتروني غير صحيح',
-    stringUrl: 'رابط غير صحيح',
-    stringUuid: 'UUID غير صحيح',
-    stringRegex: 'تنسيق غير صحيح',
-    stringStartsWith: (prefix) => `يجب أن يبدأ النص بـ "${prefix}"`,
-    stringEndsWith: (suffix) => `يجب أن ينتهي النص بـ "${suffix}"`,
-    stringIncludes: (substring) => `يجب أن يحتوي النص على "${substring}"`,
-    stringIp: 'عنوان IP غير صحيح',
-    stringIpv4: 'عنوان IPv4 غير صحيح',
-    stringIpv6: 'عنوان IPv6 غير صحيح',
-    stringEmpty: 'لا يمكن أن يكون النص فارغاً',
-    // Number validation messages
-    invalidNumber: 'رقم غير صحيح',
-    numberMin: (min) => `يجب أن يكون الرقم ${min} على الأقل`,
-    numberMax: (max) => `لا يمكن أن يكون الرقم أكبر من ${max}`,
-    numberInt: 'يجب أن يكون الرقم صحيحاً',
-    numberPositive: 'يجب أن يكون الرقم موجباً',
-    numberNegative: 'يجب أن يكون الرقم سالباً',
-    numberNonnegative: 'لا يمكن أن يكون الرقم سالباً',
-    numberNonpositive: 'لا يمكن أن يكون الرقم موجباً',
-    numberFinite: 'يجب أن يكون الرقم محدوداً',
-    numberSafe: 'يجب أن يكون الرقم صحيحاً آمناً',
-    numberMultipleOf: (value) => `يجب أن يكون الرقم مضاعفاً لـ ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'قيمة منطقية غير صحيحة',
-    // Date validation messages
-    invalidDate: 'تاريخ غير صحيح',
-    dateMin: (date) => `يجب أن يكون التاريخ بعد ${date.toISOString()}`,
-    dateMax: (date) => `يجب أن يكون التاريخ قبل ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'كائن غير صحيح',
-    unexpectedKeys: (keys) => `مفاتيح غير متوقعة: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'مصفوفة غير صحيحة',
-    arrayMin: (min) => `يجب أن تحتوي المصفوفة على ${min} عنصر على الأقل`,
-    arrayMax: (max) => `لا يمكن أن تحتوي المصفوفة على أكثر من ${max} عنصر`,
-    arrayLength: (length) => `يجب أن تحتوي المصفوفة على ${length} عنصر بالضبط`,
-    arrayEmpty: 'لا يمكن أن تكون المصفوفة فارغة',
-    arrayItem: (index, error) => `عنصر غير صحيح في الفهرس ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `حقل غير صحيح "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `لا يوجد عضو اتحاد مطابق: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `فشل في التحقق من التقاطع: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `متوقع ${expected}، تم استلام ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `متوقع واحد من [${values.join(', ')}]، تم استلام ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'متوقع undefined',
-    neverType: 'لا يمكن تحليل نوع never',
-    // New advanced type validation messages
-    invalidBigint: 'bigint غير صحيح',
-    invalidSymbol: 'رمز غير صحيح',
-    invalidTuple: 'صف غير صحيح',
-    tupleLength: (expected, received) => `يجب أن يحتوي الصف على ${expected} عنصر بالضبط، تم استلام ${received}`,
-    invalidRecord: 'سجل غير صحيح',
-    invalidSet: 'Set غير صحيح',
-    invalidMap: 'Map غير صحيح',
-    // Transformation and refinement messages
-    transformError: (error) => `فشل التحويل: ${error}`,
-    refinementError: (error) => `فشل التنقيح: ${error}`,
-    customValidationError: (error) => `فشل في التحقق المخصص: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `لا يمكن إكراه ${JSON.stringify(value)} إلى ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `متوقع ${expected}، تم استلام ${received}`,
-    stringBoolExpected: (validValues, received) => `سلسلة منطقية غير صحيحة. متوقع واحد من: ${validValues}، تم استلام: "${received}"`,
-    invalidJson: 'JSON غير صالح',
-    stringPatternInvalid: 'السلسلة لا تطابق النمط المطلوب',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'دالة متوقعة',
-    // CIDR validation messages
-    stringCidrv4: 'كتلة CIDR IPv4 غير صالحة',
-    stringCidrv6: 'كتلة CIDR IPv6 غير صالحة',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `لا يمكن استبدال المفاتيح الموجودة: ${keys.join(', ')}. استخدم extend() للاستبدال.`
-};
-
-var ar$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ar: ar
-});
-
-const hi = {
-    // String validation messages
-    invalidString: 'अमान्य स्ट्रिंग',
-    stringMin: (min) => `स्ट्रिंग में कम से कम ${min} अक्षर होने चाहिए`,
-    stringMax: (max) => `स्ट्रिंग में ${max} से अधिक अक्षर नहीं हो सकते`,
-    stringLength: (length) => `स्ट्रिंग में ठीक ${length} अक्षर होने चाहिए`,
-    stringEmail: 'अमान्य ईमेल पता',
-    stringUrl: 'अमान्य URL',
-    stringUuid: 'अमान्य UUID',
-    stringRegex: 'अमान्य प्रारूप',
-    stringStartsWith: (prefix) => `स्ट्रिंग "${prefix}" से शुरू होनी चाहिए`,
-    stringEndsWith: (suffix) => `स्ट्रिंग "${suffix}" से समाप्त होनी चाहिए`,
-    stringIncludes: (substring) => `स्ट्रिंग में "${substring}" होना चाहिए`,
-    stringIp: 'अमान्य IP पता',
-    stringIpv4: 'अमान्य IPv4 पता',
-    stringIpv6: 'अमान्य IPv6 पता',
-    stringEmpty: 'स्ट्रिंग खाली नहीं हो सकती',
-    // Number validation messages
-    invalidNumber: 'अमान्य संख्या',
-    numberMin: (min) => `संख्या कम से कम ${min} होनी चाहिए`,
-    numberMax: (max) => `संख्या ${max} से अधिक नहीं हो सकती`,
-    numberInt: 'संख्या पूर्णांक होनी चाहिए',
-    numberPositive: 'संख्या सकारात्मक होनी चाहिए',
-    numberNegative: 'संख्या नकारात्मक होनी चाहिए',
-    numberNonnegative: 'संख्या नकारात्मक नहीं हो सकती',
-    numberNonpositive: 'संख्या सकारात्मक नहीं हो सकती',
-    numberFinite: 'संख्या परिमित होनी चाहिए',
-    numberSafe: 'संख्या सुरक्षित पूर्णांक होनी चाहिए',
-    numberMultipleOf: (value) => `संख्या ${value} का गुणज होनी चाहिए`,
-    // Boolean validation messages
-    invalidBoolean: 'अमान्य बूलियन मान',
-    // Date validation messages
-    invalidDate: 'अमान्य तिथि',
-    dateMin: (date) => `तिथि ${date.toISOString()} के बाद होनी चाहिए`,
-    dateMax: (date) => `तिथि ${date.toISOString()} से पहले होनी चाहिए`,
-    // Object validation messages
-    invalidObject: 'अमान्य ऑब्जेक्ट',
-    unexpectedKeys: (keys) => `अनपेक्षित कुंजियां: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'अमान्य सरणी',
-    arrayMin: (min) => `सरणी में कम से कम ${min} तत्व होने चाहिए`,
-    arrayMax: (max) => `सरणी में ${max} से अधिक तत्व नहीं हो सकते`,
-    arrayLength: (length) => `सरणी में ठीक ${length} तत्व होने चाहिए`,
-    arrayEmpty: 'सरणी खाली नहीं हो सकती',
-    arrayItem: (index, error) => `सूचकांक ${index} पर अमान्य तत्व: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `अमान्य फ़ील्ड "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `कोई यूनियन सदस्य मेल नहीं खाया: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `प्रतिच्छेदन सत्यापन विफल: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `अपेक्षित ${expected}, प्राप्त ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `[${values.join(', ')}] में से एक अपेक्षित, प्राप्त ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'undefined अपेक्षित',
-    neverType: 'never प्रकार का विश्लेषण नहीं किया जा सकता',
-    // New advanced type validation messages
-    invalidBigint: 'अमान्य bigint',
-    invalidSymbol: 'अमान्य प्रतीक',
-    invalidTuple: 'अमान्य ट्यूपल',
-    tupleLength: (expected, received) => `ट्यूपल में ठीक ${expected} तत्व होने चाहिए, ${received} प्राप्त हुए`,
-    invalidRecord: 'अमान्य रिकॉर्ड',
-    invalidSet: 'अमान्य Set',
-    invalidMap: 'अमान्य Map',
-    // Transformation and refinement messages
-    transformError: (error) => `रूपांतरण विफल: ${error}`,
-    refinementError: (error) => `शुद्धीकरण विफल: ${error}`,
-    customValidationError: (error) => `कस्टम सत्यापन विफल: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `${JSON.stringify(value)} को ${type} में परिवर्तित नहीं किया जा सकता`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `अपेक्षित ${expected}, प्राप्त ${received}`,
-    stringBoolExpected: (validValues, received) => `अमान्य बूलियन स्ट्रिंग। निम्नलिखित में से एक अपेक्षित: ${validValues}, प्राप्त: "${received}"`,
-    invalidJson: 'अमान्य JSON',
-    stringPatternInvalid: 'स्ट्रिंग आवश्यक पैटर्न से मेल नहीं खाती',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'एक फ़ंक्शन अपेक्षित है',
-    // CIDR validation messages
-    stringCidrv4: 'अमान्य IPv4 CIDR ब्लॉक',
-    stringCidrv6: 'अमान्य IPv6 CIDR ब्लॉक',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `मौजूदा कुंजियों को ओवरराइड नहीं कर सकते: ${keys.join(', ')}। ओवरराइड करने के लिए extend() का उपयोग करें।`
-};
-
-var hi$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    hi: hi
-});
-
-const nl = {
-    // String validation messages
-    invalidString: 'Ongeldige string',
-    stringMin: (min) => `String moet ten minste ${min} tekens lang zijn`,
-    stringMax: (max) => `String mag niet meer dan ${max} tekens lang zijn`,
-    stringLength: (length) => `String moet precies ${length} tekens lang zijn`,
-    stringEmail: 'Ongeldig e-mailadres',
-    stringUrl: 'Ongeldige URL',
-    stringUuid: 'Ongeldige UUID',
-    stringRegex: 'Ongeldig formaat',
-    stringStartsWith: (prefix) => `String moet beginnen met "${prefix}"`,
-    stringEndsWith: (suffix) => `String moet eindigen met "${suffix}"`,
-    stringIncludes: (substring) => `String moet "${substring}" bevatten`,
-    stringIp: 'Ongeldig IP-adres',
-    stringIpv4: 'Ongeldig IPv4-adres',
-    stringIpv6: 'Ongeldig IPv6-adres',
-    stringEmpty: 'String mag niet leeg zijn',
-    // Number validation messages
-    invalidNumber: 'Ongeldig getal',
-    numberMin: (min) => `Getal moet ten minste ${min} zijn`,
-    numberMax: (max) => `Getal mag niet meer dan ${max} zijn`,
-    numberInt: 'Getal moet een geheel getal zijn',
-    numberPositive: 'Getal moet positief zijn',
-    numberNegative: 'Getal moet negatief zijn',
-    numberNonnegative: 'Getal mag niet negatief zijn',
-    numberNonpositive: 'Getal mag niet positief zijn',
-    numberFinite: 'Getal moet eindig zijn',
-    numberSafe: 'Getal moet een veilig geheel getal zijn',
-    numberMultipleOf: (value) => `Getal moet een veelvoud van ${value} zijn`,
-    // Boolean validation messages
-    invalidBoolean: 'Ongeldige boolean waarde',
-    // Date validation messages
-    invalidDate: 'Ongeldige datum',
-    dateMin: (date) => `Datum moet na ${date.toISOString()} zijn`,
-    dateMax: (date) => `Datum moet voor ${date.toISOString()} zijn`,
-    // Object validation messages
-    invalidObject: 'Ongeldig object',
-    unexpectedKeys: (keys) => `Onverwachte sleutels: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Ongeldige array',
-    arrayMin: (min) => `Array moet ten minste ${min} elementen hebben`,
-    arrayMax: (max) => `Array mag niet meer dan ${max} elementen hebben`,
-    arrayLength: (length) => `Array moet precies ${length} elementen hebben`,
-    arrayEmpty: 'Array mag niet leeg zijn',
-    arrayItem: (index, error) => `Ongeldig element op index ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Ongeldig veld "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Geen union lid kwam overeen: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Intersection validatie mislukt: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Verwacht ${expected}, ontvangen ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Verwacht een van [${values.join(', ')}], ontvangen ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Verwacht undefined',
-    neverType: 'Never type kan niet worden geparseerd',
-    // New advanced type validation messages
-    invalidBigint: 'Ongeldige bigint',
-    invalidSymbol: 'Ongeldig symbool',
-    invalidTuple: 'Ongeldige tuple',
-    tupleLength: (expected, received) => `Tuple moet precies ${expected} elementen hebben, ontvangen ${received}`,
-    invalidRecord: 'Ongeldig record',
-    invalidSet: 'Ongeldige set',
-    invalidMap: 'Ongeldige map',
-    // Transformation and refinement messages
-    transformError: (error) => `Transformatie mislukt: ${error}`,
-    refinementError: (error) => `Verfijning mislukt: ${error}`,
-    customValidationError: (error) => `Aangepaste validatie mislukt: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Kan ${JSON.stringify(value)} niet omzetten naar ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Verwacht ${expected}, ontvangen ${received}`,
-    stringBoolExpected: (validValues, received) => `Ongeldige boolean string. Een van de volgende verwacht: ${validValues}, ontvangen: "${received}"`,
-    invalidJson: 'Ongeldige JSON',
-    stringPatternInvalid: 'Tekenreeks komt niet overeen met het vereiste patroon',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'Een functie verwacht',
-    // CIDR validation messages
-    stringCidrv4: 'Ongeldig IPv4 CIDR-blok',
-    stringCidrv6: 'Ongeldig IPv6 CIDR-blok',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Kan bestaande sleutels niet overschrijven: ${keys.join(', ')}. Gebruik extend() als je wilt overschrijven.`
-};
-
-var nl$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    nl: nl
-});
-
-const pl = {
-    // String validation messages
-    invalidString: 'Nieprawidłowy ciąg znaków',
-    stringMin: (min) => `Ciąg znaków musi mieć co najmniej ${min} znaków`,
-    stringMax: (max) => `Ciąg znaków nie może mieć więcej niż ${max} znaków`,
-    stringLength: (length) => `Ciąg znaków musi mieć dokładnie ${length} znaków`,
-    stringEmail: 'Nieprawidłowy adres email',
-    stringUrl: 'Nieprawidłowy URL',
-    stringUuid: 'Nieprawidłowy UUID',
-    stringRegex: 'Nieprawidłowy format',
-    stringStartsWith: (prefix) => `Ciąg znaków musi zaczynać się od "${prefix}"`,
-    stringEndsWith: (suffix) => `Ciąg znaków musi kończyć się na "${suffix}"`,
-    stringIncludes: (substring) => `Ciąg znaków musi zawierać "${substring}"`,
-    stringIp: 'Nieprawidłowy adres IP',
-    stringIpv4: 'Nieprawidłowy adres IPv4',
-    stringIpv6: 'Nieprawidłowy adres IPv6',
-    stringEmpty: 'Ciąg znaków nie może być pusty',
-    // Number validation messages
-    invalidNumber: 'Nieprawidłowa liczba',
-    numberMin: (min) => `Liczba musi być co najmniej ${min}`,
-    numberMax: (max) => `Liczba nie może być większa niż ${max}`,
-    numberInt: 'Liczba musi być liczbą całkowitą',
-    numberPositive: 'Liczba musi być dodatnia',
-    numberNegative: 'Liczba musi być ujemna',
-    numberNonnegative: 'Liczba nie może być ujemna',
-    numberNonpositive: 'Liczba nie może być dodatnia',
-    numberFinite: 'Liczba musi być skończona',
-    numberSafe: 'Liczba musi być bezpieczną liczbą całkowitą',
-    numberMultipleOf: (value) => `Liczba musi być wielokrotnością ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'Nieprawidłowa wartość boolean',
-    // Date validation messages
-    invalidDate: 'Nieprawidłowa data',
-    dateMin: (date) => `Data musi być po ${date.toISOString()}`,
-    dateMax: (date) => `Data musi być przed ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Nieprawidłowy obiekt',
-    unexpectedKeys: (keys) => `Nieoczekiwane klucze: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Nieprawidłowa tablica',
-    arrayMin: (min) => `Tablica musi mieć co najmniej ${min} elementów`,
-    arrayMax: (max) => `Tablica nie może mieć więcej niż ${max} elementów`,
-    arrayLength: (length) => `Tablica musi mieć dokładnie ${length} elementów`,
-    arrayEmpty: 'Tablica nie może być pusta',
-    arrayItem: (index, error) => `Nieprawidłowy element na indeksie ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Nieprawidłowe pole "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Żaden członek unii nie pasował: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Walidacja przecięcia nie powiodła się: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Oczekiwano ${expected}, otrzymano ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Oczekiwano jednego z [${values.join(', ')}], otrzymano ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Oczekiwano undefined',
-    neverType: 'Typ never nie może być przeanalizowany',
-    // New advanced type validation messages
-    invalidBigint: 'Nieprawidłowy bigint',
-    invalidSymbol: 'Nieprawidłowy symbol',
-    invalidTuple: 'Nieprawidłowa krotka',
-    tupleLength: (expected, received) => `Krotka musi mieć dokładnie ${expected} elementów, otrzymano ${received}`,
-    invalidRecord: 'Nieprawidłowy rekord',
-    invalidSet: 'Nieprawidłowy Set',
-    invalidMap: 'Nieprawidłowa Map',
-    // Transformation and refinement messages
-    transformError: (error) => `Transformacja nie powiodła się: ${error}`,
-    refinementError: (error) => `Rafinacja nie powiodła się: ${error}`,
-    customValidationError: (error) => `Niestandardowa walidacja nie powiodła się: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Nie można przekształcić ${JSON.stringify(value)} na ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Oczekiwano ${expected}, otrzymano ${received}`,
-    stringBoolExpected: (validValues, received) => `Nieprawidłowy ciąg znaków boolean. Oczekiwano jednego z: ${validValues}, otrzymano: "${received}"`,
-    invalidJson: 'Nieprawidłowy JSON',
-    stringPatternInvalid: 'Ciąg znaków nie pasuje do wymaganego wzorca',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'Oczekiwano funkcji',
-    // CIDR validation messages
-    stringCidrv4: 'Nieprawidłowy blok CIDR IPv4',
-    stringCidrv6: 'Nieprawidłowy blok CIDR IPv6',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Nie można nadpisać istniejących kluczy: ${keys.join(', ')}. Użyj extend() aby nadpisać.`
-};
-
-var pl$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    pl: pl
-});
-
-const da = {
-    // String validation messages
-    invalidString: 'Ugyldig streng',
-    stringMin: (min) => `Streng skal være mindst ${min} tegn lang`,
-    stringMax: (max) => `Streng må højst være ${max} tegn lang`,
-    stringLength: (length) => `Streng skal være præcis ${length} tegn lang`,
-    stringEmail: 'Ugyldig e-mailadresse',
-    stringUrl: 'Ugyldig URL',
-    stringUuid: 'Ugyldig UUID',
-    stringRegex: 'Ugyldigt format',
-    stringStartsWith: (prefix) => `Streng skal starte med "${prefix}"`,
-    stringEndsWith: (suffix) => `Streng skal slutte med "${suffix}"`,
-    stringIncludes: (substring) => `Streng skal indeholde "${substring}"`,
-    stringIp: 'Ugyldig IP-adresse',
-    stringIpv4: 'Ugyldig IPv4-adresse',
-    stringIpv6: 'Ugyldig IPv6-adresse',
-    stringEmpty: 'Streng må ikke være tom',
-    // Number validation messages
-    invalidNumber: 'Ugyldigt tal',
-    numberMin: (min) => `Tal skal være mindst ${min}`,
-    numberMax: (max) => `Tal må højst være ${max}`,
-    numberInt: 'Tal skal være et heltal',
-    numberPositive: 'Tal skal være positivt',
-    numberNegative: 'Tal skal være negativt',
-    numberNonnegative: 'Tal må ikke være negativt',
-    numberNonpositive: 'Tal må ikke være positivt',
-    numberFinite: 'Tal skal være endeligt',
-    numberSafe: 'Tal skal være et sikkert heltal',
-    numberMultipleOf: (value) => `Tal skal være et multiplum af ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'Ugyldig boolean-værdi',
-    // Date validation messages
-    invalidDate: 'Ugyldig dato',
-    dateMin: (date) => `Dato skal være efter ${date.toISOString()}`,
-    dateMax: (date) => `Dato skal være før ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Ugyldigt objekt',
-    unexpectedKeys: (keys) => `Uventede nøgler: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Ugyldigt array',
-    arrayMin: (min) => `Array skal have mindst ${min} elementer`,
-    arrayMax: (max) => `Array må højst have ${max} elementer`,
-    arrayLength: (length) => `Array skal have præcis ${length} elementer`,
-    arrayEmpty: 'Array må ikke være tomt',
-    arrayItem: (index, error) => `Ugyldigt element ved indeks ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Ugyldigt felt "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Intet union-medlem matchede: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Intersection validering fejlede: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Forventede ${expected}, fik ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Forventede en af [${values.join(', ')}], fik ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Forventede undefined',
-    neverType: 'Never-type kan ikke parses',
-    // New advanced type validation messages
-    invalidBigint: 'Ugyldig bigint',
-    invalidSymbol: 'Ugyldigt symbol',
-    invalidTuple: 'Ugyldig tupel',
-    tupleLength: (expected, received) => `Tupel skal have præcis ${expected} elementer, fik ${received}`,
-    invalidRecord: 'Ugyldig post',
-    invalidSet: 'Ugyldigt Set',
-    invalidMap: 'Ugyldig Map',
-    // Transformation and refinement messages
-    transformError: (error) => `Transformation fejlede: ${error}`,
-    refinementError: (error) => `Forfinelse fejlede: ${error}`,
-    customValidationError: (error) => `Brugerdefineret validering mislykkedes: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Kan ikke konvertere ${JSON.stringify(value)} til ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Forventede ${expected}, fik ${received}`,
-    stringBoolExpected: (validValues, received) => `Ugyldig boolean streng. En af følgende forventet: ${validValues}, fik: "${received}"`,
-    invalidJson: 'Ugyldig JSON',
-    stringPatternInvalid: 'Streng matcher ikke det krævede mønster',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'En funktion forventes',
-    // CIDR validation messages
-    stringCidrv4: 'Ugyldig IPv4 CIDR-blok',
-    stringCidrv6: 'Ugyldig IPv6 CIDR-blok',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Kan ikke overskrive eksisterende nøgler: ${keys.join(', ')}. Brug extend() for at overskrive.`
-};
-
-var da$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    da: da
-});
-
-const sv = {
-    // String validation messages
-    invalidString: 'Ogiltig sträng',
-    stringMin: (min) => `Sträng måste vara minst ${min} tecken lång`,
-    stringMax: (max) => `Sträng får vara högst ${max} tecken lång`,
-    stringLength: (length) => `Sträng måste vara exakt ${length} tecken lång`,
-    stringEmail: 'Ogiltig e-postadress',
-    stringUrl: 'Ogiltig URL',
-    stringUuid: 'Ogiltig UUID',
-    stringRegex: 'Ogiltigt format',
-    stringStartsWith: (prefix) => `Sträng måste börja med "${prefix}"`,
-    stringEndsWith: (suffix) => `Sträng måste sluta med "${suffix}"`,
-    stringIncludes: (substring) => `Sträng måste innehålla "${substring}"`,
-    stringIp: 'Ogiltig IP-adress',
-    stringIpv4: 'Ogiltig IPv4-adress',
-    stringIpv6: 'Ogiltig IPv6-adress',
-    stringEmpty: 'Sträng får inte vara tom',
-    // Number validation messages
-    invalidNumber: 'Ogiltigt nummer',
-    numberMin: (min) => `Nummer måste vara minst ${min}`,
-    numberMax: (max) => `Nummer får vara högst ${max}`,
-    numberInt: 'Nummer måste vara ett heltal',
-    numberPositive: 'Nummer måste vara positivt',
-    numberNegative: 'Nummer måste vara negativt',
-    numberNonnegative: 'Nummer får inte vara negativt',
-    numberNonpositive: 'Nummer får inte vara positivt',
-    numberFinite: 'Nummer måste vara ändligt',
-    numberSafe: 'Nummer måste vara ett säkert heltal',
-    numberMultipleOf: (value) => `Nummer måste vara en multipel av ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'Ogiltigt boolean-värde',
-    // Date validation messages
-    invalidDate: 'Ogiltigt datum',
-    dateMin: (date) => `Datum måste vara efter ${date.toISOString()}`,
-    dateMax: (date) => `Datum måste vara före ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Ogiltigt objekt',
-    unexpectedKeys: (keys) => `Oväntade nycklar: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Ogiltig array',
-    arrayMin: (min) => `Array måste ha minst ${min} element`,
-    arrayMax: (max) => `Array får ha högst ${max} element`,
-    arrayLength: (length) => `Array måste ha exakt ${length} element`,
-    arrayEmpty: 'Array får inte vara tom',
-    arrayItem: (index, error) => `Ogiltigt element vid index ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Ogiltigt fält "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Ingen union-medlem matchade: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Intersection validering misslyckades: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Förväntade ${expected}, fick ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Förväntade en av [${values.join(', ')}], fick ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Förväntade undefined',
-    neverType: 'Never-typ kan inte parsas',
-    // New advanced type validation messages
-    invalidBigint: 'Ogiltig bigint',
-    invalidSymbol: 'Ogiltig symbol',
-    invalidTuple: 'Ogiltig tupel',
-    tupleLength: (expected, received) => `Tupel måste ha exakt ${expected} element, fick ${received}`,
-    invalidRecord: 'Ogiltig post',
-    invalidSet: 'Ogiltig Set',
-    invalidMap: 'Ogiltig Map',
-    // Transformation and refinement messages
-    transformError: (error) => `Transformation misslyckades: ${error}`,
-    refinementError: (error) => `Förfining misslyckades: ${error}`,
-    customValidationError: (error) => `Anpassad validering misslyckades: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Kan inte konvertera ${JSON.stringify(value)} till ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Förväntade ${expected}, fick ${received}`,
-    stringBoolExpected: (validValues, received) => `Ogiltig boolean sträng. En av följande förväntad: ${validValues}, fick: "${received}"`,
-    invalidJson: 'Ogiltig JSON',
-    stringPatternInvalid: 'Strängen matchar inte det krävda mönstret',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'En funktion förväntas',
-    // CIDR validation messages
-    stringCidrv4: 'Ogiltigt IPv4 CIDR-block',
-    stringCidrv6: 'Ogiltigt IPv6 CIDR-block',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Kan inte skriva över befintliga nycklar: ${keys.join(', ')}. Använd extend() för att skriva över.`
-};
-
-var sv$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    sv: sv
-});
-
-const no = {
-    // String validation messages
-    invalidString: 'Ugyldig streng',
-    stringMin: (min) => `Streng må være minst ${min} tegn lang`,
-    stringMax: (max) => `Streng kan være maks ${max} tegn lang`,
-    stringLength: (length) => `Streng må være nøyaktig ${length} tegn lang`,
-    stringEmail: 'Ugyldig e-postadresse',
-    stringUrl: 'Ugyldig URL',
-    stringUuid: 'Ugyldig UUID',
-    stringRegex: 'Ugyldig format',
-    stringStartsWith: (prefix) => `Streng må starte med "${prefix}"`,
-    stringEndsWith: (suffix) => `Streng må slutte med "${suffix}"`,
-    stringIncludes: (substring) => `Streng må inneholde "${substring}"`,
-    stringIp: 'Ugyldig IP-adresse',
-    stringIpv4: 'Ugyldig IPv4-adresse',
-    stringIpv6: 'Ugyldig IPv6-adresse',
-    stringEmpty: 'Streng kan ikke være tom',
-    // Number validation messages
-    invalidNumber: 'Ugyldig tall',
-    numberMin: (min) => `Tall må være minst ${min}`,
-    numberMax: (max) => `Tall kan være maks ${max}`,
-    numberInt: 'Tall må være et heltall',
-    numberPositive: 'Tall må være positivt',
-    numberNegative: 'Tall må være negativt',
-    numberNonnegative: 'Tall kan ikke være negativt',
-    numberNonpositive: 'Tall kan ikke være positivt',
-    numberFinite: 'Tall må være endelig',
-    numberSafe: 'Tall må være et trygt heltall',
-    numberMultipleOf: (value) => `Tall må være et multiplum av ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'Ugyldig boolean-verdi',
-    // Date validation messages
-    invalidDate: 'Ugyldig dato',
-    dateMin: (date) => `Dato må være etter ${date.toISOString()}`,
-    dateMax: (date) => `Dato må være før ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Ugyldig objekt',
-    unexpectedKeys: (keys) => `Uventede nøkler: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Ugyldig array',
-    arrayMin: (min) => `Array må ha minst ${min} elementer`,
-    arrayMax: (max) => `Array kan ha maks ${max} elementer`,
-    arrayLength: (length) => `Array må ha nøyaktig ${length} elementer`,
-    arrayEmpty: 'Array kan ikke være tom',
-    arrayItem: (index, error) => `Ugyldig element ved indeks ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Ugyldig felt "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Ingen union-medlem passet: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Intersection validering feilet: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Forventet ${expected}, fikk ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Forventet en av [${values.join(', ')}], fikk ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Forventet undefined',
-    neverType: 'Never-type kan ikke parses',
-    // New advanced type validation messages
-    invalidBigint: 'Ugyldig bigint',
-    invalidSymbol: 'Ugyldig symbol',
-    invalidTuple: 'Ugyldig tuppel',
-    tupleLength: (expected, received) => `Tuppel må ha nøyaktig ${expected} elementer, fikk ${received}`,
-    invalidRecord: 'Ugyldig post',
-    invalidSet: 'Ugyldig Set',
-    invalidMap: 'Ugyldig Map',
-    // Transformation and refinement messages
-    transformError: (error) => `Transformasjon mislyktes: ${error}`,
-    refinementError: (error) => `Foredling mislyktes: ${error}`,
-    customValidationError: (error) => `Tilpasset validering mislyktes: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Kan ikke konvertere ${JSON.stringify(value)} til ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Forventet ${expected}, fikk ${received}`,
-    stringBoolExpected: (validValues, received) => `Ugyldig boolean streng. En av følgende forventet: ${validValues}, fikk: "${received}"`,
-    invalidJson: 'Ugyldig JSON',
-    stringPatternInvalid: 'Strengen samsvarer ikke med det nødvendige mønsteret',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'En funksjon forventes',
-    // CIDR validation messages
-    stringCidrv4: 'Ugyldig IPv4 CIDR-blokk',
-    stringCidrv6: 'Ugyldig IPv6 CIDR-blokk',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Kan ikke overskrive eksisterende nøkler: ${keys.join(', ')}. Bruk extend() for å overskrive.`
-};
-
-var no$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    no: no
-});
-
-const fi = {
-    // String validation messages
-    invalidString: 'Virheellinen merkkijono',
-    stringMin: (min) => `Merkkijonon tulee olla vähintään ${min} merkkiä pitkä`,
-    stringMax: (max) => `Merkkijono saa olla enintään ${max} merkkiä pitkä`,
-    stringLength: (length) => `Merkkijonon tulee olla täsmälleen ${length} merkkiä pitkä`,
-    stringEmail: 'Virheellinen sähköpostiosoite',
-    stringUrl: 'Virheellinen URL',
-    stringUuid: 'Virheellinen UUID',
-    stringRegex: 'Virheellinen muoto',
-    stringStartsWith: (prefix) => `Merkkijonon tulee alkaa merkeillä "${prefix}"`,
-    stringEndsWith: (suffix) => `Merkkijonon tulee päättyä merkkeihin "${suffix}"`,
-    stringIncludes: (substring) => `Merkkijonon tulee sisältää "${substring}"`,
-    stringIp: 'Virheellinen IP-osoite',
-    stringIpv4: 'Virheellinen IPv4-osoite',
-    stringIpv6: 'Virheellinen IPv6-osoite',
-    stringEmpty: 'Merkkijono ei saa olla tyhjä',
-    // Number validation messages
-    invalidNumber: 'Virheellinen luku',
-    numberMin: (min) => `Luvun tulee olla vähintään ${min}`,
-    numberMax: (max) => `Luku saa olla enintään ${max}`,
-    numberInt: 'Luvun tulee olla kokonaisluku',
-    numberPositive: 'Luvun tulee olla positiivinen',
-    numberNegative: 'Luvun tulee olla negatiivinen',
-    numberNonnegative: 'Luku ei saa olla negatiivinen',
-    numberNonpositive: 'Luku ei saa olla positiivinen',
-    numberFinite: 'Luvun tulee olla äärellinen',
-    numberSafe: 'Luvun tulee olla turvallinen kokonaisluku',
-    numberMultipleOf: (value) => `Luvun tulee olla ${value}:n kerrannainen`,
-    // Boolean validation messages
-    invalidBoolean: 'Virheellinen totuusarvo',
-    // Date validation messages
-    invalidDate: 'Virheellinen päivämäärä',
-    dateMin: (date) => `Päivämäärän tulee olla ${date.toISOString()} jälkeen`,
-    dateMax: (date) => `Päivämäärän tulee olla ennen ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Virheellinen objekti',
-    unexpectedKeys: (keys) => `Odottamattomat avaimet: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Virheellinen taulukko',
-    arrayMin: (min) => `Taulukossa tulee olla vähintään ${min} alkiota`,
-    arrayMax: (max) => `Taulukossa saa olla enintään ${max} alkiota`,
-    arrayLength: (length) => `Taulukossa tulee olla täsmälleen ${length} alkiota`,
-    arrayEmpty: 'Taulukko ei saa olla tyhjä',
-    arrayItem: (index, error) => `Virheellinen alkio indeksissä ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Virheellinen kenttä "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Mikään union-jäsen ei täsmännyt: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Intersection validointi epäonnistui: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Odotettiin ${expected}, saatiin ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Odotettiin yhtä arvoista [${values.join(', ')}], saatiin ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Odotettiin undefined',
-    neverType: 'Never-tyyppiä ei voida jäsentää',
-    // New advanced type validation messages
-    invalidBigint: 'Virheellinen bigint',
-    invalidSymbol: 'Virheellinen symboli',
-    invalidTuple: 'Virheellinen monikko',
-    tupleLength: (expected, received) => `Monikossa tulee olla täsmälleen ${expected} alkiota, saatiin ${received}`,
-    invalidRecord: 'Virheellinen tietue',
-    invalidSet: 'Virheellinen Set',
-    invalidMap: 'Virheellinen Map',
-    // Transformation and refinement messages
-    transformError: (error) => `Muunnos epäonnistui: ${error}`,
-    refinementError: (error) => `Hiominen epäonnistui: ${error}`,
-    customValidationError: (error) => `Mukautettu validointi epäonnistui: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Arvoa ${JSON.stringify(value)} ei voida pakottaa tyyppiin ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Odotettiin ${expected}, saatiin ${received}`,
-    stringBoolExpected: (validValues, received) => `Virheellinen boolean-merkkijono. Yksi seuraavista odotettu: ${validValues}, saatiin: "${received}"`,
-    invalidJson: 'Virheellinen JSON',
-    stringPatternInvalid: 'Merkkijono ei vastaa vaadittua kuviota',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'Funktiota odotetaan',
-    // CIDR validation messages
-    stringCidrv4: 'Virheellinen IPv4 CIDR-lohko',
-    stringCidrv6: 'Virheellinen IPv6 CIDR-lohko',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Olemassa olevia avaimia ei voi ylikirjoittaa: ${keys.join(', ')}. Käytä extend() ylikirjoittamiseen.`
-};
-
-var fi$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    fi: fi
-});
-
-const th = {
-    // String validation messages
-    invalidString: 'ข้อความไม่ถูกต้อง',
-    stringMin: (min) => `ข้อความต้องมีความยาวอย่างน้อย ${min} ตัวอักษร`,
-    stringMax: (max) => `ข้อความต้องมีความยาวไม่เกิน ${max} ตัวอักษร`,
-    stringLength: (length) => `ข้อความต้องมีความยาวเท่ากับ ${length} ตัวอักษร`,
-    stringEmail: 'อีเมลไม่ถูกต้อง',
-    stringUrl: 'URL ไม่ถูกต้อง',
-    stringUuid: 'UUID ไม่ถูกต้อง',
-    stringRegex: 'รูปแบบไม่ถูกต้อง',
-    stringStartsWith: (prefix) => `ข้อความต้องเริ่มต้นด้วย "${prefix}"`,
-    stringEndsWith: (suffix) => `ข้อความต้องลงท้ายด้วย "${suffix}"`,
-    stringIncludes: (substring) => `ข้อความต้องมี "${substring}"`,
-    stringIp: 'IP address ไม่ถูกต้อง',
-    stringIpv4: 'IPv4 address ไม่ถูกต้อง',
-    stringIpv6: 'IPv6 address ไม่ถูกต้อง',
-    stringEmpty: 'ข้อความไม่สามารถเป็นค่าว่างได้',
-    // Number validation messages
-    invalidNumber: 'ตัวเลขไม่ถูกต้อง',
-    numberMin: (min) => `ตัวเลขต้องมีค่าอย่างน้อย ${min}`,
-    numberMax: (max) => `ตัวเลขต้องมีค่าไม่เกิน ${max}`,
-    numberInt: 'ตัวเลขต้องเป็นจำนวนเต็ม',
-    numberPositive: 'ตัวเลขต้องเป็นค่าบวก',
-    numberNegative: 'ตัวเลขต้องเป็นค่าลบ',
-    numberNonnegative: 'ตัวเลขไม่สามารถเป็นค่าลบได้',
-    numberNonpositive: 'ตัวเลขไม่สามารถเป็นค่าบวกได้',
-    numberFinite: 'ตัวเลขต้องเป็นค่าจำกัด',
-    numberSafe: 'ตัวเลขต้องเป็นจำนวนเต็มที่ปลอดภัย',
-    numberMultipleOf: (value) => `ตัวเลขต้องเป็นหลายเท่าของ ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'ค่า Boolean ไม่ถูกต้อง',
-    // Date validation messages
-    invalidDate: 'วันที่ไม่ถูกต้อง',
-    dateMin: (date) => `วันที่ต้องหลังจาก ${date.toISOString()}`,
-    dateMax: (date) => `วันที่ต้องก่อน ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Object ไม่ถูกต้อง',
-    unexpectedKeys: (keys) => `Key ที่ไม่คาดหวัง: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Array ไม่ถูกต้อง',
-    arrayMin: (min) => `Array ต้องมีสมาชิกอย่างน้อย ${min} ตัว`,
-    arrayMax: (max) => `Array ต้องมีสมาชิกไม่เกิน ${max} ตัว`,
-    arrayLength: (length) => `Array ต้องมีสมาชิกเท่ากับ ${length} ตัว`,
-    arrayEmpty: 'Array ไม่สามารถเป็นค่าว่างได้',
-    arrayItem: (index, error) => `สมาชิกที่ตำแหน่ง ${index} ไม่ถูกต้อง: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `ฟิลด์ "${field}" ไม่ถูกต้อง: ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `ไม่มี union member ที่ตรงกัน: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `การตรวจสอบ intersection ล้มเหลว: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `คาดหวัง ${expected}, ได้รับ ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `คาดหวังค่าใดค่าหนึ่งจาก [${values.join(', ')}], ได้รับ ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'คาดหวัง undefined',
-    neverType: 'ไม่สามารถ parse ประเภท never ได้',
-    // New advanced type validation messages
-    invalidBigint: 'bigint ไม่ถูกต้อง',
-    invalidSymbol: 'symbol ไม่ถูกต้อง',
-    invalidTuple: 'tuple ไม่ถูกต้อง',
-    tupleLength: (expected, received) => `tuple ต้องมีสมาชิกเท่ากับ ${expected} ตัว, ได้รับ ${received} ตัว`,
-    invalidRecord: 'record ไม่ถูกต้อง',
-    invalidSet: 'Set ไม่ถูกต้อง',
-    invalidMap: 'Map ไม่ถูกต้อง',
-    // Transformation and refinement messages
-    transformError: (error) => `การแปลงล้มเหลว: ${error}`,
-    refinementError: (error) => `การปรับแต่งล้มเหลว: ${error}`,
-    customValidationError: (error) => `การตรวจสอบแบบกำหนดเองล้มเหลว: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `ไม่สามารถแปลง ${JSON.stringify(value)} เป็น ${type} ได้`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `คาดหวัง ${expected}, ได้รับ ${received}`,
-    stringBoolExpected: (validValues, received) => `สตริงบูลีนไม่ถูกต้อง คาดว่าจะเป็นหนึ่งในนั้น: ${validValues}, ได้รับ: "${received}"`,
-    invalidJson: 'JSON ไม่ถูกต้อง',
-    stringPatternInvalid: 'สตริงไม่ตรงกับรูปแบบที่จำเป็น',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'คาดหวังฟังก์ชัน',
-    // CIDR validation messages
-    stringCidrv4: 'บล็อก CIDR IPv4 ไม่ถูกต้อง',
-    stringCidrv6: 'บล็อก CIDR IPv6 ไม่ถูกต้อง',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `ไม่สามารถเขียนทับคีย์ที่มีอยู่: ${keys.join(', ')}. ใช้ extend() เพื่อเขียนทับ`
-};
-
-var th$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    th: th
-});
-
-const vi = {
-    // String validation messages
-    invalidString: 'Chuỗi không hợp lệ',
-    stringMin: (min) => `Chuỗi phải có ít nhất ${min} ký tự`,
-    stringMax: (max) => `Chuỗi không được quá ${max} ký tự`,
-    stringLength: (length) => `Chuỗi phải có chính xác ${length} ký tự`,
-    stringEmail: 'Địa chỉ email không hợp lệ',
-    stringUrl: 'URL không hợp lệ',
-    stringUuid: 'UUID không hợp lệ',
-    stringRegex: 'Định dạng không hợp lệ',
-    stringStartsWith: (prefix) => `Chuỗi phải bắt đầu bằng "${prefix}"`,
-    stringEndsWith: (suffix) => `Chuỗi phải kết thúc bằng "${suffix}"`,
-    stringIncludes: (substring) => `Chuỗi phải chứa "${substring}"`,
-    stringIp: 'Địa chỉ IP không hợp lệ',
-    stringIpv4: 'Địa chỉ IPv4 không hợp lệ',
-    stringIpv6: 'Địa chỉ IPv6 không hợp lệ',
-    stringEmpty: 'Chuỗi không được để trống',
-    // Number validation messages
-    invalidNumber: 'Số không hợp lệ',
-    numberMin: (min) => `Số phải ít nhất là ${min}`,
-    numberMax: (max) => `Số không được vượt quá ${max}`,
-    numberInt: 'Số phải là số nguyên',
-    numberPositive: 'Số phải là số dương',
-    numberNegative: 'Số phải là số âm',
-    numberNonnegative: 'Số không được là số âm',
-    numberNonpositive: 'Số không được là số dương',
-    numberFinite: 'Số phải là số hữu hạn',
-    numberSafe: 'Số phải là số nguyên an toàn',
-    numberMultipleOf: (value) => `Số phải là bội số của ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'Giá trị boolean không hợp lệ',
-    // Date validation messages
-    invalidDate: 'Ngày không hợp lệ',
-    dateMin: (date) => `Ngày phải sau ${date.toISOString()}`,
-    dateMax: (date) => `Ngày phải trước ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Đối tượng không hợp lệ',
-    unexpectedKeys: (keys) => `Khóa không mong muốn: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Mảng không hợp lệ',
-    arrayMin: (min) => `Mảng phải có ít nhất ${min} phần tử`,
-    arrayMax: (max) => `Mảng không được quá ${max} phần tử`,
-    arrayLength: (length) => `Mảng phải có chính xác ${length} phần tử`,
-    arrayEmpty: 'Mảng không được để trống',
-    arrayItem: (index, error) => `Phần tử không hợp lệ tại vị trí ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Trường "${field}" không hợp lệ: ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Không có thành viên union nào khớp: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Xác thực intersection thất bại: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Mong đợi ${expected}, nhận được ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Mong đợi một trong [${values.join(', ')}], nhận được ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Mong đợi undefined',
-    neverType: 'Không thể phân tích kiểu never',
-    // New advanced type validation messages
-    invalidBigint: 'Bigint không hợp lệ',
-    invalidSymbol: 'Ký hiệu không hợp lệ',
-    invalidTuple: 'Tuple không hợp lệ',
-    tupleLength: (expected, received) => `Tuple phải có chính xác ${expected} phần tử, nhận được ${received}`,
-    invalidRecord: 'Record không hợp lệ',
-    invalidSet: 'Set không hợp lệ',
-    invalidMap: 'Map không hợp lệ',
-    // Transformation and refinement messages
-    transformError: (error) => `Biến đổi thất bại: ${error}`,
-    refinementError: (error) => `Tinh chế thất bại: ${error}`,
-    customValidationError: (error) => `Xác thực tùy chỉnh thất bại: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Không thể ép kiểu ${JSON.stringify(value)} thành ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Mong đợi ${expected}, nhận được ${received}`,
-    stringBoolExpected: (validValues, received) => `Chuỗi boolean không hợp lệ. Mong đợi một trong các: ${validValues}, nhận được: "${received}"`,
-    invalidJson: 'JSON không hợp lệ',
-    stringPatternInvalid: 'Chuỗi không khớp với mẫu bắt buộc',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'Mong đợi một hàm',
-    // CIDR validation messages
-    stringCidrv4: 'Khối CIDR IPv4 không hợp lệ',
-    stringCidrv6: 'Khối CIDR IPv6 không hợp lệ',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Không thể ghi đè các khóa hiện có: ${keys.join(', ')}. Sử dụng extend() để ghi đè.`
-};
-
-var vi$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    vi: vi
-});
-
-const id = {
-    // String validation messages
-    invalidString: 'String tidak valid',
-    stringMin: (min) => `String harus memiliki minimal ${min} karakter`,
-    stringMax: (max) => `String tidak boleh lebih dari ${max} karakter`,
-    stringLength: (length) => `String harus memiliki tepat ${length} karakter`,
-    stringEmail: 'Alamat email tidak valid',
-    stringUrl: 'URL tidak valid',
-    stringUuid: 'UUID tidak valid',
-    stringRegex: 'Format tidak valid',
-    stringStartsWith: (prefix) => `String harus diawali dengan "${prefix}"`,
-    stringEndsWith: (suffix) => `String harus diakhiri dengan "${suffix}"`,
-    stringIncludes: (substring) => `String harus mengandung "${substring}"`,
-    stringIp: 'Alamat IP tidak valid',
-    stringIpv4: 'Alamat IPv4 tidak valid',
-    stringIpv6: 'Alamat IPv6 tidak valid',
-    stringEmpty: 'String tidak boleh kosong',
-    // Number validation messages
-    invalidNumber: 'Angka tidak valid',
-    numberMin: (min) => `Angka harus minimal ${min}`,
-    numberMax: (max) => `Angka tidak boleh lebih dari ${max}`,
-    numberInt: 'Angka harus berupa bilangan bulat',
-    numberPositive: 'Angka harus positif',
-    numberNegative: 'Angka harus negatif',
-    numberNonnegative: 'Angka tidak boleh negatif',
-    numberNonpositive: 'Angka tidak boleh positif',
-    numberFinite: 'Angka harus terhingga',
-    numberSafe: 'Angka harus berupa bilangan bulat yang aman',
-    numberMultipleOf: (value) => `Angka harus kelipatan dari ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'Nilai boolean tidak valid',
-    // Date validation messages
-    invalidDate: 'Tanggal tidak valid',
-    dateMin: (date) => `Tanggal harus setelah ${date.toISOString()}`,
-    dateMax: (date) => `Tanggal harus sebelum ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Object tidak valid',
-    unexpectedKeys: (keys) => `Kunci yang tidak diharapkan: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Array tidak valid',
-    arrayMin: (min) => `Array harus memiliki minimal ${min} elemen`,
-    arrayMax: (max) => `Array tidak boleh lebih dari ${max} elemen`,
-    arrayLength: (length) => `Array harus memiliki tepat ${length} elemen`,
-    arrayEmpty: 'Array tidak boleh kosong',
-    arrayItem: (index, error) => `Elemen tidak valid pada indeks ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Field "${field}" tidak valid: ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Tidak ada anggota union yang cocok: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Validasi intersection gagal: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Diharapkan ${expected}, diterima ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Diharapkan salah satu dari [${values.join(', ')}], diterima ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Diharapkan undefined',
-    neverType: 'Tipe never tidak dapat diparse',
-    // New advanced type validation messages
-    invalidBigint: 'Bigint tidak valid',
-    invalidSymbol: 'Simbol tidak valid',
-    invalidTuple: 'Tuple tidak valid',
-    tupleLength: (expected, received) => `Tuple harus memiliki tepat ${expected} elemen, diterima ${received}`,
-    invalidRecord: 'Record tidak valid',
-    invalidSet: 'Set tidak valid',
-    invalidMap: 'Map tidak valid',
-    // Transformation and refinement messages
-    transformError: (error) => `Transformasi gagal: ${error}`,
-    refinementError: (error) => `Penyempurnaan gagal: ${error}`,
-    customValidationError: (error) => `Validasi kustom gagal: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Tidak dapat memaksa ${JSON.stringify(value)} menjadi ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Diharapkan ${expected}, diterima ${received}`,
-    stringBoolExpected: (validValues, received) => `String boolean tidak valid. Salah satu dari berikut diharapkan: ${validValues}, diterima: "${received}"`,
-    invalidJson: 'JSON tidak valid',
-    stringPatternInvalid: 'String tidak cocok dengan pola yang diperlukan',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'Fungsi diharapkan',
-    // CIDR validation messages
-    stringCidrv4: 'Blok CIDR IPv4 tidak valid',
-    stringCidrv6: 'Blok CIDR IPv6 tidak valid',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Tidak dapat menimpa kunci yang sudah ada: ${keys.join(', ')}. Gunakan extend() untuk menimpa.`
-};
-
-var id$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    id: id
-});
-
-const bn = {
-    // String validation messages
-    invalidString: 'অবৈধ স্ট্রিং',
-    stringMin: (min) => `স্ট্রিং কমপক্ষে ${min} অক্ষরের হতে হবে`,
-    stringMax: (max) => `স্ট্রিং সর্বোচ্চ ${max} অক্ষরের হতে পারে`,
-    stringLength: (length) => `স্ট্রিং ঠিক ${length} অক্ষরের হতে হবে`,
-    stringEmail: 'অবৈধ ইমেইল ঠিকানা',
-    stringUrl: 'অবৈধ URL',
-    stringUuid: 'অবৈধ UUID',
-    stringRegex: 'অবৈধ ফরম্যাট',
-    stringStartsWith: (prefix) => `স্ট্রিং "${prefix}" দিয়ে শুরু হতে হবে`,
-    stringEndsWith: (suffix) => `স্ট্রিং "${suffix}" দিয়ে শেষ হতে হবে`,
-    stringIncludes: (substring) => `স্ট্রিং-এ "${substring}" থাকতে হবে`,
-    stringIp: 'অবৈধ IP ঠিকানা',
-    stringIpv4: 'অবৈধ IPv4 ঠিকানা',
-    stringIpv6: 'অবৈধ IPv6 ঠিকানা',
-    stringEmpty: 'স্ট্রিং খালি হতে পারবে না',
-    // Number validation messages
-    invalidNumber: 'অবৈধ সংখ্যা',
-    numberMin: (min) => `সংখ্যা কমপক্ষে ${min} হতে হবে`,
-    numberMax: (max) => `সংখ্যা সর্বোচ্চ ${max} হতে পারে`,
-    numberInt: 'সংখ্যাটি একটি পূর্ণসংখ্যা হতে হবে',
-    numberPositive: 'সংখ্যাটি ধনাত্মক হতে হবে',
-    numberNegative: 'সংখ্যাটি ঋণাত্মক হতে হবে',
-    numberNonnegative: 'সংখ্যাটি ঋণাত্মক হতে পারবে না',
-    numberNonpositive: 'সংখ্যাটি ধনাত্মক হতে পারবে না',
-    numberFinite: 'সংখ্যাটি সসীম হতে হবে',
-    numberSafe: 'সংখ্যাটি একটি নিরাপদ পূর্ণসংখ্যা হতে হবে',
-    numberMultipleOf: (value) => `সংখ্যাটি ${value} এর গুণিতক হতে হবে`,
-    // Boolean validation messages
-    invalidBoolean: 'অবৈধ বুলিয়ান মান',
-    // Date validation messages
-    invalidDate: 'অবৈধ তারিখ',
-    dateMin: (date) => `তারিখ ${date.toISOString()} এর পরে হতে হবে`,
-    dateMax: (date) => `তারিখ ${date.toISOString()} এর আগে হতে হবে`,
-    // Object validation messages
-    invalidObject: 'অবৈধ অবজেক্ট',
-    unexpectedKeys: (keys) => `অপ্রত্যাশিত কী: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'অবৈধ অ্যারে',
-    arrayMin: (min) => `অ্যারে-তে কমপক্ষে ${min}টি উপাদান থাকতে হবে`,
-    arrayMax: (max) => `অ্যারে-তে সর্বোচ্চ ${max}টি উপাদান থাকতে পারে`,
-    arrayLength: (length) => `অ্যারে-তে ঠিক ${length}টি উপাদান থাকতে হবে`,
-    arrayEmpty: 'অ্যারে খালি হতে পারবে না',
-    arrayItem: (index, error) => `${index} ইনডেক্সে অবৈধ উপাদান: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `অবৈধ ফিল্ড "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `কোন ইউনিয়ন সদস্য মিলেনি: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `ইন্টারসেকশন যাচাই ব্যর্থ: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `প্রত্যাশিত ${expected}, পেয়েছি ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `[${values.join(', ')}] এর মধ্যে একটি প্রত্যাশিত, পেয়েছি ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'undefined প্রত্যাশিত',
-    neverType: 'Never টাইপ পার্স করা যায় না',
-    // New advanced type validation messages
-    invalidBigint: 'অবৈধ bigint',
-    invalidSymbol: 'অবৈধ সিম্বল',
-    invalidTuple: 'অবৈধ টুপল',
-    tupleLength: (expected, received) => `টুপলে ঠিক ${expected}টি উপাদান থাকতে হবে, পেয়েছি ${received}`,
-    invalidRecord: 'অবৈধ রেকর্ড',
-    invalidSet: 'অবৈধ Set',
-    invalidMap: 'অবৈধ Map',
-    // Transformation and refinement messages
-    transformError: (error) => `রূপান্তর ব্যর্থ: ${error}`,
-    refinementError: (error) => `পরিমার্জনা ব্যর্থ: ${error}`,
-    customValidationError: (error) => `কাস্টম যাচাইকরণ ব্যর্থ: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `${JSON.stringify(value)} কে ${type} এ রূপান্তর করা যায়নি`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `প্রত্যাশিত ${expected}, পেয়েছি ${received}`,
-    stringBoolExpected: (validValues, received) => `অবৈধ বুলিয়ান স্ট্রিং। নিম্নলিখিতগুলির একটি প্রত্যাশিত: ${validValues}, পেয়েছি: "${received}"`,
-    invalidJson: 'অবৈধ JSON',
-    stringPatternInvalid: 'স্ট্রিংটি প্রয়োজনীয় প্যাটার্নের সাথে মেলে না',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'একটি ফাংশন প্রত্যাশিত',
-    // CIDR validation messages
-    stringCidrv4: 'অবৈধ IPv4 CIDR ব্লক',
-    stringCidrv6: 'অবৈধ IPv6 CIDR ব্লক',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `বিদ্যমান কীগুলি ওভাররাইড করা যায় না: ${keys.join(', ')}। ওভাররাইড করতে extend() ব্যবহার করুন।`
-};
-
-var bn$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    bn: bn
-});
-
-const sw = {
-    // String validation messages
-    invalidString: 'Mfuatano usio sahihi',
-    stringMin: (min) => `Mfuatano lazima uwe na angalau vibambo ${min}`,
-    stringMax: (max) => `Mfuatano hauwezi kuwa na zaidi ya vibambo ${max}`,
-    stringLength: (length) => `Mfuatano lazima uwe na vibambo ${length} haswa`,
-    stringEmail: 'Anwani ya barua pepe si sahihi',
-    stringUrl: 'URL si sahihi',
-    stringUuid: 'UUID si sahihi',
-    stringRegex: 'Muundo usio sahihi',
-    stringStartsWith: (prefix) => `Mfuatano lazima uanze na "${prefix}"`,
-    stringEndsWith: (suffix) => `Mfuatano lazima umalize na "${suffix}"`,
-    stringIncludes: (substring) => `Mfuatano lazima ujumuishe "${substring}"`,
-    stringIp: 'Anwani ya IP si sahihi',
-    stringIpv4: 'Anwani ya IPv4 si sahihi',
-    stringIpv6: 'Anwani ya IPv6 si sahihi',
-    stringEmpty: 'Mfuatano hauwezi kuwa tupu',
-    // Number validation messages
-    invalidNumber: 'Nambari si sahihi',
-    numberMin: (min) => `Nambari lazima iwe angalau ${min}`,
-    numberMax: (max) => `Nambari haiwezi kuwa zaidi ya ${max}`,
-    numberInt: 'Nambari lazima iwe nzima',
-    numberPositive: 'Nambari lazima iwe chanya',
-    numberNegative: 'Nambari lazima iwe hasi',
-    numberNonnegative: 'Nambari haiwezi kuwa hasi',
-    numberNonpositive: 'Nambari haiwezi kuwa chanya',
-    numberFinite: 'Nambari lazima iwe ya mwisho',
-    numberSafe: 'Nambari lazima iwe nzima salama',
-    numberMultipleOf: (value) => `Nambari lazima iwe mzidadi wa ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'Thamani ya boolean si sahihi',
-    // Date validation messages
-    invalidDate: 'Tarehe si sahihi',
-    dateMin: (date) => `Tarehe lazima iwe baada ya ${date.toISOString()}`,
-    dateMax: (date) => `Tarehe lazima iwe kabla ya ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Kitu si sahihi',
-    unexpectedKeys: (keys) => `Funguo zisizotarajiwa: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Safu si sahihi',
-    arrayMin: (min) => `Safu lazima iwe na angalau vipengele ${min}`,
-    arrayMax: (max) => `Safu haiwezi kuwa na zaidi ya vipengele ${max}`,
-    arrayLength: (length) => `Safu lazima iwe na vipengele ${length} haswa`,
-    arrayEmpty: 'Safu haiwezi kuwa tupu',
-    arrayItem: (index, error) => `Kipengele kisicho sahihi kwenye uhurizo ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Uwanda "${field}" usio sahihi: ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Hakuna mwanachama wa umoja aliyelingana: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Uthibitisho wa intersection umeshindwa: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Ilitegemewa ${expected}, ilipokewa ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Ilitegemewa moja ya [${values.join(', ')}], ilipokewa ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Ilitegemewa undefined',
-    neverType: 'Aina ya never haiwezi kuchakatwa',
-    // New advanced type validation messages
-    invalidBigint: 'Bigint si sahihi',
-    invalidSymbol: 'Ishara si sahihi',
-    invalidTuple: 'Jozi si sahihi',
-    tupleLength: (expected, received) => `Jozi lazima iwe na vipengele ${expected} haswa, ilipokewa ${received}`,
-    invalidRecord: 'Rekodi si sahihi',
-    invalidSet: 'Set si sahihi',
-    invalidMap: 'Ramani si sahihi',
-    // Transformation and refinement messages
-    transformError: (error) => `Mageuzi yameshindwa: ${error}`,
-    refinementError: (error) => `Uboresha umeshindwa: ${error}`,
-    customValidationError: (error) => `Uthibitisho wa kawaida umeshindwa: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Haiwezi kulazimisha ${JSON.stringify(value)} kuwa ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Ilitegemewa ${expected}, ilipokewa ${received}`,
-    stringBoolExpected: (validValues, received) => `Mfuatano wa boolean usio sahihi. Moja ya zifuatazo ilitegemewa: ${validValues}, ilipokewa: "${received}"`,
-    invalidJson: 'JSON si sahihi',
-    stringPatternInvalid: 'Mfuatano haufanani na mfano uliohitajika',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'Kazi inatarajiwa',
-    // CIDR validation messages
-    stringCidrv4: 'Kizuizi cha CIDR IPv4 si sahihi',
-    stringCidrv6: 'Kizuizi cha CIDR IPv6 si sahihi',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Haiwezi kuandika juu ya funguo zilizo tayari: ${keys.join(', ')}. Tumia extend() kuandika juu.`
-};
-
-var sw$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    sw: sw
-});
-
-const af = {
-    // String validation messages
-    invalidString: 'Ongeldige string',
-    stringMin: (min) => `String moet ten minste ${min} karakters lank wees`,
-    stringMax: (max) => `String mag hoogstens ${max} karakters lank wees`,
-    stringLength: (length) => `String moet presies ${length} karakters lank wees`,
-    stringEmail: 'Ongeldige e-pos adres',
-    stringUrl: 'Ongeldige URL',
-    stringUuid: 'Ongeldige UUID',
-    stringRegex: 'Ongeldige formaat',
-    stringStartsWith: (prefix) => `String moet begin met "${prefix}"`,
-    stringEndsWith: (suffix) => `String moet eindig met "${suffix}"`,
-    stringIncludes: (substring) => `String moet "${substring}" bevat`,
-    stringIp: 'Ongeldige IP adres',
-    stringIpv4: 'Ongeldige IPv4 adres',
-    stringIpv6: 'Ongeldige IPv6 adres',
-    stringEmpty: 'String mag nie leeg wees nie',
-    // Number validation messages
-    invalidNumber: 'Ongeldige getal',
-    numberMin: (min) => `Getal moet ten minste ${min} wees`,
-    numberMax: (max) => `Getal mag hoogstens ${max} wees`,
-    numberInt: "Getal moet 'n heelgetal wees",
-    numberPositive: 'Getal moet positief wees',
-    numberNegative: 'Getal moet negatief wees',
-    numberNonnegative: 'Getal mag nie negatief wees nie',
-    numberNonpositive: 'Getal mag nie positief wees nie',
-    numberFinite: 'Getal moet eindig wees',
-    numberSafe: "Getal moet 'n veilige heelgetal wees",
-    numberMultipleOf: (value) => `Getal moet 'n veelvoud van ${value} wees`,
-    // Boolean validation messages
-    invalidBoolean: 'Ongeldige boolean waarde',
-    // Date validation messages
-    invalidDate: 'Ongeldige datum',
-    dateMin: (date) => `Datum moet na ${date.toISOString()} wees`,
-    dateMax: (date) => `Datum moet voor ${date.toISOString()} wees`,
-    // Object validation messages
-    invalidObject: 'Ongeldige objek',
-    unexpectedKeys: (keys) => `Onverwagte sleutels: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Ongeldige skikking',
-    arrayMin: (min) => `Skikking moet ten minste ${min} elemente hê`,
-    arrayMax: (max) => `Skikking mag hoogstens ${max} elemente hê`,
-    arrayLength: (length) => `Skikking moet presies ${length} elemente hê`,
-    arrayEmpty: 'Skikking mag nie leeg wees nie',
-    arrayItem: (index, error) => `Ongeldige element by indeks ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Ongeldige veld "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Geen union lid het gepas nie: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Intersection validasie het gefaal: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Verwag ${expected}, ontvang ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Verwag een van [${values.join(', ')}], ontvang ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Verwag undefined',
-    neverType: 'Never tipe kan nie geparseer word nie',
-    // New advanced type validation messages
-    invalidBigint: 'Ongeldige bigint',
-    invalidSymbol: 'Ongeldige simbool',
-    invalidTuple: 'Ongeldige tupel',
-    tupleLength: (expected, received) => `Tupel moet presies ${expected} elemente hê, ontvang ${received}`,
-    invalidRecord: 'Ongeldige rekord',
-    invalidSet: 'Ongeldige Set',
-    invalidMap: 'Ongeldige Map',
-    // Transformation and refinement messages
-    transformError: (error) => `Transformasie het gefaal: ${error}`,
-    refinementError: (error) => `Verfyning het gefaal: ${error}`,
-    customValidationError: (error) => `Pasgemaakte validasie het misluk: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Kan nie ${JSON.stringify(value)} na ${type} dwing nie`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Verwag ${expected}, ontvang ${received}`,
-    stringBoolExpected: (validValues, received) => `Ongeldige boolean string. Een van die volgende verwag: ${validValues}, ontvang: "${received}"`,
-    invalidJson: 'Ongeldige JSON',
-    stringPatternInvalid: 'String stem nie ooreen met die vereiste patroon nie',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(', ')}`,
-    // Function validation messages
-    invalidFunction: "'n Funksie word verwag",
-    // CIDR validation messages
-    stringCidrv4: 'Ongeldige IPv4 CIDR-blok',
-    stringCidrv6: 'Ongeldige IPv6 CIDR-blok',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Kan nie bestaande sleutels oorskryf nie: ${keys.join(', ')}. Gebruik extend() om te oorskryf.`
-};
-
-var af$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    af: af
-});
-
-const ptBR = {
-    // String validation messages
-    invalidString: 'String inválida',
-    stringMin: (min) => `String deve ter pelo menos ${min} caracteres`,
-    stringMax: (max) => `String não pode ter mais que ${max} caracteres`,
-    stringLength: (length) => `String deve ter exatamente ${length} caracteres`,
-    stringEmail: 'Endereço de e-mail inválido',
-    stringUrl: 'URL inválida',
-    stringUuid: 'UUID inválido',
-    stringRegex: 'Formato inválido',
-    stringStartsWith: (prefix) => `String deve começar com "${prefix}"`,
-    stringEndsWith: (suffix) => `String deve terminar com "${suffix}"`,
-    stringIncludes: (substring) => `String deve conter "${substring}"`,
-    stringIp: 'Endereço IP inválido',
-    stringIpv4: 'Endereço IPv4 inválido',
-    stringIpv6: 'Endereço IPv6 inválido',
-    stringEmpty: 'String não pode estar vazia',
-    // Number validation messages
-    invalidNumber: 'Número inválido',
-    numberMin: (min) => `Número deve ser pelo menos ${min}`,
-    numberMax: (max) => `Número não pode ser maior que ${max}`,
-    numberInt: 'Número deve ser um inteiro',
-    numberPositive: 'Número deve ser positivo',
-    numberNegative: 'Número deve ser negativo',
-    numberNonnegative: 'Número não pode ser negativo',
-    numberNonpositive: 'Número não pode ser positivo',
-    numberFinite: 'Número deve ser finito',
-    numberSafe: 'Número deve ser um inteiro seguro',
-    numberMultipleOf: (value) => `Número deve ser múltiplo de ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'Valor booleano inválido',
-    // Date validation messages
-    invalidDate: 'Data inválida',
-    dateMin: (date) => `Data deve ser após ${date.toISOString()}`,
-    dateMax: (date) => `Data deve ser antes de ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Objeto inválido',
-    unexpectedKeys: (keys) => `Chaves inesperadas: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Array inválido',
-    arrayMin: (min) => `Array deve ter pelo menos ${min} elementos`,
-    arrayMax: (max) => `Array não pode ter mais que ${max} elementos`,
-    arrayLength: (length) => `Array deve ter exatamente ${length} elementos`,
-    arrayEmpty: 'Array não pode estar vazio',
-    arrayItem: (index, error) => `Item inválido no índice ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Campo inválido "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Nenhum membro da união correspondeu: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Validação de intersecção falhou: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Esperado ${expected}, recebido ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Esperado um de [${values.join(', ')}], recebido ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Esperado undefined',
-    neverType: 'Tipo never não pode ser analisado',
-    // New advanced type validation messages
-    invalidBigint: 'Bigint inválido',
-    invalidSymbol: 'Símbolo inválido',
-    invalidTuple: 'Tupla inválida',
-    tupleLength: (expected, received) => `Tupla deve ter exatamente ${expected} elementos, recebido ${received}`,
-    invalidRecord: 'Registro inválido',
-    invalidSet: 'Set inválido',
-    invalidMap: 'Map inválido',
-    // Transformation and refinement messages
-    transformError: (error) => `Transformação falhou: ${error}`,
-    refinementError: (error) => `Refinamento falhou: ${error}`,
-    customValidationError: (error) => `Validação personalizada falhou: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `Não é possível converter ${JSON.stringify(value)} para ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Esperado ${expected}, recebido ${received}`,
-    stringBoolExpected: (validValues, received) => `String boolean inválida. Esperado um de: ${validValues}, recebido: "${received}"`,
-    invalidJson: 'JSON inválido',
-    stringPatternInvalid: 'A string não corresponde ao padrão necessário',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(", ")}`,
-    // Function validation messages
-    invalidFunction: 'Uma função é esperada',
-    // CIDR validation messages
-    stringCidrv4: 'Bloco CIDR IPv4 inválido',
-    stringCidrv6: 'Bloco CIDR IPv6 inválido',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `Não é possível substituir chaves existentes: ${keys.join(', ')}. Use extend() se quiser substituir.`
-};
-
-var ptBR$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    ptBR: ptBR
-});
-
-const esMX = {
-    // String validation messages
-    invalidString: 'Cadena inválida',
-    stringMin: (min) => `La cadena debe tener al menos ${min} caracteres`,
-    stringMax: (max) => `La cadena no puede tener más de ${max} caracteres`,
-    stringLength: (length) => `La cadena debe tener exactamente ${length} caracteres`,
-    stringEmail: 'Dirección de correo inválida',
-    stringUrl: 'URL inválida',
-    stringUuid: 'UUID inválido',
-    stringRegex: 'Formato inválido',
-    stringStartsWith: (prefix) => `La cadena debe empezar con "${prefix}"`,
-    stringEndsWith: (suffix) => `La cadena debe terminar con "${suffix}"`,
-    stringIncludes: (substring) => `La cadena debe incluir "${substring}"`,
-    stringIp: 'Dirección IP inválida',
-    stringIpv4: 'Dirección IPv4 inválida',
-    stringIpv6: 'Dirección IPv6 inválida',
-    stringEmpty: 'La cadena no puede estar vacía',
-    // Number validation messages
-    invalidNumber: 'Número inválido',
-    numberMin: (min) => `El número debe ser al menos ${min}`,
-    numberMax: (max) => `El número no puede ser mayor a ${max}`,
-    numberInt: 'El número debe ser entero',
-    numberPositive: 'El número debe ser positivo',
-    numberNegative: 'El número debe ser negativo',
-    numberNonnegative: 'El número no puede ser negativo',
-    numberNonpositive: 'El número no puede ser positivo',
-    numberFinite: 'El número debe ser finito',
-    numberSafe: 'El número debe ser un entero seguro',
-    numberMultipleOf: (value) => `El número debe ser múltiplo de ${value}`,
-    // Boolean validation messages
-    invalidBoolean: 'Valor booleano inválido',
-    // Date validation messages
-    invalidDate: 'Fecha inválida',
-    dateMin: (date) => `La fecha debe ser después de ${date.toISOString()}`,
-    dateMax: (date) => `La fecha debe ser antes de ${date.toISOString()}`,
-    // Object validation messages
-    invalidObject: 'Objeto inválido',
-    unexpectedKeys: (keys) => `Claves inesperadas: ${keys.join(', ')}`,
-    // Array validation messages
-    invalidArray: 'Array inválido',
-    arrayMin: (min) => `El array debe tener al menos ${min} elementos`,
-    arrayMax: (max) => `El array no puede tener más de ${max} elementos`,
-    arrayLength: (length) => `El array debe tener exactamente ${length} elementos`,
-    arrayEmpty: 'El array no puede estar vacío',
-    arrayItem: (index, error) => `Elemento inválido en índice ${index}: ${error}`,
-    // Object field validation
-    objectField: (field, error) => `Campo inválido "${field}": ${error}`,
-    // Union validation messages
-    unionNoMatch: (errors) => `Ningún miembro de la unión coincidió: ${errors.join(', ')}`,
-    // Intersection validation messages
-    intersectionError: (error) => `Error de validación de intersección: ${error}`,
-    // Literal validation messages
-    literalExpected: (expected, received) => `Se esperaba ${expected}, se recibió ${received}`,
-    // Enum validation messages
-    enumExpected: (values, received) => `Se esperaba uno de [${values.join(', ')}], se recibió ${received}`,
-    // Special type validation messages
-    expectedUndefined: 'Se esperaba undefined',
-    neverType: 'El tipo never no se puede analizar',
-    // New advanced type validation messages
-    invalidBigint: 'Bigint inválido',
-    invalidSymbol: 'Símbolo inválido',
-    invalidTuple: 'Tupla inválida',
-    tupleLength: (expected, received) => `La tupla debe tener exactamente ${expected} elementos, se recibieron ${received}`,
-    invalidRecord: 'Registro inválido',
-    invalidSet: 'Set inválido',
-    invalidMap: 'Map inválido',
-    // Transformation and refinement messages
-    transformError: (error) => `Transformación falló: ${error}`,
-    refinementError: (error) => `Refinamiento falló: ${error}`,
-    customValidationError: (error) => `Validación personalizada falló: ${error}`,
-    // Coercion messages
-    coercionFailed: (type, value) => `No se puede coaccionar ${JSON.stringify(value)} a ${type}`,
-    // Codec messages
-    codecDecodeFailed: 'Failed to decode value',
-    codecEncodeFailed: 'Failed to encode value',
-    codecAsyncNotSupported: 'Async codec operations require using parseAsync/encodeAsync methods',
-    // Base64/Hex messages
-    invalidBase64: 'Invalid base64 string',
-    invalidHex: 'Invalid hexadecimal string',
-    // Uint8Array messages
-    expectedUint8Array: 'Expected Uint8Array',
-    uint8ArrayMinLength: (min) => `Uint8Array must have at least ${min} bytes`,
-    uint8ArrayMaxLength: (max) => `Uint8Array must have at most ${max} bytes`,
-    uint8ArrayExactLength: (length) => `Uint8Array must have exactly ${length} bytes`,
-    // Generic type error messages
-    expectedString: 'Expected string',
-    stringExpected: (received, expected) => `Se esperaba ${expected}, se recibió ${received}`,
-    stringBoolExpected: (validValues, received) => `Cadena booleana no válida. Se esperaba uno de: ${validValues}, se recibió: "${received}"`,
-    invalidJson: 'JSON no válido',
-    stringPatternInvalid: 'La cadena no coincide con el patrón requerido',
-    // File validation messages
-    invalidFile: 'Expected a File object',
-    fileNotSupported: 'File API not supported in this environment',
-    fileMinSize: (min) => `File size must be at least ${min} bytes`,
-    fileMaxSize: (max) => `File size must not exceed ${max} bytes`,
-    fileMimeType: (allowed) => `Invalid file type. Expected: ${allowed.join(', ')}`,
-    invalidFunction: 'Se esperaba una función',
-    // CIDR validation messages
-    stringCidrv4: 'Bloque CIDR IPv4 inválido',
-    stringCidrv6: 'Bloque CIDR IPv6 inválido',
-    // Safe extend validation messages
-    safeExtendOverlap: (keys) => `No se pueden sobrescribir las claves existentes: ${keys.join(', ')}. Use extend() si desea sobrescribir.`
-};
-
-var esMX$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    esMX: esMX
-});
-
-exports.getLocale = getLocale;
-exports.getMessages = getMessages;
-exports.getMessagesForLocale = getMessagesForLocale;
+exports.getLocale = locales_runtime.getLocale;
+exports.getMessages = locales_runtime.getMessages;
+exports.getMessagesForLocale = locales_runtime.getMessagesForLocale;
+exports.isLocaleLoaded = locales_runtime.isLocaleLoaded;
+exports.registerLocale = locales_runtime.registerLocale;
 exports.getSupportedLocales = getSupportedLocales;
-exports.isLocaleLoaded = isLocaleLoaded;
 exports.isLocaleSupported = isLocaleSupported;
 exports.preloadLocales = preloadLocales;
-exports.registerLocale = registerLocale;
 exports.setLocale = setLocale;
 exports.setLocaleAsync = setLocaleAsync;
-//# sourceMappingURL=lazy.cjs.map