@oxog/vld 2.4.0 → 3.0.1

package/dist/validators/leaf-v2.d.ts

@@ -0,0 +1,138 @@
+/**
+ * V2 leaf validators: VldLiteralV2, VldBooleanV2, VldEnumV2, VldRecordV2,
+ * VldAnyV2, VldUnknownV2, VldVoidV2, VldNeverV2, VldNullV2, VldUndefinedV2,
+ * VldSymbolV2, VldNullishV2, VldFunctionV2.
+ */
+import { VldBase, type ParseResult } from './base.js';
+export interface VldLiteralDef<T> {
+    readonly type: 'literal';
+    readonly value: T | undefined;
+}
+export declare class VldLiteralV2<T extends string | number | boolean | null | undefined> extends VldBase<T, T> {
+    readonly __def: VldLiteralDef<T>;
+    constructor(value: T);
+    static create<T extends string | number | boolean | null | undefined>(value: T): VldLiteralV2<T>;
+    parse(value: unknown): T;
+    safeParse(value: unknown): ParseResult<T>;
+    get literal(): T;
+    get isSimple(): boolean;
+}
+export declare class VldBooleanV2 extends VldBase<boolean, boolean> {
+    readonly __def: {
+        type: 'boolean';
+    };
+    constructor();
+    static create(): VldBooleanV2;
+    parse(value: unknown): boolean;
+    safeParse(value: unknown): ParseResult<boolean>;
+    get isSimple(): boolean;
+}
+export interface VldEnumDef<T extends readonly (string | number)[]> {
+    readonly type: 'enum';
+    readonly values: ReadonlyArray<T[number]>;
+    readonly valuesSet: Set<T[number]>;
+}
+export declare class VldEnumV2<T extends readonly (string | number)[]> extends VldBase<T[number], T[number]> {
+    readonly __def: VldEnumDef<T>;
+    constructor(values: T);
+    static create<T extends readonly (string | number)[]>(values: T): VldEnumV2<T>;
+    parse(value: unknown): T[number];
+    safeParse(value: unknown): ParseResult<T[number]>;
+    get options(): T[number][];
+    get enumValues(): T[number][];
+    get isSimple(): boolean;
+}
+export interface VldRecordDef<T> {
+    readonly type: 'record';
+    readonly valueValidator: VldBase<unknown, T>;
+    readonly simpleValueMode: 'string' | 'number' | 'boolean' | 'bigint' | 'symbol' | undefined;
+}
+export declare class VldRecordV2<T> extends VldBase<Record<string, T>, Record<string, T>> {
+    readonly __def: VldRecordDef<T>;
+    constructor(valueValidator: VldBase<unknown, T>);
+    static create<T>(valueValidator: VldBase<unknown, T>): VldRecordV2<T>;
+    parse(value: unknown): Record<string, T>;
+    parseKnownRecord(value: Record<string, unknown>): Record<string, T>;
+    safeParse(value: unknown): ParseResult<Record<string, T>>;
+    get isSimple(): boolean;
+}
+export declare class VldAnyV2 extends VldBase<any, any> {
+    readonly __def: {
+        type: 'any';
+    };
+    constructor();
+    static create(): VldAnyV2;
+    parse(value: unknown): any;
+    safeParse(value: unknown): ParseResult<any>;
+    get isSimple(): boolean;
+}
+export declare class VldUnknownV2 extends VldBase<unknown, unknown> {
+    readonly __def: {
+        type: 'unknown';
+    };
+    constructor();
+    static create(): VldUnknownV2;
+    parse(value: unknown): unknown;
+    safeParse(value: unknown): ParseResult<unknown>;
+    get isSimple(): boolean;
+}
+export declare class VldVoidV2 extends VldBase<undefined, undefined> {
+    readonly __def: {
+        type: 'void';
+    };
+    constructor();
+    static create(): VldVoidV2;
+    parse(value: unknown): undefined;
+    safeParse(value: unknown): ParseResult<undefined>;
+    get isSimple(): boolean;
+}
+export declare class VldNeverV2 extends VldBase<never, never> {
+    readonly __def: {
+        type: 'never';
+    };
+    constructor();
+    static create(): VldNeverV2;
+    parse(_value: unknown): never;
+    safeParse(_value: unknown): ParseResult<never>;
+    get isSimple(): boolean;
+}
+export declare class VldNullV2 extends VldBase<null, null> {
+    readonly __def: {
+        type: 'null';
+    };
+    constructor();
+    static create(): VldNullV2;
+    parse(value: unknown): null;
+    safeParse(value: unknown): ParseResult<null>;
+    get isSimple(): boolean;
+}
+export declare class VldUndefinedV2 extends VldBase<undefined, undefined> {
+    readonly __def: {
+        type: 'undefined';
+    };
+    constructor();
+    static create(): VldUndefinedV2;
+    parse(value: unknown): undefined;
+    safeParse(value: unknown): ParseResult<undefined>;
+    get isSimple(): boolean;
+}
+export declare class VldSymbolV2 extends VldBase<symbol, symbol> {
+    readonly __def: {
+        type: 'symbol';
+    };
+    constructor();
+    static create(): VldSymbolV2;
+    parse(value: unknown): symbol;
+    safeParse(value: unknown): ParseResult<symbol>;
+    get isSimple(): boolean;
+}
+export declare class VldFunctionV2 extends VldBase<Function, (...args: any[]) => any> {
+    readonly __def: {
+        type: 'function';
+    };
+    constructor();
+    static create(): VldFunctionV2;
+    parse(value: unknown): (...args: any[]) => any;
+    safeParse(value: unknown): ParseResult<(...args: any[]) => any>;
+    get isSimple(): boolean;
+}

package/dist/validators/leaf-v2.js

