lighthouse 9.6.7 → 10.0.0-dev.20230209

package/core/audits/dobetterweb/doctype.js

@@ -0,0 +1,120 @@
+/**
+ * @license Copyright 2018 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.
+ */
+
+import {Audit} from '../audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that provides detail on the doctype of a page. This descriptive title is shown to users when the pages's doctype is set to HTML. */
+  title: 'Page has the HTML doctype',
+  /** Title of a Lighthouse audit that provides detail on the doctype of a page. This descriptive title is shown to users when the page's doctype is not set to HTML. */
+  failureTitle: 'Page lacks the HTML doctype, thus triggering quirks-mode',
+  /** Description of a Lighthouse audit that tells the user why they should define an HTML doctype. This is displayed after a user expands the section to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Specifying a doctype prevents the browser ' +
+    'from switching to quirks-mode. ' +
+    '[Learn more about the doctype declaration](https://developer.chrome.com/docs/lighthouse/best-practices/doctype/).',
+  /** Explanatory message stating that the document has no doctype. */
+  explanationNoDoctype: 'Document must contain a doctype',
+  /** Explanatory message stating that the document has wrong doctype that triggers `quirks-mode` */
+  explanationWrongDoctype: 'Document contains a `doctype` that triggers `quirks-mode`',
+  /** Explanatory message stating that the document has wrong doctype that triggers `limited-quirks-mode` */
+  explanationLimitedQuirks: 'Document contains a `doctype` that triggers `limited-quirks-mode`',
+  /** Explanatory message stating that the publicId field is not empty. */
+  explanationPublicId: 'Expected publicId to be an empty string',
+  /** Explanatory message stating that the systemId field is not empty. */
+  explanationSystemId: 'Expected systemId to be an empty string',
+  /** Explanatory message stating that the doctype is set, but is not "html" and is therefore invalid. */
+  explanationBadDoctype: 'Doctype name must be the string `html`',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class Doctype extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'doctype',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['Doctype'],
+      __internalOptionalArtifacts: ['InspectorIssues'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {LH.Audit.Product}
+   */
+  static audit(artifacts) {
+    if (!artifacts.Doctype) {
+      return {
+        score: 0,
+        explanation: str_(UIStrings.explanationNoDoctype),
+      };
+    }
+
+    // only set constants once we know there is a doctype
+    const doctypeName = artifacts.Doctype.name;
+    const doctypePublicId = artifacts.Doctype.publicId;
+    const doctypeSystemId = artifacts.Doctype.systemId;
+    const compatMode = artifacts.Doctype.documentCompatMode;
+    const quirksModeIssues = artifacts.InspectorIssues?.quirksModeIssue || [];
+
+    // Can only determine limited quirks mode with some helps from the protocol via
+    // inspector issues. But cannot get inspector issues in snapshot mode, so in that
+    // case we cannot distinguish no-quirks-mode from limited-quirks-mode.
+    const isLimitedQuirksMode = quirksModeIssues.some(issue => issue.isLimitedQuirksMode);
+
+    if (compatMode === 'CSS1Compat' && !isLimitedQuirksMode) {
+      return {
+        score: 1,
+      };
+    }
+
+    if (isLimitedQuirksMode) {
+      return {
+        score: 0,
+        explanation: str_(UIStrings.explanationLimitedQuirks),
+      };
+    }
+
+    if (doctypePublicId !== '') {
+      return {
+        score: 0,
+        explanation: str_(UIStrings.explanationPublicId),
+      };
+    }
+
+    if (doctypeSystemId !== '') {
+      return {
+        score: 0,
+        explanation: str_(UIStrings.explanationSystemId),
+      };
+    }
+
+    /* Note that the casing of this property is normalized to be lowercase.
+       see: https://html.spec.whatwg.org/#doctype-name-state */
+    if (doctypeName !== 'html') {
+      return {
+        score: 0,
+        explanation: str_(UIStrings.explanationBadDoctype),
+      };
+    }
+
+    // Catch-all for any quirks-mode situations the above checks didn't get.
+    // https://github.com/GoogleChrome/lighthouse/issues/10030
+    return {
+      score: 0,
+      explanation: str_(UIStrings.explanationWrongDoctype),
+    };
+  }
+}
+
+export default Doctype;
+export {UIStrings};

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/dom-size.js

