@memlab/core 1.0.0

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

@@ -0,0 +1,27 @@
+/**
+ * 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
+ * @lightSyntaxTransform
+ * @format
+ */
+import type { IHeapEdge } from '../Types';
+import type HeapSnapshot from './HeapSnapshot';
+import HeapNode from './HeapNode';
+export default class HeapEdge implements IHeapEdge {
+    private heapSnapshot;
+    private idx;
+    constructor(heapSnapshot: HeapSnapshot, idx: number);
+    get snapshot(): HeapSnapshot;
+    get edgeIndex(): number;
+    get type(): string;
+    get is_index(): boolean;
+    get name_or_index(): number | string;
+    get to_node(): number;
+    get toNode(): HeapNode;
+    get fromNode(): HeapNode;
+}
+//# sourceMappingURL=HeapEdge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HeapEdge.d.ts","sourceRoot":"","sources":["../../../src/lib/heap-data/HeapEdge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,UAAU,CAAC;AACxC,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAG/C,OAAO,QAAQ,MAAM,YAAY,CAAC;AAElC,MAAM,CAAC,OAAO,OAAO,QAAS,YAAW,SAAS;IACpC,OAAO,CAAC,YAAY;IAAgB,OAAO,CAAC,GAAG;gBAAvC,YAAY,EAAE,YAAY,EAAU,GAAG,EAAE,MAAM;IAEnE,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,IAAI,IAAI,IAAI,MAAM,CAQjB;IAKD,IAAI,QAAQ,IAAI,OAAO,CAGtB;IAED,IAAI,aAAa,IAAI,MAAM,GAAG,MAAM,CAYnC;IAED,IAAI,OAAO,IAAI,MAAM,CAWpB;IAED,IAAI,MAAM,IAAI,QAAQ,CAErB;IAED,IAAI,QAAQ,IAAI,QAAQ,CAKvB;CACF"}

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

@@ -0,0 +1,75 @@
+/**
+ * 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
+ * @lightSyntaxTransform
+ * @format
+ */
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HeapUtils_1 = require("./HeapUtils");
+const HeapNode_1 = __importDefault(require("./HeapNode"));
+class HeapEdge {
+    constructor(heapSnapshot, idx) {
+        this.heapSnapshot = heapSnapshot;
+        this.idx = idx;
+    }
+    get snapshot() {
+        return this.heapSnapshot;
+    }
+    get edgeIndex() {
+        return this.idx;
+    }
+    get type() {
+        const heapSnapshot = this.heapSnapshot;
+        const edgeValues = heapSnapshot.snapshot.edges;
+        const edgeFieldsCount = heapSnapshot._edgeFieldsCount;
+        const edgeTypes = heapSnapshot._edgeTypes;
+        const typeIdx = edgeValues[this.idx * edgeFieldsCount + heapSnapshot._edgeTypeOffset];
+        return edgeTypes[typeIdx];
+    }
+    // For element and hidden edges, the value in the slot is
+    // a numeric index property of the hosting object, rather
+    // than a pointer pointing to a string table.
+    get is_index() {
+        const type = this.type;
+        return type === 'element' || type === 'hidden';
+    }
+    get name_or_index() {
+        const heapSnapshot = this.heapSnapshot;
+        const edgeValues = heapSnapshot.snapshot.edges;
+        const edgeFieldsCount = heapSnapshot._edgeFieldsCount;
+        const idx = edgeValues[this.idx * edgeFieldsCount + heapSnapshot._edgeNameOrIndexOffset];
+        if (this.is_index) {
+            return idx;
+        }
+        return this.heapSnapshot.snapshot.strings[idx];
+    }
+    get to_node() {
+        const heapSnapshot = this.heapSnapshot;
+        const edgeValues = heapSnapshot.snapshot.edges;
+        const edgeFieldsCount = heapSnapshot._edgeFieldsCount;
+        const toNodeIdx = edgeValues[this.idx * edgeFieldsCount + heapSnapshot._edgeToNodeOffset];
+        const nodeFieldsCount = heapSnapshot._nodeFieldsCount;
+        if (toNodeIdx % nodeFieldsCount) {
+            (0, HeapUtils_1.throwError)(new Error('invalid idx: ' + this.idx));
+        }
+        return toNodeIdx / nodeFieldsCount;
+    }
+    get toNode() {
+        return new HeapNode_1.default(this.heapSnapshot, this.to_node);
+    }
+    get fromNode() {
+        const heapSnapshot = this.heapSnapshot;
+        const edgeIndex2SrcNodeIndex = heapSnapshot._edgeIndex2SrcNodeIndex;
+        const srcNodeIdx = edgeIndex2SrcNodeIndex[this.idx];
+        return new HeapNode_1.default(heapSnapshot, srcNodeIdx);
+    }
+}
+exports.default = HeapEdge;

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

