lighthouse 9.6.7 → 10.0.0

package/lighthouse-core/audits/screenshot-thumbnails.js

@@ -1,163 +0,0 @@
-/**
- * @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.
- */
-'use strict';
-
-const Audit = require('./audit.js');
-const LHError = require('../lib/lh-error.js');
-const jpeg = require('jpeg-js');
-const Speedline = require('../computed/speedline.js');
-
-const NUMBER_OF_THUMBNAILS = 10;
-const THUMBNAIL_WIDTH = 120;
-
-/** @typedef {LH.Artifacts.Speedline['frames'][0]} SpeedlineFrame */
-
-class ScreenshotThumbnails extends Audit {
-  /**
-   * @return {LH.Audit.Meta}
-   */
-  static get meta() {
-    return {
-      id: 'screenshot-thumbnails',
-      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
-      title: 'Screenshot Thumbnails',
-      description: 'This is what the load of your site looked like.',
-      requiredArtifacts: ['traces', 'GatherContext'],
-    };
-  }
-
-  /**
-   * Scales down an image to THUMBNAIL_WIDTH using nearest neighbor for speed, maintains aspect
-   * ratio of the original thumbnail.
-   *
-   * @param {ReturnType<SpeedlineFrame['getParsedImage']>} imageData
-   * @return {{width: number, height: number, data: Uint8Array}}
-   */
-  static scaleImageToThumbnail(imageData) {
-    const scaledWidth = THUMBNAIL_WIDTH;
-    const scaleFactor = imageData.width / scaledWidth;
-    const scaledHeight = Math.floor(imageData.height / scaleFactor);
-
-    const outPixels = new Uint8Array(scaledWidth * scaledHeight * 4);
-
-    for (let i = 0; i < scaledWidth; i++) {
-      for (let j = 0; j < scaledHeight; j++) {
-        const origX = Math.floor(i * scaleFactor);
-        const origY = Math.floor(j * scaleFactor);
-
-        const origPos = (origY * imageData.width + origX) * 4;
-        const outPos = (j * scaledWidth + i) * 4;
-
-        outPixels[outPos] = imageData.data[origPos];
-        outPixels[outPos + 1] = imageData.data[origPos + 1];
-        outPixels[outPos + 2] = imageData.data[origPos + 2];
-        outPixels[outPos + 3] = imageData.data[origPos + 3];
-      }
-    }
-
-    return {
-      width: scaledWidth,
-      height: scaledHeight,
-      data: outPixels,
-    };
-  }
-
-  /**
-   * @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];
-    /** @type {Map<SpeedlineFrame, string>} */
-    const cachedThumbnails = new Map();
-
-    const speedline = await Speedline.request(trace, context);
-
-    // Make the minimum time range 3s so sites that load super quickly don't get a single screenshot
-    const minimumTimelineDuration = context.options.minimumTimelineDuration || 3000;
-
-    const thumbnails = [];
-    const analyzedFrames = speedline.frames.filter(frame => !frame.isProgressInterpolated());
-    const maxFrameTime =
-      speedline.complete ||
-      Math.max(...speedline.frames.map(frame => frame.getTimeStamp() - speedline.beginning));
-    const timelineEnd = Math.max(maxFrameTime, minimumTimelineDuration);
-
-    if (!analyzedFrames.length || !Number.isFinite(timelineEnd)) {
-      throw new LHError(LHError.errors.INVALID_SPEEDLINE);
-    }
-
-    for (let i = 1; i <= NUMBER_OF_THUMBNAILS; i++) {
-      const targetTimestamp = speedline.beginning + timelineEnd * i / NUMBER_OF_THUMBNAILS;
-
-      /** @type {SpeedlineFrame} */
-      // @ts-expect-error - there will always be at least one frame by this point. TODO: use nonnullable assertion in TS2.9
-      let frameForTimestamp = null;
-      if (i === NUMBER_OF_THUMBNAILS) {
-        frameForTimestamp = analyzedFrames[analyzedFrames.length - 1];
-      } else {
-        analyzedFrames.forEach(frame => {
-          if (frame.getTimeStamp() <= targetTimestamp) {
-            frameForTimestamp = frame;
-          }
-        });
-      }
-
-      let base64Data;
-      const cachedThumbnail = cachedThumbnails.get(frameForTimestamp);
-      if (cachedThumbnail) {
-        base64Data = cachedThumbnail;
-      } else {
-        const imageData = frameForTimestamp.getParsedImage();
-        const thumbnailImageData = ScreenshotThumbnails.scaleImageToThumbnail(imageData);
-        base64Data = jpeg.encode(thumbnailImageData, 90).data.toString('base64');
-        cachedThumbnails.set(frameForTimestamp, base64Data);
-      }
-      thumbnails.push({
-        timing: Math.round(targetTimestamp - speedline.beginning),
-        timestamp: targetTimestamp * 1000,
-        data: `data:image/jpeg;base64,${base64Data}`,
-      });
-    }
-
-    return {
-      score: 1,
-      details: {
-        type: 'filmstrip',
-        scale: timelineEnd,
-        items: thumbnails,
-      },
-    };
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @param {LH.Audit.Context} context
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit(artifacts, context) {
-    try {
-      return await this._audit(artifacts, context);
-    } catch (err) {
-      const noFramesErrors = new Set([
-        LHError.errors.NO_SCREENSHOTS.code,
-        LHError.errors.SPEEDINDEX_OF_ZERO.code,
-        LHError.errors.NO_SPEEDLINE_FRAMES.code,
-        LHError.errors.INVALID_SPEEDLINE.code,
-      ]);
-
-      // If a timespan didn't happen to contain frames, that's fine. Just mark not applicable.
-      if (noFramesErrors.has(err.code) && artifacts.GatherContext.gatherMode === 'timespan') {
-        return {notApplicable: true, score: 1};
-      }
-
-      throw err;
-    }
-  }
-}
-
-module.exports = ScreenshotThumbnails;

