@oxog/vld 1.4.0 → 2.0.1

package/dist/validators/hex.js

@@ -1,62 +0,0 @@
-import { VldBase } from './base.js';
-import { VldError, createIssue } from '../errors.js';
-import { getMessages } from '../locales/index.js';
-/**
- * Hexadecimal string validator
- */
-export class VldHex extends VldBase {
-    constructor(lowercase = false) {
-        super();
-        this.lowercase = lowercase;
-    }
-    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 hex string
-        if (!VldHex.HEX_REGEX.test(value)) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().invalidHex)
-                ])
-            };
-        }
-        // Check if even length (full bytes)
-        if (value.length % 2 !== 0) {
-            return {
-                success: false,
-                error: new VldError([
-                    createIssue('custom', [], getMessages().invalidHex)
-                ])
-            };
-        }
-        // Normalize case if required
-        const normalizedValue = this.lowercase ? value.toLowerCase() : value;
-        return { success: true, data: normalizedValue };
-    }
-    /**
-     * Require lowercase hex characters
-     */
-    lowercaseMode() {
-        return new VldHex(true);
-    }
-    static create(lowercase = false) {
-        return new VldHex(lowercase);
-    }
-}
-// BUG-008 FIX: Use * instead of + to allow empty hex strings (consistent with base64 validator)
-VldHex.HEX_REGEX = /^[0-9a-fA-F]*$/;
-//# sourceMappingURL=hex.js.map

