@oxog/vld 2.1.0 → 2.2.7

package/dist/validators/base64.js

@@ -1,68 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { createIssue } from '../errors.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-/**
- * Base64 string validator
- */
-class VldBase64 extends VldBase {
-    constructor(urlSafe = false) {
-        super(VLD_VALIDATOR_TYPES.BASE64);
-        this.urlSafe = urlSafe;
-    }
-    parse(value) {
-        const result = this.safeParse(value);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
-    }
-    safeParse(value) {
-        if (typeof value !== 'string') {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('invalid_type', [], getMessages().expectedString)
-                ])
-            };
-        }
-        // Check if it's a valid base64 string
-        const regex = this.urlSafe ? VldBase64.BASE64_URL_REGEX : VldBase64.BASE64_REGEX;
-        // Check basic format
-        if (!regex.test(value)) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().invalidBase64)
-                ])
-            };
-        }
-        // For standard base64, check length is multiple of 4 (after padding)
-        // Empty strings are valid (decode to empty buffer)
-        // For URL-safe base64, padding is not required
-        if (!this.urlSafe && value.length > 0 && value.length % 4 !== 0) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().invalidBase64)
-                ])
-            };
-        }
-        return { success: true, data: value };
-    }
-    /**
-     * Create a URL-safe base64 validator
-     */
-    urlSafeMode() {
-        return new VldBase64(true);
-    }
-    static create(urlSafe = false) {
-        return new VldBase64(urlSafe);
-    }
-}
-VldBase64.BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
-// Note: RFC 4648 specifies URL-safe base64 should omit padding, but we allow it for compatibility
-VldBase64.BASE64_URL_REGEX = /^[A-Za-z0-9_-]*={0,2}$/;
-
-export { VldBase64 };
+import{VldBase as e,VLD_VALIDATOR_TYPES as s}from"./base.js";import{createIssue as r}from"../errors.js";import{getMessages as t}from"../locales/runtime.js";import{V as a}from"../chunks/errors-core-CerMg2rq.js";class VldBase64 extends e{constructor(e=!1){super(s.BASE64),this.urlSafe=e}parse(e){const s=this.safeParse(e);if(!s.success)throw s.error;return s.data}safeParse(e){if("string"!=typeof e)return{success:!1,error:new a([r("invalid_type",[],t().expectedString)])};return(this.urlSafe?VldBase64.BASE64_URL_REGEX:VldBase64.BASE64_REGEX).test(e)?!this.urlSafe&&e.length>0&&e.length%4!=0?{success:!1,error:new a([r("custom",[],t().invalidBase64)])}:{success:!0,data:e}:{success:!1,error:new a([r("custom",[],t().invalidBase64)])}}urlSafeMode(){return new VldBase64(!0)}static create(e=!1){return new VldBase64(e)}}VldBase64.BASE64_REGEX=/^[A-Za-z0-9+/]*={0,2}$/,VldBase64.BASE64_URL_REGEX=/^[A-Za-z0-9_-]*={0,2}$/;export{VldBase64};

package/dist/validators/bigint.d.ts

