@dcloudio/uni-stacktracey 2.0.2-4010420240430001 → 2.0.2-4020320240708001

package/dist/uni-stacktracey.cjs.js

@@ -1,14 +1,14 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
+var fs = require('fs');
+var path = require('path');
+var os = require('os');
 
-var require$$0$2 = require('fs');
-var require$$1$2 = require('path');
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0$2);
-var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1$2);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var os__default = /*#__PURE__*/_interopDefault(os);
 
 /*  ------------------------------------------------------------------------ */
 const O = Object, isBrowser = 
@@ -17,7 +17,9 @@ typeof window !== 'undefined' &&
     /* eslint-disable */
     window.window === window &&
     /* eslint-disable */
-    window.navigator, nodeRequire = isBrowser ? null : module.require, // to prevent bundlers from expanding the require call
+    window.navigator, 
+// @ts-ignore
+nodeRequire = isBrowser ? null : module.require, // to prevent bundlers from expanding the require call
 lastOf = (x) => x[x.length - 1], nixSlashes$1 = (x) => x.replace(/\\/g, '/'), pathRoot = isBrowser ? window.location.href : nixSlashes$1(process.cwd()) + '/';
 /*  ------------------------------------------------------------------------ */
 class StackTracey {
@@ -94,7 +96,7 @@ class StackTracey {
         result = externalDomainMatch ? externalDomainMatch[3] : result;
         // if (!isBrowser) result = nodeRequire!('path').relative(pathRoot, result)
         return [
-            nixSlashes$1(result).replace(/^.*\:\/\/?\/?/, ''),
+            nixSlashes$1(result).replace(/^.*\:\/\/?\/?/, ''), // cut webpack:/// and webpack:/ things
             externalDomain,
         ];
     }
@@ -190,8 +192,8 @@ function parseItem(e, maxColumnWidths, isMP) {
         return e.beforeParse;
     }
     const filePath = (isMP ? e.file && e.file : e.fileShort && e.fileShort) +
-        `${e.line ? ':' + e.line : ''}` +
-        `${e.column ? ':' + e.column : ''}`;
+        `${typeof e.line !== 'undefined' ? ':' + e.line : ''}` +
+        `${typeof e.column !== 'undefined' ? ':' + e.column : ''}`;
     return [
         'at ' + trimEnd(isMP ? e.callee : e.calleeShort, maxColumnWidths.callee),
         trimStart(filePath || '', maxColumnWidths.file),
@@ -204,692 +206,572 @@ function parseItem(e, maxColumnWidths, isMP) {
         return new StackTracey(this.items[method].apply(this.items, arguments));
     };
 });
-/*  ------------------------------------------------------------------------ */
-var StackTracey$1 = StackTracey;
-
-/* -*- Mode: js; js-indent-level: 2; -*- */
-/*
- * Copyright 2011 Mozilla Foundation and contributors
- * Licensed under the New BSD license. See LICENSE or:
- * http://opensource.org/licenses/BSD-3-Clause
- */
-
-const intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
-
-/**
- * Encode an integer in the range of 0 to 63 to a single base 64 digit.
- */
-var encode$1 = function(number) {
-  if (0 <= number && number < intToCharMap.length) {
-    return intToCharMap[number];
-  }
-  throw new TypeError("Must be between 0 and 63: " + number);
-};
 
-var base64$1 = {
-	encode: encode$1
-};
-
-var base64 = base64$1;
+var util$1 = {};
 
 /* -*- Mode: js; js-indent-level: 2; -*- */
 
-/*
- * Copyright 2011 Mozilla Foundation and contributors
- * Licensed under the New BSD license. See LICENSE or:
- * http://opensource.org/licenses/BSD-3-Clause
- *
- * Based on the Base 64 VLQ implementation in Closure Compiler:
- * https://code.google.com/p/closure-compiler/source/browse/trunk/src/com/google/debugging/sourcemap/Base64VLQ.java
- *
- * Copyright 2011 The Closure Compiler Authors. All rights reserved.
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *  * Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above
- *    copyright notice, this list of conditions and the following
- *    disclaimer in the documentation and/or other materials provided
- *    with the distribution.
- *  * Neither the name of Google Inc. nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-
-
-// A single base 64 digit can contain 6 bits of data. For the base 64 variable
-// length quantities we use in the source map spec, the first bit is the sign,
-// the next four bits are the actual value, and the 6th bit is the
-// continuation bit. The continuation bit tells us whether there are more
-// digits in this value following this digit.
-//
-//   Continuation
-//   |    Sign
-//   |    |
-//   V    V
-//   101011
-
-const VLQ_BASE_SHIFT = 5;
-
-// binary: 100000
-const VLQ_BASE = 1 << VLQ_BASE_SHIFT;
-
-// binary: 011111
-const VLQ_BASE_MASK = VLQ_BASE - 1;
-
-// binary: 100000
-const VLQ_CONTINUATION_BIT = VLQ_BASE;
-
-/**
- * Converts from a two-complement value to a value where the sign bit is
- * placed in the least significant bit.  For example, as decimals:
- *   1 becomes 2 (10 binary), -1 becomes 3 (11 binary)
- *   2 becomes 4 (100 binary), -2 becomes 5 (101 binary)
- */
-function toVLQSigned(aValue) {
-  return aValue < 0
-    ? ((-aValue) << 1) + 1
-    : (aValue << 1) + 0;
-}
-
-/**
- * Returns the base 64 VLQ encoded value.
- */
-var encode = function base64VLQ_encode(aValue) {
-  let encoded = "";
-  let digit;
-
-  let vlq = toVLQSigned(aValue);
-
-  do {
-    digit = vlq & VLQ_BASE_MASK;
-    vlq >>>= VLQ_BASE_SHIFT;
-    if (vlq > 0) {
-      // There are still more digits in this value, so we must make sure the
-      // continuation bit is marked.
-      digit |= VLQ_CONTINUATION_BIT;
-    }
-    encoded += base64.encode(digit);
-  } while (vlq > 0);
-
-  return encoded;
-};
-
-var base64Vlq = {
-	encode: encode
-};
-
-function createCommonjsModule(fn) {
-  var module = { exports: {} };
-	return fn(module, module.exports), module.exports;
-}
+(function (exports) {
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	/**
+	 * This is a helper function for getting values from parameter/options
+	 * objects.
+	 *
+	 * @param args The object we are extracting values from
+	 * @param name The name of the property we are getting.
+	 * @param defaultValue An optional value to return if the property is missing
+	 * from the object. If this is not specified and the property is missing, an
+	 * error will be thrown.
+	 */
+	function getArg(aArgs, aName, aDefaultValue) {
+	  if (aName in aArgs) {
+	    return aArgs[aName]
+	  } else if (arguments.length === 3) {
+	    return aDefaultValue
+	  }
+	  throw new Error('"' + aName + '" is a required argument.')
+	}
+	exports.getArg = getArg;
+
+	const urlRegexp =
+	  /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
+	const dataUrlRegexp = /^data:.+\,.+$/;
+
+	function urlParse(aUrl) {
+	  const match = aUrl.match(urlRegexp);
+	  if (!match) {
+	    return null
+	  }
+	  return {
+	    scheme: match[1],
+	    auth: match[2],
+	    host: match[3],
+	    port: match[4],
+	    path: match[5],
+	  }
+	}
+	exports.urlParse = urlParse;
+
+	function urlGenerate(aParsedUrl) {
+	  let url = '';
+	  if (aParsedUrl.scheme) {
+	    url += aParsedUrl.scheme + ':';
+	  }
+	  url += '//';
+	  if (aParsedUrl.auth) {
+	    url += aParsedUrl.auth + '@';
+	  }
+	  if (aParsedUrl.host) {
+	    url += aParsedUrl.host;
+	  }
+	  if (aParsedUrl.port) {
+	    url += ':' + aParsedUrl.port;
+	  }
+	  if (aParsedUrl.path) {
+	    url += aParsedUrl.path;
+	  }
+	  return url
+	}
+	exports.urlGenerate = urlGenerate;
+
+	const MAX_CACHED_INPUTS = 32;
+
+	/**
+	 * Takes some function `f(input) -> result` and returns a memoized version of
+	 * `f`.
+	 *
+	 * We keep at most `MAX_CACHED_INPUTS` memoized results of `f` alive. The
+	 * memoization is a dumb-simple, linear least-recently-used cache.
+	 */
+	function lruMemoize(f) {
+	  const cache = [];
+
+	  return function (input) {
+	    for (let i = 0; i < cache.length; i++) {
+	      if (cache[i].input === input) {
+	        const temp = cache[0];
+	        cache[0] = cache[i];
+	        cache[i] = temp;
+	        return cache[0].result
+	      }
+	    }
+
+	    const result = f(input);
+
+	    cache.unshift({
+	      input,
+	      result,
+	    });
+
+	    if (cache.length > MAX_CACHED_INPUTS) {
+	      cache.pop();
+	    }
+
+	    return result
+	  }
+	}
+
+	/**
+	 * Normalizes a path, or the path portion of a URL:
+	 *
+	 * - Replaces consecutive slashes with one slash.
+	 * - Removes unnecessary '.' parts.
+	 * - Removes unnecessary '<dir>/..' parts.
+	 *
+	 * Based on code in the Node.js 'path' core module.
+	 *
+	 * @param aPath The path or url to normalize.
+	 */
+	const normalize = lruMemoize(function normalize(aPath) {
+	  let path = aPath;
+	  const url = urlParse(aPath);
+	  if (url) {
+	    if (!url.path) {
+	      return aPath
+	    }
+	    path = url.path;
+	  }
+	  const isAbsolute = exports.isAbsolute(path);
+
+	  // Split the path into parts between `/` characters. This is much faster than
+	  // using `.split(/\/+/g)`.
+	  const parts = [];
+	  let start = 0;
+	  let i = 0;
+	  while (true) {
+	    start = i;
+	    i = path.indexOf('/', start);
+	    if (i === -1) {
+	      parts.push(path.slice(start));
+	      break
+	    } else {
+	      parts.push(path.slice(start, i));
+	      while (i < path.length && path[i] === '/') {
+	        i++;
+	      }
+	    }
+	  }
+
+	  let up = 0;
+	  for (i = parts.length - 1; i >= 0; i--) {
+	    const part = parts[i];
+	    if (part === '.') {
+	      parts.splice(i, 1);
+	    } else if (part === '..') {
+	      up++;
+	    } else if (up > 0) {
+	      if (part === '') {
+	        // The first part is blank if the path is absolute. Trying to go
+	        // above the root is a no-op. Therefore we can remove all '..' parts
+	        // directly after the root.
+	        parts.splice(i + 1, up);
+	        up = 0;
+	      } else {
+	        parts.splice(i, 2);
+	        up--;
+	      }
+	    }
+	  }
+	  path = parts.join('/');
+
+	  if (path === '') {
+	    path = isAbsolute ? '/' : '.';
+	  }
+
+	  if (url) {
+	    url.path = path;
+	    return urlGenerate(url)
+	  }
+	  return path
+	});
+	exports.normalize = normalize;
+
+	/**
+	 * Joins two paths/URLs.
+	 *
+	 * @param aRoot The root path or URL.
+	 * @param aPath The path or URL to be joined with the root.
+	 *
+	 * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
+	 *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
+	 *   first.
+	 * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
+	 *   is updated with the result and aRoot is returned. Otherwise the result
+	 *   is returned.
+	 *   - If aPath is absolute, the result is aPath.
+	 *   - Otherwise the two paths are joined with a slash.
+	 * - Joining for example 'http://' and 'www.example.com' is also supported.
+	 */
+	function join(aRoot, aPath) {
+	  if (aRoot === '') {
+	    aRoot = '.';
+	  }
+	  if (aPath === '') {
+	    aPath = '.';
+	  }
+	  const aPathUrl = urlParse(aPath);
+	  const aRootUrl = urlParse(aRoot);
+	  if (aRootUrl) {
+	    aRoot = aRootUrl.path || '/';
+	  }
+
+	  // `join(foo, '//www.example.org')`
+	  if (aPathUrl && !aPathUrl.scheme) {
+	    if (aRootUrl) {
+	      aPathUrl.scheme = aRootUrl.scheme;
+	    }
+	    return urlGenerate(aPathUrl)
+	  }
+
+	  if (aPathUrl || aPath.match(dataUrlRegexp)) {
+	    return aPath
+	  }
+
+	  // `join('http://', 'www.example.com')`
+	  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
+	    aRootUrl.host = aPath;
+	    return urlGenerate(aRootUrl)
+	  }
+
+	  const joined =
+	    aPath.charAt(0) === '/'
+	      ? aPath
+	      : normalize(aRoot.replace(/\/+$/, '') + '/' + aPath);
+
+	  if (aRootUrl) {
+	    aRootUrl.path = joined;
+	    return urlGenerate(aRootUrl)
+	  }
+	  return joined
+	}
+	exports.join = join;
+
+	exports.isAbsolute = function (aPath) {
+	  return aPath.charAt(0) === '/' || urlRegexp.test(aPath)
+	};
+
+	/**
+	 * Make a path relative to a URL or another path.
+	 *
+	 * @param aRoot The root path or URL.
+	 * @param aPath The path or URL to be made relative to aRoot.
+	 */
+	function relative(aRoot, aPath) {
+	  if (aRoot === '') {
+	    aRoot = '.';
+	  }
+
+	  aRoot = aRoot.replace(/\/$/, '');
+
+	  // It is possible for the path to be above the root. In this case, simply
+	  // checking whether the root is a prefix of the path won't work. Instead, we
+	  // need to remove components from the root one by one, until either we find
+	  // a prefix that fits, or we run out of components to remove.
+	  let level = 0;
+	  while (aPath.indexOf(aRoot + '/') !== 0) {
+	    const index = aRoot.lastIndexOf('/');
+	    if (index < 0) {
+	      return aPath
+	    }
+
+	    // If the only part of the root that is left is the scheme (i.e. http://,
+	    // file:///, etc.), one or more slashes (/), or simply nothing at all, we
+	    // have exhausted all components, so the path is not relative to the root.
+	    aRoot = aRoot.slice(0, index);
+	    if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
+	      return aPath
+	    }
+
+	    ++level;
+	  }
+
+	  // Make sure we add a "../" for each component we removed from the root.
+	  return Array(level + 1).join('../') + aPath.substr(aRoot.length + 1)
+	}
+	exports.relative = relative;
+
+	const supportsNullProto = (function () {
+	  const obj = Object.create(null);
+	  return !('__proto__' in obj)
+	})();
+
+	function identity(s) {
+	  return s
+	}
+
+	/**
+	 * Because behavior goes wacky when you set `__proto__` on objects, we
+	 * have to prefix all the strings in our set with an arbitrary character.
+	 *
+	 * See https://github.com/mozilla/source-map/pull/31 and
+	 * https://github.com/mozilla/source-map/issues/30
+	 *
+	 * @param String aStr
+	 */
+	function toSetString(aStr) {
+	  if (isProtoString(aStr)) {
+	    return '$' + aStr
+	  }
+
+	  return aStr
+	}
+	exports.toSetString = supportsNullProto ? identity : toSetString;
+
+	function fromSetString(aStr) {
+	  if (isProtoString(aStr)) {
+	    return aStr.slice(1)
+	  }
+
+	  return aStr
+	}
+	exports.fromSetString = supportsNullProto ? identity : fromSetString;
+
+	function isProtoString(s) {
+	  if (!s) {
+	    return false
+	  }
+
+	  const length = s.length;
+
+	  if (length < 9 /* "__proto__".length */) {
+	    return false
+	  }
+
+	  /* eslint-disable no-multi-spaces */
+	  if (
+	    s.charCodeAt(length - 1) !== 95 /* '_' */ ||
+	    s.charCodeAt(length - 2) !== 95 /* '_' */ ||
+	    s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
+	    s.charCodeAt(length - 4) !== 116 /* 't' */ ||
+	    s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
+	    s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
+	    s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
+	    s.charCodeAt(length - 8) !== 95 /* '_' */ ||
+	    s.charCodeAt(length - 9) !== 95 /* '_' */
+	  ) {
+	    return false
+	  }
+	  /* eslint-enable no-multi-spaces */
+
+	  for (let i = length - 10; i >= 0; i--) {
+	    if (s.charCodeAt(i) !== 36 /* '$' */) {
+	      return false
+	    }
+	  }
+
+	  return true
+	}
+
+	/**
+	 * Comparator between two mappings where the original positions are compared.
+	 *
+	 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+	 * mappings with the same original source/line/column, but different generated
+	 * line and column the same. Useful when searching for a mapping with a
+	 * stubbed out mapping.
+	 */
+	function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
+	  let cmp = strcmp(mappingA.source, mappingB.source);
+	  if (cmp !== 0) {
+	    return cmp
+	  }
+
+	  cmp = mappingA.originalLine - mappingB.originalLine;
+	  if (cmp !== 0) {
+	    return cmp
+	  }
+
+	  cmp = mappingA.originalColumn - mappingB.originalColumn;
+	  if (cmp !== 0 || onlyCompareOriginal) {
+	    return cmp
+	  }
+
+	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+	  if (cmp !== 0) {
+	    return cmp
+	  }
+
+	  cmp = mappingA.generatedLine - mappingB.generatedLine;
+	  if (cmp !== 0) {
+	    return cmp
+	  }
+
+	  return strcmp(mappingA.name, mappingB.name)
+	}
+	exports.compareByOriginalPositions = compareByOriginalPositions;
+
+	/**
+	 * Comparator between two mappings with deflated source and name indices where
+	 * the generated positions are compared.
+	 *
+	 * Optionally pass in `true` as `onlyCompareGenerated` to consider two
+	 * mappings with the same generated line and column, but different
+	 * source/name/original line and column the same. Useful when searching for a
+	 * mapping with a stubbed out mapping.
+	 */
+	function compareByGeneratedPositionsDeflated(
+	  mappingA,
+	  mappingB,
+	  onlyCompareGenerated
+	) {
+	  let cmp = mappingA.generatedLine - mappingB.generatedLine;
+	  if (cmp !== 0) {
+	    return cmp
+	  }
+
+	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+	  if (cmp !== 0 || onlyCompareGenerated) {
+	    return cmp
+	  }
+
+	  cmp = strcmp(mappingA.source, mappingB.source);
+	  if (cmp !== 0) {
+	    return cmp
+	  }
+
+	  cmp = mappingA.originalLine - mappingB.originalLine;
+	  if (cmp !== 0) {
+	    return cmp
+	  }
+
+	  cmp = mappingA.originalColumn - mappingB.originalColumn;
+	  if (cmp !== 0) {
+	    return cmp
+	  }
+
+	  return strcmp(mappingA.name, mappingB.name)
+	}
+	exports.compareByGeneratedPositionsDeflated =
+	  compareByGeneratedPositionsDeflated;
+
+	function strcmp(aStr1, aStr2) {
+	  if (aStr1 === aStr2) {
+	    return 0
+	  }
+
+	  if (aStr1 === null) {
+	    return 1 // aStr2 !== null
+	  }
+
+	  if (aStr2 === null) {
+	    return -1 // aStr1 !== null
+	  }
+
+	  if (aStr1 > aStr2) {
+	    return 1
+	  }
+
+	  return -1
+	}
+
+	/**
+	 * Comparator between two mappings with inflated source and name strings where
+	 * the generated positions are compared.
+	 */
+	function compareByGeneratedPositionsInflated(mappingA, mappingB) {
+	  let cmp = mappingA.generatedLine - mappingB.generatedLine;
+	  if (cmp !== 0) {
+	    return cmp
+	  }
+
+	  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
+	  if (cmp !== 0) {
+	    return cmp
+	  }
+
+	  cmp = strcmp(mappingA.source, mappingB.source);
+	  if (cmp !== 0) {
+	    return cmp
+	  }
+
+	  cmp = mappingA.originalLine - mappingB.originalLine;
+	  if (cmp !== 0) {
+	    return cmp
+	  }
+
+	  cmp = mappingA.originalColumn - mappingB.originalColumn;
+	  if (cmp !== 0) {
+	    return cmp
+	  }
+
+	  return strcmp(mappingA.name, mappingB.name)
+	}
+	exports.compareByGeneratedPositionsInflated =
+	  compareByGeneratedPositionsInflated;
+
+	/**
+	 * Strip any JSON XSSI avoidance prefix from the string (as documented
+	 * in the source maps specification), and then parse the string as
+	 * JSON.
+	 */
+	function parseSourceMapInput(str) {
+	  return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ''))
+	}
+	exports.parseSourceMapInput = parseSourceMapInput;
+
+	/**
+	 * Compute the URL of a source given the the source root, the source's
+	 * URL, and the source map's URL.
+	 */
+	function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
+	  sourceURL = sourceURL || '';
+
+	  if (sourceRoot) {
+	    // This follows what Chrome does.
+	    if (sourceRoot[sourceRoot.length - 1] !== '/' && sourceURL[0] !== '/') {
+	      sourceRoot += '/';
+	    }
+	    // The spec says:
+	    //   Line 4: An optional source root, useful for relocating source
+	    //   files on a server or removing repeated values in the
+	    //   “sources” entry.  This value is prepended to the individual
+	    //   entries in the “source” field.
+	    sourceURL = sourceRoot + sourceURL;
+	  }
+
+	  // Historically, SourceMapConsumer did not take the sourceMapURL as
+	  // a parameter.  This mode is still somewhat supported, which is why
+	  // this code block is conditional.  However, it's preferable to pass
+	  // the source map URL to SourceMapConsumer, so that this function
+	  // can implement the source URL resolution algorithm as outlined in
+	  // the spec.  This block is basically the equivalent of:
+	  //    new URL(sourceURL, sourceMapURL).toString()
+	  // ... except it avoids using URL, which wasn't available in the
+	  // older releases of node still supported by this library.
+	  //
+	  // The spec says:
+	  //   If the sources are not absolute URLs after prepending of the
+	  //   “sourceRoot”, the sources are resolved relative to the
+	  //   SourceMap (like resolving script src in a html document).
+	  if (sourceMapURL) {
+	    const parsed = urlParse(sourceMapURL);
+	    if (!parsed) {
+	      throw new Error('sourceMapURL could not be parsed')
+	    }
+	    if (parsed.path) {
+	      // Strip the last path component, but keep the "/".
+	      const index = parsed.path.lastIndexOf('/');
+	      if (index >= 0) {
+	        parsed.path = parsed.path.substring(0, index + 1);
+	      }
+	    }
+	    sourceURL = join(urlGenerate(parsed), sourceURL);
+	  }
+
+	  return normalize(sourceURL)
+	}
+	exports.computeSourceURL = computeSourceURL; 
+} (util$1));
+
+var arraySet = {};
 
 /* -*- Mode: js; js-indent-level: 2; -*- */
 
