Fix.

node_modules/istanbul-lib-source-maps/lib/map-store.js

@@ -0,0 +1,189 @@
+/*
+ Copyright 2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const debug = require('debug')('istanbuljs');
+const SMC = require('source-map').SourceMapConsumer;
+const pathutils = require('./pathutils');
+const sourceStore = require('./source-store');
+const transformer = require('./transformer');
+
+/**
+ * Tracks source maps for registered files
+ */
+class MapStore {
+    /**
+     * @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
+     */
+    constructor(opts = {}) {
+        this.baseDir = opts.baseDir || null;
+        this.verbose = opts.verbose || false;
+        this.sourceStore = sourceStore.create(opts.sourceStore, {
+            tmpdir: opts.tmpdir
+        });
+        this.data = Object.create(null);
+    }
+
+    /**
+     * 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
+     */
+    registerURL(transformedFilePath, sourceMapUrl) {
+        const d = 'data:';
+
+        if (
+            sourceMapUrl.length > d.length &&
+            sourceMapUrl.substring(0, d.length) === d
+        ) {
+            const b64 = 'base64,';
+            const 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;
+        }
+
+        const dir = path.dirname(path.resolve(transformedFilePath));
+        const 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
+     */
+    registerMap(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.
+     */
+    transformCoverage(coverageMap) {
+        const sourceFinder = filePath => {
+            const content = this.sourceStore.getSource(filePath);
+            if (content !== null) {
+                return content;
+            }
+
+            if (path.isAbsolute(filePath)) {
+                return fs.readFileSync(filePath, 'utf8');
+            }
+
+            return fs.readFileSync(
+                pathutils.asAbsolute(filePath, this.baseDir)
+            );
+        };
+
+        coverageMap.files().forEach(file => {
+            const coverage = coverageMap.fileCoverageFor(file);
+            if (coverage.data.inputSourceMap && !this.data[file]) {
+                this.registerMap(file, coverage.data.inputSourceMap);
+            }
+        });
+
+        if (Object.keys(this.data).length === 0) {
+            return {
+                map: coverageMap,
+                sourceFinder
+            };
+        }
+
+        const mappedCoverage = transformer
+            .create(filePath => {
+                try {
+                    if (!this.data[filePath]) {
+                        return null;
+                    }
+
+                    const d = this.data[filePath];
+                    let obj;
+                    if (d.type === 'file') {
+                        obj = JSON.parse(fs.readFileSync(d.data, 'utf8'));
+                    } else if (d.type === 'encoded') {
+                        obj = JSON.parse(
+                            Buffer.from(d.data, 'base64').toString()
+                        );
+                    } else {
+                        obj = d.data;
+                    }
+
+                    const smc = new SMC(obj);
+                    smc.sources.forEach(s => {
+                        const content = smc.sourceContentFor(s);
+                        if (content) {
+                            const sourceFilePath = pathutils.relativeTo(
+                                s,
+                                filePath
+                            );
+                            this.sourceStore.registerSource(
+                                sourceFilePath,
+                                content
+                            );
+                        }
+                    });
+
+                    return smc;
+                } catch (error) {
+                    debug('Error returning source map for ' + filePath);
+                    debug(error.stack);
+
+                    return null;
+                }
+            })
+            .transform(coverageMap);
+
+        return {
+            map: mappedCoverage,
+            sourceFinder
+        };
+    }
+
+    /**
+     * Disposes temporary resources allocated by this map store
+     */
+    dispose() {
+        this.sourceStore.dispose();
+    }
+}
+
+module.exports = { MapStore };