@memlab/core 1.0.8 → 1.1.1

package/dist/lib/leak-filters/BaseLeakFilter.rule.js

@@ -0,0 +1,22 @@
+"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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeakDecision = void 0;
+/**
+ * Every leak object filter rule needs to give a label
+ * to each object passed to the filter
+ */
+var LeakDecision;
+(function (LeakDecision) {
+    LeakDecision["LEAK"] = "leak";
+    LeakDecision["MAYBE_LEAK"] = "maybe-leak";
+    LeakDecision["NOT_LEAK"] = "not-leak";
+})(LeakDecision = exports.LeakDecision || (exports.LeakDecision = {}));

package/dist/lib/leak-filters/LeakFilterRuleList.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
+ * @format
+ */
+import { ILeakObjectFilterRule } from './BaseLeakFilter.rule';
+declare const _default: ILeakObjectFilterRule[];
+export default _default;
+//# sourceMappingURL=LeakFilterRuleList.d.ts.map

package/dist/lib/leak-filters/LeakFilterRuleList.js

@@ -0,0 +1,33 @@
+"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 });
+const Constant_1 = __importDefault(require("../Constant"));
+const InternalValueSetter_1 = require("../InternalValueSetter");
+const FilterByExternalFilter_rule_1 = require("./rules/FilterByExternalFilter.rule");
+const FilterDetachedDOMElement_rule_1 = require("./rules/FilterDetachedDOMElement.rule");
+const FilterHermesNode_rule_1 = require("./rules/FilterHermesNode.rule");
+const FilterOverSizedNodeAsLeak_rule_1 = require("./rules/FilterOverSizedNodeAsLeak.rule");
+const FilterStackTraceFrame_rule_1 = require("./rules/FilterStackTraceFrame.rule");
+const FilterTrivialNode_rule_1 = require("./rules/FilterTrivialNode.rule");
+const FilterUnmountedFiberNode_rule_1 = require("./rules/FilterUnmountedFiberNode.rule");
+const list = [
+    new FilterByExternalFilter_rule_1.FilterByExternalFilterRule(),
+    new FilterTrivialNode_rule_1.FilterTrivialNodeRule(),
+    new FilterHermesNode_rule_1.FilterHermesNodeRule(),
+    new FilterOverSizedNodeAsLeak_rule_1.FilterOverSizedNodeAsLeakRule(),
+    new FilterUnmountedFiberNode_rule_1.FilterUnmountedFiberNodeRule(),
+    new FilterDetachedDOMElement_rule_1.FilterDetachedDOMElementRule(),
+    new FilterStackTraceFrame_rule_1.FilterStackTraceFrameRule(),
+];
+exports.default = (0, InternalValueSetter_1.setInternalValue)(list, __filename, Constant_1.default.internalDir);

package/dist/lib/leak-filters/LeakObjectFilter.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { MemLabConfig } from '../Config';
+import type { HeapNodeIdSet, IHeapNode, IHeapSnapshot } from '../Types';
+/**
+ * apply the leak object filter rules chain and decide
+ * if an object is a memory leak or not
+ */
+export declare class LeakObjectFilter {
+    filter(config: MemLabConfig, node: IHeapNode, snapshot: IHeapSnapshot, leakedNodeIds: HeapNodeIdSet): boolean;
+}
+//# sourceMappingURL=LeakObjectFilter.d.ts.map

package/dist/lib/leak-filters/LeakObjectFilter.js

@@ -0,0 +1,36 @@
+"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.LeakObjectFilter = void 0;
+const BaseLeakFilter_rule_1 = require("./BaseLeakFilter.rule");
+const LeakFilterRuleList_1 = __importDefault(require("./LeakFilterRuleList"));
+/**
+ * apply the leak object filter rules chain and decide
+ * if an object is a memory leak or not
+ */
+class LeakObjectFilter {
+    filter(config, node, snapshot, leakedNodeIds) {
+        for (const rule of LeakFilterRuleList_1.default) {
+            const decision = rule.filter(config, node, snapshot, leakedNodeIds);
+            if (decision === BaseLeakFilter_rule_1.LeakDecision.LEAK) {
+                return true;
+            }
+            if (decision === BaseLeakFilter_rule_1.LeakDecision.NOT_LEAK) {
+                return false;
+            }
+        }
+        return false;
+    }
+}
+exports.LeakObjectFilter = LeakObjectFilter;

