imapkit 4.0.2 → 4.1.0

package/{lib → dist/esm}/commands/unsubscribe.js

@@ -1,50 +1,35 @@
-'use strict';
-
-module.exports = function (connection, parsed, data, callback) {
+export default function unsubscribeCommand(connection, parsed, data, callback) {
     if (!parsed.attributes || parsed.attributes.length !== 1 || !parsed.attributes[0] || ['STRING', 'LITERAL', 'ATOM'].indexOf(parsed.attributes[0].type) < 0) {
-        connection.send(
-            {
-                tag: parsed.tag,
-                command: 'BAD',
-                attributes: [
-                    {
-                        type: 'TEXT',
-                        value: 'UNSUBSCRIBE expects mailbox name'
-                    }
-                ]
-            },
-            'INVALID COMMAND',
-            parsed,
-            data
-        );
+        connection.send({
+            tag: parsed.tag,
+            command: 'BAD',
+            attributes: [
+                {
+                    type: 'TEXT',
+                    value: 'UNSUBSCRIBE expects mailbox name'
+                }
+            ]
+        }, 'INVALID COMMAND', parsed, data);
         return callback();
     }
-
     let path = parsed.attributes[0].value;
     if (path.toUpperCase() === 'INBOX') {
         path = 'INBOX';
     }
-
     // The subscription list holds names, so a name stays removable after its mailbox is deleted
     // (RFC 3501 section 6.3.6). Removing a name that is not subscribed is not an error (RFC 9051 section 6.3.8)
     if (connection.server.subscriptions.delete(path)) {
         connection.server.mailboxChanged('unsubscribe', path);
     }
-
-    connection.send(
-        {
-            tag: parsed.tag,
-            command: 'OK',
-            attributes: [
-                {
-                    type: 'TEXT',
-                    value: 'UNSUBSCRIBE completed'
-                }
-            ]
-        },
-        'UNSUBSCRIBE',
-        parsed,
-        data
-    );
+    connection.send({
+        tag: parsed.tag,
+        command: 'OK',
+        attributes: [
+            {
+                type: 'TEXT',
+                value: 'UNSUBSCRIBE completed'
+            }
+        ]
+    }, 'UNSUBSCRIBE', parsed, data);
     return callback();
-};
+}

package/dist/esm/dates.d.ts

@@ -0,0 +1,64 @@
+declare const MONTHS: string[];
+/** Date and time parts of a parsed date, the time fields are undefined when the value has no time */
+export interface DateParts {
+    day: number;
+    /** month index, 0 for January */
+    month: number;
+    year: number;
+    hours?: number | undefined;
+    minutes?: number | undefined;
+    seconds?: number | undefined;
+    /** `+hhmm` / `-hhmm` or a zone name */
+    zone?: string | undefined;
+}
+/**
+ * Returns the index of a month name, ignoring case like all ABNF strings
+ *
+ * @param {String} name Three letter month name, e.g. "jan"
+ * @return {Number} 0 for January to 11 for December, or -1 for an unknown name
+ */
+declare function monthIndex(name: string | undefined): number;
+/**
+ * Checks if day, month and year make a real date
+ *
+ * @param {Number|String} day Day of the month
+ * @param {Number} month Month index, 0 for January
+ * @param {Number|String} year Full year
+ * @return {Boolean} true if the date exists
+ */
+declare function isRealDate(day: number | string | undefined, month: number, year: number | string | undefined): boolean;
+/**
+ * Converts day, month and year to a comparable YYYY-MM-DD string
+ *
+ * @param {Number|String} day Day of the month
+ * @param {Number} month Month index, 0 for January
+ * @param {Number|String} year Full year
+ * @return {String|Boolean} the date, or false for an impossible date
+ */
+declare function dateKey(day: number | string, month: number, year: number | string): string | false;
+/**
+ * Parses a date-time value of the RFC 3501 section 9 form, like an INTERNALDATE ("14-Sep-2013 21:22:28 -0300").
+ * A value with only the date part is accepted as well, its time fields are left undefined
+ *
+ * @param {String} value Date-time value
+ * @return {Object|null} `{ day, month, year, hours, minutes, seconds, zone }` with the month index, or null
+ */
+declare function parseDateTime(value: unknown): DateParts | null;
+/**
+ * Parses the date-time of a Date header (RFC 5322 section 3.3, with the obsolete forms of section 4.3: comments,
+ * two and three digit years, zone names). SEARCH uses only the date as written (RFC 3501 section 6.4.4), SORT
+ * normalizes date and time to UTC with toTimestamp (RFC 5256 section 2.2), so both read the header with this
+ *
+ * @param {String} header Value of the Date header
+ * @return {Object|null} `{ day, month, year, hours, minutes, seconds, zone }` with the month index, or null if the
+ *   header has no valid date. The time fields are undefined when the header has no time
+ */
+declare function parseHeaderDate(header: string | undefined): DateParts | null;
+/**
+ * Converts date and time parts to milliseconds since the epoch, adjusted by the time zone. An unknown zone is UTC
+ *
+ * @param {Object} date `{ day, month, year, hours, minutes, seconds, zone }`, see parseDateTime and parseHeaderDate
+ * @return {Number} timestamp
+ */
+declare function toTimestamp(date: DateParts): number;
+export { MONTHS, monthIndex, isRealDate, dateKey, parseDateTime, parseHeaderDate, toTimestamp };

