@archi-code/validation 0.0.0-stage → 3.0.0-alpha.1

package/dist/cjs/validators/index.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validator = void 0;
+const equals_1 = require("./equals");
+const contains_1 = require("./contains");
+const matches_1 = require("./matches");
+const isEmail_1 = require("./isEmail");
+const isURL_1 = require("./isURL");
+const isMACAddress_1 = require("./isMACAddress");
+const isIP_1 = require("./isIP");
+const isIPRange_1 = require("./isIPRange");
+const isFQDN_1 = require("./isFQDN");
+const isDate_1 = require("./isDate");
+const isTime_1 = require("./isTime");
+const isBoolean_1 = require("./isBoolean");
+const isLocale_1 = require("./isLocale");
+const isAbaRouting_1 = require("./isAbaRouting");
+const isAlpha_1 = require("./isAlpha");
+const isAlphanumeric_1 = require("./isAlphanumeric");
+const isNumeric_1 = require("./isNumeric");
+const isPassportNumber_1 = require("./isPassportNumber");
+const isPort_1 = require("./isPort");
+const isLowercase_1 = require("./isLowercase");
+const isUppercase_1 = require("./isUppercase");
+const isIMEI_1 = require("./isIMEI");
+const isAscii_1 = require("./isAscii");
+const isFullWidth_1 = require("./isFullWidth");
+const isHalfWidth_1 = require("./isHalfWidth");
+const isVariableWidth_1 = require("./isVariableWidth");
+const isMultibyte_1 = require("./isMultibyte");
+const isSemVer_1 = require("./isSemVer");
+const isSurrogatePair_1 = require("./isSurrogatePair");
+const isInt_1 = require("./isInt");
+const isFloat_1 = require("./isFloat");
+const isDecimal_1 = require("./isDecimal");
+const isHexadecimal_1 = require("./isHexadecimal");
+const isOctal_1 = require("./isOctal");
+const isDivisibleBy_1 = require("./isDivisibleBy");
+const isHexColor_1 = require("./isHexColor");
+const isRgbColor_1 = require("./isRgbColor");
+const isHSL_1 = require("./isHSL");
+const isISRC_1 = require("./isISRC");
+const isIBAN_1 = require("./isIBAN");
+const isBIC_1 = require("./isBIC");
+const isMD5_1 = require("./isMD5");
+const isHash_1 = require("./isHash");
+const isJWT_1 = require("./isJWT");
+const isJSON_1 = require("./isJSON");
+const isEmpty_1 = require("./isEmpty");
+const isNotEmpty_1 = require("./isNotEmpty");
+const isRequired_1 = require("./isRequired");
+const isLength_1 = require("./isLength");
+const isByteLength_1 = require("./isByteLength");
+const isULID_1 = require("./isULID");
+const isUUID_1 = require("./isUUID");
+const isMongoId_1 = require("./isMongoId");
+const isAfter_1 = require("./isAfter");
+const isBefore_1 = require("./isBefore");
+const isIn_1 = require("./isIn");
+const isLuhnNumber_1 = require("./isLuhnNumber");
+const isCreditCard_1 = require("./isCreditCard");
+const isIdentityCard_1 = require("./isIdentityCard");
+const isEAN_1 = require("./isEAN");
+const isISIN_1 = require("./isISIN");
+const isISBN_1 = require("./isISBN");
+const isISSN_1 = require("./isISSN");
+const isMobilePhone_1 = require("./isMobilePhone");
+const isEthereumAddress_1 = require("./isEthereumAddress");
+const isCurrency_1 = require("./isCurrency");
+const isBtcAddress_1 = require("./isBtcAddress");
+const isISO6346_1 = require("./isISO6346");
+const isISO6391_1 = require("./isISO6391");
+const isISO8601_1 = require("./isISO8601");
+const isRFC3339_1 = require("./isRFC3339");
+const isISO15924_1 = require("./isISO15924");
+const isISO31661Alpha2_1 = require("./isISO31661Alpha2");
+const isISO31661Alpha3_1 = require("./isISO31661Alpha3");
+const isISO31661Numeric_1 = require("./isISO31661Numeric");
+const isISO4217_1 = require("./isISO4217");
+const isBase32_1 = require("./isBase32");
+const isBase58_1 = require("./isBase58");
+const isBase64_1 = require("./isBase64");
+const isDataURI_1 = require("./isDataURI");
+const isMagnetURI_1 = require("./isMagnetURI");
+const isMailtoURI_1 = require("./isMailtoURI");
+const isMimeType_1 = require("./isMimeType");
+const isLatLong_1 = require("./isLatLong");
+const isPostalCode_1 = require("./isPostalCode");
+const isWhitelisted_1 = require("./isWhitelisted");
+const isSlug_1 = require("./isSlug");
+const isLicensePlate_1 = require("./isLicensePlate");
+const isStrongPassword_1 = require("./isStrongPassword");
+const isVAT_1 = require("./isVAT");
+exports.validator = Object.freeze({
+    equals: equals_1.equals,
+    contains: contains_1.contains,
+    matches: matches_1.matches,
+    isEmail: isEmail_1.isEmail,
+    isURL: isURL_1.isURL,
+    isMACAddress: isMACAddress_1.isMACAddress,
+    isIP: isIP_1.isIP,
+    isIPRange: isIPRange_1.isIPRange,
+    isFQDN: isFQDN_1.isFQDN,
+    isBoolean: isBoolean_1.isBoolean,
+    isIBAN: isIBAN_1.isIBAN,
+    isBIC: isBIC_1.isBIC,
+    isAbaRouting: isAbaRouting_1.isAbaRouting,
+    isAlpha: isAlpha_1.isAlpha,
+    isAlphaLocales: isAlpha_1.locales,
+    isAlphanumeric: isAlphanumeric_1.isAlphanumeric,
+    isAlphanumericLocales: isAlphanumeric_1.locales,
+    isNumeric: isNumeric_1.isNumeric,
+    isPassportNumber: isPassportNumber_1.isPassportNumber,
+    passportNumberLocales: isPassportNumber_1.locales,
+    isPort: isPort_1.isPort,
+    isLowercase: isLowercase_1.isLowercase,
+    isUppercase: isUppercase_1.isUppercase,
+    isAscii: isAscii_1.isAscii,
+    isFullWidth: isFullWidth_1.isFullWidth,
+    isHalfWidth: isHalfWidth_1.isHalfWidth,
+    isVariableWidth: isVariableWidth_1.isVariableWidth,
+    isMultibyte: isMultibyte_1.isMultibyte,
+    isSemVer: isSemVer_1.isSemVer,
+    isSurrogatePair: isSurrogatePair_1.isSurrogatePair,
+    isInt: isInt_1.isInt,
+    isIMEI: isIMEI_1.isIMEI,
+    isFloat: isFloat_1.isFloat,
+    isFloatLocales: isFloat_1.locales,
+    isDecimal: isDecimal_1.isDecimal,
+    isHexadecimal: isHexadecimal_1.isHexadecimal,
+    isOctal: isOctal_1.isOctal,
+    isDivisibleBy: isDivisibleBy_1.isDivisibleBy,
+    isHexColor: isHexColor_1.isHexColor,
+    isRgbColor: isRgbColor_1.isRgbColor,
+    isHSL: isHSL_1.isHSL,
+    isISRC: isISRC_1.isISRC,
+    isMD5: isMD5_1.isMD5,
+    isHash: isHash_1.isHash,
+    isJWT: isJWT_1.isJWT,
+    isJSON: isJSON_1.isJSON,
+    isEmpty: isEmpty_1.isEmpty,
+    isNotEmpty: isNotEmpty_1.isNotEmpty,
+    isRequired: isRequired_1.isRequired,
+    isLength: isLength_1.isLength,
+    isLocale: isLocale_1.isLocale,
+    isByteLength: isByteLength_1.isByteLength,
+    isULID: isULID_1.isULID,
+    isUUID: isUUID_1.isUUID,
+    isMongoId: isMongoId_1.isMongoId,
+    isAfter: isAfter_1.isAfter,
+    isBefore: isBefore_1.isBefore,
+    isIn: isIn_1.isIn,
+    isLuhnNumber: isLuhnNumber_1.isLuhnNumber,
+    isCreditCard: isCreditCard_1.isCreditCard,
+    isIdentityCard: isIdentityCard_1.isIdentityCard,
+    isEAN: isEAN_1.isEAN,
+    isISIN: isISIN_1.isISIN,
+    isISBN: isISBN_1.isISBN,
+    isISSN: isISSN_1.isISSN,
+    isMobilePhone: isMobilePhone_1.isMobilePhone,
+    isMobilePhoneLocales: isMobilePhone_1.locales,
+    isPostalCode: isPostalCode_1.isPostalCode,
+    isPostalCodeLocales: isPostalCode_1.locales,
+    isEthereumAddress: isEthereumAddress_1.isEthereumAddress,
+    isCurrency: isCurrency_1.isCurrency,
+    isBtcAddress: isBtcAddress_1.isBtcAddress,
+    isISO6346: isISO6346_1.isISO6346,
+    isFreightContainerID: isISO6346_1.isFreightContainerID,
+    isISO6391: isISO6391_1.isISO6391,
+    isISO8601: isISO8601_1.isISO8601,
+    isISO15924: isISO15924_1.isISO15924,
+    isRFC3339: isRFC3339_1.isRFC3339,
+    isISO31661Alpha2: isISO31661Alpha2_1.isISO31661Alpha2,
+    isISO31661Alpha3: isISO31661Alpha3_1.isISO31661Alpha3,
+    isISO31661Numeric: isISO31661Numeric_1.isISO31661Numeric,
+    isISO4217: isISO4217_1.isISO4217,
+    isBase32: isBase32_1.isBase32,
+    isBase58: isBase58_1.isBase58,
+    isBase64: isBase64_1.isBase64,
+    isDataURI: isDataURI_1.isDataURI,
+    isMagnetURI: isMagnetURI_1.isMagnetURI,
+    isMailtoURI: isMailtoURI_1.isMailtoURI,
+    isMimeType: isMimeType_1.isMimeType,
+    isLatLong: isLatLong_1.isLatLong,
+    isWhitelisted: isWhitelisted_1.isWhitelisted,
+    isSlug: isSlug_1.isSlug,
+    isStrongPassword: isStrongPassword_1.isStrongPassword,
+    isDate: isDate_1.isDate,
+    isTime: isTime_1.isTime,
+    isLicensePlate: isLicensePlate_1.isLicensePlate,
+    isVAT: isVAT_1.isVAT,
+    ibanLocales: isIBAN_1.locales,
+});

