valgen 6.2.2 → 7.0.0

package/README.md

@@ -5,32 +5,119 @@
 [![CI Tests][ci-test-image]][ci-test-url]
 [![Test Coverage][coveralls-image]][coveralls-url]
 
-Fast runtime type validator, converter and io (encoding/decoding) library.
+Fast runtime type validator, converter and io (encoding/decoding) library for TypeScript and
+JavaScript.
+
+- **Composable** - build complex schemas out of small validators with `allOf`, `oneOf`, `pipe`,
+  `optional`, `nullable`, `isObject`, `isArray`, ...
+- **Coercing** - most rules can convert compatible input (`"42"` -> `42`, `"true"` -> `true`, ...)
+  instead of just rejecting it, via the `coerce` option.
+- **Two calling conventions** - call a validator directly and catch a `ValidationError`, or use
+  `.silent(...)` to get back `{ value }` / `{ errors }` without throwing.
+- **Typed** - every validator infers its output type, so a passing call narrows the type of its
+  return value.
+- **Fast** - the core dispatch path and every rule are covered by a dedicated benchmark suite (see
+  [Benchmarking](#benchmarking) below); performance regressions are something this project
+  actively measures, not just hopes for.
 
 ## Installation
 
-`$ npm install valgen --save`
+```sh
+npm install valgen --save
+```
+
+## Quick start
+
+```ts
+import { vg, isEmail, ValidationError } from 'valgen';
+
+// Individual, ready-to-use validators
+isEmail('a@b.com'); // => 'a@b.com'
+isEmail('not-an-email'); // throws ValidationError
+
+// A full object schema, built from composable rules
+const userSchema = vg.isObject({
+  id: vg.isUUID(),
+  email: vg.isEmail(),
+  age: vg.optional(vg.pipe([vg.isNumber({ coerce: true }), vg.isGt(0)])),
+  role: vg.isEnum(['admin', 'user']),
+});
+
+try {
+  const user = userSchema({
+    id: 'e6a3b1c0-70b6-4a3e-9b34-1e2f2e3d1a11',
+    email: 'a@b.com',
+    age: '30', // coerced to a number
+    role: 'admin',
+  });
+} catch (e) {
+  if (e instanceof ValidationError) {
+    console.error(e.issues); // one entry per failing field
+  }
+}
+
+// Or avoid the try/catch entirely
+const result = userSchema.silent({ email: 'not-an-email' });
+if (result.errors) {
+  // result.errors: ErrorIssue[]
+}
+```
+
+## Documentation
+
+The full API reference lives under [`docs/`](docs/api.md):
+
+- **[API overview](docs/api.md)** - the `Validator` shape, `.silent()`, pre-built instances vs.
+  factories, `ExecutionOptions`, error shape, composition patterns, and how to write a custom rule.
+- **[Type Rules](docs/api/type-rules.md)** - `isString`, `isNumber`, `isObject`, `isArray`,
+  `isTuple`, `isEnum`, `isDate`, `isRecord`, `isInstanceOf`, ...
+- **[Logical Rules](docs/api/logical-rules.md)** - `isEqual`, `isGt`/`isGte`/`isLt`/`isLte`,
+  `range`, `lengthMin`/`lengthMax`, `isEmpty`/`isNotEmpty`, `isDefined`.
+- **[Utility Rules](docs/api/utility-rules.md)** - `allOf`, `oneOf`, `pipe`, `optional`,
+  `nullable`, `required`, `fixed`, `getLength`, `forwardRef`, `iif`, string helpers.
+- **[Format Rules](docs/api/format-rules.md)** - `isEmail`, `isURL`, `isUUID`, `isIBAN`,
+  `isMACAddress`, `isCreditCard`, and every other string-format check.
+
+## Scripts
+
+| Command | Description |
+|---|---|
+| `npm test` | Run the test suite (mocha). |
+| `npm run citest` | Run the test suite with coverage (c8). |
+| `npm run qc` | Lint + circular-dependency check. |
+| `npm run bench` | Run the benchmark suite (see below). |
+| `npm run build` | Type-check and compile to `build/`. |
+
+## Benchmarking
+
+Every validator rule has a dedicated benchmark case measuring throughput (ops/sec) and per-call
+memory allocation (heap/RSS), under `benchmark/rules/`.
+
+```sh
+# Run every rule
+npm run bench
+
+# Run one or more rules (case-insensitive, comma-separated, "*" wildcards allowed)
+npm run bench -- -s isEmail,isURL
+npm run bench -- -s "is*"
+```
+
+Results print to the console as they complete and are also written to [`BENCHMARKS.md`](BENCHMARKS.md)
+at the end of the run.
 
 ## Node Compatibility
 
-  - node `>= 16.0`;
-  
+- node `>= 20.0`
+
 ### License
+
 [MIT](LICENSE)
 
-[npm-image]: https://img.shields.io/npm/v/valgen.svg
+[npm-image]: https://img.shields.io/npm/v/valgen
 [npm-url]: https://npmjs.org/package/valgen
+[downloads-image]: https://img.shields.io/npm/dm/valgen.svg
+[downloads-url]: https://npmjs.org/package/valgen
 [ci-test-image]: https://github.com/panates/valgen/actions/workflows/test.yml/badge.svg
 [ci-test-url]: https://github.com/panates/valgen/actions/workflows/test.yml
 [coveralls-image]: https://img.shields.io/coveralls/panates/valgen/master.svg
 [coveralls-url]: https://coveralls.io/r/panates/valgen
-[downloads-image]: https://img.shields.io/npm/dm/valgen.svg
-[downloads-url]: https://npmjs.org/package/valgen
-[gitter-image]: https://badges.gitter.im/panates/valgen.svg
-[gitter-url]: https://gitter.im/panates/valgen?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
-[dependencies-image]: https://david-dm.org/panates/valgen/status.svg
-[dependencies-url]:https://david-dm.org/panates/valgen
-[devdependencies-image]: https://david-dm.org/panates/valgen/dev-status.svg
-[devdependencies-url]:https://david-dm.org/panates/valgen?type=dev
-[quality-image]: http://npm.packagequality.com/shield/valgen.png
-[quality-url]: http://packagequality.com/#?package=valgen

package/constants.js

@@ -1,4 +1,4 @@
-export const version = '6.2.2';
+export const version = '7.0.0';
 export const postValidation = Symbol('postValidation');
 export const preValidation = Symbol('preValidation');
 export const VALIDATE_METADATA = Symbol('VALIDATE_METADATA');

package/core/context.js

@@ -1,7 +1,7 @@
 import { omitUndefined } from '../helpers/omit-undefined.js';
 import { ValidationError } from './validation-error.js';
 const VARIABLE_REPLACE_PATTERN = /{{([^}]*)}}/g;
-const OPTIONAL_VAR_PATTERN = /^([^?]+)(?:\||(.*))?$/;
+const OPTIONAL_VAR_PATTERN = /^([^|]+)(?:\|(.*))?$/;
 export class Context {
     isRoot = true;
     errors = [];
@@ -66,15 +66,26 @@ export class Context {
         }
     }
     extend(options) {
-        const extended = {};
+        // Object.create(this) sets the prototype at creation time. Setting it
+        // afterward via Object.setPrototypeOf() (the previous approach) is one
+        // of the slowest object operations in V8 - it invalidates hidden-class
+        // based optimizations for the object - and this runs on every nested
+        // validator call, so it showed up heavily in profiling.
+        const extended = Object.create(this);
         if (options) {
-            for (const [k, v] of Object.entries(options)) {
+            // Same filtering as the old Object.entries()+destructure (skip
+            // undefined values, so an unset option falls through to the
+            // prototype chain instead of shadowing it) but without allocating an
+            // array of [key, value] pairs just to throw it away.
+            const keys = Object.keys(options);
+            for (let i = 0; i < keys.length; i++) {
+                const k = keys[i];
+                const v = options[k];
                 if (v !== undefined)
                     extended[k] = v;
             }
         }
         extended.isRoot = false;
-        Object.setPrototypeOf(extended, this);
         return extended;
     }
 }

package/core/utilities.js

@@ -6,21 +6,21 @@ import { isValidator, validator } from './validator.js';
 export function forwardRef(fn) {
     return validator('forwardRef', (input, context) => {
         const nested = fn(context);
-        return nested(input, context);
+        return nested(input, undefined, context);
     });
 }
 export function iif(check, _then, _else) {
     return validator('iif', (input, context) => {
         let c = _else;
         try {
-            if (check(input) !== undefined)
-                c = _then;
+            check(input);
+            c = _then;
         }
         catch {
             // ignored
         }
         if (isValidator(c))
-            return c(input, context);
+            return c(input, undefined, context);
         return c;
     });
 }

package/index.js

@@ -73,15 +73,17 @@ const toDate = vg.isDate({ coerce: true });
 const toDateStringValidators = new Map();
 const toDateString = (input, options, ctx) => {
     const precisionMax = options?.trim ?? 'ms';
-    let validator = toDateStringValidators.get(precisionMax);
+    const separators = options?.separators ?? true;
+    const cacheKey = precisionMax + '|' + separators;
+    let validator = toDateStringValidators.get(cacheKey);
     if (!validator) {
         validator = vg.isDateString({
             coerce: true,
             precisionMax,
             trim: true,
-            separators: options?.separators,
+            separators,
         });
-        toDateStringValidators.set(precisionMax, validator);
+        toDateStringValidators.set(cacheKey, validator);
     }
     return validator(input, options, ctx);
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "valgen",
   "description": "Fast runtime type validator, converter and io (encoding/decoding) library",
-  "version": "6.2.2",
+  "version": "7.0.0",
   "author": "Panates",
   "license": "MIT",
   "dependencies": {

package/rules/format-rules/is-alpha.js

@@ -8,6 +8,6 @@ export function isAlpha(options) {
     return validator(isAlpha.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isAlpha(input))
             return input;
-        context.fail(_this, `"Value must be an alpha string`, input);
+        context.fail(_this, `Value must be an alpha string`, input);
     }, options);
 }

package/rules/format-rules/is-alphanumeric.js

@@ -9,6 +9,6 @@ export function isAlphanumeric(options) {
         if (typeof input === 'string' && validatorJS.isAlphanumeric(input)) {
             return input;
         }
-        context.fail(_this, `"Value must be an alphanumeric string`, input);
+        context.fail(_this, `Value must be an alphanumeric string`, input);
     }, options);
 }

