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

package/core/lib/cdt/Platform.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license Copyright 2021 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.
+ */
+/**
+ * @param {any[]} array
+ * @param {any} needle
+ * @param {any} comparator
+ */
+declare function lowerBound(array: any[], needle: any, comparator: any, left: any, right: any): any;
+/**
+ * @param {any[]} array
+ * @param {any} needle
+ * @param {any} comparator
+ */
+declare function upperBound(array: any[], needle: any, comparator: any, left: any, right: any): any;
+export namespace ArrayUtilities {
+    export { lowerBound };
+    export { upperBound };
+}
+export namespace DevToolsPath {
+    const EmptyUrlString: string;
+}
+export {};
+//# sourceMappingURL=Platform.d.ts.map

package/core/lib/cdt/SDK.d.ts

@@ -0,0 +1,2 @@
+export const TextSourceMap: typeof import("./generated/SourceMap.js");
+//# sourceMappingURL=SDK.d.ts.map

package/core/lib/cdt/generated/ParsedURL.d.ts

@@ -0,0 +1,28 @@
+export const __esModule: boolean;
+/**
+ * http://tools.ietf.org/html/rfc3986#section-5.2.4
+ */
+export function normalizePath(path: any): any;
+export class ParsedURL {
+    static concatenate(devToolsPath: any, ...appendage: any[]): any;
+    static beginsWithWindowsDriveLetter(url: any): boolean;
+    static beginsWithScheme(url: any): boolean;
+    static isRelativeURL(url: any): boolean;
+    static urlRegexInstance: null;
+    constructor(url: any);
+    isValid: boolean;
+    url: any;
+    scheme: any;
+    user: any;
+    host: any;
+    port: any;
+    path: any;
+    queryParams: any;
+    fragment: any;
+    folderPathComponents: any;
+    lastPathComponent: any;
+    blobInnerScheme: any;
+    get displayName(): any;
+    #private;
+}
+//# sourceMappingURL=ParsedURL.d.ts.map

package/core/lib/cdt/generated/SourceMap.d.ts

@@ -0,0 +1,100 @@
+export = TextSourceMap;
+declare class TextSourceMap {
+    /**
+     * Implements Source Map V3 model. See https://github.com/google/closure-compiler/wiki/Source-Maps
+     * for format description.
+     */
+    constructor(compiledURL: any, sourceMappingURL: any, payload: any, initiator: any);
+    compiledURL(): any;
+    url(): any;
+    sourceURLs(): any[];
+    embeddedContentByURL(sourceURL: any): any;
+    findEntry(lineNumber: any, columnNumber: any): {
+        lineNumber: number;
+        columnNumber: number;
+        sourceURL?: string | undefined;
+        sourceLineNumber: number;
+        sourceColumnNumber: number;
+        name?: string | undefined;
+        lastColumnNumber?: number | undefined;
+    } | null;
+    findEntryRanges(lineNumber: any, columnNumber: any): {
+        range: any;
+        sourceRange: any;
+        sourceURL: string;
+    } | null;
+    sourceLineMapping(sourceURL: any, lineNumber: any, columnNumber: any): {
+        lineNumber: number;
+        columnNumber: number;
+        sourceURL?: string | undefined;
+        sourceLineNumber: number;
+        sourceColumnNumber: number;
+        name?: string | undefined;
+        lastColumnNumber?: number | undefined;
+    } | null;
+    findReverseIndices(sourceURL: any, lineNumber: any, columnNumber: any): any;
+    findReverseEntries(sourceURL: any, lineNumber: any, columnNumber: any): any;
+    findReverseRanges(sourceURL: any, lineNumber: any, columnNumber: any): any[];
+    /** @return {Array<{lineNumber: number, columnNumber: number, sourceURL?: string, sourceLineNumber: number, sourceColumnNumber: number, name?: string, lastColumnNumber?: number}>} */
+    mappings(): Array<{
+        lineNumber: number;
+        columnNumber: number;
+        sourceURL?: string;
+        sourceLineNumber: number;
+        sourceColumnNumber: number;
+        name?: string;
+        lastColumnNumber?: number;
+    }>;
+    reversedMappings(sourceURL: any): any;
+    eachSection(callback: any): void;
+    parseSources(sourceMap: any): void;
+    parseMap(map: any, lineNumber: any, columnNumber: any): void;
+    isSeparator(char: any): boolean;
+    decodeVLQ(stringCharIterator: any): number;
+    reverseMapTextRange(url: any, textRange: any): any;
+    mapsOrigin(): boolean;
+    hasIgnoreListHint(sourceURL: any): any;
+    /**
+     * Returns a list of ranges in the generated script for original sources that
+     * match a predicate. Each range is a [begin, end) pair, meaning that code at
+     * the beginning location, up to but not including the end location, matches
+     * the predicate.
+     */
+    findRanges(predicate: any, options: any): any[];
+    #private;
+}
+declare namespace TextSourceMap {
+    export { __esModule, SourceMapV3, Section, Offset, SourceMapEntry, TextSourceMap };
+}
+declare const __esModule: boolean;
+declare class SourceMapV3 {
+    version: any;
+    file: any;
+    sources: any;
+    sections: any;
+    mappings: any;
+    sourceRoot: any;
+    names: any;
+    sourcesContent: any;
+    x_google_ignoreList: any;
+}
+declare class Section {
+    map: any;
+    offset: any;
+    url: any;
+}
+declare class Offset {
+    line: any;
+    column: any;
+}
+declare class SourceMapEntry {
+    static compare(entry1: any, entry2: any): number;
+    constructor(lineNumber: any, columnNumber: any, sourceURL: any, sourceLineNumber: any, sourceColumnNumber: any, name: any);
+    lineNumber: any;
+    columnNumber: any;
+    sourceURL: any;
+    sourceLineNumber: any;
+    sourceColumnNumber: any;
+    name: any;
+}
+//# sourceMappingURL=SourceMap.d.ts.map