@@ -0,0 +1,22 @@
+/**
+ * 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
+ * @lightSyntaxTransform
+ * @format
+ */
+import type { IHeapLocation } from '../Types';
+import type HeapSnapshot from './HeapSnapshot';
+export default class HeapLocation implements IHeapLocation {
+    private heapSnapshot;
+    private idx;
+    constructor(heapSnapshot: HeapSnapshot, idx: number);
+    get snapshot(): HeapSnapshot;
+    get script_id(): number;
+    get line(): number;
+    get column(): number;
+}
+//# sourceMappingURL=HeapLocation.d.ts.map

package/dist/lib/heap-data/HeapLocation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeapLocation.d.ts","sourceRoot":"","sources":["../../../src/lib/heap-data/HeapLocation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,UAAU,CAAC;AAC5C,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAE/C,MAAM,CAAC,OAAO,OAAO,YAAa,YAAW,aAAa;IAC5C,OAAO,CAAC,YAAY;IAAgB,OAAO,CAAC,GAAG;gBAAvC,YAAY,EAAE,YAAY,EAAU,GAAG,EAAE,MAAM;IAEnE,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,IAAI,SAAS,IAAI,MAAM,CAOtB;IAED,IAAI,IAAI,IAAI,MAAM,CAOjB;IAED,IAAI,MAAM,IAAI,MAAM,CAOnB;CACF"}

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

@@ -0,0 +1,40 @@
+/**
+ * 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
+ * @lightSyntaxTransform
+ * @format
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+class HeapLocation {
+    constructor(heapSnapshot, idx) {
+        this.heapSnapshot = heapSnapshot;
+        this.idx = idx;
+    }
+    get snapshot() {
+        return this.heapSnapshot;
+    }
+    get script_id() {
+        const heapSnapshot = this.heapSnapshot;
+        const locations = heapSnapshot.snapshot.locations;
+        const locationFieldsCount = heapSnapshot._locationFieldsCount;
+        return locations[this.idx * locationFieldsCount + heapSnapshot._locationScriptIdOffset];
+    }
+    get line() {
+        const heapSnapshot = this.heapSnapshot;
+        const locations = heapSnapshot.snapshot.locations;
+        const locationFieldsCount = heapSnapshot._locationFieldsCount;
+        return locations[this.idx * locationFieldsCount + heapSnapshot._locationLineOffset];
+    }
+    get column() {
+        const heapSnapshot = this.heapSnapshot;
+        const locations = heapSnapshot.snapshot.locations;
+        const locationFieldsCount = heapSnapshot._locationFieldsCount;
+        return locations[this.idx * locationFieldsCount + heapSnapshot._locationColumnOffset];
+    }
+}
+exports.default = HeapLocation;

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

@@ -0,0 +1,55 @@
+/**
+ * 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
+ * @lightSyntaxTransform
+ * @format
+ */
+import type { IHeapNode, IHeapEdge, Nullable, EdgeIterationCallback, Predicator, IHeapStringNode } from '../Types';
+import type HeapSnapshot from './HeapSnapshot';
+import HeapEdge from './HeapEdge';
+import HeapLocation from './HeapLocation';
+export default class HeapNode implements IHeapNode {
+    private heapSnapshot;
+    private idx;
+    constructor(heapSnapshot: HeapSnapshot, idx: number);
+    get snapshot(): HeapSnapshot;
+    get type(): string;
+    get name(): string;
+    get is_detached(): boolean;
+    set detachState(detachState: number);
+    markAsDetached(): void;
+    get attributes(): number;
+    set attributes(attr: number);
+    get id(): number;
+    get self_size(): number;
+    get edge_count(): number;
+    get trace_node_id(): number;
+    get references(): HeapEdge[];
+    forEachReference(callback: EdgeIterationCallback): void;
+    findReference(predicate: Predicator<IHeapEdge>): Nullable<IHeapEdge>;
+    findAnyReferrer(predicate: Predicator<IHeapEdge>): Nullable<IHeapEdge>;
+    findReferrers(predicate: Predicator<IHeapEdge>): IHeapEdge[];
+    get referrers(): HeapEdge[];
+    forEachReferrer(callback: EdgeIterationCallback): void;
+    get pathEdge(): Nullable<HeapEdge>;
+    set pathEdge(edge: Nullable<HeapEdge>);
+    get nodeIndex(): number;
+    get retainedSize(): number;
+    set retainedSize(size: number);
+    get dominatorNode(): Nullable<HeapNode>;
+    set dominatorNode(node: Nullable<HeapNode>);
+    get location(): Nullable<HeapLocation>;
+    getReference(edgeName: string | number, edgeType?: string): Nullable<IHeapEdge>;
+    getReferenceNode(edgeName: string | number, edgeType?: string): Nullable<IHeapNode>;
+    getAnyReferrer(edgeName: string | number, edgeType?: string): Nullable<IHeapEdge>;
+    getReferrers(edgeName: string | number, edgeType?: string): IHeapEdge[];
+    getAnyReferrerNode(edgeName: string | number, edgeType?: string): Nullable<IHeapNode>;
+    getReferrerNodes(edgeName: string | number, edgeType?: string): IHeapNode[];
+    get isString(): boolean;
+    toStringNode(): Nullable<IHeapStringNode>;
+}
+//# sourceMappingURL=HeapNode.d.ts.map

