@oxog/vld 2.1.0 → 2.2.7

package/dist/validators/enum.js

@@ -1,150 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-
-class VldEnum extends VldBase {
-    /**
-     * Private constructor to enforce immutability
-     */
-    constructor(_values, errorMessage) {
-        super(VLD_VALIDATOR_TYPES.ENUM);
-        this._values = _values;
-        this.errorMessage = errorMessage;
-        this._valueSet = _values.length > 6 ? new Set(_values) : undefined;
-    }
-    createError(value) {
-        return new Error(this.errorMessage ||
-            getMessages().enumExpected([...this._values], JSON.stringify(value)));
-    }
-    /**
-     * Get the enum values
-     */
-    get values() {
-        return this._values;
-    }
-    /**
-     * 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' && typeof value !== 'number') {
-            throw this.createError(value);
-        }
-        const values = this._values;
-        switch (values.length) {
-            case 1:
-                if (value === values[0])
-                    return value;
-                break;
-            case 2:
-                if (value === values[0] || value === values[1])
-                    return value;
-                break;
-            case 3:
-                if (value === values[0] || value === values[1] || value === values[2])
-                    return value;
-                break;
-            case 4:
-                if (value === values[0] || value === values[1] || value === values[2] || value === values[3]) {
-                    return value;
-                }
-                break;
-            case 5:
-                if (value === values[0] || value === values[1] || value === values[2] || value === values[3] || value === values[4]) {
-                    return value;
-                }
-                break;
-            case 6:
-                if (value === values[0] || value === values[1] || value === values[2] || value === values[3] || value === values[4] || value === values[5]) {
-                    return value;
-                }
-                break;
-            default:
-                if (this._valueSet.has(value))
-                    return value;
-                break;
-        }
-        throw this.createError(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' && typeof value !== 'number') {
-            return {
-                success: false,
-                error: this.createError(value)
-            };
-        }
-        const values = this._values;
-        switch (values.length) {
-            case 1:
-                if (value === values[0])
-                    return { success: true, data: value };
-                break;
-            case 2:
-                if (value === values[0] || value === values[1])
-                    return { success: true, data: value };
-                break;
-            case 3:
-                if (value === values[0] || value === values[1] || value === values[2])
-                    return { success: true, data: value };
-                break;
-            case 4:
-                if (value === values[0] || value === values[1] || value === values[2] || value === values[3]) {
-                    return { success: true, data: value };
-                }
-                break;
-            case 5:
-                if (value === values[0] || value === values[1] || value === values[2] || value === values[3] || value === values[4]) {
-                    return { success: true, data: value };
-                }
-                break;
-            case 6:
-                if (value === values[0] || value === values[1] || value === values[2] || value === values[3] || value === values[4] || value === values[5]) {
-                    return { success: true, data: value };
-                }
-                break;
-            default:
-                if (this._valueSet.has(value))
-                    return { success: true, data: value };
-                break;
-        }
-        return {
-            success: false,
-            error: this.createError(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);
-    }
-}
-
-export { VldEnum };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{getMessages as s}from"../locales/runtime.js";import{V as t}from"../chunks/errors-core-CerMg2rq.js";class VldEnum extends e{constructor(e,s){super(r.ENUM),this._values=e,this.errorMessage=s,this._valueSet=e.length>6?new Set(e):void 0}createError(e){const r={code:"invalid_value",path:[],values:[...this._values],message:this.errorMessage||s().enumExpected([...this._values],JSON.stringify(e))};return new t([r])}get values(){return this._values}get options(){return this._values}get enum(){const e={};for(const r of this._values)e[r]=r;return e}static create(e){return new VldEnum(e)}parse(e){if("string"!=typeof e&&"number"!=typeof e)throw this.createError(e);const r=this._values;switch(r.length){case 1:if(e===r[0])return e;break;case 2:if(e===r[0]||e===r[1])return e;break;case 3:if(e===r[0]||e===r[1]||e===r[2])return e;break;case 4:if(e===r[0]||e===r[1]||e===r[2]||e===r[3])return e;break;case 5:if(e===r[0]||e===r[1]||e===r[2]||e===r[3]||e===r[4])return e;break;case 6:if(e===r[0]||e===r[1]||e===r[2]||e===r[3]||e===r[4]||e===r[5])return e;break;default:if(this._valueSet.has(e))return e}throw this.createError(e)}safeParse(e){if("string"!=typeof e&&"number"!=typeof e)return{success:!1,error:this.createError(e)};const r=this._values;switch(r.length){case 1:if(e===r[0])return{success:!0,data:e};break;case 2:if(e===r[0]||e===r[1])return{success:!0,data:e};break;case 3:if(e===r[0]||e===r[1]||e===r[2])return{success:!0,data:e};break;case 4:if(e===r[0]||e===r[1]||e===r[2]||e===r[3])return{success:!0,data:e};break;case 5:if(e===r[0]||e===r[1]||e===r[2]||e===r[3]||e===r[4])return{success:!0,data:e};break;case 6:if(e===r[0]||e===r[1]||e===r[2]||e===r[3]||e===r[4]||e===r[5])return{success:!0,data:e};break;default:if(this._valueSet.has(e))return{success:!0,data:e}}return{success:!1,error:this.createError(e)}}exclude(...e){const r=1===e.length&&Array.isArray(e[0])?e[0]:e,s=this._values.filter(e=>!r.includes(e));if(0===s.length)throw new Error("Cannot exclude all enum values");return new VldEnum(s,this.errorMessage)}extract(...e){const r=1===e.length&&Array.isArray(e[0])?e[0]:e,s=this._values.filter(e=>r.includes(e));if(0===s.length)throw new Error("Cannot extract non-existent enum values");return new VldEnum(s,this.errorMessage)}}export{VldEnum};

package/dist/validators/file.js

@@ -1,125 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-function createFileError(message) {
-    return new VldError([{ code: 'invalid_type', path: [], message }]);
-}
-/**
- * Immutable file validator for file uploads
- * Supports size and MIME type validation
- */
-class VldFile extends VldBase {
-    constructor(checks = []) {
-        super(VLD_VALIDATOR_TYPES.FILE);
-        this.checks = checks;
-    }
-    /**
-     * Create a new file validator
-     */
-    static create() {
-        return new VldFile();
-    }
-    isFileLike(value) {
-        if (typeof value !== 'object' || value === null) {
-            return false;
-        }
-        if (typeof File !== 'undefined' && value instanceof File) {
-            return true;
-        }
-        return 'size' in value && 'type' in value;
-    }
-    /**
-     * Parse and validate a file value
-     */
-    parse(value) {
-        if (this.isFileLike(value)) {
-            return this.parseKnownFile(value);
-        }
-        if (typeof File === 'undefined') {
-            throw new Error(getMessages().fileNotSupported || 'File API not supported in this environment');
-        }
-        throw new Error(getMessages().invalidFile || 'Expected a File object');
-    }
-    /**
-     * Parse a value that has already passed the file-like type guard.
-     * @internal Used by object validators to avoid duplicate hot-path checks.
-     */
-    parseKnownFile(value) {
-        return this.runChecks(value);
-    }
-    /**
-     * Run all validation checks on the file
-     */
-    runChecks(file) {
-        const msgs = getMessages();
-        for (const check of this.checks) {
-            switch (check.type) {
-                case 'min':
-                    if (file.size < check.value) {
-                        throw new Error(check.message ||
-                            (msgs.fileMinSize?.(check.value) || `File size must be at least ${check.value} bytes`));
-                    }
-                    break;
-                case 'max':
-                    if (file.size > check.value) {
-                        throw new Error(check.message ||
-                            (msgs.fileMaxSize?.(check.value) || `File size must not exceed ${check.value} bytes`));
-                    }
-                    break;
-                case 'mime':
-                    if (!check.value.includes(file.type)) {
-                        throw new Error(check.message ||
-                            (msgs.fileMimeType?.(check.value) || `Invalid file type. Expected: ${check.value.join(', ')}`));
-                    }
-                    break;
-            }
-        }
-        return file;
-    }
-    /**
-     * Safely parse and validate a file value
-     */
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: createFileError(error.message) };
-        }
-    }
-    /**
-     * Set minimum file size in bytes
-     */
-    min(bytes, message) {
-        return new VldFile([...this.checks, { type: 'min', value: bytes, message }]);
-    }
-    /**
-     * Set maximum file size in bytes
-     */
-    max(bytes, message) {
-        return new VldFile([...this.checks, { type: 'max', value: bytes, message }]);
-    }
-    /**
-     * Set allowed MIME types
-     */
-    mime(types, message) {
-        const typeArray = Array.isArray(types) ? types : [types];
-        return new VldFile([...this.checks, { type: 'mime', value: typeArray, message }]);
-    }
-    /**
-     * Set both minimum and maximum file size
-     */
-    size(min, max, message) {
-        return this.min(min, message).max(max, message);
-    }
-}
-/**
- * Helper function to create file validators
- * Usage: v.file().min(1024).max(10485760).mime(['image/jpeg', 'image/png'])
- */
-function file() {
-    return VldFile.create();
-}
-
-export { VldFile, file };
+import{VldBase as e,VLD_VALIDATOR_TYPES as s}from"./base.js";import{getMessages as i}from"../locales/runtime.js";import{V as r}from"../chunks/errors-core-CerMg2rq.js";class VldFile extends e{constructor(e=[]){super(s.FILE),this.checks=e}static create(){return new VldFile}isFileLike(e){return"object"==typeof e&&null!==e&&("undefined"!=typeof File&&e instanceof File||"size"in e&&"type"in e)}parse(e){if(this.isFileLike(e))return this.parseKnownFile(e);if("undefined"==typeof File)throw new Error(i().fileNotSupported||"File API not supported in this environment");throw new Error(i().invalidFile||"Expected a File object")}parseKnownFile(e){return this.runChecks(e)}runChecks(e){const s=i();for(const i of this.checks)switch(i.type){case"min":if(e.size<i.value)throw new Error(i.message||s.fileMinSize?.(i.value)||`File size must be at least ${i.value} bytes`);break;case"max":if(e.size>i.value)throw new Error(i.message||s.fileMaxSize?.(i.value)||`File size must not exceed ${i.value} bytes`);break;case"mime":if(!i.value.includes(e.type))throw new Error(i.message||s.fileMimeType?.(i.value)||`Invalid file type. Expected: ${i.value.join(", ")}`)}return e}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:(s=e.message,new r([{code:"invalid_type",path:[],message:s}]))}}var s}min(e,s){return new VldFile([...this.checks,{type:"min",value:e,message:s}])}max(e,s){return new VldFile([...this.checks,{type:"max",value:e,message:s}])}mime(e,s){const i=Array.isArray(e)?e:[e];return new VldFile([...this.checks,{type:"mime",value:i,message:s}])}size(e,s,i){return this.min(e,i).max(s,i)}}function t(){return VldFile.create()}export{VldFile,t as file};

