@memlab/core 1.1.19 → 1.1.21

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

@@ -129,6 +129,13 @@ class HeapSnapshot {
             },
         };
     }
+    getJSONifyableObject() {
+        return Object.assign({}, this.snapshot.snapshot);
+    }
+    toJSONString(...args) {
+        const rep = this.getJSONifyableObject();
+        return JSON.stringify(rep, ...args);
+    }
     hasObjectWithClassName(className) {
         let detected = false;
         this.nodes.forEach((node) => {

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

@@ -8,11 +8,12 @@
  * @lightSyntaxTransform
  * @oncall web_perf_infra
  */
-import type { IHeapStringNode } from '../Types';
+import type { AnyRecord, IHeapStringNode } from '../Types';
 import type HeapSnapshot from './HeapSnapshot';
 import HeapNode from './HeapNode';
 export default class HeapStringNode extends HeapNode implements IHeapStringNode {
     constructor(heapSnapshot: HeapSnapshot, idx: number);
     get stringValue(): string;
+    getJSONifyableObject(): AnyRecord;
 }
 //# sourceMappingURL=HeapStringNode.d.ts.map

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

@@ -41,5 +41,10 @@ class HeapStringNode extends HeapNode_1.default {
         }
         return this.name;
     }
+    getJSONifyableObject() {
+        const rep = super.getJSONifyableObject();
+        rep.stringValue = this.stringValue;
+        return rep;
+    }
 }
 exports.default = HeapStringNode;

package/dist/lib/trace-filters/BaseTraceFilter.rule.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { MemLabConfig } from '../Config';
+import type { HeapNodeIdSet, IHeapSnapshot, LeakTracePathItem } from '../Types';
+/**
+ * Every leak trace filter rule needs to give a label
+ * to each leak trace passed to the filter
+ */
+export declare enum TraceDecision {
+    INSIGHTFUL = "insightful",
+    MAYBE_INSIGHTFUL = "maybe-insightful",
+    NOT_INSIGHTFUL = "not-insightful"
+}
+export declare type LeakTraceFilterOptions = {
+    config?: MemLabConfig;
+    snapshot?: IHeapSnapshot;
+    leakedNodeIds?: HeapNodeIdSet;
+};
+export interface ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=BaseTraceFilter.rule.d.ts.map

package/dist/lib/trace-filters/BaseTraceFilter.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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraceDecision = void 0;
+/**
+ * Every leak trace filter rule needs to give a label
+ * to each leak trace passed to the filter
+ */
+var TraceDecision;
+(function (TraceDecision) {
+    TraceDecision["INSIGHTFUL"] = "insightful";
+    TraceDecision["MAYBE_INSIGHTFUL"] = "maybe-insightful";
+    TraceDecision["NOT_INSIGHTFUL"] = "not-insightful";
+})(TraceDecision = exports.TraceDecision || (exports.TraceDecision = {}));

package/dist/lib/trace-filters/LeakTraceFilter.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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+import type { LeakTracePathItem } from '../Types';
+import type { LeakTraceFilterOptions } from './BaseTraceFilter.rule';
+/**
+ * apply the leak trace filter rules chain and decide
+ * if a leak trace is useful for memory debugging,
+ * by default all leak traces are considered useful
+ */
+export declare class LeakTraceFilter {
+    filter(p: LeakTracePathItem, options: LeakTraceFilterOptions): boolean;
+}
+//# sourceMappingURL=LeakTraceFilter.d.ts.map

package/dist/lib/trace-filters/LeakTraceFilter.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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeakTraceFilter = void 0;
+const BaseTraceFilter_rule_1 = require("./BaseTraceFilter.rule");
+const TraceFilterRuleList_1 = __importDefault(require("./TraceFilterRuleList"));
+/**
+ * apply the leak trace filter rules chain and decide
+ * if a leak trace is useful for memory debugging,
+ * by default all leak traces are considered useful
+ */
+class LeakTraceFilter {
+    filter(p, options) {
+        for (const rule of TraceFilterRuleList_1.default) {
+            const decision = rule.filter(p, options);
+            if (decision === BaseTraceFilter_rule_1.TraceDecision.INSIGHTFUL) {
+                return true;
+            }
+            if (decision === BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+exports.LeakTraceFilter = LeakTraceFilter;

package/dist/lib/trace-filters/TraceFilterRuleList.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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+import { ILeakTraceFilterRule } from './BaseTraceFilter.rule';
+declare const _default: ILeakTraceFilterRule[];
+export default _default;
+//# sourceMappingURL=TraceFilterRuleList.d.ts.map

package/dist/lib/trace-filters/TraceFilterRuleList.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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+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 FilterAttachedDOMToDetachedDOMTrace_rule_1 = require("./rules/FilterAttachedDOMToDetachedDOMTrace.rule");
+const FilterDOMNodeChainTrace_rule_1 = require("./rules/FilterDOMNodeChainTrace.rule");
+const FilterHermesTrace_rule_1 = require("./rules/FilterHermesTrace.rule");
+const FilterInternalNodeTrace_rule_1 = require("./rules/FilterInternalNodeTrace.rule");
+const FilterPendingActivitiesTrace_rule_1 = require("./rules/FilterPendingActivitiesTrace.rule");
+const FilterShadowRootTrace_rule_1 = require("./rules/FilterShadowRootTrace.rule");
+const FilterStyleEngineTrace_rule_1 = require("./rules/FilterStyleEngineTrace.rule");
+const list = [
+    new FilterHermesTrace_rule_1.FilterHermesTraceRule(),
+    new FilterInternalNodeTrace_rule_1.FilterInternalNodeTraceRule(),
+    new FilterShadowRootTrace_rule_1.FilterShadowRootTraceRule(),
+    new FilterStyleEngineTrace_rule_1.FilterStyleEngineTraceRule(),
+    new FilterPendingActivitiesTrace_rule_1.FilterPendingActivitiesTraceRule(),
+    new FilterDOMNodeChainTrace_rule_1.FilterDOMNodeChainTraceRule(),
+    new FilterAttachedDOMToDetachedDOMTrace_rule_1.FilterAttachedDOMToDetachedDOMTraceRule(),
+];
+exports.default = (0, InternalValueSetter_1.setInternalValue)(list, __filename, Constant_1.default.internalDir);

package/dist/lib/trace-filters/rules/FilterAttachedDOMToDetachedDOMTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterAttachedDOMToDetachedDOMTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterAttachedDOMToDetachedDOMTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterAttachedDOMToDetachedDOMTrace.rule.js

@@ -0,0 +1,55 @@
+"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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterAttachedDOMToDetachedDOMTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterAttachedDOMToDetachedDOMTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path consists of only DOM native nodes/elements
+        if (curConfig.hideBrowserLeak && isAttachedDOMToDetachedDOMChain(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterAttachedDOMToDetachedDOMTraceRule = FilterAttachedDOMToDetachedDOMTraceRule;
+// check if the path has pattern:
+// [Attached Element] -> [InternalNode | Text]+ -> [Detached Element]
+function isAttachedDOMToDetachedDOMChain(path) {
+    if (!path) {
+        return false;
+    }
+    let p = path;
+    let hasEncounteredAttachedNode = false;
+    // skip the rest InternalNode
+    while (p != null && p.node) {
+        if (Utils_1.default.isDetachedDOMNode(p.node)) {
+            return hasEncounteredAttachedNode;
+        }
+        // else if this is an attached node
+        if (Utils_1.default.isDOMNodeIncomplete(p.node)) {
+            hasEncounteredAttachedNode = true;
+        }
+        else {
+            // else if this not a DOM element
+            hasEncounteredAttachedNode = false;
+        }
+        p = p.next;
+    }
+    return false;
+}

package/dist/lib/trace-filters/rules/FilterDOMNodeChainTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterDOMNodeChainTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterDOMNodeChainTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterDOMNodeChainTrace.rule.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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterDOMNodeChainTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterDOMNodeChainTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path consists of only DOM native nodes/elements
+        if (curConfig.hideBrowserLeak && isDOMNodeChain(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterDOMNodeChainTraceRule = FilterDOMNodeChainTraceRule;
+function isDOMNodeChain(path) {
+    let p = path;
+    // all the reference chain consists of DOM elements/nodes
+    while (p && p.node) {
+        if (!Utils_1.default.isRootNode(p.node) && !Utils_1.default.isDOMNodeIncomplete(p.node)) {
+            return false;
+        }
+        p = p.next;
+    }
+    return true;
+}

package/dist/lib/trace-filters/rules/FilterHermesTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterHermesTraceRule implements ILeakTraceFilterRule {
+    filter(_p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterHermesTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterHermesTrace.rule.js

@@ -0,0 +1,29 @@
+"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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterHermesTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterHermesTraceRule {
+    filter(_p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // do not filter out paths when analyzing Hermes snapshots
+        if (curConfig.jsEngine === 'hermes') {
+            return BaseTraceFilter_rule_1.TraceDecision.INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterHermesTraceRule = FilterHermesTraceRule;

package/dist/lib/trace-filters/rules/FilterInternalNodeTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterInternalNodeTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterInternalNodeTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterInternalNodeTrace.rule.js

@@ -0,0 +1,57 @@
+"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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterInternalNodeTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterInternalNodeTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path has pattern: Window -> [InternalNode]+ -> DetachedElement
+        if (curConfig.hideBrowserLeak && internalNodeRetainsDetachedElement(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterInternalNodeTraceRule = FilterInternalNodeTraceRule;
+// check if the path has pattern:
+// Window -> [InternalNode | Text]+ -> DetachedElement
+function internalNodeRetainsDetachedElement(path) {
+    var _a, _b;
+    if (!path) {
+        return false;
+    }
+    let p = path;
+    // GC root is not Window
+    if (!p.node || !p.node.name.startsWith('Window')) {
+        return false;
+    }
+    p = p.next;
+    // Window is not poining to InternalNode
+    if (!p || !p.node || p.node.name !== 'InternalNode') {
+        return false;
+    }
+    // skip the rest InternalNode
+    while (((_a = p.node) === null || _a === void 0 ? void 0 : _a.name) === 'InternalNode' || ((_b = p.node) === null || _b === void 0 ? void 0 : _b.name) === 'Text') {
+        p = p.next;
+        if (!p) {
+            return false;
+        }
+    }
+    // check if the node is a detached element
+    return p && Utils_1.default.isDetachedDOMNode(p.node);
+}

package/dist/lib/trace-filters/rules/FilterPendingActivitiesTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterPendingActivitiesTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterPendingActivitiesTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterPendingActivitiesTrace.rule.js

@@ -0,0 +1,62 @@
+"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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterPendingActivitiesTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterPendingActivitiesTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path has pattern: Pending activitiies -> DetachedElement
+        if (curConfig.hideBrowserLeak &&
+            pendingActivitiesRetainsDetachedElementChain(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterPendingActivitiesTraceRule = FilterPendingActivitiesTraceRule;
+function pendingActivitiesRetainsDetachedElementChain(path) {
+    let p = path;
+    // find the Pending activities
+    while (p && p.node && !Utils_1.default.isPendingActivityNode(p.node)) {
+        p = p.next;
+        if (!p) {
+            return false;
+        }
+    }
+    p = p.next;
+    if (!p || !p.node) {
+        return false;
+    }
+    // Scan the rest of the trace, if the following check is met,
+    // the leak trace is considered as not suitable for debugging:
+    // If the scanner encounters an object o on the
+    // rest of the leak trace, where o is neither a detached DOM node nor a
+    // Fiber Node and if the scanner didn't hit a detached DOM node first
+    while (p && p.node) {
+        if (Utils_1.default.isDetachedDOMNode(p.node)) {
+            return true;
+        }
+        if (!Utils_1.default.isDOMInternalNode(p.node) &&
+            !Utils_1.default.isDetachedDOMNode(p.node) &&
+            !Utils_1.default.isFiberNode(p.node)) {
+            return false;
+        }
+        p = p.next;
+    }
+    return true;
+}

package/dist/lib/trace-filters/rules/FilterShadowRootTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterShadowRootTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterShadowRootTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterShadowRootTrace.rule.js

@@ -0,0 +1,44 @@
+"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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterShadowRootTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterShadowRootTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path has pattern: ShadowRoot -> DetachedElement
+        if (curConfig.hideBrowserLeak && shadowRootRetainsDetachedElement(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterShadowRootTraceRule = FilterShadowRootTraceRule;
+// check if the path has pattern: ShadowRoot -> DetachedElement
+function shadowRootRetainsDetachedElement(path) {
+    let p = path;
+    // find the ShadowRoot
+    while (p && p.node && p.node.name !== 'ShadowRoot') {
+        p = p.next;
+        if (!p) {
+            return false;
+        }
+    }
+    p = p.next;
+    // check if the node is a detached element
+    return !!p && Utils_1.default.isDetachedDOMNode(p.node);
+}

package/dist/lib/trace-filters/rules/FilterStyleEngineTrace.rule.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 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 web_perf_infra
+ */
+import type { LeakTracePathItem } from '../../Types';
+import { ILeakTraceFilterRule, LeakTraceFilterOptions, TraceDecision } from '../BaseTraceFilter.rule';
+export declare class FilterStyleEngineTraceRule implements ILeakTraceFilterRule {
+    filter(p: LeakTracePathItem, options?: LeakTraceFilterOptions): TraceDecision;
+}
+//# sourceMappingURL=FilterStyleEngineTrace.rule.d.ts.map

package/dist/lib/trace-filters/rules/FilterStyleEngineTrace.rule.js

@@ -0,0 +1,49 @@
+"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.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilterStyleEngineTraceRule = void 0;
+const Config_1 = __importDefault(require("../../Config"));
+const Utils_1 = __importDefault(require("../../Utils"));
+const BaseTraceFilter_rule_1 = require("../BaseTraceFilter.rule");
+class FilterStyleEngineTraceRule {
+    filter(p, options = {}) {
+        var _a;
+        const curConfig = (_a = options.config) !== null && _a !== void 0 ? _a : Config_1.default;
+        // if the path has pattern: StyleEngine -> InternalNode -> DetachedElement
+        if (curConfig.hideBrowserLeak && styleEngineRetainsDetachedElement(p)) {
+            return BaseTraceFilter_rule_1.TraceDecision.NOT_INSIGHTFUL;
+        }
+        return BaseTraceFilter_rule_1.TraceDecision.MAYBE_INSIGHTFUL;
+    }
+}
+exports.FilterStyleEngineTraceRule = FilterStyleEngineTraceRule;
+// check if the path has pattern: StyleEngine -> InternalNode -> DetachedElement
+function styleEngineRetainsDetachedElement(path) {
+    let p = path;
+    // find the StyleEngine
+    while (p && p.node && p.node.name !== 'StyleEngine') {
+        p = p.next;
+        if (!p) {
+            return false;
+        }
+    }
+    p = p.next;
+    // StyleEngine is not poining to InternalNode
+    if (!p || !p.node || p.node.name !== 'InternalNode') {
+        return false;
+    }
+    p = p.next;
+    // check if the InternalNode is pointing to a detached element
+    return !!p && Utils_1.default.isDetachedDOMNode(p.node);
+}