bguard 0.6.0 → 0.7.1

package/lib/{chunk-PAV4SQQL.js.map → chunk-3D6TPN7F.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-PAV4SQQL.js","../src/asserts/mix/oneOfValues.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,IAAM,wBAAA,EAA0B,6CAAA;AAChC,IAAM,oBAAA,EAAsB,eAAA;AAgBrB,IAAM,YAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAmB,GAAA,EAAA,GAA0B;AAC5C,EAAA,GAAA,CAAI,CAAC,QAAA,CAAS,QAAA,CAAS,QAAQ,CAAA,EAAG,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,mBAAmB,CAAA;AACxF,CAAA;AAEF,WAAA,CAAY,IAAA,EAAM,mBAAA;AAClB,WAAA,CAAY,QAAA,EAAU,uBAAA;AACtB,iDAAA,WAA8B,CAAA;ADf9B;AACA;AACE;AACF,kCAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-PAV4SQQL.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst oneOfValuesErrorMessage = 'The received value is not equal to expected';\nconst oneOfValuesErrorKey = 'm:oneOfValues';\n\n/**\n * @description Creates a custom assertion that checks if a value is equal to the one of expected values.\n * @notice It has already been implemented in the number, bigint and string schema. There is no need to use it as a custom assert.\n * @param {unknown} expected The value that the received value is expected to match.\n * @returns {RequiredValidation} A validation function that takes a received value and an exception context.\n * @throws {ValidationError} If the received value does not match at least one of the expected values.\n * @example\n * const schema = number().custom(oneOfValues([5, 4])); // Define a schema with a custom assertion\n * parseOrFail(schema, 5); // Valid\n * parseOrFail(schema, 4); // Valid\n * parseOrFail(schema, 3); // Throws an error: 'The received value is not equal to expected'\n *\n * @translation Error Translation Key = 'm:oneOfValues'\n */\nexport const oneOfValues =\n  (expected: unknown[]): RequiredValidation =>\n  (received: unknown, ctx: ExceptionContext) => {\n    if (!expected.includes(received)) ctx.addIssue(expected, received, oneOfValuesErrorKey);\n  };\n\noneOfValues.key = oneOfValuesErrorKey;\noneOfValues.message = oneOfValuesErrorMessage;\nsetToDefaultLocale(oneOfValues);\n"]}
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-3D6TPN7F.js","../src/asserts/mix/oneOfValues.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,IAAM,wBAAA,EAA0B,6CAAA;AAChC,IAAM,oBAAA,EAAsB,eAAA;AAgBrB,IAAM,YAAA,EACX,CAAC,QAAA,EAAA,GACD,CAAC,QAAA,EAAmB,GAAA,EAAA,GAA0B;AAC5C,EAAA,GAAA,CAAI,CAAC,QAAA,CAAS,QAAA,CAAS,QAAQ,CAAA,EAAG,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,mBAAmB,CAAA;AACxF,CAAA;AAEF,WAAA,CAAY,IAAA,EAAM,mBAAA;AAClB,WAAA,CAAY,QAAA,EAAU,uBAAA;AACtB,iDAAA,WAA8B,CAAA;ADf9B;AACA;AACE;AACF,kCAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-3D6TPN7F.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst oneOfValuesErrorMessage = 'The received value is not equal to expected';\nconst oneOfValuesErrorKey = 'm:oneOfValues';\n\n/**\n * @description Creates a custom assertion that checks if a value is equal to the one of expected values.\n * @notice It has already been implemented in the number, bigint and string schema. There is no need to use it as a custom assert.\n * @param {unknown} expected The value that the received value is expected to match.\n * @returns {RequiredValidation} A validation function that takes a received value and an exception context.\n * @throws {ValidationError} If the received value does not match at least one of the expected values.\n * @example\n * const schema = number().custom(oneOfValues([5, 4])); // Define a schema with a custom assertion\n * parseOrFail(schema, 5); // Valid\n * parseOrFail(schema, 4); // Valid\n * parseOrFail(schema, 3); // Throws an error: 'The received value is not equal to expected'\n *\n * @translation Error Translation Key = 'm:oneOfValues'\n */\nexport const oneOfValues =\n  (expected: unknown[]): RequiredValidation<unknown> =>\n  (received: unknown, ctx: ExceptionContext) => {\n    if (!expected.includes(received)) ctx.addIssue(expected, received, oneOfValuesErrorKey);\n  };\n\noneOfValues.key = oneOfValuesErrorKey;\noneOfValues.message = oneOfValuesErrorMessage;\nsetToDefaultLocale(oneOfValues);\n"]}

package/lib/{chunk-4UPXP4I3.js → chunk-3OAUE5VW.js}

@@ -1,12 +1,15 @@
 "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/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) => _chunkWOPNDC4Rjs._constrain.call(void 0, { format: "uri" }, (received, ctx) => {
   let regex = urlRegex;
   if (protocol) {
     regex = new RegExp(`^${protocol}:\\/\\/([a-zA-Z0-9\\-\\.]+)(:[0-9]+)?(\\/[^\\s]*)?$`);
@@ -14,12 +17,12 @@ var validUrl = (protocol) => (received, ctx) => {
   if (!regex.test(received)) {
     ctx.addIssue("Invalid URL", received, validUrlErrorKey);
   }
-};
+});
 validUrl.key = validUrlErrorKey;
 validUrl.message = validUrlErrorMessage;