package/dist/validators/hex.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hex.js","sourceRoot":"","sources":["../../src/validators/hex.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAe,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC;;GAEG;AACH,MAAM,OAAO,MAAO,SAAQ,OAAuB;IAMjD,YAAY,SAAS,GAAG,KAAK;QAC3B,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED,KAAK,CAAC,KAAc;QAClB,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;QACrC,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;YACpB,MAAM,MAAM,CAAC,KAAK,CAAC;QACrB,CAAC;QACD,OAAO,MAAM,CAAC,IAAI,CAAC;IACrB,CAAC;IAED,SAAS,CAAC,KAAc;QACtB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,IAAI,QAAQ,CAAC;oBAClB,WAAW,CAAC,cAAc,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC,cAAc,CAAC;iBAC9D,CAAC;aACH,CAAC;QACJ,CAAC;QAED,mCAAmC;QACnC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YAClC,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,IAAI,QAAQ,CAAC;oBAClB,WAAW,CAAC,QAAQ,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC,UAAU,CAAC;iBACpD,CAAC;aACH,CAAC;QACJ,CAAC;QAED,oCAAoC;QACpC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;YAC3B,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,IAAI,QAAQ,CAAC;oBAClB,WAAW,CAAC,QAAQ,EAAE,EAAE,EAAE,WAAW,EAAE,CAAC,UAAU,CAAC;iBACpD,CAAC;aACH,CAAC;QACJ,CAAC;QAED,6BAA6B;QAC7B,MAAM,eAAe,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QAErE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,eAAe,EAAE,CAAC;IAClD,CAAC;IAED;;OAEG;IACH,aAAa;QACX,OAAO,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED,MAAM,CAAC,MAAM,CAAC,SAAS,GAAG,KAAK;QAC7B,OAAO,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC;IAC/B,CAAC;;AA/DD,gGAAgG;AACxE,gBAAS,GAAG,gBAAgB,CAAC","sourcesContent":["import { VldBase, ParseResult } from './base';\r\nimport { VldError, createIssue } from '../errors';\r\nimport { getMessages } from '../locales';\r\n\r\n/**\r\n * Hexadecimal string validator\r\n */\r\nexport class VldHex extends VldBase<string, string> {\r\n  // BUG-008 FIX: Use * instead of + to allow empty hex strings (consistent with base64 validator)\r\n  private static readonly HEX_REGEX = /^[0-9a-fA-F]*$/;\r\n  \r\n  private readonly lowercase: boolean;\r\n  \r\n  constructor(lowercase = false) {\r\n    super();\r\n    this.lowercase = lowercase;\r\n  }\r\n  \r\n  parse(value: unknown): string {\r\n    const result = this.safeParse(value);\r\n    if (!result.success) {\r\n      throw result.error;\r\n    }\r\n    return result.data;\r\n  }\r\n  \r\n  safeParse(value: unknown): ParseResult<string> {\r\n    if (typeof value !== 'string') {\r\n      return {\r\n        success: false,\r\n        error: new VldError([\r\n          createIssue('invalid_type', [], getMessages().expectedString)\r\n        ])\r\n      };\r\n    }\r\n    \r\n    // Check if it's a valid hex string\r\n    if (!VldHex.HEX_REGEX.test(value)) {\r\n      return {\r\n        success: false,\r\n        error: new VldError([\r\n          createIssue('custom', [], getMessages().invalidHex)\r\n        ])\r\n      };\r\n    }\r\n    \r\n    // Check if even length (full bytes)\r\n    if (value.length % 2 !== 0) {\r\n      return {\r\n        success: false,\r\n        error: new VldError([\r\n          createIssue('custom', [], getMessages().invalidHex)\r\n        ])\r\n      };\r\n    }\r\n    \r\n    // Normalize case if required\r\n    const normalizedValue = this.lowercase ? value.toLowerCase() : value;\r\n    \r\n    return { success: true, data: normalizedValue };\r\n  }\r\n  \r\n  /**\r\n   * Require lowercase hex characters\r\n   */\r\n  lowercaseMode(): VldHex {\r\n    return new VldHex(true);\r\n  }\r\n  \r\n  static create(lowercase = false): VldHex {\r\n    return new VldHex(lowercase);\r\n  }\r\n}"]}

package/dist/validators/intersection.js

@@ -1,64 +0,0 @@
-import { VldBase } from './base.js';
-import { deepMerge, isPlainObject } from '../utils/deep-merge.js';
-import { getMessages } from '../locales/index.js';
-/**
- * Immutable intersection validator for combining validators
- */
-export class VldIntersection extends VldBase {
-    /**
-     * Private constructor to enforce immutability
-     */
-    constructor(validatorA, validatorB) {
-        super();
-        this.validatorA = validatorA;
-        this.validatorB = validatorB;
-    }
-    /**
-     * Create a new intersection validator
-     */
-    static create(validatorA, validatorB) {
-        return new VldIntersection(validatorA, validatorB);
-    }
-    /**
-     * Parse and validate a value against both validators
-     */
-    parse(value) {
-        try {
-            // Both validators must pass
-            const resultA = this.validatorA.parse(value);
-            const resultB = this.validatorB.parse(value);
-            // BUG-NEW-015 FIX: Check type consistency before merging
-            const aIsObject = isPlainObject(resultA);
-            const bIsObject = isPlainObject(resultB);
-            // Both are objects - safe to merge
-            if (aIsObject && bIsObject) {
-                return deepMerge(resultA, resultB);
-            }
-            // Neither are objects - must be identical primitives
-            if (!aIsObject && !bIsObject) {
-                if (resultA === resultB) {
-                    return resultA;
-                }
-                throw new Error('Values must be identical for intersection of primitive types');
-            }
-            // One is object, one is primitive - invalid intersection
-            throw new Error('Cannot create intersection of object and primitive types. ' +
-                'Both validators must produce the same type category.');
-        }
-        catch (error) {
-            throw new Error(getMessages().intersectionError(error.message));
-        }
-    }
-    /**
-     * Safely parse and validate a value against both validators
-     */
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-//# sourceMappingURL=intersection.js.map

package/dist/validators/intersection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"intersection.js","sourceRoot":"","sources":["../../src/validators/intersection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAe,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC;;GAEG;AACH,MAAM,OAAO,eAAsB,SAAQ,OAAuB;IAChE;;OAEG;IACH,YACmB,UAA+B,EAC/B,UAA+B;QAEhD,KAAK,EAAE,CAAC;QAHS,eAAU,GAAV,UAAU,CAAqB;QAC/B,eAAU,GAAV,UAAU,CAAqB;IAGlD,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,MAAM,CACX,UAA+B,EAC/B,UAA+B;QAE/B,OAAO,IAAI,eAAe,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;IACrD,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAc;QAClB,IAAI,CAAC;YACH,4BAA4B;YAC5B,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC7C,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAE7C,yDAAyD;YACzD,MAAM,SAAS,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;YACzC,MAAM,SAAS,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;YAEzC,mCAAmC;YACnC,IAAI,SAAS,IAAI,SAAS,EAAE,CAAC;gBAC3B,OAAO,SAAS,CAAC,OAAc,EAAE,OAAc,CAAU,CAAC;YAC5D,CAAC;YAED,qDAAqD;YACrD,IAAI,CAAC,SAAS,IAAI,CAAC,SAAS,EAAE,CAAC;gBAC7B,IAAK,OAAe,KAAM,OAAe,EAAE,CAAC;oBAC1C,OAAO,OAAgB,CAAC;gBAC1B,CAAC;gBACD,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;YAClF,CAAC;YAED,yDAAyD;YACzD,MAAM,IAAI,KAAK,CACb,4DAA4D;gBAC5D,sDAAsD,CACvD,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC,iBAAiB,CAAE,KAAe,CAAC,OAAO,CAAC,CAAC,CAAC;QAC7E,CAAC;IACH,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,KAAc;QACtB,IAAI,CAAC;YACH,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAc,EAAE,CAAC;QACnD,CAAC;IACH,CAAC;CACF","sourcesContent":["import { VldBase, ParseResult } from './base';\r\nimport { deepMerge, isPlainObject } from '../utils/deep-merge';\r\nimport { getMessages } from '../locales';\r\n\r\n/**\r\n * Immutable intersection validator for combining validators\r\n */\r\nexport class VldIntersection<A, B> extends VldBase<unknown, A & B> {\r\n  /**\r\n   * Private constructor to enforce immutability\r\n   */\r\n  private constructor(\r\n    private readonly validatorA: VldBase<unknown, A>,\r\n    private readonly validatorB: VldBase<unknown, B>\r\n  ) {\r\n    super();\r\n  }\r\n  \r\n  /**\r\n   * Create a new intersection validator\r\n   */\r\n  static create<A, B>(\r\n    validatorA: VldBase<unknown, A>,\r\n    validatorB: VldBase<unknown, B>\r\n  ): VldIntersection<A, B> {\r\n    return new VldIntersection(validatorA, validatorB);\r\n  }\r\n  \r\n  /**\r\n   * Parse and validate a value against both validators\r\n   */\r\n  parse(value: unknown): A & B {\r\n    try {\r\n      // Both validators must pass\r\n      const resultA = this.validatorA.parse(value);\r\n      const resultB = this.validatorB.parse(value);\r\n\r\n      // BUG-NEW-015 FIX: Check type consistency before merging\r\n      const aIsObject = isPlainObject(resultA);\r\n      const bIsObject = isPlainObject(resultB);\r\n\r\n      // Both are objects - safe to merge\r\n      if (aIsObject && bIsObject) {\r\n        return deepMerge(resultA as any, resultB as any) as A & B;\r\n      }\r\n\r\n      // Neither are objects - must be identical primitives\r\n      if (!aIsObject && !bIsObject) {\r\n        if ((resultA as any) === (resultB as any)) {\r\n          return resultA as A & B;\r\n        }\r\n        throw new Error('Values must be identical for intersection of primitive types');\r\n      }\r\n\r\n      // One is object, one is primitive - invalid intersection\r\n      throw new Error(\r\n        'Cannot create intersection of object and primitive types. ' +\r\n        'Both validators must produce the same type category.'\r\n      );\r\n    } catch (error) {\r\n      throw new Error(getMessages().intersectionError((error as Error).message));\r\n    }\r\n  }\r\n  \r\n  /**\r\n   * Safely parse and validate a value against both validators\r\n   */\r\n  safeParse(value: unknown): ParseResult<A & B> {\r\n    try {\r\n      return { success: true, data: this.parse(value) };\r\n    } catch (error) {\r\n      return { success: false, error: error as Error };\r\n    }\r\n  }\r\n}"]}

package/dist/validators/json.js

@@ -1,64 +0,0 @@
-import { VldBase } from './base.js';
-import { getMessages } from '../locales/index.js';
-/**
- * Immutable JSON validator that validates and parses JSON strings
- * Accepts both strings (which are parsed) and already-parsed objects
- */
-export class VldJson extends VldBase {
-    constructor(schema) {
-        super();
-        this.schema = schema;
-    }
-    /**
-     * Create a new JSON validator
-     */
-    static create(schema) {
-        return new VldJson(schema);
-    }
-    /**
-     * Parse and validate a JSON value
-     */
-    parse(value) {
-        let parsed;
-        // If it's a string, try to parse it as JSON first
-        if (typeof value === 'string') {
-            try {
-                parsed = JSON.parse(value);
-            }
-            catch (e) {
-                throw new Error(getMessages().invalidJson);
-            }
-        }
-        else {
-            // Not a string - assume it's already parsed
-            parsed = value;
-        }
-        // If we have a schema, validate against it
-        if (this.schema) {
-            return this.schema.parse(parsed);
-        }
-        // No schema - just return the parsed value
-        return parsed;
-    }
-    /**
-     * Safely parse and validate a JSON value
-     */
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error
-            };
-        }
-    }
-    /**
-     * Create a new JSON validator with a schema for validation
-     */
-    withSchema(schema) {
-        return new VldJson(schema);
-    }
-}
-//# sourceMappingURL=json.js.map

