@oxog/vld 2.0.3 → 2.1.0

package/dist/validators/index.d.ts

@@ -1,45 +1,44 @@
 /**
  * Main entry point for all validators
  */
-export { VldBase, ParseResult, VldRefine, VldTransform, VldDefault, VldCatch, VldOptional, VldExactOptional, VldNullable, VldNullish, VldPipe, VldReadonly, VldBrand, SuperRefineContext, VldSuperRefine, VldPreprocess } from './base';
-export { VldString } from './string';
-export { VldNumber } from './number';
-export { VldBoolean } from './boolean';
-export { VldDate } from './date';
-export { VldStringBool } from './string-bool';
-export { VldArray } from './array';
-export { VldObject } from './object';
-export { VldUnion } from './union';
-export { VldIntersection } from './intersection';
-export { VldLiteral } from './literal';
-export { VldEnum } from './enum';
-export { VldTuple } from './tuple';
-export { VldRecord } from './record';
-export { VldSet } from './set';
-export { VldMap } from './map';
-export { VldBigInt } from './bigint';
-export { VldSymbol } from './symbol';
-export { VldAny } from './any';
-export { VldUnknown } from './unknown';
-export { VldVoid } from './void';
-export { VldNever } from './never';
-export { VldNull } from './null';
-export { VldUndefined } from './undefined';
-export { VldNan } from './nan';
-export { VldLazy } from './lazy';
-export { VldDiscriminatedUnion } from './discriminated-union';
-export { VldXor } from './xor';
-export { VldJson } from './json';
-export { VldTemplateLiteral, templateLiteral } from './template-literal';
-export { VldCustom, custom } from './custom';
-export type { CustomValidatorOptions } from './custom';
-export { VldFile, file } from './file';
-export type { VldFileValue } from './file';
-export { VldFunction, functionValidator } from './function';
-export { VldPromise, promise } from './promise';
-export { email, uuid, uuidv4, hostname, emoji, base64, base64url, hex, jwt, nanoid, cuid, cuid2, ulid, ipv4, ipv6, mac, cidrv4, cidrv6, e164, hash, iso, stringFormat, regexes, xid, guid, httpUrl } from './string-formats';
-import { VldBase } from './base';
+export { VldBase, ParseResult, VldRefine, VldTransform, VldDefault, VldCatch, VldOptional, VldExactOptional, VldNullable, VldNullish, VldPipe, VldReadonly, VldBrand, SuperRefineContext, VldSuperRefine, VldPreprocess } from './base.js';
+export { VldString } from './string.js';
+export { VldNumber } from './number.js';
+export { VldBoolean } from './boolean.js';
+export { VldDate } from './date.js';
+export { VldStringBool } from './string-bool.js';
+export { VldArray } from './array.js';
+export { VldObject } from './object.js';
+export { VldUnion } from './union.js';
+export { VldIntersection } from './intersection.js';
+export { VldLiteral } from './literal.js';
+export { VldEnum } from './enum.js';
+export { VldTuple } from './tuple.js';
+export { VldRecord } from './record.js';
+export { VldSet } from './set.js';
+export { VldMap } from './map.js';
+export { VldBigInt } from './bigint.js';
+export { VldSymbol } from './symbol.js';
+export { VldAny } from './any.js';
+export { VldUnknown } from './unknown.js';
+export { VldVoid } from './void.js';
+export { VldNever } from './never.js';
+export { VldNull } from './null.js';
+export { VldUndefined } from './undefined.js';
+export { VldNan } from './nan.js';
+export { VldLazy } from './lazy.js';
+export { VldDiscriminatedUnion } from './discriminated-union.js';
+export { VldXor } from './xor.js';
+export { VldJson } from './json.js';
+export { VldTemplateLiteral, templateLiteral } from './template-literal.js';
+export { VldCustom, custom } from './custom.js';
+export type { CustomValidatorOptions } from './custom.js';
+export { VldFile, file } from './file.js';
+export type { VldFileValue } from './file.js';
+export { VldFunction, functionValidator } from './function.js';
+export { VldPromise, promise } from './promise.js';
+export { email, uuid, uuidv4, hostname, emoji, base64, base64url, hex, jwt, nanoid, cuid, cuid2, ulid, ipv4, ipv6, mac, cidrv4, cidrv6, e164, hash, iso, stringFormat, regexes, xid, guid, httpUrl } from './string-formats.js';
+import { VldBase } from './base.js';
 export type Infer<T extends VldBase<any, any>> = T extends VldBase<any, infer U> ? U : never;
 export type Input<T extends VldBase<any, any>> = T extends VldBase<infer I, any> ? I : never;
 export type Output<T extends VldBase<any, any>> = T extends VldBase<any, infer O> ? O : never;
