@warlock.js/notifications 5.2.4 → 5.3.0

package/esm/seal/src/rules/scalar/declined-rule.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"declined-rule.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/scalar/declined-rule.ts"],"sourcesContent":["import { getFieldValue, invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport { isEmptyValue } from \"../../helpers/is-empty-value\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\nconst isDeclinedValue = (value: any) => {\r\n  return [\"0\", \"false\", \"no\", \"n\", \"off\", 0, false, \"No\", \"N\", \"Off\"].includes(value);\r\n};\r\n\r\n/**\r\n * Validate value as declined if it equals:\r\n * 0 | \"0\" | false | \"false\" | \"no\" | \"n\" | \"off\" | 0 | false | \"No\" | \"N\" | \"Off\"\r\n */\r\nexport const declinedRule: SchemaRule = {\r\n  name: \"declined\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  description:\r\n    \"The value must be declined if it equals: 0 | '0' | false | 'false' | 'no' | 'n' | 'off' | 0 | false | 'No' | 'N' | 'Off'\",\r\n  async validate(value: any, context) {\r\n    if (isDeclinedValue(value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Declined value if another field's value equals to a specific value\r\n */\r\nexport const declinedIfRule: SchemaRule<{ field: string; value: any }> = {\r\n  name: \"declinedIf\",\r\n  description: \"The field must be declined if :field's value equals to :value\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    const { value: expectedValue } = this.context.options;\r\n\r\n    this.context.translatableParams.field = this.context.options.field;\r\n    this.context.translatableParams.value = this.context.options.value;\r\n\r\n    if (fieldValue !== expectedValue) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is not equal to the given value\r\n */\r\nexport const declinedUnlessRule: SchemaRule<{ field: string; value: any }> = {\r\n  name: \"declinedUnless\",\r\n  description: \"The field must be declined if :field's value is not equal to :value\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    const { value: expectedValue } = this.context.options;\r\n\r\n    this.context.translatableParams.field = this.context.options.field;\r\n    this.context.translatableParams.value = this.context.options.value;\r\n    if (fieldValue === expectedValue) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is required\r\n */\r\nexport const declinedIfRequiredRule: SchemaRule<{ field: string }> = {\r\n  name: \"declinedIfRequired\",\r\n  description: \"The field must be declined if :field is required\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (isEmptyValue(fieldValue)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is present\r\n */\r\nexport const declinedIfPresentRule: SchemaRule<{ field: string }> = {\r\n  name: \"declinedIfPresent\",\r\n  description: \"The field must be declined if :field is present\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (fieldValue === undefined) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\n/**\r\n * Declined if another field is missing\r\n */\r\nexport const declinedWithoutRule: SchemaRule<{ field: string }> = {\r\n  name: \"declinedWithout\",\r\n  description: \"The field must be declined if :field is missing\",\r\n  defaultErrorMessage: \"The :input must be declined\",\r\n  async validate(value: any, context) {\r\n    const fieldValue = getFieldValue(this, context);\r\n    this.context.translatableParams.field = this.context.options.field;\r\n\r\n    if (fieldValue !== undefined) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    if (!isDeclinedValue(value)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;AAIA,MAAM,mBAAmB,UAAe;CACtC,OAAO;EAAC;EAAK;EAAS;EAAM;EAAK;EAAO;EAAG;EAAO;EAAM;EAAK;CAAK,CAAC,CAAC,SAAS,KAAK;AACpF;;;;;AAMA,MAAa,eAA2B;CACtC,MAAM;CACN,qBAAqB;CACrB,aACE;CACF,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,gBAAgB,KAAK,GACvB,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,iBAA4D;CACvE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAE9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,eACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,qBAAgE;CAC3E,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,MAAM,EAAE,OAAO,kBAAkB,KAAK,QAAQ;EAE9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAC7D,IAAI,eAAe,eACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,yBAAwD;CACnE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,aAAa,UAAU,GACzB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,wBAAuD;CAClE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,QACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF;;;;AAKA,MAAa,sBAAqD;CAChE,MAAM;CACN,aAAa;CACb,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,aAAa,cAAc,MAAM,OAAO;EAC9C,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,IAAI,eAAe,QACjB,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,CAAC,gBAAgB,KAAK,GACxB,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF"}

package/esm/seal/src/rules/scalar/index.mjs

@@ -1,4 +0,0 @@
-import { acceptedIfPresentRule, acceptedIfRequiredRule, acceptedIfRule, acceptedRule, acceptedUnlessRule, acceptedWithoutRule } from "./accepted-rule.mjs";
-import { declinedIfPresentRule, declinedIfRequiredRule, declinedIfRule, declinedRule, declinedUnlessRule, declinedWithoutRule } from "./declined-rule.mjs";
-
-export {  };

package/esm/seal/src/rules/string/alpha.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"alpha.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/alpha.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Alpha rule - allows only alphabetic characters\r\n */\r\nexport const alphaRule: SchemaRule = {\r\n  name: \"alpha\",\r\n  defaultErrorMessage: \"The :input must contain only alphabetic characters\",\r\n  async validate(value: any, context) {\r\n    if (/^[a-zA-Z]+$/.test(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * AlphaNumeric rule - allows only alphanumeric characters\r\n */\r\nexport const alphaNumericRule: SchemaRule = {\r\n  name: \"alphaNumeric\",\r\n  defaultErrorMessage: \"The :input must contain only alphanumeric characters\",\r\n  async validate(value: any, context) {\r\n    if (/^[a-zA-Z0-9]+$/.test(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Numeric string rule - allows only numeric characters\r\n */\r\nexport const isNumericRule: SchemaRule = {\r\n  name: \"numeric\",\r\n  defaultErrorMessage: \"The :input must contain only numeric characters\",\r\n  async validate(value: any, context) {\r\n    if (/^[0-9]+$/.test(String(value))) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,YAAwB;CACnC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,cAAc,KAAK,KAAK,GAC1B,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,mBAA+B;CAC1C,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,iBAAiB,KAAK,KAAK,GAC7B,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,gBAA4B;CACvC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,WAAW,KAAK,OAAO,KAAK,CAAC,GAC/B,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/seal/src/rules/string/credit-card.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"credit-card.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/credit-card.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Credit card rule - validates credit card number\r\n */\r\nexport const isCreditCardRule: SchemaRule = {\r\n  name: \"creditCard\",\r\n  defaultErrorMessage: \"The :input must be a valid credit card number\",\r\n  async validate(value: any, context) {\r\n    // Luhn algorithm for credit card validation\r\n    const cardNumber = String(value).replace(/\\s/g, \"\");\r\n\r\n    if (!/^\\d+$/.test(cardNumber)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    let sum = 0;\r\n    let isEven = false;\r\n\r\n    for (let i = cardNumber.length - 1; i >= 0; i--) {\r\n      let digit = parseInt(cardNumber[i], 10);\r\n\r\n      if (isEven) {\r\n        digit *= 2;\r\n        if (digit > 9) {\r\n          digit -= 9;\r\n        }\r\n      }\r\n\r\n      sum += digit;\r\n      isEven = !isEven;\r\n    }\r\n\r\n    if (sum % 10 === 0) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,mBAA+B;CAC1C,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAElC,MAAM,aAAa,OAAO,KAAK,CAAC,CAAC,QAAQ,OAAO,EAAE;EAElD,IAAI,CAAC,QAAQ,KAAK,UAAU,GAC1B,OAAO,YAAY,MAAM,OAAO;EAGlC,IAAI,MAAM;EACV,IAAI,SAAS;EAEb,KAAK,IAAI,IAAI,WAAW,SAAS,GAAG,KAAK,GAAG,KAAK;GAC/C,IAAI,QAAQ,SAAS,WAAW,IAAI,EAAE;GAEtC,IAAI,QAAQ;IACV,SAAS;IACT,IAAI,QAAQ,GACV,SAAS;GAEb;GAEA,OAAO;GACP,SAAS,CAAC;EACZ;EAEA,IAAI,MAAM,OAAO,GACf,OAAO;EAGT,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/seal/src/rules/string/email.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"email.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/email.ts"],"sourcesContent":["import { isEmail } from \"@mongez/supportive-is\";\r\nimport { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Email rule - validates email format\r\n */\r\nexport const emailRule: SchemaRule = {\r\n  name: \"email\",\r\n  defaultErrorMessage: \"The :input must be a valid email address\",\r\n  async validate(value: any, context) {\r\n    if (isEmail(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;AAOA,MAAa,YAAwB;CACnC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,QAAQ,KAAK,GACf,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/seal/src/rules/string/id-formats.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"id-formats.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/id-formats.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\nimport type { SchemaRule } from \"../../types\";\n\n/**\n * Modern ID format validators — UUID, CUID, ULID, nanoid.\n *\n * Each rule asserts the value is a string in the canonical format for its\n * identifier scheme. Rules are intentionally strict (variant nibbles checked\n * for UUID, character classes enforced for ULID's Crockford base32, etc.)\n * so \"looks-like-but-not-valid\" inputs are rejected.\n */\n\nconst UUID_ANY = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\nconst UUID_BY_VERSION: Record<1 | 3 | 4 | 5 | 6 | 7, RegExp> = {\n  1: /^[0-9a-f]{8}-[0-9a-f]{4}-1[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  3: /^[0-9a-f]{8}-[0-9a-f]{4}-3[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  4: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  5: /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  6: /^[0-9a-f]{8}-[0-9a-f]{4}-6[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n  7: /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,\n};\n\nexport type UUIDVersion = 1 | 3 | 4 | 5 | 6 | 7;\n\n/**\n * UUID rule — value must be a valid UUID. Optionally restrict to a specific version.\n *\n * @example\n * v.string().uuid()       // any RFC 4122 UUID\n * v.string().uuid(4)      // only v4 (random)\n * v.string().uuid(7)      // only v7 (timestamp-ordered)\n */\nexport const uuidRule: SchemaRule<{ version?: UUIDVersion }> = {\n  name: \"uuid\",\n  defaultErrorMessage: \"The :input must be a valid UUID\",\n  async validate(value, context) {\n    if (typeof value !== \"string\") return invalidRule(this, context);\n\n    const version = this.context.options.version;\n\n    const pattern = version ? UUID_BY_VERSION[version] : UUID_ANY;\n    if (pattern.test(value)) return VALID_RULE;\n\n    if (version !== undefined) {\n      this.context.translationParams.version = version;\n    }\n\n    return invalidRule(this, context);\n  },\n};\n\n/**\n * CUID rule — value must be a valid CUID.\n *\n * Defaults to CUID2 (24 chars, lowercase, starts with letter — see\n * https://github.com/paralleldrive/cuid2). Pass `{ version: 1 }` for legacy\n * CUID1 format (starts with \"c\", ≥25 chars).\n *\n * @example\n * v.string().cuid()                  // CUID2\n * v.string().cuid({ version: 1 })    // legacy CUID1\n */\nexport const cuidRule: SchemaRule<{ version?: 1 | 2 }> = {\n  name: \"cuid\",\n  defaultErrorMessage: \"The :input must be a valid CUID\",\n  async validate(value, context) {\n    if (typeof value !== \"string\") return invalidRule(this, context);\n    const version = this.context.options.version ?? 2;\n    const pattern = version === 1 ? /^c[a-z0-9]{24,}$/ : /^[a-z][a-z0-9]{23}$/;\n    if (pattern.test(value)) return VALID_RULE;\n    this.context.translationParams.version = version;\n    return invalidRule(this, context);\n  },\n};\n\n/**\n * ULID rule — value must be a valid ULID (26 chars, Crockford base32).\n *\n * Crockford base32 excludes the letters I, L, O, U to avoid ambiguity.\n *\n * @example\n * v.string().ulid()\n */\nexport const ulidRule: SchemaRule = {\n  name: \"ulid\",\n  defaultErrorMessage: \"The :input must be a valid ULID\",\n  async validate(value, context) {\n    if (typeof value !== \"string\") return invalidRule(this, context);\n    if (/^[0-9A-HJKMNP-TV-Z]{26}$/.test(value)) return VALID_RULE;\n    return invalidRule(this, context);\n  },\n};\n\n/**\n * nanoid rule — value must be a valid nanoid string.\n *\n * Default length is 21 (standard nanoid). URL-safe alphabet:\n * A–Z, a–z, 0–9, `_`, `-`.\n *\n * @example\n * v.string().nanoid()         // 21 chars (default)\n * v.string().nanoid(10)       // 10 chars\n */\nexport const nanoidRule: SchemaRule<{ length?: number }> = {\n  name: \"nanoid\",\n  defaultErrorMessage: \"The :input must be a valid nanoid\",\n  async validate(value, context) {\n    if (typeof value !== \"string\") return invalidRule(this, context);\n    const length = this.context.options.length ?? 21;\n    const pattern = new RegExp(`^[A-Za-z0-9_-]{${length}}$`);\n    if (pattern.test(value)) return VALID_RULE;\n    this.context.translationParams.length = length;\n    return invalidRule(this, context);\n  },\n};\n"],"mappings":";;;;;;;;;;;;AAYA,MAAM,WAAW;AAEjB,MAAM,kBAAyD;CAC7D,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;CACH,GAAG;AACL;;;;;;;;;AAYA,MAAa,WAAkD;CAC7D,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,OAAO,UAAU,UAAU,OAAO,YAAY,MAAM,OAAO;EAE/D,MAAM,UAAU,KAAK,QAAQ,QAAQ;EAGrC,KADgB,UAAU,gBAAgB,WAAW,SAC1C,CAAC,KAAK,KAAK,GAAG,OAAO;EAEhC,IAAI,YAAY,QACd,KAAK,QAAQ,kBAAkB,UAAU;EAG3C,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;;;;;;;;;AAaA,MAAa,WAA4C;CACvD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,OAAO,UAAU,UAAU,OAAO,YAAY,MAAM,OAAO;EAC/D,MAAM,UAAU,KAAK,QAAQ,QAAQ,WAAW;EAEhD,KADgB,YAAY,IAAI,qBAAqB,sBAC1C,CAAC,KAAK,KAAK,GAAG,OAAO;EAChC,KAAK,QAAQ,kBAAkB,UAAU;EACzC,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;;;;;;AAUA,MAAa,WAAuB;CAClC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,OAAO,UAAU,UAAU,OAAO,YAAY,MAAM,OAAO;EAC/D,IAAI,2BAA2B,KAAK,KAAK,GAAG,OAAO;EACnD,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;;;;;;;;AAYA,MAAa,aAA8C;CACzD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,OAAO,UAAU,UAAU,OAAO,YAAY,MAAM,OAAO;EAC/D,MAAM,SAAS,KAAK,QAAQ,QAAQ,UAAU;EAE9C,IAAI,IADgB,OAAO,kBAAkB,OAAO,GAC1C,CAAC,CAAC,KAAK,KAAK,GAAG,OAAO;EAChC,KAAK,QAAQ,kBAAkB,SAAS;EACxC,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/seal/src/rules/string/index.mjs

@@ -1,13 +0,0 @@
-import { alphaNumericRule, alphaRule, isNumericRule } from "./alpha.mjs";
-import { isCreditCardRule } from "./credit-card.mjs";
-import { emailRule } from "./email.mjs";
-import { cuidRule, nanoidRule, ulidRule, uuidRule } from "./id-formats.mjs";
-import { ip4Rule, ip6Rule, ipRule, isIP, isIPv4, isIPv6 } from "./ip.mjs";
-import "./matches.mjs";
-import { patternRule } from "./pattern.mjs";
-import { containsRule, endsWithRule, notContainsRule, startsWithRule } from "./string-comparison.mjs";
-import { strongPasswordRule } from "./strong-password-rule.mjs";
-import { urlRule } from "./url.mjs";
-import { withoutWhitespaceRule } from "./without-whitespace.mjs";
-
-export {  };

package/esm/seal/src/rules/string/ip.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ip.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/ip.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\nimport type { SchemaRule } from \"../../types\";\n\n/**\n * Pure, dependency-free re-implementation of Node's `net.isIP`/`isIPv4`/`isIPv6`.\n * Mirrors the exact regex Node uses internally (lib/internal/net.js) so that\n * behavior stays identical while remaining runnable in the browser (no `net` import).\n */\nconst v4Seg = \"(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\";\nconst v4Str = `(${v4Seg}[.]){3}${v4Seg}`;\nconst IPv4Reg = new RegExp(`^${v4Str}$`);\n\nconst v6Seg = \"(?:[0-9a-fA-F]{1,4})\";\nconst IPv6Reg = new RegExp(\n  \"^(\" +\n    `(?:${v6Seg}:){7}(?:${v6Seg}|:)|` +\n    `(?:${v6Seg}:){6}(?:${v4Str}|:${v6Seg}|:)|` +\n    `(?:${v6Seg}:){5}(?::${v4Str}|(:${v6Seg}){1,2}|:)|` +\n    `(?:${v6Seg}:){4}(?:(:${v6Seg}){0,1}:${v4Str}|(:${v6Seg}){1,3}|:)|` +\n    `(?:${v6Seg}:){3}(?:(:${v6Seg}){0,2}:${v4Str}|(:${v6Seg}){1,4}|:)|` +\n    `(?:${v6Seg}:){2}(?:(:${v6Seg}){0,3}:${v4Str}|(:${v6Seg}){1,5}|:)|` +\n    `(?:${v6Seg}:){1}(?:(:${v6Seg}){0,4}:${v4Str}|(:${v6Seg}){1,6}|:)|` +\n    `(?::((?::${v6Seg}){0,5}:${v4Str}|(?::${v6Seg}){1,7}|:))` +\n    \")(%[0-9a-zA-Z-.:]{1,})?$\",\n);\n\nexport function isIPv4(value: string): boolean {\n  return IPv4Reg.test(value);\n}\n\nexport function isIPv6(value: string): boolean {\n  return IPv6Reg.test(value);\n}\n\n/**\n * Returns 4 or 6 when `value` is a valid IPv4/IPv6 address, otherwise 0.\n * Signature mirrors Node's `net.isIP` for drop-in behavior parity.\n */\nexport function isIP(value: string): 0 | 4 | 6 {\n  if (isIPv4(value)) return 4;\n  if (isIPv6(value)) return 6;\n  return 0;\n}\n\n/**\n * IP rule - validates IP address (v4 or v6)\n */\nexport const ipRule: SchemaRule = {\n  name: \"ip\",\n  defaultErrorMessage: \"The :input must be a valid IP address\",\n  async validate(value: any, context) {\n    if (isIP(value)) {\n      return VALID_RULE;\n    }\n    return invalidRule(this, context);\n  },\n};\n\n/**\n * IPv4 rule - validates IPv4 address\n */\nexport const ip4Rule: SchemaRule = {\n  name: \"ip4\",\n  defaultErrorMessage: \"The :input must be a valid IPv4 address\",\n  async validate(value: any, context) {\n    if (isIP(value) === 4) {\n      return VALID_RULE;\n    }\n    return invalidRule(this, context);\n  },\n};\n\n/**\n * IPv6 rule - validates IPv6 address\n */\nexport const ip6Rule: SchemaRule = {\n  name: \"ip6\",\n  defaultErrorMessage: \"The :input must be a valid IPv6 address\",\n  async validate(value: any, context) {\n    if (isIP(value) === 6) {\n      return VALID_RULE;\n    }\n    return invalidRule(this, context);\n  },\n};\n"],"mappings":";;;;;;;;;AAQA,MAAM,QAAQ;AACd,MAAM,QAAQ,IAAI,MAAM,SAAS;AACjC,MAAM,UAAU,IAAI,OAAO,IAAI,MAAM,EAAE;AAEvC,MAAM,QAAQ;AACd,MAAM,UAAU,IAAI,OAClB,QACQ,MAAM,UAAU,MAAM,SACtB,MAAM,UAAU,MAAM,IAAI,MAAM,SAChC,MAAM,WAAW,MAAM,KAAK,MAAM,eAClC,MAAM,YAAY,MAAM,SAAS,MAAM,KAAK,MAAM,eAClD,MAAM,YAAY,MAAM,SAAS,MAAM,KAAK,MAAM,eAClD,MAAM,YAAY,MAAM,SAAS,MAAM,KAAK,MAAM,eAClD,MAAM,YAAY,MAAM,SAAS,MAAM,KAAK,MAAM,qBAC5C,MAAM,SAAS,MAAM,OAAO,MAAM,oCAElD;AAEA,SAAgB,OAAO,OAAwB;CAC7C,OAAO,QAAQ,KAAK,KAAK;AAC3B;AAEA,SAAgB,OAAO,OAAwB;CAC7C,OAAO,QAAQ,KAAK,KAAK;AAC3B;;;;;AAMA,SAAgB,KAAK,OAA0B;CAC7C,IAAI,OAAO,KAAK,GAAG,OAAO;CAC1B,IAAI,OAAO,KAAK,GAAG,OAAO;CAC1B,OAAO;AACT;;;;AAKA,MAAa,SAAqB;CAChC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,KAAK,KAAK,GACZ,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,UAAsB;CACjC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,KAAK,KAAK,MAAM,GAClB,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,UAAsB;CACjC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,KAAK,KAAK,MAAM,GAClB,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/seal/src/rules/string/matches.mjs