-_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, validUrl);
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, validUrl);
 
 
 
 exports.validUrl = validUrl;
-//# sourceMappingURL=chunk-4UPXP4I3.js.map
+//# sourceMappingURL=chunk-3OAUE5VW.js.map

package/lib/chunk-3OAUE5VW.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-3OAUE5VW.js","../src/asserts/string/validUrl.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACHA,IAAM,qBAAA,EAAuB,uCAAA;AAC7B,IAAM,iBAAA,EAAmB,YAAA;AAEzB,IAAM,SAAA,EAAW,6DAAA;AAgBV,IAAM,SAAA,EAAW,CAAC,QAAA,EAAA,GACvB,yCAAA,EAAa,MAAA,EAAQ,MAAM,CAAA,EAAG,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AACzE,EAAA,IAAI,MAAA,EAAQ,QAAA;AACZ,EAAA,GAAA,CAAI,QAAA,EAAU;AACZ,IAAA,MAAA,EAAQ,IAAI,MAAA,CAAO,CAAA,CAAA,EAAI,QAAQ,CAAA,mDAAA,CAAqD,CAAA;AAAA,EACtF;AAEA,EAAA,GAAA,CAAI,CAAC,KAAA,CAAM,IAAA,CAAK,QAAQ,CAAA,EAAG;AACzB,IAAA,GAAA,CAAI,QAAA,CAAS,aAAA,EAAe,QAAA,EAAU,gBAAgB,CAAA;AAAA,EACxD;AACF,CAAC,CAAA;AAEH,QAAA,CAAS,IAAA,EAAM,gBAAA;AACf,QAAA,CAAS,QAAA,EAAU,oBAAA;AACnB,iDAAA,QAA2B,CAAA;ADd3B;AACA;AACE;AACF,4BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-3OAUE5VW.js","sourcesContent":[null,"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"]}

package/lib/chunk-3PTVMZY7.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/union/index.ts
+function union(unionSchemas) {
+  if (!Array.isArray(unionSchemas) || !unionSchemas.length)
+    throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)("Missing schemas in union method");
+  unionSchemas.forEach((unionSchema, index) => {
+    if (!(unionSchema instanceof _chunk6LUSV3SSjs.CommonSchema))
+      throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)(`Invalid schema in union method at index '${index}'`);
+  });
+  return new (0, _chunk6LUSV3SSjs.CommonSchema)({ type: [], requiredValidations: [], union: [...unionSchemas] });
+}
+
+
+
+exports.union = union;
+//# sourceMappingURL=chunk-3PTVMZY7.js.map

package/lib/chunk-3PTVMZY7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-3PTVMZY7.js","../src/asserts/union/index.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACiBO,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;ADpBA;AACA;AACE;AACF,sBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-3PTVMZY7.js","sourcesContent":[null,"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"]}

package/lib/{chunk-QEG24G7E.mjs → chunk-3T5QKF7X.mjs}

@@ -1,6 +1,6 @@
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.mjs";
 
 // src/asserts/bigint/bigintMax.ts
 var bigintMaxErrorMessage = "The received value is greater than expected";
@@ -15,4 +15,4 @@ setToDefaultLocale(bigintMax);
 export {
   bigintMax
 };
-//# sourceMappingURL=chunk-QEG24G7E.mjs.map
+//# sourceMappingURL=chunk-3T5QKF7X.mjs.map

package/lib/{chunk-QEG24G7E.mjs.map → chunk-3T5QKF7X.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/asserts/bigint/bigintMax.ts"],"sourcesContent":["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"],"mappings":";;;;;AAGA,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAenB,IAAM,YACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,WAAW,SAAU,KAAI,SAAS,UAAU,UAAU,iBAAiB;AAC7E;AAEF,UAAU,MAAM;AAChB,UAAU,UAAU;AACpB,mBAAmB,SAAS;","names":[]}
+{"version":3,"sources":["../src/asserts/bigint/bigintMax.ts"],"sourcesContent":["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"],"mappings":";;;;;AAGA,IAAM,wBAAwB;AAC9B,IAAM,oBAAoB;AAenB,IAAM,YACX,CAAC,aACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,WAAW,SAAU,KAAI,SAAS,UAAU,UAAU,iBAAiB;AAC7E;AAEF,UAAU,MAAM;AAChB,UAAU,UAAU;AACpB,mBAAmB,SAAS;","names":[]}

package/lib/{chunk-FI737YZJ.js → chunk-45K4AUO3.js}

@@ -1,19 +1,22 @@
 "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/email.ts
 var emailRegExp = /^[^@]+@[^@]+\.[^@]+$/;
 var emailErrorMessage = "The received value does not match the required email pattern";
 var emailErrorKey = "s:email";
-var email = () => (received, ctx) => {
-  if (!emailRegExp.test(received)) ctx.addIssue(emailRegExp, received, emailErrorMessage);
-};
+var email = () => _chunkWOPNDC4Rjs._constrain.call(void 0, { format: "email" }, (received, ctx) => {
+  if (!emailRegExp.test(received)) ctx.addIssue(emailRegExp, received, emailErrorKey);
+});
 email.key = emailErrorKey;
 email.message = emailErrorMessage;
-_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, email);
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, email);
 
 
 
 exports.email = email;
-//# sourceMappingURL=chunk-FI737YZJ.js.map
+//# sourceMappingURL=chunk-45K4AUO3.js.map

