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

package/core/audits/accessibility/td-headers-attr.d.ts

@@ -0,0 +1,10 @@
+export default TDHeadersAttr;
+declare class TDHeadersAttr extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from "./axe-audit.js";
+//# sourceMappingURL=td-headers-attr.d.ts.map

package/core/audits/accessibility/th-has-data-cells.d.ts

@@ -0,0 +1,10 @@
+export default THHasDataCells;
+declare class THHasDataCells extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from "./axe-audit.js";
+//# sourceMappingURL=th-has-data-cells.d.ts.map

package/core/audits/accessibility/valid-lang.d.ts

@@ -0,0 +1,10 @@
+export default ValidLang;
+declare class ValidLang extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from "./axe-audit.js";
+//# sourceMappingURL=valid-lang.d.ts.map

package/core/audits/accessibility/video-caption.d.ts

@@ -0,0 +1,10 @@
+export default VideoCaption;
+declare class VideoCaption extends AxeAudit {
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+}
+import AxeAudit from "./axe-audit.js";
+//# sourceMappingURL=video-caption.d.ts.map

package/core/audits/audit.d.ts

@@ -0,0 +1,150 @@
+export class Audit {
+    /**
+     * @return {string}
+     */
+    static get DEFAULT_PASS(): string;
+    /**
+     * @return {LH.Audit.ScoreDisplayModes}
+     */
+    static get SCORING_MODES(): import("../../types/lhr/audit-result.js").ScoreDisplayModes;
+    /**
+     * @return {LH.Audit.Meta}
+     */
+    static get meta(): LH.Audit.Meta;
+    /**
+     * @return {Object}
+     */
+    static get defaultOptions(): Object;
+    /**
+     *
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {LH.Audit.Product|Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): LH.Audit.Product | Promise<LH.Audit.Product>;
+    /**
+     * Computes a score between 0 and 1 based on the measured `value`. Score is determined by
+     * considering a log-normal distribution governed by two control points (the 10th
+     * percentile value and the median value) and represents the percentage of sites that are
+     * greater than `value`.
+     *
+     * Score characteristics:
+     * - within [0, 1]
+     * - rounded to two digits
+     * - value must meet or beat a controlPoint value to meet or exceed its percentile score:
+     *   - value > median will give a score < 0.5; value ≤ median will give a score ≥ 0.5.
+     *   - value > p10 will give a score < 0.9; value ≤ p10 will give a score ≥ 0.9.
+     * - values < p10 will get a slight boost so a score of 1 is achievable by a
+     *   `value` other than those close to 0. Scores of > ~0.99524 end up rounded to 1.
+     * @param {{median: number, p10: number}} controlPoints
+     * @param {number} value
+     * @return {number}
+     */
+    static computeLogNormalScore(controlPoints: {
+        median: number;
+        p10: number;
+    }, value: number): number;
+    /**
+     * This catches typos in the `key` property of a heading definition of table/opportunity details.
+     * Throws an error if any of keys referenced by headings don't exist in at least one of the items.
+     *
+     * @param {LH.Audit.Details.Table['headings']|LH.Audit.Details.Opportunity['headings']} headings
+     * @param {LH.Audit.Details.Opportunity['items']|LH.Audit.Details.Table['items']} items
+     */
+    static assertHeadingKeysExist(headings: LH.Audit.Details.Table['headings'] | LH.Audit.Details.Opportunity['headings'], items: LH.Audit.Details.Opportunity['items'] | LH.Audit.Details.Table['items']): void;
+    /**
+     * @param {LH.Audit.Details.Table['headings']} headings
+     * @param {LH.Audit.Details.Table['items']} results
+     * @param {LH.Audit.Details.Table['summary']=} summary
+     * @return {LH.Audit.Details.Table}
+     */
+    static makeTableDetails(headings: LH.Audit.Details.Table['headings'], results: LH.Audit.Details.Table['items'], summary?: LH.Audit.Details.Table['summary'] | undefined): LH.Audit.Details.Table;
+    /**
+     * @param {LH.Audit.Details.List['items']} items
+     * @return {LH.Audit.Details.List}
+     */
+    static makeListDetails(items: LH.Audit.Details.List['items']): LH.Audit.Details.List;
+    /** @typedef {{
+     * content: string;
+     * title: string;
+     * lineMessages: LH.Audit.Details.SnippetValue['lineMessages'];
+     * generalMessages: LH.Audit.Details.SnippetValue['generalMessages'];
+     * node?: LH.Audit.Details.NodeValue;
+     * maxLineLength?: number;
+     * maxLinesAroundMessage?: number;
+     * }} SnippetInfo */
+    /**
+     * @param {SnippetInfo} snippetInfo
+     * @return {LH.Audit.Details.SnippetValue}
+     */
+    static makeSnippetDetails({ content, title, lineMessages, generalMessages, node, maxLineLength, maxLinesAroundMessage, }: {
+        content: string;
+        title: string;
+        lineMessages: LH.Audit.Details.SnippetValue['lineMessages'];
+        generalMessages: LH.Audit.Details.SnippetValue['generalMessages'];
+        node?: LH.Audit.Details.NodeValue | undefined;
+        maxLineLength?: number | undefined;
+        maxLinesAroundMessage?: number | undefined;
+    }): LH.Audit.Details.SnippetValue;
+    /**
+     * @param {string} content
+     * @param {number} maxLineLength
+     * @return {LH.Audit.Details.SnippetValue['lines']}
+     */
+    static _makeSnippetLinesArray(content: string, maxLineLength: number): LH.Audit.Details.SnippetValue['lines'];
+    /**
+     * @param {LH.Audit.Details.Opportunity['headings']} headings
+     * @param {LH.Audit.Details.Opportunity['items']} items
+     * @param {number} overallSavingsMs
+     * @param {number=} overallSavingsBytes
+     * @return {LH.Audit.Details.Opportunity}
+     */
+    static makeOpportunityDetails(headings: LH.Audit.Details.Opportunity['headings'], items: LH.Audit.Details.Opportunity['items'], overallSavingsMs: number, overallSavingsBytes?: number | undefined): LH.Audit.Details.Opportunity;
+    /**
+     * @param {LH.Artifacts.NodeDetails} node
+     * @return {LH.Audit.Details.NodeValue}
+     */
+    static makeNodeItem(node: LH.Artifacts.NodeDetails): LH.Audit.Details.NodeValue;
+    /**
+     * @param {LH.Artifacts.Bundle} bundle
+     * @param {number} generatedLine
+     * @param {number} generatedColumn
+     * @return {LH.Audit.Details.SourceLocationValue['original']}
+     */
+    static _findOriginalLocation(bundle: LH.Artifacts.Bundle, generatedLine: number, generatedColumn: number): LH.Audit.Details.SourceLocationValue['original'];
+    /**
+     * @param {string} url
+     * @param {number} line 0-indexed
+     * @param {number} column 0-indexed
+     * @param {LH.Artifacts.Bundle=} bundle
+     * @return {LH.Audit.Details.SourceLocationValue}
+     */
+    static makeSourceLocation(url: string, line: number, column: number, bundle?: LH.Artifacts.Bundle | undefined): LH.Audit.Details.SourceLocationValue;
+    /**
+     * @param {LH.Artifacts.ConsoleMessage} entry
+     * @param {LH.Artifacts.Bundle=} bundle
+     * @return {LH.Audit.Details.SourceLocationValue | undefined}
+     */
+    static makeSourceLocationFromConsoleMessage(entry: LH.Artifacts.ConsoleMessage, bundle?: LH.Artifacts.Bundle | undefined): LH.Audit.Details.SourceLocationValue | undefined;
+    /**
+     * @param {number|null} score
+     * @param {LH.Audit.ScoreDisplayMode} scoreDisplayMode
+     * @param {string} auditId
+     * @return {number|null}
+     */
+    static _normalizeAuditScore(score: number | null, scoreDisplayMode: LH.Audit.ScoreDisplayMode, auditId: string): number | null;
+    /**
+     * @param {typeof Audit} audit
+     * @param {string | LH.IcuMessage} errorMessage
+     * @return {LH.RawIcu<LH.Audit.Result>}
+     */
+    static generateErrorAuditResult(audit: typeof Audit, errorMessage: string | LH.IcuMessage): LH.RawIcu<LH.Audit.Result>;
+    /**
+     * @param {typeof Audit} audit
+     * @param {LH.Audit.Product} product
+     * @return {LH.RawIcu<LH.Audit.Result>}
+     */
+    static generateAuditResult(audit: typeof Audit, product: LH.Audit.Product): LH.RawIcu<LH.Audit.Result>;
+}
+import * as LH from "../../types/lh.js";
+//# sourceMappingURL=audit.d.ts.map