@@ -1,4 +0,0 @@
-import "../../../../node_modules/.pnpm/@mongez_reinforcements@4.0.1/node_modules/@mongez/reinforcements/esm/index.mjs";
-import "../../helpers/index.mjs";
-
-export {  };

package/esm/seal/src/rules/string/pattern.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"pattern.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/pattern.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Pattern rule - validates against regex pattern\r\n */\r\nexport const patternRule: SchemaRule<{ pattern: RegExp }> = {\r\n  name: \"pattern\",\r\n  defaultErrorMessage: \"The :input does not match the required pattern\",\r\n  async validate(value: any, context) {\r\n    if (this.context.options.pattern.test(value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    this.context.translationParams.pattern = this.context.options.pattern.toString();\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,cAA+C;CAC1D,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,KAAK,QAAQ,QAAQ,QAAQ,KAAK,KAAK,GACzC,OAAO;EAGT,KAAK,QAAQ,kBAAkB,UAAU,KAAK,QAAQ,QAAQ,QAAQ,SAAS;EAC/E,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/seal/src/rules/string/string-comparison.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"string-comparison.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/string-comparison.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Starts with rule\r\n */\r\nexport const startsWithRule: SchemaRule<{ value: string }> = {\r\n  name: \"startsWith\",\r\n  defaultErrorMessage: \"The :input must start with :value\",\r\n  async validate(value: any, context) {\r\n    if (String(value).startsWith(this.context.options.value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    this.context.translatableParams.value = this.context.options.value;\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Ends with rule\r\n */\r\nexport const endsWithRule: SchemaRule<{ value: string }> = {\r\n  name: \"endsWith\",\r\n  defaultErrorMessage: \"The :input must end with :value\",\r\n  async validate(value: any, context) {\r\n    if (String(value).endsWith(this.context.options.value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    this.context.translatableParams.value = this.context.options.value;\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Contains rule\r\n */\r\nexport const containsRule: SchemaRule<{ value: string }> = {\r\n  name: \"contains\",\r\n  defaultErrorMessage: \"The :input must contain :value\",\r\n  async validate(value: any, context) {\r\n    if (String(value).includes(this.context.options.value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    this.context.translatableParams.value = this.context.options.value;\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n\r\n/**\r\n * Not contains rule\r\n */\r\nexport const notContainsRule: SchemaRule<{ value: string }> = {\r\n  name: \"notContains\",\r\n  defaultErrorMessage: \"The :input must not contain :value\",\r\n  async validate(value: any, context) {\r\n    if (!String(value).includes(this.context.options.value)) {\r\n      return VALID_RULE;\r\n    }\r\n\r\n    this.context.translatableParams.value = this.context.options.value;\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,iBAAgD;CAC3D,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,OAAO,KAAK,CAAC,CAAC,WAAW,KAAK,QAAQ,QAAQ,KAAK,GACrD,OAAO;EAGT,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,eAA8C;CACzD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,OAAO,KAAK,CAAC,CAAC,SAAS,KAAK,QAAQ,QAAQ,KAAK,GACnD,OAAO;EAGT,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,eAA8C;CACzD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,OAAO,KAAK,CAAC,CAAC,SAAS,KAAK,QAAQ,QAAQ,KAAK,GACnD,OAAO;EAGT,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,OAAO,YAAY,MAAM,OAAO;CAClC;AACF;;;;AAKA,MAAa,kBAAiD;CAC5D,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,CAAC,OAAO,KAAK,CAAC,CAAC,SAAS,KAAK,QAAQ,QAAQ,KAAK,GACpD,OAAO;EAGT,KAAK,QAAQ,mBAAmB,QAAQ,KAAK,QAAQ,QAAQ;EAE7D,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/seal/src/rules/string/strong-password-rule.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"strong-password-rule.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/strong-password-rule.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Strong Password rule - validates password strength\r\n * Requirements:\r\n * - At least 8 characters\r\n * - At least 1 uppercase letter\r\n * - At least 1 lowercase letter\r\n * - At least 1 number\r\n * - At least 1 special character\r\n */\r\nexport const strongPasswordRule: SchemaRule<{ minLength?: number }> = {\r\n  name: \"strongPassword\",\r\n  defaultErrorMessage:\r\n    \"The :input must be at least 8 characters and contain at least one uppercase letter, one lowercase letter, one number, and one special character\",\r\n  async validate(value: any, context) {\r\n    const password = String(value);\r\n    const minLength = this.context.options.minLength ?? 8;\r\n\r\n    // Check minimum length\r\n    if (password.length < minLength) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    // Check for at least one uppercase letter\r\n    if (!/[A-Z]/.test(password)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    // Check for at least one lowercase letter\r\n    if (!/[a-z]/.test(password)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    // Check for at least one number\r\n    if (!/[0-9]/.test(password)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    // Check for at least one special character\r\n    if (!/[!@#$%^&*()_+\\-=[\\]{};':\"\\\\|,.<>/?]/.test(password)) {\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n"],"mappings":";;;;;;;;;;;;;AAYA,MAAa,qBAAyD;CACpE,MAAM;CACN,qBACE;CACF,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,WAAW,OAAO,KAAK;EAC7B,MAAM,YAAY,KAAK,QAAQ,QAAQ,aAAa;EAGpD,IAAI,SAAS,SAAS,WACpB,OAAO,YAAY,MAAM,OAAO;EAIlC,IAAI,CAAC,QAAQ,KAAK,QAAQ,GACxB,OAAO,YAAY,MAAM,OAAO;EAIlC,IAAI,CAAC,QAAQ,KAAK,QAAQ,GACxB,OAAO,YAAY,MAAM,OAAO;EAIlC,IAAI,CAAC,QAAQ,KAAK,QAAQ,GACxB,OAAO,YAAY,MAAM,OAAO;EAIlC,IAAI,CAAC,sCAAsC,KAAK,QAAQ,GACtD,OAAO,YAAY,MAAM,OAAO;EAGlC,OAAO;CACT;AACF"}

package/esm/seal/src/rules/string/url.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"url.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/url.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * URL rule - validates URL format\r\n */\r\nexport const urlRule: SchemaRule = {\r\n  name: \"url\",\r\n  defaultErrorMessage: \"The :input must be a valid URL\",\r\n  async validate(value: any, context) {\r\n    try {\r\n      new URL(value);\r\n      return VALID_RULE;\r\n    } catch {\r\n      return invalidRule(this, context);\r\n    }\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,UAAsB;CACjC,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI;GACF,IAAI,IAAI,KAAK;GACb,OAAO;EACT,QAAQ;GACN,OAAO,YAAY,MAAM,OAAO;EAClC;CACF;AACF"}

package/esm/seal/src/rules/string/without-whitespace.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"without-whitespace.mjs","names":[],"sources":["../../../../../../../../../../seal/src/rules/string/without-whitespace.ts"],"sourcesContent":["import { invalidRule, VALID_RULE } from \"../../helpers\";\r\nimport type { SchemaRule } from \"../../types\";\r\n\r\n/**\r\n * Without whitespace rule - value must not contain whitespace\r\n */\r\nexport const withoutWhitespaceRule: SchemaRule = {\r\n  name: \"withoutWhitespace\",\r\n  defaultErrorMessage: \"The :input must not contain whitespace\",\r\n  async validate(value: any, context) {\r\n    if (!/\\s/.test(value)) {\r\n      return VALID_RULE;\r\n    }\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;;;AAMA,MAAa,wBAAoC;CAC/C,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,IAAI,CAAC,KAAK,KAAK,KAAK,GAClB,OAAO;EAET,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/seal/src/standard-schema/json-schema.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"json-schema.mjs","names":[],"sources":["../../../../../../../../../seal/src/standard-schema/json-schema.ts"],"sourcesContent":["import type { StandardJSONSchemaV1 } from \"./types\";\n\n/**\n * Supported JSON Schema generation targets.\n */\nexport type JsonSchemaTarget = StandardJSONSchemaV1.Target;\n\n/**\n * The result shape for a generated JSON Schema.\n */\nexport type JsonSchemaResult = Record<string, unknown>;\n\n/**\n * Apply nullable to a JSON Schema object based on the target dialect.\n *\n * - draft-2020-12  : `type` becomes an array: `[\"string\", \"null\"]`\n * - openai-strict  : same as draft-2020-12 (type array form)\n * - draft-07       : wraps in `oneOf: [{ ...schema }, { type: \"null\" }]`\n * - openapi-3.0    : adds `nullable: true` alongside the existing type\n *\n * Mutates the schema in-place.\n *\n * @example\n * ```ts\n * const schema = { type: \"string\" };\n * applyNullable(schema, \"draft-2020-12\");\n * // → { type: [\"string\", \"null\"] }\n * ```\n */\nexport function applyNullable(schema: JsonSchemaResult, target: JsonSchemaTarget): void {\n  if (target === \"openapi-3.0\") {\n    schema.nullable = true;\n    return;\n  }\n\n  if (target === \"draft-2020-12\" || target === \"openai-strict\") {\n    const baseType = schema.type as string | string[] | undefined;\n    schema.type = Array.isArray(baseType)\n      ? [...baseType, \"null\"]\n      : [baseType as string, \"null\"];\n    return;\n  }\n\n  // draft-07: oneOf wrapping\n  const copy = { ...schema };\n  for (const key of Object.keys(schema)) {\n    delete schema[key];\n  }\n  schema.oneOf = [copy, { type: \"null\" }];\n}\n\n/**\n * Wrap a field schema as nullable for OpenAI strict mode.\n *\n * OpenAI strict requires optional fields to be expressed as a nullable type\n * rather than being omitted from the `required` array. This helper wraps a\n * given schema into its nullable equivalent using the type-array form.\n *\n * Unlike `applyNullable()` (which mutates in-place), this returns a new\n * schema object to avoid side effects when wrapping child schemas.\n *\n * @example\n * ```ts\n * wrapNullableStrict({ type: \"string\", minLength: 3 })\n * // → { type: [\"string\", \"null\"], minLength: 3 }\n *\n * wrapNullableStrict({ type: \"object\", properties: {...} })\n * // → { type: [\"object\", \"null\"], properties: {...} }\n *\n * wrapNullableStrict({ oneOf: [...] })\n * // → { oneOf: [..., { type: \"null\" }] }\n * ```\n */\nexport function wrapNullableStrict(schema: JsonSchemaResult): JsonSchemaResult {\n  // If the schema uses oneOf/anyOf (e.g. union), append null to the list\n  if (schema.oneOf) {\n    return { ...schema, oneOf: [...(schema.oneOf as unknown[]), { type: \"null\" }] };\n  }\n\n  if (schema.anyOf) {\n    return { ...schema, anyOf: [...(schema.anyOf as unknown[]), { type: \"null\" }] };\n  }\n\n  // If there's no type at all (permissive `{}`), stay permissive\n  if (schema.type === undefined) {\n    return schema;\n  }\n\n  // Standard case: wrap type into array with null\n  const baseType = schema.type as string | string[];\n  return {\n    ...schema,\n    type: Array.isArray(baseType) ? [...baseType, \"null\"] : [baseType, \"null\"],\n  };\n}\n\n/**\n * Find the first rule matching the given name in a rules array,\n * and return its options bag.\n */\nexport function getRuleOptions(\n  rules: Array<{ name: string; context: { options: Record<string, unknown> } }>,\n  ruleName: string,\n): Record<string, unknown> | undefined {\n  const rule = rules.find(r => r.name === ruleName);\n  return rule?.context?.options as Record<string, unknown> | undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA6BA,SAAgB,cAAc,QAA0B,QAAgC;CACtF,IAAI,WAAW,eAAe;EAC5B,OAAO,WAAW;EAClB;CACF;CAEA,IAAI,WAAW,mBAAmB,WAAW,iBAAiB;EAC5D,MAAM,WAAW,OAAO;EACxB,OAAO,OAAO,MAAM,QAAQ,QAAQ,IAChC,CAAC,GAAG,UAAU,MAAM,IACpB,CAAC,UAAoB,MAAM;EAC/B;CACF;CAGA,MAAM,OAAO,EAAE,GAAG,OAAO;CACzB,KAAK,MAAM,OAAO,OAAO,KAAK,MAAM,GAClC,OAAO,OAAO;CAEhB,OAAO,QAAQ,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC;AACxC;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,mBAAmB,QAA4C;CAE7E,IAAI,OAAO,OACT,OAAO;EAAE,GAAG;EAAQ,OAAO,CAAC,GAAI,OAAO,OAAqB,EAAE,MAAM,OAAO,CAAC;CAAE;CAGhF,IAAI,OAAO,OACT,OAAO;EAAE,GAAG;EAAQ,OAAO,CAAC,GAAI,OAAO,OAAqB,EAAE,MAAM,OAAO,CAAC;CAAE;CAIhF,IAAI,OAAO,SAAS,QAClB,OAAO;CAIT,MAAM,WAAW,OAAO;CACxB,OAAO;EACL,GAAG;EACH,MAAM,MAAM,QAAQ,QAAQ,IAAI,CAAC,GAAG,UAAU,MAAM,IAAI,CAAC,UAAU,MAAM;CAC3E;AACF;;;;;AAMA,SAAgB,eACd,OACA,UACqC;CAErC,OADa,MAAM,MAAK,MAAK,EAAE,SAAS,QAC9B,CAAC,EAAE,SAAS;AACxB"}

package/esm/seal/src/standard-schema/map-result.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"map-result.mjs","names":[],"sources":["../../../../../../../../../seal/src/standard-schema/map-result.ts"],"sourcesContent":["import type { ValidationResult } from \"../types\";\nimport type { StandardSchemaV1 } from \"./types\";\n\n/**\n * Maps a Seal ValidationResult to a Standard Schema result shape.\n *\n * Seal error paths are dot-notation strings (e.g. \"address.city\").\n * Standard Schema expects an array of path segments: [{ key: \"address\" }, { key: \"city\" }].\n *\n * @example\n * ```ts\n * const result = await validator.validate(value, context);\n * return mapToStandardResult(result);\n * // Success → { value: <data> }\n * // Failure → { issues: [{ message: \"...\", path: [{ key: \"...\" }] }] }\n * ```\n */\nexport function mapToStandardResult(\n  result: ValidationResult,\n): StandardSchemaV1.Result<unknown> {\n  if (result.isValid) {\n    return { value: result.data };\n  }\n\n  return {\n    issues: result.errors.map(e => ({\n      message: e.error,\n      path: e.input\n        ? e.input.split(\".\").map(key => ({ key }))\n        : undefined,\n    })),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;AAiBA,SAAgB,oBACd,QACkC;CAClC,IAAI,OAAO,SACT,OAAO,EAAE,OAAO,OAAO,KAAK;CAG9B,OAAO,EACL,QAAQ,OAAO,OAAO,KAAI,OAAM;EAC9B,SAAS,EAAE;EACX,MAAM,EAAE,QACJ,EAAE,MAAM,MAAM,GAAG,CAAC,CAAC,KAAI,SAAQ,EAAE,IAAI,EAAE,IACvC;CACN,EAAE,EACJ;AACF"}

package/esm/seal/src/types/date-types.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"date-types.mjs","names":[],"sources":["../../../../../../../../../seal/src/types/date-types.ts"],"sourcesContent":["/**\r\n * Week day names for validation\r\n */\r\nexport type WeekDay =\r\n  | \"sunday\"\r\n  | \"monday\"\r\n  | \"tuesday\"\r\n  | \"wednesday\"\r\n  | \"thursday\"\r\n  | \"friday\"\r\n  | \"saturday\";\r\n\r\n/**\r\n * Week day numbers mapping\r\n */\r\nexport const WEEK_DAYS: Record<WeekDay, number> = {\r\n  sunday: 0,\r\n  monday: 1,\r\n  tuesday: 2,\r\n  wednesday: 3,\r\n  thursday: 4,\r\n  friday: 5,\r\n  saturday: 6,\r\n};\r\n"],"mappings":";;;;AAeA,MAAa,YAAqC;CAChD,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,WAAW;CACX,UAAU;CACV,QAAQ;CACR,UAAU;AACZ"}

package/esm/seal/src/validators/any-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"any-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/any-validator.ts"],"sourcesContent":["import type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\r\nimport { applyNullable } from \"../standard-schema/json-schema\";\r\nimport { BaseValidator } from \"./base-validator\";\r\n\r\n/**\r\n * Any validator - accepts any value\r\n */\r\nexport class AnyValidator extends BaseValidator {\r\n  /**\r\n   * Any validator means any value, so we disable the default required requirement.\r\n   */\r\n  public override requiredRule = null;\r\n\r\n  /**\r\n   * Set is optional to be true\r\n   */\r\n  public override isOptional = true;\r\n\r\n  /**\r\n   * @inheritdoc\r\n   *\r\n   * Any validator accepts anything. In JSON Schema, an empty object `{}`\r\n   * is the permissive schema that accepts any valid JSON value.\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * v.any().toJsonSchema(\"draft-2020-12\")\r\n   * // → {}\r\n   * ```\r\n   */\r\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\r\n    const schema: JsonSchemaResult = {};\r\n    if (this.isNullable) applyNullable(schema, target);\r\n    return schema;\r\n  }\r\n}\r\n"],"mappings":";;;;;;;AAOA,IAAa,eAAb,cAAkC,cAAc;;;;CAI9C,AAAgB,eAAe;;;;CAK/B,AAAgB,aAAa;;;;;;;;;;;;;CAc7B,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,MAAM,SAA2B,CAAC;EAClC,IAAI,KAAK,YAAY,cAAc,QAAQ,MAAM;EACjD,OAAO;CACT;AACF"}

