bguard 0.6.0 → 0.7.1

package/lib/chunk-LDZFOOWN.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core.ts"],"sourcesContent":["import { isValidDateInner } from './helpers/isValidDateInner';\nimport {\n  BaseType,\n  MetaContext,\n  TransformCallback,\n  TranslationErrorMap,\n  ValidationErrorData,\n  WithArray,\n  WithBGuardType,\n  WithDefault,\n  WithInput,\n  WithNull,\n  WithObject,\n  WithRecord,\n  WithTuple,\n  WithUndefined,\n} from './commonTypes';\nimport { type InferInput, type InferType } from './InferType';\nimport { BuildSchemaError, ValidationError } from './exceptions';\nimport { getTranslationByLocale } from './translationMap';\nimport { ctxSymbol } from './helpers/constants';\nimport type { StandardSchemaProps, StandardSchemaResult } from './standardSchema';\n\nconst replacePlaceholdersRegex = /{{(.*?)}}/g;\n\nfunction replacePlaceholders(template: string, replacements: Record<string, unknown>): string {\n  return template.replace(replacePlaceholdersRegex, (_, key) => {\n    return key in replacements ? `${replacements[key] as string}` : `{{${key}}}`;\n  });\n}\n\nexport class ExceptionContext {\n  constructor(\n    public readonly initialReceived: unknown,\n    public readonly t: TranslationErrorMap,\n    public readonly pathToError: string,\n    public readonly errors?: ValidationErrorData[],\n    public readonly meta?: MetaContext,\n    /** The same location as `pathToError`, as keys. A string path cannot be taken apart again\n     * reliably, because a key may itself contain a dot or a bracket. */\n    public readonly path: readonly PropertyKey[] = [],\n    /** Where async validations are collected. Absent during a synchronous parse, which is how one\n     * is detected and reported rather than silently skipped. */\n    public readonly pending?: PendingValidation[],\n  ) {}\n\n  /**\n   * The same location, reporting into a different errors list.\n   *\n   * A union tries each member against a throwaway list so a member that does not match is not fatal.\n   * An async validation reached inside the winning member is awaited long after that decision, so it\n   * has to be re-pointed at the real list or its issues would be collected where nobody reads them.\n   */\n  withErrors(errors?: ValidationErrorData[]) {\n    return new ExceptionContext(\n      this.initialReceived,\n      this.t,\n      this.pathToError,\n      errors,\n      this.meta,\n      this.path,\n      this.pending,\n    );\n  }\n\n  /**\n   * Records async validations to be awaited once the walk is over.\n   *\n   * Throws during a synchronous parse rather than dropping them: a validation that never runs is worse\n   * than a clear instruction to use parseAsync.\n   */\n  enqueueAsync(validations: AsyncRequiredValidation[], received: unknown) {\n    if (!this.pending) throw new BuildSchemaError('Schema has an async validation. Use parseAsync or parseOrFailAsync');\n\n    this.pending.push({ validations, received, ctx: this });\n  }\n\n  /**\n   * Descends into a property or an index, deriving both forms of the location from the same key so\n   * they cannot disagree.\n   */\n  createChild(pathSegment: PropertyKey, childMeta?: MetaContext) {\n    const childPathToError =\n      typeof pathSegment === 'number'\n        ? `${this.pathToError}[${pathSegment}]`\n        : `${this.pathToError}.${String(pathSegment)}`;\n\n    return new ExceptionContext(\n      this.initialReceived,\n      this.t,\n      childPathToError,\n      this.errors,\n      childMeta,\n      [...this.path, pathSegment],\n      this.pending,\n    );\n  }\n\n  public ref(path: string): unknown {\n    let ref: unknown = this.initialReceived;\n\n    for (const el of path.split('.')) {\n      // A path that runs past the end of the data yields undefined. Indexing straight into it threw\n      // a TypeError, which parseOrFail turned into a bare 'Something unexpected happened' with no\n      // indication of which assert or which path was at fault.\n      if (ref === null || ref === undefined) return undefined;\n      ref = (ref as Record<string, unknown>)[el];\n    }\n\n    return ref;\n  }\n\n  public addIssue(expected: unknown, received: unknown, messageKey: string): never | void {\n    const rawMessage = this.t[messageKey] ?? messageKey;\n    const message = replacePlaceholders(rawMessage, { e: expected, r: received, p: this.pathToError });\n\n    if (this.errors) {\n      this.errors.push({\n        expected,\n        received,\n        pathToError: this.pathToError,\n        path: this.path,\n        code: messageKey,\n        message,\n        meta: this.meta,\n      });\n\n      return;\n    }\n\n    throw new ValidationError(expected, received, this.pathToError, message, this.meta, this.path, messageKey);\n  }\n}\n\n/**\n * A validation function run against an already type-checked value.\n *\n * `T` is the value the assert knows how to inspect, and it is what stops a string assert from\n * being attached to a number schema: `custom` asks for `RequiredValidation<AssertInput<this>>`,\n * and function parameters are compared contravariantly under `strictFunctionTypes`.\n *\n * An assert that genuinely accepts anything should declare `RequiredValidation<unknown>`, which\n * stays assignable to every schema. The default of `any` is deliberate, so that custom asserts\n * written against the previous signature keep compiling.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type RequiredValidation<T = any> = (received: T, ctx: ExceptionContext) => void;\n\n/**\n * A validation that has to wait for something — a database lookup, an HTTP call.\n *\n * Registered with `customAsync` and run by `parseAsync`. Asserts only add issues, they never change the\n * value, so the value the synchronous walk produced is already final by the time these run.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type AsyncRequiredValidation<T = any> = (received: T, ctx: ExceptionContext) => Promise<void>;\n\n/** An async validation that has been reached, waiting to be awaited once the walk is over. */\ninterface PendingValidation {\n  validations: AsyncRequiredValidation[];\n  received: unknown;\n  ctx: ExceptionContext;\n}\n\n/**\n * The runtime value a schema hands to its asserts. Nullish is stripped, because `innerCheck`\n * returns before running asserts when the value is `null` or `undefined`.\n */\nexport type AssertInput<T> =\n  T extends WithBGuardType<unknown, infer Y>\n    ? NonNullable<Y>\n    : T extends WithArray<unknown, unknown>\n      ? unknown[]\n      : T extends WithTuple<unknown, unknown>\n        ? unknown[]\n        : T extends WithObject<unknown, unknown>\n          ? Record<string, unknown>\n          : T extends WithRecord<unknown, unknown, unknown>\n            ? Record<string, unknown>\n            : unknown;\n\n/**\n * Runs a schema's own assertions. The async ones are only enqueued: they are awaited after the walk,\n * so a slow check never holds up the structural validation around it.\n */\nfunction runValidations(schemaData: ValidatorContext, receivedValue: unknown, exCtx: ExceptionContext) {\n  schemaData.requiredValidations.forEach((requiredValidation) => {\n    requiredValidation(receivedValue, exCtx);\n  });\n\n  if (schemaData.asyncValidations?.length) exCtx.enqueueAsync(schemaData.asyncValidations, receivedValue);\n}\n\nfunction innerCheck(schema: CommonSchema, receivedValue: unknown, exCtx: ExceptionContext): unknown {\n  const schemaData = schema[ctxSymbol];\n\n  // Nothing to transform when the value is absent. Running the list anyway turned `undefined` into\n  // whatever the callback made of it, so an optional string with a `val + ''` transform parsed to\n  // the string 'undefined'.\n  if (receivedValue !== undefined) {\n    schemaData.transformListBefore?.forEach((transformCallback) => {\n      receivedValue = transformCallback(receivedValue);\n    });\n  }\n\n  if (receivedValue === undefined) {\n    if (schemaData.defaultValue === undefined) {\n      if (!schemaData.isOptional) exCtx.addIssue('Required', receivedValue, 'c:optional');\n      return receivedValue;\n    }\n\n    // Carry on with the default as the received value rather than returning it. Returning it handed\n    // every parse the same array or object, so mutating one result changed what later parses gave\n    // back; going through validation rebuilds containers and yields a fresh value each time.\n    receivedValue = schemaData.defaultValue;\n  }\n\n  if (receivedValue === null) {\n    if (!schemaData.isNullable) exCtx.addIssue('Not null', receivedValue, 'c:nullable');\n    return receivedValue;\n  }\n\n  if (schemaData.date) {\n    if (!isValidDateInner(receivedValue)) exCtx.addIssue('Date', receivedValue, 'c:date');\n  }\n\n  const typeOfVal = typeof receivedValue;\n\n  if (schemaData.type.length) {\n    if (!schemaData.type.includes(typeOfVal)) exCtx.addIssue(schemaData.type, typeOfVal, 'c:invalidType');\n    // NaN is a number by typeof, and every comparison against it is false, so it slipped past\n    // min, max, positive and negative alike.\n    else if (typeOfVal === 'number' && Number.isNaN(receivedValue)) exCtx.addIssue('number', receivedValue, 'c:nan');\n  }\n\n  if (schemaData.lazy) {\n    // Resolved on first use rather than at construction, which is what lets a schema refer to\n    // itself. The result is cached on the context so the thunk runs once.\n    schemaData.lazy.resolved ??= schemaData.lazy.getSchema();\n\n    if (!(schemaData.lazy.resolved instanceof CommonSchema))\n      throw new BuildSchemaError('Invalid schema returned from lazy method');\n\n    return innerCheck(schemaData.lazy.resolved, receivedValue, exCtx);\n  }\n\n  if (schemaData.tuple) {\n    if (!Array.isArray(receivedValue)) return exCtx.addIssue('Array', receivedValue, 'c:array');\n\n    runValidations(schemaData, receivedValue, exCtx);\n\n    if (receivedValue.length !== schemaData.tuple.length) {\n      // Reported and then abandoned: walking the declared positions as well would add a \"required\"\n      // error for every position the value does not reach, which says nothing further.\n      exCtx.addIssue(schemaData.tuple.length, receivedValue.length, 'c:tupleLength');\n      return receivedValue;\n    }\n\n    const parsedTuple: unknown[] = [];\n\n    for (let i = 0; i < schemaData.tuple.length; i++) {\n      const positionSchema = schemaData.tuple[i] as CommonSchema;\n      parsedTuple.push(\n        innerCheck(\n          positionSchema,\n          receivedValue[i],\n          exCtx.createChild(i, positionSchema[ctxSymbol].meta ?? schemaData.meta),\n        ),\n      );\n    }\n\n    return parsedTuple;\n  }\n\n  if (schemaData.union) {\n    // The union's own asserts see the value whichever member ends up matching, so they are declared\n    // over `unknown` and run before any member is tried.\n    runValidations(schemaData, receivedValue, exCtx);\n\n    const attemptErrors: ValidationErrorData[] = [];\n    for (const memberSchema of schemaData.union) {\n      const errorsBefore = attemptErrors.length;\n      // Async validations reached inside a member are collected separately and only kept if that member\n      // wins. Sharing the outer list would let a rejected member's validations run and report issues.\n      const attemptPending: PendingValidation[] = [];\n      // Each member is tried against a context that collects instead of throwing, so a member that\n      // does not match is not fatal. Only a member that produces nothing wins.\n      const attemptCtx = new ExceptionContext(\n        exCtx.initialReceived,\n        exCtx.t,\n        exCtx.pathToError,\n        attemptErrors,\n        schemaData.meta,\n        // Carried over, so an async validation inside the winning member keeps the right location.\n        exCtx.path,\n        exCtx.pending && attemptPending,\n      );\n\n      const parsedMember = innerCheck(memberSchema, receivedValue, attemptCtx);\n      if (attemptErrors.length === errorsBefore) {\n        for (const entry of attemptPending) {\n          exCtx.pending?.push({ ...entry, ctx: entry.ctx.withErrors(exCtx.errors) });\n        }\n\n        return parsedMember;\n      }\n    }\n\n    exCtx.addIssue('One of the union members', receivedValue, 'c:union');\n    return receivedValue;\n  }\n\n  if (schemaData.record) {\n    if (typeOfVal !== 'object' || Array.isArray(receivedValue)) {\n      if (Array.isArray(receivedValue)) {\n        exCtx.addIssue('Object', receivedValue, 'c:objectTypeAsArray');\n      } else {\n        exCtx.addIssue('Object', receivedValue, 'c:objectType');\n      }\n\n      return receivedValue;\n    }\n\n    runValidations(schemaData, receivedValue, exCtx);\n\n    const { key: keySchema, value: valueSchema } = schemaData.record;\n    const parsedRecord: Record<string, unknown> = {};\n\n    for (const [receivedKey, receivedRecordValue] of Object.entries(receivedValue as Record<string, unknown>)) {\n      const childCtx = exCtx.createChild(receivedKey, schemaData.meta);\n\n      // Keys are validated too, which is what makes a restricted key type meaningful.\n      innerCheck(keySchema, receivedKey, childCtx);\n      parsedRecord[receivedKey] = innerCheck(valueSchema, receivedRecordValue, childCtx);\n    }\n\n    return parsedRecord;\n  }\n\n  if (schemaData.array) {\n    if (!Array.isArray(receivedValue)) return exCtx.addIssue('Array', receivedValue, 'c:array');\n\n    runValidations(schemaData, receivedValue, exCtx);\n\n    const schema = schemaData.array;\n    const parsedReceivedValue: unknown[] = [];\n    // Indexed rather than forEach, which skips holes: a sparse array used to come back shorter than\n    // it went in, with no error to say so. A hole now reaches innerCheck as undefined and is\n    // reported unless the element schema is optional.\n    for (let i = 0; i < receivedValue.length; i++) {\n      const parsedElement = innerCheck(\n        schema,\n        receivedValue[i],\n        // The element's own metadata wins; the array's is inherited when it has none.\n        exCtx.createChild(i, schema[ctxSymbol].meta ?? schemaData.meta),\n      );\n      parsedReceivedValue.push(parsedElement);\n    }\n\n    return parsedReceivedValue;\n  }\n\n  if (schemaData.object) {\n    if (typeOfVal !== 'object' || Array.isArray(receivedValue)) {\n      // Reported and then abandoned. When errors are collected rather than thrown, walking the\n      // shape of a non-object went on to invent one \"unrecognized property\" per string index and\n      // one \"missing property\" per declared key, so a single wrong type produced seven errors.\n      if (Array.isArray(receivedValue)) {\n        exCtx.addIssue('Object', receivedValue, 'c:objectTypeAsArray');\n      } else {\n        exCtx.addIssue('Object', receivedValue, 'c:objectType');\n      }\n\n      return receivedValue;\n    }\n\n    runValidations(schemaData, receivedValue, exCtx);\n\n    const shapeSchema = schemaData.object;\n    const parsedReceivedValue: Record<string, unknown> = {};\n    // Null was handled above and the type guard just ruled out arrays and non-objects.\n    const receivedObject = receivedValue as Record<string, unknown>;\n\n    if (!schemaData.allowUnrecognizedObjectProps) {\n      for (const keyPerReceivedValue of Object.keys(receivedObject)) {\n        // An own-property check, not an undefined check: `constructor`, `toString` and `__proto__`\n        // all resolve on Object.prototype, so a plain lookup accepted them as declared properties\n        // and then dropped them from the output. Spelled out rather than via Object.hasOwn, which\n        // would add a runtime floor the package does not otherwise require.\n        if (!Object.prototype.hasOwnProperty.call(shapeSchema, keyPerReceivedValue))\n          exCtx.addIssue('Unrecognized property', keyPerReceivedValue, 'c:unrecognizedProperty');\n      }\n    }\n\n    for (const [keyOfSchema, valueOfSchema] of Object.entries(shapeSchema)) {\n      const valueSchemaData = valueOfSchema[ctxSymbol];\n      const receivedObjectValuePropery = receivedObject[keyOfSchema];\n      if (\n        receivedObjectValuePropery === undefined &&\n        !valueSchemaData.isOptional &&\n        // A property with a default is not missing: innerCheck substitutes the value below. The\n        // check used to run first and reject it, so default() could never apply to a property.\n        valueSchemaData.defaultValue === undefined\n      ) {\n        // Reported at the property's own path, not the container's. Reporting it on the container\n        // gave every missing property the same empty path, so neither an error list nor a Standard\n        // Schema consumer could tell which field was missing — or tell two of them apart.\n        exCtx\n          .createChild(keyOfSchema, valueSchemaData.meta ?? schemaData.meta)\n          .addIssue('Required', receivedObjectValuePropery, 'c:requiredProperty');\n\n        // Stop here, or innerCheck reports the same missing value again as 'c:optional'.\n        continue;\n      }\n\n      const parsedReceivedObjectValuePropery = innerCheck(\n        valueOfSchema,\n        receivedObjectValuePropery,\n        exCtx.createChild(keyOfSchema, valueSchemaData.meta ?? schemaData.meta),\n      );\n\n      // Only carried over when there is something to carry. Assigning unconditionally gave an absent\n      // optional property a present key holding undefined, so `Object.keys` and `in` reported a field\n      // nobody sent — invisible through JSON.stringify, which drops such keys. A property the input\n      // did hold is kept even when its value is undefined, and one with a default has a value by now.\n      if (\n        parsedReceivedObjectValuePropery !== undefined ||\n        Object.prototype.hasOwnProperty.call(receivedObject, keyOfSchema)\n      ) {\n        parsedReceivedValue[keyOfSchema] = parsedReceivedObjectValuePropery;\n      }\n    }\n\n    return parsedReceivedValue;\n  }\n\n  runValidations(schemaData, receivedValue, exCtx);\n\n  return receivedValue;\n}\n\nexport type ObjectShapeSchemaType = Record<string, CommonSchema>;\n\nexport interface RecordSchemaType {\n  key: CommonSchema;\n  value: CommonSchema;\n}\n\nexport interface LazySchemaType {\n  /** The name codeGen emits at the recursion point, instead of descending forever. */\n  typeName: string;\n  getSchema: () => CommonSchema;\n  /** Filled on first use, so the thunk runs once however many values are validated. */\n  resolved?: CommonSchema;\n}\n\nexport interface ValidatorContext {\n  type: BaseType[];\n  isNullable?: boolean;\n  isOptional?: boolean;\n  requiredValidations: RequiredValidation[];\n  asyncValidations?: AsyncRequiredValidation[];\n  array?: CommonSchema;\n  object?: ObjectShapeSchemaType;\n  union?: CommonSchema[];\n  record?: RecordSchemaType;\n  tuple?: CommonSchema[];\n  lazy?: LazySchemaType;\n  allowUnrecognizedObjectProps?: boolean;\n  strictType?: boolean;\n  strictTypeValue?: unknown;\n  date?: boolean;\n  defaultValue?: unknown;\n  meta?: MetaContext;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  transformListBefore?: TransformCallback<any, any>[];\n}\n\n/**\n * Copies a context so a derived schema can be changed without touching the one it came from.\n *\n * Child schemas in `array` and `object` are shared by reference rather than copied. That is safe\n * because schemas are immutable: refining a child produces a new instance instead of altering the\n * shared one. Only the containers themselves are re-allocated, so adding a key to a derived\n * object schema cannot be seen by the original.\n */\nfunction cloneValidatorContext(ctx: ValidatorContext): ValidatorContext {\n  const next: ValidatorContext = {\n    ...ctx,\n    type: [...ctx.type],\n    requiredValidations: [...ctx.requiredValidations],\n  };\n\n  if (ctx.asyncValidations) next.asyncValidations = [...ctx.asyncValidations];\n  if (ctx.object) next.object = { ...ctx.object };\n  if (ctx.union) next.union = [...ctx.union];\n  if (ctx.record) next.record = { ...ctx.record };\n  if (ctx.tuple) next.tuple = [...ctx.tuple];\n  if (ctx.lazy) next.lazy = { ...ctx.lazy };\n  if (ctx.transformListBefore) next.transformListBefore = [...ctx.transformListBefore];\n  if (ctx.meta) next.meta = { ...ctx.meta };\n\n  return next;\n}\n\nexport class CommonSchema {\n  [ctxSymbol]: ValidatorContext;\n  constructor(ctx: ValidatorContext) {\n    this[ctxSymbol] = ctx;\n  }\n\n  /**\n   * The Standard Schema v1 interface, which lets a bguard schema be used by any library that accepts\n   * a validator without either side knowing about the other.\n   *\n   * A getter rather than a stored property, so it costs nothing until something asks for it and is\n   * not copied by `clone`. `types` is declared but deliberately never assigned: the spec defines it\n   * as type-only. Input and output are reported separately, so a consumer generating a form asks for\n   * what the schema takes rather than what it returns.\n   */\n  public get '~standard'(): StandardSchemaProps<InferInput<this>, InferType<this>> {\n    return {\n      version: 1,\n      vendor: 'bguard',\n      // An arrow function, so `this` is the schema however the property is destructured or passed on.\n      validate: (value: unknown) => {\n        // The spec allows either a result or a promise of one, decided per call. A schema with async\n        // validations returns a promise; everything else stays synchronous, so a consumer that never\n        // awaits keeps working.\n        if (hasAsyncValidation(this)) return parseAsync(this, value, { getAllErrors: true }).then(toStandardResult);\n\n        return toStandardResult(parse(this, value, { getAllErrors: true }));\n      },\n    };\n  }\n\n  /**\n   * Returns a copy of this schema that carries its own context.\n   *\n   * Every refining method goes through this, so a schema can be shared between properties and\n   * reused as a base without one use leaking into another. Construction is deliberately bypassed:\n   * the subclass constructors validate their arguments and take extra parameters, and neither\n   * applies when deriving from an already-valid schema.\n   *\n   * Public because deriving a schema is a reasonable thing to do from outside as well — the object\n   * utilities need it to rebuild a property schema without touching the one they were handed.\n   */\n  public clone(): this {\n    const next = Object.assign(Object.create(Object.getPrototypeOf(this) as object), this) as this;\n    next[ctxSymbol] = cloneValidatorContext(this[ctxSymbol]);\n    return next;\n  }\n\n  /**\n   * @param validators - One or more custom validation functions.\n   * @returns {this} A new schema instance with the added custom validation.\n   */\n  public custom(...validators: RequiredValidation<AssertInput<this>>[]): this {\n    this.defaultValueCheck();\n    const next = this.clone();\n    next[ctxSymbol].requiredValidations.push(...validators);\n    return next;\n  }\n\n  /**\n   * Adds validations that have to wait for something, such as a database lookup.\n   *\n   * These run only under `parseAsync` or `parseOrFailAsync`; a synchronous parse reports a\n   * `BuildSchemaError` rather than skipping them. They are awaited after the structural walk is\n   * complete, all together, so several slow checks across a schema cost one round of waiting.\n   *\n   * @param validators - One or more async validation functions.\n   * @returns {this} A new schema instance with the added validations.\n   * @example\n   * const schema = string().customAsync(async (received, ctx) => {\n   *   if (await isTaken(received)) ctx.addIssue('an unused name', received, 'name is taken');\n   * });\n   */\n  public customAsync(...validators: AsyncRequiredValidation<AssertInput<this>>[]): this {\n    this.defaultValueCheck();\n    const next = this.clone();\n    next[ctxSymbol].asyncValidations = [...(next[ctxSymbol].asyncValidations ?? []), ...validators];\n    return next;\n  }\n\n  /**\n   * Marks the schema as nullable, allowing the value to be `null`.\n   *\n   * @returns {WithNull<this>} A new schema instance marked as nullable.\n   */\n  public nullable(): WithNull<this> {\n    this.defaultValueCheck();\n    const next = this.clone();\n    next[ctxSymbol].isNullable = true;\n    return next as WithNull<this>;\n  }\n\n  /**\n   * Marks the schema as optional, allowing the value to be `undefined`.\n   *\n   * @returns {WithUndefined<this>} A new schema instance marked as optional.\n   */\n  public optional(): WithUndefined<this> {\n    this.defaultValueCheck();\n    const next = this.clone();\n    next[ctxSymbol].isOptional = true;\n    return next as WithUndefined<this>;\n  }\n\n  /**\n   * Marks the schema as optional, allowing the value to be `undefined`.\n   *\n   * @returns {this} The schema instance. This method should be used as a last one because it does the check of previous methods and\n   */\n  public default(defaultValue: InferType<this>): WithDefault<this> {\n    const ctx = this[ctxSymbol];\n    if (ctx.isOptional) {\n      throw new BuildSchemaError(`Cannot call method 'default' after method 'optional'`);\n    }\n\n    try {\n      parseOrFail(this, defaultValue);\n    } catch (e) {\n      throw new BuildSchemaError((e as Error).message);\n    }\n\n    const next = this.clone();\n    next[ctxSymbol].defaultValue = defaultValue;\n    return next as WithDefault<this>;\n  }\n\n  /**\n   * Applies a transformation to the input value before any validation occurs.\n   * The transformation should return a value of the same type as the inferred type of the schema,\n   * ensuring that the overall type is not altered.\n   *\n   * @template In - The type of the input value before transformation (defaults to `unknown`).\n   * @param {TransformCallback<In, InferType<this>>} cb - The callback function that performs the transformation.\n   * @returns {this} A new schema with the applied transformation.\n   *\n   * @example\n   * const schema = string()\n   *   .nullable()\n   *   .transformBeforeValidation((val) => val + '') // Ensure the value is a string\n   *   .transformBeforeValidation((val: string) => (val === '' ? null : val)); // Convert empty strings to null\n   *\n   * // Parse 'test' will pass as 'test' is a valid string longer than 3 characters.\n   * parseOrFail(schema, 'test');\n   *\n   * // Parsing '' will be transformed to null and will pass due to .nullable().\n   * parseOrFail(schema, '');\n   */\n  public transformBeforeValidation<In>(cb: TransformCallback<In, InferType<this>>): WithInput<this, In> {\n    const next = this.clone();\n    const ctx = next[ctxSymbol];\n    if (ctx.transformListBefore) {\n      ctx.transformListBefore.push(cb);\n    } else {\n      ctx.transformListBefore = [cb];\n    }\n\n    // The callback's parameter type becomes the schema's input type, which is what lets a coercing\n    // schema say that it accepts more than it produces.\n    return next as WithInput<this, In>;\n  }\n\n  /**\n   * Assigns a unique identifier to the schema.\n   * This ID can be used to track or map validation errors back to specific fields\n   * in a form or other structures.\n   *\n   * @param {string} value - The unique identifier for the schema.\n   * @returns {this} A new schema with the assigned ID.\n   *\n   * @example\n   * const schema = string().id('username');\n   */\n  public id(value: string): this {\n    return this.meta('id', value);\n  }\n\n  /**\n   * Provides a description for the schema, offering additional context or information.\n   * The description can be used when displaying validation errors or for documentation purposes.\n   *\n   * @param {string} value - The description for the schema.\n   * @returns {this} A new schema with the added description.\n   *\n   * @example\n   * const schema = string().description('The username of the account holder.');\n   */\n  public description(value: string): this {\n    return this.meta('description', value);\n  }\n\n  private meta(key: string, value: string): this {\n    const next = this.clone();\n    const ctx = next[ctxSymbol];\n    ctx.meta = { ...ctx.meta, [key]: value };\n    return next;\n  }\n\n  protected defaultValueCheck() {\n    if (this[ctxSymbol].defaultValue !== undefined) {\n      throw new BuildSchemaError('Default value must be the last method called in schema');\n    }\n  }\n}\n\n/**\n * Parses and validates a value against the provided schema, returning a type-safe result.\n *\n * This function will throw a `ValidationError` if the value does not conform to the schema.\n * The inferred TypeScript type of the returned value will match the structure defined by the schema.\n *\n * @template T\n * @param {T} schema - The schema to validate the received value against. This schema dictates the expected structure and type of the value.\n * @param {unknown} receivedValue - The value to be validated and parsed according to the schema.\n * @param {ParseOptions} options - Options\n * @param {ParseOptions.lng} options.lng -  Set language keyword to map Error message\n * @returns {InferType<T>} The validated value, with its TypeScript type inferred from the schema.\n *\n * @throws {ValidationError} If the received value does not match the schema, a `ValidationError` will be thrown.\n * @throws {Error} If an unexpected error occurs during validation, an error will be thrown with a generic message.\n *\n * @example\n * const schema = object({\n *   name: string(),\n *   age: number(),\n * });\n *\n * const result = parseOrFail(schema, { name: 'Alice', age: 30 });\n * // result will be inferred as { name: string; age: number }\n *\n * parseOrFail(schema, { name: 'Alice', age: '30' });\n * // Throws ValidationError because 'age' should be a number, not a string.\n */\nexport function parseOrFail<T extends CommonSchema>(\n  schema: T,\n  receivedValue: unknown,\n  options?: ParseOptions,\n): InferType<T> {\n  try {\n    const ctx = new ExceptionContext(\n      receivedValue,\n      getTranslationByLocale(options?.lng),\n      '',\n      undefined,\n      schema[ctxSymbol].meta,\n    );\n    return innerCheck(schema, receivedValue, ctx) as InferType<T>;\n  } catch (e) {\n    if (e instanceof ValidationError) throw e;\n    // A BuildSchemaError means the schema itself is wrong, which is a programming error rather than\n    // a validation failure. Some are only discoverable during validation, such as a lazy getter\n    // returning something that is not a schema, and disguising them loses the reason entirely.\n    if (e instanceof BuildSchemaError) throw e;\n\n    // Anything else came from a custom assert, which can throw whatever it likes.\n    throw new Error('Something unexpected happened');\n  }\n}\n\ninterface ParseOptions {\n  /**\n   * Set language keyword to map error messages.\n   * @default 'default'\n   * @example 'sr' or 'Serbia' or any string to identify language\n   */\n  lng?: string;\n}\n\ninterface ParseAllOptions extends ParseOptions {\n  /**\n   * If true, collects all validation errors and returns them.\n   * If false or undefined, returns the first validation error it can find and stops looking,\n   * which provides a small runtime optimization.\n   *\n   * Declared only where it is honoured. `parseOrFail` throws on the first error by definition, and it\n   * used to accept this flag and ignore it.\n   * @default undefined\n   */\n  getAllErrors?: boolean;\n}\n\n/**\n * Parses and validates a value against the provided schema, returning a type-safe parsedValue.\n *\n * This function will throw a `ValidationError` if the value does not conform to the schema.\n * The inferred TypeScript type of the returned value will match the structure defined by the schema.\n *\n * @template T\n * @param {T} schema - The schema to validate the received value against. This schema dictates the expected structure and type of the value.\n * @param {unknown} receivedValue - The value to be validated and parsed according to the schema.\n * @param {ParseOptions} options - Options\n * @param {ParseOptions.lng} options.lng -  Set language keyword to map Error messages\n * @param {ParseOptions.lng} options.getAllErrors - If `false` or `undefined` - returns the first validation error it can find and stops looking, which provides a small runtime optimization.\n * @returns {[undefined, InferType<T>]} A tuple of [undefined, InferType<T>] if parsing is successful.\n * @returns {[ValidationErrorData[], undefined]} A tuple of [ValidationErrorData[], undefined]] if errors occur.\n *\n * @example\n * const schema = object({\n *   name: string(),\n *   age: number(),\n * });\n *\n * const [errors, parsedValue]  = parse(schema, { name: 'Alice', age: 30 });\n * // parsedValue will be inferred as { name: string; age: number }\n *\n *\n *  const [errors, parsedValue] = parse(schema, { name: 'Alice', age: '30' });\n * // First element in array \"errors\" will have an error because 'age' should be a number, not a string.\n * // Array 'errors' returns only one element.\n *\n *\n *  const [errors, parsedValue] = parse(schema, { name: true, age: '30' }, { getAllErrors: true});\n * // Returns array \"errors\" with multiple errors because 'age' should be a number and 'name' a string.\n * // With provided options { getAllErrors: true}, we can expecte more than one error in 'errors' array.\n *\n *\n *  const [errors, parsedValue] = parse(schema, { name: true, age: '30' }, { lng: 'SR'});\n * // First element in array \"errors\" will have an error because 'age' should be a number, not a string.\n * // With provided options { lng: 'SR'}, errors will be translated to a language mapped with keyword 'SR'\n */\nexport function parse<T extends CommonSchema>(\n  schema: T,\n  receivedValue: unknown,\n  options?: ParseAllOptions,\n): [ValidationErrorData[], null] | [null, InferType<T>] {\n  try {\n    const ctx = new ExceptionContext(\n      receivedValue,\n      getTranslationByLocale(options?.lng),\n      '',\n      options?.getAllErrors ? [] : undefined,\n      schema[ctxSymbol].meta,\n    );\n\n    const parsedValue = innerCheck(schema, receivedValue, ctx) as InferType<T>;\n\n    if (ctx.errors?.length) {\n      return [ctx.errors, null];\n    }\n\n    return [null, parsedValue];\n  } catch (e) {\n    if (e instanceof ValidationError) {\n      delete e.stack;\n      return [[e], null];\n    }\n\n    if (e instanceof BuildSchemaError) throw e;\n\n    // Anything else came from a custom assert, which can throw whatever it likes.\n    return [[unexpectedError()], null];\n  }\n}\n\n/**\n * Awaits the collected async validations and merges whatever they report.\n *\n * They are awaited together rather than in sequence, so several slow checks across one schema cost one\n * round of waiting. Each keeps the context it was reached with, so an issue lands on the right path.\n */\n/** Shapes a parse result the way Standard Schema expects it. */\nfunction toStandardResult<T>(result: [ValidationErrorData[], null] | [null, T]): StandardSchemaResult<T> {\n  const [errors, parsedValue] = result;\n\n  if (errors) return { issues: errors.map((error) => ({ message: error.message, path: error.path })) };\n\n  return { value: parsedValue as T };\n}\n\n/**\n * Whether anything in the schema needs awaiting, which decides whether `~standard.validate` hands back\n * a promise. Walks the whole tree, since an async validation may sit at any depth.\n *\n * A lazy schema is only followed once it has been resolved. Following it here would force the thunk\n * merely because someone asked for the interface, and could recurse forever on a self-referential\n * schema — so a schema whose async validation hides behind an unresolved lazy is validated\n * synchronously and reports the BuildSchemaError that explains it.\n */\nfunction hasAsyncValidation(schema: CommonSchema, seen = new Set<CommonSchema>()): boolean {\n  if (seen.has(schema)) return false;\n  seen.add(schema);\n\n  const schemaData = schema[ctxSymbol];\n  if (schemaData.asyncValidations?.length) return true;\n\n  const children: CommonSchema[] = [\n    ...(schemaData.object ? Object.values(schemaData.object) : []),\n    ...(schemaData.union ?? []),\n    ...(schemaData.tuple ?? []),\n    ...(schemaData.array ? [schemaData.array] : []),\n    ...(schemaData.record ? [schemaData.record.key, schemaData.record.value] : []),\n    ...(schemaData.lazy?.resolved ? [schemaData.lazy.resolved] : []),\n  ];\n\n  return children.some((child) => hasAsyncValidation(child, seen));\n}\n\n/** What a custom assert throwing something unrecognised is reported as, shared by both parse forms. */\nfunction unexpectedError(): ValidationErrorData {\n  return {\n    message: 'Something unexpected happened',\n    expected: '',\n    received: '',\n    pathToError: '',\n    path: [],\n    code: '',\n    meta: undefined,\n  };\n}\n\nasync function settlePending(pending: PendingValidation[]) {\n  await Promise.all(\n    pending.flatMap(({ validations, received, ctx }) => validations.map((validation) => validation(received, ctx))),\n  );\n}\n\n/**\n * The asynchronous counterpart of {@link parse}, for schemas carrying `customAsync` validations.\n *\n * The structure is validated synchronously first and the async validations run afterwards, all\n * together. That means their issues come after the synchronous ones in the returned array, and that an\n * async validation is never reached for a value the synchronous pass already rejected structurally.\n *\n * @example\n * const [errors, value] = await parseAsync(schema, received, { getAllErrors: true });\n */\nexport async function parseAsync<T extends CommonSchema>(\n  schema: T,\n  receivedValue: unknown,\n  options?: ParseAllOptions,\n): Promise<[ValidationErrorData[], null] | [null, InferType<T>]> {\n  const errors: ValidationErrorData[] = [];\n  const pending: PendingValidation[] = [];\n\n  try {\n    const ctx = new ExceptionContext(\n      receivedValue,\n      getTranslationByLocale(options?.lng),\n      '',\n      // Always collecting: a throw partway through would leave the pending validations unawaited.\n      errors,\n      schema[ctxSymbol].meta,\n      [],\n      pending,\n    );\n\n    const parsedValue = innerCheck(schema, receivedValue, ctx) as InferType<T>;\n    await settlePending(pending);\n\n    if (errors.length) {\n      if (!options?.getAllErrors) return [[errors[0] as ValidationErrorData], null];\n      return [errors, null];\n    }\n\n    return [null, parsedValue];\n  } catch (e) {\n    if (e instanceof BuildSchemaError) throw e;\n\n    // Anything else came from a custom assert, which can throw whatever it likes.\n    return [[unexpectedError()], null];\n  }\n}\n\n/**\n * The asynchronous counterpart of {@link parseOrFail}.\n *\n * Unlike the synchronous version it cannot stop at the first error, because the async validations have\n * to be awaited before anything can be reported. It throws the first error found, in the same order\n * `parseAsync` reports them.\n */\nexport async function parseOrFailAsync<T extends CommonSchema>(\n  schema: T,\n  receivedValue: unknown,\n  options?: ParseOptions,\n): Promise<InferType<T>> {\n  const [errors, parsedValue] = await parseAsync(schema, receivedValue, options);\n\n  if (errors) {\n    const [first] = errors;\n    throw new ValidationError(\n      first!.expected,\n      first!.received,\n      first!.pathToError,\n      first!.message,\n      first!.meta,\n      first!.path,\n      first!.code,\n    );\n  }\n\n  return parsedValue as InferType<T>;\n}\n"],"mappings":"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","names":["schema"]}

package/lib/{chunk-AXKX5BGH.js → chunk-LHEU4XAC.js}

@@ -1,9 +1,9 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/helpers/constants.ts
 var ONLY_ONCE = "It is allowed to call either 'equalTo' or 'oneOfValues,' but only one of them, and only once.";
-var ctxSymbol = Symbol("contextSymbol");
+var ctxSymbol = /* @__PURE__ */ Symbol("contextSymbol");
 
 
 
 
 exports.ONLY_ONCE = ONLY_ONCE; exports.ctxSymbol = ctxSymbol;
-//# sourceMappingURL=chunk-AXKX5BGH.js.map
+//# sourceMappingURL=chunk-LHEU4XAC.js.map

package/lib/chunk-LHEU4XAC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-LHEU4XAC.js","../src/helpers/constants.ts"],"names":[],"mappings":"AAAA;ACAO,IAAM,UAAA,EACX,+FAAA;AAEK,IAAM,UAAA,kBAAY,MAAA,CAAO,eAAe,CAAA;ADA/C;AACA;AACE;AACA;AACF,6DAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-LHEU4XAC.js","sourcesContent":[null,"export const ONLY_ONCE =\n  \"It is allowed to call either 'equalTo' or 'oneOfValues,' but only one of them, and only once.\";\n\nexport const ctxSymbol = Symbol('contextSymbol');\n"]}

package/lib/chunk-LNBZ7SJR.js

@@ -0,0 +1,26 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkAO6DKPJZjs = require('./chunk-AO6DKPJZ.js');
+
+
+var _chunk6LUSV3SSjs = require('./chunk-6LUSV3SS.js');
+
+
+var _chunkZWFSAKQKjs = require('./chunk-ZWFSAKQK.js');
+
+// src/asserts/object/extend.ts
+function extend(schema, shapeSchema) {
+  const shape = _chunkAO6DKPJZjs._shapeOf.call(void 0, schema, "extend");
+  if (!shapeSchema || shapeSchema instanceof _chunk6LUSV3SSjs.CommonSchema) throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)("Invalid shape in extend method");
+  for (const [key, valueSchema] of Object.entries(shapeSchema)) {
+    if (!(valueSchema instanceof _chunk6LUSV3SSjs.CommonSchema))
+      throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)(`Invalid schema in extend method for property '${key}'`);
+  }
+  return _chunkAO6DKPJZjs._objectFrom.call(void 0, schema, { ...shape, ...shapeSchema });
+}
+
+
+
+exports.extend = extend;
+//# sourceMappingURL=chunk-LNBZ7SJR.js.map

