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

package/dist/esm/validators/isMongoId.js

@@ -0,0 +1,8 @@
+import { toString } from '../convert/string.js';
+const mongoId = /^[0-9a-fA-F]{24}$/;
+export function isMongoId(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    return mongoId.test(stringResult.value);
+}

package/dist/esm/validators/isMultibyte.d.ts

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

package/dist/esm/validators/isMultibyte.js

@@ -0,0 +1,10 @@
+import { toString } from '../convert/string.js';
+const multibyte = /[^\x00-\x7F]/;
+export function isMultibyte(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return multibyte.test(str);
+}

package/dist/esm/validators/isNotEmpty.d.ts

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

package/dist/esm/validators/isNotEmpty.js

@@ -0,0 +1,7 @@
+import { toString } from '../convert/string.js';
+export function isNotEmpty(value) {
+    if (typeof value === 'boolean')
+        return false;
+    const text = toString(value);
+    return text.ok && text.value.trim() !== '';
+}

package/dist/esm/validators/isNumeric.d.ts

@@ -0,0 +1,5 @@
+export interface IsNumericOptions {
+    no_symbols?: boolean;
+    locale?: string;
+}
+export declare function isNumeric(value: unknown, options?: IsNumericOptions): boolean;

package/dist/esm/validators/isNumeric.js

@@ -0,0 +1,31 @@
+import { toString } from '../convert/string.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+import { hasOwn } from '../helpers/hasOwn.js';
+import { decimal } from './alpha.js';
+import { configText } from '../helpers/config.js';
+const numericNoSymbols = /^[0-9]+$/;
+const numericRegexCache = new Map();
+function getNumericRegex(separator) {
+    let re = numericRegexCache.get(separator);
+    if (re === undefined) {
+        re = new RegExp(`^[+-]?([0-9]*[${separator}])?[0-9]+$`);
+        numericRegexCache.set(separator, re);
+    }
+    return re;
+}
+export function isNumeric(value, options) {
+    let separator = '.';
+    if (options?.locale) {
+        if (!hasOwn(decimal, options.locale))
+            throw new ValidationConfigError(`Invalid locale '${configText(options.locale)}'`);
+        separator = decimal[options.locale];
+    }
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    if (options?.no_symbols) {
+        return numericNoSymbols.test(s);
+    }
+    return getNumericRegex(separator).test(s);
+}

package/dist/esm/validators/isOctal.d.ts

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

package/dist/esm/validators/isOctal.js

@@ -0,0 +1,10 @@
+import { toString } from '../convert/string.js';
+const octal = /^(0o)?[0-7]+$/i;
+export function isOctal(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return octal.test(str);
+}

package/dist/esm/validators/isPassportNumber.d.ts

@@ -0,0 +1,69 @@
+declare const passportRegexByCountryCode: {
+    AM: RegExp;
+    AR: RegExp;
+    AT: RegExp;
+    AU: RegExp;
+    AZ: RegExp;
+    BE: RegExp;
+    BG: RegExp;
+    BR: RegExp;
+    BY: RegExp;
+    CA: RegExp;
+    CH: RegExp;
+    CN: RegExp;
+    CY: RegExp;
+    CZ: RegExp;
+    DE: RegExp;
+    DK: RegExp;
+    DZ: RegExp;
+    EE: RegExp;
+    ES: RegExp;
+    FI: RegExp;
+    FR: RegExp;
+    GB: RegExp;
+    GR: RegExp;
+    HR: RegExp;
+    HU: RegExp;
+    IE: RegExp;
+    IN: RegExp;
+    ID: RegExp;
+    IR: RegExp;
+    IS: RegExp;
+    IT: RegExp;
+    JM: RegExp;
+    JP: RegExp;
+    KR: RegExp;
+    KZ: RegExp;
+    LI: RegExp;
+    LT: RegExp;
+    LU: RegExp;
+    LV: RegExp;
+    LY: RegExp;
+    MT: RegExp;
+    MZ: RegExp;
+    MY: RegExp;
+    MX: RegExp;
+    NL: RegExp;
+    NZ: RegExp;
+    PH: RegExp;
+    PK: RegExp;
+    PL: RegExp;
+    PT: RegExp;
+    RO: RegExp;
+    RU: RegExp;
+    SE: RegExp;
+    SL: RegExp;
+    SK: RegExp;
+    TH: RegExp;
+    TR: RegExp;
+    UA: RegExp;
+    US: RegExp;
+    ZA: RegExp;
+};
+export type PassportCountryCode = keyof typeof passportRegexByCountryCode | (string & {});
+export declare const locales: readonly string[];
+export interface IsPassportNumberOptions {
+    countryCode: PassportCountryCode;
+}
+export declare function isPassportNumber(value: unknown, options: IsPassportNumberOptions): boolean;
+export {};

