v6

node_modules/source-map-resolve/.jshintrc

@@ -0,0 +1,46 @@
+{
+  "bitwise": true,
+  "camelcase": true,
+  "curly": false,
+  "eqeqeq": true,
+  "es3": true,
+  "forin": true,
+  "immed": false,
+  "indent": false,
+  "latedef": "nofunc",
+  "newcap": false,
+  "noarg": true,
+  "noempty": true,
+  "nonew": false,
+  "plusplus": false,
+  "quotmark": false,
+  "undef": true,
+  "unused": "vars",
+  "strict": false,
+  "trailing": true,
+  "maxparams": 5,
+  "maxdepth": false,
+  "maxstatements": false,
+  "maxcomplexity": false,
+  "maxlen": 100,
+
+  "asi": true,
+  "expr": true,
+  "globalstrict": true,
+  "smarttabs": true,
+  "sub": true,
+
+  "node": true,
+  "globals": {
+    "describe": false,
+    "it": false,
+    "before": false,
+    "beforeEach": false,
+    "after": false,
+    "afterEach": false,
+    "define": false,
+    "window": false,
+    "atob": true,
+    "JSON": false
+  }
+}

node_modules/source-map-resolve/.travis.yml

@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+  - "node"

node_modules/source-map-resolve/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014, 2015, 2016, 2017 Simon Lydell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

node_modules/source-map-resolve/bower.json

@@ -0,0 +1,30 @@
+{
+  "name": "source-map-resolve",
+  "version": "0.5.2",
+  "author": "Simon Lydell",
+  "license": "MIT",
+  "description": "Resolve the source map and/or sources for a generated file.",
+  "keywords": [
+    "source map",
+    "sourcemap",
+    "source",
+    "map",
+    "sourceMappingURL",
+    "resolve",
+    "resolver",
+    "locate",
+    "locator",
+    "find",
+    "finder"
+  ],
+  "authors": [
+    "Simon Lydell"
+  ],
+  "ignore": [
+    ".*"
+  ],
+  "dependencies": {
+    "source-map-url": "^0.4.0",
+    "resolve-url": "^0.2.1"
+  }
+}

node_modules/source-map-resolve/changelog.md

@@ -0,0 +1,100 @@
+### Version 0.5.2 (2018-05-10) ###
+
+- Improved: Updated the version range of `atob` to disallow depending on `2.0.3`
+  which as a [security
+  vulnerability](https://snyk.io/test/npm/atob/2.0.3?severity=high&severity=medium&severity=low).
+
+### Version 0.5.1 (2017-10-21) ###
+
+- Fixed: URLs are now decoded before being passed to `read` in Node.js. This
+  allows reading files with spaces, for example.
+- Fixed: Missing or empty `sources` fields (such as `sources: []`) in source
+  maps are now handled. Previously, such source maps would cause crashes or
+  callbacks never bing called. Now, an empty result is produced:
+
+  ```js
+  sourcesResolved: [],
+  sourcesContent: []
+  ```
+
+### Version 0.5.0 (2016-02-28) ###
+
+- Improved: Errors now have a `sourceMapData` property that contain as much as
+  possible of the intended result of the function up until the error occurred.
+- Changed: `resolveSources` and `resolve`, as well as their `*Sync`
+  alternatives, no longer fail when one single source fails to be fetched.
+  Instead, the `sourcesContent` array in the result object will contain error
+  objects for all failed sources, and strings otherwise. (Backwards-incompatible
+  change.)
+
+### Version 0.4.0 (2015-08-29) ###
+
+- Removed: The `ignoreSourceRoot` option of `resolveSources`. It has been
+  replaced with `sourceRoot: false`. (Backwards-incompatible change.)
+- Added: The `sourceRoot` option of `resolveSources`. It not only allows to
+  ignore the source root, it also lets you replace it.
+- Added: The `parseMapToJSON` method.
+- Added: The `resolve` method now accepts `null, mapUrl, ...` as arguments, in
+  addition to the existing signature, which will read `mapUrl` instead of
+  looking for a sourceMappingURL in the code.
+
+### Version 0.3.1 (2014-08-16) ###
+
+- Improved: Updated the source-map-url dependency to 0.3.0.
+
+
+### Version 0.3.0 (2014-07-02) ###
+
+- Removed: Argument checking. It’s not worth it. (Possibly
+  backwards-incompatible change.)
+- Added: The `sourceRoot` property of source maps may now be ignored, which can
+  be useful when resolving sources outside of the browser.
+- Added: It is now possible to resolve only the URLs of sources, without
+  reading them.
+
+
+### Version 0.2.0 (2014-06-22) ###
+
+- Changed: The result of `resolveSources` is now an object, not an array. The
+  old result array is available in the `sourcesContent` property.
+  (Backwards-incompatible change.)
+- Changed: `sources` has been renamed to `sourcesContent` in the result object
+  of `resolve`. (Backwards-incompatible change.)
+- Added: `resolveSources` now also returns all sources fully resolved, in the
+  `sourcesResolved` property.
+- Added: The result object of `resolve` now contains the `sourcesResolved`
+  property from `resolveSources`.
+
+
+### Version 0.1.4 (2014-06-16) ###
+
+- Fixed: `sourcesContent` was mis-typed as `sourceContents`, which meant that
+  the `sourcesContent` property of source maps never was used when resolving
+  sources.
+
+
+### Version 0.1.3 (2014-05-06) ###
+
+- Only documentation and meta-data changes.
+
+
+### Version 0.1.2 (2014-03-23) ###
+
+- Improved: Source maps starting with `)]}'` are now parsed correctly. The spec
+  allows source maps to start with that character sequence to prevent XSSI
+  attacks.
+
+
+### Version 0.1.1 (2014-03-06) ###
+
+- Improved: Make sourceRoot resolving more sensible.
+
+  A source root such as `/scripts/subdir` is now treated as `/scripts/subdir/`
+  — that is, as a directory called “subdir”, not a file called “subdir”.
+  Pointing to a file as source root does not makes sense.
+
+
+
+### Version 0.1.0 (2014-03-03) ###
+
+- Initial release.

node_modules/source-map-resolve/component.json

@@ -0,0 +1,29 @@
+{
+  "name": "source-map-resolve",
+  "version": "0.5.2",
+  "author": "Simon Lydell",
+  "license": "MIT",
+  "description": "Resolve the source map and/or sources for a generated file.",
+  "keywords": [
+    "source map",
+    "sourcemap",
+    "source",
+    "map",
+    "sourceMappingURL",
+    "resolve",
+    "resolver",
+    "locate",
+    "locator",
+    "find",
+    "finder"
+  ],
+  "repo": "lydell/source-map-resolve",
+  "main": "source-map-resolve.js",
+  "scripts": [
+    "source-map-resolve.js"
+  ],
+  "dependencies": {
+    "lydell/source-map-url": "~0.4.0",
+    "lydell/resolve-url": "~0.2.1"
+  }
+}

node_modules/source-map-resolve/generate-source-map-resolve.js

@@ -0,0 +1,28 @@
+// Copyright 2014, 2017 Simon Lydell
+// X11 (“MIT”) Licensed. (See LICENSE.)
+
+var fs = require("fs")
+
+var template = fs.readFileSync("source-map-resolve.js.template").toString()
+var nodeCode = fs.readFileSync("lib/source-map-resolve-node.js").toString()
+
+nodeCode = nodeCode
+
+  // Remove leading comments and `require`s.
+  .replace(/^\s*(?:\/\/.+\s+|var\s+\w+\s*=\s*require\([^)]+\).*\s+)*/, "")
+
+  // Remove `urix`.
+  .replace(/(\w+)\s*=\s*urix\(\1\)\s*/g, "")
+
+  // Remove `decode-uri-component`.
+  .replace(/(var readUrl = )decodeUriComponent\(([\w.]+)\)/g, "$1$2")
+
+  // Change `module.exports = {...}` to `return {...}`.
+  .replace(/module\.exports = (\{[^}]+\})\s*$/, "return $1")
+
+  // Indent.
+  .replace(/^(?!$)/gm, "  ")
+
+var code = template.replace(/[ \t]*\{\{source-map-resolve-node.js\}\}/, nodeCode)
+
+fs.writeFileSync("source-map-resolve.js", code)