package/core/lib/csp-evaluator.d.ts

@@ -0,0 +1,41 @@
+export type Finding = import('csp_evaluator/finding').Finding;
+/**
+ * @param {Finding} finding
+ * @return {LH.IcuMessage|string}
+ */
+export function getTranslatedDescription(finding: Finding): LH.IcuMessage | string;
+/**
+ * @param {string[]} rawCsps
+ * @return {{bypasses: Finding[], warnings: Finding[], syntax: Finding[][]}}
+ */
+export function evaluateRawCspsForXss(rawCsps: string[]): {
+    bypasses: Finding[];
+    warnings: Finding[];
+    syntax: Finding[][];
+};
+/**
+ * @param {string} rawCsp
+ */
+export function parseCsp(rawCsp: string): import("csp_evaluator/dist/csp.js").Csp;
+export namespace UIStrings {
+    const missingBaseUri: string;
+    const missingScriptSrc: string;
+    const missingObjectSrc: string;
+    const strictDynamic: string;
+    const unsafeInline: string;
+    const unsafeInlineFallback: string;
+    const allowlistFallback: string;
+    const reportToOnly: string;
+    const reportingDestinationMissing: string;
+    const nonceLength: string;
+    const nonceCharset: string;
+    const missingSemicolon: string;
+    const unknownDirective: string;
+    const unknownKeyword: string;
+    const deprecatedReflectedXSS: string;
+    const deprecatedReferrer: string;
+    const deprecatedDisownOpener: string;
+    const plainWildcards: string;
+    const plainUrlScheme: string;
+}
+//# sourceMappingURL=csp-evaluator.d.ts.map

package/core/lib/dependency-graph/base-node.d.ts