package/{lib → dist/esm}/dates.js

@@ -1,8 +1,5 @@
-'use strict';
-
 // Month names of the RFC 3501 section 9 date-month rule, in the case they are sent in
 const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
-
 /**
  * Returns the index of a month name, ignoring case like all ABNF strings
  *
@@ -13,7 +10,6 @@ function monthIndex(name) {
     const value = String(name || '').toLowerCase();
     return MONTHS.findIndex(month => month.toLowerCase() === value);
 }
-
 /**
  * Checks if day, month and year make a real date
  *
@@ -30,7 +26,6 @@ function isRealDate(day, month, year) {
     }
     return day <= new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
 }
-
 /**
  * Converts day, month and year to a comparable YYYY-MM-DD string
  *
@@ -45,7 +40,6 @@ function dateKey(day, month, year) {
     }
     return String(year).padStart(4, '0') + '-' + String(month + 1).padStart(2, '0') + '-' + String(day).padStart(2, '0');
 }
-
 /**
  * Parses a date-time value of the RFC 3501 section 9 form, like an INTERNALDATE ("14-Sep-2013 21:22:28 -0300").
  * A value with only the date part is accepted as well, its time fields are left undefined
@@ -54,14 +48,13 @@ function dateKey(day, month, year) {
  * @return {Object|null} `{ day, month, year, hours, minutes, seconds, zone }` with the month index, or null
  */
 function parseDateTime(value) {
-    const match = (value || '').toString().match(/^\s*(\d{1,2})-([A-Za-z]{3})-(\d{4})(?: (\d{2}):(\d{2}):(\d{2}) ([+-]\d{4}))?/);
+    const match = String(value || '').match(/^\s*(\d{1,2})-([A-Za-z]{3})-(\d{4})(?: (\d{2}):(\d{2}):(\d{2}) ([+-]\d{4}))?/);
     if (!match || !isRealDate(match[1], monthIndex(match[2]), match[3])) {
         return null;
     }
     const time = match[4] === undefined ? {} : { hours: Number(match[4]), minutes: Number(match[5]), seconds: Number(match[6]), zone: match[7] };
     return Object.assign({ day: Number(match[1]), month: monthIndex(match[2]), year: Number(match[3]) }, time);
 }