node_modules/source-map-resolve/lib/decode-uri-component.js

@@ -0,0 +1,11 @@
+// Copyright 2017 Simon Lydell
+// X11 (“MIT”) Licensed. (See LICENSE.)
+
+var decodeUriComponent = require("decode-uri-component")
+
+function customDecodeUriComponent(string) {
+  // `decodeUriComponent` turns `+` into ` `, but that's not wanted.
+  return decodeUriComponent(string.replace(/\+/g, "%2B"))
+}
+
+module.exports = customDecodeUriComponent

node_modules/source-map-resolve/lib/resolve-url.js

@@ -0,0 +1,12 @@
+// Copyright 2014 Simon Lydell
+// X11 (“MIT”) Licensed. (See LICENSE.)
+
+var url = require("url")
+
+function resolveUrl(/* ...urls */) {
+  return Array.prototype.reduce.call(arguments, function(resolved, nextUrl) {
+    return url.resolve(resolved, nextUrl)
+  })
+}
+
+module.exports = resolveUrl

node_modules/source-map-resolve/lib/source-map-resolve-node.js

@@ -0,0 +1,302 @@
+// Copyright 2014, 2015, 2016, 2017 Simon Lydell
+// X11 (“MIT”) Licensed. (See LICENSE.)
+
+var sourceMappingURL   = require("source-map-url")
+var resolveUrl         = require("./resolve-url")
+var decodeUriComponent = require("./decode-uri-component")
+var urix               = require("urix")
+var atob               = require("atob")
+
+
+
+function callbackAsync(callback, error, result) {
+  setImmediate(function() { callback(error, result) })
+}
+
+function parseMapToJSON(string, data) {
+  try {
+    return JSON.parse(string.replace(/^\)\]\}'/, ""))
+  } catch (error) {
+    error.sourceMapData = data
+    throw error
+  }
+}
+
+function readSync(read, url, data) {
+  var readUrl = decodeUriComponent(url)
+  try {
+    return String(read(readUrl))
+  } catch (error) {
+    error.sourceMapData = data
+    throw error
+  }
+}
+
+
+
+function resolveSourceMap(code, codeUrl, read, callback) {
+  var mapData
+  try {
+    mapData = resolveSourceMapHelper(code, codeUrl)
+  } catch (error) {
+    return callbackAsync(callback, error)
+  }
+  if (!mapData || mapData.map) {
+    return callbackAsync(callback, null, mapData)
+  }
+  var readUrl = decodeUriComponent(mapData.url)
+  read(readUrl, function(error, result) {
+    if (error) {
+      error.sourceMapData = mapData
+      return callback(error)
+    }
+    mapData.map = String(result)
+    try {
+      mapData.map = parseMapToJSON(mapData.map, mapData)
+    } catch (error) {
+      return callback(error)
+    }
+    callback(null, mapData)
+  })
+}
+
+function resolveSourceMapSync(code, codeUrl, read) {
+  var mapData = resolveSourceMapHelper(code, codeUrl)
+  if (!mapData || mapData.map) {
+    return mapData
+  }
+  mapData.map = readSync(read, mapData.url, mapData)
+  mapData.map = parseMapToJSON(mapData.map, mapData)
+  return mapData
+}
+
+var dataUriRegex = /^data:([^,;]*)(;[^,;]*)*(?:,(.*))?$/
+var jsonMimeTypeRegex = /^(?:application|text)\/json$/
+
+function resolveSourceMapHelper(code, codeUrl) {
+  codeUrl = urix(codeUrl)
+
+  var url = sourceMappingURL.getFrom(code)
+  if (!url) {
+    return null
+  }
+
+  var dataUri = url.match(dataUriRegex)
+  if (dataUri) {
+    var mimeType = dataUri[1]
+    var lastParameter = dataUri[2] || ""
+    var encoded = dataUri[3] || ""
+    var data = {
+      sourceMappingURL: url,
+      url: null,
+      sourcesRelativeTo: codeUrl,
+      map: encoded
+    }
+    if (!jsonMimeTypeRegex.test(mimeType)) {
+      var error = new Error("Unuseful data uri mime type: " + (mimeType || "text/plain"))
+      error.sourceMapData = data
+      throw error
+    }
+    data.map = parseMapToJSON(
+      lastParameter === ";base64" ? atob(encoded) : decodeURIComponent(encoded),
+      data
+    )
+    return data
+  }
+
+  var mapUrl = resolveUrl(codeUrl, url)
+  return {
+    sourceMappingURL: url,
+    url: mapUrl,
+    sourcesRelativeTo: mapUrl,
+    map: null
+  }
+}
+
+
+
+function resolveSources(map, mapUrl, read, options, callback) {
+  if (typeof options === "function") {
+    callback = options
+    options = {}
+  }
+  var pending = map.sources ? map.sources.length : 0
+  var result = {
+    sourcesResolved: [],
+    sourcesContent:  []
+  }
+
+  if (pending === 0) {
+    callbackAsync(callback, null, result)
+    return
+  }
+
+  var done = function() {
+    pending--
+    if (pending === 0) {
+      callback(null, result)
+    }
+  }
+
+  resolveSourcesHelper(map, mapUrl, options, function(fullUrl, sourceContent, index) {
+    result.sourcesResolved[index] = fullUrl
+    if (typeof sourceContent === "string") {
+      result.sourcesContent[index] = sourceContent
+      callbackAsync(done, null)
+    } else {
+      var readUrl = decodeUriComponent(fullUrl)
+      read(readUrl, function(error, source) {
+        result.sourcesContent[index] = error ? error : String(source)
+        done()
+      })
+    }
+  })
+}
+
+function resolveSourcesSync(map, mapUrl, read, options) {
+  var result = {
+    sourcesResolved: [],
+    sourcesContent:  []
+  }
+
+  if (!map.sources || map.sources.length === 0) {
+    return result
+  }
+
+  resolveSourcesHelper(map, mapUrl, options, function(fullUrl, sourceContent, index) {
+    result.sourcesResolved[index] = fullUrl
+    if (read !== null) {
+      if (typeof sourceContent === "string") {
+        result.sourcesContent[index] = sourceContent
+      } else {
+        var readUrl = decodeUriComponent(fullUrl)
+        try {
+          result.sourcesContent[index] = String(read(readUrl))
+        } catch (error) {
+          result.sourcesContent[index] = error
+        }
+      }
+    }
+  })
+
+  return result
+}
+
+var endingSlash = /\/?$/
+
+function resolveSourcesHelper(map, mapUrl, options, fn) {
+  options = options || {}
+  mapUrl = urix(mapUrl)
+  var fullUrl
+  var sourceContent
+  var sourceRoot
+  for (var index = 0, len = map.sources.length; index < len; index++) {
+    sourceRoot = null
+    if (typeof options.sourceRoot === "string") {
+      sourceRoot = options.sourceRoot
+    } else if (typeof map.sourceRoot === "string" && options.sourceRoot !== false) {
+      sourceRoot = map.sourceRoot
+    }
+    // If the sourceRoot is the empty string, it is equivalent to not setting
+    // the property at all.
+    if (sourceRoot === null || sourceRoot === '') {
+      fullUrl = resolveUrl(mapUrl, map.sources[index])
+    } else {
+      // Make sure that the sourceRoot ends with a slash, so that `/scripts/subdir` becomes
+      // `/scripts/subdir/<source>`, not `/scripts/<source>`. Pointing to a file as source root
+      // does not make sense.
+      fullUrl = resolveUrl(mapUrl, sourceRoot.replace(endingSlash, "/"), map.sources[index])
+    }
+    sourceContent = (map.sourcesContent || [])[index]
+    fn(fullUrl, sourceContent, index)
+  }
+}
+
+
+
+function resolve(code, codeUrl, read, options, callback) {
+  if (typeof options === "function") {
+    callback = options
+    options = {}
+  }
+  if (code === null) {
+    var mapUrl = codeUrl
+    var data = {
+      sourceMappingURL: null,
+      url: mapUrl,
+      sourcesRelativeTo: mapUrl,
+      map: null
+    }
+    var readUrl = decodeUriComponent(mapUrl)
+    read(readUrl, function(error, result) {
+      if (error) {
+        error.sourceMapData = data
+        return callback(error)
+      }
+      data.map = String(result)
+      try {
+        data.map = parseMapToJSON(data.map, data)
+      } catch (error) {
+        return callback(error)
+      }
+      _resolveSources(data)
+    })
+  } else {
+    resolveSourceMap(code, codeUrl, read, function(error, mapData) {
+      if (error) {
+        return callback(error)
+      }
+      if (!mapData) {
+        return callback(null, null)
+      }
+      _resolveSources(mapData)
+    })
+  }
+
+  function _resolveSources(mapData) {
+    resolveSources(mapData.map, mapData.sourcesRelativeTo, read, options, function(error, result) {
+      if (error) {
+        return callback(error)
+      }
+      mapData.sourcesResolved = result.sourcesResolved
+      mapData.sourcesContent  = result.sourcesContent
+      callback(null, mapData)
+    })
+  }
+}
+
+function resolveSync(code, codeUrl, read, options) {
+  var mapData
+  if (code === null) {
+    var mapUrl = codeUrl
+    mapData = {
+      sourceMappingURL: null,
+      url: mapUrl,
+      sourcesRelativeTo: mapUrl,
+      map: null
+    }
+    mapData.map = readSync(read, mapUrl, mapData)
+    mapData.map = parseMapToJSON(mapData.map, mapData)
+  } else {
+    mapData = resolveSourceMapSync(code, codeUrl, read)
+    if (!mapData) {
+      return null
+    }
+  }
+  var result = resolveSourcesSync(mapData.map, mapData.sourcesRelativeTo, read, options)
+  mapData.sourcesResolved = result.sourcesResolved
+  mapData.sourcesContent  = result.sourcesContent
+  return mapData
+}
+
+
+
+module.exports = {
+  resolveSourceMap:     resolveSourceMap,
+  resolveSourceMapSync: resolveSourceMapSync,
+  resolveSources:       resolveSources,
+  resolveSourcesSync:   resolveSourcesSync,
+  resolve:              resolve,
+  resolveSync:          resolveSync,
+  parseMapToJSON:       parseMapToJSON
+}