package/esm/seal/src/validators/array-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"array-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/array-validator.ts"],"sourcesContent":["import { setKeyPath } from \"../helpers\";\r\nimport { flipArrayMutator, sortArrayMutator, uniqueArrayMutator } from \"../mutators\";\r\nimport {\r\n  arrayRule,\r\n  betweenLengthRule,\r\n  lengthRule,\r\n  maxLengthRule,\r\n  minLengthRule,\r\n  sortedArrayRule,\r\n  uniqueArrayRule,\r\n} from \"../rules\";\r\nimport type { SchemaContext, ValidationResult } from \"../types\";\r\nimport { BaseValidator } from \"./base-validator\";\r\nimport { applyNullable, getRuleOptions } from \"../standard-schema/json-schema\";\r\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\r\n\r\n/**\r\n * Array validator class\r\n */\r\nexport class ArrayValidator extends BaseValidator {\r\n  public constructor(\r\n    public validator: BaseValidator,\r\n    errorMessage?: string,\r\n  ) {\r\n    super();\r\n    this.addMutableRule(arrayRule, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * Check if value is an array type\r\n   */\r\n  public matchesType(value: any): boolean {\r\n    return Array.isArray(value);\r\n  }\r\n\r\n  /**\r\n   * Clone the validator\r\n   */\r\n  public override clone(): this {\r\n    const cloned = super.clone();\r\n\r\n    cloned.validator = this.validator.clone();\r\n\r\n    return cloned;\r\n  }\r\n\r\n  /** Reverse array order */\r\n  public flip() {\r\n    return this.addMutator(flipArrayMutator);\r\n  }\r\n\r\n  /** Reverse array order (alias) */\r\n  public reverse() {\r\n    return this.addMutator(flipArrayMutator);\r\n  }\r\n\r\n  /** Make it has only unique values */\r\n  public onlyUnique() {\r\n    return this.addMutator(uniqueArrayMutator);\r\n  }\r\n\r\n  /** Sort array */\r\n  public sort(direction: \"asc\" | \"desc\" = \"asc\", key?: string) {\r\n    return this.addMutator(sortArrayMutator, { direction, key });\r\n  }\r\n\r\n  /** Array length must be greater than the given length */\r\n  public minLength(length: number, errorMessage?: string) {\r\n    return this.addRule(minLengthRule, errorMessage, { minLength: length });\r\n  }\r\n\r\n  /** Array length must be less than the given length */\r\n  public maxLength(length: number, errorMessage?: string) {\r\n    return this.addRule(maxLengthRule, errorMessage, { maxLength: length });\r\n  }\r\n\r\n  /** Array length must be of the given length */\r\n  public length(length: number, errorMessage?: string) {\r\n    return this.addRule(lengthRule, errorMessage, { length });\r\n  }\r\n\r\n  /**\r\n   * Array length must be between min and max (inclusive)\r\n   *\r\n   * @param min - Minimum length (inclusive)\r\n   * @param max - Maximum length (inclusive)\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * v.array(v.string()).between(1, 10)  // Array must have 1 to 10 items\r\n   * v.array(v.number()).lengthBetween(5, 20)  // Same using alias\r\n   * ```\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public between(min: number, max: number, errorMessage?: string) {\r\n    return this.addRule(betweenLengthRule, errorMessage, {\r\n      minLength: min,\r\n      maxLength: max,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Alias for between() - array length between min and max\r\n   */\r\n  public lengthBetween(min: number, max: number, errorMessage?: string) {\r\n    return this.between(min, max, errorMessage);\r\n  }\r\n\r\n  /** Array must have unique values */\r\n  public unique(errorMessage?: string) {\r\n    return this.addRule(uniqueArrayRule, errorMessage);\r\n  }\r\n\r\n  /** Array must be sorted */\r\n  public sorted(direction: \"asc\" | \"desc\" = \"asc\", errorMessage?: string) {\r\n    return this.addRule(sortedArrayRule, errorMessage, { direction });\r\n  }\r\n\r\n  /** Mutate the data */\r\n  public mutate(data: any, context: SchemaContext) {\r\n    if (!Array.isArray(data)) return data;\r\n    return super.mutate([...data], context);\r\n  }\r\n\r\n  /** Validate array\r\n   *\r\n   * Absent input (and absent without `.default()`) propagates as `data: undefined`\r\n   * so the parent ObjectValidator can omit the key. Without this, optional array\r\n   * fields would silently materialise as `[]` in the validated output.\r\n   */\r\n  public async validate(data: any, context: SchemaContext): Promise<ValidationResult> {\r\n    // Apply default when absent, then mutate. Mirrors BaseValidator's\r\n    // `valueForRules = data ?? this.getDefaultValue()` so `.default([...])`\r\n    // works on arrays too.\r\n    const valueForRules = data ?? this.getDefaultValue();\r\n    const mutatedData = await this.mutate(valueForRules, context);\r\n\r\n    const result = await super.validate(data, context);\r\n\r\n    if (result.isValid === false) return result;\r\n\r\n    // Nothing to iterate for absent (no default) or null (nullable) inputs —\r\n    // propagate so the parent ObjectValidator can omit the key.\r\n    if (mutatedData === undefined || mutatedData === null) return result;\r\n\r\n    // Defensive: type rule (arrayRule) should have failed for non-arrays.\r\n    if (!Array.isArray(mutatedData)) return result;\r\n\r\n    const errors: ValidationResult[\"errors\"] = [];\r\n\r\n    // Validate all items in parallel (consistent with ObjectValidator)\r\n    const validationPromises = mutatedData.map(async (value: any, index: number) => {\r\n      const childContext: SchemaContext = {\r\n        ...context,\r\n        parent: mutatedData,\r\n        value,\r\n        key: index.toString(),\r\n        path: setKeyPath(context.path, index.toString()),\r\n      };\r\n\r\n      const childResult = await this.validator.validate(value, childContext);\r\n\r\n      // Update mutated data with validated result\r\n      mutatedData[index] = childResult.data;\r\n\r\n      // Collect errors from this element\r\n      if (childResult.isValid === false) {\r\n        errors.push(...childResult.errors);\r\n      }\r\n    });\r\n\r\n    await Promise.all(validationPromises);\r\n\r\n    return {\r\n      isValid: errors.length === 0,\r\n      errors,\r\n      data: await this.startTransformationPipeline(mutatedData, context),\r\n    };\r\n  }\r\n\r\n  /**\r\n   * @inheritdoc\r\n   *\r\n   * Recursively generates JSON Schema for the array items.\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * v.array(v.string().min(1)).minLength(1).toJsonSchema(\"draft-2020-12\")\r\n   * // → { type: \"array\", items: { type: \"string\", minLength: 1 }, minItems: 1 }\r\n   * ```\r\n   */\r\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\r\n    const schema: JsonSchemaResult = {\r\n      type: \"array\",\r\n      items: this.validator.toJsonSchema(target),\r\n    };\r\n\r\n    const minOpts = getRuleOptions(this.rules, \"minLength\");\r\n    if (minOpts?.minLength !== undefined) schema.minItems = minOpts.minLength;\r\n\r\n    const maxOpts = getRuleOptions(this.rules, \"maxLength\");\r\n    if (maxOpts?.maxLength !== undefined) schema.maxItems = maxOpts.maxLength;\r\n\r\n    const betweenOpts = getRuleOptions(this.rules, \"betweenLength\");\r\n    if (betweenOpts) {\r\n      if (betweenOpts.minLength !== undefined) schema.minItems = betweenOpts.minLength;\r\n      if (betweenOpts.maxLength !== undefined) schema.maxItems = betweenOpts.maxLength;\r\n    }\r\n\r\n    const lengthOpts = getRuleOptions(this.rules, \"length\");\r\n    if (lengthOpts?.length !== undefined) {\r\n      schema.minItems = lengthOpts.length;\r\n      schema.maxItems = lengthOpts.length;\r\n    }\r\n\r\n    if (this.isNullable) applyNullable(schema, target);\r\n\r\n    return schema;\r\n  }\r\n}\r\n"],"mappings":"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"}

