@mavogel/awscdk-rootmail 0.1.4 → 0.1.5

package/node_modules/nodemailer/dist/esm/json-transport/index.d.ts

@@ -7,9 +7,9 @@ import type { default as Mail, SentMessageInfo, SendMailOptions, TransportOption
  */
 export interface JSONTransportOptions extends TransportOptions {
     /** Selects this transport in createTransport */
-    jsonTransport?: boolean;
+    jsonTransport?: boolean | undefined;
     /** If true, the message is returned as an object instead of a JSON string */
-    skipEncoding?: boolean;
+    skipEncoding?: boolean | undefined;
 }
 /**
  * The value the JSON transport hands to the send callback

package/node_modules/nodemailer/dist/esm/mail-composer/index.d.ts

@@ -8,45 +8,45 @@ import type { OutgoingHttpHeaders } from 'node:http';
  */
 export interface MailComposerAlternative {
     /** The content itself: a string, a Buffer, a readable stream or a content descriptor */
-    content?: MimeNodeContent;
+    content?: MimeNodeContent | undefined;
     /** File path, data URI or http(s) URL to read the content from */
-    path?: string | false;
+    path?: string | false | undefined;
     /** URL or data URI to fetch the content from */
-    href?: string | false;
+    href?: string | false | undefined;
     /** Request headers for a URL fetch */
-    httpHeaders?: OutgoingHttpHeaders;
+    httpHeaders?: OutgoingHttpHeaders | undefined;
     /** TLS settings for a URL fetch, see nmfetch */
     tls?: {
         [key: string]: any;
-    };
+    } | undefined;
     /** Encoding of a string `content`, decoded into a Buffer unless it is utf8 or ascii */
-    encoding?: string;
+    encoding?: string | undefined;
     /** Pregenerated MIME part, used as is instead of building the node */
-    raw?: MimeNodeContent;
+    raw?: MimeNodeContent | undefined;
     /** Content type, detected from the filename, path or URL when not set */
-    contentType?: string;
+    contentType?: string | undefined;
     /** Content-Transfer-Encoding for the node, false leaves the choice to the node */
-    contentTransferEncoding?: string | false;
+    contentTransferEncoding?: string | false | undefined;
     /** Filename for the node, false suppresses the generated one */
-    filename?: string | false;
+    filename?: string | false | undefined;
     /** Additional headers for the node */
-    headers?: MimeNodeHeaders;
+    headers?: MimeNodeHeaders | undefined;
 }
 /**
  * An attachment, the shape of the attachments entries
  */
 export interface MailComposerAttachment extends MailComposerAlternative {
     /** Content-Disposition for the node, 'attachment' by default and 'inline' for a message node or an image with a cid */
-    contentDisposition?: string;
+    contentDisposition?: string | undefined;
     /** Content-Id for an embedded image, moves the attachment into the multipart/related node beside the html */
-    cid?: string;
+    cid?: string | undefined;
 }
 /**
  * The icalEvent value as an object
  */
 export interface MailComposerIcalEvent extends MailComposerAlternative {
     /** iCalendar method, PUBLISH by default */
-    method?: string;
+    method?: string | undefined;
 }
 /**
  * The attachments as sorted by getAttachments
@@ -62,7 +62,7 @@ export interface MailComposerAttachments {
  */
 export type MailComposerListHeaderEntry = string | {
     url: string;
-    comment?: string;
+    comment?: string | undefined;
 };
 /**
  * The list value: List-* headers keyed by the part after "List-" (help, unsubscribe,
@@ -79,75 +79,68 @@ export interface MailComposerListHeaders {
  * by MailComposer itself, these are marked as such
  */
 export interface MailComposerOptions {
-    from?: MimeNodeAddressInput;
-    sender?: MimeNodeAddressInput;
-    to?: MimeNodeAddressInput;
-    cc?: MimeNodeAddressInput;
-    bcc?: MimeNodeAddressInput;
-    replyTo?: MimeNodeAddressInput;
-    inReplyTo?: string;
-    references?: string | string[];
-    subject?: string;
+    from?: MimeNodeAddressInput | undefined;
+    sender?: MimeNodeAddressInput | undefined;
+    to?: MimeNodeAddressInput | undefined;
+    cc?: MimeNodeAddressInput | undefined;
+    bcc?: MimeNodeAddressInput | undefined;
+    replyTo?: MimeNodeAddressInput | undefined;
+    inReplyTo?: string | undefined;
+    references?: string | string[] | undefined;
+    subject?: string | undefined;
     /** Message-ID header value, generated when missing */
-    messageId?: string;
+    messageId?: string | undefined;
     /** Date header value, the current time when missing */
-    date?: Date | string;
+    date?: Date | string | undefined;
     /** Plaintext version of the message */
-    text?: string | Buffer | Readable | MailComposerAlternative;
+    text?: string | Buffer | Readable | MailComposerAlternative | undefined;
     /** HTML version of the message */
-    html?: string | Buffer | Readable | MailComposerAlternative;
+    html?: string | Buffer | Readable | MailComposerAlternative | undefined;
     /** Apple Watch specific HTML version of the message */
-    watchHtml?: string | Buffer | Readable | MailComposerAlternative;
+    watchHtml?: string | Buffer | Readable | MailComposerAlternative | undefined;
     /** AMP4EMAIL version of the message */
-    amp?: string | Buffer | Readable | MailComposerAlternative;
+    amp?: string | Buffer | Readable | MailComposerAlternative | undefined;
     /** iCalendar event, included both as a text/calendar alternative and as an application/ics attachment */
-    icalEvent?: string | Buffer | Readable | MailComposerIcalEvent;
-    attachments?: MailComposerAttachment[];
+    icalEvent?: string | Buffer | Readable | MailComposerIcalEvent | undefined;
+    attachments?: MailComposerAttachment[] | undefined;
     /** Further alternatives for the multipart/alternative node, after text, watchHtml, amp, html and the calendar event */
-    alternatives?: MailComposerAlternative[];
+    alternatives?: MailComposerAlternative[] | undefined;
     /** Custom headers for the root node, the standard headers above override them */
-    headers?: MimeNodeHeaders;
+    headers?: MimeNodeHeaders | undefined;
     /** List-* headers, read by the mailer */
-    list?: MailComposerListHeaders;
+    list?: MailComposerListHeaders | undefined;
     /** SMTP envelope to use instead of the one generated from the headers */
-    envelope?: MimeNodeEnvelopeInput;
+    envelope?: MimeNodeEnvelopeInput | undefined;
     /** Content-Transfer-Encoding to force for the text/* nodes that do not set their own */
-    encoding?: string;
+    encoding?: string | undefined;
     /** Header string encoding, 'Q' (the default) or 'B', 'quoted-printable' and 'base64' are accepted as well */
-    textEncoding?: string;
+    textEncoding?: string | undefined;
     /** Pregenerated rfc822 message, used as is instead of building one */
-    raw?: MimeNodeContent;
+    raw?: MimeNodeContent | undefined;
     /** Reject content that points to a URL */
-    disableUrlAccess?: boolean;
+    disableUrlAccess?: boolean | undefined;
     /** Reject content that points to a file path */
-    disableFileAccess?: boolean;
+    disableFileAccess?: boolean | undefined;
     /** Convert data: images in the html into embedded attachments, read by the mailer */
-    attachDataUrls?: boolean;
+    attachDataUrls?: boolean | undefined;
     /** Prefix for the generated multipart boundaries */
-    boundaryPrefix?: string;
+    boundaryPrefix?: string | undefined;
     /** Shared part of the unique multipart boundary */
-    baseBoundary?: string;
+    baseBoundary?: string | undefined;
     /** 'win' for CRLF and 'linux' for LF line breaks in the generated message, kept as is when not set */
-    newline?: string;
+    newline?: string | undefined;
     /** Keep the Bcc header in the generated message, listed for completeness, the transports set it on the message directly */
-    keepBcc?: boolean;
+    keepBcc?: boolean | undefined;
     /** Method to normalize header keys for custom caseing */
-    normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'];
+    normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'] | undefined;
     /** 'high', 'normal' or 'low', sets the priority headers, read by the mailer */
-    priority?: string;
+    priority?: string | undefined;
     /** X-Mailer header value, false leaves the header out, read by the mailer */
-    xMailer?: string | false;
+    xMailer?: string | false | undefined;
 }
 declare class MailComposer {
     mail: MailComposerOptions;
     message: MimeNode | false;
-    _alternatives: MailComposerAlternative[];
-    _htmlNode: MailComposerAlternative | undefined;
-    _attachments: MailComposerAttachments;
-    _useRelated: boolean;
-    _useAlternative: boolean;
-    _useMixed: boolean | number;
-    _icalEvent: MailComposerIcalEvent | undefined;
     constructor(mail?: MailComposerOptions);
     /**
      * Builds MimeNode instance
@@ -160,60 +153,12 @@ declare class MailComposer {
      * @returns An object of arrays (`related` and `attached`)
      */
     getAttachments(findRelated?: boolean): MailComposerAttachments;
-    /**
-     * Returns the icalEvent value with `path`/`href`/data uri input normalized into
-     * a `content` entry, the same way as for regular attachments. The same event is
-     * included twice (as a text/calendar alternative and as an application/ics
-     * attachment), so the shared content object is marked to be resolved just once
-     * and the buffered result is reused by the second node.
-     *
-     * @returns Normalized icalEvent data
-     */
-    _getIcalEvent(): MailComposerIcalEvent;
     /**
      * List alternatives. Resulting objects can be used as input for MimeNode nodes
      *
      * @returns An array of alternative elements. Includes the `text` and `html` values as well
      */
     getAlternatives(): MailComposerAlternative[];
-    /**
-     * Builds multipart/mixed node. It should always contain different type of elements on the same level
-     * eg. text + attachments
-     *
-     * @param parentNode Parent for this note. If it does not exist, a root node is created
-     * @returns MimeNode node element
-     */
-    _createMixed(parentNode?: MimeNode): MimeNode;
-    /**
-     * Builds multipart/alternative node. It should always contain same type of elements on the same level
-     * eg. text + html view of the same data
-     *
-     * @param parentNode Parent for this note. If it does not exist, a root node is created
-     * @returns MimeNode node element
-     */
-    _createAlternative(parentNode?: MimeNode): MimeNode;
-    /**
-     * Builds multipart/related node. It should always contain html node with related attachments
-     *
-     * @param parentNode Parent for this note. If it does not exist, a root node is created
-     * @returns MimeNode node element
-     */
-    _createRelated(parentNode?: MimeNode): MimeNode;
-    /**
-     * Creates a regular node with contents
-     *
-     * @param parentNode Parent for this note. If it does not exist, a root node is created
-     * @param element Node data
-     * @returns MimeNode node element
-     */
-    _createContentNode(parentNode: MimeNode | false, element?: MailComposerAttachment): MimeNode;
-    /**
-     * Parses data uri and converts it to a Buffer
-     *
-     * @param element Content element
-     * @return Parsed element
-     */
-    _processDataUrl<T extends MailComposerAlternative>(element: T): T;
 }
 /**
  * Type alias in the layout of the other modules (@types/nodemailer had no namespace for MailComposer)

package/node_modules/nodemailer/dist/esm/mail-composer/index.js

@@ -181,6 +181,7 @@ class MailComposer {
      * and the buffered result is reused by the second node.
      *
      * @returns Normalized icalEvent data
+     * @internal
      */
     _getIcalEvent() {
         if (!this._icalEvent) {
@@ -214,7 +215,8 @@ class MailComposer {
                 else if (icalEvent.href) {
                     icalEvent.content = {
                         href: icalEvent.href,
-                        httpHeaders: icalEvent.httpHeaders
+                        httpHeaders: icalEvent.httpHeaders,
+                        tls: icalEvent.tls
                     };
                     icalEvent.href = undefined;
                 }
@@ -323,7 +325,9 @@ class MailComposer {
             }
             else if (alternative.href) {
                 data.content = {
-                    href: alternative.href
+                    href: alternative.href,
+                    httpHeaders: alternative.httpHeaders,
+                    tls: alternative.tls
                 };
             }
             else {
@@ -345,6 +349,7 @@ class MailComposer {
      *
      * @param parentNode Parent for this note. If it does not exist, a root node is created
      * @returns MimeNode node element
+     * @internal
      */
     _createMixed(parentNode) {
         const node = parentNode
@@ -386,6 +391,7 @@ class MailComposer {
      *
      * @param parentNode Parent for this note. If it does not exist, a root node is created
      * @returns MimeNode node element
+     * @internal
      */
     _createAlternative(parentNode) {
         const node = parentNode
@@ -419,6 +425,7 @@ class MailComposer {
      *
      * @param parentNode Parent for this note. If it does not exist, a root node is created
      * @returns MimeNode node element
+     * @internal
      */
     _createRelated(parentNode) {
         const node = parentNode
@@ -447,6 +454,7 @@ class MailComposer {
      * @param parentNode Parent for this note. If it does not exist, a root node is created
      * @param element Node data
      * @returns MimeNode node element
+     * @internal
      */
     _createContentNode(parentNode, element) {
         element = element || {};
@@ -507,6 +515,7 @@ class MailComposer {
      *
      * @param element Content element
      * @return Parsed element
+     * @internal
      */
     _processDataUrl(element) {
         const dataUrl = element.path || element.href;

package/node_modules/nodemailer/dist/esm/mailer/index.d.ts

@@ -25,13 +25,13 @@ export interface SentMessageInfo {
     /** Message-ID of the sent message */
     messageId: string;
     /** Recipient addresses the transport accepted */
-    accepted?: string[];
+    accepted?: string[] | undefined;
     /** Recipient addresses the transport rejected */
-    rejected?: string[];
+    rejected?: string[] | undefined;
     /** Recipient addresses left pending, LMTP reports these */
-    pending?: string[];
+    pending?: string[] | undefined;
     /** Last response from the server */
-    response?: string;
+    response?: string | undefined;
     /** The generated message, for the transports that hand it back instead of sending it */
     message?: unknown;
     /** Transport specific fields */
@@ -59,8 +59,8 @@ export type PluginFunction<T = SentMessageInfo> = (mail: MailMessage<T>, callbac
  * the socket, with the host and port to connect to
  */
 export interface GetSocketOptions {
-    host?: string;
-    port?: number | string;
+    host?: string | undefined;
+    port?: number | string | undefined;
     [key: string]: any;
 }
 /**
@@ -68,7 +68,7 @@ export interface GetSocketOptions {
  */
 export interface SocketOptions {
     /** An established socket, the proxied connection */
-    connection?: net.Socket;
+    connection?: net.Socket | undefined;
 }
 /**
  * Receives the socket options from a getSocket handler, or the error that prevented the
@@ -119,9 +119,9 @@ export interface Transport<T = SentMessageInfo> {
     /** Registers an event listener, the transport may emit 'log', 'error', 'idle' and 'clear' */
     on?(event: string | symbol, listener: (...args: any[]) => void): this;
     /** The Mail object the transport belongs to, set by Mail */
-    mailer?: Mail<T>;
+    mailer?: Mail<T> | undefined;
     /** Socket handler for a proxied connection, set by Mail when a proxy is configured */
-    getSocket?: GetSocketHandler;
+    getSocket?: GetSocketHandler | undefined;
 }
 /**
  * Transport configuration as read by Mail itself. The transport reads its own options from
@@ -129,25 +129,25 @@ export interface Transport<T = SentMessageInfo> {
  */
 export interface TransportOptions {
     /** Bunyan compatible logger, true for the default console logger, false or unset for no logging */
-    logger?: shared.ExternalLogger | boolean;
+    logger?: shared.ExternalLogger | boolean | undefined;
     /** Component name for the log lines, defaults to 'mail' */
-    component?: string;
+    component?: string | undefined;
     /** DKIM signing options, every message is signed with these unless it carries its own */
-    dkim?: DKIMOptions;
+    dkim?: DKIMOptions | undefined;
     /** Proxy url. http(s) proxies work as is, socks proxies need the socks module set with set('proxy_socks_module', socks) */
-    proxy?: string;
+    proxy?: string | undefined;
     /** TLS options, rejectUnauthorized applies to an https proxy as well */
-    tls?: ConnectionOptions;
+    tls?: ConnectionOptions | undefined;
     /** Reject content that points to a file path, forced onto every message */
-    disableFileAccess?: boolean;
+    disableFileAccess?: boolean | undefined;
     /** Reject content that points to a URL, forced onto every message */
-    disableUrlAccess?: boolean;
+    disableUrlAccess?: boolean | undefined;
     /** Method to normalize header keys for custom caseing, forced onto every message */
-    normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'];
+    normalizeHeaderKey?: MimeNodeOptions['normalizeHeaderKey'] | undefined;
     /** Recipients allowed on one message, forced onto every message, 0 disables the limit, defaults to 100000 */
-    maxRecipients?: number;
+    maxRecipients?: number | undefined;
     /** Convert data: images in the html into embedded attachments */
-    attachDataUrls?: boolean;
+    attachDataUrls?: boolean | undefined;
 }
 /**
  * The transporter object createTransport returns, a Mail instance wrapping a transport
@@ -161,13 +161,8 @@ export type Transporter<T = SentMessageInfo> = Mail<T>;
  */
 declare class Mail<out T = SentMessageInfo> extends EventEmitter {
     options: TransportOptions;
+    /** Message defaults given to createTransport, kept public because the DefinitelyTyped typings declared it */
     _defaults: MailDefaults;
-    _defaultPlugins: {
-        [step: string]: PluginFunction<any>[];
-    };
-    _userPlugins: {
-        [step: string]: PluginFunction<any>[];
-    };
     meta: Map<string, any>;
     dkim: DKIM | false;
     transporter: Transport<T>;
@@ -182,7 +177,7 @@ declare class Mail<out T = SentMessageInfo> extends EventEmitter {
         (): Promise<true>;
     };
     /** Socket handler for a proxied connection, set by setupProxy and handed to the transport on the next send */
-    getSocket?: GetSocketHandler | false;
+    getSocket?: GetSocketHandler | false | undefined;
     constructor(transporter: Transport<T>, options?: TransportOptions, defaults?: MailDefaults);
     use(step: string, plugin: PluginFunction<T>): this;
     /**
@@ -194,14 +189,12 @@ declare class Mail<out T = SentMessageInfo> extends EventEmitter {
     sendMail(data: SendMailOptions): Promise<T>;
     sendMail(data: SendMailOptions, callback: SendMailCallback<T>): void;
     getVersionString(): string;
-    _processPlugins(step: string, mail: MailMessage<T>, callback: PluginCallback): void;
     /**
      * Sets up proxy handler for a Nodemailer object
      *
      * @param proxyUrl Proxy configuration url
      */
     setupProxy(proxyUrl: string): void;
-    _convertDataImages(mail: MailMessage<T>, callback: PluginCallback): void;
     set<K extends keyof MailMeta & string>(key: K, value: MailMeta[K]): Map<string, any>;
     get<K extends keyof MailMeta & string>(key: K): MailMeta[K] | undefined;
 }

package/node_modules/nodemailer/dist/esm/mailer/index.js

@@ -134,12 +134,24 @@ class Mail extends EventEmitter {
                 }, 'PluginCompile Error: %s', err.message);
                 return done(err);
             }
-            mail.message = new MailComposer(mail.data).compile();
-            mail.setMailerHeader();
-            mail.setPriorityHeaders();
-            mail.setListHeaders();
+            let recipientCount;
+            try {
+                mail.message = new MailComposer(mail.data).compile();
+                mail.setMailerHeader();
+                mail.setPriorityHeaders();
+                mail.setListHeaders();
+                recipientCount = mail.message.getEnvelope().to.length;
+            }
+            catch (err) {
+                // message data can throw while it is compiled, the error belongs to the callback
+                this.logger.error({
+                    err,
+                    tnx: 'transport',
+                    action: 'send'
+                }, 'Compile Error: %s', err.message);
+                return done(err);
+            }
             const maxRecipients = mail.data.maxRecipients === undefined ? DEFAULT_MAX_RECIPIENTS : mail.data.maxRecipients;
-            const recipientCount = mail.message.getEnvelope().to.length;
             if (maxRecipients && recipientCount > maxRecipients) {
                 const err = new Error(`Message has ${recipientCount} recipients, which is over the ${maxRecipients} allowed by maxRecipients`);
                 err.code = errors.EMAXRECIPIENTS;
@@ -187,6 +199,7 @@ class Mail extends EventEmitter {
     getVersionString() {
         return util.format('%s (%s; +%s; %s/%s)', packageData.name, packageData.version, packageData.homepage, this.transporter.name, this.transporter.version);
     }
+    /** @internal */
     _processPlugins(step, mail, callback) {
         step = (step || '').toString();
         if (!this._userPlugins.hasOwnProperty(step)) {
@@ -321,6 +334,7 @@ class Mail extends EventEmitter {
             callback(err);
         };
     }
+    /** @internal */
     _convertDataImages(mail, callback) {
         if ((!this.options.attachDataUrls && !mail.data.attachDataUrls) || !mail.data.html) {
             return callback();

package/node_modules/nodemailer/dist/esm/mailer/mail-message.d.ts

@@ -1,5 +1,5 @@
 import MimeNode, { type MimeNodePreparedHeaderValue } from '../mime-node/index.js';
-import type { MailComposerListHeaders, MailComposerOptions } from '../mail-composer/index.js';
+import type { MailComposerOptions } from '../mail-composer/index.js';
 import type { DKIMOptions } from '../dkim/index.js';
 import type { SMTPEnvelopeDsn } from '../smtp-connection/index.js';
 import type { SMTPTransportAuthOptions } from '../smtp-transport/index.js';
@@ -13,21 +13,19 @@ import type { SentMessageInfo } from './index.js';
  */
 export interface SendMailOptions extends MailComposerOptions {
     /** DKIM signing options for this message, used instead of the ones of the transporter */
-    dkim?: DKIMOptions;
-    /** Extra DKIM options for this message, merged over the options of the signer */
-    _dkim?: DKIMOptions;
+    dkim?: DKIMOptions | undefined;
     /** Recipients allowed on this message, 0 disables the limit, defaults to 100000 */
-    maxRecipients?: number;
+    maxRecipients?: number | undefined;
     /** SMTP transports: DSN parameters for the envelope, sent when the server supports the DSN extension */
-    dsn?: SMTPEnvelopeDsn;
+    dsn?: SMTPEnvelopeDsn | undefined;
     /** SMTP transports: RFC 8689, send the REQUIRETLS parameter with MAIL FROM */
-    requireTLSExtensionEnabled?: boolean;
+    requireTLSExtensionEnabled?: boolean | undefined;
     /** SMTP transports: per-message authentication settings, used instead of the transport level auth */
-    auth?: SMTPTransportAuthOptions;
+    auth?: SMTPTransportAuthOptions | undefined;
     /** SES transport: extra SendEmailCommand parameters merged into the API call */
     ses?: {
         [key: string]: unknown;
-    };
+    } | undefined;
 }
 /**
  * Default message fields, the third argument of createTransport. Applied to every message
@@ -43,7 +41,7 @@ export interface MailMessageData extends SendMailOptions {
     /** Header values flattened to strings and keyed by lowercase header name, set by normalize */
     normalizedHeaders?: {
         [key: string]: string;
-    };
+    } | undefined;
 }
 /**
  * Callback for resolveAll and normalize, receives the message data with every content value
@@ -89,6 +87,4 @@ export default class MailMessage<T = SentMessageInfo> {
     setMailerHeader(): void;
     setPriorityHeaders(): void;
     setListHeaders(): void;
-    _getListHeaders(listData: MailComposerListHeaders): MailMessageListHeader[];
-    _formatListUrl(url: string): string;
 }

package/node_modules/nodemailer/dist/esm/mailer/mail-message.js

@@ -239,6 +239,7 @@ export default class MailMessage {
             });
         });
     }
+    /** @internal */
     _getListHeaders(listData) {
         // make sure an url looks like <protocol:url>
         return Object.keys(listData).map(key => ({
@@ -283,6 +284,7 @@ export default class MailMessage {
             }))
         }));
     }
+    /** @internal */
     _formatListUrl(url) {
         // a url has no way to carry a control char or DEL, and the angle brackets around it
         // are not a quoting construct, so anything left here lands in the header raw

package/node_modules/nodemailer/dist/esm/mime-funcs/index.d.ts

@@ -14,7 +14,7 @@ export interface StructuredHeaderValue {
     /** The value ahead of the parameters, for example the content type */
     value: string | false;
     /** Parameter values keyed by parameter name */
-    params?: Record<string, string>;
+    params?: Record<string, string> | undefined;
 }
 /**
  * A single key=value pair of an rfc2231 encoded header parameter

package/node_modules/nodemailer/dist/esm/mime-funcs/index.js

@@ -76,7 +76,10 @@ export function encodeWord(data, mimeWordEncoding, maxLength) {
         });
     }
     else if (mimeWordEncoding === 'B') {
-        encodedStr = typeof data === 'string' ? data : base64.encode(data);
+        // the chunking loop below splits raw text and base64 encodes each part, so a
+        // Buffer goes in as its UTF-8 string: handing it the base64 of the whole input
+        // would encode the encoding itself and decode back to base64 text
+        encodedStr = typeof data === 'string' ? data : data.toString('utf-8');
         maxLength = maxLength ? Math.max(3, ((maxLength - (maxLength % 4)) / 4) * 3) : 0;
     }
     if (maxLength && (mimeWordEncoding !== 'B' ? encodedStr : base64.encode(data)).length > maxLength) {