jebus/enviPy-bayer
1
0
Fork 0
forked from enviPath/enviPy
Code Issues Pull Requests 1 Actions Releases Activity

Current Dev State

Browse Source
This commit is contained in:
Tim Lorsbach
2025-06-23 20:13:54 +02:00
parent b4f9bb277d
commit ded50edaa2
22617 changed files with 4345095 additions and 174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

210
static/js/ketcher2/node_modules/nyc/node_modules/istanbul-lib-instrument/CHANGELOG.md generated vendored Normal file
View File

@ -0,0 +1,210 @@
# Change Log
All notable changes to this project will be documented in this file.
See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
<a name="1.8.0"></a>
# [1.8.0](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.5...istanbul-lib-instrument@1.8.0) (2017-09-05)
### Features
* add support for object-spread syntax ([#82](https://github.com/istanbuljs/istanbuljs/issues/82)) ([28d5566](https://github.com/istanbuljs/istanbuljs/commit/28d5566))
<a name="1.7.5"></a>
## [1.7.5](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.4...istanbul-lib-instrument@1.7.5) (2017-08-23)
### Bug Fixes
* name of function is now preserved or named exports ([#79](https://github.com/istanbuljs/istanbuljs/issues/79)) ([2ce8974](https://github.com/istanbuljs/istanbuljs/commit/2ce8974))
<a name="1.7.4"></a>
## [1.7.4](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.3...istanbul-lib-instrument@1.7.4) (2017-07-16)
### Bug Fixes
* update increment operator to appropriate expression type ([#74](https://github.com/istanbuljs/istanbuljs/issues/74)) ([dc69e66](https://github.com/istanbuljs/istanbuljs/commit/dc69e66))
<a name="1.7.3"></a>
## [1.7.3](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.2...istanbul-lib-instrument@1.7.3) (2017-06-25)
<a name="1.7.2"></a>
## [1.7.2](https://github.com/istanbuljs/istanbuljs/compare/istanbul-lib-instrument@1.7.1...istanbul-lib-instrument@1.7.2) (2017-05-27)
### Bug Fixes
* hoist statement counter for class variables, so that name is preserved ([#60](https://github.com/istanbuljs/istanbuljs/issues/60)) ([120d221](https://github.com/istanbuljs/istanbuljs/commit/120d221))
<a name="1.7.1"></a>
## [1.7.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.7.0...istanbul-lib-instrument@1.7.1) (2017-04-29)
### Bug Fixes
* don't instrument a file if it has already been instrumented ([#38](https://github.com/istanbuljs/istanbuljs/issues/38)) ([9c38e4e](https://github.com/istanbuljs/istanbul-lib-instrument/commit/9c38e4e))
<a name="1.7.0"></a>
# [1.7.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.6.2...istanbul-lib-instrument@1.7.0) (2017-03-27)
### Features
* use extended babylon support; adding features such as jsx ([#22](https://github.com/istanbuljs/istanbuljs/issues/22)) ([11c2438](https://github.com/istanbuljs/istanbul-lib-instrument/commit/11c2438))
<a name="1.6.2"></a>
## [1.6.2](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.6.1...istanbul-lib-instrument@1.6.2) (2017-03-22)
### Bug Fixes
* loc is sometimes not defined, so loc.start fails see [#99](https://github.com/istanbuljs/istanbuljs/issues/99) ([#18](https://github.com/istanbuljs/istanbuljs/issues/18)) ([df85ba6](https://github.com/istanbuljs/istanbul-lib-instrument/commit/df85ba6))
<a name="1.6.1"></a>
## [1.6.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.6.0...istanbul-lib-instrument@1.6.1) (2017-03-21)
<a name="1.6.0"></a>
# [1.6.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/istanbul-lib-instrument@1.4.2...istanbul-lib-instrument@1.6.0) (2017-03-21)
### Features
* adds line number property back to coverage.json ([b03b927](https://github.com/istanbuljs/istanbul-lib-instrument/commit/b03b927))
<a name="1.4.2"></a>
## [1.4.2](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.4.1...v1.4.2) (2017-01-04)
### Bug Fixes
* only hoist counter for a smaller subset of function declarations ([9f8931e](https://github.com/istanbuljs/istanbul-lib-instrument/commit/9f8931e))
<a name="1.4.1"></a>
## [1.4.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.4.0...v1.4.1) (2017-01-04)
### Bug Fixes
* address regression discussed in https://github.com/istanbuljs/babel-plugin-istanbul/issues/78 ([#40](https://github.com/istanbuljs/istanbul-lib-instrument/issues/40)) ([7f458a3](https://github.com/istanbuljs/istanbul-lib-instrument/commit/7f458a3))
<a name="1.4.0"></a>
# [1.4.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.3.1...v1.4.0) (2017-01-02)
### Features
* preserve inferred function names ([#38](https://github.com/istanbuljs/istanbul-lib-instrument/issues/38)) ([312666e](https://github.com/istanbuljs/istanbul-lib-instrument/commit/312666e))
<a name="1.3.1"></a>
## [1.3.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.3.0...v1.3.1) (2016-12-27)
### Bug Fixes
* function declaration assignment now retains function name ([#33](https://github.com/istanbuljs/istanbul-lib-instrument/issues/33)) ([2d781da](https://github.com/istanbuljs/istanbul-lib-instrument/commit/2d781da))
<a name="1.3.0"></a>
# [1.3.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.2.0...v1.3.0) (2016-11-10)
### Features
* allow an input source-map to be passed to instrumentSync() ([#23](https://github.com/istanbuljs/istanbul-lib-instrument/issues/23)) ([b08e4f5](https://github.com/istanbuljs/istanbul-lib-instrument/commit/b08e4f5))
<a name="1.2.0"></a>
# [1.2.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.4...v1.2.0) (2016-10-25)
### Features
* implement function to extract empty coverage data from an instrumented file ([#28](https://github.com/istanbuljs/istanbul-lib-instrument/issues/28)) ([06d0ef6](https://github.com/istanbuljs/istanbul-lib-instrument/commit/06d0ef6))
<a name="1.1.4"></a>
## [1.1.4](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.3...v1.1.4) (2016-10-17)
### Bug Fixes
* hoist coverage variable to very top of file ([#26](https://github.com/istanbuljs/istanbul-lib-instrument/issues/26)) ([0225e8c](https://github.com/istanbuljs/istanbul-lib-instrument/commit/0225e8c))
<a name="1.1.3"></a>
## [1.1.3](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.2...v1.1.3) (2016-09-13)
### Performance Improvements
* simplify coverage variable naming https://github.com/istanbuljs/istanbul-lib-instrument/pull/24 ([7252aae](https://github.com/istanbuljs/istanbul-lib-instrument/commit/7252aae))
<a name="1.1.2"></a>
## [1.1.2](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.1...v1.1.2) (2016-09-08)
### Performance Improvements
* use zero-based numeric indices for much faster instrumented code ([#22](https://github.com/istanbuljs/istanbul-lib-instrument/issues/22)) ([5b401f5](https://github.com/istanbuljs/istanbul-lib-instrument/commit/5b401f5))
<a name="1.1.1"></a>
## [1.1.1](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.0...v1.1.1) (2016-08-30)
### Bug Fixes
* upgrade istanbul-lib-coverage ([eb9b1f6](https://github.com/istanbuljs/istanbul-lib-instrument/commit/eb9b1f6))
<a name="1.1.0"></a>
# [1.1.0](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.1.0-alpha.4...v1.1.0) (2016-08-11)
### Bug Fixes
* guard against invalid loc ([#16](https://github.com/istanbuljs/istanbul-lib-instrument/issues/16)) ([23ebfc3](https://github.com/istanbuljs/istanbul-lib-instrument/commit/23ebfc3))
<a name="1.1.0-alpha.4"></a>
# [1.1.0-alpha.4](https://github.com/istanbuljs/istanbul-lib-instrument/compare/v1.0.0-alpha.5...v1.1.0-alpha.4) (2016-07-20)
### Bug Fixes
* require more performant babel-generator ([#15](https://github.com/istanbuljs/istanbul-lib-instrument/issues/15)) ([21b2563](https://github.com/istanbuljs/istanbul-lib-instrument/commit/21b2563))

24
static/js/ketcher2/node_modules/nyc/node_modules/istanbul-lib-instrument/LICENSE generated vendored Normal file
View File

@ -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.

24
static/js/ketcher2/node_modules/nyc/node_modules/istanbul-lib-instrument/README.md generated vendored Normal file
View File

@ -0,0 +1,24 @@
istanbul-lib-instrument
-----------------------
[![Build Status](https://travis-ci.org/istanbuljs/istanbul-lib-instrument.svg?branch=master)](https://travis-ci.org/istanbuljs/istanbul-lib-instrument)
Istanbul instrumenter library.
Version 1.1.x now implements instrumentation using `Babel`. The implementation is inspired
by prior art by @dtinth as demonstrated in the `__coverage__` babel plugin.
It provides 2 "modes" of instrumentation.
* The old API that is mostly unchanged (except for incompatibilities noted) and
performs the instrumentation using babel as a library.
* A `programVisitor` function for the Babel AST that can be used by a Babel plugin
to emit instrumentation for ES6 code directly without any source map
processing. This is the preferred path for babel users. The Babel plugin is
called `babel-plugin-istanbul`.
Incompatibilities and changes to instrumentation behavior can be found in
[v0-changes.md](v0-changes.md).

19
static/js/ketcher2/node_modules/nyc/node_modules/istanbul-lib-instrument/dist/constants.js generated vendored Normal file
View File

@ -0,0 +1,19 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.MAGIC_VALUE = exports.MAGIC_KEY = exports.SHA = undefined;
var _semver = require('semver');
var _package = require('../package.json');
var _crypto = require('crypto');
// function to use for creating hashes
var SHA = exports.SHA = 'sha1';
// name of coverage data magic key
var MAGIC_KEY = exports.MAGIC_KEY = '_coverageSchema';
// name of coverage data magic value
var MAGIC_VALUE = exports.MAGIC_VALUE = (0, _crypto.createHash)(SHA).update(_package.name + '@' + (0, _semver.major)(_package.version)).digest('hex');

34
static/js/ketcher2/node_modules/nyc/node_modules/istanbul-lib-instrument/dist/index.js generated vendored Normal file
View File

@ -0,0 +1,34 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.readInitialCoverage = exports.programVisitor = exports.createInstrumenter = undefined;
var _instrumenter = require('./instrumenter');
var _instrumenter2 = _interopRequireDefault(_instrumenter);
var _visitor = require('./visitor');
var _visitor2 = _interopRequireDefault(_visitor);
var _readCoverage = require('./read-coverage');
var _readCoverage2 = _interopRequireDefault(_readCoverage);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
/**
* createInstrumenter creates a new instrumenter with the
* supplied options.
* @param {Object} opts - instrumenter options. See the documentation
* for the Instrumenter class.
*/
function createInstrumenter(opts) {
return new _instrumenter2.default(opts);
}
exports.createInstrumenter = createInstrumenter;
exports.programVisitor = _visitor2.default;
exports.readInitialCoverage = _readCoverage2.default;

207
static/js/ketcher2/node_modules/nyc/node_modules/istanbul-lib-instrument/dist/instrumenter.js generated vendored Normal file
View File

@ -0,0 +1,207 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /*
Copyright 2012-2015, Yahoo Inc.
Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
*/
var _babylon = require('babylon');
var babylon = _interopRequireWildcard(_babylon);
var _babelTypes = require('babel-types');
var t = _interopRequireWildcard(_babelTypes);
var _babelTraverse = require('babel-traverse');
var _babelTraverse2 = _interopRequireDefault(_babelTraverse);
var _babelGenerator = require('babel-generator');
var _babelGenerator2 = _interopRequireDefault(_babelGenerator);
var _visitor = require('./visitor');
var _visitor2 = _interopRequireDefault(_visitor);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function defaultOpts() {
return {
coverageVariable: "__coverage__",
preserveComments: false,
compact: true,
esModules: false,
autoWrap: false,
produceSourceMap: false,
sourceMapUrlCallback: null,
debug: false
};
}
/**
* Instrumenter is the public API for the instrument library.
* It is typically used for ES5 code. For ES6 code that you
* are already running under `babel` use the coverage plugin
* instead.
* @param {Object} opts optional.
* @param {string} [opts.coverageVariable=__coverage__] name of global coverage variable.
* @param {boolean} [opts.preserveComments=false] preserve comments in output
* @param {boolean} [opts.compact=true] generate compact code.
* @param {boolean} [opts.esModules=false] set to true to instrument ES6 modules.
* @param {boolean} [opts.autoWrap=false] set to true to allow `return` statements outside of functions.
* @param {boolean} [opts.produceSourceMap=false] set to true to produce a source map for the instrumented code.
* @param {Function} [opts.sourceMapUrlCallback=null] a callback function that is called when a source map URL
* is found in the original code. This function is called with the source file name and the source map URL.
* @param {boolean} [opts.debug=false] - turn debugging on
*/
var Instrumenter = function () {
function Instrumenter() {
var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultOpts();
_classCallCheck(this, Instrumenter);
this.opts = this.normalizeOpts(opts);
this.fileCoverage = null;
this.sourceMap = null;
}
/**
* normalize options passed in and assign defaults.
* @param opts
* @private
*/
_createClass(Instrumenter, [{
key: 'normalizeOpts',
value: function normalizeOpts(opts) {
var normalize = function normalize(name, defaultValue) {
if (!opts.hasOwnProperty(name)) {
opts[name] = defaultValue;
}
};
var defOpts = defaultOpts();
Object.keys(defOpts).forEach(function (k) {
normalize(k, defOpts[k]);
});
return opts;
}
/**
* instrument the supplied code and track coverage against the supplied
* filename. It throws if invalid code is passed to it. ES5 and ES6 syntax
* is supported. To instrument ES6 modules, make sure that you set the
* `esModules` property to `true` when creating the instrumenter.
*
* @param {string} code - the code to instrument
* @param {string} filename - the filename against which to track coverage.
* @param {object} [inputSourceMap] - the source map that maps the not instrumented code back to it's original form.
* Is assigned to the coverage object and therefore, is available in the json output and can be used to remap the
* coverage to the untranspiled source.
* @returns {string} the instrumented code.
*/
}, {
key: 'instrumentSync',
value: function instrumentSync(code, filename, inputSourceMap) {
if (typeof code !== 'string') {
throw new Error('Code must be a string');
}
filename = filename || String(new Date().getTime()) + '.js';
var opts = this.opts;
var ast = babylon.parse(code, {
allowReturnOutsideFunction: opts.autoWrap,
sourceType: opts.esModules ? "module" : "script",
plugins: ['asyncGenerators', 'dynamicImport', 'objectRestSpread', 'flow', 'jsx']
});
var ee = (0, _visitor2.default)(t, filename, {
coverageVariable: opts.coverageVariable,
inputSourceMap: inputSourceMap
});
var output = {};
var visitor = {
Program: {
enter: ee.enter,
exit: function exit(path) {
output = ee.exit(path);
}
}
};
(0, _babelTraverse2.default)(ast, visitor);
var generateOptions = {
compact: opts.compact,
sourceMaps: opts.produceSourceMap,
sourceFileName: filename
};
var codeMap = (0, _babelGenerator2.default)(ast, generateOptions, code);
this.fileCoverage = output.fileCoverage;
this.sourceMap = codeMap.map;
var cb = this.opts.sourceMapUrlCallback;
if (cb && output.sourceMappingURL) {
cb(filename, output.sourceMappingURL);
}
return codeMap.code;
}
/**
* callback-style instrument method that calls back with an error
* as opposed to throwing one. Note that in the current implementation,
* the callback will be called in the same process tick and is not asynchronous.
*
* @param {string} code - the code to instrument
* @param {string} filename - the filename against which to track coverage.
* @param {Function} callback - the callback
* @param {Object} inputSourceMap - the source map that maps the not instrumented code back to it's original form.
* Is assigned to the coverage object and therefore, is available in the json output and can be used to remap the
* coverage to the untranspiled source.
*/
}, {
key: 'instrument',
value: function instrument(code, filename, callback, inputSourceMap) {
if (!callback && typeof filename === 'function') {
callback = filename;
filename = null;
}
try {
var out = this.instrumentSync(code, filename, inputSourceMap);
callback(null, out);
} catch (ex) {
callback(ex);
}
}
/**
* returns the file coverage object for the last file instrumented.
* @returns {Object} the file coverage object.
*/
}, {
key: 'lastFileCoverage',
value: function lastFileCoverage() {
return this.fileCoverage;
}
/**
* returns the source map produced for the last file instrumented.
* @returns {null|Object} the source map object.
*/
}, {
key: 'lastSourceMap',
value: function lastSourceMap() {
return this.sourceMap;
}
}]);
return Instrumenter;
}();
exports.default = Instrumenter;

78
static/js/ketcher2/node_modules/nyc/node_modules/istanbul-lib-instrument/dist/read-coverage.js generated vendored Normal file
View File

@ -0,0 +1,78 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = readInitialCoverage;
var _constants = require('./constants');
var _babylon = require('babylon');
var _babelTraverse = require('babel-traverse');
var _babelTraverse2 = _interopRequireDefault(_babelTraverse);
var _babelTypes = require('babel-types');
var t = _interopRequireWildcard(_babelTypes);
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function readInitialCoverage(code) {
if (typeof code !== 'string') {
throw new Error('Code must be a string');
}
// Parse as leniently as possible
var ast = (0, _babylon.parse)(code, {
allowImportExportEverywhere: true,
allowReturnOutsideFunction: true,
allowSuperOutsideMethod: true,
sourceType: "script", // I think ?
plugins: ["*"]
});
var covScope = void 0;
(0, _babelTraverse2.default)(ast, {
ObjectProperty: function ObjectProperty(path) {
var node = path.node;
if (!node.computed && t.isIdentifier(node.key) && node.key.name === _constants.MAGIC_KEY) {
var magicValue = path.get('value').evaluate();
if (!magicValue.confident || magicValue.value !== _constants.MAGIC_VALUE) {
return;
}
covScope = path.scope.getFunctionParent();
path.stop();
}
}
});
if (!covScope) {
return null;
}
var result = {};
var _arr = ['path', 'hash', 'gcv', 'coverageData'];
for (var _i = 0; _i < _arr.length; _i++) {
var key = _arr[_i];
var binding = covScope.getOwnBinding(key);
if (!binding) {
return null;
}
var valuePath = binding.path.get('init');
var value = valuePath.evaluate();
if (!value.confident) {
return null;
}
result[key] = value.value;
}
delete result.coverageData[_constants.MAGIC_KEY];
return result;
}

143
static/js/ketcher2/node_modules/nyc/node_modules/istanbul-lib-instrument/dist/source-coverage.js generated vendored Normal file
View File

@ -0,0 +1,143 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.SourceCoverage = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _istanbulLibCoverage = require('istanbul-lib-coverage');
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
function cloneLocation(loc) {
return {
start: {
line: loc && loc.start.line,
column: loc && loc.start.column
},
end: {
line: loc && loc.end.line,
column: loc && loc.end.column
}
};
}
/**
* SourceCoverage provides mutation methods to manipulate the structure of
* a file coverage object. Used by the instrumenter to create a full coverage
* object for a file incrementally.
*
* @private
* @param pathOrObj {String|Object} - see the argument for {@link FileCoverage}
* @extends FileCoverage
* @constructor
*/
var SourceCoverage = function (_classes$FileCoverage) {
_inherits(SourceCoverage, _classes$FileCoverage);
function SourceCoverage(pathOrObj) {
_classCallCheck(this, SourceCoverage);
var _this = _possibleConstructorReturn(this, (SourceCoverage.__proto__ || Object.getPrototypeOf(SourceCoverage)).call(this, pathOrObj));
_this.meta = {
last: {
s: 0,
f: 0,
b: 0
}
};
return _this;
}
_createClass(SourceCoverage, [{
key: 'newStatement',
value: function newStatement(loc) {
var s = this.meta.last.s;
this.data.statementMap[s] = cloneLocation(loc);
this.data.s[s] = 0;
this.meta.last.s += 1;
return s;
}
}, {
key: 'newFunction',
value: function newFunction(name, decl, loc) {
var f = this.meta.last.f;
name = name || '(anonymous_' + f + ')';
this.data.fnMap[f] = {
name: name,
decl: cloneLocation(decl),
loc: cloneLocation(loc),
// DEPRECATED: some legacy reports require this info.
line: loc && loc.start.line
};
this.data.f[f] = 0;
this.meta.last.f += 1;
return f;
}
}, {
key: 'newBranch',
value: function newBranch(type, loc) {
var b = this.meta.last.b;
this.data.b[b] = [];
this.data.branchMap[b] = {
loc: cloneLocation(loc),
type: type,
locations: [],
// DEPRECATED: some legacy reports require this info.
line: loc && loc.start.line
};
this.meta.last.b += 1;
return b;
}
}, {
key: 'addBranchPath',
value: function addBranchPath(name, location) {
var bMeta = this.data.branchMap[name],
counts = this.data.b[name];
/* istanbul ignore if: paranoid check */
if (!bMeta) {
throw new Error("Invalid branch " + name);
}
bMeta.locations.push(cloneLocation(location));
counts.push(0);
return counts.length - 1;
}
/**
* Assigns an input source map to the coverage that can be used
* to remap the coverage output to the original source
* @param sourceMap {object} the source map
*/
}, {
key: 'inputSourceMap',
value: function inputSourceMap(sourceMap) {
this.data.inputSourceMap = sourceMap;
}
}, {
key: 'freeze',
value: function freeze() {
// prune empty branches
var map = this.data.branchMap,
branches = this.data.b;
Object.keys(map).forEach(function (b) {
if (map[b].locations.length === 0) {
delete map[b];
delete branches[b];
}
});
}
}]);
return SourceCoverage;
}(_istanbulLibCoverage.classes.FileCoverage);
exports.SourceCoverage = SourceCoverage;

564
static/js/ketcher2/node_modules/nyc/node_modules/istanbul-lib-instrument/dist/visitor.js generated vendored Normal file
View File

@ -0,0 +1,564 @@
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _sourceCoverage = require('./source-coverage');
var _constants = require('./constants');
var _crypto = require('crypto');
var _babelTemplate = require('babel-template');
var _babelTemplate2 = _interopRequireDefault(_babelTemplate);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
// istanbul ignore comment pattern
var COMMENT_RE = /^\s*istanbul\s+ignore\s+(if|else|next)(?=\W|$)/;
// source map URL pattern
var SOURCE_MAP_RE = /[#@]\s*sourceMappingURL=(.*)\s*$/m;
// generate a variable name from hashing the supplied file path
function genVar(filename) {
var hash = (0, _crypto.createHash)(_constants.SHA);
hash.update(filename);
return 'cov_' + parseInt(hash.digest('hex').substr(0, 12), 16).toString(36);
}
// VisitState holds the state of the visitor, provides helper functions
// and is the `this` for the individual coverage visitors.
var VisitState = function () {
function VisitState(types, sourceFilePath, inputSourceMap) {
_classCallCheck(this, VisitState);
this.varName = genVar(sourceFilePath);
this.attrs = {};
this.nextIgnore = null;
this.cov = new _sourceCoverage.SourceCoverage(sourceFilePath);
if (typeof inputSourceMap !== "undefined") {
this.cov.inputSourceMap(inputSourceMap);
}
this.types = types;
this.sourceMappingURL = null;
}
// should we ignore the node? Yes, if specifically ignoring
// or if the node is generated.
_createClass(VisitState, [{
key: 'shouldIgnore',
value: function shouldIgnore(path) {
return this.nextIgnore || !path.node.loc;
}
// extract the ignore comment hint (next|if|else) or null
}, {
key: 'hintFor',
value: function hintFor(node) {
var hint = null;
if (node.leadingComments) {
node.leadingComments.forEach(function (c) {
var v = (c.value || /* istanbul ignore next: paranoid check */"").trim();
var groups = v.match(COMMENT_RE);
if (groups) {
hint = groups[1];
}
});
}
return hint;
}
// extract a source map URL from comments and keep track of it
}, {
key: 'maybeAssignSourceMapURL',
value: function maybeAssignSourceMapURL(node) {
var that = this;
var extractURL = function extractURL(comments) {
if (!comments) {
return;
}
comments.forEach(function (c) {
var v = (c.value || /* istanbul ignore next: paranoid check */"").trim();
var groups = v.match(SOURCE_MAP_RE);
if (groups) {
that.sourceMappingURL = groups[1];
}
});
};
extractURL(node.leadingComments);
extractURL(node.trailingComments);
}
// for these expressions the statement counter needs to be hoisted, so
// function name inference can be preserved
}, {
key: 'counterNeedsHoisting',
value: function counterNeedsHoisting(path) {
return path.isFunctionExpression() || path.isArrowFunctionExpression() || path.isClassExpression();
}
// all the generic stuff that needs to be done on enter for every node
}, {
key: 'onEnter',
value: function onEnter(path) {
var n = path.node;
this.maybeAssignSourceMapURL(n);
// if already ignoring, nothing more to do
if (this.nextIgnore !== null) {
return;
}
// check hint to see if ignore should be turned on
var hint = this.hintFor(n);
if (hint === 'next') {
this.nextIgnore = n;
return;
}
// else check custom node attribute set by a prior visitor
if (this.getAttr(path.node, 'skip-all') !== null) {
this.nextIgnore = n;
}
}
// all the generic stuff on exit of a node,
// including reseting ignores and custom node attrs
}, {
key: 'onExit',
value: function onExit(path) {
// restore ignore status, if needed
if (path.node === this.nextIgnore) {
this.nextIgnore = null;
}
// nuke all attributes for the node
delete path.node.__cov__;
}
// set a node attribute for the supplied node
}, {
key: 'setAttr',
value: function setAttr(node, name, value) {
node.__cov__ = node.__cov__ || {};
node.__cov__[name] = value;
}
// retrieve a node attribute for the supplied node or null
}, {
key: 'getAttr',
value: function getAttr(node, name) {
var c = node.__cov__;
if (!c) {
return null;
}
return c[name];
}
//
}, {
key: 'increase',
value: function increase(type, id, index) {
var T = this.types;
var wrap = index !== null
// If `index` present, turn `x` into `x[index]`.
? function (x) {
return T.memberExpression(x, T.numericLiteral(index), true);
} : function (x) {
return x;
};
return T.updateExpression('++', wrap(T.memberExpression(T.memberExpression(T.identifier(this.varName), T.identifier(type)), T.numericLiteral(id), true)));
}
}, {
key: 'insertCounter',
value: function insertCounter(path, increment) {
var T = this.types;
if (path.isBlockStatement()) {
path.node.body.unshift(T.expressionStatement(increment));
} else if (path.isStatement()) {
path.insertBefore(T.expressionStatement(increment));
} else if (this.counterNeedsHoisting(path) && T.isVariableDeclarator(path.parentPath)) {
// make an attempt to hoist the statement counter, so that
// function names are maintained.
var parent = path.parentPath.parentPath;
if (parent && T.isExportNamedDeclaration(parent.parentPath)) {
parent.parentPath.insertBefore(T.expressionStatement(increment));
} else if (parent && (T.isProgram(parent.parentPath) || T.isBlockStatement(parent.parentPath))) {
parent.insertBefore(T.expressionStatement(increment));
} else {
path.replaceWith(T.sequenceExpression([increment, path.node]));
}
} else /* istanbul ignore else: not expected */if (path.isExpression()) {
path.replaceWith(T.sequenceExpression([increment, path.node]));
} else {
console.error('Unable to insert counter for node type:', path.node.type);
}
}
}, {
key: 'insertStatementCounter',
value: function insertStatementCounter(path) {
/* istanbul ignore if: paranoid check */
if (!(path.node && path.node.loc)) {
return;
}
var index = this.cov.newStatement(path.node.loc);
var increment = this.increase('s', index, null);
this.insertCounter(path, increment);
}
}, {
key: 'insertFunctionCounter',
value: function insertFunctionCounter(path) {
var T = this.types;
/* istanbul ignore if: paranoid check */
if (!(path.node && path.node.loc)) {
return;
}
var n = path.node;
var dloc = null;
// get location for declaration
switch (n.type) {
case "FunctionDeclaration":
/* istanbul ignore else: paranoid check */
if (n.id) {
dloc = n.id.loc;
}
break;
case "FunctionExpression":
if (n.id) {
dloc = n.id.loc;
}
break;
}
if (!dloc) {
dloc = {
start: n.loc.start,
end: { line: n.loc.start.line, column: n.loc.start.column + 1 }
};
}
var name = path.node.id ? path.node.id.name : path.node.name;
var index = this.cov.newFunction(name, dloc, path.node.body.loc);
var increment = this.increase('f', index, null);
var body = path.get('body');
/* istanbul ignore else: not expected */
if (body.isBlockStatement()) {
body.node.body.unshift(T.expressionStatement(increment));
} else {
console.error('Unable to process function body node type:', path.node.type);
}
}
}, {
key: 'getBranchIncrement',
value: function getBranchIncrement(branchName, loc) {
var index = this.cov.addBranchPath(branchName, loc);
return this.increase('b', branchName, index);
}
}, {
key: 'insertBranchCounter',
value: function insertBranchCounter(path, branchName, loc) {
var increment = this.getBranchIncrement(branchName, loc || path.node.loc);
this.insertCounter(path, increment);
}
}, {
key: 'findLeaves',
value: function findLeaves(node, accumulator, parent, property) {
if (!node) {
return;
}
if (node.type === "LogicalExpression") {
var hint = this.hintFor(node);
if (hint !== 'next') {
this.findLeaves(node.left, accumulator, node, 'left');
this.findLeaves(node.right, accumulator, node, 'right');
}
} else {
accumulator.push({
node: node,
parent: parent,
property: property
});
}
}
}]);
return VisitState;
}();
// generic function that takes a set of visitor methods and
// returns a visitor object with `enter` and `exit` properties,
// such that:
//
// * standard entry processing is done
// * the supplied visitors are called only when ignore is not in effect
// This relieves them from worrying about ignore states and generated nodes.
// * standard exit processing is done
//
function entries() {
var enter = Array.prototype.slice.call(arguments);
// the enter function
var wrappedEntry = function wrappedEntry(path, node) {
this.onEnter(path);
if (this.shouldIgnore(path)) {
return;
}
var that = this;
enter.forEach(function (e) {
e.call(that, path, node);
});
};
var exit = function exit(path, node) {
this.onExit(path, node);
};
return {
enter: wrappedEntry,
exit: exit
};
}
function coverStatement(path) {
this.insertStatementCounter(path);
}
/* istanbul ignore next: no node.js support */
function coverAssignmentPattern(path) {
var n = path.node;
var b = this.cov.newBranch('default-arg', n.loc);
this.insertBranchCounter(path.get('right'), b);
}
function coverFunction(path) {
this.insertFunctionCounter(path);
}
function coverVariableDeclarator(path) {
this.insertStatementCounter(path.get('init'));
}
function skipInit(path) {
if (path.node.init) {
this.setAttr(path.node.init, 'skip-all', true);
}
}
function makeBlock(path) {
var T = this.types;
if (!path.node) {
path.replaceWith(T.blockStatement([]));
}
if (!path.isBlockStatement()) {
path.replaceWith(T.blockStatement([path.node]));
path.node.loc = path.node.body[0].loc;
}
}
function blockProp(prop) {
return function (path) {
makeBlock.call(this, path.get(prop));
};
}
function convertArrowExpression(path) {
var n = path.node;
var T = this.types;
if (n.expression) {
var bloc = n.body.loc;
n.expression = false;
n.body = T.blockStatement([T.returnStatement(n.body)]);
// restore body location
n.body.loc = bloc;
// set up the location for the return statement so it gets
// instrumented
n.body.body[0].loc = bloc;
}
}
function coverIfBranches(path) {
var n = path.node,
hint = this.hintFor(n),
ignoreIf = hint === 'if',
ignoreElse = hint === 'else',
branch = this.cov.newBranch('if', n.loc);
if (ignoreIf) {
this.setAttr(n.consequent, 'skip-all', true);
} else {
this.insertBranchCounter(path.get('consequent'), branch, n.loc);
}
if (ignoreElse) {
this.setAttr(n.alternate, 'skip-all', true);
} else {
this.insertBranchCounter(path.get('alternate'), branch, n.loc);
}
}
function createSwitchBranch(path) {
var b = this.cov.newBranch('switch', path.node.loc);
this.setAttr(path.node, 'branchName', b);
}
function coverSwitchCase(path) {
var T = this.types;
var b = this.getAttr(path.parentPath.node, 'branchName');
/* istanbul ignore if: paranoid check */
if (b === null) {
throw new Error('Unable to get switch branch name');
}
var increment = this.getBranchIncrement(b, path.node.loc);
path.node.consequent.unshift(T.expressionStatement(increment));
}
function coverTernary(path) {
var n = path.node,
branch = this.cov.newBranch('cond-expr', path.node.loc),
cHint = this.hintFor(n.consequent),
aHint = this.hintFor(n.alternate);
if (cHint !== 'next') {
this.insertBranchCounter(path.get('consequent'), branch);
}
if (aHint !== 'next') {
this.insertBranchCounter(path.get('alternate'), branch);
}
}
function coverLogicalExpression(path) {
var T = this.types;
if (path.parentPath.node.type === "LogicalExpression") {
return; // already processed
}
var leaves = [];
this.findLeaves(path.node, leaves);
var b = this.cov.newBranch("binary-expr", path.node.loc);
for (var i = 0; i < leaves.length; i += 1) {
var leaf = leaves[i];
var hint = this.hintFor(leaf.node);
if (hint === 'next') {
continue;
}
var increment = this.getBranchIncrement(b, leaf.node.loc);
if (!increment) {
continue;
}
leaf.parent[leaf.property] = T.sequenceExpression([increment, leaf.node]);
}
}
var codeVisitor = {
ArrowFunctionExpression: entries(convertArrowExpression, coverFunction),
AssignmentPattern: entries(coverAssignmentPattern),
BlockStatement: entries(), // ignore processing only
ClassMethod: entries(coverFunction),
ExpressionStatement: entries(coverStatement),
BreakStatement: entries(coverStatement),
ContinueStatement: entries(coverStatement),
DebuggerStatement: entries(coverStatement),
ReturnStatement: entries(coverStatement),
ThrowStatement: entries(coverStatement),
TryStatement: entries(coverStatement),
VariableDeclaration: entries(), // ignore processing only
VariableDeclarator: entries(coverVariableDeclarator),
IfStatement: entries(blockProp('consequent'), blockProp('alternate'), coverStatement, coverIfBranches),
ForStatement: entries(blockProp('body'), skipInit, coverStatement),
ForInStatement: entries(blockProp('body'), skipInit, coverStatement),
ForOfStatement: entries(blockProp('body'), skipInit, coverStatement),
WhileStatement: entries(blockProp('body'), coverStatement),
DoWhileStatement: entries(blockProp('body'), coverStatement),
SwitchStatement: entries(createSwitchBranch, coverStatement),
SwitchCase: entries(coverSwitchCase),
WithStatement: entries(blockProp('body'), coverStatement),
FunctionDeclaration: entries(coverFunction),
FunctionExpression: entries(coverFunction),
LabeledStatement: entries(coverStatement),
ConditionalExpression: entries(coverTernary),
LogicalExpression: entries(coverLogicalExpression)
};
// the template to insert at the top of the program.
var coverageTemplate = (0, _babelTemplate2.default)('\n var COVERAGE_VAR = (function () {\n var path = PATH,\n hash = HASH,\n global = (new Function(\'return this\'))(),\n gcv = GLOBAL_COVERAGE_VAR,\n coverageData = INITIAL,\n coverage = global[gcv] || (global[gcv] = {});\n if (coverage[path] && coverage[path].hash === hash) {\n return coverage[path];\n }\n coverageData.hash = hash;\n return coverage[path] = coverageData;\n })();\n');
// the rewire plugin (and potentially other babel middleware)
// may cause files to be instrumented twice, see:
// https://github.com/istanbuljs/babel-plugin-istanbul/issues/94
// we should only instrument code for coverage the first time
// it's run through istanbul-lib-instrument.
function alreadyInstrumented(path, visitState) {
return path.scope.hasBinding(visitState.varName);
}
/**
* programVisitor is a `babel` adaptor for instrumentation.
* It returns an object with two methods `enter` and `exit`.
* These should be assigned to or called from `Program` entry and exit functions
* in a babel visitor.
* These functions do not make assumptions about the state set by Babel and thus
* can be used in a context other than a Babel plugin.
*
* The exit function returns an object that currently has the following keys:
*
* `fileCoverage` - the file coverage object created for the source file.
* `sourceMappingURL` - any source mapping URL found when processing the file.
*
* @param {Object} types - an instance of babel-types
* @param {string} sourceFilePath - the path to source file
* @param {Object} opts - additional options
* @param {string} [opts.coverageVariable=__coverage__] the global coverage variable name.
* @param {object} [opts.inputSourceMap=undefined] the input source map, that maps the uninstrumented code back to the
* original code.
*/
function programVisitor(types) {
var sourceFilePath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'unknown.js';
var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : { coverageVariable: '__coverage__', inputSourceMap: undefined };
var T = types;
var visitState = new VisitState(types, sourceFilePath, opts.inputSourceMap);
return {
enter: function enter(path) {
if (alreadyInstrumented(path, visitState)) {
return;
}
path.traverse(codeVisitor, visitState);
},
exit: function exit(path) {
if (alreadyInstrumented(path, visitState)) {
return;
}
visitState.cov.freeze();
var coverageData = visitState.cov.toJSON();
coverageData[_constants.MAGIC_KEY] = _constants.MAGIC_VALUE;
var hash = (0, _crypto.createHash)(_constants.SHA).update(JSON.stringify(coverageData)).digest('hex');
var coverageNode = T.valueToNode(coverageData);
delete coverageData[_constants.MAGIC_KEY];
var cv = coverageTemplate({
GLOBAL_COVERAGE_VAR: T.stringLiteral(opts.coverageVariable),
COVERAGE_VAR: T.identifier(visitState.varName),
PATH: T.stringLiteral(sourceFilePath),
INITIAL: coverageNode,
HASH: T.stringLiteral(hash)
});
cv._blockHoist = 3;
path.node.body.unshift(cv);
return {
fileCoverage: coverageData,
sourceMappingURL: visitState.sourceMappingURL
};
}
};
}
exports.default = programVisitor;

121
static/js/ketcher2/node_modules/nyc/node_modules/istanbul-lib-instrument/package.json generated vendored Normal file
View File

@ -0,0 +1,121 @@
{
"_args": [
[
{
"raw": "istanbul-lib-instrument@^1.8.0",
"scope": null,
"escapedName": "istanbul-lib-instrument",
"name": "istanbul-lib-instrument",
"rawSpec": "^1.8.0",
"spec": ">=1.8.0 <2.0.0",
"type": "range"
},
"/Users/benjamincoe/bcoe/nyc"
]
],
"_from": "istanbul-lib-instrument@>=1.8.0 <2.0.0",
"_id": "istanbul-lib-instrument@1.8.0",
"_inBundle": true,
"_inCache": true,
"_location": "/nyc/istanbul-lib-instrument",
"_nodeVersion": "7.1.0",
"_npmOperationalInternal": {
"host": "s3://npm-registry-packages",
"tmp": "tmp/istanbul-lib-instrument-1.8.0.tgz_1504571973593_0.017329889349639416"
},
"_npmUser": {
"name": "bcoe",
"email": "ben@npmjs.com"
},
"_npmVersion": "4.6.1",
"_phantomChildren": {},
"_requested": {
"raw": "istanbul-lib-instrument@^1.8.0",
"scope": null,
"escapedName": "istanbul-lib-instrument",
"name": "istanbul-lib-instrument",
"rawSpec": "^1.8.0",
"spec": ">=1.8.0 <2.0.0",
"type": "range"
},
"_requiredBy": [
"/nyc"
],
"_resolved": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-1.8.0.tgz",
"_shasum": "66f6c9421cc9ec4704f76f2db084ba9078a2b532",
"_shrinkwrap": null,
"_spec": "istanbul-lib-instrument@^1.8.0",
"_where": "/Users/benjamincoe/bcoe/nyc",
"author": {
"name": "Krishnan Anantheswaran",
"email": "kananthmail-github@yahoo.com"
},
"bugs": {
"url": "https://github.com/istanbuljs/istanbuljs/issues"
},
"dependencies": {
"babel-generator": "^6.18.0",
"babel-template": "^6.16.0",
"babel-traverse": "^6.18.0",
"babel-types": "^6.18.0",
"babylon": "^6.18.0",
"istanbul-lib-coverage": "^1.1.1",
"semver": "^5.3.0"
},
"description": "Core istanbul API for JS code coverage",
"devDependencies": {
"babel-cli": "^6.3.17",
"babel-plugin-istanbul": "^2.0.3",
"babel-preset-es2015": "^6.3.13",
"babel-register": "^6.16.3",
"chai": "^3.0.0",
"clone": "^2.0.0",
"coveralls": "^2.11.4",
"cross-env": "^2.0.1",
"documentation": "^4.0.0-beta9",
"js-yaml": "^3.3.1",
"jshint": "^2.8.0",
"mocha": "^3.1.2",
"nopt": "^3.0.6"
},
"directories": {},
"dist": {
"shasum": "66f6c9421cc9ec4704f76f2db084ba9078a2b532",
"tarball": "https://registry.npmjs.org/istanbul-lib-instrument/-/istanbul-lib-instrument-1.8.0.tgz"
},
"files": [
"dist"
],
"homepage": "https://github.com/istanbuljs/istanbuljs",
"keywords": [
"coverage",
"istanbul",
"js",
"instrumentation"
],
"license": "BSD-3-Clause",
"main": "dist/index.js",
"maintainers": [
{
"name": "bcoe",
"email": "ben@npmjs.com"
},
{
"name": "gotwarlost",
"email": "kananthmail-github@yahoo.com"
}
],
"name": "istanbul-lib-instrument",
"optionalDependencies": {},
"repository": {
"type": "git",
"url": "git+ssh://git@github.com/istanbuljs/istanbuljs.git"
},
"scripts": {
"prepublish": "npm run release",
"pretest": "jshint src/ test/",
"release": "babel src --out-dir dist && documentation build -f md -o api.md src",
"test": "mocha --require=babel-register"
},
"version": "1.8.0"
}