@putkoff/abstract-logger 0.0.59 → 0.0.60

package/dist/cjs/index.js

@@ -1595,11 +1595,11 @@ function requireAlign () {
 /* eslint no-undefined: 0 */
 
 var errors$1;
-var hasRequiredErrors;
+var hasRequiredErrors$1;
 
-function requireErrors () {
-	if (hasRequiredErrors) return errors$1;
-	hasRequiredErrors = 1;
+function requireErrors$1 () {
+	if (hasRequiredErrors$1) return errors$1;
+	hasRequiredErrors$1 = 1;
 
 	const format = format$2;
 	const { LEVEL, MESSAGE } = tripleBeam;
@@ -3649,7 +3649,7 @@ function exposeFormat(name, requireFormat) {
 // Setup all transports as lazy-loaded getters.
 //
 exposeFormat('align', function () { return requireAlign(); });
-exposeFormat('errors', function () { return requireErrors(); });
+exposeFormat('errors', function () { return requireErrors$1(); });
 exposeFormat('cli', function () { return requireCli(); });
 exposeFormat('combine', function () { return requireCombine(); });
 exposeFormat('colorize', function () { return requireColorize(); });
@@ -3726,246 +3726,288 @@ var winstonTransport = {exports: {}};
 
 var modern = {exports: {}};
 
-/**
- * For Node.js, simply re-export the core `util.deprecate` function.
- */
+var node$1;
+var hasRequiredNode;
 
-var node$1 = require$$0$2.deprecate;
-
-var stream$1 = require$$0$3;
-
-// undocumented cb() API, needed for core, not for public API
-function destroy(err, cb) {
-  var _this = this;
-  var readableDestroyed = this._readableState && this._readableState.destroyed;
-  var writableDestroyed = this._writableState && this._writableState.destroyed;
-  if (readableDestroyed || writableDestroyed) {
-    if (cb) {
-      cb(err);
-    } else if (err) {
-      if (!this._writableState) {
-        process.nextTick(emitErrorNT, this, err);
-      } else if (!this._writableState.errorEmitted) {
-        this._writableState.errorEmitted = true;
-        process.nextTick(emitErrorNT, this, err);
-      }
-    }
-    return this;
-  }
+function requireNode () {
+	if (hasRequiredNode) return node$1;
+	hasRequiredNode = 1;
+	/**
+	 * For Node.js, simply re-export the core `util.deprecate` function.
+	 */
 
-  // we set destroyed to true before firing error callbacks in order
-  // to make it re-entrance safe in case destroy() is called within callbacks
+	node$1 = require$$0$2.deprecate;
+	return node$1;
+}
 
-  if (this._readableState) {
-    this._readableState.destroyed = true;
-  }
+var stream$1;
+var hasRequiredStream$1;
 
-  // if this is a duplex stream mark the writable part as destroyed as well
-  if (this._writableState) {
-    this._writableState.destroyed = true;
-  }
-  this._destroy(err || null, function (err) {
-    if (!cb && err) {
-      if (!_this._writableState) {
-        process.nextTick(emitErrorAndCloseNT, _this, err);
-      } else if (!_this._writableState.errorEmitted) {
-        _this._writableState.errorEmitted = true;
-        process.nextTick(emitErrorAndCloseNT, _this, err);
-      } else {
-        process.nextTick(emitCloseNT, _this);
-      }
-    } else if (cb) {
-      process.nextTick(emitCloseNT, _this);
-      cb(err);
-    } else {
-      process.nextTick(emitCloseNT, _this);
-    }
-  });
-  return this;
-}
-function emitErrorAndCloseNT(self, err) {
-  emitErrorNT(self, err);
-  emitCloseNT(self);
-}
-function emitCloseNT(self) {
-  if (self._writableState && !self._writableState.emitClose) return;
-  if (self._readableState && !self._readableState.emitClose) return;
-  self.emit('close');
-}
-function undestroy() {
-  if (this._readableState) {
-    this._readableState.destroyed = false;
-    this._readableState.reading = false;
-    this._readableState.ended = false;
-    this._readableState.endEmitted = false;
-  }
-  if (this._writableState) {
-    this._writableState.destroyed = false;
-    this._writableState.ended = false;
-    this._writableState.ending = false;
-    this._writableState.finalCalled = false;
-    this._writableState.prefinished = false;
-    this._writableState.finished = false;
-    this._writableState.errorEmitted = false;
-  }
-}
-function emitErrorNT(self, err) {
-  self.emit('error', err);
+function requireStream$1 () {
+	if (hasRequiredStream$1) return stream$1;
+	hasRequiredStream$1 = 1;
+	stream$1 = require$$0$3;
+	return stream$1;
 }
-function errorOrDestroy(stream, err) {
-  // We have tests that rely on errors being emitted
-  // in the same tick, so changing this is semver major.
-  // For now when you opt-in to autoDestroy we allow
-  // the error to be emitted nextTick. In a future
-  // semver major update we should change the default to this.
-
-  var rState = stream._readableState;
-  var wState = stream._writableState;
-  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
+
+var destroy_1;
+var hasRequiredDestroy;
+
+function requireDestroy () {
+	if (hasRequiredDestroy) return destroy_1;
+	hasRequiredDestroy = 1;
+
+	// undocumented cb() API, needed for core, not for public API
+	function destroy(err, cb) {
+	  var _this = this;
+	  var readableDestroyed = this._readableState && this._readableState.destroyed;
+	  var writableDestroyed = this._writableState && this._writableState.destroyed;
+	  if (readableDestroyed || writableDestroyed) {
+	    if (cb) {
+	      cb(err);
+	    } else if (err) {
+	      if (!this._writableState) {
+	        process.nextTick(emitErrorNT, this, err);
+	      } else if (!this._writableState.errorEmitted) {
+	        this._writableState.errorEmitted = true;
+	        process.nextTick(emitErrorNT, this, err);
+	      }
+	    }
+	    return this;
+	  }
+
+	  // we set destroyed to true before firing error callbacks in order
+	  // to make it re-entrance safe in case destroy() is called within callbacks
+
+	  if (this._readableState) {
+	    this._readableState.destroyed = true;
+	  }
+
+	  // if this is a duplex stream mark the writable part as destroyed as well
+	  if (this._writableState) {
+	    this._writableState.destroyed = true;
+	  }
+	  this._destroy(err || null, function (err) {
+	    if (!cb && err) {
+	      if (!_this._writableState) {
+	        process.nextTick(emitErrorAndCloseNT, _this, err);
+	      } else if (!_this._writableState.errorEmitted) {
+	        _this._writableState.errorEmitted = true;
+	        process.nextTick(emitErrorAndCloseNT, _this, err);
+	      } else {
+	        process.nextTick(emitCloseNT, _this);
+	      }
+	    } else if (cb) {
+	      process.nextTick(emitCloseNT, _this);
+	      cb(err);
+	    } else {
+	      process.nextTick(emitCloseNT, _this);
+	    }
+	  });
+	  return this;
+	}
+	function emitErrorAndCloseNT(self, err) {
+	  emitErrorNT(self, err);
+	  emitCloseNT(self);
+	}
+	function emitCloseNT(self) {
+	  if (self._writableState && !self._writableState.emitClose) return;
+	  if (self._readableState && !self._readableState.emitClose) return;
+	  self.emit('close');
+	}
+	function undestroy() {
+	  if (this._readableState) {
+	    this._readableState.destroyed = false;
+	    this._readableState.reading = false;
+	    this._readableState.ended = false;
+	    this._readableState.endEmitted = false;
+	  }
+	  if (this._writableState) {
+	    this._writableState.destroyed = false;
+	    this._writableState.ended = false;
+	    this._writableState.ending = false;
+	    this._writableState.finalCalled = false;
+	    this._writableState.prefinished = false;
+	    this._writableState.finished = false;
+	    this._writableState.errorEmitted = false;
+	  }
+	}
+	function emitErrorNT(self, err) {
+	  self.emit('error', err);
+	}
+	function errorOrDestroy(stream, err) {
+	  // We have tests that rely on errors being emitted
+	  // in the same tick, so changing this is semver major.
+	  // For now when you opt-in to autoDestroy we allow
+	  // the error to be emitted nextTick. In a future
+	  // semver major update we should change the default to this.
+
+	  var rState = stream._readableState;
+	  var wState = stream._writableState;
+	  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
+	}
+	destroy_1 = {
+	  destroy: destroy,
+	  undestroy: undestroy,
+	  errorOrDestroy: errorOrDestroy
+	};
+	return destroy_1;
 }
-var destroy_1 = {
-  destroy: destroy,
-  undestroy: undestroy,
-  errorOrDestroy: errorOrDestroy
-};
 
 var errors = {};
 
-const codes = {};
+var hasRequiredErrors;
 
-function createErrorType(code, message, Base) {
-  if (!Base) {
-    Base = Error;
-  }
+function requireErrors () {
+	if (hasRequiredErrors) return errors;
+	hasRequiredErrors = 1;
 
-  function getMessage (arg1, arg2, arg3) {
-    if (typeof message === 'string') {
-      return message
-    } else {
-      return message(arg1, arg2, arg3)
-    }
-  }
+	const codes = {};
 
-  class NodeError extends Base {
-    constructor (arg1, arg2, arg3) {
-      super(getMessage(arg1, arg2, arg3));
-    }
-  }
+	function createErrorType(code, message, Base) {
+	  if (!Base) {
+	    Base = Error;
+	  }
 
-  NodeError.prototype.name = Base.name;
-  NodeError.prototype.code = code;
+	  function getMessage (arg1, arg2, arg3) {
+	    if (typeof message === 'string') {
+	      return message
+	    } else {
+	      return message(arg1, arg2, arg3)
+	    }
+	  }
 
-  codes[code] = NodeError;
-}
+	  class NodeError extends Base {
+	    constructor (arg1, arg2, arg3) {
+	      super(getMessage(arg1, arg2, arg3));
+	    }
+	  }
 
-// https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
-function oneOf(expected, thing) {
-  if (Array.isArray(expected)) {
-    const len = expected.length;
-    expected = expected.map((i) => String(i));
-    if (len > 2) {
-      return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` +
-             expected[len - 1];
-    } else if (len === 2) {
-      return `one of ${thing} ${expected[0]} or ${expected[1]}`;
-    } else {
-      return `of ${thing} ${expected[0]}`;
-    }
-  } else {
-    return `of ${thing} ${String(expected)}`;
-  }
-}
+	  NodeError.prototype.name = Base.name;
+	  NodeError.prototype.code = code;
 
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
-function startsWith(str, search, pos) {
-	return str.substr(0 , search.length) === search;
-}
+	  codes[code] = NodeError;
+	}
 
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
-function endsWith(str, search, this_len) {
-	if (this_len === undefined || this_len > str.length) {
-		this_len = str.length;
+	// https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
+	function oneOf(expected, thing) {
+	  if (Array.isArray(expected)) {
+	    const len = expected.length;
+	    expected = expected.map((i) => String(i));
+	    if (len > 2) {
+	      return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` +
+	             expected[len - 1];
+	    } else if (len === 2) {
+	      return `one of ${thing} ${expected[0]} or ${expected[1]}`;
+	    } else {
+	      return `of ${thing} ${expected[0]}`;
+	    }
+	  } else {
+	    return `of ${thing} ${String(expected)}`;
+	  }
 	}
-	return str.substring(this_len - search.length, this_len) === search;
-}
 
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
-function includes(str, search, start) {
-  if (typeof start !== 'number') {
-    start = 0;
-  }
+	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+	function startsWith(str, search, pos) {
+		return str.substr(0 , search.length) === search;
+	}
 
-  if (start + search.length > str.length) {
-    return false;
-  } else {
-    return str.indexOf(search, start) !== -1;
-  }
-}
+	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
+	function endsWith(str, search, this_len) {
+		if (this_len === undefined || this_len > str.length) {
+			this_len = str.length;
+		}
+		return str.substring(this_len - search.length, this_len) === search;
+	}
 
-createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
-  return 'The value "' + value + '" is invalid for option "' + name + '"'
-}, TypeError);
-createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
-  // determiner: 'must be' or 'must not be'
-  let determiner;
-  if (typeof expected === 'string' && startsWith(expected, 'not ')) {
-    determiner = 'must not be';
-    expected = expected.replace(/^not /, '');
-  } else {
-    determiner = 'must be';
-  }
+	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
+	function includes(str, search, start) {
+	  if (typeof start !== 'number') {
+	    start = 0;
+	  }
 
-  let msg;
-  if (endsWith(name, ' argument')) {
-    // For cases like 'first argument'
-    msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`;
-  } else {
-    const type = includes(name, '.') ? 'property' : 'argument';
-    msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, 'type')}`;
-  }
+	  if (start + search.length > str.length) {
+	    return false;
+	  } else {
+	    return str.indexOf(search, start) !== -1;
+	  }
+	}
 
-  msg += `. Received type ${typeof actual}`;
-  return msg;
-}, TypeError);
-createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
-createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
-  return 'The ' + name + ' method is not implemented'
-});
-createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
-createErrorType('ERR_STREAM_DESTROYED', function (name) {
-  return 'Cannot call ' + name + ' after a stream was destroyed';
-});
-createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
-createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
-createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
-createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
-createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
-  return 'Unknown encoding: ' + arg
-}, TypeError);
-createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
-
-errors.codes = codes;
-
-var ERR_INVALID_OPT_VALUE = errors.codes.ERR_INVALID_OPT_VALUE;
-function highWaterMarkFrom(options, isDuplex, duplexKey) {
-  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
+	createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
+	  return 'The value "' + value + '" is invalid for option "' + name + '"'
+	}, TypeError);
+	createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
+	  // determiner: 'must be' or 'must not be'
+	  let determiner;
+	  if (typeof expected === 'string' && startsWith(expected, 'not ')) {
+	    determiner = 'must not be';
+	    expected = expected.replace(/^not /, '');
+	  } else {
+	    determiner = 'must be';
+	  }
+
+	  let msg;
+	  if (endsWith(name, ' argument')) {
+	    // For cases like 'first argument'
+	    msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`;
+	  } else {
+	    const type = includes(name, '.') ? 'property' : 'argument';
+	    msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, 'type')}`;
+	  }
+
+	  msg += `. Received type ${typeof actual}`;
+	  return msg;
+	}, TypeError);
+	createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
+	createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
+	  return 'The ' + name + ' method is not implemented'
+	});
+	createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
+	createErrorType('ERR_STREAM_DESTROYED', function (name) {
+	  return 'Cannot call ' + name + ' after a stream was destroyed';
+	});
+	createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
+	createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
+	createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
+	createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
+	createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
+	  return 'Unknown encoding: ' + arg
+	}, TypeError);
+	createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
+
+	errors.codes = codes;
+	return errors;
 }