-var util$1 = createCommonjsModule(function (module, exports) {
-/*
- * Copyright 2011 Mozilla Foundation and contributors
- * Licensed under the New BSD license. See LICENSE or:
- * http://opensource.org/licenses/BSD-3-Clause
- */
-
-/**
- * This is a helper function for getting values from parameter/options
- * objects.
- *
- * @param args The object we are extracting values from
- * @param name The name of the property we are getting.
- * @param defaultValue An optional value to return if the property is missing
- * from the object. If this is not specified and the property is missing, an
- * error will be thrown.
- */
-function getArg(aArgs, aName, aDefaultValue) {
-  if (aName in aArgs) {
-    return aArgs[aName];
-  } else if (arguments.length === 3) {
-    return aDefaultValue;
-  }
-    throw new Error('"' + aName + '" is a required argument.');
-
-}
-exports.getArg = getArg;
-
-const urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
-const dataUrlRegexp = /^data:.+\,.+$/;
-
-function urlParse(aUrl) {
-  const match = aUrl.match(urlRegexp);
-  if (!match) {
-    return null;
-  }
-  return {
-    scheme: match[1],
-    auth: match[2],
-    host: match[3],
-    port: match[4],
-    path: match[5]
-  };
-}
-exports.urlParse = urlParse;
-
-function urlGenerate(aParsedUrl) {
-  let url = "";
-  if (aParsedUrl.scheme) {
-    url += aParsedUrl.scheme + ":";
-  }
-  url += "//";
-  if (aParsedUrl.auth) {
-    url += aParsedUrl.auth + "@";
-  }
-  if (aParsedUrl.host) {
-    url += aParsedUrl.host;
-  }
-  if (aParsedUrl.port) {
-    url += ":" + aParsedUrl.port;
-  }
-  if (aParsedUrl.path) {
-    url += aParsedUrl.path;
-  }
-  return url;
-}
-exports.urlGenerate = urlGenerate;
-
-const MAX_CACHED_INPUTS = 32;
-
-/**
- * Takes some function `f(input) -> result` and returns a memoized version of
- * `f`.
- *
- * We keep at most `MAX_CACHED_INPUTS` memoized results of `f` alive. The
- * memoization is a dumb-simple, linear least-recently-used cache.
- */
-function lruMemoize(f) {
-  const cache = [];
-
-  return function(input) {
-    for (let i = 0; i < cache.length; i++) {
-      if (cache[i].input === input) {
-        const temp = cache[0];
-        cache[0] = cache[i];
-        cache[i] = temp;
-        return cache[0].result;
-      }
-    }
-
-    const result = f(input);
-
-    cache.unshift({
-      input,
-      result,
-    });
-
-    if (cache.length > MAX_CACHED_INPUTS) {
-      cache.pop();
-    }
-
-    return result;
-  };
-}
-
-/**
- * Normalizes a path, or the path portion of a URL:
- *
- * - Replaces consecutive slashes with one slash.
- * - Removes unnecessary '.' parts.
- * - Removes unnecessary '<dir>/..' parts.
- *
- * Based on code in the Node.js 'path' core module.
- *
- * @param aPath The path or url to normalize.
- */
-const normalize = lruMemoize(function normalize(aPath) {
-  let path = aPath;
-  const url = urlParse(aPath);
-  if (url) {
-    if (!url.path) {
-      return aPath;
-    }
-    path = url.path;
-  }
-  const isAbsolute = exports.isAbsolute(path);
-
-  // Split the path into parts between `/` characters. This is much faster than
-  // using `.split(/\/+/g)`.
-  const parts = [];
-  let start = 0;
-  let i = 0;
-  while (true) {
-    start = i;
-    i = path.indexOf("/", start);
-    if (i === -1) {
-      parts.push(path.slice(start));
-      break;
-    } else {
-      parts.push(path.slice(start, i));
-      while (i < path.length && path[i] === "/") {
-        i++;
-      }
-    }
-  }
-
-  let up = 0;
-  for (i = parts.length - 1; i >= 0; i--) {
-    const part = parts[i];
-    if (part === ".") {
-      parts.splice(i, 1);
-    } else if (part === "..") {
-      up++;
-    } else if (up > 0) {
-      if (part === "") {
-        // The first part is blank if the path is absolute. Trying to go
-        // above the root is a no-op. Therefore we can remove all '..' parts
-        // directly after the root.
-        parts.splice(i + 1, up);
-        up = 0;
-      } else {
-        parts.splice(i, 2);
-        up--;
-      }
-    }
-  }
-  path = parts.join("/");
-
-  if (path === "") {
-    path = isAbsolute ? "/" : ".";
-  }
-
-  if (url) {
-    url.path = path;
-    return urlGenerate(url);
-  }
-  return path;
-});
-exports.normalize = normalize;
-
-/**
- * Joins two paths/URLs.
- *
- * @param aRoot The root path or URL.
- * @param aPath The path or URL to be joined with the root.
- *
- * - If aPath is a URL or a data URI, aPath is returned, unless aPath is a
- *   scheme-relative URL: Then the scheme of aRoot, if any, is prepended
- *   first.
- * - Otherwise aPath is a path. If aRoot is a URL, then its path portion
- *   is updated with the result and aRoot is returned. Otherwise the result
- *   is returned.
- *   - If aPath is absolute, the result is aPath.
- *   - Otherwise the two paths are joined with a slash.
- * - Joining for example 'http://' and 'www.example.com' is also supported.
- */
-function join(aRoot, aPath) {
-  if (aRoot === "") {
-    aRoot = ".";
-  }
-  if (aPath === "") {
-    aPath = ".";
-  }
-  const aPathUrl = urlParse(aPath);
-  const aRootUrl = urlParse(aRoot);
-  if (aRootUrl) {
-    aRoot = aRootUrl.path || "/";
-  }
-
-  // `join(foo, '//www.example.org')`
-  if (aPathUrl && !aPathUrl.scheme) {
-    if (aRootUrl) {
-      aPathUrl.scheme = aRootUrl.scheme;
-    }
-    return urlGenerate(aPathUrl);
-  }
-
-  if (aPathUrl || aPath.match(dataUrlRegexp)) {
-    return aPath;
-  }
-
-  // `join('http://', 'www.example.com')`
-  if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
-    aRootUrl.host = aPath;
-    return urlGenerate(aRootUrl);
-  }
-
-  const joined = aPath.charAt(0) === "/"
-    ? aPath
-    : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
-
-  if (aRootUrl) {
-    aRootUrl.path = joined;
-    return urlGenerate(aRootUrl);
-  }
-  return joined;
-}
-exports.join = join;
-
-exports.isAbsolute = function(aPath) {
-  return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
-};
-
-/**
- * Make a path relative to a URL or another path.
- *
- * @param aRoot The root path or URL.
- * @param aPath The path or URL to be made relative to aRoot.
- */
-function relative(aRoot, aPath) {
-  if (aRoot === "") {
-    aRoot = ".";
-  }
-
-  aRoot = aRoot.replace(/\/$/, "");
-
-  // It is possible for the path to be above the root. In this case, simply
-  // checking whether the root is a prefix of the path won't work. Instead, we
-  // need to remove components from the root one by one, until either we find
-  // a prefix that fits, or we run out of components to remove.
-  let level = 0;
-  while (aPath.indexOf(aRoot + "/") !== 0) {
-    const index = aRoot.lastIndexOf("/");
-    if (index < 0) {
-      return aPath;
-    }
-
-    // If the only part of the root that is left is the scheme (i.e. http://,
-    // file:///, etc.), one or more slashes (/), or simply nothing at all, we
-    // have exhausted all components, so the path is not relative to the root.
-    aRoot = aRoot.slice(0, index);
-    if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
-      return aPath;
-    }
-
-    ++level;
-  }
-
-  // Make sure we add a "../" for each component we removed from the root.
-  return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
-}
-exports.relative = relative;
-
-const supportsNullProto = (function() {
-  const obj = Object.create(null);
-  return !("__proto__" in obj);
-}());
-
-function identity(s) {
-  return s;
-}
-
-/**
- * Because behavior goes wacky when you set `__proto__` on objects, we
- * have to prefix all the strings in our set with an arbitrary character.
- *
- * See https://github.com/mozilla/source-map/pull/31 and
- * https://github.com/mozilla/source-map/issues/30
- *
- * @param String aStr
- */
-function toSetString(aStr) {
-  if (isProtoString(aStr)) {
-    return "$" + aStr;
-  }
-
-  return aStr;
-}
-exports.toSetString = supportsNullProto ? identity : toSetString;
-
-function fromSetString(aStr) {
-  if (isProtoString(aStr)) {
-    return aStr.slice(1);
-  }
-
-  return aStr;
-}
-exports.fromSetString = supportsNullProto ? identity : fromSetString;
-
-function isProtoString(s) {
-  if (!s) {
-    return false;
-  }
-
-  const length = s.length;
-
-  if (length < 9 /* "__proto__".length */) {
-    return false;
-  }
-
-  /* eslint-disable no-multi-spaces */
-  if (s.charCodeAt(length - 1) !== 95  /* '_' */ ||
-      s.charCodeAt(length - 2) !== 95  /* '_' */ ||
-      s.charCodeAt(length - 3) !== 111 /* 'o' */ ||
-      s.charCodeAt(length - 4) !== 116 /* 't' */ ||
-      s.charCodeAt(length - 5) !== 111 /* 'o' */ ||
-      s.charCodeAt(length - 6) !== 114 /* 'r' */ ||
-      s.charCodeAt(length - 7) !== 112 /* 'p' */ ||
-      s.charCodeAt(length - 8) !== 95  /* '_' */ ||
-      s.charCodeAt(length - 9) !== 95  /* '_' */) {
-    return false;
-  }
-  /* eslint-enable no-multi-spaces */
-
-  for (let i = length - 10; i >= 0; i--) {
-    if (s.charCodeAt(i) !== 36 /* '$' */) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * Comparator between two mappings where the original positions are compared.
- *
- * Optionally pass in `true` as `onlyCompareGenerated` to consider two
- * mappings with the same original source/line/column, but different generated
- * line and column the same. Useful when searching for a mapping with a
- * stubbed out mapping.
- */
-function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
-  let cmp = strcmp(mappingA.source, mappingB.source);
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  cmp = mappingA.originalLine - mappingB.originalLine;
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  cmp = mappingA.originalColumn - mappingB.originalColumn;
-  if (cmp !== 0 || onlyCompareOriginal) {
-    return cmp;
-  }
-
-  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  cmp = mappingA.generatedLine - mappingB.generatedLine;
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  return strcmp(mappingA.name, mappingB.name);
-}
-exports.compareByOriginalPositions = compareByOriginalPositions;
-
-/**
- * Comparator between two mappings with deflated source and name indices where
- * the generated positions are compared.
- *
- * Optionally pass in `true` as `onlyCompareGenerated` to consider two
- * mappings with the same generated line and column, but different
- * source/name/original line and column the same. Useful when searching for a
- * mapping with a stubbed out mapping.
- */
-function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
-  let cmp = mappingA.generatedLine - mappingB.generatedLine;
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
-  if (cmp !== 0 || onlyCompareGenerated) {
-    return cmp;
-  }
-
-  cmp = strcmp(mappingA.source, mappingB.source);
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  cmp = mappingA.originalLine - mappingB.originalLine;
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  cmp = mappingA.originalColumn - mappingB.originalColumn;
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  return strcmp(mappingA.name, mappingB.name);
-}
-exports.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
-
-function strcmp(aStr1, aStr2) {
-  if (aStr1 === aStr2) {
-    return 0;
-  }
-
-  if (aStr1 === null) {
-    return 1; // aStr2 !== null
-  }
-
-  if (aStr2 === null) {
-    return -1; // aStr1 !== null
-  }
-
-  if (aStr1 > aStr2) {
-    return 1;
-  }
-
-  return -1;
-}
-
-/**
- * Comparator between two mappings with inflated source and name strings where
- * the generated positions are compared.
- */
-function compareByGeneratedPositionsInflated(mappingA, mappingB) {
-  let cmp = mappingA.generatedLine - mappingB.generatedLine;
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  cmp = mappingA.generatedColumn - mappingB.generatedColumn;
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  cmp = strcmp(mappingA.source, mappingB.source);
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  cmp = mappingA.originalLine - mappingB.originalLine;
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  cmp = mappingA.originalColumn - mappingB.originalColumn;
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  return strcmp(mappingA.name, mappingB.name);
-}
-exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
-
-/**
- * Strip any JSON XSSI avoidance prefix from the string (as documented
- * in the source maps specification), and then parse the string as
- * JSON.
- */
-function parseSourceMapInput(str) {
-  return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
-}
-exports.parseSourceMapInput = parseSourceMapInput;
-
-/**
- * Compute the URL of a source given the the source root, the source's
- * URL, and the source map's URL.
- */
-function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
-  sourceURL = sourceURL || "";
-
-  if (sourceRoot) {
-    // This follows what Chrome does.
-    if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") {
-      sourceRoot += "/";
-    }
-    // The spec says:
-    //   Line 4: An optional source root, useful for relocating source
-    //   files on a server or removing repeated values in the
-    //   “sources” entry.  This value is prepended to the individual
-    //   entries in the “source” field.
-    sourceURL = sourceRoot + sourceURL;
-  }
-
-  // Historically, SourceMapConsumer did not take the sourceMapURL as
-  // a parameter.  This mode is still somewhat supported, which is why
-  // this code block is conditional.  However, it's preferable to pass
-  // the source map URL to SourceMapConsumer, so that this function
-  // can implement the source URL resolution algorithm as outlined in
-  // the spec.  This block is basically the equivalent of:
-  //    new URL(sourceURL, sourceMapURL).toString()
-  // ... except it avoids using URL, which wasn't available in the
-  // older releases of node still supported by this library.
-  //
-  // The spec says:
-  //   If the sources are not absolute URLs after prepending of the
-  //   “sourceRoot”, the sources are resolved relative to the
-  //   SourceMap (like resolving script src in a html document).
-  if (sourceMapURL) {
-    const parsed = urlParse(sourceMapURL);
-    if (!parsed) {
-      throw new Error("sourceMapURL could not be parsed");
-    }
-    if (parsed.path) {
-      // Strip the last path component, but keep the "/".
-      const index = parsed.path.lastIndexOf("/");
-      if (index >= 0) {
-        parsed.path = parsed.path.substring(0, index + 1);
-      }
-    }
-    sourceURL = join(urlGenerate(parsed), sourceURL);
-  }
-
-  return normalize(sourceURL);
-}
-exports.computeSourceURL = computeSourceURL;
-});
-
-/* -*- Mode: js; js-indent-level: 2; -*- */
 /*
  * Copyright 2011 Mozilla Foundation and contributors
  * Licensed under the New BSD license. See LICENSE or:
@@ -902,7 +784,7 @@ exports.computeSourceURL = computeSourceURL;
  * element is O(1). Removing elements from the set is not supported. Only
  * strings are supported for membership.
  */