package/lib/chunk-LNBZ7SJR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-LNBZ7SJR.js","../src/asserts/object/extend.ts"],"names":[],"mappings":"AAAA;AACE;AACA;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACcO,SAAS,MAAA,CACd,MAAA,EACA,WAAA,EACgD;AAChD,EAAA,MAAM,MAAA,EAAQ,uCAAA,MAAS,EAAQ,QAAQ,CAAA;AAEvC,EAAA,GAAA,CAAI,CAAC,YAAA,GAAe,YAAA,WAAuB,6BAAA,EAAc,MAAM,IAAI,sCAAA,CAAiB,gCAAgC,CAAA;AAEpH,EAAA,IAAA,CAAA,MAAW,CAAC,GAAA,EAAK,WAAW,EAAA,GAAK,MAAA,CAAO,OAAA,CAAQ,WAAW,CAAA,EAAG;AAC5D,IAAA,GAAA,CAAI,CAAA,CAAE,YAAA,WAAuB,6BAAA,CAAA;AAC3B,MAAA,MAAM,IAAI,sCAAA,CAAiB,CAAA,8CAAA,EAAiD,GAAG,CAAA,CAAA,CAAG,CAAA;AAAA,EACtF;AAEA,EAAA,OAAO,0CAAA,MAAY,EAAQ,EAAE,GAAG,KAAA,EAAO,GAAG,YAAY,CAAC,CAAA;AACzD;ADlBA;AACA;AACE;AACF,wBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-LNBZ7SJR.js","sourcesContent":[null,"import { WithObject } from '../../commonTypes';\nimport { CommonSchema, ObjectShapeSchemaType } from '../../core';\nimport { BuildSchemaError } from '../../exceptions';\nimport { ObjectSchema } from './index';\nimport { _objectFrom, _shapeOf } from './pick';\n\n/**\n * @description Creates a new object schema with extra properties added.\n *\n * A property already declared is replaced by the one given here, which is what distinguishes `extend`\n * from `intersection`: `intersection` rejects a duplicate key because it has no basis for choosing,\n * while `extend` is an explicit instruction to override.\n *\n * @template T\n * @template U\n * @param {WithObject<CommonSchema, T>} schema - The object schema to build on.\n * @param {U} shapeSchema - The properties to add or replace.\n * @returns A new object schema with the merged properties.\n * @example\n * const baseSchema = object({ id: string() });\n * const timestamped = extend(baseSchema, { createdAt: string() });\n * parseOrFail(timestamped, { id: '1', createdAt: 'now' }); // Validates successfully\n *\n * @instance Of CommonSchema\n */\nexport function extend<T extends ObjectShapeSchemaType, U extends ObjectShapeSchemaType>(\n  schema: WithObject<CommonSchema, T>,\n  shapeSchema: U,\n): WithObject<ObjectSchema, Omit<T, keyof U> & U> {\n  const shape = _shapeOf(schema, 'extend');\n\n  if (!shapeSchema || shapeSchema instanceof CommonSchema) throw new BuildSchemaError('Invalid shape in extend method');\n\n  for (const [key, valueSchema] of Object.entries(shapeSchema)) {\n    if (!(valueSchema instanceof CommonSchema))\n      throw new BuildSchemaError(`Invalid schema in extend method for property '${key}'`);\n  }\n\n  return _objectFrom(schema, { ...shape, ...shapeSchema }) as unknown as WithObject<ObjectSchema, Omit<T, keyof U> & U>;\n}\n"]}

