{"version":3,"sources":["../src/index.ts","../src/shared.ts","../src/arrays.ts","../src/booleans.ts","../src/dates.ts","../src/numbers.ts","../src/objects.ts","../src/strings.ts"],"sourcesContent":["/* istanbul ignore file */\nexport { applyArrayConfig, array, parseArray } from './arrays';\nexport type { ArrayConfig, ArrayItemValidatorResult } from './arrays';\nexport { applyBooleanConfig, boolean, parseBoolean } from './booleans';\nexport type { BooleanConfig } from './booleans';\nexport {\n  applyDateConfig,\n  date,\n  invalidDate,\n  maxDate,\n  minDate,\n  parseDate,\n} from './dates';\nexport type {\n  DateConfig,\n  MaxDateValidatorMessageParameters,\n  MinDateValidatorMessageParameters,\n  SharedDateValueType,\n} from './dates';\nexport { applyNumberConfig, integer, number, parseNumber } from './numbers';\nexport type { NumberConfig } from './numbers';\nexport { object } from './objects';\nexport type { ObjectParameter as ObjectParam } from './objects';\nexport {\n  createTypeValidatorTest,\n  createValidatorTest,\n  exact,\n  formatMessage,\n  hasOwnProperty,\n  invalid,\n  isObject,\n  max,\n  min,\n  oneOf,\n  required,\n  valid,\n} from './shared';\nexport type {\n  ConfigBase,\n  DeepPartial,\n  ExactValidatorMessageParameters,\n  ExtractError,\n  ExtractValue,\n  InvalidResult,\n  MaxValidatorMessageParameters,\n  MinValidatorMessageParameters,\n  OneOfValidatorMessageParameters,\n  SharedValueType,\n  ValidatorFactory,\n  ValidatorMessage,\n  ValidatorMessageParameters,\n  ValidatorResult,\n  ValidatorTest,\n  ValidResult,\n} from './shared';\nexport {\n  applyStringConfig,\n  email,\n  matches,\n  parseString,\n  string,\n  url,\n} from './strings';\nexport type {\n  MatchesValidatorMessageParameters,\n  StringConfig,\n} from './strings';\n","export type ValidResult<T> = {\n  /**\n   * True if the original value is valid according to all validation tests\n   * @deprecated Use `state` instead.\n   */\n  isValid: true;\n  /** This is preferred to use over `isValid` as it works better for type guards. */\n  state: 'valid';\n  /** The parsed value. Note that may be different than the original value. */\n  value: T | null | undefined;\n  /** Field name if provided. Automatically provided if using object validation. */\n  field?: string | undefined;\n};\n\nexport type InvalidResult<E> = {\n  /**\n   * True if the original value is valid according to all validation tests.\n   * @deprecated Use `state` instead.\n   */\n  isValid: false;\n  /** This is preferred to use over `isValid` as it works better for type guards. */\n  state: 'invalid';\n  /** The parsed value. Note that may be different than the original value. */\n  value: unknown;\n  /** Error message if `state` is invalid. */\n  message: string;\n  /** Field name if provided. Automatically provided if using object validation. */\n  field?: string | undefined;\n  /** Extra error details */\n  errors?: E | undefined;\n};\n\n/**\n * The result of a validation.\n * @typeParam T The value type\n * @category Types\n */\nexport type ValidatorResult<T = any, E = any> =\n  | ValidResult<T>\n  | InvalidResult<E>;\n\n/**\n * Validation test function.\n * @typeParam T The value type\n * @category Types\n */\nexport type ValidatorTest<T = any, E = any> = (\n  value?: unknown,\n  field?: string,\n) => Promise<ValidatorResult<T, E>>;\n\n/**\n * Extracts the generic error type from a ValidatorTest.\n * @typeParam T a ValidatorTest\n * @category Types\n */\nexport type ExtractError<T extends ValidatorTest> =\n  T extends ValidatorTest<any, infer E> ? E : unknown;\n\n/**\n * Extracts the generic value type from a ValidatorTest.\n * @typeParam T a ValidatorTest\n * @category Types\n */\nexport type ExtractValue<T extends ValidatorTest> =\n  T extends ValidatorTest<infer V> ? V : unknown;\n\n/**\n * Make a deep partial type.\n * @typeParam T any object type\n * @category Types\n */\nexport type DeepPartial<T> = {\n  [P in keyof T]?: DeepPartial<T[P]>;\n};\n\n/**\n * Validation factory function.\n * @typeParam C The configuration type\n * @category Types\n */\nexport type ValidatorFactory<C, T, E> = (\n  config?: Partial<C> | ValidatorTest,\n  ...tests: ValidatorTest[]\n) => ValidatorTest<T, E>;\n\n/**\n * Base configuration type.\n * @typeParam T The target type.\n * @category Types\n */\nexport interface ConfigBase<T> {\n  /** Parser to convert value into the designated type. */\n  parser: (value: unknown) => T | null | undefined;\n  /** Provide a fallback value in case the original value is undefined. */\n  default?: T;\n}\n\nexport interface ValidatorMessageParameters<T> {\n  value: T | null | undefined;\n  field: string | undefined;\n}\n\n/**\n * Validation message. May be a plain string or a function that accepts arguments.\n * While using a string, values in squiggly brackets `{}` are replaced.\n * @category Types\n */\nexport type ValidatorMessage<\n  T,\n  P extends ValidatorMessageParameters<T> = ValidatorMessageParameters<T>,\n> = string | ((parameters: P) => string);\n\n/**\n * Simple check for objects.\n * @param value Value to test\n */\nexport function isObject(value: unknown): boolean {\n  return Object.prototype.toString.call(value) === '[object Object]';\n}\n\n/**\n * Safe hasOwnProperty check\n * @param object Object to check\n * @param property Property to look for\n */\nexport function hasOwnProperty(\n  object: unknown,\n  property: string | number | symbol,\n): boolean {\n  return Object.prototype.hasOwnProperty.call(object, property);\n}\n\n/** @internal */\nconst formatPattern = /{(\\w+)}/g;\n\n/**\n * Formats a message using a squiggly bracket `{}` template.\n * @param template Message template as string or function\n * @param parameters Params to inject into template\n * @category Helpers\n */\nexport function formatMessage<T, P extends ValidatorMessageParameters<T>>(\n  template: ValidatorMessage<T, P>,\n  parameters: P,\n): string {\n  if (typeof template === 'string') {\n    return template.replaceAll(formatPattern, (_, key: string) =>\n      String((parameters as Record<string, unknown>)[key]),\n    );\n  }\n\n  return template(parameters);\n}\n\n/**\n * Creates a valid result\n * @param value Parsed value\n * @param field Field name\n * @category Helpers\n */\nexport async function valid<T, E = never>({\n  value,\n  field,\n}: {\n  value: T | null | undefined;\n  field: string | undefined;\n}): Promise<ValidatorResult<T, E>> {\n  return {\n    isValid: true,\n    state: 'valid',\n    value,\n    field,\n  };\n}\n\n/**\n * Creates an invalid result.\n * @param message Error message\n * @param value Parsed value\n * @param field Field name\n * @param extras Extra message params\n * @category Helpers\n */\nexport async function invalid<\n  T,\n  E,\n  P extends ValidatorMessageParameters<T> = ValidatorMessageParameters<T>,\n>({\n  errors,\n  field,\n  message,\n  value,\n  extras,\n}: {\n  message: ValidatorMessage<T, P>;\n  value: unknown;\n  field: string | undefined;\n  errors?: E | undefined;\n  extras?: Omit<P, 'field' | 'value'> | undefined;\n}): Promise<ValidatorResult<T, E>> {\n  return {\n    isValid: false,\n    state: 'invalid',\n    message: formatMessage(message, { ...extras, value, field } as P),\n    value,\n    field,\n    errors,\n  };\n}\n\n/**\n * Creates a type validator.\n * @typeParam T The basic type for the final value to be validated.\n * @typeParam C The configuration type.\n * @param defaultParser Parser to convert value into type.\n * @param applyConfig Function that applies configuration to value.\n * @category Helpers\n */\nexport function createTypeValidatorTest<T, C extends ConfigBase<T>>(\n  defaultConfig: C,\n  applyConfig: (value: unknown, config: C) => T | null | undefined,\n): ValidatorFactory<C, T, string> {\n  return (config, ...tests) => {\n    const cache: Record<string, ValidatorResult<T>> = {};\n    let finalConfig = defaultConfig;\n    let allTests = tests;\n\n    if (config !== undefined) {\n      if (typeof config === 'function') {\n        allTests = [config, ...tests];\n      } else {\n        finalConfig = {\n          ...defaultConfig,\n          ...config,\n        };\n      }\n    }\n\n    return async (value, field) => {\n      try {\n        const parsedValue = applyConfig(value, finalConfig);\n        const parsedValueString = String(parsedValue);\n        if (hasOwnProperty(cache, parsedValueString)) {\n          return cache[parsedValueString] as ValidatorResult<T, any>;\n        }\n\n        for (const validatorTest of allTests) {\n          const result = await validatorTest(parsedValue, field);\n          if (result.state === 'invalid') {\n            cache[parsedValueString] = result;\n            return result;\n          }\n        }\n\n        cache[parsedValueString] = await valid({ value: parsedValue, field });\n        return cache[parsedValueString] as ValidatorResult<T, any>;\n      } catch (error) {\n        return invalid({\n          message: error instanceof Error ? error.message : String(error),\n          value,\n          field,\n        });\n      }\n    };\n  };\n}\n\n/**\n * Captures basic validator test pattern\n * @param test Test function\n * @param message Error message\n * @param getExtras Optional extra fields for error message\n */\nexport function createValidatorTest<\n  T = any,\n  E = any,\n  P extends ValidatorMessageParameters<T> = ValidatorMessageParameters<T>,\n>(\n  test: (value: unknown, field?: string) => boolean,\n  message: ValidatorMessage<T, P>,\n  getExtras?: (value: T | null | undefined) => Omit<P, 'value' | 'field'>,\n): ValidatorTest<T, E> {\n  return async (value, field) => {\n    if (test(value, field)) {\n      return valid({ value: value as T, field });\n    }\n\n    return invalid({\n      message,\n      value,\n      field,\n      extras: getExtras ? getExtras(value as T) : undefined,\n    });\n  };\n}\n\n/**\n * Ensures a value is not undefined, null, empty string, NaN, nor invalid date.\n * @param message Error message\n * @param nullable Allow null values\n * @category Validation Tests\n */\nexport function required<T, P extends ValidatorMessageParameters<T>>(\n  message: ValidatorMessage<T, P>,\n  nullable?: boolean,\n): ValidatorTest<T> {\n  return createValidatorTest(\n    (value) =>\n      (nullable && value === null) ||\n      (value !== null &&\n        value !== undefined &&\n        !(typeof value === 'string' && value === '') &&\n        !(typeof value === 'number' && Number.isNaN(value)) &&\n        !(value instanceof Date && Number.isNaN(value.valueOf()))),\n    message,\n  );\n}\n\nexport type SharedValueType = string | number | unknown[];\n\n/**\n * Extracts a numeric amount from value, i.e. string length, array length, or number.\n * @internal\n */\nfunction getAmount(value: SharedValueType | null | undefined) {\n  return typeof value === 'string' || Array.isArray(value)\n    ? value.length\n    : value;\n}\n\nexport interface MaxValidatorMessageParameters\n  extends ValidatorMessageParameters<SharedValueType> {\n  max: number;\n  amount: number | null | undefined;\n  limit: number;\n  exclusive?: boolean | undefined;\n}\n\n/**\n * Ensures a string, number, or array value is at most a certain amount.\n * @param limit Size or value limit\n * @param message Error message\n * @param exclusive Use exclusive comparison instead of inclusive\n * @category Validation Tests\n */\nexport function max(\n  limit: number,\n  message: ValidatorMessage<SharedValueType, MaxValidatorMessageParameters>,\n  exclusive?: boolean,\n): ValidatorTest<SharedValueType> {\n  return createValidatorTest(\n    (value) => {\n      const amount = getAmount(value as SharedValueType);\n      return (\n        amount === undefined ||\n        amount === null ||\n        value === '' ||\n        (exclusive ? amount < limit : amount <= limit)\n      );\n    },\n    message,\n    (value) => ({\n      max: limit,\n      limit,\n      amount: getAmount(value),\n      exclusive,\n    }),\n  );\n}\n\nexport interface MinValidatorMessageParameters\n  extends ValidatorMessageParameters<SharedValueType> {\n  min: number;\n  limit: number;\n  amount: number | null | undefined;\n  exclusive?: boolean | undefined;\n}\n\n/**\n * Ensures a string, number, or array value is at most a certain amount.\n * @param limit Size or value limit\n * @param message Error message\n * @param exclusive Use exclusive comparison instead of inclusive\n * @category Validation Tests\n */\nexport function min(\n  limit: number,\n  message: ValidatorMessage<SharedValueType, MinValidatorMessageParameters>,\n  exclusive?: boolean,\n): ValidatorTest<SharedValueType> {\n  return createValidatorTest(\n    (value) => {\n      const amount = getAmount(value as SharedValueType);\n      return (\n        amount === undefined ||\n        amount === null ||\n        value === '' ||\n        (exclusive ? amount > limit : amount >= limit)\n      );\n    },\n    message,\n    (value) => ({\n      min: limit,\n      limit,\n      amount: getAmount(value),\n      exclusive,\n    }),\n  );\n}\n\nexport interface ExactValidatorMessageParameters\n  extends ValidatorMessageParameters<SharedValueType> {\n  limit: number;\n  amount: number | null | undefined;\n  exact: number;\n}\n\n/**\n * Ensures a string, number, or array value is exactly a certain amount.\n * @param limit Size or value limit\n * @param message Error message\n * @category Validation Tests\n */\nexport function exact(\n  limit: number,\n  message: ValidatorMessage<SharedValueType, ExactValidatorMessageParameters>,\n): ValidatorTest<SharedValueType> {\n  return createValidatorTest(\n    (value) => {\n      const amount = getAmount(value as SharedValueType);\n      return (\n        amount === undefined ||\n        amount === null ||\n        value === '' ||\n        amount === limit\n      );\n    },\n    message,\n    (value) => ({\n      amount: getAmount(value),\n      limit,\n      exact: limit,\n    }),\n  );\n}\n\nexport interface OneOfValidatorMessageParameters<T>\n  extends ValidatorMessageParameters<T> {\n  values: readonly T[];\n}\n\n/**\n * Ensures a value is one in a predefined list.\n * @param values List of allowed values.\n * @param message Error message\n * @category Validation Tests\n */\nexport function oneOf<T extends string | number | boolean | Date>(\n  values: readonly T[],\n  message: ValidatorMessage<T, OneOfValidatorMessageParameters<T>>,\n): ValidatorTest<T> {\n  return createValidatorTest(\n    (value) =>\n      value === undefined ||\n      value === null ||\n      values.includes(value as T) ||\n      (value instanceof Date &&\n        values.some((x) => x.valueOf() === value.valueOf())),\n    message,\n    () => ({ values }),\n  );\n}\n","import {\n  invalid,\n  valid,\n  type ConfigBase,\n  type ValidatorResult,\n  type ValidatorTest,\n} from './shared.js';\n\n/**\n * Invalid validation result for an item in the array\n * @category Types\n */\nexport type ArrayItemValidatorResult<E = unknown> = null | string | E;\n\n/**\n * Configuration for array validation.\n * @category Types\n */\nexport type ArrayConfig = ConfigBase<unknown[]>;\n\n/**\n * Parses a value into an array.\n * @param value Value to parse\n * @category Parsers\n */\nexport function parseArray(value: unknown): unknown[] | null | undefined {\n  if (Array.isArray(value)) {\n    return value as unknown[];\n  }\n\n  if (value === null || value === undefined) {\n    return value;\n  }\n\n  const iterable = value as Iterable<unknown>;\n\n  if (iterable[Symbol.iterator]) {\n    return [...iterable];\n  }\n\n  return [];\n}\n\n/**\n * Applies a configuration to the array value.\n * @param value Value to modify\n * @param config Configuration to apply\n * @category Helpers\n */\nexport function applyArrayConfig<T>(\n  config: ArrayConfig,\n  value: unknown,\n): T[] | null | undefined {\n  let parsedValue = config.parser(value);\n  if (\n    config.default !== undefined &&\n    (parsedValue === undefined ||\n      parsedValue === null ||\n      parsedValue.length === 0)\n  ) {\n    parsedValue = config.default;\n  }\n\n  return parsedValue as T[];\n}\n\n/**\n * Validates an array. The first passed validator is used to validate individual\n * items. The remaining validators target the array itself.\n * @category Type Validators\n */\nexport function array<T, E>(\n  config?: Partial<ArrayConfig> | ValidatorTest<T, E>,\n  ...tests: ValidatorTest[]\n): ValidatorTest<T[], string | ArrayItemValidatorResult<E>[]> {\n  let allTests = tests;\n  let finalConfig: ArrayConfig = {\n    parser: parseArray,\n  };\n\n  if (config !== undefined) {\n    if (typeof config === 'function') {\n      allTests = [config, ...tests];\n    } else {\n      finalConfig = {\n        ...finalConfig,\n        ...config,\n      };\n    }\n  }\n\n  return async (value, field) => {\n    const arrayValue = applyArrayConfig<T>(finalConfig, value);\n    let arrayInvalidResult: ValidatorResult | undefined;\n    let isValid = true;\n    const errors: ArrayItemValidatorResult[] = [];\n    const [validateItem, ...arrayTests] = allTests;\n\n    for (const validatorTest of arrayTests) {\n      const result = await validatorTest(arrayValue, field);\n      if (result.state === 'invalid') {\n        isValid = false;\n        arrayInvalidResult = result;\n        break;\n      }\n    }\n\n    if (arrayValue && validateItem) {\n      for (const [index, item] of arrayValue.entries()) {\n        const result = await validateItem(\n          item,\n          field ? `${field}[${index}]` : `[${index}]`,\n        );\n\n        if (result.state === 'invalid') {\n          isValid = false;\n          errors.push(result.message || result.errors);\n        } else {\n          errors.push(null);\n        }\n      }\n    }\n\n    if (isValid) {\n      return valid({\n        value: arrayValue,\n        field,\n      });\n    }\n\n    return invalid<T[], ArrayItemValidatorResult<E>[]>({\n      message:\n        arrayInvalidResult?.state === 'invalid'\n          ? arrayInvalidResult.message\n          : '',\n      value,\n      field,\n      errors: errors as ArrayItemValidatorResult<E>[],\n    });\n  };\n}\n","import { type ConfigBase, createTypeValidatorTest } from './shared.js';\n\n/**\n * Parses a value into a boolean.\n * @param value Value to parse\n * @category Parsers\n */\nexport function parseBoolean(value: unknown): boolean | null | undefined {\n  if (value === undefined || value === null) {\n    return value;\n  }\n\n  if (typeof value === 'boolean') {\n    return value;\n  }\n\n  return Boolean(value);\n}\n\n/**\n * Applies a configuration to the boolean value.\n * @param value Value to modify\n * @param config Configuration to apply\n * @category Helpers\n */\nexport function applyBooleanConfig(\n  value: unknown,\n  config: BooleanConfig,\n): boolean | null | undefined {\n  let parsedValue = config.parser(value);\n  if (\n    config.default !== undefined &&\n    (parsedValue === undefined || parsedValue === null)\n  ) {\n    parsedValue = config.default;\n  }\n\n  return parsedValue;\n}\n\n/**\n * Configuration for boolean validation.\n * @category Types\n */\nexport type BooleanConfig = ConfigBase<boolean>;\n\n/**\n * Validates a boolean value.\n * @category Type Validators\n */\nexport const boolean = createTypeValidatorTest(\n  { parser: parseBoolean },\n  applyBooleanConfig,\n);\n","import {\n  createTypeValidatorTest,\n  createValidatorTest,\n  type ConfigBase,\n  type ValidatorMessage,\n  type ValidatorMessageParameters,\n  type ValidatorTest,\n} from './shared.js';\n\n/** Badly formatted date for internal use. */\nexport const invalidDate = new Date('');\n\n/** @internal */\nconst isoDatePattern =\n  /^(\\d{4})(?:-([0-2]\\d)(?:-([0-3]\\d)(?:[ T]([0-2]\\d):([0-5]\\d)(?::([0-5]\\d)(\\.\\d+)?(Z|[+-][0-2]\\d:?[0-5]\\d)?)?)?)?)?$/;\n\n/** @internal */\nconst timezonePattern = /^([+-])([0-2]\\d):?([0-5]\\d)$/;\n\n/**\n * Parses a timezone string.\n * @param timezone Timezone to parse\n * @internal\n */\nfunction parseTimezone(timezone: string): number {\n  const parts = timezonePattern.exec(timezone);\n\n  if (timezone === 'Z' || !parts) {\n    return 0;\n  }\n\n  const [, sign, hour = '0', minute = '0'] = parts;\n  const multiplier = sign === '-' ? -1 : 1;\n  const hoursInMinutes = Number.parseInt(hour, 10) * 60;\n  const offset = hoursInMinutes + Number.parseInt(minute, 10);\n\n  return multiplier * offset;\n}\n\nconst BASE = 10;\n\nconst dateParts = [\n  // Skip\n  () => 0,\n  // Year\n  (part = '0') => Number.parseInt(part, BASE),\n  // Month\n  (part = '1') => Number.parseInt(part, BASE) - 1,\n  // Day\n  (part = '1') => Number.parseInt(part, BASE),\n  // Hour\n  (part = '0') => Number.parseInt(part, BASE),\n  // Minute\n  (part = '0') => Number.parseInt(part, BASE),\n  // Second\n  (part = '0') => Number.parseInt(part, BASE),\n  // Millisecond\n  (part = '0') => Number.parseFloat(part) * 1e3,\n];\n\n/**\n * Parses a value into a date.\n * @param value Value to parse\n * @category Parsers\n */\nexport function parseDate(value: unknown): Date | null | undefined {\n  if (value === null || value === undefined) {\n    return value;\n  }\n\n  if (value instanceof Date) {\n    return value;\n  }\n\n  if (typeof value === 'number') {\n    return new Date(value);\n  }\n\n  if (typeof value !== 'string') {\n    return invalidDate;\n  }\n\n  const parts = isoDatePattern.exec(value);\n\n  if (parts === null) {\n    return invalidDate;\n  }\n\n  const [\n    ,\n    year = 0,\n    month = 0,\n    day = 0,\n    hour = 0,\n    minute = 0,\n    second = 0,\n    millisecond = 0,\n  ] = dateParts.map((parse, index) => parse(parts[index]));\n\n  const timezone = parts[8];\n\n  if (!timezone) {\n    return new Date(year, month, day, hour, minute, second, millisecond);\n  }\n\n  const minuteOffset = parseTimezone(timezone);\n\n  return new Date(\n    Date.UTC(\n      year,\n      month,\n      day,\n      hour,\n      minute + minuteOffset,\n      second,\n      millisecond,\n    ),\n  );\n}\n\n/**\n * Applies a configuration to the date value.\n * @param value Value to modify\n * @param config Configuration to apply\n * @category Helpers\n */\nexport function applyDateConfig(\n  value: unknown,\n  config: DateConfig,\n): Date | null | undefined {\n  let parsedValue = config.parser(value);\n  if (\n    config.default !== undefined &&\n    (parsedValue === undefined ||\n      parsedValue === null ||\n      Number.isNaN(parsedValue.getTime()))\n  ) {\n    parsedValue = config.default;\n  }\n\n  return parsedValue;\n}\n\nexport type SharedDateValueType = Date | string | number;\n\nexport interface MinDateValidatorMessageParameters\n  extends ValidatorMessageParameters<Date> {\n  min: Date | null | undefined;\n  limit: Date | null | undefined;\n  exclusive?: boolean | undefined;\n}\n\n/**\n * Ensures a date value is on or after a date.\n * @param limit Minimum date\n * @param message Error message\n * @param exclusive Makes comparison exclusive instead of inclusive\n * @category Validation Tests\n */\nexport function minDate(\n  limit: SharedDateValueType,\n  message: ValidatorMessage<Date, MinDateValidatorMessageParameters>,\n  exclusive?: boolean,\n): ValidatorTest<Date, null> {\n  const parsedDate = parseDate(limit);\n  return createValidatorTest(\n    (value) =>\n      parsedDate !== null &&\n      parsedDate !== undefined &&\n      (value === null ||\n        value === undefined ||\n        (value instanceof Date &&\n          (exclusive ? value > parsedDate : value >= parsedDate))),\n    message,\n    () => ({\n      min: parsedDate,\n      limit: parsedDate,\n      exclusive,\n    }),\n  );\n}\n\nexport interface MaxDateValidatorMessageParameters\n  extends ValidatorMessageParameters<Date> {\n  max: Date | null | undefined;\n  limit: Date | null | undefined;\n  exclusive?: boolean | undefined;\n}\n\n/**\n * Ensures a date value is on or before a date.\n * @param limit Maximum date\n * @param message Error message\n * @param exclusive Makes comparison exclusive instead of inclusive\n * @category Validation Tests\n */\nexport function maxDate(\n  limit: SharedDateValueType,\n  message: ValidatorMessage<Date, MaxDateValidatorMessageParameters>,\n  exclusive?: boolean,\n): ValidatorTest<Date> {\n  const parsedDate = parseDate(limit);\n  return createValidatorTest(\n    (value) =>\n      parsedDate !== null &&\n      parsedDate !== undefined &&\n      (value === null ||\n        value === undefined ||\n        (value instanceof Date &&\n          (exclusive ? value < parsedDate : value <= parsedDate))),\n    message,\n    () => ({\n      max: parsedDate,\n      limit: parsedDate,\n      exclusive,\n    }),\n  );\n}\n\n/**\n * Configuration for date validation.\n * @category Types\n */\nexport type DateConfig = ConfigBase<Date>;\n\n/**\n * Validates a date value.\n * @category Type Validators\n */\nexport const date = createTypeValidatorTest(\n  { parser: parseDate },\n  applyDateConfig,\n);\n","import {\n  type ConfigBase,\n  createTypeValidatorTest,\n  invalid,\n  valid,\n  type ValidatorMessage,\n  type ValidatorTest,\n} from './shared.js';\n\n/**\n * Parses a value into a number.\n * @param value Value to parse\n * @category Parsers\n */\nexport function parseNumber(value: unknown): number | null | undefined {\n  if (value === null || value === undefined) {\n    return value;\n  }\n\n  if (typeof value === 'number') {\n    return value;\n  }\n\n  if (value instanceof Date) {\n    return value.getTime();\n  }\n\n  if (typeof value === 'string') {\n    return Number.parseFloat(value);\n  }\n\n  return Number.parseFloat(String(value));\n}\n\n/**\n * Applies a configuration to the number value.\n * @param value Value to modify\n * @param config Configuration to apply\n * @category Helpers\n */\nexport function applyNumberConfig(\n  value: unknown,\n  config: NumberConfig,\n): number | null | undefined {\n  let parsedValue = config.parser(value);\n  if (\n    config.default !== undefined &&\n    (parsedValue === undefined ||\n      parsedValue === null ||\n      Number.isNaN(parsedValue))\n  ) {\n    parsedValue = config.default;\n  }\n\n  if (config.round && typeof parsedValue === 'number') {\n    switch (config.round) {\n      case 'nearest': {\n        parsedValue = Math.round(parsedValue);\n        break;\n      }\n      case 'ceil': {\n        parsedValue = Math.ceil(parsedValue);\n        break;\n      }\n      case 'floor': {\n        parsedValue = Math.floor(parsedValue);\n        break;\n      }\n      default: {\n        throw new Error(`Unknown round type: ${String(config.round)}`);\n      }\n    }\n  }\n\n  return parsedValue;\n}\n\n/**\n * Ensures a number value is an integer.\n * @param message Error message\n * @category Validation Tests\n */\nexport function integer(\n  message: ValidatorMessage<number>,\n): ValidatorTest<number> {\n  return async (value, field) => {\n    if (\n      value === undefined ||\n      value === null ||\n      (typeof value === 'number' &&\n        Number.isFinite(value) &&\n        Math.floor(value) === value)\n    ) {\n      return valid({ value, field });\n    }\n\n    return invalid({\n      message,\n      value,\n      field,\n    });\n  };\n}\n\n/**\n * Configuration for number validation.\n * @category Types\n */\nexport interface NumberConfig extends ConfigBase<number> {\n  /** Apply rounding mechanism before validation. */\n  round?: 'nearest' | 'floor' | 'ceil';\n}\n\n/**\n * Validates a number value.\n * @category Type Validators\n */\nexport const number = createTypeValidatorTest(\n  {\n    parser: parseNumber,\n  },\n  applyNumberConfig,\n);\n","import {\n  type ExtractError,\n  type ExtractValue,\n  hasOwnProperty,\n  invalid,\n  valid,\n  type ValidatorTest,\n} from './shared.js';\n\nexport type ObjectParameter = Record<string, ValidatorTest<unknown, unknown>>;\n\n/**\n * Validates an object.\n * @category Type Validators\n */\nexport function object<\n  P extends ObjectParameter,\n  V extends { [K in keyof P]?: ExtractValue<P[K]> },\n  E extends { [K in keyof P]?: ExtractError<P[K]> },\n>(properties: P): ValidatorTest<V, E> {\n  if (typeof properties !== 'object' || properties === null) {\n    throw new TypeError('`properties` must be a configuration object');\n  }\n\n  return async (values, field) => {\n    const definedValues = (values ?? {}) as V;\n    const errors = {} as E;\n    const resolvedValues = {} as V;\n    let isValid = true;\n\n    for (const key in properties) {\n      if (hasOwnProperty(properties, key)) {\n        const validator = properties[key];\n        const value = definedValues[key];\n        const result =\n          typeof validator === 'function'\n            ? await validator(value, key)\n            : await invalid({ field: key, message: 'No validator set', value });\n\n        resolvedValues[key] = result.value as V[Extract<keyof P, string>];\n\n        if (result.state === 'invalid') {\n          isValid = false;\n          errors[key] = (result.message || result.errors) as E[Extract<\n            keyof P,\n            string\n          >];\n        }\n      }\n    }\n\n    if (isValid) {\n      return valid({ value: resolvedValues, field });\n    }\n\n    return invalid({\n      message: '',\n      value: values,\n      field,\n      errors,\n    });\n  };\n}\n","import {\n  type ConfigBase,\n  createTypeValidatorTest,\n  createValidatorTest,\n  isObject,\n  type ValidatorMessage,\n  type ValidatorMessageParameters,\n  type ValidatorTest,\n} from './shared.js';\n\n/** @internal */\nconst emailPattern =\n  /^[\\w!#$%&'*+./=?^`{|}~-]+@[\\dA-Za-z](?:[\\dA-Za-z-]{0,61}[\\dA-Za-z])?(?:\\.[\\dA-Za-z](?:[\\dA-Za-z-]{0,61}[\\dA-Za-z])?)*$/;\n\n/**\n * Configuration for string validation.\n * @category Types\n */\nexport interface StringConfig extends ConfigBase<string> {\n  /** Apply trim to string before validation. */\n  trim?: boolean;\n}\n\n/**\n * Parses a value into a string.\n * @param value Value to parse\n * @category Parsers\n */\nexport function parseString(value: unknown): string | null | undefined {\n  if (value === null || value === undefined) {\n    return value;\n  }\n\n  if (typeof value === 'string') {\n    return value;\n  }\n\n  if (value instanceof Date) {\n    return value.toISOString();\n  }\n\n  if (isObject(value)) {\n    throw new TypeError('Failed to parse value to string.');\n  }\n\n  return String(value);\n}\n\n/**\n * Applies a configuration to the string value.\n * @param value Value to modify\n * @param config Configuration to apply\n * @category Helpers\n */\nexport function applyStringConfig(\n  value: unknown,\n  config: StringConfig,\n): string | null | undefined {\n  let parsedValue = config.parser(value);\n  if (\n    config.default !== undefined &&\n    (parsedValue === undefined || parsedValue === null || parsedValue === '')\n  ) {\n    parsedValue = config.default;\n  }\n\n  if (config.trim && typeof parsedValue === 'string') {\n    parsedValue = parsedValue.trim();\n  }\n\n  return parsedValue;\n}\n\nexport interface MatchesValidatorMessageParameters\n  extends ValidatorMessageParameters<string> {\n  pattern: RegExp;\n}\n\n/**\n * Ensures a string value matches a pattern\n * @param pattern Pattern to match\n * @param message Error message\n * @category Validation Tests\n */\nexport function matches(\n  pattern: RegExp,\n  message: ValidatorMessage<string, MatchesValidatorMessageParameters>,\n): ValidatorTest<string> {\n  return createValidatorTest(\n    (value) =>\n      value === undefined ||\n      value === null ||\n      value === '' ||\n      (typeof value === 'string' && pattern.test(value)),\n    message,\n    () => ({ pattern }),\n  );\n}\n\n/**\n * Ensures a string value matches an email pattern\n * @param message Error message\n * @category Validation Tests\n */\nexport function email(\n  message: ValidatorMessage<string>,\n): ValidatorTest<string> {\n  return matches(emailPattern, message);\n}\n\n/**\n * Ensures a string value is a valid URL\n * @param message Error message\n * @param protocols Optional list of protocols to allow\n * @category Validation Tests\n */\nexport function url(\n  message: ValidatorMessage<string>,\n  protocols?: string[],\n): ValidatorTest<string> {\n  return createValidatorTest(\n    (value) => {\n      try {\n        let url: URL | undefined;\n        if (\n          value === undefined ||\n          value === null ||\n          value === '' ||\n          (typeof value === 'string' && (url = new URL(value)))\n        ) {\n          return !(url && protocols && !protocols.includes(url.protocol));\n        }\n      } catch {\n        // Do nothing\n      }\n\n      return false;\n    },\n    message,\n    () => ({ protocols }),\n  );\n}\n\n/**\n * Validates a string value.\n * @category Type Validators\n */\nexport const string = createTypeValidatorTest(\n  {\n    parser: parseString,\n  },\n  applyStringConfig,\n);\n"],"mappings":"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","names":["src_exports","__export","applyArrayConfig","applyBooleanConfig","applyDateConfig","applyNumberConfig","applyStringConfig","array","boolean","createTypeValidatorTest","createValidatorTest","date","email","exact","formatMessage","hasOwnProperty","integer","invalid","invalidDate","isObject","matches","max","maxDate","min","minDate","number","object","oneOf","parseArray","parseBoolean","parseDate","parseNumber","parseString","required","string","url","valid","__toCommonJS","isObject","value","hasOwnProperty","object","property","formatPattern","formatMessage","template","parameters","_","key","valid","field","invalid","errors","message","extras","createTypeValidatorTest","defaultConfig","applyConfig","config","tests","cache","finalConfig","allTests","parsedValue","parsedValueString","validatorTest","result","error","createValidatorTest","test","getExtras","required","nullable","getAmount","max","limit","exclusive","amount","min","exact","oneOf","values","x","parseArray","value","iterable","applyArrayConfig","config","parsedValue","array","tests","allTests","finalConfig","field","arrayValue","arrayInvalidResult","isValid","errors","validateItem","arrayTests","validatorTest","result","index","item","valid","invalid","parseBoolean","value","applyBooleanConfig","config","parsedValue","boolean","createTypeValidatorTest","invalidDate","isoDatePattern","timezonePattern","parseTimezone","timezone","parts","sign","hour","minute","multiplier","offset","BASE","dateParts","part","parseDate","value","year","month","day","second","millisecond","parse","index","minuteOffset","applyDateConfig","config","parsedValue","minDate","limit","message","exclusive","parsedDate","createValidatorTest","maxDate","date","createTypeValidatorTest","parseNumber","value","applyNumberConfig","config","parsedValue","integer","message","field","valid","invalid","number","createTypeValidatorTest","object","properties","values","field","definedValues","errors","resolvedValues","isValid","key","hasOwnProperty","validator","value","result","invalid","valid","emailPattern","parseString","value","isObject","applyStringConfig","config","parsedValue","matches","pattern","message","createValidatorTest","email","url","protocols","string","createTypeValidatorTest"]}