@oxog/vld 2.1.0 → 2.2.5

package/dist/validators/custom.js

@@ -1,67 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-
-/**
- * Immutable custom validator for user-defined validation logic
- * Provides type safety while allowing complete control over validation
- */
-class VldCustom extends VldBase {
-    constructor(options) {
-        super(VLD_VALIDATOR_TYPES.CUSTOM);
-        this._parseFn = options.parse;
-        this._parseAsyncFn = options.parseAsync || ((value) => Promise.resolve(this._parseFn(value)));
-        this._safeParseFn = options.safeParse || ((value) => {
-            try {
-                return { success: true, data: this._parseFn(value) };
-            }
-            catch (error) {
-                return { success: false, error: error };
-            }
-        });
-        this._safeParseAsyncFn = options.safeParseAsync || (async (value) => {
-            try {
-                return { success: true, data: await this._parseAsyncFn(value) };
-            }
-            catch (error) {
-                return { success: false, error: error };
-            }
-        });
-    }
-    /**
-     * Create a new custom validator
-     */
-    static create(options) {
-        return new VldCustom(options);
-    }
-    /**
-     * Parse and validate using the custom parse function
-     */
-    parse(value) {
-        return this._parseFn(value);
-    }
-    /**
-     * Safely parse using the custom safeParse function or default implementation
-     */
-    safeParse(value) {
-        return this._safeParseFn(value);
-    }
-    async parseAsync(value) {
-        return this._parseAsyncFn(value);
-    }
-    async safeParseAsync(value) {
-        return this._safeParseAsyncFn(value);
-    }
-}
-/**
- * Helper function to create custom validators
- * Usage: v.custom<number>({
- *   parse: (value) => {
- *     if (typeof value !== 'string') throw new Error('Expected string');
- *     return parseInt(value, 10);
- *   }
- * })
- */
-function custom(options) {
-    return VldCustom.create(options);
-}
-
-export { VldCustom, custom };
+import{VldBase as s,VLD_VALIDATOR_TYPES as r}from"./base.js";class VldCustom extends s{constructor(s){super(r.CUSTOM),this._parseFn=s.parse,this._parseAsyncFn=s.parseAsync||(s=>Promise.resolve(this._parseFn(s))),this._safeParseFn=s.safeParse||(s=>{try{return{success:!0,data:this._parseFn(s)}}catch(s){return{success:!1,error:s}}}),this._safeParseAsyncFn=s.safeParseAsync||(async s=>{try{return{success:!0,data:await this._parseAsyncFn(s)}}catch(s){return{success:!1,error:s}}})}static create(s){return new VldCustom(s)}parse(s){return this._parseFn(s)}safeParse(s){return this._safeParseFn(s)}async parseAsync(s){return this._parseAsyncFn(s)}async safeParseAsync(s){return this._safeParseAsyncFn(s)}}function e(s){return VldCustom.create(s)}export{VldCustom,e as custom};

package/dist/validators/date.js