package/dist/esm/validators/isPassportNumber.js

@@ -0,0 +1,80 @@
+import { toString } from '../convert/string.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+import { hasOwn } from '../helpers/hasOwn.js';
+import { optionsOf } from '../helpers/config.js';
+const passportRegexByCountryCode = {
+    AM: /^[A-Z]{2}\d{7}$/,
+    AR: /^[A-Z]{3}\d{6}$/,
+    AT: /^[A-Z]\d{7}$/,
+    AU: /^[A-Z]\d{7}$/,
+    AZ: /^[A-Z]{1}\d{8}$/,
+    BE: /^[A-Z]{2}\d{6}$/,
+    BG: /^\d{9}$/,
+    BR: /^[A-Z]{2}\d{6}$/,
+    BY: /^[A-Z]{2}\d{7}$/,
+    CA: /^[A-Z]{2}\d{6}$|^[A-Z]\d{6}[A-Z]{2}$/,
+    CH: /^[A-Z]\d{7}$/,
+    CN: /^G\d{8}$|^E(?![IO])[A-Z0-9]\d{7}$/,
+    CY: /^[A-Z](\d{6}|\d{8})$/,
+    CZ: /^\d{8}$/,
+    DE: /^[CFGHJKLMNPRTVWXYZ0-9]{9}$/,
+    DK: /^\d{9}$/,
+    DZ: /^\d{9}$/,
+    EE: /^([A-Z]\d{7}|[A-Z]{2}\d{7})$/,
+    ES: /^[A-Z0-9]{2}([A-Z0-9]?)\d{6}$/,
+    FI: /^[A-Z]{2}\d{7}$/,
+    FR: /^\d{2}[A-Z]{2}\d{5}$/,
+    GB: /^\d{9}$/,
+    GR: /^[A-Z]{2}\d{7}$/,
+    HR: /^\d{9}$/,
+    HU: /^[A-Z]{2}(\d{6}|\d{7})$/,
+    IE: /^[A-Z0-9]{2}\d{7}$/,
+    IN: /^[A-Z]{1}-?\d{7}$/,
+    ID: /^[A-C]\d{7}$/,
+    IR: /^[A-Z]\d{8}$/,
+    IS: /^(A)\d{7}$/,
+    IT: /^[A-Z0-9]{2}\d{7}$/,
+    JM: /^[Aa]\d{7}$/,
+    JP: /^[A-Z]{2}\d{7}$/,
+    KR: /^[MS]\d{8}$/,
+    KZ: /^[a-zA-Z]\d{7}$/,
+    LI: /^[a-zA-Z]\d{5}$/,
+    LT: /^[A-Z0-9]{8}$/,
+    LU: /^[A-Z0-9]{8}$/,
+    LV: /^[A-Z0-9]{2}\d{7}$/,
+    LY: /^[A-Z0-9]{8}$/,
+    MT: /^\d{7}$/,
+    MZ: /^(?:[A-Z]{2}\d{7}|\d{2}[A-Z]{2}\d{5})$/,
+    MY: /^[AHK]\d{8}$/,
+    MX: /^[A-Z]\d{8}$/,
+    NL: /^[A-Z]{2}[A-Z0-9]{6}\d$/,
+    NZ: /^([Ll]([Aa]|[Dd]|[Ff]|[Hh])|[Ee]([Aa]|[Pp])|[Nn])\d{6}$/,
+    PH: /^(?:[A-Z](?:\d{6}|\d{7}[A-Z])|[A-Z]{2}(?:\d{6}|\d{7}))$/,
+    PK: /^[A-Z]{2}\d{7}$/,
+    PL: /^[A-Z]{2}\d{7}$/,
+    PT: /^[A-Z]\d{6}$/,
+    RO: /^\d{8,9}$/,
+    RU: /^\d{9}$/,
+    SE: /^\d{8}$/,
+    SL: /^(P)[A-Z]\d{7}$/,
+    SK: /^[0-9A-Z]\d{7}$/,
+    TH: /^[A-Z]{1,2}\d{6,7}$/,
+    TR: /^[A-Z]\d{8}$/,
+    UA: /^[A-Z]{2}\d{6}$/,
+    US: /^\d{9}$|^[A-Z]\d{8}$/,
+    ZA: /^[TAMD]\d{8}$/,
+};
+export const locales = Object.freeze(Object.keys(passportRegexByCountryCode));
+export function isPassportNumber(value, options) {
+    const { countryCode } = optionsOf(options);
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    const normalizedStr = str.replace(/\s/g, '').toUpperCase();
+    if (typeof countryCode !== 'string')
+        throw new ValidationConfigError('countryCode must be a string');
+    const code = countryCode.toUpperCase();
+    return (hasOwn(passportRegexByCountryCode, code) && passportRegexByCountryCode[code].test(normalizedStr));
+}

