From 3c51c3be85bb0d1bdb87ea0d6632f1c256912f27 Mon Sep 17 00:00:00 2001 From: Dimitri Staessens Date: Sun, 6 Oct 2019 21:37:45 +0200 Subject: build: Add some required modules for node --- node_modules/source-map-resolve/.jshintrc | 46 + node_modules/source-map-resolve/.travis.yml | 3 + node_modules/source-map-resolve/LICENSE | 21 + node_modules/source-map-resolve/bower.json | 30 + node_modules/source-map-resolve/changelog.md | 100 ++ node_modules/source-map-resolve/component.json | 29 + .../generate-source-map-resolve.js | 28 + .../source-map-resolve/lib/decode-uri-component.js | 11 + node_modules/source-map-resolve/lib/resolve-url.js | 12 + .../lib/source-map-resolve-node.js | 302 +++++ node_modules/source-map-resolve/package.json | 81 ++ node_modules/source-map-resolve/readme.md | 231 ++++ .../source-map-resolve/source-map-resolve.js | 309 ++++++ .../source-map-resolve.js.template | 22 + node_modules/source-map-resolve/test/common.js | 27 + node_modules/source-map-resolve/test/read.js | 105 ++ .../source-map-resolve/test/source-map-resolve.js | 1162 ++++++++++++++++++++ node_modules/source-map-resolve/test/windows.js | 166 +++ node_modules/source-map-resolve/x-package.json5 | 68 ++ 19 files changed, 2753 insertions(+) create mode 100644 node_modules/source-map-resolve/.jshintrc create mode 100644 node_modules/source-map-resolve/.travis.yml create mode 100644 node_modules/source-map-resolve/LICENSE create mode 100644 node_modules/source-map-resolve/bower.json create mode 100644 node_modules/source-map-resolve/changelog.md create mode 100644 node_modules/source-map-resolve/component.json create mode 100644 node_modules/source-map-resolve/generate-source-map-resolve.js create mode 100644 node_modules/source-map-resolve/lib/decode-uri-component.js create mode 100644 node_modules/source-map-resolve/lib/resolve-url.js create mode 100644 node_modules/source-map-resolve/lib/source-map-resolve-node.js create mode 100644 node_modules/source-map-resolve/package.json create mode 100644 node_modules/source-map-resolve/readme.md create mode 100644 node_modules/source-map-resolve/source-map-resolve.js create mode 100644 node_modules/source-map-resolve/source-map-resolve.js.template create mode 100644 node_modules/source-map-resolve/test/common.js create mode 100644 node_modules/source-map-resolve/test/read.js create mode 100644 node_modules/source-map-resolve/test/source-map-resolve.js create mode 100644 node_modules/source-map-resolve/test/windows.js create mode 100644 node_modules/source-map-resolve/x-package.json5 (limited to 'node_modules/source-map-resolve') diff --git a/node_modules/source-map-resolve/.jshintrc b/node_modules/source-map-resolve/.jshintrc new file mode 100644 index 0000000..4a29289 --- /dev/null +++ b/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 + } +} diff --git a/node_modules/source-map-resolve/.travis.yml b/node_modules/source-map-resolve/.travis.yml new file mode 100644 index 0000000..2197832 --- /dev/null +++ b/node_modules/source-map-resolve/.travis.yml @@ -0,0 +1,3 @@ +language: node_js +node_js: + - "node" diff --git a/node_modules/source-map-resolve/LICENSE b/node_modules/source-map-resolve/LICENSE new file mode 100644 index 0000000..748f42e --- /dev/null +++ b/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. diff --git a/node_modules/source-map-resolve/bower.json b/node_modules/source-map-resolve/bower.json new file mode 100644 index 0000000..e95acf3 --- /dev/null +++ b/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" + } +} \ No newline at end of file diff --git a/node_modules/source-map-resolve/changelog.md b/node_modules/source-map-resolve/changelog.md new file mode 100644 index 0000000..b35771b --- /dev/null +++ b/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. diff --git a/node_modules/source-map-resolve/component.json b/node_modules/source-map-resolve/component.json new file mode 100644 index 0000000..7af17d4 --- /dev/null +++ b/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" + } +} \ No newline at end of file diff --git a/node_modules/source-map-resolve/generate-source-map-resolve.js b/node_modules/source-map-resolve/generate-source-map-resolve.js new file mode 100644 index 0000000..a37e393 --- /dev/null +++ b/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) diff --git a/node_modules/source-map-resolve/lib/decode-uri-component.js b/node_modules/source-map-resolve/lib/decode-uri-component.js new file mode 100644 index 0000000..c7064ff --- /dev/null +++ b/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 diff --git a/node_modules/source-map-resolve/lib/resolve-url.js b/node_modules/source-map-resolve/lib/resolve-url.js new file mode 100644 index 0000000..2ca8fa9 --- /dev/null +++ b/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 diff --git a/node_modules/source-map-resolve/lib/source-map-resolve-node.js b/node_modules/source-map-resolve/lib/source-map-resolve-node.js new file mode 100644 index 0000000..f80953d --- /dev/null +++ b/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/`, not `/scripts/`. 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 +} diff --git a/node_modules/source-map-resolve/package.json b/node_modules/source-map-resolve/package.json new file mode 100644 index 0000000..6f49eff --- /dev/null +++ b/node_modules/source-map-resolve/package.json @@ -0,0 +1,81 @@ +{ + "_args": [ + [ + "source-map-resolve@0.5.2", + "/home/dstaesse/git/website" + ] + ], + "_development": true, + "_from": "source-map-resolve@0.5.2", + "_id": "source-map-resolve@0.5.2", + "_inBundle": false, + "_integrity": "sha512-MjqsvNwyz1s0k81Goz/9vRBe9SZdB09Bdw+/zYyO+3CuPk6fouTaxscHkgtE8jKvf01kVfl8riHzERQ/kefaSA==", + "_location": "/source-map-resolve", + "_phantomChildren": {}, + "_requested": { + "type": "version", + "registry": true, + "raw": "source-map-resolve@0.5.2", + "name": "source-map-resolve", + "escapedName": "source-map-resolve", + "rawSpec": "0.5.2", + "saveSpec": null, + "fetchSpec": "0.5.2" + }, + "_requiredBy": [ + "/snapdragon" + ], + "_resolved": "https://registry.npmjs.org/source-map-resolve/-/source-map-resolve-0.5.2.tgz", + "_spec": "0.5.2", + "_where": "/home/dstaesse/git/website", + "author": { + "name": "Simon Lydell" + }, + "browser": "source-map-resolve.js", + "bugs": { + "url": "https://github.com/lydell/source-map-resolve/issues" + }, + "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" + }, + "description": "Resolve the source map and/or sources for a generated file.", + "devDependencies": { + "Base64": "1.0.1", + "jshint": "2.9.5", + "setimmediate": "1.0.5", + "simple-asyncify": "1.0.0", + "tape": "4.9.0" + }, + "homepage": "https://github.com/lydell/source-map-resolve#readme", + "keywords": [ + "source map", + "sourcemap", + "source", + "map", + "sourceMappingURL", + "resolve", + "resolver", + "locate", + "locator", + "find", + "finder" + ], + "license": "MIT", + "main": "lib/source-map-resolve-node.js", + "name": "source-map-resolve", + "repository": { + "type": "git", + "url": "git+https://github.com/lydell/source-map-resolve.git" + }, + "scripts": { + "build": "node generate-source-map-resolve.js", + "lint": "jshint lib/ test/", + "test": "npm run lint && npm run unit", + "unit": "node test/source-map-resolve.js && node test/windows.js" + }, + "version": "0.5.2" +} diff --git a/node_modules/source-map-resolve/readme.md b/node_modules/source-map-resolve/readme.md new file mode 100644 index 0000000..c70bcca --- /dev/null +++ b/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: [""] + // } + }) +}) + +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: [""] + // } + result.map.sourcesContent = result.sourcesContent + var map = new sourceMap.sourceMapConsumer(result.map) + map.sourceContentFor("/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: + +- +- + + +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: ` +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: ` 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). 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/`, not `/scripts/`. 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 + } + +})); diff --git a/node_modules/source-map-resolve/source-map-resolve.js.template b/node_modules/source-map-resolve/source-map-resolve.js.template new file mode 100644 index 0000000..813198a --- /dev/null +++ b/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}} + +})); diff --git a/node_modules/source-map-resolve/test/common.js b/node_modules/source-map-resolve/test/common.js new file mode 100644 index 0000000..8616c17 --- /dev/null +++ b/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 +} diff --git a/node_modules/source-map-resolve/test/read.js b/node_modules/source-map-resolve/test/read.js new file mode 100644 index 0000000..6bf2dad --- /dev/null +++ b/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)) diff --git a/node_modules/source-map-resolve/test/source-map-resolve.js b/node_modules/source-map-resolve/test/source-map-resolve.js new file mode 100644 index 0000000..f61c006 --- /dev/null +++ b/node_modules/source-map-resolve/test/source-map-resolve.js @@ -0,0 +1,1162 @@ +// Copyright 2014, 2015, 2016, 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 read = common.read +var Throws = common.Throws +var identity = common.identity + +var sourceMapResolve = require("../") + +// Polyfills. +require("setimmediate") +if (typeof window !== "undefined" && !window.atob) { + window.atob = require("Base64").atob +} + +"use strict" + +var map = { + simple: { + mappings: "AAAA", + sources: ["foo.js"], + names: [] + }, + sourceRoot: { + mappings: "AAAA", + sourceRoot: "/static/js/app/", + sources: ["foo.js", "lib/bar.js", "../vendor/dom.js", "/version.js", "//foo.org/baz.js"], + names: [] + }, + sourceRootNoSlash: { + mappings: "AAAA", + sourceRoot: "/static/js/app", + sources: ["foo.js", "lib/bar.js", "../vendor/dom.js", "/version.js", "//foo.org/baz.js"], + names: [] + }, + sourceRootEmpty: { + mappings: "AAAA", + sourceRoot: "", + sources: ["foo.js", "lib/bar.js", "../vendor/dom.js", "/version.js", "//foo.org/baz.js"], + names: [] + }, + sourcesContent: { + mappings: "AAAA", + sourceRoot: "/static/js/app/", + sources: ["foo.js", "lib/bar.js", "../vendor/dom.js", "/version.js", "//foo.org/baz.js"], + sourcesContent: ["foo.js", "lib/bar.js", "../vendor/dom.js", "/version.js", "//foo.org/baz.js"], + names: [] + }, + mixed: { + mappings: "AAAA", + sources: ["foo.js", "lib/bar.js", "../vendor/dom.js", "/version.js", "//foo.org/baz.js"], + sourcesContent: ["foo.js", null , null , "/version.js", "//foo.org/baz.js"], + names: [] + }, + noSources: { + mappings: "", + sources: [], + names: [] + }, + empty: {} +} +map.simpleString = JSON.stringify(map.simple) +map.XSSIsafe = ")]}'" + map.simpleString + +var code = { + fileRelative: u("foo.js.map"), + domainRelative: u("/foo.js.map"), + schemeRelative: u("//foo.org/foo.js.map"), + absolute: u("https://foo.org/foo.js.map"), + dataUri: u("data:application/json," + + "%7B%22mappings%22%3A%22AAAA%22%2C%22sources%22%3A%5B%22" + + "foo.js%22%5D%2C%22names%22%3A%5B%5D%7D"), + base64: u("data:application/json;base64," + + "eyJtYXBwaW5ncyI6IkFBQUEiLCJzb3VyY2VzIjpbImZvby5qcyJdLCJuYW1lcyI6W119"), + dataUriText: u("data:text/json," + + "%7B%22mappings%22%3A%22AAAA%22%2C%22sources%22%3A%5B%22" + + "foo.js%22%5D%2C%22names%22%3A%5B%5D%7D"), + dataUriParameter: u("data:application/json;charset=UTF-8;foo=bar," + + "%7B%22mappings%22%3A%22AAAA%22%2C%22sources%22%3A%5B%22" + + "foo.js%22%5D%2C%22names%22%3A%5B%5D%7D"), + dataUriNoMime: u("data:,foo"), + dataUriInvalidMime: u("data:text/html,foo"), + dataUriInvalidJSON: u("data:application/json,foo"), + dataUriXSSIsafe: u("data:application/json," + ")%5D%7D%27" + + "%7B%22mappings%22%3A%22AAAA%22%2C%22sources%22%3A%5B%22" + + "foo.js%22%5D%2C%22names%22%3A%5B%5D%7D"), + dataUriEmpty: u("data:"), + noMap: "" +} + + +function testResolveSourceMap(method, sync) { + return function(t) { + var wrap = (sync ? identity : asyncify) + + var codeUrl = "http://example.com/a/b/c/foo.js" + + t.plan(1 + 12*3 + 6*4) + + t.equal(typeof method, "function", "is a function") + + if (sync) { + method = asyncify(method) + } + + var next = false + function isAsync() { t.ok(next, "is async") } + + method(code.fileRelative, codeUrl, wrap(read(map.simpleString)), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "foo.js.map", + url: "http://example.com/a/b/c/foo.js.map", + sourcesRelativeTo: "http://example.com/a/b/c/foo.js.map", + map: map.simple + }, "fileRelative") + isAsync() + }) + + method(code.domainRelative, codeUrl, wrap(read(map.simpleString)), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "/foo.js.map", + url: "http://example.com/foo.js.map", + sourcesRelativeTo: "http://example.com/foo.js.map", + map: map.simple + }, "domainRelative") + isAsync() + }) + + method(code.schemeRelative, codeUrl, wrap(read(map.simpleString)), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "//foo.org/foo.js.map", + url: "http://foo.org/foo.js.map", + sourcesRelativeTo: "http://foo.org/foo.js.map", + map: map.simple + }, "schemeRelative") + isAsync() + }) + + method(code.absolute, codeUrl, wrap(read(map.simpleString)), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "https://foo.org/foo.js.map", + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: map.simple + }, "absolute") + isAsync() + }) + + method(code.dataUri, codeUrl, wrap(Throws), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "data:application/json," + + "%7B%22mappings%22%3A%22AAAA%22%2C%22sources%22%3A%5B%22" + + "foo.js%22%5D%2C%22names%22%3A%5B%5D%7D", + url: null, + sourcesRelativeTo: codeUrl, + map: map.simple + }, "dataUri") + isAsync() + }) + + method(code.base64, codeUrl, wrap(Throws), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "data:application/json;base64," + + "eyJtYXBwaW5ncyI6IkFBQUEiLCJzb3VyY2VzIjpbImZvby5qcyJdLCJuYW1lcyI6W119", + url: null, + sourcesRelativeTo: codeUrl, + map: map.simple + }, "base64") + isAsync() + }) + + method(code.dataUriText, codeUrl, wrap(Throws), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "data:text/json," + + "%7B%22mappings%22%3A%22AAAA%22%2C%22sources%22%3A%5B%22" + + "foo.js%22%5D%2C%22names%22%3A%5B%5D%7D", + url: null, + sourcesRelativeTo: codeUrl, + map: map.simple + }, "dataUriText") + isAsync() + }) + + method(code.dataUriParameter, codeUrl, wrap(Throws), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "data:application/json;charset=UTF-8;foo=bar," + + "%7B%22mappings%22%3A%22AAAA%22%2C%22sources%22%3A%5B%22" + + "foo.js%22%5D%2C%22names%22%3A%5B%5D%7D", + url: null, + sourcesRelativeTo: codeUrl, + map: map.simple + }, "dataUriParameter") + isAsync() + }) + + method(code.dataUriNoMime, codeUrl, wrap(Throws), function(error, result) { + t.deepEqual(error.sourceMapData, { + sourceMappingURL: "data:,foo", + url: null, + sourcesRelativeTo: codeUrl, + map: "foo" + }, "dataUriNoMime .sourceMapData") + t.ok(error.message.match(/mime type.+text\/plain/), "dataUriNoMime") + t.notOk(result) + isAsync() + }) + + method(code.dataUriInvalidMime, codeUrl, wrap(Throws), function(error, result) { + t.deepEqual(error.sourceMapData, { + sourceMappingURL: "data:text/html,foo", + url: null, + sourcesRelativeTo: codeUrl, + map: "foo" + }, "dataUriInvalidMime .sourceMapData") + t.ok(error.message.match(/mime type.+text\/html/), "dataUriInvalidMime") + t.notOk(result) + isAsync() + }) + + method(code.dataUriInvalidJSON, codeUrl, wrap(Throws), function(error, result) { + t.deepEqual(error.sourceMapData, { + sourceMappingURL: "data:application/json,foo", + url: null, + sourcesRelativeTo: codeUrl, + map: "foo" + }, "dataUriInvalidJSON .sourceMapData") + t.ok(error instanceof SyntaxError && error.message !== "data:application/json,foo", + "dataUriInvalidJSON") + t.notOk(result) + isAsync() + }) + + method(code.dataUriXSSIsafe, codeUrl, wrap(Throws), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "data:application/json," + ")%5D%7D%27" + + "%7B%22mappings%22%3A%22AAAA%22%2C%22sources%22%3A%5B%22" + + "foo.js%22%5D%2C%22names%22%3A%5B%5D%7D", + url: null, + sourcesRelativeTo: codeUrl, + map: map.simple + }, "dataUriXSSIsafe") + isAsync() + }) + + method(code.dataUriEmpty, codeUrl, wrap(Throws), function(error, result) { + t.deepEqual(error.sourceMapData, { + sourceMappingURL: "data:", + url: null, + sourcesRelativeTo: codeUrl, + map: "" + }, "dataUriEmpty .sourceMapData") + t.ok(error.message.match(/mime type.+text\/plain/), "dataUriEmpty") + t.notOk(result) + isAsync() + }) + + method(code.noMap, codeUrl, wrap(Throws), function(error, result) { + t.error(error) + t.equal(result, null, "noMap") + isAsync() + }) + + method(code.absolute, codeUrl, wrap(read([map.simpleString])), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "https://foo.org/foo.js.map", + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: map.simple + }, "read non-string") + isAsync() + }) + + method(code.absolute, codeUrl, wrap(read("invalid JSON")), function(error, result) { + t.deepEqual(error.sourceMapData, { + sourceMappingURL: "https://foo.org/foo.js.map", + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: "invalid JSON" + }, "read invalid JSON .sourceMapData") + t.ok(error instanceof SyntaxError, "read invalid JSON") + t.notOk(result) + isAsync() + }) + + method(code.absolute, codeUrl, wrap(read(map.XSSIsafe)), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "https://foo.org/foo.js.map", + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: map.simple + }, "XSSIsafe map") + isAsync() + }) + + method(code.absolute, codeUrl, wrap(Throws), function(error, result) { + t.deepEqual(error.sourceMapData, { + sourceMappingURL: "https://foo.org/foo.js.map", + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: null + }, "read throws .sourceMapData") + t.equal(error.message, "https://foo.org/foo.js.map", "read throws") + t.notOk(result) + isAsync() + }) + + next = true + } +} + +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 = "http://example.com/a/b/c/foo.js.map" + + t.plan(1 + 11*3 + 4) + + t.equal(typeof method, "function", "is a function") + + if (sync) { + method = asyncify(method) + } + + var next = false + function isAsync() { t.ok(next, "is async") } + + var options + + method(map.simple, mapUrl, wrap(identity), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourcesResolved: ["http://example.com/a/b/c/foo.js"], + sourcesContent: ["http://example.com/a/b/c/foo.js"] + }, "simple") + isAsync() + }) + + method(map.sourceRoot, mapUrl, wrap(identity), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourcesResolved: [ + "http://example.com/static/js/app/foo.js", + "http://example.com/static/js/app/lib/bar.js", + "http://example.com/static/js/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], + sourcesContent: [ + "http://example.com/static/js/app/foo.js", + "http://example.com/static/js/app/lib/bar.js", + "http://example.com/static/js/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ] + }, "sourceRoot") + isAsync() + }) + + options = {sourceRoot: false} + method(map.sourceRoot, mapUrl, wrap(identity), options, function(error, result) { + t.error(error) + t.deepEqual(result, { + sourcesResolved: [ + "http://example.com/a/b/c/foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], + sourcesContent: [ + "http://example.com/a/b/c/foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ] + }, "ignore sourceRoot") + isAsync() + }) + + options = {sourceRoot: "/static/js/"} + method(map.sourceRoot, mapUrl, wrap(identity), options, function(error, result) { + t.error(error) + t.deepEqual(result, { + sourcesResolved: [ + "http://example.com/static/js/foo.js", + "http://example.com/static/js/lib/bar.js", + "http://example.com/static/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], + sourcesContent: [ + "http://example.com/static/js/foo.js", + "http://example.com/static/js/lib/bar.js", + "http://example.com/static/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ] + }, "custom sourceRoot") + isAsync() + }) + + method(map.sourceRootNoSlash, mapUrl, wrap(identity), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourcesResolved: [ + "http://example.com/static/js/app/foo.js", + "http://example.com/static/js/app/lib/bar.js", + "http://example.com/static/js/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], + sourcesContent: [ + "http://example.com/static/js/app/foo.js", + "http://example.com/static/js/app/lib/bar.js", + "http://example.com/static/js/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ] + }, "sourceRootNoSlash") + isAsync() + }) + + method(map.sourceRootEmpty, mapUrl, wrap(identity), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourcesResolved: [ + "http://example.com/a/b/c/foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], + sourcesContent: [ + "http://example.com/a/b/c/foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ] + }, "sourceRootEmpty") + isAsync() + }) + + method(map.sourcesContent, mapUrl, wrap(Throws), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourcesResolved: [ + "http://example.com/static/js/app/foo.js", + "http://example.com/static/js/app/lib/bar.js", + "http://example.com/static/js/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], + sourcesContent: [ + "foo.js", + "lib/bar.js", + "../vendor/dom.js", + "/version.js", + "//foo.org/baz.js" + ] + }, "sourcesContent") + isAsync() + }) + + method(map.mixed, mapUrl, wrap(identity), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourcesResolved: [ + "http://example.com/a/b/c/foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], + sourcesContent: [ + "foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "/version.js", + "//foo.org/baz.js" + ] + }, "mixed") + isAsync() + }) + + method(map.noSources, mapUrl, wrap(identity), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourcesResolved: [], + sourcesContent: [] + }, "noSources") + isAsync() + }) + + method(map.empty, mapUrl, wrap(identity), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourcesResolved: [], + sourcesContent: [] + }, "empty") + isAsync() + }) + + method(map.simple, mapUrl, wrap(read(["non", "string"])), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourcesResolved: ["http://example.com/a/b/c/foo.js"], + sourcesContent: ["non,string"] + }, "read non-string") + isAsync() + }) + + method(map.mixed, mapUrl, wrap(Throws), function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, [ + "http://example.com/a/b/c/foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "read throws .sourcesResolved") + var sourcesContent = result.sourcesContent + for (var index = 0, len = sourcesContent.length; index < len; index++) { + var item = sourcesContent[index] + if (item instanceof Error) { + sourcesContent[index] = null + } + } + t.deepEqual(sourcesContent, [ + "foo.js", + null, + null, + "/version.js", + "//foo.org/baz.js" + ], "read throws .sourcesContent") + isAsync() + }) + + next = true + } +} + +test(".resolveSources", testResolveSources(sourceMapResolve.resolveSources, false)) + +test(".resolveSourcesSync", testResolveSources(sourceMapResolve.resolveSourcesSync, true)) + +test(".resolveSourcesSync no read", function(t) { + t.plan(1) + + var mapUrl = "http://example.com/a/b/c/foo.js.map" + var result = sourceMapResolve.resolveSourcesSync(map.mixed, mapUrl, null) + + t.deepEqual(result, { + sourcesResolved: [ + "http://example.com/a/b/c/foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], + sourcesContent: [] + }) +}) + + +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 = "http://example.com/a/b/c/foo.js" + + t.plan(1 + 15*3 + 21*4 + 4) + + t.equal(typeof method, "function", "is a function") + + if (sync) { + method = asyncify(method) + } + + var next = false + function isAsync() { t.ok(next, "is async") } + + var readSimple = wrapMap(read(map.simpleString), identity) + + method(code.fileRelative, codeUrl, readSimple, function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "foo.js.map", + url: "http://example.com/a/b/c/foo.js.map", + sourcesRelativeTo: "http://example.com/a/b/c/foo.js.map", + map: map.simple, + sourcesResolved: ["http://example.com/a/b/c/foo.js"], + sourcesContent: ["http://example.com/a/b/c/foo.js"] + }, "fileRelative") + isAsync() + }) + + method(code.domainRelative, codeUrl, readSimple, function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "/foo.js.map", + url: "http://example.com/foo.js.map", + sourcesRelativeTo: "http://example.com/foo.js.map", + map: map.simple, + sourcesResolved: ["http://example.com/foo.js"], + sourcesContent: ["http://example.com/foo.js"] + }, "domainRelative") + isAsync() + }) + + method(code.schemeRelative, codeUrl, readSimple, function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "//foo.org/foo.js.map", + url: "http://foo.org/foo.js.map", + sourcesRelativeTo: "http://foo.org/foo.js.map", + map: map.simple, + sourcesResolved: ["http://foo.org/foo.js"], + sourcesContent: ["http://foo.org/foo.js"] + }, "schemeRelative") + isAsync() + }) + + method(code.absolute, codeUrl, readSimple, function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "https://foo.org/foo.js.map", + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: map.simple, + sourcesResolved: ["https://foo.org/foo.js"], + sourcesContent: ["https://foo.org/foo.js"] + }, "absolute") + isAsync() + }) + + method(code.dataUri, codeUrl, wrapMap(Throws, identity), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "data:application/json," + + "%7B%22mappings%22%3A%22AAAA%22%2C%22sources%22%3A%5B%22" + + "foo.js%22%5D%2C%22names%22%3A%5B%5D%7D", + url: null, + sourcesRelativeTo: codeUrl, + map: map.simple, + sourcesResolved: ["http://example.com/a/b/c/foo.js"], + sourcesContent: ["http://example.com/a/b/c/foo.js"] + }, "dataUri") + isAsync() + }) + + method(code.base64, codeUrl, wrapMap(Throws, identity), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "data:application/json;base64," + + "eyJtYXBwaW5ncyI6IkFBQUEiLCJzb3VyY2VzIjpbImZvby5qcyJdLCJuYW1lcyI6W119", + url: null, + sourcesRelativeTo: codeUrl, + map: map.simple, + sourcesResolved: ["http://example.com/a/b/c/foo.js"], + sourcesContent: ["http://example.com/a/b/c/foo.js"] + }, "base64") + isAsync() + }) + + method(code.dataUriText, codeUrl, wrapMap(Throws, identity), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "data:text/json," + + "%7B%22mappings%22%3A%22AAAA%22%2C%22sources%22%3A%5B%22" + + "foo.js%22%5D%2C%22names%22%3A%5B%5D%7D", + url: null, + sourcesRelativeTo: codeUrl, + map: map.simple, + sourcesResolved: ["http://example.com/a/b/c/foo.js"], + sourcesContent: ["http://example.com/a/b/c/foo.js"] + }, "dataUriText") + isAsync() + }) + + method(code.dataUriParameter, codeUrl, wrapMap(Throws, identity), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "data:application/json;charset=UTF-8;foo=bar," + + "%7B%22mappings%22%3A%22AAAA%22%2C%22sources%22%3A%5B%22" + + "foo.js%22%5D%2C%22names%22%3A%5B%5D%7D", + url: null, + sourcesRelativeTo: codeUrl, + map: map.simple, + sourcesResolved: ["http://example.com/a/b/c/foo.js"], + sourcesContent: ["http://example.com/a/b/c/foo.js"] + }, "dataUriParameter") + isAsync() + }) + + method(code.dataUriNoMime, codeUrl, wrap(Throws), function(error, result) { + t.deepEqual(error.sourceMapData, { + sourceMappingURL: "data:,foo", + url: null, + sourcesRelativeTo: codeUrl, + map: "foo" + }, "dataUriNoMime .sourceMapData") + t.ok(error.message.match(/mime type.+text\/plain/), "dataUriNoMime") + t.notOk(result) + isAsync() + }) + + method(code.dataUriInvalidMime, codeUrl, wrap(Throws), function(error, result) { + t.deepEqual(error.sourceMapData, { + sourceMappingURL: "data:text/html,foo", + url: null, + sourcesRelativeTo: codeUrl, + map: "foo" + }, "dataUriInvalidMime .sourceMapData") + t.ok(error.message.match(/mime type.+text\/html/), "dataUriInvalidMime") + t.notOk(result) + isAsync() + }) + + method(code.dataUriInvalidJSON, codeUrl, wrap(Throws), function(error, result) { + t.deepEqual(error.sourceMapData, { + sourceMappingURL: "data:application/json,foo", + url: null, + sourcesRelativeTo: codeUrl, + map: "foo" + }, "dataUriInvalidJSON .sourceMapData") + t.ok(error instanceof SyntaxError && error.message !== "data:application/json,foo", + "dataUriInvalidJSON") + t.notOk(result) + isAsync() + }) + + method(code.dataUriXSSIsafe, codeUrl, wrapMap(Throws, identity), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "data:application/json," + ")%5D%7D%27" + + "%7B%22mappings%22%3A%22AAAA%22%2C%22sources%22%3A%5B%22" + + "foo.js%22%5D%2C%22names%22%3A%5B%5D%7D", + url: null, + sourcesRelativeTo: codeUrl, + map: map.simple, + sourcesResolved: ["http://example.com/a/b/c/foo.js"], + sourcesContent: ["http://example.com/a/b/c/foo.js"] + }, "dataUriXSSIsafe") + isAsync() + }) + + method(code.dataUriEmpty, codeUrl, wrap(Throws), function(error, result) { + t.deepEqual(error.sourceMapData, { + sourceMappingURL: "data:", + url: null, + sourcesRelativeTo: codeUrl, + map: "" + }, "dataUriEmpty .sourceMapData") + t.ok(error.message.match(/mime type.+text\/plain/), "dataUriEmpty") + t.notOk(result) + isAsync() + }) + + method(code.noMap, codeUrl, wrap(Throws), function(error, result) { + t.error(error) + t.equal(result, null, "noMap") + isAsync() + }) + + method(code.absolute, codeUrl, wrap(read([map.simpleString])), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "https://foo.org/foo.js.map", + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: map.simple, + sourcesResolved: ["https://foo.org/foo.js"], + sourcesContent: [map.simpleString] + }, "read non-string") + isAsync() + }) + + method(code.absolute, codeUrl, wrap(read("invalid JSON")), function(error, result) { + t.deepEqual(error.sourceMapData, { + sourceMappingURL: "https://foo.org/foo.js.map", + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: "invalid JSON" + }, "read invalid JSON .sourceMapData") + t.ok(error instanceof SyntaxError, "read invalid JSON") + t.notOk(result) + isAsync() + }) + + method(code.absolute, codeUrl, wrapMap(read(map.XSSIsafe), identity), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: "https://foo.org/foo.js.map", + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: map.simple, + sourcesResolved: ["https://foo.org/foo.js"], + sourcesContent: ["https://foo.org/foo.js"] + }, "XSSIsafe map") + isAsync() + }) + + method(code.absolute, codeUrl, wrap(Throws), function(error, result) { + t.deepEqual(error.sourceMapData, { + sourceMappingURL: "https://foo.org/foo.js.map", + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: null + }, "read throws .sourceMapData") + t.equal(error.message, "https://foo.org/foo.js.map", "read throws") + t.notOk(result) + isAsync() + }) + + function readMap(what) { + return wrapMap(read(JSON.stringify(what)), identity) + } + + var options + + method(code.fileRelative, codeUrl, readMap(map.simple), function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, ["http://example.com/a/b/c/foo.js"], "simple") + t.deepEqual(result.sourcesContent, ["http://example.com/a/b/c/foo.js"], "simple") + isAsync() + }) + + method(code.fileRelative, codeUrl, readMap(map.sourceRoot), function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, [ + "http://example.com/static/js/app/foo.js", + "http://example.com/static/js/app/lib/bar.js", + "http://example.com/static/js/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "sourceRoot") + t.deepEqual(result.sourcesContent, [ + "http://example.com/static/js/app/foo.js", + "http://example.com/static/js/app/lib/bar.js", + "http://example.com/static/js/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "sourceRoot") + isAsync() + }) + + options = {sourceRoot: false} + method(code.fileRelative, codeUrl, readMap(map.sourceRoot), options, function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, [ + "http://example.com/a/b/c/foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "ignore sourceRoot") + t.deepEqual(result.sourcesContent, [ + "http://example.com/a/b/c/foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "ignore sourceRoot") + isAsync() + }) + + options = {sourceRoot: "/static/js/"} + method(code.fileRelative, codeUrl, readMap(map.sourceRoot), options, function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, [ + "http://example.com/static/js/foo.js", + "http://example.com/static/js/lib/bar.js", + "http://example.com/static/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "custom sourceRoot") + t.deepEqual(result.sourcesContent, [ + "http://example.com/static/js/foo.js", + "http://example.com/static/js/lib/bar.js", + "http://example.com/static/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "custom sourceRoot") + isAsync() + }) + + method(code.fileRelative, codeUrl, readMap(map.sourceRootNoSlash), function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, [ + "http://example.com/static/js/app/foo.js", + "http://example.com/static/js/app/lib/bar.js", + "http://example.com/static/js/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "sourceRootNoSlash") + t.deepEqual(result.sourcesContent, [ + "http://example.com/static/js/app/foo.js", + "http://example.com/static/js/app/lib/bar.js", + "http://example.com/static/js/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "sourceRootNoSlash") + isAsync() + }) + + method(code.fileRelative, codeUrl, readMap(map.sourceRootEmpty), function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, [ + "http://example.com/a/b/c/foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "sourceRootEmpty") + t.deepEqual(result.sourcesContent, [ + "http://example.com/a/b/c/foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "sourceRootEmpty") + isAsync() + }) + + method(code.fileRelative, codeUrl, readMap(map.sourcesContent), function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, [ + "http://example.com/static/js/app/foo.js", + "http://example.com/static/js/app/lib/bar.js", + "http://example.com/static/js/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "sourcesContent") + t.deepEqual(result.sourcesContent, [ + "foo.js", + "lib/bar.js", + "../vendor/dom.js", + "/version.js", + "//foo.org/baz.js" + ], "sourcesContent") + isAsync() + }) + + method(code.fileRelative, codeUrl, readMap(map.mixed), function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, [ + "http://example.com/a/b/c/foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "mixed") + t.deepEqual(result.sourcesContent, [ + "foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "/version.js", + "//foo.org/baz.js" + ], "mixed") + isAsync() + }) + + method(code.fileRelative, codeUrl, readMap(map.noSources), function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, [], "noSources") + t.deepEqual(result.sourcesContent, [], "noSources") + isAsync() + }) + + method(code.fileRelative, codeUrl, readMap(map.empty), function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, [], "noSources") + t.deepEqual(result.sourcesContent, [], "noSources") + isAsync() + }) + + method(code.fileRelative, codeUrl, wrap(read([map.simpleString])), function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, ["http://example.com/a/b/c/foo.js"], "read non-string") + t.deepEqual(result.sourcesContent, [map.simpleString], "read non-string") + isAsync() + }) + + function ThrowsMap(what) { + return wrapMap(read(JSON.stringify(what)), Throws) + } + + method(code.fileRelative, codeUrl, ThrowsMap(map.mixed), function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, [ + "http://example.com/a/b/c/foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "read throws .sourcesResolved") + var sourcesContent = result.sourcesContent + for (var index = 0, len = sourcesContent.length; index < len; index++) { + var item = sourcesContent[index] + if (item instanceof Error) { + sourcesContent[index] = null + } + } + t.deepEqual(sourcesContent, [ + "foo.js", + null, + null, + "/version.js", + "//foo.org/baz.js" + ], "read throws .sourcesContent") + isAsync() + }) + + var mapUrl = "https://foo.org/foo.js.map" + + method(null, mapUrl, readSimple, function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: null, + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: map.simple, + sourcesResolved: ["https://foo.org/foo.js"], + sourcesContent: ["https://foo.org/foo.js"] + }, "mapUrl simple") + isAsync() + }) + + method(null, mapUrl, wrap(read([map.simpleString])), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: null, + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: map.simple, + sourcesResolved: ["https://foo.org/foo.js"], + sourcesContent: [map.simpleString] + }, "mapUrl read non-string") + isAsync() + }) + + method(null, mapUrl, wrap(read("invalid JSON")), function(error, result) { + t.deepEqual(error.sourceMapData, { + sourceMappingURL: null, + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: "invalid JSON" + }, "mapUrl read invalid JSON .sourceMapData") + t.ok(error instanceof SyntaxError, "mapUrl read invalid JSON") + t.notOk(result) + isAsync() + }) + + method(null, mapUrl, wrapMap(read(map.XSSIsafe), identity), function(error, result) { + t.error(error) + t.deepEqual(result, { + sourceMappingURL: null, + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: map.simple, + sourcesResolved: ["https://foo.org/foo.js"], + sourcesContent: ["https://foo.org/foo.js"] + }, "mapUrl XSSIsafe map") + isAsync() + }) + + method(null, mapUrl, wrap(Throws), function(error, result) { + t.deepEqual(error.sourceMapData, { + sourceMappingURL: null, + url: "https://foo.org/foo.js.map", + sourcesRelativeTo: "https://foo.org/foo.js.map", + map: null + }, "mapUrl read throws .sourceMapData") + t.equal(error.message, "https://foo.org/foo.js.map", "mapUrl read throws") + t.notOk(result) + isAsync() + }) + + mapUrl = "http://example.com/a/b/c/foo.js.map" + + options = {sourceRoot: "/static/js/"} + method(null, mapUrl, readMap(map.sourceRoot), options, function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, [ + "http://example.com/static/js/foo.js", + "http://example.com/static/js/lib/bar.js", + "http://example.com/static/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "mapUrl custom sourceRoot") + t.deepEqual(result.sourcesContent, [ + "http://example.com/static/js/foo.js", + "http://example.com/static/js/lib/bar.js", + "http://example.com/static/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "mapUrl custom sourceRoot") + isAsync() + }) + + method(null, mapUrl, readMap(map.mixed), function(error, result) { + t.error(error) + t.deepEqual(result.sourcesResolved, [ + "http://example.com/a/b/c/foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "http://example.com/version.js", + "http://foo.org/baz.js" + ], "mapUrl mixed") + t.deepEqual(result.sourcesContent, [ + "foo.js", + "http://example.com/a/b/c/lib/bar.js", + "http://example.com/a/b/vendor/dom.js", + "/version.js", + "//foo.org/baz.js" + ], "mapUrl mixed") + isAsync() + }) + + next = true + } +} + +test(".resolve", testResolve(sourceMapResolve.resolve, false)) + +test(".resolveSync", testResolve(sourceMapResolve.resolveSync, true)) + +test(".parseMapToJSON", function(t) { + t.plan(1) + t.deepEqual(sourceMapResolve.parseMapToJSON(map.XSSIsafe), map.simple) +}) diff --git a/node_modules/source-map-resolve/test/windows.js b/node_modules/source-map-resolve/test/windows.js new file mode 100644 index 0000000..611ec7d --- /dev/null +++ b/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)) diff --git a/node_modules/source-map-resolve/x-package.json5 b/node_modules/source-map-resolve/x-package.json5 new file mode 100644 index 0000000..5bc9e29 --- /dev/null +++ b/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" + } + } + } +} -- cgit v1.2.3