bguard 0.6.0 → 0.7.0

package/lib/chunk-UCHEFFWR.js

@@ -0,0 +1,79 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;
+
+var _chunk3D6TPN7Fjs = require('./chunk-3D6TPN7F.js');
+
+
+var _chunkOPA6AXSHjs = require('./chunk-OPA6AXSH.js');
+
+
+var _chunkEEKYR5IAjs = require('./chunk-EEKYR5IA.js');
+
+
+var _chunkFTHEF6SBjs = require('./chunk-FTHEF6SB.js');
+
+
+var _chunk6LUSV3SSjs = require('./chunk-6LUSV3SS.js');
+
+
+var _chunkLHEU4XACjs = require('./chunk-LHEU4XAC.js');
+
+
+var _chunkZWFSAKQKjs = require('./chunk-ZWFSAKQK.js');
+
+// src/asserts/string/index.ts
+function string() {
+  return new StringSchema({ type: ["string"], requiredValidations: [] });
+}
+var StringSchema = (_class = class extends _chunk6LUSV3SSjs.CommonSchema {constructor(...args) { super(...args); _class.prototype.__init.call(this); }
+  __init() {this._string = 1}
+  
+  /**
+   * @method equalTo
+   * @description Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
+   * @param expectedValue - The value that the schema must exactly match.
+   * @returns A new schema restricted to the specified value, with the literal value inferred as the TypeScript type
+   * @example
+   * string().equalTo('hello'); // Infers the type 'hello'
+   *
+   * @public
+   */
+  equalTo(expectedValue) {
+    this.limitGuard();
+    const next = this.custom(_chunkOPA6AXSHjs.equalTo.call(void 0, expectedValue));
+    next.limit = true;
+    _chunkFTHEF6SBjs._setStrictType.call(void 0, next, _chunkEEKYR5IAjs._quoteStringLiteral.call(void 0, expectedValue));
+    return next;
+  }
+  /**
+   * @method oneOfValues
+   * @description Restricts the schema to match one of the specified values and infers the union of those values as the TypeScript type.
+   * @param expectedValues - An array of values that the schema can match.
+   * @returns A new schema restricted to one of the specified values, with the union of those values inferred as the TypeScript type.
+   * @example
+   * string().oneOfValues(['foo', 'bar']); // Infers the type 'foo' | 'bar'
+   *
+   * @public
+   */
+  oneOfValues(expectedValue) {
+    this.limitGuard();
+    const next = this.custom(_chunk3D6TPN7Fjs.oneOfValues.call(void 0, expectedValue));
+    next.limit = true;
+    _chunkFTHEF6SBjs._setStrictType.call(void 0, 
+      next,
+      expectedValue.map((el) => _chunkEEKYR5IAjs._quoteStringLiteral.call(void 0, el))
+    );
+    return next;
+  }
+  /**
+   * Reads the once-only flag without setting it. The flag belongs on the schema that `custom`
+   * returns, not on the one it was derived from.
+   */
+  limitGuard() {
+    if (this.limit) throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)(_chunkLHEU4XACjs.ONLY_ONCE);
+  }
+}, _class);
+
+
+
+exports.string = string;
+//# sourceMappingURL=chunk-UCHEFFWR.js.map

package/lib/chunk-UCHEFFWR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-UCHEFFWR.js","../src/asserts/string/index.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACHO,SAAS,MAAA,CAAA,EAA+C;AAC7D,EAAA,OAAO,IAAI,YAAA,CAAa,EAAE,IAAA,EAAM,CAAC,QAAQ,CAAA,EAAG,mBAAA,EAAqB,CAAC,EAAE,CAAC,CAAA;AACvE;AAEA,IAAM,aAAA,YAAN,MAAA,QAA2B,8BAAa;AAAA,iBAC5B,QAAA,EAAU,EAAA;AAAA,EACZ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYD,OAAA,CAA0B,aAAA,EAA2C;AAC1E,IAAA,IAAA,CAAK,UAAA,CAAW,CAAA;AAGhB,IAAA,MAAM,KAAA,EAAO,IAAA,CAAK,MAAA,CAAO,sCAAA,aAAqB,CAAC,CAAA;AAC/C,IAAA,IAAA,CAAK,MAAA,EAAQ,IAAA;AACb,IAAA,6CAAA,IAAe,EAAM,kDAAA,aAAiC,CAAC,CAAA;AACvD,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,WAAA,CAA8B,aAAA,EAA6C;AAChF,IAAA,IAAA,CAAK,UAAA,CAAW,CAAA;AAChB,IAAA,MAAM,KAAA,EAAO,IAAA,CAAK,MAAA,CAAO,0CAAA,aAAyB,CAAC,CAAA;AACnD,IAAA,IAAA,CAAK,MAAA,EAAQ,IAAA;AACb,IAAA,6CAAA;AAAA,MACE,IAAA;AAAA,MACA,aAAA,CAAc,GAAA,CAAI,CAAC,EAAA,EAAA,GAAO,kDAAA,EAAsB,CAAC;AAAA,IACnD,CAAA;AACA,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMQ,UAAA,CAAA,EAAa;AACnB,IAAA,GAAA,CAAI,IAAA,CAAK,KAAA,EAAO,MAAM,IAAI,sCAAA,CAAiB,0BAAS,CAAA;AAAA,EACtD;AACF,UAAA;ADDA;AACA;AACE;AACF,wBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-UCHEFFWR.js","sourcesContent":[null,"import { WithBGuardType } from '../../commonTypes';\nimport { BuildSchemaError } from '../../exceptions';\nimport { ONLY_ONCE } from '../../helpers/constants';\nimport { CommonSchema } from '../../core';\nimport { _setStrictType } from '../../helpers/setStrictType';\nimport { _quoteStringLiteral } from '../../helpers/quoteStringLiteral';\nimport { equalTo } from '../mix/equalTo';\nimport { oneOfValues } from '../mix/oneOfValues';\n\n/**\n * @description Creates a new schema for validating string values.\n * @returns {WithBGuardType<StringSchema, string>} A new instance of `StringSchema` for validating strings.\n * @example\n * const schema = string();\n * parseOrFail(schema, 'hello'); // Validates successfully\n * parseOrFail(schema, 123); // Throws a validation error\n *\n * @instance Of StringSchema\n */\nexport function string(): WithBGuardType<StringSchema, string> {\n  return new StringSchema({ type: ['string'], requiredValidations: [] }) as WithBGuardType<StringSchema, string>;\n}\n\nclass StringSchema extends CommonSchema {\n  protected _string = 1;\n  private limit: boolean | undefined;\n\n  /**\n   * @method equalTo\n   * @description Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.\n   * @param expectedValue - The value that the schema must exactly match.\n   * @returns A new schema restricted to the specified value, with the literal value inferred as the TypeScript type\n   * @example\n   * string().equalTo('hello'); // Infers the type 'hello'\n   *\n   * @public\n   */\n  public equalTo<Y extends string>(expectedValue: Y): WithBGuardType<this, Y> {\n    this.limitGuard();\n    // custom() returns the copy, so the strict type and the once-only flag are set on it. Setting\n    // them on `this` first would refine the schema this one was derived from.\n    const next = this.custom(equalTo(expectedValue));\n    next.limit = true;\n    _setStrictType(next, _quoteStringLiteral(expectedValue));\n    return next as WithBGuardType<this, Y>;\n  }\n\n  /**\n   * @method oneOfValues\n   * @description Restricts the schema to match one of the specified values and infers the union of those values as the TypeScript type.\n   * @param expectedValues - An array of values that the schema can match.\n   * @returns A new schema restricted to one of the specified values, with the union of those values inferred as the TypeScript type.\n   * @example\n   * string().oneOfValues(['foo', 'bar']); // Infers the type 'foo' | 'bar'\n   *\n   * @public\n   */\n  public oneOfValues<Y extends string>(expectedValue: Y[]): WithBGuardType<this, Y> {\n    this.limitGuard();\n    const next = this.custom(oneOfValues(expectedValue));\n    next.limit = true;\n    _setStrictType(\n      next,\n      expectedValue.map((el) => _quoteStringLiteral(el)),\n    );\n    return next as WithBGuardType<this, Y>;\n  }\n\n  /**\n   * Reads the once-only flag without setting it. The flag belongs on the schema that `custom`\n   * returns, not on the one it was derived from.\n   */\n  private limitGuard() {\n    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);\n  }\n}\n"]}

package/lib/{chunk-HPIF2CMT.js → chunk-UIJIIIOA.js}

@@ -1,18 +1,21 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
+var _chunkWOPNDC4Rjs = require('./chunk-WOPNDC4R.js');
+
+
+var _chunkZJGY6EOEjs = require('./chunk-ZJGY6EOE.js');
 
 // src/asserts/string/maxLength.ts
 var maxLengthErrorMessage = "The received value length is greater than expected";
 var maxLengthErrorKey = "s:maxLength";
-var maxLength = (expected) => (received, ctx) => {
-  if (received.length > expected) ctx.addIssue(expected, received, maxLengthErrorMessage);
-};
+var maxLength = (expected) => _chunkWOPNDC4Rjs._constrain.call(void 0, { maxLength: expected }, (received, ctx) => {
+  if (received.length > expected) ctx.addIssue(expected, received, maxLengthErrorKey);
+});
 maxLength.key = maxLengthErrorKey;
 maxLength.message = maxLengthErrorMessage;
-_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, maxLength);
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, maxLength);
 
 
 
 exports.maxLength = maxLength;