package/dist/lib/heap-data/HeapNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeapNode.d.ts","sourceRoot":"","sources":["../../../src/lib/heap-data/HeapNode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EACV,SAAS,EACT,SAAS,EACT,QAAQ,EACR,qBAAqB,EACrB,UAAU,EACV,eAAe,EAChB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,YAAY,MAAM,gBAAgB,CAAC;AAG/C,OAAO,QAAQ,MAAM,YAAY,CAAC;AAClC,OAAO,YAAY,MAAM,gBAAgB,CAAC;AAE1C,MAAM,CAAC,OAAO,OAAO,QAAS,YAAW,SAAS;IACpC,OAAO,CAAC,YAAY;IAAgB,OAAO,CAAC,GAAG;gBAAvC,YAAY,EAAE,YAAY,EAAU,GAAG,EAAE,MAAM;IAEnE,IAAI,QAAQ,IAAI,YAAY,CAE3B;IAED,IAAI,IAAI,IAAI,MAAM,CAQjB;IAED,IAAI,IAAI,IAAI,MAAM,CAQjB;IAED,IAAI,WAAW,IAAI,OAAO,CAezB;IAED,IAAI,WAAW,CAAC,WAAW,EAAE,MAAM,EAWlC;IAED,cAAc,IAAI,IAAI;IAItB,IAAI,UAAU,IAAI,MAAM,CAIvB;IAED,IAAI,UAAU,CAAC,IAAI,EAAE,MAAM,EAI1B;IAED,IAAI,EAAE,IAAI,MAAM,CAOf;IAED,IAAI,SAAS,IAAI,MAAM,CAOtB;IAED,IAAI,UAAU,IAAI,MAAM,CAOvB;IAED,IAAI,aAAa,IAAI,MAAM,CAO1B;IAED,IAAI,UAAU,IAAI,QAAQ,EAAE,CAe3B;IAED,gBAAgB,CAAC,QAAQ,EAAE,qBAAqB,GAAG,IAAI;IAmBvD,aAAa,CAAC,SAAS,EAAE,UAAU,CAAC,SAAS,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC;IAWpE,eAAe,CAAC,SAAS,EAAE,UAAU,CAAC,SAAS,CAAC,GAAG,QAAQ,CAAC,SAAS,CAAC;IAWtE,aAAa,CAAC,SAAS,EAAE,UAAU,CAAC,SAAS,CAAC,GAAG,SAAS,EAAE;IAW5D,IAAI,SAAS,IAAI,QAAQ,EAAE,CAa1B;IAED,eAAe,CAAC,QAAQ,EAAE,qBAAqB,GAAG,IAAI;IAiBtD,IAAI,QAAQ,IAAI,QAAQ,CAAC,QAAQ,CAAC,CAUjC;IAED,IAAI,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAYpC;IAED,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,IAAI,YAAY,CAAC,IAAI,EAAE,MAAM,EAG5B;IAED,IAAI,aAAa,IAAI,QAAQ,CAAC,QAAQ,CAAC,CAWtC;IAED,IAAI,aAAa,CAAC,IAAI,EAAE,QAAQ,CAAC,QAAQ,CAAC,EAgBzC;IAED,IAAI,QAAQ,IAAI,QAAQ,CAAC,YAAY,CAAC,CAOrC;IAGD,YAAY,CACV,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,QAAQ,CAAC,EAAE,MAAM,GAChB,QAAQ,CAAC,SAAS,CAAC;IAgBtB,gBAAgB,CACd,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,QAAQ,CAAC,EAAE,MAAM,GAChB,QAAQ,CAAC,SAAS,CAAC;IAMtB,cAAc,CACZ,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,QAAQ,CAAC,EAAE,MAAM,GAChB,QAAQ,CAAC,SAAS,CAAC;IAgBtB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,EAAE;IAavE,kBAAkB,CAChB,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,QAAQ,CAAC,EAAE,MAAM,GAChB,QAAQ,CAAC,SAAS,CAAC;IAMtB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,EAAE;IAqB3E,IAAI,QAAQ,IAAI,OAAO,CAOtB;IAED,YAAY,IAAI,QAAQ,CAAC,eAAe,CAAC;CAK1C"}

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

