@memlab/heap-analysis 1.0.0

package/dist/index.js

@@ -0,0 +1,41 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PluginUtils = exports.StringAnalysis = exports.ObjectUnboundGrowthAnalysis = exports.ObjectShapeAnalysis = exports.ObjectFanoutAnalysis = exports.ShapeUnboundGrowthAnalysis = exports.ObjectSizeAnalysis = exports.ObjectShallowAnalysis = exports.CollectionsHoldingStaleAnalysis = exports.GlobalVariableAnalysis = exports.DetachedDOMElementAnalysis = exports.BaseAnalysis = exports.heapAnalysisLoader = void 0;
+var HeapAnalysisLoader_1 = require("./HeapAnalysisLoader");
+Object.defineProperty(exports, "heapAnalysisLoader", { enumerable: true, get: function () { return __importDefault(HeapAnalysisLoader_1).default; } });
+var BaseAnalysis_1 = require("./BaseAnalysis");
+Object.defineProperty(exports, "BaseAnalysis", { enumerable: true, get: function () { return __importDefault(BaseAnalysis_1).default; } });
+var DetachedDOMElementAnalysis_1 = require("./plugins/DetachedDOMElementAnalysis");
+Object.defineProperty(exports, "DetachedDOMElementAnalysis", { enumerable: true, get: function () { return __importDefault(DetachedDOMElementAnalysis_1).default; } });
+var GlobalVariableAnalysis_1 = require("./plugins/GlobalVariableAnalysis/GlobalVariableAnalysis");
+Object.defineProperty(exports, "GlobalVariableAnalysis", { enumerable: true, get: function () { return __importDefault(GlobalVariableAnalysis_1).default; } });
+var CollectionsHoldingStaleAnalysis_1 = require("./plugins/CollectionsHoldingStaleAnalysis");
+Object.defineProperty(exports, "CollectionsHoldingStaleAnalysis", { enumerable: true, get: function () { return __importDefault(CollectionsHoldingStaleAnalysis_1).default; } });
+var ObjectShallowAnalysis_1 = require("./plugins/ObjectShallowAnalysis");
+Object.defineProperty(exports, "ObjectShallowAnalysis", { enumerable: true, get: function () { return __importDefault(ObjectShallowAnalysis_1).default; } });
+var ObjectSizeAnalysis_1 = require("./plugins/ObjectSizeAnalysis");
+Object.defineProperty(exports, "ObjectSizeAnalysis", { enumerable: true, get: function () { return __importDefault(ObjectSizeAnalysis_1).default; } });
+var ShapeUnboundGrowthAnalysis_1 = require("./plugins/ShapeUnboundGrowthAnalysis");
+Object.defineProperty(exports, "ShapeUnboundGrowthAnalysis", { enumerable: true, get: function () { return __importDefault(ShapeUnboundGrowthAnalysis_1).default; } });
+var ObjectFanoutAnalysis_1 = require("./plugins/ObjectFanoutAnalysis");
+Object.defineProperty(exports, "ObjectFanoutAnalysis", { enumerable: true, get: function () { return __importDefault(ObjectFanoutAnalysis_1).default; } });
+var ObjectShapeAnalysis_1 = require("./plugins/ObjectShapeAnalysis");
+Object.defineProperty(exports, "ObjectShapeAnalysis", { enumerable: true, get: function () { return __importDefault(ObjectShapeAnalysis_1).default; } });
+var ObjectUnboundGrowthAnalysis_1 = require("./plugins/ObjectUnboundGrowthAnalysis");
+Object.defineProperty(exports, "ObjectUnboundGrowthAnalysis", { enumerable: true, get: function () { return __importDefault(ObjectUnboundGrowthAnalysis_1).default; } });
+var StringAnalysis_1 = require("./plugins/StringAnalysis");
+Object.defineProperty(exports, "StringAnalysis", { enumerable: true, get: function () { return __importDefault(StringAnalysis_1).default; } });
+var PluginUtils_1 = require("./PluginUtils");
+Object.defineProperty(exports, "PluginUtils", { enumerable: true, get: function () { return __importDefault(PluginUtils_1).default; } });

package/dist/options/HeapAnalysisSnapshotDirectoryOption.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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
+ */
+import type { ParsedArgs } from 'minimist';
+import { BaseOption, MemLabConfig } from '@memlab/core';
+export default class HeapAnalysisSnapshotDirectoryOption extends BaseOption {
+    getOptionName(): string;
+    getDescription(): string;
+    getExampleValues(): string[];
+    parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
+}
+//# sourceMappingURL=HeapAnalysisSnapshotDirectoryOption.d.ts.map

