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

package/core/gather/fetcher.js

@@ -4,6 +4,8 @@
  * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
  */
 
+import * as LH from '../../types/lh.js';
+
 /**
  * @fileoverview Fetcher is a utility for making requests to any arbitrary resource,
  * ignoring normal browser constraints such as CORS.

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

@@ -0,0 +1,23 @@
+export default Accessibility;
+declare class Accessibility extends FRGatherer {
+    static pageFns: {
+        runA11yChecks: typeof runA11yChecks;
+        createAxeRuleResultArtifact: typeof createAxeRuleResultArtifact;
+    };
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<LH.Artifacts.Accessibility>}
+     */
+    getArtifact(passContext: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts.Accessibility>;
+}
+import FRGatherer from "../base-gatherer.js";
+/**
+ * @return {Promise<LH.Artifacts.Accessibility>}
+ */
+declare function runA11yChecks(): Promise<LH.Artifacts.Accessibility>;
+/**
+ * @param {import('axe-core/axe').Result} result
+ * @return {LH.Artifacts.AxeRuleResult}
+ */
+declare function createAxeRuleResultArtifact(result: import('axe-core/axe').Result): LH.Artifacts.AxeRuleResult;
+//# sourceMappingURL=accessibility.d.ts.map

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

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

package/core/gather/gatherers/bf-cache-failures.d.ts

@@ -0,0 +1,43 @@
+export default BFCacheFailures;
+declare class BFCacheFailures extends FRGatherer {
+    /**
+     * @param {LH.Crdp.Page.BackForwardCacheNotRestoredExplanation[]} errorList
+     * @return {LH.Artifacts.BFCacheFailure}
+     */
+    static processBFCacheEventList(errorList: LH.Crdp.Page.BackForwardCacheNotRestoredExplanation[]): LH.Artifacts.BFCacheFailure;
+    /**
+     * @param {LH.Crdp.Page.BackForwardCacheNotRestoredExplanationTree} errorTree
+     * @return {LH.Artifacts.BFCacheFailure}
+     */
+    static processBFCacheEventTree(errorTree: LH.Crdp.Page.BackForwardCacheNotRestoredExplanationTree): LH.Artifacts.BFCacheFailure;
+    /**
+     * @param {LH.Crdp.Page.BackForwardCacheNotUsedEvent|undefined} event
+     * @return {LH.Artifacts.BFCacheFailure}
+     */
+    static processBFCacheEvent(event: LH.Crdp.Page.BackForwardCacheNotUsedEvent | undefined): LH.Artifacts.BFCacheFailure;
+    /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
+    meta: LH.Gatherer.GathererMeta<'DevtoolsLog'>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<LH.Crdp.Page.BackForwardCacheNotUsedEvent|undefined>}
+     */
+    activelyCollectBFCacheEvent(context: LH.Gatherer.FRTransitionalContext): Promise<LH.Crdp.Page.BackForwardCacheNotUsedEvent | undefined>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>} context
+     * @return {LH.Crdp.Page.BackForwardCacheNotUsedEvent[]}
+     */
+    passivelyCollectBFCacheEvents(context: LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>): LH.Crdp.Page.BackForwardCacheNotUsedEvent[];
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>} context
+     * @return {Promise<LH.Artifacts['BFCacheFailures']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>): Promise<LH.Artifacts['BFCacheFailures']>;
+    /**
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {LH.Gatherer.LoadData} loadData
+     * @return {Promise<LH.Artifacts['BFCacheFailures']>}
+     */
+    afterPass(passContext: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData): Promise<LH.Artifacts['BFCacheFailures']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=bf-cache-failures.d.ts.map

package/core/gather/gatherers/cache-contents.d.ts