@@ -0,0 +1,344 @@
+/**
+ * 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
+ * @lightSyntaxTransform
+ * @format
+ */
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const HeapUtils_1 = require("./HeapUtils");
+const HeapEdge_1 = __importDefault(require("./HeapEdge"));
+const HeapLocation_1 = __importDefault(require("./HeapLocation"));
+class HeapNode {
+    constructor(heapSnapshot, idx) {
+        this.heapSnapshot = heapSnapshot;
+        this.idx = idx;
+    }
+    get snapshot() {
+        return this.heapSnapshot;
+    }
+    get type() {
+        const heapSnapshot = this.heapSnapshot;
+        const nodeValues = heapSnapshot.snapshot.nodes;
+        const nodeFieldsCount = heapSnapshot._nodeFieldsCount;
+        const nodeTypes = heapSnapshot._nodeTypes;
+        const typeIdx = nodeValues[this.idx * nodeFieldsCount + heapSnapshot._nodeTypeOffset];
+        return nodeTypes[typeIdx];
+    }
+    get name() {
+        const heapSnapshot = this.heapSnapshot;
+        const nodeValues = heapSnapshot.snapshot.nodes;
+        const nodeFieldsCount = heapSnapshot._nodeFieldsCount;
+        const strIdx = nodeValues[this.idx * nodeFieldsCount + heapSnapshot._nodeNameOffset];
+        const prefix = this.is_detached ? 'Detached ' : '';
+        return prefix + heapSnapshot.snapshot.strings[strIdx];
+    }
+    get is_detached() {
+        const heapSnapshot = this.heapSnapshot;
+        if (heapSnapshot._nodeDetachednessOffset < 0) {
+            return (heapSnapshot._externalDetachedness[this.idx] ===
+                HeapUtils_1.NodeDetachState.Detached);
+        }
+        const nodeValues = heapSnapshot.snapshot.nodes;
+        const nodeFieldsCount = heapSnapshot._nodeFieldsCount;
+        const detachState = nodeValues[this.idx * nodeFieldsCount + heapSnapshot._nodeDetachednessOffset];
+        return detachState === HeapUtils_1.NodeDetachState.Detached;
+    }
+    set detachState(detachState) {
+        const heapSnapshot = this.heapSnapshot;
+        if (heapSnapshot._nodeDetachednessOffset >= 0) {
+            const nodeValues = heapSnapshot.snapshot.nodes;
+            const nodeFieldsCount = heapSnapshot._nodeFieldsCount;
+            nodeValues[this.idx * nodeFieldsCount + heapSnapshot._nodeDetachednessOffset] = detachState;
+        }
+        else {
+            heapSnapshot._externalDetachedness[this.idx] = detachState;
+        }
+    }
+    markAsDetached() {
+        this.detachState = HeapUtils_1.NodeDetachState.Detached;
+    }
+    get attributes() {
+        const heapSnapshot = this.heapSnapshot;
+        const nodeAttributes = heapSnapshot._additionalAttributes;
+        return nodeAttributes[this.idx];
+    }
+    set attributes(attr) {
+        const heapSnapshot = this.heapSnapshot;
+        const nodeAttributes = heapSnapshot._additionalAttributes;
+        nodeAttributes[this.idx] = attr;
+    }
+    get id() {
+        const heapSnapshot = this.heapSnapshot;
+        const nodeValues = heapSnapshot.snapshot.nodes;
+        const nodeFieldsCount = heapSnapshot._nodeFieldsCount;
+        const id = nodeValues[this.idx * nodeFieldsCount + heapSnapshot._nodeIdOffset];
+        return id;
+    }
+    get self_size() {
+        const heapSnapshot = this.heapSnapshot;
+        const nodeValues = heapSnapshot.snapshot.nodes;
+        const nodeFieldsCount = heapSnapshot._nodeFieldsCount;
+        return nodeValues[this.idx * nodeFieldsCount + heapSnapshot._nodeSelfSizeOffset];
+    }
+    get edge_count() {
+        const heapSnapshot = this.heapSnapshot;
+        const nodeValues = heapSnapshot.snapshot.nodes;
+        const nodeFieldsCount = heapSnapshot._nodeFieldsCount;
+        return nodeValues[this.idx * nodeFieldsCount + heapSnapshot._nodeEdgeCountOffset];
+    }
+    get trace_node_id() {
+        const heapSnapshot = this.heapSnapshot;
+        const nodeValues = heapSnapshot.snapshot.nodes;
+        const nodeFieldsCount = heapSnapshot._nodeFieldsCount;
+        return nodeValues[this.idx * nodeFieldsCount + heapSnapshot._nodeTraceNodeIdOffset];
+    }
+    get references() {
+        const ret = [];
+        const heapSnapshot = this.heapSnapshot;
+        const edgeFieldsCount = heapSnapshot._edgeFieldsCount;
+        const firstEdgePointers = heapSnapshot._firstEdgePointers;
+        const beginEdgeIdx = firstEdgePointers[this.idx];
+        const endEdgeIdx = firstEdgePointers[this.idx + 1];
+        for (let edgeIdx = beginEdgeIdx; edgeIdx < endEdgeIdx; edgeIdx += edgeFieldsCount) {
+            ret.push(new HeapEdge_1.default(heapSnapshot, edgeIdx / edgeFieldsCount));
+        }
+        return ret;
+    }
+    forEachReference(callback) {
+        const heapSnapshot = this.heapSnapshot;
+        const edgeFieldsCount = heapSnapshot._edgeFieldsCount;
+        const firstEdgePointers = heapSnapshot._firstEdgePointers;
+        const beginEdgeIdx = firstEdgePointers[this.idx];
+        const endEdgeIdx = firstEdgePointers[this.idx + 1];
+        for (let edgeIdx = beginEdgeIdx; edgeIdx < endEdgeIdx; edgeIdx += edgeFieldsCount) {
+            const edge = new HeapEdge_1.default(heapSnapshot, edgeIdx / edgeFieldsCount);
+            const ret = callback(edge);
+            if (ret && ret.stop) {
+                break;
+            }
+        }
+    }
+    findReference(predicate) {
+        let found = null;
+        this.forEachReference((edge) => {
+            if (predicate(edge)) {
+                found = edge;
+                return { stop: true };
+            }
+        });
+        return found;
+    }
+    findAnyReferrer(predicate) {
+        let found = null;
+        this.forEachReferrer((edge) => {
+            if (predicate(edge)) {
+                found = edge;
+                return { stop: true };
+            }
+        });
+        return found;
+    }
+    findReferrers(predicate) {
+        const ret = [];
+        this.forEachReferrer((edge) => {
+            if (predicate(edge)) {
+                ret.push(edge);
+            }
+            return null;
+        });
+        return ret;
+    }
+    get referrers() {
+        const heapSnapshot = this.heapSnapshot;
+        const retainingEdgeIndex2EdgeIndex = heapSnapshot._retainingEdgeIndex2EdgeIndex;
+        const firstRetainerIndex = heapSnapshot._firstRetainerIndex;
+        const ret = [];
+        const beginIdx = firstRetainerIndex[this.idx];
+        const endIdx = firstRetainerIndex[this.idx + 1];
+        for (let idx = beginIdx; idx < endIdx; idx++) {
+            const retainingEdgeIdx = retainingEdgeIndex2EdgeIndex[idx];
+            ret.push(new HeapEdge_1.default(heapSnapshot, retainingEdgeIdx));
+        }
+        return ret;
+    }
+    forEachReferrer(callback) {
+        const heapSnapshot = this.heapSnapshot;
+        const retainingEdgeIndex2EdgeIndex = heapSnapshot._retainingEdgeIndex2EdgeIndex;
+        const firstRetainerIndex = heapSnapshot._firstRetainerIndex;
+        const beginIdx = firstRetainerIndex[this.idx];
+        const endIdx = firstRetainerIndex[this.idx + 1];
+        for (let idx = beginIdx; idx < endIdx; idx++) {
+            const retainingEdgeIdx = retainingEdgeIndex2EdgeIndex[idx];
+            const edge = new HeapEdge_1.default(heapSnapshot, retainingEdgeIdx);
+            const ret = callback(edge);
+            if (ret && ret.stop) {
+                break;
+            }
+        }
+    }
+    get pathEdge() {
+        const heapSnapshot = this.heapSnapshot;
+        if (heapSnapshot._nodeIdxHasPathEdge[this.idx] === 0) {
+            return null;
+        }
+        if (this.idx >= heapSnapshot._nodeIdx2PathEdgeIdx.length) {
+            (0, HeapUtils_1.throwError)(new Error('invalid idx: ' + this.idx));
+        }
+        const edgeIdx = heapSnapshot._nodeIdx2PathEdgeIdx[this.idx];
+        return new HeapEdge_1.default(heapSnapshot, edgeIdx);
+    }
+    set pathEdge(edge) {
+        const heapSnapshot = this.heapSnapshot;
+        if (!edge) {
+            heapSnapshot._nodeIdxHasPathEdge[this.idx] = 0;
+            return;
+        }
+        const edgeIdx = edge.edgeIndex;
+        if (this.idx >= heapSnapshot._nodeIdx2PathEdgeIdx.length) {
+            (0, HeapUtils_1.throwError)(new Error('invalid idx: ' + this.idx));
+        }
+        heapSnapshot._nodeIdx2PathEdgeIdx[this.idx] = edgeIdx;
+        heapSnapshot._nodeIdxHasPathEdge[this.idx] = 1;
+    }
+    get nodeIndex() {
+        return this.idx;
+    }
+    get retainedSize() {
+        return this.heapSnapshot._nodeIdx2RetainedSize[this.idx];
+    }
+    set retainedSize(size) {
+        const heapSnapshot = this.heapSnapshot;
+        heapSnapshot._nodeIdx2RetainedSize[this.idx] = size;
+    }
+    get dominatorNode() {
+        const heapSnapshot = this.heapSnapshot;
+        const nodeIdx2DominatorNodeIdx = heapSnapshot._nodeIdx2DominatorNodeIdx;
+        if (this.idx >= nodeIdx2DominatorNodeIdx.length) {
+            (0, HeapUtils_1.throwError)(new Error('invalid idx: ' + this.idx));
+        }
+        if (heapSnapshot._nodeIdxHasDominatorNode[this.idx] === 0) {
+            return null;
+        }
+        const dominatorNodeIdx = nodeIdx2DominatorNodeIdx[this.idx];
+        return new HeapNode(heapSnapshot, dominatorNodeIdx);
+    }
+    set dominatorNode(node) {
+        const heapSnapshot = this.heapSnapshot;
+        if (!node) {
+            heapSnapshot._nodeIdxHasDominatorNode[this.idx] = 0;
+            return;
+        }
+        const nodeIdx2DominatorNodeIdx = heapSnapshot._nodeIdx2DominatorNodeIdx;
+        const dominatorNodeIdx = node.nodeIndex;
+        if (this.idx >= nodeIdx2DominatorNodeIdx.length ||
+            dominatorNodeIdx >= nodeIdx2DominatorNodeIdx.length) {
+            (0, HeapUtils_1.throwError)(new Error('invalid idx: ' + this.idx));
+        }
+        nodeIdx2DominatorNodeIdx[this.idx] = dominatorNodeIdx;
+        heapSnapshot._nodeIdxHasDominatorNode[this.idx] = 1;
+    }
+    get location() {
+        const heapSnapshot = this.heapSnapshot;
+        const locationIdx = heapSnapshot._nodeIdx2LocationIdx[this.idx];
+        if (locationIdx === undefined) {
+            return null;
+        }
+        return new HeapLocation_1.default(heapSnapshot, locationIdx);
+    }
+    // search reference by edge name and edge type
+    getReference(edgeName, edgeType) {
+        let ret = null;
+        this.forEachReference((edge) => {
+            if (edge.name_or_index !== edgeName) {
+                return;
+            }
+            if (edgeType != null && edge.type !== edgeType) {
+                return;
+            }
+            ret = edge;
+            return { stop: true };
+        });
+        return ret;
+    }
+    // search referenced node by edge name and edge type
+    getReferenceNode(edgeName, edgeType) {
+        const edge = this.getReference(edgeName, edgeType);
+        return edge && edge.toNode;
+    }
+    // search any referrer edge by edge name and edge type
+    getAnyReferrer(edgeName, edgeType) {
+        let ret = null;
+        this.forEachReferrer((edge) => {
+            if (edge.name_or_index !== edgeName) {
+                return;
+            }
+            if (edgeType != null && edge.type !== edgeType) {
+                return;
+            }
+            ret = edge;
+            return { stop: true };
+        });
+        return ret;
+    }
+    // search all referrer edges by edge name and edge type
+    getReferrers(edgeName, edgeType) {
+        return this.findReferrers((edge) => {
+            if (edge.name_or_index !== edgeName) {
+                return false;
+            }
+            if (edgeType != null && edge.type !== edgeType) {
+                return false;
+            }
+            return true;
+        });
+    }
+    // search any referrer node by edge name and edge type
+    getAnyReferrerNode(edgeName, edgeType) {
+        const edge = this.getAnyReferrer(edgeName, edgeType);
+        return edge && edge.fromNode;
+    }
+    // search all referrer nodes by edge name and edge type
+    getReferrerNodes(edgeName, edgeType) {
+        const ret = [];
+        const idSet = new Set();
+        this.forEachReferrer((edge) => {
+            if (edge.name_or_index !== edgeName) {
+                return;
+            }
+            if (edgeType != null && edge.type !== edgeType) {
+                return;
+            }
+            const fromNode = edge.fromNode;
+            if (idSet.has(fromNode.id)) {
+                return;
+            }
+            idSet.add(fromNode.id);
+            ret.push(fromNode);
+            return null;
+        });
+        return ret;
+    }
+    get isString() {
+        const type = this.type;
+        return (type === 'string' ||
+            type === 'sliced string' ||
+            type === 'concatenated string');
+    }
+    toStringNode() {
+        return this.isString
+            ? new HeapStringNode_1.default(this.heapSnapshot, this.idx)
+            : null;
+    }
+}
+exports.default = HeapNode;
+// HeapStringNode has to be imported after exporting HeapNode
+// since HeapStringNode imports and extends HeapNode
+const HeapStringNode_1 = __importDefault(require("./HeapStringNode"));

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

