@oxog/vld 1.0.0

package/dist/index.js

@@ -0,0 +1,1170 @@
+// 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
+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(),
+    // Coercion API
+    coerce: {
+        string: () => new VldCoerceString(),
+        number: () => new VldCoerceNumber(),
+        boolean: () => new VldCoerceBoolean(),
+        bigint: () => new VldCoerceBigInt(),
+        date: () => new VldCoerceDate(),
+    }
+};
+// 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';
+//# sourceMappingURL=index.js.map