lighthouse 9.5.0-dev.20230117 → 9.5.0-dev.20230119

package/report/renderer/pwa-category-renderer.d.ts

@@ -0,0 +1,55 @@
+export class PwaCategoryRenderer extends CategoryRenderer {
+    /**
+     * Alters SVG id references so multiple instances of an SVG element can coexist
+     * in a single page. If `svgRoot` has a `<defs>` block, gives all elements defined
+     * in it unique ids, then updates id references (`<use xlink:href="...">`,
+     * `fill="url(#...)"`) to the altered ids in all descendents of `svgRoot`.
+     * @param {SVGElement} svgRoot
+     */
+    static _makeSvgReferencesUnique(svgRoot: SVGElement): void;
+    /**
+     * @param {LH.ReportResult.Category} category
+     * @param {Object<string, LH.Result.ReportGroup>} [groupDefinitions]
+     * @return {Element}
+     */
+    render(category: LH.ReportResult.Category, groupDefinitions?: {
+        [x: string]: import("../../types/lhr/lhr.js").default.ReportGroup;
+    } | undefined): Element;
+    /**
+     * @param {LH.ReportResult.Category} category
+     * @param {Record<string, LH.Result.ReportGroup>} groupDefinitions
+     * @return {DocumentFragment}
+     */
+    renderCategoryScore(category: LH.ReportResult.Category, groupDefinitions: Record<string, LH.Result.ReportGroup>): DocumentFragment;
+    /**
+     * Returns the group IDs found in auditRefs.
+     * @param {Array<LH.ReportResult.AuditRef>} auditRefs
+     * @return {!Set<string>}
+     */
+    _getGroupIds(auditRefs: Array<LH.ReportResult.AuditRef>): Set<string>;
+    /**
+     * Returns the group IDs whose audits are all considered passing.
+     * @param {Array<LH.ReportResult.AuditRef>} auditRefs
+     * @return {Set<string>}
+     */
+    _getPassingGroupIds(auditRefs: Array<LH.ReportResult.AuditRef>): Set<string>;
+    /**
+     * Returns a tooltip string summarizing group pass rates.
+     * @param {Array<LH.ReportResult.AuditRef>} auditRefs
+     * @param {Record<string, LH.Result.ReportGroup>} groupDefinitions
+     * @return {string}
+     */
+    _getGaugeTooltip(auditRefs: Array<LH.ReportResult.AuditRef>, groupDefinitions: Record<string, LH.Result.ReportGroup>): string;
+    /**
+     * Render non-manual audits in groups, giving a badge to any group that has
+     * all passing audits.
+     * @param {Array<LH.ReportResult.AuditRef>} auditRefs
+     * @param {Object<string, LH.Result.ReportGroup>} groupDefinitions
+     * @return {Element}
+     */
+    _renderAudits(auditRefs: Array<LH.ReportResult.AuditRef>, groupDefinitions: {
+        [x: string]: LH.Result.ReportGroup;
+    }): Element;
+}
+import { CategoryRenderer } from "./category-renderer.js";
+//# sourceMappingURL=pwa-category-renderer.d.ts.map

package/report/renderer/report-renderer.d.ts