node_modules/source-map-resolve/node_modules/.bin/atob

@@ -0,0 +1 @@
+../../../atob/bin/atob.js

node_modules/source-map-resolve/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "source-map-resolve",
+  "version": "0.5.2",
+  "author": "Simon Lydell",
+  "license": "MIT",
+  "description": "Resolve the source map and/or sources for a generated file.",
+  "keywords": [
+    "source map",
+    "sourcemap",
+    "source",
+    "map",
+    "sourceMappingURL",
+    "resolve",
+    "resolver",
+    "locate",
+    "locator",
+    "find",
+    "finder"
+  ],
+  "repository": "lydell/source-map-resolve",
+  "main": "lib/source-map-resolve-node.js",
+  "browser": "source-map-resolve.js",
+  "scripts": {
+    "lint": "jshint lib/ test/",
+    "unit": "node test/source-map-resolve.js && node test/windows.js",
+    "test": "npm run lint && npm run unit",
+    "build": "node generate-source-map-resolve.js"
+  },
+  "dependencies": {
+    "atob": "^2.1.1",
+    "decode-uri-component": "^0.2.0",
+    "resolve-url": "^0.2.1",
+    "source-map-url": "^0.4.0",
+    "urix": "^0.1.0"
+  },
+  "devDependencies": {
+    "Base64": "1.0.1",
+    "jshint": "2.9.5",
+    "setimmediate": "1.0.5",
+    "simple-asyncify": "1.0.0",
+    "tape": "4.9.0"
+  }
+}

