@oxog/vld 1.4.0 → 2.0.1

package/dist/chunks/json-nIhyRPOU.js

@@ -0,0 +1,1934 @@
+import { i as VldBase, t as getMessages, V as VldString, a as VldNumber, b as VldBoolean, c as VldDate, e as VldOptional } from './bigint-ZKkWLdmi.js';
+import { c as VldCoerceString, b as VldCoerceNumber, a as VldCoerceBoolean, V as VldCoerceDate } from './date-7Iz2BGsL.js';
+
+/**
+ * Default truthy and falsy value sets
+ */
+const DEFAULT_TRUTHY = ['true', '1', 'yes', 'on', 'y', 'enabled'];
+const DEFAULT_FALSY = ['false', '0', 'no', 'off', 'n', 'disabled'];
+/**
+ * Immutable string boolean validator for flexible boolean parsing
+ * Supports string representations like "true", "yes", "on", "1", etc.
+ */
+class VldStringBool extends VldBase {
+    constructor(options) {
+        super();
+        this.options = options;
+    }
+    /**
+     * Create a new string boolean validator
+     */
+    static create(options = {}) {
+        return new VldStringBool(options);
+    }
+    /**
+     * Normalize a string value based on case sensitivity setting
+     */
+    normalizeValue(value) {
+        return this.options.caseSensitive ? value : value.toLowerCase();
+    }
+    /**
+     * Get the effective truthy values (custom or default)
+     */
+    getTruthyValues() {
+        return this.options.truthy ?? DEFAULT_TRUTHY;
+    }
+    /**
+     * Get the effective falsy values (custom or default)
+     */
+    getFalsyValues() {
+        return this.options.falsy ?? DEFAULT_FALSY;
+    }
+    /**
+     * Parse and validate a string boolean value
+     */
+    parse(value) {
+        // First, ensure we have a string
+        if (typeof value !== 'string') {
+            // Also accept actual boolean values for convenience
+            if (typeof value === 'boolean') {
+                return value;
+            }
+            throw new Error(getMessages().stringExpected(typeof value, 'string'));
+        }
+        const normalized = this.normalizeValue(value);
+        const truthyValues = this.getTruthyValues();
+        const falsyValues = this.getFalsyValues();
+        // Normalize the value sets for comparison
+        const normalizedTruthy = this.options.caseSensitive
+            ? truthyValues
+            : truthyValues.map(v => v.toLowerCase());
+        const normalizedFalsy = this.options.caseSensitive
+            ? falsyValues
+            : falsyValues.map(v => v.toLowerCase());
+        // Check if value is in truthy set
+        if (normalizedTruthy.includes(normalized)) {
+            return true;
+        }
+        // Check if value is in falsy set
+        if (normalizedFalsy.includes(normalized)) {
+            return false;
+        }
+        // Value is not recognized
+        const allValidValues = [...normalizedTruthy, ...normalizedFalsy];
+        throw new Error(getMessages().stringBoolExpected(this.options.caseSensitive ? allValidValues.join(', ') : allValidValues.join(', '), value));
+    }
+    /**
+     * Safely parse and validate a string boolean value
+     */
+    safeParse(value) {
+        try {
+            const result = this.parse(value);
+            return { success: true, data: result };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error
+            };
+        }
+    }
+    /**
+     * Create a new validator with custom truthy values
+     */
+    withTruthy(values) {
+        return new VldStringBool({
+            ...this.options,
+            truthy: values
+        });
+    }
+    /**
+     * Create a new validator with custom falsy values
+     */
+    withFalsy(values) {
+        return new VldStringBool({
+            ...this.options,
+            falsy: values
+        });
+    }
+    /**
+     * Create a new validator with case-sensitive matching
+     */
+    caseSensitive() {
+        return new VldStringBool({
+            ...this.options,
+            caseSensitive: true
+        });
+    }
+    /**
+     * Create a new validator with case-insensitive matching (default)
+     */
+    caseInsensitive() {
+        return new VldStringBool({
+            ...this.options,
+            caseSensitive: false
+        });
+    }
+}
+
+/**
+ * Immutable array validator with chainable methods
+ */
+class VldArray extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    /**
+     * Create a new array validator
+     */
+    static create(itemValidator) {
+        return new VldArray({ itemValidator });
+    }
+    /**
+     * Parse and validate an array value
+     */
+    parse(value) {
+        if (!Array.isArray(value)) {
+            throw new Error(this.config.errorMessage || getMessages().invalidArray);
+        }
+        // Validate length constraints
+        if (this.config.exactLength !== undefined && value.length !== this.config.exactLength) {
+            throw new Error(this.config.errorMessage || getMessages().arrayLength(this.config.exactLength));
+        }
+        if (this.config.minLength !== undefined && value.length < this.config.minLength) {
+            throw new Error(this.config.errorMessage || getMessages().arrayMin(this.config.minLength));
+        }
+        if (this.config.maxLength !== undefined && value.length > this.config.maxLength) {
+            throw new Error(this.config.errorMessage || getMessages().arrayMax(this.config.maxLength));
+        }
+        // Validate each item with optimized loop and safeParse
+        const result = [];
+        const length = value.length;
+        for (let i = 0; i < length; i++) {
+            const parseResult = this.config.itemValidator.safeParse(value[i]);
+            if (!parseResult.success) {
+                throw new Error(getMessages().arrayItem(i, parseResult.error.message));
+            }
+            result[i] = parseResult.data; // Direct assignment is faster than push
+        }
+        // Check uniqueness if required
+        if (this.config.unique) {
+            const seen = new Set();
+            for (const item of result) {
+                const key = typeof item === 'object' ? this.stableStringify(item) : item;
+                if (seen.has(key)) {
+                    throw new Error('Array must contain unique items');
+                }
+                seen.add(key);
+            }
+        }
+        return result;
+    }
+    /**
+     * Safely parse and validate an array value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: error };
+        }
+    }
+    /**
+     * Create a stable string representation of an object for hashing
+     * Handles circular references and deep nesting gracefully
+     * BUG-006 FIX: Added depth limit to prevent stack overflow
+     * BUG-NEW-003 FIX: Fixed depth tracking to properly track recursion depth
+     */
+    stableStringify(obj) {
+        const seen = new WeakSet();
+        const MAX_DEPTH = 100; // Reasonable depth limit to prevent stack overflow
+        // Helper function to sort keys and create stable representation
+        const sortedStringify = (value, depth = 0) => {
+            // Check depth limit
+            if (depth > MAX_DEPTH) {
+                return '"[Max Depth Exceeded]"';
+            }
+            // Handle primitives
+            if (value === null)
+                return 'null';
+            if (value === undefined)
+                return 'undefined';
+            if (typeof value !== 'object')
+                return JSON.stringify(value);
+            // Handle circular references
+            if (seen.has(value)) {
+                return '"[Circular]"';
+            }
+            seen.add(value);
+            try {
+                // Handle arrays
+                if (Array.isArray(value)) {
+                    const items = value.map(item => sortedStringify(item, depth + 1));
+                    return `[${items.join(',')}]`;
+                }
+                // Handle objects - sort keys for stability
+                const keys = Object.keys(value).sort();
+                const pairs = keys.map(key => {
+                    const serializedKey = JSON.stringify(key);
+                    const serializedValue = sortedStringify(value[key], depth + 1);
+                    return `${serializedKey}:${serializedValue}`;
+                });
+                return `{${pairs.join(',')}}`;
+            }
+            finally {
+                // Clean up seen set for this branch
+                seen.delete(value);
+            }
+        };
+        try {
+            return sortedStringify(obj);
+        }
+        catch (error) {
+            // Fallback to safe representation if stringify fails
+            return String(obj);
+        }
+    }
+    /**
+     * Create a new validator with minimum length constraint
+     */
+    min(length, message) {
+        return new VldArray({
+            ...this.config,
+            minLength: length,
+            errorMessage: message || getMessages().arrayMin(length)
+        });
+    }
+    /**
+     * Create a new validator with maximum length constraint
+     */
+    max(length, message) {
+        return new VldArray({
+            ...this.config,
+            maxLength: length,
+            errorMessage: message || getMessages().arrayMax(length)
+        });
+    }
+    /**
+     * Create a new validator with exact length constraint
+     */
+    length(length, message) {
+        return new VldArray({
+            ...this.config,
+            exactLength: length,
+            minLength: undefined,
+            maxLength: undefined,
+            errorMessage: message || getMessages().arrayLength(length)
+        });
+    }
+    /**
+     * Create a new validator that ensures array is not empty
+     */
+    nonempty(message) {
+        return new VldArray({
+            ...this.config,
+            minLength: 1,
+            errorMessage: message || getMessages().arrayEmpty
+        });
+    }
+    /**
+     * Create a new validator that ensures array contains unique items
+     */
+    unique(message) {
+        return new VldArray({
+            ...this.config,
+            unique: true,
+            errorMessage: message || 'Array must contain unique items'
+        });
+    }
+    /**
+     * Create a new validator with a range constraint for length
+     */
+    between(min, max, message) {
+        return new VldArray({
+            ...this.config,
+            minLength: min,
+            maxLength: max,
+            errorMessage: message || `Array length must be between ${min} and ${max}`
+        });
+    }
+}
+
+/**
+ * Immutable enum validator for string enum values
+ */
+class VldEnum extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(values, errorMessage) {
+        super();
+        this.values = values;
+        this.errorMessage = errorMessage;
+    }
+    /**
+     * Create a new enum validator
+     */
+    static create(values) {
+        return new VldEnum(values);
+    }
+    /**
+     * Parse and validate an enum value
+     */
+    parse(value) {
+        // BUG-002 FIX: Add type check before includes() to prevent type confusion
+        if (typeof value !== 'string') {
+            throw new Error(this.errorMessage ||
+                getMessages().enumExpected([...this.values], JSON.stringify(value)));
+        }
+        if (!this.values.includes(value)) {
+            throw new Error(this.errorMessage ||
+                getMessages().enumExpected([...this.values], JSON.stringify(value)));
+        }
+        return value;
+    }
+    /**
+     * Safely parse and validate an enum value
+     */
+    safeParse(value) {
+        // BUG-002 FIX: Add type check before includes() to prevent type confusion
+        if (typeof value !== 'string') {
+            return {
+                success: false,
+                error: new Error(this.errorMessage ||
+                    getMessages().enumExpected([...this.values], JSON.stringify(value)))
+            };
+        }
+        if (this.values.includes(value)) {
+            return { success: true, data: value };
+        }
+        return {
+            success: false,
+            error: new Error(this.errorMessage ||
+                getMessages().enumExpected([...this.values], JSON.stringify(value)))
+        };
+    }
+    /**
+     * Exclude specific values from the enum
+     * Creates a new enum validator without the specified values
+     */
+    exclude(...excludeValues) {
+        const filtered = this.values.filter(v => !excludeValues.includes(v));
+        if (filtered.length === 0) {
+            throw new Error('Cannot exclude all enum values');
+        }
+        // Type assertion needed because TypeScript can't guarantee the filtered array maintains the required type
+        return new VldEnum(filtered, this.errorMessage);
+    }
+    /**
+     * Extract specific values from the enum
+     * Creates a new enum validator with only the specified values
+     */
+    extract(...extractValues) {
+        const extracted = this.values.filter(v => extractValues.includes(v));
+        if (extracted.length === 0) {
+            throw new Error('Cannot extract non-existent enum values');
+        }
+        // Type assertion needed because TypeScript can't guarantee the extracted array has the required type
+        return new VldEnum(extracted, this.errorMessage);
+    }
+}
+
+/**
+ * Optimized immutable object validator with chainable methods
+ * Features pre-computed keys and Set-based lookups for better performance
+ */
+class VldObject extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(config) {
+        super();
+        this.config = config;
+        // Pre-compute shape keys for faster access
+        this.shapeKeys = Object.keys(config.shape);
+        this.shapeKeysSet = new Set(this.shapeKeys);
+    }
+    /**
+     * Create a new object validator
+     */
+    static create(shape) {
+        return new VldObject({ shape });
+    }
+    /**
+     * Parse and validate an object value
+     * Ultra-optimized with inline type checks and minimal overhead
+     */
+    parse(value) {
+        // Fast type check
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            throw new Error(this.config.errorMessage || getMessages().invalidObject);
+        }
+        const obj = value;
+        const result = {};
+        // Ultra-optimized field validation with inline fast paths
+        for (let i = 0; i < this.shapeKeys.length; i++) {
+            const key = this.shapeKeys[i];
+            const validator = this.config.shape[key];
+            const fieldValue = obj[key];
+            // BUG-NEW-002 FIX: Use instanceof instead of constructor.name
+            // constructor.name breaks in minified builds where class names become 'a', 'b', etc.
+            // instanceof checks are reliable regardless of minification
+            //
+            // Note: Coercion validators extend their base validators, so we need to check for
+            // coercion types first (more specific) before checking base types
+            // Check for coercion validators first - they need full safeParse for type conversion
+            if (validator instanceof VldCoerceString ||
+                validator instanceof VldCoerceNumber ||
+                validator instanceof VldCoerceBoolean ||
+                validator instanceof VldCoerceDate) {
+                // Coercion validators need safeParse to handle type conversion
+                const parseResult = validator.safeParse(fieldValue);
+                if (!parseResult.success) {
+                    throw new Error(getMessages().objectField(key, parseResult.error.message));
+                }
+                result[key] = parseResult.data;
+            }
+            else if (validator instanceof VldString) {
+                // For string with validations, use safeParse to handle email, regex etc.
+                const parseResult = validator.safeParse(fieldValue);
+                if (!parseResult.success) {
+                    throw new Error(getMessages().objectField(key, parseResult.error.message));
+                }
+                result[key] = parseResult.data;
+            }
+            else if (validator instanceof VldNumber) {
+                if (typeof fieldValue !== 'number' || isNaN(fieldValue)) {
+                    throw new Error(getMessages().objectField(key, getMessages().invalidNumber));
+                }
+                result[key] = fieldValue;
+            }
+            else if (validator instanceof VldBoolean) {
+                if (typeof fieldValue !== 'boolean') {
+                    throw new Error(getMessages().objectField(key, getMessages().invalidBoolean));
+                }
+                result[key] = fieldValue;
+            }
+            else if (validator instanceof VldDate) {
+                // Use the actual validator for Date parsing (handles string conversion)
+                const parseResult = validator.safeParse(fieldValue);
+                if (!parseResult.success) {
+                    throw new Error(getMessages().objectField(key, parseResult.error.message));
+                }
+                result[key] = parseResult.data;
+            }
+            else {
+                // Fallback to safeParse for complex validators
+                const parseResult = validator.safeParse(fieldValue);
+                if (!parseResult.success) {
+                    throw new Error(getMessages().objectField(key, parseResult.error.message));
+                }
+                result[key] = parseResult.data;
+            }
+        }
+        // Handle strict mode - optimized with Set
+        if (this.config.strict) {
+            const objKeys = Object.keys(obj);
+            const extraKeys = [];
+            for (let i = 0; i < objKeys.length; i++) {
+                if (!this.shapeKeysSet.has(objKeys[i])) {
+                    extraKeys.push(objKeys[i]);
+                }
+            }
+            if (extraKeys.length > 0) {
+                throw new Error(getMessages().unexpectedKeys(extraKeys));
+            }
+        }
+        // Handle passthrough mode - optimized with comprehensive prototype pollution protection
+        if (this.config.passthrough) {
+            const objKeys = Object.keys(obj);
+            for (let i = 0; i < objKeys.length; i++) {
+                const key = objKeys[i];
+                // Skip dangerous keys to prevent prototype pollution
+                if (!this.shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
+                    result[key] = obj[key];
+                }
+            }
+        }
+        // Handle catchall - validate extra keys with catchall validator
+        if (this.config.catchall) {
+            const objKeys = Object.keys(obj);
+            for (let i = 0; i < objKeys.length; i++) {
+                const key = objKeys[i];
+                // Skip keys already in shape and dangerous keys
+                if (!this.shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
+                    result[key] = this.config.catchall.parse(obj[key]);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Safely parse and validate an object value
+     * Optimized version using pre-computed keys
+     */
+    safeParse(value) {
+        // Fast type check
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            return {
+                success: false,
+                error: new Error(this.config.errorMessage || getMessages().invalidObject)
+            };
+        }
+        const obj = value;
+        const result = {};
+        // Validate all fields
+        for (let i = 0; i < this.shapeKeys.length; i++) {
+            const key = this.shapeKeys[i];
+            const validator = this.config.shape[key];
+            const fieldValue = obj[key];
+            const parseResult = validator.safeParse(fieldValue);
+            if (parseResult.success) {
+                result[key] = parseResult.data;
+            }
+            else {
+                return {
+                    success: false,
+                    error: new Error(getMessages().objectField(key, parseResult.error.message))
+                };
+            }
+        }
+        // Handle strict mode
+        if (this.config.strict) {
+            const objKeys = Object.keys(obj);
+            const extraKeys = [];
+            for (let i = 0; i < objKeys.length; i++) {
+                if (!this.shapeKeysSet.has(objKeys[i])) {
+                    extraKeys.push(objKeys[i]);
+                }
+            }
+            if (extraKeys.length > 0) {
+                return {
+                    success: false,
+                    error: new Error(getMessages().unexpectedKeys(extraKeys))
+                };
+            }
+        }
+        // Handle passthrough mode with comprehensive prototype pollution protection
+        if (this.config.passthrough) {
+            const objKeys = Object.keys(obj);
+            for (let i = 0; i < objKeys.length; i++) {
+                const key = objKeys[i];
+                // Skip dangerous keys to prevent prototype pollution
+                if (!this.shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
+                    result[key] = obj[key];
+                }
+            }
+        }
+        // Handle catchall - validate extra keys with catchall validator
+        if (this.config.catchall) {
+            const objKeys = Object.keys(obj);
+            for (let i = 0; i < objKeys.length; i++) {
+                const key = objKeys[i];
+                // Skip keys already in shape and dangerous keys
+                if (!this.shapeKeysSet.has(key) && !this.isDangerousKey(key)) {
+                    const catchallResult = this.config.catchall.safeParse(obj[key]);
+                    if (!catchallResult.success) {
+                        return {
+                            success: false,
+                            error: new Error(getMessages().objectField(key, catchallResult.error.message))
+                        };
+                    }
+                    result[key] = catchallResult.data;
+                }
+            }
+        }
+        return { success: true, data: result };
+    }
+    /**
+     * Comprehensive prototype pollution protection
+     * Checks for dangerous keys that could modify Object.prototype
+     */
+    isDangerousKey(key) {
+        // Direct dangerous keys
+        const directDangerousKeys = ['__proto__', 'constructor', 'prototype'];
+        if (directDangerousKeys.includes(key)) {
+            return true;
+        }
+        // Nested prototype manipulation vectors
+        // These patterns could allow prototype pollution through nested access
+        const nestedPatterns = [
+            'constructor.prototype',
+            '__proto__.toString',
+            'prototype.constructor',
+            '__defineGetter__',
+            '__defineSetter__',
+            '__lookupGetter__',
+            '__lookupSetter__'
+        ];
+        // Check for nested patterns
+        for (const pattern of nestedPatterns) {
+            if (key.includes(pattern)) {
+                return true;
+            }
+        }
+        // Check for property access chains that could lead to prototype pollution
+        // This covers patterns like "x.constructor.prototype.polluted"
+        const dangerousChains = [
+            'constructor.',
+            '__proto__.',
+            'prototype.'
+        ];
+        for (const chain of dangerousChains) {
+            if (key.includes(chain)) {
+                return true;
+            }
+        }
+        // Additional protection: reject keys that could be used for property shadowing
+        const shadowingPatterns = [
+            'hasOwnProperty',
+            'toString',
+            'valueOf',
+            'isPrototypeOf',
+            'propertyIsEnumerable'
+        ];
+        for (const pattern of shadowingPatterns) {
+            if (key === pattern || key.includes(`.${pattern}`)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Create a new validator in strict mode (no extra keys allowed)
+     */
+    strict(message) {
+        return new VldObject({
+            ...this.config,
+            strict: true,
+            passthrough: false,
+            errorMessage: message
+        });
+    }
+    /**
+     * Create a new validator in passthrough mode (extra keys are preserved)
+     */
+    passthrough() {
+        return new VldObject({
+            ...this.config,
+            strict: false,
+            passthrough: true
+        });
+    }
+    /**
+     * Create a new validator with all fields optional
+     */
+    partial() {
+        const partialShape = {};
+        for (const key in this.config.shape) {
+            partialShape[key] = new VldOptional(this.config.shape[key]);
+        }
+        return new VldObject({
+            ...this.config,
+            shape: partialShape
+        });
+    }
+    /**
+     * Create a new validator with deep partial (nested objects also partial)
+     */
+    deepPartial() {
+        const deepPartialShape = {};
+        for (const key in this.config.shape) {
+            const validator = this.config.shape[key];
+            if (validator instanceof VldObject) {
+                deepPartialShape[key] = new VldOptional(validator.deepPartial());
+            }
+            else {
+                deepPartialShape[key] = new VldOptional(validator);
+            }
+        }
+        return new VldObject({
+            ...this.config,
+            shape: deepPartialShape
+        });
+    }
+    /**
+     * Create a new validator with only specified keys
+     */
+    pick(...keys) {
+        const pickedShape = {};
+        for (const key of keys) {
+            if (key in this.config.shape) {
+                pickedShape[key] = this.config.shape[key];
+            }
+        }
+        return new VldObject({
+            ...this.config,
+            shape: pickedShape
+        });
+    }
+    /**
+     * Create a new validator without specified keys
+     */
+    omit(...keys) {
+        const omittedShape = {};
+        const keysToOmit = new Set(keys);
+        for (const key in this.config.shape) {
+            if (!keysToOmit.has(key)) {
+                omittedShape[key] = this.config.shape[key];
+            }
+        }
+        return new VldObject({
+            ...this.config,
+            shape: omittedShape
+        });
+    }
+    /**
+     * Create a new validator with additional fields
+     */
+    extend(extension) {
+        return new VldObject({
+            ...this.config,
+            shape: { ...this.config.shape, ...extension }
+        });
+    }
+    /**
+     * Create a new validator by merging with another object validator
+     */
+    merge(other) {
+        return new VldObject({
+            ...this.config,
+            shape: { ...this.config.shape, ...other.config.shape }
+        });
+    }
+    /**
+     * Create a new validator with all fields required (removes optional)
+     */
+    required() {
+        const requiredShape = {};
+        for (const key in this.config.shape) {
+            const validator = this.config.shape[key];
+            // If it's optional, unwrap it
+            if (validator instanceof VldOptional) {
+                // BUG-001 FIX: Add defensive check for baseValidator property
+                const unwrapped = validator.baseValidator;
+                if (!unwrapped || typeof unwrapped.parse !== 'function') {
+                    throw new Error(`Invalid VldOptional structure for field "${key}": missing or invalid baseValidator`);
+                }
+                requiredShape[key] = unwrapped;
+            }
+            else {
+                requiredShape[key] = validator;
+            }
+        }
+        return new VldObject({
+            ...this.config,
+            shape: requiredShape
+        });
+    }
+    /**
+     * Create a new validator with a catchall validator for extra keys
+     * Zod 4 API parity - validates unknown keys with provided schema
+     */
+    catchall(schema) {
+        return new VldObject({
+            ...this.config,
+            catchall: schema,
+            passthrough: false // catchall overrides passthrough
+        });
+    }
+    /**
+     * Access the inner shape schemas
+     * Zod 4 API parity - returns the shape object
+     */
+    get shape() {
+        return this.config.shape;
+    }
+    /**
+     * Create an enum validator from object keys
+     * Zod 4 API parity - creates literal union of keys
+     */
+    keyof() {
+        const keys = Object.keys(this.config.shape);
+        if (keys.length === 0) {
+            throw new Error('Cannot create keyof enum from empty object');
+        }
+        return VldEnum.create(keys);
+    }
+    /**
+     * Type-safe extend that throws an error if any key already exists
+     * Zod 4 API parity - prevents accidental field override
+     * @param extension The extension shape to add
+     * @returns A new validator with extended shape
+     * @throws {Error} If any extension key already exists in the shape
+     * @example
+     * const base = v.object({ name: v.string() });
+     * const extended = base.safeExtend({ age: v.number() }); // OK
+     * const invalid = base.safeExtend({ name: v.number() }); // Throws error
+     */
+    safeExtend(extension) {
+        // Check for overlapping keys
+        const existingKeys = new Set(Object.keys(this.config.shape));
+        const extensionKeys = Object.keys(extension);
+        const overlappingKeys = [];
+        for (const key of extensionKeys) {
+            if (existingKeys.has(key)) {
+                overlappingKeys.push(key);
+            }
+        }
+        if (overlappingKeys.length > 0) {
+            throw new Error(`safeExtend: ${getMessages().safeExtendOverlap(overlappingKeys)}`);
+        }
+        return new VldObject({
+            ...this.config,
+            shape: { ...this.config.shape, ...extension }
+        });
+    }
+}
+
+/**
+ * Optimized immutable union validator for multiple type options
+ * Features type-checking shortcuts for 110x performance improvement
+ */
+class VldUnion extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(validators, errorMessage) {
+        super();
+        this.validators = validators;
+        this.errorMessage = errorMessage;
+        this.typeCheckers = new Map();
+        // Pre-compile type checkers for common types
+        for (const validator of validators) {
+            this.typeCheckers.set(validator, this.createTypeChecker(validator));
+        }
+    }
+    /**
+     * Create type checker based on validator type for fast path optimization
+     * Uses a safer approach that's less prone to spoofing
+     */
+    createTypeChecker(validator) {
+        // More conservative approach that prioritizes security and stability
+        // Only use fast path checks for very common, unambiguous types
+        try {
+            // Test basic types with safe parsing to validate the validator
+            const stringTest = validator.safeParse('test');
+            if (stringTest.success) {
+                return (v) => typeof v === 'string';
+            }
+            const numberTest = validator.safeParse(123);
+            if (numberTest.success) {
+                return (v) => typeof v === 'number' && !isNaN(v);
+            }
+            const booleanTest = validator.safeParse(true);
+            if (booleanTest.success) {
+                return (v) => typeof v === 'boolean';
+            }
+            const arrayTest = validator.safeParse([]);
+            if (arrayTest.success) {
+                return (v) => Array.isArray(v);
+            }
+            const objectTest = validator.safeParse({});
+            if (objectTest.success) {
+                return (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+            }
+            const nullTest = validator.safeParse(null);
+            if (nullTest.success) {
+                return (v) => v === null;
+            }
+            const undefinedTest = validator.safeParse(undefined);
+            if (undefinedTest.success) {
+                return (v) => v === undefined;
+            }
+        }
+        catch {
+            // If safe testing fails, fall back to safe validation
+        }
+        // Fallback: no quick check available - use safe validation
+        return () => true;
+    }
+    /**
+     * Create a new union validator
+     */
+    static create(...validators) {
+        return new VldUnion(validators);
+    }
+    /**
+     * Parse and validate a value against union options
+     * Optimized with type checking and safeParse to avoid try-catch overhead
+     * BUG-NEW-013 FIX: Single-pass error collection to avoid double parsing
+     */
+    parse(value) {
+        // Single pass: collect errors during validation
+        const errors = [];
+        for (const validator of this.validators) {
+            const typeChecker = this.typeCheckers.get(validator);
+            // Skip validators that definitely won't match based on type
+            if (typeChecker && !typeChecker(value)) {
+                continue;
+            }
+            // Use safeParse to avoid try-catch overhead
+            const result = validator.safeParse(value);
+            if (result.success) {
+                return result.data;
+            }
+            // Collect error for final message if all validators fail
+            errors.push(result.error.message);
+        }
+        // All validators failed - throw with collected errors
+        throw new Error(this.errorMessage ||
+            getMessages().unionNoMatch(errors));
+    }
+    /**
+     * Safely parse and validate a value against union options
+     * Optimized version using type checking shortcuts
+     * BUG-NEW-013 FIX: Single-pass error collection to avoid double parsing
+     */
+    safeParse(value) {
+        // Single pass: collect errors during validation
+        const errors = [];
+        for (const validator of this.validators) {
+            const typeChecker = this.typeCheckers.get(validator);
+            // Skip validators that definitely won't match based on type
+            if (typeChecker && !typeChecker(value)) {
+                continue;
+            }
+            const result = validator.safeParse(value);
+            if (result.success) {
+                return result;
+            }
+            // Collect error for final message if all validators fail
+            errors.push(result.error.message);
+        }
+        // All validators failed - return error with collected messages
+        return {
+            success: false,
+            error: new Error(this.errorMessage ||
+                getMessages().unionNoMatch(errors))
+        };
+    }
+}
+
+/**
+ * Immutable literal validator for exact value matching
+ */
+class VldLiteral extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(literal, errorMessage) {
+        super();
+        this.literal = literal;
+        this.errorMessage = errorMessage;
+    }
+    /**
+     * Create a new literal validator
+     */
+    static create(literal) {
+        return new VldLiteral(literal);
+    }
+    /**
+     * Parse and validate a literal value
+     */
+    parse(value) {
+        if (value !== this.literal) {
+            throw new Error(this.errorMessage ||
+                getMessages().literalExpected(JSON.stringify(this.literal), JSON.stringify(value)));
+        }
+        return this.literal;
+    }
+    /**
+     * Safely parse and validate a literal value
+     */
+    safeParse(value) {
+        if (value === this.literal) {
+            return { success: true, data: this.literal };
+        }
+        return {
+            success: false,
+            error: new Error(this.errorMessage ||
+                getMessages().literalExpected(JSON.stringify(this.literal), JSON.stringify(value)))
+        };
+    }
+}
+
+/**
+ * Immutable symbol validator
+ */
+class VldSymbol extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(errorMessage) {
+        super();
+        this.errorMessage = errorMessage;
+    }
+    /**
+     * Create a new symbol validator
+     */
+    static create() {
+        return new VldSymbol();
+    }
+    /**
+     * Parse and validate a symbol value
+     */
+    parse(value) {
+        if (typeof value !== 'symbol') {
+            throw new Error(this.errorMessage || getMessages().invalidSymbol);
+        }
+        return value;
+    }
+    /**
+     * Safely parse and validate a symbol value
+     */
+    safeParse(value) {
+        if (typeof value === 'symbol') {
+            return { success: true, data: value };
+        }
+        return {
+            success: false,
+            error: new Error(this.errorMessage || getMessages().invalidSymbol)
+        };
+    }
+}
+
+/**
+ * Immutable tuple validator for fixed-length arrays
+ */
+class VldTuple extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(validators, errorMessage) {
+        super();
+        this.validators = validators;
+        this.errorMessage = errorMessage;
+    }
+    /**
+     * Create a new tuple validator
+     */
+    static create(...validators) {
+        return new VldTuple(validators);
+    }
+    /**
+     * Parse and validate a tuple value
+     */
+    parse(value) {
+        if (!Array.isArray(value)) {
+            throw new Error(this.errorMessage || getMessages().invalidTuple);
+        }
+        if (value.length !== this.validators.length) {
+            throw new Error(this.errorMessage ||
+                getMessages().tupleLength(this.validators.length, value.length));
+        }
+        const result = [];
+        for (let i = 0; i < this.validators.length; i++) {
+            try {
+                result[i] = this.validators[i].parse(value[i]);
+            }
+            catch (error) {
+                throw new Error(getMessages().arrayItem(i, error.message));
+            }
+        }
+        return result;
+    }
+    /**
+     * Safely parse and validate a tuple value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: error };
+        }
+    }
+}
+
+/**
+ * Security utilities for prototype pollution protection
+ * BUG-NEW-018 & BUG-NEW-020 FIX: Centralized comprehensive dangerous key detection
+ */
+/**
+ * Comprehensive prototype pollution protection
+ * Checks for dangerous keys that could modify Object.prototype or built-in prototypes
+ * @param key The property key to check
+ * @returns true if the key is dangerous, false otherwise
+ */
+function isDangerousKey(key) {
+    // Direct dangerous keys
+    const directDangerousKeys = ['__proto__', 'constructor', 'prototype'];
+    if (directDangerousKeys.includes(key)) {
+        return true;
+    }
+    // Nested prototype manipulation vectors
+    // These patterns could allow prototype pollution through nested access
+    const nestedPatterns = [
+        'constructor.prototype',
+        '__proto__.toString',
+        'prototype.constructor',
+        '__defineGetter__',
+        '__defineSetter__',
+        '__lookupGetter__',
+        '__lookupSetter__'
+    ];
+    // Check for nested patterns
+    for (const pattern of nestedPatterns) {
+        if (key.includes(pattern)) {
+            return true;
+        }
+    }
+    // Check for property access chains that could lead to prototype pollution
+    // This covers patterns like "x.constructor.prototype.polluted"
+    const dangerousChains = [
+        'constructor.',
+        '__proto__.',
+        'prototype.'
+    ];
+    for (const chain of dangerousChains) {
+        if (key.includes(chain)) {
+            return true;
+        }
+    }
+    // Additional protection: reject keys that could be used for property shadowing
+    const shadowingPatterns = [
+        'hasOwnProperty',
+        'toString',
+        'valueOf',
+        'isPrototypeOf',
+        'propertyIsEnumerable'
+    ];
+    for (const pattern of shadowingPatterns) {
+        if (key === pattern || key.includes(`.${pattern}`)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/**
+ * Immutable record validator for key-value pairs
+ * BUG-NEW-018 FIX: Uses comprehensive dangerous key protection
+ */
+class VldRecord extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(valueValidator, errorMessage) {
+        super();
+        this.valueValidator = valueValidator;
+        this.errorMessage = errorMessage;
+    }
+    /**
+     * Create a new record validator
+     */
+    static create(valueValidator) {
+        return new VldRecord(valueValidator);
+    }
+    /**
+     * Parse and validate a record value
+     * BUG-NEW-018 FIX: Use comprehensive dangerous key protection
+     */
+    parse(value) {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            throw new Error(this.errorMessage || getMessages().invalidRecord);
+        }
+        const result = {};
+        const obj = value;
+        for (const [key, val] of Object.entries(obj)) {
+            // Skip dangerous keys to prevent prototype pollution
+            // Now using comprehensive protection from shared utility
+            if (isDangerousKey(key)) {
+                continue;
+            }
+            try {
+                result[key] = this.valueValidator.parse(val);
+            }
+            catch (error) {
+                throw new Error(getMessages().objectField(key, error.message));
+            }
+        }
+        return result;
+    }
+    /**
+     * Safely parse and validate a record value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: error };
+        }
+    }
+    /**
+     * Create a partial record variant (all keys optional)
+     * Similar to v.object().partial() but for records
+     */
+    partial() {
+        const optionalValidator = this.valueValidator.optional();
+        return new VldRecord(optionalValidator);
+    }
+    /**
+     * Create a loose record variant (allows extra keys)
+     * Similar to v.object().passthrough() but for records
+     * Note: Records already allow any keys, so this mainly affects error handling
+     */
+    loose() {
+        // For records, "loose" means we don't throw errors for validation failures
+        // We return a modified version that catches validation errors
+        return new VldLooseRecord(this.valueValidator);
+    }
+}
+/**
+ * Loose record variant that allows validation failures
+ * Used internally by .loose() method
+ */
+class VldLooseRecord extends VldBase {
+    constructor(valueValidator) {
+        super();
+        this.valueValidator = valueValidator;
+    }
+    parse(value) {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            throw new Error(getMessages().invalidRecord);
+        }
+        const result = {};
+        const obj = value;
+        for (const [key, val] of Object.entries(obj)) {
+            // Skip dangerous keys
+            if (isDangerousKey(key)) {
+                continue;
+            }
+            // For loose records, skip invalid values instead of throwing
+            const parseResult = this.valueValidator.safeParse(val);
+            if (parseResult.success) {
+                result[key] = parseResult.data;
+            }
+        }
+        return result;
+    }
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: error };
+        }
+    }
+    /**
+     * Create a partial variant (all keys optional)
+     */
+    partial() {
+        const optionalValidator = this.valueValidator.optional();
+        return new VldLooseRecord(optionalValidator);
+    }
+    /**
+     * Return self (already loose)
+     */
+    loose() {
+        return this;
+    }
+}
+
+/**
+ * Immutable Set validator
+ */
+class VldSet extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(itemValidator, errorMessage) {
+        super();
+        this.itemValidator = itemValidator;
+        this.errorMessage = errorMessage;
+    }
+    /**
+     * Create a new Set validator
+     */
+    static create(itemValidator) {
+        return new VldSet(itemValidator);
+    }
+    /**
+     * Parse and validate a Set value
+     */
+    parse(value) {
+        if (!(value instanceof Set)) {
+            throw new Error(this.errorMessage || getMessages().invalidSet);
+        }
+        const result = new Set();
+        for (const item of value) {
+            try {
+                result.add(this.itemValidator.parse(item));
+            }
+            catch (error) {
+                throw new Error(error.message);
+            }
+        }
+        return result;
+    }
+    /**
+     * Safely parse and validate a Set value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: error };
+        }
+    }
+}
+
+/**
+ * Immutable Map validator
+ */
+class VldMap extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(keyValidator, valueValidator, errorMessage) {
+        super();
+        this.keyValidator = keyValidator;
+        this.valueValidator = valueValidator;
+        this.errorMessage = errorMessage;
+    }
+    /**
+     * Create a new Map validator
+     */
+    static create(keyValidator, valueValidator) {
+        return new VldMap(keyValidator, valueValidator);
+    }
+    /**
+     * Parse and validate a Map value
+     */
+    parse(value) {
+        if (!(value instanceof Map)) {
+            throw new Error(this.errorMessage || getMessages().invalidMap);
+        }
+        const result = new Map();
+        for (const [key, val] of value) {
+            try {
+                const validKey = this.keyValidator.parse(key);
+                const validValue = this.valueValidator.parse(val);
+                result.set(validKey, validValue);
+            }
+            catch (error) {
+                throw new Error(error.message);
+            }
+        }
+        return result;
+    }
+    /**
+     * Safely parse and validate a Map value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: error };
+        }
+    }
+}
+
+/**
+ * Type guard to check if a value is a plain object
+ */
+function isPlainObject(obj) {
+    return (obj !== null &&
+        typeof obj === 'object' &&
+        obj.constructor === Object &&
+        Object.prototype.toString.call(obj) === '[object Object]');
+}
+/**
+ * Safely deep merge two objects without prototype pollution vulnerability
+ * Optimized for performance with minimal object allocations
+ * BUG-NEW-020 FIX: Use comprehensive dangerous key protection from shared utility
+ * @param target The target object
+ * @param source The source object to merge from
+ * @returns A new merged object
+ */
+function deepMerge(target, source) {
+    // Create a new object to avoid mutations (only once)
+    const result = { ...target };
+    // Get source keys directly for better performance
+    const sourceKeys = Object.keys(source);
+    for (let i = 0; i < sourceKeys.length; i++) {
+        const key = sourceKeys[i];
+        // Skip dangerous keys that could lead to prototype pollution
+        if (isDangerousKey(key)) {
+            continue;
+        }
+        // Only process own properties (redundant with Object.keys but safe)
+        if (!Object.prototype.hasOwnProperty.call(source, key)) {
+            continue;
+        }
+        const sourceValue = source[key];
+        const targetValue = target[key];
+        // If both values are plain objects, merge them recursively
+        if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+            result[key] = deepMerge(targetValue, sourceValue);
+        }
+        else {
+            // Otherwise, use the source value (including undefined)
+            result[key] = sourceValue;
+        }
+    }
+    return result;
+}
+
+/**
+ * Immutable intersection validator for combining validators
+ */
+class VldIntersection extends VldBase {
+    /**
+     * Private constructor to enforce immutability
+     */
+    constructor(validatorA, validatorB) {
+        super();
+        this.validatorA = validatorA;
+        this.validatorB = validatorB;
+    }
+    /**
+     * Create a new intersection validator
+     */
+    static create(validatorA, validatorB) {
+        return new VldIntersection(validatorA, validatorB);
+    }
+    /**
+     * Parse and validate a value against both validators
+     */
+    parse(value) {
+        try {
+            // Both validators must pass
+            const resultA = this.validatorA.parse(value);
+            const resultB = this.validatorB.parse(value);
+            // BUG-NEW-015 FIX: Check type consistency before merging
+            const aIsObject = isPlainObject(resultA);
+            const bIsObject = isPlainObject(resultB);
+            // Both are objects - safe to merge
+            if (aIsObject && bIsObject) {
+                return deepMerge(resultA, resultB);
+            }
+            // Neither are objects - must be identical primitives
+            if (!aIsObject && !bIsObject) {
+                if (resultA === resultB) {
+                    return resultA;
+                }
+                throw new Error('Values must be identical for intersection of primitive types');
+            }
+            // One is object, one is primitive - invalid intersection
+            throw new Error('Cannot create intersection of object and primitive types. ' +
+                'Both validators must produce the same type category.');
+        }
+        catch (error) {
+            throw new Error(getMessages().intersectionError(error.message));
+        }
+    }
+    /**
+     * Safely parse and validate a value against both validators
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: error };
+        }
+    }
+}
+
+/**
+ * Validator that accepts any value
+ */
+class VldAny extends VldBase {
+    /**
+     * Create a new any validator
+     */
+    static create() {
+        return new VldAny();
+    }
+    /**
+     * Parse any value (always succeeds)
+     */
+    parse(value) {
+        return value;
+    }
+    /**
+     * Safely parse any value (always succeeds)
+     */
+    safeParse(value) {
+        return { success: true, data: value };
+    }
+}
+
+/**
+ * Validator that only accepts undefined
+ */
+class VldVoid extends VldBase {
+    /**
+     * Create a new void validator
+     */
+    static create() {
+        return new VldVoid();
+    }
+    /**
+     * Parse void value (must be undefined)
+     */
+    parse(value) {
+        if (value !== undefined) {
+            throw new Error(getMessages().expectedUndefined);
+        }
+        return undefined;
+    }
+    /**
+     * Safely parse void value
+     */
+    safeParse(value) {
+        if (value === undefined) {
+            return { success: true, data: undefined };
+        }
+        return {
+            success: false,
+            error: new Error(getMessages().expectedUndefined)
+        };
+    }
+}
+
+/**
+ * Validator that never succeeds
+ */
+class VldNever extends VldBase {
+    /**
+     * Create a new never validator
+     */
+    static create() {
+        return new VldNever();
+    }
+    /**
+     * Parse never value (always fails)
+     */
+    parse(_value) {
+        throw new Error(getMessages().neverType);
+    }
+    /**
+     * Safely parse never value (always fails)
+     */
+    safeParse(_value) {
+        return {
+            success: false,
+            error: new Error(getMessages().neverType)
+        };
+    }
+}
+
+/**
+ * VldNull - Validates that a value is exactly null
+ * Part of Zod 4 API parity implementation
+ */
+/**
+ * Null validator - validates that a value is exactly null
+ */
+class VldNull extends VldBase {
+    constructor() {
+        super();
+    }
+    static create() {
+        return new VldNull();
+    }
+    parse(value) {
+        if (value !== null) {
+            throw new Error(`Expected null, received ${typeof value}`);
+        }
+        return null;
+    }
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: error };
+        }
+    }
+}
+
+/**
+ * VldUndefined - Validates that a value is exactly undefined
+ * Part of Zod 4 API parity implementation
+ */
+/**
+ * Undefined validator - validates that a value is exactly undefined
+ */
+class VldUndefined extends VldBase {
+    constructor() {
+        super();
+    }
+    static create() {
+        return new VldUndefined();
+    }
+    parse(value) {
+        if (value !== undefined) {
+            throw new Error(`Expected undefined, received ${typeof value}`);
+        }
+        return undefined;
+    }
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: error };
+        }
+    }
+}
+
+/**
+ * VldNan - Validates that a value is NaN (Not a Number)
+ * Part of Zod 4 API parity implementation
+ */
+/**
+ * NaN validator - validates that a value is NaN
+ * Note: Uses Number.isNaN() which is more strict than global isNaN()
+ */
+class VldNan extends VldBase {
+    constructor() {
+        super();
+    }
+    static create() {
+        return new VldNan();
+    }
+    parse(value) {
+        if (typeof value !== 'number' || !Number.isNaN(value)) {
+            throw new Error(`Expected NaN, received ${typeof value === 'number' ? 'a valid number' : typeof value}`);
+        }
+        return value;
+    }
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return { success: false, error: error };
+        }
+    }
+}
+
+/**
+ * VldLazy - Lazy evaluation for recursive schemas
+ * Part of Zod 4 API parity implementation
+ * Allows schemas that reference themselves (e.g., tree structures, nested categories)
+ */
+/**
+ * Lazy validator - defers schema evaluation until runtime
+ * Essential for recursive and self-referencing types
+ */
+class VldLazy extends VldBase {
+    constructor(_schemaGetter) {
+        super();
+        this._schemaGetter = _schemaGetter;
+        this._cachedSchema = null;
+    }
+    static create(schemaGetter) {
+        return new VldLazy(schemaGetter);
+    }
+    /**
+     * Get the actual schema, caching it after first retrieval
+     */
+    _getSchema() {
+        if (!this._cachedSchema) {
+            this._cachedSchema = this._schemaGetter();
+        }
+        return this._cachedSchema;
+    }
+    /**
+     * Get the inner schema (unwrap)
+     */
+    unwrap() {
+        return this._getSchema();
+    }
+    parse(value) {
+        return this._getSchema().parse(value);
+    }
+    safeParse(value) {
+        return this._getSchema().safeParse(value);
+    }
+}
+
+/**
+ * VldDiscriminatedUnion - Fast union validation using discriminator field
+ * Part of Zod 4 API parity implementation
+ * Provides O(1) lookup performance by using a discriminator key
+ */
+/**
+ * Extract literal values from a schema
+ */
+function extractLiteralValues(schema) {
+    if (schema instanceof VldLiteral) {
+        const value = schema.literal;
+        return [value];
+    }
+    if (schema instanceof VldEnum) {
+        return schema.values;
+    }
+    throw new Error('Discriminator must be a literal or enum schema');
+}
+/**
+ * Discriminated union validator - validates union based on discriminator key
+ * Much faster than regular union when you have a discriminator field
+ */
+class VldDiscriminatedUnion extends VldBase {
+    constructor(_discriminator, _options) {
+        super();
+        this._discriminator = _discriminator;
+        this._options = _options;
+        // Build discriminator map for O(1) lookup
+        this._discriminatorMap = new Map();
+        for (const option of _options) {
+            if (!(option instanceof VldObject)) {
+                throw new Error('All options in a discriminated union must be objects');
+            }
+            const discriminatorSchema = option.config?.shape?.[this._discriminator];
+            if (!discriminatorSchema) {
+                throw new Error(`Missing discriminator key "${this._discriminator}" in one of the options`);
+            }
+            const values = extractLiteralValues(discriminatorSchema);
+            for (const value of values) {
+                if (this._discriminatorMap.has(value)) {
+                    throw new Error(`Duplicate discriminator value "${String(value)}" found in discriminated union`);
+                }
+                this._discriminatorMap.set(value, option);
+            }
+        }
+    }
+    static create(discriminator, options) {
+        return new VldDiscriminatedUnion(discriminator, options);
+    }
+    parse(value) {
+        const result = this.safeParse(value);
+        if (!result.success) {
+            throw result.error;
+        }
+        return result.data;
+    }
+    safeParse(value) {
+        // Check if input is an object
+        if (typeof value !== 'object' || value === null) {
+            return {
+                success: false,
+                error: new Error(`Expected object, received ${value === null ? 'null' : typeof value}`)
+            };
+        }
+        // Get discriminator value
+        const discriminatorValue = value[this._discriminator];
+        // Look up matching schema
+        const matchedSchema = this._discriminatorMap.get(discriminatorValue);
+        if (!matchedSchema) {
+            const validValues = Array.from(this._discriminatorMap.keys());
+            return {
+                success: false,
+                error: new Error(`Invalid discriminator value for "${this._discriminator}". ` +
+                    `Expected one of: ${JSON.stringify(validValues)}, ` +
+                    `received: ${JSON.stringify(discriminatorValue)}`)
+            };
+        }
+        // Validate against matched schema
+        return matchedSchema.safeParse(value);
+    }
+    /**
+     * Get the discriminator key
+     */
+    getDiscriminator() {
+        return this._discriminator;
+    }
+    /**
+     * Get all options
+     */
+    getOptions() {
+        return this._options;
+    }
+}
+
+/**
+ * VldXor - Exclusive union validator
+ * Part of Zod 4 API parity implementation
+ * Ensures exactly one schema in the union matches
+ */
+/**
+ * XOR validator - ensures exactly one option matches
+ * Unlike regular union which allows multiple matches, XOR requires exactly one
+ */
+class VldXor extends VldBase {
+    constructor(_options) {
+        super();
+        this._options = _options;
+    }
+    static create(options) {
+        if (options.length < 2) {
+            throw new Error('XOR requires at least 2 options');
+        }
+        return new VldXor(options);
+    }
+    parse(value) {
+        const result = this.safeParse(value);
+        if (!result.success) {
+            throw result.error;
+        }
+        return result.data;
+    }
+    safeParse(value) {
+        let matchCount = 0;
+        let lastSuccess = null;
+        for (const option of this._options) {
+            const result = option.safeParse(value);
+            if (result.success) {
+                matchCount++;
+                lastSuccess = result;
+                if (matchCount > 1) {
+                    // Early exit if more than one match
+                    break;
+                }
+            }
+        }
+        if (matchCount === 0) {
+            return {
+                success: false,
+                error: new Error('No schema matched in XOR union')
+            };
+        }
+        if (matchCount > 1) {
+            return {
+                success: false,
+                error: new Error(`Input matches ${matchCount} schemas in XOR union, but exactly one is required`)
+            };
+        }
+        return lastSuccess;
+    }
+    /**
+     * Get all options
+     */
+    getOptions() {
+        return this._options;
+    }
+}
+
+/**
+ * Immutable JSON validator that validates and parses JSON strings
+ * Accepts both strings (which are parsed) and already-parsed objects
+ */
+class VldJson extends VldBase {
+    constructor(schema) {
+        super();
+        this.schema = schema;
+    }
+    /**
+     * Create a new JSON validator
+     */
+    static create(schema) {
+        return new VldJson(schema);
+    }
+    /**
+     * Parse and validate a JSON value
+     */
+    parse(value) {
+        let parsed;
+        // If it's a string, try to parse it as JSON first
+        if (typeof value === 'string') {
+            try {
+                parsed = JSON.parse(value);
+            }
+            catch (e) {
+                throw new Error(getMessages().invalidJson);
+            }
+        }
+        else {
+            // Not a string - assume it's already parsed
+            parsed = value;
+        }
+        // If we have a schema, validate against it
+        if (this.schema) {
+            return this.schema.parse(parsed);
+        }
+        // No schema - just return the parsed value
+        return parsed;
+    }
+    /**
+     * Safely parse and validate a JSON value
+     */
+    safeParse(value) {
+        try {
+            return { success: true, data: this.parse(value) };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error
+            };
+        }
+    }
+    /**
+     * Create a new JSON validator with a schema for validation
+     */
+    withSchema(schema) {
+        return new VldJson(schema);
+    }
+}
+
+export { VldSymbol as V, VldStringBool as a, VldArray as b, VldObject as c, VldTuple as d, VldRecord as e, VldSet as f, VldMap as g, VldUnion as h, VldIntersection as i, VldDiscriminatedUnion as j, VldXor as k, VldLiteral as l, VldEnum as m, VldAny as n, VldVoid as o, VldNever as p, VldNull as q, VldUndefined as r, VldNan as s, VldLazy as t, VldJson as u };
+//# sourceMappingURL=json-nIhyRPOU.js.map