@@ -0,0 +1,161 @@
+/**
+ * A union of all types derived from BaseNode, allowing type check discrimination
+ * based on `node.type`. If a new node type is created, it should be added here.
+ */
+export type Node = import('./cpu-node.js').CPUNode | import('./network-node.js').NetworkNode;
+/**
+ * @license Copyright 2017 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.
+ */
+/**
+ * A union of all types derived from BaseNode, allowing type check discrimination
+ * based on `node.type`. If a new node type is created, it should be added here.
+ * @typedef {import('./cpu-node.js').CPUNode | import('./network-node.js').NetworkNode} Node
+ */
+/**
+ * @fileoverview This class encapsulates logic for handling resources and tasks used to model the
+ * execution dependency graph of the page. A node has a unique identifier and can depend on other
+ * nodes/be depended on. The construction of the graph maintains some important invariants that are
+ * inherent to the model:
+ *
+ *    1. The graph is a DAG, there are no cycles.
+ *    2. There is always a root node upon which all other nodes eventually depend.
+ *
+ * This allows particular optimizations in this class so that we do no need to check for cycles as
+ * these methods are called and we can always start traversal at the root node.
+ */
+export class BaseNode {
+    /**
+     * Returns whether the given node has a cycle in its dependent graph by performing a DFS.
+     * @param {Node} node
+     * @param {'dependents'|'dependencies'|'both'} [direction]
+     * @return {boolean}
+     */
+    static hasCycle(node: Node, direction?: "dependents" | "dependencies" | "both" | undefined): boolean;
+    /**
+     * @param {string} id
+     */
+    constructor(id: string);
+    _id: string;
+    _isMainDocument: boolean;
+    /** @type {Node[]} */
+    _dependents: Node[];
+    /** @type {Node[]} */
+    _dependencies: Node[];
+    /**
+     * @return {string}
+     */
+    get id(): string;
+    /**
+     * @return {typeof BaseNode.TYPES[keyof typeof BaseNode.TYPES]}
+     */
+    get type(): "network" | "cpu";
+    /**
+     * In microseconds
+     * @return {number}
+     */
+    get startTime(): number;
+    /**
+     * In microseconds
+     * @return {number}
+     */
+    get endTime(): number;
+    /**
+     * @param {boolean} value
+     */
+    setIsMainDocument(value: boolean): void;
+    /**
+     * @return {boolean}
+     */
+    isMainDocument(): boolean;
+    /**
+     * @return {Node[]}
+     */
+    getDependents(): Node[];
+    /**
+     * @return {number}
+     */
+    getNumberOfDependents(): number;
+    /**
+     * @return {Node[]}
+     */
+    getDependencies(): Node[];
+    /**
+     * @return {number}
+     */
+    getNumberOfDependencies(): number;
+    /**
+     * @return {Node}
+     */
+    getRootNode(): Node;
+    /**
+     * @param {Node} node
+     */
+    addDependent(node: Node): void;
+    /**
+     * @param {Node} node
+     */
+    addDependency(node: Node): void;
+    /**
+     * @param {Node} node
+     */
+    removeDependent(node: Node): void;
+    /**
+     * @param {Node} node
+     */
+    removeDependency(node: Node): void;
+    removeAllDependencies(): void;
+    /**
+     * Computes whether the given node is anywhere in the dependency graph of this node.
+     * While this method can prevent cycles, it walks the graph and should be used sparingly.
+     * Nodes are always considered dependent on themselves for the purposes of cycle detection.
+     * @param {BaseNode} node
+     * @return {boolean}
+     */
+    isDependentOn(node: BaseNode): boolean;
+    /**
+     * Clones the node's information without adding any dependencies/dependents.
+     * @return {Node}
+     */
+    cloneWithoutRelationships(): Node;
+    /**
+     * Clones the entire graph connected to this node filtered by the optional predicate. If a node is
+     * included by the predicate, all nodes along the paths between the node and the root will be included. If the
+     * node this was called on is not included in the resulting filtered graph, the method will throw.
+     * @param {function(Node):boolean} [predicate]
+     * @return {Node}
+     */
+    cloneWithRelationships(predicate?: ((arg0: Node) => boolean) | undefined): Node;
+    /**
+     * Traverses all connected nodes in BFS order, calling `callback` exactly once
+     * on each. `traversalPath` is the shortest (though not necessarily unique)
+     * path from `node` to the root of the iteration.
+     *
+     * The `getNextNodes` function takes a visited node and returns which nodes to
+     * visit next. It defaults to returning the node's dependents.
+     * @param {(node: Node, traversalPath: Node[]) => void} callback
+     * @param {function(Node): Node[]} [getNextNodes]
+     */
+    traverse(callback: (node: Node, traversalPath: Node[]) => void, getNextNodes?: ((arg0: Node) => Node[]) | undefined): void;
+    /**
+     * @see BaseNode.traverse
+     * @param {function(Node): Node[]} [getNextNodes]
+     */
+    traverseGenerator(getNextNodes?: ((arg0: Node) => Node[]) | undefined): Generator<{
+        node: Node;
+        traversalPath: Node[];
+    }, void, unknown>;
+    /**
+     * @param {Node} node
+     * @return {boolean}
+     */
+    canDependOn(node: Node): boolean;
+}
+export namespace BaseNode {
+    namespace TYPES {
+        const NETWORK: 'network';
+        const CPU: 'cpu';
+    }
+}
+//# sourceMappingURL=base-node.d.ts.map