package/dist/validators/json.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"json.js","sourceRoot":"","sources":["../../src/validators/json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAe,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC;;;GAGG;AACH,MAAM,OAAO,OAAqB,SAAQ,OAAmB;IAC3D,YACmB,MAA4B;QAE7C,KAAK,EAAE,CAAC;QAFS,WAAM,GAAN,MAAM,CAAsB;IAG/C,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,MAAM,CAAc,MAA4B;QACrD,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAc;QAClB,IAAI,MAAe,CAAC;QAEpB,kDAAkD;QAClD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC;gBACH,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC7B,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,MAAM,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC,WAAW,CAAC,CAAC;YAC7C,CAAC;QACH,CAAC;aAAM,CAAC;YACN,4CAA4C;YAC5C,MAAM,GAAG,KAAK,CAAC;QACjB,CAAC;QAED,2CAA2C;QAC3C,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACnC,CAAC;QAED,2CAA2C;QAC3C,OAAO,MAAW,CAAC;IACrB,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,KAAc;QACtB,IAAI,CAAC;YACH,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE,KAAc;aACtB,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;OAEG;IACH,UAAU,CAAI,MAA2B;QACvC,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7B,CAAC;CACF","sourcesContent":["import { VldBase, ParseResult } from './base';\nimport { getMessages } from '../locales';\n\n/**\n * Immutable JSON validator that validates and parses JSON strings\n * Accepts both strings (which are parsed) and already-parsed objects\n */\nexport class VldJson<T = unknown> extends VldBase<unknown, T> {\n  private constructor(\n    private readonly schema?: VldBase<unknown, T>\n  ) {\n    super();\n  }\n\n  /**\n   * Create a new JSON validator\n   */\n  static create<T = unknown>(schema?: VldBase<unknown, T>): VldJson<T> {\n    return new VldJson(schema);\n  }\n\n  /**\n   * Parse and validate a JSON value\n   */\n  parse(value: unknown): T {\n    let parsed: unknown;\n\n    // If it's a string, try to parse it as JSON first\n    if (typeof value === 'string') {\n      try {\n        parsed = JSON.parse(value);\n      } catch (e) {\n        throw new Error(getMessages().invalidJson);\n      }\n    } else {\n      // Not a string - assume it's already parsed\n      parsed = value;\n    }\n\n    // If we have a schema, validate against it\n    if (this.schema) {\n      return this.schema.parse(parsed);\n    }\n\n    // No schema - just return the parsed value\n    return parsed as T;\n  }\n\n  /**\n   * Safely parse and validate a JSON value\n   */\n  safeParse(value: unknown): ParseResult<T> {\n    try {\n      return { success: true, data: this.parse(value) };\n    } catch (error) {\n      return {\n        success: false,\n        error: error as Error\n      };\n    }\n  }\n\n  /**\n   * Create a new JSON validator with a schema for validation\n   */\n  withSchema<U>(schema: VldBase<unknown, U>): VldJson<U> {\n    return new VldJson(schema);\n  }\n}\n"]}

