@putkoff/abstract-logger 0.0.60 → 0.0.63

package/dist/cjs/index.js

@@ -13,6 +13,145 @@ var require$$1$1 = require('string_decoder');
 var require$$0$6 = require('http');
 var require$$1$2 = require('https');
 
+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;
+}
+
+function parseList$1(key) {
+    const v = getEnvValue({ key });
+    return v ? v.split(",").map(s => s.trim()).filter(Boolean) : [];
+}
+function getLogConfig() {
+    return {
+        condensed: getEnvValue({ key: "LOG_CONDENSED" }) !== "false",
+        expandOnDebug: getEnvValue({ key: "LOG_EXPAND_DEBUG" }) !== "false",
+        showDetails: getEnvValue({ key: "LOG_SHOW_DETAILS" }) !== "false",
+        showOnly: getEnvValue({ key: "LOG_SHOW_ONLY" }) === "true",
+        showOnlyFunctions: parseList$1("LOG_SHOW_ONLY_FUNCTIONS"),
+        showOnlyActivities: parseList$1("LOG_SHOW_ONLY_ACTIVITIES"),
+        showOnlyTypes: parseList$1("LOG_SHOW_ONLY_TYPES"),
+        maxDetailsLength: Number(getEnvValue({ key: "LOG_DETAILS_MAX" }) ?? 500),
+        sampleRate: Number(getEnvValue({ key: "LOG_SAMPLE_RATE" }) ?? 1),
+        prettyDetails: getEnvValue({ key: "LOG_PRETTY_DETAILS" }) === "true",
+        activityBlocklist: parseList$1("LOG_ACTIVITY_BLOCKLIST"),
+        logTypeBlocklist: parseList$1("LOG_TYPE_BLOCKLIST"),
+        showDetailslist: parseList$1("LOG_DETAILS_ALLOWLIST"),
+        functionAllowlist: parseList$1("LOG_FUNCTION_ALLOWLIST"),
+        functionBlocklist: parseList$1("LOG_FUNCTION_BLOCKLIST"),
+    };
+}
+function debugLogConfig() {
+    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" }),
+        });
+    }
+}
+
 /* ------------------------------------------------------------------ */
 /* Stack inspection                                                    */
 /* ------------------------------------------------------------------ */
@@ -42,7 +181,7 @@ function resolveValue(...values) {
     }
     return sawInput ? "unknown" : "unknown";
 }
-function parseList$1(value) {
+function parseList(value) {
     return value
         ? value.split(",").map(s => s.trim()).filter(Boolean)
         : [];
@@ -184,145 +323,6 @@ 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;
-}
-
-function parseList(key) {
-    const v = getEnvValue({ key });
-    return v ? v.split(",").map(s => s.trim()).filter(Boolean) : [];
-}
-function getLogConfig() {
-    return {
-        condensed: getEnvValue({ key: "LOG_CONDENSED" }) !== "false",
-        expandOnDebug: getEnvValue({ key: "LOG_EXPAND_DEBUG" }) !== "false",
-        showDetails: getEnvValue({ key: "LOG_SHOW_DETAILS" }) !== "false",
-        showOnly: getEnvValue({ key: "LOG_SHOW_ONLY" }) === "true",
-        showOnlyFunctions: parseList("LOG_SHOW_ONLY_FUNCTIONS"),
-        showOnlyActivities: parseList("LOG_SHOW_ONLY_ACTIVITIES"),
-        showOnlyTypes: parseList("LOG_SHOW_ONLY_TYPES"),
-        maxDetailsLength: Number(getEnvValue({ key: "LOG_DETAILS_MAX" }) ?? 500),
-        sampleRate: Number(getEnvValue({ key: "LOG_SAMPLE_RATE" }) ?? 1),
-        prettyDetails: getEnvValue({ key: "LOG_PRETTY_DETAILS" }) === "true",
-        activityBlocklist: parseList("LOG_ACTIVITY_BLOCKLIST"),
-        logTypeBlocklist: parseList("LOG_TYPE_BLOCKLIST"),
-        showDetailslist: parseList("LOG_DETAILS_ALLOWLIST"),
-        functionAllowlist: parseList("LOG_FUNCTION_ALLOWLIST"),
-        functionBlocklist: parseList("LOG_FUNCTION_BLOCKLIST"),
-    };
-}
-function debugLogConfig() {
-    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" }),
-        });
-    }
-}
-
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
 function getAugmentedNamespace(n) {
@@ -1595,11 +1595,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;
@@ -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$1(); });
+exposeFormat('errors', function () { return requireErrors(); });
 exposeFormat('cli', function () { return requireCli(); });
 exposeFormat('combine', function () { return requireCombine(); });
 exposeFormat('colorize', function () { return requireColorize(); });