package/rules/format-rules/is-base64.js

@@ -9,6 +9,6 @@ export function isBase64(options) {
         if (typeof input === 'string' && validatorJS.isBase64(input, options)) {
             return input;
         }
-        context.fail(_this, `"Value must be a Base64 string`, input);
+        context.fail(_this, `Value must be a Base64 string`, input);
     }, options);
 }

package/rules/format-rules/is-email.js

@@ -8,8 +8,9 @@ export function isEmail(options) {
     const emailOptions = {
         allow_display_name: true,
         allow_utf8_local_part: options?.utf8LocalPart,
-        ignore_max_length: true,
+        ignore_max_length: options?.ignoreMaxLength,
         allow_ip_domain: options?.allowIpDomain,
+        domain_specific_validation: options?.domainSpecificValidation,
     };
     return validator(isEmail.name, (input, context, _this) => {
         if (typeof input === 'string' &&
@@ -57,6 +58,6 @@ export function isEmail(options) {
             }
             return input;
         }
-        context.fail(_this, `Value must much required e-mail format`, input);
+        context.fail(_this, `Value must match required e-mail format`, input);
     }, options);
 }

package/rules/format-rules/is-iban.d.ts

@@ -1,3 +1,4 @@
+import { type IsIBANOptions as _IsIBANOptions } from '@browsery/validator';
 import { type ValidationOptions } from '../../core/index.js';
 /**
  * Validates if value is an IBAN (International Bank Account Number)
@@ -5,6 +6,6 @@ import { type ValidationOptions } from '../../core/index.js';
  */
 export declare function isIBAN(options?: isIBAN.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
 export declare namespace isIBAN {
-    interface Options extends ValidationOptions {
+    interface Options extends ValidationOptions, _IsIBANOptions {
     }
 }

package/rules/format-rules/is-iban.js

@@ -1,4 +1,4 @@
-import validatorJS from '@browsery/validator';
+import validatorJS, {} from '@browsery/validator';
 import { validator, } from '../../core/index.js';
 /**
  * Validates if value is an IBAN (International Bank Account Number)
@@ -6,7 +6,7 @@ import { validator, } from '../../core/index.js';
  */
 export function isIBAN(options) {
     return validator(isIBAN.name, (input, context, _this) => {
-        if (typeof input === 'string' && validatorJS.isIBAN(input))
+        if (typeof input === 'string' && validatorJS.isIBAN(input, options))
             return input;
         context.fail(_this, `Value must be a valid IBAN (International Bank Account Number)`, input);
     }, options);

package/rules/format-rules/is-mobile-phone.d.ts

@@ -1,7 +1,7 @@
 import { type MobilePhoneLocale as _MobilePhoneLocale } from '@browsery/validator';
 import { type ValidationOptions } from '../../core/index.js';
 /**
- * Validates if value is a valid Email
+ * Validates if value is a valid mobile phone number
  * @validator isMobilePhone
  */
 export declare function isMobilePhone(options?: isMobilePhone.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;

package/rules/format-rules/is-mobile-phone.js

@@ -1,7 +1,7 @@
 import validatorJS, {} from '@browsery/validator';
 import { validator, } from '../../core/index.js';
 /**
- * Validates if value is a valid Email
+ * Validates if value is a valid mobile phone number
  * @validator isMobilePhone
  */
 export function isMobilePhone(options) {
@@ -13,6 +13,6 @@ export function isMobilePhone(options) {
             validatorJS.isMobilePhone(input, options?.locale, opts)) {
             return input;
         }
-        context.fail(_this, `Value must be a valid a Mobile Phone Number`, input);
+        context.fail(_this, `Value must be a valid Mobile Phone Number`, input);
     }, options);
 }

package/rules/format-rules/is-passport-number.js

@@ -10,6 +10,6 @@ export function isPassportNumber(countryCode, options) {
             validatorJS.isPassportNumber(input, countryCode)) {
             return input;
         }
-        context.fail(_this, `Value must be a valid ${countryCode} PassportNumber)`, input);
+        context.fail(_this, `Value must be a valid ${countryCode} Passport Number`, input);
     }, options);
 }

