velocious 1.0.430 → 1.0.431

package/build/src/mailer/backends/smtp.js

@@ -1,20 +1,22 @@
 // @ts-check
-import restArgsError from "../../utils/rest-args-error.js";
+
+import restArgsError from "../../utils/rest-args-error.js"
+
 /**
  * Defines this typedef.
   @typedef {{auth?: Record<string, ?>, [key: string]: ?}} SmtpConnectionOptions */
+
 /**
  * Runs normalize recipients.
  * @param {?} value - Recipient input.
  * @returns {string[]} - Normalized recipients.
  */
 function normalizeRecipients(value) {
-    if (!value)
-        return [];
-    if (Array.isArray(value))
-        return value.filter((entry) => entry);
-    return [value].filter((entry) => entry);
+  if (!value) return []
+  if (Array.isArray(value)) return value.filter((entry) => entry)
+  return [value].filter((entry) => entry)
 }
+
 /**
  * Runs header line.
  * @param {string} name - Header name.
@@ -22,147 +24,174 @@ function normalizeRecipients(value) {
  * @returns {string | null} - Header line.
  */
 function headerLine(name, value) {
-    if (!value)
-        return null;
-    return `${name}: ${value}`;
+  if (!value) return null
+
+  return `${name}: ${value}`
 }
+
 /**
  * Runs envelope address.
  * @param {string} address - Header or mailbox address.
  * @returns {string} - SMTP envelope mailbox.
  */
 function envelopeAddress(address) {
-    const match = address.match(/<([^<>]+)>/);
-    return (match ? match[1] : address).trim();
+  const match = address.match(/<([^<>]+)>/)
+
+  return (match ? match[1] : address).trim()
 }
