n4s 6.1.12 → 6.2.0

package/dist/n4s-CoDF5Fg6.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"n4s-CoDF5Fg6.cjs","names":["ctx","equals","booleanRules.isBoolean","greaterThan","greaterThanOrEquals","lessThan","lessThanOrEquals","notEquals","isNotBlank","gte","lt","lte","gte","min","lte","max","isNotBetween","min","max","greaterThan","equals","parsedArray: any[]","lastRes: RuleRunReturn<any> | undefined","passingTransformedType: any","output: Record<string, any>","filtered: Record<string, any>","parsedValue: Record<string, any>","parsedEntries: Record<string, any>","arrayRules","booleanRules","commonComparison","commonContainer","commonLength","generalRules","nullishRules","numberRules","objectRules","stringRules","compoundRules","schemaRules","customRules: Record<string, (...args: any[]) => any>","customMessage: Maybe<string>","proxy: EagerReturn<T>","CHAIN_PREPEND: unique symbol","lazyRegistry: Record<string, (...args: any[]) => Predicate>","chain: Predicate[]","target: Partial<T>","lazyMessage: Maybe<LazyMessage>","prepend","validate: T['validate']","test: T['test']","parse: T['parse']","run: T['run']","proxy: T","max","min","arrayRules","numberRules","stringRules","booleanRules","schemaRules.omit","schemaRules.optional","schemaRules.partial","schemaRules.pick","schemaRules.shape","schemaRules.loose","arrayRules","schemaRules.isArrayOf","compoundRules","generalRules","objectRules","result: RuleRunReturn<T>","context"],"sources":["../src/enforceContext.ts","../src/rules/boolean/isBoolean.ts","../src/rules/boolean/isFalse.ts","../src/rules/boolean/isTrue.ts","../src/rules/general/equals.ts","../src/rules/general/isFalsy.ts","../src/rules/general/isTruthy.ts","../src/rules/booleanRules.ts","../src/ruleResult.ts","../src/eager/ruleCallGenerator.ts","../src/rules/array/includes.ts","../src/rules/array/isArrayRule.ts","../src/rules/commonComparison.ts","../src/rules/commonContainer.ts","../src/rules/commonLength.ts","../src/rules/general/isNotArray.ts","../src/rules/arrayRules.ts","../src/utils/RuleRunReturn.ts","../src/rules/compoundRules/allOf.ts","../src/rules/compoundRules/anyOf.ts","../src/rules/compoundRules/noneOf.ts","../src/rules/compoundRules/oneOf.ts","../src/rules/compoundRules/compoundRules.ts","../src/rules/general/condition.ts","../src/rules/general/notEquals.ts","../src/rules/general/isEmpty.ts","../src/rules/general/isNaN.ts","../src/rules/general/isNotBoolean.ts","../src/rules/general/isNotEmpty.ts","../src/rules/general/isNotNaN.ts","../src/rules/general/isNotNumber.ts","../src/rules/general/isNotNumeric.ts","../src/rules/general/isNotString.ts","../src/rules/general/isNotNull.ts","../src/rules/general/isNotUndefined.ts","../src/rules/general/isNotNullish.ts","../src/rules/general/isBlank.ts","../src/rules/generalRules.ts","../src/rules/nullish/isNull.ts","../src/rules/nullish/isUndefined.ts","../src/rules/nullish/isNullish.ts","../src/rules/nullishRules.ts","../src/rules/number/greaterThanOrEquals.ts","../src/rules/number/lessThan.ts","../src/rules/number/lessThanOrEquals.ts","../src/rules/number/isBetween.ts","../src/rules/number/isEven.ts","../src/rules/number/isNegative.ts","../src/rules/number/isNotBetween.ts","../src/rules/number/isNumber.ts","../src/rules/number/isOdd.ts","../src/rules/number/isPositive.ts","../src/rules/numeric/toNumber.ts","../src/rules/number/numberNotEquals.ts","../src/rules/numberRules.ts","../src/rules/numeric/isNumeric.ts","../src/rules/object/isKeyOf.ts","../src/rules/object/isValueOf.ts","../src/rules/objectRules.ts","../src/rules/schemaRules/isArrayOf.ts","../src/rules/schemaRules/schemaObjectUtils.ts","../src/rules/schemaRules/loose.ts","../src/rules/schemaRules/optional.ts","../src/rules/schemaRules/partial.ts","../src/rules/schemaRules/pick.ts","../src/rules/schemaRules/omit.ts","../src/rules/schemaRules/shape.ts","../src/rules/schemaRules/schemaRules.ts","../src/rules/string/endsWith.ts","../src/rules/string/doesNotEndWith.ts","../src/rules/string/startsWith.ts","../src/rules/string/doesNotStartWith.ts","../src/rules/string/isBlankString.ts","../src/rules/string/isNotBlank.ts","../src/rules/string/isString.ts","../src/utils/regex.ts","../src/rules/string/matches.ts","../src/rules/string/notMatches.ts","../src/rules/stringRules.ts","../src/eager/allRules.ts","../src/eager/ruleRegistry.ts","../src/eager.ts","../src/rules/chainBuilder/chainExecutor.ts","../src/rules/parsers/parserUtils.ts","../src/rules/chainBuilder/lazyRegistry.ts","../src/rules/chainBuilder/proxyHandlers.ts","../src/rules/chainBuilder/chainBuilder.ts","../src/rules/genRuleChain.ts","../src/extendLogic.ts","../src/lazy/ruleAdapter.ts","../src/rules/parsers/arrayParsers.ts","../src/rules/parsers/toBoolean.ts","../src/rules/parsers/generalParsers.ts","../src/rules/parsers/numberParsers.ts","../src/rules/parsers/stringParsers.ts","../src/lazy/typeRules.ts","../src/lazy.ts","../src/compose.ts","../src/n4s.ts"],"sourcesContent":["import { createCascade } from 'context';\nimport { assign, Nullable } from 'vest-utils';\n\n/**\n * Context API for accessing validation state during rule execution.\n * Provides access to the current value being validated, metadata, and parent context.\n * Used internally by rules to track nested validation (e.g., in shape, isArrayOf).\n *\n * @example\n * ```typescript\n * // Access context in custom rules\n * enforce.extend({\n *   customRule: (value: any) => {\n *     const context = enforce.context();\n *     console.log('Current value:', context?.value);\n *     console.log('Metadata:', context?.meta);\n *     return true;\n *   }\n * });\n *\n * // Context is automatically set in nested validations\n * enforce({ user: { name: 'John' } }).shape({\n *   user: enforce.shape({\n *     name: enforce.isString()\n *   })\n * });\n * // When validating 'name', context.parent() gives access to 'user' object\n * ```\n */\nexport const ctx = createCascade<CTXType>((ctxRef, parentContext): CTXType => {\n  const base = {\n    value: ctxRef.value,\n    meta: ctxRef.meta || {},\n  };\n\n  if (!parentContext) {\n    return assign(base, {\n      parent: emptyParent,\n    });\n  } else if (ctxRef.set) {\n    return assign(base, {\n      parent: (): EnforceContext => stripContext(parentContext),\n    });\n  }\n\n  return parentContext;\n});\n\nfunction stripContext(ctx: CTXType): EnforceContext {\n  return {\n    value: ctx.value,\n    meta: ctx.meta,\n    parent: ctx.parent,\n  };\n}\n\ntype CTXType = {\n  meta: Record<string, any>;\n  value: any;\n  set?: boolean;\n  parent: () => Nullable<CTXType>;\n};\n\nexport type EnforceContext = Nullable<{\n  meta: Record<string, any>;\n  value: any;\n  parent: () => EnforceContext;\n}>;\n\nfunction emptyParent(): null {\n  return null;\n}\n","import { isBoolean as isBooleanValue } from 'vest-utils';\n\n/**\n * Validates that a value is a boolean.\n * Type guard that narrows the type to boolean.\n *\n * @param value - Value to validate\n * @returns True if value is a boolean\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce(true).isBoolean(); // passes\n * enforce(false).isBoolean(); // passes\n * enforce(1).isBoolean(); // fails\n * enforce('true').isBoolean(); // fails\n *\n * // Lazy API\n * const boolRule = enforce.isBoolean();\n * boolRule.test(true); // true\n * boolRule.test(0); // false\n *\n * // Chains with boolean-specific rules\n * enforce(true).isBoolean().isTrue();\n * ```\n */\nexport function isBoolean(value: any): value is boolean {\n  return isBooleanValue(value);\n}\n","// Checks if value is strictly equal to false\nexport function isFalse(value: boolean): boolean {\n  return value === false;\n}\n","// Checks if value is strictly equal to true\nexport function isTrue(value: boolean): boolean {\n  return value === true;\n}\n","// Validates that two values are strictly equal (===)\nexport function equals<T>(value: T, v: T): boolean {\n  return value === v;\n}\n","// Validates that a value is falsy (false, 0, '', null, undefined, or NaN)\nexport function isFalsy(value: any): boolean {\n  return !value;\n}\n","// Validates that a value is truthy (not false, 0, '', null, undefined, or NaN)\nexport function isTruthy(value: any): boolean {\n  return !!value;\n}\n","import { type DropFirst } from 'vest-utils';\n\nimport { RuleInstance } from '../utils/RuleInstance';\n\nimport { isBoolean } from './boolean/isBoolean';\nimport { isFalse } from './boolean/isFalse';\nimport { isTrue } from './boolean/isTrue';\nimport { equals } from './general/equals';\nimport { isFalsy } from './general/isFalsy';\nimport { isTruthy } from './general/isTruthy';\n\nexport { equals, isFalsy, isFalse, isTrue, isTruthy, isBoolean };\n\nexport interface BooleanRuleInstance extends RuleInstance<boolean, [boolean]> {\n  isTrue(...args: DropFirst<Parameters<typeof isTrue>>): BooleanRuleInstance;\n  isFalse(...args: DropFirst<Parameters<typeof isFalse>>): BooleanRuleInstance;\n  isTruthy(\n    ...args: DropFirst<Parameters<typeof isTruthy>>\n  ): BooleanRuleInstance;\n  isFalsy(...args: DropFirst<Parameters<typeof isFalsy>>): BooleanRuleInstance;\n  equals(...args: DropFirst<Parameters<typeof equals>>): BooleanRuleInstance;\n  isBoolean(\n    ...args: DropFirst<Parameters<typeof isBoolean>>\n  ): BooleanRuleInstance;\n}\n","import { dynamicValue, invariant, isNullish, StringObject } from 'vest-utils';\nimport type { Stringable } from 'vest-utils';\n\nimport * as booleanRules from './rules/booleanRules';\n\nexport type RuleValue = unknown;\nexport type Args = any[];\nexport type RuleDetailedResult = {\n  pass: boolean;\n  message?: Stringable;\n  path?: string[];\n};\n\nexport function enforceMessage(\n  ruleName: string,\n  transformedResult: RuleDetailedResult,\n  value: RuleValue,\n  customMessage?: string,\n) {\n  if (!isNullish(customMessage)) return StringObject(customMessage);\n  if (isNullish(transformedResult.message)) {\n    return `enforce/${ruleName} failed with ${JSON.stringify(value)}`;\n  }\n  return StringObject(transformedResult.message);\n}\n\nexport function transformResult(\n  result: any,\n  ruleName: string,\n  value: RuleValue,\n  ...args: Args\n): RuleDetailedResult {\n  validateResult(result);\n\n  if (booleanRules.isBoolean(result)) {\n    return { pass: result };\n  }\n\n  return {\n    pass: !!result.pass,\n    message: dynamicValue(result.message, ruleName, value, ...args),\n    path: result.path,\n  };\n}\n\nexport function validateResult(result: any): void {\n  invariant(\n    booleanRules.isBoolean(result) ||\n      (result && booleanRules.isBoolean(result.pass)),\n    'Incorrect return value for rule: ' + JSON.stringify(result),\n  );\n}\n","import { invariant } from 'vest-utils';\n\nimport { ctx } from '../enforceContext';\nimport { enforceMessage, transformResult } from '../ruleResult';\n\nimport type { UnmodifiedRules, SchemaRules } from './ruleRegistry';\n\ntype RuleCallConfig = {\n  target: any;\n  rule: UnmodifiedRules | SchemaRules;\n  ruleName: string;\n  value: any;\n  customMessage: string | undefined;\n  clearMessage: () => void;\n};\n\nexport function createRuleCall(config: RuleCallConfig) {\n  const { target, rule, ruleName, value, customMessage, clearMessage } = config;\n\n  return function ruleCall(...args: any[]): any {\n    const transformedResult = ctx.run({ value }, () =>\n      transformResult(\n        (rule as (...args: any[]) => any)(value, ...args),\n        ruleName,\n        value,\n        ...args,\n      ),\n    );\n\n    invariant(\n      transformedResult.pass,\n      enforceMessage(ruleName, transformedResult, value, customMessage),\n    );\n\n    // Clear message after each rule - it only applies to the next rule\n    clearMessage();\n    target.pass = transformedResult.pass;\n\n    return target;\n  };\n}\n","// Checks if array contains the given item\nexport function includes<T>(arr: T[], item: T): boolean {\n  return Array.isArray(arr) && arr.includes(item);\n}\n","/**\n * Validates that a value is an array.\n * Type guard that narrows the type to any[].\n *\n * @param value - Value to validate\n * @returns True if value is an array\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce([1, 2, 3]).isArray(); // passes\n * enforce('hello').isArray(); // fails\n *\n * // Lazy API\n * const arrayRule = enforce.isArray();\n * arrayRule.test([1, 2]); // true\n * arrayRule.test({}); // false\n * ```\n */\nexport function isArray(value: any): value is any[] {\n  return Array.isArray(value);\n}\n","/**\n * Common comparison predicates that work across multiple types\n */\n\nexport function equals<T>(a: T, b: T): boolean {\n  return a === b;\n}\n\nexport function notEquals<T>(a: T, b: T): boolean {\n  return a !== b;\n}\n\nexport function greaterThan<T extends number | string>(a: T, b: T): boolean {\n  return a > b;\n}\n\nexport function greaterThanOrEquals<T extends number | string>(\n  a: T,\n  b: T,\n): boolean {\n  return a >= b;\n}\n\nexport function lessThan<T extends number | string>(a: T, b: T): boolean {\n  return a < b;\n}\n\nexport function lessThanOrEquals<T extends number | string>(\n  a: T,\n  b: T,\n): boolean {\n  return a <= b;\n}\n","/**\n * Common container predicates for arrays and strings\n */\n\nfunction isStringContainment(value: unknown, container: unknown): boolean {\n  return typeof container === 'string' && typeof value === 'string';\n}\n\nfunction checkAllItemsInSet<T>(items: T[], set: Set<T>): boolean {\n  for (const item of items) {\n    if (!set.has(item)) return false;\n  }\n  return true;\n}\n\nfunction checkAnyItemNotInSet<T>(items: T[], set: Set<T>): boolean {\n  for (const item of items) {\n    if (!set.has(item)) return true;\n  }\n  return false;\n}\n\nexport function inside<T>(value: T, container: T[] | string): boolean {\n  if (isStringContainment(value, container)) {\n    return (container as string).includes(value as string);\n  }\n\n  if (Array.isArray(container)) {\n    const set = new Set(container as T[]);\n    return Array.isArray(value)\n      ? checkAllItemsInSet(value, set)\n      : set.has(value as T);\n  }\n\n  return false;\n}\n\nexport function notInside<T>(value: T, container: any): boolean {\n  if (isStringContainment(value, container)) {\n    return !(container as string).includes(value as string);\n  }\n\n  if (Array.isArray(container)) {\n    const set = new Set(container as T[]);\n    return Array.isArray(value)\n      ? checkAnyItemNotInSet(value, set)\n      : !set.has(value as T);\n  }\n\n  return true;\n}\n","// Shared length-based predicates for strings and arrays.\n// Works on any value with a .length property.\n\ntype Lengthable = { length: number };\n\nexport function minLength(value: Lengthable, n: number): boolean {\n  return value.length >= n;\n}\n\nexport function maxLength(value: Lengthable, n: number): boolean {\n  return value.length <= n;\n}\n\nexport const min = minLength;\nexport const max = maxLength;\n\nexport function lengthEquals(value: Lengthable, n: number): boolean {\n  return value.length === n;\n}\n\nexport function lengthNotEquals(value: Lengthable, n: number): boolean {\n  return value.length !== n;\n}\n\nexport function longerThan(value: Lengthable, n: number): boolean {\n  return value.length > n;\n}\n\nexport function longerThanOrEquals(value: Lengthable, n: number): boolean {\n  return value.length >= n;\n}\n\nexport function shorterThan(value: Lengthable, n: number): boolean {\n  return value.length < n;\n}\n\nexport function shorterThanOrEquals(value: Lengthable, n: number): boolean {\n  return value.length <= n;\n}\n","/**\n * Validates that a value is not an array.\n * Inverse of isArray.\n *\n * @param value - Value to validate\n * @returns True if value is not an array\n *\n * @example\n * ```typescript\n * enforce({}).isNotArray(); // passes\n * enforce('hello').isNotArray(); // passes\n * enforce([1, 2, 3]).isNotArray(); // fails\n * ```\n */\nexport function isNotArray(value: any): boolean {\n  return !Array.isArray(value);\n}\n","import { isEmpty, isNotEmpty } from 'vest-utils';\n\nimport { BuildRuleInstance, ExtractRuleFunctions } from './RuleInstanceBuilder';\nimport { includes } from './array/includes';\nimport { isArray } from './array/isArrayRule';\nimport { equals, notEquals } from './commonComparison';\nimport { inside, notInside } from './commonContainer';\nimport {\n  lengthEquals,\n  lengthNotEquals,\n  longerThan,\n  longerThanOrEquals,\n  maxLength,\n  minLength,\n  shorterThan,\n  shorterThanOrEquals,\n} from './commonLength';\nimport { isNotArray } from './general/isNotArray';\n\nexport {\n  equals,\n  includes,\n  inside,\n  isArray,\n  isEmpty,\n  isNotArray,\n  isNotEmpty,\n  lengthEquals,\n  lengthNotEquals,\n  longerThan,\n  longerThanOrEquals,\n  maxLength,\n  minLength,\n  notEquals,\n  notInside,\n  shorterThan,\n  shorterThanOrEquals,\n};\n\nconst arrayRules = {\n  equals,\n  includes,\n  inside,\n  isEmpty,\n  isNotEmpty,\n  lengthEquals,\n  lengthNotEquals,\n  longerThan,\n  longerThanOrEquals,\n  maxLength,\n  minLength,\n  notEquals,\n  notInside,\n  shorterThan,\n  shorterThanOrEquals,\n} as const;\n\nexport type ArrayRuleInstance<T = any, TInput = T> = BuildRuleInstance<\n  T[],\n  [TInput[]],\n  ExtractRuleFunctions<typeof arrayRules>\n>;\n","import { isBoolean, Stringable, dynamicValue } from 'vest-utils';\n\n/**\n * Represents the result of a validation rule execution.\n * Contains the pass/fail status, the validated type, and an optional error message.\n *\n * @template T - The type of value that was validated\n *\n * @example\n * ```typescript\n * const result = RuleRunReturn.Passing('hello');\n * console.log(result.pass); // true\n * console.log(result.type); // 'hello'\n *\n * const failed = RuleRunReturn.Failing(123, 'Must be positive');\n * console.log(failed.pass); // false\n * console.log(failed.message); // 'Must be positive'\n * ```\n */\nexport class RuleRunReturn<T> {\n  /** Whether the validation passed */\n  pass: boolean;\n  /** The validated value's type */\n  type: T;\n  /** Optional error message if validation failed */\n  message?: string;\n  path?: string[];\n\n  constructor(pass: boolean, type: T, message?: string) {\n    this.pass = pass;\n    this.type = type;\n    this.message = message;\n  }\n\n  /**\n   * Creates a RuleRunReturn from a boolean or existing RuleRunReturn.\n   * Handles message resolution and type coercion.\n   *\n   * @param pass - Boolean indicating success, or existing RuleRunReturn\n   * @param type - The type of the validated value\n   * @param message - Optional error message (can be string or function)\n   * @returns A new RuleRunReturn instance\n   */\n  static create<T>(\n    pass: boolean | RuleRunReturn<T>,\n    type: T,\n    message?: Stringable,\n  ): RuleRunReturn<T> {\n    if (isBoolean(pass)) {\n      return new RuleRunReturn(!!pass, type, dynamicValue(message, type));\n    }\n    return RuleRunReturn.fromObject(pass, type, message);\n  }\n\n  // eslint-disable-next-line complexity\n  private static fromObject<T>(\n    pass: any,\n    type: T,\n    message?: Stringable,\n  ): RuleRunReturn<T> {\n    const hasValidObject = pass && isBoolean(pass.pass);\n\n    if (!hasValidObject) {\n      return new RuleRunReturn(false, type, dynamicValue(message, type));\n    }\n\n    const resolvedPass = !!pass.pass;\n\n    const successType = pass.type === undefined ? type : pass.type;\n    const failureType = type === undefined ? pass.type : type;\n    const resolvedType = (resolvedPass ? successType : failureType) as T;\n\n    const res = new RuleRunReturn(\n      resolvedPass,\n      resolvedType as T,\n      dynamicValue(message ?? pass.message, type),\n    );\n\n    res.path = pass.path;\n\n    return res;\n  }\n\n  /**\n   * Creates a passing RuleRunReturn.\n   *\n   * @param type - The validated value's type\n   * @param message - Optional success message\n   * @returns A RuleRunReturn with pass=true\n   *\n   * @example\n   * ```typescript\n   * const result = RuleRunReturn.Passing('valid');\n   * console.log(result.pass); // true\n   * ```\n   */\n  static Passing<T>(type: T, message?: Stringable): RuleRunReturn<T> {\n    return RuleRunReturn.create(true, type, message);\n  }\n\n  /**\n   * Creates a failing RuleRunReturn.\n   *\n   * @param type - The validated value's type\n   * @param message - Optional error message\n   * @returns A RuleRunReturn with pass=false\n   *\n   * @example\n   * ```typescript\n   * const result = RuleRunReturn.Failing(123, 'Number must be positive');\n   * console.log(result.pass); // false\n   * console.log(result.message); // 'Number must be positive'\n   * ```\n   */\n  static Failing<T>(type: T, message?: Stringable): RuleRunReturn<T> {\n    return RuleRunReturn.create(false, type, message);\n  }\n}\n","import { mapFirst } from 'vest-utils';\n\nimport { RuleInstance } from '../../utils/RuleInstance';\nimport { RuleRunReturn } from '../../utils/RuleRunReturn';\n\n/**\n * Validates that a value passes all of the provided rules.\n * All rules must pass for the validation to succeed.\n * Evaluation stops at the first failing rule.\n *\n * @template T - The value type to validate\n * @param value - The value to validate\n * @param rules - One or more RuleInstances that must all pass\n * @returns RuleRunReturn indicating success or failure\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce(25)\n *   .allOf(\n *     enforce.isNumber().greaterThan(18).lessThan(100)\n *   ); // passes (all rules pass)\n *\n * // Lazy API\n * const adultAgeRule = enforce.allOf(\n *   enforce.isNumber().greaterThanOrEquals(18).lessThan(150)\n * );\n *\n * adultAgeRule.test(25); // true\n * adultAgeRule.test(16); // false\n * adultAgeRule.test('25'); // false (not a number)\n * ```\n */\nexport function allOf<T>(value: T, ...rules: any[]): RuleRunReturn<T> {\n  return (\n    mapFirst(rules, (rule, breakout) => {\n      const res = rule.run(value);\n      breakout(!res.pass, res);\n    }) || RuleRunReturn.Passing(value)\n  );\n}\n\n// Type for allOf rule instance\nexport type AllOfRuleInstance<T> = RuleInstance<T, [T]>;\n","import { mapFirst } from 'vest-utils';\n\nimport { RuleInstance } from '../../utils/RuleInstance';\nimport { RuleRunReturn } from '../../utils/RuleRunReturn';\n\n/**\n * Validates that a value passes at least one of the provided rules.\n * At least one rule must pass for the validation to succeed.\n * Evaluation stops at the first passing rule.\n *\n * @template T - The value type to validate\n * @param value - The value to validate\n * @param rules - One or more RuleInstances where at least one must pass\n * @returns RuleRunReturn indicating success or failure\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce('hello')\n *   .anyOf(\n *     enforce.isNumber(),\n *     enforce.isString()\n *   ); // passes (string matches)\n *\n * // Lazy API - accept either format\n * const phoneOrEmailRule = enforce.anyOf(\n *   enforce.isString().matches(/^\\d{10}$/), // phone\n *   enforce.isString().matches(/@/) // email\n * );\n *\n * phoneOrEmailRule.test('1234567890'); // true\n * phoneOrEmailRule.test('user@example.com'); // true\n * phoneOrEmailRule.test('invalid'); // false\n * ```\n */\nexport function anyOf<T>(value: T, ...rules: any[]): RuleRunReturn<T> {\n  return (\n    mapFirst(rules, (rule, breakout) => {\n      const res = rule.run(value);\n      breakout(res.pass, res);\n    }) || RuleRunReturn.Failing(value)\n  );\n}\n\n// Type for anyOf rule instance\nexport type AnyOfRuleInstance<T> = RuleInstance<T, [T]>;\n","import { mapFirst } from 'vest-utils';\n\nimport { RuleInstance } from '../../utils/RuleInstance';\nimport { RuleRunReturn } from '../../utils/RuleRunReturn';\n\n/**\n * Validates that a value passes none of the provided rules.\n * All rules must fail for the validation to succeed.\n * Evaluation stops at the first passing rule.\n *\n * @template T - The value type to validate\n * @param value - The value to validate\n * @param rules - One or more RuleInstances that must all fail\n * @returns RuleRunReturn indicating success or failure\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce(0)\n *   .noneOf(\n *     enforce.greaterThan(0),\n *     enforce.lessThan(0)\n *   ); // passes (neither rule passes)\n *\n * // Lazy API - exclude reserved usernames\n * const notReservedRule = enforce.noneOf(\n *   enforce.equals('admin'),\n *   enforce.equals('root'),\n *   enforce.equals('system')\n * );\n *\n * notReservedRule.test('john'); // true\n * notReservedRule.test('admin'); // false\n * notReservedRule.test('root'); // false\n * ```\n */\nexport function noneOf<T>(value: T, ...rules: any[]): RuleRunReturn<T> {\n  return (\n    mapFirst(rules, (rule, breakout) => {\n      const res = rule.run(value);\n      breakout(res.pass, RuleRunReturn.Failing(value));\n    }) || RuleRunReturn.Passing(value)\n  );\n}\n\n// Type for noneOf rule instance\nexport type NoneOfRuleInstance<T> = RuleInstance<T, [T]>;\n","import { greaterThan } from 'vest-utils';\n\nimport { RuleInstance } from '../../utils/RuleInstance';\nimport { RuleRunReturn } from '../../utils/RuleRunReturn';\n\nconst REQUIRED_COUNT = 1;\n\n/**\n * Validates that a value passes exactly one of the provided rules.\n * Exactly one rule must pass - not zero, not two or more.\n * All rules are evaluated to count passing rules.\n *\n * @template T - The value type to validate\n * @param value - The value to validate\n * @param rules - One or more RuleInstances where exactly one must pass\n * @returns RuleRunReturn indicating success or failure\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce(5)\n *   .oneOf(\n *     enforce.lessThan(10),\n *     enforce.greaterThan(100)\n *   ); // passes (only first rule passes)\n *\n * // Lazy API - accept either type but not both\n * const stringOrNumberRule = enforce.oneOf(\n *   enforce.isString(),\n *   enforce.isNumber()\n * );\n *\n * stringOrNumberRule.test('hello'); // true\n * stringOrNumberRule.test(42); // true\n * stringOrNumberRule.test(true); // false (no rules pass)\n *\n * // More complex example - exclusive validation\n * const exclusiveRule = enforce.oneOf(\n *   enforce.equals(null),\n *   enforce.isString().longerThan(0)\n * );\n *\n * exclusiveRule.test(null); // true (exactly one passes)\n * exclusiveRule.test('hello'); // true (exactly one passes)\n * exclusiveRule.test(''); // false (neither passes)\n * ```\n */\nexport function oneOf<T>(value: T, ...rules: any[]): RuleRunReturn<T> {\n  let passingCount = 0;\n  rules.some(rule => {\n    const res = rule.run(value);\n\n    if (res.pass) {\n      passingCount++;\n    }\n\n    if (greaterThan(passingCount, REQUIRED_COUNT)) {\n      return RuleRunReturn.Failing(value);\n    }\n  });\n\n  return RuleRunReturn.create(passingCount === REQUIRED_COUNT, value);\n}\n\n// Type for oneOf rule instance\nexport type OneOfRuleInstance<T> = RuleInstance<T, [T]>;\n","import './compoundRulesTypes';\n\nexport { allOf, type AllOfRuleInstance } from './allOf';\nexport { anyOf, type AnyOfRuleInstance } from './anyOf';\nexport { noneOf, type NoneOfRuleInstance } from './noneOf';\nexport { oneOf, type OneOfRuleInstance } from './oneOf';\nexport type { CompoundRuleLazyTypes } from './compoundRulesTypes';\n","// Runs custom validation function, returns false if callback throws\nexport function condition(\n  value: any,\n  callback: (value: any) => boolean,\n): boolean {\n  try {\n    return callback(value);\n  } catch {\n    return false;\n  }\n}\n","// Validates that two values are not strictly equal (!==)\nexport function notEquals<T>(value: T, v: T): boolean {\n  return value !== v;\n}\n","import { isEmpty as isEmptyValue } from 'vest-utils';\n\n// Validates that a value is empty (empty string, array, object, null, or undefined)\nexport function isEmpty(value: any): boolean {\n  return isEmptyValue(value);\n}\n","import { toNumber } from 'vest-utils';\n\nimport { RuleInstance } from '../../utils/RuleInstance';\n\nexport interface NaNRuleInstance extends RuleInstance<number | string, [any]> {}\n\n// Validates that a value is NaN (Not a Number)\nexport function isNaN(value: number | string): boolean {\n  return Number.isNaN(toNumber(value).unwrapOr(NaN));\n}\n","/**\n * Validates that a value is not a boolean.\n * Inverse of isBoolean.\n *\n * @param value - Value to validate\n * @returns True if value is not a boolean\n *\n * @example\n * ```typescript\n * enforce(1).isNotBoolean(); // passes\n * enforce('true').isNotBoolean(); // passes\n * enforce(true).isNotBoolean(); // fails\n * enforce(false).isNotBoolean(); // fails\n * ```\n */\nexport function isNotBoolean(value: any): boolean {\n  return typeof value !== 'boolean';\n}\n","import { isNotEmpty as isNotEmptyValue } from 'vest-utils';\n\n// Checks if value is not empty (not null, undefined, empty string, empty array, or empty object)\nexport function isNotEmpty(value: any): boolean {\n  return isNotEmptyValue(value);\n}\n","import { toNumber } from 'vest-utils';\n\n// Validates that a value is not NaN\nexport function isNotNaN(value: any): boolean {\n  return !Number.isNaN(toNumber(value).unwrapOr(value));\n}\n","/**\n * Validates that a value is not a number (or is NaN).\n * Inverse of isNumber. Considers NaN as not a number.\n *\n * @param value - Value to validate\n * @returns True if value is not a number or is NaN\n *\n * @example\n * ```typescript\n * enforce('123').isNotNumber(); // passes\n * enforce(NaN).isNotNumber(); // passes\n * enforce(true).isNotNumber(); // passes\n * enforce(42).isNotNumber(); // fails\n * ```\n */\nexport function isNotNumber(value: any): boolean {\n  return typeof value !== 'number' || Number.isNaN(value);\n}\n","import { isNumeric as isNumericValue } from 'vest-utils';\n\n/**\n * Validates that a value is not numeric (not a number or numeric string).\n * Inverse of isNumeric.\n *\n * @param value - Value to validate\n * @returns True if value is not numeric\n *\n * @example\n * ```typescript\n * enforce('hello').isNotNumeric(); // passes\n * enforce(true).isNotNumeric(); // passes\n * enforce(NaN).isNotNumeric(); // passes\n * enforce(42).isNotNumeric(); // fails\n * enforce('42').isNotNumeric(); // fails\n * ```\n */\nexport function isNotNumeric(value: any): boolean {\n  // Accept numbers (including Infinity) and numeric strings as numeric\n  if (typeof value === 'number') {\n    // Only NaN is not numeric among numbers\n    return Number.isNaN(value);\n  }\n  // For strings, use the vest-utils isNumeric which excludes Infinity strings\n  return !isNumericValue(value);\n}\n","/**\n * Validates that a value is not a string.\n * Inverse of isString.\n *\n * @param value - Value to validate\n * @returns True if value is not a string\n *\n * @example\n * ```typescript\n * enforce(123).isNotString(); // passes\n * enforce([]).isNotString(); // passes\n * enforce('hello').isNotString(); // fails\n * ```\n */\nexport function isNotString(value: any): boolean {\n  return typeof value !== 'string';\n}\n","import { isNotNull as isNotNullValue } from 'vest-utils';\n\n/**\n * Validates that a value is not null.\n * Inverse of isNull. Note: undefined passes this check.\n *\n * @param value - Value to validate\n * @returns True if value is not null\n *\n * @example\n * ```typescript\n * enforce(undefined).isNotNull(); // passes\n * enforce(0).isNotNull(); // passes\n * enforce('').isNotNull(); // passes\n * enforce(null).isNotNull(); // fails\n * ```\n */\nexport function isNotNull(value: any): boolean {\n  return isNotNullValue(value);\n}\n","import { isNotUndefined as isNotUndefinedValue } from 'vest-utils';\n\n/**\n * Validates that a value is not undefined.\n * Inverse of isUndefined. Note: null passes this check.\n *\n * @param value - Value to validate\n * @returns True if value is not undefined\n *\n * @example\n * ```typescript\n * enforce(null).isNotUndefined(); // passes\n * enforce(0).isNotUndefined(); // passes\n * enforce('').isNotUndefined(); // passes\n * enforce(undefined).isNotUndefined(); // fails\n * ```\n */\nexport function isNotUndefined(value: any): boolean {\n  return isNotUndefinedValue(value);\n}\n","import { isNotNullish as isNotNullishValue } from 'vest-utils';\n\n/**\n * Validates that a value is not nullish (not null and not undefined).\n * Inverse of isNullish.\n *\n * @param value - Value to validate\n * @returns True if value is neither null nor undefined\n *\n * @example\n * ```typescript\n * enforce(0).isNotNullish(); // passes\n * enforce('').isNotNullish(); // passes\n * enforce(false).isNotNullish(); // passes\n * enforce(null).isNotNullish(); // fails\n * enforce(undefined).isNotNullish(); // fails\n * ```\n */\nexport function isNotNullish(value: any): boolean {\n  return isNotNullishValue(value);\n}\n","import { BlankValue, isNullish, isStringValue } from 'vest-utils';\n\nexport function isBlank(value: unknown): value is BlankValue {\n  return isNullish(value) || (isStringValue(value) && !value.trim());\n}\n\nexport function isNotBlank(value: unknown): boolean {\n  return !isBlank(value);\n}\n","import { RuleInstance } from '../utils/RuleInstance';\n\n// Common type for rules that accept any value\nexport interface AnyRuleInstance extends RuleInstance<any, [any]> {}\n\nexport { condition } from './general/condition';\nexport { equals } from './general/equals';\nexport { notEquals } from './general/notEquals';\nexport { isEmpty } from './general/isEmpty';\nexport { isFalsy } from './general/isFalsy';\nexport { isNaN } from './general/isNaN';\nexport type { NaNRuleInstance } from './general/isNaN';\nexport { isNotArray } from './general/isNotArray';\nexport { isNotBoolean } from './general/isNotBoolean';\nexport { isNotEmpty } from './general/isNotEmpty';\nexport { isNotNaN } from './general/isNotNaN';\nexport { isNotNumber } from './general/isNotNumber';\nexport { isNotNumeric } from './general/isNotNumeric';\nexport { isNotString } from './general/isNotString';\nexport { isTruthy } from './general/isTruthy';\nexport { isNotNull } from './general/isNotNull';\nexport { isNotUndefined } from './general/isNotUndefined';\nexport { isNotNullish } from './general/isNotNullish';\nexport { isBlank } from './general/isBlank';\nexport { isNotBlank } from './general/isBlank';\n","import { isNull as isNullValue } from 'vest-utils';\n\n/**\n * Validates that a value is null.\n * Type guard that narrows the type to null.\n *\n * @param value - Value to validate\n * @returns True if value is null\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce(null).isNull(); // passes\n * enforce(undefined).isNull(); // fails\n * enforce(0).isNull(); // fails\n *\n * // Lazy API\n * const nullRule = enforce.isNull();\n * nullRule.test(null); // true\n * nullRule.test(undefined); // false\n * ```\n */\nexport function isNull(value: any): value is null {\n  return isNullValue(value);\n}\n","import { isUndefined as isUndefinedValue } from 'vest-utils';\n\n/**\n * Validates that a value is undefined.\n * Type guard that narrows the type to undefined.\n *\n * @param value - Value to validate\n * @returns True if value is undefined\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce(undefined).isUndefined(); // passes\n * enforce(null).isUndefined(); // fails\n * enforce('').isUndefined(); // fails\n *\n * // Lazy API\n * const undefRule = enforce.isUndefined();\n * undefRule.test(undefined); // true\n * undefRule.test(null); // false\n *\n * // Useful for optional properties\n * const schema = enforce.shape({\n *   optional: enforce.optional(enforce.isString())\n * });\n * ```\n */\nexport function isUndefined(value: any): value is undefined {\n  return isUndefinedValue(value);\n}\n","import { isNullish as isNullishValue } from 'vest-utils';\n\n/**\n * Validates that a value is null or undefined (nullish).\n * Type guard that narrows the type to null | undefined.\n *\n * @param value - Value to validate\n * @returns True if value is null or undefined\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce(null).isNullish(); // passes\n * enforce(undefined).isNullish(); // passes\n * enforce(0).isNullish(); // fails\n * enforce('').isNullish(); // fails\n * enforce(false).isNullish(); // fails\n *\n * // Lazy API\n * const nullishRule = enforce.isNullish();\n * nullishRule.test(null); // true\n * nullishRule.test(undefined); // true\n * nullishRule.test(0); // false\n * ```\n */\nexport function isNullish(value: any): value is null | undefined {\n  return isNullishValue(value);\n}\n","import { RuleInstance } from '../utils/RuleInstance';\n\n// Backward-compatible re-exports to avoid breaking existing imports\nexport { isNull } from './nullish/isNull';\n\nexport { isUndefined } from './nullish/isUndefined';\n\nexport { isNullish } from './nullish/isNullish';\n\nexport interface NullRuleInstance extends RuleInstance<null, [null]> {}\n\nexport interface UndefinedRuleInstance extends RuleInstance<\n  undefined,\n  [undefined]\n> {}\n\nexport interface NullishRuleInstance extends RuleInstance<\n  null | undefined,\n  [null | undefined]\n> {}\n","import { greaterThan, numberEquals } from 'vest-utils';\n\n// Checks if numeric value is greater than or equal to the given threshold\nexport function greaterThanOrEquals(\n  value: string | number,\n  gte: string | number,\n): boolean {\n  return numberEquals(value, gte) || greaterThan(value, gte);\n}\n","import { isNumeric } from 'vest-utils';\n\n// Checks if numeric value is less than the given threshold\nexport function lessThan(value: string | number, lt: string | number): boolean {\n  return isNumeric(value) && isNumeric(lt) && Number(value) < Number(lt);\n}\n","import { numberEquals } from 'vest-utils';\n\nimport { lessThan } from './lessThan';\n\n// Checks if numeric value is less than or equal to the given threshold\nexport function lessThanOrEquals(\n  value: string | number,\n  lte: string | number,\n): boolean {\n  return numberEquals(value, lte) || lessThan(value, lte);\n}\n","import { bindNot } from 'vest-utils';\n\nimport { greaterThanOrEquals as gte } from './greaterThanOrEquals';\nimport { lessThanOrEquals as lte } from './lessThanOrEquals';\n\n// Checks if numeric value is within the given range (inclusive)\nexport function isBetween(\n  value: number | string,\n  min: number | string,\n  max: number | string,\n): boolean {\n  return gte(value, min) && lte(value, max);\n}\n\nexport const isNotBetween = bindNot(isBetween);\n","import { isNumeric, toNumber } from 'vest-utils';\n\n/**\n * Validates that a given value is an even number\n */\nexport const isEven = (value: string | number): boolean => {\n  if (isNumeric(value)) {\n    const asNumber = toNumber(value).unwrap();\n\n    if (asNumber !== null) {\n      return asNumber % 2 === 0;\n    }\n  }\n\n  return false;\n};\n","// Checks if number is less than zero\nexport function isNegative(value: number): boolean {\n  return value < 0;\n}\n","export function isNotBetween(value: number, min: number, max: number): boolean {\n  return value < min || value > max;\n}\n","/**\n * Validates that a value is a number (excluding NaN).\n * Type guard that narrows the type to number.\n *\n * @param value - Value to validate\n * @returns True if value is a number and not NaN\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce(42).isNumber(); // passes\n * enforce('42').isNumber(); // fails (string)\n * enforce(NaN).isNumber(); // fails (NaN is excluded)\n *\n * // Lazy API\n * const numberRule = enforce.isNumber();\n * numberRule.test(42); // true\n * numberRule.test(Infinity); // true\n * numberRule.test(NaN); // false\n *\n * // Chains with number-specific rules\n * enforce(25).isNumber().greaterThan(18);\n * ```\n */\nexport function isNumber(value: any): value is number {\n  return typeof value === 'number' && !Number.isNaN(value);\n}\n","import { isNumeric, toNumber } from 'vest-utils';\n\n/**\n * Validates that a given value is an odd number\n */\nexport const isOdd = (value: string | number): boolean => {\n  if (isNumeric(value)) {\n    const asNumber = toNumber(value).unwrap();\n    if (asNumber !== null) {\n      return asNumber % 2 !== 0;\n    }\n  }\n\n  return false;\n};\n","// Checks if number is greater than zero\nexport function isPositive(value: number): boolean {\n  return value > 0;\n}\n","import { isFailure, toNumber as toNumberValue } from 'vest-utils';\n\nimport { RuleRunReturn } from '../../utils/RuleRunReturn';\n\nexport function toNumber(value: unknown): RuleRunReturn<number> {\n  const result = toNumberValue(value);\n\n  if (isFailure(result)) {\n    return RuleRunReturn.Failing(NaN, result.error);\n  }\n\n  return RuleRunReturn.Passing(result.value);\n}\n","import { numberNotEquals as numberNotEqualsValue } from 'vest-utils';\n\n// Checks if numeric value is not equal to the given number (with tolerance for floating-point)\nexport function numberNotEquals(value: number, n: number | string): boolean {\n  return numberNotEqualsValue(value, n);\n}\n","import { greaterThan, numberEquals } from 'vest-utils';\n\nimport { BuildRuleInstance, ExtractRuleFunctions } from './RuleInstanceBuilder';\nimport { equals } from './general/equals';\nimport { isNaN } from './general/isNaN';\nimport { isNotNaN } from './general/isNotNaN';\nimport { greaterThanOrEquals } from './number/greaterThanOrEquals';\nimport { isBetween } from './number/isBetween';\nimport { isEven } from './number/isEven';\nimport { isNegative } from './number/isNegative';\nimport { isNotBetween } from './number/isNotBetween';\nimport { isNumber } from './number/isNumber';\nimport { isOdd } from './number/isOdd';\nimport { isPositive } from './number/isPositive';\nimport { lessThan } from './number/lessThan';\nimport { lessThanOrEquals } from './number/lessThanOrEquals';\nimport { toNumber } from './numeric/toNumber';\nimport { numberNotEquals } from './number/numberNotEquals';\n\nconst gt = greaterThan;\nconst gte = greaterThanOrEquals;\nconst lt = lessThan;\nconst lte = lessThanOrEquals;\nconst eq = equals;\nconst neq = numberNotEquals;\n\nconst aliases = {\n  eq,\n  gt,\n  gte,\n  lt,\n  lte,\n  neq,\n};\n\nexport {\n  gt,\n  gte,\n  lt,\n  lte,\n  eq,\n  neq,\n  equals,\n  greaterThan,\n  greaterThanOrEquals,\n  isBetween,\n  isEven,\n  isNaN,\n  isNegative,\n  isNotBetween,\n  isNotNaN,\n  isNumber,\n  isOdd,\n  isPositive,\n  lessThan,\n  lessThanOrEquals,\n  numberEquals,\n  numberNotEquals,\n  toNumber,\n};\n\nconst numberRules = {\n  ...aliases,\n  equals,\n  greaterThan,\n  greaterThanOrEquals,\n  isBetween,\n  isEven,\n  isNaN,\n  isNegative,\n  isNotBetween,\n  isNotNaN,\n  isNumber,\n  isOdd,\n  isPositive,\n  lessThan,\n  lessThanOrEquals,\n  numberEquals,\n  numberNotEquals,\n  toNumber,\n} as const;\n\nexport type NumberRuleInstance = BuildRuleInstance<\n  number,\n  [number],\n  ExtractRuleFunctions<typeof numberRules>\n>;\n\nexport type NumericRuleInstance = BuildRuleInstance<\n  string | number,\n  [string | number],\n  ExtractRuleFunctions<typeof numberRules>\n>;\n","import { isNumeric as isNumericValue } from 'vest-utils';\n\n/**\n * Validates that a value is numeric (a number or a numeric string).\n * Type guard that narrows the type to number | string.\n * Excludes NaN but includes Infinity and numeric strings.\n *\n * @param value - Value to validate\n * @returns True if value is a number or numeric string\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce(42).isNumeric(); // passes\n * enforce('42').isNumeric(); // passes (numeric string)\n * enforce('42.5').isNumeric(); // passes\n * enforce(Infinity).isNumeric(); // passes\n * enforce('hello').isNumeric(); // fails\n * enforce(NaN).isNumeric(); // fails\n *\n * // Lazy API\n * const numericRule = enforce.isNumeric();\n * numericRule.test(100); // true\n * numericRule.test('100'); // true\n * numericRule.test('abc'); // false\n *\n * // Chains with numeric comparison rules\n * enforce('25').isNumeric().greaterThan(18);\n * ```\n */\nexport function isNumeric(value: any): value is number | string {\n  // Accept numbers (including Infinity) and numeric strings\n  if (typeof value === 'number') {\n    return !Number.isNaN(value);\n  }\n  // For strings, use the vest-utils isNumeric which excludes Infinity strings\n  return isNumericValue(value);\n}\n","import { isObject, hasOwnProperty } from 'vest-utils';\n\n// Checks if value is a key that exists in the given object\nexport function isKeyOf(key: string | number | symbol, obj: object): boolean {\n  return isObject(obj) && hasOwnProperty(obj, key);\n}\n\n// Checks if value is not a key in the given object\nexport function isNotKeyOf(\n  key: string | number | symbol,\n  obj: object,\n): boolean {\n  return !isObject(obj) || !hasOwnProperty(obj, key);\n}\n","import { isObject } from 'vest-utils';\n\n// Checks if value exists in the given object's values\nexport function isValueOf<T = any>(value: T, obj: Record<string, T>): boolean {\n  return isObject(obj) && Object.values(obj).includes(value);\n}\n\n// Checks if value does not exist in the given object's values\nexport function isNotValueOf<T = any>(\n  value: T,\n  obj: Record<string, T>,\n): boolean {\n  return isObject(obj) && !Object.values(obj).includes(value);\n}\n","import { RuleInstance } from '../utils/RuleInstance';\n\nexport interface ObjectRuleInstance extends RuleInstance<object, [object]> {}\n\nexport interface KeyOfRuleInstance extends RuleInstance<\n  string | number | symbol,\n  [string | number | symbol]\n> {}\n\nexport interface ValueOfRuleInstance<T> extends RuleInstance<T, [T]> {}\n\nexport type ObjectRulesUnion =\n  | ObjectRuleInstance\n  | KeyOfRuleInstance\n  | ValueOfRuleInstance<any>;\n\nexport { isKeyOf, isNotKeyOf } from './object/isKeyOf';\n\nexport { isValueOf, isNotValueOf } from './object/isValueOf';\n","/* eslint-disable max-nested-callbacks */\nimport { lengthEquals, mapFirst } from 'vest-utils';\n\nimport { ctx } from '../../enforceContext';\nimport { transformResult } from '../../ruleResult';\nimport { RuleRunReturn } from '../../utils/RuleRunReturn';\n\n/**\n * Validates that a value is an array and all elements match at least one of the provided rules.\n * Each array element must pass at least one of the validation rules.\n *\n * @template T - The element type of the array\n * @param value - The array to validate\n * @param rules - One or more RuleInstances that elements should match\n * @returns RuleRunReturn indicating success or failure\n *\n * @example\n * ```typescript\n * // Eager API - array of strings\n * enforce(['a', 'b', 'c'])\n *   .isArrayOf(enforce.isString()); // passes\n *\n * enforce([1, 2, 'three'])\n *   .isArrayOf(enforce.isString()); // fails\n *\n * // Lazy API - array of numbers or strings\n * const mixedArrayRule = enforce.isArrayOf(\n *   enforce.isNumber(),\n *   enforce.isString()\n * );\n *\n * mixedArrayRule.test([1, 'two', 3, 'four']); // true\n * mixedArrayRule.test([1, 2, true]); // false (boolean not allowed)\n *\n * // Complex schema validation\n * const usersRule = enforce.isArrayOf(\n *   enforce.shape({\n *     name: enforce.isString(),\n *     age: enforce.isNumber()\n *   })\n * );\n *\n * usersRule.test([\n *   { name: 'John', age: 30 },\n *   { name: 'Jane', age: 25 }\n * ]); // true\n * ```\n */\n\nexport function isArrayOf<T>(value: T[], ...rules: any[]): RuleRunReturn<T[]> {\n  if (!Array.isArray(value)) {\n    return RuleRunReturn.Failing(value);\n  }\n\n  const parsedArray: any[] = [];\n\n  const failingResult = mapFirst(value, (item, breakout, index) => {\n    const res = ctx.run({ value: item, set: true, meta: { index } }, () => {\n      let lastRes: RuleRunReturn<any> | undefined;\n      let passingTransformedType: any = item;\n\n      // Try each rule with the item - any rule passing is OK\n      const anyPass = rules.some(rule => {\n        const rawResult = rule.run(item);\n        lastRes = rawResult;\n        const transformed = transformResult(rawResult, 'isArrayOf', item);\n        if (transformed.pass) {\n          passingTransformedType = rawResult.type ?? item;\n        }\n        return transformed.pass;\n      });\n\n      if (anyPass) {\n        parsedArray.push(passingTransformedType);\n        return RuleRunReturn.Passing(passingTransformedType);\n      }\n\n      // If failed and we have a single rule, return its failure (might contain nested path)\n      if (lengthEquals(rules, 1) && lastRes) {\n        return lastRes;\n      }\n\n      return RuleRunReturn.Failing(item);\n    });\n\n    if (!res.pass) {\n      const currentPath = res.path || [];\n      const newRes = { ...res, path: [index.toString(), ...currentPath] };\n      breakout(true, newRes);\n    }\n  });\n\n  return failingResult || RuleRunReturn.Passing(parsedArray as T[]);\n}\n\n// Type for isArrayOf rule instance - should chain array rules like isArray does\nexport type IsArrayOfRuleInstance<\n  T,\n  TInput = T,\n> = import('../arrayRules').ArrayRuleInstance<T, TInput>;\n","import { isObject, isUnsafeKey } from 'vest-utils';\n\n/**\n * Returns only own enumerable keys for object-like values.\n *\n * Prototype keys are never traversed which prevents inherited-key surprises.\n */\nexport function ownKeys(value: unknown): string[] {\n  if (!isObject(value)) {\n    return [];\n  }\n\n  return Object.keys(value as Record<string, unknown>);\n}\n\n/**\n * Returns the first dangerous own key if present; otherwise null.\n */\nexport function findDangerousOwnKey(value: unknown): string | null {\n  for (const key of ownKeys(value)) {\n    if (isUnsafeKey(key)) {\n      return key;\n    }\n  }\n\n  return null;\n}\n\n/**\n * Produces a plain shallow sanitized copy that includes only own enumerable keys\n * and excludes dangerous keys. Prototype and non-enumerable properties are not preserved.\n */\nexport function safeShallowCopy(\n  value: Record<string, any>,\n): Record<string, any> {\n  const output: Record<string, any> = {};\n\n  for (const key of ownKeys(value)) {\n    if (isUnsafeKey(key)) {\n      continue;\n    }\n\n    output[key] = value[key];\n  }\n\n  return output;\n}\n\n/**\n * Returns true if both value and schema are plain objects (not arrays).\n */\nexport function isValidSchemaInput(value: unknown, schema: unknown): boolean {\n  return (\n    isObject(value) &&\n    !Array.isArray(value) &&\n    isObject(schema) &&\n    !Array.isArray(schema)\n  );\n}\n\n/**\n * Checks if the value or the schema contain any inherently dangerous keys natively.\n */\nexport function checkDangerousKeys<T>(\n  value: T,\n  schema: Record<string, any>,\n): { pass: false; path: string[] } | null {\n  const dangerousSchemaKey = findDangerousOwnKey(schema);\n  if (dangerousSchemaKey) {\n    return { pass: false, path: [dangerousSchemaKey] };\n  }\n\n  const dangerousValueKey = findDangerousOwnKey(value);\n  if (dangerousValueKey) {\n    return { pass: false, path: [dangerousValueKey] };\n  }\n\n  return null;\n}\n\n/**\n * Filters schema keys using a predicate, returning a new schema\n * containing only the keys for which the predicate returns true.\n */\nexport function filterSchemaKeys(\n  schema: Record<string, any>,\n  predicate: (key: string) => boolean,\n): Record<string, any> {\n  const filtered: Record<string, any> = {};\n  if (!isObject(schema)) {\n    return filtered;\n  }\n  for (const key of ownKeys(schema)) {\n    if (predicate(key)) {\n      filtered[key] = schema[key];\n    }\n  }\n  return filtered;\n}\n","import { hasOwnProperty, isObject } from 'vest-utils';\n\nimport { ctx } from '../../enforceContext';\nimport type { RuleInstance } from '../../utils/RuleInstance';\nimport { RuleRunReturn } from '../../utils/RuleRunReturn';\n\nimport {\n  findDangerousOwnKey,\n  ownKeys,\n  safeShallowCopy,\n} from './schemaObjectUtils';\nimport type { Prettify } from './schemaRulesTypes';\nimport type { ShapeInputType, ShapeType } from './shape';\n\n/**\n * Validates that an object matches a schema loosely - all schema keys required, extra keys allowed.\n * Like shape() but permits additional properties not defined in the schema.\n *\n * @template T - The object type to validate\n * @param value - The object to validate\n * @param schema - Schema mapping keys to validation rules\n * @returns RuleRunReturn indicating success or failure\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce({ name: 'John', age: 30, extra: 'allowed' })\n *   .loose({\n *     name: enforce.isString(),\n *     age: enforce.isNumber()\n *   }); // passes (extra key is ok)\n *\n * // Lazy API\n * const partialUserSchema = enforce.loose({\n *   name: enforce.isString(),\n *   email: enforce.isString()\n * });\n *\n * // All schema keys must be present and valid\n * partialUserSchema.test({ name: 'Jane', email: 'jane@example.com' }); // true\n * partialUserSchema.test({ name: 'Jane', email: 'jane@example.com', age: 30 }); // true (extra ok)\n * partialUserSchema.test({ name: 'Jane' }); // false (missing email)\n * ```\n */\n// eslint-disable-next-line complexity\nexport function loose<T extends Record<string, any>>(\n  value: T,\n  schema: Record<string, any>,\n): RuleRunReturn<T> {\n  if (!isObject(value)) {\n    return RuleRunReturn.Failing(value);\n  }\n\n  const dangerousSchemaKey = findDangerousOwnKey(schema);\n  if (dangerousSchemaKey) {\n    return {\n      ...RuleRunReturn.Failing(value),\n      path: [dangerousSchemaKey],\n    };\n  }\n\n  const dangerousValueKey = findDangerousOwnKey(value);\n  if (dangerousValueKey) {\n    return {\n      ...RuleRunReturn.Failing(value),\n      path: [dangerousValueKey],\n    };\n  }\n\n  const parsedValue: Record<string, any> = safeShallowCopy(value);\n\n  for (const key of ownKeys(schema)) {\n    const fieldValue = hasOwnProperty(value, key) ? value[key] : undefined;\n    const res = ctx.run({ value: fieldValue, set: true, meta: { key } }, () =>\n      schema[key].run(fieldValue),\n    );\n    if (!res.pass) {\n      const currentPath = res.path || [];\n      const newRes = { ...res, path: [key, ...currentPath] };\n      return newRes as RuleRunReturn<T>;\n    }\n\n    parsedValue[key] = res.type;\n  }\n\n  return RuleRunReturn.Passing(parsedValue as T);\n}\n\n// Types colocated with loose rule\nexport type LooseRuleInstance<S extends Record<string, RuleInstance<any>>> =\n  RuleInstance<\n    Prettify<ShapeType<S> & Record<string, unknown>>,\n    [Prettify<ShapeInputType<S> & Record<string, unknown>>]\n  >;\n\nexport type LooseShapeValue<S extends Record<string, RuleInstance<any>>> =\n  Prettify<ShapeType<S> & Record<string, unknown>>;\n","import { isNullish } from 'vest-utils';\n\nimport { RuleInstance } from '../../utils/RuleInstance';\nimport { RuleRunReturn } from '../../utils/RuleRunReturn';\n\n/**\n * Makes a validation rule optional by allowing null or undefined values to pass.\n * If the value is null or undefined, validation passes without running the inner rule.\n * Otherwise, the inner rule is executed.\n *\n * @template T - The value type to validate\n * @param value - The value to validate (may be null/undefined)\n * @param rule - The RuleInstance to apply if value is not nullish\n * @returns RuleRunReturn indicating success or failure\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce(undefined).optional(enforce.isString()); // passes\n * enforce(null).optional(enforce.isString()); // passes\n * enforce('hello').optional(enforce.isString()); // passes\n * enforce(123).optional(enforce.isString()); // fails\n *\n * // Lazy API - useful in schemas\n * const userSchema = enforce.shape({\n *   name: enforce.isString(),\n *   middleName: enforce.optional(enforce.isString()),\n *   age: enforce.isNumber()\n * });\n *\n * userSchema.test({ name: 'John', age: 30 }); // true (middleName optional)\n * userSchema.test({ name: 'John', middleName: null, age: 30 }); // true\n * userSchema.test({ name: 'John', middleName: 'Q', age: 30 }); // true\n * userSchema.test({ name: 'John', middleName: 123, age: 30 }); // false\n * ```\n */\nexport function optional<T>(\n  value: T | undefined | null,\n  rule: any,\n): RuleRunReturn<T | undefined | null> {\n  if (isNullish(value)) {\n    return RuleRunReturn.Passing(value);\n  }\n  return rule.run(value);\n}\n\n// Type for optional rule instance\nexport type OptionalRuleInstance<T> = RuleInstance<\n  T | undefined | null,\n  [T | undefined | null]\n>;\n","import { hasOwnProperty, isObject } from 'vest-utils';\n\nimport { ctx } from '../../enforceContext';\nimport type { RuleInstance } from '../../utils/RuleInstance';\nimport { RuleRunReturn } from '../../utils/RuleRunReturn';\n\nimport {\n  findDangerousOwnKey,\n  ownKeys,\n  safeShallowCopy,\n} from './schemaObjectUtils';\nimport type { ShapeInputType, ShapeType } from './shape';\n\n/**\n * Checks if value has any keys not present in schema.\n */\nfunction getFirstExtraKey<T extends Record<string, any>>(\n  value: T,\n  schema: Record<string, any>,\n): string | null {\n  for (const key of ownKeys(value)) {\n    if (!hasOwnProperty(schema, key)) {\n      return key;\n    }\n  }\n\n  return null;\n}\n\n/**\n * Validates provided keys against their schema rules and returns parsed entries.\n *\n * Missing keys are allowed (partial validation).\n */\nfunction validateProvidedKeys<T extends Record<string, any>>(\n  value: T,\n  schema: Record<string, any>,\n): RuleRunReturn<T> | { parsedEntries: Record<string, any> } {\n  const parsedEntries: Record<string, any> = {};\n\n  for (const key of ownKeys(schema)) {\n    if (hasOwnProperty(value, key)) {\n      const fieldValue = value[key];\n      const res = ctx.run({ value: fieldValue, set: true, meta: { key } }, () =>\n        schema[key].run(fieldValue),\n      );\n      if (!res.pass) {\n        const currentPath = res.path || [];\n        return {\n          ...res,\n          path: [key, ...currentPath],\n        } as RuleRunReturn<T>;\n      }\n\n      parsedEntries[key] = res.type;\n    }\n  }\n\n  return { parsedEntries };\n}\n\n/**\n * partial(value, schema) validates that:\n * 1. value's keys are a subset of schema's keys (no extras)\n * 2. Zero or more keys may be present (empty object is allowed)\n * 3. For each provided key, the corresponding rule passes\n */\n/**\n * Validates that an object partially matches a schema - schema keys are optional, no extra keys allowed.\n * All provided keys must exist in schema and pass their validation rules.\n * Missing keys are allowed (making all fields optional).\n *\n * @template T - The object type to validate\n * @param value - The object to validate\n * @param schema - Schema mapping keys to validation rules\n * @returns RuleRunReturn indicating success or failure\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce({ name: 'John' })\n *   .partial({\n *     name: enforce.isString(),\n *     age: enforce.isNumber(),\n *     email: enforce.isString()\n *   }); // passes (age and email are optional)\n *\n * // Lazy API\n * const updateSchema = enforce.partial({\n *   name: enforce.isString(),\n *   email: enforce.isString().matches(/@/),\n *   age: enforce.isNumber()\n * });\n *\n * updateSchema.test({}); // true (all fields optional)\n * updateSchema.test({ name: 'Jane' }); // true (partial update)\n * updateSchema.test({ name: 'Jane', email: 'jane@example.com' }); // true\n * updateSchema.test({ name: 'Jane', extra: 'x' }); // false (extra key not in schema)\n * ```\n */\n// eslint-disable-next-line complexity\nexport function partial<T extends Record<string, any>>(\n  value: T,\n  schema: Record<string, any>,\n): RuleRunReturn<T> {\n  if (!isObject(value)) {\n    return RuleRunReturn.Failing(value);\n  }\n\n  const dangerousSchemaKey = findDangerousOwnKey(schema);\n  if (dangerousSchemaKey) {\n    return {\n      ...RuleRunReturn.Failing(value),\n      path: [dangerousSchemaKey],\n    };\n  }\n\n  const dangerousValueKey = findDangerousOwnKey(value);\n  if (dangerousValueKey) {\n    return {\n      ...RuleRunReturn.Failing(value),\n      path: [dangerousValueKey],\n    };\n  }\n\n  const extraKey = getFirstExtraKey(value, schema);\n  if (extraKey) {\n    return {\n      ...RuleRunReturn.Failing(value),\n      path: [extraKey],\n    };\n  }\n\n  const parsedValue = safeShallowCopy(value);\n  const parsedEntriesOrFailure = validateProvidedKeys(value, schema);\n  if ('pass' in parsedEntriesOrFailure) {\n    return parsedEntriesOrFailure;\n  }\n\n  return RuleRunReturn.Passing({\n    ...parsedValue,\n    ...parsedEntriesOrFailure.parsedEntries,\n  } as T);\n}\n\n// Types colocated with partial rule\nexport type PartialRuleInstance<S extends Record<string, RuleInstance<any>>> =\n  RuleInstance<Partial<ShapeType<S>>, [Partial<ShapeInputType<S>>]>;\n\nexport type PartialShapeValue<S extends Record<string, RuleInstance<any>>> =\n  Partial<ShapeType<S>>;\n","import { asArray } from 'vest-utils';\n\nimport type { RuleInstance } from '../../utils/RuleInstance';\nimport { RuleRunReturn } from '../../utils/RuleRunReturn';\nimport {\n  checkDangerousKeys,\n  filterSchemaKeys,\n  isValidSchemaInput,\n} from './schemaObjectUtils';\nimport { loose } from './loose';\nimport type { ShapeType, ShapeInputType } from './shape';\n\n/**\n * Validates that an object loosely matches a schema but only validates the specified keys.\n * Other keys in the object are ignored and no validation is applied to them.\n *\n * @template T - The object type to validate\n * @param value - The object to validate\n * @param schema - Schema mapping keys to validation rules\n * @param keysToPick - Array of keys that should be validated from the schema\n * @returns RuleRunReturn indicating success or failure\n */\nexport function pick<T extends Record<string, any>>(\n  value: T,\n  schema: Record<string, any>,\n  keysToPick: string[] | string,\n): RuleRunReturn<T> {\n  if (!isValidSchemaInput(value, schema)) {\n    return RuleRunReturn.Failing(value);\n  }\n\n  const pickKeys = new Set(asArray(keysToPick));\n\n  const dangerousKeyError = checkDangerousKeys(value, schema);\n  if (dangerousKeyError) {\n    return { ...RuleRunReturn.Failing(value), ...dangerousKeyError };\n  }\n\n  const pickedSchema = filterSchemaKeys(schema, key => pickKeys.has(key));\n\n  // Use `loose` so we only care about validating our picked subset of schema rules\n  // without failing if the object has extra unspecified fields.\n  const baseRes = loose(value, pickedSchema);\n  return baseRes.pass ? RuleRunReturn.Passing(baseRes.type as T) : baseRes;\n}\n\nexport type PickRuleInstance<S extends Record<string, RuleInstance<any>>> =\n  RuleInstance<ShapeType<S>, [ShapeInputType<S>]>;\n","import { asArray } from 'vest-utils';\n\nimport type { RuleInstance } from '../../utils/RuleInstance';\nimport { RuleRunReturn } from '../../utils/RuleRunReturn';\nimport {\n  checkDangerousKeys,\n  filterSchemaKeys,\n  isValidSchemaInput,\n} from './schemaObjectUtils';\nimport { loose } from './loose';\nimport type { ShapeType, ShapeInputType } from './shape';\n\n/**\n * Validates that an object loosely matches a schema but omits specified keys from validation.\n * The omitted keys in the object are ignored and no validation is applied to them.\n *\n * @template T - The object type to validate\n * @param value - The object to validate\n * @param schema - Schema mapping keys to validation rules\n * @param keysToOmit - Array of keys that should be omitted from schema validation\n * @returns RuleRunReturn indicating success or failure\n */\nexport function omit<T extends Record<string, any>>(\n  value: T,\n  schema: Record<string, any>,\n  keysToOmit: string[] | string,\n): RuleRunReturn<T> {\n  if (!isValidSchemaInput(value, schema)) {\n    return RuleRunReturn.Failing(value);\n  }\n\n  const omitKeys = new Set(asArray(keysToOmit));\n\n  const dangerousKeyError = checkDangerousKeys(value, schema);\n  if (dangerousKeyError) {\n    return { ...RuleRunReturn.Failing(value), ...dangerousKeyError };\n  }\n\n  const omittedSchema = filterSchemaKeys(schema, key => !omitKeys.has(key));\n\n  const baseRes = loose(value, omittedSchema);\n  return baseRes.pass ? RuleRunReturn.Passing(baseRes.type as T) : baseRes;\n}\n\nexport type OmitRuleInstance<S extends Record<string, RuleInstance<any>>> =\n  RuleInstance<ShapeType<S>, [ShapeInputType<S>]>;\n","import { hasOwnProperty } from 'vest-utils';\n\nimport type { RuleInstance } from '../../utils/RuleInstance';\nimport { RuleRunReturn } from '../../utils/RuleRunReturn';\n\nimport { loose } from './loose';\nimport { ownKeys } from './schemaObjectUtils';\n\n// Types colocated with shape rule\nimport type { InferShape, SchemaInfer, SchemaInput } from './schemaRulesTypes';\n\n/**\n * Validates that an object matches a schema exactly - all keys required, no extra keys allowed.\n * Each field value is validated against its corresponding RuleInstance in the schema.\n *\n * @template T - The object type to validate\n * @param value - The object to validate\n * @param schema - Schema mapping keys to validation rules\n * @returns RuleRunReturn indicating success or failure\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce({ name: 'John', age: 30 })\n *   .shape({\n *     name: enforce.isString(),\n *     age: enforce.isNumber().greaterThan(0)\n *   }); // passes\n *\n * // Lazy API\n * const userSchema = enforce.shape({\n *   name: enforce.isString(),\n *   email: enforce.isString().matches(/@/),\n *   age: enforce.isNumber().greaterThanOrEquals(18)\n * });\n *\n * userSchema.test({ name: 'Jane', email: 'jane@example.com', age: 25 }); // true\n * userSchema.test({ name: 'Jane', age: 25 }); // false (missing email)\n * userSchema.test({ name: 'Jane', email: 'jane@example.com', age: 25, extra: 'x' }); // false (extra key)\n * ```\n */\nexport function shape<T extends Record<string, any>>(\n  value: T,\n  schema: Record<string, any>,\n): RuleRunReturn<T> {\n  const baseRes = loose(value, schema);\n  if (!baseRes.pass) {\n    return baseRes;\n  }\n\n  for (const key of ownKeys(value)) {\n    if (!hasOwnProperty(schema, key)) {\n      const res = RuleRunReturn.Failing(value);\n      const newRes = { ...res, path: [key] };\n      return newRes;\n    }\n  }\n\n  return RuleRunReturn.Passing(baseRes.type);\n}\n\nexport type { InferShape, SchemaInfer };\n\nexport type ShapeType<T extends Record<string, RuleInstance<any>>> =\n  SchemaInfer<T>;\n\nexport type ShapeInputType<T extends Record<string, RuleInstance<any>>> =\n  SchemaInput<T>;\n\nexport type ShapeRuleInstance<S extends Record<string, RuleInstance<any>>> =\n  RuleInstance<ShapeType<S>, [ShapeInputType<S>]>;\n\nexport type ShapeValue<S extends Record<string, RuleInstance<any>>> =\n  ShapeType<S>;\n\nexport type SchemaValidationRule = <T extends Record<string, any>>(\n  value: T,\n  schema: Record<string, RuleInstance<any>>,\n) => RuleRunReturn<T>;\n","import './schemaRulesLazyTypes';\n\nexport { isArrayOf, type IsArrayOfRuleInstance } from './isArrayOf';\nexport { loose, type LooseRuleInstance } from './loose';\nexport { optional, type OptionalRuleInstance } from './optional';\nexport { partial, type PartialRuleInstance } from './partial';\nexport { pick, type PickRuleInstance } from './pick';\nexport { omit, type OmitRuleInstance } from './omit';\nexport { shape, type ShapeRuleInstance } from './shape';\nexport type { SchemaRuleLazyTypes } from './schemaRulesLazyTypes';\n","// Checks if string ends with the given suffix\nexport function endsWith(str: string, ending: string): boolean {\n  return str.endsWith(ending);\n}\n","import { endsWith } from './endsWith';\n\n// Checks if string does not end with the given suffix\nexport function doesNotEndWith(str: string, ending: string): boolean {\n  return !endsWith(str, ending);\n}\n","// Checks if string starts with the given prefix\nexport function startsWith(str: string, start: string): boolean {\n  return str.startsWith(start);\n}\n","import { startsWith } from './startsWith';\n\n// Checks if string does not start with the given prefix\nexport function doesNotStartWith(str: string, start: string): boolean {\n  return !startsWith(str, start);\n}\n","import { isStringValue } from 'vest-utils';\n\nimport { isBlank } from '../general/isBlank';\n\n// Checks if string contains only whitespace characters\nexport function isBlankString(str: string): boolean {\n  return isStringValue(str) && isBlank(str);\n}\n","// Checks if string contains non-whitespace characters\nexport function isNotBlank(str: string): boolean {\n  return str.trim().length > 0;\n}\n","import { isStringValue } from 'vest-utils';\n\n/**\n * Validates that a value is a string.\n * Type guard that narrows the type to string.\n *\n * @param value - Value to validate\n * @returns True if value is a string\n *\n * @example\n * ```typescript\n * // Eager API\n * enforce('hello').isString(); // passes\n * enforce(123).isString(); // fails\n *\n * // Lazy API\n * const stringRule = enforce.isString();\n * stringRule.test('hello'); // true\n *\n * // Chains with string-specific rules\n * enforce('hello').isString().longerThan(3);\n * ```\n */\nexport function isString(value: any): value is string {\n  return isStringValue(value);\n}\n","import { isStringValue } from 'vest-utils';\n\nexport function toRegExp(regex: RegExp | string): RegExp | null {\n  if (regex instanceof RegExp) return regex;\n  if (isStringValue(regex)) return new RegExp(regex);\n  return null;\n}\n","import { toRegExp } from '../../utils/regex';\n\n// Checks if string matches the given regular expression pattern\nexport function matches(str: string, regex: RegExp | string): boolean {\n  const r = toRegExp(regex);\n  return !!r && r.test(str);\n}\n","import { toRegExp } from '../../utils/regex';\n\n// Checks if string does not match the given regular expression pattern\nexport function notMatches(str: string, regex: RegExp | string): boolean {\n  const r = toRegExp(regex);\n  return !!r && !r.test(str);\n}\n","import { BuildRuleInstance, ExtractRuleFunctions } from './RuleInstanceBuilder';\nimport { equals, notEquals } from './commonComparison';\nimport { inside, notInside } from './commonContainer';\nimport {\n  lengthEquals,\n  lengthNotEquals,\n  longerThan,\n  longerThanOrEquals,\n  maxLength,\n  minLength,\n  shorterThan,\n  shorterThanOrEquals,\n} from './commonLength';\nimport { doesNotEndWith } from './string/doesNotEndWith';\nimport { doesNotStartWith } from './string/doesNotStartWith';\nimport { endsWith } from './string/endsWith';\nimport { isBlankString as isBlank } from './string/isBlankString';\nimport { isNotBlank } from './string/isNotBlank';\nimport { isString } from './string/isString';\nimport { matches } from './string/matches';\nimport { notMatches } from './string/notMatches';\nimport { startsWith } from './string/startsWith';\n\nexport {\n  doesNotEndWith,\n  doesNotStartWith,\n  endsWith,\n  equals,\n  inside,\n  isBlank,\n  isNotBlank,\n  isString,\n  lengthEquals,\n  lengthNotEquals,\n  longerThan,\n  longerThanOrEquals,\n  matches,\n  maxLength,\n  minLength,\n  notEquals,\n  notInside,\n  notMatches,\n  shorterThan,\n  shorterThanOrEquals,\n  startsWith,\n};\n\nconst stringRules = {\n  doesNotEndWith,\n  doesNotStartWith,\n  endsWith,\n  equals,\n  inside,\n  isBlank,\n  isNotBlank,\n  lengthEquals,\n  lengthNotEquals,\n  longerThan,\n  longerThanOrEquals,\n  matches,\n  maxLength,\n  minLength,\n  notEquals,\n  notInside,\n  notMatches,\n  shorterThan,\n  shorterThanOrEquals,\n  startsWith,\n} as const;\n\nexport type StringRuleInstance = BuildRuleInstance<\n  string,\n  [string],\n  ExtractRuleFunctions<typeof stringRules>\n>;\n","import * as arrayRules from '../rules/arrayRules';\nimport * as booleanRules from '../rules/booleanRules';\nimport * as commonComparison from '../rules/commonComparison';\nimport * as commonContainer from '../rules/commonContainer';\nimport * as commonLength from '../rules/commonLength';\nimport * as compoundRules from '../rules/compoundRules/compoundRules';\nimport * as generalRules from '../rules/generalRules';\nimport * as nullishRules from '../rules/nullishRules';\nimport * as numberRules from '../rules/numberRules';\nimport { isNumeric } from '../rules/numeric/isNumeric';\nimport * as objectRules from '../rules/objectRules';\nimport * as schemaRules from '../rules/schemaRules/schemaRules';\nimport * as stringRules from '../rules/stringRules';\n\nexport const allRules = {\n  ...arrayRules,\n  ...booleanRules,\n  ...commonComparison,\n  ...commonContainer,\n  ...commonLength,\n  ...generalRules,\n  ...nullishRules,\n  ...numberRules,\n  // not ideal but it helps us that all the numeric rules are exported directly from number rules\n  isNumeric,\n  ...objectRules,\n  ...stringRules,\n} as const;\n\nexport const schemaRulesMap = {\n  ...compoundRules,\n  ...schemaRules,\n} as const;\n","import { assign } from 'vest-utils';\n\nimport { allRules, schemaRulesMap } from './allRules';\n\nconst customRules: Record<string, (...args: any[]) => any> = {};\n\nexport type UnmodifiedRuleKeys = keyof typeof allRules;\nexport type UnmodifiedRules = (typeof allRules)[UnmodifiedRuleKeys];\nexport type SchemaRuleKeys = keyof typeof schemaRulesMap;\nexport type SchemaRules = (typeof schemaRulesMap)[SchemaRuleKeys];\n\nexport function extendEager(rules: Record<string, (...args: any[]) => any>) {\n  assign(customRules, rules);\n}\n\nexport function getSchemaRule(ruleName: string): SchemaRules | null {\n  return schemaRulesMap[ruleName as SchemaRuleKeys] ?? null;\n}\n\nexport function getRule(ruleName: string): UnmodifiedRules | null {\n  return (\n    (customRules[ruleName] as UnmodifiedRules | undefined) ??\n    allRules[ruleName as UnmodifiedRuleKeys]\n  );\n}\n","import type { Maybe } from 'vest-utils';\n\nimport { allRules, schemaRulesMap } from './eager/allRules';\nimport type { EnforceEagerReturn } from './eager/eagerTypes';\nimport { createRuleCall } from './eager/ruleCallGenerator';\nimport { extendEager, getRule, getSchemaRule } from './eager/ruleRegistry';\n\nexport { extendEager };\nexport type { EnforceEagerReturn } from './eager/eagerTypes';\n\nconst MESSAGE_KEY = 'message';\n\ntype EagerReturn<T> = EnforceEagerReturn<\n  T,\n  typeof allRules,\n  typeof schemaRulesMap\n>;\n\n/**\n * Eager (imperative) validation API - validates a value immediately with chainable assertions.\n * Each chained rule executes synchronously and the chain breaks on the first failure.\n *\n * @template T - The type of value being validated\n * @param value - The value to validate\n * @returns A proxy object with chainable validation methods and a `pass` property\n *\n * @example\n * ```typescript\n * // Simple validation\n * enforce('hello').isString(); // passes\n *\n * // Chained validation\n * enforce(25)\n *   .isNumber()\n *   .greaterThan(18)\n *   .lessThan(100);\n *\n * // Custom error messages\n * enforce('')\n *   .message('Field is required')\n *   .isNotEmpty();\n *\n * // Type narrowing\n * enforce(value)\n *   .isString()\n *   .longerThan(5);\n * // value is now known to be a string\n *\n * // Schema validation\n * enforce({ name: 'John', age: 30 })\n *   .shape({\n *     name: enforce.isString(),\n *     age: enforce.isNumber()\n *   });\n *\n * // Check pass status without throwing\n * const result = enforce(value).isString();\n * if (result.pass) {\n *   // validation passed\n * }\n * ```\n */\nexport function enforceEager<T>(value: T): EagerReturn<T> {\n  let customMessage: Maybe<string> = undefined;\n\n  const setMessage = (msg?: string) => {\n    customMessage = msg;\n    return proxy;\n  };\n\n  const clearMessage = () => setMessage(undefined);\n\n  const proxy: EagerReturn<T> = new Proxy(\n    {},\n    {\n      get(_target: any, key: string) {\n        if (key === MESSAGE_KEY) return setMessage;\n\n        const rule = getRule(key) ?? getSchemaRule(key);\n        if (rule) {\n          return createRuleCall({\n            clearMessage,\n            customMessage,\n            rule,\n            ruleName: key,\n            target: proxy,\n            value,\n          });\n        }\n\n        return _target[key];\n      },\n    },\n  );\n\n  return proxy;\n}\n","import { isObject } from 'vest-utils';\n\nimport { RuleRunReturn } from '../../utils/RuleRunReturn';\n\nexport type Predicate = (value: any) => boolean | RuleRunReturn<any>;\n\nfunction isRuleRunReturn(result: any): result is RuleRunReturn<any> {\n  return isObject(result) && 'pass' in result;\n}\n\nexport function executeChain(\n  chain: Predicate[],\n  value: any,\n): RuleRunReturn<any> {\n  let currentValue = value;\n\n  for (const predicate of chain) {\n    const result = predicate(currentValue);\n\n    if (isRuleRunReturn(result)) {\n      if (!result.pass) return result as RuleRunReturn<any>;\n      currentValue = result.type;\n    } else if (!result) {\n      return RuleRunReturn.Failing(currentValue);\n    }\n  }\n\n  return RuleRunReturn.Passing(currentValue);\n}\n","import { RuleRunReturn } from '../../utils/RuleRunReturn';\n\n/**\n * Marks a parser as a pre-type-check transform.\n * Parsers tagged with this symbol are prepended to the chain\n * so they run before type checks (e.g. defaultTo).\n */\nexport const CHAIN_PREPEND: unique symbol = Symbol('chainPrepend');\n\nexport function mapPassing<TInput, TOutput>(\n  transform: (value: TInput) => TOutput,\n): (value: TInput) => RuleRunReturn<TOutput> {\n  return (value: TInput) => RuleRunReturn.Passing(transform(value));\n}\n","import type { Predicate } from './chainExecutor';\n\nconst lazyRegistry: Record<string, (...args: any[]) => Predicate> = {};\n\nexport function registerLazyRule(\n  name: string,\n  builder: (...args: any[]) => Predicate,\n) {\n  lazyRegistry[name] = builder;\n}\n\nexport function getLazyRule(\n  name: string,\n): ((...args: any[]) => Predicate) | undefined {\n  return lazyRegistry[name];\n}\n","import { hasOwnProperty } from 'vest-utils';\nimport { StandardSchemaV1 } from 'vest-utils/standardSchemaSpec';\n\nimport { RuleInstance } from '../../utils/RuleInstance';\nimport { CHAIN_PREPEND } from '../parsers/parserUtils';\n\nimport type { Predicate } from './chainExecutor';\nimport { getLazyRule } from './lazyRegistry';\n\nexport function createChainProxyHandlers<T extends RuleInstance<any, any>>(\n  rules: Record<string, (...args: any[]) => any>,\n  {\n    add,\n    test,\n    validate,\n    run,\n    parse,\n    message,\n    prepend,\n    '~standard': standard,\n  }: {\n    add: (p: Predicate) => T;\n    test: T['test'];\n    validate: T['validate'];\n    run: T['run'];\n    parse: T['parse'];\n    message: (msg: any) => T;\n    prepend: (p: Predicate) => T;\n    '~standard': StandardSchemaV1.Props<any, any>;\n  },\n) {\n  const methods = {\n    '~standard': standard,\n    message,\n    parse,\n    run,\n    test,\n    validate,\n  };\n  const methodKeys = new Set([\n    'infer',\n    'test',\n    'validate',\n    'run',\n    'parse',\n    'message',\n    '~standard',\n  ]);\n\n  return createProxyHandlersHelper(rules, methods, methodKeys, {\n    add,\n    prepend,\n  });\n}\n\nfunction createProxyHandlersHelper<T extends RuleInstance<any, any>>(\n  rules: Record<string, any>,\n  methods: Record<string, any>,\n  methodKeys: Set<string>,\n  inserters: { add: (p: Predicate) => T; prepend: (p: Predicate) => T },\n) {\n  function getRuleHandler(prop: string | symbol) {\n    if (hasOwnProperty(rules, prop)) {\n      const insert = rules[prop][CHAIN_PREPEND]\n        ? inserters.prepend\n        : inserters.add;\n      return (...args: any[]) =>\n        insert((value: any) => rules[prop](value, ...args));\n    }\n\n    if (typeof prop === 'string') {\n      const lazyRule = getLazyRule(prop);\n      if (lazyRule) {\n        return (...args: any[]) => inserters.add(lazyRule(...args));\n      }\n    }\n\n    return undefined;\n  }\n\n  return {\n    get(_target: T, prop: string | symbol, receiver: any) {\n      if (hasOwnProperty(methods, prop)) {\n        return methods[prop];\n      }\n\n      return (\n        getRuleHandler(prop) ?? Reflect.get(_target as object, prop, receiver)\n      );\n    },\n    has(_target: T, prop: string | symbol) {\n      if (typeof prop === 'string') {\n        if (methodKeys.has(prop) || getLazyRule(prop)) return true;\n      }\n      if (hasOwnProperty(rules, prop)) return true;\n      return Reflect.has(_target as object, prop);\n    },\n  };\n}\n","/* eslint-disable max-statements */\n/* eslint-disable max-lines-per-function */\nimport {\n  dynamicValue,\n  type DynamicValue,\n  type Maybe,\n  type Stringable,\n} from 'vest-utils';\nimport { StandardSchemaV1 } from 'vest-utils/standardSchemaSpec';\n\nimport { RuleInstance } from '../../utils/RuleInstance';\n\nimport { executeChain, type Predicate } from './chainExecutor';\nimport { createChainProxyHandlers } from './proxyHandlers';\n\nexport type RuleFunctions<T extends RuleInstance<any, any>> = Record<\n  keyof Omit<T, 'infer' | 'test' | 'validate' | 'parse' | '~standard'>,\n  (...args: any[]) => boolean | ReturnType<Predicate>\n>;\n\ntype LazyMessage = DynamicValue<\n  string,\n  [value: unknown, originalMessage?: Stringable]\n>;\n\n/**\n * Creates a chain builder for rule validation.\n * Provides methods to add predicates, run validation, and apply custom messages.\n * Implements StandardSchema v1 support.\n */\nexport function createChainBuilder<T extends RuleInstance<any, any>>(\n  rules: RuleFunctions<T> | Record<string, (...args: any[]) => any>,\n) {\n  const chain: Predicate[] = [];\n  const target: Partial<T> = {};\n  let lazyMessage: Maybe<LazyMessage> = undefined;\n\n  const add = (p: Predicate): T => {\n    chain.push(p);\n    return proxy;\n  };\n\n  const prepend = (p: Predicate): T => {\n    chain.unshift(p);\n    return proxy;\n  };\n\n  const resolveMessage = (\n    result: ReturnType<typeof executeChain>,\n    value: unknown,\n  ): string => {\n    const defaultMessage = result.message || 'Validation failed';\n    if (!lazyMessage) {\n      return defaultMessage;\n    }\n    return dynamicValue(lazyMessage, value, result.message) ?? defaultMessage;\n  };\n\n  const validate: T['validate'] = ((...args: any[]) => {\n    const result = executeChain(chain, args[0]);\n    if (result.pass) {\n      return { value: result.type };\n    }\n    return {\n      issues: [\n        {\n          message: resolveMessage(result, args[0]),\n          path: result.path || [],\n        },\n      ],\n    };\n  }) as T['validate'];\n\n  const test: T['test'] = ((...args: any[]) => {\n    const result = validate(...args);\n    return !result.issues;\n  }) as T['test'];\n\n  // Internal compatibility method - converts StandardSchema Result to RuleRunReturn\n\n  const parse: T['parse'] = ((...args: any[]) => {\n    const result = validate(...args);\n    if (!result.issues) {\n      return result.value;\n    }\n\n    const [firstIssue] = result.issues;\n    throw new TypeError(firstIssue?.message || 'Validation failed');\n  }) as T['parse'];\n\n  const run: T['run'] = ((...args: any[]) => {\n    const result = executeChain(chain, args[0]);\n    if (!result.pass && lazyMessage) {\n      return {\n        ...result,\n        message:\n          dynamicValue(lazyMessage, args[0], result.message) ?? result.message,\n      };\n    }\n    return result;\n  }) as T['run'];\n\n  const message = (msg: Stringable): T => {\n    if (msg) {\n      lazyMessage = msg;\n    }\n    return proxy;\n  };\n\n  const proxy: T = new Proxy(\n    target as T,\n    createChainProxyHandlers(rules, {\n      '~standard': {\n        types: {\n          input: undefined!,\n          output: undefined!,\n        },\n        validate,\n        vendor: 'n4s',\n        version: 1 as const,\n      } as StandardSchemaV1.Props<any, any>,\n      add,\n      message,\n      parse,\n      prepend,\n      run,\n      test,\n      validate,\n    }),\n  );\n\n  return { add, proxy } as const;\n}\n","import { RuleInstance } from '../utils/RuleInstance';\n\nimport {\n  createChainBuilder,\n  type RuleFunctions,\n} from './chainBuilder/chainBuilder';\nimport { type Predicate } from './chainBuilder/chainExecutor';\nimport { registerLazyRule } from './chainBuilder/lazyRegistry';\n\nexport { registerLazyRule };\n\n/**\n * Adds a predicate to a new rule chain and returns the chained rule instance.\n */\nexport function addToChain<T extends RuleInstance<any, any>>(\n  rules: RuleFunctions<T> | Record<string, (...args: any[]) => any>,\n  predicate: Predicate,\n): T {\n  const { add, proxy } = createChainBuilder<T>(rules);\n  add(predicate);\n  return proxy as T;\n}\n","import { extendEager } from './eager';\nimport { ctx } from './enforceContext';\nimport { addToChain, registerLazyRule } from './rules/genRuleChain';\nimport { RuleRunReturn } from './utils/RuleRunReturn';\n\n/**\n * Extends the enforce API with custom validation rules.\n * Custom rules are added to both eager and lazy APIs automatically.\n *\n * Rules receive the value as the first parameter, followed by any additional arguments.\n * They should return a boolean or RuleRunReturn.\n *\n * @param enforce - The enforce object to extend\n * @param rules - Object mapping rule names to validation functions\n *\n * @example\n * ```typescript\n * // Add custom rules\n * extendEnforce(enforce, {\n *   isPositive: (value: number) => value > 0,\n *   isBetween: (value: number, min: number, max: number) =>\n *     value >= min && value <= max,\n *   isEven: (value: number) => value % 2 === 0\n * });\n *\n * // Use in eager API\n * enforce(10).isPositive().isEven();\n * enforce(5).isBetween(1, 10);\n *\n * // Use in lazy API\n * const positiveRule = enforce.isPositive();\n * positiveRule.test(5); // true\n * positiveRule.test(-3); // false\n *\n * // Combine with built-in rules\n * const schema = enforce.shape({\n *   age: enforce.isNumber().isPositive().isBetween(18, 100),\n *   score: enforce.isNumber().isEven()\n * });\n * ```\n */\nexport function extendEnforce(\n  enforce: any,\n  rules: Record<string, (...args: any[]) => any>,\n) {\n  extendEager(rules);\n\n  Object.keys(rules).forEach(ruleName => {\n    const rule = rules[ruleName];\n    const ruleWrapper = (value: any, ...args: any[]) => {\n      const res = ctx.run({ value }, () => rule(value, ...args));\n      return RuleRunReturn.create(res, value);\n    };\n\n    enforce[ruleName] = (...args: any[]) =>\n      addToChain({}, (value: any) => ruleWrapper(value, ...args));\n\n    registerLazyRule(\n      ruleName,\n      (...args: any[]) =>\n        (value: any) =>\n          ruleWrapper(value, ...args),\n    );\n  });\n}\n","import { ctx } from '../enforceContext';\nimport { addToChain } from '../rules/genRuleChain';\nimport { RuleInstance } from '../utils/RuleInstance';\nimport { RuleRunReturn } from '../utils/RuleRunReturn';\n\nexport function adaptDynamicRules<\n  T extends RuleInstance<any, [any]>,\n  O extends Record<string, (...args: any[]) => any>,\n>(container: O): Record<keyof typeof container, (...args: any[]) => T> {\n  return Object.keys(container).reduce(\n    (acc, key) => {\n      acc[key as keyof O] = (...args: any[]) =>\n        addToChain({}, (value: any) => {\n          // eslint-disable-next-line max-nested-callbacks\n          const result = ctx.run({ value }, () =>\n            container[key as keyof O](value, ...args),\n          );\n          return RuleRunReturn.create(result, value);\n        });\n      return acc;\n    },\n    {} as Record<keyof typeof container, (...args: any[]) => T>,\n  );\n}\n","import { mapPassing } from './parserUtils';\n\nexport const join = (value: unknown[], separator = ',') =>\n  mapPassing((current: unknown[]) => current.join(separator))(value);\n\nexport const uniq = (value: unknown[]) =>\n  mapPassing((current: unknown[]) => [...new Set(current)])(value);\n\nexport const arrayParsers = {\n  join,\n  uniq,\n} as const;\n","import { RuleRunReturn } from '../../utils/RuleRunReturn';\n\nconst TRUTHY_STRINGS = new Set(['true', '1', 'yes', 'on']);\nconst FALSY_STRINGS = new Set(['false', '0', 'no', 'off']);\n\nfunction parseStringBoolean(value: string): boolean | undefined {\n  const normalized = value.trim().toLowerCase();\n  if (TRUTHY_STRINGS.has(normalized)) {\n    return true;\n  }\n  if (FALSY_STRINGS.has(normalized)) {\n    return false;\n  }\n\n  return undefined;\n}\n\nfunction parseNumberBoolean(value: number): boolean | undefined {\n  if (value === 1) return true;\n  if (value === 0) return false;\n  return undefined;\n}\n\nfunction parseBooleanValue(value: unknown): boolean | undefined {\n  if (typeof value === 'boolean') return value;\n  if (typeof value === 'string') return parseStringBoolean(value);\n  if (typeof value === 'number') return parseNumberBoolean(value);\n  return undefined;\n}\n\nexport function toBoolean(value: unknown): RuleRunReturn<boolean> {\n  const parsed = parseBooleanValue(value);\n  if (parsed !== undefined) {\n    return RuleRunReturn.Passing(parsed);\n  }\n\n  return RuleRunReturn.Failing(false, 'Could not parse to boolean');\n}\n","import { RuleRunReturn } from '../../utils/RuleRunReturn';\nimport { CHAIN_PREPEND } from './parserUtils';\nimport { toBoolean } from './toBoolean';\n\nexport function defaultTo<TValue>(\n  value: TValue,\n  fallback: NonNullable<TValue>,\n): RuleRunReturn<NonNullable<TValue>> {\n  if (value == null) {\n    return RuleRunReturn.Passing(fallback);\n  }\n\n  return RuleRunReturn.Passing(value as NonNullable<TValue>);\n}\n\n(defaultTo as unknown as Record<symbol, boolean>)[CHAIN_PREPEND] = true;\n\nexport const parseJSON = (value: string): RuleRunReturn<unknown> => {\n  try {\n    return RuleRunReturn.Passing(JSON.parse(value));\n  } catch {\n    return RuleRunReturn.Failing(value, 'Could not parse JSON');\n  }\n};\n\nexport const generalParsers = {\n  defaultTo,\n  parseJSON,\n  toBoolean,\n} as const;\n","import { RuleRunReturn } from '../../utils/RuleRunReturn';\n\nimport { mapPassing } from './parserUtils';\n\nexport const ceil = (value: number) =>\n  mapPassing((current: number) => Math.ceil(current))(value);\n\nexport const clamp = (value: number, min: number, max: number) =>\n  mapPassing((current: number) => Math.min(max, Math.max(min, current)))(value);\n\nexport const floor = (value: number) =>\n  mapPassing((current: number) => Math.floor(current))(value);\n\nexport const round = (value: number) =>\n  mapPassing((current: number) => Math.round(current))(value);\n\nexport const toAbsolute = (value: number) =>\n  mapPassing((current: number) => Math.abs(current))(value);\n\nexport const toDate = (value: unknown): RuleRunReturn<Date> => {\n  if (\n    typeof value !== 'string' &&\n    typeof value !== 'number' &&\n    !(value instanceof Date)\n  ) {\n    return RuleRunReturn.Failing(\n      new Date(NaN),\n      'Could not parse to Date: expected string, number, or Date',\n    );\n  }\n\n  const parsed = new Date(value as string | number | Date);\n  if (Number.isNaN(parsed.getTime())) {\n    return RuleRunReturn.Failing(parsed, 'Could not parse to Date');\n  }\n\n  return RuleRunReturn.Passing(parsed);\n};\n\nexport const toFloat = (value: unknown): RuleRunReturn<number> => {\n  const parsed = typeof value === 'number' ? value : parseFloat(String(value));\n  if (Number.isNaN(parsed)) {\n    return RuleRunReturn.Failing(NaN, 'Could not parse to float');\n  }\n\n  return RuleRunReturn.Passing(parsed);\n};\n\nfunction isValidRadix(radix: number): boolean {\n  return Number.isInteger(radix) && radix >= 2 && radix <= 36;\n}\n\nexport const toInteger = (\n  value: unknown,\n  radix = 10,\n): RuleRunReturn<number> => {\n  if (!isValidRadix(radix)) {\n    return RuleRunReturn.Failing(\n      NaN,\n      'Invalid radix: must be an integer between 2 and 36',\n    );\n  }\n\n  const parsed =\n    typeof value === 'number'\n      ? Math.trunc(value)\n      : parseInt(String(value), radix);\n\n  if (Number.isNaN(parsed)) {\n    return RuleRunReturn.Failing(NaN, 'Could not parse to integer');\n  }\n\n  return RuleRunReturn.Passing(parsed);\n};\n\nexport const numberParsers = {\n  ceil,\n  clamp,\n  floor,\n  round,\n  toAbsolute,\n  toDate,\n  toFloat,\n  toInteger,\n} as const;\n","import { mapPassing } from './parserUtils';\n\nfunction toCamelCase(value: string): string {\n  return value\n    .trim()\n    .toLowerCase()\n    .replace(/[\\s_-]+(.)?/g, (_match, chr: string | undefined) =>\n      chr ? chr.toUpperCase() : '',\n    );\n}\n\nfunction toPascalCase(value: string): string {\n  const camel = toCamelCase(value);\n  return camel.charAt(0).toUpperCase() + camel.slice(1);\n}\n\nfunction toSnakeCase(value: string): string {\n  return value\n    .trim()\n    .replace(/([a-z0-9])([A-Z])/g, '$1_$2')\n    .replace(/[\\s-]+/g, '_')\n    .toLowerCase();\n}\n\nfunction toKebabCase(value: string): string {\n  return value\n    .trim()\n    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')\n    .replace(/[\\s_]+/g, '-')\n    .toLowerCase();\n}\n\nexport const append = (value: string, suffix: string) =>\n  mapPassing((current: string) => `${current}${suffix}`)(value);\n\nexport const normalizeWhitespace = (value: string) =>\n  mapPassing((current: string) => current.replace(/\\s+/g, ' ').trim())(value);\n\nexport const prepend = (value: string, prefix: string) =>\n  mapPassing((current: string) => `${prefix}${current}`)(value);\n\nexport const removeNonAlphanumeric = (value: string) =>\n  mapPassing((current: string) => current.replace(/[^a-zA-Z0-9]/g, ''))(value);\n\nexport const removeNonDigits = (value: string) =>\n  mapPassing((current: string) => current.replace(/\\D+/g, ''))(value);\n\nexport const removeNonLetters = (value: string) =>\n  mapPassing((current: string) => current.replace(/[^a-zA-Z]/g, ''))(value);\n\nexport const replace = (\n  value: string,\n  searchValue: string | RegExp,\n  replaceValue: string,\n) =>\n  mapPassing((current: string) => current.replace(searchValue, replaceValue))(\n    value,\n  );\n\nexport const replaceAll = (\n  value: string,\n  searchValue: string | RegExp,\n  replaceValue: string,\n) =>\n  mapPassing((current: string) =>\n    typeof searchValue === 'string'\n      ? searchValue === ''\n        ? current\n        : current.split(searchValue).join(replaceValue)\n      : current.replace(\n          new RegExp(\n            searchValue.source,\n            [...new Set(searchValue.flags + 'g')].join(''),\n          ),\n          replaceValue,\n        ),\n  )(value);\n\nexport const split = (\n  value: string,\n  separator: string | RegExp,\n  limit?: number,\n) => mapPassing((current: string) => current.split(separator, limit))(value);\n\nexport const stripWhitespace = (value: string) =>\n  mapPassing((current: string) => current.replace(/\\s+/g, ''))(value);\n\nexport const toCamel = (value: string) =>\n  mapPassing((current: string) => toCamelCase(current))(value);\n\nexport const toCapitalized = (value: string) =>\n  mapPassing(\n    (current: string) =>\n      current.charAt(0).toUpperCase() + current.slice(1).toLowerCase(),\n  )(value);\n\nexport const toKebab = (value: string) =>\n  mapPassing((current: string) => toKebabCase(current))(value);\n\nexport const toLower = (value: string) =>\n  mapPassing((current: string) => current.toLowerCase())(value);\n\nexport const toPascal = (value: string) =>\n  mapPassing((current: string) => toPascalCase(current))(value);\n\nexport const toSnake = (value: string) =>\n  mapPassing((current: string) => toSnakeCase(current))(value);\n\nexport const toTitle = (value: string) =>\n  mapPassing((current: string) =>\n    current.toLowerCase().replace(/\\b\\w/g, char => char.toUpperCase()),\n  )(value);\n\nexport const toUpper = (value: string) =>\n  mapPassing((current: string) => current.toUpperCase())(value);\n\nexport const trim = (value: string) =>\n  mapPassing((current: string) => current.trim())(value);\n\nexport const trimEnd = (value: string) =>\n  mapPassing((current: string) => current.trimEnd())(value);\n\nexport const trimStart = (value: string) =>\n  mapPassing((current: string) => current.trimStart())(value);\n\nexport const stringParsers = {\n  append,\n  normalizeWhitespace,\n  prepend,\n  removeNonAlphanumeric,\n  removeNonDigits,\n  removeNonLetters,\n  replace,\n  replaceAll,\n  split,\n  stripWhitespace,\n  toCamel,\n  toCapitalized,\n  toKebab,\n  toLower,\n  toPascal,\n  toSnake,\n  toTitle,\n  toUpper,\n  trim,\n  trimEnd,\n  trimStart,\n} as const;\n","import { isArray } from '../rules/array/isArrayRule';\nimport {\n  BuildRuleInstance,\n  ExtractRuleFunctions,\n} from '../rules/RuleInstanceBuilder';\nimport * as arrayRules from '../rules/arrayRules';\nimport { isBoolean, type BooleanRuleInstance } from '../rules/booleanRules';\nimport * as booleanRules from '../rules/booleanRules';\nimport { addToChain } from '../rules/genRuleChain';\nimport {\n  isNull,\n  isUndefined,\n  isNullish,\n  type NullRuleInstance,\n  type UndefinedRuleInstance,\n  type NullishRuleInstance,\n} from '../rules/nullishRules';\nimport { isNumber } from '../rules/numberRules';\nimport * as numberRules from '../rules/numberRules';\nimport { isNumeric } from '../rules/numeric/isNumeric';\nimport { arrayParsers } from '../rules/parsers/arrayParsers';\nimport { generalParsers } from '../rules/parsers/generalParsers';\nimport { numberParsers } from '../rules/parsers/numberParsers';\nimport { stringParsers } from '../rules/parsers/stringParsers';\nimport { isString } from '../rules/stringRules';\nimport * as stringRules from '../rules/stringRules';\n\nconst lazyArrayRules = {\n  ...arrayRules,\n  ...arrayParsers,\n  ...generalParsers,\n} as const;\n\nconst lazyNumberRules = {\n  ...numberRules,\n  ...numberParsers,\n  ...generalParsers,\n} as const;\n\nconst lazyStringRules = {\n  ...stringRules,\n  ...stringParsers,\n  ...generalParsers,\n} as const;\n\ntype LazyArrayRuleInstance<T = any> = BuildRuleInstance<\n  T[],\n  [T[]],\n  ExtractRuleFunctions<typeof lazyArrayRules>\n>;\n\ntype LazyNumberRuleInstance = BuildRuleInstance<\n  number,\n  [number],\n  ExtractRuleFunctions<typeof lazyNumberRules>\n>;\n\ntype LazyNumericRuleInstance = BuildRuleInstance<\n  string | number,\n  [string | number],\n  ExtractRuleFunctions<typeof lazyNumberRules>\n>;\n\ntype LazyStringRuleInstance = BuildRuleInstance<\n  string,\n  [string],\n  ExtractRuleFunctions<typeof lazyStringRules>\n>;\n\nexport const typeRules = {\n  isArray: <T = any>(): LazyArrayRuleInstance<T> =>\n    addToChain<LazyArrayRuleInstance<T>>(lazyArrayRules, isArray),\n  isBoolean: (): BooleanRuleInstance => addToChain(booleanRules, isBoolean),\n  isNull: (): NullRuleInstance => addToChain({}, isNull),\n  isNullish: (): NullishRuleInstance => addToChain({}, isNullish),\n  isNumber: (): LazyNumberRuleInstance =>\n    addToChain<LazyNumberRuleInstance>(lazyNumberRules, isNumber),\n  isNumeric: (): LazyNumericRuleInstance =>\n    addToChain<LazyNumericRuleInstance>(lazyNumberRules, isNumeric),\n  isString: (): LazyStringRuleInstance =>\n    addToChain<LazyStringRuleInstance>(lazyStringRules, isString),\n  isUndefined: (): UndefinedRuleInstance => addToChain({}, isUndefined),\n};\n","import { FirstParam } from './eager/typeUtils';\nimport { ctx } from './enforceContext';\nimport { adaptDynamicRules } from './lazy/ruleAdapter';\nimport { typeRules } from './lazy/typeRules';\nimport type { CustomMatcherArgs } from './n4sTypes';\nimport type { ArrayRuleInstance } from './rules/arrayRules';\nimport * as arrayRules from './rules/arrayRules';\nimport * as compoundRules from './rules/compoundRules/compoundRules';\nimport type { CompoundRuleLazyTypes } from './rules/compoundRules/compoundRules';\nimport { addToChain } from './rules/genRuleChain';\nimport { AnyRuleInstance } from './rules/generalRules';\nimport * as generalRules from './rules/generalRules';\nimport type { ObjectRulesUnion } from './rules/objectRules';\nimport * as objectRules from './rules/objectRules';\nimport * as schemaRules from './rules/schemaRules/schemaRules';\nimport type { SchemaRuleLazyTypes } from './rules/schemaRules/schemaRules';\nimport { type RuleInstance } from './utils/RuleInstance';\nimport { RuleRunReturn } from './utils/RuleRunReturn';\n\n/**\n * Extracts the output type from a custom matcher function.\n * If the matcher returns { type: T }, uses T (coercion rules like toNumber).\n * Otherwise falls back to the first parameter type (validation rules like isPositive).\n */\ntype InferMatcherOutput<K extends keyof n4s.EnforceMatchers> =\n  ReturnType<Extract<n4s.EnforceMatchers[K], (...args: any[]) => any>> extends {\n    type: infer T;\n  }\n    ? T\n    : FirstParam<n4s.EnforceMatchers[K]>;\n\ntype TCustomLazyRules = {\n  [K in keyof n4s.EnforceMatchers as K extends keyof SchemaRuleLazyTypes\n    ? never\n    : K extends keyof CompoundRuleLazyTypes\n      ? never\n      : K]: (\n    ...args: CustomMatcherArgs<K>\n  ) => RuleInstance<\n    InferMatcherOutput<K>,\n    [FirstParam<n4s.EnforceMatchers[K]>]\n  >;\n};\n\n// Explicitly adapt only the schema modifiers that act as wrappers\nconst schemaModifiers = adaptDynamicRules<\n  RuleInstance<any, [any]>,\n  Pick<typeof schemaRules, 'omit' | 'optional' | 'partial' | 'pick'>\n>({\n  omit: schemaRules.omit,\n  optional: schemaRules.optional,\n  partial: schemaRules.partial,\n  pick: schemaRules.pick,\n});\n\n// Explicitly adapt the base schema evaluators that need __schema exposure\nconst schemaEvaluators = adaptDynamicRules<\n  RuleInstance<any, [any]>,\n  Pick<typeof schemaRules, 'shape' | 'loose'>\n>({\n  shape: schemaRules.shape,\n  loose: schemaRules.loose,\n});\n\n/**\n * Wraps a lazy schema evaluator so the resulting RuleInstance carries\n * a `__schema` reference to the original schema definition.\n * Downstream code (e.g. vest's focus/only filtering) reads `__schema`\n * to introspect the schema keys. Treat `__schema` as internal metadata.\n */\nconst schemaAttacher =\n  (ruleFn: (schema: any) => RuleInstance<any, [any]>) => (schema: any) => {\n    const rule = ruleFn(schema);\n    rule.__schema = schema;\n    return rule;\n  };\n\n// Build the final schema rules object with special handling for arrays and base evaluators\nconst schemaRulesWithArrayChaining = {\n  ...schemaModifiers,\n  isArrayOf: <T>(...rules: any[]): ArrayRuleInstance<T> =>\n    addToChain<ArrayRuleInstance<T>>(arrayRules, (value: any) => {\n      const result = ctx.run({ value }, () =>\n        schemaRules.isArrayOf(value, ...rules),\n      );\n      return RuleRunReturn.create(result, value);\n    }),\n  loose: schemaAttacher(schemaEvaluators.loose),\n  shape: schemaAttacher(schemaEvaluators.shape),\n};\n\nconst baseEnforceLazy = {\n  ...(adaptDynamicRules<RuleInstance<any, [any]>, typeof compoundRules>(\n    compoundRules,\n  ) as CompoundRuleLazyTypes),\n  ...(schemaRulesWithArrayChaining as SchemaRuleLazyTypes),\n  ...adaptDynamicRules<AnyRuleInstance, typeof generalRules>(generalRules),\n  ...adaptDynamicRules<ObjectRulesUnion, typeof objectRules>(objectRules),\n  ...typeRules,\n};\n\n/**\n * Lazy (builder) API for creating reusable validation rules.\n * Rules are created without a value and can be executed later with `run()` or `test()`.\n *\n * This is the builder pattern side of the enforce API - rules are chainable and reusable.\n *\n * @example\n * ```typescript\n * // Create reusable rules\n * const stringRule = enforce.isString();\n * const emailRule = enforce.isString().matches(/@/);\n *\n * // Test with values\n * stringRule.test('hello'); // true\n * stringRule.test(123); // false\n *\n * // Run for detailed results\n * const result = emailRule.run('user@example.com');\n * console.log(result.pass); // true\n *\n * // Chain type-specific rules\n * const ageRule = enforce.isNumber()\n *   .greaterThanOrEquals(18)\n *   .lessThan(150);\n *\n * // Schema validation\n * const userSchema = enforce.shape({\n *   name: enforce.isString(),\n *   email: enforce.isString().matches(/@/),\n *   age: ageRule\n * });\n *\n * userSchema.test({ name: 'John', email: 'john@example.com', age: 25 }); // true\n * ```\n */\nexport const enforceLazy = baseEnforceLazy as unknown as TCustomLazyRules &\n  typeof baseEnforceLazy;\n","import { StringObject, assign, invariant, mapFirst } from 'vest-utils';\n\nimport { ctx } from './enforceContext';\nimport { RuleInstance } from './utils/RuleInstance';\nimport { RuleRunReturn } from './utils/RuleRunReturn';\n\ntype ComposeResult<T = any> = RuleInstance<T, [T]> & {\n  (value: T): void;\n};\n\n/**\n * Composes multiple validation rules into a single reusable rule.\n * The composed rule executes rules in order and fails on the first failing rule.\n * Returns a RuleInstance that can be used with both eager and lazy APIs.\n *\n * @template T - The type of value to validate\n * @param composites - Validation rules to compose\n * @returns A composed rule that can be run with values or called directly\n *\n * @example\n * ```typescript\n * // Create a reusable adult age validation\n * const isAdult = compose(\n *   enforce.isNumber(),\n *   enforce.greaterThanOrEquals(18),\n *   enforce.lessThan(150)\n * );\n *\n * // Use with lazy API\n * isAdult.test(25); // true\n * isAdult.test(16); // false\n *\n * // Use with eager API\n * enforce(30).run(isAdult); // passes\n *\n * // Call directly (throws on failure)\n * isAdult(25); // ok\n * isAdult(16); // throws\n *\n * // Compose with other rules\n * const userSchema = enforce.shape({\n *   age: isAdult,\n *   name: enforce.isString()\n * });\n * ```\n */\nexport function compose<T = any>(\n  ...composites: RuleInstance<any, [any]>[]\n): ComposeResult<T> {\n  const composedFn = assign(\n    (value: T) => {\n      const res = run(value);\n      invariant(res.pass, StringObject(res.message));\n    },\n    {\n      run,\n      test: (value: T) => run(value).pass,\n      infer: {} as T,\n    },\n  );\n\n  return composedFn as ComposeResult<T>;\n\n  function run(value: T): RuleRunReturn<T> {\n    return ctx.run({ value }, () => {\n      let result: RuleRunReturn<T> = RuleRunReturn.Passing(value);\n\n      mapFirst(\n        composites,\n        (\n          composite: RuleInstance<any, [any]>,\n          breakout: (conditional: boolean, res: RuleRunReturn<any>) => void,\n        ) => {\n          const res = composite.run(value);\n          if (!res.pass) {\n            result = res;\n            breakout(true, res);\n          }\n        },\n      );\n\n      return result;\n    });\n  }\n}\n","import { assign } from 'vest-utils';\n\nimport { enforceEager } from './eager';\nimport { ctx } from './enforceContext';\nimport type { EnforceContext } from './enforceContext';\nimport { extendEnforce } from './extendLogic';\nimport { enforceLazy } from './lazy';\n\n/**\n * Context API for accessing validation context.\n * Allows accessing metadata and parent validation context during rule execution.\n */\nexport { ctx } from './enforceContext';\n\n/**\n * Compose multiple validation rules into a single reusable rule.\n * Returns a composed rule that can be used in both eager and lazy validation.\n *\n * @example\n * ```typescript\n * // Compose separate rules that apply to the same value\n * const isValidUsername = compose(\n *   enforce.isString()\n *     .longerThan(3)\n *     .shorterThan(20)\n *     .matches(/^[a-zA-Z0-9_]+$/)\n * );\n *\n * isValidUsername.test('john_doe'); // true\n * isValidUsername.test('ab'); // false (too short)\n * isValidUsername.test('john doe'); // false (contains space)\n *\n * // Use in schema validation\n * enforce({ username: 'john_doe' }).shape({\n *   username: isValidUsername\n * });\n * ```\n */\nexport { compose } from './compose';\n\ntype ExtendFn = (rules: Record<string, (...args: any[]) => any>) => void;\ntype ContextFn = () => EnforceContext;\ntype Enforce = typeof enforceEager &\n  typeof enforceLazy & { extend: ExtendFn; context: ContextFn };\n\n/**\n * Main validation function supporting both eager (imperative) and lazy (builder) APIs.\n *\n * **Eager API (Imperative):**\n * Immediately validates a value with chainable assertions that execute on call.\n *\n * **Lazy API (Builder Pattern):**\n * Builds a reusable validation rule without a value, returns a RuleInstance.\n *\n * @example\n * ```typescript\n * // Eager API - validates immediately\n * enforce('hello').isString().longerThan(3);\n *\n * // Lazy API - builds a reusable rule\n * const stringRule = enforce.isString();\n * stringRule.test('hello'); // true\n * stringRule.run('hello'); // RuleRunReturn { pass: true, type: 'hello' }\n *\n * // Custom messages\n * enforce('').message('Field is required').isNotEmpty();\n *\n * // Schema validation\n * enforce({ name: 'John', age: 30 }).shape({\n *   name: enforce.isString(),\n *   age: enforce.isNumber()\n * });\n * ```\n */\nexport const enforce = assign(enforceEager, enforceLazy) as Enforce;\n\n/**\n * Access the current validation context.\n * Returns metadata and parent context information during rule execution.\n *\n * @returns The current EnforceContext or null if not in validation context\n *\n * @example\n * ```typescript\n * const context = enforce.context();\n * console.log(context?.value); // Current value being validated\n * console.log(context?.meta);  // Metadata attached to context\n * ```\n */\nenforce.context = function context(): EnforceContext {\n  return ctx.use();\n};\n\n/**\n * Extend enforce with custom validation rules.\n * Custom rules become available on both eager and lazy APIs.\n *\n * @param rules - Object mapping rule names to validation functions\n *\n * @example\n * ```typescript\n * enforce.extend({\n *   isPositive: (value: number) => value > 0,\n *   isBetween: (value: number, min: number, max: number) =>\n *     value >= min && value <= max\n * });\n *\n * // Now use your custom rules\n * enforce(5).isPositive(); // eager API\n * const rule = enforce.isPositive(); // lazy API\n *\n * // With TypeScript, declare types:\n * declare global {\n *   namespace n4s {\n *     interface EnforceMatchers {\n *       isPositive: (value: number) => boolean;\n *       isBetween: (value: number, min: number, max: number) => boolean;\n *     }\n *   }\n * }\n * ```\n */\nenforce.extend = function extend(\n  rules: Record<string, (...args: any[]) => any>,\n) {\n  extendEnforce(enforce, rules);\n};\n"],"mappings":"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"}