@@ -1,274 +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 createDateError(message) {
-    return new VldError([{ code: 'invalid_date', path: [], message }]);
-}
-/**
- * Immutable date validator with chainable methods
- */
-class VldDate extends VldBase {
-    /**
-     * Protected constructor to allow extension while maintaining immutability
-     */
-    constructor(config) {
-        super(config?.validatorType || VLD_VALIDATOR_TYPES.DATE);
-        this.config = {
-            checks: config?.checks || [],
-            errorMessage: config?.errorMessage,
-            jsonSchema: config?.jsonSchema
-        };
-        this._checks = this.config.checks;
-        this._isSimple = this._checks.length === 0;
-    }
-    get jsonSchema() {
-        return this.config.jsonSchema;
-    }
-    /**
-     * Create a new date validator
-     */
-    static create() {
-        return new VldDate();
-    }
-    /**
-     * Parse and validate a date value
-     */
-    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.config.errorMessage || getMessages().invalidDate);
-        }
-        // Check if the date is valid
-        if (isNaN(date.getTime())) {
-            throw new Error(this.config.errorMessage || getMessages().invalidDate);
-        }
-        return this.parseValidDate(date);
-    }
-    /**
-     * Parse a Date instance that has already passed the Date validity check.
-     * @internal Used by object validators to avoid duplicate hot-path checks.
-     */
-    parseKnownDate(value) {
-        if (isNaN(value.getTime())) {
-            throw new Error(this.config.errorMessage || getMessages().invalidDate);
-        }
-        return this.parseValidDate(value);
-    }
-    parseValidDate(date) {
-        if (this._isSimple) {
-            return date;
-        }
-        // Apply all checks
-        for (const check of this._checks) {
-            if (!check.fn(date)) {
-                throw new Error(check.message);
-            }
-        }
-        return date;
-    }
-    /**
-     * Safely parse and validate a date value
-     */
-    safeParse(value) {
-        if (value instanceof Date) {
-            try {
-                return { success: true, data: this.parseKnownDate(value) };
-            }
-            catch (error) {
-                return { success: false, error: createDateError(error.message) };
-            }
-        }
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: createDateError(error.message) };
-        }
-    }
-    /**
-     * Create a new validator with minimum date constraint
-     * BUG-NEW-009 FIX: Validate that min date is valid before creating validator
-     */
-    min(date, message) {
-        const minDate = date instanceof Date ? date : new Date(date);
-        // Validate that minDate is valid
-        if (isNaN(minDate.getTime())) {
-            throw new Error(`Invalid date provided to min(): ${date}`);
-        }
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => v >= minDate,
-                    message: message || getMessages().dateMin(minDate)
-                }],
-            jsonSchema: { ...this.config.jsonSchema, formatMinimum: minDate.toISOString() }
-        });
-    }
-    /**
-     * Create a new validator with maximum date constraint
-     * BUG-NEW-009 FIX: Validate that max date is valid before creating validator
-     */
-    max(date, message) {
-        const maxDate = date instanceof Date ? date : new Date(date);
-        // Validate that maxDate is valid
-        if (isNaN(maxDate.getTime())) {
-            throw new Error(`Invalid date provided to max(): ${date}`);
-        }
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => v <= maxDate,
-                    message: message || getMessages().dateMax(maxDate)
-                }],
-            jsonSchema: { ...this.config.jsonSchema, formatMaximum: maxDate.toISOString() }
-        });
-    }
-    /**
-     * Create a new validator with a range constraint
-     * BUG-NEW-019 FIX: Validate that min/max dates are valid before creating validator
-     */
-    between(min, max, message) {
-        const minDate = min instanceof Date ? min : new Date(min);
-        const maxDate = max instanceof Date ? max : new Date(max);
-        // Validate that both dates are valid
-        if (isNaN(minDate.getTime())) {
-            throw new Error(`Invalid min date provided to between(): ${min}`);
-        }
-        if (isNaN(maxDate.getTime())) {
-            throw new Error(`Invalid max date provided to between(): ${max}`);
-        }
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => v >= minDate && v <= maxDate,
-                    message: message || `Date must be between ${minDate.toISOString()} and ${maxDate.toISOString()}`
-                }],
-            jsonSchema: {
-                ...this.config.jsonSchema,
-                formatMinimum: minDate.toISOString(),
-                formatMaximum: maxDate.toISOString()
-            }
-        });
-    }
-    /**
-     * Create a new validator that checks if date is in the past
-     * BUG-NEW-006 FIX: Capture reference date at validator creation time for deterministic behavior
-     */
-    past(message) {
-        const referenceDate = new Date(); // Capture NOW at validator creation time
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => v < referenceDate,
-                    message: message || 'Date must be in the past'
-                }],
-            jsonSchema: { ...this.config.jsonSchema, formatExclusiveMaximum: referenceDate.toISOString() }
-        });
-    }
-    /**
-     * Create a new validator that checks if date is in the future
-     * BUG-NEW-006 FIX: Capture reference date at validator creation time for deterministic behavior
-     */
-    future(message) {
-        const referenceDate = new Date(); // Capture NOW at validator creation time
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => v > referenceDate,
-                    message: message || 'Date must be in the future'
-                }],
-            jsonSchema: { ...this.config.jsonSchema, formatExclusiveMinimum: referenceDate.toISOString() }
-        });
-    }
-    /**
-     * Create a new validator that checks if date is today
-     * BUG-NEW-008 FIX: Capture reference date at validator creation time for deterministic behavior
-     */
-    today(message) {
-        // Capture the reference date (today) at validator creation time
-        const referenceDate = new Date();
-        const refYear = referenceDate.getFullYear();
-        const refMonth = referenceDate.getMonth();
-        const refDate = referenceDate.getDate();
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => {
-                        return v.getFullYear() === refYear &&
-                            v.getMonth() === refMonth &&
-                            v.getDate() === refDate;
-                    },
-                    message: message || 'Date must be today'
-                }]
-        });
-    }
-    /**
-     * Create a new validator that checks if date is a weekday
-     */
-    weekday(message) {
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => {
-                        const day = v.getDay();
-                        return day >= 1 && day <= 5;
-                    },
-                    message: message || 'Date must be a weekday'
-                }]
-        });
-    }
-    /**
-     * Create a new validator that checks if date is a weekend
-     */
-    weekend(message) {
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => {
-                        const day = v.getDay();
-                        return day === 0 || day === 6;
-                    },
-                    message: message || 'Date must be a weekend'
-                }]
-        });
-    }
-    /**
-     * Create a new validator with strict greater than constraint
-     * Zod 4 API parity - strictly greater than (not equal to)
-     */
-    gt(value, message) {
-        const compareDate = value instanceof Date ? value : new Date(value);
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => v.getTime() > compareDate.getTime(),
-                    message: message || `Date must be greater than ${compareDate.toISOString()}`
-                }],
-            jsonSchema: { ...this.config.jsonSchema, formatExclusiveMinimum: compareDate.toISOString() }
-        });
-    }
-    /**
-     * Create a new validator with strict less than constraint
-     * Zod 4 API parity - strictly less than (not equal to)
-     */
-    lt(value, message) {
-        const compareDate = value instanceof Date ? value : new Date(value);
-        return new VldDate({
-            ...this.config,
-            checks: [...this.config.checks, {
-                    fn: (v) => v.getTime() < compareDate.getTime(),
-                    message: message || `Date must be less than ${compareDate.toISOString()}`
-                }],
-            jsonSchema: { ...this.config.jsonSchema, formatExclusiveMaximum: compareDate.toISOString() }
-        });
-    }
-}
-
-export { VldDate };
+import{VldBase as e,VLD_VALIDATOR_TYPES as t}from"./base.js";import{getMessages as s}from"../locales/runtime.js";import{V as n}from"../chunks/errors-core-Cqi4-9ew.js";function i(e){return new n([{code:"invalid_date",path:[],message:e}])}class VldDate extends e{constructor(e){super(e?.validatorType||t.DATE),this.config={checks:e?.checks||[],errorMessage:e?.errorMessage,jsonSchema:e?.jsonSchema},this._checks=this.config.checks,this._isSimple=0===this._checks.length}get jsonSchema(){return this.config.jsonSchema}static create(){return new VldDate}parse(e){let t;if(e instanceof Date)t=e;else{if("string"!=typeof e&&"number"!=typeof e)throw new Error(this.config.errorMessage||s().invalidDate);t=new Date(e)}if(isNaN(t.getTime()))throw new Error(this.config.errorMessage||s().invalidDate);return this.parseValidDate(t)}parseKnownDate(e){if(isNaN(e.getTime()))throw new Error(this.config.errorMessage||s().invalidDate);return this.parseValidDate(e)}parseValidDate(e){if(this._isSimple)return e;for(const t of this._checks)if(!t.fn(e))throw new Error(t.message);return e}safeParse(e){if(e instanceof Date)try{return{success:!0,data:this.parseKnownDate(e)}}catch(e){return{success:!1,error:i(e.message)}}try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:i(e.message)}}}min(e,t){const n=e instanceof Date?e:new Date(e);if(isNaN(n.getTime()))throw new Error(`Invalid date provided to min(): ${e}`);return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e>=n,message:t||s().dateMin(n)}],jsonSchema:{...this.config.jsonSchema,formatMinimum:n.toISOString()}})}max(e,t){const n=e instanceof Date?e:new Date(e);if(isNaN(n.getTime()))throw new Error(`Invalid date provided to max(): ${e}`);return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e<=n,message:t||s().dateMax(n)}],jsonSchema:{...this.config.jsonSchema,formatMaximum:n.toISOString()}})}between(e,t,s){const n=e instanceof Date?e:new Date(e),i=t instanceof Date?t:new Date(t);if(isNaN(n.getTime()))throw new Error(`Invalid min date provided to between(): ${e}`);if(isNaN(i.getTime()))throw new Error(`Invalid max date provided to between(): ${t}`);return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e>=n&&e<=i,message:s||`Date must be between ${n.toISOString()} and ${i.toISOString()}`}],jsonSchema:{...this.config.jsonSchema,formatMinimum:n.toISOString(),formatMaximum:i.toISOString()}})}past(e){const t=new Date;return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e<t,message:e||"Date must be in the past"}],jsonSchema:{...this.config.jsonSchema,formatExclusiveMaximum:t.toISOString()}})}future(e){const t=new Date;return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e>t,message:e||"Date must be in the future"}],jsonSchema:{...this.config.jsonSchema,formatExclusiveMinimum:t.toISOString()}})}today(e){const t=new Date,s=t.getFullYear(),n=t.getMonth(),i=t.getDate();return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e.getFullYear()===s&&e.getMonth()===n&&e.getDate()===i,message:e||"Date must be today"}]})}weekday(e){return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>{const t=e.getDay();return t>=1&&t<=5},message:e||"Date must be a weekday"}]})}weekend(e){return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>{const t=e.getDay();return 0===t||6===t},message:e||"Date must be a weekend"}]})}gt(e,t){const s=e instanceof Date?e:new Date(e);return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e.getTime()>s.getTime(),message:t||`Date must be greater than ${s.toISOString()}`}],jsonSchema:{...this.config.jsonSchema,formatExclusiveMinimum:s.toISOString()}})}lt(e,t){const s=e instanceof Date?e:new Date(e);return new VldDate({...this.config,checks:[...this.config.checks,{fn:e=>e.getTime()<s.getTime(),message:t||`Date must be less than ${s.toISOString()}`}],jsonSchema:{...this.config.jsonSchema,formatExclusiveMaximum:s.toISOString()}})}}export{VldDate};

