Repository: validatorjs/validator.js
Pull request #1633 (2021-03-20 03:48:25)

isISIN optimization
i was playing around and challenged myself to optimize `isISIN`. i'm not sure it's 100% there, but it's significantly more performant that it was.

```
$ node ./util.bench.js old-version
group times: [1390.93, 1344.84, 1396.37, 1426.44, 1408.29, 1373.00, 1517.00, 1381.53, 1372.97]
average per 100000: 1401.263
standard deviation of 9 intervals: 46.406
total: gc count: 1568, gc time: 137.500
done

$ node ./util.bench.js v3
group times: [211.69, 207.08, 213.71, 213.63, 214.08, 214.64, 213.91, 212.19, 213.39]
average per 100000: 212.703
standard deviation of 9 intervals: 2.168
total: gc count: 17, gc time: 3.633
done


## Checklist

- [x] PR contains only changes related; no stray files, etc.
- [x] README updated (where applicable) (NA)
- [x] Tests written (where applicable) (NA but one item added)


codecov[bot]: # [Codecov](https://codecov.io/gh/validatorjs/validator.js/pull/1633?src=pr&el=h1) Report
> Merging [#1633](https://codecov.io/gh/validatorjs/validator.js/pull/1633?src=pr&el=desc) (0891e68) into [master](https://codecov.io/gh/validatorjs/validator.js/commit/deb1d1ef79fd60dfc60e7894db345df51eb409ee?el=desc) (deb1d1e) will **not change** coverage.
> The diff coverage is `100.00%`.

[![Impacted file tree graph](https://codecov.io/gh/validatorjs/validator.js/pull/1633/graphs/tree.svg?width=650&height=150&src=pr&token=YzR3kbN1m2)](https://codecov.io/gh/validatorjs/validator.js/pull/1633?src=pr&el=tree)

```diff
@@            Coverage Diff            @@
##            master     #1633   +/-   ##
=========================================
  Coverage   100.00%   100.00%           
=========================================
  Files          100       100           
  Lines         1807      1852   +45     
=========================================
+ Hits          1807      1852   +45     
```


| [Impacted Files](https://codecov.io/gh/validatorjs/validator.js/pull/1633?src=pr&el=tree) | Coverage Δ | |
|---|---|---|
| [src/lib/isISIN.js](https://codecov.io/gh/validatorjs/validator.js/pull/1633/diff?src=pr&el=tree#diff-c3JjL2xpYi9pc0lTSU4uanM=) | `100.00% <100.00%> (ø)` | |
| [src/lib/isTaxID.js](https://codecov.io/gh/validatorjs/validator.js/pull/1633/diff?src=pr&el=tree#diff-c3JjL2xpYi9pc1RheElELmpz) | `100.00% <0.00%> (ø)` | |
| [src/lib/isLicensePlate.js](https://codecov.io/gh/validatorjs/validator.js/pull/1633/diff?src=pr&el=tree#diff-c3JjL2xpYi9pc0xpY2Vuc2VQbGF0ZS5qcw==) | `100.00% <0.00%> (ø)` | |
| [src/lib/isPassportNumber.js](https://codecov.io/gh/validatorjs/validator.js/pull/1633/diff?src=pr&el=tree#diff-c3JjL2xpYi9pc1Bhc3Nwb3J0TnVtYmVyLmpz) | `100.00% <0.00%> (ø)` | |
| [src/lib/isStrongPassword.js](https://codecov.io/gh/validatorjs/validator.js/pull/1633/diff?src=pr&el=tree#diff-c3JjL2xpYi9pc1N0cm9uZ1Bhc3N3b3JkLmpz) | `100.00% <0.00%> (ø)` | |

------

[Continue to review full report at Codecov](https://codecov.io/gh/validatorjs/validator.js/pull/1633?src=pr&el=continue).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/validatorjs/validator.js/pull/1633?src=pr&el=footer). Last update [deb1d1e...0891e68](https://codecov.io/gh/validatorjs/validator.js/pull/1633?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).


Patch:
diff --git a/README.md b/README.md
index d86ed5d..ab5ff55 100644
--- a/README.md
+++ b/README.md
@@ -115,12 +115,12 @@ Validator                               | Description
 **isHexColor(str)**                     | check if the string is a hexadecimal color.
 **isHSL(str)**                          | check if the string is an HSL (hue, saturation, lightness, optional alpha) color based on [CSS Colors Level 4 specification](https://developer.mozilla.org/en-US/docs/Web/CSS/color_value).<br/><br/>Comma-separated format supported. Space-separated format supported with the exception of a few edge cases (ex: `hsl(200grad+.1%62%/1)`).
 **isIBAN(str)**                         | check if a string is a IBAN (International Bank Account Number).
-**isIdentityCard(str [, locale])**      | check if the string is a valid identity card code.<br/><br/>`locale` is one of `['ES', 'IN', 'IT', 'NO', 'zh-TW', 'he-IL', 'ar-LY', 'ar-TN', 'zh-CN']` OR `'any'`. If 'any' is used, function will check if any of the locals match.<br/><br/>Defaults to 'any'.
+**isIdentityCard(str [, locale])**      | check if the string is a valid identity card code.<br/><br/>`locale` is one of `['ES', 'IN', 'IT', 'IR', 'NO', 'zh-TW', 'he-IL', 'ar-LY', 'ar-TN', 'zh-CN']` OR `'any'`. If 'any' is used, function will check if any of the locals match.<br/><br/>Defaults to 'any'.
 **isIMEI(str [, options]))**                         | check if the string is a valid IMEI number. Imei should be of format `###############` or `##-######-######-#`.<br/><br/>`options` is an object which can contain the keys `allow_hyphens`. Defaults to first format . If allow_hyphens is set to true, the validator will validate the second format.
 **isIn(str, values)**                   | check if the string is in a array of allowed values.
 **isInt(str [, options])**              | check if the string is an integer.<br/><br/>`options` is an object which can contain the keys `min` and/or `max` to check the integer is within boundaries (e.g. `{ min: 10, max: 99 }`). `options` can also contain the key `allow_leading_zeroes`, which when set to false will disallow integer values with leading zeroes (e.g. `{ allow_leading_zeroes: false }`). Finally, `options` can contain the keys `gt` and/or `lt` which will enforce integers being greater than or less than, respectively, the value provided (e.g. `{gt: 1, lt: 4}` for a number between 1 and 4).
 **isIP(str [, version])**               | check if the string is an IP (version 4 or 6).