@@ -0,0 +1,57 @@
+export class ReportRenderer {
+    /**
+     * @param {DOM} dom
+     */
+    constructor(dom: DOM);
+    /** @type {DOM} */
+    _dom: DOM;
+    /** @type {LH.Renderer.Options} */
+    _opts: LH.Renderer.Options;
+    /**
+     * @param {LH.Result} lhr
+     * @param {HTMLElement?} rootEl Report root element containing the report
+     * @param {LH.Renderer.Options=} opts
+     * @return {!Element}
+     */
+    renderReport(lhr: LH.Result, rootEl: HTMLElement | null, opts?: LH.Renderer.Options | undefined): Element;
+    /**
+     * @param {LH.ReportResult} report
+     * @return {DocumentFragment}
+     */
+    _renderReportTopbar(report: LH.ReportResult): DocumentFragment;
+    /**
+     * @return {DocumentFragment}
+     */
+    _renderReportHeader(): DocumentFragment;
+    /**
+     * @param {LH.ReportResult} report
+     * @return {DocumentFragment}
+     */
+    _renderReportFooter(report: LH.ReportResult): DocumentFragment;
+    /**
+     * @param {LH.ReportResult} report
+     * @param {DocumentFragment} footer
+     */
+    _renderMetaBlock(report: LH.ReportResult, footer: DocumentFragment): void;
+    /**
+     * Returns a div with a list of top-level warnings, or an empty div if no warnings.
+     * @param {LH.ReportResult} report
+     * @return {Node}
+     */
+    _renderReportWarnings(report: LH.ReportResult): Node;
+    /**
+     * @param {LH.ReportResult} report
+     * @param {CategoryRenderer} categoryRenderer
+     * @param {Record<string, CategoryRenderer>} specificCategoryRenderers
+     * @return {!DocumentFragment[]}
+     */
+    _renderScoreGauges(report: LH.ReportResult, categoryRenderer: CategoryRenderer, specificCategoryRenderers: Record<string, CategoryRenderer>): DocumentFragment[];
+    /**
+     * @param {LH.ReportResult} report
+     * @return {!DocumentFragment}
+     */
+    _renderReport(report: LH.ReportResult): DocumentFragment;
+}
+export type DOM = import('./dom.js').DOM;
+import { CategoryRenderer } from "./category-renderer.js";
+//# sourceMappingURL=report-renderer.d.ts.map

package/report/renderer/report-ui-features.d.ts

@@ -0,0 +1,71 @@
+export class ReportUIFeatures {
+    /**
+     * @param {DOM} dom
+     * @param {LH.Renderer.Options} opts
+     */
+    constructor(dom: DOM, opts?: LH.Renderer.Options);
+    /** @type {LH.Result} */
+    json: LH.Result;
+    /** @type {DOM} */
+    _dom: DOM;
+    _opts: import("../types/report-renderer.js").default.Options;
+    _topbar: TopbarFeatures | null;
+    /**
+     * Handle media query change events.
+     * @param {MediaQueryList|MediaQueryListEvent} mql
+     */
+    onMediaQueryChange(mql: MediaQueryList | MediaQueryListEvent): void;
+    /**
+     * Adds tools button, print, and other functionality to the report. The method
+     * should be called whenever the report needs to be re-rendered.
+     * @param {LH.Result} lhr
+     */
+    initFeatures(lhr: LH.Result): void;
+    _fullPageScreenshot: import("../../types/lhr/lhr.js").default.FullPageScreenshot | undefined;
+    /**
+     * @param {{text: string, icon?: string, onClick: () => void}} opts
+     */
+    addButton(opts: {
+        text: string;
+        icon?: string;
+        onClick: () => void;
+    }): HTMLButtonElement | undefined;
+    resetUIState(): void;
+    /**
+     * Returns the html that recreates this report.
+     * @return {string}
+     */
+    getReportHtml(): string;
+    /**
+     * Save json as a gist. Unimplemented in base UI features.
+     */
+    saveAsGist(): void;
+    _enableFireworks(): void;
+    _setupMediaQueryListeners(): void;
+    /**
+     * Resets the state of page before capturing the page for export.
+     * When the user opens the exported HTML page, certain UI elements should
+     * be in their closed state (not opened) and the templates should be unstamped.
+     */
+    _resetUIState(): void;
+    _setupThirdPartyFilter(): void;
+    /**
+     * @param {Element} rootEl
+     */
+    _setupElementScreenshotOverlay(rootEl: Element): void;
+    /**
+     * From a table with URL entries, finds the rows containing third-party URLs
+     * and returns them.
+     * @param {HTMLElement[]} rowEls
+     * @param {string} finalDisplayedUrl
+     * @return {Array<HTMLElement>}
+     */
+    _getThirdPartyRows(rowEls: HTMLElement[], finalDisplayedUrl: string): Array<HTMLElement>;
+    /**
+     * @param {Blob|File} blob
+     */
+    _saveFile(blob: Blob | File): void;
+}
+export type DOM = import('./dom').DOM;
+import { TopbarFeatures } from "./topbar-features.js";
+//# sourceMappingURL=report-ui-features.d.ts.map

