@putkoff/abstract-logger 0.0.48 → 0.0.49

package/dist/esm/index.js

@@ -1,15 +1,15 @@
-import require$$0$2 from 'util';
+import fs from 'fs';
+import path from 'path';
 import require$$0$1 from 'os';
+import require$$0$2 from 'util';
 import require$$0$3 from 'stream';
 import require$$0$4 from 'buffer';
 import require$$0$5 from 'events';
-import require$$0$6 from 'fs';
-import require$$1$2 from 'path';
 import require$$3 from 'zlib';
 import require$$1 from 'tty';
 import require$$1$1 from 'string_decoder';
-import require$$0$7 from 'http';
-import require$$1$3 from 'https';
+import require$$0$6 from 'http';
+import require$$1$2 from 'https';
 
 /* ------------------------------------------------------------------ */
 /* Stack inspection                                                    */
@@ -182,40 +182,144 @@ const COLS = {
     file: 16,
 };
 
+if (typeof process === "undefined") {
+    throw new Error("@putkoff/abstract-env is Node-only");
+}
+/* ========================================================================== */
+/* Utilities                                                                  */
+/* ========================================================================== */
+function splitEq(line) {
+    const idx = line.indexOf("=");
+    if (idx === -1)
+        return [line.trim(), null];
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim().replace(/^['"]|['"]$/g, "");
+    return [key, value];
+}
+/* ========================================================================== */
+/* AbstractEnv                                                                */
+/* ========================================================================== */
+class AbstractEnv {
+    key;
+    fileName;
+    path;
+    deepScan;
+    currentFolder;
+    homeFolder;
+    envyAll;
+    directories = [];
+    envValue = null;
+    envPath = null;
+    constructor(options = {}) {
+        this.key = options.key ?? "MY_PASSWORD";
+        this.fileName = options.fileName ?? ".env";
+        this.path = options.startPath ?? process.cwd();
+        this.deepScan = options.deepScan ?? false;
+        this.currentFolder = process.cwd();
+        this.homeFolder = require$$0$1.homedir();
+        this.envyAll = path.join(this.homeFolder, ".envy_all");
+        this.initialize();
+    }
+    initialize() {
+        if (fs.existsSync(this.path) && fs.statSync(this.path).isFile()) {
+            this.fileName = path.basename(this.path);
+            this.path = path.dirname(this.path);
+        }
+        this.directories = this.getDirectories();
+        this.envValue = this.findAndReadEnv();
+    }
+    getDirectories() {
+        const dirs = [
+            this.path,
+            this.currentFolder,
+            this.homeFolder,
+            this.envyAll,
+        ];
+        return [...new Set(dirs.filter(d => fs.existsSync(d) && fs.statSync(d).isDirectory()))];
+    }
+    findAndReadEnv() {
+        for (const dir of this.directories) {
+            const envPath = path.join(dir, this.fileName);
+            if (!fs.existsSync(envPath))
+                continue;
+            this.envPath = envPath;
+            const value = this.searchForKey(envPath);
+            if (value !== null)
+                return value;
+        }
+        return null;
+    }
+    searchForKey(filePath) {
+        const content = fs.readFileSync(filePath, "utf8");
+        const lines = content.split(/\r?\n/);
+        let bestMatch = null;
+        for (const line of lines) {
+            const [lineKey, lineValue] = splitEq(line);
+            if (!lineValue)
+                continue;
+            if (lineKey === this.key)
+                return lineValue;
+            if (this.deepScan) {
+                const score = this.fuzzyScore(this.key, lineKey);
+                if (score >= 0.5 && (!bestMatch || score > bestMatch.score)) {
+                    bestMatch = { value: lineValue, score };
+                }
+            }
+        }
+        return bestMatch?.value ?? null;
+    }
+    fuzzyScore(target, candidate) {
+        let matched = 0;
+        for (const part of target.split("_")) {
+            if (candidate.includes(part))
+                matched += part.length;
+        }
+        return matched / target.length;
+    }
+}
+
+/**
+ * Retrieve environment variable value by searching .env files.
+ */
+function getEnvValue(options = {}) {
+    const env = new AbstractEnv(options);
+    return env.envValue;
+}
+
 /* ------------------------------------------------------------------ */
 /* Winston logger (Node only)                                          */
 /* ------------------------------------------------------------------ */
 function getLogConfig() {
     return {
-        condensed: process.env.LOG_CONDENSED !== "false",
-        expandOnDebug: process.env.LOG_EXPAND_DEBUG !== "false",
-        showDetails: process.env.LOG_SHOW_DETAILS !== "false",
-        maxDetailsLength: Number(process.env.LOG_DETAILS_MAX ?? 500),
-        activityBlocklist: parse$1(process.env.LOG_ACTIVITY_BLOCKLIST),
-        logTypeBlocklist: parse$1(process.env.LOG_TYPE_BLOCKLIST),
-        sampleRate: Number(process.env.LOG_SAMPLE_RATE ?? 1), // 0–1
+        condensed: getEnvValue({ key: "LOG_CONDENSED" }) !== "false",
+        expandOnDebug: getEnvValue({ key: "LOG_EXPAND_DEBUG" }) !== "false",
+        showDetails: getEnvValue({ key: "LOG_SHOW_DETAILS" }) !== "false",
+        maxDetailsLength: Number(getEnvValue({ key: "LOG_DETAILS_MAX" }) ?? 500),
+        activityBlocklist: parse$1(getEnvValue({ key: "LOG_ACTIVITY_BLOCKLIST" }) || ""),
+        logTypeBlocklist: parse$1(getEnvValue({ key: "LOG_TYPE_BLOCKLIST" }) || ""),
+        sampleRate: Number(getEnvValue({ key: "LOG_SAMPLE_RATE" }) ?? 1), // 0–1
         // 👇 NEW
-        prettyDetails: process.env.LOG_PRETTY_DETAILS === "true",
-        showDetailslist: process.env.LOG_DETAILS_ALLOWLIST
-            ? process.env.LOG_DETAILS_ALLOWLIST.split(",").map(s => s.trim())
+        prettyDetails: getEnvValue({ key: "LOG_PRETTY_DETAILS" }) === "true",
+        showDetailslist: getEnvValue({ key: "LOG_DETAILS_ALLOWLIST" })
+            ? getEnvValue({ key: "LOG_DETAILS_ALLOWLIST" }) || "".split(",").map(s => s.trim())
             : [],
-        functionAllowlist: process.env.LOG_FUNCTION_ALLOWLIST
-            ? process.env.LOG_FUNCTION_ALLOWLIST.split(",").map(s => s.trim())
+        functionAllowlist: getEnvValue({ key: "LOG_FUNCTION_ALLOWLIST" })
+            ? getEnvValue({ key: "LOG_FUNCTION_ALLOWLIST" }) || "".split(",").map(s => s.trim())
             : [],
-        functionBlocklist: process.env.LOG_FUNCTION_BLOCKLIST
-            ? process.env.LOG_FUNCTION_BLOCKLIST.split(",").map(s => s.trim())
+        functionBlocklist: getEnvValue({ key: "LOG_FUNCTION_BLOCKLIST" })
+            ? getEnvValue({ key: "LOG_FUNCTION_BLOCKLIST" }) || "".split(",").map(s => s.trim())
             : [],
     };
 }
 function debugLogConfig() {
-    if (process.env.LOG_DEBUG_CONFIG === "true") {
-        console.log("LOG CONFIG ENV:", {
-            LOG_SHOW_DETAILS: process.env.LOG_SHOW_DETAILS,
-            LOG_DETAILS_ALLOWLIST: process.env.LOG_DETAILS_ALLOWLIST,
-            LOG_PRETTY_DETAILS: process.env.LOG_PRETTY_DETAILS,
-            LOG_CONDENSED: process.env.LOG_CONDENSED,
-            LOG_EXPAND_DEBUG: process.env.LOG_EXPAND_DEBUG,
-        });
+    if (getEnvValue({ key: "LOG_DEBUG_CONFIG" }) === "true") {
+        console.log("LOG CONFIG ENV:"), {
+            LOG_SHOW_DETAILS: getEnvValue({ key: "LOG_SHOW_DETAILS" }),
+            LOG_DETAILS_ALLOWLIST: getEnvValue({ key: "LOG_DETAILS_ALLOWLIST" }),
+            LOG_PRETTY_DETAILS: getEnvValue({ key: "LOG_PRETTY_DETAILS" }),
+            LOG_CONDENSED: getEnvValue({ key: "LOG_CONDENSED" }),
+            LOG_EXPAND_DEBUG: getEnvValue({ key: "LOG_EXPAND_DEBUG" }),
+        };
     }
 }
 function parse$1(v) {
@@ -1494,11 +1598,11 @@ function requireAlign () {
 /* eslint no-undefined: 0 */
 
 var errors$1;
-var hasRequiredErrors$1;
+var hasRequiredErrors;
 
-function requireErrors$1 () {
-	if (hasRequiredErrors$1) return errors$1;
-	hasRequiredErrors$1 = 1;
+function requireErrors () {
+	if (hasRequiredErrors) return errors$1;
+	hasRequiredErrors = 1;
 
 	const format = format$2;
 	const { LEVEL, MESSAGE } = tripleBeam;
@@ -3548,7 +3652,7 @@ function exposeFormat(name, requireFormat) {
 // Setup all transports as lazy-loaded getters.
 //
 exposeFormat('align', function () { return requireAlign(); });
-exposeFormat('errors', function () { return requireErrors$1(); });
+exposeFormat('errors', function () { return requireErrors(); });
 exposeFormat('cli', function () { return requireCli(); });
 exposeFormat('combine', function () { return requireCombine(); });
 exposeFormat('colorize', function () { return requireColorize(); });
@@ -3625,288 +3729,246 @@ var winstonTransport = {exports: {}};
 
 var modern = {exports: {}};
 
-var node$1;
-var hasRequiredNode;
+/**
+ * For Node.js, simply re-export the core `util.deprecate` function.
+ */
 
-function requireNode () {
-	if (hasRequiredNode) return node$1;
-	hasRequiredNode = 1;
-	/**
-	 * For Node.js, simply re-export the core `util.deprecate` function.
-	 */
+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;
+  }
 
-	node$1 = require$$0$2.deprecate;
-	return node$1;
-}
+  // we set destroyed to true before firing error callbacks in order
+  // to make it re-entrance safe in case destroy() is called within callbacks
 
-var stream$1;
-var hasRequiredStream$1;
+  if (this._readableState) {
+    this._readableState.destroyed = true;
+  }
 
-function requireStream$1 () {
-	if (hasRequiredStream$1) return stream$1;
-	hasRequiredStream$1 = 1;
-	stream$1 = require$$0$3;
-	return stream$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;
 }
-
-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;
+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);
+}
+var destroy_1 = {
+  destroy: destroy,
+  undestroy: undestroy,
+  errorOrDestroy: errorOrDestroy
+};
 
 var errors = {};
 
-var hasRequiredErrors;
-
-function requireErrors () {
-	if (hasRequiredErrors) return errors;
-	hasRequiredErrors = 1;
-
-	const codes = {};
-
-	function createErrorType(code, message, Base) {
-	  if (!Base) {
-	    Base = Error;
-	  }
-
-	  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;
-		}
-		return str.substring(this_len - search.length, this_len) === search;
-	}
+// 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)}`;
+  }
+}
 
-	// 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';
-	  }
-
-	  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')}`;
-	  }
+// 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;
+  }
 