package/dist/cjs/validators/isAbaRouting.d.ts

@@ -0,0 +1 @@
+export declare function isAbaRouting(value: unknown): boolean;

package/dist/cjs/validators/isAbaRouting.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbaRouting = isAbaRouting;
+const string_1 = require("../convert/string");
+const nineDigitsOutsideReservedSeries = /^(?!(1[3-9])|(20)|(3[3-9])|(4[0-9])|(5[0-9])|(60)|(7[3-9])|(8[1-9])|(9[0-2])|(9[3-9]))[0-9]{9}$/;
+function isAbaRouting(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    if (!nineDigitsOutsideReservedSeries.test(str))
+        return false;
+    let checkSumVal = 0;
+    for (let i = 0; i < str.length; i++) {
+        if (i % 3 === 0)
+            checkSumVal += Number(str[i]) * 3;
+        else if (i % 3 === 1)
+            checkSumVal += Number(str[i]) * 7;
+        else
+            checkSumVal += Number(str[i]);
+    }
+    return checkSumVal % 10 === 0;
+}

package/dist/cjs/validators/isAfter.d.ts

@@ -0,0 +1,4 @@
+export interface IsAfterOptions {
+    comparisonDate?: string;
+}
+export declare function isAfter(value: unknown, options?: IsAfterOptions): boolean;

