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

package/dist/esm/validators/isCurrency.js

@@ -0,0 +1,111 @@
+import { merge } from '../helpers/merge.js';
+import { toString } from '../convert/string.js';
+import { escapeRegExp } from '../helpers/escapeRegExp.js';
+import { BoundedCache } from '../helpers/boundedCache.js';
+import { ValidationConfigError } from '../helpers/errors.js';
+function currencyRegex(options) {
+    let decimal_digits = `\\d{${options.digits_after_decimal[0]}}`;
+    options.digits_after_decimal.forEach((digit, index) => {
+        if (index !== 0)
+            decimal_digits = `${decimal_digits}|\\d{${digit}}`;
+    });
+    const symbol = `(${escapeRegExp(options.symbol)})${options.require_symbol ? '' : '?'}`, negative = '-?', whole_dollar_amount_without_sep = '[1-9]\\d*', whole_dollar_amount_with_sep = `[1-9]\\d{0,2}(${escapeRegExp(options.thousands_separator)}\\d{3})*`, valid_whole_dollar_amounts = [
+        '0',
+        whole_dollar_amount_without_sep,
+        whole_dollar_amount_with_sep,
+    ], whole_dollar_amount = `(${valid_whole_dollar_amounts.join('|')})?`, decimal_amount = `(${escapeRegExp(options.decimal_separator)}(${decimal_digits}))${options.require_decimal ? '' : '?'}`;
+    let pattern = whole_dollar_amount + (options.allow_decimal || options.require_decimal ? decimal_amount : '');
+    if (options.allow_negatives && !options.parens_for_negatives) {
+        if (options.negative_sign_after_digits) {
+            pattern += negative;
+        }
+        else if (options.negative_sign_before_digits) {
+            pattern = negative + pattern;
+        }
+    }
+    if (options.allow_negative_sign_placeholder) {
+        pattern = `( (?!\\-))?${pattern}`;
+    }
+    else if (options.allow_space_after_symbol) {
+        pattern = ` ?${pattern}`;
+    }
+    else if (options.allow_space_after_digits) {
+        pattern += '( (?!$))?';
+    }
+    if (options.symbol_after_digits) {
+        pattern += symbol;
+    }
+    else {
+        pattern = symbol + pattern;
+    }
+    if (options.allow_negatives) {
+        if (options.parens_for_negatives) {
+            pattern = `(\\(${pattern}\\)|${pattern})`;
+        }
+        else if (!(options.negative_sign_before_digits || options.negative_sign_after_digits)) {
+            pattern = negative + pattern;
+        }
+    }
+    const notStartingWithSpaceOrSignedSpace = '(?!-? )';
+    const containingADigit = '(?=.*\\d)';
+    return new RegExp(`^${notStartingWithSpaceOrSignedSpace}${containingADigit}${pattern}$`);
+}
+const default_currency_options = {
+    symbol: '$',
+    require_symbol: false,
+    allow_space_after_symbol: false,
+    symbol_after_digits: false,
+    allow_negatives: true,
+    parens_for_negatives: false,
+    negative_sign_before_digits: false,
+    negative_sign_after_digits: false,
+    allow_negative_sign_placeholder: false,
+    thousands_separator: ',',
+    decimal_separator: '.',
+    allow_decimal: true,
+    require_decimal: false,
+    digits_after_decimal: [2],
+    allow_space_after_digits: false,
+};
+const currencyRegexCache = new BoundedCache();
+function assertValidOptions(options) {
+    for (const key of ['symbol', 'thousands_separator', 'decimal_separator']) {
+        if (typeof options[key] !== 'string')
+            throw new ValidationConfigError(`${key} must be a string`);
+    }
+    const digits = options.digits_after_decimal;
+    if (!Array.isArray(digits) ||
+        digits.length === 0 ||
+        !digits.every((d) => Number.isInteger(d) && d >= 0)) {
+        throw new ValidationConfigError('digits_after_decimal must be a non-empty array of non-negative integers');
+    }
+}
+function getCurrencyRegex(options) {
+    assertValidOptions(options);
+    const key = JSON.stringify([
+        options.symbol,
+        options.require_symbol,
+        options.allow_space_after_symbol,
+        options.symbol_after_digits,
+        options.allow_negatives,
+        options.parens_for_negatives,
+        options.negative_sign_before_digits,
+        options.negative_sign_after_digits,
+        options.allow_negative_sign_placeholder,
+        options.thousands_separator,
+        options.decimal_separator,
+        options.allow_decimal,
+        options.require_decimal,
+        options.digits_after_decimal,
+        options.allow_space_after_digits,
+    ]);
+    return currencyRegexCache.getOrCreate(key, () => currencyRegex(options));
+}
+export function isCurrency(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const opts = merge(options, default_currency_options);
+    return getCurrencyRegex(opts).test(s);
+}

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

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