node_modules/source-map-resolve/readme.md

@@ -0,0 +1,231 @@
+Overview [![Build Status](https://travis-ci.org/lydell/source-map-resolve.svg?branch=master)](https://travis-ci.org/lydell/source-map-resolve)
+========
+
+Resolve the source map and/or sources for a generated file.
+
+```js
+var sourceMapResolve = require("source-map-resolve")
+var sourceMap        = require("source-map")
+
+var code = [
+  "!function(){...}();",
+  "/*# sourceMappingURL=foo.js.map */"
+].join("\n")
+
+sourceMapResolve.resolveSourceMap(code, "/js/foo.js", fs.readFile, function(error, result) {
+  if (error) {
+    return notifyFailure(error)
+  }
+  result
+  // {
+  //   map: {file: "foo.js", mappings: "...", sources: ["/coffee/foo.coffee"], names: []},
+  //   url: "/js/foo.js.map",
+  //   sourcesRelativeTo: "/js/foo.js.map",
+  //   sourceMappingURL: "foo.js.map"
+  // }
+
+  sourceMapResolve.resolveSources(result.map, result.sourcesRelativeTo, fs.readFile, function(error, result) {
+    if (error) {
+      return notifyFailure(error)
+    }
+    result
+    // {
+    //   sourcesResolved: ["/coffee/foo.coffee"],
+    //   sourcesContent: ["<contents of /coffee/foo.coffee>"]
+    // }
+  })
+})
+
+sourceMapResolve.resolve(code, "/js/foo.js", fs.readFile, function(error, result) {
+  if (error) {
+    return notifyFailure(error)
+  }
+  result
+  // {
+  //   map: {file: "foo.js", mappings: "...", sources: ["/coffee/foo.coffee"], names: []},
+  //   url: "/js/foo.js.map",
+  //   sourcesRelativeTo: "/js/foo.js.map",
+  //   sourceMappingURL: "foo.js.map",
+  //   sourcesResolved: ["/coffee/foo.coffee"],
+  //   sourcesContent: ["<contents of /coffee/foo.coffee>"]
+  // }
+  result.map.sourcesContent = result.sourcesContent
+  var map = new sourceMap.sourceMapConsumer(result.map)
+  map.sourceContentFor("/coffee/foo.coffee")
+  // "<contents of /coffee/foo.coffee>"
+})
+```
+
+
+Installation
+============
+
+- `npm install source-map-resolve`
+- `bower install source-map-resolve`
+- `component install lydell/source-map-resolve`
+
+Works with CommonJS, AMD and browser globals, through UMD.
+
+Note: This module requires `setImmediate` and `atob`.
+Use polyfills if needed, such as:
+
+- <https://github.com/NobleJS/setImmediate>
+- <https://github.com/davidchambers/Base64.js>
+
+
+Usage
+=====
+
+### `sourceMapResolve.resolveSourceMap(code, codeUrl, read, callback)` ###
+
+- `code` is a string of code that may or may not contain a sourceMappingURL
+  comment. Such a comment is used to resolve the source map.
+- `codeUrl` is the url to the file containing `code`. If the sourceMappingURL
+  is relative, it is resolved against `codeUrl`.
+- `read(url, callback)` is a function that reads `url` and responds using
+  `callback(error, content)`. In Node.js you might want to use `fs.readFile`,
+  while in the browser you might want to use an asynchronus `XMLHttpRequest`.
+- `callback(error, result)` is a function that is invoked with either an error
+  or `null` and the result.
+
+The result is an object with the following properties:
+
+- `map`: The source map for `code`, as an object (not a string).
+- `url`: The url to the source map. If the source map came from a data uri,
+  this property is `null`, since then there is no url to it.
+- `sourcesRelativeTo`: The url that the sources of the source map are relative
+  to. Since the sources are relative to the source map, and the url to the
+  source map is provided as the `url` property, this property might seem
+  superfluos. However, remember that the `url` property can be `null` if the
+  source map came from a data uri. If so, the sources are relative to the file
+  containing the data uri—`codeUrl`. This property will be identical to the
+  `url` property or `codeUrl`, whichever is appropriate. This way you can
+  conveniently resolve the sources without having to think about where the
+  source map came from.
+- `sourceMappingURL`: The url of the sourceMappingURL comment in `code`.
+
+If `code` contains no sourceMappingURL, the result is `null`.
+
+### `sourceMapResolve.resolveSources(map, mapUrl, read, [options], callback)` ###
+
+- `map` is a source map, as an object (not a string).
+- `mapUrl` is the url to the file containing `map`. Relative sources in the
+  source map, if any, are resolved against `mapUrl`.
+- `read(url, callback)` is a function that reads `url` and responds using
+  `callback(error, content)`. In Node.js you might want to use `fs.readFile`,
+  while in the browser you might want to use an asynchronus `XMLHttpRequest`.
+- `options` is an optional object with any of the following properties:
+  - `sourceRoot`: Override the `sourceRoot` property of the source map, which
+    might only be relevant when resolving sources in the browser. This lets you
+    bypass it when using the module outside of a browser, if needed. Pass a
+    string to replace the `sourceRoot` property with, or `false` to ignore it.
+    Defaults to `undefined`.
+- `callback(error, result)` is a function that is invoked with either an error
+  or `null` and the result.
+
+The result is an object with the following properties:
+
+- `sourcesResolved`: The same as `map.sources`, except all the sources are
+  fully resolved.
+- `sourcesContent`: An array with the contents of all sources in `map.sources`,
+  in the same order as `map.sources`. If getting the contents of a source fails,
+  an error object is put into the array instead.
+
+### `sourceMapResolve.resolve(code, codeUrl, read, [options], callback)` ###
+
+The arguments are identical to `sourceMapResolve.resolveSourceMap`, except that
+you may also provide the same `options` as in `sourceMapResolve.resolveSources`.
+
+This is a convenience method that first resolves the source map and then its
+sources. You could also do this by first calling
+`sourceMapResolve.resolveSourceMap` and then `sourceMapResolve.resolveSources`.
+
+The result is identical to `sourceMapResolve.resolveSourceMap`, with the
+properties from `sourceMapResolve.resolveSources` merged into it.
+
+There is one extra feature available, though. If `code` is `null`, `codeUrl` is
+treated as a url to the source map instead of to `code`, and will be read. This
+is handy if you _sometimes_ get the source map url from the `SourceMap: <url>`
+header (see the [Notes] section). In this case, the `sourceMappingURL` property
+of the result is `null`.
+
+
+[Notes]: #notes
+
+### `sourceMapResolve.*Sync()` ###
+
+There are also sync versions of the three previous functions. They are identical
+to the async versions, except:
+
+- They expect a sync reading function. In Node.js you might want to use
+  `fs.readFileSync`, while in the browser you might want to use a synchronus
+  `XMLHttpRequest`.
+- They throw errors and return the result instead of using a callback.
+
+`sourceMapResolve.resolveSourcesSync` also accepts `null` as the `read`
+parameter. The result is the same as when passing a function as the `read
+parameter`, except that the `sourcesContent` property of the result will be an
+empty array. In other words, the sources aren’t read. You only get the
+`sourcesResolved` property. (This only supported in the synchronus version, since
+there is no point doing it asynchronusly.)
+
+### `sourceMapResolve.parseMapToJSON(string, [data])` ###
+
+The spec says that if a source map (as a string) starts with `)]}'`, it should
+be stripped off. This is to prevent XSSI attacks. This function does that and
+returns the result of `JSON.parse`ing what’s left.
+
+If this function throws `error`, `error.sourceMapData === data`.
+
+### Errors
+
+All errors passed to callbacks or thrown by this module have a `sourceMapData`
+property that contain as much as possible of the intended result of the function
+up until the error occurred.
+
+Note that while the `map` property of result objects always is an object,
+`error.sourceMapData.map` will be a string if parsing that string fails.
+
+
+Note
+====
+
+This module resolves the source map for a given generated file by looking for a
+sourceMappingURL comment. The spec defines yet a way to provide the URL to the
+source map: By sending the `SourceMap: <url>` header along with the generated
+file. Since this module doesn’t retrive the generated code for you (instead
+_you_ give the generated code to the module), it’s up to you to look for such a
+header when you retrieve the file (should the need arise).
+
+
+Development
+===========
+
+Tests
+-----
+
+First off, run `npm install` to install testing modules and browser polyfills.
+
+`npm test` lints the code and runs the test suite in Node.js.
+
+x-package.json5
+---------------
+
+package.json, component.json and bower.json are all generated from
+x-package.json5 by using [`xpkg`]. Only edit x-package.json5, and remember to
+run `xpkg` before commiting!
+
+[`xpkg`]: https://github.com/kof/node-xpkg
+
+Generating the browser version
+------------------------------
+
+source-map-resolve.js is generated from source-map-resolve-node.js and
+source-map-resolve-template.js. Only edit the two latter files, _not_
+source-map-resolve.js! To generate it, run `npm run build`.
+
+
+License
+=======
+
+[The X11 (“MIT”) License](LICENSE).

node_modules/source-map-resolve/source-map-resolve.js

@@ -0,0 +1,309 @@
+// Copyright 2014, 2015, 2016, 2017 Simon Lydell
+// X11 (“MIT”) Licensed. (See LICENSE.)
+
+// Note: source-map-resolve.js is generated from source-map-resolve-node.js and
+// source-map-resolve-template.js. Only edit the two latter files, _not_
+// source-map-resolve.js!
+
+void (function(root, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["source-map-url", "resolve-url"], factory)
+  } else if (typeof exports === "object") {
+    var sourceMappingURL = require("source-map-url")
+    var resolveUrl = require("resolve-url")
+    module.exports = factory(sourceMappingURL, resolveUrl)
+  } else {
+    root.sourceMapResolve = factory(root.sourceMappingURL, root.resolveUrl)
+  }
+}(this, function(sourceMappingURL, resolveUrl) {
+
+  function callbackAsync(callback, error, result) {
+    setImmediate(function() { callback(error, result) })
+  }
+
+  function parseMapToJSON(string, data) {
+    try {
+      return JSON.parse(string.replace(/^\)\]\}'/, ""))
+    } catch (error) {
+      error.sourceMapData = data
+      throw error
+    }
+  }
+
+  function readSync(read, url, data) {
+    var readUrl = url
+    try {
+      return String(read(readUrl))
+    } catch (error) {
+      error.sourceMapData = data
+      throw error
+    }
+  }
+
+
+
+  function resolveSourceMap(code, codeUrl, read, callback) {
+    var mapData
+    try {
+      mapData = resolveSourceMapHelper(code, codeUrl)
+    } catch (error) {
+      return callbackAsync(callback, error)
+    }
+    if (!mapData || mapData.map) {
+      return callbackAsync(callback, null, mapData)
+    }
+    var readUrl = mapData.url
+    read(readUrl, function(error, result) {
+      if (error) {
+        error.sourceMapData = mapData
+        return callback(error)
+      }
+      mapData.map = String(result)
+      try {
+        mapData.map = parseMapToJSON(mapData.map, mapData)
+      } catch (error) {
+        return callback(error)
+      }
+      callback(null, mapData)
+    })
+  }
+
+  function resolveSourceMapSync(code, codeUrl, read) {
+    var mapData = resolveSourceMapHelper(code, codeUrl)
+    if (!mapData || mapData.map) {
+      return mapData
+    }
+    mapData.map = readSync(read, mapData.url, mapData)
+    mapData.map = parseMapToJSON(mapData.map, mapData)
+    return mapData
+  }
+
+  var dataUriRegex = /^data:([^,;]*)(;[^,;]*)*(?:,(.*))?$/
+  var jsonMimeTypeRegex = /^(?:application|text)\/json$/
+
+  function resolveSourceMapHelper(code, codeUrl) {
+    var url = sourceMappingURL.getFrom(code)
+    if (!url) {
+      return null
+    }
+
+    var dataUri = url.match(dataUriRegex)
+    if (dataUri) {
+      var mimeType = dataUri[1]
+      var lastParameter = dataUri[2] || ""
+      var encoded = dataUri[3] || ""
+      var data = {
+        sourceMappingURL: url,
+        url: null,
+        sourcesRelativeTo: codeUrl,
+        map: encoded
+      }
+      if (!jsonMimeTypeRegex.test(mimeType)) {
+        var error = new Error("Unuseful data uri mime type: " + (mimeType || "text/plain"))
+        error.sourceMapData = data
+        throw error
+      }
+      data.map = parseMapToJSON(
+        lastParameter === ";base64" ? atob(encoded) : decodeURIComponent(encoded),
+        data
+      )
+      return data
+    }
+
+    var mapUrl = resolveUrl(codeUrl, url)
+    return {
+      sourceMappingURL: url,
+      url: mapUrl,
+      sourcesRelativeTo: mapUrl,
+      map: null
+    }
+  }
+
+
+
+  function resolveSources(map, mapUrl, read, options, callback) {
+    if (typeof options === "function") {
+      callback = options
+      options = {}
+    }
+    var pending = map.sources ? map.sources.length : 0
+    var result = {
+      sourcesResolved: [],
+      sourcesContent:  []
+    }
+
+    if (pending === 0) {
+      callbackAsync(callback, null, result)
+      return
+    }
+
+    var done = function() {
+      pending--
+      if (pending === 0) {
+        callback(null, result)
+      }
+    }
+
+    resolveSourcesHelper(map, mapUrl, options, function(fullUrl, sourceContent, index) {
+      result.sourcesResolved[index] = fullUrl
+      if (typeof sourceContent === "string") {
+        result.sourcesContent[index] = sourceContent
+        callbackAsync(done, null)
+      } else {
+        var readUrl = fullUrl
+        read(readUrl, function(error, source) {
+          result.sourcesContent[index] = error ? error : String(source)
+          done()
+        })
+      }
+    })
+  }
+
+  function resolveSourcesSync(map, mapUrl, read, options) {
+    var result = {
+      sourcesResolved: [],
+      sourcesContent:  []
+    }
+
+    if (!map.sources || map.sources.length === 0) {
+      return result
+    }
+
+    resolveSourcesHelper(map, mapUrl, options, function(fullUrl, sourceContent, index) {
+      result.sourcesResolved[index] = fullUrl
+      if (read !== null) {
+        if (typeof sourceContent === "string") {
+          result.sourcesContent[index] = sourceContent
+        } else {
+          var readUrl = fullUrl
+          try {
+            result.sourcesContent[index] = String(read(readUrl))
+          } catch (error) {
+            result.sourcesContent[index] = error
+          }
+        }
+      }
+    })
+
+    return result
+  }
+
+  var endingSlash = /\/?$/
+
+  function resolveSourcesHelper(map, mapUrl, options, fn) {
+    options = options || {}
+    var fullUrl
+    var sourceContent
+    var sourceRoot
+    for (var index = 0, len = map.sources.length; index < len; index++) {
+      sourceRoot = null
+      if (typeof options.sourceRoot === "string") {
+        sourceRoot = options.sourceRoot
+      } else if (typeof map.sourceRoot === "string" && options.sourceRoot !== false) {
+        sourceRoot = map.sourceRoot
+      }
+      // If the sourceRoot is the empty string, it is equivalent to not setting
+      // the property at all.
+      if (sourceRoot === null || sourceRoot === '') {
+        fullUrl = resolveUrl(mapUrl, map.sources[index])
+      } else {
+        // Make sure that the sourceRoot ends with a slash, so that `/scripts/subdir` becomes
+        // `/scripts/subdir/<source>`, not `/scripts/<source>`. Pointing to a file as source root
+        // does not make sense.
+        fullUrl = resolveUrl(mapUrl, sourceRoot.replace(endingSlash, "/"), map.sources[index])
+      }
+      sourceContent = (map.sourcesContent || [])[index]
+      fn(fullUrl, sourceContent, index)
+    }
+  }
+
+
+
+  function resolve(code, codeUrl, read, options, callback) {
+    if (typeof options === "function") {
+      callback = options
+      options = {}
+    }
+    if (code === null) {
+      var mapUrl = codeUrl
+      var data = {
+        sourceMappingURL: null,
+        url: mapUrl,
+        sourcesRelativeTo: mapUrl,
+        map: null
+      }
+      var readUrl = mapUrl
+      read(readUrl, function(error, result) {
+        if (error) {
+          error.sourceMapData = data
+          return callback(error)
+        }
+        data.map = String(result)
+        try {
+          data.map = parseMapToJSON(data.map, data)
+        } catch (error) {
+          return callback(error)
+        }
+        _resolveSources(data)
+      })
+    } else {
+      resolveSourceMap(code, codeUrl, read, function(error, mapData) {
+        if (error) {
+          return callback(error)
+        }
+        if (!mapData) {
+          return callback(null, null)
+        }
+        _resolveSources(mapData)
+      })
+    }
+
+    function _resolveSources(mapData) {
+      resolveSources(mapData.map, mapData.sourcesRelativeTo, read, options, function(error, result) {
+        if (error) {
+          return callback(error)
+        }
+        mapData.sourcesResolved = result.sourcesResolved
+        mapData.sourcesContent  = result.sourcesContent
+        callback(null, mapData)
+      })
+    }
+  }
+
+  function resolveSync(code, codeUrl, read, options) {
+    var mapData
+    if (code === null) {
+      var mapUrl = codeUrl
+      mapData = {
+        sourceMappingURL: null,
+        url: mapUrl,
+        sourcesRelativeTo: mapUrl,
+        map: null
+      }
+      mapData.map = readSync(read, mapUrl, mapData)
+      mapData.map = parseMapToJSON(mapData.map, mapData)
+    } else {
+      mapData = resolveSourceMapSync(code, codeUrl, read)
+      if (!mapData) {
+        return null
+      }
+    }
+    var result = resolveSourcesSync(mapData.map, mapData.sourcesRelativeTo, read, options)
+    mapData.sourcesResolved = result.sourcesResolved
+    mapData.sourcesContent  = result.sourcesContent
+    return mapData
+  }
+
+
+
+  return {
+    resolveSourceMap:     resolveSourceMap,
+    resolveSourceMapSync: resolveSourceMapSync,
+    resolveSources:       resolveSources,
+    resolveSourcesSync:   resolveSourcesSync,
+    resolve:              resolve,
+    resolveSync:          resolveSync,
+    parseMapToJSON:       parseMapToJSON
+  }
+
+}));

