@zipbul/baker 5.0.0 → 5.2.0

package/dist/src/metadata/interfaces.d.ts

@@ -0,0 +1,90 @@
+import type { ClassCtor } from '../common';
+import type { InternalRule } from '../rules';
+import type { TransformFunction } from '../transformers';
+import type { CollectionType } from './enums';
+/** Arguments for user-defined message callback */
+export interface MessageArgs {
+    property: string;
+    value: unknown;
+    constraints: Record<string, unknown>;
+}
+export interface RuleDef {
+    rule: InternalRule;
+    each?: boolean;
+    groups?: string[];
+    /** Value to include in BakerIssue.message on validation failure */
+    message?: string | ((args: MessageArgs) => string);
+    /** Arbitrary value to include in BakerIssue.context on validation failure */
+    context?: unknown;
+}
+export interface TransformDef {
+    fn: TransformFunction;
+    isAsync?: boolean;
+    options?: {
+        groups?: string[];
+        deserializeOnly?: boolean;
+        serializeOnly?: boolean;
+    };
+}
+export interface ExposeDef {
+    name?: string;
+    groups?: string[];
+    deserializeOnly?: boolean;
+    serializeOnly?: boolean;
+}
+export interface ExcludeDef {
+    deserializeOnly?: boolean;
+    serializeOnly?: boolean;
+}
+/** A polymorphic discriminator subtype mapping — a class constructor keyed by its wire name. */
+export interface DiscriminatorSubType {
+    value: ClassCtor;
+    name: string;
+}
+/** Polymorphic discriminator config — shared single source between @Field options and the IR TypeDef. */
+export interface DiscriminatorDef {
+    property: string;
+    subTypes: DiscriminatorSubType[];
+}
+export interface TypeDef {
+    fn: () => ClassCtor | ClassCtor[] | MapConstructor | SetConstructor;
+    discriminator?: DiscriminatorDef;
+    keepDiscriminatorProperty?: boolean;
+    /** seal-time normalization result — true if fn() returns an array */
+    isArray?: boolean;
+    /** seal-time normalization result — cached class after resolving fn() (DTOs only, excluding primitives) */
+    resolvedClass?: ClassCtor;
+    /** seal-time normalization result — Map or Set collection type */
+    collection?: CollectionType;
+    /** Nested DTO class thunk for Map value / Set element */
+    collectionValue?: () => ClassCtor;
+    /** seal-time normalization result — cached class after resolving collectionValue */
+    resolvedCollectionValue?: ClassCtor;
+}
+export interface PropertyFlags {
+    /** `@Field({ optional })` — skip all validation when undefined/null */
+    isOptional?: boolean;
+    /** `@Field({ nullable })` — allow and assign null, reject undefined */
+    isNullable?: boolean;
+    /** `@Field({ when })` — skip all field validation when the predicate returns false */
+    validateIf?: (obj: Record<string, unknown>) => boolean;
+    /** Seal-derived — trigger recursive validation for nested `@Field({ type })` DTOs */
+    validateNested?: boolean;
+    /** Seal-derived — validate nested DTOs per array element */
+    validateNestedEach?: boolean;
+}
+export interface RawPropertyMeta {
+    validation: RuleDef[];
+    transform: TransformDef[];
+    expose: ExposeDef[];
+    exclude: ExcludeDef | null;
+    type: TypeDef | null;
+    flags: PropertyFlags;
+    /** Field-level message applied to ALL failures of this field (gate/structural/required/conversion/rule) */
+    message?: string | ((args: MessageArgs) => string);
+    /** Field-level context attached to ALL failures of this field */
+    context?: unknown;
+}
+export interface RawClassMeta {
+    [propertyKey: string]: RawPropertyMeta;
+}

package/dist/src/metadata/meta-store.d.ts

@@ -0,0 +1,49 @@
+import type { RawClassMeta, RawPropertyMeta } from './interfaces';
+import type { MetaObject } from './types';
+import { RAW } from '../symbols';
+/**
+ * The single boundary that bridges symbol-keyed decorator metadata to typed RAW metadata. All RAW
+ * access goes through this one process-wide `metaStore` instance (and, for the seal pipeline, an
+ * injected reference) — no other module touches `Class[Symbol.metadata][this.#rawKey]` directly. The private
+ * `#metaOf`/`#ensureOwnMeta` methods are the actual encapsulation; `RAW` itself is process-global
+ * (`Symbol.for('baker:raw')`), so the value of consolidating access here is one access protocol, not
+ * a "private symbol".
+ *
+ * RAW lives on the TC39 decorator metadata object (`Class[Symbol.metadata][this.#rawKey]`) — where modern field
+ * decorators can write (they receive `context.metadata`, never the class). Sealed executors live in
+ * each Baker's own map, never on the class.
+ */
+declare class MetaStore {
+    #private;
+    constructor(rawKey?: typeof RAW);
+    get(cls: Function): RawClassMeta | undefined;
+    /**
+     * Test-only: like {@link get} but throws if the class has no @Field decorators. Specs use it to
+     * assert metadata presence; production reads go through {@link get}/{@link hasOwn}.
+     */
+    require(cls: Function): RawClassMeta;
+    /**
+     * Test-only: inject RAW metadata directly, bypassing the @Field decorator path. The seal-pipeline
+     * specs use this to author DTOs programmatically; production metadata is written via {@link ensure}.
+     */
+    set(cls: Function, raw: RawClassMeta): void;
+    /** Test-only: drop a class's own RAW slot so specs can reset state between cases. */
+    delete(cls: Function): void;
+    /**
+     * True only when cls has its OWN RAW slot. A subclass without its own @Field decorators resolves
+     * `Class[Symbol.metadata]` to the parent's metadata via the class prototype chain; the dual own-check
+     * keeps inheritance merging from double-counting inherited fields.
+     */
+    hasOwn(cls: Function): boolean;
+    /**
+     * The RawPropertyMeta for `key` on a decorator metadata object — creating the RAW slot and the
+     * per-key default meta if absent. Called by @Field, which receives `context.metadata`.
+     *
+     * The own-RAW check is required: a subclass's metadata inherits the parent's RAW via the metadata
+     * prototype chain, so a bare assignment would pollute the parent. A fresh own RAW (null prototype)
+     * keeps child fields isolated.
+     */
+    ensure(metadata: MetaObject, key: string): RawPropertyMeta;
+}
+export { MetaStore };
+export declare const metaStore: MetaStore;

package/dist/src/metadata/meta-store.js

