.

node_modules/istanbul-lib-report/CHANGELOG.md

@@ -0,0 +1,137 @@
+# Change Log
+
+All notable changes to this project will be documented in this file.
+See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
+
+## [2.0.8](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-report@2.0.7...istanbul-lib-report@2.0.8) (2019-04-24)
+
+**Note:** Version bump only for package istanbul-lib-report
+
+
+
+
+
+## [2.0.7](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-report@2.0.6...istanbul-lib-report@2.0.7) (2019-04-09)
+
+**Note:** Version bump only for package istanbul-lib-report
+
+
+
+
+
+## [2.0.6](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-report@2.0.5...istanbul-lib-report@2.0.6) (2019-04-03)
+
+
+### Bug Fixes
+
+* Avoid corrupting HTML report's arrow png during copy ([#343](https://github.com/istanbuljs/istanbuljs/issues/343)) ([ce664c7](https://github.com/istanbuljs/istanbuljs/commit/ce664c7))
+
+
+
+
+
+## [2.0.5](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-report@2.0.4...istanbul-lib-report@2.0.5) (2019-03-12)
+
+**Note:** Version bump only for package istanbul-lib-report
+
+
+
+
+
+## [2.0.4](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-report@2.0.3...istanbul-lib-report@2.0.4) (2019-01-26)
+
+
+### Bug Fixes
+
+* nested summarizer error with no files ([#230](https://github.com/istanbuljs/istanbuljs/issues/230)) ([07724bf](https://github.com/istanbuljs/istanbuljs/commit/07724bf))
+
+
+
+
+
+<a name="2.0.3"></a>
+## [2.0.3](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-report@2.0.2...istanbul-lib-report@2.0.3) (2018-12-25)
+
+
+
+
+**Note:** Version bump only for package istanbul-lib-report
+
+<a name="2.0.2"></a>
+## [2.0.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-report@2.0.1...istanbul-lib-report@2.0.2) (2018-09-06)
+
+
+
+
+**Note:** Version bump only for package istanbul-lib-report
+
+<a name="2.0.1"></a>
+## [2.0.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-report@2.0.0...istanbul-lib-report@2.0.1) (2018-07-07)
+
+
+
+
+**Note:** Version bump only for package istanbul-lib-report
+
+<a name="2.0.0"></a>
+# [2.0.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-report@1.1.4...istanbul-lib-report@2.0.0) (2018-06-06)
+
+
+### Bug Fixes
+
+* use null prototype for map objects ([#177](https://github.com/istanbuljs/istanbuljs/issues/177)) ([9a5a30c](https://github.com/istanbuljs/istanbuljs/commit/9a5a30c))
+
+
+### BREAKING CHANGES
+
+* a null prototype is now used in several places rather than the default `{}` assignment.
+
+
+
+
+<a name="1.1.4"></a>
+## [1.1.4](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-report@1.1.3...istanbul-lib-report@1.1.4) (2018-03-04)
+
+
+
+
+**Note:** Version bump only for package istanbul-lib-report
+
+<a name="1.1.3"></a>
+## [1.1.3](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-report@1.1.2...istanbul-lib-report@1.1.3) (2018-02-13)
+
+
+
+
+**Note:** Version bump only for package istanbul-lib-report
+
+<a name="1.1.2"></a>
+## [1.1.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-report@1.1.1...istanbul-lib-report@1.1.2) (2017-10-21)
+
+
+### Bug Fixes
+
+* remove call to mkdirp.sync() in constructor so when used for ConsoleWriter ([#104](https://github.com/istanbuljs/istanbuljs/issues/104)) ([58eb79d](https://github.com/istanbuljs/istanbuljs/commit/58eb79d))
+
+
+
+
+<a name="1.1.1"></a>
+## [1.1.1](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-report@1.1.0...istanbul-lib-report@1.1.1) (2017-05-27)
+
+
+
+
+<a name="1.1.0"></a>
+# [1.1.0](https://github.com/istanbuljs/istanbul-lib-report/compare/istanbul-lib-report@1.0.0...istanbul-lib-report@1.1.0) (2017-04-29)
+
+
+### Features
+
+* once 100% line coverage is achieved, missing branch coverage is now shown in text report ([#45](https://github.com/istanbuljs/istanbuljs/issues/45)) ([8a809f8](https://github.com/istanbuljs/istanbul-lib-report/commit/8a809f8))
+
+
+
+
+<a name="1.0.0"></a>
+# [1.0.0](https://github.com/istanbuljs/istanbul-lib-report/compare/istanbul-lib-report@1.0.0-alpha.3...istanbul-lib-report@1.0.0) (2017-03-27)

node_modules/istanbul-lib-report/LICENSE

@@ -0,0 +1,24 @@
+Copyright 2012-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.

node_modules/istanbul-lib-report/README.md

@@ -0,0 +1,6 @@
+# istanbul-lib-report
+
+[![Greenkeeper badge](https://badges.greenkeeper.io/istanbuljs/istanbul-lib-report.svg)](https://greenkeeper.io/)
+[![Build Status](https://travis-ci.org/istanbuljs/istanbul-lib-report.svg?branch=master)](https://travis-ci.org/istanbuljs/istanbul-lib-report)
+
+Core reporting utilities for istanbul. Docs to follow.

node_modules/istanbul-lib-report/index.js

@@ -0,0 +1,56 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+'use strict';
+
+/**
+ * @module Exports
+ */
+
+const summarizer = require('./lib/summarizer');
+const context = require('./lib/context');
+const watermarks = require('./lib/watermarks');
+
+module.exports = {
+    /**
+     * returns a reporting context for the supplied options
+     * @param {Object} [opts=null] opts
+     * @returns {Context}
+     */
+    createContext(opts) {
+        return context.create(opts);
+    },
+    /**
+     * returns the default watermarks that would be used when not
+     * overridden
+     * @returns {Object} an object with `statements`, `functions`, `branches`,
+     *  and `line` keys. Each value is a 2 element array that has the low and
+     *  high watermark as percentages.
+     */
+    getDefaultWatermarks() {
+        return watermarks.getDefault();
+    }
+};
+/**
+ * standard summary functions
+ */
+module.exports.summarizers = {
+    /**
+     * a summarizer that creates a flat tree with one root node and bunch of
+     * files directly under it
+     */
+    flat: summarizer.createFlatSummary,
+    /**
+     * a summarizer that creates a hierarchical tree where the coverage summaries
+     * of each directly reflect the summaries of all subdirectories and files in it
+     */
+    nested: summarizer.createNestedSummary,
+    /**
+     * a summarizer that creates a tree in which directories are not nested.
+     * Every subdirectory is a child of the root node and only reflects the
+     * coverage numbers for the files in it (i.e. excludes subdirectories).
+     * This is the default summarizer.
+     */
+    pkg: summarizer.createPackageSummary
+};

node_modules/istanbul-lib-report/lib/context.js

@@ -0,0 +1,126 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+const fs = require('fs');
+const FileWriter = require('./file-writer');
+const XMLWriter = require('./xml-writer');
+const tree = require('./tree');
+const watermarks = require('./watermarks');
+
+function defaultSourceLookup(path) {
+    try {
+        return fs.readFileSync(path, 'utf8');
+    } catch (ex) {
+        throw new Error(
+            'Unable to lookup source: ' + path + '(' + ex.message + ')'
+        );
+    }
+}
+
+function mergeWatermarks(specified, defaults) {
+    specified = specified || {};
+    Object.keys(defaults).forEach(k => {
+        const specValue = specified[k];
+        if (
+            !(specValue && Array.isArray(specValue) && specValue.length === 2)
+        ) {
+            specified[k] = defaults[k];
+        }
+    });
+    return specified;
+}
+/**
+ * A reporting context that is passed to report implementations
+ * @param {Object} [opts=null] opts options
+ * @param {String} [opts.dir='coverage'] opts.dir the reporting directory
+ * @param {Object} [opts.watermarks=null] opts.watermarks watermarks for
+ *  statements, lines, branches and functions
+ * @param {Function} [opts.sourceFinder=fsLookup] opts.sourceFinder a
+ *  function that returns source code given a file path. Defaults to
+ *  filesystem lookups based on path.
+ * @constructor
+ */
+function Context(opts) {
+    opts = opts || {};
+    this.dir = opts.dir || 'coverage';
+    this.watermarks = mergeWatermarks(opts.watermarks, watermarks.getDefault());
+    this.sourceFinder = opts.sourceFinder || defaultSourceLookup;
+    this.data = {};
+}
+
+Object.defineProperty(Context.prototype, 'writer', {
+    enumerable: true,
+    get() {
+        if (!this.data.writer) {
+            this.data.writer = new FileWriter(this.dir);
+        }
+        return this.data.writer;
+    }
+});
+
+/**
+ * returns a FileWriter implementation for reporting use. Also available
+ * as the `writer` property on the context.
+ * @returns {Writer}
+ */
+Context.prototype.getWriter = function() {
+    return this.writer;
+};
+
+/**
+ * returns the source code for the specified file path or throws if
+ * the source could not be found.
+ * @param {String} filePath the file path as found in a file coverage object
+ * @returns {String} the source code
+ */
+Context.prototype.getSource = function(filePath) {
+    return this.sourceFinder(filePath);
+};
+
+/**
+ * returns the coverage class given a coverage
+ * types and a percentage value.
+ * @param {String} type - the coverage type, one of `statements`, `functions`,
+ *  `branches`, or `lines`
+ * @param {Number} value - the percentage value
+ * @returns {String} one of `high`, `medium` or `low`
+ */
+Context.prototype.classForPercent = function(type, value) {
+    const watermarks = this.watermarks[type];
+    if (!watermarks) {
+        return 'unknown';
+    }
+    if (value < watermarks[0]) {
+        return 'low';
+    }
+    if (value >= watermarks[1]) {
+        return 'high';
+    }
+    return 'medium';
+};
+/**
+ * returns an XML writer for the supplied content writer
+ * @param {ContentWriter} contentWriter the content writer to which the returned XML writer
+ *  writes data
+ * @returns {XMLWriter}
+ */
+Context.prototype.getXMLWriter = function(contentWriter) {
+    return new XMLWriter(contentWriter);
+};
+/**
+ * returns a full visitor given a partial one.
+ * @param {Object} partialVisitor a partial visitor only having the functions of
+ *  interest to the caller. These functions are called with a scope that is the
+ *  supplied object.
+ * @returns {Visitor}
+ */
+Context.prototype.getVisitor = function(partialVisitor) {
+    return new tree.Visitor(partialVisitor);
+};
+
+module.exports = {
+    create(opts) {
+        return new Context(opts);
+    }
+};

node_modules/istanbul-lib-report/lib/file-writer.js

@@ -0,0 +1,194 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+const util = require('util');
+const path = require('path');
+const fs = require('fs');
+const mkdirp = require('make-dir');
+const supportsColor = require('supports-color');
+const isAbsolute =
+    path.isAbsolute ||
+    /* istanbul ignore next */ function(p) {
+        return path.resolve(p) === path.normalize(p);
+    };
+
+/**
+ * abstract interface for writing content
+ * @class ContentWriter
+ * @constructor
+ */
+/* istanbul ignore next: abstract class */
+function ContentWriter() {}
+
+/**
+ * writes a string as-is to the destination
+ * @param {String} str the string to write
+ */
+/* istanbul ignore next: abstract class */
+ContentWriter.prototype.write = function() {
+    throw new Error('write: must be overridden');
+};
+
+/**
+ * returns the colorized version of a string. Typically,
+ * content writers that write to files will return the
+ * same string and ones writing to a tty will wrap it in
+ * appropriate escape sequences.
+ * @param {String} str the string to colorize
+ * @param {String} clazz one of `high`, `medium` or `low`
+ * @returns {String} the colorized form of the string
+ */
+ContentWriter.prototype.colorize = function(str /*, clazz*/) {
+    return str;
+};
+
+/**
+ * writes a string appended with a newline to the destination
+ * @param {String} str the string to write
+ */
+ContentWriter.prototype.println = function(str) {
+    this.write(str + '\n');
+};
+
+/**
+ * closes this content writer. Should be called after all writes are complete.
+ */
+ContentWriter.prototype.close = function() {};
+
+/**
+ * a content writer that writes to a file
+ * @param {Number} fd - the file descriptor
+ * @extends ContentWriter
+ * @constructor
+ */
+function FileContentWriter(fd) {
+    this.fd = fd;
+}
+util.inherits(FileContentWriter, ContentWriter);
+
+FileContentWriter.prototype.write = function(str) {
+    fs.writeSync(this.fd, str);
+};
+
+FileContentWriter.prototype.close = function() {
+    fs.closeSync(this.fd);
+};
+
+/**
+ * a content writer that writes to the console
+ * @extends ContentWriter
+ * @constructor
+ */
+function ConsoleWriter() {}
+util.inherits(ConsoleWriter, ContentWriter);
+
+// allow stdout to be captured for tests.
+let capture = false;
+let output = '';
+ConsoleWriter.prototype.write = function(str) {
+    if (capture) {
+        output += str;
+    } else {
+        process.stdout.write(str);
+    }
+};
+
+ConsoleWriter.prototype.colorize = function(str, clazz) {
+    const colors = {
+        low: '31;1',
+        medium: '33;1',
+        high: '32;1'
+    };
+
+    /* istanbul ignore next: different modes for CI and local */
+    if (supportsColor.stdout && colors[clazz]) {
+        return '\u001b[' + colors[clazz] + 'm' + str + '\u001b[0m';
+    }
+    return str;
+};
+
+/**
+ * utility for writing files under a specific directory
+ * @class FileWriter
+ * @param {String} baseDir the base directory under which files should be written
+ * @constructor
+ */
+function FileWriter(baseDir) {
+    if (!baseDir) {
+        throw new Error('baseDir must be specified');
+    }
+    this.baseDir = baseDir;
+}
+
+/**
+ * static helpers for capturing stdout report output;
+ * super useful for tests!
+ */
+FileWriter.startCapture = function() {
+    capture = true;
+};
+FileWriter.stopCapture = function() {
+    capture = false;
+};
+FileWriter.getOutput = function() {
+    return output;
+};
+FileWriter.resetOutput = function() {
+    output = '';
+};
+
+/**
+ * returns a FileWriter that is rooted at the supplied subdirectory
+ * @param {String} subdir the subdirectory under which to root the
+ *  returned FileWriter
+ * @returns {FileWriter}
+ */
+FileWriter.prototype.writerForDir = function(subdir) {
+    if (isAbsolute(subdir)) {
+        throw new Error(
+            'Cannot create subdir writer for absolute path: ' + subdir
+        );
+    }
+    return new FileWriter(this.baseDir + '/' + subdir);
+};
+/**
+ * copies a file from a source directory to a destination name
+ * @param {String} source path to source file
+ * @param {String} dest relative path to destination file
+ * @param {String} [header=undefined] optional text to prepend to destination
+ *  (e.g., an "this file is autogenerated" comment, copyright notice, etc.)
+ */
+FileWriter.prototype.copyFile = function(source, dest, header) {
+    if (isAbsolute(dest)) {
+        throw new Error('Cannot write to absolute path: ' + dest);
+    }
+    dest = path.resolve(this.baseDir, dest);
+    mkdirp.sync(path.dirname(dest));
+    let contents;
+    if (header) {
+        contents = header + fs.readFileSync(source, 'utf8');
+    } else {
+        contents = fs.readFileSync(source);
+    }
+    fs.writeFileSync(dest, contents);
+};
+/**
+ * returns a content writer for writing content to the supplied file.
+ * @param {String|null} file the relative path to the file or the special
+ *  values `"-"` or `null` for writing to the console
+ * @returns {ContentWriter}
+ */
+FileWriter.prototype.writeFile = function(file) {
+    if (file === null || file === '-') {
+        return new ConsoleWriter();
+    }
+    if (isAbsolute(file)) {
+        throw new Error('Cannot write to absolute path: ' + file);
+    }
+    file = path.resolve(this.baseDir, file);
+    mkdirp.sync(path.dirname(file));
+    return new FileContentWriter(fs.openSync(file, 'w'));
+};
+
+module.exports = FileWriter;

node_modules/istanbul-lib-report/lib/path.js

@@ -0,0 +1,159 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+'use strict';
+
+const path = require('path');
+let parsePath = path.parse;
+let SEP = path.sep || /* istanbul ignore next */ '/';
+const origParser = parsePath;
+const origSep = SEP;
+
+function makeRelativeNormalizedPath(str, sep) {
+    const parsed = parsePath(str);
+    let root = parsed.root;
+    let dir;
+    let file = parsed.base;
+    let quoted;
+    let pos;
+
+    // handle a weird windows case separately
+    if (sep === '\\') {
+        pos = root.indexOf(':\\');
+        if (pos >= 0) {
+            root = root.substring(0, pos + 2);
+        }
+    }
+    dir = parsed.dir.substring(root.length);
+
+    if (str === '') {
+        return [];
+    }
+
+    if (sep !== '/') {
+        quoted = new RegExp(sep.replace(/\W/g, '\\$&'), 'g');
+        dir = dir.replace(quoted, '/');
+        file = file.replace(quoted, '/'); // excessively paranoid?
+    }
+
+    if (dir !== '') {
+        dir = dir + '/' + file;
+    } else {
+        dir = file;
+    }
+    if (dir.substring(0, 1) === '/') {
+        dir = dir.substring(1);
+    }
+    dir = dir.split(/\/+/);
+    return dir;
+}
+
+function Path(strOrArray) {
+    if (Array.isArray(strOrArray)) {
+        this.v = strOrArray;
+    } else if (typeof strOrArray === 'string') {
+        this.v = makeRelativeNormalizedPath(strOrArray, SEP);
+    } else {
+        throw new Error(
+            'Invalid Path argument must be string or array:' + strOrArray
+        );
+    }
+}
+
+Path.prototype.toString = function() {
+    return this.v.join('/');
+};
+
+Path.prototype.hasParent = function() {
+    return this.v.length > 0;
+};
+
+Path.prototype.parent = function() {
+    if (!this.hasParent()) {
+        throw new Error('Unable to get parent for 0 elem path');
+    }
+    const p = this.v.slice();
+    p.pop();
+    return new Path(p);
+};
+
+Path.prototype.elements = function() {
+    return this.v.slice();
+};
+
+Path.prototype.contains = function(other) {
+    let i;
+    if (other.length > this.length) {
+        return false;
+    }
+    for (i = 0; i < other.length; i += 1) {
+        if (this.v[i] !== other.v[i]) {
+            return false;
+        }
+    }
+    return true;
+};
+
+Path.prototype.ancestorOf = function(other) {
+    return other.contains(this) && other.length !== this.length;
+};
+
+Path.prototype.descendantOf = function(other) {
+    return this.contains(other) && other.length !== this.length;
+};
+
+Path.prototype.commonPrefixPath = function(other) {
+    const len = this.length > other.length ? other.length : this.length;
+    let i;
+    const ret = [];
+
+    for (i = 0; i < len; i += 1) {
+        if (this.v[i] === other.v[i]) {
+            ret.push(this.v[i]);
+        } else {
+            break;
+        }
+    }
+    return new Path(ret);
+};
+
+['push', 'pop', 'shift', 'unshift', 'splice'].forEach(f => {
+    Path.prototype[f] = function(...args) {
+        const v = this.v;
+        return v[f](...args);
+    };
+});
+
+Path.compare = function(a, b) {
+    const al = a.length;
+    const bl = b.length;
+    if (al < bl) {
+        return -1;
+    }
+    if (al > bl) {
+        return 1;
+    }
+    const astr = a.toString();
+    const bstr = b.toString();
+    return astr < bstr ? -1 : astr > bstr ? 1 : 0;
+};
+
+Object.defineProperty(Path.prototype, 'length', {
+    enumerable: true,
+    get() {
+        return this.v.length;
+    }
+});
+
+module.exports = Path;
+Path.tester = {
+    setParserAndSep(p, sep) {
+        parsePath = p;
+        SEP = sep;
+    },
+    reset() {
+        parsePath = origParser;
+        SEP = origSep;
+    }
+};

node_modules/istanbul-lib-report/lib/summarizer.js

@@ -0,0 +1,285 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+'use strict';
+
+const util = require('util');
+const coverage = require('istanbul-lib-coverage');
+const Path = require('./path');
+const tree = require('./tree');
+const BaseNode = tree.Node;
+const BaseTree = tree.Tree;
+
+function ReportNode(path, fileCoverage) {
+    this.path = path;
+    this.parent = null;
+    this.fileCoverage = fileCoverage;
+    this.children = [];
+}
+
+util.inherits(ReportNode, BaseNode);
+
+ReportNode.prototype.addChild = function(child) {
+    child.parent = this;
+    this.children.push(child);
+};
+
+ReportNode.prototype.asRelative = function(p) {
+    /* istanbul ignore if */
+    if (p.substring(0, 1) === '/') {
+        return p.substring(1);
+    }
+    return p;
+};
+
+ReportNode.prototype.getQualifiedName = function() {
+    return this.asRelative(this.path.toString());
+};
+
+ReportNode.prototype.getRelativeName = function() {
+    const parent = this.getParent();
+    const myPath = this.path;
+    let relPath;
+    let i;
+    const parentPath = parent ? parent.path : new Path([]);
+    if (parentPath.ancestorOf(myPath)) {
+        relPath = new Path(myPath.elements());
+        for (i = 0; i < parentPath.length; i += 1) {
+            relPath.shift();
+        }
+        return this.asRelative(relPath.toString());
+    }
+    return this.asRelative(this.path.toString());
+};
+
+ReportNode.prototype.getParent = function() {
+    return this.parent;
+};
+
+ReportNode.prototype.getChildren = function() {
+    return this.children;
+};
+
+ReportNode.prototype.isSummary = function() {
+    return !this.fileCoverage;
+};
+
+ReportNode.prototype.getFileCoverage = function() {
+    return this.fileCoverage;
+};
+
+ReportNode.prototype.getCoverageSummary = function(filesOnly) {
+    const cacheProp = 'c_' + (filesOnly ? 'files' : 'full');
+    let summary;
+
+    if (this.hasOwnProperty(cacheProp)) {
+        return this[cacheProp];
+    }
+
+    if (!this.isSummary()) {
+        summary = this.getFileCoverage().toSummary();
+    } else {
+        let count = 0;
+        summary = coverage.createCoverageSummary();
+        this.getChildren().forEach(child => {
+            if (filesOnly && child.isSummary()) {
+                return;
+            }
+            count += 1;
+            summary.merge(child.getCoverageSummary(filesOnly));
+        });
+        if (count === 0 && filesOnly) {
+            summary = null;
+        }
+    }
+    this[cacheProp] = summary;
+    return summary;
+};
+
+function treeFor(root, childPrefix) {
+    const tree = new BaseTree();
+    const maybePrefix = function(node) {
+        if (childPrefix && !node.isRoot()) {
+            node.path.unshift(childPrefix);
+        }
+    };
+    tree.getRoot = function() {
+        return root;
+    };
+    const visitor = {
+        onDetail(node) {
+            maybePrefix(node);
+        },
+        onSummary(node) {
+            maybePrefix(node);
+            node.children.sort((a, b) => {
+                const astr = a.path.toString();
+                const bstr = b.path.toString();
+                return astr < bstr
+                    ? -1
+                    : astr > bstr
+                    ? 1
+                    : /* istanbul ignore next */ 0;
+            });
+        }
+    };
+    tree.visit(visitor);
+    return tree;
+}
+
+function findCommonParent(paths) {
+    if (paths.length === 0) {
+        return new Path([]);
+    }
+    let common = paths[0];
+    let i;
+
+    for (i = 1; i < paths.length; i += 1) {
+        common = common.commonPrefixPath(paths[i]);
+        if (common.length === 0) {
+            break;
+        }
+    }
+    return common;
+}
+
+function toInitialList(coverageMap) {
+    const ret = [];
+    coverageMap.files().forEach(filePath => {
+        const p = new Path(filePath);
+        const coverage = coverageMap.fileCoverageFor(filePath);
+        ret.push({
+            filePath,
+            path: p,
+            fileCoverage: coverage
+        });
+    });
+
+    const commonParent = findCommonParent(ret.map(o => o.path.parent()));
+    if (commonParent.length > 0) {
+        ret.forEach(o => {
+            o.path.splice(0, commonParent.length);
+        });
+    }
+    return {
+        list: ret,
+        commonParent
+    };
+}
+
+function toDirParents(list) {
+    const nodeMap = Object.create(null);
+    const parentNodeList = [];
+    list.forEach(o => {
+        const node = new ReportNode(o.path, o.fileCoverage);
+        const parentPath = o.path.parent();
+        let parent = nodeMap[parentPath.toString()];
+
+        if (!parent) {
+            parent = new ReportNode(parentPath);
+            nodeMap[parentPath.toString()] = parent;
+            parentNodeList.push(parent);
+        }
+        parent.addChild(node);
+    });
+    return parentNodeList;
+}
+
+function foldIntoParents(nodeList) {
+    const ret = [];
+    let i;
+    let j;
+
+    // sort by longest length first
+    nodeList.sort((a, b) => -1 * Path.compare(a.path, b.path));
+
+    for (i = 0; i < nodeList.length; i += 1) {
+        const first = nodeList[i];
+        let inserted = false;
+
+        for (j = i + 1; j < nodeList.length; j += 1) {
+            const second = nodeList[j];
+            if (second.path.ancestorOf(first.path)) {
+                second.addChild(first);
+                inserted = true;
+                break;
+            }
+        }
+
+        if (!inserted) {
+            ret.push(first);
+        }
+    }
+    return ret;
+}
+
+function createRoot() {
+    return new ReportNode(new Path([]));
+}
+
+function createNestedSummary(coverageMap) {
+    const flattened = toInitialList(coverageMap);
+    const dirParents = toDirParents(flattened.list);
+    const topNodes = foldIntoParents(dirParents);
+
+    if (topNodes.length === 0) {
+        return treeFor(new ReportNode(new Path([])));
+    }
+
+    if (topNodes.length === 1) {
+        return treeFor(topNodes[0]);
+    }
+
+    const root = createRoot();
+    topNodes.forEach(node => {
+        root.addChild(node);
+    });
+    return treeFor(root);
+}
+
+function createPackageSummary(coverageMap) {
+    const flattened = toInitialList(coverageMap);
+    const dirParents = toDirParents(flattened.list);
+    const common = flattened.commonParent;
+    let prefix;
+    let root;
+
+    if (dirParents.length === 1) {
+        root = dirParents[0];
+    } else {
+        root = createRoot();
+        // if one of the dirs is itself the root,
+        // then we need to create a top-level dir
+        dirParents.forEach(dp => {
+            if (dp.path.length === 0) {
+                prefix = 'root';
+            }
+        });
+        if (prefix && common.length > 0) {
+            prefix = common.elements()[common.elements().length - 1];
+        }
+        dirParents.forEach(node => {
+            root.addChild(node);
+        });
+    }
+    return treeFor(root, prefix);
+}
+
+function createFlatSummary(coverageMap) {
+    const flattened = toInitialList(coverageMap);
+    const list = flattened.list;
+    const root = createRoot();
+
+    list.forEach(o => {
+        const node = new ReportNode(o.path, o.fileCoverage);
+        root.addChild(node);
+    });
+    return treeFor(root);
+}
+
+module.exports = {
+    createNestedSummary,
+    createPackageSummary,
+    createFlatSummary
+};

node_modules/istanbul-lib-report/lib/tree.js

@@ -0,0 +1,159 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+'use strict';
+
+const util = require('util');
+/**
+ * An object with methods that are called during the traversal of the coverage tree.
+ * A visitor has the following methods that are called during tree traversal.
+ *
+ *   * `onStart(root, state)` - called before traversal begins
+ *   * `onSummary(node, state)` - called for every summary node
+ *   * `onDetail(node, state)` - called for every detail node
+ *   * `onSummaryEnd(node, state)` - called after all children have been visited for
+ *      a summary node.
+ *   * `onEnd(root, state)` - called after traversal ends
+ *
+ * @param delegate - a partial visitor that only implements the methods of interest
+ *  The visitor object supplies the missing methods as noops. For example, reports
+ *  that only need the final coverage summary need implement `onStart` and nothing
+ *  else. Reports that use only detailed coverage information need implement `onDetail`
+ *  and nothing else.
+ * @constructor
+ */
+function Visitor(delegate) {
+    this.delegate = delegate;
+}
+
+['Start', 'End', 'Summary', 'SummaryEnd', 'Detail'].forEach(k => {
+    const f = 'on' + k;
+    Visitor.prototype[f] = function(node, state) {
+        if (this.delegate[f] && typeof this.delegate[f] === 'function') {
+            this.delegate[f].call(this.delegate, node, state);
+        }
+    };
+});
+
+function CompositeVisitor(visitors) {
+    if (!Array.isArray(visitors)) {
+        visitors = [visitors];
+    }
+    this.visitors = visitors.map(v => {
+        if (v instanceof Visitor) {
+            return v;
+        }
+        return new Visitor(v);
+    });
+}
+
+util.inherits(CompositeVisitor, Visitor);
+
+['Start', 'Summary', 'SummaryEnd', 'Detail', 'End'].forEach(k => {
+    const f = 'on' + k;
+    CompositeVisitor.prototype[f] = function(node, state) {
+        this.visitors.forEach(v => {
+            v[f](node, state);
+        });
+    };
+});
+
+function Node() {}
+
+/* istanbul ignore next: abstract method */
+Node.prototype.getQualifiedName = function() {
+    throw new Error('getQualifiedName must be overridden');
+};
+
+/* istanbul ignore next: abstract method */
+Node.prototype.getRelativeName = function() {
+    throw new Error('getRelativeName must be overridden');
+};
+
+/* istanbul ignore next: abstract method */
+Node.prototype.isRoot = function() {
+    return !this.getParent();
+};
+
+/* istanbul ignore next: abstract method */
+Node.prototype.getParent = function() {
+    throw new Error('getParent must be overridden');
+};
+
+/* istanbul ignore next: abstract method */
+Node.prototype.getChildren = function() {
+    throw new Error('getChildren must be overridden');
+};
+
+/* istanbul ignore next: abstract method */
+Node.prototype.isSummary = function() {
+    throw new Error('isSummary must be overridden');
+};
+
+/* istanbul ignore next: abstract method */
+Node.prototype.getCoverageSummary = function(/* filesOnly */) {
+    throw new Error('getCoverageSummary must be overridden');
+};
+
+/* istanbul ignore next: abstract method */
+Node.prototype.getFileCoverage = function() {
+    throw new Error('getFileCoverage must be overridden');
+};
+/**
+ * visit all nodes depth-first from this node down. Note that `onStart`
+ * and `onEnd` are never called on the visitor even if the current
+ * node is the root of the tree.
+ * @param visitor a full visitor that is called during tree traversal
+ * @param state optional state that is passed around
+ */
+Node.prototype.visit = function(visitor, state) {
+    if (this.isSummary()) {
+        visitor.onSummary(this, state);
+    } else {
+        visitor.onDetail(this, state);
+    }
+
+    this.getChildren().forEach(child => {
+        child.visit(visitor, state);
+    });
+
+    if (this.isSummary()) {
+        visitor.onSummaryEnd(this, state);
+    }
+};
+
+/**
+ * abstract base class for a coverage tree.
+ * @constructor
+ */
+function Tree() {}
+
+/**
+ * returns the root node of the tree
+ */
+/* istanbul ignore next: abstract method */
+Tree.prototype.getRoot = function() {
+    throw new Error('getRoot must be overridden');
+};
+
+/**
+ * visits the tree depth-first with the supplied partial visitor
+ * @param visitor - a potentially partial visitor
+ * @param state - the state to be passed around during tree traversal
+ */
+Tree.prototype.visit = function(visitor, state) {
+    if (!(visitor instanceof Visitor)) {
+        visitor = new Visitor(visitor);
+    }
+    visitor.onStart(this.getRoot(), state);
+    this.getRoot().visit(visitor, state);
+    visitor.onEnd(this.getRoot(), state);
+};
+
+module.exports = {
+    Tree,
+    Node,
+    Visitor,
+    CompositeVisitor
+};

node_modules/istanbul-lib-report/lib/watermarks.js

@@ -0,0 +1,14 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+module.exports = {
+    getDefault() {
+        return {
+            statements: [50, 80],
+            functions: [50, 80],
+            branches: [50, 80],
+            lines: [50, 80]
+        };
+    }
+};

node_modules/istanbul-lib-report/lib/xml-writer.js

@@ -0,0 +1,95 @@
+/*
+ Copyright 2012-2015, Yahoo Inc.
+ Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+const INDENT = '  ';
+
+/**
+ * a utility class to produce well-formed, indented XML
+ * @param {ContentWriter} contentWriter the content writer that this utility wraps
+ * @constructor
+ */
+function XMLWriter(contentWriter) {
+    this.cw = contentWriter;
+    this.stack = [];
+}
+
+function attrString(attrs) {
+    if (!attrs) {
+        return '';
+    }
+    const ret = [];
+    Object.keys(attrs).forEach(k => {
+        const v = attrs[k];
+        ret.push(k + '="' + v + '"');
+    });
+    return ret.length === 0 ? '' : ' ' + ret.join(' ');
+}
+
+XMLWriter.prototype.indent = function(str) {
+    return this.stack.map(() => INDENT).join('') + str;
+};
+
+/**
+ * writes the opening XML tag with the supplied attributes
+ * @param {String} name tag name
+ * @param {Object} [attrs=null] attrs attributes for the tag
+ */
+XMLWriter.prototype.openTag = function(name, attrs) {
+    const str = this.indent('<' + name + attrString(attrs) + '>');
+    this.cw.println(str);
+    this.stack.push(name);
+};
+
+/**
+ * closes an open XML tag.
+ * @param {String} name - tag name to close. This must match the writer's
+ *  notion of the tag that is currently open.
+ */
+XMLWriter.prototype.closeTag = function(name) {
+    if (this.stack.length === 0) {
+        throw new Error('Attempt to close tag ' + name + ' when not opened');
+    }
+    const stashed = this.stack.pop();
+    const str = '</' + name + '>';
+
+    if (stashed !== name) {
+        throw new Error(
+            'Attempt to close tag ' +
+                name +
+                ' when ' +
+                stashed +
+                ' was the one open'
+        );
+    }
+    this.cw.println(this.indent(str));
+};
+/**
+ * writes a tag and its value opening and closing it at the same time
+ * @param {String} name tag name
+ * @param {Object} [attrs=null] attrs tag attributes
+ * @param {String} [content=null] content optional tag content
+ */
+XMLWriter.prototype.inlineTag = function(name, attrs, content) {
+    let str = '<' + name + attrString(attrs);
+    if (content) {
+        str += '>' + content + '</' + name + '>';
+    } else {
+        str += '/>';
+    }
+    str = this.indent(str);
+    this.cw.println(str);
+};
+/**
+ * closes all open tags and ends the document
+ */
+XMLWriter.prototype.closeAll = function() {
+    this.stack
+        .slice()
+        .reverse()
+        .forEach(name => {
+            this.closeTag(name);
+        });
+};
+
+module.exports = XMLWriter;

node_modules/istanbul-lib-report/node_modules/supports-color/browser.js

@@ -0,0 +1,5 @@
+'use strict';
+module.exports = {
+	stdout: false,
+	stderr: false
+};

node_modules/istanbul-lib-report/node_modules/supports-color/index.js

@@ -0,0 +1,138 @@
+'use strict';
+const os = require('os');
+const hasFlag = require('has-flag');
+
+const {env} = process;
+
+let forceColor;
+if (hasFlag('no-color') ||
+	hasFlag('no-colors') ||
+	hasFlag('color=false') ||
+	hasFlag('color=never')) {
+	forceColor = 0;
+} else if (hasFlag('color') ||
+	hasFlag('colors') ||
+	hasFlag('color=true') ||
+	hasFlag('color=always')) {
+	forceColor = 1;
+}
+if ('FORCE_COLOR' in env) {
+	if (env.FORCE_COLOR === true || env.FORCE_COLOR === 'true') {
+		forceColor = 1;
+	} else if (env.FORCE_COLOR === false || env.FORCE_COLOR === 'false') {
+		forceColor = 0;
+	} else {
+		forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+	}
+}
+
+function translateLevel(level) {
+	if (level === 0) {
+		return false;
+	}
+
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
+
+function supportsColor(stream) {
+	if (forceColor === 0) {
+		return 0;
+	}
+
+	if (hasFlag('color=16m') ||
+		hasFlag('color=full') ||
+		hasFlag('color=truecolor')) {
+		return 3;
+	}
+
+	if (hasFlag('color=256')) {
+		return 2;
+	}
+
+	if (stream && !stream.isTTY && forceColor === undefined) {
+		return 0;
+	}
+
+	const min = forceColor || 0;
+
+	if (env.TERM === 'dumb') {
+		return min;
+	}
+
+	if (process.platform === 'win32') {
+		// Node.js 7.5.0 is the first version of Node.js to include a patch to
+		// libuv that enables 256 color output on Windows. Anything earlier and it
+		// won't work. However, here we target Node.js 8 at minimum as it is an LTS
+		// release, and Node.js 7 is not. Windows 10 build 10586 is the first Windows
+		// release that supports 256 colors. Windows 10 build 14931 is the first release
+		// that supports 16m/TrueColor.
+		const osRelease = os.release().split('.');
+		if (
+			Number(process.versions.node.split('.')[0]) >= 8 &&
+			Number(osRelease[0]) >= 10 &&
+			Number(osRelease[2]) >= 10586
+		) {
+			return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		}
+
+		return 1;
+	}
+
+	if ('CI' in env) {
+		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+			return 1;
+		}
+
+		return min;
+	}
+
+	if ('TEAMCITY_VERSION' in env) {
+		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	}
+
+	if (env.COLORTERM === 'truecolor') {
+		return 3;
+	}
+
+	if ('TERM_PROGRAM' in env) {
+		const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+		switch (env.TERM_PROGRAM) {
+			case 'iTerm.app':
+				return version >= 3 ? 3 : 2;
+			case 'Apple_Terminal':
+				return 2;
+			// No default
+		}
+	}
+
+	if (/-256(color)?$/i.test(env.TERM)) {
+		return 2;
+	}
+
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+		return 1;
+	}
+
+	if ('COLORTERM' in env) {
+		return 1;
+	}
+
+	return min;
+}
+
+function getSupportLevel(stream) {
+	const level = supportsColor(stream);
+	return translateLevel(level);
+}
+
+module.exports = {
+	supportsColor: getSupportLevel,
+	stdout: getSupportLevel(process.stdout),
+	stderr: getSupportLevel(process.stderr)
+};

node_modules/istanbul-lib-report/node_modules/supports-color/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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.

node_modules/istanbul-lib-report/node_modules/supports-color/package.json

@@ -0,0 +1,57 @@
+{
+	"name": "supports-color",
+	"version": "6.1.0",
+	"description": "Detect whether a terminal supports color",
+	"license": "MIT",
+	"repository": "chalk/supports-color",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=6"
+	},
+	"scripts": {
+		"test": "xo && ava"
+	},
+	"files": [
+		"index.js",
+		"browser.js"
+	],
+	"keywords": [
+		"color",
+		"colour",
+		"colors",
+		"terminal",
+		"console",
+		"cli",
+		"ansi",
+		"styles",
+		"tty",
+		"rgb",
+		"256",
+		"shell",
+		"xterm",
+		"command-line",
+		"support",
+		"supports",
+		"capability",
+		"detect",
+		"truecolor",
+		"16m"
+	],
+	"dependencies": {
+		"has-flag": "^3.0.0"
+	},
+	"devDependencies": {
+		"ava": "^0.25.0",
+		"import-fresh": "^2.0.0",
+		"xo": "^0.23.0"
+	},
+	"browser": "browser.js"
+
+,"_resolved": "https://registry.npmjs.org/supports-color/-/supports-color-6.1.0.tgz"
+,"_integrity": "sha512-qe1jfm1Mg7Nq/NSh6XE24gPXROEVsWHxC1LIx//XNlD9iw7YZQGjZNjYN7xGaEG6iKdA8EtNFW6R0gjnVXp+wQ=="
+,"_from": "supports-color@6.1.0"
+}

node_modules/istanbul-lib-report/node_modules/supports-color/readme.md

@@ -0,0 +1,85 @@
+# supports-color [![Build Status](https://travis-ci.org/chalk/supports-color.svg?branch=master)](https://travis-ci.org/chalk/supports-color)
+
+> Detect whether a terminal supports color
+
+---
+
+<div align="center">
+	<b>
+		<a href="https://tidelift.com/subscription/pkg/npm-supports-color?utm_source=npm-supports-color&utm_medium=referral&utm_campaign=readme">Get professional support for this package with a Tidelift subscription</a>
+	</b>
+	<br>
+	<sub>
+		Tidelift helps make open source sustainable for maintainers while giving companies<br>assurances about security, maintenance, and licensing for their dependencies.
+	</sub>
+</div>
+
+---
+
+
+## Install
+
+```
+$ npm install supports-color
+```
+
+
+## Usage
+
+```js
+const supportsColor = require('supports-color');
+
+if (supportsColor.stdout) {
+	console.log('Terminal stdout supports color');
+}
+
+if (supportsColor.stdout.has256) {
+	console.log('Terminal stdout supports 256 colors');
+}
+
+if (supportsColor.stderr.has16m) {
+	console.log('Terminal stderr supports 16 million colors (truecolor)');
+}
+```
+
+
+## API
+
+Returns an `Object` with a `stdout` and `stderr` property for testing either streams. Each property is an `Object`, or `false` if color is not supported.
+
+The `stdout`/`stderr` objects specifies a level of support for color through a `.level` property and a corresponding flag:
+
+- `.level = 1` and `.hasBasic = true`: Basic color support (16 colors)
+- `.level = 2` and `.has256 = true`: 256 color support
+- `.level = 3` and `.has16m = true`: Truecolor support (16 million colors)
+
+
+## Info
+
+It obeys the `--color` and `--no-color` CLI flags.
+
+For situations where using `--color` is not possible, use the environment variable `FORCE_COLOR=1` (level 1), `FORCE_COLOR=2` (level 2), or `FORCE_COLOR=3` (level 3) to forcefully enable color, or `FORCE_COLOR=0` to forcefully disable. The use of `FORCE_COLOR` overrides all other color support checks.
+
+Explicit 256/Truecolor mode can be enabled using the `--color=256` and `--color=16m` flags, respectively.
+
+
+## Security
+
+To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure.
+
+
+## Related
+
+- [supports-color-cli](https://github.com/chalk/supports-color-cli) - CLI for this module
+- [chalk](https://github.com/chalk/chalk) - Terminal string styling done right
+
+
+## Maintainers
+
+- [Sindre Sorhus](https://github.com/sindresorhus)
+- [Josh Junon](https://github.com/qix-)
+
+
+## License
+
+MIT

node_modules/istanbul-lib-report/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "istanbul-lib-report",
+  "version": "2.0.8",
+  "description": "Base reporting library for istanbul",
+  "author": "Krishnan Anantheswaran <kananthmail-github@yahoo.com>",
+  "main": "index.js",
+  "files": [
+    "lib",
+    "index.js"
+  ],
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "istanbul-lib-coverage": "^2.0.5",
+    "make-dir": "^2.1.0",
+    "supports-color": "^6.1.0"
+  },
+  "license": "BSD-3-Clause",
+  "bugs": {
+    "url": "https://github.com/istanbuljs/istanbuljs/issues"
+  },
+  "homepage": "https://istanbul.js.org/",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:istanbuljs/istanbuljs.git"
+  },
+  "keywords": [
+    "istanbul",
+    "report",
+    "api",
+    "lib"
+  ],
+  "engines": {
+    "node": ">=6"
+  },
+  "gitHead": "90e60cc47833bb780680f916488ca24f0be36ca2"
+
+,"_resolved": "https://registry.npmjs.org/istanbul-lib-report/-/istanbul-lib-report-2.0.8.tgz"
+,"_integrity": "sha512-fHBeG573EIihhAblwgxrSenp0Dby6tJMFR/HvlerBsrCTD5bkUuoNtn3gVh29ZCS824cGGBPn7Sg7cNk+2xUsQ=="
+,"_from": "istanbul-lib-report@2.0.8"
+}