package/esm/seal/src/validators/base-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"base-validator.mjs","names":["defaultRequiredRule"],"sources":["../../../../../../../../../seal/src/validators/base-validator.ts"],"sourcesContent":["import { clone } from \"@mongez/reinforcements\";\nimport { validate } from \"../factory/validate\";\nimport { VALID_RULE, invalidRule } from \"../helpers\";\nimport { isEmptyValue } from \"../helpers/is-empty-value\";\nimport { requiredRule as defaultRequiredRule } from \"../rules/core/required\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport { mapToStandardResult } from \"../standard-schema/map-result\";\nimport type { StandardJSONSchemaV1, StandardSchemaV1 } from \"../standard-schema/types\";\nimport type {\n  ContextualSchemaRule,\n  ContextualizedMutator,\n  ContextualizedTransformer,\n  Mutator,\n  SchemaContext,\n  SchemaRule,\n  SchemaRuleOptions,\n  SimpleTransformerCallback,\n  TransformerCallback,\n  ValidationAttributesList,\n  ValidationResult,\n} from \"../types\";\n\n/**\n * Base validator class - foundation for all validators\n */\nexport class BaseValidator<TInput = unknown, TOutput = TInput> {\n  public rules: ContextualSchemaRule[] = [];\n  public mutators: ContextualizedMutator[] = [];\n  protected defaultValue: any | (() => any);\n  protected description?: string;\n  protected shouldOmit = false;\n  protected isNullable = false;\n  protected isMutable = false;\n\n  /**\n   * Catch state — when `hasCatch` is true and validation fails, `catchValue`\n   * (or its callback result) substitutes for the failed value, and the public\n   * result reports `isValid: true` with no errors.\n   *\n   * See `.catch()` for semantics and the v1 scope (leaf-only).\n   */\n  protected catchValue:\n    | any\n    | ((errors: ValidationResult[\"errors\"], originalInput: any) => any | Promise<any>);\n  protected hasCatch = false;\n\n  /**\n   * Whether the field is optional.\n   * - false (default): field is required unless a requiredRule governs the condition.\n   * - true: field can be absent or empty — set by calling .optional().\n   *\n   * Also used as a TypeScript literal brand via the optional() return type.\n   */\n  public isOptional = false;\n\n  /**\n   * The single required-condition rule for this field.\n   * - null: field uses strict default (always required when not optional).\n   * - set: the rule governs when the field is required (e.g., requiredIf).\n   *\n   * Stored separately from rules[] and prepended at validate() time.\n   */\n  public requiredRule: ContextualSchemaRule | null = this.createRule(defaultRequiredRule);\n\n  /**\n   * Pipeline to transform the mutated/original data before returning it\n   */\n  protected dataTransformers: ContextualizedTransformer[] = [];\n\n  /**\n   * Attributes text to be replaced on translations\n   * If the value is an object, it will be used as the attributes list for the rule\n   * If the value is a string, it will be used as the attributes list for the rule\n   */\n  protected attributesText: ValidationAttributesList = {};\n\n  /**\n   * Attributed that will be always using the attribute translator\n   */\n  protected translatedAttributes: Record<string, string> = {};\n\n  /**\n   * Mark the validator as mutable\n   */\n  public get mutable() {\n    this.isMutable = true;\n    return this;\n  }\n\n  /**\n   * Mark the validator as immutable\n   */\n  public get immutable() {\n    this.isMutable = false;\n    return this;\n  }\n\n  /**\n   * Get the instance to apply changes to.\n   * By default (immutable), returns a clone so the original is unchanged.\n   * When `.mutable` is set, returns `this` to mutate in place.\n   */\n  protected get instance(): this {\n    return this.isMutable ? this : this.clone();\n  }\n\n  /**\n   * Get the default value\n   * Supports lazy evaluation via callbacks\n   */\n  public getDefaultValue(): any {\n    return typeof this.defaultValue === \"function\" ? this.defaultValue() : this.defaultValue;\n  }\n\n  /**\n   * Allow null as a valid value.\n   *\n   * Brands the return type with `{ isNullable: true }` so `Infer<>` widens\n   * the inferred output to include `| null`.\n   */\n  public nullable(): this & { isNullable: true } {\n    const instance = this.instance;\n    instance.isNullable = true;\n    return instance as this & { isNullable: true };\n  }\n\n  /**\n   * Explicitly disallow null values after calling nullable.\n   *\n   * Brands the return type with `{ isNullable: false }` to cancel any prior\n   * `.nullable()` at the type level.\n   */\n  public notNullable(): this & { isNullable: false } {\n    const instance = this.instance;\n    instance.isNullable = false;\n    return instance as this & { isNullable: false };\n  }\n\n  /**\n   * Add transformer with optional options\n   *\n   * @param transform - The transformer callback function\n   * @param options - Optional options to pass to the transformer\n   *\n   * @example\n   * ```ts\n   * // Without options\n   * v.date().addTransformer(data => data.toISOString())\n   *\n   * // With options\n   * v.date().addTransformer(\n   *   (data, { options }) => dayjs(data).format(options.format),\n   *   { format: 'YYYY-MM-DD' }\n   * )\n   * ```\n   */\n  public addTransformer(transform: TransformerCallback, options: any = {}) {\n    const instance = this.instance;\n    instance.addMutableTransformer(transform, options);\n\n    return instance;\n  }\n\n  /**\n   * Add transformer with optional options\n   *\n   * @param transform - The transformer callback function\n   * @param options - Optional options to pass to the transformer\n   *\n   * @example\n   * ```ts\n   * // Without options\n   * v.date().addTransformer(data => data.toISOString())\n   *\n   * // With options\n   * v.date().addTransformer(\n   *   (data, { options }) => dayjs(data).format(options.format),\n   *   { format: 'YYYY-MM-DD' }\n   * )\n   * ```\n   */\n  public addMutableTransformer(transform: TransformerCallback, options: any = {}) {\n    this.dataTransformers.push({\n      transform,\n      options,\n    });\n  }\n\n  /**\n   * Transform the output value - simple one-time transformation\n   *\n   * @param callback - Simple callback receiving data and context\n   *\n   * @example\n   * ```ts\n   * // Simple transformation\n   * v.string().outputAs(data => data.toUpperCase())\n   *\n   * // With context\n   * v.string().outputAs((data, context) => {\n   *   console.log(`Transforming ${context.path}`);\n   *   return data.toLowerCase();\n   * })\n   * ```\n   */\n  public outputAs(callback: SimpleTransformerCallback) {\n    return this.addTransformer((data, { context }) => callback(data, context));\n  }\n\n  /**\n   * Transform output to JSON string\n   *\n   * Works with any validator type (string, number, date, object, array, etc.)\n   *\n   * @param indent - Optional indentation for pretty printing (default: 0 for compact)\n   *\n   * @example\n   * ```ts\n   * // Compact JSON\n   * v.object({ name: v.string() }).toJSON()\n   * // Output: '{\"name\":\"John\"}'\n   *\n   * // Pretty-printed JSON\n   * v.array(v.object({...})).toJSON(2)\n   * // Output:\n   * // [\n   * //   {\n   * //     \"name\": \"John\"\n   * //   }\n   * // ]\n   *\n   * // Works with any type\n   * v.string().toJSON()  // '\"hello\"'\n   * v.number().toJSON()  // '42'\n   * v.date().toJSON()    // '\"2024-10-26T00:00:00.000Z\"'\n   * ```\n   *\n   * @category Transformer\n   */\n  public toJSON(indent?: number) {\n    return this.addTransformer((data, { options }) => JSON.stringify(data, null, options.indent), {\n      indent: indent ?? 0,\n    });\n  }\n\n  /**\n   * Start data transformation pipeline\n   * Context is passed at runtime, not stored\n   */\n  public async startTransformationPipeline(data: any, context: SchemaContext) {\n    for (const transformer of this.dataTransformers) {\n      data = await transformer.transform(data, {\n        options: transformer.options,\n        context,\n      });\n    }\n\n    return data;\n  }\n\n  /**\n   * Set attributes text to be replaced on translations\n   * If the value is an object, it will be used as the attributes list for the rule\n   * If the value is a string, it will be used as the attributes list for the rule\n   *\n   * @example\n   * v.string().attributes({\n   *   name: \"Name\",\n   *   email: \"Email\",\n   * });\n   * // Example 2: Add custom attributes for matches\n   * v.string().matches(\"confirmPassword\").attributes({\n   *   matches: {\n   *     confirmPassword: \"Confirm Password\",\n   *   },\n   * });\n   */\n  public attributes(attributes: Record<string, string | Record<string, string>>) {\n    const instance = this.instance;\n    for (const key in attributes) {\n      instance.attributesText[key] = attributes[key];\n    }\n\n    return instance;\n  }\n\n  /**\n   * Define a lazy getter property for each attribute in the given object and use the config attribute translator\n   */\n  public transAttributes(attributes: Record<string, string>) {\n    const instance = this.instance;\n    for (const key in attributes) {\n      instance.translatedAttributes[key] = attributes[key];\n    }\n\n    return instance;\n  }\n\n  /**\n   * Add description to the validator\n   */\n  public describe(description: string) {\n    const instance = this.instance;\n    instance.description = description;\n    return instance;\n  }\n\n  /**\n   * Check if this validator can handle the given value's type\n   * Override this in specific validators to enable type-based routing in union validators\n   *\n   * Default: returns true (validator will attempt to validate any type)\n   *\n   * @param value - The value to check\n   * @returns True if this validator can handle this type\n   *\n   * @example\n   * ```ts\n   * // StringValidator\n   * public matchesType(value: any): boolean {\n   *   return typeof value === 'string';\n   * }\n   *\n   * // Custom FileValidator\n   * public matchesType(value: any): boolean {\n   *   return value instanceof UploadedFile;\n   * }\n   * ```\n   */\n  public matchesType(_value: any): boolean {\n    return true; // Default: permissive, attempt to validate any type\n  }\n\n  /**\n   * Create a copy of this validator with the same configuration\n   * Copies all rules, mutators, transformers, default values, and settings\n   *\n   * @returns A new validator instance with copied configuration\n   *\n   * @example\n   * ```ts\n   * // Create reusable validator templates\n   * const baseString = v.string().required().trim().min(3);\n   * const emailField = baseString.clone().email();\n   * const usernameField = baseString.clone().alphanumeric().max(20);\n   *\n   * // Works with all validators\n   * const positiveInt = v.int().positive().required();\n   * const ageField = positiveInt.clone().min(18).max(120);\n   * ```\n   */\n  public clone(): this {\n    // Create a new instance using Object.create to preserve the prototype chain\n    const Constructor = this.constructor as new (...args: any[]) => this;\n    const cloned = Object.create(Constructor.prototype);\n\n    // Copy all BaseValidator properties\n    cloned.rules = [...this.rules];\n    cloned.mutators = [...this.mutators];\n    cloned.dataTransformers = [...this.dataTransformers];\n    cloned.defaultValue = this.defaultValue;\n    cloned.shouldOmit = this.shouldOmit;\n    cloned.description = this.description;\n    cloned.attributesText = { ...this.attributesText };\n    cloned.isNullable = this.isNullable;\n    cloned.isOptional = this.isOptional;\n    cloned.requiredRule = this.requiredRule; // same reference is fine — rule is treated as immutable\n    cloned.catchValue = this.catchValue;\n    cloned.hasCatch = this.hasCatch;\n\n    return cloned;\n  }\n\n  /**\n   * @deprecated This method is no longer needed and does nothing.\n   * Empty values are now automatically skipped for validation rules by default.\n   * Only presence validators (required, present, etc.) will check empty values.\n   * You can safely remove this call from your code.\n   */\n  public ignoreEmptyValue(_ignoreEmptyValue = true) {\n    // No-op for backward compatibility\n    return this;\n  }\n\n  /**\n   * Omit this field from the validated data output\n   *\n   * Field will still be validated but not included in the final result.\n   * Useful for confirmation fields, captcha, terms acceptance, etc.\n   *\n   * @example\n   * ```ts\n   * v.object({\n   *   password: v.string().required(),\n   *   confirmPassword: v.string().required().sameAs(\"password\").omit(),\n   *   acceptTerms: v.boolean().required().omit(),\n   * });\n   * // Output: { password: \"...\" }\n   * // confirmPassword and acceptTerms validated but omitted\n   * ```\n   */\n  public omit() {\n    const instance = this.instance;\n    instance.shouldOmit = true;\n    return instance;\n  }\n\n  /**\n   * @alias omit\n   */\n  public exclude() {\n    return this.omit();\n  }\n\n  /**\n   * Check if this field should be omitted from the output\n   */\n  public isOmitted(): boolean {\n    return this.shouldOmit;\n  }\n\n  /**\n   * Add rule to the validator\n   */\n  public addRule<T extends SchemaRuleOptions = SchemaRuleOptions>(\n    rule: SchemaRule<T>,\n    errorMessage?: string,\n    options: T = {} as T,\n  ): this {\n    const instance = this.instance;\n    instance.addMutableRule(rule, errorMessage, options);\n    return instance;\n  }\n\n  /**\n   * Set the required-condition rule for this field.\n   *\n   * Unlike addRule(), this does NOT push to rules[]. The rule is stored in the\n   * dedicated `requiredRule` slot and is prepended to the validation pipeline\n   * at runtime. Only one required rule can be active per field — this replaces\n   * any previously set required rule.\n   *\n   * Also marks the field as not optional (isOptional = false).\n   *\n   * @example\n   * ```ts\n   * // Used internally by required(), requiredIf(), requiredWith(), etc.\n   * BaseValidator.prototype.required = function(msg) {\n   *   return this.setRequiredRule(requiredRule, msg);\n   * };\n   * ```\n   */\n  public setRequiredRule<T extends SchemaRuleOptions = SchemaRuleOptions>(\n    rule: SchemaRule<T>,\n    errorMessage?: string,\n    options: T = {} as T,\n  ): this {\n    const instance = this.instance;\n    instance.isOptional = false;\n    instance.requiredRule = instance.createRule(rule, errorMessage, options);\n    return instance;\n  }\n\n  /**\n   * Add mutable rule\n   */\n  public addMutableRule<T extends SchemaRuleOptions = SchemaRuleOptions>(\n    rule: SchemaRule<T>,\n    errorMessage?: string,\n    options: T = {} as T,\n  ): ContextualSchemaRule<T> {\n    const newRule: ContextualSchemaRule<T> = this.createRule(rule, errorMessage, options);\n\n    this.rules.push(newRule);\n\n    return newRule;\n  }\n\n  /**\n   * Create new rule\n   */\n  protected createRule<T extends SchemaRuleOptions = SchemaRuleOptions>(\n    rule: SchemaRule<T>,\n    errorMessage?: string,\n    options: T = {} as T,\n  ): ContextualSchemaRule<T> {\n    const newRule: ContextualSchemaRule<T> = {\n      ...(clone(rule) as ContextualSchemaRule<T>),\n      context: {\n        errorMessage,\n        options,\n        attributesList: this.attributesText,\n        translatedAttributes: this.translatedAttributes,\n        translationParams: {},\n        translatableParams: {},\n      },\n    };\n\n    if (errorMessage) {\n      newRule.errorMessage = errorMessage;\n    }\n\n    if (rule.sortOrder === undefined) {\n      newRule.sortOrder = this.rules.length + 1;\n    }\n\n    return newRule;\n  }\n\n  /**\n   * Use a custom or pre-built validation rule\n   *\n   * @param rule - The validation rule to apply\n   * @param options - Rule options including errorMessage and any rule-specific options\n   *\n   * @example\n   * ```ts\n   * import { hexColorRule } from \"@warlock.js/seal\";\n   *\n   * v.string().useRule(hexColorRule, { errorMessage: \"Invalid color\" });\n   * ```\n   *\n   * @example\n   * ```ts\n   * // With rule options\n   * v.string().useRule(myCustomRule, {\n   *   customOption: true,\n   *   errorMessage: \"Custom validation failed\"\n   * });\n   * ```\n   */\n  public useRule<T extends SchemaRuleOptions = SchemaRuleOptions>(\n    rule: SchemaRule<T>,\n    options?: T & { errorMessage?: string },\n  ) {\n    const { errorMessage, ...ruleOptions } = options || ({} as any);\n    return this.addRule(rule, errorMessage, ruleOptions);\n  }\n\n  /**\n   * Define custom rule\n   */\n  public refine(\n    callback: (\n      value: any,\n      context: SchemaContext,\n    ) => Promise<string | undefined> | string | undefined,\n  ) {\n    return this.addRule({\n      name: \"custom\",\n      async validate(value, context) {\n        const result = await callback(value, context);\n        if (result) {\n          this.context.errorMessage = result;\n          return invalidRule(this, context);\n        }\n        return VALID_RULE;\n      },\n    });\n  }\n\n  /**\n   * Add mutator to the validator\n   */\n  public addMutator(mutator: Mutator, options: any = {}) {\n    const instance = this.instance;\n    instance.addMutableMutator(mutator, options);\n    return instance;\n  }\n\n  /**\n   * Add mutable mutator\n   */\n  public addMutableMutator(mutator: Mutator, options: any = {}) {\n    this.mutators.push({\n      mutate: mutator,\n      context: {\n        options,\n        ctx: {} as any,\n      },\n    });\n  }\n\n  /**\n   * Set default value for the field. The default is used when the input is\n   * absent (`undefined`); it then flows through the rule pipeline.\n   *\n   * Brands the return type with `{ hasDefault: true }` so `Infer<>` treats\n   * the field as guaranteed-present even when chained with `.optional()`.\n   */\n  public default(value: any): this & { hasDefault: true } {\n    const instance = this.instance;\n    instance.defaultValue = value;\n    return instance as this & { hasDefault: true };\n  }\n\n  /**\n   * Fallback to a value when validation fails.\n   *\n   * Complementary to `.default()`: `.default(x)` fires when input is **absent**,\n   * `.catch(y)` fires when input is **present but invalid**. Combine them when\n   * you want both behaviours: `.optional().default(x).catch(y)`.\n   *\n   * The fallback can be a value or a callback `(errors, originalInput) => fallback`.\n   * The callback variant is the only side-channel for the swallowed errors —\n   * use it to log/alert before the fallback substitutes.\n   *\n   * Brands the return type with `{ hasCatch: true }` so `Infer<>` treats the\n   * field as guaranteed-present (the catch ensures a value will always exist).\n   *\n   * **Scope (v1).** Catch is honoured for **leaf validators** (string, number,\n   * boolean, date, …) and for fields inside containers. It is a **no-op on\n   * container validators themselves** (`v.object`, `v.array`, `v.record`,\n   * `v.tuple`, `v.discriminatedUnion`) — those use their own iteration logic\n   * that bypasses the catch hook in `BaseValidator.validate()`.\n   *\n   * @example\n   * ```ts\n   * v.int().min(0).catch(3)                   // bad number → 3\n   * v.string().in([\"us\", \"eu\"]).catch(\"us\")   // unknown enum → \"us\"\n   * v.string().catch((errors, input) => {\n   *   console.warn(`bad user value: ${JSON.stringify(input)}`, errors);\n   *   return \"anonymous\";\n   * })\n   * ```\n   */\n  public catch(\n    fallback:\n      | any\n      | ((errors: ValidationResult[\"errors\"], originalInput: any) => any | Promise<any>),\n  ): this & { hasCatch: true } {\n    const instance = this.instance;\n\n    instance.catchValue = fallback;\n    instance.hasCatch = true;\n\n    return instance as this & { hasCatch: true };\n  }\n\n  /**\n   * Mutate the data\n   */\n  public async mutate(data: any, context: SchemaContext) {\n    let mutatedData = data;\n\n    for (const mutator of this.mutators) {\n      mutator.context.ctx = context;\n      mutatedData = await mutator.mutate(mutatedData, mutator.context);\n    }\n\n    return mutatedData;\n  }\n\n  /**\n   * Set the label for the validator that will be matching the :input attribute\n   */\n  public label(label: string) {\n    const instance = this.instance;\n    instance.attributesText.input = label;\n    return instance;\n  }\n\n  /**\n   * Validate the data\n   */\n  public async validate(data: any, context: SchemaContext): Promise<ValidationResult> {\n    if (data === null && this.isNullable) {\n      return { isValid: true, errors: [], data: null };\n    }\n\n    const valueForRules = data ?? this.getDefaultValue();\n    const mutatedData = await this.mutate(valueForRules, context);\n\n    const errors: ValidationResult[\"errors\"] = [];\n    let isValid = true;\n    const isFirstErrorOnly = context.configurations?.firstErrorOnly ?? true;\n\n    const isEmpty = isEmptyValue(valueForRules);\n\n    // D8 fix (design/core-defects-found.md): for an optional field, only a\n    // truly ABSENT value (`valueForRules === undefined` — the key was\n    // missing, or was `null`/`undefined` and got coalesced above) may skip\n    // the value rules. A PRESENT-but-empty value (e.g. `\"\"` from `?page=`)\n    // must still run them, so `v.int().optional()` given `\"\"` fails instead\n    // of silently handing back a string that `Infer.Output`'s\n    // `number | undefined` forbids. Non-optional fields are unaffected —\n    // their `requiredRule` (not nulled out by `.optional()`) already rejects\n    // `\"\"` before these rules matter.\n    const skipEmptyRules = this.isOptional ? valueForRules === undefined : isEmpty;\n\n    // Prepend the required-condition rule if set, so it always runs first.\n    // requiredRule has requiresValue = false so it runs even on empty values.\n    const rulesToRun = this.requiredRule ? [this.requiredRule, ...this.rules] : this.rules;\n\n    for (const rule of rulesToRun) {\n      if ((rule.requiresValue ?? true) && skipEmptyRules) continue;\n\n      this.setRuleAttributesList(rule);\n\n      const result = await rule.validate(mutatedData, context);\n\n      if (result.isValid === false) {\n        isValid = false;\n        errors.push({\n          type: rule.name,\n          error: result.error,\n          input: result.path ?? context.path,\n        });\n\n        if (isFirstErrorOnly) {\n          break;\n        }\n      }\n    }\n\n    const result: ValidationResult = {\n      isValid,\n      errors,\n      data:\n        mutatedData !== undefined\n          ? await this.startTransformationPipeline(mutatedData, context)\n          : undefined,\n    };\n\n    // Catch fallback — only on the leaf path. Container validators override\n    // validate() and don't run this hook on their own outcome, so catching\n    // a whole object/array/record is a no-op in v1.\n    if (result.isValid === false && this.hasCatch) {\n      const fallback =\n        typeof this.catchValue === \"function\"\n          ? await this.catchValue(result.errors, data)\n          : this.catchValue;\n\n      return { isValid: true, errors: [], data: fallback };\n    }\n\n    return result;\n  }\n\n  /**\n   * Set rule attributes list\n   */\n  protected setRuleAttributesList(rule: ContextualSchemaRule) {\n    rule.context.attributesList =\n      typeof this.attributesText[rule.name] === \"object\"\n        ? (this.attributesText[rule.name] as ValidationAttributesList)\n        : this.attributesText;\n  }\n\n  /**\n   * Standard Schema V1 compliance.\n   *\n   * Allows this validator to be used with any Standard Schema-aware library\n   * (OpenAI structured outputs, LangGraph, TanStack Form, Conform, Valibot adapters, etc.)\n   * without extra adapters.\n   *\n   * Delegates to the `validate()` factory so all `configureSeal()` options\n   * (translations, firstErrorOnly) are picked up automatically at call time.\n   *\n   * Includes Standard JSON Schema support via `jsonSchema.input()` / `jsonSchema.output()`.\n   *\n   * ## How Standard Schema libraries consume this\n   *\n   * You pass the **schema object itself** to the library — they internally read\n   * `schema[\"~standard\"]`. Do NOT pass `schema[\"~standard\"]` directly.\n   *\n   * @example\n   * ```ts\n   * const schema = v.object({ name: v.string().required() });\n   *\n   * // TanStack Form — pass schema, library reads [\"~standard\"] internally\n   * const form = useForm({ validators: { onChange: schema } });\n   *\n   * // Conform (Remix) — same pattern\n   * const [form] = useForm({ onValidate({ formData }) {\n   *   return parseWithStandardSchema(formData, { schema });\n   * }});\n   *\n   * // Direct validation (lower level — most apps don't need this)\n   * const result = await schema[\"~standard\"].validate({ name: \"Hasan\" });\n   * // → { value: { name: \"Hasan\" } }  on success\n   * // → { issues: [{ message: \"...\", path: [{ key: \"name\" }] }] }  on failure\n   *\n   * // JSON Schema for OpenAI / LangChain tool calling\n   * const parameters = schema[\"~standard\"].jsonSchema.input({ target: \"openai-strict\" });\n   * // → { type: \"object\", properties: {...}, required: [...], additionalProperties: false }\n   * ```\n   *\n   * @note Cross-field rules (sameAs, requiredIf, requiredWith) rely on sibling values\n   * available in the full validation context. When called on a standalone scalar validator,\n   * sibling data is absent and those rules will not evaluate correctly.\n   * Always call on the parent ObjectValidator for full-payload validation.\n   */\n  get [\"~standard\"](): StandardJSONSchemaV1.Props<TInput, TOutput> {\n    return {\n      version: 1,\n      vendor: \"seal\",\n      types: undefined as unknown as StandardSchemaV1.Types<TInput, TOutput>,\n      validate: async (value: unknown) => {\n        const result = await validate(this, value);\n        return mapToStandardResult(result) as StandardSchemaV1.Result<TOutput>;\n      },\n      jsonSchema: {\n        input: (options) => this.toJsonSchema(options.target),\n        output: (options) => this.toJsonSchema(options.target),\n      },\n    };\n  }\n\n  /**\n   * Generate a JSON Schema representation of this validator.\n   *\n   * Supports targets: `\"draft-2020-12\"` (default), `\"draft-07\"`, `\"openapi-3.0\"`.\n   *\n   * Subclasses override this to describe their specific constraints.\n   * The base implementation returns `{}` (permissive — accepts anything),\n   * which is correct for validators with no representable JSON Schema constraints.\n   *\n   * @note Rules that cannot be expressed in JSON Schema are silently omitted:\n   * - Cross-field rules: sameAs, requiredIf, requiredWith, requiredWithout\n   * - Custom callbacks: refine()\n   * - Framework-specific runtime rules (core/cascade plugins)\n   * These rules still run normally at validation time — only absent from JSON Schema.\n   *\n   * @example\n   * ```ts\n   * v.string().min(3).max(50).toJsonSchema(\"draft-2020-12\")\n   * // → { type: \"string\", minLength: 3, maxLength: 50 }\n   *\n   * v.object({ name: v.string().required(), age: v.int().optional() })\n   *   .toJsonSchema(\"draft-07\")\n   * // → { type: \"object\", properties: { name: { type: \"string\" }, age: { type: \"integer\" } }, required: [\"name\"] }\n   * ```\n   */\n  public toJsonSchema(_target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    return {};\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAyBA,IAAa,gBAAb,MAA+D;CAC7D,AAAO,QAAgC,CAAC;CACxC,AAAO,WAAoC,CAAC;CAC5C,AAAU;CACV,AAAU;CACV,AAAU,aAAa;CACvB,AAAU,aAAa;CACvB,AAAU,YAAY;;;;;;;;CAStB,AAAU;CAGV,AAAU,WAAW;;;;;;;;CASrB,AAAO,aAAa;;;;;;;;CASpB,AAAO,eAA4C,KAAK,WAAWA,YAAmB;;;;CAKtF,AAAU,mBAAgD,CAAC;;;;;;CAO3D,AAAU,iBAA2C,CAAC;;;;CAKtD,AAAU,uBAA+C,CAAC;;;;CAK1D,IAAW,UAAU;EACnB,KAAK,YAAY;EACjB,OAAO;CACT;;;;CAKA,IAAW,YAAY;EACrB,KAAK,YAAY;EACjB,OAAO;CACT;;;;;;CAOA,IAAc,WAAiB;EAC7B,OAAO,KAAK,YAAY,OAAO,KAAK,MAAM;CAC5C;;;;;CAMA,AAAO,kBAAuB;EAC5B,OAAO,OAAO,KAAK,iBAAiB,aAAa,KAAK,aAAa,IAAI,KAAK;CAC9E;;;;;;;CAQA,AAAO,WAAwC;EAC7C,MAAM,WAAW,KAAK;EACtB,SAAS,aAAa;EACtB,OAAO;CACT;;;;;;;CAQA,AAAO,cAA4C;EACjD,MAAM,WAAW,KAAK;EACtB,SAAS,aAAa;EACtB,OAAO;CACT;;;;;;;;;;;;;;;;;;;CAoBA,AAAO,eAAe,WAAgC,UAAe,CAAC,GAAG;EACvE,MAAM,WAAW,KAAK;EACtB,SAAS,sBAAsB,WAAW,OAAO;EAEjD,OAAO;CACT;;;;;;;;;;;;;;;;;;;CAoBA,AAAO,sBAAsB,WAAgC,UAAe,CAAC,GAAG;EAC9E,KAAK,iBAAiB,KAAK;GACzB;GACA;EACF,CAAC;CACH;;;;;;;;;;;;;;;;;;CAmBA,AAAO,SAAS,UAAqC;EACnD,OAAO,KAAK,gBAAgB,MAAM,EAAE,cAAc,SAAS,MAAM,OAAO,CAAC;CAC3E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCA,AAAO,OAAO,QAAiB;EAC7B,OAAO,KAAK,gBAAgB,MAAM,EAAE,cAAc,KAAK,UAAU,MAAM,MAAM,QAAQ,MAAM,GAAG,EAC5F,QAAQ,UAAU,EACpB,CAAC;CACH;;;;;CAMA,MAAa,4BAA4B,MAAW,SAAwB;EAC1E,KAAK,MAAM,eAAe,KAAK,kBAC7B,OAAO,MAAM,YAAY,UAAU,MAAM;GACvC,SAAS,YAAY;GACrB;EACF,CAAC;EAGH,OAAO;CACT;;;;;;;;;;;;;;;;;;CAmBA,AAAO,WAAW,YAA6D;EAC7E,MAAM,WAAW,KAAK;EACtB,KAAK,MAAM,OAAO,YAChB,SAAS,eAAe,OAAO,WAAW;EAG5C,OAAO;CACT;;;;CAKA,AAAO,gBAAgB,YAAoC;EACzD,MAAM,WAAW,KAAK;EACtB,KAAK,MAAM,OAAO,YAChB,SAAS,qBAAqB,OAAO,WAAW;EAGlD,OAAO;CACT;;;;CAKA,AAAO,SAAS,aAAqB;EACnC,MAAM,WAAW,KAAK;EACtB,SAAS,cAAc;EACvB,OAAO;CACT;;;;;;;;;;;;;;;;;;;;;;;CAwBA,AAAO,YAAY,QAAsB;EACvC,OAAO;CACT;;;;;;;;;;;;;;;;;;;CAoBA,AAAO,QAAc;EAEnB,MAAM,cAAc,KAAK;EACzB,MAAM,SAAS,OAAO,OAAO,YAAY,SAAS;EAGlD,OAAO,QAAQ,CAAC,GAAG,KAAK,KAAK;EAC7B,OAAO,WAAW,CAAC,GAAG,KAAK,QAAQ;EACnC,OAAO,mBAAmB,CAAC,GAAG,KAAK,gBAAgB;EACnD,OAAO,eAAe,KAAK;EAC3B,OAAO,aAAa,KAAK;EACzB,OAAO,cAAc,KAAK;EAC1B,OAAO,iBAAiB,EAAE,GAAG,KAAK,eAAe;EACjD,OAAO,aAAa,KAAK;EACzB,OAAO,aAAa,KAAK;EACzB,OAAO,eAAe,KAAK;EAC3B,OAAO,aAAa,KAAK;EACzB,OAAO,WAAW,KAAK;EAEvB,OAAO;CACT;;;;;;;CAQA,AAAO,iBAAiB,oBAAoB,MAAM;EAEhD,OAAO;CACT;;;;;;;;;;;;;;;;;;CAmBA,AAAO,OAAO;EACZ,MAAM,WAAW,KAAK;EACtB,SAAS,aAAa;EACtB,OAAO;CACT;;;;CAKA,AAAO,UAAU;EACf,OAAO,KAAK,KAAK;CACnB;;;;CAKA,AAAO,YAAqB;EAC1B,OAAO,KAAK;CACd;;;;CAKA,AAAO,QACL,MACA,cACA,UAAa,CAAC,GACR;EACN,MAAM,WAAW,KAAK;EACtB,SAAS,eAAe,MAAM,cAAc,OAAO;EACnD,OAAO;CACT;;;;;;;;;;;;;;;;;;;CAoBA,AAAO,gBACL,MACA,cACA,UAAa,CAAC,GACR;EACN,MAAM,WAAW,KAAK;EACtB,SAAS,aAAa;EACtB,SAAS,eAAe,SAAS,WAAW,MAAM,cAAc,OAAO;EACvE,OAAO;CACT;;;;CAKA,AAAO,eACL,MACA,cACA,UAAa,CAAC,GACW;EACzB,MAAM,UAAmC,KAAK,WAAW,MAAM,cAAc,OAAO;EAEpF,KAAK,MAAM,KAAK,OAAO;EAEvB,OAAO;CACT;;;;CAKA,AAAU,WACR,MACA,cACA,UAAa,CAAC,GACW;EACzB,MAAM,UAAmC;GACvC,GAAI,MAAM,IAAI;GACd,SAAS;IACP;IACA;IACA,gBAAgB,KAAK;IACrB,sBAAsB,KAAK;IAC3B,mBAAmB,CAAC;IACpB,oBAAoB,CAAC;GACvB;EACF;EAEA,IAAI,cACF,QAAQ,eAAe;EAGzB,IAAI,KAAK,cAAc,QACrB,QAAQ,YAAY,KAAK,MAAM,SAAS;EAG1C,OAAO;CACT;;;;;;;;;;;;;;;;;;;;;;;CAwBA,AAAO,QACL,MACA,SACA;EACA,MAAM,EAAE,cAAc,GAAG,gBAAgB,WAAY,CAAC;EACtD,OAAO,KAAK,QAAQ,MAAM,cAAc,WAAW;CACrD;;;;CAKA,AAAO,OACL,UAIA;EACA,OAAO,KAAK,QAAQ;GAClB,MAAM;GACN,MAAM,SAAS,OAAO,SAAS;IAC7B,MAAM,SAAS,MAAM,SAAS,OAAO,OAAO;IAC5C,IAAI,QAAQ;KACV,KAAK,QAAQ,eAAe;KAC5B,OAAO,YAAY,MAAM,OAAO;IAClC;IACA,OAAO;GACT;EACF,CAAC;CACH;;;;CAKA,AAAO,WAAW,SAAkB,UAAe,CAAC,GAAG;EACrD,MAAM,WAAW,KAAK;EACtB,SAAS,kBAAkB,SAAS,OAAO;EAC3C,OAAO;CACT;;;;CAKA,AAAO,kBAAkB,SAAkB,UAAe,CAAC,GAAG;EAC5D,KAAK,SAAS,KAAK;GACjB,QAAQ;GACR,SAAS;IACP;IACA,KAAK,CAAC;GACR;EACF,CAAC;CACH;;;;;;;;CASA,AAAO,QAAQ,OAAyC;EACtD,MAAM,WAAW,KAAK;EACtB,SAAS,eAAe;EACxB,OAAO;CACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCA,AAAO,MACL,UAG2B;EAC3B,MAAM,WAAW,KAAK;EAEtB,SAAS,aAAa;EACtB,SAAS,WAAW;EAEpB,OAAO;CACT;;;;CAKA,MAAa,OAAO,MAAW,SAAwB;EACrD,IAAI,cAAc;EAElB,KAAK,MAAM,WAAW,KAAK,UAAU;GACnC,QAAQ,QAAQ,MAAM;GACtB,cAAc,MAAM,QAAQ,OAAO,aAAa,QAAQ,OAAO;EACjE;EAEA,OAAO;CACT;;;;CAKA,AAAO,MAAM,OAAe;EAC1B,MAAM,WAAW,KAAK;EACtB,SAAS,eAAe,QAAQ;EAChC,OAAO;CACT;;;;CAKA,MAAa,SAAS,MAAW,SAAmD;EAClF,IAAI,SAAS,QAAQ,KAAK,YACxB,OAAO;GAAE,SAAS;GAAM,QAAQ,CAAC;GAAG,MAAM;EAAK;EAGjD,MAAM,gBAAgB,QAAQ,KAAK,gBAAgB;EACnD,MAAM,cAAc,MAAM,KAAK,OAAO,eAAe,OAAO;EAE5D,MAAM,SAAqC,CAAC;EAC5C,IAAI,UAAU;EACd,MAAM,mBAAmB,QAAQ,gBAAgB,kBAAkB;EAEnE,MAAM,UAAU,aAAa,aAAa;EAW1C,MAAM,iBAAiB,KAAK,aAAa,kBAAkB,SAAY;EAIvE,MAAM,aAAa,KAAK,eAAe,CAAC,KAAK,cAAc,GAAG,KAAK,KAAK,IAAI,KAAK;EAEjF,KAAK,MAAM,QAAQ,YAAY;GAC7B,KAAK,KAAK,iBAAiB,SAAS,gBAAgB;GAEpD,KAAK,sBAAsB,IAAI;GAE/B,MAAM,SAAS,MAAM,KAAK,SAAS,aAAa,OAAO;GAEvD,IAAI,OAAO,YAAY,OAAO;IAC5B,UAAU;IACV,OAAO,KAAK;KACV,MAAM,KAAK;KACX,OAAO,OAAO;KACd,OAAO,OAAO,QAAQ,QAAQ;IAChC,CAAC;IAED,IAAI,kBACF;GAEJ;EACF;EAEA,MAAM,SAA2B;GAC/B;GACA;GACA,MACE,gBAAgB,SACZ,MAAM,KAAK,4BAA4B,aAAa,OAAO,IAC3D;EACR;EAKA,IAAI,OAAO,YAAY,SAAS,KAAK,UAMnC,OAAO;GAAE,SAAS;GAAM,QAAQ,CAAC;GAAG,MAJlC,OAAO,KAAK,eAAe,aACvB,MAAM,KAAK,WAAW,OAAO,QAAQ,IAAI,IACzC,KAAK;EAEwC;EAGrD,OAAO;CACT;;;;CAKA,AAAU,sBAAsB,MAA4B;EAC1D,KAAK,QAAQ,iBACX,OAAO,KAAK,eAAe,KAAK,UAAU,WACrC,KAAK,eAAe,KAAK,QAC1B,KAAK;CACb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8CA,KAAK,eAA4D;EAC/D,OAAO;GACL,SAAS;GACT,QAAQ;GACR,OAAO;GACP,UAAU,OAAO,UAAmB;IAElC,OAAO,oBAAoB,MADN,SAAS,MAAM,KAAK,CACR;GACnC;GACA,YAAY;IACV,QAAQ,YAAY,KAAK,aAAa,QAAQ,MAAM;IACpD,SAAS,YAAY,KAAK,aAAa,QAAQ,MAAM;GACvD;EACF;CACF;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BA,AAAO,aAAa,UAA4B,iBAAmC;EACjF,OAAO,CAAC;CACV;AACF"}