package/dist/validators/lazy.js

@@ -1,42 +0,0 @@
-/**
- * VldLazy - Lazy evaluation for recursive schemas
- * Part of Zod 4 API parity implementation
- * Allows schemas that reference themselves (e.g., tree structures, nested categories)
- */
-import { VldBase } from './base.js';
-/**
- * Lazy validator - defers schema evaluation until runtime
- * Essential for recursive and self-referencing types
- */
-export class VldLazy extends VldBase {
-    constructor(_schemaGetter) {
-        super();
-        this._schemaGetter = _schemaGetter;
-        this._cachedSchema = null;
-    }
-    static create(schemaGetter) {
-        return new VldLazy(schemaGetter);
-    }
-    /**
-     * Get the actual schema, caching it after first retrieval
-     */
-    _getSchema() {
-        if (!this._cachedSchema) {
-            this._cachedSchema = this._schemaGetter();
-        }
-        return this._cachedSchema;
-    }
-    /**
-     * Get the inner schema (unwrap)
-     */
-    unwrap() {
-        return this._getSchema();
-    }
-    parse(value) {
-        return this._getSchema().parse(value);
-    }
-    safeParse(value) {
-        return this._getSchema().safeParse(value);
-    }
-}
-//# sourceMappingURL=lazy.js.map

