@oxog/vld 2.1.0 → 2.2.5

package/dist/validators/promise.js

@@ -1,111 +1 @@
-import { VLD_VALIDATOR_TYPES } from './base.js';
-
-/**
- * Promise validator - validates Promise values
- * Validates that the resolved value matches the inner schema
- */
-/**
- * Promise validator - validates Promise<T> where T matches inner schema
- * Zod 4 API parity - allows async validation with proper type inference
- *
- * Validates that the input is a Promise, and validates the resolved value
- * against the inner schema when parsed.
- *
- * Use parseAsync() or safeParseAsync() for proper async handling.
- */
-class VldPromise {
-    constructor(inner) {
-        this.inner = inner;
-        this.validatorType = VLD_VALIDATOR_TYPES.PROMISE;
-    }
-    get '~standard'() {
-        return {
-            version: 1,
-            vendor: 'vld',
-            validate: async (value) => {
-                const result = await this.safeParseAsync(value);
-                if (result.success) {
-                    return { value: result.data };
-                }
-                return { issues: [{ message: result.error.message }] };
-            },
-            types: undefined
-        };
-    }
-    /**
-     * Check if value is thenable (Promise-like)
-     * Must be called BEFORE wrapping in Promise.resolve
-     */
-    _isThenable(value) {
-        return value !== null && typeof value.then === 'function';
-    }
-    unwrap() {
-        return this.inner;
-    }
-    /**
-     * Parse and validate a Promise value asynchronously
-     * @param value The Promise to validate
-     * @returns The validated value
-     * @throws {Error} If validation fails when Promise resolves
-     */
-    async parse(value) {
-        // Check if value is thenable BEFORE wrapping in Promise.resolve
-        if (!this._isThenable(value)) {
-            throw new Error('Expected a Promise value');
-        }
-        // Now we can safely await it
-        const resolved = await Promise.resolve(value);
-        return this.inner.parseAsync ? this.inner.parseAsync(resolved) : this.inner.parse(resolved);
-    }
-    parseAsync(value) {
-        return this.parse(value);
-    }
-    /**
-     * Safely parse and validate a Promise value asynchronously
-     * @param value The Promise to validate
-     * @returns A Promise resolving to ParseResult containing the validated value
-     */
-    async safeParse(value) {
-        // Check if value is thenable BEFORE wrapping in Promise.resolve
-        if (!this._isThenable(value)) {
-            return {
-                success: false,
-                error: new Error('Expected a Promise value')
-            };
-        }
-        try {
-            const resolved = await Promise.resolve(value);
-            if (this.inner.safeParseAsync) {
-                return await this.inner.safeParseAsync(resolved);
-            }
-            const innerResult = this.inner.safeParse(resolved);
-            if (!innerResult.success) {
-                return innerResult;
-            }
-            return { success: true, data: innerResult.data };
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: err instanceof Error ? err : new Error(String(err))
-            };
-        }
-    }
-    safeParseAsync(value) {
-        return this.safeParse(value);
-    }
-}
-/**
- * Create a Promise validator
- * @param inner The schema to validate the resolved value against
- * @returns A new Promise validator
- * @example
- * const promiseSchema = v.promise(v.string());
- * const result = await promiseSchema.parse(Promise.resolve("hello"));
- * // result is string
- */
-function promise(inner) {
-    return new VldPromise(inner);
-}
-
-export { VldPromise, promise };
+import{VLD_VALIDATOR_TYPES as e}from"./base.js";class VldPromise{constructor(s){this.inner=s,this.validatorType=e.PROMISE}get"~standard"(){return{version:1,vendor:"vld",validate:async e=>{const s=await this.safeParseAsync(e);return s.success?{value:s.data}:{issues:[{message:s.error.message}]}},types:void 0}}_isThenable(e){return null!==e&&"function"==typeof e.then}unwrap(){return this.inner}async parse(e){if(!this._isThenable(e))throw new Error("Expected a Promise value");const s=await Promise.resolve(e);return this.inner.parseAsync?this.inner.parseAsync(s):this.inner.parse(s)}parseAsync(e){return this.parse(e)}async safeParse(e){if(!this._isThenable(e))return{success:!1,error:new Error("Expected a Promise value")};try{const s=await Promise.resolve(e);if(this.inner.safeParseAsync)return await this.inner.safeParseAsync(s);const r=this.inner.safeParse(s);return r.success?{success:!0,data:r.data}:r}catch(e){return{success:!1,error:e instanceof Error?e:new Error(String(e))}}}safeParseAsync(e){return this.safeParse(e)}}function s(e){return new VldPromise(e)}export{VldPromise,s as promise};

