valgen 5.2.2 → 5.3.1

package/cjs/rules/{is-object.js → type-rules/is-object.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isObject = void 0;
-const constants_js_1 = require("../constants.js");
-const index_js_1 = require("../core/index.js");
+const constants_js_1 = require("../../constants.js");
+const index_js_1 = require("../../core/index.js");
 /**
  * Validates object according to schema
  * Converts properties according to schema rules if coerce option is set to 'true'.
@@ -37,7 +37,8 @@ function isObject(schema, options) {
     const _rule = (0, index_js_1.validator)('isObject', function (input, context, _this) {
         if (ctor && ctor[constants_js_1.preValidation])
             input = ctor[constants_js_1.preValidation](input, context, _this);
-        if (typeof input === 'string' && context.coerce)
+        const coerce = options?.coerce || context.coerce;
+        if (typeof input === 'string' && coerce)
             input = JSON.parse(input);
         if (!(input && typeof input === 'object')) {
             context.fail(_this, `{{label}} must be an object`, input);
@@ -68,8 +69,7 @@ function isObject(schema, options) {
             inputKey = keys[i];
             schemaKey = caseInSensitive ? inputKey.toLowerCase() : inputKey;
             v = input[inputKey];
-            _propRule = propertyRules[schemaKey] ||
-                ((0, index_js_1.isValidator)(additionalFields) ? additionalFields : undefined);
+            _propRule = propertyRules[schemaKey] || ((0, index_js_1.isValidator)(additionalFields) ? additionalFields : undefined);
             if (_propRule) {
                 if (processedSchemaKeys[schemaKey])
                     continue;

package/cjs/rules/{is-record.js → type-rules/is-record.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isRecord = void 0;
-const index_js_1 = require("../core/index.js");
+const index_js_1 = require("../../core/index.js");
 /**
  * Validates record object according to given "key" and "value" rules
  * Converts properties according to rules if coerce option is set to 'true'.

package/cjs/rules/{is-string.js → type-rules/is-string.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.trimStart = exports.trimEnd = exports.trim = exports.stringSplit = exports.stringReplace = exports.isString = void 0;
-const index_js_1 = require("../core/index.js");
+const index_js_1 = require("../../core/index.js");
 /**
  * Validates if value is "string".
  * Converts input value to string if coerce option is set to 'true'.
@@ -9,7 +9,8 @@ const index_js_1 = require("../core/index.js");
  */
 function isString(options) {
     return (0, index_js_1.validator)('isString', function (input, context, _this) {
-        if (input != null && typeof input !== 'string' && context.coerce) {
+        const coerce = options?.coerce || context.coerce;
+        if (input != null && typeof input !== 'string' && coerce) {
             if (typeof input === 'object') {
                 if (typeof input.toJSON === 'function')
                     input = input.toJSON();

package/cjs/rules/{is-tuple.js → type-rules/is-tuple.js}

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTuple = void 0;
-const index_js_1 = require("../core/index.js");
+const index_js_1 = require("../../core/index.js");
 function isTuple(items, options) {
     return (0, index_js_1.validator)('isTuple', function (input, context, _this) {
-        if (input != null && context.coerce && !Array.isArray(input))
+        const coerce = options?.coerce || context.coerce;
+        if (input != null && coerce && !Array.isArray(input))
             input = [input];
         if (!Array.isArray(input)) {
-            context.fail(_this, `{{label}} must be a tuple`, input);
+            context.fail(_this, `"{{value}}" is not a valid tuple`, input);
             return;
         }
         const location = context.location || '';
@@ -24,8 +25,7 @@ function isTuple(items, options) {
             itemContext.label = context.label ? context.label + `[${i}]` : undefined;
             itemContext.index = i;
             itemContext.location = location + '[' + i + ']';
-            itemContext.label = (itemContext.label || itemContext.property || 'Value at ') +
-                `[${i}]`;
+            itemContext.label = (itemContext.label || itemContext.property || 'Value at ') + `[${i}]`;
             v = itemRule(input[i], itemContext);
             out.push(v);
         }

package/cjs/rules/utility-rules/exists.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exists = void 0;
+const index_js_1 = require("../../core/index.js");
+/**
+ * Validates if property exists
+ * @validator exists
+ */
+function exists(options) {
+    return (0, index_js_1.validator)('exists', function (input, context, _this) {
+        if (input !== undefined || (context.scope && Object.getOwnPropertyDescriptor(context.scope, input)))
+            return input;
+        context.fail(_this, `{{label}} must exist`, input);
+    }, options);
+}
+exports.exists = exists;

package/cjs/rules/utility-rules/get-length.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLength = void 0;
+const index_js_1 = require("../../core/index.js");
+/**
+ * Returns length of an Array, String, ArrayBuffer, Buffer or any object with the "length" property.
+ * @validator getLength
+ */
+function getLength() {
+    return (0, index_js_1.validator)('getLength', function (input, context, _this) {
+        if (typeof input === 'string')
+            return input.length;
+        if (Array.isArray(input))
+            return input.length;
+        if (input instanceof ArrayBuffer)
+            return input.byteLength;
+        if (input && typeof input === 'object' && typeof input.length === 'number')
+            return input.length;
+        if (input && typeof input === 'object' && typeof input.size === 'number')
+            return input.size;
+        context.fail(_this, `Unable to get length of {{label}}`, input);
+    });
+}
+exports.getLength = getLength;

package/cjs/rules/utility-rules/optional.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optional = void 0;
+const index_js_1 = require("../../core/index.js");
+/**
+ * Makes sub-rule optional
+ * @validator optional
+ */
+function optional(nested, options) {
+    return (0, index_js_1.validator)('optional', function (input, context) {
+        if (input == null)
+            return input;
+        return nested(input, context);
+    }, options);
+}
+exports.optional = optional;

package/cjs/rules/{pipe.js → utility-rules/pipe.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.allOf = exports.pipe = void 0;
-const index_js_1 = require("../core/index.js");
+const index_js_1 = require("../../core/index.js");
 /**
  *
  * @validator pipe

package/cjs/rules/utility-rules/required.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.required = void 0;
+const index_js_1 = require("../../core/index.js");
+/**
+ * Makes sub-rule required
+ * @validator required
+ */
+function required(nested, options) {
+    return (0, index_js_1.validator)('required', function (input, context, _this) {
+        if (input == null) {
+            context.fail(_this, `{{label}} is required`, input);
+            return;
+        }
+        return nested(input, context);
+    }, options);
+}
+exports.required = required;

package/cjs/rules/{union.js → utility-rules/union.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.union = void 0;
-const index_js_1 = require("../core/index.js");
+const index_js_1 = require("../../core/index.js");
 /**
  *
  */
@@ -13,7 +13,7 @@ function union(codecs) {
         let v;
         let passed = false;
         // Mock fail method to prevent errors
-        context.fail = () => passed = false;
+        context.fail = () => (passed = false);
         for (i = 0; i < l; i++) {
             c = codecs[i];
             try {
@@ -30,7 +30,7 @@ function union(codecs) {
         delete context.fail;
         if (passed)
             return v;
-        context.fail(_this, `{{location}} didn't match any of required format`, input);
+        context.fail(_this, `Value didn't match any on union rules`, input);
     });
 }
 exports.union = union;

package/esm/core/context.js

@@ -19,7 +19,7 @@ export class Context {
             index: this.index,
             label: this.label,
             value,
-            ...details
+            ...details,
         });
         issue.value = value;
         const onFail = this.onFail || rule[kOptions].onFail;
@@ -34,14 +34,17 @@ export class Context {
             else
                 issue.message = String(x);
         }
-        issue.message = ('' + issue.message)
-            .replace(VARIABLE_REPLACE_PATTERN, (x, g) => {
+        issue.message = ('' + issue.message).replace(VARIABLE_REPLACE_PATTERN, (x, g) => {
             const m = OPTIONAL_VAR_PATTERN.exec(g);
             if (!m)
                 return x;
             const k = m[1];
             let v = issue[k];
-            if (!v && m[1] === 'label' && (this.location || this.property))
+            if (k === 'value') {
+                const s = String(issue.value);
+                return s.length < 30 ? s : s.substring(0, 30) + '..';
+            }
+            if (!v && k === 'label' && (this.location || this.property))
                 v = '`' + (this.location || this.property) + '`';
             if (v != null)
                 return v;

package/esm/core/validator.js

@@ -19,10 +19,10 @@ export function validator(arg0, arg1, arg2) {
         throw new TypeError('You must provide a rule function argument');
     id = id || fn.name || 'unnamed-rule';
     const name = fn.name || camelCase(id);
-    const _rule = ({
+    const _rule = {
         [name](input, options) {
             const ctx = options instanceof Context ? options : undefined;
-            const opts = (ctx ? undefined : options);
+            const opts = ctx ? undefined : options;
             const context = ctx || new Context(opts);
             let value;
             try {
@@ -36,8 +36,8 @@ export function validator(arg0, arg1, arg2) {
             if (!ctx && context.errors.length)
                 throw new ValidationError(context.errors);
             return value;
-        }
-    })[name];
+        },
+    }[name];
     _rule.id = id;
     _rule[kValidatorFn] = fn;
     _rule[kOptions] = validatorOptions || {};

package/esm/index.js

@@ -32,7 +32,7 @@ const isMACAddress = vg.isMACAddress();
 const isPort = vg.isPort();
 const isURL = vg.isURL();
 const isBase64 = vg.isBase64();
-const isBIC = vg.isBIC();
+const isSWIFT = vg.isSWIFT();
 const isCreditCard = vg.isCreditCard();
 const isIBAN = vg.isIBAN();
 const isEAN = vg.isEAN();
@@ -48,5 +48,12 @@ const isAlpha = vg.isAlpha();
 const isAlphanumeric = vg.isAlphanumeric();
 const isAscii = vg.isAscii();
 const isDecimal = vg.isDecimal();
-const isHexadecimal = vg.isHexadecimal();
-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, isBIC, isCreditCard, isIBAN, isEAN, isFQDN, isISSN, isBtcAddress, isETHAddress, isHexColor, isJWT, isLowercase, isUppercase, isAlpha, isAlphanumeric, isAscii, isDecimal, isHexadecimal };
+const isHex = vg.isHex();
+const toArray = vg.isArray(isAny, { coerce: true });
+const toBoolean = vg.isBoolean({ coerce: true });
+const toDate = vg.isDate({ coerce: true });
+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, toDate, toDateString, toInteger, toNumber, toString, };

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

@@ -0,0 +1,24 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Check if the string contains only letters (a-zA-Z).
+ * @validator isAlpha
+ */
+export function isAlpha(options) {
+    return validator('isLowercase', function (input, context, _this) {
+        if (typeof input === 'string' && validatorJS.isAlpha(input))
+            return input;
+        context.fail(_this, `"{{value}}" is not an alpha string`, input);
+    }, options);
+}
+/**
+ * Check if the string contains only letters and numbers.
+ * @validator isAlphanumeric
+ */
+export function isAlphanumeric(options) {
+    return validator('isAlphanumeric', function (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

@@ -0,0 +1,13 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Check if the string contains ASCII chars only.
+ * @validator isAscii
+ */
+export function isAscii(options) {
+    return validator('isAscii', function (input, context, _this) {
+        if (typeof input === 'string' && validatorJS.isAscii(input))
+            return input;
+        context.fail(_this, `Value is not an ascii string`, input);
+    }, options);
+}

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

@@ -0,0 +1,13 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is a "Base64" string.
+ * @validator isBase64
+ */
+export function isBase64(options) {
+    return validator('isBase64', function (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

@@ -0,0 +1,13 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is a BTC address.
+ * @validator isBtcAddress
+ */
+export function isBtcAddress(options) {
+    return validator('isBtcAddress', function (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

@@ -0,0 +1,13 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is a credit card number
+ * @validator isCreditCard
+ */
+export function isCreditCard(options) {
+    return validator('isCreditCard', function (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

@@ -0,0 +1,14 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Check if the string represents a decimal number,
+ * such as `0.1`, `.3`, `1.1`, `1.00003`, `4.0` etc.
+ * @validator isDecimal
+ */
+export function isDecimal(options) {
+    return validator('isDecimal', function (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

@@ -0,0 +1,13 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is an EAN (European Article Number)
+ * @validator isEAN
+ */
+export function isEAN(options) {
+    return validator('isEAN', function (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);
+    }, options);
+}

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

@@ -0,0 +1,70 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is a valid Email
+ * @validator isEmail
+ */
+export function isEmail(options) {
+    const emailOptions = {
+        // eslint-disable-next-line camelcase
+        allow_display_name: true,
+        // eslint-disable-next-line camelcase
+        allow_utf8_local_part: options?.utf8LocalPart,
+        // eslint-disable-next-line camelcase
+        ignore_max_length: true,
+        // 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)) {
+            if (options?.requireDisplayName) {
+                if (!validatorJS.isEmail(input, {
+                    ...emailOptions,
+                    // eslint-disable-next-line camelcase
+                    require_display_name: true,
+                })) {
+                    context.fail(_this, `Display name for the email is required. Etc. ( Name <me@tempuri.org> ) `, input);
+                    return;
+                }
+            }
+            else if (!options?.allowDisplayName &&
+                !validatorJS.isEmail(input, {
+                    ...emailOptions,
+                    // eslint-disable-next-line camelcase
+                    allow_display_name: false,
+                })) {
+                context.fail(_this, `Display name in email is not allowed`, input);
+                return;
+            }
+            if (options?.hostBlacklist &&
+                !validatorJS.isEmail(input, {
+                    ...emailOptions,
+                    // eslint-disable-next-line camelcase
+                    host_blacklist: options.hostBlacklist,
+                })) {
+                context.fail(_this, `Email "{{value}}" is in black-list`, input);
+                return;
+            }
+            if (options?.hostWhitelist &&
+                !validatorJS.isEmail(input, {
+                    ...emailOptions,
+                    // eslint-disable-next-line camelcase
+                    host_whitelist: options.hostWhitelist,
+                })) {
+                context.fail(_this, `Email "{{value}}" is in not white-list`, input);
+                return;
+            }
+            if (options?.blacklistedChars &&
+                !validatorJS.isEmail(input, {
+                    ...emailOptions,
+                    // eslint-disable-next-line camelcase
+                    blacklisted_chars: options.blacklistedChars,
+                })) {
+                context.fail(_this, `Black listed characters (${options.blacklistedChars}) found in name part`, input);
+                return;
+            }
+            return input;
+        }
+        context.fail(_this, `"{{value}}" does not match required e-mail format`, input);
+    }, options);
+}

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

@@ -0,0 +1,13 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is a ETH (Ethereum) address.
+ * @validator isETHAddress
+ */
+export function isETHAddress(options) {
+    return validator('isETHAddress', function (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

@@ -0,0 +1,17 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is an FQDN
+ * @validator isFQDN
+ */
+export function isFQDN(options) {
+    const opts = {
+        // 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 input;
+        context.fail(_this, `"{{value}}" is not valid FQDN`, input);
+    }, options);
+}

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

@@ -0,0 +1,13 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value a hash of type algorithm
+ * @validator isHash
+ */
+export function isHash(algorithm, options) {
+    return validator('isHash', function (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

@@ -0,0 +1,13 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is a Hex Color
+ * @validator isHexColor
+ */
+export function isHexColor(options) {
+    return validator('isHexColor', function (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

@@ -0,0 +1,13 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Check if the string is a hexadecimal number.
+ * @validator isHex
+ */
+export function isHex(options) {
+    return validator('isHex', function (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

@@ -0,0 +1,24 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is an IBAN (International Bank Account Number)
+ * @validator isIBAN
+ */
+export function isIBAN(options) {
+    return validator('isIBAN', function (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);
+    }, options);
+}
+/**
+ * Validates if value is a BIC (Bank Identification Code) or SWIFT code
+ * @validator isSWIFT
+ */
+export function isSWIFT(options) {
+    return validator('isSWIFT', function (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);
+    }, options);
+}

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

@@ -0,0 +1,24 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is an IP
+ * @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 input;
+        context.fail(_this, `"{{value}}" is not a valid IP${version ? ' v' + version : ''}`, input);
+    }, options);
+}
+/**
+ * Validates if value is an IP
+ * @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 input;
+        context.fail(_this, `"{{value}}" is not a valid IP${version ? ' v' + version : ''} range`, input);
+    }, options);
+}

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

@@ -0,0 +1,17 @@
+import * as validatorJS from 'validator';
+import { validator } from '../../core/index.js';
+/**
+ * Validates if value is an ISSN
+ * @validator isISSN
+ */
+export function isISSN(options) {
+    const opts = {
+        // 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 input;
+        context.fail(_this, `"{{value}}" is not a valid ISSN`, input);
+    }, options);
+}

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

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