package/dist/lib/leak-filters/rules/FilterByExternalFilter.rule.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { MemLabConfig } from '../../Config';
+import type { HeapNodeIdSet, IHeapNode, IHeapSnapshot } from '../../Types';
+import { ILeakObjectFilterRule, LeakDecision } from '../BaseLeakFilter.rule';
+/**
+ * filter memory leaks defined by external leak filter
+ */
+export declare class FilterByExternalFilterRule implements ILeakObjectFilterRule {
+    filter(config: MemLabConfig, node: IHeapNode, snapshot: IHeapSnapshot, leakedNodeIds: HeapNodeIdSet): LeakDecision;
+}
+//# sourceMappingURL=FilterByExternalFilter.rule.d.ts.map

package/dist/lib/leak-filters/rules/FilterByExternalFilter.rule.js

@@ -0,0 +1,27 @@
+"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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterByExternalFilterRule = void 0;
+const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
+/**
+ * filter memory leaks defined by external leak filter
+ */
+class FilterByExternalFilterRule {
+    filter(config, node, snapshot, leakedNodeIds) {
+        if (config.externalLeakFilter) {
+            return config.externalLeakFilter.leakFilter(node, snapshot, leakedNodeIds)
+                ? BaseLeakFilter_rule_1.LeakDecision.LEAK
+                : BaseLeakFilter_rule_1.LeakDecision.NOT_LEAK;
+        }
+        return BaseLeakFilter_rule_1.LeakDecision.MAYBE_LEAK;
+    }
+}
+exports.FilterByExternalFilterRule = FilterByExternalFilterRule;

package/dist/lib/leak-filters/rules/FilterDetachedDOMElement.rule.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { MemLabConfig } from '../../Config';
+import type { IHeapNode } from '../../Types';
+import { ILeakObjectFilterRule, LeakDecision } from '../BaseLeakFilter.rule';
+/**
+ * mark detached DOM elements as memory leaks
+ */
+export declare class FilterDetachedDOMElementRule implements ILeakObjectFilterRule {
+    filter(_config: MemLabConfig, node: IHeapNode): LeakDecision;
+    protected checkDetachedFiberNode(config: MemLabConfig, node: IHeapNode): boolean;
+}
+//# sourceMappingURL=FilterDetachedDOMElement.rule.d.ts.map

package/dist/lib/leak-filters/rules/FilterDetachedDOMElement.rule.js

@@ -0,0 +1,40 @@
+"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.FilterDetachedDOMElementRule = void 0;
+const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
+const Utils_1 = __importDefault(require("../../Utils"));
+/**
+ * mark detached DOM elements as memory leaks
+ */
+class FilterDetachedDOMElementRule {
+    filter(_config, node) {
+        const isDetached = Utils_1.default.isDetachedDOMNode(node, {
+            ignoreInternalNode: true,
+        });
+        if (isDetached) {
+            return BaseLeakFilter_rule_1.LeakDecision.LEAK;
+        }
+        return BaseLeakFilter_rule_1.LeakDecision.MAYBE_LEAK;
+    }
+    checkDetachedFiberNode(config, node) {
+        if (!config.detectFiberNodeLeak ||
+            !Utils_1.default.isFiberNode(node) ||
+            Utils_1.default.hasHostRoot(node)) {
+            return false;
+        }
+        return !Utils_1.default.isNodeDominatedByDeletionsArray(node);
+    }
+}
+exports.FilterDetachedDOMElementRule = FilterDetachedDOMElementRule;

package/dist/lib/leak-filters/rules/FilterHermesNode.rule.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 { MemLabConfig } from '../../Config';
+import type { IHeapNode } from '../../Types';
+import { ILeakObjectFilterRule, LeakDecision } from '../BaseLeakFilter.rule';
+export declare class FilterHermesNodeRule implements ILeakObjectFilterRule {
+    filter(config: MemLabConfig, node: IHeapNode): LeakDecision;
+}
+//# sourceMappingURL=FilterHermesNode.rule.d.ts.map

package/dist/lib/leak-filters/rules/FilterHermesNode.rule.js

@@ -0,0 +1,27 @@
+"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.FilterHermesNodeRule = void 0;
+const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
+const Utils_1 = __importDefault(require("../../Utils"));
+class FilterHermesNodeRule {
+    filter(config, node) {
+        // when analyzing hermes heap snapshots, filter Hermes internal objects
+        if (config.jsEngine === 'hermes' && Utils_1.default.isHermesInternalObject(node)) {
+            return BaseLeakFilter_rule_1.LeakDecision.NOT_LEAK;
+        }
+        return BaseLeakFilter_rule_1.LeakDecision.MAYBE_LEAK;
+    }
+}
+exports.FilterHermesNodeRule = FilterHermesNodeRule;