@@ -3726,288 +3726,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 = {};
+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)
-	    }
-	  }
-
-	  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: {}};
 
@@ -4048,23 +4006,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;
 
@@ -4624,7 +4577,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 () {
@@ -4910,7 +4863,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') {
@@ -4979,7 +4932,7 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = requireStream$1();
+	var Stream = stream$1;
 	/*</replacement>*/
 
 	var Buffer = require$$0$4.Buffer;
@@ -5002,10 +4955,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,
@@ -5015,7 +4968,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) {
@@ -5988,7 +5941,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);
@@ -6107,12 +6060,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;
@@ -6123,10 +6076,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,
@@ -6136,7 +6089,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();
@@ -8112,13 +8065,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;
@@ -8248,7 +8201,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);
@@ -8275,7 +8228,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) {
@@ -14911,6 +14864,14 @@ function formatLogLine({ emoji, timestamp, functionName, message, details, file,
     return line;
 }
 
+var LogMode;
+(function (LogMode) {
+    LogMode["FULL"] = "full";
+    LogMode["CONSOLE"] = "console";
+    LogMode["COUNT"] = "count";
+    LogMode["OFF"] = "off";
+})(LogMode || (LogMode = {}));
+
 const seen = new Map();
 function hash(str) {
     let h = 0;
@@ -14978,7 +14939,7 @@ function shouldLog(opts, caller) {
     return true;
 }
 
-function getLogString(messageOrOptions, logType = null, details = null, function_name = null, file_location = null, consumerLogger = null) {
+function logit(messageOrOptions, logType = null, details = null, function_name = null, file_location = null, consumerLogger = null) {
     /* -------------------------------------------------- */
     /* Normalize inputs                                   */
     /* -------------------------------------------------- */
@@ -14996,7 +14957,7 @@ function getLogString(messageOrOptions, logType = null, details = null, function
     /* -------------------------------------------------- */
     /* Caller info                                        */
     /* -------------------------------------------------- */
-    const caller = getCallerInfo(getLogString);
+    const caller = getCallerInfo(logit);
     /* -------------------------------------------------- */
     /* 🔒 Single source of truth for logType               */
     /* -------------------------------------------------- */
@@ -15046,6 +15007,136 @@ function getLogString(messageOrOptions, logType = null, details = null, function
     }), finalLogType, resolvedLoggerInput);
 }
 
+let mode = LogMode.COUNT; // 🔒 DEFAULT FASTEST
+const LATENCY_BUCKETS = [1000n, 10000n, 100000n, 1000000n];
+const stats = {
+    calls: 0,
+    totalNs: 0n,
+    byMode: {},
+    byType: {},
+    byFunction: {},
+    latency: {
+        buckets: LATENCY_BUCKETS.map(Number),
+        counts: new Array(LATENCY_BUCKETS.length + 1).fill(0),
+    },
+};
+function inc(map, key) {
+    if (!key)
+        return;
+    map[key] = (map[key] ?? 0) + 1;
+}
+function recordLatency(ns) {
+    let i = 0;
+    while (i < LATENCY_BUCKETS.length && ns > LATENCY_BUCKETS[i])
+        i++;
+    stats.latency.counts[i]++;
+}
+/* ---------------------------------- */
+/* Mode control (LOCKED)               */
+/* ---------------------------------- */
+function setLogMode(next) {
+    mode = next;
+}
+function getLogMode() {
+    return mode;
+}
+/* ---------------------------------- */
+/* Stats                               */
+/* ---------------------------------- */
+function getLogStats() {
+    return {
+        calls: stats.calls,
+        avgNs: stats.calls === 0
+            ? 0
+            : Number(stats.totalNs / BigInt(stats.calls)),
+        byMode: stats.byMode,
+        byType: stats.byType,
+        byFunction: stats.byFunction,
+        latency: stats.latency,
+    };
+}
+function resetLogStats() {
+    stats.calls = 0;
+    stats.totalNs = 0n;
+    stats.byMode = {};
+    stats.byType = {};
+    stats.byFunction = {};
+    stats.latency.counts.fill(0);
+}
+/* ---------------------------------- */
+/* Unified logging entry point         */
+/* ---------------------------------- */
+function logEvent(props) {
+    stats.calls++;
+    // 🔥 OFF = absolute fastest
+    if (mode === LogMode.OFF)
+        return;
+    const type = typeof props?.logType === "string" ? props.logType : "info";
+    inc(stats.byMode, mode);
+    inc(stats.byType, type);
+    inc(stats.byFunction, props?.function_name);
+    // ⚡ COUNT = no timers, no I/O
+    if (mode === LogMode.COUNT)
+        return;
+    const start = process.hrtime.bigint();
+    if (mode === LogMode.FULL) {
+        logit(props);
+    }
+    else if (mode === LogMode.CONSOLE) {
+        console.log(props);
+    }
+    const elapsed = process.hrtime.bigint() - start;
+    stats.totalNs += elapsed;
+    recordLatency(elapsed);
+}
+function setLogs(mode = null, interval = false, window_ms = null) {
+    const modes = [
+        LogMode.FULL,
+        LogMode.CONSOLE,
+        LogMode.COUNT,
+        LogMode.OFF,
+    ];
+    if (window_ms != false) {
+        if (window_ms === true || window_ms == null) {
+            window_ms = 30000;
+        }
+    }
+    if (interval != true) {
+        mode = mode || 3;
+        setLogMode(modes[mode]);
+        resetLogStats();
+    }
+    else {
+        let i = 0;
+        setInterval(() => {
+            window_ms || (window_ms = 30000);
+            recordBenchSnapshot(window_ms);
+            resetLogStats();
+            setLogMode(modes[++i % modes.length]);
+        }, window_ms);
+    }
+}
+
+const LOG_DIR = process.env.LOG_BENCH_DIR ??
+    path.resolve(process.cwd(), "log-bench");
+const FILE = path.join(LOG_DIR, "bench.ndjson");
+fs.mkdirSync(LOG_DIR, { recursive: true });
+function recordBenchSnapshot(windowMs) {
+    const stats = getLogStats();
+    const record = {
+        ts: new Date().toISOString(),
+        windowMs,
+        mode: getLogMode(),
+        calls: stats.calls,
+        avgNs: stats.avgNs,
+        byMode: stats.byMode,
+        byType: stats.byType,
+        byFunction: stats.byFunction,
+        latency: stats.latency,
+    };
+    fs.appendFileSync(FILE, JSON.stringify(record) + "\n");
+}
+
 exports.COLS = COLS;
 exports.IS_BROWSER = IS_BROWSER;
 exports.IS_NODE = IS_NODE;
@@ -15058,15 +15149,16 @@ exports.formatLogLine = formatLogLine;
 exports.getCallerInfo = getCallerInfo;
 exports.getFinalLine = getFinalLine;
 exports.getLogConfig = getLogConfig;
-exports.getLogString = getLogString;
+exports.getLogString = logEvent;
 exports.getNodeLogger = getNodeLogger;
 exports.logger = logger;
 exports.padLeft = padLeft;
 exports.padRight = padRight;
-exports.parseList = parseList$1;
+exports.parseList = parseList;
 exports.resolveLogger = resolveLogger;
 exports.resolveValue = resolveValue;
 exports.serializeDetails = serializeDetails;
+exports.setLogs = setLogs;
 exports.shouldCondense = shouldCondense;
 exports.shouldShowDetails = shouldShowDetails;
 exports.transports = winston.transports;