@oxog/vld 2.0.3 → 2.1.0

package/dist/chunks/{index-DO8CFMxD.js → index-0R2ntSud.js}

@@ -1,401 +1,13 @@
-import { i as VldBase, u as getMessages, h as VldString, c as VldNumber, V as VldBigInt, b as VldDate, a as VldBoolean } from './bigint-CRS0QVsy.js';
-import { VldError, createIssue } from '../errors.js';
-import { V as VldUnknown } from './unknown-Dhzri_T-.js';
-
-/**
- * Codec validator for bidirectional transformations
- * Enables converting between different data representations
- */
-class VldCodec extends VldBase {
-    constructor(inputValidator, outputValidator, codecTransform) {
-        super();
-        this.inputValidator = inputValidator;
-        this.outputValidator = outputValidator;
-        this.codecTransform = codecTransform;
-    }
-    /**
-     * Parse (decode) a value from input to output format
-     */
-    parse(value) {
-        const result = this.safeParse(value);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
-    }
-    /**
-     * Safely parse (decode) a value from input to output format
-     */
-    safeParse(value) {
-        // First validate the input
-        const inputResult = this.inputValidator.safeParse(value);
-        if (!inputResult.success) {
-            return inputResult;
-        }
-        try {
-            // Then decode to output
-            const decoded = this.codecTransform.decode(inputResult.data);
-            // Handle async decode
-            if (decoded instanceof Promise) {
-                throw new VldError([
-                    createIssue('custom', [], getMessages().codecAsyncNotSupported)
-                ]);
-            }
-            // Validate the decoded output
-            return this.outputValidator.safeParse(decoded);
-        }
-        catch (error) {
-            if (error instanceof VldError) {
-                return { success: false, error };
-            }
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().codecDecodeFailed)
-                ])
-            };
-        }
-    }
-    /**
-     * Encode a value from output back to input format
-     */
-    encode(value) {
-        const result = this.safeEncode(value);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
-    }
-    /**
-     * Safely encode a value from output back to input format
-     */
-    safeEncode(value) {
-        // First validate the output
-        const outputResult = this.outputValidator.safeParse(value);
-        if (!outputResult.success) {
-            return outputResult;
-        }
-        try {
-            // Then encode to input
-            const encoded = this.codecTransform.encode(outputResult.data);
-            // Handle async encode
-            if (encoded instanceof Promise) {
-                throw new VldError([
-                    createIssue('custom', [], getMessages().codecAsyncNotSupported)
-                ]);
-            }
-            // Validate the encoded input
-            return this.inputValidator.safeParse(encoded);
-        }
-        catch (error) {
-            if (error instanceof VldError) {
-                return { success: false, error };
-            }
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().codecEncodeFailed)
-                ])
-            };
-        }
-    }
-    /**
-     * Async version of parse (decode)
-     */
-    async parseAsync(value) {
-        const result = await this.safeParseAsync(value);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
-    }
-    /**
-     * Async version of safeParse (decode)
-     */
-    async safeParseAsync(value) {
-        // First validate the input
-        const inputResult = this.inputValidator.safeParse(value);
-        if (!inputResult.success) {
-            return inputResult;
-        }
-        try {
-            // Then decode to output (supports async)
-            const decoded = await this.codecTransform.decode(inputResult.data);
-            // Validate the decoded output
-            return this.outputValidator.safeParse(decoded);
-        }
-        catch (error) {
-            if (error instanceof VldError) {
-                return { success: false, error };
-            }
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().codecDecodeFailed)
-                ])
-            };
-        }
-    }
-    /**
-     * Async version of encode
-     */
-    async encodeAsync(value) {
-        const result = await this.safeEncodeAsync(value);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
-    }
-    /**
-     * Async version of safeEncode
-     */
-    async safeEncodeAsync(value) {
-        // First validate the output
-        const outputResult = this.outputValidator.safeParse(value);
-        if (!outputResult.success) {
-            return outputResult;
-        }
-        try {
-            // Then encode to input (supports async)
-            const encoded = await this.codecTransform.encode(outputResult.data);
-            // Validate the encoded input
-            return this.inputValidator.safeParse(encoded);
-        }
-        catch (error) {
-            if (error instanceof VldError) {
-                return { success: false, error };
-            }
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().codecEncodeFailed)
-                ])
-            };
-        }
-    }
-    /**
-     * Create a codec validator
-     */
-    static create(inputValidator, outputValidator, codecTransform) {
-        return new VldCodec(inputValidator, outputValidator, codecTransform);
-    }
-}
-
-/**
- * Base64 string validator
- */
-class VldBase64 extends VldBase {
-    constructor(urlSafe = false) {
-        super();
-        this.urlSafe = urlSafe;
-    }
-    parse(value) {
-        const result = this.safeParse(value);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
-    }
-    safeParse(value) {
-        if (typeof value !== 'string') {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('invalid_type', [], getMessages().expectedString)
-                ])
-            };
-        }
-        // Check if it's a valid base64 string
-        const regex = this.urlSafe ? VldBase64.BASE64_URL_REGEX : VldBase64.BASE64_REGEX;
-        // Check basic format
-        if (!regex.test(value)) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().invalidBase64)
-                ])
-            };
-        }
-        // For standard base64, check length is multiple of 4 (after padding)
-        // Empty strings are valid (decode to empty buffer)
-        // For URL-safe base64, padding is not required
-        if (!this.urlSafe && value.length > 0 && value.length % 4 !== 0) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().invalidBase64)
-                ])
-            };
-        }
-        return { success: true, data: value };
-    }
-    /**
-     * Create a URL-safe base64 validator
-     */
-    urlSafeMode() {
-        return new VldBase64(true);
-    }
-    static create(urlSafe = false) {
-        return new VldBase64(urlSafe);
-    }
-}
-VldBase64.BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
-// Note: RFC 4648 specifies URL-safe base64 should omit padding, but we allow it for compatibility
-VldBase64.BASE64_URL_REGEX = /^[A-Za-z0-9_-]*={0,2}$/;
-
-/**
- * Hexadecimal string validator
- */
-class VldHex extends VldBase {
-    constructor(lowercase = false) {
-        super();
-        this.lowercase = lowercase;
-    }
-    parse(value) {
-        const result = this.safeParse(value);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
-    }
-    safeParse(value) {
-        if (typeof value !== 'string') {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('invalid_type', [], getMessages().expectedString)
-                ])
-            };
-        }
-        // Check if it's a valid hex string
-        if (!VldHex.HEX_REGEX.test(value)) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().invalidHex)
-                ])
-            };
-        }
-        // Check if even length (full bytes)
-        if (value.length % 2 !== 0) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().invalidHex)
-                ])
-            };
-        }
-        // Normalize case if required
-        const normalizedValue = this.lowercase ? value.toLowerCase() : value;
-        return { success: true, data: normalizedValue };
-    }
-    /**
-     * Require lowercase hex characters
-     */
-    lowercaseMode() {
-        return new VldHex(true);
-    }
-    static create(lowercase = false) {
-        return new VldHex(lowercase);
-    }
-}
-// BUG-008 FIX: Use * instead of + to allow empty hex strings (consistent with base64 validator)
-VldHex.HEX_REGEX = /^[0-9a-fA-F]*$/;
-
-/**
- * Uint8Array validator with immutable configuration
- * BUG-NEW-010 FIX: Refactored to follow immutability pattern
- */
-class VldUint8Array extends VldBase {
-    /**
-     * Protected constructor to maintain immutability
-     */
-    constructor(config) {
-        super();
-        this.config = config || {};
-    }
-    parse(value) {
-        const result = this.safeParse(value);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
-    }
-    safeParse(value) {
-        if (!(value instanceof Uint8Array)) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('invalid_type', [], getMessages().expectedUint8Array)
-                ])
-            };
-        }
-        // Check exact length if specified
-        if (this.config.exactLength !== undefined && value.length !== this.config.exactLength) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().uint8ArrayExactLength(this.config.exactLength))
-                ])
-            };
-        }
-        // Check minimum length
-        if (this.config.minLength !== undefined && value.length < this.config.minLength) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().uint8ArrayMinLength(this.config.minLength))
-                ])
-            };
-        }
-        // Check maximum length
-        if (this.config.maxLength !== undefined && value.length > this.config.maxLength) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().uint8ArrayMaxLength(this.config.maxLength))
-                ])
-            };
-        }
-        return { success: true, data: value };
-    }
-    /**
-     * Set minimum byte length
-     * Returns new immutable validator instance
-     */
-    min(length) {
-        return new VldUint8Array({
-            ...this.config,
-            minLength: length
-        });
-    }
-    /**
-     * Set maximum byte length
-     * Returns new immutable validator instance
-     */
-    max(length) {
-        return new VldUint8Array({
-            ...this.config,
-            maxLength: length
-        });
-    }
-    /**
-     * Set exact byte length
-     * Returns new immutable validator instance
-     * Clears min/max when setting exact length
-     */
-    length(length) {
-        return new VldUint8Array({
-            exactLength: length,
-            // Clear min/max when exact length is set
-            minLength: undefined,
-            maxLength: undefined
-        });
-    }
-    static create() {
-        return new VldUint8Array();
-    }
-}
+import { VldCodec } from '../validators/codec.js';
+import { VldBase64 } from '../validators/base64.js';
+import { VldHex } from '../validators/hex.js';
+import { VldUint8Array } from '../validators/uint8array.js';
+import { V as VldString } from './string-BJRQod3t.js';
+import { VldNumber } from '../validators/number.js';
+import { VldBigInt } from '../validators/bigint.js';
+import { VldBoolean } from '../validators/boolean.js';
+import { VldDate } from '../validators/date.js';
+import { VldUnknown } from '../validators/unknown.js';
 
 /**
  * Utility functions for codec transformations
@@ -588,7 +200,7 @@ function safeAtob(encoded) {
         try {
             return atob(encoded);
         }
-        catch (error) {
+        catch {
             throw new Error('Failed to decode base64 data');
         }
     }
@@ -627,8 +239,11 @@ function safeBtoa(str) {
 }
 
 /**
- * Predefined codecs for common transformations (Zod-compatible)
+ * Invert a codec, swapping encode and decode directions.
  */