package/esm/seal/src/validators/boolean-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"boolean-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/boolean-validator.ts"],"sourcesContent":["import {\n  acceptedIfPresentRule,\n  acceptedIfRequiredRule,\n  acceptedIfRule,\n  acceptedRule,\n  acceptedUnlessRule,\n  acceptedWithoutRule,\n  declinedIfPresentRule,\n  declinedIfRequiredRule,\n  declinedIfRule,\n  declinedRule,\n  declinedUnlessRule,\n  declinedWithoutRule,\n} from \"../rules/scalar\";\nimport { booleanRule } from \"../rules\";\nimport { PrimitiveValidator } from \"./primitive-validator\";\nimport { applyNullable } from \"../standard-schema/json-schema\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\n\n/**\n * Boolean validator class\n *\n * Extends PrimitiveValidator — inherits enum/in/oneOf/allowsOnly/forbids/notIn.\n * Defines accepted/declined directly as real methods (not ScalarValidator field copies)\n * so they survive cloning correctly.\n */\nexport class BooleanValidator extends PrimitiveValidator {\n  public constructor(errorMessage?: string) {\n    super();\n    this.addMutableRule(booleanRule, errorMessage);\n  }\n\n  /**\n   * Check if value is a boolean type\n   */\n  public matchesType(value: any): boolean {\n    return typeof value === \"boolean\";\n  }\n\n  // ==================== Accepted ====================\n\n  /** Value must be accepted (true, \"yes\", 1, \"on\", etc.) */\n  public accepted(errorMessage?: string) {\n    return this.addRule(acceptedRule, errorMessage);\n  }\n\n  /** Value must be accepted if another field equals a value */\n  public acceptedIf(field: string, value: any, errorMessage?: string) {\n    return this.addRule(acceptedIfRule, errorMessage, { field, value });\n  }\n\n  /** Value must be accepted unless another field equals a value */\n  public acceptedUnless(field: string, value: any, errorMessage?: string) {\n    return this.addRule(acceptedUnlessRule, errorMessage, { field, value });\n  }\n\n  /** Value must be accepted if another field is required */\n  public acceptedIfRequired(field: string, errorMessage?: string) {\n    return this.addRule(acceptedIfRequiredRule, errorMessage, { field });\n  }\n\n  /** Value must be accepted if another field is present */\n  public acceptedIfPresent(field: string, errorMessage?: string) {\n    return this.addRule(acceptedIfPresentRule, errorMessage, { field });\n  }\n\n  /** Value must be accepted if another field is missing */\n  public acceptedWithout(field: string, errorMessage?: string) {\n    return this.addRule(acceptedWithoutRule, errorMessage, { field });\n  }\n\n  // ==================== Declined ====================\n\n  /** Value must be declined (false, \"no\", 0, \"off\", etc.) */\n  public declined(errorMessage?: string) {\n    return this.addRule(declinedRule, errorMessage);\n  }\n\n  /** Value must be declined if another field equals a value */\n  public declinedIf(field: string, value: any, errorMessage?: string) {\n    return this.addRule(declinedIfRule, errorMessage, { field, value });\n  }\n\n  /** Value must be declined unless another field equals a value */\n  public declinedUnless(field: string, value: any, errorMessage?: string) {\n    return this.addRule(declinedUnlessRule, errorMessage, { field, value });\n  }\n\n  /** Value must be declined if another field is required */\n  public declinedIfRequired(field: string, errorMessage?: string) {\n    return this.addRule(declinedIfRequiredRule, errorMessage, { field });\n  }\n\n  /** Value must be declined if another field is present */\n  public declinedIfPresent(field: string, errorMessage?: string) {\n    return this.addRule(declinedIfPresentRule, errorMessage, { field });\n  }\n\n  /** Value must be declined if another field is missing */\n  public declinedWithout(field: string, errorMessage?: string) {\n    return this.addRule(declinedWithoutRule, errorMessage, { field });\n  }\n\n  // ==================== Strict boolean checks ====================\n\n  /**\n   * Value must be strictly true (not \"yes\", \"on\", 1, etc.)\n   * @alias accepted - strict version\n   */\n  public mustBeTrue(errorMessage?: string) {\n    return this.equal(true, errorMessage);\n  }\n\n  /**\n   * Value must be strictly false (not \"no\", \"off\", 0, etc.)\n   * @alias declined - strict version\n   */\n  public mustBeFalse(errorMessage?: string) {\n    return this.equal(false, errorMessage);\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * @note accepted/declined rules and all cross-field boolean rules\n   * are not representable in JSON Schema and are silently omitted.\n   *\n   * @example\n   * ```ts\n   * v.boolean().toJsonSchema(\"draft-2020-12\")\n   * // → { type: \"boolean\" }\n   *\n   * v.boolean().nullable().toJsonSchema(\"openapi-3.0\")\n   * // → { type: \"boolean\", nullable: true }\n   * ```\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    const schema: JsonSchemaResult = { type: \"boolean\" };\n    if (this.isNullable) applyNullable(schema, target);\n    return schema;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA0BA,IAAa,mBAAb,cAAsC,mBAAmB;CACvD,AAAO,YAAY,cAAuB;EACxC,MAAM;EACN,KAAK,eAAe,aAAa,YAAY;CAC/C;;;;CAKA,AAAO,YAAY,OAAqB;EACtC,OAAO,OAAO,UAAU;CAC1B;;CAKA,AAAO,SAAS,cAAuB;EACrC,OAAO,KAAK,QAAQ,cAAc,YAAY;CAChD;;CAGA,AAAO,WAAW,OAAe,OAAY,cAAuB;EAClE,OAAO,KAAK,QAAQ,gBAAgB,cAAc;GAAE;GAAO;EAAM,CAAC;CACpE;;CAGA,AAAO,eAAe,OAAe,OAAY,cAAuB;EACtE,OAAO,KAAK,QAAQ,oBAAoB,cAAc;GAAE;GAAO;EAAM,CAAC;CACxE;;CAGA,AAAO,mBAAmB,OAAe,cAAuB;EAC9D,OAAO,KAAK,QAAQ,wBAAwB,cAAc,EAAE,MAAM,CAAC;CACrE;;CAGA,AAAO,kBAAkB,OAAe,cAAuB;EAC7D,OAAO,KAAK,QAAQ,uBAAuB,cAAc,EAAE,MAAM,CAAC;CACpE;;CAGA,AAAO,gBAAgB,OAAe,cAAuB;EAC3D,OAAO,KAAK,QAAQ,qBAAqB,cAAc,EAAE,MAAM,CAAC;CAClE;;CAKA,AAAO,SAAS,cAAuB;EACrC,OAAO,KAAK,QAAQ,cAAc,YAAY;CAChD;;CAGA,AAAO,WAAW,OAAe,OAAY,cAAuB;EAClE,OAAO,KAAK,QAAQ,gBAAgB,cAAc;GAAE;GAAO;EAAM,CAAC;CACpE;;CAGA,AAAO,eAAe,OAAe,OAAY,cAAuB;EACtE,OAAO,KAAK,QAAQ,oBAAoB,cAAc;GAAE;GAAO;EAAM,CAAC;CACxE;;CAGA,AAAO,mBAAmB,OAAe,cAAuB;EAC9D,OAAO,KAAK,QAAQ,wBAAwB,cAAc,EAAE,MAAM,CAAC;CACrE;;CAGA,AAAO,kBAAkB,OAAe,cAAuB;EAC7D,OAAO,KAAK,QAAQ,uBAAuB,cAAc,EAAE,MAAM,CAAC;CACpE;;CAGA,AAAO,gBAAgB,OAAe,cAAuB;EAC3D,OAAO,KAAK,QAAQ,qBAAqB,cAAc,EAAE,MAAM,CAAC;CAClE;;;;;CAQA,AAAO,WAAW,cAAuB;EACvC,OAAO,KAAK,MAAM,MAAM,YAAY;CACtC;;;;;CAMA,AAAO,YAAY,cAAuB;EACxC,OAAO,KAAK,MAAM,OAAO,YAAY;CACvC;;;;;;;;;;;;;;;;CAiBA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,MAAM,SAA2B,EAAE,MAAM,UAAU;EACnD,IAAI,KAAK,YAAY,cAAc,QAAQ,MAAM;EACjD,OAAO;CACT;AACF"}

package/esm/seal/src/validators/computed-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"computed-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/computed-validator.ts"],"sourcesContent":["import type { SchemaContext, ValidationResult } from \"../types\";\nimport { BaseValidator } from \"./base-validator\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\n\n/**\n * Callback function for computed fields\n * Receives validated & mutated data and full schema context\n */\nexport type ComputedCallback<TResult = any> = (\n  data: any,\n  context: SchemaContext,\n) => TResult | Promise<TResult>;\n\n/**\n * Computed field validator\n *\n * Computes a value based on other validated fields in the schema.\n * The computed value is persisted and can optionally be validated.\n *\n * @example\n * ```ts\n * // Basic computed field\n * const schema = v.object({\n *   title: v.string().required(),\n *   slug: v.computed(data => slugify(data.title)),\n * });\n *\n * // With result validation\n * const schema = v.object({\n *   title: v.string().required(),\n *   slug: v.computed(\n *     data => slugify(data.title),\n *     v.string().minLength(3)\n *   ),\n * });\n *\n * // Async computation\n * const schema = v.object({\n *   image: v.string().url(),\n *   thumbnail: v.computed(async data => {\n *     return await generateThumbnail(data.image);\n *   }),\n * });\n * ```\n */\nexport class ComputedValidator<TResult = any> extends BaseValidator {\n  /**\n   * Create a new computed field validator\n   *\n   * @param callback - Function to compute the value from validated data\n   * @param resultValidator - Optional validator to validate the computed result\n   */\n  public constructor(\n    protected callback: ComputedCallback<TResult>,\n    protected resultValidator?: BaseValidator,\n  ) {\n    super();\n  }\n\n  /**\n   * Execute the callback and optionally validate the result\n   */\n  public async validate(data: any, context: SchemaContext): Promise<ValidationResult> {\n    try {\n      // Execute the callback with validated data\n      const result = await this.callback(data, context);\n\n      // Optionally validate the computed result\n      if (this.resultValidator) {\n        const validation = await this.resultValidator.validate(result, context);\n\n        if (!validation.isValid) {\n          return {\n            isValid: false,\n            errors: validation.errors,\n            data: undefined,\n          };\n        }\n\n        return {\n          isValid: true,\n          errors: [],\n          data: validation.data,\n        };\n      }\n\n      // No validation - return computed result directly\n      return {\n        isValid: true,\n        errors: [],\n        data: result,\n      };\n    } catch (error) {\n      // Handle callback execution errors\n      return {\n        isValid: false,\n        errors: [\n          {\n            type: \"computed\",\n            error: error instanceof Error ? error.message : \"Computed field callback failed\",\n            input: context.path,\n          },\n        ],\n        data: undefined,\n      };\n    }\n  }\n\n  /**\n   * Clone this validator with all its configuration\n   * Critical for ObjectValidator.clone(), extend(), merge(), etc.\n   */\n  public override clone(): this {\n    const cloned = super.clone();\n\n    // Copy ComputedValidator-specific properties\n    cloned.callback = this.callback; // Functions are safe to copy by reference\n    cloned.resultValidator = this.resultValidator?.clone(); // Deep clone validator\n\n    return cloned;\n  }\n\n  /**\n   * Computed fields don't have a specific type to match\n   */\n  public matchesType(value: any): boolean {\n    return true; // Computed fields accept any input (they generate their own value)\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * Computed fields are server-side runtime values — they have no input schema\n   * and cannot be represented in JSON Schema. Calling this method is always a\n   * programming error.\n   *\n   * @throws Error Always throws — computed/managed fields have no JSON Schema representation.\n   */\n  public override toJsonSchema(_target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    throw new Error(\n      `[Seal] toJsonSchema() is not supported on ComputedValidator / ManagedValidator. ` +\n      `Computed fields are runtime-only and have no input JSON Schema representation. ` +\n      `ObjectValidator.toJsonSchema() automatically skips computed fields — ` +\n      `do not call toJsonSchema() on a computed validator directly.`,\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,IAAa,oBAAb,cAAsD,cAAc;CAQtD;CACA;;;;;;;CAFZ,AAAO,YACL,AAAU,UACV,AAAU,iBACV;EACA,MAAM;EAHI;EACA;CAGZ;;;;CAKA,MAAa,SAAS,MAAW,SAAmD;EAClF,IAAI;GAEF,MAAM,SAAS,MAAM,KAAK,SAAS,MAAM,OAAO;GAGhD,IAAI,KAAK,iBAAiB;IACxB,MAAM,aAAa,MAAM,KAAK,gBAAgB,SAAS,QAAQ,OAAO;IAEtE,IAAI,CAAC,WAAW,SACd,OAAO;KACL,SAAS;KACT,QAAQ,WAAW;KACnB,MAAM;IACR;IAGF,OAAO;KACL,SAAS;KACT,QAAQ,CAAC;KACT,MAAM,WAAW;IACnB;GACF;GAGA,OAAO;IACL,SAAS;IACT,QAAQ,CAAC;IACT,MAAM;GACR;EACF,SAAS,OAAO;GAEd,OAAO;IACL,SAAS;IACT,QAAQ,CACN;KACE,MAAM;KACN,OAAO,iBAAiB,QAAQ,MAAM,UAAU;KAChD,OAAO,QAAQ;IACjB,CACF;IACA,MAAM;GACR;EACF;CACF;;;;;CAMA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAG3B,OAAO,WAAW,KAAK;EACvB,OAAO,kBAAkB,KAAK,iBAAiB,MAAM;EAErD,OAAO;CACT;;;;CAKA,AAAO,YAAY,OAAqB;EACtC,OAAO;CACT;;;;;;;;;;CAWA,AAAgB,aAAa,UAA4B,iBAAmC;EAC1F,MAAM,IAAI,MACR,kSAIF;CACF;AACF"}

