diff options
Diffstat (limited to 'node_modules/istanbul-lib-source-maps')
12 files changed, 715 insertions, 0 deletions
diff --git a/node_modules/istanbul-lib-source-maps/CHANGELOG.md b/node_modules/istanbul-lib-source-maps/CHANGELOG.md new file mode 100644 index 000000000..dd847c7b4 --- /dev/null +++ b/node_modules/istanbul-lib-source-maps/CHANGELOG.md @@ -0,0 +1,56 @@ +# Change Log + +All notable changes to this project will be documented in this file. +See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines. + +<a name="1.2.0"></a> +# [1.2.0](https://github.com/istanbuljs/istanbul-lib-source-maps/compare/istanbul-lib-source-maps@1.1.1...istanbul-lib-source-maps@1.2.0) (2017-04-29) + + +### Features + +* pull in debug module, to make debug messages optional ([#36](https://github.com/istanbuljs/istanbuljs/issues/36)) ([189519d](https://github.com/istanbuljs/istanbul-lib-source-maps/commit/189519d)) + + + + +<a name="1.1.1"></a> +## [1.1.1](https://github.com/istanbuljs/istanbul-lib-source-maps/compare/istanbul-lib-source-maps@1.1.0...istanbul-lib-source-maps@1.1.1) (2017-03-27) + +<a name="1.1.0"></a> +# [1.1.0](https://github.com/istanbuljs/istanbul-lib-source-maps/compare/v1.0.2...v1.1.0) (2016-11-10) + + +### Features + +* read and apply any input source maps stored with coverage data ([#4](https://github.com/istanbuljs/istanbul-lib-source-maps/issues/4)) ([aea405b](https://github.com/istanbuljs/istanbul-lib-source-maps/commit/aea405b)) + + + +<a name="1.0.2"></a> +## [1.0.2](https://github.com/istanbuljs/istanbul-lib-source-maps/compare/v1.0.1...v1.0.2) (2016-10-03) + + +### Bug Fixes + +* broken mapped coverage report ([#6](https://github.com/istanbuljs/istanbul-lib-source-maps/issues/6)) ([d9dd738](https://github.com/istanbuljs/istanbul-lib-source-maps/commit/d9dd738)) + + + +<a name="1.0.1"></a> +## [1.0.1](https://github.com/istanbuljs/istanbul-lib-source-maps/compare/v1.0.0...v1.0.1) (2016-09-13) + + +### Bug Fixes + +* position validation shouldn't throw away locations with 0 ([#5](https://github.com/istanbuljs/istanbul-lib-source-maps/issues/5)) ([ac4b72c](https://github.com/istanbuljs/istanbul-lib-source-maps/commit/ac4b72c)) + + + +<a name="1.0.0"></a> +# [1.0.0](https://github.com/istanbuljs/istanbul-lib-source-maps/compare/v1.0.0-alpha.9...v1.0.0) (2016-08-31) + + +### Bug Fixes + +* discard more bad source map positions ([#3](https://github.com/istanbuljs/istanbul-lib-source-maps/issues/3)) ([ed7b27f](https://github.com/istanbuljs/istanbul-lib-source-maps/commit/ed7b27f)) diff --git a/node_modules/istanbul-lib-source-maps/LICENSE b/node_modules/istanbul-lib-source-maps/LICENSE new file mode 100644 index 000000000..c05aaafba --- /dev/null +++ b/node_modules/istanbul-lib-source-maps/LICENSE @@ -0,0 +1,24 @@ +Copyright 2015 Yahoo! Inc. +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + * Neither the name of the Yahoo! Inc. nor the + names of its contributors may be used to endorse or promote products + derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL YAHOO! INC. BE LIABLE FOR ANY +DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/node_modules/istanbul-lib-source-maps/README.md b/node_modules/istanbul-lib-source-maps/README.md new file mode 100644 index 000000000..05c3538e2 --- /dev/null +++ b/node_modules/istanbul-lib-source-maps/README.md @@ -0,0 +1,12 @@ +istanbul-lib-source-maps +======================== + +[](https://travis-ci.org/istanbuljs/istanbuljs) + +Source map support for istanbuljs. + +## Debugging + +_istanbul-lib-source-maps_ uses the [debug](https://www.npmjs.com/package/debug) module. +Run your application with the environment variable `DEBUG=istanbuljs`, to receive debug +output. diff --git a/node_modules/istanbul-lib-source-maps/index.js b/node_modules/istanbul-lib-source-maps/index.js new file mode 100644 index 000000000..225bf5916 --- /dev/null +++ b/node_modules/istanbul-lib-source-maps/index.js @@ -0,0 +1,17 @@ +/* + Copyright 2012-2015, Yahoo Inc. + Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms. + */ +"use strict"; + +var MapStore = require('./lib/map-store').MapStore; +/** + * @module Exports + */ +module.exports = { + createSourceMapStore: function (opts) { + return new MapStore(opts); + } +}; + + diff --git a/node_modules/istanbul-lib-source-maps/lib/map-store.js b/node_modules/istanbul-lib-source-maps/lib/map-store.js new file mode 100644 index 000000000..8b31d4229 --- /dev/null +++ b/node_modules/istanbul-lib-source-maps/lib/map-store.js @@ -0,0 +1,160 @@ +/* + Copyright 2015, Yahoo Inc. + Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms. + */ +"use strict"; + +var debug = require('debug')('istanbuljs'), + path = require('path'), + fs = require('fs'), + pathutils = require('./pathutils'), + sourceStore = require('./source-store'), + transformer = require('./transformer'), + SMC = require('source-map').SourceMapConsumer; + +/** + * tracks source maps for registered files + * @param {Object} opts [opts=undefined] options. + * @param {Boolean} opts.verbose [opts.verbose=false] verbose mode + * @param {String} opts.baseDir [opts.baseDir=null] alternate base directory + * to resolve sourcemap files + * @param {String} opts.sourceStore [opts.sourceStore='memory'] - store that tracks + * embedded sources found in source maps, one of 'memory' or 'file' + * @param {String} opts.tmpdir [opts.tmpdir=undefined] - temporary directory + * to use for storing files. + * @constructor + */ +function MapStore(opts) { + opts = opts || {}; + this.baseDir = opts.baseDir || null; + this.verbose = opts.verbose || false; + this.sourceStore = sourceStore.create(opts.sourceStore, { tmpdir: opts.tmpdir}); + this.data = {}; +} +/** + * registers a source map URL with this store. It makes some input sanity checks + * and silently fails on malformed input. + * @param transformedFilePath - the file path for which the source map is valid. + * This must *exactly* match the path stashed for the coverage object to be + * useful. + * @param sourceMapUrl - the source map URL, **not** a comment + */ +MapStore.prototype.registerURL = function (transformedFilePath, sourceMapUrl) { + var d = 'data:', + b64 = 'base64,', + pos; + + if (sourceMapUrl.length > d.length && sourceMapUrl.substring(0, d.length) === d) { + pos = sourceMapUrl.indexOf(b64); + if (pos > 0) { + this.data[transformedFilePath] = { + type: 'encoded', + data: sourceMapUrl.substring(pos + b64.length) + }; + } else { + debug('Unable to interpret source map URL: ' + sourceMapUrl); + } + return; + } + var dir = path.dirname(path.resolve(transformedFilePath)), + file = path.resolve(dir, sourceMapUrl); + this.data[transformedFilePath] = { type: 'file', data: file }; +}; +/** + * registers a source map object with this store. Makes some basic sanity checks + * and silently fails on malformed input. + * @param transformedFilePath - the file path for which the source map is valid + * @param sourceMap - the source map object + */ +MapStore.prototype.registerMap = function (transformedFilePath, sourceMap) { + if (sourceMap && sourceMap.version) { + this.data[transformedFilePath] = { type: 'object', data: sourceMap }; + } else { + debug('Invalid source map object:' + JSON.stringify(sourceMap, null, 2)); + } +}; +/** + * transforms the coverage map provided into one that refers to original + * sources when valid mappings have been registered with this store. + * @param {CoverageMap} coverageMap - the coverage map to transform + * @returns {Object} an object with 2 properties. `map` for the transformed + * coverage map and `sourceFinder` which is a function to return the source + * text for a file. + */ +MapStore.prototype.transformCoverage = function (coverageMap) { + var that = this, + mappedCoverage, + sourceFinder; + + sourceFinder = function (filePath) { + var content = that.sourceStore.getSource(filePath); + if (content !== null) { + return content; + } + if (pathutils.isAbsolute(filePath)) { + return fs.readFileSync(filePath, 'utf8'); + } + return fs.readFileSync(pathutils.asAbsolute(filePath, that.baseDir)); + }; + + coverageMap.files().forEach(function (file) { + var coverage = coverageMap.fileCoverageFor(file); + if (coverage.data.inputSourceMap && !that.data[file]) { + that.registerMap(file, coverage.data.inputSourceMap); + } + }); + + if (Object.keys(this.data).length === 0) { + return { + map: coverageMap, + sourceFinder: sourceFinder + }; + } + mappedCoverage = transformer.create(function (filePath) { + try { + if (!that.data[filePath]) { + return null; + } + var d = that.data[filePath], + obj, + smc; + + if (d.type === 'file') { + obj = JSON.parse(fs.readFileSync(d.data, 'utf8')); + } else if (d.type === 'encoded') { + obj = JSON.parse(new Buffer(d.data, 'base64').toString()); + } else { + obj = d.data; + } + smc = new SMC(obj); + smc.sources.forEach(function (s) { + var content = smc.sourceContentFor(s), + sourceFilePath = pathutils.relativeTo(s, filePath); + if (content) { + that.sourceStore.registerSource(sourceFilePath, content); + } + }); + return smc; + } catch (ex) { + debug('Error returning source map for ' + filePath); + debug(ex.stack); + return null; + } + }).transform(coverageMap); + + return { + map: mappedCoverage, + sourceFinder: sourceFinder + }; +}; + +/** + * disposes temporary resources allocated by this map store + */ +MapStore.prototype.dispose = function () { + this.sourceStore.dispose(); +}; + +module.exports = { + MapStore: MapStore +}; diff --git a/node_modules/istanbul-lib-source-maps/lib/mapped.js b/node_modules/istanbul-lib-source-maps/lib/mapped.js new file mode 100644 index 000000000..fac8d7d5f --- /dev/null +++ b/node_modules/istanbul-lib-source-maps/lib/mapped.js @@ -0,0 +1,120 @@ +/* + Copyright 2015, Yahoo Inc. + Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms. + */ +"use strict"; + +var FileCoverage = require('istanbul-lib-coverage').classes.FileCoverage, + util = require('util'); + +function MappedCoverage(pathOrObj) { + FileCoverage.call(this, pathOrObj); + this.meta = { + last: { + s: 0, + f: 0, + b: 0 + }, + seen: {} + }; +} + +util.inherits(MappedCoverage, FileCoverage); + +function locString(loc) { + return [loc.start.line, loc.start.column, loc.end.line, loc.end.column].join(':'); +} + +MappedCoverage.prototype.addStatement = function (loc, hits) { + var key = 's:' + locString(loc), + meta = this.meta, + index = meta.seen[key]; + + if (index === undefined) { + index = meta.last.s; + meta.last.s += 1; + meta.seen[key] = index; + this.statementMap[index] = this.cloneLocation(loc); + } + this.s[index] = this.s[index] || 0; + this.s[index] += hits; + return index; +}; + +MappedCoverage.prototype.addFunction = function (name, decl, loc, hits) { + var key = 'f:' + locString(decl), + meta = this.meta, + index = meta.seen[key]; + + if (index === undefined) { + index = meta.last.f; + meta.last.f += 1; + meta.seen[key] = index; + name = name || '(unknown_' + index + ')'; + this.fnMap[index] = { + name: name, + decl: this.cloneLocation(decl), + loc: this.cloneLocation(loc) + }; + } + this.f[index] = this.f[index] || 0; + this.f[index] += hits; + return index; +}; + +MappedCoverage.prototype.addBranch = function (type, loc, branchLocations, hits) { + var key = ['b'], + meta = this.meta, + that = this, + index, + i; + + branchLocations.forEach(function (l) { + key.push(locString(l)); + }); + + key = key.join(':'); + index = meta.seen[key]; + if (index === undefined) { + index = meta.last.b; + meta.last.b += 1; + meta.seen[key] = index; + this.branchMap[index] = { + loc: loc, + type: type, + locations: branchLocations.map(function (l) { + return that.cloneLocation(l); + }) + }; + } + + if (!this.b[index]) { + this.b[index] = []; + branchLocations.forEach(function () { + that.b[index].push(0); + }); + } + for (i = 0; i < hits.length; i += 1) { + that.b[index][i] += hits[i]; + } + return index; +}; + +// returns a clone of the location object with only +// the attributes of interest +MappedCoverage.prototype.cloneLocation = function (loc) { + return { + start: { + line: loc.start.line, + column: loc.start.column + }, + end: { + line: loc.end.line, + column: loc.end.column + } + }; +}; + +module.exports = { + MappedCoverage: MappedCoverage +}; diff --git a/node_modules/istanbul-lib-source-maps/lib/pathutils.js b/node_modules/istanbul-lib-source-maps/lib/pathutils.js new file mode 100644 index 000000000..c72eb6ecf --- /dev/null +++ b/node_modules/istanbul-lib-source-maps/lib/pathutils.js @@ -0,0 +1,17 @@ +var path = require('path'), + isAbsolute = function (p) { + if (path.isAbsolute) { + return path.isAbsolute(p); + } + return path.resolve(p) === path.normalize(p); + }; + +exports.isAbsolute = isAbsolute; + +exports.asAbsolute = function (file, baseDir) { + return isAbsolute(file) ? file : path.resolve(baseDir || process.cwd, file); +}; + +exports.relativeTo = function (file, origFile) { + return isAbsolute(file) ? file : path.resolve(path.dirname(origFile), file); +}; diff --git a/node_modules/istanbul-lib-source-maps/lib/source-store.js b/node_modules/istanbul-lib-source-maps/lib/source-store.js new file mode 100644 index 000000000..cb84e9ec8 --- /dev/null +++ b/node_modules/istanbul-lib-source-maps/lib/source-store.js @@ -0,0 +1,80 @@ +var util = require('util'), + os = require('os'), + path = require('path'), + mkdirp = require('mkdirp'), + rimraf = require('rimraf'), + fs = require('fs'); + +function SourceStore(/*opts*/) { +} + +SourceStore.prototype.registerSource = function (/* filePath, sourceText */) { + throw new Error('registerSource must be overridden'); +}; + +SourceStore.prototype.getSource = function (/* filePath */) { + throw new Error('getSource must be overridden'); +}; + +SourceStore.prototype.dispose = function () { +}; + +function MemoryStore() { + this.data = {}; +} + +util.inherits(MemoryStore, SourceStore); + +MemoryStore.prototype.registerSource = function (filePath, sourceText) { + this.data[filePath] = sourceText; +}; + +MemoryStore.prototype.getSource = function (filePath) { + return this.data[filePath] || null; +}; + +function FileStore(opts) { + opts = opts || {}; + var tmpDir = opts.tmpdir || os.tmpdir(); + this.counter = 0; + this.mappings = []; + this.basePath = path.resolve(tmpDir, '.istanbul', 'cache_'); + mkdirp.sync(path.dirname(this.basePath)); +} + +util.inherits(FileStore, SourceStore); + +FileStore.prototype.registerSource = function (filePath, sourceText) { + if (this.mappings[filePath]) { + return; + } + this.counter += 1; + var mapFile = this.basePath + this.counter; + this.mappings[filePath] = mapFile; + fs.writeFileSync(mapFile, sourceText, 'utf8'); +}; + +FileStore.prototype.getSource = function (filePath) { + var mapFile = this.mappings[filePath]; + if (!mapFile) { + return null; + } + return fs.readFileSync(mapFile, 'utf8'); +}; + +FileStore.prototype.dispose = function () { + this.mappings = []; + rimraf.sync(path.dirname(this.basePath)); +}; + +module.exports = { + create: function (type, opts) { + opts = opts || {}; + type = (type || 'memory').toLowerCase(); + + if (type === 'file') { + return new FileStore(opts); + } + return new MemoryStore(opts); + } +}; diff --git a/node_modules/istanbul-lib-source-maps/lib/transformer.js b/node_modules/istanbul-lib-source-maps/lib/transformer.js new file mode 100644 index 000000000..748805949 --- /dev/null +++ b/node_modules/istanbul-lib-source-maps/lib/transformer.js @@ -0,0 +1,181 @@ +/* + Copyright 2015, Yahoo Inc. + Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms. + */ +"use strict"; + +var debug = require('debug')('istanbuljs'), + pathutils = require('./pathutils'), + libCoverage = require('istanbul-lib-coverage'), + MappedCoverage = require('./mapped').MappedCoverage; + +function isInvalidPosition (pos) { + return !pos || typeof pos.line !== "number" || typeof pos.column !== "number" || pos.line < 0 || pos.column < 0; +} + +/** + * determines the original position for a given location + * @param {SourceMapConsumer} sourceMap the source map + * @param {Object} location the original location Object + * @returns {Object} the remapped location Object + */ +function getMapping(sourceMap, location, origFile) { + + if (!location) { + return null; + } + + if (isInvalidPosition(location.start) || isInvalidPosition(location.end)) { + return null; + } + + var start = sourceMap.originalPositionFor(location.start), + end = sourceMap.originalPositionFor(location.end); + + /* istanbul ignore if: edge case too hard to test for */ + if (!(start && end)) { + return null; + } + if (!(start.source && end.source)) { + return null; + } + if (start.source !== end.source) { + return null; + } + + /* istanbul ignore if: edge case too hard to test for */ + if (start.line === null || start.column === null) { + return null; + } + /* istanbul ignore if: edge case too hard to test for */ + if (end.line === null || end.column === null) { + return null; + } + + if (start.line === end.line && start.column === end.column) { + end = sourceMap.originalPositionFor({ + line: location.end.line, + column: location.end.column, + bias: 2 + }); + end.column = end.column - 1; + } + + return { + source: pathutils.relativeTo(start.source, origFile), + loc: { + start: { + line: start.line, + column: start.column + }, + end: { + line: end.line, + column: end.column + } + } + }; +} + +function SourceMapTransformer(finder, opts) { + opts = opts || {}; + this.finder = finder; + this.baseDir = opts.baseDir || process.cwd(); +} + +SourceMapTransformer.prototype.processFile = function (fc, sourceMap, coverageMapper) { + var changes = 0; + + Object.keys(fc.statementMap).forEach(function (s) { + var loc = fc.statementMap[s], + hits = fc.s[s], + mapping = getMapping(sourceMap, loc, fc.path), + mappedCoverage; + + if (mapping) { + changes += 1; + mappedCoverage = coverageMapper(mapping.source); + mappedCoverage.addStatement(mapping.loc, hits); + } + }); + + Object.keys(fc.fnMap).forEach(function (f) { + var fnMeta = fc.fnMap[f], + hits = fc.f[f], + mapping = getMapping(sourceMap, fnMeta.decl, fc.path), + spanMapping = getMapping(sourceMap, fnMeta.loc, fc.path), + mappedCoverage; + + if (mapping && spanMapping && mapping.source === spanMapping.source) { + changes += 1; + mappedCoverage = coverageMapper(mapping.source); + mappedCoverage.addFunction(fnMeta.name, mapping.loc, spanMapping.loc, hits); + } + }); + + Object.keys(fc.branchMap).forEach(function (b) { + var branchMeta = fc.branchMap[b], + source, + hits = fc.b[b], + mapping, + locs = [], + mappedHits = [], + mappedCoverage, + skip, + i; + for (i = 0; i < branchMeta.locations.length; i += 1) { + mapping = getMapping(sourceMap, branchMeta.locations[i], fc.path); + if (mapping) { + if (!source) { + source = mapping.source; + } + if (mapping.source !== source) { + skip = true; + } + locs.push(mapping.loc); + mappedHits.push(hits[i]); + } + } + if (!skip && locs.length > 0) { + changes += 1; + mappedCoverage = coverageMapper(source); + mappedCoverage.addBranch(branchMeta.type, locs[0] /* XXX */, locs, mappedHits); + } + }); + + return changes > 0; +}; + +SourceMapTransformer.prototype.transform = function (coverageMap) { + var that = this, + finder = this.finder, + output = {}, + getMappedCoverage = function (file) { + if (!output[file]) { + output[file] = new MappedCoverage(file); + } + return output[file]; + }; + + coverageMap.files().forEach(function (file) { + var fc = coverageMap.fileCoverageFor(file), + sourceMap = finder(file), + changed; + + if (!sourceMap) { + output[file] = fc; + return; + } + + changed = that.processFile(fc, sourceMap, getMappedCoverage); + if (!changed) { + debug('File [' + file + '] ignored, nothing could be mapped'); + } + }); + return libCoverage.createCoverageMap(output); +}; + +module.exports = { + create: function (finder, opts) { + return new SourceMapTransformer(finder, opts); + } +}; diff --git a/node_modules/istanbul-lib-source-maps/node_modules/.bin/mkdirp b/node_modules/istanbul-lib-source-maps/node_modules/.bin/mkdirp new file mode 120000 index 000000000..91a5f623f --- /dev/null +++ b/node_modules/istanbul-lib-source-maps/node_modules/.bin/mkdirp @@ -0,0 +1 @@ +../../../mkdirp/bin/cmd.js
\ No newline at end of file diff --git a/node_modules/istanbul-lib-source-maps/node_modules/.bin/rimraf b/node_modules/istanbul-lib-source-maps/node_modules/.bin/rimraf new file mode 120000 index 000000000..632d6da23 --- /dev/null +++ b/node_modules/istanbul-lib-source-maps/node_modules/.bin/rimraf @@ -0,0 +1 @@ +../../../rimraf/bin.js
\ No newline at end of file diff --git a/node_modules/istanbul-lib-source-maps/package.json b/node_modules/istanbul-lib-source-maps/package.json new file mode 100644 index 000000000..51b06488d --- /dev/null +++ b/node_modules/istanbul-lib-source-maps/package.json @@ -0,0 +1,46 @@ +{ + "name": "istanbul-lib-source-maps", + "version": "1.2.0", + "description": "Source maps support for istanbul", + "author": "Krishnan Anantheswaran <kananthmail-github@yahoo.com>", + "main": "index.js", + "files": [ + "lib", + "index.js" + ], + "scripts": { + "pretest": "jshint index.js lib/ test/", + "test": "mocha" + }, + "dependencies": { + "debug": "^2.6.3", + "istanbul-lib-coverage": "^1.1.0", + "mkdirp": "^0.5.1", + "rimraf": "^2.6.1", + "source-map": "^0.5.3" + }, + "devDependencies": { + "babel-core": "^6.2.1", + "chai": "^3.4.1", + "is-windows": "^1.0.0", + "jshint": "^2.8.0", + "mocha": "^3.2.0", + "ts-node": "^2.0.0" + }, + "license": "BSD-3-Clause", + "bugs": { + "url": "https://github.com/istanbuljs/istanbul-lib-source-maps/issues" + }, + "homepage": "https://github.com/istanbuljs/istanbul-lib-source-maps#readme", + "repository": { + "type": "git", + "url": "git+ssh://git@github.com/istanbuljs/istanbul-lib-source-maps.git" + }, + "keywords": [ + "istanbul", + "sourcemaps", + "sourcemap", + "source", + "maps" + ] +} |