package/report/renderer/snippet-renderer.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Render snippet of text with line numbers and annotations.
+ * By default we only show a few lines around each annotation and the user
+ * can click "Expand snippet" to show more.
+ * Content lines with annotations are highlighted.
+ */
+export class SnippetRenderer {
+    /**
+     * @param {DOM} dom
+     * @param {LH.Audit.Details.SnippetValue} details
+     * @param {DetailsRenderer} detailsRenderer
+     * @param {function} toggleExpandedFn
+     * @return {DocumentFragment}
+     */
+    static renderHeader(dom: DOM, details: LH.Audit.Details.SnippetValue, detailsRenderer: DetailsRenderer, toggleExpandedFn: Function): DocumentFragment;
+    /**
+     * Renders a line (text content, message, or placeholder) as a DOM element.
+     * @param {DOM} dom
+     * @param {DocumentFragment} tmpl
+     * @param {LineDetails} lineDetails
+     * @return {Element}
+     */
+    static renderSnippetLine(dom: DOM, tmpl: DocumentFragment, { content, lineNumber, truncated, contentType, visibility }: LineDetails): Element;
+    /**
+     * @param {DOM} dom
+     * @param {DocumentFragment} tmpl
+     * @param {{message: string}} message
+     * @return {Element}
+     */
+    static renderMessage(dom: DOM, tmpl: DocumentFragment, message: {
+        message: string;
+    }): Element;
+    /**
+     * @param {DOM} dom
+     * @param {DocumentFragment} tmpl
+     * @param {LineVisibility} visibility
+     * @return {Element}
+     */
+    static renderOmittedLinesPlaceholder(dom: DOM, tmpl: DocumentFragment, visibility: LineVisibility): Element;
+    /**
+     * @param {DOM} dom
+     * @param {DocumentFragment} tmpl
+     * @param {LH.Audit.Details.SnippetValue} details
+     * @return {DocumentFragment}
+     */
+    static renderSnippetContent(dom: DOM, tmpl: DocumentFragment, details: LH.Audit.Details.SnippetValue): DocumentFragment;
+    /**
+     * @param {DOM} dom
+     * @param {DocumentFragment} tmpl
+     * @param {LH.Audit.Details.SnippetValue} details
+     * @return {DocumentFragment}
+     */
+    static renderSnippetLines(dom: DOM, tmpl: DocumentFragment, details: LH.Audit.Details.SnippetValue): DocumentFragment;
+    /**
+     * @param {DOM} dom
+     * @param {LH.Audit.Details.SnippetValue} details
+     * @param {DetailsRenderer} detailsRenderer
+     * @return {!Element}
+     */
+    static render(dom: DOM, details: LH.Audit.Details.SnippetValue, detailsRenderer: DetailsRenderer): Element;
+}
+export type DetailsRenderer = import('./details-renderer').DetailsRenderer;
+export type DOM = import('./dom').DOM;
+export type LineDetails = {
+    content: string;
+    lineNumber: string | number;
+    contentType: LineContentType;
+    truncated?: boolean;
+    visibility?: LineVisibility;
+};
+type LineVisibility = number;
+declare namespace LineVisibility {
+    const ALWAYS: number;
+    const WHEN_COLLAPSED: number;
+    const WHEN_EXPANDED: number;
+}
+type LineContentType = number;
+declare namespace LineContentType {
+    const CONTENT_NORMAL: number;
+    const CONTENT_HIGHLIGHTED: number;
+    const PLACEHOLDER: number;
+    const MESSAGE: number;
+}
+export {};
+//# sourceMappingURL=snippet-renderer.d.ts.map

