elit 3.6.4 → 3.6.6

package/dist/smtp-server.js

@@ -0,0 +1,4186 @@
+"use strict";
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined") return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  };
+  var __commonJS = (cb, mod) => function __require2() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // node_modules/smtp-server/lib/smtp-stream.js
+  var require_smtp_stream = __commonJS({
+    "node_modules/smtp-server/lib/smtp-stream.js"(exports, module) {
+      "use strict";
+      var stream = __require("stream");
+      var Writable = stream.Writable;
+      var PassThrough = stream.PassThrough;
+      var SMTPStream = class extends Writable {
+        constructor(options) {
+          super(options);
+          this._dataMode = false;
+          this._dataStream = null;
+          this._maxBytes = Infinity;
+          this.dataBytes = 0;
+          this._continueCallback = false;
+          this._remainder = "";
+          this._lastBytes = false;
+          this._maxCommandLength = options && options.maxCommandLength || 4 * 1024;
+          this.isClosed = false;
+          this.on("finish", () => this._flushData());
+        }
+        /**
+         * Placeholder command handler. Override this with your own.
+         */
+        oncommand() {
+          throw new Error("Command handler is not set");
+        }
+        /**
+         * Switch to data mode and return output stream. The dots in the stream are unescaped.
+         *
+         * @returns {Stream} Data stream
+         */
+        startDataMode(maxBytes) {
+          this._dataMode = true;
+          this._maxBytes = maxBytes && Number(maxBytes) || Infinity;
+          this.dataBytes = 0;
+          this._dataStream = new PassThrough();
+          return this._dataStream;
+        }
+        /**
+         * Call this once data mode is over and you have finished processing the data stream
+         */
+        continue() {
+          if (typeof this._continueCallback === "function") {
+            this._continueCallback();
+            this._continueCallback = false;
+          } else {
+            this._continueCallback = true;
+          }
+        }
+        // PRIVATE METHODS
+        /**
+         * Writable._write method.
+         */
+        _write(chunk, encoding, next) {
+          if (!chunk || !chunk.length) {
+            return next();
+          }
+          let data;
+          let pos = 0;
+          let newlineRegex;
+          let called = false;
+          let done = (...args) => {
+            if (called) {
+              return;
+            }
+            called = true;
+            next(...args);
+          };
+          if (this.isClosed) {
+            return done();
+          }
+          if (!this._dataMode) {
+            newlineRegex = /\r?\n/g;
+            data = this._remainder + chunk.toString("binary");
+            let readLine = () => {
+              let match;
+              let line;
+              let buf;
+              if (this._dataMode) {
+                buf = Buffer.from(data.substr(pos), "binary");
+                this._remainder = "";
+                return this._write(buf, "buffer", done);
+              }
+              if (match = newlineRegex.exec(data)) {
+                line = data.substr(pos, match.index - pos);
+                pos += line.length + match[0].length;
+              } else {
+                this._remainder = pos < data.length ? data.substr(pos) : "";
+                if (this._remainder.length > this._maxCommandLength) {
+                  this._remainder = "";
+                  return done(new Error("Command line too long"));
+                }
+                return done();
+              }
+              this.oncommand(Buffer.from(line, "binary"), readLine);
+            };
+            readLine();
+          } else {
+            this._feedDataStream(chunk, done);
+          }
+        }
+        /**
+         * Processes a chunk in data mode. Escape dots are removed and final dot ends the data mode.
+         */
+        _feedDataStream(chunk, done) {
+          let i;
+          let endseq = Buffer.from("\r\n.\r\n");
+          let len;
+          let handled;
+          let buf;
+          if (this._lastBytes && this._lastBytes.length) {
+            chunk = Buffer.concat([this._lastBytes, chunk], this._lastBytes.length + chunk.length);
+            this._lastBytes = false;
+          }
+          len = chunk.length;
+          if (!this.dataBytes && len >= 3 && Buffer.compare(chunk.slice(0, 3), Buffer.from(".\r\n")) === 0) {
+            this._endDataMode(false, chunk.slice(3), done);
+            return;
+          }
+          if (!this.dataBytes && len >= 2 && chunk[0] === 46 && chunk[1] === 46) {
+            chunk = chunk.slice(1);
+            len--;
+          }
+          for (i = 2; i < len - 2; i++) {
+            if (chunk[i] === 46 && chunk[i - 1] === 10) {
+              if (Buffer.compare(chunk.slice(i - 2, i + 3), endseq) === 0) {
+                if (i > 2) {
+                  buf = chunk.slice(0, i);
+                  this.dataBytes += buf.length;
+                  this._endDataMode(buf, chunk.slice(i + 3), done);
+                } else {
+                  this._endDataMode(false, chunk.slice(i + 3), done);
+                }
+                return;
+              }
+              if (chunk[i + 1] === 46) {
+                buf = chunk.slice(0, i);
+                this._lastBytes = false;
+                this.dataBytes += buf.length;
+                if (this._dataStream.writable) {
+                  this._dataStream.write(buf);
+                }
+                return setImmediate(() => this._feedDataStream(chunk.slice(i + 1), done));
+              }
+            }
+          }
+          if (chunk.length < 4) {
+            this._lastBytes = chunk;
+          } else {
+            this._lastBytes = chunk.slice(chunk.length - 4);
+          }
+          if (this._lastBytes.length < chunk.length) {
+            buf = chunk.slice(0, chunk.length - this._lastBytes.length);
+            this.dataBytes += buf.length;
+            if (this._dataStream.writable) {
+              handled = this._dataStream.write(buf);
+              if (!handled) {
+                this._dataStream.once("drain", done);
+              } else {
+                return done();
+              }
+            } else {
+              return done();
+            }
+          } else {
+            return done();
+          }
+        }
+        /**
+         * Flushes remaining bytes
+         */
+        _flushData() {
+          let line;
+          if (this._remainder && !this.isClosed) {
+            line = this._remainder;
+            this._remainder = "";
+            this.oncommand(Buffer.from(line, "binary"));
+          }
+        }
+        /**
+         * Ends data mode and returns to command mode. Stream is not resumed before #continue is called
+         */
+        _endDataMode(chunk, remainder, callback) {
+          if (this._continueCallback === true) {
+            this._continueCallback = false;
+            this._dataStream.once("end", callback);
+          } else {
+            this._continueCallback = () => this._write(remainder, "buffer", callback);
+          }
+          this._dataStream.byteLength = this.dataBytes;
+          this._dataStream.sizeExceeded = this.dataBytes > this._maxBytes;
+          if (chunk && chunk.length && this._dataStream.writable) {
+            this._dataStream.end(chunk);
+          } else {
+            this._dataStream.end();
+          }
+          this._dataMode = false;
+          this._remainder = "";
+          this._dataStream = null;
+        }
+      };
+      module.exports.SMTPStream = SMTPStream;
+    }
+  });
+
+  // node_modules/ipv6-normalize/index.js
+  var require_ipv6_normalize = __commonJS({
+    "node_modules/ipv6-normalize/index.js"(exports, module) {
+      "use strict";
+      module.exports = function(address) {
+        var _address = address.toLowerCase();
+        var segments = _address.split(":");
+        var length = segments.length;
+        var total = 8;
+        if (segments[0] === "" && segments[1] === "" && segments[2] === "") {
+          segments.shift();
+          segments.shift();
+        } else if (segments[0] === "" && segments[1] === "") {
+          segments.shift();
+        } else if (segments[length - 1] === "" && segments[length - 2] === "") {
+          segments.pop();
+        }
+        length = segments.length;
+        if (segments[length - 1].indexOf(".") !== -1) {
+          total = 7;
+        }
+        var pos;
+        for (pos = 0; pos < length; pos++) {
+          if (segments[pos] === "") {
+            break;
+          }
+        }
+        if (pos < total) {
+          segments.splice(pos, 1, "0000");
+          while (segments.length < total) {
+            segments.splice(pos, 0, "0000");
+          }
+          length = segments.length;
+        }
+        var _segments;
+        for (var i = 0; i < total; i++) {
+          _segments = segments[i].split("");
+          for (var j = 0; j < 3; j++) {
+            if (_segments[0] === "0" && _segments.length > 1) {
+              _segments.splice(0, 1);
+            } else {
+              break;
+            }
+          }
+          segments[i] = _segments.join("");
+        }
+        var best = -1;
+        var _best = 0;
+        var _current = 0;
+        var current = -1;
+        var inzeroes = false;
+        for (i = 0; i < total; i++) {
+          if (inzeroes) {
+            if (segments[i] === "0") {
+              _current += 1;
+            } else {
+              inzeroes = false;
+              if (_current > _best) {
+                best = current;
+                _best = _current;
+              }
+            }
+          } else {
+            if (segments[i] === "0") {
+              inzeroes = true;
+              current = i;
+              _current = 1;
+            }
+          }
+        }
+        if (_current > _best) {
+          best = current;
+          _best = _current;
+        }
+        if (_best > 1) {
+          segments.splice(best, _best, "");
+        }
+        length = segments.length;
+        var result = "";
+        if (segments[0] === "") {
+          result = ":";
+        }
+        for (i = 0; i < length; i++) {
+          result += segments[i];
+          if (i === length - 1) {
+            break;
+          }
+          result += ":";
+        }
+        if (segments[length - 1] === "") {
+          result += ":";
+        }
+        return result;
+      };
+    }
+  });
+
+  // node_modules/smtp-server/lib/sasl.js
+  var require_sasl = __commonJS({
+    "node_modules/smtp-server/lib/sasl.js"(exports, module) {
+      "use strict";
+      var util = __require("util");
+      var crypto = __require("crypto");
+      var SASL = module.exports = {
+        SASL_PLAIN(args, callback) {
+          if (args.length > 1) {
+            this.send(501, "Error: syntax: AUTH PLAIN token");
+            return callback();
+          }
+          if (!args.length) {
+            this._nextHandler = SASL.PLAIN_token.bind(this, true);
+            this.send(334);
+            return callback();
+          }
+          SASL.PLAIN_token.call(this, false, args[0], callback);
+        },
+        SASL_LOGIN(args, callback) {
+          if (args.length > 1) {
+            this.send(501, "Error: syntax: AUTH LOGIN");
+            return callback();
+          }
+          if (!args.length) {
+            this._nextHandler = SASL.LOGIN_username.bind(this, true);
+            this.send(334, "VXNlcm5hbWU6");
+            return callback();
+          }
+          SASL.LOGIN_username.call(this, false, args[0], callback);
+        },
+        SASL_XOAUTH2(args, callback) {
+          if (args.length > 1) {
+            this.send(501, "Error: syntax: AUTH XOAUTH2 token");
+            return callback();
+          }
+          if (!args.length) {
+            this._nextHandler = SASL.XOAUTH2_token.bind(this, true);
+            this.send(334);
+            return callback();
+          }
+          SASL.XOAUTH2_token.call(this, false, args[0], callback);
+        },
+        "SASL_CRAM-MD5"(args, callback) {
+          if (args.length) {
+            this.send(501, "Error: syntax: AUTH CRAM-MD5");
+            return callback();
+          }
+          let challenge = util.format(
+            "<%s%s@%s>",
+            String(Math.random()).replace(/^[0.]+/, "").substr(0, 8),
+            // random numbers
+            Math.floor(Date.now() / 1e3),
+            // timestamp
+            this.name
+            // hostname
+          );
+          this._nextHandler = SASL["CRAM-MD5_token"].bind(this, true, challenge);
+          this.send(334, Buffer.from(challenge).toString("base64"));
+          return callback();
+        },
+        PLAIN_token(canAbort, token, callback) {
+          token = (token || "").toString().trim();
+          if (canAbort && token === "*") {
+            this.send(501, "Authentication aborted");
+            return callback();
+          }
+          let data = Buffer.from(token, "base64").toString().split("\0");
+          if (data.length !== 3) {
+            this.send(500, "Error: invalid userdata");
+            return callback();
+          }
+          let username = data[1] || data[0] || "";
+          let password = data[2] || "";
+          this._server.onAuth(
+            {
+              method: "PLAIN",
+              username,
+              password
+            },
+            this.session,
+            (err, response) => {
+              if (err) {
+                this._server.logger.info(
+                  {
+                    err,
+                    tnx: "autherror",
+                    cid: this.id,
+                    method: "PLAIN",
+                    user: username
+                  },
+                  "Authentication error for %s using %s. %s",
+                  username,
+                  "PLAIN",
+                  err.message
+                );
+                this.send(err.responseCode || 535, err.message);
+                return callback();
+              }
+              if (!response.user) {
+                this._server.logger.info(
+                  {
+                    tnx: "authfail",
+                    cid: this.id,
+                    method: "PLAIN",
+                    user: username
+                  },
+                  "Authentication failed for %s using %s",
+                  username,
+                  "PLAIN"
+                );
+                this.send(response.responseCode || 535, response.message || "Error: Authentication credentials invalid");
+                return callback();
+              }
+              this._server.logger.info(
+                {
+                  tnx: "auth",
+                  cid: this.id,
+                  method: "PLAIN",
+                  user: username
+                },
+                "%s authenticated using %s",
+                username,
+                "PLAIN"
+              );
+              this.session.user = response.user;
+              this.session.transmissionType = this._transmissionType();
+              this.send(235, "Authentication successful");
+              callback();
+            }
+          );
+        },
+        LOGIN_username(canAbort, username, callback) {
+          username = (username || "").toString().trim();
+          if (canAbort && username === "*") {
+            this.send(501, "Authentication aborted");
+            return callback();
+          }
+          username = Buffer.from(username, "base64").toString();
+          if (!username) {
+            this.send(500, "Error: missing username");
+            return callback();
+          }
+          this._nextHandler = SASL.LOGIN_password.bind(this, username);
+          this.send(334, "UGFzc3dvcmQ6");
+          return callback();
+        },
+        LOGIN_password(username, password, callback) {
+          password = (password || "").toString().trim();
+          if (password === "*") {
+            this.send(501, "Authentication aborted");
+            return callback();
+          }
+          password = Buffer.from(password, "base64").toString();
+          this._server.onAuth(
+            {
+              method: "LOGIN",
+              username,
+              password
+            },
+            this.session,
+            (err, response) => {
+              if (err) {
+                this._server.logger.info(
+                  {
+                    err,
+                    tnx: "autherror",
+                    cid: this.id,
+                    method: "LOGIN",
+                    user: username
+                  },
+                  "Authentication error for %s using %s. %s",
+                  username,
+                  "LOGIN",
+                  err.message
+                );
+                this.send(err.responseCode || 535, err.message);
+                return callback();
+              }
+              if (!response.user) {
+                this._server.logger.info(
+                  {
+                    tnx: "authfail",
+                    cid: this.id,
+                    method: "LOGIN",
+                    user: username
+                  },
+                  "Authentication failed for %s using %s",
+                  username,
+                  "LOGIN"
+                );
+                this.send(response.responseCode || 535, response.message || "Error: Authentication credentials invalid");
+                return callback();
+              }
+              this._server.logger.info(
+                {
+                  tnx: "auth",
+                  cid: this.id,
+                  method: "PLAIN",
+                  user: username
+                },
+                "%s authenticated using %s",
+                username,
+                "LOGIN"
+              );
+              this.session.user = response.user;
+              this.session.transmissionType = this._transmissionType();
+              this.send(235, "Authentication successful");
+              callback();
+            }
+          );
+        },
+        XOAUTH2_token(canAbort, token, callback) {
+          token = (token || "").toString().trim();
+          if (canAbort && token === "*") {
+            this.send(501, "Authentication aborted");
+            return callback();
+          }
+          let username;
+          let accessToken;
+          Buffer.from(token, "base64").toString().split("
").forEach((part) => {
+            part = part.split("=");
+            let key = part.shift().toLowerCase();
+            let value = part.join("=").trim();
+            if (key === "user") {
+              username = value;
+            } else if (key === "auth") {
+              value = value.split(/\s+/);
+              if (value.shift().toLowerCase() === "bearer") {
+                accessToken = value.join(" ");
+              }
+            }
+          });
+          if (!username || !accessToken) {
+            this.send(500, "Error: invalid userdata");
+            return callback();
+          }
+          this._server.onAuth(
+            {
+              method: "XOAUTH2",
+              username,
+              accessToken
+            },
+            this.session,
+            (err, response) => {
+              if (err) {
+                this._server.logger.info(
+                  {
+                    err,
+                    tnx: "autherror",
+                    cid: this.id,
+                    method: "XOAUTH2",
+                    user: username
+                  },
+                  "Authentication error for %s using %s. %s",
+                  username,
+                  "XOAUTH2",
+                  err.message
+                );
+                this.send(err.responseCode || 535, err.message);
+                return callback();
+              }
+              if (!response.user) {
+                this._server.logger.info(
+                  {
+                    tnx: "authfail",
+                    cid: this.id,
+                    method: "XOAUTH2",
+                    user: username
+                  },
+                  "Authentication failed for %s using %s",
+                  username,
+                  "XOAUTH2"
+                );
+                this._nextHandler = SASL.XOAUTH2_error.bind(this);
+                this.send(response.responseCode || 334, Buffer.from(JSON.stringify(response.data || {})).toString("base64"));
+                return callback();
+              }
+              this._server.logger.info(
+                {
+                  tnx: "auth",
+                  cid: this.id,
+                  method: "XOAUTH2",
+                  user: username
+                },
+                "%s authenticated using %s",
+                username,
+                "XOAUTH2"
+              );
+              this.session.user = response.user;
+              this.session.transmissionType = this._transmissionType();
+              this.send(235, "Authentication successful");
+              callback();
+            }
+          );
+        },
+        XOAUTH2_error(data, callback) {
+          this.send(535, "Error: Username and Password not accepted");
+          return callback();
+        },
+        "CRAM-MD5_token"(canAbort, challenge, token, callback) {
+          token = (token || "").toString().trim();
+          if (canAbort && token === "*") {
+            this.send(501, "Authentication aborted");
+            return callback();
+          }
+          let tokenParts = Buffer.from(token, "base64").toString().split(" ");
+          let username = tokenParts.shift();
+          let challengeResponse = (tokenParts.shift() || "").toLowerCase();
+          this._server.onAuth(
+            {
+              method: "CRAM-MD5",
+              username,
+              challenge,
+              challengeResponse,
+              validatePassword(password) {
+                let hmac = crypto.createHmac("md5", password);
+                return hmac.update(challenge).digest("hex").toLowerCase() === challengeResponse;
+              }
+            },
+            this.session,
+            (err, response) => {
+              if (err) {
+                this._server.logger.info(
+                  {
+                    err,
+                    tnx: "autherror",
+                    cid: this.id,
+                    method: "CRAM-MD5",
+                    user: username
+                  },
+                  "Authentication error for %s using %s. %s",
+                  username,
+                  "CRAM-MD5",
+                  err.message
+                );
+                this.send(err.responseCode || 535, err.message);
+                return callback();
+              }
+              if (!response.user) {
+                this._server.logger.info(
+                  {
+                    tnx: "authfail",
+                    cid: this.id,
+                    method: "CRAM-MD5",
+                    user: username
+                  },
+                  "Authentication failed for %s using %s",
+                  username,
+                  "CRAM-MD5"
+                );
+                this.send(response.responseCode || 535, response.message || "Error: Authentication credentials invalid");
+                return callback();
+              }
+              this._server.logger.info(
+                {
+                  tnx: "auth",
+                  cid: this.id,
+                  method: "CRAM-MD5",
+                  user: username
+                },
+                "%s authenticated using %s",
+                username,
+                "CRAM-MD5"
+              );
+              this.session.user = response.user;
+              this.session.transmissionType = this._transmissionType();
+              this.send(235, "Authentication successful");
+              callback();
+            }
+          );
+        },
+        // this is not a real auth but a username validation initiated by SMTP proxy
+        SASL_XCLIENT(args, callback) {
+          const username = (args && args[0] || "").toString().trim();
+          this._server.onAuth(
+            {
+              method: "XCLIENT",
+              username,
+              password: null
+            },
+            this.session,
+            (err, response) => {
+              if (err) {
+                this._server.logger.info(
+                  {
+                    err,
+                    tnx: "autherror",
+                    cid: this.id,
+                    method: "XCLIENT",
+                    user: username
+                  },
+                  "Authentication error for %s using %s. %s",
+                  username,
+                  "XCLIENT",
+                  err.message
+                );
+                return callback(err);
+              }
+              if (!response.user) {
+                this._server.logger.info(
+                  {
+                    tnx: "authfail",
+                    cid: this.id,
+                    method: "XCLIENT",
+                    user: username
+                  },
+                  "Authentication failed for %s using %s",
+                  username,
+                  "XCLIENT"
+                );
+                return callback(new Error("Authentication credentials invalid"));
+              }
+              this._server.logger.info(
+                {
+                  tnx: "auth",
+                  cid: this.id,
+                  method: "XCLIENT",
+                  user: username
+                },
+                "%s authenticated using %s",
+                username,
+                "XCLIENT"
+              );
+              this.session.user = response.user;
+              this.session.transmissionType = this._transmissionType();
+              callback();
+            }
+          );
+        }
+      };
+    }
+  });
+
+  // node_modules/punycode.js/punycode.es6.js
+  var punycode_es6_exports = {};
+  __export(punycode_es6_exports, {
+    decode: () => decode,
+    default: () => punycode_es6_default,
+    encode: () => encode,
+    toASCII: () => toASCII,
+    toUnicode: () => toUnicode,
+    ucs2decode: () => ucs2decode,
+    ucs2encode: () => ucs2encode
+  });
+  function error(type) {
+    throw new RangeError(errors[type]);
+  }
+  function map(array, callback) {
+    const result = [];
+    let length = array.length;
+    while (length--) {
+      result[length] = callback(array[length]);
+    }
+    return result;
+  }
+  function mapDomain(domain, callback) {
+    const parts = domain.split("@");
+    let result = "";
+    if (parts.length > 1) {
+      result = parts[0] + "@";
+      domain = parts[1];
+    }
+    domain = domain.replace(regexSeparators, ".");
+    const labels = domain.split(".");
+    const encoded = map(labels, callback).join(".");
+    return result + encoded;
+  }
+  function ucs2decode(string) {
+    const output = [];
+    let counter = 0;
+    const length = string.length;
+    while (counter < length) {
+      const value = string.charCodeAt(counter++);
+      if (value >= 55296 && value <= 56319 && counter < length) {
+        const extra = string.charCodeAt(counter++);
+        if ((extra & 64512) == 56320) {
+          output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
+        } else {
+          output.push(value);
+          counter--;
+        }
+      } else {
+        output.push(value);
+      }
+    }
+    return output;
+  }
+  var maxInt, base, tMin, tMax, skew, damp, initialBias, initialN, delimiter, regexPunycode, regexNonASCII, regexSeparators, errors, baseMinusTMin, floor, stringFromCharCode, ucs2encode, basicToDigit, digitToBasic, adapt, decode, encode, toUnicode, toASCII, punycode, punycode_es6_default;
+  var init_punycode_es6 = __esm({
+    "node_modules/punycode.js/punycode.es6.js"() {
+      "use strict";
+      maxInt = 2147483647;
+      base = 36;
+      tMin = 1;
+      tMax = 26;
+      skew = 38;
+      damp = 700;
+      initialBias = 72;
+      initialN = 128;
+      delimiter = "-";
+      regexPunycode = /^xn--/;
+      regexNonASCII = /[^\0-\x7F]/;
+      regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
+      errors = {
+        "overflow": "Overflow: input needs wider integers to process",
+        "not-basic": "Illegal input >= 0x80 (not a basic code point)",
+        "invalid-input": "Invalid input"
+      };
+      baseMinusTMin = base - tMin;
+      floor = Math.floor;
+      stringFromCharCode = String.fromCharCode;
+      ucs2encode = (codePoints) => String.fromCodePoint(...codePoints);
+      basicToDigit = function(codePoint) {
+        if (codePoint >= 48 && codePoint < 58) {
+          return 26 + (codePoint - 48);
+        }
+        if (codePoint >= 65 && codePoint < 91) {
+          return codePoint - 65;
+        }
+        if (codePoint >= 97 && codePoint < 123) {
+          return codePoint - 97;
+        }
+        return base;
+      };
+      digitToBasic = function(digit, flag) {
+        return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
+      };
+      adapt = function(delta, numPoints, firstTime) {
+        let k = 0;
+        delta = firstTime ? floor(delta / damp) : delta >> 1;
+        delta += floor(delta / numPoints);
+        for (; delta > baseMinusTMin * tMax >> 1; k += base) {
+          delta = floor(delta / baseMinusTMin);
+        }
+        return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
+      };
+      decode = function(input) {
+        const output = [];
+        const inputLength = input.length;
+        let i = 0;
+        let n = initialN;
+        let bias = initialBias;
+        let basic = input.lastIndexOf(delimiter);
+        if (basic < 0) {
+          basic = 0;
+        }
+        for (let j = 0; j < basic; ++j) {
+          if (input.charCodeAt(j) >= 128) {
+            error("not-basic");
+          }
+          output.push(input.charCodeAt(j));
+        }
+        for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
+          const oldi = i;
+          for (let w = 1, k = base; ; k += base) {
+            if (index >= inputLength) {
+              error("invalid-input");
+            }
+            const digit = basicToDigit(input.charCodeAt(index++));
+            if (digit >= base) {
+              error("invalid-input");
+            }
+            if (digit > floor((maxInt - i) / w)) {
+              error("overflow");
+            }
+            i += digit * w;
+            const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+            if (digit < t) {
+              break;
+            }
+            const baseMinusT = base - t;
+            if (w > floor(maxInt / baseMinusT)) {
+              error("overflow");
+            }
+            w *= baseMinusT;
+          }
+          const out = output.length + 1;
+          bias = adapt(i - oldi, out, oldi == 0);
+          if (floor(i / out) > maxInt - n) {
+            error("overflow");
+          }
+          n += floor(i / out);
+          i %= out;
+          output.splice(i++, 0, n);
+        }
+        return String.fromCodePoint(...output);
+      };
+      encode = function(input) {
+        const output = [];
+        input = ucs2decode(input);
+        const inputLength = input.length;
+        let n = initialN;
+        let delta = 0;
+        let bias = initialBias;
+        for (const currentValue of input) {
+          if (currentValue < 128) {
+            output.push(stringFromCharCode(currentValue));
+          }
+        }
+        const basicLength = output.length;
+        let handledCPCount = basicLength;
+        if (basicLength) {
+          output.push(delimiter);
+        }
+        while (handledCPCount < inputLength) {
+          let m = maxInt;
+          for (const currentValue of input) {
+            if (currentValue >= n && currentValue < m) {
+              m = currentValue;
+            }
+          }
+          const handledCPCountPlusOne = handledCPCount + 1;
+          if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
+            error("overflow");
+          }
+          delta += (m - n) * handledCPCountPlusOne;
+          n = m;
+          for (const currentValue of input) {
+            if (currentValue < n && ++delta > maxInt) {
+              error("overflow");
+            }
+            if (currentValue === n) {
+              let q = delta;
+              for (let k = base; ; k += base) {
+                const t = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
+                if (q < t) {
+                  break;
+                }
+                const qMinusT = q - t;
+                const baseMinusT = base - t;
+                output.push(
+                  stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))
+                );
+                q = floor(qMinusT / baseMinusT);
+              }
+              output.push(stringFromCharCode(digitToBasic(q, 0)));
+              bias = adapt(delta, handledCPCountPlusOne, handledCPCount === basicLength);
+              delta = 0;
+              ++handledCPCount;
+            }
+          }
+          ++delta;
+          ++n;
+        }
+        return output.join("");
+      };
+      toUnicode = function(input) {
+        return mapDomain(input, function(string) {
+          return regexPunycode.test(string) ? decode(string.slice(4).toLowerCase()) : string;
+        });
+      };
+      toASCII = function(input) {
+        return mapDomain(input, function(string) {
+          return regexNonASCII.test(string) ? "xn--" + encode(string) : string;
+        });
+      };
+      punycode = {
+        /**
+         * A string representing the current Punycode.js version number.
+         * @memberOf punycode
+         * @type String
+         */
+        "version": "2.3.1",
+        /**
+         * An object of methods to convert from JavaScript's internal character
+         * representation (UCS-2) to Unicode code points, and back.
+         * @see <https://mathiasbynens.be/notes/javascript-encoding>
+         * @memberOf punycode
+         * @type Object
+         */
+        "ucs2": {
+          "decode": ucs2decode,
+          "encode": ucs2encode
+        },
+        "decode": decode,
+        "encode": encode,
+        "toASCII": toASCII,
+        "toUnicode": toUnicode
+      };
+      punycode_es6_default = punycode;
+    }
+  });
+
+  // node_modules/smtp-server/lib/smtp-connection.js
+  var require_smtp_connection = __commonJS({
+    "node_modules/smtp-server/lib/smtp-connection.js"(exports, module) {
+      "use strict";
+      var SMTPStream = require_smtp_stream().SMTPStream;
+      var dns = __require("dns");
+      var tls = __require("tls");
+      var net = __require("net");
+      var ipv6normalize = require_ipv6_normalize();
+      var sasl = require_sasl();
+      var crypto = __require("crypto");
+      var os = __require("os");
+      var punycode2 = (init_punycode_es6(), __toCommonJS(punycode_es6_exports));
+      var EventEmitter = __require("events");
+      var SOCKET_TIMEOUT = 60 * 1e3;
+      var ENHANCED_STATUS_CODES = {
+        // Success codes (2xx)
+        200: "2.0.0",
+        // System status, or system help reply
+        211: "2.0.0",
+        // System status, or system help reply
+        214: "2.0.0",
+        // Help message
+        220: "2.0.0",
+        // Service ready
+        221: "2.0.0",
+        // Service closing transmission channel
+        235: "2.7.0",
+        // Authentication successful
+        250: "2.0.0",
+        // Requested mail action okay, completed
+        251: "2.1.5",
+        // User not local; will forward
+        252: "2.1.5",
+        // Cannot VRFY user, but will accept message
+        334: "3.7.0",
+        // Server challenge for authentication
+        354: "2.0.0",
+        // Start mail input; end with <CRLF>.<CRLF>
+        // Temporary failure codes (4xx)
+        420: "4.4.2",
+        // Timeout or connection lost (non-standard, used by some servers)
+        421: "4.4.2",
+        // Service not available, closing transmission channel
+        450: "4.2.1",
+        // Requested mail action not taken: mailbox unavailable
+        451: "4.3.0",
+        // Requested action aborted: local error in processing
+        452: "4.2.2",
+        // Requested action not taken: insufficient system storage
+        454: "4.7.0",
+        // Temporary authentication failure
+        // Permanent failure codes (5xx)
+        500: "5.5.2",
+        // Syntax error, command unrecognized
+        501: "5.5.4",
+        // Syntax error in parameters or arguments
+        502: "5.5.1",
+        // Command not implemented
+        503: "5.5.1",
+        // Bad sequence of commands
+        504: "5.5.4",
+        // Command parameter not implemented
+        521: "5.3.2",
+        // Machine does not accept mail
+        523: "5.3.4",
+        // Message size exceeds server limit (non-standard, used by some servers)
+        530: "5.7.0",
+        // Authentication required
+        535: "5.7.8",
+        // Authentication credentials invalid
+        538: "5.7.0",
+        // Must issue a STARTTLS command first (non-standard)
+        550: "5.1.1",
+        // Requested action not taken: mailbox unavailable
+        551: "5.1.6",
+        // User not local; please try forwarding
+        552: "5.2.2",
+        // Requested mail action aborted: exceeded storage allocation
+        553: "5.1.3",
+        // Requested action not taken: mailbox name not allowed
+        554: "5.6.0",
+        // Transaction failed
+        555: "5.5.4",
+        // MAIL FROM/RCPT TO parameters not recognized or not implemented
+        556: "5.1.10",
+        // RCPT TO syntax error (non-standard)
+        557: "5.7.1",
+        // Delivery not authorized (non-standard, used by some servers)
+        558: "5.2.3"
+        // Message too large for recipient (non-standard, used by some servers)
+      };
+      var SKIPPED_COMMANDS_FOR_ENHANCED_STATUS_CODES = /* @__PURE__ */ new Set(["HELO", "EHLO", "LHLO"]);
+      var CONTEXTUAL_STATUS_CODES = {
+        // Mail transaction specific codes
+        MAIL_FROM_OK: "2.1.0",
+        // Originator address valid
+        RCPT_TO_OK: "2.1.5",
+        // Destination address valid
+        DATA_OK: "2.6.0",
+        // Message accepted for delivery
+        // Authentication specific codes
+        AUTH_SUCCESS: "2.7.0",
+        // Authentication successful
+        AUTH_REQUIRED: "5.7.0",
+        // Authentication required
+        AUTH_INVALID: "5.7.8",
+        // Authentication credentials invalid
+        // Policy specific codes
+        POLICY_VIOLATION: "5.7.1",
+        // Delivery not authorized
+        SPAM_REJECTED: "5.7.1",
+        // Message refused
+        // Mailbox specific codes
+        MAILBOX_FULL: "4.2.2",
+        // Mailbox full
+        MAILBOX_NOT_FOUND: "5.1.1",
+        // Mailbox does not exist
+        MAILBOX_SYNTAX_ERROR: "5.1.3",
+        // Invalid mailbox syntax
+        // System specific codes
+        SYSTEM_ERROR: "4.3.0",
+        // System error
+        SYSTEM_FULL: "4.3.1",
+        // System storage exceeded
+        // Network specific codes
+        NETWORK_ERROR: "4.4.0",
+        // Network routing error
+        CONNECTION_TIMEOUT: "4.4.2"
+        // Connection timeout
+      };
+      var SMTPConnection = class extends EventEmitter {
+        constructor(server, socket, options) {
+          super();
+          options = options || {};
+          this.id = options.id || BigInt("0x" + crypto.randomBytes(10).toString("hex")).toString(32).padStart(16, "0");
+          this.ignore = options.ignore;
+          this._server = server;
+          this._socket = socket;
+          this.session = this.session = {
+            id: this.id
+          };
+          this._transactionCounter = 0;
+          this._ready = false;
+          this._upgrading = false;
+          this._nextHandler = false;
+          this._parser = new SMTPStream({
+            maxCommandLength: this._server.options.maxCommandLength
+          });
+          this._parser.oncommand = (...args) => this._onCommand(...args);
+          this._dataStream = false;
+          this.session.secure = this.secure = !!this._server.options.secure;
+          this.needsUpgrade = !!this._server.options.needsUpgrade;
+          this.tlsOptions = this.secure && !this.needsUpgrade && this._socket.getCipher ? this._socket.getCipher() : false;
+          this.localAddress = (options.localAddress || this._socket.localAddress || "").replace(/^::ffff:/, "");
+          this.localPort = Number(options.localPort || this._socket.localPort) || 0;
+          this.remoteAddress = (options.remoteAddress || this._socket.remoteAddress || "").replace(/^::ffff:/, "");
+          this.remotePort = Number(options.remotePort || this._socket.remotePort) || 0;
+          if (this.localAddress && net.isIPv6(this.localAddress)) {
+            this.localAddress = ipv6normalize(this.localAddress);
+          }
+          if (this.remoteAddress && net.isIPv6(this.remoteAddress)) {
+            this.remoteAddress = ipv6normalize(this.remoteAddress);
+          }
+          this._unauthenticatedCommands = 0;
+          this._maxAllowedUnauthenticatedCommands = this._server.options.maxAllowedUnauthenticatedCommands || 10;
+          this._unrecognizedCommands = 0;
+          this.name = this._server.options.name || os.hostname();
+          this.clientHostname = false;
+          this.openingCommand = false;
+          this.hostNameAppearsAs = false;
+          this._xClient = /* @__PURE__ */ new Map();
+          this._xForward = /* @__PURE__ */ new Map();
+          this._canEmitConnection = true;
+          this._closing = false;
+          this._closed = false;
+        }
+        /**
+         * Initiates the connection. Checks connection limits and reverse resolves client hostname. The client
+         * is not allowed to send anything before init has finished otherwise 'You talk too soon' error is returned
+         */
+        init() {
+          this._setListeners(() => {
+            if (this._server.options.maxClients && this._server.connections.size > this._server.options.maxClients) {
+              return this.send(421, this.name + " Too many connected clients, try again in a moment", false);
+            }
+            let readyTimer = setTimeout(() => this.connectionReady(), 100);
+            readyTimer.unref();
+          });
+        }
+        connectionReady(next) {
+          let reverseCb = (err, hostnames) => {
+            if (err) {
+              this._server.logger.error(
+                {
+                  tnx: "connection",
+                  cid: this.id,
+                  host: this.remoteAddress,
+                  hostname: this.clientHostname,
+                  err
+                },
+                "Reverse resolve for %s: %s",
+                this.remoteAddress,
+                err.message
+              );
+            }
+            if (this._closing || this._closed) {
+              return;
+            }
+            this.clientHostname = hostnames && hostnames.shift() || "[" + this.remoteAddress + "]";
+            this._resetSession();
+            let onSecureIfNeeded = (next2) => {
+              if (!this.session.secure) {
+                return next2();
+              }
+              this.session.servername = this._socket.servername;
+              this._server.onSecure(this._socket, this.session, (err2) => {
+                if (err2) {
+                  return this._onError(err2);
+                }
+                next2();
+              });
+            };
+            this._server.onConnect(this.session, (err2) => {
+              this._server.logger.info(
+                {
+                  tnx: "connection",
+                  cid: this.id,
+                  host: this.remoteAddress,
+                  hostname: this.clientHostname
+                },
+                "Connection from %s",
+                this.clientHostname
+              );
+              if (err2) {
+                this.send(err2.responseCode || 554, err2.message, false);
+                return this.close();
+              }
+              onSecureIfNeeded(() => {
+                this._ready = true;
+                if (!this._server.options.useXClient && !this._server.options.useXForward) {
+                  this.emitConnection();
+                }
+                this.send(
+                  220,
+                  this.name + " " + (this._server.options.lmtp ? "LMTP" : "ESMTP") + (this._server.options.banner ? " " + this._server.options.banner : ""),
+                  false
+                );
+                if (typeof next === "function") {
+                  next();
+                }
+              });
+            });
+          };
+          if (this._server.options.disableReverseLookup) {
+            return reverseCb(null, false);
+          }
+          let greetingSent = false;
+          let reverseTimer = setTimeout(() => {
+            clearTimeout(reverseTimer);
+            if (greetingSent) {
+              return;
+            }
+            greetingSent = true;
+            reverseCb(new Error("Timeout"));
+          }, 1500);
+          reverseTimer.unref();
+          const handleResolverResult = (...args) => {
+            clearTimeout(reverseTimer);
+            if (greetingSent) {
+              return;
+            }
+            greetingSent = true;
+            reverseCb(...args);
+          };
+          try {
+            if (this._server.options.resolver && typeof this._server.options.resolver.reverse === "function") {
+              this._server.options.resolver.reverse(this.remoteAddress.toString(), handleResolverResult);
+            } else {
+              dns.reverse(this.remoteAddress.toString(), handleResolverResult);
+            }
+          } catch (E) {
+            clearTimeout(reverseTimer);
+            if (greetingSent) {
+              return;
+            }
+            greetingSent = true;
+            reverseCb(E);
+          }
+        }
+        /**
+         * Send data to socket
+         *
+         * @param {Number} code Response code
+         * @param {String|Array} data If data is Array, send a multi-line response
+         * @param {String|Boolean} context Optional context for enhanced status codes
+         */
+        send(code, data, context) {
+          let payload;
+          let enhancedCode = this._getEnhancedStatusCode(code, context);
+          if (Array.isArray(data)) {
+            payload = data.map((line, i, arr) => {
+              let prefix = code + (i < arr.length - 1 ? "-" : " ");
+              if (enhancedCode) {
+                prefix += enhancedCode + " ";
+              }
+              return prefix + line;
+            }).join("\r\n");
+          } else {
+            let parts = [code];
+            if (enhancedCode) {
+              parts.push(enhancedCode);
+            }
+            if (data) {
+              parts.push(data);
+            }
+            payload = parts.join(" ");
+          }
+          if (code >= 400) {
+            this.session.error = payload;
+          }
+          if (code === 334 && payload === "334") {
+            payload += " ";
+          }
+          if (this._socket && !this._socket.destroyed && this._socket.readyState === "open") {
+            this._socket.write(payload + "\r\n");
+            this._server.logger.debug(
+              {
+                tnx: "send",
+                cid: this.id,
+                user: this.session.user && this.session.user.username || this.session.user
+              },
+              "S:",
+              payload
+            );
+          }
+          if (code === 421) {
+            this.close();
+          }
+        }
+        /**
+         * Close socket
+         */
+        close() {
+          if (!this._socket.destroyed && this._socket.writable) {
+            this._socket.end();
+          }
+          this._server.connections.delete(this);
+          this._closing = true;
+        }
+        // PRIVATE METHODS
+        /**
+         * Setup socket event handlers
+         */
+        _setListeners(callback) {
+          this._socket.on("close", (hadError) => this._onCloseEvent(hadError));
+          this._socket.on("error", (err) => this._onError(err));
+          this._parser.on("error", (err) => {
+            this.send(421, "Error: " + err.message);
+          });
+          this._socket.setTimeout(this._server.options.socketTimeout || SOCKET_TIMEOUT, () => this._onTimeout());
+          this._socket.pipe(this._parser);
+          if (!this.needsUpgrade) {
+            return callback();
+          }
+          this.upgrade(() => false, callback);
+        }
+        _onCloseEvent(hadError) {
+          this._server.logger.info(
+            {
+              tnx: "close",
+              cid: this.id,
+              host: this.remoteAddress,
+              user: this.session.user && this.session.user.username || this.session.user,
+              hadError
+            },
+            '%s received "close" event from %s' + (hadError ? " after error" : ""),
+            this.id,
+            this.remoteAddress
+          );
+          this._onClose();
+        }
+        /**
+         * Fired when the socket is closed
+         * @event
+         */
+        _onClose() {
+          if (this._parser) {
+            this._parser.isClosed = true;
+            this._socket.unpipe(this._parser);
+            this._parser = false;
+          }
+          if (this._dataStream) {
+            this._dataStream.unpipe();
+            this._dataStream = null;
+          }
+          this._server.connections.delete(this);
+          if (this._closed) {
+            return;
+          }
+          this._closed = true;
+          this._closing = false;
+          this._server.logger.info(
+            {
+              tnx: "close",
+              cid: this.id,
+              host: this.remoteAddress,
+              user: this.session.user && this.session.user.username || this.session.user
+            },
+            "Connection closed to %s",
+            this.clientHostname || this.remoteAddress
+          );
+          setImmediate(() => this._server.onClose(this.session));
+        }
+        /**
+         * Fired when an error occurs with the socket
+         *
+         * @event
+         * @param {Error} err Error object
+         */
+        _onError(err) {
+          err.remoteAddress = this.remoteAddress;
+          this._server.logger.error(
+            {
+              err,
+              tnx: "error",
+              user: this.session.user && this.session.user.username || this.session.user
+            },
+            "%s %s %s",
+            this.id,
+            this.remoteAddress,
+            err.message
+          );
+          if ((err.code === "ECONNRESET" || err.code === "EPIPE") && (!this.session.envelope || !this.session.envelope.mailFrom)) {
+            this.close();
+            return;
+          }
+          this.emit("error", err);
+        }
+        /**
+         * Fired when socket timeouts. Closes connection
+         *
+         * @event
+         */
+        _onTimeout() {
+          this.send(421, "Timeout - closing connection");
+        }
+        /**
+         * Checks if a selected command is available and invokes it
+         *
+         * @param {Buffer} command Single line of data from the client
+         * @param {Function} callback Callback to run once the command is processed
+         */
+        _onCommand(command, callback) {
+          let commandName = (command || "").toString().split(" ").shift().toUpperCase();
+          this._server.logger.debug(
+            {
+              tnx: "command",
+              cid: this.id,
+              command: commandName,
+              user: this.session.user && this.session.user.username || this.session.user
+            },
+            "C:",
+            (command || "").toString()
+          );
+          let handler;
+          callback = callback || (() => false);
+          if (this._server._closeTimeout) {
+            return this.send(421, "Server shutting down", commandName);
+          }
+          if (!this._ready) {
+            return this.send(421, this.name + " You talk too soon", commandName);
+          }
+          if (/^(OPTIONS|GET|HEAD|POST|PUT|DELETE|TRACE|CONNECT) \/.* HTTP\/\d\.\d$/i.test(command)) {
+            return this.send(421, "HTTP requests not allowed", commandName);
+          }
+          if (this._upgrading) {
+            return callback();
+          }
+          if (this._nextHandler) {
+            handler = this._nextHandler;
+            this._nextHandler = false;
+          } else {
+            switch (commandName) {
+              case "HELO":
+              case "EHLO":
+              case "LHLO":
+                this.openingCommand = commandName;
+                break;
+            }
+            if (this._server.options.lmtp) {
+              switch (commandName) {
+                case "HELO":
+                case "EHLO":
+                  this.send(500, "Error: " + commandName + " not allowed in LMTP server", false);
+                  return setImmediate(callback);
+                case "LHLO":
+                  commandName = "EHLO";
+                  break;
+              }
+            }
+            if (this._isSupported(commandName)) {
+              handler = this["handler_" + commandName];
+            }
+          }
+          if (!handler) {
+            this._unrecognizedCommands++;
+            if (this._unrecognizedCommands >= 10) {
+              return this.send(421, "Error: too many unrecognized commands", commandName);
+            }
+            this.send(500, "Error: command not recognized", commandName);
+            return setImmediate(callback);
+          }
+          if (!this.session.user && this._isSupported("AUTH") && !this._server.options.authOptional && commandName !== "AUTH" && this._maxAllowedUnauthenticatedCommands !== false) {
+            this._unauthenticatedCommands++;
+            if (this._unauthenticatedCommands >= this._maxAllowedUnauthenticatedCommands) {
+              return this.send(421, "Error: too many unauthenticated commands", commandName);
+            }
+          }
+          if (!this.hostNameAppearsAs && commandName && ["MAIL", "RCPT", "DATA", "AUTH"].includes(commandName)) {
+            this.send(503, "Error: send " + (this._server.options.lmtp ? "LHLO" : "HELO/EHLO") + " first");
+            return setImmediate(callback);
+          }
+          if (!this.session.user && this._isSupported("AUTH") && ["MAIL", "RCPT", "DATA"].includes(commandName) && !this._server.options.authOptional) {
+            this.send(
+              530,
+              typeof this._server.options.authRequiredMessage === "string" ? this._server.options.authRequiredMessage : "Error: authentication Required"
+            );
+            return setImmediate(callback);
+          }
+          handler.call(this, command, callback);
+        }
+        /**
+         * Checks that a command is available and is not listed in the disabled commands array
+         *
+         * @param {String} command Command name
+         * @returns {Boolean} Returns true if the command can be used
+         */
+        _isSupported(command) {
+          command = (command || "").toString().trim().toUpperCase();
+          return !this._server.options.disabledCommands.includes(command) && typeof this["handler_" + command] === "function";
+        }
+        /**
+         * Determines if enhanced status codes should be used
+         * @returns {Boolean} True if enhanced status codes should be included in responses
+         */
+        _useEnhancedStatusCodes() {
+          return !this._server.options.hideENHANCEDSTATUSCODES;
+        }
+        /**
+         * Gets the appropriate enhanced status code for a given SMTP response code and context
+         * @param {Number} code SMTP response code
+         * @param {String|Boolean} context Optional context for more specific status codes
+         * @returns {String} Enhanced status code or empty string if not applicable
+         */
+        _getEnhancedStatusCode(code, context) {
+          if (context === false || !this._useEnhancedStatusCodes()) {
+            return "";
+          }
+          if (code >= 300 && code < 400) {
+            return "";
+          }
+          if (context && SKIPPED_COMMANDS_FOR_ENHANCED_STATUS_CODES.has(context)) {
+            return "";
+          }
+          if (context && CONTEXTUAL_STATUS_CODES[context]) {
+            return CONTEXTUAL_STATUS_CODES[context];
+          }
+          if (ENHANCED_STATUS_CODES[code]) {
+            return ENHANCED_STATUS_CODES[code];
+          }
+          if (code >= 200 && code < 300) {
+            return "2.0.0";
+          }
+          if (code >= 400 && code < 500) {
+            return "4.0.0";
+          }
+          if (code >= 500) {
+            return "5.0.0";
+          }
+          return "";
+        }
+        /**
+         * Parses commands like MAIL FROM and RCPT TO. Returns an object with the address and optional arguments.
+         *
+         * @param {[type]} name Address type, eg 'mail from' or 'rcpt to'
+         * @param {[type]} command Data payload to parse
+         * @returns {Object|Boolean} Parsed address in the form of {address:, args: {}} or false if parsing failed
+         */
+        _parseAddressCommand(name, command) {
+          command = (command || "").toString();
+          name = (name || "").toString().trim().toUpperCase();
+          let parts = command.split(":");
+          command = parts.shift().trim().toUpperCase();
+          parts = parts.join(":").trim().split(/\s+/);
+          let address = parts.shift();
+          let args = false;
+          let invalid = false;
+          if (name !== command) {
+            return false;
+          }
+          if (!/^<[^<>]*>$/.test(address)) {
+            invalid = true;
+          } else {
+            address = address.substr(1, address.length - 2);
+          }
+          parts.forEach((part) => {
+            part = part.split("=");
+            let key = part.shift().toUpperCase();
+            let value = part.join("=") || true;
+            if (!key || key.trim() === "") {
+              return;
+            }
+            if (typeof value === "string") {
+              value = value.replace(/\+([0-9A-F]{2})/g, (match, hex) => unescape("%" + hex));
+            }
+            if (!args) {
+              args = {};
+            }
+            args[key] = value;
+          });
+          if (address) {
+            address = address.split("@");
+            if (address.length !== 2 || !address[0] || !address[1]) {
+              invalid = true;
+            } else {
+              let localPart = address[0];
+              let domain = address[1];
+              if (localPart.length + 1 + domain.length > 253) {
+                invalid = true;
+              } else {
+                if (localPart.startsWith(".") || localPart.endsWith(".") || localPart.includes("..")) {
+                  invalid = true;
+                }
+                let isIPLiteral = !invalid && domain.startsWith("[") && domain.endsWith("]");
+                if (isIPLiteral) {
+                  let ipContent = domain.slice(1, -1);
+                  let isValidIP = false;
+                  if (ipContent.toUpperCase().startsWith("IPV6:")) {
+                    let ipv6Addr = ipContent.slice(5);
+                    if (net.isIPv6(ipv6Addr)) {
+                      isValidIP = true;
+                      try {
+                        ipv6Addr = ipv6normalize(ipv6Addr);
+                        domain = "[IPv6:" + ipv6Addr + "]";
+                      } catch {
+                      }
+                    }
+                  } else {
+                    if (net.isIPv4(ipContent)) {
+                      isValidIP = true;
+                    }
+                  }
+                  if (!isValidIP) {
+                    invalid = true;
+                  }
+                  if (!invalid) {
+                    address = [localPart, "@", domain].join("");
+                  }
+                } else {
+                  if (!invalid && (domain.startsWith(".") || domain.endsWith(".") || domain.includes("..") || domain.includes(".-") || domain.includes("-.") || !/^[a-zA-Z0-9\u0080-\uFFFF.-]+$/.test(domain))) {
+                    invalid = true;
+                  }
+                  if (!invalid) {
+                    try {
+                      address = [localPart, "@", punycode2.toUnicode(domain)].join("");
+                    } catch (E) {
+                      this._server.logger.error(
+                        {
+                          tnx: "punycode",
+                          cid: this.id,
+                          user: this.session.user && this.session.user.username || this.session.user
+                        },
+                        'Failed to process punycode domain "%s". error=%s',
+                        domain,
+                        E.message
+                      );
+                      invalid = true;
+                    }
+                  }
+                }
+              }
+            }
+          }
+          return invalid ? false : {
+            address,
+            args
+          };
+        }
+        /**
+         * Resets or sets up a new session. We reuse existing session object to keep
+         * application specific data.
+         */
+        _resetSession() {
+          let session = this.session;
+          session.localAddress = this.localAddress;
+          session.localPort = this.localPort;
+          session.remoteAddress = this.remoteAddress;
+          session.remotePort = this.remotePort;
+          session.clientHostname = this.clientHostname;
+          session.openingCommand = this.openingCommand;
+          session.hostNameAppearsAs = this.hostNameAppearsAs;
+          session.xClient = this._xClient;
+          session.xForward = this._xForward;
+          session.transmissionType = this._transmissionType();
+          session.tlsOptions = this.tlsOptions;
+          session.envelope = {
+            mailFrom: false,
+            rcptTo: [],
+            /** @property {boolean} requireTLS - RFC 8689: Indicates client requires TLS for entire delivery chain */
+            requireTLS: false,
+            /** @property {string} bodyType - RFC 6152: Message body encoding type (7bit or 8bitmime) */
+            bodyType: "7bit",
+            /** @property {boolean} smtpUtf8 - RFC 6531: Indicates UTF-8 support is requested */
+            smtpUtf8: false
+          };
+          if (!this._server.options.hideDSN)
+            session.envelope.dsn = {
+              ret: null,
+              // RET parameter from MAIL FROM (FULL or HDRS)
+              envid: null
+              // ENVID parameter from MAIL FROM
+            };
+          session.transaction = this._transactionCounter + 1;
+        }
+        /**
+         * Returns current transmission type
+         *
+         * @return {String} Transmission type
+         */
+        _transmissionType() {
+          let type = this._server.options.lmtp ? "LMTP" : "SMTP";
+          if (this.openingCommand === "EHLO") {
+            type = "E" + type;
+          }
+          if (this.secure) {
+            type += "S";
+          }
+          if (this.session.user) {
+            type += "A";
+          }
+          return type;
+        }
+        emitConnection() {
+          if (!this._canEmitConnection) {
+            return;
+          }
+          this._canEmitConnection = false;
+          this.emit("connect", {
+            id: this.id,
+            localAddress: this.localAddress,
+            localPort: this.localPort,
+            remoteAddress: this.remoteAddress,
+            remotePort: this.remotePort,
+            hostNameAppearsAs: this.hostNameAppearsAs,
+            clientHostname: this.clientHostname
+          });
+        }
+        // COMMAND HANDLERS
+        /**
+         * Processes EHLO. Requires valid hostname as the single argument.
+         */
+        handler_EHLO(command, callback) {
+          let parts = command.toString().trim().split(/\s+/);
+          let hostname = parts[1] || "";
+          if (parts.length !== 2) {
+            this.send(501, "Error: syntax: " + (this._server.options.lmtp ? "LHLO" : "EHLO") + " hostname", false);
+            return callback();
+          }
+          this.hostNameAppearsAs = hostname.toLowerCase();
+          let features = ["PIPELINING", "8BITMIME", "SMTPUTF8", "ENHANCEDSTATUSCODES", "DSN"].filter((feature) => !this._server.options["hide" + feature]);
+          if (this._server.options.authMethods.length && this._isSupported("AUTH") && !this.session.user) {
+            features.push(["AUTH"].concat(this._server.options.authMethods).join(" "));
+          }
+          if (!this.secure && this._isSupported("STARTTLS") && !this._server.options.hideSTARTTLS) {
+            features.push("STARTTLS");
+          }
+          if (this.secure && !this._server.options.hideREQUIRETLS) {
+            features.push("REQUIRETLS");
+          }
+          if (this._server.options.size) {
+            features.push("SIZE" + (this._server.options.hideSize ? "" : " " + this._server.options.size));
+          }
+          if (!this._xClient.has("ADDR") && this._server.options.useXClient && this._isSupported("XCLIENT")) {
+            features.push("XCLIENT NAME ADDR PORT PROTO HELO LOGIN");
+          }
+          if (!this._xClient.has("ADDR") && this._server.options.useXForward && this._isSupported("XFORWARD")) {
+            features.push("XFORWARD NAME ADDR PORT PROTO HELO IDENT SOURCE");
+          }
+          this._resetSession();
+          let heloResponse = this._server.options.heloResponse || "%s Nice to meet you, %s";
+          let replacements = [this.name, this.clientHostname];
+          let replacementIndex = 0;
+          let formattedResponse = heloResponse.replace(/%s/g, () => replacements[replacementIndex++] || "");
+          this.send(250, [formattedResponse].concat(features || []), false);
+          callback();
+        }
+        /**
+         * Processes HELO. Requires valid hostname as the single argument.
+         */
+        handler_HELO(command, callback) {
+          let parts = command.toString().trim().split(/\s+/);
+          let hostname = parts[1] || "";
+          if (parts.length !== 2) {
+            this.send(501, "Error: Syntax: HELO hostname", false);
+            return callback();
+          }
+          this.hostNameAppearsAs = hostname.toLowerCase();
+          this._resetSession();
+          let heloResponse = this._server.options.heloResponse || "%s Nice to meet you, %s";
+          let replacements = [this.name, this.clientHostname];
+          let replacementIndex = 0;
+          let formattedResponse = heloResponse.replace(/%s/g, () => replacements[replacementIndex++] || "");
+          this.send(250, formattedResponse, false);
+          callback();
+        }
+        /**
+         * Processes QUIT. Closes the connection
+         */
+        handler_QUIT(command, callback) {
+          this.send(221, "Bye");
+          this.close();
+          callback();
+        }
+        /**
+         * Processes NOOP. Does nothing but keeps the connection alive
+         */
+        handler_NOOP(command, callback) {
+          this.send(250, "OK");
+          callback();
+        }
+        /**
+         * Processes RSET. Resets user and session info
+         */
+        handler_RSET(command, callback) {
+          this._resetSession();
+          this.send(250, "Flushed");
+          callback();
+        }
+        /**
+         * Processes HELP. Responds with url to RFC
+         */
+        handler_HELP(command, callback) {
+          this.send(214, "See https://tools.ietf.org/html/rfc5321 for details");
+          callback();
+        }
+        /**
+         * Processes VRFY. Does not verify anything
+         */
+        handler_VRFY(command, callback) {
+          this.send(252, "Try to send something. No promises though");
+          callback();
+        }
+        /**
+         * Overrides connection info
+         * http://www.postfix.org/XCLIENT_README.html
+         *
+         * TODO: add unit tests
+         */
+        handler_XCLIENT(command, callback) {
+          if (this._xClient.has("ADDR") || !this._server.options.useXClient) {
+            this.send(550, "Error: Not allowed");
+            return callback();
+          }
+          if (this.session.envelope.mailFrom) {
+            this.send(503, "Error: Mail transaction in progress");
+            return callback();
+          }
+          let allowedKeys = ["NAME", "ADDR", "PORT", "PROTO", "HELO", "LOGIN"];
+          let parts = command.toString().trim().split(/\s+/);
+          let key, value;
+          let data = /* @__PURE__ */ new Map();
+          parts.shift();
+          if (!parts.length) {
+            this.send(501, "Error: Bad command parameter syntax");
+            return callback();
+          }
+          let loginValue = false;
+          for (let i = 0, len = parts.length; i < len; i++) {
+            value = parts[i].split("=");
+            key = value.shift();
+            if (value.length !== 1 || !allowedKeys.includes(key.toUpperCase())) {
+              this.send(501, "Error: Bad command parameter syntax");
+              return callback();
+            }
+            key = key.toUpperCase();
+            value = (value[0] || "").replace(/\+([0-9A-F]{2})/g, (match, hex) => unescape("%" + hex));
+            if (["[UNAVAILABLE]", "[TEMPUNAVAIL]"].includes(value.toUpperCase())) {
+              value = false;
+            }
+            if (data.has(key)) {
+              continue;
+            }
+            data.set(key, value);
+            switch (key) {
+              // handled outside the switch
+              case "LOGIN":
+                loginValue = value;
+                break;
+              case "ADDR":
+                if (value) {
+                  value = value.replace(/^IPV6:/i, "");
+                  if (!net.isIP(value)) {
+                    this.send(501, "Error: Bad command parameter syntax. Invalid address");
+                    return callback();
+                  }
+                  if (net.isIPv6(value)) {
+                    value = ipv6normalize(value);
+                  }
+                  this._server.logger.info(
+                    {
+                      tnx: "xclient",
+                      cid: this.id,
+                      xclientKey: "ADDR",
+                      xclient: value,
+                      user: this.session.user && this.session.user.username || this.session.user
+                    },
+                    "XCLIENT from %s through %s",
+                    value,
+                    this.remoteAddress
+                  );
+                  if (!this._xClient.has("ADDR:DEFAULT")) {
+                    this._xClient.set("ADDR:DEFAULT", this.remoteAddress);
+                  }
+                  this.remoteAddress = value;
+                  this.hostNameAppearsAs = false;
+                }
+                break;
+              case "NAME":
+                value = value || "";
+                this._server.logger.info(
+                  {
+                    tnx: "xclient",
+                    cid: this.id,
+                    xclientKey: "NAME",
+                    xclient: value,
+                    user: this.session.user && this.session.user.username || this.session.user
+                  },
+                  'XCLIENT hostname resolved as "%s"',
+                  value
+                );
+                if (!this._xClient.has("NAME:DEFAULT")) {
+                  this._xClient.set("NAME:DEFAULT", this.clientHostname || "");
+                }
+                this.clientHostname = value.toLowerCase();
+                break;
+              case "PORT":
+                value = Number(value) || "";
+                this._server.logger.info(
+                  {
+                    tnx: "xclient",
+                    cid: this.id,
+                    xclientKey: "PORT",
+                    xclient: value,
+                    user: this.session.user && this.session.user.username || this.session.user
+                  },
+                  'XCLIENT remote port resolved as "%s"',
+                  value
+                );
+                if (!this._xClient.has("PORT:DEFAULT")) {
+                  this._xClient.set("PORT:DEFAULT", this.remotePort || "");
+                }
+                this.remotePort = value;
+                break;
+              default:
+            }
+            this._xClient.set(key, value);
+          }
+          let checkLogin = (done) => {
+            if (typeof loginValue !== "string") {
+              return done();
+            }
+            if (!loginValue) {
+              this._server.logger.info(
+                {
+                  tnx: "deauth",
+                  cid: this.id,
+                  user: this.session.user && this.session.user.username || this.session.user
+                },
+                "User deauthenticated using %s",
+                "XCLIENT"
+              );
+              this.session.user = false;
+              return done();
+            }
+            let method = "SASL_XCLIENT";
+            sasl[method].call(this, [loginValue], (err) => {
+              if (err) {
+                this.send(550, err.message);
+                this.close();
+                return;
+              }
+              done();
+            });
+          };
+          if (this.remoteAddress && !this.clientHostname) {
+            this.clientHostname = "[" + this.remoteAddress + "]";
+          }
+          if (data.has("ADDR")) {
+            this.emitConnection();
+          }
+          checkLogin(() => {
+            this.send(
+              220,
+              this.name + " " + (this._server.options.lmtp ? "LMTP" : "ESMTP") + (this._server.options.banner ? " " + this._server.options.banner : "")
+            );
+            callback();
+          });
+        }
+        /**
+         * Processes XFORWARD data
+         * http://www.postfix.org/XFORWARD_README.html
+         *
+         * TODO: add unit tests
+         */
+        handler_XFORWARD(command, callback) {
+          if (!this._server.options.useXForward) {
+            this.send(550, "Error: Not allowed");
+            return callback();
+          }
+          if (this.session.envelope.mailFrom) {
+            this.send(503, "Error: Mail transaction in progress");
+            return callback();
+          }
+          let allowedKeys = ["NAME", "ADDR", "PORT", "PROTO", "HELO", "IDENT", "SOURCE"];
+          let parts = command.toString().trim().split(/\s+/);
+          let key, value;
+          let data = /* @__PURE__ */ new Map();
+          let hasAddr = false;
+          parts.shift();
+          if (!parts.length) {
+            this.send(501, "Error: Bad command parameter syntax");
+            return callback();
+          }
+          for (let i = 0, len = parts.length; i < len; i++) {
+            value = parts[i].split("=");
+            key = value.shift();
+            if (value.length !== 1 || !allowedKeys.includes(key.toUpperCase())) {
+              this.send(501, "Error: Bad command parameter syntax");
+              return callback();
+            }
+            key = key.toUpperCase();
+            if (data.has(key)) {
+              continue;
+            }
+            value = (value[0] || "").replace(/\+([0-9A-F]{2})/g, (match, hex) => unescape("%" + hex));
+            if (value.toUpperCase() === "[UNAVAILABLE]") {
+              value = false;
+            }
+            data.set(key, value);
+            switch (key) {
+              case "ADDR":
+                if (value) {
+                  value = value.replace(/^IPV6:/i, "");
+                  if (!net.isIP(value)) {
+                    this.send(501, "Error: Bad command parameter syntax. Invalid address");
+                    return callback();
+                  }
+                  if (net.isIPv6(value)) {
+                    value = ipv6normalize(value);
+                  }
+                  this._server.logger.info(
+                    {
+                      tnx: "xforward",
+                      cid: this.id,
+                      xforwardKey: "ADDR",
+                      xforward: value,
+                      user: this.session.user && this.session.user.username || this.session.user
+                    },
+                    "XFORWARD from %s through %s",
+                    value,
+                    this.remoteAddress
+                  );
+                  if (!this._xClient.has("ADDR:DEFAULT")) {
+                    this._xClient.set("ADDR:DEFAULT", this.remoteAddress);
+                  }
+                  hasAddr = true;
+                  this.remoteAddress = value;
+                }
+                break;
+              case "NAME":
+                value = value || "";
+                this._server.logger.info(
+                  {
+                    tnx: "xforward",
+                    cid: this.id,
+                    xforwardKey: "NAME",
+                    xforward: value,
+                    user: this.session.user && this.session.user.username || this.session.user
+                  },
+                  'XFORWARD hostname resolved as "%s"',
+                  value
+                );
+                this.clientHostname = value.toLowerCase();
+                break;
+              case "PORT":
+                value = Number(value) || 0;
+                this._server.logger.info(
+                  {
+                    tnx: "xforward",
+                    cid: this.id,
+                    xforwardKey: "PORT",
+                    xforward: value,
+                    user: this.session.user && this.session.user.username || this.session.user
+                  },
+                  'XFORWARD port resolved as "%s"',
+                  value
+                );
+                this.remotePort = value;
+                break;
+              case "HELO":
+                value = (value || "").toString().toLowerCase();
+                this._server.logger.info(
+                  {
+                    tnx: "xforward",
+                    cid: this.id,
+                    xforwardKey: "HELO",
+                    xforward: value,
+                    user: this.session.user && this.session.user.username || this.session.user
+                  },
+                  'XFORWARD HELO name resolved as "%s"',
+                  value
+                );
+                this.hostNameAppearsAs = value;
+                break;
+              default:
+            }
+            this._xForward.set(key, value);
+          }
+          if (hasAddr) {
+            this._canEmitConnection = true;
+            this.emitConnection();
+          }
+          this.send(250, "OK");
+          callback();
+        }
+        /**
+         * Upgrades connection to TLS if possible
+         */
+        handler_STARTTLS(command, callback) {
+          if (this.secure) {
+            this.send(503, "Error: TLS already active");
+            return callback();
+          }
+          this.send(220, "Ready to start TLS");
+          this.upgrade(callback);
+        }
+        /**
+         * Check if selected authentication is available and delegate auth data to SASL
+         */
+        handler_AUTH(command, callback) {
+          let args = command.toString().trim().split(/\s+/);
+          let method;
+          let handler;
+          args.shift();
+          method = (args.shift() || "").toString().toUpperCase();
+          handler = sasl["SASL_" + method];
+          handler = handler ? handler.bind(this) : handler;
+          if (!this.secure && this._isSupported("STARTTLS") && !this._server.options.hideSTARTTLS && !this._server.options.allowInsecureAuth) {
+            this.send(538, "Error: Must issue a STARTTLS command first");
+            return callback();
+          }
+          if (this.session.user) {
+            this.send(503, "Error: No identity changes permitted");
+            return callback();
+          }
+          if (!this._server.options.authMethods.includes(method) || typeof handler !== "function") {
+            this.send(504, "Error: Unrecognized authentication type");
+            return callback();
+          }
+          handler(args, callback);
+        }
+        /**
+         * Validates MAIL FROM parameters
+         * @param {Object} parsed - Parsed address command with args
+         * @returns {Object|null} Returns error object {code, message, enhancedCode} if validation fails, null if successful
+         */
+        _validateMailParams(parsed) {
+          if (parsed.args.BODY) {
+            const bodyType = parsed.args.BODY.toLowerCase();
+            if (bodyType !== "7bit" && bodyType !== "8bitmime") {
+              return {
+                code: 501,
+                message: "Invalid BODY parameter value. Must be 7BIT or 8BITMIME",
+                enhancedCode: null
+              };
+            }
+          }
+          if (parsed.args.SMTPUTF8 !== void 0) {
+            if (parsed.args.SMTPUTF8 !== true) {
+              return {
+                code: 501,
+                message: "Invalid SMTPUTF8 parameter. This flag does not accept a value",
+                enhancedCode: null
+              };
+            }
+          }
+          if (parsed.args.REQUIRETLS !== void 0) {
+            if (!this.secure) {
+              return {
+                code: 530,
+                message: "REQUIRETLS not permitted on non-TLS connections",
+                enhancedCode: null
+              };
+            }
+            if (parsed.args.REQUIRETLS !== true) {
+              return {
+                code: 501,
+                message: "Invalid REQUIRETLS parameter. This flag does not accept a value",
+                enhancedCode: null
+              };
+            }
+          }
+          if (!this._server.options.hideDSN) {
+            if (parsed.args.RET) {
+              const ret = parsed.args.RET.toUpperCase();
+              if (ret !== "FULL" && ret !== "HDRS") {
+                return {
+                  code: 501,
+                  message: "Invalid RET parameter value. Must be FULL or HDRS",
+                  enhancedCode: null
+                };
+              }
+            }
+          }
+          return null;
+        }
+        /**
+         * Applies validated MAIL FROM parameters to session envelope
+         * @param {Object} parsed - Parsed address command with args
+         */
+        _applyMailParams(parsed) {
+          if (parsed.args.BODY) {
+            this.session.envelope.bodyType = parsed.args.BODY.toLowerCase();
+          }
+          if (parsed.args.SMTPUTF8 === true) {
+            this.session.envelope.smtpUtf8 = true;
+          }
+          if (parsed.args.REQUIRETLS === true) {
+            this.session.envelope.requireTLS = true;
+          }
+          if (!this._server.options.hideDSN) {
+            if (parsed.args.RET) {
+              this.session.envelope.dsn.ret = parsed.args.RET.toUpperCase();
+            }
+            if (parsed.args.ENVID) {
+              this.session.envelope.dsn.envid = parsed.args.ENVID;
+            }
+          }
+        }
+        /**
+         * Processes MAIL FROM command, parses address and extra arguments
+         */
+        handler_MAIL(command, callback) {
+          let parsed = this._parseAddressCommand("mail from", command);
+          this.emitConnection();
+          if (!parsed) {
+            this.send(501, "Error: Bad sender address syntax", "MAILBOX_SYNTAX_ERROR");
+            return callback();
+          }
+          if (this.session.envelope.mailFrom) {
+            this.send(503, "Error: nested MAIL command");
+            return callback();
+          }
+          if (!this._server.options.hideSize && this._server.options.size && parsed.args.SIZE && Number(parsed.args.SIZE) > this._server.options.size) {
+            this.send(552, "Error: message exceeds fixed maximum message size " + this._server.options.size, "SYSTEM_FULL");
+            return callback();
+          }
+          const validationError = this._validateMailParams(parsed);
+          if (validationError) {
+            this.send(validationError.code, validationError.message, validationError.enhancedCode);
+            return callback();
+          }
+          this._applyMailParams(parsed);
+          this._server.onMailFrom(parsed, this.session, (err) => {
+            if (err) {
+              this.send(err.responseCode || 550, err.message);
+              return callback();
+            }
+            this.session.envelope.mailFrom = parsed;
+            this.send(250, "Accepted", "MAIL_FROM_OK");
+            callback();
+          });
+        }
+        /**
+         * Processes RCPT TO command, parses address and extra arguments
+         */
+        handler_RCPT(command, callback) {
+          let parsed = this._parseAddressCommand("rcpt to", command);
+          if (!parsed || !parsed.address) {
+            this.send(501, "Error: Bad recipient address syntax", "MAILBOX_SYNTAX_ERROR");
+            return callback();
+          }
+          if (!this.session.envelope.mailFrom) {
+            this.send(503, "Error: need MAIL command");
+            return callback();
+          }
+          if (!this._server.options.hideDSN) {
+            if (parsed.args.NOTIFY) {
+              const notify = parsed.args.NOTIFY.toUpperCase();
+              const validNotifyValues = ["NEVER", "SUCCESS", "FAILURE", "DELAY"];
+              const notifyValues = notify.split(",");
+              for (let value of notifyValues) {
+                if (!validNotifyValues.includes(value)) {
+                  this.send(501, "Error: NOTIFY parameter must be NEVER, SUCCESS, FAILURE, or DELAY");
+                  return callback();
+                }
+              }
+              if (notifyValues.includes("NEVER") && notifyValues.length > 1) {
+                this.send(501, "Error: NOTIFY=NEVER cannot be combined with other values");
+                return callback();
+              }
+              parsed.dsn = parsed.dsn || {};
+              parsed.dsn.notify = notifyValues;
+            }
+            if (parsed.args.ORCPT) {
+              parsed.dsn = parsed.dsn || {};
+              parsed.dsn.orcpt = parsed.args.ORCPT;
+            }
+          }
+          this._server.onRcptTo(parsed, this.session, (err) => {
+            if (err) {
+              this.send(err.responseCode || 550, err.message);
+              return callback();
+            }
+            for (let i = 0, len = this.session.envelope.rcptTo.length; i < len; i++) {
+              if (this.session.envelope.rcptTo[i].address.toLowerCase() === parsed.address.toLowerCase()) {
+                this.session.envelope.rcptTo[i] = parsed;
+                parsed = false;
+                break;
+              }
+            }
+            if (parsed) {
+              this.session.envelope.rcptTo.push(parsed);
+            }
+            this.send(250, "Accepted", "RCPT_TO_OK");
+            callback();
+          });
+        }
+        /**
+         * Processes DATA by forwarding incoming stream to the onData handler
+         */
+        handler_DATA(command, callback) {
+          if (!this.session.envelope.rcptTo.length) {
+            this.send(503, "Error: need RCPT command");
+            return callback();
+          }
+          if (!this._parser) {
+            return callback();
+          }
+          this._dataStream = this._parser.startDataMode(this._server.options.size);
+          let close = (err, message) => {
+            let i, len;
+            this._server.logger.debug(
+              {
+                tnx: "data",
+                cid: this.id,
+                bytes: this._parser.dataBytes,
+                user: this.session.user && this.session.user.username || this.session.user
+              },
+              "C: <%s bytes of DATA>",
+              this._parser.dataBytes
+            );
+            if (typeof this._dataStream === "object" && this._dataStream && this._dataStream.readable) {
+              this._dataStream.removeAllListeners();
+            }
+            if (err) {
+              if (this._server.options.lmtp) {
+                for (i = 0, len = this.session.envelope.rcptTo.length; i < len; i++) {
+                  this.send(err.responseCode || 450, err.message);
+                }
+              } else {
+                this.send(err.responseCode || 450, err.message);
+              }
+            } else if (Array.isArray(message)) {
+              message.forEach((response) => {
+                if (/Error\]$/i.test(Object.prototype.toString.call(response))) {
+                  this.send(response.responseCode || 450, response.message);
+                } else {
+                  this.send(250, typeof response === "string" ? response : "OK: message accepted", "DATA_OK");
+                }
+              });
+            } else if (this._server.options.lmtp) {
+              for (i = 0, len = this.session.envelope.rcptTo.length; i < len; i++) {
+                this.send(250, typeof message === "string" ? message : "OK: message accepted", "DATA_OK");
+              }
+            } else {
+              this.send(250, typeof message === "string" ? message : "OK: message queued", "DATA_OK");
+            }
+            this._transactionCounter++;
+            this._unrecognizedCommands = 0;
+            this._resetSession();
+            if (typeof this._parser === "object" && this._parser) {
+              this._parser.continue();
+            }
+          };
+          this._server.onData(this._dataStream, this.session, (err, message) => {
+            if (typeof this._dataStream === "object" && this._dataStream && this._dataStream.readable) {
+              this._dataStream.on("end", () => close(err, message));
+              return;
+            }
+            close(err, message);
+          });
+          this.send(354, "End data with <CR><LF>.<CR><LF>");
+          callback();
+        }
+        // Dummy handlers for some old sendmail specific commands
+        /**
+         * Processes sendmail WIZ command, upgrades to "wizard mode"
+         */
+        handler_WIZ(command, callback) {
+          let args = command.toString().trim().split(/\s+/);
+          let password;
+          args.shift();
+          password = (args.shift() || "").toString();
+          if (!password) {
+            this.send(500, "You are no wizard!");
+            return callback();
+          }
+          this.session.isWizard = true;
+          this.send(200, "Please pass, oh mighty wizard");
+          callback();
+        }
+        /**
+         * Processes sendmail SHELL command, should return interactive shell but this is a dummy function
+         * so no actual shell is provided to the client
+         */
+        handler_SHELL(command, callback) {
+          this._server.logger.info(
+            {
+              tnx: "shell",
+              cid: this.id,
+              user: this.session.user && this.session.user.username || this.session.user
+            },
+            "Client tried to invoke SHELL"
+          );
+          if (!this.session.isWizard) {
+            this.send(500, "Mere mortals must not mutter that mantra");
+            return callback();
+          }
+          this.send(500, "Error: Invoking shell is not allowed. This incident will be reported.");
+          callback();
+        }
+        /**
+         * Processes sendmail KILL command
+         */
+        handler_KILL(command, callback) {
+          this._server.logger.info(
+            {
+              tnx: "kill",
+              cid: this.id,
+              user: this.session.user && this.session.user.username || this.session.user
+            },
+            "Client tried to invoke KILL"
+          );
+          this.send(500, "Can not kill Mom");
+          callback();
+        }
+        upgrade(callback, secureCallback) {
+          this._socket.unpipe(this._parser);
+          this._upgrading = true;
+          setImmediate(callback);
+          let secureSocket;
+          let onError = (err) => {
+            const meta = {};
+            if (secureSocket) {
+              meta.tlsProtocol = secureSocket.getProtocol();
+            }
+            meta.protocol = "smtp";
+            meta.stage = "connect";
+            if (err) {
+              err.meta = meta;
+            }
+            if (err && /SSL[23]*_GET_CLIENT_HELLO|ssl[23]*_read_bytes|ssl_bytes_to_cipher_list/i.test(err.message)) {
+              let message = err.message;
+              err.message = "Failed to establish TLS session";
+              err.responseCode = 500;
+              err.code = err.code || "TLSError";
+              meta.message = message;
+            }
+            if (!err || !err.message) {
+              err = new Error("Socket closed while initiating TLS");
+              err.responseCode = 500;
+              err.code = "SocketError";
+              err.report = false;
+              err.meta = meta;
+            }
+            this._onError(err);
+          };
+          let secureContext = this._server.secureContext.get("*");
+          let socketOptions = {
+            secureContext,
+            isServer: true,
+            server: this._server.server,
+            SNICallback: this._server.options.SNICallback
+          };
+          ["requestCert", "rejectUnauthorized", "NPNProtocols", "SNICallback", "session", "requestOCSP"].forEach((key) => {
+            if (key in this._server.options) {
+              socketOptions[key] = this._server.options[key];
+            }
+          });
+          this._socket.removeAllListeners();
+          this._socket.on("error", (err) => this._onError(err));
+          secureSocket = new tls.TLSSocket(this._socket, socketOptions);
+          secureSocket.once("close", (hadError) => this._onCloseEvent(hadError));
+          secureSocket.once("error", (err) => onError(err));
+          secureSocket.once("_tlsError", (err) => onError(err));
+          secureSocket.once("clientError", (err) => onError(err));
+          secureSocket.setTimeout(this._server.options.socketTimeout || SOCKET_TIMEOUT, () => this._onTimeout());
+          secureSocket.on("secure", () => {
+            this.session.secure = this.secure = true;
+            this._socket = secureSocket;
+            this._upgrading = false;
+            this.session.tlsOptions = this.tlsOptions = this._socket.getCipher();
+            this.session.servername = this._socket.servername;
+            let cipher = this.session.tlsOptions && this.session.tlsOptions.name;
+            this._server.logger.info(
+              {
+                tnx: "starttls",
+                cid: this.id,
+                user: this.session.user && this.session.user.username || this.session.user,
+                cipher
+              },
+              "Connection upgraded to TLS using",
+              cipher || "N/A"
+            );
+            this._server.onSecure(this._socket, this.session, (err) => {
+              if (err) {
+                return this._onError(err);
+              }
+              this._socket.pipe(this._parser);
+              if (typeof secureCallback === "function") {
+                secureCallback();
+              }
+            });
+          });
+        }
+      };
+      module.exports.SMTPConnection = SMTPConnection;
+    }
+  });
+
+  // node_modules/smtp-server/lib/tls-options.js
+  var require_tls_options = __commonJS({
+    "node_modules/smtp-server/lib/tls-options.js"(exports, module) {
+      "use strict";
+      var crypto = __require("crypto");
+      module.exports = getTLSOptions;
+      var tlsDefaults = {
+        // pregenerated default certificates for localhost
+        // obviusly, do not use in production
+        key: "-----BEGIN RSA PRIVATE KEY-----\nMIIEpAIBAAKCAQEA6Z5Qqhw+oWfhtEiMHE32Ht94mwTBpAfjt3vPpX8M7DMCTwHs\n1xcXvQ4lQ3rwreDTOWdoJeEEy7gMxXqH0jw0WfBx+8IIJU69xstOyT7FRFDvA1yT\nRXY2yt9K5s6SKken/ebMfmZR+03ND4UFsDzkz0FfgcjrkXmrMF5Eh5UXX/+9YHeU\nxlp0gMAt+/SumSmgCaysxZLjLpd4uXz+X+JVxsk1ACg1NoEO7lWJC/3WBP7MIcu2\nwVsMd2XegLT0gWYfT1/jsIH64U/mS/SVXC9QhxMl9Yfko2kx1OiYhDxhHs75RJZh\nrNRxgfiwgSb50Gw4NAQaDIxr/DJPdLhgnpY6UQIDAQABAoIBAE+tfzWFjJbgJ0ql\ns6Ozs020Sh4U8TZQuonJ4HhBbNbiTtdDgNObPK1uNadeNtgW5fOeIRdKN6iDjVeN\nAuXhQrmqGDYVZ1HSGUfD74sTrZQvRlWPLWtzdhybK6Css41YAyPFo9k4bJ2ZW2b/\np4EEQ8WsNja9oBpttMU6YYUchGxo1gujN8hmfDdXUQx3k5Xwx4KA68dveJ8GasIt\nd+0Jd/FVwCyyx8HTiF1FF8QZYQeAXxbXJgLBuCsMQJghlcpBEzWkscBR3Ap1U0Zi\n4oat8wrPZGCblaA6rNkRUVbc/+Vw0stnuJ/BLHbPxyBs6w495yBSjBqUWZMvljNz\nm9/aK0ECgYEA9oVIVAd0enjSVIyAZNbw11ElidzdtBkeIJdsxqhmXzeIFZbB39Gd\nbjtAVclVbq5mLsI1j22ER2rHA4Ygkn6vlLghK3ZMPxZa57oJtmL3oP0RvOjE4zRV\ndzKexNGo9gU/x9SQbuyOmuauvAYhXZxeLpv+lEfsZTqqrvPUGeBiEQcCgYEA8poG\nWVnykWuTmCe0bMmvYDsWpAEiZnFLDaKcSbz3O7RMGbPy1cypmqSinIYUpURBT/WY\nwVPAGtjkuTXtd1Cy58m7PqziB7NNWMcsMGj+lWrTPZ6hCHIBcAImKEPpd+Y9vGJX\noatFJguqAGOz7rigBq6iPfeQOCWpmprNAuah++cCgYB1gcybOT59TnA7mwlsh8Qf\nbm+tSllnin2A3Y0dGJJLmsXEPKtHS7x2Gcot2h1d98V/TlWHe5WNEUmx1VJbYgXB\npw8wj2ACxl4ojNYqWPxegaLd4DpRbtW6Tqe9e47FTnU7hIggR6QmFAWAXI+09l8y\namssNShqjE9lu5YDi6BTKwKBgQCuIlKGViLfsKjrYSyHnajNWPxiUhIgGBf4PI0T\n/Jg1ea/aDykxv0rKHnw9/5vYGIsM2st/kR7l5mMecg/2Qa145HsLfMptHo1ZOPWF\n9gcuttPTegY6aqKPhGthIYX2MwSDMM+X0ri6m0q2JtqjclAjG7yG4CjbtGTt/UlE\nWMlSZwKBgQDslGeLUnkW0bsV5EG3AKRUyPKz/6DVNuxaIRRhOeWVKV101claqXAT\nwXOpdKrvkjZbT4AzcNrlGtRl3l7dEVXTu+dN7/ZieJRu7zaStlAQZkIyP9O3DdQ3\nrIcetQpfrJ1cAqz6Ng0pD0mh77vQ13WG1BBmDFa2A9BuzLoBituf4g==\n-----END RSA PRIVATE KEY-----",
+        cert: "-----BEGIN CERTIFICATE-----\nMIICpDCCAYwCCQCuVLVKVTXnAjANBgkqhkiG9w0BAQsFADAUMRIwEAYDVQQDEwls\nb2NhbGhvc3QwHhcNMTUwMjEyMTEzMjU4WhcNMjUwMjA5MTEzMjU4WjAUMRIwEAYD\nVQQDEwlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDp\nnlCqHD6hZ+G0SIwcTfYe33ibBMGkB+O3e8+lfwzsMwJPAezXFxe9DiVDevCt4NM5\nZ2gl4QTLuAzFeofSPDRZ8HH7wgglTr3Gy07JPsVEUO8DXJNFdjbK30rmzpIqR6f9\n5sx+ZlH7Tc0PhQWwPOTPQV+ByOuReaswXkSHlRdf/71gd5TGWnSAwC379K6ZKaAJ\nrKzFkuMul3i5fP5f4lXGyTUAKDU2gQ7uVYkL/dYE/swhy7bBWwx3Zd6AtPSBZh9P\nX+OwgfrhT+ZL9JVcL1CHEyX1h+SjaTHU6JiEPGEezvlElmGs1HGB+LCBJvnQbDg0\nBBoMjGv8Mk90uGCeljpRAgMBAAEwDQYJKoZIhvcNAQELBQADggEBABXm8GPdY0sc\nmMUFlgDqFzcevjdGDce0QfboR+M7WDdm512Jz2SbRTgZD/4na42ThODOZz9z1AcM\nzLgx2ZNZzVhBz0odCU4JVhOCEks/OzSyKeGwjIb4JAY7dh+Kju1+6MNfQJ4r1Hza\nSVXH0+JlpJDaJ73NQ2JyfqELmJ1mTcptkA/N6rQWhlzycTBSlfogwf9xawgVPATP\n4AuwgjHl12JI2HVVs1gu65Y3slvaHRCr0B4+Kg1GYNLLcbFcK+NEHrHmPxy9TnTh\nZwp1dsNQU+Xkylz8IUANWSLHYZOMtN2e5SKIdwTtl5C8YxveuY8YKb1gDExnMraT\nVGXQDqPleug=\n-----END CERTIFICATE-----",
+        honorCipherOrder: true,
+        requestOCSP: false,
+        sessionIdContext: crypto.createHash("sha1").update(process.argv.join(" ")).digest("hex").slice(0, 32),
+        minVersion: "TLSv1"
+        // sadly there are very old SMTP clients out there
+      };
+      function getTLSOptions(opts) {
+        return Object.assign({}, tlsDefaults, opts || {});
+      }
+    }
+  });
+
+  // node_modules/nodemailer/lib/fetch/cookies.js
+  var require_cookies = __commonJS({
+    "node_modules/nodemailer/lib/fetch/cookies.js"(exports, module) {
+      "use strict";
+      var urllib = __require("url");
+      var SESSION_TIMEOUT = 1800;
+      var Cookies = class {
+        constructor(options) {
+          this.options = options || {};
+          this.cookies = [];
+        }
+        /**
+         * Stores a cookie string to the cookie storage
+         *
+         * @param {String} cookieStr Value from the 'Set-Cookie:' header
+         * @param {String} url Current URL
+         */
+        set(cookieStr, url) {
+          const urlparts = urllib.parse(url || "");
+          const cookie = this.parse(cookieStr);
+          let domain;
+          if (cookie.domain) {
+            domain = cookie.domain.replace(/^\./, "");
+            if (
+              // can't be valid if the requested domain is shorter than current hostname
+              urlparts.hostname.length < domain.length || // prefix domains with dot to be sure that partial matches are not used
+              ("." + urlparts.hostname).substr(-domain.length + 1) !== "." + domain
+            ) {
+              cookie.domain = urlparts.hostname;
+            }
+          } else {
+            cookie.domain = urlparts.hostname;
+          }
+          if (!cookie.path) {
+            cookie.path = this.getPath(urlparts.pathname);
+          }
+          if (!cookie.expires) {
+            cookie.expires = new Date(Date.now() + (Number(this.options.sessionTimeout || SESSION_TIMEOUT) || SESSION_TIMEOUT) * 1e3);
+          }
+          return this.add(cookie);
+        }
+        /**
+         * Returns cookie string for the 'Cookie:' header.
+         *
+         * @param {String} url URL to check for
+         * @returns {String} Cookie header or empty string if no matches were found
+         */
+        get(url) {
+          return this.list(url).map((cookie) => cookie.name + "=" + cookie.value).join("; ");
+        }
+        /**
+         * Lists all valied cookie objects for the specified URL
+         *
+         * @param {String} url URL to check for
+         * @returns {Array} An array of cookie objects
+         */
+        list(url) {
+          const result = [];
+          for (let i = this.cookies.length - 1; i >= 0; i--) {
+            const cookie = this.cookies[i];
+            if (this.isExpired(cookie)) {
+              this.cookies.splice(i, 1);
+              continue;
+            }
+            if (this.match(cookie, url)) {
+              result.unshift(cookie);
+            }
+          }
+          return result;
+        }
+        /**
+         * Parses cookie string from the 'Set-Cookie:' header
+         *
+         * @param {String} cookieStr String from the 'Set-Cookie:' header
+         * @returns {Object} Cookie object
+         */
+        parse(cookieStr) {
+          const cookie = {};
+          (cookieStr || "").toString().split(";").forEach((cookiePart) => {
+            const valueParts = cookiePart.split("=");
+            const key = valueParts.shift().trim().toLowerCase();
+            let value = valueParts.join("=").trim();
+            let domain;
+            if (!key) {
+              return;
+            }
+            switch (key) {
+              case "expires":
+                value = new Date(value);
+                if (value.toString() !== "Invalid Date") {
+                  cookie.expires = value;
+                }
+                break;
+              case "path":
+                cookie.path = value;
+                break;
+              case "domain":
+                domain = value.toLowerCase();
+                if (domain.length && domain.charAt(0) !== ".") {
+                  domain = "." + domain;
+                }
+                cookie.domain = domain;
+                break;
+              case "max-age":
+                cookie.expires = new Date(Date.now() + (Number(value) || 0) * 1e3);
+                break;
+              case "secure":
+                cookie.secure = true;
+                break;
+              case "httponly":
+                cookie.httponly = true;
+                break;
+              default:
+                if (!cookie.name) {
+                  cookie.name = key;
+                  cookie.value = value;
+                }
+            }
+          });
+          return cookie;
+        }
+        /**
+         * Checks if a cookie object is valid for a specified URL
+         *
+         * @param {Object} cookie Cookie object
+         * @param {String} url URL to check for
+         * @returns {Boolean} true if cookie is valid for specifiec URL
+         */
+        match(cookie, url) {
+          const urlparts = urllib.parse(url || "");
+          if (urlparts.hostname !== cookie.domain && (cookie.domain.charAt(0) !== "." || ("." + urlparts.hostname).substr(-cookie.domain.length) !== cookie.domain)) {
+            return false;
+          }
+          const path = this.getPath(urlparts.pathname);
+          if (path.substr(0, cookie.path.length) !== cookie.path) {
+            return false;
+          }
+          if (cookie.secure && urlparts.protocol !== "https:") {
+            return false;
+          }
+          return true;
+        }
+        /**
+         * Adds (or updates/removes if needed) a cookie object to the cookie storage
+         *
+         * @param {Object} cookie Cookie value to be stored
+         */
+        add(cookie) {
+          if (!cookie || !cookie.name) {
+            return false;
+          }
+          for (let i = 0, len = this.cookies.length; i < len; i++) {
+            if (this.compare(this.cookies[i], cookie)) {
+              if (this.isExpired(cookie)) {
+                this.cookies.splice(i, 1);
+                return false;
+              }
+              this.cookies[i] = cookie;
+              return true;
+            }
+          }
+          if (!this.isExpired(cookie)) {
+            this.cookies.push(cookie);
+          }
+          return true;
+        }
+        /**
+         * Checks if two cookie objects are the same
+         *
+         * @param {Object} a Cookie to check against
+         * @param {Object} b Cookie to check against
+         * @returns {Boolean} True, if the cookies are the same
+         */
+        compare(a, b) {
+          return a.name === b.name && a.path === b.path && a.domain === b.domain && a.secure === b.secure && a.httponly === b.httponly;
+        }
+        /**
+         * Checks if a cookie is expired
+         *
+         * @param {Object} cookie Cookie object to check against
+         * @returns {Boolean} True, if the cookie is expired
+         */
+        isExpired(cookie) {
+          return cookie.expires && cookie.expires < /* @__PURE__ */ new Date() || !cookie.value;
+        }
+        /**
+         * Returns normalized cookie path for an URL path argument
+         *
+         * @param {String} pathname
+         * @returns {String} Normalized path
+         */
+        getPath(pathname) {
+          let path = (pathname || "/").split("/");
+          path.pop();
+          path = path.join("/").trim();
+          if (path.charAt(0) !== "/") {
+            path = "/" + path;
+          }
+          if (path.substr(-1) !== "/") {
+            path += "/";
+          }
+          return path;
+        }
+      };
+      module.exports = Cookies;
+    }
+  });
+
+  // node_modules/nodemailer/package.json
+  var require_package = __commonJS({
+    "node_modules/nodemailer/package.json"(exports, module) {
+      module.exports = {
+        name: "nodemailer",
+        version: "8.0.5",
+        description: "Easy as cake e-mail sending from your Node.js applications",
+        main: "lib/nodemailer.js",
+        scripts: {
+          test: "node --test --test-concurrency=1 test/**/*.test.js test/**/*-test.js",
+          "test:coverage": "c8 node --test --test-concurrency=1 test/**/*.test.js test/**/*-test.js",
+          format: 'prettier --write "**/*.{js,json,md}"',
+          "format:check": 'prettier --check "**/*.{js,json,md}"',
+          lint: "eslint .",
+          "lint:fix": "eslint . --fix",
+          update: "rm -rf node_modules/ package-lock.json && ncu -u && npm install",
+          "test:syntax": 'docker run --rm -v "$PWD:/app:ro" -w /app node:6-alpine node test/syntax-compat.js'
+        },
+        repository: {
+          type: "git",
+          url: "https://github.com/nodemailer/nodemailer.git"
+        },
+        keywords: [
+          "Nodemailer"
+        ],
+        author: "Andris Reinman",
+        license: "MIT-0",
+        bugs: {
+          url: "https://github.com/nodemailer/nodemailer/issues"
+        },
+        homepage: "https://nodemailer.com/",
+        devDependencies: {
+          "@aws-sdk/client-sesv2": "3.1025.0",
+          bunyan: "1.8.15",
+          c8: "11.0.0",
+          eslint: "10.2.0",
+          "eslint-config-prettier": "10.1.8",
+          globals: "17.4.0",
+          libbase64: "1.3.0",
+          libmime: "5.3.7",
+          libqp: "2.1.1",
+          "nodemailer-ntlm-auth": "1.0.4",
+          prettier: "3.8.1",
+          proxy: "1.0.2",
+          "proxy-test-server": "1.0.0",
+          "smtp-server": "3.18.3"
+        },
+        engines: {
+          node: ">=6.0.0"
+        }
+      };
+    }
+  });
+
+  // node_modules/nodemailer/lib/errors.js
+  var require_errors = __commonJS({
+    "node_modules/nodemailer/lib/errors.js"(exports, module) {
+      "use strict";
+      var ERROR_CODES = {
+        // Connection errors
+        ECONNECTION: "Connection closed unexpectedly",
+        ETIMEDOUT: "Connection or operation timed out",
+        ESOCKET: "Socket-level error",
+        EDNS: "DNS resolution failed",
+        // TLS/Security errors
+        ETLS: "TLS handshake or STARTTLS failed",
+        EREQUIRETLS: "REQUIRETLS not supported by server (RFC 8689)",
+        // Protocol errors
+        EPROTOCOL: "Invalid SMTP server response",
+        EENVELOPE: "Invalid mail envelope (sender or recipients)",
+        EMESSAGE: "Message delivery error",
+        ESTREAM: "Stream processing error",
+        // Authentication errors
+        EAUTH: "Authentication failed",
+        ENOAUTH: "Authentication credentials not provided",
+        EOAUTH2: "OAuth2 token generation or refresh error",
+        // Resource errors
+        EMAXLIMIT: "Pool resource limit reached (max messages per connection)",
+        // Transport-specific errors
+        ESENDMAIL: "Sendmail command error",
+        ESES: "AWS SES transport error",
+        // Configuration and access errors
+        ECONFIG: "Invalid configuration",
+        EPROXY: "Proxy connection error",
+        EFILEACCESS: "File access rejected (disableFileAccess is set)",
+        EURLACCESS: "URL access rejected (disableUrlAccess is set)",
+        EFETCH: "HTTP fetch error"
+      };
+      module.exports = { ERROR_CODES };
+      for (const code of Object.keys(ERROR_CODES)) {
+        module.exports[code] = code;
+      }
+    }
+  });
+
+  // node_modules/nodemailer/lib/fetch/index.js
+  var require_fetch = __commonJS({
+    "node_modules/nodemailer/lib/fetch/index.js"(exports, module) {
+      "use strict";
+      var http = __require("http");
+      var https = __require("https");
+      var urllib = __require("url");
+      var zlib = __require("zlib");
+      var { PassThrough } = __require("stream");
+      var Cookies = require_cookies();
+      var packageData = require_package();
+      var net = __require("net");
+      var errors2 = require_errors();
+      var MAX_REDIRECTS = 5;
+      module.exports = function(url, options) {
+        return nmfetch(url, options);
+      };
+      module.exports.Cookies = Cookies;
+      function nmfetch(url, options) {
+        options = options || {};
+        options.fetchRes = options.fetchRes || new PassThrough();
+        options.cookies = options.cookies || new Cookies();
+        options.redirects = options.redirects || 0;
+        options.maxRedirects = isNaN(options.maxRedirects) ? MAX_REDIRECTS : options.maxRedirects;
+        if (options.cookie) {
+          [].concat(options.cookie || []).forEach((cookie) => {
+            options.cookies.set(cookie, url);
+          });
+          options.cookie = false;
+        }
+        const fetchRes = options.fetchRes;
+        const parsed = urllib.parse(url);
+        let method = (options.method || "").toString().trim().toUpperCase() || "GET";
+        let finished = false;
+        let cookies;
+        let body;
+        const handler = parsed.protocol === "https:" ? https : http;
+        const headers = {
+          "accept-encoding": "gzip,deflate",
+          "user-agent": "nodemailer/" + packageData.version
+        };
+        Object.keys(options.headers || {}).forEach((key) => {
+          headers[key.toLowerCase().trim()] = options.headers[key];
+        });
+        if (options.userAgent) {
+          headers["user-agent"] = options.userAgent;
+        }
+        if (parsed.auth) {
+          headers.Authorization = "Basic " + Buffer.from(parsed.auth).toString("base64");
+        }
+        if (cookies = options.cookies.get(url)) {
+          headers.cookie = cookies;
+        }
+        if (options.body) {
+          if (options.contentType !== false) {
+            headers["Content-Type"] = options.contentType || "application/x-www-form-urlencoded";
+          }
+          if (typeof options.body.pipe === "function") {
+            headers["Transfer-Encoding"] = "chunked";
+            body = options.body;
+            body.on("error", (err) => {
+              if (finished) {
+                return;
+              }
+              finished = true;
+              err.code = errors2.EFETCH;
+              err.sourceUrl = url;
+              fetchRes.emit("error", err);
+            });
+          } else {
+            if (options.body instanceof Buffer) {
+              body = options.body;
+            } else if (typeof options.body === "object") {
+              try {
+                body = Buffer.from(
+                  Object.keys(options.body).map((key) => {
+                    const value = options.body[key].toString().trim();
+                    return encodeURIComponent(key) + "=" + encodeURIComponent(value);
+                  }).join("&")
+                );
+              } catch (E) {
+                if (finished) {
+                  return;
+                }
+                finished = true;
+                E.code = errors2.EFETCH;
+                E.sourceUrl = url;
+                fetchRes.emit("error", E);
+                return;
+              }
+            } else {
+              body = Buffer.from(options.body.toString().trim());
+            }
+            headers["Content-Type"] = options.contentType || "application/x-www-form-urlencoded";
+            headers["Content-Length"] = body.length;
+          }
+          method = (options.method || "").toString().trim().toUpperCase() || "POST";
+        }
+        let req;
+        const reqOptions = {
+          method,
+          host: parsed.hostname,
+          path: parsed.path,
+          port: parsed.port ? parsed.port : parsed.protocol === "https:" ? 443 : 80,
+          headers,
+          rejectUnauthorized: false,
+          agent: false
+        };
+        if (options.tls) {
+          Object.assign(reqOptions, options.tls);
+        }
+        if (parsed.protocol === "https:" && parsed.hostname && parsed.hostname !== reqOptions.host && !net.isIP(parsed.hostname) && !reqOptions.servername) {
+          reqOptions.servername = parsed.hostname;
+        }
+        try {
+          req = handler.request(reqOptions);
+        } catch (E) {
+          finished = true;
+          setImmediate(() => {
+            E.code = errors2.EFETCH;
+            E.sourceUrl = url;
+            fetchRes.emit("error", E);
+          });
+          return fetchRes;
+        }
+        if (options.timeout) {
+          req.setTimeout(options.timeout, () => {
+            if (finished) {
+              return;
+            }
+            finished = true;
+            req.abort();
+            const err = new Error("Request Timeout");
+            err.code = errors2.EFETCH;
+            err.sourceUrl = url;
+            fetchRes.emit("error", err);
+          });
+        }
+        req.on("error", (err) => {
+          if (finished) {
+            return;
+          }
+          finished = true;
+          err.code = errors2.EFETCH;
+          err.sourceUrl = url;
+          fetchRes.emit("error", err);
+        });
+        req.on("response", (res) => {
+          let inflate;
+          if (finished) {
+            return;
+          }
+          switch (res.headers["content-encoding"]) {
+            case "gzip":
+            case "deflate":
+              inflate = zlib.createUnzip();
+              break;
+          }
+          if (res.headers["set-cookie"]) {
+            [].concat(res.headers["set-cookie"] || []).forEach((cookie) => {
+              options.cookies.set(cookie, url);
+            });
+          }
+          if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.headers.location) {
+            options.redirects++;
+            if (options.redirects > options.maxRedirects) {
+              finished = true;
+              const err = new Error("Maximum redirect count exceeded");
+              err.code = errors2.EFETCH;
+              err.sourceUrl = url;
+              fetchRes.emit("error", err);
+              req.abort();
+              return;
+            }
+            options.method = "GET";
+            options.body = false;
+            return nmfetch(urllib.resolve(url, res.headers.location), options);
+          }
+          fetchRes.statusCode = res.statusCode;
+          fetchRes.headers = res.headers;
+          if (res.statusCode >= 300 && !options.allowErrorResponse) {
+            finished = true;
+            const err = new Error("Invalid status code " + res.statusCode);
+            err.code = errors2.EFETCH;
+            err.sourceUrl = url;
+            fetchRes.emit("error", err);
+            req.abort();
+            return;
+          }
+          res.on("error", (err) => {
+            if (finished) {
+              return;
+            }
+            finished = true;
+            err.code = errors2.EFETCH;
+            err.sourceUrl = url;
+            fetchRes.emit("error", err);
+            req.abort();
+          });
+          if (inflate) {
+            res.pipe(inflate).pipe(fetchRes);
+            inflate.on("error", (err) => {
+              if (finished) {
+                return;
+              }
+              finished = true;
+              err.code = errors2.EFETCH;
+              err.sourceUrl = url;
+              fetchRes.emit("error", err);
+              req.abort();
+            });
+          } else {
+            res.pipe(fetchRes);
+          }
+        });
+        setImmediate(() => {
+          if (body) {
+            try {
+              if (typeof body.pipe === "function") {
+                return body.pipe(req);
+              }
+              req.write(body);
+            } catch (err) {
+              finished = true;
+              err.code = errors2.EFETCH;
+              err.sourceUrl = url;
+              fetchRes.emit("error", err);
+              return;
+            }
+          }
+          req.end();
+        });
+        return fetchRes;
+      }
+    }
+  });
+
+  // node_modules/nodemailer/lib/shared/index.js
+  var require_shared = __commonJS({
+    "node_modules/nodemailer/lib/shared/index.js"(exports, module) {
+      "use strict";
+      var urllib = __require("url");
+      var util = __require("util");
+      var fs = __require("fs");
+      var nmfetch = require_fetch();
+      var dns = __require("dns");
+      var net = __require("net");
+      var os = __require("os");
+      var DNS_TTL = 5 * 60 * 1e3;
+      var CACHE_CLEANUP_INTERVAL = 30 * 1e3;
+      var MAX_CACHE_SIZE = 1e3;
+      var lastCacheCleanup = 0;
+      module.exports._lastCacheCleanup = () => lastCacheCleanup;
+      module.exports._resetCacheCleanup = () => {
+        lastCacheCleanup = 0;
+      };
+      var networkInterfaces;
+      try {
+        networkInterfaces = os.networkInterfaces();
+      } catch (_err) {
+      }
+      module.exports.networkInterfaces = networkInterfaces;
+      var isFamilySupported = (family, allowInternal) => {
+        const ifaces = module.exports.networkInterfaces;
+        if (!ifaces) {
+          return true;
+        }
+        return Object.keys(ifaces).map((key) => ifaces[key]).reduce((acc, val) => acc.concat(val), []).filter((i) => !i.internal || allowInternal).some((i) => i.family === "IPv" + family || i.family === family);
+      };
+      var resolve = (family, hostname, options, callback) => {
+        options = options || {};
+        if (!isFamilySupported(family, options.allowInternalNetworkInterfaces)) {
+          return callback(null, []);
+        }
+        const dnsResolver = dns.Resolver ? new dns.Resolver(options) : dns;
+        dnsResolver["resolve" + family](hostname, (err, addresses) => {
+          if (err) {
+            switch (err.code) {
+              case dns.NODATA:
+              case dns.NOTFOUND:
+              case dns.NOTIMP:
+              case dns.SERVFAIL:
+              case dns.CONNREFUSED:
+              case dns.REFUSED:
+              case "EAI_AGAIN":
+                return callback(null, []);
+            }
+            return callback(err);
+          }
+          return callback(null, Array.isArray(addresses) ? addresses : [].concat(addresses || []));
+        });
+      };
+      var dnsCache = module.exports.dnsCache = /* @__PURE__ */ new Map();
+      var formatDNSValue = (value, extra) => {
+        if (!value) {
+          return Object.assign({}, extra || {});
+        }
+        const addresses = value.addresses || [];
+        const host = addresses.length > 0 ? addresses[Math.floor(Math.random() * addresses.length)] : null;
+        return Object.assign(
+          {
+            servername: value.servername,
+            host,
+            // Include all addresses for connection fallback support
+            _addresses: addresses
+          },
+          extra || {}
+        );
+      };
+      module.exports.resolveHostname = (options, callback) => {
+        options = options || {};
+        if (!options.host && options.servername) {
+          options.host = options.servername;
+        }
+        if (!options.host || net.isIP(options.host)) {
+          const value = {
+            addresses: [options.host],
+            servername: options.servername || false
+          };
+          return callback(
+            null,
+            formatDNSValue(value, {
+              cached: false
+            })
+          );
+        }
+        let cached;
+        if (dnsCache.has(options.host)) {
+          cached = dnsCache.get(options.host);
+          const now = Date.now();
+          if (now - lastCacheCleanup > CACHE_CLEANUP_INTERVAL) {
+            lastCacheCleanup = now;
+            for (const [host, entry] of dnsCache.entries()) {
+              if (entry.expires && entry.expires < now) {
+                dnsCache.delete(host);
+              }
+            }
+            if (dnsCache.size > MAX_CACHE_SIZE) {
+              const toDelete = Math.floor(MAX_CACHE_SIZE * 0.1);
+              const keys = Array.from(dnsCache.keys()).slice(0, toDelete);
+              keys.forEach((key) => dnsCache.delete(key));
+            }
+          }
+          if (!cached.expires || cached.expires >= now) {
+            return callback(
+              null,
+              formatDNSValue(cached.value, {
+                cached: true
+              })
+            );
+          }
+        }
+        let ipv4Addresses = [];
+        let ipv6Addresses = [];
+        let ipv4Error = null;
+        let ipv6Error = null;
+        resolve(4, options.host, options, (err, addresses) => {
+          if (err) {
+            ipv4Error = err;
+          } else {
+            ipv4Addresses = addresses || [];
+          }
+          resolve(6, options.host, options, (err2, addresses2) => {
+            if (err2) {
+              ipv6Error = err2;
+            } else {
+              ipv6Addresses = addresses2 || [];
+            }
+            const allAddresses = ipv4Addresses.concat(ipv6Addresses);
+            if (allAddresses.length) {
+              const value = {
+                addresses: allAddresses,
+                servername: options.servername || options.host
+              };
+              dnsCache.set(options.host, {
+                value,
+                expires: Date.now() + (options.dnsTtl || DNS_TTL)
+              });
+              return callback(
+                null,
+                formatDNSValue(value, {
+                  cached: false
+                })
+              );
+            }
+            if (ipv4Error && ipv6Error) {
+              if (cached) {
+                dnsCache.set(options.host, {
+                  value: cached.value,
+                  expires: Date.now() + (options.dnsTtl || DNS_TTL)
+                });
+                return callback(
+                  null,
+                  formatDNSValue(cached.value, {
+                    cached: true,
+                    error: ipv4Error
+                  })
+                );
+              }
+            }
+            try {
+              dns.lookup(options.host, { all: true }, (err3, addresses3) => {
+                if (err3) {
+                  if (cached) {
+                    dnsCache.set(options.host, {
+                      value: cached.value,
+                      expires: Date.now() + (options.dnsTtl || DNS_TTL)
+                    });
+                    return callback(
+                      null,
+                      formatDNSValue(cached.value, {
+                        cached: true,
+                        error: err3
+                      })
+                    );
+                  }
+                  return callback(err3);
+                }
+                const supportedAddresses = addresses3 ? addresses3.filter((addr) => isFamilySupported(addr.family)).map((addr) => addr.address) : [];
+                if (addresses3 && addresses3.length && !supportedAddresses.length) {
+                  console.warn(`Failed to resolve IPv${addresses3[0].family} addresses with current network`);
+                }
+                if (!supportedAddresses.length && cached) {
+                  return callback(
+                    null,
+                    formatDNSValue(cached.value, {
+                      cached: true
+                    })
+                  );
+                }
+                const value = {
+                  addresses: supportedAddresses.length ? supportedAddresses : [options.host],
+                  servername: options.servername || options.host
+                };
+                dnsCache.set(options.host, {
+                  value,
+                  expires: Date.now() + (options.dnsTtl || DNS_TTL)
+                });
+                return callback(
+                  null,
+                  formatDNSValue(value, {
+                    cached: false
+                  })
+                );
+              });
+            } catch (lookupErr) {
+              if (cached) {
+                dnsCache.set(options.host, {
+                  value: cached.value,
+                  expires: Date.now() + (options.dnsTtl || DNS_TTL)
+                });
+                return callback(
+                  null,
+                  formatDNSValue(cached.value, {
+                    cached: true,
+                    error: lookupErr
+                  })
+                );
+              }
+              return callback(ipv4Error || ipv6Error || lookupErr);
+            }
+          });
+        });
+      };
+      module.exports.parseConnectionUrl = (str) => {
+        str = str || "";
+        const options = {};
+        const url = urllib.parse(str, true);
+        switch (url.protocol) {
+          case "smtp:":
+            options.secure = false;
+            break;
+          case "smtps:":
+            options.secure = true;
+            break;
+          case "direct:":
+            options.direct = true;
+            break;
+        }
+        if (!isNaN(url.port) && Number(url.port)) {
+          options.port = Number(url.port);
+        }
+        if (url.hostname) {
+          options.host = url.hostname;
+        }
+        if (url.auth) {
+          const auth = url.auth.split(":");
+          options.auth = {
+            user: auth.shift(),
+            pass: auth.join(":")
+          };
+        }
+        Object.keys(url.query || {}).forEach((key) => {
+          let obj = options;
+          let lKey = key;
+          let value = url.query[key];
+          if (!isNaN(value)) {
+            value = Number(value);
+          }
+          switch (value) {
+            case "true":
+              value = true;
+              break;
+            case "false":
+              value = false;
+              break;
+          }
+          if (key.indexOf("tls.") === 0) {
+            lKey = key.substr(4);
+            if (!options.tls) {
+              options.tls = {};
+            }
+            obj = options.tls;
+          } else if (key.indexOf(".") >= 0) {
+            return;
+          }
+          if (!(lKey in obj)) {
+            obj[lKey] = value;
+          }
+        });
+        return options;
+      };
+      module.exports._logFunc = (logger, level, defaults, data, message, ...args) => {
+        const entry = Object.assign({}, defaults || {}, data || {});
+        delete entry.level;
+        logger[level](entry, message, ...args);
+      };
+      module.exports.getLogger = (options, defaults) => {
+        options = options || {};
+        const response = {};
+        const levels = ["trace", "debug", "info", "warn", "error", "fatal"];
+        if (!options.logger) {
+          levels.forEach((level) => {
+            response[level] = () => false;
+          });
+          return response;
+        }
+        const logger = options.logger === true ? createDefaultLogger(levels) : options.logger;
+        levels.forEach((level) => {
+          response[level] = (data, message, ...args) => {
+            module.exports._logFunc(logger, level, defaults, data, message, ...args);
+          };
+        });
+        return response;
+      };
+      module.exports.callbackPromise = (resolve2, reject) => function() {
+        const args = Array.from(arguments);
+        const err = args.shift();
+        if (err) {
+          reject(err);
+        } else {
+          resolve2(...args);
+        }
+      };
+      module.exports.parseDataURI = (uri) => {
+        if (typeof uri !== "string") {
+          return null;
+        }
+        if (!uri.startsWith("data:")) {
+          return null;
+        }
+        const commaPos = uri.indexOf(",");
+        if (commaPos === -1) {
+          return null;
+        }
+        const data = uri.substring(commaPos + 1);
+        const metaStr = uri.substring("data:".length, commaPos);
+        let encoding;
+        const metaEntries = metaStr.split(";");
+        if (metaEntries.length > 0) {
+          const lastEntry = metaEntries[metaEntries.length - 1].toLowerCase().trim();
+          if (["base64", "utf8", "utf-8"].includes(lastEntry) && lastEntry.indexOf("=") === -1) {
+            encoding = lastEntry;
+            metaEntries.pop();
+          }
+        }
+        const contentType = metaEntries.length > 0 ? metaEntries.shift() : "application/octet-stream";
+        const params = {};
+        for (let i = 0; i < metaEntries.length; i++) {
+          const entry = metaEntries[i];
+          const sepPos = entry.indexOf("=");
+          if (sepPos > 0) {
+            const key = entry.substring(0, sepPos).trim();
+            const value = entry.substring(sepPos + 1).trim();
+            if (key) {
+              params[key] = value;
+            }
+          }
+        }
+        let bufferData;
+        try {
+          if (encoding === "base64") {
+            bufferData = Buffer.from(data, "base64");
+          } else {
+            try {
+              bufferData = Buffer.from(decodeURIComponent(data));
+            } catch (_decodeError) {
+              bufferData = Buffer.from(data);
+            }
+          }
+        } catch (_bufferError) {
+          bufferData = Buffer.alloc(0);
+        }
+        return {
+          data: bufferData,
+          encoding: encoding || null,
+          contentType: contentType || "application/octet-stream",
+          params
+        };
+      };
+      module.exports.resolveContent = (data, key, callback) => {
+        let promise;
+        if (!callback) {
+          promise = new Promise((resolve2, reject) => {
+            callback = module.exports.callbackPromise(resolve2, reject);
+          });
+        }
+        let content = data && data[key] && data[key].content || data[key];
+        const encoding = (typeof data[key] === "object" && data[key].encoding || "utf8").toString().toLowerCase().replace(/[-_\s]/g, "");
+        if (!content) {
+          return callback(null, content);
+        }
+        if (typeof content === "object") {
+          if (typeof content.pipe === "function") {
+            return resolveStream(content, (err, value) => {
+              if (err) {
+                return callback(err);
+              }
+              if (data[key].content) {
+                data[key].content = value;
+              } else {
+                data[key] = value;
+              }
+              callback(null, value);
+            });
+          } else if (/^https?:\/\//i.test(content.path || content.href)) {
+            return resolveStream(nmfetch(content.path || content.href), callback);
+          } else if (/^data:/i.test(content.path || content.href)) {
+            const parsedDataUri = module.exports.parseDataURI(content.path || content.href);
+            if (!parsedDataUri || !parsedDataUri.data) {
+              return callback(null, Buffer.from(0));
+            }
+            return callback(null, parsedDataUri.data);
+          } else if (content.path) {
+            return resolveStream(fs.createReadStream(content.path), callback);
+          }
+        }
+        if (typeof data[key].content === "string" && !["utf8", "usascii", "ascii"].includes(encoding)) {
+          content = Buffer.from(data[key].content, encoding);
+        }
+        setImmediate(() => callback(null, content));
+        return promise;
+      };
+      module.exports.assign = function() {
+        const args = Array.from(arguments);
+        const target = args.shift() || {};
+        args.forEach((source) => {
+          Object.keys(source || {}).forEach((key) => {
+            if (["tls", "auth"].includes(key) && source[key] && typeof source[key] === "object") {
+              target[key] = Object.assign(target[key] || {}, source[key]);
+            } else {
+              target[key] = source[key];
+            }
+          });
+        });
+        return target;
+      };
+      module.exports.encodeXText = (str) => {
+        if (!/[^\x21-\x2A\x2C-\x3C\x3E-\x7E]/.test(str)) {
+          return str;
+        }
+        const buf = Buffer.from(str);
+        let result = "";
+        for (let i = 0, len = buf.length; i < len; i++) {
+          const c = buf[i];
+          if (c < 33 || c > 126 || c === 43 || c === 61) {
+            result += "+" + (c < 16 ? "0" : "") + c.toString(16).toUpperCase();
+          } else {
+            result += String.fromCharCode(c);
+          }
+        }
+        return result;
+      };
+      function resolveStream(stream, callback) {
+        let responded = false;
+        const chunks = [];
+        let chunklen = 0;
+        stream.on("error", (err) => {
+          if (responded) {
+            return;
+          }
+          responded = true;
+          callback(err);
+        });
+        stream.on("readable", () => {
+          let chunk;
+          while ((chunk = stream.read()) !== null) {
+            chunks.push(chunk);
+            chunklen += chunk.length;
+          }
+        });
+        stream.on("end", () => {
+          if (responded) {
+            return;
+          }
+          responded = true;
+          let value;
+          try {
+            value = Buffer.concat(chunks, chunklen);
+          } catch (E) {
+            return callback(E);
+          }
+          callback(null, value);
+        });
+      }
+      function createDefaultLogger(levels) {
+        const levelMaxLen = levels.reduce((max, level) => Math.max(max, level.length), 0);
+        const levelNames = /* @__PURE__ */ new Map();
+        levels.forEach((level) => {
+          let levelName = level.toUpperCase();
+          if (levelName.length < levelMaxLen) {
+            levelName += " ".repeat(levelMaxLen - levelName.length);
+          }
+          levelNames.set(level, levelName);
+        });
+        const print = (level, entry, message, ...args) => {
+          let prefix = "";
+          if (entry) {
+            if (entry.tnx === "server") {
+              prefix = "S: ";
+            } else if (entry.tnx === "client") {
+              prefix = "C: ";
+            }
+            if (entry.sid) {
+              prefix = "[" + entry.sid + "] " + prefix;
+            }
+            if (entry.cid) {
+              prefix = "[#" + entry.cid + "] " + prefix;
+            }
+          }
+          message = util.format(message, ...args);
+          message.split(/\r?\n/).forEach((line) => {
+            console.log("[%s] %s %s", (/* @__PURE__ */ new Date()).toISOString().substr(0, 19).replace(/T/, " "), levelNames.get(level), prefix + line);
+          });
+        };
+        const logger = {};
+        levels.forEach((level) => {
+          logger[level] = print.bind(null, level);
+        });
+        return logger;
+      }
+    }
+  });
+
+  // node_modules/smtp-server/lib/smtp-server.js
+  var require_smtp_server = __commonJS({
+    "node_modules/smtp-server/lib/smtp-server.js"(exports, module) {
+      "use strict";
+      var net = __require("net");
+      var tls = __require("tls");
+      var SMTPConnection = require_smtp_connection().SMTPConnection;
+      var tlsOptions = require_tls_options();
+      var EventEmitter = __require("events");
+      var shared = require_shared();
+      var punycode2 = (init_punycode_es6(), __toCommonJS(punycode_es6_exports));
+      var crypto = __require("crypto");
+      var CLOSE_TIMEOUT = 30 * 1e3;
+      var SMTPServer2 = class extends EventEmitter {
+        constructor(options) {
+          super();
+          this.options = options || {};
+          this.updateSecureContext();
+          this.options.disabledCommands = [].concat(this.options.disabledCommands || []).map((command) => (command || "").toString().toUpperCase().trim());
+          this.options.authMethods = [].concat(this.options.authMethods || []).map((method) => (method || "").toString().toUpperCase().trim());
+          if (!this.options.authMethods.length) {
+            this.options.authMethods = ["LOGIN", "PLAIN"];
+          }
+          if (this.options.hideENHANCEDSTATUSCODES === void 0) {
+            this.options.hideENHANCEDSTATUSCODES = true;
+          }
+          if (this.options.hideDSN === void 0) {
+            this.options.hideDSN = true;
+          }
+          if (this.options.hideREQUIRETLS === void 0) {
+            this.options.hideREQUIRETLS = true;
+          }
+          this.logger = shared.getLogger(this.options, {
+            component: this.options.component || "smtp-server"
+          });
+          ["onConnect", "onSecure", "onAuth", "onMailFrom", "onRcptTo", "onData", "onClose"].forEach((handler) => {
+            if (typeof this.options[handler] === "function") {
+              this[handler] = this.options[handler];
+            }
+          });
+          this._closeTimeout = false;
+          this.connections = /* @__PURE__ */ new Set();
+          if (this.options.secure && !this.options.needsUpgrade) {
+            this.server = net.createServer(this.options, (socket) => {
+              this._handleProxy(socket, (err, socketOptions) => {
+                if (err) {
+                }
+                if (this.options.secured) {
+                  return this.connect(socket, socketOptions);
+                }
+                this._upgrade(socket, (err2, tlsSocket) => {
+                  if (err2) {
+                    return this._onError(err2);
+                  }
+                  this.connect(tlsSocket, socketOptions);
+                });
+              });
+            });
+          } else {
+            this.server = net.createServer(
+              this.options,
+              (socket) => this._handleProxy(socket, (err, socketOptions) => {
+                if (err) {
+                }
+                this.connect(socket, socketOptions);
+              })
+            );
+          }
+          this._setListeners();
+        }
+        connect(socket, socketOptions) {
+          let connection = new SMTPConnection(this, socket, socketOptions);
+          this.connections.add(connection);
+          connection.on("error", (err) => this._onError(err));
+          connection.on("connect", (data) => this._onClientConnect(data));
+          connection.init();
+        }
+        /**
+         * Start listening on selected port and interface
+         */
+        listen(...args) {
+          return this.server.listen(...args);
+        }
+        /**
+         * Closes the server
+         *
+         * @param {Function} callback Callback to run once the server is fully closed
+         */
+        close(callback) {
+          let connections = this.connections.size;
+          let timeout = this.options.closeTimeout || CLOSE_TIMEOUT;
+          this.server.close(() => {
+            clearTimeout(this._closeTimeout);
+            if (typeof callback === "function") {
+              return callback();
+            }
+          });
+          if (connections) {
+            this.logger.info(
+              {
+                tnx: "close"
+              },
+              "Server closing with %s pending connection%s, waiting %s seconds before terminating",
+              connections,
+              connections !== 1 ? "s" : "",
+              timeout / 1e3
+            );
+          }
+          this._closeTimeout = setTimeout(() => {
+            connections = this.connections.size;
+            if (connections) {
+              this.logger.info(
+                {
+                  tnx: "close"
+                },
+                "Closing %s pending connection%s to close the server",
+                connections,
+                connections !== 1 ? "s" : ""
+              );
+              this.connections.forEach((connection) => {
+                connection.send(421, "Server shutting down");
+                connection.close();
+              });
+            }
+            if (typeof callback === "function") {
+              const realCallback = callback;
+              callback = null;
+              return realCallback();
+            }
+          }, timeout);
+          this._closeTimeout.unref();
+        }
+        /**
+         * Authentication handler. Override this
+         *
+         * @param {Object} auth Authentication options
+         * @param {Function} callback Callback to run once the user is authenticated
+         */
+        onAuth(auth, session, callback) {
+          if (auth.method === "XOAUTH2") {
+            return callback(null, {
+              data: {
+                status: "401",
+                schemes: "bearer mac",
+                scope: "https://mail.google.com/"
+              }
+            });
+          }
+          if (auth.method === "XCLIENT") {
+            return callback();
+          }
+          return callback(null, {
+            message: "Authentication not implemented"
+          });
+        }
+        onConnect(session, callback) {
+          setImmediate(callback);
+        }
+        onMailFrom(address, session, callback) {
+          setImmediate(callback);
+        }
+        onRcptTo(address, session, callback) {
+          setImmediate(callback);
+        }
+        onSecure(socket, session, callback) {
+          setImmediate(callback);
+        }
+        onData(stream, session, callback) {
+          let chunklen = 0;
+          stream.on("data", (chunk) => {
+            chunklen += chunk.length;
+          });
+          stream.on("end", () => {
+            this.logger.info(
+              {
+                tnx: "message",
+                size: chunklen
+              },
+              "<received %s bytes>",
+              chunklen
+            );
+            callback();
+          });
+        }
+        onClose() {
+        }
+        updateSecureContext(options) {
+          Object.keys(options || {}).forEach((key) => {
+            this.options[key] = options[key];
+          });
+          let defaultTlsOptions = tlsOptions(this.options);
+          this.secureContext = /* @__PURE__ */ new Map();
+          this.secureContext.set("*", tls.createSecureContext(defaultTlsOptions));
+          let ctxMap = this.options.sniOptions || {};
+          if (typeof ctxMap.get === "function") {
+            ctxMap.forEach((ctx, servername) => {
+              this.secureContext.set(this._normalizeHostname(servername), tls.createSecureContext(tlsOptions(ctx)));
+            });
+          } else {
+            Object.keys(ctxMap).forEach((servername) => {
+              this.secureContext.set(this._normalizeHostname(servername), tls.createSecureContext(tlsOptions(ctxMap[servername])));
+            });
+          }
+          if (this.options.secure) {
+            Object.keys(defaultTlsOptions || {}).forEach((key) => {
+              if (!(key in this.options)) {
+                this.options[key] = defaultTlsOptions[key];
+              }
+            });
+            if (typeof this.options.SNICallback !== "function") {
+              this.options.SNICallback = (servername, cb) => {
+                cb(null, this.secureContext.get(servername));
+              };
+            }
+          }
+        }
+        // PRIVATE METHODS
+        /**
+         * Setup server event handlers
+         */
+        _setListeners() {
+          let server = this.server;
+          server.once("listening", (...args) => this._onListening(...args));
+          server.once("close", (...args) => this._onClose(server, ...args));
+          server.on("error", (...args) => this._onError(...args));
+        }
+        /**
+         * Called when server started listening
+         *
+         * @event
+         */
+        _onListening() {
+          let address = this.server.address();
+          if (address === null) {
+            address = { address: null, port: null, family: null };
+          }
+          this.logger.info(
+            //
+            {
+              tnx: "listen",
+              host: address.address,
+              port: address.port,
+              secure: !!this.options.secure,
+              protocol: this.options.lmtp ? "LMTP" : "SMTP"
+            },
+            "%s%s Server listening on %s:%s",
+            this.options.secure ? "Secure " : "",
+            this.options.lmtp ? "LMTP" : "SMTP",
+            address.family === "IPv4" ? address.address : "[" + address.address + "]",
+            address.port
+          );
+        }
+        /**
+         * Called when server is closed
+         *
+         * @event
+         */
+        _onClose(server) {
+          this.logger.info(
+            {
+              tnx: "closed"
+            },
+            (this.options.lmtp ? "LMTP" : "SMTP") + " Server closed"
+          );
+          if (server !== this.server) {
+            return;
+          }
+          this.emit("close");
+        }
+        /**
+         * Called when an error occurs with the server
+         *
+         * @event
+         */
+        _onError(err) {
+          this.emit("error", err);
+        }
+        _handleProxy(socket, callback) {
+          let socketOptions = {
+            id: BigInt("0x" + crypto.randomBytes(10).toString("hex")).toString(32).padStart(16, "0")
+          };
+          if (!this.options.useProxy || Array.isArray(this.options.useProxy) && !this.options.useProxy.includes(socket.remoteAddress) && !this.options.useProxy.includes("*")) {
+            socketOptions.ignore = this.options.ignoredHosts && this.options.ignoredHosts.includes(socket.remoteAddress);
+            return setImmediate(() => callback(null, socketOptions));
+          }
+          let chunks = [];
+          let chunklen = 0;
+          let socketReader = () => {
+            let chunk;
+            while ((chunk = socket.read()) !== null) {
+              for (let i = 0, len = chunk.length; i < len; i++) {
+                let chr = chunk[i];
+                if (chr === 10) {
+                  socket.removeListener("readable", socketReader);
+                  chunks.push(chunk.slice(0, i + 1));
+                  chunklen += i + 1;
+                  let remainder = chunk.slice(i + 1);
+                  if (remainder.length) {
+                    socket.unshift(remainder);
+                  }
+                  let header = Buffer.concat(chunks, chunklen).toString().trim();
+                  let params = (header || "").toString().split(" ");
+                  let commandName = params.shift().toUpperCase();
+                  if (commandName !== "PROXY") {
+                    try {
+                      socket.end("* BAD Invalid PROXY header\r\n");
+                    } catch {
+                    }
+                    return;
+                  }
+                  if (params[1]) {
+                    socketOptions.remoteAddress = params[1].trim().toLowerCase();
+                    socketOptions.ignore = this.options.ignoredHosts && this.options.ignoredHosts.includes(socketOptions.remoteAddress);
+                    try {
+                      if (!socketOptions.ignore) {
+                        this.logger.info(
+                          {
+                            tnx: "proxy",
+                            cid: socketOptions.id,
+                            proxy: params[1].trim().toLowerCase()
+                          },
+                          "[%s] PROXY from %s through %s (%s)",
+                          socketOptions.id,
+                          params[1].trim().toLowerCase(),
+                          params[2].trim().toLowerCase(),
+                          JSON.stringify(params)
+                        );
+                      }
+                    } catch {
+                      socket.end("* BAD Invalid PROXY header\r\n");
+                      return;
+                    }
+                    if (params[3]) {
+                      socketOptions.remotePort = Number(params[3].trim()) || socketOptions.remotePort;
+                    }
+                  }
+                  return callback(null, socketOptions);
+                }
+              }
+              chunks.push(chunk);
+              chunklen += chunk.length;
+            }
+          };
+          socket.on("readable", socketReader);
+        }
+        /**
+         * Called when a new connection is established. This might not be the same time the socket is opened
+         *
+         * @event
+         */
+        _onClientConnect(data) {
+          this.emit("connect", data);
+        }
+        /**
+         * Normalize hostname
+         *
+         * @event
+         */
+        _normalizeHostname(hostname) {
+          try {
+            hostname = punycode2.toUnicode((hostname || "").toString().trim()).toLowerCase();
+          } catch (E) {
+            this.logger.error(
+              {
+                tnx: "punycode"
+              },
+              'Failed to process punycode domain "%s". error=%s',
+              hostname,
+              E.message
+            );
+          }
+          return hostname;
+        }
+        _upgrade(socket, callback) {
+          let socketOptions = {
+            secureContext: this.secureContext.get("*"),
+            isServer: true,
+            server: this.server,
+            SNICallback: (servername, cb) => {
+              this.options.SNICallback(this._normalizeHostname(servername), (err, context) => {
+                if (err) {
+                  this.logger.error(
+                    {
+                      tnx: "sni",
+                      servername,
+                      err
+                    },
+                    "Failed to fetch SNI context for servername %s",
+                    servername
+                  );
+                }
+                return cb(null, context || this.secureContext.get("*"));
+              });
+            }
+          };
+          let returned = false;
+          let tlsSocket;
+          let onError = (err) => {
+            if (returned) {
+              return;
+            }
+            returned = true;
+            const meta = {};
+            if (tlsSocket) {
+              meta.tlsProtocol = tlsSocket.getProtocol();
+            }
+            meta.protocol = "smtp";
+            meta.stage = "connect";
+            meta.remoteAddress = socket.remoteAddress;
+            if (err) {
+              err.meta = meta;
+            }
+            if (err && /SSL[23]*_GET_CLIENT_HELLO|ssl[23]*_read_bytes|ssl_bytes_to_cipher_list/i.test(err.message)) {
+              let message = err.message;
+              err.message = "Failed to establish TLS session";
+              err.responseCode = 500;
+              err.code = err.code || "TLSError";
+              meta.message = message;
+            }
+            if (!err || !err.message) {
+              err = new Error("Socket closed while initiating TLS");
+              err.responseCode = 500;
+              err.code = "SocketError";
+              err.report = false;
+              err.meta = meta;
+            }
+            callback(err || new Error("Socket closed unexpectedly"));
+          };
+          socket.once("error", onError);
+          tlsSocket = new tls.TLSSocket(socket, socketOptions);
+          tlsSocket.once("close", onError);
+          tlsSocket.once("error", onError);
+          tlsSocket.once("_tlsError", onError);
+          tlsSocket.once("clientError", onError);
+          tlsSocket.once("tlsClientError", onError);
+          tlsSocket.on("secure", () => {
+            socket.removeListener("error", onError);
+            tlsSocket.removeListener("close", onError);
+            tlsSocket.removeListener("error", onError);
+            tlsSocket.removeListener("_tlsError", onError);
+            tlsSocket.removeListener("clientError", onError);
+            tlsSocket.removeListener("tlsClientError", onError);
+            if (returned) {
+              try {
+                tlsSocket.end();
+              } catch {
+              }
+              return;
+            }
+            returned = true;
+            return callback(null, tlsSocket);
+          });
+        }
+      };
+      module.exports.SMTPServer = SMTPServer2;
+    }
+  });
+
+  // src/smtp-server.ts
+  var import_smtp_server = __toESM(require_smtp_server());
+  var DEFAULT_SMTP_PORT = 2525;
+  var DEFAULT_SMTP_HOST = "127.0.0.1";
+  function resolveSmtpServerConfig(config = {}) {
+    const { port = DEFAULT_SMTP_PORT, host = DEFAULT_SMTP_HOST, label, ...serverOptions } = config;
+    return {
+      ...serverOptions,
+      port,
+      host,
+      label
+    };
+  }
+  function normalizeSmtpServerConfigs(input) {
+    const configs = Array.isArray(input) ? input : input ? [input] : [];
+    return configs.map((config) => resolveSmtpServerConfig(config));
+  }
+  function closeSmtpServer(server) {
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (error2) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        if (error2) {
+          reject(error2);
+          return;
+        }
+        resolve();
+      };
+      const handleCloseError = (error2) => {
+        const errorCode = error2.code;
+        if (errorCode === "ERR_SERVER_NOT_RUNNING") {
+          finish();
+          return;
+        }
+        finish(error2);
+      };
+      try {
+        server.close(() => finish());
+      } catch (error2) {
+        handleCloseError(error2);
+      }
+    });
+  }
+  function createSmtpServer(config = {}) {
+    const resolvedConfig = resolveSmtpServerConfig(config);
+    const { port, host, label: _label, ...serverOptions } = resolvedConfig;
+    const server = new import_smtp_server.SMTPServer(serverOptions);
+    return {
+      server,
+      config: resolvedConfig,
+      listen(callback) {
+        return callback ? server.listen(port, host, callback) : server.listen(port, host);
+      },
+      address() {
+        return server.server.address();
+      },
+      close() {
+        return closeSmtpServer(server);
+      }
+    };
+  }
+  function startSmtpServer(config = {}) {
+    const handle = createSmtpServer(config);
+    handle.listen();
+    return handle;
+  }
+  var smtp_server_default = {
+    SMTPServer: import_smtp_server.SMTPServer,
+    createSmtpServer,
+    startSmtpServer,
+    DEFAULT_SMTP_HOST,
+    DEFAULT_SMTP_PORT
+  };
+})();