@memlab/core 1.0.0

package/dist/lib/Utils.js

@@ -0,0 +1,1736 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * 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
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSnapshotFilePath = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const process_1 = __importDefault(require("process"));
+const Config_1 = __importStar(require("./Config"));
+const Console_1 = __importDefault(require("./Console"));
+const Constant_1 = __importDefault(require("./Constant"));
+const HeapParser_1 = __importDefault(require("./HeapParser"));
+const BrowserInfo_1 = __importDefault(require("./BrowserInfo"));
+const memCache = Object.create(null);
+const FileManager_1 = __importDefault(require("./FileManager"));
+const __1 = require("..");
+// For more details see ReactWorkTags.js of React
+const reactWorkTag = {
+    FunctionComponent: 0,
+    ClassComponent: 1,
+    IndeterminateComponent: 2,
+    HostRoot: 3,
+    HostPortal: 4,
+    HostComponent: 5,
+    HostText: 6,
+    Fragment: 7,
+    Mode: 8,
+    ContextConsumer: 9,
+    ContextProvider: 10,
+    ForwardRef: 11,
+    Profiler: 12,
+    SuspenseComponent: 13,
+    MemoComponent: 14,
+    SimpleMemoComponent: 15,
+    LazyComponent: 16,
+    IncompleteClassComponent: 17,
+    DehydratedFragment: 18,
+    SuspenseListComponent: 19,
+    ScopeComponent: 21,
+    OffscreenComponent: 22,
+    LegacyHiddenComponent: 23,
+    CacheComponent: 24,
+};
+const reactTagIdToName = [];
+Object.entries(reactWorkTag).forEach(workTag => (reactTagIdToName[workTag[1]] = workTag[0]));
+function _getReactWorkTagName(tagId) {
+    if (typeof tagId === 'string') {
+        tagId = parseInt(tagId, 10);
+    }
+    if (typeof tagId !== 'number' || tagId !== tagId) {
+        return null;
+    }
+    return reactTagIdToName[tagId];
+}
+function isHermesInternalObject(node) {
+    return (node.type === 'number' ||
+        node.name === 'HiddenClass' ||
+        node.name === 'Environment' ||
+        node.name === 'ArrayStorage' ||
+        node.name === 'SegmentedArray' ||
+        node.name === 'WeakValueMap' ||
+        node.name === 'HashMapEntry');
+}
+function isStackTraceFrame(node) {
+    if (!node || node.type !== 'hidden') {
+        return false;
+    }
+    return node.name === 'system / StackTraceFrame';
+}
+// returns true if it is detached DOM element or detached FiberNode
+// NOTE: Doesn't work for FiberNode without detachedness field
+function isDetached(node) {
+    if (Config_1.default.snapshotHasDetachedness) {
+        return node.is_detached;
+    }
+    return node.name.startsWith('Detached ');
+}
+function isFiberNode(node) {
+    if (!node || node.type !== 'object') {
+        return false;
+    }
+    const name = node.name;
+    return name === 'FiberNode' || name === 'Detached FiberNode';
+}
+// quickly check the detachedness field
+// need to call hasHostRoot(node) before this function
+// does not traverse and check the existance of HostRoot
+// NOTE: Doesn't work for FiberNode without detachedness field
+function isDetachedFiberNode(node) {
+    return isFiberNode(node) && isDetached(node);
+}
+// this function returns a more general sense of DOM nodes. Specifically,
+// any detached DOM nodes (e.g., HTMLXXElement, IntersectionObserver etc.)
+// that are not internal nodes.
+function isDetachedDOMNode(node, args = {}) {
+    if (!node || typeof node.name !== 'string') {
+        return false;
+    }
+    const name = node.name;
+    if (isFiberNode(node)) {
+        return false;
+    }
+    if (name === 'Detached InternalNode' && args.ignoreInternalNode) {
+        return false;
+    }
+    return isDetached(node);
+}
+function isWeakMapEdge(edge) {
+    if (!edge || typeof edge.name_or_index !== 'string') {
+        return false;
+    }
+    if (edge.name_or_index.indexOf('WeakMap') < 0) {
+        return false;
+    }
+    return true;
+}
+function isWeakMapEdgeToKey(edge) {
+    if (!isWeakMapEdge(edge)) {
+        return false;
+    }
+    const weakMapKeyObjectId = getWeakMapEdgeKeyId(edge);
+    const toNodeObjectId = edge.toNode.id;
+    // in WeakMap, keys are weakly referenced
+    if (weakMapKeyObjectId === toNodeObjectId) {
+        return true;
+    }
+    return false;
+}
+function isWeakMapEdgeToValue(edge) {
+    if (!isWeakMapEdge(edge)) {
+        return false;
+    }
+    const weakMapKeyObjectId = getWeakMapEdgeKeyId(edge);
+    const toNodeObjectId = edge.toNode.id;
+    // in WeakMap, keys are weakly referenced
+    if (weakMapKeyObjectId !== toNodeObjectId) {
+        return true;
+    }
+    return false;
+}
+function isEssentialEdge(nodeIndex, edgeType, rootNodeIndex) {
+    // According to Chrome Devtools, most shortcut edges are non-essential
+    // except at the root node, which have special meaning of marking user
+    // global objects
+    // NOTE: However, bound function may have a shortcut edge to the bound
+    //       host object
+    return (edgeType !== 'weak' &&
+        (edgeType !== 'shortcut' || nodeIndex === rootNodeIndex));
+}
+function isFiberNodeDeletionsEdge(edge) {
+    if (!edge || !edge.fromNode || !edge.toNode) {
+        return false;
+    }
+    if (!isFiberNode(edge.fromNode)) {
+        return false;
+    }
+    return edge.name_or_index === 'deletions';
+}
+function isBlinkRootNode(node) {
+    if (!node || !node.name) {
+        return false;
+    }
+    return (node.type === 'synthetic' &&
+        (node.name === 'Blink cross-thread roots' || node.name === 'Blink roots'));
+}
+function isPendingActivityNode(node) {
+    if (!node || !node.name) {
+        return false;
+    }
+    return node.type === 'synthetic' && node.name === 'Pending activities';
+}
+function isRootNode(node, opt = {}) {
+    if (!node || !node.name) {
+        return false;
+    }
+    // consider Hermes snapshot GC roots
+    if (Config_1.default.jsEngine === 'hermes') {
+        return node.name === '(GC roots)' || node.name === '(GC Roots)';
+    }
+    // the window object
+    if (node.type === 'native' && node.name.indexOf('Window') === 0) {
+        return true;
+    }
+    if (node.type === 'synthetic' && node.name === '(GC roots)') {
+        return true;
+    }
+    if (!opt.excludeBlinkRoot && isBlinkRootNode(node)) {
+        return true;
+    }
+    if (!opt.excludePendingActivity && isPendingActivityNode(node)) {
+        return true;
+    }
+    return false;
+}
+// in Hermes engine, directProp edge is a shortcut reference
+// and is less useful for debugging leak trace
+const directPropRegex = /^directProp\d+$/;
+function isDirectPropEdge(edge) {
+    return directPropRegex.test(`${edge.name_or_index}`);
+}
+function isReturnEdge(edge) {
+    if (!edge) {
+        return false;
+    }
+    if (typeof edge.name_or_index !== 'string') {
+        return false;
+    }
+    return edge.name_or_index.startsWith('return');
+}
+function isReactPropsEdge(edge) {
+    if (!edge) {
+        return false;
+    }
+    if (typeof edge.name_or_index !== 'string') {
+        return false;
+    }
+    return edge.name_or_index.startsWith('__reactProps$');
+}
+function isReactFiberEdge(edge) {
+    if (!edge) {
+        return false;
+    }
+    if (typeof edge.name_or_index !== 'string') {
+        return false;
+    }
+    return edge.name_or_index.startsWith('__reactFiber$');
+}
+function hasReactEdges(node) {
+    if (!node) {
+        return false;
+    }
+    let ret = false;
+    node.forEachReference((edge) => {
+        if (isReactFiberEdge(edge) || isReactPropsEdge(edge)) {
+            ret = true;
+        }
+        return { stop: true };
+    });
+    return ret;
+}
+// HostRoot's stateNode should be a FiberRootNode
+function isHostRoot(node) {
+    if (!isFiberNode(node)) {
+        return false;
+    }
+    const stateNode = getToNodeByEdge(node, 'stateNode', 'property');
+    return !!stateNode && stateNode.name === 'FiberRootNode';
+}
+function getReactFiberNode(node, propName) {
+    if (!node || !isFiberNode(node)) {
+        return;
+    }
+    const targetNode = getToNodeByEdge(node, propName, 'property');
+    return isFiberNode(targetNode) ? targetNode : undefined;
+}
+// check if the current node's parent has the node as a child
+function checkIsChildOfParent(node) {
+    const parent = getToNodeByEdge(node, 'return', 'property');
+    let matched = false;
+    iterateChildFiberNodes(parent, child => {
+        if (child.id === node.id) {
+            matched = true;
+            return { stop: true };
+        }
+    });
+    return matched;
+}
+// iterate through immediate children
+function iterateChildFiberNodes(node, cb) {
+    if (!isFiberNode(node)) {
+        return;
+    }
+    const visited = new Set();
+    let cur = getReactFiberNode(node, 'child');
+    while (cur && isFiberNode(cur) && !visited.has(cur.id)) {
+        const ret = cb(cur);
+        visited.add(cur.id);
+        if (ret && ret.stop) {
+            break;
+        }
+        cur = getReactFiberNode(cur, 'sibling');
+    }
+}
+function iterateDescendantFiberNodes(node, iteratorCB) {
+    if (!isFiberNode(node)) {
+        return;
+    }
+    const visited = new Set();
+    const stack = [node];
+    while (stack.length > 0) {
+        const cur = stack.pop();
+        if (!cur) {
+            continue;
+        }
+        const ret = iteratorCB(cur);
+        visited.add(cur.id);
+        if (ret && ret.stop) {
+            break;
+        }
+        iterateChildFiberNodes(cur, child => {
+            if (visited.has(child.id)) {
+                return;
+            }
+            stack.push(child);
+        });
+    }
+}
+function getNodesIdSet(snapshot) {
+    const set = new Set();
+    snapshot.nodes.forEach(node => {
+        set.add(node.id);
+    });
+    return set;
+}
+// given a set of nodes S, return a subset S' where
+// no nodes are dominaeted by nodes in S
+function getConditionalDominatorIds(ids, snapshot, condCb) {
+    const dominatorIds = new Set();
+    // set all node ids
+    applyToNodes(ids, snapshot, node => {
+        if (condCb(node)) {
+            dominatorIds.add(node.id);
+        }
+    });
+    // traverse the dominators and remove the node
+    // if one of it's dominators is already in the set
+    applyToNodes(ids, snapshot, node => {
+        const visited = new Set([node.id]);
+        let cur = node.dominatorNode;
+        while (cur) {
+            if (visited.has(cur.id)) {
+                break;
+            }
+            if (dominatorIds.has(cur.id)) {
+                dominatorIds.delete(node.id);
+                break;
+            }
+            visited.add(cur.id);
+            cur = cur.dominatorNode;
+        }
+    });
+    return dominatorIds;
+}
+const ALTERNATE_NODE_FLAG = 0b1;
+const REGULAR_NODE_FLAG = 0b10;
+function setFiberNodeAttribute(node, flag) {
+    if (!node || !isFiberNode(node)) {
+        return;
+    }
+    // eslint-disable-next-line no-bitwise
+    node.attributes |= flag;
+}
+function hasFiberNodeAttribute(node, flag) {
+    if (!isFiberNode(node)) {
+        return false;
+    }
+    return !!(node.attributes & flag);
+}
+function setIsAlternateNode(node) {
+    setFiberNodeAttribute(node, ALTERNATE_NODE_FLAG);
+}
+function isAlternateNode(node) {
+    return hasFiberNodeAttribute(node, ALTERNATE_NODE_FLAG);
+}
+function setIsRegularFiberNode(node) {
+    setFiberNodeAttribute(node, REGULAR_NODE_FLAG);
+}
+function isRegularFiberNode(node) {
+    return hasFiberNodeAttribute(node, REGULAR_NODE_FLAG);
+}
+// The Fiber tree starts with a special type of Fiber node (HostRoot).
+function hasHostRoot(node) {
+    if (node && node.is_detached) {
+        return false;
+    }
+    let cur = node;
+    const visitedIds = new Set();
+    const visitedNodes = new Set();
+    while (cur && isFiberNode(cur)) {
+        if (cur.id == null || visitedIds.has(cur.id)) {
+            break;
+        }
+        visitedNodes.add(cur);
+        visitedIds.add(cur.id);
+        if (isHostRoot(cur)) {
+            return true;
+        }
+        cur = getReactFiberNode(cur, 'return');
+    }
+    for (const visitedNode of visitedNodes) {
+        visitedNode.markAsDetached();
+    }
+    return false;
+}
+function filterNodesInPlace(idSet, snapshot, cb) {
+    const ids = Array.from(idSet.keys());
+    for (const id of ids) {
+        const node = snapshot.getNodeById(id);
+        if (node && !cb(node, snapshot)) {
+            idSet.delete(id);
+        }
+    }
+}
+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) {
+        ids = ids.reverse();
+    }
+    for (const id of ids) {
+        const node = snapshot.getNodeById(id);
+        if (!node) {
+            Console_1.default.warning(`node @${id} is not found`);
+            return;
+        }
+        cb(node, snapshot);
+    }
+}
+function checkScenarioInstance(s) {
+    if (typeof s !== 'object' ||
+        typeof s.url !== 'function' ||
+        (s.action && typeof s.action !== 'function') ||
+        (s.back && typeof s.back !== 'function') ||
+        (s.repeat && typeof s.repeat !== 'function') ||
+        (s.isPageLoaded && typeof s.isPageLoaded !== 'function') ||
+        (s.leakFilter && typeof s.leakFilter !== 'function') ||
+        (s.beforeLeakFilter && typeof s.beforeLeakFilter !== 'function')) {
+        throw new Error('Invalid senario');
+    }
+    return s;
+}
+function loadLeakFilter(filename) {
+    const filepath = resolveFilePath(filename);
+    if (!filepath || !fs_1.default.existsSync(filepath)) {
+        // add a throw to silent the type error
+        throw haltOrThrow(`Leak filter definition file doesn't exist: ${filepath}`);
+    }
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        let filter = require(filepath);
+        if (typeof filter === 'function') {
+            return { leakFilter: filter };
+        }
+        filter = (filter === null || filter === void 0 ? void 0 : filter.default) || filter;
+        if (typeof filter === 'function') {
+            return { leakFilter: filter };
+        }
+        if (typeof (filter === null || filter === void 0 ? void 0 : filter.leakFilter) === 'function') {
+            return filter;
+        }
+        throw haltOrThrow(`Invalid leak filter in ${filepath}`);
+    }
+    catch (ex) {
+        throw haltOrThrow('Invalid leak filter definition file: ' + filename);
+    }
+}
+function loadScenario(filename) {
+    const filepath = resolveFilePath(filename);
+    if (!filepath || !fs_1.default.existsSync(filepath)) {
+        // add a throw to silent the type error
+        throw haltOrThrow(`Scenario file doesn't exist: ${filepath}`);
+    }
+    let scenario;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        scenario = require(filepath);
+        scenario = checkScenarioInstance(scenario);
+        if (scenario.name == null) {
+            scenario.name = () => path_1.default.basename(filename);
+        }
+        return scenario;
+    }
+    catch (ex) {
+        throw haltOrThrow('Invalid scenario file: ' + filename);
+    }
+}
+function getScenarioName(scenario) {
+    if (!scenario.name) {
+        return Constant_1.default.namePrefixForScenarioFromFile;
+    }
+    return Constant_1.default.namePrefixForScenarioFromFile + '-' + scenario.name();
+}
+function handleSnapshotError(e) {
+    haltOrThrow(e, {
+        primaryMessageToPrint: 'Error parsing heap snapshot',
+        secondaryMessageToPrint: 'Please pass in a valid heap snapshot file',
+    });
+}
+function getSnapshotFromFile(filename, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        Console_1.default.overwrite('parsing ' + filename + ' ...');
+        let ret = null;
+        try {
+            ret = yield HeapParser_1.default.parse(filename, options);
+        }
+        catch (e) {
+            handleSnapshotError(getError(e));
+        }
+        return ret;
+    });
+}
+function getSnapshotNodeIdsFromFile(filename, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        Console_1.default.overwrite('lightweight parsing ' + filename + ' ...');
+        let ret = new Set();
+        try {
+            ret = yield HeapParser_1.default.getNodeIdsFromFile(filename, options);
+        }
+        catch (e) {
+            handleSnapshotError(getError(e));
+        }
+        return ret;
+    });
+}
+const weakMapKeyRegExp = /@(\d+)\) ->/;
+function getWeakMapEdgeKeyId(edge) {
+    const name = edge.name_or_index;
+    if (typeof name !== 'string') {
+        return -1;
+    }
+    const ret = name.match(weakMapKeyRegExp);
+    if (!ret) {
+        return -1;
+    }
+    return Number(ret[1]);
+}
+function isDocumentDOMTreesRoot(node) {
+    if (!node) {
+        return false;
+    }
+    return node.type === 'synthetic' && node.name === '(Document DOM trees)';
+}
+function getEdgeByNameAndType(node, edgeName, type) {
+    if (!node) {
+        return null;
+    }
+    return node.findReference((edge) => edge.name_or_index === edgeName &&
+        (type === undefined || edge.type === type));
+}
+function getEdgeStartsWithName(node, prefix) {
+    if (!node) {
+        return null;
+    }
+    return node.findReference(edge => typeof edge.name_or_index === 'string' &&
+        edge.name_or_index.startsWith(prefix));
+}
+function isStringNode(node) {
+    const type = node.type;
+    return (type === 'string' ||
+        type === 'sliced string' ||
+        type === 'concatenated string');
+}
+function isSlicedStringNode(node) {
+    return node.type === 'sliced string';
+}
+function getStringNodeValue(node) {
+    var _a, _b, _c;
+    if (!node) {
+        return '';
+    }
+    if (node.type === 'concatenated string') {
+        const firstNode = (_a = getEdgeByNameAndType(node, 'first')) === null || _a === void 0 ? void 0 : _a.toNode;
+        const secondNode = (_b = getEdgeByNameAndType(node, 'second')) === null || _b === void 0 ? void 0 : _b.toNode;
+        return getStringNodeValue(firstNode) + getStringNodeValue(secondNode);
+    }
+    if (isSlicedStringNode(node)) {
+        const parentNode = (_c = getEdgeByNameAndType(node, 'parent')) === null || _c === void 0 ? void 0 : _c.toNode;
+        return getStringNodeValue(parentNode);
+    }
+    return node.name;
+}
+function extractClosureNodeInfo(node) {
+    let name = _extractClosureNodeInfo(node);
+    // replace all [, ], (, and )
+    name = name.replace(/[[\]()]/g, '');
+    return name;
+}
+function _extractClosureNodeInfo(node) {
+    if (!node) {
+        return '';
+    }
+    const name = node.name === '' ? '<anonymous>' : node.name;
+    if (node.type !== 'closure') {
+        return name;
+    }
+    // node.shared
+    const sharedEdge = getEdgeByNameAndType(node, 'shared');
+    if (!sharedEdge) {
+        return name;
+    }
+    // node.shared.function_data
+    const sharedNode = sharedEdge.toNode;
+    const functionDataEdge = getEdgeByNameAndType(sharedNode, 'function_data');
+    if (!functionDataEdge) {
+        return name;
+    }
+    // node.shared.function_data[0]
+    const functionDataNode = functionDataEdge.toNode;
+    const displaynameEdge = getEdgeByNameAndType(functionDataNode, 0, 'hidden');
+    if (!displaynameEdge) {
+        return name;
+    }
+    // extract display name
+    const displayNameNode = displaynameEdge.toNode;
+    if (displayNameNode.type === 'concatenated string' ||
+        displayNameNode.type === 'string' ||
+        displayNameNode.type === 'sliced string') {
+        const str = getStringNodeValue(displayNameNode);
+        if (str !== '') {
+            return `${name} ${str}`;
+        }
+    }
+    return name;
+}
+function extractFiberNodeInfo(node) {
+    let name = _extractFiberNodeInfo(node);
+    const tagName = _extractFiberNodeTagInfo(node);
+    if (tagName) {
+        name += ` ${tagName}`;
+    }
+    // simplify redundant pattern:
+    //  "(Detached )FiberNode X from X.react" -> "(Detached )FiberNode X"
+    const detachedPrefix = 'Detached ';
+    let prefix = '';
+    if (name.startsWith(detachedPrefix)) {
+        prefix = detachedPrefix;
+        name = name.substring(detachedPrefix.length);
+    }
+    const matches = name.match(/^FiberNode (\w+) \[from (\w+)\.react\]$/);
+    if (matches && matches[1] === matches[2]) {
+        name = `FiberNode ${matches[1]}`;
+    }
+    // replace all [, ], (, and )
+    name = name.replace(/[[\]()]/g, '');
+    return prefix + name;
+}
+function getNumberNodeValue(node) {
+    if (!node) {
+        return null;
+    }
+    if (Config_1.default.jsEngine === 'hermes') {
+        return +node.name;
+    }
+    const valueNode = getToNodeByEdge(node, 'value', 'internal');
+    if (!valueNode) {
+        return null;
+    }
+    return +valueNode.name;
+}
+function getBooleanNodeValue(node) {
+    if (node === null || node === undefined) {
+        return null;
+    }
+    if (Config_1.default.jsEngine === 'hermes') {
+        return node.name === 'true';
+    }
+    const valueNode = getToNodeByEdge(node, 'value', 'internal');
+    if (valueNode === null || valueNode === undefined) {
+        return null;
+    }
+    return valueNode.name === 'true';
+}
+function _extractFiberNodeTagInfo(node) {
+    if (!node) {
+        return null;
+    }
+    if (!isFiberNode(node)) {
+        return null;
+    }
+    const tagNode = getToNodeByEdge(node, 'tag', 'property');
+    if (!tagNode) {
+        return null;
+    }
+    if (tagNode.type !== 'number') {
+        return null;
+    }
+    const tagId = getNumberNodeValue(tagNode);
+    return _getReactWorkTagName(tagId);
+}
+function getToNodeByEdge(node, propName, propType) {
+    const edge = getEdgeByNameAndType(node, propName, propType);
+    if (!edge) {
+        return null;
+    }
+    return edge.toNode;
+}
+function getSymbolNodeValue(node) {
+    if (!node || node.name !== 'symbol') {
+        return null;
+    }
+    const nameNode = getToNodeByEdge(node, 'name');
+    if (!nameNode) {
+        return null;
+    }
+    return nameNode.name;
+}
+function _extractFiberNodeInfo(node) {
+    if (!node) {
+        return '';
+    }
+    const name = node.name;
+    if (!isFiberNode(node)) {
+        return name;
+    }
+    // extract FiberNode.type
+    const typeNode = getToNodeByEdge(node, 'type', 'property');
+    if (!typeNode) {
+        return name;
+    }
+    if (typeNode.type === 'string') {
+        return `${name} ${typeNode.name}`;
+    }
+    // extract FiberNode.type.render
+    const renderNode = getToNodeByEdge(typeNode, 'render');
+    if (renderNode && renderNode.name) {
+        return `${name} ${renderNode.name}`;
+    }
+    // if FiberNode.type or FiberNode.elementType is a symbol
+    let value = getSymbolNodeValue(typeNode);
+    if (value) {
+        return `${name} ${value}`;
+    }
+    const elementTypeNode = getToNodeByEdge(node, 'elementType', 'property');
+    value = getSymbolNodeValue(elementTypeNode);
+    if (value) {
+        return `${name} ${value}`;
+    }
+    // extract FiberNode.elementType.$$typeof
+    const typeofNode = getToNodeByEdge(elementTypeNode, '$$typeof', 'property');
+    value = getSymbolNodeValue(typeofNode);
+    if (value) {
+        return `${name} ${value}`;
+    }
+    // extract FiberNode.type.displayName
+    const displayNameNode = getToNodeByEdge(typeNode, 'displayName');
+    if (!displayNameNode) {
+        return name;
+    }
+    if (displayNameNode.type === 'string') {
+        return `${name} ${displayNameNode.name}`;
+    }
+    if (displayNameNode.type === 'concatenated string') {
+        return `${name} ${getStringNodeValue(displayNameNode)}`;
+    }
+    return name;
+}
+function extractHTMLElementNodeInfo(node) {
+    if (!node) {
+        return '';
+    }
+    const reactFiberEdge = getEdgeStartsWithName(node, '__reactFiber$');
+    if (!reactFiberEdge) {
+        return node.name;
+    }
+    return `${node.name} ${extractFiberNodeInfo(reactFiberEdge.toNode)}`;
+}
+function hasOnlyWeakReferrers(node) {
+    const referrer = node.findAnyReferrer((edge) => edge.type !== 'weak' && edge.type !== 'shortcut');
+    return !!referrer;
+}
+function getRunMetaFilePath() {
+    return Config_1.default.useExternalSnapshot
+        ? Config_1.default.externalRunMetaFile
+        : Config_1.default.runMetaFile;
+}
+function loadRunMetaInfo() {
+    const file = getRunMetaFilePath();
+    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.');
+    }
+}
+function loadTargetInfoFromRunMeta() {
+    const meta = loadRunMetaInfo();
+    Config_1.default.targetApp = meta.app;
+    Config_1.default.targetTab = meta.interaction;
+    BrowserInfo_1.default.load(meta.browserInfo);
+}
+function getSnapshotSequenceFilePath() {
+    if (!Config_1.default.useExternalSnapshot) {
+        // load the snapshot sequence meta file from the default location
+        return Config_1.default.snapshotSequenceFile;
+    }
+    if (Config_1.default.externalSnapshotDir) {
+        // try to load the snap-seq.json file from the specified external dir
+        const metaFile = path_1.default.join(Config_1.default.externalSnapshotDir, 'snap-seq.json');
+        if (fs_1.default.existsSync(metaFile)) {
+            return metaFile;
+        }
+    }
+    // otherwise return the default meta file for external snapshots
+    return Config_1.default.externalSnapshotVisitOrderFile;
+}
+// this should be called only after exploration
+function loadTabsOrder() {
+    try {
+        const content = fs_1.default.readFileSync(getSnapshotSequenceFilePath(), 'UTF-8');
+        return JSON.parse(content);
+    }
+    catch (_a) {
+        throw haltOrThrow('snapshot meta data invalid or missing');
+    }
+}
+// if true the leak trace is will be reported
+function isInterestingPath(p) {
+    // do not filter paths when analyzing Hermes snapshots
+    if (Config_1.default.jsEngine === 'hermes') {
+        return true;
+    }
+    // if the path has pattern: Window -> [InternalNode]+ -> DetachedElement
+    if (Config_1.default.hideBrowserLeak && internalNodeRetainsDetachedElement(p)) {
+        return false;
+    }
+    // if the path has pattern: ShadowRoot -> DetachedElement
+    if (Config_1.default.hideBrowserLeak && shadowRootRetainsDetachedElement(p)) {
+        return false;
+    }
+    return true;
+}
+// return true if the heap node represents JS object or closure
+function isObjectNode(node) {
+    if (isPlainJSObjectNode(node)) {
+        return true;
+    }
+    return node.type === 'closure';
+}
+// return true if the heap node represents JS object
+function isPlainJSObjectNode(node) {
+    if (!node) {
+        return false;
+    }
+    if (Config_1.default.jsEngine === 'hermes') {
+        return node.name === 'Object' || node.name.startsWith('Object(');
+    }
+    return node.name === 'Object';
+}
+// check if the path has pattern:
+// Window -> [InternalNode | Text]+ -> DetachedElement
+function internalNodeRetainsDetachedElement(path) {
+    var _a, _b;
+    if (!path) {
+        return false;
+    }
+    let p = path;
+    // GC root is not Window
+    if (!p.node || !p.node.name.startsWith('Window')) {
+        return false;
+    }
+    p = p.next;
+    // Window is not poining to InternalNode
+    if (!p || !p.node || p.node.name !== 'InternalNode') {
+        return false;
+    }
+    // skip the rest InternalNode
+    while (((_a = p.node) === null || _a === void 0 ? void 0 : _a.name) === 'InternalNode' || ((_b = p.node) === null || _b === void 0 ? void 0 : _b.name) === 'Text') {
+        p = p.next;
+        if (!p) {
+            return false;
+        }
+    }
+    // check if the node is a detached element
+    return p && isDetachedDOMNode(p.node);
+}
+// check if the path has pattern: ShadowRoot -> DetachedElement
+function shadowRootRetainsDetachedElement(path) {
+    let p = path;
+    // find the ShadowRoot
+    while (p && p.node && p.node.name !== 'ShadowRoot') {
+        p = p.next;
+        if (!p) {
+            return false;
+        }
+    }
+    p = p.next;
+    // check if the node is a detached element
+    return !!p && isDetachedDOMNode(p.node);
+}
+function pathHasDetachedHTMLNode(path) {
+    if (!path) {
+        return false;
+    }
+    let p = path;
+    while (p) {
+        if (p.node && isDetachedDOMNode(p.node)) {
+            return true;
+        }
+        p = p.next;
+    }
+    return false;
+}
+function pathHasEdgeWithIndex(path, idx) {
+    if (!path || typeof idx !== 'number') {
+        return false;
+    }
+    let p = path;
+    while (p) {
+        if (p.edge && p.edge.edgeIndex === idx) {
+            return true;
+        }
+        p = p.next;
+    }
+    return false;
+}
+function getLastNodeId(path) {
+    if (!path) {
+        return -1;
+    }
+    let p = path;
+    while (p) {
+        if (!p.next && p.node) {
+            return p.node.id;
+        }
+        p = p.next;
+    }
+    return -1;
+}
+function getReadablePercent(num) {
+    if (Number.isNaN(num)) {
+        return `${num}%`;
+    }
+    const v = num * 100;
+    let str = v.toFixed(2);
+    if (str.endsWith('.00')) {
+        str = str.slice(0, -3);
+    }
+    else if (str.endsWith('0')) {
+        str = str.slice(0, -1);
+    }
+    return str + '%';
+}
+function getReadableBytes(bytes) {
+    let n, suffix;
+    if (bytes === undefined || bytes === null) {
+        return '';
+    }
+    if (bytes >= 1e12) {
+        n = ((bytes / 1e11) | 0) / 10;
+        suffix = 'TB';
+    }
+    else if (bytes >= 1e9) {
+        n = ((bytes / 1e8) | 0) / 10;
+        suffix = 'GB';
+    }
+    else if (bytes >= 1e6) {
+        n = ((bytes / 1e5) | 0) / 10;
+        suffix = 'MB';
+    }
+    else if (bytes >= 1e3) {
+        n = ((bytes / 1e2) | 0) / 10;
+        suffix = 'KB';
+    }
+    else if (bytes > 1) {
+        n = bytes;
+        suffix = ' bytes';
+    }
+    else if (bytes >= 0) {
+        n = bytes;
+        suffix = ' byte';
+    }
+    else {
+        return '';
+    }
+    return n + suffix;
+}
+function p1(n, divide) {
+    return (((n * 10) / divide) | 0) / 10;
+}
+function getReadableTime(ms) {
+    let time = ms;
+    if (time < 1000) {
+        return `${time}ms`;
+    }
+    time /= 1000;
+    if (time < 60) {
+        return `${p1(time, 1)}s`;
+    }
+    time /= 60;
+    if (time < 60) {
+        return `${p1(time, 1)}min`;
+    }
+    time /= 60;
+    if (time < 24) {
+        return `${p1(time, 1)}hr`;
+    }
+    time /= 24;
+    return `${p1(time, 1)} days`;
+}
+function shouldShowMoreInfo(node) {
+    if (!node || !node.name) {
+        return false;
+    }
+    if (!Config_1.default.nodeToShowMoreInfo) {
+        return false;
+    }
+    return Config_1.default.nodeToShowMoreInfo.has(node.name);
+}
+function isDebuggableNode(node) {
+    if (!node) {
+        return false;
+    }
+    if (node.type === 'native' && !isDetachedDOMNode(node)) {
+        return false;
+    }
+    if (node.type === 'hidden' ||
+        node.type === 'array' ||
+        node.type === 'string' ||
+        node.type === 'number' ||
+        node.type === 'concatenated string' ||
+        node.type === 'sliced string' ||
+        node.type === 'code' ||
+        node.name === 'system / Context') {
+        return false;
+    }
+    return true;
+}
+function throwError(error) {
+    if (error) {
+        error.stack;
+    }
+    throw error;
+}
+function callAsync(f) {
+    const promise = f();
+    if (promise && promise.catch) {
+        promise.catch((e) => {
+            var _a;
+            const parsedError = getError(e);
+            Console_1.default.error(parsedError.message);
+            Console_1.default.lowLevel((_a = parsedError.stack) !== null && _a !== void 0 ? _a : '');
+        });
+    }
+}
+function checkUninstalledLibrary(ex) {
+    var _a;
+    const stackStr = (_a = ex.stack) === null || _a === void 0 ? void 0 : _a.toString();
+    if (stackStr === null || stackStr === void 0 ? void 0 : stackStr.includes('cannot open shared object file')) {
+        haltOrThrow(ex, {
+            primaryMessageToPrint: 'Could not launch Chrome. To run MemLab on a CentOS 8 devserver, please run the following command:\n',
+            secondaryMessageToPrint: 'sudo dnf install nss libwayland-client libwayland-egl egl-wayland libpng15 mesa-libGL atk java-atk-wrapper at-spi2-atk gtk3 libXt',
+        });
+    }
+}
+function closePuppeteer(browser, pages, options = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (Config_1.default.isLocalPuppeteer && !options.warmup) {
+            yield Promise.all(pages.map(page => page.close()));
+            yield browser.disconnect();
+        }
+        else {
+            yield browser.close();
+        }
+    });
+}
+function camelCaseToReadableString(str) {
+    let ret = '';
+    const isUpperCase = (c) => /^[A-Z]$/.test(c);
+    for (const c of str) {
+        if (isUpperCase(c)) {
+            ret += ret.length > 0 ? ' ' : '';
+            ret += c.toLowerCase();
+        }
+        else {
+            ret += c;
+        }
+    }
+    return ret;
+}
+// Given a file path (relative or absolute),
+// this function tries to resolve to a absolute path that exists
+// in MemLab's directories.
+// if nothing is found, it returns null.
+function resolveFilePath(file) {
+    if (!file) {
+        return null;
+    }
+    const dirs = [
+        Config_1.default.curDataDir,
+        Config_1.default.persistentDataDir,
+        Config_1.default.monoRepoDir,
+    ];
+    const paths = [file].concat(dirs.map(d => path_1.default.join(d, file)));
+    for (const p of paths) {
+        const filepath = path_1.default.resolve(p);
+        if (fs_1.default.existsSync(filepath)) {
+            return filepath;
+        }
+    }
+    return null;
+}
+const snapshotNamePattern = /^s(\d+)\.heapsnapshot$/;
+function compareSnapshotName(f1, f2) {
+    // if file name follows the 's{\d+}.heapsnapshot' pattern
+    // then order based on the ascending order of the number
+    const m1 = f1.match(snapshotNamePattern);
+    const m2 = f2.match(snapshotNamePattern);
+    if (m1 && m2) {
+        return parseInt(m1[1], 10) - parseInt(m2[1], 10);
+    }
+    // otherwise sort in alpha numeric order
+    return f1 < f2 ? -1 : f1 === f2 ? 0 : 1;
+}
+function getSnapshotFilesInDir(dir) {
+    try {
+        return fs_1.default
+            .readdirSync(dir)
+            .filter(file => file.endsWith('.heapsnapshot'))
+            .sort(compareSnapshotName)
+            .map(file => path_1.default.join(dir, file));
+    }
+    catch (ex) {
+        throw __1.utils.haltOrThrow(__1.utils.getError(ex));
+    }
+}
+function getSnapshotFilesFromTabsOrder(options = {}) {
+    const tabsOrder = loadTabsOrder();
+    const ret = [];
+    const typesSeen = new Set();
+    for (let i = 0; i < tabsOrder.length; i++) {
+        const tab = tabsOrder[i];
+        if (!tab.snapshot) {
+            continue;
+        }
+        if (tab.type) {
+            typesSeen.add(tab.type);
+        }
+        if (options.skipBeforeTabType &&
+            !typesSeen.has(options.skipBeforeTabType)) {
+            continue;
+        }
+        ret.push(getSnapshotFilePath(tab));
+    }
+    return ret;
+}
+// checks if the snapshots along with their meta data are complete
+function checkSnapshots(options = {}) {
+    if (Config_1.default.skipSnapshot) {
+        haltOrThrow('This command is run with `--no-snapshot`, skip snapshot check.');
+    }
+    let snapshotDir;
+    if (options.snapshotDir) {
+        snapshotDir = options.snapshotDir;
+    }
+    else if (Config_1.default.useExternalSnapshot) {
+        snapshotDir = Config_1.default.externalSnapshotDir || '<missing>';
+    }
+    else {
+        snapshotDir = FileManager_1.default.getCurDataDir({});
+    }
+    if (options.snapshotDir) {
+        const snapshots = getSnapshotFilesInDir(snapshotDir);
+        const min = options.minSnapshots || 1;
+        if (snapshots.length < min) {
+            __1.utils.haltOrThrow(`Directory has < ${min} snapshot files: ${options.snapshotDir}`);
+        }
+        return;
+    }
+    // check if any snapshot file is missing
+    const tabsOrder = loadTabsOrder();
+    const missingTabs = Object.create(null);
+    let miss = 0;
+    for (const tab of tabsOrder) {
+        if (!tab.snapshot) {
+            continue;
+        }
+        const file = getSnapshotFilePath(tab);
+        if (!fs_1.default.existsSync(file)) {
+            ++miss;
+            missingTabs[tab.idx] = {
+                name: tab.name,
+                url: tab.url,
+                type: tab.type,
+            };
+        }
+    }
+    if (miss > 0) {
+        const msg = 'snapshot for the following tabs are missing:';
+        const printCallback = () => {
+            Console_1.default.warning(msg);
+            Console_1.default.table(missingTabs);
+        };
+        haltOrThrow(msg + JSON.stringify(missingTabs, null, 2), {
+            printCallback,
+        });
+    }
+}
+function resolveSnapshotFilePath(snapshotFile) {
+    const file = resolveFilePath(snapshotFile);
+    if (!file) {
+        throw haltOrThrow(new Error(`Error: snapshot file doesn't exist ${snapshotFile}`));
+    }
+    return file;
+}
+exports.resolveSnapshotFilePath = resolveSnapshotFilePath;
+function getSnapshotDirForAnalysis() {
+    const dir = Config_1.default.externalSnapshotDir;
+    if (!dir) {
+        throw __1.utils.haltOrThrow(new Error('external snapshot file not set'));
+    }
+    return dir;
+}
+function getSingleSnapshotFileForAnalysis() {
+    const path = Config_1.default.useExternalSnapshot && Config_1.default.externalSnapshotFilePaths[0]
+        ? Config_1.default.externalSnapshotFilePaths[0]
+        : getSnapshotFilePathWithTabType(/(final)|(target)|(baseline)/);
+    return resolveSnapshotFilePath(path);
+}
+function getSnapshotFilePath(tab) {
+    if (!Config_1.default.useExternalSnapshot) {
+        return path_1.default.join(Config_1.default.curDataDir, `s${tab.idx}.heapsnapshot`);
+    }
+    // if we are loading snapshot from external snapshot dir
+    if (Config_1.default.externalSnapshotDir) {
+        return path_1.default.join(Config_1.default.externalSnapshotDir, `s${tab.idx}.heapsnapshot`);
+    }
+    return Config_1.default.externalSnapshotFilePaths[tab.idx - 1];
+}
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+function equalOrMatch(v1, v2) {
+    const t1 = typeof v1;
+    const t2 = typeof v2;
+    if (t1 === t2) {
+        return v1 === v2;
+    }
+    if (t1 === 'string' && v2 instanceof RegExp) {
+        return v2.test(v1);
+    }
+    if (t2 === 'string' && v1 instanceof RegExp) {
+        return v1.test(v2);
+    }
+    return false;
+}
+function getSnapshotFilePathWithTabType(type) {
+    checkSnapshots();
+    const tabsOrder = loadTabsOrder();
+    for (let i = tabsOrder.length - 1; i >= 0; --i) {
+        const tab = tabsOrder[i];
+        if (!tab.snapshot) {
+            continue;
+        }
+        if (equalOrMatch(tab.type, type)) {
+            return getSnapshotFilePath(tab);
+        }
+    }
+    return null;
+}
+function isMeaningfulNode(node) {
+    if (!node) {
+        return false;
+    }
+    if (Config_1.default.nodeNameBlockList.has(node.name)) {
+        return false;
+    }
+    if (isFiberNode(node)) {
+        const displayName = extractFiberNodeInfo(node);
+        if (Config_1.default.nodeNameBlockList.has(displayName)) {
+            return false;
+        }
+    }
+    // More details in https://github.com/ChromeDevTools/devtools-frontend
+    // under front_end/heap_snapshot_worker/HeapSnapshot.ts
+    if (node.name === 'system / NativeContext') {
+        return false;
+    }
+    if (node.name === 'system / SourcePositionTableWithFrameCache') {
+        return false;
+    }
+    if (node.name === '(map descriptors)') {
+        return false;
+    }
+    if (node.type === 'code') {
+        return false;
+    }
+    return true;
+}
+function isMeaningfulEdge(edge, options = {}) {
+    const node = options.isForward ? edge.toNode : edge.fromNode;
+    const source = options.isForward ? edge.fromNode : edge.toNode;
+    // exclude self references
+    if (source.id === node.id) {
+        return false;
+    }
+    if (typeof edge.name_or_index === 'string' &&
+        Config_1.default.edgeNameBlockList.has(edge.name_or_index)) {
+        return false;
+    }
+    // shortcut edge may be meaningful edges
+    // --forceUpdate (variable)--->  [native_bind]
+    // --bound_argument_0 (shortcut)--->  [FiberNode]
+    if (edge.type === 'weak' /* || edge.type === 'shortcut' */) {
+        return false;
+    }
+    if (options.excludeWeakMapEdge && isWeakMapEdgeToKey(edge)) {
+        return false;
+    }
+    if (options.visited && options.visited[node.nodeIndex]) {
+        return false;
+    }
+    if (options.queued && options.queued[node.nodeIndex]) {
+        return false;
+    }
+    if (!options.includeString && node.type === 'string') {
+        return false;
+    }
+    if (edge.type === 'internal' && edge.name_or_index === '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') {
+        return false;
+    }
+    if (edge.type === 'hidden' && node.name === '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;
+        // only elements at particular indexes of (map descriptors) are holding
+        // representative references to objects.
+        if (index >= 2 || (typeof index === 'number' && index % 3 === 1)) {
+            return false;
+        }
+    }
+    if (!isMeaningfulNode(node)) {
+        return false;
+    }
+    if (Config_1.default.jsEngine === 'hermes' && isDirectPropEdge(edge)) {
+        return false;
+    }
+    if (Config_1.default.ignoreInternalNode && node.name.includes('InternalNode')) {
+        return false;
+    }
+    if (Config_1.default.ignoreDevToolsConsoleLeak) {
+        const name = edge.name_or_index;
+        if (typeof name === 'string' && name.includes('DevTools console')) {
+            return false;
+        }
+    }
+    return true;
+}
+// check if two URLs are equivalent
+// for example, the following pairs are equal
+// 'https://test.com/?a=1&b=2&a=3', 'https://test.com?b=2&a=3&a=1'
+// 'https://test.com/p1/p2?a=1,b=2', 'https://test.com/p1/p2/?a=1,b=2'
+function isURLEqual(url1, url2) {
+    let u1, u2;
+    try {
+        u1 = new URL(url1);
+        u2 = new URL(url2);
+        // eslint-disable-next-line fb-www/no-unused-catch-bindings
+    }
+    catch (_e) {
+        return false;
+    }
+    // compare URL fields
+    if (u1.protocol !== u2.protocol ||
+        u1.host !== u2.host ||
+        u1.hostname !== u2.hostname ||
+        u1.port !== u2.port ||
+        u1.hash !== u2.hash) {
+        return false;
+    }
+    // compare path
+    let p1 = u1.pathname;
+    p1 = p1.endsWith('/') ? p1.slice(0, -1) : p1;
+    let p2 = u2.pathname;
+    p2 = p2.endsWith('/') ? p2.slice(0, -1) : p2;
+    if (p1 !== p2) {
+        return false;
+    }
+    // compare URL params
+    const paramKeys = new Set([
+        ...Array.from(u1.searchParams.keys()),
+        ...Array.from(u2.searchParams.keys()),
+    ]);
+    for (const key of paramKeys) {
+        const v1 = u1.searchParams.getAll(key).sort().join(' ');
+        const v2 = u2.searchParams.getAll(key).sort().join(' ');
+        if (v1 !== v2) {
+            return false;
+        }
+    }
+    return true;
+}
+function shuffleArray(array) {
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [array[i], array[j]] = [array[j], array[i]];
+    }
+    return array;
+}
+function getLeakedNode(path) {
+    let p = path;
+    const set = new Set([p]);
+    while (p.next && !set.has(p.next)) {
+        set.add(p.next);
+        p = p.next;
+    }
+    if (!p || !p.node) {
+        return null;
+    }
+    return p.node;
+}
+// print snapshot to file for local testing
+function dumpSnapshot(file, snapshot) {
+    fs_1.default.writeFileSync(file, JSON.stringify(snapshot.snapshot.meta, null, 0), 'UTF-8');
+    const dumpSection = (name, arr) => {
+        let buf = '';
+        fs_1.default.appendFileSync(file, `\n\n ${name}:\n\n`, 'UTF-8');
+        for (let i = 0; i < arr.length; ++i) {
+            buf += arr[i] + ',';
+            if (buf.length > 1024 * 1024) {
+                fs_1.default.appendFileSync(file, '\n\n' + buf, 'UTF-8');
+                buf = '';
+            }
+        }
+        fs_1.default.appendFileSync(file, '\n\n' + buf, 'UTF-8');
+        buf = '';
+    };
+    dumpSection('nodes', snapshot.nodes);
+    dumpSection('edges', snapshot.edges);
+    dumpSection('locations', snapshot.locations);
+}
+function markAllDetachedFiberNode(snapshot) {
+    Console_1.default.overwrite('marking all detached Fiber nodes...');
+    snapshot.nodes.forEach(node => {
+        // hasHostRoot checks and marks detached Fiber Nodes
+        isFiberNode(node) && !hasHostRoot(node);
+    });
+}
+function markAlternateFiberNode(snapshot) {
+    Console_1.default.overwrite('marking alternate Fiber nodes...');
+    snapshot.nodes.forEach(node => {
+        // mark the fiber root node
+        if (!isHostRoot(node)) {
+            return;
+        }
+        iterateDescendantFiberNodes(node, (descendant) => {
+            // check if the node is doubly linked to its parent
+            if (checkIsChildOfParent(descendant)) {
+                setIsRegularFiberNode(descendant);
+            }
+            // mark explicit alternate fiber node
+            setIsAlternateNode(getToNodeByEdge(descendant, 'alternate', 'property'));
+        });
+    });
+}
+function getAllDominators(node) {
+    const visited = new Set();
+    const dominators = [];
+    let cur = node;
+    while (cur && !visited.has(cur.id)) {
+        visited.add(cur.id);
+        dominators.push(cur);
+        cur = cur.dominatorNode;
+    }
+    return dominators;
+}
+function upperCaseFirstCharacter(text) {
+    if (text.length === 0) {
+        return text;
+    }
+    return text[0].toUpperCase() + text.substring(1);
+}
+function repeat(str, n) {
+    let ret = '';
+    for (let i = 0; i < n; ++i) {
+        ret += str;
+    }
+    return ret;
+}
+function normalizeBaseUrl(url) {
+    let ret = url;
+    if (url.length > 0 &&
+        !url.endsWith('.html') &&
+        !url.endsWith('.htm') &&
+        !url.endsWith('/')) {
+        ret += '/';
+    }
+    return ret;
+}
+function haltOrThrow(errorInfo, options = {}) {
+    var _a;
+    const err = getError(errorInfo);
+    const halt = () => __awaiter(this, void 0, void 0, function* () {
+        var _b;
+        if (options.printErrorBeforeHalting !== false) {
+            // only print the error.message when there is no
+            // primary message to print or there is no print callback
+            if (!options.primaryMessageToPrint && !options.printCallback) {
+                Console_1.default.error(err.message);
+            }
+            // only print stack trace in verbose mode
+            if (Config_1.default.verbose) {
+                Console_1.default.lowLevel((_b = err.stack) !== null && _b !== void 0 ? _b : '');
+            }
+            else {
+                Console_1.default.topLevel('Use `memlab help` or `memlab <COMMAND> -h` to get helper text');
+            }
+            if (options.primaryMessageToPrint) {
+                Console_1.default.error(options.primaryMessageToPrint);
+            }
+            if (options.secondaryMessageToPrint) {
+                Console_1.default.lowLevel(options.secondaryMessageToPrint);
+            }
+            if (options.printCallback) {
+                options.printCallback();
+            }
+        }
+        throw process_1.default.exit(1);
+    });
+    const throwErr = () => {
+        let message = '';
+        // show primary message
+        if (options.primaryMessageToPrint) {
+            message = options.primaryMessageToPrint;
+        }
+        else {
+            message = err.message;
+        }
+        // append secondary message
+        if (options.secondaryMessageToPrint) {
+            message += `(${options.secondaryMessageToPrint})`;
+        }
+        // if already specified a primary message,
+        // append the error.message at the end
+        if (options.primaryMessageToPrint) {
+            if (message.length > 0 && !message.endsWith('.')) {
+                message += '. ';
+            }
+            message += err.message;
+        }
+        err.message = message;
+        throw err;
+    };
+    const handling = (_a = options === null || options === void 0 ? void 0 : options.errorHandling) !== null && _a !== void 0 ? _a : Config_1.default.errorHandling;
+    switch (handling) {
+        case Config_1.ErrorHandling.Halt:
+            halt();
+            break;
+        case Config_1.ErrorHandling.Throw:
+            throwErr();
+            break;
+    }
+    throw 'unreachable';
+}
+function getError(maybeError) {
+    if (maybeError instanceof Error) {
+        return maybeError;
+    }
+    return convertToError(maybeError);
+}
+function convertToError(maybeError) {
+    if (isErrorWithMessage(maybeError)) {
+        return new Error(maybeError.message);
+    }
+    try {
+        const msg = typeof maybeError === 'string' ? maybeError : JSON.stringify(maybeError);
+        return new Error(msg);
+    }
+    catch (_a) {
+        // fallback in case there's an error stringifying the maybeError
+        // like with circular references for example.
+        return new Error(String(maybeError));
+    }
+}
+function isErrorWithMessage(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        typeof error.message === 'string');
+}
+// check if a node is dominated by an array referenced as 'deletions'
+// React stores unmounted fiber nodes that will be deleted soon in
+// a 'deletions' array.
+function isNodeDominatedByDeletionsArray(node) {
+    const dominators = getAllDominators(node);
+    return dominators.some(dominator => {
+        const edges = dominator.referrers;
+        return edges.some(e => e.name_or_index === 'deletions');
+    });
+}
+let uindex = 1;
+function getUniqueID() {
+    return `${process_1.default.pid}-${Date.now()}-${uindex++}`;
+}
+exports.default = {
+    applyToNodes,
+    callAsync,
+    camelCaseToReadableString,
+    checkSnapshots,
+    checkUninstalledLibrary,
+    checkIsChildOfParent,
+    closePuppeteer,
+    dumpSnapshot,
+    equalOrMatch,
+    extractClosureNodeInfo,
+    extractFiberNodeInfo,
+    extractHTMLElementNodeInfo,
+    filterNodesInPlace,
+    getAllDominators,
+    getConditionalDominatorIds,
+    getError,
+    getEdgeByNameAndType,
+    getLastNodeId,
+    getLeakedNode,
+    getNodesIdSet,
+    getNumberNodeValue,
+    getReadableBytes,
+    getReadablePercent,
+    getReadableTime,
+    getRunMetaFilePath,
+    getScenarioName,
+    getSingleSnapshotFileForAnalysis,
+    getSnapshotDirForAnalysis,
+    getSnapshotFilesInDir,
+    getSnapshotFilesFromTabsOrder,
+    getSnapshotFromFile,
+    getSnapshotNodeIdsFromFile,
+    getSnapshotSequenceFilePath,
+    getSnapshotFilePath,
+    getSnapshotFilePathWithTabType,
+    getStringNodeValue,
+    getToNodeByEdge,
+    getUniqueID,
+    getWeakMapEdgeKeyId,
+    haltOrThrow,
+    hasHostRoot,
+    hasOnlyWeakReferrers,
+    hasReactEdges,
+    isAlternateNode,
+    isBlinkRootNode,
+    isDebuggableNode,
+    isDetachedFiberNode,
+    isDetachedDOMNode,
+    isDirectPropEdge,
+    isDocumentDOMTreesRoot,
+    isEssentialEdge,
+    isFiberNode,
+    isFiberNodeDeletionsEdge,
+    isHermesInternalObject,
+    isHostRoot,
+    isInterestingPath,
+    isMeaningfulEdge,
+    isMeaningfulNode,
+    isNodeDominatedByDeletionsArray,
+    isObjectNode,
+    isPendingActivityNode,
+    isPlainJSObjectNode,
+    isReactFiberEdge,
+    isReactPropsEdge,
+    isRegularFiberNode,
+    isReturnEdge,
+    isRootNode,
+    isSlicedStringNode,
+    isStackTraceFrame,
+    isStringNode,
+    isURLEqual,
+    isWeakMapEdge,
+    isWeakMapEdgeToKey,
+    isWeakMapEdgeToValue,
+    iterateChildFiberNodes,
+    iterateDescendantFiberNodes,
+    loadRunMetaInfo,
+    loadLeakFilter,
+    loadScenario,
+    loadTabsOrder,
+    loadTargetInfoFromRunMeta,
+    markAllDetachedFiberNode,
+    markAlternateFiberNode,
+    memCache,
+    normalizeBaseUrl,
+    pathHasDetachedHTMLNode,
+    pathHasEdgeWithIndex,
+    repeat,
+    resolveFilePath,
+    resolveSnapshotFilePath,
+    setIsAlternateNode,
+    setIsRegularFiberNode,
+    shouldShowMoreInfo,
+    shuffleArray,
+    throwError,
+    upperCaseFirstCharacter,
+    getBooleanNodeValue,
+};