@elliemae/encw-heap-doctor 26.2.1

package/dist/cjs/analysis/patternMatcher.js

@@ -0,0 +1,198 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var patternMatcher_exports = {};
+__export(patternMatcher_exports, {
+  PatternMatcher: () => PatternMatcher
+});
+module.exports = __toCommonJS(patternMatcher_exports);
+var import_formatUtils = require("../utils/formatUtils.js");
+class PatternMatcher {
+  static KNOWN_PATTERNS = [
+    {
+      id: "gtm-datalayer",
+      name: "Google Tag Manager Data Layer",
+      detect(steps) {
+        return steps.some(
+          (s) => (s.edge ?? "").includes("gtmDataLayer") || s.label.includes("gtmDataLayer")
+        );
+      },
+      why(steps) {
+        const elStep = steps.find(
+          (s) => (s.edge ?? "").startsWith("gtm.element")
+        );
+        const rawLabel = elStep?.label.replace(/^gtm\.element\s+in\s+/, "") ?? "";
+        const el = elStep ? import_formatUtils.FormatUtils.truncate(rawLabel, 80) : "a DOM element";
+        return `Google Tag Manager (GTM) captured a reference to ${el} via "gtm.element" in window.dataLayer. GTM click/form tracking stores the event target in the data layer, and these references persist indefinitely \u2014 preventing the element and its entire subtree from being garbage collected.`;
+      },
+      fixes: [
+        "Configure GTM to not capture element references in click/form triggers",
+        "Periodically trim stale entries: window.dataLayer = window.dataLayer.slice(-50)",
+        "Use CSS selectors or element IDs in GTM triggers instead of element references",
+        "Add cleanup that nullifies gtm.element on stale dataLayer entries"
+      ]
+    },
+    {
+      id: "angularjs-scope",
+      name: "AngularJS Scope / Watcher Leak",
+      detect(steps) {
+        return steps.some((s) => {
+          const e = s.edge ?? "";
+          const l = s.label;
+          return e.includes("$scope") || e.includes("$$watchers") || l.includes("$scope") || l.includes("$$watchers");
+        });
+      },
+      why(steps) {
+        const ctrlStep = steps.find((s) => s.label.includes("Controller"));
+        const ctrl = ctrlStep ? import_formatUtils.FormatUtils.truncate(ctrlStep.label, 60) : "a controller";
+        return `An AngularJS $scope from ${ctrl} was not destroyed when the component was removed. Its $$watchers hold closures that still reference DOM elements, keeping them alive after removal from the document.`;
+      },
+      fixes: [
+        "Call $scope.$destroy() when the directive/component is removed",
+        "Deregister $watch listeners by calling the returned deregistration function",
+        'Ensure $on("$destroy", cleanup) handlers are properly registered',
+        "Upgrade from AngularJS to a modern framework with automatic cleanup"
+      ]
+    },
+    {
+      id: "angularjs-cache",
+      name: "AngularJS Element Cache",
+      detect(steps) {
+        const hasAngular = steps.some(
+          (s) => (s.edge ?? "") === "angular" || s.label.includes("angular")
+        );
+        const hasCache = steps.some(
+          (s) => (s.edge ?? "") === "cache" || s.label.includes("in cache")
+        );
+        return hasAngular && hasCache;
+      },
+      why() {
+        return `AngularJS's internal element cache (angular.element.cache) stores data and event handlers for DOM elements. When elements are removed without proper AngularJS cleanup ($destroy), their cache entries persist indefinitely \u2014 keeping detached DOM nodes alive.`;
+      },
+      fixes: [
+        "Use angular.element(el).remove() instead of native DOM removal to trigger cache cleanup",
+        "Ensure directives call element.off() and scope.$destroy() in $destroy handlers",
+        "Monitor angular.element.cache size for growth in long-running SPAs"
+      ]
+    },
+    {
+      id: "react-fiber",
+      name: "React Component Tree Retention",
+      detect(steps) {
+        return steps.some((s) => {
+          const e = s.edge ?? "";
+          return e.startsWith("__reactFiber") || e === "stateNode" || e.startsWith("__reactInternalInstance");
+        });
+      },
+      why(steps) {
+        const depth = steps.filter(
+          (s) => s.edge === "return" || s.edge === "child" || s.edge === "memoizedState"
+        ).length;
+        return `A React Fiber node retains the detached DOM element through its internal tree structure (${depth} hops via return/child/memoizedState pointers). This typically means a parent component holds a ref or state that outlives the child element.`;
+      },
+      fixes: [
+        "Return cleanup functions from useEffect to release references on unmount",
+        "Set refs to null in cleanup: useEffect(() => () => { ref.current = null })",
+        "Guard async setState: if (!cancelled) setState(...)",
+        "Check for missing dependency arrays in useEffect"
+      ]
+    },
+    {
+      id: "event-listener",
+      name: "Forgotten Event Listener",
+      detect(steps) {
+        return steps.some((s) => {
+          const l = s.label.toLowerCase();
+          const e = (s.edge ?? "").toLowerCase();
+          return l.includes("listener") || l.includes("eventlistener") || e.includes("listener");
+        });
+      },
+      why() {
+        return `An event listener callback holds a closure reference to detached DOM nodes. The listener was not removed when the element was detached from the document.`;
+      },
+      fixes: [
+        "Call removeEventListener with the same function reference on cleanup",
+        "Use { once: true } for one-shot event listeners",
+        "Use AbortController.signal to bulk-remove listeners on cleanup",
+        "In React: clean up listeners in the useEffect return function"
+      ]
+    },
+    {
+      id: "timer-leak",
+      name: "Timer / Interval Leak",
+      detect(steps) {
+        return steps.some((s) => {
+          const l = s.label;
+          const e = s.edge ?? "";
+          return l.includes("Timeout") || l.includes("Interval") || e.includes("timer") || e.includes("interval");
+        });
+      },
+      why() {
+        return `A setInterval or setTimeout callback holds closure references to detached DOM nodes. The timer was not cleared when the component was unmounted.`;
+      },
+      fixes: [
+        "Store the timer ID and call clearInterval/clearTimeout on cleanup",
+        "In React: clear timers inside the useEffect return function",
+        "Use AbortController to coordinate timer cleanup with other async operations"
+      ]
+    },
+    {
+      id: "observer-leak",
+      name: "Observer Leak (MutationObserver / ResizeObserver)",
+      detect(steps) {
+        return steps.some((s) => {
+          const l = s.label;
+          return l.includes("MutationObserver") || l.includes("ResizeObserver") || l.includes("IntersectionObserver");
+        });
+      },
+      why(steps) {
+        const obsStep = steps.find((s) => s.label.includes("Observer"));
+        const obsName = obsStep ? import_formatUtils.FormatUtils.truncate(obsStep.label, 40) : "An observer";
+        return `${obsName} is still observing elements that have been removed from the DOM. The observer's callback closure keeps references to the detached elements alive.`;
+      },
+      fixes: [
+        "Call observer.disconnect() when the component unmounts",
+        "In React: disconnect in the useEffect cleanup function",
+        "Ensure observed elements are unobserved before removal"
+      ]
+    }
+  ];
+  /**
+   * Match known leak patterns against the given retainer chains.
+   * @param chainResults - Retainer chains from leak analysis.
+   * @returns Primary and contributing matched patterns.
+   */
+  match(chainResults) {
+    const allSteps = chainResults.flatMap((c) => c.chain);
+    const matched = [];
+    PatternMatcher.KNOWN_PATTERNS.forEach((pattern) => {
+      if (pattern.detect(allSteps)) {
+        matched.push({
+          id: pattern.id,
+          name: pattern.name,
+          why: pattern.why(allSteps),
+          fixes: pattern.fixes
+        });
+      }
+    });
+    return {
+      primary: matched[0] ?? null,
+      contributing: matched.slice(1)
+    };
+  }
+}