-
 /**
  * Parses the date-time of a Date header (RFC 5322 section 3.3, with the obsolete forms of section 4.3: comments,
  * two and three digit years, zone names). SEARCH uses only the date as written (RFC 3501 section 6.4.4), SORT
@@ -83,7 +76,8 @@ function parseHeaderDate(header) {
     // RFC 5322 section 4.3: two digit years below 50 are 20xx, three digit years add 1900
     if (match[3].length === 2) {
         year += year < 50 ? 2000 : 1900;
-    } else if (match[3].length === 3) {
+    }
+    else if (match[3].length === 3) {
         year += 1900;
     }
     const day = Number(match[1]);
@@ -94,10 +88,8 @@ function parseHeaderDate(header) {
     const time = match[4] === undefined ? {} : { hours: Number(match[4]), minutes: Number(match[5]), seconds: Number(match[6] || 0), zone: match[7] };
     return Object.assign({ day, month, year }, time);
 }
-
 // RFC 5322 section 4.3 obsolete zones, military zones are treated as "-0000"
 const ZONES = { UT: 0, GMT: 0, EST: -5, EDT: -4, CST: -6, CDT: -5, MST: -7, MDT: -6, PST: -8, PDT: -7 };
-
 /**
  * Converts date and time parts to milliseconds since the epoch, adjusted by the time zone. An unknown zone is UTC
  *
@@ -114,10 +106,10 @@ function toTimestamp(date) {
         if (zoneMinutes < 60) {
             offset = sign * (zoneHours * 60 + zoneMinutes);
         }
-    } else if (Object.hasOwn(ZONES, zone.toUpperCase())) {
+    }
+    else if (Object.hasOwn(ZONES, zone.toUpperCase())) {
         offset = ZONES[zone.toUpperCase()] * 60;
     }
     return Date.UTC(date.year, date.month, date.day, date.hours || 0, date.minutes || 0, date.seconds || 0) - offset * 60 * 1000;
 }
-
-module.exports = { MONTHS, monthIndex, isRealDate, dateKey, parseDateTime, parseHeaderDate, toTimestamp };
+export { MONTHS, monthIndex, isRealDate, dateKey, parseDateTime, parseHeaderDate, toTimestamp };

package/dist/esm/deflate-layer.d.ts

@@ -0,0 +1,83 @@
+import zlib from 'node:zlib';
+/** Options of a DeflateLayer */
+export interface DeflateLayerOptions {
+    /** sends octets to the peer */
+    writeRaw: (data: Buffer | string) => void;
+    /** gets the input, decompressed while compression is active */
+    onData: (data: Buffer) => void;
+    /** called when the input is not valid DEFLATE data */
+    onError?: ((err: Error) => unknown) | undefined;
+}
+/**
+ * One end of a COMPRESS=DEFLATE layer (RFC 4978): raw DEFLATE (RFC 1951, no zlib header or
+ * checksum) in both directions. The server plugin uses it, and so do the clients of the tests and
+ * the compare tool.
+ *
+ * Either direction can be terminated, which UNAUTHENTICATE requires (RFC 8437 section 4.1). Output
+ * terminates with a final DEFLATE block, data written after that goes out uncompressed once the
+ * compressed data is out. Input terminates where the peer ended its compression: at the end of
+ * its DEFLATE stream if it sent a final block, otherwise at the end of the sync flush that
+ * carried the last compressed data. The input is split at sync flush markers to find that point.
+ */
+declare class DeflateLayer {
+    writeRaw: (data: Buffer | string) => void;
+    onData: (data: Buffer) => void;
+    onError: (err: Error) => unknown;
+    active: boolean;
+    inputActive: boolean;
+    _deflate: zlib.DeflateRaw;
+    _held: (Buffer | string)[] | null;
+    _endCallbacks: (() => void)[];
+    _flushScheduled: boolean;
+    _inflate: zlib.InflateRaw;
+    _pieces: Buffer[];
+    _busy: boolean;
+    _fed: number;
+    _expectFinal: boolean;
+    _idleCallbacks: (() => void)[];
+    /**
+     * @param {Object} options
+     * @param {Function} options.writeRaw `(buffer)` sends octets to the peer
+     * @param {Function} options.onData `(buffer)` gets the input, decompressed while compression is active
+     * @param {Function} [options.onError] `(err)` called when the input is not valid DEFLATE data
+     */
+    constructor(options: DeflateLayerOptions);
+    /**
+     * Sends data to the peer, compressed while compression is active
+     *
+     * @param {Buffer} data Data to send
+     */
+    write(data: Buffer | string): void;
+    /**
+     * Terminates the outgoing compression with a final DEFLATE block. Later writes are sent
+     * uncompressed, after the compressed data.
+     *
+     * @param {Function} [callback] Called once the compressed data is written out
+     */
+    end(callback?: (() => void) | null): void;
+    _runCallbacks(key: '_endCallbacks' | '_idleCallbacks'): void;
+    /**
+     * Handles octets received from the peer
+     *
+     * @param {Buffer} chunk Received data
+     */
+    receive(chunk: Buffer): void;
+    /**
+     * Tells the layer that the peer terminates its compression after the data decompressed so far
+     * (RFC 8437 section 4.1). Call it from onData, the rest of the input is then passed on as is.
+     */
+    endInput(): void;
+    /**
+     * Calls back once all received data is passed on
+     *
+     * @param {Function} callback Function to call
+     */
+    whenIdle(callback: () => void): void;
+    _next(): void;
+    _receivePlain(chunk: Buffer): void;
+    /**
+     * Frees the compressor and the decompressor
+     */
+    destroy(): void;
+}
+export default DeflateLayer;

package/{lib → dist/esm}/deflate-layer.js