package/esm/seal/src/validators/date-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"date-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/date-validator.ts"],"sourcesContent":["import dayjs from \"dayjs\";\r\nimport {\r\n  addDaysMutator,\r\n  addHoursMutator,\r\n  addMonthsMutator,\r\n  addYearsMutator,\r\n  dateMutator,\r\n  toEndOfDayMutator,\r\n  toEndOfMonthMutator,\r\n  toEndOfYearMutator,\r\n  toStartOfDayMutator,\r\n  toStartOfMonthMutator,\r\n  toStartOfYearMutator,\r\n  toUTCMutator,\r\n} from \"../mutators\";\r\nimport {\r\n  afterFieldRule,\r\n  afterTodayRule,\r\n  ageRule,\r\n  beforeFieldRule,\r\n  beforeHourRule,\r\n  beforeMinuteRule,\r\n  beforeTodayRule,\r\n  betweenAgeRule,\r\n  betweenDatesRule,\r\n  betweenDaysRule,\r\n  betweenHoursRule,\r\n  betweenMinutesRule,\r\n  betweenMonthsRule,\r\n  betweenTimesRule,\r\n  betweenYearsRule,\r\n  birthdayRule,\r\n  businessDayRule,\r\n  dateRule,\r\n  fromHourRule,\r\n  fromMinuteRule,\r\n  fromTodayRule,\r\n  futureRule,\r\n  leapYearRule,\r\n  maxAgeRule,\r\n  maxDateRule,\r\n  maxDayRule,\r\n  maxMonthRule,\r\n  maxYearRule,\r\n  minAgeRule,\r\n  minDateRule,\r\n  minDayRule,\r\n  minMonthRule,\r\n  minYearRule,\r\n  type Month,\r\n  monthRule,\r\n  pastRule,\r\n  quarterRule,\r\n  sameAsFieldDateRule,\r\n  todayRule,\r\n  weekDayRule,\r\n  weekdaysRule,\r\n  weekendRule,\r\n  withinDaysRule,\r\n  withinFutureDaysRule,\r\n  withinPastDaysRule,\r\n  yearRule,\r\n} from \"../rules\";\r\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\r\nimport { applyNullable, getRuleOptions } from \"../standard-schema/json-schema\";\r\nimport type { WeekDay } from \"../types/date-types\";\r\nimport { isDateValue } from \"./../helpers/date-helpers\";\r\nimport { BaseValidator } from \"./base-validator\";\r\n\r\n/**\r\n * Date validator class\r\n */\r\nexport class DateValidator extends BaseValidator {\r\n  public constructor(errorMessage?: string) {\r\n    super();\r\n    this.addMutableMutator(dateMutator); // Normalize to Date object first\r\n    this.addMutableRule(dateRule, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * Check if value is a Date type\r\n   */\r\n  public matchesType(value: any): boolean {\r\n    return isDateValue(value);\r\n  }\r\n\r\n  // ==================== Output Transformers ====================\r\n  // These transform the Date after validation into different formats\r\n\r\n  /**\r\n   * Convert date to ISO string format\r\n   * @category transformer\r\n   */\r\n  public toISOString() {\r\n    return this.addTransformer((data) => (data instanceof Date ? data.toISOString() : data));\r\n  }\r\n\r\n  /** Convert date to Unix timestamp (milliseconds) */\r\n  public toTimestamp() {\r\n    return this.addTransformer((data) => (data instanceof Date ? data.getTime() : data));\r\n  }\r\n\r\n  // ==================== String Format Transformers ====================\r\n  // These convert Date to formatted strings after validation\r\n\r\n  /** Convert date to specific format using dayjs */\r\n  public toFormat(format: string) {\r\n    return this.addTransformer(\r\n      (data, { options }) => (data instanceof Date ? dayjs(data).format(options.format) : data),\r\n      { format },\r\n    );\r\n  }\r\n\r\n  /** Convert to date only (remove time, returns YYYY-MM-DD) */\r\n  public toDateOnly() {\r\n    return this.addTransformer(\r\n      (data) => (data instanceof Date ? dayjs(data).format(\"YYYY-MM-DD\") : data),\r\n      { __jsonSchemaFormat: \"date\" },\r\n    );\r\n  }\r\n\r\n  /** Convert to time only (returns HH:MM:SS) */\r\n  public toTimeOnly() {\r\n    return this.addTransformer(\r\n      (data) => (data instanceof Date ? dayjs(data).format(\"HH:mm:ss\") : data),\r\n      { __jsonSchemaFormat: \"time\" },\r\n    );\r\n  }\r\n\r\n  // ==================== Date Mutators ====================\r\n  // These modify the Date object before validation\r\n\r\n  /**\r\n   * Convert date to start of day (00:00:00)\r\n   * @category mutator\r\n   */\r\n  public toStartOfDay() {\r\n    return this.addMutator(toStartOfDayMutator);\r\n  }\r\n\r\n  /** Convert date to end of day (23:59:59.999) */\r\n  public toEndOfDay() {\r\n    return this.addMutator(toEndOfDayMutator);\r\n  }\r\n\r\n  /** Add or subtract days from date */\r\n  public addDays(days: number) {\r\n    return this.addMutator(addDaysMutator, { days });\r\n  }\r\n\r\n  /** Add or subtract months from date */\r\n  public addMonths(months: number) {\r\n    return this.addMutator(addMonthsMutator, { months });\r\n  }\r\n\r\n  /** Add or subtract years from date */\r\n  public addYears(years: number) {\r\n    return this.addMutator(addYearsMutator, { years });\r\n  }\r\n\r\n  /** Add or subtract hours from date */\r\n  public addHours(hours: number) {\r\n    return this.addMutator(addHoursMutator, { hours });\r\n  }\r\n\r\n  /** Convert date to UTC */\r\n  public toUTC() {\r\n    return this.addMutator(toUTCMutator);\r\n  }\r\n\r\n  // ==================== Date Range Mutators ====================\r\n\r\n  /** Set to start of month */\r\n  public toStartOfMonth() {\r\n    return this.addMutator(toStartOfMonthMutator);\r\n  }\r\n\r\n  /** Set to end of month */\r\n  public toEndOfMonth() {\r\n    return this.addMutator(toEndOfMonthMutator);\r\n  }\r\n\r\n  /** Set to start of year */\r\n  public toStartOfYear() {\r\n    return this.addMutator(toStartOfYearMutator);\r\n  }\r\n\r\n  /** Set to end of year */\r\n  public toEndOfYear() {\r\n    return this.addMutator(toEndOfYearMutator);\r\n  }\r\n\r\n  // ==================== Date Comparison ====================\r\n\r\n  /**\r\n   * Date must be greater than or equal to the given date or field (inclusive)\r\n   *\r\n   * Smart detection:\r\n   * - Date instance, timestamp, or date string (with - or /) → value comparison\r\n   * - Plain string → field comparison\r\n   *\r\n   * @param dateOrField - Date, timestamp, date string, or field name\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * // Value comparison\r\n   * v.date().min('2024-01-01')\r\n   * v.date().min(new Date())\r\n   * v.date().min(1698278400000)\r\n   *\r\n   * // Field comparison\r\n   * v.date().min('startsAt')\r\n   * ```\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public min(dateOrField: Date | string | number, errorMessage?: string): this {\r\n    return this.addRule(minDateRule, errorMessage, {\r\n      dateOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be less than or equal to the given date or field (inclusive)\r\n   *\r\n   * Smart detection:\r\n   * - Date instance, timestamp, or date string (with - or /) → value comparison\r\n   * - Plain string → field comparison\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public max(dateOrField: Date | string | number, errorMessage?: string): this {\r\n    return this.addRule(maxDateRule, errorMessage, {\r\n      dateOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be strictly less than the given date or field (exclusive)\r\n   *\r\n   * Smart detection:\r\n   * - Date instance, timestamp, or date string (with - or /) → value comparison\r\n   * - Plain string → field comparison\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public before(dateOrField: Date | string | number, errorMessage?: string): this {\r\n    return this.addRule(beforeFieldRule, errorMessage, {\r\n      dateOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be strictly greater than the given date or field (exclusive)\r\n   *\r\n   * Smart detection:\r\n   * - Date instance, timestamp, or date string (with - or /) → value comparison\r\n   * - Plain string → field comparison\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public after(dateOrField: Date | string | number, errorMessage?: string): this {\r\n    return this.addRule(afterFieldRule, errorMessage, {\r\n      dateOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /** Date must be between start and end dates */\r\n  public between(startDate: Date, endDate: Date, errorMessage?: string) {\r\n    return this.addRule(betweenDatesRule, errorMessage, { startDate, endDate });\r\n  }\r\n\r\n  /** Date must be exactly today */\r\n  public today(errorMessage?: string) {\r\n    return this.addRule(todayRule, errorMessage);\r\n  }\r\n\r\n  /** Date must be today or in the future */\r\n  public fromToday(errorMessage?: string) {\r\n    return this.addRule(fromTodayRule, errorMessage);\r\n  }\r\n\r\n  /** Date must be before today */\r\n  public beforeToday(errorMessage?: string) {\r\n    return this.addRule(beforeTodayRule, errorMessage);\r\n  }\r\n\r\n  /** Date must be after today (not including today) */\r\n  public afterToday(errorMessage?: string) {\r\n    return this.addRule(afterTodayRule, errorMessage);\r\n  }\r\n\r\n  /** Date must be in the past */\r\n  public past(errorMessage?: string) {\r\n    return this.addRule(pastRule, errorMessage);\r\n  }\r\n\r\n  /** Date must be in the future */\r\n  public future(errorMessage?: string) {\r\n    return this.addRule(futureRule, errorMessage);\r\n  }\r\n\r\n  // ==================== Sibling Field Comparison ====================\r\n  // Explicit sibling scope methods\r\n\r\n  /**\r\n   * Date must be >= sibling field value (inclusive)\r\n   * @category Validation Rule\r\n   */\r\n  public minSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(minDateRule, errorMessage, {\r\n      dateOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be <= sibling field value (inclusive)\r\n   * @category Validation Rule\r\n   */\r\n  public maxSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(maxDateRule, errorMessage, {\r\n      dateOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be < sibling field value (exclusive)\r\n   * @category Validation Rule\r\n   */\r\n  public beforeSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(beforeFieldRule, errorMessage, {\r\n      dateOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be > sibling field value (exclusive)\r\n   * @category Validation Rule\r\n   */\r\n  public afterSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(afterFieldRule, errorMessage, {\r\n      dateOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /** Date must be the same as another field's date */\r\n  public sameAsField(field: string, errorMessage?: string) {\r\n    return this.addRule(sameAsFieldDateRule, errorMessage, {\r\n      field,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /** Date must be the same as another sibling field's date */\r\n  public sameAsFieldSibling(field: string, errorMessage?: string) {\r\n    return this.addRule(sameAsFieldDateRule, errorMessage, {\r\n      field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  // ==================== Time Validation ====================\r\n\r\n  /** Time must be from specific hour onwards (0-23) */\r\n  public fromHour(hour: number, errorMessage?: string) {\r\n    return this.addRule(fromHourRule, errorMessage, { hour });\r\n  }\r\n\r\n  /** Time must be before specific hour (0-23) */\r\n  public beforeHour(hour: number, errorMessage?: string) {\r\n    return this.addRule(beforeHourRule, errorMessage, { hour });\r\n  }\r\n\r\n  /** Time must be between start and end hours (0-23) */\r\n  public betweenHours(startHour: number, endHour: number, errorMessage?: string) {\r\n    return this.addRule(betweenHoursRule, errorMessage, { startHour, endHour });\r\n  }\r\n\r\n  /** Time must be from specific minute onwards (0-59) */\r\n  public fromMinute(minute: number, errorMessage?: string) {\r\n    return this.addRule(fromMinuteRule, errorMessage, { minute });\r\n  }\r\n\r\n  /** Time must be before specific minute (0-59) */\r\n  public beforeMinute(minute: number, errorMessage?: string) {\r\n    return this.addRule(beforeMinuteRule, errorMessage, { minute });\r\n  }\r\n\r\n  /** Time must be between start and end minutes (0-59) */\r\n  public betweenMinutes(startMinute: number, endMinute: number, errorMessage?: string) {\r\n    return this.addRule(betweenMinutesRule, errorMessage, {\r\n      startMinute,\r\n      endMinute,\r\n    });\r\n  }\r\n\r\n  /** Time must be between start and end times (HH:MM format) */\r\n  public betweenTimes(startTime: string, endTime: string, errorMessage?: string) {\r\n    return this.addRule(betweenTimesRule, errorMessage, { startTime, endTime });\r\n  }\r\n\r\n  // ==================== Age Validation ====================\r\n\r\n  /** Age must be exactly the given years */\r\n  public age(years: number, errorMessage?: string) {\r\n    return this.addRule(ageRule, errorMessage, { years });\r\n  }\r\n\r\n  /** Minimum age requirement */\r\n  public minAge(years: number, errorMessage?: string) {\r\n    return this.addRule(minAgeRule, errorMessage, { years });\r\n  }\r\n\r\n  /** Maximum age requirement */\r\n  public maxAge(years: number, errorMessage?: string) {\r\n    return this.addRule(maxAgeRule, errorMessage, { years });\r\n  }\r\n\r\n  /** Age must be between min and max years */\r\n  public betweenAge(minAge: number, maxAge: number, errorMessage?: string) {\r\n    return this.addRule(betweenAgeRule, errorMessage, { minAge, maxAge });\r\n  }\r\n\r\n  // ==================== Day Validation ====================\r\n\r\n  /** Date must be specific weekday */\r\n  public weekDay(day: WeekDay, errorMessage?: string) {\r\n    return this.addRule(weekDayRule, errorMessage, { day });\r\n  }\r\n\r\n  /** Date must be one of specified weekdays */\r\n  public weekdays(days: WeekDay[], errorMessage?: string) {\r\n    return this.addRule(weekdaysRule, errorMessage, { days });\r\n  }\r\n\r\n  /** Date must be a weekend (Saturday or Sunday) */\r\n  public weekend(errorMessage?: string) {\r\n    return this.addRule(weekendRule, errorMessage);\r\n  }\r\n\r\n  /** Date must be a business day (Monday-Friday) */\r\n  public businessDay(errorMessage?: string) {\r\n    return this.addRule(businessDayRule, errorMessage);\r\n  }\r\n\r\n  /** Date must match specific format */\r\n  public format(format: string, errorMessage?: string) {\r\n    return this.addRule(dateRule, errorMessage, { format });\r\n  }\r\n\r\n  // ==================== Relative Date Validation ====================\r\n\r\n  /** Date must be within X days from now (past or future) */\r\n  public withinDays(days: number, errorMessage?: string) {\r\n    return this.addRule(withinDaysRule, errorMessage, { days });\r\n  }\r\n\r\n  /** Date must be within X days in the past */\r\n  public withinPastDays(days: number, errorMessage?: string) {\r\n    return this.addRule(withinPastDaysRule, errorMessage, { days });\r\n  }\r\n\r\n  /** Date must be within X days in the future */\r\n  public withinFutureDays(days: number, errorMessage?: string) {\r\n    return this.addRule(withinFutureDaysRule, errorMessage, { days });\r\n  }\r\n\r\n  // ==================== Period Validation ====================\r\n\r\n  /** Date must be in specific month (1-12) */\r\n  public month(month: Month, errorMessage?: string) {\r\n    return this.addRule(monthRule, errorMessage, { month });\r\n  }\r\n\r\n  /** Date must be in specific year */\r\n  public year(year: number, errorMessage?: string) {\r\n    return this.addRule(yearRule, errorMessage, { year });\r\n  }\r\n\r\n  /**\r\n   * Date must be between start and end years\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public betweenYears(startYear: number | string, endYear: number | string, errorMessage?: string) {\r\n    return this.addRule(betweenYearsRule, errorMessage, {\r\n      startYear,\r\n      endYear,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be between start and end months (1-12)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public betweenMonths(\r\n    startMonth: Month | string,\r\n    endMonth: Month | string,\r\n    errorMessage?: string,\r\n  ) {\r\n    return this.addRule(betweenMonthsRule, errorMessage, {\r\n      startMonth,\r\n      endMonth,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be between start and end days (1-31)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public betweenDays(startDay: number | string, endDay: number | string, errorMessage?: string) {\r\n    return this.addRule(betweenDaysRule, errorMessage, {\r\n      startDay,\r\n      endDay,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be between sibling field years\r\n   * @category Validation Rule\r\n   */\r\n  public betweenYearsSibling(startYearField: string, endYearField: string, errorMessage?: string) {\r\n    return this.addRule(betweenYearsRule, errorMessage, {\r\n      startYear: startYearField,\r\n      endYear: endYearField,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be between sibling field months\r\n   * @category Validation Rule\r\n   */\r\n  public betweenMonthsSibling(\r\n    startMonthField: string,\r\n    endMonthField: string,\r\n    errorMessage?: string,\r\n  ) {\r\n    return this.addRule(betweenMonthsRule, errorMessage, {\r\n      startMonth: startMonthField,\r\n      endMonth: endMonthField,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Date must be between sibling field days\r\n   * @category Validation Rule\r\n   */\r\n  public betweenDaysSibling(startDayField: string, endDayField: string, errorMessage?: string) {\r\n    return this.addRule(betweenDaysRule, errorMessage, {\r\n      startDay: startDayField,\r\n      endDay: endDayField,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Year must be >= given year or field\r\n   * Smart detection: number or field name\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * // Value comparison\r\n   * v.date().minYear(2024)\r\n   *\r\n   * // Field comparison\r\n   * v.date().minYear('startYear')\r\n   * ```\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public minYear(yearOrField: number | string, errorMessage?: string): this {\r\n    return this.addRule(minYearRule, errorMessage, {\r\n      yearOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Year must be <= given year or field\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public maxYear(yearOrField: number | string, errorMessage?: string): this {\r\n    return this.addRule(maxYearRule, errorMessage, {\r\n      yearOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Month must be >= given month or field (1-12)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public minMonth(monthOrField: number | string, errorMessage?: string): this {\r\n    return this.addRule(minMonthRule, errorMessage, {\r\n      monthOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Month must be <= given month or field (1-12)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public maxMonth(monthOrField: Month | string, errorMessage?: string): this {\r\n    return this.addRule(maxMonthRule, errorMessage, {\r\n      monthOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Day must be >= given day or field (1-31)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public minDay(dayOrField: number | string, errorMessage?: string): this {\r\n    return this.addRule(minDayRule, errorMessage, {\r\n      dayOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Day must be <= given day or field (1-31)\r\n   * Smart detection: number or field name\r\n   *\r\n   * @category Validation Rule\r\n   */\r\n  public maxDay(dayOrField: number | string, errorMessage?: string): this {\r\n    return this.addRule(maxDayRule, errorMessage, {\r\n      dayOrField,\r\n      scope: \"global\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Year must be >= sibling field year\r\n   * @category Validation Rule\r\n   */\r\n  public minYearSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(minYearRule, errorMessage, {\r\n      yearOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Year must be <= sibling field year\r\n   * @category Validation Rule\r\n   */\r\n  public maxYearSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(maxYearRule, errorMessage, {\r\n      yearOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Month must be >= sibling field month\r\n   * @category Validation Rule\r\n   */\r\n  public minMonthSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(minMonthRule, errorMessage, {\r\n      monthOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Month must be <= sibling field month\r\n   * @category Validation Rule\r\n   */\r\n  public maxMonthSibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(maxMonthRule, errorMessage, {\r\n      monthOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Day must be >= sibling field day\r\n   * @category Validation Rule\r\n   */\r\n  public minDaySibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(minDayRule, errorMessage, {\r\n      dayOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Day must be <= sibling field day\r\n   * @category Validation Rule\r\n   */\r\n  public maxDaySibling(field: string, errorMessage?: string): this {\r\n    return this.addRule(maxDayRule, errorMessage, {\r\n      dayOrField: field,\r\n      scope: \"sibling\",\r\n    });\r\n  }\r\n\r\n  /** Date must be in specific quarter (1-4) */\r\n  public quarter(quarter: 1 | 2 | 3 | 4, errorMessage?: string) {\r\n    return this.addRule(quarterRule, errorMessage, { quarter });\r\n  }\r\n\r\n  // ==================== Special Validation ====================\r\n\r\n  /** Valid birthday (not in future, reasonable age) */\r\n  public birthday(minAge?: number, maxAge?: number, errorMessage?: string) {\r\n    return this.addRule(birthdayRule, errorMessage, { minAge, maxAge });\r\n  }\r\n\r\n  /** Date must be in a leap year */\r\n  public leapYear(errorMessage?: string) {\r\n    return this.addRule(leapYearRule, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * Set default value as current time of exeuction\r\n   */\r\n  public defaultNow() {\r\n    return this.default(() => new Date());\r\n  }\r\n\r\n  /**\r\n   * @inheritdoc\r\n   *\r\n   * Maps DateValidator to JSON Schema format keywords.\r\n   * Default is `date-time`. If `.toDateOnly()` or `.toTimeOnly()` are used,\r\n   * falls back to `date` or `time` formats respectively.\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * v.date().toJsonSchema(\"draft-2020-12\")\r\n   * // → { type: \"string\", format: \"date-time\" }\r\n   *\r\n   * v.date().toDateOnly().toJsonSchema(\"draft-2020-12\")\r\n   * // → { type: \"string\", format: \"date\" }\r\n   * ```\r\n   */\r\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\r\n    const schema: JsonSchemaResult = { type: \"string\", format: \"date-time\" };\r\n\r\n    // Check if an explicit format rule was applied via v.date().format()\r\n    const dateOpts = getRuleOptions(this.rules, \"date\");\r\n    if (dateOpts?.format === \"YYYY-MM-DD\") {\r\n      schema.format = \"date\";\r\n    } else if (dateOpts?.format === \"HH:mm:ss\") {\r\n      schema.format = \"time\";\r\n    }\r\n\r\n    // Transformer-based detection (marker-driven; minifier-safe).\r\n    // toDateOnly/toTimeOnly tag their options bag with __jsonSchemaFormat.\r\n    // toFormat() exposes the user-supplied format string in options.format.\r\n    if (schema.format === \"date-time\") {\r\n      for (const t of this.dataTransformers) {\r\n        const hint = t.options?.__jsonSchemaFormat;\r\n        if (hint === \"date\" || hint === \"time\") {\r\n          schema.format = hint;\r\n          break;\r\n        }\r\n\r\n        const userFormat = t.options?.format;\r\n\r\n        if (userFormat === \"YYYY-MM-DD\") {\r\n          schema.format = \"date\";\r\n          break;\r\n        }\r\n\r\n        if (userFormat === \"HH:mm:ss\") {\r\n          schema.format = \"time\";\r\n          break;\r\n        }\r\n      }\r\n    }\r\n\r\n    if (this.isNullable) applyNullable(schema, target);\r\n\r\n    return schema;\r\n  }\r\n}\r\n"],"mappings":"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"}