-class ArraySet$2 {
+let ArraySet$1 = class ArraySet {
   constructor() {
     this._array = [];
     this._set = new Map();
@@ -912,11 +794,11 @@ class ArraySet$2 {
    * Static method for creating ArraySet instances from an existing array.
    */
   static fromArray(aArray, aAllowDuplicates) {
-    const set = new ArraySet$2();
+    const set = new ArraySet();
     for (let i = 0, len = aArray.length; i < len; i++) {
       set.add(aArray[i], aAllowDuplicates);
     }
-    return set;
+    return set
   }
 
   /**
@@ -926,7 +808,7 @@ class ArraySet$2 {
    * @returns Number
    */
   size() {
-    return this._set.size;
+    return this._set.size
   }
 
   /**
@@ -951,7 +833,7 @@ class ArraySet$2 {
    * @param String aStr
    */
   has(aStr) {
-      return this._set.has(aStr);
+    return this._set.has(aStr)
   }
 
   /**
@@ -962,9 +844,9 @@ class ArraySet$2 {
   indexOf(aStr) {
     const idx = this._set.get(aStr);
     if (idx >= 0) {
-        return idx;
+      return idx
     }
-    throw new Error('"' + aStr + '" is not in the set.');
+    throw new Error('"' + aStr + '" is not in the set.')
   }
 
   /**
@@ -974,9 +856,9 @@ class ArraySet$2 {
    */
   at(aIdx) {
     if (aIdx >= 0 && aIdx < this._array.length) {
-      return this._array[aIdx];
+      return this._array[aIdx]
     }
-    throw new Error("No element indexed by " + aIdx);
+    throw new Error('No element indexed by ' + aIdx)
   }
 
   /**
@@ -985,662 +867,168 @@ class ArraySet$2 {
    * for storing the members so that no one can mess with internal state.
    */
   toArray() {
-    return this._array.slice();
+    return this._array.slice()
   }
-}
-var ArraySet_1 = ArraySet$2;
-
-var arraySet = {
-	ArraySet: ArraySet_1
 };
+arraySet.ArraySet = ArraySet$1;
 
-var util = util$1;
-
-/* -*- Mode: js; js-indent-level: 2; -*- */
-
-/*
- * Copyright 2014 Mozilla Foundation and contributors
- * Licensed under the New BSD license. See LICENSE or:
- * http://opensource.org/licenses/BSD-3-Clause
- */
-
+var sourceMapConsumer = {};
 
-
-/**
- * Determine whether mappingB is after mappingA with respect to generated
- * position.
- */
-function generatedPositionAfter(mappingA, mappingB) {
-  // Optimized for most common case
-  const lineA = mappingA.generatedLine;
-  const lineB = mappingB.generatedLine;
-  const columnA = mappingA.generatedColumn;
-  const columnB = mappingB.generatedColumn;
-  return lineB > lineA || lineB == lineA && columnB >= columnA ||
-         util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
-}
-
-/**
- * A data structure to provide a sorted view of accumulated mappings in a
- * performance conscious manner. It trades a negligible overhead in general
- * case for a large speedup in case of mappings being added in order.
- */
-class MappingList$1 {
-  constructor() {
-    this._array = [];
-    this._sorted = true;
-    // Serves as infimum
-    this._last = {generatedLine: -1, generatedColumn: 0};
-  }
-
-  /**
-   * Iterate through internal items. This method takes the same arguments that
-   * `Array.prototype.forEach` takes.
-   *
-   * NOTE: The order of the mappings is NOT guaranteed.
-   */
-  unsortedForEach(aCallback, aThisArg) {
-    this._array.forEach(aCallback, aThisArg);
-  }
-
-  /**
-   * Add the given source mapping.
-   *
-   * @param Object aMapping
-   */
-  add(aMapping) {
-    if (generatedPositionAfter(this._last, aMapping)) {
-      this._last = aMapping;
-      this._array.push(aMapping);
-    } else {
-      this._sorted = false;
-      this._array.push(aMapping);
-    }
-  }
-
-  /**
-   * Returns the flat, sorted array of mappings. The mappings are sorted by
-   * generated position.
-   *
-   * WARNING: This method returns internal data without copying, for
-   * performance. The return value must NOT be mutated, and should be treated as
-   * an immutable borrow. If you want to take ownership, you must make your own
-   * copy.
-   */
-  toArray() {
-    if (!this._sorted) {
-      this._array.sort(util.compareByGeneratedPositionsInflated);
-      this._sorted = true;
-    }
-    return this._array;
-  }
-}
-
-var MappingList_1 = MappingList$1;
-
-var mappingList = {
-	MappingList: MappingList_1
-};
-
-var base64VLQ = base64Vlq;
-
-var require$$0$1 = arraySet;
-
-var require$$1$1 = mappingList;
+var binarySearch$1 = {};
 
 /* -*- Mode: js; js-indent-level: 2; -*- */
 
-/*
- * Copyright 2011 Mozilla Foundation and contributors
- * Licensed under the New BSD license. See LICENSE or:
- * http://opensource.org/licenses/BSD-3-Clause
- */
-
-
-
-const ArraySet$1 = require$$0$1.ArraySet;
-const MappingList = require$$1$1.MappingList;
-
-/**
- * An instance of the SourceMapGenerator represents a source map which is
- * being built incrementally. You may pass an object with the following
- * properties:
- *
- *   - file: The filename of the generated source.
- *   - sourceRoot: A root for all relative URLs in this source map.
- */
-class SourceMapGenerator$1 {
-  constructor(aArgs) {
-    if (!aArgs) {
-      aArgs = {};
-    }
-    this._file = util.getArg(aArgs, "file", null);
-    this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
-    this._skipValidation = util.getArg(aArgs, "skipValidation", false);
-    this._sources = new ArraySet$1();
-    this._names = new ArraySet$1();
-    this._mappings = new MappingList();
-    this._sourcesContents = null;
-  }
-
-  /**
-   * Creates a new SourceMapGenerator based on a SourceMapConsumer
-   *
-   * @param aSourceMapConsumer The SourceMap.
-   */
-  static fromSourceMap(aSourceMapConsumer) {
-    const sourceRoot = aSourceMapConsumer.sourceRoot;
-    const generator = new SourceMapGenerator$1({
-      file: aSourceMapConsumer.file,
-      sourceRoot
-    });
-    aSourceMapConsumer.eachMapping(function(mapping) {
-      const newMapping = {
-        generated: {
-          line: mapping.generatedLine,
-          column: mapping.generatedColumn
-        }
-      };
-
-      if (mapping.source != null) {
-        newMapping.source = mapping.source;
-        if (sourceRoot != null) {
-          newMapping.source = util.relative(sourceRoot, newMapping.source);
-        }
-
-        newMapping.original = {
-          line: mapping.originalLine,
-          column: mapping.originalColumn
-        };
-
-        if (mapping.name != null) {
-          newMapping.name = mapping.name;
-        }
-      }
-
-      generator.addMapping(newMapping);
-    });
-    aSourceMapConsumer.sources.forEach(function(sourceFile) {
-      let sourceRelative = sourceFile;
-      if (sourceRoot !== null) {
-        sourceRelative = util.relative(sourceRoot, sourceFile);
-      }
-
-      if (!generator._sources.has(sourceRelative)) {
-        generator._sources.add(sourceRelative);
-      }
-
-      const content = aSourceMapConsumer.sourceContentFor(sourceFile);
-      if (content != null) {
-        generator.setSourceContent(sourceFile, content);
-      }
-    });
-    return generator;
-  }
-
-  /**
-   * Add a single mapping from original source line and column to the generated
-   * source's line and column for this source map being created. The mapping
-   * object should have the following properties:
-   *
-   *   - generated: An object with the generated line and column positions.
-   *   - original: An object with the original line and column positions.
-   *   - source: The original source file (relative to the sourceRoot).
-   *   - name: An optional original token name for this mapping.
-   */
-  addMapping(aArgs) {
-    const generated = util.getArg(aArgs, "generated");
-    const original = util.getArg(aArgs, "original", null);
-    let source = util.getArg(aArgs, "source", null);
-    let name = util.getArg(aArgs, "name", null);
-
-    if (!this._skipValidation) {
-      this._validateMapping(generated, original, source, name);
-    }
-
-    if (source != null) {
-      source = String(source);
-      if (!this._sources.has(source)) {
-        this._sources.add(source);
-      }
-    }
-
-    if (name != null) {
-      name = String(name);
-      if (!this._names.has(name)) {
-        this._names.add(name);
-      }
-    }
-
-    this._mappings.add({
-      generatedLine: generated.line,
-      generatedColumn: generated.column,
-      originalLine: original != null && original.line,
-      originalColumn: original != null && original.column,
-      source,
-      name
-    });
-  }
-
-  /**
-   * Set the source content for a source file.
-   */
-  setSourceContent(aSourceFile, aSourceContent) {
-    let source = aSourceFile;
-    if (this._sourceRoot != null) {
-      source = util.relative(this._sourceRoot, source);
-    }
-
-    if (aSourceContent != null) {
-      // Add the source content to the _sourcesContents map.
-      // Create a new _sourcesContents map if the property is null.
-      if (!this._sourcesContents) {
-        this._sourcesContents = Object.create(null);
-      }
-      this._sourcesContents[util.toSetString(source)] = aSourceContent;
-    } else if (this._sourcesContents) {
-      // Remove the source file from the _sourcesContents map.
-      // If the _sourcesContents map is empty, set the property to null.
-      delete this._sourcesContents[util.toSetString(source)];
-      if (Object.keys(this._sourcesContents).length === 0) {
-        this._sourcesContents = null;
-      }
-    }
-  }
-
-  /**
-   * Applies the mappings of a sub-source-map for a specific source file to the
-   * source map being generated. Each mapping to the supplied source file is
-   * rewritten using the supplied source map. Note: The resolution for the
-   * resulting mappings is the minimium of this map and the supplied map.
-   *
-   * @param aSourceMapConsumer The source map to be applied.
-   * @param aSourceFile Optional. The filename of the source file.
-   *        If omitted, SourceMapConsumer's file property will be used.
-   * @param aSourceMapPath Optional. The dirname of the path to the source map
-   *        to be applied. If relative, it is relative to the SourceMapConsumer.
-   *        This parameter is needed when the two source maps aren't in the same
-   *        directory, and the source map to be applied contains relative source
-   *        paths. If so, those relative source paths need to be rewritten
-   *        relative to the SourceMapGenerator.
-   */
-  applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
-    let sourceFile = aSourceFile;
-    // If aSourceFile is omitted, we will use the file property of the SourceMap
-    if (aSourceFile == null) {
-      if (aSourceMapConsumer.file == null) {
-        throw new Error(
-          "SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, " +
-          'or the source map\'s "file" property. Both were omitted.'
-        );
-      }
-      sourceFile = aSourceMapConsumer.file;
-    }
-    const sourceRoot = this._sourceRoot;
-    // Make "sourceFile" relative if an absolute Url is passed.
-    if (sourceRoot != null) {
-      sourceFile = util.relative(sourceRoot, sourceFile);
-    }
-    // Applying the SourceMap can add and remove items from the sources and
-    // the names array.
-    const newSources = this._mappings.toArray().length > 0
-      ? new ArraySet$1()
-      : this._sources;
-    const newNames = new ArraySet$1();
-
-    // Find mappings for the "sourceFile"
-    this._mappings.unsortedForEach(function(mapping) {
-      if (mapping.source === sourceFile && mapping.originalLine != null) {
-        // Check if it can be mapped by the source map, then update the mapping.
-        const original = aSourceMapConsumer.originalPositionFor({
-          line: mapping.originalLine,
-          column: mapping.originalColumn
-        });
-        if (original.source != null) {
-          // Copy mapping
-          mapping.source = original.source;
-          if (aSourceMapPath != null) {
-            mapping.source = util.join(aSourceMapPath, mapping.source);
-          }
-          if (sourceRoot != null) {
-            mapping.source = util.relative(sourceRoot, mapping.source);
-          }
-          mapping.originalLine = original.line;
-          mapping.originalColumn = original.column;
-          if (original.name != null) {
-            mapping.name = original.name;
-          }
-        }
-      }
-
-      const source = mapping.source;
-      if (source != null && !newSources.has(source)) {
-        newSources.add(source);
-      }
-
-      const name = mapping.name;
-      if (name != null && !newNames.has(name)) {
-        newNames.add(name);
-      }
-
-    }, this);
-    this._sources = newSources;
-    this._names = newNames;
-
-    // Copy sourcesContents of applied map.
-    aSourceMapConsumer.sources.forEach(function(srcFile) {
-      const content = aSourceMapConsumer.sourceContentFor(srcFile);
-      if (content != null) {
-        if (aSourceMapPath != null) {
-          srcFile = util.join(aSourceMapPath, srcFile);
-        }
-        if (sourceRoot != null) {
-          srcFile = util.relative(sourceRoot, srcFile);
-        }
-        this.setSourceContent(srcFile, content);
-      }
-    }, this);
-  }
-
-  /**
-   * A mapping can have one of the three levels of data:
-   *
-   *   1. Just the generated position.
-   *   2. The Generated position, original position, and original source.
-   *   3. Generated and original position, original source, as well as a name
-   *      token.
-   *
-   * To maintain consistency, we validate that any new mapping being added falls
-   * in to one of these categories.
-   */
-  _validateMapping(aGenerated, aOriginal, aSource, aName) {
-    // When aOriginal is truthy but has empty values for .line and .column,
-    // it is most likely a programmer error. In this case we throw a very
-    // specific error message to try to guide them the right way.
-    // For example: https://github.com/Polymer/polymer-bundler/pull/519
-    if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") {
-        throw new Error(
-            "original.line and original.column are not numbers -- you probably meant to omit " +
-            "the original mapping entirely and only map the generated position. If so, pass " +
-            "null for the original mapping instead of an object with empty or null values."
-        );
-    }
-
-    if (aGenerated && "line" in aGenerated && "column" in aGenerated
-        && aGenerated.line > 0 && aGenerated.column >= 0
-        && !aOriginal && !aSource && !aName) ; else if (aGenerated && "line" in aGenerated && "column" in aGenerated
-             && aOriginal && "line" in aOriginal && "column" in aOriginal
-             && aGenerated.line > 0 && aGenerated.column >= 0
-             && aOriginal.line > 0 && aOriginal.column >= 0
-             && aSource) ; else {
-      throw new Error("Invalid mapping: " + JSON.stringify({
-        generated: aGenerated,
-        source: aSource,
-        original: aOriginal,
-        name: aName
-      }));
-    }
-  }
-
-  /**
-   * Serialize the accumulated mappings in to the stream of base 64 VLQs
-   * specified by the source map format.
-   */
-  _serializeMappings() {
-    let previousGeneratedColumn = 0;
-    let previousGeneratedLine = 1;
-    let previousOriginalColumn = 0;
-    let previousOriginalLine = 0;
-    let previousName = 0;
-    let previousSource = 0;
-    let result = "";
-    let next;
-    let mapping;
-    let nameIdx;
-    let sourceIdx;
-
-    const mappings = this._mappings.toArray();
-    for (let i = 0, len = mappings.length; i < len; i++) {
-      mapping = mappings[i];
-      next = "";
-
-      if (mapping.generatedLine !== previousGeneratedLine) {
-        previousGeneratedColumn = 0;
-        while (mapping.generatedLine !== previousGeneratedLine) {
-          next += ";";
-          previousGeneratedLine++;
-        }
-      } else if (i > 0) {
-        if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
-          continue;
-        }
-        next += ",";
-      }
-
-      next += base64VLQ.encode(mapping.generatedColumn
-                                 - previousGeneratedColumn);
-      previousGeneratedColumn = mapping.generatedColumn;
-
-      if (mapping.source != null) {
-        sourceIdx = this._sources.indexOf(mapping.source);
-        next += base64VLQ.encode(sourceIdx - previousSource);
-        previousSource = sourceIdx;
-
-        // lines are stored 0-based in SourceMap spec version 3
-        next += base64VLQ.encode(mapping.originalLine - 1
-                                   - previousOriginalLine);
-        previousOriginalLine = mapping.originalLine - 1;
-
-        next += base64VLQ.encode(mapping.originalColumn
-                                   - previousOriginalColumn);
-        previousOriginalColumn = mapping.originalColumn;
-
-        if (mapping.name != null) {
-          nameIdx = this._names.indexOf(mapping.name);
-          next += base64VLQ.encode(nameIdx - previousName);
-          previousName = nameIdx;
-        }
-      }
-
-      result += next;
-    }
-
-    return result;
-  }
-
-  _generateSourcesContent(aSources, aSourceRoot) {
-    return aSources.map(function(source) {
-      if (!this._sourcesContents) {
-        return null;
-      }
-      if (aSourceRoot != null) {
-        source = util.relative(aSourceRoot, source);
-      }
-      const key = util.toSetString(source);
-      return Object.prototype.hasOwnProperty.call(this._sourcesContents, key)
-        ? this._sourcesContents[key]
-        : null;
-    }, this);
-  }
-
-  /**
-   * Externalize the source map.
-   */
-  toJSON() {
-    const map = {
-      version: this._version,
-      sources: this._sources.toArray(),
-      names: this._names.toArray(),
-      mappings: this._serializeMappings()
-    };
-    if (this._file != null) {
-      map.file = this._file;
-    }
-    if (this._sourceRoot != null) {
-      map.sourceRoot = this._sourceRoot;
-    }
-    if (this._sourcesContents) {
-      map.sourcesContent = this._generateSourcesContent(map.sources, map.sourceRoot);
-    }
-
-    return map;
-  }
-
-  /**
-   * Render the source map being generated to a string.
-   */
-  toString() {
-    return JSON.stringify(this.toJSON());
-  }
-}
-
-SourceMapGenerator$1.prototype._version = 3;
-var SourceMapGenerator_1 = SourceMapGenerator$1;
-
-var sourceMapGenerator = {
-	SourceMapGenerator: SourceMapGenerator_1
-};
-
-/* -*- Mode: js; js-indent-level: 2; -*- */
-
-var binarySearch$1 = createCommonjsModule(function (module, exports) {
-/*
- * Copyright 2011 Mozilla Foundation and contributors
- * Licensed under the New BSD license. See LICENSE or:
- * http://opensource.org/licenses/BSD-3-Clause
- */
-
-exports.GREATEST_LOWER_BOUND = 1;
-exports.LEAST_UPPER_BOUND = 2;
-
-/**
- * Recursive implementation of binary search.
- *
- * @param aLow Indices here and lower do not contain the needle.
- * @param aHigh Indices here and higher do not contain the needle.
- * @param aNeedle The element being searched for.
- * @param aHaystack The non-empty array being searched.
- * @param aCompare Function which takes two elements and returns -1, 0, or 1.
- * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
- *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
- *     closest element that is smaller than or greater than the one we are
- *     searching for, respectively, if the exact element cannot be found.
- */
-function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
-  // This function terminates when one of the following is true:
-  //
-  //   1. We find the exact element we are looking for.
-  //
-  //   2. We did not find the exact element, but we can return the index of
-  //      the next-closest element.
-  //
-  //   3. We did not find the exact element, and there is no next-closest
-  //      element than the one we are searching for, so we return -1.
-  const mid = Math.floor((aHigh - aLow) / 2) + aLow;
-  const cmp = aCompare(aNeedle, aHaystack[mid], true);
-  if (cmp === 0) {
-    // Found the element we are looking for.
-    return mid;
-  } else if (cmp > 0) {
-    // Our needle is greater than aHaystack[mid].
-    if (aHigh - mid > 1) {
-      // The element is in the upper half.
-      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
-    }
-
-    // The exact needle element was not found in this haystack. Determine if
-    // we are in termination case (3) or (2) and return the appropriate thing.
-    if (aBias == exports.LEAST_UPPER_BOUND) {
-      return aHigh < aHaystack.length ? aHigh : -1;
-    }
-    return mid;
-  }
-
-  // Our needle is less than aHaystack[mid].
-  if (mid - aLow > 1) {
-    // The element is in the lower half.
-    return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
-  }
-
-  // we are in termination case (3) or (2) and return the appropriate thing.
-  if (aBias == exports.LEAST_UPPER_BOUND) {
-    return mid;
-  }
-  return aLow < 0 ? -1 : aLow;
-}
-
-/**
- * This is an implementation of binary search which will always try and return
- * the index of the closest element if there is no exact hit. This is because
- * mappings between original and generated line/col pairs are single points,
- * and there is an implicit region between each of them, so a miss just means
- * that you aren't on the very start of a region.
- *
- * @param aNeedle The element you are looking for.
- * @param aHaystack The array that is being searched.
- * @param aCompare A function which takes the needle and an element in the
- *     array and returns -1, 0, or 1 depending on whether the needle is less
- *     than, equal to, or greater than the element, respectively.
- * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
- *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
- *     closest element that is smaller than or greater than the one we are
- *     searching for, respectively, if the exact element cannot be found.
- *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
- */
-exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
-  if (aHaystack.length === 0) {
-    return -1;
-  }
-
-  let index = recursiveSearch(-1, aHaystack.length, aNeedle, aHaystack,
-                              aCompare, aBias || exports.GREATEST_LOWER_BOUND);
-  if (index < 0) {
-    return -1;
-  }
-
-  // We have found either the exact element, or the next-closest element than
-  // the one we are searching for. However, there may be more than one such
-  // element. Make sure we always return the smallest of these.
-  while (index - 1 >= 0) {
-    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
-      break;
-    }
-    --index;
-  }
-
-  return index;
-};
-});
+(function (exports) {
+	/*
+	 * Copyright 2011 Mozilla Foundation and contributors
+	 * Licensed under the New BSD license. See LICENSE or:
+	 * http://opensource.org/licenses/BSD-3-Clause
+	 */
+
+	exports.GREATEST_LOWER_BOUND = 1;
+	exports.LEAST_UPPER_BOUND = 2;
+
+	/**
+	 * Recursive implementation of binary search.
+	 *
+	 * @param aLow Indices here and lower do not contain the needle.
+	 * @param aHigh Indices here and higher do not contain the needle.
+	 * @param aNeedle The element being searched for.
+	 * @param aHaystack The non-empty array being searched.
+	 * @param aCompare Function which takes two elements and returns -1, 0, or 1.
+	 * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
+	 *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
+	 *     closest element that is smaller than or greater than the one we are
+	 *     searching for, respectively, if the exact element cannot be found.
+	 */
+	function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
+	  // This function terminates when one of the following is true:
+	  //
+	  //   1. We find the exact element we are looking for.
+	  //
+	  //   2. We did not find the exact element, but we can return the index of
+	  //      the next-closest element.
+	  //
+	  //   3. We did not find the exact element, and there is no next-closest
+	  //      element than the one we are searching for, so we return -1.
+	  const mid = Math.floor((aHigh - aLow) / 2) + aLow;
+	  const cmp = aCompare(aNeedle, aHaystack[mid], true);
+	  if (cmp === 0) {
+	    // Found the element we are looking for.
+	    return mid
+	  } else if (cmp > 0) {
+	    // Our needle is greater than aHaystack[mid].
+	    if (aHigh - mid > 1) {
+	      // The element is in the upper half.
+	      return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias)
+	    }
+
+	    // The exact needle element was not found in this haystack. Determine if
+	    // we are in termination case (3) or (2) and return the appropriate thing.
+	    if (aBias == exports.LEAST_UPPER_BOUND) {
+	      return aHigh < aHaystack.length ? aHigh : -1
+	    }
+	    return mid
+	  }
+
+	  // Our needle is less than aHaystack[mid].
+	  if (mid - aLow > 1) {
+	    // The element is in the lower half.
+	    return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias)
+	  }
+
+	  // we are in termination case (3) or (2) and return the appropriate thing.
+	  if (aBias == exports.LEAST_UPPER_BOUND) {
+	    return mid
+	  }
+	  return aLow < 0 ? -1 : aLow
+	}
+
+	/**
+	 * This is an implementation of binary search which will always try and return
+	 * the index of the closest element if there is no exact hit. This is because
+	 * mappings between original and generated line/col pairs are single points,
+	 * and there is an implicit region between each of them, so a miss just means
+	 * that you aren't on the very start of a region.
+	 *
+	 * @param aNeedle The element you are looking for.
+	 * @param aHaystack The array that is being searched.
+	 * @param aCompare A function which takes the needle and an element in the
+	 *     array and returns -1, 0, or 1 depending on whether the needle is less
+	 *     than, equal to, or greater than the element, respectively.
+	 * @param aBias Either 'binarySearch.GREATEST_LOWER_BOUND' or
+	 *     'binarySearch.LEAST_UPPER_BOUND'. Specifies whether to return the
+	 *     closest element that is smaller than or greater than the one we are
+	 *     searching for, respectively, if the exact element cannot be found.
+	 *     Defaults to 'binarySearch.GREATEST_LOWER_BOUND'.
+	 */
+	exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
+	  if (aHaystack.length === 0) {
+	    return -1
+	  }
+
+	  let index = recursiveSearch(
+	    -1,
+	    aHaystack.length,
+	    aNeedle,
+	    aHaystack,
+	    aCompare,
+	    aBias || exports.GREATEST_LOWER_BOUND
+	  );
+	  if (index < 0) {
+	    return -1
+	  }
+
+	  // We have found either the exact element, or the next-closest element than
+	  // the one we are searching for. However, there may be more than one such
+	  // element. Make sure we always return the smallest of these.
+	  while (index - 1 >= 0) {
+	    if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
+	      break
+	    }
+	    --index;
+	  }
+
+	  return index
+	}; 
+} (binarySearch$1));
+
+var readWasm$2 = {exports: {}};
 
 /* Determine browser vs node environment by testing the default top level context. Solution courtesy of: https://stackoverflow.com/questions/17575790/environment-detection-node-js-or-browser */