package/dist/validators/lazy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lazy.js","sourceRoot":"","sources":["../../src/validators/lazy.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAGjC;;;GAGG;AACH,MAAM,OAAO,OAAyB,SAAQ,OAAwB;IAGpE,YACmB,aAA6C;QAE9D,KAAK,EAAE,CAAC;QAFS,kBAAa,GAAb,aAAa,CAAgC;QAHxD,kBAAa,GAAoC,IAAI,CAAC;IAM9D,CAAC;IAED,MAAM,CAAC,MAAM,CACX,YAA4C;QAE5C,OAAO,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;IACnC,CAAC;IAED;;OAEG;IACK,UAAU;QAChB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;YACxB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,aAAa,EAAE,CAAC;QAC5C,CAAC;QACD,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,MAAM;QACJ,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC;IAC3B,CAAC;IAED,KAAK,CAAC,KAAc;QAClB,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;IAED,SAAS,CAAC,KAAc;QACtB,OAAO,IAAI,CAAC,UAAU,EAAE,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC5C,CAAC;CACF","sourcesContent":["/**\n * VldLazy - Lazy evaluation for recursive schemas\n * Part of Zod 4 API parity implementation\n * Allows schemas that reference themselves (e.g., tree structures, nested categories)\n */\n\nimport { VldBase } from './base';\nimport type { ParseResult } from './base';\n\n/**\n * Lazy validator - defers schema evaluation until runtime\n * Essential for recursive and self-referencing types\n */\nexport class VldLazy<TInput, TOutput> extends VldBase<TInput, TOutput> {\n  private _cachedSchema: VldBase<TInput, TOutput> | null = null;\n\n  private constructor(\n    private readonly _schemaGetter: () => VldBase<TInput, TOutput>\n  ) {\n    super();\n  }\n\n  static create<TInput, TOutput>(\n    schemaGetter: () => VldBase<TInput, TOutput>\n  ): VldLazy<TInput, TOutput> {\n    return new VldLazy(schemaGetter);\n  }\n\n  /**\n   * Get the actual schema, caching it after first retrieval\n   */\n  private _getSchema(): VldBase<TInput, TOutput> {\n    if (!this._cachedSchema) {\n      this._cachedSchema = this._schemaGetter();\n    }\n    return this._cachedSchema;\n  }\n\n  /**\n   * Get the inner schema (unwrap)\n   */\n  unwrap(): VldBase<TInput, TOutput> {\n    return this._getSchema();\n  }\n\n  parse(value: unknown): TOutput {\n    return this._getSchema().parse(value);\n  }\n\n  safeParse(value: unknown): ParseResult<TOutput> {\n    return this._getSchema().safeParse(value);\n  }\n}\n"]}

package/dist/validators/literal.js

@@ -1,45 +0,0 @@
-import { VldBase } from './base.js';
-import { getMessages } from '../locales/index.js';
-/**
- * Immutable literal validator for exact value matching
- */
-export class VldLiteral extends VldBase {
-    /**
-     * Private constructor to enforce immutability
-     */
-    constructor(literal, errorMessage) {
-        super();
-        this.literal = literal;
-        this.errorMessage = errorMessage;
-    }
-    /**
-     * Create a new literal validator
-     */
-    static create(literal) {
-        return new VldLiteral(literal);
-    }
-    /**
-     * Parse and validate a literal value
-     */
-    parse(value) {
-        if (value !== this.literal) {
-            throw new Error(this.errorMessage ||
-                getMessages().literalExpected(JSON.stringify(this.literal), JSON.stringify(value)));
-        }
-        return this.literal;
-    }
-    /**
-     * Safely parse and validate a literal value
-     */
-    safeParse(value) {
-        if (value === this.literal) {
-            return { success: true, data: this.literal };
-        }
-        return {
-            success: false,
-            error: new Error(this.errorMessage ||
-                getMessages().literalExpected(JSON.stringify(this.literal), JSON.stringify(value)))
-        };
-    }
-}
-//# sourceMappingURL=literal.js.map