node_modules/source-map-resolve/source-map-resolve.js.template

@@ -0,0 +1,22 @@
+// Copyright 2014, 2015, 2016, 2017 Simon Lydell
+// X11 (“MIT”) Licensed. (See LICENSE.)
+
+// Note: source-map-resolve.js is generated from source-map-resolve-node.js and
+// source-map-resolve-template.js. Only edit the two latter files, _not_
+// source-map-resolve.js!
+
+void (function(root, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["source-map-url", "resolve-url"], factory)
+  } else if (typeof exports === "object") {
+    var sourceMappingURL = require("source-map-url")
+    var resolveUrl = require("resolve-url")
+    module.exports = factory(sourceMappingURL, resolveUrl)
+  } else {
+    root.sourceMapResolve = factory(root.sourceMappingURL, root.resolveUrl)
+  }
+}(this, function(sourceMappingURL, resolveUrl) {
+
+  {{source-map-resolve-node.js}}
+
+}));

node_modules/source-map-resolve/test/common.js

@@ -0,0 +1,27 @@
+// Copyright 2014 Simon Lydell
+// X11 (“MIT”) Licensed. (See LICENSE.)
+
+function u(url) {
+  return "code\n/*# sourceMappingURL=" + url + " */"
+}
+
+function read(x) {
+  return function() {
+    return x
+  }
+}
+
+function Throws(x) {
+  throw new Error(x)
+}
+
+function identity(x) {
+  return x
+}
+
+module.exports = {
+  u:        u,
+  read:     read,
+  Throws:   Throws,
+  identity: identity
+}