-//# sourceMappingURL=chunk-HPIF2CMT.js.map
+//# sourceMappingURL=chunk-UIJIIIOA.js.map

package/lib/chunk-UIJIIIOA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-UIJIIIOA.js","../src/asserts/string/maxLength.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACHA,IAAM,sBAAA,EAAwB,oDAAA;AAC9B,IAAM,kBAAA,EAAoB,aAAA;AAcnB,IAAM,UAAA,EAAY,CAAC,QAAA,EAAA,GACxB,yCAAA,EAAa,SAAA,EAAW,SAAS,CAAA,EAAG,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC/E,EAAA,GAAA,CAAI,QAAA,CAAS,OAAA,EAAS,QAAA,EAAU,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,iBAAiB,CAAA;AACpF,CAAC,CAAA;AAEH,SAAA,CAAU,IAAA,EAAM,iBAAA;AAChB,SAAA,CAAU,QAAA,EAAU,qBAAA;AACpB,iDAAA,SAA4B,CAAA;ADV5B;AACA;AACE;AACF,8BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-UIJIIIOA.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst maxLengthErrorMessage = 'The received value length is greater than expected';\nconst maxLengthErrorKey = 's:maxLength';\n\n/**\n * @description Asserts that the length of a string value is not greater than a specified maximum length.\n * @param {number} expected The maximum allowed length for the string.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the length of the received value is greater than the expected length.\n * @example\n * const schema = string().custom(maxLength(10));\n * parseOrFail(schema, 'short');   // Valid\n * parseOrFail(schema, 'this is a very long string'); // Throws an error: 'The received value length is greater than expected'\n *\n * @translation Error Translation Key = 's:maxLength'\n */\nexport const maxLength = (expected: number): RequiredValidation<string> =>\n  _constrain({ maxLength: expected }, (received: string, ctx: ExceptionContext) => {\n    if (received.length > expected) ctx.addIssue(expected, received, maxLengthErrorKey);\n  });\n\nmaxLength.key = maxLengthErrorKey;\nmaxLength.message = maxLengthErrorMessage;\nsetToDefaultLocale(maxLength);\n"]}

package/lib/chunk-UMS4M7FU.mjs

@@ -0,0 +1,22 @@
+import {
+  CommonSchema
+} from "./chunk-LDZFOOWN.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-O2WD4JBG.mjs";
+
+// src/asserts/mix/index.ts
+function oneOfTypes(valueTypes) {
+  if (!valueTypes.length) throw new BuildSchemaError("Missing value types in oneOfTypes method");
+  return new CommonSchema({
+    type: valueTypes,
+    requiredValidations: [],
+    // Without this the inferred type said `| undefined` while validation rejected it as missing.
+    isOptional: valueTypes.includes("undefined") || void 0
+  });
+}
+
+export {
+  oneOfTypes
+};
+//# sourceMappingURL=chunk-UMS4M7FU.mjs.map