package/rules/format-rules/is-swift.js

@@ -8,6 +8,6 @@ export function isSWIFT(options) {
     return validator(isSWIFT.name, (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isBIC(input))
             return input;
-        context.fail(_this, `Value must be a valid a BIC (Bank Identification Code) or SWIFT code`, input);
+        context.fail(_this, `Value must be a valid BIC (Bank Identification Code) or SWIFT code`, input);
     }, options);
 }

package/rules/format-rules/is-time.js

@@ -1,5 +1,5 @@
 import { validator, } from '../../core/index.js';
-const TIME_PATTERN = /^(\d{2}):?(\d{2})(?::?(\d{2})?(?:\.(\d{1,3}))?)?$/;
+const TIME_PATTERN = /^(\d{2}):?(\d{2})(?::?(\d{2}))?(?:\.(\d{1,3}))?$/;
 /**
  * Validates if value is a time formatted string
  * @validator isTime

package/rules/format-rules/matches.d.ts

@@ -1,7 +1,7 @@
 import { type ValidationOptions } from '../../core/index.js';
 /**
- * Coerces given value to "UUID" format or returns undefined if nullish
- * @validator uuid
+ * Validates if value matches the given regular expression, or returns undefined if nullish
+ * @validator matches
  */
 export declare function matches(format: string | RegExp, options?: matches.Options): import("../../core/validator.js").Validator<string, string, import("../../core/types.js").ExecutionOptions>;
 export declare namespace matches {

package/rules/format-rules/matches.js

@@ -1,7 +1,7 @@
 import { validator, } from '../../core/index.js';
 /**
- * Coerces given value to "UUID" format or returns undefined if nullish
- * @validator uuid
+ * Validates if value matches the given regular expression, or returns undefined if nullish
+ * @validator matches
  */
 export function matches(format, options) {
     const regExp = format instanceof RegExp ? format : new RegExp(format);
@@ -9,6 +9,7 @@ export function matches(format, options) {
     return validator(matches.name, (input, context, _this) => {
         if (input == null)
             return;
+        regExp.lastIndex = 0;
         if (typeof input === 'string' && regExp.test(input))
             return input;
         context.fail(_this, `Value must match ${formatName || 'requested'} format`, input, {

package/rules/logical-rules/is-defined.d.ts

@@ -1,6 +1,7 @@
 import { type ValidationOptions } from '../../core/index.js';
 /**
- * Validates if value is not "undefined" nor "null"
+ * Validates if value is not "undefined". Note that "null" is considered
+ * defined; use `isNotNullish` to reject both "undefined" and "null".
  * @validator isDefined
  */
 export declare function isDefined(options?: isDefined.Options): import("../../core/validator.js").Validator<any, unknown, import("../../core/types.js").ExecutionOptions>;

package/rules/logical-rules/is-defined.js

@@ -1,6 +1,7 @@
 import { validator, } from '../../core/index.js';
 /**
- * Validates if value is not "undefined" nor "null"
+ * Validates if value is not "undefined". Note that "null" is considered
+ * defined; use `isNotNullish` to reject both "undefined" and "null".
  * @validator isDefined
  */
 export function isDefined(options) {

package/rules/logical-rules/is-equal.d.ts

@@ -1,6 +1,7 @@
 import { type ValidationOptions } from '../../core/index.js';
 /**
- *
+ * Validates if the value is strictly equal ("===") to "compare".
+ * `null`/`undefined` input is passed through unchanged.
  * @validator isEqual
  */
 export declare function isEqual<T>(compare: T, options?: isEqual.Options): import("../../core/validator.js").Validator<any, any, import("../../core/types.js").ExecutionOptions>;
@@ -9,7 +10,8 @@ export declare namespace isEqual {
     }
 }
 /**
- *
+ * Validates if the value is not strictly equal ("===") to "compare".
+ * `null`/`undefined` input is passed through unchanged.
  * @validator isNotEqual
  */
 export declare function isNotEqual(compare: any, options?: isNotEqual.Options): import("../../core/validator.js").Validator<any, any, import("../../core/types.js").ExecutionOptions>;

package/rules/logical-rules/is-equal.js

@@ -1,6 +1,7 @@
 import { validator, } from '../../core/index.js';
 /**
- *
+ * Validates if the value is strictly equal ("===") to "compare".
+ * `null`/`undefined` input is passed through unchanged.
  * @validator isEqual
  */
 export function isEqual(compare, options) {
@@ -13,7 +14,8 @@ export function isEqual(compare, options) {
     }, options);
 }
 /**
- *
+ * Validates if the value is not strictly equal ("===") to "compare".
+ * `null`/`undefined` input is passed through unchanged.
  * @validator isNotEqual
  */
 export function isNotEqual(compare, options) {

package/rules/logical-rules/is-gt.d.ts

@@ -1,8 +1,8 @@
 import { type ValidationOptions, type Validator } from '../../core/index.js';
 import type { range } from './range.js';
 /**
- * Checks if value is grater than "minValue"
- * @validator iGt
+ * Checks if value is greater than "minValue"
+ * @validator isGt
  */
 export declare function isGt<T extends range.Input>(minValue: T, options?: isGt.Options): Validator;
 export declare namespace isGt {

package/rules/logical-rules/is-gt.js

@@ -1,7 +1,7 @@
 import { validator, } from '../../core/index.js';
 /**
- * Checks if value is grater than "minValue"
- * @validator iGt
+ * Checks if value is greater than "minValue"
+ * @validator isGt
  */
 export function isGt(minValue, options) {
     return validator(isGt.name, (input, context, _this) => {

package/rules/logical-rules/is-gte.d.ts

@@ -1,7 +1,7 @@
 import { type ValidationOptions, type Validator } from '../../core/index.js';
 import type { range } from './range.js';
 /**
- * Checks if value is grater than or equal to minValue
+ * Checks if value is greater than or equal to minValue
  * @validator isGte
  */
 export declare function isGte<T extends range.Input>(minValue: T, options?: isGte.Options): Validator<T>;

package/rules/logical-rules/is-gte.js

@@ -1,6 +1,6 @@
 import { validator, } from '../../core/index.js';
 /**
- * Checks if value is grater than or equal to minValue
+ * Checks if value is greater than or equal to minValue
  * @validator isGte
  */
 export function isGte(minValue, options) {

package/rules/logical-rules/is-lt.d.ts

@@ -1,7 +1,7 @@
 import { type ValidationOptions, type Validator } from '../../core/index.js';
 import type { range } from './range.js';
 /**
- * Checks if the value is lover than maxValue
+ * Checks if the value is lower than maxValue
  * @validator isLt
  */
 export declare function isLt<T extends range.Input>(maxValue: T, options?: isLt.Options): Validator;

package/rules/logical-rules/is-lt.js

@@ -1,6 +1,6 @@
 import { validator, } from '../../core/index.js';
 /**
- * Checks if the value is lover than maxValue
+ * Checks if the value is lower than maxValue
  * @validator isLt
  */
 export function isLt(maxValue, options) {
@@ -22,6 +22,6 @@ export function isLt(maxValue, options) {
                     input.toLowerCase() < maxValue.toLowerCase()))) {
             return input;
         }
-        context.fail(_this, `Value must be lover than ${typeof maxValue === 'string' ? `"${maxValue}"` : maxValue}`, input);
+        context.fail(_this, `Value must be lower than ${typeof maxValue === 'string' ? `"${maxValue}"` : maxValue}`, input);
     }, options);
 }

package/rules/logical-rules/is-lte.d.ts

@@ -1,7 +1,7 @@
 import { type ValidationOptions, type Validator } from '../../core/index.js';
 import type { range } from './range.js';
 /**
- * Checks if the value is lover than or equal to maxValue
+ * Checks if the value is lower than or equal to maxValue
  * @validator isLte
  */
 export declare function isLte<T extends range.Input>(maxValue: T, options?: isLte.Options): Validator;

package/rules/logical-rules/is-lte.js

@@ -1,6 +1,6 @@
 import { validator, } from '../../core/index.js';
 /**
- * Checks if the value is lover than or equal to maxValue
+ * Checks if the value is lower than or equal to maxValue
  * @validator isLte
  */
 export function isLte(maxValue, options) {
@@ -22,6 +22,6 @@ export function isLte(maxValue, options) {
                     input.toLowerCase() <= maxValue.toLowerCase()))) {
             return input;
         }
-        context.fail(_this, `Value must be lover than or equal to ${typeof maxValue === 'string' ? `"${maxValue}"` : maxValue}`, input);
+        context.fail(_this, `Value must be lower than or equal to ${typeof maxValue === 'string' ? `"${maxValue}"` : maxValue}`, input);
     }, options);
 }

package/rules/type-rules/is-array.js

@@ -16,25 +16,27 @@ export function isArray(itemValidator, options) {
         }
         if (!itemValidator)
             return output;
-        // const location = context.location || '';
         const itemContext = context.extend();
         let i;
         let v;
         const l = output.length;
         const out = [];
+        // Set directly on the (already reused) context instead of passed as
+        // a fresh {onFail} options object on every call - `i` is read at call
+        // time (synchronously, before it's incremented), so a single closure
+        // works for the whole loop. This also lets the item call below pass
+        // `undefined` for options, which the validator wrapper needs in order
+        // to skip a needless context.extend() when the item rule has no
+        // options of its own.
+        itemContext.onFail = (issue) => `Item at index [${i}] is not valid. ` + issue.message;
         for (i = 0; i < l; i++) {
             v = output[i];
             itemContext.scope = output;
-            // itemContext.location = location + '[' + i + ']';
             itemContext.location = context.location
                 ? context.location + `[${i}]`
                 : `<Array>[${i}]`;
             itemContext.index = i;
-            v = itemValidator(v, {
-                onFail(issue) {
-                    return `Item at index [${i}] is not valid. ` + issue.message;
-                },
-            }, itemContext);
+            v = itemValidator(v, undefined, itemContext);
             out.push(v);
         }
         return out;

package/rules/type-rules/is-bigint.d.ts

@@ -1,8 +1,8 @@
 import { type ValidationOptions } from '../../core/index.js';
 /**
  * Validates if value is "BigInt".
- * Converts input value to number if the coerce option is set to 'true'.
- * @validator isNumber
+ * Converts input value to BigInt if the coerce option is set to 'true'.
+ * @validator isBigint
  */
 export declare function isBigint(options?: isBigint.Options): import("../../core/validator.js").Validator<bigint, unknown, import("../../core/types.js").ExecutionOptions>;
 export declare namespace isBigint {

package/rules/type-rules/is-bigint.js

@@ -1,17 +1,21 @@
 import { validator, } from '../../core/index.js';
 /**
  * Validates if value is "BigInt".
- * Converts input value to number if the coerce option is set to 'true'.
- * @validator isNumber
+ * Converts input value to BigInt if the coerce option is set to 'true'.
+ * @validator isBigint
  */
 export function isBigint(options) {
     return validator(isBigint.name, (input, context, _this) => {
         const coerce = options?.coerce ?? context.coerce;
         if (typeof input === 'bigint')
             return input;
-        if ((typeof input === 'number' && !isNaN(input)) ||
-            (typeof input === 'string' && coerce)) {
-            return BigInt(input);
+        if (coerce && (typeof input === 'number' || typeof input === 'string')) {
+            try {
+                return BigInt(input);
+            }
+            catch {
+                // falls through to context.fail below
+            }
         }
         context.fail(_this, `Value must be a BigInt`, input);
     }, options);

package/rules/type-rules/is-boolean.js

@@ -1,6 +1,6 @@
 import { validator, } from '../../core/index.js';
-const TRUE_PATTERN = /^true|t|1|yes|y$/i;
-const FALSE_PATTERN = /^false|f|0|no|n$/i;
+const TRUE_PATTERN = /^(?:true|t|1|yes|y)$/i;
+const FALSE_PATTERN = /^(?:false|f|0|no|n)$/i;
 /**
  * Validates if value is "boolean".
  * Converts input value to boolean if the coerce option is set to 'true'.