package/dist/validators/record.d.ts

@@ -3,45 +3,48 @@ import { VldBase, ParseResult } from './base.js';
  * Immutable record validator for key-value pairs
  * BUG-NEW-018 FIX: Uses comprehensive dangerous key protection
  */
-export declare class VldRecord<T> extends VldBase<unknown, Record<string, T>> {
+export declare class VldRecord<T, K extends PropertyKey = string> extends VldBase<unknown, Record<K, T>> {
     protected readonly valueValidator: VldBase<unknown, T>;
+    private readonly keyValidator?;
     private readonly errorMessage?;
     /**
      * Private constructor to enforce immutability
      */
-    protected constructor(valueValidator: VldBase<unknown, T>, errorMessage?: string | undefined);
+    protected constructor(valueValidator: VldBase<unknown, T>, keyValidator?: VldBase<unknown, K> | undefined, errorMessage?: string | undefined);
     private readonly _simpleValueMode;
     private readonly _simpleValue;
     get valueSchema(): VldBase<unknown, T>;
+    get keySchema(): VldBase<unknown, K> | undefined;
     /**
      * Create a new record validator
      */
-    static create<T>(valueValidator: VldBase<unknown, T>): VldRecord<T>;
+    static create<T, K extends PropertyKey = string>(valueValidator: VldBase<unknown, T>, keyValidator?: VldBase<unknown, K>): VldRecord<T, K>;
     private getSimpleValueMode;
     private getSimpleValueError;
     /**
      * Parse and validate a record value
      * BUG-NEW-018 FIX: Use comprehensive dangerous key protection
      */
-    parse(value: unknown): Record<string, T>;
+    parse(value: unknown): Record<K, T>;
     /**
      * Parse a value that has already passed the record object type guard.
      * @internal Used by object validators to avoid duplicate hot-path checks.
      */
-    parseKnownRecord(obj: Record<string, unknown>): Record<string, T>;
+    parseKnownRecord(obj: Record<string, unknown>): Record<K, T>;
+    private parseKeyedRecord;
     /**
      * Safely parse and validate a record value
      */
-    safeParse(value: unknown): ParseResult<Record<string, T>>;
+    safeParse(value: unknown): ParseResult<Record<K, T>>;
     /**
      * Create a partial record variant (all keys optional)
      * Similar to v.object().partial() but for records
      */
-    partial(): VldRecord<T | undefined>;
+    partial(): VldRecord<T | undefined, K>;
     /**
      * Create a loose record variant (allows extra keys)
      * Similar to v.object().passthrough() but for records
      * Note: Records already allow any keys, so this mainly affects error handling
      */
-    loose(): VldBase<unknown, Record<string, T>>;
+    loose(): VldBase<unknown, Record<K, T>>;
 }

package/dist/validators/record.js

@@ -1,258 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { getMessages } from '../locales/runtime.js';
-import { i as isDangerousKey } from '../chunks/security-B0Pd_vSY.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-function createRecordError(message) {
-    return new VldError([{ code: 'invalid_object', path: [], message }]);
-}
-/**
- * Immutable record validator for key-value pairs
- * BUG-NEW-018 FIX: Uses comprehensive dangerous key protection
- */
-class VldRecord extends VldBase {
-    /**
-     * Private constructor to enforce immutability
-     */
-    constructor(valueValidator, errorMessage) {
-        super(VLD_VALIDATOR_TYPES.RECORD);
-        this.valueValidator = valueValidator;
-        this.errorMessage = errorMessage;
-        this._simpleValueMode = this.getSimpleValueMode(valueValidator);
-        this._simpleValue = this._simpleValueMode === 'literal' ? valueValidator.literal : undefined;
-    }
-    get valueSchema() {
-        return this.valueValidator;
-    }
-    /**
-     * Create a new record validator
-     */
-    static create(valueValidator) {
-        return new VldRecord(valueValidator);
-    }
-    getSimpleValueMode(valueValidator) {
-        if (valueValidator.isSimple !== true) {
-            return undefined;
-        }
-        switch (valueValidator.validatorType) {
-            case VLD_VALIDATOR_TYPES.STRING:
-                return 'string';
-            case VLD_VALIDATOR_TYPES.NUMBER:
-                return 'number';
-            case VLD_VALIDATOR_TYPES.BOOLEAN:
-                return 'boolean';
-            case VLD_VALIDATOR_TYPES.BIGINT:
-                return 'bigint';
-            case VLD_VALIDATOR_TYPES.SYMBOL:
-                return 'symbol';
-            case VLD_VALIDATOR_TYPES.NULL:
-                return 'null';
-            case VLD_VALIDATOR_TYPES.UNDEFINED:
-            case VLD_VALIDATOR_TYPES.VOID:
-                return 'undefinedValue';
-            case VLD_VALIDATOR_TYPES.LITERAL:
-                return 'literal';
-            case VLD_VALIDATOR_TYPES.ANY:
-            case VLD_VALIDATOR_TYPES.UNKNOWN:
-                return 'passthrough';
-            default:
-                return undefined;
-        }
-    }
-    getSimpleValueError(received) {
-        switch (this._simpleValueMode) {
-            case 'string':
-                return getMessages().invalidString;
-            case 'number':
-                return getMessages().invalidNumber;
-            case 'boolean':
-                return getMessages().invalidBoolean;
-            case 'bigint':
-                return getMessages().invalidBigint;
-            case 'symbol':
-                return getMessages().invalidSymbol;
-            case 'null':
-                return `Expected null, received ${typeof received}`;
-            case 'undefinedValue':
-                return getMessages().expectedUndefined;
-            case 'literal':
-                return getMessages().literalExpected(JSON.stringify(this._simpleValue), JSON.stringify(received));
-            default:
-                return getMessages().invalidRecord;
-        }
-    }
-    /**
-     * Parse and validate a record value
-     * BUG-NEW-018 FIX: Use comprehensive dangerous key protection
-     */
-    parse(value) {
-        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-            throw new Error(this.errorMessage || getMessages().invalidRecord);
-        }
-        return this.parseKnownRecord(value);
-    }
-    /**
-     * Parse a value that has already passed the record object type guard.
-     * @internal Used by object validators to avoid duplicate hot-path checks.
-     */
-    parseKnownRecord(obj) {
-        const result = {};
-        const keys = Object.keys(obj);
-        const simpleMode = this._simpleValueMode;
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            // Skip dangerous keys to prevent prototype pollution
-            // Now using comprehensive protection from shared utility
-            if (isDangerousKey(key)) {
-                continue;
-            }
-            const val = obj[key];
-            if (simpleMode !== undefined) {
-                switch (simpleMode) {
-                    case 'string':
-                        if (typeof val !== 'string') {
-                            throw new Error(getMessages().objectField(key, getMessages().invalidString));
-                        }
-                        result[key] = val;
-                        continue;
-                    case 'number':
-                        if (typeof val !== 'number' || isNaN(val)) {
-                            throw new Error(getMessages().objectField(key, getMessages().invalidNumber));
-                        }
-                        result[key] = val;
-                        continue;
-                    case 'boolean':
-                        if (typeof val !== 'boolean') {
-                            throw new Error(getMessages().objectField(key, getMessages().invalidBoolean));
-                        }
-                        result[key] = val;
-                        continue;
-                    case 'bigint':
-                        if (typeof val !== 'bigint') {
-                            throw new Error(getMessages().objectField(key, getMessages().invalidBigint));
-                        }
-                        result[key] = val;
-                        continue;
-                    case 'symbol':
-                        if (typeof val !== 'symbol') {
-                            throw new Error(getMessages().objectField(key, getMessages().invalidSymbol));
-                        }
-                        result[key] = val;
-                        continue;
-                    case 'null':
-                        if (val !== null) {
-                            throw new Error(getMessages().objectField(key, this.getSimpleValueError(val)));
-                        }
-                        result[key] = null;
-                        continue;
-                    case 'undefinedValue':
-                        if (val !== undefined) {
-                            throw new Error(getMessages().objectField(key, getMessages().expectedUndefined));
-                        }
-                        result[key] = undefined;
-                        continue;
-                    case 'literal':
-                        if (val !== this._simpleValue) {
-                            throw new Error(getMessages().objectField(key, this.getSimpleValueError(val)));
-                        }
-                        result[key] = this._simpleValue;
-                        continue;
-                    case 'passthrough':
-                        result[key] = val;
-                        continue;
-                }
-            }
-            try {
-                result[key] = this.valueValidator.parse(val);
-            }
-            catch (error) {
-                throw new Error(getMessages().objectField(key, error.message));
-            }
-        }
-        return result;
-    }
-    /**
-     * Safely parse and validate a record value
-     */
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: createRecordError(error.message) };
-        }
-    }
-    /**
-     * Create a partial record variant (all keys optional)
-     * Similar to v.object().partial() but for records
-     */
-    partial() {
-        const optionalValidator = this.valueValidator.optional();
-        return new VldRecord(optionalValidator);
-    }
-    /**
-     * Create a loose record variant (allows extra keys)
-     * Similar to v.object().passthrough() but for records
-     * Note: Records already allow any keys, so this mainly affects error handling
-     */
-    loose() {
-        // For records, "loose" means we don't throw errors for validation failures
-        // We return a modified version that catches validation errors
-        return new VldLooseRecord(this.valueValidator);
-    }
-}
-/**
- * Loose record variant that allows validation failures
- * Used internally by .loose() method
- */
-class VldLooseRecord extends VldBase {
-    constructor(valueValidator) {
-        super(VLD_VALIDATOR_TYPES.RECORD);
-        this.valueValidator = valueValidator;
-    }
-    get valueSchema() {
-        return this.valueValidator;
-    }
-    parse(value) {
-        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
-            throw new Error(getMessages().invalidRecord);
-        }
-        const result = {};
-        const obj = value;
-        for (const [key, val] of Object.entries(obj)) {
-            // Skip dangerous keys
-            if (isDangerousKey(key)) {
-                continue;
-            }
-            // For loose records, skip invalid values instead of throwing
-            const parseResult = this.valueValidator.safeParse(val);
-            if (parseResult.success) {
-                result[key] = parseResult.data;
-            }
-        }
-        return result;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: createRecordError(error.message) };
-        }
-    }
-    /**
-     * Create a partial variant (all keys optional)
-     */
-    partial() {
-        const optionalValidator = this.valueValidator.optional();
-        return new VldLooseRecord(optionalValidator);
-    }
-    /**
-     * Return self (already loose)
-     */
-    loose() {
-        return this;
-    }
-}
-
-export { VldRecord };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{getMessages as t}from"../locales/runtime.js";import{i}from"../chunks/security-Dy24T8N7.js";import{V as o}from"../chunks/errors-core-Cqi4-9ew.js";function s(e){return new o([{code:"invalid_object",path:[],message:e}])}class VldRecord extends e{constructor(e,t,i){super(r.RECORD),this.valueValidator=e,this.keyValidator=t,this.errorMessage=i,this._simpleValueMode=this.getSimpleValueMode(e),this._simpleValue="literal"===this._simpleValueMode?e.literal:void 0}get valueSchema(){return this.valueValidator}get keySchema(){return this.keyValidator}static create(e,r){return new VldRecord(e,r)}getSimpleValueMode(e){if(!0===e.isSimple)switch(e.validatorType){case r.STRING:return"string";case r.NUMBER:return"number";case r.BOOLEAN:return"boolean";case r.BIGINT:return"bigint";case r.SYMBOL:return"symbol";case r.NULL:return"null";case r.UNDEFINED:case r.VOID:return"undefinedValue";case r.LITERAL:return"literal";case r.ANY:case r.UNKNOWN:return"passthrough";default:return}}getSimpleValueError(e){switch(this._simpleValueMode){case"string":return t().invalidString;case"number":return t().invalidNumber;case"boolean":return t().invalidBoolean;case"bigint":return t().invalidBigint;case"symbol":return t().invalidSymbol;case"null":return"Expected null, received "+typeof e;case"undefinedValue":return t().expectedUndefined;case"literal":return t().literalExpected(JSON.stringify(this._simpleValue),JSON.stringify(e));default:return t().invalidRecord}}parse(e){if("object"!=typeof e||null===e||Array.isArray(e))throw new Error(this.errorMessage||t().invalidRecord);return this.parseKnownRecord(e)}parseKnownRecord(e){if(void 0!==this.keyValidator)return this.parseKeyedRecord(e);const r={},o=Object.keys(e),s=this._simpleValueMode;for(let a=0;a<o.length;a++){const n=o[a];if(i(n))continue;const l=e[n];if(void 0!==s)switch(s){case"string":if("string"!=typeof l)throw new Error(t().objectField(n,t().invalidString));r[n]=l;continue;case"number":if("number"!=typeof l||isNaN(l))throw new Error(t().objectField(n,t().invalidNumber));r[n]=l;continue;case"boolean":if("boolean"!=typeof l)throw new Error(t().objectField(n,t().invalidBoolean));r[n]=l;continue;case"bigint":if("bigint"!=typeof l)throw new Error(t().objectField(n,t().invalidBigint));r[n]=l;continue;case"symbol":if("symbol"!=typeof l)throw new Error(t().objectField(n,t().invalidSymbol));r[n]=l;continue;case"null":if(null!==l)throw new Error(t().objectField(n,this.getSimpleValueError(l)));r[n]=null;continue;case"undefinedValue":if(void 0!==l)throw new Error(t().objectField(n,t().expectedUndefined));r[n]=void 0;continue;case"literal":if(l!==this._simpleValue)throw new Error(t().objectField(n,this.getSimpleValueError(l)));r[n]=this._simpleValue;continue;case"passthrough":r[n]=l;continue}try{r[n]=this.valueValidator.parse(l)}catch(e){throw new Error(t().objectField(n,e.message))}}return r}parseKeyedRecord(e){const r={},s=Reflect.ownKeys(e);for(const a of s){if(!Object.prototype.propertyIsEnumerable.call(e,a))continue;if("string"==typeof a&&i(a))continue;const s=this.keyValidator.safeParse(a);if(!s.success)throw new o([{code:"invalid_key",path:[String(a)],message:s.error.message}]);if("string"!=typeof s.data&&"number"!=typeof s.data&&"symbol"!=typeof s.data)throw new o([{code:"invalid_key",path:[String(a)],message:"Record key transform must return a property key"}]);if("string"!=typeof s.data||!i(s.data))try{r[s.data]=this.valueValidator.parse(e[a])}catch(e){throw new Error(t().objectField(String(a),e.message))}}return r}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return e instanceof o?{success:!1,error:e}:{success:!1,error:s(e.message)}}}partial(){const e=this.valueValidator.optional();return new VldRecord(e,this.keyValidator)}loose(){return new VldLooseRecord(this.valueValidator,this.keyValidator)}}class VldLooseRecord extends e{constructor(e,t){super(r.RECORD),this.valueValidator=e,this.keyValidator=t}get valueSchema(){return this.valueValidator}parse(e){if("object"!=typeof e||null===e||Array.isArray(e))throw new Error(t().invalidRecord);const r={},o=e;for(const e of Reflect.ownKeys(o)){if(!Object.prototype.propertyIsEnumerable.call(o,e))continue;if("string"==typeof e&&i(e))continue;const t=this.keyValidator?.safeParse(e);if(t&&!t.success)continue;const s=t?.data??e;if("string"!=typeof s&&"number"!=typeof s&&"symbol"!=typeof s)continue;if("string"==typeof s&&i(s))continue;const a=this.valueValidator.safeParse(o[e]);a.success&&(r[s]=a.data)}return r}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:s(e.message)}}}partial(){const e=this.valueValidator.optional();return new VldLooseRecord(e,this.keyValidator)}loose(){return this}}export{VldRecord};