-**isIPRange(str)**                      | check if the string is an IP Range(version 4 only).
+**isIPRange(str [, version])**          | check if the string is an IP Range (version 4 or 6).
 **isISBN(str [, version])**             | check if the string is an ISBN (version 10 or 13).
 **isISIN(str)**                         | check if the string is an [ISIN][ISIN] (stock/security identifier).
 **isISO8601(str)**                      | check if the string is a valid [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) date. <br/>`options` is an object which defaults to `{ strict: false, strictSeparator: false }`. If `strict` is true, date strings with invalid dates like `2009-02-29` will be invalid. If `strictSeparator` is true, date strings with date and time separated by anything other than a T will be invalid.
@@ -144,9 +144,9 @@ Validator                               | Description
 **isMultibyte(str)**                    | check if the string contains one or more multibyte chars.
 **isNumeric(str [, options])**                      | check if the string contains only numbers.<br/><br/>`options` is an object which defaults to `{no_symbols: false}` it also has locale as an option. If `no_symbols` is true, the validator will reject numeric strings that feature a symbol (e.g. `+`, `-`, or `.`).<br/><br/>`locale` determine the decimal separator and is one of `['ar', 'ar-AE', 'ar-BH', 'ar-DZ', 'ar-EG', 'ar-IQ', 'ar-JO', 'ar-KW', 'ar-LB', 'ar-LY', 'ar-MA', 'ar-QA', 'ar-QM', 'ar-SA', 'ar-SD', 'ar-SY', 'ar-TN', 'ar-YE', 'bg-BG', 'cs-CZ', 'da-DK', 'de-DE', 'en-AU', 'en-GB', 'en-HK', 'en-IN', 'en-NZ', 'en-US', 'en-ZA', 'en-ZM', 'es-ES', 'fr-FR', 'fr-CA', 'hu-HU', 'it-IT', 'nb-NO', 'nl-NL', 'nn-NO', 'pl-PL', 'pt-BR', 'pt-PT', 'ru-RU', 'sl-SI', 'sr-RS', 'sr-RS@latin', 'sv-SE', 'tr-TR', 'uk-UA']`.
 **isOctal(str)**                        | check if the string is a valid octal number.