package/dist/cjs/validators/isAfter.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAfter = isAfter;
+const date_1 = require("../convert/date");
+const config_1 = require("../helpers/config");
+function isAfter(value, options) {
+    const { comparisonDate } = (0, config_1.optionsOf)(options);
+    const comparison = comparisonDate
+        ? (0, date_1.toDate)(comparisonDate, { lax: true })
+        : { ok: true, value: new Date() };
+    const original = (0, date_1.toDate)(value, { lax: true });
+    if (!comparison.ok || !original.ok)
+        return false;
+    return original.value > comparison.value;
+}

package/dist/cjs/validators/isAlpha.d.ts

@@ -0,0 +1,8 @@
+import { alpha } from './alpha';
+export type AlphaLocale = keyof typeof alpha | (string & {});
+export interface IsAlphaOptions {
+    locale?: AlphaLocale;
+    ignore?: string | RegExp;
+}
+export declare function isAlpha(value: unknown, options?: IsAlphaOptions): boolean;
+export declare const locales: readonly string[];

package/dist/cjs/validators/isAlpha.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.locales = void 0;
+exports.isAlpha = isAlpha;
+const string_1 = require("../convert/string");
+const errors_1 = require("../helpers/errors");
+const hasOwn_1 = require("../helpers/hasOwn");
+const escapeRegExp_1 = require("../helpers/escapeRegExp");
+const alpha_1 = require("./alpha");
+const config_1 = require("../helpers/config");
+function isAlpha(value, options) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    let str = s;
+    const { locale = 'en-US', ignore } = (0, config_1.optionsOf)(options);
+    if (ignore) {
+        if (ignore instanceof RegExp) {
+            ignore.lastIndex = 0;
+            str = str.replace(ignore, '');
+        }
+        else if (typeof ignore === 'string') {
+            str = str.replace(new RegExp(`[${(0, escapeRegExp_1.escapeRegExp)(ignore)}]`, 'g'), '');
+        }
+        else {
+            throw new errors_1.ValidationConfigError('ignore should be instance of a String or RegExp');
+        }
+    }
+    if ((0, hasOwn_1.hasOwn)(alpha_1.alpha, locale)) {
+        return alpha_1.alpha[locale].test(str);
+    }
+    throw new errors_1.ValidationConfigError(`Invalid locale '${(0, config_1.configText)(locale)}'`);
+}
+exports.locales = Object.freeze(Object.keys(alpha_1.alpha));