package/dist/validators/literal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"literal.js","sourceRoot":"","sources":["../../src/validators/literal.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAe,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC;;GAEG;AACH,MAAM,OAAO,UAAmE,SAAQ,OAAa;IACnG;;OAEG;IACH,YACmB,OAAU,EACV,YAAqB;QAEtC,KAAK,EAAE,CAAC;QAHS,YAAO,GAAP,OAAO,CAAG;QACV,iBAAY,GAAZ,YAAY,CAAS;IAGxC,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,MAAM,CAAyD,OAAU;QAC9E,OAAO,IAAI,UAAU,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAc;QAClB,IAAI,KAAK,KAAK,IAAI,CAAC,OAAO,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CACb,IAAI,CAAC,YAAY;gBACjB,WAAW,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CACnF,CAAC;QACJ,CAAC;QACD,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,KAAc;QACtB,IAAI,KAAK,KAAK,IAAI,CAAC,OAAO,EAAE,CAAC;YAC3B,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC;QAC/C,CAAC;QACD,OAAO;YACL,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,IAAI,KAAK,CACd,IAAI,CAAC,YAAY;gBACjB,WAAW,EAAE,CAAC,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CACnF;SACF,CAAC;IACJ,CAAC;CACF","sourcesContent":["import { VldBase, ParseResult } from './base';\nimport { getMessages } from '../locales';\n\n/**\n * Immutable literal validator for exact value matching\n */\nexport class VldLiteral<T extends string | number | boolean | null | undefined> extends VldBase<T, T> {\n  /**\n   * Private constructor to enforce immutability\n   */\n  private constructor(\n    private readonly literal: T,\n    private readonly errorMessage?: string\n  ) {\n    super();\n  }\n  \n  /**\n   * Create a new literal validator\n   */\n  static create<T extends string | number | boolean | null | undefined>(literal: T): VldLiteral<T> {\n    return new VldLiteral(literal);\n  }\n  \n  /**\n   * Parse and validate a literal value\n   */\n  parse(value: unknown): T {\n    if (value !== this.literal) {\n      throw new Error(\n        this.errorMessage || \n        getMessages().literalExpected(JSON.stringify(this.literal), JSON.stringify(value))\n      );\n    }\n    return this.literal;\n  }\n  \n  /**\n   * Safely parse and validate a literal value\n   */\n  safeParse(value: unknown): ParseResult<T> {\n    if (value === this.literal) {\n      return { success: true, data: this.literal };\n    }\n    return { \n      success: false, \n      error: new Error(\n        this.errorMessage || \n        getMessages().literalExpected(JSON.stringify(this.literal), JSON.stringify(value))\n      )\n    };\n  }\n}"]}

package/dist/validators/map.js

