@oxog/vld 1.0.0 → 1.1.1

package/dist/index.js

@@ -1,1170 +1,92 @@
-// VLD - Fast, Type-Safe Validation Library
-// Zero dependencies, blazing fast performance
-import { getMessages } from './locales/index.js';
-// Base class for all validators
-class VldBase {
-    refine(predicate, message) {
-        return new VldRefine(this, predicate, message);
-    }
-    // Transform data after validation
-    transform(fn) {
-        return new VldTransform(this, fn);
-    }
-    // Add default value
-    default(value) {
-        return new VldDefault(this, value);
-    }
-    // Catch validation errors and provide fallback
-    catch(value) {
-        return new VldCatch(this, value);
-    }
-}
-// Pre-compiled regex patterns
-const EMAIL_REGEX = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)+$/;
-const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-const URL_REGEX = /^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)$/;
-const IPV4_REGEX = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
-const IPV6_REGEX = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
-// Helper function for deep merging objects in intersection
-function deepMerge(obj1, obj2) {
-    const result = { ...obj1 };
-    for (const key in obj2) {
-        if (obj2.hasOwnProperty(key)) {
-            if (typeof obj2[key] === 'object' && obj2[key] !== null && !Array.isArray(obj2[key]) &&
-                typeof obj1[key] === 'object' && obj1[key] !== null && !Array.isArray(obj1[key])) {
-                result[key] = deepMerge(obj1[key], obj2[key]);
-            }
-            else {
-                result[key] = obj2[key];
-            }
-        }
-    }
-    return result;
-}
-// String validator
-export class VldString extends VldBase {
-    constructor() {
-        super(...arguments);
-        this.checks = [];
-        this.transforms = [];
-        this.errorMessage = getMessages().invalidString;
-    }
-    parse(value) {
-        if (typeof value !== 'string') {
-            throw new Error(this.errorMessage || getMessages().invalidString);
-        }
-        let val = value;
-        // Apply transforms
-        for (const transform of this.transforms) {
-            val = transform(val);
-        }
-        // Apply checks
-        for (const check of this.checks) {
-            if (!check(val)) {
-                throw new Error(this.errorMessage || getMessages().invalidString);
-            }
-        }
-        return val;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-    // Chainable methods
-    min(length, message) {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks, (v) => v.length >= length];
-        newValidator.transforms = [...this.transforms];
-        newValidator.errorMessage = message || getMessages().stringMin(length);
-        return newValidator;
-    }
-    max(length, message) {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks, (v) => v.length <= length];
-        newValidator.transforms = [...this.transforms];
-        newValidator.errorMessage = message || getMessages().stringMax(length);
-        return newValidator;
-    }
-    length(length, message) {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks, (v) => v.length === length];
-        newValidator.transforms = [...this.transforms];
-        newValidator.errorMessage = message || getMessages().stringLength(length);
-        return newValidator;
-    }
-    email(message) {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks, (v) => EMAIL_REGEX.test(v)];
-        newValidator.transforms = [...this.transforms];
-        newValidator.errorMessage = message || getMessages().stringEmail;
-        return newValidator;
-    }
-    url(message) {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks, (v) => URL_REGEX.test(v)];
-        newValidator.transforms = [...this.transforms];
-        newValidator.errorMessage = message || getMessages().stringUrl;
-        return newValidator;
-    }
-    uuid(message) {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks, (v) => UUID_REGEX.test(v)];
-        newValidator.transforms = [...this.transforms];
-        newValidator.errorMessage = message || getMessages().stringUuid;
-        return newValidator;
-    }
-    regex(pattern, message) {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks, (v) => pattern.test(v)];
-        newValidator.transforms = [...this.transforms];
-        newValidator.errorMessage = message || getMessages().stringRegex;
-        return newValidator;
-    }
-    trim() {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks];
-        newValidator.transforms = [...this.transforms, (v) => v.trim()];
-        newValidator.errorMessage = this.errorMessage;
-        return newValidator;
-    }
-    toLowerCase() {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks];
-        newValidator.transforms = [...this.transforms, (v) => v.toLowerCase()];
-        newValidator.errorMessage = this.errorMessage;
-        return newValidator;
-    }
-    toUpperCase() {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks];
-        newValidator.transforms = [...this.transforms, (v) => v.toUpperCase()];
-        newValidator.errorMessage = this.errorMessage;
-        return newValidator;
-    }
-    startsWith(str, message) {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks, (v) => v.startsWith(str)];
-        newValidator.transforms = [...this.transforms];
-        newValidator.errorMessage = message || getMessages().stringStartsWith(str);
-        return newValidator;
-    }
-    endsWith(str, message) {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks, (v) => v.endsWith(str)];
-        newValidator.transforms = [...this.transforms];
-        newValidator.errorMessage = message || getMessages().stringEndsWith(str);
-        return newValidator;
-    }
-    includes(str, message) {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks, (v) => v.includes(str)];
-        newValidator.transforms = [...this.transforms];
-        newValidator.errorMessage = message || getMessages().stringIncludes(str);
-        return newValidator;
-    }
-    ip(message) {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks, (v) => IPV4_REGEX.test(v) || IPV6_REGEX.test(v)];
-        newValidator.transforms = [...this.transforms];
-        newValidator.errorMessage = message || getMessages().stringIp;
-        return newValidator;
-    }
-    ipv4(message) {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks, (v) => IPV4_REGEX.test(v)];
-        newValidator.transforms = [...this.transforms];
-        newValidator.errorMessage = message || getMessages().stringIpv4;
-        return newValidator;
-    }
-    ipv6(message) {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks, (v) => IPV6_REGEX.test(v)];
-        newValidator.transforms = [...this.transforms];
-        newValidator.errorMessage = message || getMessages().stringIpv6;
-        return newValidator;
-    }
-    nonempty(message) {
-        const newValidator = new VldString();
-        newValidator.checks = [...this.checks, (v) => v.length > 0];
-        newValidator.transforms = [...this.transforms];
-        newValidator.errorMessage = message || getMessages().stringEmpty;
-        return newValidator;
-    }
-}
-// Number validator
-export class VldNumber extends VldBase {
-    constructor() {
-        super(...arguments);
-        this.checks = [];
-        this.errorMessage = getMessages().invalidNumber;
-    }
-    parse(value) {
-        if (typeof value !== 'number' || isNaN(value)) {
-            throw new Error(this.errorMessage || getMessages().invalidNumber);
-        }
-        for (const check of this.checks) {
-            if (!check(value)) {
-                throw new Error(this.errorMessage || getMessages().invalidNumber);
-            }
-        }
-        return value;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-    min(value, message) {
-        const newValidator = new VldNumber();
-        newValidator.checks = [...this.checks, (v) => v >= value];
-        newValidator.errorMessage = message || getMessages().numberMin(value);
-        return newValidator;
-    }
-    max(value, message) {
-        const newValidator = new VldNumber();
-        newValidator.checks = [...this.checks, (v) => v <= value];
-        newValidator.errorMessage = message || getMessages().numberMax(value);
-        return newValidator;
-    }
-    int(message) {
-        const newValidator = new VldNumber();
-        newValidator.checks = [...this.checks, (v) => Number.isInteger(v)];
-        newValidator.errorMessage = message || getMessages().numberInt;
-        return newValidator;
-    }
-    positive(message) {
-        const newValidator = new VldNumber();
-        newValidator.checks = [...this.checks, (v) => v > 0];
-        newValidator.errorMessage = message || getMessages().numberPositive;
-        return newValidator;
-    }
-    negative(message) {
-        const newValidator = new VldNumber();
-        newValidator.checks = [...this.checks, (v) => v < 0];
-        newValidator.errorMessage = message || getMessages().numberNegative;
-        return newValidator;
-    }
-    nonnegative(message) {
-        const newValidator = new VldNumber();
-        newValidator.checks = [...this.checks, (v) => v >= 0];
-        newValidator.errorMessage = message || getMessages().numberNonnegative;
-        return newValidator;
-    }
-    nonpositive(message) {
-        const newValidator = new VldNumber();
-        newValidator.checks = [...this.checks, (v) => v <= 0];
-        newValidator.errorMessage = message || getMessages().numberNonpositive;
-        return newValidator;
-    }
-    finite(message) {
-        const newValidator = new VldNumber();
-        newValidator.checks = [...this.checks, (v) => Number.isFinite(v)];
-        newValidator.errorMessage = message || getMessages().numberFinite;
-        return newValidator;
-    }
-    safe(message) {
-        const newValidator = new VldNumber();
-        newValidator.checks = [...this.checks, (v) => Number.isSafeInteger(v)];
-        newValidator.errorMessage = message || getMessages().numberSafe;
-        return newValidator;
-    }
-    multipleOf(value, message) {
-        const newValidator = new VldNumber();
-        newValidator.checks = [...this.checks, (v) => v % value === 0];
-        newValidator.errorMessage = message || getMessages().numberMultipleOf(value);
-        return newValidator;
-    }
-    step(value, message) {
-        return this.multipleOf(value, message);
-    }
-}
-// Boolean validator
-export class VldBoolean extends VldBase {
-    constructor() {
-        super(...arguments);
-        this.errorMessage = getMessages().invalidBoolean;
-    }
-    parse(value) {
-        if (typeof value !== 'boolean') {
-            throw new Error(this.errorMessage || getMessages().invalidBoolean);
-        }
-        return value;
-    }
-    safeParse(value) {
-        if (typeof value === 'boolean') {
-            return { success: true, data: value };
-        }
-        return { success: false, error: new Error(this.errorMessage) };
-    }
-}
-// Array validator
-export class VldArray extends VldBase {
-    constructor(itemValidator) {
-        super();
-        this.itemValidator = itemValidator;
-    }
-    parse(value) {
-        if (!Array.isArray(value)) {
-            throw new Error(getMessages().invalidArray);
-        }
-        return value.map((item, index) => {
-            try {
-                return this.itemValidator.parse(item);
-            }
-            catch (error) {
-                throw new Error(getMessages().arrayItem(index, error.message));
-            }
-        });
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-    min(length, message) {
-        const originalParse = this.parse.bind(this);
-        this.parse = (value) => {
-            const arr = originalParse(value);
-            if (arr.length < length) {
-                throw new Error(message || getMessages().arrayMin(length));
-            }
-            return arr;
-        };
-        return this;
-    }
-    max(length, message) {
-        const originalParse = this.parse.bind(this);
-        this.parse = (value) => {
-            const arr = originalParse(value);
-            if (arr.length > length) {
-                throw new Error(message || getMessages().arrayMax(length));
-            }
-            return arr;
-        };
-        return this;
-    }
-    length(length, message) {
-        const originalParse = this.parse.bind(this);
-        this.parse = (value) => {
-            const arr = originalParse(value);
-            if (arr.length !== length) {
-                throw new Error(message || getMessages().arrayLength(length));
-            }
-            return arr;
-        };
-        return this;
-    }
-    nonempty(message) {
-        return this.min(1, message || getMessages().arrayEmpty);
-    }
-}
-// Object validator
-export class VldObject extends VldBase {
-    constructor(shape) {
-        super();
-        this.shape = shape;
-    }
-    parse(value) {
-        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-            throw new Error(getMessages().invalidObject);
-        }
-        const result = {};
-        const obj = value;
-        for (const [key, validator] of Object.entries(this.shape)) {
-            try {
-                result[key] = validator.parse(obj[key]);
-            }
-            catch (error) {
-                throw new Error(getMessages().objectField(key, error.message));
-            }
-        }
-        return result;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-    partial() {
-        const partialShape = {};
-        for (const [key, validator] of Object.entries(this.shape)) {
-            partialShape[key] = new VldOptional(validator);
-        }
-        return new VldObject(partialShape);
-    }
-    strict() {
-        const originalParse = this.parse.bind(this);
-        this.parse = (value) => {
-            const result = originalParse(value);
-            const obj = value;
-            const extraKeys = Object.keys(obj).filter(key => !(key in this.shape));
-            if (extraKeys.length > 0) {
-                throw new Error(getMessages().unexpectedKeys(extraKeys));
-            }
-            return result;
-        };
-        return this;
-    }
-    pick(...keys) {
-        const pickedShape = {};
-        for (const key of keys) {
-            if (key in this.shape) {
-                pickedShape[key] = this.shape[key];
-            }
-        }
-        return new VldObject(pickedShape);
-    }
-    omit(...keys) {
-        const omittedShape = {};
-        for (const [key, validator] of Object.entries(this.shape)) {
-            if (!keys.includes(key)) {
-                omittedShape[key] = validator;
-            }
-        }
-        return new VldObject(omittedShape);
-    }
-    extend(extension) {
-        const extendedShape = { ...this.shape };
-        for (const [key, validator] of Object.entries(extension)) {
-            extendedShape[key] = validator;
-        }
-        return new VldObject(extendedShape);
-    }
-}
-// Optional validator
-export class VldOptional extends VldBase {
-    constructor(validator) {
-        super();
-        this.validator = validator;
-    }
-    parse(value) {
-        if (value === undefined) {
-            return undefined;
-        }
-        return this.validator.parse(value);
-    }
-    safeParse(value) {
-        if (value === undefined) {
-            return { success: true, data: undefined };
-        }
-        return this.validator.safeParse(value);
-    }
-}
-// Nullable validator
-export class VldNullable extends VldBase {
-    constructor(validator) {
-        super();
-        this.validator = validator;
-    }
-    parse(value) {
-        if (value === null) {
-            return null;
-        }
-        return this.validator.parse(value);
-    }
-    safeParse(value) {
-        if (value === null) {
-            return { success: true, data: null };
-        }
-        return this.validator.safeParse(value);
-    }
-}
-// Union validator
-export class VldUnion extends VldBase {
-    constructor(validators) {
-        super();
-        this.validators = validators;
-    }
-    parse(value) {
-        const errors = [];
-        for (const validator of this.validators) {
-            try {
-                return validator.parse(value);
-            }
-            catch (error) {
-                errors.push(error);
-            }
-        }
-        throw new Error(getMessages().unionNoMatch(errors.map(e => e.message)));
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-// Intersection validator
-export class VldIntersection extends VldBase {
-    constructor(validatorA, validatorB) {
-        super();
-        this.validatorA = validatorA;
-        this.validatorB = validatorB;
-    }
-    parse(value) {
-        try {
-            // Both validators must pass
-            const resultA = this.validatorA.parse(value);
-            const resultB = this.validatorB.parse(value);
-            // For object types, deep merge the results
-            if (typeof resultA === 'object' && resultA !== null &&
-                typeof resultB === 'object' && resultB !== null &&
-                !Array.isArray(resultA) && !Array.isArray(resultB)) {
-                return deepMerge(resultA, resultB);
-            }
-            // For primitive types, both must be the same value
-            if (resultA === resultB) {
-                return resultA;
-            }
-            // If they're different primitive values, this is an error
-            throw new Error(getMessages().intersectionError('Values must be identical for intersection of primitive types'));
-        }
-        catch (error) {
-            throw new Error(getMessages().intersectionError(error.message));
-        }
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-// Literal validator
-export class VldLiteral extends VldBase {
-    constructor(literal) {
-        super();
-        this.literal = literal;
-    }
-    parse(value) {
-        if (value !== this.literal) {
-            throw new Error(getMessages().literalExpected(JSON.stringify(this.literal), JSON.stringify(value)));
-        }
-        return this.literal;
-    }
-    safeParse(value) {
-        if (value === this.literal) {
-            return { success: true, data: this.literal };
-        }
-        return { success: false, error: new Error(getMessages().literalExpected(JSON.stringify(this.literal), 'received')) };
-    }
-}
-// Enum validator
-export class VldEnum extends VldBase {
-    constructor(values) {
-        super();
-        this.values = values;
-    }
-    parse(value) {
-        if (!this.values.includes(value)) {
-            throw new Error(getMessages().enumExpected([...this.values], JSON.stringify(value)));
-        }
-        return value;
-    }
-    safeParse(value) {
-        if (this.values.includes(value)) {
-            return { success: true, data: value };
-        }
-        return { success: false, error: new Error(getMessages().enumExpected([...this.values], 'received')) };
-    }
-}
-// Date validator
-export class VldDate extends VldBase {
-    constructor() {
-        super(...arguments);
-        this.checks = [];
-        this.errorMessage = getMessages().invalidDate;
-    }
-    parse(value) {
-        let date;
-        if (value instanceof Date) {
-            date = value;
-        }
-        else if (typeof value === 'string' || typeof value === 'number') {
-            date = new Date(value);
-        }
-        else {
-            throw new Error(this.errorMessage || getMessages().invalidDate);
-        }
-        if (isNaN(date.getTime())) {
-            throw new Error(this.errorMessage || getMessages().invalidDate);
-        }
-        for (const check of this.checks) {
-            if (!check(date)) {
-                throw new Error(this.errorMessage || getMessages().invalidDate);
-            }
-        }
-        return date;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-    min(date, message) {
-        const newValidator = new VldDate();
-        newValidator.checks = [...this.checks, (v) => v >= date];
-        newValidator.errorMessage = message || getMessages().dateMin(date);
-        return newValidator;
-    }
-    max(date, message) {
-        const newValidator = new VldDate();
-        newValidator.checks = [...this.checks, (v) => v <= date];
-        newValidator.errorMessage = message || getMessages().dateMax(date);
-        return newValidator;
-    }
-}
-// Any validator
-export class VldAny extends VldBase {
-    parse(value) {
-        return value;
-    }
-    safeParse(value) {
-        return { success: true, data: value };
-    }
-}
-// Unknown validator
-export class VldUnknown extends VldBase {
-    parse(value) {
-        return value;
-    }
-    safeParse(value) {
-        return { success: true, data: value };
-    }
-}
-// Void validator
-export class VldVoid extends VldBase {
-    parse(value) {
-        if (value !== undefined) {
-            throw new Error(getMessages().expectedUndefined);
-        }
-        return undefined;
-    }
-    safeParse(value) {
-        if (value === undefined) {
-            return { success: true, data: undefined };
-        }
-        return { success: false, error: new Error(getMessages().expectedUndefined) };
-    }
-}
-// Never validator
-export class VldNever extends VldBase {
-    parse(_value) {
-        throw new Error(getMessages().neverType);
-    }
-    safeParse(_value) {
-        return { success: false, error: new Error(getMessages().neverType) };
-    }
-}
-// BigInt validator
-export class VldBigInt extends VldBase {
-    constructor() {
-        super(...arguments);
-        this.checks = [];
-        this.errorMessage = getMessages().invalidBigint;
-    }
-    parse(value) {
-        if (typeof value !== 'bigint') {
-            throw new Error(this.errorMessage || getMessages().invalidBigint);
-        }
-        for (const check of this.checks) {
-            if (!check(value)) {
-                throw new Error(this.errorMessage || getMessages().invalidBigint);
-            }
-        }
-        return value;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-// Symbol validator
-export class VldSymbol extends VldBase {
-    constructor() {
-        super(...arguments);
-        this.errorMessage = getMessages().invalidSymbol;
-    }
-    parse(value) {
-        if (typeof value !== 'symbol') {
-            throw new Error(this.errorMessage || getMessages().invalidSymbol);
-        }
-        return value;
-    }
-    safeParse(value) {
-        if (typeof value === 'symbol') {
-            return { success: true, data: value };
-        }
-        return { success: false, error: new Error(this.errorMessage) };
-    }
-}
-// Tuple validator
-export class VldTuple extends VldBase {
-    constructor(validators) {
-        super();
-        this.validators = validators;
-    }
-    parse(value) {
-        if (!Array.isArray(value)) {
-            throw new Error(getMessages().invalidTuple);
-        }
-        if (value.length !== this.validators.length) {
-            throw new Error(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;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-// Record validator
-export class VldRecord 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)) {
-            try {
-                result[key] = this.valueValidator.parse(val);
-            }
-            catch (error) {
-                throw new Error(getMessages().objectField(key, error.message));
-            }
-        }
-        return result;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-// Set validator
-export class VldSet extends VldBase {
-    constructor(itemValidator) {
-        super();
-        this.itemValidator = itemValidator;
-    }
-    parse(value) {
-        if (!(value instanceof Set)) {
-            throw new Error(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;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-// Map validator
-export class VldMap extends VldBase {
-    constructor(keyValidator, valueValidator) {
-        super();
-        this.keyValidator = keyValidator;
-        this.valueValidator = valueValidator;
-    }
-    parse(value) {
-        if (!(value instanceof Map)) {
-            throw new Error(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;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-// Coercion classes
-export class VldCoerceString extends VldString {
-    parse(value) {
-        try {
-            // Attempt coercion to string
-            if (value === null || value === undefined) {
-                throw new Error(getMessages().coercionFailed('string', value));
-            }
-            const coerced = String(value);
-            // Call parent parse with coerced value
-            return super.parse(coerced);
-        }
-        catch (error) {
-            const errorMessage = error.message;
-            // If it's a coercion error, re-throw as is
-            if (errorMessage.includes('Cannot coerce')) {
-                throw error;
-            }
-            // If it's a validation error from parent, re-throw as is
-            if (errorMessage.includes('String must') || errorMessage.includes('Invalid')) {
-                throw error;
-            }
-            // Otherwise, it's a coercion failure
-            throw new Error(getMessages().coercionFailed('string', value));
-        }
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-export class VldCoerceNumber extends VldNumber {
-    parse(value) {
-        try {
-            // Attempt coercion to number
-            if (typeof value === 'string') {
-                const trimmed = value.trim();
-                if (trimmed === '') {
-                    throw new Error(getMessages().coercionFailed('number', value));
-                }
-                const coerced = Number(trimmed);
-                if (isNaN(coerced)) {
-                    throw new Error(getMessages().coercionFailed('number', value));
-                }
-                return super.parse(coerced);
-            }
-            else if (typeof value === 'boolean') {
-                return super.parse(value ? 1 : 0);
-            }
-            else if (value === null || value === undefined) {
-                throw new Error(getMessages().coercionFailed('number', value));
-            }
-            return super.parse(Number(value));
-        }
-        catch (error) {
-            if (error.message.includes('coercionFailed')) {
-                throw error;
-            }
-            throw new Error(getMessages().coercionFailed('number', value));
-        }
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-export class VldCoerceBoolean extends VldBoolean {
-    parse(value) {
-        try {
-            // Attempt coercion to boolean
-            if (typeof value === 'string') {
-                const lower = value.toLowerCase().trim();
-                if (lower === 'true' || lower === '1' || lower === 'yes')
-                    return true;
-                if (lower === 'false' || lower === '0' || lower === 'no')
-                    return false;
-                throw new Error(getMessages().coercionFailed('boolean', value));
-            }
-            else if (typeof value === 'number') {
-                if (value === 1)
-                    return true;
-                if (value === 0)
-                    return false;
-                throw new Error(getMessages().coercionFailed('boolean', value));
-            }
-            else if (value === null || value === undefined) {
-                throw new Error(getMessages().coercionFailed('boolean', value));
-            }
-            return super.parse(Boolean(value));
-        }
-        catch (error) {
-            if (error.message.includes('coercionFailed')) {
-                throw error;
-            }
-            throw new Error(getMessages().coercionFailed('boolean', value));
-        }
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-export class VldCoerceBigInt extends VldBigInt {
-    parse(value) {
-        try {
-            // Attempt coercion to bigint
-            if (typeof value === 'string') {
-                const trimmed = value.trim();
-                if (trimmed === '') {
-                    throw new Error(getMessages().coercionFailed('bigint', value));
-                }
-                return super.parse(BigInt(trimmed));
-            }
-            else if (typeof value === 'number') {
-                if (!Number.isInteger(value)) {
-                    throw new Error(getMessages().coercionFailed('bigint', value));
-                }
-                return super.parse(BigInt(value));
-            }
-            else if (value === null || value === undefined) {
-                throw new Error(getMessages().coercionFailed('bigint', value));
-            }
-            return super.parse(BigInt(value));
-        }
-        catch (error) {
-            if (error.message.includes('coercionFailed')) {
-                throw error;
-            }
-            throw new Error(getMessages().coercionFailed('bigint', value));
-        }
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-export class VldCoerceDate extends VldDate {
-    parse(value) {
-        try {
-            // Attempt coercion to date
-            if (typeof value === 'string' || typeof value === 'number') {
-                return super.parse(new Date(value));
-            }
-            else if (value === null || value === undefined) {
-                throw new Error(getMessages().coercionFailed('date', value));
-            }
-            return super.parse(value);
-        }
-        catch (error) {
-            if (error.message.includes('coercionFailed')) {
-                throw error;
-            }
-            throw new Error(getMessages().coercionFailed('date', value));
-        }
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-// Refine validator - adds custom validation
-export class VldRefine extends VldBase {
-    constructor(baseValidator, predicate, customMessage) {
-        super();
-        this.baseValidator = baseValidator;
-        this.predicate = predicate;
-        this.customMessage = customMessage;
-    }
-    parse(value) {
-        const baseResult = this.baseValidator.parse(value);
-        try {
-            if (!this.predicate(baseResult)) {
-                throw new Error(this.customMessage || 'Refinement condition not met');
-            }
-        }
-        catch (error) {
-            throw new Error(getMessages().customValidationError(error.message));
-        }
-        return baseResult;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-// Transform validator - transforms data after validation
-export class VldTransform extends VldBase {
-    constructor(baseValidator, transformer) {
-        super();
-        this.baseValidator = baseValidator;
-        this.transformer = transformer;
-    }
-    parse(value) {
-        const baseResult = this.baseValidator.parse(value);
-        try {
-            return this.transformer(baseResult);
-        }
-        catch (error) {
-            throw new Error(getMessages().transformError(error.message));
-        }
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-// Default validator - provides default value for undefined
-export class VldDefault extends VldBase {
-    constructor(baseValidator, defaultValue) {
-        super();
-        this.baseValidator = baseValidator;
-        this.defaultValue = defaultValue;
-    }
-    parse(value) {
-        if (value === undefined) {
-            return this.defaultValue;
-        }
-        return this.baseValidator.parse(value);
-    }
-    safeParse(value) {
-        if (value === undefined) {
-            return { success: true, data: this.defaultValue };
-        }
-        return this.baseValidator.safeParse(value);
-    }
-}
-// Catch validator - provides fallback value on validation error
-export class VldCatch extends VldBase {
-    constructor(baseValidator, fallbackValue) {
-        super();
-        this.baseValidator = baseValidator;
-        this.fallbackValue = fallbackValue;
-    }
-    parse(value) {
-        try {
-            return this.baseValidator.parse(value);
-        }
-        catch {
-            return this.fallbackValue;
-        }
-    }
-    safeParse(value) {
-        const result = this.baseValidator.safeParse(value);
-        if (result.success) {
-            return result;
-        }
-        else {
-            return { success: true, data: this.fallbackValue };
-        }
-    }
-}
-// Main API
+/**
+ * VLD - Fast, Type-Safe Validation Library
+ * Zero dependencies, blazing fast performance
+ *
+ * This is the new modular implementation with:
+ * - Immutable validators (no memory leaks)
+ * - Secure deepMerge (no prototype pollution)
+ * - TypeScript strict mode support
+ * - Better performance through pooling and memoization
+ */
+// Import validators
+import { VldString } from './validators/string.js';
+import { VldNumber } from './validators/number.js';
+import { VldBoolean } from './validators/boolean.js';
+import { VldDate } from './validators/date.js';
+import { VldArray } from './validators/array.js';
+import { VldObject } from './validators/object.js';
+import { VldUnion } from './validators/union.js';
+import { VldLiteral } from './validators/literal.js';
+import { VldBigInt } from './validators/bigint.js';
+import { VldSymbol } from './validators/symbol.js';
+import { VldTuple } from './validators/tuple.js';
+import { VldRecord } from './validators/record.js';
+import { VldSet } from './validators/set.js';
+import { VldMap } from './validators/map.js';
+import { VldEnum } from './validators/enum.js';
+import { VldIntersection } from './validators/intersection.js';
+import { VldAny } from './validators/any.js';
+import { VldUnknown } from './validators/unknown.js';
+import { VldVoid } from './validators/void.js';
+import { VldNever } from './validators/never.js';
+import { VldOptional } from './validators/base.js';
+import { VldNullable } from './validators/base.js';
+import { VldNullish } from './validators/base.js';
+// Import coercion validators
+import { VldCoerceString } from './coercion/string.js';
+import { VldCoerceNumber } from './coercion/number.js';
+import { VldCoerceBoolean } from './coercion/boolean.js';
+import { VldCoerceDate } from './coercion/date.js';
+import { VldCoerceBigInt } from './coercion/bigint.js';
+// Re-export base classes for extension
+export { VldBase } from './validators/base.js';
+export { VldIntersection } from './validators/intersection.js';
+// Re-export locale functionality
+export { setLocale, getLocale, getMessages } from './locales.js';
+// Re-export error formatting utilities
+export { VldError, treeifyError, prettifyError, flattenError } from './errors.js';
+/**
+ * Main API object with factory methods for all validators
+ */
 export const v = {
-    string: () => new VldString(),
-    number: () => new VldNumber(),
-    boolean: () => new VldBoolean(),
-    bigint: () => new VldBigInt(),
-    symbol: () => new VldSymbol(),
-    array: (item) => new VldArray(item),
-    tuple: (...validators) => new VldTuple(validators),
-    object: (shape) => new VldObject(shape),
-    record: (valueValidator) => new VldRecord(valueValidator),
-    set: (item) => new VldSet(item),
-    map: (key, value) => new VldMap(key, value),
-    optional: (validator) => new VldOptional(validator),
-    nullable: (validator) => new VldNullable(validator),
-    union: (...validators) => new VldUnion(validators),
-    intersection: (a, b) => new VldIntersection(a, b),
-    literal: (value) => new VldLiteral(value),
-    enum: (...values) => new VldEnum(values),
-    date: () => new VldDate(),
-    any: () => new VldAny(),
-    unknown: () => new VldUnknown(),
-    void: () => new VldVoid(),
-    never: () => new VldNever(),
+    // Primitive validators
+    string: () => VldString.create(),
+    number: () => VldNumber.create(),
+    boolean: () => VldBoolean.create(),
+    date: () => VldDate.create(),
+    bigint: () => VldBigInt.create(),
+    symbol: () => VldSymbol.create(),
+    // Complex validators
+    array: (item) => VldArray.create(item),
+    object: (shape) => VldObject.create(shape),
+    tuple: (...items) => VldTuple.create(...items),
+    record: (value) => VldRecord.create(value),
+    set: (item) => VldSet.create(item),
+    map: (key, value) => VldMap.create(key, value),
+    // Union and intersection
+    union: (...validators) => VldUnion.create(...validators),
+    intersection: (first, second) => VldIntersection.create(first, second),
+    // Literal and enum
+    literal: (value) => VldLiteral.create(value),
+    enum: (...values) => VldEnum.create(values),
+    // Special validators
+    any: () => VldAny.create(),
+    unknown: () => VldUnknown.create(),
+    void: () => VldVoid.create(),
+    never: () => VldNever.create(),
+    // Utility validators
+    optional: (validator) => VldOptional.create(validator),
+    nullable: (validator) => VldNullable.create(validator),
+    nullish: (validator) => VldNullish.create(validator),
     // Coercion API
     coerce: {
-        string: () => new VldCoerceString(),
-        number: () => new VldCoerceNumber(),
-        boolean: () => new VldCoerceBoolean(),
-        bigint: () => new VldCoerceBigInt(),
-        date: () => new VldCoerceDate(),
+        string: () => VldCoerceString.create(),
+        number: () => VldCoerceNumber.create(),
+        boolean: () => VldCoerceBoolean.create(),
+        date: () => VldCoerceDate.create(),
+        bigint: () => VldCoerceBigInt.create(),
     }
 };
-// Export all validators for direct use
-export { VldBase, };
-// Export locale functionality
-export { setLocale, getLocale, getMessages } from './locales/index.js';
-// Export error formatting utilities
-export { VldError, treeifyError, prettifyError, flattenError } from './errors.js';
+// For backward compatibility during migration
+export default v;
 //# sourceMappingURL=index.js.map