node_modules/source-map-resolve/test/read.js

@@ -0,0 +1,105 @@
+// Copyright 2017 Simon Lydell
+// X11 (“MIT”) Licensed. (See LICENSE.)
+
+var test         = require("tape")
+var asyncify     = require("simple-asyncify")
+var common       = require("./common")
+var u            = common.u
+
+var sourceMapResolve = require("../")
+
+var mapUrl = "operators%20map.json"
+var codeUrl = "./built files/operators:+-<>%25.js"
+var sourceUrl = "../source files/operators:+-<>%25.coffee"
+
+function readTest(t, files) {
+  return function(file, callback) {
+    var fileData = files[file]
+    t.ok(fileData, "decoded file name")
+    if (callback) {
+      callback(null, fileData)
+    } else {
+      return fileData
+    }
+  }
+}
+
+
+
+function testResolveSourceMap(method, sync) {
+  return function(t) {
+    t.plan(2)
+
+    if (sync) {
+      method = asyncify(method)
+    }
+
+    var read = readTest(t, {
+      "built files/operators map.json": "{}"
+    })
+
+    method(u(mapUrl), codeUrl, read, function(error) {
+      t.error(error)
+    })
+
+  }
+}
+
+test(".resolveSourceMap",     testResolveSourceMap(sourceMapResolve.resolveSourceMap,    false))
+
+test(".resolveSourceMapSync", testResolveSourceMap(sourceMapResolve.resolveSourceMapSync, true))
+
+
+function testResolveSources(method, sync) {
+  return function(t) {
+    t.plan(2)
+
+    if (sync) {
+      method = asyncify(method)
+    }
+
+    var map = {
+      sources: [sourceUrl]
+    }
+    var read = readTest(t, {
+      "../source files/operators:+-<>%.coffee": "source code"
+    })
+
+    method(map, mapUrl, read, function(error) {
+      t.error(error)
+    })
+
+  }
+}
+
+test(".resolveSources",     testResolveSources(sourceMapResolve.resolveSources,    false))
+
+test(".resolveSourcesSync", testResolveSources(sourceMapResolve.resolveSourcesSync, true))
+
+
+function testResolve(method, sync) {
+  return function(t) {
+    t.plan(3)
+
+    if (sync) {
+      method = asyncify(method)
+    }
+
+    var map = {
+      sources: [sourceUrl]
+    }
+    var read = readTest(t, {
+      "built files/operators map.json": JSON.stringify(map),
+      "source files/operators:+-<>%.coffee": "source code"
+    })
+
+    method(u(mapUrl), codeUrl, read, function(error) {
+      t.error(error)
+    })
+
+  }
+}
+
+test(".resolve",     testResolve(sourceMapResolve.resolve,    false))
+
+test(".resolveSync", testResolve(sourceMapResolve.resolveSync, true))