-**isPassportNumber(str, countryCode)**    | check if the string is a valid passport number.<br/><br/>(countryCode is one of `[ 'AM', 'AR', 'AT', 'AU', 'BE', 'BG', 'BY', 'BR', 'CA', 'CH', 'CN', 'CY', 'CZ', 'DE', 'DK', 'DZ', 'EE', 'ES', 'FI', 'FR', 'GB', 'GR', 'HR', 'HU', 'IE' 'IN', 'IS', 'IT', 'JP', 'KR', 'LT', 'LU', 'LV', 'LY', 'MT', 'MY', 'NL', 'PO', 'PT', 'RO', 'RU', 'SE', 'SL', 'SK', 'TR', 'UA', 'US' ]`.
+**isPassportNumber(str, countryCode)**    | check if the string is a valid passport number.<br/><br/>(countryCode is one of `[ 'AM', 'AR', 'AT', 'AU', 'BE', 'BG', 'BY', 'BR', 'CA', 'CH', 'CN', 'CY', 'CZ', 'DE', 'DK', 'DZ', 'EE', 'ES', 'FI', 'FR', 'GB', 'GR', 'HR', 'HU', 'IE' 'IN', 'IR', 'IS', 'IT', 'JP', 'KR', 'LT', 'LU', 'LV', 'LY', 'MT', 'MY', 'NL', 'PO', 'PT', 'RO', 'RU', 'SE', 'SL', 'SK', 'TR', 'UA', 'US' ]`.
 **isPort(str)**                         | check if the string is a valid port number.
-**isPostalCode(str, locale)**           | check if the string is a postal code,<br/><br/>(locale is one of `[ 'AD', 'AT', 'AU', 'AZ', 'BE', 'BG', 'BR', 'BY', 'CA', 'CH', 'CN', 'CZ', 'DE', 'DK', 'DO', 'DZ', 'EE', 'ES', 'FI', 'FR', 'GB', 'GR', 'HR', 'HT', 'HU', 'ID', 'IE' 'IL', 'IN', 'IR', 'IS', 'IT', 'JP', 'KE', 'LI', 'LT', 'LU', 'LV', 'MT', 'MX', 'MY', 'NL', 'NO', 'NP', 'NZ', 'PL', 'PR', 'PT', 'RO', 'RU', 'SA', 'SE', 'SG', 'SI', 'TH', 'TN', 'TW', 'UA', 'US', 'ZA', 'ZM' ]` OR 'any'. If 'any' is used, function will check if any of the locals match. Locale list is `validator.isPostalCodeLocales`.).
+**isPostalCode(str, locale)**           | check if the string is a postal code,<br/><br/>(locale is one of `[ 'AD', 'AT', 'AU', 'AZ', 'BE', 'BG', 'BR', 'BY', 'CA', 'CH', 'CN', 'CZ', 'DE', 'DK', 'DO', 'DZ', 'EE', 'ES', 'FI', 'FR', 'GB', 'GR', 'HR', 'HT', 'HU', 'ID', 'IE' 'IL', 'IN', 'IR', 'IS', 'IT', 'JP', 'KE', 'KR', 'LI', 'LT', 'LU', 'LV', 'MT', 'MX', 'MY', 'NL', 'NO', 'NP', 'NZ', 'PL', 'PR', 'PT', 'RO', 'RU', 'SA', 'SE', 'SG', 'SI', 'TH', 'TN', 'TW', 'UA', 'US', 'ZA', 'ZM' ]` OR 'any'. If 'any' is used, function will check if any of the locals match. Locale list is `validator.isPostalCodeLocales`.).
 **isRFC3339(str)**                      | check if the string is a valid [RFC 3339](https://tools.ietf.org/html/rfc3339) date.
 **isRgbColor(str [, includePercentValues])**                     | check if the string is a rgb or rgba color.<br/><br/>`includePercentValues` defaults to `true`. If you don't want to allow to set `rgb` or `rgba` values with percents, like `rgb(5%,5%,5%)`, or `rgba(90%,90%,90%,.3)`, then set it to false.
 **isSemVer(str)**                       | check if the string is a Semantic Versioning Specification (SemVer).
diff --git a/src/lib/isBIC.js b/src/lib/isBIC.js
index 1420da6..240bfe1 100644
--- a/src/lib/isBIC.js
+++ b/src/lib/isBIC.js
@@ -1,8 +1,17 @@
 import assertString from './util/assertString';
+import { CountryCodes } from './isISO31661Alpha2';
 
-const isBICReg = /^[A-z]{4}[A-z]{2}\w{2}(\w{3})?$/;
+// https://en.wikipedia.org/wiki/ISO_9362
+const isBICReg = /^[A-Za-z]{6}[A-Za-z0-9]{2}([A-Za-z0-9]{3})?$/;
 
 export default function isBIC(str) {
   assertString(str);
+
+  // toUpperCase() should be removed when a new major version goes out that changes
+  // the regex to [A-Z] (per the spec).
+  if (CountryCodes.indexOf(str.slice(4, 6).toUpperCase()) < 0) {
+    return false;
+  }
+
   return isBICReg.test(str);
 }
diff --git a/src/lib/isIP.js b/src/lib/isIP.js
index a9a8057..25856ca 100644
--- a/src/lib/isIP.js
+++ b/src/lib/isIP.js
@@ -28,86 +28,37 @@ import assertString from './util/assertString';
    where the interface "ne0" belongs to the 1st link, "pvc1.3" belongs
    to the 5th link, and "interface10" belongs to the 10th organization.
  * * */
-const ipv4Maybe = /^(([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/;
-const ipv6Block = /^[0-9A-F]{1,4}$/i;
+const IPv4SegmentFormat = '(?:[0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])';
+const IPv4AddressFormat = `(${IPv4SegmentFormat}[.]){3}${IPv4SegmentFormat}`;
+const IPv4AddressRegExp = new RegExp(`^${IPv4AddressFormat}$`);
+
+const IPv6SegmentFormat = '(?:[0-9a-fA-F]{1,4})';
+const IPv6AddressRegExp = new RegExp('^(' +
+  `(?:${IPv6SegmentFormat}:){7}(?:${IPv6SegmentFormat}|:)|` +
+  `(?:${IPv6SegmentFormat}:){6}(?:${IPv4AddressFormat}|:${IPv6SegmentFormat}|:)|` +
+  `(?:${IPv6SegmentFormat}:){5}(?::${IPv4AddressFormat}|(:${IPv6SegmentFormat}){1,2}|:)|` +
+  `(?:${IPv6SegmentFormat}:){4}(?:(:${IPv6SegmentFormat}){0,1}:${IPv4AddressFormat}|(:${IPv6SegmentFormat}){1,3}|:)|` +
+  `(?:${IPv6SegmentFormat}:){3}(?:(:${IPv6SegmentFormat}){0,2}:${IPv4AddressFormat}|(:${IPv6SegmentFormat}){1,4}|:)|` +
+  `(?:${IPv6SegmentFormat}:){2}(?:(:${IPv6SegmentFormat}){0,3}:${IPv4AddressFormat}|(:${IPv6SegmentFormat}){1,5}|:)|` +
+  `(?:${IPv6SegmentFormat}:){1}(?:(:${IPv6SegmentFormat}){0,4}:${IPv4AddressFormat}|(:${IPv6SegmentFormat}){1,6}|:)|` +
+  `(?::((?::${IPv6SegmentFormat}){0,5}:${IPv4AddressFormat}|(?::${IPv6SegmentFormat}){1,7}|:))` +
+  ')(%[0-9a-zA-Z-.:]{1,})?$');
 
 export default function isIP(str, version = '') {
   assertString(str);
   version = String(version);
   if (!version) {
     return isIP(str, 4) || isIP(str, 6);
-  } else if (version === '4') {
-    if (!ipv4Maybe.test(str)) {
+  }
+  if (version === '4') {
+    if (!IPv4AddressRegExp.test(str)) {
       return false;
     }
     const parts = str.split('.').sort((a, b) => a - b);
     return parts[3] <= 255;
-  } else if (version === '6') {
-    let addressAndZone = [str];
-    // ipv6 addresses could have scoped architecture
-    // according to https://tools.ietf.org/html/rfc4007#section-11
-    if (str.includes('%')) {
-      addressAndZone = str.split('%');
-      if (addressAndZone.length !== 2) {
-        // it must be just two parts
-        return false;
-      }
-      if (!addressAndZone[0].includes(':')) {
-        // the first part must be the address
-        return false;
-      }
-
-      if (addressAndZone[1] === '') {
-        // the second part must not be empty
-        return false;
-      }
-    }
-
-    const blocks = addressAndZone[0].split(':');
-    let foundOmissionBlock = false; // marker to indicate ::
-
-    // At least some OS accept the last 32 bits of an IPv6 address
-    // (i.e. 2 of the blocks) in IPv4 notation, and RFC 3493 says
-    // that '::ffff:a.b.c.d' is valid for IPv4-mapped IPv6 addresses,
-    // and '::a.b.c.d' is deprecated, but also valid.
-    const foundIPv4TransitionBlock = isIP(blocks[blocks.length - 1], 4);
-    const expectedNumberOfBlocks = foundIPv4TransitionBlock ? 7 : 8;
-
-    if (blocks.length > expectedNumberOfBlocks) {
-      return false;
-    }
-    // initial or final ::
-    if (str === '::') {
-      return true;
-    } else if (str.substr(0, 2) === '::') {
-      blocks.shift();
-      blocks.shift();
-      foundOmissionBlock = true;
-    } else if (str.substr(str.length - 2) === '::') {
-      blocks.pop();
-      blocks.pop();
-      foundOmissionBlock = true;
-    }
-
-    for (let i = 0; i < blocks.length; ++i) {
-      // test for a :: which can not be at the string start/end
-      // since those cases have been handled above
-      if (blocks[i] === '' && i > 0 && i < blocks.length - 1) {
-        if (foundOmissionBlock) {
-          return false; // multiple :: in address
-        }
-        foundOmissionBlock = true;
-      } else if (foundIPv4TransitionBlock && i === blocks.length - 1) {
-        // it has been checked before that the last
-        // block is a valid IPv4 address
-      } else if (!ipv6Block.test(blocks[i])) {
-        return false;
-      }
-    }
-    if (foundOmissionBlock) {
-      return blocks.length >= 1;
-    }
-    return blocks.length === expectedNumberOfBlocks;
+  }
+  if (version === '6') {
+    return !!IPv6AddressRegExp.test(str);
   }
   return false;
 }
diff --git a/src/lib/isIPRange.js b/src/lib/isIPRange.js
index ffb4e1a..5bb6916 100644
--- a/src/lib/isIPRange.js
+++ b/src/lib/isIPRange.js
@@ -1,9 +1,11 @@
 import assertString from './util/assertString';
 import isIP from './isIP';
 
-const subnetMaybe = /^\d{1,2}$/;
+const subnetMaybe = /^\d{1,3}$/;
+const v4Subnet = 32;
+const v6Subnet = 128;
 
-export default function isIPRange(str) {
+export default function isIPRange(str, version = '') {
   assertString(str);
   const parts = str.split('/');
 
@@ -21,5 +23,25 @@ export default function isIPRange(str) {
     return false;
   }
 
-  return isIP(parts[0], 4) && parts[1] <= 32 && parts[1] >= 0;
+  const isValidIP = isIP(parts[0], version);
+  if (!isValidIP) {
+    return false;
+  }
+
+  // Define valid subnet according to IP's version
+  let expectedSubnet = null;
+  switch (String(version)) {
+    case '4':
+      expectedSubnet = v4Subnet;
+      break;
+
+    case '6':
+      expectedSubnet = v6Subnet;
+      break;
+
+    default:
+      expectedSubnet = isIP(parts[0], '6') ? v6Subnet : v4Subnet;
+  }
+
+  return parts[1] <= expectedSubnet && parts[1] >= 0;
 }
diff --git a/src/lib/isISIN.js b/src/lib/isISIN.js
index 4576b68..a6f6fa6 100644
--- a/src/lib/isISIN.js
+++ b/src/lib/isISIN.js
@@ -2,6 +2,12 @@ import assertString from './util/assertString';
 
 const isin = /^[A-Z]{2}[0-9A-Z]{9}[0-9]$/;
 
+// this link details how the check digit is calculated:
+// https://www.isin.org/isin-format/. it is a little bit
+// odd in that it works with digits, not numbers. in order
+// to make only one pass through the ISIN characters, the
+// each alpha character is handled as 2 characters within
+// the loop.
 
 export default function isISIN(str) {
   assertString(str);
@@ -9,27 +15,44 @@ export default function isISIN(str) {
     return false;
   }
 
-  const checksumStr = str.replace(/[A-Z]/g, character => (parseInt(character, 36)));
-
+  let double = true;
   let sum = 0;
-  let digit;
-  let tmpNum;
-  let shouldDouble = true;
-  for (let i = checksumStr.length - 2; i >= 0; i--) {
-    digit = checksumStr.substring(i, (i + 1));
-    tmpNum = parseInt(digit, 10);
-    if (shouldDouble) {
-      tmpNum *= 2;
-      if (tmpNum >= 10) {
-        sum += tmpNum + 1;
-      } else {
-        sum += tmpNum;
+  // convert values
+  for (let i = str.length - 2; i >= 0; i--) {
+    if (str[i] >= 'A' && str[i] <= 'Z') {
+      const value = str[i].charCodeAt(0) - 55;
+      const lo = value % 10;
+      const hi = Math.trunc(value / 10);
+      // letters have two digits, so handle the low order
+      // and high order digits separately.
+      for (const digit of [lo, hi]) {
+        if (double) {
+          if (digit >= 5) {
+            sum += 1 + ((digit - 5) * 2);
+          } else {
+            sum += digit * 2;
+          }
+        } else {
+          sum += digit;
+        }
+        double = !double;
       }
     } else {
-      sum += tmpNum;
+      const digit = str[i].charCodeAt(0) - '0'.charCodeAt(0);
+      if (double) {
+        if (digit >= 5) {
+          sum += 1 + ((digit - 5) * 2);
+        } else {
+          sum += digit * 2;
+        }
+      } else {
+        sum += digit;
+      }
+      double = !double;
     }
-    shouldDouble = !shouldDouble;
   }
 
-  return parseInt(str.substr(str.length - 1), 10) === (10000 - sum) % 10;
+  const check = (Math.trunc(((sum + 9) / 10)) * 10) - sum;
+
+  return +str[str.length - 1] === check;
 }
diff --git a/src/lib/isISO31661Alpha2.js b/src/lib/isISO31661Alpha2.js
index ee1c33a..e91ae87 100644
--- a/src/lib/isISO31661Alpha2.js
+++ b/src/lib/isISO31661Alpha2.js
@@ -1,5 +1,4 @@
 import assertString from './util/assertString';
-import includes from './util/includes';
 
 // from https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
 const validISO31661Alpha2CountriesCodes = [
@@ -32,5 +31,7 @@ const validISO31661Alpha2CountriesCodes = [
 
 export default function isISO31661Alpha2(str) {
   assertString(str);
-  return includes(validISO31661Alpha2CountriesCodes, str.toUpperCase());
+  return validISO31661Alpha2CountriesCodes.indexOf(str.toUpperCase()) >= 0;
 }
+
+export const CountryCodes = validISO31661Alpha2CountriesCodes;
diff --git a/src/lib/isIdentityCard.js b/src/lib/isIdentityCard.js
index c24054b..872ff19 100644
--- a/src/lib/isIdentityCard.js
+++ b/src/lib/isIdentityCard.js
@@ -75,6 +75,25 @@ const validators = {
 
     return c === 0;
   },
+  IR: (str) => {
+    if (!str.match(/^\d{10}$/)) return false;
+    str = (`0000${str}`).substr(str.length - 6);
+
+    if (parseInt(str.substr(3, 6), 10) === 0) return false;
+
+    const lastNumber = parseInt(str.substr(9, 1), 10);
+    let sum = 0;
+
+    for (let i = 0; i < 9; i++) {
+      sum += parseInt(str.substr(i, 1), 10) * (10 - i);
+    }
+
+    sum %= 11;
+
+    return (
+      (sum < 2 && lastNumber === sum) || (sum >= 2 && lastNumber === 11 - sum)
+    );
+  },
   IT: function IT(str) {
     if (str.length !== 9) return false;
     if (str === 'CA00000AA') return false; // https://it.wikipedia.org/wiki/Carta_d%27identit%C3%A0_elettronica_italiana
diff --git a/src/lib/isLocale.js b/src/lib/isLocale.js
index ab66e5c..cacac8a 100644
--- a/src/lib/isLocale.js
+++ b/src/lib/isLocale.js
@@ -1,6 +1,6 @@
 import assertString from './util/assertString';
 
-const localeReg = /^[A-z]{2,4}([_-]([A-z]{4}|[\d]{3}))?([_-]([A-z]{2}|[\d]{3}))?$/;
+const localeReg = /^[A-Za-z]{2,4}([_-]([A-Za-z]{4}|[\d]{3}))?([_-]([A-Za-z]{2}|[\d]{3}))?$/;
 
 export default function isLocale(str) {
   assertString(str);
diff --git a/src/lib/isMobilePhone.js b/src/lib/isMobilePhone.js
index 207dae7..ed1f6d2 100644
--- a/src/lib/isMobilePhone.js
+++ b/src/lib/isMobilePhone.js
@@ -46,7 +46,7 @@ const phones = {
   'en-PK': /^((\+92)|(0092))-{0,1}\d{3}-{0,1}\d{7}$|^\d{11}$|^\d{4}-\d{7}$/,
   'en-PH': /^(09|\+639)\d{9}$/,
   'en-RW': /^(\+?250|0)?[7]\d{8}$/,
-  'en-SG': /^(\+65)?[689]\d{7}$/,
+  'en-SG': /^(\+65)?[3689]\d{7}$/,
   'en-SL': /^(?:0|94|\+94)?(7(0|1|2|5|6|7|8)( |-)?\d)\d{6}$/,
   'en-TZ': /^(\+?255|0)?[67]\d{8}$/,
   'en-UG': /^(\+?256|0)?[7]\d{8}$/,
diff --git a/src/lib/isPassportNumber.js b/src/lib/isPassportNumber.js
index 3572abd..ceda6ff 100644
--- a/src/lib/isPassportNumber.js
+++ b/src/lib/isPassportNumber.js
@@ -33,6 +33,7 @@ const passportRegexByCountryCode = {
   HU: /^[A-Z]{2}(\d{6}|\d{7})$/, // HUNGARY
   IE: /^[A-Z0-9]{2}\d{7}$/, // IRELAND
   IN: /^[A-Z]{1}-?\d{7}$/, // INDIA
+  IR: /^[A-Z]\d{8}$/, // IRAN
   IS: /^(A)\d{7}$/, // ICELAND
   IT: /^[A-Z0-9]{2}\d{7}$/, // ITALY
   JP: /^[A-Z]{2}\d{7}$/, // JAPAN
diff --git a/src/lib/isPostalCode.js b/src/lib/isPostalCode.js
index 23b3734..915c27f 100644
--- a/src/lib/isPostalCode.js
+++ b/src/lib/isPostalCode.js
@@ -33,7 +33,7 @@ const patterns = {
   HT: /^HT\d{4}$/,
   HU: fourDigit,
   ID: fiveDigit,
-  IE: /^(?!.*(?:o))[A-z]\d[\dw]\s\w{4}$/i,
+  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: /\b(?!(\d)\1{3})[13-9]{4}[1346-9][013-9]{5}\b/,
@@ -41,6 +41,7 @@ const patterns = {
   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,


Test patch:
diff --git a/test/validators.js b/test/validators.js
index 4a4180a..1f92e14 100644
--- a/test/validators.js
+++ b/test/validators.js
@@ -771,6 +771,7 @@ describe('Validators', () => {
         '1.2.3.4',
         '::1',
         '2001:db8:0000:1:1:1:1:1',
+        '2001:db8:3:4::192.0.2.33',
         '2001:41d0:2:a141::1',
         '::ffff:127.0.0.1',
         '::0000',
@@ -779,8 +780,33 @@ describe('Validators', () => {
         '1111:1:1:1:1:1:1:1',
         'fe80::a6db:30ff:fe98:e946',
         '::',
+        '::8',
         '::ffff:127.0.0.1',
+        '::ffff:255.255.255.255',
+        '::ffff:0:255.255.255.255',
+        '::2:3:4:5:6:7:8',
+        '::255.255.255.255',
         '0:0:0:0:0:ffff:127.0.0.1',
+        '1:2:3:4:5:6:7::',
+        '1:2:3:4:5:6::8',
+        '1::7:8',
+        '1:2:3:4:5::7:8',
+        '1:2:3:4:5::8',
+        '1::6:7:8',
+        '1:2:3:4::6:7:8',
+        '1:2:3:4::8',
+        '1::5:6:7:8',
+        '1:2:3::5:6:7:8',
+        '1:2:3::8',
+        '1::4:5:6:7:8',
+        '1:2::4:5:6:7:8',
+        '1:2::8',
+        '1::3:4:5:6:7:8',
+        '1::8',
+        'fe80::7:8%eth0',
+        'fe80::7:8%1',
+        '64:ff9b::192.0.2.33',
+        '0:0:0:0:0:0:10.0.0.1',
       ],
       invalid: [
         'abc',
@@ -872,18 +898,88 @@ describe('Validators', () => {
         '127.0.0.1/24',
         '0.0.0.0/0',
         '255.255.255.0/32',
+        '::/0',
+        '::/128',
+        '2001::/128',
+        '2001:800::/128',
+        '::ffff:127.0.0.1/128',
       ],
       invalid: [
+        'abc',
         '127.200.230.1/35',
         '127.200.230.1/-1',
         '1.1.1.1/011',
-        '::1/64',
         '1.1.1/24.1',
         '1.1.1.1/01',
         '1.1.1.1/1.1',
         '1.1.1.1/1.',
         '1.1.1.1/1/1',
         '1.1.1.1',
+        '::1',
+        '::1/164',
+        '2001::/240',
+        '2001::/-1',
+        '2001::/001',
+        '2001::/24.1',
+        '2001:db8:0000:1:1:1:1:1',
+        '::ffff:127.0.0.1',
+      ],
+    });
+    test({
+      validator: 'isIPRange',
+      args: [4],
+      valid: [
+        '127.0.0.1/1',
+        '0.0.0.0/1',
+        '255.255.255.255/1',
+        '1.2.3.4/1',
+        '255.0.0.1/1',
+        '0.0.1.1/1',
+      ],
+      invalid: [
+        'abc',
+        '::1',
+        '2001:db8:0000:1:1:1:1:1',
+        '::ffff:127.0.0.1',
+        '137.132.10.01',
+        '0.256.0.256',
+        '255.256.255.256',
+      ],
+    });
+    test({
+      validator: 'isIPRange',
+      args: [6],
+      valid: [
+        '::1/1',
+        '2001:db8:0000:1:1:1:1:1/1',
+        '::ffff:127.0.0.1/1',
+      ],
+      invalid: [
+        'abc',
+        '127.0.0.1',
+        '0.0.0.0',
+        '255.255.255.255',
+        '1.2.3.4',
+        '::ffff:287.0.0.1',
+        '::ffff:287.0.0.1/254',
+        '%',
+        'fe80::1234%',
+        'fe80::1234%1%3%4',
+        'fe80%fe80%',
+      ],
+    });
+    test({
+      validator: 'isIPRange',
+      args: [10],
+      valid: [],
+      invalid: [
+        'abc',
+        '127.0.0.1/1',
+        '0.0.0.0/1',
+        '255.255.255.255/1',
+        '1.2.3.4/1',
+        '::1/1',
+        '2001:db8:0000:1:1:1:1:1/1',
       ],
     });
   });
@@ -2553,6 +2649,21 @@ describe('Validators', () => {
       ],
     });
 
+    test({
+      validator: 'isPassportNumber',
+      args: ['IR'],
+      valid: [
+        'J97634522',
+        'A01234567',
+        'Z11977831',
+      ],
+      invalid: [
+        'A0123456',
+        'A0123456Z',
+        '012345678',
+      ],
+    });
+
     test({
       validator: 'isPassportNumber',
       args: ['IS'],
@@ -4475,6 +4586,31 @@ describe('Validators', () => {
           'X1234567L',
         ],
       },
+      {
+        locale: 'IR',
+        valid: [
+          '0499370899',
+          '0790419904',
+          '0084575948',
+          '0963695398',
+          '0684159414',
+          '0067749828',
+          '0650451252',
+          '1583250689',
+          '4032152314',
+          '0076229645',
+          '4271467685',
+          '0200203241',
+        ],
+        invalid: [
+          '1260293040',
+          '0000000001',
+          '1999999999',
+          '9999999991',
+          'AAAAAAAAAA',
+          '0684159415',
+        ],
+      },
       {
         locale: 'IT',
         valid: [
@@ -4709,6 +4845,7 @@ describe('Validators', () => {
         'GB0001411924',
         'DE000WCH8881',
         'PLLWBGD00016',
+        'US0378331005',
       ],
       invalid: [
         'DE000BAY0018',
@@ -6263,6 +6400,7 @@ describe('Validators', () => {
       {
         locale: 'en-SG',
         valid: [
+          '32891278',
           '87654321',
           '98765432',
           '+6587654321',
@@ -6270,6 +6408,7 @@ describe('Validators', () => {
           '+6565241234',
         ],
         invalid: [
+          '332891231',
           '987654321',
           '876543219',
           '8765432',
@@ -9503,6 +9642,17 @@ describe('Validators', () => {
           'ab1234',
         ],
       },
+      {
+        locale: 'KR',
+        valid: [
+          '17008',
+          '339012',
+        ],
+        invalid: [
+          '1412347',
+          'ab1234',
+        ],
+      },
     ];
 
     let allValid = [];