@contrast/agent 4.16.1 → 4.17.1

package/node_modules/winston/dist/winston/transports/stream.js

@@ -1,30 +1,30 @@
-/**
- * stream.js: Transport for outputting to any arbitrary stream.
- *
- * (C) 2010 Charlie Robbins
- * MIT LICENCE
+/**
+ * stream.js: Transport for outputting to any arbitrary stream.
+ *
+ * (C) 2010 Charlie Robbins
+ * MIT LICENCE
  */
 'use strict';
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
 
 function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
 
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
 
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
 
 function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
 
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
 
@@ -36,10 +36,10 @@ var _require = require('triple-beam'),
 var os = require('os');
 
 var TransportStream = require('winston-transport');
-/**
- * Transport for outputting to any arbitrary stream.
- * @type {Stream}
- * @extends {TransportStream}
+/**
+ * Transport for outputting to any arbitrary stream.
+ * @type {Stream}
+ * @extends {TransportStream}
  */
 
 
@@ -48,10 +48,10 @@ module.exports = /*#__PURE__*/function (_TransportStream) {
 
   var _super = _createSuper(Stream);
 
-  /**
-   * Constructor function for the Console transport object responsible for
-   * persisting log messages and metadata to a terminal or TTY.
-   * @param {!Object} [options={}] - Options for this instance.
+  /**
+   * Constructor function for the Console transport object responsible for
+   * persisting log messages and metadata to a terminal or TTY.
+   * @param {!Object} [options={}] - Options for this instance.
    */
   function Stream() {
     var _this;
@@ -73,14 +73,14 @@ module.exports = /*#__PURE__*/function (_TransportStream) {
     _this._stream.setMaxListeners(Infinity);
 
     _this.isObjectMode = options.stream._writableState.objectMode;
-    _this.eol = options.eol || os.EOL;
+    _this.eol = typeof options.eol === 'string' ? options.eol : os.EOL;
     return _this;
   }
-  /**
-   * Core logging method exposed to Winston.
-   * @param {Object} info - TODO: add param description.
-   * @param {Function} callback - TODO: add param description.
-   * @returns {undefined}
+  /**
+   * Core logging method exposed to Winston.
+   * @param {Object} info - TODO: add param description.
+   * @param {Function} callback - TODO: add param description.
+   * @returns {undefined}
    */
 
 

package/node_modules/winston/dist/winston.js

@@ -1,8 +1,8 @@
-/**
- * winston.js: Top-level include defining Winston.
- *
- * (C) 2010 Charlie Robbins
- * MIT LICENCE
+/**
+ * winston.js: Top-level include defining Winston.
+ *
+ * (C) 2010 Charlie Robbins
+ * MIT LICENCE
  */
 'use strict';
 
@@ -10,109 +10,103 @@ var logform = require('logform');
 
 var _require = require('./winston/common'),
     warn = _require.warn;
-/**
- * Setup to expose.
- * @type {Object}
+/**
+ * Expose version. Use `require` method for `webpack` support.
+ * @type {string}
  */
 
 
-var winston = exports;
-/**
- * Expose version. Use `require` method for `webpack` support.
- * @type {string}
+exports.version = require('../package.json').version;
+/**
+ * Include transports defined by default by winston
+ * @type {Array}
  */
 
-winston.version = require('../package.json').version;
-/**
- * Include transports defined by default by winston
- * @type {Array}
+exports.transports = require('./winston/transports');
+/**
+ * Expose utility methods
+ * @type {Object}
  */
 
-winston.transports = require('./winston/transports');
-/**
- * Expose utility methods
- * @type {Object}
+exports.config = require('./winston/config');
+/**
+ * Hoist format-related functionality from logform.
+ * @type {Object}
  */
 
-winston.config = require('./winston/config');
-/**
- * Hoist format-related functionality from logform.
- * @type {Object}
+exports.addColors = logform.levels;
+/**
+ * Hoist format-related functionality from logform.
+ * @type {Object}
  */
 
-winston.addColors = logform.levels;
-/**
- * Hoist format-related functionality from logform.
- * @type {Object}
+exports.format = logform.format;
+/**
+ * Expose core Logging-related prototypes.
+ * @type {function}
  */
 
-winston.format = logform.format;
-/**
- * Expose core Logging-related prototypes.
- * @type {function}
+exports.createLogger = require('./winston/create-logger');
+/**
+ * Expose core Logging-related prototypes.
+ * @type {Object}
  */
 
-winston.createLogger = require('./winston/create-logger');
-/**
- * Expose core Logging-related prototypes.
- * @type {Object}
+exports.ExceptionHandler = require('./winston/exception-handler');
+/**
+ * Expose core Logging-related prototypes.
+ * @type {Object}
  */
 
-winston.ExceptionHandler = require('./winston/exception-handler');
-/**
- * Expose core Logging-related prototypes.
- * @type {Object}
+exports.RejectionHandler = require('./winston/rejection-handler');
+/**
+ * Expose core Logging-related prototypes.
+ * @type {Container}
  */
 
-winston.RejectionHandler = require('./winston/rejection-handler');
-/**
- * Expose core Logging-related prototypes.
- * @type {Container}
+exports.Container = require('./winston/container');
+/**
+ * Expose core Logging-related prototypes.
+ * @type {Object}
  */
 
-winston.Container = require('./winston/container');
-/**
- * Expose core Logging-related prototypes.
- * @type {Object}
+exports.Transport = require('winston-transport');
+/**
+ * We create and expose a default `Container` to `winston.loggers` so that the
+ * programmer may manage multiple `winston.Logger` instances without any
+ * additional overhead.
+ * @example
+ *   // some-file1.js
+ *   const logger = require('winston').loggers.get('something');
+ *
+ *   // some-file2.js
+ *   const logger = require('winston').loggers.get('something');
  */
 
-winston.Transport = require('winston-transport');
-/**
- * We create and expose a default `Container` to `winston.loggers` so that the
- * programmer may manage multiple `winston.Logger` instances without any
- * additional overhead.
- * @example
- *   // some-file1.js
- *   const logger = require('winston').loggers.get('something');
- *
- *   // some-file2.js
- *   const logger = require('winston').loggers.get('something');
+exports.loggers = new exports.Container();
+/**
+ * We create and expose a 'defaultLogger' so that the programmer may do the
+ * following without the need to create an instance of winston.Logger directly:
+ * @example
+ *   const winston = require('winston');
+ *   winston.log('info', 'some message');
+ *   winston.error('some error');
  */
 
-winston.loggers = new winston.Container();
-/**
- * We create and expose a 'defaultLogger' so that the programmer may do the
- * following without the need to create an instance of winston.Logger directly:
- * @example
- *   const winston = require('winston');
- *   winston.log('info', 'some message');
- *   winston.error('some error');
- */
-
-var defaultLogger = winston.createLogger(); // Pass through the target methods onto `winston.
+var defaultLogger = exports.createLogger(); // Pass through the target methods onto `winston.
 
-Object.keys(winston.config.npm.levels).concat(['log', 'query', 'stream', 'add', 'remove', 'clear', 'profile', 'startTimer', 'handleExceptions', 'unhandleExceptions', 'handleRejections', 'unhandleRejections', 'configure', 'child']).forEach(function (method) {
-  return winston[method] = function () {
+Object.keys(exports.config.npm.levels).concat(['log', 'query', 'stream', 'add', 'remove', 'clear', 'profile', 'startTimer', 'handleExceptions', 'unhandleExceptions', 'handleRejections', 'unhandleRejections', 'configure', 'child']).forEach(function (method) {
+  return exports[method] = function () {
     return defaultLogger[method].apply(defaultLogger, arguments);
   };
 });
-/**
- * Define getter / setter for the default logger level which need to be exposed
- * by winston.
- * @type {string}
+/**
+ * Define getter / setter for the default logger level which need to be exposed
+ * by winston.
+ * @type {string}
  */
 
-Object.defineProperty(winston, 'level', {
+Object.defineProperty(exports, 'level', {
   get: function get() {
     return defaultLogger.level;
   },
@@ -120,25 +114,25 @@ Object.defineProperty(winston, 'level', {
     defaultLogger.level = val;
   }
 });
-/**
- * Define getter for `exceptions` which replaces `handleExceptions` and
- * `unhandleExceptions`.
- * @type {Object}
+/**
+ * Define getter for `exceptions` which replaces `handleExceptions` and
+ * `unhandleExceptions`.
+ * @type {Object}
  */
 
-Object.defineProperty(winston, 'exceptions', {
+Object.defineProperty(exports, 'exceptions', {
   get: function get() {
     return defaultLogger.exceptions;
   }
 });
-/**
- * Define getters / setters for appropriate properties of the default logger
- * which need to be exposed by winston.
- * @type {Logger}
+/**
+ * Define getters / setters for appropriate properties of the default logger
+ * which need to be exposed by winston.
+ * @type {Logger}
  */
 
 ['exitOnError'].forEach(function (prop) {
-  Object.defineProperty(winston, prop, {
+  Object.defineProperty(exports, prop, {
     get: function get() {
       return defaultLogger[prop];
     },
@@ -147,12 +141,12 @@ Object.defineProperty(winston, 'exceptions', {
     }
   });
 });
-/**
- * The default transports and exceptionHandlers for the default winston logger.
- * @type {Object}
+/**
+ * The default transports and exceptionHandlers for the default winston logger.
+ * @type {Object}
  */
 
-Object.defineProperty(winston, 'default', {
+Object.defineProperty(exports, 'default', {
   get: function get() {
     return {
       exceptionHandlers: defaultLogger.exceptionHandlers,
@@ -163,10 +157,10 @@ Object.defineProperty(winston, 'default', {
 }); // Have friendlier breakage notices for properties that were exposed by default
 // on winston < 3.0.
 
-warn.deprecated(winston, 'setLevels');
-warn.forFunctions(winston, 'useFormat', ['cli']);
-warn.forProperties(winston, 'useFormat', ['padLevels', 'stripColors']);
-warn.forFunctions(winston, 'deprecated', ['addRewriter', 'addFilter', 'clone', 'extend']);
-warn.forProperties(winston, 'deprecated', ['emitErrs', 'levelLength']); // Throw a useful error when users attempt to run `new winston.Logger`.
+warn.deprecated(exports, 'setLevels');
+warn.forFunctions(exports, 'useFormat', ['cli']);
+warn.forProperties(exports, 'useFormat', ['padLevels', 'stripColors']);
+warn.forFunctions(exports, 'deprecated', ['addRewriter', 'addFilter', 'clone', 'extend']);
+warn.forProperties(exports, 'deprecated', ['emitErrs', 'levelLength']); // Throw a useful error when users attempt to run `new winston.Logger`.
 
-warn.moved(winston, 'createLogger', 'Logger');
+warn.moved(exports, 'createLogger', 'Logger');