package/dist/options/HeapAnalysisSnapshotDirectoryOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeapAnalysisSnapshotDirectoryOption.d.ts","sourceRoot":"","sources":["../../src/options/HeapAnalysisSnapshotDirectoryOption.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AAGzC,OAAO,EAAC,UAAU,EAAE,YAAY,EAAQ,MAAM,cAAc,CAAC;AAE7D,MAAM,CAAC,OAAO,OAAO,mCAAoC,SAAQ,UAAU;IACzE,aAAa,IAAI,MAAM;IAIvB,cAAc,IAAI,MAAM;IAIxB,gBAAgB,IAAI,MAAM,EAAE;IAItB,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAWnE"}

package/dist/options/HeapAnalysisSnapshotDirectoryOption.js

@@ -0,0 +1,50 @@
+"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 __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 });
+const fs_1 = __importDefault(require("fs"));
+const core_1 = require("@memlab/core");
+class HeapAnalysisSnapshotDirectoryOption extends core_1.BaseOption {
+    getOptionName() {
+        return 'snapshot-dir';
+    }
+    getDescription() {
+        return 'set directory path containing all heap snapshots under analysis';
+    }
+    getExampleValues() {
+        return ['/tmp/snapshots/'];
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!args[this.getOptionName()]) {
+                return;
+            }
+            const dir = args[this.getOptionName()];
+            if (!fs_1.default.existsSync(dir)) {
+                core_1.utils.haltOrThrow(`Invalid directory: ${dir}`);
+            }
+            config.externalSnapshotDir = dir;
+            config.useExternalSnapshot = true;
+        });
+    }
+}
+exports.default = HeapAnalysisSnapshotDirectoryOption;

package/dist/options/HeapAnalysisSnapshotFileOption.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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
+ */
+import type { ParsedArgs } from 'minimist';
+import { BaseOption, MemLabConfig } from '@memlab/core';
+export default class HeapAnalysisSnapshotFileOption extends BaseOption {
+    getOptionName(): string;
+    getDescription(): string;
+    getExampleValues(): string[];
+    parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
+}
+//# sourceMappingURL=HeapAnalysisSnapshotFileOption.d.ts.map

package/dist/options/HeapAnalysisSnapshotFileOption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HeapAnalysisSnapshotFileOption.d.ts","sourceRoot":"","sources":["../../src/options/HeapAnalysisSnapshotFileOption.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,UAAU,CAAC;AAGzC,OAAO,EAAC,UAAU,EAAE,YAAY,EAAQ,MAAM,cAAc,CAAC;AAE7D,MAAM,CAAC,OAAO,OAAO,8BAA+B,SAAQ,UAAU;IACpE,aAAa,IAAI,MAAM;IAIvB,cAAc,IAAI,MAAM;IAIxB,gBAAgB,IAAI,MAAM,EAAE;IAItB,KAAK,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAWnE"}

package/dist/options/HeapAnalysisSnapshotFileOption.js

@@ -0,0 +1,50 @@
+"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 __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 });
+const fs_1 = __importDefault(require("fs"));
+const core_1 = require("@memlab/core");
+class HeapAnalysisSnapshotFileOption extends core_1.BaseOption {
+    getOptionName() {
+        return 'snapshot';
+    }
+    getDescription() {
+        return 'set file path of the heap snapshot under analysis';
+    }
+    getExampleValues() {
+        return ['/tmp/file.heapsnapshot'];
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!args.snapshot) {
+                return;
+            }
+            const file = args.snapshot;
+            if (!fs_1.default.existsSync(file)) {
+                core_1.utils.haltOrThrow(`Invalid snapshot file: ${file}`);
+            }
+            config.useExternalSnapshot = true;
+            config.externalSnapshotFilePaths[0] = file;
+        });
+    }
+}
+exports.default = HeapAnalysisSnapshotFileOption;

package/dist/plugins/CollectionsHoldingStaleAnalysis.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
+ * @format
+ */
+import type { HeapAnalysisOptions } from '../PluginUtils';
+import { BaseOption } from '@memlab/core';
+import BaseAnalysis from '../BaseAnalysis';
+export default class CollectionsHoldingStaleAnalysis extends BaseAnalysis {
+    getCommandName(): string;
+    getDescription(): string;
+    getOptions(): BaseOption[];
+    private staleCollectionMapper;
+    process(options: HeapAnalysisOptions): Promise<void>;
+    private getCollectionsWithStaleValues;
+    private print;
+}
+//# sourceMappingURL=CollectionsHoldingStaleAnalysis.d.ts.map