package/dist/lib/leak-filters/rules/FilterOverSizedNodeAsLeak.rule.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { MemLabConfig } from '../../Config';
+import type { IHeapNode } from '../../Types';
+import { ILeakObjectFilterRule, LeakDecision } from '../BaseLeakFilter.rule';
+/**
+ * trivial nodes are not reported as memory leaks
+ */
+export declare class FilterOverSizedNodeAsLeakRule implements ILeakObjectFilterRule {
+    filter(config: MemLabConfig, node: IHeapNode): LeakDecision;
+}
+//# sourceMappingURL=FilterOverSizedNodeAsLeak.rule.d.ts.map

package/dist/lib/leak-filters/rules/FilterOverSizedNodeAsLeak.rule.js

@@ -0,0 +1,27 @@
+"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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterOverSizedNodeAsLeakRule = void 0;
+const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
+/**
+ * trivial nodes are not reported as memory leaks
+ */
+class FilterOverSizedNodeAsLeakRule {
+    filter(config, node) {
+        if (config.oversizeObjectAsLeak) {
+            return node.retainedSize > config.oversizeThreshold
+                ? BaseLeakFilter_rule_1.LeakDecision.LEAK
+                : BaseLeakFilter_rule_1.LeakDecision.NOT_LEAK;
+        }
+        return BaseLeakFilter_rule_1.LeakDecision.MAYBE_LEAK;
+    }
+}
+exports.FilterOverSizedNodeAsLeakRule = FilterOverSizedNodeAsLeakRule;

package/dist/lib/leak-filters/rules/FilterStackTraceFrame.rule.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { MemLabConfig } from '../../Config';
+import type { IHeapNode } from '../../Types';
+import { ILeakObjectFilterRule, LeakDecision } from '../BaseLeakFilter.rule';
+/**
+ * stack trace frames as memory leaks
+ */
+export declare class FilterStackTraceFrameRule implements ILeakObjectFilterRule {
+    filter(_config: MemLabConfig, node: IHeapNode): LeakDecision;
+}
+//# sourceMappingURL=FilterStackTraceFrame.rule.d.ts.map

package/dist/lib/leak-filters/rules/FilterStackTraceFrame.rule.js

@@ -0,0 +1,28 @@
+"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.FilterStackTraceFrameRule = void 0;
+const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
+const Utils_1 = __importDefault(require("../../Utils"));
+/**
+ * stack trace frames as memory leaks
+ */
+class FilterStackTraceFrameRule {
+    filter(_config, node) {
+        return Utils_1.default.isStackTraceFrame(node)
+            ? BaseLeakFilter_rule_1.LeakDecision.LEAK
+            : BaseLeakFilter_rule_1.LeakDecision.MAYBE_LEAK;
+    }
+}
+exports.FilterStackTraceFrameRule = FilterStackTraceFrameRule;

package/dist/lib/leak-filters/rules/FilterTrivialNode.rule.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { MemLabConfig } from '../../Config';
+import type { IHeapNode } from '../../Types';
+import { ILeakObjectFilterRule, LeakDecision } from '../BaseLeakFilter.rule';
+/**
+ * trivial nodes are not reported as memory leaks
+ */
+export declare class FilterTrivialNodeRule implements ILeakObjectFilterRule {
+    filter(config: MemLabConfig, node: IHeapNode): LeakDecision;
+    protected isTrivialNode(node: IHeapNode): boolean;
+}
+//# sourceMappingURL=FilterTrivialNode.rule.d.ts.map

package/dist/lib/leak-filters/rules/FilterTrivialNode.rule.js

@@ -0,0 +1,33 @@
+"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.FilterTrivialNodeRule = void 0;
+const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
+const Utils_1 = __importDefault(require("../../Utils"));
+/**
+ * trivial nodes are not reported as memory leaks
+ */
+class FilterTrivialNodeRule {
+    filter(config, node) {
+        return this.isTrivialNode(node)
+            ? BaseLeakFilter_rule_1.LeakDecision.NOT_LEAK
+            : BaseLeakFilter_rule_1.LeakDecision.MAYBE_LEAK;
+    }
+    isTrivialNode(node) {
+        return (node.type === 'number' ||
+            Utils_1.default.isStringNode(node) ||
+            node.type === 'hidden');
+    }
+}
+exports.FilterTrivialNodeRule = FilterTrivialNodeRule;