package/dist/esm/validators/isPort.d.ts

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

package/dist/esm/validators/isPort.js

@@ -0,0 +1,4 @@
+import { isInt } from './isInt.js';
+export function isPort(value) {
+    return isInt(value, { allow_leading_zeroes: false, min: 0, max: 65535 });
+}

package/dist/esm/validators/isPostalCode.d.ts

@@ -0,0 +1,79 @@
+declare const patterns: {
+    AD: RegExp;
+    AT: RegExp;
+    AU: RegExp;
+    AZ: RegExp;
+    BA: RegExp;
+    BD: RegExp;
+    BE: RegExp;
+    BG: RegExp;
+    BR: RegExp;
+    BY: RegExp;
+    CA: RegExp;
+    CH: RegExp;
+    CN: RegExp;
+    CO: RegExp;
+    CZ: RegExp;
+    DE: RegExp;
+    DK: RegExp;
+    DO: RegExp;
+    DZ: RegExp;
+    EE: RegExp;
+    ES: RegExp;
+    FI: RegExp;
+    FR: RegExp;
+    GB: RegExp;
+    GR: RegExp;
+    HR: RegExp;
+    HT: RegExp;
+    HU: RegExp;
+    ID: RegExp;
+    IE: RegExp;
+    IL: RegExp;
+    IN: RegExp;
+    IR: RegExp;
+    IS: RegExp;
+    IT: RegExp;
+    JP: RegExp;
+    KE: RegExp;
+    KR: RegExp;
+    LI: RegExp;
+    LT: RegExp;
+    LU: RegExp;
+    LV: RegExp;
+    LK: RegExp;
+    MC: RegExp;
+    MG: RegExp;
+    MX: RegExp;
+    MT: RegExp;
+    MY: RegExp;
+    NL: RegExp;
+    NO: RegExp;
+    NP: RegExp;
+    NZ: RegExp;
+    PK: RegExp;
+    PL: RegExp;
+    PR: RegExp;
+    PT: RegExp;
+    RO: RegExp;
+    RU: RegExp;
+    SA: RegExp;
+    SE: RegExp;
+    SG: RegExp;
+    SI: RegExp;
+    SK: RegExp;
+    TH: RegExp;
+    TN: RegExp;
+    TW: RegExp;
+    UA: RegExp;
+    US: RegExp;
+    ZA: RegExp;
+    ZM: RegExp;
+};
+export type PostalCodeLocale = keyof typeof patterns | 'any' | (string & {});
+export declare const locales: readonly string[];
+export interface IsPostalCodeOptions {
+    locale: PostalCodeLocale;
+}
+export declare function isPostalCode(value: unknown, options: IsPostalCodeOptions): boolean;
+export {};

package/dist/esm/validators/isPostalCode.js

