lighthouse 9.6.7 → 10.0.0

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/csp-xss.js

@@ -0,0 +1,186 @@
+/**
+ * @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.
+ */
+
+import {Audit} from './audit.js';
+import {MainResource} from '../computed/main-resource.js';
+import * as i18n from '../lib/i18n/i18n.js';
+import {evaluateRawCspsForXss, getTranslatedDescription} from '../lib/csp-evaluator.js';
+
+/** @typedef {import('../lib/csp-evaluator.js').Finding} Finding */
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that evaluates the security of a page's CSP. "CSP" stands for "Content Security Policy". "XSS" stands for "Cross Site Scripting". "CSP" and "XSS" do not need to be translated. */
+  title: 'Ensure CSP is effective against XSS attacks',
+  /** Description of a Lighthouse audit that evaluates the security of a page's CSP. 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. "CSP" stands for "Content Security Policy". "XSS" stands for "Cross Site Scripting". "CSP" and "XSS" do not need to be translated. */
+  description: 'A strong Content Security Policy (CSP) significantly ' +
+    'reduces the risk of cross-site scripting (XSS) attacks. ' +
+    '[Learn how to use a CSP to prevent XSS](https://developer.chrome.com/docs/lighthouse/best-practices/csp-xss/)',
+  /** Summary text for the results of a Lighthouse audit that evaluates the security of a page's CSP. This is displayed if no CSP is being enforced. "CSP" stands for "Content Security Policy". "CSP" does not need to be translated. */
+  noCsp: 'No CSP found in enforcement mode',
+  /** Message shown when one or more CSPs are defined in a <meta> tag. Shown in a table with a list of other CSP bypasses and warnings. "CSP" stands for "Content Security Policy". "CSP" and "HTTP" do not need to be translated. */
+  metaTagMessage: 'The page contains a CSP defined in a <meta> tag. ' +
+    'Consider moving the CSP to an HTTP header or ' +
+    'defining another strict CSP in an HTTP header.',
+  /** Label for a column in a data table; entries will be a directive of a CSP. "CSP" stands for "Content Security Policy". */
+  columnDirective: 'Directive',
+  /** Label for a column in a data table; entries will be the severity of an issue with the CSP. "CSP" stands for "Content Security Policy". */
+  columnSeverity: 'Severity',
+  /** Table item value calling out the presence of a syntax error. */
+  itemSeveritySyntax: 'Syntax',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class CspXss extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'csp-xss',
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      title: str_(UIStrings.title),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['devtoolsLogs', 'MetaElements', 'URL'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<{cspHeaders: string[], cspMetaTags: string[]}>}
+   */
+  static async getRawCsps(artifacts, context) {
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const mainResource = await MainResource.request({devtoolsLog, URL: artifacts.URL}, context);
+
+    const cspMetaTags = artifacts.MetaElements
+      .filter(m => {
+        return m.httpEquiv && m.httpEquiv.toLowerCase() === 'content-security-policy';
+      })
+      .flatMap(m => (m.content || '').split(','))
+      .filter(rawCsp => rawCsp.replace(/\s/g, ''));
+    const cspHeaders = mainResource.responseHeaders
+      .filter(h => {
+        return h.name.toLowerCase() === 'content-security-policy';
+      })
+      .flatMap(h => h.value.split(','))
+      .filter(rawCsp => rawCsp.replace(/\s/g, ''));
+
+    return {cspHeaders, cspMetaTags};
+  }
+
+  /**
+   * @param {Finding} finding
+   * @param {LH.IcuMessage=} severity
+   * @return {LH.Audit.Details.TableItem}
+   */
+  static findingToTableItem(finding, severity) {
+    return {
+      directive: finding.directive,
+      description: getTranslatedDescription(finding),
+      severity,
+    };
+  }
+
+  /**
+   * @param {Finding[][]} syntaxFindings
+   * @param {string[]} rawCsps
+   * @return {LH.Audit.Details.TableItem[]}
+   */
+  static constructSyntaxResults(syntaxFindings, rawCsps) {
+    /** @type {LH.Audit.Details.TableItem[]} */
+    const results = [];
+
+    for (let i = 0; i < syntaxFindings.length; ++i) {
+      const items = syntaxFindings[i].map(f => this.findingToTableItem(f));
+      if (!items.length) continue;
+      results.push({
+        severity: str_(UIStrings.itemSeveritySyntax),
+        description: {
+          type: 'code',
+          value: rawCsps[i],
+        },
+        subItems: {
+          type: 'subitems',
+          items,
+        },
+      });
+    }
+
+    return results;
+  }
+
+  /**
+   * @param {string[]} cspHeaders
+   * @param {string[]} cspMetaTags
+   * @return {{score: number, results: LH.Audit.Details.TableItem[]}}
+   */
+  static constructResults(cspHeaders, cspMetaTags) {
+    const rawCsps = [...cspHeaders, ...cspMetaTags];
+    if (!rawCsps.length) {
+      return {
+        score: 0,
+        results: [{
+          severity: str_(i18n.UIStrings.itemSeverityHigh),
+          description: str_(UIStrings.noCsp),
+          directive: undefined,
+        }],
+      };
+    }
+
+    const {bypasses, warnings, syntax} = evaluateRawCspsForXss(rawCsps);
+
+    const results = [
+      ...this.constructSyntaxResults(syntax, rawCsps),
+      ...bypasses.map(f => this.findingToTableItem(f, str_(i18n.UIStrings.itemSeverityHigh))),
+      ...warnings.map(f => this.findingToTableItem(f, str_(i18n.UIStrings.itemSeverityMedium))),
+    ];
+
+    const headerOnlyBypasses = evaluateRawCspsForXss(cspHeaders).bypasses;
+    const headerOnlyIsInsecure = headerOnlyBypasses.length > 0 || cspHeaders.length === 0;
+
+    // Warn if there is a meta tag CSP and the header CSPs are not strict enough on their own.
+    if (cspMetaTags.length > 0 && headerOnlyIsInsecure) {
+      results.push({
+        severity: str_(i18n.UIStrings.itemSeverityMedium),
+        description: str_(UIStrings.metaTagMessage),
+        directive: undefined,
+      });
+    }
+
+    return {score: bypasses.length ? 0 : 1, results};
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const {cspHeaders, cspMetaTags} = await this.getRawCsps(artifacts, context);
+    const {score, results} = this.constructResults(cspHeaders, cspMetaTags);
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      /* eslint-disable max-len */
+      {key: 'description', valueType: 'text', subItemsHeading: {key: 'description'}, label: str_(i18n.UIStrings.columnDescription)},
+      {key: 'directive', valueType: 'code', subItemsHeading: {key: 'directive'}, label: str_(UIStrings.columnDirective)},
+      {key: 'severity', valueType: 'text', subItemsHeading: {key: 'severity'}, label: str_(UIStrings.columnSeverity)},
+      /* eslint-enable max-len */
+    ];
+    const details = Audit.makeTableDetails(headings, results);
+
+    return {
+      score,
+      notApplicable: !results.length,
+      details,
+    };
+  }
+}
+
+export default CspXss;
+export {UIStrings};

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/deprecations.js