package/core/audits/audit.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 {isUnderTest} from '../lib/lh-env.js';
 import * as statistics from '../lib/statistics.js';
 import {Util} from '../util.cjs';

package/core/audits/autocomplete.d.ts

@@ -0,0 +1,36 @@
+export default AutocompleteAudit;
+/**
+ * The autocomplete attribute can have multiple tokens in it. All tokens should be valid and in the correct order.
+ * For example, cc-namez is an invalid token. tel mobile shipping section-foo are valid tokens, but out of order. The spec defines correct ordering, but in short, correct order is:
+ *
+ * [section-*] [shipping|billing] [home|work|mobile|fax|pager] <autofill field name>
+ *
+ * If either of these invalid situations, the autocomplete property will be an empty string. */
+declare class AutocompleteAudit extends Audit {
+    /**
+     * @param {LH.Artifacts.InputElement} input
+     * @return {{hasValidTokens: boolean, isValidOrder?: boolean}}
+     */
+    static checkAttributeValidity(input: LH.Artifacts.InputElement): {
+        hasValidTokens: boolean;
+        isValidOrder?: boolean;
+    };
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {LH.Audit.Product}
+     */
+    static audit(artifacts: LH.Artifacts): LH.Audit.Product;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const columnSuggestions: string;
+    const columnCurrent: string;
+    const warningInvalid: string;
+    const warningOrder: string;
+    const reviewOrder: string;
+    const manualReview: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=autocomplete.d.ts.map

package/core/audits/bf-cache.d.ts

@@ -0,0 +1,21 @@
+export default BFCache;
+declare class BFCache extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const actionableFailureType: string;
+    const notActionableFailureType: string;
+    const supportPendingFailureType: string;
+    const failureReasonColumn: string;
+    const failureTypeColumn: string;
+    const displayValue: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=bf-cache.d.ts.map

package/core/audits/bootup-time.d.ts

@@ -0,0 +1,26 @@
+export default BootupTime;
+declare class BootupTime extends Audit {
+    /**
+     * @return {LH.Audit.ScoreOptions & {thresholdInMs: number}}
+     */
+    static get defaultOptions(): import("../../types/audit.js").default.ScoreOptions & {
+        thresholdInMs: number;
+    };
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const columnTotal: string;
+    const columnScriptEval: string;
+    const columnScriptParse: string;
+    const chromeExtensionsWarning: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=bootup-time.d.ts.map

package/core/audits/byte-efficiency/byte-efficiency-audit.d.ts

@@ -0,0 +1,82 @@
+export type Simulator = import('../../lib/dependency-graph/simulator/simulator').Simulator;
+export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+export type ByteEfficiencyProduct = {
+    items: Array<LH.Audit.ByteEfficiencyItem>;
+    wastedBytesByUrl?: Map<string, number> | undefined;
+    headings: LH.Audit.Details.Opportunity['headings'];
+    displayValue?: import("../../index.js").IcuMessage | undefined;
+    explanation?: import("../../index.js").IcuMessage | undefined;
+    warnings?: (string | import("../../index.js").IcuMessage)[] | undefined;
+};
+/**
+ * @typedef {object} ByteEfficiencyProduct
+ * @property {Array<LH.Audit.ByteEfficiencyItem>} items
+ * @property {Map<string, number>=} wastedBytesByUrl
+ * @property {LH.Audit.Details.Opportunity['headings']} headings
+ * @property {LH.IcuMessage} [displayValue]
+ * @property {LH.IcuMessage} [explanation]
+ * @property {Array<string | LH.IcuMessage>} [warnings]
+ */
+/**
+ * @overview Used as the base for all byte efficiency audits. Computes total bytes
+ *    and estimated time saved. Subclass and override `audit_` to return results.
+ */
+export class ByteEfficiencyAudit extends Audit {
+    /**
+     * Creates a score based on the wastedMs value using linear interpolation between control points.
+     *
+     * @param {number} wastedMs
+     * @return {number}
+     */
+    static scoreForWastedMs(wastedMs: number): number;
+    /**
+     * Estimates the number of bytes this network record would have consumed on the network based on the
+     * uncompressed size (totalBytes). Uses the actual transfer size from the network record if applicable.
+     *
+     * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
+     * @param {number} totalBytes Uncompressed size of the resource
+     * @param {LH.Crdp.Network.ResourceType=} resourceType
+     * @return {number}
+     */
+    static estimateTransferSize(networkRecord: LH.Artifacts.NetworkRequest | undefined, totalBytes: number, resourceType?: LH.Crdp.Network.ResourceType | undefined): number;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<LH.Audit.Product>}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<LH.Audit.Product>;
+    /**
+     * Computes the estimated effect of all the byte savings on the maximum of the following:
+     *
+     * - end time of the last long task in the provided graph
+     * - (if includeLoad is true or not provided) end time of the last node in the graph
+     *
+     * @param {Array<LH.Audit.ByteEfficiencyItem>} results The array of byte savings results per resource
+     * @param {Node} graph
+     * @param {Simulator} simulator
+     * @param {{includeLoad?: boolean, label?: string, providedWastedBytesByUrl?: Map<string, number>}=} options
+     * @return {number}
+     */
+    static computeWasteWithTTIGraph(results: Array<LH.Audit.ByteEfficiencyItem>, graph: Node, simulator: Simulator, options?: {
+        includeLoad?: boolean;
+        label?: string;
+        providedWastedBytesByUrl?: Map<string, number>;
+    } | undefined): number;
+    /**
+     * @param {ByteEfficiencyProduct} result
+     * @param {Node|null} graph
+     * @param {Simulator} simulator
+     * @param {LH.Artifacts['GatherContext']} gatherContext
+     * @return {LH.Audit.Product}
+     */
+    static createAuditProduct(result: ByteEfficiencyProduct, graph: Node | null, simulator: Simulator, gatherContext: LH.Artifacts['GatherContext']): LH.Audit.Product;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {LH.Audit.Context} context
+     * @return {ByteEfficiencyProduct|Promise<ByteEfficiencyProduct>}
+     */
+    static audit_(artifacts: LH.Artifacts, networkRecords: Array<LH.Artifacts.NetworkRequest>, context: LH.Audit.Context): ByteEfficiencyProduct | Promise<ByteEfficiencyProduct>;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=byte-efficiency-audit.d.ts.map

package/core/audits/byte-efficiency/duplicated-javascript.d.ts

@@ -0,0 +1,52 @@
+export default DuplicatedJavascript;
+export type ByteEfficiencyProduct = import('./byte-efficiency-audit.js').ByteEfficiencyProduct;
+export type Item = LH.Audit.ByteEfficiencyItem & {
+    source: string;
+    subItems: {
+        type: 'subitems';
+        items: SubItem[];
+    };
+};
+export type SubItem = {
+    url: string;
+    sourceTransferBytes?: number;
+};
+declare class DuplicatedJavascript extends ByteEfficiencyAudit {
+    /**
+     * @param {string} source
+     */
+    static _getNodeModuleName(source: string): string;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     */
+    static _getDuplicationGroupedByNodeModules(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<Map<string, {
+        scriptId: string;
+        scriptUrl: string;
+        resourceSize: number;
+    }[]>>;
+    /**
+     *
+     * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
+     * @param {number} contentLength
+     */
+    static _estimateTransferRatio(networkRecord: LH.Artifacts.NetworkRequest | undefined, contentLength: number): number;
+    /**
+     * This audit highlights JavaScript modules that appear to be duplicated across all resources,
+     * either within the same bundle or between different bundles. Each details item returned is
+     * a module with subItems for each resource that includes it. The wastedBytes for the details
+     * item is the number of bytes occupied by the sum of all but the largest copy of the module.
+     * wastedBytesByUrl attributes the cost of the bytes to a specific resource, for use by lantern.
+     * @param {LH.Artifacts} artifacts
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {LH.Audit.Context} context
+     * @return {Promise<ByteEfficiencyProduct>}
+     */
+    static audit_(artifacts: LH.Artifacts, networkRecords: Array<LH.Artifacts.NetworkRequest>, context: LH.Audit.Context): Promise<ByteEfficiencyProduct>;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+}
+import { ByteEfficiencyAudit } from "./byte-efficiency-audit.js";
+//# sourceMappingURL=duplicated-javascript.d.ts.map

package/core/audits/byte-efficiency/efficient-animated-content.d.ts

@@ -0,0 +1,23 @@
+export default EfficientAnimatedContent;
+declare class EfficientAnimatedContent extends ByteEfficiencyAudit {
+    /**
+     * Calculate rough savings percentage based on 1000 real gifs transcoded to video
+     * @param {number} bytes
+     * @return {number} rough savings percentage
+     * @see https://github.com/GoogleChrome/lighthouse/issues/4696#issuecomment-380296510 bytes
+     */
+    static getPercentSavings(bytes: number): number;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @return {import('./byte-efficiency-audit.js').ByteEfficiencyProduct}
+     */
+    static audit_(artifacts: LH.Artifacts, networkRecords: Array<LH.Artifacts.NetworkRequest>): import('./byte-efficiency-audit.js').ByteEfficiencyProduct;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+}
+import { ByteEfficiencyAudit } from "./byte-efficiency-audit.js";
+import { NetworkRequest } from "../../lib/network-request.js";
+//# sourceMappingURL=efficient-animated-content.d.ts.map

package/core/audits/byte-efficiency/legacy-javascript.d.ts

@@ -0,0 +1,99 @@
+export default LegacyJavascript;
+export type Pattern = {
+    name: string;
+    expression: string;
+    estimateBytes?: ((result: PatternMatchResult) => number) | undefined;
+};
+export type PatternMatchResult = {
+    name: string;
+    line: number;
+    column: number;
+    count: number;
+};
+export type ByteEfficiencyProduct = import('./byte-efficiency-audit.js').ByteEfficiencyProduct;
+export type Item = LH.Audit.ByteEfficiencyItem & {
+    subItems: {
+        type: 'subitems';
+        items: SubItem[];
+    };
+};
+export type SubItem = {
+    signal: string;
+    location: LH.Audit.Details.SourceLocationValue;
+};
+declare class LegacyJavascript extends ByteEfficiencyAudit {
+    /**
+     * @param {string?} object
+     * @param {string} property
+     */
+    static buildPolyfillExpression(object: string | null, property: string): string;
+    static getPolyfillData(): {
+        name: string;
+        coreJs2Module: string;
+        coreJs3Module: string;
+    }[];
+    /**
+     * @return {Pattern[]}
+     */
+    static getPolyfillPatterns(): Pattern[];
+    /**
+     * @return {Pattern[]}
+     */
+    static getTransformPatterns(): Pattern[];
+    /**
+     * Returns a collection of match results grouped by script url.
+     *
+     * @param {CodePatternMatcher} matcher
+     * @param {LH.Artifacts['Scripts']} scripts
+     * @param {LH.Artifacts.NetworkRequest[]} networkRecords
+     * @param {LH.Artifacts.Bundle[]} bundles
+     * @return {Map<LH.Artifacts.Script, PatternMatchResult[]>}
+     */
+    static detectAcrossScripts(matcher: CodePatternMatcher, scripts: LH.Artifacts['Scripts'], networkRecords: LH.Artifacts.NetworkRequest[], bundles: LH.Artifacts.Bundle[]): Map<LH.Artifacts.Script, PatternMatchResult[]>;
+    /**
+     * @param {PatternMatchResult[]} matches
+     * @return {number}
+     */
+    static estimateWastedBytes(matches: PatternMatchResult[]): number;
+    /**
+     * Utility function to estimate transfer size and cache calculation.
+     *
+     * Note: duplicated-javascript does this exact thing. In the future, consider
+     * making a generic estimator on ByteEfficienyAudit.
+     * @param {Map<string, number>} transferRatioByUrl
+     * @param {string} url
+     * @param {LH.Artifacts} artifacts
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     */
+    static estimateTransferRatioForScript(transferRatioByUrl: Map<string, number>, url: string, artifacts: LH.Artifacts, networkRecords: Array<LH.Artifacts.NetworkRequest>): Promise<number>;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {LH.Audit.Context} context
+     * @return {Promise<ByteEfficiencyProduct>}
+     */
+    static audit_(artifacts: LH.Artifacts, networkRecords: Array<LH.Artifacts.NetworkRequest>, context: LH.Audit.Context): Promise<ByteEfficiencyProduct>;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+}
+import { ByteEfficiencyAudit } from "./byte-efficiency-audit.js";
+/**
+ * Takes a list of patterns (consisting of a name identifier and a RegExp expression string)
+ * and returns match results with line / column information for a given code input.
+ */
+declare class CodePatternMatcher {
+    /**
+     * @param {Pattern[]} patterns
+     */
+    constructor(patterns: Pattern[]);
+    re: RegExp;
+    patterns: Pattern[];
+    /**
+     * @param {string} code
+     * @return {PatternMatchResult[]}
+     */
+    match(code: string): PatternMatchResult[];
+}
+//# sourceMappingURL=legacy-javascript.d.ts.map

package/core/audits/byte-efficiency/modern-image-formats.d.ts

@@ -0,0 +1,38 @@
+export default ModernImageFormats;
+declare class ModernImageFormats extends ByteEfficiencyAudit {
+    /**
+     * @param {{naturalWidth: number, naturalHeight: number}} imageElement
+     * @return {number}
+     */
+    static estimateWebPSizeFromDimensions(imageElement: {
+        naturalWidth: number;
+        naturalHeight: number;
+    }): number;
+    /**
+     * @param {{naturalWidth: number, naturalHeight: number}} imageElement
+     * @return {number}
+     */
+    static estimateAvifSizeFromDimensions(imageElement: {
+        naturalWidth: number;
+        naturalHeight: number;
+    }): number;
+    /**
+     * @param {{jpegSize: number | undefined, webpSize: number | undefined}} otherFormatSizes
+     * @return {number|undefined}
+     */
+    static estimateAvifSizeFromWebPAndJpegEstimates(otherFormatSizes: {
+        jpegSize: number | undefined;
+        webpSize: number | undefined;
+    }): number | undefined;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {import('./byte-efficiency-audit.js').ByteEfficiencyProduct}
+     */
+    static audit_(artifacts: LH.Artifacts): import('./byte-efficiency-audit.js').ByteEfficiencyProduct;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+}
+import { ByteEfficiencyAudit } from "./byte-efficiency-audit.js";
+//# sourceMappingURL=modern-image-formats.d.ts.map

package/core/audits/byte-efficiency/offscreen-images.d.ts

@@ -0,0 +1,75 @@
+export default OffscreenImages;
+export type WasteResult = {
+    node: LH.Audit.Details.NodeValue;
+    url: string;
+    requestStartTime: number;
+    totalBytes: number;
+    wastedBytes: number;
+    wastedPercent: number;
+};
+/** @typedef {{node: LH.Audit.Details.NodeValue, url: string, requestStartTime: number, totalBytes: number, wastedBytes: number, wastedPercent: number}} WasteResult */
+declare class OffscreenImages extends ByteEfficiencyAudit {
+    /**
+     * @param {{top: number, bottom: number, left: number, right: number}} imageRect
+     * @param {{innerWidth: number, innerHeight: number}} viewportDimensions
+     * @return {number}
+     */
+    static computeVisiblePixels(imageRect: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    }, viewportDimensions: {
+        innerWidth: number;
+        innerHeight: number;
+    }): number;
+    /**
+     * @param {LH.Artifacts.ImageElement} image
+     * @param {{innerWidth: number, innerHeight: number}} viewportDimensions
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @return {null|Error|WasteResult}
+     */
+    static computeWaste(image: LH.Artifacts.ImageElement, viewportDimensions: {
+        innerWidth: number;
+        innerHeight: number;
+    }, networkRecords: Array<LH.Artifacts.NetworkRequest>): null | Error | WasteResult;
+    /**
+     * Filters out image requests that were requested after the last long task based on lantern timings.
+     *
+     * @param {WasteResult[]} images
+     * @param {LH.Artifacts.LanternMetric} lanternMetricData
+     */
+    static filterLanternResults(images: WasteResult[], lanternMetricData: LH.Artifacts.LanternMetric): WasteResult[];
+    /**
+     * Filters out image requests that were requested after TTI.
+     *
+     * @param {WasteResult[]} images
+     * @param {number} interactiveTimestamp
+     */
+    static filterObservedResults(images: WasteResult[], interactiveTimestamp: number): WasteResult[];
+    /**
+     * The default byte efficiency audit will report max(TTI, load), since lazy-loading offscreen
+     * images won't reduce the overall time and the wasted bytes are really only "wasted" for TTI,
+     * override the function to just look at TTI savings.
+     *
+     * @param {Array<LH.Audit.ByteEfficiencyItem>} results
+     * @param {LH.Gatherer.Simulation.GraphNode} graph
+     * @param {LH.Gatherer.Simulation.Simulator} simulator
+     * @return {number}
+     */
+    static computeWasteWithTTIGraph(results: Array<LH.Audit.ByteEfficiencyItem>, graph: LH.Gatherer.Simulation.GraphNode, simulator: LH.Gatherer.Simulation.Simulator): number;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @param {LH.Audit.Context} context
+     * @return {Promise<import('./byte-efficiency-audit.js').ByteEfficiencyProduct>}
+     */
+    static audit_(artifacts: LH.Artifacts, networkRecords: Array<LH.Artifacts.NetworkRequest>, context: LH.Audit.Context): Promise<import('./byte-efficiency-audit.js').ByteEfficiencyProduct>;
+}
+export namespace UIStrings {
+    const title: string;
+    const description: string;
+}
+import { ByteEfficiencyAudit } from "./byte-efficiency-audit.js";
+import { NetworkRequest } from "../../lib/network-request.js";
+//# sourceMappingURL=offscreen-images.d.ts.map