package/dist/esm/validators/isDataURI.js

@@ -0,0 +1,36 @@
+import { toString } from '../convert/string.js';
+const validMediaType = /^[a-z]+\/[a-z0-9\-+._]+$/i;
+const validAttribute = /^[a-z-]+=[a-z0-9-]+$/i;
+const validData = /^[a-z0-9!$&'()*+,;=\-._~:@/?%\s]*$/i;
+export function isDataURI(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    const data = str.split(',');
+    if (data.length < 2) {
+        return false;
+    }
+    const attributes = data.shift().trim().split(';');
+    const schemeAndMediaType = attributes.shift();
+    if (schemeAndMediaType.slice(0, 5) !== 'data:') {
+        return false;
+    }
+    const mediaType = schemeAndMediaType.slice(5);
+    if (mediaType !== '' && !validMediaType.test(mediaType)) {
+        return false;
+    }
+    for (let i = 0; i < attributes.length; i++) {
+        if (!(i === attributes.length - 1 && attributes[i].toLowerCase() === 'base64') &&
+            !validAttribute.test(attributes[i])) {
+            return false;
+        }
+    }
+    for (const item of data) {
+        if (!validData.test(item)) {
+            return false;
+        }
+    }
+    return true;
+}

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

@@ -0,0 +1,7 @@
+export interface IsDateOptions {
+    format?: string;
+    strictMode?: boolean;
+    delimiters?: string[];
+    twoDigitYearPivot?: number;
+}
+export declare function isDate(value: unknown, options?: IsDateOptions): boolean;

package/dist/esm/validators/isDate.js

@@ -0,0 +1,5 @@
+import { toDate } from '../convert/date.js';
+import { optionsOf } from '../helpers/config.js';
+export function isDate(value, options) {
+    return toDate(value, optionsOf(options)).ok;
+}

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

@@ -0,0 +1,6 @@
+export interface IsDecimalOptions {
+    force_decimal?: boolean;
+    decimal_digits?: string;
+    locale?: string;
+}
+export declare function isDecimal(value: unknown, options?: IsDecimalOptions): boolean;

package/dist/esm/validators/isDecimal.js

@@ -0,0 +1,43 @@
+import { ValidationConfigError } from '../helpers/errors.js';
+import { hasOwn } from '../helpers/hasOwn.js';
+import { merge } from '../helpers/merge.js';
+import { toString } from '../convert/string.js';
+import { escapeRegExp } from '../helpers/escapeRegExp.js';
+import { BoundedCache } from '../helpers/boundedCache.js';
+import { decimal } from './alpha.js';
+import { configText } from '../helpers/config.js';
+const decimalRegexCache = new BoundedCache();
+const DECIMAL_DIGITS_FORMAT = /^\d+(,\d*)?$/;
+function isValidDecimalDigits(digits) {
+    if (typeof digits !== 'string' || !DECIMAL_DIGITS_FORMAT.test(digits))
+        return false;
+    const [min, max = ''] = digits.split(',');
+    const LARGEST_QUANTIFIER = 1000000;
+    return (Number(min) <= LARGEST_QUANTIFIER &&
+        (max === '' || (Number(min) <= Number(max) && Number(max) <= LARGEST_QUANTIFIER)));
+}
+function decimalRegExp(options) {
+    const key = JSON.stringify([options.locale, options.decimal_digits, options.force_decimal]);
+    return decimalRegexCache.getOrCreate(key, () => new RegExp(`^[-+]?([0-9]+)?(${escapeRegExp(decimal[options.locale])}[0-9]{${options.decimal_digits}})${options.force_decimal ? '' : '?'}$`));
+}
+const default_decimal_options = {
+    force_decimal: false,
+    decimal_digits: '1,',
+    locale: 'en-US',
+};
+const blacklist = ['', '-', '+'];
+export function isDecimal(value, options) {
+    const opts = merge(options, default_decimal_options);
+    opts.locale = String(opts.locale);
+    if (!hasOwn(decimal, opts.locale)) {
+        throw new ValidationConfigError(`Invalid locale '${configText(opts.locale)}'`);
+    }
+    if (!isValidDecimalDigits(opts.decimal_digits)) {
+        throw new ValidationConfigError(`Invalid decimal_digits '${configText(opts.decimal_digits)}'`);
+    }
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    return !blacklist.includes(s.replace(/ /g, '')) && decimalRegExp(opts).test(s);
+}

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

@@ -0,0 +1,4 @@
+export interface IsDivisibleByOptions {
+    num: number;
+}
+export declare function isDivisibleBy(value: unknown, options: IsDivisibleByOptions): boolean;

package/dist/esm/validators/isDivisibleBy.js

@@ -0,0 +1,12 @@
+import { toString } from '../convert/string.js';
+import { toFloat } from '../convert/float.js';
+import { optionsOf } from '../helpers/config.js';
+export function isDivisibleBy(value, options) {
+    const { num } = optionsOf(options);
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const r = toFloat(s, { syntax: 'validator' });
+    return r.ok && r.value % parseInt(String(num), 10) === 0;
+}

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

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

package/dist/esm/validators/isEAN.js

@@ -0,0 +1,28 @@
+import { toString } from '../convert/string.js';
+const LENGTH_EAN_8 = 8;
+const LENGTH_EAN_14 = 14;
+const validEanRegex = /^(\d{8}|\d{13}|\d{14})$/;
+function getPositionWeightThroughLengthAndIndex(length, index) {
+    if (length === LENGTH_EAN_8 || length === LENGTH_EAN_14) {
+        return index % 2 === 0 ? 3 : 1;
+    }
+    return index % 2 === 0 ? 1 : 3;
+}
+function calculateCheckDigit(ean) {
+    const checksum = ean
+        .slice(0, -1)
+        .split('')
+        .map((char, index) => Number(char) * getPositionWeightThroughLengthAndIndex(ean.length, index))
+        .reduce((acc, partialSum) => acc + partialSum, 0);
+    const remainder = 10 - (checksum % 10);
+    return remainder < 10 ? remainder : 0;
+}
+export function isEAN(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    const actualCheckDigit = Number(str.slice(-1));
+    return validEanRegex.test(str) && actualCheckDigit === calculateCheckDigit(str);
+}

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

@@ -0,0 +1,14 @@
+export interface IsEmailOptions {
+    allow_display_name?: boolean;
+    allow_underscores?: boolean;
+    require_display_name?: boolean;
+    allow_utf8_local_part?: boolean;
+    require_tld?: boolean;
+    blacklisted_chars?: string;
+    ignore_max_length?: boolean;
+    host_blacklist?: (string | RegExp)[];
+    host_whitelist?: (string | RegExp)[];
+    allow_ip_domain?: boolean;
+    domain_specific_validation?: boolean;
+}
+export declare function isEmail(value: unknown, options?: IsEmailOptions): boolean;

package/dist/esm/validators/isEmail.js

@@ -0,0 +1,150 @@
+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 { escapeRegExp } from '../helpers/escapeRegExp.js';
+import { isByteLength } from './isByteLength.js';
+import { isFQDN } from './isFQDN.js';
+import { isIP } from './isIP.js';
+import { merge } from '../helpers/merge.js';
+const default_email_options = {
+    allow_display_name: false,
+    allow_underscores: false,
+    require_display_name: false,
+    allow_utf8_local_part: true,
+    require_tld: true,
+    blacklisted_chars: '',
+    ignore_max_length: false,
+    host_blacklist: [],
+    host_whitelist: [],
+};
+const splitNameAddress = /^([^\x00-\x1F\x7F-\x9F\cX]+)</i;
+const emailUserPart = /^[a-z\d!#$%&'*+\-/=?^_`{|}~]+$/i;
+const gmailUserPart = /^[a-z\d]+$/;
+const quotedEmailUser = /^([\t \x21\x23-\x5b\x5d-\x7e]|(\\[\t\x20-\x7e]))*$/i;
+const emailUserUtf8Part = /^[a-z\d!#$%&'*+\-/=?^_`{|}~\u00A1-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+$/i;
+const quotedEmailUserUtf8 = /^([\t \x21\x23-\x5b\x5d-\x7e\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]|(\\[\t\x20-\x7e\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))*$/i;
+const defaultMaxEmailLength = 254;
+const invisibleLocalPart = /[\p{Cf}\p{Cs}\p{Zl}\p{Zp}\u00A0\u1680\u2000-\u200A\u202F\u205F\u3000]/u;
+function validateDisplayName(display_name) {
+    const display_name_without_quotes = display_name.replace(/^"(.+)"$/, '$1');
+    if (!display_name_without_quotes.trim()) {
+        return false;
+    }
+    const contains_illegal = /[.";<>]/.test(display_name_without_quotes);
+    if (contains_illegal) {
+        const is_quoted = display_name_without_quotes !== display_name;
+        if (!is_quoted) {
+            return false;
+        }
+        const all_start_with_back_slash = display_name_without_quotes.split('"').length ===
+            display_name_without_quotes.split('\\"').length;
+        if (!all_start_with_back_slash) {
+            return false;
+        }
+    }
+    return true;
+}
+export function isEmail(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    let strVal = s;
+    options = merge(options, default_email_options);
+    if (options.require_display_name || options.allow_display_name) {
+        const display_email = strVal.match(splitNameAddress);
+        if (display_email) {
+            let display_name = display_email[1];
+            const address = strVal.replace(display_name, '');
+            if (!address.endsWith('>')) {
+                return false;
+            }
+            strVal = address.slice(1, -1);
+            if (display_name.endsWith(' ')) {
+                display_name = display_name.slice(0, -1);
+            }
+            if (!validateDisplayName(display_name)) {
+                return false;
+            }
+        }
+        else if (options.require_display_name) {
+            return false;
+        }
+    }
+    if (!options.ignore_max_length && strVal.length > defaultMaxEmailLength) {
+        return false;
+    }
+    const parts = strVal.split('@');
+    const domain = parts.pop();
+    const lower_domain = domain.toLowerCase();
+    const host_blacklist = hostList(options.host_blacklist, 'host_blacklist');
+    const host_whitelist = hostList(options.host_whitelist, 'host_whitelist');
+    if (host_blacklist.length > 0 && checkHost(lower_domain, host_blacklist)) {
+        return false;
+    }
+    if (host_whitelist.length > 0 && !checkHost(lower_domain, host_whitelist)) {
+        return false;
+    }
+    let user = parts.join('@');
+    if (options.domain_specific_validation &&
+        (lower_domain === 'gmail.com' || lower_domain === 'googlemail.com')) {
+        user = user.toLowerCase();
+        const username = user.split('+')[0];
+        if (!isByteLength(username.replace(/\./g, ''), { min: 6, max: 30 })) {
+            return false;
+        }
+        const user_parts = username.split('.');
+        for (const part of user_parts) {
+            if (!gmailUserPart.test(part)) {
+                return false;
+            }
+        }
+    }
+    if (!options.ignore_max_length &&
+        (!isByteLength(user, { max: 64 }) || !isByteLength(domain, { max: 254 }))) {
+        return false;
+    }
+    if (!isFQDN(domain, {
+        require_tld: options.require_tld,
+        ignore_max_length: options.ignore_max_length,
+        allow_underscores: options.allow_underscores,
+    })) {
+        if (!options.allow_ip_domain) {
+            return false;
+        }
+        if (!isIP(domain)) {
+            if (!domain.startsWith('[') || !domain.endsWith(']')) {
+                return false;
+            }
+            const noBracketdomain = domain.slice(1, -1);
+            if (noBracketdomain.length === 0 || !isIP(noBracketdomain)) {
+                return false;
+            }
+        }
+    }
+    if (options.blacklisted_chars) {
+        if (typeof options.blacklisted_chars !== 'string') {
+            throw new ValidationConfigError(`blacklisted_chars must be a string, got ${configText(options.blacklisted_chars)}`);
+        }
+        if (new RegExp(`[${escapeRegExp(options.blacklisted_chars)}]`).test(user))
+            return false;
+    }
+    if (invisibleLocalPart.test(user)) {
+        return false;
+    }
+    if (user[0] === '"' && user[user.length - 1] === '"') {
+        user = user.slice(1, user.length - 1);
+        return options.allow_utf8_local_part
+            ? quotedEmailUserUtf8.test(user)
+            : quotedEmailUser.test(user);
+    }
+    const pattern = options.allow_utf8_local_part ? emailUserUtf8Part : emailUserPart;
+    const user_parts = user.split('.');
+    for (const part of user_parts) {
+        if (!pattern.test(part)) {
+            return false;
+        }
+    }
+    return true;
+}

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

@@ -0,0 +1,4 @@
+export interface IsEmptyOptions {
+    ignore_whitespace?: boolean;
+}
+export declare function isEmpty(value: unknown, options?: IsEmptyOptions): boolean;

package/dist/esm/validators/isEmpty.js

@@ -0,0 +1,14 @@
+import { toString } from '../convert/string.js';
+import { merge } from '../helpers/merge.js';
+const default_is_empty_options = {
+    ignore_whitespace: false,
+};
+export function isEmpty(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    options = merge(options, default_is_empty_options);
+    return (options.ignore_whitespace ? str.trim().length : str.length) === 0;
+}

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

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

package/dist/esm/validators/isEthereumAddress.js

@@ -0,0 +1,10 @@
+import { toString } from '../convert/string.js';
+const eth = /^(0x)[0-9a-f]{40}$/i;
+export function isEthereumAddress(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return eth.test(str);
+}

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

@@ -0,0 +1,9 @@
+export interface IsFQDNOptions {
+    require_tld?: boolean;
+    allow_underscores?: boolean;
+    allow_trailing_dot?: boolean;
+    allow_numeric_tld?: boolean;
+    allow_wildcard?: boolean;
+    ignore_max_length?: boolean;
+}
+export declare function isFQDN(value: unknown, options?: IsFQDNOptions): boolean;

package/dist/esm/validators/isFQDN.js

@@ -0,0 +1,65 @@
+import { toString } from '../convert/string.js';
+import { merge } from '../helpers/merge.js';
+const default_fqdn_options = {
+    require_tld: true,
+    allow_underscores: false,
+    allow_trailing_dot: false,
+    allow_numeric_tld: false,
+    allow_wildcard: false,
+    ignore_max_length: false,
+};
+const tldRegex = /^([a-z¡-¨ª-퟿豈-﷏ﷰ-￯]{2,}|xn[a-z0-9-]{2,})$/i;
+const numericRegex = /^\d+$/;
+const partCharsRegex = /^[a-z_¡-￿0-9-]+$/i;
+const fullWidthRegex = /[！-～]/;
+const hyphenEdgeRegex = /^-|-$/;
+const underscoreRegex = /_/;
+const invisibleRegex = /[\p{Cc}\p{Cf}\p{Cs}\p{Z}]/u;
+export function isFQDN(value, options) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    let strVal = s;
+    options = merge(options, default_fqdn_options);
+    if (options.allow_trailing_dot && strVal[strVal.length - 1] === '.') {
+        strVal = strVal.substring(0, strVal.length - 1);
+    }
+    if (options.allow_wildcard === true && strVal.indexOf('*.') === 0) {
+        strVal = strVal.substring(2);
+    }
+    if (invisibleRegex.test(strVal)) {
+        return false;
+    }
+    const parts = strVal.split('.');
+    const tld = parts[parts.length - 1];
+    if (options.require_tld) {
+        if (parts.length < 2) {
+            return false;
+        }
+        if (!options.allow_numeric_tld && !tldRegex.test(tld)) {
+            return false;
+        }
+    }
+    if (!options.allow_numeric_tld && numericRegex.test(tld)) {
+        return false;
+    }
+    return parts.every((part) => {
+        if (part.length > 63 && !options.ignore_max_length) {
+            return false;
+        }
+        if (!partCharsRegex.test(part)) {
+            return false;
+        }
+        if (fullWidthRegex.test(part)) {
+            return false;
+        }
+        if (hyphenEdgeRegex.test(part)) {
+            return false;
+        }
+        if (!options.allow_underscores && underscoreRegex.test(part)) {
+            return false;
+        }
+        return true;
+    });
+}

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

@@ -0,0 +1,9 @@
+export interface IsFloatOptions {
+    min?: number;
+    max?: number;
+    lt?: number;
+    gt?: number;
+    locale?: string;
+}
+export declare function isFloat(value: unknown, options?: IsFloatOptions): boolean;
+export declare const locales: readonly string[];

package/dist/esm/validators/isFloat.js

@@ -0,0 +1,26 @@
+import { toFloat } from '../convert/float.js';
+import { decimal } from './alpha.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';
+export function isFloat(value, options) {
+    const opts = options || {};
+    if (typeof value !== 'number') {
+        if (!toString(value).ok)
+            return false;
+        if (opts.locale && !hasOwn(decimal, opts.locale)) {
+            throw new ValidationConfigError(`Invalid locale '${configText(opts.locale)}'`);
+        }
+    }
+    const decimalSeparator = opts.locale ? decimal[opts.locale] : '.';
+    const r = toFloat(value, { syntax: 'validator', decimalSeparator });
+    if (!r.ok)
+        return false;
+    const n = r.value;
+    return ((opts.min == null || n >= opts.min) &&
+        (opts.max == null || n <= opts.max) &&
+        (opts.lt == null || n < opts.lt) &&
+        (opts.gt == null || n > opts.gt));
+}
+export const locales = Object.freeze(Object.keys(decimal));

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

@@ -0,0 +1,2 @@
+export declare const fullWidth: RegExp;
+export declare function isFullWidth(value: unknown): boolean;

package/dist/esm/validators/isFullWidth.js

@@ -0,0 +1,10 @@
+import { toString } from '../convert/string.js';
+export const fullWidth = /[^\u0020-\u007E\uFF61-\uFF9F\uFFA0-\uFFDC\uFFE8-\uFFEE0-9a-zA-Z]/;
+export function isFullWidth(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return fullWidth.test(str);
+}

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

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

package/dist/esm/validators/isHSL.js

@@ -0,0 +1,15 @@
+import { toString } from '../convert/string.js';
+const hslComma = /^hsla?\(((\+|-)?([0-9]+(\.[0-9]+)?(e(\+|-)?[0-9]+)?|\.[0-9]+(e(\+|-)?[0-9]+)?))(deg|grad|rad|turn)?(,(\+|-)?([0-9]+(\.[0-9]+)?(e(\+|-)?[0-9]+)?|\.[0-9]+(e(\+|-)?[0-9]+)?)%){2}(,((\+|-)?([0-9]+(\.[0-9]+)?(e(\+|-)?[0-9]+)?|\.[0-9]+(e(\+|-)?[0-9]+)?)%?))?\)$/i;
+const hslSpace = /^hsla?\(((\+|-)?([0-9]+(\.[0-9]+)?(e(\+|-)?[0-9]+)?|\.[0-9]+(e(\+|-)?[0-9]+)?))(deg|grad|rad|turn)?(\s(\+|-)?([0-9]+(\.[0-9]+)?(e(\+|-)?[0-9]+)?|\.[0-9]+(e(\+|-)?[0-9]+)?)%){2}\s?(\/\s((\+|-)?([0-9]+(\.[0-9]+)?(e(\+|-)?[0-9]+)?|\.[0-9]+(e(\+|-)?[0-9]+)?)%?)\s?)?\)$/i;
+export function isHSL(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    const strippedStr = str.replace(/\s+/g, ' ').replace(/\s?(hsla?\(|\)|,)\s?/gi, '$1');
+    if (strippedStr.indexOf(',') !== -1) {
+        return hslComma.test(strippedStr);
+    }
+    return hslSpace.test(strippedStr);
+}

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

@@ -0,0 +1,2 @@
+export declare const halfWidth: RegExp;
+export declare function isHalfWidth(value: unknown): boolean;

package/dist/esm/validators/isHalfWidth.js

@@ -0,0 +1,10 @@
+import { toString } from '../convert/string.js';
+export const halfWidth = /[\u0020-\u007E\uFF61-\uFF9F\uFFA0-\uFFDC\uFFE8-\uFFEE0-9a-zA-Z]/;
+export function isHalfWidth(value) {
+    const stringResult = toString(value);
+    if (!stringResult.ok)
+        return false;
+    const s = stringResult.value;
+    const str = s;
+    return halfWidth.test(str);
+}

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

@@ -0,0 +1,21 @@
+declare const lengths: {
+    md5: number;
+    md4: number;
+    sha1: number;
+    sha256: number;
+    sha384: number;
+    sha512: number;
+    ripemd128: number;
+    ripemd160: number;
+    tiger128: number;
+    tiger160: number;
+    tiger192: number;
+    crc32: number;
+    crc32b: number;
+};
+export type HashAlgorithm = keyof typeof lengths | (string & {});
+export interface IsHashOptions {
+    algorithm: HashAlgorithm;
+}
+export declare function isHash(value: unknown, options: IsHashOptions): boolean;
+export {};