tldts 7.0.32 → 7.1.0

package/src/suffix-trie.ts

@@ -1,60 +1,174 @@
+// NOTE: kept (intentionally) near-identical to packages/tldts-icann/src/suffix-trie.ts.
+// They are separate copies rather than a shared helper because the lookup is
+// only fast when the typed arrays are module-scope monomorphic globals —
+// closing over them (a shared factory) measured ~20% slower. The ICANN build
+// also specializes (constant mask, no isIcann/isPrivate). Keep the two in sync.
 import {
   fastPathLookup,
   IPublicSuffix,
   ISuffixLookupOptions,
 } from 'tldts-core';
-import { exceptions, ITrie, rules } from './data/trie';
+import {
+  edgeChild,
+  edgeLength,
+  edgeStart,
+  exceptionsRoot,
+  labelText,
+  nodeFlags,
+  rulesRoot,
+} from './data/trie';
 
-// Flags used to know if a rule is ICANN or Private
 const enum RULE_TYPE {
   ICANN = 1,
   PRIVATE = 2,
 }
 
-interface IMatch {
-  index: number;
-  isIcann: boolean;
-  isPrivate: boolean;
+// `edgeOffset` (where each label starts in `labelText`), `edgeHash` (djb2 of
+// each label) and `wildcardEdge` (each node's '*' edge, or -1) are derived once
+// at load instead of being shipped: the bundle then carries only the
+// compressible `labelText` + structure, while the lookup binary-searches
+// integer hashes. The cost is a single ~1ms pass at first import — cheaper than
+// the object trie it replaces. Kept at module scope (not captured in a closure)
+// so V8 treats the typed arrays as fast monomorphic globals.
+const numberOfNodes = nodeFlags.length;
+const numberOfEdges = edgeLength.length;
+const edgeOffset = new Uint32Array(numberOfEdges);
+const edgeHash = new Uint32Array(numberOfEdges);
+const wildcardEdge = new Int32Array(numberOfNodes).fill(-1);
+for (let node = 0, offset = 0; node < numberOfNodes; node += 1) {
+  for (let edge = edgeStart[node]!; edge < edgeStart[node + 1]!; edge += 1) {
+    edgeOffset[edge] = offset;
+    const end = offset + edgeLength[edge]!;
+    let hash = 5381;
+    for (let i = end - 1; i >= offset; i -= 1) {
+      hash = (hash * 33) ^ labelText.charCodeAt(i);
+    }
+    edgeHash[edge] = hash >>> 0;
+    if (
+      edgeLength[edge] === 1 &&
+      labelText.charCodeAt(offset) === 42 /* '*' */
+    ) {
+      wildcardEdge[node] = edge;
+    }
+    offset = end;
+  }
 }
 
+// Result of the last `walk`, kept in module scope to avoid allocating a match
+// object. Safe because lookups are synchronous and read right after `walk`.
+let matchNode = -1;
+let matchStart = 0;
+let matchEnd = 0;
+
 /**
- * Lookup parts of domain in Trie
+ * True if edge `edge`'s label equals `hostname[start, start + length)`.
  */
-function lookupInTrie(
-  parts: string[],
-  trie: ITrie,
-  index: number,
-  allowedMask: number,
-): IMatch | null {
-  let result: IMatch | null = null;
-  let node: ITrie | undefined = trie;
-  while (node !== undefined) {
-    // We have a match!
-    if ((node[0] & allowedMask) !== 0) {
-      result = {
-        index: index + 1,
-        isIcann: (node[0] & RULE_TYPE.ICANN) !== 0,
-        isPrivate: (node[0] & RULE_TYPE.PRIVATE) !== 0,
-      };
+function labelEquals(
+  edge: number,
+  hostname: string,
+  start: number,
+  length: number,
+): boolean {
+  if (edgeLength[edge] !== length) {
+    return false;
+  }
+  const offset = edgeOffset[edge]!;
+  for (let i = 0; i < length; i += 1) {
+    if (labelText.charCodeAt(offset + i) !== hostname.charCodeAt(start + i)) {
+      return false;
     }
+  }
+  return true;
+}
 
-    // No more `parts` to look for
-    if (index === -1) {
-      break;
+/**
+ * Find the child edge of `node` whose label is `hostname[start, start + length)`.
+ * Edges are sorted by hash, so binary-search the hash then verify the label
+ * (scanning the rare run of equal hashes). Returns the edge index or -1.
+ */
+function findEdge(
+  node: number,
+  hash: number,
+  hostname: string,
+  start: number,
+  length: number,
+): number {
+  let lo = edgeStart[node]!;
+  let hi = edgeStart[node + 1]!;
+  while (lo < hi) {
+    const mid = (lo + hi) >>> 1;
+    const value = edgeHash[mid]!;
+    if (value < hash) {
+      lo = mid + 1;
+    } else if (value > hash) {
+      hi = mid;
+    } else {
+      for (let e = mid; e >= lo && edgeHash[e] === hash; e -= 1) {
+        if (labelEquals(e, hostname, start, length)) return e;
+      }
+      for (let e = mid + 1; e < hi && edgeHash[e] === hash; e += 1) {
+        if (labelEquals(e, hostname, start, length)) return e;
+      }
+      return -1;
     }
+  }
+  return -1;
+}
 
-    const succ: Record<string, ITrie> = node[1];
-    node = Object.prototype.hasOwnProperty.call(succ, parts[index]!)
-      ? succ[parts[index]!]
-      : succ['*'];
-    index -= 1;
+/**
+ * Walk `hostname`'s labels right-to-left from `root`, recording the deepest
+ * node whose flag passes `allowedMask` (with the label boundaries of that match
+ * in `matchStart`/`matchEnd`). Returns whether any match was found.
+ */
+function walk(hostname: string, root: number, allowedMask: number): boolean {
+  let node = root;
+  let end = hostname.length;
+  let hash = 5381;
+  matchNode = -1;
+  for (let i = hostname.length - 1; i >= 0; i -= 1) {
+    const code = hostname.charCodeAt(i);
+    if (code === 46 /* '.' */) {
+      const start = i + 1;
+      let edge = findEdge(node, hash >>> 0, hostname, start, end - start);
+      if (edge === -1) {
+        edge = wildcardEdge[node]!;
+      }
+      if (edge === -1) {
+        return matchNode !== -1;
+      }
+      node = edgeChild[edge]!;
+      if ((nodeFlags[node]! & allowedMask) !== 0) {
+        matchNode = node;
+        matchStart = start;
+        matchEnd = end;
+      }
+      end = i;
+      hash = 5381;
+    } else {
+      hash = (hash * 33) ^ code;
+    }
   }
 
-  return result;
+  // Left-most label: hostname[0, end). Same find/descend/record as the loop —
+  // duplicated rather than folded into the loop (via `i >= -1`) because that
+  // extra per-character branch measured slightly slower on the hot path.
+  let edge = findEdge(node, hash >>> 0, hostname, 0, end);
+  if (edge === -1) {
+    edge = wildcardEdge[node]!;
+  }
+  if (edge !== -1) {
+    node = edgeChild[edge]!;
+    if ((nodeFlags[node]! & allowedMask) !== 0) {
+      matchNode = node;
+      matchStart = 0;
+      matchEnd = end;
+    }
+  }
+  return matchNode !== -1;
 }
 
 /**
- * Check if `hostname` has a valid public suffix in `trie`.
+ * Check if `hostname` has a valid public suffix in the trie.
  */
 export default function suffixLookup(
   hostname: string,
@@ -65,46 +179,29 @@ export default function suffixLookup(
     return;
   }
 
-  const hostnameParts = hostname.split('.');
-
   const allowedMask =
     (options.allowPrivateDomains ? RULE_TYPE.PRIVATE : 0) |
     (options.allowIcannDomains ? RULE_TYPE.ICANN : 0);
 
-  // Look for exceptions
-  const exceptionMatch = lookupInTrie(
-    hostnameParts,
-    exceptions,
-    hostnameParts.length - 1,
-    allowedMask,
-  );
-
-  if (exceptionMatch !== null) {
-    out.isIcann = exceptionMatch.isIcann;
-    out.isPrivate = exceptionMatch.isPrivate;
-    out.publicSuffix = hostnameParts.slice(exceptionMatch.index + 1).join('.');
+  // Exceptions have priority and strip their own left-most label (e.g. the
+  // rule '!www.ck' makes the suffix of 'www.ck' be 'ck').
+  if (walk(hostname, exceptionsRoot, allowedMask)) {
+    out.isIcann = (nodeFlags[matchNode]! & RULE_TYPE.ICANN) !== 0;
+    out.isPrivate = (nodeFlags[matchNode]! & RULE_TYPE.PRIVATE) !== 0;
+    out.publicSuffix = hostname.slice(matchEnd + 1);
     return;
   }
 
-  // Look for a match in rules
-  const rulesMatch = lookupInTrie(
-    hostnameParts,
-    rules,
-    hostnameParts.length - 1,
-    allowedMask,
-  );
-
-  if (rulesMatch !== null) {
-    out.isIcann = rulesMatch.isIcann;
-    out.isPrivate = rulesMatch.isPrivate;
-    out.publicSuffix = hostnameParts.slice(rulesMatch.index).join('.');
+  if (walk(hostname, rulesRoot, allowedMask)) {
+    out.isIcann = (nodeFlags[matchNode]! & RULE_TYPE.ICANN) !== 0;
+    out.isPrivate = (nodeFlags[matchNode]! & RULE_TYPE.PRIVATE) !== 0;
+    out.publicSuffix = hostname.slice(matchStart);
     return;
   }
 
-  // No match found...
-  // Prevailing rule is '*' so we consider the top-level domain to be the
-  // public suffix of `hostname` (e.g.: 'example.org' => 'org').
+  // No match: the prevailing '*' rule makes the right-most label the suffix.
   out.isIcann = false;
   out.isPrivate = false;
-  out.publicSuffix = hostnameParts[hostnameParts.length - 1] ?? null;
+  const lastDot = hostname.lastIndexOf('.');
+  out.publicSuffix = lastDot === -1 ? hostname : hostname.slice(lastDot + 1);
 }