@oxog/vld 2.0.2 → 2.1.0

package/dist/cjs/validators/base.cjs

@@ -0,0 +1,887 @@
+'use strict';
+
+var registry = require('../registry.cjs');
+
+/**
+ * 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 registry.globalRegistry.get(this);
+        }
+        const schema = new VldMeta(this, data);
+        registry.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, ...registry.globalRegistry.get(this) };
+        }
+        const schema = new VldMeta(this.baseValidator, { ...this.metadata, ...data });
+        registry.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
+            };
+        }
+    }
+}
+
+exports.VLD_VALIDATOR_TYPES = VLD_VALIDATOR_TYPES;
+exports.VldBase = VldBase;
+exports.VldBrand = VldBrand;
+exports.VldCatch = VldCatch;
+exports.VldDefault = VldDefault;
+exports.VldExactOptional = VldExactOptional;
+exports.VldMeta = VldMeta;
+exports.VldNullable = VldNullable;
+exports.VldNullish = VldNullish;
+exports.VldOptional = VldOptional;
+exports.VldPipe = VldPipe;
+exports.VldPrefault = VldPrefault;
+exports.VldPreprocess = VldPreprocess;
+exports.VldReadonly = VldReadonly;
+exports.VldRefine = VldRefine;
+exports.VldSuperRefine = VldSuperRefine;
+exports.VldTransform = VldTransform;
+exports.resolveErrorMessage = resolveErrorMessage;