package/lighthouse-core/audits/script-treemap-data.js

@@ -1,288 +0,0 @@
-/**
- * @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.
- */
-'use strict';
-
-/**
- * @fileoverview
- * Creates nodes for treemap app.
- * Example output: treemap/app/debug.json
- */
-
-/**
- * @typedef {Omit<LH.Treemap.Node, 'name'|'children'>} SourceData
- */
-
-const Audit = require('./audit.js');
-const JsBundles = require('../computed/js-bundles.js');
-const UnusedJavaScriptSummary = require('../computed/unused-javascript-summary.js');
-const ModuleDuplication = require('../computed/module-duplication.js');
-
-class ScriptTreemapDataAudit extends Audit {
-  /**
-   * @return {LH.Audit.Meta}
-   */
-  static get meta() {
-    return {
-      id: 'script-treemap-data',
-      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,
-      title: 'Script Treemap Data',
-      description: 'Used for treemap app',
-      requiredArtifacts:
-        ['traces', 'devtoolsLogs', 'SourceMaps', 'ScriptElements', 'JsUsage', 'URL'],
-    };
-  }
-
-  /**
-   * Returns a tree data structure where leaf nodes are sources (ie. real files from source tree)
-   * from a source map, and non-leaf nodes are directories. Leaf nodes have data
-   * for bytes, coverage, etc., when available, and non-leaf nodes have the
-   * same data as the sum of all descendant leaf nodes.
-   * @param {string} src
-   * @param {string} sourceRoot
-   * @param {Record<string, SourceData>} sourcesData
-   * @return {LH.Treemap.Node}
-   */
-  static makeScriptNode(src, sourceRoot, sourcesData) {
-    /**
-     * @param {string} name
-     * @return {LH.Treemap.Node}
-     */
-    function newNode(name) {
-      return {
-        name,
-        resourceBytes: 0,
-      };
-    }
-
-    const sourceRootNode = newNode(sourceRoot);
-
-    /**
-     * Given a slash-delimited path, traverse the Node structure and increment
-     * the data provided for each node in the chain. Creates nodes as needed.
-     * Ex: path/to/file.js will find or create "path" on `node`, increment the data fields,
-     *     and continue with "to", and so on.
-     * @param {string} source
-     * @param {SourceData} data
-     */
-    function addAllNodesInSourcePath(source, data) {
-      let node = sourceRootNode;
-
-      // Apply the data to the sourceRootNode.
-      sourceRootNode.resourceBytes += data.resourceBytes;
-      if (data.unusedBytes) {
-        sourceRootNode.unusedBytes = (sourceRootNode.unusedBytes || 0) + data.unusedBytes;
-      }
-
-      // Strip off the shared root.
-      const sourcePathSegments = source.replace(sourceRoot, '').split(/\/+/);
-      sourcePathSegments.forEach((sourcePathSegment, i) => {
-        if (sourcePathSegment.length === 0) return;
-
-        const isLeaf = i === sourcePathSegments.length - 1;
-
-        let child = node.children && node.children.find(child => child.name === sourcePathSegment);
-        if (!child) {
-          child = newNode(sourcePathSegment);
-          node.children = node.children || [];
-          node.children.push(child);
-        }
-        node = child;
-
-        // Now that we've found or created the next node in the path, apply the data.
-        node.resourceBytes += data.resourceBytes;
-        if (data.unusedBytes) node.unusedBytes = (node.unusedBytes || 0) + data.unusedBytes;
-
-        // Only leaf nodes might have duplication data.
-        if (isLeaf && data.duplicatedNormalizedModuleName !== undefined) {
-          node.duplicatedNormalizedModuleName = data.duplicatedNormalizedModuleName;
-        }
-      });
-    }
-
-    // For every source file, apply the data to all components
-    // of the source path, creating nodes as necessary.
-    for (const [source, data] of Object.entries(sourcesData)) {
-      addAllNodesInSourcePath(source, data);
-    }
-
-    /**
-     * Collapse nodes that have only one child.
-     * @param {LH.Treemap.Node} node
-     */
-    function collapseAll(node) {
-      while (node.children && node.children.length === 1) {
-        node.name += '/' + node.children[0].name;
-        node.children = node.children[0].children;
-      }
-
-      if (node.children) {
-        for (const child of node.children) {
-          collapseAll(child);
-        }
-      }
-    }
-    collapseAll(sourceRootNode);
-
-    // If sourceRootNode.name is falsy (no defined sourceRoot + no collapsed common prefix),
-    // collapse the sourceRootNode children into the scriptNode.
-    // Otherwise, we add another node.
-    if (!sourceRootNode.name) {
-      return {
-        ...sourceRootNode,
-        name: src,
-        children: sourceRootNode.children,
-      };
-    }
-
-    // Script node should be just the script src.
-    const scriptNode = {...sourceRootNode};
-    scriptNode.name = src;
-    scriptNode.children = [sourceRootNode];
-    return scriptNode;
-  }
-
-  /**
-   * Returns nodes where the first level of nodes are URLs.
-   * Every external script has a node.
-   * All inline scripts are combined into a single node.
-   * If a script has a source map, that node will be set by makeNodeFromSourceMapData.
-   *
-   * Example return result:
-     - index.html (inlines scripts)
-     - main.js
-     - - webpack://
-     - - - react.js
-     - - - app.js
-     - i-have-no-map.js
-   *
-   * @param {LH.Artifacts} artifacts
-   * @param {LH.Audit.Context} context
-   * @return {Promise<LH.Treemap.Node[]>}
-   */
-  static async makeNodes(artifacts, context) {
-    /** @type {LH.Treemap.Node[]} */
-    const nodes = [];
-
-    let inlineScriptLength = 0;
-    for (const scriptElement of artifacts.ScriptElements) {
-      // No src means script is inline.
-      // Combine these ScriptElements so that inline scripts show up as a single root node.
-      if (!scriptElement.src) {
-        inlineScriptLength += (scriptElement.content || '').length;
-      }
-    }
-    if (inlineScriptLength) {
-      const name = artifacts.URL.finalUrl;
-      nodes.push({
-        name,
-        resourceBytes: inlineScriptLength,
-      });
-    }
-
-    const bundles = await JsBundles.request(artifacts, context);
-    const duplicationByPath = await ModuleDuplication.request(artifacts, context);
-
-    for (const scriptElement of artifacts.ScriptElements) {
-      if (!scriptElement.src) continue;
-
-      const name = scriptElement.src;
-      const bundle = bundles.find(bundle => scriptElement.src === bundle.script.src);
-      const scriptCoverages = artifacts.JsUsage[scriptElement.src] || [];
-      if (!bundle && scriptCoverages.length === 0) {
-        // No bundle and no coverage information, so simply make a single node
-        // detailing how big the script is.
-
-        nodes.push({
-          name,
-          resourceBytes: scriptElement.content?.length || 0,
-        });
-        continue;
-      }
-
-      const unusedJavascriptSummary = await UnusedJavaScriptSummary.request(
-        {url: scriptElement.src, scriptCoverages, bundle}, context);
-
-      /** @type {LH.Treemap.Node} */
-      let node;
-      if (bundle && !('errorMessage' in bundle.sizes)) {
-        // Create nodes for each module in a bundle.
-
-        /** @type {Record<string, SourceData>} */
-        const sourcesData = {};
-        for (const source of Object.keys(bundle.sizes.files)) {
-          /** @type {SourceData} */
-          const sourceData = {
-            resourceBytes: bundle.sizes.files[source],
-          };
-
-          if (unusedJavascriptSummary.sourcesWastedBytes) {
-            sourceData.unusedBytes = unusedJavascriptSummary.sourcesWastedBytes[source];
-          }
-
-          // ModuleDuplication uses keys without the source root prepended, but
-          // bundle.sizes uses keys with it prepended, so we remove the source root before
-          // using it with duplicationByPath.
-          let sourceWithoutSourceRoot = source;
-          if (bundle.rawMap.sourceRoot && source.startsWith(bundle.rawMap.sourceRoot)) {
-            sourceWithoutSourceRoot = source.replace(bundle.rawMap.sourceRoot, '');
-          }
-
-          const key = ModuleDuplication.normalizeSource(sourceWithoutSourceRoot);
-          if (duplicationByPath.has(key)) sourceData.duplicatedNormalizedModuleName = key;
-
-          sourcesData[source] = sourceData;
-        }
-
-        if (bundle.sizes.unmappedBytes) {
-          /** @type {SourceData} */
-          const sourceData = {
-            resourceBytes: bundle.sizes.unmappedBytes,
-          };
-          if (unusedJavascriptSummary.sourcesWastedBytes) {
-            sourceData.unusedBytes = unusedJavascriptSummary.sourcesWastedBytes['(unmapped)'];
-          }
-          sourcesData['(unmapped)'] = sourceData;
-        }
-
-        node = this.makeScriptNode(scriptElement.src, bundle.rawMap.sourceRoot || '', sourcesData);
-      } else {
-        // No valid source map for this script, so we can only produce a single node.
-
-        node = {
-          name,
-          resourceBytes: unusedJavascriptSummary.totalBytes,
-          unusedBytes: unusedJavascriptSummary.wastedBytes,
-        };
-      }
-
-      nodes.push(node);
-    }
-
-    return nodes;
-  }
-
-  /**
-   * @param {LH.Artifacts} artifacts
-   * @param {LH.Audit.Context} context
-   * @return {Promise<LH.Audit.Product>}
-   */
-  static async audit(artifacts, context) {
-    const nodes = await ScriptTreemapDataAudit.makeNodes(artifacts, context);
-
-    /** @type {LH.Audit.Details.TreemapData} */
-    const details = {
-      type: 'treemap-data',
-      nodes,
-    };
-
-    return {
-      score: 1,
-      details,
-    };
-  }
-}
-
-module.exports = ScriptTreemapDataAudit;