@@ -0,0 +1 @@
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{V as t,c as s,g as n}from"../chunks/errors-core-BU14-Dk8.js";class VldLiteralV2 extends e{constructor(e){super(r.LITERAL),this.__def=Object.freeze({type:"literal",value:e})}static create(e){return new VldLiteralV2(e)}parse(e){const r=this.__def.value;if(e!==r)throw new t([{code:"invalid_literal",path:[],expected:String(r),received:void 0===e?"undefined":typeof e,message:`Invalid input: expected ${JSON.stringify(r)}, received ${JSON.stringify(e)}`}]);return r}safeParse(e){const r=this.__def.value;return e===r?{success:!0,data:r}:{success:!1,error:new t([{code:"invalid_literal",path:[],expected:String(r),received:void 0===e?"undefined":typeof e,message:`Invalid input: expected ${JSON.stringify(r)}, received ${JSON.stringify(e)}`}])}}get literal(){return this.__def.value}get isSimple(){return!0}}class VldBooleanV2 extends e{constructor(){super(r.BOOLEAN),this.__def=Object.freeze({type:"boolean"})}static create(){return new VldBooleanV2}parse(e){if("boolean"!=typeof e)throw new t([s("boolean",n(e),void 0)]);return e}safeParse(e){return"boolean"==typeof e?{success:!0,data:e}:{success:!1,error:new t([s("boolean",n(e),void 0)])}}get isSimple(){return!0}}class VldEnumV2 extends e{constructor(e){super(r.ENUM),this.__def=Object.freeze({type:"enum",values:Object.freeze([...e]),valuesSet:new Set(e)})}static create(e){return new VldEnumV2(e)}parse(e){if(!this.__def.valuesSet.has(e))throw new t([{code:"invalid_value",path:[],values:[...this.__def.values],received:typeof e,message:`Invalid enum value. Expected ${[...this.__def.values].join(" | ")}, received ${JSON.stringify(e)}`}]);return e}safeParse(e){return this.__def.valuesSet.has(e)?{success:!0,data:e}:{success:!1,error:new t([{code:"invalid_value",path:[],values:[...this.__def.values],received:typeof e,message:`Invalid enum value. Expected ${[...this.__def.values].join(" | ")}, received ${JSON.stringify(e)}`}])}}get options(){return[...this.__def.values]}get enumValues(){return this.options}get isSimple(){return!0}}class VldRecordV2 extends e{constructor(e){super(r.RECORD);const t=!0===e.isSimple?e.validatorType===r.STRING?"string":e.validatorType===r.NUMBER?"number":e.validatorType===r.BOOLEAN?"boolean":e.validatorType===r.BIGINT?"bigint":e.validatorType===r.SYMBOL?"symbol":void 0:void 0;this.__def=Object.freeze({type:"record",valueValidator:e,simpleValueMode:t})}static create(e){return new VldRecordV2(e)}parse(e){if("object"!=typeof e||null===e||Array.isArray(e))throw new t([s("record",n(e),void 0)]);return this.parseKnownRecord(e)}parseKnownRecord(e){const r=this.__def.simpleValueMode,t={},s=Object.keys(e);if(void 0!==r)for(let n=0;n<s.length;n++){const i=s[n],a=e[i];switch(r){case"string":if("string"!=typeof a)throw new Error(`Invalid field ${i}: expected string, received ${typeof a}`);t[i]=a;break;case"number":if("number"!=typeof a||isNaN(a))throw new Error(`Invalid field ${i}: expected number, received ${typeof a}`);t[i]=a;break;case"boolean":if("boolean"!=typeof a)throw new Error(`Invalid field ${i}: expected boolean, received ${typeof a}`);t[i]=a;break;case"bigint":if("bigint"!=typeof a)throw new Error(`Invalid field ${i}: expected bigint, received ${typeof a}`);t[i]=a;break;case"symbol":if("symbol"!=typeof a)throw new Error(`Invalid field ${i}: expected symbol, received ${typeof a}`);t[i]=a}}else{const r=this.__def.valueValidator;for(let n=0;n<s.length;n++){const i=s[n];t[i]=r.parse(e[i])}}return t}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:e instanceof t?e:new t([{code:"custom",path:[],message:String(e)}])}}}get isSimple(){return!1}}class VldAnyV2 extends e{constructor(){super(r.ANY),this.__def=Object.freeze({type:"any"})}static create(){return new VldAnyV2}parse(e){return e}safeParse(e){return{success:!0,data:e}}get isSimple(){return!0}}class VldUnknownV2 extends e{constructor(){super(r.UNKNOWN),this.__def=Object.freeze({type:"unknown"})}static create(){return new VldUnknownV2}parse(e){return e}safeParse(e){return{success:!0,data:e}}get isSimple(){return!0}}class VldVoidV2 extends e{constructor(){super(r.VOID),this.__def=Object.freeze({type:"void"})}static create(){return new VldVoidV2}parse(e){if(void 0!==e)throw new t([s("void",n(e),void 0)])}safeParse(e){return void 0===e?{success:!0,data:void 0}:{success:!1,error:new t([s("void",n(e),void 0)])}}get isSimple(){return!0}}class VldNeverV2 extends e{constructor(){super(r.NEVER),this.__def=Object.freeze({type:"never"})}static create(){return new VldNeverV2}parse(e){throw new t([{code:"custom",path:[],message:"No value can pass never validation"}])}safeParse(e){return{success:!1,error:new t([{code:"custom",path:[],message:"No value can pass never validation"}])}}get isSimple(){return!0}}class VldNullV2 extends e{constructor(){super(r.NULL),this.__def=Object.freeze({type:"null"})}static create(){return new VldNullV2}parse(e){if(null!==e)throw new t([s("null",n(e),void 0)]);return null}safeParse(e){return null===e?{success:!0,data:null}:{success:!1,error:new t([s("null",n(e),void 0)])}}get isSimple(){return!0}}class VldUndefinedV2 extends e{constructor(){super(r.UNDEFINED),this.__def=Object.freeze({type:"undefined"})}static create(){return new VldUndefinedV2}parse(e){if(void 0!==e)throw new t([s("undefined",n(e),void 0)])}safeParse(e){return void 0===e?{success:!0,data:void 0}:{success:!1,error:new t([s("undefined",n(e),void 0)])}}get isSimple(){return!0}}class VldSymbolV2 extends e{constructor(){super(r.SYMBOL),this.__def=Object.freeze({type:"symbol"})}static create(){return new VldSymbolV2}parse(e){if("symbol"!=typeof e)throw new t([s("symbol",n(e),void 0)]);return e}safeParse(e){return"symbol"==typeof e?{success:!0,data:e}:{success:!1,error:new t([s("symbol",n(e),void 0)])}}get isSimple(){return!0}}class VldFunctionV2 extends e{constructor(){super(r.FUNCTION),this.__def=Object.freeze({type:"function"})}static create(){return new VldFunctionV2}parse(e){if("function"!=typeof e)throw new t([s("function",n(e),void 0)]);return e}safeParse(e){return"function"==typeof e?{success:!0,data:e}:{success:!1,error:new t([s("function",n(e),void 0)])}}get isSimple(){return!0}}export{VldAnyV2,VldBooleanV2,VldEnumV2,VldFunctionV2,VldLiteralV2,VldNeverV2,VldNullV2,VldRecordV2,VldSymbolV2,VldUndefinedV2,VldUnknownV2,VldVoidV2};

package/dist/validators/literal.js