package/dist/validators/function.js

@@ -1,58 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-function createFunctionError(message) {
-    return new VldError([{ code: 'invalid_type', path: [], message }]);
-}
-/**
- * Immutable function validator
- * Validates that a value is a function
- */
-class VldFunction extends VldBase {
-    constructor() {
-        super(VLD_VALIDATOR_TYPES.FUNCTION);
-    }
-    /**
-     * Create a new function validator
-     */
-    static create() {
-        return new VldFunction();
-    }
-    /**
-     * Parse and validate a function value
-     */
-    parse(value) {
-        if (typeof value !== 'function') {
-            throw new Error(getMessages().invalidFunction || 'Expected a function');
-        }
-        return value;
-    }
-    /**
-     * Parse a value that has already passed the function type guard.
-     * @internal Used by object validators to avoid duplicate hot-path checks.
-     */
-    parseKnownFunction(value) {
-        return value;
-    }
-    /**
-     * Safely parse and validate a function value
-     */
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: createFunctionError(error.message) };
-        }
-    }
-}
-/**
- * Helper function to create function validators
- * Usage: v.function()
- */
-function functionValidator() {
-    return VldFunction.create();
-}
-
-export { VldFunction, functionValidator };
+import{VldBase as r,VLD_VALIDATOR_TYPES as e}from"./base.js";import{getMessages as t}from"../locales/runtime.js";import{V as n}from"../chunks/errors-core-CerMg2rq.js";class VldFunction extends r{constructor(){super(e.FUNCTION)}static create(){return new VldFunction}parse(r){if("function"!=typeof r)throw new Error(t().invalidFunction||"Expected a function");return r}parseKnownFunction(r){return r}safeParse(r){try{return{success:!0,data:this.parse(r)}}catch(r){return{success:!1,error:(e=r.message,new n([{code:"invalid_type",path:[],message:e}]))}}var e}}function s(){return VldFunction.create()}export{VldFunction,s as functionValidator};