@@ -0,0 +1 @@
+class MetaStore{#z;constructor(z=I){this.#z=z}#D(z){return z[Symbol.metadata]??void 0}#G(z){if(!Object.hasOwn(z,Symbol.metadata))Object.defineProperty(z,Symbol.metadata,{value:{},writable:!0,configurable:!0,enumerable:!1});return z[Symbol.metadata]}get(z){return this.#D(z)?.[this.#z]}require(z){const D=this.get(z);if(D===void 0)throw new H(`${z.name||"<anonymous>"}: class has no @Field decorators`);return D}set(z,D){this.#G(z)[this.#z]=D}delete(z){if(Object.hasOwn(z,Symbol.metadata))delete z[Symbol.metadata][this.#z]}hasOwn(z){if(!Object.hasOwn(z,Symbol.metadata))return!1;const D=z[Symbol.metadata];return D!=null&&Object.hasOwn(D,this.#z)}ensure(z,D){if(!Object.hasOwn(z,this.#z))z[this.#z]=Object.create(null);const G=z[this.#z];return G[D]??={validation:[],transform:[],expose:[],exclude:null,type:null,flags:{}}}}import{BakerError as H}from"../common/index.js";import{RAW as I}from"../symbols.js";export{MetaStore};export const metaStore=new MetaStore;

package/dist/src/metadata/types.d.ts

@@ -0,0 +1,10 @@
+import type { RawClassMeta } from './interfaces';
+import { RAW } from '../symbols';
+/** The TC39 decorator-metadata object that carries the baker RAW slot (`Class[Symbol.metadata]`). */
+export type MetaObject = Record<PropertyKey, unknown> & {
+    [RAW]?: RawClassMeta;
+};
+/** A class (constructor) viewed as a carrier of decorator metadata. */
+export type MetaCarrier = Function & {
+    [Symbol.metadata]?: MetaObject | null;
+};

package/dist/src/rules/array.d.ts

@@ -1,8 +1,8 @@
-import type { EmittableRule } from '../types';
+import type { EmittableRule } from './interfaces';
 declare function arrayContains(values: unknown[]): EmittableRule;
 declare function arrayNotContains(values: unknown[]): EmittableRule;
 declare function arrayMinSize(min: number): EmittableRule;
 declare function arrayMaxSize(max: number): EmittableRule;
 declare function arrayUnique(identifier?: (val: unknown) => unknown): EmittableRule;
-declare const arrayNotEmpty: import("../types").InternalRule;
+declare const arrayNotEmpty: import("./interfaces").InternalRule;
 export { arrayContains, arrayNotContains, arrayMinSize, arrayMaxSize, arrayUnique, arrayNotEmpty };

package/dist/src/rules/array.js

@@ -1 +1 @@
-import{CacheKey as D,RequiredType as A,RuleOp as F}from"../enums.js";import{makePlannedRule as G,makeRule as H,planCompare as I,planLength as J}from"../rule-plan.js";function arrayContains(b){return H({name:"arrayContains",requiresType:A.Array,constraints:{values:b},validate:(j)=>Array.isArray(j)&&b.every((w)=>j.includes(w)),emit:(j,w)=>{return`if (!refs[${w.addRef(b)}].every(function(v){return ${j}.includes(v);})) ${w.fail("arrayContains")};`}})}function arrayNotContains(b){return H({name:"arrayNotContains",requiresType:A.Array,constraints:{values:b},validate:(j)=>Array.isArray(j)&&b.every((w)=>!j.includes(w)),emit:(j,w)=>{return`if (refs[${w.addRef(b)}].some(function(v){return ${j}.includes(v);})) ${w.fail("arrayNotContains")};`}})}function arrayMinSize(b){const j={cacheKey:D.Length,failure:I(J(),F.Lt,b)};return G({name:"arrayMinSize",requiresType:A.Array,constraints:{min:b},plan:j,validate:(w)=>Array.isArray(w)&&w.length>=b})}function arrayMaxSize(b){const j={cacheKey:D.Length,failure:I(J(),F.Gt,b)};return G({name:"arrayMaxSize",requiresType:A.Array,constraints:{max:b},plan:j,validate:(w)=>Array.isArray(w)&&w.length<=b})}function arrayUnique(b){return H({name:"arrayUnique",requiresType:A.Array,constraints:{},validate:(j)=>{if(!Array.isArray(j))return!1;if(b){const w=j.map(b);return new Set(w).size===w.length}return new Set(j).size===j.length},emit:(j,w)=>{if(b){const B=w.addRef(b);return`{var keys=${j}.map(refs[${B}]);if(new Set(keys).size!==keys.length)${w.fail("arrayUnique")};}`}return`if(new Set(${j}).size!==${j}.length)${w.fail("arrayUnique")};`}})}const Q={cacheKey:D.Length,failure:I(J(),F.Eq,0)};const arrayNotEmpty=G({name:"arrayNotEmpty",requiresType:A.Array,constraints:{},plan:Q,validate:(b)=>Array.isArray(b)&&b.length>0});export{arrayContains,arrayNotContains,arrayMinSize,arrayMaxSize,arrayUnique,arrayNotEmpty};
+import{CacheKey as D}from"../common/index.js";import{RequiredType as A,RuleOp as F}from"./enums.js";import{makePlannedRule as G,makeRule as H,planCompare as I,planLength as J}from"./rule-plan.js";function arrayContains(b){return H({name:"arrayContains",requiresType:A.Array,constraints:{values:b},validate:(j)=>Array.isArray(j)&&b.every((w)=>j.includes(w)),emit:(j,w)=>{return`if (!refs[${w.addRef(b)}].every(function(v){return ${j}.includes(v);})) ${w.fail("arrayContains")};`}})}function arrayNotContains(b){return H({name:"arrayNotContains",requiresType:A.Array,constraints:{values:b},validate:(j)=>Array.isArray(j)&&b.every((w)=>!j.includes(w)),emit:(j,w)=>{return`if (refs[${w.addRef(b)}].some(function(v){return ${j}.includes(v);})) ${w.fail("arrayNotContains")};`}})}function arrayMinSize(b){const j={cacheKey:D.Length,failure:I(J(),F.Lt,b)};return G({name:"arrayMinSize",requiresType:A.Array,constraints:{min:b},plan:j,validate:(w)=>Array.isArray(w)&&w.length>=b})}function arrayMaxSize(b){const j={cacheKey:D.Length,failure:I(J(),F.Gt,b)};return G({name:"arrayMaxSize",requiresType:A.Array,constraints:{max:b},plan:j,validate:(w)=>Array.isArray(w)&&w.length<=b})}function arrayUnique(b){return H({name:"arrayUnique",requiresType:A.Array,constraints:{},validate:(j)=>{if(!Array.isArray(j))return!1;if(b){const w=j.map(b);return new Set(w).size===w.length}return new Set(j).size===j.length},emit:(j,w)=>{if(b){const B=w.addRef(b);return`{var keys=${j}.map(refs[${B}]);if(new Set(keys).size!==keys.length)${w.fail("arrayUnique")};}`}return`if(new Set(${j}).size!==${j}.length)${w.fail("arrayUnique")};`}})}const Q={cacheKey:D.Length,failure:I(J(),F.Eq,0)};const arrayNotEmpty=G({name:"arrayNotEmpty",requiresType:A.Array,constraints:{},plan:Q,validate:(b)=>Array.isArray(b)&&b.length>0});export{arrayContains,arrayNotContains,arrayMinSize,arrayMaxSize,arrayUnique,arrayNotEmpty};

package/dist/src/rules/binary.d.ts

@@ -1,3 +1,3 @@
-import type { EmittableRule } from '../types';
-export declare const isUint8Array: import("../types").InternalRule;
+import type { EmittableRule } from './interfaces';
+export declare const isUint8Array: import("./interfaces").InternalRule;
 export declare function isByteSize(min: number, max?: number): EmittableRule;

package/dist/src/rules/binary.js

@@ -1,3 +1,3 @@
-import{makeRule as A}from"../rule-plan.js";export const isUint8Array=A({name:"isUint8Array",constraints:{},validate:(f)=>f instanceof Uint8Array,emit:(f,j)=>`if (!(${f} instanceof Uint8Array)) ${j.fail("isUint8Array")};`});export function isByteSize(f,j){return A({name:"isByteSize",constraints:{min:f,max:j},validate:(q)=>{if(!ArrayBuffer.isView(q))return!1;const w=q.byteLength;if(w<f)return!1;if(j!==void 0&&w>j)return!1;return!0},emit:(q,w)=>{let z=`if (!ArrayBuffer.isView(${q})) ${w.fail("isByteSize")};`;z+=`
+import{makeRule as A}from"./rule-plan.js";export const isUint8Array=A({name:"isUint8Array",constraints:{},validate:(f)=>f instanceof Uint8Array,emit:(f,j)=>`if (!(${f} instanceof Uint8Array)) ${j.fail("isUint8Array")};`});export function isByteSize(f,j){return A({name:"isByteSize",constraints:j!==void 0?{min:f,max:j}:{min:f},validate:(q)=>{if(!ArrayBuffer.isView(q))return!1;const w=q.byteLength;if(w<f)return!1;if(j!==void 0&&w>j)return!1;return!0},emit:(q,w)=>{let z=`if (!ArrayBuffer.isView(${q})) ${w.fail("isByteSize")};`;z+=`
 else if (${q}.byteLength < ${f}) ${w.fail("isByteSize")};`;if(j!==void 0)z+=`
 else if (${q}.byteLength > ${j}) ${w.fail("isByteSize")};`;return z}})}

package/dist/src/rules/combinators.d.ts

@@ -1,4 +1,4 @@
-import type { EmittableRule } from '../types';
+import type { EmittableRule } from './interfaces';
 declare function oneOf(...branches: EmittableRule[]): EmittableRule;
 declare function arrayEvery(...rules: EmittableRule[]): EmittableRule;
 export { oneOf, arrayEvery };

package/dist/src/rules/combinators.js

@@ -1 +1 @@
-import{BakerError as H}from"../errors.js";import{makeRule as F}from"../rule-plan.js";function J(q,D){if(typeof q==="function"&&typeof q.emit==="function"&&typeof q.ruleName==="string")return;throw new H(`${D}: every argument must be a baker rule (function with .emit and .ruleName). Use createRule() or import a rule from @zipbul/baker/rules.`)}function oneOf(...q){if(q.length===0)throw new H("oneOf requires at least one rule.");for(const z of q)J(z,"oneOf");const D={oneOf:q.map((z)=>z.ruleName)};if(q.some((z)=>z.isAsync===!0)){const z=async(j)=>{for(const w of q)if(await w(j))return!0;return!1};return F({name:"oneOf",constraints:D,isAsync:!0,validate:z,emit:(j,w)=>{return`if (!(await refs[${w.addRef(z)}](${j}))) ${w.fail("oneOf")};`}})}return F({name:"oneOf",constraints:D,validate:(z)=>q.some((j)=>j(z)),emit:(z,j)=>{return`if (!(${q.map((C)=>`refs[${j.addRef(C)}](${z})`).join(" || ")})) ${j.fail("oneOf")};`}})}function arrayEvery(...q){if(q.length===0)throw new H("arrayEvery requires at least one rule.");for(const j of q)J(j,"arrayEvery");const D={arrayEvery:q.map((j)=>j.ruleName)};if(q.some((j)=>j.isAsync===!0)){const j=async(w)=>{if(!Array.isArray(w))return!1;for(const C of w)for(const I of q)if(!await I(C))return!1;return!0};return F({name:"arrayEvery",constraints:D,isAsync:!0,validate:j,emit:(w,C)=>{return`if (!(await refs[${C.addRef(j)}](${w}))) ${C.fail("arrayEvery")};`}})}const G=(j)=>q.every((w)=>w(j));return F({name:"arrayEvery",constraints:D,validate:(j)=>Array.isArray(j)&&j.every(G),emit:(j,w)=>{const C=w.addRef(G);return`if (!(Array.isArray(${j}) && ${j}.every(refs[${C}]))) ${w.fail("arrayEvery")};`}})}export{oneOf,arrayEvery};
+import{BakerError as I}from"../common/index.js";import{makeRule as D}from"./rule-plan.js";function oneOf(...q){if(q.length===0)throw new I("oneOf requires at least one rule.");const C={oneOf:q.map((z)=>z.ruleName)};if(q.some((z)=>z.isAsync===!0)){const z=async(g)=>{for(const j of q)if(await j(g))return!0;return!1};return D({name:"oneOf",constraints:C,isAsync:!0,validate:z,emit:(g,j)=>{return`if (!(await refs[${j.addRef(z)}](${g}))) ${j.fail("oneOf")};`}})}const F=q;return D({name:"oneOf",constraints:C,validate:(z)=>F.some((g)=>g(z)),emit:(z,g)=>{return`if (!(${q.map((A)=>`refs[${g.addRef(A)}](${z})`).join(" || ")})) ${g.fail("oneOf")};`}})}function arrayEvery(...q){if(q.length===0)throw new I("arrayEvery requires at least one rule.");const C={arrayEvery:q.map((g)=>g.ruleName)};if(q.some((g)=>g.isAsync===!0)){const g=async(j)=>{if(!Array.isArray(j))return!1;for(const A of j)for(const H of q)if(!await H(A))return!1;return!0};return D({name:"arrayEvery",constraints:C,isAsync:!0,validate:g,emit:(j,A)=>{return`if (!(await refs[${A.addRef(g)}](${j}))) ${A.fail("arrayEvery")};`}})}const F=q,G=(g)=>F.every((j)=>j(g));return D({name:"arrayEvery",constraints:C,validate:(g)=>Array.isArray(g)&&g.every(G),emit:(g,j)=>{const A=j.addRef(G);return`if (!(Array.isArray(${g}) && ${g}.every(refs[${A}]))) ${j.fail("arrayEvery")};`}})}export{oneOf,arrayEvery};

package/dist/src/rules/common.d.ts

@@ -1,7 +1,7 @@
-import type { EmittableRule } from '../types';
+import type { EmittableRule } from './interfaces';
 export declare function equals(comparison: unknown): EmittableRule;
 export declare function notEquals(comparison: unknown): EmittableRule;
-export declare const isEmpty: import("../types").InternalRule;
-export declare const isNotEmpty: import("../types").InternalRule;
+export declare const isEmpty: import("./interfaces").InternalRule;
+export declare const isNotEmpty: import("./interfaces").InternalRule;
 export declare function isIn(array: unknown[]): EmittableRule;
 export declare function isNotIn(array: unknown[]): EmittableRule;

package/dist/src/rules/common.js

@@ -1 +1 @@
-import{makeRule as h}from"../rule-plan.js";export function equals(b){return h({name:"equals",constraints:{value:b},validate:(d)=>d===b,emit:(d,f)=>{const g=f.addRef(b);return`if (${d} !== refs[${g}]) ${f.fail("equals")};`}})}export function notEquals(b){return h({name:"notEquals",constraints:{value:b},validate:(d)=>d!==b,emit:(d,f)=>{const g=f.addRef(b);return`if (${d} === refs[${g}]) ${f.fail("notEquals")};`}})}export const isEmpty=h({name:"isEmpty",constraints:{},validate:(b)=>b===void 0||b===null||b==="",emit:(b,d)=>`if (${b} !== undefined && ${b} !== null && ${b} !== '') ${d.fail("isEmpty")};`});export const isNotEmpty=h({name:"isNotEmpty",constraints:{},validate:(b)=>b!==void 0&&b!==null&&b!=="",emit:(b,d)=>`if (${b} === undefined || ${b} === null || ${b} === '') ${d.fail("isNotEmpty")};`});export function isIn(b){const d=new Set(b);return h({name:"isIn",constraints:{values:b},validate:(f)=>d.has(f),emit:(f,g)=>{return`if (!refs[${g.addRef(d)}].has(${f})) ${g.fail("isIn")};`}})}export function isNotIn(b){const d=new Set(b);return h({name:"isNotIn",constraints:{values:b},validate:(f)=>!d.has(f),emit:(f,g)=>{return`if (refs[${g.addRef(d)}].has(${f})) ${g.fail("isNotIn")};`}})}
+import{makeRule as h}from"./rule-plan.js";export function equals(b){return h({name:"equals",constraints:{value:b},validate:(d)=>d===b,emit:(d,f)=>{const g=f.addRef(b);return`if (${d} !== refs[${g}]) ${f.fail("equals")};`}})}export function notEquals(b){return h({name:"notEquals",constraints:{value:b},validate:(d)=>d!==b,emit:(d,f)=>{const g=f.addRef(b);return`if (${d} === refs[${g}]) ${f.fail("notEquals")};`}})}export const isEmpty=h({name:"isEmpty",constraints:{},validate:(b)=>b===void 0||b===null||b==="",emit:(b,d)=>`if (${b} !== undefined && ${b} !== null && ${b} !== '') ${d.fail("isEmpty")};`});export const isNotEmpty=h({name:"isNotEmpty",constraints:{},validate:(b)=>b!==void 0&&b!==null&&b!=="",emit:(b,d)=>`if (${b} === undefined || ${b} === null || ${b} === '') ${d.fail("isNotEmpty")};`});export function isIn(b){const d=new Set(b);return h({name:"isIn",constraints:{values:b},validate:(f)=>d.has(f),emit:(f,g)=>{return`if (!refs[${g.addRef(d)}].has(${f})) ${g.fail("isIn")};`}})}export function isNotIn(b){const d=new Set(b);return h({name:"isNotIn",constraints:{values:b},validate:(f)=>!d.has(f),emit:(f,g)=>{return`if (refs[${g.addRef(d)}].has(${f})) ${g.fail("isNotIn")};`}})}

package/dist/src/rules/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const IBAN_COUNTRY_LENGTH: Record<string, number>;
+export declare const ISO4217_CODES: Set<string>;
+export declare const ISO31661A2_CODES: Set<string>;
+export declare const ISO31661A3_CODES: Set<string>;
+export declare const HASH_REGEXES: Record<string, RegExp>;
+export declare const TAX_ID_REGEXES: Record<string, RegExp>;
+export declare const MOBILE_PHONE_REGEXES: Record<string, RegExp>;
+export declare const POSTAL_CODE_REGEXES: Record<string, RegExp>;
+export declare const IDENTITY_CARD_REGEXES: Record<string, RegExp>;
+export declare const PASSPORT_REGEXES: Record<string, RegExp>;

package/dist/src/rules/constants.js

@@ -0,0 +1 @@
+export const IBAN_COUNTRY_LENGTH={AD:24,AE:23,AL:28,AT:20,AZ:28,BA:20,BE:16,BG:22,BH:22,BR:29,CH:21,CR:22,CY:28,CZ:24,DE:22,DK:18,DO:28,EE:20,ES:24,FI:18,FO:18,FR:27,GB:22,GE:22,GI:23,GL:18,GR:27,GT:28,HR:21,HU:28,IE:22,IL:23,IS:26,IT:27,JO:30,KW:30,KZ:20,LB:28,LC:32,LI:21,LT:20,LU:20,LV:21,MC:27,MD:24,ME:22,MK:19,MR:27,MT:31,MU:30,NL:18,NO:15,PK:24,PL:28,PS:29,PT:25,QA:29,RO:24,RS:22,SA:24,SC:31,SE:24,SI:19,SK:24,SM:27,ST:25,SV:28,TL:23,TN:24,TR:26,UA:29,VA:22,VG:24,XK:20};export const ISO4217_CODES=new Set(["AED","AFN","ALL","AMD","ANG","AOA","ARS","AUD","AWG","AZN","BAM","BBD","BDT","BGN","BHD","BIF","BMD","BND","BOB","BOV","BRL","BSD","BTN","BWP","BYN","BZD","CAD","CDF","CHE","CHF","CHW","CLF","CLP","CNY","COP","COU","CRC","CUC","CUP","CVE","CZK","DJF","DKK","DOP","DZD","EGP","ERN","ETB","EUR","FJD","FKP","GBP","GEL","GHS","GIP","GMD","GNF","GTQ","GYD","HKD","HNL","HRK","HTG","HUF","IDR","ILS","INR","IQD","IRR","ISK","JMD","JOD","JPY","KES","KGS","KHR","KMF","KPW","KRW","KWD","KYD","KZT","LAK","LBP","LKR","LRD","LSL","LYD","MAD","MDL","MGA","MKD","MMK","MNT","MOP","MRU","MUR","MVR","MWK","MXN","MXV","MYR","MZN","NAD","NGN","NIO","NOK","NPR","NZD","OMR","PAB","PEN","PGK","PHP","PKR","PLN","PYG","QAR","RON","RSD","RUB","RWF","SAR","SBD","SCR","SDG","SEK","SGD","SHP","SLE","SLL","SOS","SRD","SSP","STN","SVC","SYP","SZL","THB","TJS","TMT","TND","TOP","TRY","TTD","TWD","TZS","UAH","UGX","USD","USN","UYI","UYU","UYW","UZS","VED","VES","VND","VUV","WST","XAF","XAG","XAU","XBA","XBB","XBC","XBD","XCD","XDR","XOF","XPD","XPF","XPT","XSU","XTS","XUA","YER","ZAR","ZMW","ZWL"]);export const ISO31661A2_CODES=new Set(["AD","AE","AF","AG","AI","AL","AM","AO","AQ","AR","AS","AT","AU","AW","AX","AZ","BA","BB","BD","BE","BF","BG","BH","BI","BJ","BL","BM","BN","BO","BQ","BR","BS","BT","BV","BW","BY","BZ","CA","CC","CD","CF","CG","CH","CI","CK","CL","CM","CN","CO","CR","CU","CV","CW","CX","CY","CZ","DE","DJ","DK","DM","DO","DZ","EC","EE","EG","EH","ER","ES","ET","FI","FJ","FK","FM","FO","FR","GA","GB","GD","GE","GF","GG","GH","GI","GL","GM","GN","GP","GQ","GR","GS","GT","GU","GW","GY","HK","HM","HN","HR","HT","HU","ID","IE","IL","IM","IN","IO","IQ","IR","IS","IT","JE","JM","JO","JP","KE","KG","KH","KI","KM","KN","KP","KR","KW","KY","KZ","LA","LB","LC","LI","LK","LR","LS","LT","LU","LV","LY","MA","MC","MD","ME","MF","MG","MH","MK","ML","MM","MN","MO","MP","MQ","MR","MS","MT","MU","MV","MW","MX","MY","MZ","NA","NC","NE","NF","NG","NI","NL","NO","NP","NR","NU","NZ","OM","PA","PE","PF","PG","PH","PK","PL","PM","PN","PR","PS","PT","PW","PY","QA","RE","RO","RS","RU","RW","SA","SB","SC","SD","SE","SG","SH","SI","SJ","SK","SL","SM","SN","SO","SR","SS","ST","SV","SX","SY","SZ","TC","TD","TF","TG","TH","TJ","TK","TL","TM","TN","TO","TR","TT","TV","TW","TZ","UA","UG","UM","US","UY","UZ","VA","VC","VE","VG","VI","VN","VU","WF","WS","YE","YT","ZA","ZM","ZW"]);export const ISO31661A3_CODES=new Set(["ABW","AFG","AGO","AIA","ALA","ALB","AND","ARE","ARG","ARM","ASM","ATA","ATF","ATG","AUS","AUT","AZE","BDI","BEL","BEN","BES","BFA","BGD","BGR","BHR","BHS","BIH","BLM","BLR","BLZ","BMU","BOL","BRA","BRB","BRN","BTN","BVT","BWA","CAF","CAN","CCK","CHE","CHL","CHN","CIV","CMR","COD","COG","COK","COL","COM","CPV","CRI","CUB","CUW","CXR","CYM","CYP","CZE","DEU","DJI","DMA","DNK","DOM","DZA","ECU","EGY","ERI","ESH","ESP","EST","ETH","FIN","FJI","FLK","FRA","FRO","FSM","GAB","GBR","GEO","GGY","GHA","GIB","GIN","GLP","GMB","GNB","GNQ","GRC","GRD","GRL","GTM","GUF","GUM","GUY","HKG","HMD","HND","HRV","HTI","HUN","IDN","IMN","IND","IOT","IRL","IRN","IRQ","ISL","ISR","ITA","JAM","JEY","JOR","JPN","KAZ","KEN","KGZ","KHM","KIR","KNA","KOR","KWT","LAO","LBN","LBR","LBY","LCA","LIE","LKA","LSO","LTU","LUX","LVA","MAC","MAF","MAR","MCO","MDA","MDG","MDV","MEX","MHL","MKD","MLI","MLT","MMR","MNE","MNG","MNP","MOZ","MRT","MSR","MTQ","MUS","MWI","MYS","MYT","NAM","NCL","NER","NFK","NGA","NIC","NIU","NLD","NOR","NPL","NRU","NZL","OMN","PAK","PAN","PCN","PER","PHL","PLW","PNG","POL","PRI","PRK","PRT","PRY","PSE","PYF","QAT","REU","ROU","RUS","RWA","SAU","SDN","SEN","SGP","SGS","SHN","SJM","SLB","SLE","SLV","SMR","SOM","SPM","SRB","SSD","STP","SUR","SVK","SVN","SWE","SWZ","SXM","SYC","SYR","TCA","TCD","TGO","THA","TJK","TKL","TKM","TLS","TON","TTO","TUN","TUR","TUV","TWN","TZA","UGA","UKR","UMI","URY","USA","UZB","VAT","VCT","VEN","VGB","VIR","VNM","VUT","WLF","WSM","YEM","ZAF","ZMB","ZWE"]);export const HASH_REGEXES={md5:/^[a-f0-9]{32}$/i,md4:/^[a-f0-9]{32}$/i,md2:/^[a-f0-9]{32}$/i,sha1:/^[a-f0-9]{40}$/i,sha256:/^[a-f0-9]{64}$/i,sha384:/^[a-f0-9]{96}$/i,sha512:/^[a-f0-9]{128}$/i,ripemd128:/^[a-f0-9]{32}$/i,ripemd160:/^[a-f0-9]{40}$/i,"tiger128,3":/^[a-f0-9]{32}$/i,"tiger128,4":/^[a-f0-9]{32}$/i,"tiger160,3":/^[a-f0-9]{40}$/i,"tiger160,4":/^[a-f0-9]{40}$/i,"tiger192,3":/^[a-f0-9]{48}$/i,"tiger192,4":/^[a-f0-9]{48}$/i,crc32:/^[a-f0-9]{8}$/i,crc32b:/^[a-f0-9]{8}$/i};export const TAX_ID_REGEXES={US:/^\d{2}-\d{7}$/,KR:/^\d{3}-\d{2}-\d{5}$/,DE:/^\d{11}$/,FR:/^[0-9]{13}$/,GB:/^\d{10}$/,IT:/^[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]$/i,ES:/^[0-9A-Z]\d{7}[0-9A-Z]$/i,AU:/^\d{11}$/,CA:/^\d{9}$/,IN:/^[A-Z]{5}\d{4}[A-Z]$/i};export const MOBILE_PHONE_REGEXES={"ko-KR":/^(\+?82|0)1[016789]\d{7,8}$/,"en-US":/^\+?1?[2-9]\d{2}[2-9]\d{6}$/,"zh-CN":/^(\+?86)?1[3-9]\d{9}$/,"zh-TW":/^(\+?886)?9\d{8}$/,"ja-JP":/^(\+?81)?0?[789]0[0-9]{8}$/,"de-DE":/^(\+?49)?1(5\d|6[0-9]|7[0-9])\d{8}$/,"fr-FR":/^(\+?33)?[67]\d{8}$/,"en-GB":/^(\+?44)?7[1-9]\d{8}$/,"ru-RU":/^(\+?7)?9\d{9}$/,"pt-BR":/^(\+?55)?[1-9]{2}9?\d{8}$/,"in-IN":/^(\+?91)?[6-9]\d{9}$/,"ar-SA":/^(\+?966)?5\d{8}$/,"ar-EG":/^(\+?20)?1[0125]\d{8}$/,"vi-VN":/^(\+?84)?[35789]\d{8}$/,"th-TH":/^(\+?66)?[689]\d{8}$/,"id-ID":/^(\+?62)?8\d{9,11}$/,"ms-MY":/^(\+?60)?1\d{8,9}$/,"nl-NL":/^(\+?31)?6\d{8}$/,"it-IT":/^(\+?39)?3\d{9}$/,"es-ES":/^(\+?34)?[67]\d{8}$/,"pl-PL":/^(\+?48)?[45789]\d{8}$/};export const POSTAL_CODE_REGEXES={AD:/^AD\d{3}$/,AT:/^\d{4}$/,AU:/^\d{4}$/,AZ:/^\d{4}$/,BE:/^\d{4}$/,BG:/^\d{4}$/,BR:/^\d{5}-?\d{3}$/,BY:/^\d{6}$/,CA:/^[ABCEGHJKLMNPRSTVXY]\d[ABCEGHJ-NPRSTV-Z] ?\d[ABCEGHJ-NPRSTV-Z]\d$/i,CH:/^\d{4}$/,CN:/^\d{6}$/,CZ:/^\d{3} ?\d{2}$/,DE:/^\d{5}$/,DK:/^\d{4}$/,EE:/^\d{5}$/,ES:/^\d{5}$/,FI:/^\d{5}$/,FR:/^\d{2} ?\d{3}$/,GB:/^(GIR ?0AA|[A-PR-UWYZ]([0-9]{1,2}|([A-HK-Y][0-9]([0-9ABEHMNPRV-Y])?)|[0-9][A-HJKPSTUW]) ?[0-9][ABD-HJLNP-UW-Z]{2})$/i,GR:/^\d{3} ?\d{2}$/,HR:/^\d{5}$/,HU:/^\d{4}$/,ID:/^\d{5}$/,IL:/^\d{5}(\d{2})?$/,IN:/^\d{6}$/,IS:/^\d{3}$/,IT:/^\d{5}$/,JP:/^\d{3}-?\d{4}$/,KR:/^\d{5}$/,LI:/^(948[5-9]|949[0-7])$/,LT:/^LT-\d{5}$/,LU:/^\d{4}$/,LV:/^LV-\d{4}$/,MX:/^\d{5}$/,MT:/^[A-Z]{3} ?\d{4}$/i,MZ:/^\d{4}$/,NL:/^\d{4} ?[A-Z]{2}$/i,NO:/^\d{4}$/,NP:/^\d{5}$/,NZ:/^\d{4}$/,PH:/^\d{4}$/,PK:/^\d{5}$/,PL:/^\d{2}-\d{3}$/,PR:/^009\d{2}([ -]\d{4})?$/,PT:/^\d{4}-\d{3}$/,RO:/^\d{6}$/,RU:/^\d{6}$/,SE:/^\d{3} ?\d{2}$/,SG:/^\d{6}$/,SI:/^\d{4}$/,SK:/^\d{3} ?\d{2}$/,TH:/^\d{5}$/,TN:/^\d{4}$/,TW:/^\d{3}(\d{2})?$/,UA:/^\d{5}$/,US:/^\d{5}(-\d{4})?$/,ZA:/^\d{4}$/,ZM:/^\d{5}$/};export const IDENTITY_CARD_REGEXES={AF:/^\d{8}$/,AL:/^[A-Z]\d{8}[A-Z]$/i,AR:/^\d{7,8}$/,AZ:/^AZE\d{8}$/,BE:/^\d{11}$/,BG:/^\d{10}$/,BR:/^\d{9}$/,BY:/^[A-Z]{2}\d{7}$/i,CA:/^\d{9}$/,CH:/^756\d{10}$/,CN:/^\d{15}(\d{2}[0-9xX])?$/,CY:/^\d{7}[A-Z]$/i,CZ:/^\d{9,10}$/,DE:/^[LITOUAEVBMNPRSZDFGHCK]{9}$/i,DK:/^\d{10}$/,EE:/^\d{11}$/,ES:/^[0-9X-Z]\d{7}[TRWAGMYFPDXBNJZSQVHLCKE]$/i,FI:/^\d{6}[+-A]\d{3}[0-9A-FHJ-NPR-Y]$/,FR:/^\d{8,9}[0-9\u00C1-\u00FF]{1}$/i,GB:/^[A-Z]{2}\d{6}[A-Z]$/i,GR:/^[A-Z]{2}\d{6}$/i,HR:/^\d{11}$/,HU:/^\d{8}[A-Z]{2}$/i,ID:/^\d{16}$/,IE:/^\d{7}[A-W][A-W]?$/,IL:/^\d{9}$/,IN:/^\d{12}$/,IR:/^\d{10}$/,IS:/^\d{10}$/,IT:/^[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]$/i,JP:/^\d{12}$/,KR:/^\d{6}-\d{7}$/,LT:/^\d{11}$/,LU:/^\d{13}$/,LV:/^\d{6}-\d{5}$/,MK:/^\d{13}$/,MX:/^[A-Z]{4}\d{6}[HM][A-Z]{2}[B-DF-HJ-NP-TV-Z]{3}[A-Z0-9]\d$/i,MT:/^\d{7}[A-Z]$/i,NL:/^\d{9}$/,NO:/^\d{11}$/,PL:/^\d{11}$/,PT:/^[1-9]\d{7}[0-9TV]$/i,RO:/^\d{13}$/,RS:/^\d{13}$/,RU:/^\d{10}$/,SE:/^\d{10,12}$/,SI:/^\d{13}$/,SK:/^\d{9,10}$/,TH:/^\d{13}$/,TR:/^\d{11}$/,TW:/^[A-Z]\d{9}$/i,UA:/^\d{9}$/,US:/^\d{3}-\d{2}-\d{4}$/,ZA:/^\d{13}$/};export const PASSPORT_REGEXES={AM:/^[A-Z]{2}\d{7}$/i,AR:/^[A-Z]{3}\d{6}$/i,AT:/^[A-Z]\d{7}$/i,AU:/^[A-Z]\d{7}$/i,AZ:/^[Aa]\d{8}$/,BE:/^[A-Z]{2}\d{6}$/i,BG:/^\d{9}$/,BH:/^[A-Z]{2}\d{6}$/i,BR:/^[A-Z]{2}\d{6}$/i,BY:/^[A-Z]{2}\d{7}$/i,CA:/^[A-Z]{2}\d{6}$/i,CH:/^[A-Z]\d{7}$/i,CN:/^G\d{8}$/,CY:/^[A-Z](\d{6}|\d{8})$/i,CZ:/^\d{8}$/,DE:/^[CFGHJKLMNPRTVWXYZ0-9]{9}$/i,DK:/^\d{9}$/,EE:/^([A-Z]\d{7}|[A-Z]{2}\d{7})$/i,ES:/^[A-Z0-9]{2}([A-Z0-9]?)\d{6}$/i,FI:/^[A-Z]{2}\d{7}$/i,FR:/^[A-Z0-9]{9}$/i,GB:/^\d{9}$/,GR:/^[A-Z]{2}\d{7}$/i,HR:/^\d{9}$/,HU:/^[A-Z]{2}(\d{6}|\d{7})$/i,ID:/^[A-C]\d{7}$/i,IE:/^[A-Z0-9]{2}\d{7}$/i,IL:/^\d{9}$/,IN:/^[A-Z]\d{7}$/i,IR:/^[A-Z]\d{8}$/i,IS:/^(A)\d{7}$/i,IT:/^[A-Z0-9]{9}$/i,JO:/^[A-Z]{2}\d{7}$/i,JP:/^[A-Z]{2}\d{7}$/i,KR:/^[A-Z][A-Z0-9]\d{7}$/i,KW:/^\d{8}$/,KZ:/^[A-Z]\d{8}$/i,LI:/^[A-Z]\d{6}X$/i,LT:/^[A-Z0-9]{8}$/i,LU:/^[A-Z0-9]{8}$/i,LV:/^[A-Z0-9]{2}\d{7}$/i,LY:/^[A-Z]{2}\d{7}$/i,MA:/^[A-Z0-9]{2}\d{7}$/i,MD:/^[A-Z]{2}\d{7}$/i,ME:/^[A-Z]{2}\d{7}$/i,MK:/^[A-Z]\d{7}$/i,MT:/^\d{7}$/,MX:/^[A-Z]\d{8}$/i,MY:/^[AHK]\d{8}[A-Z]$/i,NL:/^[A-NP-Z]{2}[A-NP-Z0-9]{6}\d$/i,NO:/^\d{9}$/,NZ:/^[A-Z]{2}\d{6}$/i,PH:/^[A-Z]\d{7}[A-Z]$/i,PK:/^[A-Z]{2}\d{7}$/i,PL:/^[A-Z]{2}\d{7}$/i,PT:/^[A-Z]\d{6}$/i,RO:/^\d{8}$/,RS:/^\d{9}$/,RU:/^\d{9}$/,SA:/^[A-Z]\d{8}$/i,SE:/^\d{8}$/,SL:/^(P)[A-Z]\d{7}$/i,SK:/^[0-9A-Z]\d{7}$/i,TH:/^[A-Z]{1,2}\d{6,7}$/i,TN:/^\d{8}$/,TR:/^[A-Z]\d{8}$/i,TW:/^[A-Z]\d{9}$/i,UA:/^[A-Z]{2}\d{6}$/i,US:/^\d{9}$/,ZA:/^[A-Z]\d{8}$/i};

package/dist/src/{create-rule.d.ts → rules/create-rule.d.ts}

@@ -1,5 +1,5 @@
 import type { RequiredType } from './enums';
-import type { EmittableRule } from './types';
+import type { EmittableRule } from './interfaces';
 export interface CreateRuleOptions {
     /** Rule name. Used as the error code. */
     name: string;

package/dist/src/rules/create-rule.js

@@ -0,0 +1 @@
+import{BakerError as K,isAsyncFunction as U,isPromiseLike as V}from"../common/index.js";import{defineRuleMetadata as W}from"./rule-metadata.js";export function createRule(b,Q){const z=typeof b==="string"?b:b.name,C=typeof b==="string"?Q:b.validate;if(typeof C!=="function")throw new K(`createRule(${z}): a validate function is required.`);const I=typeof b==="object"?b.constraints:void 0,J=typeof b==="object"?b.requiresType:void 0,D=U(C),j=function(H){const w=C(H);if(!D&&V(w))throw new K(`createRule(${z}): sync rule returned Promise. Declare the validator with async if it is asynchronous.`);return w};j.emit=function(H,w){const S=w.addRef(j);return`if(!(${D?"await ":""}refs[${S}](${H}))) ${w.fail(z)};`};const G={emit:j.emit,ruleName:z,isAsync:D};if(I!==void 0)G.constraints=I;if(J!==void 0)G.requiresType=J;W(j,G);return j}

package/dist/src/rules/date.d.ts

@@ -1,3 +1,3 @@
-import type { EmittableRule } from '../types';
+import type { EmittableRule } from './interfaces';
 export declare function minDate(date: Date): EmittableRule;
 export declare function maxDate(date: Date): EmittableRule;

package/dist/src/rules/date.js

@@ -1 +1 @@
-import{CacheKey as A,RequiredType as B,RuleOp as w}from"../enums.js";import{makePlannedRule as D,planCompare as x,planLiteral as E,planOr as F,planTime as b}from"../rule-plan.js";export function minDate(f){const g=f.getTime(),z={cacheKey:A.Time,failure:F(x(b(),w.Neq,b()),x(b(),w.Lt,E(g)))};return D({name:"minDate",requiresType:B.Date,constraints:{min:f.toISOString()},plan:z,validate:(j)=>j instanceof Date&&j.getTime()>=g})}export function maxDate(f){const g=f.getTime(),z={cacheKey:A.Time,failure:F(x(b(),w.Neq,b()),x(b(),w.Gt,E(g)))};return D({name:"maxDate",requiresType:B.Date,constraints:{max:f.toISOString()},plan:z,validate:(j)=>j instanceof Date&&j.getTime()<=g})}
+import{CacheKey as A}from"../common/index.js";import{RequiredType as B,RuleOp as w}from"./enums.js";import{makePlannedRule as D,planCompare as x,planLiteral as E,planOr as F,planTime as b}from"./rule-plan.js";export function minDate(f){const g=f.getTime(),z={cacheKey:A.Time,failure:F(x(b(),w.Neq,b()),x(b(),w.Lt,E(g)))};return D({name:"minDate",requiresType:B.Date,constraints:{min:f.toISOString()},plan:z,validate:(j)=>j instanceof Date&&j.getTime()>=g})}export function maxDate(f){const g=f.getTime(),z={cacheKey:A.Time,failure:F(x(b(),w.Neq,b()),x(b(),w.Gt,E(g)))};return D({name:"maxDate",requiresType:B.Date,constraints:{max:f.toISOString()},plan:z,validate:(j)=>j instanceof Date&&j.getTime()<=g})}

package/dist/src/{enums.d.ts → rules/enums.d.ts}

@@ -7,21 +7,6 @@ export declare enum RequiredType {
     Array = "array",
     Object = "object"
 }
-/** Direction of a (de)serialization pass. */
-export declare enum Direction {
-    Deserialize = "deserialize",
-    Serialize = "serialize"
-}
-/** Collection container type for a nested field. */
-export declare enum CollectionType {
-    Map = "Map",
-    Set = "Set"
-}
-/** Cached accessor a RulePlan reuses across checks. */
-export declare enum CacheKey {
-    Length = "length",
-    Time = "time"
-}
 /** Discriminant for a RulePlanExpr node. */
 export declare enum RulePlanExprKind {
     Value = "value",
@@ -44,8 +29,3 @@ export declare enum RuleOp {
     Eq = "===",
     Neq = "!=="
 }
-/** Direction in which a field is excluded. */
-export declare enum ExcludeMode {
-    DeserializeOnly = "deserializeOnly",
-    SerializeOnly = "serializeOnly"
-}

package/dist/src/rules/enums.js

@@ -0,0 +1 @@
+export var RequiredType;((b)=>{b.String="string";b.Number="number";b.Boolean="boolean";b.Date="date";b.Array="array";b.Object="object"})(RequiredType||={});export var RulePlanExprKind;((f)=>{f.Value="value";f.Member="member";f.Call0="call0";f.Literal="literal"})(RulePlanExprKind||={});export var RulePlanCheckKind;((j)=>{j.Compare="compare";j.And="and";j.Or="or"})(RulePlanCheckKind||={});export var RuleOp;((b)=>{b.Lt="<";b.Lte="<=";b.Gt=">";b.Gte=">=";b.Eq="===";b.Neq="!=="})(RuleOp||={});

package/dist/src/rules/index.d.ts

@@ -1,13 +1,5 @@
-export { isString, isNumber, isBoolean, isDate, isEnum, isInt, isArray, isObject, isRegExp, isFunction, isStatelessRegExp, } from './typechecker';
-export type { IsNumberOptions } from './typechecker';
-export { oneOf, arrayEvery } from './combinators';
-export { min, max, isPositive, isNegative, isDivisibleBy } from './number';
-export { minDate, maxDate } from './date';
-export { equals, notEquals, isEmpty, isNotEmpty, isIn, isNotIn } from './common';
-export { minLength, maxLength, length, contains, notContains, matches, isLowercase, isUppercase, isAscii, isAlpha, isAlphanumeric, isHttpToken, isOrigin, isCorsOrigin, isBooleanString, isNumberString, isDecimal, isFullWidth, isHalfWidth, isVariableWidth, isMultibyte, isSurrogatePair, isHexadecimal, isOctal, isEmail, isURL, isUUID, isIP, isHexColor, isRgbColor, isHSL, isMACAddress, isISBN, isISIN, isISO8601, isISRC, isISSN, isJWT, isLatLong, isLocale, isDataURI, isFQDN, isPort, isEAN, isISO31661Alpha2, isISO31661Alpha3, isBIC, isFirebasePushId, isSemVer, isMongoId, isJSON, isBase32, isBase58, isBase64, isDateString, isMimeType, isCurrency, isMagnetURI, isCreditCard, isIBAN, isByteLength, isHash, isRFC3339, isMilitaryTime, isLatitude, isLongitude, isEthereumAddress, isBtcAddress, isISO4217CurrencyCode, isPhoneNumber, isStrongPassword, isTaxId, isULID, isCUID2, } from './string';
-export type { IsURLOptions, IsBase64Options, IsMACAddressOptions, IsIBANOptions, IsISSNOptions, IsFQDNOptions, IsISO8601Options, IsNumberStringOptions, IsStrongPasswordOptions, } from './string';
-export { arrayContains, arrayNotContains, arrayMinSize, arrayMaxSize, arrayUnique, arrayNotEmpty } from './array';
-export { isNotEmptyObject, isInstance } from './object';
-export type { IsNotEmptyObjectOptions } from './object';
-export { isMobilePhone, isPostalCode, isIdentityCard, isPassportNumber } from './locales';
-export { isUint8Array, isByteSize } from './binary';
+export * from './public';
+export { emitRulePlan } from './rule-plan';
+export { RequiredType } from './enums';
+export type { EmittableRule, InternalRule, EmitContext } from './interfaces';
+export type { RulePlanCache } from './types';

package/dist/src/rules/index.js

@@ -1 +1 @@
-export{isString,isNumber,isBoolean,isDate,isEnum,isInt,isArray,isObject,isRegExp,isFunction,isStatelessRegExp}from"./typechecker.js";export{oneOf,arrayEvery}from"./combinators.js";export{min,max,isPositive,isNegative,isDivisibleBy}from"./number.js";export{minDate,maxDate}from"./date.js";export{equals,notEquals,isEmpty,isNotEmpty,isIn,isNotIn}from"./common.js";export{minLength,maxLength,length,contains,notContains,matches,isLowercase,isUppercase,isAscii,isAlpha,isAlphanumeric,isHttpToken,isOrigin,isCorsOrigin,isBooleanString,isNumberString,isDecimal,isFullWidth,isHalfWidth,isVariableWidth,isMultibyte,isSurrogatePair,isHexadecimal,isOctal,isEmail,isURL,isUUID,isIP,isHexColor,isRgbColor,isHSL,isMACAddress,isISBN,isISIN,isISO8601,isISRC,isISSN,isJWT,isLatLong,isLocale,isDataURI,isFQDN,isPort,isEAN,isISO31661Alpha2,isISO31661Alpha3,isBIC,isFirebasePushId,isSemVer,isMongoId,isJSON,isBase32,isBase58,isBase64,isDateString,isMimeType,isCurrency,isMagnetURI,isCreditCard,isIBAN,isByteLength,isHash,isRFC3339,isMilitaryTime,isLatitude,isLongitude,isEthereumAddress,isBtcAddress,isISO4217CurrencyCode,isPhoneNumber,isStrongPassword,isTaxId,isULID,isCUID2}from"./string.js";export{arrayContains,arrayNotContains,arrayMinSize,arrayMaxSize,arrayUnique,arrayNotEmpty}from"./array.js";export{isNotEmptyObject,isInstance}from"./object.js";export{isMobilePhone,isPostalCode,isIdentityCard,isPassportNumber}from"./locales.js";export{isUint8Array,isByteSize}from"./binary.js";
+export*from"./public.js";export{emitRulePlan}from"./rule-plan.js";export{RequiredType}from"./enums.js";

package/dist/src/rules/interfaces.d.ts

@@ -0,0 +1,43 @@
+import type { CacheKey } from '../common';
+import type { SealedExecutors } from '../seal';
+import type { RequiredType } from './enums';
+import type { RulePlanCheck } from './types';
+export interface EmitContext {
+    /** Register a RegExp in the reference array, return its index */
+    addRegex(re: RegExp): number;
+    /** Register in the reference array, return its index — functions, arrays, Sets, primitives, etc. */
+    addRef(value: unknown): number;
+    /** Register a SealedExecutors object in the reference array — for nested @Type DTOs */
+    addExecutor(executor: SealedExecutors<unknown>): number;
+    /** Generate a failure code string from an error code — path is bound by the builder */
+    fail(code: string): string;
+    /** Whether error collection mode is enabled (= !stopAtFirstError) */
+    collectErrors: boolean;
+    /** Whether this emit runs inside a type gate (typeof/instanceof already verified) */
+    insideTypeGate?: boolean;
+    /** @internal Path expression for inline nested — used by makeRuleEmitCtx */
+    pathExpr?: string;
+}
+export interface EmittableRule {
+    (value: unknown): boolean | Promise<boolean>;
+    emit(varName: string, ctx: EmitContext): string;
+    readonly ruleName: string;
+    /**
+     * Meta for the builder to determine whether to insert a typeof guard.
+     * Only set for rules that assume a specific type (e.g., isEmail → 'string').
+     * `@IsString` itself is undefined (it includes its own typeof check).
+     */
+    readonly requiresType?: RequiredType;
+    /** Expose rule parameters for external reading */
+    readonly constraints?: Record<string, unknown>;
+    /** true when the rule is explicitly async and must be awaited */
+    readonly isAsync?: boolean;
+}
+/** @internal internal rule shape used by builders for optimization metadata */
+export interface InternalRule extends EmittableRule {
+    readonly plan?: RulePlan;
+}
+export interface RulePlan {
+    cacheKey?: CacheKey;
+    failure: RulePlanCheck;
+}

package/dist/src/rules/locales.d.ts

@@ -1,4 +1,4 @@
-import type { EmittableRule } from '../types';
+import type { EmittableRule } from './interfaces';
 declare function isMobilePhone(locale: string): EmittableRule;
 declare function isPostalCode(locale: string): EmittableRule;
 declare function isIdentityCard(locale: string): EmittableRule;

package/dist/src/rules/locales.js

@@ -1 +1 @@
-import{RequiredType as Q}from"../enums.js";import{BakerError as U}from"../errors.js";import{makeRule as V}from"../rule-plan.js";const W={"ko-KR":/^(\+?82|0)1[016789]\d{7,8}$/,"en-US":/^\+?1?[2-9]\d{2}[2-9]\d{6}$/,"zh-CN":/^(\+?86)?1[3-9]\d{9}$/,"zh-TW":/^(\+?886)?9\d{8}$/,"ja-JP":/^(\+?81)?0?[789]0[0-9]{8}$/,"de-DE":/^(\+?49)?1(5\d|6[0-9]|7[0-9])\d{8}$/,"fr-FR":/^(\+?33)?[67]\d{8}$/,"en-GB":/^(\+?44)?7[1-9]\d{8}$/,"ru-RU":/^(\+?7)?9\d{9}$/,"pt-BR":/^(\+?55)?[1-9]{2}9?\d{8}$/,"in-IN":/^(\+?91)?[6-9]\d{9}$/,"ar-SA":/^(\+?966)?5\d{8}$/,"ar-EG":/^(\+?20)?1[0125]\d{8}$/,"vi-VN":/^(\+?84)?[35789]\d{8}$/,"th-TH":/^(\+?66)?[689]\d{8}$/,"id-ID":/^(\+?62)?8\d{9,11}$/,"ms-MY":/^(\+?60)?1\d{8,9}$/,"nl-NL":/^(\+?31)?6\d{8}$/,"it-IT":/^(\+?39)?3\d{9}$/,"es-ES":/^(\+?34)?[67]\d{8}$/,"pl-PL":/^(\+?48)?[45789]\d{8}$/};function isMobilePhone(f){return w("isMobilePhone",f,W)}const Z={AD:/^AD\d{3}$/,AT:/^\d{4}$/,AU:/^\d{4}$/,AZ:/^\d{4}$/,BE:/^\d{4}$/,BG:/^\d{4}$/,BR:/^\d{5}-?\d{3}$/,BY:/^\d{6}$/,CA:/^[ABCEGHJKLMNPRSTVXY]\d[ABCEGHJ-NPRSTV-Z] ?\d[ABCEGHJ-NPRSTV-Z]\d$/i,CH:/^\d{4}$/,CN:/^\d{6}$/,CZ:/^\d{3} ?\d{2}$/,DE:/^\d{5}$/,DK:/^\d{4}$/,EE:/^\d{5}$/,ES:/^\d{5}$/,FI:/^\d{5}$/,FR:/^\d{2} ?\d{3}$/,GB:/^(GIR ?0AA|[A-PR-UWYZ]([0-9]{1,2}|([A-HK-Y][0-9]([0-9ABEHMNPRV-Y])?)|[0-9][A-HJKPSTUW]) ?[0-9][ABD-HJLNP-UW-Z]{2})$/i,GR:/^\d{3} ?\d{2}$/,HR:/^\d{5}$/,HU:/^\d{4}$/,ID:/^\d{5}$/,IL:/^\d{5}(\d{2})?$/,IN:/^\d{6}$/,IS:/^\d{3}$/,IT:/^\d{5}$/,JP:/^\d{3}-?\d{4}$/,KR:/^\d{5}$/,LI:/^(948[5-9]|949[0-7])$/,LT:/^LT-\d{5}$/,LU:/^\d{4}$/,LV:/^LV-\d{4}$/,MX:/^\d{5}$/,MT:/^[A-Z]{3} ?\d{4}$/i,MZ:/^\d{4}$/,NL:/^\d{4} ?[A-Z]{2}$/i,NO:/^\d{4}$/,NP:/^\d{5}$/,NZ:/^\d{4}$/,PH:/^\d{4}$/,PK:/^\d{5}$/,PL:/^\d{2}-\d{3}$/,PR:/^009\d{2}([ -]\d{4})?$/,PT:/^\d{4}-\d{3}$/,RO:/^\d{6}$/,RU:/^\d{6}$/,SE:/^\d{3} ?\d{2}$/,SG:/^\d{6}$/,SI:/^\d{4}$/,SK:/^\d{3} ?\d{2}$/,TH:/^\d{5}$/,TN:/^\d{4}$/,TW:/^\d{3}(\d{2})?$/,UA:/^\d{5}$/,US:/^\d{5}(-\d{4})?$/,ZA:/^\d{4}$/,ZM:/^\d{5}$/};function isPostalCode(f){return w("isPostalCode",f,Z)}const $={AF:/^\d{8}$/,AL:/^[A-Z]\d{8}[A-Z]$/i,AR:/^\d{7,8}$/,AZ:/^AZE\d{8}$/,BE:/^\d{11}$/,BG:/^\d{10}$/,BR:/^\d{9}$/,BY:/^[A-Z]{2}\d{7}$/i,CA:/^\d{9}$/,CH:/^756\d{10}$/,CN:/^\d{15}(\d{2}[0-9xX])?$/,CY:/^\d{7}[A-Z]$/i,CZ:/^\d{9,10}$/,DE:/^[LITOUAEVBMNPRSZDFGHCK]{9}$/i,DK:/^\d{10}$/,EE:/^\d{11}$/,ES:/^[0-9X-Z]\d{7}[TRWAGMYFPDXBNJZSQVHLCKE]$/i,FI:/^\d{6}[+-A]\d{3}[0-9A-FHJ-NPR-Y]$/,FR:/^\d{8,9}[0-9\u00C1-\u00FF]{1}$/i,GB:/^[A-Z]{2}\d{6}[A-Z]$/i,GR:/^[A-Z]{2}\d{6}$/i,HR:/^\d{11}$/,HU:/^\d{8}[A-Z]{2}$/i,ID:/^\d{16}$/,IE:/^\d{7}[A-W][A-W]?$/,IL:/^\d{9}$/,IN:/^\d{12}$/,IR:/^\d{10}$/,IS:/^\d{10}$/,IT:/^[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]$/i,JP:/^\d{12}$/,KR:/^\d{6}-\d{7}$/,LT:/^\d{11}$/,LU:/^\d{13}$/,LV:/^\d{6}-\d{5}$/,MK:/^\d{13}$/,MX:/^[A-Z]{4}\d{6}[HM][A-Z]{2}[B-DF-HJ-NP-TV-Z]{3}[A-Z0-9]\d$/i,MT:/^\d{7}[A-Z]$/i,NL:/^\d{9}$/,NO:/^\d{11}$/,PL:/^\d{11}$/,PT:/^[1-9]\d{7}[0-9TV]$/i,RO:/^\d{13}$/,RS:/^\d{13}$/,RU:/^\d{10}$/,SE:/^\d{10,12}$/,SI:/^\d{13}$/,SK:/^\d{9,10}$/,TH:/^\d{13}$/,TR:/^\d{11}$/,TW:/^[A-Z]\d{9}$/i,UA:/^\d{9}$/,US:/^\d{3}-\d{2}-\d{4}$/,ZA:/^\d{13}$/};function isIdentityCard(f){return w("isIdentityCard",f,$)}const h={AM:/^[A-Z]{2}\d{7}$/i,AR:/^[A-Z]{3}\d{6}$/i,AT:/^[A-Z]\d{7}$/i,AU:/^[A-Z]\d{7}$/i,AZ:/^[Aa]\d{8}$/,BE:/^[A-Z]{2}\d{6}$/i,BG:/^\d{9}$/,BH:/^[A-Z]{2}\d{6}$/i,BR:/^[A-Z]{2}\d{6}$/i,BY:/^[A-Z]{2}\d{7}$/i,CA:/^[A-Z]{2}\d{6}$/i,CH:/^[A-Z]\d{7}$/i,CN:/^G\d{8}$/,CY:/^[A-Z](\d{6}|\d{8})$/i,CZ:/^\d{8}$/,DE:/^[CFGHJKLMNPRTVWXYZ0-9]{9}$/i,DK:/^\d{9}$/,EE:/^([A-Z]\d{7}|[A-Z]{2}\d{7})$/i,ES:/^[A-Z0-9]{2}([A-Z0-9]?)\d{6}$/i,FI:/^[A-Z]{2}\d{7}$/i,FR:/^[A-Z0-9]{9}$/i,GB:/^\d{9}$/,GR:/^[A-Z]{2}\d{7}$/i,HR:/^\d{9}$/,HU:/^[A-Z]{2}(\d{6}|\d{7})$/i,ID:/^[A-C]\d{7}$/i,IE:/^[A-Z0-9]{2}\d{7}$/i,IL:/^\d{9}$/,IN:/^[A-Z]\d{7}$/i,IR:/^[A-Z]\d{8}$/i,IS:/^(A)\d{7}$/i,IT:/^[A-Z0-9]{9}$/i,JO:/^[A-Z]{2}\d{7}$/i,JP:/^[A-Z]{2}\d{7}$/i,KR:/^[A-Z][A-Z0-9]\d{7}$/i,KW:/^\d{8}$/,KZ:/^[A-Z]\d{8}$/i,LI:/^[A-Z]\d{6}X$/i,LT:/^[A-Z0-9]{8}$/i,LU:/^[A-Z0-9]{8}$/i,LV:/^[A-Z0-9]{2}\d{7}$/i,LY:/^[A-Z]{2}\d{7}$/i,MA:/^[A-Z0-9]{2}\d{7}$/i,MD:/^[A-Z]{2}\d{7}$/i,ME:/^[A-Z]{2}\d{7}$/i,MK:/^[A-Z]\d{7}$/i,MT:/^\d{7}$/,MX:/^[A-Z]\d{8}$/i,MY:/^[AHK]\d{8}[A-Z]$/i,NL:/^[A-NP-Z]{2}[A-NP-Z0-9]{6}\d$/i,NO:/^\d{9}$/,NZ:/^[A-Z]{2}\d{6}$/i,PH:/^[A-Z]\d{7}[A-Z]$/i,PK:/^[A-Z]{2}\d{7}$/i,PL:/^[A-Z]{2}\d{7}$/i,PT:/^[A-Z]\d{6}$/i,RO:/^\d{8}$/,RS:/^\d{9}$/,RU:/^\d{9}$/,SA:/^[A-Z]\d{8}$/i,SE:/^\d{8}$/,SL:/^(P)[A-Z]\d{7}$/i,SK:/^[0-9A-Z]\d{7}$/i,TH:/^[A-Z]{1,2}\d{6,7}$/i,TN:/^\d{8}$/,TR:/^[A-Z]\d{8}$/i,TW:/^[A-Z]\d{9}$/i,UA:/^[A-Z]{2}\d{6}$/i,US:/^\d{9}$/,ZA:/^[A-Z]\d{8}$/i};function isPassportNumber(f){return w("isPassportNumber",f,h)}function w(f,z,K){const F=K[z];if(!F)throw new U(`Unsupported locale: "${z}" for ${f}`);return V({name:f,requiresType:Q.String,constraints:{locale:z},validate:(j)=>typeof j==="string"&&F.test(j),emit:(j,J)=>{return`if (!re[${J.addRegex(F)}].test(${j})) ${J.fail(f)};`}})}export{isMobilePhone,isPostalCode,isIdentityCard,isPassportNumber};
+import{BakerError as Q}from"../common/index.js";import{MOBILE_PHONE_REGEXES as U,POSTAL_CODE_REGEXES as V,IDENTITY_CARD_REGEXES as W,PASSPORT_REGEXES as Z}from"./constants.js";import{RequiredType as $}from"./enums.js";import{makeRule as h}from"./rule-plan.js";function isMobilePhone(f){return w("isMobilePhone",f,U)}function isPostalCode(f){return w("isPostalCode",f,V)}function isIdentityCard(f){return w("isIdentityCard",f,W)}function isPassportNumber(f){return w("isPassportNumber",f,Z)}function w(f,z,K){const F=K[z];if(!F)throw new Q(`Unsupported locale: "${z}" for ${f}`);return h({name:f,requiresType:$.String,constraints:{locale:z},validate:(j)=>typeof j==="string"&&F.test(j),emit:(j,J)=>{return`if (!re[${J.addRegex(F)}].test(${j})) ${J.fail(f)};`}})}export{isMobilePhone,isPostalCode,isIdentityCard,isPassportNumber};

package/dist/src/rules/number.d.ts

@@ -1,10 +1,10 @@
-import type { EmittableRule } from '../types';
+import type { EmittableRule } from './interfaces';
 export declare function min(n: number, opts?: {
     exclusive?: boolean;
 }): EmittableRule;
 export declare function max(n: number, opts?: {
     exclusive?: boolean;
 }): EmittableRule;
-export declare const isPositive: import("../types").InternalRule;
-export declare const isNegative: import("../types").InternalRule;
+export declare const isPositive: import("./interfaces").InternalRule;
+export declare const isNegative: import("./interfaces").InternalRule;
 export declare function isDivisibleBy(n: number): EmittableRule;

package/dist/src/rules/number.js

@@ -1 +1 @@
-import{RequiredType as A,RuleOp as h}from"../enums.js";import{BakerError as I}from"../errors.js";import{makePlannedRule as D,makeRule as J,planCompare as z,planLiteral as F,planOr as G,planValue as f}from"../rule-plan.js";export function min(b,w){if(!Number.isFinite(b))throw new I(`min: bound must be a finite number, got ${b}`);const j=w?.exclusive??!1,H={failure:G(z(f(),h.Neq,f()),z(f(),j?h.Lte:h.Lt,F(b)))};return D({name:"min",requiresType:A.Number,constraints:j?{min:b,exclusive:!0}:{min:b},plan:H,validate:j?(g)=>typeof g==="number"&&g>b:(g)=>typeof g==="number"&&g>=b})}export function max(b,w){if(!Number.isFinite(b))throw new I(`max: bound must be a finite number, got ${b}`);const j=w?.exclusive??!1,H={failure:G(z(f(),h.Neq,f()),z(f(),j?h.Gte:h.Gt,F(b)))};return D({name:"max",requiresType:A.Number,constraints:j?{max:b,exclusive:!0}:{max:b},plan:H,validate:j?(g)=>typeof g==="number"&&g<b:(g)=>typeof g==="number"&&g<=b})}export const isPositive=D({name:"isPositive",requiresType:A.Number,constraints:{min:0,exclusive:!0},plan:{failure:G(z(f(),h.Neq,f()),z(f(),h.Lte,F(0)))},validate:(b)=>typeof b==="number"&&b>0});export const isNegative=D({name:"isNegative",requiresType:A.Number,constraints:{max:0,exclusive:!0},plan:{failure:G(z(f(),h.Neq,f()),z(f(),h.Gte,F(0)))},validate:(b)=>typeof b==="number"&&b<0});export function isDivisibleBy(b){if(b===0)throw new I("isDivisibleBy: divisor must not be zero");return J({name:"isDivisibleBy",requiresType:A.Number,constraints:{divisor:b},validate:(w)=>typeof w==="number"&&w%b===0,emit:(w,j)=>`if (${w} % ${b} !== 0) ${j.fail("isDivisibleBy")};`})}
+import{BakerError as I}from"../common/index.js";import{RequiredType as A,RuleOp as h}from"./enums.js";import{makePlannedRule as D,makeRule as J,planCompare as z,planLiteral as F,planOr as G,planValue as f}from"./rule-plan.js";export function min(b,w){if(!Number.isFinite(b))throw new I(`min: bound must be a finite number, got ${b}`);const j=w?.exclusive??!1,H={failure:G(z(f(),h.Neq,f()),z(f(),j?h.Lte:h.Lt,F(b)))};return D({name:"min",requiresType:A.Number,constraints:j?{min:b,exclusive:!0}:{min:b},plan:H,validate:j?(g)=>typeof g==="number"&&g>b:(g)=>typeof g==="number"&&g>=b})}export function max(b,w){if(!Number.isFinite(b))throw new I(`max: bound must be a finite number, got ${b}`);const j=w?.exclusive??!1,H={failure:G(z(f(),h.Neq,f()),z(f(),j?h.Gte:h.Gt,F(b)))};return D({name:"max",requiresType:A.Number,constraints:j?{max:b,exclusive:!0}:{max:b},plan:H,validate:j?(g)=>typeof g==="number"&&g<b:(g)=>typeof g==="number"&&g<=b})}export const isPositive=D({name:"isPositive",requiresType:A.Number,constraints:{min:0,exclusive:!0},plan:{failure:G(z(f(),h.Neq,f()),z(f(),h.Lte,F(0)))},validate:(b)=>typeof b==="number"&&b>0});export const isNegative=D({name:"isNegative",requiresType:A.Number,constraints:{max:0,exclusive:!0},plan:{failure:G(z(f(),h.Neq,f()),z(f(),h.Gte,F(0)))},validate:(b)=>typeof b==="number"&&b<0});export function isDivisibleBy(b){if(b===0)throw new I("isDivisibleBy: divisor must not be zero");return J({name:"isDivisibleBy",requiresType:A.Number,constraints:{divisor:b},validate:(w)=>typeof w==="number"&&w%b===0,emit:(w,j)=>`if (${w} % ${b} !== 0) ${j.fail("isDivisibleBy")};`})}

package/dist/src/rules/object.d.ts

@@ -1,4 +1,4 @@
-import type { EmittableRule } from '../types';
+import type { EmittableRule } from './interfaces';
 export interface IsNotEmptyObjectOptions {
     /** Whether to ignore keys with null/undefined values (default: false — do not ignore) */
     nullable?: boolean;

package/dist/src/rules/object.js

@@ -1 +1 @@
-import{RequiredType as C}from"../enums.js";import{makeRule as B}from"../rule-plan.js";export function isNotEmptyObject(w){const z=(f)=>{if(f===null||typeof f!=="object"||Array.isArray(f))return!1;const h=f;if(w?.nullable){for(const A in h)if(h[A]!=null)return!0;return!1}for(const A in h)return!0;return!1};return B({name:"isNotEmptyObject",requiresType:C.Object,constraints:{nullable:w?.nullable},validate:z,emit:(f,h)=>{if(w?.nullable)return`{var __ne=false;for(var __k in ${f}){if(${f}[__k]!=null){__ne=true;break;}}if(!__ne) ${h.fail("isNotEmptyObject")};}`;return`{var __ne=false;for(var __k in ${f}){__ne=true;break;}if(!__ne) ${h.fail("isNotEmptyObject")};}`}})}export function isInstance(w){return B({name:"isInstance",constraints:{type:w.name},validate:(z)=>z instanceof w,emit:(z,f)=>{const h=f.addRef(w);return`if (!(${z} instanceof refs[${h}])) ${f.fail("isInstance")};`}})}
+import{RequiredType as C}from"./enums.js";import{makeRule as B}from"./rule-plan.js";export function isNotEmptyObject(h){const z=(f)=>{if(f===null||typeof f!=="object"||Array.isArray(f))return!1;const w=f;if(h?.nullable){for(const A in w)if(w[A]!=null)return!0;return!1}for(const A in w)return!0;return!1};return B({name:"isNotEmptyObject",requiresType:C.Object,constraints:h?.nullable!==void 0?{nullable:h.nullable}:{},validate:z,emit:(f,w)=>{if(h?.nullable)return`{var __ne=false;for(var __k in ${f}){if(${f}[__k]!=null){__ne=true;break;}}if(!__ne) ${w.fail("isNotEmptyObject")};}`;return`{var __ne=false;for(var __k in ${f}){__ne=true;break;}if(!__ne) ${w.fail("isNotEmptyObject")};}`}})}export function isInstance(h){return B({name:"isInstance",constraints:{type:h.name},validate:(z)=>z instanceof h,emit:(z,f)=>{const w=f.addRef(h);return`if (!(${z} instanceof refs[${w}])) ${f.fail("isInstance")};`}})}

package/dist/src/rules/public.d.ts

@@ -0,0 +1,14 @@
+export { createRule } from './create-rule';
+export { isString, isNumber, isBoolean, isDate, isEnum, isInt, isArray, isObject, isRegExp, isFunction, isStatelessRegExp, } from './typechecker';
+export type { IsNumberOptions } from './typechecker';
+export { oneOf, arrayEvery } from './combinators';
+export { min, max, isPositive, isNegative, isDivisibleBy } from './number';
+export { minDate, maxDate } from './date';
+export { equals, notEquals, isEmpty, isNotEmpty, isIn, isNotIn } from './common';
+export { minLength, maxLength, length, contains, notContains, matches, isLowercase, isUppercase, isAscii, isAlpha, isAlphanumeric, isHttpToken, isOrigin, isCorsOrigin, isBooleanString, isNumberString, isDecimal, isFullWidth, isHalfWidth, isVariableWidth, isMultibyte, isSurrogatePair, isHexadecimal, isOctal, isEmail, isURL, isUUID, isIP, isHexColor, isRgbColor, isHSL, isMACAddress, isISBN, isISIN, isISO8601, isISRC, isISSN, isJWT, isLatLong, isLocale, isDataURI, isFQDN, isPort, isEAN, isISO31661Alpha2, isISO31661Alpha3, isBIC, isFirebasePushId, isSemVer, isMongoId, isJSON, isBase32, isBase58, isBase64, isDateString, isMimeType, isCurrency, isMagnetURI, isCreditCard, isIBAN, isByteLength, isHash, isRFC3339, isMilitaryTime, isLatitude, isLongitude, isEthereumAddress, isBtcAddress, isISO4217CurrencyCode, isPhoneNumber, isStrongPassword, isTaxId, isULID, isCUID2, } from './string';
+export type { IsURLOptions, IsBase64Options, IsMACAddressOptions, IsIBANOptions, IsISSNOptions, IsFQDNOptions, IsISO8601Options, IsNumberStringOptions, IsStrongPasswordOptions, } from './string';
+export { arrayContains, arrayNotContains, arrayMinSize, arrayMaxSize, arrayUnique, arrayNotEmpty } from './array';
+export { isNotEmptyObject, isInstance } from './object';
+export type { IsNotEmptyObjectOptions } from './object';
+export { isMobilePhone, isPostalCode, isIdentityCard, isPassportNumber } from './locales';
+export { isUint8Array, isByteSize } from './binary';

package/dist/src/rules/public.js

@@ -0,0 +1 @@
+export{createRule}from"./create-rule.js";export{isString,isNumber,isBoolean,isDate,isEnum,isInt,isArray,isObject,isRegExp,isFunction,isStatelessRegExp}from"./typechecker.js";export{oneOf,arrayEvery}from"./combinators.js";export{min,max,isPositive,isNegative,isDivisibleBy}from"./number.js";export{minDate,maxDate}from"./date.js";export{equals,notEquals,isEmpty,isNotEmpty,isIn,isNotIn}from"./common.js";export{minLength,maxLength,length,contains,notContains,matches,isLowercase,isUppercase,isAscii,isAlpha,isAlphanumeric,isHttpToken,isOrigin,isCorsOrigin,isBooleanString,isNumberString,isDecimal,isFullWidth,isHalfWidth,isVariableWidth,isMultibyte,isSurrogatePair,isHexadecimal,isOctal,isEmail,isURL,isUUID,isIP,isHexColor,isRgbColor,isHSL,isMACAddress,isISBN,isISIN,isISO8601,isISRC,isISSN,isJWT,isLatLong,isLocale,isDataURI,isFQDN,isPort,isEAN,isISO31661Alpha2,isISO31661Alpha3,isBIC,isFirebasePushId,isSemVer,isMongoId,isJSON,isBase32,isBase58,isBase64,isDateString,isMimeType,isCurrency,isMagnetURI,isCreditCard,isIBAN,isByteLength,isHash,isRFC3339,isMilitaryTime,isLatitude,isLongitude,isEthereumAddress,isBtcAddress,isISO4217CurrencyCode,isPhoneNumber,isStrongPassword,isTaxId,isULID,isCUID2}from"./string.js";export{arrayContains,arrayNotContains,arrayMinSize,arrayMaxSize,arrayUnique,arrayNotEmpty}from"./array.js";export{isNotEmptyObject,isInstance}from"./object.js";export{isMobilePhone,isPostalCode,isIdentityCard,isPassportNumber}from"./locales.js";export{isUint8Array,isByteSize}from"./binary.js";

package/dist/src/{rule-metadata.d.ts → rules/rule-metadata.d.ts}

@@ -1,4 +1,4 @@
-import type { EmittableRule, InternalRule, RulePlan } from './types';
+import type { EmittableRule, InternalRule, RulePlan } from './interfaces';
 interface RuleMetadata {
     emit: EmittableRule['emit'];
     ruleName: string;

package/dist/src/{rule-metadata.js → rules/rule-metadata.js}

@@ -1 +1 @@
-export function defineRuleMetadata(q,b){const j=q;j.emit=b.emit;j.ruleName=b.ruleName;if(b.requiresType!==void 0)j.requiresType=b.requiresType;if(b.constraints!==void 0)j.constraints=b.constraints;if(b.isAsync!==void 0)j.isAsync=b.isAsync;if(b.plan)j.plan=b.plan}
+export function defineRuleMetadata(q,b){const j=q;j.emit=b.emit;j.ruleName=b.ruleName;if(b.requiresType!==void 0)j.requiresType=b.requiresType;if(b.constraints!==void 0)j.constraints=b.constraints;if(b.isAsync!==void 0)j.isAsync=b.isAsync;if(b.plan!==void 0)j.plan=b.plan}

package/dist/src/{rule-plan.d.ts → rules/rule-plan.d.ts}

@@ -1,13 +1,10 @@
 import type { RequiredType } from './enums';
-import type { EmitContext, InternalRule, RulePlan, RulePlanCheck, RulePlanExpr } from './types';
+import type { EmitContext, InternalRule, RulePlan } from './interfaces';
+import type { RulePlanCache, RulePlanCheck, RulePlanExpr } from './types';
 import { RuleOp } from './enums';
-type RulePlanCache = {
-    length?: string;
-    time?: string;
-};
 declare const planValue: () => RulePlanExpr;
-declare const planLength: (object?: RulePlanExpr) => RulePlanExpr;
-declare const planTime: (object?: RulePlanExpr) => RulePlanExpr;
+declare const planLength: () => RulePlanExpr;
+declare const planTime: () => RulePlanExpr;
 declare const planLiteral: (value: number) => RulePlanExpr;
 declare const planCompare: (left: RulePlanExpr, op: RuleOp, right: number | RulePlanExpr) => RulePlanCheck;
 declare const planOr: (...checks: RulePlanCheck[]) => RulePlanCheck;

package/dist/src/rules/rule-plan.js

@@ -0,0 +1 @@
+import{RuleOp as X,RulePlanCheckKind as H,RulePlanExprKind as D}from"./enums.js";import{defineRuleMetadata as Y}from"./rule-metadata.js";const planValue=()=>({kind:D.Value});const planLength=()=>({kind:D.Member,property:"length"});const planTime=()=>({kind:D.Call0,method:"getTime"});const planLiteral=(z)=>({kind:D.Literal,value:z});const planCompare=(z,A,B)=>({kind:H.Compare,left:z,op:A,right:typeof B==="number"?planLiteral(B):B});const planOr=(...z)=>({kind:H.Or,checks:z});function makePlannedRule(z){const A={name:z.name,requiresType:z.requiresType,plan:z.plan,validate:z.validate,emit:(B,F)=>emitRulePlan(B,F,z.name,z.plan,void 0,F.insideTypeGate)};if(z.constraints!==void 0)A.constraints=z.constraints;return makeRule(A)}function makeRule(z){const A=(F)=>z.validate(F),B={emit:z.emit,ruleName:z.name,constraints:z.constraints??{}};if(z.requiresType!==void 0)B.requiresType=z.requiresType;if(z.isAsync!==void 0)B.isAsync=z.isAsync;if(z.plan!==void 0)B.plan=z.plan;Y(A,B);return A}function emitRulePlan(z,A,B,F,I,U){const W=U?Z(F.failure):F.failure;return`if (${Q(W,z,I)}) ${A.fail(B)};`}function Z(z){if(z.kind===H.Compare)return z;const A=z.checks.filter((B)=>!_(B));if(A.length===0)return z;if(A.length===1)return A[0];return{kind:z.kind,checks:A}}function _(z){if(z.kind!==H.Compare||z.op!==X.Neq)return!1;return $(z.left,z.right)}function $(z,A){switch(z.kind){case D.Value:return A.kind===D.Value;case D.Member:return A.kind===D.Member;case D.Call0:return A.kind===D.Call0;case D.Literal:return A.kind===D.Literal&&z.value===A.value;default:return z}}function Q(z,A,B){if(z.kind===H.Compare)return`${J(z.left,A,B)} ${z.op} ${J(z.right,A,B)}`;const F=z.kind===H.And?" && ":" || ";return`(${z.checks.map((I)=>Q(I,A,B)).join(F)})`}function J(z,A,B){switch(z.kind){case D.Value:return A;case D.Literal:return String(z.value);case D.Member:return B?.length??`${A}.length`;case D.Call0:return B?.time??`${A}.getTime()`;default:return z}}export{planValue,planLength,planTime,planLiteral,planCompare,planOr,makePlannedRule,makeRule,emitRulePlan};

package/dist/src/rules/string-basic.d.ts

@@ -0,0 +1,23 @@
+import type { EmittableRule } from './interfaces';
+declare function minLength(min: number): EmittableRule;
+declare function maxLength(max: number): EmittableRule;
+declare function length(minLen: number, maxLen: number): EmittableRule;
+declare function contains(seed: string): EmittableRule;
+declare function notContains(seed: string): EmittableRule;
+declare function matches(pattern: string | RegExp, modifiers?: string): EmittableRule;
+declare const isLowercase: import("./interfaces").InternalRule;
+declare const isUppercase: import("./interfaces").InternalRule;
+declare const isAscii: EmittableRule;
+declare const isAlpha: EmittableRule;
+declare const isAlphanumeric: EmittableRule;
+declare const isHttpToken: EmittableRule;
+declare const isOrigin: import("./interfaces").InternalRule;
+declare const isCorsOrigin: import("./interfaces").InternalRule;
+declare const isBooleanString: import("./interfaces").InternalRule;
+interface IsNumberStringOptions {
+    noSymbols?: boolean;
+}
+declare function isNumberString(options?: IsNumberStringOptions): EmittableRule;
+declare function isDecimal(): EmittableRule;
+export { minLength, maxLength, length, contains, notContains, matches, isLowercase, isUppercase, isAscii, isAlpha, isAlphanumeric, isHttpToken, isOrigin, isCorsOrigin, isBooleanString, isNumberString, isDecimal, };
+export type { IsNumberStringOptions };