@@ -1 +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-CerMg2rq.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 value(){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};
+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-BU14-Dk8.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 value(){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.js

@@ -1 +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-CerMg2rq.js";class VldMap extends e{constructor(e,t,s,i=[]){super(r.MAP),this.keyValidator=e,this.valueValidator=t,this.errorMessage=s,this._checks=i,this._simpleKeyMode=this.getSimpleItemMode(e),this._simpleValueMode=this.getSimpleItemMode(t),this._simpleKeyValue="literal"===this._simpleKeyMode?e.literal:void 0,this._simpleValueValue="literal"===this._simpleValueMode?t.literal:void 0}get keySchema(){return this.keyValidator}get valueSchema(){return this.valueValidator}get keyType(){return this.keyValidator}get valueType(){return this.valueValidator}static create(e,r){return new VldMap(e,r)}getSimpleItemMode(e){if(!0===e.isSimple)switch(e.validatorType){case r.STRING:return"string";case r.NUMBER:return"number";case r.BOOLEAN:return"boolean";case r.BIGINT:return"bigint";case r.SYMBOL:return"symbol";case r.NULL:return"null";case r.UNDEFINED:case r.VOID:return"undefinedValue";case r.LITERAL:return"literal";case r.ANY:case r.UNKNOWN:return"passthrough";default:return}}getSimpleItemError(e,r,s){switch(e){case"string":return t().invalidString;case"number":return t().invalidNumber;case"boolean":return t().invalidBoolean;case"bigint":return t().invalidBigint;case"symbol":return t().invalidSymbol;case"null":return"Expected null, received "+typeof s;case"undefinedValue":return t().expectedUndefined;case"literal":return t().literalExpected(JSON.stringify(r),JSON.stringify(s));default:return t().invalidMap}}parseSimpleItem(e,r,t){switch(e){case"string":if("string"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"number":if("number"!=typeof t||isNaN(t))throw new Error(this.getSimpleItemError(e,r,t));return t;case"boolean":if("boolean"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"bigint":if("bigint"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"symbol":if("symbol"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"null":if(null!==t)throw new Error(this.getSimpleItemError(e,r,t));return null;case"undefinedValue":if(void 0!==t)throw new Error(this.getSimpleItemError(e,r,t));return;case"literal":if(t!==r)throw new Error(this.getSimpleItemError(e,r,t));return r;case"passthrough":return t}}parse(e){if(!(e instanceof Map))throw new Error(this.errorMessage||t().invalidMap);return this.parseKnownMap(e)}parseKnownMap(e){const r=new Map,t=this._simpleKeyMode,s=this._simpleValueMode;if("string"===t&&"number"===s)for(const[i,a]of e){if("string"!=typeof i)throw new Error(this.getSimpleItemError(t,this._simpleKeyValue,i));if("number"!=typeof a||isNaN(a))throw new Error(this.getSimpleItemError(s,this._simpleValueValue,a));r.set(i,a)}else if("string"===t&&"string"===s)for(const[i,a]of e){if("string"!=typeof i)throw new Error(this.getSimpleItemError(t,this._simpleKeyValue,i));if("string"!=typeof a)throw new Error(this.getSimpleItemError(s,this._simpleValueValue,a));r.set(i,a)}else if(void 0!==t&&void 0!==s){const i=t,a=s;for(const[t,s]of e){const e=this.parseSimpleItem(i,this._simpleKeyValue,t),n=this.parseSimpleItem(a,this._simpleValueValue,s);r.set(e,n)}}else for(const[i,a]of e)try{const e=void 0===t?this.keyValidator.parse(i):this.parseSimpleItem(t,this._simpleKeyValue,i),n=void 0===s?this.valueValidator.parse(a):this.parseSimpleItem(s,this._simpleValueValue,a);r.set(e,n)}catch(e){throw new Error(e.message)}for(const e of this._checks)if(!e.fn(r))throw new Error(e.message);return r}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:(r=e.message,new s([{code:"invalid_type",path:[],message:r}]))}}var r}min(e,r){return new VldMap(this.keyValidator,this.valueValidator,this.errorMessage,[...this._checks,{fn:r=>r.size>=e,message:r||`Map must contain at least ${e} entries`}])}max(e,r){return new VldMap(this.keyValidator,this.valueValidator,this.errorMessage,[...this._checks,{fn:r=>r.size<=e,message:r||`Map must contain at most ${e} entries`}])}size(e,r){return new VldMap(this.keyValidator,this.valueValidator,this.errorMessage,[...this._checks,{fn:r=>r.size===e,message:r||`Map must contain exactly ${e} entries`}])}nonempty(e){return this.min(1,e||"Map cannot be empty")}}export{VldMap};
+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-BU14-Dk8.js";class VldMap extends e{constructor(e,t,s,i=[]){super(r.MAP),this.keyValidator=e,this.valueValidator=t,this.errorMessage=s,this._checks=i,this._simpleKeyMode=this.getSimpleItemMode(e),this._simpleValueMode=this.getSimpleItemMode(t),this._simpleKeyValue="literal"===this._simpleKeyMode?e.literal:void 0,this._simpleValueValue="literal"===this._simpleValueMode?t.literal:void 0}get keySchema(){return this.keyValidator}get valueSchema(){return this.valueValidator}get keyType(){return this.keyValidator}get valueType(){return this.valueValidator}static create(e,r){return new VldMap(e,r)}getSimpleItemMode(e){if(!0===e.isSimple)switch(e.validatorType){case r.STRING:return"string";case r.NUMBER:return"number";case r.BOOLEAN:return"boolean";case r.BIGINT:return"bigint";case r.SYMBOL:return"symbol";case r.NULL:return"null";case r.UNDEFINED:case r.VOID:return"undefinedValue";case r.LITERAL:return"literal";case r.ANY:case r.UNKNOWN:return"passthrough";default:return}}getSimpleItemError(e,r,s){switch(e){case"string":return t().invalidString;case"number":return t().invalidNumber;case"boolean":return t().invalidBoolean;case"bigint":return t().invalidBigint;case"symbol":return t().invalidSymbol;case"null":return"Expected null, received "+typeof s;case"undefinedValue":return t().expectedUndefined;case"literal":return t().literalExpected(JSON.stringify(r),JSON.stringify(s));default:return t().invalidMap}}parseSimpleItem(e,r,t){switch(e){case"string":if("string"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"number":if("number"!=typeof t||isNaN(t))throw new Error(this.getSimpleItemError(e,r,t));return t;case"boolean":if("boolean"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"bigint":if("bigint"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"symbol":if("symbol"!=typeof t)throw new Error(this.getSimpleItemError(e,r,t));return t;case"null":if(null!==t)throw new Error(this.getSimpleItemError(e,r,t));return null;case"undefinedValue":if(void 0!==t)throw new Error(this.getSimpleItemError(e,r,t));return;case"literal":if(t!==r)throw new Error(this.getSimpleItemError(e,r,t));return r;case"passthrough":return t}}parse(e){if(!(e instanceof Map))throw new Error(this.errorMessage||t().invalidMap);return this.parseKnownMap(e)}parseKnownMap(e){const r=new Map,t=this._simpleKeyMode,s=this._simpleValueMode;if("string"===t&&"number"===s)for(const[i,a]of e){if("string"!=typeof i)throw new Error(this.getSimpleItemError(t,this._simpleKeyValue,i));if("number"!=typeof a||isNaN(a))throw new Error(this.getSimpleItemError(s,this._simpleValueValue,a));r.set(i,a)}else if("string"===t&&"string"===s)for(const[i,a]of e){if("string"!=typeof i)throw new Error(this.getSimpleItemError(t,this._simpleKeyValue,i));if("string"!=typeof a)throw new Error(this.getSimpleItemError(s,this._simpleValueValue,a));r.set(i,a)}else if(void 0!==t&&void 0!==s){const i=t,a=s;for(const[t,s]of e){const e=this.parseSimpleItem(i,this._simpleKeyValue,t),n=this.parseSimpleItem(a,this._simpleValueValue,s);r.set(e,n)}}else for(const[i,a]of e)try{const e=void 0===t?this.keyValidator.parse(i):this.parseSimpleItem(t,this._simpleKeyValue,i),n=void 0===s?this.valueValidator.parse(a):this.parseSimpleItem(s,this._simpleValueValue,a);r.set(e,n)}catch(e){throw new Error(e.message)}for(const e of this._checks)if(!e.fn(r))throw new Error(e.message);return r}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:(r=e.message,new s([{code:"invalid_type",path:[],message:r}]))}}var r}min(e,r){return new VldMap(this.keyValidator,this.valueValidator,this.errorMessage,[...this._checks,{fn:r=>r.size>=e,message:r||`Map must contain at least ${e} entries`}])}max(e,r){return new VldMap(this.keyValidator,this.valueValidator,this.errorMessage,[...this._checks,{fn:r=>r.size<=e,message:r||`Map must contain at most ${e} entries`}])}size(e,r){return new VldMap(this.keyValidator,this.valueValidator,this.errorMessage,[...this._checks,{fn:r=>r.size===e,message:r||`Map must contain exactly ${e} entries`}])}nonempty(e){return this.min(1,e||"Map cannot be empty")}}export{VldMap};

package/dist/validators/nan.js

@@ -1 +1 @@
-import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{V as s}from"../chunks/errors-core-CerMg2rq.js";class VldNan extends e{constructor(){super(r.NAN)}static create(){return new VldNan}parse(e){if("number"!=typeof e||!Number.isNaN(e))throw new Error("Expected NaN, received "+("number"==typeof e?"a valid number":typeof e));return e}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:(r=e.message,new s([{code:"invalid_number",path:[],message:r}]))}}var r}}export{VldNan};
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{V as s}from"../chunks/errors-core-BU14-Dk8.js";class VldNan extends e{constructor(){super(r.NAN)}static create(){return new VldNan}parse(e){if("number"!=typeof e||!Number.isNaN(e))throw new Error("Expected NaN, received "+("number"==typeof e?"a valid number":typeof e));return e}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:(r=e.message,new s([{code:"invalid_number",path:[],message:r}]))}}var r}}export{VldNan};

package/dist/validators/never.js

@@ -1 +1 @@
-import{VldBase as e}from"./base.js";import{getMessages as r}from"../locales/runtime.js";import{V as s}from"../chunks/errors-core-CerMg2rq.js";class VldNever extends e{static create(){return new VldNever}parse(e){throw new Error(r().neverType)}safeParse(e){return{success:!1,error:new s([{code:"invalid_type",path:[],message:r().neverType}])}}}export{VldNever};
+import{VldBase as e}from"./base.js";import{getMessages as r}from"../locales/runtime.js";import{V as s}from"../chunks/errors-core-BU14-Dk8.js";class VldNever extends e{static create(){return new VldNever}parse(e){throw new Error(r().neverType)}safeParse(e){return{success:!1,error:new s([{code:"invalid_type",path:[],message:r().neverType}])}}}export{VldNever};

package/dist/validators/null.js

@@ -1 +1 @@
-import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{V as s}from"../chunks/errors-core-CerMg2rq.js";class VldNull extends e{constructor(){super(r.NULL)}static create(){return new VldNull}get isSimple(){return!0}parse(e){if(null!==e)throw new Error("Expected null, received "+typeof e);return null}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:(r=e.message,new s([{code:"invalid_type",path:[],message:r}]))}}var r}}export{VldNull};
+import{VldBase as e,VLD_VALIDATOR_TYPES as r}from"./base.js";import{V as s}from"../chunks/errors-core-BU14-Dk8.js";class VldNull extends e{constructor(){super(r.NULL)}static create(){return new VldNull}get isSimple(){return!0}parse(e){if(null!==e)throw new Error("Expected null, received "+typeof e);return null}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:(r=e.message,new s([{code:"invalid_type",path:[],message:r}]))}}var r}}export{VldNull};

package/dist/validators/number-v2.d.ts

