@stacksjs/strings 0.70.22 → 0.70.25

package/README.md

@@ -94,7 +94,7 @@ console.log(camelCase('hello world')) // => "helloWorld"
 console.log(plural('dog')) // => "dogs"
 ```
 
-To view the full documentation, please visit [https://stacksjs.org/strings](https://stacksjs.org/strings).
+To view the full documentation, please visit [<https://stacksjs.com/string>s](https://stacksjs.com/strings).
 
 ## 🧪 Testing
 

package/dist/index.js

@@ -1,63 +1,4 @@
 // @bun
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// src/string.ts
-var exports_string = {};
-__export(exports_string, {
-  urlAlphabet: () => urlAlphabet,
-  truncate: () => truncate,
-  trainCase: () => trainCase,
-  toString: () => toString,
-  titleCase: () => titleCase,
-  template: () => template,
-  swapCase: () => swapCase,
-  str: () => str,
-  spongeCase: () => spongeCase,
-  splitSeparateNumbers: () => splitSeparateNumbers,
-  split: () => split,
-  snakeCase: () => snakeCase,
-  slugify: () => slugify,
-  slug: () => slug,
-  slash: () => slash,
-  singular: () => singular,
-  sentenceCase: () => sentenceCase,
-  random: () => random,
-  pluralize: () => pluralize,
-  plural: () => plural,
-  pathCase: () => pathCase,
-  pascalSnakeCase: () => pascalSnakeCase,
-  pascalCase: () => pascalCase,
-  paramCase: () => paramCase,
-  noCase: () => noCase,
-  lowercase: () => lowercase,
-  kebabCase: () => kebabCase,
-  extendCharMap: () => extendCharMap,
-  ensureSuffix: () => ensureSuffix,
-  ensurePrefix: () => ensurePrefix,
-  dotCase: () => dotCase,
-  detectNewlineGraceful: () => detectNewlineGraceful,
-  detectNewline: () => detectNewline,
-  detectIndent: () => detectIndent,
-  constantCase: () => constantCase,
-  capitalize: () => capitalize,
-  capitalCase: () => capitalCase,
-  camelCase: () => camelCase,
-  WORD_SEPARATORS: () => WORD_SEPARATORS,
-  TITLE_TERMINATORS: () => TITLE_TERMINATORS,
-  Str: () => Str,
-  SMALL_WORDS: () => SMALL_WORDS,
-  SENTENCE_TERMINATORS: () => SENTENCE_TERMINATORS
-});
-
 // src/sponge-case.ts
 function spongeCase(input, locale) {
   let result = "";
@@ -146,6 +87,8 @@ function titleCase(input, options = {}) {
       result += whiteSpace;
       continue;
     }
+    if (token === undefined)
+      continue;
     if (IS_SPECIAL_CASE.test(token)) {
       const acronym = token.match(IS_ACRONYM);
       if (acronym) {
@@ -161,7 +104,10 @@ function titleCase(input, options = {}) {
       let value = token;
       let isSentenceEnd = false;
       for (let i = 0;i < matches.length; i++) {
-        const { 0: word, index: wordIndex = 0 } = matches[i];
+        const match = matches[i];
+        if (!match)
+          continue;
+        const { 0: word, index: wordIndex = 0 } = match;
         const nextChar = token.charAt(wordIndex + word.length);
         isSentenceEnd = terminators.has(nextChar);
         if (isNewSentence) {
@@ -226,9 +172,11 @@ function splitSeparateNumbers(value) {
   const words = split(value);
   for (let i = 0;i < words.length; i++) {
     const word = words[i];
+    if (word === undefined)
+      continue;
     const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
     if (match) {
-      const offset = match.index + (match[1] ?? match[2]).length;
+      const offset = match.index + (match[1] ?? match[2] ?? "").length;
       words.splice(i, 1, word.slice(0, offset), word.slice(offset));
     }
   }
@@ -305,11 +253,17 @@ function upperFactory(locale) {
   return locale === false ? (input) => input.toUpperCase() : (input) => input.toLocaleUpperCase(locale);
 }
 function capitalCaseTransformFactory(lower, upper) {
-  return (word) => `${upper(word[0])}${lower(word.slice(1))}`;
+  return (word) => {
+    if (!word)
+      return word;
+    return `${upper(word[0] ?? "")}${lower(word.slice(1))}`;
+  };
 }
 function pascalCaseTransformFactory(lower, upper) {
   return (word, index) => {
-    const char0 = word[0];
+    if (!word)
+      return word;
+    const char0 = word[0] ?? "";
     const initial = index > 0 && char0 >= "0" && char0 <= "9" ? `_${char0}` : upper(char0);
     return initial + lower(word.slice(1));
   };
@@ -339,10 +293,12 @@ function splitPrefixSuffix(input, options = {}) {
     input.slice(suffixIndex)
   ];
 }
+
 // src/helpers.ts
 function toString(v) {
   return Object.prototype.toString.call(v);
 }
+
 // src/pluralize.ts
 var pluralRules = [];
 var singularRules = [];
@@ -359,19 +315,20 @@ function restoreCase(word, token) {
     return token.toLowerCase();
   if (word === word.toUpperCase())
     return token.toUpperCase();
-  if (word[0] === word[0].toUpperCase()) {
+  const firstChar = word[0];
+  if (firstChar !== undefined && firstChar === firstChar.toUpperCase()) {
     return token.charAt(0).toUpperCase() + token.slice(1).toLowerCase();
   }
   return token.toLowerCase();
 }
 function interpolate(str, ...args) {
-  return str.replace(/\$(\d{1,2})/g, (match, index) => args[Number(index)] || "");
+  return str.replace(/\$(\d{1,2})/g, (_match, index) => args[Number(index)] || "");
 }
 function replace(word, rule) {
   return word.replace(rule[0], (...matchArgs) => {
     const result = interpolate(rule[1], ...matchArgs);
     if (matchArgs[0] === "") {
-      return restoreCase(word[matchArgs[matchArgs.length - 2] - 1], result);
+      return restoreCase(word[matchArgs[matchArgs.length - 2] - 1] ?? "", result);
     }
     return restoreCase(matchArgs[0], result);
   });
@@ -382,7 +339,7 @@ function sanitizeWord(token, word, rules) {
   }
   for (let i = rules.length - 1;i >= 0; i--) {
     const rule = rules[i];
-    if (rule[0].test(word))
+    if (rule && rule[0].test(word))
       return replace(word, rule);
   }
   return word;
@@ -498,7 +455,7 @@ pluralize.addIrregularRule = (single, plural2) => {
   ["pickaxe", "pickaxes"],
   ["passerby", "passersby"],
   ["canvas", "canvases"]
-].forEach(([single, plural2]) => pluralize.addIrregularRule(single, plural2));
+].forEach(([single, plural2]) => pluralize.addIrregularRule(single ?? "", plural2 ?? ""));
 [
   [/s?$/i, "s"],
   [/[^\x20-\x7F]$/, "$0"],
@@ -525,7 +482,11 @@ pluralize.addIrregularRule = (single, plural2) => {
   [/eaux$/i, "$0"],
   [/m[ae]n$/i, "men"],
   ["thou", "you"]
-].forEach(([rule, replacement]) => pluralize.addPluralRule(rule, replacement));
+].forEach(([rule, replacement]) => {
+  if (rule === undefined)
+    return;
+  pluralize.addPluralRule(rule, replacement);
+});
 [
   [/s$/i, ""],
   [/(ss)$/i, "$1"],
@@ -551,7 +512,11 @@ pluralize.addIrregularRule = (single, plural2) => {
   [/(child)ren$/i, "$1"],
   [/(eau)x?$/i, "$1"],
   [/men$/i, "man"]
-].forEach(([rule, replacement]) => pluralize.addSingularRule(rule, replacement));
+].forEach(([rule, replacement]) => {
+  if (rule === undefined)
+    return;
+  pluralize.addSingularRule(rule, replacement);
+});
 [
   "adulthood",
   "advice",
@@ -695,7 +660,7 @@ function makeIndentsMap(string, ignoreSingleSpaces = true) {
   const indents = new Map;
   let previousSize = 0;
   let previousIndentType;
-  let key;
+  let key = "";
   for (const line of string.split(/\n/g)) {
     if (!line) {
       continue;
@@ -773,13 +738,10 @@ function detectIndent(string) {
     indents = makeIndentsMap(string, false);
   }
   const keyOfMostUsedIndent = getMostUsedKey(indents);
-  let type;
-  let amount = 0;
-  let indent = "";
-  if (keyOfMostUsedIndent !== undefined) {
-    ({ type, amount } = decodeIndentsKey(keyOfMostUsedIndent));
-    indent = makeIndentString(type, amount);
-  }
+  const decoded = keyOfMostUsedIndent !== undefined ? decodeIndentsKey(keyOfMostUsedIndent) : undefined;
+  const type = decoded?.type;
+  const amount = decoded?.amount ?? 0;
+  const indent = decoded ? makeIndentString(type, amount) : "";
   return {
     amount,
     type,
@@ -823,7 +785,7 @@ function ensureSuffix(suffix, str) {
 function template(str, ...args) {
   return str.replace(/\{(\d+)\}/g, (match, key) => {
     const index = Number(key);
-    return Number.isNaN(index) ? match : args[index];
+    return Number.isNaN(index) || args[index] === undefined ? match : args[index];
   });
 }
 function truncate(str, length, end = "...") {
@@ -832,11 +794,15 @@ function truncate(str, length, end = "...") {
   return str.slice(0, length - end.length) + end;
 }
 function random(size = 16, dict = urlAlphabet) {
-  let id = "";
-  let i = size;
   const len = dict.length;
-  while (i--)
-    id += dict[Math.random() * len | 0];
+  const g = globalThis;
+  if (!g.crypto?.getRandomValues)
+    throw new Error("[strings.random] crypto.getRandomValues is not available; cannot generate secure random string.");
+  const bytes = new Uint8Array(size);
+  g.crypto.getRandomValues(bytes);
+  let id = "";
+  for (let i = 0;i < size; i++)
+    id += dict[(bytes[i] ?? 0) % len];
   return id;
 }
 function slug(str, options) {
@@ -942,7 +908,312 @@ var Str = {
   }
 };
 var str = Str;
+
+// src/validators.ts
+function isEmail(email) {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+function isStrongPassword(password) {
+  if (password.length < 8)
+    return false;
+  const hasUpperCase = /[A-Z]/.test(password);
+  const hasLowerCase = /[a-z]/.test(password);
+  const hasNumber = /\d/.test(password);
+  const hasSymbol = /[!@#$%^&*()_+\-=[\]{};':"\\|,.<>/?]/.test(password);
+  return hasUpperCase && hasLowerCase && hasNumber && hasSymbol;
+}
+function isAlphanumeric(str2) {
+  return /^[a-zA-Z0-9]+$/.test(str2);
+}
+function isURL(url) {
+  try {
+    const parsed = new URL(url);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}
+function isMobilePhone(phoneNumber) {
+  const phoneRegex = /^\+?[1-9]\d{6,14}$/;
+  const cleaned = phoneNumber.replace(/[\s()-]/g, "");
+  return phoneRegex.test(cleaned);
+}
+function isAlpha(str2) {
+  return /^[a-zA-Z]+$/.test(str2);
+}
+function isPostalCode(zipCode) {
+  const usZip = /^\d{5}(-\d{4})?$/;
+  const ukPostcode = /^[A-Z]{1,2}\d{1,2}[A-Z]?\s?\d[A-Z]{2}$/i;
+  const canadaPostcode = /^[A-Z]\d[A-Z]\s?\d[A-Z]\d$/i;
+  const generic = /^[a-zA-Z0-9]{3,10}$/;
+  return usZip.test(zipCode) || ukPostcode.test(zipCode) || canadaPostcode.test(zipCode) || generic.test(zipCode);
+}
+function isNumeric(str2) {
+  return /^\d+$/.test(str2);
+}
+function isHexColor(color) {
+  return /^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$/.test(color);
+}
+function isHexadecimal(hex) {
+  return /^[A-Fa-f0-9]+$/.test(hex);
+}
+function isBase64(base64) {
+  try {
+    return btoa(atob(base64)) === base64;
+  } catch {
+    return false;
+  }
+}
+function isUUID(uuid) {
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return uuidRegex.test(uuid);
+}
+function isJSON(json) {
+  try {
+    JSON.parse(json);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isCreditCard(creditCard) {
+  const cleaned = creditCard.replace(/[\s-]/g, "");
+  if (!/^\d{13,19}$/.test(cleaned))
+    return false;
+  let sum = 0;
+  let isEven = false;
+  for (let i = cleaned.length - 1;i >= 0; i--) {
+    let digit = parseInt(cleaned.charAt(i), 10);
+    if (isEven) {
+      digit *= 2;
+      if (digit > 9)
+        digit -= 9;
+    }
+    sum += digit;
+    isEven = !isEven;
+  }
+  return sum % 10 === 0;
+}
+function isISBN(isbn) {
+  const cleaned = isbn.replace(/[\s-]/g, "");
+  if (cleaned.length === 10) {
+    let sum = 0;
+    for (let i = 0;i < 9; i++) {
+      const digit = parseInt(cleaned.charAt(i), 10);
+      if (isNaN(digit))
+        return false;
+      sum += digit * (10 - i);
+    }
+    const checkChar = cleaned.charAt(9);
+    const checkDigit = checkChar === "X" ? 10 : parseInt(checkChar, 10);
+    if (isNaN(checkDigit) && checkChar !== "X")
+      return false;
+    sum += checkDigit;
+    return sum % 11 === 0;
+  }
+  if (cleaned.length === 13) {
+    let sum = 0;
+    for (let i = 0;i < 12; i++) {
+      const digit = parseInt(cleaned.charAt(i), 10);
+      if (isNaN(digit))
+        return false;
+      sum += digit * (i % 2 === 0 ? 1 : 3);
+    }
+    const checkDigit = parseInt(cleaned.charAt(12), 10);
+    if (isNaN(checkDigit))
+      return false;
+    return (10 - sum % 10) % 10 === checkDigit;
+  }
+  return false;
+}
+function isIP(ip) {
+  const ipv4Regex = /^(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+  if (ipv4Regex.test(ip))
+    return true;
+  const ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
+  return ipv6Regex.test(ip);
+}
+function isIPRange(ip) {
+  const parts = ip.split("/");
+  if (parts.length !== 2)
+    return false;
+  const [address, cidr] = parts;
+  if (address === undefined || cidr === undefined)
+    return false;
+  const cidrNum = parseInt(cidr, 10);
+  if (!isIP(address))
+    return false;
+  if (address.includes(":")) {
+    return cidrNum >= 0 && cidrNum <= 128;
+  } else {
+    return cidrNum >= 0 && cidrNum <= 32;
+  }
+}
+function isMACAddress(macAddress) {
+  const macRegex = /^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$/;
+  return macRegex.test(macAddress);
+}
+function isLatLong(latlong) {
+  const parts = latlong.split(",");
+  if (parts.length !== 2)
+    return false;
+  const lat = parseFloat((parts[0] ?? "").trim());
+  const long = parseFloat((parts[1] ?? "").trim());
+  return !isNaN(lat) && !isNaN(long) && lat >= -90 && lat <= 90 && long >= -180 && long <= 180;
+}
+function isCurrency(currency) {
+  const currencyRegex = /^[$\u00A3\u20AC\u00A5]?\d{1,3}(,?\d{3})*(\.\d{2})?$/;
+  return currencyRegex.test(currency.trim());
+}
+function isDataURI(dataURI) {
+  const dataURIRegex = /^data:([a-z]+\/[a-z0-9-+.]+(;[a-z-]+=[a-z0-9-]+)*)?;base64,([a-z0-9+/]+=*)/i;
+  return dataURIRegex.test(dataURI) || /^data:,/.test(dataURI);
+}
+function isMimeType(mimeType) {
+  const mimeTypeRegex = /^[a-z]+\/[a-z0-9\-+.]+$/i;
+  return mimeTypeRegex.test(mimeType);
+}
+function isJWT(jwt) {
+  const parts = jwt.split(".");
+  if (parts.length !== 3)
+    return false;
+  try {
+    parts.forEach((part) => {
+      atob(part.replace(/-/g, "+").replace(/_/g, "/"));
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isAscii(ascii) {
+  return /^[\x00-\x7F]*$/.test(ascii);
+}
+function isBase32(base32) {
+  return /^[A-Z2-7]+=*$/.test(base32.toUpperCase());
+}
+function isByteLength(str2, options) {
+  const min = options?.min ?? 0;
+  const max = options?.max ?? Infinity;
+  const byteLength = new TextEncoder().encode(str2).length;
+  return byteLength >= min && byteLength <= max;
+}
+function isFQDN(fqdn) {
+  const fqdnRegex = /^(?=.{1,253}$)((?!-)[A-Za-z0-9-]{1,63}(?<!-)\.)+[A-Za-z]{2,}$/;
+  return fqdnRegex.test(fqdn);
+}
+function isFullWidth(fullWidth) {
+  return /^[\uFF00-\uFFEF]+$/.test(fullWidth);
+}
+function isHalfWidth(halfWidth) {
+  return /^[\u0020-\u007E\uFF61-\uFF9F]+$/.test(halfWidth);
+}
+function isHash(hash, algorithm) {
+  const hashLengths = {
+    md5: 32,
+    sha1: 40,
+    sha256: 64,
+    sha384: 96,
+    sha512: 128
+  };
+  const expectedLength = hashLengths[algorithm];
+  if (!expectedLength)
+    return false;
+  return hash.length === expectedLength && /^[a-f0-9]+$/i.test(hash);
+}
+function isHSL(hsl) {
+  const hslRegex = /^hsl\(\s*(\d+)\s*,\s*(\d+(?:\.\d+)?%)\s*,\s*(\d+(?:\.\d+)?%)\s*\)$/;
+  return hslRegex.test(hsl);
+}
+function isIBAN(iban) {
+  const cleaned = iban.replace(/\s/g, "").toUpperCase();
+  if (!/^[A-Z]{2}\d{2}[A-Z0-9]+$/.test(cleaned))
+    return false;
+  if (cleaned.length < 15 || cleaned.length > 34)
+    return false;
+  const rearranged = cleaned.slice(4) + cleaned.slice(0, 4);
+  const digits = rearranged.split("").map((char) => {
+    const code = char.charCodeAt(0);
+    return code >= 65 && code <= 90 ? (code - 55).toString() : char;
+  }).join("");
+  let remainder = digits.slice(0, 2);
+  for (let i = 2;i < digits.length; i += 7) {
+    remainder = (parseInt(remainder + digits.slice(i, i + 7), 10) % 97).toString();
+  }
+  return parseInt(remainder, 10) === 1;
+}
+function isIdentityCard(identityCard) {
+  const cleaned = identityCard.replace(/[\s-]/g, "");
+  return /^[A-Z0-9]{5,20}$/i.test(cleaned);
+}
+function isISIN(isin) {
+  if (!/^[A-Z]{2}[A-Z0-9]{9}\d$/.test(isin))
+    return false;
+  const digits = isin.split("").map((char) => {
+    const code = char.charCodeAt(0);
+    return code >= 65 && code <= 90 ? (code - 55).toString() : char;
+  }).join("");
+  let sum = 0;
+  let isEven = true;
+  for (let i = digits.length - 1;i >= 0; i--) {
+    let digit = parseInt(digits.charAt(i), 10);
+    if (isEven) {
+      digit *= 2;
+      if (digit > 9)
+        digit -= 9;
+    }
+    sum += digit;
+    isEven = !isEven;
+  }
+  return sum % 10 === 0;
+}
+function isISO8601(iso8601) {
+  const iso8601Regex = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{3})?(Z|[+-]\d{2}:\d{2})?)?$/;
+  if (!iso8601Regex.test(iso8601))
+    return false;
+  try {
+    const date = new Date(iso8601);
+    return !isNaN(date.getTime());
+  } catch {
+    return false;
+  }
+}
+function isISRC(isrc) {
+  return /^[A-Z]{2}[A-Z0-9]{3}\d{2}\d{5}$/.test(isrc.replace(/-/g, ""));
+}
+function isISSN(issn) {
+  const cleaned = issn.replace(/[\s-]/g, "");
+  if (!/^\d{7}[\dX]$/.test(cleaned))
+    return false;
+  let sum = 0;
+  for (let i = 0;i < 7; i++) {
+    sum += parseInt(cleaned.charAt(i), 10) * (8 - i);
+  }
+  const checkChar = cleaned.charAt(7);
+  const checkDigit = checkChar === "X" ? 10 : parseInt(checkChar, 10);
+  sum += checkDigit;
+  return sum % 11 === 0;
+}
+function isISO31661Alpha2(iso31661Alpha2) {
+  return /^[A-Z]{2}$/.test(iso31661Alpha2);
+}
+function isISO31661Alpha3(iso31661Alpha3) {
+  return /^[A-Z]{3}$/.test(iso31661Alpha3);
+}
+function validateUsername(username) {
+  return isAlphanumeric(username);
+}
+function isLatitude(latitude) {
+  const lat = parseFloat(latitude);
+  return !isNaN(lat) && lat >= -90 && lat <= 90;
+}
+function isLongitude(longitude) {
+  const long = parseFloat(longitude);
+  return !isNaN(long) && long >= -180 && long <= 180;
+}
 export {
+  validateUsername,
   urlAlphabet,
   truncate,
   trainCase,
@@ -950,7 +1221,7 @@ export {
   titleCase,
   template,
   swapCase,
-  exports_string as string,
+  string2 as string,
   str,
   spongeCase,
   splitSeparateNumbers,
@@ -971,6 +1242,47 @@ export {
   noCase,
   lowercase,
   kebabCase,
+  isUUID,
+  isURL,
+  isStrongPassword,
+  isPostalCode,
+  isNumeric,
+  isMobilePhone,
+  isMimeType,
+  isMACAddress,
+  isLongitude,
+  isLatitude,
+  isLatLong,
+  isJWT,
+  isJSON,
+  isIdentityCard,
+  isISSN,
+  isISRC,
+  isISO8601,
+  isISO31661Alpha3,
+  isISO31661Alpha2,
+  isISIN,
+  isISBN,
+  isIPRange,
+  isIP,
+  isIBAN,
+  isHexadecimal,
+  isHexColor,
+  isHash,
+  isHalfWidth,
+  isHSL,
+  isFullWidth,
+  isFQDN,
+  isEmail,
+  isDataURI,
+  isCurrency,
+  isCreditCard,
+  isByteLength,
+  isBase64,
+  isBase32,
+  isAscii,
+  isAlphanumeric,
+  isAlpha,
   extendCharMap,
   ensureSuffix,
   ensurePrefix,