node_modules/source-map-resolve/test/windows.js

@@ -0,0 +1,166 @@
+// Copyright 2014 Simon Lydell
+// X11 (“MIT”) Licensed. (See LICENSE.)
+
+var path         = require("path")
+var test         = require("tape")
+var asyncify     = require("simple-asyncify")
+var common       = require("./common")
+var u            = common.u
+var read         = common.read
+var identity     = common.identity
+
+var sourceMapResolve = require("../")
+
+path.sep = "\\"
+
+
+function testResolveSourceMap(method, sync) {
+  return function(t) {
+    var wrap = (sync ? identity : asyncify)
+
+    var codeUrl = "c:\\a\\b\\c\\foo.js"
+
+    t.plan(3 * 2)
+
+    if (sync) {
+      method = asyncify(method)
+    }
+
+    var map = {}
+    var readMap = wrap(read(JSON.stringify(map)))
+
+    method(u("foo.js.map"), codeUrl, readMap, function(error, result) {
+      t.error(error)
+      t.deepEqual(result, {
+        sourceMappingURL:  "foo.js.map",
+        url:               "/a/b/c/foo.js.map",
+        sourcesRelativeTo: "/a/b/c/foo.js.map",
+        map:               map
+      })
+    })
+
+    method(u("/foo.js.map"), codeUrl, readMap, function(error, result) {
+      t.error(error)
+      t.deepEqual(result, {
+        sourceMappingURL:  "/foo.js.map",
+        url:               "/foo.js.map",
+        sourcesRelativeTo: "/foo.js.map",
+        map:               map
+      })
+    })
+
+    method(u("../foo.js.map"), codeUrl, readMap, function(error, result) {
+      t.error(error)
+      t.deepEqual(result, {
+        sourceMappingURL:  "../foo.js.map",
+        url:               "/a/b/foo.js.map",
+        sourcesRelativeTo: "/a/b/foo.js.map",
+        map:               map
+      })
+    })
+
+  }
+}
+
+test(".resolveSourceMap",     testResolveSourceMap(sourceMapResolve.resolveSourceMap,    false))
+
+test(".resolveSourceMapSync", testResolveSourceMap(sourceMapResolve.resolveSourceMapSync, true))
+
+
+function testResolveSources(method, sync) {
+  return function(t) {
+    var wrap = (sync ? identity : asyncify)
+
+    var mapUrl = "c:\\a\\b\\c\\foo.js.map"
+
+    t.plan(1 * 3)
+
+    if (sync) {
+      method = asyncify(method)
+    }
+
+    var map = {
+      sources: ["foo.js", "/foo.js", "../foo.js"]
+    }
+
+    method(map, mapUrl, wrap(identity), function(error, result) {
+      t.error(error)
+      t.deepEqual(result.sourcesResolved, ["/a/b/c/foo.js", "/foo.js", "/a/b/foo.js"])
+      t.deepEqual(result.sourcesContent,  ["/a/b/c/foo.js", "/foo.js", "/a/b/foo.js"])
+    })
+
+  }
+}
+
+test(".resolveSources",     testResolveSources(sourceMapResolve.resolveSources,    false))
+
+test(".resolveSourcesSync", testResolveSources(sourceMapResolve.resolveSourcesSync, true))
+
+
+function testResolve(method, sync) {
+  return function(t) {
+    var wrap = (sync ? identity : asyncify)
+    var wrapMap = function(mapFn, fn) {
+      return wrap(function(url) {
+        if (/\.map$/.test(url)) {
+          return mapFn(url)
+        }
+        return fn(url)
+      })
+    }
+
+    var codeUrl = "c:\\a\\b\\c\\foo.js"
+
+    t.plan(3 * 2)
+
+    if (sync) {
+      method = asyncify(method)
+    }
+
+    var map = {
+      sources: ["foo.js", "/foo.js", "../foo.js"]
+    }
+    var readMap = wrapMap(read(JSON.stringify(map)), identity)
+
+    method(u("foo.js.map"), codeUrl, readMap, function(error, result) {
+      t.error(error)
+      t.deepEqual(result, {
+        sourceMappingURL:  "foo.js.map",
+        url:               "/a/b/c/foo.js.map",
+        sourcesRelativeTo: "/a/b/c/foo.js.map",
+        map:               map,
+        sourcesResolved:   ["/a/b/c/foo.js", "/foo.js", "/a/b/foo.js"],
+        sourcesContent:    ["/a/b/c/foo.js", "/foo.js", "/a/b/foo.js"]
+      })
+    })
+
+    method(u("/foo.js.map"), codeUrl, readMap, function(error, result) {
+      t.error(error)
+      t.deepEqual(result, {
+        sourceMappingURL:  "/foo.js.map",
+        url:               "/foo.js.map",
+        sourcesRelativeTo: "/foo.js.map",
+        map:               map,
+        sourcesResolved:   ["/foo.js", "/foo.js", "/foo.js"],
+        sourcesContent:    ["/foo.js", "/foo.js", "/foo.js"]
+      })
+    })
+
+    method(u("../foo.js.map"), codeUrl, readMap, function(error, result) {
+      t.error(error)
+      t.deepEqual(result, {
+        sourceMappingURL:  "../foo.js.map",
+        url:               "/a/b/foo.js.map",
+        sourcesRelativeTo: "/a/b/foo.js.map",
+        map:               map,
+        sourcesResolved:   ["/a/b/foo.js", "/foo.js", "/a/foo.js"],
+        sourcesContent:    ["/a/b/foo.js", "/foo.js", "/a/foo.js"]
+      })
+    })
+
+  }
+}
+
+test(".resolve",     testResolve(sourceMapResolve.resolve,    false))
+
+test(".resolveSync", testResolve(sourceMapResolve.resolveSync, true))