package/esm/seal/src/validators/discriminated-union-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"discriminated-union-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/discriminated-union-validator.ts"],"sourcesContent":["import { isPlainObject } from \"@mongez/supportive-is\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport { applyNullable, wrapNullableStrict } from \"../standard-schema/json-schema\";\nimport type { SchemaContext, ValidationResult } from \"../types\";\nimport { BaseValidator } from \"./base-validator\";\nimport { LiteralValidator } from \"./literal-validator\";\nimport { ObjectValidator } from \"./object-validator\";\n\n/**\n * Discriminated union validator — routes payloads by a shared discriminator field.\n *\n * Plain `v.union()` falls back to `matchesType()` to pick a branch, which is\n * coarse for object-vs-object unions (every branch matches \"is plain object\").\n * Discriminated union reads a known field's value and routes directly to the\n * matching branch, producing precise errors instead of confused mash from the\n * wrong branch.\n *\n * **Construction-time validation.** Every branch must:\n * - Be an `ObjectValidator`\n * - Declare the discriminator field\n * - Type the discriminator as `v.literal(...)` (single or multi-literal both work)\n * - Not collide with another branch's literal values\n *\n * Misconfigurations throw eagerly so tests catch them at schema-build time.\n *\n * @example\n * ```ts\n * const email = v.object({ type: v.literal(\"email\"), email: v.string().email() });\n * const sms   = v.object({ type: v.literal(\"sms\"),   phone: v.string() });\n * const push  = v.object({ type: v.literal(\"push\"),  deviceId: v.string() });\n *\n * const notif = v.discriminatedUnion(\"type\", [email, sms, push]);\n *\n * await validate(notif, { type: \"sms\", phone: \"555-1234\" });\n * // → routes to sms branch only; errors (if any) come from sms\n * ```\n *\n * @see `domains/seal/plans/2026-05-12-discriminated-union.md`\n */\nexport class DiscriminatedUnionValidator<\n  K extends string = string,\n  Branches extends ReadonlyArray<ObjectValidator<any>> = ReadonlyArray<ObjectValidator<any>>,\n> extends BaseValidator {\n  /** Map from discriminator literal value → matching branch validator. */\n  private branches: Map<string | number | boolean, ObjectValidator<any>>;\n\n  public constructor(\n    public discriminator: K,\n    public validators: Branches,\n  ) {\n    super();\n\n    this.branches = DiscriminatedUnionValidator.buildBranchMap(discriminator, validators);\n  }\n\n  /**\n   * Walk every branch, pull out the discriminator's literal values, and build\n   * the lookup map. Throws on misconfiguration (missing discriminator,\n   * non-literal discriminator, duplicate literal value).\n   */\n  private static buildBranchMap(\n    discriminator: string,\n    validators: ReadonlyArray<ObjectValidator<any>>,\n  ): Map<string | number | boolean, ObjectValidator<any>> {\n    const map = new Map<string | number | boolean, ObjectValidator<any>>();\n\n    for (const branch of validators) {\n      const discriminatorValidator = branch.schema?.[discriminator];\n\n      if (!discriminatorValidator) {\n        throw new Error(\n          `[Seal] discriminatedUnion: branch missing discriminator field \"${discriminator}\"`,\n        );\n      }\n\n      if (!(discriminatorValidator instanceof LiteralValidator)) {\n        throw new Error(\n          `[Seal] discriminatedUnion: discriminator \"${discriminator}\" must be v.literal(...) on every branch`,\n        );\n      }\n\n      for (const value of discriminatorValidator.values) {\n        if (map.has(value)) {\n          throw new Error(\n            `[Seal] discriminatedUnion: duplicate discriminator value \"${String(value)}\"`,\n          );\n        }\n        map.set(value, branch);\n      }\n    }\n\n    return map;\n  }\n\n  public override matchesType(value: any): boolean {\n    return isPlainObject(value);\n  }\n\n  public override async validate(data: any, context: SchemaContext): Promise<ValidationResult> {\n    if (data === null && this.isNullable) {\n      return { isValid: true, errors: [], data: null };\n    }\n\n    if (!isPlainObject(data)) {\n      return {\n        isValid: false,\n        errors: [\n          {\n            type: \"discriminatedUnion\",\n            error: `Expected object with discriminator field \"${this.discriminator}\"`,\n            input: context.key || context.path || \"value\",\n          },\n        ],\n        data: undefined,\n      };\n    }\n\n    const discriminatorValue = data[this.discriminator];\n    const branch = this.branches.get(discriminatorValue);\n\n    if (!branch) {\n      const allowed = [...this.branches.keys()].map((k) => String(k)).join(\", \");\n      return {\n        isValid: false,\n        errors: [\n          {\n            type: \"discriminatedUnion\",\n            error: `Field \"${this.discriminator}\" must be one of: ${allowed}`,\n            input: this.discriminator,\n          },\n        ],\n        data: undefined,\n      };\n    }\n\n    return branch.validate(data, context);\n  }\n\n  public override clone(): this {\n    const cloned = super.clone() as any;\n    cloned.discriminator = this.discriminator;\n    cloned.validators = this.validators.map((v: ObjectValidator<any>) => v.clone());\n    cloned.branches = DiscriminatedUnionValidator.buildBranchMap(\n      cloned.discriminator,\n      cloned.validators,\n    );\n    return cloned;\n  }\n\n  /**\n   * Emit `oneOf` of branch schemas. Each branch's own `toJsonSchema()` handles\n   * its `properties.{discriminator}.const` and the surrounding required/optional\n   * structure — we just enumerate.\n   *\n   * For `openai-strict`: the per-branch ObjectValidator already inflates\n   * `required` to include every field; `oneOf` is OpenAI-accepted as long as\n   * each branch passes strict rules independently.\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    const oneOf = this.validators.map((v) => v.toJsonSchema(target));\n    const schema: JsonSchemaResult = { oneOf };\n\n    if (this.isNullable) {\n      if (target === \"openai-strict\") {\n        return wrapNullableStrict(schema);\n      }\n      applyNullable(schema, target);\n    }\n\n    return schema;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,IAAa,8BAAb,MAAa,oCAGH,cAAc;CAKb;CACA;;CAJT,AAAQ;CAER,AAAO,YACL,AAAO,eACP,AAAO,YACP;EACA,MAAM;EAHC;EACA;EAIP,KAAK,WAAW,4BAA4B,eAAe,eAAe,UAAU;CACtF;;;;;;CAOA,OAAe,eACb,eACA,YACsD;EACtD,MAAM,sBAAM,IAAI,IAAqD;EAErE,KAAK,MAAM,UAAU,YAAY;GAC/B,MAAM,yBAAyB,OAAO,SAAS;GAE/C,IAAI,CAAC,wBACH,MAAM,IAAI,MACR,kEAAkE,cAAc,EAClF;GAGF,IAAI,EAAE,kCAAkC,mBACtC,MAAM,IAAI,MACR,6CAA6C,cAAc,yCAC7D;GAGF,KAAK,MAAM,SAAS,uBAAuB,QAAQ;IACjD,IAAI,IAAI,IAAI,KAAK,GACf,MAAM,IAAI,MACR,6DAA6D,OAAO,KAAK,EAAE,EAC7E;IAEF,IAAI,IAAI,OAAO,MAAM;GACvB;EACF;EAEA,OAAO;CACT;CAEA,AAAgB,YAAY,OAAqB;EAC/C,OAAO,cAAc,KAAK;CAC5B;CAEA,MAAsB,SAAS,MAAW,SAAmD;EAC3F,IAAI,SAAS,QAAQ,KAAK,YACxB,OAAO;GAAE,SAAS;GAAM,QAAQ,CAAC;GAAG,MAAM;EAAK;EAGjD,IAAI,CAAC,cAAc,IAAI,GACrB,OAAO;GACL,SAAS;GACT,QAAQ,CACN;IACE,MAAM;IACN,OAAO,6CAA6C,KAAK,cAAc;IACvE,OAAO,QAAQ,OAAO,QAAQ,QAAQ;GACxC,CACF;GACA,MAAM;EACR;EAGF,MAAM,qBAAqB,KAAK,KAAK;EACrC,MAAM,SAAS,KAAK,SAAS,IAAI,kBAAkB;EAEnD,IAAI,CAAC,QAAQ;GACX,MAAM,UAAU,CAAC,GAAG,KAAK,SAAS,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,OAAO,CAAC,CAAC,CAAC,CAAC,KAAK,IAAI;GACzE,OAAO;IACL,SAAS;IACT,QAAQ,CACN;KACE,MAAM;KACN,OAAO,UAAU,KAAK,cAAc,oBAAoB;KACxD,OAAO,KAAK;IACd,CACF;IACA,MAAM;GACR;EACF;EAEA,OAAO,OAAO,SAAS,MAAM,OAAO;CACtC;CAEA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAC3B,OAAO,gBAAgB,KAAK;EAC5B,OAAO,aAAa,KAAK,WAAW,KAAK,MAA4B,EAAE,MAAM,CAAC;EAC9E,OAAO,WAAW,4BAA4B,eAC5C,OAAO,eACP,OAAO,UACT;EACA,OAAO;CACT;;;;;;;;;;CAWA,AAAgB,aAAa,SAA2B,iBAAmC;EAEzF,MAAM,SAA2B,EAAE,OADrB,KAAK,WAAW,KAAK,MAAM,EAAE,aAAa,MAAM,CACvB,EAAE;EAEzC,IAAI,KAAK,YAAY;GACnB,IAAI,WAAW,iBACb,OAAO,mBAAmB,MAAM;GAElC,cAAc,QAAQ,MAAM;EAC9B;EAEA,OAAO;CACT;AACF"}

package/esm/seal/src/validators/float-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"float-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/float-validator.ts"],"sourcesContent":["import { floatRule } from \"../rules\";\r\nimport { NumberValidator } from \"./number-validator\";\r\n\r\n/**\r\n * Float validator class\r\n */\r\nexport class FloatValidator extends NumberValidator {\r\n  public constructor(errorMessage?: string) {\r\n    super();\r\n    this.addMutableRule(floatRule, errorMessage);\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;AAMA,IAAa,iBAAb,cAAoC,gBAAgB;CAClD,AAAO,YAAY,cAAuB;EACxC,MAAM;EACN,KAAK,eAAe,WAAW,YAAY;CAC7C;AACF"}

package/esm/seal/src/validators/index.mjs

@@ -1,28 +0,0 @@
-import { BaseValidator } from "./base-validator.mjs";
-import { AnyValidator } from "./any-validator.mjs";
-import { ArrayValidator } from "./array-validator.mjs";
-import "./methods/equality-conditional-methods.mjs";
-import "./methods/forbidden-methods.mjs";
-import "./methods/present-methods.mjs";
-import "./methods/required-methods.mjs";
-import { PrimitiveValidator } from "./primitive-validator.mjs";
-import { BooleanValidator } from "./boolean-validator.mjs";
-import { ComputedValidator } from "./computed-validator.mjs";
-import { DateValidator } from "./date-validator.mjs";
-import { LiteralValidator } from "./literal-validator.mjs";
-import { DiscriminatedUnionValidator } from "./discriminated-union-validator.mjs";
-import { NumberValidator } from "./number-validator.mjs";
-import { FloatValidator } from "./float-validator.mjs";
-import { InstanceOfValidator } from "./instanceof-validator.mjs";
-import { IntValidator } from "./int-validator.mjs";
-import { LazyValidator } from "./lazy-validator.mjs";
-import { ManagedValidator } from "./managed-validator.mjs";
-import { NumericValidator } from "./numeric-validator.mjs";
-import { ObjectValidator } from "./object-validator.mjs";
-import { RecordValidator } from "./record-validator.mjs";
-import { ScalarValidator } from "./scalar-validator.mjs";
-import { StringValidator } from "./string-validator.mjs";
-import { TupleValidator } from "./tuple-validator.mjs";
-import { UnionValidator } from "./union-validator.mjs";
-
-export {  };

package/esm/seal/src/validators/instanceof-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"instanceof-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/instanceof-validator.ts"],"sourcesContent":["import { instanceofRule } from \"../rules/common/instanceof\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport { BaseValidator } from \"./base-validator\";\n\n/**\n * InstanceOf validator class\n *\n * Validates that the value is an instance of the given constructor (`value instanceof Ctor`).\n * Useful for File uploads, Buffer/Uint8Array payloads, and custom domain classes —\n * anywhere a runtime class identity is the right contract.\n *\n * Note: `Date` is already covered by `v.date()` with richer date-specific rules;\n * reach for `v.instanceof(Date)` only when you specifically want raw `instanceof`\n * semantics with no normalization.\n *\n * @example\n * v.instanceof(File)        // type: File\n * v.instanceof(Buffer)      // type: Buffer\n * v.instanceof(MyClass)     // type: MyClass\n */\nexport class InstanceOfValidator<T = unknown> extends BaseValidator {\n  public ctor: new (...args: any[]) => T;\n\n  public constructor(ctor: new (...args: any[]) => T, errorMessage?: string) {\n    super();\n    this.ctor = ctor;\n    this.addMutableRule(instanceofRule, errorMessage, { ctor, name: ctor.name || \"instance\" });\n  }\n\n  /**\n   * Check if value is an instance of the configured constructor\n   */\n  public matchesType(value: any): boolean {\n    return value instanceof this.ctor;\n  }\n\n  /**\n   * Clone the validator, preserving the target constructor.\n   *\n   * The base `clone()` only copies `BaseValidator` fields, so without this\n   * override a cloned `instanceof` validator loses its `ctor` reference and\n   * `matchesType()` would throw on the next call.\n   */\n  public override clone(): this {\n    const cloned = super.clone();\n    cloned.ctor = this.ctor;\n    return cloned;\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * Class instances are not representable in JSON Schema — returns an empty\n   * schema (permissive). Consumers serializing to OpenAPI should attach an\n   * appropriate format manually if needed (e.g. `{ type: \"string\", format: \"binary\" }`\n   * for `File`).\n   */\n  public override toJsonSchema(_target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    return {};\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,IAAa,sBAAb,cAAsD,cAAc;CAClE,AAAO;CAEP,AAAO,YAAY,MAAiC,cAAuB;EACzE,MAAM;EACN,KAAK,OAAO;EACZ,KAAK,eAAe,gBAAgB,cAAc;GAAE;GAAM,MAAM,KAAK,QAAQ;EAAW,CAAC;CAC3F;;;;CAKA,AAAO,YAAY,OAAqB;EACtC,OAAO,iBAAiB,KAAK;CAC/B;;;;;;;;CASA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAC3B,OAAO,OAAO,KAAK;EACnB,OAAO;CACT;;;;;;;;;CAUA,AAAgB,aAAa,UAA4B,iBAAmC;EAC1F,OAAO,CAAC;CACV;AACF"}

package/esm/seal/src/validators/int-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"int-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/int-validator.ts"],"sourcesContent":["import { intRule } from \"../rules\";\r\nimport { NumberValidator } from \"./number-validator\";\r\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\r\n\r\n/**\r\n * Integer validator class\r\n */\r\nexport class IntValidator extends NumberValidator {\r\n  public constructor(errorMessage?: string) {\r\n    super();\r\n    this.addMutableRule(intRule, errorMessage);\r\n  }\r\n\r\n  /**\r\n   * @inheritdoc — returns `{ type: \"integer\" }` instead of `{ type: \"number\" }`\r\n   *\r\n   * @example\r\n   * ```ts\r\n   * v.int().min(1).max(100).toJsonSchema(\"draft-2020-12\")\r\n   * // → { type: \"integer\", minimum: 1, maximum: 100 }\r\n   * ```\r\n   */\r\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\r\n    return this.buildNumberJsonSchema(\"integer\", target);\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;AAOA,IAAa,eAAb,cAAkC,gBAAgB;CAChD,AAAO,YAAY,cAAuB;EACxC,MAAM;EACN,KAAK,eAAe,SAAS,YAAY;CAC3C;;;;;;;;;;CAWA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,OAAO,KAAK,sBAAsB,WAAW,MAAM;CACrD;AACF"}

package/esm/seal/src/validators/lazy-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"lazy-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/lazy-validator.ts"],"sourcesContent":["import type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport type { SchemaContext, ValidationResult } from \"../types\";\nimport { BaseValidator } from \"./base-validator\";\n\n/**\n * Lazy validator — defers resolution of the inner validator until validate-time.\n *\n * Solves the chicken-and-egg of self-referencing schemas. JavaScript evaluates\n * an object literal before the `const` binding completes, so this can't work:\n *\n * ```ts\n * const categorySchema = v.object({\n *   name: v.string(),\n *   children: v.array(categorySchema),  // ❌ ReferenceError\n * });\n * ```\n *\n * Wrap the recursive reference in `v.lazy(() => …)` — the thunk isn't invoked\n * during construction, only when `validate()` is called:\n *\n * ```ts\n * type Category = { name: string; children: Category[] };\n *\n * const categorySchema: ObjectValidator<...> = v.object({\n *   name: v.string(),\n *   children: v.array(v.lazy(() => categorySchema)),\n * });\n *\n * type T = Infer<typeof categorySchema>;\n * // { name: string; children: T[] }   ← recursive type\n * ```\n *\n * The thunk is memoized — it's invoked once on the first validate (or\n * `matchesType` / `toJsonSchema`) call and the result is cached. The thunk is\n * expected to return a stable validator; calling it on every validate would be\n * wasteful and could mask bugs where the user accidentally returns a fresh\n * validator each time.\n *\n * **JSON Schema caveat.** v1 uses simple resolve-and-delegate — recursive\n * schemas will infinite-loop in `toJsonSchema()`. If you need JSON Schema for\n * a recursive shape, generate it manually with `$defs` + `$ref` until v2 lands.\n *\n * @see `domains/seal/plans/2026-05-12-lazy-validator.md`\n */\nexport class LazyValidator<T extends BaseValidator = BaseValidator> extends BaseValidator {\n  private resolvedValidator: T | undefined;\n\n  public constructor(private thunk: () => T) {\n    super();\n    // Lazy itself defers required handling to the inner validator —\n    // mark the wrapper as optional so the required check doesn't fire here.\n    this.requiredRule = null;\n    this.isOptional = true;\n  }\n\n  /**\n   * Resolve the inner validator. Memoizes the result so subsequent calls\n   * don't re-execute the thunk.\n   */\n  private resolve(): T {\n    if (this.resolvedValidator === undefined) {\n      this.resolvedValidator = this.thunk();\n    }\n\n    return this.resolvedValidator;\n  }\n\n  public override async validate(data: any, context: SchemaContext): Promise<ValidationResult> {\n    return this.resolve().validate(data, context);\n  }\n\n  public override matchesType(value: any): boolean {\n    return this.resolve().matchesType(value);\n  }\n\n  public override clone(): this {\n    const cloned = super.clone();\n    // Share the thunk reference; reset the memo so the clone resolves\n    // independently on its first call (in case the thunk closure resolves\n    // differently in a different context — unlikely but cheap insurance).\n    cloned.thunk = this.thunk;\n    cloned.resolvedValidator = undefined;\n\n    return cloned;\n  }\n\n  /**\n   * JSON Schema generation — simple resolve-and-delegate.\n   *\n   * **Recursive schemas will infinite-loop.** Until v2 adds `$ref` + `$defs`\n   * generation, callers needing JSON Schema for recursive shapes must build\n   * the schema manually.\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    return this.resolve().toJsonSchema(target);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,IAAa,gBAAb,cAA4E,cAAc;CAG7D;CAF3B,AAAQ;CAER,AAAO,YAAY,AAAQ,OAAgB;EACzC,MAAM;EADmB;EAIzB,KAAK,eAAe;EACpB,KAAK,aAAa;CACpB;;;;;CAMA,AAAQ,UAAa;EACnB,IAAI,KAAK,sBAAsB,QAC7B,KAAK,oBAAoB,KAAK,MAAM;EAGtC,OAAO,KAAK;CACd;CAEA,MAAsB,SAAS,MAAW,SAAmD;EAC3F,OAAO,KAAK,QAAQ,CAAC,CAAC,SAAS,MAAM,OAAO;CAC9C;CAEA,AAAgB,YAAY,OAAqB;EAC/C,OAAO,KAAK,QAAQ,CAAC,CAAC,YAAY,KAAK;CACzC;CAEA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAI3B,OAAO,QAAQ,KAAK;EACpB,OAAO,oBAAoB;EAE3B,OAAO;CACT;;;;;;;;CASA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,OAAO,KAAK,QAAQ,CAAC,CAAC,aAAa,MAAM;CAC3C;AACF"}

package/esm/seal/src/validators/literal-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"literal-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/literal-validator.ts"],"sourcesContent":["import { isEmptyValue } from \"../helpers/is-empty-value\";\nimport { literalRule } from \"../rules/common/literal\";\nimport { presentRule } from \"../rules/core/required\";\nimport { applyNullable } from \"../standard-schema/json-schema\";\nimport type { JsonSchemaResult, JsonSchemaTarget } from \"../standard-schema/json-schema\";\nimport { BaseValidator } from \"./base-validator\";\n\n/**\n * Literal validator class\n *\n * Accepts a fixed tuple of primitive literal values (string, number, boolean).\n * The TypeScript type narrows to the union of those literals — `v.literal(\"a\", \"b\")`\n * infers as `\"a\" | \"b\"`, not `string`. Use for discriminator fields, enum-like\n * unions of constants, and any case where `oneOf([...])` would lose literal types.\n *\n * @example\n * v.literal(\"items\")               // type: \"items\"\n * v.literal(\"draft\", \"published\")  // type: \"draft\" | \"published\"\n * v.literal(1, 2, 3)               // type: 1 | 2 | 3\n * v.literal(true)                  // type: true\n */\nexport class LiteralValidator<\n  T extends readonly (string | number | boolean)[] = readonly (string | number | boolean)[],\n> extends BaseValidator {\n  public values: T;\n\n  public constructor(values: T, errorMessage?: string) {\n    super();\n    this.values = values;\n    this.addMutableRule(literalRule, errorMessage, { values });\n\n    // `\"\"` is a value, not an absence. Every validator is required by default,\n    // and `required` rejects anything `isEmptyValue` calls empty — including the\n    // empty string — so `v.literal(\"\")` could never pass. When the author has\n    // explicitly listed an empty value as acceptable, swap `required` for\n    // `present`: the key must still exist, but judging the value is the literal\n    // set's job, and it is already the stricter statement of intent.\n    //\n    // Dropping the rule entirely instead would make a missing key valid, which\n    // is the opposite mistake — `alt=\"\"` and no `alt` at all are different\n    // things to a screen reader, and to anything else reading the schema.\n    if (values.some(value => isEmptyValue(value))) {\n      this.requiredRule = this.createRule(presentRule);\n    }\n  }\n\n  /**\n   * Check if value is one of the configured literals\n   */\n  public matchesType(value: any): boolean {\n    return (this.values as readonly any[]).includes(value);\n  }\n\n  /**\n   * Clone the validator, preserving the literal `values` set.\n   *\n   * The base `clone()` only copies `BaseValidator` fields, so without this\n   * override a cloned literal loses its public `values` array — which breaks\n   * any consumer that reads it (e.g. `discriminatedUnion` branch routing).\n   */\n  public override clone(): this {\n    const cloned = super.clone();\n    cloned.values = this.values;\n    return cloned;\n  }\n\n  /**\n   * @inheritdoc\n   *\n   * Single literal → `{ const: <value> }`. Multiple → `{ enum: [...] }`.\n   *\n   * @example\n   * ```ts\n   * v.literal(\"items\").toJsonSchema()\n   * // → { const: \"items\" }\n   *\n   * v.literal(\"draft\", \"published\").toJsonSchema()\n   * // → { enum: [\"draft\", \"published\"] }\n   * ```\n   */\n  public override toJsonSchema(target: JsonSchemaTarget = \"draft-2020-12\"): JsonSchemaResult {\n    const schema: JsonSchemaResult =\n      this.values.length === 1 ? { const: this.values[0] } : { enum: [...this.values] };\n    if (this.isNullable) applyNullable(schema, target);\n    return schema;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,IAAa,mBAAb,cAEU,cAAc;CACtB,AAAO;CAEP,AAAO,YAAY,QAAW,cAAuB;EACnD,MAAM;EACN,KAAK,SAAS;EACd,KAAK,eAAe,aAAa,cAAc,EAAE,OAAO,CAAC;EAYzD,IAAI,OAAO,MAAK,UAAS,aAAa,KAAK,CAAC,GAC1C,KAAK,eAAe,KAAK,WAAW,WAAW;CAEnD;;;;CAKA,AAAO,YAAY,OAAqB;EACtC,OAAQ,KAAK,OAA0B,SAAS,KAAK;CACvD;;;;;;;;CASA,AAAgB,QAAc;EAC5B,MAAM,SAAS,MAAM,MAAM;EAC3B,OAAO,SAAS,KAAK;EACrB,OAAO;CACT;;;;;;;;;;;;;;;CAgBA,AAAgB,aAAa,SAA2B,iBAAmC;EACzF,MAAM,SACJ,KAAK,OAAO,WAAW,IAAI,EAAE,OAAO,KAAK,OAAO,GAAG,IAAI,EAAE,MAAM,CAAC,GAAG,KAAK,MAAM,EAAE;EAClF,IAAI,KAAK,YAAY,cAAc,QAAQ,MAAM;EACjD,OAAO;CACT;AACF"}