-
-var readWasm$1 = createCommonjsModule(function (module) {
 {
   // Node version of reading a wasm file into an array buffer.
-  const fs = require$$0__default["default"];
-  const path = require$$1__default["default"];
+  const fs = fs__default.default;
+  const path = path__default.default;
 
-  module.exports = function readWasm() {
+  readWasm$2.exports = function readWasm() {
     return new Promise((resolve, reject) => {
-      const wasmPath = path.join(__dirname, "../lib/source-map/lib", "mappings.wasm");
+      const wasmPath = path.join(
+        __dirname,
+        '../lib/source-map/lib',
+        'mappings.wasm'
+      );
       fs.readFile(wasmPath, null, (error, data) => {
         if (error) {
           reject(error);
-          return;
+          return
         }
 
         resolve(data.buffer);
       });
-    });
+    })
   };
 
-  module.exports.initialize = _ => {
-    console.debug("SourceMapConsumer.initialize is a no-op when running in node.js");
+  readWasm$2.exports.initialize = (_) => {
+    console.debug(
+      'SourceMapConsumer.initialize is a no-op when running in node.js'
+    );
   };
 }
-});
 
-var readWasm = readWasm$1;
+var readWasmExports = readWasm$2.exports;
+
+const readWasm$1 = readWasmExports;
 
 /**
  * Provide the JIT with a nice shape / hidden class.
@@ -1659,12 +1047,13 @@ let cachedWasm = null;
 
 var wasm$1 = function wasm() {
   if (cachedWasm) {
-    return cachedWasm;
+    return cachedWasm
   }
 
   const callbackStack = [];
 
-  cachedWasm = readWasm().then(buffer => {
+  cachedWasm = readWasm$1()
+    .then((buffer) => {
       return WebAssembly.instantiate(buffer, {
         env: {
           mapping_callback(
@@ -1706,52 +1095,78 @@ var wasm$1 = function wasm() {
             callbackStack[callbackStack.length - 1](mapping);
           },
 
-          start_all_generated_locations_for() { console.time("all_generated_locations_for"); },
-          end_all_generated_locations_for() { console.timeEnd("all_generated_locations_for"); },
+          start_all_generated_locations_for() {
+            console.time('all_generated_locations_for');
+          },
+          end_all_generated_locations_for() {
+            console.timeEnd('all_generated_locations_for');
+          },
 
-          start_compute_column_spans() { console.time("compute_column_spans"); },
-          end_compute_column_spans() { console.timeEnd("compute_column_spans"); },
+          start_compute_column_spans() {
+            console.time('compute_column_spans');
+          },
+          end_compute_column_spans() {
+            console.timeEnd('compute_column_spans');
+          },
 
-          start_generated_location_for() { console.time("generated_location_for"); },
-          end_generated_location_for() { console.timeEnd("generated_location_for"); },
+          start_generated_location_for() {
+            console.time('generated_location_for');
+          },
+          end_generated_location_for() {
+            console.timeEnd('generated_location_for');
+          },
 
-          start_original_location_for() { console.time("original_location_for"); },
-          end_original_location_for() { console.timeEnd("original_location_for"); },
+          start_original_location_for() {
+            console.time('original_location_for');
+          },
+          end_original_location_for() {
+            console.timeEnd('original_location_for');
+          },
 
-          start_parse_mappings() { console.time("parse_mappings"); },
-          end_parse_mappings() { console.timeEnd("parse_mappings"); },
+          start_parse_mappings() {
+            console.time('parse_mappings');
+          },
+          end_parse_mappings() {
+            console.timeEnd('parse_mappings');
+          },
 
-          start_sort_by_generated_location() { console.time("sort_by_generated_location"); },
-          end_sort_by_generated_location() { console.timeEnd("sort_by_generated_location"); },
+          start_sort_by_generated_location() {
+            console.time('sort_by_generated_location');
+          },
+          end_sort_by_generated_location() {
+            console.timeEnd('sort_by_generated_location');
+          },
 
-          start_sort_by_original_location() { console.time("sort_by_original_location"); },
-          end_sort_by_original_location() { console.timeEnd("sort_by_original_location"); },
-        }
-      });
-  }).then(Wasm => {
-    return {
-      exports: Wasm.instance.exports,
-      withMappingCallback: (mappingCallback, f) => {
-        callbackStack.push(mappingCallback);
-        try {
-          f();
-        } finally {
-          callbackStack.pop();
-        }
+          start_sort_by_original_location() {
+            console.time('sort_by_original_location');
+          },
+          end_sort_by_original_location() {
+            console.timeEnd('sort_by_original_location');
+          },
+        },
+      })
+    })
+    .then((Wasm) => {
+      return {
+        exports: Wasm.instance.exports,
+        withMappingCallback: (mappingCallback, f) => {
+          callbackStack.push(mappingCallback);
+          try {
+            f();
+          } finally {
+            callbackStack.pop();
+          }
+        },
       }
-    };
-  }).then(null, e => {
-    cachedWasm = null;
-    throw e;
-  });
+    })
+    .then(null, (e) => {
+      cachedWasm = null;
+      throw e
+    });
 
-  return cachedWasm;
+  return cachedWasm
 };
 
-var binarySearch = binarySearch$1;
-
-var wasm = wasm$1;
-
 /* -*- Mode: js; js-indent-level: 2; -*- */
 
 /*
@@ -1760,33 +1175,32 @@ var wasm = wasm$1;
  * http://opensource.org/licenses/BSD-3-Clause
  */
 