package/report/renderer/swap-locale-feature.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @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.
+ */
+/**
+ * @fileoverview Creates a <select> element, filled with all supported locales
+ */
+/** @typedef {import('./dom.js').DOM} DOM */
+/** @typedef {import('./report-ui-features').ReportUIFeatures} ReportUIFeatures */
+export class SwapLocaleFeature {
+    /**
+     * @param {ReportUIFeatures} reportUIFeatures
+     * @param {DOM} dom
+     * @param {{onLocaleSelected: (localeModuleName: LH.Locale) => Promise<void>}} callbacks
+     *        Specifiy the URL where the i18n module script can be found, and the URLS for the locale JSON files.
+     */
+    constructor(reportUIFeatures: ReportUIFeatures, dom: DOM, callbacks: {
+        onLocaleSelected: (localeModuleName: LH.Locale) => Promise<void>;
+    });
+    _reportUIFeatures: import("./report-ui-features").ReportUIFeatures;
+    _dom: import("./dom.js").DOM;
+    _localeSelectedCallback: (localeModuleName: LH.Locale) => Promise<void>;
+    /**
+     * @param {Array<LH.Locale>} locales
+     */
+    enable(locales: Array<LH.Locale>): void;
+}
+export type DOM = import('./dom.js').DOM;
+export type ReportUIFeatures = import('./report-ui-features').ReportUIFeatures;
+//# sourceMappingURL=swap-locale-feature.d.ts.map

package/report/renderer/text-encoding.d.ts

@@ -0,0 +1,26 @@
+export namespace TextEncoding {
+    export { toBase64 };
+    export { fromBase64 };
+}
+/**
+ * Takes an UTF-8 string and returns a base64 encoded string.
+ * If gzip is true, the UTF-8 bytes are gzipped before base64'd, using
+ * CompressionStream (currently only in Chrome), falling back to pako
+ * (which is only used to encode in our Node tests).
+ * @param {string} string
+ * @param {{gzip: boolean}} options
+ * @return {Promise<string>}
+ */
+declare function toBase64(string: string, options: {
+    gzip: boolean;
+}): Promise<string>;
+/**
+ * @param {string} encoded
+ * @param {{gzip: boolean}} options
+ * @return {string}
+ */
+declare function fromBase64(encoded: string, options: {
+    gzip: boolean;
+}): string;
+export {};
+//# sourceMappingURL=text-encoding.d.ts.map

package/report/renderer/topbar-features.d.ts

@@ -0,0 +1,82 @@
+export class TopbarFeatures {
+    /**
+     * @param {ReportUIFeatures} reportUIFeatures
+     * @param {DOM} dom
+     */
+    constructor(reportUIFeatures: ReportUIFeatures, dom: DOM);
+    /** @type {LH.Result} */
+    lhr: LH.Result;
+    _reportUIFeatures: import("./report-ui-features").ReportUIFeatures;
+    _dom: import("./dom.js").DOM;
+    _dropDownMenu: DropDownMenu;
+    _copyAttempt: boolean;
+    /** @type {HTMLElement} */
+    topbarEl: HTMLElement;
+    /** @type {HTMLElement} */
+    categoriesEl: HTMLElement;
+    /** @type {HTMLElement?} */
+    stickyHeaderEl: HTMLElement | null;
+    /** @type {HTMLElement} */
+    highlightEl: HTMLElement;
+    /**
+     * Handler for tool button.
+     * @param {Event} e
+     */
+    onDropDownMenuClick(e: Event): void;
+    /**
+     * Keyup handler for the document.
+     * @param {KeyboardEvent} e
+     */
+    onKeyUp(e: KeyboardEvent): void;
+    /**
+     * Handle copy events.
+     * @param {ClipboardEvent} e
+     */
+    onCopy(e: ClipboardEvent): void;
+    /**
+     * Collapses all audit `<details>`.
+     * open a `<details>` element.
+     */
+    collapseAllDetails(): void;
+    /**
+     * @param {LH.Result} lhr
+     */
+    enable(lhr: LH.Result): void;
+    /**
+     * Copies the report JSON to the clipboard (if supported by the browser).
+     */
+    onCopyButtonClick(): void;
+    /**
+     * Expands all audit `<details>`.
+     * Ideally, a print stylesheet could take care of this, but CSS has no way to
+     * open a `<details>` element.
+     */
+    expandAllDetails(): void;
+    _print(): void;
+    /**
+     * Resets the state of page before capturing the page for export.
+     * When the user opens the exported HTML page, certain UI elements should
+     * be in their closed state (not opened) and the templates should be unstamped.
+     */
+    resetUIState(): void;
+    /**
+     * Finds the first scrollable ancestor of `element`. Falls back to the document.
+     * @param {Element} element
+     * @return {Element | Document}
+     */
+    _getScrollParent(element: Element): Element | Document;
+    /**
+     * Sets up listeners to collapse audit `<details>` when the user closes the
+     * print dialog, all `<details>` are collapsed.
+     */
+    _setUpCollapseDetailsAfterPrinting(): void;
+    _setupStickyHeader(): void;
+    /**
+     * Toggle visibility and update highlighter position
+     */
+    _updateStickyHeader(): void;
+}
+export type DOM = import('./dom.js').DOM;
+export type ReportUIFeatures = import('./report-ui-features').ReportUIFeatures;
+import { DropDownMenu } from "./drop-down-menu.js";
+//# sourceMappingURL=topbar-features.d.ts.map