package/dist/validators/set.js

@@ -1,199 +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 createSetError(message) {
-    return new VldError([{ code: 'invalid_type', path: [], message }]);
-}
-/**
- * Immutable Set validator
- */
-class VldSet extends VldBase {
-    /**
-     * Private constructor to enforce immutability
-     */
-    constructor(itemValidator, errorMessage) {
-        super(VLD_VALIDATOR_TYPES.SET);
-        this.itemValidator = itemValidator;
-        this.errorMessage = errorMessage;
-        this._simpleItemMode = this.getSimpleItemMode(itemValidator);
-        this._simpleItemValue = this._simpleItemMode === 'literal' ? itemValidator.literal : undefined;
-    }
-    get itemSchema() {
-        return this.itemValidator;
-    }
-    /**
-     * Create a new Set validator
-     */
-    static create(itemValidator) {
-        return new VldSet(itemValidator);
-    }
-    getSimpleItemMode(itemValidator) {
-        if (itemValidator.isSimple !== true) {
-            return undefined;
-        }
-        switch (itemValidator.validatorType) {
-            case VLD_VALIDATOR_TYPES.STRING:
-                return 'string';
-            case VLD_VALIDATOR_TYPES.NUMBER:
-                return 'number';
-            case VLD_VALIDATOR_TYPES.BOOLEAN:
-                return 'boolean';
-            case VLD_VALIDATOR_TYPES.BIGINT:
-                return 'bigint';
-            case VLD_VALIDATOR_TYPES.SYMBOL:
-                return 'symbol';
-            case VLD_VALIDATOR_TYPES.NULL:
-                return 'null';
-            case VLD_VALIDATOR_TYPES.UNDEFINED:
-            case VLD_VALIDATOR_TYPES.VOID:
-                return 'undefinedValue';
-            case VLD_VALIDATOR_TYPES.LITERAL:
-                return 'literal';
-            case VLD_VALIDATOR_TYPES.ANY:
-            case VLD_VALIDATOR_TYPES.UNKNOWN:
-                return 'passthrough';
-            default:
-                return undefined;
-        }
-    }
-    getSimpleItemError(received) {
-        switch (this._simpleItemMode) {
-            case 'string':
-                return getMessages().invalidString;
-            case 'number':
-                return getMessages().invalidNumber;
-            case 'boolean':
-                return getMessages().invalidBoolean;
-            case 'bigint':
-                return getMessages().invalidBigint;
-            case 'symbol':
-                return getMessages().invalidSymbol;
-            case 'null':
-                return `Expected null, received ${typeof received}`;
-            case 'undefinedValue':
-                return getMessages().expectedUndefined;
-            case 'literal':
-                return getMessages().literalExpected(JSON.stringify(this._simpleItemValue), JSON.stringify(received));
-            default:
-                return getMessages().invalidSet;
-        }
-    }
-    /**
-     * Parse and validate a Set value
-     */
-    parse(value) {
-        if (!(value instanceof Set)) {
-            throw new Error(this.errorMessage || getMessages().invalidSet);
-        }
-        return this.parseKnownSet(value);
-    }
-    /**
-     * Parse a value that has already passed the Set instance guard.
-     * @internal Used by object validators to avoid duplicate hot-path checks.
-     */
-    parseKnownSet(value) {
-        const result = new Set();
-        const simpleMode = this._simpleItemMode;
-        if (simpleMode === 'string') {
-            for (const item of value) {
-                if (typeof item !== 'string') {
-                    throw new Error(this.getSimpleItemError(item));
-                }
-                result.add(item);
-            }
-            return result;
-        }
-        if (simpleMode === 'number') {
-            for (const item of value) {
-                if (typeof item !== 'number' || isNaN(item)) {
-                    throw new Error(this.getSimpleItemError(item));
-                }
-                result.add(item);
-            }
-            return result;
-        }
-        if (simpleMode === 'boolean') {
-            for (const item of value) {
-                if (typeof item !== 'boolean') {
-                    throw new Error(this.getSimpleItemError(item));
-                }
-                result.add(item);
-            }
-            return result;
-        }
-        if (simpleMode === 'bigint') {
-            for (const item of value) {
-                if (typeof item !== 'bigint') {
-                    throw new Error(this.getSimpleItemError(item));
-                }
-                result.add(item);
-            }
-            return result;
-        }
-        if (simpleMode === 'symbol') {
-            for (const item of value) {
-                if (typeof item !== 'symbol') {
-                    throw new Error(this.getSimpleItemError(item));
-                }
-                result.add(item);
-            }
-            return result;
-        }
-        if (simpleMode === 'null') {
-            for (const item of value) {
-                if (item !== null) {
-                    throw new Error(this.getSimpleItemError(item));
-                }
-                result.add(null);
-            }
-            return result;
-        }
-        if (simpleMode === 'undefinedValue') {
-            for (const item of value) {
-                if (item !== undefined) {
-                    throw new Error(this.getSimpleItemError(item));
-                }
-                result.add(undefined);
-            }
-            return result;
-        }
-        if (simpleMode === 'literal') {
-            for (const item of value) {
-                if (item !== this._simpleItemValue) {
-                    throw new Error(this.getSimpleItemError(item));
-                }
-                result.add(this._simpleItemValue);
-            }
-            return result;
-        }
-        if (simpleMode === 'passthrough') {
-            for (const item of value) {
-                result.add(item);
-            }
-            return result;
-        }
-        for (const item of value) {
-            try {
-                result.add(this.itemValidator.parse(item));
-            }
-            catch (error) {
-                throw new Error(error.message);
-            }
-        }
-        return result;
-    }
-    /**
-     * Safely parse and validate a Set value
-     */
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: createSetError(error.message) };
-        }
-    }
-}
-
-export { VldSet };
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{getMessages as t}from"../locales/runtime.js";import{V as i}from"../chunks/errors-core-Cqi4-9ew.js";class VldSet extends e{constructor(e,t){super(r.SET),this.itemValidator=e,this.errorMessage=t,this._simpleItemMode=this.getSimpleItemMode(e),this._simpleItemValue="literal"===this._simpleItemMode?e.literal:void 0}get itemSchema(){return this.itemValidator}static create(e){return new VldSet(e)}getSimpleItemMode(e){if(!0===e.isSimple)switch(e.validatorType){case r.STRING:return"string";case r.NUMBER:return"number";case r.BOOLEAN:return"boolean";case r.BIGINT:return"bigint";case r.SYMBOL:return"symbol";case r.NULL:return"null";case r.UNDEFINED:case r.VOID:return"undefinedValue";case r.LITERAL:return"literal";case r.ANY:case r.UNKNOWN:return"passthrough";default:return}}getSimpleItemError(e){switch(this._simpleItemMode){case"string":return t().invalidString;case"number":return t().invalidNumber;case"boolean":return t().invalidBoolean;case"bigint":return t().invalidBigint;case"symbol":return t().invalidSymbol;case"null":return"Expected null, received "+typeof e;case"undefinedValue":return t().expectedUndefined;case"literal":return t().literalExpected(JSON.stringify(this._simpleItemValue),JSON.stringify(e));default:return t().invalidSet}}parse(e){if(!(e instanceof Set))throw new Error(this.errorMessage||t().invalidSet);return this.parseKnownSet(e)}parseKnownSet(e){const r=new Set,t=this._simpleItemMode;if("string"===t){for(const t of e){if("string"!=typeof t)throw new Error(this.getSimpleItemError(t));r.add(t)}return r}if("number"===t){for(const t of e){if("number"!=typeof t||isNaN(t))throw new Error(this.getSimpleItemError(t));r.add(t)}return r}if("boolean"===t){for(const t of e){if("boolean"!=typeof t)throw new Error(this.getSimpleItemError(t));r.add(t)}return r}if("bigint"===t){for(const t of e){if("bigint"!=typeof t)throw new Error(this.getSimpleItemError(t));r.add(t)}return r}if("symbol"===t){for(const t of e){if("symbol"!=typeof t)throw new Error(this.getSimpleItemError(t));r.add(t)}return r}if("null"===t){for(const t of e){if(null!==t)throw new Error(this.getSimpleItemError(t));r.add(null)}return r}if("undefinedValue"===t){for(const t of e){if(void 0!==t)throw new Error(this.getSimpleItemError(t));r.add(void 0)}return r}if("literal"===t){for(const t of e){if(t!==this._simpleItemValue)throw new Error(this.getSimpleItemError(t));r.add(this._simpleItemValue)}return r}if("passthrough"===t){for(const t of e)r.add(t);return r}for(const t of e)try{r.add(this.itemValidator.parse(t))}catch(e){throw new Error(e.message)}return r}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:(r=e.message,new i([{code:"invalid_type",path:[],message:r}]))}}var r}}export{VldSet};