+const util = util$1;
+const binarySearch = binarySearch$1;
+const ArraySet = arraySet.ArraySet;
+const readWasm = readWasmExports;
+const wasm = wasm$1;
 
+const INTERNAL = Symbol('smcInternal');
 
-const ArraySet = require$$0$1.ArraySet;
- // eslint-disable-line no-unused-vars
-
-
-
-const INTERNAL = Symbol("smcInternal");
-
-class SourceMapConsumer$1 {
+let SourceMapConsumer$1 = class SourceMapConsumer {
   constructor(aSourceMap, aSourceMapURL) {
     // If the constructor was called by super(), just return Promise<this>.
     // Yes, this is a hack to retain the pre-existing API of the base-class
     // constructor also being an async factory function.
     if (aSourceMap == INTERNAL) {
-      return Promise.resolve(this);
+      return Promise.resolve(this)
     }
 
-    return _factory(aSourceMap, aSourceMapURL);
+    return _factory(aSourceMap, aSourceMapURL)
   }
 
   static initialize(opts) {
-    readWasm.initialize(opts["lib/mappings.wasm"]);
+    readWasm.initialize(opts['lib/mappings.wasm']);
   }
 
   static fromSourceMap(aSourceMap, aSourceMapURL) {
-    return _factoryBSM(aSourceMap, aSourceMapURL);
+    return _factoryBSM(aSourceMap, aSourceMapURL)
   }
 
   /**
@@ -1820,9 +1234,9 @@ class SourceMapConsumer$1 {
    * ```
    */
   static async with(rawSourceMap, sourceMapUrl, f) {
-    const consumer = await new SourceMapConsumer$1(rawSourceMap, sourceMapUrl);
+    const consumer = await new SourceMapConsumer(rawSourceMap, sourceMapUrl);
     try {
-      return await f(consumer);
+      return await f(consumer)
     } finally {
       consumer.destroy();
     }
@@ -1834,7 +1248,7 @@ class SourceMapConsumer$1 {
    * `this.__originalMappings` properties).
    */
   _parseMappings(aStr, aSourceRoot) {
-    throw new Error("Subclasses must implement _parseMappings");
+    throw new Error('Subclasses must implement _parseMappings')
   }
 
   /**
@@ -1854,7 +1268,7 @@ class SourceMapConsumer$1 {
    *        `SourceMapConsumer.GENERATED_ORDER`.
    */
   eachMapping(aCallback, aContext, aOrder) {
-    throw new Error("Subclasses must implement eachMapping");
+    throw new Error('Subclasses must implement eachMapping')
   }
 
   /**
@@ -1880,13 +1294,13 @@ class SourceMapConsumer$1 {
    *    The column number is 0-based.
    */
   allGeneratedPositionsFor(aArgs) {
-    throw new Error("Subclasses must implement allGeneratedPositionsFor");
+    throw new Error('Subclasses must implement allGeneratedPositionsFor')
   }
 
   destroy() {
-    throw new Error("Subclasses must implement destroy");
+    throw new Error('Subclasses must implement destroy')
   }
-}
+};
 
 /**
  * The version of the source mapping spec that we are consuming.
@@ -1898,7 +1312,7 @@ SourceMapConsumer$1.ORIGINAL_ORDER = 2;
 SourceMapConsumer$1.GREATEST_LOWER_BOUND = 1;
 SourceMapConsumer$1.LEAST_UPPER_BOUND = 2;
 
-var SourceMapConsumer_1 = SourceMapConsumer$1;
+sourceMapConsumer.SourceMapConsumer = SourceMapConsumer$1;
 
 /**
  * A BasicSourceMapConsumer instance represents a parsed source map which we can
@@ -1936,26 +1350,26 @@ var SourceMapConsumer_1 = SourceMapConsumer$1;
  */
 class BasicSourceMapConsumer extends SourceMapConsumer$1 {
   constructor(aSourceMap, aSourceMapURL) {
-    return super(INTERNAL).then(that => {
+    return super(INTERNAL).then((that) => {
       let sourceMap = aSourceMap;
-      if (typeof aSourceMap === "string") {
+      if (typeof aSourceMap === 'string') {
         sourceMap = util.parseSourceMapInput(aSourceMap);
       }
 
-      const version = util.getArg(sourceMap, "version");
-      let sources = util.getArg(sourceMap, "sources");
+      const version = util.getArg(sourceMap, 'version');
+      let sources = util.getArg(sourceMap, 'sources');
       // Sass 3.3 leaves out the 'names' array, so we deviate from the spec (which
       // requires the array) to play nice here.
-      const names = util.getArg(sourceMap, "names", []);
-      let sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
-      const sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
-      const mappings = util.getArg(sourceMap, "mappings");
-      const file = util.getArg(sourceMap, "file", null);
+      const names = util.getArg(sourceMap, 'names', []);
+      let sourceRoot = util.getArg(sourceMap, 'sourceRoot', null);
+      const sourcesContent = util.getArg(sourceMap, 'sourcesContent', null);
+      const mappings = util.getArg(sourceMap, 'mappings');
+      const file = util.getArg(sourceMap, 'file', null);
 
       // Once again, Sass deviates from the spec and supplies the version as a
       // string rather than a number, so we use loose equality checking here.
       if (version != that._version) {
-        throw new Error("Unsupported version: " + version);
+        throw new Error('Unsupported version: ' + version)
       }
 
       if (sourceRoot) {
@@ -1972,10 +1386,12 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
         // the source root, if the source root is absolute. Not doing this would
         // be particularly problematic when the source root is a prefix of the
         // source (valid, but why??). See github issue #199 and bugzil.la/1188982.
-        .map(function(source) {
-          return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source)
+        .map(function (source) {
+          return sourceRoot &&
+            util.isAbsolute(sourceRoot) &&
+            util.isAbsolute(source)
             ? util.relative(sourceRoot, source)
-            : source;
+            : source
         });
 
       // Pass `true` below to allow duplicate names and sources. While source maps
@@ -1985,8 +1401,8 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
       that._names = ArraySet.fromArray(names.map(String), true);
       that._sources = ArraySet.fromArray(sources, true);
 
-      that._absoluteSources = that._sources.toArray().map(function(s) {
-        return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
+      that._absoluteSources = that._sources.toArray().map(function (s) {
+        return util.computeSourceURL(sourceRoot, s, aSourceMapURL)
       });
 
       that.sourceRoot = sourceRoot;
@@ -1999,11 +1415,11 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
       that._mappingsPtr = 0;
       that._wasm = null;
 
-      return wasm().then(w => {
+      return wasm().then((w) => {
         that._wasm = w;
-        return that;
-      });
-    });
+        return that
+      })
+    })
   }
 
   /**
@@ -2017,18 +1433,18 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
     }
 
     if (this._sources.has(relativeSource)) {
-      return this._sources.indexOf(relativeSource);
+      return this._sources.indexOf(relativeSource)
     }
 
     // Maybe aSource is an absolute URL as returned by |sources|.  In
     // this case we can't simply undo the transform.
     for (let i = 0; i < this._absoluteSources.length; ++i) {
       if (this._absoluteSources[i] == aSource) {
-        return i;
+        return i
       }
     }
 
-    return -1;
+    return -1
   }
 
   /**
@@ -2041,11 +1457,11 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
    * @returns BasicSourceMapConsumer
    */
   static fromSourceMap(aSourceMap, aSourceMapURL) {
-    return new BasicSourceMapConsumer(aSourceMap.toString());
+    return new BasicSourceMapConsumer(aSourceMap.toString())
   }
 
   get sources() {
-    return this._absoluteSources.slice();
+    return this._absoluteSources.slice()
   }
 
   _getMappingsPtr() {
@@ -2053,7 +1469,7 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
       this._parseMappings(this._mappings, this.sourceRoot);
     }
 
-    return this._mappingsPtr;
+    return this._mappingsPtr
   }
 
   /**
@@ -2065,7 +1481,11 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
     const size = aStr.length;
 
     const mappingsBufPtr = this._wasm.exports.allocate_mappings(size);
-    const mappingsBuf = new Uint8Array(this._wasm.exports.memory.buffer, mappingsBufPtr, size);
+    const mappingsBuf = new Uint8Array(
+      this._wasm.exports.memory.buffer,
+      mappingsBufPtr,
+      size
+    );
     for (let i = 0; i < size; i++) {
       mappingsBuf[i] = aStr.charCodeAt(i);
     }
@@ -2079,23 +1499,24 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
       // XXX: keep these error codes in sync with `fitzgen/source-map-mappings`.
       switch (error) {
         case 1:
-          msg += "the mappings contained a negative line, column, source index, or name index";
-          break;
+          msg +=
+            'the mappings contained a negative line, column, source index, or name index';
+          break
         case 2:
-          msg += "the mappings contained a number larger than 2**32";
-          break;
+          msg += 'the mappings contained a number larger than 2**32';
+          break
         case 3:
-          msg += "reached EOF while in the middle of parsing a VLQ";
-          break;
+          msg += 'reached EOF while in the middle of parsing a VLQ';
+          break
         case 4:
-          msg += "invalid base 64 character while parsing a VLQ";
-          break;
+          msg += 'invalid base 64 character while parsing a VLQ';
+          break
         default:
-          msg += "unknown error code";
-          break;
+          msg += 'unknown error code';
+          break
       }
 
-      throw new Error(msg);
+      throw new Error(msg)
     }
 
     this._mappingsPtr = mappingsPtr;
@@ -2107,10 +1528,14 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
     const sourceRoot = this.sourceRoot;
 
     this._wasm.withMappingCallback(
-      mapping => {
+      (mapping) => {
         if (mapping.source !== null) {
           mapping.source = this._sources.at(mapping.source);
-          mapping.source = util.computeSourceURL(sourceRoot, mapping.source, this._sourceMapURL);
+          mapping.source = util.computeSourceURL(
+            sourceRoot,
+            mapping.source,
+            this._sourceMapURL
+          );
 
           if (mapping.name !== null) {
             mapping.name = this._names.at(mapping.name);
@@ -2121,41 +1546,41 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
       },
       () => {
         switch (order) {
-        case SourceMapConsumer$1.GENERATED_ORDER:
-          this._wasm.exports.by_generated_location(this._getMappingsPtr());
-          break;
-        case SourceMapConsumer$1.ORIGINAL_ORDER:
-          this._wasm.exports.by_original_location(this._getMappingsPtr());
-          break;
-        default:
-          throw new Error("Unknown order of iteration.");
+          case SourceMapConsumer$1.GENERATED_ORDER:
+            this._wasm.exports.by_generated_location(this._getMappingsPtr());
+            break
+          case SourceMapConsumer$1.ORIGINAL_ORDER:
+            this._wasm.exports.by_original_location(this._getMappingsPtr());
+            break
+          default:
+            throw new Error('Unknown order of iteration.')
         }
       }
     );
   }
 
   allGeneratedPositionsFor(aArgs) {
-    let source = util.getArg(aArgs, "source");
-    const originalLine = util.getArg(aArgs, "line");
+    let source = util.getArg(aArgs, 'source');
+    const originalLine = util.getArg(aArgs, 'line');
     const originalColumn = aArgs.column || 0;
 
     source = this._findSourceIndex(source);
     if (source < 0) {
-      return [];
+      return []
     }
 
     if (originalLine < 1) {
-      throw new Error("Line numbers must be >= 1");
+      throw new Error('Line numbers must be >= 1')
     }
 
     if (originalColumn < 0) {
-      throw new Error("Column numbers must be >= 0");
+      throw new Error('Column numbers must be >= 0')
     }
 
     const mappings = [];
 
     this._wasm.withMappingCallback(
-      m => {
+      (m) => {
         let lastColumn = m.lastGeneratedColumn;
         if (this._computedColumnSpans && lastColumn === null) {
           lastColumn = Infinity;
@@ -2165,18 +1590,19 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
           column: m.generatedColumn,
           lastColumn,
         });
-      }, () => {
+      },
+      () => {
         this._wasm.exports.all_generated_locations_for(
           this._getMappingsPtr(),
           source,
           originalLine - 1,
-          "column" in aArgs,
+          'column' in aArgs,
           originalColumn
         );
       }
     );
 
-    return mappings;
+    return mappings
   }
 
   destroy() {
@@ -2192,7 +1618,7 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
    */
   computeColumnSpans() {
     if (this._computedColumnSpans) {
-      return;
+      return
     }
 
     this._wasm.exports.compute_column_spans(this._getMappingsPtr());
@@ -2225,52 +1651,63 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
    */
   originalPositionFor(aArgs) {
     const needle = {
-      generatedLine: util.getArg(aArgs, "line"),
-      generatedColumn: util.getArg(aArgs, "column")
+      generatedLine: util.getArg(aArgs, 'line'),
+      generatedColumn: util.getArg(aArgs, 'column'),
     };
 
     if (needle.generatedLine < 1) {
-      throw new Error("Line numbers must be >= 1");
+      throw new Error('Line numbers must be >= 1')
     }
 
     if (needle.generatedColumn < 0) {
-      throw new Error("Column numbers must be >= 0");
+      throw new Error('Column numbers must be >= 0')
     }
 
-    let bias = util.getArg(aArgs, "bias", SourceMapConsumer$1.GREATEST_LOWER_BOUND);
+    let bias = util.getArg(
+      aArgs,
+      'bias',
+      SourceMapConsumer$1.GREATEST_LOWER_BOUND
+    );
     if (bias == null) {
       bias = SourceMapConsumer$1.GREATEST_LOWER_BOUND;
     }
 
     let mapping;
-    this._wasm.withMappingCallback(m => mapping = m, () => {
-      this._wasm.exports.original_location_for(
-        this._getMappingsPtr(),
-        needle.generatedLine - 1,
-        needle.generatedColumn,
-        bias
-      );
-    });
+    this._wasm.withMappingCallback(
+      (m) => (mapping = m),
+      () => {
+        this._wasm.exports.original_location_for(
+          this._getMappingsPtr(),
+          needle.generatedLine - 1,
+          needle.generatedColumn,
+          bias
+        );
+      }
+    );
 
     if (mapping) {
       if (mapping.generatedLine === needle.generatedLine) {
-        let source = util.getArg(mapping, "source", null);
+        let source = util.getArg(mapping, 'source', null);
         if (source !== null) {
           source = this._sources.at(source);
-          source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
+          source = util.computeSourceURL(
+            this.sourceRoot,
+            source,
+            this._sourceMapURL
+          );
         }
 
-        let name = util.getArg(mapping, "name", null);
+        let name = util.getArg(mapping, 'name', null);
         if (name !== null) {
           name = this._names.at(name);
         }
 
         return {
           source,
-          line: util.getArg(mapping, "originalLine", null),
-          column: util.getArg(mapping, "originalColumn", null),
-          name
-        };
+          line: util.getArg(mapping, 'originalLine', null),
+          column: util.getArg(mapping, 'originalColumn', null),
+          name,
+        }
       }
     }
 
@@ -2278,8 +1715,8 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
       source: null,
       line: null,
       column: null,
-      name: null
-    };
+      name: null,
+    }
   }
 
   /**
@@ -2288,10 +1725,14 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
    */
   hasContentsOfAllSources() {
     if (!this.sourcesContent) {
-      return false;
+      return false
     }
-    return this.sourcesContent.length >= this._sources.size() &&
-      !this.sourcesContent.some(function(sc) { return sc == null; });
+    return (
+      this.sourcesContent.length >= this._sources.size() &&
+      !this.sourcesContent.some(function (sc) {
+        return sc == null
+      })
+    )
   }
 
   /**
@@ -2301,12 +1742,12 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
    */
   sourceContentFor(aSource, nullOnMissing) {
     if (!this.sourcesContent) {
-      return null;
+      return null
     }
 
     const index = this._findSourceIndex(aSource);
     if (index >= 0) {
-      return this.sourcesContent[index];
+      return this.sourcesContent[index]
     }
 
     let relativeSource = aSource;
@@ -2315,21 +1756,21 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
     }
 
     let url;
-    if (this.sourceRoot != null
-        && (url = util.urlParse(this.sourceRoot))) {
+    if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) {
       // XXX: file:// URIs and absolute paths lead to unexpected behavior for
       // many users. We can help them out when they expect file:// URIs to
       // behave like it would if they were running a local HTTP server. See
       // https://bugzilla.mozilla.org/show_bug.cgi?id=885597.
-      const fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
-      if (url.scheme == "file"
-          && this._sources.has(fileUriAbsPath)) {
-        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
+      const fileUriAbsPath = relativeSource.replace(/^file:\/\//, '');
+      if (url.scheme == 'file' && this._sources.has(fileUriAbsPath)) {
+        return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)]
       }
 
-      if ((!url.path || url.path == "/")
-          && this._sources.has("/" + relativeSource)) {
-        return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
+      if (
+        (!url.path || url.path == '/') &&
+        this._sources.has('/' + relativeSource)
+      ) {
+        return this.sourcesContent[this._sources.indexOf('/' + relativeSource)]
       }
     }
 
@@ -2338,10 +1779,10 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
     // don't want to throw if we can't find the source - we just want to
     // return null, so we provide a flag to exit gracefully.
     if (nullOnMissing) {
-      return null;
+      return null
     }
 
-    throw new Error('"' + relativeSource + '" is not in the SourceMap.');
+    throw new Error('"' + relativeSource + '" is not in the SourceMap.')
   }
 
   /**
@@ -2368,45 +1809,52 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
    *     The column number is 0-based.
    */
   generatedPositionFor(aArgs) {
-    let source = util.getArg(aArgs, "source");
+    let source = util.getArg(aArgs, 'source');
     source = this._findSourceIndex(source);
     if (source < 0) {
       return {
         line: null,
         column: null,
-        lastColumn: null
-      };
+        lastColumn: null,
+      }
     }
 
     const needle = {
       source,
-      originalLine: util.getArg(aArgs, "line"),
-      originalColumn: util.getArg(aArgs, "column")
+      originalLine: util.getArg(aArgs, 'line'),
+      originalColumn: util.getArg(aArgs, 'column'),
     };
 
     if (needle.originalLine < 1) {
-      throw new Error("Line numbers must be >= 1");
+      throw new Error('Line numbers must be >= 1')
     }
 
     if (needle.originalColumn < 0) {
-      throw new Error("Column numbers must be >= 0");
+      throw new Error('Column numbers must be >= 0')
     }
 
-    let bias = util.getArg(aArgs, "bias", SourceMapConsumer$1.GREATEST_LOWER_BOUND);
+    let bias = util.getArg(
+      aArgs,
+      'bias',
+      SourceMapConsumer$1.GREATEST_LOWER_BOUND
+    );
     if (bias == null) {
       bias = SourceMapConsumer$1.GREATEST_LOWER_BOUND;
     }
 
     let mapping;
-    this._wasm.withMappingCallback(m => mapping = m, () => {
-      this._wasm.exports.generated_location_for(
-        this._getMappingsPtr(),
-        needle.source,
-        needle.originalLine - 1,
-        needle.originalColumn,
-        bias
-      );
-    });
+    this._wasm.withMappingCallback(
+      (m) => (mapping = m),
+      () => {
+        this._wasm.exports.generated_location_for(
+          this._getMappingsPtr(),
+          needle.source,
+          needle.originalLine - 1,
+          needle.originalColumn,
+          bias
+        );
+      }
+    );
 
     if (mapping) {
       if (mapping.source === needle.source) {
@@ -2415,23 +1863,23 @@ class BasicSourceMapConsumer extends SourceMapConsumer$1 {
           lastColumn = Infinity;
         }
         return {
-          line: util.getArg(mapping, "generatedLine", null),
-          column: util.getArg(mapping, "generatedColumn", null),
+          line: util.getArg(mapping, 'generatedLine', null),
+          column: util.getArg(mapping, 'generatedColumn', null),
           lastColumn,
-        };
+        }
       }
     }
 
     return {
       line: null,
       column: null,
-      lastColumn: null
-    };
+      lastColumn: null,
+    }
   }
 }
 
 BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer$1;
