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

package/core/lib/median-run.d.ts

@@ -0,0 +1,17 @@
+/**
+ * We want the run that's closest to the median of the FCP and the median of the TTI.
+ * We're using the Euclidean distance for that (https://en.wikipedia.org/wiki/Euclidean_distance).
+ * We use FCP and TTI because they represent the earliest and latest moments in the page lifecycle.
+ * We avoid the median of single measures like the performance score because they can still exhibit
+ * outlier behavior at the beginning or end of load.
+ *
+ * @param {Array<LH.Result>} runs
+ * @return {LH.Result}
+ */
+export function computeMedianRun(runs: Array<LH.Result>): LH.Result;
+/**
+ * @param {Array<LH.Result>} runs
+ * @return {Array<LH.Result>}
+ */
+export function filterToValidRuns(runs: Array<LH.Result>): Array<LH.Result>;
+//# sourceMappingURL=median-run.d.ts.map

package/core/lib/minification-estimator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @param {string} content
+ */
+export function computeJSTokenLength(content: string): number;
+/**
+ * @param {string} content
+ */
+export function computeCSSTokenLength(content: string): number;
+//# sourceMappingURL=minification-estimator.d.ts.map

package/core/lib/minify-devtoolslog.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {LH.DevtoolsLog} log
+ * @return {LH.DevtoolsLog}
+ */
+export function minifyDevtoolsLog(log: import("..").DevtoolsLog): import("..").DevtoolsLog;
+//# sourceMappingURL=minify-devtoolslog.d.ts.map

package/core/lib/minify-trace.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @param {LH.Trace} inputTrace
+ * @return {LH.Trace}
+ */
+export function minifyTrace(inputTrace: LH.Trace): LH.Trace;
+//# sourceMappingURL=minify-trace.d.ts.map

package/core/lib/navigation-error.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Returns an error if the original network request failed or wasn't found.
+ * @param {LH.Artifacts.NetworkRequest|undefined} mainRecord
+ * @return {LH.LighthouseError|undefined}
+ */
+export function getNetworkError(mainRecord: LH.Artifacts.NetworkRequest | undefined): LH.LighthouseError | undefined;
+/**
+ * Returns an error if we ended up on the `chrome-error` page and all other requests failed.
+ * @param {LH.Artifacts.NetworkRequest|undefined} mainRecord
+ * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+ * @return {LH.LighthouseError|undefined}
+ */
+export function getInterstitialError(mainRecord: LH.Artifacts.NetworkRequest | undefined, networkRecords: Array<LH.Artifacts.NetworkRequest>): LH.LighthouseError | undefined;
+/**
+ * Returns an error if the page load should be considered failed, e.g. from a
+ * main document request failure, a security issue, etc.
+ * @param {LH.LighthouseError|undefined} navigationError
+ * @param {{url: string, loadFailureMode: LH.Gatherer.PassContext['passConfig']['loadFailureMode'], networkRecords: Array<LH.Artifacts.NetworkRequest>, warnings: Array<string | LH.IcuMessage>}} context
+ * @return {LH.LighthouseError|undefined}
+ */
+export function getPageLoadError(navigationError: LH.LighthouseError | undefined, context: {
+    url: string;
+    loadFailureMode: LH.Gatherer.PassContext['passConfig']['loadFailureMode'];
+    networkRecords: Array<LH.Artifacts.NetworkRequest>;
+    warnings: Array<string | LH.IcuMessage>;
+}): LH.LighthouseError | undefined;
+/**
+ * Returns an error if we try to load a non-HTML page.
+ * Expects a network request with all redirects resolved, otherwise the MIME type may be incorrect.
+ * @param {LH.Artifacts.NetworkRequest|undefined} finalRecord
+ * @return {LH.LighthouseError|undefined}
+ */
+export function getNonHtmlError(finalRecord: LH.Artifacts.NetworkRequest | undefined): LH.LighthouseError | undefined;
+export namespace UIStrings {
+    const warningXhtml: string;
+}
+import { NetworkRequest } from "./network-request.js";
+import { LighthouseError } from "./lh-error.js";
+//# sourceMappingURL=navigation-error.d.ts.map