+
 /**
  * SMTP mailer backend using smtp-connection.
  */
 export default class SmtpMailerBackend {
-    /**
-     * Runs constructor.
-     * @param {object} args - Constructor args.
-     * @param {SmtpConnectionOptions} args.connectionOptions - smtp-connection options.
-     * @param {string} [args.defaultFrom] - Default from address.
-     */
-    constructor({ connectionOptions, defaultFrom, ...restArgs }) {
-        restArgsError(restArgs);
-        if (!connectionOptions) {
-            throw new Error(`Missing smtp connection options. Got: ${String(connectionOptions)}`);
-        }
-        this.connectionOptions = connectionOptions;
-        this.defaultFrom = defaultFrom;
+  /**
+   * Runs constructor.
+   * @param {object} args - Constructor args.
+   * @param {SmtpConnectionOptions} args.connectionOptions - smtp-connection options.
+   * @param {string} [args.defaultFrom] - Default from address.
+   */
+  constructor({connectionOptions, defaultFrom, ...restArgs}) {
+    restArgsError(restArgs)
+
+    if (!connectionOptions) {
+      throw new Error(`Missing smtp connection options. Got: ${String(connectionOptions)}`)
     }
-    /**
-     * Runs deliver.
-     * @param {object} args - Delivery args.
-     * @param {import("../index.js").MailerDeliveryPayload} args.payload - Mail delivery payload.
-     * @param {import("../../configuration.js").default} [args.configuration] - Active configuration.
-     * @returns {Promise<void>} - Resolves when complete.
-     */
-    async deliver({ payload, configuration: _configuration, ...restArgs }) {
-        restArgsError(restArgs);
-        const from = payload.from || this.defaultFrom;
-        if (!from) {
-            throw new Error(`Missing mail "from" address. Got: ${String(from)}`);
-        }
-        const envelopeFrom = envelopeAddress(String(from));
-        const toList = normalizeRecipients(payload.to);
-        const ccList = normalizeRecipients(payload.cc);
-        const bccList = normalizeRecipients(payload.bcc);
-        const recipients = [...toList, ...ccList, ...bccList];
-        if (recipients.length === 0) {
-            throw new Error(`Missing mail recipients. Got: ${JSON.stringify({ to: payload.to, cc: payload.cc, bcc: payload.bcc })}`);
+
+    this.connectionOptions = connectionOptions
+    this.defaultFrom = defaultFrom
+  }
+
+  /**
+   * Runs deliver.
+   * @param {object} args - Delivery args.
+   * @param {import("../index.js").MailerDeliveryPayload} args.payload - Mail delivery payload.
+   * @param {import("../../configuration.js").default} [args.configuration] - Active configuration.
+   * @returns {Promise<void>} - Resolves when complete.
+   */
+  async deliver({payload, configuration: _configuration, ...restArgs}) {
+    restArgsError(restArgs)
+
+    const from = payload.from || this.defaultFrom
+
+    if (!from) {
+      throw new Error(`Missing mail "from" address. Got: ${String(from)}`)
+    }
+
+    const envelopeFrom = envelopeAddress(String(from))
+
+    const toList = normalizeRecipients(payload.to)
+    const ccList = normalizeRecipients(payload.cc)
+    const bccList = normalizeRecipients(payload.bcc)
+    const recipients = [...toList, ...ccList, ...bccList]
+
+    if (recipients.length === 0) {
+      throw new Error(`Missing mail recipients. Got: ${JSON.stringify({to: payload.to, cc: payload.cc, bcc: payload.bcc})}`)
+    }
+
+    const headers = [
+      headerLine("From", from),
+      headerLine("To", toList.length > 0 ? toList.join(", ") : undefined),
+      headerLine("Cc", ccList.length > 0 ? ccList.join(", ") : undefined),
+      headerLine("Subject", payload.subject),
+      "MIME-Version: 1.0",
+      "Content-Type: text/html; charset=UTF-8"
+    ].filter((line) => line)
+
+    if (payload.headers) {
+      for (const [headerName, headerValue] of Object.entries(payload.headers)) {
+        headers.push(`${headerName}: ${headerValue}`)
+      }
+    }
+
+    const message = `${headers.join("\r\n")}\r\n\r\n${payload.html}`
+    const {default: SmtpConnection} = await import("smtp-connection")
+    const connectionOptions = this.connectionOptions
+    const connection = new SmtpConnection(connectionOptions)
+
+    await new Promise((resolve, reject) => {
+      let settled = false
+      let shuttingDown = false
+
+      const cleanup = () => {
+        connection.removeListener("end", onEnd)
+        connection.removeListener("error", onError)
+      }
+
+      const resolveDelivery = () => {
+        if (settled) return
+
+        settled = true
+        cleanup()
+        resolve(undefined)
+      }
+
+      /**
+       * Reject delivery.
+       * @param {Error} error - Error that failed delivery.
+       */
+      const rejectDelivery = (error) => {
+        if (settled) return
+
+        settled = true
+        cleanup()
+        connection.close()
+        reject(error)
+      }
+
+      const onEnd = () => resolveDelivery()
+
+      /**
+       * On error.
+       * @param {Error} error - Error emitted by the SMTP connection.
+       */
+      const onError = (error) => {
+        if (shuttingDown) {
+          resolveDelivery()
+          return
         }
-        const headers = [
-            headerLine("From", from),
-            headerLine("To", toList.length > 0 ? toList.join(", ") : undefined),
-            headerLine("Cc", ccList.length > 0 ? ccList.join(", ") : undefined),
-            headerLine("Subject", payload.subject),
-            "MIME-Version: 1.0",
-            "Content-Type: text/html; charset=UTF-8"
-        ].filter((line) => line);
-        if (payload.headers) {
-            for (const [headerName, headerValue] of Object.entries(payload.headers)) {
-                headers.push(`${headerName}: ${headerValue}`);
-            }
+
+        rejectDelivery(error)
+      }
+
+      const quitAfterAcceptedMessage = () => {
+        shuttingDown = true
+        connection.once("end", onEnd)
+        connection.quit()
+      }
+
+      const sendMessage = () => {
+        connection.send({from: envelopeFrom, to: recipients}, /**
+                                                               * Narrows the runtime value to the documented type.
+                                                                @type {?} */ (message), (/**
+                                                                                          * Narrows the runtime value to the documented type.
+                                                                                           @type {Error | null | undefined} */ sendError) => {
+          if (sendError) {
+            rejectDelivery(sendError)
+            return
+          }
+
+          quitAfterAcceptedMessage()
+        })
+      }
+
+      const authenticateAndSend = () => {
+        if (!connectionOptions.auth) {
+          sendMessage()
+          return
         }
-        const message = `${headers.join("\r\n")}\r\n\r\n${payload.html}`;
-        const { default: SmtpConnection } = await import("smtp-connection");
-        const connectionOptions = this.connectionOptions;
-        const connection = new SmtpConnection(connectionOptions);
-        await new Promise((resolve, reject) => {
-            let settled = false;
-            let shuttingDown = false;
-            const cleanup = () => {
-                connection.removeListener("end", onEnd);
-                connection.removeListener("error", onError);
-            };
-            const resolveDelivery = () => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                resolve(undefined);
-            };
-            /**
-             * Reject delivery.
-             * @param {Error} error - Error that failed delivery.
-             */
-            const rejectDelivery = (error) => {
-                if (settled)
-                    return;
-                settled = true;
-                cleanup();
-                connection.close();
-                reject(error);
-            };
-            const onEnd = () => resolveDelivery();
-            /**
-             * On error.
-             * @param {Error} error - Error emitted by the SMTP connection.
-             */
-            const onError = (error) => {
-                if (shuttingDown) {
-                    resolveDelivery();
-                    return;
-                }
-                rejectDelivery(error);
-            };
-            const quitAfterAcceptedMessage = () => {
-                shuttingDown = true;
-                connection.once("end", onEnd);
-                connection.quit();
-            };
-            const sendMessage = () => {
-                connection.send({ from: envelopeFrom, to: recipients }, /**
-                                                                       * Narrows the runtime value to the documented type.
-                                                                        @type {?} */ (message), (/**
-                                          * Narrows the runtime value to the documented type.
-                                           @type {Error | null | undefined} */ sendError) => {
-                    if (sendError) {
-                        rejectDelivery(sendError);
-                        return;
-                    }
-                    quitAfterAcceptedMessage();
-                });
-            };
-            const authenticateAndSend = () => {
-                if (!connectionOptions.auth) {
-                    sendMessage();
-                    return;
-                }
-                connection.login(connectionOptions.auth, (loginError) => {
-                    if (loginError) {
-                        rejectDelivery(loginError);
-                        return;
-                    }
-                    sendMessage();
-                });
-            };
-            connection.on("error", onError);
-            connection.connect(authenticateAndSend);
-        });
-    }
+
+        connection.login(connectionOptions.auth, (loginError) => {
+          if (loginError) {
+            rejectDelivery(loginError)
+            return
+          }
+
+          sendMessage()
+        })
+      }
+
+      connection.on("error", onError)
+      connection.connect(authenticateAndSend)
+    })
+  }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smtp.js","sourceRoot":"","sources":["../../../../src/mailer/backends/smtp.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,aAAa,MAAM,gCAAgC,CAAA;AAE1D;;kFAEkF;AAElF;;;;GAIG;AACH,SAAS,mBAAmB,CAAC,KAAK;IAChC,IAAI,CAAC,KAAK;QAAE,OAAO,EAAE,CAAA;IACrB,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAA;IAC/D,OAAO,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAA;AACzC,CAAC;AAED;;;;;GAKG;AACH,SAAS,UAAU,CAAC,IAAI,EAAE,KAAK;IAC7B,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAA;IAEvB,OAAO,GAAG,IAAI,KAAK,KAAK,EAAE,CAAA;AAC5B,CAAC;AAED;;;;GAIG;AACH,SAAS,eAAe,CAAC,OAAO;IAC9B,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAA;IAEzC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAA;AAC5C,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC;;;;;OAKG;IACH,YAAY,EAAC,iBAAiB,EAAE,WAAW,EAAE,GAAG,QAAQ,EAAC;QACvD,aAAa,CAAC,QAAQ,CAAC,CAAA;QAEvB,IAAI,CAAC,iBAAiB,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,yCAAyC,MAAM,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAA;QACvF,CAAC;QAED,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAA;QAC1C,IAAI,CAAC,WAAW,GAAG,WAAW,CAAA;IAChC,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,CAAC,EAAC,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,GAAG,QAAQ,EAAC;QACjE,aAAa,CAAC,QAAQ,CAAC,CAAA;QAEvB,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,CAAA;QAE7C,IAAI,CAAC,IAAI,EAAE,CAAC;YACV,MAAM,IAAI,KAAK,CAAC,qCAAqC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QACtE,CAAC;QAED,MAAM,YAAY,GAAG,eAAe,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAA;QAElD,MAAM,MAAM,GAAG,mBAAmB,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QAC9C,MAAM,MAAM,GAAG,mBAAmB,CAAC,OAAO,CAAC,EAAE,CAAC,CAAA;QAC9C,MAAM,OAAO,GAAG,mBAAmB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QAChD,MAAM,UAAU,GAAG,CAAC,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,CAAA;QAErD,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CAAC,iCAAiC,IAAI,CAAC,SAAS,CAAC,EAAC,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAC,CAAC,EAAE,CAAC,CAAA;QACxH,CAAC;QAED,MAAM,OAAO,GAAG;YACd,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC;YACxB,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YACnE,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YACnE,UAAU,CAAC,SAAS,EAAE,OAAO,CAAC,OAAO,CAAC;YACtC,mBAAmB;YACnB,wCAAwC;SACzC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,CAAA;QAExB,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YACpB,KAAK,MAAM,CAAC,UAAU,EAAE,WAAW,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;gBACxE,OAAO,CAAC,IAAI,CAAC,GAAG,UAAU,KAAK,WAAW,EAAE,CAAC,CAAA;YAC/C,CAAC;QACH,CAAC;QAED,MAAM,OAAO,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,WAAW,OAAO,CAAC,IAAI,EAAE,CAAA;QAChE,MAAM,EAAC,OAAO,EAAE,cAAc,EAAC,GAAG,MAAM,MAAM,CAAC,iBAAiB,CAAC,CAAA;QACjE,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAA;QAChD,MAAM,UAAU,GAAG,IAAI,cAAc,CAAC,iBAAiB,CAAC,CAAA;QAExD,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACpC,IAAI,OAAO,GAAG,KAAK,CAAA;YACnB,IAAI,YAAY,GAAG,KAAK,CAAA;YAExB,MAAM,OAAO,GAAG,GAAG,EAAE;gBACnB,UAAU,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;gBACvC,UAAU,CAAC,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;YAC7C,CAAC,CAAA;YAED,MAAM,eAAe,GAAG,GAAG,EAAE;gBAC3B,IAAI,OAAO;oBAAE,OAAM;gBAEnB,OAAO,GAAG,IAAI,CAAA;gBACd,OAAO,EAAE,CAAA;gBACT,OAAO,CAAC,SAAS,CAAC,CAAA;YACpB,CAAC,CAAA;YAED;;;eAGG;YACH,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,EAAE;gBAC/B,IAAI,OAAO;oBAAE,OAAM;gBAEnB,OAAO,GAAG,IAAI,CAAA;gBACd,OAAO,EAAE,CAAA;gBACT,UAAU,CAAC,KAAK,EAAE,CAAA;gBAClB,MAAM,CAAC,KAAK,CAAC,CAAA;YACf,CAAC,CAAA;YAED,MAAM,KAAK,GAAG,GAAG,EAAE,CAAC,eAAe,EAAE,CAAA;YAErC;;;eAGG;YACH,MAAM,OAAO,GAAG,CAAC,KAAK,EAAE,EAAE;gBACxB,IAAI,YAAY,EAAE,CAAC;oBACjB,eAAe,EAAE,CAAA;oBACjB,OAAM;gBACR,CAAC;gBAED,cAAc,CAAC,KAAK,CAAC,CAAA;YACvB,CAAC,CAAA;YAED,MAAM,wBAAwB,GAAG,GAAG,EAAE;gBACpC,YAAY,GAAG,IAAI,CAAA;gBACnB,UAAU,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;gBAC7B,UAAU,CAAC,IAAI,EAAE,CAAA;YACnB,CAAC,CAAA;YAED,MAAM,WAAW,GAAG,GAAG,EAAE;gBACvB,UAAU,CAAC,IAAI,CAAC,EAAC,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,UAAU,EAAC,EAAE;;oFAEc,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;;8EAEqC,CAAC,SAAS,EAAE,EAAE;oBAClI,IAAI,SAAS,EAAE,CAAC;wBACd,cAAc,CAAC,SAAS,CAAC,CAAA;wBACzB,OAAM;oBACR,CAAC;oBAED,wBAAwB,EAAE,CAAA;gBAC5B,CAAC,CAAC,CAAA;YACJ,CAAC,CAAA;YAED,MAAM,mBAAmB,GAAG,GAAG,EAAE;gBAC/B,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC;oBAC5B,WAAW,EAAE,CAAA;oBACb,OAAM;gBACR,CAAC;gBAED,UAAU,CAAC,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC,UAAU,EAAE,EAAE;oBACtD,IAAI,UAAU,EAAE,CAAC;wBACf,cAAc,CAAC,UAAU,CAAC,CAAA;wBAC1B,OAAM;oBACR,CAAC;oBAED,WAAW,EAAE,CAAA;gBACf,CAAC,CAAC,CAAA;YACJ,CAAC,CAAA;YAED,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,CAAA;YAC/B,UAAU,CAAC,OAAO,CAAC,mBAAmB,CAAC,CAAA;QACzC,CAAC,CAAC,CAAA;IACJ,CAAC;CACF","sourcesContent":["// @ts-check\n\nimport restArgsError from \"../../utils/rest-args-error.js\"\n\n/**\n * Defines this typedef.\n  @typedef {{auth?: Record<string, ?>, [key: string]: ?}} SmtpConnectionOptions */\n\n/**\n * Runs normalize recipients.\n * @param {?} value - Recipient input.\n * @returns {string[]} - Normalized recipients.\n */\nfunction normalizeRecipients(value) {\n  if (!value) return []\n  if (Array.isArray(value)) return value.filter((entry) => entry)\n  return [value].filter((entry) => entry)\n}\n\n/**\n * Runs header line.\n * @param {string} name - Header name.\n * @param {string | undefined} value - Header value.\n * @returns {string | null} - Header line.\n */\nfunction headerLine(name, value) {\n  if (!value) return null\n\n  return `${name}: ${value}`\n}\n\n/**\n * Runs envelope address.\n * @param {string} address - Header or mailbox address.\n * @returns {string} - SMTP envelope mailbox.\n */\nfunction envelopeAddress(address) {\n  const match = address.match(/<([^<>]+)>/)\n\n  return (match ? match[1] : address).trim()\n}\n\n/**\n * SMTP mailer backend using smtp-connection.\n */\nexport default class SmtpMailerBackend {\n  /**\n   * Runs constructor.\n   * @param {object} args - Constructor args.\n   * @param {SmtpConnectionOptions} args.connectionOptions - smtp-connection options.\n   * @param {string} [args.defaultFrom] - Default from address.\n   */\n  constructor({connectionOptions, defaultFrom, ...restArgs}) {\n    restArgsError(restArgs)\n\n    if (!connectionOptions) {\n      throw new Error(`Missing smtp connection options. Got: ${String(connectionOptions)}`)\n    }\n\n    this.connectionOptions = connectionOptions\n    this.defaultFrom = defaultFrom\n  }\n\n  /**\n   * Runs deliver.\n   * @param {object} args - Delivery args.\n   * @param {import(\"../index.js\").MailerDeliveryPayload} args.payload - Mail delivery payload.\n   * @param {import(\"../../configuration.js\").default} [args.configuration] - Active configuration.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async deliver({payload, configuration: _configuration, ...restArgs}) {\n    restArgsError(restArgs)\n\n    const from = payload.from || this.defaultFrom\n\n    if (!from) {\n      throw new Error(`Missing mail \"from\" address. Got: ${String(from)}`)\n    }\n\n    const envelopeFrom = envelopeAddress(String(from))\n\n    const toList = normalizeRecipients(payload.to)\n    const ccList = normalizeRecipients(payload.cc)\n    const bccList = normalizeRecipients(payload.bcc)\n    const recipients = [...toList, ...ccList, ...bccList]\n\n    if (recipients.length === 0) {\n      throw new Error(`Missing mail recipients. Got: ${JSON.stringify({to: payload.to, cc: payload.cc, bcc: payload.bcc})}`)\n    }\n\n    const headers = [\n      headerLine(\"From\", from),\n      headerLine(\"To\", toList.length > 0 ? toList.join(\", \") : undefined),\n      headerLine(\"Cc\", ccList.length > 0 ? ccList.join(\", \") : undefined),\n      headerLine(\"Subject\", payload.subject),\n      \"MIME-Version: 1.0\",\n      \"Content-Type: text/html; charset=UTF-8\"\n    ].filter((line) => line)\n\n    if (payload.headers) {\n      for (const [headerName, headerValue] of Object.entries(payload.headers)) {\n        headers.push(`${headerName}: ${headerValue}`)\n      }\n    }\n\n    const message = `${headers.join(\"\\r\\n\")}\\r\\n\\r\\n${payload.html}`\n    const {default: SmtpConnection} = await import(\"smtp-connection\")\n    const connectionOptions = this.connectionOptions\n    const connection = new SmtpConnection(connectionOptions)\n\n    await new Promise((resolve, reject) => {\n      let settled = false\n      let shuttingDown = false\n\n      const cleanup = () => {\n        connection.removeListener(\"end\", onEnd)\n        connection.removeListener(\"error\", onError)\n      }\n\n      const resolveDelivery = () => {\n        if (settled) return\n\n        settled = true\n        cleanup()\n        resolve(undefined)\n      }\n\n      /**\n       * Reject delivery.\n       * @param {Error} error - Error that failed delivery.\n       */\n      const rejectDelivery = (error) => {\n        if (settled) return\n\n        settled = true\n        cleanup()\n        connection.close()\n        reject(error)\n      }\n\n      const onEnd = () => resolveDelivery()\n\n      /**\n       * On error.\n       * @param {Error} error - Error emitted by the SMTP connection.\n       */\n      const onError = (error) => {\n        if (shuttingDown) {\n          resolveDelivery()\n          return\n        }\n\n        rejectDelivery(error)\n      }\n\n      const quitAfterAcceptedMessage = () => {\n        shuttingDown = true\n        connection.once(\"end\", onEnd)\n        connection.quit()\n      }\n\n      const sendMessage = () => {\n        connection.send({from: envelopeFrom, to: recipients}, /**\n                                                               * Narrows the runtime value to the documented type.\n                                                                @type {?} */ (message), (/**\n                                                                                          * Narrows the runtime value to the documented type.\n                                                                                           @type {Error | null | undefined} */ sendError) => {\n          if (sendError) {\n            rejectDelivery(sendError)\n            return\n          }\n\n          quitAfterAcceptedMessage()\n        })\n      }\n\n      const authenticateAndSend = () => {\n        if (!connectionOptions.auth) {\n          sendMessage()\n          return\n        }\n\n        connection.login(connectionOptions.auth, (loginError) => {\n          if (loginError) {\n            rejectDelivery(loginError)\n            return\n          }\n\n          sendMessage()\n        })\n      }\n\n      connection.on(\"error\", onError)\n      connection.connect(authenticateAndSend)\n    })\n  }\n}\n"]}