text: /*
   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 = 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
   */
  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
  };
  