+/**+ * @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';++const TreemapData_ = require('../../audits/treemap-data.js');+const networkRecordsToDevtoolsLog = require('../network-records-to-devtools-log.js');+const {loadSourceMapFixture, makeParamsOptional} = require('../test-utils.js');++/* eslint-env jest */++const TreemapData = {+  audit: makeParamsOptional(TreemapData_.audit),+  prepareTreemapNodes: makeParamsOptional(TreemapData_.prepareTreemapNodes),+};++/**+ * @param {string} name+ */+function load(name) {+  const data = loadSourceMapFixture(name);+  if (!data.usage) throw new Error('exepcted usage');

 class Driver {     }   } +  /**+   * @param {string} url+   * @param {(LH.IcuMessage | string)[]} LighthouseRunWarnings+   */+  async getImportantStorageWarning(url, LighthouseRunWarnings) {+    const usageData = await this.sendCommand('Storage.getUsageAndQuota', {+      origin: url,+    });+    /** @type {Object.<string, string>} */+    const storageTypeNames = {+      local_storage: 'Local Storage',+      indexeddb: 'IndexedDB',+      websql: 'Web SQL',+    };+    const locations = usageData.usageBreakdown+      .filter(usage => usage.usage)+      .map(usage => storageTypeNames[usage.storageType] || '')+      .filter(Boolean);+    if (locations.length) {+      LighthouseRunWarnings.push(str_(+        UIStrings.warningData,+        {locations: locations.join(', '), locationCount: locations.length}

 describe('.goOnline', () => {   }); }); +describe('.clearDataForOrigin', () => {+  it('only clears data from certain locations', async () => {+    let foundStorageTypes;+    connectionStub.sendCommand = createMockSendCommandFn()+      .mockResponse('Storage.clearDataForOrigin', ({storageTypes}) => {+        foundStorageTypes = storageTypes;+      });+    await driver.clearDataForOrigin('https://example.com');+    expect(foundStorageTypes).toMatchInlineSnapshot(

 class Driver {     }   } +  /**+   * @param {string} url+   * @param {(LH.IcuMessage | string)[]} LighthouseRunWarnings+   */+  async getImportantStorageWarning(url, LighthouseRunWarnings) {+    const usageData = await this.sendCommand('Storage.getUsageAndQuota', {+      origin: url,+    });+    /** @type {Object.<string, string>} */

+/**+ * @license Copyright 2020 Google Inc. 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 treemap data for webtreemap.+ */++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');+const NetworkRecords = require('../computed/network-records.js');+const ResourceSummary = require('../computed/resource-summary.js');++/**+ * @typedef {Record<string, RootNode[]>} TreemapData+ */++/**+ * @typedef RootNode+ * @property {string} name+ * @property {Node} node+ */++/**+ * @typedef Node+ * @property {string} name+ * @property {number} resourceBytes+ * @property {number=} unusedBytes+ * @property {number=} executionTime+ * @property {string=} duplicate+ * @property {Node[]=} children+ */++/**+ * @typedef {Omit<Node, 'name'|'children'>} SourceData+ */++class TreemapDataAudit extends Audit {+  /**+   * @return {LH.Audit.Meta}+   */+  static get meta() {+    return {+      id: 'treemap-data',+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,+      title: 'Treemap Data',+      description: 'Used for treemap visualization.',+      requiredArtifacts:+        ['traces', 'devtoolsLogs', 'SourceMaps', 'ScriptElements', 'JsUsage', 'URL'],+    };+  }++  /**+   * @param {string} sourceRoot+   * @param {Record<string, SourceData>} sourcesData+   * @return {Node}+   */+  static prepareTreemapNodes(sourceRoot, sourcesData) {+    /**+     * @param {string} name+     * @return {Node}+     */+    function newNode(name) {+      return {+        name,+        resourceBytes: 0,+      };+    }++    /**+     * 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+     * @param {Node} node+     */+    function addNode(source, data, node) {+      // Strip off the shared root.+      const sourcePathSegments = source.replace(sourceRoot, '').split(/\/+/);+      sourcePathSegments.forEach((sourcePathSegment, i) => {+        const isLastSegment = 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;+        if (data.duplicate !== undefined && isLastSegment) {+          node.duplicate = data.duplicate;+        }+      });+    }++    const rootNode = newNode(sourceRoot);++    // 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)) {+      addNode(source || `<unmapped>`, data, rootNode);++      // Apply the data to the rootNode.+      rootNode.resourceBytes += data.resourceBytes;+      if (data.unusedBytes) rootNode.unusedBytes = (rootNode.unusedBytes || 0) + data.unusedBytes;+    }++    /**+     * Collapse nodes that have only one child.+     * @param {*} node+     */+    function collapse(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) {+          collapse(child);+        }+      }+    }+    collapse(rootNode);++    // TODO(cjamcl): Should this structure be flattened for space savings?+    // Like DOM Snapshot.+    // Less JSON (no super nested children, and no repeated property names).++    return rootNode;+  }++  /**+   * @param {LH.Artifacts} artifacts+   * @param {LH.Audit.Context} context+   * @return {Promise<RootNode[]>}+   */+  static async makeJavaScriptRootNodes(artifacts, context) {+    /** @type {RootNode[]} */+    const rootNodes = [];++    const bundles = await JsBundles.request(artifacts, context);+    const duplication = await ModuleDuplication.request(artifacts, context);++    /** @type {Array<{src: string, length: number, unusedJavascriptSummary?: import('../computed/unused-javascript-summary.js').Summary}>} */+    const scriptData = [];+    const inlineScriptData = {+      src: artifacts.URL.finalUrl,+      length: 0,+    };+    for (const scriptElement of artifacts.ScriptElements) {+      // Normalize ScriptElements so that inline scripts show up as a single entity.+      if (!scriptElement.src) {+        inlineScriptData.length += (scriptElement.content || '').length;+        continue;+      }++      const url = scriptElement.src;+      const bundle = bundles.find(bundle => url === bundle.script.src);+      const scriptCoverages = artifacts.JsUsage[url];+      if (!bundle || !scriptCoverages) continue;++      scriptData.push({+        src: scriptElement.src,+        length: (scriptElement.content || '').length,+        unusedJavascriptSummary:+          await UnusedJavaScriptSummary.request({url, scriptCoverages, bundle}, context),+      });+    }+    if (inlineScriptData.length) scriptData.unshift(inlineScriptData);++    for (const {src, length, unusedJavascriptSummary} of scriptData) {+      const bundle = bundles.find(bundle => bundle.script.src === src);+      const name = src;++      let node;+      if (bundle && unusedJavascriptSummary && unusedJavascriptSummary.sourcesWastedBytes) {+        /** @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 && unusedJavascriptSummary.sourcesWastedBytes) {+            sourceData.unusedBytes = unusedJavascriptSummary.sourcesWastedBytes[source];+          }++          if (duplication) {+            const key = ModuleDuplication._normalizeSource(source);+            if (duplication.has(key)) sourceData.duplicate = key;+          }++          sourcesData[source] = sourceData;+        }++        node = this.prepareTreemapNodes(bundle.rawMap.sourceRoot || '', sourcesData);+      } else if (unusedJavascriptSummary) {+        node = {+          name,+          resourceBytes: unusedJavascriptSummary.totalBytes,+          unusedBytes: unusedJavascriptSummary.wastedBytes,+          executionTime: 0,+        };+      } else {+        // TODO ...?+        node = {+          name,+          resourceBytes: length,+          unusedBytes: 0,+          executionTime: 0,+        };+      }++      rootNodes.push({+        name: name,+        node,+      });+    }++    return rootNodes;+  }++  /**+   * @param {LH.Artifacts.Bundle[]} bundles+   * @param {string} url+   * @param {LH.Artifacts['JsUsage']} JsUsage+   * @param {LH.Audit.Context} context+   */+  static async getUnusedJavascriptSummary(bundles, url, JsUsage, context) {+    const bundle = bundles.find(bundle => url === bundle.script.src);+    const scriptCoverages = JsUsage[url];+    if (!scriptCoverages) return;++    const unusedJsSumary =+      await UnusedJavaScriptSummary.request({url, scriptCoverages, bundle}, context);+    return unusedJsSumary;+  }++  /**+   * @param {LH.Artifacts} artifacts+   * @param {LH.Audit.Context} context+   * @return {Promise<RootNode>}+   */+  static async makeResourceSummaryRootNode(artifacts, context) {+    const devtoolsLog = artifacts.devtoolsLogs[Audit.DEFAULT_PASS];+    const networkRecords = await NetworkRecords.request(devtoolsLog, context);+    const origin = new URL(artifacts.URL.finalUrl).origin;++    const totalCount = networkRecords.length;+    let totalSize = 0;++    /** @type {Node[]} */+    const children = [];+    for (const networkRecord of networkRecords) {+      const resourceType = ResourceSummary.determineResourceType(networkRecord);++      let child = children.find(child => child.name === resourceType);+      if (!child) {+        child = {+          name: resourceType,+          resourceBytes: 0,+          children: [],+        };+        children.push(child);+      }++      totalSize += networkRecord.resourceSize;+      child.resourceBytes += networkRecord.resourceSize;++      let name = networkRecord.url;+      // TODO ...+      if (name.startsWith(origin)) name = name.replace(origin, '/');+      child.children = child.children || [];+      child.children.push({+        name,+        resourceBytes: networkRecord.resourceSize,+      });+    }++    return {+      name: 'Resource Summary',+      node: {+        name: `${totalCount} requests`,+        resourceBytes: totalSize,+        children,+      },+    };+  }++  /**+   * @param {LH.Artifacts} artifacts+   * @param {LH.Audit.Context} context+   * @return {Promise<LH.Audit.Product>}+   */+  static async audit(artifacts, context) {+    /** @type {TreemapData} */+    const treemapData = {+      scripts: await TreemapDataAudit.makeJavaScriptRootNodes(artifacts, context),+      resources: [await TreemapDataAudit.makeResourceSummaryRootNode(artifacts, context)],+    };++    /** @type {LH.Audit.Details.DebugData} */

 function getProtoRoundTrip() {   }; } +/**+ * @typedef PartialScriptCoverage+ * @property {string} url+ * @property {Array<{ranges: LH.Crdp.Profiler.CoverageRange[]}>} functions+ */++/**+ * @param {string} name+ * @return {{map: LH.Artifacts.RawSourceMap, content: string, usage?: PartialScriptCoverage}}

+/**+ * @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';++const TreemapData_ = require('../../audits/treemap-data.js');+const networkRecordsToDevtoolsLog = require('../network-records-to-devtools-log.js');+const {loadSourceMapFixture, makeParamsOptional} = require('../test-utils.js');++/* eslint-env jest */++const TreemapData = {+  audit: makeParamsOptional(TreemapData_.audit),+  prepareTreemapNodes: makeParamsOptional(TreemapData_.prepareTreemapNodes),+};++/**+ * @param {string} name+ */+function load(name) {+  const data = loadSourceMapFixture(name);+  if (!data.usage) throw new Error('exepcted usage');+  return {...data, usage: data.usage};+}++/**+ * @param {string} url+ * @param {number} transferSize+ * @param {LH.Crdp.Network.ResourceType} resourceType+ */+function generateRecord(url, transferSize, resourceType) {+  return {url, transferSize, resourceType};+}++describe('TreemapData audit', () => {+  describe('squoosh fixture', () => {+    /** @type {import('../../audits/treemap-data.js').TreemapData} */+    let treemapData;+    beforeAll(async () => {+      const context = {computedCache: new Map()};+      const {map, content, usage} = load('squoosh');+      const mainUrl = 'https://squoosh.app';+      const scriptUrl = 'https://squoosh.app/main-app.js';+      const networkRecords = [generateRecord(scriptUrl, content.length, 'Script')];++      const artifacts = {+        URL: {requestedUrl: mainUrl, finalUrl: mainUrl},+        JsUsage: {[usage.url]: [usage]},+        devtoolsLogs: {defaultPass: networkRecordsToDevtoolsLog(networkRecords)},+        SourceMaps: [{scriptUrl: scriptUrl, map}],+        ScriptElements: [{src: scriptUrl, content}],+      };+      const results = await TreemapData.audit(artifacts, context);++      // @ts-expect-error: Debug data.+      treemapData = results.details.treemapData;+    });++    it('basics', () => {+      expect(Object.keys(treemapData)).toEqual(['scripts', 'resources']);+    });++    it('js', () => {+      expect(treemapData.scripts).toMatchSnapshot();+    });++    it('resource summary', () => {

+/**+ * @license Copyright 2020 Google Inc. 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 treemap data for webtreemap.+ */++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');+const NetworkRecords = require('../computed/network-records.js');+const ResourceSummary = require('../computed/resource-summary.js');++/**+ * @typedef {Record<string, RootNode[]>} TreemapData+ */++/**+ * @typedef RootNode+ * @property {string} name+ * @property {Node} node+ */++/**+ * @typedef Node+ * @property {string} name+ * @property {number} resourceBytes+ * @property {number=} unusedBytes+ * @property {number=} executionTime+ * @property {string=} duplicate+ * @property {Node[]=} children+ */++/**+ * @typedef {Omit<Node, 'name'|'children'>} SourceData+ */++class TreemapDataAudit extends Audit {+  /**+   * @return {LH.Audit.Meta}+   */+  static get meta() {+    return {+      id: 'treemap-data',+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,+      title: 'Treemap Data',+      description: 'Used for treemap app.',+      requiredArtifacts:+        ['traces', 'devtoolsLogs', 'SourceMaps', 'ScriptElements', 'JsUsage', 'URL'],+    };+  }++  /**+   * @param {string} sourceRoot+   * @param {Record<string, SourceData>} sourcesData+   * @return {Node}+   */+  static prepareTreemapNodes(sourceRoot, sourcesData) {+    /**+     * @param {string} name+     * @return {Node}+     */+    function newNode(name) {+      return {+        name,+        resourceBytes: 0,+      };+    }++    /**+     * 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+     * @param {Node} node+     */+    function addNode(source, data, node) {+      // Strip off the shared root.+      const sourcePathSegments = source.replace(sourceRoot, '').split(/\/+/);+      sourcePathSegments.forEach((sourcePathSegment, i) => {+        const isLastSegment = 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;+        if (data.duplicate !== undefined && isLastSegment) {+          node.duplicate = data.duplicate;+        }+      });+    }++    const rootNode = newNode(sourceRoot);++    // 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)) {+      addNode(source || `<unmapped>`, data, rootNode);++      // Apply the data to the rootNode.+      rootNode.resourceBytes += data.resourceBytes;+      if (data.unusedBytes) rootNode.unusedBytes = (rootNode.unusedBytes || 0) + data.unusedBytes;+    }++    /**+     * Collapse nodes that have only one child.+     * @param {Node} node+     */+    function collapse(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) {+          collapse(child);+        }+      }+    }+    collapse(rootNode);++    // TODO(cjamcl): Should this structure be flattened for space savings?+    // Like DOM Snapshot.+    // Less JSON (no super nested children, and no repeated property names).++    return rootNode;+  }++  /**+   * @param {LH.Artifacts} artifacts+   * @param {LH.Audit.Context} context+   * @return {Promise<RootNode[]>}+   */+  static async makeJavaScriptRootNodes(artifacts, context) {+    /** @type {RootNode[]} */+    const rootNodes = [];++    const bundles = await JsBundles.request(artifacts, context);+    const duplication = await ModuleDuplication.request(artifacts, context);++    /** @type {Array<{src: string, length: number, unusedJavascriptSummary?: import('../computed/unused-javascript-summary.js').Summary}>} */+    const scriptData = [];+    const inlineScriptData = {+      src: artifacts.URL.finalUrl,+      length: 0,+    };+    for (const scriptElement of artifacts.ScriptElements) {+      // Normalize ScriptElements so that inline scripts show up as a single entity.+      if (!scriptElement.src) {+        inlineScriptData.length += (scriptElement.content || '').length;+        continue;+      }++      const url = scriptElement.src;+      const bundle = bundles.find(bundle => url === bundle.script.src);+      const scriptCoverages = artifacts.JsUsage[url];+      if (!bundle || !scriptCoverages) continue;++      scriptData.push({+        src: scriptElement.src,+        length: (scriptElement.content || '').length,+        unusedJavascriptSummary:+          await UnusedJavaScriptSummary.request({url, scriptCoverages, bundle}, context),+      });+    }+    if (inlineScriptData.length) scriptData.unshift(inlineScriptData);++    for (const {src, length, unusedJavascriptSummary} of scriptData) {+      const bundle = bundles.find(bundle => bundle.script.src === src);+      const name = src;++      let node;+      if (bundle && unusedJavascriptSummary && unusedJavascriptSummary.sourcesWastedBytes) {+        /** @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 && unusedJavascriptSummary.sourcesWastedBytes) {+            sourceData.unusedBytes = unusedJavascriptSummary.sourcesWastedBytes[source];+          }++          if (duplication) {+            const key = ModuleDuplication._normalizeSource(source);+            if (duplication.has(key)) sourceData.duplicate = key;+          }++          sourcesData[source] = sourceData;+        }++        node = this.prepareTreemapNodes(bundle.rawMap.sourceRoot || '', sourcesData);+      } else if (unusedJavascriptSummary) {+        node = {+          name,+          resourceBytes: unusedJavascriptSummary.totalBytes,+          unusedBytes: unusedJavascriptSummary.wastedBytes,+          executionTime: 0,+        };+      } else {+        node = {+          name,+          resourceBytes: length,+          unusedBytes: 0,+          executionTime: 0,+        };+      }++      rootNodes.push({+        name,+        node,+      });+    }++    return rootNodes;+  }++  /**

+/**+ * @license Copyright 2020 Google Inc. 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 treemap data for webtreemap.+ */++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');+const NetworkRecords = require('../computed/network-records.js');+const ResourceSummary = require('../computed/resource-summary.js');++/**+ * @typedef {Record<string, RootNode[]>} TreemapData+ */++/**+ * @typedef RootNode+ * @property {string} name+ * @property {Node} node+ */++/**+ * @typedef Node+ * @property {string} name+ * @property {number} resourceBytes+ * @property {number=} unusedBytes+ * @property {number=} executionTime+ * @property {string=} duplicate+ * @property {Node[]=} children+ */++/**+ * @typedef {Omit<Node, 'name'|'children'>} SourceData+ */++class TreemapDataAudit extends Audit {+  /**+   * @return {LH.Audit.Meta}+   */+  static get meta() {+    return {+      id: 'treemap-data',+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,+      title: 'Treemap Data',+      description: 'Used for treemap app.',+      requiredArtifacts:+        ['traces', 'devtoolsLogs', 'SourceMaps', 'ScriptElements', 'JsUsage', 'URL'],+    };+  }++  /**

+/**+ * @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';++const TreemapData_ = require('../../audits/treemap-data.js');+const networkRecordsToDevtoolsLog = require('../network-records-to-devtools-log.js');+const {loadSourceMapFixture, makeParamsOptional} = require('../test-utils.js');++/* eslint-env jest */++const TreemapData = {+  audit: makeParamsOptional(TreemapData_.audit),+  prepareTreemapNodes: makeParamsOptional(TreemapData_.prepareTreemapNodes),+};++/**+ * @param {string} name+ */+function load(name) {+  const data = loadSourceMapFixture(name);+  if (!data.usage) throw new Error('exepcted usage');

+/**+ * @license Copyright 2020 Google Inc. 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 treemap data for webtreemap.+ */++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');+const NetworkRecords = require('../computed/network-records.js');+const ResourceSummary = require('../computed/resource-summary.js');++/**+ * @typedef {Record<string, RootNode[]>} TreemapData+ */++/**+ * @typedef RootNode+ * @property {string} name+ * @property {Node} node+ */++/**+ * @typedef Node+ * @property {string} name+ * @property {number} resourceBytes+ * @property {number=} unusedBytes+ * @property {number=} executionTime+ * @property {string=} duplicate+ * @property {Node[]=} children+ */++/**+ * @typedef {Omit<Node, 'name'|'children'>} SourceData+ */++class TreemapDataAudit extends Audit {+  /**+   * @return {LH.Audit.Meta}+   */+  static get meta() {+    return {+      id: 'treemap-data',+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,+      title: 'Treemap Data',+      description: 'Used for treemap app.',+      requiredArtifacts:+        ['traces', 'devtoolsLogs', 'SourceMaps', 'ScriptElements', 'JsUsage', 'URL'],+    };+  }++  /**+   * @param {string} sourceRoot+   * @param {Record<string, SourceData>} sourcesData+   * @return {Node}+   */+  static prepareTreemapNodes(sourceRoot, sourcesData) {+    /**+     * @param {string} name+     * @return {Node}+     */+    function newNode(name) {+      return {+        name,+        resourceBytes: 0,+      };+    }++    /**+     * 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+     * @param {Node} node+     */+    function addNode(source, data, node) {+      // Strip off the shared root.+      const sourcePathSegments = source.replace(sourceRoot, '').split(/\/+/);+      sourcePathSegments.forEach((sourcePathSegment, i) => {+        const isLastSegment = 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;+        if (data.duplicate !== undefined && isLastSegment) {+          node.duplicate = data.duplicate;+        }+      });+    }++    const rootNode = newNode(sourceRoot);++    // 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)) {+      addNode(source || `<unmapped>`, data, rootNode);++      // Apply the data to the rootNode.+      rootNode.resourceBytes += data.resourceBytes;+      if (data.unusedBytes) rootNode.unusedBytes = (rootNode.unusedBytes || 0) + data.unusedBytes;+    }++    /**+     * Collapse nodes that have only one child.+     * @param {Node} node+     */+    function collapse(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) {+          collapse(child);+        }+      }+    }+    collapse(rootNode);++    // TODO(cjamcl): Should this structure be flattened for space savings?+    // Like DOM Snapshot.+    // Less JSON (no super nested children, and no repeated property names).++    return rootNode;+  }++  /**+   * @param {LH.Artifacts} artifacts+   * @param {LH.Audit.Context} context+   * @return {Promise<RootNode[]>}+   */+  static async makeJavaScriptRootNodes(artifacts, context) {+    /** @type {RootNode[]} */+    const rootNodes = [];++    const bundles = await JsBundles.request(artifacts, context);+    const duplication = await ModuleDuplication.request(artifacts, context);++    /** @type {Array<{src: string, length: number, unusedJavascriptSummary?: import('../computed/unused-javascript-summary.js').Summary}>} */+    const scriptData = [];+    const inlineScriptData = {+      src: artifacts.URL.finalUrl,+      length: 0,+    };+    for (const scriptElement of artifacts.ScriptElements) {+      // Normalize ScriptElements so that inline scripts show up as a single entity.+      if (!scriptElement.src) {+        inlineScriptData.length += (scriptElement.content || '').length;+        continue;+      }++      const url = scriptElement.src;+      const bundle = bundles.find(bundle => url === bundle.script.src);+      const scriptCoverages = artifacts.JsUsage[url];+      if (!bundle || !scriptCoverages) continue;++      scriptData.push({+        src: scriptElement.src,+        length: (scriptElement.content || '').length,+        unusedJavascriptSummary:+          await UnusedJavaScriptSummary.request({url, scriptCoverages, bundle}, context),+      });+    }+    if (inlineScriptData.length) scriptData.unshift(inlineScriptData);++    for (const {src, length, unusedJavascriptSummary} of scriptData) {+      const bundle = bundles.find(bundle => bundle.script.src === src);+      const name = src;++      let node;+      if (bundle && unusedJavascriptSummary && unusedJavascriptSummary.sourcesWastedBytes) {+        /** @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 && unusedJavascriptSummary.sourcesWastedBytes) {+            sourceData.unusedBytes = unusedJavascriptSummary.sourcesWastedBytes[source];+          }++          if (duplication) {+            const key = ModuleDuplication._normalizeSource(source);

+/**+ * @license Copyright 2020 Google Inc. 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 treemap data for webtreemap.+ */++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');+const NetworkRecords = require('../computed/network-records.js');+const ResourceSummary = require('../computed/resource-summary.js');++/**+ * @typedef {Record<string, RootNode[]>} TreemapData+ */++/**+ * @typedef RootNode+ * @property {string} name+ * @property {Node} node+ */++/**+ * @typedef Node+ * @property {string} name+ * @property {number} resourceBytes+ * @property {number=} unusedBytes+ * @property {number=} executionTime+ * @property {string=} duplicate+ * @property {Node[]=} children+ */++/**+ * @typedef {Omit<Node, 'name'|'children'>} SourceData+ */++class TreemapDataAudit extends Audit {+  /**+   * @return {LH.Audit.Meta}+   */+  static get meta() {+    return {+      id: 'treemap-data',+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,+      title: 'Treemap Data',+      description: 'Used for treemap app.',+      requiredArtifacts:+        ['traces', 'devtoolsLogs', 'SourceMaps', 'ScriptElements', 'JsUsage', 'URL'],+    };+  }++  /**+   * @param {string} sourceRoot+   * @param {Record<string, SourceData>} sourcesData+   * @return {Node}+   */+  static prepareTreemapNodes(sourceRoot, sourcesData) {+    /**+     * @param {string} name+     * @return {Node}+     */+    function newNode(name) {+      return {+        name,+        resourceBytes: 0,+      };+    }++    /**+     * 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+     * @param {Node} node+     */+    function addNode(source, data, node) {+      // Strip off the shared root.+      const sourcePathSegments = source.replace(sourceRoot, '').split(/\/+/);+      sourcePathSegments.forEach((sourcePathSegment, i) => {+        const isLastSegment = 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;+        if (data.duplicate !== undefined && isLastSegment) {+          node.duplicate = data.duplicate;+        }+      });+    }++    const rootNode = newNode(sourceRoot);++    // 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)) {+      addNode(source || `<unmapped>`, data, rootNode);++      // Apply the data to the rootNode.+      rootNode.resourceBytes += data.resourceBytes;+      if (data.unusedBytes) rootNode.unusedBytes = (rootNode.unusedBytes || 0) + data.unusedBytes;+    }++    /**+     * Collapse nodes that have only one child.+     * @param {Node} node+     */+    function collapse(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) {+          collapse(child);+        }+      }+    }+    collapse(rootNode);++    // TODO(cjamcl): Should this structure be flattened for space savings?+    // Like DOM Snapshot.+    // Less JSON (no super nested children, and no repeated property names).++    return rootNode;+  }++  /**+   * @param {LH.Artifacts} artifacts+   * @param {LH.Audit.Context} context+   * @return {Promise<RootNode[]>}+   */+  static async makeJavaScriptRootNodes(artifacts, context) {+    /** @type {RootNode[]} */+    const rootNodes = [];++    const bundles = await JsBundles.request(artifacts, context);+    const duplication = await ModuleDuplication.request(artifacts, context);++    /** @type {Array<{src: string, length: number, unusedJavascriptSummary?: import('../computed/unused-javascript-summary.js').Summary}>} */+    const scriptData = [];+    const inlineScriptData = {+      src: artifacts.URL.finalUrl,+      length: 0,+    };+    for (const scriptElement of artifacts.ScriptElements) {+      // Normalize ScriptElements so that inline scripts show up as a single entity.+      if (!scriptElement.src) {+        inlineScriptData.length += (scriptElement.content || '').length;+        continue;+      }++      const url = scriptElement.src;+      const bundle = bundles.find(bundle => url === bundle.script.src);+      const scriptCoverages = artifacts.JsUsage[url];+      if (!bundle || !scriptCoverages) continue;++      scriptData.push({+        src: scriptElement.src,+        length: (scriptElement.content || '').length,+        unusedJavascriptSummary:+          await UnusedJavaScriptSummary.request({url, scriptCoverages, bundle}, context),+      });+    }+    if (inlineScriptData.length) scriptData.unshift(inlineScriptData);++    for (const {src, length, unusedJavascriptSummary} of scriptData) {+      const bundle = bundles.find(bundle => bundle.script.src === src);+      const name = src;++      let node;+      if (bundle && unusedJavascriptSummary && unusedJavascriptSummary.sourcesWastedBytes) {+        /** @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 && unusedJavascriptSummary.sourcesWastedBytes) {+            sourceData.unusedBytes = unusedJavascriptSummary.sourcesWastedBytes[source];+          }++          if (duplication) {

+/**+ * @license Copyright 2020 Google Inc. 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 treemap data for webtreemap.+ */++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');+const NetworkRecords = require('../computed/network-records.js');+const ResourceSummary = require('../computed/resource-summary.js');++/**+ * @typedef {Record<string, RootNode[]>} TreemapData+ */++/**+ * @typedef RootNode+ * @property {string} name+ * @property {Node} node+ */++/**+ * @typedef Node+ * @property {string} name

+/**+ * @license Copyright 2020 Google Inc. 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 treemap data for webtreemap.+ */++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');+const NetworkRecords = require('../computed/network-records.js');+const ResourceSummary = require('../computed/resource-summary.js');++/**+ * @typedef {Record<string, RootNode[]>} TreemapData+ */++/**+ * @typedef RootNode+ * @property {string} name+ * @property {Node} node+ */++/**+ * @typedef Node+ * @property {string} name+ * @property {number} resourceBytes+ * @property {number=} unusedBytes+ * @property {number=} executionTime+ * @property {string=} duplicate+ * @property {Node[]=} children+ */++/**+ * @typedef {Omit<Node, 'name'|'children'>} SourceData+ */++class TreemapDataAudit extends Audit {+  /**+   * @return {LH.Audit.Meta}+   */+  static get meta() {+    return {+      id: 'treemap-data',+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,+      title: 'Treemap Data',+      description: 'Used for treemap app.',+      requiredArtifacts:+        ['traces', 'devtoolsLogs', 'SourceMaps', 'ScriptElements', 'JsUsage', 'URL'],+    };+  }++  /**+   * @param {string} sourceRoot+   * @param {Record<string, SourceData>} sourcesData+   * @return {Node}+   */+  static prepareTreemapNodes(sourceRoot, sourcesData) {+    /**+     * @param {string} name+     * @return {Node}+     */+    function newNode(name) {+      return {+        name,+        resourceBytes: 0,+      };+    }++    /**+     * 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+     * @param {Node} node+     */+    function addNode(source, data, node) {+      // Strip off the shared root.+      const sourcePathSegments = source.replace(sourceRoot, '').split(/\/+/);+      sourcePathSegments.forEach((sourcePathSegment, i) => {+        const isLastSegment = 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;+        if (data.duplicate !== undefined && isLastSegment) {+          node.duplicate = data.duplicate;+        }+      });+    }++    const rootNode = newNode(sourceRoot);++    // 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)) {+      addNode(source || `<unmapped>`, data, rootNode);++      // Apply the data to the rootNode.+      rootNode.resourceBytes += data.resourceBytes;+      if (data.unusedBytes) rootNode.unusedBytes = (rootNode.unusedBytes || 0) + data.unusedBytes;+    }++    /**+     * Collapse nodes that have only one child.+     * @param {Node} node+     */+    function collapse(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) {+          collapse(child);+        }+      }+    }+    collapse(rootNode);++    // TODO(cjamcl): Should this structure be flattened for space savings?+    // Like DOM Snapshot.+    // Less JSON (no super nested children, and no repeated property names).++    return rootNode;+  }++  /**+   * @param {LH.Artifacts} artifacts+   * @param {LH.Audit.Context} context+   * @return {Promise<RootNode[]>}+   */+  static async makeJavaScriptRootNodes(artifacts, context) {+    /** @type {RootNode[]} */+    const rootNodes = [];++    const bundles = await JsBundles.request(artifacts, context);+    const duplication = await ModuleDuplication.request(artifacts, context);++    /** @type {Array<{src: string, length: number, unusedJavascriptSummary?: import('../computed/unused-javascript-summary.js').Summary}>} */+    const scriptData = [];+    const inlineScriptData = {+      src: artifacts.URL.finalUrl,+      length: 0,+    };+    for (const scriptElement of artifacts.ScriptElements) {+      // Normalize ScriptElements so that inline scripts show up as a single entity.+      if (!scriptElement.src) {+        inlineScriptData.length += (scriptElement.content || '').length;+        continue;+      }++      const url = scriptElement.src;+      const bundle = bundles.find(bundle => url === bundle.script.src);+      const scriptCoverages = artifacts.JsUsage[url];+      if (!bundle || !scriptCoverages) continue;++      scriptData.push({+        src: scriptElement.src,+        length: (scriptElement.content || '').length,+        unusedJavascriptSummary:+          await UnusedJavaScriptSummary.request({url, scriptCoverages, bundle}, context),+      });+    }+    if (inlineScriptData.length) scriptData.unshift(inlineScriptData);++    for (const {src, length, unusedJavascriptSummary} of scriptData) {+      const bundle = bundles.find(bundle => bundle.script.src === src);+      const name = src;++      let node;+      if (bundle && unusedJavascriptSummary && unusedJavascriptSummary.sourcesWastedBytes) {+        /** @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 && unusedJavascriptSummary.sourcesWastedBytes) {

+/**+ * @license Copyright 2020 Google Inc. 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 treemap data for webtreemap.+ */++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');+const NetworkRecords = require('../computed/network-records.js');+const ResourceSummary = require('../computed/resource-summary.js');++/**+ * @typedef {Record<string, RootNode[]>} TreemapData+ */++/**+ * @typedef RootNode+ * @property {string} name+ * @property {Node} node+ */++/**+ * @typedef Node+ * @property {string} name+ * @property {number} resourceBytes+ * @property {number=} unusedBytes+ * @property {number=} executionTime+ * @property {string=} duplicate+ * @property {Node[]=} children+ */++/**+ * @typedef {Omit<Node, 'name'|'children'>} SourceData+ */++class TreemapDataAudit extends Audit {+  /**+   * @return {LH.Audit.Meta}+   */+  static get meta() {+    return {+      id: 'treemap-data',+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,+      title: 'Treemap Data',+      description: 'Used for treemap app.',+      requiredArtifacts:+        ['traces', 'devtoolsLogs', 'SourceMaps', 'ScriptElements', 'JsUsage', 'URL'],+    };+  }++  /**+   * @param {string} sourceRoot+   * @param {Record<string, SourceData>} sourcesData+   * @return {Node}+   */+  static prepareTreemapNodes(sourceRoot, sourcesData) {+    /**+     * @param {string} name+     * @return {Node}+     */+    function newNode(name) {+      return {+        name,+        resourceBytes: 0,+      };+    }++    /**+     * 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+     * @param {Node} node+     */+    function addNode(source, data, node) {+      // Strip off the shared root.+      const sourcePathSegments = source.replace(sourceRoot, '').split(/\/+/);+      sourcePathSegments.forEach((sourcePathSegment, i) => {+        const isLastSegment = 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;+        if (data.duplicate !== undefined && isLastSegment) {+          node.duplicate = data.duplicate;+        }+      });+    }++    const rootNode = newNode(sourceRoot);++    // 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)) {+      addNode(source || `<unmapped>`, data, rootNode);++      // Apply the data to the rootNode.+      rootNode.resourceBytes += data.resourceBytes;+      if (data.unusedBytes) rootNode.unusedBytes = (rootNode.unusedBytes || 0) + data.unusedBytes;+    }++    /**+     * Collapse nodes that have only one child.+     * @param {Node} node+     */+    function collapse(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) {+          collapse(child);+        }+      }+    }+    collapse(rootNode);++    // TODO(cjamcl): Should this structure be flattened for space savings?+    // Like DOM Snapshot.+    // Less JSON (no super nested children, and no repeated property names).++    return rootNode;+  }++  /**+   * @param {LH.Artifacts} artifacts+   * @param {LH.Audit.Context} context+   * @return {Promise<RootNode[]>}+   */+  static async makeJavaScriptRootNodes(artifacts, context) {+    /** @type {RootNode[]} */+    const rootNodes = [];++    const bundles = await JsBundles.request(artifacts, context);+    const duplication = await ModuleDuplication.request(artifacts, context);++    /** @type {Array<{src: string, length: number, unusedJavascriptSummary?: import('../computed/unused-javascript-summary.js').Summary}>} */+    const scriptData = [];+    const inlineScriptData = {+      src: artifacts.URL.finalUrl,+      length: 0,+    };+    for (const scriptElement of artifacts.ScriptElements) {+      // Normalize ScriptElements so that inline scripts show up as a single entity.+      if (!scriptElement.src) {+        inlineScriptData.length += (scriptElement.content || '').length;+        continue;+      }++      const url = scriptElement.src;+      const bundle = bundles.find(bundle => url === bundle.script.src);+      const scriptCoverages = artifacts.JsUsage[url];+      if (!bundle || !scriptCoverages) continue;++      scriptData.push({+        src: scriptElement.src,+        length: (scriptElement.content || '').length,+        unusedJavascriptSummary:+          await UnusedJavaScriptSummary.request({url, scriptCoverages, bundle}, context),+      });+    }+    if (inlineScriptData.length) scriptData.unshift(inlineScriptData);

+/**+ * @license Copyright 2020 Google Inc. 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 treemap data for webtreemap.+ */++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');+const NetworkRecords = require('../computed/network-records.js');+const ResourceSummary = require('../computed/resource-summary.js');++/**+ * @typedef {Record<string, RootNode[]>} TreemapData+ */++/**+ * @typedef RootNode+ * @property {string} name+ * @property {Node} node+ */++/**+ * @typedef Node+ * @property {string} name+ * @property {number} resourceBytes+ * @property {number=} unusedBytes+ * @property {number=} executionTime+ * @property {string=} duplicate+ * @property {Node[]=} children+ */++/**+ * @typedef {Omit<Node, 'name'|'children'>} SourceData+ */++class TreemapDataAudit extends Audit {+  /**+   * @return {LH.Audit.Meta}+   */+  static get meta() {+    return {+      id: 'treemap-data',+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,+      title: 'Treemap Data',+      description: 'Used for treemap app.',+      requiredArtifacts:+        ['traces', 'devtoolsLogs', 'SourceMaps', 'ScriptElements', 'JsUsage', 'URL'],+    };+  }++  /**+   * @param {string} sourceRoot+   * @param {Record<string, SourceData>} sourcesData+   * @return {Node}+   */+  static prepareTreemapNodes(sourceRoot, sourcesData) {+    /**+     * @param {string} name+     * @return {Node}+     */+    function newNode(name) {+      return {+        name,+        resourceBytes: 0,+      };+    }++    /**+     * 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+     * @param {Node} node+     */+    function addNode(source, data, node) {+      // Strip off the shared root.+      const sourcePathSegments = source.replace(sourceRoot, '').split(/\/+/);+      sourcePathSegments.forEach((sourcePathSegment, i) => {+        const isLastSegment = 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;+        if (data.duplicate !== undefined && isLastSegment) {+          node.duplicate = data.duplicate;+        }+      });+    }++    const rootNode = newNode(sourceRoot);++    // 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)) {+      addNode(source || `<unmapped>`, data, rootNode);++      // Apply the data to the rootNode.+      rootNode.resourceBytes += data.resourceBytes;+      if (data.unusedBytes) rootNode.unusedBytes = (rootNode.unusedBytes || 0) + data.unusedBytes;+    }++    /**+     * Collapse nodes that have only one child.+     * @param {Node} node+     */+    function collapse(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) {+          collapse(child);+        }+      }+    }+    collapse(rootNode);++    // TODO(cjamcl): Should this structure be flattened for space savings?+    // Like DOM Snapshot.+    // Less JSON (no super nested children, and no repeated property names).++    return rootNode;+  }++  /**+   * @param {LH.Artifacts} artifacts+   * @param {LH.Audit.Context} context+   * @return {Promise<RootNode[]>}+   */+  static async makeJavaScriptRootNodes(artifacts, context) {+    /** @type {RootNode[]} */+    const rootNodes = [];++    const bundles = await JsBundles.request(artifacts, context);+    const duplication = await ModuleDuplication.request(artifacts, context);++    /** @type {Array<{src: string, length: number, unusedJavascriptSummary?: import('../computed/unused-javascript-summary.js').Summary}>} */+    const scriptData = [];+    const inlineScriptData = {+      src: artifacts.URL.finalUrl,+      length: 0,+    };+    for (const scriptElement of artifacts.ScriptElements) {+      // Normalize ScriptElements so that inline scripts show up as a single entity.+      if (!scriptElement.src) {+        inlineScriptData.length += (scriptElement.content || '').length;+        continue;+      }++      const url = scriptElement.src;+      const bundle = bundles.find(bundle => url === bundle.script.src);+      const scriptCoverages = artifacts.JsUsage[url];+      if (!bundle || !scriptCoverages) continue;++      scriptData.push({+        src: scriptElement.src,+        length: (scriptElement.content || '').length,+        unusedJavascriptSummary:+          await UnusedJavaScriptSummary.request({url, scriptCoverages, bundle}, context),+      });+    }+    if (inlineScriptData.length) scriptData.unshift(inlineScriptData);++    for (const {src, length, unusedJavascriptSummary} of scriptData) {

+/**+ * @license Copyright 2020 Google Inc. 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 treemap data for webtreemap.+ */++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');+const NetworkRecords = require('../computed/network-records.js');+const ResourceSummary = require('../computed/resource-summary.js');++/**+ * @typedef {Record<string, RootNode[]>} TreemapData+ */++/**+ * @typedef RootNode+ * @property {string} name+ * @property {Node} node+ */++/**+ * @typedef Node+ * @property {string} name+ * @property {number} resourceBytes+ * @property {number=} unusedBytes+ * @property {number=} executionTime+ * @property {string=} duplicate+ * @property {Node[]=} children+ */++/**+ * @typedef {Omit<Node, 'name'|'children'>} SourceData+ */++class TreemapDataAudit extends Audit {+  /**+   * @return {LH.Audit.Meta}+   */+  static get meta() {+    return {+      id: 'treemap-data',+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,+      title: 'Treemap Data',+      description: 'Used for treemap app.',+      requiredArtifacts:+        ['traces', 'devtoolsLogs', 'SourceMaps', 'ScriptElements', 'JsUsage', 'URL'],+    };+  }++  /**+   * @param {string} sourceRoot+   * @param {Record<string, SourceData>} sourcesData+   * @return {Node}+   */+  static prepareTreemapNodes(sourceRoot, sourcesData) {+    /**+     * @param {string} name+     * @return {Node}+     */+    function newNode(name) {+      return {+        name,+        resourceBytes: 0,+      };+    }++    /**+     * 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+     * @param {Node} node+     */+    function addNode(source, data, node) {+      // Strip off the shared root.+      const sourcePathSegments = source.replace(sourceRoot, '').split(/\/+/);+      sourcePathSegments.forEach((sourcePathSegment, i) => {+        const isLastSegment = 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;+        if (data.duplicate !== undefined && isLastSegment) {+          node.duplicate = data.duplicate;+        }+      });+    }++    const rootNode = newNode(sourceRoot);++    // 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)) {+      addNode(source || `<unmapped>`, data, rootNode);++      // Apply the data to the rootNode.+      rootNode.resourceBytes += data.resourceBytes;+      if (data.unusedBytes) rootNode.unusedBytes = (rootNode.unusedBytes || 0) + data.unusedBytes;+    }++    /**+     * Collapse nodes that have only one child.+     * @param {Node} node+     */+    function collapse(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) {+          collapse(child);+        }+      }+    }+    collapse(rootNode);++    // TODO(cjamcl): Should this structure be flattened for space savings?+    // Like DOM Snapshot.+    // Less JSON (no super nested children, and no repeated property names).++    return rootNode;+  }++  /**+   * @param {LH.Artifacts} artifacts+   * @param {LH.Audit.Context} context+   * @return {Promise<RootNode[]>}+   */+  static async makeJavaScriptRootNodes(artifacts, context) {+    /** @type {RootNode[]} */+    const rootNodes = [];++    const bundles = await JsBundles.request(artifacts, context);+    const duplication = await ModuleDuplication.request(artifacts, context);++    /** @type {Array<{src: string, length: number, unusedJavascriptSummary?: import('../computed/unused-javascript-summary.js').Summary}>} */+    const scriptData = [];+    const inlineScriptData = {+      src: artifacts.URL.finalUrl,+      length: 0,+    };+    for (const scriptElement of artifacts.ScriptElements) {+      // Normalize ScriptElements so that inline scripts show up as a single entity.+      if (!scriptElement.src) {+        inlineScriptData.length += (scriptElement.content || '').length;+        continue;+      }++      const url = scriptElement.src;+      const bundle = bundles.find(bundle => url === bundle.script.src);+      const scriptCoverages = artifacts.JsUsage[url];+      if (!bundle || !scriptCoverages) continue;++      scriptData.push({+        src: scriptElement.src,+        length: (scriptElement.content || '').length,+        unusedJavascriptSummary:+          await UnusedJavaScriptSummary.request({url, scriptCoverages, bundle}, context),+      });+    }+    if (inlineScriptData.length) scriptData.unshift(inlineScriptData);++    for (const {src, length, unusedJavascriptSummary} of scriptData) {+      const bundle = bundles.find(bundle => bundle.script.src === src);+      const name = src;++      let node;+      if (bundle && unusedJavascriptSummary && unusedJavascriptSummary.sourcesWastedBytes) {

+/**+ * @license Copyright 2020 Google Inc. 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 treemap data for webtreemap.+ */++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');+const NetworkRecords = require('../computed/network-records.js');+const ResourceSummary = require('../computed/resource-summary.js');++/**+ * @typedef {Record<string, RootNode[]>} TreemapData+ */++/**+ * @typedef RootNode+ * @property {string} name+ * @property {Node} node+ */++/**+ * @typedef Node+ * @property {string} name+ * @property {number} resourceBytes+ * @property {number=} unusedBytes+ * @property {number=} executionTime+ * @property {string=} duplicate+ * @property {Node[]=} children+ */++/**+ * @typedef {Omit<Node, 'name'|'children'>} SourceData+ */++class TreemapDataAudit extends Audit {+  /**+   * @return {LH.Audit.Meta}+   */+  static get meta() {+    return {+      id: 'treemap-data',+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,+      title: 'Treemap Data',+      description: 'Used for treemap app.',+      requiredArtifacts:+        ['traces', 'devtoolsLogs', 'SourceMaps', 'ScriptElements', 'JsUsage', 'URL'],+    };+  }++  /**+   * @param {string} sourceRoot+   * @param {Record<string, SourceData>} sourcesData+   * @return {Node}+   */+  static prepareTreemapNodes(sourceRoot, sourcesData) {+    /**+     * @param {string} name+     * @return {Node}+     */+    function newNode(name) {+      return {+        name,+        resourceBytes: 0,+      };+    }++    /**+     * 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+     * @param {Node} node+     */+    function addNode(source, data, node) {+      // Strip off the shared root.+      const sourcePathSegments = source.replace(sourceRoot, '').split(/\/+/);+      sourcePathSegments.forEach((sourcePathSegment, i) => {+        const isLastSegment = 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;+        if (data.duplicate !== undefined && isLastSegment) {+          node.duplicate = data.duplicate;+        }+      });+    }++    const rootNode = newNode(sourceRoot);++    // 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)) {+      addNode(source || `<unmapped>`, data, rootNode);++      // Apply the data to the rootNode.+      rootNode.resourceBytes += data.resourceBytes;+      if (data.unusedBytes) rootNode.unusedBytes = (rootNode.unusedBytes || 0) + data.unusedBytes;+    }++    /**+     * Collapse nodes that have only one child.+     * @param {Node} node+     */+    function collapse(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) {+          collapse(child);+        }+      }+    }+    collapse(rootNode);++    // TODO(cjamcl): Should this structure be flattened for space savings?+    // Like DOM Snapshot.+    // Less JSON (no super nested children, and no repeated property names).++    return rootNode;+  }++  /**+   * @param {LH.Artifacts} artifacts+   * @param {LH.Audit.Context} context+   * @return {Promise<RootNode[]>}+   */+  static async makeJavaScriptRootNodes(artifacts, context) {+    /** @type {RootNode[]} */+    const rootNodes = [];++    const bundles = await JsBundles.request(artifacts, context);+    const duplication = await ModuleDuplication.request(artifacts, context);++    /** @type {Array<{src: string, length: number, unusedJavascriptSummary?: import('../computed/unused-javascript-summary.js').Summary}>} */+    const scriptData = [];+    const inlineScriptData = {+      src: artifacts.URL.finalUrl,+      length: 0,+    };+    for (const scriptElement of artifacts.ScriptElements) {+      // Normalize ScriptElements so that inline scripts show up as a single entity.+      if (!scriptElement.src) {+        inlineScriptData.length += (scriptElement.content || '').length;+        continue;+      }++      const url = scriptElement.src;+      const bundle = bundles.find(bundle => url === bundle.script.src);+      const scriptCoverages = artifacts.JsUsage[url];+      if (!bundle || !scriptCoverages) continue;

+/**+ * @license Copyright 2020 Google Inc. 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 treemap data for webtreemap.+ */++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');+const NetworkRecords = require('../computed/network-records.js');+const ResourceSummary = require('../computed/resource-summary.js');++/**+ * @typedef {Record<string, RootNode[]>} TreemapData+ */++/**+ * @typedef RootNode+ * @property {string} name+ * @property {Node} node+ */++/**+ * @typedef Node+ * @property {string} name+ * @property {number} resourceBytes+ * @property {number=} unusedBytes+ * @property {number=} executionTime+ * @property {string=} duplicate+ * @property {Node[]=} children+ */++/**+ * @typedef {Omit<Node, 'name'|'children'>} SourceData+ */++class TreemapDataAudit extends Audit {+  /**+   * @return {LH.Audit.Meta}+   */+  static get meta() {+    return {+      id: 'treemap-data',+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,+      title: 'Treemap Data',+      description: 'Used for treemap app.',+      requiredArtifacts:+        ['traces', 'devtoolsLogs', 'SourceMaps', 'ScriptElements', 'JsUsage', 'URL'],+    };+  }++  /**+   * @param {string} sourceRoot+   * @param {Record<string, SourceData>} sourcesData+   * @return {Node}+   */+  static prepareTreemapNodes(sourceRoot, sourcesData) {+    /**+     * @param {string} name+     * @return {Node}+     */+    function newNode(name) {+      return {+        name,+        resourceBytes: 0,+      };+    }++    /**+     * 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+     * @param {Node} node+     */+    function addNode(source, data, node) {+      // Strip off the shared root.+      const sourcePathSegments = source.replace(sourceRoot, '').split(/\/+/);+      sourcePathSegments.forEach((sourcePathSegment, i) => {+        const isLastSegment = 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;+        if (data.duplicate !== undefined && isLastSegment) {+          node.duplicate = data.duplicate;+        }+      });+    }++    const rootNode = newNode(sourceRoot);++    // 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)) {+      addNode(source || `<unmapped>`, data, rootNode);++      // Apply the data to the rootNode.+      rootNode.resourceBytes += data.resourceBytes;+      if (data.unusedBytes) rootNode.unusedBytes = (rootNode.unusedBytes || 0) + data.unusedBytes;+    }++    /**+     * Collapse nodes that have only one child.+     * @param {Node} node+     */+    function collapse(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) {+          collapse(child);+        }+      }+    }+    collapse(rootNode);++    // TODO(cjamcl): Should this structure be flattened for space savings?+    // Like DOM Snapshot.+    // Less JSON (no super nested children, and no repeated property names).++    return rootNode;+  }++  /**+   * @param {LH.Artifacts} artifacts+   * @param {LH.Audit.Context} context+   * @return {Promise<RootNode[]>}+   */+  static async makeJavaScriptRootNodes(artifacts, context) {+    /** @type {RootNode[]} */+    const rootNodes = [];++    const bundles = await JsBundles.request(artifacts, context);+    const duplication = await ModuleDuplication.request(artifacts, context);++    /** @type {Array<{src: string, length: number, unusedJavascriptSummary?: import('../computed/unused-javascript-summary.js').Summary}>} */+    const scriptData = [];+    const inlineScriptData = {+      src: artifacts.URL.finalUrl,+      length: 0,+    };+    for (const scriptElement of artifacts.ScriptElements) {+      // Normalize ScriptElements so that inline scripts show up as a single entity.+      if (!scriptElement.src) {+        inlineScriptData.length += (scriptElement.content || '').length;+        continue;+      }++      const url = scriptElement.src;

+/**+ * @license Copyright 2020 Google Inc. 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 treemap data for webtreemap.+ */++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');+const NetworkRecords = require('../computed/network-records.js');+const ResourceSummary = require('../computed/resource-summary.js');++/**+ * @typedef {Record<string, RootNode[]>} TreemapData+ */++/**+ * @typedef RootNode+ * @property {string} name+ * @property {Node} node+ */++/**+ * @typedef Node+ * @property {string} name+ * @property {number} resourceBytes+ * @property {number=} unusedBytes+ * @property {number=} executionTime+ * @property {string=} duplicate+ * @property {Node[]=} children+ */++/**+ * @typedef {Omit<Node, 'name'|'children'>} SourceData+ */++class TreemapDataAudit extends Audit {+  /**+   * @return {LH.Audit.Meta}+   */+  static get meta() {+    return {+      id: 'treemap-data',+      scoreDisplayMode: Audit.SCORING_MODES.INFORMATIVE,+      title: 'Treemap Data',+      description: 'Used for treemap app.',+      requiredArtifacts:+        ['traces', 'devtoolsLogs', 'SourceMaps', 'ScriptElements', 'JsUsage', 'URL'],+    };+  }++  /**+   * @param {string} sourceRoot+   * @param {Record<string, SourceData>} sourcesData+   * @return {Node}+   */+  static prepareTreemapNodes(sourceRoot, sourcesData) {+    /**+     * @param {string} name+     * @return {Node}+     */+    function newNode(name) {+      return {+        name,+        resourceBytes: 0,+      };+    }++    /**+     * 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+     * @param {Node} node+     */+    function addNode(source, data, node) {+      // Strip off the shared root.+      const sourcePathSegments = source.replace(sourceRoot, '').split(/\/+/);+      sourcePathSegments.forEach((sourcePathSegment, i) => {+        const isLastSegment = 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;+        if (data.duplicate !== undefined && isLastSegment) {+          node.duplicate = data.duplicate;+        }+      });+    }++    const rootNode = newNode(sourceRoot);++    // 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)) {+      addNode(source || `<unmapped>`, data, rootNode);++      // Apply the data to the rootNode.+      rootNode.resourceBytes += data.resourceBytes;+      if (data.unusedBytes) rootNode.unusedBytes = (rootNode.unusedBytes || 0) + data.unusedBytes;+    }++    /**+     * Collapse nodes that have only one child.+     * @param {Node} node+     */+    function collapse(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) {+          collapse(child);+        }+      }+    }+    collapse(rootNode);++    // TODO(cjamcl): Should this structure be flattened for space savings?+    // Like DOM Snapshot.+    // Less JSON (no super nested children, and no repeated property names).++    return rootNode;+  }++  /**+   * @param {LH.Artifacts} artifacts+   * @param {LH.Audit.Context} context+   * @return {Promise<RootNode[]>}+   */+  static async makeJavaScriptRootNodes(artifacts, context) {+    /** @type {RootNode[]} */+    const rootNodes = [];++    const bundles = await JsBundles.request(artifacts, context);+    const duplication = await ModuleDuplication.request(artifacts, context);++    /** @type {Array<{src: string, length: number, unusedJavascriptSummary?: import('../computed/unused-javascript-summary.js').Summary}>} */+    const scriptData = [];+    const inlineScriptData = {+      src: artifacts.URL.finalUrl,+      length: 0,+    };+    for (const scriptElement of artifacts.ScriptElements) {+      // Normalize ScriptElements so that inline scripts show up as a single entity.

 class GatherRunner {     await driver.registerPerformanceObserver();     await driver.dismissJavaScriptDialogs();     await driver.registerRequestIdleCallbackWrap(options.settings);-    if (resetStorage) await driver.clearDataForOrigin(options.requestedUrl);+    if (resetStorage) {+      const locations = await driver.getImportantLocationsNotCleared(options.requestedUrl);+      if (locations.length) {+        LighthouseRunWarnings.push(str_(+          UIStrings.warningData,+          {locations: locations.join(', '), locationCount: locations.length}

 class GatherRunner {     await driver.registerPerformanceObserver();     await driver.dismissJavaScriptDialogs();     await driver.registerRequestIdleCallbackWrap(options.settings);-    if (resetStorage) await driver.clearDataForOrigin(options.requestedUrl);+    if (resetStorage) {+      const locations = await driver.getImportantLocationsNotCleared(options.requestedUrl);+      if (locations.length) {+        LighthouseRunWarnings.push(str_(+          UIStrings.warningData,+          {locations: locations.join(', '), locationCount: locations.length}+        ));+      }

 describe('GatherRunner', function() {     });   }); +  it('warns if important data not cleared may impact performance', () => {+    const asyncFunc = () => Promise.resolve();+    driver.assertNoSameOriginServiceWorkerClients = asyncFunc;+    driver.beginEmulation = asyncFunc;+    driver.enableRuntimeEvents = asyncFunc;+    driver.enableAsyncStacks = asyncFunc;+    driver.cacheNatives = asyncFunc;+    driver.registerPerformanceObserver = asyncFunc;+    driver.dismissJavaScriptDialogs = asyncFunc;+    driver.registerRequestIdleCallbackWrap = asyncFunc;+    driver.clearDataForOrigin = asyncFunc;++    connectionStub.sendCommand = createMockSendCommandFn()+      .mockResponse('Storage.getUsageAndQuota', {usageBreakdown: [+        {storageType: 'local_storage', usage: 5},+        {storageType: 'indexeddb', usage: 5},+        {storageType: 'websql', usage: 0},+        {storageType: 'appcache', usage: 5},+        {storageType: 'cookies', usage: 5},+        {storageType: 'file_systems', usage: 5},+        {storageType: 'shader_cache', usage: 5},+        {storageType: 'service_workers', usage: 5},+        {storageType: 'cache_storage', usage: 0},+      ]});+    /** @type {string[]} */+    const LighthouseRunWarnings = [];+    GatherRunner.setupDriver(driver, {settings: {}}, LighthouseRunWarnings).then(_ => {+      expect(LighthouseRunWarnings[0]).toBeDisplayString(new RegExp(

 describe('GatherRunner', function() {     });   }); +  it('warns if important data not cleared may impact performance', () => {+    const asyncFunc = () => Promise.resolve();+    driver.assertNoSameOriginServiceWorkerClients = asyncFunc;+    driver.beginEmulation = asyncFunc;+    driver.enableRuntimeEvents = asyncFunc;+    driver.enableAsyncStacks = asyncFunc;+    driver.cacheNatives = asyncFunc;+    driver.registerPerformanceObserver = asyncFunc;+    driver.dismissJavaScriptDialogs = asyncFunc;+    driver.registerRequestIdleCallbackWrap = asyncFunc;+    driver.clearDataForOrigin = asyncFunc;++    connectionStub.sendCommand = createMockSendCommandFn()+      .mockResponse('Storage.getUsageAndQuota', {usageBreakdown: [+        {storageType: 'local_storage', usage: 5},+        {storageType: 'indexeddb', usage: 5},+        {storageType: 'websql', usage: 0},+        {storageType: 'appcache', usage: 5},+        {storageType: 'cookies', usage: 5},+        {storageType: 'file_systems', usage: 5},+        {storageType: 'shader_cache', usage: 5},+        {storageType: 'service_workers', usage: 5},+        {storageType: 'cache_storage', usage: 0},+      ]});+    /** @type {string[]} */+    const LighthouseRunWarnings = [];+    GatherRunner.setupDriver(driver, {settings: {}}, LighthouseRunWarnings).then(_ => {+      expect(LighthouseRunWarnings[0]).toBeDisplayString(new RegExp(

 class Driver {   async clearDataForOrigin(url) {     const origin = new URL(url).origin; -    // Clear all types of storage except cookies, so the user isn't logged out.+    // Clear some types of storage.+    // Cookies are not cleared, so the user isn't logged out.+    // indexeddb, websql, and localstorage are not cleared to prevent loss of potentially important data.     //   https://chromedevtools.github.io/debugger-protocol-viewer/tot/Storage/#type-StorageType     const typesToClear = [       'appcache',       // 'cookies',       'file_systems',-      'indexeddb',

 class GatherRunner {     await driver.registerPerformanceObserver();     await driver.dismissJavaScriptDialogs();     await driver.registerRequestIdleCallbackWrap(options.settings);-    if (resetStorage) await driver.clearDataForOrigin(options.requestedUrl);+    if (resetStorage) {+      const locations = await driver.getImportantLocationsNotCleared(options.requestedUrl);+      if (locations.length) {+        LighthouseRunWarnings.push(str_(+          UIStrings.warningData,+          {locations: locations.join(', '), locationCount: locations.length}

 class Driver {     }   } +  /**+   * @param {string} url+   * @return {Promise<string[]>}+   */+  async getImportantLocationsNotCleared(url) {+    const usageData = await this.sendCommand('Storage.getUsageAndQuota', {+      origin: url,+    });+    const locations = usageData.usageBreakdown.filter(usage => usage.usage)+      .map(usage => {+        switch (usage.storageType) {+          case 'local_storage':+            return 'Local Storage';+          case 'indexeddb':+            return 'IndexedDB';+          case 'websql':+            return 'Web SQL';+          default:+            return '';+        }+      })+      .filter(resourceString => resourceString);

 class GatherRunner {     await driver.registerPerformanceObserver();     await driver.dismissJavaScriptDialogs();     await driver.registerRequestIdleCallbackWrap(options.settings);-    if (resetStorage) await driver.clearDataForOrigin(options.requestedUrl);+    if (resetStorage) {+      const locations = await driver.getImportantLocationsNotCleared(options.requestedUrl);+      if (locations.length) {+        LighthouseRunWarnings.push(str_(+          UIStrings.warningData,+          {locations: locations.join(', '), locationCount: locations.length}+        ));+      }

 describe('GatherRunner', function() {     });   }); +  it('warns if important data not cleared may impact performance', () => {+    const asyncFunc = () => Promise.resolve();+    driver.assertNoSameOriginServiceWorkerClients = asyncFunc;+    driver.beginEmulation = asyncFunc;+    driver.enableRuntimeEvents = asyncFunc;+    driver.enableAsyncStacks = asyncFunc;+    driver.cacheNatives = asyncFunc;+    driver.registerPerformanceObserver = asyncFunc;+    driver.dismissJavaScriptDialogs = asyncFunc;+    driver.registerRequestIdleCallbackWrap = asyncFunc;+    driver.clearDataForOrigin = asyncFunc;++    connectionStub.sendCommand = createMockSendCommandFn()+      .mockResponse('Storage.getUsageAndQuota', {usageBreakdown: [+        {storageType: 'local_storage', usage: 5},+        {storageType: 'indexeddb', usage: 5},+        {storageType: 'websql', usage: 0},+        {storageType: 'appcache', usage: 5},+        {storageType: 'cookies', usage: 5},+        {storageType: 'file_systems', usage: 5},+        {storageType: 'shader_cache', usage: 5},+        {storageType: 'service_workers', usage: 5},+        {storageType: 'cache_storage', usage: 0},+      ]});+    /** @type {string[]} */+    const LighthouseRunWarnings = [];+    GatherRunner.setupDriver(driver, {settings: {}}, LighthouseRunWarnings).then(_ => {

 class GatherRunner {   /**    * @param {Driver} driver    * @param {{requestedUrl: string, settings: LH.Config.Settings}} options+   * @param {string[]} LighthouseRunWarnings

 describe('GatherRunner', function() {     });   }); +  it('warns if important data not cleared may impact performance', () => {+    const asyncFunc = () => Promise.resolve();+    driver.assertNoSameOriginServiceWorkerClients = asyncFunc;+    driver.beginEmulation = asyncFunc;+    driver.enableRuntimeEvents = asyncFunc;+    driver.enableAsyncStacks = asyncFunc;+    driver.cacheNatives = asyncFunc;+    driver.registerPerformanceObserver = asyncFunc;+    driver.dismissJavaScriptDialogs = asyncFunc;+    driver.registerRequestIdleCallbackWrap = asyncFunc;+    driver.clearDataForOrigin = asyncFunc;++    connectionStub.sendCommand = createMockSendCommandFn()+      .mockResponse('Storage.getUsageAndQuota', {usageBreakdown: [+        {storageType: 'local_storage', usage: 5},+        {storageType: 'indexeddb', usage: 5},+        {storageType: 'websql', usage: 0},+        {storageType: 'appcache', usage: 5},+        {storageType: 'cookies', usage: 5},+        {storageType: 'file_systems', usage: 5},+        {storageType: 'shader_cache', usage: 5},+        {storageType: 'service_workers', usage: 5},+        {storageType: 'cache_storage', usage: 0},+      ]});+    /** @type {string[]} */+    const LighthouseRunWarnings = [];+    GatherRunner.setupDriver(driver, {settings: {}}, LighthouseRunWarnings).then(_ => {+      expect(LighthouseRunWarnings[0]).toBeDisplayString(new RegExp(

 # Using Puppeteer with Lighthouse +## Recipes++### [Using Puppeteer for authenticated pages](./recipes/auth/README.md)

 # Using Puppeteer with Lighthouse +## Recipes++### [Using Puppeteer for authenticated pages](./recipes/auth/README.md)

 declare global {           files: Record<string, number>;           unmappedBytes: number;           totalBytes: number;-        };+        } | {error: string};

 declare global {           files: Record<string, number>;           unmappedBytes: number;           totalBytes: number;-        };+        } | {error: string};

 function computeGeneratedFileSizes(map, content) {      const line = lines[lineNum];     if (line === null) {-      log.error('JSBundles', `${map.url()} mapping for line out of bounds: ${lineNum + 1}`);-      return failureResult;+      const error = `${map.url()} mapping for line out of bounds: ${lineNum + 1}`;+      log.error('JSBundles', error);+      return {error};

 declare global {           files: Record<string, number>;           unmappedBytes: number;           totalBytes: number;-        };+        } | {error: string};

 const UIStrings = {   /** Description of a Lighthouse audit that tells the user *why* HTTPS use *for all resources* is important. 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: 'All sites should be protected with HTTPS, even ones that don\'t handle ' +       'sensitive data. This includes avoiding [mixed content](https://developers.google.com/web/fundamentals/security/prevent-mixed-content/what-is-mixed-content), ' +-      'where some resources are loaded over HTTP despite the initial request being served' ++      'where some resources are loaded over HTTP despite the initial request being served ' +

 ViewportDimensions: { }  -content-width: pass +content-width: pass undefined

+#!/usr/bin/env bash++set -euo pipefail++##+# @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.+##++if [[ -z $CHROME_PATH ]]+then+  echo 'Must set $CHROME_PATH'+  exit 1+fi++export DEVTOOLS_PATH=${DEVTOOLS_PATH:-"$HOME/src/devtools/devtools-frontend"}

 const isDevtools = file => /** @param {string} file */ const isLightrider = file => path.basename(file).includes('lightrider'); -const BANNER = `// lighthouse, browserified. ${VERSION} (${COMMIT_HASH})\n` +-  '// @ts-nocheck\n'; // To prevent tsc stepping into any required bundles.

     "@wardpeet/brfs": "2.1.0-0",     "angular": "^1.7.4",     "archiver": "^3.0.0",-    "babel-core": "^6.26.0",-    "babel-plugin-syntax-async-generators": "^6.13.0",-    "babel-plugin-syntax-object-rest-spread": "^6.13.0",     "browserify": "^16.2.3",+    "browserify-banner": "^1.0.15",+    "bundlesize": "^0.18.0",

 async function browserifyFile(entryPath, distPath) {     writeStream.on('finish', resolve);     writeStream.on('error', reject); -    bundleStream.pipe(writeStream);+    bundleStream+      // Extract the inline source map to an external file.+      .pipe(exorcist(`${distPath}.map`))+      .pipe(writeStream);   }); }  /**- * Minimally minify a javascript file, in place.+ * Minify a javascript file, in place.  * @param {string} filePath  */ function minifyScript(filePath) {-  const opts = {-    compact: true, // Do not include superfluous whitespace characters and line terminators.-    retainLines: true, // Keep things on the same line (looks wonky but helps with stacktraces)-    comments: false, // Don't output comments-    shouldPrintComment: () => false, // Don't include @license or @preserve comments either-    plugins: [-      'syntax-object-rest-spread',-      'syntax-async-generators',-    ],-    // sourceMaps: 'both'-  };+  const result = terser.minify(fs.readFileSync(filePath, 'utf-8'), {+    output: {+      comments: /^!/,+      // @ts-ignore - terser types are whack-a-doodle wrong.

 async function browserifyFile(entryPath, distPath) {     writeStream.on('finish', resolve);     writeStream.on('error', reject); -    bundleStream.pipe(writeStream);+    bundleStream+      // Extract the inline source map to an external file.+      .pipe(exorcist(`${distPath}.map`))+      .pipe(writeStream);   }); }  /**- * Minimally minify a javascript file, in place.+ * Minify a javascript file, in place.  * @param {string} filePath  */ function minifyScript(filePath) {-  const opts = {-    compact: true, // Do not include superfluous whitespace characters and line terminators.-    retainLines: true, // Keep things on the same line (looks wonky but helps with stacktraces)-    comments: false, // Don't output comments-    shouldPrintComment: () => false, // Don't include @license or @preserve comments either-    plugins: [-      'syntax-object-rest-spread',-      'syntax-async-generators',-    ],-    // sourceMaps: 'both'-  };+  const result = terser.minify(fs.readFileSync(filePath, 'utf-8'), {+    output: {+      comments: /^!/,+      // @ts-ignore - terser types are whack-a-doodle wrong.+      max_line_len: /** @type {boolean} */ (1000),+    },+    // The config relies on class names for gatherers.+    keep_classnames: true,+    // Runtime.evaluate errors if function names are elided.+    keep_fnames: true,+    sourceMap: {+      content: JSON.parse(fs.readFileSync(`${filePath}.map`, 'utf-8')),+      url: path.basename(`${filePath}.map`),+    },+  });+  if (result.error) {+    throw result.error;+  } -  // Add the banner and modify globals for DevTools if necessary-  let minified = BANNER + babel.transformFileSync(filePath, opts).code;-  if (isDevtools(filePath)) {-    assert.ok(minified.includes('\nrequire='), 'missing browserify require stub');-    minified = minified.replace('\nrequire=', '\nglobalThis.require=');-    assert.ok(!minified.includes('\nrequire='), 'contained unexpected browserify require stub');+  // Add the banner and modify globals for DevTools if necessary.+  // This will mess up the source map for the first line, but we don't ship+  // the map to DevTools, so that's fine.