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

package/core/computed/metrics/total-blocking-time.d.ts

@@ -0,0 +1,23 @@
+export { TotalBlockingTimeComputed as TotalBlockingTime };
+declare const TotalBlockingTimeComputed: typeof TotalBlockingTime & {
+    request: (dependencies: import("../../index.js").Artifacts.MetricComputationDataInput, context: import("../../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../../index.js").Artifacts.Metric | import("../../index.js").Artifacts.LanternMetric>;
+};
+/**
+ * @fileoverview This audit determines Total Blocking Time.
+
+ * We define Blocking Time as any time interval in the loading timeline where task length exceeds
+ * 50ms. For example, if there is a 110ms main thread task, the last 60ms of it is blocking time.
+ * Total Blocking Time is the sum of all Blocking Time between First Contentful Paint and
+ * Interactive Time (TTI).
+ *
+ * This is a new metric designed to accompany Time to Interactive. TTI is strict and does not
+ * reflect incremental improvements to the site performance unless the improvement concerns the last
+ * long task. Total Blocking Time on the other hand is designed to be much more responsive
+ * to smaller improvements to main thread responsiveness.
+ */
+declare class TotalBlockingTime extends ComputedMetric {
+}
+import ComputedMetric from "./metric.js";
+//# sourceMappingURL=total-blocking-time.d.ts.map

package/core/computed/module-duplication.d.ts

@@ -0,0 +1,37 @@
+export { ModuleDuplicationComputed as ModuleDuplication };
+declare const ModuleDuplicationComputed: typeof ModuleDuplication & {
+    request: (dependencies: Pick<import("../index.js").Artifacts, "Scripts" | "SourceMaps">, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<Map<string, {
+        scriptId: string;
+        scriptUrl: string;
+        resourceSize: number;
+    }[]>>;
+};
+declare class ModuleDuplication {
+    /**
+     * @param {string} source
+     */
+    static normalizeSource(source: string): string;
+    /**
+     * @param {string} source
+     */
+    static _shouldIgnoreSource(source: string): boolean;
+    /**
+     * @param {Map<string, Array<{scriptId: string, resourceSize: number}>>} moduleNameToSourceData
+     */
+    static _normalizeAggregatedData(moduleNameToSourceData: Map<string, Array<{
+        scriptId: string;
+        resourceSize: number;
+    }>>): void;
+    /**
+     * @param {Pick<LH.Artifacts, 'Scripts'|'SourceMaps'>} artifacts
+     * @param {LH.Artifacts.ComputedContext} context
+     */
+    static compute_(artifacts: Pick<LH.Artifacts, 'Scripts' | 'SourceMaps'>, context: LH.Artifacts.ComputedContext): Promise<Map<string, {
+        scriptId: string;
+        scriptUrl: string;
+        resourceSize: number;
+    }[]>>;
+}
+//# sourceMappingURL=module-duplication.d.ts.map

package/core/computed/network-analysis.d.ts

@@ -0,0 +1,20 @@
+export { NetworkAnalysisComputed as NetworkAnalysis };
+declare const NetworkAnalysisComputed: typeof NetworkAnalysis & {
+    request: (dependencies: import("../index.js").DevtoolsLog, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../index.js").Artifacts.NetworkAnalysis>;
+};
+declare class NetworkAnalysis {
+    /**
+     * @param {Array<LH.Artifacts.NetworkRequest>} records
+     * @return {LH.Util.StrictOmit<LH.Artifacts.NetworkAnalysis, 'throughput'>}
+     */
+    static computeRTTAndServerResponseTime(records: Array<LH.Artifacts.NetworkRequest>): LH.Util.StrictOmit<LH.Artifacts.NetworkAnalysis, 'throughput'>;
+    /**
+     * @param {LH.DevtoolsLog} devtoolsLog
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.NetworkAnalysis>}
+     */
+    static compute_(devtoolsLog: import("../index.js").DevtoolsLog, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.NetworkAnalysis>;
+}
+//# sourceMappingURL=network-analysis.d.ts.map

package/core/computed/network-records.d.ts

@@ -0,0 +1,15 @@
+export { NetworkRecordsComputed as NetworkRecords };
+declare const NetworkRecordsComputed: typeof NetworkRecords & {
+    request: (dependencies: LH.DevtoolsLog, context: LH.Util.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../lib/network-request.js").NetworkRequest[]>;
+};
+declare class NetworkRecords {
+    /**
+     * @param {LH.DevtoolsLog} devtoolsLog
+     * @return {Promise<Array<LH.Artifacts.NetworkRequest>>} networkRecords
+     */
+    static compute_(devtoolsLog: LH.DevtoolsLog): Promise<Array<LH.Artifacts.NetworkRequest>>;
+}
+import * as LH from "../../types/lh.js";
+//# sourceMappingURL=network-records.d.ts.map

package/core/computed/network-records.js

@@ -4,6 +4,7 @@
  * 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';
 import {makeComputedArtifact} from './computed-artifact.js';
 import {NetworkRecorder} from '../lib/network-recorder.js';
 

package/core/computed/page-dependency-graph.d.ts

@@ -0,0 +1,88 @@
+export { PageDependencyGraphComputed as PageDependencyGraph };
+export type Node = import('../lib/dependency-graph/base-node.js').Node;
+export type URLArtifact = Omit<LH.Artifacts['URL'], 'finalDisplayedUrl'>;
+export type NetworkNodeOutput = {
+    nodes: Array<NetworkNode>;
+    idToNodeMap: Map<string, NetworkNode>;
+    urlToNodeMap: Map<string, Array<NetworkNode>>;
+    frameIdToNodeMap: Map<string, NetworkNode | null>;
+};
+declare const PageDependencyGraphComputed: typeof PageDependencyGraph & {
+    request: (dependencies: {
+        trace: LH.Trace;
+        devtoolsLog: import("../index.js").DevtoolsLog;
+        URL: LH.Artifacts['URL'];
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../lib/dependency-graph/base-node.js").Node>;
+};
+import { NetworkNode } from "../lib/dependency-graph/network-node.js";
+declare class PageDependencyGraph {
+    /**
+     * @param {LH.Artifacts.NetworkRequest} record
+     * @return {Array<string>}
+     */
+    static getNetworkInitiators(record: LH.Artifacts.NetworkRequest): Array<string>;
+    /**
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @return {NetworkNodeOutput}
+     */
+    static getNetworkNodeOutput(networkRecords: Array<LH.Artifacts.NetworkRequest>): NetworkNodeOutput;
+    /**
+     * @param {LH.Artifacts.ProcessedTrace} processedTrace
+     * @return {Array<CPUNode>}
+     */
+    static getCPUNodes({ mainThreadEvents }: LH.Artifacts.ProcessedTrace): Array<CPUNode>;
+    /**
+     * @param {NetworkNode} rootNode
+     * @param {NetworkNodeOutput} networkNodeOutput
+     */
+    static linkNetworkNodes(rootNode: NetworkNode, networkNodeOutput: NetworkNodeOutput): void;
+    /**
+     * @param {Node} rootNode
+     * @param {NetworkNodeOutput} networkNodeOutput
+     * @param {Array<CPUNode>} cpuNodes
+     */
+    static linkCPUNodes(rootNode: Node, networkNodeOutput: NetworkNodeOutput, cpuNodes: Array<CPUNode>): void;
+    /**
+     * Removes the given node from the graph, but retains all paths between its dependencies and
+     * dependents.
+     * @param {Node} node
+     */
+    static _pruneNode(node: Node): void;
+    /**
+     * @param {LH.Artifacts.ProcessedTrace} processedTrace
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {URLArtifact} URL
+     * @return {Node}
+     */
+    static createGraph(processedTrace: LH.Artifacts.ProcessedTrace, networkRecords: Array<LH.Artifacts.NetworkRequest>, URL: URLArtifact): Node;
+    /**
+     *
+     * @param {Node} rootNode
+     */
+    static printGraph(rootNode: Node, widthInCharacters?: number): void;
+    /**
+     * Recalculate `artifacts.URL` for clients that don't provide it.
+     *
+     * @param {LH.DevtoolsLog} devtoolsLog
+     * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+     * @param {LH.Artifacts.ProcessedTrace} processedTrace
+     * @return {URLArtifact}
+     */
+    static getDocumentUrls(devtoolsLog: import("../index.js").DevtoolsLog, networkRecords: LH.Artifacts.NetworkRequest[], processedTrace: LH.Artifacts.ProcessedTrace): URLArtifact;
+    /**
+     * @param {{trace: LH.Trace, devtoolsLog: LH.DevtoolsLog, URL: LH.Artifacts['URL']}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<Node>}
+     */
+    static compute_(data: {
+        trace: LH.Trace;
+        devtoolsLog: import("../index.js").DevtoolsLog;
+        URL: LH.Artifacts['URL'];
+    }, context: LH.Artifacts.ComputedContext): Promise<Node>;
+}
+import { NetworkRequest } from "../lib/network-request.js";
+import { ProcessedTrace } from "./processed-trace.js";
+import { CPUNode } from "../lib/dependency-graph/cpu-node.js";
+//# sourceMappingURL=page-dependency-graph.d.ts.map

package/core/computed/processed-navigation.d.ts

@@ -0,0 +1,15 @@
+export { ProcessedNavigationComputed as ProcessedNavigation };
+declare const ProcessedNavigationComputed: typeof ProcessedNavigation & {
+    request: (dependencies: import("../index.js").Trace, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../index.js").Artifacts.ProcessedNavigation>;
+};
+declare class ProcessedNavigation {
+    /**
+       * @param {LH.Trace} trace
+       * @param {LH.Artifacts.ComputedContext} context
+       * @return {Promise<LH.Artifacts.ProcessedNavigation>}
+      */
+    static compute_(trace: LH.Trace, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.ProcessedNavigation>;
+}
+//# sourceMappingURL=processed-navigation.d.ts.map

package/core/computed/processed-trace.d.ts

@@ -0,0 +1,14 @@
+export { ProcessedTraceComputed as ProcessedTrace };
+declare const ProcessedTraceComputed: typeof ProcessedTrace & {
+    request: (dependencies: import("../index.js").Trace, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../index.js").Artifacts.ProcessedTrace>;
+};
+declare class ProcessedTrace {
+    /**
+      * @param {LH.Trace} trace
+      * @return {Promise<LH.Artifacts.ProcessedTrace>}
+     */
+    static compute_(trace: LH.Trace): Promise<LH.Artifacts.ProcessedTrace>;
+}
+//# sourceMappingURL=processed-trace.d.ts.map

package/core/computed/resource-summary.d.ts

@@ -0,0 +1,44 @@
+export { ResourceSummaryComputed as ResourceSummary };
+export type ResourceEntry = {
+    count: number;
+    resourceSize: number;
+    transferSize: number;
+};
+declare const ResourceSummaryComputed: typeof ResourceSummary & {
+    request: (dependencies: {
+        URL: LH.Artifacts['URL'];
+        devtoolsLog: import("../index.js").DevtoolsLog;
+        budgets: LH.Util.ImmutableObject<LH.Budget[] | null>;
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<Record<import("../../types/lhr/budget.js").default.ResourceType, ResourceEntry>>;
+};
+/** @typedef {{count: number, resourceSize: number, transferSize: number}} ResourceEntry */
+declare class ResourceSummary {
+    /**
+     * @param {LH.Artifacts.NetworkRequest} record
+     * @return {LH.Budget.ResourceType}
+     */
+    static determineResourceType(record: LH.Artifacts.NetworkRequest): LH.Budget.ResourceType;
+    /**
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {LH.Artifacts.URL} URLArtifact
+     * @param {LH.Util.ImmutableObject<LH.Budget[]|null>} budgets
+     * @return {Record<LH.Budget.ResourceType, ResourceEntry>}
+     */
+    static summarize(networkRecords: Array<LH.Artifacts.NetworkRequest>, URLArtifact: LH.Artifacts.URL, budgets: LH.Util.ImmutableObject<LH.Budget[] | null>): Record<LH.Budget.ResourceType, ResourceEntry>;
+    /**
+     * @param {{URL: LH.Artifacts['URL'], devtoolsLog: LH.DevtoolsLog, budgets: LH.Util.ImmutableObject<LH.Budget[]|null>}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<Record<LH.Budget.ResourceType,ResourceEntry>>}
+     */
+    static compute_(data: {
+        URL: LH.Artifacts['URL'];
+        devtoolsLog: import("../index.js").DevtoolsLog;
+        budgets: LH.Util.ImmutableObject<LH.Budget[] | null>;
+    }, context: LH.Artifacts.ComputedContext): Promise<Record<LH.Budget.ResourceType, ResourceEntry>>;
+}
+import { Util } from "../util.cjs";
+import { Budget } from "../config/budget.js";
+import { NetworkRequest } from "../lib/network-request.js";
+//# sourceMappingURL=resource-summary.d.ts.map

package/core/computed/screenshots.d.ts

@@ -0,0 +1,20 @@
+export { ScreenshotsComputed as Screenshots };
+declare const ScreenshotsComputed: typeof Screenshots & {
+    request: (dependencies: import("../index.js").Trace, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<{
+        timestamp: number;
+        datauri: string;
+    }[]>;
+};
+declare class Screenshots {
+    /**
+     * @param {LH.Trace} trace
+     * @return {Promise<Array<{timestamp: number, datauri: string}>>}
+    */
+    static compute_(trace: LH.Trace): Promise<Array<{
+        timestamp: number;
+        datauri: string;
+    }>>;
+}
+//# sourceMappingURL=screenshots.d.ts.map

package/core/computed/speedline.d.ts

@@ -0,0 +1,15 @@
+export { SpeedlineComputed as Speedline };
+declare const SpeedlineComputed: typeof Speedline & {
+    request: (dependencies: import("../index.js").Trace, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../index.js").Artifacts.Speedline>;
+};
+declare class Speedline {
+    /**
+     * @param {LH.Trace} trace
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Artifacts.Speedline>}
+     */
+    static compute_(trace: LH.Trace, context: LH.Artifacts.ComputedContext): Promise<LH.Artifacts.Speedline>;
+}
+//# sourceMappingURL=speedline.d.ts.map

package/core/computed/unused-css.d.ts

@@ -0,0 +1,62 @@
+export { UnusedCSSComputed as UnusedCSS };
+export type StyleSheetInfo = LH.Artifacts.CSSStyleSheetInfo & {
+    networkRecord: LH.Artifacts.NetworkRequest;
+    usedRules: Array<LH.Crdp.CSS.RuleUsage>;
+};
+declare const UnusedCSSComputed: typeof UnusedCSS & {
+    request: (dependencies: {
+        CSSUsage: LH.Artifacts['CSSUsage'];
+        devtoolsLog: import("../index.js").DevtoolsLog;
+    }, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<import("../../types/audit.js").default.ByteEfficiencyItem[]>;
+};
+/** @typedef {LH.Artifacts.CSSStyleSheetInfo & {networkRecord: LH.Artifacts.NetworkRequest, usedRules: Array<LH.Crdp.CSS.RuleUsage>}} StyleSheetInfo */
+declare class UnusedCSS {
+    /**
+     * @param {Array<LH.Artifacts.CSSStyleSheetInfo>} styles The output of the Styles gatherer.
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @return {Object<string, StyleSheetInfo>} A map of styleSheetId to stylesheet information.
+     */
+    static indexStylesheetsById(styles: Array<LH.Artifacts.CSSStyleSheetInfo>, networkRecords: Array<LH.Artifacts.NetworkRequest>): {
+        [x: string]: StyleSheetInfo;
+    };
+    /**
+     * Adds used rules to their corresponding stylesheet.
+     * @param {Array<LH.Crdp.CSS.RuleUsage>} rules The output of the CSSUsage gatherer.
+     * @param {Object<string, StyleSheetInfo>} indexedStylesheets Stylesheet information indexed by id.
+     */
+    static indexUsedRules(rules: Array<LH.Crdp.CSS.RuleUsage>, indexedStylesheets: {
+        [x: string]: StyleSheetInfo;
+    }): void;
+    /**
+     * @param {StyleSheetInfo} stylesheetInfo
+     * @return {{wastedBytes: number, totalBytes: number, wastedPercent: number}}
+     */
+    static computeUsage(stylesheetInfo: StyleSheetInfo): {
+        wastedBytes: number;
+        totalBytes: number;
+        wastedPercent: number;
+    };
+    /**
+     * Trims stylesheet content down to the first rule-set definition.
+     * @param {string=} content
+     * @return {string}
+     */
+    static determineContentPreview(content?: string | undefined): string;
+    /**
+     * @param {StyleSheetInfo} stylesheetInfo The stylesheetInfo object.
+     * @return {LH.Audit.ByteEfficiencyItem}
+     */
+    static mapSheetToResult(stylesheetInfo: StyleSheetInfo): LH.Audit.ByteEfficiencyItem;
+    /**
+     * @param {{CSSUsage: LH.Artifacts['CSSUsage'], devtoolsLog: LH.DevtoolsLog}} data
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<LH.Audit.ByteEfficiencyItem[]>}
+    */
+    static compute_(data: {
+        CSSUsage: LH.Artifacts['CSSUsage'];
+        devtoolsLog: import("../index.js").DevtoolsLog;
+    }, context: LH.Artifacts.ComputedContext): Promise<LH.Audit.ByteEfficiencyItem[]>;
+}
+//# sourceMappingURL=unused-css.d.ts.map

package/core/computed/unused-javascript-summary.d.ts

@@ -0,0 +1,71 @@
+export { UnusedJavascriptSummaryComputed as UnusedJavascriptSummary };
+export type WasteData = {
+    unusedByIndex: Uint8Array;
+    unusedLength: number;
+    contentLength: number;
+};
+export type ComputeInput = {
+    scriptId: string;
+    scriptCoverage: Omit<LH.Crdp.Profiler.ScriptCoverage, 'url'>;
+    bundle?: LH.Artifacts.Bundle | undefined;
+};
+export type Summary = {
+    scriptId: string;
+    wastedBytes: number;
+    totalBytes: number;
+    wastedPercent?: number | undefined;
+    /**
+     * Keyed by file name. Includes (unmapped) key too.
+     */
+    sourcesWastedBytes?: Record<string, number> | undefined;
+};
+declare const UnusedJavascriptSummaryComputed: typeof UnusedJavascriptSummary & {
+    request: (dependencies: ComputeInput, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<Summary>;
+};
+/**
+ * @typedef WasteData
+ * @property {Uint8Array} unusedByIndex
+ * @property {number} unusedLength
+ * @property {number} contentLength
+ */
+/**
+ * @typedef ComputeInput
+ * @property {string} scriptId
+ * @property {Omit<LH.Crdp.Profiler.ScriptCoverage, 'url'>} scriptCoverage
+ * @property {LH.Artifacts.Bundle=} bundle
+ */
+/**
+ * @typedef Summary
+ * @property {string} scriptId
+ * @property {number} wastedBytes
+ * @property {number} totalBytes
+ * @property {number} wastedBytes
+ * @property {number=} wastedPercent
+ * @property {Record<string, number>=} sourcesWastedBytes Keyed by file name. Includes (unmapped) key too.
+ */
+declare class UnusedJavascriptSummary {
+    /**
+     * @param {Omit<LH.Crdp.Profiler.ScriptCoverage, 'url'>} scriptCoverage
+     * @return {WasteData}
+     */
+    static computeWaste(scriptCoverage: Omit<LH.Crdp.Profiler.ScriptCoverage, 'url'>): WasteData;
+    /**
+     * @param {string} scriptId
+     * @param {WasteData} wasteData
+     * @return {Summary}
+     */
+    static createItem(scriptId: string, wasteData: WasteData): Summary;
+    /**
+     * @param {WasteData} wasteData
+     * @param {LH.Artifacts.Bundle} bundle
+     */
+    static createSourceWastedBytes(wasteData: WasteData, bundle: LH.Artifacts.Bundle): Record<string, number> | undefined;
+    /**
+     * @param {ComputeInput} data
+     * @return {Promise<Summary>}
+     */
+    static compute_(data: ComputeInput): Promise<Summary>;
+}
+//# sourceMappingURL=unused-javascript-summary.d.ts.map

package/core/computed/user-timings.d.ts

@@ -0,0 +1,31 @@
+export { UserTimingsComputed as UserTimings };
+export type MarkEvent = {
+    name: string;
+    isMark: true;
+    args: LH.TraceEvent['args'];
+    startTime: number;
+};
+export type MeasureEvent = {
+    name: string;
+    isMark: false;
+    args: LH.TraceEvent['args'];
+    startTime: number;
+    endTime: number;
+    duration: number;
+};
+declare const UserTimingsComputed: typeof UserTimings & {
+    request: (dependencies: import("../index.js").Trace, context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<(MarkEvent | MeasureEvent)[]>;
+};
+/** @typedef {{name: string, isMark: true, args: LH.TraceEvent['args'], startTime: number}} MarkEvent */
+/** @typedef {{name: string, isMark: false, args: LH.TraceEvent['args'], startTime: number, endTime: number, duration: number}} MeasureEvent */
+declare class UserTimings {
+    /**
+     * @param {LH.Trace} trace
+     * @param {LH.Artifacts.ComputedContext} context
+     * @return {Promise<Array<MarkEvent|MeasureEvent>>}
+     */
+    static compute_(trace: LH.Trace, context: LH.Artifacts.ComputedContext): Promise<Array<MarkEvent | MeasureEvent>>;
+}
+//# sourceMappingURL=user-timings.d.ts.map

package/core/computed/viewport-meta.d.ts

@@ -0,0 +1,35 @@
+export { ViewportMetaComputed as ViewportMeta };
+export type ViewportMetaResult = {
+    /**
+     * Whether the page has any viewport tag.
+     */
+    hasViewportTag: boolean;
+    /**
+     * Whether the viewport tag is optimized for mobile screens.
+     */
+    isMobileOptimized: boolean;
+    /**
+     * Warnings if the parser encountered invalid content in the viewport tag.
+     */
+    parserWarnings: Array<string>;
+};
+declare const ViewportMetaComputed: typeof ViewportMeta & {
+    request: (dependencies: {
+        name?: string | undefined;
+        content?: string | undefined;
+        property?: string | undefined;
+        httpEquiv?: string | undefined;
+        charset?: string | undefined;
+        node: import("../index.js").Artifacts.NodeDetails;
+    }[], context: import("../../types/utility-types.js").default.ImmutableObject<{
+        computedCache: Map<string, import("../lib/arbitrary-equality-map.js").ArbitraryEqualityMap>;
+    }>) => Promise<ViewportMetaResult>;
+};
+declare class ViewportMeta {
+    /**
+     * @param {LH.GathererArtifacts['MetaElements']} MetaElements
+     * @return {Promise<ViewportMetaResult>}
+    */
+    static compute_(MetaElements: LH.GathererArtifacts['MetaElements']): Promise<ViewportMetaResult>;
+}
+//# sourceMappingURL=viewport-meta.d.ts.map

package/core/config/budget.d.ts

@@ -0,0 +1,74 @@
+export class Budget {
+    /**
+     * Asserts that obj has no own properties, throwing a nice error message if it does.
+     * `objectName` is included for nicer logging.
+     * @param {Record<string, unknown>} obj
+     * @param {string} objectName
+     */
+    static assertNoExcessProperties(obj: Record<string, unknown>, objectName: string): void;
+    /**
+     * Asserts that `strings` has no duplicate strings in it, throwing an error if
+     * it does. `arrayName` is included for nicer logging.
+     * @param {Array<string>} strings
+     * @param {string} arrayName
+     */
+    static assertNoDuplicateStrings(strings: Array<string>, arrayName: string): void;
+    /**
+     * @param {Record<string, unknown>} resourceBudget
+     * @return {LH.Budget.ResourceBudget}
+     */
+    static validateResourceBudget(resourceBudget: Record<string, unknown>): LH.Budget.ResourceBudget;
+    /**
+     * @param {unknown} path
+     * @param {string} error
+     */
+    static throwInvalidPathError(path: unknown, error: string): void;
+    /**
+     * Validates that path is either: a) undefined or ) properly formed.
+     * Verifies the quantity and location of the two robot.txt regex characters: $, *
+     * @param {unknown} path
+     * @return {undefined|string}
+     */
+    static validatePath(path: unknown): undefined | string;
+    /**
+     * Returns the budget that applies to a given URL.
+     * If multiple budgets match based on thier 'path' property,
+     * then the last-listed of those budgets is returned.
+     * @param {LH.Util.Immutable<Array<LH.Budget>>|null} budgets
+     * @param {string|undefined} url
+     * @return {LH.Util.Immutable<LH.Budget> | undefined} budget
+     */
+    static getMatchingBudget(budgets: LH.Util.Immutable<Array<LH.Budget>> | null, url: string | undefined): LH.Util.Immutable<LH.Budget> | undefined;
+    /**
+     * Determines whether a URL matches against a robots.txt-style "path".
+     * Pattern should use the robots.txt format. E.g. "/*-article.html" or "/". Reference:
+     * https://developers.google.com/search/reference/robots_txt#url-matching-based-on-path-values
+     * @param {string} url
+     * @param {string=} pattern
+     * @return {boolean}
+     */
+    static urlMatchesPattern(url: string, pattern?: string | undefined): boolean;
+    /**
+     * @param {Record<string, unknown>} timingBudget
+     * @return {LH.Budget.TimingBudget}
+     */
+    static validateTimingBudget(timingBudget: Record<string, unknown>): LH.Budget.TimingBudget;
+    /**
+     * @param {string} hostname
+     * @return {string}
+     */
+    static validateHostname(hostname: string): string;
+    /**
+     * @param {unknown} hostnames
+     * @return {undefined|Array<string>}
+     */
+    static validateHostnames(hostnames: unknown): undefined | Array<string>;
+    /**
+     * More info on the Budget format:
+     * https://github.com/GoogleChrome/lighthouse/issues/6053#issuecomment-428385930
+     * @param {unknown} budgetJson
+     * @return {Array<LH.Budget>}
+     */
+    static initializeBudget(budgetJson: unknown): Array<LH.Budget>;
+}
+//# sourceMappingURL=budget.d.ts.map