build: Add some required modules for node

1 files changed, 309 insertions, 0 deletions

diff --git a/node_modules/source-map-resolve/source-map-resolve.js b/node_modules/source-map-resolve/source-map-resolve.js
new file mode 100644
index 0000000..387fc19
--- /dev/null
+++ b/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
+  }
+
+}));