@nocobase/plugin-workflow-mailer 2.2.20 → 2.2.21

package/dist/node_modules/nodemailer/{lib → dist/esm}/shared/index.js

@@ -1,61 +1,46 @@
 /* eslint no-console: 0 */
-
-'use strict';
-
-const urllib = require('./url');
-const util = require('util');
-const fs = require('fs');
-const nmfetch = require('../fetch');
-const errors = require('../errors');
-const objects = require('./objects');
-const dns = require('dns');
-const net = require('net');
-const os = require('os');
-
+import * as urllib from './url.js';
+import util from 'node:util';
+import fs from 'node:fs';
+import nmfetch from '../fetch/index.js';
+import * as errors from '../errors.js';
+import { isProtoKey, copyOwnKeys } from './objects.js';
+import dns from 'node:dns';
+import net from 'node:net';
+import os from 'node:os';
 // re-exported for the callers that already depend on this module, see ./objects
-const isProtoKey = (module.exports.isProtoKey = objects.isProtoKey);
-module.exports.copyOwnKeys = objects.copyOwnKeys;
-
+export { isProtoKey, copyOwnKeys };
 const DNS_TTL = 5 * 60 * 1000;
 const CACHE_CLEANUP_INTERVAL = 30 * 1000; // Minimum 30 seconds between cleanups
 const MAX_CACHE_SIZE = 1000; // Maximum number of entries in cache
-
 let lastCacheCleanup = 0;
-module.exports._lastCacheCleanup = () => lastCacheCleanup;
-module.exports._resetCacheCleanup = () => {
+/** @internal */
+export const _lastCacheCleanup = () => lastCacheCleanup;
+/** @internal */
+export const _resetCacheCleanup = () => {
     lastCacheCleanup = 0;
 };
-
-let networkInterfaces;
+export let networkInterfaces;
 try {
     networkInterfaces = os.networkInterfaces();
-} catch (_err) {
+}
+catch (_err) {
     // fails on some systems
 }
-
-module.exports.networkInterfaces = networkInterfaces;
-
 const isFamilySupported = (family, allowInternal) => {
-    const ifaces = module.exports.networkInterfaces;
-    if (!ifaces) {
-        // hope for the best
+    const addresses = Object.values(networkInterfaces || {}).flat();
+    if (!addresses.length) {
+        // hope for the best. Runtimes without an interface table (Cloudflare
+        // Workers) report an empty object rather than throwing
         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);
+    return addresses.filter(i => !i.internal || allowInternal).some(i => i.family === 'IPv' + family || i.family === family);
 };
-
 const 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) {
@@ -74,67 +59,54 @@ const resolve = (family, hostname, options, callback) => {
         return callback(null, Array.isArray(addresses) ? addresses : [].concat(addresses || []));
     });
 };
-
-const dnsCache = (module.exports.dnsCache = new Map());
-
+export const dnsCache = new Map();
 const formatDNSValue = (value, extra) => {
     if (!value) {
         return Object.assign({}, extra || {});
     }
-
     const addresses = value.addresses || [];
-
     // Select a random address from available addresses, or null if none
     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 || {}
-    );
+    return Object.assign({
+        host,
+        // Include all addresses for connection fallback support
+        _addresses: addresses
+    }, extra || {});
 };