@@ -0,0 +1,11 @@
+export default CacheContents;
+declare class CacheContents extends FRGatherer {
+    /**
+     * Creates an array of cached URLs.
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<LH.Artifacts['CacheContents']>}
+     */
+    getArtifact(passContext: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['CacheContents']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=cache-contents.d.ts.map

package/core/gather/gatherers/console-messages.d.ts

@@ -0,0 +1,39 @@
+export default ConsoleMessages;
+declare class ConsoleMessages extends FRGatherer {
+    /** @type {LH.Artifacts.ConsoleMessage[]} */
+    _logEntries: LH.Artifacts.ConsoleMessage[];
+    _onConsoleAPICalled: (event: LH.Crdp.Runtime.ConsoleAPICalledEvent) => void;
+    _onExceptionThrown: (event: LH.Crdp.Runtime.ExceptionThrownEvent) => void;
+    _onLogEntryAdded: (event: LH.Crdp.Log.EntryAddedEvent) => void;
+    /**
+     * Handles events for when a script invokes a console API.
+     * @param {LH.Crdp.Runtime.ConsoleAPICalledEvent} event
+     */
+    onConsoleAPICalled(event: LH.Crdp.Runtime.ConsoleAPICalledEvent): void;
+    /**
+     * Handles exception thrown events.
+     * @param {LH.Crdp.Runtime.ExceptionThrownEvent} event
+     */
+    onExceptionThrown(event: LH.Crdp.Runtime.ExceptionThrownEvent): void;
+    /**
+     * Handles browser reports logged to the console, including interventions,
+     * deprecations, violations, and more.
+     * @param {LH.Crdp.Log.EntryAddedEvent} event
+     */
+    onLogEntry(event: LH.Crdp.Log.EntryAddedEvent): void;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     */
+    startInstrumentation(passContext: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<void>}
+     */
+    stopInstrumentation({ driver }: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @return {Promise<LH.Artifacts['ConsoleMessages']>}
+     */
+    getArtifact(): Promise<LH.Artifacts['ConsoleMessages']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=console-messages.d.ts.map

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

@@ -0,0 +1,39 @@
+export default CSSUsage;
+declare class CSSUsage extends FRGatherer {
+    /** @type {LH.Gatherer.FRProtocolSession|undefined} */
+    _session: LH.Gatherer.FRProtocolSession | undefined;
+    /** @type {Map<string, Promise<LH.Artifacts.CSSStyleSheetInfo|Error>>} */
+    _sheetPromises: Map<string, Promise<LH.Artifacts.CSSStyleSheetInfo | Error>>;
+    /**
+     * Initialize as undefined so we can assert results are fetched.
+     * @type {LH.Crdp.CSS.RuleUsage[]|undefined}
+     */
+    _ruleUsage: LH.Crdp.CSS.RuleUsage[] | undefined;
+    /**
+     * @param {LH.Crdp.CSS.StyleSheetAddedEvent} event
+     */
+    _onStylesheetAdded(event: LH.Crdp.CSS.StyleSheetAddedEvent): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     */
+    startCSSUsageTracking(context: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     */
+    stopCSSUsageTracking(context: LH.Gatherer.FRTransitionalContext): Promise<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>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<LH.Artifacts['CSSUsage']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['CSSUsage']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=css-usage.d.ts.map

package/core/gather/gatherers/devtools-log-compat.d.ts

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

package/core/gather/gatherers/devtools-log.d.ts

@@ -0,0 +1,48 @@
+export default DevtoolsLog;
+declare class DevtoolsLog extends FRGatherer {
+    static symbol: symbol;
+    _messageLog: DevtoolsMessageLog;
+    /** @param {LH.Protocol.RawEventMessage} e */
+    _onProtocolMessage: (e: LH.Protocol.RawEventMessage) => void;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     */
+    startSensitiveInstrumentation({ driver }: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     */
+    stopSensitiveInstrumentation({ driver }: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @return {Promise<LH.Artifacts['DevtoolsLog']>}
+     */
+    getArtifact(): Promise<LH.Artifacts['DevtoolsLog']>;
+}
+/**
+ * This class saves all protocol messages whose method match a particular
+ * regex filter. Used when saving assets for later analysis by another tool such as
+ * Webpagetest.
+ */
+export class DevtoolsMessageLog {
+    /**
+     * @param {RegExp=} regexFilter
+     */
+    constructor(regexFilter?: RegExp | undefined);
+    _filter: RegExp | undefined;
+    /** @type {LH.DevtoolsLog} */
+    _messages: import("../../index.js").DevtoolsLog;
+    _isRecording: boolean;
+    /**
+     * @return {LH.DevtoolsLog}
+     */
+    get messages(): import("../../index.js").DevtoolsLog;
+    reset(): void;
+    beginRecording(): void;
+    endRecording(): void;
+    /**
+     * Records a message if method matches filter and recording has been started.
+     * @param {LH.Protocol.RawEventMessage} message
+     */
+    record(message: LH.Protocol.RawEventMessage): void;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=devtools-log.d.ts.map

package/core/gather/gatherers/dobetterweb/doctype.d.ts

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

package/core/gather/gatherers/dobetterweb/domstats.d.ts

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

package/core/gather/gatherers/dobetterweb/optimized-images.d.ts

@@ -0,0 +1,61 @@
+export default OptimizedImages;
+export type SimplifiedNetworkRecord = {
+    requestId: string;
+    url: string;
+    mimeType: string;
+    resourceSize: number;
+};
+/** @typedef {{requestId: string, url: string, mimeType: string, resourceSize: number}} SimplifiedNetworkRecord */
+declare class OptimizedImages extends FRGatherer {
+    /**
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @return {Array<SimplifiedNetworkRecord>}
+     */
+    static filterImageRequests(networkRecords: Array<LH.Artifacts.NetworkRequest>): Array<SimplifiedNetworkRecord>;
+    /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
+    meta: LH.Gatherer.GathererMeta<'DevtoolsLog'>;
+    _encodingStartAt: number;
+    /**
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @param {string} requestId
+     * @param {'jpeg'|'webp'} encoding Either webp or jpeg.
+     * @return {Promise<LH.Crdp.Audits.GetEncodedResponseResponse>}
+     */
+    _getEncodedResponse(session: LH.Gatherer.FRProtocolSession, requestId: string, encoding: 'jpeg' | 'webp'): Promise<LH.Crdp.Audits.GetEncodedResponseResponse>;
+    /**
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @param {SimplifiedNetworkRecord} networkRecord
+     * @return {Promise<{originalSize: number, jpegSize?: number, webpSize?: number}>}
+     */
+    calculateImageStats(session: LH.Gatherer.FRProtocolSession, networkRecord: SimplifiedNetworkRecord): Promise<{
+        originalSize: number;
+        jpegSize?: number | undefined;
+        webpSize?: number | undefined;
+    }>;
+    /**
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @param {Array<SimplifiedNetworkRecord>} imageRecords
+     * @return {Promise<LH.Artifacts['OptimizedImages']>}
+     */
+    computeOptimizedImages(session: LH.Gatherer.FRProtocolSession, imageRecords: Array<SimplifiedNetworkRecord>): Promise<LH.Artifacts['OptimizedImages']>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+     * @return {Promise<LH.Artifacts['OptimizedImages']>}
+     */
+    _getArtifact(context: LH.Gatherer.FRTransitionalContext, networkRecords: LH.Artifacts.NetworkRequest[]): Promise<LH.Artifacts['OptimizedImages']>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>} context
+     * @return {Promise<LH.Artifacts['OptimizedImages']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>): Promise<LH.Artifacts['OptimizedImages']>;
+    /**
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {LH.Gatherer.LoadData} loadData
+     * @return {Promise<LH.Artifacts['OptimizedImages']>}
+     */
+    afterPass(passContext: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData): Promise<LH.Artifacts['OptimizedImages']>;
+}
+import FRGatherer from "../../base-gatherer.js";
+import { NetworkRequest } from "../../../lib/network-request.js";
+//# sourceMappingURL=optimized-images.d.ts.map

package/core/gather/gatherers/dobetterweb/password-inputs-with-prevented-paste.d.ts

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

package/core/gather/gatherers/dobetterweb/response-compression.d.ts

@@ -0,0 +1,30 @@
+export default ResponseCompression;
+declare class ResponseCompression extends FRGatherer {
+    /**
+     * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+     * @return {LH.Artifacts['ResponseCompression']}
+     */
+    static filterUnoptimizedResponses(networkRecords: LH.Artifacts.NetworkRequest[]): LH.Artifacts['ResponseCompression'];
+    /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
+    meta: LH.Gatherer.GathererMeta<'DevtoolsLog'>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+     * @return {Promise<LH.Artifacts['ResponseCompression']>}
+     */
+    _getArtifact(context: LH.Gatherer.FRTransitionalContext, networkRecords: LH.Artifacts.NetworkRequest[]): Promise<LH.Artifacts['ResponseCompression']>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>} context
+     * @return {Promise<LH.Artifacts['ResponseCompression']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>): Promise<LH.Artifacts['ResponseCompression']>;
+    /**
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {LH.Gatherer.LoadData} loadData
+     * @return {Promise<LH.Artifacts['ResponseCompression']>}
+     */
+    afterPass(passContext: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData): Promise<LH.Artifacts['ResponseCompression']>;
+}
+import FRGatherer from "../../base-gatherer.js";
+import { NetworkRequest } from "../../../lib/network-request.js";
+//# sourceMappingURL=response-compression.d.ts.map

package/core/gather/gatherers/dobetterweb/tags-blocking-first-paint.d.ts

@@ -0,0 +1,53 @@
+export default TagsBlockingFirstPaint;
+export type MediaChange = {
+    href: string;
+    media: string;
+    msSinceHTMLEnd: number;
+    matches: boolean;
+};
+export type LinkTag = {
+    tagName: 'LINK';
+    url: string;
+    href: string;
+    rel: string;
+    media: string;
+    disabled: boolean;
+    mediaChanges: Array<MediaChange>;
+};
+export type ScriptTag = {
+    tagName: 'SCRIPT';
+    url: string;
+    src: string;
+};
+declare class TagsBlockingFirstPaint extends FRGatherer {
+    /**
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @return {Map<string, LH.Artifacts.NetworkRequest>}
+     */
+    static _filteredAndIndexedByUrl(networkRecords: Array<LH.Artifacts.NetworkRequest>): Map<string, LH.Artifacts.NetworkRequest>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalDriver} driver
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @return {Promise<Array<LH.Artifacts.TagBlockingFirstPaint>>}
+     */
+    static findBlockingTags(driver: LH.Gatherer.FRTransitionalDriver, networkRecords: Array<LH.Artifacts.NetworkRequest>): Promise<Array<LH.Artifacts.TagBlockingFirstPaint>>;
+    /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
+    meta: LH.Gatherer.GathererMeta<'DevtoolsLog'>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     */
+    startSensitiveInstrumentation(context: LH.Gatherer.FRTransitionalContext): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>} context
+     * @return {Promise<LH.Artifacts['TagsBlockingFirstPaint']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>): Promise<LH.Artifacts['TagsBlockingFirstPaint']>;
+    /**
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {LH.Gatherer.LoadData} loadData
+     * @return {Promise<LH.Artifacts['TagsBlockingFirstPaint']>}
+     */
+    afterPass(passContext: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData): Promise<LH.Artifacts['TagsBlockingFirstPaint']>;
+}
+import FRGatherer from "../../base-gatherer.js";
+//# sourceMappingURL=tags-blocking-first-paint.d.ts.map

package/core/gather/gatherers/full-page-screenshot.d.ts

@@ -0,0 +1,35 @@
+export default FullPageScreenshot;
+declare class FullPageScreenshot extends FRGatherer {
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @param {{height: number, width: number, mobile: boolean}} deviceMetrics
+     */
+    _resizeViewport(context: LH.Gatherer.FRTransitionalContext, deviceMetrics: {
+        height: number;
+        width: number;
+        mobile: boolean;
+    }): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<LH.Result.FullPageScreenshot['screenshot']>}
+     */
+    _takeScreenshot(context: LH.Gatherer.FRTransitionalContext): Promise<LH.Result.FullPageScreenshot['screenshot']>;
+    /**
+     * Gatherers can collect details about DOM nodes, including their position on the page.
+     * Layout shifts occuring after a gatherer runs can cause these positions to be incorrect,
+     * resulting in a poor experience for element screenshots.
+     * `getNodeDetails` maintains a collection of DOM objects in the page, which we can iterate
+     * to re-collect the bounding client rectangle.
+     * @see pageFunctions.getNodeDetails
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<LH.Result.FullPageScreenshot['nodes']>}
+     */
+    _resolveNodes(context: LH.Gatherer.FRTransitionalContext): Promise<LH.Result.FullPageScreenshot['nodes']>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<LH.Artifacts['FullPageScreenshot']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['FullPageScreenshot']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=full-page-screenshot.d.ts.map

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

@@ -0,0 +1,46 @@
+/**
+ * @license Copyright 2016 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+/**
+ * Base class for all gatherers; defines pass lifecycle methods. The artifact
+ * from the gatherer is the last not-undefined value returned by a lifecycle
+ * method. All methods can return the artifact value directly or return a
+ * Promise that resolves to that value.
+ *
+ * If an Error is thrown (or a Promise that rejects on an Error),
+ * the runner will treat it as an error internal to the gatherer and
+ * continue execution of any remaining gatherers.
+ *
+ * @implements {LH.Gatherer.GathererInstance}
+ */
+export class Gatherer implements LH.Gatherer.GathererInstance {
+    /**
+     * @return {keyof LH.GathererArtifacts}
+     */
+    get name(): keyof import("../..").GathererArtifacts;
+    /**
+     * Called before navigation to target url.
+     * @param {LH.Gatherer.PassContext} passContext
+     * @return {LH.Gatherer.PhaseResult}
+     */
+    beforePass(passContext: LH.Gatherer.PassContext): LH.Gatherer.PhaseResult;
+    /**
+     * Called after target page is loaded. If a trace is enabled for this pass,
+     * the trace is still being recorded.
+     * @param {LH.Gatherer.PassContext} passContext
+     * @return {LH.Gatherer.PhaseResult}
+     */
+    pass(passContext: LH.Gatherer.PassContext): LH.Gatherer.PhaseResult;
+    /**
+     * Called after target page is loaded, all gatherer `pass` methods have been
+     * executed, and — if generated in this pass — the trace is ended. The trace
+     * and record of network activity are provided in `loadData`.
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {LH.Gatherer.LoadData} loadData
+     * @return {LH.Gatherer.PhaseResult}
+     */
+    afterPass(passContext: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData): LH.Gatherer.PhaseResult;
+}
+//# sourceMappingURL=gatherer.d.ts.map

package/core/gather/gatherers/global-listeners.d.ts

@@ -0,0 +1,27 @@
+export default GlobalListeners;
+declare class GlobalListeners extends FRGatherer {
+    /**
+     * @param {LH.Crdp.DOMDebugger.EventListener} listener
+     * @return {listener is {type: 'pagehide'|'unload'|'visibilitychange'} & LH.Crdp.DOMDebugger.EventListener}
+     */
+    static _filterForAllowlistedTypes(listener: LH.Crdp.DOMDebugger.EventListener): listener is {
+        type: 'pagehide' | 'unload' | 'visibilitychange';
+    } & import("devtools-protocol").Protocol.DOMDebugger.EventListener;
+    /**
+     * @param { LH.Artifacts.GlobalListener } listener
+     * @return { string }
+     */
+    getListenerIndentifier(listener: LH.Artifacts.GlobalListener): string;
+    /**
+     * @param { LH.Artifacts['GlobalListeners'] } listeners
+     * @return { LH.Artifacts['GlobalListeners'] }
+     */
+    dedupeListeners(listeners: LH.Artifacts['GlobalListeners']): LH.Artifacts['GlobalListeners'];
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} passContext
+     * @return {Promise<LH.Artifacts['GlobalListeners']>}
+     */
+    getArtifact(passContext: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['GlobalListeners']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=global-listeners.d.ts.map

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

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

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

@@ -0,0 +1,35 @@
+export default ImageElements;
+declare class ImageElements extends FRGatherer {
+    /** @type {Map<string, {naturalWidth: number, naturalHeight: number}>} */
+    _naturalSizeCache: Map<string, {
+        naturalWidth: number;
+        naturalHeight: number;
+    }>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalDriver} driver
+     * @param {LH.Artifacts.ImageElement} element
+     */
+    fetchElementWithSizeInformation(driver: LH.Gatherer.FRTransitionalDriver, element: LH.Artifacts.ImageElement): Promise<void>;
+    /**
+     * Images might be sized via CSS. In order to compute unsized-images failures, we need to collect
+     * matched CSS rules to see if this is the case.
+     * @url http://go/dwoqq (googlers only)
+     * @param {LH.Gatherer.FRProtocolSession} session
+     * @param {string} devtoolsNodePath
+     * @param {LH.Artifacts.ImageElement} element
+     */
+    fetchSourceRules(session: LH.Gatherer.FRProtocolSession, devtoolsNodePath: string, element: LH.Artifacts.ImageElement): Promise<void>;
+    /**
+     *
+     * @param {LH.Gatherer.FRTransitionalDriver} driver
+     * @param {LH.Artifacts.ImageElement[]} elements
+     */
+    collectExtraDetails(driver: LH.Gatherer.FRTransitionalDriver, elements: LH.Artifacts.ImageElement[]): Promise<void>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext} context
+     * @return {Promise<LH.Artifacts['ImageElements']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext): Promise<LH.Artifacts['ImageElements']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=image-elements.d.ts.map

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

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

package/core/gather/gatherers/inspector-issues.d.ts

@@ -0,0 +1,38 @@
+export default InspectorIssues;
+declare class InspectorIssues extends FRGatherer {
+    /** @type {LH.Gatherer.GathererMeta<'DevtoolsLog'>} */
+    meta: LH.Gatherer.GathererMeta<'DevtoolsLog'>;
+    /** @type {Array<LH.Crdp.Audits.InspectorIssue>} */
+    _issues: Array<LH.Crdp.Audits.InspectorIssue>;
+    _onIssueAdded: (entry: LH.Crdp.Audits.IssueAddedEvent) => void;
+    /**
+     * @param {LH.Crdp.Audits.IssueAddedEvent} entry
+     */
+    onIssueAdded(entry: LH.Crdp.Audits.IssueAddedEvent): 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>;
+    /**
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @return {Promise<LH.Artifacts['InspectorIssues']>}
+     */
+    _getArtifact(networkRecords: Array<LH.Artifacts.NetworkRequest>): Promise<LH.Artifacts['InspectorIssues']>;
+    /**
+     * @param {LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>} context
+     * @return {Promise<LH.Artifacts['InspectorIssues']>}
+     */
+    getArtifact(context: LH.Gatherer.FRTransitionalContext<'DevtoolsLog'>): Promise<LH.Artifacts['InspectorIssues']>;
+    /**
+     * @param {LH.Gatherer.PassContext} passContext
+     * @param {LH.Gatherer.LoadData} loadData
+     * @return {Promise<LH.Artifacts['InspectorIssues']>}
+     */
+    afterPass(passContext: LH.Gatherer.PassContext, loadData: LH.Gatherer.LoadData): Promise<LH.Artifacts['InspectorIssues']>;
+}
+import FRGatherer from "../base-gatherer.js";
+//# sourceMappingURL=inspector-issues.d.ts.map