lighthouse 9.6.7 → 10.0.0-dev.20230209

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

@@ -0,0 +1,287 @@
+/**
+ * @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
+ * Creates nodes for treemap app.
+ * Example output: treemap/app/debug.json
+ */
+
+/**
+ * @typedef {Omit<LH.Treemap.Node, 'name'|'children'>} SourceData
+ */
+
+import {Audit} from './audit.js';
+import {JSBundles} from '../computed/js-bundles.js';
+import {UnusedJavascriptSummary} from '../computed/unused-javascript-summary.js';
+import {ModuleDuplication} from '../computed/module-duplication.js';
+import {isInline} from '../lib/script-helpers.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', 'Scripts', '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 created by makeScriptNode.
+   *
+   * Example return result:
+     - index.html (inline 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 = [];
+    /** @type {Map<string, LH.Treemap.Node>} */
+    const htmlNodesByFrameId = new Map();
+    const bundles = await JSBundles.request(artifacts, context);
+    const duplicationByPath = await ModuleDuplication.request(artifacts, context);
+
+    for (const script of artifacts.Scripts) {
+      if (script.scriptLanguage !== 'JavaScript') continue;
+
+      const name = script.url;
+      const bundle = bundles.find(bundle => script.scriptId === bundle.script.scriptId);
+      const scriptCoverage = /** @type {LH.Artifacts['JsUsage'][string] | undefined} */
+        (artifacts.JsUsage[script.scriptId]);
+      const unusedJavascriptSummary = scriptCoverage ?
+        await UnusedJavascriptSummary.request(
+          {scriptId: script.scriptId, scriptCoverage, bundle}, context) :
+        undefined;
+
+      /** @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(script.url, 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 ?? script.length ?? 0,
+          unusedBytes: unusedJavascriptSummary?.wastedBytes,
+        };
+      }
+
+      // If this is an inline script, place the node inside a top-level (aka depth-one) node.
+      // Also separate each iframe / the main page's inline scripts into their own top-level nodes.
+      if (isInline(script)) {
+        let htmlNode = htmlNodesByFrameId.get(script.executionContextAuxData.frameId);
+        if (!htmlNode) {
+          htmlNode = {
+            name,
+            resourceBytes: 0,
+            unusedBytes: undefined,
+            children: [],
+          };
+          htmlNodesByFrameId.set(script.executionContextAuxData.frameId, htmlNode);
+          nodes.push(htmlNode);
+        }
+        htmlNode.resourceBytes += node.resourceBytes;
+        if (node.unusedBytes) htmlNode.unusedBytes = (htmlNode.unusedBytes || 0) + node.unusedBytes;
+        node.name = script.content ?
+          '(inline) ' + script.content.trimStart().substring(0, 15) + '…' :
+          '(inline)';
+        htmlNode.children?.push(node);
+      } else {
+        // Non-inline scripts each have their own top-level node.
+        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,
+    };
+  }
+}
+
+export default ScriptTreemapDataAudit;

package/core/audits/seo/canonical.d.ts

@@ -0,0 +1,51 @@
+export default Canonical;
+export type CanonicalURLData = {
+    uniqueCanonicalURLs: Set<string>;
+    hreflangURLs: Set<string>;
+    invalidCanonicalLink: LH.Artifacts.LinkElement | undefined;
+    relativeCanonicallink: LH.Artifacts.LinkElement | undefined;
+};
+/**
+ * @typedef CanonicalURLData
+ * @property {Set<string>} uniqueCanonicalURLs
+ * @property {Set<string>} hreflangURLs
+ * @property {LH.Artifacts.LinkElement|undefined} invalidCanonicalLink
+ * @property {LH.Artifacts.LinkElement|undefined} relativeCanonicallink
+ */
+declare class Canonical extends Audit {
+    /**
+     * @param {LH.Artifacts.LinkElement[]} linkElements
+     * @return {CanonicalURLData}
+     */
+    static collectCanonicalURLs(linkElements: LH.Artifacts.LinkElement[]): CanonicalURLData;
+    /**
+     * @param {CanonicalURLData} canonicalURLData
+     * @return {LH.Audit.Product|undefined}
+     */
+    static findInvalidCanonicalURLReason(canonicalURLData: CanonicalURLData): LH.Audit.Product | undefined;
+    /**
+     * @param {CanonicalURLData} canonicalURLData
+     * @param {URL} canonicalURL
+     * @param {URL} baseURL
+     * @return {LH.Audit.Product|undefined}
+     */
+    static findCommonCanonicalURLMistakes(canonicalURLData: CanonicalURLData, canonicalURL: URL, baseURL: URL): LH.Audit.Product | undefined;
+    /**
+     * @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 explanationConflict: string;
+    const explanationInvalid: string;
+    const explanationRelative: string;
+    const explanationPointsElsewhere: string;
+    const explanationRoot: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=canonical.d.ts.map

package/core/audits/seo/canonical.js

@@ -0,0 +1,217 @@
+/**
+ * @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.
+ */
+
+import {Audit} from '../audit.js';
+import UrlUtils from '../../lib/url-utils.js';
+import {MainResource} from '../../computed/main-resource.js';
+import * as i18n from '../../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. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Canonical links suggest which URL to show in search results. ' +
+    '[Learn more about canonical links](https://developer.chrome.com/docs/lighthouse/seo/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.createIcuMessageFn(import.meta.url, 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 (!UrlUtils.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,
+    };
+  }
+}
+
+export default Canonical;
+export {UIStrings};