-function getHighWaterMark(state, options, duplexKey, isDuplex) {
-  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
-  if (hwm != null) {
-    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
-      var name = isDuplex ? duplexKey : 'highWaterMark';
-      throw new ERR_INVALID_OPT_VALUE(name, hwm);
-    }
-    return Math.floor(hwm);
-  }
 
-  // Default value
-  return state.objectMode ? 16 : 16 * 1024;
+var state;
+var hasRequiredState;
+
+function requireState () {
+	if (hasRequiredState) return state;
+	hasRequiredState = 1;
+
+	var ERR_INVALID_OPT_VALUE = requireErrors().codes.ERR_INVALID_OPT_VALUE;
+	function highWaterMarkFrom(options, isDuplex, duplexKey) {
+	  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
+	}
+	function getHighWaterMark(state, options, duplexKey, isDuplex) {
+	  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
+	  if (hwm != null) {
+	    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
+	      var name = isDuplex ? duplexKey : 'highWaterMark';
+	      throw new ERR_INVALID_OPT_VALUE(name, hwm);
+	    }
+	    return Math.floor(hwm);
+	  }
+
+	  // Default value
+	  return state.objectMode ? 16 : 16 * 1024;
+	}
+	state = {
+	  getHighWaterMark: getHighWaterMark
+	};
+	return state;
 }
