lighthouse 11.3.0-dev.20231205 → 11.3.0-dev.20231206

package/core/audits/byte-efficiency/byte-efficiency-audit.d.ts

@@ -33,29 +33,6 @@ export class ByteEfficiencyAudit extends Audit {
      * @return {number}
      */
     static scoreForWastedMs(wastedMs: number): number;
-    /**
-     * Estimates the number of bytes this network record would have consumed on the network based on the
-     * uncompressed size (totalBytes). Uses the actual transfer size from the network record if applicable.
-     *
-     * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
-     * @param {number} totalBytes Uncompressed size of the resource
-     * @param {LH.Crdp.Network.ResourceType=} resourceType
-     * @return {number}
-     */
-    static estimateTransferSize(networkRecord: LH.Artifacts.NetworkRequest | undefined, totalBytes: number, resourceType?: LH.Crdp.Network.ResourceType | undefined): number;
-    /**
-     * Estimates the number of bytes the content of this network record would have consumed on the network based on the
-     * uncompressed size (totalBytes). Uses the actual transfer size from the network record if applicable,
-     * minus the size of the response headers.
-     *
-     * This differs from `estimateTransferSize` only in that is subtracts the response headers from the estimate.
-     *
-     * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
-     * @param {number} totalBytes Uncompressed size of the resource
-     * @param {LH.Crdp.Network.ResourceType=} resourceType
-     * @return {number}
-     */
-    static estimateCompressedContentSize(networkRecord: LH.Artifacts.NetworkRequest | undefined, totalBytes: number, resourceType?: LH.Crdp.Network.ResourceType | undefined): number;
     /**
      * @param {LH.Artifacts} artifacts
      * @param {LH.Audit.Context} context
@@ -112,5 +89,4 @@ export class ByteEfficiencyAudit extends Audit {
     static audit_(artifacts: LH.Artifacts, networkRecords: Array<LH.Artifacts.NetworkRequest>, context: LH.Audit.Context): ByteEfficiencyProduct | Promise<ByteEfficiencyProduct>;
 }
 import { Audit } from '../audit.js';
-import { NetworkRequest } from '../../lib/network-request.js';
 //# sourceMappingURL=byte-efficiency-audit.d.ts.map

package/core/audits/byte-efficiency/byte-efficiency-audit.js

@@ -13,7 +13,6 @@ import {PageDependencyGraph} from '../../computed/page-dependency-graph.js';
 import {LanternLargestContentfulPaint} from '../../computed/metrics/lantern-largest-contentful-paint.js';
 import {LanternFirstContentfulPaint} from '../../computed/metrics/lantern-first-contentful-paint.js';
 import {LCPImageRecord} from '../../computed/lcp-image-record.js';
-import {NetworkRequest} from '../../lib/network-request.js';
 
 const str_ = i18n.createIcuMessageFn(import.meta.url, {});
 
@@ -59,107 +58,6 @@ class ByteEfficiencyAudit extends Audit {
     );
   }
 
-  /**
-   * Estimates the number of bytes this network record would have consumed on the network based on the
-   * uncompressed size (totalBytes). Uses the actual transfer size from the network record if applicable.
-   *
-   * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
-   * @param {number} totalBytes Uncompressed size of the resource
-   * @param {LH.Crdp.Network.ResourceType=} resourceType
-   * @return {number}
-   */
-  static estimateTransferSize(networkRecord, totalBytes, resourceType) {
-    if (!networkRecord) {
-      // We don't know how many bytes this asset used on the network, but we can guess it was
-      // roughly the size of the content gzipped.
-      // See https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/optimize-encoding-and-transfer for specific CSS/Script examples
-      // See https://discuss.httparchive.org/t/file-size-and-compression-savings/145 for fallback multipliers
-      switch (resourceType) {
-        case 'Stylesheet':
-          // Stylesheets tend to compress extremely well.
-          return Math.round(totalBytes * 0.2);
-        case 'Script':
-        case 'Document':
-          // Scripts and HTML compress fairly well too.
-          return Math.round(totalBytes * 0.33);
-        default:
-          // Otherwise we'll just fallback to the average savings in HTTPArchive
-          return Math.round(totalBytes * 0.5);
-      }
-    } else if (networkRecord.resourceType === resourceType) {
-      // This was a regular standalone asset, just use the transfer size.
-      return networkRecord.transferSize || 0;
-    } else {
-      // This was an asset that was inlined in a different resource type (e.g. HTML document).
-      // Use the compression ratio of the resource to estimate the total transferred bytes.
-      const transferSize = networkRecord.transferSize || 0;
-      const resourceSize = networkRecord.resourceSize || 0;
-      // Get the compression ratio, if it's an invalid number, assume no compression.
-      const compressionRatio = Number.isFinite(resourceSize) && resourceSize > 0 ?
-        (transferSize / resourceSize) : 1;
-      return Math.round(totalBytes * compressionRatio);
-    }
-  }
-
-  /**
-   * Estimates the number of bytes the content of this network record would have consumed on the network based on the
-   * uncompressed size (totalBytes). Uses the actual transfer size from the network record if applicable,
-   * minus the size of the response headers.
-   *
-   * This differs from `estimateTransferSize` only in that is subtracts the response headers from the estimate.
-   *
-   * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
-   * @param {number} totalBytes Uncompressed size of the resource
-   * @param {LH.Crdp.Network.ResourceType=} resourceType
-   * @return {number}
-   */
-  static estimateCompressedContentSize(networkRecord, totalBytes, resourceType) {
-    if (!networkRecord) {
-      // We don't know how many bytes this asset used on the network, but we can guess it was
-      // roughly the size of the content gzipped.
-      // See https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/optimize-encoding-and-transfer for specific CSS/Script examples
-      // See https://discuss.httparchive.org/t/file-size-and-compression-savings/145 for fallback multipliers
-      switch (resourceType) {
-        case 'Stylesheet':
-          // Stylesheets tend to compress extremely well.
-          return Math.round(totalBytes * 0.2);
-        case 'Script':
-        case 'Document':
-          // Scripts and HTML compress fairly well too.
-          return Math.round(totalBytes * 0.33);
-        default:
-          // Otherwise we'll just fallback to the average savings in HTTPArchive
-          return Math.round(totalBytes * 0.5);
-      }
-    }
-
-    // Get the size of the response body on the network.
-    let contentTransferSize = networkRecord.transferSize || 0;
-    if (!NetworkRequest.isContentEncoded(networkRecord)) {
-      // This is not encoded, so we can use resourceSize directly.
-      // This would be equivalent to transfer size minus headers transfer size, but transfer size
-      // may also include bytes for SSL connection etc.
-      contentTransferSize = networkRecord.resourceSize;
-    } else if (networkRecord.responseHeadersTransferSize) {
-      // Subtract the size of the encoded headers.
-      contentTransferSize =
-        Math.max(0, contentTransferSize - networkRecord.responseHeadersTransferSize);
-    }
-
-    if (networkRecord.resourceType === resourceType) {
-      // This was a regular standalone asset, just use the transfer size.
-      return contentTransferSize;
-    } else {
-      // This was an asset that was inlined in a different resource type (e.g. HTML document).
-      // Use the compression ratio of the resource to estimate the total transferred bytes.
-      const resourceSize = networkRecord.resourceSize || 0;
-      // Get the compression ratio, if it's an invalid number, assume no compression.
-      const compressionRatio = Number.isFinite(resourceSize) && resourceSize > 0 ?
-        (contentTransferSize / resourceSize) : 1;
-      return Math.round(totalBytes * compressionRatio);
-    }
-  }
-
   /**
    * @param {LH.Artifacts} artifacts
    * @param {LH.Audit.Context} context

package/core/audits/byte-efficiency/duplicated-javascript.js

@@ -11,7 +11,7 @@
 import {ByteEfficiencyAudit} from './byte-efficiency-audit.js';
 import {ModuleDuplication} from '../../computed/module-duplication.js';
 import * as i18n from '../../lib/i18n/i18n.js';
-import {getRequestForScript} from '../../lib/script-helpers.js';
+import {estimateTransferSize, getRequestForScript} from '../../lib/script-helpers.js';
 
 const UIStrings = {
   /** Imperative title of a Lighthouse audit that tells the user to remove duplicate JavaScript from their code. This is displayed in a list of audit titles that Lighthouse generates. */
@@ -109,8 +109,7 @@ class DuplicatedJavascript extends ByteEfficiencyAudit {
    * @param {number} contentLength
    */
   static _estimateTransferRatio(networkRecord, contentLength) {
-    const transferSize =
-      ByteEfficiencyAudit.estimateTransferSize(networkRecord, contentLength, 'Script');
+    const transferSize = estimateTransferSize(networkRecord, contentLength, 'Script');
     return transferSize / contentLength;
   }
 

package/core/audits/byte-efficiency/legacy-javascript.d.ts

@@ -60,19 +60,6 @@ declare class LegacyJavascript extends ByteEfficiencyAudit {
      * @return {number}
      */
     static estimateWastedBytes(matches: PatternMatchResult[]): number;
-    /**
-     * Utility function to estimate the ratio of the compression on the resource.
-     * This excludes the size of the response headers.
-     * Also caches the calculation.
-     *
-     * Note: duplicated-javascript does this exact thing. In the future, consider
-     * making a generic estimator on ByteEfficiencyAudit.
-     * @param {Map<string, number>} compressionRatioByUrl
-     * @param {string} url
-     * @param {LH.Artifacts} artifacts
-     * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-     */
-    static estimateCompressionRatioForContent(compressionRatioByUrl: Map<string, number>, url: string, artifacts: LH.Artifacts, networkRecords: Array<LH.Artifacts.NetworkRequest>): Promise<number>;
     /**
      * @param {LH.Artifacts} artifacts
      * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords

package/core/audits/byte-efficiency/legacy-javascript.js

@@ -24,7 +24,7 @@ import {ByteEfficiencyAudit} from './byte-efficiency-audit.js';
 import {EntityClassification} from '../../computed/entity-classification.js';
 import {JSBundles} from '../../computed/js-bundles.js';
 import * as i18n from '../../lib/i18n/i18n.js';
-import {getRequestForScript} from '../../lib/script-helpers.js';
+import {estimateCompressionRatioForContent} from '../../lib/script-helpers.js';
 import {LH_ROOT} from '../../../shared/root.js';
 
 const graphJson = fs.readFileSync(
@@ -390,40 +390,6 @@ class LegacyJavascript extends ByteEfficiencyAudit {
     return estimatedWastedBytes;
   }
 
-  /**
-   * Utility function to estimate the ratio of the compression on the resource.
-   * This excludes the size of the response headers.
-   * Also caches the calculation.
-   *
-   * Note: duplicated-javascript does this exact thing. In the future, consider
-   * making a generic estimator on ByteEfficiencyAudit.
-   * @param {Map<string, number>} compressionRatioByUrl
-   * @param {string} url
-   * @param {LH.Artifacts} artifacts
-   * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
-   */
-  static async estimateCompressionRatioForContent(compressionRatioByUrl, url,
-      artifacts, networkRecords) {
-    let compressionRatio = compressionRatioByUrl.get(url);
-    if (compressionRatio !== undefined) return compressionRatio;
-
-    const script = artifacts.Scripts.find(script => script.url === url);
-
-    if (!script) {
-      // Can't find content, so just use 1.
-      compressionRatio = 1;
-    } else {
-      const networkRecord = getRequestForScript(networkRecords, script);
-      const contentLength = networkRecord?.resourceSize || script.length || 0;
-      const compressedSize =
-        ByteEfficiencyAudit.estimateCompressedContentSize(networkRecord, contentLength, 'Script');
-      compressionRatio = compressedSize / contentLength;
-    }
-
-    compressionRatioByUrl.set(url, compressionRatio);
-    return compressionRatio;
-  }
-
   /**
    * @param {LH.Artifacts} artifacts
    * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
@@ -451,7 +417,7 @@ class LegacyJavascript extends ByteEfficiencyAudit {
     const scriptToMatchResults =
       this.detectAcrossScripts(matcher, artifacts.Scripts, networkRecords, bundles);
     for (const [script, matches] of scriptToMatchResults.entries()) {
-      const compressionRatio = await this.estimateCompressionRatioForContent(
+      const compressionRatio = await estimateCompressionRatioForContent(
         compressionRatioByUrl, script.url, artifacts, networkRecords);
       const wastedBytes = Math.round(this.estimateWastedBytes(matches) * compressionRatio);
       /** @type {typeof items[number]} */

package/core/audits/byte-efficiency/unminified-css.js

@@ -8,6 +8,7 @@ import {ByteEfficiencyAudit} from './byte-efficiency-audit.js';
 import {UnusedCSS} from '../../computed/unused-css.js';
 import * as i18n from '../../lib/i18n/i18n.js';
 import {computeCSSTokenLength as computeTokenLength} from '../../lib/minification-estimator.js';
+import {estimateTransferSize} from '../../lib/script-helpers.js';
 
 const UIStrings = {
   /** Imperative title of a Lighthouse audit that tells the user to minify (remove whitespace) the page's CSS code. This is displayed in a list of audit titles that Lighthouse generates. */
@@ -65,8 +66,7 @@ class UnminifiedCSS extends ByteEfficiencyAudit {
       url = contentPreview;
     }
 
-    const totalBytes = ByteEfficiencyAudit.estimateTransferSize(networkRecord, content.length,
-      'Stylesheet');
+    const totalBytes = estimateTransferSize(networkRecord, content.length, 'Stylesheet');
     const wastedRatio = 1 - totalTokenLength / content.length;
     const wastedBytes = Math.round(totalBytes * wastedRatio);
 

package/core/audits/byte-efficiency/unminified-javascript.js

@@ -7,7 +7,7 @@
 import {ByteEfficiencyAudit} from './byte-efficiency-audit.js';
 import * as i18n from '../../lib/i18n/i18n.js';
 import {computeJSTokenLength as computeTokenLength} from '../../lib/minification-estimator.js';
-import {getRequestForScript, isInline} from '../../lib/script-helpers.js';
+import {estimateTransferSize, getRequestForScript, isInline} from '../../lib/script-helpers.js';
 import {Util} from '../../../shared/util.js';
 
 const UIStrings = {
@@ -58,8 +58,7 @@ class UnminifiedJavaScript extends ByteEfficiencyAudit {
     const contentLength = scriptContent.length;
     const totalTokenLength = computeTokenLength(scriptContent);
 
-    const totalBytes = ByteEfficiencyAudit.estimateTransferSize(networkRecord, contentLength,
-      'Script');
+    const totalBytes = estimateTransferSize(networkRecord, contentLength, 'Script');
     const wastedRatio = 1 - totalTokenLength / contentLength;
     const wastedBytes = Math.round(totalBytes * wastedRatio);
 

package/core/audits/byte-efficiency/unused-javascript.js

@@ -8,7 +8,7 @@ import {ByteEfficiencyAudit} from './byte-efficiency-audit.js';
 import {UnusedJavascriptSummary} from '../../computed/unused-javascript-summary.js';
 import {JSBundles} from '../../computed/js-bundles.js';
 import * as i18n from '../../lib/i18n/i18n.js';
-import {getRequestForScript} from '../../lib/script-helpers.js';
+import {estimateTransferSize, getRequestForScript} from '../../lib/script-helpers.js';
 
 const UIStrings = {
   /** Imperative title of a Lighthouse audit that tells the user to reduce JavaScript that is never evaluated during page load. This is displayed in a list of audit titles that Lighthouse generates. */
@@ -99,8 +99,7 @@ class UnusedJavaScript extends ByteEfficiencyAudit {
         await UnusedJavascriptSummary.request({scriptId, scriptCoverage, bundle}, context);
       if (unusedJsSummary.wastedBytes === 0 || unusedJsSummary.totalBytes === 0) continue;
 
-      const transfer = ByteEfficiencyAudit
-        .estimateTransferSize(networkRecord, unusedJsSummary.totalBytes, 'Script');
+      const transfer = estimateTransferSize(networkRecord, unusedJsSummary.totalBytes, 'Script');
       const transferRatio = transfer / unusedJsSummary.totalBytes;
       /** @type {LH.Audit.ByteEfficiencyItem} */
       const item = {

package/core/computed/unused-css.js

@@ -5,9 +5,9 @@
  */
 
 import {makeComputedArtifact} from './computed-artifact.js';
-import {ByteEfficiencyAudit} from '../audits/byte-efficiency/byte-efficiency-audit.js';
 import {NetworkRecords} from './network-records.js';
 import {Util} from '../../shared/util.js';
+import {estimateTransferSize} from '../lib/script-helpers.js';
 
 const PREVIEW_LENGTH = 100;
 
@@ -70,7 +70,7 @@ class UnusedCSS {
       usedUncompressedBytes += usedRule.endOffset - usedRule.startOffset;
     }
 
-    const totalTransferredBytes = ByteEfficiencyAudit.estimateTransferSize(
+    const totalTransferredBytes = estimateTransferSize(
         stylesheetInfo.networkRecord, totalUncompressedBytes, 'Stylesheet');
     const percentUnused = (totalUncompressedBytes - usedUncompressedBytes) / totalUncompressedBytes;
     const wastedBytes = Math.round(percentUnused * totalTransferredBytes);

package/core/lib/script-helpers.d.ts

@@ -4,14 +4,43 @@
  * @return {LH.Artifacts.NetworkRequest|undefined}
  */
 export function getRequestForScript(networkRecords: LH.Artifacts.NetworkRequest[], script: LH.Artifacts.Script): LH.Artifacts.NetworkRequest | undefined;
-/**
- * @license
- * Copyright 2022 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
 /**
  * @param {LH.Artifacts.Script} script
  * @return {boolean}
  */
 export function isInline(script: LH.Artifacts.Script): boolean;
+/**
+ * Estimates the number of bytes the content of this network record would have consumed on the network based on the
+ * uncompressed size (totalBytes). Uses the actual transfer size from the network record if applicable,
+ * minus the size of the response headers.
+ *
+ * This differs from `estimateTransferSize` only in that is subtracts the response headers from the estimate.
+ *
+ * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
+ * @param {number} totalBytes Uncompressed size of the resource
+ * @param {LH.Crdp.Network.ResourceType=} resourceType
+ * @return {number}
+ */
+export function estimateCompressedContentSize(networkRecord: LH.Artifacts.NetworkRequest | undefined, totalBytes: number, resourceType?: LH.Crdp.Network.ResourceType | undefined): number;
+/**
+ * Estimates the number of bytes this network record would have consumed on the network based on the
+ * uncompressed size (totalBytes). Uses the actual transfer size from the network record if applicable.
+ *
+ * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
+ * @param {number} totalBytes Uncompressed size of the resource
+ * @param {LH.Crdp.Network.ResourceType=} resourceType
+ * @return {number}
+ */
+export function estimateTransferSize(networkRecord: LH.Artifacts.NetworkRequest | undefined, totalBytes: number, resourceType?: LH.Crdp.Network.ResourceType | undefined): number;
+/**
+ * Utility function to estimate the ratio of the compression on the resource.
+ * This excludes the size of the response headers.
+ * Also caches the calculation.
+ * @param {Map<string, number>} compressionRatioByUrl
+ * @param {string} url
+ * @param {LH.Artifacts} artifacts
+ * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+ */
+export function estimateCompressionRatioForContent(compressionRatioByUrl: Map<string, number>, url: string, artifacts: LH.Artifacts, networkRecords: Array<LH.Artifacts.NetworkRequest>): Promise<number>;
+import { NetworkRequest } from './network-request.js';
 //# sourceMappingURL=script-helpers.d.ts.map

package/core/lib/script-helpers.js

@@ -4,6 +4,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import {NetworkRequest} from './network-request.js';
+
 /**
  * @param {LH.Artifacts.Script} script
  * @return {boolean}
@@ -25,7 +27,141 @@ function getRequestForScript(networkRecords, script) {
   return networkRequest;
 }
 
+/**
+ * Estimates the number of bytes this network record would have consumed on the network based on the
+ * uncompressed size (totalBytes). Uses the actual transfer size from the network record if applicable.
+ *
+ * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
+ * @param {number} totalBytes Uncompressed size of the resource
+ * @param {LH.Crdp.Network.ResourceType=} resourceType
+ * @return {number}
+ */
+function estimateTransferSize(networkRecord, totalBytes, resourceType) {
+  if (!networkRecord) {
+    // We don't know how many bytes this asset used on the network, but we can guess it was
+    // roughly the size of the content gzipped.
+    // See https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/optimize-encoding-and-transfer for specific CSS/Script examples
+    // See https://discuss.httparchive.org/t/file-size-and-compression-savings/145 for fallback multipliers
+    switch (resourceType) {
+      case 'Stylesheet':
+        // Stylesheets tend to compress extremely well.
+        return Math.round(totalBytes * 0.2);
+      case 'Script':
+      case 'Document':
+        // Scripts and HTML compress fairly well too.
+        return Math.round(totalBytes * 0.33);
+      default:
+        // Otherwise we'll just fallback to the average savings in HTTPArchive
+        return Math.round(totalBytes * 0.5);
+    }
+  } else if (networkRecord.resourceType === resourceType) {
+    // This was a regular standalone asset, just use the transfer size.
+    return networkRecord.transferSize || 0;
+  } else {
+    // This was an asset that was inlined in a different resource type (e.g. HTML document).
+    // Use the compression ratio of the resource to estimate the total transferred bytes.
+    const transferSize = networkRecord.transferSize || 0;
+    const resourceSize = networkRecord.resourceSize || 0;
+    // Get the compression ratio, if it's an invalid number, assume no compression.
+    const compressionRatio = Number.isFinite(resourceSize) && resourceSize > 0 ?
+      (transferSize / resourceSize) : 1;
+    return Math.round(totalBytes * compressionRatio);
+  }
+}
+
+/**
+ * Estimates the number of bytes the content of this network record would have consumed on the network based on the
+ * uncompressed size (totalBytes). Uses the actual transfer size from the network record if applicable,
+ * minus the size of the response headers.
+ *
+ * This differs from `estimateTransferSize` only in that is subtracts the response headers from the estimate.
+ *
+ * @param {LH.Artifacts.NetworkRequest|undefined} networkRecord
+ * @param {number} totalBytes Uncompressed size of the resource
+ * @param {LH.Crdp.Network.ResourceType=} resourceType
+ * @return {number}
+ */
+function estimateCompressedContentSize(networkRecord, totalBytes, resourceType) {
+  if (!networkRecord) {
+    // We don't know how many bytes this asset used on the network, but we can guess it was
+    // roughly the size of the content gzipped.
+    // See https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/optimize-encoding-and-transfer for specific CSS/Script examples
+    // See https://discuss.httparchive.org/t/file-size-and-compression-savings/145 for fallback multipliers
+    switch (resourceType) {
+      case 'Stylesheet':
+        // Stylesheets tend to compress extremely well.
+        return Math.round(totalBytes * 0.2);
+      case 'Script':
+      case 'Document':
+        // Scripts and HTML compress fairly well too.
+        return Math.round(totalBytes * 0.33);
+      default:
+        // Otherwise we'll just fallback to the average savings in HTTPArchive
+        return Math.round(totalBytes * 0.5);
+    }
+  }
+
+  // Get the size of the response body on the network.
+  let contentTransferSize = networkRecord.transferSize || 0;
+  if (!NetworkRequest.isContentEncoded(networkRecord)) {
+    // This is not encoded, so we can use resourceSize directly.
+    // This would be equivalent to transfer size minus headers transfer size, but transfer size
+    // may also include bytes for SSL connection etc.
+    contentTransferSize = networkRecord.resourceSize;
+  } else if (networkRecord.responseHeadersTransferSize) {
+    // Subtract the size of the encoded headers.
+    contentTransferSize =
+      Math.max(0, contentTransferSize - networkRecord.responseHeadersTransferSize);
+  }
+
+  if (networkRecord.resourceType === resourceType) {
+    // This was a regular standalone asset, just use the transfer size.
+    return contentTransferSize;
+  } else {
+    // This was an asset that was inlined in a different resource type (e.g. HTML document).
+    // Use the compression ratio of the resource to estimate the total transferred bytes.
+    const resourceSize = networkRecord.resourceSize || 0;
+    // Get the compression ratio, if it's an invalid number, assume no compression.
+    const compressionRatio = Number.isFinite(resourceSize) && resourceSize > 0 ?
+      (contentTransferSize / resourceSize) : 1;
+    return Math.round(totalBytes * compressionRatio);
+  }
+}
+
+/**
+ * Utility function to estimate the ratio of the compression on the resource.
+ * This excludes the size of the response headers.
+ * Also caches the calculation.
+ * @param {Map<string, number>} compressionRatioByUrl
+ * @param {string} url
+ * @param {LH.Artifacts} artifacts
+ * @param {Array<LH.Artifacts.NetworkRequest>} networkRecords
+ */
+async function estimateCompressionRatioForContent(compressionRatioByUrl, url,
+  artifacts, networkRecords) {
+  let compressionRatio = compressionRatioByUrl.get(url);
+  if (compressionRatio !== undefined) return compressionRatio;
+
+  const script = artifacts.Scripts.find(script => script.url === url);
+
+  if (!script) {
+    // Can't find content, so just use 1.
+    compressionRatio = 1;
+  } else {
+    const networkRecord = getRequestForScript(networkRecords, script);
+    const contentLength = networkRecord?.resourceSize || script.length || 0;
+    const compressedSize = estimateCompressedContentSize(networkRecord, contentLength, 'Script');
+    compressionRatio = compressedSize / contentLength;
+  }
+
+  compressionRatioByUrl.set(url, compressionRatio);
+  return compressionRatio;
+}
+
 export {
   getRequestForScript,
   isInline,
+  estimateCompressedContentSize,
+  estimateTransferSize,
+  estimateCompressionRatioForContent,
 };