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

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

@@ -0,0 +1,22 @@
+export interface IsURLOptions {
+    protocols?: string[];
+    require_tld?: boolean;
+    require_protocol?: boolean;
+    require_host?: boolean;
+    require_port?: boolean;
+    require_valid_protocol?: boolean;
+    allow_underscores?: boolean;
+    allow_trailing_dot?: boolean;
+    allow_protocol_relative_urls?: boolean;
+    allow_fragments?: boolean;
+    allow_query_components?: boolean;
+    disallow_auth?: boolean;
+    validate_length?: boolean;
+    max_allowed_length?: number;
+    host_whitelist?: (string | RegExp)[];
+    host_blacklist?: (string | RegExp)[];
+    allow_wildcard?: boolean;
+    allow_numeric_tld?: boolean;
+    ignore_max_length?: boolean;
+}
+export declare function isURL(value: unknown, options?: IsURLOptions): boolean;

package/dist/esm/validators/isURL.js

@@ -0,0 +1,212 @@
+import { toString } from '../convert/string.js';
+import { checkHost, hostList } from '../helpers/checkHost.js';
+import { configText } from '../helpers/config.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+import { isFQDN } from './isFQDN.js';
+import { isIP } from './isIP.js';
+import { merge } from '../helpers/merge.js';
+const default_url_options = {
+    protocols: ['http', 'https', 'ftp'],
+    require_tld: true,
+    require_protocol: false,
+    require_host: true,
+    require_port: false,
+    require_valid_protocol: true,
+    allow_underscores: false,
+    allow_trailing_dot: false,
+    allow_protocol_relative_urls: false,
+    allow_fragments: true,
+    allow_query_components: true,
+    validate_length: true,
+    max_allowed_length: 2084,
+};
+const wrapped_ipv6 = /^\[([^\]]+)\](?::([0-9]+))?$/;
+const forbiddenUrlCharactersRegex = /[\s<>\x00-\x1f\x7f]/;
+const userinfoPartRegex = /^(?:[\p{L}\p{M}\p{N}\-._~!$&'()*+,;=]|%[0-9A-Fa-f]{2})*$/u;
+const codeExecutingSchemes = ['javascript', 'vbscript', 'data'];
+const protocolRegex = /^([a-z][a-z0-9+\-.]*):/i;
+const validAuthRegex = /^[a-zA-Z0-9\-_.%:]*$/;
+const encodedContentRegex = /%[0-9a-fA-F]{2}/;
+const leadingDigitRegex = /^[0-9]/;
+const digitsOnlyRegex = /^[0-9]+$/;
+export function isURL(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    let url = s;
+    if (!url || forbiddenUrlCharactersRegex.test(url)) {
+        return false;
+    }
+    if (url.indexOf('mailto:') === 0) {
+        return false;
+    }
+    options = merge(options, default_url_options);
+    if (!Array.isArray(options.protocols) || !options.protocols.every((p) => typeof p === 'string')) {
+        throw new ValidationConfigError(`protocols must be an array of strings, got ${configText(options.protocols)}`);
+    }
+    if (options.validate_length && typeof options.max_allowed_length !== 'number') {
+        throw new ValidationConfigError(`max_allowed_length must be a number, got ${configText(options.max_allowed_length)}`);
+    }
+    const host_whitelist = options.host_whitelist === undefined
+        ? undefined
+        : hostList(options.host_whitelist, 'host_whitelist');
+    const host_blacklist = options.host_blacklist === undefined
+        ? undefined
+        : hostList(options.host_blacklist, 'host_blacklist');
+    if (options.validate_length && url.length > options.max_allowed_length) {
+        return false;
+    }
+    if (!options.allow_fragments && url.includes('#')) {
+        return false;
+    }
+    if (!options.allow_query_components && (url.includes('?') || url.includes('&'))) {
+        return false;
+    }
+    let protocol, auth, host, port, port_str, split, ipv6;
+    split = url.split('#');
+    url = split.shift();
+    split = url.split('?');
+    url = split.shift();
+    const protocol_match = url.match(protocolRegex);
+    let had_explicit_protocol = false;
+    const cleanUpProtocol = (potential_protocol) => {
+        had_explicit_protocol = true;
+        protocol = potential_protocol.toLowerCase();
+        if (options.require_valid_protocol &&
+            options.protocols.indexOf(protocol) === -1) {
+            return false;
+        }
+        return url.substring(protocol_match[0].length);
+    };
+    if (protocol_match) {
+        const potential_protocol = protocol_match[1];
+        const after_colon = url.substring(protocol_match[0].length);
+        const starts_with_slashes = after_colon.slice(0, 2) === '//';
+        if (!starts_with_slashes) {
+            const first_slash_position = after_colon.indexOf('/');
+            const before_slash = first_slash_position === -1 ? after_colon : after_colon.substring(0, first_slash_position);
+            const at_position = before_slash.indexOf('@');
+            if (at_position !== -1) {
+                const before_at = before_slash.substring(0, at_position);
+                const is_valid_auth = validAuthRegex.test(before_at);
+                const has_encoded_content = encodedContentRegex.test(before_at);
+                const is_code_executing_scheme = codeExecutingSchemes.includes(potential_protocol.toLowerCase());
+                if (is_valid_auth && !has_encoded_content && !is_code_executing_scheme) {
+                    if (options.require_protocol) {
+                        return false;
+                    }
+                }
+                else {
+                    const cleaned1 = cleanUpProtocol(potential_protocol);
+                    if (cleaned1 === false) {
+                        return false;
+                    }
+                    url = cleaned1;
+                }
+            }
+            else {
+                const looks_like_port = leadingDigitRegex.test(after_colon);
+                if (looks_like_port) {
+                    if (options.require_protocol) {
+                        return false;
+                    }
+                }
+                else {
+                    const cleaned2 = cleanUpProtocol(potential_protocol);
+                    if (cleaned2 === false) {
+                        return false;
+                    }
+                    url = cleaned2;
+                }
+            }
+        }
+        else {
+            const cleaned3 = cleanUpProtocol(potential_protocol);
+            if (cleaned3 === false) {
+                return false;
+            }
+            url = cleaned3;
+        }
+    }
+    else if (options.require_protocol) {
+        return false;
+    }
+    if (url.slice(0, 2) === '//') {
+        if (!had_explicit_protocol && !options.allow_protocol_relative_urls) {
+            return false;
+        }
+        url = url.slice(2);
+    }
+    if (url === '') {
+        return false;
+    }
+    split = url.split('/');
+    url = split.shift();
+    if (url.includes('\\')) {
+        return false;
+    }
+    if (url === '' && !options.require_host) {
+        return true;
+    }
+    split = url.split('@');
+    if (split.length > 1) {
+        if (options.disallow_auth) {
+            return false;
+        }
+        if (split[0] === '') {
+            return false;
+        }
+        auth = split.shift();
+        if (auth.indexOf(':') >= 0 && auth.split(':').length > 2) {
+            return false;
+        }
+        const [user, password] = auth.split(':');
+        if (user === '' && password === '') {
+            return false;
+        }
+        if (!userinfoPartRegex.test(user) ||
+            (password !== undefined && !userinfoPartRegex.test(password))) {
+            return false;
+        }
+    }
+    const hostname = split.join('@');
+    port_str = null;
+    ipv6 = null;
+    const ipv6_match = hostname.match(wrapped_ipv6);
+    if (ipv6_match) {
+        host = '';
+        ipv6 = ipv6_match[1];
+        port_str = ipv6_match[2] || null;
+    }
+    else {
+        split = hostname.split(':');
+        host = split.shift();
+        if (split.length) {
+            port_str = split.join(':');
+        }
+    }
+    if (port_str !== null && port_str.length > 0) {
+        port = parseInt(port_str, 10);
+        if (!digitsOnlyRegex.test(port_str) || port <= 0 || port > 65535) {
+            return false;
+        }
+    }
+    else if (options.require_port) {
+        return false;
+    }
+    if (host_whitelist && !checkHost(host || ipv6 || '', host_whitelist)) {
+        return false;
+    }
+    if (host === '' && !options.require_host) {
+        return true;
+    }
+    if (!isIP(host) && !isFQDN(host, options) && (!ipv6 || !isIP(ipv6, { version: 6 }))) {
+        return false;
+    }
+    host = host || ipv6;
+    if (host_blacklist && checkHost(host, host_blacklist)) {
+        return false;
+    }
+    return true;
+}

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

@@ -0,0 +1,5 @@
+export type IsUUIDVersion = 'all' | 'loose' | 'nil' | 'max' | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+export interface IsUUIDOptions {
+    version?: IsUUIDVersion;
+}
+export declare function isUUID(value: unknown, options?: IsUUIDOptions): boolean;

package/dist/esm/validators/isUUID.js

@@ -0,0 +1,28 @@
+import { toString } from '../convert/string.js';
+import { hasOwn } from '../helpers/hasOwn.js';
+import { optionsOf } from '../helpers/config.js';
+const uuid = {
+    1: /^[0-9A-F]{8}-[0-9A-F]{4}-1[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    2: /^[0-9A-F]{8}-[0-9A-F]{4}-2[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    3: /^[0-9A-F]{8}-[0-9A-F]{4}-3[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    4: /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    5: /^[0-9A-F]{8}-[0-9A-F]{4}-5[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    6: /^[0-9A-F]{8}-[0-9A-F]{4}-6[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    7: /^[0-9A-F]{8}-[0-9A-F]{4}-7[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    8: /^[0-9A-F]{8}-[0-9A-F]{4}-8[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i,
+    nil: /^00000000-0000-0000-0000-000000000000$/i,
+    max: /^ffffffff-ffff-ffff-ffff-ffffffffffff$/i,
+    loose: /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i,
+    all: /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i,
+};
+export function isUUID(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    const version = optionsOf(options).version ?? 'all';
+    return hasOwn(uuid, String(version))
+        ? uuid[String(version)].test(str)
+        : false;
+}

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

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

package/dist/esm/validators/isUppercase.js

@@ -0,0 +1,9 @@
+import { toString } from '../convert/string.js';
+export function isUppercase(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return str === str.toUpperCase();
+}

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

@@ -0,0 +1,75 @@
+export declare const vatMatchers: {
+    AT: (str: string) => boolean;
+    BE: (str: string) => boolean;
+    BG: (str: string) => boolean;
+    HR: (str: string) => boolean;
+    CY: (str: string) => boolean;
+    CZ: (str: string) => boolean;
+    DK: (str: string) => boolean;
+    EE: (str: string) => boolean;
+    FI: (str: string) => boolean;
+    FR: (str: string) => boolean;
+    DE: (str: string) => boolean;
+    EL: (str: string) => boolean;
+    HU: (str: string) => boolean;
+    IE: (str: string) => boolean;
+    IT: (str: string) => boolean;
+    LV: (str: string) => boolean;
+    LT: (str: string) => boolean;
+    LU: (str: string) => boolean;
+    MT: (str: string) => boolean;
+    NL: (str: string) => boolean;
+    PL: (str: string) => boolean;
+    PT: (str: string) => boolean;
+    RO: (str: string) => boolean;
+    SK: (str: string) => boolean;
+    SI: (str: string) => boolean;
+    ES: (str: string) => boolean;
+    SE: (str: string) => boolean;
+    AL: (str: string) => boolean;
+    MK: (str: string) => boolean;
+    AU: (str: string) => boolean;
+    BY: (str: string) => boolean;
+    CA: (str: string) => boolean;
+    IS: (str: string) => boolean;
+    IN: (str: string) => boolean;
+    ID: (str: string) => boolean;
+    IL: (str: string) => boolean;
+    KZ: (str: string) => boolean;
+    NZ: (str: string) => boolean;
+    NG: (str: string) => boolean;
+    NO: (str: string) => boolean;
+    PH: (str: string) => boolean;
+    RU: (str: string) => boolean;
+    SM: (str: string) => boolean;
+    SA: (str: string) => boolean;
+    RS: (str: string) => boolean;
+    CH: (str: string) => boolean;
+    TR: (str: string) => boolean;
+    UA: (str: string) => boolean;
+    GB: (str: string) => boolean;
+    UZ: (str: string) => boolean;
+    AR: (str: string) => boolean;
+    BO: (str: string) => boolean;
+    BR: (str: string) => boolean;
+    CL: (str: string) => boolean;
+    CO: (str: string) => boolean;
+    CR: (str: string) => boolean;
+    EC: (str: string) => boolean;
+    SV: (str: string) => boolean;
+    GT: (str: string) => boolean;
+    HN: (str: string) => boolean;
+    MX: (str: string) => boolean;
+    NI: (str: string) => boolean;
+    PA: (str: string) => boolean;
+    PY: (str: string) => boolean;
+    PE: (str: string) => boolean;
+    DO: (str: string) => boolean;
+    UY: (str: string) => boolean;
+    VE: (str: string) => boolean;
+};
+export type VATCountryCode = keyof typeof vatMatchers | (string & {});
+export interface IsVATOptions {
+    countryCode: VATCountryCode;
+}
+export declare function isVAT(value: unknown, options: IsVATOptions): boolean;

package/dist/esm/validators/isVAT.js

@@ -0,0 +1,130 @@
+import { ValidationConfigError } from '../helpers/errors.js';
+import { hasOwn } from '../helpers/hasOwn.js';
+import { toString } from '../convert/string.js';
+import * as algorithms from '../helpers/algorithms.js';
+import { configText, optionsOf } from '../helpers/config.js';
+const AU = (str) => {
+    const match = str.match(/^(AU)?(\d{11})$/);
+    if (!match) {
+        return false;
+    }
+    const weights = [10, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
+    str = str.replace(/^AU/, '');
+    const ABN = (parseInt(str.slice(0, 1), 10) - 1).toString() + str.slice(1);
+    let total = 0;
+    for (let i = 0; i < 11; i++) {
+        total += weights[i] * Number(ABN.charAt(i));
+    }
+    return total !== 0 && total % 89 === 0;
+};
+const CH = (str) => {
+    const hasValidCheckNumber = (digits) => {
+        const checkDigit = digits.pop();
+        const weights = [5, 4, 3, 2, 7, 6, 5, 4];
+        const calculatedCheckNumber = (11 - (digits.reduce((acc, el, idx) => acc + el * weights[idx], 0) % 11)) % 11;
+        return checkDigit === calculatedCheckNumber;
+    };
+    return (/^(CHE[- ]?)?(\d{9}|(\d{3}\.\d{3}\.\d{3})|(\d{3} \d{3} \d{3})) ?(TVA|MWST|IVA)?$/.test(str) &&
+        hasValidCheckNumber(str.match(/\d/g).map((el) => +el)));
+};
+const PT = (str) => {
+    const match = str.match(/^(PT)?(\d{9})$/);
+    if (!match) {
+        return false;
+    }
+    const tin = match[2];
+    const checksum = 11 -
+        (algorithms.reverseMultiplyAndSum(tin
+            .split('')
+            .slice(0, 8)
+            .map((a) => parseInt(a, 10)), 9) %
+            11);
+    if (checksum > 9) {
+        return parseInt(tin[8], 10) === 0;
+    }
+    return checksum === parseInt(tin[8], 10);
+};
+export const vatMatchers = {
+    AT: (str) => /^(AT)?U\d{8}$/.test(str),
+    BE: (str) => /^(BE)?\d{10}$/.test(str),
+    BG: (str) => /^(BG)?\d{9,10}$/.test(str),
+    HR: (str) => /^(HR)?\d{11}$/.test(str),
+    CY: (str) => /^(CY)?[0-9A-Za-z]{9}$/.test(str),
+    CZ: (str) => /^(CZ)?\d{8,10}$/.test(str),
+    DK: (str) => /^(DK)?\d{8}$/.test(str),
+    EE: (str) => /^(EE)?\d{9}$/.test(str),
+    FI: (str) => /^(FI)?\d{8}$/.test(str),
+    FR: (str) => /^(FR)([A-Z0-9]{2}\d{9})$/.test(str),
+    DE: (str) => /^(DE)?\d{9}$/.test(str),
+    EL: (str) => /^(EL)?\d{9}$/.test(str),
+    HU: (str) => /^(HU)?\d{8}$/.test(str),
+    IE: (str) => /^(IE)?\d{7}\w{1}(W)?$/.test(str),
+    IT: (str) => /^(IT)?\d{11}$/.test(str),
+    LV: (str) => /^(LV)?\d{11}$/.test(str),
+    LT: (str) => /^(LT)?\d{9,12}$/.test(str),
+    LU: (str) => /^(LU)?\d{8}$/.test(str),
+    MT: (str) => /^(MT)?\d{8}$/.test(str),
+    NL: (str) => /^(NL)?\d{9}B\d{2}$/.test(str),
+    PL: (str) => /^(PL)?(\d{10}|(\d{3}-\d{3}-\d{2}-\d{2})|(\d{3}-\d{2}-\d{2}-\d{3}))$/.test(str),
+    PT,
+    RO: (str) => /^(RO)?\d{2,10}$/.test(str),
+    SK: (str) => /^(SK)?\d{10}$/.test(str),
+    SI: (str) => /^(SI)?\d{8}$/.test(str),
+    ES: (str) => /^(ES)?\w\d{7}[A-Z]$/.test(str),
+    SE: (str) => /^(SE)?\d{12}$/.test(str),
+    AL: (str) => /^(AL)?\w{9}[A-Z]$/.test(str),
+    MK: (str) => /^(MK)?\d{13}$/.test(str),
+    AU,
+    BY: (str) => /^(УНП )?\d{9}$/.test(str),
+    CA: (str) => /^(CA)?\d{9}$/.test(str),
+    IS: (str) => /^(IS)?\d{5,6}$/.test(str),
+    IN: (str) => /^(IN)?\d{15}$/.test(str),
+    ID: (str) => /^(ID)?(\d{15}|(\d{2}\.\d{3}\.\d{3}\.\d{1}-\d{3}\.\d{3}))$/.test(str),
+    IL: (str) => /^(IL)?\d{9}$/.test(str),
+    KZ: (str) => /^(KZ)?\d{12}$/.test(str),
+    NZ: (str) => /^(NZ)?\d{9}$/.test(str),
+    NG: (str) => /^(NG)?(\d{12}|(\d{8}-\d{4}))$/.test(str),
+    NO: (str) => /^(NO)?\d{9}MVA$/.test(str),
+    PH: (str) => /^(PH)?(\d{12}|\d{3} \d{3} \d{3} \d{3})$/.test(str),
+    RU: (str) => /^(RU)?(\d{10}|\d{12})$/.test(str),
+    SM: (str) => /^(SM)?\d{5}$/.test(str),
+    SA: (str) => /^(SA)?\d{15}$/.test(str),
+    RS: (str) => /^(RS)?\d{9}$/.test(str),
+    CH,
+    TR: (str) => /^(TR)?\d{10}$/.test(str),
+    UA: (str) => /^(UA)?\d{12}$/.test(str),
+    GB: (str) => /^GB((\d{3} \d{4} ([0-8][0-9]|9[0-6]))|(\d{9} \d{3})|(((GD[0-4])|(HA[5-9]))[0-9]{2}))$/.test(str),
+    UZ: (str) => /^(UZ)?\d{9}$/.test(str),
+    AR: (str) => /^(AR)?\d{11}$/.test(str),
+    BO: (str) => /^(BO)?\d{7}$/.test(str),
+    BR: (str) => /^(BR)?((\d{2}\.\d{3}\.\d{3}\/\d{4}-\d{2})|(\d{3}\.\d{3}\.\d{3}-\d{2}))$/.test(str),
+    CL: (str) => /^(CL)?\d{8}-\d{1}$/.test(str),
+    CO: (str) => /^(CO)?\d{10}$/.test(str),
+    CR: (str) => /^(CR)?\d{9,12}$/.test(str),
+    EC: (str) => /^(EC)?\d{13}$/.test(str),
+    SV: (str) => /^(SV)?\d{4}-\d{6}-\d{3}-\d{1}$/.test(str),
+    GT: (str) => /^(GT)?\d{7}-\d{1}$/.test(str),
+    HN: (str) => /^HN$/.test(str),
+    MX: (str) => /^(MX)?\w{3,4}\d{6}\w{3}$/.test(str),
+    NI: (str) => /^(NI)?\d{3}-\d{6}-\d{4}\w{1}$/.test(str),
+    PA: (str) => /^(PA)?[0-9A-Z-]*\d[0-9A-Z-]*$/.test(str),
+    PY: (str) => /^(PY)?\d{6,8}-\d{1}$/.test(str),
+    PE: (str) => /^(PE)?\d{11}$/.test(str),
+    DO: (str) => /^(DO)?(\d{11}|(\d{3}-\d{7}-\d{1})|[145]{1}\d{8}|([145]{1})-\d{2}-\d{5}-\d{1})$/.test(str),
+    UY: (str) => /^(UY)?\d{12}$/.test(str),
+    VE: (str) => /^(VE)?[JGVE]{1}-(\d{9}|(\d{8}-\d{1}))$/.test(str),
+};
+export function isVAT(value, options) {
+    const { countryCode } = optionsOf(options);
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    if (typeof countryCode !== 'string')
+        throw new ValidationConfigError('countryCode must be a string');
+    if (hasOwn(vatMatchers, countryCode)) {
+        return vatMatchers[countryCode](str);
+    }
+    throw new ValidationConfigError(`Invalid country code: '${configText(countryCode)}'`);
+}

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

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

package/dist/esm/validators/isVariableWidth.js

@@ -0,0 +1,11 @@
+import { toString } from '../convert/string.js';
+import { fullWidth } from './isFullWidth.js';
+import { halfWidth } from './isHalfWidth.js';
+export function isVariableWidth(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return fullWidth.test(str) && halfWidth.test(str);
+}

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

@@ -0,0 +1,4 @@
+export interface IsWhitelistedOptions {
+    chars: string | string[];
+}
+export declare function isWhitelisted(value: unknown, options: IsWhitelistedOptions): boolean;

package/dist/esm/validators/isWhitelisted.js

@@ -0,0 +1,20 @@
+import { toString } from '../convert/string.js';
+import { configText, optionsOf } from '../helpers/config.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+export function isWhitelisted(value, options) {
+    const { chars } = optionsOf(options);
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    if (typeof chars !== 'string' && !Array.isArray(chars)) {
+        throw new ValidationConfigError(`chars must be a string or an array, got ${configText(chars)}`);
+    }
+    for (let i = str.length - 1; i >= 0; i--) {
+        if (chars.indexOf(str[i]) === -1) {
+            return false;
+        }
+    }
+    return true;
+}

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

@@ -0,0 +1,5 @@
+export interface MatchesOptions {
+    pattern: RegExp | string;
+    modifiers?: string;
+}
+export declare function matches(value: unknown, options: MatchesOptions): boolean;

package/dist/esm/validators/matches.js

@@ -0,0 +1,26 @@
+import { toString } from '../convert/string.js';
+import { configText, optionsOf } from '../helpers/config.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+export function matches(value, options) {
+    const { pattern, modifiers } = optionsOf(options);
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    if (Object.prototype.toString.call(pattern) === '[object RegExp]') {
+        pattern.lastIndex = 0;
+        return !!str.match(pattern);
+    }
+    if (typeof pattern !== 'string') {
+        throw new ValidationConfigError(`pattern must be a RegExp or a string, got ${configText(pattern)}`);
+    }
+    let regex;
+    try {
+        regex = new RegExp(pattern, modifiers);
+    }
+    catch {
+        throw new ValidationConfigError(`Invalid pattern '${pattern}' or modifiers '${configText(modifiers)}'`);
+    }
+    return !!str.match(regex);
+}