eoapi-cdk 5.4.1 → 6.0.1

package/node_modules/source-map-resolve/changelog.md

@@ -0,0 +1,108 @@
+### Version 0.5.3 (2019-12-28) ###
+
+- Fixed: base64 encoded source maps now correctly decodes as utf-8. Previously,
+  non-ASCII characters could end up garbled. Thanks to ZHAO Jinxiang
+  (@xiaoxiangmoe)! (Note: This fix does not work in old evironments not
+  supporting both `TextDecoder` and `Uint8Array`.)
+- Improved: Reduced size of the npm package.
+
+### 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.

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

@@ -0,0 +1,8 @@
+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

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

@@ -0,0 +1,9 @@
+var url = require("url")
+
+function resolveUrl(/* ...urls */) {
+  return Array.prototype.reduce.call(arguments, function(resolved, nextUrl) {
+    return url.resolve(resolved, nextUrl)
+  })
+}
+
+module.exports = resolveUrl

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

@@ -0,0 +1,342 @@
+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:([^,;]*)(;[^,;]*)*(?:,(.*))?$/
+
+/**
+ * The media type for JSON text is application/json.
+ *
+ * {@link https://tools.ietf.org/html/rfc8259#section-11 | IANA Considerations }
+ *
+ * `text/json` is non-standard media type
+ */
+var jsonMimeTypeRegex = /^(?:application|text)\/json$/
+
+/**
+ * JSON text exchanged between systems that are not part of a closed ecosystem
+ * MUST be encoded using UTF-8.
+ *
+ * {@link https://tools.ietf.org/html/rfc8259#section-8.1 | Character Encoding}
+ */
+var jsonCharacterEncoding = "utf-8"
+
+function base64ToBuf(b64) {
+  var binStr = atob(b64)
+  var len = binStr.length
+  var arr = new Uint8Array(len)
+  for (var i = 0; i < len; i++) {
+    arr[i] = binStr.charCodeAt(i)
+  }
+  return arr
+}
+
+function decodeBase64String(b64) {
+  if (typeof TextDecoder === "undefined" || typeof Uint8Array === "undefined") {
+    return atob(b64)
+  }
+  var buf = base64ToBuf(b64);
+  // Note: `decoder.decode` method will throw a `DOMException` with the
+  // `"EncodingError"` value when an coding error is found.
+  var decoder = new TextDecoder(jsonCharacterEncoding, {fatal: true})
+  return decoder.decode(buf);
+}
+
+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] || "text/plain"
+    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)
+      error.sourceMapData = data
+      throw error
+    }
+    try {
+      data.map = parseMapToJSON(
+        lastParameter === ";base64" ? decodeBase64String(encoded) : decodeURIComponent(encoded),
+        data
+      )
+    } catch (error) {
+      error.sourceMapData = data
+      throw error
+    }
+    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
+}

package/node_modules/source-map-resolve/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "source-map-resolve",
+  "version": "0.5.3",
+  "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",
+  "files": [
+    "lib",
+    "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.2",
+    "decode-uri-component": "^0.2.0",
+    "resolve-url": "^0.2.1",
+    "source-map-url": "^0.4.0",
+    "urix": "^0.1.0"
+  },
+  "devDependencies": {
+    "Base64": "1.1.0",
+    "jshint": "2.10.3",
+    "setimmediate": "1.0.5",
+    "simple-asyncify": "1.0.0",
+    "tape": "4.12.1"
+  }
+}