node_modules/source-map-resolve/x-package.json5

@@ -0,0 +1,68 @@
+{
+  name: "source-map-resolve",
+  version: "0.5.2",
+  author: "Simon Lydell",
+  license: "MIT",
+  description: "Resolve the source map and/or sources for a generated file.",
+  keywords: [
+    "source map",
+    "sourcemap",
+    "source",
+    "map",
+    "sourceMappingURL",
+    "resolve",
+    "resolver",
+    "locate",
+    "locator",
+    "find",
+    "finder"
+  ],
+  overlay: {
+    npm: {
+      repository: "lydell/source-map-resolve",
+      main: "lib/source-map-resolve-node.js",
+      browser: "source-map-resolve.js",
+      scripts: {
+        lint: "jshint lib/ test/",
+        unit: "node test/source-map-resolve.js && node test/windows.js",
+        test: "npm run lint && npm run unit",
+        build: "node generate-source-map-resolve.js"
+      },
+      dependencies: {
+        "atob": "^2.1.1",
+        "decode-uri-component": "^0.2.0",
+        "resolve-url": "^0.2.1",
+        "source-map-url": "^0.4.0",
+        "urix": "^0.1.0"
+      },
+      devDependencies: {
+        "Base64": "1.0.1",
+        "jshint": "2.9.5",
+        "setimmediate": "1.0.5",
+        "simple-asyncify": "1.0.0",
+        "tape": "4.9.0"
+      }
+    },
+    component: {
+      repo: "lydell/source-map-resolve",
+      main: "source-map-resolve.js",
+      scripts: [
+        "source-map-resolve.js"
+      ],
+      dependencies: {
+        "lydell/source-map-url": "~0.4.0",
+        "lydell/resolve-url": "~0.2.1"
+      }
+    },
+    bower: {
+      authors: ["Simon Lydell"],
+      ignore: [
+        ".*"
+      ],
+      dependencies: {
+        "source-map-url": "^0.4.0",
+        "resolve-url": "^0.2.1"
+      }
+    }
+  }
+}