@memlab/cli 1.0.7 → 1.0.11

package/dist/commands/heap/interactive/ui-components/HeapViewController.d.ts

@@ -0,0 +1,73 @@
+/**
+ * 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.
+ *
+ * @format
+ * @oncall ws_labs
+ */
+import type { IHeapSnapshot, IHeapNode } from '@memlab/core';
+import type ListComponent from './ListComponent';
+import { ComponentDataItem, ComponentData } from './HeapViewUtils';
+declare type SelectHeapObjectOption = {
+    noChangeInReferenceBox?: boolean;
+    noChangeInReferrerBox?: boolean;
+    noChangeInRetainerTraceBox?: boolean;
+    noChangeInObjectPropertyBox?: boolean;
+    componentDataItem?: ComponentDataItem;
+};
+export declare type ObjectCategory = Map<string, ComponentDataItem[]>;
+/**
+ * HeapViewController managers all the data associated with each
+ * UI components in CLI and coordinates the events/interaction
+ * among all UI components.
+ */
+export default class HeapViewController {
+    private currentHeapObject;
+    private selectedHeapObject;
+    private currentHeapObjectsInfo;
+    private currentClusteredObjectsInfo;
+    private componentIdToDataMap;
+    private componentIdToComponentMap;
+    private heap;
+    private clusteredBox;
+    private referrerBox;
+    private objectBox;
+    private referenceBox;
+    private objectPropertyBox;
+    private retainerTracePropertyBox;
+    constructor(heap: IHeapSnapshot, objectCategory: ObjectCategory);
+    private getFlattenHeapObjectsInfo;
+    private getFlattenClusteredObjectsInfo;
+    private shouldClusterCategory;
+    private clusterComponentDataItems;
+    getContent(componentId: number): string[];
+    setClusteredBox(component: ListComponent): void;
+    getClusteredBoxData(): ComponentData;
+    setReferrerBox(component: ListComponent): void;
+    getReferrerBoxData(node?: IHeapNode): ComponentData;
+    setObjectBox(component: ListComponent): void;
+    getObjectBoxData(): ComponentData;
+    setReferenceBox(component: ListComponent): void;
+    getReferenceBoxData(): ComponentData;
+    setObjectPropertyBox(component: ListComponent): void;
+    getObjectPropertyData(options?: {
+        details?: Map<string, string>;
+    }): ComponentData;
+    private getReadableString;
+    private getKeyValuePairString;
+    setRetainerTraceBox(component: ListComponent): void;
+    getRetainerTraceData(): ComponentData;
+    setCurrentHeapObjectFromComponent(componentId: number, itemIndex: number, options?: {
+        skipFocus?: boolean;
+    }): void;
+    setCurrentHeapObject(node: IHeapNode, options?: {
+        skipFocus?: boolean;
+    }): void;
+    focusOnComponent(componentId: number): void;
+    setSelectedHeapObjectFromComponent(componentId: number, itemIndex: number): void;
+    setSelectedHeapObject(node: IHeapNode, options?: SelectHeapObjectOption): void;
+}
+export {};
+//# sourceMappingURL=HeapViewController.d.ts.map

package/dist/commands/heap/interactive/ui-components/HeapViewController.js