package/dist/cjs/analysis/retainerTracer.js

@@ -0,0 +1,376 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var retainerTracer_exports = {};
+__export(retainerTracer_exports, {
+  RetainerTracer: () => RetainerTracer
+});
+module.exports = __toCommonJS(retainerTracer_exports);
+class RetainerTracer {
+  static GC_ROOT_NAMES = /* @__PURE__ */ new Set([
+    "(GC roots)",
+    "(Internals)",
+    "(Global handles)",
+    "(Strong roots)",
+    "(Bootstrapper)",
+    "(Strong root list)",
+    "(Traced handles)",
+    "(Builtins)",
+    "(Internalized strings)",
+    "(External strings)",
+    "(Smi roots)",
+    "(Read-only roots)",
+    "C++ Persistent roots"
+  ]);
+  static PREFERRED_ROOTS = /* @__PURE__ */ new Set([
+    "(GC roots)",
+    "(Global handles)"
+  ]);
+  static SKIP_GLOBALS = /* @__PURE__ */ new Set([
+    "Window",
+    "window",
+    "global",
+    "globalThis"
+  ]);
+  static V8_ENGINE_NAMES = /* @__PURE__ */ new Set([
+    "<dummy>",
+    "instruction_stream",
+    "dependent_code",
+    "js_map_map",
+    "no_elements_protector",
+    "trusted_function_data",
+    "constant_elements",
+    "shared_function_info",
+    "feedback_vector",
+    "bytecode_array",
+    "scope_info",
+    "prototype_info",
+    "enum_cache",
+    "function_data",
+    "raw_properties_or_hash",
+    "descriptors",
+    "transitions",
+    "constructor_or_back_pointer"
+  ]);
+  static V8_ENGINE_EDGE_NAMES = /* @__PURE__ */ new Set([
+    "__proto__",
+    "map",
+    "properties",
+    "elements",
+    "shared_function_info",
+    "feedback_vector",
+    "code",
+    "dependent_code",
+    "instruction_stream",
+    "js_map_map",
+    "no_elements_protector",
+    "trusted_function_data",
+    "constant_elements",
+    "bytecode_array",
+    "scope_info",
+    "prototype_info",
+    "enum_cache",
+    "raw_properties_or_hash",
+    "descriptors",
+    "transitions",
+    "constructor_or_back_pointer"
+  ]);
+  static JS_ROOTS = /* @__PURE__ */ new Set([
+    "(GC roots)",
+    "(Global handles)",
+    "C++ Persistent roots"
+  ]);
+  static MAX_DEPTH = 40;
+  static MAX_PATHS_INTERNAL = 3;
+  static MAX_PATHS = 1;
+  /**
+   * Trace retainer paths from a leaked node back to GC roots.
+   * @param startNi - Node index of the leaked element.
+   * @param snapshot - The parsed heap snapshot.
+   * @returns An array of traced RetainerChain results.
+   */
+  trace(startNi, snapshot) {
+    const rawPaths = RetainerTracer.findRetainerPaths(startNi, snapshot);
+    return rawPaths.map((path) => {
+      const result = RetainerTracer.buildRetainerChain(path, snapshot);
+      const compactChain = RetainerTracer.formatChainString(result);
+      return { ...result, compactChain };
+    });
+  }
+  /**
+   * Walk up the DOM tree from a deeply nested element to find the root
+   * of its detached subtree — the ancestor directly retained by JS objects.
+   * @param startNi
+   * @param snapshot
+   * @param maxSteps
+   */
+  // eslint-disable-next-line complexity
+  walkToSubtreeRoot(startNi, snapshot) {
+    const indices = snapshot.groupIndicesForWalk ?? [startNi];
+    for (const ni of indices) {
+      for (const ei of snapshot.nodeRetainers(ni)) {
+        const fromNi = snapshot.edgeFromNode(ei);
+        const fromType = snapshot.nodeType(fromNi);
+        const edgeName = String(snapshot.edgeName(ei) ?? "");
+        const hasJSRetainer = fromType === "object" || fromType === "closure" || fromType === "array" || edgeName.startsWith("__reactFiber") || edgeName === "stateNode" || edgeName.startsWith("__reactInternalInstance") || edgeName === "gtm.element";
+        if (hasJSRetainer) return ni;
+      }
+    }
+    return startNi;
+  }
+  // ── Path finding ──
+  static findRetainerPaths(startNi, snapshot) {
+    let paths = RetainerTracer.bfsRetainers(startNi, snapshot, true, true);
+    if (paths.length === 0) {
+      paths = RetainerTracer.bfsRetainers(startNi, snapshot, true, false);
+    }
+    if (paths.length === 0) {
+      paths = RetainerTracer.bfsRetainers(startNi, snapshot, false, false);
+    }
+    paths.sort((a, b) => {
+      const rootA = a[a.length - 1];
+      const rootB = b[b.length - 1];
+      const nameA = snapshot.nodeName(rootA.ni);
+      const nameB = snapshot.nodeName(rootB.ni);
+      const prefA = RetainerTracer.PREFERRED_ROOTS.has(nameA) ? 0 : 1;
+      const prefB = RetainerTracer.PREFERRED_ROOTS.has(nameB) ? 0 : 1;
+      if (prefA !== prefB) return prefA - prefB;
+      const internalA = a.filter(
+        (s) => s.ei >= 0 && RetainerTracer.isV8Engine(
+          snapshot.edgeFromNode(s.ei),
+          snapshot
+        )
+      ).length;
+      const internalB = b.filter(
+        (s) => s.ei >= 0 && RetainerTracer.isV8Engine(
+          snapshot.edgeFromNode(s.ei),
+          snapshot
+        )
+      ).length;
+      return internalA - internalB;
+    });
+    return paths.slice(0, RetainerTracer.MAX_PATHS);
+  }
+  // eslint-disable-next-line max-params, max-statements, complexity
+  static bfsRetainers(startNi, snapshot, strict, jsRootsOnly) {
+    const paths = [];
+    const visited = /* @__PURE__ */ new Set([startNi]);
+    const queue = [
+      { ni: startNi, path: [] }
+    ];
+    const isValidRoot = jsRootsOnly ? (ni) => RetainerTracer.isJSRoot(ni, snapshot) : (ni) => RetainerTracer.isGCRoot(ni, snapshot);
+    while (queue.length > 0 && paths.length < RetainerTracer.MAX_PATHS_INTERNAL) {
+      const { ni, path } = queue.shift();
+      if (path.length > 0 && isValidRoot(ni)) {
+        paths.push([...path, { ni, ei: -1 }]);
+        continue;
+      }
+      if (path.length >= RetainerTracer.MAX_DEPTH) continue;
+      const retainerEdges = [];
+      for (const ei of snapshot.nodeRetainers(ni)) {
+        retainerEdges.push(ei);
+      }
+      retainerEdges.sort(
+        (a, b) => RetainerTracer.edgePriority(a, snapshot) - RetainerTracer.edgePriority(b, snapshot)
+      );
+      const bestPri = retainerEdges.length > 0 ? RetainerTracer.edgePriority(retainerEdges[0], snapshot) : Infinity;
+      for (const ei of retainerEdges.slice(0, 8)) {
+        const pri = RetainerTracer.edgePriority(ei, snapshot);
+        if (strict && pri >= 500 && bestPri < 500) continue;
+        const fromNi = snapshot.edgeFromNode(ei);
+        if (visited.has(fromNi)) continue;
+        visited.add(fromNi);
+        queue.push({
+          ni: fromNi,
+          path: [...path, { ni, ei }]
+        });
+      }
+    }
+    return paths;
+  }
+  // ── Classification helpers ──
+  static isGCRoot(ni, snapshot) {
+    return ni === 0 || RetainerTracer.GC_ROOT_NAMES.has(snapshot.nodeName(ni)) || snapshot.nodeType(ni) === "synthetic";
+  }
+  static isJSRoot(ni, snapshot) {
+    const name = snapshot.nodeName(ni);
+    return ni === 0 || RetainerTracer.JS_ROOTS.has(name);
+  }
+  static isV8Engine(ni, snapshot) {
+    const name = snapshot.nodeName(ni);
+    const type = snapshot.nodeType(ni);
+    if (type === "code") return true;
+    if (RetainerTracer.V8_ENGINE_NAMES.has(name)) return true;
+    if (name === "<dummy>") return true;
+    if (name.startsWith("blink::")) return true;
+    if (/^\d+$/.test(name)) return true;
+    if (/^\d+ \/ blink::/.test(name)) return true;
+    return false;
+  }
+  static isGlobalLike(name) {
+    if (RetainerTracer.SKIP_GLOBALS.has(name)) return true;
+    if (name.startsWith("Window / ")) return true;
+    return false;
+  }
+  // eslint-disable-next-line complexity
+  static edgePriority(ei, snapshot) {
+    const fromNi = snapshot.edgeFromNode(ei);
+    const fromType = snapshot.nodeType(fromNi);
+    const fromName = snapshot.nodeName(fromNi);
+    const edgeType = snapshot.edgeType(ei);
+    const edgeName = String(snapshot.edgeName(ei) ?? "");
+    if (edgeType === "weak") return 1e3;
+    if (RetainerTracer.isV8Engine(fromNi, snapshot)) return 500;
+    if (RetainerTracer.V8_ENGINE_EDGE_NAMES.has(edgeName)) return 200;
+    if (fromName === "InternalNode") return 30;
+    if (fromType === "hidden" && !fromName.startsWith("system / ")) return 35;
+    if (fromName.startsWith("system / ")) return 100;
+    if (fromType === "synthetic") return 50;
+    switch (edgeType) {
+      case "property":
+        return 0;
+      case "context":
+        return 1;
+      case "element":
+        return 2;
+      case "shortcut":
+        return 3;
+      case "internal":
+        return 15;
+      case "hidden":
+        return 20;
+      default:
+        return 5;
+    }
+  }
+  // ── Chain building ──
+  static isV8InternalEdgeName(edge) {
+    if (!edge) return false;
+    if (/^\d+ \/ /.test(edge)) return true;
+    if (edge.includes("part of key")) return true;
+    return false;
+  }
+  static formatEdgeName(ei, snapshot) {
+    const type = snapshot.edgeType(ei);
+    if (type === "element") return `[${snapshot.edgeName(ei)}]`;
+    const name = String(snapshot.edgeName(ei) ?? "");
+    if (!name || name === "undefined") return null;
+    return name;
+  }
+  // eslint-disable-next-line complexity
+  static isDisplayInternal(ni, snapshot) {
+    const name = snapshot.nodeName(ni);
+    const type = snapshot.nodeType(ni);
+    if (type === "code") return true;
+    if (type === "synthetic") return true;
+    if (name.startsWith("system / ")) return true;
+    if (name === "(internal array)") return true;
+    if (name === "InternalNode") return true;
+    if (name.startsWith("(object properties)")) return true;
+    if (name.startsWith("(object elements)")) return true;
+    if (RetainerTracer.V8_ENGINE_NAMES.has(name)) return true;
+    if (/^\d+$/.test(name)) return true;
+    if (/^\d+ \/ /.test(name)) return true;
+    if (type === "hidden" && !name.startsWith("<")) return true;
+    return false;
+  }
+  // eslint-disable-next-line max-statements, complexity
+  static buildRetainerChain(path, snapshot) {
+    const steps = [];
+    for (let i = path.length - 1; i >= 0; i -= 1) {
+      const { ni, ei } = path[i];
+      const nodeName = snapshot.nodeName(ni);
+      const nodeType = snapshot.nodeType(ni);
+      const nodeId = snapshot.nodeId(ni);
+      const edgeName = ei >= 0 ? RetainerTracer.formatEdgeName(ei, snapshot) : null;
+      const internal = RetainerTracer.isDisplayInternal(ni, snapshot);
+      steps.push({
+        ni,
+        edgeName,
+        nodeName,
+        nodeType,
+        nodeId,
+        isInternal: internal,
+        isRoot: RetainerTracer.isGCRoot(ni, snapshot),
+        isLeaked: i === 0,
+        isGlobal: RetainerTracer.isGlobalLike(nodeName)
+      });
+    }
+    const chain = [];
+    steps.forEach((step) => {
+      let label;
+      if (step.isRoot) {
+        label = step.nodeName || "(GC roots)";
+      } else if (step.isLeaked) {
+        label = step.nodeType === "closure" ? `${step.nodeName || "(anonymous)"}()` : step.nodeName;
+      } else {
+        const parts = [];
+        if (step.edgeName) parts.push(step.edgeName);
+        if (!step.isInternal && !step.isGlobal) {
+          if (step.nodeType === "closure") {
+            parts.push(`${step.nodeName || "(anonymous)"}()`);
+          } else if (step.nodeType === "object" && step.nodeName && !step.nodeName.startsWith("(")) {
+            parts.push(`in ${step.nodeName}`);
+          } else if (step.nodeType === "native" && step.nodeName && step.nodeName.startsWith("<")) {
+            parts.push(`in ${step.nodeName}`);
+          }
+        }
+        label = parts.join(" ") || step.nodeName;
+      }
+      let stepType;
+      if (step.isRoot) {
+        stepType = "root";
+      } else if (step.isLeaked) {
+        stepType = "leaked";
+      } else if (step.isInternal) {
+        stepType = "internal";
+      } else if (step.isGlobal) {
+        stepType = "global";
+      } else {
+        stepType = "code";
+      }
+      chain.push({
+        label,
+        type: stepType,
+        edge: step.edgeName,
+        nodeType: step.nodeType
+      });
+    });
+    let leakSource = null;
+    let firstCodeStep = null;
+    for (let i = 0; i < chain.length; i += 1) {
+      const step = chain[i];
+      if (step.type === "root" || step.type === "global" || step.type === "leaked")
+        continue;
+      if (step.type === "internal") continue;
+      if (step.edge && RetainerTracer.isV8InternalEdgeName(step.edge)) continue;
+      if (step.type === "code") {
+        if (!firstCodeStep) firstCodeStep = { label: step.label, index: i };
+        if (step.nodeType === "closure") {
+          leakSource = { label: step.label, index: i };
+          break;
+        }
+      }
+    }
+    if (!leakSource) leakSource = firstCodeStep;
+    return { chain, leakSource };
+  }
+  static formatChainString(chainResult) {
+    return chainResult.chain.filter((s) => s.type !== "internal" && s.type !== "global").map((s) => s.label);
+  }
+}