package/dist/cjs/validators/isAlphanumeric.d.ts

@@ -0,0 +1,8 @@
+import { alphanumeric } from './alpha';
+export type AlphanumericLocale = keyof typeof alphanumeric | (string & {});
+export interface IsAlphanumericOptions {
+    locale?: AlphanumericLocale;
+    ignore?: string | RegExp;
+}
+export declare function isAlphanumeric(value: unknown, options?: IsAlphanumericOptions): boolean;
+export declare const locales: readonly string[];

package/dist/cjs/validators/isAlphanumeric.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.locales = void 0;
+exports.isAlphanumeric = isAlphanumeric;
+const string_1 = require("../convert/string");
+const errors_1 = require("../helpers/errors");
+const hasOwn_1 = require("../helpers/hasOwn");
+const escapeRegExp_1 = require("../helpers/escapeRegExp");
+const alpha_1 = require("./alpha");
+const config_1 = require("../helpers/config");
+function isAlphanumeric(value, options) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    let str = s;
+    const { locale = 'en-US', ignore } = (0, config_1.optionsOf)(options);
+    if (ignore) {
+        if (ignore instanceof RegExp) {
+            ignore.lastIndex = 0;
+            str = str.replace(ignore, '');
+        }
+        else if (typeof ignore === 'string') {
+            str = str.replace(new RegExp(`[${(0, escapeRegExp_1.escapeRegExp)(ignore)}]`, 'g'), '');
+        }
+        else {
+            throw new errors_1.ValidationConfigError('ignore should be instance of a String or RegExp');
+        }
+    }
+    if ((0, hasOwn_1.hasOwn)(alpha_1.alphanumeric, locale)) {
+        return alpha_1.alphanumeric[locale].test(str);
+    }
+    throw new errors_1.ValidationConfigError(`Invalid locale '${(0, config_1.configText)(locale)}'`);
+}
+exports.locales = Object.freeze(Object.keys(alpha_1.alphanumeric));