@@ -0,0 +1,252 @@
+/**
+ * VldNumberV2 — OPTIMIZED: check returns Issue | null, no per-call payload.
+ * Same public API as legacy VldNumber.
+ */
+import { VldBase, type ErrorParam, type ParseResult } from './base.js';
+import { type VldIssue } from '../errors-core.js';
+export declare abstract class VldNumberCheck {
+    abstract readonly kind: 'min' | 'max' | 'gt' | 'lt' | 'int' | 'finite' | 'safe' | 'multipleOf' | 'positive' | 'negative' | 'nonnegative' | 'nonpositive' | 'even' | 'odd' | 'uint32' | 'uint64' | 'int32' | 'int64' | 'float32' | 'float64';
+    abstract check(value: number): VldIssue | null;
+    abstract meta(): Record<string, any>;
+}
+export declare class VldNumberCheckMin extends VldNumberCheck {
+    readonly threshold: number;
+    private _msg?;
+    readonly kind: "min";
+    constructor(threshold: number, _msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        value: number;
+        inclusive: boolean;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckMax extends VldNumberCheck {
+    readonly threshold: number;
+    private _msg?;
+    readonly kind: "max";
+    constructor(threshold: number, _msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        value: number;
+        inclusive: boolean;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckGt extends VldNumberCheck {
+    readonly threshold: number;
+    private _msg?;
+    readonly kind: "gt";
+    constructor(threshold: number, _msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        value: number;
+        inclusive: boolean;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckLt extends VldNumberCheck {
+    readonly threshold: number;
+    private _msg?;
+    readonly kind: "lt";
+    constructor(threshold: number, _msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        value: number;
+        inclusive: boolean;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckInt extends VldNumberCheck {
+    private _msg?;
+    readonly kind: "int";
+    constructor(_msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckFinite extends VldNumberCheck {
+    private _msg?;
+    readonly kind: "finite";
+    constructor(_msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckSafe extends VldNumberCheck {
+    private _msg?;
+    readonly kind: "safe";
+    constructor(_msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckMultipleOf extends VldNumberCheck {
+    readonly divisor: number;
+    private _msg?;
+    readonly kind: "multipleOf";
+    constructor(divisor: number, _msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        value: number;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckRange extends VldNumberCheck {
+    readonly min: number;
+    readonly max: number;
+    private _msg?;
+    readonly kind: "min";
+    constructor(min: number, max: number, _msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        min: number;
+        max: number;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckEven extends VldNumberCheck {
+    private _msg?;
+    readonly kind: "even";
+    constructor(_msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckOdd extends VldNumberCheck {
+    private _msg?;
+    readonly kind: "odd";
+    constructor(_msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckUInt32 extends VldNumberCheck {
+    private _msg?;
+    readonly kind: "uint32";
+    constructor(_msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckUInt64 extends VldNumberCheck {
+    private _msg?;
+    readonly kind: "uint64";
+    constructor(_msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckInt32 extends VldNumberCheck {
+    private _msg?;
+    readonly kind: "int32";
+    constructor(_msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckInt64 extends VldNumberCheck {
+    private _msg?;
+    readonly kind: "int64";
+    constructor(_msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        message: string | undefined;
+    };
+}
+export declare class VldNumberCheckFloat32 extends VldNumberCheck {
+    private _msg?;
+    readonly kind: "float32";
+    constructor(_msg?: string | undefined);
+    check(value: number): VldIssue | null;
+    meta(): {
+        kind: string;
+        message: string | undefined;
+    };
+}
+export interface VldNumberDef {
+    readonly type: 'number';
+    readonly checks: ReadonlyArray<VldNumberCheck>;
+    readonly jsonSchema?: {
+        minimum?: number;
+        maximum?: number;
+        exclusiveMinimum?: number;
+        exclusiveMaximum?: number;
+        type?: 'integer' | 'number';
+        multipleOf?: number;
+        format?: string;
+    } | undefined;
+    readonly errorMessage?: string | undefined;
+    readonly isSimple: boolean;
+}
+export declare class VldNumberV2 extends VldBase<number, number> {
+    readonly __def: VldNumberDef;
+    constructor(def?: VldNumberDef);
+    static create(): VldNumberV2;
+    get isSimple(): boolean;
+    get hasCustomChecks(): boolean;
+    get minValue(): number | null;
+    get maxValue(): number | null;
+    get isInt(): boolean;
+    get isFinite(): boolean;
+    get getFormat(): string | null;
+    get isCoercion(): boolean;
+    parse(value: unknown): number;
+    parseKnownNumber(value: number): number;
+    safeParse(value: unknown): ParseResult<number>;
+    protected withDef(def: Partial<VldNumberDef> & {
+        type: 'number';
+    }): VldNumberV2;
+    min(value: number, message?: ErrorParam): VldNumberV2;
+    max(value: number, message?: ErrorParam): VldNumberV2;
+    int(message?: ErrorParam): VldNumberV2;
+    positive(message?: ErrorParam): VldNumberV2;
+    negative(message?: ErrorParam): VldNumberV2;
+    nonnegative(message?: ErrorParam): VldNumberV2;
+    nonpositive(message?: ErrorParam): VldNumberV2;
+    finite(message?: ErrorParam): VldNumberV2;
+    safe(message?: ErrorParam): VldNumberV2;
+    multipleOf(value: number, message?: ErrorParam): VldNumberV2;
+    step(value: number, message?: ErrorParam): VldNumberV2;
+    between(min: number, max: number, message?: ErrorParam): VldNumberV2;
+    even(message?: ErrorParam): VldNumberV2;
+    odd(message?: ErrorParam): VldNumberV2;
+    gt(value: number, message?: ErrorParam): VldNumberV2;
+    lt(value: number, message?: ErrorParam): VldNumberV2;
+    gte(value: number, message?: ErrorParam): VldNumberV2;
+    lte(value: number, message?: ErrorParam): VldNumberV2;
+    uint32(message?: ErrorParam): VldNumberV2;
+    uint64(message?: ErrorParam): VldNumberV2;
+    int32(message?: ErrorParam): VldNumberV2;
+    int64(message?: ErrorParam): VldNumberV2;
+    float32(message?: ErrorParam): VldNumberV2;
+    float64(message?: ErrorParam): VldNumberV2;
+}
+export declare class VldCoerceNumberV2 extends VldNumberV2 {
+    constructor(def?: VldNumberDef);
+    static create(): VldCoerceNumberV2;
+    parse(value: unknown): number;
+}

package/dist/validators/number-v2.js

@@ -0,0 +1 @@
+import{VLD_VALIDATOR_TYPES as e,VldBase as t,resolveErrorMessage as s}from"./base.js";import{V as r,c as i,g as n}from"../chunks/errors-core-BU14-Dk8.js";import{getMessages as m}from"../locales/runtime.js";class VldNumberCheck{}class VldNumberCheckMin extends VldNumberCheck{constructor(e,t){super(),this.threshold=e,this._msg=t,this.kind="min"}check(e){return e<this.threshold?{code:"too_small",path:[],origin:"number",minimum:this.threshold,inclusive:!0,message:this._msg||`Too small: expected number to be >=${this.threshold}`}:null}meta(){return{kind:"min",value:this.threshold,inclusive:!0,message:this._msg}}}class VldNumberCheckMax extends VldNumberCheck{constructor(e,t){super(),this.threshold=e,this._msg=t,this.kind="max"}check(e){return e>this.threshold?{code:"too_big",path:[],origin:"number",maximum:this.threshold,inclusive:!0,message:this._msg||`Too big: expected number to be <=${this.threshold}`}:null}meta(){return{kind:"max",value:this.threshold,inclusive:!0,message:this._msg}}}class VldNumberCheckGt extends VldNumberCheck{constructor(e,t){super(),this.threshold=e,this._msg=t,this.kind="gt"}check(e){return e<=this.threshold?{code:"too_small",path:[],origin:"number",minimum:this.threshold,inclusive:!1,message:this._msg||`Too small: expected number to be >${this.threshold}`}:null}meta(){return{kind:"gt",value:this.threshold,inclusive:!1,message:this._msg}}}class VldNumberCheckLt extends VldNumberCheck{constructor(e,t){super(),this.threshold=e,this._msg=t,this.kind="lt"}check(e){return e>=this.threshold?{code:"too_big",path:[],origin:"number",maximum:this.threshold,inclusive:!1,message:this._msg||`Too big: expected number to be <${this.threshold}`}:null}meta(){return{kind:"lt",value:this.threshold,inclusive:!1,message:this._msg}}}class VldNumberCheckInt extends VldNumberCheck{constructor(e){super(),this._msg=e,this.kind="int"}check(e){return Number.isInteger(e)?null:{code:"invalid_type",path:[],expected:"int",received:"number",message:this._msg||"Invalid input: expected int, received number"}}meta(){return{kind:"int",message:this._msg}}}class VldNumberCheckFinite extends VldNumberCheck{constructor(e){super(),this._msg=e,this.kind="finite"}check(e){return Number.isFinite(e)?null:{code:"custom",path:[],message:this._msg||"Number must be finite"}}meta(){return{kind:"finite",message:this._msg}}}class VldNumberCheckSafe extends VldNumberCheck{constructor(e){super(),this._msg=e,this.kind="safe"}check(e){return Number.isSafeInteger(e)?null:{code:"custom",path:[],message:this._msg||"Number must be a safe integer"}}meta(){return{kind:"safe",message:this._msg}}}class VldNumberCheckMultipleOf extends VldNumberCheck{constructor(e,t){super(),this.divisor=e,this._msg=t,this.kind="multipleOf"}check(e){const t=Math.abs(e%this.divisor);return t<Number.EPSILON||Math.abs(t-Math.abs(this.divisor))<Number.EPSILON?null:{code:"custom",path:[],message:this._msg||`Number must be a multiple of ${this.divisor}`}}meta(){return{kind:"multipleOf",value:this.divisor,message:this._msg}}}class VldNumberCheckRange extends VldNumberCheck{constructor(e,t,s){super(),this.min=e,this.max=t,this._msg=s,this.kind="min"}check(e){return e<this.min||e>this.max?{code:"custom",path:[],message:this._msg||`Number must be between ${this.min} and ${this.max}`}:null}meta(){return{kind:"range",min:this.min,max:this.max,message:this._msg}}}class VldNumberCheckEven extends VldNumberCheck{constructor(e){super(),this._msg=e,this.kind="even"}check(e){return Number.isInteger(e)&&e%2==0?null:{code:"custom",path:[],message:this._msg||"Number must be even"}}meta(){return{kind:"even",message:this._msg}}}class VldNumberCheckOdd extends VldNumberCheck{constructor(e){super(),this._msg=e,this.kind="odd"}check(e){return Number.isInteger(e)&&e%2!=0?null:{code:"custom",path:[],message:this._msg||"Number must be odd"}}meta(){return{kind:"odd",message:this._msg}}}class VldNumberCheckUInt32 extends VldNumberCheck{constructor(e){super(),this._msg=e,this.kind="uint32"}check(e){return!Number.isSafeInteger(e)||e<0||e>4294967295?{code:"custom",path:[],message:this._msg||"Expected an unsigned 32-bit integer"}:null}meta(){return{kind:"uint32",message:this._msg}}}class VldNumberCheckUInt64 extends VldNumberCheck{constructor(e){super(),this._msg=e,this.kind="uint64"}check(e){return!Number.isSafeInteger(e)||e<0?{code:"custom",path:[],message:this._msg||"Expected an unsigned 64-bit integer"}:null}meta(){return{kind:"uint64",message:this._msg}}}class VldNumberCheckInt32 extends VldNumberCheck{constructor(e){super(),this._msg=e,this.kind="int32"}check(e){return!Number.isSafeInteger(e)||e<-2147483648||e>2147483647?{code:"custom",path:[],message:this._msg||"Expected a signed 32-bit integer"}:null}meta(){return{kind:"int32",message:this._msg}}}class VldNumberCheckInt64 extends VldNumberCheck{constructor(e){super(),this._msg=e,this.kind="int64"}check(e){return Number.isSafeInteger(e)?null:{code:"custom",path:[],message:this._msg||"Expected a signed 64-bit integer"}}meta(){return{kind:"int64",message:this._msg}}}class VldNumberCheckFloat32 extends VldNumberCheck{constructor(e){super(),this._msg=e,this.kind="float32"}check(e){return!Number.isFinite(e)||Math.abs(e)>34e37?{code:"custom",path:[],message:this._msg||"Expected a 32-bit float"}:null}meta(){return{kind:"float32",message:this._msg}}}const h=Object.freeze({type:"number",checks:Object.freeze([]),isSimple:!0});class VldNumberV2 extends t{constructor(t=h){super(e.NUMBER),this.__def=t}static create(){return new VldNumberV2}get isSimple(){return this.__def.isSimple}get hasCustomChecks(){return!this.isSimple}get minValue(){const e=this.__def.jsonSchema;return e?.minimum??e?.exclusiveMinimum??null}get maxValue(){const e=this.__def.jsonSchema;return e?.maximum??e?.exclusiveMaximum??null}get isInt(){return"integer"===this.__def.jsonSchema?.type}get isFinite(){return!0}get getFormat(){return this.__def.jsonSchema?.format??null}get isCoercion(){return this.validatorType===e.COERCE_NUMBER}parse(e){if("number"!=typeof e||!Number.isFinite(e))throw new r([i("number",n(e),this.__def.errorMessage)]);return this.__def.isSimple?e:this.parseKnownNumber(e)}parseKnownNumber(e){const t=this.__def.checks;for(let s=0;s<t.length;s++){const i=t[s].check(e);if(null!==i)throw new r([i])}return e}safeParse(e){try{return{success:!0,data:this.parse(e)}}catch(e){return{success:!1,error:e instanceof r?e:new r([{code:"custom",path:[],message:String(e)}])}}}withDef(e){const t=(s=e.checks??this.__def.checks,r=e.jsonSchema??this.__def.jsonSchema,i=e.errorMessage??this.__def.errorMessage,Object.freeze({type:"number",checks:s,jsonSchema:r,errorMessage:i,isSimple:0===s.length}));var s,r,i;return new this.constructor(t)}min(e,t){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckMin(e,s(t,m().numberMin(e)))],jsonSchema:{...this.__def.jsonSchema,minimum:e},errorMessage:s(t,m().numberMin(e))})}max(e,t){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckMax(e,s(t,m().numberMax(e)))],jsonSchema:{...this.__def.jsonSchema,maximum:e},errorMessage:s(t,m().numberMax(e))})}int(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckInt(s(e,m().numberInt))],jsonSchema:{...this.__def.jsonSchema,type:"integer"},errorMessage:s(e,m().numberInt)})}positive(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckGt(0,s(e,m().numberPositive))],jsonSchema:{...this.__def.jsonSchema,exclusiveMinimum:0},errorMessage:s(e,m().numberPositive)})}negative(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckLt(0,s(e,m().numberNegative))],jsonSchema:{...this.__def.jsonSchema,exclusiveMaximum:0},errorMessage:s(e,m().numberNegative)})}nonnegative(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckMin(0,s(e,m().numberNonnegative))],jsonSchema:{...this.__def.jsonSchema,minimum:0},errorMessage:s(e,m().numberNonnegative)})}nonpositive(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckMax(0,s(e,m().numberNonpositive))],jsonSchema:{...this.__def.jsonSchema,maximum:0},errorMessage:s(e,m().numberNonpositive)})}finite(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckFinite(s(e,m().numberFinite))],errorMessage:s(e,m().numberFinite)})}safe(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckSafe(s(e,m().numberSafe))],jsonSchema:{...this.__def.jsonSchema,type:"integer"},errorMessage:s(e,m().numberSafe)})}multipleOf(e,t){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckMultipleOf(e,s(t,m().numberMultipleOf(e)))],jsonSchema:{...this.__def.jsonSchema,multipleOf:e},errorMessage:s(t,m().numberMultipleOf(e))})}step(e,t){return this.multipleOf(e,t)}between(e,t,r){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckRange(e,t,s(r,`Number must be between ${e} and ${t}`))],jsonSchema:{...this.__def.jsonSchema,minimum:e,maximum:t},errorMessage:s(r,`Number must be between ${e} and ${t}`)})}even(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckEven(s(e,"Number must be even"))],jsonSchema:{...this.__def.jsonSchema,type:"integer",multipleOf:2},errorMessage:s(e,"Number must be even")})}odd(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckOdd(s(e,"Number must be odd"))],jsonSchema:{...this.__def.jsonSchema,type:"integer"},errorMessage:s(e,"Number must be odd")})}gt(e,t){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckGt(e,s(t,`Number must be greater than ${e}`))],jsonSchema:{...this.__def.jsonSchema,exclusiveMinimum:e},errorMessage:s(t,`Number must be greater than ${e}`)})}lt(e,t){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckLt(e,s(t,`Number must be less than ${e}`))],jsonSchema:{...this.__def.jsonSchema,exclusiveMaximum:e},errorMessage:s(t,`Number must be less than ${e}`)})}gte(e,t){return this.min(e,t)}lte(e,t){return this.max(e,t)}uint32(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckUInt32(s(e,"Expected an unsigned 32-bit integer"))],jsonSchema:{...this.__def.jsonSchema,type:"integer",minimum:0,maximum:4294967295},errorMessage:s(e,"Expected an unsigned 32-bit integer")})}uint64(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckUInt64(s(e,"Expected an unsigned 64-bit integer"))],jsonSchema:{...this.__def.jsonSchema,type:"integer",minimum:0},errorMessage:s(e,"Expected an unsigned 64-bit integer")})}int32(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckInt32(s(e,"Expected a signed 32-bit integer"))],jsonSchema:{...this.__def.jsonSchema,type:"integer",minimum:-2147483648,maximum:2147483647},errorMessage:s(e,"Expected a signed 32-bit integer")})}int64(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckInt64(s(e,"Expected a signed 64-bit integer"))],jsonSchema:{...this.__def.jsonSchema,type:"integer"},errorMessage:s(e,"Expected a signed 64-bit integer")})}float32(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckFloat32(s(e,"Expected a 32-bit float"))],jsonSchema:{...this.__def.jsonSchema,minimum:-34e37,maximum:34e37},errorMessage:s(e,"Expected a 32-bit float")})}float64(e){return this.withDef({type:"number",checks:[...this.__def.checks,new VldNumberCheckFinite(s(e,"Expected a 64-bit float"))],errorMessage:s(e,"Expected a 64-bit float")})}}const c=Object.freeze({type:"number",checks:Object.freeze([]),isSimple:!0});class VldCoerceNumberV2 extends VldNumberV2{constructor(t=c){super(t),this.validatorType=e.COERCE_NUMBER}static create(){return new VldCoerceNumberV2}parse(e){let t;if("number"==typeof e)t=e;else if("string"==typeof e&&""!==e.trim()){const s=Number(e);if(Number.isNaN(s))throw new Error(m().coercionFailed("number",e));t=s}else if("boolean"==typeof e)t=e?1:0;else if("bigint"==typeof e){const s=Number(e);if(Number.isNaN(s))throw new Error(m().coercionFailed("number",e));t=s}else{if(null!==e)throw new Error(m().coercionFailed("number",e));t=0}if(!Number.isFinite(t))throw new Error(m().coercionFailed("number",e));return super.parse(t)}}export{VldCoerceNumberV2,VldNumberCheck,VldNumberCheckEven,VldNumberCheckFinite,VldNumberCheckFloat32,VldNumberCheckGt,VldNumberCheckInt,VldNumberCheckInt32,VldNumberCheckInt64,VldNumberCheckLt,VldNumberCheckMax,VldNumberCheckMin,VldNumberCheckMultipleOf,VldNumberCheckOdd,VldNumberCheckRange,VldNumberCheckSafe,VldNumberCheckUInt32,VldNumberCheckUInt64,VldNumberV2};

