@sap/ux-ui5-tooling 1.12.3 → 1.12.5

package/dist/middlewares/fiori-tools-appreload.js

@@ -9307,10 +9307,10 @@ var require_common = __commonJS({
       createDebug.enable = enable;
       createDebug.enabled = enabled;
       createDebug.humanize = require_ms();
+      createDebug.destroy = destroy;
       Object.keys(env).forEach((key) => {
         createDebug[key] = env[key];
       });
-      createDebug.instances = [];
       createDebug.names = [];
       createDebug.skips = [];
       createDebug.formatters = {};
@@ -9325,6 +9325,9 @@ var require_common = __commonJS({
       createDebug.selectColor = selectColor;
       function createDebug(namespace) {
         let prevTime;
+        let enableOverride = null;
+        let namespacesCache;
+        let enabledCache;
         function debug(...args) {
           if (!debug.enabled) {
             return;
@@ -9343,7 +9346,7 @@ var require_common = __commonJS({
           let index2 = 0;
           args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format2) => {
             if (match === "%%") {
-              return match;
+              return "%";
             }
             index2++;
             const formatter = createDebug.formatters[format2];
@@ -9360,25 +9363,32 @@ var require_common = __commonJS({
           logFn.apply(self2, args);
         }
         debug.namespace = namespace;
-        debug.enabled = createDebug.enabled(namespace);
         debug.useColors = createDebug.useColors();
         debug.color = createDebug.selectColor(namespace);
-        debug.destroy = destroy;
         debug.extend = extend2;
+        debug.destroy = createDebug.destroy;
+        Object.defineProperty(debug, "enabled", {
+          enumerable: true,
+          configurable: false,
+          get: () => {
+            if (enableOverride !== null) {
+              return enableOverride;
+            }
+            if (namespacesCache !== createDebug.namespaces) {
+              namespacesCache = createDebug.namespaces;
+              enabledCache = createDebug.enabled(namespace);
+            }
+            return enabledCache;
+          },
+          set: (v) => {
+            enableOverride = v;
+          }
+        });
         if (typeof createDebug.init === "function") {
           createDebug.init(debug);
         }
-        createDebug.instances.push(debug);
         return debug;
       }
-      function destroy() {
-        const index2 = createDebug.instances.indexOf(this);
-        if (index2 !== -1) {
-          createDebug.instances.splice(index2, 1);
-          return true;
-        }
-        return false;
-      }
       function extend2(namespace, delimiter) {
         const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
         newDebug.log = this.log;
@@ -9386,6 +9396,7 @@ var require_common = __commonJS({
       }
       function enable(namespaces) {
         createDebug.save(namespaces);
+        createDebug.namespaces = namespaces;
         createDebug.names = [];
         createDebug.skips = [];
         let i;
@@ -9397,15 +9408,11 @@ var require_common = __commonJS({
           }
           namespaces = split[i].replace(/\*/g, ".*?");
           if (namespaces[0] === "-") {
-            createDebug.skips.push(new RegExp("^" + namespaces.substr(1) + "$"));
+            createDebug.skips.push(new RegExp("^" + namespaces.slice(1) + "$"));
           } else {
             createDebug.names.push(new RegExp("^" + namespaces + "$"));
           }
         }
-        for (i = 0; i < createDebug.instances.length; i++) {
-          const instance = createDebug.instances[i];
-          instance.enabled = createDebug.enabled(instance.namespace);
-        }
       }
       function disable() {
         const namespaces = [
@@ -9442,6 +9449,9 @@ var require_common = __commonJS({
         }
         return val;
       }
+      function destroy() {
+        console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+      }
       createDebug.enable(createDebug.load());
       return createDebug;
     }
@@ -9457,6 +9467,15 @@ var require_browser = __commonJS({
     exports.load = load;
     exports.useColors = useColors;
     exports.storage = localstorage();
+    exports.destroy = (() => {
+      let warned = false;
+      return () => {
+        if (!warned) {
+          warned = true;
+          console.warn("Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`.");
+        }
+      };
+    })();
     exports.colors = [
       "#0000CC",
       "#0000FF",
@@ -9735,6 +9754,11 @@ var require_node = __commonJS({
     exports.save = save;
     exports.load = load;
     exports.useColors = useColors;
+    exports.destroy = util2.deprecate(
+      () => {
+      },
+      "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
+    );
     exports.colors = [6, 2, 3, 4, 5, 1];
     try {
       const supportsColor = require_supports_color();
@@ -9884,7 +9908,7 @@ var require_node = __commonJS({
     var { formatters } = module2.exports;
     formatters.o = function(v) {
       this.inspectOpts.colors = this.useColors;
-      return util2.inspect(v, this.inspectOpts).replace(/\s*\n\s*/g, " ");
+      return util2.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
     };
     formatters.O = function(v) {
       this.inspectOpts.colors = this.useColors;
@@ -12667,7 +12691,9 @@ var require_node2 = __commonJS({
     var formatters = module2.exports.formatters;
     formatters.o = function(v) {
       this.inspectOpts.colors = this.useColors;
-      return util2.inspect(v, this.inspectOpts).replace(/\s*\n\s*/g, " ");
+      return util2.inspect(v, this.inspectOpts).split("\n").map(function(str) {
+        return str.trim();
+      }).join(" ");
     };
     formatters.O = function(v) {
       this.inspectOpts.colors = this.useColors;
@@ -14840,7 +14866,7 @@ var require_types = __commonJS({
       LogLevel2[LogLevel2["Verbose"] = 3] = "Verbose";
       LogLevel2[LogLevel2["Debug"] = 4] = "Debug";
       LogLevel2[LogLevel2["Silly"] = 5] = "Silly";
-    })(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+    })(LogLevel || (exports.LogLevel = LogLevel = {}));
     var Transport = class {
       /**
        * A utility copy method to make immutable, deep copies of objects
@@ -14863,16 +14889,16 @@ var require_node3 = __commonJS({
   }
 });
 
-// ../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/stream.js
+// ../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/internal/streams/stream.js
 var require_stream = __commonJS({
-  "../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/stream.js"(exports, module2) {
+  "../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/internal/streams/stream.js"(exports, module2) {
     module2.exports = require("stream");
   }
 });
 
-// ../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/destroy.js
+// ../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/internal/streams/destroy.js
 var require_destroy = __commonJS({
-  "../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/destroy.js"(exports, module2) {
+  "../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/internal/streams/destroy.js"(exports, module2) {
     "use strict";
     function destroy(err, cb) {
       var _this = this;
@@ -14963,9 +14989,9 @@ var require_destroy = __commonJS({
   }
 });
 
-// ../../node_modules/winston-transport/node_modules/readable-stream/errors.js
+// ../../node_modules/@sap-ux/logger/node_modules/readable-stream/errors.js
 var require_errors = __commonJS({
-  "../../node_modules/winston-transport/node_modules/readable-stream/errors.js"(exports, module2) {
+  "../../node_modules/@sap-ux/logger/node_modules/readable-stream/errors.js"(exports, module2) {
     "use strict";
     var codes = {};
     function createErrorType(code, message, Base) {
@@ -15063,9 +15089,9 @@ var require_errors = __commonJS({
   }
 });
 
-// ../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/state.js
+// ../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/internal/streams/state.js
 var require_state2 = __commonJS({
-  "../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/state.js"(exports, module2) {
+  "../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/internal/streams/state.js"(exports, module2) {
     "use strict";
     var ERR_INVALID_OPT_VALUE = require_errors().codes.ERR_INVALID_OPT_VALUE;
     function highWaterMarkFrom(options, isDuplex, duplexKey) {
@@ -15135,9 +15161,9 @@ var require_inherits = __commonJS({
   }
 });
 
-// ../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/buffer_list.js
+// ../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/internal/streams/buffer_list.js
 var require_buffer_list = __commonJS({
-  "../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/buffer_list.js"(exports, module2) {
+  "../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/internal/streams/buffer_list.js"(exports, module2) {
     "use strict";
     function ownKeys(object, enumerableOnly) {
       var keys = Object.keys(object);
@@ -15446,9 +15472,9 @@ var require_safe_buffer = __commonJS({
   }
 });
 
-// ../../node_modules/winston-transport/node_modules/string_decoder/lib/string_decoder.js
+// ../../node_modules/@sap-ux/logger/node_modules/string_decoder/lib/string_decoder.js
 var require_string_decoder = __commonJS({
-  "../../node_modules/winston-transport/node_modules/string_decoder/lib/string_decoder.js"(exports) {
+  "../../node_modules/@sap-ux/logger/node_modules/string_decoder/lib/string_decoder.js"(exports) {
     "use strict";
     var Buffer2 = require_safe_buffer().Buffer;
     var isEncoding = Buffer2.isEncoding || function(encoding) {
@@ -15706,9 +15732,9 @@ var require_string_decoder = __commonJS({
   }
 });
 
-// ../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/end-of-stream.js
+// ../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/internal/streams/end-of-stream.js
 var require_end_of_stream = __commonJS({
-  "../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/end-of-stream.js"(exports, module2) {
+  "../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/internal/streams/end-of-stream.js"(exports, module2) {
     "use strict";
     var ERR_STREAM_PREMATURE_CLOSE = require_errors().codes.ERR_STREAM_PREMATURE_CLOSE;
     function once2(callback) {
@@ -15807,9 +15833,9 @@ var require_end_of_stream = __commonJS({
   }
 });
 
-// ../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/async_iterator.js
+// ../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/internal/streams/async_iterator.js
 var require_async_iterator = __commonJS({
-  "../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/async_iterator.js"(exports, module2) {
+  "../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/internal/streams/async_iterator.js"(exports, module2) {
     "use strict";
     var _Object$setPrototypeO;
     function _defineProperty2(obj, key, value) {
@@ -15975,9 +16001,9 @@ var require_async_iterator = __commonJS({
   }
 });
 
-// ../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/from.js
+// ../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/internal/streams/from.js
 var require_from = __commonJS({
-  "../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/from.js"(exports, module2) {
+  "../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/internal/streams/from.js"(exports, module2) {
     "use strict";
     function asyncGeneratorStep(gen, resolve, reject2, _next, _throw, key, arg) {
       try {
@@ -16092,9 +16118,9 @@ var require_from = __commonJS({
   }
 });
 
-// ../../node_modules/winston-transport/node_modules/readable-stream/lib/_stream_readable.js
+// ../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/_stream_readable.js
 var require_stream_readable = __commonJS({
-  "../../node_modules/winston-transport/node_modules/readable-stream/lib/_stream_readable.js"(exports, module2) {
+  "../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/_stream_readable.js"(exports, module2) {
     "use strict";
     module2.exports = Readable2;
     var Duplex;
@@ -16890,9 +16916,9 @@ var require_stream_readable = __commonJS({
   }
 });
 
-// ../../node_modules/winston-transport/node_modules/readable-stream/lib/_stream_duplex.js
+// ../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/_stream_duplex.js
 var require_stream_duplex = __commonJS({
-  "../../node_modules/winston-transport/node_modules/readable-stream/lib/_stream_duplex.js"(exports, module2) {
+  "../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/_stream_duplex.js"(exports, module2) {
     "use strict";
     var objectKeys = Object.keys || function(obj) {
       var keys2 = [];
@@ -16990,9 +17016,9 @@ var require_stream_duplex = __commonJS({
   }
 });
 
-// ../../node_modules/winston-transport/node_modules/readable-stream/lib/_stream_writable.js
+// ../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/_stream_writable.js
 var require_stream_writable = __commonJS({
-  "../../node_modules/winston-transport/node_modules/readable-stream/lib/_stream_writable.js"(exports, module2) {
+  "../../node_modules/@sap-ux/logger/node_modules/readable-stream/lib/_stream_writable.js"(exports, module2) {
     "use strict";
     module2.exports = Writable;
     function CorkedRequest(state) {
@@ -17608,75 +17634,9 @@ var require_triple_beam = __commonJS({
   }
 });
 
-// ../../node_modules/winston-transport/legacy.js
-var require_legacy = __commonJS({
-  "../../node_modules/winston-transport/legacy.js"(exports, module2) {
-    "use strict";
-    var util2 = require("util");
-    var { LEVEL } = require_triple_beam();
-    var TransportStream = require_winston_transport();
-    var LegacyTransportStream = module2.exports = function LegacyTransportStream2(options = {}) {
-      TransportStream.call(this, options);
-      if (!options.transport || typeof options.transport.log !== "function") {
-        throw new Error("Invalid transport, must be an object with a log method.");
-      }
-      this.transport = options.transport;
-      this.level = this.level || options.transport.level;
-      this.handleExceptions = this.handleExceptions || options.transport.handleExceptions;
-      this._deprecated();
-      function transportError(err) {
-        this.emit("error", err, this.transport);
-      }
-      if (!this.transport.__winstonError) {
-        this.transport.__winstonError = transportError.bind(this);
-        this.transport.on("error", this.transport.__winstonError);
-      }
-    };
-    util2.inherits(LegacyTransportStream, TransportStream);
-    LegacyTransportStream.prototype._write = function _write(info, enc, callback) {
-      if (this.silent || info.exception === true && !this.handleExceptions) {
-        return callback(null);
-      }
-      if (!this.level || this.levels[this.level] >= this.levels[info[LEVEL]]) {
-        this.transport.log(info[LEVEL], info.message, info, this._nop);
-      }
-      callback(null);
-    };
-    LegacyTransportStream.prototype._writev = function _writev(chunks, callback) {
-      for (let i = 0; i < chunks.length; i++) {
-        if (this._accept(chunks[i])) {
-          this.transport.log(
-            chunks[i].chunk[LEVEL],
-            chunks[i].chunk.message,
-            chunks[i].chunk,
-            this._nop
-          );
-          chunks[i].callback();
-        }
-      }
-      return callback(null);
-    };
-    LegacyTransportStream.prototype._deprecated = function _deprecated() {
-      console.error([
-        `${this.transport.name} is a legacy winston transport. Consider upgrading: `,
-        "- Upgrade docs: https://github.com/winstonjs/winston/blob/master/UPGRADE-3.0.md"
-      ].join("\n"));
-    };
-    LegacyTransportStream.prototype.close = function close() {
-      if (this.transport.close) {
-        this.transport.close();
-      }
-      if (this.transport.__winstonError) {
-        this.transport.removeListener("error", this.transport.__winstonError);
-        this.transport.__winstonError = null;
-      }
-    };
-  }
-});
-
-// ../../node_modules/winston-transport/index.js
-var require_winston_transport = __commonJS({
-  "../../node_modules/winston-transport/index.js"(exports, module2) {
+// ../../node_modules/@sap-ux/logger/node_modules/winston-transport/modern.js
+var require_modern = __commonJS({
+  "../../node_modules/@sap-ux/logger/node_modules/winston-transport/modern.js"(exports, module2) {
     "use strict";
     var util2 = require("util");
     var Writable = require_stream_writable();
@@ -17788,6 +17748,80 @@ var require_winston_transport = __commonJS({
     TransportStream.prototype._nop = function _nop() {
       return void 0;
     };
+  }
+});
+
+// ../../node_modules/@sap-ux/logger/node_modules/winston-transport/legacy.js
+var require_legacy = __commonJS({
+  "../../node_modules/@sap-ux/logger/node_modules/winston-transport/legacy.js"(exports, module2) {
+    "use strict";
+    var util2 = require("util");
+    var { LEVEL } = require_triple_beam();
+    var TransportStream = require_modern();
+    var LegacyTransportStream = module2.exports = function LegacyTransportStream2(options = {}) {
+      TransportStream.call(this, options);
+      if (!options.transport || typeof options.transport.log !== "function") {
+        throw new Error("Invalid transport, must be an object with a log method.");
+      }
+      this.transport = options.transport;
+      this.level = this.level || options.transport.level;
+      this.handleExceptions = this.handleExceptions || options.transport.handleExceptions;
+      this._deprecated();
+      function transportError(err) {
+        this.emit("error", err, this.transport);
+      }
+      if (!this.transport.__winstonError) {
+        this.transport.__winstonError = transportError.bind(this);
+        this.transport.on("error", this.transport.__winstonError);
+      }
+    };
+    util2.inherits(LegacyTransportStream, TransportStream);
+    LegacyTransportStream.prototype._write = function _write(info, enc, callback) {
+      if (this.silent || info.exception === true && !this.handleExceptions) {
+        return callback(null);
+      }
+      if (!this.level || this.levels[this.level] >= this.levels[info[LEVEL]]) {
+        this.transport.log(info[LEVEL], info.message, info, this._nop);
+      }
+      callback(null);
+    };
+    LegacyTransportStream.prototype._writev = function _writev(chunks, callback) {
+      for (let i = 0; i < chunks.length; i++) {
+        if (this._accept(chunks[i])) {
+          this.transport.log(
+            chunks[i].chunk[LEVEL],
+            chunks[i].chunk.message,
+            chunks[i].chunk,
+            this._nop
+          );
+          chunks[i].callback();
+        }
+      }
+      return callback(null);
+    };
+    LegacyTransportStream.prototype._deprecated = function _deprecated() {
+      console.error([
+        `${this.transport.name} is a legacy winston transport. Consider upgrading: `,
+        "- Upgrade docs: https://github.com/winstonjs/winston/blob/master/UPGRADE-3.0.md"
+      ].join("\n"));
+    };
+    LegacyTransportStream.prototype.close = function close() {
+      if (this.transport.close) {
+        this.transport.close();
+      }
+      if (this.transport.__winstonError) {
+        this.transport.removeListener("error", this.transport.__winstonError);
+        this.transport.__winstonError = null;
+      }
+    };
+  }
+});
+
+// ../../node_modules/@sap-ux/logger/node_modules/winston-transport/index.js
+var require_winston_transport = __commonJS({
+  "../../node_modules/@sap-ux/logger/node_modules/winston-transport/index.js"(exports, module2) {
+    "use strict";
+    module2.exports = require_modern();
     module2.exports.LegacyTransportStream = require_legacy();
   }
 });
@@ -17866,9 +17900,10 @@ var require_transport = __commonJS({
     VSCodeTransport.instances = /* @__PURE__ */ new Map();
     var ArrayTransport = class extends winston_transport_1.default {
       constructor(opts) {
+        var _a;
         super({ level: typeof (opts === null || opts === void 0 ? void 0 : opts.logLevel) === "number" ? types_1.LogLevel[opts.logLevel].toLowerCase() : "debug" });
         this.copy = types_1.Transport.prototype.copy;
-        this.logs = (opts === null || opts === void 0 ? void 0 : opts.logs) || [];
+        this.logs = (_a = opts === null || opts === void 0 ? void 0 : opts.logs) !== null && _a !== void 0 ? _a : [];
       }
       log(info, next) {
         this.logs.push(info);
@@ -20352,20 +20387,6 @@ var require_common3 = __commonJS({
           obj[prop] = exports.warn[type](prop);
         });
       },
-      moved(obj, movedTo, prop) {
-        function movedNotice() {
-          return () => {
-            throw new Error([
-              format2("winston.%s was moved in winston@3.0.0.", prop),
-              format2("Use a winston.%s instead.", movedTo)
-            ].join("\n"));
-          };
-        }
-        Object.defineProperty(obj, prop, {
-          get: movedNotice,
-          set: movedNotice
-        });
-      },
       forProperties(obj, type, props) {
         props.forEach((prop) => {
           const notice = exports.warn[type](prop);
@@ -20385,7 +20406,7 @@ var require_package = __commonJS({
     module2.exports = {
       name: "winston",
       description: "A logger for just about everything.",
-      version: "3.7.2",
+      version: "3.11.0",
       author: "Charlie Robbins <charlie.robbins@gmail.com>",
       maintainers: [
         "David Hyde <dabh@alumni.stanford.edu>"
@@ -20409,6 +20430,7 @@ var require_package = __commonJS({
       ],
       dependencies: {
         "@dabh/diagnostics": "^2.0.2",
+        "@colors/colors": "^1.6.0",
         async: "^3.2.3",
         "is-stream": "^2.0.0",
         logform: "^2.4.0",
@@ -20423,9 +20445,8 @@ var require_package = __commonJS({
         "@babel/cli": "^7.17.0",
         "@babel/core": "^7.17.2",
         "@babel/preset-env": "^7.16.7",
-        "@colors/colors": "1.5.0",
         "@dabh/eslint-config-populist": "^5.0.0",
-        "@types/node": "^17.0.17",
+        "@types/node": "^20.3.1",
         "abstract-winston-transport": "^0.5.1",
         assume: "^2.2.0",
         "cross-spawn-async": "^2.2.5",
@@ -20433,13 +20454,13 @@ var require_package = __commonJS({
         hock: "^1.4.1",
         mocha: "8.1.3",
         nyc: "^15.1.0",
-        rimraf: "^3.0.2",
+        rimraf: "^5.0.5",
         split2: "^4.1.0",
         "std-mocks": "^1.0.1",
         through2: "^4.0.2",
         "winston-compat": "^0.1.5"
       },
-      main: "./lib/winston",
+      main: "./lib/winston.js",
       browser: "./dist/winston",
       types: "./index.d.ts",
       scripts: {
@@ -20459,48 +20480,2754 @@ var require_package = __commonJS({
   }
 });
 
-// ../../node_modules/winston/lib/winston/transports/console.js
-var require_console = __commonJS({
-  "../../node_modules/winston/lib/winston/transports/console.js"(exports, module2) {
+// ../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/stream.js
+var require_stream2 = __commonJS({
+  "../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/stream.js"(exports, module2) {
+    module2.exports = require("stream");
+  }
+});
+
+// ../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/destroy.js
+var require_destroy2 = __commonJS({
+  "../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/destroy.js"(exports, module2) {
     "use strict";
-    var os = require("os");
-    var { LEVEL, MESSAGE } = require_triple_beam();
-    var TransportStream = require_winston_transport();
-    module2.exports = class Console extends TransportStream {
-      /**
-       * Constructor function for the Console transport object responsible for
-       * persisting log messages and metadata to a terminal or TTY.
-       * @param {!Object} [options={}] - Options for this instance.
-       */
-      constructor(options = {}) {
-        super(options);
-        this.name = options.name || "console";
-        this.stderrLevels = this._stringArrayToSet(options.stderrLevels);
-        this.consoleWarnLevels = this._stringArrayToSet(options.consoleWarnLevels);
-        this.eol = typeof options.eol === "string" ? options.eol : os.EOL;
-        this.setMaxListeners(30);
-      }
-      /**
-       * Core logging method exposed to Winston.
-       * @param {Object} info - TODO: add param description.
-       * @param {Function} callback - TODO: add param description.
-       * @returns {undefined}
-       */
-      log(info, callback) {
-        setImmediate(() => this.emit("logged", info));
-        if (this.stderrLevels[info[LEVEL]]) {
-          if (console._stderr) {
-            console._stderr.write(`${info[MESSAGE]}${this.eol}`);
-          } else {
-            console.error(info[MESSAGE]);
-          }
-          if (callback) {
-            callback();
+    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;
-        } else if (this.consoleWarnLevels[info[LEVEL]]) {
-          if (console._stderr) {
-            console._stderr.write(`${info[MESSAGE]}${this.eol}`);
+        }
+        return this;
+      }
+      if (this._readableState) {
+        this._readableState.destroyed = true;
+      }
+      if (this._writableState) {
+        this._writableState.destroyed = true;
+      }
+      this._destroy(err || null, function(err2) {
+        if (!cb && err2) {
+          if (!_this._writableState) {
+            process.nextTick(emitErrorAndCloseNT, _this, err2);
+          } else if (!_this._writableState.errorEmitted) {
+            _this._writableState.errorEmitted = true;
+            process.nextTick(emitErrorAndCloseNT, _this, err2);
+          } else {
+            process.nextTick(emitCloseNT, _this);
+          }
+        } else if (cb) {
+          process.nextTick(emitCloseNT, _this);
+          cb(err2);
+        } else {
+          process.nextTick(emitCloseNT, _this);
+        }
+      });
+      return this;
+    }
+    function emitErrorAndCloseNT(self2, err) {
+      emitErrorNT(self2, err);
+      emitCloseNT(self2);
+    }
+    function emitCloseNT(self2) {
+      if (self2._writableState && !self2._writableState.emitClose)
+        return;
+      if (self2._readableState && !self2._readableState.emitClose)
+        return;
+      self2.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(self2, err) {
+      self2.emit("error", err);
+    }
+    function errorOrDestroy(stream4, err) {
+      var rState = stream4._readableState;
+      var wState = stream4._writableState;
+      if (rState && rState.autoDestroy || wState && wState.autoDestroy)
+        stream4.destroy(err);
+      else
+        stream4.emit("error", err);
+    }
+    module2.exports = {
+      destroy,
+      undestroy,
+      errorOrDestroy
+    };
+  }
+});
+
+// ../../node_modules/winston-transport/node_modules/readable-stream/errors.js
+var require_errors3 = __commonJS({
+  "../../node_modules/winston-transport/node_modules/readable-stream/errors.js"(exports, module2) {
+    "use strict";
+    var 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));
+        }
+      }
+      NodeError.prototype.name = Base.name;
+      NodeError.prototype.code = code;
+      codes[code] = NodeError;
+    }
+    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)}`;
+      }
+    }
+    function startsWith(str, search, pos) {
+      return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
+    }
+    function endsWith2(str, search, this_len) {
+      if (this_len === void 0 || this_len > str.length) {
+        this_len = str.length;
+      }
+      return str.substring(this_len - search.length, this_len) === search;
+    }
+    function includes(str, search, start) {
+      if (typeof start !== "number") {
+        start = 0;
+      }
+      if (start + search.length > str.length) {
+        return false;
+      } else {
+        return str.indexOf(search, start) !== -1;
+      }
+    }
+    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) {
+      let determiner;
+      if (typeof expected === "string" && startsWith(expected, "not ")) {
+        determiner = "must not be";
+        expected = expected.replace(/^not /, "");
+      } else {
+        determiner = "must be";
+      }
+      let msg;
+      if (endsWith2(name, " 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");
+    module2.exports.codes = codes;
+  }
+});
+
+// ../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/state.js
+var require_state3 = __commonJS({
+  "../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/state.js"(exports, module2) {
+    "use strict";
+    var ERR_INVALID_OPT_VALUE = require_errors3().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);
+      }
+      return state.objectMode ? 16 : 16 * 1024;
+    }
+    module2.exports = {
+      getHighWaterMark
+    };
+  }
+});
+
+// ../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/buffer_list.js
+var require_buffer_list2 = __commonJS({
+  "../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/buffer_list.js"(exports, module2) {
+    "use strict";
+    function ownKeys(object, enumerableOnly) {
+      var keys = Object.keys(object);
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly)
+          symbols = symbols.filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+          });
+        keys.push.apply(keys, symbols);
+      }
+      return keys;
+    }
+    function _objectSpread2(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i] != null ? arguments[i] : {};
+        if (i % 2) {
+          ownKeys(Object(source), true).forEach(function(key) {
+            _defineProperty2(target, key, source[key]);
+          });
+        } else if (Object.getOwnPropertyDescriptors) {
+          Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+        } else {
+          ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+          });
+        }
+      }
+      return target;
+    }
+    function _defineProperty2(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _classCallCheck2(instance, Constructor) {
+      if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+      }
+    }
+    function _defineProperties2(target, props) {
+      for (var i = 0; i < props.length; i++) {
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor)
+          descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+      }
+    }
+    function _createClass2(Constructor, protoProps, staticProps) {
+      if (protoProps)
+        _defineProperties2(Constructor.prototype, protoProps);
+      if (staticProps)
+        _defineProperties2(Constructor, staticProps);
+      return Constructor;
+    }
+    var _require = require("buffer");
+    var Buffer2 = _require.Buffer;
+    var _require2 = require("util");
+    var inspect = _require2.inspect;
+    var custom = inspect && inspect.custom || "inspect";
+    function copyBuffer(src, target, offset) {
+      Buffer2.prototype.copy.call(src, target, offset);
+    }
+    module2.exports = /* @__PURE__ */ function() {
+      function BufferList() {
+        _classCallCheck2(this, BufferList);
+        this.head = null;
+        this.tail = null;
+        this.length = 0;
+      }
+      _createClass2(BufferList, [{
+        key: "push",
+        value: function push(v) {
+          var entry = {
+            data: v,
+            next: null
+          };
+          if (this.length > 0)
+            this.tail.next = entry;
+          else
+            this.head = entry;
+          this.tail = entry;
+          ++this.length;
+        }
+      }, {
+        key: "unshift",
+        value: function unshift(v) {
+          var entry = {
+            data: v,
+            next: this.head
+          };
+          if (this.length === 0)
+            this.tail = entry;
+          this.head = entry;
+          ++this.length;
+        }
+      }, {
+        key: "shift",
+        value: function shift() {
+          if (this.length === 0)
+            return;
+          var ret = this.head.data;
+          if (this.length === 1)
+            this.head = this.tail = null;
+          else
+            this.head = this.head.next;
+          --this.length;
+          return ret;
+        }
+      }, {
+        key: "clear",
+        value: function clear() {
+          this.head = this.tail = null;
+          this.length = 0;
+        }
+      }, {
+        key: "join",
+        value: function join2(s) {
+          if (this.length === 0)
+            return "";
+          var p = this.head;
+          var ret = "" + p.data;
+          while (p = p.next) {
+            ret += s + p.data;
+          }
+          return ret;
+        }
+      }, {
+        key: "concat",
+        value: function concat2(n) {
+          if (this.length === 0)
+            return Buffer2.alloc(0);
+          var ret = Buffer2.allocUnsafe(n >>> 0);
+          var p = this.head;
+          var i = 0;
+          while (p) {
+            copyBuffer(p.data, ret, i);
+            i += p.data.length;
+            p = p.next;
+          }
+          return ret;
+        }
+        // Consumes a specified amount of bytes or characters from the buffered data.
+      }, {
+        key: "consume",
+        value: function consume(n, hasStrings) {
+          var ret;
+          if (n < this.head.data.length) {
+            ret = this.head.data.slice(0, n);
+            this.head.data = this.head.data.slice(n);
+          } else if (n === this.head.data.length) {
+            ret = this.shift();
+          } else {
+            ret = hasStrings ? this._getString(n) : this._getBuffer(n);
+          }
+          return ret;
+        }
+      }, {
+        key: "first",
+        value: function first() {
+          return this.head.data;
+        }
+        // Consumes a specified amount of characters from the buffered data.
+      }, {
+        key: "_getString",
+        value: function _getString(n) {
+          var p = this.head;
+          var c = 1;
+          var ret = p.data;
+          n -= ret.length;
+          while (p = p.next) {
+            var str = p.data;
+            var nb = n > str.length ? str.length : n;
+            if (nb === str.length)
+              ret += str;
+            else
+              ret += str.slice(0, n);
+            n -= nb;
+            if (n === 0) {
+              if (nb === str.length) {
+                ++c;
+                if (p.next)
+                  this.head = p.next;
+                else
+                  this.head = this.tail = null;
+              } else {
+                this.head = p;
+                p.data = str.slice(nb);
+              }
+              break;
+            }
+            ++c;
+          }
+          this.length -= c;
+          return ret;
+        }
+        // Consumes a specified amount of bytes from the buffered data.
+      }, {
+        key: "_getBuffer",
+        value: function _getBuffer(n) {
+          var ret = Buffer2.allocUnsafe(n);
+          var p = this.head;
+          var c = 1;
+          p.data.copy(ret);
+          n -= p.data.length;
+          while (p = p.next) {
+            var buf = p.data;
+            var nb = n > buf.length ? buf.length : n;
+            buf.copy(ret, ret.length - n, 0, nb);
+            n -= nb;
+            if (n === 0) {
+              if (nb === buf.length) {
+                ++c;
+                if (p.next)
+                  this.head = p.next;
+                else
+                  this.head = this.tail = null;
+              } else {
+                this.head = p;
+                p.data = buf.slice(nb);
+              }
+              break;
+            }
+            ++c;
+          }
+          this.length -= c;
+          return ret;
+        }
+        // Make sure the linked list only shows the minimal necessary information.
+      }, {
+        key: custom,
+        value: function value(_23, options) {
+          return inspect(this, _objectSpread2({}, options, {
+            // Only inspect one level.
+            depth: 0,
+            // It should not recurse.
+            customInspect: false
+          }));
+        }
+      }]);
+      return BufferList;
+    }();
+  }
+});
+
+// ../../node_modules/winston-transport/node_modules/string_decoder/lib/string_decoder.js
+var require_string_decoder2 = __commonJS({
+  "../../node_modules/winston-transport/node_modules/string_decoder/lib/string_decoder.js"(exports) {
+    "use strict";
+    var Buffer2 = require_safe_buffer().Buffer;
+    var isEncoding = Buffer2.isEncoding || function(encoding) {
+      encoding = "" + encoding;
+      switch (encoding && encoding.toLowerCase()) {
+        case "hex":
+        case "utf8":
+        case "utf-8":
+        case "ascii":
+        case "binary":
+        case "base64":
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+        case "raw":
+          return true;
+        default:
+          return false;
+      }
+    };
+    function _normalizeEncoding(enc) {
+      if (!enc)
+        return "utf8";
+      var retried;
+      while (true) {
+        switch (enc) {
+          case "utf8":
+          case "utf-8":
+            return "utf8";
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return "utf16le";
+          case "latin1":
+          case "binary":
+            return "latin1";
+          case "base64":
+          case "ascii":
+          case "hex":
+            return enc;
+          default:
+            if (retried)
+              return;
+            enc = ("" + enc).toLowerCase();
+            retried = true;
+        }
+      }
+    }
+    function normalizeEncoding(enc) {
+      var nenc = _normalizeEncoding(enc);
+      if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc)))
+        throw new Error("Unknown encoding: " + enc);
+      return nenc || enc;
+    }
+    exports.StringDecoder = StringDecoder;
+    function StringDecoder(encoding) {
+      this.encoding = normalizeEncoding(encoding);
+      var nb;
+      switch (this.encoding) {
+        case "utf16le":
+          this.text = utf16Text;
+          this.end = utf16End;
+          nb = 4;
+          break;
+        case "utf8":
+          this.fillLast = utf8FillLast;
+          nb = 4;
+          break;
+        case "base64":
+          this.text = base64Text;
+          this.end = base64End;
+          nb = 3;
+          break;
+        default:
+          this.write = simpleWrite;
+          this.end = simpleEnd;
+          return;
+      }
+      this.lastNeed = 0;
+      this.lastTotal = 0;
+      this.lastChar = Buffer2.allocUnsafe(nb);
+    }
+    StringDecoder.prototype.write = function(buf) {
+      if (buf.length === 0)
+        return "";
+      var r;
+      var i;
+      if (this.lastNeed) {
+        r = this.fillLast(buf);
+        if (r === void 0)
+          return "";
+        i = this.lastNeed;
+        this.lastNeed = 0;
+      } else {
+        i = 0;
+      }
+      if (i < buf.length)
+        return r ? r + this.text(buf, i) : this.text(buf, i);
+      return r || "";
+    };
+    StringDecoder.prototype.end = utf8End;
+    StringDecoder.prototype.text = utf8Text;
+    StringDecoder.prototype.fillLast = function(buf) {
+      if (this.lastNeed <= buf.length) {
+        buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
+        return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+      }
+      buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
+      this.lastNeed -= buf.length;
+    };
+    function utf8CheckByte(byte) {
+      if (byte <= 127)
+        return 0;
+      else if (byte >> 5 === 6)
+        return 2;
+      else if (byte >> 4 === 14)
+        return 3;
+      else if (byte >> 3 === 30)
+        return 4;
+      return byte >> 6 === 2 ? -1 : -2;
+    }
+    function utf8CheckIncomplete(self2, buf, i) {
+      var j = buf.length - 1;
+      if (j < i)
+        return 0;
+      var nb = utf8CheckByte(buf[j]);
+      if (nb >= 0) {
+        if (nb > 0)
+          self2.lastNeed = nb - 1;
+        return nb;
+      }
+      if (--j < i || nb === -2)
+        return 0;
+      nb = utf8CheckByte(buf[j]);
+      if (nb >= 0) {
+        if (nb > 0)
+          self2.lastNeed = nb - 2;
+        return nb;
+      }
+      if (--j < i || nb === -2)
+        return 0;
+      nb = utf8CheckByte(buf[j]);
+      if (nb >= 0) {
+        if (nb > 0) {
+          if (nb === 2)
+            nb = 0;
+          else
+            self2.lastNeed = nb - 3;
+        }
+        return nb;
+      }
+      return 0;
+    }
+    function utf8CheckExtraBytes(self2, buf, p) {
+      if ((buf[0] & 192) !== 128) {
+        self2.lastNeed = 0;
+        return "\uFFFD";
+      }
+      if (self2.lastNeed > 1 && buf.length > 1) {
+        if ((buf[1] & 192) !== 128) {
+          self2.lastNeed = 1;
+          return "\uFFFD";
+        }
+        if (self2.lastNeed > 2 && buf.length > 2) {
+          if ((buf[2] & 192) !== 128) {
+            self2.lastNeed = 2;
+            return "\uFFFD";
+          }
+        }
+      }
+    }
+    function utf8FillLast(buf) {
+      var p = this.lastTotal - this.lastNeed;
+      var r = utf8CheckExtraBytes(this, buf, p);
+      if (r !== void 0)
+        return r;
+      if (this.lastNeed <= buf.length) {
+        buf.copy(this.lastChar, p, 0, this.lastNeed);
+        return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+      }
+      buf.copy(this.lastChar, p, 0, buf.length);
+      this.lastNeed -= buf.length;
+    }
+    function utf8Text(buf, i) {
+      var total = utf8CheckIncomplete(this, buf, i);
+      if (!this.lastNeed)
+        return buf.toString("utf8", i);
+      this.lastTotal = total;
+      var end = buf.length - (total - this.lastNeed);
+      buf.copy(this.lastChar, 0, end);
+      return buf.toString("utf8", i, end);
+    }
+    function utf8End(buf) {
+      var r = buf && buf.length ? this.write(buf) : "";
+      if (this.lastNeed)
+        return r + "\uFFFD";
+      return r;
+    }
+    function utf16Text(buf, i) {
+      if ((buf.length - i) % 2 === 0) {
+        var r = buf.toString("utf16le", i);
+        if (r) {
+          var c = r.charCodeAt(r.length - 1);
+          if (c >= 55296 && c <= 56319) {
+            this.lastNeed = 2;
+            this.lastTotal = 4;
+            this.lastChar[0] = buf[buf.length - 2];
+            this.lastChar[1] = buf[buf.length - 1];
+            return r.slice(0, -1);
+          }
+        }
+        return r;
+      }
+      this.lastNeed = 1;
+      this.lastTotal = 2;
+      this.lastChar[0] = buf[buf.length - 1];
+      return buf.toString("utf16le", i, buf.length - 1);
+    }
+    function utf16End(buf) {
+      var r = buf && buf.length ? this.write(buf) : "";
+      if (this.lastNeed) {
+        var end = this.lastTotal - this.lastNeed;
+        return r + this.lastChar.toString("utf16le", 0, end);
+      }
+      return r;
+    }
+    function base64Text(buf, i) {
+      var n = (buf.length - i) % 3;
+      if (n === 0)
+        return buf.toString("base64", i);
+      this.lastNeed = 3 - n;
+      this.lastTotal = 3;
+      if (n === 1) {
+        this.lastChar[0] = buf[buf.length - 1];
+      } else {
+        this.lastChar[0] = buf[buf.length - 2];
+        this.lastChar[1] = buf[buf.length - 1];
+      }
+      return buf.toString("base64", i, buf.length - n);
+    }
+    function base64End(buf) {
+      var r = buf && buf.length ? this.write(buf) : "";
+      if (this.lastNeed)
+        return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
+      return r;
+    }
+    function simpleWrite(buf) {
+      return buf.toString(this.encoding);
+    }
+    function simpleEnd(buf) {
+      return buf && buf.length ? this.write(buf) : "";
+    }
+  }
+});
+
+// ../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/end-of-stream.js
+var require_end_of_stream2 = __commonJS({
+  "../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/end-of-stream.js"(exports, module2) {
+    "use strict";
+    var ERR_STREAM_PREMATURE_CLOSE = require_errors3().codes.ERR_STREAM_PREMATURE_CLOSE;
+    function once2(callback) {
+      var called = false;
+      return function() {
+        if (called)
+          return;
+        called = true;
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+        callback.apply(this, args);
+      };
+    }
+    function noop3() {
+    }
+    function isRequest(stream4) {
+      return stream4.setHeader && typeof stream4.abort === "function";
+    }
+    function eos(stream4, opts, callback) {
+      if (typeof opts === "function")
+        return eos(stream4, null, opts);
+      if (!opts)
+        opts = {};
+      callback = once2(callback || noop3);
+      var readable = opts.readable || opts.readable !== false && stream4.readable;
+      var writable = opts.writable || opts.writable !== false && stream4.writable;
+      var onlegacyfinish = function onlegacyfinish2() {
+        if (!stream4.writable)
+          onfinish();
+      };
+      var writableEnded = stream4._writableState && stream4._writableState.finished;
+      var onfinish = function onfinish2() {
+        writable = false;
+        writableEnded = true;
+        if (!readable)
+          callback.call(stream4);
+      };
+      var readableEnded = stream4._readableState && stream4._readableState.endEmitted;
+      var onend = function onend2() {
+        readable = false;
+        readableEnded = true;
+        if (!writable)
+          callback.call(stream4);
+      };
+      var onerror = function onerror2(err) {
+        callback.call(stream4, err);
+      };
+      var onclose = function onclose2() {
+        var err;
+        if (readable && !readableEnded) {
+          if (!stream4._readableState || !stream4._readableState.ended)
+            err = new ERR_STREAM_PREMATURE_CLOSE();
+          return callback.call(stream4, err);
+        }
+        if (writable && !writableEnded) {
+          if (!stream4._writableState || !stream4._writableState.ended)
+            err = new ERR_STREAM_PREMATURE_CLOSE();
+          return callback.call(stream4, err);
+        }
+      };
+      var onrequest = function onrequest2() {
+        stream4.req.on("finish", onfinish);
+      };
+      if (isRequest(stream4)) {
+        stream4.on("complete", onfinish);
+        stream4.on("abort", onclose);
+        if (stream4.req)
+          onrequest();
+        else
+          stream4.on("request", onrequest);
+      } else if (writable && !stream4._writableState) {
+        stream4.on("end", onlegacyfinish);
+        stream4.on("close", onlegacyfinish);
+      }
+      stream4.on("end", onend);
+      stream4.on("finish", onfinish);
+      if (opts.error !== false)
+        stream4.on("error", onerror);
+      stream4.on("close", onclose);
+      return function() {
+        stream4.removeListener("complete", onfinish);
+        stream4.removeListener("abort", onclose);
+        stream4.removeListener("request", onrequest);
+        if (stream4.req)
+          stream4.req.removeListener("finish", onfinish);
+        stream4.removeListener("end", onlegacyfinish);
+        stream4.removeListener("close", onlegacyfinish);
+        stream4.removeListener("finish", onfinish);
+        stream4.removeListener("end", onend);
+        stream4.removeListener("error", onerror);
+        stream4.removeListener("close", onclose);
+      };
+    }
+    module2.exports = eos;
+  }
+});
+
+// ../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/async_iterator.js
+var require_async_iterator2 = __commonJS({
+  "../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/async_iterator.js"(exports, module2) {
+    "use strict";
+    var _Object$setPrototypeO;
+    function _defineProperty2(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    var finished = require_end_of_stream2();
+    var kLastResolve = Symbol("lastResolve");
+    var kLastReject = Symbol("lastReject");
+    var kError = Symbol("error");
+    var kEnded = Symbol("ended");
+    var kLastPromise = Symbol("lastPromise");
+    var kHandlePromise = Symbol("handlePromise");
+    var kStream = Symbol("stream");
+    function createIterResult(value, done) {
+      return {
+        value,
+        done
+      };
+    }
+    function readAndResolve(iter) {
+      var resolve = iter[kLastResolve];
+      if (resolve !== null) {
+        var data = iter[kStream].read();
+        if (data !== null) {
+          iter[kLastPromise] = null;
+          iter[kLastResolve] = null;
+          iter[kLastReject] = null;
+          resolve(createIterResult(data, false));
+        }
+      }
+    }
+    function onReadable(iter) {
+      process.nextTick(readAndResolve, iter);
+    }
+    function wrapForNext(lastPromise, iter) {
+      return function(resolve, reject2) {
+        lastPromise.then(function() {
+          if (iter[kEnded]) {
+            resolve(createIterResult(void 0, true));
+            return;
+          }
+          iter[kHandlePromise](resolve, reject2);
+        }, reject2);
+      };
+    }
+    var AsyncIteratorPrototype = Object.getPrototypeOf(function() {
+    });
+    var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
+      get stream() {
+        return this[kStream];
+      },
+      next: function next() {
+        var _this = this;
+        var error2 = this[kError];
+        if (error2 !== null) {
+          return Promise.reject(error2);
+        }
+        if (this[kEnded]) {
+          return Promise.resolve(createIterResult(void 0, true));
+        }
+        if (this[kStream].destroyed) {
+          return new Promise(function(resolve, reject2) {
+            process.nextTick(function() {
+              if (_this[kError]) {
+                reject2(_this[kError]);
+              } else {
+                resolve(createIterResult(void 0, true));
+              }
+            });
+          });
+        }
+        var lastPromise = this[kLastPromise];
+        var promise;
+        if (lastPromise) {
+          promise = new Promise(wrapForNext(lastPromise, this));
+        } else {
+          var data = this[kStream].read();
+          if (data !== null) {
+            return Promise.resolve(createIterResult(data, false));
+          }
+          promise = new Promise(this[kHandlePromise]);
+        }
+        this[kLastPromise] = promise;
+        return promise;
+      }
+    }, _defineProperty2(_Object$setPrototypeO, Symbol.asyncIterator, function() {
+      return this;
+    }), _defineProperty2(_Object$setPrototypeO, "return", function _return() {
+      var _this2 = this;
+      return new Promise(function(resolve, reject2) {
+        _this2[kStream].destroy(null, function(err) {
+          if (err) {
+            reject2(err);
+            return;
+          }
+          resolve(createIterResult(void 0, true));
+        });
+      });
+    }), _Object$setPrototypeO), AsyncIteratorPrototype);
+    var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator2(stream4) {
+      var _Object$create;
+      var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty2(_Object$create, kStream, {
+        value: stream4,
+        writable: true
+      }), _defineProperty2(_Object$create, kLastResolve, {
+        value: null,
+        writable: true
+      }), _defineProperty2(_Object$create, kLastReject, {
+        value: null,
+        writable: true
+      }), _defineProperty2(_Object$create, kError, {
+        value: null,
+        writable: true
+      }), _defineProperty2(_Object$create, kEnded, {
+        value: stream4._readableState.endEmitted,
+        writable: true
+      }), _defineProperty2(_Object$create, kHandlePromise, {
+        value: function value(resolve, reject2) {
+          var data = iterator[kStream].read();
+          if (data) {
+            iterator[kLastPromise] = null;
+            iterator[kLastResolve] = null;
+            iterator[kLastReject] = null;
+            resolve(createIterResult(data, false));
+          } else {
+            iterator[kLastResolve] = resolve;
+            iterator[kLastReject] = reject2;
+          }
+        },
+        writable: true
+      }), _Object$create));
+      iterator[kLastPromise] = null;
+      finished(stream4, function(err) {
+        if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+          var reject2 = iterator[kLastReject];
+          if (reject2 !== null) {
+            iterator[kLastPromise] = null;
+            iterator[kLastResolve] = null;
+            iterator[kLastReject] = null;
+            reject2(err);
+          }
+          iterator[kError] = err;
+          return;
+        }
+        var resolve = iterator[kLastResolve];
+        if (resolve !== null) {
+          iterator[kLastPromise] = null;
+          iterator[kLastResolve] = null;
+          iterator[kLastReject] = null;
+          resolve(createIterResult(void 0, true));
+        }
+        iterator[kEnded] = true;
+      });
+      stream4.on("readable", onReadable.bind(null, iterator));
+      return iterator;
+    };
+    module2.exports = createReadableStreamAsyncIterator;
+  }
+});
+
+// ../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/from.js
+var require_from2 = __commonJS({
+  "../../node_modules/winston-transport/node_modules/readable-stream/lib/internal/streams/from.js"(exports, module2) {
+    "use strict";
+    function asyncGeneratorStep(gen, resolve, reject2, _next, _throw, key, arg) {
+      try {
+        var info = gen[key](arg);
+        var value = info.value;
+      } catch (error2) {
+        reject2(error2);
+        return;
+      }
+      if (info.done) {
+        resolve(value);
+      } else {
+        Promise.resolve(value).then(_next, _throw);
+      }
+    }
+    function _asyncToGenerator(fn) {
+      return function() {
+        var self2 = this, args = arguments;
+        return new Promise(function(resolve, reject2) {
+          var gen = fn.apply(self2, args);
+          function _next(value) {
+            asyncGeneratorStep(gen, resolve, reject2, _next, _throw, "next", value);
+          }
+          function _throw(err) {
+            asyncGeneratorStep(gen, resolve, reject2, _next, _throw, "throw", err);
+          }
+          _next(void 0);
+        });
+      };
+    }
+    function ownKeys(object, enumerableOnly) {
+      var keys = Object.keys(object);
+      if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly)
+          symbols = symbols.filter(function(sym) {
+            return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+          });
+        keys.push.apply(keys, symbols);
+      }
+      return keys;
+    }
+    function _objectSpread2(target) {
+      for (var i = 1; i < arguments.length; i++) {
+        var source = arguments[i] != null ? arguments[i] : {};
+        if (i % 2) {
+          ownKeys(Object(source), true).forEach(function(key) {
+            _defineProperty2(target, key, source[key]);
+          });
+        } else if (Object.getOwnPropertyDescriptors) {
+          Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+        } else {
+          ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+          });
+        }
+      }
+      return target;
+    }
+    function _defineProperty2(obj, key, value) {
+      if (key in obj) {
+        Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
+      } else {
+        obj[key] = value;
+      }
+      return obj;
+    }
+    var ERR_INVALID_ARG_TYPE = require_errors3().codes.ERR_INVALID_ARG_TYPE;
+    function from(Readable2, iterable, opts) {
+      var iterator;
+      if (iterable && typeof iterable.next === "function") {
+        iterator = iterable;
+      } else if (iterable && iterable[Symbol.asyncIterator])
+        iterator = iterable[Symbol.asyncIterator]();
+      else if (iterable && iterable[Symbol.iterator])
+        iterator = iterable[Symbol.iterator]();
+      else
+        throw new ERR_INVALID_ARG_TYPE("iterable", ["Iterable"], iterable);
+      var readable = new Readable2(_objectSpread2({
+        objectMode: true
+      }, opts));
+      var reading = false;
+      readable._read = function() {
+        if (!reading) {
+          reading = true;
+          next();
+        }
+      };
+      function next() {
+        return _next2.apply(this, arguments);
+      }
+      function _next2() {
+        _next2 = _asyncToGenerator(function* () {
+          try {
+            var _ref = yield iterator.next(), value = _ref.value, done = _ref.done;
+            if (done) {
+              readable.push(null);
+            } else if (readable.push(yield value)) {
+              next();
+            } else {
+              reading = false;
+            }
+          } catch (err) {
+            readable.destroy(err);
+          }
+        });
+        return _next2.apply(this, arguments);
+      }
+      return readable;
+    }
+    module2.exports = from;
+  }
+});
+
+// ../../node_modules/winston-transport/node_modules/readable-stream/lib/_stream_readable.js
+var require_stream_readable2 = __commonJS({
+  "../../node_modules/winston-transport/node_modules/readable-stream/lib/_stream_readable.js"(exports, module2) {
+    "use strict";
+    module2.exports = Readable2;
+    var Duplex;
+    Readable2.ReadableState = ReadableState;
+    var EE = require("events").EventEmitter;
+    var EElistenerCount = function EElistenerCount2(emitter, type) {
+      return emitter.listeners(type).length;
+    };
+    var Stream = require_stream2();
+    var Buffer2 = require("buffer").Buffer;
+    var OurUint8Array = global.Uint8Array || function() {
+    };
+    function _uint8ArrayToBuffer(chunk) {
+      return Buffer2.from(chunk);
+    }
+    function _isUint8Array(obj) {
+      return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
+    }
+    var debugUtil = require("util");
+    var debug;
+    if (debugUtil && debugUtil.debuglog) {
+      debug = debugUtil.debuglog("stream");
+    } else {
+      debug = function debug2() {
+      };
+    }
+    var BufferList = require_buffer_list2();
+    var destroyImpl = require_destroy2();
+    var _require = require_state3();
+    var getHighWaterMark = _require.getHighWaterMark;
+    var _require$codes = require_errors3().codes;
+    var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
+    var ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF;
+    var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
+    var ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT;
+    var StringDecoder;
+    var createReadableStreamAsyncIterator;
+    var from;
+    require_inherits()(Readable2, Stream);
+    var errorOrDestroy = destroyImpl.errorOrDestroy;
+    var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
+    function prependListener(emitter, event, fn) {
+      if (typeof emitter.prependListener === "function")
+        return emitter.prependListener(event, fn);
+      if (!emitter._events || !emitter._events[event])
+        emitter.on(event, fn);
+      else if (Array.isArray(emitter._events[event]))
+        emitter._events[event].unshift(fn);
+      else
+        emitter._events[event] = [fn, emitter._events[event]];
+    }
+    function ReadableState(options, stream4, isDuplex) {
+      Duplex = Duplex || require_stream_duplex2();
+      options = options || {};
+      if (typeof isDuplex !== "boolean")
+        isDuplex = stream4 instanceof Duplex;
+      this.objectMode = !!options.objectMode;
+      if (isDuplex)
+        this.objectMode = this.objectMode || !!options.readableObjectMode;
+      this.highWaterMark = getHighWaterMark(this, options, "readableHighWaterMark", isDuplex);
+      this.buffer = new BufferList();
+      this.length = 0;
+      this.pipes = null;
+      this.pipesCount = 0;
+      this.flowing = null;
+      this.ended = false;
+      this.endEmitted = false;
+      this.reading = false;
+      this.sync = true;
+      this.needReadable = false;
+      this.emittedReadable = false;
+      this.readableListening = false;
+      this.resumeScheduled = false;
+      this.paused = true;
+      this.emitClose = options.emitClose !== false;
+      this.autoDestroy = !!options.autoDestroy;
+      this.destroyed = false;
+      this.defaultEncoding = options.defaultEncoding || "utf8";
+      this.awaitDrain = 0;
+      this.readingMore = false;
+      this.decoder = null;
+      this.encoding = null;
+      if (options.encoding) {
+        if (!StringDecoder)
+          StringDecoder = require_string_decoder2().StringDecoder;
+        this.decoder = new StringDecoder(options.encoding);
+        this.encoding = options.encoding;
+      }
+    }
+    function Readable2(options) {
+      Duplex = Duplex || require_stream_duplex2();
+      if (!(this instanceof Readable2))
+        return new Readable2(options);
+      var isDuplex = this instanceof Duplex;
+      this._readableState = new ReadableState(options, this, isDuplex);
+      this.readable = true;
+      if (options) {
+        if (typeof options.read === "function")
+          this._read = options.read;
+        if (typeof options.destroy === "function")
+          this._destroy = options.destroy;
+      }
+      Stream.call(this);
+    }
+    Object.defineProperty(Readable2.prototype, "destroyed", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function get2() {
+        if (this._readableState === void 0) {
+          return false;
+        }
+        return this._readableState.destroyed;
+      },
+      set: function set(value) {
+        if (!this._readableState) {
+          return;
+        }
+        this._readableState.destroyed = value;
+      }
+    });
+    Readable2.prototype.destroy = destroyImpl.destroy;
+    Readable2.prototype._undestroy = destroyImpl.undestroy;
+    Readable2.prototype._destroy = function(err, cb) {
+      cb(err);
+    };
+    Readable2.prototype.push = function(chunk, encoding) {
+      var state = this._readableState;
+      var skipChunkCheck;
+      if (!state.objectMode) {
+        if (typeof chunk === "string") {
+          encoding = encoding || state.defaultEncoding;
+          if (encoding !== state.encoding) {
+            chunk = Buffer2.from(chunk, encoding);
+            encoding = "";
+          }
+          skipChunkCheck = true;
+        }
+      } else {
+        skipChunkCheck = true;
+      }
+      return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
+    };
+    Readable2.prototype.unshift = function(chunk) {
+      return readableAddChunk(this, chunk, null, true, false);
+    };
+    function readableAddChunk(stream4, chunk, encoding, addToFront, skipChunkCheck) {
+      debug("readableAddChunk", chunk);
+      var state = stream4._readableState;
+      if (chunk === null) {
+        state.reading = false;
+        onEofChunk(stream4, state);
+      } else {
+        var er;
+        if (!skipChunkCheck)
+          er = chunkInvalid(state, chunk);
+        if (er) {
+          errorOrDestroy(stream4, er);
+        } else if (state.objectMode || chunk && chunk.length > 0) {
+          if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer2.prototype) {
+            chunk = _uint8ArrayToBuffer(chunk);
+          }
+          if (addToFront) {
+            if (state.endEmitted)
+              errorOrDestroy(stream4, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());
+            else
+              addChunk(stream4, state, chunk, true);
+          } else if (state.ended) {
+            errorOrDestroy(stream4, new ERR_STREAM_PUSH_AFTER_EOF());
+          } else if (state.destroyed) {
+            return false;
+          } else {
+            state.reading = false;
+            if (state.decoder && !encoding) {
+              chunk = state.decoder.write(chunk);
+              if (state.objectMode || chunk.length !== 0)
+                addChunk(stream4, state, chunk, false);
+              else
+                maybeReadMore(stream4, state);
+            } else {
+              addChunk(stream4, state, chunk, false);
+            }
+          }
+        } else if (!addToFront) {
+          state.reading = false;
+          maybeReadMore(stream4, state);
+        }
+      }
+      return !state.ended && (state.length < state.highWaterMark || state.length === 0);
+    }
+    function addChunk(stream4, state, chunk, addToFront) {
+      if (state.flowing && state.length === 0 && !state.sync) {
+        state.awaitDrain = 0;
+        stream4.emit("data", chunk);
+      } else {
+        state.length += state.objectMode ? 1 : chunk.length;
+        if (addToFront)
+          state.buffer.unshift(chunk);
+        else
+          state.buffer.push(chunk);
+        if (state.needReadable)
+          emitReadable(stream4);
+      }
+      maybeReadMore(stream4, state);
+    }
+    function chunkInvalid(state, chunk) {
+      var er;
+      if (!_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== void 0 && !state.objectMode) {
+        er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);
+      }
+      return er;
+    }
+    Readable2.prototype.isPaused = function() {
+      return this._readableState.flowing === false;
+    };
+    Readable2.prototype.setEncoding = function(enc) {
+      if (!StringDecoder)
+        StringDecoder = require_string_decoder2().StringDecoder;
+      var decoder = new StringDecoder(enc);
+      this._readableState.decoder = decoder;
+      this._readableState.encoding = this._readableState.decoder.encoding;
+      var p = this._readableState.buffer.head;
+      var content = "";
+      while (p !== null) {
+        content += decoder.write(p.data);
+        p = p.next;
+      }
+      this._readableState.buffer.clear();
+      if (content !== "")
+        this._readableState.buffer.push(content);
+      this._readableState.length = content.length;
+      return this;
+    };
+    var MAX_HWM = 1073741824;
+    function computeNewHighWaterMark(n) {
+      if (n >= MAX_HWM) {
+        n = MAX_HWM;
+      } else {
+        n--;
+        n |= n >>> 1;
+        n |= n >>> 2;
+        n |= n >>> 4;
+        n |= n >>> 8;
+        n |= n >>> 16;
+        n++;
+      }
+      return n;
+    }
+    function howMuchToRead(n, state) {
+      if (n <= 0 || state.length === 0 && state.ended)
+        return 0;
+      if (state.objectMode)
+        return 1;
+      if (n !== n) {
+        if (state.flowing && state.length)
+          return state.buffer.head.data.length;
+        else
+          return state.length;
+      }
+      if (n > state.highWaterMark)
+        state.highWaterMark = computeNewHighWaterMark(n);
+      if (n <= state.length)
+        return n;
+      if (!state.ended) {
+        state.needReadable = true;
+        return 0;
+      }
+      return state.length;
+    }
+    Readable2.prototype.read = function(n) {
+      debug("read", n);
+      n = parseInt(n, 10);
+      var state = this._readableState;
+      var nOrig = n;
+      if (n !== 0)
+        state.emittedReadable = false;
+      if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {
+        debug("read: emitReadable", state.length, state.ended);
+        if (state.length === 0 && state.ended)
+          endReadable(this);
+        else
+          emitReadable(this);
+        return null;
+      }
+      n = howMuchToRead(n, state);
+      if (n === 0 && state.ended) {
+        if (state.length === 0)
+          endReadable(this);
+        return null;
+      }
+      var doRead = state.needReadable;
+      debug("need readable", doRead);
+      if (state.length === 0 || state.length - n < state.highWaterMark) {
+        doRead = true;
+        debug("length less than watermark", doRead);
+      }
+      if (state.ended || state.reading) {
+        doRead = false;
+        debug("reading or ended", doRead);
+      } else if (doRead) {
+        debug("do read");
+        state.reading = true;
+        state.sync = true;
+        if (state.length === 0)
+          state.needReadable = true;
+        this._read(state.highWaterMark);
+        state.sync = false;
+        if (!state.reading)
+          n = howMuchToRead(nOrig, state);
+      }
+      var ret;
+      if (n > 0)
+        ret = fromList(n, state);
+      else
+        ret = null;
+      if (ret === null) {
+        state.needReadable = state.length <= state.highWaterMark;
+        n = 0;
+      } else {
+        state.length -= n;
+        state.awaitDrain = 0;
+      }
+      if (state.length === 0) {
+        if (!state.ended)
+          state.needReadable = true;
+        if (nOrig !== n && state.ended)
+          endReadable(this);
+      }
+      if (ret !== null)
+        this.emit("data", ret);
+      return ret;
+    };
+    function onEofChunk(stream4, state) {
+      debug("onEofChunk");
+      if (state.ended)
+        return;
+      if (state.decoder) {
+        var chunk = state.decoder.end();
+        if (chunk && chunk.length) {
+          state.buffer.push(chunk);
+          state.length += state.objectMode ? 1 : chunk.length;
+        }
+      }
+      state.ended = true;
+      if (state.sync) {
+        emitReadable(stream4);
+      } else {
+        state.needReadable = false;
+        if (!state.emittedReadable) {
+          state.emittedReadable = true;
+          emitReadable_(stream4);
+        }
+      }
+    }
+    function emitReadable(stream4) {
+      var state = stream4._readableState;
+      debug("emitReadable", state.needReadable, state.emittedReadable);
+      state.needReadable = false;
+      if (!state.emittedReadable) {
+        debug("emitReadable", state.flowing);
+        state.emittedReadable = true;
+        process.nextTick(emitReadable_, stream4);
+      }
+    }
+    function emitReadable_(stream4) {
+      var state = stream4._readableState;
+      debug("emitReadable_", state.destroyed, state.length, state.ended);
+      if (!state.destroyed && (state.length || state.ended)) {
+        stream4.emit("readable");
+        state.emittedReadable = false;
+      }
+      state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;
+      flow(stream4);
+    }
+    function maybeReadMore(stream4, state) {
+      if (!state.readingMore) {
+        state.readingMore = true;
+        process.nextTick(maybeReadMore_, stream4, state);
+      }
+    }
+    function maybeReadMore_(stream4, state) {
+      while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {
+        var len = state.length;
+        debug("maybeReadMore read 0");
+        stream4.read(0);
+        if (len === state.length)
+          break;
+      }
+      state.readingMore = false;
+    }
+    Readable2.prototype._read = function(n) {
+      errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED("_read()"));
+    };
+    Readable2.prototype.pipe = function(dest, pipeOpts) {
+      var src = this;
+      var state = this._readableState;
+      switch (state.pipesCount) {
+        case 0:
+          state.pipes = dest;
+          break;
+        case 1:
+          state.pipes = [state.pipes, dest];
+          break;
+        default:
+          state.pipes.push(dest);
+          break;
+      }
+      state.pipesCount += 1;
+      debug("pipe count=%d opts=%j", state.pipesCount, pipeOpts);
+      var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
+      var endFn = doEnd ? onend : unpipe;
+      if (state.endEmitted)
+        process.nextTick(endFn);
+      else
+        src.once("end", endFn);
+      dest.on("unpipe", onunpipe);
+      function onunpipe(readable, unpipeInfo) {
+        debug("onunpipe");
+        if (readable === src) {
+          if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
+            unpipeInfo.hasUnpiped = true;
+            cleanup();
+          }
+        }
+      }
+      function onend() {
+        debug("onend");
+        dest.end();
+      }
+      var ondrain = pipeOnDrain(src);
+      dest.on("drain", ondrain);
+      var cleanedUp = false;
+      function cleanup() {
+        debug("cleanup");
+        dest.removeListener("close", onclose);
+        dest.removeListener("finish", onfinish);
+        dest.removeListener("drain", ondrain);
+        dest.removeListener("error", onerror);
+        dest.removeListener("unpipe", onunpipe);
+        src.removeListener("end", onend);
+        src.removeListener("end", unpipe);
+        src.removeListener("data", ondata);
+        cleanedUp = true;
+        if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain))
+          ondrain();
+      }
+      src.on("data", ondata);
+      function ondata(chunk) {
+        debug("ondata");
+        var ret = dest.write(chunk);
+        debug("dest.write", ret);
+        if (ret === false) {
+          if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
+            debug("false write response, pause", state.awaitDrain);
+            state.awaitDrain++;
+          }
+          src.pause();
+        }
+      }
+      function onerror(er) {
+        debug("onerror", er);
+        unpipe();
+        dest.removeListener("error", onerror);
+        if (EElistenerCount(dest, "error") === 0)
+          errorOrDestroy(dest, er);
+      }
+      prependListener(dest, "error", onerror);
+      function onclose() {
+        dest.removeListener("finish", onfinish);
+        unpipe();
+      }
+      dest.once("close", onclose);
+      function onfinish() {
+        debug("onfinish");
+        dest.removeListener("close", onclose);
+        unpipe();
+      }
+      dest.once("finish", onfinish);
+      function unpipe() {
+        debug("unpipe");
+        src.unpipe(dest);
+      }
+      dest.emit("pipe", src);
+      if (!state.flowing) {
+        debug("pipe resume");
+        src.resume();
+      }
+      return dest;
+    };
+    function pipeOnDrain(src) {
+      return function pipeOnDrainFunctionResult() {
+        var state = src._readableState;
+        debug("pipeOnDrain", state.awaitDrain);
+        if (state.awaitDrain)
+          state.awaitDrain--;
+        if (state.awaitDrain === 0 && EElistenerCount(src, "data")) {
+          state.flowing = true;
+          flow(src);
+        }
+      };
+    }
+    Readable2.prototype.unpipe = function(dest) {
+      var state = this._readableState;
+      var unpipeInfo = {
+        hasUnpiped: false
+      };
+      if (state.pipesCount === 0)
+        return this;
+      if (state.pipesCount === 1) {
+        if (dest && dest !== state.pipes)
+          return this;
+        if (!dest)
+          dest = state.pipes;
+        state.pipes = null;
+        state.pipesCount = 0;
+        state.flowing = false;
+        if (dest)
+          dest.emit("unpipe", this, unpipeInfo);
+        return this;
+      }
+      if (!dest) {
+        var dests = state.pipes;
+        var len = state.pipesCount;
+        state.pipes = null;
+        state.pipesCount = 0;
+        state.flowing = false;
+        for (var i = 0; i < len; i++) {
+          dests[i].emit("unpipe", this, {
+            hasUnpiped: false
+          });
+        }
+        return this;
+      }
+      var index2 = indexOf(state.pipes, dest);
+      if (index2 === -1)
+        return this;
+      state.pipes.splice(index2, 1);
+      state.pipesCount -= 1;
+      if (state.pipesCount === 1)
+        state.pipes = state.pipes[0];
+      dest.emit("unpipe", this, unpipeInfo);
+      return this;
+    };
+    Readable2.prototype.on = function(ev, fn) {
+      var res = Stream.prototype.on.call(this, ev, fn);
+      var state = this._readableState;
+      if (ev === "data") {
+        state.readableListening = this.listenerCount("readable") > 0;
+        if (state.flowing !== false)
+          this.resume();
+      } else if (ev === "readable") {
+        if (!state.endEmitted && !state.readableListening) {
+          state.readableListening = state.needReadable = true;
+          state.flowing = false;
+          state.emittedReadable = false;
+          debug("on readable", state.length, state.reading);
+          if (state.length) {
+            emitReadable(this);
+          } else if (!state.reading) {
+            process.nextTick(nReadingNextTick, this);
+          }
+        }
+      }
+      return res;
+    };
+    Readable2.prototype.addListener = Readable2.prototype.on;
+    Readable2.prototype.removeListener = function(ev, fn) {
+      var res = Stream.prototype.removeListener.call(this, ev, fn);
+      if (ev === "readable") {
+        process.nextTick(updateReadableListening, this);
+      }
+      return res;
+    };
+    Readable2.prototype.removeAllListeners = function(ev) {
+      var res = Stream.prototype.removeAllListeners.apply(this, arguments);
+      if (ev === "readable" || ev === void 0) {
+        process.nextTick(updateReadableListening, this);
+      }
+      return res;
+    };
+    function updateReadableListening(self2) {
+      var state = self2._readableState;
+      state.readableListening = self2.listenerCount("readable") > 0;
+      if (state.resumeScheduled && !state.paused) {
+        state.flowing = true;
+      } else if (self2.listenerCount("data") > 0) {
+        self2.resume();
+      }
+    }
+    function nReadingNextTick(self2) {
+      debug("readable nexttick read 0");
+      self2.read(0);
+    }
+    Readable2.prototype.resume = function() {
+      var state = this._readableState;
+      if (!state.flowing) {
+        debug("resume");
+        state.flowing = !state.readableListening;
+        resume(this, state);
+      }
+      state.paused = false;
+      return this;
+    };
+    function resume(stream4, state) {
+      if (!state.resumeScheduled) {
+        state.resumeScheduled = true;
+        process.nextTick(resume_, stream4, state);
+      }
+    }
+    function resume_(stream4, state) {
+      debug("resume", state.reading);
+      if (!state.reading) {
+        stream4.read(0);
+      }
+      state.resumeScheduled = false;
+      stream4.emit("resume");
+      flow(stream4);
+      if (state.flowing && !state.reading)
+        stream4.read(0);
+    }
+    Readable2.prototype.pause = function() {
+      debug("call pause flowing=%j", this._readableState.flowing);
+      if (this._readableState.flowing !== false) {
+        debug("pause");
+        this._readableState.flowing = false;
+        this.emit("pause");
+      }
+      this._readableState.paused = true;
+      return this;
+    };
+    function flow(stream4) {
+      var state = stream4._readableState;
+      debug("flow", state.flowing);
+      while (state.flowing && stream4.read() !== null) {
+        ;
+      }
+    }
+    Readable2.prototype.wrap = function(stream4) {
+      var _this = this;
+      var state = this._readableState;
+      var paused = false;
+      stream4.on("end", function() {
+        debug("wrapped end");
+        if (state.decoder && !state.ended) {
+          var chunk = state.decoder.end();
+          if (chunk && chunk.length)
+            _this.push(chunk);
+        }
+        _this.push(null);
+      });
+      stream4.on("data", function(chunk) {
+        debug("wrapped data");
+        if (state.decoder)
+          chunk = state.decoder.write(chunk);
+        if (state.objectMode && (chunk === null || chunk === void 0))
+          return;
+        else if (!state.objectMode && (!chunk || !chunk.length))
+          return;
+        var ret = _this.push(chunk);
+        if (!ret) {
+          paused = true;
+          stream4.pause();
+        }
+      });
+      for (var i in stream4) {
+        if (this[i] === void 0 && typeof stream4[i] === "function") {
+          this[i] = function methodWrap(method) {
+            return function methodWrapReturnFunction() {
+              return stream4[method].apply(stream4, arguments);
+            };
+          }(i);
+        }
+      }
+      for (var n = 0; n < kProxyEvents.length; n++) {
+        stream4.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
+      }
+      this._read = function(n2) {
+        debug("wrapped _read", n2);
+        if (paused) {
+          paused = false;
+          stream4.resume();
+        }
+      };
+      return this;
+    };
+    if (typeof Symbol === "function") {
+      Readable2.prototype[Symbol.asyncIterator] = function() {
+        if (createReadableStreamAsyncIterator === void 0) {
+          createReadableStreamAsyncIterator = require_async_iterator2();
+        }
+        return createReadableStreamAsyncIterator(this);
+      };
+    }
+    Object.defineProperty(Readable2.prototype, "readableHighWaterMark", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function get2() {
+        return this._readableState.highWaterMark;
+      }
+    });
+    Object.defineProperty(Readable2.prototype, "readableBuffer", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function get2() {
+        return this._readableState && this._readableState.buffer;
+      }
+    });
+    Object.defineProperty(Readable2.prototype, "readableFlowing", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function get2() {
+        return this._readableState.flowing;
+      },
+      set: function set(state) {
+        if (this._readableState) {
+          this._readableState.flowing = state;
+        }
+      }
+    });
+    Readable2._fromList = fromList;
+    Object.defineProperty(Readable2.prototype, "readableLength", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function get2() {
+        return this._readableState.length;
+      }
+    });
+    function fromList(n, state) {
+      if (state.length === 0)
+        return null;
+      var ret;
+      if (state.objectMode)
+        ret = state.buffer.shift();
+      else if (!n || n >= state.length) {
+        if (state.decoder)
+          ret = state.buffer.join("");
+        else if (state.buffer.length === 1)
+          ret = state.buffer.first();
+        else
+          ret = state.buffer.concat(state.length);
+        state.buffer.clear();
+      } else {
+        ret = state.buffer.consume(n, state.decoder);
+      }
+      return ret;
+    }
+    function endReadable(stream4) {
+      var state = stream4._readableState;
+      debug("endReadable", state.endEmitted);
+      if (!state.endEmitted) {
+        state.ended = true;
+        process.nextTick(endReadableNT, state, stream4);
+      }
+    }
+    function endReadableNT(state, stream4) {
+      debug("endReadableNT", state.endEmitted, state.length);
+      if (!state.endEmitted && state.length === 0) {
+        state.endEmitted = true;
+        stream4.readable = false;
+        stream4.emit("end");
+        if (state.autoDestroy) {
+          var wState = stream4._writableState;
+          if (!wState || wState.autoDestroy && wState.finished) {
+            stream4.destroy();
+          }
+        }
+      }
+    }
+    if (typeof Symbol === "function") {
+      Readable2.from = function(iterable, opts) {
+        if (from === void 0) {
+          from = require_from2();
+        }
+        return from(Readable2, iterable, opts);
+      };
+    }
+    function indexOf(xs, x) {
+      for (var i = 0, l = xs.length; i < l; i++) {
+        if (xs[i] === x)
+          return i;
+      }
+      return -1;
+    }
+  }
+});
+
+// ../../node_modules/winston-transport/node_modules/readable-stream/lib/_stream_duplex.js
+var require_stream_duplex2 = __commonJS({
+  "../../node_modules/winston-transport/node_modules/readable-stream/lib/_stream_duplex.js"(exports, module2) {
+    "use strict";
+    var objectKeys = Object.keys || function(obj) {
+      var keys2 = [];
+      for (var key in obj) {
+        keys2.push(key);
+      }
+      return keys2;
+    };
+    module2.exports = Duplex;
+    var Readable2 = require_stream_readable2();
+    var Writable = require_stream_writable2();
+    require_inherits()(Duplex, Readable2);
+    {
+      keys = objectKeys(Writable.prototype);
+      for (v = 0; v < keys.length; v++) {
+        method = keys[v];
+        if (!Duplex.prototype[method])
+          Duplex.prototype[method] = Writable.prototype[method];
+      }
+    }
+    var keys;
+    var method;
+    var v;
+    function Duplex(options) {
+      if (!(this instanceof Duplex))
+        return new Duplex(options);
+      Readable2.call(this, options);
+      Writable.call(this, options);
+      this.allowHalfOpen = true;
+      if (options) {
+        if (options.readable === false)
+          this.readable = false;
+        if (options.writable === false)
+          this.writable = false;
+        if (options.allowHalfOpen === false) {
+          this.allowHalfOpen = false;
+          this.once("end", onend);
+        }
+      }
+    }
+    Object.defineProperty(Duplex.prototype, "writableHighWaterMark", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function get2() {
+        return this._writableState.highWaterMark;
+      }
+    });
+    Object.defineProperty(Duplex.prototype, "writableBuffer", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function get2() {
+        return this._writableState && this._writableState.getBuffer();
+      }
+    });
+    Object.defineProperty(Duplex.prototype, "writableLength", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function get2() {
+        return this._writableState.length;
+      }
+    });
+    function onend() {
+      if (this._writableState.ended)
+        return;
+      process.nextTick(onEndNT, this);
+    }
+    function onEndNT(self2) {
+      self2.end();
+    }
+    Object.defineProperty(Duplex.prototype, "destroyed", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function get2() {
+        if (this._readableState === void 0 || this._writableState === void 0) {
+          return false;
+        }
+        return this._readableState.destroyed && this._writableState.destroyed;
+      },
+      set: function set(value) {
+        if (this._readableState === void 0 || this._writableState === void 0) {
+          return;
+        }
+        this._readableState.destroyed = value;
+        this._writableState.destroyed = value;
+      }
+    });
+  }
+});
+
+// ../../node_modules/winston-transport/node_modules/readable-stream/lib/_stream_writable.js
+var require_stream_writable2 = __commonJS({
+  "../../node_modules/winston-transport/node_modules/readable-stream/lib/_stream_writable.js"(exports, module2) {
+    "use strict";
+    module2.exports = Writable;
+    function CorkedRequest(state) {
+      var _this = this;
+      this.next = null;
+      this.entry = null;
+      this.finish = function() {
+        onCorkedFinish(_this, state);
+      };
+    }
+    var Duplex;
+    Writable.WritableState = WritableState;
+    var internalUtil = {
+      deprecate: require_node3()
+    };
+    var Stream = require_stream2();
+    var Buffer2 = require("buffer").Buffer;
+    var OurUint8Array = global.Uint8Array || function() {
+    };
+    function _uint8ArrayToBuffer(chunk) {
+      return Buffer2.from(chunk);
+    }
+    function _isUint8Array(obj) {
+      return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
+    }
+    var destroyImpl = require_destroy2();
+    var _require = require_state3();
+    var getHighWaterMark = _require.getHighWaterMark;
+    var _require$codes = require_errors3().codes;
+    var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
+    var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
+    var ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK;
+    var ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE;
+    var ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
+    var ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES;
+    var ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END;
+    var ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
+    var errorOrDestroy = destroyImpl.errorOrDestroy;
+    require_inherits()(Writable, Stream);
+    function nop() {
+    }
+    function WritableState(options, stream4, isDuplex) {
+      Duplex = Duplex || require_stream_duplex2();
+      options = options || {};
+      if (typeof isDuplex !== "boolean")
+        isDuplex = stream4 instanceof Duplex;
+      this.objectMode = !!options.objectMode;
+      if (isDuplex)
+        this.objectMode = this.objectMode || !!options.writableObjectMode;
+      this.highWaterMark = getHighWaterMark(this, options, "writableHighWaterMark", isDuplex);
+      this.finalCalled = false;
+      this.needDrain = false;
+      this.ending = false;
+      this.ended = false;
+      this.finished = false;
+      this.destroyed = false;
+      var noDecode = options.decodeStrings === false;
+      this.decodeStrings = !noDecode;
+      this.defaultEncoding = options.defaultEncoding || "utf8";
+      this.length = 0;
+      this.writing = false;
+      this.corked = 0;
+      this.sync = true;
+      this.bufferProcessing = false;
+      this.onwrite = function(er) {
+        onwrite(stream4, er);
+      };
+      this.writecb = null;
+      this.writelen = 0;
+      this.bufferedRequest = null;
+      this.lastBufferedRequest = null;
+      this.pendingcb = 0;
+      this.prefinished = false;
+      this.errorEmitted = false;
+      this.emitClose = options.emitClose !== false;
+      this.autoDestroy = !!options.autoDestroy;
+      this.bufferedRequestCount = 0;
+      this.corkedRequestsFree = new CorkedRequest(this);
+    }
+    WritableState.prototype.getBuffer = function getBuffer() {
+      var current = this.bufferedRequest;
+      var out = [];
+      while (current) {
+        out.push(current);
+        current = current.next;
+      }
+      return out;
+    };
+    (function() {
+      try {
+        Object.defineProperty(WritableState.prototype, "buffer", {
+          get: internalUtil.deprecate(function writableStateBufferGetter() {
+            return this.getBuffer();
+          }, "_writableState.buffer is deprecated. Use _writableState.getBuffer instead.", "DEP0003")
+        });
+      } catch (_23) {
+      }
+    })();
+    var realHasInstance;
+    if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
+      realHasInstance = Function.prototype[Symbol.hasInstance];
+      Object.defineProperty(Writable, Symbol.hasInstance, {
+        value: function value(object) {
+          if (realHasInstance.call(this, object))
+            return true;
+          if (this !== Writable)
+            return false;
+          return object && object._writableState instanceof WritableState;
+        }
+      });
+    } else {
+      realHasInstance = function realHasInstance2(object) {
+        return object instanceof this;
+      };
+    }
+    function Writable(options) {
+      Duplex = Duplex || require_stream_duplex2();
+      var isDuplex = this instanceof Duplex;
+      if (!isDuplex && !realHasInstance.call(Writable, this))
+        return new Writable(options);
+      this._writableState = new WritableState(options, this, isDuplex);
+      this.writable = true;
+      if (options) {
+        if (typeof options.write === "function")
+          this._write = options.write;
+        if (typeof options.writev === "function")
+          this._writev = options.writev;
+        if (typeof options.destroy === "function")
+          this._destroy = options.destroy;
+        if (typeof options.final === "function")
+          this._final = options.final;
+      }
+      Stream.call(this);
+    }
+    Writable.prototype.pipe = function() {
+      errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
+    };
+    function writeAfterEnd(stream4, cb) {
+      var er = new ERR_STREAM_WRITE_AFTER_END();
+      errorOrDestroy(stream4, er);
+      process.nextTick(cb, er);
+    }
+    function validChunk(stream4, state, chunk, cb) {
+      var er;
+      if (chunk === null) {
+        er = new ERR_STREAM_NULL_VALUES();
+      } else if (typeof chunk !== "string" && !state.objectMode) {
+        er = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer"], chunk);
+      }
+      if (er) {
+        errorOrDestroy(stream4, er);
+        process.nextTick(cb, er);
+        return false;
+      }
+      return true;
+    }
+    Writable.prototype.write = function(chunk, encoding, cb) {
+      var state = this._writableState;
+      var ret = false;
+      var isBuf = !state.objectMode && _isUint8Array(chunk);
+      if (isBuf && !Buffer2.isBuffer(chunk)) {
+        chunk = _uint8ArrayToBuffer(chunk);
+      }
+      if (typeof encoding === "function") {
+        cb = encoding;
+        encoding = null;
+      }
+      if (isBuf)
+        encoding = "buffer";
+      else if (!encoding)
+        encoding = state.defaultEncoding;
+      if (typeof cb !== "function")
+        cb = nop;
+      if (state.ending)
+        writeAfterEnd(this, cb);
+      else if (isBuf || validChunk(this, state, chunk, cb)) {
+        state.pendingcb++;
+        ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
+      }
+      return ret;
+    };
+    Writable.prototype.cork = function() {
+      this._writableState.corked++;
+    };
+    Writable.prototype.uncork = function() {
+      var state = this._writableState;
+      if (state.corked) {
+        state.corked--;
+        if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest)
+          clearBuffer(this, state);
+      }
+    };
+    Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
+      if (typeof encoding === "string")
+        encoding = encoding.toLowerCase();
+      if (!(["hex", "utf8", "utf-8", "ascii", "binary", "base64", "ucs2", "ucs-2", "utf16le", "utf-16le", "raw"].indexOf((encoding + "").toLowerCase()) > -1))
+        throw new ERR_UNKNOWN_ENCODING(encoding);
+      this._writableState.defaultEncoding = encoding;
+      return this;
+    };
+    Object.defineProperty(Writable.prototype, "writableBuffer", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function get2() {
+        return this._writableState && this._writableState.getBuffer();
+      }
+    });
+    function decodeChunk(state, chunk, encoding) {
+      if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") {
+        chunk = Buffer2.from(chunk, encoding);
+      }
+      return chunk;
+    }
+    Object.defineProperty(Writable.prototype, "writableHighWaterMark", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function get2() {
+        return this._writableState.highWaterMark;
+      }
+    });
+    function writeOrBuffer(stream4, state, isBuf, chunk, encoding, cb) {
+      if (!isBuf) {
+        var newChunk = decodeChunk(state, chunk, encoding);
+        if (chunk !== newChunk) {
+          isBuf = true;
+          encoding = "buffer";
+          chunk = newChunk;
+        }
+      }
+      var len = state.objectMode ? 1 : chunk.length;
+      state.length += len;
+      var ret = state.length < state.highWaterMark;
+      if (!ret)
+        state.needDrain = true;
+      if (state.writing || state.corked) {
+        var last = state.lastBufferedRequest;
+        state.lastBufferedRequest = {
+          chunk,
+          encoding,
+          isBuf,
+          callback: cb,
+          next: null
+        };
+        if (last) {
+          last.next = state.lastBufferedRequest;
+        } else {
+          state.bufferedRequest = state.lastBufferedRequest;
+        }
+        state.bufferedRequestCount += 1;
+      } else {
+        doWrite(stream4, state, false, len, chunk, encoding, cb);
+      }
+      return ret;
+    }
+    function doWrite(stream4, state, writev, len, chunk, encoding, cb) {
+      state.writelen = len;
+      state.writecb = cb;
+      state.writing = true;
+      state.sync = true;
+      if (state.destroyed)
+        state.onwrite(new ERR_STREAM_DESTROYED("write"));
+      else if (writev)
+        stream4._writev(chunk, state.onwrite);
+      else
+        stream4._write(chunk, encoding, state.onwrite);
+      state.sync = false;
+    }
+    function onwriteError(stream4, state, sync, er, cb) {
+      --state.pendingcb;
+      if (sync) {
+        process.nextTick(cb, er);
+        process.nextTick(finishMaybe, stream4, state);
+        stream4._writableState.errorEmitted = true;
+        errorOrDestroy(stream4, er);
+      } else {
+        cb(er);
+        stream4._writableState.errorEmitted = true;
+        errorOrDestroy(stream4, er);
+        finishMaybe(stream4, state);
+      }
+    }
+    function onwriteStateUpdate(state) {
+      state.writing = false;
+      state.writecb = null;
+      state.length -= state.writelen;
+      state.writelen = 0;
+    }
+    function onwrite(stream4, er) {
+      var state = stream4._writableState;
+      var sync = state.sync;
+      var cb = state.writecb;
+      if (typeof cb !== "function")
+        throw new ERR_MULTIPLE_CALLBACK();
+      onwriteStateUpdate(state);
+      if (er)
+        onwriteError(stream4, state, sync, er, cb);
+      else {
+        var finished = needFinish(state) || stream4.destroyed;
+        if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
+          clearBuffer(stream4, state);
+        }
+        if (sync) {
+          process.nextTick(afterWrite, stream4, state, finished, cb);
+        } else {
+          afterWrite(stream4, state, finished, cb);
+        }
+      }
+    }
+    function afterWrite(stream4, state, finished, cb) {
+      if (!finished)
+        onwriteDrain(stream4, state);
+      state.pendingcb--;
+      cb();
+      finishMaybe(stream4, state);
+    }
+    function onwriteDrain(stream4, state) {
+      if (state.length === 0 && state.needDrain) {
+        state.needDrain = false;
+        stream4.emit("drain");
+      }
+    }
+    function clearBuffer(stream4, state) {
+      state.bufferProcessing = true;
+      var entry = state.bufferedRequest;
+      if (stream4._writev && entry && entry.next) {
+        var l = state.bufferedRequestCount;
+        var buffer = new Array(l);
+        var holder = state.corkedRequestsFree;
+        holder.entry = entry;
+        var count = 0;
+        var allBuffers = true;
+        while (entry) {
+          buffer[count] = entry;
+          if (!entry.isBuf)
+            allBuffers = false;
+          entry = entry.next;
+          count += 1;
+        }
+        buffer.allBuffers = allBuffers;
+        doWrite(stream4, state, true, state.length, buffer, "", holder.finish);
+        state.pendingcb++;
+        state.lastBufferedRequest = null;
+        if (holder.next) {
+          state.corkedRequestsFree = holder.next;
+          holder.next = null;
+        } else {
+          state.corkedRequestsFree = new CorkedRequest(state);
+        }
+        state.bufferedRequestCount = 0;
+      } else {
+        while (entry) {
+          var chunk = entry.chunk;
+          var encoding = entry.encoding;
+          var cb = entry.callback;
+          var len = state.objectMode ? 1 : chunk.length;
+          doWrite(stream4, state, false, len, chunk, encoding, cb);
+          entry = entry.next;
+          state.bufferedRequestCount--;
+          if (state.writing) {
+            break;
+          }
+        }
+        if (entry === null)
+          state.lastBufferedRequest = null;
+      }
+      state.bufferedRequest = entry;
+      state.bufferProcessing = false;
+    }
+    Writable.prototype._write = function(chunk, encoding, cb) {
+      cb(new ERR_METHOD_NOT_IMPLEMENTED("_write()"));
+    };
+    Writable.prototype._writev = null;
+    Writable.prototype.end = function(chunk, encoding, cb) {
+      var state = this._writableState;
+      if (typeof chunk === "function") {
+        cb = chunk;
+        chunk = null;
+        encoding = null;
+      } else if (typeof encoding === "function") {
+        cb = encoding;
+        encoding = null;
+      }
+      if (chunk !== null && chunk !== void 0)
+        this.write(chunk, encoding);
+      if (state.corked) {
+        state.corked = 1;
+        this.uncork();
+      }
+      if (!state.ending)
+        endWritable(this, state, cb);
+      return this;
+    };
+    Object.defineProperty(Writable.prototype, "writableLength", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function get2() {
+        return this._writableState.length;
+      }
+    });
+    function needFinish(state) {
+      return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
+    }
+    function callFinal(stream4, state) {
+      stream4._final(function(err) {
+        state.pendingcb--;
+        if (err) {
+          errorOrDestroy(stream4, err);
+        }
+        state.prefinished = true;
+        stream4.emit("prefinish");
+        finishMaybe(stream4, state);
+      });
+    }
+    function prefinish(stream4, state) {
+      if (!state.prefinished && !state.finalCalled) {
+        if (typeof stream4._final === "function" && !state.destroyed) {
+          state.pendingcb++;
+          state.finalCalled = true;
+          process.nextTick(callFinal, stream4, state);
+        } else {
+          state.prefinished = true;
+          stream4.emit("prefinish");
+        }
+      }
+    }
+    function finishMaybe(stream4, state) {
+      var need = needFinish(state);
+      if (need) {
+        prefinish(stream4, state);
+        if (state.pendingcb === 0) {
+          state.finished = true;
+          stream4.emit("finish");
+          if (state.autoDestroy) {
+            var rState = stream4._readableState;
+            if (!rState || rState.autoDestroy && rState.endEmitted) {
+              stream4.destroy();
+            }
+          }
+        }
+      }
+      return need;
+    }
+    function endWritable(stream4, state, cb) {
+      state.ending = true;
+      finishMaybe(stream4, state);
+      if (cb) {
+        if (state.finished)
+          process.nextTick(cb);
+        else
+          stream4.once("finish", cb);
+      }
+      state.ended = true;
+      stream4.writable = false;
+    }
+    function onCorkedFinish(corkReq, state, err) {
+      var entry = corkReq.entry;
+      corkReq.entry = null;
+      while (entry) {
+        var cb = entry.callback;
+        state.pendingcb--;
+        cb(err);
+        entry = entry.next;
+      }
+      state.corkedRequestsFree.next = corkReq;
+    }
+    Object.defineProperty(Writable.prototype, "destroyed", {
+      // making it explicit this property is not enumerable
+      // because otherwise some prototype manipulation in
+      // userland will fail
+      enumerable: false,
+      get: function get2() {
+        if (this._writableState === void 0) {
+          return false;
+        }
+        return this._writableState.destroyed;
+      },
+      set: function set(value) {
+        if (!this._writableState) {
+          return;
+        }
+        this._writableState.destroyed = value;
+      }
+    });
+    Writable.prototype.destroy = destroyImpl.destroy;
+    Writable.prototype._undestroy = destroyImpl.undestroy;
+    Writable.prototype._destroy = function(err, cb) {
+      cb(err);
+    };
+  }
+});
+
+// ../../node_modules/winston-transport/legacy.js
+var require_legacy2 = __commonJS({
+  "../../node_modules/winston-transport/legacy.js"(exports, module2) {
+    "use strict";
+    var util2 = require("util");
+    var { LEVEL } = require_triple_beam();
+    var TransportStream = require_winston_transport2();
+    var LegacyTransportStream = module2.exports = function LegacyTransportStream2(options = {}) {
+      TransportStream.call(this, options);
+      if (!options.transport || typeof options.transport.log !== "function") {
+        throw new Error("Invalid transport, must be an object with a log method.");
+      }
+      this.transport = options.transport;
+      this.level = this.level || options.transport.level;
+      this.handleExceptions = this.handleExceptions || options.transport.handleExceptions;
+      this._deprecated();
+      function transportError(err) {
+        this.emit("error", err, this.transport);
+      }
+      if (!this.transport.__winstonError) {
+        this.transport.__winstonError = transportError.bind(this);
+        this.transport.on("error", this.transport.__winstonError);
+      }
+    };
+    util2.inherits(LegacyTransportStream, TransportStream);
+    LegacyTransportStream.prototype._write = function _write(info, enc, callback) {
+      if (this.silent || info.exception === true && !this.handleExceptions) {
+        return callback(null);
+      }
+      if (!this.level || this.levels[this.level] >= this.levels[info[LEVEL]]) {
+        this.transport.log(info[LEVEL], info.message, info, this._nop);
+      }
+      callback(null);
+    };
+    LegacyTransportStream.prototype._writev = function _writev(chunks, callback) {
+      for (let i = 0; i < chunks.length; i++) {
+        if (this._accept(chunks[i])) {
+          this.transport.log(
+            chunks[i].chunk[LEVEL],
+            chunks[i].chunk.message,
+            chunks[i].chunk,
+            this._nop
+          );
+          chunks[i].callback();
+        }
+      }
+      return callback(null);
+    };
+    LegacyTransportStream.prototype._deprecated = function _deprecated() {
+      console.error([
+        `${this.transport.name} is a legacy winston transport. Consider upgrading: `,
+        "- Upgrade docs: https://github.com/winstonjs/winston/blob/master/UPGRADE-3.0.md"
+      ].join("\n"));
+    };
+    LegacyTransportStream.prototype.close = function close() {
+      if (this.transport.close) {
+        this.transport.close();
+      }
+      if (this.transport.__winstonError) {
+        this.transport.removeListener("error", this.transport.__winstonError);
+        this.transport.__winstonError = null;
+      }
+    };
+  }
+});
+
+// ../../node_modules/winston-transport/index.js
+var require_winston_transport2 = __commonJS({
+  "../../node_modules/winston-transport/index.js"(exports, module2) {
+    "use strict";
+    var util2 = require("util");
+    var Writable = require_stream_writable2();
+    var { LEVEL } = require_triple_beam();
+    var TransportStream = module2.exports = function TransportStream2(options = {}) {
+      Writable.call(this, { objectMode: true, highWaterMark: options.highWaterMark });
+      this.format = options.format;
+      this.level = options.level;
+      this.handleExceptions = options.handleExceptions;
+      this.handleRejections = options.handleRejections;
+      this.silent = options.silent;
+      if (options.log)
+        this.log = options.log;
+      if (options.logv)
+        this.logv = options.logv;
+      if (options.close)
+        this.close = options.close;
+      this.once("pipe", (logger) => {
+        this.levels = logger.levels;
+        this.parent = logger;
+      });
+      this.once("unpipe", (src) => {
+        if (src === this.parent) {
+          this.parent = null;
+          if (this.close) {
+            this.close();
+          }
+        }
+      });
+    };
+    util2.inherits(TransportStream, Writable);
+    TransportStream.prototype._write = function _write(info, enc, callback) {
+      if (this.silent || info.exception === true && !this.handleExceptions) {
+        return callback(null);
+      }
+      const level = this.level || this.parent && this.parent.level;
+      if (!level || this.levels[level] >= this.levels[info[LEVEL]]) {
+        if (info && !this.format) {
+          return this.log(info, callback);
+        }
+        let errState;
+        let transformed;
+        try {
+          transformed = this.format.transform(Object.assign({}, info), this.format.options);
+        } catch (err) {
+          errState = err;
+        }
+        if (errState || !transformed) {
+          callback();
+          if (errState)
+            throw errState;
+          return;
+        }
+        return this.log(transformed, callback);
+      }
+      this._writableState.sync = false;
+      return callback(null);
+    };
+    TransportStream.prototype._writev = function _writev(chunks, callback) {
+      if (this.logv) {
+        const infos = chunks.filter(this._accept, this);
+        if (!infos.length) {
+          return callback(null);
+        }
+        return this.logv(infos, callback);
+      }
+      for (let i = 0; i < chunks.length; i++) {
+        if (!this._accept(chunks[i]))
+          continue;
+        if (chunks[i].chunk && !this.format) {
+          this.log(chunks[i].chunk, chunks[i].callback);
+          continue;
+        }
+        let errState;
+        let transformed;
+        try {
+          transformed = this.format.transform(
+            Object.assign({}, chunks[i].chunk),
+            this.format.options
+          );
+        } catch (err) {
+          errState = err;
+        }
+        if (errState || !transformed) {
+          chunks[i].callback();
+          if (errState) {
+            callback(null);
+            throw errState;
+          }
+        } else {
+          this.log(transformed, chunks[i].callback);
+        }
+      }
+      return callback(null);
+    };
+    TransportStream.prototype._accept = function _accept(write) {
+      const info = write.chunk;
+      if (this.silent) {
+        return false;
+      }
+      const level = this.level || this.parent && this.parent.level;
+      if (info.exception === true || !level || this.levels[level] >= this.levels[info[LEVEL]]) {
+        if (this.handleExceptions || info.exception !== true) {
+          return true;
+        }
+      }
+      return false;
+    };
+    TransportStream.prototype._nop = function _nop() {
+      return void 0;
+    };
+    module2.exports.LegacyTransportStream = require_legacy2();
+  }
+});
+
+// ../../node_modules/winston/lib/winston/transports/console.js
+var require_console = __commonJS({
+  "../../node_modules/winston/lib/winston/transports/console.js"(exports, module2) {
+    "use strict";
+    var os = require("os");
+    var { LEVEL, MESSAGE } = require_triple_beam();
+    var TransportStream = require_winston_transport2();
+    module2.exports = class Console extends TransportStream {
+      /**
+       * Constructor function for the Console transport object responsible for
+       * persisting log messages and metadata to a terminal or TTY.
+       * @param {!Object} [options={}] - Options for this instance.
+       */
+      constructor(options = {}) {
+        super(options);
+        this.name = options.name || "console";
+        this.stderrLevels = this._stringArrayToSet(options.stderrLevels);
+        this.consoleWarnLevels = this._stringArrayToSet(options.consoleWarnLevels);
+        this.eol = typeof options.eol === "string" ? options.eol : os.EOL;
+        this.setMaxListeners(30);
+      }
+      /**
+       * Core logging method exposed to Winston.
+       * @param {Object} info - TODO: add param description.
+       * @param {Function} callback - TODO: add param description.
+       * @returns {undefined}
+       */
+      log(info, callback) {
+        setImmediate(() => this.emit("logged", info));
+        if (this.stderrLevels[info[LEVEL]]) {
+          if (console._stderr) {
+            console._stderr.write(`${info[MESSAGE]}${this.eol}`);
+          } else {
+            console.error(info[MESSAGE]);
+          }
+          if (callback) {
+            callback();
+          }
+          return;
+        } else if (this.consoleWarnLevels[info[LEVEL]]) {
+          if (console._stderr) {
+            console._stderr.write(`${info[MESSAGE]}${this.eol}`);
           } else {
             console.warn(info[MESSAGE]);
           }
@@ -21109,14 +23836,14 @@ var require_series = __commonJS({
 });
 
 // ../../node_modules/winston/node_modules/readable-stream/lib/internal/streams/stream.js
-var require_stream2 = __commonJS({
+var require_stream3 = __commonJS({
   "../../node_modules/winston/node_modules/readable-stream/lib/internal/streams/stream.js"(exports, module2) {
     module2.exports = require("stream");
   }
 });
 
 // ../../node_modules/winston/node_modules/readable-stream/lib/internal/streams/buffer_list.js
-var require_buffer_list2 = __commonJS({
+var require_buffer_list3 = __commonJS({
   "../../node_modules/winston/node_modules/readable-stream/lib/internal/streams/buffer_list.js"(exports, module2) {
     "use strict";
     function ownKeys(object, enumerableOnly) {
@@ -21369,7 +24096,7 @@ var require_buffer_list2 = __commonJS({
 });
 
 // ../../node_modules/winston/node_modules/readable-stream/lib/internal/streams/destroy.js
-var require_destroy2 = __commonJS({
+var require_destroy3 = __commonJS({
   "../../node_modules/winston/node_modules/readable-stream/lib/internal/streams/destroy.js"(exports, module2) {
     "use strict";
     function destroy(err, cb) {
@@ -21462,7 +24189,7 @@ var require_destroy2 = __commonJS({
 });
 
 // ../../node_modules/winston/node_modules/readable-stream/errors.js
-var require_errors3 = __commonJS({
+var require_errors4 = __commonJS({
   "../../node_modules/winston/node_modules/readable-stream/errors.js"(exports, module2) {
     "use strict";
     var codes = {};
@@ -21562,10 +24289,10 @@ var require_errors3 = __commonJS({
 });
 
 // ../../node_modules/winston/node_modules/readable-stream/lib/internal/streams/state.js
-var require_state3 = __commonJS({
+var require_state4 = __commonJS({
   "../../node_modules/winston/node_modules/readable-stream/lib/internal/streams/state.js"(exports, module2) {
     "use strict";
-    var ERR_INVALID_OPT_VALUE = require_errors3().codes.ERR_INVALID_OPT_VALUE;
+    var ERR_INVALID_OPT_VALUE = require_errors4().codes.ERR_INVALID_OPT_VALUE;
     function highWaterMarkFrom(options, isDuplex, duplexKey) {
       return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
     }
@@ -21587,7 +24314,7 @@ var require_state3 = __commonJS({
 });
 
 // ../../node_modules/winston/node_modules/readable-stream/lib/_stream_writable.js
-var require_stream_writable2 = __commonJS({
+var require_stream_writable3 = __commonJS({
   "../../node_modules/winston/node_modules/readable-stream/lib/_stream_writable.js"(exports, module2) {
     "use strict";
     module2.exports = Writable;
@@ -21604,7 +24331,7 @@ var require_stream_writable2 = __commonJS({
     var internalUtil = {
       deprecate: require_node3()
     };
-    var Stream = require_stream2();
+    var Stream = require_stream3();
     var Buffer2 = require("buffer").Buffer;
     var OurUint8Array = global.Uint8Array || function() {
     };
@@ -21614,10 +24341,10 @@ var require_stream_writable2 = __commonJS({
     function _isUint8Array(obj) {
       return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
     }
-    var destroyImpl = require_destroy2();
-    var _require = require_state3();
+    var destroyImpl = require_destroy3();
+    var _require = require_state4();
     var getHighWaterMark = _require.getHighWaterMark;
-    var _require$codes = require_errors3().codes;
+    var _require$codes = require_errors4().codes;
     var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
     var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
     var ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK;
@@ -21631,7 +24358,7 @@ var require_stream_writable2 = __commonJS({
     function nop() {
     }
     function WritableState(options, stream4, isDuplex) {
-      Duplex = Duplex || require_stream_duplex2();
+      Duplex = Duplex || require_stream_duplex3();
       options = options || {};
       if (typeof isDuplex !== "boolean")
         isDuplex = stream4 instanceof Duplex;
@@ -21705,7 +24432,7 @@ var require_stream_writable2 = __commonJS({
       };
     }
     function Writable(options) {
-      Duplex = Duplex || require_stream_duplex2();
+      Duplex = Duplex || require_stream_duplex3();
       var isDuplex = this instanceof Duplex;
       if (!isDuplex && !realHasInstance.call(Writable, this))
         return new Writable(options);
@@ -22087,7 +24814,7 @@ var require_stream_writable2 = __commonJS({
 });
 
 // ../../node_modules/winston/node_modules/readable-stream/lib/_stream_duplex.js
-var require_stream_duplex2 = __commonJS({
+var require_stream_duplex3 = __commonJS({
   "../../node_modules/winston/node_modules/readable-stream/lib/_stream_duplex.js"(exports, module2) {
     "use strict";
     var objectKeys = Object.keys || function(obj) {
@@ -22098,8 +24825,8 @@ var require_stream_duplex2 = __commonJS({
       return keys2;
     };
     module2.exports = Duplex;
-    var Readable2 = require_stream_readable2();
-    var Writable = require_stream_writable2();
+    var Readable2 = require_stream_readable3();
+    var Writable = require_stream_writable3();
     require_inherits()(Duplex, Readable2);
     {
       keys = objectKeys(Writable.prototype);
@@ -22187,7 +24914,7 @@ var require_stream_duplex2 = __commonJS({
 });
 
 // ../../node_modules/winston/node_modules/string_decoder/lib/string_decoder.js
-var require_string_decoder2 = __commonJS({
+var require_string_decoder3 = __commonJS({
   "../../node_modules/winston/node_modules/string_decoder/lib/string_decoder.js"(exports) {
     "use strict";
     var Buffer2 = require_safe_buffer().Buffer;
@@ -22447,10 +25174,10 @@ var require_string_decoder2 = __commonJS({
 });
 
 // ../../node_modules/winston/node_modules/readable-stream/lib/internal/streams/end-of-stream.js
-var require_end_of_stream2 = __commonJS({
+var require_end_of_stream3 = __commonJS({
   "../../node_modules/winston/node_modules/readable-stream/lib/internal/streams/end-of-stream.js"(exports, module2) {
     "use strict";
-    var ERR_STREAM_PREMATURE_CLOSE = require_errors3().codes.ERR_STREAM_PREMATURE_CLOSE;
+    var ERR_STREAM_PREMATURE_CLOSE = require_errors4().codes.ERR_STREAM_PREMATURE_CLOSE;
     function once2(callback) {
       var called = false;
       return function() {
@@ -22548,7 +25275,7 @@ var require_end_of_stream2 = __commonJS({
 });
 
 // ../../node_modules/winston/node_modules/readable-stream/lib/internal/streams/async_iterator.js
-var require_async_iterator2 = __commonJS({
+var require_async_iterator3 = __commonJS({
   "../../node_modules/winston/node_modules/readable-stream/lib/internal/streams/async_iterator.js"(exports, module2) {
     "use strict";
     var _Object$setPrototypeO;
@@ -22560,7 +25287,7 @@ var require_async_iterator2 = __commonJS({
       }
       return obj;
     }
-    var finished = require_end_of_stream2();
+    var finished = require_end_of_stream3();
     var kLastResolve = Symbol("lastResolve");
     var kLastReject = Symbol("lastReject");
     var kError = Symbol("error");
@@ -22716,7 +25443,7 @@ var require_async_iterator2 = __commonJS({
 });
 
 // ../../node_modules/winston/node_modules/readable-stream/lib/internal/streams/from.js
-var require_from2 = __commonJS({
+var require_from3 = __commonJS({
   "../../node_modules/winston/node_modules/readable-stream/lib/internal/streams/from.js"(exports, module2) {
     "use strict";
     function asyncGeneratorStep(gen, resolve, reject2, _next, _throw, key, arg) {
@@ -22785,7 +25512,7 @@ var require_from2 = __commonJS({
       }
       return obj;
     }
-    var ERR_INVALID_ARG_TYPE = require_errors3().codes.ERR_INVALID_ARG_TYPE;
+    var ERR_INVALID_ARG_TYPE = require_errors4().codes.ERR_INVALID_ARG_TYPE;
     function from(Readable2, iterable, opts) {
       var iterator;
       if (iterable && typeof iterable.next === "function") {
@@ -22833,7 +25560,7 @@ var require_from2 = __commonJS({
 });
 
 // ../../node_modules/winston/node_modules/readable-stream/lib/_stream_readable.js
-var require_stream_readable2 = __commonJS({
+var require_stream_readable3 = __commonJS({
   "../../node_modules/winston/node_modules/readable-stream/lib/_stream_readable.js"(exports, module2) {
     "use strict";
     module2.exports = Readable2;
@@ -22843,7 +25570,7 @@ var require_stream_readable2 = __commonJS({
     var EElistenerCount = function EElistenerCount2(emitter, type) {
       return emitter.listeners(type).length;
     };
-    var Stream = require_stream2();
+    var Stream = require_stream3();
     var Buffer2 = require("buffer").Buffer;
     var OurUint8Array = global.Uint8Array || function() {
     };
@@ -22861,11 +25588,11 @@ var require_stream_readable2 = __commonJS({
       debug = function debug2() {
       };
     }
-    var BufferList = require_buffer_list2();
-    var destroyImpl = require_destroy2();
-    var _require = require_state3();
+    var BufferList = require_buffer_list3();
+    var destroyImpl = require_destroy3();
+    var _require = require_state4();
     var getHighWaterMark = _require.getHighWaterMark;
-    var _require$codes = require_errors3().codes;
+    var _require$codes = require_errors4().codes;
     var ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE;
     var ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF;
     var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
@@ -22887,7 +25614,7 @@ var require_stream_readable2 = __commonJS({
         emitter._events[event] = [fn, emitter._events[event]];
     }
     function ReadableState(options, stream4, isDuplex) {
-      Duplex = Duplex || require_stream_duplex2();
+      Duplex = Duplex || require_stream_duplex3();
       options = options || {};
       if (typeof isDuplex !== "boolean")
         isDuplex = stream4 instanceof Duplex;
@@ -22919,13 +25646,13 @@ var require_stream_readable2 = __commonJS({
       this.encoding = null;
       if (options.encoding) {
         if (!StringDecoder)
-          StringDecoder = require_string_decoder2().StringDecoder;
+          StringDecoder = require_string_decoder3().StringDecoder;
         this.decoder = new StringDecoder(options.encoding);
         this.encoding = options.encoding;
       }
     }
     function Readable2(options) {
-      Duplex = Duplex || require_stream_duplex2();
+      Duplex = Duplex || require_stream_duplex3();
       if (!(this instanceof Readable2))
         return new Readable2(options);
       var isDuplex = this instanceof Duplex;
@@ -23053,7 +25780,7 @@ var require_stream_readable2 = __commonJS({
     };
     Readable2.prototype.setEncoding = function(enc) {
       if (!StringDecoder)
-        StringDecoder = require_string_decoder2().StringDecoder;
+        StringDecoder = require_string_decoder3().StringDecoder;
       var decoder = new StringDecoder(enc);
       this._readableState.decoder = decoder;
       this._readableState.encoding = this._readableState.decoder.encoding;
@@ -23524,7 +26251,7 @@ var require_stream_readable2 = __commonJS({
     if (typeof Symbol === "function") {
       Readable2.prototype[Symbol.asyncIterator] = function() {
         if (createReadableStreamAsyncIterator === void 0) {
-          createReadableStreamAsyncIterator = require_async_iterator2();
+          createReadableStreamAsyncIterator = require_async_iterator3();
         }
         return createReadableStreamAsyncIterator(this);
       };
@@ -23615,7 +26342,7 @@ var require_stream_readable2 = __commonJS({
     if (typeof Symbol === "function") {
       Readable2.from = function(iterable, opts) {
         if (from === void 0) {
-          from = require_from2();
+          from = require_from3();
         }
         return from(Readable2, iterable, opts);
       };
@@ -23635,12 +26362,12 @@ var require_stream_transform = __commonJS({
   "../../node_modules/winston/node_modules/readable-stream/lib/_stream_transform.js"(exports, module2) {
     "use strict";
     module2.exports = Transform;
-    var _require$codes = require_errors3().codes;
+    var _require$codes = require_errors4().codes;
     var ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED;
     var ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK;
     var ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING;
     var ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
-    var Duplex = require_stream_duplex2();
+    var Duplex = require_stream_duplex3();
     require_inherits()(Transform, Duplex);
     function afterTransform(er, data) {
       var ts = this._transformState;
@@ -23770,7 +26497,7 @@ var require_pipeline = __commonJS({
         callback.apply(void 0, arguments);
       };
     }
-    var _require$codes = require_errors3().codes;
+    var _require$codes = require_errors4().codes;
     var ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;
     var ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
     function noop3(err) {
@@ -23787,7 +26514,7 @@ var require_pipeline = __commonJS({
         closed = true;
       });
       if (eos === void 0)
-        eos = require_end_of_stream2();
+        eos = require_end_of_stream3();
       eos(stream4, {
         readable: reading,
         writable: writing
@@ -23864,14 +26591,14 @@ var require_readable = __commonJS({
       Object.assign(module2.exports, Stream);
       module2.exports.Stream = Stream;
     } else {
-      exports = module2.exports = require_stream_readable2();
+      exports = module2.exports = require_stream_readable3();
       exports.Stream = Stream || exports;
       exports.Readable = exports;
-      exports.Writable = require_stream_writable2();
-      exports.Duplex = require_stream_duplex2();
+      exports.Writable = require_stream_writable3();
+      exports.Duplex = require_stream_duplex3();
       exports.Transform = require_stream_transform();
       exports.PassThrough = require_stream_passthrough();
-      exports.finished = require_end_of_stream2();
+      exports.finished = require_end_of_stream3();
       exports.pipeline = require_pipeline();
     }
   }
@@ -26039,7 +28766,7 @@ var require_file = __commonJS({
     var zlib2 = require("zlib");
     var { MESSAGE } = require_triple_beam();
     var { Stream, PassThrough } = require_readable();
-    var TransportStream = require_winston_transport();
+    var TransportStream = require_winston_transport2();
     var debug = require_node4()("winston:file");
     var os = require("os");
     var tailFile = require_tail_file();
@@ -26081,15 +28808,18 @@ var require_file = __commonJS({
         this.maxFiles = options.maxFiles || null;
         this.eol = typeof options.eol === "string" ? options.eol : os.EOL;
         this.tailable = options.tailable || false;
+        this.lazy = options.lazy || false;
         this._size = 0;
         this._pendingSize = 0;
         this._created = 0;
         this._drain = false;
         this._opening = false;
         this._ending = false;
+        this._fileExist = false;
         if (this.dirname)
           this._createLogDirIfNotExist(this.dirname);
-        this.open();
+        if (!this.lazy)
+          this.open();
       }
       finishIfEnding() {
         if (this._ending) {
@@ -26130,6 +28860,32 @@ var require_file = __commonJS({
           });
           return;
         }
+        if (this.lazy) {
+          if (!this._fileExist) {
+            if (!this._opening) {
+              this.open();
+            }
+            this.once("open", () => {
+              this._fileExist = true;
+              this.log(info, callback);
+              return;
+            });
+            return;
+          }
+          if (this._needsNewFile(this._pendingSize)) {
+            this._dest.once("close", () => {
+              if (!this._opening) {
+                this.open();
+              }
+              this.once("open", () => {
+                this.log(info, callback);
+                return;
+              });
+              return;
+            });
+            return;
+          }
+        }
         const output2 = `${info[MESSAGE]}${this.eol}`;
         const bytes = Buffer.byteLength(output2);
         function logged() {
@@ -26137,12 +28893,21 @@ var require_file = __commonJS({
           this._pendingSize -= bytes;
           debug("logged %s %s", this._size, output2);
           this.emit("logged", info);
+          if (this._rotate) {
+            return;
+          }
           if (this._opening) {
             return;
           }
           if (!this._needsNewFile()) {
             return;
           }
+          if (this.lazy) {
+            this._endStream(() => {
+              this.emit("fileclosed");
+            });
+            return;
+          }
           this._rotate = true;
           this._endStream(() => this._rotateFile());
         }
@@ -26404,6 +29169,7 @@ var require_file = __commonJS({
        */
       _cleanupStream(stream4) {
         stream4.removeListener("error", this._onError);
+        stream4.destroy();
         return stream4;
       }
       /**
@@ -26435,7 +29201,7 @@ var require_file = __commonJS({
        * Returns the WritableStream for the active file on this instance. If we
        * should gzip the file then a zlib stream is returned.
        *
-       * @param {ReadableStream} source – PassThrough to pipe to the file when open.
+       * @param {ReadableStream} source –PassThrough to pipe to the file when open.
        * @returns {WritableStream} Stream that writes to disk for the active file.
        */
       _createStream(source) {
@@ -26564,7 +29330,7 @@ var require_http = __commonJS({
     var http2 = require("http");
     var https2 = require("https");
     var { Stream } = require_readable();
-    var TransportStream = require_winston_transport();
+    var TransportStream = require_winston_transport2();
     var jsonStringify = require_safe_stable_stringify();
     module2.exports = class Http extends TransportStream {
       /**
@@ -26602,7 +29368,7 @@ var require_http = __commonJS({
        * @returns {undefined}
        */
       log(info, callback) {
-        this._request(info, (err, res) => {
+        this._request(info, null, null, (err, res) => {
           if (res && res.statusCode !== 200) {
             err = new Error(`Invalid HTTP Status Code: ${res.statusCode}`);
           }
@@ -26631,15 +29397,11 @@ var require_http = __commonJS({
           method: "query",
           params: this.normalizeQuery(options)
         };
-        if (options.params.path) {
-          options.path = options.params.path;
-          delete options.params.path;
-        }
-        if (options.params.auth) {
-          options.auth = options.params.auth;
-          delete options.params.auth;
-        }
-        this._request(options, (err, res, body) => {
+        const auth = options.params.auth || null;
+        delete options.params.auth;
+        const path = options.params.path || null;
+        delete options.params.path;
+        this._request(options, auth, path, (err, res, body) => {
           if (res && res.statusCode !== 200) {
             err = new Error(`Invalid HTTP Status Code: ${res.statusCode}`);
           }
@@ -26667,16 +29429,12 @@ var require_http = __commonJS({
           method: "stream",
           params: options
         };
-        if (options.params.path) {
-          options.path = options.params.path;
-          delete options.params.path;
-        }
-        if (options.params.auth) {
-          options.auth = options.params.auth;
-          delete options.params.auth;
-        }
+        const path = options.params.path || null;
+        delete options.params.path;
+        const auth = options.params.auth || null;
+        delete options.params.auth;
         let buff = "";
-        const req = this._request(options);
+        const req = this._request(options, auth, path);
         stream4.destroy = () => req.destroy();
         req.on("data", (data) => {
           data = (buff + data).split(/\n+/);
@@ -26698,14 +29456,14 @@ var require_http = __commonJS({
        * Make a request to a winstond server or any http server which can
        * handle json-rpc.
        * @param {function} options - Options to sent the request.
+       * @param {Object?} auth - authentication options
+       * @param {string} path - request path
        * @param {function} callback - Continuation to respond to when complete.
        */
-      _request(options, callback) {
+      _request(options, auth, path, callback) {
         options = options || {};
-        const auth = options.auth || this.auth;
-        const path = options.path || this.path || "";
-        delete options.auth;
-        delete options.path;
+        auth = auth || this.auth;
+        path = path || this.path || "";
         if (this.batch) {
           this._doBatch(options, callback, auth, path);
         } else {
@@ -26773,7 +29531,7 @@ var require_http = __commonJS({
         });
         req.on("error", callback);
         req.on("response", (res) => res.on("end", () => callback(null, res)).resume());
-        req.end(Buffer.from(jsonStringify(options), "utf8"));
+        req.end(Buffer.from(jsonStringify(options, this.options.replacer), "utf8"));
       }
     };
   }
@@ -26793,13 +29551,13 @@ var require_is_stream = __commonJS({
 });
 
 // ../../node_modules/winston/lib/winston/transports/stream.js
-var require_stream3 = __commonJS({
+var require_stream4 = __commonJS({
   "../../node_modules/winston/lib/winston/transports/stream.js"(exports, module2) {
     "use strict";
     var isStream2 = require_is_stream();
     var { MESSAGE } = require_triple_beam();
     var os = require("os");
-    var TransportStream = require_winston_transport();
+    var TransportStream = require_winston_transport2();
     module2.exports = class Stream extends TransportStream {
       /**
        * Constructor function for the Console transport object responsible for
@@ -26870,7 +29628,7 @@ var require_transports2 = __commonJS({
       configurable: true,
       enumerable: true,
       get() {
-        return require_stream3();
+        return require_stream4();
       }
     });
   }
@@ -27253,9 +30011,9 @@ var require_exception_handler = __commonJS({
        * @returns {mixed} - TODO: add return description.
        */
       getAllInfo(err) {
-        let { message } = err;
-        if (!message && typeof err === "string") {
-          message = err;
+        let message = null;
+        if (err) {
+          message = typeof err === "string" ? err : err.message;
         }
         return {
           error: err,
@@ -27263,9 +30021,9 @@ var require_exception_handler = __commonJS({
           level: "error",
           message: [
             `uncaughtException: ${message || "(no error message)"}`,
-            err.stack || "  No stack trace"
+            err && err.stack || "  No stack trace"
           ].join("\n"),
-          stack: err.stack,
+          stack: err && err.stack,
           exception: true,
           date: (/* @__PURE__ */ new Date()).toString(),
           process: this.getProcessInfo(),
@@ -27602,7 +30360,7 @@ var require_rejection_handler = __commonJS({
 var require_profiler = __commonJS({
   "../../node_modules/winston/lib/winston/profiler.js"(exports, module2) {
     "use strict";
-    module2.exports = class Profiler {
+    var Profiler = class {
       /**
        * Constructor function for the Profiler instance used by
        * `Logger.prototype.startTimer`. When done is called the timer will finish
@@ -27611,11 +30369,13 @@ var require_profiler = __commonJS({
        * @private
        */
       constructor(logger) {
-        if (!logger) {
-          throw new Error("Logger is required for profiling.");
+        const Logger2 = require_logger();
+        if (typeof logger !== "object" || Array.isArray(logger) || !(logger instanceof Logger2)) {
+          throw new Error("Logger is required for profiling");
+        } else {
+          this.logger = logger;
+          this.start = Date.now();
         }
-        this.logger = logger;
-        this.start = Date.now();
       }
       /**
        * Ends the current timer (i.e. Profiler) instance and logs the `msg` along
@@ -27634,6 +30394,7 @@ var require_profiler = __commonJS({
         return this.logger.write(info);
       }
     };
+    module2.exports = Profiler;
   }
 });
 
@@ -27647,7 +30408,7 @@ var require_logger = __commonJS({
     var isStream2 = require_is_stream();
     var ExceptionHandler = require_exception_handler();
     var RejectionHandler = require_rejection_handler();
-    var LegacyTransportStream = require_legacy();
+    var LegacyTransportStream = require_legacy2();
     var Profiler = require_profiler();
     var { warn: warn2 } = require_common3();
     var config = require_config2();
@@ -27860,7 +30621,7 @@ var require_logger = __commonJS({
         }
         if (!this._readableState.pipes) {
           console.error(
-            "[winston] Attempt to write logs with no transports %j",
+            "[winston] Attempt to write logs with no transports, which can increase memory usage: %j",
             info
           );
         }
@@ -28242,7 +31003,11 @@ var require_container = __commonJS({
         if (!this.loggers.has(id)) {
           options = Object.assign({}, options || this.options);
           const existing = options.transports || this.options.transports;
-          options.transports = existing ? existing.slice() : [];
+          if (existing) {
+            options.transports = Array.isArray(existing) ? existing.slice() : [existing];
+          } else {
+            options.transports = [];
+          }
           const logger = createLogger(options);
           logger.on("close", () => this._delete(id));
           this.loggers.set(id, logger);
@@ -28320,10 +31085,11 @@ var require_winston = __commonJS({
     exports.addColors = logform.levels;
     exports.format = logform.format;
     exports.createLogger = require_create_logger();
+    exports.Logger = require_logger();
     exports.ExceptionHandler = require_exception_handler();
     exports.RejectionHandler = require_rejection_handler();
     exports.Container = require_container();
-    exports.Transport = require_winston_transport();
+    exports.Transport = require_winston_transport2();
     exports.loggers = new exports.Container();
     var defaultLogger = exports.createLogger();
     Object.keys(exports.config.npm.levels).concat([
@@ -28386,7 +31152,6 @@ var require_winston = __commonJS({
       "extend"
     ]);
     warn2.forProperties(exports, "deprecated", ["emitErrs", "levelLength"]);
-    warn2.moved(exports, "createLogger", "Logger");
   }
 });
 
@@ -28422,14 +31187,27 @@ var require_vscode_output_channel_transport = __commonJS({
     var VSCodeTransport = class extends winston_transport_1.default {
       constructor(options) {
         super(options);
-        this.channel = getVSCodeInstance().window.createOutputChannel(options.channelName);
+        this.winstonToVSCodeMap = /* @__PURE__ */ new Map([
+          ["error", "error"],
+          ["warn", "warn"],
+          ["info", "info"],
+          ["verbose", "debug"],
+          ["debug", "debug"],
+          ["silly", "trace"]
+        ]);
+        this.channel = getVSCodeInstance().window.createOutputChannel(options.channelName, { log: true });
       }
       log(data, callback) {
         setImmediate(() => {
-          this.channel.appendLine(`${data.timestamp} [${data.level.toUpperCase()}] - ${data.message}`);
+          var _a;
+          const logFunction = (_a = this.winstonToVSCodeMap.get(data.level)) !== null && _a !== void 0 ? _a : "info";
+          this.channel[logFunction](data.message);
         });
         callback();
       }
+      show() {
+        this.channel.show();
+      }
     };
     exports.VSCodeTransport = VSCodeTransport;
     function getVSCodeInstance() {
@@ -30007,7 +32785,7 @@ var require_logger2 = __commonJS({
         const logger = winston_1.default.createLogger({
           level,
           transports: Array.from(transportMap.values()),
-          format: winston_1.format.combine(winston_1.format.timestamp(), winston_1.format.json()),
+          format: winston_1.format.combine(winston_1.format.timestamp(), winston_1.format.json(), winston_1.format.splat()),
           defaultMeta: { label: logPrefix, labelColor: (0, utils_1.nextColor)() }
         });
         const winstonLevel = level !== null && level !== void 0 ? level : logger.level;
@@ -30031,6 +32809,102 @@ var require_winston_logger = __commonJS({
   }
 });
 
+// ../../node_modules/@sap-ux/logger/dist/extension-logger/index.js
+var require_extension_logger = __commonJS({
+  "../../node_modules/@sap-ux/logger/dist/extension-logger/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ExtensionLogger = void 0;
+    var transports_1 = require_transports();
+    var vscode_output_channel_transport_1 = require_vscode_output_channel_transport();
+    var winston_logger_1 = require_winston_logger();
+    var types_1 = require_types();
+    var adapter_1 = require_adapter();
+    var ExtensionLogger = class extends winston_logger_1.WinstonLogger {
+      constructor(channelName) {
+        const vscodeTransport = new transports_1.VSCodeTransport({ channelName });
+        super({
+          logLevel: types_1.LogLevel.Silly,
+          // set to lowest level, let VSCode filter levels
+          transports: [vscodeTransport],
+          logPrefix: ""
+        });
+      }
+      /**
+       * Private function to enable adding additional arguments to the log message.
+       * Prepares the message for formatting with format.splat().
+       *
+       * @param level - log level
+       * @param message - log message
+       * @param args - additional arguments like objects, arrays, etc.
+       */
+      logWithArgs(level, message, ...args) {
+        var _a;
+        const winstonLevel = (_a = (0, adapter_1.toWinstonLogLevel)(level)) !== null && _a !== void 0 ? _a : this._logger.level;
+        if (args.length > 0) {
+          message += " %O".repeat(args.length);
+        }
+        this._logger.log(winstonLevel, message, ...args);
+      }
+      /**
+       * Log an error message.
+       *
+       * @param message - error message
+       * @param args - additional arguments like objects, arrays, etc.
+       */
+      error(message, ...args) {
+        this.logWithArgs(types_1.LogLevel.Error, message, ...args);
+      }
+      /**
+       * Log a warning message.
+       *
+       * @param message - warning message
+       * @param args - additional arguments like objects, arrays, etc.
+       */
+      warn(message, ...args) {
+        this.logWithArgs(types_1.LogLevel.Warn, message, ...args);
+      }
+      /**
+       * Log an info message.
+       *
+       * @param message - info message
+       * @param args - additional arguments like objects, arrays, etc.
+       */
+      info(message, ...args) {
+        this.logWithArgs(types_1.LogLevel.Info, message, ...args);
+      }
+      /**
+       * Log a debug message.
+       *
+       * @param message - debug message
+       * @param args - additional arguments like objects, arrays, etc.
+       */
+      debug(message, ...args) {
+        this.logWithArgs(types_1.LogLevel.Debug, message, ...args);
+      }
+      /**
+       * Log a trace message.
+       *
+       * @param message - log message
+       * @param args - additional arguments like objects, arrays, etc.
+       */
+      trace(message, ...args) {
+        this.logWithArgs(types_1.LogLevel.Silly, message, ...args);
+      }
+      /**
+       * Show the output channel in Visual Studio Code.
+       */
+      show() {
+        const winstonVSCodeTransport = this._logger.transports.find((t) => t instanceof vscode_output_channel_transport_1.VSCodeTransport);
+        if (winstonVSCodeTransport) {
+          winstonVSCodeTransport.show();
+        }
+      }
+    };
+    exports.ExtensionLogger = ExtensionLogger;
+  }
+});
+
 // ../../node_modules/@sap-ux/logger/dist/index.js
 var require_dist = __commonJS({
   "../../node_modules/@sap-ux/logger/dist/index.js"(exports) {
@@ -30056,13 +32930,17 @@ var require_dist = __commonJS({
           __createBinding(exports2, m, p);
     };
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.ToolsLogger = void 0;
+    exports.ExtensionLogger = exports.ToolsLogger = void 0;
     __exportStar(require_types(), exports);
     __exportStar(require_transports(), exports);
     var winston_logger_1 = require_winston_logger();
     Object.defineProperty(exports, "ToolsLogger", { enumerable: true, get: function() {
       return winston_logger_1.WinstonLogger;
     } });
+    var extension_logger_1 = require_extension_logger();
+    Object.defineProperty(exports, "ExtensionLogger", { enumerable: true, get: function() {
+      return extension_logger_1.ExtensionLogger;
+    } });
   }
 });
 
@@ -32464,7 +35342,7 @@ var i18n_default = {
   INDEX_EXISTS_NOT_OVERWRITING: "'index.html' already exists, not generating one",
   INDEX_HTML_ADDED: "index.html added",
   INFO_CREATE_ARCHIVE: "Create Archive",
-  INFO_COMMAND_FAILED: "Command {{cmd}} failed with error {{-message}}",
+  INFO_COMMAND_FAILED: "Command {{cmd}} failed with error : {{-message}}",
   INFO_DEPLOYMENT_SUCCESSFUL: "Deployment Successful.",
   INFO_TEST_MODE: "Deployment in TestMode completed. A successful TestMode execution does not necessarily mean that your upload will be successful",
   ERROR_NO_SYSTEM_IN_STORE: "Error in deployment. The BTP system used in the deployment configuration could not be found as one of your local saved SAP systems. Please ensure you have saved this system locally so that it can be used for deployment.",
@@ -32549,6 +35427,7 @@ var i18n_default = {
   ARCHIVE_PATH_CREATED: "Archive path created {{-archivePath}}",
   ARCHIVE_PATH_AVAILABLE: "Archive read from {{-archivePath}}",
   ERROR_UPDATE_DEPLOY_CONFIG: "Error while updating config file, error was: {{-error}}",
+  ERROR_NO_DEPLOY_CONFIG: "Error loading deployment configuration. Please ensure the YAML syntax and indentation is correct.",
   TELEMETRY_CALL_FAILED: "Error while sending telemetry data",
   ERROR_TRANSPORT_REQUEST_CREATION: "Transport request could not be created for application {{appName}}. Please create it manually and re-run deployment configuration for this project.",
   UPDATE_UI5_CLI: "The UI5 CLI version of the project is outdated. Please upgrade your project to UI5 CLI v3:\nhttps://sap.github.io/ui5-tooling/v3/updates/migrate-v3/."