@@ -1,12 +1,8 @@
-'use strict';
-
-const zlib = require('zlib');
-
+import zlib from 'node:zlib';
 // Z_SYNC_FLUSH ends with an empty stored block, LEN 0 and NLEN 0xFFFF (RFC 1951 section 3.2.4)
 const SYNC_MARKER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
 // Z_FINISH right after a flush is an empty final block with fixed Huffman codes
 const EMPTY_FINAL_BLOCK = Buffer.from([0x03, 0x00]);
-
 /**
  * One end of a COMPRESS=DEFLATE layer (RFC 4978): raw DEFLATE (RFC 1951, no zlib header or
  * checksum) in both directions. The server plugin uses it, and so do the clients of the tests and
@@ -29,28 +25,25 @@ class DeflateLayer {
         this.writeRaw = options.writeRaw;
         this.onData = options.onData;
         this.onError = options.onError || (() => false);
-
         // outgoing data is compressed
         this.active = true;
         // incoming data is compressed
         this.inputActive = true;
-
         this._deflate = zlib.createDeflateRaw();
-        this._deflate.on('data', chunk => this.writeRaw(chunk));
-        this._deflate.on('error', err => this.onError(err));
+        this._deflate.on('data', (chunk) => this.writeRaw(chunk));
+        this._deflate.on('error', (err) => this.onError(err));
         // writes that wait for the final compressed data, null when nothing is waiting
         this._held = null;
         this._endCallbacks = [];
         this._flushScheduled = false;
-
         this._inflate = zlib.createInflateRaw({ flush: zlib.constants.Z_SYNC_FLUSH });
-        this._inflate.on('data', chunk => {
+        this._inflate.on('data', (chunk) => {
             // anything the peer compressed after it ended its compression is dropped
             if (this.inputActive) {
                 this.onData(chunk);
             }
         });
-        this._inflate.on('error', err => {
+        this._inflate.on('error', (err) => {
             this.inputActive = false;
             this._pieces = [];
             this._busy = false;
@@ -67,7 +60,6 @@ class DeflateLayer {
         // called once the received data is processed
         this._idleCallbacks = [];
     }
-
     /**
      * Sends data to the peer, compressed while compression is active
      *
@@ -95,7 +87,6 @@ class DeflateLayer {
             });
         }
     }
-
     /**
      * Terminates the outgoing compression with a final DEFLATE block. Later writes are sent
      * uncompressed, after the compressed data.
@@ -115,21 +106,19 @@ class DeflateLayer {
         this.active = false;
         this._held = [];
         this._deflate.once('end', () => {
-            const held = this._held;
+            const held = this._held || [];
             this._held = null;
             held.forEach(data => this.writeRaw(data));
             this._runCallbacks('_endCallbacks');
         });
         this._deflate.end();
     }
-
     // calls the callbacks of a list once, callbacks added meanwhile wait for the next run
     _runCallbacks(key) {
         const callbacks = this[key];
         this[key] = [];
         callbacks.forEach(callback => callback());
     }
-
     /**
      * Handles octets received from the peer
      *
@@ -151,7 +140,6 @@ class DeflateLayer {
         }
         this._next();
     }
-
     /**
      * Tells the layer that the peer terminates its compression after the data decompressed so far
      * (RFC 8437 section 4.1). Call it from onData, the rest of the input is then passed on as is.
@@ -159,7 +147,6 @@ class DeflateLayer {
     endInput() {
         this.inputActive = false;
     }
-
     /**
      * Calls back once all received data is passed on
      *
@@ -169,7 +156,6 @@ class DeflateLayer {
         this._idleCallbacks.push(callback);
         this._next();
     }
-
     _next() {
         if (this._busy) {
             return;
@@ -185,7 +171,6 @@ class DeflateLayer {
             this._next();
             return;
         }
-
         const piece = this._pieces.shift();
         this._busy = true;
         this._fed += piece.length;
@@ -198,14 +183,14 @@ class DeflateLayer {
                 if (unused > 0) {
                     this._pieces.unshift(piece.subarray(piece.length - unused));
                 }
-            } else if (!this.inputActive) {
+            }
+            else if (!this.inputActive) {
                 // the input ended at a sync flush, the final block may still follow
                 this._expectFinal = true;
             }
             this._next();
         });
     }
-
     _receivePlain(chunk) {
         if (this._expectFinal) {
             this._expectFinal = false;
@@ -217,7 +202,6 @@ class DeflateLayer {
             this.onData(chunk);
         }
     }
-
     /**
      * Frees the compressor and the decompressor
      */