package/dist/cjs/analysis/snapshotComparer.js

@@ -0,0 +1,107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var snapshotComparer_exports = {};
+__export(snapshotComparer_exports, {
+  SnapshotComparer: () => SnapshotComparer
+});
+module.exports = __toCommonJS(snapshotComparer_exports);
+class SnapshotComparer {
+  leakDetector;
+  constructor(leakDetector) {
+    this.leakDetector = leakDetector;
+  }
+  /**
+   * Diff two snapshots and report what changed.
+   * @param before - The "before" snapshot (baseline).
+   * @param after - The "after" snapshot (current state).
+   * @param topN - Max leak groups to detect per snapshot.
+   * @returns A delta summary describing new and removed nodes, size changes, etc.
+   */
+  compare(before, after, topN = 5) {
+    const beforeIds = SnapshotComparer.collectNodeIds(before);
+    const afterIds = SnapshotComparer.collectNodeIds(after);
+    let newNodeCount = 0;
+    let removedNodeCount = 0;
+    for (const id of afterIds.keys()) {
+      if (!beforeIds.has(id)) newNodeCount += 1;
+    }
+    for (const id of beforeIds.keys()) {
+      if (!afterIds.has(id)) removedNodeCount += 1;
+    }
+    const beforeRetained = SnapshotComparer.totalRetainedSize(before);
+    const afterRetained = SnapshotComparer.totalRetainedSize(after);
+    const retainedSizeDelta = afterRetained - beforeRetained;
+    const beforeLeaks = this.leakDetector.detect(before, topN);
+    const afterLeaks = this.leakDetector.detect(after, topN);
+    const beforeLabels = new Set(beforeLeaks.map((l) => l.label));
+    const newLeakGroups = afterLeaks.filter((l) => !beforeLabels.has(l.label));
+    const detachedDomDelta = SnapshotComparer.computeDetachedDelta(
+      beforeLeaks,
+      afterLeaks
+    );
+    const delta = {
+      newNodeCount,
+      removedNodeCount,
+      retainedSizeDelta,
+      newLeakGroups,
+      detachedDomDelta
+    };
+    return { delta, afterLeaks };
+  }
+  static collectNodeIds(snapshot) {
+    const map = /* @__PURE__ */ new Map();
+    for (let i = 0; i < snapshot.nodeCount; i += 1) {
+      const ni = i;
+      map.set(snapshot.nodeId(ni), ni);
+    }
+    return map;
+  }
+  static totalRetainedSize(snapshot) {
+    let total = 0;
+    for (let i = 0; i < snapshot.nodeCount; i += 1) {
+      total += snapshot.nodeSelfSize(i);
+    }
+    return total;
+  }
+  // eslint-disable-next-line complexity
+  static computeDetachedDelta(beforeLeaks, afterLeaks) {
+    const delta = /* @__PURE__ */ new Map();
+    const beforeByTag = /* @__PURE__ */ new Map();
+    const afterByTag = /* @__PURE__ */ new Map();
+    beforeLeaks.forEach((leak) => {
+      if (leak.reason === "detached-dom" && leak.tag) {
+        beforeByTag.set(
+          leak.tag,
+          (beforeByTag.get(leak.tag) ?? 0) + leak.count
+        );
+      }
+    });
+    afterLeaks.forEach((leak) => {
+      if (leak.reason === "detached-dom" && leak.tag) {
+        afterByTag.set(leak.tag, (afterByTag.get(leak.tag) ?? 0) + leak.count);
+      }
+    });
+    const allTags = /* @__PURE__ */ new Set([...beforeByTag.keys(), ...afterByTag.keys()]);
+    allTags.forEach((tag) => {
+      const diff = (afterByTag.get(tag) ?? 0) - (beforeByTag.get(tag) ?? 0);
+      if (diff !== 0) delta.set(tag, diff);
+    });
+    return delta;
+  }
+}