@@ -1,54 +0,0 @@
-import { VldBase } from './base.js';
-import { getMessages } from '../locales/index.js';
-/**
- * Immutable Map validator
- */
-export class VldMap extends VldBase {
-    /**
-     * Private constructor to enforce immutability
-     */
-    constructor(keyValidator, valueValidator, errorMessage) {
-        super();
-        this.keyValidator = keyValidator;
-        this.valueValidator = valueValidator;
-        this.errorMessage = errorMessage;
-    }
-    /**
-     * Create a new Map validator
-     */
-    static create(keyValidator, valueValidator) {
-        return new VldMap(keyValidator, valueValidator);
-    }
-    /**
-     * Parse and validate a Map value
-     */
-    parse(value) {
-        if (!(value instanceof Map)) {
-            throw new Error(this.errorMessage || getMessages().invalidMap);
-        }
-        const result = new Map();
-        for (const [key, val] of value) {
-            try {
-                const validKey = this.keyValidator.parse(key);
-                const validValue = this.valueValidator.parse(val);
-                result.set(validKey, validValue);
-            }
-            catch (error) {
-                throw new Error(error.message);
-            }
-        }
-        return result;
-    }
-    /**
-     * Safely parse and validate a Map value
-     */
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-//# sourceMappingURL=map.js.map

package/dist/validators/map.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"map.js","sourceRoot":"","sources":["../../src/validators/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAe,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC;;GAEG;AACH,MAAM,OAAO,MAAa,SAAQ,OAA2B;IAC3D;;OAEG;IACH,YACmB,YAAiC,EACjC,cAAmC,EACnC,YAAqB;QAEtC,KAAK,EAAE,CAAC;QAJS,iBAAY,GAAZ,YAAY,CAAqB;QACjC,mBAAc,GAAd,cAAc,CAAqB;QACnC,iBAAY,GAAZ,YAAY,CAAS;IAGxC,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,MAAM,CACX,YAAiC,EACjC,cAAmC;QAEnC,OAAO,IAAI,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,CAAC;IAClD,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAc;QAClB,IAAI,CAAC,CAAC,KAAK,YAAY,GAAG,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,YAAY,IAAI,WAAW,EAAE,CAAC,UAAU,CAAC,CAAC;QACjE,CAAC;QAED,MAAM,MAAM,GAAG,IAAI,GAAG,EAAQ,CAAC;QAC/B,KAAK,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,KAAK,EAAE,CAAC;YAC/B,IAAI,CAAC;gBACH,MAAM,QAAQ,GAAG,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAC9C,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBAClD,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;YACnC,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,IAAI,KAAK,CAAE,KAAe,CAAC,OAAO,CAAC,CAAC;YAC5C,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,KAAc;QACtB,IAAI,CAAC;YACH,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAc,EAAE,CAAC;QACnD,CAAC;IACH,CAAC;CACF","sourcesContent":["import { VldBase, ParseResult } from './base';\nimport { getMessages } from '../locales';\n\n/**\n * Immutable Map validator\n */\nexport class VldMap<K, V> extends VldBase<unknown, Map<K, V>> {\n  /**\n   * Private constructor to enforce immutability\n   */\n  private constructor(\n    private readonly keyValidator: VldBase<unknown, K>,\n    private readonly valueValidator: VldBase<unknown, V>,\n    private readonly errorMessage?: string\n  ) {\n    super();\n  }\n  \n  /**\n   * Create a new Map validator\n   */\n  static create<K, V>(\n    keyValidator: VldBase<unknown, K>,\n    valueValidator: VldBase<unknown, V>\n  ): VldMap<K, V> {\n    return new VldMap(keyValidator, valueValidator);\n  }\n  \n  /**\n   * Parse and validate a Map value\n   */\n  parse(value: unknown): Map<K, V> {\n    if (!(value instanceof Map)) {\n      throw new Error(this.errorMessage || getMessages().invalidMap);\n    }\n    \n    const result = new Map<K, V>();\n    for (const [key, val] of value) {\n      try {\n        const validKey = this.keyValidator.parse(key);\n        const validValue = this.valueValidator.parse(val);\n        result.set(validKey, validValue);\n      } catch (error) {\n        throw new Error((error as Error).message);\n      }\n    }\n    \n    return result;\n  }\n  \n  /**\n   * Safely parse and validate a Map value\n   */\n  safeParse(value: unknown): ParseResult<Map<K, V>> {\n    try {\n      return { success: true, data: this.parse(value) };\n    } catch (error) {\n      return { success: false, error: error as Error };\n    }\n  }\n}"]}

package/dist/validators/nan.js

@@ -1,32 +0,0 @@
-/**
- * VldNan - Validates that a value is NaN (Not a Number)
- * Part of Zod 4 API parity implementation
- */
-import { VldBase } from './base.js';
-/**
- * NaN validator - validates that a value is NaN
- * Note: Uses Number.isNaN() which is more strict than global isNaN()
- */
-export class VldNan extends VldBase {
-    constructor() {
-        super();
-    }
-    static create() {
-        return new VldNan();
-    }
-    parse(value) {
-        if (typeof value !== 'number' || !Number.isNaN(value)) {
-            throw new Error(`Expected NaN, received ${typeof value === 'number' ? 'a valid number' : typeof value}`);
-        }
-        return value;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-//# sourceMappingURL=nan.js.map

package/dist/validators/nan.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"nan.js","sourceRoot":"","sources":["../../src/validators/nan.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAGjC;;;GAGG;AACH,MAAM,OAAO,MAAO,SAAQ,OAAwB;IAClD;QACE,KAAK,EAAE,CAAC;IACV,CAAC;IAED,MAAM,CAAC,MAAM;QACX,OAAO,IAAI,MAAM,EAAE,CAAC;IACtB,CAAC;IAED,KAAK,CAAC,KAAc;QAClB,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YACtD,MAAM,IAAI,KAAK,CAAC,0BAA0B,OAAO,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,OAAO,KAAK,EAAE,CAAC,CAAC;QAC3G,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,SAAS,CAAC,KAAc;QACtB,IAAI,CAAC;YACH,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAc,EAAE,CAAC;QACnD,CAAC;IACH,CAAC;CACF","sourcesContent":["/**\n * VldNan - Validates that a value is NaN (Not a Number)\n * Part of Zod 4 API parity implementation\n */\n\nimport { VldBase } from './base';\nimport type { ParseResult } from './base';\n\n/**\n * NaN validator - validates that a value is NaN\n * Note: Uses Number.isNaN() which is more strict than global isNaN()\n */\nexport class VldNan extends VldBase<unknown, number> {\n  private constructor() {\n    super();\n  }\n\n  static create(): VldNan {\n    return new VldNan();\n  }\n\n  parse(value: unknown): number {\n    if (typeof value !== 'number' || !Number.isNaN(value)) {\n      throw new Error(`Expected NaN, received ${typeof value === 'number' ? 'a valid number' : typeof value}`);\n    }\n    return value;\n  }\n\n  safeParse(value: unknown): ParseResult<number> {\n    try {\n      return { success: true, data: this.parse(value) };\n    } catch (error) {\n      return { success: false, error: error as Error };\n    }\n  }\n}\n"]}

package/dist/validators/never.js

@@ -1,29 +0,0 @@
-import { VldBase } from './base.js';
-import { getMessages } from '../locales/index.js';
-/**
- * Validator that never succeeds
- */
-export class VldNever extends VldBase {
-    /**
-     * Create a new never validator
-     */
-    static create() {
-        return new VldNever();
-    }
-    /**
-     * Parse never value (always fails)
-     */
-    parse(_value) {
-        throw new Error(getMessages().neverType);
-    }
-    /**
-     * Safely parse never value (always fails)
-     */
-    safeParse(_value) {
-        return {
-            success: false,
-            error: new Error(getMessages().neverType)
-        };
-    }
-}
-//# sourceMappingURL=never.js.map

package/dist/validators/never.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"never.js","sourceRoot":"","sources":["../../src/validators/never.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAe,MAAM,QAAQ,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC;;GAEG;AACH,MAAM,OAAO,QAAS,SAAQ,OAAqB;IACjD;;OAEG;IACH,MAAM,CAAC,MAAM;QACX,OAAO,IAAI,QAAQ,EAAE,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,MAAe;QACnB,MAAM,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACH,SAAS,CAAC,MAAe;QACvB,OAAO;YACL,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,IAAI,KAAK,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC;SAC1C,CAAC;IACJ,CAAC;CACF","sourcesContent":["import { VldBase, ParseResult } from './base';\nimport { getMessages } from '../locales';\n\n/**\n * Validator that never succeeds\n */\nexport class VldNever extends VldBase<never, never> {\n  /**\n   * Create a new never validator\n   */\n  static create(): VldNever {\n    return new VldNever();\n  }\n  \n  /**\n   * Parse never value (always fails)\n   */\n  parse(_value: unknown): never {\n    throw new Error(getMessages().neverType);\n  }\n  \n  /**\n   * Safely parse never value (always fails)\n   */\n  safeParse(_value: unknown): ParseResult<never> {\n    return { \n      success: false, \n      error: new Error(getMessages().neverType) \n    };\n  }\n}"]}

package/dist/validators/null.js

@@ -1,31 +0,0 @@
-/**
- * VldNull - Validates that a value is exactly null
- * Part of Zod 4 API parity implementation
- */
-import { VldBase } from './base.js';
-/**
- * Null validator - validates that a value is exactly null
- */
-export class VldNull extends VldBase {
-    constructor() {
-        super();
-    }
-    static create() {
-        return new VldNull();
-    }
-    parse(value) {
-        if (value !== null) {
-            throw new Error(`Expected null, received ${typeof value}`);
-        }
-        return null;
-    }
-    safeParse(value) {
-        try {
-            return { success: true, data: this.parse(value) };
-        }
-        catch (error) {
-            return { success: false, error: error };
-        }
-    }
-}
-//# sourceMappingURL=null.js.map

package/dist/validators/null.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"null.js","sourceRoot":"","sources":["../../src/validators/null.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAGjC;;GAEG;AACH,MAAM,OAAO,OAAQ,SAAQ,OAAsB;IACjD;QACE,KAAK,EAAE,CAAC;IACV,CAAC;IAED,MAAM,CAAC,MAAM;QACX,OAAO,IAAI,OAAO,EAAE,CAAC;IACvB,CAAC;IAED,KAAK,CAAC,KAAc;QAClB,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YACnB,MAAM,IAAI,KAAK,CAAC,2BAA2B,OAAO,KAAK,EAAE,CAAC,CAAC;QAC7D,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,SAAS,CAAC,KAAc;QACtB,IAAI,CAAC;YACH,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;QACpD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAc,EAAE,CAAC;QACnD,CAAC;IACH,CAAC;CACF","sourcesContent":["/**\n * VldNull - Validates that a value is exactly null\n * Part of Zod 4 API parity implementation\n */\n\nimport { VldBase } from './base';\nimport type { ParseResult } from './base';\n\n/**\n * Null validator - validates that a value is exactly null\n */\nexport class VldNull extends VldBase<unknown, null> {\n  private constructor() {\n    super();\n  }\n\n  static create(): VldNull {\n    return new VldNull();\n  }\n\n  parse(value: unknown): null {\n    if (value !== null) {\n      throw new Error(`Expected null, received ${typeof value}`);\n    }\n    return null;\n  }\n\n  safeParse(value: unknown): ParseResult<null> {\n    try {\n      return { success: true, data: this.parse(value) };\n    } catch (error) {\n      return { success: false, error: error as Error };\n    }\n  }\n}\n"]}