@@ -0,0 +1,114 @@
+/**
+ * @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 determine if it is calling deprecated APIs.
+ */
+
+import {Audit} from './audit.js';
+import {JSBundles} from '../computed/js-bundles.js';
+import * as i18n from '../lib/i18n/i18n.js';
+import {getIssueDetailDescription} from '../lib/deprecations-strings.js';
+
+/* eslint-disable max-len */
+const UIStrings = {
+  /** Title of a Lighthouse audit that provides detail on the use of deprecated APIs. This descriptive title is shown to users when the page does not use deprecated APIs. */
+  title: 'Avoids deprecated APIs',
+  /** Title of a Lighthouse audit that provides detail on the use of deprecated APIs. This descriptive title is shown to users when the page uses deprecated APIs. */
+  failureTitle: 'Uses deprecated APIs',
+  /** Description of a Lighthouse audit that tells the user why they should not use deprecated APIs on their page. 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: 'Deprecated APIs will eventually be removed from the browser. ' +
+      '[Learn more about deprecated APIs](https://developer.chrome.com/docs/lighthouse/best-practices/deprecations/).',
+  /** [ICU Syntax] Label for the audit identifying the number of warnings generated by using deprecated APIs. */
+  displayValue: `{itemCount, plural,
+    =1 {1 warning found}
+    other {# warnings found}
+    }`,
+  /** Header of the table column which displays the warning message describing use of a deprecated API by code running in the web page. */
+  columnDeprecate: 'Deprecation / Warning',
+  /** Table column header for line of code (eg. 432) that is using a deprecated API. */
+  columnLine: 'Line',
+};
+/* eslint-enable max-len */
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class Deprecations extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'deprecations',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['InspectorIssues', 'SourceMaps', 'Scripts'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const bundles = await JSBundles.request(artifacts, context);
+
+    const deprecations = artifacts.InspectorIssues.deprecationIssue
+      .map(deprecation => {
+        const {scriptId, url, lineNumber, columnNumber} = deprecation.sourceCodeLocation;
+        const bundle = bundles.find(bundle => bundle.script.scriptId === scriptId);
+        const deprecationMeta = getIssueDetailDescription(deprecation);
+
+        /** @type {LH.Audit.Details.TableSubItems=} */
+        let subItems = undefined;
+        if (deprecationMeta.links.length) {
+          subItems = {
+            type: 'subitems',
+            items: deprecationMeta.links.map(link => ({
+              type: 'link',
+              url: link.link,
+              text: link.linkTitle,
+            })),
+          };
+        }
+
+        // @ts-expect-error: The english string used to be included on the protocol, but no longer is.
+        const legacyMessage = deprecation.message;
+
+        /** @type {LH.Audit.Details.TableItem} */
+        const item = {
+          value: deprecationMeta.message || legacyMessage || deprecation.type,
+          // Protocol.Audits.SourceCodeLocation.columnNumber is 1-indexed, but we use 0-indexed.
+          source: Audit.makeSourceLocation(url, lineNumber, columnNumber - 1, bundle),
+          subItems,
+        };
+        return item;
+      });
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [
+      {key: 'value', valueType: 'text', label: str_(UIStrings.columnDeprecate)},
+      {key: 'source', valueType: 'source-location', label: str_(i18n.UIStrings.columnSource)},
+    ];
+    const details = Audit.makeTableDetails(headings, deprecations);
+
+    let displayValue;
+    if (deprecations.length > 0) {
+      displayValue = str_(UIStrings.displayValue, {itemCount: deprecations.length});
+    }
+
+    return {
+      score: Number(deprecations.length === 0),
+      displayValue,
+      details,
+    };
+  }
+}
+
+export default Deprecations;
+export {UIStrings};

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/diagnostics.js

