valgen 5.4.1 → 5.5.0

package/esm/core/context.js

@@ -1,5 +1,4 @@
 import { omitUndefined } from '../helpers/omit-undefined.js';
-import { kOptions } from './constants.js';
 import { ValidationError } from './validation-error.js';
 const VARIABLE_REPLACE_PATTERN = /{{([^}]*)}}/g;
 const OPTIONAL_VAR_PATTERN = /^([^?]+)(?:\||(.*))?$/;
@@ -22,11 +21,8 @@ export class Context {
             ...details,
         });
         issue.value = value;
-        const onFail = this.onFail || rule[kOptions].onFail;
-        if (onFail) {
-            const proto = Object.getPrototypeOf(this);
-            const superOnFail = proto.onFail !== onFail ? proto.onFail : undefined;
-            const x = onFail(issue, this, superOnFail);
+        if (this.onFail) {
+            const x = this.onFail(issue, this);
             if (!x)
                 return;
             if (typeof x === 'object')
@@ -44,8 +40,9 @@ export class Context {
                 const s = String(issue.value);
                 return s.length < 30 ? s : s.substring(0, 30) + '..';
             }
-            if (!v && k === 'label' && (this.location || this.property))
+            if (!v && k === 'label' && (this.location || this.property)) {
                 v = '`' + (this.location || this.property) + '`';
+            }
             if (v != null)
                 return v;
             if (m[2])
@@ -53,13 +50,19 @@ export class Context {
             return m[1] === 'label' ? 'Value' : x;
         });
         this.errors.push(issue);
-        if (this.errors.length >= (this.maxErrors ?? Infinity))
+        if (this.errors.length >= (this.maxErrors ?? Infinity)) {
             throw new ValidationError(this.errors);
+        }
     }
     extend(options) {
-        const extended = new Context({ onFail: undefined, ...options });
+        const extended = {};
+        if (options) {
+            for (const [k, v] of Object.entries(options)) {
+                if (v !== undefined)
+                    extended[k] = v;
+            }
+        }
         Object.setPrototypeOf(extended, this);
-        delete extended.errors;
         return extended;
     }
 }

package/esm/core/index.js

@@ -1,6 +1,6 @@
-export * from './context.js';
 export * from './constants.js';
+export * from './context.js';
 export * from './types.js';
+export * from './utilities.js';
 export * from './validation-error.js';
 export * from './validator.js';
-export * from './utilities.js';

package/esm/core/utilities.js