package/dist/cjs/validators/isAscii.d.ts

@@ -0,0 +1 @@
+export declare function isAscii(value: unknown): boolean;

package/dist/cjs/validators/isAscii.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAscii = isAscii;
+const string_1 = require("../convert/string");
+const ascii = /^[\x00-\x7F]+$/;
+function isAscii(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return ascii.test(str);
+}

package/dist/cjs/validators/isBIC.d.ts

@@ -0,0 +1 @@
+export declare function isBIC(value: unknown): boolean;

package/dist/cjs/validators/isBIC.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBIC = isBIC;
+const string_1 = require("../convert/string");
+const isISO31661Alpha2_1 = require("./isISO31661Alpha2");
+const isBICReg = /^[A-Za-z]{6}[A-Za-z0-9]{2}([A-Za-z0-9]{3})?$/;
+function isBIC(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    const countryCode = str.slice(4, 6).toUpperCase();
+    if (!isISO31661Alpha2_1.CountryCodes.has(countryCode) && countryCode !== 'XK') {
+        return false;
+    }
+    return isBICReg.test(str);
+}

package/dist/cjs/validators/isBase32.d.ts

@@ -0,0 +1,4 @@
+export interface IsBase32Options {
+    crockford?: boolean;
+}
+export declare function isBase32(value: unknown, options?: IsBase32Options): boolean;

package/dist/cjs/validators/isBase32.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBase32 = isBase32;
+const string_1 = require("../convert/string");
+const merge_1 = require("../helpers/merge");
+const base32 = /^[A-Z2-7]+=*$/;
+const crockfordBase32 = /^[A-HJKMNP-TV-Z0-9]+$/;
+const defaultBase32Options = {
+    crockford: false,
+};
+function isBase32(value, options) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    options = (0, merge_1.merge)(options, defaultBase32Options);
+    if (options.crockford) {
+        return crockfordBase32.test(s);
+    }
+    return s.length % 8 === 0 && base32.test(s);
+}

package/dist/cjs/validators/isBase58.d.ts

@@ -0,0 +1 @@
+export declare function isBase58(value: unknown): boolean;

package/dist/cjs/validators/isBase58.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBase58 = isBase58;
+const string_1 = require("../convert/string");
+const base58Reg = /^[A-HJ-NP-Za-km-z1-9]*$/;
+function isBase58(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return base58Reg.test(str);
+}

package/dist/cjs/validators/isBase64.d.ts

@@ -0,0 +1,5 @@
+export interface IsBase64Options {
+    urlSafe?: boolean;
+    padding?: boolean;
+}
+export declare function isBase64(value: unknown, options?: IsBase64Options): boolean;

