@memlab/core 1.0.5 → 1.0.9

package/dist/lib/Types.d.ts

@@ -11,19 +11,30 @@ import { ParsedArgs } from 'minimist';
 import type { LaunchOptions, Page } from 'puppeteer';
 import type { ErrorHandling, MemLabConfig } from './Config';
 export declare type AnyValue = any;
+/** @internal */
 export declare type RecordValue = string | number | boolean | null | RecordValue[] | {
     [key: string]: RecordValue;
 };
+/** @internal */
 export declare type Nullable<T> = T | null;
+/** @internal */
 export declare type Optional<T> = Nullable<T> | undefined;
+/** @internal */
 export declare type AnyRecord = Record<string, RecordValue>;
+/** @internal */
 export declare type AnyAyncFunction = (...args: AnyValue[]) => Promise<AnyValue>;
+/** @internal */
 export declare type AnyFunction = (...args: AnyValue[]) => AnyValue;
+/** @internal */
 export declare type AnyOptions = Record<string, unknown>;
+/** @internal */
 export declare type UnusedOptions = Record<string, never>;
+/** @internal */
 export declare type Command = [string, string[], AnyOptions];
 export declare type Predicator<T> = (node: T) => boolean;
-export declare type HeapNodeIdSet = Set<IHeapNode['id']>;
+/** @internal */
+export declare type HeapNodeIdSet = Set<number>;
+/** @internal */
 export declare type HaltOrThrowOptions = {
     printErrorBeforeHalting?: boolean;
     errorHandling?: ErrorHandling;
@@ -31,10 +42,12 @@ export declare type HaltOrThrowOptions = {
     secondaryMessageToPrint?: string;
     printCallback?: () => void;
 };
+/** @internal */
 export declare type CLIOptions = {
     cliArgs: ParsedArgs;
     configFromOptions?: AnyRecord;
 };
+/** @internal */
 export declare type XvfbType = {
     start: (callback: (error: Error) => AnyValue | null) => void;
     stop: (callback: (error: Error) => AnyValue | null) => void;
@@ -42,6 +55,7 @@ export declare type XvfbType = {
     stopSync: () => void;
     display: () => string;
 };
+/** @internal */
 export declare type CLIArgs = {
     verbose: boolean;
     app: string;
@@ -71,11 +85,11 @@ export declare type CLIArgs = {
     'local-puppeteer': boolean;
     'snapshot-dir': string;
 };
-declare type CookieItem = {
+export declare type Cookies = Array<{
     name: string;
     value: string;
-};
-export declare type Cookies = Array<CookieItem>;
+}>;
+/** @internal */
 export interface IE2EScenarioSynthesizer {
     getAppName(): string;
     getOrigin(): Nullable<string>;
@@ -99,9 +113,11 @@ export interface IE2EScenarioSynthesizer {
     getExtraOperationsForStep(_stepInfo: E2EStepInfo): E2EOperation[];
     synthesis(baseline: string, target: string, intermediates: string[], options: E2ESynthesizerOptions): IE2EScenarioVisitPlan;
 }
+/** @internal */
 export interface E2EScenarioSynthesizerConstructor {
     new (config: Config): IE2EScenarioSynthesizer;
 }
+/** @internal */
 export interface IRunningMode {
     setConfig(config: Config): void;
     beforeRunning(visitPlan: IE2EScenarioVisitPlan): void;
@@ -117,7 +133,9 @@ export interface IRunningMode {
     getAdditionalMetrics(page: Page, tabInfo?: E2EStepInfo): Promise<E2EStepInfo['metrics']>;
     postProcessData(visitPlan: IE2EScenarioVisitPlan): void;
 }
+/** @internal */
 export declare type Config = MemLabConfig;
+/** @internal */
 export declare type QuickExperiment = {
     universe: string;
     experiment: string;
@@ -133,7 +151,7 @@ export declare type InteractionsCallback = (page: Page, args?: OperationArgs) =>
 export interface IScenario {
     name?: () => string;
     app?: () => string;
-    cookies?: () => CookieItem[];
+    cookies?: () => Cookies;
     url: () => string;
     action?: InteractionsCallback;
     back?: InteractionsCallback;
@@ -142,12 +160,14 @@ export interface IScenario {
     beforeLeakFilter?: InitLeakFilterCallback;
     leakFilter?: LeakFilterCallback;
 }
+/** @internal */
 export declare type LeakTracePathItem = {
     node?: IHeapNode;
     edge?: IHeapEdge;
     next?: LeakTracePathItem;
     edgeRetainSize?: number;
 };
+/** @internal */
 export declare type TraceCluster = {
     id?: number;
     path: LeakTracePathItem;
@@ -157,11 +177,13 @@ export declare type TraceCluster = {
     leakedNodeIds?: HeapNodeIdSet;
     clusterMetaInfo?: TraceClusterMetaInfo;
 };
+/** @internal */
 export declare type TraceClusterDiff = {
     staleClusters: TraceCluster[];
     clustersToAdd: TraceCluster[];
     allClusters: TraceCluster[][];
 };
+/** @internal */
 export declare type LeakTraceElement = {
     kind: string;
     id?: number;
@@ -169,12 +191,15 @@ export declare type LeakTraceElement = {
     name_or_index?: string | number;
     type: string;
 };
+/** @internal */
 export declare type LeakTrace = LeakTraceElement[];
+/** @internal */
 export declare type TraceDiff = {
     staleClusters: LeakTrace[];
     clustersToAdd: LeakTrace[];
     allClusters: LeakTrace[][];
 };
+/** @internal */
 export declare type TraceClusterMetaInfo = {
     cluster_id: number;
     creation_time: number;
@@ -189,14 +214,17 @@ export declare type TraceClusterMetaInfo = {
     leak_trace_handle?: string;
     meta_data: string;
 };
+/** @internal */
 export interface E2EInteraction {
     kind: string;
     timeout?: number;
 }
+/** @internal */
 export declare type E2EOperation = E2EInteraction & {
     selector: string;
     act(page: Page, opArgs?: OperationArgs): Promise<void>;
 };
+/** @internal */
 export declare type E2ESynthesizerOptions = {
     name?: string;
     type?: string;
@@ -212,11 +240,14 @@ export declare type E2ESynthesizerOptions = {
     gk_enable?: string[];
     gk_disable?: string[];
 };
+/** @internal */
 export interface IDataBuilder {
     className: string;
     state: Record<string, AnyValue>;
 }
+/** @internal */
 export declare type CheckPageLoadCallback = (page: Page) => Promise<boolean>;
+/** @internal */
 export interface IE2EScenarioVisitPlan {
     name: string;
     appName: string;
@@ -230,6 +261,7 @@ export interface IE2EScenarioVisitPlan {
     dataBuilder: Optional<IDataBuilder>;
     isPageLoaded?: CheckPageLoadCallback;
 }
+/** @internal */
 export declare type OperationArgs = {
     isPageLoaded?: CheckPageLoadCallback;
     showProgress?: boolean;
@@ -240,6 +272,7 @@ export declare type OperationArgs = {
     warmup?: boolean;
     noWaitAfterPageLoad?: boolean;
 };
+/** @internal */
 export interface IE2EStepBasic {
     name: string;
     url: string;
@@ -252,6 +285,7 @@ export interface IE2EStepBasic {
     interactions: E2EOperation | Array<E2EOperation | InteractionsCallback>;
     postInteractions?: E2EOperation | Array<E2EOperation | InteractionsCallback>;
 }
+/** @internal */
 export declare type E2EStepInfo = IE2EStepBasic & {
     snapshot: boolean;
     screenshot: boolean;
@@ -260,6 +294,7 @@ export declare type E2EStepInfo = IE2EStepBasic & {
     delay?: number;
     metrics: Record<string, number>;
 };
+/** @internal */
 export interface IBrowserInfo {
     _browserVersion: string;
     _puppeteerConfig: LaunchOptions;
@@ -353,16 +388,27 @@ export interface IHeapNodes {
     forEach(callback: (node: IHeapNode, index: number) => void | boolean): void;
     forEachTraceable(callback: (node: IHeapNode, index: number) => void | boolean): void;
 }
+/** @internal */
 export declare type HeapNodeFields = string[];
+/** @internal */
 export declare type HeapNodeTypes = string[];
+/** @internal */
 export declare type RawHeapNodeTypes = Array<HeapNodeTypes | string>;
+/** @internal */
 export declare type HeapEdgeFields = string[];
+/** @internal */
 export declare type HeapEdgeTypes = string[] | string;
+/** @internal */
 export declare type RawHeapEdgeTypes = Array<HeapEdgeTypes | string>;
+/** @internal */
 export declare type HeapTraceFunctionInfoFields = string[];
+/** @internal */
 export declare type HeapTraceNodeFields = string[];
+/** @internal */
 export declare type HeapSampleFields = string[];
+/** @internal */
 export declare type HeapLocationFields = string[];
+/** @internal */
 export declare type HeapSnapshotMeta = {
     node_fields: HeapNodeFields;
     node_types: RawHeapNodeTypes;
@@ -373,12 +419,14 @@ export declare type HeapSnapshotMeta = {
     sample_fields: HeapSampleFields;
     location_fields: HeapLocationFields;
 };
+/** @internal */
 export declare type HeapSnapshotInfo = {
     meta: HeapSnapshotMeta;
     node_count: number;
     edge_count: number;
     trace_function_count: number;
 };
+/** @internal */
 export declare type RawHeapSnapshot = {
     snapshot: HeapSnapshotInfo;
     nodes: number[];
@@ -389,12 +437,15 @@ export declare type RawHeapSnapshot = {
     locations: number[];
     strings: string[];
 };
+/** @internal */
 export interface ISerializedInfo {
     [key: string]: string | number | boolean | ISerializedInfo;
 }
+/** @internal */
 export declare type NumericDictionary = {
     [index: number]: number;
 };
+/** @internal */
 export interface IOveralHeapInfo {
     fiberNodeSize: number;
     regularFiberNodeSize: number;
@@ -402,31 +453,37 @@ export interface IOveralHeapInfo {
     alternateFiberNodeSize: number;
     error: number;
 }
+/** @internal */
 export interface IOveralLeakInfo extends Partial<IOveralHeapInfo> {
     leakedSize: number;
     leakedFiberNodeSize: number;
     leakedAlternateFiberNodeSize: number;
 }
+/** @internal */
 export interface IMemoryAnalystOptions {
     snapshotDir?: string;
     minSnapshots?: number;
 }
+/** @internal */
 export interface IMemoryAnalystSnapshotDiff {
     leakedHeapNodeIdSet: HeapNodeIdSet;
     snapshot: IHeapSnapshot;
     listOfLeakedHeapNodeIdSet: Array<HeapNodeIdSet>;
 }
+/** @internal */
 export interface IMemoryAnalystHeapNodeLeakSummary extends Pick<IHeapNode, 'name' | 'type' | 'retainedSize'> {
     count: number;
 }
+/** @internal */
 export interface IMemoryAnalystHeapNodeReferrenceStat {
     numberOfEdgesToNode: number;
     source: IHeapNode;
     edge: IHeapEdge;
 }
+/** @internal */
 export interface IClusterStrategy {
     diffTraces: (newLeakTraces: LeakTrace[], existingLeakTraces: LeakTrace[]) => TraceDiff;
 }
+/** @internal */
 export declare type ErrorWithMessage = Pick<Error, 'message'>;
-export {};
 //# sourceMappingURL=Types.d.ts.map

package/dist/lib/Utils.js

@@ -356,7 +356,7 @@ function getNodesIdSet(snapshot) {
     return set;
 }
 // given a set of nodes S, return a subset S' where
-// no nodes are dominaeted by nodes in S
+// no nodes are dominated by nodes in S
 function getConditionalDominatorIds(ids, snapshot, condCb) {
     const dominatorIds = new Set();
     // set all node ids
@@ -863,6 +863,10 @@ function isInterestingPath(p) {
     if (Config_1.default.hideBrowserLeak && shadowRootRetainsDetachedElement(p)) {
         return false;
     }
+    // if the path has pattern: StyleEngine -> InternalNode -> DetachedElement
+    if (Config_1.default.hideBrowserLeak && styleEngineRetainsDetachedElement(p)) {
+        return false;
+    }
     return true;
 }
 // return true if the heap node represents JS object or closure
@@ -923,6 +927,25 @@ function shadowRootRetainsDetachedElement(path) {
     // check if the node is a detached element
     return !!p && isDetachedDOMNode(p.node);
 }
+// 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 && isDetachedDOMNode(p.node);
+}
 function pathHasDetachedHTMLNode(path) {
     if (!path) {
         return false;

package/dist/lib/leak-filters/BaseLeakFilter.rule.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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';
+/**
+ * Every leak object filter rule needs to give a label
+ * to each object passed to the filter
+ */
+export declare enum LeakDecision {
+    LEAK = "leak",
+    MAYBE_LEAK = "maybe-leak",
+    NOT_LEAK = "not-leak"
+}
+export interface ILeakObjectFilterRule {
+    filter(config: MemLabConfig, node: IHeapNode, snapshot: IHeapSnapshot, leakedNodeIds: HeapNodeIdSet): LeakDecision;
+}
+//# sourceMappingURL=BaseLeakFilter.rule.d.ts.map

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