package/dist/validators/discriminated-union.d.ts

@@ -9,14 +9,14 @@ import type { ParseResult } from './base.js';
  * Discriminated union validator - validates union based on discriminator key
  * Much faster than regular union when you have a discriminator field
  */
-export declare class VldDiscriminatedUnion<K extends string, Options extends VldBase<any, any>[]> extends VldBase<unknown, Options[number] extends VldBase<any, infer T> ? T : never> {
+export declare class VldDiscriminatedUnion<K extends string, Options extends readonly VldBase<any, any>[]> extends VldBase<unknown, Options[number] extends VldBase<any, infer T> ? T : never> {
     private readonly _discriminator;
     private readonly _options;
     private readonly _discriminatorMap;
     private readonly _stringDiscriminatorMap;
     private readonly _validValues;
     constructor(_discriminator: K, _options: Options);
-    static create<K extends string, Options extends VldBase<any, any>[]>(discriminator: K, options: Options): VldDiscriminatedUnion<K, Options>;
+    static create<K extends string, Options extends readonly VldBase<any, any>[]>(discriminator: K, options: Options): VldDiscriminatedUnion<K, Options>;
     parse(value: unknown): Options[number] extends VldBase<any, infer T> ? T : never;
     safeParse(value: unknown): ParseResult<Options[number] extends VldBase<any, infer T> ? T : never>;
     /**

package/dist/validators/discriminated-union.js

@@ -1,123 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { VldObject } from './object.js';
-import { VldLiteral } from './literal.js';
-import { VldEnum } from './enum.js';
-
-/**
- * VldDiscriminatedUnion - Fast union validation using discriminator field
- * Part of Zod 4 API parity implementation
- * Provides O(1) lookup performance by using a discriminator key
- */
-/**
- * Extract literal values from a schema
- */
-function extractLiteralValues(schema) {
-    if (schema instanceof VldLiteral) {
-        return [schema.literal];
-    }
-    if (schema instanceof VldEnum) {
-        return [...schema.values];
-    }
-    throw new Error('Discriminator must be a literal or enum schema');
-}
-/**
- * Discriminated union validator - validates union based on discriminator key
- * Much faster than regular union when you have a discriminator field
- */
-class VldDiscriminatedUnion extends VldBase {
-    constructor(_discriminator, _options) {
-        super(VLD_VALIDATOR_TYPES.DISCRIMINATED_UNION);
-        this._discriminator = _discriminator;
-        this._options = _options;
-        // Build discriminator map for O(1) lookup
-        this._discriminatorMap = new Map();
-        this._stringDiscriminatorMap = Object.create(null);
-        for (const option of _options) {
-            if (!(option instanceof VldObject)) {
-                throw new Error('All options in a discriminated union must be objects');
-            }
-            const discriminatorSchema = option.config?.shape?.[this._discriminator];
-            if (!discriminatorSchema) {
-                throw new Error(`Missing discriminator key "${this._discriminator}" in one of the options`);
-            }
-            const values = extractLiteralValues(discriminatorSchema);
-            for (const value of values) {
-                if (this._discriminatorMap.has(value)) {
-                    throw new Error(`Duplicate discriminator value "${String(value)}" found in discriminated union`);
-                }
-                this._discriminatorMap.set(value, option);
-                if (typeof value === 'string') {
-                    this._stringDiscriminatorMap[value] = option;
-                }
-            }
-        }
-        this._validValues = Array.from(this._discriminatorMap.keys());
-    }
-    static create(discriminator, options) {
-        return new VldDiscriminatedUnion(discriminator, options);
-    }
-    parse(value) {
-        if (typeof value !== 'object' || value === null) {
-            throw new Error(`Expected object, received ${value === null ? 'null' : typeof value}`);
-        }
-        const discriminatorValue = value[this._discriminator];
-        const matchedSchema = typeof discriminatorValue === 'string'
-            ? this._stringDiscriminatorMap[discriminatorValue]
-            : this._discriminatorMap.get(discriminatorValue);
-        if (!matchedSchema) {
-            throw new Error(`Invalid discriminator value for "${this._discriminator}". ` +
-                `Expected one of: ${JSON.stringify(this._validValues)}, ` +
-                `received: ${JSON.stringify(discriminatorValue)}`);
-        }
-        return matchedSchema.parseTrustedKnownObject(value, this._discriminator);
-    }
-    safeParse(value) {
-        // Check if input is an object
-        if (typeof value !== 'object' || value === null) {
-            return {
-                success: false,
-                error: new Error(`Expected object, received ${value === null ? 'null' : typeof value}`)
-            };
-        }
-        // Get discriminator value
-        const discriminatorValue = value[this._discriminator];
-        // Look up matching schema
-        const matchedSchema = typeof discriminatorValue === 'string'
-            ? this._stringDiscriminatorMap[discriminatorValue]
-            : this._discriminatorMap.get(discriminatorValue);
-        if (!matchedSchema) {
-            return {
-                success: false,
-                error: new Error(`Invalid discriminator value for "${this._discriminator}". ` +
-                    `Expected one of: ${JSON.stringify(this._validValues)}, ` +
-                    `received: ${JSON.stringify(discriminatorValue)}`)
-            };
-        }
-        try {
-            return {
-                success: true,
-                data: matchedSchema.parseTrustedKnownObject(value, this._discriminator)
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error
-            };
-        }
-    }
-    /**
-     * Get the discriminator key
-     */
-    getDiscriminator() {
-        return this._discriminator;
-    }
-    /**
-     * Get all options
-     */
-    getOptions() {
-        return this._options;
-    }
-}
-
-export { VldDiscriminatedUnion };
+import{VldBase as i,VLD_VALIDATOR_TYPES as r}from"./base.js";import{VldObject as t}from"./object.js";import{VldLiteral as s}from"./literal.js";import{VldEnum as n}from"./enum.js";function e(i){if(i instanceof s)return[...i.values];if(i instanceof n)return[...i.values];throw new Error("Discriminator must be a literal or enum schema")}class VldDiscriminatedUnion extends i{constructor(i,s){super(r.DISCRIMINATED_UNION),this._discriminator=i,this._options=s,this._discriminatorMap=new Map,this._stringDiscriminatorMap=Object.create(null);for(const i of s){if(!(i instanceof t))throw new Error("All options in a discriminated union must be objects");const r=i.config?.shape?.[this._discriminator];if(!r)throw new Error(`Missing discriminator key "${this._discriminator}" in one of the options`);const s=e(r);for(const r of s){if(this._discriminatorMap.has(r))throw new Error(`Duplicate discriminator value "${String(r)}" found in discriminated union`);this._discriminatorMap.set(r,i),"string"==typeof r&&(this._stringDiscriminatorMap[r]=i)}}this._validValues=Array.from(this._discriminatorMap.keys())}static create(i,r){return new VldDiscriminatedUnion(i,r)}parse(i){if("object"!=typeof i||null===i)throw new Error("Expected object, received "+(null===i?"null":typeof i));const r=i[this._discriminator],t="string"==typeof r?this._stringDiscriminatorMap[r]:this._discriminatorMap.get(r);if(!t)throw new Error(`Invalid discriminator value for "${this._discriminator}". Expected one of: ${JSON.stringify(this._validValues)}, received: ${JSON.stringify(r)}`);return t.parseTrustedKnownObject(i,this._discriminator)}safeParse(i){if("object"!=typeof i||null===i)return{success:!1,error:new Error("Expected object, received "+(null===i?"null":typeof i))};const r=i[this._discriminator],t="string"==typeof r?this._stringDiscriminatorMap[r]:this._discriminatorMap.get(r);if(!t)return{success:!1,error:new Error(`Invalid discriminator value for "${this._discriminator}". Expected one of: ${JSON.stringify(this._validValues)}, received: ${JSON.stringify(r)}`)};try{return{success:!0,data:t.parseTrustedKnownObject(i,this._discriminator)}}catch(i){return{success:!1,error:i}}}getDiscriminator(){return this._discriminator}getOptions(){return this._options}}export{VldDiscriminatedUnion};

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-Cqi4-9ew.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}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=this._values.filter(r=>!e.includes(r));if(0===r.length)throw new Error("Cannot exclude all enum values");return new VldEnum(r,this.errorMessage)}extract(...e){const r=this._values.filter(r=>e.includes(r));if(0===r.length)throw new Error("Cannot extract non-existent enum values");return new VldEnum(r,this.errorMessage)}}export{VldEnum};