-//# sourceMappingURL=index.d.ts.map

package/dist/validators/index.js

@@ -1,515 +1,35 @@
-import { i as VldBase, u as getMessages, h as VldString } from '../chunks/bigint-CRS0QVsy.js';
-export { V as VldBigInt, a as VldBoolean, j as VldBrand, k as VldCatch, b as VldDate, l as VldDefault, r as VldExactOptional, d as VldNullable, e as VldNullish, c as VldNumber, f as VldOptional, m as VldPipe, g as VldPreprocess, n as VldReadonly, o as VldRefine, p as VldSuperRefine, q as VldTransform } from '../chunks/bigint-CRS0QVsy.js';
-export { a as VldAny, b as VldArray, c as VldDiscriminatedUnion, d as VldEnum, e as VldIntersection, f as VldJson, g as VldLazy, h as VldLiteral, k as VldMap, l as VldNan, V as VldNever, m as VldNull, i as VldObject, j as VldRecord, n as VldSet, o as VldStringBool, p as VldSymbol, q as VldTuple, r as VldUndefined, s as VldUnion, t as VldVoid, u as VldXor } from '../chunks/json-Cp4WO0M9.js';
-export { V as VldUnknown } from '../chunks/unknown-Dhzri_T-.js';
-
-/**
- * Immutable template literal validator
- * Validates strings matching a template pattern
- */
-class VldTemplateLiteral extends VldBase {
-    constructor(pattern) {
-        super();
-        this.pattern = pattern;
-    }
-    /**
-     * Create a template literal validator from components
-     */
-    static create(...components) {
-        // Build regex pattern from components
-        let pattern = '^';
-        for (const comp of components) {
-            if (typeof comp === 'string') {
-                // Escape special regex characters
-                pattern += comp.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            }
-            else {
-                // Add appropriate pattern based on validator type
-                pattern += getPatternForValidator(comp);
-            }
-        }
-        pattern += '$';
-        return new VldTemplateLiteral(new RegExp(pattern));
-    }
-    /**
-     * Parse and validate a template literal string
-     */
-    parse(value) {
-        if (typeof value !== 'string') {
-            throw new Error(getMessages().invalidString);
-        }
-        if (!this.pattern.test(value)) {
-            throw new Error(getMessages().stringPatternInvalid);
-        }
-        return value;
-    }
-    /**
-     * Safely parse and validate a template literal string
-     */
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error
-            };
-        }
-    }
-}
-/**
- * Get regex pattern for a validator type
- */
-function getPatternForValidator(validator) {
-    // For template literals, we need to identify the validator type
-    // and return an appropriate capture group pattern
-    const className = validator.constructor.name;
-    // Check for specific validator types
-    if (className === 'VldString') {
-        return '(.+)';
-    }
-    if (className === 'VldNumber' || className === 'VldInt') {
-        return '(-?\\d+(?:\\.\\d+)?)';
-    }
-    if (className === 'VldBigInt') {
-        return '(-?\\d+)';
-    }
-    if (className === 'VldBoolean') {
-        return '(true|false)';
-    }
-    if (className === 'VldNull') {
-        return '(null)';
-    }
-    if (className === 'VldUndefined' || className === 'VldVoid') {
-        return '(undefined)';
-    }
-    if (className === 'VldLiteral') {
-        // Extract literal value - access private literal property via any
-        const literalValidator = validator;
-        if (literalValidator.literal !== undefined) {
-            const valueStr = String(literalValidator.literal);
-            return '(' + valueStr.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') + ')';
-        }
-    }
-    // Default: match any string
-    return '(.+)';
-}
-/**
- * Helper function to create template literal validators
- * Usage: v.templateLiteral(v.string(), '-', v.number())
- */
-function templateLiteral(...components) {
-    return VldTemplateLiteral.create(...components);
-}
-
-/**
- * Immutable custom validator for user-defined validation logic
- * Provides type safety while allowing complete control over validation
- */
-class VldCustom extends VldBase {
-    constructor(options) {
-        super();
-        this._parseFn = options.parse;
-        this._safeParseFn = options.safeParse || ((value) => {
-            try {
-                return { success: true, data: this._parseFn(value) };
-            }
-            catch (error) {
-                return { success: false, error: error };
-            }
-        });
-    }
-    /**
-     * Create a new custom validator
-     */
-    static create(options) {
-        return new VldCustom(options);
-    }
-    /**
-     * Parse and validate using the custom parse function
-     */
-    parse(value) {
-        return this._parseFn(value);
-    }
-    /**
-     * Safely parse using the custom safeParse function or default implementation
-     */
-    safeParse(value) {
-        return this._safeParseFn(value);
-    }
-}
-/**
- * Helper function to create custom validators
- * Usage: v.custom<number>({
- *   parse: (value) => {
- *     if (typeof value !== 'string') throw new Error('Expected string');
- *     return parseInt(value, 10);
- *   }
- * })
- */
-function custom(options) {
-    return VldCustom.create(options);
-}
-
-/**
- * Immutable file validator for file uploads
- * Supports size and MIME type validation
- */
-class VldFile extends VldBase {
-    constructor(checks = []) {
-        super();
-        this.checks = checks;
-    }
-    /**
-     * Create a new file validator
-     */
-    static create() {
-        return new VldFile();
-    }
-    /**
-     * Parse and validate a file value
-     */
-    parse(value) {
-        // Check if File API is supported
-        const FileSupported = typeof File !== 'undefined';
-        if (!FileSupported) {
-            throw new Error(getMessages().fileNotSupported || 'File API not supported in this environment');
-        }
-        // Check if value is a File object
-        if (!(value instanceof File)) {
-            // Allow plain object with size and type for Node.js compatibility
-            if (typeof value === 'object' &&
-                value !== null &&
-                'size' in value &&
-                'type' in value) {
-                const fileObj = value;
-                return this.runChecks(fileObj);
-            }
-            throw new Error(getMessages().invalidFile || 'Expected a File object');
-        }
-        return this.runChecks(value);
-    }
-    /**
-     * Run all validation checks on the file
-     */
-    runChecks(file) {
-        const msgs = getMessages();
-        for (const check of this.checks) {
-            switch (check.type) {
-                case 'min':
-                    if (file.size < check.value) {
-                        throw new Error(check.message ||
-                            (msgs.fileMinSize?.(check.value) || `File size must be at least ${check.value} bytes`));
-                    }
-                    break;
-                case 'max':
-                    if (file.size > check.value) {
-                        throw new Error(check.message ||
-                            (msgs.fileMaxSize?.(check.value) || `File size must not exceed ${check.value} bytes`));
-                    }
-                    break;
-                case 'mime':
-                    if (!check.value.includes(file.type)) {
-                        throw new Error(check.message ||
-                            (msgs.fileMimeType?.(check.value) || `Invalid file type. Expected: ${check.value.join(', ')}`));
-                    }
-                    break;
-            }
-        }
-        return file;
-    }
-    /**
-     * Safely parse and validate a file value
-     */
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-    /**
-     * Set minimum file size in bytes
-     */
-    min(bytes, message) {
-        return new VldFile([...this.checks, { type: 'min', value: bytes, message }]);
-    }
-    /**
-     * Set maximum file size in bytes
-     */
-    max(bytes, message) {
-        return new VldFile([...this.checks, { type: 'max', value: bytes, message }]);
-    }
-    /**
-     * Set allowed MIME types
-     */
-    mime(types, message) {
-        const typeArray = Array.isArray(types) ? types : [types];
-        return new VldFile([...this.checks, { type: 'mime', value: typeArray, message }]);
-    }
-    /**
-     * Set both minimum and maximum file size
-     */
-    size(min, max, message) {
-        return this.min(min, message).max(max, message);
-    }
-}
-/**
- * Helper function to create file validators
- * Usage: v.file().min(1024).max(10485760).mime(['image/jpeg', 'image/png'])
- */
-function file() {
-    return VldFile.create();
-}
-
-/**
- * Immutable function validator
- * Validates that a value is a function
- */
-class VldFunction extends VldBase {
-    constructor() {
-        super();
-    }
-    /**
-     * Create a new function validator
-     */
-    static create() {
-        return new VldFunction();
-    }
-    /**
-     * Parse and validate a function value
-     */
-    parse(value) {
-        if (typeof value !== 'function') {
-            throw new Error(getMessages().invalidFunction || 'Expected a function');
-        }
-        return value;
-    }
-    /**
-     * Safely parse and validate a function value
-     */
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-/**
- * Helper function to create function validators
- * Usage: v.function()
- */
-function functionValidator() {
-    return VldFunction.create();
-}
-
-/**
- * Promise validator - validates Promise values
- * Validates that the resolved value matches the inner schema
- */
-/**
- * Promise validator - validates Promise<T> where T matches inner schema
- * Zod 4 API parity - allows async validation with proper type inference
- *
- * Validates that the input is a Promise, and validates the resolved value
- * against the inner schema when parsed.
- *
- * Use parseAsync() or safeParseAsync() for proper async handling.
- */
-class VldPromise {
-    constructor(inner) {
-        this.inner = inner;
-    }
-    /**
-     * Check if value is thenable (Promise-like)
-     * Must be called BEFORE wrapping in Promise.resolve
-     */
-    _isThenable(value) {
-        return value !== null && typeof value.then === 'function';
-    }
-    /**
-     * Parse and validate a Promise value asynchronously
-     * @param value The Promise to validate
-     * @returns The validated value
-     * @throws {Error} If validation fails when Promise resolves
-     */
-    async parse(value) {
-        // Check if value is thenable BEFORE wrapping in Promise.resolve
-        if (!this._isThenable(value)) {
-            throw new Error('Expected a Promise value');
-        }
-        // Now we can safely await it
-        const resolved = await Promise.resolve(value);
-        return this.inner.parse(resolved);
-    }
-    /**
-     * Safely parse and validate a Promise value asynchronously
-     * @param value The Promise to validate
-     * @returns A Promise resolving to ParseResult containing the validated value
-     */
-    async safeParse(value) {
-        // Check if value is thenable BEFORE wrapping in Promise.resolve
-        if (!this._isThenable(value)) {
-            return {
-                success: false,
-                error: new Error('Expected a Promise value')
-            };
-        }
-        try {
-            const resolved = await Promise.resolve(value);
-            const validated = this.inner.parse(resolved);
-            return {
-                success: true,
-                data: validated
-            };
-        }
-        catch (err) {
-            return {
-                success: false,
-                error: err instanceof Error ? err : new Error(String(err))
-            };
-        }
-    }
-}
-/**
- * Create a Promise validator
- * @param inner The schema to validate the resolved value against
- * @returns A new Promise validator
- * @example
- * const promiseSchema = v.promise(v.string());
- * const result = await promiseSchema.parse(Promise.resolve("hello"));
- * // result is string
- */
-function promise(inner) {
-    return new VldPromise(inner);
-}
-
-/**
- * Top-level string format validators
- * Part of Zod 4 API parity implementation
- * Provides convenient validators for common string formats
- */
-/**
- * Pre-compiled regex patterns for performance
- */
-const REGEXES = {
-    email: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
-    uuid: /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
-    uuidv4: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
-    uuidv6: /^[0-9a-f]{8}-[0-9a-f]{4}-6[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
-    uuidv7: /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
-    hostname: /^(?=.{1,253}$)(?:(?!-)[a-zA-Z0-9-]{1,63}(?<!-)\.)+[a-zA-Z]{2,63}$/,
-    emoji: /^(?:\p{Emoji_Presentation}|\p{Emoji}\uFE0F)(?:\u200D(?:\p{Emoji_Presentation}|\p{Emoji}\uFE0F))*$/u,
-    base64: /^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=)?$/,
-    base64url: /^[A-Za-z0-9_-]*$/,
-    hex: /^[0-9a-fA-F]*$/,
-    jwt: /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*$/,
-    nanoid: /^[A-Za-z0-9_-]{21}$/,
-    cuid: /^c[^\s-]{8,}$/i,
-    cuid2: /^[0-9a-z]+$/,
-    ulid: /^[0-9A-HJKMNP-TV-Z]{26}$/,
-    ipv4: /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/,
-    ipv6: /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/,
-    mac: /^([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$/,
-    cidrv4: /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\/(?:3[0-2]|[12]?[0-9])$/,
-    cidrv6: /^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}\/(?:12[0-8]|1[01][0-9]|[1-9]?[0-9])$|^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}\/(?:12[0-8]|1[01][0-9]|[1-9]?[0-9])$|^(?:[0-9a-fA-F]{1,4}:){1,7}:\/(?:12[0-8]|1[01][0-9]|[1-9]?[0-9])$/,
-    e164: /^\+[1-9]\d{1,14}$/,
-    isoDate: /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])$/,
-    isoTime: /^(?:[01]\d|2[0-3]):[0-5]\d(?::[0-5]\d(?:\.\d+)?)?$/,
-    isoDateTime: /^\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])T(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d(?:\.\d+)?Z?$/,
-    md5: /^[a-f0-9]{32}$/i,
-    sha1: /^[a-f0-9]{40}$/i,
-    sha256: /^[a-f0-9]{64}$/i,
-    sha384: /^[a-f0-9]{96}$/i,
-    sha512: /^[a-f0-9]{128}$/i,
-    // Additional formats (Zod v4 parity)
-    xid: /^[A-HJKMNP-TV-Z0-9]{20}$/, // ksort's XID format
-    guid: /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/i, // Alias for UUID
-    httpUrl: /^https?:\/\/[^\s/$.?#].[^\s]*$/, // HTTP/HTTPS URL
-};
-/**
- * Generic string format validator
- */
-class VldStringFormat extends VldBase {
-    constructor(_format, _validator, _errorMessage) {
-        super();
-        this._format = _format;
-        this._validator = _validator;
-        this._errorMessage = _errorMessage;
-    }
-    static create(format, validator, errorMessage) {
-        return new VldStringFormat(format, validator, errorMessage);
-    }
-    parse(value) {
-        const result = VldString.create().parse(value);
-        if (!this._validator(result)) {
-            throw new Error(this._errorMessage || `Invalid ${this._format} format`);
-        }
-        return result;
-    }
-    safeParse(value) {
-        const stringResult = VldString.create().safeParse(value);
-        if (!stringResult.success) {
-            return stringResult;
-        }
-        if (!this._validator(stringResult.data)) {
-            return {
-                success: false,
-                error: new Error(this._errorMessage || `Invalid ${this._format} format`)
-            };
-        }
-        return { success: true, data: stringResult.data };
-    }
-}
-/**
- * Top-level string format validators
- */
-const email = (options) => VldStringFormat.create('email', (val) => (options?.pattern ?? REGEXES.email).test(val));
-const uuid = (options) => {
-    const pattern = options?.version ? REGEXES[`uuid${options.version}`] : REGEXES.uuid;
-    return VldStringFormat.create('uuid', (val) => pattern.test(val));
-};
-const uuidv4 = () => VldStringFormat.create('uuid', (val) => REGEXES.uuidv4.test(val));
-const hostname = () => VldStringFormat.create('hostname', (val) => REGEXES.hostname.test(val));
-const emoji = () => VldStringFormat.create('emoji', (val) => REGEXES.emoji.test(val));
-const base64 = () => VldStringFormat.create('base64', (val) => REGEXES.base64.test(val));
-const base64url = () => VldStringFormat.create('base64url', (val) => REGEXES.base64url.test(val));
-const hex = () => VldStringFormat.create('hex', (val) => REGEXES.hex.test(val));
-const jwt = () => VldStringFormat.create('jwt', (val) => REGEXES.jwt.test(val));
-const nanoid = () => VldStringFormat.create('nanoid', (val) => REGEXES.nanoid.test(val));
-const cuid = () => VldStringFormat.create('cuid', (val) => REGEXES.cuid.test(val));
-const cuid2 = () => VldStringFormat.create('cuid2', (val) => REGEXES.cuid2.test(val));
-const ulid = () => VldStringFormat.create('ulid', (val) => REGEXES.ulid.test(val));
-const ipv4 = () => VldStringFormat.create('ipv4', (val) => REGEXES.ipv4.test(val));
-const ipv6 = () => VldStringFormat.create('ipv6', (val) => REGEXES.ipv6.test(val));
-const mac = () => VldStringFormat.create('mac', (val) => REGEXES.mac.test(val));
-const cidrv4 = () => VldStringFormat.create('cidrv4', (val) => REGEXES.cidrv4.test(val));
-const cidrv6 = () => VldStringFormat.create('cidrv6', (val) => REGEXES.cidrv6.test(val));
-const e164 = () => VldStringFormat.create('e164', (val) => REGEXES.e164.test(val));
-const xid = () => VldStringFormat.create('xid', (val) => REGEXES.xid.test(val));
-const guid = () => VldStringFormat.create('guid', (val) => REGEXES.guid.test(val));
-const httpUrl = () => VldStringFormat.create('httpUrl', (val) => REGEXES.httpUrl.test(val));
-const hash = (algorithm) => VldStringFormat.create('hash', (val) => REGEXES[algorithm]?.test(val) ?? false, `Invalid ${algorithm} hash`);
-/**
- * ISO date/time validators
- */
-const iso = {
-    date: () => VldStringFormat.create('date', (val) => REGEXES.isoDate.test(val)),
-    time: () => VldStringFormat.create('time', (val) => REGEXES.isoTime.test(val)),
-    dateTime: (_options) => VldStringFormat.create('datetime', (val) => REGEXES.isoDateTime.test(val)),
-    duration: () => VldStringFormat.create('duration', (val) => /^P/.test(val)),
-};
-/**
- * Custom format validator
- */
-const stringFormat = (name, validator) => {
-    const fn = validator instanceof RegExp ? (val) => validator.test(val) : validator;
-    return VldStringFormat.create(name, fn);
-};
-
-export { VldBase, VldCustom, VldFile, VldFunction, VldPromise, VldString, VldTemplateLiteral, base64, base64url, cidrv4, cidrv6, cuid, cuid2, custom, e164, email, emoji, file, functionValidator, guid, hash, hex, hostname, httpUrl, ipv4, ipv6, iso, jwt, mac, nanoid, promise, REGEXES as regexes, stringFormat, templateLiteral, ulid, uuid, uuidv4, xid };
-//# sourceMappingURL=index.js.map
+export { VldBase, VldBrand, VldCatch, VldDefault, VldExactOptional, VldNullable, VldNullish, VldOptional, VldPipe, VldPreprocess, VldReadonly, VldRefine, VldSuperRefine, VldTransform } from './base.js';
+export { V as VldString } from '../chunks/string-BJRQod3t.js';
+export { VldNumber } from './number.js';
+export { VldBoolean } from './boolean.js';
+export { VldDate } from './date.js';
+export { VldStringBool } from './string-bool.js';
+export { VldArray } from './array.js';
+export { VldObject } from './object.js';
+export { VldUnion } from './union.js';
+export { VldIntersection } from './intersection.js';
+export { VldLiteral } from './literal.js';
+export { VldEnum } from './enum.js';
+export { VldTuple } from './tuple.js';
+export { VldRecord } from './record.js';
+export { VldSet } from './set.js';
+export { VldMap } from './map.js';
+export { VldBigInt } from './bigint.js';
+export { VldSymbol } from './symbol.js';
+export { VldAny } from './any.js';
+export { VldUnknown } from './unknown.js';
+export { VldVoid } from './void.js';
+export { VldNever } from './never.js';
+export { VldNull } from './null.js';
+export { VldUndefined } from './undefined.js';
+export { VldNan } from './nan.js';
+export { VldLazy } from './lazy.js';
+export { VldDiscriminatedUnion } from './discriminated-union.js';
+export { VldXor } from './xor.js';
+export { VldJson } from './json.js';
+export { VldTemplateLiteral, templateLiteral } from './template-literal.js';
+export { VldCustom, custom } from './custom.js';
+export { VldFile, file } from './file.js';
+export { VldFunction, functionValidator } from './function.js';
+export { VldPromise, promise } from './promise.js';
+export { base64, base64url, cidrv4, cidrv6, cuid, cuid2, e164, email, emoji, guid, hash, hex, hostname, httpUrl, ipv4, ipv6, iso, jwt, mac, nanoid, regexes, stringFormat, ulid, uuid, uuidv4, xid } from './string-formats.js';

package/dist/validators/intersection.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Immutable intersection validator for combining validators
  */
@@ -22,4 +22,3 @@ export declare class VldIntersection<A, B> extends VldBase<unknown, A & B> {
      */
     safeParse(value: unknown): ParseResult<A & B>;
 }
-//# sourceMappingURL=intersection.d.ts.map