package/core/lib/network-recorder.d.ts

@@ -0,0 +1,115 @@
+export type NetworkRecorderEventMap = {
+    requeststarted: [NetworkRequest];
+    requestfinished: [NetworkRequest];
+};
+export type RequestEmitter = LH.Protocol.StrictEventEmitterClass<NetworkRecorderEventMap>;
+declare const NetworkRecorder_base: RequestEmitter;
+export class NetworkRecorder extends NetworkRecorder_base {
+    /**
+     * @param {NetworkRequest} record The record to find the initiator of
+     * @param {Map<string, NetworkRequest[]>} recordsByURL
+     * @return {NetworkRequest|null}
+     * @private
+     */
+    private static _chooseInitiatorRequest;
+    /**
+     * Construct network records from a log of devtools protocol messages.
+     * @param {LH.DevtoolsLog} devtoolsLog
+     * @return {Array<LH.Artifacts.NetworkRequest>}
+     */
+    static recordsFromLogs(devtoolsLog: import("../index.js").DevtoolsLog): Array<LH.Artifacts.NetworkRequest>;
+    /** @type {NetworkRequest[]} */
+    _records: NetworkRequest[];
+    /** @type {Map<string, NetworkRequest>} */
+    _recordsById: Map<string, NetworkRequest>;
+    /** @type {string|null|undefined} */
+    _mainSessionId: string | null | undefined;
+    /**
+     * Returns the array of raw network request data without finalizing the initiator and
+     * redirect chain.
+     * @return {Array<NetworkRequest>}
+     */
+    getRawRecords(): Array<NetworkRequest>;
+    /**
+     * Listener for the DevTools SDK NetworkManager's RequestStarted event, which includes both
+     * web socket and normal request creation.
+     * @param {NetworkRequest} request
+     * @private
+     */
+    private onRequestStarted;
+    /**
+     * Listener for the DevTools SDK NetworkManager's RequestFinished event, which includes
+     * request finish, failure, and redirect, as well as the closing of web sockets.
+     * @param {NetworkRequest} request
+     * @private
+     */
+    private onRequestFinished;
+    /**
+     * @param {{params: LH.Crdp.Network.RequestWillBeSentEvent, sessionId?: string}} event
+     */
+    onRequestWillBeSent(event: {
+        params: LH.Crdp.Network.RequestWillBeSentEvent;
+        sessionId?: string;
+    }): void;
+    /**
+     * @param {{params: LH.Crdp.Network.RequestServedFromCacheEvent, sessionId?: string}} event
+     */
+    onRequestServedFromCache(event: {
+        params: LH.Crdp.Network.RequestServedFromCacheEvent;
+        sessionId?: string;
+    }): void;
+    /**
+     * @param {{params: LH.Crdp.Network.ResponseReceivedEvent, sessionId?: string}} event
+     */
+    onResponseReceived(event: {
+        params: LH.Crdp.Network.ResponseReceivedEvent;
+        sessionId?: string;
+    }): void;
+    /**
+     * @param {{params: LH.Crdp.Network.DataReceivedEvent, sessionId?: string}} event
+     */
+    onDataReceived(event: {
+        params: LH.Crdp.Network.DataReceivedEvent;
+        sessionId?: string;
+    }): void;
+    /**
+     * @param {{params: LH.Crdp.Network.LoadingFinishedEvent, sessionId?: string}} event
+     */
+    onLoadingFinished(event: {
+        params: LH.Crdp.Network.LoadingFinishedEvent;
+        sessionId?: string;
+    }): void;
+    /**
+     * @param {{params: LH.Crdp.Network.LoadingFailedEvent, sessionId?: string}} event
+     */
+    onLoadingFailed(event: {
+        params: LH.Crdp.Network.LoadingFailedEvent;
+        sessionId?: string;
+    }): void;
+    /**
+     * @param {{params: LH.Crdp.Network.ResourceChangedPriorityEvent, sessionId?: string}} event
+     */
+    onResourceChangedPriority(event: {
+        params: LH.Crdp.Network.ResourceChangedPriorityEvent;
+        sessionId?: string;
+    }): void;
+    /**
+     * Routes network events to their handlers, so we can construct networkRecords
+     * @param {LH.Protocol.RawEventMessage} event
+     */
+    dispatch(event: LH.Protocol.RawEventMessage): void;
+    /**
+     * Redirected requests all have identical requestIds over the protocol. Once a request has been
+     * redirected all future messages referrencing that requestId are about the new destination, not
+     * the original. This method is a helper for finding the real request object to which the current
+     * message is referring.
+     *
+     * @param {string} requestId
+     * @param {string|undefined} sessionId
+     * @return {NetworkRequest|undefined}
+     */
+    _findRealRequestAndSetSession(requestId: string, sessionId: string | undefined): NetworkRequest | undefined;
+}
+import { NetworkRequest } from "./network-request.js";
+export {};
+//# sourceMappingURL=network-recorder.d.ts.map

