bguard 0.6.0 → 0.7.1

package/lib/chunk-RDJK3X4J.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/number/positive.ts"],"sourcesContent":["import { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\n\nconst positiveErrorMessage = 'The received value is not a positive number';\nconst positiveErrorKey = 'n:positive';\n\n/**\n * @description Asserts that a number value is positive (greater than zero).\n * @returns {RequiredValidation} A validation function that takes a received number and an exception context.\n * @throws {ValidationError} if the received value is not positive.\n * @example\n * const schema = number().custom(positive());\n * parseOrFail(schema, 10);  // Valid\n * parseOrFail(schema, 0);  // Throws an error: 'The received value is not a positive number'\n * parseOrFail(schema, -5); // Throws an error: 'The received value is not a positive number'\n *\n * @translation Error Translation Key = 'n:positive'\n */\nexport const positive = (): RequiredValidation<number> =>\n  _constrain({ exclusiveMinimum: 0 }, (received: number, ctx: ExceptionContext) => {\n    if (received <= 0) ctx.addIssue('positive', received, positiveErrorKey);\n  });\n\npositive.key = positiveErrorKey;\npositive.message = positiveErrorMessage;\nsetToDefaultLocale(positive);\n"],"mappings":";;;;;;;;AAIA,IAAM,uBAAuB;AAC7B,IAAM,mBAAmB;AAclB,IAAM,WAAW,MACtB,WAAW,EAAE,kBAAkB,EAAE,GAAG,CAAC,UAAkB,QAA0B;AAC/E,MAAI,YAAY,EAAG,KAAI,SAAS,YAAY,UAAU,gBAAgB;AACxE,CAAC;AAEH,SAAS,MAAM;AACf,SAAS,UAAU;AACnB,mBAAmB,QAAQ;","names":[]}

package/lib/{chunk-4N5J426R.mjs → chunk-RXU74KSN.mjs}

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

package/lib/{chunk-4N5J426R.mjs.map → chunk-RXU74KSN.mjs.map}

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

package/lib/{chunk-S5D5AFDF.js → chunk-S6N4N4FT.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/regExp.ts
 var regExpErrorMessage = "The received value does not match the required text pattern";
 var regExpErrorKey = "s:regExp";
-var regExp = (expected) => (received, ctx) => {
-  if (!expected.test(received)) ctx.addIssue(expected, received, regExpErrorMessage);
-};
+var regExp = (expected) => _chunkWOPNDC4Rjs._constrain.call(void 0, { pattern: expected.source }, (received, ctx) => {
+  if (!expected.test(received)) ctx.addIssue(expected, received, regExpErrorKey);
+});
 regExp.key = regExpErrorKey;
 regExp.message = regExpErrorMessage;
-_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, regExp);
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, regExp);
 
 
 
 exports.regExp = regExp;
-//# sourceMappingURL=chunk-S5D5AFDF.js.map
+//# sourceMappingURL=chunk-S6N4N4FT.js.map

package/lib/chunk-S6N4N4FT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-S6N4N4FT.js","../src/asserts/string/regExp.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACHA,IAAM,mBAAA,EAAqB,6DAAA;AAC3B,IAAM,eAAA,EAAiB,UAAA;AAchB,IAAM,OAAA,EAAS,CAAC,QAAA,EAAA,GACrB,yCAAA,EAAa,OAAA,EAAS,QAAA,CAAS,OAAO,CAAA,EAAG,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AACpF,EAAA,GAAA,CAAI,CAAC,QAAA,CAAS,IAAA,CAAK,QAAQ,CAAA,EAAG,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,cAAc,CAAA;AAC/E,CAAC,CAAA;AAEH,MAAA,CAAO,IAAA,EAAM,cAAA;AACb,MAAA,CAAO,QAAA,EAAU,kBAAA;AACjB,iDAAA,MAAyB,CAAA;ADVzB;AACA;AACE;AACF,wBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-S6N4N4FT.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst regExpErrorMessage = 'The received value does not match the required text pattern';\nconst regExpErrorKey = 's:regExp';\n\n/**\n * @description Asserts that a string value matches a specified regular expression pattern.\n * @param {RegExp} expected The regular expression pattern that the string value should match.\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 pattern.\n * @example\n * const schema = string().custom(regExp(/^[A-Za-z0-9]+$/)); // Validates against alphanumeric pattern\n * parseOrFail(schema, 'valid123');   // Valid\n * parseOrFail(schema, 'invalid!@#'); // Throws an error: 'The received value does not match the required text pattern'\n *\n * @translation Error Translation Key = 's:regExp'\n */\nexport const regExp = (expected: RegExp): RequiredValidation<string> =>\n  _constrain({ pattern: expected.source }, (received: string, ctx: ExceptionContext) => {\n    if (!expected.test(received)) ctx.addIssue(expected, received, regExpErrorKey);\n  });\n\nregExp.key = regExpErrorKey;\nregExp.message = regExpErrorMessage;\nsetToDefaultLocale(regExp);\n"]}

package/lib/chunk-SBNUNRI3.mjs

@@ -0,0 +1,13 @@
+import {
+  string
+} from "./chunk-J3EKIWPZ.mjs";
+
+// src/asserts/coerce/string.ts
+var coerceString = () => string().transformBeforeValidation(
+  (received) => received === null || typeof received === "string" ? received : String(received)
+);
+
+export {
+  coerceString
+};
+//# sourceMappingURL=chunk-SBNUNRI3.mjs.map

package/lib/chunk-SBNUNRI3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/coerce/string.ts"],"sourcesContent":["import { string } from '../string/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 string before validating it. Anything that is not\n * already a string is passed through `String`.\n *\n * @returns A string schema that accepts `unknown` as its input type.\n * @example\n * parseOrFail(coerceString(), 42); // '42'\n */\nexport const coerceString = () =>\n  string().transformBeforeValidation<unknown>((received) =>\n    received === null || typeof received === 'string' ? (received as string) : String(received),\n  );\n"],"mappings":";;;;;AAsBO,IAAM,eAAe,MAC1B,OAAO,EAAE;AAAA,EAAmC,CAAC,aAC3C,aAAa,QAAQ,OAAO,aAAa,WAAY,WAAsB,OAAO,QAAQ;AAC5F;","names":[]}

package/lib/{chunk-SFIX77W5.js → chunk-SGWF66HS.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/string/uuidV5.ts
 var uuidV5ErrorMessage = "The received value is not a valid UUID v5";
@@ -13,9 +13,9 @@ var uuidV5 = () => (received, ctx) => {
 };
 uuidV5.key = uuidV5ErrorKey;
 uuidV5.message = uuidV5ErrorMessage;
-_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, uuidV5);
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, uuidV5);
 
 
 
 exports.uuidV5 = uuidV5;
-//# sourceMappingURL=chunk-SFIX77W5.js.map
+//# sourceMappingURL=chunk-SGWF66HS.js.map

