@oxog/vld 2.1.0 → 2.2.7

package/dist/validators/base.js

@@ -1,868 +1 @@
-import { globalRegistry } from '../registry.js';
-
-/**
- * Validator type constants for O(1) dispatch
- * Used by VldObject to replace instanceof chains with Map lookups
- */
-const VLD_VALIDATOR_TYPES = {
-    // Primitives
-    STRING: 'string',
-    STRING_FORMAT: 'stringFormat',
-    STRING_BOOL: 'stringBool',
-    NUMBER: 'number',
-    BOOLEAN: 'boolean',
-    DATE: 'date',
-    BIGINT: 'bigint',
-    UNDEFINED: 'undefined',
-    NULL: 'null',
-    UNKNOWN: 'unknown',
-    ANY: 'any',
-    VOID: 'void',
-    NEVER: 'never',
-    SYMBOL: 'symbol',
-    NAN: 'nan',
-    HEX: 'hex',
-    BASE64: 'base64',
-    UINT8_ARRAY: 'uint8Array',
-    // Coercion
-    COERCE_STRING: 'coerceString',
-    COERCE_NUMBER: 'coerceNumber',
-    COERCE_BOOLEAN: 'coerceBoolean',
-    COERCE_DATE: 'coerceDate',
-    COERCE_BIGINT: 'coerceBigint',
-    // Composite
-    OBJECT: 'object',
-    ARRAY: 'array',
-    TUPLE: 'tuple',
-    SET: 'set',
-    MAP: 'map',
-    RECORD: 'record',
-    // Union types
-    UNION: 'union',
-    DISCRIMINATED_UNION: 'discriminatedUnion',
-    INTERSECTION: 'intersection',
-    XOR: 'xor',
-    // Values
-    ENUM: 'enum',
-    LITERAL: 'literal',
-    // Special validators
-    LAZY: 'lazy',
-    CUSTOM: 'custom',
-    FUNCTION: 'function',
-    FILE: 'file',
-    JSON: 'json',
-    TEMPLATE_LITERAL: 'templateLiteral',
-    PROMISE: 'promise',
-    // Wrapper/Modifier validators
-    OPTIONAL: 'optional',
-    NULLABLE: 'nullable',
-    NULLISH: 'nullish',
-    EXACT_OPTIONAL: 'exactOptional',
-    DEFAULT: 'default',
-    CATCH: 'catch',
-    REFINE: 'refine',
-    TRANSFORM: 'transform',
-    PIPE: 'pipe',
-    PREPROCESS: 'preprocess',
-    SUPER_REFINE: 'superRefine',
-    BRAND: 'brand',
-    READONLY: 'readonly',
-    META: 'meta',
-    PREFAULT: 'prefault',
-    PREFault: 'prefault',
-    // Codec
-    CODEC: 'codec',
-};
-function resolveErrorMessage(error, fallback) {
-    if (typeof error === 'string') {
-        return error;
-    }
-    if (typeof error?.error === 'string') {
-        return error.error;
-    }
-    if (typeof error?.error === 'function') {
-        return error.error({}) || fallback;
-    }
-    if (typeof error?.message === 'string') {
-        return error.message;
-    }
-    return fallback;
-}
-function isPromiseLike(value) {
-    return value !== null &&
-        (typeof value === 'object' || typeof value === 'function') &&
-        typeof value.then === 'function';
-}
-function getSimpleWrappedMode(baseValidator) {
-    if (baseValidator.isSimple !== true) {
-        return undefined;
-    }
-    switch (baseValidator.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';
-        default:
-            return undefined;
-    }
-}
-function parseSimpleWrappedValue(mode, value) {
-    switch (mode) {
-        case 'string':
-            return typeof value === 'string' ? value : undefined;
-        case 'number':
-            return typeof value === 'number' && !isNaN(value) ? value : undefined;
-        case 'boolean':
-            return typeof value === 'boolean' ? value : undefined;
-        case 'bigint':
-            return typeof value === 'bigint' ? value : undefined;
-        case 'symbol':
-            return typeof value === 'symbol' ? value : undefined;
-        default:
-            return undefined;
-    }
-}
-/**
- * Abstract base class for all validators
- * Implements immutable pattern to prevent memory leaks and race conditions
- */
-class VldBase {
-    /**
-     * Constructor with runtime type identifier
-     * @param validatorType The runtime type identifier
-     */
-    constructor(validatorType = 'unknown') {
-        this.validatorType = validatorType;
-    }
-    get '~standard'() {
-        return {
-            version: 1,
-            vendor: 'vld',
-            validate: (value) => {
-                const result = this.safeParse(value);
-                if (result.success) {
-                    return { value: result.data };
-                }
-                return { issues: [{ message: result.error.message }] };
-            },
-            types: undefined
-        };
-    }
-    async parseAsync(value) {
-        return this.parse(value);
-    }
-    async safeParseAsync(value) {
-        try {
-            return { success: true, data: await this.parseAsync(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-    /**
-     * Check if a value is valid according to this validator
-     * @param value The value to check
-     * @returns True if valid, false otherwise
-     */
-    isValid(value) {
-        return this.safeParse(value).success;
-    }
-    /**
-     * Parse a value or return a default if validation fails
-     * BUG-NEW-017 FIX: Validate default value to ensure type safety
-     * @param value The value to validate
-     * @param defaultValue The default value to return on failure
-     * @returns The validated value or default
-     */
-    parseOrDefault(value, defaultValue) {
-        const result = this.safeParse(value);
-        if (result.success) {
-            return result.data;
-        }
-        // Validate the default value to ensure it's actually valid
-        const defaultResult = this.safeParse(defaultValue);
-        if (!defaultResult.success) {
-            throw new Error(`Invalid default value provided: ${defaultResult.error.message}`);
-        }
-        return defaultResult.data;
-    }
-    refine(predicate, message) {
-        return new VldRefine(this, predicate, message);
-    }
-    /**
-     * Advanced refinement with context for adding multiple issues
-     * @param refinement The refinement function with context
-     * @returns A new super refined validator
-     */
-    superRefine(refinement) {
-        return new VldSuperRefine(this, refinement);
-    }
-    /**
-     * Create a new validator that transforms the output
-     * @param transformer The transformation function
-     * @returns A new transformed validator
-     */
-    transform(transformer) {
-        return new VldTransform(this, transformer);
-    }
-    /**
-     * Create a new validator with a default value for undefined inputs
-     * @param defaultValue The default value
-     * @returns A new validator with default
-     */
-    default(defaultValue) {
-        return new VldDefault(this, defaultValue);
-    }
-    /**
-     * Create a new validator that catches errors and returns a fallback
-     * @param fallbackValue The fallback value
-     * @returns A new validator with catch
-     */
-    catch(fallbackValue) {
-        return new VldCatch(this, fallbackValue);
-    }
-    /**
-     * Make this validator optional (allows undefined)
-     * @returns A new optional validator
-     */
-    optional() {
-        return new VldOptional(this);
-    }
-    /**
-     * Make this validator nullable (allows null)
-     * @returns A new nullable validator
-     */
-    nullable() {
-        return new VldNullable(this);
-    }
-    /**
-     * Make this validator nullish (allows null or undefined)
-     * @returns A new nullish validator
-     */
-    nullish() {
-        return new VldNullish(this);
-    }
-    /**
-     * Make this validator exactly optional - allows undefined but not missing
-     * Unlike .optional() which treats missing as undefined, exactOptional()
-     * requires the key to be present but allows undefined as a value
-     * Zod 4 API parity
-     * @returns A new exact optional validator
-     */
-    exactOptional() {
-        return new VldExactOptional(this);
-    }
-    /**
-     * Pipe the output of this validator into another validator
-     * @param next The next validator to pipe into
-     * @returns A new piped validator
-     */
-    pipe(next) {
-        return new VldPipe(this, next);
-    }
-    /**
-     * Create a new validator that returns readonly output
-     * Zod 4 API parity - marks output as readonly for TypeScript
-     * @returns A new readonly validator
-     */
-    readonly() {
-        return new VldReadonly(this);
-    }
-    /**
-     * Brand the output type with a unique brand for nominal typing
-     * Zod 4 API parity - prevents accidental assignment of similarly typed values
-     * @returns A new branded validator
-     * @example
-     * const userIdSchema = v.string().brand<'UserId'>();
-     * const productIdSchema = v.string().brand<'ProductId'>();
-     *
-     * let userId: UserId = userIdSchema.parse('abc');
-     * let productId: ProductId = productIdSchema.parse('xyz');
-     *
-     * userId = productId; // TypeScript error: types are incompatible
-     */
-    brand() {
-        return new VldBrand(this);
-    }
-    /**
-     * Apply an external function to transform this validator
-     * Zod 4 API parity - allows external function chaining
-     * @param fn External function that takes this validator and returns a new validator
-     * @returns The result of applying the function to this validator
-     * @example
-     * const withLength = (schema: VldBase<unknown, string>) => schema.transform(s => s.length);
-     * const lengthSchema = v.string().apply(withLength); // validates string, returns number
-     */
-    apply(fn) {
-        return fn(this);
-    }
-    check(predicate, message) {
-        return new VldRefine(this, predicate, message);
-    }
-    /**
-     * Get or set metadata for this schema
-     */
-    meta(data) {
-        if (data === undefined) {
-            return globalRegistry.get(this);
-        }
-        const schema = new VldMeta(this, data);
-        globalRegistry.add(schema, data);
-        return schema;
-    }
-    /**
-     * Register this schema in a metadata registry and return the same instance.
-     * This mirrors Zod 4's registry convenience API without changing validator
-     * immutability.
-     */
-    register(targetRegistry, metadata) {
-        targetRegistry.add(this, metadata);
-        return this;
-    }
-    /**
-     * Add a description to this schema
-     * Zod 4 API parity - convenience method for .meta({ description: ... })
-     * @param description The description to add
-     * @returns A new validator with the description
-     */
-    describe(description) {
-        return this.meta({ description });
-    }
-}
-/**
- * Metadata validator - wraps a schema with metadata
- */
-class VldMeta extends VldBase {
-    constructor(baseValidator, metadata) {
-        super(VLD_VALIDATOR_TYPES.META);
-        this.baseValidator = baseValidator;
-        this.metadata = metadata;
-    }
-    parse(value) {
-        return this.baseValidator.parse(value);
-    }
-    safeParse(value) {
-        return this.baseValidator.safeParse(value);
-    }
-    /**
-     * Get the metadata
-     */
-    getMeta() {
-        return { ...this.metadata };
-    }
-    meta(data) {
-        if (data === undefined) {
-            return { ...this.metadata, ...globalRegistry.get(this) };
-        }
-        const schema = new VldMeta(this.baseValidator, { ...this.metadata, ...data });
-        globalRegistry.add(schema, schema.getMeta());
-        return schema;
-    }
-    describe(description) {
-        return this.meta({ description });
-    }
-}
-/**
- * Readonly validator - marks output as readonly
- */
-class VldReadonly extends VldBase {
-    constructor(baseValidator) {
-        super(VLD_VALIDATOR_TYPES.READONLY);
-        this.baseValidator = baseValidator;
-    }
-    parse(value) {
-        return this.baseValidator.parse(value);
-    }
-    safeParse(value) {
-        const result = this.baseValidator.safeParse(value);
-        if (result.success) {
-            return { success: true, data: result.data };
-        }
-        return { success: false, error: result.error };
-    }
-}
-/**
- * Brand validator - adds a unique brand to the output type for nominal typing
- * Uses TypeScript's branded types pattern to prevent accidental assignment
- */
-class VldBrand extends VldBase {
-    constructor(baseValidator) {
-        super(VLD_VALIDATOR_TYPES.BRAND);
-        this.baseValidator = baseValidator;
-    }
-    parse(value) {
-        return this.baseValidator.parse(value);
-    }
-    safeParse(value) {
-        const result = this.baseValidator.safeParse(value);
-        if (result.success) {
-            return {
-                success: true,
-                data: result.data
-            };
-        }
-        return { success: false, error: result.error };
-    }
-}
-/**
- * Refine validator - adds custom validation
- */
-class VldRefine extends VldBase {
-    constructor(baseValidator, predicate, customMessage) {
-        super(VLD_VALIDATOR_TYPES.REFINE);
-        this.baseValidator = baseValidator;
-        this.predicate = predicate;
-        this.customMessage = customMessage;
-    }
-    parse(value) {
-        const baseResult = this.baseValidator.parse(value);
-        const passed = this.predicate(baseResult);
-        if (isPromiseLike(passed)) {
-            throw new Error('Use parseAsync for async refinements');
-        }
-        if (!passed) {
-            throw new Error(this.customMessage || 'Refinement check failed');
-        }
-        return baseResult;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-    async parseAsync(value) {
-        const baseResult = await this.baseValidator.parseAsync(value);
-        if (!await this.predicate(baseResult)) {
-            throw new Error(this.customMessage || 'Refinement check failed');
-        }
-        return baseResult;
-    }
-}
-/**
- * Transform validator - transforms data after validation
- */
-class VldTransform extends VldBase {
-    constructor(baseValidator, transformer) {
-        super(VLD_VALIDATOR_TYPES.TRANSFORM);
-        this.baseValidator = baseValidator;
-        this.transformer = transformer;
-    }
-    parse(value) {
-        const baseResult = this.baseValidator.parse(value);
-        try {
-            const transformed = this.transformer(baseResult);
-            if (isPromiseLike(transformed)) {
-                throw new Error('Use parseAsync for async transforms');
-            }
-            return transformed;
-        }
-        catch (error) {
-            throw new Error(`Transform failed: ${error.message}`);
-        }
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-    async parseAsync(value) {
-        const baseResult = await this.baseValidator.parseAsync(value);
-        try {
-            return await this.transformer(baseResult);
-        }
-        catch (error) {
-            throw new Error(`Transform failed: ${error.message}`);
-        }
-    }
-}
-/**
- * Default validator - provides default value for undefined
- * Note: Does not validate the default value at construction time.
- * Use .prefault() to validate the default value at parse time.
- */
-class VldDefault extends VldBase {
-    constructor(baseValidator, defaultValue) {
-        super(VLD_VALIDATOR_TYPES.DEFAULT);
-        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);
-    }
-    /**
-     * Pre-parse default - validates the default value instead of returning it directly
-     * This is useful when the default value needs to be validated against the schema
-     */
-    prefault() {
-        // Return a new validator that validates the default value when parse(undefined) is called
-        return new VldPrefault(this.baseValidator, this.defaultValue);
-    }
-}
-/**
- * Prefault validator - validates the default value instead of returning it directly
- */
-class VldPrefault extends VldBase {
-    constructor(baseValidator, defaultValue) {
-        super(VLD_VALIDATOR_TYPES.PREFAULT);
-        this.baseValidator = baseValidator;
-        this.defaultValue = defaultValue;
-    }
-    parse(value) {
-        if (value === undefined) {
-            // Validate the default value through the base validator
-            return this.baseValidator.parse(this.defaultValue);
-        }
-        return this.baseValidator.parse(value);
-    }
-    safeParse(value) {
-        if (value === undefined) {
-            return this.baseValidator.safeParse(this.defaultValue);
-        }
-        return this.baseValidator.safeParse(value);
-    }
-    /**
-     * Calling prefault multiple times should be safe - return self
-     */
-    prefault() {
-        return this;
-    }
-}
-/**
- * Catch validator - provides fallback value on validation error
- * BUG-NPM-003 FIX: Validate fallback value at construction time
- */
-class VldCatch extends VldBase {
-    constructor(baseValidator, fallbackValue) {
-        super(VLD_VALIDATOR_TYPES.CATCH);
-        this.baseValidator = baseValidator;
-        this.fallbackValue = fallbackValue;
-        this.simpleMode = getSimpleWrappedMode(baseValidator);
-        // BUG-NPM-003 FIX: Validate the fallback value to ensure type safety
-        const validation = baseValidator.safeParse(fallbackValue);
-        if (!validation.success) {
-            throw new Error(`Invalid fallback value: ${validation.error.message}`);
-        }
-    }
-    parse(value) {
-        const simpleValue = parseSimpleWrappedValue(this.simpleMode, value);
-        if (simpleValue !== undefined) {
-            return simpleValue;
-        }
-        if (this.simpleMode !== undefined) {
-            return this.fallbackValue;
-        }
-        try {
-            return this.baseValidator.parse(value);
-        }
-        catch {
-            return this.fallbackValue;
-        }
-    }
-    safeParse(value) {
-        const simpleValue = parseSimpleWrappedValue(this.simpleMode, value);
-        if (simpleValue !== undefined) {
-            return { success: true, data: simpleValue };
-        }
-        if (this.simpleMode !== undefined) {
-            return { success: true, data: this.fallbackValue };
-        }
-        const result = this.baseValidator.safeParse(value);
-        if (result.success) {
-            return result;
-        }
-        return { success: true, data: this.fallbackValue };
-    }
-}
-/**
- * Optional validator - allows undefined
- */
-class VldOptional extends VldBase {
-    constructor(baseValidator) {
-        super(VLD_VALIDATOR_TYPES.OPTIONAL);
-        this.baseValidator = baseValidator;
-        this.simpleMode = getSimpleWrappedMode(baseValidator);
-    }
-    parseSimpleValue(value) {
-        return parseSimpleWrappedValue(this.simpleMode, value);
-    }
-    static create(baseValidator) {
-        return new VldOptional(baseValidator);
-    }
-    parse(value) {
-        if (value === undefined) {
-            return undefined;
-        }
-        const simpleValue = this.parseSimpleValue(value);
-        if (simpleValue !== undefined) {
-            return simpleValue;
-        }
-        return this.baseValidator.parse(value);
-    }
-    safeParse(value) {
-        if (value === undefined) {
-            return { success: true, data: undefined };
-        }
-        const simpleValue = this.parseSimpleValue(value);
-        if (simpleValue !== undefined) {
-            return { success: true, data: simpleValue };
-        }
-        return this.baseValidator.safeParse(value);
-    }
-    unwrap() {
-        return this.baseValidator;
-    }
-}
-/**
- * Exact optional validator - allows undefined but requires key presence
- * Unlike Optional which treats missing as undefined, ExactOptional
- * requires the key to be present (not missing from object) but allows undefined
- * Zod 4 API parity
- */
-class VldExactOptional extends VldBase {
-    constructor(baseValidator) {
-        super(VLD_VALIDATOR_TYPES.EXACT_OPTIONAL);
-        this.baseValidator = baseValidator;
-        this.simpleMode = getSimpleWrappedMode(baseValidator);
-    }
-    static create(baseValidator) {
-        return new VldExactOptional(baseValidator);
-    }
-    parse(value) {
-        if (value === undefined) {
-            return undefined;
-        }
-        const simpleValue = parseSimpleWrappedValue(this.simpleMode, value);
-        if (simpleValue !== undefined) {
-            return simpleValue;
-        }
-        return this.baseValidator.parse(value);
-    }
-    safeParse(value) {
-        // Unlike regular optional, undefined is explicitly valid
-        // but we still validate through the base validator
-        if (value === undefined) {
-            return { success: true, data: undefined };
-        }
-        const simpleValue = parseSimpleWrappedValue(this.simpleMode, value);
-        if (simpleValue !== undefined) {
-            return { success: true, data: simpleValue };
-        }
-        return this.baseValidator.safeParse(value);
-    }
-    unwrap() {
-        return this.baseValidator;
-    }
-}
-/**
- * Nullable validator - allows null
- */
-class VldNullable extends VldBase {
-    constructor(baseValidator) {
-        super(VLD_VALIDATOR_TYPES.NULLABLE);
-        this.baseValidator = baseValidator;
-        this.simpleMode = getSimpleWrappedMode(baseValidator);
-    }
-    static create(baseValidator) {
-        return new VldNullable(baseValidator);
-    }
-    parse(value) {
-        if (value === null) {
-            return null;
-        }
-        const simpleValue = parseSimpleWrappedValue(this.simpleMode, value);
-        if (simpleValue !== undefined) {
-            return simpleValue;
-        }
-        return this.baseValidator.parse(value);
-    }
-    safeParse(value) {
-        if (value === null) {
-            return { success: true, data: null };
-        }
-        const simpleValue = parseSimpleWrappedValue(this.simpleMode, value);
-        if (simpleValue !== undefined) {
-            return { success: true, data: simpleValue };
-        }
-        return this.baseValidator.safeParse(value);
-    }
-    unwrap() {
-        return this.baseValidator;
-    }
-}
-/**
- * Nullish validator - allows null or undefined
- */
-class VldNullish extends VldBase {
-    constructor(baseValidator) {
-        super(VLD_VALIDATOR_TYPES.NULLISH);
-        this.baseValidator = baseValidator;
-        this.simpleMode = getSimpleWrappedMode(baseValidator);
-    }
-    static create(baseValidator) {
-        return new VldNullish(baseValidator);
-    }
-    parse(value) {
-        if (value === null || value === undefined) {
-            return value;
-        }
-        const simpleValue = parseSimpleWrappedValue(this.simpleMode, value);
-        if (simpleValue !== undefined) {
-            return simpleValue;
-        }
-        return this.baseValidator.parse(value);
-    }
-    safeParse(value) {
-        if (value === null || value === undefined) {
-            return { success: true, data: value };
-        }
-        const simpleValue = parseSimpleWrappedValue(this.simpleMode, value);
-        if (simpleValue !== undefined) {
-            return { success: true, data: simpleValue };
-        }
-        return this.baseValidator.safeParse(value);
-    }
-    unwrap() {
-        return this.baseValidator;
-    }
-}
-/**
- * Pipe validator - chains validators, passing output of one to the next
- */
-class VldPipe extends VldBase {
-    constructor(first, second) {
-        super(VLD_VALIDATOR_TYPES.PIPE);
-        this.first = first;
-        this.second = second;
-    }
-    parse(value) {
-        const intermediateResult = this.first.parse(value);
-        return this.second.parse(intermediateResult);
-    }
-    safeParse(value) {
-        const firstResult = this.first.safeParse(value);
-        if (!firstResult.success) {
-            return { success: false, error: firstResult.error };
-        }
-        return this.second.safeParse(firstResult.data);
-    }
-}
-/**
- * SuperRefine validator - advanced refinement with context
- */
-class VldSuperRefine extends VldBase {
-    constructor(_inner, _refinement) {
-        super(VLD_VALIDATOR_TYPES.SUPER_REFINE);
-        this._inner = _inner;
-        this._refinement = _refinement;
-    }
-    parse(value) {
-        const result = this._inner.parse(value);
-        const issues = [];
-        const ctx = {
-            addIssue: (issue) => issues.push(issue),
-            path: []
-        };
-        const maybePromise = this._refinement(result, ctx);
-        if (maybePromise instanceof Promise) {
-            throw new Error('Use parseAsync for async refinements');
-        }
-        if (issues.length > 0) {
-            throw new Error(issues.map(i => i.message).join('; '));
-        }
-        return result;
-    }
-    safeParse(value) {
-        const result = this._inner.safeParse(value);
-        if (!result.success)
-            return { success: false, error: result.error };
-        const issues = [];
-        const ctx = {
-            addIssue: (issue) => issues.push(issue),
-            path: []
-        };
-        const maybePromise = this._refinement(result.data, ctx);
-        if (maybePromise instanceof Promise) {
-            throw new Error('Use safeParseAsync for async refinements');
-        }
-        if (issues.length > 0) {
-            return {
-                success: false,
-                error: new Error(issues.map(i => i.message).join('; '))
-            };
-        }
-        return result;
-    }
-    async parseAsync(value) {
-        const result = await this._inner.parseAsync(value);
-        const issues = [];
-        const ctx = {
-            addIssue: (issue) => issues.push(issue),
-            path: []
-        };
-        await this._refinement(result, ctx);
-        if (issues.length > 0) {
-            throw new Error(issues.map(i => i.message).join('; '));
-        }
-        return result;
-    }
-    async safeParseAsync(value) {
-        try {
-            return { success: true, data: await this.parseAsync(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-/**
- * Preprocess validator - transforms input before validation
- */
-class VldPreprocess extends VldBase {
-    constructor(_preprocessor, _schema) {
-        super(VLD_VALIDATOR_TYPES.PREPROCESS);
-        this._preprocessor = _preprocessor;
-        this._schema = _schema;
-    }
-    static create(preprocessor, schema) {
-        return new VldPreprocess(preprocessor, schema);
-    }
-    parse(value) {
-        const preprocessed = this._preprocessor(value);
-        return this._schema.parse(preprocessed);
-    }
-    safeParse(value) {
-        try {
-            const preprocessed = this._preprocessor(value);
-            return this._schema.safeParse(preprocessed);
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error
-            };
-        }
-    }
-}
-
-export { VLD_VALIDATOR_TYPES, VldBase, VldBrand, VldCatch, VldDefault, VldExactOptional, VldMeta, VldNullable, VldNullish, VldOptional, VldPipe, VldPrefault, VldPreprocess, VldReadonly, VldRefine, VldSuperRefine, VldTransform, resolveErrorMessage };
+import{globalRegistry as e}from"../registry.js";import{V as t}from"../chunks/errors-core-CerMg2rq.js";function s(e){if(e instanceof t)return e;const s=e instanceof Error?e.message:String(e);return new t([{code:"custom",path:[],message:s}])}const r={STRING:"string",STRING_FORMAT:"stringFormat",STRING_BOOL:"stringBool",NUMBER:"number",BOOLEAN:"boolean",DATE:"date",BIGINT:"bigint",UNDEFINED:"undefined",NULL:"null",UNKNOWN:"unknown",ANY:"any",VOID:"void",NEVER:"never",SYMBOL:"symbol",NAN:"nan",HEX:"hex",BASE64:"base64",UINT8_ARRAY:"uint8Array",COERCE_STRING:"coerceString",COERCE_NUMBER:"coerceNumber",COERCE_BOOLEAN:"coerceBoolean",COERCE_DATE:"coerceDate",COERCE_BIGINT:"coerceBigint",OBJECT:"object",ARRAY:"array",TUPLE:"tuple",SET:"set",MAP:"map",RECORD:"record",UNION:"union",DISCRIMINATED_UNION:"discriminatedUnion",INTERSECTION:"intersection",XOR:"xor",ENUM:"enum",LITERAL:"literal",LAZY:"lazy",CUSTOM:"custom",FUNCTION:"function",FILE:"file",JSON:"json",TEMPLATE_LITERAL:"templateLiteral",PROMISE:"promise",OPTIONAL:"optional",NULLABLE:"nullable",NULLISH:"nullish",EXACT_OPTIONAL:"exactOptional",DEFAULT:"default",CATCH:"catch",REFINE:"refine",TRANSFORM:"transform",PIPE:"pipe",PREPROCESS:"preprocess",SUPER_REFINE:"superRefine",BRAND:"brand",READONLY:"readonly",META:"meta",PREFAULT:"prefault",PREFault:"prefault",CODEC:"codec"};function a(e,t){if("string"==typeof e)return e;if("function"==typeof e){const s=e(void 0);return"string"==typeof s?s:"object"==typeof s&&s?.message?s.message:t}if("object"==typeof e&&null!==e){if("string"==typeof e.error)return e.error;if("function"==typeof e.error)return e.error({})||t;if("string"==typeof e.message)return e.message}return t}function i(e){return null!==e&&("object"==typeof e||"function"==typeof e)&&"function"==typeof e.then}let n;function o(e){n=e}function h(e){return"function"==typeof e?e():function(e){if(Array.isArray(e))return[...e];if(e instanceof Map)return new Map(e);if(e instanceof Set)return new Set(e);if(null!==e&&"object"==typeof e){const t=Object.getPrototypeOf(e);if(t===Object.prototype||null===t)return{...e}}return e}(e)}function u(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";default:return}}function l(e,t){switch(e){case"string":return"string"==typeof t?t:void 0;case"number":return"number"!=typeof t||isNaN(t)?void 0:t;case"boolean":return"boolean"==typeof t?t:void 0;case"bigint":return"bigint"==typeof t?t:void 0;case"symbol":return"symbol"==typeof t?t:void 0;default:return}}class VldBase{constructor(e="unknown"){this.validatorType=e}get type(){return this.validatorType}get _def(){return{typeName:"Zod"+this.validatorType.charAt(0).toUpperCase()+this.validatorType.slice(1),...this.config||{}}}get def(){return this._def}get _zod(){return this._def}get"~standard"(){return{version:1,vendor:"vld",validate:e=>{const t=this.safeParse(e);return t.success?{value:t.data}:{issues:[{message:t.error.message}]}},types:void 0}}async parseAsync(e){return this.parse(e)}async safeParseAsync(e){try{return{success:!0,data:await this.parseAsync(e)}}catch(e){return{success:!1,error:s(e)}}}decode(e){return this.parse(e)}safeDecode(e){return this.safeParse(e)}async decodeAsync(e){return this.parseAsync(e)}async safeDecodeAsync(e){return this.safeParseAsync(e)}encode(e){return this.parse(e)}safeEncode(e){const t=this.safeParse(e);return t.success?{success:!0,data:t.data}:t}async encodeAsync(e){return this.parseAsync(e)}async safeEncodeAsync(e){const t=await this.safeParseAsync(e);return t.success?{success:!0,data:t.data}:t}spa(e){return this.safeParseAsync(e)}isOptional(){return this.safeParse(void 0).success}isNullable(){return this.safeParse(null).success}clone(){return this}isValid(e){return this.safeParse(e).success}parseOrDefault(e,t){const s=this.safeParse(e);if(s.success)return s.data;const r=this.safeParse(t);if(!r.success)throw new Error(`Invalid default value provided: ${r.error.message}`);return r.data}refine(e,t){return new VldRefine(this,e,t)}superRefine(e){return new VldSuperRefine(this,e)}transform(e){return new VldTransform(this,e)}default(e){return new VldDefault(this,e)}prefault(e){return new VldPrefault(this,e)}nonoptional(e){return new VldRefine(this,e=>void 0!==e,a(e,"Expected non-optional value"))}array(){return n.array(this)}or(e){return n.union(this,e)}and(e){return n.intersection(this,e)}overwrite(e){return new VldTransform(this,e)}with(...e){return new VldSuperRefine(this,(t,s)=>{const r={value:t,issues:[]},a=[];for(const t of e){const e="function"==typeof t?t:t._zod?.check;if(!e)continue;const s=e(r);i(s)&&a.push(Promise.resolve(s))}const n=()=>{for(const e of r.issues)s.addIssue(void 0===e.code?{message:e.message||"Custom check failed"}:{message:e.message||"Custom check failed",code:e.code})};if(a.length>0)return Promise.all(a).then(n);n()})}toJSONSchema(e){return n.toJSONSchema(this,e)}catch(e){return new VldCatch(this,e)}optional(){return new VldOptional(this)}nullable(){return new VldNullable(this)}nullish(){return new VldNullish(this)}exactOptional(){return new VldExactOptional(this)}pipe(e){return new VldPipe(this,e)}readonly(){return new VldReadonly(this)}brand(){return new VldBrand(this)}apply(e){return e(this)}check(e,t){return this.refine(e,t)}meta(t){if(void 0===t)return e.get(this)??this.baseValidator?.meta?.()??this.schema?.meta?.()??this.inner?.meta?.();const s=new VldMeta(this,t);return e.add(s,t),s}register(e,t){return e.add(this,t),this}describe(e){return this.meta({description:e})}get description(){return this.meta()?.description??this.baseValidator?.description??this.schema?.description??this.inner?.description}}class VldMeta extends VldBase{constructor(e,t){super(r.META),this.baseValidator=e,this.metadata=t}parse(e){return this.baseValidator.parse(e)}safeParse(e){return this.baseValidator.safeParse(e)}getMeta(){return{...this.metadata}}meta(t){if(void 0===t)return{...this.metadata,...e.get(this)};const s=new VldMeta(this.baseValidator,{...this.metadata,...t});return e.add(s,s.getMeta()),s}describe(e){return this.meta({description:e})}}class VldReadonly extends VldBase{constructor(e){super(r.READONLY),this.baseValidator=e}parse(e){return this.baseValidator.parse(e)}safeParse(e){const t=this.baseValidator.safeParse(e);return t.success?{success:!0,data:t.data}:{success:!1,error:t.error}}}class VldBrand extends VldBase{constructor(e){super(r.BRAND),this.baseValidator=e}parse(e){return this.baseValidator.parse(e)}safeParse(e){const t=this.baseValidator.safeParse(e);return t.success?{success:!0,data:t.data}:{success:!1,error:t.error}}}class VldRefine extends VldBase{constructor(e,t,s){super(r.REFINE),this.baseValidator=e,this.predicate=t,this.customMessage=s??"Refinement check failed","object"==typeof s&&null!==s&&"path"in s&&Array.isArray(s.path)&&(this.refinePath=s.path)}_createIssue(e){if("function"==typeof this.customMessage){const t=this.customMessage(e);return"string"==typeof t?{code:"custom",path:this.refinePath??[],message:t}:{code:"custom",path:t?.path??this.refinePath??[],message:t?.message??"Refinement check failed"}}if("object"==typeof this.customMessage&&null!==this.customMessage){const e=this.customMessage.message??this.customMessage.error,t="function"==typeof e?e({}):"string"==typeof e?e:"Refinement check failed";return{code:"custom",path:this.customMessage.path??this.refinePath??[],message:t}}return{code:"custom",path:this.refinePath??[],message:"string"==typeof this.customMessage?this.customMessage:"Refinement check failed"}}parse(e){const s=this.baseValidator.parse(e),r=this.predicate(s);if(i(r))throw new Error("Use parseAsync for async refinements");if(!r)throw new t([this._createIssue(s)]);return s}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:s(e)}}}async parseAsync(e){const s=await this.baseValidator.parseAsync(e);if(!await this.predicate(s))throw new t([this._createIssue(s)]);return s}async safeParseAsync(e){try{return{success:!0,data:await this.parseAsync(e)}}catch(e){return{success:!1,error:s(e)}}}_wrap(e){return new VldRefine(e,this.predicate,this.customMessage)}min(e,t){return this._wrap(this.baseValidator.min?.(e,t)??this.baseValidator)}max(e,t){return this._wrap(this.baseValidator.max?.(e,t)??this.baseValidator)}length(e,t){return this._wrap(this.baseValidator.length?.(e,t)??this.baseValidator)}email(e){return this._wrap(this.baseValidator.email?.(e)??this.baseValidator)}url(e){return this._wrap(this.baseValidator.url?.(e)??this.baseValidator)}uuid(e){return this._wrap(this.baseValidator.uuid?.(e)??this.baseValidator)}regex(e,t){return this._wrap(this.baseValidator.regex?.(e,t)??this.baseValidator)}startsWith(e,t){return this._wrap(this.baseValidator.startsWith?.(e,t)??this.baseValidator)}endsWith(e,t){return this._wrap(this.baseValidator.endsWith?.(e,t)??this.baseValidator)}includes(e,t){return this._wrap(this.baseValidator.includes?.(e,t)??this.baseValidator)}ip(e){return this._wrap(this.baseValidator.ip?.(e)??this.baseValidator)}ipv4(e){return this._wrap(this.baseValidator.ipv4?.(e)??this.baseValidator)}ipv6(e){return this._wrap(this.baseValidator.ipv6?.(e)??this.baseValidator)}nonempty(e){return this._wrap(this.baseValidator.nonempty?.(e)??this.baseValidator)}trim(){return this._wrap(this.baseValidator.trim?.()??this.baseValidator)}toLowerCase(){return this._wrap(this.baseValidator.toLowerCase?.()??this.baseValidator)}lowercase(){return this.toLowerCase()}toUpperCase(){return this._wrap(this.baseValidator.toUpperCase?.()??this.baseValidator)}uppercase(){return this.toUpperCase()}positive(e){return this._wrap(this.baseValidator.positive?.(e)??this.baseValidator)}negative(e){return this._wrap(this.baseValidator.negative?.(e)??this.baseValidator)}nonnegative(e){return this._wrap(this.baseValidator.nonnegative?.(e)??this.baseValidator)}nonpositive(e){return this._wrap(this.baseValidator.nonpositive?.(e)??this.baseValidator)}int(e){return this._wrap(this.baseValidator.int?.(e)??this.baseValidator)}finite(e){return this._wrap(this.baseValidator.finite?.(e)??this.baseValidator)}safe(e){return this._wrap(this.baseValidator.safe?.(e)??this.baseValidator)}multipleOf(e,t){return this._wrap(this.baseValidator.multipleOf?.(e,t)??this.baseValidator)}step(e,t){return this._wrap(this.baseValidator.step?.(e,t)??this.baseValidator)}gt(e,t){return this._wrap(this.baseValidator.gt?.(e,t)??this.baseValidator)}gte(e,t){return this._wrap(this.baseValidator.gte?.(e,t)??this.baseValidator)}lt(e,t){return this._wrap(this.baseValidator.lt?.(e,t)??this.baseValidator)}lte(e,t){return this._wrap(this.baseValidator.lte?.(e,t)??this.baseValidator)}extend(e){return this._wrap(this.baseValidator.extend?.(e)??this.baseValidator)}merge(e){return this._wrap(this.baseValidator.merge?.(e)??this.baseValidator)}pick(...e){return this._wrap(this.baseValidator.pick?.(...e)??this.baseValidator)}omit(...e){return this._wrap(this.baseValidator.omit?.(...e)??this.baseValidator)}partial(){return this._wrap(this.baseValidator.partial?.()??this.baseValidator)}required(){return this._wrap(this.baseValidator.required?.()??this.baseValidator)}strict(e){return this._wrap(this.baseValidator.strict?.(e)??this.baseValidator)}passthrough(){return this._wrap(this.baseValidator.passthrough?.()??this.baseValidator)}strip(){return this._wrap(this.baseValidator.strip?.()??this.baseValidator)}catchall(e){return this._wrap(this.baseValidator.catchall?.(e)??this.baseValidator)}get shape(){return this.baseValidator.shape}get keyof(){return this.baseValidator.keyof}unwrap(){return this.baseValidator.unwrap?this.baseValidator.unwrap():this.baseValidator}get element(){return this.baseValidator.element}}class VldTransform extends VldBase{constructor(e,t){super(r.TRANSFORM),this.baseValidator=e,this.transformer=t}parse(e){const t=this.baseValidator.parse(e);try{const e=this.transformer(t);if(i(e))throw new Error("Use parseAsync for async transforms");return e}catch(e){throw new Error(`Transform failed: ${e.message}`)}}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:s(e)}}}async parseAsync(e){const t=await this.baseValidator.parseAsync(e);try{return await this.transformer(t)}catch(e){throw new Error(`Transform failed: ${e.message}`)}}}class VldDefault extends VldBase{constructor(e,t){super(r.DEFAULT),this.baseValidator=e,this.defaultValue=t}parse(e){return void 0===e?h(this.defaultValue):this.baseValidator.parse(e)}safeParse(e){return void 0===e?{success:!0,data:h(this.defaultValue)}:this.baseValidator.safeParse(e)}prefault(e){return new VldPrefault(this.baseValidator,void 0===e?this.defaultValue:e)}unwrap(){return this.baseValidator}removeDefault(){return this.baseValidator}}class VldPrefault extends VldBase{constructor(e,t){super(r.PREFAULT),this.baseValidator=e,this.defaultValue=t}parse(e){return void 0===e?this.baseValidator.parse(h(this.defaultValue)):this.baseValidator.parse(e)}safeParse(e){return void 0===e?this.baseValidator.safeParse(h(this.defaultValue)):this.baseValidator.safeParse(e)}prefault(e){return void 0===e?this:new VldPrefault(this.baseValidator,e)}unwrap(){return this.baseValidator}}class VldCatch extends VldBase{constructor(e,t){super(r.CATCH),this.baseValidator=e,this.fallbackValue=t,this.simpleMode=u(e);const s=e.safeParse(t);if(!s.success)throw new Error(`Invalid fallback value: ${s.error.message}`)}parse(e){const t=l(this.simpleMode,e);if(void 0!==t)return t;if(void 0!==this.simpleMode)return this.fallbackValue;try{return this.baseValidator.parse(e)}catch{return this.fallbackValue}}safeParse(e){const t=l(this.simpleMode,e);if(void 0!==t)return{success:!0,data:t};if(void 0!==this.simpleMode)return{success:!0,data:this.fallbackValue};const s=this.baseValidator.safeParse(e);return s.success?s:{success:!0,data:this.fallbackValue}}}class VldOptional extends VldBase{constructor(e){super(r.OPTIONAL),this.baseValidator=e,this.simpleMode=u(e)}parseSimpleValue(e){return l(this.simpleMode,e)}static create(e){return new VldOptional(e)}parse(e){if(void 0===e)return;const t=this.parseSimpleValue(e);return void 0!==t?t:this.baseValidator.parse(e)}safeParse(e){if(void 0===e)return{success:!0,data:void 0};const t=this.parseSimpleValue(e);return void 0!==t?{success:!0,data:t}:this.baseValidator.safeParse(e)}unwrap(){return this.baseValidator}}class VldExactOptional extends VldBase{constructor(e){super(r.EXACT_OPTIONAL),this.baseValidator=e,this.simpleMode=u(e)}static create(e){return new VldExactOptional(e)}parse(e){if(void 0===e)return;const t=l(this.simpleMode,e);return void 0!==t?t:this.baseValidator.parse(e)}safeParse(e){if(void 0===e)return{success:!0,data:void 0};const t=l(this.simpleMode,e);return void 0!==t?{success:!0,data:t}:this.baseValidator.safeParse(e)}unwrap(){return this.baseValidator}}class VldNullable extends VldBase{constructor(e){super(r.NULLABLE),this.baseValidator=e,this.simpleMode=u(e)}static create(e){return new VldNullable(e)}parse(e){if(null===e)return null;const t=l(this.simpleMode,e);return void 0!==t?t:this.baseValidator.parse(e)}safeParse(e){if(null===e)return{success:!0,data:null};const t=l(this.simpleMode,e);return void 0!==t?{success:!0,data:t}:this.baseValidator.safeParse(e)}unwrap(){return this.baseValidator}}class VldNullish extends VldBase{constructor(e){super(r.NULLISH),this.baseValidator=e,this.simpleMode=u(e)}static create(e){return new VldNullish(e)}parse(e){if(null==e)return e;const t=l(this.simpleMode,e);return void 0!==t?t:this.baseValidator.parse(e)}safeParse(e){if(null==e)return{success:!0,data:e};const t=l(this.simpleMode,e);return void 0!==t?{success:!0,data:t}:this.baseValidator.safeParse(e)}unwrap(){return this.baseValidator}}class VldPipe extends VldBase{constructor(e,t){super(r.PIPE),this.first=e,this.second=t}parse(e){const t=this.first.parse(e);return this.second.parse(t)}safeParse(e){const t=this.first.safeParse(e);return t.success?this.second.safeParse(t.data):{success:!1,error:t.error}}}class VldSuperRefine extends VldBase{constructor(e,t){super(r.SUPER_REFINE),this._inner=e,this._refinement=t}parse(e){const s=this._inner.parse(e),r=[],a={addIssue:e=>{r.push({code:e.code||"custom",path:e.path??[],message:e.message||"Validation error"})},path:[]};if(this._refinement(s,a)instanceof Promise)throw new Error("Use parseAsync for async refinements");if(r.length>0)throw new t(r,r.map(e=>e.message).join("; "));return s}safeParse(e){const r=this._inner.safeParse(e);if(!r.success)return{success:!1,error:s(r.error)};const a=[],i={addIssue:e=>{a.push({code:e.code||"custom",path:e.path??[],message:e.message||"Validation error"})},path:[]};if(this._refinement(r.data,i)instanceof Promise)throw new Error("Use safeParseAsync for async refinements");return a.length>0?{success:!1,error:new t(a,a.map(e=>e.message).join("; "))}:r}async parseAsync(e){const s=await this._inner.parseAsync(e),r=[],a={addIssue:e=>{r.push({code:e.code||"custom",path:e.path??[],message:e.message||"Validation error"})},path:[]};if(await this._refinement(s,a),r.length>0)throw new t(r,r.map(e=>e.message).join("; "));return s}async safeParseAsync(e){try{return{success:!0,data:await this.parseAsync(e)}}catch(e){return{success:!1,error:s(e)}}}_wrap(e){return new VldSuperRefine(e,this._refinement)}min(e,t){return this._wrap(this._inner.min?.(e,t)??this._inner)}max(e,t){return this._wrap(this._inner.max?.(e,t)??this._inner)}length(e,t){return this._wrap(this._inner.length?.(e,t)??this._inner)}email(e){return this._wrap(this._inner.email?.(e)??this._inner)}url(e){return this._wrap(this._inner.url?.(e)??this._inner)}uuid(e){return this._wrap(this._inner.uuid?.(e)??this._inner)}regex(e,t){return this._wrap(this._inner.regex?.(e,t)??this._inner)}startsWith(e,t){return this._wrap(this._inner.startsWith?.(e,t)??this._inner)}endsWith(e,t){return this._wrap(this._inner.endsWith?.(e,t)??this._inner)}includes(e,t){return this._wrap(this._inner.includes?.(e,t)??this._inner)}ip(e){return this._wrap(this._inner.ip?.(e)??this._inner)}ipv4(e){return this._wrap(this._inner.ipv4?.(e)??this._inner)}ipv6(e){return this._wrap(this._inner.ipv6?.(e)??this._inner)}nonempty(e){return this._wrap(this._inner.nonempty?.(e)??this._inner)}trim(){return this._wrap(this._inner.trim?.()??this._inner)}toLowerCase(){return this._wrap(this._inner.toLowerCase?.()??this._inner)}lowercase(){return this.toLowerCase()}toUpperCase(){return this._wrap(this._inner.toUpperCase?.()??this._inner)}uppercase(){return this.toUpperCase()}positive(e){return this._wrap(this._inner.positive?.(e)??this._inner)}negative(e){return this._wrap(this._inner.negative?.(e)??this._inner)}nonnegative(e){return this._wrap(this._inner.nonnegative?.(e)??this._inner)}nonpositive(e){return this._wrap(this._inner.nonpositive?.(e)??this._inner)}int(e){return this._wrap(this._inner.int?.(e)??this._inner)}finite(e){return this._wrap(this._inner.finite?.(e)??this._inner)}safe(e){return this._wrap(this._inner.safe?.(e)??this._inner)}multipleOf(e,t){return this._wrap(this._inner.multipleOf?.(e,t)??this._inner)}step(e,t){return this._wrap(this._inner.step?.(e,t)??this._inner)}gt(e,t){return this._wrap(this._inner.gt?.(e,t)??this._inner)}gte(e,t){return this._wrap(this._inner.gte?.(e,t)??this._inner)}lt(e,t){return this._wrap(this._inner.lt?.(e,t)??this._inner)}lte(e,t){return this._wrap(this._inner.lte?.(e,t)??this._inner)}extend(e){return this._wrap(this._inner.extend?.(e)??this._inner)}merge(e){return this._wrap(this._inner.merge?.(e)??this._inner)}pick(...e){return this._wrap(this._inner.pick?.(...e)??this._inner)}omit(...e){return this._wrap(this._inner.omit?.(...e)??this._inner)}partial(){return this._wrap(this._inner.partial?.()??this._inner)}required(){return this._wrap(this._inner.required?.()??this._inner)}strict(e){return this._wrap(this._inner.strict?.(e)??this._inner)}passthrough(){return this._wrap(this._inner.passthrough?.()??this._inner)}strip(){return this._wrap(this._inner.strip?.()??this._inner)}catchall(e){return this._wrap(this._inner.catchall?.(e)??this._inner)}get shape(){return this._inner.shape}get keyof(){return this._inner.keyof}unwrap(){return this._inner.unwrap?this._inner.unwrap():this._inner}get element(){return this._inner.element}}class VldPreprocess extends VldBase{constructor(e,t){super(r.PREPROCESS),this._preprocessor=e,this._schema=t}static create(e,t){return new VldPreprocess(e,t)}parse(e){const t=this._preprocessor(e);return this._schema.parse(t)}safeParse(e){try{const t=this._preprocessor(e);return this._schema.safeParse(t)}catch(e){return{success:!1,error:s(e)}}}}export{r as VLD_VALIDATOR_TYPES,VldBase,VldBrand,VldCatch,VldDefault,VldExactOptional,VldMeta,VldNullable,VldNullish,VldOptional,VldPipe,VldPrefault,VldPreprocess,VldReadonly,VldRefine,VldSuperRefine,VldTransform,o as configureSchemaCompositionFactories,s as ensureVldError,i as isPromiseLike,a as resolveErrorMessage};