@@ -0,0 +1,358 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const core_1 = require("@memlab/core");
+const HeapViewUtils_1 = require("./HeapViewUtils");
+/**
+ * HeapViewController managers all the data associated with each
+ * UI components in CLI and coordinates the events/interaction
+ * among all UI components.
+ */
+class HeapViewController {
+    constructor(heap, objectCategory) {
+        this.heap = heap;
+        this.currentHeapObjectsInfo =
+            this.getFlattenHeapObjectsInfo(objectCategory);
+        this.currentClusteredObjectsInfo =
+            this.getFlattenClusteredObjectsInfo(objectCategory);
+        this.currentHeapObject = (0, HeapViewUtils_1.getHeapObjectAt)(this.currentHeapObjectsInfo, 0);
+        this.componentIdToDataMap = new Map();
+        this.componentIdToComponentMap = new Map();
+    }
+    getFlattenHeapObjectsInfo(objectCategory) {
+        let ret = [];
+        for (const category of objectCategory.keys()) {
+            const nodes = objectCategory.get(category);
+            ret = [...ret, ...nodes];
+        }
+        return ret;
+    }
+    getFlattenClusteredObjectsInfo(objectCategory) {
+        let ret = [];
+        for (const category of objectCategory.keys()) {
+            let nodes = objectCategory.get(category);
+            if (this.shouldClusterCategory(category)) {
+                nodes = this.clusterComponentDataItems(nodes);
+            }
+            ret = [...ret, ...nodes];
+        }
+        return ret;
+    }
+    shouldClusterCategory(category) {
+        return category === 'detached';
+    }
+    clusterComponentDataItems(nodes) {
+        const ret = [];
+        const nodeIds = new Set(nodes
+            .filter(node => node.heapObject)
+            .map(node => { var _a, _b; return (_b = (_a = node.heapObject) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : -1; }));
+        const clusters = core_1.analysis.clusterHeapObjects(nodeIds, this.heap);
+        clusters.forEach(cluster => {
+            var _a;
+            const id = (_a = cluster.id) !== null && _a !== void 0 ? _a : -1;
+            let node = null;
+            node = this.heap.getNodeById(id);
+            const details = new Map();
+            if (cluster.count) {
+                details.set('# of clusters', `${cluster.count}`);
+            }
+            if (cluster.retainedSize) {
+                details.set('aggregated retained size', `${core_1.utils.getReadableBytes(cluster.retainedSize)}`);
+            }
+            ret.push({ tag: 'Cluster', heapObject: node, details });
+        });
+        return ret;
+    }
+    getContent(componentId) {
+        const ret = [];
+        const data = this.componentIdToDataMap.get(componentId);
+        if (data) {
+            for (const item of data.items) {
+                ret.push(HeapViewUtils_1.ComponentDataItem.getTextForDisplay(item));
+            }
+        }
+        return ret;
+    }
+    setClusteredBox(component) {
+        this.componentIdToComponentMap.set(component.id, component);
+        this.clusteredBox = component;
+        this.componentIdToDataMap.set(component.id, new HeapViewUtils_1.ComponentData());
+    }
+    getClusteredBoxData() {
+        const data = new HeapViewUtils_1.ComponentData();
+        data.selectedIdx = 0;
+        data.items = this.currentClusteredObjectsInfo;
+        return data;
+    }
+    setReferrerBox(component) {
+        this.componentIdToComponentMap.set(component.id, component);
+        this.referrerBox = component;
+        this.componentIdToDataMap.set(component.id, new HeapViewUtils_1.ComponentData());
+    }
+    getReferrerBoxData(node = this.selectedHeapObject) {
+        const data = new HeapViewUtils_1.ComponentData();
+        node.forEachReferrer(ref => {
+            var _a, _b;
+            const tag = ref.fromNode.id === ((_b = (_a = node.pathEdge) === null || _a === void 0 ? void 0 : _a.fromNode) === null || _b === void 0 ? void 0 : _b.id) ? { tag: '<-' } : {};
+            data.items.push(Object.assign({ heapObject: ref.fromNode, referenceEdge: ref }, tag));
+            return { stop: false };
+        });
+        data.selectedIdx = data.items.length > 0 ? 0 : -1;
+        return data;
+    }
+    setObjectBox(component) {
+        this.componentIdToComponentMap.set(component.id, component);
+        this.objectBox = component;
+        this.componentIdToDataMap.set(component.id, new HeapViewUtils_1.ComponentData());
+    }
+    getObjectBoxData() {
+        const data = new HeapViewUtils_1.ComponentData();
+        const index = this.currentHeapObjectsInfo.findIndex(item => { var _a; return ((_a = item.heapObject) === null || _a === void 0 ? void 0 : _a.id) === this.currentHeapObject.id; });
+        if (index >= 0) {
+            data.selectedIdx = index;
+        }
+        else {
+            data.selectedIdx = 0;
+            this.currentHeapObjectsInfo.unshift({
+                tag: 'Chosen',
+                heapObject: this.currentHeapObject,
+            });
+        }
+        data.items = this.currentHeapObjectsInfo;
+        return data;
+    }
+    setReferenceBox(component) {
+        this.componentIdToComponentMap.set(component.id, component);
+        this.referenceBox = component;
+        this.componentIdToDataMap.set(component.id, new HeapViewUtils_1.ComponentData());
+    }
+    getReferenceBoxData() {
+        const data = new HeapViewUtils_1.ComponentData();
+        this.selectedHeapObject.forEachReference(ref => {
+            data.items.push({ referrerEdge: ref, heapObject: ref.toNode });
+            return { stop: false };
+        });
+        data.items.sort((i1, i2) => { var _a, _b, _c, _d; return ((_b = (_a = i2.heapObject) === null || _a === void 0 ? void 0 : _a.retainedSize) !== null && _b !== void 0 ? _b : 0) - ((_d = (_c = i1.heapObject) === null || _c === void 0 ? void 0 : _c.retainedSize) !== null && _d !== void 0 ? _d : 0); });
+        data.selectedIdx = data.items.length > 0 ? 0 : -1;
+        return data;
+    }
+    setObjectPropertyBox(component) {
+        this.componentIdToComponentMap.set(component.id, component);
+        this.objectPropertyBox = component;
+        this.componentIdToDataMap.set(component.id, new HeapViewUtils_1.ComponentData());
+    }
+    getObjectPropertyData(options = {}) {
+        var _a, _b;
+        const data = new HeapViewUtils_1.ComponentData();
+        const node = this.selectedHeapObject;
+        data.items.push({
+            stringContent: this.getKeyValuePairString('id', `@${node.id}`),
+        });
+        data.items.push({
+            stringContent: this.getKeyValuePairString('name', node.name),
+        });
+        data.items.push({
+            stringContent: this.getKeyValuePairString('type', node.type),
+        });
+        data.items.push({
+            stringContent: this.getKeyValuePairString('self size', core_1.utils.getReadableBytes(node.self_size)),
+        });
+        data.items.push({
+            stringContent: this.getKeyValuePairString('retained size', core_1.utils.getReadableBytes(node.retainedSize)),
+        });
+        data.items.push({
+            stringContent: this.getKeyValuePairString('# of references', node.edge_count),
+        });
+        data.items.push({
+            stringContent: this.getKeyValuePairString('# of referrers', node.referrers.length),
+        });
+        if (node.dominatorNode) {
+            data.items.push({
+                stringContent: 'dominator node' + chalk_1.default.grey(': '),
+                heapObject: node.dominatorNode,
+            });
+        }
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const self = this;
+        (_a = options.details) === null || _a === void 0 ? void 0 : _a.forEach((value, key) => data.items.push({
+            stringContent: self.getKeyValuePairString(key, value),
+        }));
+        // inject additional node information
+        if (node.isString) {
+            const stringNode = node.toStringNode();
+            if (stringNode) {
+                const value = this.getReadableString(stringNode.stringValue);
+                data.items.push({
+                    stringContent: this.getKeyValuePairString('string value', value),
+                });
+            }
+        }
+        if (node.type === 'number') {
+            data.items.push({
+                stringContent: this.getKeyValuePairString('numeric value', (_b = core_1.utils.getNumberNodeValue(node)) !== null && _b !== void 0 ? _b : '<error>'),
+            });
+        }
+        if (node.type === 'closure') {
+            const contextNode = node.getReferenceNode('context', 'internal');
+            if (contextNode) {
+                contextNode.forEachReference(edge => {
+                    data.items.push({
+                        tag: chalk_1.default.grey('Scope Variable'),
+                        referrerEdge: edge,
+                        heapObject: edge.toNode,
+                    });
+                });
+            }
+        }
+        data.selectedIdx = data.items.length > 0 ? 0 : -1;
+        return data;
+    }
+    getReadableString(value) {
+        return value.length > 300
+            ? value.substring(0, 300) + chalk_1.default.grey('...')
+            : value;
+    }
+    getKeyValuePairString(key, value) {
+        return key + chalk_1.default.grey(': ') + chalk_1.default.green(value);
+    }
+    setRetainerTraceBox(component) {
+        this.componentIdToComponentMap.set(component.id, component);
+        this.retainerTracePropertyBox = component;
+        this.componentIdToDataMap.set(component.id, new HeapViewUtils_1.ComponentData());
+    }
+    getRetainerTraceData() {
+        var _a;
+        const data = new HeapViewUtils_1.ComponentData();
+        const node = this.selectedHeapObject;
+        let curNode = node;
+        while (curNode && !core_1.utils.isRootNode(curNode)) {
+            if (!curNode.pathEdge) {
+                curNode = null;
+                break;
+            }
+            data.items.unshift({ referrerEdge: curNode.pathEdge, heapObject: curNode });
+            curNode = (_a = curNode.pathEdge) === null || _a === void 0 ? void 0 : _a.fromNode;
+        }
+        if (curNode) {
+            data.items.unshift({ heapObject: curNode });
+        }
+        data.selectedIdx = data.items.length > 0 ? 0 : -1;
+        return data;
+    }
+    setCurrentHeapObjectFromComponent(componentId, itemIndex, options = {}) {
+        const data = this.componentIdToDataMap.get(componentId);
+        if (!data) {
+            return;
+        }
+        const item = data.items[itemIndex];
+        if (!item) {
+            return;
+        }
+        const heapObject = item.heapObject;
+        if (!heapObject) {
+            return;
+        }
+        this.setCurrentHeapObject(heapObject, options);
+    }
+    setCurrentHeapObject(node, options = {}) {
+        this.currentHeapObject = node;
+        // set parent box's data and content
+        const clusteredBoxData = this.getClusteredBoxData();
+        this.componentIdToDataMap.set(this.clusteredBox.id, clusteredBoxData);
+        this.clusteredBox.setContent(this.getContent(this.clusteredBox.id));
+        this.clusteredBox.selectIndex(clusteredBoxData.selectedIdx);
+        // set object box's data and content
+        const objectBoxData = this.getObjectBoxData();
+        this.componentIdToDataMap.set(this.objectBox.id, objectBoxData);
+        this.objectBox.setContent(this.getContent(this.objectBox.id));
+        this.objectBox.selectIndex(objectBoxData.selectedIdx);
+        this.setSelectedHeapObject(node);
+        if (!options.skipFocus) {
+            this.focusOnComponent(this.objectBox.id);
+        }
+    }
+    focusOnComponent(componentId) {
+        var _a;
+        for (const component of this.componentIdToComponentMap.values()) {
+            if (component.id === componentId) {
+                component.focus();
+                const data = this.componentIdToDataMap.get(componentId);
+                const selectIndex = (_a = (data && data.selectedIdx)) !== null && _a !== void 0 ? _a : -1;
+                this.setSelectedHeapObjectFromComponent(componentId, selectIndex);
+            }
+            else {
+                component.loseFocus();
+            }
+        }
+    }
+    setSelectedHeapObjectFromComponent(componentId, itemIndex) {
+        const data = this.componentIdToDataMap.get(componentId);
+        if (!data) {
+            return;
+        }
+        data.selectedIdx = itemIndex;
+        const item = data.items[itemIndex];
+        if (!item) {
+            return;
+        }
+        const heapObject = item.heapObject;
+        if (!heapObject) {
+            return;
+        }
+        // if selecting in a specific box, do not update content in that box
+        const noChangeInReferenceBox = componentId === this.referenceBox.id;
+        const noChangeInReferrerBox = componentId === this.referrerBox.id;
+        const noChangeInRetainerTraceBox = componentId === this.retainerTracePropertyBox.id;
+        const noChangeInObjectPropertyBox = componentId === this.objectPropertyBox.id;
+        this.setSelectedHeapObject(heapObject, {
+            noChangeInReferenceBox,
+            noChangeInReferrerBox,
+            noChangeInRetainerTraceBox,
+            noChangeInObjectPropertyBox,
+            componentDataItem: item,
+        });
+    }
+    setSelectedHeapObject(node, options = {}) {
+        var _a;
+        this.selectedHeapObject = node;
+        // set referrer box's data and content
+        if (!options.noChangeInReferrerBox) {
+            const data = this.getReferrerBoxData();
+            this.componentIdToDataMap.set(this.referrerBox.id, data);
+            this.referrerBox.setContent(this.getContent(this.referrerBox.id));
+            this.referrerBox.selectIndex(data.selectedIdx);
+            this.referrerBox.setLabel(`Referrers of @${node.id}`);
+        }
+        // set reference box's data and content
+        if (!options.noChangeInReferenceBox) {
+            const data = this.getReferenceBoxData();
+            this.componentIdToDataMap.set(this.referenceBox.id, data);
+            this.referenceBox.setContent(this.getContent(this.referenceBox.id));
+            this.referenceBox.selectIndex(data.selectedIdx);
+            this.referenceBox.setLabel(`References of @${node.id}`);
+        }
+        // set object property box's data and content
+        if (!options.noChangeInObjectPropertyBox) {
+            const propertyOption = ((_a = options === null || options === void 0 ? void 0 : options.componentDataItem) === null || _a === void 0 ? void 0 : _a.details)
+                ? { details: options.componentDataItem.details }
+                : {};
+            const data = this.getObjectPropertyData(propertyOption);
+            this.componentIdToDataMap.set(this.objectPropertyBox.id, data);
+            this.objectPropertyBox.setContent(this.getContent(this.objectPropertyBox.id));
+            this.objectPropertyBox.selectIndex(data.selectedIdx);
+            this.objectPropertyBox.setLabel(`Object: @${node.id}`);
+        }
+        // set retainer trace box's data and content
+        if (!options.noChangeInRetainerTraceBox) {
+            const data = this.getRetainerTraceData();
+            this.componentIdToDataMap.set(this.retainerTracePropertyBox.id, data);
+            this.retainerTracePropertyBox.setContent(this.getContent(this.retainerTracePropertyBox.id));
+            this.retainerTracePropertyBox.selectIndex(data.selectedIdx);
+            this.retainerTracePropertyBox.setLabel(`Retainer Trace of @${node.id}`);
+        }
+    }
+}
+exports.default = HeapViewController;

package/dist/commands/heap/interactive/ui-components/HeapViewUtils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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.
+ *
+ * @format
+ * @oncall ws_labs
+ */
+import type { IHeapEdge, IHeapNode } from '@memlab/core';
+export declare class ComponentDataItem {
+    stringContent?: string;
+    tag?: string;
+    referrerEdge?: IHeapEdge;
+    heapObject?: IHeapNode;
+    referenceEdge?: IHeapEdge;
+    type?: string;
+    details?: Map<string, string>;
+    static getTextForDisplay(data: ComponentDataItem): string;
+    private static getTextContent;
+}
+export declare class ComponentData {
+    selectedIdx: number;
+    items: ComponentDataItem[];
+}
+export declare function throwIfNodesEmpty(nodes: ComponentDataItem[]): boolean;
+export declare function getHeapObjectAt(nodes: ComponentDataItem[], index: number): IHeapNode;
+export declare function substringWithColor(input: string, begin: number): string;
+export declare type DebounceCallback = () => void;
+export declare type DebounceFunction = (callback: DebounceCallback) => void;
+export declare function debounce(timeInMs: number): DebounceFunction;
+//# sourceMappingURL=HeapViewUtils.d.ts.map

package/dist/commands/heap/interactive/ui-components/HeapViewUtils.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounce = exports.substringWithColor = exports.getHeapObjectAt = exports.throwIfNodesEmpty = exports.ComponentData = exports.ComponentDataItem = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const core_1 = require("@memlab/core");
+const lessUsefulEdgeTypeForDebugging = new Set([
+    'internal',
+    'hidden',
+    'shortcut',
+    'weak',
+]);
+const reactEdgeNames = new Set([
+    'alternate',
+    'firstEffect',
+    'lastEffect',
+    'concurrentQueues',
+    'child',
+    'return',
+    'sibling',
+]);
+function isUsefulEdgeForDebugging(edge) {
+    if (lessUsefulEdgeTypeForDebugging.has(edge.type)) {
+        return false;
+    }
+    const edgeStr = `${edge.name_or_index}`;
+    if (reactEdgeNames.has(edgeStr)) {
+        if (core_1.utils.isFiberNode(edge.fromNode) || core_1.utils.isFiberNode(edge.toNode)) {
+            return false;
+        }
+    }
+    if (edgeStr.startsWith('__reactProps$')) {
+        return false;
+    }
+    return true;
+}
+const lessUsefulObjectTypeForDebugging = new Set([
+    'native',
+    'hidden',
+    'array',
+    'code',
+    'synthetic',
+]);
+function isUsefulObjectForDebugging(object) {
+    if (lessUsefulObjectTypeForDebugging.has(object.type)) {
+        return false;
+    }
+    return !core_1.utils.isFiberNode(object);
+}
+class ComponentDataItem {
+    static getTextForDisplay(data) {
+        const content = ComponentDataItem.getTextContent(data);
+        if (data.referrerEdge && isUsefulEdgeForDebugging(data.referrerEdge)) {
+            return content;
+        }
+        if (data.referenceEdge && isUsefulEdgeForDebugging(data.referenceEdge)) {
+            return content;
+        }
+        if (data.heapObject && isUsefulObjectForDebugging(data.heapObject)) {
+            return content;
+        }
+        if (!data.referenceEdge && !data.heapObject && !data.referrerEdge) {
+            return content;
+        }
+        return chalk_1.default.grey(content);
+    }
+    static getTextContent(data) {
+        let ret = '';
+        if (data.tag) {
+            ret += `[${data.tag}] `;
+        }
+        if (data.stringContent) {
+            ret += data.stringContent;
+        }
+        const arrowPrefix = chalk_1.default.grey('--');
+        const arrowSuffix = chalk_1.default.grey('---') + '>';
+        if (data.referrerEdge) {
+            const edgeType = chalk_1.default.grey(`(${data.referrerEdge.type})`);
+            const edgeName = data.referrerEdge.name_or_index;
+            ret += `${arrowPrefix}${edgeName}${edgeType}${arrowSuffix} `;
+        }
+        if (data.heapObject) {
+            const objectType = chalk_1.default.grey(`(${data.heapObject.type})`);
+            const objectId = chalk_1.default.grey(` @${data.heapObject.id}`);
+            const size = core_1.utils.getReadableBytes(data.heapObject.retainedSize);
+            const sizeInfo = chalk_1.default.grey(' [') + chalk_1.default.bold(chalk_1.default.blue(size)) + chalk_1.default.grey(']');
+            ret +=
+                chalk_1.default.green('[') +
+                    (isUsefulObjectForDebugging(data.heapObject)
+                        ? chalk_1.default.green(data.heapObject.name)
+                        : chalk_1.default.bold(chalk_1.default.grey(data.heapObject.name))) +
+                    chalk_1.default.green(']') +
+                    objectType +
+                    objectId +
+                    sizeInfo;
+        }
+        if (data.referenceEdge) {
+            const edgeType = chalk_1.default.grey(`(${data.referenceEdge.type})`);
+            const edgeName = data.referenceEdge.name_or_index;
+            ret += ` ${arrowPrefix}${edgeName}${edgeType}${arrowSuffix} `;
+        }
+        return ret === '' ? chalk_1.default.grey('<undefinied>') : ret;
+    }
+}
+exports.ComponentDataItem = ComponentDataItem;
+class ComponentData {
+    constructor() {
+        this.selectedIdx = -1;
+        this.items = [];
+    }
+}
+exports.ComponentData = ComponentData;
+function throwIfNodesEmpty(nodes) {
+    if (nodes.length === 0) {
+        throw core_1.utils.haltOrThrow('no heap node specified');
+    }
+    for (let i = 0; i < nodes.length; ++i) {
+        if (!nodes[i].heapObject) {
+            throw core_1.utils.haltOrThrow('heap node missing in ComponentDataItem[]');
+        }
+    }
+    return true;
+}
+exports.throwIfNodesEmpty = throwIfNodesEmpty;
+function getHeapObjectAt(nodes, index) {
+    throwIfNodesEmpty(nodes);
+    if (index < 0 || index >= nodes.length) {
+        throw core_1.utils.haltOrThrow('index is outside of nodes range');
+    }
+    return nodes[index].heapObject;
+}
+exports.getHeapObjectAt = getHeapObjectAt;
+// eslint-disable-next-line no-control-regex
+const colorBegin = /^\u001b\[(\d+)m/;
+// eslint-disable-next-line no-control-regex
+const colorEnd = /^\u001b\](\d+)m/;
+function stripColorCodeIfAny(input) {
+    const matchBegin = input.match(colorBegin);
+    const matchEnd = input.match(colorEnd);
+    const match = matchBegin || matchEnd;
+    if (!match) {
+        return { str: input, code: -1, isBegin: false };
+    }
+    const isBegin = !!matchBegin;
+    const code = parseInt(match[1], 10);
+    const str = input.substring(match[0].length);
+    return { str, code, isBegin };
+}
+function toColorControlChar(code, isBegin) {
+    const colorSpecialChar = '\u001b';
+    return colorSpecialChar + (isBegin ? '[' : ']') + code + 'm';
+}
+function substringWithColor(input, begin) {
+    const codeQueue = [];
+    let curIndex = 0;
+    let curStr = input;
+    while (curIndex < begin) {
+        // enqueue all control characters
+        let strip;
+        do {
+            strip = stripColorCodeIfAny(curStr);
+            curStr = strip.str;
+            if (strip.code >= 0) {
+                // pop if control begin meets control ends
+                const last = codeQueue[codeQueue.length - 1];
+                if (!last ||
+                    last.code !== strip.code ||
+                    strip.isBegin === true ||
+                    last.isBegin === false) {
+                    codeQueue.push({ code: strip.code, isBegin: strip.isBegin });
+                }
+                else {
+                    codeQueue.pop();
+                }
+            }
+        } while (strip.code >= 0);
+        // strip one actual content character
+        curStr = curStr.substring(1);
+        ++curIndex;
+    }
+    // prepend control characters
+    while (codeQueue.length > 0) {
+        const last = codeQueue.pop();
+        if (last) {
+            curStr = toColorControlChar(last === null || last === void 0 ? void 0 : last.code, last === null || last === void 0 ? void 0 : last.isBegin) + curStr;
+        }
+    }
+    return curStr;
+}
+exports.substringWithColor = substringWithColor;
+function debounce(timeInMs) {
+    let id = null;
+    return (callback) => {
+        if (id) {
+            clearTimeout(id);
+        }
+        id = setTimeout(() => {
+            callback();
+            id = null;
+        }, timeInMs);
+    };
+}
+exports.debounce = debounce;