package/lighthouse-core/audits/seo/canonical.js

@@ -1,218 +0,0 @@
-/**
- * @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.
- */
-'use strict';
-
-const Audit = require('../audit.js');
-const URL = require('../../lib/url-shim.js');
-const MainResource = require('../../computed/main-resource.js');
-const i18n = require('../../lib/i18n/i18n.js');
-
-const UIStrings = {
-  /** Title of a Lighthouse audit that provides detail on a page's rel=canonical link. This descriptive title is shown to users when the rel=canonical link is valid. "rel=canonical" is an HTML attribute and value and so should not be translated. */
-  title: 'Document has a valid `rel=canonical`',
-  /** Title of a Lighthouse audit that provides detail on a page's rel=canonical link. This descriptive title is shown to users when the rel=canonical link is invalid and should be fixed. "rel=canonical" is an HTML attribute and value and so should not be translated. */
-  failureTitle: 'Document does not have a valid `rel=canonical`',
-  /** Description of a Lighthouse audit that tells the user *why* they need to have a valid rel=canonical link. This is displayed after a user expands the section to see more. No character length limits. 'Learn More' becomes link text to additional documentation. */
-  description: 'Canonical links suggest which URL to show in search results. ' +
-    '[Learn more](https://web.dev/canonical/).',
-  /**
-   * @description Explanatory message stating that there was a failure in an audit caused by multiple URLs conflicting with each other.
-   * @example {https://example.com, https://example2.com} urlList
-   * */
-  explanationConflict: 'Multiple conflicting URLs ({urlList})',
-  /**
-   * @description Explanatory message stating that there was a failure in an audit caused by a URL being invalid.
-   * @example {https://example.com/} url
-   * */
-  explanationInvalid: 'Invalid URL ({url})',
-  /**
-   * @description Explanatory message stating that there was a failure in an audit caused by a URL being relative instead of absolute.
-   * @example {https://example.com/} url
-   * */
-  explanationRelative: 'Is not an absolute URL ({url})',
-  /**
-   * @description Explanatory message stating that there was a failure in an audit caused by a URL pointing to a different hreflang than the current context.'hreflang' is an HTML attribute and should not be translated.
-   * @example {https://example.com/} url
-   */
-  explanationPointsElsewhere: 'Points to another `hreflang` location ({url})',
-  /** Explanatory message stating that the page's canonical URL was pointing to the domain's root URL, which is a common mistake. "points" refers to the action of the 'rel=canonical' referencing another link. "root" refers to the starting/home page of the website. "domain" refers to the registered domain name of the website. */
-  explanationRoot: 'Points to the domain\'s root URL (the homepage), ' +
-    'instead of an equivalent page of content',
-};
-
-const str_ = i18n.createMessageInstanceIdFn(__filename, UIStrings);
-
-/**
- * @typedef CanonicalURLData
- * @property {Set<string>} uniqueCanonicalURLs
- * @property {Set<string>} hreflangURLs
- * @property {LH.Artifacts.LinkElement|undefined} invalidCanonicalLink
- * @property {LH.Artifacts.LinkElement|undefined} relativeCanonicallink
- */
-
-class Canonical extends Audit {
-  /**
-   * @return {LH.Audit.Meta}
-   */
-  static get meta() {
-    return {
-      id: 'canonical',
-      title: str_(UIStrings.title),
-      failureTitle: str_(UIStrings.failureTitle),
-      description: str_(UIStrings.description),
-      supportedModes: ['navigation'],
-      requiredArtifacts: ['LinkElements', 'URL', 'devtoolsLogs'],
-    };
-  }
-
-  /**
-   * @param {LH.Artifacts.LinkElement[]} linkElements
-   * @return {CanonicalURLData}
-   */
-  static collectCanonicalURLs(linkElements) {
-    /** @type {Set<string>} */
-    const uniqueCanonicalURLs = new Set();
-    /** @type {Set<string>} */
-    const hreflangURLs = new Set();
-
-    /** @type {LH.Artifacts.LinkElement|undefined} */
-    let invalidCanonicalLink;
-    /** @type {LH.Artifacts.LinkElement|undefined} */
-    let relativeCanonicallink;
-    for (const link of linkElements) {
-      // Links in the body aren't canonical references for SEO, skip them
-      /** @see https://html.spec.whatwg.org/multipage/links.html#body-ok */
-      if (link.source === 'body') continue;
-
-      if (link.rel === 'canonical') {
-        // Links that don't have an href aren't canonical references for SEO, skip them
-        if (!link.hrefRaw) continue;
-
-        // Links that had an hrefRaw but didn't have a valid href were invalid, flag them
-        if (!link.href) invalidCanonicalLink = link;
-        // Links that had a valid href but didn't have a valid hrefRaw must have been relatively resolved, flag them
-        else if (!URL.isValid(link.hrefRaw)) relativeCanonicallink = link;
-        // Otherwise, it was a valid canonical URL
-        else uniqueCanonicalURLs.add(link.href);
-      } else if (link.rel === 'alternate') {
-        if (link.href && link.hreflang) hreflangURLs.add(link.href);
-      }
-    }
-
-    return {uniqueCanonicalURLs, hreflangURLs, invalidCanonicalLink, relativeCanonicallink};
-  }
-
-  /**
-   * @param {CanonicalURLData} canonicalURLData
-   * @return {LH.Audit.Product|undefined}
-   */
-  static findInvalidCanonicalURLReason(canonicalURLData) {
-    const {uniqueCanonicalURLs, invalidCanonicalLink, relativeCanonicallink} = canonicalURLData;
-
-    // the canonical link is totally invalid
-    if (invalidCanonicalLink) {
-      return {
-        score: 0,
-        explanation: str_(UIStrings.explanationInvalid, {url: invalidCanonicalLink.hrefRaw}),
-      };
-    }
-
-    // the canonical link is valid, but it's relative which isn't allowed
-    if (relativeCanonicallink) {
-      return {
-        score: 0,
-        explanation: str_(UIStrings.explanationRelative, {url: relativeCanonicallink.hrefRaw}),
-      };
-    }
-
-    /** @type {string[]} */
-    const canonicalURLs = Array.from(uniqueCanonicalURLs);
-
-    // there's no canonical URL at all, we're done
-    if (canonicalURLs.length === 0) {
-      return {
-        score: 1,
-        notApplicable: true,
-      };
-    }
-
-    // we have multiple conflicting canonical URls, we're done
-    if (canonicalURLs.length > 1) {
-      return {
-        score: 0,
-        explanation: str_(UIStrings.explanationConflict, {urlList: canonicalURLs.join(', ')}),
-      };
-    }
-  }
-
-  /**
-   * @param {CanonicalURLData} canonicalURLData
-   * @param {URL} canonicalURL
-   * @param {URL} baseURL
-   * @return {LH.Audit.Product|undefined}
-   */
-  static findCommonCanonicalURLMistakes(canonicalURLData, canonicalURL, baseURL) {
-    const {hreflangURLs} = canonicalURLData;
-
-    // cross-language or cross-country canonicals are a common issue
-    if (
-      hreflangURLs.has(baseURL.href) &&
-      hreflangURLs.has(canonicalURL.href) &&
-      baseURL.href !== canonicalURL.href
-    ) {
-      return {
-        score: 0,
-        explanation: str_(UIStrings.explanationPointsElsewhere, {url: baseURL.href}),
-      };
-    }
-
-    // another common mistake is to have canonical pointing from all pages of the website to its root
-    if (
-      canonicalURL.origin === baseURL.origin &&
-      canonicalURL.pathname === '/' &&
-      baseURL.pathname !== '/'
-    ) {
-      return {
-        score: 0,
-        explanation: str_(UIStrings.explanationRoot),
-      };
-    }
-  }
-
-  /**
-   * @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);
-    const baseURL = new URL(mainResource.url);
-    const canonicalURLData = Canonical.collectCanonicalURLs(artifacts.LinkElements);
-
-    // First we'll check that there was a single valid canonical URL.
-    const invalidURLAuditProduct = Canonical.findInvalidCanonicalURLReason(canonicalURLData);
-    if (invalidURLAuditProduct) return invalidURLAuditProduct;
-
-    // There was a single valid canonical URL, so now we'll just check for common mistakes.
-    const canonicalURL = new URL([...canonicalURLData.uniqueCanonicalURLs][0]);
-    const mistakeAuditProduct = Canonical.findCommonCanonicalURLMistakes(
-      canonicalURLData,
-      canonicalURL,
-      baseURL
-    );
-
-    if (mistakeAuditProduct) return mistakeAuditProduct;
-
-    return {
-      score: 1,
-    };
-  }
-}
-
-module.exports = Canonical;
-module.exports.UIStrings = UIStrings;