tldts-core 5.7.111 → 6.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tldts-core",
-  "version": "5.7.111",
+  "version": "6.0.0",
   "description": "tldts core primitives (internal module)",
   "author": {
     "name": "Rémi Berson"
@@ -45,7 +45,6 @@
   ],
   "scripts": {
     "clean": "rimraf dist",
-    "lint": "tslint --config ../../tslint.json --project ./tsconfig.json",
     "build": "tsc --build ./tsconfig.json",
     "bundle": "tsc --build ./tsconfig.bundle.json && rollup --config ./rollup.config.ts --configPlugin typescript",
     "prepack": "yarn run bundle",
@@ -56,16 +55,14 @@
     "@rollup/plugin-typescript": "^11.0.0",
     "@types/chai": "^4.2.18",
     "@types/mocha": "^10.0.0",
-    "@types/node": "^18.0.0",
+    "@types/node": "^18.15.11",
     "chai": "^4.2.0",
     "mocha": "^10.1.0",
     "nyc": "^15.0.1",
-    "rimraf": "^4.1.2",
-    "rollup": "^3.17.3",
+    "rimraf": "^4.4.1",
+    "rollup": "^3.20.2",
     "rollup-plugin-sourcemaps": "^0.6.1",
-    "tslint": "^6.0.0",
-    "tslint-config-prettier": "^1.18.0",
-    "typescript": "^4.3.2"
+    "typescript": "^5.0.3"
   },
-  "gitHead": "fcb5a1872b2a2ec312fba291aa164edcd7cdccc6"
+  "gitHead": "bc3d5270b8e60787816fa821680f175547c1008f"
 }

package/src/domain-without-suffix.ts

@@ -1,10 +1,12 @@
-
 /**
  * Return the part of domain without suffix.
  *
  * Example: for domain 'foo.com', the result would be 'foo'.
  */