package/dist/validators/number.js

@@ -1 +1 @@
-import{VldBase as e,VLD_VALIDATOR_TYPES as s,resolveErrorMessage as i}from"./base.js";import{getMessages as n}from"../locales/runtime.js";import{V as t,c,g as r}from"../chunks/errors-core-CerMg2rq.js";class VldNumber extends e{constructor(e){super(e?.validatorType||s.NUMBER),this.config={checks:e?.checks||[],errorMessage:e?.errorMessage,jsonSchema:e?.jsonSchema,checkMetas:e?.checkMetas},this._checks=this.config.checks,this._isSimple=0===this._checks.length,this._fastCheckMode=this.detectFastCheckMode(),this._checkMetas=this.config.checkMetas}detectFastCheckMode(){const e=this.config.jsonSchema;return 0===this._checks.length?"none":1===this._checks.length&&0===e?.exclusiveMinimum&&"integer"!==e.type?"positive":2===this._checks.length&&0===e?.exclusiveMinimum&&"integer"===e.type?"positive-int":void 0}get hasCustomChecks(){return!this._isSimple}get isSimple(){return this._isSimple}get minValue(){return this.config.jsonSchema?.minimum??this.config.jsonSchema?.exclusiveMinimum??null}get maxValue(){return this.config.jsonSchema?.maximum??this.config.jsonSchema?.exclusiveMaximum??null}get isInt(){return"integer"===this.config.jsonSchema?.type}get isFinite(){return!0}get format(){return this.config.jsonSchema?.format??null}static create(){return new VldNumber}parse(e){if("number"!=typeof e||!Number.isFinite(e))throw new t([c("number",r(e),this.config.errorMessage)]);switch(this._fastCheckMode){case"none":return e;case"positive":if(e>0)return e;throw new t([this._createCheckIssue("gt",0,this.config.errorMessage)]);case"positive-int":if(e>0&&Number.isInteger(e))return e;throw new t([this._createCheckIssue("int",void 0,this.config.errorMessage)])}return this.parseKnownNumber(e)}_createCheckIssue(e,s,i){switch(e){case"min":return{code:"too_small",path:[],origin:"number",minimum:s,inclusive:!0,message:i||`Too small: expected number to be >=${s}`};case"max":return{code:"too_big",path:[],origin:"number",maximum:s,inclusive:!0,message:i||`Too big: expected number to be <=${s}`};case"gt":return{code:"too_small",path:[],origin:"number",minimum:s,inclusive:!1,message:i||`Too small: expected number to be >${s}`};case"lt":return{code:"too_big",path:[],origin:"number",maximum:s,inclusive:!1,message:i||`Too big: expected number to be <${s}`};case"int":return{code:"invalid_type",path:[],expected:"int",received:"number",message:i||"Invalid input: expected int, received number"};default:return{code:"custom",path:[],message:i||"Invalid number"}}}_findFailingCheck(e){const s=this._checks,i=this._checkMetas;for(let n=0;n<s.length;n++)if(!s[n](e))return i?.[n]??{kind:"other",message:this.config.errorMessage};return null}parseKnownNumber(e){switch(this._fastCheckMode){case"none":return e;case"positive":if(e>0)return e;throw new t([this._createCheckIssue("gt",0,this.config.errorMessage)]);case"positive-int":if(e>0&&Number.isInteger(e))return e;throw new t([this._createCheckIssue("int",void 0,this.config.errorMessage)])}const s=this._findFailingCheck(e);if(s)throw new t([this._createCheckIssue(s.kind,s.value,s.message)]);return e}safeParse(e){if("number"!=typeof e||!Number.isFinite(e))return{success:!1,error:new t([c("number",r(e),this.config.errorMessage)])};try{const s=this._findFailingCheck(e);if(s)return{success:!1,error:new t([this._createCheckIssue(s.kind,s.value,s.message)])}}catch(e){return e instanceof t?{success:!1,error:e}:{success:!1,error:new t([{code:"custom",path:[],message:e.message}])}}return{success:!0,data:e}}min(e,s){return new VldNumber({checks:[...this.config.checks,s=>s>=e],errorMessage:i(s,n().numberMin(e)),jsonSchema:{...this.config.jsonSchema,minimum:e},checkMetas:[...this.config.checkMetas??[],{kind:"min",value:e,inclusive:!0,message:i(s,n().numberMin(e))}]})}max(e,s){return new VldNumber({checks:[...this.config.checks,s=>s<=e],errorMessage:i(s,n().numberMax(e)),jsonSchema:{...this.config.jsonSchema,maximum:e},checkMetas:[...this.config.checkMetas??[],{kind:"max",value:e,inclusive:!0,message:i(s,n().numberMax(e))}]})}int(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isInteger(e)],errorMessage:i(e,n().numberInt),jsonSchema:{...this.config.jsonSchema,type:"integer"},checkMetas:[...this.config.checkMetas??[],{kind:"int",message:i(e,n().numberInt)}]})}positive(e){return new VldNumber({checks:[...this.config.checks,e=>e>0],errorMessage:i(e,n().numberPositive),jsonSchema:{...this.config.jsonSchema,exclusiveMinimum:0},checkMetas:[...this.config.checkMetas??[],{kind:"gt",value:0,inclusive:!1,message:i(e,n().numberPositive)}]})}negative(e){return new VldNumber({checks:[...this.config.checks,e=>e<0],errorMessage:i(e,n().numberNegative),jsonSchema:{...this.config.jsonSchema,exclusiveMaximum:0},checkMetas:[...this.config.checkMetas??[],{kind:"lt",value:0,inclusive:!1,message:i(e,n().numberNegative)}]})}nonnegative(e){return new VldNumber({checks:[...this.config.checks,e=>e>=0],errorMessage:i(e,n().numberNonnegative),jsonSchema:{...this.config.jsonSchema,minimum:0},checkMetas:[...this.config.checkMetas??[],{kind:"min",value:0,inclusive:!0,message:i(e,n().numberNonnegative)}]})}nonpositive(e){return new VldNumber({checks:[...this.config.checks,e=>e<=0],errorMessage:i(e,n().numberNonpositive),jsonSchema:{...this.config.jsonSchema,maximum:0},checkMetas:[...this.config.checkMetas??[],{kind:"max",value:0,inclusive:!0,message:i(e,n().numberNonpositive)}]})}finite(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isFinite(e)],errorMessage:i(e,n().numberFinite),jsonSchema:this.config.jsonSchema})}safe(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)],errorMessage:i(e,n().numberSafe),jsonSchema:{...this.config.jsonSchema,type:"integer"}})}multipleOf(e,s){return new VldNumber({checks:[...this.config.checks,s=>{const i=Math.abs(s%e);return i<Number.EPSILON||Math.abs(i-Math.abs(e))<Number.EPSILON}],errorMessage:i(s,n().numberMultipleOf(e)),jsonSchema:{...this.config.jsonSchema,multipleOf:e}})}step(e,s){return this.multipleOf(e,s)}between(e,s,n){return new VldNumber({checks:[...this.config.checks,i=>i>=e&&i<=s],errorMessage:i(n,`Number must be between ${e} and ${s}`),jsonSchema:{...this.config.jsonSchema,minimum:e,maximum:s}})}even(e){return new VldNumber({checks:[...this.config.checks,e=>!!Number.isInteger(e)&&e%2==0],errorMessage:i(e,"Number must be even"),jsonSchema:{...this.config.jsonSchema,type:"integer",multipleOf:2}})}odd(e){return new VldNumber({checks:[...this.config.checks,e=>!!Number.isInteger(e)&&e%2!=0],errorMessage:i(e,"Number must be odd"),jsonSchema:{...this.config.jsonSchema,type:"integer"}})}gt(e,s){return new VldNumber({checks:[...this.config.checks,s=>s>e],errorMessage:i(s,`Number must be greater than ${e}`),jsonSchema:{...this.config.jsonSchema,exclusiveMinimum:e},checkMetas:[...this.config.checkMetas??[],{kind:"gt",value:e,inclusive:!1,message:i(s,`Number must be greater than ${e}`)}]})}lt(e,s){return new VldNumber({checks:[...this.config.checks,s=>s<e],errorMessage:i(s,`Number must be less than ${e}`),jsonSchema:{...this.config.jsonSchema,exclusiveMaximum:e},checkMetas:[...this.config.checkMetas??[],{kind:"lt",value:e,inclusive:!1,message:i(s,`Number must be less than ${e}`)}]})}gte(e,s){return this.min(e,s)}lte(e,s){return this.max(e,s)}uint32(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)&&e>=0&&e<=4294967295],errorMessage:i(e,"Expected an unsigned 32-bit integer"),jsonSchema:{...this.config.jsonSchema,type:"integer",minimum:0,maximum:4294967295}})}uint64(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)&&e>=0],errorMessage:i(e,"Expected an unsigned 64-bit integer"),jsonSchema:{...this.config.jsonSchema,type:"integer",minimum:0}})}int32(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)&&e>=-2147483648&&e<=2147483647],errorMessage:i(e,"Expected a signed 32-bit integer"),jsonSchema:{...this.config.jsonSchema,type:"integer",minimum:-2147483648,maximum:2147483647}})}int64(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)],errorMessage:i(e,"Expected a signed 64-bit integer"),jsonSchema:{...this.config.jsonSchema,type:"integer"}})}float32(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isFinite(e)&&Math.abs(e)<=34e37],errorMessage:i(e,"Expected a 32-bit float"),jsonSchema:{...this.config.jsonSchema,minimum:-34e37,maximum:34e37}})}float64(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isFinite(e)],errorMessage:i(e,"Expected a 64-bit float"),jsonSchema:this.config.jsonSchema})}}export{VldNumber};
+import{VldBase as e,VLD_VALIDATOR_TYPES as s,resolveErrorMessage as i}from"./base.js";import{getMessages as n}from"../locales/runtime.js";import{V as t,c,g as r}from"../chunks/errors-core-BU14-Dk8.js";class VldNumber extends e{constructor(e){super(e?.validatorType||s.NUMBER),this.config={checks:e?.checks||[],errorMessage:e?.errorMessage,jsonSchema:e?.jsonSchema,checkMetas:e?.checkMetas},this._checks=this.config.checks,this._isSimple=0===this._checks.length,this._fastCheckMode=this.detectFastCheckMode(),this._checkMetas=this.config.checkMetas}detectFastCheckMode(){const e=this.config.jsonSchema;return 0===this._checks.length?"none":1===this._checks.length&&0===e?.exclusiveMinimum&&"integer"!==e.type?"positive":2===this._checks.length&&0===e?.exclusiveMinimum&&"integer"===e.type?"positive-int":void 0}get hasCustomChecks(){return!this._isSimple}get isSimple(){return this._isSimple}get minValue(){return this.config.jsonSchema?.minimum??this.config.jsonSchema?.exclusiveMinimum??null}get maxValue(){return this.config.jsonSchema?.maximum??this.config.jsonSchema?.exclusiveMaximum??null}get isInt(){return"integer"===this.config.jsonSchema?.type}get isFinite(){return!0}get format(){return this.config.jsonSchema?.format??null}static create(){return new VldNumber}parse(e){if("number"!=typeof e||!Number.isFinite(e))throw new t([c("number",r(e),this.config.errorMessage)]);switch(this._fastCheckMode){case"none":return e;case"positive":if(e>0)return e;throw new t([this._createCheckIssue("gt",0,this.config.errorMessage)]);case"positive-int":if(e>0&&Number.isInteger(e))return e;throw new t([this._createCheckIssue("int",void 0,this.config.errorMessage)])}return this.parseKnownNumber(e)}_createCheckIssue(e,s,i){switch(e){case"min":return{code:"too_small",path:[],origin:"number",minimum:s,inclusive:!0,message:i||`Too small: expected number to be >=${s}`};case"max":return{code:"too_big",path:[],origin:"number",maximum:s,inclusive:!0,message:i||`Too big: expected number to be <=${s}`};case"gt":return{code:"too_small",path:[],origin:"number",minimum:s,inclusive:!1,message:i||`Too small: expected number to be >${s}`};case"lt":return{code:"too_big",path:[],origin:"number",maximum:s,inclusive:!1,message:i||`Too big: expected number to be <${s}`};case"int":return{code:"invalid_type",path:[],expected:"int",received:"number",message:i||"Invalid input: expected int, received number"};default:return{code:"custom",path:[],message:i||"Invalid number"}}}_findFailingCheck(e){const s=this._checks,i=this._checkMetas;for(let n=0;n<s.length;n++)if(!s[n](e))return i?.[n]??{kind:"other",message:this.config.errorMessage};return null}parseKnownNumber(e){switch(this._fastCheckMode){case"none":return e;case"positive":if(e>0)return e;throw new t([this._createCheckIssue("gt",0,this.config.errorMessage)]);case"positive-int":if(e>0&&Number.isInteger(e))return e;throw new t([this._createCheckIssue("int",void 0,this.config.errorMessage)])}const s=this._findFailingCheck(e);if(s)throw new t([this._createCheckIssue(s.kind,s.value,s.message)]);return e}safeParse(e){if("number"!=typeof e||!Number.isFinite(e))return{success:!1,error:new t([c("number",r(e),this.config.errorMessage)])};try{const s=this._findFailingCheck(e);if(s)return{success:!1,error:new t([this._createCheckIssue(s.kind,s.value,s.message)])}}catch(e){return e instanceof t?{success:!1,error:e}:{success:!1,error:new t([{code:"custom",path:[],message:e.message}])}}return{success:!0,data:e}}min(e,s){return new VldNumber({checks:[...this.config.checks,s=>s>=e],errorMessage:i(s,n().numberMin(e)),jsonSchema:{...this.config.jsonSchema,minimum:e},checkMetas:[...this.config.checkMetas??[],{kind:"min",value:e,inclusive:!0,message:i(s,n().numberMin(e))}]})}max(e,s){return new VldNumber({checks:[...this.config.checks,s=>s<=e],errorMessage:i(s,n().numberMax(e)),jsonSchema:{...this.config.jsonSchema,maximum:e},checkMetas:[...this.config.checkMetas??[],{kind:"max",value:e,inclusive:!0,message:i(s,n().numberMax(e))}]})}int(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isInteger(e)],errorMessage:i(e,n().numberInt),jsonSchema:{...this.config.jsonSchema,type:"integer"},checkMetas:[...this.config.checkMetas??[],{kind:"int",message:i(e,n().numberInt)}]})}positive(e){return new VldNumber({checks:[...this.config.checks,e=>e>0],errorMessage:i(e,n().numberPositive),jsonSchema:{...this.config.jsonSchema,exclusiveMinimum:0},checkMetas:[...this.config.checkMetas??[],{kind:"gt",value:0,inclusive:!1,message:i(e,n().numberPositive)}]})}negative(e){return new VldNumber({checks:[...this.config.checks,e=>e<0],errorMessage:i(e,n().numberNegative),jsonSchema:{...this.config.jsonSchema,exclusiveMaximum:0},checkMetas:[...this.config.checkMetas??[],{kind:"lt",value:0,inclusive:!1,message:i(e,n().numberNegative)}]})}nonnegative(e){return new VldNumber({checks:[...this.config.checks,e=>e>=0],errorMessage:i(e,n().numberNonnegative),jsonSchema:{...this.config.jsonSchema,minimum:0},checkMetas:[...this.config.checkMetas??[],{kind:"min",value:0,inclusive:!0,message:i(e,n().numberNonnegative)}]})}nonpositive(e){return new VldNumber({checks:[...this.config.checks,e=>e<=0],errorMessage:i(e,n().numberNonpositive),jsonSchema:{...this.config.jsonSchema,maximum:0},checkMetas:[...this.config.checkMetas??[],{kind:"max",value:0,inclusive:!0,message:i(e,n().numberNonpositive)}]})}finite(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isFinite(e)],errorMessage:i(e,n().numberFinite),jsonSchema:this.config.jsonSchema})}safe(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)],errorMessage:i(e,n().numberSafe),jsonSchema:{...this.config.jsonSchema,type:"integer"}})}multipleOf(e,s){return new VldNumber({checks:[...this.config.checks,s=>{const i=Math.abs(s%e);return i<Number.EPSILON||Math.abs(i-Math.abs(e))<Number.EPSILON}],errorMessage:i(s,n().numberMultipleOf(e)),jsonSchema:{...this.config.jsonSchema,multipleOf:e}})}step(e,s){return this.multipleOf(e,s)}between(e,s,n){return new VldNumber({checks:[...this.config.checks,i=>i>=e&&i<=s],errorMessage:i(n,`Number must be between ${e} and ${s}`),jsonSchema:{...this.config.jsonSchema,minimum:e,maximum:s}})}even(e){return new VldNumber({checks:[...this.config.checks,e=>!!Number.isInteger(e)&&e%2==0],errorMessage:i(e,"Number must be even"),jsonSchema:{...this.config.jsonSchema,type:"integer",multipleOf:2}})}odd(e){return new VldNumber({checks:[...this.config.checks,e=>!!Number.isInteger(e)&&e%2!=0],errorMessage:i(e,"Number must be odd"),jsonSchema:{...this.config.jsonSchema,type:"integer"}})}gt(e,s){return new VldNumber({checks:[...this.config.checks,s=>s>e],errorMessage:i(s,`Number must be greater than ${e}`),jsonSchema:{...this.config.jsonSchema,exclusiveMinimum:e},checkMetas:[...this.config.checkMetas??[],{kind:"gt",value:e,inclusive:!1,message:i(s,`Number must be greater than ${e}`)}]})}lt(e,s){return new VldNumber({checks:[...this.config.checks,s=>s<e],errorMessage:i(s,`Number must be less than ${e}`),jsonSchema:{...this.config.jsonSchema,exclusiveMaximum:e},checkMetas:[...this.config.checkMetas??[],{kind:"lt",value:e,inclusive:!1,message:i(s,`Number must be less than ${e}`)}]})}gte(e,s){return this.min(e,s)}lte(e,s){return this.max(e,s)}uint32(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)&&e>=0&&e<=4294967295],errorMessage:i(e,"Expected an unsigned 32-bit integer"),jsonSchema:{...this.config.jsonSchema,type:"integer",minimum:0,maximum:4294967295}})}uint64(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)&&e>=0],errorMessage:i(e,"Expected an unsigned 64-bit integer"),jsonSchema:{...this.config.jsonSchema,type:"integer",minimum:0}})}int32(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)&&e>=-2147483648&&e<=2147483647],errorMessage:i(e,"Expected a signed 32-bit integer"),jsonSchema:{...this.config.jsonSchema,type:"integer",minimum:-2147483648,maximum:2147483647}})}int64(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isSafeInteger(e)],errorMessage:i(e,"Expected a signed 64-bit integer"),jsonSchema:{...this.config.jsonSchema,type:"integer"}})}float32(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isFinite(e)&&Math.abs(e)<=34e37],errorMessage:i(e,"Expected a 32-bit float"),jsonSchema:{...this.config.jsonSchema,minimum:-34e37,maximum:34e37}})}float64(e){return new VldNumber({checks:[...this.config.checks,e=>Number.isFinite(e)],errorMessage:i(e,"Expected a 64-bit float"),jsonSchema:this.config.jsonSchema})}}export{VldNumber};