package/lib/{chunk-AQCV7PB4.mjs → chunk-M7EMQU7U.mjs}

@@ -1,12 +1,12 @@
+import {
+  setToDefaultLocale
+} from "./chunk-65X7NTUS.mjs";
 import {
   isValidDateInner
 } from "./chunk-YBVMP4EI.mjs";
-import {
-  setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
 import {
   BuildSchemaError
-} from "./chunk-ZTCXXAKD.mjs";
+} from "./chunk-O2WD4JBG.mjs";
 
 // src/asserts/date/dateMin.ts
 var dateMinErrorMessage = "The received value is less than expected";
@@ -25,4 +25,4 @@ setToDefaultLocale(dateMin);
 export {
   dateMin
 };
-//# sourceMappingURL=chunk-AQCV7PB4.mjs.map
+//# sourceMappingURL=chunk-M7EMQU7U.mjs.map

package/lib/{chunk-AQCV7PB4.mjs.map → chunk-M7EMQU7U.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/asserts/date/dateMin.ts"],"sourcesContent":["import { setToDefaultLocale } from '../../translationMap';\nimport { BuildSchemaError } from '../../exceptions';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\nimport { isValidDateInner } from '../../helpers/isValidDateInner';\n\nconst dateMinErrorMessage = 'The received value is less than expected';\nconst dateMinErrorKey = 'dt:min';\n/**\n * @description Asserts that a number value is not less than a specified minimum value.\n * @param {Date | string} expected The minimum allowable value.\n * @returns {RequiredValidation} A validation function that takes a received Date or string and an exception context.\n * @throws {ValidationError} if the received value is less than the expected minimum value.\n * @example\n * const schema = date().custom(dateMin('2023-01-01'));\n * parseOrFail(schema, new Date('2023-01-02'));  // Valid\n * parseOrFail(schema, new Date('2023-01-01'));  // Valid\n * parseOrFail(schema, new Date('2022-12-31'));  // Throws an error: 'The received value is less than expected'\n *\n * @translation Error Translation Key = 'dt:min'\n */\nexport const dateMin = (expected: Date | string): RequiredValidation => {\n  const transformedExpected = typeof expected === 'string' ? new Date(expected) : expected;\n  if (!isValidDateInner(transformedExpected)) throw new BuildSchemaError('Invalid date in Date assertion');\n  return (received: Date, ctx: ExceptionContext) => {\n    if (transformedExpected > received) ctx.addIssue(transformedExpected, received, dateMinErrorKey);\n  };\n};\n\ndateMin.key = dateMinErrorKey;\ndateMin.message = dateMinErrorMessage;\nsetToDefaultLocale(dateMin);\n"],"mappings":";;;;;;;;;;;AAKA,IAAM,sBAAsB;AAC5B,IAAM,kBAAkB;AAcjB,IAAM,UAAU,CAAC,aAAgD;AACtE,QAAM,sBAAsB,OAAO,aAAa,WAAW,IAAI,KAAK,QAAQ,IAAI;AAChF,MAAI,CAAC,iBAAiB,mBAAmB,EAAG,OAAM,IAAI,iBAAiB,gCAAgC;AACvG,SAAO,CAAC,UAAgB,QAA0B;AAChD,QAAI,sBAAsB,SAAU,KAAI,SAAS,qBAAqB,UAAU,eAAe;AAAA,EACjG;AACF;AAEA,QAAQ,MAAM;AACd,QAAQ,UAAU;AAClB,mBAAmB,OAAO;","names":[]}
+{"version":3,"sources":["../src/asserts/date/dateMin.ts"],"sourcesContent":["import { setToDefaultLocale } from '../../translationMap';\nimport { BuildSchemaError } from '../../exceptions';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\nimport { isValidDateInner } from '../../helpers/isValidDateInner';\n\nconst dateMinErrorMessage = 'The received value is less than expected';\nconst dateMinErrorKey = 'dt:min';\n/**\n * @description Asserts that a number value is not less than a specified minimum value.\n * @param {Date | string} expected The minimum allowable value.\n * @returns {RequiredValidation} A validation function that takes a received Date or string and an exception context.\n * @throws {ValidationError} if the received value is less than the expected minimum value.\n * @example\n * const schema = date().custom(dateMin('2023-01-01'));\n * parseOrFail(schema, new Date('2023-01-02'));  // Valid\n * parseOrFail(schema, new Date('2023-01-01'));  // Valid\n * parseOrFail(schema, new Date('2022-12-31'));  // Throws an error: 'The received value is less than expected'\n *\n * @translation Error Translation Key = 'dt:min'\n */\nexport const dateMin = (expected: Date | string): RequiredValidation<Date> => {\n  const transformedExpected = typeof expected === 'string' ? new Date(expected) : expected;\n  if (!isValidDateInner(transformedExpected)) throw new BuildSchemaError('Invalid date in Date assertion');\n  return (received: Date, ctx: ExceptionContext) => {\n    if (transformedExpected > received) ctx.addIssue(transformedExpected, received, dateMinErrorKey);\n  };\n};\n\ndateMin.key = dateMinErrorKey;\ndateMin.message = dateMinErrorMessage;\nsetToDefaultLocale(dateMin);\n"],"mappings":";;;;;;;;;;;AAKA,IAAM,sBAAsB;AAC5B,IAAM,kBAAkB;AAcjB,IAAM,UAAU,CAAC,aAAsD;AAC5E,QAAM,sBAAsB,OAAO,aAAa,WAAW,IAAI,KAAK,QAAQ,IAAI;AAChF,MAAI,CAAC,iBAAiB,mBAAmB,EAAG,OAAM,IAAI,iBAAiB,gCAAgC;AACvG,SAAO,CAAC,UAAgB,QAA0B;AAChD,QAAI,sBAAsB,SAAU,KAAI,SAAS,qBAAqB,UAAU,eAAe;AAAA,EACjG;AACF;AAEA,QAAQ,MAAM;AACd,QAAQ,UAAU;AAClB,mBAAmB,OAAO;","names":[]}

package/lib/{chunk-GGWJJFXY.mjs → chunk-MOHROZTD.mjs}

@@ -1,6 +1,6 @@
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.mjs";
 
 // src/asserts/string/atLeastOneLowerChar.ts
 var atLeastOneLowerCharErrorMessage = "The received value does not contain at least one lowercase character";
@@ -17,4 +17,4 @@ setToDefaultLocale(atLeastOneLowerChar);
 export {
   atLeastOneLowerChar
 };
-//# sourceMappingURL=chunk-GGWJJFXY.mjs.map
+//# sourceMappingURL=chunk-MOHROZTD.mjs.map

package/lib/{chunk-GGWJJFXY.mjs.map → chunk-MOHROZTD.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/asserts/string/atLeastOneLowerChar.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst atLeastOneLowerCharErrorMessage = 'The received value does not contain at least one lowercase character';\nconst atLeastOneLowerCharErrorKey = 's:atLeastOneLowerChar';\n\n/**\n * @description Asserts that a string value contains at least one lowercase character.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value does not contain at least one lowercase character.\n * @example\n * const schema = string().custom(atLeastOneLowerChar());\n * parseOrFail(schema, 'abcDEF'); // Valid\n * parseOrFail(schema, 'ABCDEF'); // Throws an error: 'The received value does not contain at least one lowercase character'\n *\n * @translation Error Translation Key = 's:atLeastOneLowerChar'\n */\nexport const atLeastOneLowerChar = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  const lowerCharRegExp = /[a-z]/;\n  if (!lowerCharRegExp.test(received))\n    ctx.addIssue('at least one lowercase character', received, atLeastOneLowerCharErrorKey);\n};\n\natLeastOneLowerChar.key = atLeastOneLowerCharErrorKey;\natLeastOneLowerChar.message = atLeastOneLowerCharErrorMessage;\nsetToDefaultLocale(atLeastOneLowerChar);\n"],"mappings":";;;;;AAGA,IAAM,kCAAkC;AACxC,IAAM,8BAA8B;AAa7B,IAAM,sBAAsB,MAA0B,CAAC,UAAkB,QAA0B;AACxG,QAAM,kBAAkB;AACxB,MAAI,CAAC,gBAAgB,KAAK,QAAQ;AAChC,QAAI,SAAS,oCAAoC,UAAU,2BAA2B;AAC1F;AAEA,oBAAoB,MAAM;AAC1B,oBAAoB,UAAU;AAC9B,mBAAmB,mBAAmB;","names":[]}
+{"version":3,"sources":["../src/asserts/string/atLeastOneLowerChar.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst atLeastOneLowerCharErrorMessage = 'The received value does not contain at least one lowercase character';\nconst atLeastOneLowerCharErrorKey = 's:atLeastOneLowerChar';\n\n/**\n * @description Asserts that a string value contains at least one lowercase character.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value does not contain at least one lowercase character.\n * @example\n * const schema = string().custom(atLeastOneLowerChar());\n * parseOrFail(schema, 'abcDEF'); // Valid\n * parseOrFail(schema, 'ABCDEF'); // Throws an error: 'The received value does not contain at least one lowercase character'\n *\n * @translation Error Translation Key = 's:atLeastOneLowerChar'\n */\nexport const atLeastOneLowerChar = (): RequiredValidation<string> => (received: string, ctx: ExceptionContext) => {\n  const lowerCharRegExp = /[a-z]/;\n  if (!lowerCharRegExp.test(received))\n    ctx.addIssue('at least one lowercase character', received, atLeastOneLowerCharErrorKey);\n};\n\natLeastOneLowerChar.key = atLeastOneLowerCharErrorKey;\natLeastOneLowerChar.message = atLeastOneLowerCharErrorMessage;\nsetToDefaultLocale(atLeastOneLowerChar);\n"],"mappings":";;;;;AAGA,IAAM,kCAAkC;AACxC,IAAM,8BAA8B;AAa7B,IAAM,sBAAsB,MAAkC,CAAC,UAAkB,QAA0B;AAChH,QAAM,kBAAkB;AACxB,MAAI,CAAC,gBAAgB,KAAK,QAAQ;AAChC,QAAI,SAAS,oCAAoC,UAAU,2BAA2B;AAC1F;AAEA,oBAAoB,MAAM;AAC1B,oBAAoB,UAAU;AAC9B,mBAAmB,mBAAmB;","names":[]}

package/lib/{chunk-SBO6OQIX.mjs → chunk-MQGE7GIK.mjs}

@@ -1,17 +1,20 @@
+import {
+  _constrain
+} from "./chunk-VERUOTB3.mjs";
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.mjs";
 
 // src/asserts/string/isValidDate.ts
 var dateErrorMessage = "The received value is not a valid date";
 var dateErrorKey = "s:isValidDate";
 var dateRegexPattern = /^(19|20)\d\d-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
 var isValidDate = () => {
-  return (received, ctx) => {
+  return _constrain({ format: "date" }, (received, ctx) => {
     if (!dateRegexPattern.test(received)) {
-      ctx.addIssue(received, dateErrorMessage, dateErrorKey);
+      ctx.addIssue("valid date", received, dateErrorKey);
     }
-  };
+  });
 };
 isValidDate.key = dateErrorKey;
 isValidDate.message = dateErrorMessage;
@@ -20,4 +23,4 @@ setToDefaultLocale(isValidDate);
 export {
   isValidDate
 };
-//# sourceMappingURL=chunk-SBO6OQIX.mjs.map
+//# sourceMappingURL=chunk-MQGE7GIK.mjs.map

package/lib/chunk-MQGE7GIK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/isValidDate.ts"],"sourcesContent":["import { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\n\nconst dateErrorMessage = 'The received value is not a valid date';\nconst dateErrorKey = 's:isValidDate';\n\n// Regex to match YYYY-MM-DD format\nconst dateRegexPattern = /^(19|20)\\d\\d-(0[1-9]|1[0-2])-(0[1-9]|[12]\\d|3[01])$/;\n\n/**\n * @description Asserts that a string is a valid date in the format YYYY-MM-DD.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received string is not a valid date.\n * @example\n * const schema = string().custom(isValidDate());\n * parseOrFail(schema, \"2020-01-01\"); // Valid\n * parseOrFail(schema, \"2020-1-1\");   // Throws an error: 'The received value is not a valid date'\n * parseOrFail(schema, \"2020-01-32\"); // Throws an error: 'The received value is not a valid date'\n *\n * @translation Error Translation Key = 's:isValidDate'\n */\nexport const isValidDate = (): RequiredValidation<string> => {\n  return _constrain({ format: 'date' }, (received: string, ctx: ExceptionContext) => {\n    if (!dateRegexPattern.test(received)) {\n      ctx.addIssue('valid date', received, dateErrorKey);\n    }\n  });\n};\n\nisValidDate.key = dateErrorKey;\nisValidDate.message = dateErrorMessage;\nsetToDefaultLocale(isValidDate);\n"],"mappings":";;;;;;;;AAIA,IAAM,mBAAmB;AACzB,IAAM,eAAe;AAGrB,IAAM,mBAAmB;AAclB,IAAM,cAAc,MAAkC;AAC3D,SAAO,WAAW,EAAE,QAAQ,OAAO,GAAG,CAAC,UAAkB,QAA0B;AACjF,QAAI,CAAC,iBAAiB,KAAK,QAAQ,GAAG;AACpC,UAAI,SAAS,cAAc,UAAU,YAAY;AAAA,IACnD;AAAA,EACF,CAAC;AACH;AAEA,YAAY,MAAM;AAClB,YAAY,UAAU;AACtB,mBAAmB,WAAW;","names":[]}

package/lib/chunk-MUXY6Q45.mjs

@@ -0,0 +1,13 @@
+import {
+  date
+} from "./chunk-FU5WAVRB.mjs";
+
+// src/asserts/coerce/date.ts
+var coerceDate = () => date().transformBeforeValidation(
+  (received) => received === null || received instanceof Date ? received : new Date(received)
+);
+
+export {
+  coerceDate
+};
+//# sourceMappingURL=chunk-MUXY6Q45.mjs.map

package/lib/chunk-MUXY6Q45.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/coerce/date.ts"],"sourcesContent":["import { date } from '../date/index';\n\n/**\n * A coercing transform must never throw: it runs before validation, and throwing would replace a clear\n * validation error with an unexplained failure. Anything it cannot convert is passed through unchanged\n * so that validation reports the type problem itself.\n *\n * `null` is never coerced, so `nullable()` still decides whether it is allowed rather than it becoming\n * the string `'null'` or the number `0`.\n *\n * The return type is inferred rather than written out. Naming it flattened the schema to\n * `CommonSchema`, which silently dropped the methods only the concrete classes define — `equalTo`,\n * `oneOfValues`, `onlyTrue`, `onlyFalse`.\n */\n/**\n * @description Coerces the received value to a Date before validating it. Anything that is not already\n * a Date is passed through `new Date`.\n *\n * An unreadable value becomes an invalid Date, which `date()` rejects.\n *\n * @returns A date schema that accepts `unknown` as its input type.\n * @example\n * parseOrFail(coerceDate(), '2024-01-01'); // Date\n */\nexport const coerceDate = () =>\n  date().transformBeforeValidation<unknown>((received) =>\n    received === null || received instanceof Date ? (received as Date) : new Date(received as string),\n  );\n"],"mappings":";;;;;AAwBO,IAAM,aAAa,MACxB,KAAK,EAAE;AAAA,EAAmC,CAAC,aACzC,aAAa,QAAQ,oBAAoB,OAAQ,WAAoB,IAAI,KAAK,QAAkB;AAClG;","names":[]}

package/lib/{chunk-H2M4FCRZ.mjs → chunk-NC7E2FQR.mjs}

@@ -1,6 +1,6 @@
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.mjs";
 
 // src/asserts/string/uuidV2.ts
 var uuidV2ErrorMessage = "The received value is not a valid UUID v2";
@@ -18,4 +18,4 @@ setToDefaultLocale(uuidV2);
 export {
   uuidV2
 };
-//# sourceMappingURL=chunk-H2M4FCRZ.mjs.map
+//# sourceMappingURL=chunk-NC7E2FQR.mjs.map

package/lib/{chunk-H2M4FCRZ.mjs.map → chunk-NC7E2FQR.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/asserts/string/uuidV2.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst uuidV2ErrorMessage = 'The received value is not a valid UUID v2';\nconst uuidV2ErrorKey = 's:uuidV2';\n\nconst uuidV2Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-2[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;\n\n/**\n * @description Asserts that a string value matches the UUID v2 format.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value is not a valid UUID v2.\n * @example\n * const schema = string().custom(uuidV2());\n * parseOrFail(schema, '550e8400-e29b-21d4-a716-446655440000'); // Valid\n * parseOrFail(schema, '550e8400-e29b-31d4-d716-446655440000'); // Throws an error: 'The received value is not a valid UUID v2'\n * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v2'\n *\n * @translation Error Translation Key = 's:uuidV2'\n */\nexport const uuidV2 = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (!uuidV2Pattern.test(received)) {\n    ctx.addIssue('uuid v2', received, uuidV2ErrorKey);\n  }\n};\n\nuuidV2.key = uuidV2ErrorKey;\nuuidV2.message = uuidV2ErrorMessage;\nsetToDefaultLocale(uuidV2);\n"],"mappings":";;;;;AAGA,IAAM,qBAAqB;AAC3B,IAAM,iBAAiB;AAEvB,IAAM,gBAAgB;AAcf,IAAM,SAAS,MAA0B,CAAC,UAAkB,QAA0B;AAC3F,MAAI,CAAC,cAAc,KAAK,QAAQ,GAAG;AACjC,QAAI,SAAS,WAAW,UAAU,cAAc;AAAA,EAClD;AACF;AAEA,OAAO,MAAM;AACb,OAAO,UAAU;AACjB,mBAAmB,MAAM;","names":[]}
+{"version":3,"sources":["../src/asserts/string/uuidV2.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst uuidV2ErrorMessage = 'The received value is not a valid UUID v2';\nconst uuidV2ErrorKey = 's:uuidV2';\n\nconst uuidV2Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-2[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;\n\n/**\n * @description Asserts that a string value matches the UUID v2 format.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value is not a valid UUID v2.\n * @example\n * const schema = string().custom(uuidV2());\n * parseOrFail(schema, '550e8400-e29b-21d4-a716-446655440000'); // Valid\n * parseOrFail(schema, '550e8400-e29b-31d4-d716-446655440000'); // Throws an error: 'The received value is not a valid UUID v2'\n * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v2'\n *\n * @translation Error Translation Key = 's:uuidV2'\n */\nexport const uuidV2 = (): RequiredValidation<string> => (received: string, ctx: ExceptionContext) => {\n  if (!uuidV2Pattern.test(received)) {\n    ctx.addIssue('uuid v2', received, uuidV2ErrorKey);\n  }\n};\n\nuuidV2.key = uuidV2ErrorKey;\nuuidV2.message = uuidV2ErrorMessage;\nsetToDefaultLocale(uuidV2);\n"],"mappings":";;;;;AAGA,IAAM,qBAAqB;AAC3B,IAAM,iBAAiB;AAEvB,IAAM,gBAAgB;AAcf,IAAM,SAAS,MAAkC,CAAC,UAAkB,QAA0B;AACnG,MAAI,CAAC,cAAc,KAAK,QAAQ,GAAG;AACjC,QAAI,SAAS,WAAW,UAAU,cAAc;AAAA,EAClD;AACF;AAEA,OAAO,MAAM;AACb,OAAO,UAAU;AACjB,mBAAmB,MAAM;","names":[]}

package/lib/chunk-NM3VRT77.mjs

@@ -0,0 +1,120 @@
+import {
+  CommonSchema
+} from "./chunk-LDZFOOWN.mjs";
+import {
+  ctxSymbol
+} from "./chunk-C76DLZFD.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-O2WD4JBG.mjs";
+
+// src/toJSONSchema.ts
+var typeNames = {
+  string: "string",
+  number: "number",
+  boolean: "boolean",
+  object: "object"
+};
+function constraintsOf(schemaData) {
+  const constraints = {};
+  for (const validation of schemaData.requiredValidations) {
+    const carried = validation.jsonSchema;
+    if (carried) Object.assign(constraints, carried);
+  }
+  return constraints;
+}
+function literalOf(schemaData) {
+  if (!schemaData.strictType) return void 0;
+  const unquote = (value) => typeof value === "string" && value.startsWith("'") && value.endsWith("'") ? value.slice(1, -1).replace(/\\'/g, "'").replace(/\\\\/g, "\\") : value;
+  if (Array.isArray(schemaData.strictTypeValue)) return { enum: schemaData.strictTypeValue.map(unquote) };
+  return { const: unquote(schemaData.strictTypeValue) };
+}
+function baseOf(schemaData, context) {
+  if (schemaData.lazy) {
+    const { typeName, getSchema } = schemaData.lazy;
+    if (context.inProgress.has(typeName)) return { $ref: `#/$defs/${typeName}` };
+    schemaData.lazy.resolved ??= getSchema();
+    if (!(schemaData.lazy.resolved instanceof CommonSchema))
+      throw new BuildSchemaError("Invalid schema returned from lazy method");
+    context.inProgress.add(typeName);
+    context.definitions[typeName] = generate(schemaData.lazy.resolved, context);
+    context.inProgress.delete(typeName);
+    return { $ref: `#/$defs/${typeName}` };
+  }
+  if (schemaData.union) return { anyOf: schemaData.union.map((member) => generate(member, context)) };
+  if (schemaData.tuple)
+    return {
+      type: "array",
+      // Draft 2020-12 spells positional schemas `prefixItems`, and forbidding extras is what makes it a
+      // tuple rather than an array that happens to start a certain way.
+      prefixItems: schemaData.tuple.map((position) => generate(position, context)),
+      items: false,
+      minItems: schemaData.tuple.length,
+      maxItems: schemaData.tuple.length
+    };
+  if (schemaData.record) {
+    const keyLiteral = literalOf(schemaData.record.key[ctxSymbol]);
+    const valueSchema = generate(schemaData.record.value, context);
+    if (keyLiteral?.enum)
+      return {
+        type: "object",
+        properties: Object.fromEntries(keyLiteral.enum.map((key) => [String(key), valueSchema])),
+        additionalProperties: false
+      };
+    return { type: "object", additionalProperties: valueSchema };
+  }
+  if (schemaData.array) return { type: "array", items: generate(schemaData.array, context) };
+  if (schemaData.object) {
+    const properties = {};
+    const required = [];
+    for (const [key, valueSchema] of Object.entries(schemaData.object)) {
+      const valueSchemaData = valueSchema[ctxSymbol];
+      properties[key] = generate(valueSchema, context);
+      if (!valueSchemaData.isOptional && valueSchemaData.defaultValue === void 0) required.push(key);
+    }
+    const objectSchema = { type: "object", properties };
+    if (required.length) objectSchema.required = required;
+    if (!schemaData.allowUnrecognizedObjectProps) objectSchema.additionalProperties = false;
+    return objectSchema;
+  }
+  if (schemaData.date) return { type: "string", format: "date-time" };
+  const named = schemaData.type.filter((type) => type !== "undefined");
+  if (!named.length) return {};
+  const jsonTypes = named.map((type) => {
+    const jsonType = typeNames[type];
+    if (!jsonType) throw new BuildSchemaError(`Type '${type}' has no JSON Schema equivalent and cannot be generated`);
+    return jsonType;
+  });
+  return { type: jsonTypes.length === 1 ? jsonTypes[0] : jsonTypes };
+}
+function generate(schema, context) {
+  const schemaData = schema[ctxSymbol];
+  const base = baseOf(schemaData, context);
+  const literal = literalOf(schemaData);
+  let result = literal ? { ...base, ...literal } : { ...base, ...constraintsOf(schemaData) };
+  if (literal && result.type) delete result.type;
+  if (schemaData.isNullable) {
+    result = result.$ref || result.anyOf ? { anyOf: [result, { type: "null" }] } : mergeNull(result);
+  }
+  if (schemaData.defaultValue !== void 0) result.default = schemaData.defaultValue;
+  if (schemaData.meta?.description) result.description = schemaData.meta.description;
+  return result;
+}
+function mergeNull(schema) {
+  if (typeof schema.type === "string") return { ...schema, type: [schema.type, "null"] };
+  if (Array.isArray(schema.type)) return { ...schema, type: [...schema.type, "null"] };
+  return { anyOf: [schema, { type: "null" }] };
+}
+function toJSONSchema(schema, options) {
+  const context = { definitions: {}, inProgress: /* @__PURE__ */ new Set() };
+  const generated = generate(schema, context);
+  const dialect = options?.dialect === void 0 ? "https://json-schema.org/draft/2020-12/schema" : options.dialect;
+  const document = dialect ? { $schema: dialect, ...generated } : generated;
+  if (Object.keys(context.definitions).length) document.$defs = context.definitions;
+  return document;
+}
+
+export {
+  toJSONSchema
+};
+//# sourceMappingURL=chunk-NM3VRT77.mjs.map

package/lib/chunk-NM3VRT77.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/toJSONSchema.ts"],"sourcesContent":["import type { BaseType } from './commonTypes';\nimport { CommonSchema, type ValidatorContext } from './core';\nimport { BuildSchemaError } from './exceptions';\nimport { ctxSymbol } from './helpers/constants';\n\nexport interface JSONSchema {\n  [keyword: string]: unknown;\n}\n\nexport interface ToJSONSchemaOptions {\n  /**\n   * The dialect to declare in `$schema`. Pass `null` to leave it out, which is what you want when the\n   * result is embedded in a larger document such as an OpenAPI `components.schemas` entry.\n   * @default 'https://json-schema.org/draft/2020-12/schema'\n   */\n  dialect?: string | null;\n}\n\n/** What a bguard primitive is called in JSON Schema. */\nconst typeNames: Partial<Record<BaseType, string>> = {\n  string: 'string',\n  number: 'number',\n  boolean: 'boolean',\n  object: 'object',\n};\n\n/** A validation may carry the JSON Schema keywords it stands for. Those that cannot, do not. */\ninterface ConstrainedValidation {\n  jsonSchema?: JSONSchema;\n}\n\ninterface Context {\n  /** Named subschemas, filled as lazy schemas are met so a recursive schema can reference itself. */\n  definitions: Record<string, JSONSchema>;\n  /** Lazy type names currently being generated, so a self-reference emits a `$ref` instead of looping. */\n  inProgress: Set<string>;\n}\n\nfunction constraintsOf(schemaData: ValidatorContext): JSONSchema {\n  const constraints: JSONSchema = {};\n\n  for (const validation of schemaData.requiredValidations) {\n    const carried = (validation as ConstrainedValidation).jsonSchema;\n    if (carried) Object.assign(constraints, carried);\n  }\n\n  return constraints;\n}\n\nfunction literalOf(schemaData: ValidatorContext): JSONSchema | undefined {\n  if (!schemaData.strictType) return undefined;\n\n  // equalTo stores one value, oneOfValues an array. String literals arrive already quoted for codeGen,\n  // so the quotes have to come back off for JSON.\n  const unquote = (value: unknown) =>\n    typeof value === 'string' && value.startsWith(\"'\") && value.endsWith(\"'\")\n      ? value.slice(1, -1).replace(/\\\\'/g, \"'\").replace(/\\\\\\\\/g, '\\\\')\n      : value;\n\n  if (Array.isArray(schemaData.strictTypeValue)) return { enum: schemaData.strictTypeValue.map(unquote) };\n\n  return { const: unquote(schemaData.strictTypeValue) };\n}\n\nfunction baseOf(schemaData: ValidatorContext, context: Context): JSONSchema {\n  if (schemaData.lazy) {\n    const { typeName, getSchema } = schemaData.lazy;\n\n    // A self-reference resolves to a pointer, which is what stops generation from recursing forever.\n    if (context.inProgress.has(typeName)) return { $ref: `#/$defs/${typeName}` };\n\n    schemaData.lazy.resolved ??= getSchema();\n    if (!(schemaData.lazy.resolved instanceof CommonSchema))\n      throw new BuildSchemaError('Invalid schema returned from lazy method');\n\n    context.inProgress.add(typeName);\n    context.definitions[typeName] = generate(schemaData.lazy.resolved, context);\n    context.inProgress.delete(typeName);\n\n    return { $ref: `#/$defs/${typeName}` };\n  }\n\n  if (schemaData.union) return { anyOf: schemaData.union.map((member) => generate(member, context)) };\n\n  if (schemaData.tuple)\n    return {\n      type: 'array',\n      // Draft 2020-12 spells positional schemas `prefixItems`, and forbidding extras is what makes it a\n      // tuple rather than an array that happens to start a certain way.\n      prefixItems: schemaData.tuple.map((position) => generate(position, context)),\n      items: false,\n      minItems: schemaData.tuple.length,\n      maxItems: schemaData.tuple.length,\n    };\n\n  if (schemaData.record) {\n    const keyLiteral = literalOf(schemaData.record.key[ctxSymbol]);\n    const valueSchema = generate(schemaData.record.value, context);\n\n    // A restricted key set becomes named properties. There is no `required`, because validation checks\n    // the keys that are present rather than demanding the whole set — the same reason InferType says\n    // Partial.\n    if (keyLiteral?.enum)\n      return {\n        type: 'object',\n        properties: Object.fromEntries((keyLiteral.enum as unknown[]).map((key) => [String(key), valueSchema])),\n        additionalProperties: false,\n      };\n\n    return { type: 'object', additionalProperties: valueSchema };\n  }\n\n  if (schemaData.array) return { type: 'array', items: generate(schemaData.array, context) };\n\n  if (schemaData.object) {\n    const properties: Record<string, JSONSchema> = {};\n    const required: string[] = [];\n\n    for (const [key, valueSchema] of Object.entries(schemaData.object)) {\n      const valueSchemaData = valueSchema[ctxSymbol];\n      properties[key] = generate(valueSchema, context);\n\n      // A default supplies the value, so the caller need not send it — the same rule InferInput follows.\n      if (!valueSchemaData.isOptional && valueSchemaData.defaultValue === undefined) required.push(key);\n    }\n\n    const objectSchema: JSONSchema = { type: 'object', properties };\n    if (required.length) objectSchema.required = required;\n    if (!schemaData.allowUnrecognizedObjectProps) objectSchema.additionalProperties = false;\n\n    return objectSchema;\n  }\n\n  if (schemaData.date) return { type: 'string', format: 'date-time' };\n\n  const named = schemaData.type.filter((type) => type !== 'undefined');\n  if (!named.length) return {};\n\n  const jsonTypes = named.map((type) => {\n    const jsonType = typeNames[type];\n    if (!jsonType) throw new BuildSchemaError(`Type '${type}' has no JSON Schema equivalent and cannot be generated`);\n\n    return jsonType;\n  });\n\n  return { type: jsonTypes.length === 1 ? jsonTypes[0] : jsonTypes };\n}\n\nfunction generate(schema: CommonSchema, context: Context): JSONSchema {\n  const schemaData = schema[ctxSymbol];\n  const base = baseOf(schemaData, context);\n  const literal = literalOf(schemaData);\n\n  // A literal already says everything about the value, so the type is redundant beside it.\n  let result: JSONSchema = literal ? { ...base, ...literal } : { ...base, ...constraintsOf(schemaData) };\n  if (literal && result.type) delete result.type;\n\n  if (schemaData.isNullable) {\n    // `$ref` and `anyOf` cannot take a sibling type, so nullability has to wrap rather than merge.\n    result = result.$ref || result.anyOf ? { anyOf: [result, { type: 'null' }] } : mergeNull(result);\n  }\n\n  if (schemaData.defaultValue !== undefined) result.default = schemaData.defaultValue;\n  if (schemaData.meta?.description) result.description = schemaData.meta.description;\n\n  return result;\n}\n\n/** Adds null to a plain type, which reads better than wrapping a single type in `anyOf`. */\nfunction mergeNull(schema: JSONSchema): JSONSchema {\n  if (typeof schema.type === 'string') return { ...schema, type: [schema.type, 'null'] };\n  if (Array.isArray(schema.type)) return { ...schema, type: [...(schema.type as string[]), 'null'] };\n\n  return { anyOf: [schema, { type: 'null' }] };\n}\n\n/**\n * Renders a schema as a JSON Schema document, for OpenAPI, form generators and tool definitions.\n *\n * What is represented: types, object properties and which of them are required, arrays, tuples,\n * records, unions, literals and enums, nullability, defaults, `description()`, and recursive schemas\n * via `$defs` and `$ref`. Assertions that map onto a JSON Schema keyword — string lengths and patterns,\n * numeric bounds, array lengths — are included; those with no equivalent are not, because JSON Schema\n * has no way to express them.\n *\n * `bigint` and `symbol` have no JSON Schema counterpart and raise a `BuildSchemaError` rather than\n * being quietly emitted as something they are not. A `date()` becomes `{ type: 'string', format:\n * 'date-time' }`, since JSON has no date type.\n *\n * @example\n * const schema = object({ name: string().custom(minLength(2)), age: number().optional() });\n * toJSONSchema(schema);\n * // {\n * //   $schema: 'https://json-schema.org/draft/2020-12/schema',\n * //   type: 'object',\n * //   properties: { name: { type: 'string', minLength: 2 }, age: { type: 'number' } },\n * //   required: ['name'],\n * //   additionalProperties: false,\n * // }\n */\nexport function toJSONSchema(schema: CommonSchema, options?: ToJSONSchemaOptions): JSONSchema {\n  const context: Context = { definitions: {}, inProgress: new Set() };\n  const generated = generate(schema, context);\n\n  const dialect = options?.dialect === undefined ? 'https://json-schema.org/draft/2020-12/schema' : options.dialect;\n  const document: JSONSchema = dialect ? { $schema: dialect, ...generated } : generated;\n\n  if (Object.keys(context.definitions).length) document.$defs = context.definitions;\n\n  return document;\n}\n"],"mappings":"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","names":[]}

package/lib/{chunk-OHUOBIHX.mjs → chunk-NM4TCTZM.mjs}

@@ -1,6 +1,6 @@
 import {
   ctxSymbol
-} from "./chunk-2ANPCB4O.mjs";
+} from "./chunk-C76DLZFD.mjs";
 
 // src/codeGen.ts
 function generateBaseType(schemaData) {
@@ -10,18 +10,33 @@ function generateBaseType(schemaData) {
     return schemaData.strictTypeValue;
   }
   if (!schemaData.type.length) return "";
-  const joined = schemaData.type.join(" | ");
-  return joined;
+  const named = schemaData.type.filter((type) => type !== "undefined");
+  if (!named.length) return "";
+  return named.join(" | ");
 }
 var INDENT_DEFAULT = `  `;
 function innerGenerator(schema, isProperty, indent = INDENT_DEFAULT) {
   const schemaData = schema[ctxSymbol];
   let code = "";
-  if (isProperty) {
-    code = code + (schemaData.isOptional ? "?: " : ": ");
+  if (schemaData.lazy) {
+    code = code + schemaData.lazy.typeName;
+  }
+  if (schemaData.tuple) {
+    const positions = schemaData.tuple.map((positionSchema) => innerGenerator(positionSchema, false, indent));
+    code = code + `[${positions.join(", ")}]`;
+  }
+  if (schemaData.union) {
+    const members = schemaData.union.map((memberSchema) => innerGenerator(memberSchema, false, indent));
+    code = code + members.join(" | ");
+  }
+  if (schemaData.record) {
+    const keyCode = innerGenerator(schemaData.record.key, false, indent);
+    const valueCode = innerGenerator(schemaData.record.value, false, indent);
+    const record = `Record<${keyCode}, ${valueCode}>`;
+    code = code + (schemaData.record.key[ctxSymbol].strictType ? `Partial<${record}>` : record);
   }
   if (schemaData.array) {
-    const innerArrayCode = innerGenerator(schemaData.array, false, indent + INDENT_DEFAULT);
+    const innerArrayCode = innerGenerator(schemaData.array, false, indent);
     code = code + (innerArrayCode.includes("|") ? `(${innerArrayCode})[]` : `${innerArrayCode}[]`);
   }
   if (schemaData.object) {
@@ -32,9 +47,12 @@ function innerGenerator(schema, isProperty, indent = INDENT_DEFAULT) {
     code = code + indent.slice(0, -INDENT_DEFAULT.length) + "}";
   }
   code = code + generateBaseType(schemaData);
-  code = code + (schemaData.isNullable ? " | null" : "");
-  code = code + (schemaData.isOptional ? " | undefined" : "");
-  return code;
+  const nullish = [];
+  if (schemaData.isNullable) nullish.push("null");
+  if (schemaData.isOptional) nullish.push("undefined");
+  const type = (code ? [code, ...nullish] : nullish).join(" | ");
+  const prefix = isProperty ? schemaData.isOptional ? "?: " : ": " : "";
+  return prefix + type;
 }
 function codeGen(schema) {
   const result = innerGenerator(schema, false) + ";";
@@ -49,4 +67,4 @@ export {
   codeGen,
   codeGenWithName
 };
-//# sourceMappingURL=chunk-OHUOBIHX.mjs.map
+//# sourceMappingURL=chunk-NM4TCTZM.mjs.map

package/lib/chunk-NM4TCTZM.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/codeGen.ts"],"sourcesContent":["import { ctxSymbol } from './helpers/constants';\nimport { type CommonSchema, type ValidatorContext } from './core';\n\nfunction generateBaseType(schemaData: ValidatorContext) {\n  if (schemaData.date) return 'Date';\n\n  if (schemaData.strictType) {\n    if (Array.isArray(schemaData.strictTypeValue)) return schemaData.strictTypeValue.join(' | ');\n    return schemaData.strictTypeValue;\n  }\n  if (!schemaData.type.length) return '';\n\n  // `undefined` in the type list also sets isOptional, which appends `| undefined` further down,\n  // so including it here as well would emit it twice.\n  const named = schemaData.type.filter((type) => type !== 'undefined');\n  if (!named.length) return '';\n\n  return named.join(' | ');\n}\n\nconst INDENT_DEFAULT = `  `;\n\nfunction innerGenerator(schema: CommonSchema, isProperty: boolean, indent = INDENT_DEFAULT): string {\n  const schemaData = schema[ctxSymbol];\n  // The property prefix is kept out of `code`, which holds only the type. Mixing them meant the\n  // emptiness check below could not tell a missing type from a bare `?: `.\n  let code = '';\n\n  if (schemaData.lazy) {\n    // The name, not the schema behind it. Descending into a lazy schema is what makes recursion\n    // possible at validation time and what would make code generation loop forever.\n    code = code + schemaData.lazy.typeName;\n  }\n\n  if (schemaData.tuple) {\n    const positions = schemaData.tuple.map((positionSchema) => innerGenerator(positionSchema, false, indent));\n    code = code + `[${positions.join(', ')}]`;\n  }\n\n  if (schemaData.union) {\n    const members = schemaData.union.map((memberSchema) => innerGenerator(memberSchema, false, indent));\n    code = code + members.join(' | ');\n  }\n\n  if (schemaData.record) {\n    const keyCode = innerGenerator(schemaData.record.key, false, indent);\n    const valueCode = innerGenerator(schemaData.record.value, false, indent);\n    // Mirrors InferType: a restricted key type is Partial, because validation checks the keys that\n    // are present without requiring the whole set.\n    const record = `Record<${keyCode}, ${valueCode}>`;\n    code = code + (schemaData.record.key[ctxSymbol].strictType ? `Partial<${record}>` : record);\n  }\n\n  if (schemaData.array) {\n    // `indent` is passed through unchanged: an array does not introduce a visual nesting level,\n    // so its element type sits at the same depth as the property that holds the array. Adding a\n    // level here indented the element's members one step too far and its closing brace two.\n    const innerArrayCode = innerGenerator(schemaData.array, false, indent);\n    code = code + (innerArrayCode.includes('|') ? `(${innerArrayCode})[]` : `${innerArrayCode}[]`);\n  }\n\n  if (schemaData.object) {\n    code = code + '{\\n';\n    for (const [keyOfSchema, valueOfSchema] of Object.entries(schemaData.object)) {\n      code = code + indent + keyOfSchema + innerGenerator(valueOfSchema, true, indent + INDENT_DEFAULT) + ';\\n';\n    }\n    code = code + indent.slice(0, -INDENT_DEFAULT.length) + '}';\n  }\n\n  code = code + generateBaseType(schemaData);\n\n  // Joined rather than concatenated, so a schema with no named type of its own — `oneOfTypes` given\n  // nothing but 'undefined' — does not come out as a leading `| undefined`, which does not parse.\n  const nullish: string[] = [];\n  if (schemaData.isNullable) nullish.push('null');\n  if (schemaData.isOptional) nullish.push('undefined');\n\n  const type = (code ? [code, ...nullish] : nullish).join(' | ');\n  const prefix = isProperty ? (schemaData.isOptional ? '?: ' : ': ') : '';\n\n  return prefix + type;\n}\n\nexport function codeGen(schema: CommonSchema): string {\n  const result = innerGenerator(schema, false) + ';';\n  return result;\n}\n\nexport function codeGenWithName(typeName: string, schema: CommonSchema): string {\n  const result = 'type ' + typeName + ' = ' + codeGen(schema) + '\\n';\n  return result;\n}\n"],"mappings":";;;;;AAGA,SAAS,iBAAiB,YAA8B;AACtD,MAAI,WAAW,KAAM,QAAO;AAE5B,MAAI,WAAW,YAAY;AACzB,QAAI,MAAM,QAAQ,WAAW,eAAe,EAAG,QAAO,WAAW,gBAAgB,KAAK,KAAK;AAC3F,WAAO,WAAW;AAAA,EACpB;AACA,MAAI,CAAC,WAAW,KAAK,OAAQ,QAAO;AAIpC,QAAM,QAAQ,WAAW,KAAK,OAAO,CAAC,SAAS,SAAS,WAAW;AACnE,MAAI,CAAC,MAAM,OAAQ,QAAO;AAE1B,SAAO,MAAM,KAAK,KAAK;AACzB;AAEA,IAAM,iBAAiB;AAEvB,SAAS,eAAe,QAAsB,YAAqB,SAAS,gBAAwB;AAClG,QAAM,aAAa,OAAO,SAAS;AAGnC,MAAI,OAAO;AAEX,MAAI,WAAW,MAAM;AAGnB,WAAO,OAAO,WAAW,KAAK;AAAA,EAChC;AAEA,MAAI,WAAW,OAAO;AACpB,UAAM,YAAY,WAAW,MAAM,IAAI,CAAC,mBAAmB,eAAe,gBAAgB,OAAO,MAAM,CAAC;AACxG,WAAO,OAAO,IAAI,UAAU,KAAK,IAAI,CAAC;AAAA,EACxC;AAEA,MAAI,WAAW,OAAO;AACpB,UAAM,UAAU,WAAW,MAAM,IAAI,CAAC,iBAAiB,eAAe,cAAc,OAAO,MAAM,CAAC;AAClG,WAAO,OAAO,QAAQ,KAAK,KAAK;AAAA,EAClC;AAEA,MAAI,WAAW,QAAQ;AACrB,UAAM,UAAU,eAAe,WAAW,OAAO,KAAK,OAAO,MAAM;AACnE,UAAM,YAAY,eAAe,WAAW,OAAO,OAAO,OAAO,MAAM;AAGvE,UAAM,SAAS,UAAU,OAAO,KAAK,SAAS;AAC9C,WAAO,QAAQ,WAAW,OAAO,IAAI,SAAS,EAAE,aAAa,WAAW,MAAM,MAAM;AAAA,EACtF;AAEA,MAAI,WAAW,OAAO;AAIpB,UAAM,iBAAiB,eAAe,WAAW,OAAO,OAAO,MAAM;AACrE,WAAO,QAAQ,eAAe,SAAS,GAAG,IAAI,IAAI,cAAc,QAAQ,GAAG,cAAc;AAAA,EAC3F;AAEA,MAAI,WAAW,QAAQ;AACrB,WAAO,OAAO;AACd,eAAW,CAAC,aAAa,aAAa,KAAK,OAAO,QAAQ,WAAW,MAAM,GAAG;AAC5E,aAAO,OAAO,SAAS,cAAc,eAAe,eAAe,MAAM,SAAS,cAAc,IAAI;AAAA,IACtG;AACA,WAAO,OAAO,OAAO,MAAM,GAAG,CAAC,eAAe,MAAM,IAAI;AAAA,EAC1D;AAEA,SAAO,OAAO,iBAAiB,UAAU;AAIzC,QAAM,UAAoB,CAAC;AAC3B,MAAI,WAAW,WAAY,SAAQ,KAAK,MAAM;AAC9C,MAAI,WAAW,WAAY,SAAQ,KAAK,WAAW;AAEnD,QAAM,QAAQ,OAAO,CAAC,MAAM,GAAG,OAAO,IAAI,SAAS,KAAK,KAAK;AAC7D,QAAM,SAAS,aAAc,WAAW,aAAa,QAAQ,OAAQ;AAErE,SAAO,SAAS;AAClB;AAEO,SAAS,QAAQ,QAA8B;AACpD,QAAM,SAAS,eAAe,QAAQ,KAAK,IAAI;AAC/C,SAAO;AACT;AAEO,SAAS,gBAAgB,UAAkB,QAA8B;AAC9E,QAAM,SAAS,UAAU,WAAW,QAAQ,QAAQ,MAAM,IAAI;AAC9D,SAAO;AACT;","names":[]}

package/lib/chunk-NXS5ULAJ.mjs

@@ -0,0 +1,22 @@
+import {
+  CommonSchema
+} from "./chunk-LDZFOOWN.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-O2WD4JBG.mjs";
+
+// src/asserts/record/index.ts
+function record(keySchema, valueSchema) {
+  if (!(keySchema instanceof CommonSchema)) throw new BuildSchemaError("Invalid key schema in record method");
+  if (!(valueSchema instanceof CommonSchema)) throw new BuildSchemaError("Invalid value schema in record method");
+  return new CommonSchema({
+    type: [],
+    requiredValidations: [],
+    record: { key: keySchema, value: valueSchema }
+  });
+}
+
+export {
+  record
+};
+//# sourceMappingURL=chunk-NXS5ULAJ.mjs.map

package/lib/chunk-NXS5ULAJ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/record/index.ts"],"sourcesContent":["import { WithRecord } from '../../commonTypes';\nimport { CommonSchema } from '../../core';\nimport { BuildSchemaError } from '../../exceptions';\n\n/**\n * @description Creates a new schema for an object whose keys are not known in advance.\n *\n * Every key is validated against `keySchema` and every value against `valueSchema`. Keys arrive as\n * strings, so `keySchema` must be a string schema. Validation checks the keys that are present\n * rather than requiring a fixed set, which is why a restricted key type infers as `Partial`.\n *\n * @template K\n * @template V\n * @param {K} keySchema - The schema every key must satisfy.\n * @param {V} valueSchema - The schema every value must satisfy.\n * @returns A new schema inferring `Record<key, value>`.\n * @example\n * const schema = record(string(), number());\n * parseOrFail(schema, { a: 1, b: 2 }); // Validates successfully\n * parseOrFail(schema, { a: 'one' }); // Throws a validation error\n *\n * @instance Of CommonSchema\n */\nexport function record<K extends CommonSchema, V extends CommonSchema>(\n  keySchema: K,\n  valueSchema: V,\n): WithRecord<CommonSchema, K, V> {\n  if (!(keySchema instanceof CommonSchema)) throw new BuildSchemaError('Invalid key schema in record method');\n  if (!(valueSchema instanceof CommonSchema)) throw new BuildSchemaError('Invalid value schema in record method');\n\n  return new CommonSchema({\n    type: [],\n    requiredValidations: [],\n    record: { key: keySchema, value: valueSchema },\n  }) as WithRecord<CommonSchema, K, V>;\n}\n"],"mappings":";;;;;;;;AAuBO,SAAS,OACd,WACA,aACgC;AAChC,MAAI,EAAE,qBAAqB,cAAe,OAAM,IAAI,iBAAiB,qCAAqC;AAC1G,MAAI,EAAE,uBAAuB,cAAe,OAAM,IAAI,iBAAiB,uCAAuC;AAE9G,SAAO,IAAI,aAAa;AAAA,IACtB,MAAM,CAAC;AAAA,IACP,qBAAqB,CAAC;AAAA,IACtB,QAAQ,EAAE,KAAK,WAAW,OAAO,YAAY;AAAA,EAC/C,CAAC;AACH;","names":[]}

package/lib/{chunk-2D3HCTJV.js → chunk-NZOANK7A.js}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
+var _chunkZJGY6EOEjs = require('./chunk-ZJGY6EOE.js');
 
 // src/asserts/bigint/bigintMaxExcluded.ts
 var bigintMaxExcludedErrorMessage = "The received value is greater than or equal to expected";
@@ -10,9 +10,9 @@ var bigintMaxExcluded = (expected) => (received, ctx) => {
 };
 bigintMaxExcluded.key = bigintMaxExcludedErrorKey;
 bigintMaxExcluded.message = bigintMaxExcludedErrorMessage;
-_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, bigintMaxExcluded);
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, bigintMaxExcluded);
 
 
 
 exports.bigintMaxExcluded = bigintMaxExcluded;
-//# sourceMappingURL=chunk-2D3HCTJV.js.map
+//# sourceMappingURL=chunk-NZOANK7A.js.map