-var BasicSourceMapConsumer_1 = BasicSourceMapConsumer;
+sourceMapConsumer.BasicSourceMapConsumer = BasicSourceMapConsumer;
 
 /**
  * An IndexedSourceMapConsumer instance represents a parsed source map which
@@ -2484,17 +1932,17 @@ var BasicSourceMapConsumer_1 = BasicSourceMapConsumer;
  */
 class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
   constructor(aSourceMap, aSourceMapURL) {
-    return super(INTERNAL).then(that => {
+    return super(INTERNAL).then((that) => {
       let sourceMap = aSourceMap;
-      if (typeof aSourceMap === "string") {
+      if (typeof aSourceMap === 'string') {
         sourceMap = util.parseSourceMapInput(aSourceMap);
       }
 
-      const version = util.getArg(sourceMap, "version");
-      const sections = util.getArg(sourceMap, "sections");
+      const version = util.getArg(sourceMap, 'version');
+      const sections = util.getArg(sourceMap, 'sections');
 
       if (version != that._version) {
-        throw new Error("Unsupported version: " + version);
+        throw new Error('Unsupported version: ' + version)
       }
 
       that._sources = new ArraySet();
@@ -2506,41 +1954,52 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
 
       let lastOffset = {
         line: -1,
-        column: 0
+        column: 0,
       };
-      return Promise.all(sections.map(s => {
-        if (s.url) {
-          // The url field will require support for asynchronicity.
-          // See https://github.com/mozilla/source-map/issues/16
-          throw new Error("Support for url field in sections not implemented.");
-        }
-        const offset = util.getArg(s, "offset");
-        const offsetLine = util.getArg(offset, "line");
-        const offsetColumn = util.getArg(offset, "column");
+      return Promise.all(
+        sections.map((s) => {
+          if (s.url) {
+            // The url field will require support for asynchronicity.
+            // See https://github.com/mozilla/source-map/issues/16
+            throw new Error(
+              'Support for url field in sections not implemented.'
+            )
+          }
+          const offset = util.getArg(s, 'offset');
+          const offsetLine = util.getArg(offset, 'line');
+          const offsetColumn = util.getArg(offset, 'column');
 
-        if (offsetLine < lastOffset.line ||
-            (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
-          throw new Error("Section offsets must be ordered and non-overlapping.");
-        }
-        lastOffset = offset;
-
-        const cons = new SourceMapConsumer$1(util.getArg(s, "map"), aSourceMapURL);
-        return cons.then(consumer => {
-          return {
-            generatedOffset: {
-              // The offset fields are 0-based, but we use 1-based indices when
-              // encoding/decoding from VLQ.
-              generatedLine: offsetLine + 1,
-              generatedColumn: offsetColumn + 1
-            },
-            consumer
-          };
-        });
-      })).then(s => {
+          if (
+            offsetLine < lastOffset.line ||
+            (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)
+          ) {
+            throw new Error(
+              'Section offsets must be ordered and non-overlapping.'
+            )
+          }
+          lastOffset = offset;
+
+          const cons = new SourceMapConsumer$1(
+            util.getArg(s, 'map'),
+            aSourceMapURL
+          );
+          return cons.then((consumer) => {
+            return {
+              generatedOffset: {
+                // The offset fields are 0-based, but we use 1-based indices when
+                // encoding/decoding from VLQ.
+                generatedLine: offsetLine + 1,
+                generatedColumn: offsetColumn + 1,
+              },
+              consumer,
+            }
+          })
+        })
+      ).then((s) => {
         that._sections = s;
-        return that;
-      });
-    });
+        return that
+      })
+    })
   }
 
   // `__generatedMappings` and `__originalMappings` are arrays that hold the
@@ -2577,7 +2036,7 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
       this._sortGeneratedMappings();
     }
 
-    return this.__generatedMappings;
+    return this.__generatedMappings
   }
 
   get _originalMappings() {
@@ -2585,7 +2044,7 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
       this._sortOriginalMappings();
     }
 
-    return this.__originalMappings;
+    return this.__originalMappings
   }
 
   get _generatedMappingsUnsorted() {
@@ -2593,7 +2052,7 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
       this._parseMappings(this._mappings, this.sourceRoot);
     }
 
-    return this.__generatedMappingsUnsorted;
+    return this.__generatedMappingsUnsorted
   }
 
   get _originalMappingsUnsorted() {
@@ -2601,7 +2060,7 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
       this._parseMappings(this._mappings, this.sourceRoot);
     }
 
-    return this.__originalMappingsUnsorted;
+    return this.__originalMappingsUnsorted
   }
 
   _sortGeneratedMappings() {
@@ -2626,7 +2085,7 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
         sources.push(this._sections[i].consumer.sources[j]);
       }
     }
-    return sources;
+    return sources
   }
 
   /**
@@ -2650,22 +2109,25 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
    */
   originalPositionFor(aArgs) {
     const needle = {
-      generatedLine: util.getArg(aArgs, "line"),
-      generatedColumn: util.getArg(aArgs, "column")
+      generatedLine: util.getArg(aArgs, 'line'),
+      generatedColumn: util.getArg(aArgs, 'column'),
     };
 
     // Find the section containing the generated position we're trying to map
     // to an original position.
-    const sectionIndex = binarySearch.search(needle, this._sections,
-      function(aNeedle, section) {
-        const cmp = aNeedle.generatedLine - section.generatedOffset.generatedLine;
+    const sectionIndex = binarySearch.search(
+      needle,
+      this._sections,
+      function (aNeedle, section) {
+        const cmp =
+          aNeedle.generatedLine - section.generatedOffset.generatedLine;
         if (cmp) {
-          return cmp;
+          return cmp
         }
 
-        return (aNeedle.generatedColumn -
-                section.generatedOffset.generatedColumn);
-      });
+        return aNeedle.generatedColumn - section.generatedOffset.generatedColumn
+      }
+    );
     const section = this._sections[sectionIndex];
 
     if (!section) {
@@ -2673,19 +2135,19 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
         source: null,
         line: null,
         column: null,
-        name: null
-      };
+        name: null,
+      }
     }
 
     return section.consumer.originalPositionFor({
-      line: needle.generatedLine -
-        (section.generatedOffset.generatedLine - 1),
-      column: needle.generatedColumn -
+      line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
+      column:
+        needle.generatedColumn -
         (section.generatedOffset.generatedLine === needle.generatedLine
-         ? section.generatedOffset.generatedColumn - 1
-         : 0),
-      bias: aArgs.bias
-    });
+          ? section.generatedOffset.generatedColumn - 1
+          : 0),
+      bias: aArgs.bias,
+    })
   }
 
   /**
@@ -2693,9 +2155,9 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
    * map, false otherwise.
    */
   hasContentsOfAllSources() {
-    return this._sections.every(function(s) {
-      return s.consumer.hasContentsOfAllSources();
-    });
+    return this._sections.every(function (s) {
+      return s.consumer.hasContentsOfAllSources()
+    })
   }
 
   /**
@@ -2709,13 +2171,13 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
 
       const content = section.consumer.sourceContentFor(aSource, true);
       if (content) {
-        return content;
+        return content
       }
     }
     if (nullOnMissing) {
-      return null;
+      return null
     }
-    throw new Error('"' + aSource + '" is not in the SourceMap.');
+    throw new Error('"' + aSource + '" is not in the SourceMap.')
   }
 
   /**
@@ -2742,27 +2204,31 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
 
       // Only consider this section if the requested source is in the list of
       // sources of the consumer.
-      if (section.consumer._findSourceIndex(util.getArg(aArgs, "source")) === -1) {
-        continue;
+      if (
+        section.consumer._findSourceIndex(util.getArg(aArgs, 'source')) === -1
+      ) {
+        continue
       }
       const generatedPosition = section.consumer.generatedPositionFor(aArgs);
       if (generatedPosition) {
         const ret = {
-          line: generatedPosition.line +
+          line:
+            generatedPosition.line +
             (section.generatedOffset.generatedLine - 1),
-          column: generatedPosition.column +
+          column:
+            generatedPosition.column +
             (section.generatedOffset.generatedLine === generatedPosition.line
-             ? section.generatedOffset.generatedColumn - 1
-             : 0)
+              ? section.generatedOffset.generatedColumn - 1
+              : 0),
         };
-        return ret;
+        return ret
       }
     }
 
     return {
       line: null,
-      column: null
-    };
+      column: null,
+    }
   }
 
   /**
@@ -2771,13 +2237,13 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
    * `this.__originalMappings` properties).
    */
   _parseMappings(aStr, aSourceRoot) {
-    const generatedMappings = this.__generatedMappingsUnsorted = [];
-    const originalMappings = this.__originalMappingsUnsorted = [];
+    const generatedMappings = (this.__generatedMappingsUnsorted = []);
+    const originalMappings = (this.__originalMappingsUnsorted = []);
     for (let i = 0; i < this._sections.length; i++) {
       const section = this._sections[i];
 
       const sectionMappings = [];
-      section.consumer.eachMapping(m => sectionMappings.push(m));
+      section.consumer.eachMapping((m) => sectionMappings.push(m));
 
       for (let j = 0; j < sectionMappings.length; j++) {
         const mapping = sectionMappings[j];
@@ -2786,7 +2252,11 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
         // `source`, which would actually have gotten used as null because
         // var's get hoisted.
         // See: https://github.com/mozilla/source-map/issues/333
-        let source = util.computeSourceURL(section.consumer.sourceRoot, null, this._sourceMapURL);
+        let source = util.computeSourceURL(
+          section.consumer.sourceRoot,
+          null,
+          this._sourceMapURL
+        );
         this._sources.add(source);
         source = this._sources.indexOf(source);
 
@@ -2802,19 +2272,20 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
         // generated file.
         const adjustedMapping = {
           source,
-          generatedLine: mapping.generatedLine +
-            (section.generatedOffset.generatedLine - 1),
-          generatedColumn: mapping.generatedColumn +
+          generatedLine:
+            mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
+          generatedColumn:
+            mapping.generatedColumn +
             (section.generatedOffset.generatedLine === mapping.generatedLine
-            ? section.generatedOffset.generatedColumn - 1
-            : 0),
+              ? section.generatedOffset.generatedColumn - 1
+              : 0),
           originalLine: mapping.originalLine,
           originalColumn: mapping.originalColumn,
-          name
+          name,
         };
 
         generatedMappings.push(adjustedMapping);
-        if (typeof adjustedMapping.originalLine === "number") {
+        if (typeof adjustedMapping.originalLine === 'number') {
           originalMappings.push(adjustedMapping);
         }
       }
@@ -2827,91 +2298,96 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
 
     let mappings;
     switch (order) {
-    case SourceMapConsumer$1.GENERATED_ORDER:
-      mappings = this._generatedMappings;
-      break;
-    case SourceMapConsumer$1.ORIGINAL_ORDER:
-      mappings = this._originalMappings;
-      break;
-    default:
-      throw new Error("Unknown order of iteration.");
+      case SourceMapConsumer$1.GENERATED_ORDER:
+        mappings = this._generatedMappings;
+        break
+      case SourceMapConsumer$1.ORIGINAL_ORDER:
+        mappings = this._originalMappings;
+        break
+      default:
+        throw new Error('Unknown order of iteration.')
     }
 
     const sourceRoot = this.sourceRoot;
-    mappings.map(function(mapping) {
-      let source = null;
-      if (mapping.source !== null) {
-        source = this._sources.at(mapping.source);
-        source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL);
-      }
-      return {
-        source,
-        generatedLine: mapping.generatedLine,
-        generatedColumn: mapping.generatedColumn,
-        originalLine: mapping.originalLine,
-        originalColumn: mapping.originalColumn,
-        name: mapping.name === null ? null : this._names.at(mapping.name)
-      };
-    }, this).forEach(aCallback, context);
+    mappings
+      .map(function (mapping) {
+        let source = null;
+        if (mapping.source !== null) {
+          source = this._sources.at(mapping.source);
+          source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL);
+        }
+        return {
+          source,
+          generatedLine: mapping.generatedLine,
+          generatedColumn: mapping.generatedColumn,
+          originalLine: mapping.originalLine,
+          originalColumn: mapping.originalColumn,
+          name: mapping.name === null ? null : this._names.at(mapping.name),
+        }
+      }, this)
+      .forEach(aCallback, context);
   }
 
   /**
    * Find the mapping that best matches the hypothetical "needle" mapping that
    * we are searching for in the given "haystack" of mappings.
    */