package/lib/{chunk-SFIX77W5.js.map → chunk-SGWF66HS.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-SFIX77W5.js","../src/asserts/string/uuidV5.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,IAAM,mBAAA,EAAqB,2CAAA;AAC3B,IAAM,eAAA,EAAiB,UAAA;AAEvB,IAAM,cAAA,EAAgB,wEAAA;AAcf,IAAM,OAAA,EAAS,CAAA,EAAA,GAA0B,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AAC3F,EAAA,GAAA,CAAI,CAAC,aAAA,CAAc,IAAA,CAAK,QAAQ,CAAA,EAAG;AACjC,IAAA,GAAA,CAAI,QAAA,CAAS,SAAA,EAAW,QAAA,EAAU,cAAc,CAAA;AAAA,EAClD;AACF,CAAA;AAEA,MAAA,CAAO,IAAA,EAAM,cAAA;AACb,MAAA,CAAO,QAAA,EAAU,kBAAA;AACjB,iDAAA,MAAyB,CAAA;ADZzB;AACA;AACE;AACF,wBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-SFIX77W5.js","sourcesContent":[null,"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"]}
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-SGWF66HS.js","../src/asserts/string/uuidV5.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACDA,IAAM,mBAAA,EAAqB,2CAAA;AAC3B,IAAM,eAAA,EAAiB,UAAA;AAEvB,IAAM,cAAA,EAAgB,wEAAA;AAcf,IAAM,OAAA,EAAS,CAAA,EAAA,GAAkC,CAAC,QAAA,EAAkB,GAAA,EAAA,GAA0B;AACnG,EAAA,GAAA,CAAI,CAAC,aAAA,CAAc,IAAA,CAAK,QAAQ,CAAA,EAAG;AACjC,IAAA,GAAA,CAAI,QAAA,CAAS,SAAA,EAAW,QAAA,EAAU,cAAc,CAAA;AAAA,EAClD;AACF,CAAA;AAEA,MAAA,CAAO,IAAA,EAAM,cAAA;AACb,MAAA,CAAO,QAAA,EAAU,kBAAA;AACjB,iDAAA,MAAyB,CAAA;ADZzB;AACA;AACE;AACF,wBAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-SGWF66HS.js","sourcesContent":[null,"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"]}

package/lib/{chunk-OU5BTUDV.mjs → chunk-SKMDZ4S6.mjs}

@@ -1,6 +1,6 @@
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.mjs";
 
 // src/asserts/string/atLeastOneSpecialChar.ts
 var atLeastOneSpecialCharErrorMessage = "The received value does not contain at least one special character";
@@ -20,4 +20,4 @@ setToDefaultLocale(atLeastOneSpecialChar);
 export {
   atLeastOneSpecialChar
 };
-//# sourceMappingURL=chunk-OU5BTUDV.mjs.map
+//# sourceMappingURL=chunk-SKMDZ4S6.mjs.map

package/lib/{chunk-OU5BTUDV.mjs.map → chunk-SKMDZ4S6.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/asserts/string/atLeastOneSpecialChar.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst atLeastOneSpecialCharErrorMessage = 'The received value does not contain at least one special character';\nconst atLeastOneSpecialCharErrorKey = 's:atLeastOneSpecialChar';\n\n/**\n * @description Asserts that a string value contains at least one special character.\n * @param {string} [allowedSpecialChars=*] The string containing allowed special characters. Defaults to '*@$!#%&()^~{}'.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value does not contain at least one of the allowed special characters.\n * @example\n * const schema = string().custom(atLeastOneSpecialChar()); // Default special characters\n * parseOrFail(schema, 'abc!def'); // Valid\n * parseOrFail(schema, 'abcdef');  // Throws an error: 'The received value does not contain at least one special character'\n *\n * const customSchema = string().custom(atLeastOneSpecialChar('@$')); // Custom special characters\n * parseOrFail(customSchema, 'abc@def'); // Valid\n * parseOrFail(customSchema, 'abcdef');  // Throws an error: 'The received value does not contain at least one special character'\n *\n * @translation Error Translation Key = 's:atLeastOneSpecialChar'\n */\nexport const atLeastOneSpecialChar = (allowedSpecialChars?: string): RequiredValidation => {\n  const specialCharRegExp = new RegExp(\n    `[${(allowedSpecialChars ?? '*@$!#%&()^~{}').replace(/[-/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&')}]`,\n  );\n  return (received: string, ctx: ExceptionContext) => {\n    if (!specialCharRegExp.test(received)) ctx.addIssue('special character', received, atLeastOneSpecialCharErrorKey);\n  };\n};\n\natLeastOneSpecialChar.key = atLeastOneSpecialCharErrorKey;\natLeastOneSpecialChar.message = atLeastOneSpecialCharErrorMessage;\nsetToDefaultLocale(atLeastOneSpecialChar);\n"],"mappings":";;;;;AAGA,IAAM,oCAAoC;AAC1C,IAAM,gCAAgC;AAkB/B,IAAM,wBAAwB,CAAC,wBAAqD;AACzF,QAAM,oBAAoB,IAAI;AAAA,IAC5B,KAAK,uBAAuB,iBAAiB,QAAQ,yBAAyB,MAAM,CAAC;AAAA,EACvF;AACA,SAAO,CAAC,UAAkB,QAA0B;AAClD,QAAI,CAAC,kBAAkB,KAAK,QAAQ,EAAG,KAAI,SAAS,qBAAqB,UAAU,6BAA6B;AAAA,EAClH;AACF;AAEA,sBAAsB,MAAM;AAC5B,sBAAsB,UAAU;AAChC,mBAAmB,qBAAqB;","names":[]}
+{"version":3,"sources":["../src/asserts/string/atLeastOneSpecialChar.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst atLeastOneSpecialCharErrorMessage = 'The received value does not contain at least one special character';\nconst atLeastOneSpecialCharErrorKey = 's:atLeastOneSpecialChar';\n\n/**\n * @description Asserts that a string value contains at least one special character.\n * @param {string} [allowedSpecialChars=*] The string containing allowed special characters. Defaults to '*@$!#%&()^~{}'.\n * @returns {RequiredValidation} A validation function that takes a received string and an exception context.\n * @throws {ValidationError} if the received value does not contain at least one of the allowed special characters.\n * @example\n * const schema = string().custom(atLeastOneSpecialChar()); // Default special characters\n * parseOrFail(schema, 'abc!def'); // Valid\n * parseOrFail(schema, 'abcdef');  // Throws an error: 'The received value does not contain at least one special character'\n *\n * const customSchema = string().custom(atLeastOneSpecialChar('@$')); // Custom special characters\n * parseOrFail(customSchema, 'abc@def'); // Valid\n * parseOrFail(customSchema, 'abcdef');  // Throws an error: 'The received value does not contain at least one special character'\n *\n * @translation Error Translation Key = 's:atLeastOneSpecialChar'\n */\nexport const atLeastOneSpecialChar = (allowedSpecialChars?: string): RequiredValidation<string> => {\n  const specialCharRegExp = new RegExp(\n    `[${(allowedSpecialChars ?? '*@$!#%&()^~{}').replace(/[-/\\\\^$*+?.()|[\\]{}]/g, '\\\\$&')}]`,\n  );\n  return (received: string, ctx: ExceptionContext) => {\n    if (!specialCharRegExp.test(received)) ctx.addIssue('special character', received, atLeastOneSpecialCharErrorKey);\n  };\n};\n\natLeastOneSpecialChar.key = atLeastOneSpecialCharErrorKey;\natLeastOneSpecialChar.message = atLeastOneSpecialCharErrorMessage;\nsetToDefaultLocale(atLeastOneSpecialChar);\n"],"mappings":";;;;;AAGA,IAAM,oCAAoC;AAC1C,IAAM,gCAAgC;AAkB/B,IAAM,wBAAwB,CAAC,wBAA6D;AACjG,QAAM,oBAAoB,IAAI;AAAA,IAC5B,KAAK,uBAAuB,iBAAiB,QAAQ,yBAAyB,MAAM,CAAC;AAAA,EACvF;AACA,SAAO,CAAC,UAAkB,QAA0B;AAClD,QAAI,CAAC,kBAAkB,KAAK,QAAQ,EAAG,KAAI,SAAS,qBAAqB,UAAU,6BAA6B;AAAA,EAClH;AACF;AAEA,sBAAsB,MAAM;AAC5B,sBAAsB,UAAU;AAChC,mBAAmB,qBAAqB;","names":[]}

package/lib/chunk-SVRCKC65.js

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

package/lib/chunk-SVRCKC65.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-SVRCKC65.js","../src/toJSONSchema.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACSA,IAAM,UAAA,EAA+C;AAAA,EACnD,MAAA,EAAQ,QAAA;AAAA,EACR,MAAA,EAAQ,QAAA;AAAA,EACR,OAAA,EAAS,SAAA;AAAA,EACT,MAAA,EAAQ;AACV,CAAA;AAcA,SAAS,aAAA,CAAc,UAAA,EAA0C;AAC/D,EAAA,MAAM,YAAA,EAA0B,CAAC,CAAA;AAEjC,EAAA,IAAA,CAAA,MAAW,WAAA,GAAc,UAAA,CAAW,mBAAA,EAAqB;AACvD,IAAA,MAAM,QAAA,EAAW,UAAA,CAAqC,UAAA;AACtD,IAAA,GAAA,CAAI,OAAA,EAAS,MAAA,CAAO,MAAA,CAAO,WAAA,EAAa,OAAO,CAAA;AAAA,EACjD;AAEA,EAAA,OAAO,WAAA;AACT;AAEA,SAAS,SAAA,CAAU,UAAA,EAAsD;AACvE,EAAA,GAAA,CAAI,CAAC,UAAA,CAAW,UAAA,EAAY,OAAO,KAAA,CAAA;AAInC,EAAA,MAAM,QAAA,EAAU,CAAC,KAAA,EAAA,GACf,OAAO,MAAA,IAAU,SAAA,GAAY,KAAA,CAAM,UAAA,CAAW,GAAG,EAAA,GAAK,KAAA,CAAM,QAAA,CAAS,GAAG,EAAA,EACpE,KAAA,CAAM,KAAA,CAAM,CAAA,EAAG,CAAA,CAAE,CAAA,CAAE,OAAA,CAAQ,MAAA,EAAQ,GAAG,CAAA,CAAE,OAAA,CAAQ,OAAA,EAAS,IAAI,EAAA,EAC7D,KAAA;AAEN,EAAA,GAAA,CAAI,KAAA,CAAM,OAAA,CAAQ,UAAA,CAAW,eAAe,CAAA,EAAG,OAAO,EAAE,IAAA,EAAM,UAAA,CAAW,eAAA,CAAgB,GAAA,CAAI,OAAO,EAAE,CAAA;AAEtG,EAAA,OAAO,EAAE,KAAA,EAAO,OAAA,CAAQ,UAAA,CAAW,eAAe,EAAE,CAAA;AACtD;AAEA,SAAS,MAAA,CAAO,UAAA,EAA8B,OAAA,EAA8B;AAC1E,EAAA,GAAA,CAAI,UAAA,CAAW,IAAA,EAAM;AACnB,IAAA,MAAM,EAAE,QAAA,EAAU,UAAU,EAAA,EAAI,UAAA,CAAW,IAAA;AAG3C,IAAA,GAAA,CAAI,OAAA,CAAQ,UAAA,CAAW,GAAA,CAAI,QAAQ,CAAA,EAAG,OAAO,EAAE,IAAA,EAAM,CAAA,QAAA,EAAW,QAAQ,CAAA,EAAA;AAEjC,IAAA;AACG,IAAA;AAC6B,MAAA;AAExC,IAAA;AACoC,IAAA;AACjC,IAAA;AAEG,IAAA;AACvC,EAAA;AAEuE,EAAA;AAExD,EAAA;AACN,IAAA;AACC,MAAA;AAAA;AAAA;AAG6D,MAAA;AAC5D,MAAA;AACoB,MAAA;AACA,MAAA;AAC7B,IAAA;AAEqB,EAAA;AACwC,IAAA;AACA,IAAA;AAK7C,IAAA;AACP,MAAA;AACC,QAAA;AAC6E,QAAA;AAC7D,QAAA;AACxB,MAAA;AAEyD,IAAA;AAC7D,EAAA;AAEyE,EAAA;AAElD,EAAA;AAC2B,IAAA;AACpB,IAAA;AAEwC,IAAA;AACrB,MAAA;AACE,MAAA;AAGqB,MAAA;AACtE,IAAA;AAE8D,IAAA;AACjB,IAAA;AACc,IAAA;AAEpD,IAAA;AACT,EAAA;AAEkE,EAAA;AAEC,EAAA;AACxC,EAAA;AAEW,EAAA;AACL,IAAA;AACwB,IAAA;AAEhD,IAAA;AACR,EAAA;AAEgE,EAAA;AACnE;AAEsE;AACjC,EAAA;AACI,EAAA;AACH,EAAA;AAGuC,EAAA;AACjC,EAAA;AAEf,EAAA;AAEgD,IAAA;AAC3E,EAAA;AAEuE,EAAA;AACA,EAAA;AAEhE,EAAA;AACT;AAGmD;AACsB,EAAA;AACkB,EAAA;AAE9C,EAAA;AAC7C;AA0B8F;AAC1B,EAAA;AACxB,EAAA;AAEO,EAAA;AAC2B,EAAA;AAEN,EAAA;AAE/D,EAAA;AACT;AD/F6E;AACA;AACA;AACA","file":"/home/runner/work/bguard/bguard/lib/chunk-SVRCKC65.js","sourcesContent":[null,"import type { BaseType } from './commonTypes';\nimport { CommonSchema, type ValidatorContext } from './core';\nimport { BuildSchemaError } from './exceptions';\nimport { ctxSymbol } from './helpers/constants';\n\nexport interface JSONSchema {\n  [keyword: string]: unknown;\n}\n\nexport interface ToJSONSchemaOptions {\n  /**\n   * The dialect to declare in `$schema`. Pass `null` to leave it out, which is what you want when the\n   * result is embedded in a larger document such as an OpenAPI `components.schemas` entry.\n   * @default 'https://json-schema.org/draft/2020-12/schema'\n   */\n  dialect?: string | null;\n}\n\n/** What a bguard primitive is called in JSON Schema. */\nconst typeNames: Partial<Record<BaseType, string>> = {\n  string: 'string',\n  number: 'number',\n  boolean: 'boolean',\n  object: 'object',\n};\n\n/** A validation may carry the JSON Schema keywords it stands for. Those that cannot, do not. */\ninterface ConstrainedValidation {\n  jsonSchema?: JSONSchema;\n}\n\ninterface Context {\n  /** Named subschemas, filled as lazy schemas are met so a recursive schema can reference itself. */\n  definitions: Record<string, JSONSchema>;\n  /** Lazy type names currently being generated, so a self-reference emits a `$ref` instead of looping. */\n  inProgress: Set<string>;\n}\n\nfunction constraintsOf(schemaData: ValidatorContext): JSONSchema {\n  const constraints: JSONSchema = {};\n\n  for (const validation of schemaData.requiredValidations) {\n    const carried = (validation as ConstrainedValidation).jsonSchema;\n    if (carried) Object.assign(constraints, carried);\n  }\n\n  return constraints;\n}\n\nfunction literalOf(schemaData: ValidatorContext): JSONSchema | undefined {\n  if (!schemaData.strictType) return undefined;\n\n  // equalTo stores one value, oneOfValues an array. String literals arrive already quoted for codeGen,\n  // so the quotes have to come back off for JSON.\n  const unquote = (value: unknown) =>\n    typeof value === 'string' && value.startsWith(\"'\") && value.endsWith(\"'\")\n      ? value.slice(1, -1).replace(/\\\\'/g, \"'\").replace(/\\\\\\\\/g, '\\\\')\n      : value;\n\n  if (Array.isArray(schemaData.strictTypeValue)) return { enum: schemaData.strictTypeValue.map(unquote) };\n\n  return { const: unquote(schemaData.strictTypeValue) };\n}\n\nfunction baseOf(schemaData: ValidatorContext, context: Context): JSONSchema {\n  if (schemaData.lazy) {\n    const { typeName, getSchema } = schemaData.lazy;\n\n    // A self-reference resolves to a pointer, which is what stops generation from recursing forever.\n    if (context.inProgress.has(typeName)) return { $ref: `#/$defs/${typeName}` };\n\n    schemaData.lazy.resolved ??= getSchema();\n    if (!(schemaData.lazy.resolved instanceof CommonSchema))\n      throw new BuildSchemaError('Invalid schema returned from lazy method');\n\n    context.inProgress.add(typeName);\n    context.definitions[typeName] = generate(schemaData.lazy.resolved, context);\n    context.inProgress.delete(typeName);\n\n    return { $ref: `#/$defs/${typeName}` };\n  }\n\n  if (schemaData.union) return { anyOf: schemaData.union.map((member) => generate(member, context)) };\n\n  if (schemaData.tuple)\n    return {\n      type: 'array',\n      // Draft 2020-12 spells positional schemas `prefixItems`, and forbidding extras is what makes it a\n      // tuple rather than an array that happens to start a certain way.\n      prefixItems: schemaData.tuple.map((position) => generate(position, context)),\n      items: false,\n      minItems: schemaData.tuple.length,\n      maxItems: schemaData.tuple.length,\n    };\n\n  if (schemaData.record) {\n    const keyLiteral = literalOf(schemaData.record.key[ctxSymbol]);\n    const valueSchema = generate(schemaData.record.value, context);\n\n    // A restricted key set becomes named properties. There is no `required`, because validation checks\n    // the keys that are present rather than demanding the whole set — the same reason InferType says\n    // Partial.\n    if (keyLiteral?.enum)\n      return {\n        type: 'object',\n        properties: Object.fromEntries((keyLiteral.enum as unknown[]).map((key) => [String(key), valueSchema])),\n        additionalProperties: false,\n      };\n\n    return { type: 'object', additionalProperties: valueSchema };\n  }\n\n  if (schemaData.array) return { type: 'array', items: generate(schemaData.array, context) };\n\n  if (schemaData.object) {\n    const properties: Record<string, JSONSchema> = {};\n    const required: string[] = [];\n\n    for (const [key, valueSchema] of Object.entries(schemaData.object)) {\n      const valueSchemaData = valueSchema[ctxSymbol];\n      properties[key] = generate(valueSchema, context);\n\n      // A default supplies the value, so the caller need not send it — the same rule InferInput follows.\n      if (!valueSchemaData.isOptional && valueSchemaData.defaultValue === undefined) required.push(key);\n    }\n\n    const objectSchema: JSONSchema = { type: 'object', properties };\n    if (required.length) objectSchema.required = required;\n    if (!schemaData.allowUnrecognizedObjectProps) objectSchema.additionalProperties = false;\n\n    return objectSchema;\n  }\n\n  if (schemaData.date) return { type: 'string', format: 'date-time' };\n\n  const named = schemaData.type.filter((type) => type !== 'undefined');\n  if (!named.length) return {};\n\n  const jsonTypes = named.map((type) => {\n    const jsonType = typeNames[type];\n    if (!jsonType) throw new BuildSchemaError(`Type '${type}' has no JSON Schema equivalent and cannot be generated`);\n\n    return jsonType;\n  });\n\n  return { type: jsonTypes.length === 1 ? jsonTypes[0] : jsonTypes };\n}\n\nfunction generate(schema: CommonSchema, context: Context): JSONSchema {\n  const schemaData = schema[ctxSymbol];\n  const base = baseOf(schemaData, context);\n  const literal = literalOf(schemaData);\n\n  // A literal already says everything about the value, so the type is redundant beside it.\n  let result: JSONSchema = literal ? { ...base, ...literal } : { ...base, ...constraintsOf(schemaData) };\n  if (literal && result.type) delete result.type;\n\n  if (schemaData.isNullable) {\n    // `$ref` and `anyOf` cannot take a sibling type, so nullability has to wrap rather than merge.\n    result = result.$ref || result.anyOf ? { anyOf: [result, { type: 'null' }] } : mergeNull(result);\n  }\n\n  if (schemaData.defaultValue !== undefined) result.default = schemaData.defaultValue;\n  if (schemaData.meta?.description) result.description = schemaData.meta.description;\n\n  return result;\n}\n\n/** Adds null to a plain type, which reads better than wrapping a single type in `anyOf`. */\nfunction mergeNull(schema: JSONSchema): JSONSchema {\n  if (typeof schema.type === 'string') return { ...schema, type: [schema.type, 'null'] };\n  if (Array.isArray(schema.type)) return { ...schema, type: [...(schema.type as string[]), 'null'] };\n\n  return { anyOf: [schema, { type: 'null' }] };\n}\n\n/**\n * Renders a schema as a JSON Schema document, for OpenAPI, form generators and tool definitions.\n *\n * What is represented: types, object properties and which of them are required, arrays, tuples,\n * records, unions, literals and enums, nullability, defaults, `description()`, and recursive schemas\n * via `$defs` and `$ref`. Assertions that map onto a JSON Schema keyword — string lengths and patterns,\n * numeric bounds, array lengths — are included; those with no equivalent are not, because JSON Schema\n * has no way to express them.\n *\n * `bigint` and `symbol` have no JSON Schema counterpart and raise a `BuildSchemaError` rather than\n * being quietly emitted as something they are not. A `date()` becomes `{ type: 'string', format:\n * 'date-time' }`, since JSON has no date type.\n *\n * @example\n * const schema = object({ name: string().custom(minLength(2)), age: number().optional() });\n * toJSONSchema(schema);\n * // {\n * //   $schema: 'https://json-schema.org/draft/2020-12/schema',\n * //   type: 'object',\n * //   properties: { name: { type: 'string', minLength: 2 }, age: { type: 'number' } },\n * //   required: ['name'],\n * //   additionalProperties: false,\n * // }\n */\nexport function toJSONSchema(schema: CommonSchema, options?: ToJSONSchemaOptions): JSONSchema {\n  const context: Context = { definitions: {}, inProgress: new Set() };\n  const generated = generate(schema, context);\n\n  const dialect = options?.dialect === undefined ? 'https://json-schema.org/draft/2020-12/schema' : options.dialect;\n  const document: JSONSchema = dialect ? { $schema: dialect, ...generated } : generated;\n\n  if (Object.keys(context.definitions).length) document.$defs = context.definitions;\n\n  return document;\n}\n"]}

package/lib/{chunk-OQYS7JVF.js → chunk-SY2V2V54.js}

@@ -1,28 +1,28 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkVBTWYDEMjs = require('./chunk-VBTWYDEM.js');
+var _chunkZJGY6EOEjs = require('./chunk-ZJGY6EOE.js');
 
 
-var _chunkTJQ5NVL4js = require('./chunk-TJQ5NVL4.js');
+var _chunkVBTWYDEMjs = require('./chunk-VBTWYDEM.js');
 
 
-var _chunkFIDPCCCWjs = require('./chunk-FIDPCCCW.js');
+var _chunkZWFSAKQKjs = require('./chunk-ZWFSAKQK.js');
 
 // src/asserts/date/dateMax.ts
 var dateMaxErrorMessage = "The received value is greater than expected";
 var dateMaxErrorKey = "dt:max";
 var dateMax = (expected) => {
   const transformedExpected = typeof expected === "string" ? new Date(expected) : expected;
-  if (!_chunkVBTWYDEMjs.isValidDateInner.call(void 0, transformedExpected)) throw new (0, _chunkFIDPCCCWjs.BuildSchemaError)("Invalid date in Date assertion");
+  if (!_chunkVBTWYDEMjs.isValidDateInner.call(void 0, transformedExpected)) throw new (0, _chunkZWFSAKQKjs.BuildSchemaError)("Invalid date in Date assertion");
   return (received, ctx) => {
     if (transformedExpected < received) ctx.addIssue(transformedExpected, received, dateMaxErrorKey);
   };
 };
 dateMax.key = dateMaxErrorKey;
 dateMax.message = dateMaxErrorMessage;
-_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, dateMax);
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, dateMax);
 
 
 
 exports.dateMax = dateMax;
-//# sourceMappingURL=chunk-OQYS7JVF.js.map
+//# sourceMappingURL=chunk-SY2V2V54.js.map

package/lib/{chunk-OQYS7JVF.js.map → chunk-SY2V2V54.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-OQYS7JVF.js","../src/asserts/date/dateMax.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACLA,IAAM,oBAAA,EAAsB,6CAAA;AAC5B,IAAM,gBAAA,EAAkB,QAAA;AAcjB,IAAM,QAAA,EAAU,CAAC,QAAA,EAAA,GAAgD;AACtE,EAAA,MAAM,oBAAA,EAAsB,OAAO,SAAA,IAAa,SAAA,EAAW,IAAI,IAAA,CAAK,QAAQ,EAAA,EAAI,QAAA;AAChF,EAAA,GAAA,CAAI,CAAC,+CAAA,mBAAoC,CAAA,EAAG,MAAM,IAAI,sCAAA,CAAiB,gCAAgC,CAAA;AACvG,EAAA,OAAO,CAAC,QAAA,EAAgB,GAAA,EAAA,GAA0B;AAChD,IAAA,GAAA,CAAI,oBAAA,EAAsB,QAAA,EAAU,GAAA,CAAI,QAAA,CAAS,mBAAA,EAAqB,QAAA,EAAU,eAAe,CAAA;AAAA,EACjG,CAAA;AACF,CAAA;AAEA,OAAA,CAAQ,IAAA,EAAM,eAAA;AACd,OAAA,CAAQ,QAAA,EAAU,mBAAA;AAClB,iDAAA,OAA0B,CAAA;ADP1B;AACA;AACE;AACF,0BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-OQYS7JVF.js","sourcesContent":[null,"import { setToDefaultLocale } from '../../translationMap';\nimport { BuildSchemaError } from '../../exceptions';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\nimport { isValidDateInner } from '../../helpers/isValidDateInner';\n\nconst dateMaxErrorMessage = 'The received value is greater than expected';\nconst dateMaxErrorKey = 'dt:max';\n/**\n * @description Asserts that a date value is not greater than a specified maximum value.\n * @param {Date | string} expected The maximum allowable value.\n * @returns {RequiredValidation} A validation function that takes a received Date or string and an exception context.\n * @throws {ValidationError} if the received value is greater than the expected maximum value.\n * @example\n * const schema = date().custom(dateMax('2024-12-31'));\n * parseOrFail(schema, new Date('2024-12-30'));  // Valid\n * parseOrFail(schema, new Date('2024-12-31'));  // Valid\n * parseOrFail(schema, new Date('2025-01-01'));  // Throws an error: 'The received value is greater than expected'\n *\n * @translation Error Translation Key = 'dt:max'\n */\nexport const dateMax = (expected: Date | string): RequiredValidation => {\n  const transformedExpected = typeof expected === 'string' ? new Date(expected) : expected;\n  if (!isValidDateInner(transformedExpected)) throw new BuildSchemaError('Invalid date in Date assertion');\n  return (received: Date, ctx: ExceptionContext) => {\n    if (transformedExpected < received) ctx.addIssue(transformedExpected, received, dateMaxErrorKey);\n  };\n};\n\ndateMax.key = dateMaxErrorKey;\ndateMax.message = dateMaxErrorMessage;\nsetToDefaultLocale(dateMax);\n"]}
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-SY2V2V54.js","../src/asserts/date/dateMax.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACLA,IAAM,oBAAA,EAAsB,6CAAA;AAC5B,IAAM,gBAAA,EAAkB,QAAA;AAcjB,IAAM,QAAA,EAAU,CAAC,QAAA,EAAA,GAAsD;AAC5E,EAAA,MAAM,oBAAA,EAAsB,OAAO,SAAA,IAAa,SAAA,EAAW,IAAI,IAAA,CAAK,QAAQ,EAAA,EAAI,QAAA;AAChF,EAAA,GAAA,CAAI,CAAC,+CAAA,mBAAoC,CAAA,EAAG,MAAM,IAAI,sCAAA,CAAiB,gCAAgC,CAAA;AACvG,EAAA,OAAO,CAAC,QAAA,EAAgB,GAAA,EAAA,GAA0B;AAChD,IAAA,GAAA,CAAI,oBAAA,EAAsB,QAAA,EAAU,GAAA,CAAI,QAAA,CAAS,mBAAA,EAAqB,QAAA,EAAU,eAAe,CAAA;AAAA,EACjG,CAAA;AACF,CAAA;AAEA,OAAA,CAAQ,IAAA,EAAM,eAAA;AACd,OAAA,CAAQ,QAAA,EAAU,mBAAA;AAClB,iDAAA,OAA0B,CAAA;ADP1B;AACA;AACE;AACF,0BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-SY2V2V54.js","sourcesContent":[null,"import { setToDefaultLocale } from '../../translationMap';\nimport { BuildSchemaError } from '../../exceptions';\nimport type { ExceptionContext, RequiredValidation } from '../../core';\nimport { isValidDateInner } from '../../helpers/isValidDateInner';\n\nconst dateMaxErrorMessage = 'The received value is greater than expected';\nconst dateMaxErrorKey = 'dt:max';\n/**\n * @description Asserts that a date value is not greater than a specified maximum value.\n * @param {Date | string} expected The maximum allowable value.\n * @returns {RequiredValidation} A validation function that takes a received Date or string and an exception context.\n * @throws {ValidationError} if the received value is greater than the expected maximum value.\n * @example\n * const schema = date().custom(dateMax('2024-12-31'));\n * parseOrFail(schema, new Date('2024-12-30'));  // Valid\n * parseOrFail(schema, new Date('2024-12-31'));  // Valid\n * parseOrFail(schema, new Date('2025-01-01'));  // Throws an error: 'The received value is greater than expected'\n *\n * @translation Error Translation Key = 'dt:max'\n */\nexport const dateMax = (expected: Date | string): RequiredValidation<Date> => {\n  const transformedExpected = typeof expected === 'string' ? new Date(expected) : expected;\n  if (!isValidDateInner(transformedExpected)) throw new BuildSchemaError('Invalid date in Date assertion');\n  return (received: Date, ctx: ExceptionContext) => {\n    if (transformedExpected < received) ctx.addIssue(transformedExpected, received, dateMaxErrorKey);\n  };\n};\n\ndateMax.key = dateMaxErrorKey;\ndateMax.message = dateMaxErrorMessage;\nsetToDefaultLocale(dateMax);\n"]}

package/lib/{chunk-YMPRYKNY.js → chunk-SZO4SUUG.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/array/maxArrayLength.ts
 var maxArrayLengthErrorMessage = "The received value length is greater than expected";
 var maxArrayLengthErrorKey = "a:maxArrayLength";
-var maxArrayLength = (expected) => (received, ctx) => {
-  if (received.length > expected) ctx.addIssue(expected, received, maxArrayLengthErrorMessage);
-};
+var maxArrayLength = (expected) => _chunkWOPNDC4Rjs._constrain.call(void 0, { maxItems: expected }, (received, ctx) => {
+  if (received.length > expected) ctx.addIssue(expected, received, maxArrayLengthErrorKey);
+});
 maxArrayLength.key = maxArrayLengthErrorKey;
 maxArrayLength.message = maxArrayLengthErrorMessage;
-_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, maxArrayLength);
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, maxArrayLength);
 
 
 
 exports.maxArrayLength = maxArrayLength;
-//# sourceMappingURL=chunk-YMPRYKNY.js.map
+//# sourceMappingURL=chunk-SZO4SUUG.js.map

package/lib/chunk-SZO4SUUG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-SZO4SUUG.js","../src/asserts/array/maxArrayLength.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACHA,IAAM,2BAAA,EAA6B,oDAAA;AACnC,IAAM,uBAAA,EAAyB,kBAAA;AAexB,IAAM,eAAA,EAAiB,CAAC,QAAA,EAAA,GAC7B,yCAAA,EAAa,QAAA,EAAU,SAAS,CAAA,EAAG,CAAC,QAAA,EAAqB,GAAA,EAAA,GAA0B;AACjF,EAAA,GAAA,CAAI,QAAA,CAAS,OAAA,EAAS,QAAA,EAAU,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,sBAAsB,CAAA;AACzF,CAAC,CAAA;AAEH,cAAA,CAAe,IAAA,EAAM,sBAAA;AACrB,cAAA,CAAe,QAAA,EAAU,0BAAA;AACzB,iDAAA,cAAiC,CAAA;ADXjC;AACA;AACE;AACF,wCAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-SZO4SUUG.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst maxArrayLengthErrorMessage = 'The received value length is greater than expected';\nconst maxArrayLengthErrorKey = 'a:maxArrayLength';\n\n/**\n * @description Asserts that the length of an array is not greater than a specified maximum length.\n * @param {number} expected The maximum allowed length for the array.\n * @returns {RequiredValidation} A validation function that takes a received array 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 = array(string()).custom(maxArrayLength(3));\n * parseOrFail(schema, ['adequate', 'array']);   // Valid\n * parseOrFail(schema, ['adequate', 'array', 'length']);   // Valid\n * parseOrFail(schema, ['adequate', 'array', 'length', 'test']); // Throws an error: 'The received value length is greater than expected'\n *\n * @translation Error Translation Key = 'a:maxArrayLength'\n */\nexport const maxArrayLength = (expected: number): RequiredValidation<unknown[]> =>\n  _constrain({ maxItems: expected }, (received: unknown[], ctx: ExceptionContext) => {\n    if (received.length > expected) ctx.addIssue(expected, received, maxArrayLengthErrorKey);\n  });\n\nmaxArrayLength.key = maxArrayLengthErrorKey;\nmaxArrayLength.message = maxArrayLengthErrorMessage;\nsetToDefaultLocale(maxArrayLength);\n"]}

package/lib/chunk-TCHVA6VG.js

@@ -0,0 +1,24 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkAO6DKPJZjs = require('./chunk-AO6DKPJZ.js');
+
+
+var _chunkLHEU4XACjs = require('./chunk-LHEU4XAC.js');
+
+// src/asserts/object/required.ts
+function required(schema) {
+  const shape = _chunkAO6DKPJZjs._shapeOf.call(void 0, schema, "required");
+  const tightened = {};
+  for (const [key, valueSchema] of Object.entries(shape)) {
+    const tightenedSchema = valueSchema.clone();
+    delete tightenedSchema[_chunkLHEU4XACjs.ctxSymbol].isOptional;
+    tightened[key] = tightenedSchema;
+  }
+  return _chunkAO6DKPJZjs._objectFrom.call(void 0, schema, tightened);
+}
+
+
+
+exports.required = required;
+//# sourceMappingURL=chunk-TCHVA6VG.js.map

package/lib/chunk-TCHVA6VG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-TCHVA6VG.js","../src/asserts/object/required.ts"],"names":[],"mappings":"AAAA;AACE;AACA;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;AC0BO,SAAS,QAAA,CACd,MAAA,EAC4C;AAC5C,EAAA,MAAM,MAAA,EAAQ,uCAAA,MAAS,EAAQ,UAAU,CAAA;AACzC,EAAA,MAAM,UAAA,EAAmC,CAAC,CAAA;AAE1C,EAAA,IAAA,CAAA,MAAW,CAAC,GAAA,EAAK,WAAW,EAAA,GAAK,MAAA,CAAO,OAAA,CAAQ,KAAK,CAAA,EAAG;AAEtD,IAAA,MAAM,gBAAA,EAAkB,WAAA,CAAY,KAAA,CAAM,CAAA;AAC1C,IAAA,OAAO,eAAA,CAAgB,0BAAS,CAAA,CAAE,UAAA;AAClC,IAAA,SAAA,CAAU,GAAG,EAAA,EAAI,eAAA;AAAA,EACnB;AAEA,EAAA,OAAO,0CAAA,MAAY,EAAQ,SAAS,CAAA;AACtC;AD7BA;AACA;AACE;AACF,4BAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-TCHVA6VG.js","sourcesContent":[null,"import { WithObject } from '../../commonTypes';\nimport { CommonSchema, ObjectShapeSchemaType } from '../../core';\nimport { ctxSymbol } from '../../helpers/constants';\nimport { ObjectSchema } from './index';\nimport { _objectFrom, _shapeOf } from './pick';\n\n/**\n * Named rather than written inline in both the signature and the cast: the two spellings of the same\n * mapped type are not provably identical to the compiler once `~standard` puts a deferred\n * `InferType<this>` inside them.\n *\n * Removing the brand rather than trying to recover the type it wraps, because an intersection cannot\n * be taken apart again. What matters to `InferType` is that the result no longer carries the marker.\n */\ntype RequiredShape<T extends ObjectShapeSchemaType> = { [K in keyof T]: Omit<T[K], 'validation_undefined'> };\n\n/**\n * @description Creates a new object schema in which every property is required, the counterpart to\n * `partial`.\n *\n * A property that carried a default keeps it, so it may still be omitted — a default is what makes a\n * property supply its own value rather than optional.\n *\n * @template T\n * @param {WithObject<CommonSchema, T>} schema - The object schema to tighten.\n * @returns A new object schema with every property required.\n * @example\n * const patchSchema = partial(object({ id: string(), name: string() }));\n * const fullSchema = required(patchSchema);\n * parseOrFail(fullSchema, { id: '1', name: 'a' }); // Validates successfully\n * parseOrFail(fullSchema, {}); // Throws a validation error\n *\n * @instance Of CommonSchema\n */\nexport function required<T extends ObjectShapeSchemaType>(\n  schema: WithObject<CommonSchema, T>,\n): WithObject<ObjectSchema, RequiredShape<T>> {\n  const shape = _shapeOf(schema, 'required');\n  const tightened: ObjectShapeSchemaType = {};\n\n  for (const [key, valueSchema] of Object.entries(shape)) {\n    // A copy, so the property schema the source holds keeps whatever it had.\n    const tightenedSchema = valueSchema.clone();\n    delete tightenedSchema[ctxSymbol].isOptional;\n    tightened[key] = tightenedSchema;\n  }\n\n  return _objectFrom(schema, tightened) as unknown as WithObject<ObjectSchema, RequiredShape<T>>;\n}\n"]}

package/lib/chunk-TD3Y3IV3.js

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkEI6TQG4Ljs = require('./chunk-EI6TQG4L.js');
+
+// src/asserts/coerce/string.ts
+var coerceString = () => _chunkEI6TQG4Ljs.string.call(void 0, ).transformBeforeValidation(
+  (received) => received === null || typeof received === "string" ? received : String(received)
+);
+
+
+
+exports.coerceString = coerceString;
+//# sourceMappingURL=chunk-TD3Y3IV3.js.map

package/lib/chunk-TD3Y3IV3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-TD3Y3IV3.js","../src/asserts/coerce/string.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACA;ACkBO,IAAM,aAAA,EAAe,CAAA,EAAA,GAC1B,qCAAA,CAAO,CAAE,yBAAA;AAAA,EAAmC,CAAC,QAAA,EAAA,GAC3C,SAAA,IAAa,KAAA,GAAQ,OAAO,SAAA,IAAa,SAAA,EAAY,SAAA,EAAsB,MAAA,CAAO,QAAQ;AAC5F,CAAA;ADjBF;AACA;AACE;AACF,oCAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-TD3Y3IV3.js","sourcesContent":[null,"import { string } from '../string/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 string before validating it. Anything that is not\n * already a string is passed through `String`.\n *\n * @returns A string schema that accepts `unknown` as its input type.\n * @example\n * parseOrFail(coerceString(), 42); // '42'\n */\nexport const coerceString = () =>\n  string().transformBeforeValidation<unknown>((received) =>\n    received === null || typeof received === 'string' ? (received as string) : String(received),\n  );\n"]}

package/lib/{chunk-C2VSTWID.js → chunk-TJ7IQSHU.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/array/minArrayLength.ts
 var minArrayLengthErrorMessage = "The received value length is less than expected";
 var minArrayLengthErrorKey = "a:minArrayLength";
-var minArrayLength = (expected) => (received, ctx) => {
-  if (received.length < expected) ctx.addIssue(expected, received, minArrayLengthErrorMessage);
-};
+var minArrayLength = (expected) => _chunkWOPNDC4Rjs._constrain.call(void 0, { minItems: expected }, (received, ctx) => {
+  if (received.length < expected) ctx.addIssue(expected, received, minArrayLengthErrorKey);
+});
 minArrayLength.key = minArrayLengthErrorKey;
 minArrayLength.message = minArrayLengthErrorMessage;
-_chunkTJQ5NVL4js.setToDefaultLocale.call(void 0, minArrayLength);
+_chunkZJGY6EOEjs.setToDefaultLocale.call(void 0, minArrayLength);
 
 
 
 exports.minArrayLength = minArrayLength;
-//# sourceMappingURL=chunk-C2VSTWID.js.map
+//# sourceMappingURL=chunk-TJ7IQSHU.js.map

package/lib/chunk-TJ7IQSHU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/bguard/bguard/lib/chunk-TJ7IQSHU.js","../src/asserts/array/minArrayLength.ts"],"names":[],"mappings":"AAAA;AACE;AACF,sDAA4B;AAC5B;AACE;AACF,sDAA4B;AAC5B;AACA;ACHA,IAAM,2BAAA,EAA6B,iDAAA;AACnC,IAAM,uBAAA,EAAyB,kBAAA;AAexB,IAAM,eAAA,EAAiB,CAAC,QAAA,EAAA,GAC7B,yCAAA,EAAa,QAAA,EAAU,SAAS,CAAA,EAAG,CAAC,QAAA,EAAqB,GAAA,EAAA,GAA0B;AACjF,EAAA,GAAA,CAAI,QAAA,CAAS,OAAA,EAAS,QAAA,EAAU,GAAA,CAAI,QAAA,CAAS,QAAA,EAAU,QAAA,EAAU,sBAAsB,CAAA;AACzF,CAAC,CAAA;AAEH,cAAA,CAAe,IAAA,EAAM,sBAAA;AACrB,cAAA,CAAe,QAAA,EAAU,0BAAA;AACzB,iDAAA,cAAiC,CAAA;ADXjC;AACA;AACE;AACF,wCAAC","file":"/home/runner/work/bguard/bguard/lib/chunk-TJ7IQSHU.js","sourcesContent":[null,"import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { _constrain } from '../../helpers/jsonSchemaConstraint';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst minArrayLengthErrorMessage = 'The received value length is less than expected';\nconst minArrayLengthErrorKey = 'a:minArrayLength';\n\n/**\n * @description Asserts that the length of na array is not less than a specified minimum length.\n * @param {number} expected The minimum required length for the array.\n * @returns {RequiredValidation} A validation function that takes a received array and an exception context.\n * @throws {ValidationError} if the length of the received value is less than the expected length.\n * @example\n * const schema = array(string()).custom(minArrayLength(3));\n * parseOrFail(schema, ['short', 'array']);    // Throws an error: 'The received value length is less than expected'\n * parseOrFail(schema, ['adequate', 'array', 'length']); // Valid\n * parseOrFail(schema, ['adequate', 'array', 'length', 'test']); // Valid\n *\n * @translation Error Translation Key = 'a:minArrayLength'\n */\nexport const minArrayLength = (expected: number): RequiredValidation<unknown[]> =>\n  _constrain({ minItems: expected }, (received: unknown[], ctx: ExceptionContext) => {\n    if (received.length < expected) ctx.addIssue(expected, received, minArrayLengthErrorKey);\n  });\n\nminArrayLength.key = minArrayLengthErrorKey;\nminArrayLength.message = minArrayLengthErrorMessage;\nsetToDefaultLocale(minArrayLength);\n"]}

package/lib/{chunk-7JL66G7G.mjs → chunk-TPSWNY5K.mjs}

@@ -1,6 +1,6 @@
 import {
   setToDefaultLocale
-} from "./chunk-OE3L7EKN.mjs";
+} from "./chunk-65X7NTUS.mjs";
 
 // src/asserts/string/endsWith.ts
 var endsWithErrorMessage = "The received value does not end with the required substring";
@@ -17,4 +17,4 @@ setToDefaultLocale(endsWith);
 export {
   endsWith
 };
-//# sourceMappingURL=chunk-7JL66G7G.mjs.map
+//# sourceMappingURL=chunk-TPSWNY5K.mjs.map

package/lib/{chunk-7JL66G7G.mjs.map → chunk-TPSWNY5K.mjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/asserts/string/endsWith.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst endsWithErrorMessage = 'The received value does not end with the required substring';\nconst endsWithErrorKey = 's:endsWith';\n\n/**\n * @description Asserts that a string value ends with a specified substring.\n * @param {string} substring The substring that the string value must end 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 end with the required substring.\n * @example\n * const schema = string().custom(endsWith('bar'));\n * parseOrFail(schema, 'foobar'); // Valid\n * parseOrFail(schema, 'foofoo'); // Throws an error: 'The received value does not end with the required substring'\n *\n * @translation Error Translation Key = 's:endsWith'\n */\nexport const endsWith =\n  (substring: string): RequiredValidation =>\n  (received: string, ctx: ExceptionContext) => {\n    if (!received.endsWith(substring)) {\n      ctx.addIssue(`ends with '${substring}'`, received, endsWithErrorKey);\n    }\n  };\n\nendsWith.key = endsWithErrorKey;\nendsWith.message = endsWithErrorMessage;\nsetToDefaultLocale(endsWith);\n"],"mappings":";;;;;AAGA,IAAM,uBAAuB;AAC7B,IAAM,mBAAmB;AAclB,IAAM,WACX,CAAC,cACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,CAAC,SAAS,SAAS,SAAS,GAAG;AACjC,QAAI,SAAS,cAAc,SAAS,KAAK,UAAU,gBAAgB;AAAA,EACrE;AACF;AAEF,SAAS,MAAM;AACf,SAAS,UAAU;AACnB,mBAAmB,QAAQ;","names":[]}
+{"version":3,"sources":["../src/asserts/string/endsWith.ts"],"sourcesContent":["import type { ExceptionContext, RequiredValidation } from '../../core';\nimport { setToDefaultLocale } from '../../translationMap';\n\nconst endsWithErrorMessage = 'The received value does not end with the required substring';\nconst endsWithErrorKey = 's:endsWith';\n\n/**\n * @description Asserts that a string value ends with a specified substring.\n * @param {string} substring The substring that the string value must end 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 end with the required substring.\n * @example\n * const schema = string().custom(endsWith('bar'));\n * parseOrFail(schema, 'foobar'); // Valid\n * parseOrFail(schema, 'foofoo'); // Throws an error: 'The received value does not end with the required substring'\n *\n * @translation Error Translation Key = 's:endsWith'\n */\nexport const endsWith =\n  (substring: string): RequiredValidation<string> =>\n  (received: string, ctx: ExceptionContext) => {\n    if (!received.endsWith(substring)) {\n      ctx.addIssue(`ends with '${substring}'`, received, endsWithErrorKey);\n    }\n  };\n\nendsWith.key = endsWithErrorKey;\nendsWith.message = endsWithErrorMessage;\nsetToDefaultLocale(endsWith);\n"],"mappings":";;;;;AAGA,IAAM,uBAAuB;AAC7B,IAAM,mBAAmB;AAclB,IAAM,WACX,CAAC,cACD,CAAC,UAAkB,QAA0B;AAC3C,MAAI,CAAC,SAAS,SAAS,SAAS,GAAG;AACjC,QAAI,SAAS,cAAc,SAAS,KAAK,UAAU,gBAAgB;AAAA,EACrE;AACF;AAEF,SAAS,MAAM;AACf,SAAS,UAAU;AACnB,mBAAmB,QAAQ;","names":[]}

package/lib/chunk-UCY3HEYZ.mjs

@@ -0,0 +1,13 @@
+import {
+  number
+} from "./chunk-DS2LUTTF.mjs";
+
+// src/asserts/coerce/number.ts
+var coerceNumber = () => number().transformBeforeValidation(
+  (received) => received === null || typeof received === "number" ? received : Number(received)
+);
+
+export {
+  coerceNumber
+};
+//# sourceMappingURL=chunk-UCY3HEYZ.mjs.map

package/lib/chunk-UCY3HEYZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/asserts/coerce/number.ts"],"sourcesContent":["import { number } from '../number/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 number before validating it. Anything that is not\n * already a number is passed through `Number`.\n *\n * A value `Number` cannot read becomes `NaN`, which `number()` rejects, so `'abc'` fails validation\n * rather than passing as a number.\n *\n * @returns A number schema that accepts `unknown` as its input type.\n * @example\n * parseOrFail(coerceNumber(), '42'); // 42\n */\nexport const coerceNumber = () =>\n  number().transformBeforeValidation<unknown>((received) =>\n    received === null || typeof received === 'number' ? (received as number) : Number(received),\n  );\n"],"mappings":";;;;;AAyBO,IAAM,eAAe,MAC1B,OAAO,EAAE;AAAA,EAAmC,CAAC,aAC3C,aAAa,QAAQ,OAAO,aAAa,WAAY,WAAsB,OAAO,QAAQ;AAC5F;","names":[]}

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":[]}