static async compute_(artifacts, context) {
    const bundles = await JSBundles.request(artifacts, context);

    /**
     * @typedef SourceData
     * @property {string} source
     * @property {number} resourceSize
     */

    /** @type {Map<LH.Artifacts.RawSourceMap, SourceData[]>} */
    const sourceDatasMap = new Map();

    // Determine size of each `sources` entry.
    for (const {rawMap, sizes} of bundles) {
      if ('errorMessage' in sizes) continue;

      /** @type {SourceData[]} */
      const sourceDataArray = [];
      sourceDatasMap.set(rawMap, sourceDataArray);

      for (let i = 0; i < rawMap.sources.length; i++) {
        if (this._shouldIgnoreSource(rawMap.sources[i])) continue;

        const sourceKey = (rawMap.sourceRoot || '') + rawMap.sources[i];
        const sourceSize = sizes.files[sourceKey];
        sourceDataArray.push({
          source: ModuleDuplication.normalizeSource(rawMap.sources[i]),
          resourceSize: sourceSize,
        });
      }
    }

    /** @type {Map<string, Array<{scriptId: string, scriptUrl: string, resourceSize: number}>>} */
    const moduleNameToSourceData = new Map();
    for (const {rawMap, script} of bundles) {
      const sourceDataArray = sourceDatasMap.get(rawMap);
      if (!sourceDataArray) continue;

      for (const sourceData of sourceDataArray) {
        let data = moduleNameToSourceData.get(sourceData.source);
        if (!data) {
          data = [];
          moduleNameToSourceData.set(sourceData.source, data);
        }
        data.push({
          scriptId: script.scriptId,
          scriptUrl: script.url,
          resourceSize: sourceData.resourceSize,
        });
      }
    }

    this._normalizeAggregatedData(moduleNameToSourceData);
    return moduleNameToSourceData;
  }
@param {Pick<LH.Artifacts, 'Scripts'|'SourceMaps'>} artifacts
@param {LH.Artifacts.ComputedContext} context