package/lib/chunk-45K4AUO3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-45K4AUO3.js","../src/asserts/string/email.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACHA,IAAM,YAAA,EAAc,sBAAA;AACpB,IAAM,kBAAA,EAAoB,8DAAA;AAC1B,IAAM,cAAA,EAAgB,SAAA;AAaf,IAAM,MAAA,EAAQ,CAAA,EAAA,GACnB,yCAAA,EAAa,MAAA,EAAQ,QAAQ,CAAA,EAAG,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC3E,EAAA,GAAA,CAAI,CAAC,WAAA,CAAY,IAAA,CAAK,QAAQ,CAAA,EAAG,GAAA,CAAI,QAAA,CAAS,WAAA,EAAa,QAAA,EAAU,aAAa,CAAA;AACpF,CAAC,CAAA;AAEH,KAAA,CAAM,IAAA,EAAM,aAAA;AACZ,KAAA,CAAM,QAAA,EAAU,iBAAA;AAChB,iDAAA,KAAwB,CAAA;ADTxB;AACA;AACE;AACF,sBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-45K4AUO3.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst emailRegExp = /^[^@]+@[^@]+\\.[^@]+$/;\nconst emailErrorMessage = 'The received value does not match the required email pattern';\nconst emailErrorKey = 's:email';\n\n/**\n * @description Asserts that a string value matches the email pattern. The pattern checks for a basic email format.\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 email pattern.\n * @example\n * const schema = string().custom(email());\n * parseOrFail(schema, 'example@example.com'); // Valid\n * parseOrFail(schema, 'invalid-email');      // Throws an error: 'The received value does not match the required email pattern'\n *\n * @translation - Error Translation Key = 's:email'\n */\nexport const email = (): RequiredValidation<string> =>\n  _constrain({ format: 'email' }, (received: string, ctx: ExceptionContext) => {\n    if (!emailRegExp.test(received)) ctx.addIssue(emailRegExp, received, emailErrorKey);\n  });\n\nemail.key = emailErrorKey;\nemail.message = emailErrorMessage;\nsetToDefaultLocale(email);\n"]}

package/lib/{chunk-PNSDUVRE.mjs → chunk-4AZOGLHD.mjs}

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