@@ -228,5 +212,4 @@ class DeflateLayer {
         this._inflate.destroy();
     }
 }
-
-module.exports = DeflateLayer;
+export default DeflateLayer;

package/dist/esm/encoded-words.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Reads a binary string (one char per octet) as UTF-8, invalid sequences become U+FFFD
+ */
+declare function decodeUtf8(value: string): string;
+/**
+ * Decodes an RFC 2047 header value to a Unicode string. Text outside encoded words is read as UTF-8
+ * (invalid sequences become U+FFFD). Adjacent encoded words in the same charset are decoded together,
+ * so a multi-octet character may span them, and the white space between them is dropped (RFC 2047
+ * section 6.2). Encoded words in an unknown charset are kept as they are.
+ *
+ * @param {String} value Header value as a binary string
+ * @return {String} Decoded value
+ */
+declare function decodeHeader(input: unknown): string;
+export { decodeHeader, decodeUtf8 };

package/{lib → dist/esm}/encoded-words.js

@@ -1,23 +1,16 @@
-'use strict';
-
 // RFC 2047 encoded words in header values, decoded for SEARCH, SORT and THREAD
-
 // RFC 2047 section 2: encoded-word = "=?" charset "?" encoding "?" encoded-text "?=", RFC 2231 section 5
 // adds an optional "*" language suffix to the charset
 const ENCODED_WORD = /=\?([^?\s*]+)(?:\*[^?\s]*)?\?([BbQq])\?([^?\s]*)\?=/g;
-
 const utf8Decoder = new TextDecoder('utf-8');
-
 /**
  * Reads a binary string (one char per octet) as UTF-8, invalid sequences become U+FFFD
  */
 function decodeUtf8(value) {
     return utf8Decoder.decode(Buffer.from(value, 'binary'));
 }
-
 // decoders by lower case charset name, false for a charset that TextDecoder does not know
 const decoders = new Map();
-
 /**
  * Decodes the octets of an encoded word, or returns false if the charset is unknown
  */
@@ -27,15 +20,15 @@ function decodeCharset(charset, octets) {
         let decoder = false;
         try {
             decoder = new TextDecoder(charset);
-        } catch {
+        }
+        catch {
             // unknown charset
         }
         decoders.set(charset, decoder);
     }
     const decoder = decoders.get(charset);
-    return decoder && decoder.decode(octets);
+    return decoder ? decoder.decode(octets) : false;
 }
-
 /**
  * Decodes an RFC 2047 header value to a Unicode string. Text outside encoded words is read as UTF-8
  * (invalid sequences become U+FFFD). Adjacent encoded words in the same charset are decoded together,
@@ -45,8 +38,8 @@ function decodeCharset(charset, octets) {
  * @param {String} value Header value as a binary string
  * @return {String} Decoded value
  */
