lighthouse 13.5.0-dev.20261014 → 13.5.0-dev.20261019

package/core/gather/gatherers/scripts.js

@@ -5,19 +5,31 @@
  */
 
 import BaseGatherer from '../base-gatherer.js';
+import Trace from './trace.js';
+
+/**
+ * @typedef {Object} TraceScript
+ * @property {string} scriptId
+ * @property {string} [sourceText]
+ * @property {string[]} [chunks]
+ * @property {string} [url]
+ * @property {string} [sourceUrl]
+ * @property {number} [executionContextId]
+ * @property {string} [frame]
+ */
 
 /**
  * @template T, U
  * @param {Array<T>} values
- * @param {(value: T) => Promise<U>} promiseMapper
+ * @param {(value: T, index: number) => Promise<U>} promiseMapper
  * @param {boolean} runInSeries
  * @return {Promise<Array<U>>}
  */
 async function runInSeriesOrParallel(values, promiseMapper, runInSeries) {
   if (runInSeries) {
     const results = [];
-    for (const value of values) {
-      const result = await promiseMapper(value);
+    for (let i = 0; i < values.length; i++) {
+      const result = await promiseMapper(values[i], i);
       results.push(result);
     }
     return results;
@@ -27,6 +39,121 @@ async function runInSeriesOrParallel(values, promiseMapper, runInSeries) {
   }
 }
 
+/**
+ * Extracts script source text and disambiguating metadata from trace rundown events,
+ * grouped by `scriptId`.
+ * @param {LH.TraceEvent[]} traceEvents
+ * @return {Map<string, TraceScript[]>}
+ */
+function collectTraceScripts(traceEvents) {
+  /** @type {Map<string, TraceScript>} */
+  const byIsolateAndScriptId = new Map();
+
+  /**
+   * @param {NonNullable<LH.TraceEvent['args']['data']>} data
+   * @return {TraceScript}
+   */
+  const getOrCreateRecord = (data) => {
+    const scriptId = String(data.scriptId);
+    const key = `${data.isolate ?? ''}.${scriptId}`;
+    let record = byIsolateAndScriptId.get(key);
+    if (!record) {
+      record = {scriptId};
+      byIsolateAndScriptId.set(key, record);
+    }
+    return record;
+  };
+
+  for (const event of traceEvents) {
+    const data = event.args?.data;
+    if (!data || data.scriptId === undefined) continue;
+
+    if (event.cat === 'disabled-by-default-devtools.target-rundown') {
+      if (typeof data.frame === 'string') {
+        getOrCreateRecord(data).frame = data.frame;
+      }
+    } else if (event.cat === 'disabled-by-default-devtools.v8-source-rundown' &&
+        event.name === 'ScriptCatchup') {
+      const record = getOrCreateRecord(data);
+      if (typeof data.url === 'string') record.url = data.url;
+      if (typeof data.sourceUrl === 'string') record.sourceUrl = data.sourceUrl;
+      if (typeof data.executionContextId === 'number') {
+        record.executionContextId = data.executionContextId;
+      }
+    } else if (event.cat === 'disabled-by-default-devtools.v8-source-rundown-sources' &&
+        typeof data.sourceText === 'string') {
+      const record = getOrCreateRecord(data);
+      if (event.name === 'ScriptCatchup') {
+        record.sourceText = data.sourceText;
+      } else if (event.name === 'LargeScriptCatchup') {
+        if (!record.chunks || data.splitIndex === 0) record.chunks = [];
+        record.chunks.push(data.sourceText);
+      }
+    }
+  }
+
+  /** @type {Map<string, TraceScript[]>} */
+  const byScriptId = new Map();
+  for (const record of byIsolateAndScriptId.values()) {
+    if (record.chunks) record.sourceText = record.chunks.join('');
+    if (record.sourceText === undefined) continue;
+
+    let list = byScriptId.get(record.scriptId);
+    if (!list) {
+      list = [];
+      byScriptId.set(record.scriptId, list);
+    }
+    list.push(record);
+  }
+
+  return byScriptId;
+}
+
+/**
+ * @param {TraceScript} traceScript
+ * @param {LH.Crdp.Debugger.ScriptParsedEvent} script
+ * @return {boolean}
+ */
+function matchesScriptParsedEvent(traceScript, script) {
+  const frameId = script.executionContextAuxData?.frameId;
+  if (frameId && traceScript.frame !== undefined && traceScript.frame !== frameId) {
+    return false;
+  }
+  const scriptUrl = script.embedderName || script.url;
+  if (traceScript.url !== undefined &&
+      traceScript.url !== scriptUrl &&
+      traceScript.sourceUrl !== script.url) {
+    return false;
+  }
+  if (script.executionContextId !== undefined &&
+      traceScript.executionContextId !== undefined &&
+      traceScript.executionContextId !== script.executionContextId) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * @param {LH.Crdp.Debugger.ScriptParsedEvent} script
+ * @param {Map<string, TraceScript[]>} traceScriptsByScriptId
+ * @return {string|undefined}
+ */
+function findTraceScriptSource(script, traceScriptsByScriptId) {
+  const candidates = traceScriptsByScriptId.get(script.scriptId);
+  if (!candidates) return undefined;
+
+  const matches = candidates.filter((candidate) => matchesScriptParsedEvent(candidate, script));
+  if (matches.length === 1) return matches[0].sourceText;
+
+  const frameId = script.executionContextAuxData?.frameId;
+  if (matches.length > 1 && frameId) {
+    const frameMatches = matches.filter((candidate) => candidate.frame === frameId);
+    if (frameMatches.length === 1) return frameMatches[0].sourceText;
+  }
+
+  return undefined;
+}
+
 /**
  * Returns true if the script was created via our own calls
  * to Runtime.evaluate.
@@ -50,18 +177,16 @@ function isLighthouseRuntimeEvaluateScript(script) {
 class Scripts extends BaseGatherer {
   static symbol = Symbol('Scripts');
 
-  /** @type {LH.Gatherer.GathererMeta} */
+  /** @type {LH.Gatherer.GathererMeta<'Trace'>} */
   meta = {
     symbol: Scripts.symbol,
     supportedModes: ['timespan', 'navigation'],
+    dependencies: {Trace: Trace.symbol},
   };
 
   /** @type {LH.Crdp.Debugger.ScriptParsedEvent[]} */
   _scriptParsedEvents = [];
 
-  /** @type {Array<string | undefined>} */
-  _scriptContents = [];
-
   constructor() {
     super();
     this.onScriptParsed = this.onScriptParsed.bind(this);
@@ -89,26 +214,42 @@ class Scripts extends BaseGatherer {
    * @param {LH.Gatherer.Context} context
    */
   async stopInstrumentation(context) {
+    const session = context.driver.defaultSession;
+    session.off('Debugger.scriptParsed', this.onScriptParsed);
+  }
+
+  /**
+   * @param {LH.Gatherer.Context<'Trace'>} context
+   * @return {Promise<LH.Artifacts['Scripts']>}
+   */
+  async getArtifact(context) {
     const session = context.driver.defaultSession;
     const formFactor = context.baseArtifacts.HostFormFactor;
+    const traceScriptsByScriptId = collectTraceScripts(context.dependencies.Trace.traceEvents);
+    const traceSources = this._scriptParsedEvents.map(
+      (script) => findTraceScriptSource(script, traceScriptsByScriptId)
+    );
 
-    session.off('Debugger.scriptParsed', this.onScriptParsed);
+    if (traceSources.some((source) => source === undefined)) {
+      // `disableAsyncStacks()` in `prepare.js` runs after `stopInstrumentation` and calls
+      // `Debugger.disable`, so re-enable `Debugger` if we need to call `Debugger.getScriptSource`.
+      await session.sendCommand('Debugger.enable');
+    }
 
     // If run on a mobile device, be sensitive to memory limitations and only
     // request one at a time.
-    this._scriptContents = await runInSeriesOrParallel(
+    const scriptContents = await runInSeriesOrParallel(
       this._scriptParsedEvents,
-      ({scriptId}) => {
-        return session.sendCommand('Debugger.getScriptSource', {scriptId})
+      (script, i) => {
+        if (traceSources[i] !== undefined) return Promise.resolve(traceSources[i]);
+        return session.sendCommand('Debugger.getScriptSource', {scriptId: script.scriptId})
           .then((resp) => resp.scriptSource)
           .catch(() => undefined);
       },
       formFactor === 'mobile' /* runInSeries */
     );
     await session.sendCommand('Debugger.disable');
-  }
 
-  async getArtifact() {
     /** @type {LH.Artifacts['Scripts']} */
     const scripts = this._scriptParsedEvents.map((event, i) => {
       // 'embedderName' and 'url' are confusingly named, so we rewrite them here.
@@ -123,10 +264,12 @@ class Scripts extends BaseGatherer {
         // embedderName is optional on the protocol because backends like Node may not set it.
         // For our purposes, it is always set. But just in case it isn't... fallback to the url.
         url: event.embedderName || event.url,
-        content: this._scriptContents[i],
+        content: scriptContents[i],
       };
     });
 
+    this._scriptParsedEvents = [];
+
     return scripts;
   }
 }

package/core/gather/gatherers/stylesheets.js

@@ -82,6 +82,8 @@ class Stylesheets extends BaseGatherer {
 
     // Ensure we finish fetching all stylesheet contents before disabling the CSS domain
     const sheets = await Promise.all(this._sheetPromises.values());
+    this._sheetPromises.clear();
+    this._session = undefined;
 
     await session.sendCommand('CSS.disable');
     await session.sendCommand('DOM.disable');

package/core/gather/gatherers/trace-elements.js

@@ -21,6 +21,7 @@ import {ProcessedTrace} from '../../computed/processed-trace.js';
 import {Responsiveness} from '../../computed/metrics/responsiveness.js';
 import {CumulativeLayoutShift} from '../../computed/metrics/cumulative-layout-shift.js';
 import {TraceEngineResult} from '../../computed/trace-engine-result.js';
+import {Helpers} from '../../lib/trace-engine.js';
 import SourceMaps from './source-maps.js';
 
 /** @typedef {{nodeId: number, animations?: {name?: string, failureReasonsMask?: number, unsupportedProperties?: string[]}[], type?: string}} TraceElementData */
@@ -80,7 +81,7 @@ class TraceElements extends BaseGatherer {
     }
 
     if (navigationId) {
-      if (insightSet.navigation?.args.data?.navigationId !== navigationId) {
+      if (Helpers.Trace.navigationIDForEvent(insightSet.navigation) !== navigationId) {
         return [];
       }
     } else {

package/core/lib/arbitrary-equality-map.d.ts

@@ -5,9 +5,7 @@
  */
 export class ArbitraryEqualityMap {
     /**
-     * Determines whether two objects are deeply equal. Defers to lodash isEqual, but is kept here for
-     * easy usage by consumers.
-     * See https://lodash.com/docs/4.17.5#isEqual.
+     * Determines whether two objects are deeply equal.
      * @param {*} objA
      * @param {*} objB
      * @return {boolean}
@@ -44,4 +42,17 @@ export class ArbitraryEqualityMap {
      */
     _findIndexOf(key: any): number;
 }
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @param {*} a
+ * @param {*} b
+ * @param {WeakMap<object, object>=} seen
+ * @return {boolean}
+ */
+declare function deepEquals(a: any, b: any, seen?: WeakMap<object, object> | undefined): boolean;
+export { deepEquals as isEqual };
 //# sourceMappingURL=arbitrary-equality-map.d.ts.map

package/core/lib/arbitrary-equality-map.js

@@ -4,7 +4,76 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import {isEqual} from 'lodash-es';
+/**
+ * @param {*} a
+ * @param {*} b
+ * @param {WeakMap<object, object>=} seen
+ * @return {boolean}
+ */
+function deepEquals(a, b, seen) {
+  if (a === b || (Number.isNaN(a) && Number.isNaN(b))) return true;
+  if (typeof a !== 'object' || a === null || typeof b !== 'object' || b === null) {
+    return false;
+  }
+  if (a.constructor !== b.constructor) return false;
+
+  if (a instanceof Date && b instanceof Date) {
+    return a.getTime() === b.getTime() || (Number.isNaN(a.getTime()) && Number.isNaN(b.getTime()));
+  }
+  if (a instanceof RegExp && b instanceof RegExp) {
+    return a.source === b.source && a.flags === b.flags;
+  }
+  if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+    if (a.byteLength !== b.byteLength) return false;
+    const viewA = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
+    const viewB = new Uint8Array(b.buffer, b.byteOffset, b.byteLength);
+    for (let i = 0; i < viewA.length; i++) {
+      if (viewA[i] !== viewB[i]) return false;
+    }
+    return true;
+  }
+
+  if (seen) {
+    if (seen.get(a) === b) return true;
+  } else {
+    seen = new WeakMap();
+  }
+  seen.set(a, b);
+
+  if (Array.isArray(a)) {
+    const arrB = /** @type {unknown[]} */ (b);
+    if (a.length !== arrB.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!deepEquals(a[i], arrB[i], seen)) return false;
+    }
+    return true;
+  }
+
+  if (a instanceof Map && b instanceof Map) {
+    if (a.size !== b.size) return false;
+    for (const [k, v] of a) {
+      if (!b.has(k) || !deepEquals(v, b.get(k), seen)) return false;
+    }
+    return true;
+  }
+
+  if (a instanceof Set && b instanceof Set) {
+    if (a.size !== b.size) return false;
+    for (const v of a) {
+      if (!b.has(v)) return false;
+    }
+    return true;
+  }
+
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (let i = 0; i < keysA.length; i++) {
+    const key = keysA[i];
+    if (!Object.hasOwn(b, key) || !deepEquals(a[key], b[key], seen)) return false;
+  }
+  return true;
+}
 
 /**
  * @fileoverview This class is designed to allow maps with arbitrary equality functions.
@@ -65,16 +134,14 @@ class ArbitraryEqualityMap {
   }
 
   /**
-   * Determines whether two objects are deeply equal. Defers to lodash isEqual, but is kept here for
-   * easy usage by consumers.
-   * See https://lodash.com/docs/4.17.5#isEqual.
+   * Determines whether two objects are deeply equal.
    * @param {*} objA
    * @param {*} objB
    * @return {boolean}
    */
   static deepEquals(objA, objB) {
-    return isEqual(objA, objB);
+    return deepEquals(objA, objB);
   }
 }
 
-export {ArbitraryEqualityMap};
+export {ArbitraryEqualityMap, deepEquals as isEqual};

package/core/lib/cdt/Common.d.ts

@@ -1,3 +1,3 @@
 export { ParsedURL };
-import ParsedURL = require("./generated/ParsedURL.js");
+import * as ParsedURL from './generated/ParsedURL.js';
 //# sourceMappingURL=Common.d.ts.map

package/core/lib/cdt/Common.js

@@ -5,8 +5,8 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-const ParsedURL = require('./generated/ParsedURL.js');
+import * as ParsedURL from './generated/ParsedURL.js';
 
-module.exports = {
+export {
   ParsedURL,
 };

package/core/lib/cdt/Platform.d.ts

@@ -1,3 +1,10 @@
+export namespace ArrayUtilities {
+    export { lowerBound };
+    export { upperBound };
+}
+export namespace DevToolsPath {
+    let EmptyUrlString: string;
+}
 /**
  * @license
  * Copyright 2021 Google LLC
@@ -15,12 +22,5 @@ declare function lowerBound(array: any[], needle: any, comparator: any, left: an
  * @param {any} comparator
  */
 declare function upperBound(array: any[], needle: any, comparator: any, left: any, right: any): any;
-export namespace ArrayUtilities {
-    export { lowerBound };
-    export { upperBound };
-}
-export namespace DevToolsPath {
-    let EmptyUrlString: string;
-}
 export {};
 //# sourceMappingURL=Platform.d.ts.map

package/core/lib/cdt/Platform.js

@@ -46,12 +46,15 @@ function upperBound(array, needle, comparator, left, right) {
   return r;
 }
 
-module.exports = {
-  ArrayUtilities: {
-    lowerBound,
-    upperBound,
-  },
-  DevToolsPath: {
-    EmptyUrlString: '',
-  },
+const ArrayUtilities = {
+  lowerBound,
+  upperBound,
+};
+const DevToolsPath = {
+  EmptyUrlString: '',
+};
+
+export {
+  ArrayUtilities,
+  DevToolsPath,
 };

package/core/lib/cdt/SDK.d.ts

@@ -1,2 +1,6 @@
-export let SourceMap: typeof import("./generated/SourceMap.js");
+export default SDK;
+declare namespace SDK {
+    export { SourceMap };
+}
+import SourceMap from './generated/SourceMap.js';
 //# sourceMappingURL=SDK.d.ts.map

package/core/lib/cdt/SDK.js

@@ -4,8 +4,10 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import SourceMap from './generated/SourceMap.js';
+
 const SDK = {
-  SourceMap: require('./generated/SourceMap.js'),
+  SourceMap,
 };
 
 // Add `lastColumnNumber` to mappings. This will eventually be added to CDT.
@@ -25,4 +27,4 @@ SDK.SourceMap.prototype.computeLastGeneratedColumns = function() {
   // Now, all but the last mapping on each line will have 'lastColumnNumber' set to a number.
 };
 
-module.exports = SDK;
+export default SDK;

package/core/lib/cdt/generated/ParsedURL.d.ts

@@ -1,4 +1,3 @@
-export const __esModule: boolean;
 /**
  * http://tools.ietf.org/html/rfc3986#section-5.2.4
  */

package/core/lib/cdt/generated/ParsedURL.js

@@ -1,7 +1,6 @@
 // @ts-nocheck
 // generated by yarn build-cdt-lib
 /* eslint-disable */
-"use strict";
 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
@@ -31,15 +30,11 @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ParsedURL = void 0;
-exports.normalizePath = normalizePath;
-exports.schemeIs = schemeIs;
 ;
 /**
  * http://tools.ietf.org/html/rfc3986#section-5.2.4
  */
-function normalizePath(path) {
+export function normalizePath(path) {
     if (path.indexOf('..') === -1 && path.indexOf('.') === -1) {
         return path;
     }
@@ -69,7 +64,7 @@ function normalizePath(path) {
     }
     return normalizedPath;
 }
-function schemeIs(url, scheme) {
+export function schemeIs(url, scheme) {
     try {
         return (new URL(url)).protocol === scheme;
     }
@@ -77,7 +72,7 @@ function schemeIs(url, scheme) {
         return false;
     }
 }
-class ParsedURL {
+export class ParsedURL {
     isValid;
     url;
     scheme;
@@ -186,5 +181,4 @@ class ParsedURL {
     }
     static urlRegexInstance = null;
 }
-exports.ParsedURL = ParsedURL;
 

package/core/lib/cdt/generated/SourceMap.d.ts

@@ -1,5 +1,23 @@
-export = SourceMap;
-declare class SourceMap {
+/**
+ * Parses the {@link content} as JSON, ignoring BOM markers in the beginning, and
+ * also handling the CORB bypass prefix correctly.
+ *
+ * @param content the string representation of a sourcemap.
+ * @returns the {@link SourceMapV3} representation of the {@link content}.
+ */
+export function parseSourceMap(content: any): any;
+export class SourceMapEntry {
+    static compare(entry1: any, entry2: any): number;
+    constructor(lineNumber: any, columnNumber: any, sourceIndex: any, sourceURL: any, sourceLineNumber: any, sourceColumnNumber: any, name: any);
+    lineNumber: any;
+    columnNumber: any;
+    sourceIndex: any;
+    sourceURL: any;
+    sourceLineNumber: any;
+    sourceColumnNumber: any;
+    name: any;
+}
+export class SourceMap {
     /**
      * @param {string} compiledURL
      * @param {string} sourceMappingURL
@@ -76,30 +94,10 @@ declare class SourceMap {
     findOriginalFunctionName(position: any): any;
     #private;
 }
-declare namespace SourceMap {
-    export { parseSourceMap, __esModule, SourceMapEntry, SourceMap, TokenIterator };
-}
-/**
- * Parses the {@link content} as JSON, ignoring BOM markers in the beginning, and
- * also handling the CORB bypass prefix correctly.
- *
- * @param content the string representation of a sourcemap.
- * @returns the {@link SourceMapV3} representation of the {@link content}.
- */
-declare function parseSourceMap(content: any): any;
-declare const __esModule: boolean;
-declare class SourceMapEntry {
-    static compare(entry1: any, entry2: any): number;
-    constructor(lineNumber: any, columnNumber: any, sourceIndex: any, sourceURL: any, sourceLineNumber: any, sourceColumnNumber: any, name: any);
-    lineNumber: any;
-    columnNumber: any;
-    sourceIndex: any;
-    sourceURL: any;
-    sourceLineNumber: any;
-    sourceColumnNumber: any;
-    name: any;
+export namespace SourceMap {
+    export { parseSourceMap };
 }
-declare class TokenIterator {
+export class TokenIterator {
     constructor(string: any);
     next(): any;
     /** Returns the unicode value of the next character and advances the iterator  */
@@ -114,4 +112,5 @@ declare class TokenIterator {
     peekVLQ(): number | null;
     #private;
 }
+export default SourceMap;
 //# sourceMappingURL=SourceMap.d.ts.map

package/core/lib/cdt/generated/SourceMap.js

@@ -1,9 +1,8 @@
 // @ts-nocheck
 // generated by yarn build-cdt-lib
 /* eslint-disable */
-"use strict";
-const Common = require('../Common.js');
-const Platform = require('../Platform.js');
+import * as Common from '../Common.js';
+import * as Platform from '../Platform.js';
 
         const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
         const BASE64_CODES = new Uint8Array(123);
@@ -14,9 +13,6 @@ const Platform = require('../Platform.js');
 // Copyright 2021 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenIterator = exports.SourceMap = exports.SourceMapEntry = void 0;
-exports.parseSourceMap = parseSourceMap;
 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
@@ -59,7 +55,7 @@ exports.parseSourceMap = parseSourceMap;
  * @param content the string representation of a sourcemap.
  * @returns the {@link SourceMapV3} representation of the {@link content}.
  */
-function parseSourceMap(content) {
+export function parseSourceMap(content) {
     if (content.startsWith(')]}')) {
         content = content.substring(content.indexOf('\n'));
     }
@@ -69,7 +65,7 @@ function parseSourceMap(content) {
     }
     return JSON.parse(content);
 }
-class SourceMapEntry {
+export class SourceMapEntry {
     lineNumber;
     columnNumber;
     sourceIndex;
@@ -93,8 +89,7 @@ class SourceMapEntry {
         return entry1.columnNumber - entry2.columnNumber;
     }
 }
-exports.SourceMapEntry = SourceMapEntry;
-class SourceMap {
+export class SourceMap {
     #json;
     #compiledURLInternal;
     #sourceMappingURL;
@@ -502,11 +497,10 @@ class SourceMap {
         return this.#scopesInfo?.findOriginalFunctionName(position) ?? null;
     }
 }
-exports.SourceMap = SourceMap;
 const VLQ_BASE_SHIFT = 5;
 const VLQ_BASE_MASK = (1 << 5) - 1;
 const VLQ_CONTINUATION_MASK = 1 << 5;
-class TokenIterator {
+export class TokenIterator {
     #string;
     #position;
     constructor(string) {
@@ -565,8 +559,6 @@ class TokenIterator {
         }
     }
 }
-exports.TokenIterator = TokenIterator;
 
-
-module.exports = SourceMap;
+export default SourceMap;
 SourceMap.parseSourceMap = parseSourceMap;