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

package/core/audits/byte-efficiency/render-blocking-resources.d.ts

@@ -0,0 +1,55 @@
+export default RenderBlockingResources;
+export type Simulator = import('../../lib/dependency-graph/simulator/simulator').Simulator;
+export type Node = import('../../lib/dependency-graph/base-node.js').Node;
+export type NetworkNode = typeof import("../../lib/dependency-graph/network-node.js");
+declare class RenderBlockingResources extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<{wastedMs: number, results: Array<{url: string, totalBytes: number, wastedMs: number}>}>}
+     */
+    static computeResults(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<{
+        wastedMs: number;
+        results: {
+            url: string;
+            totalBytes: number;
+            wastedMs: number;
+        }[];
+    }>;
+    /**
+     * Estimates how much faster this page would reach FCP if we inlined all the used CSS from the
+     * render blocking stylesheets and deferred all the scripts. This is more conservative than
+     * removing all the assets and more aggressive than inlining everything.
+     *
+     * *Most* of the time, scripts in the head are there accidentally/due to lack of awareness
+     * rather than necessity, so we're comfortable with this balance. In the worst case, we're telling
+     * devs that they should be able to get to a reasonable first paint without JS, which is not a bad
+     * thing.
+     *
+     * @param {Simulator} simulator
+     * @param {Node} fcpGraph
+     * @param {Set<string>} deferredIds
+     * @param {Map<string, number>} wastedCssBytesByUrl
+     * @param {LH.Artifacts.DetectedStack[]} Stacks
+     * @return {number}
+     */
+    static estimateSavingsWithGraphs(simulator: Simulator, fcpGraph: Node, deferredIds: Set<string>, wastedCssBytesByUrl: Map<string, number>, Stacks: LH.Artifacts.DetectedStack[]): number;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<Map<string, number>>}
+     */
+    static computeWastedCSSBytes(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<Map<string, 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 description: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=render-blocking-resources.d.ts.map

package/core/audits/byte-efficiency/total-byte-weight.d.ts

@@ -0,0 +1,21 @@
+export default TotalByteWeight;
+declare class TotalByteWeight extends Audit {
+    /**
+     * @return {LH.Audit.ScoreOptions}
+     */
+    static get defaultOptions(): import("../../../types/audit.js").default.ScoreOptions;
+    /**
+     * @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 displayValue: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=total-byte-weight.d.ts.map

package/core/audits/byte-efficiency/unminified-css.d.ts

@@ -0,0 +1,36 @@
+export default UnminifiedCSS;
+/**
+ * @fileOverview
+ */
+declare class UnminifiedCSS extends ByteEfficiencyAudit {
+    /**
+     * Computes the total length of the meaningful tokens (CSS excluding comments and whitespace).
+     *
+     * @param {string} content
+     * @return {number}
+     */
+    static computeTokenLength(content: string): number;
+    /**
+     * @param {LH.Artifacts.CSSStyleSheetInfo} stylesheet
+     * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
+     * @return {{url: string, totalBytes: number, wastedBytes: number, wastedPercent: number}}
+     */
+    static computeWaste(stylesheet: LH.Artifacts.CSSStyleSheetInfo, networkRecord: LH.Artifacts.NetworkRequest | undefined): {
+        url: string;
+        totalBytes: number;
+        wastedBytes: number;
+        wastedPercent: 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";
+//# sourceMappingURL=unminified-css.d.ts.map

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

@@ -0,0 +1,37 @@
+export default UnminifiedJavaScript;
+/**
+ * @fileOverview Estimates minification savings by determining the ratio of parseable JS tokens to the
+ * length of the entire string. Though simple, this method is quite accurate at identifying whether
+ * a script was already minified and offers a relatively conservative minification estimate (our two
+ * primary goals).
+ *
+ * This audit only examines scripts that were independent network requests and not inlined or eval'd.
+ *
+ * See https://github.com/GoogleChrome/lighthouse/pull/3950#issue-277887798 for stats on accuracy.
+ */
+declare class UnminifiedJavaScript extends ByteEfficiencyAudit {
+    /**
+     * @param {string} scriptContent
+     * @param {string} displayUrl
+     * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
+     * @return {{url: string, totalBytes: number, wastedBytes: number, wastedPercent: number}}
+     */
+    static computeWaste(scriptContent: string, displayUrl: string, networkRecord: LH.Artifacts.NetworkRequest | undefined): {
+        url: string;
+        totalBytes: number;
+        wastedBytes: number;
+        wastedPercent: 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";
+//# sourceMappingURL=unminified-javascript.d.ts.map

package/core/audits/byte-efficiency/unused-css-rules.d.ts

@@ -0,0 +1,16 @@
+export default UnusedCSSRules;
+declare class UnusedCSSRules extends ByteEfficiencyAudit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Artifacts.NetworkRequest[]} _
+     * @param {LH.Audit.Context} context
+     * @return {Promise<import('./byte-efficiency-audit.js').ByteEfficiencyProduct>}
+     */
+    static audit_(artifacts: LH.Artifacts, _: 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";
+//# sourceMappingURL=unused-css-rules.d.ts.map

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

@@ -0,0 +1,27 @@
+export default UnusedJavaScript;
+export type WasteData = {
+    unusedByIndex: Uint8Array;
+    unusedLength: number;
+    contentLength: number;
+};
+/**
+ * @typedef WasteData
+ * @property {Uint8Array} unusedByIndex
+ * @property {number} unusedLength
+ * @property {number} contentLength
+ */
+declare class UnusedJavaScript extends ByteEfficiencyAudit {
+    /**
+     * @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";
+//# sourceMappingURL=unused-javascript.d.ts.map

package/core/audits/byte-efficiency/uses-long-cache-ttl.d.ts

@@ -0,0 +1,61 @@
+/// <reference path="../../../../../types/internal/parse-cache-control.d.ts" />
+export default CacheHeaders;
+declare class CacheHeaders extends Audit {
+    /**
+     * @return {LH.Audit.ScoreOptions}
+     */
+    static get defaultOptions(): import("../../../types/audit.js").default.ScoreOptions;
+    /**
+     * Computes the percent likelihood that a return visit will be within the cache lifetime, based on
+     * Chrome UMA stats see the note below.
+     * @param {number} maxAgeInSeconds
+     * @return {number}
+     */
+    static getCacheHitProbability(maxAgeInSeconds: number): number;
+    /**
+     * Return max-age if defined, otherwise expires header if defined, and null if not.
+     * @param {Map<string, string>} headers
+     * @param {ReturnType<typeof parseCacheControl>} cacheControl
+     * @return {?number}
+     */
+    static computeCacheLifetimeInSeconds(headers: Map<string, string>, cacheControl: ReturnType<typeof parseCacheControl>): number | null;
+    /**
+     * Given a network record, returns whether we believe the asset is cacheable, i.e. it was a network
+     * request that satisifed the conditions:
+     *
+     *  1. Has a cacheable status code
+     *  2. Has a resource type that corresponds to static assets (image, script, stylesheet, etc).
+     *
+     * Allowing assets with a query string is debatable, PSI considered them non-cacheable with a similar
+     * caveat.
+     *
+     * TODO: Investigate impact in HTTPArchive, experiment with this policy to see what changes.
+     *
+     * @param {LH.Artifacts.NetworkRequest} record
+     * @return {boolean}
+     */
+    static isCacheableAsset(record: LH.Artifacts.NetworkRequest): boolean;
+    /**
+     * Returns true if headers suggest a record should not be cached for a long time.
+     * @param {Map<string, string>} headers
+     * @param {ReturnType<typeof parseCacheControl>} cacheControl
+     * @return {boolean}
+     */
+    static shouldSkipRecord(headers: Map<string, string>, cacheControl: ReturnType<typeof parseCacheControl>): boolean;
+    /**
+     * @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 displayValue: string;
+}
+import { Audit } from "../audit.js";
+import parseCacheControl from "parse-cache-control";
+import { NetworkRequest } from "../../lib/network-request.js";
+//# sourceMappingURL=uses-long-cache-ttl.d.ts.map

package/core/audits/byte-efficiency/uses-optimized-images.d.ts

@@ -0,0 +1,33 @@
+export default UsesOptimizedImages;
+declare class UsesOptimizedImages extends ByteEfficiencyAudit {
+    /**
+     * @param {{originalSize: number, jpegSize: number}} image
+     * @return {{bytes: number, percent: number}}
+     */
+    static computeSavings(image: {
+        originalSize: number;
+        jpegSize: number;
+    }): {
+        bytes: number;
+        percent: number;
+    };
+    /**
+     * @param {{naturalWidth: number, naturalHeight: number}} imageElement
+     * @return {number}
+     */
+    static estimateJPEGSizeFromDimensions(imageElement: {
+        naturalWidth: number;
+        naturalHeight: number;
+    }): number;
+    /**
+     * @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=uses-optimized-images.d.ts.map

package/core/audits/byte-efficiency/uses-responsive-images-snapshot.d.ts

@@ -0,0 +1,16 @@
+export default UsesResponsiveImagesSnapshot;
+declare class UsesResponsiveImagesSnapshot 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 columnDisplayedDimensions: string;
+    const columnActualDimensions: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=uses-responsive-images-snapshot.d.ts.map

package/core/audits/byte-efficiency/uses-responsive-images.d.ts

@@ -0,0 +1,45 @@
+export default UsesResponsiveImages;
+declare class UsesResponsiveImages extends ByteEfficiencyAudit {
+    /**
+     * @param {LH.Artifacts.ImageElement & {naturalWidth: number, naturalHeight: number}} image
+     * @param {LH.Artifacts.ViewportDimensions} ViewportDimensions
+     * @return {{width: number, height: number}};
+     */
+    static getDisplayedDimensions(image: LH.Artifacts.ImageElement & {
+        naturalWidth: number;
+        naturalHeight: number;
+    }, ViewportDimensions: LH.Artifacts.ViewportDimensions): {
+        width: number;
+        height: number;
+    };
+    /**
+     * @param {LH.Artifacts.ImageElement & {naturalWidth: number, naturalHeight: number}} image
+     * @param {LH.Artifacts.ViewportDimensions} ViewportDimensions
+     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+     * @return {null|LH.Audit.ByteEfficiencyItem};
+     */
+    static computeWaste(image: LH.Artifacts.ImageElement & {
+        naturalWidth: number;
+        naturalHeight: number;
+    }, ViewportDimensions: LH.Artifacts.ViewportDimensions, networkRecords: Array<LH.Artifacts.NetworkRequest>): null | LH.Audit.ByteEfficiencyItem;
+    /**
+     * @param {LH.Artifacts.ImageElement} image
+     * @return {number};
+     */
+    static determineAllowableWaste(image: LH.Artifacts.ImageElement): 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;
+}
+export const str_: (message: string, values?: Record<string, string | number> | undefined) => import("../../index.js").IcuMessage;
+import { ByteEfficiencyAudit } from "./byte-efficiency-audit.js";
+import { NetworkRequest } from "../../lib/network-request.js";
+//# sourceMappingURL=uses-responsive-images.d.ts.map

package/core/audits/byte-efficiency/uses-text-compression.d.ts

@@ -0,0 +1,14 @@
+export default ResponsesAreCompressed;
+declare class ResponsesAreCompressed extends ByteEfficiencyAudit {
+    /**
+     * @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=uses-text-compression.d.ts.map

package/core/audits/content-width.d.ts

@@ -0,0 +1,17 @@
+export default ContentWidth;
+declare class ContentWidth extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {LH.Audit.Product}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): LH.Audit.Product;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const explanation: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=content-width.d.ts.map

package/core/audits/critical-request-chains.d.ts

@@ -0,0 +1,44 @@
+export default CriticalRequestChains;
+declare class CriticalRequestChains extends Audit {
+    /** @typedef {{depth: number, id: string, chainDuration: number, chainTransferSize: number, node: LH.Audit.Details.SimpleCriticalRequestNode[string]}} CrcNodeInfo */
+    /**
+     * @param {LH.Audit.Details.SimpleCriticalRequestNode} tree
+     * @param {function(CrcNodeInfo): void} cb
+     */
+    static _traverse(tree: LH.Audit.Details.SimpleCriticalRequestNode, cb: (arg0: {
+        depth: number;
+        id: string;
+        chainDuration: number;
+        chainTransferSize: number;
+        node: LH.Audit.Details.SimpleCriticalRequestNode[string];
+    }) => void): void;
+    /**
+     * Get stats about the longest initiator chain (as determined by time duration)
+     * @param {LH.Audit.Details.SimpleCriticalRequestNode} tree
+     * @return {{duration: number, length: number, transferSize: number}}
+     */
+    static _getLongestChain(tree: LH.Audit.Details.SimpleCriticalRequestNode): {
+        duration: number;
+        length: number;
+        transferSize: number;
+    };
+    /**
+     * @param {LH.Artifacts.CriticalRequestNode} tree
+     * @return {LH.Audit.Details.SimpleCriticalRequestNode}
+     */
+    static flattenRequests(tree: LH.Artifacts.CriticalRequestNode): LH.Audit.Details.SimpleCriticalRequestNode;
+    /**
+     * Audits the page to give a score for First Meaningful Paint.
+     * @param {LH.Artifacts} artifacts The artifacts from the gather phase.
+     * @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 description: string;
+    const displayValue: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=critical-request-chains.d.ts.map

package/core/audits/csp-xss.d.ts

@@ -0,0 +1,51 @@
+export default CspXss;
+export type Finding = import('../lib/csp-evaluator.js').Finding;
+declare class CspXss extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {Promise<{cspHeaders: string[], cspMetaTags: string[]}>}
+     */
+    static getRawCsps(artifacts: LH.Artifacts, context: LH.Audit.Context): Promise<{
+        cspHeaders: string[];
+        cspMetaTags: string[];
+    }>;
+    /**
+     * @param {Finding} finding
+     * @param {LH.IcuMessage=} severity
+     * @return {LH.Audit.Details.TableItem}
+     */
+    static findingToTableItem(finding: Finding, severity?: LH.IcuMessage | undefined): LH.Audit.Details.TableItem;
+    /**
+     * @param {Finding[][]} syntaxFindings
+     * @param {string[]} rawCsps
+     * @return {LH.Audit.Details.TableItem[]}
+     */
+    static constructSyntaxResults(syntaxFindings: Finding[][], rawCsps: string[]): LH.Audit.Details.TableItem[];
+    /**
+     * @param {string[]} cspHeaders
+     * @param {string[]} cspMetaTags
+     * @return {{score: number, results: LH.Audit.Details.TableItem[]}}
+     */
+    static constructResults(cspHeaders: string[], cspMetaTags: string[]): {
+        score: number;
+        results: LH.Audit.Details.TableItem[];
+    };
+    /**
+     * @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 description: string;
+    const noCsp: string;
+    const metaTagMessage: string;
+    const columnDirective: string;
+    const columnSeverity: string;
+    const itemSeveritySyntax: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=csp-xss.d.ts.map

package/core/audits/deprecations.d.ts

@@ -0,0 +1,19 @@
+export default Deprecations;
+declare class Deprecations extends Audit {
+    /**
+     * @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 displayValue: string;
+    const columnDeprecate: string;
+    const columnLine: string;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=deprecations.d.ts.map

package/core/audits/diagnostics.d.ts

@@ -0,0 +1,11 @@
+export default Diagnostics;
+declare class Diagnostics extends Audit {
+    /**
+     * @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>;
+}
+import { Audit } from "./audit.js";
+//# sourceMappingURL=diagnostics.d.ts.map

package/core/audits/dobetterweb/charset.d.ts

@@ -0,0 +1,19 @@
+export default CharsetDefined;
+declare class CharsetDefined extends Audit {
+    /**
+     * @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;
+}
+export const CHARSET_HTML_REGEX: RegExp;
+export const CHARSET_HTTP_REGEX: RegExp;
+export const IANA_REGEX: RegExp;
+import { Audit } from "../audit.js";
+//# sourceMappingURL=charset.d.ts.map

package/core/audits/dobetterweb/doctype.d.ts

@@ -0,0 +1,21 @@
+export default Doctype;
+declare class Doctype extends Audit {
+    /**
+     * @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 explanationNoDoctype: string;
+    const explanationWrongDoctype: string;
+    const explanationLimitedQuirks: string;
+    const explanationPublicId: string;
+    const explanationSystemId: string;
+    const explanationBadDoctype: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=doctype.d.ts.map

package/core/audits/dobetterweb/dom-size.d.ts

@@ -0,0 +1,26 @@
+export default DOMSize;
+declare class DOMSize extends Audit {
+    /**
+     * @return {LH.Audit.ScoreOptions}
+     */
+    static get defaultOptions(): import("../../../types/audit.js").default.ScoreOptions;
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @param {LH.Audit.Context} context
+     * @return {LH.Audit.Product}
+     */
+    static audit(artifacts: LH.Artifacts, context: LH.Audit.Context): LH.Audit.Product;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const columnStatistic: string;
+    const columnValue: string;
+    const displayValue: string;
+    const statisticDOMElements: string;
+    const statisticDOMDepth: string;
+    const statisticDOMWidth: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=dom-size.d.ts.map

package/core/audits/dobetterweb/geolocation-on-start.d.ts

@@ -0,0 +1,16 @@
+export default GeolocationOnStart;
+declare class GeolocationOnStart extends ViolationAudit {
+    /**
+     * @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;
+}
+import ViolationAudit from "../violation-audit.js";
+//# sourceMappingURL=geolocation-on-start.d.ts.map

package/core/audits/dobetterweb/inspector-issues.d.ts

@@ -0,0 +1,45 @@
+export default IssuesPanelEntries;
+export type IssueSubItem = {
+    url: string;
+};
+export type IssueItem = {
+    issueType: string | LH.IcuMessage;
+    subItems: Array<IssueSubItem>;
+};
+declare class IssuesPanelEntries extends Audit {
+    /**
+     * @param {Array<LH.Crdp.Audits.MixedContentIssueDetails>} mixedContentIssues
+     * @return {LH.Audit.Details.TableItem}
+     */
+    static getMixedContentRow(mixedContentIssues: Array<LH.Crdp.Audits.MixedContentIssueDetails>): LH.Audit.Details.TableItem;
+    /**
+     * @param {Array<LH.Crdp.Audits.CookieIssueDetails>} CookieIssues
+     * @return {LH.Audit.Details.TableItem}
+     */
+    static getCookieRow(CookieIssues: Array<LH.Crdp.Audits.CookieIssueDetails>): LH.Audit.Details.TableItem;
+    /**
+     * @param {Array<LH.Crdp.Audits.BlockedByResponseIssueDetails>} blockedByResponseIssues
+     * @return {LH.Audit.Details.TableItem}
+     */
+    static getBlockedByResponseRow(blockedByResponseIssues: Array<LH.Crdp.Audits.BlockedByResponseIssueDetails>): LH.Audit.Details.TableItem;
+    /**
+     * @param {Array<LH.Crdp.Audits.ContentSecurityPolicyIssueDetails>} cspIssues
+     * @return {LH.Audit.Details.TableItem}
+     */
+    static getContentSecurityPolicyRow(cspIssues: Array<LH.Crdp.Audits.ContentSecurityPolicyIssueDetails>): LH.Audit.Details.TableItem;
+    /**
+     * @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 columnIssueType: string;
+    const issueTypeBlockedByResponse: string;
+    const issueTypeHeavyAds: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=inspector-issues.d.ts.map