+function invertCodec(codec) {
+    return codec.invert();
+}
 // ===== STRING TO NUMBER CODECS =====
 /**
  * String to number codec
@@ -890,5 +505,4 @@ const jwtPayload = (schema) => {
     });
 };
 
-export { uint8ArrayToBase64Url as A, uint8ArrayToHex as B, uint8ArrayToString as C, uriComponent as D, utf8ToBytes as E, VldCodec as V, VldUint8Array as a, VldHex as b, VldBase64 as c, base64Json as d, base64ToBytes as e, base64ToUint8Array as f, base64UrlToBytes as g, base64urlToBytes as h, bytesToUtf8 as i, epochMillisToDate as j, epochSecondsToDate as k, hexLowerToBytes as l, hexToBytes as m, hexToUint8Array as n, isoDatetimeToDate as o, jsonCodec as p, jwtPayload as q, numberToBigInt as r, stringToBigInt as s, stringToBoolean as t, stringToHttpURL as u, stringToInt as v, stringToNumber as w, stringToURL as x, stringToUint8Array as y, uint8ArrayToBase64 as z };
-//# sourceMappingURL=index-DO8CFMxD.js.map
+export { uint8ArrayToString as A, uriComponent as B, utf8ToBytes as C, base64ToBytes as a, base64Json as b, base64ToUint8Array as c, base64UrlToBytes as d, base64urlToBytes as e, bytesToUtf8 as f, epochMillisToDate as g, epochSecondsToDate as h, hexLowerToBytes as i, hexToBytes as j, hexToUint8Array as k, invertCodec as l, isoDatetimeToDate as m, jsonCodec as n, jwtPayload as o, numberToBigInt as p, stringToBoolean as q, stringToHttpURL as r, stringToBigInt as s, stringToInt as t, stringToNumber as u, stringToURL as v, stringToUint8Array as w, uint8ArrayToBase64 as x, uint8ArrayToBase64Url as y, uint8ArrayToHex as z };

package/dist/chunks/index-BvH403Yy.js

@@ -0,0 +1,88 @@
+import { registerLocale, registerFallbackLocale, setLocale, getLocale, getMessages, getMessagesForLocale, getSupportedLocales, isLocaleLoaded, isLocaleSupported } from '../locales/runtime.js';
+import { en } from '../locales/en.js';
+import { tr } from '../locales/tr.js';
+import { es } from '../locales/es.js';
+import { fr } from '../locales/fr.js';
+import { de } from '../locales/de.js';
+import { it } from '../locales/it.js';
+import { pt } from '../locales/pt.js';
+import { ru } from '../locales/ru.js';
+import { ja } from '../locales/ja.js';
+import { ko } from '../locales/ko.js';
+import { zh } from '../locales/zh.js';
+import { ar } from '../locales/ar.js';
+import { hi } from '../locales/hi.js';
+import { nl } from '../locales/nl.js';
+import { pl } from '../locales/pl.js';
+import { da } from '../locales/da.js';
+import { sv } from '../locales/sv.js';
+import { no } from '../locales/no.js';
+import { fi } from '../locales/fi.js';
+import { th } from '../locales/th.js';
+import { vi } from '../locales/vi.js';
+import { id } from '../locales/id.js';
+import { bn } from '../locales/bn.js';
+import { sw } from '../locales/sw.js';
+import { af } from '../locales/af.js';
+import { ptBR } from '../locales/pt-BR.js';
+import { esMX } from '../locales/es-MX.js';
+
+const translatedLocaleCodes = [
+    'en', 'tr', 'es', 'fr', 'de', 'it', 'pt', 'ru', 'ja', 'ko', 'zh', 'ar', 'hi', 'nl', 'pl',
+    'da', 'sv', 'no', 'fi',
+    'th', 'vi', 'id', 'bn',
+    'sw', 'af',
+    'pt-BR', 'es-MX'
+];
+const fallbackLocaleCodes = [
+    'is', 'cs', 'sk', 'hu', 'ro', 'bg', 'hr', 'sl', 'lv', 'lt', 'et',
+    'el', 'mk', 'sq', 'sr', 'bs', 'me', 'mt', 'ga', 'cy', 'eu', 'ca',
+    'ms', 'tl', 'ur', 'fa', 'he', 'ka', 'am', 'hy', 'az', 'kk', 'ky',
+    'uz', 'tg', 'mn', 'my', 'km', 'lo', 'si', 'ta', 'te', 'ml', 'kn',
+    'gu', 'pa', 'or', 'as', 'ne', 'mr', 'sd', 'dv',
+    'ha', 'yo', 'ig', 'zu', 'xh', 'st', 'tn', 'ts', 've', 'nr', 'ss',
+    'es-AR', 'fr-CA', 'qu', 'gn', 'ay'
+];
+const translatedLocales = {
+    // Base languages
+    en, tr, es, fr, de, it, pt, ru, ja, ko, zh, ar, hi, nl, pl,
+    // Major European Languages
+    da, sv, no, fi,
+    // Major Asian Languages  
+    th, vi, id, bn,
+    // African Languages
+    sw, af,
+    // American Languages
+    'pt-BR': ptBR,
+    'es-MX': esMX,
+};
+for (const locale of translatedLocaleCodes) {
+    registerLocale(locale, translatedLocales[locale]);
+}
+for (const locale of fallbackLocaleCodes) {
+    registerFallbackLocale(locale);
+}
+/**
+ * Set the current locale asynchronously.
+ *
+ * The eager locale entrypoint already bundles translated locales and English
+ * fallbacks, so this mirrors setLocale() while preserving async API parity.
+ */
+async function setLocaleAsync(locale) {
+    setLocale(locale);
+}
+
+var localeNamespace = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getLocale: getLocale,
+    getMessages: getMessages,
+    getMessagesForLocale: getMessagesForLocale,
+    getSupportedLocales: getSupportedLocales,
+    isLocaleLoaded: isLocaleLoaded,
+    isLocaleSupported: isLocaleSupported,
+    registerLocale: registerLocale,
+    setLocale: setLocale,
+    setLocaleAsync: setLocaleAsync
+});
+
+export { localeNamespace as l, setLocaleAsync as s };