package/dist/plugins/CollectionsHoldingStaleAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollectionsHoldingStaleAnalysis.d.ts","sourceRoot":"","sources":["../../src/plugins/CollectionsHoldingStaleAnalysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AAGxD,OAAO,EAAc,UAAU,EAAC,MAAM,cAAc,CAAC;AACrD,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAgD3C,MAAM,CAAC,OAAO,OAAO,+BAAgC,SAAQ,YAAY;IAChE,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAI/B,UAAU,IAAI,UAAU,EAAE;IAI1B,OAAO,CAAC,qBAAqB,CAO1B;IAEG,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;IAM1D,OAAO,CAAC,6BAA6B;IAoBrC,OAAO,CAAC,KAAK;CAgCd"}

package/dist/plugins/CollectionsHoldingStaleAnalysis.js

@@ -0,0 +1,132 @@
+"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 __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 });
+const core_1 = require("@memlab/core");
+const BaseAnalysis_1 = __importDefault(require("../BaseAnalysis"));
+const PluginUtils_1 = __importDefault(require("../PluginUtils"));
+const chalk_1 = __importDefault(require("chalk"));
+const HeapAnalysisSnapshotFileOption_1 = __importDefault(require("../options/HeapAnalysisSnapshotFileOption"));
+function initCollectionStat(collection) {
+    return {
+        collection,
+        staleChildren: [],
+        childrenSize: 0,
+        staleRetainedSize: 0,
+    };
+}
+function processCollectionChildren(node) {
+    const stat = initCollectionStat(node);
+    const refs = node.references;
+    for (const ref of refs) {
+        ++stat.childrenSize;
+        const elementNode = ref.toNode;
+        if (!core_1.utils.isDetachedDOMNode(elementNode) &&
+            !core_1.utils.isDetachedFiberNode(elementNode)) {
+            continue;
+        }
+        // update stat for the collection
+        stat.staleChildren.push(elementNode);
+        stat.staleRetainedSize += elementNode.retainedSize;
+    }
+    return stat;
+}
+function processMapOrSet(node) {
+    const tableEdge = core_1.utils.getEdgeByNameAndType(node, 'table');
+    if (!tableEdge) {
+        return initCollectionStat(node);
+    }
+    return processCollectionChildren(tableEdge.toNode);
+}
+class CollectionsHoldingStaleAnalysis extends BaseAnalysis_1.default {
+    constructor() {
+        super(...arguments);
+        this.staleCollectionMapper = new Map([
+            ['Map', processMapOrSet],
+            ['Set', processMapOrSet],
+            ['Array', processCollectionChildren],
+        ]);
+    }
+    getCommandName() {
+        return 'collections-with-stale';
+    }
+    getDescription() {
+        return 'Analyze collections holding stale objects';
+    }
+    getOptions() {
+        return [new HeapAnalysisSnapshotFileOption_1.default()];
+    }
+    process(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const snapshot = yield PluginUtils_1.default.loadHeapSnapshot(options);
+            const collectionsStat = this.getCollectionsWithStaleValues(snapshot);
+            this.print(collectionsStat);
+        });
+    }
+    getCollectionsWithStaleValues(snapshot) {
+        core_1.info.overwrite('analyzing collections...');
+        const collections = [];
+        // going through collection nodes
+        snapshot.nodes.forEachTraceable((node) => {
+            const statCollector = this.staleCollectionMapper.get(node.name);
+            if (!statCollector) {
+                return;
+            }
+            const stat = statCollector(node);
+            if (stat.staleChildren.length > 0) {
+                collections.push(stat);
+            }
+        });
+        return collections;
+    }
+    print(collections) {
+        const dot = chalk_1.default.grey('·');
+        const head = chalk_1.default.yellow.bind(chalk_1.default);
+        if (collections.length === 0) {
+            core_1.info.success('Congratulations! No collections holding stale objects');
+        }
+        else {
+            core_1.info.topLevel(head('\nCollections holding stale objects:'));
+        }
+        collections.sort((c1, c2) => c2.staleRetainedSize - c1.staleRetainedSize);
+        collections = collections.slice(0, 20);
+        for (const stat of collections) {
+            const collection = stat.collection;
+            const collectionSize = core_1.utils.getReadableBytes(collection.retainedSize);
+            const staleChildrenSize = stat.staleChildren.length;
+            const childrenSize = stat.childrenSize;
+            const staleDesc = `${staleChildrenSize} out of ${childrenSize} elements are stale`;
+            const name = chalk_1.default.blue(collection.name);
+            const id = `(${chalk_1.default.grey('@' + collection.id)})`;
+            const collectionDesc = `${name} ${id} ${collectionSize} (${staleDesc})`;
+            let childrenIds = stat.staleChildren.map(node => `@${node.id}`);
+            if (childrenIds.length > 10) {
+                childrenIds = childrenIds.slice(0, 10);
+                childrenIds.push('...');
+            }
+            const childrenDesc = chalk_1.default.grey(childrenIds.join(', '));
+            core_1.info.topLevel(`\n${dot} ${collectionDesc}:`);
+            core_1.info.topLevel(`  ${childrenDesc}`);
+        }
+    }
+}
+exports.default = CollectionsHoldingStaleAnalysis;