package/core/audits/seo/crawlable-anchors.d.ts

@@ -0,0 +1,16 @@
+export default CrawlableAnchors;
+declare class CrawlableAnchors extends Audit {
+    /**
+     * @param {LH.Artifacts} artifacts
+     * @return {LH.Audit.Product}
+     */
+    static audit({ AnchorElements: anchorElements, URL: url }: LH.Artifacts): LH.Audit.Product;
+}
+export namespace UIStrings {
+    const title: string;
+    const failureTitle: string;
+    const description: string;
+    const columnFailingLink: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=crawlable-anchors.d.ts.map

package/core/audits/seo/crawlable-anchors.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.
+ */
+
+import {Audit} from '../audit.js';
+import * as i18n from '../../lib/i18n/i18n.js';
+
+const UIStrings = {
+  /** Title of a Lighthouse audit that provides detail on whether links have potentially-crawlable href attributes. This descriptive title is shown when all links on the page are potentially-crawlable. */
+  title: 'Links are crawlable',
+  /** Descriptive title of a Lighthouse audit that provides detail on whether links have potentially-crawlable href attributes. This descriptive title is shown when there are href attributes which are not crawlable by search engines. */
+  failureTitle: 'Links are not crawlable',
+  /** Description of a Lighthouse audit that tells the user why href attributes on links should be crawlable. This is displayed after a user expands the section to see more. The last sentence starting with 'Learn' becomes link text to additional documentation. */
+  description: 'Search engines may use `href` attributes on links to crawl websites. Ensure that the `href` attribute of anchor elements links to an appropriate destination, so more pages of the site can be discovered. [Learn how to make links crawlable](https://support.google.com/webmasters/answer/9112205)',
+  /** Label for a column in a data table; entries will be the HTML anchor elements that failed the audit. Anchors are DOM elements that are links. */
+  columnFailingLink: 'Uncrawlable Link',
+};
+
+const str_ = i18n.createIcuMessageFn(import.meta.url, UIStrings);
+
+class CrawlableAnchors extends Audit {
+  /**
+   * @return {LH.Audit.Meta}
+   */
+  static get meta() {
+    return {
+      id: 'crawlable-anchors',
+      title: str_(UIStrings.title),
+      failureTitle: str_(UIStrings.failureTitle),
+      description: str_(UIStrings.description),
+      requiredArtifacts: ['AnchorElements', 'URL'],
+    };
+  }
+
+  /**
+   * @param {LH.Artifacts} artifacts
+   * @return {LH.Audit.Product}
+   */
+  static audit({AnchorElements: anchorElements, URL: url}) {
+    const failingAnchors = anchorElements.filter(({
+      rawHref,
+      name = '',
+      role = '',
+    }) => {
+      rawHref = rawHref.replace( /\s/g, '');
+      name = name.trim();
+      role = role.trim();
+
+      if (role.length > 0) return;
+      // Ignore mailto links even if they use one of the failing patterns. See https://github.com/GoogleChrome/lighthouse/issues/11443#issuecomment-694898412
+      if (rawHref.startsWith('mailto:')) return;
+
+      const javaScriptVoidRegExp = /javascript:void(\(|)0(\)|)/;
+
+      if (rawHref.startsWith('file:')) return true;
+      if (name.length > 0) return;
+
+      if (rawHref === '') return true;
+      if (javaScriptVoidRegExp.test(rawHref)) return true;
+
+      // checking if rawHref is a valid
+      try {
+        new URL(rawHref, url.finalDisplayedUrl);
+      } catch (e) {
+        return true;
+      }
+    });
+
+    /** @type {LH.Audit.Details.Table['headings']} */
+    const headings = [{
+      key: 'node',
+      valueType: 'node',
+      label: str_(UIStrings.columnFailingLink),
+    }];
+
+    /** @type {LH.Audit.Details.Table['items']} */
+    const itemsToDisplay = failingAnchors.map(anchor => {
+      return {
+        node: Audit.makeNodeItem(anchor.node),
+      };
+    });
+
+    return {
+      score: Number(failingAnchors.length === 0),
+      details: Audit.makeTableDetails(headings, itemsToDisplay),
+    };
+  }
+}
+
+export default CrawlableAnchors;
+export {UIStrings};

package/core/audits/seo/font-size.d.ts

@@ -0,0 +1,24 @@
+export default FontSize;
+export type FailingNodeData = LH.Artifacts.FontSize['analyzedFailingNodesData'][0];
+declare class FontSize 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 explanationViewport: string;
+    const additionalIllegibleText: string;
+    const legibleText: string;
+    const columnSelector: string;
+    const columnPercentPageText: string;
+    const columnFontSize: string;
+}
+import { Audit } from "../audit.js";
+//# sourceMappingURL=font-size.d.ts.map