-function decodeHeader(value) {
-    value = (value || '').toString();
+function decodeHeader(input) {
+    const value = String(input || '');
     if (value.indexOf('=?') < 0 && !/[\u0080-\u00ff]/.test(value)) {
         // nothing to decode
         return value;
@@ -54,7 +47,6 @@ function decodeHeader(value) {
     let result = '';
     let pending = null;
     let lastIndex = 0;
-
     const flush = () => {
         if (pending) {
             const decoded = decodeCharset(pending.charset, Buffer.concat(pending.octets));
@@ -62,7 +54,6 @@ function decodeHeader(value) {
             pending = null;
         }
     };
-
     ENCODED_WORD.lastIndex = 0;
     let match;
     while ((match = ENCODED_WORD.exec(value))) {
@@ -73,15 +64,9 @@ function decodeHeader(value) {
             result += decodeUtf8(between);
         }
         lastIndex = ENCODED_WORD.lastIndex;
-
-        const octets =
-            match[2].toUpperCase() === 'B'
-                ? Buffer.from(match[3], 'base64')
-                : Buffer.from(
-                      match[3].replace(/_/g, ' ').replace(/=([0-9a-fA-F]{2})/g, (m, hex) => String.fromCharCode(parseInt(hex, 16))),
-                      'binary'
-                  );
-
+        const octets = match[2].toUpperCase() === 'B'
+            ? Buffer.from(match[3], 'base64')
+            : Buffer.from(match[3].replace(/_/g, ' ').replace(/=([0-9a-fA-F]{2})/g, (m, hex) => String.fromCharCode(parseInt(hex, 16))), 'binary');
         if (pending && pending.charset.toLowerCase() !== match[1].toLowerCase()) {
             flush();
         }
@@ -94,5 +79,4 @@ function decodeHeader(value) {
     flush();
     return result + decodeUtf8(value.substr(lastIndex));
 }
-
-module.exports = { decodeHeader, decodeUtf8 };
+export { decodeHeader, decodeUtf8 };

package/dist/esm/envelope.d.ts

@@ -0,0 +1,33 @@
+import type { ParsedAddress } from './addressparser.js';
+import type { ParsedHeader } from './mimeparser.js';
+/** An address of the ENVELOPE (RFC 3501 section 9): name, source route, mailbox and host, all NIL for a group end */
+export type EnvelopeAddress = [name: string | null, adl: null, mailbox: string | null, host: string | null];
+/** The fields of the ENVELOPE (RFC 3501 section 7.4.2), in order */
+export type Envelope = [
+    date: string | null,
+    subject: string | null,
+    from: EnvelopeAddress[] | null,
+    sender: EnvelopeAddress[] | null,
+    replyTo: EnvelopeAddress[] | null,
+    to: EnvelopeAddress[] | null,
+    cc: EnvelopeAddress[] | null,
+    bcc: EnvelopeAddress[] | null,
+    inReplyTo: string | null,
+    messageId: string | null
+];
+/**
+ * Convert a message object to an ENVELOPE object
+ *
+ * @param {Object} header Parsed header of a mime tree node
+ * @return {Object} ENVELOPE compatible object
+ */
+export default function envelope(header: ParsedHeader): Envelope;
+/**
+ * Converts an address object to a list of arrays
+ * [{name: "User Name", addres:"user@example.com"}] -> [["User Name", null, "user", "example.com"]]
+ *
+ * @param {Array} arr An array of address objects
+ * @return {Array} A list of addresses
+ */
+declare function processAddress(arr: ParsedAddress | ParsedAddress[] | undefined, def?: ParsedAddress | ParsedAddress[]): EnvelopeAddress[] | null;
+export { processAddress };

package/{lib → dist/esm}/envelope.js

@@ -1,14 +1,11 @@
-'use strict';
-
 // This module converts message structure into an ENVELOPE object
-
 /**
  * Convert a message object to an ENVELOPE object
  *
  * @param {Object} header Parsed header of a mime tree node
  * @return {Object} ENVELOPE compatible object
  */
-module.exports = function (header) {
+export default function envelope(header) {
     // RFC 3501 9: env-date and env-subject are nstring, NIL when the header is missing
     const subject = header.subject;
     return [
@@ -25,8 +22,7 @@ module.exports = function (header) {
         header['in-reply-to'] || null,
         header['message-id'] || null
     ];
-};
-
+}
 /**
  * Converts an address object to a list of arrays
  * [{name: "User Name", addres:"user@example.com"}] -> [["User Name", null, "user", "example.com"]]
@@ -35,15 +31,15 @@ module.exports = function (header) {
  * @return {Array} A list of addresses
  */
 function processAddress(arr, def) {
-    arr = [].concat(arr || []);
-    if (!arr.length) {
-        arr = [].concat(def || []);
+    let list = [].concat(arr || []);
+    if (!list.length) {
+        list = [].concat(def || []);
     }
-    if (!arr.length) {
+    if (!list.length) {
         return null;
     }
     let result = [];
-    arr.forEach(addr => {
+    list.forEach(addr => {
         if (addr.group) {
             // Handle group syntax
             result.push([null, null, addr.name || '', null]);
@@ -51,32 +47,25 @@ function processAddress(arr, def) {
             result.push([null, null, null, null]);
             return;
         }
-
         let name = addr.name || null;
         let address = addr.address || '';
-
         if (!address && name) {
             // a bare word ("To: localuser") is the mailbox, not the name
             address = name;
             name = null;
         }
-
         if (!address) {
             return;
         }
-
         const at = address.lastIndexOf('@');
         const user = at >= 0 ? address.substr(0, at) : address;
         // RFC 3501 7.4.2 reserves a NIL host for group markers, so an address without a domain gets
         // the placeholder host that Dovecot uses for the same input
         const domain = (at >= 0 ? address.substr(at + 1) : '') || 'MISSING_DOMAIN';
-
         result.push([name, null, user || null, domain]);
     });
-
     // env-from = "(" 1*address ")", there is no SP between the addresses (RFC 3501 section 9)
     Object.defineProperty(result, 'adjacentLists', { value: true });
     return result.length ? result : null;
 }
-
-module.exports.processAddress = processAddress;
+export { processAddress };