package/dist/plugins/DetachedDOMElementAnalysis.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
+ * @format
+ */
+import type { HeapAnalysisOptions } from '../PluginUtils';
+import type { IHeapNode } from '@memlab/core';
+import { BaseOption } from '@memlab/core';
+import BaseAnalysis from '../BaseAnalysis';
+export default class DetachedDOMElementAnalysis extends BaseAnalysis {
+    getCommandName(): string;
+    getDescription(): string;
+    getOptions(): BaseOption[];
+    private detachedElements;
+    getDetachedElements(): IHeapNode[];
+    process(options: HeapAnalysisOptions): Promise<void>;
+}
+//# sourceMappingURL=DetachedDOMElementAnalysis.d.ts.map

package/dist/plugins/DetachedDOMElementAnalysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DetachedDOMElementAnalysis.d.ts","sourceRoot":"","sources":["../../src/plugins/DetachedDOMElementAnalysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AAE5C,OAAO,EAAQ,UAAU,EAAC,MAAM,cAAc,CAAC;AAC/C,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAI3C,MAAM,CAAC,OAAO,OAAO,0BAA2B,SAAQ,YAAY;IAClE,cAAc,IAAI,MAAM;IAIxB,cAAc,IAAI,MAAM;IAIxB,UAAU,IAAI,UAAU,EAAE;IAI1B,OAAO,CAAC,gBAAgB,CAAmB;IAEpC,mBAAmB,IAAI,SAAS,EAAE;IAInC,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;CAQ3D"}

package/dist/plugins/DetachedDOMElementAnalysis.js

@@ -0,0 +1,53 @@
+"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 __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 });
+const core_1 = require("@memlab/core");
+const BaseAnalysis_1 = __importDefault(require("../BaseAnalysis"));
+const PluginUtils_1 = __importDefault(require("../PluginUtils"));
+const HeapAnalysisSnapshotFileOption_1 = __importDefault(require("../options/HeapAnalysisSnapshotFileOption"));
+class DetachedDOMElementAnalysis extends BaseAnalysis_1.default {
+    constructor() {
+        super(...arguments);
+        this.detachedElements = [];
+    }
+    getCommandName() {
+        return 'detached-DOM';
+    }
+    getDescription() {
+        return 'Get detached DOM elements';
+    }
+    getOptions() {
+        return [new HeapAnalysisSnapshotFileOption_1.default()];
+    }
+    getDetachedElements() {
+        return this.detachedElements;
+    }
+    process(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const snapshot = yield PluginUtils_1.default.loadHeapSnapshot(options);
+            this.detachedElements = PluginUtils_1.default.filterOutLargestObjects(snapshot, core_1.utils.isDetachedDOMNode);
+            PluginUtils_1.default.printNodeListInTerminal(this.detachedElements);
+        });
+    }
+}
+exports.default = DetachedDOMElementAnalysis;

package/dist/plugins/GlobalVariableAnalysis/BuiltInGlobalVariables.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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
+ */
+declare const _default: Set<string>;
+export default _default;
+//# sourceMappingURL=BuiltInGlobalVariables.d.ts.map

package/dist/plugins/GlobalVariableAnalysis/BuiltInGlobalVariables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BuiltInGlobalVariables.d.ts","sourceRoot":"","sources":["../../../src/plugins/GlobalVariableAnalysis/BuiltInGlobalVariables.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;;AAEH,wBAoiCG"}