package/core/lib/dependency-graph/cpu-node.d.ts

@@ -0,0 +1,34 @@
+export class CPUNode extends BaseNode {
+    /**
+     * @param {LH.TraceEvent} parentEvent
+     * @param {LH.TraceEvent[]=} childEvents
+     */
+    constructor(parentEvent: LH.TraceEvent, childEvents?: LH.TraceEvent[] | undefined);
+    _event: LH.TraceEvent;
+    _childEvents: LH.TraceEvent[];
+    get type(): "cpu";
+    /**
+     * @return {LH.TraceEvent}
+     */
+    get event(): LH.TraceEvent;
+    /**
+     * @return {LH.TraceEvent[]}
+     */
+    get childEvents(): LH.TraceEvent[];
+    /**
+     * Returns true if this node contains a Layout task.
+     * @return {boolean}
+     */
+    didPerformLayout(): boolean;
+    /**
+     * Returns the script URLs that had their EvaluateScript events occur in this task.
+     */
+    getEvaluateScriptURLs(): Set<string>;
+    /**
+     * @return {CPUNode}
+     */
+    cloneWithoutRelationships(): CPUNode;
+}
+import { BaseNode } from "./base-node.js";
+import * as LH from "../../../types/lh.js";
+//# sourceMappingURL=cpu-node.d.ts.map