@@ -31,6 +31,9 @@ export declare class VldBigInt extends VldBase<bigint, bigint> {
     protected constructor(config?: Partial<BigIntValidatorConfig>);
     get jsonSchema(): BigIntJSONSchemaHints | undefined;
     get isSimple(): boolean;
+    get minValue(): bigint | null;
+    get maxValue(): bigint | null;
+    get format(): string | null;
     /**
      * Create a new bigint validator
      */
@@ -94,5 +97,9 @@ export declare class VldBigInt extends VldBase<bigint, bigint> {
      * Zod 4 API parity - alias for max()
      */
     lte(value: bigint | number, message?: string): VldBigInt;
+    /**
+     * Create a new validator with multiple of constraint
+     */
+    multipleOf(divisor: bigint, message?: string): VldBigInt;
 }
 export {};

package/dist/validators/bigint.js

@@ -1,228 +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 createBigIntError(message) {
-    return new VldError([{ code: 'invalid_type', path: [], message }]);
-}
-/**
- * Immutable bigint validator
- */
-class VldBigInt extends VldBase {
-    /**
-     * Protected constructor to allow extension while maintaining immutability
-     */
-    constructor(config) {
-        super(config?.validatorType || VLD_VALIDATOR_TYPES.BIGINT);
-        this.config = {
-            checks: config?.checks || [],
-            errorMessage: config?.errorMessage,
-            jsonSchema: config?.jsonSchema
-        };
-        this._checks = this.config.checks;
-        this._fastCheckMode = this.detectFastCheckMode();
-    }
-    get jsonSchema() {
-        return this.config.jsonSchema;
-    }
-    get isSimple() {
-        return this._checks.length === 0;
-    }
-    /**
-     * Create a new bigint validator
-     */
-    static create() {
-        return new VldBigInt();
-    }
-    detectFastCheckMode() {
-        if (this._checks.length === 0) {
-            return 'none';
-        }
-        if (this._checks.length !== 1) {
-            return undefined;
-        }
-        const schema = this.config.jsonSchema;
-        if (schema?.exclusiveMinimum === 0n && schema.minimum === undefined && schema.maximum === undefined) {
-            return 'positive';
-        }
-        if (schema?.exclusiveMaximum === 0n && schema.minimum === undefined && schema.maximum === undefined) {
-            return 'negative';
-        }
-        if (schema?.minimum === 0n && schema.maximum === undefined && schema.exclusiveMaximum === undefined) {
-            return 'nonnegative';
-        }
-        if (schema?.maximum === 0n && schema.minimum === undefined && schema.exclusiveMinimum === undefined) {
-            return 'nonpositive';
-        }
-        return undefined;
-    }
-    getValidationError() {
-        return new Error(this.config.errorMessage || getMessages().invalidBigint);
-    }
-    /**
-     * Parse and validate a bigint value
-     */
-    parse(value) {
-        if (typeof value !== 'bigint') {
-            throw this.getValidationError();
-        }
-        return this.parseKnownBigInt(value);
-    }
-    /**
-     * Parse a value that has already passed the bigint type guard.
-     * @internal Used by object validators to avoid duplicate hot-path checks.
-     */
-    parseKnownBigInt(value) {
-        switch (this._fastCheckMode) {
-            case 'none':
-                return value;
-            case 'positive':
-                if (value > 0n)
-                    return value;
-                throw this.getValidationError();
-            case 'negative':
-                if (value < 0n)
-                    return value;
-                throw this.getValidationError();
-            case 'nonnegative':
-                if (value >= 0n)
-                    return value;
-                throw this.getValidationError();
-            case 'nonpositive':
-                if (value <= 0n)
-                    return value;
-                throw this.getValidationError();
-        }
-        // Apply all checks
-        for (const check of this._checks) {
-            if (!check(value)) {
-                throw this.getValidationError();
-            }
-        }
-        return value;
-    }
-    /**
-     * Safely parse and validate a bigint value
-     */
-    safeParse(value) {
-        if (typeof value !== 'bigint') {
-            return { success: false, error: createBigIntError(this.getValidationError().message) };
-        }
-        try {
-            return { success: true, data: this.parseKnownBigInt(value) };
-        }
-        catch (error) {
-            return { success: false, error: createBigIntError(error.message) };
-        }
-    }
-    /**
-     * Create a new validator with minimum value constraint
-     */
-    min(value, message) {
-        return new VldBigInt({
-            ...this.config,
-            checks: [...this.config.checks, (v) => v >= value],
-            errorMessage: message || `BigInt must be at least ${value}`,
-            jsonSchema: { ...this.config.jsonSchema, minimum: value }
-        });
-    }
-    /**
-     * Create a new validator with maximum value constraint
-     */
-    max(value, message) {
-        return new VldBigInt({
-            ...this.config,
-            checks: [...this.config.checks, (v) => v <= value],
-            errorMessage: message || `BigInt must be at most ${value}`,
-            jsonSchema: { ...this.config.jsonSchema, maximum: value }
-        });
-    }
-    /**
-     * Create a new validator that checks for positive values
-     */
-    positive(message) {
-        return new VldBigInt({
-            ...this.config,
-            checks: [...this.config.checks, (v) => v > 0n],
-            errorMessage: message || 'BigInt must be positive',
-            jsonSchema: { ...this.config.jsonSchema, exclusiveMinimum: 0n }
-        });
-    }
-    /**
-     * Create a new validator that checks for negative values
-     */
-    negative(message) {
-        return new VldBigInt({
-            ...this.config,
-            checks: [...this.config.checks, (v) => v < 0n],
-            errorMessage: message || 'BigInt must be negative',
-            jsonSchema: { ...this.config.jsonSchema, exclusiveMaximum: 0n }
-        });
-    }
-    /**
-     * Create a new validator that checks for non-negative values
-     */
-    nonnegative(message) {
-        return new VldBigInt({
-            ...this.config,
-            checks: [...this.config.checks, (v) => v >= 0n],
-            errorMessage: message || 'BigInt must be non-negative',
-            jsonSchema: { ...this.config.jsonSchema, minimum: 0n }
-        });
-    }
-    /**
-     * Create a new validator that checks for non-positive values
-     */
-    nonpositive(message) {
-        return new VldBigInt({
-            ...this.config,
-            checks: [...this.config.checks, (v) => v <= 0n],
-            errorMessage: message || 'BigInt must be non-positive',
-            jsonSchema: { ...this.config.jsonSchema, maximum: 0n }
-        });
-    }
-    /**
-     * Create a new validator with strict greater than constraint
-     * Zod 4 API parity - strictly greater than (not equal to)
-     */
-    gt(value, message) {
-        const compareValue = typeof value === 'bigint' ? value : BigInt(value);
-        return new VldBigInt({
-            ...this.config,
-            checks: [...this.config.checks, (v) => v > compareValue],
-            errorMessage: message || `BigInt must be greater than ${compareValue}`,
-            jsonSchema: { ...this.config.jsonSchema, exclusiveMinimum: compareValue }
-        });
-    }
-    /**
-     * Create a new validator with strict less than constraint
-     * Zod 4 API parity - strictly less than (not equal to)
-     */
-    lt(value, message) {
-        const compareValue = typeof value === 'bigint' ? value : BigInt(value);
-        return new VldBigInt({
-            ...this.config,
-            checks: [...this.config.checks, (v) => v < compareValue],
-            errorMessage: message || `BigInt must be less than ${compareValue}`,
-            jsonSchema: { ...this.config.jsonSchema, exclusiveMaximum: compareValue }
-        });
-    }
-    /**
-     * Create a new validator with greater than or equal constraint
-     * Zod 4 API parity - alias for min()
-     */
-    gte(value, message) {
-        const compareValue = typeof value === 'bigint' ? value : BigInt(value);
-        return this.min(compareValue, message);
-    }
-    /**
-     * Create a new validator with less than or equal constraint
-     * Zod 4 API parity - alias for max()
-     */
-    lte(value, message) {
-        const compareValue = typeof value === 'bigint' ? value : BigInt(value);
-        return this.max(compareValue, message);
-    }
-}
-
-export { VldBigInt };
+import{VldBase as e,VLD_VALIDATOR_TYPES as i}from"./base.js";import{getMessages as n}from"../locales/runtime.js";import{V as t}from"../chunks/errors-core-CerMg2rq.js";function s(e){return new t([{code:"invalid_type",path:[],message:e}])}class VldBigInt extends e{constructor(e){super(e?.validatorType||i.BIGINT),this.config={checks:e?.checks||[],errorMessage:e?.errorMessage,jsonSchema:e?.jsonSchema},this._checks=this.config.checks,this._fastCheckMode=this.detectFastCheckMode()}get jsonSchema(){return this.config.jsonSchema}get isSimple(){return 0===this._checks.length}get minValue(){return this.config.jsonSchema?.minimum?BigInt(this.config.jsonSchema.minimum):null}get maxValue(){return this.config.jsonSchema?.maximum?BigInt(this.config.jsonSchema.maximum):null}get format(){return this.config.jsonSchema?.format??null}static create(){return new VldBigInt}detectFastCheckMode(){if(0===this._checks.length)return"none";if(1!==this._checks.length)return;const e=this.config.jsonSchema;return 0n===e?.exclusiveMinimum&&void 0===e.minimum&&void 0===e.maximum?"positive":0n===e?.exclusiveMaximum&&void 0===e.minimum&&void 0===e.maximum?"negative":0n===e?.minimum&&void 0===e.maximum&&void 0===e.exclusiveMaximum?"nonnegative":0n===e?.maximum&&void 0===e.minimum&&void 0===e.exclusiveMinimum?"nonpositive":void 0}getValidationError(){return new Error(this.config.errorMessage||n().invalidBigint)}parse(e){if("bigint"!=typeof e)throw this.getValidationError();return this.parseKnownBigInt(e)}parseKnownBigInt(e){switch(this._fastCheckMode){case"none":return e;case"positive":if(e>0n)return e;throw this.getValidationError();case"negative":if(e<0n)return e;throw this.getValidationError();case"nonnegative":if(e>=0n)return e;throw this.getValidationError();case"nonpositive":if(e<=0n)return e;throw this.getValidationError()}for(const i of this._checks)if(!i(e))throw this.getValidationError();return e}safeParse(e){if("bigint"!=typeof e)return{success:!1,error:s(this.getValidationError().message)};try{return{success:!0,data:this.parseKnownBigInt(e)}}catch(e){return{success:!1,error:s(e.message)}}}min(e,i){return new VldBigInt({...this.config,checks:[...this.config.checks,i=>i>=e],errorMessage:i||`BigInt must be at least ${e}`,jsonSchema:{...this.config.jsonSchema,minimum:e}})}max(e,i){return new VldBigInt({...this.config,checks:[...this.config.checks,i=>i<=e],errorMessage:i||`BigInt must be at most ${e}`,jsonSchema:{...this.config.jsonSchema,maximum:e}})}positive(e){return new VldBigInt({...this.config,checks:[...this.config.checks,e=>e>0n],errorMessage:e||"BigInt must be positive",jsonSchema:{...this.config.jsonSchema,exclusiveMinimum:0n}})}negative(e){return new VldBigInt({...this.config,checks:[...this.config.checks,e=>e<0n],errorMessage:e||"BigInt must be negative",jsonSchema:{...this.config.jsonSchema,exclusiveMaximum:0n}})}nonnegative(e){return new VldBigInt({...this.config,checks:[...this.config.checks,e=>e>=0n],errorMessage:e||"BigInt must be non-negative",jsonSchema:{...this.config.jsonSchema,minimum:0n}})}nonpositive(e){return new VldBigInt({...this.config,checks:[...this.config.checks,e=>e<=0n],errorMessage:e||"BigInt must be non-positive",jsonSchema:{...this.config.jsonSchema,maximum:0n}})}gt(e,i){const n="bigint"==typeof e?e:BigInt(e);return new VldBigInt({...this.config,checks:[...this.config.checks,e=>e>n],errorMessage:i||`BigInt must be greater than ${n}`,jsonSchema:{...this.config.jsonSchema,exclusiveMinimum:n}})}lt(e,i){const n="bigint"==typeof e?e:BigInt(e);return new VldBigInt({...this.config,checks:[...this.config.checks,e=>e<n],errorMessage:i||`BigInt must be less than ${n}`,jsonSchema:{...this.config.jsonSchema,exclusiveMaximum:n}})}gte(e,i){const n="bigint"==typeof e?e:BigInt(e);return this.min(n,i)}lte(e,i){const n="bigint"==typeof e?e:BigInt(e);return this.max(n,i)}multipleOf(e,i){return new VldBigInt({...this.config,checks:[...this.config.checks,i=>i%e===0n],errorMessage:i||`BigInt must be a multiple of ${e}`,jsonSchema:{...this.config.jsonSchema,multipleOf:e}})}}export{VldBigInt};

package/dist/validators/boolean.js

@@ -1,142 +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 createBooleanError(message) {
-    return new VldError([{ code: 'invalid_boolean', path: [], message }]);
-}
-/**
- * Immutable boolean validator
- */
-class VldBoolean extends VldBase {
-    /**
-     * Protected constructor to allow extension while maintaining immutability
-     */
-    constructor(errorMessage, validatorType) {
-        super(validatorType || VLD_VALIDATOR_TYPES.BOOLEAN);
-        this.errorMessage = errorMessage;
-    }
-    /**
-     * Returns true if this is a simple boolean validator with no custom checks
-     * Used by VldObject for optimized fast-path dispatch
-     */
-    get isSimple() {
-        return true;
-    }
-    /**
-     * Create a new boolean validator
-     */
-    static create() {
-        return new VldBoolean();
-    }
-    /**
-     * Parse and validate a boolean value
-     */
-    parse(value) {
-        if (typeof value !== 'boolean') {
-            throw new Error(this.errorMessage || getMessages().invalidBoolean);
-        }
-        return value;
-    }
-    /**
-     * Parse a value that has already passed the boolean type guard.
-     * @internal Used by object validators to avoid duplicate hot-path checks.
-     */
-    parseKnownBoolean(value) {
-        return value;
-    }
-    /**
-     * Safely parse and validate a boolean value
-     */
-    safeParse(value) {
-        if (typeof value === 'boolean') {
-            return { success: true, data: value };
-        }
-        return {
-            success: false,
-            error: createBooleanError(this.errorMessage || getMessages().invalidBoolean)
-        };
-    }
-    /**
-     * Create a new validator that only accepts true
-     */
-    true(message) {
-        return new VldTrue(message || 'Value must be true');
-    }
-    /**
-     * Create a new validator that only accepts false
-     */
-    false(message) {
-        return new VldFalse(message || 'Value must be false');
-    }
-}
-/**
- * Validator that only accepts true
- */
-class VldTrue extends VldBoolean {
-    constructor(message) {
-        super(message);
-        this.message = message;
-    }
-    get isSimple() {
-        return false;
-    }
-    parse(value) {
-        if (value !== true) {
-            throw new Error(this.message);
-        }
-        return true;
-    }
-    parseKnownBoolean(value) {
-        if (value !== true) {
-            throw new Error(this.message);
-        }
-        return true;
-    }
-    // BUG-003 FIX: Override safeParse to ensure true validation
-    safeParse(value) {
-        if (value !== true) {
-            return {
-                success: false,
-                error: createBooleanError(this.message)
-            };
-        }
-        return { success: true, data: true };
-    }
-}
-/**
- * Validator that only accepts false
- */
-class VldFalse extends VldBoolean {
-    constructor(message) {
-        super(message);
-        this.message = message;
-    }
-    get isSimple() {
-        return false;
-    }
-    parse(value) {
-        if (value !== false) {
-            throw new Error(this.message);
-        }
-        return false;
-    }
-    parseKnownBoolean(value) {
-        if (value !== false) {
-            throw new Error(this.message);
-        }
-        return false;
-    }
-    // BUG-003 FIX: Override safeParse to ensure false validation
-    safeParse(value) {
-        if (value !== false) {
-            return {
-                success: false,
-                error: createBooleanError(this.message)
-            };
-        }
-        return { success: true, data: false };
-    }
-}
-
-export { VldBoolean };
+import{VldBase as e,VLD_VALIDATOR_TYPES as s}from"./base.js";import{V as r,c as t,g as a}from"../chunks/errors-core-CerMg2rq.js";class VldBoolean extends e{constructor(e,r){super(r||s.BOOLEAN),this.errorMessage=e}get isSimple(){return!0}static create(){return new VldBoolean}parse(e){if("boolean"!=typeof e)throw new r([t("boolean",a(e),this.errorMessage)]);return e}parseKnownBoolean(e){return e}safeParse(e){return"boolean"==typeof e?{success:!0,data:e}:{success:!1,error:new r([t("boolean",a(e),this.errorMessage)])}}true(e){return new VldTrue(e||"Value must be true")}false(e){return new VldFalse(e||"Value must be false")}}class VldTrue extends VldBoolean{constructor(e){super(e),this.message=e}get isSimple(){return!1}parse(e){if(!0!==e)throw new r([{code:"custom",path:[],message:this.message}]);return!0}parseKnownBoolean(e){if(!0!==e)throw new r([{code:"custom",path:[],message:this.message}]);return!0}safeParse(e){return!0!==e?{success:!1,error:new r([{code:"custom",path:[],message:this.message}])}:{success:!0,data:!0}}}class VldFalse extends VldBoolean{constructor(e){super(e),this.message=e}get isSimple(){return!1}parse(e){if(!1!==e)throw new r([{code:"custom",path:[],message:this.message}]);return!1}parseKnownBoolean(e){if(!1!==e)throw new r([{code:"custom",path:[],message:this.message}]);return!1}safeParse(e){return!1!==e?{success:!1,error:new r([{code:"custom",path:[],message:this.message}])}:{success:!0,data:!1}}}export{VldBoolean};

package/dist/validators/codec.js

@@ -1,200 +1 @@
-import { VldBase, VLD_VALIDATOR_TYPES } from './base.js';
-import { createIssue } from '../errors.js';
-import { getMessages } from '../locales/runtime.js';
-import { V as VldError } from '../chunks/errors-core-BeiFUtZM.js';
-
-/**
- * Codec validator for bidirectional transformations
- * Enables converting between different data representations
- */
-class VldCodec extends VldBase {
-    constructor(inputValidator, outputValidator, codecTransform) {
-        super(VLD_VALIDATOR_TYPES.CODEC);
-        this.inputValidator = inputValidator;
-        this.outputValidator = outputValidator;
-        this.codecTransform = codecTransform;
-    }
-    /**
-     * Parse (decode) a value from input to output format
-     */
-    parse(value) {
-        const result = this.safeParse(value);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
-    }
-    /**
-     * Safely parse (decode) a value from input to output format
-     */
-    safeParse(value) {
-        // First validate the input
-        const inputResult = this.inputValidator.safeParse(value);
-        if (!inputResult.success) {
-            return { success: false, error: inputResult.error };
-        }
-        try {
-            // Then decode to output
-            const decoded = this.codecTransform.decode(inputResult.data);
-            // Handle async decode
-            if (decoded instanceof Promise) {
-                throw new VldError([
-                    createIssue('custom', [], getMessages().codecAsyncNotSupported)
-                ]);
-            }
-            // Validate the decoded output
-            return this.outputValidator.safeParse(decoded);
-        }
-        catch (error) {
-            if (error instanceof VldError) {
-                return { success: false, error };
-            }
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().codecDecodeFailed)
-                ])
-            };
-        }
-    }
-    /**
-     * Create a new codec with input and output directions swapped.
-     */
-    invert() {
-        return new VldCodec(this.outputValidator, this.inputValidator, {
-            decode: this.codecTransform.encode,
-            encode: this.codecTransform.decode
-        });
-    }
-    /**
-     * Encode a value from output back to input format
-     */
-    encode(value) {
-        const result = this.safeEncode(value);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
-    }
-    /**
-     * Safely encode a value from output back to input format
-     */
-    safeEncode(value) {
-        // First validate the output
-        const outputResult = this.outputValidator.safeParse(value);
-        if (!outputResult.success) {
-            return { success: false, error: outputResult.error };
-        }
-        try {
-            // Then encode to input
-            const encoded = this.codecTransform.encode(outputResult.data);
-            // Handle async encode
-            if (encoded instanceof Promise) {
-                throw new VldError([
-                    createIssue('custom', [], getMessages().codecAsyncNotSupported)
-                ]);
-            }
-            // Validate the encoded input
-            return this.inputValidator.safeParse(encoded);
-        }
-        catch (error) {
-            if (error instanceof VldError) {
-                return { success: false, error };
-            }
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().codecEncodeFailed)
-                ])
-            };
-        }
-    }
-    /**
-     * Async version of parse (decode)
-     */
-    async parseAsync(value) {
-        const result = await this.safeParseAsync(value);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
-    }
-    /**
-     * Async version of safeParse (decode)
-     */
-    async safeParseAsync(value) {
-        // First validate the input
-        const inputResult = this.inputValidator.safeParse(value);
-        if (!inputResult.success) {
-            return { success: false, error: inputResult.error };
-        }
-        try {
-            // Then decode to output (supports async)
-            const decoded = await this.codecTransform.decode(inputResult.data);
-            // Validate the decoded output
-            return this.outputValidator.safeParse(decoded);
-        }
-        catch (error) {
-            if (error instanceof VldError) {
-                return { success: false, error };
-            }
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().codecDecodeFailed)
-                ])
-            };
-        }
-    }
-    /**
-     * Async version of encode
-     */
-    async encodeAsync(value) {
-        const result = await this.safeEncodeAsync(value);
-        if (!result.success) {
-            throw result.error;
-        }
-        return result.data;
-    }
-    /**
-     * Async version of safeEncode
-     */
-    async safeEncodeAsync(value) {
-        // First validate the output
-        const outputResult = this.outputValidator.safeParse(value);
-        if (!outputResult.success) {
-            return { success: false, error: outputResult.error };
-        }
-        try {
-            // Then encode to input (supports async)
-            const encoded = await this.codecTransform.encode(outputResult.data);
-            // Validate the encoded input
-            return this.inputValidator.safeParse(encoded);
-        }
-        catch (error) {
-            if (error instanceof VldError) {
-                return { success: false, error };
-            }
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().codecEncodeFailed)
-                ])
-            };
-        }
-    }
-    /**
-     * Create a codec validator
-     */
-    static create(inputValidator, outputValidator, codecTransform) {
-        return new VldCodec(inputValidator, outputValidator, codecTransform);
-    }
-    /**
-     * Create a codec with input and output directions swapped.
-     */
-    static invert(codec) {
-        return codec.invert();
-    }
-}
-
-export { VldCodec };
+import{VldBase as r,VLD_VALIDATOR_TYPES as s}from"./base.js";import{createIssue as e}from"../errors.js";import{getMessages as t}from"../locales/runtime.js";import{V as c}from"../chunks/errors-core-CerMg2rq.js";class VldCodec extends r{constructor(r,e,t){super(s.CODEC),this.inputValidator=r,this.outputValidator=e,this.codecTransform=t}parse(r){const s=this.safeParse(r);if(!s.success)throw s.error;return s.data}safeParse(r){const s=this.inputValidator.safeParse(r);if(!s.success)return{success:!1,error:s.error};try{const r=this.codecTransform.decode(s.data);if(r instanceof Promise)throw new c([e("custom",[],t().codecAsyncNotSupported)]);return this.outputValidator.safeParse(r)}catch(r){return r instanceof c?{success:!1,error:r}:{success:!1,error:new c([e("custom",[],t().codecDecodeFailed)])}}}invert(){return new VldCodec(this.outputValidator,this.inputValidator,{decode:this.codecTransform.encode,encode:this.codecTransform.decode})}encode(r){const s=this.safeEncode(r);if(!s.success)throw s.error;return s.data}safeEncode(r){const s=this.outputValidator.safeParse(r);if(!s.success)return{success:!1,error:s.error};try{const r=this.codecTransform.encode(s.data);if(r instanceof Promise)throw new c([e("custom",[],t().codecAsyncNotSupported)]);return this.inputValidator.safeParse(r)}catch(r){return r instanceof c?{success:!1,error:r}:{success:!1,error:new c([e("custom",[],t().codecEncodeFailed)])}}}async parseAsync(r){const s=await this.safeParseAsync(r);if(!s.success)throw s.error;return s.data}async safeParseAsync(r){const s=this.inputValidator.safeParse(r);if(!s.success)return{success:!1,error:s.error};try{const r=await this.codecTransform.decode(s.data);return this.outputValidator.safeParse(r)}catch(r){return r instanceof c?{success:!1,error:r}:{success:!1,error:new c([e("custom",[],t().codecDecodeFailed)])}}}async encodeAsync(r){const s=await this.safeEncodeAsync(r);if(!s.success)throw s.error;return s.data}async safeEncodeAsync(r){const s=this.outputValidator.safeParse(r);if(!s.success)return{success:!1,error:s.error};try{const r=await this.codecTransform.encode(s.data);return this.inputValidator.safeParse(r)}catch(r){return r instanceof c?{success:!1,error:r}:{success:!1,error:new c([e("custom",[],t().codecEncodeFailed)])}}}static create(r,s,e){return new VldCodec(r,s,e)}static invert(r){return r.invert()}}export{VldCodec};