package/dist/validators/hex.js

@@ -1,65 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { createIssue } from '../errors.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-/**
- * Hexadecimal string validator
- */
-class VldHex extends VldBase {
-    constructor(lowercase = false) {
-        super(VLD_VALIDATOR_TYPES.HEX);
-        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]*$/;
-
-export { VldHex };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{createIssue as s}from"../errors.js";import{getMessages as t}from"../locales/runtime.js";import{V as o}from"../chunks/errors-core-CerMg2rq.js";class VldHex extends e{constructor(e=!1){super(r.HEX),this.lowercase=e}parse(e){const r=this.safeParse(e);if(!r.success)throw r.error;return r.data}safeParse(e){if("string"!=typeof e)return{success:!1,error:new o([s("invalid_type",[],t().expectedString)])};if(!VldHex.HEX_REGEX.test(e))return{success:!1,error:new o([s("custom",[],t().invalidHex)])};if(e.length%2!=0)return{success:!1,error:new o([s("custom",[],t().invalidHex)])};return{success:!0,data:this.lowercase?e.toLowerCase():e}}lowercaseMode(){return new VldHex(!0)}static create(e=!1){return new VldHex(e)}}VldHex.HEX_REGEX=/^[0-9a-fA-F]*$/;export{VldHex};

package/dist/validators/index.d.ts

@@ -37,7 +37,7 @@ export { VldFile, file } from './file.js';
 export type { VldFileValue } from './file.js';
 export { VldFunction, functionValidator } from './function.js';
 export { VldPromise, promise } from './promise.js';
-export { email, uuid, uuidv4, hostname, emoji, base64, base64url, hex, jwt, nanoid, cuid, cuid2, ulid, ipv4, ipv6, mac, cidrv4, cidrv6, e164, hash, iso, stringFormat, regexes, xid, guid, httpUrl } from './string-formats.js';
+export { email, url, uuid, uuidv4, uuidv6, uuidv7, hostname, emoji, base64, base64url, hex, jwt, nanoid, cuid, cuid2, ulid, ipv4, ipv6, mac, cidrv4, cidrv6, e164, hash, iso, stringFormat, regexes, xid, guid, httpUrl, ksuid, type ISODateTimeOptions, type ISOTimeOptions, type URLFormatOptions, type UUIDVersion } from './string-formats.js';
 import { VldBase } from './base.js';
 export type Infer<T extends VldBase<any, any>> = T extends VldBase<any, infer U> ? U : never;
 export type Input<T extends VldBase<any, any>> = T extends VldBase<infer I, any> ? I : never;

package/dist/validators/index.js

@@ -1,35 +1 @@
-export { VldBase, VldBrand, VldCatch, VldDefault, VldExactOptional, VldNullable, VldNullish, VldOptional, VldPipe, VldPreprocess, VldReadonly, VldRefine, VldSuperRefine, VldTransform } from './base.js';
-export { V as VldString } from '../chunks/string-BJRQod3t.js';
-export { VldNumber } from './number.js';
-export { VldBoolean } from './boolean.js';
-export { VldDate } from './date.js';
-export { VldStringBool } from './string-bool.js';
-export { VldArray } from './array.js';
-export { VldObject } from './object.js';
-export { VldUnion } from './union.js';
-export { VldIntersection } from './intersection.js';
-export { VldLiteral } from './literal.js';
-export { VldEnum } from './enum.js';
-export { VldTuple } from './tuple.js';
-export { VldRecord } from './record.js';
-export { VldSet } from './set.js';
-export { VldMap } from './map.js';
-export { VldBigInt } from './bigint.js';
-export { VldSymbol } from './symbol.js';
-export { VldAny } from './any.js';
-export { VldUnknown } from './unknown.js';
-export { VldVoid } from './void.js';
-export { VldNever } from './never.js';
-export { VldNull } from './null.js';
-export { VldUndefined } from './undefined.js';
-export { VldNan } from './nan.js';
-export { VldLazy } from './lazy.js';
-export { VldDiscriminatedUnion } from './discriminated-union.js';
-export { VldXor } from './xor.js';
-export { VldJson } from './json.js';
-export { VldTemplateLiteral, templateLiteral } from './template-literal.js';
-export { VldCustom, custom } from './custom.js';
-export { VldFile, file } from './file.js';
-export { VldFunction, functionValidator } from './function.js';
-export { VldPromise, promise } from './promise.js';
-export { base64, base64url, cidrv4, cidrv6, cuid, cuid2, e164, email, emoji, guid, hash, hex, hostname, httpUrl, ipv4, ipv6, iso, jwt, mac, nanoid, regexes, stringFormat, ulid, uuid, uuidv4, xid } from './string-formats.js';
+export{VldBase,VldBrand,VldCatch,VldDefault,VldExactOptional,VldNullable,VldNullish,VldOptional,VldPipe,VldPreprocess,VldReadonly,VldRefine,VldSuperRefine,VldTransform}from"./base.js";export{VldString}from"./string.js";export{VldNumber}from"./number.js";export{VldBoolean}from"./boolean.js";export{VldDate}from"./date.js";export{VldStringBool}from"./string-bool.js";export{VldArray}from"./array.js";export{VldObject}from"./object.js";export{VldUnion}from"./union.js";export{VldIntersection}from"./intersection.js";export{VldLiteral}from"./literal.js";export{VldEnum}from"./enum.js";export{VldTuple}from"./tuple.js";export{VldRecord}from"./record.js";export{VldSet}from"./set.js";export{VldMap}from"./map.js";export{VldBigInt}from"./bigint.js";export{VldSymbol}from"./symbol.js";export{VldAny}from"./any.js";export{VldUnknown}from"./unknown.js";export{VldVoid}from"./void.js";export{VldNever}from"./never.js";export{VldNull}from"./null.js";export{VldUndefined}from"./undefined.js";export{VldNan}from"./nan.js";export{VldLazy}from"./lazy.js";export{VldDiscriminatedUnion}from"./discriminated-union.js";export{VldXor}from"./xor.js";export{VldJson}from"./json.js";export{VldTemplateLiteral,templateLiteral}from"./template-literal.js";export{VldCustom,custom}from"./custom.js";export{VldFile,file}from"./file.js";export{VldFunction,functionValidator}from"./function.js";export{VldPromise,promise}from"./promise.js";export{base64,base64url,cidrv4,cidrv6,cuid,cuid2,e164,email,emoji,guid,hash,hex,hostname,httpUrl,ipv4,ipv6,iso,jwt,ksuid,mac,nanoid,regexes,stringFormat,ulid,url,uuid,uuidv4,uuidv6,uuidv7,xid}from"./string-formats.js";

package/dist/validators/intersection.js

@@ -1,116 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { i as isDangerousKey } from '../chunks/security-B0Pd_vSY.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-/**
- * 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;
-}
-
-function createIntersectionError(message) {
-    return new VldError([{ code: 'invalid_type', path: [], message }]);
-}
-/**
- * Immutable intersection validator for combining validators
- */
-class VldIntersection extends VldBase {
-    /**
-     * Private constructor to enforce immutability
-     */
-    constructor(validatorA, validatorB) {
-        super(VLD_VALIDATOR_TYPES.INTERSECTION);
-        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: createIntersectionError(error.message) };
-        }
-    }
-}
-
-export { VldIntersection };
+import{VldBase as t,VLD_VALIDATOR_TYPES as e}from"./base.js";import{i as r}from"../chunks/security-Dy24T8N7.js";import{getMessages as o}from"../locales/runtime.js";import{V as s}from"../chunks/errors-core-CerMg2rq.js";function n(t){return null!==t&&"object"==typeof t&&t.constructor===Object&&"[object Object]"===Object.prototype.toString.call(t)}function c(t,e){const o={...t},s=Object.keys(e);for(let i=0;i<s.length;i++){const a=s[i];if(r(a))continue;if(!Object.prototype.hasOwnProperty.call(e,a))continue;const u=e[a],p=t[a];n(u)&&n(p)?o[a]=c(p,u):o[a]=u}return o}class VldIntersection extends t{constructor(t,r){super(e.INTERSECTION),this.validatorA=t,this.validatorB=r}static create(t,e){return new VldIntersection(t,e)}parse(t){try{const e=this.validatorA.parse(t),r=this.validatorB.parse(t),o=n(e),s=n(r);if(o&&s)return c(e,r);if(!o&&!s){if(e===r)return e;throw new Error("Values must be identical for intersection of primitive types")}throw new Error("Cannot create intersection of object and primitive types. Both validators must produce the same type category.")}catch(t){throw new Error(o().intersectionError(t.message))}}safeParse(t){try{return{success:!0,data:this.parse(t)}}catch(t){return{success:!1,error:(e=t.message,new s([{code:"invalid_type",path:[],message:e}]))}}var e}}export{VldIntersection};

package/dist/validators/json.js

@@ -1,66 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-
-/**
- * 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(VLD_VALIDATOR_TYPES.JSON);
-        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 {
-                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 { VldJson };
+import{VldBase as s,VLD_VALIDATOR_TYPES as r,ensureVldError as e}from"./base.js";import{getMessages as t}from"../locales/runtime.js";class VldJson extends s{constructor(s){super(r.JSON),this.schema=s}static create(s){return new VldJson(s)}parse(s){let r;if("string"==typeof s)try{r=JSON.parse(s)}catch{throw new Error(t().invalidJson)}else r=s;return this.schema?this.schema.parse(r):r}safeParse(s){try{return{success:!0,data:this.parse(s)}}catch(s){return{success:!1,error:e(s)}}}withSchema(s){return new VldJson(s)}}export{VldJson};