@@ -0,0 +1,134 @@
+/**
+ * @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.
+ */
+
+/**
+ * @fileoverview Audits a page to see how the size of DOM it creates. Stats like
+ * tree depth, # children, and total elements are returned. The score is calculated
+ * based solely on the total number of elements found on the page.
+ */
+
+
+import {Audit} from '../audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a diagnostic audit that provides detail on the size of the web page's DOM. The size of a DOM is characterized by the total number of DOM elements and greatest DOM depth. This descriptive title is shown to users when the amount is acceptable and no user action is required. */
+  title: 'Avoids an excessive DOM size',
+  /** Title of a diagnostic audit that provides detail on the size of the web page's DOM. The size of a DOM is characterized by the total number of DOM elements and greatest DOM depth. This imperative title is shown to users when there is a significant amount of execution time that could be reduced. */
+  failureTitle: 'Avoid an excessive DOM size',
+  /** Description of a Lighthouse audit that tells the user *why* they should reduce the size of the web page's DOM. The size of a DOM is characterized by the total number of DOM elements and greatest DOM depth. This is displayed after a user expands the section to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'A large DOM will increase memory usage, cause longer ' +
+    '[style calculations](https://developers.google.com/web/fundamentals/performance/rendering/reduce-the-scope-and-complexity-of-style-calculations), ' +
+    'and produce costly [layout reflows](https://developers.google.com/speed/articles/reflow). [Learn how to avoid an excessive DOM size](https://developer.chrome.com/docs/lighthouse/performance/dom-size/).',
+  /** Table column header for the type of statistic. These statistics describe how big the DOM is (count of DOM elements, children, depth). */
+  columnStatistic: 'Statistic',
+  /** Table column header for the observed value of the DOM statistic. */
+  columnValue: 'Value',
+  /** [ICU Syntax] Label for an audit identifying the number of DOM elements found in the page. */
+  displayValue: `{itemCount, plural,
+    =1 {1 element}
+    other {# elements}
+    }`,
+  /** Label for the total number of DOM elements found in the page. */
+  statisticDOMElements: 'Total DOM Elements',
+  /** Label for the numeric value of the maximum depth in the page's DOM tree. */
+  statisticDOMDepth: 'Maximum DOM Depth',
+  /** Label for the numeric value of the maximum number of children any DOM element in the page has. The element described will have the most children in the page. */
+  statisticDOMWidth: 'Maximum Child Elements',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class DOMSize extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'dom-size',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      scoreDisplayMode: Audit.SCORING_MODES.NUMERIC,
+      requiredArtifacts: ['DOMStats'],
+    };
+  }
+
+  /**
+   * @return {LH.Audit.ScoreOptions}
+   */
+  static get defaultOptions() {
+    return {
+      // https://bigquery.cloud.google.com/table/httparchive:lighthouse.2018_04_01_mobile?pli=1
+      // see https://www.desmos.com/calculator/tsunbwqt3f
+      p10: 818,
+      median: 1400,
+    };
+  }
+
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {LH.Audit.Product}
+   */
+  static audit(artifacts, context) {
+    const stats = artifacts.DOMStats;
+
+    const score = Audit.computeLogNormalScore(
+      {p10: context.options.p10, median: context.options.median},
+      stats.totalBodyElements
+    );
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'statistic', valueType: 'text', label: str_(UIStrings.columnStatistic)},
+      {key: 'node', valueType: 'node', label: str_(i18n.UIStrings.columnElement)},
+      {key: 'value', valueType: 'numeric', label: str_(UIStrings.columnValue)},
+    ];
+
+    /** @type {LH.Audit.Details.Table['items']} */
+    const items = [
+      {
+        statistic: str_(UIStrings.statisticDOMElements),
+        value: {
+          type: 'numeric',
+          granularity: 1,
+          value: stats.totalBodyElements,
+        },
+      },
+      {
+        node: Audit.makeNodeItem(stats.depth),
+        statistic: str_(UIStrings.statisticDOMDepth),
+        value: {
+          type: 'numeric',
+          granularity: 1,
+          value: stats.depth.max,
+        },
+      },
+      {
+        node: Audit.makeNodeItem(stats.width),
+        statistic: str_(UIStrings.statisticDOMWidth),
+        value: {
+          type: 'numeric',
+          granularity: 1,
+          value: stats.width.max,
+        },
+      },
+    ];
+
+    return {
+      score,
+      numericValue: stats.totalBodyElements,
+      numericUnit: 'element',
+      displayValue: str_(UIStrings.displayValue, {itemCount: stats.totalBodyElements}),
+      details: Audit.makeTableDetails(headings, items),
+    };
+  }
+}
+
+export default DOMSize;
+export {UIStrings};

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/geolocation-on-start.js