@@ -0,0 +1,85 @@
+/**
+ * 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
+ * @lightSyntaxTransform
+ * @format
+ */
+import type { IHeapNode, IHeapNodes, IHeapEdges, IHeapSnapshot, HeapNodeTypes, HeapEdgeTypes, HeapSnapshotMeta, RawHeapSnapshot, NumericDictionary, Nullable } from '../Types';
+import HeapNode from './HeapNode';
+export default class HeapSnapshot implements IHeapSnapshot {
+    snapshot: RawHeapSnapshot;
+    nodes: IHeapNodes;
+    _nodeCount: number;
+    edges: IHeapEdges;
+    _edgeCount: number;
+    _nodeId2NodeIdx: NumericDictionary;
+    _nodeIdxHasPathEdge: Uint8Array;
+    _nodeIdx2PathEdgeIdx: Uint32Array;
+    _nodeIdx2DominatorNodeIdx: Uint32Array;
+    _nodeIdxHasDominatorNode: Uint8Array;
+    _nodeIdx2RetainedSize: NumericDictionary;
+    _additionalAttributes: Uint8Array;
+    _nodeDetachednessOffset: number;
+    _externalDetachedness: Uint8Array;
+    _nodeIdx2LocationIdx: NumericDictionary;
+    _locationFieldsCount: number;
+    _locationCount: number;
+    _locationObjectIndexOffset: number;
+    _nodeFieldsCount: number;
+    _nodeIdOffset: number;
+    forwardEdges: number[];
+    _metaNode: HeapSnapshotMeta;
+    _nodeTypeOffset: number;
+    _nodeNameOffset: number;
+    _nodeSelfSizeOffset: number;
+    _nodeEdgeCountOffset: number;
+    _nodeTraceNodeIdOffset: number;
+    _nodeTypes: HeapNodeTypes;
+    _nodeArrayType: number;
+    _nodeHiddenType: number;
+    _nodeObjectType: number;
+    _nodeNativeType: number;
+    _nodeConsStringType: number;
+    _nodeSlicedStringType: number;
+    _nodeCodeType: number;
+    _nodeSyntheticType: number;
+    _edgeFieldsCount: number;
+    _edgeTypeOffset: number;
+    _edgeNameOrIndexOffset: number;
+    _edgeToNodeOffset: number;
+    _edgeTypes: HeapEdgeTypes;
+    _edgeElementType: number;
+    _edgeHiddenType: number;
+    _edgeInternalType: number;
+    _edgeShortcutType: number;
+    _edgeWeakType: number;
+    _edgeInvisibleType: number;
+    _locationScriptIdOffset: number;
+    _locationLineOffset: number;
+    _locationColumnOffset: number;
+    _firstEdgePointers: Uint32Array;
+    _retainingEdgeIndex2EdgeIndex: Uint32Array;
+    _firstRetainerIndex: Uint32Array;
+    _edgeIndex2SrcNodeIndex: Uint32Array;
+    constructor(snapshot: RawHeapSnapshot, _options?: Record<string, never>);
+    hasObjectWithClassName(className: string): boolean;
+    getAnyObjectWithClassName(className: string): Nullable<IHeapNode>;
+    hasObjectWithPropertyName(nameOrIndex: string | number): boolean;
+    hasObjectWithTag(tag: string): boolean;
+    getNodeById(id: number): Nullable<HeapNode>;
+    clearShortestPathInfo(): void;
+    _buildMetaData(): void;
+    _buildExtraMetaData(): void;
+    _buildLocationIdx(): void;
+    _buildNodeIdx(): void;
+    _calculateBasicInfo(): void;
+    _buildReferencesIndex(): void;
+    _buildReferrersIndex(): void;
+    _iterateDirectChildren(nodeIndex: number, edgeFilterCallback: (edgeType: number) => boolean, childCallback: (nodeIndex: number) => void): void;
+    _propagateDetachednessState(): void;
+}
+//# sourceMappingURL=HeapSnapshot.d.ts.map