package/report/renderer/util.d.ts

@@ -0,0 +1,230 @@
+export type I18n<T> = import('./i18n').I18n<T>;
+export class Util {
+    /** @type {I18n<typeof UIStrings>} */
+    static i18n: I18n<typeof UIStrings>;
+    static get PASS_THRESHOLD(): number;
+    static get MS_DISPLAY_VALUE(): string;
+    /**
+     * If LHR is older than 10.0 it will not have the `finalDisplayedUrl` property.
+     * Old LHRs should have the `finalUrl` property which will work fine for the report.
+     *
+     * @param {LH.Result} lhr
+     */
+    static getFinalDisplayedUrl(lhr: LH.Result): string;
+    /**
+     * If LHR is older than 10.0 it will not have the `mainDocumentUrl` property.
+     * Old LHRs should have the `finalUrl` property which is the same as `mainDocumentUrl`.
+     *
+     * @param {LH.Result} lhr
+     */
+    static getMainDocumentUrl(lhr: LH.Result): string | undefined;
+    /**
+     * Returns a new LHR that's reshaped for slightly better ergonomics within the report rendereer.
+     * Also, sets up the localized UI strings used within renderer and makes changes to old LHRs to be
+     * compatible with current renderer.
+     * The LHR passed in is not mutated.
+     * TODO(team): we all agree the LHR shape change is technical debt we should fix
+     * @param {LH.Result} result
+     * @return {LH.ReportResult}
+     */
+    static prepareReportResult(result: LH.Result): LH.ReportResult;
+    /**
+     * @param {LH.Result} lhr
+     * @return {LH.Result.FullPageScreenshot=}
+     */
+    static getFullPageScreenshot(lhr: LH.Result): LH.Result.FullPageScreenshot | undefined;
+    /**
+     * Used to determine if the "passed" for the purposes of showing up in the "failed" or "passed"
+     * sections of the report.
+     *
+     * @param {{score: (number|null), scoreDisplayMode: string}} audit
+     * @return {boolean}
+     */
+    static showAsPassed(audit: {
+        score: (number | null);
+        scoreDisplayMode: string;
+    }): boolean;
+    /**
+     * Convert a score to a rating label.
+     * TODO: Return `'error'` for `score === null && !scoreDisplayMode`.
+     *
+     * @param {number|null} score
+     * @param {string=} scoreDisplayMode
+     * @return {string}
+     */
+    static calculateRating(score: number | null, scoreDisplayMode?: string | undefined): string;
+    /**
+     * Split a string by markdown code spans (enclosed in `backticks`), splitting
+     * into segments that were enclosed in backticks (marked as `isCode === true`)
+     * and those that outside the backticks (`isCode === false`).
+     * @param {string} text
+     * @return {Array<{isCode: true, text: string}|{isCode: false, text: string}>}
+     */
+    static splitMarkdownCodeSpans(text: string): Array<{
+        isCode: true;
+        text: string;
+    } | {
+        isCode: false;
+        text: string;
+    }>;
+    /**
+     * Split a string on markdown links (e.g. [some link](https://...)) into
+     * segments of plain text that weren't part of a link (marked as
+     * `isLink === false`), and segments with text content and a URL that did make
+     * up a link (marked as `isLink === true`).
+     * @param {string} text
+     * @return {Array<{isLink: true, text: string, linkHref: string}|{isLink: false, text: string}>}
+     */
+    static splitMarkdownLink(text: string): Array<{
+        isLink: true;
+        text: string;
+        linkHref: string;
+    } | {
+        isLink: false;
+        text: string;
+    }>;
+    /**
+     * @param {URL} parsedUrl
+     * @param {{numPathParts?: number, preserveQuery?: boolean, preserveHost?: boolean}=} options
+     * @return {string}
+     */
+    static getURLDisplayName(parsedUrl: URL, options?: {
+        numPathParts?: number | undefined;
+        preserveQuery?: boolean | undefined;
+        preserveHost?: boolean | undefined;
+    } | undefined): string;
+    /**
+     * Split a URL into a file, hostname and origin for easy display.
+     * @param {string} url
+     * @return {{file: string, hostname: string, origin: string}}
+     */
+    static parseURL(url: string): {
+        file: string;
+        hostname: string;
+        origin: string;
+    };
+    /**
+     * @param {string|URL} value
+     * @return {!URL}
+     */
+    static createOrReturnURL(value: string | URL): URL;
+    /**
+     * Gets the tld of a domain
+     *
+     * @param {string} hostname
+     * @return {string} tld
+     */
+    static getTld(hostname: string): string;
+    /**
+     * Returns a primary domain for provided hostname (e.g. www.example.com -> example.com).
+     * @param {string|URL} url hostname or URL object
+     * @return {string}
+     */
+    static getRootDomain(url: string | URL): string;
+    /**
+     * @param {LH.Result['configSettings']} settings
+     * @return {!{deviceEmulation: string, screenEmulation?: string, networkThrottling: string, cpuThrottling: string, summary: string}}
+     */
+    static getEmulationDescriptions(settings: LH.Result['configSettings']): {
+        deviceEmulation: string;
+        screenEmulation?: string | undefined;
+        networkThrottling: string;
+        cpuThrottling: string;
+        summary: string;
+    };
+    /**
+     * Returns only lines that are near a message, or the first few lines if there are
+     * no line messages.
+     * @param {LH.Audit.Details.SnippetValue['lines']} lines
+     * @param {LH.Audit.Details.SnippetValue['lineMessages']} lineMessages
+     * @param {number} surroundingLineCount Number of lines to include before and after
+     * the message. If this is e.g. 2 this function might return 5 lines.
+     */
+    static filterRelevantLines(lines: LH.Audit.Details.SnippetValue['lines'], lineMessages: LH.Audit.Details.SnippetValue['lineMessages'], surroundingLineCount: number): {
+        content: string;
+        lineNumber: number;
+        truncated?: boolean | undefined;
+    }[];
+    /**
+     * @param {string} categoryId
+     */
+    static isPluginCategory(categoryId: string): boolean;
+    /**
+     * @param {LH.Result.GatherMode} gatherMode
+     */
+    static shouldDisplayAsFraction(gatherMode: LH.Result.GatherMode): boolean;
+    /**
+     * @param {LH.ReportResult.Category} category
+     */
+    static calculateCategoryFraction(category: LH.ReportResult.Category): {
+        numPassed: number;
+        numPassableAudits: number;
+        numInformative: number;
+        totalWeight: number;
+    };
+}
+export namespace Util {
+    export const reportJson: LH.ReportResult | null;
+    /**
+     * An always-increasing counter for making unique SVG ID suffixes.
+     */
+    export function getUniqueSuffix(): number;
+    export function resetUniqueSuffix(): void;
+    export { UIStrings };
+}
+export namespace UIStrings {
+    const varianceDisclaimer: string;
+    const calculatorLink: string;
+    const showRelevantAudits: string;
+    const opportunityResourceColumnLabel: string;
+    const opportunitySavingsColumnLabel: string;
+    const errorMissingAuditInfo: string;
+    const errorLabel: string;
+    const warningHeader: string;
+    const warningAuditsGroupTitle: string;
+    const passedAuditsGroupTitle: string;
+    const notApplicableAuditsGroupTitle: string;
+    const manualAuditsGroupTitle: string;
+    const toplevelWarningsMessage: string;
+    const crcInitialNavigation: string;
+    const crcLongestDurationLabel: string;
+    const snippetExpandButtonLabel: string;
+    const snippetCollapseButtonLabel: string;
+    const lsPerformanceCategoryDescription: string;
+    const labDataTitle: string;
+    const thirdPartyResourcesLabel: string;
+    const viewTreemapLabel: string;
+    const viewTraceLabel: string;
+    const viewOriginalTraceLabel: string;
+    const dropdownPrintSummary: string;
+    const dropdownPrintExpanded: string;
+    const dropdownCopyJSON: string;
+    const dropdownSaveHTML: string;
+    const dropdownSaveJSON: string;
+    const dropdownViewer: string;
+    const dropdownSaveGist: string;
+    const dropdownDarkTheme: string;
+    const runtimeSettingsDevice: string;
+    const runtimeSettingsNetworkThrottling: string;
+    const runtimeSettingsCPUThrottling: string;
+    const runtimeSettingsUANetwork: string;
+    const runtimeSettingsBenchmark: string;
+    const runtimeSettingsAxeVersion: string;
+    const runtimeSettingsScreenEmulation: string;
+    const footerIssue: string;
+    const runtimeNoEmulation: string;
+    const runtimeMobileEmulation: string;
+    const runtimeDesktopEmulation: string;
+    const runtimeUnknown: string;
+    const runtimeSingleLoad: string;
+    const runtimeAnalysisWindow: string;
+    const runtimeSingleLoadTooltip: string;
+    const throttlingProvided: string;
+    const show: string;
+    const hide: string;
+    const expandView: string;
+    const collapseView: string;
+    const runtimeSlow4g: string;
+    const runtimeCustom: string;
+}
+//# sourceMappingURL=util.d.ts.map