@@ -0,0 +1,104 @@
+import { toString } from '../convert/string.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+import { hasOwn } from '../helpers/hasOwn.js';
+import { configText, optionsOf } from '../helpers/config.js';
+const threeDigit = /^\d{3}$/;
+const fourDigit = /^\d{4}$/;
+const fiveDigit = /^\d{5}$/;
+const sixDigit = /^\d{6}$/;
+const patterns = {
+    AD: /^AD\d{3}$/,
+    AT: fourDigit,
+    AU: fourDigit,
+    AZ: /^AZ\d{4}$/,
+    BA: /^([7-8]\d{4}$)/,
+    BD: /^([1-8][0-9]{3}|9[0-4][0-9]{2})$/,
+    BE: fourDigit,
+    BG: fourDigit,
+    BR: /^\d{5}-?\d{3}$/,
+    BY: /^2[1-4]\d{4}$/,
+    CA: /^[ABCEGHJKLMNPRSTVXY]\d[ABCEGHJ-NPRSTV-Z][\s-]?\d[ABCEGHJ-NPRSTV-Z]\d$/i,
+    CH: fourDigit,
+    CN: /^(0[1-7]|1[012356]|2[0-7]|3[0-6]|4[0-7]|5[1-7]|6[1-7]|7[1-5]|8[1345]|9[09])\d{4}$/,
+    CO: /^(05|08|11|13|15|17|18|19|20|23|25|27|41|44|47|50|52|54|63|66|68|70|73|76|81|85|86|88|91|94|95|97|99)(\d{4})$/,
+    CZ: /^\d{3}\s?\d{2}$/,
+    DE: fiveDigit,
+    DK: fourDigit,
+    DO: fiveDigit,
+    DZ: fiveDigit,
+    EE: fiveDigit,
+    ES: /^(5[0-2]{1}|[0-4]{1}\d{1})\d{3}$/,
+    FI: fiveDigit,
+    FR: /^(?:(?:0[1-9]|[1-8]\d|9[0-5])\d{3}|97[1-46]\d{2})$/,
+    GB: /^(gir\s?0aa|[a-z]{1,2}\d[\da-z]?\s?(\d[a-z]{2})?)$/i,
+    GR: /^\d{3}\s?\d{2}$/,
+    HR: /^([1-5]\d{4}$)/,
+    HT: /^HT\d{4}$/,
+    HU: fourDigit,
+    ID: fiveDigit,
+    IE: /^(?!.*(?:o))[A-Za-z]\d[\dw]\s\w{4}$/i,
+    IL: /^(\d{5}|\d{7})$/,
+    IN: /^((?!10|29|35|54|55|65|66|86|87|88|89)[1-9][0-9]{5})$/,
+    IR: /^(?!(\d)\1{3})[13-9]{4}[1346-9][013-9]{5}$/,
+    IS: threeDigit,
+    IT: fiveDigit,
+    JP: /^\d{3}-\d{4}$/,
+    KE: fiveDigit,
+    KR: /^(\d{5}|\d{6})$/,
+    LI: /^(948[5-9]|949[0-7])$/,
+    LT: /^LT-\d{5}$/,
+    LU: fourDigit,
+    LV: /^LV-\d{4}$/,
+    LK: fiveDigit,
+    MC: /^980\d{2}$/,
+    MG: threeDigit,
+    MX: fiveDigit,
+    MT: /^[A-Za-z]{3}\s{0,1}\d{4}$/,
+    MY: fiveDigit,
+    NL: /^[1-9]\d{3}\s?(?!sa|sd|ss)[a-z]{2}$/i,
+    NO: fourDigit,
+    NP: /^(10|21|22|32|33|34|44|45|56|57)\d{3}$|^(977)$/i,
+    NZ: fourDigit,
+    PK: fiveDigit,
+    PL: /^\d{2}-\d{3}$/,
+    PR: /^00[679]\d{2}([ -]\d{4})?$/,
+    PT: /^\d{4}-\d{3}?$/,
+    RO: sixDigit,
+    RU: sixDigit,
+    SA: fiveDigit,
+    SE: /^[1-9]\d{2}\s?\d{2}$/,
+    SG: sixDigit,
+    SI: fourDigit,
+    SK: /^\d{3}\s?\d{2}$/,
+    TH: fiveDigit,
+    TN: fourDigit,
+    TW: /^\d{3}(\d{2,3})?$/,
+    UA: fiveDigit,
+    US: /^\d{5}(-\d{4})?$/,
+    ZA: fourDigit,
+    ZM: fiveDigit,
+};
+export const locales = Object.freeze(Object.keys(patterns));
+export function isPostalCode(value, options) {
+    const { locale } = optionsOf(options);
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    if (hasOwn(patterns, locale)) {
+        return patterns[locale].test(str);
+    }
+    if (locale === 'any') {
+        for (const key in patterns) {
+            if (Object.prototype.hasOwnProperty.call(patterns, key)) {
+                const pattern = patterns[key];
+                if (pattern.test(str)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    throw new ValidationConfigError(`Invalid locale '${configText(locale)}'`);
+}

package/dist/esm/validators/isRFC3339.d.ts

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

package/dist/esm/validators/isRFC3339.js

@@ -0,0 +1,25 @@
+import { toString } from '../convert/string.js';
+import { isCalendarDate } from '../convert/date.js';
+const dateFullYear = /[0-9]{4}/;
+const dateMonth = /(0[1-9]|1[0-2])/;
+const dateMDay = /([12]\d|0[1-9]|3[01])/;
+const timeHour = /([01][0-9]|2[0-3])/;
+const timeMinute = /[0-5][0-9]/;
+const timeSecond = /([0-5][0-9]|60)/;
+const timeSecFrac = /(\.[0-9]+)?/;
+const timeNumOffset = new RegExp(`[-+]${timeHour.source}:${timeMinute.source}`);
+const timeOffset = new RegExp(`([zZ]|${timeNumOffset.source})`);
+const partialTime = new RegExp(`${timeHour.source}:${timeMinute.source}:${timeSecond.source}${timeSecFrac.source}`);
+const fullDate = new RegExp(`${dateFullYear.source}-${dateMonth.source}-${dateMDay.source}`);
+const fullTime = new RegExp(`${partialTime.source}${timeOffset.source}`);
+const rfc3339 = new RegExp(`^${fullDate.source}[ tT]${fullTime.source}$`);
+function isRealCalendarDate(str) {
+    return isCalendarDate(Number(str.slice(0, 4)), Number(str.slice(5, 7)), Number(str.slice(8, 10)));
+}
+export function isRFC3339(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    return rfc3339.test(s) && isRealCalendarDate(s);
+}

package/dist/esm/validators/isRequired.d.ts

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

package/dist/esm/validators/isRequired.js

@@ -0,0 +1,3 @@
+export function isRequired(value) {
+    return value !== null && value !== undefined;
+}

package/dist/esm/validators/isRgbColor.d.ts

@@ -0,0 +1,5 @@
+export interface IsRgbColorOptions {
+    includePercentValues?: boolean;
+    allowSpaces?: boolean;
+}
+export declare function isRgbColor(value: unknown, options?: IsRgbColorOptions): boolean;

package/dist/esm/validators/isRgbColor.js

@@ -0,0 +1,35 @@
+import { toString } from '../convert/string.js';
+const rgbColor = /^rgb\((([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5]),){2}([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\)$/;
+const rgbaColor = /^rgba\((([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5]),){3}(0?\.\d\d?|1(\.0)?|0(\.0)?)\)$/;
+const rgbColorPercent = /^rgb\((([0-9]%|[1-9][0-9]%|100%),){2}([0-9]%|[1-9][0-9]%|100%)\)$/;
+const rgbaColorPercent = /^rgba\((([0-9]%|[1-9][0-9]%|100%),){3}(0?\.\d\d?|1(\.0)?|0(\.0)?)\)$/;
+const startsWithUnspacedRgbPrefix = /^rgba?/;
+export function isRgbColor(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    let str = s;
+    let allowSpaces = false;
+    let includePercentValues = true;
+    if (options !== null && typeof options === 'object') {
+        allowSpaces = options.allowSpaces !== undefined ? options.allowSpaces : allowSpaces;
+        includePercentValues =
+            options.includePercentValues !== undefined
+                ? options.includePercentValues
+                : includePercentValues;
+    }
+    if (allowSpaces) {
+        if (!startsWithUnspacedRgbPrefix.test(str)) {
+            return false;
+        }
+        str = str.replace(/\s/g, '');
+    }
+    if (!includePercentValues) {
+        return rgbColor.test(str) || rgbaColor.test(str);
+    }
+    return (rgbColor.test(str) ||
+        rgbaColor.test(str) ||
+        rgbColorPercent.test(str) ||
+        rgbaColorPercent.test(str));
+}

package/dist/esm/validators/isSemVer.d.ts

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

package/dist/esm/validators/isSemVer.js

@@ -0,0 +1,12 @@
+import { toString } from '../convert/string.js';
+const semanticVersioningRegex = new RegExp('^(0|[1-9]\\d*)\\.(0|[1-9]\\d*)\\.(0|[1-9]\\d*)' +
+    '(?:-((?:0|[1-9]\\d*|\\d*[a-z-][0-9a-z-]*)(?:\\.(?:0|[1-9]\\d*|\\d*[a-z-][0-9a-z-]*))*))' +
+    '?(?:\\+([0-9a-z-]+(?:\\.[0-9a-z-]+)*))?$', 'i');
+export function isSemVer(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return semanticVersioningRegex.test(str);
+}

package/dist/esm/validators/isSlug.d.ts

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

package/dist/esm/validators/isSlug.js

@@ -0,0 +1,10 @@
+import { toString } from '../convert/string.js';
+const charsetRegex = /^[a-z0-9](?!.*[-_]{2,})(?:[a-z0-9_-]*[a-z0-9])?$/;
+export function isSlug(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return charsetRegex.test(str);
+}

package/dist/esm/validators/isStrongPassword.d.ts

@@ -0,0 +1,8 @@
+export interface IsStrongPasswordOptions {
+    minLength?: number;
+    minLowercase?: number;
+    minUppercase?: number;
+    minNumbers?: number;
+    minSymbols?: number;
+}
+export declare function isStrongPassword(value: unknown, options?: IsStrongPasswordOptions): boolean;

package/dist/esm/validators/isStrongPassword.js

@@ -0,0 +1,22 @@
+import { merge } from '../helpers/merge.js';
+import { analyzePassword } from '../helpers/analyzePassword.js';
+import { toString } from '../convert/string.js';
+const defaultOptions = {
+    minLength: 8,
+    minLowercase: 1,
+    minUppercase: 1,
+    minNumbers: 1,
+    minSymbols: 1,
+};
+export function isStrongPassword(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const analysis = analyzePassword(stringResult.value);
+    const mergedOptions = merge(options || {}, defaultOptions);
+    return (analysis.length >= mergedOptions.minLength &&
+        analysis.lowercaseCount >= mergedOptions.minLowercase &&
+        analysis.uppercaseCount >= mergedOptions.minUppercase &&
+        analysis.numberCount >= mergedOptions.minNumbers &&
+        analysis.symbolCount >= mergedOptions.minSymbols);
+}

package/dist/esm/validators/isSurrogatePair.d.ts

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

package/dist/esm/validators/isSurrogatePair.js

@@ -0,0 +1,10 @@
+import { toString } from '../convert/string.js';
+const surrogatePair = /[\uD800-\uDBFF][\uDC00-\uDFFF]/;
+export function isSurrogatePair(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return surrogatePair.test(str);
+}

package/dist/esm/validators/isTime.d.ts

@@ -0,0 +1,5 @@
+export interface IsTimeOptions {
+    hourFormat?: 'hour12' | 'hour24';
+    mode?: 'default' | 'withSeconds' | 'withOptionalSeconds';
+}
+export declare function isTime(value: unknown, options?: IsTimeOptions): boolean;

package/dist/esm/validators/isTime.js

@@ -0,0 +1,34 @@
+import { merge } from '../helpers/merge.js';
+import { toString } from '../convert/string.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+import { hasOwn } from '../helpers/hasOwn.js';
+import { configText } from '../helpers/config.js';
+const default_time_options = {
+    hourFormat: 'hour24',
+    mode: 'default',
+};
+const formats = {
+    hour24: {
+        default: /^([01]?[0-9]|2[0-3]):([0-5][0-9])$/,
+        withSeconds: /^([01]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$/,
+        withOptionalSeconds: /^([01]?[0-9]|2[0-3]):([0-5][0-9])(?::([0-5][0-9]))?$/,
+    },
+    hour12: {
+        default: /^(0?[1-9]|1[0-2]):([0-5][0-9]) (A|P)M$/,
+        withSeconds: /^(0?[1-9]|1[0-2]):([0-5][0-9]):([0-5][0-9]) (A|P)M$/,
+        withOptionalSeconds: /^(0?[1-9]|1[0-2]):([0-5][0-9])(?::([0-5][0-9]))? (A|P)M$/,
+    },
+};
+export function isTime(value, options) {
+    const { hourFormat, mode } = merge(options, default_time_options);
+    if (!hasOwn(formats, hourFormat))
+        throw new ValidationConfigError(`Invalid hourFormat '${configText(hourFormat)}'`);
+    const byMode = formats[hourFormat];
+    if (!hasOwn(byMode, mode))
+        throw new ValidationConfigError(`Invalid mode '${configText(mode)}'`);
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    return byMode[mode].test(s);
+}

package/dist/esm/validators/isULID.d.ts

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

package/dist/esm/validators/isULID.js

@@ -0,0 +1,9 @@
+import { toString } from '../convert/string.js';
+export function isULID(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i.test(str);
+}