-
-module.exports.resolveHostname = (options, callback) => {
+export const resolveHostname = (options, callback) => {
     options = options || {};
-
     if (!options.host && options.servername) {
         options.host = options.servername;
     }
-
     if (!options.host || net.isIP(options.host)) {
         // nothing to do here
         const value = {
-            addresses: [options.host],
-            servername: options.servername || false
+            addresses: [options.host]
         };
-        return callback(
-            null,
-            formatDNSValue(value, {
-                cached: false
-            })
-        );
+        return callback(null, formatDNSValue(value, {
+            servername: options.servername || false,
+            cached: false
+        }));
     }
-
+    const host = options.host;
+    // The TLS server name belongs to the connection asking, not to the host it resolves. The
+    // cache is shared by every transport of the process and keyed by host alone, so a server
+    // name stored in it would be the one of whichever transport resolved the host first, and a
+    // later transport with its own tls.servername would present and verify that name instead
+    const servername = options.servername || host;
     let cached;
     if (dnsCache.has(options.host)) {
         cached = dnsCache.get(options.host);
-
         // Lazy cleanup with time throttling
         const now = Date.now();
         if (now - lastCacheCleanup > CACHE_CLEANUP_INTERVAL) {
             lastCacheCleanup = now;
-
             // Clean up expired entries
             for (const [host, entry] of dnsCache.entries()) {
                 if (entry.expires && entry.expires < now) {
                     dnsCache.delete(host);
                 }
             }
-
             // If cache is still too large, remove oldest entries
             if (dnsCache.size > MAX_CACHE_SIZE) {
                 const toDelete = Math.floor(MAX_CACHE_SIZE * 0.1); // Remove 10% of entries
@@ -142,149 +114,117 @@ module.exports.resolveHostname = (options, callback) => {
                 keys.forEach(key => dnsCache.delete(key));
             }
         }
-
         if (!cached.expires || cached.expires >= now) {
-            return callback(
-                null,
-                formatDNSValue(cached.value, {
-                    cached: true
-                })
-            );
+            return callback(null, formatDNSValue(cached.value, {
+                servername,
+                cached: true
+            }));
         }
     }
-
     // Resolve both IPv4 and IPv6 addresses for fallback support
     let ipv4Addresses = [];
     let ipv6Addresses = [];
     let ipv4Error = null;
     let ipv6Error = null;
-
     resolve(4, options.host, options, (err, addresses) => {
         if (err) {
             ipv4Error = err;
-        } else {
+        }
+        else {
             ipv4Addresses = addresses || [];
         }
-
-        resolve(6, options.host, options, (err, addresses) => {
+        resolve(6, host, options, (err, addresses) => {
             if (err) {
                 ipv6Error = err;
-            } else {
+            }
+            else {
                 ipv6Addresses = addresses || [];
             }
-
             // Combine addresses: IPv4 first, then IPv6
             const allAddresses = ipv4Addresses.concat(ipv6Addresses);
-
             if (allAddresses.length) {
                 const value = {
-                    addresses: allAddresses,
-                    servername: options.servername || options.host
+                    addresses: allAddresses
                 };
-
-                dnsCache.set(options.host, {
+                dnsCache.set(host, {
                     value,
                     expires: Date.now() + (options.dnsTtl || DNS_TTL)
                 });
-
-                return callback(
-                    null,
-                    formatDNSValue(value, {
-                        cached: false
-                    })
-                );
+                return callback(null, formatDNSValue(value, {
+                    servername,
+                    cached: false
+                }));
             }
-
             // No addresses from resolve4/resolve6, try dns.lookup as fallback
             if (ipv4Error && ipv6Error) {
                 // Both resolvers had errors
                 if (cached) {
-                    dnsCache.set(options.host, {
+                    dnsCache.set(host, {
                         value: cached.value,
                         expires: Date.now() + (options.dnsTtl || DNS_TTL)
                     });
-
-                    return callback(
-                        null,
-                        formatDNSValue(cached.value, {
-                            cached: true,
-                            error: ipv4Error
-                        })
-                    );
+                    return callback(null, formatDNSValue(cached.value, {
+                        servername,
+                        cached: true,
+                        error: ipv4Error
+                    }));
                 }
             }
-
             try {
-                dns.lookup(options.host, { all: true }, (err, addresses) => {
+                dns.lookup(host, { all: true }, (err, addresses) => {
                     if (err) {
                         if (cached) {
-                            dnsCache.set(options.host, {
+                            dnsCache.set(host, {
                                 value: cached.value,
                                 expires: Date.now() + (options.dnsTtl || DNS_TTL)
                             });
-
-                            return callback(
-                                null,
-                                formatDNSValue(cached.value, {
-                                    cached: true,
-                                    error: err
-                                })
-                            );
+                            return callback(null, formatDNSValue(cached.value, {
+                                servername,
+                                cached: true,
+                                error: err
+                            }));
                         }
                         return callback(err);
                     }
-
                     // Get all supported addresses from dns.lookup
                     const supportedAddresses = addresses
                         ? addresses.filter(addr => isFamilySupported(addr.family)).map(addr => addr.address)
                         : [];
-
                     if (addresses && addresses.length && !supportedAddresses.length) {
                         // there are addresses but none can be used
                         console.warn(`Failed to resolve IPv${addresses[0].family} addresses with current network`);
                     }
-
                     if (!supportedAddresses.length && cached) {
                         // nothing was found, fallback to cached value
-                        return callback(
-                            null,
-                            formatDNSValue(cached.value, {
-                                cached: true
-                            })
-                        );
+                        return callback(null, formatDNSValue(cached.value, {
+                            servername,
+                            cached: true
+                        }));
                     }
-
                     const value = {
-                        addresses: supportedAddresses.length ? supportedAddresses : [options.host],
-                        servername: options.servername || options.host
+                        addresses: supportedAddresses.length ? supportedAddresses : [host]
                     };
-
-                    dnsCache.set(options.host, {
+                    dnsCache.set(host, {
                         value,
                         expires: Date.now() + (options.dnsTtl || DNS_TTL)
                     });
-
-                    return callback(
-                        null,
-                        formatDNSValue(value, {
-                            cached: false
-                        })
-                    );
+                    return callback(null, formatDNSValue(value, {
+                        servername,
+                        cached: false
+                    }));
                 });
-            } catch (lookupErr) {
+            }
+            catch (lookupErr) {
                 if (cached) {
-                    dnsCache.set(options.host, {
+                    dnsCache.set(host, {
                         value: cached.value,
                         expires: Date.now() + (options.dnsTtl || DNS_TTL)
                     });
-
-                    return callback(
-                        null,
-                        formatDNSValue(cached.value, {
-                            cached: true,
-                            error: lookupErr
-                        })
-                    );
+                    return callback(null, formatDNSValue(cached.value, {
+                        servername,
+                        cached: true,
+                        error: lookupErr
+                    }));
                 }
                 return callback(ipv4Error || ipv6Error || lookupErr);
             }
@@ -294,14 +234,13 @@ module.exports.resolveHostname = (options, callback) => {
 /**
  * Parses connection url to a structured configuration object
  *
- * @param {String} str Connection url
- * @return {Object} Configuration object
+ * @param str Connection url
+ * @return Configuration object
  */
-module.exports.parseConnectionUrl = str => {
+export const parseConnectionUrl = (str) => {
     str = str || '';
     const options = {};
     const url = urllib.parse(str, true);
-
     switch (url.protocol) {
         case 'smtp:':
             options.secure = false;
@@ -313,32 +252,25 @@ module.exports.parseConnectionUrl = str => {
             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(':');
+    if (url.username || url.password) {
         options.auth = {
-            user: auth.shift(),
-            pass: auth.join(':')
+            user: url.username || '',
+            pass: url.password || ''
         };
     }
-
     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;
@@ -347,7 +279,6 @@ module.exports.parseConnectionUrl = str => {
                 value = false;
                 break;
         }
-
         // tls is nested object
         if (key.indexOf('tls.') === 0) {
             lKey = key.substr(4);
@@ -355,50 +286,45 @@ module.exports.parseConnectionUrl = str => {
                 options.tls = {};
             }
             obj = options.tls;
-        } else if (key.indexOf('.') >= 0) {
+        }
+        else if (key.indexOf('.') >= 0) {
             // ignore nested properties besides tls
             return;
         }
-
         // `in` already keeps "__proto__" out, but only as a side effect of it being an
         // Object.prototype member. Say it, so the protection survives a change to the check
         if (!isProtoKey(lKey) && !(lKey in obj)) {
             obj[lKey] = value;
         }
     });
-
     return options;
 };
-
-module.exports._logFunc = (logger, level, defaults, data, message, ...args) => {
+/** @internal */
+export const _logFunc = (logger, level, defaults, data, message, ...args) => {
     const entry = Object.assign({}, defaults || {}, data || {});
     delete entry.level;
-
     let logLevel = level;
     if (typeof logger[logLevel] !== 'function') {
         // Provided logger does not implement this level. Fall back to a
         // lower-severity handler instead of throwing.
         logLevel = ['info', 'debug', 'log', 'trace', 'warn', 'error'].find(name => typeof logger[name] === 'function');
     }
-
     if (logLevel) {
         logger[logLevel](entry, message, ...args);
     }
 };
-
 /**
  * Returns a bunyan-compatible logger interface. Uses either provided logger or
  * creates a default console logger
  *
- * @param {Object} [options] Options object that might include 'logger' value
- * @return {Object} bunyan compatible logger
+ * @param [options] Options object that might include 'logger' value
+ * @param [defaults] Fields merged into every log entry, overridden by the fields of the entry itself
+ * @return bunyan compatible logger
  */
-module.exports.getLogger = (options, defaults) => {
+export const getLogger = (options, defaults) => {
     options = options || {};
-
     const response = {};
     const levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
-
     if (!options.logger) {
         // use vanity logger
         levels.forEach(level => {
@@ -406,58 +332,49 @@ module.exports.getLogger = (options, defaults) => {
         });
         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);
+        response[level] = (...args) => {
+            // the bunyan forms: a data object first, or the message alone
+            const data = typeof args[0] === 'string' ? undefined : args.shift();
+            _logFunc(logger, level, defaults, data, ...args);
         };
     });
-
     return response;
 };
-
 /**
  * Wrapper for creating a callback that either resolves or rejects a promise
  * based on input
  *
- * @param {Function} resolve Function to run if callback is called
- * @param {Function} reject Function to run if callback ends with an error
+ * @param resolve Function to run if callback is called
+ * @param reject Function to run if callback ends with an error
  */
-module.exports.callbackPromise = (resolve, reject) =>
-    function () {
-        const args = Array.from(arguments);
-        const err = args.shift();
-        if (err) {
-            reject(err);
-        } else {
-            resolve(...args);
-        }
-    };
-
-module.exports.parseDataURI = uri => {
+export const callbackPromise = (resolve, reject) => function (...args) {
+    const err = args.shift();
+    if (err) {
+        reject(err);
+    }
+    else {
+        resolve(...args);
+    }
+};
+export const parseDataURI = (uri) => {
     if (typeof uri !== 'string') {
         return null;
     }
-
     // Early return for non-data URIs to avoid unnecessary processing
     if (!uri.startsWith('data:')) {
         return null;
     }
-
     // Find the first comma safely - this prevents ReDoS
     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();
         // Only recognize valid encoding types to prevent manipulation
@@ -466,10 +383,8 @@ module.exports.parseDataURI = uri => {
             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('=');
@@ -482,23 +397,24 @@ module.exports.parseDataURI = uri => {
             }
         }
     }
-
     // Decode data based on encoding with proper error handling
     let bufferData;
     try {
         if (encoding === 'base64') {
             bufferData = Buffer.from(data, 'base64');
-        } else {
+        }
+        else {
             try {
                 bufferData = Buffer.from(decodeURIComponent(data));
-            } catch (_decodeError) {
+            }
+            catch (_decodeError) {
                 bufferData = Buffer.from(data);
             }
         }
-    } catch (_bufferError) {
+    }
+    catch (_bufferError) {
         bufferData = Buffer.alloc(0);
     }
-
     return {
         data: bufferData,
         encoding: encoding || null,
@@ -506,53 +422,31 @@ module.exports.parseDataURI = uri => {
         params
     };
 };
-
-/**
- * Resolves a String or a Buffer value for content value. Useful if the value
- * is a Stream or a file or an URL. If the value is a Stream, overwrites
- * the stream object with the resolved value (you can't stream a value twice).
- *
- * This is useful when you want to create a plugin that needs a content value,
- * for example the `html` or `text` value as a String or a Buffer but not as
- * a file path or an URL.
- *
- * @param {Object} data An object or an Array you want to resolve an element for
- * @param {String|Number} key Property name or an Array index
- * @param {Object} [options] Optional access policy: { disableFileAccess, disableUrlAccess }
- * @param {Function} callback Callback function with (err, value)
- */
-module.exports.resolveContent = (data, key, options, callback) => {
+export function resolveContent(data, key, options, callback) {
     // options is optional; support the legacy resolveContent(data, key, callback) signature
     if (!callback && typeof options === 'function') {
         callback = options;
         options = false;
     }
     options = options || {};
-
     let promise;
-
     if (!callback) {
         promise = new Promise((resolve, reject) => {
-            callback = module.exports.callbackPromise(resolve, reject);
+            callback = callbackPromise(resolve, reject);
         });
     }
-
     resolveContentValue(data, key, options, callback);
-
     return promise;
-};
-
+}
 function resolveContentValue(data, key, options, callback) {
     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) => {
@@ -563,75 +457,77 @@ function resolveContentValue(data, key, options, callback) {
                 // to replace the stream object with the streaming result
                 if (data[key].content) {
                     data[key].content = value;
-                } else {
+                }
+                else {
                     data[key] = value;
                 }
                 callback(null, value);
             });
-        } else if (/^data:/i.test(content.path || content.href)) {
-            const parsedDataUri = module.exports.parseDataURI(content.path || content.href);
-
+        }
+        else if (/^data:/i.test(content.path || content.href)) {
+            const parsedDataUri = parseDataURI(content.path || content.href);
             return callback(null, parsedDataUri && parsedDataUri.data ? parsedDataUri.data : Buffer.alloc(0));
-        } else if (content.href || /^https?:\/\//i.test(content.path)) {
+        }
+        else if (content.href || /^https?:\/\//i.test(content.path)) {
             // An href is always a URL, and so is a path that looks like one. Let nmfetch
             // decide whether it is fetchable, it validates the parsed URL. Testing the raw
             // string here instead would let a file: href fall through to the "return as is"
             // default below and travel on inside the resolved message.
             const url = content.href || content.path;
             if (options.disableUrlAccess) {
-                return setImmediate(() => {
+                setImmediate(() => {
                     const err = new Error('Url access rejected for ' + url);
                     err.code = errors.EURLACCESS;
                     callback(err);
                 });
+                return;
             }
             return resolveStream(nmfetch(url, { headers: content.httpHeaders, tls: content.tls }), callback);
-        } else if (content.path) {
+        }
+        else if (content.path) {
             if (options.disableFileAccess) {
-                return setImmediate(() => {
+                setImmediate(() => {
                     const err = new Error('File access rejected for ' + content.path);
                     err.code = errors.EFILEACCESS;
                     callback(err);
                 });
+                return;
             }
             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);
     }
-
     // default action, return as is
     setImmediate(() => callback(null, content));
 }
-
 /**
  * Copies properties from source objects to target objects
  */
-module.exports.assign = function (/* target, ... sources */) {
-    const args = Array.from(arguments);
+export const assign = function (...args) {
     const target = args.shift() || {};
-
     args.forEach(source => {
         Object.keys(source || {}).forEach(key => {
             if (isProtoKey(key)) {
                 return;
             }
-            if (['tls', 'auth'].includes(key) && source[key] && typeof source[key] === 'object') {
+            if (['tls', 'auth'].includes(key) &&
+                source[key] &&
+                typeof source[key] === 'object') {
                 // tls and auth are special keys that need to be enumerated separately
                 // other objects are passed as is. Enumerating is a copy of user supplied
                 // keys just like the loop above, so it gets the same treatment
-                target[key] = module.exports.copyOwnKeys(target[key] || {}, source[key]);
-            } else {
+                target[key] = copyOwnKeys(target[key] || {}, source[key]);
+            }
+            else {
                 target[key] = source[key];
             }
         });
     });
     return target;
 };
-
-module.exports.encodeXText = str => {
+export const encodeXText = (str) => {
     // ! 0x21
     // + 0x2B
     // = 0x3D
@@ -645,33 +541,30 @@ module.exports.encodeXText = str => {
         const c = buf[i];
         if (c < 0x21 || c > 0x7e || c === 0x2b || c === 0x3d) {
             result += '+' + (c < 0x10 ? '0' : '') + c.toString(16).toUpperCase();
-        } else {
+        }
+        else {
             result += String.fromCharCode(c);
         }
     }
     return result;
 };
-
 /**
  * Streams a stream value into a Buffer
  *
- * @param {Object} stream Readable stream
- * @param {Function} callback Callback function with (err, value)
+ * @param stream Readable stream
+ * @param callback Callback function with (err, value)
  */
 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) {
@@ -679,33 +572,29 @@ function resolveStream(stream, callback) {
             chunklen += chunk.length;
         }
     });
-
     stream.on('end', () => {
         if (responded) {
             return;
         }
         responded = true;
-
         let value;
-
         try {
             value = Buffer.concat(chunks, chunklen);
-        } catch (E) {
+        }
+        catch (E) {
             return callback(E);
         }
         callback(null, value);
     });
 }
-
 /**
  * Generates a bunyan-like logger that prints to console
  *
- * @returns {Object} Bunyan logger instance
+ * @returns Bunyan logger instance
  */
 function createDefaultLogger(levels) {
     const levelMaxLen = levels.reduce((max, level) => Math.max(max, level.length), 0);
     const levelNames = new Map();
-
     levels.forEach(level => {
         let levelName = level.toUpperCase();
         if (levelName.length < levelMaxLen) {
@@ -713,35 +602,30 @@ function createDefaultLogger(levels) {
         }
         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') {
+            }
+            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 => {
+        message.split(/\r?\n/).forEach((line) => {
             console.log('[%s] %s %s', 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;
 }