package/core/lib/network-request.d.ts

@@ -0,0 +1,245 @@
+export type HeaderEntry = {
+    name: string;
+    value: string;
+};
+export type ParsedURL = {
+    /**
+     * Equivalent to a `new URL(url).protocol` BUT w/o the trailing colon (:)
+     */
+    scheme: string;
+    /**
+     * Equivalent to a `new URL(url).hostname`
+     */
+    host: string;
+    securityOrigin: string;
+};
+/**
+ * The difference in endTime between the observed Lighthouse endTime and Lightrider's derived endTime.
+ */
+export type LightriderStatistics = {
+    /**
+     * The time spent making a TCP connection (connect + SSL).
+     */
+    endTimeDeltaMs: number;
+    /**
+     * The time spent requesting a resource from a remote server, we use this to approx RTT.
+     */
+    TCPMs: number;
+    /**
+     * The time spent transferring a resource from a remote server.
+     */
+    requestMs: number;
+    responseMs: number;
+};
+export class NetworkRequest {
+    /**
+     * Convert the requestId to backend-version by removing the `:redirect` portion
+     *
+     * @param {string} requestId
+     * @return {string}
+     */
+    static getRequestIdForBackend(requestId: string): string;
+    /**
+     * Based on DevTools NetworkManager.
+     * @see https://github.com/ChromeDevTools/devtools-frontend/blob/3415ee28e86a3f4bcc2e15b652d22069938df3a6/front_end/sdk/NetworkManager.js#L285-L297
+     * @param {LH.Crdp.Network.Headers} headersDict
+     * @return {Array<HeaderEntry>}
+     */
+    static _headersDictToHeadersArray(headersDict: LH.Crdp.Network.Headers): Array<HeaderEntry>;
+    static get TYPES(): LH.Util.SelfMap<LH.Crdp.Network.ResourceType>;
+    /**
+     * @param {NetworkRequest} record
+     * @return {boolean}
+     */
+    static isNonNetworkRequest(record: NetworkRequest): boolean;
+    /**
+     * Technically there's not alignment on URLs that create "secure connections" vs "secure contexts"
+     * https://github.com/GoogleChrome/lighthouse/pull/11766#discussion_r582340683
+     * But for our purposes, we don't need to worry too much.
+     * @param {NetworkRequest} record
+     * @return {boolean}
+     */
+    static isSecureRequest(record: NetworkRequest): boolean;
+    /**
+     * Returns whether the network request was an HSTS redirect request.
+     * @param {NetworkRequest} record
+     * @return {boolean}
+     */
+    static isHstsRequest(record: NetworkRequest): boolean;
+    /**
+     * Resource size is almost always the right one to be using because of the below:
+     *     `transferSize = resourceSize + headers.length`.
+     * HOWEVER, there are some cases where an image is compressed again over the network and transfer size
+     * is smaller (see https://github.com/GoogleChrome/lighthouse/pull/4968).
+     * Use the min of the two numbers to be safe.
+     * `tranferSize` of cached records is 0
+     * @param {NetworkRequest} networkRecord
+     * @return {number}
+     */
+    static getResourceSizeOnNetwork(networkRecord: NetworkRequest): number;
+    requestId: string;
+    connectionId: string;
+    connectionReused: boolean;
+    url: string;
+    protocol: string;
+    isSecure: boolean;
+    isValid: boolean;
+    parsedURL: ParsedURL;
+    documentURL: string;
+    /**
+     * When the network service is about to handle a request, ie. just before going to the
+     * HTTP cache or going to the network for DNS/connection setup, in milliseconds.
+     */
+    startTime: number;
+    /** When the last byte of the response body is received, in milliseconds. */
+    endTime: number;
+    /** When the last byte of the response headers is received, in milliseconds. */
+    responseReceivedTime: number;
+    transferSize: number;
+    resourceSize: number;
+    fromDiskCache: boolean;
+    fromMemoryCache: boolean;
+    fromPrefetchCache: boolean;
+    /** @type {LightriderStatistics|undefined} Extra timing information available only when run in Lightrider. */
+    lrStatistics: LightriderStatistics | undefined;
+    finished: boolean;
+    requestMethod: string;
+    statusCode: number;
+    /** @type {NetworkRequest|undefined} The network request that redirected to this one */
+    redirectSource: NetworkRequest | undefined;
+    /** @type {NetworkRequest|undefined} The network request that this one redirected to */
+    redirectDestination: NetworkRequest | undefined;
+    /** @type {NetworkRequest[]|undefined} The chain of network requests that redirected to this one */
+    redirects: NetworkRequest[] | undefined;
+    failed: boolean;
+    localizedFailDescription: string;
+    /** @type {LH.Crdp.Network.Initiator} */
+    initiator: LH.Crdp.Network.Initiator;
+    /** @type {LH.Crdp.Network.ResourceTiming|undefined} */
+    timing: LH.Crdp.Network.ResourceTiming | undefined;
+    /** @type {LH.Crdp.Network.ResourceType|undefined} */
+    resourceType: LH.Crdp.Network.ResourceType | undefined;
+    mimeType: string;
+    /** @type {LH.Crdp.Network.ResourcePriority} */
+    priority: LH.Crdp.Network.ResourcePriority;
+    /** @type {NetworkRequest|undefined} */
+    initiatorRequest: NetworkRequest | undefined;
+    /** @type {HeaderEntry[]} */
+    responseHeaders: HeaderEntry[];
+    /** @type {string} */
+    responseHeadersText: string;
+    fetchedViaServiceWorker: boolean;
+    /** @type {string|undefined} */
+    frameId: string | undefined;
+    /**
+     * @type {string|undefined}
+     * Only set for child targets (OOPIFs). This is the sessionId of the protocol connection on
+     * which this request was discovered. `undefined` means it came from the root.
+     */
+    sessionId: string | undefined;
+    isLinkPreload: boolean;
+    /**
+     * @return {boolean}
+     */
+    hasErrorStatusCode(): boolean;
+    /**
+     * @param {NetworkRequest} initiatorRequest
+     */
+    setInitiatorRequest(initiatorRequest: NetworkRequest): void;
+    /**
+     * @param {LH.Crdp.Network.RequestWillBeSentEvent} data
+     */
+    onRequestWillBeSent(data: LH.Crdp.Network.RequestWillBeSentEvent): void;
+    onRequestServedFromCache(): void;
+    /**
+     * @param {LH.Crdp.Network.ResponseReceivedEvent} data
+     */
+    onResponseReceived(data: LH.Crdp.Network.ResponseReceivedEvent): void;
+    /**
+     * @param {LH.Crdp.Network.DataReceivedEvent} data
+     */
+    onDataReceived(data: LH.Crdp.Network.DataReceivedEvent): void;
+    /**
+     * @param {LH.Crdp.Network.LoadingFinishedEvent} data
+     */
+    onLoadingFinished(data: LH.Crdp.Network.LoadingFinishedEvent): void;
+    /**
+     * @param {LH.Crdp.Network.LoadingFailedEvent} data
+     */
+    onLoadingFailed(data: LH.Crdp.Network.LoadingFailedEvent): void;
+    /**
+     * @param {LH.Crdp.Network.ResourceChangedPriorityEvent} data
+     */
+    onResourceChangedPriority(data: LH.Crdp.Network.ResourceChangedPriorityEvent): void;
+    /**
+     * @param {LH.Crdp.Network.RequestWillBeSentEvent} data
+     */
+    onRedirectResponse(data: LH.Crdp.Network.RequestWillBeSentEvent): void;
+    /**
+     * @param {string=} sessionId
+     */
+    setSession(sessionId?: string | undefined): void;
+    /**
+     * @param {LH.Crdp.Network.Response} response
+     * @param {number} timestamp in seconds
+     * @param {LH.Crdp.Network.ResponseReceivedEvent['type']=} resourceType
+     */
+    _onResponse(response: LH.Crdp.Network.Response, timestamp: number, resourceType?: LH.Crdp.Network.ResponseReceivedEvent['type'] | undefined): void;
+    /**
+     * Resolve differences between conflicting timing signals. Based on the property setters in DevTools.
+     * @see https://github.com/ChromeDevTools/devtools-frontend/blob/56a99365197b85c24b732ac92b0ac70feed80179/front_end/sdk/NetworkRequest.js#L485-L502
+     * @param {LH.Crdp.Network.ResourceTiming} timing
+     */
+    _recomputeTimesWithResourceTiming(timing: LH.Crdp.Network.ResourceTiming): void;
+    /**
+     * Update responseReceivedTime to the endTime if endTime is earlier.
+     * A response can't be received after the entire request finished.
+     */
+    _updateResponseReceivedTimeIfNecessary(): void;
+    /**
+     * LR loses transfer size information, but passes it in the 'X-TotalFetchedSize' header.
+     * 'X-TotalFetchedSize' is the canonical transfer size in LR. Nothing should supersede it.
+     *
+     * The total length of the encoded data is spread out among multiple events. The sum of the
+     * values in onResponseReceived and all the onDataReceived events typically equals the value
+     * seen on the onLoadingFinished event. In <1% of cases we see the values differ. As we process
+     * onResponseReceived and onDataReceived we accumulate the total encodedDataLength. When we
+     * process onLoadingFinished, we override the accumulated total. We do this so that if the
+     * request is aborted or fails, we still get a value via the accumulation.
+     *
+     * In Lightrider, due to instrumentation limitations, our values for encodedDataLength are bogus
+     * and not valid. However the resource's true encodedDataLength/transferSize is shared via a
+     * special response header, X-TotalFetchedSize. In this situation, we read this value from
+     * responseReceived, use it for the transferSize and ignore the encodedDataLength values in
+     * both dataReceived and loadingFinished.
+     */
+    _updateTransferSizeForLightrider(): void;
+    /**
+     * LR loses protocol information.
+     */
+    _updateProtocolForLightrider(): void;
+    /**
+     * LR gets additional, accurate timing information from its underlying fetch infrastructure.  This
+     * is passed in via X-Headers similar to 'X-TotalFetchedSize'.
+     */
+    _updateTimingsForLightrider(): void;
+}
+export namespace NetworkRequest {
+    export { HEADER_TCP };
+    export { HEADER_SSL };
+    export { HEADER_REQ };
+    export { HEADER_RES };
+    export { HEADER_TOTAL };
+    export { HEADER_FETCHED_SIZE };
+    export { HEADER_PROTOCOL_IS_H2 };
+}
+import * as LH from "../../types/lh.js";
+declare const HEADER_TCP: "X-TCPMs";
+declare const HEADER_SSL: "X-SSLMs";
+declare const HEADER_REQ: "X-RequestMs";
+declare const HEADER_RES: "X-ResponseMs";
+declare const HEADER_TOTAL: "X-TotalMs";
+declare const HEADER_FETCHED_SIZE: "X-TotalFetchedSize";
+declare const HEADER_PROTOCOL_IS_H2: "X-ProtocolIsH2";
+export {};
+//# sourceMappingURL=network-request.d.ts.map