package/lib/{chunk-PNSDUVRE.mjs.map → chunk-4AZOGLHD.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/asserts/string/uuidV4.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst uuidV4ErrorMessage = 'The received value is not a valid UUID v4';\nconst uuidV4ErrorKey = 's:uuidV4';\n\nconst uuidV4Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[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 v4 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 v4.\n * @example\n * const schema = string().custom(uuidV4());\n * parseOrFail(schema, '123e4567-e89b-42d3-a456-426614174000'); // Valid\n * parseOrFail(schema, '123e4567-e89b-12d3-a456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'\n * parseOrFail(schema, '123e4567-e89b-a2d3-a456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'\n * parseOrFail(schema, '123e4567-e89b-42d3-c456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'\n * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v4'\n *\n * @translation Error Translation Key = 's:uuidV4'\n */\nexport const uuidV4 = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (!uuidV4Pattern.test(received)) {\n    ctx.addIssue('uuid v4', received, uuidV4ErrorKey);\n  }\n};\n\nuuidV4.key = uuidV4ErrorKey;\nuuidV4.message = uuidV4ErrorMessage;\nsetToDefaultLocale(uuidV4);\n"],"mappings":";;;;;AAGA,IAAM,qBAAqB;AAC3B,IAAM,iBAAiB;AAEvB,IAAM,gBAAgB;AAgBf,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/uuidV4.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst uuidV4ErrorMessage = 'The received value is not a valid UUID v4';\nconst uuidV4ErrorKey = 's:uuidV4';\n\nconst uuidV4Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[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 v4 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 v4.\n * @example\n * const schema = string().custom(uuidV4());\n * parseOrFail(schema, '123e4567-e89b-42d3-a456-426614174000'); // Valid\n * parseOrFail(schema, '123e4567-e89b-12d3-a456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'\n * parseOrFail(schema, '123e4567-e89b-a2d3-a456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'\n * parseOrFail(schema, '123e4567-e89b-42d3-c456-426614174000'); // Throws an error: 'The received value is not a valid UUID v4'\n * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v4'\n *\n * @translation Error Translation Key = 's:uuidV4'\n */\nexport const uuidV4 = (): RequiredValidation<string> => (received: string, ctx: ExceptionContext) => {\n  if (!uuidV4Pattern.test(received)) {\n    ctx.addIssue('uuid v4', received, uuidV4ErrorKey);\n  }\n};\n\nuuidV4.key = uuidV4ErrorKey;\nuuidV4.message = uuidV4ErrorMessage;\nsetToDefaultLocale(uuidV4);\n"],"mappings":";;;;;AAGA,IAAM,qBAAqB;AAC3B,IAAM,iBAAiB;AAEvB,IAAM,gBAAgB;AAgBf,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-4PPMVVQY.js

@@ -0,0 +1,67 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;
+
+var _chunkOPA6AXSHjs = require('./chunk-OPA6AXSH.js');
+
+
+var _chunk3D6TPN7Fjs = require('./chunk-3D6TPN7F.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/number/index.ts
+function number() {
+  return new NumberSchema({ type: ["number"], requiredValidations: [] });
+}
+var NumberSchema = (_class = class extends _chunk6LUSV3SSjs.CommonSchema {constructor(...args) { super(...args); _class.prototype.__init.call(this); }
+  __init() {this._number = 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
+   * number().equalTo(42); // Infers the type 42
+   *
+   * @public
+   */
+  equalTo(expectedValue) {
+    if (this.limit) throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)(_chunkLHEU4XACjs.ONLY_ONCE);
+    const next = this.custom(_chunkOPA6AXSHjs.equalTo.call(void 0, expectedValue));
+    next.limit = true;
+    _chunkFTHEF6SBjs._setStrictType.call(void 0, next, 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
+   * number().oneOfValues([5, 7]); // Infers the type 5 | 7
+   *
+   * @public
+   */
+  oneOfValues(expectedValue) {
+    if (this.limit) throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)(_chunkLHEU4XACjs.ONLY_ONCE);
+    const next = this.custom(_chunk3D6TPN7Fjs.oneOfValues.call(void 0, expectedValue));
+    next.limit = true;
+    _chunkFTHEF6SBjs._setStrictType.call(void 0, next, expectedValue);
+    return next;
+  }
+}, _class);
+
+
+
+
+exports.number = number; exports.NumberSchema = NumberSchema;
+//# sourceMappingURL=chunk-4PPMVVQY.js.map

package/lib/chunk-4PPMVVQY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-4PPMVVQY.js","../src/asserts/number/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;AACA;ACDO,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;AAEO,IAAM,aAAA,YAAN,MAAA,QAA2B,8BAAa;AAAA,iBACnC,QAAA,EAAU,EAAA;AAAA,EACZ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYD,OAAA,CAA0B,aAAA,EAA2C;AAC1E,IAAA,GAAA,CAAI,IAAA,CAAK,KAAA,EAAO,MAAM,IAAI,sCAAA,CAAiB,0BAAS,CAAA;AAGpD,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,aAAa,CAAA;AAClC,IAAA,OAAO,IAAA;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYO,WAAA,CAA8B,aAAA,EAA6C;AAChF,IAAA,GAAA,CAAI,IAAA,CAAK,KAAA,EAAO,MAAM,IAAI,sCAAA,CAAiB,0BAAS,CAAA;AACpD,IAAA,MAAM,KAAA,EAAO,IAAA,CAAK,MAAA,CAAO,0CAAA,aAAyB,CAAC,CAAA;AACnD,IAAA,IAAA,CAAK,MAAA,EAAQ,IAAA;AACb,IAAA,6CAAA,IAAe,EAAM,aAAa,CAAA;AAClC,IAAA,OAAO,IAAA;AAAA,EACT;AACF,UAAA;ADFA;AACA;AACE;AACA;AACF,6DAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-4PPMVVQY.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 { equalTo } from '../mix/equalTo';\nimport { oneOfValues } from '../mix/oneOfValues';\n\n/**\n * @description Creates a new schema for validating number values.\n * @returns {NumberSchema} A new instance of `NumberSchema` for validating numbers.\n * @example\n * const schema = number();\n * parseOrFail(schema, 42); // Validates successfully\n * parseOrFail(schema, '42'); // Throws a validation error\n *\n * @instance Of NumberSchema\n */\nexport function number(): WithBGuardType<NumberSchema, number> {\n  return new NumberSchema({ type: ['number'], requiredValidations: [] }) as WithBGuardType<NumberSchema, number>;\n}\n\nexport class NumberSchema extends CommonSchema {\n  protected _number = 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   * number().equalTo(42); // Infers the type 42\n   *\n   * @public\n   */\n  public equalTo<Y extends number>(expectedValue: Y): WithBGuardType<this, Y> {\n    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);\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, 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   * number().oneOfValues([5, 7]); // Infers the type 5 | 7\n   *\n   * @public\n   */\n  public oneOfValues<Y extends number>(expectedValue: Y[]): WithBGuardType<this, Y> {\n    if (this.limit) throw new BuildSchemaError(ONLY_ONCE);\n    const next = this.custom(oneOfValues(expectedValue));\n    next.limit = true;\n    _setStrictType(next, expectedValue);\n    return next as WithBGuardType<this, Y>;\n  }\n}\n"]}

package/lib/{chunk-HWVM4SYU.mjs → chunk-54F462SS.mjs}

@@ -1,13 +1,16 @@
+import {
+  _constrain
+} from "./chunk-VERUOTB3.mjs";
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.mjs";
 
 // src/asserts/number/maxExcluded.ts
 var maxExcludedErrorMessage = "The received value is greater than or equal to expected";
 var maxExcludedErrorKey = "n:maxExcluded";
-var maxExcluded = (expected) => (received, ctx) => {
+var maxExcluded = (expected) => _constrain({ exclusiveMaximum: expected }, (received, ctx) => {
   if (expected <= received) ctx.addIssue(expected, received, maxExcludedErrorKey);
-};
+});
 maxExcluded.key = maxExcludedErrorKey;
 maxExcluded.message = maxExcludedErrorMessage;
 setToDefaultLocale(maxExcluded);
@@ -15,4 +18,4 @@ setToDefaultLocale(maxExcluded);
 export {
   maxExcluded
 };
-//# sourceMappingURL=chunk-HWVM4SYU.mjs.map
+//# sourceMappingURL=chunk-54F462SS.mjs.map

package/lib/chunk-54F462SS.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/number/maxExcluded.ts"],"sourcesContent":["import { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\n\nconst maxExcludedErrorMessage = 'The received value is greater than or equal to expected';\nconst maxExcludedErrorKey = 'n:maxExcluded';\n\n/**\n * @description - Asserts that a number value is strictly less than a specified maximum value (i.e., the maximum value is excluded).\n * @param {number} expected - The maximum allowable value, which is excluded.\n * @returns {RequiredValidation} -  A validation function that takes a received number and an exception context.\n * @throws {ValidationError} if the received value is greater than or equal to the expected maximum value.\n * @example\n * const schema = number().custom(maxExcluded(100));\n * parseOrFail(schema, 99);  // Valid\n * parseOrFail(schema, 100); // Throws an error: 'The received value is greater than or equal to expected'\n * parseOrFail(schema, 101); // Throws an error: 'The received value is greater than or equal to expected'\n *\n * @translation Error Translation Key = 'n:maxExcluded'\n */\nexport const maxExcluded = (expected: number): RequiredValidation<number> =>\n  _constrain({ exclusiveMaximum: expected }, (received: number, ctx: ExceptionContext) => {\n    if (expected <= received) ctx.addIssue(expected, received, maxExcludedErrorKey);\n  });\n\nmaxExcluded.key = maxExcludedErrorKey;\nmaxExcluded.message = maxExcludedErrorMessage;\nsetToDefaultLocale(maxExcluded);\n"],"mappings":";;;;;;;;AAIA,IAAM,0BAA0B;AAChC,IAAM,sBAAsB;AAerB,IAAM,cAAc,CAAC,aAC1B,WAAW,EAAE,kBAAkB,SAAS,GAAG,CAAC,UAAkB,QAA0B;AACtF,MAAI,YAAY,SAAU,KAAI,SAAS,UAAU,UAAU,mBAAmB;AAChF,CAAC;AAEH,YAAY,MAAM;AAClB,YAAY,UAAU;AACtB,mBAAmB,WAAW;","names":[]}

package/lib/{chunk-S4FWDTEW.mjs → chunk-55P4YTMX.mjs}

@@ -1,6 +1,6 @@
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.mjs";
 
 // src/asserts/string/startsWith.ts
 var startsWithErrorMessage = "The received value does not start with the required substring";
@@ -17,4 +17,4 @@ setToDefaultLocale(startsWith);
 export {
   startsWith
 };
-//# sourceMappingURL=chunk-S4FWDTEW.mjs.map
+//# sourceMappingURL=chunk-55P4YTMX.mjs.map

package/lib/{chunk-S4FWDTEW.mjs.map → chunk-55P4YTMX.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/asserts/string/startsWith.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst startsWithErrorMessage = 'The received value does not start with the required substring';\nconst startsWithErrorKey = 's:startsWith';\n\n/**\n * @description Asserts that a string value starts with a specified substring.\n * @param {string} substring The substring that the string value must start with.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value does not start with the required substring.\n * @example\n * const schema = string().custom(startsWith('foo'));\n * parseOrFail(schema, 'foobar'); // Valid\n * parseOrFail(schema, 'barfoo'); // Throws an error: 'The received value does not start with the required substring'\n *\n * @translation Error Translation Key = 's:startsWith'\n */\nexport const startsWith =\n  (substring: string): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (!received.startsWith(substring)) {\n      ctx.addIssue(`starts with '${substring}'`, received, startsWithErrorKey);\n    }\n  };\n\nstartsWith.key = startsWithErrorKey;\nstartsWith.message = startsWithErrorMessage;\nsetToDefaultLocale(startsWith);\n"],"mappings":";;;;;AAGA,IAAM,yBAAyB;AAC/B,IAAM,qBAAqB;AAcpB,IAAM,aACX,CAAC,cACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,CAAC,SAAS,WAAW,SAAS,GAAG;AACnC,QAAI,SAAS,gBAAgB,SAAS,KAAK,UAAU,kBAAkB;AAAA,EACzE;AACF;AAEF,WAAW,MAAM;AACjB,WAAW,UAAU;AACrB,mBAAmB,UAAU;","names":[]}
+{"version":3,"sources":["../src/asserts/string/startsWith.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst startsWithErrorMessage = 'The received value does not start with the required substring';\nconst startsWithErrorKey = 's:startsWith';\n\n/**\n * @description Asserts that a string value starts with a specified substring.\n * @param {string} substring The substring that the string value must start with.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value does not start with the required substring.\n * @example\n * const schema = string().custom(startsWith('foo'));\n * parseOrFail(schema, 'foobar'); // Valid\n * parseOrFail(schema, 'barfoo'); // Throws an error: 'The received value does not start with the required substring'\n *\n * @translation Error Translation Key = 's:startsWith'\n */\nexport const startsWith =\n  (substring: string): RequiredValidation<string> =>\n  (received: string, ctx: ExceptionContext) => {\n    if (!received.startsWith(substring)) {\n      ctx.addIssue(`starts with '${substring}'`, received, startsWithErrorKey);\n    }\n  };\n\nstartsWith.key = startsWithErrorKey;\nstartsWith.message = startsWithErrorMessage;\nsetToDefaultLocale(startsWith);\n"],"mappings":";;;;;AAGA,IAAM,yBAAyB;AAC/B,IAAM,qBAAqB;AAcpB,IAAM,aACX,CAAC,cACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,CAAC,SAAS,WAAW,SAAS,GAAG;AACnC,QAAI,SAAS,gBAAgB,SAAS,KAAK,UAAU,kBAAkB;AAAA,EACzE;AACF;AAEF,WAAW,MAAM;AACjB,WAAW,UAAU;AACrB,mBAAmB,UAAU;","names":[]}

package/lib/chunk-56TWNROC.js

@@ -0,0 +1,20 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk23R5R7PLjs = require('./chunk-23R5R7PL.js');
+
+// src/asserts/coerce/boolean.ts
+var coerceBoolean = () => _chunk23R5R7PLjs.boolean.call(void 0, ).transformBeforeValidation((received) => {
+  if (typeof received === "string") {
+    const lowered = received.toLowerCase();
+    if (lowered === "true") return true;
+    if (lowered === "false") return false;
+  }
+  if (received === 1) return true;
+  if (received === 0) return false;
+  return received;
+});
+
+
+
+exports.coerceBoolean = coerceBoolean;
+//# sourceMappingURL=chunk-56TWNROC.js.map

package/lib/chunk-56TWNROC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-56TWNROC.js","../src/asserts/coerce/boolean.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACuBO,IAAM,cAAA,EAAgB,CAAA,EAAA,GAC3B,sCAAA,CAAQ,CAAE,yBAAA,CAAmC,CAAC,QAAA,EAAA,GAAa;AACzD,EAAA,GAAA,CAAI,OAAO,SAAA,IAAa,QAAA,EAAU;AAChC,IAAA,MAAM,QAAA,EAAU,QAAA,CAAS,WAAA,CAAY,CAAA;AACrC,IAAA,GAAA,CAAI,QAAA,IAAY,MAAA,EAAQ,OAAO,IAAA;AAC/B,IAAA,GAAA,CAAI,QAAA,IAAY,OAAA,EAAS,OAAO,KAAA;AAAA,EAClC;AAEA,EAAA,GAAA,CAAI,SAAA,IAAa,CAAA,EAAG,OAAO,IAAA;AAC3B,EAAA,GAAA,CAAI,SAAA,IAAa,CAAA,EAAG,OAAO,KAAA;AAE3B,EAAA,OAAO,QAAA;AACT,CAAC,CAAA;ADxBH;AACA;AACE;AACF,sCAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-56TWNROC.js","sourcesContent":[null,"import { boolean } from '../boolean/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 boolean before validating it.\n *\n * Only the values that unambiguously mean a boolean are converted: the strings `'true'` and `'false'`\n * in any case, and the numbers `1` and `0`. Everything else is left for validation to reject.\n *\n * Deliberately narrower than passing the value through `Boolean`, which would accept every input and\n * quietly read `'false'` as `true`.\n *\n * @returns A boolean schema that accepts `unknown` as its input type.\n * @example\n * parseOrFail(coerceBoolean(), 'false'); // false\n */\nexport const coerceBoolean = () =>\n  boolean().transformBeforeValidation<unknown>((received) => {\n    if (typeof received === 'string') {\n      const lowered = received.toLowerCase();\n      if (lowered === 'true') return true;\n      if (lowered === 'false') return false;\n    }\n\n    if (received === 1) return true;\n    if (received === 0) return false;\n\n    return received as boolean;\n  });\n"]}

package/lib/chunk-5PIGAEGL.mjs

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

package/lib/chunk-5PIGAEGL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/tuple/index.ts"],"sourcesContent":["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"],"mappings":";;;;;;;;AAuBO,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-NFD7D5GZ.mjs → chunk-5PXMSVTE.mjs}

@@ -1,21 +1,21 @@
-import {
-  oneOfValues
-} from "./chunk-W3U7RYLP.mjs";
 import {
   equalTo
-} from "./chunk-4ZKU4RJL.mjs";
+} from "./chunk-YQP44G45.mjs";
+import {
+  oneOfValues
+} from "./chunk-D42AL6CN.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,26 @@ 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
+  bigint,
+  BigIntSchema
 };
-//# sourceMappingURL=chunk-NFD7D5GZ.mjs.map
+//# sourceMappingURL=chunk-5PXMSVTE.mjs.map

package/lib/chunk-5PXMSVTE.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\nexport class 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;AAEO,IAAM,eAAN,cAA2B,aAAa;AAAA,EACnC,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-ZGUF5ZDP.mjs → chunk-5U5CYDRB.mjs}

@@ -1,6 +1,6 @@
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.mjs";
 
 // src/asserts/string/uuidV5.ts
 var uuidV5ErrorMessage = "The received value is not a valid UUID v5";
@@ -18,4 +18,4 @@ setToDefaultLocale(uuidV5);
 export {
   uuidV5
 };
-//# sourceMappingURL=chunk-ZGUF5ZDP.mjs.map
+//# sourceMappingURL=chunk-5U5CYDRB.mjs.map

package/lib/{chunk-ZGUF5ZDP.mjs.map → chunk-5U5CYDRB.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/asserts/string/uuidV5.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst uuidV5ErrorMessage = 'The received value is not a valid UUID v5';\nconst uuidV5ErrorKey = 's:uuidV5';\n\nconst uuidV5Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-5[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 v5 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 v5.\n * @example\n * const schema = string().custom(uuidV5());\n * parseOrFail(schema, '550e8400-e29b-51d4-a716-446655440000'); // Valid\n * parseOrFail(schema, '550e8400-e29b-41d4-a716-446655440000'); // Throws an error: 'The received value is not a valid UUID v5'\n * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v5'\n *\n * @translation Error Translation Key = 's:uuidV5'\n */\nexport const uuidV5 = (): RequiredValidation => (received: string, ctx: ExceptionContext) => {\n  if (!uuidV5Pattern.test(received)) {\n    ctx.addIssue('uuid v5', received, uuidV5ErrorKey);\n  }\n};\n\nuuidV5.key = uuidV5ErrorKey;\nuuidV5.message = uuidV5ErrorMessage;\nsetToDefaultLocale(uuidV5);\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/uuidV5.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst uuidV5ErrorMessage = 'The received value is not a valid UUID v5';\nconst uuidV5ErrorKey = 's:uuidV5';\n\nconst uuidV5Pattern = /^[0-9a-f]{8}-[0-9a-f]{4}-5[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 v5 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 v5.\n * @example\n * const schema = string().custom(uuidV5());\n * parseOrFail(schema, '550e8400-e29b-51d4-a716-446655440000'); // Valid\n * parseOrFail(schema, '550e8400-e29b-41d4-a716-446655440000'); // Throws an error: 'The received value is not a valid UUID v5'\n * parseOrFail(schema, 'invalid-uuid'); // Throws an error: 'The received value is not a valid UUID v5'\n *\n * @translation Error Translation Key = 's:uuidV5'\n */\nexport const uuidV5 = (): RequiredValidation<string> => (received: string, ctx: ExceptionContext) => {\n  if (!uuidV5Pattern.test(received)) {\n    ctx.addIssue('uuid v5', received, uuidV5ErrorKey);\n  }\n};\n\nuuidV5.key = uuidV5ErrorKey;\nuuidV5.message = uuidV5ErrorMessage;\nsetToDefaultLocale(uuidV5);\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-V7C77FML.mjs → chunk-5WLWZKC6.mjs}

@@ -1,13 +1,16 @@
+import {
+  _constrain
+} from "./chunk-VERUOTB3.mjs";
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.mjs";
 
 // src/asserts/number/minExcluded.ts
 var minExcludedErrorMessage = "The received value is less than or equal to expected";
 var minExcludedErrorKey = "n:minExcluded";
-var minExcluded = (expected) => (received, ctx) => {
+var minExcluded = (expected) => _constrain({ exclusiveMinimum: expected }, (received, ctx) => {
   if (expected >= received) ctx.addIssue(expected, received, minExcludedErrorKey);
-};
+});
 minExcluded.key = minExcludedErrorKey;
 minExcluded.message = minExcludedErrorMessage;
 setToDefaultLocale(minExcluded);
@@ -15,4 +18,4 @@ setToDefaultLocale(minExcluded);
 export {
   minExcluded
 };
-//# sourceMappingURL=chunk-V7C77FML.mjs.map
+//# sourceMappingURL=chunk-5WLWZKC6.mjs.map

package/lib/chunk-5WLWZKC6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/number/minExcluded.ts"],"sourcesContent":["import { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\n\nconst minExcludedErrorMessage = 'The received value is less than or equal to expected';\nconst minExcludedErrorKey = 'n:minExcluded';\n\n/**\n * @description Asserts that a number value is strictly greater than a specified minimum value (i.e., the minimum value is excluded).\n * @param {number} expected The minimum allowable value, which is excluded.\n * @returns {RequiredValidation} A validation function that takes a received number and an exception context.\n * @throws {ValidationError} if the received value is less than or equal to the expected minimum value.\n * @example\n * const schema = number().custom(minExcluded(10));\n * parseOrFail(schema, 11);  // Valid\n * parseOrFail(schema, 10); // Throws an error: 'The received value is less than or equal to expected'\n * parseOrFail(schema, 9);  // Throws an error: 'The received value is less than or equal to expected'\n *\n * @translation Error Translation Key = 'n:minExcluded'\n */\nexport const minExcluded = (expected: number): RequiredValidation<number> =>\n  _constrain({ exclusiveMinimum: expected }, (received: number, ctx: ExceptionContext) => {\n    if (expected >= received) ctx.addIssue(expected, received, minExcludedErrorKey);\n  });\n\nminExcluded.key = minExcludedErrorKey;\nminExcluded.message = minExcludedErrorMessage;\nsetToDefaultLocale(minExcluded);\n"],"mappings":";;;;;;;;AAIA,IAAM,0BAA0B;AAChC,IAAM,sBAAsB;AAerB,IAAM,cAAc,CAAC,aAC1B,WAAW,EAAE,kBAAkB,SAAS,GAAG,CAAC,UAAkB,QAA0B;AACtF,MAAI,YAAY,SAAU,KAAI,SAAS,UAAU,UAAU,mBAAmB;AAChF,CAAC;AAEH,YAAY,MAAM;AAClB,YAAY,UAAU;AACtB,mBAAmB,WAAW;","names":[]}

package/lib/{chunk-GFWZQ4XW.mjs → chunk-5WV7FMW7.mjs}

@@ -1,6 +1,9 @@
+import {
+  _constrain
+} from "./chunk-VERUOTB3.mjs";
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.mjs";
 
 // src/asserts/string/isValidDateTime.ts
 var dateTimeErrorMessage = "The received value is not a valid ISO 8601 datetime string";
@@ -10,15 +13,15 @@ var defaultOptions = {
   precision: void 0
 };
 var isValidDateTime = (options = defaultOptions) => {
-  return (received, ctx) => {
+  return _constrain({ format: "date-time" }, (received, ctx) => {
     const { offset, precision } = options;
     const dateTimeRegex = new RegExp(
       `^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}` + (precision !== void 0 ? `(\\.\\d{${precision}})` : `(\\.\\d+)?`) + `(${offset ? `([+-]\\d{2}:\\d{2}|[+-]\\d{2}\\d{2}|[+-]\\d{2}|Z)` : "Z"})$`
     );
     if (!dateTimeRegex.test(received)) {
-      ctx.addIssue(received, dateTimeErrorMessage, dateTimeErrorKey);
+      ctx.addIssue("valid date time", received, dateTimeErrorKey);
     }
-  };
+  });
 };
 isValidDateTime.key = dateTimeErrorKey;
 isValidDateTime.message = dateTimeErrorMessage;
@@ -27,4 +30,4 @@ setToDefaultLocale(isValidDateTime);
 export {
   isValidDateTime
 };
-//# sourceMappingURL=chunk-GFWZQ4XW.mjs.map
+//# sourceMappingURL=chunk-5WV7FMW7.mjs.map

package/lib/chunk-5WV7FMW7.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/string/isValidDateTime.ts"],"sourcesContent":["import { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\n\n// Default error messages and keys\nconst dateTimeErrorMessage = 'The received value is not a valid ISO 8601 datetime string';\nconst dateTimeErrorKey = 's:isValidDateTime';\n\ntype DateTimeOptions = {\n  offset?: boolean;\n  precision?: number;\n};\n\nconst defaultOptions: DateTimeOptions = {\n  offset: false,\n  precision: undefined,\n};\n\n/**\n * @description Asserts that a string value is a valid ISO 8601 datetime string.\n * @param {DateTimeOptions} options Options to control the validation:\n * - `offset`: If `true`, allows timezone offsets in the datetime string.\n * - `precision`: Specify the exact number of fractional second digits allowed (e.g., 3 for milliseconds).\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 datetime string according to the options.\n * @example\n * const schema = string().custom(isValidDateTime());\n * parseOrFail(schema, \"2024-01-01T00:00:00Z\"); // Valid\n * parseOrFail(schema, \"2024-01-01T00:00:00.123Z\"); // Valid\n * parseOrFail(schema, \"2024-01-01T00:00:00+03:00\"); // Invalid (no offsets allowed)\n *\n * const schemaWithOffset = string().custom(isValidDateTime({ offset: true }));\n * parseOrFail(schemaWithOffset, \"2024-01-01T00:00:00+04:00\"); // Valid\n *\n * const schemaWithPrecision = string().custom(isValidDateTime({ precision: 3 }));\n * parseOrFail(schemaWithPrecision, \"2024-01-01T00:00:00.123Z\"); // Valid\n * parseOrFail(schemaWithPrecision, \"2024-01-01T00:00:00.123456Z\"); // Invalid\n *\n * @translation Error Translation Key = 's:isValidDateTime'\n */\nexport const isValidDateTime = (options: DateTimeOptions = defaultOptions): RequiredValidation<string> => {\n  return _constrain({ format: 'date-time' }, (received: string, ctx: ExceptionContext) => {\n    const { offset, precision } = options;\n\n    const dateTimeRegex = new RegExp(\n      `^\\\\d{4}-\\\\d{2}-\\\\d{2}T\\\\d{2}:\\\\d{2}:\\\\d{2}` +\n        (precision !== undefined ? `(\\\\.\\\\d{${precision}})` : `(\\\\.\\\\d+)?`) +\n        `(${offset ? `([+-]\\\\d{2}:\\\\d{2}|[+-]\\\\d{2}\\\\d{2}|[+-]\\\\d{2}|Z)` : 'Z'})$`,\n    );\n\n    if (!dateTimeRegex.test(received)) {\n      ctx.addIssue('valid date time', received, dateTimeErrorKey);\n    }\n  });\n};\n\nisValidDateTime.key = dateTimeErrorKey;\nisValidDateTime.message = dateTimeErrorMessage;\nsetToDefaultLocale(isValidDateTime);\n"],"mappings":";;;;;;;;AAKA,IAAM,uBAAuB;AAC7B,IAAM,mBAAmB;AAOzB,IAAM,iBAAkC;AAAA,EACtC,QAAQ;AAAA,EACR,WAAW;AACb;AAwBO,IAAM,kBAAkB,CAAC,UAA2B,mBAA+C;AACxG,SAAO,WAAW,EAAE,QAAQ,YAAY,GAAG,CAAC,UAAkB,QAA0B;AACtF,UAAM,EAAE,QAAQ,UAAU,IAAI;AAE9B,UAAM,gBAAgB,IAAI;AAAA,MACxB,gDACG,cAAc,SAAY,WAAW,SAAS,OAAO,gBACtD,IAAI,SAAS,sDAAsD,GAAG;AAAA,IAC1E;AAEA,QAAI,CAAC,cAAc,KAAK,QAAQ,GAAG;AACjC,UAAI,SAAS,mBAAmB,UAAU,gBAAgB;AAAA,IAC5D;AAAA,EACF,CAAC;AACH;AAEA,gBAAgB,MAAM;AACtB,gBAAgB,UAAU;AAC1B,mBAAmB,eAAe;","names":[]}