-	  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;
+  if (start + search.length > str.length) {
+    return false;
+  } else {
+    return str.indexOf(search, start) !== -1;
+  }
 }
 
-var state;
-var hasRequiredState;
+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';
+  }
 
-function requireState () {
-	if (hasRequiredState) return state;
-	hasRequiredState = 1;
+  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')}`;
+  }
 
-	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);
-	  }
+  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;
+}
+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;
+  // Default value
+  return state.objectMode ? 16 : 16 * 1024;
 }
+var state = {
+  getHighWaterMark: getHighWaterMark
+};
 
 var inherits = {exports: {}};
 
@@ -3947,23 +4009,18 @@ function requireInherits_browser () {
 	return inherits_browser.exports;
 }
 
-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;
+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 inheritsExports = inherits.exports;
+
 var buffer_list;
 var hasRequiredBuffer_list;
 
@@ -4523,7 +4580,7 @@ function requireEndOfStream () {
 	if (hasRequiredEndOfStream) return endOfStream;
 	hasRequiredEndOfStream = 1;
 
-	var ERR_STREAM_PREMATURE_CLOSE = requireErrors().codes.ERR_STREAM_PREMATURE_CLOSE;
+	var ERR_STREAM_PREMATURE_CLOSE = errors.codes.ERR_STREAM_PREMATURE_CLOSE;
 	function once(callback) {
 	  var called = false;
 	  return function () {
@@ -4809,7 +4866,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 = requireErrors().codes.ERR_INVALID_ARG_TYPE;
+	var ERR_INVALID_ARG_TYPE = errors.codes.ERR_INVALID_ARG_TYPE;
 	function from(Readable, iterable, opts) {
 	  var iterator;
 	  if (iterable && typeof iterable.next === 'function') {
@@ -4878,7 +4935,7 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = requireStream$1();
+	var Stream = stream$1;
 	/*</replacement>*/
 
 	var Buffer = require$$0$4.Buffer;
@@ -4901,10 +4958,10 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	var BufferList = requireBuffer_list();
-	var destroyImpl = requireDestroy();
-	var _require = requireState(),
+	var destroyImpl = destroy_1;
+	var _require = state,
 	  getHighWaterMark = _require.getHighWaterMark;
-	var _require$codes = requireErrors().codes,
+	var _require$codes = errors.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,
@@ -4914,7 +4971,7 @@ function require_stream_readable () {
 	var StringDecoder;
 	var createReadableStreamAsyncIterator;
 	var from;
-	requireInherits()(Readable, Stream);
+	inheritsExports(Readable, Stream);
 	var errorOrDestroy = destroyImpl.errorOrDestroy;
 	var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
 	function prependListener(emitter, event, fn) {
@@ -5887,7 +5944,7 @@ function require_stream_duplex () {
 	_stream_duplex = Duplex;
 	var Readable = require_stream_readable();
 	var Writable = require_stream_writable();
-	requireInherits()(Duplex, Readable);
+	inheritsExports(Duplex, Readable);
 	{
 	  // Allow the keys array to be GC'ed.
 	  var keys = objectKeys(Writable.prototype);
@@ -6006,12 +6063,12 @@ function require_stream_writable () {
 
 	/*<replacement>*/
 	var internalUtil = {
-	  deprecate: requireNode()
+	  deprecate: node$1
 	};
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = requireStream$1();
+	var Stream = stream$1;
 	/*</replacement>*/
 
 	var Buffer = require$$0$4.Buffer;
@@ -6022,10 +6079,10 @@ function require_stream_writable () {
 	function _isUint8Array(obj) {
 	  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
 	}
-	var destroyImpl = requireDestroy();
-	var _require = requireState(),
+	var destroyImpl = destroy_1;
+	var _require = state,
 	  getHighWaterMark = _require.getHighWaterMark;
-	var _require$codes = requireErrors().codes,
+	var _require$codes = errors.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,
@@ -6035,7 +6092,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;
-	requireInherits()(Writable, Stream);
+	inheritsExports(Writable, Stream);
 	function nop() {}
 	function WritableState(options, stream, isDuplex) {
 	  Duplex = Duplex || require_stream_duplex();
@@ -8011,13 +8068,13 @@ function require_stream_transform () {
 	hasRequired_stream_transform = 1;
 
 	_stream_transform = Transform;
-	var _require$codes = requireErrors().codes,
+	var _require$codes = errors.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();
-	requireInherits()(Transform, Duplex);
+	inheritsExports(Transform, Duplex);
 	function afterTransform(er, data) {
 	  var ts = this._transformState;
 	  ts.transforming = false;
@@ -8147,7 +8204,7 @@ function require_stream_passthrough () {
 
 	_stream_passthrough = PassThrough;
 	var Transform = require_stream_transform();
-	requireInherits()(PassThrough, Transform);
+	inheritsExports(PassThrough, Transform);
 	function PassThrough(options) {
 	  if (!(this instanceof PassThrough)) return new PassThrough(options);
 	  Transform.call(this, options);
@@ -8174,7 +8231,7 @@ function requirePipeline () {
 	    callback.apply(void 0, arguments);
 	  };
 	}
-	var _require$codes = requireErrors().codes,
+	var _require$codes = errors.codes,
 	  ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
 	  ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
 	function noop(err) {
@@ -10949,7 +11006,7 @@ function requireTailFile () {
 	if (hasRequiredTailFile) return tailFile;
 	hasRequiredTailFile = 1;
 
-	const fs = require$$0$6;
+	const fs$1 = fs;
 	const { StringDecoder } = require$$1$1;
 	const { Stream } = readableExports;
 
@@ -10985,7 +11042,7 @@ function requireTailFile () {
 	    stream.emit('close');
 	  };
 
-	  fs.open(options.file, 'a+', '0644', (err, fd) => {
+	  fs$1.open(options.file, 'a+', '0644', (err, fd) => {
 	    if (err) {
 	      if (!iter) {
 	        stream.emit('error', err);
@@ -10998,11 +11055,11 @@ function requireTailFile () {
 
 	    (function read() {
 	      if (stream.destroyed) {
-	        fs.close(fd, noop);
+	        fs$1.close(fd, noop);
 	        return;
 	      }
 
-	      return fs.read(fd, buffer, 0, buffer.length, pos, (error, bytes) => {
+	      return fs$1.read(fd, buffer, 0, buffer.length, pos, (error, bytes) => {
 	        if (error) {
 	          if (!iter) {
 	            stream.emit('error', error);
@@ -11076,8 +11133,8 @@ function requireFile () {
 	if (hasRequiredFile) return file;
 	hasRequiredFile = 1;
 
-	const fs = require$$0$6;
-	const path = require$$1$2;
+	const fs$1 = fs;
+	const path$1 = path;
 	const asyncSeries = requireSeries();
 	const zlib = require$$3;
 	const { MESSAGE } = tripleBeam;
@@ -11124,17 +11181,17 @@ function requireFile () {
 	    if (options.filename || options.dirname) {
 	      throwIf('filename or dirname', 'stream');
 	      this._basename = this.filename = options.filename
-	        ? path.basename(options.filename)
+	        ? path$1.basename(options.filename)
 	        : 'winston.log';
 
-	      this.dirname = options.dirname || path.dirname(options.filename);
+	      this.dirname = options.dirname || path$1.dirname(options.filename);
 	      this.options = options.options || { flags: 'a' };
 	    } else if (options.stream) {
 	      // eslint-disable-next-line no-console
 	      console.warn('options.stream will be removed in winston@4. Use winston.transports.Stream');
 	      throwIf('stream', 'filename', 'maxsize');
 	      this._dest = this._stream.pipe(this._setupStream(options.stream));
-	      this.dirname = path.dirname(this._dest.path);
+	      this.dirname = path$1.dirname(this._dest.path);
 	      // We need to listen for drain events when write() returns false. This
 	      // can make node mad at times.
 	    } else {
@@ -11350,12 +11407,12 @@ function requireFile () {
 	    }
 
 	    options = normalizeQuery(options);
-	    const file = path.join(this.dirname, this.filename);
+	    const file = path$1.join(this.dirname, this.filename);
 	    let buff = '';
 	    let results = [];
 	    let row = 0;
 
-	    const stream = fs.createReadStream(file, {
+	    const stream = fs$1.createReadStream(file, {
 	      encoding: 'utf8'
 	    });
 
@@ -11493,7 +11550,7 @@ function requireFile () {
 	   * TODO: Refactor me.
 	   */
 	  stream(options = {}) {
-	    const file = path.join(this.dirname, this.filename);
+	    const file = path$1.join(this.dirname, this.filename);
 	    const stream = new Stream();
 	    const tail = {
 	      file,
@@ -11553,9 +11610,9 @@ function requireFile () {
 	   */
 	  stat(callback) {
 	    const target = this._getFile();
-	    const fullpath = path.join(this.dirname, target);
+	    const fullpath = path$1.join(this.dirname, target);
 
-	    fs.stat(fullpath, (err, stat) => {
+	    fs$1.stat(fullpath, (err, stat) => {
 	      if (err && err.code === 'ENOENT') {
 	        debug('ENOENT ok', fullpath);
 	        // Update internally tracked filename with the new target name.
@@ -11675,10 +11732,10 @@ function requireFile () {
 	   * @returns {WritableStream} Stream that writes to disk for the active file.
 	   */
 	  _createStream(source) {
-	    const fullpath = path.join(this.dirname, this.filename);
+	    const fullpath = path$1.join(this.dirname, this.filename);
 
 	    debug('create stream start', fullpath, this.options);
-	    const dest = fs.createWriteStream(fullpath, this.options)
+	    const dest = fs$1.createWriteStream(fullpath, this.options)
 	      // TODO: What should we do with errors here?
 	      .on('error', err => debug(err))
 	      .on('close', () => debug('close', dest.path, dest.bytesWritten))
@@ -11711,8 +11768,8 @@ function requireFile () {
 	   */
 	  _incFile(callback) {
 	    debug('_incFile', this.filename);
-	    const ext = path.extname(this._basename);
-	    const basename = path.basename(this._basename, ext);
+	    const ext = path$1.extname(this._basename);
+	    const basename = path$1.basename(this._basename, ext);
 	    const tasks = [];
 
 	    if (this.zippedArchive) {
@@ -11720,8 +11777,8 @@ function requireFile () {
 	        function (cb) {
 	          const num = this._created > 0 && !this.tailable ? this._created : '';
 	          this._compressFile(
-	            path.join(this.dirname, `${basename}${num}${ext}`),
-	            path.join(this.dirname, `${basename}${num}${ext}.gz`),
+	            path$1.join(this.dirname, `${basename}${num}${ext}`),
+	            path$1.join(this.dirname, `${basename}${num}${ext}.gz`),
 	            cb
 	          );
 	        }.bind(this)
@@ -11749,8 +11806,8 @@ function requireFile () {
 	   * @private
 	   */
 	  _getFile() {
-	    const ext = path.extname(this._basename);
-	    const basename = path.basename(this._basename, ext);
+	    const ext = path$1.extname(this._basename);
+	    const basename = path$1.basename(this._basename, ext);
 	    const isRotation = this.rotationFormat
 	      ? this.rotationFormat()
 	      : this._created;
@@ -11781,9 +11838,9 @@ function requireFile () {
 	    const isOldest = oldest !== 0 ? oldest : '';
 	    const isZipped = this.zippedArchive ? '.gz' : '';
 	    const filePath = `${basename}${isOldest}${ext}${isZipped}`;
-	    const target = path.join(this.dirname, filePath);
+	    const target = path$1.join(this.dirname, filePath);
 
-	    fs.unlink(target, callback);
+	    fs$1.unlink(target, callback);
 	  }
 
 	  /**
@@ -11808,23 +11865,23 @@ function requireFile () {
 	    for (let x = this.maxFiles - 1; x > 1; x--) {
 	      tasks.push(function (i, cb) {
 	        let fileName = `${basename}${(i - 1)}${ext}${isZipped}`;
-	        const tmppath = path.join(this.dirname, fileName);
+	        const tmppath = path$1.join(this.dirname, fileName);
 
-	        fs.exists(tmppath, exists => {
+	        fs$1.exists(tmppath, exists => {
 	          if (!exists) {
 	            return cb(null);
 	          }
 
 	          fileName = `${basename}${i}${ext}${isZipped}`;
-	          fs.rename(tmppath, path.join(this.dirname, fileName), cb);
+	          fs$1.rename(tmppath, path$1.join(this.dirname, fileName), cb);
 	        });
 	      }.bind(this, x));
 	    }
 
 	    asyncSeries(tasks, () => {
-	      fs.rename(
-	        path.join(this.dirname, `${basename}${ext}${isZipped}`),
-	        path.join(this.dirname, `${basename}1${ext}${isZipped}`),
+	      fs$1.rename(
+	        path$1.join(this.dirname, `${basename}${ext}${isZipped}`),
+	        path$1.join(this.dirname, `${basename}1${ext}${isZipped}`),
 	        callback
 	      );
 	    });
@@ -11839,15 +11896,15 @@ function requireFile () {
 	   * @private
 	   */
 	  _compressFile(src, dest, callback) {
-	    fs.access(src, fs.F_OK, (err) => {
+	    fs$1.access(src, fs$1.F_OK, (err) => {
 	      if (err) {
 	        return callback();
 	      }
 	      var gzip = zlib.createGzip();
-	      var inp = fs.createReadStream(src);
-	      var out = fs.createWriteStream(dest);
+	      var inp = fs$1.createReadStream(src);
+	      var out = fs$1.createWriteStream(dest);
 	      out.on('finish', () => {
-	        fs.unlink(src, callback);
+	        fs$1.unlink(src, callback);
 	      });
 	      inp.pipe(gzip).pipe(out);
 	    });
@@ -11855,8 +11912,8 @@ function requireFile () {
 
 	  _createLogDirIfNotExist(dirPath) {
 	    /* eslint-disable no-sync */
-	    if (!fs.existsSync(dirPath)) {
-	      fs.mkdirSync(dirPath, { recursive: true });
+	    if (!fs$1.existsSync(dirPath)) {
+	      fs$1.mkdirSync(dirPath, { recursive: true });
 	    }
 	    /* eslint-enable no-sync */
 	  }
@@ -11878,8 +11935,8 @@ function requireHttp () {
 	if (hasRequiredHttp) return http_1;
 	hasRequiredHttp = 1;
 
-	const http = require$$0$7;
-	const https = require$$1$3;
+	const http = require$$0$6;
+	const https = require$$1$2;
 	const { Stream } = readableExports;
 	const TransportStream = winstonTransportExports;
 	const { configure } = requireSafeStableStringify();