package/lib/chunk-UMS4M7FU.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/mix/index.ts"],"sourcesContent":["import { BaseType, MapMixTypes, WithBGuardType, WithUndefined } from '../../commonTypes';\nimport { CommonSchema } from '../../core';\nimport { BuildSchemaError } from '../../exceptions';\n\n/**\n * Listing `'undefined'` infers `| undefined`, so the schema has to accept a missing value as well,\n * and an object property holding it has to be optional. Both follow from the `WithUndefined` brand\n * plus `isOptional` on the context.\n */\ntype OneOfTypesSchema<T extends BaseType[]> = 'undefined' extends T[number]\n  ? WithUndefined<WithBGuardType<CommonSchema, MapMixTypes<T>>>\n  : WithBGuardType<CommonSchema, MapMixTypes<T>>;\n\n/**\n * @description Creates a new schema for validating values that can match any one of the specified primitive types.\n * @template T\n * @param {T} valueTypes - An array of primitive types that the value can match.\n * @returns A new schema for validating values that can match any of the specified types.\n * @example\n * const schema = oneOfTypes(['string', 'number']);\n * parseOrFail(schema, 'hello'); // Validates successfully\n * parseOrFail(schema, 42); // Validates successfully\n * parseOrFail(schema, true); // Throws a validation error\n *\n * @instance Of CommonSchema\n */\nexport function oneOfTypes<T extends BaseType[]>(valueTypes: T): OneOfTypesSchema<T> {\n  // An empty list left the type check with nothing to compare against, so the schema accepted any\n  // value at all and code-generated to an empty type annotation.\n  if (!valueTypes.length) throw new BuildSchemaError('Missing value types in oneOfTypes method');\n\n  return new CommonSchema({\n    type: valueTypes,\n    requiredValidations: [],\n    // Without this the inferred type said `| undefined` while validation rejected it as missing.\n    isOptional: valueTypes.includes('undefined') || undefined,\n  }) as OneOfTypesSchema<T>;\n}\n"],"mappings":";;;;;;;;AA0BO,SAAS,WAAiC,YAAoC;AAGnF,MAAI,CAAC,WAAW,OAAQ,OAAM,IAAI,iBAAiB,0CAA0C;AAE7F,SAAO,IAAI,aAAa;AAAA,IACtB,MAAM;AAAA,IACN,qBAAqB,CAAC;AAAA;AAAA,IAEtB,YAAY,WAAW,SAAS,WAAW,KAAK;AAAA,EAClD,CAAC;AACH;","names":[]}

package/lib/{chunk-N3EHGKZV.mjs → chunk-UN5S46LE.mjs}

@@ -1,12 +1,15 @@
+import {
+  _constrain
+} from "./chunk-VERUOTB3.mjs";
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.mjs";
 
 // src/asserts/string/validUrl.ts
 var validUrlErrorMessage = "The received value is not a valid URL";
 var validUrlErrorKey = "s:validUrl";
 var urlRegex = /^(http:\/\/|https:\/\/)([a-zA-Z0-9\-.]+)(:\d+)?(\/[^\s]*)?$/;
-var validUrl = (protocol) => (received, ctx) => {
+var validUrl = (protocol) => _constrain({ format: "uri" }, (received, ctx) => {
   let regex = urlRegex;
   if (protocol) {
     regex = new RegExp(`^${protocol}:\\/\\/([a-zA-Z0-9\\-\\.]+)(:[0-9]+)?(\\/[^\\s]*)?$`);
@@ -14,7 +17,7 @@ var validUrl = (protocol) => (received, ctx) => {
   if (!regex.test(received)) {
     ctx.addIssue("Invalid URL", received, validUrlErrorKey);
   }
-};
+});
 validUrl.key = validUrlErrorKey;
 validUrl.message = validUrlErrorMessage;
 setToDefaultLocale(validUrl);
@@ -22,4 +25,4 @@ setToDefaultLocale(validUrl);
 export {
   validUrl
 };
-//# sourceMappingURL=chunk-N3EHGKZV.mjs.map
+//# sourceMappingURL=chunk-UN5S46LE.mjs.map

package/lib/chunk-UN5S46LE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/validUrl.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst validUrlErrorMessage = 'The received value is not a valid URL';\nconst validUrlErrorKey = 's:validUrl';\n\nconst urlRegex = /^(http:\\/\\/|https:\\/\\/)([a-zA-Z0-9\\-.]+)(:\\d+)?(\\/[^\\s]*)?$/;\n\n/**\n * @description Asserts that the string value is a valid URL with optional protocol validation.\n * @param {string} [protocol] The protocol that the URL must start with (e.g., 'http'). If not provided, any URL starting with 'http://' or 'https://' is considered valid.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value does not match the expected URL pattern.\n * @example\n * const schema = string().custom(validUrl()); // Validates any URL starting with 'http://' or 'https://'\n * parseOrFail(schema, 'http://example.com'); // Valid\n * parseOrFail(schema, 'https://example.com'); // Valid\n * parseOrFail(schema, 'ftp://example.com');   // Throws an error\n * parseOrFail(schema, 'http:example.com');    // Throws an error\n *\n * @translation Error Translation Key = 's:url'\n */\nexport const validUrl = (protocol?: string): RequiredValidation<string> =>\n  _constrain({ format: 'uri' }, (received: string, ctx: ExceptionContext) => {\n    let regex = urlRegex;\n    if (protocol) {\n      regex = new RegExp(`^${protocol}:\\\\/\\\\/([a-zA-Z0-9\\\\-\\\\.]+)(:[0-9]+)?(\\\\/[^\\\\s]*)?$`);\n    }\n\n    if (!regex.test(received)) {\n      ctx.addIssue('Invalid URL', received, validUrlErrorKey);\n    }\n  });\n\nvalidUrl.key = validUrlErrorKey;\nvalidUrl.message = validUrlErrorMessage;\nsetToDefaultLocale(validUrl);\n"],"mappings":";;;;;;;;AAIA,IAAM,uBAAuB;AAC7B,IAAM,mBAAmB;AAEzB,IAAM,WAAW;AAgBV,IAAM,WAAW,CAAC,aACvB,WAAW,EAAE,QAAQ,MAAM,GAAG,CAAC,UAAkB,QAA0B;AACzE,MAAI,QAAQ;AACZ,MAAI,UAAU;AACZ,YAAQ,IAAI,OAAO,IAAI,QAAQ,qDAAqD;AAAA,EACtF;AAEA,MAAI,CAAC,MAAM,KAAK,QAAQ,GAAG;AACzB,QAAI,SAAS,eAAe,UAAU,gBAAgB;AAAA,EACxD;AACF,CAAC;AAEH,SAAS,MAAM;AACf,SAAS,UAAU;AACnB,mBAAmB,QAAQ;","names":[]}

package/lib/{chunk-NFD7D5GZ.mjs → chunk-UWONIZJZ.mjs}

@@ -1,21 +1,21 @@
 import {
   oneOfValues
-} from "./chunk-W3U7RYLP.mjs";
+} from "./chunk-D42AL6CN.mjs";
 import {
   equalTo
-} from "./chunk-4ZKU4RJL.mjs";
+} from "./chunk-YQP44G45.mjs";
 import {
   _setStrictType
-} from "./chunk-THU5VBSO.mjs";
+} from "./chunk-IIL6D2UL.mjs";
 import {
   CommonSchema
-} from "./chunk-QIPGUTIG.mjs";
-import {
-  BuildSchemaError
-} from "./chunk-ZTCXXAKD.mjs";
+} from "./chunk-LDZFOOWN.mjs";
 import {
   ONLY_ONCE
-} from "./chunk-2ANPCB4O.mjs";
+} from "./chunk-C76DLZFD.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-O2WD4JBG.mjs";
 
 // src/asserts/bigint/index.ts
 function bigint() {
@@ -28,7 +28,7 @@ var BigIntSchema = class extends CommonSchema {
    * @method equalTo
    * @description Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.
    * @param expectedValue - The value that the schema must exactly match.
-   * @returns The schema instance restricted to the specified value, with the literal value inferred as the TypeScript type
+   * @returns A new schema restricted to the specified value, with the literal value inferred as the TypeScript type
    * @example
    * bigint().equalTo(42n); // Infers the type 42n
    *
@@ -36,15 +36,17 @@ var BigIntSchema = class extends CommonSchema {
    */
   equalTo(expectedValue) {
     this.defaultValueCheck();
-    this.limitCheck();
-    _setStrictType(this, `${expectedValue}n`);
-    return this.custom(equalTo(expectedValue));
+    this.limitGuard();
+    const next = this.custom(equalTo(expectedValue));
+    next.limit = true;
+    _setStrictType(next, `${expectedValue}n`);
+    return next;
   }
   /**
    * @method oneOfValues
    * @description Restricts the schema to match one of the specified values and infers the union of those values as the TypeScript type.
    * @param expectedValues - An array of values that the schema can match.
-   * @returns The schema instance restricted to one of the specified values, with the union of those values inferred as the TypeScript type.
+   * @returns A new schema restricted to one of the specified values, with the union of those values inferred as the TypeScript type.
    * @example
    * bigint().oneOfValues([5n, 7n]); // Infers the type 5n | 7n
    *
@@ -52,20 +54,25 @@ var BigIntSchema = class extends CommonSchema {
    */
   oneOfValues(expectedValue) {
     this.defaultValueCheck();
-    this.limitCheck();
+    this.limitGuard();
+    const next = this.custom(oneOfValues(expectedValue));
+    next.limit = true;
     _setStrictType(
-      this,
+      next,
       expectedValue.map((el) => `${el}n`)
     );
-    return this.custom(oneOfValues(expectedValue));
+    return next;
   }
-  limitCheck() {
+  /**
+   * Reads the once-only flag without setting it. The flag belongs on the schema that `custom`
+   * returns, not on the one it was derived from.
+   */
+  limitGuard() {
     if (this.limit) throw new BuildSchemaError(ONLY_ONCE);
-    this.limit = true;
   }
 };
 
 export {
   bigint
 };
-//# sourceMappingURL=chunk-NFD7D5GZ.mjs.map
+//# sourceMappingURL=chunk-UWONIZJZ.mjs.map

package/lib/chunk-UWONIZJZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/bigint/index.ts"],"sourcesContent":["import { WithBGuardType } from '../../commonTypes';\nimport { BuildSchemaError } from '../../exceptions';\nimport { ONLY_ONCE } from '../../helpers/constants';\nimport { CommonSchema } from '../../core';\nimport { _setStrictType } from '../../helpers/setStrictType';\nimport { equalTo } from '../mix/equalTo';\nimport { oneOfValues } from '../mix/oneOfValues';\n\n/**\n * @description - Creates a new schema for validating bigint values.\n * @returns {WithBGuardType<BigIntSchema, bigint>} A new instance of `BigIntSchema` for validating bigints.\n * @example\n * const schema = bigint();\n * parseOrFail(schema, 42n); // Validates successfully\n * parseOrFail(schema, 42); // Throws a validation error\n * parseOrFail(schema, '42'); // Throws a validation error\n *\n * @instance Of BigIntSchema\n */\nexport function bigint(): WithBGuardType<BigIntSchema, bigint> {\n  return new BigIntSchema({ type: ['bigint'], requiredValidations: [] }) as WithBGuardType<BigIntSchema, bigint>;\n}\n\nclass BigIntSchema extends CommonSchema {\n  protected _bigint = 1;\n  private limit: boolean | undefined;\n\n  /**\n   * @method equalTo\n   * @description Restricts the schema to exactly match the specified value and infers the literal value as the TypeScript type.\n   * @param expectedValue - The value that the schema must exactly match.\n   * @returns A new schema restricted to the specified value, with the literal value inferred as the TypeScript type\n   * @example\n   * bigint().equalTo(42n); // Infers the type 42n\n   *\n   * @public\n   */\n  public equalTo<Y extends bigint>(expectedValue: Y): WithBGuardType<this, Y> {\n    this.defaultValueCheck();\n    this.limitGuard();\n    const next = this.custom(equalTo(expectedValue));\n    next.limit = true;\n    _setStrictType(next, `${expectedValue}n`);\n    return next as WithBGuardType<this, Y>;\n  }\n\n  /**\n   * @method oneOfValues\n   * @description Restricts the schema to match one of the specified values and infers the union of those values as the TypeScript type.\n   * @param expectedValues - An array of values that the schema can match.\n   * @returns A new schema restricted to one of the specified values, with the union of those values inferred as the TypeScript type.\n   * @example\n   * bigint().oneOfValues([5n, 7n]); // Infers the type 5n | 7n\n   *\n   * @public\n   */\n  public oneOfValues<Y extends bigint>(expectedValue: Y[]): WithBGuardType<this, Y> {\n    this.defaultValueCheck();\n    this.limitGuard();\n    const next = this.custom(oneOfValues(expectedValue));\n    next.limit = true;\n    _setStrictType(\n      next,\n      expectedValue.map((el) => `${el}n`),\n    );\n    return next as WithBGuardType<this, Y>;\n  }\n\n  /**\n   * Reads the once-only flag without setting it. The flag belongs on the schema that `custom`\n   * returns, not on the one it was derived from.\n   */\n  private limitGuard() {\n    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmBO,SAAS,SAA+C;AAC7D,SAAO,IAAI,aAAa,EAAE,MAAM,CAAC,QAAQ,GAAG,qBAAqB,CAAC,EAAE,CAAC;AACvE;AAEA,IAAM,eAAN,cAA2B,aAAa;AAAA,EAC5B,UAAU;AAAA,EACZ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYD,QAA0B,eAA2C;AAC1E,SAAK,kBAAkB;AACvB,SAAK,WAAW;AAChB,UAAM,OAAO,KAAK,OAAO,QAAQ,aAAa,CAAC;AAC/C,SAAK,QAAQ;AACb,mBAAe,MAAM,GAAG,aAAa,GAAG;AACxC,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,YAA8B,eAA6C;AAChF,SAAK,kBAAkB;AACvB,SAAK,WAAW;AAChB,UAAM,OAAO,KAAK,OAAO,YAAY,aAAa,CAAC;AACnD,SAAK,QAAQ;AACb;AAAA,MACE;AAAA,MACA,cAAc,IAAI,CAAC,OAAO,GAAG,EAAE,GAAG;AAAA,IACpC;AACA,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA,EAMQ,aAAa;AACnB,QAAI,KAAK,MAAO,OAAM,IAAI,iBAAiB,SAAS;AAAA,EACtD;AACF;","names":[]}

package/lib/chunk-UYAF7QRD.mjs

@@ -0,0 +1,22 @@
+import {
+  CommonSchema
+} from "./chunk-LDZFOOWN.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-O2WD4JBG.mjs";
+
+// src/asserts/union/index.ts
+function union(unionSchemas) {
+  if (!Array.isArray(unionSchemas) || !unionSchemas.length)
+    throw new BuildSchemaError("Missing schemas in union method");
+  unionSchemas.forEach((unionSchema, index) => {
+    if (!(unionSchema instanceof CommonSchema))
+      throw new BuildSchemaError(`Invalid schema in union method at index '${index}'`);
+  });
+  return new CommonSchema({ type: [], requiredValidations: [], union: [...unionSchemas] });
+}
+
+export {
+  union
+};
+//# sourceMappingURL=chunk-UYAF7QRD.mjs.map

package/lib/chunk-UYAF7QRD.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/union/index.ts"],"sourcesContent":["import { WithUnion } from '../../commonTypes';\nimport { CommonSchema } from '../../core';\nimport { BuildSchemaError } from '../../exceptions';\n\n/**\n * @description Creates a new schema that accepts a value matching any one of the given schemas.\n *\n * Members are tried in order and the first one that validates cleanly wins, so its parsed value is\n * the result. Order matters when members overlap: put the more specific member first.\n *\n * Unlike `oneOfTypes`, which only compares `typeof`, each member is a full schema, so members can\n * carry their own assertions and structure.\n *\n * @template T\n * @param {T} unionSchemas - The schemas the value may match.\n * @returns A new schema inferring the union of its members' types.\n * @example\n * const schema = union([string().custom(email()), number().custom(min(0))]);\n * parseOrFail(schema, 'a@b.com'); // Validates successfully\n * parseOrFail(schema, 42); // Validates successfully\n * parseOrFail(schema, true); // Throws a validation error\n *\n * @instance Of CommonSchema\n */\nexport function union<T extends [CommonSchema, ...CommonSchema[]]>(unionSchemas: T): WithUnion<CommonSchema, T> {\n  if (!Array.isArray(unionSchemas) || !unionSchemas.length)\n    throw new BuildSchemaError('Missing schemas in union method');\n\n  unionSchemas.forEach((unionSchema, index) => {\n    if (!(unionSchema instanceof CommonSchema))\n      throw new BuildSchemaError(`Invalid schema in union method at index '${index}'`);\n  });\n\n  return new CommonSchema({ type: [], requiredValidations: [], union: [...unionSchemas] }) as WithUnion<\n    CommonSchema,\n    T\n  >;\n}\n"],"mappings":";;;;;;;;AAwBO,SAAS,MAAmD,cAA6C;AAC9G,MAAI,CAAC,MAAM,QAAQ,YAAY,KAAK,CAAC,aAAa;AAChD,UAAM,IAAI,iBAAiB,iCAAiC;AAE9D,eAAa,QAAQ,CAAC,aAAa,UAAU;AAC3C,QAAI,EAAE,uBAAuB;AAC3B,YAAM,IAAI,iBAAiB,4CAA4C,KAAK,GAAG;AAAA,EACnF,CAAC;AAED,SAAO,IAAI,aAAa,EAAE,MAAM,CAAC,GAAG,qBAAqB,CAAC,GAAG,OAAO,CAAC,GAAG,YAAY,EAAE,CAAC;AAIzF;","names":[]}

package/lib/chunk-VERUOTB3.mjs

@@ -0,0 +1,10 @@
+// src/helpers/jsonSchemaConstraint.ts
+function _constrain(constraint, validation) {
+  validation.jsonSchema = constraint;
+  return validation;
+}
+
+export {
+  _constrain
+};
+//# sourceMappingURL=chunk-VERUOTB3.mjs.map

package/lib/chunk-VERUOTB3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/helpers/jsonSchemaConstraint.ts"],"sourcesContent":["import type { JSONSchema } from '../toJSONSchema';\n\n/**\n * Records the JSON Schema keywords an assertion stands for, on the validation itself.\n *\n * The generator only ever sees the closure a factory returned, not the factory or the arguments it was\n * given, so an assertion that wants to appear in the output has to carry its own translation. Those\n * with no JSON Schema equivalent simply do not call this, and are absent from the output rather than\n * approximated.\n */\nexport function _constrain<T extends (...args: never[]) => void>(constraint: JSONSchema, validation: T): T {\n  (validation as T & { jsonSchema?: JSONSchema }).jsonSchema = constraint;\n  return validation;\n}\n"],"mappings":";AAUO,SAAS,WAAiD,YAAwB,YAAkB;AACzG,EAAC,WAA+C,aAAa;AAC7D,SAAO;AACT;","names":[]}

package/lib/{chunk-62EKGBXF.js → chunk-VGOAXY26.js}

@@ -1,21 +1,24 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
+var _chunkWOPNDC4Rjs = require('./chunk-WOPNDC4R.js');
+
+
+var _chunkZJGY6EOEjs = require('./chunk-ZJGY6EOE.js');
 
 // src/asserts/string/uuid.ts
 var uuidErrorMessage = "The received value is not a valid UUID";
 var uuidErrorKey = "s:uuid";
 var uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var uuid = () => (received, ctx) => {
+var uuid = () => _chunkWOPNDC4Rjs._constrain.call(void 0, { format: "uuid" }, (received, ctx) => {
   if (!uuidPattern.test(received)) {
     ctx.addIssue("uuid", received, uuidErrorKey);
   }
-};
+});
 uuid.key = uuidErrorKey;
 uuid.message = uuidErrorMessage;
-_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, uuid);
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, uuid);
 
 
 
 exports.uuid = uuid;
-//# sourceMappingURL=chunk-62EKGBXF.js.map
+//# sourceMappingURL=chunk-VGOAXY26.js.map

package/lib/chunk-VGOAXY26.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-VGOAXY26.js","../src/asserts/string/uuid.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACHA,IAAM,iBAAA,EAAmB,wCAAA;AACzB,IAAM,aAAA,EAAe,QAAA;AAErB,IAAM,YAAA,EAAc,iEAAA;AAab,IAAM,KAAA,EAAO,CAAA,EAAA,GAClB,yCAAA,EAAa,MAAA,EAAQ,OAAO,CAAA,EAAG,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC1E,EAAA,GAAA,CAAI,CAAC,WAAA,CAAY,IAAA,CAAK,QAAQ,CAAA,EAAG;AAC/B,IAAA,GAAA,CAAI,QAAA,CAAS,MAAA,EAAQ,QAAA,EAAU,YAAY,CAAA;AAAA,EAC7C;AACF,CAAC,CAAA;AAEH,IAAA,CAAK,IAAA,EAAM,YAAA;AACX,IAAA,CAAK,QAAA,EAAU,gBAAA;AACf,iDAAA,IAAuB,CAAA;ADVvB;AACA;AACE;AACF,oBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-VGOAXY26.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst uuidErrorMessage = 'The received value is not a valid UUID';\nconst uuidErrorKey = 's:uuid';\n\nconst uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;\n\n/**\n * @description Asserts that a string value matches the UUID 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.\n * @example\n * const schema = string().custom(uuid());\n * parseOrFail(schema, '123e4567-e89b-12d3-a456-426614174000'); // Valid\n * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID'\n *\n * @translation Error Translation Key = 's:uuid'\n */\nexport const uuid = (): RequiredValidation<string> =>\n  _constrain({ format: 'uuid' }, (received: string, ctx: ExceptionContext) => {\n    if (!uuidPattern.test(received)) {\n      ctx.addIssue('uuid', received, uuidErrorKey);\n    }\n  });\n\nuuid.key = uuidErrorKey;\nuuid.message = uuidErrorMessage;\nsetToDefaultLocale(uuid);\n"]}

package/lib/chunk-VKSBOWCE.mjs

@@ -0,0 +1,50 @@
+import {
+  ObjectSchema
+} from "./chunk-KAFZGQ2W.mjs";
+import {
+  CommonSchema
+} from "./chunk-LDZFOOWN.mjs";
+import {
+  ctxSymbol
+} from "./chunk-C76DLZFD.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-O2WD4JBG.mjs";
+
+// src/asserts/intersection/index.ts
+function intersection(intersectionSchemas) {
+  if (!Array.isArray(intersectionSchemas) || !intersectionSchemas.length)
+    throw new BuildSchemaError("Missing schemas in intersection method");
+  const mergedShape = {};
+  const mergedValidations = [];
+  let allowUnrecognized = false;
+  intersectionSchemas.forEach((intersectionSchema, index) => {
+    if (!(intersectionSchema instanceof CommonSchema))
+      throw new BuildSchemaError(`Invalid schema in intersection method at index '${index}'`);
+    const memberData = intersectionSchema[ctxSymbol];
+    if (!memberData.object)
+      throw new BuildSchemaError(`Schema in intersection method at index '${index}' is not an object schema`);
+    if (memberData.isNullable || memberData.isOptional)
+      throw new BuildSchemaError(`Schema in intersection method at index '${index}' cannot be nullable or optional`);
+    for (const [key, valueSchema] of Object.entries(memberData.object)) {
+      if (Object.prototype.hasOwnProperty.call(mergedShape, key))
+        throw new BuildSchemaError(`Duplicate property '${key}' in intersection method`);
+      mergedShape[key] = valueSchema;
+    }
+    mergedValidations.push(...memberData.requiredValidations);
+    allowUnrecognized = allowUnrecognized || Boolean(memberData.allowUnrecognizedObjectProps);
+  });
+  return new ObjectSchema(
+    {
+      type: [],
+      requiredValidations: mergedValidations,
+      allowUnrecognizedObjectProps: allowUnrecognized || void 0
+    },
+    mergedShape
+  );
+}
+
+export {
+  intersection
+};
+//# sourceMappingURL=chunk-VKSBOWCE.mjs.map

package/lib/chunk-VKSBOWCE.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/intersection/index.ts"],"sourcesContent":["import { IntersectShapes, WithObject } from '../../commonTypes';\nimport { CommonSchema, ObjectShapeSchemaType, RequiredValidation } from '../../core';\nimport { ObjectSchema } from '../object/index';\nimport { BuildSchemaError } from '../../exceptions';\nimport { ctxSymbol } from '../../helpers/constants';\n\ntype ObjectSchemaLike = WithObject<CommonSchema, ObjectShapeSchemaType>;\n\n/**\n * @description Combines several object schemas into one that requires all of them.\n *\n * The shapes are merged when the schema is built, so the result is an ordinary object schema: a key\n * declared by any member is recognised, and validation, inference and code generation all follow from\n * the merged shape. That is what makes `intersection([object({ a }), object({ b })])` accept\n * `{ a, b }` — validating against each member separately would have the first reject `b` as an\n * unrecognised property.\n *\n * Members must be object schemas, and a key may not be declared twice. Two members declaring the same\n * key would give `A & B` for that property in the type while only one schema could run at validation\n * time, so it is rejected rather than silently resolved one way.\n *\n * @template T\n * @param {T} intersectionSchemas - The object schemas to combine.\n * @returns A new object schema inferring the intersection of its members' types.\n * @example\n * const withId = object({ id: string() });\n * const withName = object({ name: string() });\n * const schema = intersection([withId, withName]);\n * parseOrFail(schema, { id: '1', name: 'a' }); // Validates successfully\n * parseOrFail(schema, { id: '1' }); // Throws a validation error\n *\n * @instance Of CommonSchema\n */\nexport function intersection<T extends [ObjectSchemaLike, ...ObjectSchemaLike[]]>(\n  intersectionSchemas: T,\n): WithObject<ObjectSchema, IntersectShapes<T>> {\n  if (!Array.isArray(intersectionSchemas) || !intersectionSchemas.length)\n    throw new BuildSchemaError('Missing schemas in intersection method');\n\n  const mergedShape: ObjectShapeSchemaType = {};\n  const mergedValidations: RequiredValidation[] = [];\n  let allowUnrecognized = false;\n\n  intersectionSchemas.forEach((intersectionSchema, index) => {\n    if (!(intersectionSchema instanceof CommonSchema))\n      throw new BuildSchemaError(`Invalid schema in intersection method at index '${index}'`);\n\n    const memberData = intersectionSchema[ctxSymbol];\n    if (!memberData.object)\n      throw new BuildSchemaError(`Schema in intersection method at index '${index}' is not an object schema`);\n\n    // A nullable or optional member would mean `({ a } | null) & { b }`, which the merged shape\n    // cannot express. Rejected rather than quietly dropped.\n    if (memberData.isNullable || memberData.isOptional)\n      throw new BuildSchemaError(`Schema in intersection method at index '${index}' cannot be nullable or optional`);\n\n    for (const [key, valueSchema] of Object.entries(memberData.object)) {\n      if (Object.prototype.hasOwnProperty.call(mergedShape, key))\n        throw new BuildSchemaError(`Duplicate property '${key}' in intersection method`);\n\n      mergedShape[key] = valueSchema;\n    }\n\n    mergedValidations.push(...memberData.requiredValidations);\n    allowUnrecognized = allowUnrecognized || Boolean(memberData.allowUnrecognizedObjectProps);\n  });\n\n  // A real ObjectSchema, not a bare CommonSchema: the result is an object schema in every respect,\n  // including the methods that only that class defines, such as allowUnrecognized.\n  return new ObjectSchema(\n    {\n      type: [],\n      requiredValidations: mergedValidations,\n      allowUnrecognizedObjectProps: allowUnrecognized || undefined,\n    },\n    mergedShape,\n  ) as WithObject<ObjectSchema, IntersectShapes<T>>;\n}\n"],"mappings":";;;;;;;;;;;;;;AAiCO,SAAS,aACd,qBAC8C;AAC9C,MAAI,CAAC,MAAM,QAAQ,mBAAmB,KAAK,CAAC,oBAAoB;AAC9D,UAAM,IAAI,iBAAiB,wCAAwC;AAErE,QAAM,cAAqC,CAAC;AAC5C,QAAM,oBAA0C,CAAC;AACjD,MAAI,oBAAoB;AAExB,sBAAoB,QAAQ,CAAC,oBAAoB,UAAU;AACzD,QAAI,EAAE,8BAA8B;AAClC,YAAM,IAAI,iBAAiB,mDAAmD,KAAK,GAAG;AAExF,UAAM,aAAa,mBAAmB,SAAS;AAC/C,QAAI,CAAC,WAAW;AACd,YAAM,IAAI,iBAAiB,2CAA2C,KAAK,2BAA2B;AAIxG,QAAI,WAAW,cAAc,WAAW;AACtC,YAAM,IAAI,iBAAiB,2CAA2C,KAAK,kCAAkC;AAE/G,eAAW,CAAC,KAAK,WAAW,KAAK,OAAO,QAAQ,WAAW,MAAM,GAAG;AAClE,UAAI,OAAO,UAAU,eAAe,KAAK,aAAa,GAAG;AACvD,cAAM,IAAI,iBAAiB,uBAAuB,GAAG,0BAA0B;AAEjF,kBAAY,GAAG,IAAI;AAAA,IACrB;AAEA,sBAAkB,KAAK,GAAG,WAAW,mBAAmB;AACxD,wBAAoB,qBAAqB,QAAQ,WAAW,4BAA4B;AAAA,EAC1F,CAAC;AAID,SAAO,IAAI;AAAA,IACT;AAAA,MACE,MAAM,CAAC;AAAA,MACP,qBAAqB;AAAA,MACrB,8BAA8B,qBAAqB;AAAA,IACrD;AAAA,IACA;AAAA,EACF;AACF;","names":[]}

package/lib/chunk-VT2JBMWQ.mjs

@@ -0,0 +1,27 @@
+import {
+  _objectFrom,
+  _shapeOf
+} from "./chunk-A36G62K5.mjs";
+import {
+  BuildSchemaError
+} from "./chunk-O2WD4JBG.mjs";
+
+// src/asserts/object/omit.ts
+function omit(schema, keys) {
+  const shape = _shapeOf(schema, "omit");
+  const dropped = new Set(keys);
+  for (const key of keys) {
+    if (!Object.prototype.hasOwnProperty.call(shape, key))
+      throw new BuildSchemaError(`Unknown property '${key}' in omit method`);
+  }
+  const kept = {};
+  for (const [key, valueSchema] of Object.entries(shape)) {
+    if (!dropped.has(key)) kept[key] = valueSchema;
+  }
+  return _objectFrom(schema, kept);
+}
+
+export {
+  omit
+};
+//# sourceMappingURL=chunk-VT2JBMWQ.mjs.map

package/lib/chunk-VT2JBMWQ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/object/omit.ts"],"sourcesContent":["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 without the named properties.\n *\n * The original is untouched.\n *\n * @template T\n * @template K\n * @param {WithObject<CommonSchema, T>} schema - The object schema to narrow.\n * @param {readonly K[]} keys - The properties to drop.\n * @returns A new object schema without those properties.\n * @example\n * const userSchema = object({ id: string(), name: string(), secret: string() });\n * const publicSchema = omit(userSchema, ['secret']);\n * parseOrFail(publicSchema, { id: '1', name: 'a' }); // Validates successfully\n *\n * @instance Of CommonSchema\n */\nexport function omit<T extends ObjectShapeSchemaType, K extends keyof T & string>(\n  schema: WithObject<CommonSchema, T>,\n  keys: readonly K[],\n): WithObject<ObjectSchema, Omit<T, K>> {\n  const shape = _shapeOf(schema, 'omit');\n  const dropped = new Set<string>(keys);\n\n  for (const key of keys) {\n    if (!Object.prototype.hasOwnProperty.call(shape, key))\n      throw new BuildSchemaError(`Unknown property '${key}' in omit method`);\n  }\n\n  const kept: ObjectShapeSchemaType = {};\n  for (const [key, valueSchema] of Object.entries(shape)) {\n    if (!dropped.has(key)) kept[key] = valueSchema;\n  }\n\n  return _objectFrom(schema, kept) as unknown as WithObject<ObjectSchema, Omit<T, K>>;\n}\n"],"mappings":";;;;;;;;;AAuBO,SAAS,KACd,QACA,MACsC;AACtC,QAAM,QAAQ,SAAS,QAAQ,MAAM;AACrC,QAAM,UAAU,IAAI,IAAY,IAAI;AAEpC,aAAW,OAAO,MAAM;AACtB,QAAI,CAAC,OAAO,UAAU,eAAe,KAAK,OAAO,GAAG;AAClD,YAAM,IAAI,iBAAiB,qBAAqB,GAAG,kBAAkB;AAAA,EACzE;AAEA,QAAM,OAA8B,CAAC;AACrC,aAAW,CAAC,KAAK,WAAW,KAAK,OAAO,QAAQ,KAAK,GAAG;AACtD,QAAI,CAAC,QAAQ,IAAI,GAAG,EAAG,MAAK,GAAG,IAAI;AAAA,EACrC;AAEA,SAAO,YAAY,QAAQ,IAAI;AACjC;","names":[]}

package/lib/{chunk-LXZTBF7F.js → chunk-VWHKNZLG.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/bigintMax.ts
 var bigintMaxErrorMessage = "The received value is greater than expected";
@@ -10,9 +10,9 @@ var bigintMax = (expected) => (received, ctx) => {
 };
 bigintMax.key = bigintMaxErrorKey;
 bigintMax.message = bigintMaxErrorMessage;
-_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, bigintMax);
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, bigintMax);
 
 
 
 exports.bigintMax = bigintMax;
-//# sourceMappingURL=chunk-LXZTBF7F.js.map
+//# sourceMappingURL=chunk-VWHKNZLG.js.map

package/lib/{chunk-LXZTBF7F.js.map → chunk-VWHKNZLG.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-LXZTBF7F.js","../src/asserts/bigint/bigintMax.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,IAAM,sBAAA,EAAwB,6CAAA;AAC9B,IAAM,kBAAA,EAAoB,QAAA;AAenB,IAAM,UAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC3C,EAAA,GAAA,CAAI,SAAA,EAAW,QAAA,EAAU,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,iBAAiB,CAAA;AAC7E,CAAA;AAEF,SAAA,CAAU,IAAA,EAAM,iBAAA;AAChB,SAAA,CAAU,QAAA,EAAU,qBAAA;AACpB,iDAAA,SAA4B,CAAA;ADd5B;AACA;AACE;AACF,8BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-LXZTBF7F.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst bigintMaxErrorMessage = 'The received value is greater than expected';\nconst bigintMaxErrorKey = 'bi:max';\n\n/**\n * @description Asserts that a bigint value does not exceed a specified maximum value.\n * @param {bigint} expected The maximum allowable value.\n * @returns {RequiredValidation} A validation function that takes a received bigint and an exception context.\n * @throws {ValidationError} if the received value exceeds the expected maximum value.\n * @example\n * const schema = bigint().custom(bigintMax(100n));\n * parseOrFail(schema, 99n);  // Valid\n * parseOrFail(schema, 100n); // Valid\n * parseOrFail(schema, 101n); // Throws an error: 'The received value is greater than expected'\n *\n * @translation Error Translation Key = 'bi:max'\n */\nexport const bigintMax =\n  (expected: bigint): RequiredValidation =>\n  (received: bigint, ctx: ExceptionContext) => {\n    if (expected < received) ctx.addIssue(expected, received, bigintMaxErrorKey);\n  };\n\nbigintMax.key = bigintMaxErrorKey;\nbigintMax.message = bigintMaxErrorMessage;\nsetToDefaultLocale(bigintMax);\n"]}
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-VWHKNZLG.js","../src/asserts/bigint/bigintMax.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,IAAM,sBAAA,EAAwB,6CAAA;AAC9B,IAAM,kBAAA,EAAoB,QAAA;AAenB,IAAM,UAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC3C,EAAA,GAAA,CAAI,SAAA,EAAW,QAAA,EAAU,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,iBAAiB,CAAA;AAC7E,CAAA;AAEF,SAAA,CAAU,IAAA,EAAM,iBAAA;AAChB,SAAA,CAAU,QAAA,EAAU,qBAAA;AACpB,iDAAA,SAA4B,CAAA;ADd5B;AACA;AACE;AACF,8BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-VWHKNZLG.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst bigintMaxErrorMessage = 'The received value is greater than expected';\nconst bigintMaxErrorKey = 'bi:max';\n\n/**\n * @description Asserts that a bigint value does not exceed a specified maximum value.\n * @param {bigint} expected The maximum allowable value.\n * @returns {RequiredValidation} A validation function that takes a received bigint and an exception context.\n * @throws {ValidationError} if the received value exceeds the expected maximum value.\n * @example\n * const schema = bigint().custom(bigintMax(100n));\n * parseOrFail(schema, 99n);  // Valid\n * parseOrFail(schema, 100n); // Valid\n * parseOrFail(schema, 101n); // Throws an error: 'The received value is greater than expected'\n *\n * @translation Error Translation Key = 'bi:max'\n */\nexport const bigintMax =\n  (expected: bigint): RequiredValidation<bigint> =>\n  (received: bigint, ctx: ExceptionContext) => {\n    if (expected < received) ctx.addIssue(expected, received, bigintMaxErrorKey);\n  };\n\nbigintMax.key = bigintMaxErrorKey;\nbigintMax.message = bigintMaxErrorMessage;\nsetToDefaultLocale(bigintMax);\n"]}

package/lib/{chunk-TLRVQWCI.mjs → chunk-WL7BV4XV.mjs}

@@ -1,24 +1,27 @@
+import {
+  _constrain
+} from "./chunk-VERUOTB3.mjs";
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.mjs";
 
 // src/asserts/string/isValidTime.ts
 var timeErrorMessage = "The received value is not a valid time";
 var timeErrorKey = "s:isValidTime";
 var isValidTime = (options = {}) => {
-  return (received, ctx) => {
+  return _constrain({ format: "time" }, (received, ctx) => {
     const { precision } = options;
     let timeRegex = /^([01]\d|2[0-3]):([0-5]\d):([0-5]\d)(\.\d+)?$/;
     if (precision !== void 0) {
       timeRegex = new RegExp(`^([01]\\d|2[0-3]):([0-5]\\d):([0-5]\\d)(\\.\\d{${precision}})?$`);
     }
     if (!timeRegex.test(received)) {
-      ctx.addIssue(received, timeErrorMessage, timeErrorKey);
+      ctx.addIssue("valid time", received, timeErrorKey);
     }
     if (precision !== void 0 && !received.includes(".")) {
-      ctx.addIssue(received, timeErrorMessage, timeErrorKey);
+      ctx.addIssue("valid time", received, timeErrorKey);
     }
-  };
+  });
 };
 isValidTime.key = timeErrorKey;
 isValidTime.message = timeErrorMessage;
@@ -27,4 +30,4 @@ setToDefaultLocale(isValidTime);
 export {
   isValidTime
 };
-//# sourceMappingURL=chunk-TLRVQWCI.mjs.map
+//# sourceMappingURL=chunk-WL7BV4XV.mjs.map

package/lib/chunk-WL7BV4XV.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/isValidTime.ts"],"sourcesContent":["import { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\n\nconst timeErrorMessage = 'The received value is not a valid time';\nconst timeErrorKey = 's:isValidTime';\n\ninterface IsValidTimeOptions {\n  precision?: number;\n}\n\n/**\n * @description Asserts that a string is a valid time in the format HH:mm:ss, with optional fractional seconds.\n * @param {IsValidTimeOptions} options Optional settings to configure the validation.\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 time.\n * @example\n * const schema = string().custom(isValidTime());\n * parseOrFail(schema, \"00:00:00\"); // Valid\n * parseOrFail(schema, \"23:59:59.9999999\"); // Valid\n * parseOrFail(schema, \"00:00:00.256Z\");   // Throws an error: 'The received value is not a valid time'\n *\n * const schemaWithPrecision = string().custom(isValidTime({ precision: 3 }));\n * parseOrFail(schemaWithPrecision, \"00:00:00.256\"); // Valid\n * parseOrFail(schemaWithPrecision, \"00:00:00\");    // Throws an error: 'The received value is not a valid time'\n *\n * @translation Error Translation Key = 's:isValidTime'\n */\nexport const isValidTime = (options: IsValidTimeOptions = {}): RequiredValidation<string> => {\n  return _constrain({ format: 'time' }, (received: string, ctx: ExceptionContext) => {\n    const { precision } = options;\n\n    // Base regex for HH:mm:ss format\n    let timeRegex = /^([01]\\d|2[0-3]):([0-5]\\d):([0-5]\\d)(\\.\\d+)?$/;\n\n    // If precision is specified, enforce exact number of digits in fractional seconds\n    if (precision !== undefined) {\n      timeRegex = new RegExp(`^([01]\\\\d|2[0-3]):([0-5]\\\\d):([0-5]\\\\d)(\\\\.\\\\d{${precision}})?$`);\n    }\n\n    // Check if the string is a valid time\n    if (!timeRegex.test(received)) {\n      ctx.addIssue('valid time', received, timeErrorKey);\n    }\n\n    // Additional check for precision if it's specified and the time does not have fractional seconds\n    if (precision !== undefined && !received.includes('.')) {\n      ctx.addIssue('valid time', received, timeErrorKey);\n    }\n  });\n};\n\nisValidTime.key = timeErrorKey;\nisValidTime.message = timeErrorMessage;\nsetToDefaultLocale(isValidTime);\n"],"mappings":";;;;;;;;AAIA,IAAM,mBAAmB;AACzB,IAAM,eAAe;AAuBd,IAAM,cAAc,CAAC,UAA8B,CAAC,MAAkC;AAC3F,SAAO,WAAW,EAAE,QAAQ,OAAO,GAAG,CAAC,UAAkB,QAA0B;AACjF,UAAM,EAAE,UAAU,IAAI;AAGtB,QAAI,YAAY;AAGhB,QAAI,cAAc,QAAW;AAC3B,kBAAY,IAAI,OAAO,kDAAkD,SAAS,MAAM;AAAA,IAC1F;AAGA,QAAI,CAAC,UAAU,KAAK,QAAQ,GAAG;AAC7B,UAAI,SAAS,cAAc,UAAU,YAAY;AAAA,IACnD;AAGA,QAAI,cAAc,UAAa,CAAC,SAAS,SAAS,GAAG,GAAG;AACtD,UAAI,SAAS,cAAc,UAAU,YAAY;AAAA,IACnD;AAAA,EACF,CAAC;AACH;AAEA,YAAY,MAAM;AAClB,YAAY,UAAU;AACtB,mBAAmB,WAAW;","names":[]}

package/lib/chunk-WOPNDC4R.js

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/helpers/jsonSchemaConstraint.ts
+function _constrain(constraint, validation) {
+  validation.jsonSchema = constraint;
+  return validation;
+}
+
+
+
+exports._constrain = _constrain;
+//# sourceMappingURL=chunk-WOPNDC4R.js.map

package/lib/chunk-WOPNDC4R.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-WOPNDC4R.js","../src/helpers/jsonSchemaConstraint.ts"],"names":[],"mappings":"AAAA;ACUO,SAAS,UAAA,CAAiD,UAAA,EAAwB,UAAA,EAAkB;AACzG,EAAC,UAAA,CAA+C,WAAA,EAAa,UAAA;AAC7D,EAAA,OAAO,UAAA;AACT;ADRA;AACA;AACE;AACF,gCAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-WOPNDC4R.js","sourcesContent":[null,"import type { JSONSchema } from '../toJSONSchema';\n\n/**\n * Records the JSON Schema keywords an assertion stands for, on the validation itself.\n *\n * The generator only ever sees the closure a factory returned, not the factory or the arguments it was\n * given, so an assertion that wants to appear in the output has to carry its own translation. Those\n * with no JSON Schema equivalent simply do not call this, and are absent from the output rather than\n * approximated.\n */\nexport function _constrain<T extends (...args: never[]) => void>(constraint: JSONSchema, validation: T): T {\n  (validation as T & { jsonSchema?: JSONSchema }).jsonSchema = constraint;\n  return validation;\n}\n"]}

package/lib/chunk-X6SI76NQ.js

@@ -0,0 +1,22 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk6LUSV3SSjs = require('./chunk-6LUSV3SS.js');
+
+
+var _chunkZWFSAKQKjs = require('./chunk-ZWFSAKQK.js');
+
+// src/asserts/tuple/index.ts
+function tuple(tupleSchemas) {
+  if (!Array.isArray(tupleSchemas) || !tupleSchemas.length)
+    throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)("Missing schemas in tuple method");
+  tupleSchemas.forEach((tupleSchema, index) => {
+    if (!(tupleSchema instanceof _chunk6LUSV3SSjs.CommonSchema))
+      throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)(`Invalid schema in tuple method at index '${index}'`);
+  });
+  return new (0, _chunk6LUSV3SSjs.CommonSchema)({ type: [], requiredValidations: [], tuple: [...tupleSchemas] });
+}
+
+
+
+exports.tuple = tuple;
+//# sourceMappingURL=chunk-X6SI76NQ.js.map

package/lib/chunk-X6SI76NQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-X6SI76NQ.js","../src/asserts/tuple/index.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACgBO,SAAS,KAAA,CAAmD,YAAA,EAA6C;AAC9G,EAAA,GAAA,CAAI,CAAC,KAAA,CAAM,OAAA,CAAQ,YAAY,EAAA,GAAK,CAAC,YAAA,CAAa,MAAA;AAChD,IAAA,MAAM,IAAI,sCAAA,CAAiB,iCAAiC,CAAA;AAE9D,EAAA,YAAA,CAAa,OAAA,CAAQ,CAAC,WAAA,EAAa,KAAA,EAAA,GAAU;AAC3C,IAAA,GAAA,CAAI,CAAA,CAAE,YAAA,WAAuB,6BAAA,CAAA;AAC3B,MAAA,MAAM,IAAI,sCAAA,CAAiB,CAAA,yCAAA,EAA4C,KAAK,CAAA,CAAA,CAAG,CAAA;AAAA,EACnF,CAAC,CAAA;AAED,EAAA,OAAO,IAAI,kCAAA,CAAa,EAAE,IAAA,EAAM,CAAC,CAAA,EAAG,mBAAA,EAAqB,CAAC,CAAA,EAAG,KAAA,EAAO,CAAC,GAAG,YAAY,EAAE,CAAC,CAAA;AAIzF;ADnBA;AACA;AACE;AACF,sBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-X6SI76NQ.js","sourcesContent":[null,"import { WithTuple } from '../../commonTypes';\nimport { CommonSchema } from '../../core';\nimport { BuildSchemaError } from '../../exceptions';\n\n/**\n * @description Creates a new schema for an array of a fixed length, where each position has its own\n * schema.\n *\n * The received value must be an array of exactly that many entries. Unlike `array`, which applies one\n * schema to every element, each position here is validated against the schema declared for it, and\n * the inferred type keeps the positions distinct.\n *\n * @template T\n * @param {T} tupleSchemas - The schema for each position, in order.\n * @returns A new schema inferring a tuple of its positions' types.\n * @example\n * const schema = tuple([string(), number()]);\n * parseOrFail(schema, ['a', 1]); // Validates successfully\n * parseOrFail(schema, [1, 'a']); // Throws a validation error\n * parseOrFail(schema, ['a']); // Throws a validation error, wrong length\n *\n * @instance Of CommonSchema\n */\nexport function tuple<T extends [CommonSchema, ...CommonSchema[]]>(tupleSchemas: T): WithTuple<CommonSchema, T> {\n  if (!Array.isArray(tupleSchemas) || !tupleSchemas.length)\n    throw new BuildSchemaError('Missing schemas in tuple method');\n\n  tupleSchemas.forEach((tupleSchema, index) => {\n    if (!(tupleSchema instanceof CommonSchema))\n      throw new BuildSchemaError(`Invalid schema in tuple method at index '${index}'`);\n  });\n\n  return new CommonSchema({ type: [], requiredValidations: [], tuple: [...tupleSchemas] }) as WithTuple<\n    CommonSchema,\n    T\n  >;\n}\n"]}