package/dist/validators/object-v2.d.ts

@@ -0,0 +1,40 @@
+/**
+ * VldObjectV2 — Analysis and decision document
+ *
+ * After detailed analysis of VldObject (1071 lines, 10 own properties, all
+ * precomputed internal arrays for fast-path dispatch), the V2 single-def
+ * pattern does NOT yield memory wins for composite validators. Here's why:
+ *
+ *   - The V2 pattern saves memory by collapsing duplicated data
+ *     (`config` + `_checks` + `_transforms` + `_isSimple` + `_checkMetas`)
+ *     into a single `__def` object.
+ *   - VldObject has NO duplicated data — it has 10 distinct internal arrays
+ *     (shapeKeys, validators, validatorTypes, simpleFieldModes, ...), each
+ *     serving a unique fast-path purpose.
+ *   - A "VldObjectV2" wrapper that holds both a `__def` AND a VldObject
+ *     child would have 2+10=12 own properties — WORSE than the legacy.
+ *
+ * The real Zod 4.5 9.8x win on `z.object()` came from a fundamentally
+ * different data layout: a single `def = {type, shape, ...}` object shared
+ * across all chained variants, plus bound methods. Replicating that for
+ * VldObject would require rewriting the entire fast-path dispatch logic
+ * (1071 lines) into a def-based representation — a multi-day refactor with
+ * uncertain return.
+ *
+ * Decision (Faz 4): VldObject, VldArray, VldUnion remain in their legacy
+ * form. The composite-side memory benefit from the V2 pattern is below
+ * noise. The ~38% wins we observed come from using VldStringV2/VldNumberV2
+ * as the children of VldObject — that's where the savings live.
+ *
+ * The composite itself is not refactored. Only its child primitive types
+ * get the V2 treatment.
+ *
+ * If you really need to push composites, the next step would be:
+ *   1. Move the precomputed arrays into a single shared `__def` object
+ *   2. Replace per-instance fields with getter accessors on `__def`
+ *   3. Use lazy memoization for keys that are only computed once
+ *
+ * That's a 3-5 day refactor of VldObject with ~10-20% expected win, much
+ * smaller than the 38% we got from primitive V2.
+ */
+export {};

package/dist/validators/object-v2.js

@@ -0,0 +1 @@
+