package/dist/chunks/security-B0Pd_vSY.js

@@ -0,0 +1,35 @@
+/**
+ * Security utilities for prototype pollution protection
+ */
+/**
+ * Keys that, when written via `obj[key] = ...`, can mutate Object.prototype
+ * or alter property accessor behavior across the program.
+ *
+ * `__proto__`, `constructor`, `prototype` are the canonical prototype-pollution
+ * sinks. The `__define*Getter__` / `__lookup*Getter__` family installs accessors
+ * on the prototype chain in legacy engines.
+ *
+ * Note: keys such as `toString`, `valueOf`, or `hasOwnProperty` are NOT
+ * blocked. Those are legitimate property names that appear in real payloads
+ * (localization tables, custom widget config, generic key/value stores).
+ * Silently dropping them causes data loss; a validation library must not do
+ * that.
+ */
+const DANGEROUS_KEYS = new Set([
+    '__proto__',
+    'constructor',
+    'prototype',
+    '__defineGetter__',
+    '__defineSetter__',
+    '__lookupGetter__',
+    '__lookupSetter__',
+]);
+/**
+ * Return true if a property key would, if assigned, mutate the prototype
+ * chain or accessor behavior of the target object.
+ */
+function isDangerousKey(key) {
+    return DANGEROUS_KEYS.has(key);
+}
+
+export { isDangerousKey as i };