package/dist/cjs/validators/isBase64.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBase64 = isBase64;
+const string_1 = require("../convert/string");
+const merge_1 = require("../helpers/merge");
+const base64WithPadding = /^[A-Za-z0-9+/]+={0,2}$/;
+const base64WithoutPadding = /^[A-Za-z0-9+/]+$/;
+const base64UrlWithPadding = /^[A-Za-z0-9_-]+={0,2}$/;
+const base64UrlWithoutPadding = /^[A-Za-z0-9_-]+$/;
+function isBase64(value, options) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    options = (0, merge_1.merge)(options, { urlSafe: false, padding: !options?.urlSafe });
+    if (s === '')
+        return true;
+    if (options.padding && s.length % 4 !== 0)
+        return false;
+    let regex;
+    if (options.urlSafe) {
+        regex = options.padding ? base64UrlWithPadding : base64UrlWithoutPadding;
+    }
+    else {
+        regex = options.padding ? base64WithPadding : base64WithoutPadding;
+    }
+    return (!options.padding || s.length % 4 === 0) && regex.test(s);
+}

package/dist/cjs/validators/isBefore.d.ts

@@ -0,0 +1,4 @@
+export interface IsBeforeOptions {
+    comparisonDate?: string;
+}
+export declare function isBefore(value: unknown, options?: IsBeforeOptions): boolean;

package/dist/cjs/validators/isBefore.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBefore = isBefore;
+const date_1 = require("../convert/date");
+const config_1 = require("../helpers/config");
+function isBefore(value, options) {
+    const { comparisonDate } = (0, config_1.optionsOf)(options);
+    const comparison = comparisonDate
+        ? (0, date_1.toDate)(comparisonDate, { lax: true })
+        : { ok: true, value: new Date() };
+    const original = (0, date_1.toDate)(value, { lax: true });
+    if (!comparison.ok || !original.ok)
+        return false;
+    return original.value < comparison.value;
+}

package/dist/cjs/validators/isBoolean.d.ts

@@ -0,0 +1,4 @@
+export interface IsBooleanOptions {
+    loose?: boolean;
+}
+export declare function isBoolean(value: unknown, options?: IsBooleanOptions): boolean;

package/dist/cjs/validators/isBoolean.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBoolean = isBoolean;
+const boolean_1 = require("../convert/boolean");
+function isBoolean(value, options) {
+    return (0, boolean_1.toBoolean)(value, { mode: options?.loose ? 'loose' : 'strict' }).ok;
+}

package/dist/cjs/validators/isBtcAddress.d.ts

@@ -0,0 +1 @@
+export declare function isBtcAddress(value: unknown): boolean;

package/dist/cjs/validators/isBtcAddress.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBtcAddress = isBtcAddress;
+const string_1 = require("../convert/string");
+const bech32 = /^(bc1|tb1|bc1p|tb1p)[ac-hj-np-z02-9]{39,58}$/;
+const base58 = /^(1|2|3|m)[A-HJ-NP-Za-km-z1-9]{25,39}$/;
+function isBtcAddress(value) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return bech32.test(str) || base58.test(str);
+}

package/dist/cjs/validators/isByteLength.d.ts

@@ -0,0 +1,5 @@
+export interface IsByteLengthOptions {
+    min?: number;
+    max?: number;
+}
+export declare function isByteLength(value: unknown, options?: IsByteLengthOptions): boolean;

package/dist/cjs/validators/isByteLength.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isByteLength = isByteLength;
+const string_1 = require("../convert/string");
+const config_1 = require("../helpers/config");
+function isByteLength(value, options) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const { min, max } = (0, config_1.boundsOf)(options);
+    const len = utf8ByteLength(s);
+    return len >= min && (typeof max === 'undefined' || len <= max);
+}
+function utf8ByteLength(s) {
+    let bytes = 0;
+    for (let i = 0; i < s.length; i++) {
+        const code = s.charCodeAt(i);
+        if (code < 0x80)
+            bytes += 1;
+        else if (code < 0x800)
+            bytes += 2;
+        else if (code >= 0xd800 && code <= 0xdbff && i + 1 < s.length) {
+            const next = s.charCodeAt(i + 1);
+            if (next >= 0xdc00 && next <= 0xdfff) {
+                bytes += 4;
+                i++;
+            }
+            else
+                bytes += 3;
+        }
+        else
+            bytes += 3;
+    }
+    return bytes;
+}