-  _findMapping(aNeedle, aMappings, aLineName,
-              aColumnName, aComparator, aBias) {
+  _findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
     // To return the position we are searching for, we must first find the
     // mapping for the given position and then return the opposite position it
     // points to. Because the mappings are sorted, we can use binary search to
     // find the best mapping.
 
     if (aNeedle[aLineName] <= 0) {
-      throw new TypeError("Line must be greater than or equal to 1, got "
-                          + aNeedle[aLineName]);
+      throw new TypeError(
+        'Line must be greater than or equal to 1, got ' + aNeedle[aLineName]
+      )
     }
     if (aNeedle[aColumnName] < 0) {
-      throw new TypeError("Column must be greater than or equal to 0, got "
-                          + aNeedle[aColumnName]);
+      throw new TypeError(
+        'Column must be greater than or equal to 0, got ' + aNeedle[aColumnName]
+      )
     }
 
-    return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
+    return binarySearch.search(aNeedle, aMappings, aComparator, aBias)
   }
 
   allGeneratedPositionsFor(aArgs) {
-    const line = util.getArg(aArgs, "line");
+    const line = util.getArg(aArgs, 'line');
 
     // When there is no exact match, BasicSourceMapConsumer.prototype._findMapping
     // returns the index of the closest mapping less than the needle. By
     // setting needle.originalColumn to 0, we thus find the last mapping for
     // the given line, provided such a mapping exists.
     const needle = {
-      source: util.getArg(aArgs, "source"),
+      source: util.getArg(aArgs, 'source'),
       originalLine: line,
-      originalColumn: util.getArg(aArgs, "column", 0)
+      originalColumn: util.getArg(aArgs, 'column', 0),
     };
 
     needle.source = this._findSourceIndex(needle.source);
     if (needle.source < 0) {
-      return [];
+      return []
     }
 
     if (needle.originalLine < 1) {
-      throw new Error("Line numbers must be >= 1");
+      throw new Error('Line numbers must be >= 1')
     }
 
     if (needle.originalColumn < 0) {
-      throw new Error("Column numbers must be >= 0");
+      throw new Error('Column numbers must be >= 0')
     }
 
     const mappings = [];
 
-    let index = this._findMapping(needle,
-                                  this._originalMappings,
-                                  "originalLine",
-                                  "originalColumn",
-                                  util.compareByOriginalPositions,
-                                  binarySearch.LEAST_UPPER_BOUND);
+    let index = this._findMapping(
+      needle,
+      this._originalMappings,
+      'originalLine',
+      'originalColumn',
+      util.compareByOriginalPositions,
+      binarySearch.LEAST_UPPER_BOUND
+    );
     if (index >= 0) {
       let mapping = this._originalMappings[index];
 
@@ -2928,8 +2404,8 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
             lastColumn = Infinity;
           }
           mappings.push({
-            line: util.getArg(mapping, "generatedLine", null),
-            column: util.getArg(mapping, "generatedColumn", null),
+            line: util.getArg(mapping, 'generatedLine', null),
+            column: util.getArg(mapping, 'generatedColumn', null),
             lastColumn,
           });
 
@@ -2942,16 +2418,18 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
         // a mapping for a different line than the one we were searching for.
         // Since mappings are sorted, this is guaranteed to find all mappings for
         // the line we are searching for.
-        while (mapping &&
-               mapping.originalLine === line &&
-               mapping.originalColumn == originalColumn) {
+        while (
+          mapping &&
+          mapping.originalLine === line &&
+          mapping.originalColumn == originalColumn
+        ) {
           let lastColumn = mapping.lastGeneratedColumn;
           if (this._computedColumnSpans && lastColumn === null) {
             lastColumn = Infinity;
           }
           mappings.push({
-            line: util.getArg(mapping, "generatedLine", null),
-            column: util.getArg(mapping, "generatedColumn", null),
+            line: util.getArg(mapping, 'generatedLine', null),
+            column: util.getArg(mapping, 'generatedColumn', null),
             lastColumn,
           });
 
@@ -2960,7 +2438,7 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
       }
     }
 
-    return mappings;
+    return mappings
   }
 
   destroy() {
@@ -2969,7 +2447,7 @@ class IndexedSourceMapConsumer extends SourceMapConsumer$1 {
     }
   }
 }
-var IndexedSourceMapConsumer_1 = IndexedSourceMapConsumer;
+sourceMapConsumer.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
 
 /*
  * Cheat to get around inter-twingled classes.  `factory()` can be at the end
@@ -2977,451 +2455,188 @@ var IndexedSourceMapConsumer_1 = IndexedSourceMapConsumer;
  */
 function _factory(aSourceMap, aSourceMapURL) {
   let sourceMap = aSourceMap;
-  if (typeof aSourceMap === "string") {
+  if (typeof aSourceMap === 'string') {
     sourceMap = util.parseSourceMapInput(aSourceMap);
   }
 
-  const consumer = sourceMap.sections != null
+  const consumer =
+    sourceMap.sections != null
       ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL)
       : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
-  return Promise.resolve(consumer);
+  return Promise.resolve(consumer)
 }
 
 function _factoryBSM(aSourceMap, aSourceMapURL) {
-  return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
+  return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL)
 }
 
-var sourceMapConsumer = {
-	SourceMapConsumer: SourceMapConsumer_1,
-	BasicSourceMapConsumer: BasicSourceMapConsumer_1,
-	IndexedSourceMapConsumer: IndexedSourceMapConsumer_1
-};
-
-var require$$0 = sourceMapGenerator;
-
-/* -*- Mode: js; js-indent-level: 2; -*- */
-
 /*
- * Copyright 2011 Mozilla Foundation and contributors
- * Licensed under the New BSD license. See LICENSE or:
+ * Copyright 2009-2011 Mozilla Foundation and contributors
+ * Licensed under the New BSD license. See LICENSE.txt or:
  * http://opensource.org/licenses/BSD-3-Clause
  */
