@memlab/core 1.1.5 → 1.1.9

package/dist/lib/Types.d.ts

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 import { ParsedArgs } from 'minimist';
 import type { LaunchOptions, Page } from 'puppeteer';
@@ -32,7 +32,6 @@ export declare type AnyOptions = Record<string, unknown>;
 export declare type UnusedOptions = Record<string, never>;
 /** @internal */
 export declare type Command = [string, string[], AnyOptions];
-export declare type Predicator<T> = (node: T) => boolean;
 /** @internal */
 export declare type HeapNodeIdSet = Set<number>;
 /** @internal */
@@ -86,6 +85,22 @@ export declare type CLIArgs = {
     'local-puppeteer': boolean;
     'snapshot-dir': string;
 };
+/**
+ * the predicate callback is used to decide if a
+ * entity of type `T`.
+ * For more concrete examples on where it is used,
+ * check out {@link findAnyReference}, {@link findAnyReferrer},
+ * and {@link findReferrers}.
+ *
+ * @typeParam T - the type of the entity to be checked
+ * @param entity - the entity to be checked
+ * @returns whether the entity passes the predicate check
+ */
+export declare type Predicator<T> = (entity: T) => boolean;
+/**
+ * Data structure for holding cookies.
+ * For concrete example, check out {@link cookies}.
+ */
 export declare type Cookies = Array<{
     name: string;
     value: string;
@@ -288,9 +303,10 @@ export interface ILeakFilter {
 /**
  * Lifecycle function callback that is invoked initially once before calling any
  * leak filter function.
+ * For concrete example, check out {@link beforeLeakFilter}.
  *
- * @param snaphost - heap snapshot see {@link IHeapSnapshot}
- * @param leakedNodeIds - the set of leaked object (node) ids.
+ * @param snapshot heap snapshot see {@link IHeapSnapshot}
+ * @param leakedNodeIds the set of leaked object (node) ids.
  */
 export declare type InitLeakFilterCallback = (snapshot: IHeapSnapshot, leakedNodeIds: HeapNodeIdSet) => void;
 /**
@@ -299,6 +315,8 @@ export declare type InitLeakFilterCallback = (snapshot: IHeapSnapshot, leakedNod
  * allocated but not released from the target interaction
  * in the heap snapshot.
  *
+ * For concrete examples, check out {@link leakFilter}.
+ *
  * @param node - the node that is kept alive in the memory in the heap snapshot
  * @param snapshot - the snapshot of target interaction
  * @param leakedNodeIds - the set of leaked node ids
@@ -317,6 +335,11 @@ export declare type LeakFilterCallback = (node: IHeapNode, snapshot: IHeapSnapsh
 /**
  * The callback defines browser interactions which are
  * used by memlab to interact with the web app under test.
+ * For concrete examples, check out {@link action} or {@link back}.
+ *
+ * @param page the puppeteer [`Page`](https://pptr.dev/api/puppeteer.page)
+ * object, which provides APIs to interact with the web browser
+ * @returns no return value
  */
 export declare type InteractionsCallback = (page: Page, args?: OperationArgs) => Promise<void>;
 /**
@@ -684,6 +707,7 @@ export interface IDataBuilder {
 }
 /**
  * Callback function to provide if the page is loaded.
+ * For concrete example, check out {@link isPageLoaded}.
  * @param page - puppeteer's [Page](https://pptr.dev/api/puppeteer.page/) object.
  * @returns a boolean value, if it returns `true`, memlab will consider
  * the navigation completes, if it returns `false`, memlab will keep calling
@@ -738,16 +762,42 @@ export declare type E2EStepInfo = IE2EStepBasic & {
     delay?: number;
     metrics: Record<string, number>;
 };
-/** @internal */
+/**
+ * This data structure contains the input configuration for the browser and
+ * output data from the browser. You can retrieve the instance of this type
+ * through {@link RunMetaInfo}.
+ */
 export interface IBrowserInfo {
+    /**
+     * browser version
+     */
     _browserVersion: string;
+    /**
+     * configuration for puppeteer
+     */
     _puppeteerConfig: LaunchOptions;
+    /**
+     * all web console output
+     */
     _consoleMessages: string[];
 }
+/**
+ * This data structure holds the information about memlab run.
+ * You can retrieve the instance of this type through {@link getRunMetaInfo}.
+ */
 export declare type RunMetaInfo = {
+    /** @internal */
     app: string;
+    /** @internal */
     interaction: string;
+    /**
+     * type of the memlab run
+     */
     type: string;
+    /**
+     * input configuration for the browser and
+     * output data from the browser
+     */
     browserInfo: IBrowserInfo;
 };
 /**
@@ -757,6 +807,13 @@ export declare type RunMetaInfo = {
  * {@link IHeapNode} and {@link IHeapEdge}.
  */
 export interface IHeapSnapshot {
+    /**
+     * flag indicating if the heap snapshot has included
+     * the post-processing meta data (e.g., shortest path to GC root,
+     * dominator info and retainer size etc.)
+     * @internal
+     */
+    isProcessed: boolean;
     /** @internal */
     snapshot: RawHeapSnapshot;
     /**
@@ -769,11 +826,11 @@ export interface IHeapSnapshot {
      * ```typescript
      * import type {IHeapSnapshot, IHeapNode} from '@memlab/core';
      * import {dumpNodeHeapSnapshot} from '@memlab/core';
-     * import {getHeapFromFile} from '@memlab/heap-analysis';
+     * import {getFullHeapFromFile} from '@memlab/heap-analysis';
      *
      * (async function () {
      *   const heapFile = dumpNodeHeapSnapshot();
-     *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+     *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
      *
      *   // get the total number of heap objects
      *   heap.nodes.length;
@@ -795,11 +852,11 @@ export interface IHeapSnapshot {
      * ```typescript
      * import type {IHeapSnapshot, IHeapEdge} from '@memlab/core';
      * import {dumpNodeHeapSnapshot} from '@memlab/core';
-     * import {getHeapFromFile} from '@memlab/heap-analysis';
+     * import {getFullHeapFromFile} from '@memlab/heap-analysis';
      *
      * (async function () {
      *   const heapFile = dumpNodeHeapSnapshot();
-     *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+     *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
      *
      *   // get the total number of heap references
      *   heap.edges.length;
@@ -821,11 +878,11 @@ export interface IHeapSnapshot {
      * ```typescript
      * import type {IHeapSnapshot} from '@memlab/core';
      * import {dumpNodeHeapSnapshot} from '@memlab/core';
-     * import {getHeapFromFile} from '@memlab/heap-analysis';
+     * import {getFullHeapFromFile} from '@memlab/heap-analysis';
      *
      * (async function () {
      *   const heapFile = dumpNodeHeapSnapshot();
-     *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+     *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
      *
      *   const node = heap.getNodeById(351);
      *   node?.id; // should be 351
@@ -843,7 +900,7 @@ export interface IHeapSnapshot {
      * ```typescript
      * // save as example.test.ts
      * import type {IHeapSnapshot, Nullable} from '@memlab/core';
-     * import {config, getNodeInnocentHeap} from '@memlab/core';
+     * import {config, takeNodeMinimalHeap} from '@memlab/core';
      *
      * class TestObject {
      *   public arr1 = [1, 2, 3];
@@ -855,7 +912,7 @@ export interface IHeapSnapshot {
      *
      *   let obj: Nullable<TestObject> = new TestObject();
      *   // get a heap snapshot of the current program state
-     *   let heap: IHeapSnapshot = await getNodeInnocentHeap();
+     *   let heap: IHeapSnapshot = await takeNodeMinimalHeap();
      *
      *   // call some function that may add references to obj
      *   rabbitHole(obj)
@@ -863,7 +920,7 @@ export interface IHeapSnapshot {
      *   expect(heap.hasObjectWithClassName('TestObject')).toBe(true);
      *   obj = null;
      *
-     *   heap = await getNodeInnocentHeap();
+     *   heap = await takeNodeMinimalHeap();
      *   // if rabbitHole does not have any side effect that
      *   // adds new references to obj, then obj can be GCed
      *   expect(heap.hasObjectWithClassName('TestObject')).toBe(false);
@@ -882,7 +939,7 @@ export interface IHeapSnapshot {
      * * **Examples**:
      * ```typescript
      * import type {IHeapSnapshot} from '@memlab/core';
-     * import {getNodeInnocentHeap} from '@memlab/core';
+     * import {takeNodeMinimalHeap} from '@memlab/core';
      *
      * class TestObject {
      *   public arr1 = [1, 2, 3];
@@ -892,7 +949,7 @@ export interface IHeapSnapshot {
      * (async function () {
      *   const obj = new TestObject();
      *   // get a heap snapshot of the current program state
-     *   const heap: IHeapSnapshot = await getNodeInnocentHeap();
+     *   const heap: IHeapSnapshot = await takeNodeMinimalHeap();
      *
      *   const node = heap.getAnyObjectWithClassName('TestObject');
      *   console.log(node?.name); // should be 'TestObject'
@@ -911,14 +968,14 @@ export interface IHeapSnapshot {
      * ```typescript
      * import type {IHeapSnapshot} from '@memlab/core';
      * import {dumpNodeHeapSnapshot} from '@memlab/core';
-     * import {getHeapFromFile} from '@memlab/heap-analysis';
+     * import {getFullHeapFromFile} from '@memlab/heap-analysis';
      *
      * (async function () {
      *   // eslint-disable-next-line @typescript-eslint/no-unused-vars
      *   const object = {'memlab-test-heap-property': 'memlab-test-heap-value'};
      *
      *   const heapFile = dumpNodeHeapSnapshot();
-     *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+     *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
      *
      *   // should be true
      *   console.log(heap.hasObjectWithPropertyName('memlab-test-heap-property'));
@@ -938,7 +995,7 @@ export interface IHeapSnapshot {
      *
      * ```typescript
      * import type {IHeapSnapshot, AnyValue} from '@memlab/core';
-     * import {config, getNodeInnocentHeap, tagObject} from '@memlab/core';
+     * import {config, takeNodeMinimalHeap, tagObject} from '@memlab/core';
      *
      * test('memory test', async () => {
      *   config.muteConsole = true;
@@ -952,7 +1009,7 @@ export interface IHeapSnapshot {
      *
      *   o2 = null;
      *
-     *   const heap: IHeapSnapshot = await getNodeInnocentHeap();
+     *   const heap: IHeapSnapshot = await takeNodeMinimalHeap();
      *
      *   // expect object with marker "memlab-mark-1" exists
      *   expect(heap.hasObjectWithTag('memlab-mark-1')).toBe(true);
@@ -976,16 +1033,16 @@ export interface IHeapSnapshot {
  * @readonly it is not recommended to modify any `IHeapLocation` instance
  *
  * * **Examples**: V8 or hermes heap snapshot can be parsed by the
- * {@link getHeapFromFile} API.
+ * {@link getFullHeapFromFile} API.
  *
  * ```typescript
  * import type {IHeapSnapshot, IHeapNode, IHeapLocation} from '@memlab/core';
  * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {getFullHeapFromFile} from '@memlab/heap-analysis';
  *
  * (async function () {
  *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
  *
  *   // iterate over each node (heap object)
  *   heap.nodes.forEach((node: IHeapNode, i: number) => {
@@ -1038,16 +1095,16 @@ export interface IHeapEdgeBasic {
  * @readonly it is not recommended to modify any `IHeapEdge` instance
  *
  * * **Examples**: V8 or hermes heap snapshot can be parsed by the
- * {@link getHeapFromFile} API.
+ * {@link getFullHeapFromFile} API.
  *
  * ```typescript
  * import type {IHeapSnapshot, IHeapEdge} from '@memlab/core';
  * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {getFullHeapFromFile} from '@memlab/heap-analysis';
  *
  * (async function () {
  *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
  *
  *   // iterate over each edge (JS reference in heap)
  *   heap.edges.forEach((edge: IHeapEdge, i: number) => {
@@ -1101,11 +1158,11 @@ export interface IHeapEdge extends IHeapEdgeBasic {
  * ```typescript
  * import type {IHeapSnapshot, IHeapEdges} from '@memlab/core';
  * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {getFullHeapFromFile} from '@memlab/heap-analysis';
  *
  * (async function () {
  *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
  *
  *   const edges: IHeapEdges = heap.edges;
  *   edges.length;
@@ -1162,6 +1219,13 @@ export interface IHeapNodeBasic {
      */
     id: number;
 }
+/**
+ * Executes a provided callback once for JavaScript references.
+ * For concrete examples, check out {@link forEachReference}
+ * or {@link forEachReferrer}.
+ * @param callback the callback for each JavaScript reference from a collection
+ * @returns this API returns void
+ */
 export declare type EdgeIterationCallback = (edge: IHeapEdge) => Optional<{
     stop: boolean;
 }>;
@@ -1173,16 +1237,16 @@ export declare type EdgeIterationCallback = (edge: IHeapEdge) => Optional<{
  * @readonly it is not recommended to modify any `IHeapNode` instance
  *
  * * **Examples**: V8 or hermes heap snapshot can be parsed by the
- * {@link getHeapFromFile} API.
+ * {@link getFullHeapFromFile} API.
  *
  * ```typescript
  * import type {IHeapSnapshot, IHeapNode} from '@memlab/core';
  * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {getFullHeapFromFile} from '@memlab/heap-analysis';
  *
  * (async function () {
  *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
  *
  *   // iterate over each node (heap object)
  *   heap.nodes.forEach((node: IHeapNode, i: number) => {
@@ -1237,6 +1301,11 @@ export interface IHeapNode extends IHeapNodeBasic {
      * object (including engine-internal, native, and JS references).
      */
     referrers: IHeapEdge[];
+    /**
+     * returns true if the heap node has been set an incoming edge
+     * which leads to the parent node on the shortest path to GC root.
+     */
+    hasPathEdge: boolean;
     /**
      * The incoming edge which leads to the parent node
      * on the shortest path to GC root.
@@ -1481,16 +1550,16 @@ export interface IHeapNode extends IHeapNodeBasic {
  * @readonly it is not recommended to modify any `IHeapStringNode` instance
  *
  * * **Examples**: V8 or hermes heap snapshot can be parsed by the
- * {@link getHeapFromFile} API.
+ * {@link getFullHeapFromFile} API.
  *
  * ```typescript
  * import type {IHeapSnapshot, IHeapNode, IHeapStringNode} from '@memlab/core';
  * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {getFullHeapFromFile} from '@memlab/heap-analysis';
  *
  * (async function () {
  *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
  *
  *   // iterate over each node (heap object)
  *   heap.nodes.forEach((node: IHeapNode, i: number) => {
@@ -1522,11 +1591,11 @@ export interface IHeapStringNode extends IHeapNode {
  * ```typescript
  * import type {IHeapSnapshot, IHeapNodes} from '@memlab/core';
  * import {dumpNodeHeapSnapshot} from '@memlab/core';
- * import {getHeapFromFile} from '@memlab/heap-analysis';
+ * import {getFullHeapFromFile} from '@memlab/heap-analysis';
  *
  * (async function () {
  *   const heapFile = dumpNodeHeapSnapshot();
- *   const heap: IHeapSnapshot = await getHeapFromFile(heapFile);
+ *   const heap: IHeapSnapshot = await getFullHeapFromFile(heapFile);
  *
  *   const nodes: IHeapNodes = heap.nodes;
  *   nodes.length;
@@ -1661,5 +1730,11 @@ export interface IClusterStrategy {
     diffTraces: (newLeakTraces: LeakTrace[], existingLeakTraces: LeakTrace[]) => TraceDiff;
 }
 /** @internal */
+export interface IHeapConfig {
+    isCliInteractiveMode: boolean;
+    currentHeapFile: Optional<string>;
+    currentHeap: Optional<IHeapSnapshot>;
+}
+/** @internal */
 export declare type ErrorWithMessage = Pick<Error, 'message'>;
 //# sourceMappingURL=Types.d.ts.map

package/dist/lib/Types.js

@@ -5,8 +5,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/Utils.d.ts

@@ -4,8 +4,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 import type { HaltOrThrowOptions } from './Types';
 import type { Browser, Page } from 'puppeteer';

package/dist/lib/Utils.js

@@ -5,8 +5,8 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
+ * @oncall ws_labs
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -136,10 +136,10 @@ function isDetachedFiberNode(node) {
 // any detached DOM nodes (e.g., HTMLXXElement, IntersectionObserver etc.)
 // that are not internal nodes.
 function isDetachedDOMNode(node, args = {}) {
-    if (!node || typeof node.name !== 'string') {
+    let name = null;
+    if (!node || typeof (name = node.name) !== 'string') {
         return false;
     }
-    const name = node.name;
     if (isFiberNode(node)) {
         return false;
     }
@@ -213,13 +213,16 @@ function isPendingActivityNode(node) {
     return node.type === 'synthetic' && node.name === 'Pending activities';
 }
 function isRootNode(node, opt = {}) {
-    if (!node || !node.name) {
+    if (!node) {
         return false;
     }
     // consider Hermes snapshot GC roots
     if (Config_1.default.jsEngine === 'hermes') {
         return node.name === '(GC roots)' || node.name === '(GC Roots)';
     }
+    if (node.id === 0 || node.id === 1) {
+        return true;
+    }
     // the window object
     if (node.type === 'native' && node.name.indexOf('Window') === 0) {
         return true;
@@ -390,7 +393,6 @@ function setFiberNodeAttribute(node, flag) {
     if (!node || !isFiberNode(node)) {
         return;
     }
-    // eslint-disable-next-line no-bitwise
     node.attributes |= flag;
 }
 function hasFiberNodeAttribute(node, flag) {
@@ -447,7 +449,6 @@ function filterNodesInPlace(idSet, snapshot, cb) {
 function applyToNodes(idSet, snapshot, cb, options = {}) {
     let ids = Array.from(idSet.keys());
     if (options.shuffle) {
-        // eslint-disable-next-line fb-www/unsafe-math-random
         ids.sort(() => Math.random() - 0.5);
     }
     else if (options.reverse) {
@@ -508,7 +509,6 @@ function loadScenario(filename) {
     }
     let scenario;
     try {
-        // eslint-disable-next-line @typescript-eslint/no-var-requires
         scenario = require(filepath);
         scenario = checkScenarioInstance(scenario);
         if (scenario.name == null) {
@@ -534,6 +534,12 @@ function handleSnapshotError(e) {
 }
 function getSnapshotFromFile(filename, options) {
     return __awaiter(this, void 0, void 0, function* () {
+        const heapConfig = Config_1.default.heapConfig;
+        if (heapConfig &&
+            heapConfig.currentHeapFile === filename &&
+            heapConfig.currentHeap) {
+            return heapConfig.currentHeap;
+        }
         Console_1.default.overwrite('parsing ' + filename + ' ...');
         let ret = null;
         try {
@@ -812,7 +818,6 @@ function loadRunMetaInfo(metaFile = undefined) {
     try {
         const content = fs_1.default.readFileSync(file, 'UTF-8');
         return JSON.parse(content);
-        // eslint-disable-next-line fb-www/no-unused-catch-bindings
     }
     catch (_) {
         throw haltOrThrow('Run info missing. Please make sure `memlab run` is complete.');
@@ -1271,9 +1276,23 @@ function getSnapshotDirForAnalysis() {
     return dir;
 }
 function getSingleSnapshotFileForAnalysis() {
-    const path = Config_1.default.useExternalSnapshot && Config_1.default.externalSnapshotFilePaths[0]
-        ? Config_1.default.externalSnapshotFilePaths[0]
-        : getSnapshotFilePathWithTabType(/(final)|(target)|(baseline)/);
+    let path = null;
+    // if an external snapshot file is specified
+    if (Config_1.default.useExternalSnapshot &&
+        Config_1.default.externalSnapshotFilePaths.length > 0) {
+        path =
+            Config_1.default.externalSnapshotFilePaths[Config_1.default.externalSnapshotFilePaths.length - 1];
+        // if running in interactive heap analysis mode
+    }
+    else if (Config_1.default.heapConfig &&
+        Config_1.default.heapConfig.isCliInteractiveMode &&
+        Config_1.default.heapConfig.currentHeapFile) {
+        path = Config_1.default.heapConfig.currentHeapFile;
+        // search for snapshot labeled as baseline, target, or final
+    }
+    else {
+        path = getSnapshotFilePathWithTabType(/(final)|(target)|(baseline)/);
+    }
     return resolveSnapshotFilePath(path);
 }
 function getSnapshotFilePath(tab) {
@@ -1286,7 +1305,7 @@ function getSnapshotFilePath(tab) {
     }
     return Config_1.default.externalSnapshotFilePaths[tab.idx - 1];
 }
-// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function equalOrMatch(v1, v2) {
     const t1 = typeof v1;
     const t2 = typeof v2;
@@ -1319,7 +1338,8 @@ function isMeaningfulNode(node) {
     if (!node) {
         return false;
     }
-    if (Config_1.default.nodeNameBlockList.has(node.name)) {
+    const nodeName = node.name;
+    if (Config_1.default.nodeNameBlockList.has(nodeName)) {
         return false;
     }
     if (isFiberNode(node)) {
@@ -1330,13 +1350,13 @@ function isMeaningfulNode(node) {
     }
     // More details in https://github.com/ChromeDevTools/devtools-frontend
     // under front_end/heap_snapshot_worker/HeapSnapshot.ts
-    if (node.name === 'system / NativeContext') {
+    if (nodeName === 'system / NativeContext') {
         return false;
     }
-    if (node.name === 'system / SourcePositionTableWithFrameCache') {
+    if (nodeName === 'system / SourcePositionTableWithFrameCache') {
         return false;
     }
-    if (node.name === '(map descriptors)') {
+    if (nodeName === '(map descriptors)') {
         return false;
     }
     if (node.type === 'code') {
@@ -1351,44 +1371,49 @@ function isMeaningfulEdge(edge, options = {}) {
     if (source.id === node.id) {
         return false;
     }
-    if (typeof edge.name_or_index === 'string' &&
-        Config_1.default.edgeNameBlockList.has(edge.name_or_index)) {
+    const edgeNameOrIndex = edge.name_or_index;
+    if (typeof edgeNameOrIndex === 'string' &&
+        Config_1.default.edgeNameBlockList.has(edgeNameOrIndex)) {
         return false;
     }
+    const edgeType = edge.type;
     // shortcut edge may be meaningful edges
     // --forceUpdate (variable)--->  [native_bind]
     // --bound_argument_0 (shortcut)--->  [FiberNode]
-    if (edge.type === 'weak' /* || edge.type === 'shortcut' */) {
+    if (edgeType === 'weak' /* || edge.type === 'shortcut' */) {
         return false;
     }
     if (options.excludeWeakMapEdge && isWeakMapEdgeToKey(edge)) {
         return false;
     }
-    if (options.visited && options.visited[node.nodeIndex]) {
+    const nodeIndex = node.nodeIndex;
+    if (options.visited && options.visited[nodeIndex]) {
         return false;
     }
-    if (options.queued && options.queued[node.nodeIndex]) {
+    if (options.queued && options.queued[nodeIndex]) {
         return false;
     }
-    if (!options.includeString && node.type === 'string') {
+    const nodeType = node.type;
+    if (!options.includeString && nodeType === 'string') {
         return false;
     }
-    if (edge.type === 'internal' && edge.name_or_index === 'code') {
+    if (edgeType === 'internal' && edgeNameOrIndex === 'code') {
         return false;
     }
     // More details about the following three special cases are available
     // in https://github.com/ChromeDevTools/devtools-frontend
     // under front_end/heap_snapshot_worker/HeapSnapshot.ts
-    if (edge.type === 'hidden' && edge.name_or_index === 'sloppy_function_map') {
+    if (edgeType === 'hidden' && edgeNameOrIndex === 'sloppy_function_map') {
         return false;
     }
-    if (edge.type === 'hidden' && node.name === 'system / NativeContext') {
+    const nodeName = node.name;
+    if (edgeType === 'hidden' && nodeName === 'system / NativeContext') {
         return false;
     }
     // In v8, (map descriptors) are fixed-length descriptors arrays used
     // to hold JS descriptors.
-    if (node.type === 'array' && node.name === '(map descriptors)') {
-        const index = edge.name_or_index;
+    if (edgeType === 'array' && nodeName === '(map descriptors)') {
+        const index = edgeNameOrIndex;
         // only elements at particular indexes of (map descriptors) are holding
         // representative references to objects.
         if (index >= 2 || (typeof index === 'number' && index % 3 === 1)) {
@@ -1401,12 +1426,12 @@ function isMeaningfulEdge(edge, options = {}) {
     if (Config_1.default.jsEngine === 'hermes' && isDirectPropEdge(edge)) {
         return false;
     }
-    if (Config_1.default.ignoreInternalNode && node.name.includes('InternalNode')) {
+    if (Config_1.default.ignoreInternalNode && nodeName.includes('InternalNode')) {
         return false;
     }
     if (Config_1.default.ignoreDevToolsConsoleLeak) {
-        const name = edge.name_or_index;
-        if (typeof name === 'string' && name.includes('DevTools console')) {
+        if (typeof edgeNameOrIndex === 'string' &&
+            edgeNameOrIndex.includes('DevTools console')) {
             return false;
         }
     }
@@ -1421,7 +1446,6 @@ function isURLEqual(url1, url2) {
     try {
         u1 = new URL(url1);
         u2 = new URL(url2);
-        // eslint-disable-next-line fb-www/no-unused-catch-bindings
     }
     catch (_e) {
         return false;

package/dist/lib/heap-data/HeapEdge.d.ts

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 import type { IHeapEdge } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';

package/dist/lib/heap-data/HeapEdge.js

@@ -4,9 +4,9 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
- * @lightSyntaxTransform
  * @format
+ * @lightSyntaxTransform
+ * @oncall ws_labs
  */
 'use strict';
 var __importDefault = (this && this.__importDefault) || function (mod) {