@oxog/vld 2.0.3 → 2.2.5

package/dist/validators/index.js

@@ -1,515 +1 @@
-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{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{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,ksuid,mac,nanoid,regexes,stringFormat,ulid,url,uuid,uuidv4,uuidv6,uuidv7,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

package/dist/validators/intersection.js

@@ -0,0 +1 @@
+import{VldBase as t,VLD_VALIDATOR_TYPES as e}from"./base.js";import{i as r}from"../chunks/security-Dy24T8N7.js";import{getMessages as o}from"../locales/runtime.js";import{V as s}from"../chunks/errors-core-Cqi4-9ew.js";function n(t){return null!==t&&"object"==typeof t&&t.constructor===Object&&"[object Object]"===Object.prototype.toString.call(t)}function c(t,e){const o={...t},s=Object.keys(e);for(let i=0;i<s.length;i++){const a=s[i];if(r(a))continue;if(!Object.prototype.hasOwnProperty.call(e,a))continue;const u=e[a],p=t[a];n(u)&&n(p)?o[a]=c(p,u):o[a]=u}return o}class VldIntersection extends t{constructor(t,r){super(e.INTERSECTION),this.validatorA=t,this.validatorB=r}static create(t,e){return new VldIntersection(t,e)}parse(t){try{const e=this.validatorA.parse(t),r=this.validatorB.parse(t),o=n(e),s=n(r);if(o&&s)return c(e,r);if(!o&&!s){if(e===r)return e;throw new Error("Values must be identical for intersection of primitive types")}throw new Error("Cannot create intersection of object and primitive types. Both validators must produce the same type category.")}catch(t){throw new Error(o().intersectionError(t.message))}}safeParse(t){try{return{success:!0,data:this.parse(t)}}catch(t){return{success:!1,error:(e=t.message,new s([{code:"invalid_type",path:[],message:e}]))}}var e}}export{VldIntersection};

package/dist/validators/json.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Immutable JSON validator that validates and parses JSON strings
  * Accepts both strings (which are parsed) and already-parsed objects
@@ -23,4 +23,3 @@ export declare class VldJson<T = unknown> extends VldBase<unknown, T> {
      */
     withSchema<U>(schema: VldBase<unknown, U>): VldJson<U>;
 }
-//# sourceMappingURL=json.d.ts.map

package/dist/validators/json.js

@@ -0,0 +1 @@
+import{VldBase as s,VLD_VALIDATOR_TYPES as r}from"./base.js";import{getMessages as e}from"../locales/runtime.js";class VldJson extends s{constructor(s){super(r.JSON),this.schema=s}static create(s){return new VldJson(s)}parse(s){let r;if("string"==typeof s)try{r=JSON.parse(s)}catch{throw new Error(e().invalidJson)}else r=s;return this.schema?this.schema.parse(r):r}safeParse(s){try{return{success:!0,data:this.parse(s)}}catch(s){return{success:!1,error:s}}}withSchema(s){return new VldJson(s)}}export{VldJson};

package/dist/validators/lazy.d.ts

@@ -3,25 +3,22 @@
  * Part of Zod 4 API parity implementation
  * Allows schemas that reference themselves (e.g., tree structures, nested categories)
  */
-import { VldBase } from './base';
-import type { ParseResult } from './base';
+import { VldBase } from './base.js';
+import type { ParseResult } from './base.js';
 /**
  * Lazy validator - defers schema evaluation until runtime
  * Essential for recursive and self-referencing types
  *
- * MEMORY OPTIMIZATION: Uses WeakRef for the cached schema to allow garbage collection
- * when the validator is no longer in use. This prevents memory leaks in long-running
- * applications with dynamically created schemas.
+ * Caches the resolved schema after first use. This keeps recursive schemas stable
+ * and avoids re-running the schema getter on hot parse paths.
  */
 export declare class VldLazy<TInput, TOutput> extends VldBase<TInput, TOutput> {
     private readonly _schemaGetter;
-    private _cachedSchemaRef;
-    private _strongRef;
+    private _cachedSchema;
     private constructor();
     static create<TInput, TOutput>(schemaGetter: () => VldBase<TInput, TOutput>): VldLazy<TInput, TOutput>;
     /**
      * Get the actual schema, caching it after first retrieval
-     * Uses WeakRef to allow garbage collection when validator is not in use
      */
     private _getSchema;
     /**
@@ -32,4 +29,3 @@ export declare class VldLazy<TInput, TOutput> extends VldBase<TInput, TOutput> {
     parse(value: unknown): TOutput;
     safeParse(value: unknown): ParseResult<TOutput>;
 }
-//# sourceMappingURL=lazy.d.ts.map

package/dist/validators/lazy.js

@@ -0,0 +1 @@
+import{VldBase as e,VLD_VALIDATOR_TYPES as t}from"./base.js";class VldLazy extends e{constructor(e){super(t.LAZY),this._schemaGetter=e,this._cachedSchema=null}static create(e){return new VldLazy(e)}_getSchema(){if(this._cachedSchema)return this._cachedSchema;const e=this._schemaGetter();return this._cachedSchema=e,e}unwrap(){return this._getSchema()}parse(e){return this._getSchema().parse(e)}safeParse(e){return this._getSchema().safeParse(e)}}export{VldLazy};

package/dist/validators/literal.d.ts

@@ -1,9 +1,10 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Immutable literal validator for exact value matching
  */
-export declare class VldLiteral<T extends string | number | boolean | null | undefined> extends VldBase<T, T> {
-    private readonly _literal;
+export type LiteralValue = string | number | bigint | boolean | null | undefined;
+export declare class VldLiteral<T extends LiteralValue> extends VldBase<T, T> {
+    private readonly _values;
     private readonly errorMessage?;
     /**
      * Private constructor to enforce immutability
@@ -13,17 +14,20 @@ export declare class VldLiteral<T extends string | number | boolean | null | und
      * Get the literal value
      */
     get literal(): T;
+    get values(): readonly T[];
+    get isSimple(): boolean;
+    private get expectedDisplay();
     /**
      * Create a new literal validator
      */
-    static create<T extends string | number | boolean | null | undefined>(literal: T): VldLiteral<T>;
+    static create<T extends LiteralValue>(literal: T | readonly T[]): VldLiteral<T>;
     /**
      * Parse and validate a literal value
      */
     parse(value: unknown): T;
+    private _createLiteralError;
     /**
      * Safely parse and validate a literal value
      */
     safeParse(value: unknown): ParseResult<T>;
 }
-//# sourceMappingURL=literal.d.ts.map

package/dist/validators/literal.js

@@ -0,0 +1 @@
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{getMessages as t}from"../locales/runtime.js";import{V as s}from"../chunks/errors-core-Cqi4-9ew.js";function a(e){const r=JSON.stringify(e,(e,r)=>"bigint"==typeof r?r.toString():r);return void 0===r?String(e):r}class VldLiteral extends e{constructor(e,t){super(r.LITERAL),this._values=e,this.errorMessage=t}get literal(){return this._values[0]}get values(){return this._values}get isSimple(){return 1===this._values.length}get expectedDisplay(){return a(1===this._values.length?this._values[0]:this._values)}static create(e){const r=Array.isArray(e)?e:[e];if(0===r.length)throw new Error("Cannot create literal schema with no valid values");return new VldLiteral(r)}parse(e){if(!this._values.includes(e))throw this._createLiteralError(e);return e}_createLiteralError(e){const r={code:"invalid_value",path:[],values:[...this._values],message:this.errorMessage||t().literalExpected(this.expectedDisplay,a(e))};return new s([r])}safeParse(e){return this._values.includes(e)?{success:!0,data:e}:{success:!1,error:this._createLiteralError(e)}}}export{VldLiteral};

package/dist/validators/map.d.ts

@@ -1,4 +1,4 @@
-import { VldBase, ParseResult } from './base';
+import { VldBase, ParseResult } from './base.js';
 /**
  * Immutable Map validator
  */
@@ -10,17 +10,30 @@ export declare class VldMap<K, V> extends VldBase<unknown, Map<K, V>> {
      * Private constructor to enforce immutability
      */
     private constructor();
+    private readonly _simpleKeyMode;
+    private readonly _simpleValueMode;
+    private readonly _simpleKeyValue;
+    private readonly _simpleValueValue;
+    get keySchema(): VldBase<unknown, K>;
+    get valueSchema(): VldBase<unknown, V>;
     /**
      * Create a new Map validator
      */
     static create<K, V>(keyValidator: VldBase<unknown, K>, valueValidator: VldBase<unknown, V>): VldMap<K, V>;
+    private getSimpleItemMode;
+    private getSimpleItemError;
+    private parseSimpleItem;
     /**
      * Parse and validate a Map value
      */
     parse(value: unknown): Map<K, V>;
+    /**
+     * Parse a value that has already passed the Map instance guard.
+     * @internal Used by object validators to avoid duplicate hot-path checks.
+     */
+    parseKnownMap(value: Map<unknown, unknown>): Map<K, V>;
     /**
      * Safely parse and validate a Map value
      */
     safeParse(value: unknown): ParseResult<Map<K, V>>;
 }
-//# sourceMappingURL=map.d.ts.map