package/core/lib/dependency-graph/cpu-node.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 {BaseNode} from './base-node.js';
 
 class CPUNode extends BaseNode {

package/core/lib/dependency-graph/network-node.d.ts

@@ -0,0 +1,43 @@
+export class NetworkNode extends BaseNode {
+    /**
+     * @param {LH.Artifacts.NetworkRequest} networkRecord
+     */
+    constructor(networkRecord: LH.Artifacts.NetworkRequest);
+    /** @private */
+    private _record;
+    get type(): "network";
+    /**
+     * @return {LH.Artifacts.NetworkRequest}
+     */
+    get record(): NetworkRequest;
+    /**
+     * @return {string}
+     */
+    get initiatorType(): string;
+    /**
+     * @return {boolean}
+     */
+    get fromDiskCache(): boolean;
+    /**
+     * @return {boolean}
+     */
+    get isNonNetworkProtocol(): boolean;
+    /**
+     * Returns whether this network record can be downloaded without a TCP connection.
+     * During simulation we treat data coming in over a network connection separately from on-device data.
+     * @return {boolean}
+     */
+    get isConnectionless(): boolean;
+    /**
+     * @return {boolean}
+     */
+    hasRenderBlockingPriority(): boolean;
+    /**
+     * @return {NetworkNode}
+     */
+    cloneWithoutRelationships(): NetworkNode;
+}
+import { BaseNode } from "./base-node.js";
+import { NetworkRequest } from "../network-request.js";
+import * as LH from "../../../types/lh.js";
+//# sourceMappingURL=network-node.d.ts.map

package/core/lib/dependency-graph/network-node.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 {BaseNode} from './base-node.js';
 import {NetworkRequest} from '../network-request.js';
 

package/core/lib/dependency-graph/simulator/connection-pool.d.ts

@@ -0,0 +1,58 @@
+export class ConnectionPool {
+    /**
+     * @param {LH.Artifacts.NetworkRequest[]} records
+     * @param {Required<LH.Gatherer.Simulation.Options>} options
+     */
+    constructor(records: LH.Artifacts.NetworkRequest[], options: Required<LH.Gatherer.Simulation.Options>);
+    _options: Required<LH.Gatherer.Simulation.Options>;
+    _records: import("../../network-request.js").NetworkRequest[];
+    /** @type {Map<string, TcpConnection[]>} */
+    _connectionsByOrigin: Map<string, TcpConnection[]>;
+    /** @type {Map<LH.Artifacts.NetworkRequest, TcpConnection>} */
+    _connectionsByRecord: Map<LH.Artifacts.NetworkRequest, TcpConnection>;
+    _connectionsInUse: Set<any>;
+    _connectionReusedByRequestId: Map<string, boolean>;
+    /**
+     * @return {TcpConnection[]}
+     */
+    connectionsInUse(): TcpConnection[];
+    _initializeConnections(): void;
+    /**
+     * @param {Array<TcpConnection>} connections
+     * @param {{ignoreConnectionReused?: boolean, observedConnectionWasReused: boolean}} options
+     */
+    _findAvailableConnectionWithLargestCongestionWindow(connections: Array<TcpConnection>, options: {
+        ignoreConnectionReused?: boolean | undefined;
+        observedConnectionWasReused: boolean;
+    }): TcpConnection | null;
+    /**
+     * This method finds an available connection to the origin specified by the network record or null
+     * if no connection was available. If returned, connection will not be available for other network
+     * records until release is called.
+     *
+     * If ignoreConnectionReused is true, acquire will consider all connections not in use as available.
+     * Otherwise, only connections that have matching "warmth" are considered available.
+     *
+     * @param {LH.Artifacts.NetworkRequest} record
+     * @param {{ignoreConnectionReused?: boolean}} options
+     * @return {?TcpConnection}
+     */
+    acquire(record: LH.Artifacts.NetworkRequest, options?: {
+        ignoreConnectionReused?: boolean;
+    }): TcpConnection | null;
+    /**
+     * Return the connection currently being used to fetch a record. If no connection
+     * currently being used for this record, an error will be thrown.
+     *
+     * @param {LH.Artifacts.NetworkRequest} record
+     * @return {TcpConnection}
+     */
+    acquireActiveConnectionFromRecord(record: LH.Artifacts.NetworkRequest): TcpConnection;
+    /**
+     * @param {LH.Artifacts.NetworkRequest} record
+     */
+    release(record: LH.Artifacts.NetworkRequest): void;
+}
+import * as LH from "../../../../types/lh.js";
+import { TcpConnection } from "./tcp-connection.js";
+//# sourceMappingURL=connection-pool.d.ts.map

package/core/lib/dependency-graph/simulator/connection-pool.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 {NetworkAnalyzer} from './network-analyzer.js';
 import {TcpConnection} from './tcp-connection.js';
 

package/core/lib/dependency-graph/simulator/dns-cache.d.ts

@@ -0,0 +1,42 @@
+export class DNSCache {
+    /**
+     * @param {{rtt: number}} options
+     */
+    constructor({ rtt }: {
+        rtt: number;
+    });
+    _rtt: number;
+    /** @type {Map<string, {resolvedAt: number}>} */
+    _resolvedDomainNames: Map<string, {
+        resolvedAt: number;
+    }>;
+    /**
+     * @param {LH.Artifacts.NetworkRequest} request
+     * @param {{requestedAt: number, shouldUpdateCache: boolean}=} options
+     * @return {number}
+     */
+    getTimeUntilResolution(request: LH.Artifacts.NetworkRequest, options?: {
+        requestedAt: number;
+        shouldUpdateCache: boolean;
+    } | undefined): number;
+    /**
+     * @param {LH.Artifacts.NetworkRequest} request
+     * @param {number} resolvedAt
+     */
+    _updateCacheResolvedAtIfNeeded(request: LH.Artifacts.NetworkRequest, resolvedAt: number): void;
+    /**
+     * Forcefully sets the DNS resolution time for a record.
+     * Useful for testing and alternate execution simulations.
+     *
+     * @param {string} domain
+     * @param {number} resolvedAt
+     */
+    setResolvedAt(domain: string, resolvedAt: number): void;
+}
+export namespace DNSCache {
+    export { DNS_RESOLUTION_RTT_MULTIPLIER as RTT_MULTIPLIER };
+}
+import * as LH from "../../../../types/lh.js";
+declare const DNS_RESOLUTION_RTT_MULTIPLIER: 2;
+export {};
+//# sourceMappingURL=dns-cache.d.ts.map

package/core/lib/dependency-graph/simulator/dns-cache.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';
+
 // A DNS lookup will usually take ~1-2 roundtrips of connection latency plus the extra DNS routing time.
 // Example: https://www.webpagetest.org/result/180703_3A_e33ec79747c002ed4d7bcbfc81462203/1/details/#waterfall_view_step1
 // Example: https://www.webpagetest.org/result/180707_1M_89673eb633b5d98386de95dfcf9b33d5/1/details/#waterfall_view_step1