@@ -0,0 +1,79 @@
+/**
+ * @license Copyright 2019 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 {MainThreadTasks} from '../computed/main-thread-tasks.js';
+import {NetworkRecords} from '../computed/network-records.js';
+import {NetworkAnalysis} from '../computed/network-analysis.js';
+import {MainResource} from '../computed/main-resource.js';
+
+class Diagnostics extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'diagnostics',
+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
+      title: 'Diagnostics',
+      description: 'Collection of useful page vitals.',
+      supportedModes: ['navigation'],
+      requiredArtifacts: ['URL', 'traces', 'devtoolsLogs'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const trace = artifacts.traces[Audit.DEFAULT_PASS];
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const tasks = await MainThreadTasks.request(trace, context);
+    const records = await NetworkRecords.request(devtoolsLog, context);
+    const analysis = await NetworkAnalysis.request(devtoolsLog, context);
+    const mainResource = await MainResource.request({devtoolsLog, URL: artifacts.URL}, context);
+
+    const toplevelTasks = tasks.filter(t => !t.parent);
+    const mainDocumentTransferSize = mainResource.transferSize;
+    const totalByteWeight = records.reduce((sum, r) => sum + (r.transferSize || 0), 0);
+    const totalTaskTime = toplevelTasks.reduce((sum, t) => sum + (t.duration || 0), 0);
+    const maxRtt = Math.max(...analysis.additionalRttByOrigin.values()) + analysis.rtt;
+    const maxServerLatency = Math.max(...analysis.serverResponseTimeByOrigin.values());
+
+    const diagnostics = {
+      numRequests: records.length,
+      numScripts: records.filter(r => r.resourceType === 'Script').length,
+      numStylesheets: records.filter(r => r.resourceType === 'Stylesheet').length,
+      numFonts: records.filter(r => r.resourceType === 'Font').length,
+      numTasks: toplevelTasks.length,
+      numTasksOver10ms: toplevelTasks.filter(t => t.duration > 10).length,
+      numTasksOver25ms: toplevelTasks.filter(t => t.duration > 25).length,
+      numTasksOver50ms: toplevelTasks.filter(t => t.duration > 50).length,
+      numTasksOver100ms: toplevelTasks.filter(t => t.duration > 100).length,
+      numTasksOver500ms: toplevelTasks.filter(t => t.duration > 500).length,
+      rtt: analysis.rtt,
+      throughput: analysis.throughput,
+      maxRtt,
+      maxServerLatency,
+      totalByteWeight,
+      totalTaskTime,
+      mainDocumentTransferSize,
+    };
+
+    return {
+      score: 1,
+      details: {
+        type: 'debugdata',
+        // TODO: Consider not nesting diagnostics under `items`.
+        items: [diagnostics],
+      },
+    };
+  }
+}
+
+export default Diagnostics;

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/charset.js

@@ -0,0 +1,93 @@
+/**
+ * @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 ensure charset it configured properly.
+ * It must be defined within the first 1024 bytes of the HTML document, defined in the HTTP header, or the document source must start with a BOM.
+ *
+ * @see https://github.com/GoogleChrome/lighthouse/issues/10023
+ */
+
+
+import {Audit} from '../audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+import {MainResource} from '../../computed/main-resource.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that provides detail on if the charset is set properly for a page. This title is shown when the charset is defined correctly. Charset defines the character encoding (eg UTF-8) of the page content. */
+  title: 'Properly defines charset',
+  /** Title of a Lighthouse audit that provides detail on if the charset is set properly for a page. This title is shown when the charset meta tag is missing or defined too late in the page. */
+  failureTitle: 'Charset declaration is missing or occurs too late in the HTML',
+  /** Description of a Lighthouse audit that tells the user why the charset needs to be defined early on. */
+  description: 'A character encoding declaration is required. It can be done with a `<meta>` tag ' +
+    'in the first 1024 bytes of the HTML or in the Content-Type HTTP response header. ' +
+    '[Learn more about declaring the character encoding](https://developer.chrome.com/docs/lighthouse/best-practices/charset/).',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+const CONTENT_TYPE_HEADER = 'content-type';
+// /^[a-zA-Z0-9-_:.()]{2,}$/ matches all known IANA charset names (https://www.iana.org/assignments/character-sets/character-sets.xhtml)
+const IANA_REGEX = /^[a-zA-Z0-9-_:.()]{2,}$/;
+const CHARSET_HTML_REGEX = /<meta[^>]+charset[^<]+>/i;
+const CHARSET_HTTP_REGEX = /charset\s*=\s*[a-zA-Z0-9-_:.()]{2,}/i;
+
+class CharsetDefined extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'charset',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['MainDocumentContent', 'URL', 'devtoolsLogs', 'MetaElements'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @param {LH.Audit.Context} context
+   * @return {Promise<LH.Audit.Product>}
+   */
+  static async audit(artifacts, context) {
+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];
+    const mainResource = await MainResource.request({devtoolsLog, URL: artifacts.URL}, context);
+    let isCharsetSet = false;
+    // Check the http header 'content-type' to see if charset is defined there
+    if (mainResource.responseHeaders) {
+      const contentTypeHeader = mainResource.responseHeaders
+        .find(header => header.name.toLowerCase() === CONTENT_TYPE_HEADER);
+
+      if (contentTypeHeader) {
+        isCharsetSet = CHARSET_HTTP_REGEX.test(contentTypeHeader.value);
+      }
+    }
+
+    // Check if there is a BOM byte marker
+    const BOM_FIRSTCHAR = 0xFEFF;
+    isCharsetSet = isCharsetSet || artifacts.MainDocumentContent.charCodeAt(0) === BOM_FIRSTCHAR;
+
+    // Check if charset-ish meta tag is defined within the first 1024 characters(~1024 bytes) of the HTML document
+    if (CHARSET_HTML_REGEX.test(artifacts.MainDocumentContent.slice(0, 1024))) {
+      // If so, double-check the DOM attributes, considering both legacy http-equiv and html5 charset styles.
+      isCharsetSet = isCharsetSet || artifacts.MetaElements.some(meta => {
+        return (meta.charset && IANA_REGEX.test(meta.charset)) ||
+          (meta.httpEquiv === 'content-type' &&
+          meta.content &&
+          CHARSET_HTTP_REGEX.test(meta.content));
+      });
+    }
+
+    return {
+      score: Number(isCharsetSet),
+    };
+  }
+}
+
+export default CharsetDefined;
+export {UIStrings, CHARSET_HTML_REGEX, CHARSET_HTTP_REGEX, IANA_REGEX};

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