package/core/lib/network-request.js

@@ -52,6 +52,7 @@
       Trace: ResourceFinish.ts
  */
 
+import * as LH from '../../types/lh.js';
 import UrlUtils from './url-utils.js';
 
 // Lightrider X-Header names for timing information.

package/core/lib/page-functions.d.ts

@@ -0,0 +1,149 @@
+export namespace pageFunctions {
+    export { wrapRuntimeEvalErrorInBrowser };
+    export { getElementsInDocument };
+    export { getOuterHTMLSnippet };
+    export { computeBenchmarkIndex };
+    export { getNodeDetails };
+    export { getNodePath };
+    export { getNodeSelector };
+    export { getNodeLabel };
+    export { isPositionFixed };
+    export { wrapRequestIdleCallback };
+    export { getBoundingClientRect };
+}
+/**
+ * `typed-query-selector`'s CSS selector parser.
+ */
+export type ParseSelector<T extends string> = import('typed-query-selector/parser').ParseSelector<T>;
+/**
+ * @license Copyright 2018 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.
+ */
+/**
+ * @fileoverview
+ * Helper functions that are passed by `toString()` by Driver to be evaluated in target page.
+ *
+ * Every function in this module only runs in the browser, so it is ignored from
+ * the c8 code coverage tool. See c8.sh
+ *
+ * Important: this module should only be imported like this:
+ *     const pageFunctions = require('...');
+ * Never like this:
+ *     const {justWhatINeed} = require('...');
+ * Otherwise, minification will mangle the variable names and break usage.
+ */
+/**
+ * `typed-query-selector`'s CSS selector parser.
+ * @template {string} T
+ * @typedef {import('typed-query-selector/parser').ParseSelector<T>} ParseSelector
+ */
+/**
+ * The `exceptionDetails` provided by the debugger protocol does not contain the useful
+ * information such as name, message, and stack trace of the error when it's wrapped in a
+ * promise. Instead, map to a successful object that contains this information.
+ * @param {string|Error} [err] The error to convert
+ * @return {{__failedInBrowser: boolean, name: string, message: string, stack: string|undefined}}
+ */
+declare function wrapRuntimeEvalErrorInBrowser(err?: string | Error | undefined): {
+    __failedInBrowser: boolean;
+    name: string;
+    message: string;
+    stack: string | undefined;
+};
+/**
+ * @template {string} T
+ * @param {T} selector Optional simple CSS selector to filter nodes on.
+ *     Combinators are not supported.
+ * @return {Array<ParseSelector<T>>}
+ */
+declare function getElementsInDocument<T extends string>(selector: T): import("typed-query-selector/parser").ParseSelector<T, Element>[];
+/**
+ * Gets the opening tag text of the given node.
+ * @param {Element|ShadowRoot} element
+ * @param {Array<string>=} ignoreAttrs An optional array of attribute tags to not include in the HTML snippet.
+ * @return {string}
+ */
+declare function getOuterHTMLSnippet(element: Element | ShadowRoot, ignoreAttrs?: Array<string> | undefined, snippetCharacterLimit?: number): string;
+/**
+ * Computes a memory/CPU performance benchmark index to determine rough device class.
+ * @see https://github.com/GoogleChrome/lighthouse/issues/9085
+ * @see https://docs.google.com/spreadsheets/d/1E0gZwKsxegudkjJl8Fki_sOwHKpqgXwt8aBAfuUaB8A/edit?usp=sharing
+ *
+ * Historically (until LH 6.3), this benchmark created a string of length 100,000 in a loop, and returned
+ * the number of times per second the string can be created.
+ *
+ * Changes to v8 in 8.6.106 changed this number and also made Chrome more variable w.r.t GC interupts.
+ * This benchmark now is a hybrid of a similar GC-heavy approach to the original benchmark and an array
+ * copy benchmark.
+ *
+ * As of Chrome m86...
+ *
+ *  - 1000+ is a desktop-class device, Core i3 PC, iPhone X, etc
+ *  - 800+ is a high-end Android phone, Galaxy S8, low-end Chromebook, etc
+ *  - 125+ is a mid-tier Android phone, Moto G4, etc
+ *  - <125 is a budget Android phone, Alcatel Ideal, Galaxy J2, etc
+ * @return {number}
+ */
+declare function computeBenchmarkIndex(): number;
+/**
+ * @param {Element|ShadowRoot} element
+ * @return {LH.Artifacts.NodeDetails}
+ */
+declare function getNodeDetails(element: Element | ShadowRoot): LH.Artifacts.NodeDetails;
+declare namespace getNodeDetails {
+    function toString(): string;
+}
+/**
+ * Adapted from DevTools' SDK.DOMNode.prototype.path
+ *   https://github.com/ChromeDevTools/devtools-frontend/blob/4fff931bb/front_end/sdk/DOMModel.js#L625-L647
+ * Backend: https://source.chromium.org/search?q=f:node.cc%20symbol:PrintNodePathTo&sq=&ss=chromium%2Fchromium%2Fsrc
+ *
+ * TODO: DevTools nodePath handling doesn't support iframes, but probably could. https://crbug.com/1127635
+ * @param {Node} node
+ * @return {string}
+ */
+declare function getNodePath(node: Node): string;
+/**
+ * @param {Element} element
+ * @return {string}
+ *
+ * Note: CSS Selectors having no standard mechanism to describe shadow DOM piercing. So we can't.
+ *
+ * If the node resides within shadow DOM, the selector *only* starts from the shadow root.
+ * For example, consider this img within a <section> within a shadow root..
+ *  - DOM: <html> <body> <div> #shadow-root <section> <img/>
+ *  - nodePath: 0,HTML,1,BODY,1,DIV,a,#document-fragment,0,SECTION,0,IMG
+ *  - nodeSelector: section > img
+ */
+declare function getNodeSelector(element: Element): string;
+/**
+ * Generate a human-readable label for the given element, based on end-user facing
+ * strings like the innerText or alt attribute.
+ * Returns label string or null if no useful label is found.
+ * @param {Element} element
+ * @return {string | null}
+ */
+declare function getNodeLabel(element: Element): string | null;
+/**
+ * This function checks if an element or an ancestor of an element is `position:fixed`.
+ * In addition we ensure that the element is capable of behaving as a `position:fixed`
+ * element, checking that it lives within a scrollable ancestor.
+ * @param {HTMLElement} element
+ * @return {boolean}
+ */
+declare function isPositionFixed(element: HTMLElement): boolean;
+/**
+ * RequestIdleCallback shim that calculates the remaining deadline time in order to avoid a potential lighthouse
+ * penalty for tests run with simulated throttling. Reduces the deadline time to (50 - safetyAllowance) / cpuSlowdownMultiplier to
+ * ensure a long task is very unlikely if using the API correctly.
+ * @param {number} cpuSlowdownMultiplier
+ */
+declare function wrapRequestIdleCallback(cpuSlowdownMultiplier: number): void;
+/**
+ * @param {Element} element
+ * @return {LH.Artifacts.Rect}
+ */
+declare function getBoundingClientRect(element: Element): LH.Artifacts.Rect;
+export {};
+//# sourceMappingURL=page-functions.d.ts.map

package/core/lib/proto-preprocessor.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @fileoverview Helper functions to transform an LHR into a proto-ready LHR.
+ *
+ * FIXME: This file is 100% technical debt.  Our eventual goal is for the
+ * roundtrip JSON to match the Golden LHR 1:1.
+ */
+/**
+ * Transform an LHR into a proto-friendly, mostly-compatible LHR.
+ * @param {LH.Result} lhr
+ * @return {LH.Result}
+ */
+export function processForProto(lhr: LH.Result): LH.Result;
+//# sourceMappingURL=proto-preprocessor.d.ts.map