package/dist/lib/leak-filters/rules/FilterUnmountedFiberNode.rule.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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 { MemLabConfig } from '../../Config';
+import type { IHeapNode } from '../../Types';
+import { ILeakObjectFilterRule, LeakDecision } from '../BaseLeakFilter.rule';
+/**
+ * mark React FiberNodes without a React Fiber Root as memory leaks
+ */
+export declare class FilterUnmountedFiberNodeRule implements ILeakObjectFilterRule {
+    filter(config: MemLabConfig, node: IHeapNode): LeakDecision;
+    protected checkDetachedFiberNode(config: MemLabConfig, node: IHeapNode): boolean;
+}
+//# sourceMappingURL=FilterUnmountedFiberNode.rule.d.ts.map

package/dist/lib/leak-filters/rules/FilterUnmountedFiberNode.rule.js

@@ -0,0 +1,37 @@
+"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.FilterUnmountedFiberNodeRule = void 0;
+const BaseLeakFilter_rule_1 = require("../BaseLeakFilter.rule");
+const Utils_1 = __importDefault(require("../../Utils"));
+/**
+ * mark React FiberNodes without a React Fiber Root as memory leaks
+ */
+class FilterUnmountedFiberNodeRule {
+    filter(config, node) {
+        if (this.checkDetachedFiberNode(config, node)) {
+            return BaseLeakFilter_rule_1.LeakDecision.LEAK;
+        }
+        return BaseLeakFilter_rule_1.LeakDecision.MAYBE_LEAK;
+    }
+    checkDetachedFiberNode(config, node) {
+        if (!config.detectFiberNodeLeak ||
+            !Utils_1.default.isFiberNode(node) ||
+            Utils_1.default.hasHostRoot(node)) {
+            return false;
+        }
+        return !Utils_1.default.isNodeDominatedByDeletionsArray(node);
+    }
+}
+exports.FilterUnmountedFiberNodeRule = FilterUnmountedFiberNodeRule;

package/dist/trace-cluster/TraceBucket.d.ts

@@ -25,6 +25,7 @@ export default class NormalizedTrace {
     private static diffTraces;
     static diffClusters(newClusters: TraceCluster[], existingClusters: TraceCluster[]): TraceClusterDiff;
     static clusterLeakTraces(leakTraces: LeakTrace[]): Record<string, string>;
+    static filterClusters(clusters: TraceCluster[]): TraceCluster[];
     static clusterPaths(paths: LeakTracePathItem[], snapshot: IHeapSnapshot, aggregateDominatorMetrics: AggregateNodeCb, option?: {
         strategy?: IClusterStrategy;
     }): TraceCluster[];

package/dist/trace-cluster/TraceBucket.js

@@ -171,6 +171,16 @@ class NormalizedTrace {
         }, {});
         return labaledLeakTraces;
     }
+    static filterClusters(clusters) {
+        if (Config_1.default.clusterRetainedSizeThreshold <= 0) {
+            return clusters;
+        }
+        return clusters.filter(cluster => {
+            var _a;
+            return ((_a = cluster.retainedSize) !== null && _a !== void 0 ? _a : Infinity) >
+                Config_1.default.clusterRetainedSizeThreshold;
+        });
+    }
     static clusterPaths(paths, snapshot, aggregateDominatorMetrics, option = {}) {
         Console_1.default.overwrite('Clustering leak traces');
         if (paths.length === 0) {
@@ -192,7 +202,7 @@ class NormalizedTrace {
         // cluster traces
         const { allClusters } = NormalizedTrace.diffTraces(traces, [], option);
         // construct TraceCluster from clustering result
-        const clusters = allClusters.map((traces) => {
+        let clusters = allClusters.map((traces) => {
             const cluster = {
                 path: traceToPathMap.get(traces[0]),
                 count: traces.length,
@@ -205,6 +215,7 @@ class NormalizedTrace {
             this.calculateClusterRetainedSize(cluster, snapshot, aggregateDominatorMetrics);
             return cluster;
         });
+        clusters = NormalizedTrace.filterClusters(clusters);
         clusters.sort((c1, c2) => { var _a, _b; return ((_a = c2.retainedSize) !== null && _a !== void 0 ? _a : 0) - ((_b = c1.retainedSize) !== null && _b !== void 0 ? _b : 0); });
         Console_1.default.midLevel(`MemLab found ${clusters.length} leak(s)`);
         return clusters;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memlab/core",
-  "version": "1.0.8",
+  "version": "1.1.1",
   "license": "MIT",
   "description": "memlab core libraries",
   "author": "Liang Gong <lgong@fb.com>",