package/dist/lib/heap-data/HeapSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeapSnapshot.d.ts","sourceRoot":"","sources":["../../../src/lib/heap-data/HeapSnapshot.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EACV,SAAS,EACT,UAAU,EAEV,UAAU,EACV,aAAa,EACb,aAAa,EACb,aAAa,EACb,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EACjB,QAAQ,EACT,MAAM,UAAU,CAAC;AAIlB,OAAO,QAAQ,MAAM,YAAY,CAAC;AAOlC,MAAM,CAAC,OAAO,OAAO,YAAa,YAAW,aAAa;IACjD,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,UAAU,CAAC;IAClB,UAAU,SAAM;IAChB,KAAK,EAAE,UAAU,CAAC;IAClB,UAAU,SAAM;IAChB,eAAe,EAAE,iBAAiB,CAAM;IACxC,mBAAmB,EAAE,UAAU,CAAqB;IACpD,oBAAoB,EAAE,WAAW,CAAsB;IACvD,yBAAyB,EAAE,WAAW,CAAsB;IAC5D,wBAAwB,EAAE,UAAU,CAAqB;IACzD,qBAAqB,EAAE,iBAAiB,CAAM;IAC9C,qBAAqB,EAAE,UAAU,CAAqB;IACtD,uBAAuB,SAAM;IAC7B,qBAAqB,EAAE,UAAU,CAAqB;IACtD,oBAAoB,EAAE,iBAAiB,CAAM;IAC7C,oBAAoB,SAAM;IAC1B,cAAc,SAAM;IACpB,0BAA0B,SAAM;IAChC,gBAAgB,SAAM;IACtB,aAAa,SAAM;IACnB,YAAY,EAAE,MAAM,EAAE,CAAM;IAC5B,SAAS,EAAE,gBAAgB,CAAC;IAC5B,eAAe,SAAM;IACrB,eAAe,SAAM;IACrB,mBAAmB,SAAM;IACzB,oBAAoB,SAAM;IAC1B,sBAAsB,SAAM;IAC5B,UAAU,EAAE,aAAa,CAAM;IAC/B,cAAc,SAAM;IACpB,eAAe,SAAM;IACrB,eAAe,SAAM;IACrB,eAAe,SAAM;IACrB,mBAAmB,SAAM;IACzB,qBAAqB,SAAM;IAC3B,aAAa,SAAM;IACnB,kBAAkB,SAAM;IAExB,gBAAgB,SAAM;IACtB,eAAe,SAAM;IACrB,sBAAsB,SAAM;IAC5B,iBAAiB,SAAM;IAEvB,UAAU,EAAE,aAAa,CAAM;IAC/B,gBAAgB,SAAM;IACtB,eAAe,SAAM;IACrB,iBAAiB,SAAM;IACvB,iBAAiB,SAAM;IACvB,aAAa,SAAM;IACnB,kBAAkB,SAAM;IAExB,uBAAuB,SAAM;IAC7B,mBAAmB,SAAM;IACzB,qBAAqB,SAAM;IAC3B,kBAAkB,EAAE,WAAW,CAAsB;IACrD,6BAA6B,EAAE,WAAW,CAAsB;IAChE,mBAAmB,EAAE,WAAW,CAAsB;IACtD,uBAAuB,EAAE,WAAW,CAAsB;gBAGrD,QAAQ,EAAE,eAAe,EAAE,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAM;IAoD3E,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAWlD,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,CAAC,SAAS,CAAC;IAWjE,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;IAWhE,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAyCtC,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,CAAC,QAAQ,CAAC;IAQ3C,qBAAqB,IAAI,IAAI;IAI7B,cAAc,IAAI,IAAI;IAUtB,mBAAmB,IAAI,IAAI;IAkB3B,iBAAiB,IAAI,IAAI;IAiBzB,aAAa,IAAI,IAAI;IAcrB,mBAAmB,IAAI,IAAI;IA0D3B,qBAAqB,IAAI,IAAI;IAqB7B,oBAAoB,IAAI,IAAI;IAwE5B,sBAAsB,CACpB,SAAS,EAAE,MAAM,EACjB,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,EACjD,aAAa,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,GACzC,IAAI;IAsBP,2BAA2B,IAAI,IAAI;CAmGpC"}