package/dist/cjs/validators/isCreditCard.d.ts

@@ -0,0 +1,15 @@
+declare const cards: {
+    amex: RegExp;
+    dinersclub: RegExp;
+    discover: RegExp;
+    jcb: RegExp;
+    mastercard: RegExp;
+    unionpay: RegExp;
+    visa: RegExp;
+};
+export type CreditCardProvider = keyof typeof cards | (string & {});
+export interface IsCreditCardOptions {
+    provider?: CreditCardProvider;
+}
+export declare function isCreditCard(value: unknown, options?: IsCreditCardOptions): boolean;
+export {};

package/dist/cjs/validators/isCreditCard.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isCreditCard = isCreditCard;
+const string_1 = require("../convert/string");
+const errors_1 = require("../helpers/errors");
+const hasOwn_1 = require("../helpers/hasOwn");
+const isLuhnNumber_1 = require("./isLuhnNumber");
+const config_1 = require("../helpers/config");
+const cards = {
+    amex: /^3[47][0-9]{13}$/,
+    dinersclub: /^3(?:0[0-5]|[68][0-9])[0-9]{11}$/,
+    discover: /^6(?:011|5[0-9][0-9])[0-9]{12,15}$/,
+    jcb: /^(?:2131|1800|35\d{3})\d{11}$/,
+    mastercard: /^(?:5[1-5][0-9]{2}|222[1-9]|22[3-9][0-9]|2[3-6][0-9]{2}|27[01][0-9]|2720)[0-9]{12}$/,
+    unionpay: /^(6[27][0-9]{14}|^(81[0-9]{14,17}))$/,
+    visa: /^(?:4[0-9]{12})(?:[0-9]{3,6})?$/,
+};
+const allCards = (() => {
+    const tmpCardsArray = [];
+    for (const cardProvider in cards) {
+        if (Object.prototype.hasOwnProperty.call(cards, cardProvider)) {
+            tmpCardsArray.push(cards[cardProvider]);
+        }
+    }
+    return tmpCardsArray;
+})();
+function isCreditCard(value, options) {
+    const stringResult = (0, string_1.toString)(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const card = s;
+    const { provider } = (0, config_1.optionsOf)(options);
+    const sanitized = card.replace(/[- ]+/g, '');
+    if (provider !== undefined && typeof provider !== 'string') {
+        throw new errors_1.ValidationConfigError('provider must be a string');
+    }
+    if (provider && (0, hasOwn_1.hasOwn)(cards, provider.toLowerCase())) {
+        if (!cards[provider.toLowerCase()].test(sanitized)) {
+            return false;
+        }
+    }
+    else if (provider) {
+        throw new errors_1.ValidationConfigError(`${(0, config_1.configText)(provider)} is not a valid credit card provider.`);
+    }
+    else if (!allCards.some((cardProvider) => cardProvider.test(sanitized))) {
+        return false;
+    }
+    return (0, isLuhnNumber_1.isLuhnNumber)(card);
+}

package/dist/cjs/validators/isCurrency.d.ts

@@ -0,0 +1,18 @@
+export interface IsCurrencyOptions {
+    symbol?: string;
+    require_symbol?: boolean;
+    allow_space_after_symbol?: boolean;
+    symbol_after_digits?: boolean;
+    allow_negatives?: boolean;
+    parens_for_negatives?: boolean;
+    negative_sign_before_digits?: boolean;
+    negative_sign_after_digits?: boolean;
+    allow_negative_sign_placeholder?: boolean;
+    thousands_separator?: string;
+    decimal_separator?: string;
+    allow_decimal?: boolean;
+    require_decimal?: boolean;
+    digits_after_decimal?: number[];
+    allow_space_after_digits?: boolean;
+}
+export declare function isCurrency(value: unknown, options?: IsCurrencyOptions): boolean;