-
-const SourceMapGenerator = require$$0.SourceMapGenerator;
-
-
-// Matches a Windows-style `\r\n` newline or a `\n` newline used by all other
-// operating systems these days (capturing the result).
-const REGEX_NEWLINE = /(\r?\n)/;
-
-// Newline character code for charCodeAt() comparisons
-const NEWLINE_CODE = 10;
-
-// Private symbol for identifying `SourceNode`s when multiple versions of
-// the source-map library are loaded. This MUST NOT CHANGE across
-// versions!
-const isSourceNode = "$$$isSourceNode$$$";
-
-/**
- * SourceNodes provide a way to abstract over interpolating/concatenating
- * snippets of generated JavaScript source code while maintaining the line and
- * column information associated with the original source code.
- *
- * @param aLine The original line number.
- * @param aColumn The original column number.
- * @param aSource The original source's filename.
- * @param aChunks Optional. An array of strings which are snippets of
- *        generated JS, or other SourceNodes.
- * @param aName The original identifier.
- */
-class SourceNode {
-  constructor(aLine, aColumn, aSource, aChunks, aName) {
-    this.children = [];
-    this.sourceContents = {};
-    this.line = aLine == null ? null : aLine;
-    this.column = aColumn == null ? null : aColumn;
-    this.source = aSource == null ? null : aSource;
-    this.name = aName == null ? null : aName;
-    this[isSourceNode] = true;
-    if (aChunks != null) this.add(aChunks);
-  }
-
-  /**
-   * Creates a SourceNode from generated code and a SourceMapConsumer.
-   *
-   * @param aGeneratedCode The generated code
-   * @param aSourceMapConsumer The SourceMap for the generated code
-   * @param aRelativePath Optional. The path that relative sources in the
-   *        SourceMapConsumer should be relative to.
-   */
-  static fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
-    // The SourceNode we want to fill with the generated code
-    // and the SourceMap
-    const node = new SourceNode();
-
-    // All even indices of this array are one line of the generated code,
-    // while all odd indices are the newlines between two adjacent lines
-    // (since `REGEX_NEWLINE` captures its match).
-    // Processed fragments are accessed by calling `shiftNextLine`.
-    const remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
-    let remainingLinesIndex = 0;
-    const shiftNextLine = function() {
-      const lineContents = getNextLine();
-      // The last line of a file might not have a newline.
-      const newLine = getNextLine() || "";
-      return lineContents + newLine;
-
-      function getNextLine() {
-        return remainingLinesIndex < remainingLines.length ?
-            remainingLines[remainingLinesIndex++] : undefined;
-      }
-    };
-
-    // We need to remember the position of "remainingLines"
-    let lastGeneratedLine = 1, lastGeneratedColumn = 0;
-
-    // The generate SourceNodes we need a code range.
-    // To extract it current and last mapping is used.
-    // Here we store the last mapping.
-    let lastMapping = null;
-    let nextLine;
-
-    aSourceMapConsumer.eachMapping(function(mapping) {
-      if (lastMapping !== null) {
-        // We add the code from "lastMapping" to "mapping":
-        // First check if there is a new line in between.
-        if (lastGeneratedLine < mapping.generatedLine) {
-          // Associate first line with "lastMapping"
-          addMappingWithCode(lastMapping, shiftNextLine());
-          lastGeneratedLine++;
-          lastGeneratedColumn = 0;
-          // The remaining code is added without mapping
-        } else {
-          // There is no new line in between.
-          // Associate the code between "lastGeneratedColumn" and
-          // "mapping.generatedColumn" with "lastMapping"
-          nextLine = remainingLines[remainingLinesIndex] || "";
-          const code = nextLine.substr(0, mapping.generatedColumn -
-                                        lastGeneratedColumn);
-          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn -
-                                              lastGeneratedColumn);
-          lastGeneratedColumn = mapping.generatedColumn;
-          addMappingWithCode(lastMapping, code);
-          // No more remaining code, continue
-          lastMapping = mapping;
-          return;
+var SourceMapConsumer = sourceMapConsumer.SourceMapConsumer;
+
+const splitRE = /\r?\n/;
+const range = 2;
+function posToNumber(source, pos) {
+    if (typeof pos === 'number')
+        return pos;
+    const lines = source.split(splitRE);
+    const { line, column } = pos;
+    let start = 0;
+    for (let i = 0; i < line - 1; i++) {
+        start += lines[i].length + 1;
+    }
+    return start + column;
+}
+function generateCodeFrame(source, start = 0, end) {
+    start = posToNumber(source, start);
+    end = end || start;
+    const lines = source.split(splitRE);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - range; j <= i + range || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${line}${' '.repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`   |  ` + '^'.repeat(length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
         }
-      }
-      // We add the generated code until the first mapping
-      // to the SourceNode without any mapping.
-      // Each line is added as separate string.
-      while (lastGeneratedLine < mapping.generatedLine) {
-        node.add(shiftNextLine());
-        lastGeneratedLine++;
-      }
-      if (lastGeneratedColumn < mapping.generatedColumn) {
-        nextLine = remainingLines[remainingLinesIndex] || "";
-        node.add(nextLine.substr(0, mapping.generatedColumn));
-        remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
-        lastGeneratedColumn = mapping.generatedColumn;
-      }
-      lastMapping = mapping;
-    }, this);
-    // We have processed all mappings.
-    if (remainingLinesIndex < remainingLines.length) {
-      if (lastMapping) {
-        // Associate the remaining code in the current line with "lastMapping"
-        addMappingWithCode(lastMapping, shiftNextLine());
-      }
-      // and add the remaining lines without any mapping
-      node.add(remainingLines.splice(remainingLinesIndex).join(""));
     }
-
-    // Copy sourcesContent into SourceNode
-    aSourceMapConsumer.sources.forEach(function(sourceFile) {
-      const content = aSourceMapConsumer.sourceContentFor(sourceFile);
-      if (content != null) {
-        if (aRelativePath != null) {
-          sourceFile = util.join(aRelativePath, sourceFile);
+    return res.join('\n');
+}
+let isWindows = false;
+try {
+    isWindows = os__default.default.platform() === 'win32';
+}
+catch (error) { }
+function normalizePath(id) {
+    return isWindows ? id.replace(/\\/g, '/') : id;
+}
+function generateCodeFrameSourceMapConsumer(consumer, m, options = {}) {
+    if (m.file) {
+        const res = consumer.originalPositionFor({
+            line: m.line,
+            column: m.column,
+        });
+        if (res.source != null && res.line != null && res.column != null) {
+            let code = consumer.sourceContentFor(res.source, true);
+            if (code) {
+                code = generateCodeFrame(code, { line: res.line, column: res.column });
+                if (options.replaceTabsWithSpace) {
+                    code = code.replace(/\t/g, ' ');
+                }
+                return {
+                    type: m.type,
+                    file: options.sourceRoot
+                        ? normalizePath(path__default.default.relative(options.sourceRoot, res.source.replace('\\\\?\\', '')))
+                        : res.source,
+                    line: res.line,
+                    column: res.column,
+                    message: m.message,
+                    code,
+                };
+            }
         }
-        node.setSourceContent(sourceFile, content);
-      }
-    });
-
-    return node;
-
-    function addMappingWithCode(mapping, code) {
-      if (mapping === null || mapping.source === undefined) {
-        node.add(code);
-      } else {
-        const source = aRelativePath
-          ? util.join(aRelativePath, mapping.source)
-          : mapping.source;
-        node.add(new SourceNode(mapping.originalLine,
-                                mapping.originalColumn,
-                                source,
-                                code,
-                                mapping.name));
-      }
-    }
-  }
-
-  /**
-   * Add a chunk of generated JS to this source node.
-   *
-   * @param aChunk A string snippet of generated JS code, another instance of
-   *        SourceNode, or an array where each member is one of those things.
-   */
-  add(aChunk) {
-    if (Array.isArray(aChunk)) {
-      aChunk.forEach(function(chunk) {
-        this.add(chunk);
-      }, this);
-    } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
-      if (aChunk) {
-        this.children.push(aChunk);
-      }
-    } else {
-      throw new TypeError(
-        "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
-      );
-    }
-    return this;
-  }
-
-  /**
-   * Add a chunk of generated JS to the beginning of this source node.
-   *
-   * @param aChunk A string snippet of generated JS code, another instance of
-   *        SourceNode, or an array where each member is one of those things.
-   */
-  prepend(aChunk) {
-    if (Array.isArray(aChunk)) {
-      for (let i = aChunk.length - 1; i >= 0; i--) {
-        this.prepend(aChunk[i]);
-      }
-    } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
-      this.children.unshift(aChunk);
-    } else {
-      throw new TypeError(
-        "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
-      );
-    }
-    return this;
-  }
-
-  /**
-   * Walk over the tree of JS snippets in this node and its children. The
-   * walking function is called once for each snippet of JS and is passed that
-   * snippet and the its original associated source's line/column location.
-   *
-   * @param aFn The traversal function.
-   */
-  walk(aFn) {
-    let chunk;
-    for (let i = 0, len = this.children.length; i < len; i++) {
-      chunk = this.children[i];
-      if (chunk[isSourceNode]) {
-        chunk.walk(aFn);
-      } else if (chunk !== "") {
-        aFn(chunk, { source: this.source,
-                      line: this.line,
-                      column: this.column,
-                      name: this.name });
-      }
-    }
-  }
-
-  /**
-   * Like `String.prototype.join` except for SourceNodes. Inserts `aStr` between
-   * each of `this.children`.
-   *
-   * @param aSep The separator.
-   */
-  join(aSep) {
-    let newChildren;
-    let i;
-    const len = this.children.length;
-    if (len > 0) {
-      newChildren = [];
-      for (i = 0; i < len - 1; i++) {
-        newChildren.push(this.children[i]);
-        newChildren.push(aSep);
-      }
-      newChildren.push(this.children[i]);
-      this.children = newChildren;
-    }
-    return this;
-  }
-
-  /**
-   * Call String.prototype.replace on the very right-most source snippet. Useful
-   * for trimming whitespace from the end of a source node, etc.
-   *
-   * @param aPattern The pattern to replace.
-   * @param aReplacement The thing to replace the pattern with.
-   */
-  replaceRight(aPattern, aReplacement) {
-    const lastChild = this.children[this.children.length - 1];
-    if (lastChild[isSourceNode]) {
-      lastChild.replaceRight(aPattern, aReplacement);
-    } else if (typeof lastChild === "string") {
-      this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
-    } else {
-      this.children.push("".replace(aPattern, aReplacement));
-    }
-    return this;
-  }
-
-  /**
-   * Set the source content for a source file. This will be added to the SourceMapGenerator
-   * in the sourcesContent field.
-   *
-   * @param aSourceFile The filename of the source file
-   * @param aSourceContent The content of the source file
-   */
-  setSourceContent(aSourceFile, aSourceContent) {
-    this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
-  }
-
-  /**
-   * Walk over the tree of SourceNodes. The walking function is called for each
-   * source file content and is passed the filename and source content.
-   *
-   * @param aFn The traversal function.
-   */
-  walkSourceContents(aFn) {
-    for (let i = 0, len = this.children.length; i < len; i++) {
-      if (this.children[i][isSourceNode]) {
-        this.children[i].walkSourceContents(aFn);
-      }
     }
-
-    const sources = Object.keys(this.sourceContents);
-    for (let i = 0, len = sources.length; i < len; i++) {
-      aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
+}
+function initConsumer(filename) {
+    if (fs__default.default.existsSync(filename)) {
+        return new SourceMapConsumer(fs__default.default.readFileSync(filename, 'utf8'));
     }
-  }
-
-  /**
-   * Return the string representation of this source node. Walks over the tree
-   * and concatenates all the various snippets together to one string.
-   */
-  toString() {
-    let str = "";
-    this.walk(function(chunk) {
-      str += chunk;
-    });
-    return str;
-  }
-
-  /**
-   * Returns the string representation of this source node along with a source
-   * map.
-   */
-  toStringWithSourceMap(aArgs) {
-    const generated = {
-      code: "",
-      line: 1,
-      column: 0
-    };
-    const map = new SourceMapGenerator(aArgs);
-    let sourceMappingActive = false;
-    let lastOriginalSource = null;
-    let lastOriginalLine = null;
-    let lastOriginalColumn = null;
-    let lastOriginalName = null;
-    this.walk(function(chunk, original) {
-      generated.code += chunk;
-      if (original.source !== null
-          && original.line !== null
-          && original.column !== null) {
-        if (lastOriginalSource !== original.source
-          || lastOriginalLine !== original.line
-          || lastOriginalColumn !== original.column
-          || lastOriginalName !== original.name) {
-          map.addMapping({
-            source: original.source,
-            original: {
-              line: original.line,
-              column: original.column
-            },
-            generated: {
-              line: generated.line,
-              column: generated.column
-            },
-            name: original.name
-          });
+    return Promise.resolve(undefined);
+}
+function generateCodeFrameWithSourceMapPath(filename, messages, options = {}) {
+    if (typeof messages === 'string') {
+        try {
+            messages = JSON.parse(messages);
         }
-        lastOriginalSource = original.source;
-        lastOriginalLine = original.line;
-        lastOriginalColumn = original.column;
-        lastOriginalName = original.name;
-        sourceMappingActive = true;
-      } else if (sourceMappingActive) {
-        map.addMapping({
-          generated: {
-            line: generated.line,
-            column: generated.column
-          }
-        });
-        lastOriginalSource = null;
-        sourceMappingActive = false;
-      }
-      for (let idx = 0, length = chunk.length; idx < length; idx++) {
-        if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
-          generated.line++;
-          generated.column = 0;
-          // Mappings end at eol
-          if (idx + 1 === length) {
-            lastOriginalSource = null;
-            sourceMappingActive = false;
-          } else if (sourceMappingActive) {
-            map.addMapping({
-              source: original.source,
-              original: {
-                line: original.line,
-                column: original.column
-              },
-              generated: {
-                line: generated.line,
-                column: generated.column
-              },
-              name: original.name
+        catch (e) { }
+    }
+    if (Array.isArray(messages) && messages.length) {
+        return new Promise((resolve) => {
+            initConsumer(filename).then((consumer) => {
+                resolve(messages
+                    .map((m) => {
+                    if (m.file && consumer) {
+                        const message = generateCodeFrameSourceMapConsumer(consumer, m, options);
+                        if (message) {
+                            return message;
+                        }
+                    }
+                    if (!m.file) {
+                        m.file = '';
+                    }
+                    return m;
+                })
+                    .filter(Boolean));
             });
-          }
-        } else {
-          generated.column++;
-        }
-      }
+        });
+    }
+    return Promise.resolve([]);
+}
+function resolveSourceMapPath(sourceMapFilename, name, outputDir) {
+    const is_uni_modules = path__default.default.basename(path__default.default.dirname(name)) === 'uni_modules';
+    return path__default.default.resolve(outputDir, '../.sourcemap/app', name, is_uni_modules ? 'utssdk' : '', sourceMapFilename);
+}
+function generateCodeFrameWithKotlinStacktrace(stacktrace, { name, inputDir, outputDir }) {
+    const sourceMapFilename = resolveSourceMapPath('app-android/index.kt.map', name, outputDir);
+    return generateCodeFrameWithStacktrace(stacktrace, /e:\s+(.*):\s+\(([0-9]+),\s+([0-9]+)\):\s+(.*)/g, {
+        sourceRoot: inputDir,
+        sourceMapFilename,
     });
-    this.walkSourceContents(function(sourceFile, sourceContent) {
-      map.setSourceContent(sourceFile, sourceContent);
+}
+function generateCodeFrameWithSwiftStacktrace(stacktrace, { name, inputDir, outputDir }) {
+    const sourceMapFilename = resolveSourceMapPath('app-ios/index.swift.map', name, outputDir);
+    return generateCodeFrameWithStacktrace(stacktrace, /(.*):([0-9]+):([0-9]+):\s+error:\s+(.*)/g, {
+        sourceRoot: inputDir,
+        sourceMapFilename,
+    });
+}
+function generateCodeFrameWithStacktrace(stacktrace, regexp, { sourceRoot, sourceMapFilename, replaceTabsWithSpace, }) {
+    return new Promise((resolve) => {
+        initConsumer(sourceMapFilename).then((consumer) => {
+            if (!consumer) {
+                return resolve(stacktrace);
+            }
+            resolve(stacktrace.replace(regexp, (substring, file, line, column, message) => {
+                const m = generateCodeFrameSourceMapConsumer(consumer, {
+                    type: 'error',
+                    file,
+                    message,
+                    line: parseInt(line),
+                    column: parseInt(column),
+                }, { sourceRoot, replaceTabsWithSpace });
+                if (!m) {
+                    return substring;
+                }
+                return `error: ${message}
+at ${m.file}:${m.line}:${m.column}
+${m.code}
+`;
+            }));
+        });
     });
-
-    return { code: generated.code, map };
-  }
 }
-
-var SourceNode_1 = SourceNode;
-
-var sourceNode = {
-	SourceNode: SourceNode_1
-};
-
-var require$$1 = sourceMapConsumer;
-
-var require$$2 = sourceNode;
-
-/*
- * Copyright 2009-2011 Mozilla Foundation and contributors
- * Licensed under the New BSD license. See LICENSE.txt or:
- * http://opensource.org/licenses/BSD-3-Clause
- */
-
-require$$0.SourceMapGenerator;
-var SourceMapConsumer = require$$1.SourceMapConsumer;
-require$$2.SourceNode;
 
 const nixSlashes = (x) => x.replace(/\\/g, '/');
 const sourcemapCatch = {};
@@ -3441,9 +2656,9 @@ function stacktracey(stacktrace, opts) {
                     if (content) {
                         return getConsumer(content).then((consumer) => {
                             return parseSourceMapContent(consumer, {
-                                line,
+                                line: line + (opts.preset.lineOffset || 0),
                                 column,
-                            });
+                            }, !!opts.withSourceContent);
                         });
                     }
                 });
@@ -3451,7 +2666,7 @@ function stacktracey(stacktrace, opts) {
             try {
                 return _getSourceMapContent(file, fileName, fileRelative).then((sourceMapContent) => {
                     if (sourceMapContent) {
-                        const { source, sourcePath, sourceLine, sourceColumn, fileName = '', } = sourceMapContent;
+                        const { source, sourcePath, sourceLine, sourceColumn, sourceContent, fileName = '', } = sourceMapContent;
                         stack.items[index] = Object.assign({}, item, {
                             file: source,
                             line: sourceLine,
@@ -3461,6 +2676,7 @@ function stacktracey(stacktrace, opts) {
                             fileName,
                             thirdParty: isThirdParty(sourcePath),
                             parsed: true,
+                            sourceContent,
                         });
                         /**
                          * 以 .js 结尾
@@ -3519,7 +2735,7 @@ function getConsumer(content) {
                 });
             }
             else {
-                // @ts-ignore
+                // @ts-expect-error
                 const consumer = SourceMapConsumer(content);
                 resolve(consumer);
             }
@@ -3552,7 +2768,7 @@ function getSourceMapContent(sourcemapUrl) {
                         });
                     }
                     else {
-                        sourcemapCatch[sourcemapUrl] = require$$0__default["default"].readFileSync(sourcemapUrl, 'utf-8');
+                        sourcemapCatch[sourcemapUrl] = fs__default.default.readFileSync(sourcemapUrl, 'utf-8');
                         resolve(sourcemapCatch[sourcemapUrl]);
                     }
                 }
@@ -3565,7 +2781,7 @@ function getSourceMapContent(sourcemapUrl) {
         return '';
     }
 }
-function parseSourceMapContent(consumer, obj) {
+function parseSourceMapContent(consumer, obj, withSourceContent) {
     // source -> 'uni-app:///node_modules/@sentry/browser/esm/helpers.js'
     const { source, line: sourceLine, column: sourceColumn, } = consumer.originalPositionFor(obj);
     if (source) {
@@ -3578,6 +2794,9 @@ function parseSourceMapContent(consumer, obj) {
             sourceLine: sourceLine === null ? 0 : sourceLine,
             sourceColumn: sourceColumn === null ? 0 : sourceColumn,
             fileName,
+            sourceContent: withSourceContent
+                ? consumer.sourceContentFor(source) || ''
+                : '',
         };
     }
 }
@@ -3591,7 +2810,7 @@ function joinItem(item) {
     return `${a}${b}${c}`;
 }
 function uniStracktraceyPreset(opts) {
-    const { base, sourceRoot, splitThirdParty, uniPlatform } = opts;
+    const { base, sourceRoot, splitThirdParty, uniPlatform, lineOffset } = opts;
     let stack;
     return {
         /**
@@ -3633,7 +2852,7 @@ function uniStracktraceyPreset(opts) {
             return Promise.resolve(getSourceMapContent(sourcemapUrl));
         },
         parseStacktrace(stacktrace) {
-            stack = new StackTracey$1(stacktrace, uniPlatform);
+            stack = new StackTracey(stacktrace, uniPlatform);
             return stack;
         },
         asTableStacktrace({ maxColumnWidths, stacktrace, stack }) {
@@ -3674,18 +2893,15 @@ function uniStracktraceyPreset(opts) {
                 return errorName;
             }
         },
+        lineOffset,
     };
 }
 function utsStracktraceyPreset(opts) {
-    const { base, sourceRoot } = opts;
+    const { inputRoot, outputRoot, sourceMapRoot } = opts;
     let errStack = [];
     return {
         parseSourceMapUrl(file, fileName, fileRelative) {
-            // 组合 sourceMapUrl
-            if (sourceRoot) {
-                return `${file.replace(sourceRoot, base + '/')}.map`;
-            }
-            return `${base}/${file}.map`;
+            return path__default.default.resolve(sourceMapRoot, path__default.default.relative(outputRoot, file) + '.map');
         },
         getSourceMapContent(file, fileName, fileRelative) {
             // 根据 base,filename 组合 sourceMapUrl
@@ -3696,30 +2912,26 @@ function utsStracktraceyPreset(opts) {
             const entries = lines
                 .map((line, index) => {
                 line = line.trim();
-                let callee, fileLineColumn = [], planA, planB;
-                if ((planA = line.match(/e: (.+\.kt)(.+\))*:\s*(.+)*/))) {
+                const matches = line.match(/\s*(.+\.kt):([0-9]+):([0-9]+):\s+(.*)/);
+                if (matches) {
                     errStack.push('%StacktraceyItem%');
-                    callee = 'e: ';
-                    fileLineColumn = (planA[2].match(/.*:.*\((\d+).+?(\d+)\)/) || []).slice(1);
                 }
                 else {
                     errStack.push(line);
-                    return undefined;
+                    return;
                 }
-                const fileName = planA[1]
-                    ? (planB = planA[1].match(/(.*)*\/(.+)/) || [])[2] || ''
-                    : '';
+                const fileName = matches[1].replace(/^.*(\\|\/|\:)/, '');
                 return {
                     beforeParse: line,
-                    callee: callee || '',
+                    callee: '',
                     index: false,
                     native: false,
-                    file: nixSlashes(planA[1] || ''),
-                    line: parseInt(fileLineColumn[0] || '', 10) || undefined,
-                    column: parseInt(fileLineColumn[1] || '', 10) || undefined,
+                    file: nixSlashes(matches[1]),
+                    line: parseInt(matches[2]),
+                    column: parseInt(matches[3]),
                     fileName,
-                    fileShort: planB ? planB[1] : '',
-                    errMsg: planA[3] || '',
+                    fileShort: line,
+                    errMsg: matches[4] || '',
                     calleeShort: '',
                     fileRelative: '',
                     thirdParty: false,
@@ -3736,8 +2948,11 @@ function utsStracktraceyPreset(opts) {
                 .map((item) => {
                 if (item === '%StacktraceyItem%') {
                     const _stack = stack.items.shift();
-                    if (_stack)
-                        return `${_stack.callee}${_stack.file}: (${_stack.line}, ${_stack.column}): ${_stack.errMsg}`;
+                    if (_stack) {
+                        return `at ${nixSlashes(path__default.default.relative(inputRoot, _stack.file.replace('\\\\?\\', '')))}:${_stack.line}:${_stack.column}
+${_stack.errMsg}`;
+                    }
+                    return '';
                 }
                 return item;
             })
@@ -3746,6 +2961,12 @@ function utsStracktraceyPreset(opts) {
     };
 }
 
+exports.SourceMapConsumer = SourceMapConsumer;
+exports.generateCodeFrame = generateCodeFrame;
+exports.generateCodeFrameSourceMapConsumer = generateCodeFrameSourceMapConsumer;
+exports.generateCodeFrameWithKotlinStacktrace = generateCodeFrameWithKotlinStacktrace;
+exports.generateCodeFrameWithSourceMapPath = generateCodeFrameWithSourceMapPath;
+exports.generateCodeFrameWithSwiftStacktrace = generateCodeFrameWithSwiftStacktrace;
 exports.stacktracey = stacktracey;
 exports.uniStracktraceyPreset = uniStracktraceyPreset;
 exports.utsStracktraceyPreset = utsStracktraceyPreset;