.

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;