@@ -0,0 +1,69 @@
+/**
+ * @license Copyright 2016 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 Audits a page to see if it is requesting the geolocation API on
+ * page load. This is often a sign of poor user experience because it lacks context.
+ */
+
+
+import ViolationAudit from '../violation-audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that provides detail on geolocation permission requests while the page is loading. This descriptive title is shown to users when the page does not ask for geolocation permissions on load. */
+  title: 'Avoids requesting the geolocation permission on page load',
+  /** Title of a Lighthouse audit that provides detail on geolocation permissions requests. This descriptive title is shown to users when the page does ask for geolocation permissions on load. */
+  failureTitle: 'Requests the geolocation permission on page load',
+  /** Description of a Lighthouse audit that tells the user why they should not ask for geolocation permissions on load. This is displayed after a user expands the section to see more. No character length limits. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Users are mistrustful of or confused by sites that request their ' +
+    'location without context. Consider tying the request to a user action instead. ' +
+    '[Learn more about the geolocation permission](https://developer.chrome.com/docs/lighthouse/best-practices/geolocation-on-start/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class GeolocationOnStart extends ViolationAudit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'geolocation-on-start',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      supportedModes: ['navigation'],
+      requiredArtifacts: ['ConsoleMessages', 'SourceMaps', 'Scripts'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    // 'Only request geolocation information in response to a user gesture.'
+    const results = await ViolationAudit.getViolationResults(artifacts, context, /geolocation/);
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'source', valueType: 'source-location', label: str_(i18n.UIStrings.columnSource)},
+    ];
+    // TODO(bckenny): there should actually be a ts error here. results[0].stackTrace
+    // should violate the results type. Shouldn't be removed from details items regardless.
+    const details = ViolationAudit.makeTableDetails(headings, results);
+
+    return {
+      score: Number(results.length === 0),
+      details,
+    };
+  }
+}
+
+export default GeolocationOnStart;
+export {UIStrings};

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

package/core/audits/dobetterweb/inspector-issues.js

@@ -0,0 +1,191 @@
+/**
+ * @license Copyright 2020 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 Audits a page to determine whether it generates issues in the Issues panel of Chrome Devtools.
+ * The audit is meant to maintain parity with the Chrome Devtools Issues panel front end.
+ * https://source.chromium.org/chromium/chromium/src/+/main:third_party/devtools-frontend/src/front_end/sdk/
+ */
+
+
+/** @typedef {{url: string}} IssueSubItem */
+/** @typedef {{issueType: string|LH.IcuMessage, subItems: Array<IssueSubItem>}} IssueItem */
+
+import {Audit} from '../audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that provides detail on various types of problems with a website, like security or network errors. This descriptive title is shown to users when no issues were logged into the Chrome DevTools Issues panel. */
+  title: 'No issues in the `Issues` panel in Chrome Devtools',
+  /** Title of a Lighthouse audit that provides detail on various types of problems with a website, like security or network errors. This descriptive title is shown to users when issues are detected and logged into the Chrome DevTools Issues panel. */
+  failureTitle: 'Issues were logged in the `Issues` panel in Chrome Devtools',
+  /* eslint-disable max-len */
+  /** Description of a Lighthouse audit that tells the user why issues being logged to the Chrome DevTools Issues panel are a cause for concern and so should be fixed. This is displayed after a user expands the section to see more. No character length limits. */
+  description: 'Issues logged to the `Issues` panel in Chrome Devtools indicate unresolved problems. They can come from network request failures, insufficient security controls, and other browser concerns. Open up the Issues panel in Chrome DevTools for more details on each issue.',
+  /* eslint-enable max-len */
+  /** Table column header for the types of problems observed in a website, like security or network errors. */
+  columnIssueType: 'Issue type',
+  /** The type of an Issue in Chrome DevTools when a resource is blocked due to the website's cross-origin policy. */
+  issueTypeBlockedByResponse: 'Blocked by cross-origin policy',
+  /** The type of an Issue in Chrome DevTools when a site has large ads that use up a lot of the browser's resources. */
+  issueTypeHeavyAds: 'Heavy resource usage by ads',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class IssuesPanelEntries extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'inspector-issues',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['InspectorIssues'],
+    };
+  }
+
+  /**
+   * @param {Array<LH.Crdp.Audits.MixedContentIssueDetails>} mixedContentIssues
+   * @return {LH.Audit.Details.TableItem}
+   */
+  static getMixedContentRow(mixedContentIssues) {
+    const requestUrls = new Set();
+    for (const issue of mixedContentIssues) {
+      const requestUrl = issue.request?.url || issue.mainResourceURL;
+      requestUrls.add(requestUrl);
+    }
+    return {
+      issueType: 'Mixed content',
+      subItems: {
+        type: 'subitems',
+        items: Array.from(requestUrls).map(url => ({url})),
+      },
+    };
+  }
+
+  /**
+   * @param {Array<LH.Crdp.Audits.CookieIssueDetails>} CookieIssues
+   * @return {LH.Audit.Details.TableItem}
+   */
+  static getCookieRow(CookieIssues) {
+    const requestUrls = new Set();
+    for (const issue of CookieIssues) {
+      const requestUrl = (issue.request?.url) || issue.cookieUrl;
+      if (requestUrl) {
+        requestUrls.add(requestUrl);
+      }
+    }
+    return {
+      issueType: 'Cookie',
+      subItems: {
+        type: 'subitems',
+        items: Array.from(requestUrls).map(url => {
+          return {
+            url,
+          };
+        }),
+      },
+    };
+  }
+
+  /**
+   * @param {Array<LH.Crdp.Audits.BlockedByResponseIssueDetails>} blockedByResponseIssues
+   * @return {LH.Audit.Details.TableItem}
+   */
+  static getBlockedByResponseRow(blockedByResponseIssues) {
+    const requestUrls = new Set();
+    for (const issue of blockedByResponseIssues) {
+      const requestUrl = issue.request?.url;
+      if (requestUrl) {
+        requestUrls.add(requestUrl);
+      }
+    }
+    return {
+      issueType: str_(UIStrings.issueTypeBlockedByResponse),
+      subItems: {
+        type: 'subitems',
+        items: Array.from(requestUrls).map(url => {
+          return {
+            url,
+          };
+        }),
+      },
+    };
+  }
+
+  /**
+   * @param {Array<LH.Crdp.Audits.ContentSecurityPolicyIssueDetails>} cspIssues
+   * @return {LH.Audit.Details.TableItem}
+   */
+  static getContentSecurityPolicyRow(cspIssues) {
+    const requestUrls = new Set();
+    for (const issue of cspIssues) {
+      const requestUrl = issue.blockedURL;
+      if (requestUrl) {
+        requestUrls.add(requestUrl);
+      }
+    }
+    return {
+      issueType: 'Content security policy',
+      subItems: {
+        type: 'subitems',
+        items: Array.from(requestUrls).map(url => {
+          return {
+            url,
+          };
+        }),
+      },
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {LH.Audit.Product}
+   */
+  static audit(artifacts) {
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      /* eslint-disable max-len */
+      {key: 'issueType', valueType: 'text', subItemsHeading: {key: 'url', valueType: 'url'}, label: str_(UIStrings.columnIssueType)},
+      /* eslint-enable max-len */
+    ];
+
+    const issues = artifacts.InspectorIssues;
+    /** @type LH.Audit.Details.TableItem[] */
+    const items = [];
+
+    if (issues.mixedContentIssue.length) {
+      items.push(this.getMixedContentRow(issues.mixedContentIssue));
+    }
+    if (issues.cookieIssue.length) {
+      items.push(this.getCookieRow(issues.cookieIssue));
+    }
+    if (issues.blockedByResponseIssue.length) {
+      items.push(this.getBlockedByResponseRow(issues.blockedByResponseIssue));
+    }
+    if (issues.heavyAdIssue.length) {
+      items.push({issueType: str_(UIStrings.issueTypeHeavyAds)});
+    }
+    const cspIssues = issues.contentSecurityPolicyIssue.filter(issue => {
+      // kTrustedTypesSinkViolation and kTrustedTypesPolicyViolation aren't currently supported by the Issues panel
+      return issue.contentSecurityPolicyViolationType !== 'kTrustedTypesSinkViolation' &&
+        issue.contentSecurityPolicyViolationType !== 'kTrustedTypesPolicyViolation';
+    });
+    if (cspIssues.length) {
+      items.push(this.getContentSecurityPolicyRow(cspIssues));
+    }
+    return {
+      score: items.length > 0 ? 0 : 1,
+      details: Audit.makeTableDetails(headings, items),
+    };
+  }
+}
+
+export default IssuesPanelEntries;
+export {UIStrings};

package/core/audits/dobetterweb/js-libraries.d.ts

@@ -0,0 +1,15 @@
+export default JsLibrariesAudit;
+declare class JsLibrariesAudit 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 description: string;
+    const columnVersion: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=js-libraries.d.ts.map