lighthouse 9.5.0-dev.20230118 → 9.5.0-dev.20230119

package/core/gather/gatherers/installability-errors.d.ts

@@ -0,0 +1,17 @@
+export default InstallabilityErrors;
+declare class InstallabilityErrors extends FRGatherer {
+    /**
+     * Creates an Artifacts.InstallabilityErrors, tranforming data from the protocol
+     * for old versions of Chrome.
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @return {Promise<LH.Artifacts['InstallabilityErrors']>}
+     */
+    static getInstallabilityErrors(session: LH.Gatherer.FRProtocolSession): Promise<LH.Artifacts['InstallabilityErrors']>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<LH.Artifacts['InstallabilityErrors']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['InstallabilityErrors']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=installability-errors.d.ts.map

package/core/gather/gatherers/js-usage.d.ts

@@ -0,0 +1,22 @@
+export default JsUsage;
+/**
+ * @fileoverview Tracks unused JavaScript
+ */
+declare class JsUsage extends FRGatherer {
+    /** @type {LH.Crdp.Profiler.ScriptCoverage[]} */
+    _scriptUsages: LH.Crdp.Profiler.ScriptCoverage[];
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     */
+    startInstrumentation(context: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     */
+    stopInstrumentation(context: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @return {Promise<LH.Artifacts['JsUsage']>}
+     */
+    getArtifact(): Promise<LH.Artifacts['JsUsage']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=js-usage.d.ts.map

package/core/gather/gatherers/link-elements.d.ts

@@ -0,0 +1,39 @@
+export default LinkElements;
+declare class LinkElements extends FRGatherer {
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<LH.Artifacts['LinkElements']>}
+     */
+    static getLinkElementsInDOM(context: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['LinkElements']>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @param {LH.Artifacts['DevtoolsLog']} devtoolsLog
+     * @return {Promise<LH.Artifacts['LinkElements']>}
+     */
+    static getLinkElementsInHeaders(context: LH.Gatherer.FRTransitionalContext, devtoolsLog: LH.Artifacts['DevtoolsLog']): Promise<LH.Artifacts['LinkElements']>;
+    /**
+     * This needs to be in the constructor.
+     * https://github.com/GoogleChrome/lighthouse/issues/12134
+     * @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>}
+     */
+    meta: LH.Gatherer.GathererMeta<'DevtoolsLog'>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @param {LH.Artifacts['DevtoolsLog']} devtoolsLog
+     * @return {Promise<LH.Artifacts['LinkElements']>}
+     */
+    _getArtifact(context: LH.Gatherer.FRTransitionalContext, devtoolsLog: LH.Artifacts['DevtoolsLog']): Promise<LH.Artifacts['LinkElements']>;
+    /**
+     * @param {LH.Gatherer.PassContext} context
+     * @param {LH.Gatherer.LoadData} loadData
+     * @return {Promise<LH.Artifacts['LinkElements']>}
+     */
+    afterPass(context: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData): Promise<LH.Artifacts['LinkElements']>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>} context
+     * @return {Promise<LH.Artifacts['LinkElements']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>): Promise<LH.Artifacts['LinkElements']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=link-elements.d.ts.map

package/core/gather/gatherers/main-document-content.d.ts

@@ -0,0 +1,27 @@
+export default MainDocumentContent;
+/**
+ * Collects the content of the main html document.
+ */
+declare class MainDocumentContent extends FRGatherer {
+    /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
+    meta: LH.Gatherer.GathererMeta<'DevtoolsLog'>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @param {LH.Artifacts['DevtoolsLog']} devtoolsLog
+     * @return {Promise<LH.Artifacts['MainDocumentContent']>}
+     */
+    _getArtifact(context: LH.Gatherer.FRTransitionalContext, devtoolsLog: LH.Artifacts['DevtoolsLog']): Promise<LH.Artifacts['MainDocumentContent']>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>} context
+     * @return {Promise<LH.Artifacts['MainDocumentContent']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>): Promise<LH.Artifacts['MainDocumentContent']>;
+    /**
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {LH.Gatherer.LoadData} loadData
+     * @return {Promise<LH.Artifacts['MainDocumentContent']>}
+     */
+    afterPass(passContext: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData): Promise<LH.Artifacts['MainDocumentContent']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=main-document-content.d.ts.map

package/core/gather/gatherers/meta-elements.d.ts

@@ -0,0 +1,10 @@
+export default MetaElements;
+declare class MetaElements extends FRGatherer {
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<LH.Artifacts['MetaElements']>}
+     */
+    getArtifact(passContext: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['MetaElements']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=meta-elements.d.ts.map

package/core/gather/gatherers/network-user-agent.d.ts

@@ -0,0 +1,18 @@
+export default NetworkUserAgent;
+/** @implements {LH.Gatherer.FRGathererInstance<'DevtoolsLog'>} */
+declare class NetworkUserAgent extends FRGatherer implements LH.Gatherer.FRGathererInstance<'DevtoolsLog'> {
+    /**
+     * @param {LH.Artifacts['DevtoolsLog']} devtoolsLog
+     * @return {string}
+     */
+    static getNetworkUserAgent(devtoolsLog: LH.Artifacts['DevtoolsLog']): string;
+    /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
+    meta: LH.Gatherer.GathererMeta<'DevtoolsLog'>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>} context
+     * @return {Promise<LH.Artifacts['NetworkUserAgent']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>): Promise<LH.Artifacts['NetworkUserAgent']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=network-user-agent.d.ts.map

package/core/gather/gatherers/script-elements.d.ts

@@ -0,0 +1,26 @@
+export default ScriptElements;
+/**
+ * @fileoverview Gets JavaScript file contents.
+ */
+declare class ScriptElements extends FRGatherer {
+    /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
+    meta: LH.Gatherer.GathererMeta<'DevtoolsLog'>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+     * @return {Promise<LH.Artifacts['ScriptElements']>}
+     */
+    _getArtifact(context: LH.Gatherer.FRTransitionalContext, networkRecords: LH.Artifacts.NetworkRequest[]): Promise<LH.Artifacts['ScriptElements']>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>} context
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>): Promise<import("../../index.js").Artifacts.ScriptElement[]>;
+    /**
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {LH.Gatherer.LoadData} loadData
+     */
+    afterPass(passContext: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData): Promise<import("../../index.js").Artifacts.ScriptElement[]>;
+}
+import FRGatherer from "../base-gatherer.js";
+import { NetworkRequest } from "../../lib/network-request.js";
+//# sourceMappingURL=script-elements.d.ts.map

package/core/gather/gatherers/scripts.d.ts

@@ -0,0 +1,27 @@
+export default Scripts;
+/**
+ * @fileoverview Gets JavaScript file contents.
+ */
+declare class Scripts extends FRGatherer {
+    /** @type {LH.Crdp.Debugger.ScriptParsedEvent[]} */
+    _scriptParsedEvents: LH.Crdp.Debugger.ScriptParsedEvent[];
+    /** @type {Array<string | undefined>} */
+    _scriptContents: Array<string | undefined>;
+    /** @type {string|null|undefined} */
+    _mainSessionId: string | null | undefined;
+    /**
+     * @param {LH.Crdp.Debugger.ScriptParsedEvent} params
+     */
+    onScriptParsed(params: LH.Crdp.Debugger.ScriptParsedEvent): void;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     */
+    startInstrumentation(context: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     */
+    stopInstrumentation(context: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    getArtifact(): Promise<import("../../index.js").Artifacts.Script[]>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=scripts.d.ts.map

package/core/gather/gatherers/seo/embedded-content.d.ts

@@ -0,0 +1,10 @@
+export default EmbeddedContent;
+declare class EmbeddedContent extends FRGatherer {
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<LH.Artifacts['EmbeddedContent']>}
+     */
+    getArtifact(passContext: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['EmbeddedContent']>;
+}
+import FRGatherer from "../../base-gatherer.js";
+//# sourceMappingURL=embedded-content.d.ts.map

package/core/gather/gatherers/seo/font-size.d.ts

@@ -0,0 +1,131 @@
+export default FontSize;
+export type Driver = typeof import("../../../legacy/gather/driver.js");
+export type NodeFontData = LH.Artifacts.FontSize['analyzedFailingNodesData'][0];
+export type BackendIdsToFontData = Map<number, {
+    fontSize: number;
+    textLength: number;
+}>;
+declare class FontSize extends FRGatherer {
+    /**
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @param {Array<NodeFontData>} failingNodes
+     */
+    static fetchFailingNodeSourceRules(session: LH.Gatherer.FRProtocolSession, failingNodes: Array<NodeFontData>): Promise<{
+        analyzedFailingNodesData: {
+            nodeId: number;
+            fontSize: number;
+            textLength: number;
+            parentNode: {
+                backendNodeId: number;
+                attributes: string[];
+                nodeName: string;
+                parentNode?: {
+                    backendNodeId: number;
+                    attributes: string[];
+                    nodeName: string;
+                } | undefined;
+            };
+            cssRule?: {
+                type: "Inline" | "Regular" | "Attributes";
+                range?: {
+                    startLine: number;
+                    startColumn: number;
+                } | undefined;
+                parentRule?: {
+                    origin: import("devtools-protocol").Protocol.CSS.StyleSheetOrigin;
+                    selectors: {
+                        text: string;
+                    }[];
+                } | undefined;
+                styleSheetId?: string | undefined;
+                stylesheet?: import("devtools-protocol").Protocol.CSS.CSSStyleSheetHeader | undefined;
+                cssProperties?: import("devtools-protocol").Protocol.CSS.CSSProperty[] | undefined;
+            } | undefined;
+        }[];
+        analyzedFailingTextLength: number;
+    }>;
+    /**
+     * Returns the TextNodes in a DOM Snapshot.
+     * Every entry is associated with a TextNode in the layout tree (not display: none).
+     * @param {LH.Crdp.DOMSnapshot.CaptureSnapshotResponse} snapshot
+     */
+    getTextNodesInLayoutFromSnapshot(snapshot: LH.Crdp.DOMSnapshot.CaptureSnapshotResponse): {
+        nodeIndex: number;
+        backendNodeId: number;
+        fontSize: number;
+        textLength: number;
+        parentNode: {
+            parentNode: {
+                backendNodeId: number;
+                attributes: string[];
+                nodeName: string;
+            } | undefined;
+            backendNodeId: number;
+            attributes: string[];
+            nodeName: string;
+        };
+    }[];
+    /**
+     * Get all the failing text nodes that don't meet the legible text threshold.
+     * @param {LH.Crdp.DOMSnapshot.CaptureSnapshotResponse} snapshot
+     */
+    findFailingNodes(snapshot: LH.Crdp.DOMSnapshot.CaptureSnapshotResponse): {
+        totalTextLength: number;
+        failingTextLength: number;
+        failingNodes: {
+            nodeId: number;
+            fontSize: number;
+            textLength: number;
+            parentNode: {
+                backendNodeId: number;
+                attributes: string[];
+                nodeName: string;
+                parentNode?: {
+                    backendNodeId: number;
+                    attributes: string[];
+                    nodeName: string;
+                } | undefined;
+            };
+            cssRule?: {
+                type: "Inline" | "Regular" | "Attributes";
+                range?: {
+                    startLine: number;
+                    startColumn: number;
+                } | undefined;
+                parentRule?: {
+                    origin: import("devtools-protocol").Protocol.CSS.StyleSheetOrigin;
+                    selectors: {
+                        text: string;
+                    }[];
+                } | undefined;
+                styleSheetId?: string | undefined;
+                stylesheet?: import("devtools-protocol").Protocol.CSS.CSSStyleSheetHeader | undefined;
+                cssProperties?: import("devtools-protocol").Protocol.CSS.CSSProperty[] | undefined;
+            } | undefined;
+        }[];
+    };
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<LH.Artifacts.FontSize>} font-size analysis
+     */
+    getArtifact(passContext: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts.FontSize>;
+}
+/**
+ * Returns the governing/winning CSS font-size rule for the set of styles given.
+ * This is roughly a stripped down version of the CSSMatchedStyle class in DevTools.
+ *
+ * @see https://cs.chromium.org/chromium/src/third_party/blink/renderer/devtools/front_end/sdk/CSSMatchedStyles.js?q=CSSMatchedStyles+f:devtools+-f:out&sq=package:chromium&dr=C&l=59-134
+ * @param {LH.Crdp.CSS.GetMatchedStylesForNodeResponse} matched CSS rules
+ * @return {NodeFontData['cssRule']|undefined}
+ */
+export function getEffectiveFontRule({ attributesStyle, inlineStyle, matchedCSSRules, inherited }: LH.Crdp.CSS.GetMatchedStylesForNodeResponse): NodeFontData['cssRule'] | undefined;
+/**
+ * Finds the most specific directly matched CSS font-size rule from the list.
+ *
+ * @param {Array<LH.Crdp.CSS.RuleMatch>} matchedCSSRules
+ * @param {function(LH.Crdp.CSS.CSSStyle):boolean|string|undefined} isDeclarationOfInterest
+ * @return {NodeFontData['cssRule']|undefined}
+ */
+export function findMostSpecificMatchedCSSRule(matchedCSSRules: import("devtools-protocol").Protocol.CSS.RuleMatch[] | undefined, isDeclarationOfInterest: (arg0: LH.Crdp.CSS.CSSStyle) => boolean | string | undefined): NodeFontData['cssRule'] | undefined;
+import FRGatherer from "../../base-gatherer.js";
+//# sourceMappingURL=font-size.d.ts.map

package/core/gather/gatherers/seo/robots-txt.d.ts

@@ -0,0 +1,10 @@
+export default RobotsTxt;
+declare class RobotsTxt extends FRGatherer {
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<LH.Artifacts['RobotsTxt']>}
+     */
+    getArtifact(passContext: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['RobotsTxt']>;
+}
+import FRGatherer from "../../base-gatherer.js";
+//# sourceMappingURL=robots-txt.d.ts.map

package/core/gather/gatherers/seo/tap-targets.d.ts

@@ -0,0 +1,21 @@
+export default TapTargets;
+declare class TapTargets extends FRGatherer {
+    /**
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @param {string} className
+     * @return {Promise<string>}
+     */
+    addStyleRule(session: LH.Gatherer.FRProtocolSession, className: string): Promise<string>;
+    /**
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @param {string} styleSheetId
+     */
+    removeStyleRule(session: LH.Gatherer.FRProtocolSession, styleSheetId: string): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<LH.Artifacts.TapTarget[]>} All visible tap targets with their positions and sizes
+     */
+    getArtifact(passContext: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts.TapTarget[]>;
+}
+import FRGatherer from "../../base-gatherer.js";
+//# sourceMappingURL=tap-targets.d.ts.map

package/core/gather/gatherers/service-worker.d.ts

@@ -0,0 +1,16 @@
+export default ServiceWorker;
+declare class ServiceWorker extends FRGatherer {
+    /**
+     * @param {LH.Gatherer.PassContext} passContext
+     * @return {Promise<LH.Artifacts['ServiceWorker']>}
+     */
+    beforePass(passContext: LH.Gatherer.PassContext): Promise<LH.Artifacts['ServiceWorker']>;
+    afterPass(): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<LH.Artifacts['ServiceWorker']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['ServiceWorker']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=service-worker.d.ts.map

package/core/gather/gatherers/source-maps.d.ts

@@ -0,0 +1,50 @@
+export default SourceMaps;
+/**
+ * @fileoverview Gets JavaScript source maps.
+ */
+declare class SourceMaps extends FRGatherer {
+    /** @type {LH.Crdp.Debugger.ScriptParsedEvent[]} */
+    _scriptParsedEvents: LH.Crdp.Debugger.ScriptParsedEvent[];
+    /**
+     * @param {LH.Crdp.Debugger.ScriptParsedEvent} event
+     */
+    onScriptParsed(event: LH.Crdp.Debugger.ScriptParsedEvent): void;
+    /**
+     * @param {LH.Gatherer.FRTransitionalDriver} driver
+     * @param {string} sourceMapUrl
+     * @return {Promise<LH.Artifacts.RawSourceMap>}
+     */
+    fetchSourceMap(driver: LH.Gatherer.FRTransitionalDriver, sourceMapUrl: string): Promise<LH.Artifacts.RawSourceMap>;
+    /**
+     * @param {string} sourceMapURL
+     * @return {LH.Artifacts.RawSourceMap}
+     */
+    parseSourceMapFromDataUrl(sourceMapURL: string): LH.Artifacts.RawSourceMap;
+    /**
+     * @param {string} url
+     * @param {string} base
+     * @return {string|undefined}
+     */
+    _resolveUrl(url: string, base: string): string | undefined;
+    /**
+     * @param {LH.Gatherer.FRTransitionalDriver} driver
+     * @param {LH.Crdp.Debugger.ScriptParsedEvent} event
+     * @return {Promise<LH.Artifacts.SourceMap>}
+     */
+    _retrieveMapFromScriptParsedEvent(driver: LH.Gatherer.FRTransitionalDriver, event: LH.Crdp.Debugger.ScriptParsedEvent): Promise<LH.Artifacts.SourceMap>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     */
+    startSensitiveInstrumentation(context: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     */
+    stopSensitiveInstrumentation(context: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<LH.Artifacts['SourceMaps']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['SourceMaps']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=source-maps.d.ts.map

package/core/gather/gatherers/stacks.d.ts

@@ -0,0 +1,38 @@
+export default Stacks;
+export type JSLibraryDetectorTestResult = false | {
+    version: string | number | null;
+};
+export type JSLibraryDetectorTest = {
+    id: string;
+    icon: string;
+    url: string;
+    /**
+     * npm module name, if applicable to library.
+     */
+    npm: string | null;
+    /**
+     * Returns false if library is not present, otherwise returns an object that contains the library version (set to null if the version is not detected).
+     */
+    test: (arg0: Window) => JSLibraryDetectorTestResult | Promise<JSLibraryDetectorTestResult>;
+};
+export type JSLibrary = {
+    id: string;
+    name: string;
+    version: string | number | null;
+    npm: string | null;
+};
+/** @implements {LH.Gatherer.FRGathererInstance} */
+declare class Stacks extends FRGatherer implements LH.Gatherer.FRGathererInstance {
+    /**
+     * @param {LH.Gatherer.FRTransitionalDriver['executionContext']} executionContext
+     * @return {Promise<LH.Artifacts['Stacks']>}
+     */
+    static collectStacks(executionContext: LH.Gatherer.FRTransitionalDriver['executionContext']): Promise<LH.Artifacts['Stacks']>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<LH.Artifacts['Stacks']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['Stacks']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=stacks.d.ts.map

package/core/gather/gatherers/trace-compat.d.ts

@@ -0,0 +1,13 @@
+export default TraceCompat;
+/** @implements {LH.Gatherer.FRGathererInstance<'Trace'>} */
+declare class TraceCompat extends FRGatherer implements LH.Gatherer.FRGathererInstance<'Trace'> {
+    /** @type {LH.Gatherer.GathererMeta<'Trace'>} */
+    meta: LH.Gatherer.GathererMeta<'Trace'>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext<'Trace'>} passContext
+     * @return {Promise<LH.Artifacts['traces']>}
+     */
+    getArtifact(passContext: LH.Gatherer.FRTransitionalContext<'Trace'>): Promise<LH.Artifacts['traces']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=trace-compat.d.ts.map

package/core/gather/gatherers/trace-elements.d.ts

@@ -0,0 +1,83 @@
+export default TraceElements;
+export type TraceElementData = {
+    nodeId: number;
+    score?: number;
+    animations?: {
+        name?: string;
+        failureReasonsMask?: number;
+        unsupportedProperties?: string[];
+    }[];
+    type?: string;
+};
+declare class TraceElements extends FRGatherer {
+    /**
+     * @param {Array<number>} rect
+     * @return {LH.Artifacts.Rect}
+     */
+    static traceRectToLHRect(rect: Array<number>): LH.Artifacts.Rect;
+    /**
+     * This function finds the top (up to 5) elements that contribute to the CLS score of the page.
+     * Each layout shift event has a 'score' which is the amount added to the CLS as a result of the given shift(s).
+     * We calculate the score per element by taking the 'score' of each layout shift event and
+     * distributing it between all the nodes that were shifted, proportianal to the impact region of
+     * each shifted element.
+     * @param {Array<LH.TraceEvent>} mainThreadEvents
+     * @return {Array<TraceElementData>}
+     */
+    static getTopLayoutShiftElements(mainThreadEvents: Array<LH.TraceEvent>): Array<TraceElementData>;
+    /**
+     * @param {LH.Trace} trace
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<TraceElementData|undefined>}
+     */
+    static getResponsivenessElement(trace: LH.Trace, context: LH.Gatherer.FRTransitionalContext): Promise<TraceElementData | undefined>;
+    /**
+     * @param {LH.Trace} trace
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<{nodeId: number, type: string} | undefined>}
+     */
+    static getLcpElement(trace: LH.Trace, context: LH.Gatherer.FRTransitionalContext): Promise<{
+        nodeId: number;
+        type: string;
+    } | undefined>;
+    /** @type {LH.Gatherer.GathererMeta<'Trace'>} */
+    meta: LH.Gatherer.GathererMeta<'Trace'>;
+    /** @type {Map<string, string>} */
+    animationIdToName: Map<string, string>;
+    /** @param {LH.Crdp.Animation.AnimationStartedEvent} args */
+    _onAnimationStarted({ animation: { id, name } }: LH.Crdp.Animation.AnimationStartedEvent): void;
+    /**
+     * Find the node ids of elements which are animated using the Animation trace events.
+     * @param {Array<LH.TraceEvent>} mainThreadEvents
+     * @return {Promise<Array<TraceElementData>>}
+     */
+    getAnimatedElements(mainThreadEvents: Array<LH.TraceEvent>): Promise<Array<TraceElementData>>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     */
+    startInstrumentation(context: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     */
+    stopInstrumentation(context: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @param {LH.Trace|undefined} trace
+     * @return {Promise<LH.Artifacts['TraceElements']>}
+     */
+    _getArtifact(context: LH.Gatherer.FRTransitionalContext, trace: LH.Trace | undefined): Promise<LH.Artifacts['TraceElements']>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext<'Trace'>} context
+     * @return {Promise<LH.Artifacts.TraceElement[]>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext<'Trace'>): Promise<LH.Artifacts.TraceElement[]>;
+    /**
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {LH.Gatherer.LoadData} loadData
+     * @return {Promise<LH.Artifacts.TraceElement[]>}
+     */
+    afterPass(passContext: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData): Promise<LH.Artifacts.TraceElement[]>;
+}
+import FRGatherer from "../base-gatherer.js";
+import Trace from "./trace.js";
+//# sourceMappingURL=trace-elements.d.ts.map

package/core/gather/gatherers/trace.d.ts

@@ -0,0 +1,23 @@
+export default Trace;
+declare class Trace extends FRGatherer {
+    static getDefaultTraceCategories(): string[];
+    /**
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @return {Promise<LH.Trace>}
+     */
+    static endTraceAndCollectEvents(session: LH.Gatherer.FRProtocolSession): Promise<LH.Trace>;
+    static symbol: symbol;
+    /** @type {LH.Trace} */
+    _trace: LH.Trace;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     */
+    startSensitiveInstrumentation({ driver, gatherMode, settings }: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     */
+    stopSensitiveInstrumentation({ driver }: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    getArtifact(): import("../../index.js").Trace;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=trace.d.ts.map

package/core/gather/gatherers/viewport-dimensions.d.ts

@@ -0,0 +1,10 @@
+export default ViewportDimensions;
+declare class ViewportDimensions extends FRGatherer {
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<LH.Artifacts.ViewportDimensions>}
+     */
+    getArtifact(passContext: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts.ViewportDimensions>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=viewport-dimensions.d.ts.map

package/core/gather/gatherers/web-app-manifest.d.ts

@@ -0,0 +1,32 @@
+export default WebAppManifest;
+declare class WebAppManifest extends FRGatherer {
+    /**
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @return {Promise<{url: string, data: string}|null>}
+     */
+    static fetchAppManifest(session: LH.Gatherer.FRProtocolSession): Promise<{
+        url: string;
+        data: string;
+    } | null>;
+    /**
+     * Uses the debugger protocol to fetch the manifest from within the context of
+     * the target page, reusing any credentials, emulation, etc, already established
+     * there.
+     *
+     * Returns the parsed manifest or null if the page had no manifest. If the manifest
+     * was unparseable as JSON, manifest.value will be undefined and manifest.warning
+     * will have the reason. See manifest-parser.js for more information.
+     *
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @param {string} pageUrl
+     * @return {Promise<LH.Artifacts.Manifest|null>}
+     */
+    static getWebAppManifest(session: LH.Gatherer.FRProtocolSession, pageUrl: string): Promise<LH.Artifacts.Manifest | null>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<LH.Artifacts['WebAppManifest']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['WebAppManifest']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=web-app-manifest.d.ts.map