-var state = {
-  getHighWaterMark: getHighWaterMark
-};
 
 var inherits = {exports: {}};
 
@@ -4006,18 +4048,23 @@ function requireInherits_browser () {
 	return inherits_browser.exports;
 }
 
-try {
-  var util$2 = require('util');
-  /* istanbul ignore next */
-  if (typeof util$2.inherits !== 'function') throw '';
-  inherits.exports = util$2.inherits;
-} catch (e) {
-  /* istanbul ignore next */
-  inherits.exports = requireInherits_browser();
+var hasRequiredInherits;
+
+function requireInherits () {
+	if (hasRequiredInherits) return inherits.exports;
+	hasRequiredInherits = 1;
+	try {
+	  var util = require('util');
+	  /* istanbul ignore next */
+	  if (typeof util.inherits !== 'function') throw '';
+	  inherits.exports = util.inherits;
+	} catch (e) {
+	  /* istanbul ignore next */
+	  inherits.exports = requireInherits_browser();
+	}
+	return inherits.exports;
 }
 
-var inheritsExports = inherits.exports;
-
 var buffer_list;
 var hasRequiredBuffer_list;
 
@@ -4577,7 +4624,7 @@ function requireEndOfStream () {
 	if (hasRequiredEndOfStream) return endOfStream;
 	hasRequiredEndOfStream = 1;
 
-	var ERR_STREAM_PREMATURE_CLOSE = errors.codes.ERR_STREAM_PREMATURE_CLOSE;
+	var ERR_STREAM_PREMATURE_CLOSE = requireErrors().codes.ERR_STREAM_PREMATURE_CLOSE;
 	function once(callback) {
 	  var called = false;
 	  return function () {
@@ -4863,7 +4910,7 @@ function requireFrom () {
 	function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 	function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
 	function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-	var ERR_INVALID_ARG_TYPE = errors.codes.ERR_INVALID_ARG_TYPE;
+	var ERR_INVALID_ARG_TYPE = requireErrors().codes.ERR_INVALID_ARG_TYPE;
 	function from(Readable, iterable, opts) {
 	  var iterator;
 	  if (iterable && typeof iterable.next === 'function') {
@@ -4932,7 +4979,7 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = stream$1;
+	var Stream = requireStream$1();
 	/*</replacement>*/
 
 	var Buffer = require$$0$4.Buffer;
@@ -4955,10 +5002,10 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	var BufferList = requireBuffer_list();
-	var destroyImpl = destroy_1;
-	var _require = state,
+	var destroyImpl = requireDestroy();
+	var _require = requireState(),
 	  getHighWaterMark = _require.getHighWaterMark;
-	var _require$codes = errors.codes,
+	var _require$codes = requireErrors().codes,
 	  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
 	  ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,
 	  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
@@ -4968,7 +5015,7 @@ function require_stream_readable () {
 	var StringDecoder;
 	var createReadableStreamAsyncIterator;
 	var from;
-	inheritsExports(Readable, Stream);
+	requireInherits()(Readable, Stream);
 	var errorOrDestroy = destroyImpl.errorOrDestroy;
 	var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
 	function prependListener(emitter, event, fn) {
@@ -5941,7 +5988,7 @@ function require_stream_duplex () {
 	_stream_duplex = Duplex;
 	var Readable = require_stream_readable();
 	var Writable = require_stream_writable();
-	inheritsExports(Duplex, Readable);
+	requireInherits()(Duplex, Readable);
 	{
 	  // Allow the keys array to be GC'ed.
 	  var keys = objectKeys(Writable.prototype);
@@ -6060,12 +6107,12 @@ function require_stream_writable () {
 
 	/*<replacement>*/
 	var internalUtil = {
-	  deprecate: node$1
+	  deprecate: requireNode()
 	};
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = stream$1;
+	var Stream = requireStream$1();
 	/*</replacement>*/
 
 	var Buffer = require$$0$4.Buffer;
@@ -6076,10 +6123,10 @@ function require_stream_writable () {
 	function _isUint8Array(obj) {
 	  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
 	}
-	var destroyImpl = destroy_1;
-	var _require = state,
+	var destroyImpl = requireDestroy();
+	var _require = requireState(),
 	  getHighWaterMark = _require.getHighWaterMark;
-	var _require$codes = errors.codes,
+	var _require$codes = requireErrors().codes,
 	  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
 	  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
 	  ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
@@ -6089,7 +6136,7 @@ function require_stream_writable () {
 	  ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,
 	  ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
 	var errorOrDestroy = destroyImpl.errorOrDestroy;
-	inheritsExports(Writable, Stream);
+	requireInherits()(Writable, Stream);
 	function nop() {}
 	function WritableState(options, stream, isDuplex) {
 	  Duplex = Duplex || require_stream_duplex();
@@ -8065,13 +8112,13 @@ function require_stream_transform () {
 	hasRequired_stream_transform = 1;
 
 	_stream_transform = Transform;
-	var _require$codes = errors.codes,
+	var _require$codes = requireErrors().codes,
 	  ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
 	  ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
 	  ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,
 	  ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
 	var Duplex = require_stream_duplex();
-	inheritsExports(Transform, Duplex);
+	requireInherits()(Transform, Duplex);
 	function afterTransform(er, data) {
 	  var ts = this._transformState;
 	  ts.transforming = false;
@@ -8201,7 +8248,7 @@ function require_stream_passthrough () {
 
 	_stream_passthrough = PassThrough;
 	var Transform = require_stream_transform();
-	inheritsExports(PassThrough, Transform);
+	requireInherits()(PassThrough, Transform);
 	function PassThrough(options) {
 	  if (!(this instanceof PassThrough)) return new PassThrough(options);
 	  Transform.call(this, options);
@@ -8228,7 +8275,7 @@ function requirePipeline () {
 	    callback.apply(void 0, arguments);
 	  };
 	}
-	var _require$codes = errors.codes,
+	var _require$codes = requireErrors().codes,
 	  ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
 	  ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
 	function noop(err) {
@@ -15003,8 +15050,10 @@ exports.COLS = COLS;
 exports.IS_BROWSER = IS_BROWSER;
 exports.IS_NODE = IS_NODE;
 exports.activityEmojiMap = activityEmojiMap;
+exports.createLogger = winston.createLogger;
 exports.debugLogConfig = debugLogConfig;
 exports.extractFile = extractFile;
+exports.format = winston.format;
 exports.formatLogLine = formatLogLine;
 exports.getCallerInfo = getCallerInfo;
 exports.getFinalLine = getFinalLine;
@@ -15020,4 +15069,5 @@ exports.resolveValue = resolveValue;
 exports.serializeDetails = serializeDetails;
 exports.shouldCondense = shouldCondense;
 exports.shouldShowDetails = shouldShowDetails;
+exports.transports = winston.transports;
 //# sourceMappingURL=index.js.map