package/report/test/generator/report-generator-test.js

@@ -106,7 +106,7 @@ describe('ReportGenerator', () => {
 \\"http://localhost:10200/dobetterweb/dbw_tester.html\\",\\"http://localhost:10200/dobetterweb/dbw_tester.html\\",\\"2021-09-07T20:11:11.853Z\\",\\"navigation\\"
 
 category,score
-\\"performance\\",\\"0.26\\"
+\\"performance\\",\\"0.3\\"
 \\"accessibility\\",\\"0.77\\"
 \\"best-practices\\",\\"0.25\\"
 \\"seo\\",\\"0.67\\"
@@ -114,9 +114,9 @@ category,score
 
 category,audit,score,displayValue,description
 \\"performance\\",\\"first-contentful-paint\\",\\"0.01\\",\\"6.8 s\\",\\"First Contentful Paint marks the time at which the first text or image is painted. [Learn more about the First Contentful Paint metric](https://developer.chrome.com/docs/lighthouse/performance/first-contentful-paint/).\\"
-\\"performance\\",\\"interactive\\",\\"0.41\\",\\"8.2 s\\",\\"Time to Interactive is the amount of time it takes for the page to become fully interactive. [Learn more about the Time to Interactive metric](https://developer.chrome.com/docs/lighthouse/performance/interactive/).\\"
-\\"performance\\",\\"speed-index\\",\\"0.21\\",\\"8.1 s\\",\\"Speed Index shows how quickly the contents of a page are visibly populated. [Learn more about the Speed Index metric](https://developer.chrome.com/docs/lighthouse/performance/speed-index/).\\"
+\\"performance\\",\\"largest-contentful-paint\\",\\"0.07\\",\\"6.8 s\\",\\"Largest Contentful Paint marks the time at which the largest text or image is painted. [Learn more about the Largest Contentful Paint metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-largest-contentful-paint/)\\"
 \\"performance\\",\\"total-blocking-time\\",\\"0.2\\",\\"1,220 ms\\",\\"Sum of all time periods between FCP and Time to Interactive, when task length exceeded 50ms, expressed in milliseconds. [Learn more about the Total Blocking Time metric](https://developer.chrome.com/docs/lighthouse/performance/lighthouse-total-blocking-time/).\\"
+\\"performance\\",\\"cumulative-layout-shift\\",\\"0.8\\",\\"0.136\\",\\"Cumulative Layout Shift measures the movement of visible elements within the viewport. [Learn more about the Cumulative Layout Shift metric](https://web.dev/cls/).\\"
 "
 `);