@@ -1,16 +1,16 @@
-import { isValidator, validator } from './index.js';
+import { isValidator, validator, } from './index.js';
 /**
  * Forwards codec process to a sub codec. Useful for circular checks
  * @validator forwardRef
  */
 export function forwardRef(fn) {
-    return validator('forwardRef', function (input, context) {
+    return validator('forwardRef', (input, context) => {
         const nested = fn(context);
         return nested(input, context);
     });
 }
 export function iif(check, _then, _else) {
-    return validator('iif', function (input, context) {
+    return validator('iif', (input, context) => {
         let c = _else;
         try {
             if (check(input) !== undefined)

package/esm/core/validator.js

@@ -2,6 +2,7 @@ import { camelCase } from '../helpers/string.utils.js';
 import { kOptions, kValidatorFn } from './constants.js';
 import { Context } from './context.js';
 import { ValidationError } from './validation-error.js';
+let unnamedValidatorIndex = 0;
 export function validator(arg0, arg1, arg2) {
     let id = '';
     let fn;
@@ -15,15 +16,17 @@ export function validator(arg0, arg1, arg2) {
         fn = arg0;
         validatorOptions = arg1;
     }
-    if (typeof fn !== 'function')
+    if (typeof fn !== 'function') {
         throw new TypeError('You must provide a rule function argument');
-    id = id || fn.name || 'unnamed-rule';
+    }
+    id = id || fn.name || 'validator' + ++unnamedValidatorIndex;
     const name = fn.name || camelCase(id);
     const _rule = {
         [name](input, options) {
             const ctx = options instanceof Context ? options : undefined;
             const opts = ctx ? undefined : options;
-            const context = ctx || new Context(opts);
+            const context = ctx?.extend({ ...validatorOptions, ...opts }) ||
+                new Context({ ...validatorOptions, ...opts });
             let value;
             try {
                 value = fn(input, context, _rule);
@@ -33,8 +36,9 @@ export function validator(arg0, arg1, arg2) {
                     throw e;
                 context.fail(_rule, e, input);
             }
-            if (!ctx && context.errors.length)
+            if (!ctx && context.errors.length) {
                 throw new ValidationError(context.errors);
+            }
             return value;
         },
     }[name];

package/esm/helpers/string.utils.js

@@ -1,5 +1,3 @@
 export function camelCase(v) {
-    return v.replace(/[\W_\s]+([^\W_\s])/g, (arg$, c) => {
-        return c[0].toUpperCase();
-    });
+    return v.replace(/[\W_\s]+([^\W_\s])/g, (arg$, c) => c[0].toUpperCase());
 }

package/esm/index.js

@@ -57,4 +57,4 @@ const toDateString = vg.isDateString({ coerce: true });
 const toInteger = vg.isInteger({ coerce: true });
 const toNumber = vg.isNumber({ coerce: true });
 const toString = vg.isString({ coerce: true });
-export { vg, isAny, isArray, isBigint, isBoolean, isDate, isDateString, isEmpty, isNotEmpty, isInteger, isNull, isNullish, isDefined, isUndefined, isNumber, isObject, isObjectId, isString, isUUID, isUUID1, isUUID2, isUUID3, isUUID4, isUUID5, isEmail, isMobilePhone, isIP, isIPRange, isMACAddress, isPort, isURL, isBase64, isSWIFT, isCreditCard, isIBAN, isEAN, isFQDN, isISSN, isBtcAddress, isETHAddress, isHexColor, isJWT, isLowercase, isUppercase, isAlpha, isAlphanumeric, isAscii, isDecimal, isHex, toArray, toBoolean, toBigint, toDate, toDateString, toInteger, toNumber, toString, };
+export { isAlpha, isAlphanumeric, isAny, isArray, isAscii, isBase64, isBigint, isBoolean, isBtcAddress, isCreditCard, isDate, isDateString, isDecimal, isDefined, isEAN, isEmail, isEmpty, isETHAddress, isFQDN, isHex, isHexColor, isIBAN, isInteger, isIP, isIPRange, isISSN, isJWT, isLowercase, isMACAddress, isMobilePhone, isNotEmpty, isNull, isNullish, isNumber, isObject, isObjectId, isPort, isString, isSWIFT, isUndefined, isUppercase, isURL, isUUID, isUUID1, isUUID2, isUUID3, isUUID4, isUUID5, toArray, toBigint, toBoolean, toDate, toDateString, toInteger, toNumber, toString, vg, };

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

@@ -5,7 +5,7 @@ import { validator } from '../../core/index.js';
  * @validator isAlpha
  */
 export function isAlpha(options) {
-    return validator('isLowercase', function (input, context, _this) {
+    return validator('isLowercase', (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isAlpha(input))
             return input;
         context.fail(_this, `"{{value}}" is not an alpha string`, input);
@@ -16,9 +16,10 @@ export function isAlpha(options) {
  * @validator isAlphanumeric
  */
 export function isAlphanumeric(options) {
-    return validator('isAlphanumeric', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isAlphanumeric(input))
+    return validator('isAlphanumeric', (input, context, _this) => {
+        if (typeof input === 'string' && validatorJS.isAlphanumeric(input)) {
             return input;
+        }
         context.fail(_this, `"{{value}}" is not an alphanumeric string`, input);
     }, options);
 }

package/esm/rules/format-rules/is-ascii.js

@@ -5,7 +5,7 @@ import { validator } from '../../core/index.js';
  * @validator isAscii
  */
 export function isAscii(options) {
-    return validator('isAscii', function (input, context, _this) {
+    return validator('isAscii', (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isAscii(input))
             return input;
         context.fail(_this, `Value is not an ascii string`, input);

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

@@ -5,9 +5,10 @@ import { validator } from '../../core/index.js';
  * @validator isBase64
  */
 export function isBase64(options) {
-    return validator('isBase64', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isBase64(input, options))
+    return validator('isBase64', (input, context, _this) => {
+        if (typeof input === 'string' && validatorJS.isBase64(input, options)) {
             return input;
+        }
         context.fail(_this, `"{{value}}" is not a valid a Base64 string`, input);
     }, options);
 }

package/esm/rules/format-rules/is-btc-address.js

@@ -5,9 +5,10 @@ import { validator } from '../../core/index.js';
  * @validator isBtcAddress
  */
 export function isBtcAddress(options) {
-    return validator('isBtcAddress', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isBtcAddress(input))
+    return validator('isBtcAddress', (input, context, _this) => {
+        if (typeof input === 'string' && validatorJS.isBtcAddress(input)) {
             return input;
+        }
         context.fail(_this, `Value is not a valid a BTC address`, input);
     }, options);
 }

package/esm/rules/format-rules/is-credit-card.js

@@ -5,9 +5,11 @@ import { validator } from '../../core/index.js';
  * @validator isCreditCard
  */
 export function isCreditCard(options) {
-    return validator('isCreditCard', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isCreditCard(input, options))
+    return validator('isCreditCard', (input, context, _this) => {
+        if (typeof input === 'string' &&
+            validatorJS.isCreditCard(input, options)) {
             return input;
+        }
         context.fail(_this, `"{{value}}" is not a valid Credit Card number`, input);
     }, options);
 }

package/esm/rules/format-rules/is-decimal.js

@@ -6,9 +6,10 @@ import { validator } from '../../core/index.js';
  * @validator isDecimal
  */
 export function isDecimal(options) {
-    return validator('isDecimal', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isDecimal(input))
+    return validator('isDecimal', (input, context, _this) => {
+        if (typeof input === 'string' && validatorJS.isDecimal(input)) {
             return input;
+        }
         context.fail(_this, `"{{value}}" is not an decimal number string`, input);
     }, options);
 }

package/esm/rules/format-rules/is-ean.js

@@ -5,7 +5,7 @@ import { validator } from '../../core/index.js';
  * @validator isEAN
  */
 export function isEAN(options) {
-    return validator('isEAN', function (input, context, _this) {
+    return validator('isEAN', (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isEAN(input))
             return input;
         context.fail(_this, `"{{value}}" is not a valid EAN (European Article Number)`, input);

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

@@ -15,8 +15,9 @@ export function isEmail(options) {
         // eslint-disable-next-line camelcase
         allow_ip_domain: options?.allowIpDomain,
     };
-    return validator('isEmail', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isEmail(input, emailOptions)) {
+    return validator('isEmail', (input, context, _this) => {
+        if (typeof input === 'string' &&
+            validatorJS.isEmail(input, emailOptions)) {
             if (options?.requireDisplayName) {
                 if (!validatorJS.isEmail(input, {
                     ...emailOptions,

package/esm/rules/format-rules/is-eth-address.js

@@ -5,9 +5,10 @@ import { validator } from '../../core/index.js';
  * @validator isETHAddress
  */
 export function isETHAddress(options) {
-    return validator('isETHAddress', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isEthereumAddress(input))
+    return validator('isETHAddress', (input, context, _this) => {
+        if (typeof input === 'string' && validatorJS.isEthereumAddress(input)) {
             return input;
+        }
         context.fail(_this, `Value is not a valid a ETH (Ethereum) address`, input);
     }, options);
 }

package/esm/rules/format-rules/is-fqdn.js

@@ -9,9 +9,10 @@ export function isFQDN(options) {
         // eslint-disable-next-line camelcase
         allow_wildcard: options?.allowWildcard,
     };
-    return validator('isFQDN', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isFQDN(input, opts))
+    return validator('isFQDN', (input, context, _this) => {
+        if (typeof input === 'string' && validatorJS.isFQDN(input, opts)) {
             return input;
+        }
         context.fail(_this, `"{{value}}" is not valid FQDN`, input);
     }, options);
 }

package/esm/rules/format-rules/is-hash.js

@@ -5,9 +5,10 @@ import { validator } from '../../core/index.js';
  * @validator isHash
  */
 export function isHash(algorithm, options) {
-    return validator('isHash', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isHash(input, algorithm))
+    return validator('isHash', (input, context, _this) => {
+        if (typeof input === 'string' && validatorJS.isHash(input, algorithm)) {
             return input;
+        }
         context.fail(_this, `Value is not a valid ${algorithm} hash`, input);
     }, options);
 }

package/esm/rules/format-rules/is-hex-color.js

@@ -5,9 +5,10 @@ import { validator } from '../../core/index.js';
  * @validator isHexColor
  */
 export function isHexColor(options) {
-    return validator('isHexColor', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isHexColor(input))
+    return validator('isHexColor', (input, context, _this) => {
+        if (typeof input === 'string' && validatorJS.isHexColor(input)) {
             return input;
+        }
         context.fail(_this, `{{label}} is not a valid Hex Color`, input);
     }, options);
 }

package/esm/rules/format-rules/is-hex.js

@@ -5,9 +5,10 @@ import { validator } from '../../core/index.js';
  * @validator isHex
  */
 export function isHex(options) {
-    return validator('isHex', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isHexadecimal(input))
+    return validator('isHex', (input, context, _this) => {
+        if (typeof input === 'string' && validatorJS.isHexadecimal(input)) {
             return input;
+        }
         context.fail(_this, `{{label}} is not an hexadecimal string`, input);
     }, options);
 }

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

@@ -5,7 +5,7 @@ import { validator } from '../../core/index.js';
  * @validator isIBAN
  */
 export function isIBAN(options) {
-    return validator('isIBAN', function (input, context, _this) {
+    return validator('isIBAN', (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isIBAN(input))
             return input;
         context.fail(_this, `{{label}} is not a valid IBAN (International Bank Account Number)`, input);
@@ -16,7 +16,7 @@ export function isIBAN(options) {
  * @validator isSWIFT
  */
 export function isSWIFT(options) {
-    return validator('isSWIFT', function (input, context, _this) {
+    return validator('isSWIFT', (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isBIC(input))
             return input;
         context.fail(_this, `{{label}}is not a valid a BIC (Bank Identification Code) or SWIFT code`, input);

package/esm/rules/format-rules/is-ip.js

@@ -5,9 +5,12 @@ import { validator } from '../../core/index.js';
  * @validator isIP
  */
 export function isIP(version, options) {
-    return validator('isIP', function (input, context, _this) {
-        if (input != null && typeof input === 'string' && validatorJS.isIP(input, version))
+    return validator('isIP', (input, context, _this) => {
+        if (input != null &&
+            typeof input === 'string' &&
+            validatorJS.isIP(input, version)) {
             return input;
+        }
         context.fail(_this, `"{{value}}" is not a valid IP${version ? ' v' + version : ''}`, input);
     }, options);
 }
@@ -16,9 +19,12 @@ export function isIP(version, options) {
  * @validator isIPRange
  */
 export function isIPRange(version, options) {
-    return validator('isIPRange', function (input, context, _this) {
-        if (input != null && typeof input === 'string' && validatorJS.isIPRange(input, version))
+    return validator('isIPRange', (input, context, _this) => {
+        if (input != null &&
+            typeof input === 'string' &&
+            validatorJS.isIPRange(input, version)) {
             return input;
+        }
         context.fail(_this, `"{{value}}" is not a valid IP${version ? ' v' + version : ''} range`, input);
     }, options);
 }

package/esm/rules/format-rules/is-issn.js

@@ -9,9 +9,10 @@ export function isISSN(options) {
         // eslint-disable-next-line camelcase
         case_sensitive: options?.caseSensitive,
     };
-    return validator('isISSN', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isISSN(input, opts))
+    return validator('isISSN', (input, context, _this) => {
+        if (typeof input === 'string' && validatorJS.isISSN(input, opts)) {
             return input;
+        }
         context.fail(_this, `"{{value}}" is not a valid ISSN`, input);
     }, options);
 }

package/esm/rules/format-rules/is-jwt.js

@@ -5,7 +5,7 @@ import { validator } from '../../core/index.js';
  * @validator isJWT
  */
 export function isJWT(options) {
-    return validator('isJWT', function (input, context, _this) {
+    return validator('isJWT', (input, context, _this) => {
         if (typeof input === 'string' && validatorJS.isJWT(input))
             return input;
         context.fail(_this, `Value is not a valid JWT token`, input);

package/esm/rules/format-rules/is-lowercase.js

@@ -5,9 +5,10 @@ import { validator } from '../../core/index.js';
  * @validator isLowercase
  */
 export function isLowercase(options) {
-    return validator('isLowercase', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isLowercase(input))
+    return validator('isLowercase', (input, context, _this) => {
+        if (typeof input === 'string' && validatorJS.isLowercase(input)) {
             return input;
+        }
         context.fail(_this, `"{{value}}" is not a lowercase string`, input);
     }, options);
 }
@@ -16,9 +17,10 @@ export function isLowercase(options) {
  * @validator isUppercase
  */
 export function isUppercase(options) {
-    return validator('isUppercase', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isUppercase(input))
+    return validator('isUppercase', (input, context, _this) => {
+        if (typeof input === 'string' && validatorJS.isUppercase(input)) {
             return input;
+        }
         context.fail(_this, `"{{value}}" is not an uppercase string`, input);
     }, options);
 }

package/esm/rules/format-rules/is-mac-address.js

@@ -10,9 +10,12 @@ export function isMACAddress(options) {
         no_separators: options?.noSeparators,
         eui: options?.eui,
     };
-    return validator('isMACAddress', function (input, context, _this) {
-        if (input != null && typeof input === 'string' && validatorJS.isMACAddress(input, opts))
+    return validator('isMACAddress', (input, context, _this) => {
+        if (input != null &&
+            typeof input === 'string' &&
+            validatorJS.isMACAddress(input, opts)) {
             return input;
+        }
         context.fail(_this, `{{label}} is not a valid MAC address`, input);
     }, options);
 }

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

@@ -8,9 +8,11 @@ export function isMobilePhone(options) {
     const opts = {
         strictMode: options?.strictMode,
     };
-    return validator('isMobilePhone', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isMobilePhone(input, options?.locale, opts))
+    return validator('isMobilePhone', (input, context, _this) => {
+        if (typeof input === 'string' &&
+            validatorJS.isMobilePhone(input, options?.locale, opts)) {
             return input;
+        }
         context.fail(_this, `"{{value}}" is not a valid a Mobile Phone Number`, input);
     }, options);
 }

package/esm/rules/format-rules/is-object-id.js

@@ -1,21 +1,24 @@
 import validatorJS from 'validator';
-import { validator } from '../../core/index.js';
+import { validator, } from '../../core/index.js';
 /**
  * Validates if value is an "ObjectId".
  * @validator isObjectId
  */
 export function isObjectId(options) {
-    return validator('isObjectId', function (input, context, _this) {
+    return validator('isObjectId', (input, context, _this) => {
         if (input != null &&
             (_isObjectIdValue(input) ||
                 (typeof input === 'object' &&
                     typeof input.toHexString === 'function' &&
-                    _isObjectIdValue(input.toHexString()))))
+                    _isObjectIdValue(input.toHexString())))) {
             return input;
+        }
         context.fail(_this, `"{{value}}" is not a valid ObjectId`, input);
     }, options);
 }
 function _isObjectIdValue(input) {
     return ((input instanceof Uint8Array && input.length === 12) ||
-        (typeof input === 'string' && input.length === 24 && validatorJS.isHexadecimal(input)));
+        (typeof input === 'string' &&
+            input.length === 24 &&
+            validatorJS.isHexadecimal(input)));
 }

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

@@ -5,9 +5,11 @@ import { validator } from '../../core/index.js';
  * @validator isPassportNumber
  */
 export function isPassportNumber(countryCode, options) {
-    return validator('isPassportNumber', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isPassportNumber(input, countryCode))
+    return validator('isPassportNumber', (input, context, _this) => {
+        if (typeof input === 'string' &&
+            validatorJS.isPassportNumber(input, countryCode)) {
             return input;
+        }
         context.fail(_this, `"{{value}}" is not a valid ${countryCode} PassportNumber)`, input);
     }, options);
 }

package/esm/rules/format-rules/is-port.js

@@ -5,9 +5,12 @@ import { validator } from '../../core/index.js';
  * @validator isPort
  */
 export function isPort(options) {
-    return validator('isPort', function (input, context, _this) {
-        if (input != null && typeof input === 'string' && validatorJS.isPort(input))
+    return validator('isPort', (input, context, _this) => {
+        if (input != null &&
+            typeof input === 'string' &&
+            validatorJS.isPort(input)) {
             return input;
+        }
         context.fail(_this, `{{label}} is not a valid port number`, input);
     }, options);
 }

package/esm/rules/format-rules/is-url.js

@@ -5,9 +5,12 @@ import { validator } from '../../core/index.js';
  * @validator isURL
  */
 export function isURL(options) {
-    return validator('isURL', function (input, context, _this) {
-        if (input != null && typeof input === 'string' && validatorJS.isURL(input, options))
+    return validator('isURL', (input, context, _this) => {
+        if (input != null &&
+            typeof input === 'string' &&
+            validatorJS.isURL(input, options)) {
             return input;
+        }
         context.fail(_this, `{{value}} is not a valid URL`, input);
     }, options);
 }

package/esm/rules/format-rules/is-uuid.js

@@ -5,9 +5,12 @@ import { validator } from '../../core/index.js';
  * @validator isUUID
  */
 export function isUUID(version, options) {
-    return validator('isUUID', function (input, context, _this) {
-        if (input != null && typeof input === 'string' && validatorJS.isUUID(input, version))
+    return validator('isUUID', (input, context, _this) => {
+        if (input != null &&
+            typeof input === 'string' &&
+            validatorJS.isUUID(input, version)) {
             return input;
+        }
         context.fail(_this, `{{label}} is not a valid UUID${version ? ' v' + version : ''}`, input);
     }, options);
 }

package/esm/rules/format-rules/is-vat-number.js

@@ -5,9 +5,10 @@ import { validator } from '../../core/index.js';
  * @validator isVAT
  */
 export function isVATNumber(countryCode, options) {
-    return validator('isVATNumber', function (input, context, _this) {
-        if (typeof input === 'string' && validatorJS.isVAT(input, countryCode))
+    return validator('isVATNumber', (input, context, _this) => {
+        if (typeof input === 'string' && validatorJS.isVAT(input, countryCode)) {
             return input;
+        }
         context.fail(_this, `"{{value}}" is not a valid VAT number`, input);
     }, options);
 }

package/esm/rules/format-rules/matches.js

@@ -1,4 +1,4 @@
-import { validator } from '../../core/index.js';
+import { validator, } from '../../core/index.js';
 /**
  * Coerces given value to "UUID" format or returns undefined if nullish
  * @validator uuid
@@ -6,7 +6,7 @@ import { validator } from '../../core/index.js';
 export function matches(format, options) {
     const regExp = format instanceof RegExp ? format : new RegExp(format);
     const formatName = options?.formatName;
-    return validator('matches', function (input, context, _this) {
+    return validator('matches', (input, context, _this) => {
         if (input == null)
             return;
         if (typeof input === 'string' && regExp.test(input))

package/esm/rules/index.js

@@ -1,16 +1,3 @@
-export * from './type-rules/is-any.js';
-export * from './type-rules/is-array.js';
-export * from './type-rules/is-bigint.js';
-export * from './type-rules/is-boolean.js';
-export * from './type-rules/is-date.js';
-export * from './type-rules/is-enum.js';
-export * from './type-rules/is-integer.js';
-export * from './type-rules/is-null.js';
-export * from './type-rules/is-number.js';
-export * from './type-rules/is-object.js';
-export * from './type-rules/is-record.js';
-export * from './type-rules/is-string.js';
-export * from './type-rules/is-tuple.js';
 export * from './format-rules/is-alpha.js';
 export * from './format-rules/is-ascii.js';
 export * from './format-rules/is-base64.js';
@@ -41,6 +28,20 @@ export * from './format-rules/matches.js';
 export * from './logical-rules/is-defined.js';
 export * from './logical-rules/is-empty.js';
 export * from './logical-rules/range.js';
+export * from './type-rules/is-any.js';
+export * from './type-rules/is-array.js';
+export * from './type-rules/is-bigint.js';
+export * from './type-rules/is-boolean.js';
+export * from './type-rules/is-date.js';
+export * from './type-rules/is-enum.js';
+export * from './type-rules/is-integer.js';
+export * from './type-rules/is-null.js';
+export * from './type-rules/is-number.js';
+export * from './type-rules/is-object.js';
+export * from './type-rules/is-record.js';
+export * from './type-rules/is-string.js';
+export * from './type-rules/is-tuple.js';
+export * from './type-rules/is-undefined.js';
 export * from './utility-rules/exists.js';
 export * from './utility-rules/get-length.js';
 export * from './utility-rules/optional.js';