package/esm/seal/src/validators/managed-validator.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"managed-validator.mjs","names":[],"sources":["../../../../../../../../../seal/src/validators/managed-validator.ts"],"sourcesContent":["import type { SchemaContext } from \"../types\";\nimport type { BaseValidator } from \"./base-validator\";\nimport { ComputedValidator, type ComputedCallback } from \"./computed-validator\";\n\n/**\n * Callback function for managed fields\n * Receives only schema context (no data dependency)\n */\nexport type ManagedCallback<TResult = any> = (context: SchemaContext) => TResult | Promise<TResult>;\n\n/**\n * Managed field validator\n *\n * The callback is optional - if not provided, the framework can inject the value.\n * @example\n * ```ts\n * // With callback (framework executes it)\n * const schema = v.object({\n *   name: v.string(),\n *   createdAt: v.managed(() => new Date()),\n *   updatedAt: v.managed(() => new Date()),\n * });\n *\n * // Without callback (framework injects value)\n * const schema = v.object({\n *   name: v.string(),\n *   id: v.managed(() => 1),\n * });\n * ```\n */\nexport class ManagedValidator<TResult = any> extends ComputedValidator<TResult> {\n  /**\n   * Create a new managed field validator\n   *\n   * @param callback - Optional function to generate the value\n   * @param resultValidator - Optional validator to validate the generated result\n   */\n  constructor(callback: ManagedCallback<TResult>, resultValidator?: BaseValidator) {\n    // Convert ManagedCallback to ComputedCallback\n    // Managed callbacks don't receive data, only context\n    const computedCallback: ComputedCallback<TResult> = (_data, context) => callback(context);\n\n    super(computedCallback, resultValidator);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,mBAAb,cAAqD,kBAA2B;;;;;;;CAO9E,YAAY,UAAoC,iBAAiC;EAG/E,MAAM,oBAA+C,OAAO,YAAY,SAAS,OAAO;EAExF,MAAM,kBAAkB,eAAe;CACzC;AACF"}

package/esm/seal/src/validators/methods/equality-conditional-methods.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"equality-conditional-methods.mjs","names":[],"sources":["../../../../../../../../../../seal/src/validators/methods/equality-conditional-methods.ts"],"sourcesContent":["import { equalsFieldRule, notEqualsFieldRule } from \"../../rules\";\r\nimport { equalRule } from \"../../rules/core/equal\";\r\nimport { whenRule } from \"../../rules/core/when\";\r\nimport type { WhenRuleOptions } from \"../../types\";\r\nimport { BaseValidator } from \"../base-validator\";\r\n\r\n/**\r\n * Marker re-exported by the validators barrel so the dts bundler keeps this\r\n * module (and its `declare module` augmentation) in the bundled `.d.ts`.\r\n */\r\nexport const equalityConditionalMethodsApplied = true;\r\n\r\ndeclare module \"../base-validator\" {\r\n  interface BaseValidator {\r\n    /**\r\n     * Value must be equal to the given value\r\n     */\r\n    equal(value: any, errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value must be the same as another field's value\r\n     */\r\n    sameAs(field: string, errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value must be the same as another sibling field's value\r\n     */\r\n    sameAsSibling(field: string, errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value must be different from another field's value\r\n     */\r\n    differentFrom(field: string, errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value must be different from another sibling field's value\r\n     */\r\n    differentFromSibling(field: string, errorMessage?: string): this;\r\n\r\n    /**\r\n     * Apply different validation rules based on another field's value (global scope)\r\n     *\r\n     * Use this when you need to apply completely different validators\r\n     * based on another field's value (not just required/optional).\r\n     *\r\n     * @param field - Field name to check (can be nested with dot notation)\r\n     * @param options - Validation options per field value\r\n     *\r\n     * @example\r\n     * ```ts\r\n     * // Different allowed values based on user type\r\n     * v.object({\r\n     *   userType: v.string().in(['admin', 'user']),\r\n     *   role: v.string().when('userType', {\r\n     *     is: {\r\n     *       admin: v.string().in(['super', 'moderator']),\r\n     *       user: v.string().in(['member', 'guest'])\r\n     *     },\r\n     *     otherwise: v.string().optional()\r\n     *   })\r\n     * })\r\n     *\r\n     * // Different validation rules based on type\r\n     * v.object({\r\n     *   contactType: v.string().in(['email', 'phone']),\r\n     *   contact: v.string().when('contactType', {\r\n     *     is: {\r\n     *       email: v.string().email(),\r\n     *       phone: v.string().pattern(/^\\d{10}$/)\r\n     *     }\r\n     *   })\r\n     * })\r\n     * ```\r\n     * @category Conditional Validation\r\n     */\r\n    when(field: string, options: Omit<WhenRuleOptions, \"field\" | \"scope\">): this;\r\n\r\n    /**\r\n     * Apply different validation rules based on sibling field's value\r\n     *\r\n     * Use this for nested objects where you need to check a field\r\n     * within the same parent object.\r\n     *\r\n     * @param siblingField - Sibling field name to check\r\n     * @param options - Validation options per field value\r\n     *\r\n     * @example\r\n     * ```ts\r\n     * // Array of users with role-based permissions\r\n     * v.array(v.object({\r\n     *   userType: v.string().in(['admin', 'user']),\r\n     *   permissions: v.string().whenSibling('userType', {\r\n     *     is: {\r\n     *       admin: v.string().in(['read', 'write', 'delete']),\r\n     *       user: v.string().in(['read'])\r\n     *     }\r\n     *   })\r\n     * }))\r\n     * ```\r\n     * @category Conditional Validation\r\n     */\r\n    whenSibling(siblingField: string, options: Omit<WhenRuleOptions, \"field\" | \"scope\">): this;\r\n  }\r\n}\r\n\r\n/**\r\n * Value must be equal to the given value\r\n */\r\nBaseValidator.prototype.equal = function (value: any, errorMessage?: string) {\r\n  return this.addRule(equalRule, errorMessage, { value });\r\n};\r\n\r\n/**\r\n * Value must be the same as another field's value\r\n */\r\nBaseValidator.prototype.sameAs = function (field: string, errorMessage?: string) {\r\n  return this.addRule(equalsFieldRule, errorMessage, {\r\n    field,\r\n    scope: \"global\",\r\n  });\r\n};\r\n\r\n/**\r\n * Value must be the same as another sibling field's value\r\n */\r\nBaseValidator.prototype.sameAsSibling = function (field: string, errorMessage?: string) {\r\n  return this.addRule(equalsFieldRule, errorMessage, {\r\n    field,\r\n    scope: \"sibling\",\r\n  });\r\n};\r\n\r\n/**\r\n * Value must be different from another field's value\r\n */\r\nBaseValidator.prototype.differentFrom = function (field: string, errorMessage?: string) {\r\n  return this.addRule(notEqualsFieldRule, errorMessage, {\r\n    field,\r\n    scope: \"global\",\r\n  });\r\n};\r\n\r\n/**\r\n * Value must be different from another sibling field's value\r\n */\r\nBaseValidator.prototype.differentFromSibling = function (field: string, errorMessage?: string) {\r\n  return this.addRule(notEqualsFieldRule, errorMessage, {\r\n    field,\r\n    scope: \"sibling\",\r\n  });\r\n};\r\n\r\n/**\r\n * Apply different validation rules based on another field's value (global scope)\r\n *\r\n * Use this when you need to apply completely different validators\r\n * based on another field's value (not just required/optional).\r\n *\r\n * @param field - Field name to check (can be nested with dot notation)\r\n * @param options - Validation options per field value\r\n *\r\n * @example\r\n * ```ts\r\n * // Different allowed values based on user type\r\n * v.object({\r\n *   userType: v.string().in(['admin', 'user']),\r\n *   role: v.string().when('userType', {\r\n *     is: {\r\n *       admin: v.string().in(['super', 'moderator']),\r\n *       user: v.string().in(['member', 'guest'])\r\n *     },\r\n *     otherwise: v.string().optional()\r\n *   })\r\n * })\r\n *\r\n * // Different validation rules based on type\r\n * v.object({\r\n *   contactType: v.string().in(['email', 'phone']),\r\n *   contact: v.string().when('contactType', {\r\n *     is: {\r\n *       email: v.string().email(),\r\n *       phone: v.string().pattern(/^\\d{10}$/)\r\n *     }\r\n *   })\r\n * })\r\n * ```\r\n * @category Conditional Validation\r\n */\r\nBaseValidator.prototype.when = function (\r\n  field: string,\r\n  options: Omit<WhenRuleOptions, \"field\" | \"scope\">,\r\n) {\r\n  return this.addRule(whenRule, undefined, {\r\n    field,\r\n    is: options.is,\r\n    otherwise: options.otherwise,\r\n    scope: \"global\",\r\n  });\r\n};\r\n\r\n/**\r\n * Apply different validation rules based on sibling field's value\r\n *\r\n * Use this for nested objects where you need to check a field\r\n * within the same parent object.\r\n *\r\n * @param siblingField - Sibling field name to check\r\n * @param options - Validation options per field value\r\n *\r\n * @example\r\n * ```ts\r\n * // Array of users with role-based permissions\r\n * v.array(v.object({\r\n *   userType: v.string().in(['admin', 'user']),\r\n *   permissions: v.string().whenSibling('userType', {\r\n *     is: {\r\n *       admin: v.string().in(['read', 'write', 'delete']),\r\n *       user: v.string().in(['read'])\r\n *     }\r\n *   })\r\n * }))\r\n * ```\r\n * @category Conditional Validation\r\n */\r\nBaseValidator.prototype.whenSibling = function (\r\n  siblingField: string,\r\n  options: Omit<WhenRuleOptions, \"field\" | \"scope\">,\r\n) {\r\n  return this.addRule(whenRule, undefined, {\r\n    field: siblingField,\r\n    is: options.is,\r\n    otherwise: options.otherwise,\r\n    scope: \"sibling\",\r\n  });\r\n};\r\n"],"mappings":";;;;;;;;;;AA4GA,cAAc,UAAU,QAAQ,SAAU,OAAY,cAAuB;CAC3E,OAAO,KAAK,QAAQ,WAAW,cAAc,EAAE,MAAM,CAAC;AACxD;;;;AAKA,cAAc,UAAU,SAAS,SAAU,OAAe,cAAuB;CAC/E,OAAO,KAAK,QAAQ,iBAAiB,cAAc;EACjD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,gBAAgB,SAAU,OAAe,cAAuB;CACtF,OAAO,KAAK,QAAQ,iBAAiB,cAAc;EACjD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,gBAAgB,SAAU,OAAe,cAAuB;CACtF,OAAO,KAAK,QAAQ,oBAAoB,cAAc;EACpD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,uBAAuB,SAAU,OAAe,cAAuB;CAC7F,OAAO,KAAK,QAAQ,oBAAoB,cAAc;EACpD;EACA,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,cAAc,UAAU,OAAO,SAC7B,OACA,SACA;CACA,OAAO,KAAK,QAAQ,UAAU,QAAW;EACvC;EACA,IAAI,QAAQ;EACZ,WAAW,QAAQ;EACnB,OAAO;CACT,CAAC;AACH;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,cAAc,UAAU,cAAc,SACpC,cACA,SACA;CACA,OAAO,KAAK,QAAQ,UAAU,QAAW;EACvC,OAAO;EACP,IAAI,QAAQ;EACZ,WAAW,QAAQ;EACnB,OAAO;CACT,CAAC;AACH"}

package/esm/seal/src/validators/methods/forbidden-methods.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"forbidden-methods.mjs","names":[],"sources":["../../../../../../../../../../seal/src/validators/methods/forbidden-methods.ts"],"sourcesContent":["import {\r\n  forbiddenIfEmptyRule,\r\n  forbiddenIfInRule,\r\n  forbiddenIfNotEmptyRule,\r\n  forbiddenIfNotInRule,\r\n  forbiddenIfNotRule,\r\n  forbiddenIfRule,\r\n} from \"../../rules/conditional/forbidden-if-rules\";\r\nimport { forbiddenRule } from \"../../rules/core/forbidden\";\r\nimport { BaseValidator } from \"../base-validator\";\r\n\r\n/**\r\n * Marker re-exported by the validators barrel so the dts bundler keeps this\r\n * module (and its `declare module` augmentation) in the bundled `.d.ts`.\r\n */\r\nexport const forbiddenMethodsApplied = true;\r\n\r\ndeclare module \"../base-validator\" {\r\n  interface BaseValidator {\r\n    /**\r\n     * Value is forbidden to be present\r\n     */\r\n    forbidden(errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value is forbidden if another field equals a specific value (global scope)\r\n     */\r\n    forbiddenIf(field: string, value: any, errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value is forbidden if another field equals a specific value (sibling scope)\r\n     */\r\n    forbiddenIfSibling(field: string, value: any, errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value is forbidden if another field does NOT equal a specific value (global scope)\r\n     */\r\n    forbiddenIfNot(field: string, value: any, errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value is forbidden if another field does NOT equal a specific value (sibling scope)\r\n     */\r\n    forbiddenIfNotSibling(field: string, value: any, errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value is forbidden if another field is empty (global scope)\r\n     */\r\n    forbiddenIfEmpty(field: string, errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value is forbidden if another field is empty (sibling scope)\r\n     */\r\n    forbiddenIfEmptySibling(field: string, errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value is forbidden if another field is not empty (global scope)\r\n     */\r\n    forbiddenIfNotEmpty(field: string, errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value is forbidden if another field is not empty (sibling scope)\r\n     */\r\n    forbiddenIfNotEmptySibling(field: string, errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value is forbidden if another field's value is in the given array (global scope)\r\n     */\r\n    forbiddenIfIn(field: string, values: any[], errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value is forbidden if another field's value is in the given array (sibling scope)\r\n     */\r\n    forbiddenIfInSibling(field: string, values: any[], errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value is forbidden if another field's value is NOT in the given array (global scope)\r\n     */\r\n    forbiddenIfNotIn(field: string, values: any[], errorMessage?: string): this;\r\n\r\n    /**\r\n     * Value is forbidden if another field's value is NOT in the given array (sibling scope)\r\n     */\r\n    forbiddenIfNotInSibling(field: string, values: any[], errorMessage?: string): this;\r\n  }\r\n}\r\n\r\n/**\r\n * Value is forbidden to be present\r\n */\r\nBaseValidator.prototype.forbidden = function (errorMessage?: string) {\r\n  return this.addRule(forbiddenRule, errorMessage);\r\n};\r\n\r\n/**\r\n * Value is forbidden if another field equals a specific value (global scope)\r\n */\r\nBaseValidator.prototype.forbiddenIf = function (field: string, value: any, errorMessage?: string) {\r\n  return this.addRule(forbiddenIfRule, errorMessage, {\r\n    field,\r\n    value,\r\n    scope: \"global\",\r\n  });\r\n};\r\n\r\n/**\r\n * Value is forbidden if another field equals a specific value (sibling scope)\r\n */\r\nBaseValidator.prototype.forbiddenIfSibling = function (\r\n  field: string,\r\n  value: any,\r\n  errorMessage?: string,\r\n) {\r\n  return this.addRule(forbiddenIfRule, errorMessage, {\r\n    field,\r\n    value,\r\n    scope: \"sibling\",\r\n  });\r\n};\r\n\r\n/**\r\n * Value is forbidden if another field does NOT equal a specific value (global scope)\r\n */\r\nBaseValidator.prototype.forbiddenIfNot = function (\r\n  field: string,\r\n  value: any,\r\n  errorMessage?: string,\r\n) {\r\n  return this.addRule(forbiddenIfNotRule, errorMessage, {\r\n    field,\r\n    value,\r\n    scope: \"global\",\r\n  });\r\n};\r\n\r\n/**\r\n * Value is forbidden if another field does NOT equal a specific value (sibling scope)\r\n */\r\nBaseValidator.prototype.forbiddenIfNotSibling = function (\r\n  field: string,\r\n  value: any,\r\n  errorMessage?: string,\r\n) {\r\n  return this.addRule(forbiddenIfNotRule, errorMessage, {\r\n    field,\r\n    value,\r\n    scope: \"sibling\",\r\n  });\r\n};\r\n\r\n/**\r\n * Value is forbidden if another field is empty (global scope)\r\n */\r\nBaseValidator.prototype.forbiddenIfEmpty = function (field: string, errorMessage?: string) {\r\n  return this.addRule(forbiddenIfEmptyRule, errorMessage, {\r\n    field,\r\n    scope: \"global\",\r\n  });\r\n};\r\n\r\n/**\r\n * Value is forbidden if another field is empty (sibling scope)\r\n */\r\nBaseValidator.prototype.forbiddenIfEmptySibling = function (field: string, errorMessage?: string) {\r\n  return this.addRule(forbiddenIfEmptyRule, errorMessage, {\r\n    field,\r\n    scope: \"sibling\",\r\n  });\r\n};\r\n\r\n/**\r\n * Value is forbidden if another field is not empty (global scope)\r\n */\r\nBaseValidator.prototype.forbiddenIfNotEmpty = function (field: string, errorMessage?: string) {\r\n  return this.addRule(forbiddenIfNotEmptyRule, errorMessage, {\r\n    field,\r\n    scope: \"global\",\r\n  });\r\n};\r\n\r\n/**\r\n * Value is forbidden if another field is not empty (sibling scope)\r\n */\r\nBaseValidator.prototype.forbiddenIfNotEmptySibling = function (\r\n  field: string,\r\n  errorMessage?: string,\r\n) {\r\n  return this.addRule(forbiddenIfNotEmptyRule, errorMessage, {\r\n    field,\r\n    scope: \"sibling\",\r\n  });\r\n};\r\n\r\n/**\r\n * Value is forbidden if another field's value is in the given array (global scope)\r\n */\r\nBaseValidator.prototype.forbiddenIfIn = function (\r\n  field: string,\r\n  values: any[],\r\n  errorMessage?: string,\r\n) {\r\n  return this.addRule(forbiddenIfInRule, errorMessage, {\r\n    field,\r\n    values,\r\n    scope: \"global\",\r\n  });\r\n};\r\n\r\n/**\r\n * Value is forbidden if another field's value is in the given array (sibling scope)\r\n */\r\nBaseValidator.prototype.forbiddenIfInSibling = function (\r\n  field: string,\r\n  values: any[],\r\n  errorMessage?: string,\r\n) {\r\n  return this.addRule(forbiddenIfInRule, errorMessage, {\r\n    field,\r\n    values,\r\n    scope: \"sibling\",\r\n  });\r\n};\r\n\r\n/**\r\n * Value is forbidden if another field's value is NOT in the given array (global scope)\r\n */\r\nBaseValidator.prototype.forbiddenIfNotIn = function (\r\n  field: string,\r\n  values: any[],\r\n  errorMessage?: string,\r\n) {\r\n  return this.addRule(forbiddenIfNotInRule, errorMessage, {\r\n    field,\r\n    values,\r\n    scope: \"global\",\r\n  });\r\n};\r\n\r\n/**\r\n * Value is forbidden if another field's value is NOT in the given array (sibling scope)\r\n */\r\nBaseValidator.prototype.forbiddenIfNotInSibling = function (\r\n  field: string,\r\n  values: any[],\r\n  errorMessage?: string,\r\n) {\r\n  return this.addRule(forbiddenIfNotInRule, errorMessage, {\r\n    field,\r\n    values,\r\n    scope: \"sibling\",\r\n  });\r\n};\r\n"],"mappings":";;;;;;;;AAyFA,cAAc,UAAU,YAAY,SAAU,cAAuB;CACnE,OAAO,KAAK,QAAQ,eAAe,YAAY;AACjD;;;;AAKA,cAAc,UAAU,cAAc,SAAU,OAAe,OAAY,cAAuB;CAChG,OAAO,KAAK,QAAQ,iBAAiB,cAAc;EACjD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,qBAAqB,SAC3C,OACA,OACA,cACA;CACA,OAAO,KAAK,QAAQ,iBAAiB,cAAc;EACjD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,iBAAiB,SACvC,OACA,OACA,cACA;CACA,OAAO,KAAK,QAAQ,oBAAoB,cAAc;EACpD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,wBAAwB,SAC9C,OACA,OACA,cACA;CACA,OAAO,KAAK,QAAQ,oBAAoB,cAAc;EACpD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,mBAAmB,SAAU,OAAe,cAAuB;CACzF,OAAO,KAAK,QAAQ,sBAAsB,cAAc;EACtD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,0BAA0B,SAAU,OAAe,cAAuB;CAChG,OAAO,KAAK,QAAQ,sBAAsB,cAAc;EACtD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,sBAAsB,SAAU,OAAe,cAAuB;CAC5F,OAAO,KAAK,QAAQ,yBAAyB,cAAc;EACzD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,6BAA6B,SACnD,OACA,cACA;CACA,OAAO,KAAK,QAAQ,yBAAyB,cAAc;EACzD;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,gBAAgB,SACtC,OACA,QACA,cACA;CACA,OAAO,KAAK,QAAQ,mBAAmB,cAAc;EACnD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,uBAAuB,SAC7C,OACA,QACA,cACA;CACA,OAAO,KAAK,QAAQ,mBAAmB,cAAc;EACnD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,mBAAmB,SACzC,OACA,QACA,cACA;CACA,OAAO,KAAK,QAAQ,sBAAsB,cAAc;EACtD;EACA;EACA,OAAO;CACT,CAAC;AACH;;;;AAKA,cAAc,UAAU,0BAA0B,SAChD,OACA,QACA,cACA;CACA,OAAO,KAAK,QAAQ,sBAAsB,cAAc;EACtD;EACA;EACA,OAAO;CACT,CAAC;AACH"}