-export default function getDomainWithoutSuffix(domain: string, suffix: string): string {
+export default function getDomainWithoutSuffix(
+  domain: string,
+  suffix: string,
+): string {
   // Note: here `domain` and `suffix` cannot have the same length because in
   // this case we set `domain` to `null` instead. It is thus safe to assume
   // that `suffix` is shorter than `domain`.

package/src/domain.ts

@@ -66,19 +66,28 @@ export default function getDomain(
   // Check if `hostname` ends with a member of `validHosts`.
   if (options.validHosts !== null) {
     const validHosts = options.validHosts;
-    for (let i = 0; i < validHosts.length; i += 1) {
-      const vhost = validHosts[i];
-      if (/*@__INLINE__*/ shareSameDomainSuffix(hostname, vhost) === true) {
+    for (const vhost of validHosts) {
+      if (/*@__INLINE__*/ shareSameDomainSuffix(hostname, vhost)) {
         return vhost;
       }
     }
   }
 
+  let numberOfLeadingDots = 0;
+  if (hostname.startsWith('.')) {
+    while (
+      numberOfLeadingDots < hostname.length &&
+      hostname[numberOfLeadingDots] === '.'
+    ) {
+      numberOfLeadingDots += 1;
+    }
+  }
+
   // If `hostname` is a valid public suffix, then there is no domain to return.
   // Since we already know that `getPublicSuffix` returns a suffix of `hostname`
   // there is no need to perform a string comparison and we only compare the
   // size.
-  if (suffix.length === hostname.length) {
+  if (suffix.length === hostname.length - numberOfLeadingDots) {
     return null;
   }
 

package/src/extract-hostname.ts

@@ -6,14 +6,14 @@ export default function extractHostname(
   url: string,
   urlIsValidHostname: boolean,
 ): string | null {
-  let start: number = 0;
+  let start = 0;
   let end: number = url.length;
-  let hasUpper: boolean = false;
+  let hasUpper = false;
 
   // If url is not already a valid hostname, then try to extract hostname.
-  if (urlIsValidHostname === false) {
+  if (!urlIsValidHostname) {
     // Special handling of data URLs
-    if (url.startsWith('data:') === true) {
+    if (url.startsWith('data:')) {
       return null;
     }
 
@@ -81,11 +81,15 @@ export default function extractHostname(
           for (let i = start; i < indexOfProtocol; i += 1) {
             const lowerCaseCode = url.charCodeAt(i) | 32;
             if (
-              ((lowerCaseCode >= 97 && lowerCaseCode <= 122) || // [a, z]
-              (lowerCaseCode >= 48 && lowerCaseCode <= 57) || // [0, 9]
-              lowerCaseCode === 46 || // '.'
-              lowerCaseCode === 45 || // '-'
-                lowerCaseCode === 43) === false // '+'
+              !(
+                (
+                  (lowerCaseCode >= 97 && lowerCaseCode <= 122) || // [a, z]
+                  (lowerCaseCode >= 48 && lowerCaseCode <= 57) || // [0, 9]
+                  lowerCaseCode === 46 || // '.'
+                  lowerCaseCode === 45 || // '-'
+                  lowerCaseCode === 43 // '+'
+                )
+              )
             ) {
               return null;
             }
@@ -103,9 +107,9 @@ export default function extractHostname(
     // Detect first occurrence of '/', '?' or '#'. We also keep track of the
     // last occurrence of '@', ']' or ':' to speed-up subsequent parsing of
     // (respectively), identifier, ipv6 or port.
-    let indexOfIdentifier: number = -1;
-    let indexOfClosingBracket: number = -1;
-    let indexOfPort: number = -1;
+    let indexOfIdentifier = -1;
+    let indexOfClosingBracket = -1;
+    let indexOfPort = -1;
     for (let i = start; i < end; i += 1) {
       const code: number = url.charCodeAt(i);
       if (

package/src/factory.ts

@@ -101,9 +101,9 @@ export function parseImpl(
   // set to `false` to speed-up parsing. If only URLs are expected then
   // `mixedInputs` can be set to `false`. The `mixedInputs` is only a hint
   // and will not change the behavior of the library.
-  if (options.extractHostname === false) {
+  if (!options.extractHostname) {
     result.hostname = url;
-  } else if (options.mixedInputs === true) {
+  } else if (options.mixedInputs) {
     result.hostname = extractHostname(url, isValidHostname(url));
   } else {
     result.hostname = extractHostname(url, false);
@@ -114,9 +114,9 @@ export function parseImpl(
   }
 
   // Check if `hostname` is a valid ip address
-  if (options.detectIp === true) {
+  if (options.detectIp) {
     result.isIp = isIp(result.hostname);
-    if (result.isIp === true) {
+    if (result.isIp) {
       return result;
     }
   }
@@ -124,9 +124,9 @@ export function parseImpl(
   // Perform optional hostname validation. If hostname is not valid, no need to
   // go further as there will be no valid domain or sub-domain.
   if (
-    options.validateHostname === true &&
-    options.extractHostname === true &&
-    isValidHostname(result.hostname) === false
+    options.validateHostname &&
+    options.extractHostname &&
+    !isValidHostname(result.hostname)
   ) {
     result.hostname = null;
     return result;

package/src/is-ip.ts

@@ -40,7 +40,7 @@ function isProbablyIpv6(hostname: string): boolean {
     return false;
   }
 
-  let start = hostname[0] === '[' ? 1 : 0;
+  let start = hostname.startsWith('[') ? 1 : 0;
   let end = hostname.length;
 
   if (hostname[end - 1] === ']') {
@@ -54,7 +54,7 @@ function isProbablyIpv6(hostname: string): boolean {
     return false;
   }
 
-  let hasColon: boolean = false;
+  let hasColon = false;
 
   for (; start < end; start += 1) {
     const code = hostname.charCodeAt(start);
@@ -62,10 +62,11 @@ function isProbablyIpv6(hostname: string): boolean {
     if (code === 58 /* ':' */) {
       hasColon = true;
     } else if (
-      ((code >= 48 && code <= 57) || // 0-9
+      !(
+        (code >= 48 && code <= 57) || // 0-9
         (code >= 97 && code <= 102) || // a-f
-        (code >= 65 && code <= 90)) === // A-F
-      false
+        (code >= 65 && code <= 90) // A-F
+      )
     ) {
       return false;
     }

package/src/is-valid.ts

@@ -28,13 +28,17 @@ export default function (hostname: string): boolean {
     return false;
   }
 
-  if (/*@__INLINE__*/ isValidAscii(hostname.charCodeAt(0)) === false) {
+  if (
+    /*@__INLINE__*/ !isValidAscii(hostname.charCodeAt(0)) &&
+    hostname.charCodeAt(0) !== 46 && // '.' (dot)
+    hostname.charCodeAt(0) !== 95 // '_' (underscore)
+  ) {
     return false;
   }
 
   // Validate hostname according to RFC
-  let lastDotIndex: number = -1;
-  let lastCharCode: number = -1;
+  let lastDotIndex = -1;
+  let lastCharCode = -1;
   const len = hostname.length;
 
   for (let i = 0; i < len; i += 1) {
@@ -55,8 +59,7 @@ export default function (hostname: string): boolean {
 
       lastDotIndex = i;
     } else if (
-      (/*@__INLINE__*/ isValidAscii(code) || code === 45 || code === 95) ===
-      false
+      !(/*@__INLINE__*/ (isValidAscii(code) || code === 45 || code === 95))
     ) {
       // Check if there is a forbidden character in the label
       return false;

package/src/lookup/fast-path.ts

@@ -1,13 +1,13 @@
 import { IPublicSuffix, ISuffixLookupOptions } from './interface';
 
-export default function(
+export default function (
   hostname: string,
   options: ISuffixLookupOptions,
   out: IPublicSuffix,
 ): boolean {
   // Fast path for very popular suffixes; this allows to by-pass lookup
   // completely as well as any extra allocation or string manipulation.
-  if (options.allowPrivateDomains === false && hostname.length > 3) {
+  if (!options.allowPrivateDomains && hostname.length > 3) {
     const last: number = hostname.length - 1;
     const c3: number = hostname.charCodeAt(last);
     const c2: number = hostname.charCodeAt(last - 1);